From 77357a954e7ae74b300e0225338c9019d1db8773 Mon Sep 17 00:00:00 2001 From: REPPL <77722411+REPPL@users.noreply.github.com> Date: Mon, 13 Jul 2026 21:22:49 +0100 Subject: [PATCH] chore(record): the ABCD sensemaking method, its principle, and itd-86/87 abcd's principles were re-deriving a method that was never written down here: the cold reading (blind specification pass), the warm ledger, and the human disposition. itd-27/42, itd-55, and now itd-86/87 had all been accumulating as siblings with no stated parent, which is why the cold reading's prohibitions (propose no fixes, rank nothing) read as arbitrary in isolation - they only make sense if the disposition step downstream is known to exist. Record the method as the parent note, and mint exactly one principle from it: recurrence-is-signal. The cold/warm split is already stated by evaluator-outside-the-loop and verifier-selects-gates-decide, and one-canonical-primitive forbids a third near-copy; recurrence was the only element of the method with no counterpart in the record. itd-86 (cold-reading surface) and itd-87 (recurrence escalation in capture) land together because they are coupled, not merely related: a blind reading re-raises old tensions by design, so pointing it at a ledger that dedupes them yields a detector fighting its own store. Also corrects a stale pointer: the skills-evaluation note cited a skills/abcd-intent-grill/ directory that the Go rebuild left unbuilt; the grill is planned work (itd-27, adr-7, itd-42) and its harvest target is those. The ACKNOWLEDGEMENTS entry crediting the cold reading to abcd's co-author is deliberately held, not forgotten - it awaits confirmation of the credit line and must land before itd-86 ships. Assisted-by: Claude:claude-opus-4-8 --- .../drafts/itd-86-cold-reading-surface.md | 56 +++++++++ ...itd-87-recurrence-escalation-in-capture.md | 54 ++++++++ .../principles/recurrence-is-signal.md | 52 ++++++++ .../2026-07-13-abcd-sensemaking-method.md | 118 ++++++++++++++++++ ...-and-first-principles-skills-evaluation.md | 24 ++-- .abcd/work/DECISIONS.md | 17 +++ 6 files changed, 313 insertions(+), 8 deletions(-) create mode 100644 .abcd/development/intents/drafts/itd-86-cold-reading-surface.md create mode 100644 .abcd/development/intents/drafts/itd-87-recurrence-escalation-in-capture.md create mode 100644 .abcd/development/principles/recurrence-is-signal.md create mode 100644 .abcd/development/research/notes/2026-07-13-abcd-sensemaking-method.md diff --git a/.abcd/development/intents/drafts/itd-86-cold-reading-surface.md b/.abcd/development/intents/drafts/itd-86-cold-reading-surface.md new file mode 100644 index 00000000..7d3fd5dd --- /dev/null +++ b/.abcd/development/intents/drafts/itd-86-cold-reading-surface.md @@ -0,0 +1,56 @@ +--- +id: itd-86 +slug: cold-reading-surface +spec_id: null +kind: null +suggested_kind: standalone +reclassification_history: [] +related_adrs: [] +prd_path: null +severity: minor +--- + +# abcd Can Read Its Own Design Documents As A Stranger Would + +## Press Release + +> **abcd gains a cold reading: a pass that reads one design document as though it had never been seen before — knowing how designs of this kind work, but knowing nothing about how this one came to be framed — and surfaces the places where the document's own constraints contradict its framing.** Every other reviewer abcd has is warm: the fidelity reviewer knows the intent, the grill knows the acceptance criteria, the docs reviewer knows the code. Warmth is what lets them check correspondence, and it is also what makes them sympathetic — they fill in the gaps the author left, because they know what the author meant. The cold reading is denied all of it. It reports tensions, names the constraint each one violates, explains why it is a tension, and then stops: no fixes, no ranking, no verdict. What to do about them is the human's call. + +> "The problem with reviewing our own briefs is that we already agree with them," said Alice, who maintains abcd's design record. "By the third read I'm not reading the document any more, I'm remembering the argument we had about it. I want a reader who doesn't know that argument happened — one that just sees a brief promising a thing on page two and quietly forbidding it on page nine, and says so without softening it into a suggestion." + +## Why This Matters + +abcd's design record is now large enough that no one comes to it cold. The brief, the principles, the intents and the ADRs cross-reference each other, and every reader arrives already knowing why things are shaped as they are. That knowledge is what makes an embedded reviewer fast — and it is exactly what makes them miss constraint divergence, because familiarity normalises the inconsistency. A reader who knows why the team framed things as they did will unconsciously smooth over what a stranger would trip on. + +This is the Specification pass of the ABCD sensemaking method (see [the method note](../../research/notes/2026-07-13-abcd-sensemaking-method.md)), and abcd currently has no surface that performs it. The gap is not "another reviewer" — abcd has four. It is that all four are warm, and the method's value comes from a reader that is structurally denied context. abcd already believes this in the abstract: [`evaluator-outside-the-loop`](../../principles/evaluator-outside-the-loop.md) isolates the evaluator from the gate it judges. The cold reading extends that isolation from *what the evaluator may edit* to *what the evaluator may know*. + +## What's In Scope + +- A surface that takes exactly one target document and produces candidate detections against the constraints visible in that document alone. +- The blindness contract, which is the substance of the intent and not a stylistic preference: the reading carries no project context, consults no prior reading, and is given no access to the ledger of what was previously dispositioned. +- The detection shape — **tension**, **constraint in play** (explicit or implicit, and what implies it), **why it is a tension** — with no fourth element proposing a remedy. +- The three prohibitions that define the output: propose no fixes, rank nothing (detections come in document order), pre-judge no intentionality (no "this may be deliberate, but…"). +- Re-raising a previously surfaced tension that is still present in the document, per [`recurrence-is-signal`](../../principles/recurrence-is-signal.md) — the cold reading is the detector that principle is written for. +- A settled-enough check: a visibly mid-draft target (placeholders, TODOs, half-specified sections) is flagged in one line as likely to yield incompleteness rather than genuine constraint divergence, with the pass offered anyway. + +## What's Out of Scope + +- **The warm ledger and the disposition step.** These are operated by a human against a record the cold reading is deliberately kept blind to. This intent must not disposition, assign priority, or assess closure — doing so from inside the detector collapses the separation the method depends on. +- **Duplicating the grill (itd-27 / itd-42) or the foundations auditor (itd-55).** The grill interrogates acceptance criteria interactively; the auditor asks where a justification terminates; the cold reading asks whether the framing contradicts the document's own constraints. Three different questions, and the third is the only blind one. +- **Reviewing code.** The target is a design document. `ruthless-reviewer` owns diffs. +- **Auto-firing on a lifecycle transition.** Whether a cold reading is required before an intent is promoted is a policy question for later, not part of establishing the surface. + +## Acceptance Criteria + +> _Given-When-Then per the itd-1 discipline._ + +- **Given** a design document containing a constraint stated in one section and breached by the framing in another, **when** the cold reading runs, **then** it reports that divergence as a detection carrying the tension, the constraint in play, and why it is a tension — and carrying no proposed remedy. +- **Given** a document whose surrounding project context would explain away a tension, **when** the cold reading runs with that context available in the environment, **then** the detection is still raised — the context does not suppress it. +- **Given** a tension that was surfaced by a previous cold reading and is still present in the document, **when** the cold reading runs again, **then** it is re-raised rather than suppressed as already-seen. +- **Given** a document with no constraint divergence, **when** the cold reading runs, **then** it reports the detections it has (possibly none) and adds the single closing line "No divergence beyond the detections above" — and does **not** declare the document closed or approved, since closure is a human judgement made against the ledger. +- **Given** a visibly mid-draft document, **when** the cold reading runs, **then** it says so in one line and flags that detections may be dominated by incompleteness, before proceeding. + +## Open Questions + +- **Is the blindness enforceable, or only instructed?** A host-delegated reading is instructed not to use context it may already hold in its window. That is a weaker guarantee than a reader that structurally cannot see the ledger. Whether the surface must run in a context-isolated subagent to make the contract real — rather than merely asked for — is the central design question and should be settled before build. +- The two disposition axes the method names (frame-location, MoSCoW priority) belong to the ledger, not here — but the detection shape may need to carry enough for a human to assign them later. diff --git a/.abcd/development/intents/drafts/itd-87-recurrence-escalation-in-capture.md b/.abcd/development/intents/drafts/itd-87-recurrence-escalation-in-capture.md new file mode 100644 index 00000000..c4f48a54 --- /dev/null +++ b/.abcd/development/intents/drafts/itd-87-recurrence-escalation-in-capture.md @@ -0,0 +1,54 @@ +--- +id: itd-87 +slug: recurrence-escalation-in-capture +spec_id: null +kind: null +suggested_kind: standalone +reclassification_history: [] +related_adrs: [] +prd_path: null +severity: minor +--- + +# A Finding That Comes Back After You Closed It Tells You Something, And abcd Stops Throwing It Away + +## Press Release + +> **abcd's capture ledger learns the difference between a duplicate and a recurrence.** When a finding arrives that matches one already dispositioned — resolved or wontfixed — the ledger no longer quietly folds it into the closed entry. It escalates: a new entry, citing the closed one, saying plainly that the condition which produced the original finding is still present. A closure carries an implicit claim that the thing was dealt with, and a recurrence is the cheapest available evidence that the claim is false. Today that evidence is exactly what deduplication destroys. + +> "I closed an issue as fixed, and three weeks later the same thing surfaced again," said Bob, who works the ledger. "The tool told me it was a duplicate of the one I'd already closed — which is true, and completely the wrong thing to say. It wasn't a duplicate. It was the fix not holding. I want the ledger to tell me my closure was wrong, not to reassure me that it already knows." + +## Why This Matters + +A ledger's instinct is to dedupe, because a ledger's usual enemy is noise. But dedupe applied to a *dispositioned* entry is not noise control — it is evidence destruction. It converts "we were wrong to close this" into "we already know about this", and the second sentence is a lie the first would have caught. The failure mode is a ledger that grows quieter as it grows less accurate: the more confidently things are closed, the less able the ledger is to report that closing them was a mistake. + +This is the one element of the ABCD sensemaking method with no counterpart anywhere in abcd's record (see [the method note](../../research/notes/2026-07-13-abcd-sensemaking-method.md)). The method states it as a prohibition on the reader — be deliberately amnesiac, re-raise tensions you have surfaced before, because one that keeps re-surfacing after it was supposedly resolved is the signal that the resolution was false. The principle [`recurrence-is-signal`](../../principles/recurrence-is-signal.md) states it as a rule. This intent is the mechanism: the principle's promotion from convention to tool. + +It also unblocks itd-86. A blind cold reading re-raises old tensions *by design*; pointed at a ledger that dedupes them, it produces a detector fighting its own store. The escalation behaviour is what makes the re-raising useful rather than noisy, which is why the two are recorded together. + +## What's In Scope + +- Matching an incoming capture against **dispositioned** entries (`resolve`, `wontfix`), not merely against open ones. +- On a match, escalating rather than deduping: a new entry that cites the closed one and states that the condition persists. +- Distinguishing the two recurrence kinds, because they are different facts: a recurrence after `resolve` says the fix did not hold or was never made; a recurrence after `wontfix` says the accepted cost is still being paid. +- Keeping the human as the gate: an escalation is a claim that the closure is in question, never an automatic reopening. "Still wontfix, and here is why" must remain available — and is a stronger record than the original wontfix, having been made against evidence of persistence. + +## What's Out of Scope + +- **Automatic reopening or reversal of a disposition.** Per [`verifier-selects-gates-decide`](../../principles/verifier-selects-gates-decide.md), the escalation is a proposal. +- **Deduplication of *open* entries.** Unchanged; two live reports of the same open thing are a duplicate and should be treated as one. +- **Making the matcher clever.** A fuzzy matcher that invents recurrences is worse than no matcher, since it manufactures false evidence against closures the human made correctly. The matching rule should be conservative and explicable, and its false-recurrence rate is the thing to watch. + +## Acceptance Criteria + +> _Given-When-Then per the itd-1 discipline._ + +- **Given** a capture matching an entry previously dispositioned `resolve`, **when** it is filed, **then** a new entry is created citing the resolved one and marked as a recurrence — and the capture is **not** folded into the closed entry. +- **Given** a capture matching an entry previously dispositioned `wontfix`, **when** it is filed, **then** it is escalated as a recurrence distinguishable from the `resolve` case, since the two carry different meanings. +- **Given** a capture matching an entry that is still **open**, **when** it is filed, **then** it is deduplicated as today — the new behaviour applies only to dispositioned entries. +- **Given** an escalated recurrence, **when** the human dispositions it `wontfix` again, **then** that is accepted and recorded against the evidence of persistence — the ledger never reopens or reverses a disposition on its own. + +## Open Questions + +- **What counts as "matching"?** The conservative rule (exact same detector plus same location) under-reports; anything looser risks false recurrences. This is the crux of the build and should be settled with a corpus of real closures before implementation, per the acceptance-corpus discipline. +- Whether an escalation should surface at capture time, at `abcd audit` time, or both. diff --git a/.abcd/development/principles/recurrence-is-signal.md b/.abcd/development/principles/recurrence-is-signal.md new file mode 100644 index 00000000..09dc0981 --- /dev/null +++ b/.abcd/development/principles/recurrence-is-signal.md @@ -0,0 +1,52 @@ +# Recurrence is signal + +**The rule.** A finding that reappears after it was dispositioned is evidence +about the disposition, not a duplicate of the finding. A detector re-raises a +tension it has surfaced before whenever that tension is still present, and the +ledger escalates the recurrence rather than folding it back into the closed +entry. Suppressing a repeat because "we covered this before" destroys the only +signal that tells you the resolution was weak or false. + +**Why.** A closed finding carries an implicit claim: *this was dealt with.* The +cheapest available test of that claim is whether the condition that produced the +finding is still there. If a blind detector — one that cannot see the ledger and +therefore cannot be influenced by the fact of closure — surfaces the same tension +again, the closure is contradicted by evidence, and that contradiction is more +informative than the original detection was. The failure mode this guards against +is a ledger that grows quieter as it grows less accurate: every dedupe silently +converts "we were wrong to close this" into "we already know about this". The +ABCD sensemaking method makes the same point from the detector side and states it +as a prohibition on the reader — *be deliberately amnesiac; re-raise previously +surfaced tensions* — because a tension that keeps re-surfacing after it was +supposedly resolved is the signal that the resolution was false +([the method](../research/notes/2026-07-13-abcd-sensemaking-method.md)). + +**Bounds.** + +- **Recurrence is not reopening.** The escalation is a claim that the closure is + in question, not an automatic reversal of it. The human's disposition remains + the gate — a recurrence can itself be dispositioned "still wontfix, and here is + why", which is a *stronger* record than the original wontfix, because it was + made against evidence of persistence. +- **This is not a licence to re-raise noise.** The rule earns its keep only where + the detector is deterministic or blind. A detector that re-raises because it + forgot, rather than because the condition persists, is producing duplicates and + the rule does not protect it. +- **A recurrence after a `resolve` is a different fact from a recurrence after a + `wontfix`.** The first says the fix did not hold (or was never made); the + second says the accepted cost is still being paid. Both are worth surfacing; + they are not the same signal and should not be collapsed into one. +- Composes with [`verifier-selects-gates-decide`](verifier-selects-gates-decide.md): + the escalation is a proposal. It composes with + [`evaluator-outside-the-loop`](evaluator-outside-the-loop.md) in the strong + form — a detector that *can* read the ledger it feeds will learn to fall silent + about closed entries, which is precisely the gaming this rule exists to prevent. + +**Promotion.** The MVP is a convention: when a finding recurs, file it as a new +finding citing the closed one, rather than reopening or deduping — the citation is +the escalation. The tool is the ledger doing this itself: `abcd capture` matching +an incoming finding against dispositioned entries and escalating on a hit instead +of deduping, which is [itd-87](../intents/drafts/itd-87-recurrence-escalation-in-capture.md). +As a maintained detector it is demotable to advisory if its matching produces +false recurrences, and archivable to regression-only if closures stop recurring at +all — the saturation case, which is the outcome the rule wants. diff --git a/.abcd/development/research/notes/2026-07-13-abcd-sensemaking-method.md b/.abcd/development/research/notes/2026-07-13-abcd-sensemaking-method.md new file mode 100644 index 00000000..1abb1ba2 --- /dev/null +++ b/.abcd/development/research/notes/2026-07-13-abcd-sensemaking-method.md @@ -0,0 +1,118 @@ +# The ABCD sensemaking method — cold reading, warm ledger, disposition + +**Status:** durable record of the method abcd tools. Recorded 2026-07-13. + +abcd's principles have been converging on a method that was never written down in +this record. The method exists; it was developed alongside abcd, and one of its +passes — the cold reading — exists as a working skill outside this repo. This note +is the parent the record has been missing: it states the method, maps it onto the +principles that already restate parts of it, and names which intents implement +which pass. + +Without this note, each pass gets rediscovered piecemeal and its rules look +arbitrary. A detector that refuses to propose fixes reads as an unhelpful detector +unless you know a disposition step exists downstream to do that work. + +--- + +## The method + +Three parts, and the separation between them is the whole point. + +### 1. The cold reading — the blind specification pass + +A reader with broad knowledge of how designs of this kind work, and **zero +investment in how this particular design came to be framed**, reads a single +document against the constraints visible *in that document* and surfaces +**candidate detections**: places where the document's own stated or implied +constraints are inconsistent with its framing. + +Its value comes from what it refuses to do: + +- **Carries no project context.** Background about the wider programme, prior + decisions, or why the design is shaped as it is, is set aside — even when known. + An embedded reader's sympathy smooths over exactly the inconsistencies that + familiarity has normalised. +- **Remembers no prior readings.** Deliberately amnesiac; re-raises tensions it + surfaced before if they are still present in the document. +- **Proposes no fixes.** A detection presented with its solution attached has + already been collapsed into a resolution and can no longer be *held*. +- **Ranks nothing.** Prioritisation is a meta-level judgement made against the + ledger, on axes the cold reading cannot see. +- **Does not pre-judge intentionality.** No "this may be intentional, but…". A + tension that turns out to be intentional is not a false positive — surfacing it + forces the intention to be stated, which is the value. + +Each detection carries exactly three things: the **tension**, the **constraint in +play** (explicit or implicit, and what implies it), and **why it is a tension**. +No fourth element. + +### 2. The warm ledger — the accumulated record + +The detections, their dispositions, and the history of both. It is warm precisely +because it carries everything the cold reading is denied: what was decided before, +what was accepted as an intentional constraint, what is still open. The cold +reading never sees it. **This is the separation that makes the method work.** + +### 3. The disposition — the human judgement + +A human takes each candidate detection and dispositions it: **accept**, **reject**, +or **hold** — that last one being the load-bearing option, and the one a +fix-proposing reviewer destroys. A tension can be real and not yet articulable; +holding it keeps it alive without forcing a premature resolution. + +--- + +## What this method already is, inside abcd + +The convergence is not a coincidence — it is the record re-deriving the method from +the other direction, one principle at a time. + +| Method element | Where abcd already states it | +|---|---| +| Detector is denied the context that would make it sympathetic | [`evaluator-outside-the-loop`](../../principles/evaluator-outside-the-loop.md) — but abcd's version isolates the evaluator *structurally* (it cannot edit its own gate), not *epistemically* (it must not know why the design is shaped as it is). The method's cut is stronger. | +| A detection is a proposal; the human's disposition is the gate | [`verifier-selects-gates-decide`](../../principles/verifier-selects-gates-decide.md) — an exact restatement, arrived at independently. | +| A recurring detection is evidence the resolution was false | **Nothing.** This is the one element with no counterpart in the record. Now [`recurrence-is-signal`](../../principles/recurrence-is-signal.md). | +| The warm ledger | The capture ledger (`iss-N`) is the warm ledger's tooled form — detections land, a human dispositions them (`resolve` / `wontfix`). It is missing the recurrence behaviour (see itd-87). | + +The deliberate omission: **no new principle was minted for the cold/warm split.** +It is already covered by the two principles above, and `one-canonical-primitive` +forbids a third near-copy. Only the genuinely absent element became a principle. + +## Which intents implement which pass + +- **itd-27 / itd-42** (grill; ADR-0007) — interactive challenge of acceptance + criteria. *Planned, not built.* +- **itd-55** (foundations auditor) — audits where a claim's justification + terminates. *Draft.* +- **itd-86** (cold-reading surface) — the blind detection pass. *Draft.* +- **itd-87** (recurrence escalation in capture) — makes the ledger warm in the + sense the method requires. *Draft.* + +These four have been accumulating as siblings with no stated parent. This note is +the parent. + +--- + +## Provenance and attribution + +The cold reading was developed by abcd's co-author in support of abcd. The +`ACKNOWLEDGEMENTS.md` entry is **deliberately deferred, not forgotten** — it is +held pending confirmation of how they wish to be credited, and must land before +itd-86 ships. Recording this openly rather than silently, per +[`loud-staging`](../../principles/loud-staging.md). + +Its sibling skills (`socratic-grill`, `first-principles-analysis`) were evaluated +separately in +[`socratic-and-first-principles-skills-evaluation.md`](socratic-and-first-principles-skills-evaluation.md); +that note's dispositions stand. + +## Scope of this note + +This records the method as it is practised. The cold reading's own text is the +source for part 1; parts 2 and 3 are stated at the level the cold reading's scope +boundary implies them, since they are operated by a human at the meta-level. Where +this note describes the ledger's two disposition axes (frame-location and MoSCoW +priority) it is naming them, not specifying them — a full specification of the +warm ledger and the disposition step is **not** in this note and is not implied by +it. diff --git a/.abcd/development/research/notes/socratic-and-first-principles-skills-evaluation.md b/.abcd/development/research/notes/socratic-and-first-principles-skills-evaluation.md index f6627634..8c820920 100644 --- a/.abcd/development/research/notes/socratic-and-first-principles-skills-evaluation.md +++ b/.abcd/development/research/notes/socratic-and-first-principles-skills-evaluation.md @@ -16,14 +16,22 @@ justification), three temperature modes (`explore` / `challenge` / apply to prose or to architecture. Output: assumption inventory, contradictions, robustness failures, unanswered questions, a forcing-function verdict. -**abcd already has this, built further:** `skills/abcd-intent-grill/` is a -two-phase Socratic challenger (interactive one-question loop, 12-question cap, -EARS rewrites, Toulmin tagging, exit ramps, glossary/lite tiers, Phase-2 PRD -synthesis) — itself adapted from `mattpocock/skills` (`/grill-me`, -`/grill-with-docs`), credited in its ACKNOWLEDGEMENTS. So socratic-grill is a -sibling of something abcd built deeper. Importing it whole would collide with -abcd-intent-grill and violate the one-canonical-surface-per-concept rule -(the abstraction-layer boundary). +**abcd already has this, designed further:** the grill is a two-phase Socratic +challenger (interactive one-question loop, 12-question cap, EARS rewrites, Toulmin +tagging, exit ramps, glossary/lite tiers, Phase-2 PRD synthesis) — itself adapted +from `mattpocock/skills` (`/grill-me`, `/grill-with-docs`). So socratic-grill is a +sibling of something abcd specified deeper. Importing it whole would collide with +the grill and violate the one-canonical-surface-per-concept rule (the +abstraction-layer boundary). + +> **Pointer corrected 2026-07-13.** This note originally cited a +> `skills/abcd-intent-grill/` directory and its ACKNOWLEDGEMENTS as existing. +> They do not exist in the tree: the Go rebuild left the grill as *planned, +> unbuilt* work — [itd-27](../../intents/planned/itd-27-grill-skill-and-glossary.md), +> [adr-7](../../decisions/adrs/0007-grill-skill-and-glossary.md), extended by +> [itd-42](../../intents/planned/itd-42-coherence-aware-grill.md). The harvest +> disposition below stands; its target is itd-27/itd-42, and the mattpocock +> attribution is owed when the grill is built, not before. **What socratic-grill does better (the harvest):** 1. **Domain-agnostic targeting.** abcd-intent-grill only grills `itd-N` intents. diff --git a/.abcd/work/DECISIONS.md b/.abcd/work/DECISIONS.md index 4ab7b4e0..d7ef380c 100644 --- a/.abcd/work/DECISIONS.md +++ b/.abcd/work/DECISIONS.md @@ -370,3 +370,20 @@ parallel-agent merge contention bites. the serializer seam is shaped for SARIF but no SARIF is emitted yet, and the convention is to credit a pattern in the change that lands it, never ahead. Add the SARIF entry when the --format sarif serializer ships. + +- 2026-07-13 (sensemaking method): recorded the ABCD method (cold reading / warm + ledger / disposition) as a research note — the parent that itd-27, itd-42, + itd-55, itd-86 and itd-87 had all been accumulating under without one. Minted + exactly ONE principle (recurrence-is-signal) rather than one per method element: + the cold/warm split is already stated by evaluator-outside-the-loop and + verifier-selects-gates-decide, and one-canonical-primitive forbids a third + near-copy. Recurrence was the only element with no counterpart in the record. + REJECTED minting a `read-it-cold` principle for the same reason. +- 2026-07-13 (itd-86/87): recorded the two intents TOGETHER because they are + coupled, not merely related — a blind cold reading re-raises old tensions by + design, so pointing it at a ledger that dedupes them yields a detector fighting + its own store. itd-87 is the precondition that makes itd-86's re-raising useful. +- 2026-07-13 (attribution): DEFERRED the ACKNOWLEDGEMENTS entry crediting the cold + reading to abcd's co-author, pending confirmation of how they wish to be + credited. Held loudly (stated in the method note), not silently; it must land + before itd-86 ships. Do NOT guess the credit line.