Open questions — the answered

The questions and docket rows of Open questions that are answered or resolved, moved here whole, byte for byte, on 2026-11-14, each with one line under it naming the rule or commit that answered it; a row answered only in part is kept on that page with the part still open.

Authored questions

Replace the prose Lineage with a ledger and a decision log

Status: landed 2026-08-27. Agreed the same day with the bar tightened by the author — change history is for huge directional changes; everything else goes into the detailed commits — piloted on Login, then applied to all fifty-two patterns: Ledger grammar and --census in the linter (check R, gating, with a missing Ledger a finding), Ledgers for every pattern (the fifteen partially resolved ones from their gate verdicts and routed rosters, the thirty-seven grounded ones with open: none), Decisions where a directional turn exists (twenty-one patterns), spec-format.md / pressure-testing.md / contributing.md / AGENTS.md / execution-contract.md rewritten to the new sections, and the fifty-two Lineages deleted in one closing commit. Kept here as the record of the case.

The case. The corpus carries 2.1M characters of per-pattern history — 33% of everything, 49% of the size of the specifications themselves, and on two patterns more than the specification. Measured by shape, 37% of it is finding bullets carrying prescribed fixes, which a future round genuinely needs; 63% is round-by-round narrative, which decays fast and is duplicated by the commit messages that landed the same rounds. That history is also, silently, the corpus’s health ledger — the place you count open findings from — and prose is the wrong medium for a ledger. On 2026-08-27 that broke three ways in one day: the roadmap’s aggregate was stale (it said seven patterns; there were fifteen), five patterns’ Status lines contradicted their own Lineage (two of them created by the rounds that closed the findings), and a census by machine returned 15 or 112 depending on the regex, because closures are recorded inline in some patterns and in later entries in others and the word open appears inside closed findings’ text. It took a full read of fifteen patterns to produce a number, and the number was 46.

The history is doing three jobs in one register, and only one of them justifies the cost.

Job Needed? Right medium Today
Ledger — what is open now, per pattern yes, and it must be countable a structured block with one place to update prose, scattered, contradictory
Decisions — why a load-bearing choice was made, what was ruled out yes — this is the history that checks decisions a short dated list, one screen per pattern interleaved with narrative, unfindable
Narrative — what happened in round N no git log, which already has it, with the commit message 63% of the volume, in the spec file

The proposal. ## Status and the prose Lineage are replaced by two sections, and the narrative dies.

1. ## Ledger — the countable SSOT for a pattern’s health. A fixed line grammar the linter parses, not free prose:

## Ledger

status: partially resolved
formal: verified — login.tla + 1 twin, 2026-06-03
last gate: 2026-08-26 — fresh reader — 5 foundational, all since closed

open:
- 2026-08-27-a · foundational · Action wiring, cascade step 4 · `failures` is consumed by the completion event and by check 3 and initialized nowhere → initialize at step 4; increment on 5b's failure arm
- 2026-08-27-b · foundational · Generation acceptance check 3 · joins per-session events on `initiation_event_id`, which none of the three per-session cascade events carries → add it to their payloads

Five fields per line — id, class, where, defect, fix — with → separating defect from fix. Ids are date-based, not gate-based, so a finding does not need to know which Final Critique it came from. When a finding closes, its line is deleted. If the closure carried a decision, the decision goes in section 2; the fact that it was found and closed is in git. Closed findings do not accumulate, which is the single largest volume win and the thing that makes the block stay one screen. The linter derives what it can and refuses contradictions by construction: status: grounded requires zero open foundational; every open line has five fields; and the corpus census becomes python3 lint.py --census instead of a day’s reading.

2. ## Decisions — directional changes only. Not every load-bearing choice: the turns a future reader must know the pattern took — a change to what it promises, to how it attributes, to what it composes. Three fields, no narrative:

- **2026-08-26 — Every Login event is composition-attributed.** *Chose:* attest under `application_actor_ref`, human parties in `data`. *Over:* attesting under the principal's own credential. *Because:* Login's callers are end principals whose material is the thing under test, not registry actors — and a failed login has no valid credential to attest with.

The bar is directional, and it is high on purpose. An implementation choice — a sandwich read, a completion event, a bound stated — is not a direction; it is in the commit. A classification detail is not a direction. A gate’s roster is not a direction. The test is whether the pattern would be a different pattern had it gone the other way. A mature pattern has two or three entries, not nine.

Which makes the commit message load-bearing, and that should be said out loud. Every rationale that used to sit in the Lineage now sits in the commit that made the change, and git log -- <file> is the per-pattern index of it. The corpus’s rule stays — never commit; propose the message in chat — but the message is no longer a courtesy summary. A commit that changes a spec carries the why in its message; the spec carries only the what, and for directional changes, the why. A round whose commit message would not let a future reader reconstruct its reasoning has not finished.

3. Everything else is deleted, with a one-line pointer: History before 2026-08-28 is in git log -- <file>. Round narratives that carry a methodology lesson already go to discoveries.md; that practice continues. Gate provenance — who cleared what, when — collapses to the last gate: line, since a pattern’s health is its current state, not its record of past states.

Pilot: Login, landed. Its 51K characters of history reduce to a ledger of two open lines and two decisions. A first draft had nine; against the directional bar seven of them were implementation choices whose reasoning belongs in their commits — the formal model’s presence (provenance, now the Ledger’s formal: line), the sandwich read, the union-defined cascade set, derived expiry (the constituent’s choice, not this pattern’s), the truth-bearing window classification, the completion event, the tier-0 bound. The two that survive change what the pattern is:

  • 2026-08-26 — Every Login event is composition-attributed. Chose: attest under application_actor_ref, human parties in data. Over: attesting under the principal’s own credential. Because: Login’s callers are end principals whose material is the thing under test, not registry actors — and a failed login has no valid credential to attest with.
  • 2026-08-26 — Invariant 2 promises less than it did. Chose: cascade completeness only for verifies that committed after the revocation, with the in-flight window named and a second cascade prescribed. Over: single-cascade sufficiency. Because: a login whose verify committed before the revocation can land its session after the snapshot, and no single cascade can see it.

Two decisions, under 1K characters. The other 50K were narrative or implementation rationale, and every one of those rounds has a commit message saying the same thing — which is where it now lives.

What the pass touches beyond the patterns. spec-format.md and the section titled Where the journey gets recorded in pressure-testing.md mandate the current Lineage and change with it; the linter’s Status-grammar checks (G, H, I) are replaced by the Ledger grammar; roadmap.md’s hand-maintained tallies are replaced by the census command’s output. The operating rule from 2026-08-27 — a round that closes a finding must close it in every place the pattern claims it is open — becomes unnecessary, because there is one place.

Sequencing, so nothing is lost. Pilot on Login and one grounded pattern to prove both shapes. Land the linter grammar and --census. Then a mechanical pass: the fifteen partially resolved patterns’ ledgers are already written, in the census; the thirty-seven grounded patterns’ ledgers are trivial (no open lines); the decision logs are the judgment work, roughly one pattern per short round or batched with review. Delete the Lineages last, in one commit, so git log has a single line to point at.

Answered: landed 2026-08-27, as the entry says: the Ledger grammar and --census in the linter, a Ledger in every pattern, Decisions where a directional turn exists, and the prose Lineages deleted in one commit.

Taxonomy axes

Current pattern categories (productivity, temporal, resource-lifecycle, compliance, messaging, workflow, healthcare) mix conceptual axes — healthcare is domain-scoped while the others are concept-scoped; compliance mixes pure-compliance-infrastructure atoms with atoms that happen to be regulated. The right axial split will be forced by content as the catalog grows past the size where preemptive cuts are reasonable; restructuring earlier would relocate the same confusion under different labels. The workflow/ sub-question — whether one atom justifies the category — is resolved (2026-06-04): the category now holds two grounded atoms, Approval Step (the fixed-state pole — states fixed by the atom) and Workflow / State Machine (atom #9, the general-declared pole — states declared by the deployment), so it stands on present catalog evidence rather than on a planned atom. The broader axial split question across all categories is independently open. See the section titled Atoms are stored flat; classification is derived in spec-format.md, where the ruling lives, and the section titled Taxonomy question in roadmap.md for the parallel ROADMAP framing.

Status (2026-06-08): RESOLVED — executed. The usage-derived taxonomy (atoms/TAXONOMY.md) landed: atoms are stored flat (atoms/<name>.md), cross-cutting classification (regulated / security / standards) is derived from the composition graph as overlays, and domain is the one intrinsic, EOS-gated axis. This dissolves the mixed-axes problem — there is no longer one folder per atom to mis-assign. See the 2026-06-08 entry in discoveries.md.

Answered: resolved 2026-06-08, as the entry says: atoms are stored flat and classification is derived (spec-format.md, the section titled Atoms are stored flat; classification is derived; atoms/TAXONOMY.md).

Regulation as folder vs. attribute

The former compliance/ folder conflated two things: atoms whose primary domain is compliance infrastructure (Actor Identity, Retention Window, Tamper Evidence — these have no meaningful non-regulated use case), and atoms that belong to other domains but carry a heavy regulated surface (Soft Delete is resource-lifecycle by nature; Medication Order and Clinical Observation are healthcare; Legal Hold could reasonably be resource-lifecycle or temporal). As the library grows, “regulation” may belong as a frontmatter attribute — regulated: true, or a standards: [GDPR, HIPAA, FRCP] field — rather than a folder that atoms are placed in by consequence rather than by domain. The practical implication: the compliance/ folder may eventually narrow to pure compliance infrastructure primitives, while regulated atoms in other domains carry their regulatory surface as metadata. This restructuring will cause significant tree churn and cross-reference updates across every regulated atom’s Composition notes; it should be executed as a single discrete refactor pass once the content forces the decision, not incrementally. Deferred until the catalog is large enough to make the right cut obvious.

Status (2026-06-08): RESOLVED — executed. regulated / standards / security are now derived from the composition graph (never a folder, never a stored attribute); the move landed flat storage plus generated browse-by-overlay views. The live sub-questions carry forward in atoms/TAXONOMY.md: uncomposed atoms, and the regulated-overlay stewardship obligation that is intrinsic to compliance-infrastructure atoms even when derived classification says otherwise (e.g. selective-disclosure, which the generated view should lint for the overlay sections separately from classification).

Answered: resolved 2026-06-08, as the entry says: regulated, standards and security are derived from the composition graph, never a folder or a stored attribute; the live sub-questions carry forward in atoms/TAXONOMY.md.

Substrate-composing overlay and reverse-leverage view (added 2026-06-12)

A composition that names another composition in its ## Composes (a “super” / substrate composition) is a structural fact derivable straight from the composition graph — does Composes reference ≥1 composition? — exactly like the regulated / security overlays the usage-derived taxonomy already derives. Today it is legible only by reading each spec (a 2026-06-12 hand count: 14 of 24 grounded compositions are substrate-composing; 13 build on Audit Trail, Data Subject Rights Fulfillment is two layers deep, Privileged Access Provisioning composes two compositions at once). It should be a derived overlay in tools/taxonomy/, never a hand-applied tag — a hand-maintained one would drift like a count snapshot. Inverting the same edge yields the reverse-leverage view — “Audit Trail: composed by 13” — which surfaces the reuse leverage a flat pattern count hides (and guards the count against being misread as independent-concept breadth). Open — to generate; trivial once the taxonomy generator gains a composition→composition edge pass.

Status (2026-07-06): RESOLVED — executed. tools/taxonomy/generate_graph.py parses the composition→composition edges (Composes-section constituent list items only — prose mentions and deliberate non-compositions do not count as edges) and emits the reverse-leverage view as the generated graph.md page (atom fan-in and substrate fan-in tables, the substrate spine as a Mermaid diagram, the full graph) plus per-pattern card data (_data/patterns.json) rendered onto every pattern page at Jekyll build time — the canonical files untouched. The derived numbers confirmed the 2026-06-12 hand count exactly: Audit Trail substrate-of-13, the two-layer chain, the dual-substrate case. If a second consumer of the substrate edge appears, the parse graduates from generate_graph.py into reverse_index.py per the note in its header.

Answered: resolved 2026-07-06, as the entry says: tools/taxonomy/generate_graph.py parses the composition-to-composition edges and emits graph.md and _data/patterns.json.

Status-line grammar and the roadmap status mirror (added 2026-06-11)

Two coupled problems surfaced by the 2026-06-11 root-doc scan. First, there is no canonical status grammar. The corpus carries at least six shapes: `grounded` with a parenthetical, a Tier-1 gloss inside the backticks (Soft Delete), grounded on Final Critique N with and without an em-dash date, qualifier statuses (grounded — formal coverage of Invariant 4 pending), and — in two compositions (Session-Gated Authorization, External Onboarding) — Status carried as a top-of-file **Status:** line instead of the ## Status section spec-format.md requires, a canonical-shape deviation by that document’s own rule. Second, roadmap.md mirrors ~50 status cells by hand with no defined semantics and no mechanical check — the 2026-06-11 scan found six rows stale (qualifiers missing on Forensic Recovery/Chain of Custody; markers and dates behind on Multi-Party Approval, Login, Session-Gated Authorization, External Onboarding, Attributed Permissions Admin) plus a duplicated row and a constituent-list mismatch, all while the linter scanned clean the same day. The linter today is pre-alpha, proof-of-concept grade: six high-precision checks, wired to no gate, and the status-mirror class is unwritable against six grammars.

The dependency chain to close it: (1) pin one status grammar in spec-format.md (one marker form, one date semantic — the latest complete round, per the entry Status line format in pressure-testing.md — and ## Status as the only placement); (2) migrate the corpus’s Status lines to it in one discrete pass; (3) add the status-mirror linter check (pattern Status line ⇔ roadmap row) plus a table-duplicate check — both ~20 lines once the grammar exists; (4) wire the linter to an enforcement point — done 2026-06-11: the lint gate runs in continuous integration (.github/workflows/lint.yml), so the checks from step 3 enforce on arrival. Steps 1–2 are a real review pass with touch implications; until they land, roadmap rows are corrected opportunistically (the 2026-06-11 note in the roadmap marks the verified-vs-unverified boundary). Sub-item (added 2026-06-11, guided-tool design review F3): the token taxonomy is as unpinned as the grammar was — unresolved vs partially resolved has no stated boundary anywhere (the entry Status line format in pressure-testing.md points at “the taxonomy above,” which defines none); pin the boundary alongside step (1). The guided tool meanwhile carries its own local mapping (unacknowledged findings → unresolved; resolved-or-carried → partially resolved). Open — steps 1–3 remain; sequencing decided, execution unscheduled.

Answered: closed by Scott’s 2026-11-13 ruling that a status is todo, doing or done. The status line is the first line of ## Status and starts with one backticked token, todo, doing or done — YYYY-MM-DD (pressure-testing.md, the section titled Status line format), held by the linter’s G-status-grammar check; the boundary between unresolved and partially resolved is gone with the tokens, and the roadmap prints each pattern’s state instead of mirroring it.

GRACE lang, two of the three questions the self-hosting read left open

Who arbitrates admission — resolved 2026-09-11. The maintainer, the human in charge of the corpus, decides every admission under Principle 2 (GRACE-lang.md Principle 8); the council advises and cannot admit, and is constituted in the section titled The language council in governance.md. Whether a flag count over a threshold ever becomes a checkable trigger for the maintainer’s decision stays with the watch list.

Answered: the maintainer decides every admission under Principle 2 (GRACE-lang.md, Principle 8); the council advises and is constituted in governance.md. Resolved 2026-09-11, as the paragraph says.

Whether the parser exists. It does not. A forty-line scan has run over the grammar and Recoverable Invocation; the parser reads the corpus after the rewrite (the migration plan). The council’s findings 1 through 4 on v0.29 are the output the parser’s first run should reproduce, and are its first test corpus.

Answered: the parser exists: tools/grace/ir.py reads every spec in atoms/ and compositions/ into the derived IR (tools/grace/README.md, the section titled The IR; Scott, 2026-10-28), and python3 tools/grace/ir.py --check reads the corpus clean.

The classes the migration was accumulating: rows answered

Class Count What it is What would decide it
The implicit success path 181 sites, every migrated spec An action carries rejection rules and, separately, unconditional effect rules — so a refused call is obliged to reject and to perform the effect. Capacity’s [Allocate] must answer closed against a closed pool and, by a second rule with no condition on it, raise the running total and append an event. The prose specs relied on procedural case-order — if we reached this line, the guards passed — which is how every spec document reads and which Hard invariant 15 and Hard invariant 16 explicitly forbid inferring. The case table knows the state machine; the normative surface does not. Detected corpus-wide at 181 sites across all seventeen migrated documents, with no spec exempt (council read 26). The cure is uniform and needs no grammar: a declared admitted-call term per action, taken as the effect rules’ subject — an admitted allocate MUST raise allocated to the requested total. One declaration and a subject swap per rule. The ruling is whether that becomes the corpus’s standard form, and whether W-unconditional-effect gates once the sites are cleared.

Answered: Execution Contract Read 4 (commit dbdb385, 2026-10-22): a rule saying what an action does holds only for a call the action admits, whatever the rule names as its subject, so no admitted-call term is owed and the effect rules need none. W-unconditional-effect was retired with it (tools/grace/check.py, the comment above COND_ENGLISH).

Class Count What it is What would decide it
A mutating action with no write-failure outcome 1 atom; the arm landed 2026-10-21 Capability’s [Redeem] lowers the counter and can move the status to [Redeemed] in the same operation, and its signature carried redeemed(...) and four invalid(...) arms and nothing for the write failing — while [Allocate] and [Revoke], which write less, both carry [Storage Failure]. The prose spec stated the gap as a feature ([Redeem] is not a rejection-based action — all five outcomes are first-class results, not errors), which is how it survived Final Critique 5: every outcome named is indeed a result, and the unnamed one is the write. Beneath it sits the commit-ambiguity problem Recoverable Invocation exists for — a crash past a durable commit and before the reply leaves a completion nobody can resolve from this atom’s surface (council read 22). The arm landed at Capability’s Final Critique 6 (2026-10-21): [Redeem] answers storage-failure where the database refuses its write and state-unavailable where its read fails, the Execution Contract’s Step 3 and Step 1 failures, since the Database contract the atom takes by its Capability requirement 5 guarantees no write commits, so no host obligation could make the write unfailable. Who owns resolving an ambiguous redemption — a redeem whose answer is lost after its commit, one specimen of the row titled The lost answer.

Answered: the arm landed at Capability’s Final Critique 6 (2026-10-21), as the row says, and the residue it names, a redemption whose answer is lost after its commit, is the lost answer’s, answered by Execution Contract Error model 1 (commit 142036d, 2026-10-24).

Class Count What it is What would decide it
A missing deployment default gets two answers 2 atoms Invitation refuses the caller: IF the default ttl EQUALS blank THEN [Initiate] MUST answer invalid-request. Credential does not refuse at all — a deployment declaring no default expires_at leaves the credential’s expires_at absent, and the credential reads live forever. The same configuration miss, opposite answers, same migration day, neither citing the other. This is the config-miss sibling of the rare-condition-routing row above: there the question is which existing arm a rare cause borrows, here it is whether a deployment’s own gap is the caller’s problem at all (council read 41). Whether an undeclared deployment default is a refusal, a silent absence, or a spec-by-spec decision — and if the third, whether the spec must say which it chose. Credential says so in a term declaration; Invitation says so in a rule; a reader comparing them has to notice the difference to find it.

Answered: Execution Contract Logic confinement 15 (commit 215a131, 2026-11-04): a setting with no default is required at start, and an instance does not start while one is blank; a specification that states what a blank setting answers keeps its own answer, which a declaration, a rule or a setting taken from another may give.

Class Count What it is What would decide it
A bound consumed and never declared 2 atoms Party Identity’s String 7 and Credential’s String 7 each refuse a string input exceeding the deployment’s length bound, and each obliges the deployment to set one, while neither declared the bound as a term — Party Identity’s bounds category was empty and Credential’s named only its default deadline. So a load-bearing value entered the rules through prose, which is the same shape as the seam gap M-seam-injection now catches one layer over: a rule consuming something the spec’s own vocabulary does not name. Both now declare length bound and the rules cite it (council read 43). Whether the bounds category gets the treatment the seam declaration just got — a cross-check that a rule naming a bound finds it declared. Closed vocabulary 4 already requires every identifier to resolve; the gap is that an undeclared bound reads as prose rather than as an identifier, so nothing looks for it.

Answered: Execution Contract Input 2 (commit 690b048, 2026-11-02; stated again at 9cc7197, 2026-11-03): a bound is a default cap, never left unstated, and a deployment never has to supply one, so a rule that names a bound finds it declared.

Class Count What it is What would decide it
The input-handling regime 4 regimes, 6 atoms Permissions and Notification carry String 1 through 7; Legal Hold carried blank load-bearing and undefined until it was declared; Message Preference declared blank and then refuses to bound anything at all, handing every size cap to the deployment, with exact-match equality resting on two Identity rules and no no-trim or no-case-fold rule beside them. Provisional Commitment is the fourth posture and the one that shows the question is not only about caps: its migration shipped with no String family at all, so two presence checks tested caller strings for absence with no declared reading of whitespace anywhere on the page, and a whitespace-only resource was neither a hold nor a refusal. It now carries String 1 through 6, bounds duration by declaration and bounds its strings by nothing — a declared cap, a delegated cap, and silence, with silence twice arrived at by different routes. Invitation is the sixth and repeats Provisional Commitment’s failure exactly: prose that said non-null and non-empty required eight times, no String family, no blank, and therefore no declared reading of a whitespace-only context or reason anywhere on the page. Two migrations running, the same gap, found the same way — which is the argument for a declared posture rather than a per-atom habit (council read 17, council read 18, council read 38). One third of the posture is now declared: since GRACE-lang v0.52 the grammar owns blank, so what a presence check refuses is no longer an atom’s choice; equality and size still are (council read 99). One declared posture on opaque inputs — what a presence check refuses, what equality does, who bounds size — or a ruling that the posture is the domain’s.

Answered: Execution Contract Input 1 to 3 (what an input is: its declared type, else a string; the default cap a deployment may override; commits 690b048 and 9cc7197), GRACE-lang’s blank since v0.52 (what a presence check refuses), Logic confinement 13 (a reference is canonicalized at the seam, so equality compares one spelling) and Logic confinement 10 (a string’s order is its code point order). Presence, equality and size each have an owner.

Class Count What it is What would decide it
Uniqueness asserted over randomness, with no collision path 3 atoms, 2 cures An absolute invariant — two records MUST NOT share an id — over an id drawn from a random source, with no action in the signature that can report a collision. Session’s [Issue] answers a token, invalid-request or storage-failure and nothing else; Subscription and Capability carry the same shape. 128 bits makes a collision fantastically unlikely; it does not make the invariant logically true (council read 19). Capability is the exception and the cure: Invariant 12.2 makes the store refuse a colliding write, so uniqueness is enforced rather than hoped for and a collision surfaces as an existing outcome, [Storage Failure] — no new arm, no probabilistic invariant. Session and Subscription assert the same uniqueness with no such rule. Invitation is the second atom to carry the cure, and its migration states it as an Identity rule rather than an Invariant — IF the store holds the invitation_token THEN [Initiate] MUST answer storage-failure — with the store-side half as an explicit Capability requirement, which is the shape the ruling would generalize if it goes that way (council read 38). Whether the store-refusal rule Capability carries becomes the corpus’s answer and propagates to the other two, or each atom keeps its own posture. The cure needs no new grammar, which is the argument for propagating it.

Answered: Execution Contract Logic confinement 16 (commit b87b09e, 2026-11-05): the host does not supply one id it allocates to two calls of one instance, so the invariant holds without an action that reports a collision; a specification’s own rule that an id names no record already held stands beside it, as Credential’s and Gift Card’s do.

What resists automation: rows answered

Stage State What resists, and why  
The lost answer RULED 2026-10-25 A caller whose answer is lost cannot tell refused, nothing written from succeeded, answer lost, and the corpus meets that fact in three places without naming it once. Caller-side: Approval Step’s Indeterminate outcome 1 through 3 — read before retrying, never read a transport fault as a storage-failure, and a retried resolving action is self-detecting because the step has moved while a retried [Submit] is not, because submission is not idempotent. Auditor-side: the answer-capture row above exists because lost answers are indistinguishable from refusals, which is why the store alone cannot enumerate the calls that succeeded. Composition-side: Audit Trail’s 2026-08-30-b open line is the same shape one layer up — a step-4 recording failure that never returns the event_id, so the retry appends a second event and the first is unretained and unmarked. The fork is the useful part, and it has three members rather than two: self-detecting because the action moved state (a retried resolve answers not-pending), self-detecting because the guard inverted (Soft Delete’s second purge answers not-deleted, since the guard tests standing-in-deleted and a purged record does not), and duplicating because the action only appended. Soft Delete is the fourth surface and the sharpest argument for a declared treatment: it needs the discipline — a retried [Soft Delete] after a lost answer creates nothing but a rejection, while a retried [Purge] answers a reason that does not say whether the record was destroyed — and it states no Indeterminate outcome family, because its prose carried none to raise. Adding one would be logic (council read 33, council read 34). Provisional Commitment is the family’s most inconsistent specimen and the reason the row is not only about retries: it routed rejection observability to a composing Event Log whose own composition note obliged an append on admitted actions only, so the routing target was empty for exactly the content routed to it. The note now covers refused actions too. Three atoms, three treatments — capture the answers, route to a log, route to a log that does not take them — and still no declared ruling (council read 38). Invitation changes the row’s status rather than its content: it arrived carrying Composition note 4 and Composition note 5 — append on every admitted action and on every refused action — which is the exact treatment the Provisional Commitment repair pass had invented one atom earlier, reached independently. Two specimens, one treatment, so the recurrence half of Principle 2 is satisfied and the contested half is a decision rather than a wait. Invitation’s External check 1 also names the newest wrinkle: the already-resolved payload is itself answer-only, so even a log of refusals does not carry it unless the caller records what the caller was told (council read 39). Undo History is the fifth surface, the first composition-authored one, and it adds the fork’s fourth member — the one with no self-detection at all. A retried [Undo] after a lost answer does not collide with the first: Action wiring 15 targets the undo target, and the first undo’s committed event has already advanced that target past itself, so the second call admits, appends a second well-formed undo event, and answers the next forward event’s type. Every member above is either self-detecting (the retry meets a rejection) or duplicating visibly (two identical appends the auditor can see); this one duplicates and answers success, and both events are correct by every rule in the spec. The caller’s only recourse is [Read History] and a count of undo events — which is exactly Approval Step’s read-before-retrying — so the cure is already in the corpus and the spec is the one place it cannot be stated. It is not stated, and for the Soft Delete reason: the prose carries no lost-answer material, so adding an Indeterminate outcome family would be logic. That ruling now has its second instance and its worst consequence, which is the argument for making the treatment declared rather than per-spec — a hazard class that is invisible in the answer cannot be left to whether a particular prose author happened to think of it (council read 46, council read 47). Ruled by the maintainer, 2026-10-25: the Execution Contract states it once, as Error model 1. A lost answer is none of the three failure classes: the caller cannot tell whether the call landed, a retry is a second call (Read 4), and what the caller does next is the composing pattern’s unless the specification states it. One declared treatment, then, and not a posture per action: a page that names its caller’s course, such as the record read before retrying, keeps it and cites the label, and the rules ten specifications wrote to restate the arm are tombstoned to it. Whether the three surfaces get one declared treatment — a named idempotency posture per action — or stay three specs and one open line describing one fact.

Answered: RULED 2026-10-25, as the row says: Execution Contract Error model 1 (commit 142036d, 2026-10-24) states that a lost answer is none of the three outcomes, that a retry is a second call the action admits or refuses on the records as it finds them (Read 4), and that what the caller does next is the composing pattern’s unless the specification states it; a page that names its caller’s course keeps it and cites the label.

Stage State What resists, and why  
The atom with no acceptance surface 3 of 28, and the composition epoch inherits it Generation acceptance is where a spec says what an external auditor can clear from records and the query surface alone, and three atoms carry none at all — no section, no Check family, nothing auditing any rule: Duplicate Prevention, Event Log, Personal Todo. cites.py --unchecked states it flatly for the largest — no checks — nothing audits any of its 85 rules. Two of the three are exactly the atoms that closed the set without a council read, and all three are the earliest migration wave; Consent is that same wave with a full section, so the cause is not vintage but the loop — the reads are what produced acceptance sections, and the specs that skipped the loop skipped the section. The cost is not paid by the atoms, which are small and much-read. It is paid one layer up: Undo History composes Event Log and Personal Todo, and its thirteen Check rules and four External check rules rest on two constituents with no acceptance surface between them, so the first composition of the epoch is auditable exactly as far as its own rules reach (council read 49). Complete as of council read 51: all three have now been read, each returned a different class — an unchecked sharpest invariant in Consent, an uncited frozen contract surface in Event Log, a doubly-declared boundary in Duplicate Prevention — and none of the three reads produced an acceptance section, because writing one is work the reads did not have a ruling for. The correlation the row rests on is therefore as strong as it is going to get without that ruling. Whether every migrated spec must carry the section — presence is mechanical, so it would be a lint.py check — or whether an atom may decline it and say so, in which case a composition needs a way to know its constituent’s guarantees are unaudited before resting thirteen checks on them.

Answered: presence of the section was made mandatory on 2026-09-14 (commit dfdae21) and is held by the linter’s Y-acceptance-surface check (council read 65): a migrated spec carries a Generation acceptance section with a Check or External check rule, or declines by delegation on its own Term qualifiers line, naming the pattern that owns the surface. Duplicate Prevention, Event Log and Personal Todo each carry the section now.

Stage State What resists, and why  
Which direction a rule may point across a seam RULED 2026-09-14 Composition note 10 in three atoms reads a composing pattern reading the store MUST NOT write to the store — an atom legislating a composition’s surface, where the other nine notes in the same family only route ownership outward (a composing pattern MUST own X). Composition notes are labelled rules carrying one obligation each, so the polarity is real: nothing rules whether an atom may bind a composition, a composition may bind an atom, or both. No conflict has surfaced in the corpus yet, which is why this is a docket row rather than a finding (council read 36). One has now, and it is about credit rather than content. Session’s Composition note 4 states the gate — IF Validate gives an invalid answer THEN a composing pattern MUST NOT call Permissions — and Session’s WHY names Session-Gated Authorization as the pattern that carries it. That composition’s Summary calls the same gate its load-bearing emergent invariant, belonging to neither atom. Both forbid the identical call, so nothing is contradicted; what is contested is whether a composition’s reason to exist can be a rule its constituent already owns. The contrast inside one document settles the shape of the question: Permissions’s Composition note 3 assigns the caller-to-subject binding without stating the rule, so that composition’s Invariant 2 is genuinely emergent, while Invariant 1 is inherited. An assignment and a prohibition are different obligations wearing one family name. Ruled by the maintainer, 2026-09-14: atoms may bind compositions; a composition cites what the composition inherits and owns what the composition adds. The direction question is answered — obligations may point down the seam, and the composing side’s duty is citation rather than silence or restatement, which is Authority 5 and Authority 6 already written and never before applied across the seam. Session-Gated Authorization is the worked example: Composes 7 cites Composition note 4, the three rules enumerating it are tombstoned to it, and Invariant 1.1 stands because it is strictly stronger — the note fires on an invalid answer given, the invariant on no valid answer given, so a deployment that skipped validate entirely satisfies one and breaches the other. Authority 4 is what keeps the two apart: a citing spec may add, and what it adds is its own. The residue, small and left open: nothing yet rules whether a composition may bind an atom — every instance so far points down (council read 36, council read 53). Whether obligations may point up the composition seam as well as down, and what a composition does with an atom’s rule it disagrees with.

Answered in part: the direction question was ruled by the maintainer on 2026-09-14 (atoms may bind compositions; a composition cites what it inherits and owns what it adds, Authority 4 through 6), and Execution Contract Atom interface 1 (commit cab291d, 2026-10-30) states the seam’s side of it: a composing pattern changes a constituent’s records only through the constituent’s declared actions, so a constituent’s rule forbidding a composing pattern reading its records to write them forbids only a write outside those actions. Open, and kept on the page: whether a composition may bind an atom.

Generated index (planned, not built)

Open questions are also scattered through the artifacts as markers: *(forthcoming)* links, atoms/compositions marked unresolved / partially resolved, open CORNERS items, and the sub-question sections in proposals (e.g. atoms/TAXONOMY.md). Those are derivable — a future generator should project them into an index appended here rather than anyone hand-maintaining the list. Same discipline as the taxonomy itself: name the irreducible (the authored architectural questions above), derive the rest.

Scope addition (2026-07-06): the roadmap dashboard. An external readability review asked the roadmap for an executive summary — the request is legitimate and the hand-written form is forbidden (a summary block is a snapshot that rots; the roadmap now says so in its orientation note). The permitted form is the same generated-view move: a derived dashboard — pattern counts from _data/patterns.json (already emitted by tools/taxonomy/generate_graph.py), open methodology debts extracted from the roadmap’s numbered headers, open questions from this file’s section list — regenerated alongside the graph page, never hand-edited. Rides this generated-index plan; build it when the generator gains its next pass, not before (smallest machinery)…

Answered: nothing builds it; the open questions are the ones this page lists, and the derivable markers (forthcoming links, status tokens) are counted by the roadmap and the linter. Moved here whole on 2026-11-14 with its heading’s words: planned, not built.