@sema-agent/core 7.64.0 → 7.66.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (192) hide show
  1. package/CHANGELOG.md +571 -0
  2. package/dist/agents/delegation-registry-seat.d.ts +15 -0
  3. package/dist/agents/delegation-registry-seat.js +13 -0
  4. package/dist/agents/org-delivery-gate.d.ts +8 -1
  5. package/dist/agents/org-delivery-gate.js +9 -3
  6. package/dist/agents/peer-held-queue.js +1 -1
  7. package/dist/agents/peer-idle.js +1 -1
  8. package/dist/agents/peer-session-drain.d.ts +51 -12
  9. package/dist/agents/peer-session-drain.js +47 -34
  10. package/dist/agents/read-inbox-tool.d.ts +6 -2
  11. package/dist/agents/read-inbox-tool.js +18 -5
  12. package/dist/agents/subagent.d.ts +3 -1
  13. package/dist/agents/subagent.js +84 -77
  14. package/dist/brain/reasoning.d.ts +2 -0
  15. package/dist/brain/reasoning.js +1 -0
  16. package/dist/core/allow-entry.d.ts +9 -0
  17. package/dist/core/allow-entry.js +7 -1
  18. package/dist/core/ask-origin.d.ts +23 -3
  19. package/dist/core/ask-origin.js +11 -1
  20. package/dist/core/auto-promote.d.ts +3 -2
  21. package/dist/core/background-agent-store.d.ts +7 -0
  22. package/dist/core/checkpoint-store.d.ts +2 -3
  23. package/dist/core/context-settings.d.ts +1 -2
  24. package/dist/core/context-settings.js +1 -1
  25. package/dist/core/engine-attestation.d.ts +2 -2
  26. package/dist/core/engine-notice.d.ts +13 -1
  27. package/dist/core/engine-notice.js +3 -1
  28. package/dist/core/file-history-store.d.ts +2 -2
  29. package/dist/core/file-history-store.js +0 -4
  30. package/dist/core/gate-fold.js +3 -1
  31. package/dist/core/governance-codes.d.ts +6 -4
  32. package/dist/core/governance-codes.js +5 -3
  33. package/dist/core/human-input-projection.d.ts +9 -0
  34. package/dist/core/human-input-projection.js +13 -0
  35. package/dist/core/input-author.d.ts +66 -6
  36. package/dist/core/input-author.js +21 -3
  37. package/dist/core/leg-identity.d.ts +18 -2
  38. package/dist/core/leg-identity.js +5 -7
  39. package/dist/core/mailbox-store.d.ts +1 -1
  40. package/dist/core/memory-engine/consolidation.d.ts +30 -10
  41. package/dist/core/memory-engine/consolidation.js +41 -6
  42. package/dist/core/memory-engine/control-objects.d.ts +36 -3
  43. package/dist/core/memory-engine/control-objects.js +134 -12
  44. package/dist/core/memory-engine/control-plane-adoption.d.ts +13 -9
  45. package/dist/core/memory-engine/control-plane-adoption.js +58 -31
  46. package/dist/core/memory-engine/delegation-settlement.d.ts +75 -52
  47. package/dist/core/memory-engine/delegation-settlement.js +211 -228
  48. package/dist/core/memory-engine/dual-root.d.ts +3 -2
  49. package/dist/core/memory-engine/dual-root.js +5 -1
  50. package/dist/core/memory-engine/engine.d.ts +33 -16
  51. package/dist/core/memory-engine/engine.js +213 -177
  52. package/dist/core/memory-engine/file-backend.d.ts +21 -12
  53. package/dist/core/memory-engine/file-backend.js +58 -104
  54. package/dist/core/memory-engine/index.d.ts +2 -2
  55. package/dist/core/memory-engine/index.js +2 -2
  56. package/dist/core/memory-engine/layout.d.ts +184 -83
  57. package/dist/core/memory-engine/layout.js +267 -172
  58. package/dist/core/memory-engine/memory-age.d.ts +12 -0
  59. package/dist/core/memory-engine/memory-age.js +17 -0
  60. package/dist/core/memory-engine/memory-backend-contract.js +12 -11
  61. package/dist/core/memory-engine/memory-deployment.d.ts +4 -3
  62. package/dist/core/memory-engine/memory-deployment.js +6 -3
  63. package/dist/core/memory-engine/origin-clearance.d.ts +43 -15
  64. package/dist/core/memory-engine/origin-clearance.js +142 -58
  65. package/dist/core/memory-engine/tools.d.ts +2 -2
  66. package/dist/core/memory-engine/tools.js +7 -7
  67. package/dist/core/memory-engine/types.d.ts +16 -10
  68. package/dist/core/memory-vector.d.ts +6 -14
  69. package/dist/core/memory.d.ts +0 -462
  70. package/dist/core/memory.js +0 -333
  71. package/dist/core/model-receipt.d.ts +2 -1
  72. package/dist/core/model-receipt.js +5 -0
  73. package/dist/core/mods/dollar.d.ts +12 -0
  74. package/dist/core/mods/kernel/dispatch.d.ts +3 -1
  75. package/dist/core/mods/kernel/dispatch.js +5 -2
  76. package/dist/core/mods/kernel/events.d.ts +3 -1
  77. package/dist/core/mods/kernel/events.js +2 -2
  78. package/dist/core/mods/prompt-submit.d.ts +4 -0
  79. package/dist/core/mods/prompt-submit.js +24 -0
  80. package/dist/core/mods/stations.d.ts +23 -4
  81. package/dist/core/mods/stations.js +14 -7
  82. package/dist/core/permission-rule-consent.d.ts +49 -18
  83. package/dist/core/permission-rule-consent.js +59 -38
  84. package/dist/core/permission-rule-store.d.ts +24 -14
  85. package/dist/core/retention.d.ts +2 -7
  86. package/dist/core/retention.js +0 -1
  87. package/dist/core/retired-host-table-account.d.ts +19 -0
  88. package/dist/core/retired-host-table-account.js +28 -0
  89. package/dist/core/retired-tool-name-account.d.ts +60 -0
  90. package/dist/core/retired-tool-name-account.js +32 -0
  91. package/dist/core/roles.d.ts +3 -1
  92. package/dist/core/roles.js +5 -2
  93. package/dist/core/runner/classifier-ladder.d.ts +3 -1
  94. package/dist/core/runner/classifier-ladder.js +2 -2
  95. package/dist/core/runner/compact-session.js +2 -1
  96. package/dist/core/runner/contracts.d.ts +9 -9
  97. package/dist/core/runner/delegation-owner.d.ts +0 -8
  98. package/dist/core/runner/delegation-owner.js +1 -3
  99. package/dist/core/runner/gate-exit.js +9 -2
  100. package/dist/core/runner/memory-consolidation-driver.js +2 -2
  101. package/dist/core/runner/prepare-config-doors.js +1 -1
  102. package/dist/core/runner/prepare-delegation-surface.d.ts +1 -1
  103. package/dist/core/runner/prepare-delegation-surface.js +5 -3
  104. package/dist/core/runner/prepare-gate-stations.d.ts +8 -5
  105. package/dist/core/runner/prepare-gate-stations.js +13 -5
  106. package/dist/core/runner/prepare-inherited-gate.js +2 -0
  107. package/dist/core/runner/prepare-memory-engine-session.js +1 -1
  108. package/dist/core/runner/prepare-memory.js +35 -14
  109. package/dist/core/runner/prepare-policy-chain.js +12 -3
  110. package/dist/core/runner/prepare-project-context.js +2 -2
  111. package/dist/core/runner/prepare-task.d.ts +9 -1
  112. package/dist/core/runner/prepare-task.js +6 -5
  113. package/dist/core/runner/prepare-wiring-manifest.js +5 -4
  114. package/dist/core/runner/prompt-suggestions.js +1 -1
  115. package/dist/core/runner/run-identity-wiring.js +2 -2
  116. package/dist/core/runner/run-leg.js +3 -3
  117. package/dist/core/runner/run-notification-lane.d.ts +3 -0
  118. package/dist/core/runner/run-notification-lane.js +2 -2
  119. package/dist/core/runner/runtask.js +6 -3
  120. package/dist/core/runner/steer-admission.d.ts +11 -2
  121. package/dist/core/runner/stream-steer-verb.d.ts +5 -2
  122. package/dist/core/runner/stream-steer-verb.js +67 -14
  123. package/dist/core/runner/sub-agent-deny-lists.d.ts +8 -8
  124. package/dist/core/runner/sub-agent-deny-lists.js +22 -8
  125. package/dist/core/runner-deps.d.ts +4 -4
  126. package/dist/core/secret-env.d.ts +2 -2
  127. package/dist/core/secret-env.js +6 -20
  128. package/dist/core/session-store.d.ts +6 -6
  129. package/dist/core/session-store.js +3 -3
  130. package/dist/core/shell-run-candidates.js +3 -3
  131. package/dist/core/side-query.js +1 -1
  132. package/dist/core/skill-grant.d.ts +7 -0
  133. package/dist/core/skill-grant.js +14 -5
  134. package/dist/core/store-contracts/background-agent-store-contract.js +13 -0
  135. package/dist/core/task-event.d.ts +14 -0
  136. package/dist/core/task-notification.d.ts +35 -8
  137. package/dist/core/task-notification.js +31 -13
  138. package/dist/core/task-registry-agent.js +1 -0
  139. package/dist/core/task-registry-shared.d.ts +4 -0
  140. package/dist/core/tool-errors.d.ts +3 -3
  141. package/dist/core/tool-policy.js +2 -3
  142. package/dist/core/tool-spec.d.ts +20 -10
  143. package/dist/core/user-attachment.d.ts +5 -1
  144. package/dist/core/user-attachment.js +11 -5
  145. package/dist/core/write-protect.d.ts +16 -0
  146. package/dist/core/write-protect.js +10 -0
  147. package/dist/engine/harness/agent-harness.d.ts +19 -11
  148. package/dist/engine/harness/agent-harness.js +7 -4
  149. package/dist/engine/llm/types.d.ts +22 -10
  150. package/dist/engine/session/repo-utils.d.ts +14 -4
  151. package/dist/engine/session/repo-utils.js +5 -4
  152. package/dist/index.d.ts +10 -8
  153. package/dist/index.js +9 -7
  154. package/dist/prompts/default.d.ts +1 -2
  155. package/dist/scenarios/full-body.d.ts +1 -1
  156. package/dist/shell/lex.d.ts +50 -15
  157. package/dist/shell/lex.js +43 -9
  158. package/dist/stores/file/adoption/adopt.d.ts +1 -1
  159. package/dist/stores/file/index.d.ts +1 -15
  160. package/dist/stores/file/index.js +1 -15
  161. package/dist/stores/file/permission-rule-store.d.ts +12 -1
  162. package/dist/stores/file/permission-rule-store.js +31 -4
  163. package/dist/stores/file/session-store.js +1 -1
  164. package/dist/tools/fs/fs-bash.js +3 -3
  165. package/dist/tools/fs/removal-targets.d.ts +8 -2
  166. package/dist/tools/fs/removal-targets.js +31 -4
  167. package/dist/tools/fs/shell-read-argv.js +7 -1
  168. package/dist/tools/fs/shell-read-bindings.d.ts +21 -5
  169. package/dist/tools/fs/shell-read-bindings.js +130 -44
  170. package/dist/tools/fs/shell-read-plan.js +95 -29
  171. package/dist/tools/fs/shell-read-sourced.d.ts +25 -0
  172. package/dist/tools/fs/shell-read-sourced.js +119 -0
  173. package/dist/tools/fs/shell-read-word.d.ts +2 -2
  174. package/dist/tools/fs/shell-read-word.js +4 -5
  175. package/dist/tools/fs/shell-read-workdir.d.ts +19 -3
  176. package/dist/tools/fs/shell-read-workdir.js +60 -15
  177. package/dist/tools/fs/shell-reentry-text.d.ts +10 -2
  178. package/dist/tools/fs/shell-reentry-text.js +11 -4
  179. package/package.json +2 -2
  180. package/test/export-surface.snapshot.json +21 -79
  181. package/wire-changes/core-stores-sql@7.65.0.json +30 -0
  182. package/wire-changes/core-stores-sql@7.66.0.json +30 -0
  183. package/wire-changes/core@7.65.0.json +1650 -0
  184. package/wire-changes/core@7.66.0.json +1218 -0
  185. package/wire-changes/mods-kernel@7.65.0.json +30 -0
  186. package/wire-changes/mods-kernel@7.66.0.json +65 -0
  187. package/wire-changes/primitives@7.65.0.json +337 -0
  188. package/wire-changes/primitives@7.66.0.json +30 -0
  189. package/dist/core/memory-recall.d.ts +0 -208
  190. package/dist/core/memory-recall.js +0 -136
  191. package/dist/stores/file/memory-store.d.ts +0 -124
  192. package/dist/stores/file/memory-store.js +0 -353
package/CHANGELOG.md CHANGED
@@ -1,3 +1,574 @@
1
+ ## 7.66.0 — 2026-11-04
2
+
3
+ ### Errata to the 7.63.0 section (11-04)
4
+
5
+ - **#3355 node, "Claude Code 2.1.316" paragraph — the sentence "CC has no durable approval park" is untrue.** Claude Code 2.1.316 carries a worker-level parked-permission takeover (class `lS`, `cli316.js:288862`): `arm()` waits `answerWaitMs` — `CLAUDE_CODE_PARKED_PERMISSION_WAIT_MS ?? 2000` — then `fire("timeout")` retires the call. That wait is the takeover wait, not a card lifetime, so the comparison the paragraph wanted (a parked approval that outlives the worker, announced when the deployment reconciles — D-3355-a / D-3355-b in the divergence register) stands; the absence claim does not. Found by car-div-7660 registering D-3355-a/b (11-04); the car-3355 receipt carries the same erratum. Nothing in the package changes.
6
+
7
+ ### A deployment's delivery gate may narrow who reaches whom, and nothing downstream reads its list — the contract sentence `cross_session.gate_narrows_reach` in INTEGRATION-CORE §13.1b, and the known limit of a principal inbox nobody reads (#3538; behavior change: none — documentation only, no line of `src/` moved; hard-breaking: none; closed sets: none; exports: none) (@server @dgx)
8
+
9
+ - **Before.** The gate contract (INTEGRATION-CORE §13.1) said an unknown recipient and one the sender may not reach answer the same `not_member` bytes, and nothing said what a deployment may do with that room: whether the gate may keep a list of the senders a recipient accepts, what such a list releases and what it cannot, and whether it reaches the tool-question ladder. A deployment asked to let a household's agents write to each other without a person approving each letter had no sentence to choose between "put it in the gate" and "teach the engine's judge a sender arm". The picture behind that ask was also off: a cross-principal letter is never put to a person — the principal arm is a pure judgment, every cause it holds a letter with (`managed-setting`, `explicit-setting`, `invalid-setting`, `cross-principal-default`) sits outside `PEER_HELD_REVIEW_CAUSES`, and the receipt for it is `held_by_policy`.
10
+ - **Now.** §13.1b of `docs/INTEGRATION-CORE.md` states one contract sentence, `cross_session.gate_narrows_reach`: a deployment may narrow, inside its `OrgDeliveryGate`, who can write to whom beyond organization membership; a narrowing refusal is `org_delivery.not_member` with the same code and the same message bytes as an unknown recipient or another organization, given at the membership step, before anything is appended and before any quota is spent; the gate never writes a verdict on the record, so every letter it appends is judged at the recipient's drain by the principal arm like any other. Passing the gate therefore means "may be stored" and nothing more: it is not `next-turn` or `wake` (a recipient who set nothing still holds the letter as `cross-principal-default`), it releases no letter a setting holds, it is not retroactive in either direction (the judge reads the setting and the letter's `fromScope`, not a list), and a sender on a list mints no allow rule and clears no `mandated` question (`ruleClearanceOf` takes no sender). A listed sender's letter keeps every mark of a cross-principal letter: the `CROSS_PRINCIPAL_MESSAGE_NOTICE` block and the external-content accounting. The section also says who owns the answer: core holds no list of trusted senders, no judge arm keyed by the sender and no setting for either.
11
+ - **Narrowing / widening.** None. No line of `src/` changed; the sentence states what the gate contract, `judgeCrossSessionInbound` (`src/agents/cross-session-judge.ts`) and the ask ladder already do.
12
+ - **Wire / exports.** None.
13
+ - **Consumers.** @server: a gate that adds this narrowing answers `org_delivery.not_member` before the append and before any quota is spent, and keeps it to the membership step; a recipient who lists senders and sets nothing else still holds their letters as `cross-principal-default`, so the household path is two settings together — the list (who may be stored) and a principal-layer `next-turn` / `wake` (what a stored letter does); for a recipient who lists senders, a same-organization sender not on the list goes from "stored, held" to "refused", the deployment's own release point to name. @dgx: the grid the design asked for (principal, direction, scene, how fast a letter must be read, who may edit the row, what happens to letters already in the box on revocation) describes the list's data, which the deployment keeps; core reads none of it. @cli @client-core @test: no change; a test of the deployment's gate reads, as seen from outside, a sender outside the list getting the membership refusal with nothing appended or counted, a listed sender plus `next-turn` delivered, a listed sender with nothing set held, and a listed sender plus a managed `hold` held.
14
+ - **Rules.** None added or retired: the sentence states a rule the three parts it names already follow.
15
+ - **Claude Code 2.1.316.** No anchor (inferred): the reference's `ListAgents` description names only the caller's own subagents, team, other local sessions and cloud sessions (`cli316.js:268223`, `ListAgents`), so it has no cross-account lane and no sender list; this contract is this engine's alone.
16
+ - **Known limits.** KL-3538-a — a principal inbox declared `{ assistant: handle }` has a reader only where a leg runs under that handle and something continues it after an append (the sema-server deployment's side of it is inferred from a grep of its source, not run). The ticket's first wording ("core mints a principal lane only for `terminals`") described v7.65.0; since #2637 (this release) the leg whose host task id is the handle has a pull-only lane, so the row states the narrower fact.
17
+ - **Pins.** `test/docs-contract-pins.test.ts` — G1 §13.1b sits between 13.1 and 13.2 and carries the sentence's anchors · G2 the KL-3538-a row exists with five columns and names its two coordinates · G3 `org_delivery.not_member` is one of the gate contract's four words · G4 the principal arm reads the setting and `fromScope` only: unset holds `cross-principal-default`, an explicit value decides alike for every sender, managed beats user, a garbage value holds `invalid-setting` · G5 no setting cause is a review cause (`held_by_policy`) · G6 `ruleClearanceOf(ask, marks)` takes no sender and a mandated ask stays mandated · G7 an `{ assistant }` declaration lanes the one leg under the handle, compared exactly, and `terminals` lanes nothing on a leg with no session box.
18
+
19
+ ### The release lint reads the divergence register — every `D-…` number the release's CHANGELOG block and its post name must stand in `core/cc-parity/divergences.json`, and a count the post gives about the register is the register's (#3561; tooling only, no package surface: behavior change: none for the engine; hard-breaking: none; closed sets: none; exports: none; wire: no key added)
20
+
21
+ - **Before.** The legs of `scripts/ship-post-lint.mjs` asked whether the FEATS / AUDITS / PLANS / CAPABILITY ledgers moved for the release, and none read the divergence register. 7.64.0 and 7.65.0 shipped blocks that named a dozen `D-…` numbers while no divergence car had run, so the register held none of them, and the 7.65.0 post still wrote "car-div-7650 已登 +12" — the number of the window before, recalled instead of read. Nothing could be red.
22
+ - **Now.** A document leg, `checkDivergenceLeg` (it runs under `--no-build`, after the registry legs; `--internal-root <dir>` names the internal checkout, default the sibling `sema-internal` beside this checkout or the main one). (1) Each `D-<ticket>-<letters>` in the prose of the `## <package.json version>` block of the working directory's `CHANGELOG.md` and of the post (fenced blocks and HTML comments are not read) must stand in a string field of at least one register entry — an entry's `id` is a slug and the number lives in `decidedBy` (and in `surface` / `reason` of entries whose author wrote it there), so every string field is read and none specially. (2) A `+N` or `N 条` in a sentence of the post (a line cut at `。`; a `;` does not end it, and the count often stands after one) that names `偏离册` / `divergences` / `car-div-` must equal the number of the block's literals that stand in the register; the FAILED line prints the machine's list and number, and a post with no such clause gets the number printed to copy. (3) A block that is absent, and a register that is absent, not JSON or not an array, are FAILED (exit 1) — not a skip, not a warning. A register total (`555 → 567`) is another quantity and is not judged.
23
+ - **Rules.** +1 leg, the posture of the FEATS / AUDITS legs (the machine checks the cheap half — "is it written down?" — never whether the entry is right); the block is read with the one reader of versioned blocks (`versionedBlocks`), the prose with the one reader of a post's prose (`proseOf`). No rule retired; no second reading of either.
24
+ - **Known limits.** A number cited inside another entry's `surface` / `reason` also reads as registered, so the leg proves a literal is written down in the register, not that it has an entry of its own. A number that is not `D-<1–5 digits>-<1–3 lower-case letters>` (`D-S5`, a bare ticket) is not read. A count written in another unit ("12 个") or in a sentence that does not name the register is not read.
25
+ - **Pins.** `test/ship-post-lint-divergence-leg.test.ts` — G1–G7 (all registered and the count right; no count sentence, the number printed; non-literals and fenced / commented text not read; only this release's block; the number found in `decidedBy` / `surface` / `reason`; totals not judged; a number in another sentence of the line or in a fence not a count), R1–R5 (a literal missing from the register, named with where it stands; `+12` against eight; `N 条`; a count after a `;` is the sentence's; the count taken over the registered literals only; a `## ` line inside a fence or a comment does not end the release's block; an unreadable register in four forms; an absent version block, an absent or doubled CHANGELOG; the three real count sentences of posts 12584 / 12788 / 12941), W1–W4 (the CLI under `--no-build`: a missing literal is exit 1, the clean line is printed, an unreadable register is exit 1 and not 2, the leg is part of `allOk`); mutations M1a–M17 (the literal regex without either boundary or widened; the CHANGELOG cut into blocks before its fences are blanked; the register read through `id` only or `decidedBy` only; an absent / non-array / unparseable register as a skip; the count not compared; the whole CHANGELOG as the block; fences read; the leg left out of `allOk` or skipped under `--no-build`; totals judged; a sentence as the whole line, a `;` ending it; the post's own literals not judged; the count taken over every named literal; the `+N` form or the `N 条` form dropped; an absent version block not a problem), each red.
26
+
27
+ ### An attachment an extension refused says which extension refused it — `human_input{applied}`'s `attachments[i].declinedBy` names the `prompt.mention` extension whose `{ deny }` / `{ type: null }` answer, or whose failing handler, kept the attachment from the model (#2826; ruled C-R928 A; behavior change: none for a run that raised no `prompt.mention` — the frame of an attachment that reached the model, and every refusal no extension made, is byte-for-byte what it was; hard-breaking: none; closed sets: none; exports: none added or removed — one optional member on each of two exported types, below; wire: +1 optional member on `human_input.attachments[]`) (@cli @client-core @test)
28
+
29
+ - **Before.** An extension that refused a mention (`prompt.mention` → `{ deny: "…" }` or `{ type: null }`, or a handler that threw, ran past its budget or answered what the station refuses) kept the attachment from the model, and the engine said so to the model in the attachment's frame text — but the host's `human_input{applied}` frame carried only `{ ordinal, kind?, outcome: "not_attached", label }`. A host drawing the attachment row could say "not attached" and not who refused it (`notes: ["extension_declined"]` lives on the transcript record, not on the frame; test mods2809 W6).
30
+ - **Now.** `HumanInputAttachment` gains the optional member `declinedBy?: ExtensionRequester` — `{ kind: "extension", name }`, the author type the requester and rewrite records already use, built by the one reading `readExtensionRequester` from the registration name the dispatch names (`namedRegistration`: the engine's own origin word names no extension). Present on a `not_attached` attachment whose refusal an extension made — the producer of a decline answer, or the registration whose handler failed (the two outcomes that mint the `extension_declined` note with a name to give); absent on every attachment that reached the model, and on a refusal no extension made (a read rule's deny, the run's cancel, the engine's own fault). One projection builds it (`humanInputAttachmentsOf`), from a member the frame the leg just minted carries (`MintedAttachmentFrame.declinedBy`, the same fact one hop earlier — a projection chain, not a second record); the transcript record is unchanged.
31
+ - **Type face (additive).** `HumanInputAttachment.declinedBy?` and `MintedAttachmentFrame.declinedBy?`, both optional and read-only; nothing removed, retyped or made required. @cli @client-core: render a not-attached row's refuser from `declinedBy.name` when present ("not attached — refused by <name>"); a consumer that ignores the member sees the frame it saw before.
32
+ - **Known limits.** KL-2826-a (three forms carry the `extension_declined` note and no `declinedBy`: a cancel while an extension was judging, the engine's own violation, and a bad spelling handed down the chain — the dispatch does not say which handler handed it; present ⇒ named, the converse does not hold); KL-2826-b (the name exists only on the frame minted at the run, not on the persisted record: a replay surface rebuilt from records would show "not attached" without the refuser — none exists in core today).
33
+ - **Pins.** `test/backlog2826-declined-by.test.ts` — D1–D8 drive a real Runner and read the frame (a deny on a path, a host text and a host image; the attached controls; one refused and one attached in the same objective; a read rule's deny with and without a passing extension; two extensions on the chain; `{ type: null }`; a throwing handler and a forging one; the unnamed bad-spelling form), U1–U5 hand `readUserAttachments` each outcome kind the dispatcher can give (answered with and without a producer, failed by an extension and by the engine, aborted, the bottom's own refusal, a blank name).
34
+
35
+ ### A function body, a sourced body and a line `read` binds are judged where they run — the evaluator's re-entry and a child shell's literal text are callers, a file this command wrote and then sources is the text it sources, and a here-string's lines bound by `read` are the paths the body reads (#3399 / #3400 / #3401; behavior change: narrowing — seven forms that ran with protected bytes on the bypass seat are refused before the program runs; hard-breaking: none; wire: none)
36
+
37
+ - **Before.** Three places a body (or a path) runs were not read as that place, so a protected read inside ran unjudged on the bypass seat and was only the mandated question elsewhere (car-read-boundary-7630-a receipt §R; cx-readb Y2 / Y6; both trees since 7.62.0): (1) `f() { cat secrets/key.txt; }; cd .. && printf x | read 'a[$(f)]'` — the `read` builtin evaluates the subscript it is handed as a quoted literal, which runs `f` where the `read` stands, but the walk read callers only from unquoted substitutions; `export -f f; cd .. && bash -c f` — the child shell's literal text names the exported function, which runs its body where the launcher stands. (2) `printf 'f(){ cat secrets/key.txt; }\n' > lib.sh; . ./lib.sh; cd .. && f` — `source` ran text the station did not hold, so `f` was no function of the text and its call no caller. (3) `cd .. && while read -r p; do cat "$p"; done <<< secrets/key.txt` (a here-document alike, and `read -r p <<< X && cat "$p"`) — `read` left its name unknown, so the body's `cat "$p"` was an unresolvable word.
38
+ - **Now.** One callers set, grown by two forms (`segmentRunsBody`, `src/tools/fs/shell-read-workdir.ts`): the arithmetic text a segment hands the evaluator — an assignment word's subscript, or the subscript of a name a builtin binds (`read 'a[$(f)]'`, `unset 'a[$(f)]'`, quoted or not) — is lexed for a call, in THIS shell; and the literal text a child shell is handed (`bash -c f`) is lexed for a call to a function this shell EXPORTED before that segment (`export -f` / `declare -fx`, in order), which runs there, where the segment stands. A bare `source` / `.` of a file the segment IMMEDIATELY before it wrote with a literal printer and a `>` redirection — `printf FORMAT` converting nothing or `echo [-n] WORD…` with no escape; the write not reached through `&&` / `||` unless the source is `&&`-chained to it; the `source` carrying no redirection of its own — is spliced in place at the lexer's output (`src/tools/fs/shell-read-sourced.ts`): the written literal's segments stand where the `source` stood, and every reader (definitions, bodies, callers, bindings, the working-directory thread) reads them as the shell runs them. `read NAME` fed a text the command itself spells (a here-string or here-document — the loop's where its `done` carries it, by the one reading a group's input already takes) binds NAME to the text's first line — or, fed by a loop's `done` (each beat reads the next line), to one of its lines, a reader judged over every one (`readBuiltinLines`, `src/tools/fs/shell-read-bindings.ts`; held through the loop body as a `for` variable is); only the plain form is read — one identifier other than `HOME` (a home rebound from data is never placed, the 7.30.0 law), `-r` the only option, no `IFS` bound before it (earlier in the text, anywhere in a loop it sits in, anywhere at all in a text that defines a function, or in the text this one was started from) or in the command's environment, every text that may arrive literal — and a `read` the shell may not run (the builtin disabled where the text cannot tell, a redirection of its own that may fail to open) binds one more value the name may hold rather than replacing it, while one the shell cannot run at all (the builtin disabled for certain) leaves the name what it held; any other form leaves the name unknown as before. A pipe into the segment outranks the loop's input; nested loops take the innermost `done` that names one. The evaluator's texts a segment hands over include `let`'s words whole (their grammar is the evaluator's, not the shell's: every substitution a word spells is taken to run, KL-3399-c) and `(( … ))`'s whole expression, and a child shell's text includes the last text its standard input spells (`bash <<< f`, a here-document on descriptor 0 — the lexer now keeps a here-document's descriptor, so `3<<EOF` is not standard input — this retires the 7.49.0 reading in which every here-document counted as the child shell's standard input (pin #1417 ⑬ re-pinned: `echo … | bash 3<<EOF` plans nothing of the here-document, its script being the pipe's product) — what a loop's `done` feeds it; an output redirection on a loop's `read` leaves the loop's input its own; a descriptor closed or moved is not read, KL-3401-b).
39
+ - **#3557 (legB astra high · legA R-1, 11-04) — the splice reads, it never certifies.** The first cut replaced the `source` segment with the written literal's segments and read what they bind as certain, so `p=secrets/key.txt; cd ..; printf 'p=ok.txt\n' > /dev/null; . /dev/null; cat "$p"` was vouched on the bypass seat (`/dev/null` keeps nothing, the shell read `secrets/key.txt`), and the mandated question `. ./lib.sh` raised in v7.65.0 on the other seats vanished with the segment. Now (a) every spliced segment carries `LexedSegment.spliced`: its bindings are `detached` — one more value the name may hold, the #3536 floor law; its moves read as any move does (after `;` the unmoved place stays a candidate, under `&&` the read in the same text happens only where the move landed — the first cut's `never provable` clause over-refused that form and was shown redundant for the rest, D12); (b) a write to a device or to `-` is a write like any other — bash makes a file named `-`, `/dev/shm/x.sh` keeps bytes — so its text splices as detached text (the first cut excluded `/dev/*` and `-`, which let `printf 'cat secrets/key.txt\n' > -; . ./-` run on the bypass seat; codex astra r1); (c) the `source` segment itself stays after the literal's segments (connector `;`), so where the written text did not land (a failed or backgrounded write, `set -C`, a same-name file found on PATH) its own question about sourcing an unread file still stands; (d) a text the station does not hold — `eval`, or `source` of an unread file — is a may-have-run entry too: the name is unknown and what it held before stays its deny floor (it used to wipe the floor: `p=secrets/key.txt; . /dev/null; cat "$p"` ran on the bypass seat); a call or a loop head that may rebind a name still reads certain-unknown — the same hole through a call (`p=secrets/key.txt; f; cat "$p"`) is #3562, deferred because closing it re-pins six #1554 cells from a question to a refusal; (e) a `source` inside spliced text of a file that text wrote keeps splicing on the next pass, within the depth limit — only the retained `source` segment carries `LexedSegment.sourced`, the never-again mark (the first cut guarded on `spliced` and dropped `echo 'echo "cat secrets/key.txt" > inner.sh; . ./inner.sh' > outer.sh; . ./outer.sh` to an ordinary question; codex astra r1); (f) a call or a loop head INSIDE spliced text is a may-have-run kill too — `p=secrets/key.txt; cd ..; printf 'f(){ p=ok.txt; }; f\n' > /dev/null; . /dev/null; cat "$p"` kept the protected path on the bypass seat as the first cut's certain kill wiped it (codex astra r2); a call or loop head the text itself writes keeps the certain-unknown reading (#3562). **Narrowing — open to veto (@cli @server):** a spliced rebinding of a protected value to an open one (D4: `p=secrets/key.txt; cd ..; printf 'p=ok.txt\n' > lib.sh; . ./lib.sh; cat "$p"`, which bash runs reading `ok.txt`) and a spliced move away from a protected place (D6) are refused on both seats (pins D4 / D6 / N4: the bypass seat refuses, the default seat refuses rather than asks — the spliced rebinding is one more value and the protected value stays the floor) — the station cannot prove the literal ran; and a protected value read after an `eval` / `source` / call that may have rebound it is refused where v7.65.0 let it run (a deny floor, not a vouch). **Rules.** +2 bits (`spliced`, `sourced`), +1 parameter (`kill(…, spliced)`), −0 conditions (no device exclusion, no spliced-move clause); the floor law of #3536 now also governs an unread text's rebinding — one law, one more site, no new one (kills: #3562).
40
+ - **Fixed within this window (legC astra on 7ab4634f0; #3576 and #3566 by one rule).** The first cut read a call to a function as a certain kill of every name its body binds (#3562), whatever the body's own certainty — so a definition that came in as SPLICED text (it may never have happened) and a `local` the retained `source` segment made a builtin that may not run (`prefix`) both lost the outer name's deny floor at the call: `printf 'f(){ local p; p=ok.txt; }' > /dev/null; . /dev/null; f; cat "$p"` ran on 7ab4634f0 and was refused on 0715168f4 (the regression), `printf 'f(){ p=ok.txt; }' > /dev/null; . /dev/null; f; cat "$p"` ran on both (#3566). Now a call kills certainly only what the bodies certainly bind; a name a body MAY have bound (a `prefix` binding, a binding in spliced text) is one more value the name may hold — the #3536 law at the call — and the floor stands (pins D13 / D14 / D15; `functionMaybeBound`). One rule, no second one: a spliced `local` stays unrecorded (detached) and the may-bound reading at the call covers it (pin D16: a name the body also binds certainly is killed as certain). **Known limit (KL-3562-a, pre-existing on both trees):** a call still kills as certain every name ANY function body binds certainly — the call does not name its body — so an assignment inside a body that never runs removes the deny floor (`g(){ p=ok.txt; }; f(){ :; }; f; cat "$p"` runs on the bypass seat on 0715168f4 and here alike; the default seat asks). Same lever as #3562; fixed with it.
41
+ - **Narrowing — seven forms (open to veto, @cli @server).** On the bypass seat each of E1 (`read 'a[$(f)]'`), E2 (`export -f f; … bash -c f`), S1 / S2 (`. ./lib.sh` / `source lib.sh` of a file this command wrote), H1 / H2 (`while read -r p; do cat "$p"; done <<< FILE` / `<<EOF`) and H3 (`read -r p <<< FILE && cat "$p"`) is refused `read_boundary` before the program runs where v7.65.0 ran it with the protected bytes; on the default seat each is refused where v7.65.0 asked. The controls (an exported function never called, a subscript running a body that reads an open file, a sourced body reading an open file, a bound line naming an open file, a bound line printed rather than opened) answer as before. Widening: none.
42
+ - **Rules.** Callers: +0 (two more texts join the one set). Sourced text: +0 rules of reading (the literal's segments are read by every existing reader; `source` of a file the command did not write stays what it was — text run in this shell that the station does not hold). `read`: +1 (the plain-form binding), the loop's `done` redirection feeding its members is the group-input reading extended to loops (+0).
43
+ - **Claude Code 2.1.316.** The reference reads `source` / `.` and a child `bash -c` as shell text by their words (cli316.js:270088) and binds nothing from `read`; this reads the written file and the bound line.
44
+ - **Known limits.** KL-3399-c (the `let` word counts whole: a substitution bash's evaluator would reject is one more question); KL-3401-b (descriptor closes and moves are not read: the loop's lines stay the candidates); KL-3400-a (bash's `sourcepath` PATH search of a bare `source NAME` is not read: the file this command wrote at that spelling is taken as the text; a write not immediately before the source — another segment between — splices nothing, nor does one reached through `||`, one the source is `||`-chained to, or one reached through `&&` with the source not `&&`-chained, so `printf … > lib.sh; echo x; . ./lib.sh` stays what it was); KL-3400-b (a child shell fed an unquoted here-document that has expansions is not read as a caller — the re-entry itself is the mandated question on both trees, so nothing runs unjudged); KL-3401-a (`read` with several names, `HOME`, `-a` / `-d` / `-n` / `-N` / `-t` / `-u`, an `IFS` bound anywhere, or a text that may arrive through a pipe or a file leaves the name unknown — not read, as before); KL-3399-a (an `export -f` AFTER the launcher that names the function is not that child's); a move INSIDE the caller's own text — `bash -c 'cd .. && f'`, `read 'a[$(cd .. && f)]'` — places the body since the next section (#3530).
45
+ - **Pins.** `test/backlog3399-3400-3401-body-runs-where-callers.test.ts` — thirteen forms × bash truth × two seats (E1–E4 / S1–S4 / H1–H5; base column = stage-7660 `0d7033794`, branch column = this tree). #3557 adds D1–D11 (the astra `/dev/null` form, a shadowed printer, a failed write, the accepted narrowings D4 / D6 / D8 / D9, a device move, a spliced protected value as control, D10 / D11 the unread-text law alone — a source of unwritten text, an eval of unreadable text), N1–N4 (the nested source, the `-` file name, a call inside spliced device text, a spliced call that did run — accepted narrowing) and P10–P12 (the `source` segment stays after its literal; a nested source keeps splicing; a `/dev/shm` write splices); base column for D1–D11 / N1–N4 = stage-7660 `0715168f4`. The two program-read-model equivalence corpora register the nine HOME forms whose name operand the text cannot settle under the allowed class `3557-may-have-run-unknown-keeps-floor` (`test/fixtures/program-read-model-equivalence*.allowed.json`).
46
+
47
+ ### A body a text calls runs where that text's own walk stands at the call — `bash -c 'cd .. && f'`, `eval 'cd .. && f'`, `echo "$(cd .. && f)"`, `read 'a[$(cd .. && f)]'` place `f` in the parent directory — and a `{NAME}` redirection prefix is read the two ways bash reads it (#3530 / #3533; behavior change; narrowing — four, open to veto; widening — one, open to veto; hard-breaking: none; closed sets: none; exports: none; members: +1 optional on a root-reachable type — `StdinText.allocated?: true`, read from the root as `ShellReadSegment.stdin[].allocated` (the lexer's own `LexedRedirect` / `LexedHeredoc` +`allocated?: true` are internal); wire: one additive optional member) (@cli @server @test @client-core)
48
+
49
+ - **Before.** (1) A text a segment hands a shell — a child shell's literal `-c` text or standard input, a literal `eval` text, a command substitution, an evaluated subscript, a launcher's command (`env -C DIR bash -c f`) — joined the callers set as the segment itself: the body it calls was placed where the segment stood, so a move inside the text before the call (`cd ..`, `pushd ..`, a second shell inside) did not place the body, and on the bypass seat `export -f f; bash -c 'cd .. && f'` with `f() { cat secrets/key.txt; }` ran with the protected bytes (cx-readb F4 C1 / C2; both trees since 7.62.0). (2) The `{NAME}` prefix (`cmd {fd}<<EOF`, `{fd}<<<w`, `{fd}>out`) was recognized by a word test beside the redirection reader: a here-document's prefix was missed (its body counted as the child shell's standard input under every bash), a word with a blank before the operator (`echo {fd} >out`, an argument to bash) was taken as a descriptor name, and a child shell's text was read one way only — bash ≥ 4.1 allocates a descriptor (≥ 10) for the prefix and passes no `{NAME}` argument, so `bash <<< f {fd}<<EOF` runs the here-string, while macOS's `/bin/bash` 3.2 passes `{fd}` as a word and redirects the operator's default descriptor, so the same command runs the here-document.
50
+ - **Now.** (1) A segment's handed texts are read through their own walk (`segmentRunsBody` returns which texts run a body, `src/tools/fs/shell-read-workdir.ts:488`; `textCallers`, `src/tools/fs/shell-read-plan.ts:565`): the place the body runs is where THAT text's plan stands at its calls — started where the segment stands, or where a launcher puts the child (`launchedAt`, the reading the child's reads already take) — and nested texts read the same way at any depth; a text the station cannot read leaves the segment's own place a caller, as before. (2) The lexer marks a redirection or here-document whose operator the `{NAME}` word immediately precedes (`allocated`, `src/shell/lex.ts:1920`); the word stays a word, and `namesRedirectDescriptor` (`:1091`) / `descriptorNameWords` (`:1096`) read that one bit. A text on an allocated descriptor is standard input to bash 3.2 only: it replaces no pipe and no loop's input (`stdinTextsOf`, `src/tools/fs/shell-reentry-text.ts:429`; `loopFeedOf`, `shell-read-plan.ts:331`), and a child shell's text is read under both readings — bash 3.2's argv and input, and bash ≥ 4.1's (no `{NAME}` argument, the allocated texts not its input) — every text either one runs is read (`reenterShell`, `shell-read-plan.ts:1120`, the call that hands it the allocated texts too; `segmentRunsBody`), as a command's environment is read both ways; the name the prefix spells is the descriptor (≥ 4.1, a number the text does not settle) or what it held (3.2) — a binding that may not have run (`prefix`, `src/tools/fs/shell-read-bindings.ts`), and the binding table's walk (`tableAt`) now goes on past an unknown binding that may not have run, joining what the name held as its deny floor (the section below, #3536, joined only known values: an unknown one that may not have run ended the walk, dropping every older value). A literal `eval`'s own substitutions — in its redirections or prefix assignments (`eval : <<< "$(f)"`, `x=$(f) eval :`) — run where the `eval` stands, read as any segment's, and an own text the lexer cannot read (`eval 'cd .. && f' <<< "${x:-$(f)}"`) makes the segment's place a caller without losing the eval text's.
51
+ - **Narrowing — four (open to veto, @cli @server).** (a) C1–C10 (`bash -c 'cd .. && f'`, `eval 'cd .. && f'`, `bash <<< 'cd .. && f'`, `echo "$(cd .. && f)"`, `read 'a[$(cd .. && f)]'`, `bash -c 'pushd .. && f'`, `bash -c 'cd .. && bash -c f'`, a here-document's `$(cd .. && f)`, `eval 'cd ..; f'`, `env -C .. bash -c f`, and X8 / X9, a literal eval text beside an own here-string or here-document the lexer cannot read, with `f` reading a denied path; X9's bypass seat refused it before as a mandated question): on the bypass seat refused `read_boundary` before the program runs where v7.65.0 ran them with the protected bytes; on the default seat refused where v7.65.0 asked (measured on v7.65.0 and on the stage base `716d35301`, the same letters). (b) D1 / D4 / D6 / D8 / D10 (`bash <<< f {fd}<<EOF`, `bash -s <<< f {fd}<<< :`, `bash <<< 'cat secrets/key.txt' {fd}<<EOF`, an inner loop's `done {fd}<<< ok.txt` under an outer loop fed the denied path, `printf f | bash {fd}<<< :`; and X4, `p=secrets/key.txt; cd .. && : {p}>/dev/null; cat "$p"`, where bash 3.2 keeps `p` and reads the file — a miss on both trees before for `>` / `<<<`, which already took the name as the descriptor alone; X7 the same with every segment certain). (c) X5, `p=secrets/key.txt; cd .. && true || p=$(echo x); cat "$p"` — an unknown binding that may not have run (behind `&&` / `||`, a prefix to a special builtin, in a block that closed) no longer drops what the name held: refused on both seats where the base and stage-7660 with the section below (`9567faa58`) ran it with the protected bytes or asked (both measured). (d) The permission rules' tightening reader takes the program bash ≥ 4.1 runs behind a `{NAME}` here-document prefix: `{fd}<<EOF chmod 777 x` is a run of `chmod 777 x` (the base read `{fd}` as the program, so a deny on `chmod` did not reach it), and a `{fd}` word with a blank before the operator stays an argument (`echo {fd} >out`; probe on both trees): refused on both seats under both bash generations — where the host's bash is ≥ 4.1, v7.65.0 ran them with the protected bytes (bypass) or asked (default); where it is 3.2, bash itself reads nothing (it runs the other text) and v7.65.0 ran them clean or asked: the refusal there is the cost of reading both generations (KL-3533-a).
52
+ - **Widening — one, against the section above (open to veto, @cli @server).** K5 (`export -f f; cd .. && bash -c 'cd sub && f'`, `f` reading `secrets/key.txt` relative to where it runs): the section above (#3399) places the body where the launching segment stands (the parent, where the path is protected) and refuses it; it now runs where the child's text moved it (`sub`, where bash finds no such file) — the bypass seat runs it (bash's own answer: nothing read), the default seat asks the mandated re-entry question. Against v7.65.0, which read no child text as a caller, K5 answers as it did (V / M, measured): the release widens nothing. A body's reads also stand where it is written, so `bash -c 'cd sub && f'` launched from the project root (K4) is refused before and after.
53
+ - **Rules.** #3530: +0 — the handed texts were already the callers set; their call sites are now read by the text's own walk, which replaces the segment's position as that text's caller (one reading, not a union). #3533: +1 — one lexer bit at the prefix (a here-document's included), read by every reader that asked the word test, which retires; "an allocated text replaces no inherited input" is that bit's one consequence in the two stdin readers, and the name it spells is a binding that may not have run (+0, the existing `prefix` reading); the walk's one reading — a binding that may not have run is one more value the name may hold — now holds for an unknown value too (+0): the special stop of `tableAt`'s walk at an unknown binding that may not have run (#3536) retires — X5, `p=secrets/key.txt; cd .. && true || p=$(echo x); cat "$p"`, ran with the protected bytes on the bypass seat of stage-7660 `9567faa58` and is refused now; past the reader's bound (`WORD_VALUES_MAX`) the held values are let go oldest first, each name keeping its newest, instead of all at once (`wordFloorValues`), so the values the walk now joins past such a binding never crowd out a newer one it joined before (X10: a 64-value loop variable, `true || p=$(echo x)`, `true && p=secrets/key.txt`, `cat "$p"` — refused on stage-7660 and here, run on the base). Two call sites move to the bit's reader: `src/tools/fs/shell-read-bindings.ts:835` (the name the prefix binds, now a binding that may not have run, above) and `src/core/shell-run-candidates.ts:214` (the word left out of a program's arguments, unchanged in meaning — the tightening reader takes bash ≥ 4.1's program, so a `{NAME}` here-document prefix no longer hides it).
54
+ - **Type face (additive).** `StdinText` (the element type of the root-exported `ShellReadSegment.stdin`, `src/tools/fs/shell-reentry-text.ts:385`) gains the optional read-only `allocated?: true` (`:391`) — present on a text opened on a `{NAME}` descriptor (standard input to bash 3.2 only), absent on every other text; nothing removed, retyped or made required. @cli @client-core @server: nothing to read today; a consumer that ignores the member sees the segment it saw before.
55
+ - **Claude Code 2.1.316.** The reference asks any `{NAME}` redirection whole as too complex to read ("fd-variable assignment", `cli316.js:265916`; its detector `Bt` at :265920 takes a blank between the word and the operator too), and follows a plain `cd DIR` without `..` only (`cli316.js:270088`, `Dqe`; its role read from the body — inferred); it places no function body. This reads both bash readings and the caller text's moves.
56
+ - **Known limits.** KL-3533-a (both readings: a command the host's bash would run one way is judged by the other way's texts too — one more refusal or question, never a missed read). Pinned as observed, not this change: a child shell reading the input a group's closing `}` names (`{ bash; } <<< f`, `cd .. && { bash {fd}<<< :; } <<< f`) — the group's input is not read as its members' standard input, pre-existing on both trees (its own ticket); `read -u 3 p 3<<EOF` leaves the name unknown (KL-3401-a).
57
+ - **Pins.** `test/backlog3530-3533-caller-text-moves-allocated-fd.test.ts` — the shell truth, the bypass and default seats on a real Runner, for every form under `/bin/bash` and, for the `{NAME}` forms, under `/opt/homebrew/bin/bash` when present; base column = stage-7660 `716d35301` (v7.65.0 the same but K5, V / M there), branch column = this tree: C1–C10 LEAK / M → R / R, K1–K3 controls V / M both, K4 R both, K5 R → V / M, D1 / D4 / D6 / D8 / D10 LEAK / M (≥ 4.1) or V / M (3.2) → R / R, D2 / D3 R both, X1 / X2 (a literal `eval`'s own substitutions) and X3 (a `{p}` here-document) R both, X4 / X7 LEAK / M (3.2) or V / M (≥ 4.1) → R / R, X5 / X8 / X10 LEAK / M → R / R, X9 A / M (the bypass seat's mandated question refused) → R / R, X6 control V / M both, D5 control V / M both, D7 / D9 / G1 observed; the lexer cells L1–L4 and planner cells P1–P4 red on the base.
58
+
59
+ ### A binding that may not have run before a reader is a value its name may hold — the read boundary judges it as the unknown name's deny floor instead of dropping it, so `cd <proj> && read -r p <<< secrets/key.txt; cat "$p"` (`;` or a new line between) is refused on the bypass seat (#3536; behavior change: narrowing — twelve forms that ran with the protected bytes on the bypass seat are refused before the program runs, and one form bash runs reading nothing is refused, open to veto; widening: none; hard-breaking: none; closed sets: none; exports: none; wire: none) (@cli @server @test)
60
+
61
+ - **Before.** The binding table walks the bindings before a reader newest first and joins the value of each one that may not have run until it reaches one that certainly ran (`BindingThread.tableAt`). Where it reached the name's unknown start, or an unknown binding, instead, the values it had joined were dropped with it: the name read unknown, the word reading it was unplaced, and no deny row was asked. So on the bypass seat `cd <proj> && read -r p <<< secrets/key.txt; cat "$p"` ran with the protected bytes (car-cx-readb-7660 F1, both v7.65.0 and stage-7660; the `&&`-chained `… && cat "$p"` was refused, the read being certain in its own run), and so did every binding of that kind: reached through `&&` / `||` and read in a later run, a `prefix` that may not take effect (a `read` with a redirection of its own — `2>/dev/null` — or a declaration through a launcher), one in a branch that closed, a `for` variable past its loop, a function body's own conditional binding. The `prefix` reading ("one more value the name may hold") and the #3401 entry above held only above a binding that certainly ran.
62
+ - **Now.** Where the walk ends unknown, every value it joined stays the name's deny floor (`BindingTable.floorOf` — the slot an array element's spellings already use — read by `tableAt` in `src/tools/fs/shell-read-bindings.ts`), and a text nested at the reader (a substitution body) starts with it. The reader's word stays unresolved: a floor is no binding — an open value grants nothing (the default seat still asks), a protected one is refused before the program runs. A binding inside a subshell that closed before the reader leaves no floor (it is no binding for that reader); a certain binding after the conditional one settles the name as before.
63
+ - **Narrowing — open to veto (@cli @server).** Refused `read_boundary` on the bypass seat where v7.65.0 and stage-7660 ran them with the protected bytes (and on the default seat where they asked; the basis is in the last sentence of this paragraph): a `read` reached through `&&` or `||` and read after `;` or on a new line, a plain assignment reached through `&&` / `||` and read in a later run, a `read` with a redirection of its own, an assignment in a branch that closed, a `for` variable past its loop, a substitution body or an input redirection reading the name, a function body's own conditional binding. Accepted over-read: `cd .. && false && read -r p <<< secrets/key.txt; cat "$p"` — bash never runs the read and reads nothing — is refused. The removal guard's card for a declaration that may not have run names the declared target: `env declare TMPDIR=/ ; rm -rf "$TMPDIR/usr"` answers the dangerous-delete card for `/usr` where it answered the unverifiable-target card (denied in every arm either way). Widening: none. Basis: the walk this changes (`BindingThread.tableAt`) is v7.65.0's — `git diff v7.65.0 716d35301 -- src/tools/fs/shell-read-bindings.ts` has no hunk in it — so a plain-assignment form reads on v7.65.0 as on the pin's base column (stage-7660 `716d35301`), and a `read` form reads there as an unknown name, which ran as well (v7.65.0 binds nothing from `read`, #3401); measured on both trees for the `;` and new-line `read` forms only (car-cx-readb-7660 F1), on `716d35301` for the rest — v7.65.0's the same by this reading, not run.
64
+ - **Rules.** +0 for the reading: the one existing reading — a binding that may not have run joins one more value the name may hold — now holds where the name starts unknown too, instead of a silent exception that dropped the joined values there. No `read` and no `&&` special case; a loop variable's hold through its body (`certainUntil`) is unchanged. +1 at the floor reader's bound (`wordFloorValues`, 64 spellings a word): past it, the values a binding that may not have run left (`FloorValue.held`) are let go first, so they never crowd out a floor a binding that ran left — an array element's spelling beside sixty-four conditional values is still refused (codex review; without it that element, refused on stage-7660, ran).
65
+ - **Known limits.** KL-3536-a (past the bound the conditional values are let go oldest first — each name keeps its newest, since the section above (#3533) — until the word fits, the name unknown as before; among them the values the walk joined past an unknown binding that may not have run, a certain one included; a word whose own binding floors (an array's elements) are past it too has none, as before — an array of more than sixty-four elements included). KL-3401-a corrected (a conditionally reached `read` is a value the name may hold — its deny floor — not a name left unknown). A function body's reader of a name the text binds only AFTER the body's text (`f(){ cat "$p"; }; p=secrets/key.txt; cd .. && f`) is still unknown with no floor: the walk does not visit later bindings (a separate ticket).
66
+ - **Pins.** `test/backlog3536-conditional-binding-held.test.ts` — twenty-two forms × bash truth × two seats (C1–C22, C21 / C22 the bound's two sides; base column = stage-7660 `716d35301`, branch column = this tree) and seven planner readings (P1–P7: the floor is deny-only and placed where the reader stands, the operand stays unresolved, every joined value, past an unknown binding, not past a certain one, not from a closed subshell, an open floor settles nothing). Re-pinned (#1554's removal cells): `test/backlog1554-where-the-command-stands.test.ts` `declare-through-env-binds-nothing` / `declare-past-a-failing-redirection-binds-nothing` — unverifiable → dangerous delete, denied in every arm as before.
67
+
68
+ ### A compound assignment's value is read as the scalar assignments its elements are — `args=("$@")`, `files=($x)`, `local A=("$@")`, `declare -A M=([key]=v)` are no longer the mandated "could not be read as shell" question, and `a=(${p@P})` / `a=(${!n})` are refused on the bypass seat as `y=${p@P}` is (#2156; behavior change; widening — one, open to veto; narrowing — three, open to veto; hard-breaking: none; closed sets: none; exports: none; wire: one additive optional member) (@cli @server @test @client-core)
69
+
70
+ - **Before.** The lexer kept a compound value `NAME=(…)` one opaque piece (`unresolved: "compound_array_value"`) and the readers asked one textual predicate of it (`compoundValueHidesRun`, v7.65.0 `src/shell/lex.ts:996`): a `$` other than `$'`, a backquote, or a `[…]` naming a variable anywhere in the value made the read station ask its mandated question with the card "the command's text could not be read as shell…", the deny lanes read a hidden run and auto-background kept the command in front. An ordinary parameter (`"$@"`, `$x`) or an associative key could therefore not be answered by an allowed `Bash` or by a rule, while the value's own expansions never reached the plan's reader: `a=(${p@P})` / `a=(${!n})`, whose value bash re-reads as text, ran unasked on the bypass seat.
71
+ - **Now.** The lexer records each element as the scalar assignment bash performs for it (`NAME=E` for an element, `NAME[k]=v` for a keyed one — the subscript closing where the scalar assignment's does, so `[x[0]]=1` keys `x[0]`; an element that is itself a compound value, which bash refuses, leaves the value unsplit), and one reading, `assignedWords`, hands every reader those words: the read station's unreadable reading and its plan's expansion reader, the arithmetic reader (a keyed element's subscript follows the text's bindings as `A[k]=v` does), the bindings table, the deny lanes and auto-background. The lanes ask the lexer's one word predicate (`wordHidesRun`) instead of a body of their own; the lanes and auto-background read an assignment subscript through one clause (`subscriptHidesRun`). A compound form answers on every seat as its scalar form does; a value the lexer could not split into elements still answers "may run anything".
72
+ - **Widening — one (open to veto).** Ordinary expansions in a compound value are no longer asked: on the default seat they are the classifier's ordinary question (an allowed `Bash` or a rule answers it), on a pre-approved seat they run — `args=("$@")`, `files=($x)`, `local A=("$@")`, `declare -A M=([key]=v)`, `a=($(printf x))` (its substitution is read and its program judged, a denied read still refuses), `a=([i]=v)` and `A=(${v:x})` (a name the arithmetic evaluator reads from outside the text vouches, as the scalar `a[i]=v` does — KL-994o / KL-994p ⑥). An element the old text predicate over-read is vouched as its scalar is (`A=(f[ab].txt)`, `C=($'\e[0m' x)`). The deny lanes read `local A=($x)` / `readonly A=(${P@Q})` as `not_reached` (a plain parameter and a respelling transform run nothing). @cli @server: the card "the command's text could not be read as shell" no longer appears for these forms.
73
+ - **Narrowing — three (open to veto).** (1) The bypass seat refuses `a=(${p@P})` / `a=(${!n})` before they run, as it refuses `y=${p@P}`; and every seat refuses a bare compound's keyed element whose subscript names a variable the text binds to a denied read (`x='b[$(cat secrets/key.txt)0]'; A=([x]=1)`, as `A[x]=1` refuses) — v7.65.0 asked it on the default seat and RAN the denied read on the bypass seat. (2) An element the lexer cannot decode asks as its scalar does: `A=($'\q' ok.txt)`, `declare -a A=($'\170' b)`, `C=($'\033' x)`, `C=($'\x1b' x)` (an ANSI-C escape outside the thirteen letters is not decodable, C-R80 C-1; FIX8 vouched these because the value was opaque). (3) A scalar assignment whose subscript the deny lanes read as a hidden run (`A[x]=1 cmd`, `` A[`id`]=1 cmd ``) now keeps the command in front of auto-background, as the compound form already did.
74
+ - **Rules.** Retired: `compoundValueHidesRun` (the value's text predicate), the lanes' own word body, the bindings table's own compound split. Added: one element record in the lexer and one reading of it (`assignedWords`); the word predicate (`wordHidesRun`) and its subscript clause (`subscriptHidesRun`) are the lexer's, beside `expansionHidesRun`.
75
+ - **Type face (additive).** `AssignmentFact` (reached as `ShellReadSegment.argv[].assignment`) gains an optional `elements` member, present only on a compound value the lexer split: each element's word and the scalar assignment word it is read as. No member is removed or retyped; a compound value the lexer could not split keeps `unresolved: "compound_array_value"` and no `elements`. @server @cli @client-core: nothing to read today.
76
+ - **Claude Code 2.1.316.** The reference parser reads an array assignment's value as words, each element a word of its own (cli316.js:294902); this reads each element as the scalar assignment it is.
77
+ - **Known limit.** KL-994p ④ (rewritten): an integer attribute's value (`declare -ai A=($'\170')`, `declare -i A=$'\170'`) is still not evaluated by auto-background, and the deny lanes read the compound form by its whole text (conservative) and the scalar one `not_reached`.
78
+ - **Pins.** `test/backlog2156-2144-compound-value-and-removal-cwd.test.ts` C1–C4 / H1–H5 / S1–S4 / S6 / D1–D7 on three seats and the eleven-spelling equivalence cell (the v7.65.0 column read on that tree; eleven rows change: C1–C4, H1–H5, D5, D7); re-pinned per form to its scalar's reading (reason in each cell): `test/backlog994-s2-one-lexer.test.ts` FIX8 block (with the keyed-subscript and bounded-nesting cells), `test/backlog7300-shell-reentry.test.ts` (`A=($'\q' package.json)`), `test/backlog1102-read-station-semantics.test.ts` K-8 (`a=('b[$(cat …)0]'); echo "${a[0]}"` vouched again; the scalar spelling's environment-face refusal pinned beside it).
79
+
80
+ ### A removal's start directory stops being one of its working directories once the text proves the session's own shell left it — `cd <ws> && rm -rf <ws>/x`, the session standing in `<ws>/x`, is no longer the mandated dangerous-delete question (#2144; behavior change; widening — one, open to veto; hard-breaking: none; closed sets: none; exports: none; wire: none) (@cli @server @test)
81
+
82
+ - **Before.** The removal judge counted the call's start directory among the working directories of every removal in the text, even after a `cd` the text runs had moved the session's shell away: removing that directory from its parent (`cd <ws> && rm -rf x`, `cd <ws> && rm -rf <ws>/x`, `{ cd <ws> && rm -rf x; }`, `cd <ws> && (rm -rf x)`) was the mandated "would remove a workspace directory" question, refused on the bypass seat.
83
+ - **Now.** The start directory is a working directory of a removal unless the working-directory thread the read station already walks proves that the shell running the removal stands elsewhere — outside the start directory, neither it nor beneath it, by spelling and by the environment's canonical path (a link may lead back; a directory the environment cannot resolve, or no environment seated, proves nothing) — and is the shell the session goes on in — not a background job, not a text another shell runs (`bash -c '…'`; a nested plan keeps the start directory). A subshell's or a pipeline member's move does not move the session's shell (the walk keeps its place); `cd <ws>; rm -rf x` keeps it (the move may fail). One judgment per removal (`removalSeatAt`) over the walk the station already computes; the departure is proven through the resolver the judge already asks for the home (`ExecutionEnv.canonicalPath`); no new working-directory reading.
84
+ - **Widening — one (open to veto).** The four forms above run without the question, and so does a move through a link that leads outside the start directory; the session goes on in the directory the text moved to. With no execution environment seated (nothing resolves a path) the start directory stays a working directory: the four forms are asked as on v7.65.0. Still refused: `rm -rf <ws>/x` from inside it, `cd <ws>/x/child && rm -rf <ws>/x`, `cd <link to <ws>/x> && rm -rf <ws>/x`, `(cd <ws> && rm -rf x)`, `{ cd <ws> && rm -rf x; } & wait`, `cd <ws> | cat && rm -rf <ws>/x`, `bash -c 'cd <ws> && rm -rf x'`, `cd <ws> && bash -c 'rm -rf x'` (a text another shell runs keeps the start directory), `cd <ws>; rm -rf x`. @cli @server: the dangerous-delete card for these four forms no longer appears.
85
+ - **Claude Code 2.1.316.** The reference asks the same working-directory question (cli316.js:270072) and takes a removal's directory from one leading literal `cd X` joined by `&&` only (`Dqe`, cli316.js:270088-270089); this reads the station's walk, so it also follows a brace group's move and a move that is not the first command — divergence D-2144-a (registered; the operator may veto).
86
+ - **Known limit.** KL-2144-a: the directory the text moved into is not a working directory of its removal (`cd scratch && rm -rf ../scratch`), as on v7.65.0. KL-2144-b: the departure is proven before the text runs — a link the text itself builds back to the start directory and then moves through (`rm -rf <ws>/n && ln -s <ws>/x <ws>/n && cd <ws>/n && rm -rf <ws>/x`) is not seen (v7.65.0 asked it).
87
+ - **Pins.** `test/backlog2156-2144-compound-value-and-removal-cwd.test.ts` FP-a / FP-b / SUB-after / BRACE / OUT-link (v7.65.0 refuses, now runs), TP / TP-dot / TP-slash / TP-case / TP-alias / BACK-dash / BACK-tilde / BACK-old / BACK-cdpath / BACK-home / IN-child / IN-link / SUB / BG / PIPE / NEST / NEST-after / SEMI (refused on both), FP-c / FP-d / CTL / PIPE-rel (run on both), KL-2144-a (run on both), KL-2144-b (v7.65.0 refuses, now runs), and TP's default-seat card.
88
+
89
+ ### The origin clearances, their custody and the capture opt-out records are read and written through the governance store, and an erasure erases the custody of its entries' clearances; an engine whose backend carries a store refuses a control plane that still holds that store's records, and adoption removes the replica's copies once the carrier holds every one (#3484, #3463; ruled C-R1119 S2b, addenda 6 and 7; behavior change: for a backend that carries a governance store which is not the File store over the engine's control plane, these records now live in that store; narrowing — six, open to veto; widening — one, open to veto; hard-breaking: four, three sentences each below, open to veto — HB-2 (`listOriginClearances`), the capture record trio's retirement, the erasure carrier class (HB-6, type level), the clearance row's `custodyErased` (HB-6, type level, the row); closed sets: `STORE_FORM_REFUSAL_CODES` +1 (`memory.control_plane_strays`), `NON_GOVERNANCE_MEMORY_CODES` +1 (the same code, CONTROL-PLANE IO), `ERASURE_CARRIER_CLASSES` +1 (`clearanceCustody`); exports: −3, `markSessionCaptureOptOut`, `readSessionCaptureOptOut`, `listSessionCaptureOptOut`; members: `MemoryEngine.listOriginClearances` returns a Promise, `OriginClearanceRow` +`custodyErased?: true`, `MemoryErasureAttestation.residuals.carriers` +`clearanceCustody`; wire: one code added to a closed family, one optional row member, one attestation carrier key) (@server @dgx @cli @client-core @test)
90
+
91
+ - **Rule.** The last two record families of the control plane move onto the seat 7.64.0 laid down, under its one law: the origin-clearance account is the `origin-clearances` document and each clearance's custody text a `clearance-custody` object; a session's capture opt-out record is the `capture` object `<session>.json` (an occupant's own slot `<session>@<incarnation>.json`), minted through the same put-once reading as the pollution marker (`putControlObjectOnce`). With them no reader or writer of a control-plane record joins a directory name onto a control-plane path outside four places — the File store itself, the File backend over its own plane, the File layout's upgrade step, and the adoption verb — and a census pins that (`test/backlog3484-carrier-readers-census.test.ts`), which is what lets the adoption remove what it handed over.
92
+ - **Before.** In 7.65.0 the engine read and wrote `<its control dir>/origin-clearances.json`, `origin-clearance-custody/` and `session-capture-optout/` itself, whatever store its backend carried; the default capture carrier was the control-plane file trio (`markSessionCaptureOptOut` / `readSessionCaptureOptOut` / `listSessionCaptureOptOut`), synchronous. An erasure left the custody text of its entries' clearances standing (KL-3465-b). `adoptReplicaControlPlane` copied a replica's records into the store and removed nothing (#3478; KL-3465-c). `memoryGovernanceDurability` answered `"backend"` ⇔ the backend publishes a non-empty `controlPlaneRoot`.
93
+ - **Now.** The engine reads and writes the clearances and the capture records through `this.governanceStore` (the backend's `governance`, else the File store over its control dir) — for a File backend, and for a backend without a store, the same directories, names and bytes as before. The default capture carrier is that store's `capture` objects (`governanceCaptureRecordStore`, internal); `fileSessionCaptureRecordStore(controlDir)` keeps its name and is now the File store's `capture` objects at that directory — the same files — whose three legs answer Promises. `RunnerDeps.memoryCaptureRecordStore` is unchanged (an override seat beside the kind). A spawning ancestor's opt-out record is read through the carrier its plane keeps it in, in one order (`readAncestorCaptureOptOut`, `prepare-memory.ts`): ① a plane this run holds an engine over → that engine's carrier; ② the host's store for that plane (`RunnerDeps.memoryCaptureRecordStore`); ③ the File carrier at that plane, only when every plane this run holds keeps its records in the File store at its own control plane; ④ otherwise indeterminate. Adoption hands every record over first and then, only when nothing was refused, removes each replica copy that still reads back the digest it handed over (a copy that changed since is kept and refused; a removal that fails is refused; a re-run over an emptied replica answers `{ adopted: [], refused: [] }`); the receipt row and the `outcome` words keep their 7.65.0 meaning (#3478). The capture opt-out the delegation floor reads, `ToolExecuteContext.memoryCaptureOptedOut?: boolean | Promise<boolean>` (both forms were already in the type, `src/core/tool-spec.ts:1156`; 7.65.0 `:1155`), is now a `Promise<boolean>` on the default carrier — the 7.65.0 file trio answered a plain boolean (`engine.ts` defaulted to `fileSessionCaptureRecordStore(controlDir)`, whose `read` was synchronous). The tree's own readers take both forms (`prepare-inherited-gate.ts:785-787` forwards the answer and never folds it, `run-workflow-tool.ts:1346-1354`, `subagent.ts:5146`).
94
+ - **Narrowing — six (open to veto).**
95
+ 1. (HB-5) *An engine refuses a control plane that still holds its store's records.* Constructing a `MemoryEngine` whose backend carries a store that is not the File store over the engine's own control dir, while that dir still holds a governance document (a file or its journal) or a control object of any kind, throws `memory.control_plane_strays` (a store-form refusal; `detail.path` = the control dir; the sentence counts what stands by document and kind and names `adoptReplicaControlPlane`) — nothing is written. 7.65.0 opened such an engine, and every record in that dir was read by nobody. A dir that does not exist holds nothing and is not refused.
96
+ 2. (HB-6) *An erasure erases the custody of its entries' clearances.* For every resolved id a conflict did not keep standing, the clearance rows of that entry are marked first (`custodyErased`, with the time the erasure marked them, `custodyErasedAt`, the account's own; an inline text and the digest are dropped with it) and then each custody object is deleted — written once, and a name an erasure took does not come back: every update of the account deletes the custody object of every row it reads erased, so a move of an older writer's inline text that wrote it back at the same moment is undone by that same update (#3558, the section below); the attestation answers the class `clearanceCustody` (`removed` / `remaining`). A second erasure of the same entry removes nothing and leaves the row as it is. The row stays (who cleared, why, when, its events); its text does not: `listOriginClearances` answers that row's `entryText` as `""` with `custodyErased: true`, and a `clearEntryOrigin` that would resume it refuses `memory.origin_clear_unknown` naming the erasure. A pending row is not settled by the erasure. 7.65.0 kept the text.
97
+ 3. (A†, the session-account first read) *A session-account document still in the v1 key form is refused by its readers until the layout's upgrade converts it.* The conversion runs where it always has, in the File layout's adoption at mount, and now only when the engine's carrier is the File store over that dir (and in `adoptReplicaControlPlane`, before it hands the document over); the readers no longer convert on read. Cost, stated: on a control plane last written before 2026-09-11 and not yet mounted, a host that reads a session-account face before the engine's first mount gets `ControlPlaneCorruptError` instead of an answer — transient, the mount converts it. @server.
98
+ 4. (KL-3466-b retired) *A capture opt-out slot that stands as no readable object is not answered as a record that already stood.* A dangling link, a directory, an entry the store cannot read to tell: the mint answers that it could not be persisted (`unpersisted`, the pollution twin's answer since 7.65.0, #3466 narrowing 4), and the session still reads opted out. 7.65.0 answered `existed`.
99
+ 5. (Ancestry arm ④) *An ancestor whose plane's carrier this run cannot read is indeterminate.* A child's harvest whose spawning ancestor names a control plane this run holds no engine over, with no host store for it, while some plane this run holds keeps its records in a store other than the File store at its own plane, admits nothing ("the floor state is indeterminate and commits are suppressed fail-closed"). 7.65.0 read the File record at that coordinate — a file no carrier keeps.
100
+ 6. *A capture opt-out record is created owner-only (0o600)* — every File control object is (since 7.65.0, #3466 narrowing 3). 7.65.0 created it with the process umask (0o644 under the usual 022); a tool running as another OS user that read new records no longer can.
101
+ - **Widening — one (open to veto).** (HB-4) `memoryGovernanceDurability(backend)` answers `"backend"` ⇔ the backend carries `governance` (the File backend's is the File store over its own plane). Every record a consolidation reads now rides that store, the capture records its eligibility reads among them, so a backend that carries a store but publishes no `controlPlaneRoot` now admits `consolidation.multiNode` where 7.65.0 refused `config.memory_consolidation_replica_local`. Its one narrowing half: a host-built backend that publishes `controlPlaneRoot` but carries no store (none in core) now answers `"replica-local"`.
102
+ - **Hard-breaking — four, three sentences each (open to veto).**
103
+ - (HB-2) *What changed:* `MemoryEngine.listOriginClearances()` returns `Promise<OriginClearanceRow[]>` (it reads the store). *Who is affected:* a host that reads its answer without `await` — @server at `src/memory-operator-faces.ts:259-326` (the operator face's `listClearances`, which its note calls synchronous), `src/http/routes/memory-origin.ts:3 · :199 · :391` (the route that reads it in a synchronous `try`) and `src/http/server.ts:559` (origin/main `96a91d82`); none in the cli's or client-core's trees. *Compensation:* `await` it; the rows are the same rows.
104
+ - (The capture record trio) *What changed:* the package root no longer exports `markSessionCaptureOptOut`, `readSessionCaptureOptOut` and `listSessionCaptureOptOut`, and `fileSessionCaptureRecordStore(controlDir)`'s `mark` / `read` / `list` answer Promises. *Who is affected:* @server — `docs/core-consumption/LEDGER.json` carries the three as skip rows (`:11258`, `:11341`, `:12075`), `test/memory-capture-local-carrier.test.ts:36 · :178` imports and calls `readSessionCaptureOptOut`, and `src/plugins/store-backend.ts:842` hands core `fileSessionCaptureRecordStore(...)` (core awaits it; nothing to change there); the cli's and client-core's trees have no hit. *Compensation:* `await fileSessionCaptureRecordStore(controlDir).mark(sessionId, { at, reason, incarnation? })` / `.read(sessionId, identity?)` / `.list()` — the same files and bytes.
105
+ - (HB-6, type level) *What changed:* `ErasureCarrierClass` gains `clearanceCustody`, so `MemoryErasureAttestation.residuals.carriers` (a `Record` over the class) requires it. *Who is affected:* a host that builds an attestation itself — an evidence face of its own (none in the server's tree at origin/main) or a test double — and a host face run against `memoryBackendContract`, whose erasure clause now asks the ninth class too. *Compensation:* answer it `{ unverified: true }` and the engine answers it over the store its clearances live in, or count it yourself; `erasureStatusOf` reads a missing or unverified class as unproven.
106
+ - (HB-6, type level, the row) *What changed:* `OriginClearanceRow` gains the optional member `custodyErased?: true` — present on a row whose custody an erasure took, which `listOriginClearances` then answers with `entryText: ""` — so a projection of the row that accounts for every member by name has one it does not account for. *Who is affected:* @server — `buildClearanceRowWire` (`src/http/routes/memory-origin.ts:271`) and the face that guards it, `origin_clearance_row` (`src/trace/wire-projection-faces.ts:252-258`: `excluded: ["entryText"]`, `minted: ["custodyBytes"]`), both at origin/main `c672157c`: a core member that the projector does not forward and the face does not list in `excluded` breaks the face's keyset equation (`test/wire-whitelist-exhaustiveness.test.ts`) and, where the keyset guard reads this row, `tsc` (TS2344 — the server's own account of its guard, as for #3394 HB-1; this entry did not re-derive the guard's compile-time class); @cli @client-core only if one mirrors the row's type (Consumers below). *Compensation:* account for the member — forward it (`...(r.custodyErased === true ? { custodyErased: true } : {})` beside `custodyBytes`) or add it to the face's `excluded` column, one row of the guard's table either way — and read `custodyBytes` as 0 for such a row.
107
+ - **Consumers.** @server: HB-2 and the trio above; `OriginClearanceRow` gains `custodyErased?: true`, which your keyset guard on the clearance projection will name (TS2344; the fourth hard break above) — project it, and `custodyBytes` reads 0 for such a row; narrowing 3's transient refusal; a replica that ran over a store-carrying backend before this release holds records in its own control dir (any of the families) — run `adoptReplicaControlPlane(<that dir>, <the store>)` once before its first start on this release, or narrowing 1 refuses it. @dgx: narrowing 1 and the class `clearanceCustody` if you carry a store or build attestations. @server @dgx: a tool of your own that reads `ctx.memoryCaptureOptedOut` as `=== true` without awaiting it reads a pending answer as "not opted out" — `await` it (the effect is inferred: the member's only hits in the server's tree at origin/main `c672157c`, the cli's and client-core's are `memoryCaptureOptedOutNotice` comments, none reads the context member; dgx's tree was not scanned). @cli @client-core: no hit for the retired names; `custodyErased` if you mirror the row. @test — black box: an engine over a shared store with a stray `session-capture-optout/s.json` in its control dir is refused `memory.control_plane_strays` and writes nothing; after `adoptReplicaControlPlane` the dir holds no record and the same construction opens, and the session still reads opted out on every replica; erase an entry with a clearance ⇒ its custody object is gone, the row answers `custodyErased: true` / `entryText: ""`, a resume refuses `memory.origin_clear_unknown`; control: a File backend reads and writes `<control dir>/origin-clearances.json` and `session-capture-optout/` as before and is never refused.
108
+ - **Retired.** KL-3466-b (the two twin records read one damaged slot two ways; narrowing 4), KL-3465-b (an erasure left the clearances' custody; narrowing 2) and KL-3465-c (adoption copied and the capture readers still read the replica; both moved here).
109
+ - **Known limits.** KL-3484-a: each re-record leg of a clearance asks the account again right before it adds the entry back and refuses `memory.origin_clear_unknown` when an erasure took the custody meanwhile, but that read and the backend's add are not one step — an erasure landing exactly between them is undone (closing it needs a per-entry fence or a conditional add across backends). KL-3484-b: the adoption's removal re-checks the replica's copy, not the carrier's; a carrier object deleted between hand-over and removal is gone from both, deliberately — only an engine verdict deletes a carrier object, and keeping the replica's copy would hand it back on the next adoption.
110
+ - **Rules.** Retired: the engine's own spellings of the clearance and capture paths, the capture file trio, the session-account readers' conversion on read (the one converter is the layout's), the ancestry walk's File read at an arbitrary coordinate, and the adoption's keep-everything arm. Added: one reading of "this control plane is its own carrier" (`governanceStoreIsFileOver`: the same directory once resolved, or the same device and inode) asked by the strays judge, the layout's conversion and the ancestry walk; the adoption's removal phase; the erasure's custody step (one function, both lanes; it tries every matching clearance's object, an inline row's too); the re-record legs' one re-read of the account before each add (`clearanceCustodyErased`).
111
+ - **Claude Code 2.1.316.** No divergence of its own: the reference has no governance control plane (D-3407-a covers the seat).
112
+ - **Pins.** `test/backlog3484-control-plane-s2b-two-tree.test.ts` (21 cells, each red on 7.65.0 and green here but for three controls green on both: the clearance account and its custody in the carrier, and HB-2's Promise; the capture record in the carrier, its slot that stands as no readable object (narrowing 4), a File-backend control; the durability reading (HB-4), the strays refusal emptied by the adoption (narrowing 1) and a control, the adoption's removal of a handed-over capture record, a replica copy rewritten during the hand-over kept and refused; the custody erasure on both lanes and through a face that leaves the class out, a second erasure that leaves the row and its `custodyErasedAt` as they were, a pending erased row that does not resume, an erasure landing inside an in-flight clearance that is not undone, a row whose custody stood both inline and as its object, a control; the v1 session-account refusal (narrowing 3)); `memoryBackendContract`'s adoption clauses (a pass with no refusal empties the replica, a pass with a refusal removes nothing, a re-run over an emptied replica answers empty); `test/backlog3484-ancestry-by-carrier.test.ts` (arms ①–④ through `prepareMemory` and its harvest, one control); `test/backlog3484-carrier-readers-census.test.ts` (the four classes, the table's staleness, the census's discrimination; red on 7.65.0). Re-pinned to the carrier forms: `test/backlog3465-control-plane-carrier.test.ts` (C8 / C11 / C18 / C20 follow the removal law and narrowing 1; C20 still adopts, restarts and reads both markers), `test/design336-origin-clear-face.test.ts`, `test/design336-backfill-hardening.test.ts`, `test/design336-slice2-settlement-hold.test.ts`, `test/design383-capture-optout.test.ts`, `test/design383-capture-optout-rescan.test.ts`, `test/design511-capture-store-dual-form.test.ts`, `test/design511-session-memory-status.test.ts`, `test/backlog514-session-incarnation.test.ts`, `test/backlog1479-session-incarnation.test.ts`, `test/backlog900-governance-two-replica.test.ts`, `test/design178-v2b-erasure-evidence.test.ts`, `test/memory-layout-migration.test.ts`, `test/memory-projection-writeback-debt.test.ts`, `test/backlog1080b-writer-liveness.test.ts`, `test/backlog1080c-legs-and-undecided.test.ts`, `test/backlog1080d-leg-lifecycle.test.ts`, `test/backlog1080e-observation-edges.test.ts` (the File trio's calls go through `test/helpers/capture-records.ts`, which awaits `fileSessionCaptureRecordStore`).
113
+
114
+ ### A name an erasure took stays gone — every update of the clearance account deletes the custody object of every row it reads erased, so a move of an older writer's inline custody text that wrote an erased text back is undone by that same update (#3558; found by the 7.66.0 release review, leg B; ruled C-R1119 addendum 8; behavior change: an erasure's `clearanceCustody` answer holds for the store once the updates around it settle, and its `removed` counts the text its mark took whoever deleted the object; narrowing — one, open to veto; widening: none; hard-breaking: none; closed sets: none; exports: none; wire: no key added) (@server @dgx @test)
115
+
116
+ - **Rule.** Every update of the account — opening, marking or settling a clearance, `moveOriginClearanceCustodyOut` — deletes the `clearance-custody` object of every row it reads `custodyErased`: the rows its own callback read under the document's lock, or, when that update never ran (a put or the update failed before it), one more read of the account. The move's puts run before that read, outside the lock, so the read sees any erasure that completed in between; a row that still reads unerased there is marked later, and the erasure's own delete follows the put. The same rule finishes, at the next update, a delete an earlier one could not make. An erasure's `removed` counts each kept text its mark took once the object is gone — deleted by its own delete or already by an update that read the mark first.
117
+ - **Before.** In #3484 as first merged (unreleased; 7.65.0 never erased the custody, KL-3465-b) every update of the account put each inline text before taking the lock and dropped it from the row under the lock; an erasure that marked the row and deleted the object between the update's read and its put was undone by that put, the update then skipped the erased row, and the erasure had answered `{ removed: 1, remaining: 0 }` while the text stood as the row's `clearance-custody` object (an interleaving of the store calls; reachable on any account that still carries a row written before the text moved out).
118
+ - **Now.** The update deletes what it wrote back before it settles — also when its own callback refuses (a settlement of an unknown clearance), when a later put of the same update fails, and when a put publishes the name and then throws (the put's error is the answer). A resumed `clearEntryOrigin` whose tombstone mark could not delete (the engine goes on past that best-effort leg) has the delete made again by its settlement's update. Cost, stated: each account update makes one more delete per erased row — the rows of the clearances of erased entries, which the account keeps (it is append-only) — beside the read and write of the whole account it already makes.
119
+ - **Narrowing — one (open to veto).** An account update whose delete of an erased row's object the store refuses throws the store's error once every erased row was tried and after its own write landed — fail-closed: while the store refuses to delete an erased name, every clearance operation over that account is refused. Through `clearEntryOrigin` the call that throws is the settlement's update (the tombstone mark is best-effort and its refusal is passed over; the settlement deletes again and refuses), so the clearance does not answer done while the erased text stands. Before, no delete was attempted and the call settled. @server @dgx: a governance store whose `deleteObject` throws now surfaces through these calls.
120
+ - **Known limit.** KL-3558-a: a process that dies between the put and any read after it leaves the text standing under the erased row until the next update of the account (any clearance operation) or a replay of the erasure (by id) deletes it — the first erasure's answer was true when it was given.
121
+ - **Rules.** Added: one (an update deletes every erased row's object it reads). Retired: none. Not here: an erasure concurrent with the opening of a clearance on the same entry (#3559).
122
+ - **Claude Code 2.1.316.** No divergence: the reference has no governance control plane (D-3407-a).
123
+ - **Pins.** `test/backlog3558-custody-move-erasure-fence.test.ts` (16 cells; eleven red before this change and green here — the reported interleaving at the module and through the engine, the refusing update, the failing later put, the put that publishes and throws, the refused delete, one refused name that does not shield another row's delete, the resumed clearance whose mark could not delete, the erased name the store will not delete, the erasure's count when an update deleted first, and the next update that finishes a dead move's delete; five controls green on both — the reverse interleaving, an erasure between the put and the update, another writer's move, an interrupted move that re-runs, and KL-3558-a's replay).
124
+
125
+ ### A refusal for an ask nobody could answer says one thing about the durable park — after a park was attempted and failed, the refusal no longer also says "do not retry it in this session" (no approver) or "no durable approval gate is armed" (the approver answered `unavailable`) (#2158; behavior change: the model-facing refusal text in those two cells only; hard-breaking: none; closed sets: none; exports: none; wire: no key added) (@cli @test)
126
+
127
+ - **Before.** The base sentence of the refusal is minted by the ask resolver before the gate's deny exit knows whether a durable park was attempted for the call and failed, and it carried clauses that depend on that: the headless sentence said "do not retry it in this session", the `unavailable` sentence said "and no durable approval gate is armed". On a run with a park lane armed whose commit failed, the exit then appended the failed-park note ("a durable approval park was attempted for this call and could not be minted (…); with nobody to judge the call, that is why it stopped — it can be issued again once its park can be minted"). One paragraph said "do not retry" and "can be issued again" (no approver, park lane, commit fails), or "no gate is armed" and "a park was attempted" (approver answers `unavailable`, park lane, commit fails). A refusal a person gave while the park failed was never affected.
128
+ - **Now.** One mint for the base sentence of both causes, `unresolvedAskDenialMessage(cause, tool, question, parkFailed)` (`src/core/ask-origin.ts`, internal; the inverse `unresolvedAskQuestionOf` sits beside it and takes its stem from the same call). With no park attempt it is the sentence the resolver always minted, byte for byte — so a run with no park lane, and a person's refusal, read as before. When the deny exit finds a park attempted and failed, and the standing sentence is that refusal, it re-words the base over the very question the resolver quoted (an allow-rule note on the card included): the headless sentence without ", and do not retry it in this session", the `unavailable` sentence without " and no durable approval gate is armed". The failed-park note is then the only sentence about the park, so "do not retry" belongs to a run with no park attempt, "no gate is armed" to a run with no park lane, and "it can be issued again once its park can be minted" to a park that failed.
129
+ - **Behavior change (open to veto).** Only two cells change the text the model reads: no approver ∧ park lane armed ∧ commit fails, and approver answers `unavailable` ∧ park lane armed ∧ commit fails. The same refusal elsewhere (no park lane; a person refuses; the `delegation.ask_unresolvable` notice, which already followed `parkLaneExisted`) is unchanged. @cli @test: a probe that matches the old wording in those two cells mismatches.
130
+ - **Rules.** Retired: the two park-state clauses in the resolver's base sentences once a park failed; the `unavailable` arm's inline copy of its sentence. Added: one builder and its inverse, and the exit's one re-wording over them. The sentence's words are spelled once.
131
+ - **Claude Code 2.1.316.** No anchor for the park half: Claude Code's parked-permission takeover is worker-level (class `lS`, cli316.js:288862), with no durable park row. The headless sentence with no park attempt is the reference implementation's, unchanged.
132
+ - **Known limit.** KL-2158-a: the refusal of an intercepted inherited approval (`prepare-ask-lane.ts:242`) is not that template; if its call also had a park attempted and failed, its "no durable approval park is available" and the note still sit in one paragraph.
133
+ - **Pins.** `test/backlog2158-unresolved-refusal-park-state.test.ts` (cells A–E for the five causes, B′ for a multi-line question, F1–F3 for the builder and its inverse); mutations M1–M8, each red in the cell it names.
134
+
135
+ ### Inside a Runner task the delegation tool registers its background children in the registry the run reads — the one its leg end, TaskStop, ListAgents and teardown read; `background.registry` is optional and the out-of-task fallback only, and inside a task an option naming a different registry is refused at spawn, `config.invalid_task_registry` (#2280, KL-2160-d retired; ruled C-R1143; behavior change; narrowing — one, open to veto; widening: none; hard-breaking: none; closed sets: none — one new thrown code, `config.invalid_task_registry`, of the `config` class its prefix names (no registered set enumerates the delegation tool's spawn refusals; its sibling `config.invalid_checkpoint_store` is in none at that site either); exports: none; members: `SubagentToolOptions.background.registry` required → optional, +1 optional runner-filled `ToolExecuteContext.taskRegistry`; wire: none) (@server @cli @client-core @test)
136
+
137
+ - **Before.** The registry was the one member of the delegation tool's `background` bag that never looked at the run executing the tool: the owner reads `ctx.taskId ?? background.owner` and the checkpoint store `ctx.checkpointStoreForChildren`, but the children were always registered in `background.registry`, while every reader of the run reads the engine's one registry (`defaultTaskRegistry`). A host that wired a registry of its own got background rows no reader of the run sees: on a `multi_tenant` tree the leg end's owed-delivery reading (#2160, the cross-boundary rule) missed a child that had read beyond the device, so the next leg's device `Bash` ran without a person (test core756r1b ④); the run's TaskStop and ListAgents could not find the child; and the parent's end could not stop it, so a turn-scoped child kept running past its parent.
138
+ - **Now.** The engine hands the delegation context the registry its readers read, `ToolExecuteContext.taskRegistry` (Runner-filled, never a model or tool argument), and the delegation tool reads its bag once at the call's entry: the children live in that seat inside a task; outside one (a direct `execute`, an operator resume, a second simulated process) in `background.registry`, else `defaultTaskRegistry`. An option naming the run's own registry (the server's wiring) is accepted as before.
139
+ - **Narrowing — one (open to veto).** Inside a Runner task a delegation tool whose `background.registry` is a registry other than the run's is refused at every spawn: the call answers an error result with the sentence "background.registry is not the registry this run reads …", the child is not started, and the thrown value carries `code: "config.invalid_task_registry"` (the sibling of the bag's `config.invalid_checkpoint_store`). What a host that drops the option gets is what the server's wiring already had: its background children are the run's, so the spawner's end stops a child still running then (a grandchild never outlives the child that spawned it); a child meant to outlive the turn is declared session-scoped (`TaskSpec.backgroundScope: "session"`, direct children of that run). @server: none — `src/capabilities/scenarios.ts:319-320` passes `defaultTaskRegistry`, which is the run's. @cli @client-core: no delegation tool is constructed.
140
+ - **Rules.** Retired: the registry member's own reading (the one bag member read without the run). Added: one entry reading of the children's registry (`delegationRegistryOf`, beside the bag read once — the bag itself is never copied, so a host's class-written bag keeps its prototype members) and one refusal, the shape the checkpoint-store member already has. Every background registry read of the call is of that one value (the fork lane, the background lane, the entry-cap pool, the session reap hook, the parked lane's sink, the steer resume's registry).
141
+ - **Consumers.** @server: zero change; a host that wants children outside the run's registry runs the tool outside a task. @test (black box): the cross-boundary cell with a host registry of its own — on 7.65.0 the child's read beyond the device runs and the next leg's device `Bash` runs without a person; now the spawn is refused and nothing reads beyond the device. Same-shaped `registry` inputs remain on `createTaskStopTool` (`TaskToolOptions.registry`), `createMonitorTool` (`MonitorToolOptions.registry`) and the shell band (`src/tools/fs/fs-bash.ts:1020`) — engine-mounted with the engine's registry, a separate ticket.
142
+ - **Claude Code 2.1.316.** One session task table: a task is registered into and updated in the session state's `tasks` map through the same state setter (`cli316.js:267047`, minified names; the register / update reading is inferred), so there is no second registry for an agent to land in. Divergence D-2280-a (registered; the operator may veto): the reference refuses an in-process teammate that would spawn a background agent and a teammate that would spawn another teammate (`subagent_teammate_background_denied` / `subagent_nested_teammate`, `cli316.js:277006`), so it has no background grandchild that outlives its spawner (inferred from the two refusals); this engine allows the spawn and binds the child to its spawner's lifetime (C-R1143).
143
+ - **Pins.** `test/backlog2280-delegation-registry-seat.test.ts` — direct execute, seat present: option left out / explicit `undefined` / the run's own registry (control) / a different registry refused; seat absent: a registry of its own (control, a second process) / left out ⇒ the engine's registry; real Runner: left out ⇒ the row is where the leg end reads and the parent's end stops the child / the engine's registry (control) / a registry of its own refused, no child started. `test/backlog2159-cross-boundary-bit-on-run.test.ts` "#2280" — left out ⇒ the next leg's device `Bash` is a person's; a registry of its own ⇒ no read beyond the device runs. A class-written bag (prototype `notify` / getter `scope`) launches in the background inside and outside a task. 7.65.0: 11 of the 16 new cells red; the three controls and the two class-bag cells green. Re-pinned (the cells rode the split — on 7.65.0 the same cells are red when the bag names the engine's registry, the server's wiring): `test/rb375-a2-descendant-terminal-anchor.test.ts` PIN ① / ⑦ (a grandchild outliving its spawner) → ①′ the spawner's end stops it and its terminal reaches the root run / ⑦′ a session-scoped middle child, the grandchild stopped at its end, the terminal reaches the root session's next run / ①″ the private-registry wiring refused; `test/backlog1599-delegate-auto.test.ts` ⑥b and `test/backlog1602-child-scope.test.ts` ① (background child parking after the parent's run), `test/backlog2181-delegated-child-parent-session-rules.test.ts` and `test/backlog2208-session-rules-children-read-live.test.ts` (a looping background leg) — session-scoped children, and at depth 2 the middle leg waits for the grandchild; 50 files drop the bag's registry, and the cells that run the tool outside a task keep a registry of their own.
144
+
145
+ ### The assistant reads its principal inbox — under `principalInboxConsumer: { assistant: "<handle>" }` the leg that runs as that handle mounts an external `ReadInbox` over the scope's principal inbox, and the inbox is read only through it: no letter arrives at a turn boundary (#2637; ruled C-R1149 K10 and its addendum (a)–(e); behavior change: an assistant deployment's letters become readable on the assistant's leg; hard-breaking: none; closed sets: none registered (the wire manifest lists `ReadInboxToolOptions.coversPrincipalInbox` +`"pullOnly"`, additive); exports: none added or removed; wire: one root-exported option widened) (@server @dgx @cli @client-core @test)
146
+
147
+ - **Before.** An assistant deployment declared its consumer and no leg of the engine consumed the box: the lane's predicate (`terminalsDrainPrincipalInbox`) answered `true` for `"terminals"` only, the drain bound only on a leg with its own session box, and `ReadInbox` mounted only there, local, reading that session box. A letter the delivery gate minted for the assistant waited in `principal.inbox` with no reader in core (design/972b §8 S2 ①: the true prerequisite of a deployment's assistant ↔ digital-person inbox).
148
+ - **Now.** One binding judgment per leg, `peerDrainLanesOf(deps, { sessionBox, hostTaskId, sessionId })` (`src/agents/peer-session-drain.ts:90`), read by both the drain bind (`src/core/runner/prepare-wiring-manifest.ts:751`) and the `ReadInbox` mount (`src/core/runner/prepare-delegation-surface.ts:305`): `"terminals"` ⇒ a `"drain"` lane on every leg with a session box (as before); `{ assistant: handle }` ⇒ a `"pullOnly"` lane on the one leg whose host task id (`rowTaskId ?? spec.taskId ?? sessionId`) is exactly `handle`, delegated or not, over a mailbox that declares cross-process safety, on a session id the peer address grammar accepts (the lane's queue and its host review face are seated by that address, as the session box is). A pull-only lane is claimed, settled and acked at every turn boundary like any lane, and its delivery half runs only on a `ReadInbox` pull (`peer-session-drain.ts:1087`); a delegated assistant leg drains no session box of its own (the drain's `sessionBox: false`, the delegated-child gate unchanged). On that leg `ReadInbox` declares `contentOrigin: "external"` and its description says the inbox is read ONLY through it and that its letters never arrive at a turn boundary (`coversPrincipalInbox: "pullOnly"`, `src/agents/read-inbox-tool.ts:39`). A held letter a person approves on that lane is handed over by the next pull, never by a boundary, and a card that leaves the queue without a decision (shutdown, eviction, an inject that throws) writes nothing to the box — the letter stays `held` for the next reader (Q3 A, unchanged).
149
+ - **No inbox count at the boundary.** The turn boundary does not announce how many letters wait on a pull-only lane (addendum (d)); the assistant reads on its own initiative, and a host that wants a wake continues the assistant's row (§13.4).
150
+ - **Widening — one (open to veto, @cli @client-core).** `ReadInboxToolOptions.coversPrincipalInbox` widens from `boolean` to `boolean | "pullOnly"`; `true` keeps its face byte for byte. Model-facing text changes on the pull-only leg only: its trailer reads "call ReadInbox again (letters in your principal inbox are read only here: none of them arrives at a turn boundary)" in place of "or they arrive at your next turn boundaries". The four repositories' `origin/main` read this option nowhere outside core (receipt).
151
+ - **Narrowing — one (open to veto, @server).** The consumer declaration is now read on a leg with no session box of its own (a delegated leg over a cross-process-safe mailbox), so a malformed `principalInboxConsumer` fails that leg's prepare too with `config.principal_inbox_consumer_invalid` (`detail.reason: "malformed"`), where 7.65.0 read it only on legs with a session box. A server whose boot already refuses a malformed value sees no change.
152
+ - **Consumers.** @server @dgx: the assistant's leg must run with `rowTaskId` or `spec.taskId` equal to `principalInboxConsumer.handle` (exact, case-sensitive); no leg in the server tree runs under that handle today (inferred from reading `origin/main`), so the configuration face is a ticket of the deployment's. A mailbox that does not declare cross-process safety, or a host session id outside the peer address grammar (`chat:42`; the session box's mount names that refusal as `config.peer_lane_unmounted` when a directory is wired), mounts no lane there (the same posture as the terminals' lane). @test (black box): the assistant leg pulls a gate-minted letter and the model reads it in the next request; a turn boundary on that leg never carries it.
153
+ - **Rules.** Retired: `terminalsDrainPrincipalInbox` and the two copies of the binding condition (bind site, mount site). Added: one binding judgment and one lane mode bit (`Lane.pullOnly`), with the drain's `sessionBox: false` as the second fact a delegated assistant leg needs (it cannot be left out: that leg has no session box to drain). Net −1.
154
+ - **Claude Code 2.1.316.** No anchor: the reference has no cross-principal inbox and no principal lane.
155
+ - **Pins.** `test/backlog2637-assistant-principal-lane-pull-only.test.ts` — real Runner: P1 (terminals control), P2 (the assistant leg's boundaries never carry the letter; the box is claimed; `ReadInbox` external, read-only-here wording), P3 (a pull reads it, `from-scope`), P4 (a delegated background child with `rowTaskId` = handle reads it and claims no session box), P5 × 5 not bound (another handle, a sync child, a fork child, the handle in another case, terminals on a delegated leg), P6 (a mailbox without cross-process safety), P10 (malformed declaration on a delegated leg), P11 (a session id outside the address grammar: the leg runs, no lane); drain: D1 (a decision between pulls is delivered at the next pull, not at a boundary), D2 / D3 (shutdown and eviction leave the letter `held`), D4 (an inject that throws in drain mode), D5 (acked after a pull), D6 (boundaries inject nothing), D7 (a drain with no lane is refused at construction); F1 (the two face texts).
156
+
157
+ ### A model entry's default thinking tier may be `off`, and every engine lane reads the one chain request > role > model default — a request that names no tier on a model whose default is off carries the explicit off (a Qwen chat template's `enable_thinking: false`), and a default that is not one of the seven tiers is refused where the model is received (#3394; ruled C-R1148, addendum 1; behavior change; narrowing — one, open to veto; widening — two, open to veto; hard-breaking: one, three sentences below, open to veto — HB-1 (type level); closed sets: none; exports: none; members: `Model.defaultThinking` takes the seven tiers (`"off"` added; `compat.reasoningEffortLevels` / `effortLevels` unchanged, six); `ResolvedRole.thinking` now includes the model's default; wire: no key added or removed — the manifest reads 0 type keys moved; the member's value type widens) (@server @ss @dgx @test)
158
+
159
+ - **Rule.** A model's default tier is `Model.defaultThinking`, the tier its requests take when neither the request nor its role names one, and it is read in one place: `resolveTaskModel` answers `ResolvedRole.thinking` = request > role > model default on both of its branches, and the run, a side query, a compaction pass and the next-prompt suggestions read that answer. `"off"` is one of its tiers — the request then carries the wire's explicit off where the wire spells one — and is not "no default": absence is no default, and a request with no tier anywhere writes no thinking key, so the provider's default governs. The member takes the seven tiers; the effort ladders a model declares stay the six enabled tiers, so off is never a rung the clamp compares against.
160
+ - **Before.** In 7.65.0 the member was typed with the six enabled tiers, so a model could not declare a default off (a host read off as "no model-level default"); the chain was spelled three times (`prepare-config-doors.ts`, `side-query.ts`, `compact-session.ts`); the suggestions pass read `ResolvedRole.thinking` for its role-resolved model, which skipped the model's default, and folded an explicit off into absence (on a default-on gateway it thought); a `defaultThinking` outside the seven tiers was read as no tier at all — every request on the provider's default, disclosed only as a `dropped` resolution on the trace.
161
+ - **Now.** `Model.defaultThinking?: ModelThinkingLevel`. The three spellings read `ResolvedRole.thinking`. The suggestions pass forwards the tier as resolved, off included, as the compaction lane's options builder already did. The default is clamped exactly like a request's own tier (`max` on a stock endpoint ⇒ `high`; `high` over a declared `["low", "medium"]` ⇒ `medium`) — a default outside the declared ladder is not refused, one reading of one value.
162
+ - **Narrowing — one (open to veto).** *A `defaultThinking` that is present but not one of `off, minimal, low, medium, high, xhigh, max` is refused at the model door* — `config.unknown_role` with `detail` `{ field: <the seat>, reason: "not_a_model_ref" }`, the sentence naming `defaultThinking`, the value and the seven tiers: a typo'd word, a number, `""`, `null`, a case variant (`"OFF"`), a list, an object. At a task's own model the task fails before any request; at a catalog entry it is a construction error of the `Runner` (and of `swapDeps`), like every entry the door judges. 7.65.0 accepted it and sent nothing.
163
+ - **Widening — two (open to veto).** (1) A model may declare `defaultThinking: "off"`, and a request that names no tier then carries the explicit off: on a default-on gateway it stops thinking. (2) `ResolvedRole.thinking`, a root-export answer, now includes the model's default (zero readers in the server's, cli's, client-core's and test's trees — the server's `resolveTaskModel` is its own); a host that appended `?? resolved.model.defaultThinking` gets the same tier.
164
+ - **Hard-breaking — one, three sentences (open to veto).** (HB-1, type level) *What changed:* `Model["defaultThinking"]` is `ModelThinkingLevel` ("off" and the six tiers), no longer the six enabled tiers. *Who is affected:* @server — `src/model-compat.ts:50-51` derives `ModelThinkingLevel = NonNullable<Model["defaultThinking"]>` and keys `THINKING_LEVEL_TABLE: Record<ModelThinkingLevel, true>` (six entries) by it, the same type that types `reasoningEffortLevels`, so it fails to compile (server's reading, 11-03; `src/model-compat.ts:42-43` at origin/main `96a91d82`); `web-admin-client/apply-effective.ts:37` derives the same type. *Compensation:* split the two types — the default takes `Model["defaultThinking"]` (seven), the ladder `NonNullable<OpenAICompletionsCompat["reasoningEffortLevels"]>[number]` (six).
165
+ - **Consumers.** @server: HB-1; your reading of `MODEL_DEFAULT_THINKING=off` as "no model-level default" (`config.ts:2118-2119 / :2204 / :2530`, `config-catalog.ts:558-563`, `web-admin-client/apply-effective.ts:37 / :72 / :123`, server's reading, 11-03) is the server half of dgx's ask: mint `defaultThinking: "off"` for it and the engine sends the off; the A2A `message/send` path already falls to this chain when it sends no `thinking`. @ss: the roster `ModelEntry` has no `defaultThinking` key today (the declaration face a roster or a `models.json` entry needs; ss 21.0.0 ticket). @dgx: a catalog entry you build for the brain sidecar may declare `defaultThinking: "off"`; one outside the seven tiers is now a construction error. @test — black box: a Qwen chat-template model with `defaultThinking: "off"` and a request with no `reasoningEffort` ⇒ the request body carries `chat_template_kwargs.enable_thinking: false`, a request with `"high"` ⇒ `true`, a model with no default ⇒ no `chat_template_kwargs`; `defaultThinking: "of"` on the task's own model ⇒ the task fails `config.unknown_role` before any request.
166
+ - **Rules.** Retired: the chain's three re-spellings, the suggestions pass's off-fold. Added: the model door's judgment of one member (the existing refusal, no new code).
167
+ - **Claude Code 2.1.316.** A per-model default effort exists: `Hcr` (`cli316.js:264811`) resolves a model's default as the user's setting or a remote flag, then the served capability `default_effort` (used only when it is an effort word the model supports, else the next source, silently), then a static table's `default_effort ?? "high"`; its effort set is `["low","medium","high","xhigh","max"]` (`cli316.js:260980`), with thinking off on a separate axis. Divergences: D-3394-a — the model default may be `off` (sema's one seven-tier knob, design/96); D-3394-b — a default that is not a tier is refused, not skipped (the bad-values-loud rule, #123).
168
+ - **Pins.** `test/backlog3394-model-default-thinking.test.ts` (19 cells: W1 the dgx case, W2 the qwen key and deepseek's disabled form, W3 a request's tier wins, W4 absence writes nothing, W5 the clamp, W6 off never a ladder rung and the read face lists no off; R1 / R2 the model default on both branches of `resolveTaskModel`, R3 role > model default and request > both, R4 none ⇒ undefined, R5 a side query sends the default off; S1 the suggestions producer forwards off, S2 the summarize-role model's own default reaches the pass, S3 the task model's default off reaches it; D1 a typo'd word, D2 six wrong shapes, D3 the seven tiers and absence received, D4 a catalog entry refused at construction, D5 a task's own model refused before any request). 7.65.0: 9 red (R1, R2, S1, S2, S3, D1, D2, D4, D5), 10 green (the W cells — off already reached the wire at runtime, only the type and the hosts' reading of it kept it out — R3, R4, R5, D3).
169
+
170
+ ### An extension can hand its own leg a prompt — `$.prompt.submit({ text })` enters the leg the way a person's typed input does, through the leg's one steer relay, under its own author word `extension`: screened, framed for the model as the extension's, never counted as the person's (#3539, #3284; ruled C-R1150 K1–K10 and addendum ①; behavior change: none for a deployment no extension of which calls `$.prompt.submit`, but for the two narrowings below; hard-breaking: four, below; closed sets: `InputAuthor` +1 `extension` (and registered); exports: +1 type `PromptSubmitAnswer`; wire: +2 optional members on `human_input` (`author`, `extension`); mods contract 8 → 9) (@server @cli @client-core @test)
171
+
172
+ - **Rule.** One input path, one author table. An extension's prompt is an input like the person's: `$.prompt.submit` reaches the leg's steer relay — the one `TaskStream.steer` and an observer's report run through — under the author `extension`, and every fact the engine knows about an input's author is one row of one table (`AUTHOR_ROWS`, `src/core/input-author.ts`) with three columns, each read by its own readers: `screened` (the prompt screen runs on it), `countsAsOperator` (the person's account, the durable park, the hold of a stopped run, the drain after it) and `frame` (how the model reads it mid-run). The relay raises `prompt.submit` once, `classic.UserPromptSubmit` in its bottom, under the caller's frames and origin, so the caller's own handlers stay out of both stations; what the screen lets through waits for the would-otherwise-stop seat (`later`) and starts a turn in the person's place.
173
+ - **Before.** An extension could not hand the leg a prompt (`$.prompt.submit` was "not callable on the engine bus in this version"). The author table was one set (`COUNTS_AS_OPERATOR`) whose one predicate also decided screening; an observer's report reached the model under the person's mid-turn header ("The user sent a new message while you were working:"); the `human_input` frames named no author; the steer relay's refusals rejected.
174
+ - **Now.** `$.prompt.submit({ text })` (declared in `uses.calls`) answers when the input is taken: `{ text }` (what entered — the caller's text or the screen's rewrite) or `{ drop: <reason> }` (the screen refused it, the run stopped on the person's own refusal and they have not spoken since, the run is not live, the call was cut before the input was taken, or no running leg takes a prompt here). It takes `{ text }` alone (any other member — `asUser`, `attachments`, `priority`, `inputId` — or an empty text throws a TypeError); a `/` text is a prompt. A call from a handler the leg is waiting on before it can take the input throws at once (a handler of the prompt's screen; any handler while the loop has not begun taking input — `session.start`, `classic.SessionStart`, `classic.SubagentStart`, the objective's screen), where the relay would otherwise wait on itself or out the 30 s birth window. The model reads it as `The extension "<name>" sent a message:` with the reference's own two facts (`cli316.js:261046-261048`). The `"queued"` and `"applied"` `human_input` frames carry `author: "extension"` and `extension: <name>`; an observer's carry `author: "observer"`. A child leg's extension submits into the child's own stream. `Runner.compactSession`'s `$` answers it unavailable. INTEGRATION-CORE §10.17.
175
+ - **Hard-breaking — four, three sentences each (open to veto).**
176
+ - (HB-1, type level) *What changed:* `InputAuthor` (`INPUT_AUTHORS`) gains `extension`, so a `Record` over it or an exhaustive switch on it lacks a row, and `HumanInputEvent["author"]` admits it. *Who is affected:* a host that tables the words itself — none in the server's (`c672157c`: one comment, `src/boot/runner-deps.ts:98`), the cli's (`ecfc687a`) or client-core's (`2e5f328`) trees at origin/main. *Compensation:* add the row; render `extension` as the extension's input, never the person's.
177
+ - (HB-2) *What changed:* the mods kernel contract is 9 (`KERNEL_CONTRACT_VERSION`); `loadModPackage` refuses a package that declares 8; the engine `$` (`EngineDollar`) gains the required `prompt` namespace (`prompt.submit`) and the leg facade's seats (`LegFacadeSeats`, reached through `ResumeRun.legMods.bindFacade`) the required `promptSubmit` entry. *Who is affected:* every mod package a deployment loads — @server reads the engine's number at load (`src/boot/deployment-mods.ts:111`), @client-core keys its kernel identity on it (`src/modsKernelIdentity.ts:129`); a test double that implements `EngineDollar` or builds the facade's seats itself. *Compensation:* re-declare `"contract": 9`; give a hand-built `$` a `prompt.submit` (or cast it, as such doubles do) — nothing else in a package's surface changed but the two pinned keys of HB-4.
178
+ - (HB-3, type level) *What changed:* the handler variant of `ModFrame` carries `event` (the event the handler runs on), minted at one place (`handlerFrame`, `src/core/mods/kernel/dispatch.ts`). *Who is affected:* a host or a test double that builds a handler frame itself — none in the three trees (client-core re-exports the type, `src/modsKernelTransit.ts:96`, and builds none). *Compensation:* carry the event's name.
179
+ - (HB-4, behavioural) *What changed:* `prompt.submit` pins `author` (`"operator"` at the four entrances, `"extension"` at `$.prompt.submit`) and `extension` (present only beside `"extension"`). *Who is affected:* a `prompt.submit` handler that hands `next` a payload it builds by hand instead of spreading `e` — the station judges a dropped pinned key as a change and its failure column refuses the prompt at that entrance; none in the three trees. *Compensation:* hand on `{ ...e, text }`.
180
+ - **Narrowing — two (open to veto).**
181
+ 1. *The hold of a run the person stopped holds every input that is not the person's.* After the person's bare refusal of a call and until they speak again, the steer relay refuses an input of any other author at entry (`{ drop }` for `$.prompt.submit`), and the drain holds what one queued before the stop (`isDrainable` reads `isOperatorInput` where it read "engine-minted"). An observer's report — the one other author the relay carried — drained past the hold before; the halt is the parent thread's (`isBareHumanRefusal` excludes a delegated child) and an observer's report enters a child, so no run is known to change (inferred).
182
+ 2. *An observer's report reaches the model in its own envelope, without the person's frame header.* The relay frames an input by its author's `frame` column; the observer's is the text as handed (its own `<observer-report>`-style envelope). Before, it wore "The user sent a new message while you were working:" (pin E13 is red on the base tree for exactly that).
183
+ - **Design correction.** The design's premise that `prompt.submit`'s bottom raises `classic.UserPromptSubmit` with empty frames does not hold at the four entrances: the bottom's context carries the frames of the chain's own handlers (`dispatch.ts`, the bottom's `fr`). The classic station is therefore raised under what the screen was raised under (the `$` call's frames and origin; nothing at the four entrances), the one reading K4 asks for, and the four entrances' behaviour is unchanged.
184
+ - **Consumers.** @server: HB-2 (re-declare your packages' contract); `humanInputEventData` (`src/trace/project.ts:2046`) whitelists keys and does not project `author` / `extension` — until it does, an extension's (and an observer's) input reads on your wire as an unattributed input; the relay's answer is internal (no package face). @cli / @client-core: render `human_input.author === "extension"` as the extension's message (`extension` names it), never as the person's; HB-2 / HB-3 for the kernel mirror. @test: E1–E14 below are the black-box judgments.
185
+ - **Claude Code 2.1.316.** The call's shape is the reference's (`bTo`, `cli316.js:269591`; the re-entry refusal `AMe`, `:272862`; the hold `Iet` / `_A`, `:269556` / `:269590`; the `later` tier `hWe`, `:269590`; the frame `:261046-261048`). Divergences D-3284-a…i (INTEGRATION-CORE §10.17): the author set (a); `asUser` refused (b); answered when taken, not at idle (c); the hold is the person's bare refusal (d); `/` not refused (e); `author` pinned (f); a later submit counts against the same run's turn cap (g); a child leg's submit passes the child's screen (h); a session-start handler's call refused (i).
186
+ - **Rules.** Added: one conditional arm (the re-entry refusal, two clauses of one fact) and two columns of the author table (`screened`, `frame`) — the one predicate that answered both "screened?" and "the person's?" is split, the six earlier words answering both alike (pin E14). New readers of existing rules, no new rule: the relay reads the stopped run's hold once at entry for every author that is not the person's (the rule the harness's lanes keep); the relay reads its `$` call's own cancellation at its one acceptance moment (a cut call takes nothing, screen or not); the relay's answer reads the verb's own `steering.*` refusals as `{ drop }`; the entry checks its argument form as every `$` entry does. Unchanged in count: the drain predicate reads `isOperatorInput` in place of "engine-minted"; the handler frame's two spellings are one mint (`handlerFrame`). Zero branches on the author word.
187
+ - **Pins.** `test/backlog3539-prompt-submit-s1.test.ts` (21 cells, real Runner but E14 / S1: E1 the extension's turn and frames; E2 another's classic block ⇒ drop; E3 the caller's own two screen handlers not raised, a rewrite named, the classic handler's origin; E4a–d the re-entry refusal at once from both screens, `session.start`, `classic.SessionStart`, `classic.SubagentStart`, and taken from `turn.start`; E5a / b dropped and named, never parked or on the person's account (E5b: a stopping run's `turn.complete` is not re-entry); E6a / b the hold; E7 the argument form; E8 `compactSession`; E9 `uses.calls`; E10 the child's own stream; E11 the turn cap; E12 the classifier's `[engine note]`; E13 the observer's frame; E14 the table's columns; E15 a call cut past its handler's budget takes nothing, no screen registered; S1 one handler-frame mint). Every cell is red on the base tree (the call is not there; E13 on the person's header); one mutation per cell, each killed. Re-pinned: `test/backlog3010-3011-mods-s4.test.ts` K1 (the `prompt.submit` row; contract ≥ 8), `test/backlog2941-input-author.test.ts` §0 (seven words).
188
+
189
+ ### The memory-consolidation driver's role-resolved chat and a mod's `$.model.complete` take the model's default thinking tier — the one chain #3394 made, read through `resolveTaskModel`, so an `off` default reaches both requests (#3535; ruled C-R1148, addendum 1; behavior change: the two requests name the model's default tier where they named none; hard-breaking: none; closed sets: none; exports: none; wire: no key added or removed)
190
+
191
+ - **Before.** #3394 pointed the run, a side query, a compaction pass and the next-prompt suggestions at `ResolvedRole.thinking`. Two more places call the brain on a bare `Model` and passed no `reasoning` at all: the consolidation driver's chat when the seat is read off the `consolidate` / `summarize` roles (`resolveMemoryConsolidationDriver`), and `$.model.complete` on a leg (`legFacadeSeats`, for the leg's own model and for a catalog model the call names). On a default-on gateway (a Qwen chat template) a request that names no tier thinks, so a model that declares `defaultThinking: "off"` still thought on both.
192
+ - **Now.** Both ask `resolveTaskModel({ model }, {}).thinking` — the answering model's own default, the chain's last link, since neither request names a tier and neither is a role seat — and hand it to the brain as the request's `reasoning` (absent when the chain gave none): an `off` default is the wire's explicit off (`chat_template_kwargs.enable_thinking: false`), a non-off default is that tier (clamped like any request's), and no default writes no thinking key, so the provider's default governs. For `$.model.complete` the model is the one that answers (a named catalog model's default, not the leg's). The explicit chat seat of the driver (a function, or an endpoint triple) holds no `Model`, so it has no default to read and is unchanged.
193
+ - **Cost note.** A model that declares a default above `off` (`high`, say) now asks for it on the consolidation distillation (one pass reads the whole library) and on a mod's completion — the tier the declaration says the model thinks at. A deployment that wants these two cheap declares the cheap model's default, or binds `roles.consolidate` / the named model to one that declares `off`.
194
+ - **Rules.** Retired: none. Added: none — the same one reader as the other lanes; a pin reads both files and refuses a second `?? model.defaultThinking`.
195
+ - **Known limit.** A role's own `thinking` (`roles.consolidate.thinking` / `roles.summarize.thinking`) is not read by the driver: `roleModelIfSet` hands back the `Model` alone. Tracked as #3542.
196
+ - **Pins.** `test/backlog3535-side-model-default-thinking.test.ts` (8 cells: D1 the driver sends the explicit off for an off default, D2 no default writes no thinking key, D3 a `high` default is on the wire; M1 the leg's own model, M2 a named catalog model's default governs and not the leg's, M3 no default writes nothing, M4 `high` reaches the wire; S1 neither file reads `defaultThinking` itself).
197
+
198
+ ### `hostOfUrl` is a root export — the one call-side reading of a URL every host rule judges on, so an enforcement point outside the engine reads a peer or egress URL as the engine does (#3544; web-admin QC1 [13004]; behavior change: none; hard-breaking: none; closed sets: none registered (the five unreadable reasons are the keys of the exported sentence table); exports: four added, none removed; wire: +4 root names, additive) (@web-admin @server @cli @client-core)
199
+
200
+ - **Before.** `hostOfUrl` (host lower-cased, an IDN in its ASCII form, trailing dots read off, or one of five reasons the URL names no host a rule can be judged on) was the engine's reading for the fetch tool, the permission-rule judges and the deployment host floor, and was not on the package root: `compileHostFloor` and `headerOwnershipCollision` were, this reading was not. A console that wanted to refuse a peer URL by the same host rules had to copy it, and a copy drifts on exactly the corners the reading exists for (`https://2130706433../`, an IDN, credentials in the URL).
201
+ - **Now.** The root exports `hostOfUrl`, `HOST_UNREADABLE_SENTENCE` (the sentence a refusal states for each unreadable reason) and the types `HostReading` and `HostUnreadableReason` — the module's own bindings (`src/core/host-target.ts`), re-exported, not wrapped: one function, one frozen table. A consumer states a refusal as `HOST_UNREADABLE_SENTENCE[reading.unreadable]`. Nothing about the reading changes.
202
+ - **Consumers.** @web-admin: its a2a peer-URL policy reads the host through the root name (QC1, the blocker for its car A). @server @cli @client-core: nothing to do; a copy of this reading in a tree can be replaced by the root name, and `HOST_UNREADABLE_SENTENCE`'s five keys are the closed set to switch over.
203
+ - **Claude Code 2.1.316.** No anchor: the reference has no host-rule engine of this shape.
204
+ - **Pins.** `test/backlog3544-host-of-url-root-export.test.ts` (5 cells: R1 the root's function is the module's own, R2 the root's table is the module's own, frozen, one sentence per reason, R3 each of the five reasons answers on one input, R4 the readable forms, R5 both types resolve from the root); `test/export-surface.snapshot.json` +4; `scripts/consumer-smoke-probe.mjs` registers `hostOfUrl` and `HOST_UNREADABLE_SENTENCE`.
205
+
206
+ ### The principal-inbox lane declaration is loud about every bad value — `principalInboxConsumer: { assistant }` must be an agent handle, and `ReadInboxToolOptions.coversPrincipalInbox` outside absent / `false` / `true` / `"pullOnly"` is refused at construction, both with `config.principal_inbox_consumer_invalid` (#3543; found by the second-pass counter-example batch of #2637, cases E2 / E6 / E7; behavior change: two narrowings, open to veto; hard-breaking: none; closed sets: none; exports: none added or removed; wire: no key added or removed) (@server @dgx @cli @client-core)
207
+
208
+ - **Before.** The declared handle was checked for "not blank" and nothing else, so ` a0123456789abcdef ` (padded), `A0123456789ABCDEF` and a 20 KB string were accepted: the leg ran, `ReadInbox` mounted local, no leg's task id ever equalled the handle so the lane never seated, the letters waited in `principal.inbox` and nothing said so — while `""` and a declaration with an extra key were refused with `config.principal_inbox_consumer_invalid`, two loudnesses for one declaration. And `ReadInboxToolOptions.coversPrincipalInbox`, whose closed set (`boolean | "pullOnly"`) lived only in its type, read `"PULLONLY"` (or any other word) as "covers nothing" on a root-exported factory a JavaScript caller reaches.
209
+ - **Now.** `principalInboxConsumerOf` reads the handle by the one shape gate of an agent handle, `DURABLE_AGENT_HANDLE_RE` (`src/core/task-registry-shared.ts:1145`, a root export): `a` and 6–32 lower-case hex digits, what the task registry mints. Anything else is refused with `config.principal_inbox_consumer_invalid`, `detail.reason: "malformed"`, in a sentence that names the shape and quotes the value at most 96 characters (a 20 KB handle is not echoed); it is read wherever the declaration already was read — the drain binding, the `ReadInbox` mount, the record mint. `createReadInboxTool` judges `coversPrincipalInbox` against its closed set where it receives it and refuses a word outside it with the same code and reason: the option is the tool face's copy of the principal-inbox lane declaration (the Runner's binding judgment sets it, never independently), so one subject takes one code. `RunnerDeps.principalInboxConsumer`'s contract sentence and `docs/INTEGRATION-CORE.md` §13.3 state the handle shape.
210
+ - **Narrowing — two (open to veto, @server @dgx @cli @client-core).** (1) A declaration `{ assistant: "<x>" }` whose `<x>` is not an agent-handle shape — for instance a top-level assistant leg whose host `spec.taskId` is an opaque deployment string such as `"asst-1"` — was accepted and seated the lane when the leg's task id equalled it exactly; it is now refused at the prepare of every leg that reads the declaration. `spec.taskId` itself stays opaque (nothing judges it); only the declaration is. Nothing in the tree declares such a value (every pin of #2637 and of the design/385 slice 7 uses a minted-shape handle), and the server tree declares none today (inferred, from the #2637 reading of `origin/main`). To declare an assistant, mint its leg's task id in the agent-handle shape (a registry-minted id already is). (2) `createReadInboxTool({ coversPrincipalInbox })` with a value outside the four now throws at construction; the Runner's own call and every typed caller pass one of the four.
211
+ - **Consumers.** @server @dgx: the assistant declaration you write must be an agent handle; a value you generate from a catalog id or a display name is refused at boot of the first leg that reads it, with the shape named. @cli @client-core: nothing to do — neither reads the declaration or the option.
212
+ - **Rules.** Retired: the handle's `trim() !== ""` check. Added: none — the handle is read by the existing agent-handle shape gate, and `consumerRefusal` (a module export, not a root one) is now the refusal both readers of the lane declaration throw. Net −1.
213
+ - **Claude Code 2.1.316.** No anchor: the reference has no principal inbox.
214
+ - **Pins.** `test/backlog3543-principal-inbox-declaration-bad-values.test.ts` (20 cells: U1 padded / trailing newline / upper-case / 20 KB through `principalInboxConsumerOf`, U2 the shape's edges, U3 the controls; G1 the same four through a real Runner's delegated leg, with the valid-handle control seating the external `ReadInbox`; K1 `"PULLONLY"`, K2 seven other values, K3 the four members' faces). On the base every refusal cell is red (17) and every control green; nine mutations are each killed (trim-only check, a loose regex, the whole-value echo, the wrong reason word, the face's check removed / case-folded / throwing a plain `TypeError` / refusing `false` / echoing whole).
215
+
216
+ ### A damaged scope registry or registry journal is the same fault as a damaged root anchor: the personal store is in the deployment's set, `stores()` throws `ControlPlaneCorruptError` and the session status answers the plane `fault` (#3531; behavior change: loudness only — a mount that used to open as a healthy store now says what it is; hard-breaking: none; closed sets: none; exports: none; wire: no key added) (@server @test)
217
+
218
+ - **Before.** The set counted a mount as holding a store when its anchor, registry or journal stood there damaged (`storeHoldsRecord`, #3360), but only the anchor was refused by the open (the File store's constructor reads it); the registry and its journal were read at the first transaction. So a personal mount whose `scopes.json` was not JSON (or an array, a version this engine does not read, a label that is no path segment) or whose journal was torn was in the set, `stores()` answered two stores without a throw, and the status said the personal plane was healthy while the first read of a scope threw (test [12971] G11.c; v7.63.0 and v7.65.0 alike).
219
+ - **Now.** One reading of "damaged" with one loudness: the census and the open read the same fault (`storeOpenArtifactFault` over `STORE_OPEN_ARTIFACTS.files`, `layout.ts`; `namedArtifactFault` is the census's reader returning the fault instead of a boolean). The deployment's personal store reads it before it constructs the store, on every call (the census reads the disk each time, so does this — a store opened whole and kept is refused the next time its registry is damaged), and throws it; `personalOpenFault` carries it as it carries the anchor's, so the status row is `optOutSource: "fault"`.
220
+ - **Narrowing (open to veto, @server @test).** A deployment whose personal mount holds a damaged registry or journal got two stores and a healthy row; it now gets the throw and the `fault` row, as it already did for a damaged anchor. A damaged named artifact is no longer a thing only a first read says.
221
+ - **Rules.** −1: the census's boolean and the open's constructor were two readings of the same artifacts; now one function returns the fault and the census asks whether there is one. Contract sentence `memory.deployment.store_set` says it (a store that cannot be opened — the damaged anchor, registry or journal that put it in the set is one such cause).
222
+ - **Claude Code 2.1.316.** No counterpart: the reference has no memory store set.
223
+ - **Known limit.** KL-3531-a: only the personal plane's open reads the named artifacts' fault; the project plane (the deployment's own backend, always in the set) still meets a damaged registry at its first read.
224
+ - **Pins.** `test/backlog3531-store-set-damaged-registry.test.ts` (A1–A5 five registry / journal forms, B1 anchor `{}`, C1 both, D1 whole beside a record, E1 the fault is the census's own, E2 whole artifacts have none, F1 a cached store refused after damage, G1 project-only untouched; A1–A5 / E1 / E2 / F1 red on stage-7660, the rest controls green on both) and `test/backlog3360-3361-store-set-damaged-artifact.test.ts` (the torn-journal cell now throws, where it used to pin the healthy open); mutations M1–M5, each red.
225
+
226
+ ### post-ship flips a ledger row under the release that first carried its fixing commit, not the release being posted — `rows[i].sha` (#3532; tooling only, no package surface: behavior change: none for the engine; hard-breaking: none; closed sets: none; exports: none; wire: no key added)
227
+
228
+ - **Before.** `scripts/post-ship.mjs` wrote every `manifest.rows` entry as `SHIPPED-UNVERIFIED core@<manifest.version>`; the manifest's one value was all the script knew of a row's release. A straggler flipped at a later release therefore carried that later number: 7.64.0's back-flip wrote `core@7.63.0` on five rows (#565 / #2810 / #2817 = v7.59.0, #1489 = v7.55.0, #1169 = v7.40.1), and the test's version-by-CHANGELOG mapping looked in the wrong release (test [12974] (iv)).
229
+ - **Now.** A row may name the commit that fixed its ticket (`sha`); the row is flipped under the first release tag that contains it (`git tag --contains <sha> --sort=version:refname`, release tags `v<x.y.z>` only), written as a back-flip (`补翻 [ship] / 首含 tag v<…> 含 <sha>`), and the run prints one `WARNING:` line naming the release it used when that is not the one being posted. The commit being an ancestor of `R` is only the existence check; a commit outside the release, one no release tag holds, a tag later than the release, and a `sha` that is no hex refuse the run before anything is written. A row without `sha` is this release's, as before. A back-flip row (one this release's R car did not write) must carry its `sha`.
230
+ - **Rules.** The release of a row had one reading (the manifest's version) and now has one derivation (the commit's first tag); a row without a commit keeps the old reading.
231
+ - **Known limit.** KL-3532-a: a row without `sha` is still written under the release being posted; the script cannot tell which rows are back-flips.
232
+ - **Pins.** `test/post-ship-script.test.ts` S1–S7 (real git fixture: three commits, tags `v7.2.0` / `v7.9.0` / `v7.10.0`, a draft tag and a package tag at the first; the oldest by version order not name order; outside / untagged / no-hex refused with nothing written; a row without `sha` unchanged); mutations M1–M6 (name order, no tag filter, no ancestor check, newest tag, no warning, `sha` ignored), each red.
233
+
234
+ ### The account of a restricting table the host owns and the engine never reads — `retiredToolNameAccount`, the sentence and the data of `config.legacy_tool_name` for the entries that name a tool the engine retired with no successor, by the engine's own judgment and in the engine's own words (#3528; additive: one root export; hard-breaking: none; closed sets: none; exports: +1 `retiredToolNameAccount`; wire: no key added) (@server)
235
+
236
+ - **Before.** `config.legacy_tool_name` (audience `user`, minter `engine`) said a retired no-successor name in a tool policy's deny / ask list was left out and the run went on (7.65.0, #3437). Its sentence and data lived in `runner/sub-agent-deny-lists.ts` as the engine's mint, and `judgeRuleToolName` (root export) judged the name — but a restricting table the engine never reads, `settings.permissions.neverAuto` (the server's own), had no way to say the same thing in the same words: a host had to re-spell the judgment (kind `retired` and no `currentName`) and the sentence, a second reading of one fact.
237
+ - **Now.** `retiredToolNameAccount({ field, source, entries }, roster?)` (root export; `src/core/retired-host-table-account.ts`, beside `retired-tool-name-account.ts` which holds the words) reads the names with the engine's own entry reader and asks the engine's own question of each answer (`compileAllowList`, then `isRetiredLeftOut` — the one predicate the engine's task lists and skill tables ask) and returns `{ message, detail: { layer: "host_table", entries: [{ field, entry, layer, guidance, source }], total } }`, or `undefined` when the table holds no retired no-successor name. It is pure data and words — no code, audience, minter or session: the host mints its own `config.legacy_tool_name` notice (minter the host) from it, adding `sessionId` to `detail`, and decides what its table does with the entries. The engine's own mint (`retiredToolNameNotice`) now builds from the same `accountOfRetired`, byte for byte as before for its three layers; `layer` gains the word `host_table` (a layer the engine itself never audits). A renamed name, an unprefixed namespace and an unmintable segment are not in the account — the host refuses those as the engine does; `roster` names the tools the host knows are mounted, so a tool mounted under a retired name is its own, and a tool mounted under another case of it (`teamcreate` beside an entry `TeamCreate`) keeps the entry refused — the answer the engine's tables give for the same roster, not a second one. An entry is read as the engine reads a rule entry, so a spelling the reader reads as nothing (a name with blanks around it) is not a retired name, and `Name(content)` is read by its tool name. A table the account cannot be made for is refused loudly with a `TypeError` coded `config.invalid_argument` (no code added; the precedent is `redeemWorkflowParks`): `field` outside `deny` / `ask`, a `source` that is not a non-blank string (it names the table in the sentence), `entries` that are no list, a table that is no object — no sentence is made from them; an entry that is no string reads as nothing.
238
+ - **Rules.** +0: the sentence and the detail were one function's, now in one module (moved, not copied) and read by two mints; the account holds no judgment of its own — the reader and the predicate are the engine's — and the function sits in its own module because the module that holds the words cannot import the reader (import cycle through the skill table). The engine's policy audit is untouched.
239
+ - **Consumers.** @server: `settings.permissions.neverAuto` may call it with `{ field: "ask", source: "settings.permissions.neverAuto", entries }` and mint its notice (minter `server`); the table's other behaviour is yours.
240
+ - **Pins.** `test/backlog3528-retired-name-account.test.ts` R1–R7 + R8 (a roster case twin keeps the entry out of the account) + R9 (a bad `field`, a blank or non-string `source`, entries that are no list and a table that is no object are refused with the coded `TypeError`) (red on stage-7660 where the export does not exist); mutations M1–M7 (a renamed name counted, the roster ignored, `source` dropped, the wrong layer, no dedupe, a non-string reaching the judge, the bound moved) + M8 (the twin question dropped) + M9 (the `field` guard dropped) + M10 (the `source` guard dropped), each red; `test/backlog3437-retired-name-left-out.test.ts` unchanged and green (the engine's mint is byte-identical).
241
+
242
+ ### A tool the engine retired with no successor, named on a task's tool-name list or in a skill's `disallowed-tools`, is told as the notice every restricting table gives it — `config.legacy_tool_name` — and a skill that lists one activates (#3527; behavior change: a skill's activation is no longer refused on such an entry, and the task's list stops calling it a misspelling; hard-breaking: none; closed sets: none registered — `detail.layer` of the notice gains `task_selector` / `skill_table`, entries an optional `source`; exports: none; wire: no key added) (@server @cli @test)
243
+
244
+ - **Before.** A tool policy's deny / ask list that names a tool the engine retired with no successor (the retirement table's `removed` / `folded` lines) left the entry out and told it in one `config.legacy_tool_name` (7.65.0, #3437). Two other restricting tables read the same name two other ways: a task's tool-name lists (`excludeTools`, a definition's or a delegation tool's `denyTools`) kept the entry and told it as a possible typo ("no tool of this task answers to that name … If the name is misspelt, fix the entry", `onError`, no code); a skill's `disallowed-tools` read it as an entry that "reads as nothing" and REFUSED the skill's activation (`config.skill_deny_unreadable`, the run for a user-invoked skill). One input, three postures — and the person who wrote it believes it guards a tool in all three.
245
+ - **Now.** One posture, one reader's answer (`isRetiredLeftOut` over the entry reader's `tool_name` / `retired` / no `currentName`): the entry is kept and left out of the refusals, and told once as `config.legacy_tool_name` (audience `user`, minter `engine`) — for a task's lists `detail.layer: "task_selector"`, each entry's `source` the list that holds it (once per session for one set, as the advisory it replaces; the run's own list that the spawning run already told is not told again); for a skill `detail.layer: "skill_table"`, `source` the skill (in the place the "grants or refuses nothing" notice was told, per prepared task), and the skill activates (a carried deny record — a park's frozen row, a parent's capture — that the leg's roster reads this way still refuses the leg, as before: dropping it would lose the protection without a word). A name that was RENAMED (it has a successor: the entry guarded a tool that is still mounted) is refused as before; so is a name whose tool the deployment mounts under another CASE of it (`TEAMCREATE` beside `TeamCreate`: the entry was written for that tool, as the policy audit already asks); a tool a deployment mounts under the retired name itself is the tool's own (the entry binds, no notice); an allowed list keeps its advisory (it is no restricting table); a pool that cannot be listed keeps the advisory too (the name may be one of its own tools).
246
+ - **Widening — one (open to veto, @server @cli @test).** A skill whose `disallowed-tools` holds a retired no-successor name used to refuse its activation (and a user-invoked one refused the run); it now activates with its readable entries in force. What the entry meant to guard never existed (no tool answers to that name), so no protection is lost; a client that keyed on `config.skill_deny_unreadable` for this entry no longer sees it.
247
+ - **Rules.** −1: the skill table's refusal on a retired no-successor entry and the task list's typo advisory for the same entry were two postures for one fact; both are the one notice now (one predicate, `isRetiredLeftOut`, over the one reader's answer). The notice's mint moved with its sentence to `src/core/retired-tool-name-account.ts` (shared with #3528).
248
+ - **Consumers.** @server: the front-door 400 / 422 arms for a retired name on `excludeTools` / `denyTools` (S-3212) can be removed — the engine accepts the entry and tells it; render `config.legacy_tool_name` as for the policy table (the new `layer` words are `task_selector` and `skill_table`). @cli @client-core: the notice is rendered as the policy table's is, no change. @test: a skill whose `disallowed-tools` holds a retired no-successor name activates and yields one notice; `bash` (renamed) still refuses.
249
+ - **Claude Code 2.1.316.** The reference accepts a tool name nothing matches and never refuses on it (cli316.js:260988 region); this keeps the entry and says so, the superset D-3437-a already registered.
250
+ - **Known limit.** KL-3527-a: an allowed list and a pool that cannot be listed keep the misspelling advisory for such a name (the first restricts nothing; in the second the name may be one of the pool's own tools).
251
+ - **Pins.** `test/backlog3527-retired-name-restricting-tables.test.ts` — T1–T3 (own list / definition / delegation tool), T4 renamed control, T5 roster-mounted control, T6 once per session, T7 allowed-list control, T8 told-upstream, T9 case-twin control, T10 the once-per-session digest is of the whole set, S1–S2 (model / user activation), S3 renamed control (two renames), S4 roster-mounted row binds, S5 allowed-tools control, S6 carried-record control, S7 case-twin control; T1–T3, T6, T8, T10, S1, S2 red on stage-7660, the controls green on both; `test/backlog1930-near-miss-refuses.test.ts` (#1930's near-miss pin) K2 re-pinned (notice, no advisory); `test/legacy-residue-gate.test.ts` banks the moved code literal (src/core 95 → 96, src/core/runner 46 → 44); mutations M1–M10 (the skill refuses again, the skill's entries not split out, the selector branch off, the allowed side too, no once-per-session, a rename counted, a carried record dropped silently, the case-twin question not asked, the digest of the bounded detail, the told-upstream list told again), each red.
252
+
253
+ no-notes: #3339, #3534(release-tooling only, scripts/release/: the re-window reads a car written by its short ledger name, keeps a row whose car head an earlier release already shipped and says so; nothing in the package changes), #1930(named in the subject of a #3527 commit as the ticket that first described the retired-name form; the notes of that work are under #3527 / #3528)
254
+
255
+ ## 7.65.0 — 2026-11-03
256
+
257
+ ### Errata to the 7.64.0 section and to the errata it carries (those sections are frozen; the corrections live here)
258
+
259
+ - **The ticket that carries the server's second-redaction retirement.** The 7.56.0 section's "How to migrate" named S-2027 for it, and the 7.64.0 erratum for that section corrected it to S-2026. Neither is the live ticket: the retirement of the server's own second redaction is carried by **S-3162** (its exit seat's second redaction; it is blocked on this engine's vocabulary reaching the same forms, #2570). S-2026 is the server's 7.138.0 delivery of two single mint points, closed and not reopened; S-2027 stays the ticket for the `Cookie` / `Set-Cookie` header lines and the `x-amz-security-token` header, as the 7.64.0 erratum says. The instruction itself (the server retires its own second redaction) stands. Source: @server direct message, 11-03.
260
+ - **"@server: projects `gate` whole — no key to add".** The Consumers paragraphs of the 7.64.0 sections for #3410 and #3442 said so. Untrue: the server rebuilds the refused arm of `tool_end.gate.disposition` key by key (`screenedGate`, `src/trace/project.ts`) and guards the members it knows (`_GuardGateDisposition`, `src/trace/core-keyset-guard.ts`), so a new member of `GateDisposition` is stripped until the server adds it to its projection and its guard. `echoed` is such a member: the server's pickup of 7.64.0 added it (each element rebuilt as `{ kind, value, canonical? }`, `value` and `canonical` through its exit-seat text redaction), and the guard was red on 7.64.0 until then. The 7.59.0 section for #2810 has the same projection sentence about `gate.disposition.extension`; it was not re-checked here. Source: @server review of the 7.64.0 pickup, 11-02.
261
+ - **"The batch path (`redeemRuleBatch`) is unchanged for the server".** The Affected paragraph of the 7.64.0 section for #3428 said so. It held for a top-level refusal and a rejection; it did not hold for an import walk's member rows. A member whose compare-and-set or dot allocation threw answered `store_write` / `unknown`, and the server read that as settled-with-an-unknown-outcome and recorded the member indeterminate, where nothing had been written and a repeat was right. The word is corrected in this release (#3492: those steps answer `committed: "no"`, and `retriable` says whether the same call may be repeated). Source: @server review of the 7.64.0 pickup, 11-02.
262
+ - **"The parked tool call dropped".** The Before paragraph of the 7.64.0 section for #3412 said that on 7.63.0 a `plan_review` gate holding a tool approval, given a plan approval, resumed, was `resolved` and "the parked tool call dropped" (M2). The black-box reading on 7.63.0 (a real Runner through the package surface, no server or shell) is different in its last step: the person's approval was consumed and the row `resolved`, the tool did not run, and the run then asked again — a second approval card for the same `toolCallId`. The call is not lost; the approval is consumed without effect and the question is put a second time. The 7.64.0 refusal and every other sentence of that section stand. Source: @test, 11-03.
263
+
264
+ ### A redemption refusal's `committed` is read one way — a store step before the rule write is `no` — and whether the same call may be repeated is its own member, `retriable` (#3492; ruled C-R1135; behavior change: the refusals of a dot allocation, of the approval record's compare-and-set that records the redemption's dot and of a prepare entry's record creation answer `committed: "no"` where they answered `"unknown"` (a confirmation's and a card edit's answer carry no `committed` and are unchanged); narrowing: none; widening: none; hard-breaking: one, type level, three sentences below, open to veto; closed sets: none (no word added); exports: none; members: `RedeemResult` refused arm +`retriable`, `RedeemedBatchMember` refused arm +`retriable`, both required in type; wire: the refused result and a refused member row +1 key, additive) (@server @client-core @cli @test)
265
+
266
+ - **Before.** `RuleWriteCommitted` is defined as "has the store settled whether the call's rule stands", but the redemption leg's store step minted the word from the step's verb: a dot allocation and the record's compare-and-set that records the dot answered `store_write` / `unknown` (7.64.0, #3428), and so did a prepare entry's record creation (this release's #3430 section), although each runs before the rule write and the rule cannot stand. A host reads `unknown` as "reconcile, do not repeat": an import walk whose member's dot allocation threw answered a complete table with an `unknown` row, which a host lands as indeterminate and never retries. A `dot_removed` row answered `no` like a store failure before the write, with nothing but the code to tell them apart.
267
+ - **Now.** One reading, the store table's: every step before the rule write is `no`, whatever that step's own bytes did; `unknown` only for a rule write that was issued and did not settle (the apply threw, answered unreadably, or left no trace of its dot) or the read-back after it that could not be taken. The member code set is unchanged. Beside the word, every refusal carries `retriable`, derived once (`refusalRetriable`) in the one function that mints the refused arm: `true` exactly for `store_read` / `store_write` with `no` (a store failed before the rule write; repeating the same call can land it), `false` for every other refusal (`dot_removed`, a cause the record or the person decided, a write the store refused or lost, a write issued with an unknown outcome). A confirmation's answer carries neither word; a landed row carries none.
268
+ - **Hard-breaking — one, type level, three sentences (open to veto).** *What changed:* the refused arm of `RedeemResult` and the refused arm of `RedeemedBatchMember` gain the required member `retriable: boolean`. *Who is affected:* a host that builds such a value (a fake door in a test, a mirrored type) no longer compiles until it sets the member — @server where its tests construct refused results, @client-core where it mirrors the types; code that reads results is unaffected. *Compensation:* carry the engine's `retriable` through; never derive it from `committed`.
269
+ - **Rules.** Retired: the store step's own word (it derived `committed` from the code). Added: one derivation, one call site.
270
+ - **Consumers.** @server: 7.147.0 reads `retriable` to decide a repeat and `committed` to decide a reconcile; the 7.146.0 settlement rollback is unaffected. The 7.64.0 #3428 section's "the batch path (`redeemRuleBatch`) is unchanged for the server" stops holding here: a member row's `store_write` for a compare-and-set or a dot allocation is `no` now. @client-core: mirror the member. @test (black box): an import walk whose member's dot allocation throws ⇒ `store_write` / `no` / `retriable: true`, and walking it again lands the rule once; `dot_removed` ⇒ `no` / `retriable: false`; a rule write that commits and loses its acknowledgement ⇒ `store_write` / `unknown` / `retriable: false`.
271
+ - **Claude Code 2.1.316.** No anchor: Claude Code keeps no persisted approval record and no redemption.
272
+ - **Pins.** `test/backlog3492-committed-word-retriable.test.ts` C1–C10; re-pinned (`committed` literal only, reason in each cell): `test/backlog3428-approvals-store-failure.test.ts` R2 / R2b / R4 / R7 / R8, `test/backlog3430-approvals-record-store-failure.test.ts` P1–P3 / P9 / P11, `test/backlog3414-refusal-one-shape.test.ts` S4 / B4; whole-object refused pins gain `retriable` in `test/permission-rule-consent.test.ts`, `test/permission-rule-adopt.test.ts`, `test/permission-rule-owner-consent.test.ts`, `test/design375-batch-consent.test.ts`. Mutations (receipt).
273
+
274
+ ### A redemption reports landed only while its dot is live — an allow member of a batch walked again, and a single ticket redeemed again, after the person removed the rule answer `dot_removed` where they answered `persisted` / `deduped` and `redeemed` (#3493, #3495; behavior change; narrowing — one, open to veto; widening — one, open to veto; hard-breaking: none; closed sets: none; exports: none; wire: no key added) (@server @cli @client-core @test)
275
+
276
+ - **Before.** The batch walk read a member's standing after its redemption only for a deny / ask member; the single ticket did not read it. The landing's witness reads the raw state, where a dot the person removed since is still present under its tombstone, so a replay of that dot answered `persisted` / `deduped` (an allow member) or `redeemed` / `alreadyRedeemed: true` (any single ticket) while the rule did not stand.
277
+ - **Now.** One read-back, in the redemption leg every entry takes: a dot that a read which succeeded finds not live answers `dot_removed` / `no` / `retriable: false`; a read-back that cannot be taken answers `store_read` / `unknown` / `retriable: false`. A batch member carries the leg's answer, and the walk keeps no check of its own. An allow that does not stand withholds nothing (it leaves the store narrower than the list); only a deny / ask member's failure withholds the allows, as before. Each redemption takes one store read more. The look asks one question, the same for the leg and for the single ticket's check of an allow's deny / ask siblings: is the record's redeemed dot a live add on a row of the candidate's behavior and scope? It reads the dot (the add's audit identity, the one fact the record keeps of the write), never the rule text, because the row carries the parser's spelling of the candidate and a record can spell it otherwise.
278
+ - **Widening — one (open to veto).** A record whose deny / ask candidate is spelled otherwise than the row the parser writes for it (`Bash(curl -s:*)`, stored `Bash(curl -s:*)`): a record persisted under an earlier parser's spelling, or one a host built — the engine's own card, import and starter records carry the parser's spelling. 7.64.0 compared the text, so it read that deny, once landed, as not standing: the walk answered its row `dot_removed` and withheld the record's allows, and the single ticket withheld an allow whose deny sibling stood, on every repeat. The deny's row is `persisted` now and those allows land. @server: a lane that tracked such a record as "withheld until a fresh card" sees it complete.
279
+ - **Narrowing — one (open to veto).** An allow batch can now carry `dot_removed` rows, and a replayed ticket can answer `dot_removed` where it answered `redeemed`. @server: a lane batch guard that reads `committed: "no"` as "untouched" must read `retriable` and the member code the same day — a `dot_removed` row is `no` and not retriable.
280
+ - **Rules.** Moved: the standing read-back, from the walk's loop into the leg (one site). Retired: its `behavior !== "allow"` condition, and the rule-text comparison of the look. Merged: the two copies of "is this dot live" (the read-back and the siblings' check) into one predicate.
281
+ - **Consumers.** @server @cli @client-core: render a single ticket's `dot_removed` as a member row's ("removed since — a new consent is required"). @test (black box): redeem a ticket, remove its rule, redeem the same ticket ⇒ `dot_removed`; walk a batch, remove one allow, walk again ⇒ that row `dot_removed`, the other allow `deduped`.
282
+ - **Claude Code 2.1.316.** No anchor, as above.
283
+ - **Pins.** `test/backlog3492-committed-word-retriable.test.ts` A1–A3 (the walk) and B1–B6 (the single ticket; B4 the live-replay control, B6 a rule added again under a new dot), B7–B9 (a folded spelling at the door, in the walk and as a sibling; B7's control: the engine's card mints the parser's spelling). Mutations (receipt).
284
+
285
+ ### A background agent's durable row records its tree's root occupant beside the root anchor, and a revival reads both back — what a revived tree escalates to its root is addressed to the occupant the tree was born under (#3434, ruled C-R1109 addendum 2; behavior change; narrowing: none; widening: one, below, open to veto; hard-breaking: none; closed sets: none; exports: none; members: +1 optional `rootSessionIncarnation` on `BackgroundAgentRecord` and on the background registration input; wire: none) (@server @test)
286
+
287
+ - **Before.** 7.64.0 wrote a background agent's root anchor on its durable row (`BackgroundAgentRecord.rootSessionId`) but not the occupant of that root's row, though the spawning run's ctx carried both. A claim-driven revival (another process claiming the row, the parked-resume drive a host decide starts) rebuilt the child's root anchor from the row, so its `RunInternals.rootSessionIncarnation` was absent. A terminal frame its subtree escalated to the root (a grandchild's completion with no live lane to take it) was addressed to an unknown occupant and, the root having an occupant on record, discarded with `delegation.delivery_discarded` (`addressed: unknown`) even when the root was never deleted. This was the narrowing (2) of #3431 (KL-3431-a).
288
+ - **Now.** The registration that creates the row writes `rootSessionIncarnation` beside `rootSessionId`, from the spawner's `ctx.rootSessionIncarnation`. It is written only together with the anchor, never alone. A revival from a row reads it back beside the anchor; a row whose anchor is the parent fallback, or that records no occupant, revives a tree whose root occupant is unknown, as before. So a revived tree's escalation reaches the root's next run while the root holds the occupant the tree was born under. Once the root's id was deleted and created again, it is discarded with `addressed: known`.
289
+ - **Widening (open to veto).** A revived tree's root-anchor escalation is delivered again when the root still holds the occupant its row recorded. 7.64.0 discarded it. A row written before this release records no occupant and keeps the 7.64.0 reading (discarded, `addressed: unknown`; C-R1109 Q2 (A)).
290
+ - **Rules.** The address stays one rule: (session id, occupant), judged by `sameOccupant` at the store's seat. No new reading is added: the revival restores the member the spawn already carried in memory. Retired: the root anchor travelling on the row without its occupant.
291
+ - **Claude Code 2.1.316.** Not applicable: a Claude Code process revives no background agent from a row in another process. Inferred, not checked against the corpus.
292
+ - **Consumers.** @server: a `BackgroundAgentStore` gains an optional member to store and return as written. The SQL agent store keeps the whole record as `record_json` (`src/stores-sql/background-agent-store-sql.ts` :21 / :100 at server origin/main 96a91d82, read here), so the member round-trips with no column change; the store contract kit gains a cell that says so (put, read, CAS, absent stays absent). @test (black box): a background agent parked on an approval and decided by the host after its own run has ended; a report its subtree sends after that reaches the root session's next run, and with the root deleted and created again it does not, with one operator `delegation.delivery_discarded` (`addressed: known`).
293
+ - **Known limits.** KL-3431-a is rewritten: the revived-tree shape is closed for rows this release writes. Rows an earlier release wrote, a host-mounted workflow tool that names its root only through `originatingSessionId`, and a leg whose occupant read threw keep discarding under an unknown occupant.
294
+ - **Pins.** `test/backlog3434-root-occupant-row.test.ts` — O1 a background spawn writes the root occupant beside the anchor · O2 real Runner, a host decide revives the parked child under the same root occupant ⇒ its ctx names that occupant and the subtree report reaches the root's next leg, no notice · O3 the root's id created again before the revival ⇒ discarded, `addressed: known`, no token and no report text on the notice, never in the new occupant's model · O4 control, a row with no recorded occupant ⇒ discarded, `addressed: unknown` · O5 the registration records an occupant only beside an anchor, never alone · O6 the fork lane's background spawn records it too. The base tree (stage-7650 at v7.64.0) fails O1–O3, O5 and O6; O2 is discarded there with `addressed: unknown`. The store contract kit (`src/core/store-contracts/background-agent-store-contract.ts`) gains the round-trip cell, run against both bundled stores by `test/background-agent-store.test.ts`. `test/backlog3431-session-occupant-address.test.ts` P8 (a tree whose internals name no root occupant) is unchanged: it is the earlier-row shape.
295
+
296
+ ### A delegated leg's user-face notice is for the root occupant its tree was born under — once the root's id was deleted and created again, the old tree's notice is discarded and said, `delegation.delivery_discarded` with `path: "notice"`, not delivered to the root's later occupant (#3479, ruled C-R1109 addendum 2; behavior change; behavior narrowing — two, below, open to veto; hard-breaking: none; closed sets: `DiscardedDeliveryPath` +1 (`notice`), additive; exports: none — the delivery throat `deliverEngineNotice` takes an optional third parameter, and it is not on the package surface (`src/index.ts` does not export it; the export-surface snapshot and the wire report carry no signature change); wire: one word added to `delegation.delivery_discarded` `detail.path`) (@server @cli @client-core @test)
297
+
298
+ - **Before.** 7.64.0 addressed a delegated leg's user-face notices to its delegation tree's root session (#3083, C-R1121): `delegation.ask_unresolvable`, `permission.ask_released_by_mode`, `permission.read_deny_unapplied` and `classifier.unavailable` carry the root's id as `detail.sessionId`, lifted to the notice's top-level `sessionId`, and a deployment routes a notice by that id. The address was the id alone (`noticeAddressOf`, `src/core/leg-identity.ts` :90-98 at v7.64.0). Frames addressed to the same root were already judged by occupant (#3431). So when the root's id had been deleted and created again while a background child of the earlier occupant still ran, that child's notices — which tool of which child was refused, released or unclassified — reached the later occupant's route.
299
+ - **Now.** The root is a session address like every other destination: its id and the root occupant the tree was born under (`internals.rootSessionIncarnation`). `noticeAddressOf` answers both: the keys the notice carries (unchanged) and, on a delegated leg addressed to its root, the destination. The destination is never spread into a notice; no occupant token rides the wire. A leg delivers its four user-face notices through the one throat under one admission (`legNoticeAdmission`, `src/core/runner/prepare-gate-stations.ts`), handed to the throat as its new optional third parameter. A notice with a destination is first judged by the Runner's in-process notification store (`discardsStaleNotice`), with the same judgement that decides a frame addressed there. If the root's current occupant is another, the notice is discarded and `delegation.delivery_discarded` is said once (operator), with `path: "notice"`, `taskId` = the leg it came from (its agent id, else its session), `taskType` = the discarded notice's code, and `addressed` / `current` as for frames. Otherwise, and for a root no leg of which this process admitted, the notice is delivered as before. A top-level leg's notice goes to its own session and is never judged.
300
+ - **Narrowing (open to veto).** (1) A delegated leg's user-face notice addressed to a root whose id was deleted and created again (the later occupant admitted in this process) is no longer delivered. It reached the later occupant's route, which is the defect. (2) A delegated leg whose tree's root occupant is unknown (its internals name none: a tree revived from a row an earlier release wrote, a host-mounted workflow tool that names its root only through `originatingSessionId`) has its user-face notices discarded and said with `addressed: unknown` whenever the root has an occupant on record here. They used to be delivered. The refusal itself is unchanged, and the child's tool result still says it; what the root's viewer loses is the notice (KL-3479-a).
301
+ - **Rules.** One address rule, (session id, occupant), judged in one place for frames and notices alike (the store's `staleAgainst`, read by `discardsStale` and `discardsStaleNotice`). One mint of the discard account (`deliveryDiscardedNotice`); its input is the discarded delivery's name (`DiscardedDelivery`, `{ taskId, taskType }`), and a frame passes `frameDelivery(payload)`. Retired: a delegated leg's notice addressed by the root's id alone. Added: the throat's admission, `deliverEngineNotice(onNotice, notice, admission?)` (an engine-internal function; named `admission`, since `admits` is a tool-selector predicate whose reads the valve guard of #1971 counts). The third parameter is optional; a call that passes none behaves as in 7.64.0. When one is passed, a notice it answers `false` for is handed to no seat, and the predicate must already have said so on its own account (here the judge mints `delegation.delivery_discarded`). It only judges and never rewrites the notice, so the mint stays at the call site. Net rules: zero (the throat gains the admission; no forwarder is built, so every throat call still mints its notice in place, where the notice-catalog scan of #433 reads it). The classifier station's notice seat (`classifierUnavailableSeat`) gains the same optional `admission` beside its sink; the inherited station passes none, as before. The judge reaches prepare as the last positional parameter of the internal `PrepareTaskFn` contract (absent outside a Runner: every notice delivered).
302
+ - **Claude Code 2.1.316.** Not checked against the corpus. Inferred: a Claude Code process holds one conversation, and a subagent's permission notice goes to that process's own stream, so an id re-created under another owner is not a destination there.
303
+ - **Consumers.** @server: `delegation.delivery_discarded` gains `path: "notice"`; with it, `detail.taskType` is a notice code (for example `delegation.ask_unresolvable`) and `detail.taskId` the delegated leg's agent id. Audience and minter are unchanged (`operator`, `engine`), so keep it off the user wire. The session door's owner check does not retire: the store judges only this process's seats, and a root no leg of which this process admitted is not known to have been created again. @cli: an operator notice; no user-face text expected. @client-core: a mirror of `detail.path`'s words gains `notice`. @test (black box): delete a session and create it again under the same id while the earlier occupant's background child is running, then let the child call a tool the deployment cannot approve. The new occupant's stream never carries that `delegation.ask_unresolvable`, and the operator sink carries one `delegation.delivery_discarded` with `path: notice, addressed: known, current: known`.
304
+ - **Known limits.** KL-3479-a: a notice cannot wait the way a frame parks, so a root created again but not yet admitted in this process (or one whose legs run in another process) still takes the earlier tree's notice by id; and a delegated leg with an unknown root occupant has its notices discarded (narrowing 2).
305
+ - **Pins.** `test/backlog3479-notice-root-occupant.test.ts` — N1 real Runner, two trees: the root deleted and created again while its background child waits ⇒ the child's refusal is discarded, `path: notice`, the agent id named, no token and no ask text on the notice, never delivered · N2 control: the same root occupant ⇒ delivered to the root, naming the child · N3 the route: a top-level leg has no destination; a delegated one carries the root's address beside its keys, never in them · N4 a delegated leg judged against the root's current occupant: (a) same ⇒ delivered, (b) a root no leg of which was admitted here ⇒ delivered, (c) an earlier occupant ⇒ discarded `addressed: known`, (d) an unknown occupant ⇒ discarded `addressed: unknown` · N5 another of the leg's notices takes the same judge: a bypass release on a leg of the earlier tree still runs the tool, and its `permission.ask_released_by_mode` notice is discarded and named · N6 (structural) every throat call in the gate station carries the leg's admission, and the classifier seat is handed it beside the deployment's sink · N7 the throat's admission: absent ⇒ delivered as in 7.64.0, `false` ⇒ no seat (nor the default seat) hears it, asked once with the notice as it leaves. The base tree (stage-7650 at v7.64.0) fails N1, N3, N4 (c) / (d), N5, N6 and N7.
306
+
307
+ ### One occupant reading — `sameOccupant` decodes each side as a stored cell is decoded and is the only answer to "one occupant?"; `compareOccupants` keeps its name and signature as the predicate's row-level face, `"unknown"` only when a side has no row (#3433, ruled C-R1109 addendum 2; behavior change; behavior narrowing — three, below, open to veto; widening — two, below, open to veto; hard-breaking: one, semantic, three sentences below, open to veto; closed sets: none; exports: none added or removed — `compareOccupants` keeps its name, signature and three answers; wire: no key, `delegation.delivery_discarded` `detail.addressed` / `detail.current` say `unknown` for an empty or non-string cell) (@server @test)
308
+
309
+ - **Before.** 7.64.0 answered the question with two readings. The delegation seats, the notification store, the session-box drain and the peer idle / held-queue seats compared the cells as written (`sameOccupant`, `held === current`), so an empty cell and an absent one were two occupants. `compareOccupants` answered `"unknown"` whenever a side had no token, so each of its readers decided that case its own way: the File repo joined the live authority ("a row without a token cannot say, and the file decides"), and the cached-session store dropped its view over a repo with a by-id read and kept it over one without.
310
+ - **Now.** `sameOccupant` lives beside the cell decoder (`src/engine/session/repo-utils.ts`). Each side is decoded as `readIncarnationCell` decodes a stored cell: a non-empty string is the token, and absent, `""` or a non-string is no token. The same token, or no token on either side, is one occupant; a token on one side only is another. `compareOccupants(before, after)` is `"unknown"` when a side has no row, otherwise `sameOccupant` of the two cells as `"same"` or `"different"`. The File repo joins a live authority only on `"same"`. The cached-session store's view stands on `"same"` unless the row names another owner, falls on `"different"`, and with no row answers the repo's default as before. The discarded-delivery notice says whether each side names an occupant through the same predicate.
311
+ - **Narrowing (open to veto).** (1) A File session row with no token whose file is rewritten in place with a header naming a token — the row created again under the id, by a writer this process does not see — is no longer joined to the live authority. The authority is evicted, a handle on it is refused (`log_closed`), and the occupant the header names is served from disk. 7.64.0 joined it and served the earlier occupant's transcript to whoever the row now admits. (2) Over a repo with no by-id read, a listing no longer lends a cached view's run (`lastTaskId` / `lastTaskRunId`) to a row whose occupant cell differs from the view's by having or lacking a token. 7.64.0 answered `"unknown"` there and the view stood. (3) A `delegation.delivery_discarded` account whose address or current occupant cell is `""` or a non-string now says `addressed: "unknown"` / `current: "unknown"`, where 7.64.0 said `"known"`: such a cell names nobody by the one reading, so the account no longer claims an occupant was named.
312
+ - **Widening (open to veto).** (1) Over a repo with a by-id read, a cached view of a row with no token stands for that row while it names the same owner and, on acquire, the same leaf: acquire serves the view and the listing lends it its run. 7.64.0 dropped it and resolved the id from the row again. Every write that creates a row mints a token, so two token-less readings of one id are one generation. (2) A frame, a box record or a seat addressed under an empty or non-string cell is the occupant of a seat with no token, and is delivered to it. 7.64.0 discarded it as another occupant's. A token against no token stays another occupant everywhere: no token is never a wildcard.
313
+ - **Hard-breaking — one, semantic, three sentences (open to veto).** *What changed:* `compareOccupants` answers `"same"` for two heads that both have a row and no occupant token (absent, `""` or a non-string cell), and `"different"` for a token on one side only, where 7.64.0 answered `"unknown"` for both; only a side with no row is still `"unknown"`, and the name, the signature and the three answers are unchanged. *Who is affected:* @server's warm-session cache takes a cached view only on `"same"` (`src/plugins/caching-session-store.ts:324` `freshHit`). A head with no token beside a cached view with no token is now a hit where it was a stale miss; the leaf must still match, and a token against no token is still a miss. Three server sentences no longer describe the core answer: the cache's head note (`:35`, "`unknown` included"), `src/security.ts:225`, and `src/session-incarnation.ts:31-35` ("任一侧没有行或没有令牌 ⇒ `unknown`"). These were read on server origin/main `96a91d82` and not compiled against this tree. No other repository calls it: grep of the cli / client-core / sdk / test origin/main finds no `compareOccupants`. *Compensation:* read whether a head carries a token from the head itself (`head.incarnation`), not from `compareOccupants`. A reader that must refuse a token-less row keeps its own refusal, as the server's write path does (`sessionFaceOfHead` → `SessionIncarnationMissingError`); that refusal was never `compareOccupants`'s answer. Update the three sentences.
314
+ - **Rules.** Two readings become one: the predicate beside the decoder, with `compareOccupants` a row-presence wrapper over it. The delegation-owner module no longer defines its own copy, and the notification store, the drain and the peer seats import the one predicate. The discarded-delivery notice's `addressed` / `current` stop testing `!== undefined` and ask the predicate. The cached-session judgement keeps its owner check on every non-`"different"` answer, so a token-less row naming another owner never stands (Q5). A row with a token has one owner, so the check changes nothing reachable there (inferred).
315
+ - **Interplay with #3461 (inferred, not pinned).** A session-box drain whose by-id read answers a non-string `incarnation` and whose leg holds no token now confirms itself the current occupant: records named for another occupant are discarded with their account instead of staying in the box. A head answering a non-string beside a leg that holds a token remains #3461's form, unchanged.
316
+ - **Claude Code 2.1.316.** Not applicable: a Claude Code session carries no occupant token. Inferred, not checked against the corpus.
317
+ - **Consumers.** @server: the semantic hard-breaking item above. @test: the empty-cell and in-place shapes below are the constructions to retry against a real deployment.
318
+ - **Pins.** `test/backlog3433-one-occupant-reading.test.ts`:
319
+ - Q1: the two faces agree on every pair of six cells (absent / `""` / `7` / `null` / two tokens). No row ⇒ unknown; otherwise `"same"` exactly when the predicate says one occupant.
320
+ - Q2: a seat admitted under an empty cell takes a frame addressed with no token (parked, drained, nothing discarded). Control: a token against an empty cell is refused and said, with `addressed: unknown`.
321
+ - Q3 (two trees): a token-less row rewritten in place with a token is not joined. The earlier transcript is not served, the new occupant's turn reaches the file, and the held handle is refused.
322
+ - Q4 (two trees): a token-less view over a repo with a by-id read still lends its run, and acquire serves the same view.
323
+ - Q5: a token-less row rewritten to name another owner lends nothing.
324
+
325
+ The base tree (stage-7650 at v7.64.0) fails Q1 (it has no predicate in the row module), Q2, Q3 and Q4.
326
+
327
+ Re-pinned (a re-pin, not a widening): `test/backlog1468-s2-session-row-head.test.ts` H9. Its three pairs of rows with no token each (absent, `""`, `7`) answered `"unknown"` and answer `"same"`. Two pairs with a token on one side only are added, and answer `"different"`. Also re-pinned: `test/backlog1468-s3-list.test.ts` L8b cell (4). Over a repo with a by-id read, a row and a view with no token each now stand on both call sites, where they refused; this is widening (1) above, read by the same judgement. L8c is unchanged: a token-less row created again under another owner, or under none, still lends nothing.
328
+
329
+ ### Retired (C-R1075 加注 3 ④): the `syncBlobFaces` word means nothing to the blob-exchange judge — `fileHistoryBlobExchangeOf` reads the `blobExchange` group alone, so a store that still carries the word is read by its group like any other (#3148, retirement line RL-3148-sync-blob-faces; behavior change; behavior widening — one, open to veto; hard-breaking: none; closed sets: none; exports: none) (@server @test)
330
+
331
+ - **Before.** In 7.64.0 the judge read two members: the `blobExchange` group, and the retired marker word `syncBlobFaces`. A store carrying the word, with or without a whole group beside it, was refused `config.invalid_argument` ("FileHistoryStore carries the retired syncBlobFaces marker …", `src/core/file-history-store.ts` :903 / :908 at v7.64.0), so that a deployment store still built on the 7.60.x marker was told, rather than read, while its readers moved to the group.
332
+ - **Now.** One reading. The capability is the `blobExchange` group: present and whole ⇒ the three members, bound; absent ⇒ none; anything else ⇒ the group's own coded refusal. No other member of the store is read, so `syncBlobFaces` alone is no capability and beside a whole group changes nothing. The line's condition holds — no store carries the word: zero carriers in the `src` of @server (`96a91d82`), @cli (`feda7f7c`), @client-core (`426331e`) and @sdk (`d5aed66`); the server reads the capability only through this judge (`src/session-sync.ts:88-94`, `src/capability-facts.ts:263`) and its SQL twins carry the group; the remaining mentions are CHANGELOG / MIGRATION prose, @sdk documentation and tests (grep of each `origin/main`).
333
+ - **Widening — one (open to veto; @server).** A store carrying `syncBlobFaces` is no longer refused: alone it reads as no blob exchange (where it was refused), beside a whole group it exchanges blobs (where it was refused). Nothing that answered before answers differently.
334
+ - **Consumers.** @server — `test/capability-facts.test.ts` asserts the retired refusal in three places, all to re-pin at pickup (coordinates on the pickup branch `che-PICK764` `275b010b`; on `origin/main` `96a91d82` they sit two lines earlier): the shape row `:107` ("🔴 PICK7610 还带退役标记词 syncBlobFaces(整组也在)", `reaches: "refused"`, built at `:100`), which now reaches `true` (the group is whole) — re-pin it to the group's reading or drop it; the refused arm's sentence `:115` ("判官拒(半组 / 退役标记词)") and the head note `:80`, which name the word as a refusal reason — only the half group is one now. @test — black box: a file-history store carrying `syncBlobFaces: true` and a whole `blobExchange` group exchanges blobs; the same store without the group reads as no exchange; a half group beside the word is refused with the group's own sentence, which does not name the word. Not affected: @cli @client-core @sdk (no reader).
335
+ - **Rules.** Retired: the judge's second member read and its refusal, and the retirement row. Added: none.
336
+ - **Claude Code 2.1.316.** No anchor (inferred): Claude Code has no blob-exchange seat on a file-history store.
337
+ - **Pins.** `test/backlog3148-write-faces.test.ts` — "RL-3148 retired: the syncBlobFaces word is no reading at all" (the word alone ⇒ no exchange, either value; beside a whole group ⇒ the group, bound and working; beside a half group ⇒ the group's own refusal, which does not name the word) · "RL-3148 retired: no source file names the retired word, and the retirement table has no row for it". Mutations: `.gate-logs/criteria-rl-7650-mutations.md` (receipt).
338
+
339
+ ### Retired (C-R1075 加注 3 ③): the memory store family leaves the package — the store implementations, their write gates and selective-recall helpers, the file backend's memory member and its two options, the retention table's row for that member, and the three error codes only the family minted; the engine behind `RunnerDeps.memoryBackend` is the one memory (#1654 / #2910 / #3031, retirement line RL-1654-store-family; behavior change; behavior narrowing — one, open to veto; hard-breaking: four, three sentences each below, open to veto; closed sets: `NON_GOVERNANCE_MEMORY_CODES` −3 (`memory.secret_detected`, `memory.promotable_ungated`, `memory.projection_failed`), `RETENTION_CASCADE` −1 row (`memoryStore`); exports: −35 root names (21 values, 14 types); members: −1 `FileStorageBackend.memoryStore`, −2 `FileStorageBackendOptions.utilityGate` / `embedder`, −1 `RetentionCascadeStores.memoryStore`) (@server @cli @test)
340
+
341
+ - **Before.** In 7.64.0 the root still exported a second memory path that no Runner path had read since `RunnerDeps.memoryStore` was removed (design/138 S4, design/157 B19): the store implementations `InMemoryMemoryStore` / `FileMemoryStore` and the wrapper `guardedMemoryStore`; their write gates (`enforceSecretWriteGate` / `enforceStructuredNoteSecretGate`, refusing with `memory.secret_detected`; `classifyPromotable` / `enforcePromotableWriteGate`, refusing with `memory.promotable_ungated`) and error classes (`MemoryGateError`, `MemoryProjectionError` — `memory.projection_failed`); the consolidation probes (`supportsConsolidation`, `supportsPeriodicConsolidation`), the lexical helpers (`expandLexicalTerms`, `lexicalSearchMatch`) and the selective-recall helpers of `src/core/memory-recall.ts`. A `FileStorageBackend` carried `memoryStore` — a `FileMemoryStore` writing under `<root>/memory/`, shaped by the backend's options `utilityGate` / `embedder` — and the retention table carried an exempt row for that member.
342
+ - **Now.** `npm run handoff:diff v7.64.0 HEAD`: 35 removed / 0 added. Values: `FileMemoryStore`, `InMemoryMemoryStore`, `guardedMemoryStore`, `MemoryGateError`, `MemoryProjectionError`, `enforceSecretWriteGate`, `enforceStructuredNoteSecretGate`, `classifyPromotable`, `enforcePromotableWriteGate`, `supportsConsolidation`, `supportsPeriodicConsolidation`, `expandLexicalTerms`, `lexicalSearchMatch`, `encodeSurfacedKey`, `buildManifestText`, `validateSelectedIds`, `composeSelectiveBody`, `resolveLinkedIds`, `RECALL_CAVEAT`, `DEFAULT_MAX_SELECTED`, `DEFAULT_MAX_LINKED`. Types: `Embedder`, `UtilityGate`, `MemoryVectorMode`, `ScoredMemory`, `MemoryNoteHeader`, `MemoryNoteRecord`, `MemoryNoteType`, `StructuredNoteInput`, `MemorySelector`, `MemorySelectRequest`, `SelectiveRecallOptions`, `SelectiveRecallResult`, `LayeredRecallOptions`, `LayeredRecallResult`. `src/core/memory-recall.ts` and `src/stores/file/memory-store.ts` are deleted; `formatMemoryAge` moves to `src/core/memory-engine/memory-age.ts` and stays a root export. A `FileStorageBackend` has no `memoryStore`, creates no `<root>/memory/`, and refuses `utilityGate` / `embedder` at construction the way it refuses any key outside its option table — one door, `receiveOptions` (`config.invalid_argument`: `FileStorageBackend options: "embedder" is not an option it takes — the options it takes are …`). Notes an older backend wrote under `<root>/memory/<scope>/` (`notes.jsonl`, `vectors.jsonl`, `MEMORY.md`) stay on disk byte for byte and are read by nothing. No migration verb is minted for them (the one-off v1 migration verb is superseded, C-R1075 加注 2); as with 7.64.0's ledger retirement, the way out is an older engine — a host that still wants those notes reads them with an engine at or below 7.64.0, whose `FileMemoryStore` serves them, and writes what it keeps through its memory backend. The retention table loses the `memoryStore` row; it was an exempt row, so the session-tree erasure order is unchanged (steps 1–11). `NON_GOVERNANCE_MEMORY_CODES` loses the three codes no source file mints any more, and the gate that keeps that list honest reads mint sites only: it used to read the list's own file as a mint site, so its stale-entry check could not fail.
343
+ - **Narrowing — one (open to veto; @server @test).** `new FileStorageBackend({ root, utilityGate })` and `new FileStorageBackend({ root, embedder })` throw `config.invalid_argument` naming the key, where 7.64.0 built a memory store with them.
344
+ - **Hard-breaking — HB-1, thirty-five root names removed (open to veto).** *What changed:* the names above are no longer exported from `@sema-agent/core`. *Who is affected:* a host that imports any of them fails to compile (a JavaScript caller reads `undefined`); the origin/main of server (`96a91d82`), cli (`feda7f7c`), client-core (`9069705`) and sdk (`d5aed66`) carry no code reader of any of them. *What to read instead:* memory is the MemoryEngine behind `RunnerDeps.memoryBackend` (`MemoryBackend`, `FileMemoryEngineBackend`, `memoryBackendContract`); secret screening of memory writes is the engine's own, and `formatMemoryAge` is still exported.
345
+ - **Hard-breaking — HB-2, the file backend's memory member and its two options (open to veto).** *What changed:* `FileStorageBackend` has no `memoryStore`, makes no `<root>/memory/` directory, and its options type has no `utilityGate` / `embedder` (passing either throws, as above). *Who is affected:* a host that read `backend.memoryStore` (it reads `undefined`) or passed either option; none in the four repositories above. *What to read instead:* inject a memory backend into `RunnerDeps.memoryBackend`; notes left under `<root>/memory/` are not migrated (see Now).
346
+ - **Hard-breaking — HB-3, the retention table's `memoryStore` row (open to veto).** *What changed:* `RETENTION_CASCADE` has no `memoryStore` row and `RetentionCascadeStores` has no `memoryStore` member. *Who is affected:* code that enumerates the table's rows or builds a `RetentionCascadeStores` value with a `memoryStore` (a TypeScript excess-property error); the server reads only `RETENTION_CASCADE_DOMAINS` / `RETENTION_CASCADE_EXEMPT` (`test/retention-declaration.test.ts:26`), which are unchanged. *What to read instead:* the table as it stands — the row was an exemption, so no erasure step moved.
347
+ - **Hard-breaking — HB-4, `NON_GOVERNANCE_MEMORY_CODES` −3 (open to veto).** *What changed:* `memory.secret_detected`, `memory.promotable_ungated` and `memory.projection_failed` are no members. *Who is affected:* a host that asks the set about one of the three strings reads `false`; no repository above spells any of them in code, and `errorClassOf` answers `unknown` for each, as before. *What to read instead:* nothing — no engine path mints the three codes.
348
+ - **Exports, tiers.** `cosineDistance` and `firstSentence` move from `stable` to `advanced` in the export-surface layering: their only front-door demonstration was the retired PostgreSQL memory example.
349
+ - **Repository (not in the package).** The PostgreSQL reference adapter loses `PgMemoryStore`, `PgEmbedder`, `PgAgentSchemaOptions`, the two memory tables and `ensurePgAgentSchema`'s options parameter (`ensurePgAgentSchema(query)`). The consumer smoke probe no longer checks `MemoryProjectionError`. The live gate's conditional-file mechanism goes with its only row (`test/live-memory-embed.test.ts`, deleted with the store): `scripts/run-live-gate.mjs` runs every live file, so the R live reading changes from `N / 0 / 0 / OMITTED 1` to one with no OMITTED item; the summary's `omitted` field stays (now `[]`), and the ship post and the live stamp read it generically.
350
+ - **Consumers.** @server — no code reader; the comment `test/core-dependency-floor.test.ts:1362` names `MemoryProjectionError` as a `skip` row of the export ledger, which drops at pickup. @cli — the wire-consumption manifest rows `scripts/wire-consumption-manifest.json:5370` / `:5377` (`MemoryProjectionError`) go stale and drop at pickup. @client-core @sdk — no reader. @test — black box: `import { FileMemoryStore } from "@sema-agent/core"` is a compile error and a runtime read is `undefined`; `new FileStorageBackend({ root, embedder: {} })` throws naming `embedder`; a fresh backend has no `memoryStore` and leaves no `<root>/memory/`; a `<root>/memory/<scope>/notes.jsonl` written beforehand is untouched after open and dispose. The historical repros under `repro/` that import these names run against their own pinned dists. @dgx — the local dgx checkout's HEAD carries no code reader (a checkout of 10-24, not origin).
351
+ - **The credential-table section below.** Its hard-breaking sentence (2), its Consumers line and its U2 pin were written against 7.64.0, where the memory write door also had `enforceSecretWriteGate`, the guarded store and `memory.secret_detected`; with this retirement those read false in 7.65.0, so they are rewritten to the door that remains (`detectSecret`, read by `scanMemoryWrite`, answering the engine's `secret` rejection). The refused shapes are unchanged.
352
+ - **Rules.** Retired: the second memory path whole (its stores, gates, recall helpers, the backend member and its two options, the retention row, three codes), and the live gate's conditional-file rule. Repaired: the non-governance list's stale-entry check reads mint sites only. Added: none.
353
+ - **Claude Code 2.1.316.** No anchor (inferred): Claude Code's memory is one file set read at session start; it has no second, store-shaped memory seat.
354
+ - **Pins.** `test/backlog1654-store-exports-retired.test.ts` — S1 (none of the twenty-one value names is a runtime export, none of the thirty-five is spelled in `src/index.ts`; control: `MemoryEngine` is) · S2 (the two modules are gone; `formatMemoryAge` lives with the engine and is still a root export) · S3 (a file backend carries no memory member and makes no `memory/`) · S4 (an older backend's notes stay byte for byte) · S5 (the two options are refused by name) · S6 (no retention row for the member; erasure steps 1–11 unchanged) · S7 (the three codes are no members and no source file mints them; control: `memory.announce_failed` is) · R5 (the retirement table holds no `RL-1654` row; RL-1103 / RL-1333 untouched); `test/governance-codes.test.ts` (the stale-entry check reads mint sites only). Deleted with the family: `test/file-memory-store.test.ts`, `test/file-memory-searchscored-property.test.ts`, `test/memory-promotable-gate.test.ts`, `test/backlog784-legacy-store-projection.test.ts`, `test/live-memory-embed.test.ts`, `test/live-gate-conditional-registry.test.ts`. Re-pinned off the retired faces: the RSI L6 bench and its harness (`test/rsi-l6-bench.test.ts`, `test/rsi-tier-on-harness.ts` — the Gate-2 step and the store axis go; `gate2Verdict` is the profile's own input; 20 cells → 16), `test/pg-stores.test.ts` / `test/pg-live.test.ts` (no memory table), `test/error-class-of.test.ts`, `test/backlog3336-env-namespace-class.test.ts`, `test/backlog3406-landing-admission-root-exports.test.ts` (a live member stands for the list), and the memory / file-backend files that built the store; `test/retirement-lines-gate.test.ts` (the cited-row discriminance runs on RL-1103, the one row src comments still cite) and the sleep allow list of `test/flaky-guard.test.ts` (the recall rebuild file sleeps no more). Two shipped criteria observations are annotated `retiredIn: "7.65.0"` instead of rewritten: 7.20.0 G4.c (`MemoryProjectionError.committed`) and 7.62.0 G4.c (`FileStorageBackend.memoryStore`). Mutations: `.gate-logs/criteria-rl-7650-mutations.md` (receipt).
355
+
356
+ ### A write onto the write-protection table that a surviving ask is about is asked once, with the table's sentence in it — the ask keeps its own question and gains `(tool "Write" writes to a write-protected path (table entry "N") — explicit approval required)` (#3474; behavior change: the message of a surviving ask over a protected target gains the table's sentence; narrowing: none; widening: none; hard-breaking: none; closed sets: none; exports: none) (@cli @client-core @test)
357
+
358
+ - **Before.** A deployment whose write face asks first (`defaultWrite: "ask"`, no admitting root) met a write onto the write-protection table with two questions on one call: the write face's (`approve write to "<path>"?`) and the table's (`tool "Write" writes to a write-protected path (table entry "N") …`). The gate folded them into one ask and kept the write face's words (the post-fold tighten replaced a surviving allow and nothing else, and said so in its comment and in three pins); the table's finding rode only as the ask's class and its mandate (no standing allow rule retires it). The ask's `message` named no table entry: it said the table's sentence only where the write face allowed first (a root that admits the path, a worktree) — the 7.58.0 black-box reading G3.b. The same held for a deployment layer's own ask or a hook's.
359
+ - **Now.** One mint of the sentence, `writeProtectionTightenDecision` (unchanged); one placement, `askWithTableSentence` (`src/core/write-protect.ts`): over a surviving ask the fold keeps the ask's action, provenance, class and disclosures — `decisionReason`, `askReasons` (the asker's own words) and the mandate are what they were — and its message becomes `<standing message> (<the table's sentence>)`, the form the persisted-rule tightening appends its account in, once (a message that already says the sentence is not told it twice; an ask with no message takes the sentence alone). The tighten's deny (a target whose destination cannot be determined) still outranks a question and appends nothing; a policy's deny is left as it is. The fold's rule is one sentence: the tighten's ask replaces a surviving allow and is the sentence a surviving ask is said with.
360
+ - **Narrowing / widening.** None on any decision: the same call asks (or is refused) as before, the same mandate rides, the same approvers answer. The visible difference is the text: an ask raised by the write face, a deployment's policy or a hook, over a target the table meets, now ends with the table's sentence (and the reach clause when the row is met only where the path resolves on disk, #2793). The standing ask keeps its echoed paths; the table's sentence rides in parentheses (#3498): when the standing ask's message IS the engine's own sentence (the write gate's generic question, `engineSentenceOf`, #3442), `askWithTableSentence` restates that account over the merged text — `text` is the merged message, `generic` and the listed `echoed` path ride along — so a person's refusal of the merged question still files `disposition.echoed` beside `deniedBy: "ask_resolution"` (the first cut of this change dropped the account and with it the list; #1216 2.2 caught it on the stage). A standing ask that is a layer's or a hook's own words keeps them and gains no account, as before. A persisted rule's appended account (`persisted-rule-arms.ts`) is a different placement and is unchanged: its refusal still quotes the message whole (#3442 K7).
361
+ - **Consumers.** @cli @client-core: an ask's `message` over a write-protected path can be longer and names the table entry; a surface that renders `askReasons` and the typed members (the structured approval surface) is unchanged. A host that matched `approve write to "<path>"?` byte for byte on a protected path matches its prefix now. @test: the black-box face is the approval card of `Write` onto `.bashrc` / `.claude/**` in `default` mode with no admitting root (G3.b): one card, both sentences.
362
+ - **Pins.** `test/backlog3474-write-protect-merged-ask.test.ts` — D1 the write face asks first onto the table ⇒ one ask, its question then the table's sentence in parentheses · D2 control: an ordinary path keeps the generic question byte for byte and the engine's account of it · D3 control: a surviving allow demoted by the table says the sentence alone · D4 a deployment layer's own ask over a protected path ⇒ its words then the sentence, its reason and its asker's words kept · D5 a message that already says the sentence is not told it twice · D6 the mandate is untouched (a standing allow rule does not clear the merged ask; the approver is asked once) · D7 the merged ask carries the engine's account of its own longer message (`text` = the merged message, `generic`, the quoted path; #3498) · D8 a link onto the table ⇒ the sentence carries the one reach clause · D9 an undeterminable target is still a refusal · D10 a policy's deny over a protected path is not given a question appended · D11 a standing ask with no words of its own takes the sentence alone. Changed pins (they asserted the old rule): `test/backlog286-write-protect-default.test.ts` (a policy's ask over `.npmrc`), `test/backlog850-write-protection-rule-immune.test.ts` G6a (byte-identical but for the mandate stamps and the appended sentence), `test/backlog839-tighten-order-and-membership.test.ts` ① (a hit over a standing ask). `test/backlog3498-merged-ask-keeps-echoed.test.ts` (#3498) — G1 the write face onto the table, a person refuses ⇒ the record files the path and the approver was handed the merged question · G2 control: an ordinary path, the same record, the generic question byte for byte · G3 a link onto the table ⇒ the reach clause in the question, the path still filed · G4 a deployment layer's own ask ⇒ its words then the sentence, no list · G5 a demoted allow ⇒ the sentence alone, no list · U1–U6 the placement itself (the account follows the merged text; no account for a layer's words, a stale account or a replayed record; `generic` rides). `src/core/gate-fold.ts` stays at 575 lines (the placement lives in `write-protect.ts`, +19).
363
+
364
+ ### `sessionBoxMountVerdict` is on the package root — a host can ask, before it wires a deployment, whether its mailbox store and session store will be refused the session-box mount (#3480; behavior change: none; hard-breaking: none; closed sets: none; exports: +1, `sessionBoxMountVerdict`) (@server @cli @test)
365
+
366
+ - **Before.** The session-box lane (a session's own `session.<id>` box, the drain that consumes it and every seat that appends to it) mounts only over a mailbox that declares `crossProcessSafe: true` and a session store that reads a session's row by id (`SessionStore.headOf`). One function judges it — `sessionBoxMountVerdict(mailbox, sessions)`, read by the drain mount, the peer-lane mount and the send face — but only its mailbox half, `mailboxCrossProcessMountVerdict`, was on the root. A host that wanted to know whether its own store pair would be refused a mount had to run a leg and read `config.peer_lane_unmounted` afterwards, or copy the `headOf` test (a second source).
367
+ - **Now.** `sessionBoxMountVerdict` is exported from the root next to `mailboxCrossProcessMountVerdict` and answers the same `MailboxCrossProcessVerdict`: `{ ok: true }`, or `{ ok: false, code, reason }` — the mailbox half's reason first, then the missing by-id read named. The function, its signature and its answers are the engine's own and did not change; `SMOKE_CHECKED_EXPORTS` proves the name reachable from a stranger install, and the frozen export surface carries it (`count` 3190 → 3191, tier `advanced`).
368
+ - **Narrowing / widening.** None. One export added; nothing it reads changed.
369
+ - **Consumers.** @server @cli: call it with the mailbox store and session store you wire and show `reason` when `ok` is `false`, instead of discovering the unmounted lane at run time. @test: nothing changes in the running engine; the black-box face is the import.
370
+ - **Pins.** `test/backlog3480-session-box-verdict-root.test.ts` — B1 the root value is the module's function · B2 the verdict over both halves (the mailbox half judged first, its reason with no word of `headOf`; an absent store, `{}`, a non-function, `null` and a misnamed read each name the missing read) · B3 a passing pair is exactly the mailbox verdict's own answer · B4 the engine's seats call this function and its judgment is written once · B5 the smoke list · B6 the frozen surface. `test/export-surface.test.ts` re-baselined (Δ +1).
371
+
372
+ ### "Is this entry a control object?" is one question — a kind's listing names regular files under legal names, `getObject` / `deleteObject` / `putObject` refuse any other entry by name, a name is at most 255 UTF-8 bytes, and adopting from a directory that is not there is refused (#3476; behavior change: the File store's listing, read, delete and put over a non-object entry, a name over 255 bytes, and `adoptReplicaControlPlane` over a missing directory; narrowing: two, for the implementers of the seat and for adoption callers, open to veto; hard-breaking: none (no type changed); closed sets: none; exports: none) (@server @dgx @test)
373
+
374
+ - **Before.** The File store answered "what is in this kind?" by `readdir` alone: a subdirectory or a dangling link was listed as an object name, `getObject` met the same entry with an errno read as "stands but cannot be read", `deleteObject` met it with a raw `EPERM` and no code, and a 20 KB name passed `isControlObjectName` and failed as `ENAMETOOLONG` read as "the control plane cannot be probed" — a store fault, not a refused name. `adoptReplicaControlPlane` over a directory that was never there reported nothing adopted, so a mistyped path read as a finished handover.
375
+ - **Now.** One reading, `entryAt` (`src/core/memory-engine/control-objects.ts`): `absent` (only an `lstat` that finds nothing), `object` (a regular file, or a link whose target is one) or `other`. `listObjects` names the `object` entries under legal names, sorted; `getObject`, `deleteObject` and `putObject` over an `other` entry throw `ControlPlaneCorruptError` in one sentence (`… stands but is not a control object (a regular file under a legal name) — … (fail-closed)`), with no raw errno, and leave the entry standing; an object whose unlink fails is a `ControlPlaneCorruptError` with its errno as `cause`. `isControlObjectName` adds the bound: at most 255 UTF-8 bytes (a file name on the systems the store runs on), so an over-long name is `memory.control_object_unknown` on every verb, in the File store, in the test kit's in-memory twin and in the contract suite's clause. `adoptReplicaControlPlane(controlDir, …)` over a `controlDir` that does not exist throws `ControlPlaneCorruptError` naming the path (the File store over that same directory still answers an empty report); `replicaControlPlaneStrays` is unchanged and answers empty for it — a plane nothing was written to holds nothing, and the engine's construction-time probe (S2) must be able to ask. The filter is the store verb's alone: adoption and the strays reader read `standingFileControlObjectNames` (every name standing in a kind's directory), so an entry standing where an object belongs — a directory at a hold's custody name, a dangling link at a marker's — is still counted as a stray and still refused by name in adoption, which withholds the documents behind it (a document row never reaches the carrier ahead of the bytes it names); skipping it there would have copied the hold ledger without its custody (the one finding of the branch's codex round, fixed).
376
+ - **Narrowing 1 (open to veto, @server @dgx).** A store outside core that accepts a name longer than 255 UTF-8 bytes fails `memoryGovernanceStoreContract`'s "one opaque segment" clause; refuse it `memory.control_object_unknown`. A name over that length already failed on the File store (`ENAMETOOLONG`, read as an unprobeable control plane), so nothing that worked stops working; it now fails as a refused name instead of a store fault (inferred from the File store's behaviour; the minters of core's names were not audited here). **Narrowing 2 (open to veto, @server @cli).** A host that called `adoptReplicaControlPlane` on a directory that may not exist now gets a refusal there: ask `replicaControlPlaneStrays` first (it answers empty), or catch it.
377
+ - **Known limit.** An entry is an object by its kind (a regular file) and its name's shape, never by what it is called: a stray `.DS_Store` file in a kind's directory is a regular file under a legal name and is still listed (`.hidden` is a legal object name, so the predicate cannot drop it without refusing names a writer may use). A subdirectory, a link to one and a dangling link are no longer listed.
378
+ - **Consumers.** @server @dgx: the name bound is a clause of the suite your SQL / PG leg runs; a column that holds a name needs 255 bytes. @test: black-box faces are `listObjects` over a directory with a subdirectory in it, `deleteObject` over one (a coded refusal where it was a raw `EPERM`), and the adoption refusal.
379
+ - **Pins.** `test/backlog3476-control-object-entry.test.ts` — L1 a listing answers regular files under legal names only · L2 a backslash name is not listed · L3 get over absent / file / subdirectory / dangling link / link to a directory · L4 delete over the same: refused by name, no raw errno, left standing · L5 one predicate: every entry is listed exactly when get answers bytes, and delete refuses exactly the present unlisted · L6 255 bytes work end to end, 256 bytes (and 258 bytes in 86 characters) are `memory.control_object_unknown` on every verb, nothing written · L7 the in-memory twin · L8 the strays reader still counts every standing entry while the store's verb names objects only · L9 adoption from a missing directory is refused by name, the strays reader answers empty, the same-directory File store answers an empty report, nothing is created · L10 an existing empty directory is an empty report · L11 an object whose unlink fails is a coded refusal carrying the errno as its cause · L12 adoption refuses a directory at a hold's custody name and a dangling link at a marker's, withholds the hold ledger behind them, and converges once the damage is gone. The contract suite's "one opaque segment" clause carries the two over-long names.
380
+
381
+ ### A put over a standing name is answered for the same bytes only — `putObject` refuses other bytes, and an entry it cannot read to tell, the way `moveObject` refuses a target holding other bytes (#3475; behavior change: the File store's `putObject` over a standing name holding other bytes throws `ControlPlaneCorruptError` where it answered `"existed"`; narrowing: one, for the implementers of the seat, open to veto; hard-breaking: none (no type changed); closed sets: none; exports: none) (@server @dgx @test)
382
+
383
+ - **Before.** The File store's `putObject` answered `"existed"` for any name that stood, without looking at what it held: a caller whose bytes differed had them dropped and was told the name existed (put `AAAA`, put `BBBBBBBB`: `"existed"`, the disk still `AAAA`). `moveObject` over a target holding other bytes refused. One seat, two readings of "the name stands with other bytes". The same held for an entry that stood but could not be read (a directory on the name): the put answered `"existed"`.
384
+ - **Now.** `"existed"` means the name holds exactly the bytes handed in. Other bytes — and an entry that cannot be read to compare — throw `ControlPlaneCorruptError` in the sentence the move uses (`… the name already stands with different bytes — refusing to overwrite it (fail-closed)`); no new code, nothing is written, no stage file is left. The comparison reads the standing name through `getObject`'s own reader, and also runs when the name was not there at the probe but won the `link` (a lost race). The contract sentence `memory.governance.object_written_once` and the `putObject` JSDoc say it; `memoryGovernanceStoreContract` asserts it ("an object is written once", "an object that stands but cannot be read"). The origin-clearance account's custody writer relied on a second look after `"existed"`; the put's own comparison made it dead, and it is gone.
385
+ - **Narrowing (open to veto, @server @dgx).** An implementation of `MemoryGovernanceStore.putObject` outside core that answers `"existed"` for a standing name whatever it holds now fails the contract suite's two clauses above. The fix on their side is the one comparison: byte-equal ⇒ `"existed"`, other bytes ⇒ throw your `ControlPlaneCorruptError`. The bundled File store and the test kit's in-memory twin do it. Adoption (`adoptReplicaControlPlane`) onto a carrier that holds an object of that name with other bytes now reports the carrier's own refusal sentence as the record's reason (the record is refused and left in the replica, as before).
386
+ - **Consumers.** @server @dgx: the SQL / PG leg of the seat (S-3068) implements the clause above before it takes the suite. @test: the visible surface is the seat's own verbs and `adoptReplicaControlPlane`'s `refused` reason (`already stands with different bytes`); the engine's own writers still call the File helper directly (S2 moves them onto the seat), and the helper has the same comparison.
387
+ - **Pins.** `test/backlog3475-put-other-bytes.test.ts` — P1 same bytes ⇒ existed, nothing changes · P2 other bytes ⇒ refused by kind/name, standing bytes stand, no stage file · P3 empty vs non-empty both ways · P4 every kind · P5 the put's and the move's refusal are one class, one sentence stem, no code · P6 the probe misses, the link finds the name (lost race): other bytes refused, same bytes existed · P7 the name is gone between the lost link and the comparison: nothing written, said so · P8 a directory on the name: refused, never existed · P9 the in-memory twin · P10 the contract sentence and its registry row. Changed pins: `test/backlog3465-control-plane-carrier.test.ts` C1 / C2 / C9 (the old ones asserted `"existed"` for other bytes and for a directory), the kit's two clauses (`src/core/memory-engine/memory-backend-contract.ts`).
388
+
389
+ ### `CompactionSeat` is a registry row — `COMPACTION_SEATS` is exported from its module, so the closed-sets registry and the release manifest read the two seat words from one source (#3481; behavior change: none; hard-breaking: none; closed sets: +1 registry row, no word added or removed; exports: none — the array leaves its module, not the package root) (@test)
390
+
391
+ - **Before.** `COMPACTION_SEATS` (`src/core/context-settings.ts`) was a module-private `const`. The release manifest's reader (`scripts/wire-changes.mjs`) enumerates exported closed-set arrays only, so the 7.64.0 section could state the seat words only as a note under "Notes per row" of `docs/CLOSED-SETS.md`, not as a registry row — a second place a reader had to know about.
392
+ - **Now.** `export const COMPACTION_SEATS` (frozen where it is declared, as before) and the registry row `| CompactionSeat | src/core/context-settings.ts | array:COMPACTION_SEATS | — | live |`; the note's closing sentence ("Not a registry row … the row waits for the array to be exported") is gone because the row it was waiting for is there. `src/index.ts` is untouched: the type and the array are still not on the package root.
393
+ - **Narrowing / widening.** None. No word was added to or removed from the set; no read or refusal changed.
394
+ - **Consumers.** None outside the repository's own gates.
395
+ - **Pins.** `gate:closed-sets` (the new row's file, set and members are read from source) · `test/closed-sets-literal-members.test.ts` (the registry's reader and the manifest's reader agree word for word over every row, this one included) · `test/closed-sets-frozen-exports.test.ts` (the exported array is frozen).
396
+
397
+ ### The credential table is the union of the engine's, the server's and the settings package's shapes — six new rows and five widened ones; each family's strict, wide and environment-value forms sit on its one row, and the environment scrub's seven value rules and token head are read off the rows (`tokenPrefix` retired) (#3339 = #3223 S1b, ruled C-R1084 K5 / K6 / K12; behavior change: egress withholds the forms listed below, the durable memory write door refuses five more strict shapes; narrowing: those forms, security, open to veto; widening: none; hard-breaking: three sentences below, plus one type-level sentence (the `@sema-agent/primitives` wire manifest's three breaking items: `CredentialVocabulary` +`flagWords` +`names` required, −`tokenPrefix`; `EnvNameView` −`tokenPrefix`); closed sets: none; exports: `@sema-agent/primitives` +1 value `envValueView`, +1 type `EnvValueView`; members: `CredentialVocabulary` −`tokenPrefix` +`flagWords`, `ValueFamilyRow` +`envValue?` +`envValueHead?`, `EnvNameView` −`tokenPrefix`; `@sema-agent/core` none) (@server @ss @cli @client-core @test)
398
+
399
+ - **Before.** The table held twenty rows. The server's redaction recognised shapes the table did not (the GitLab token kinds beyond `glpat-`, PyPI upload tokens, Slack refresh and app-level tokens, `sk_org_` keys, `Basic` / `token` scheme credentials, signed-URL parameters such as `X-Amz-Signature`), the settings package held its own private-key containers, and the engine's environment scrub (`src/core/secret-env.ts`) spelled seven value rules of its own (credential assignment, webhook URL, SonarQube login, private-key header, `Authorization:` header, `token <value>`, `Bearer` / `Basic <value>`) and read a token head from a `tokenPrefix` member of the table that no row owned.
400
+ - **Now.** `CREDENTIAL_VOCABULARY` has twenty-six rows (`src/primitives/secret-vocabulary.ts`). New: `pypi-token`, `slack-app-token`, `basic-credential`, `token-scheme`, `sonar-login`, `webhook-url`. Widened: `gitlab-pat` (thirteen prefixes, and a strict form: a body holding a digit), `slack-token` (`xoxe-`), `stripe-secret-key` (strict `sk_org_` / `rk_org_`), `private-key` (SSH2 and PuTTY containers), `signed-url-param` (every URL credential name, below). A row's environment-value form (`envValue`) and token head (`envValueHead`) are members of the row; the env scrub reads them through `envValueView()` — `forms` (each row's `envValue`, table order), `tokenHead` (each row's `envValueHead` as one anchored alternation, the same ten heads `tokenPrefix` held: `gh[opusr]_` `github_pat_` `sk-` `pk-` `glpat-` `npm_` `ya29.` `xox[abpr]-` `AKIA` `eyJ`) and `flagWords` (the table's). The environment faces answer as before on every base fixture and on 270 texts (`looksLikeCredentialValue` and `isSecretEnvKey`: zero changes, base `c9bc43b3b` against this tree; the scrub reads those two). The signed-URL row's value run (and the new SonarQube row's) ends where every value run ends, so a backslash-escaped closing quote stays whole: such a parameter inside a JSON string inside a JSON string no longer breaks the outer document (KNOWN-LIMITS KL-958-d, its signed-URL clause closed).
401
+ - **Hard-breaking — three sentences (open to veto, @server @ss @cli @client-core).** *What changed:* (1) the engine's one egress pass (`egressText`, both tiers — so `redactSecrets`, `redactHostLeaks`, the activity-argument summary and every face that writes through it) now withholds the forms listed below, where it let them through; (2) the durable memory write door (`detectSecret`, read by the engine's write scan `scanMemoryWrite`) refuses five more strict shapes — a `secret` finding naming the family, so the engine refuses the write: `gitlab_pat` (thirteen prefixes, a body holding a digit — `glpat-` included, which the door let through before), `pypi_token`, `slack_token` (`xoxe-`), `slack_app_token` and `stripe_secret_key` (`sk_org_` / `rk_org_`). *Who is affected:* a host that pins "egress equals input" for one of these forms, and a host whose memory writes held one of these strict shapes. *Compensation / migration:* re-pin the egress assertion to the `[redacted]` form; remove the credential from the memory write (nothing else moves — no verb, frame, code or option changed).
402
+ - **Hard-breaking — type level (open to veto, @server @cli @client-core).** *What changed:* `CredentialVocabulary.tokenPrefix` and `EnvNameView.tokenPrefix` are gone from `@sema-agent/primitives` (exported since 7.63.0), and `CredentialVocabulary` gains the required member `flagWords` (`names`, below, is the other required addition). *Who is affected:* a reader of either removed member, and a caller that builds a `CredentialVocabulary` literal by hand to pass to `envNameView` / `envValueView` — none in core; at origin/main a name search finds no `tokenPrefix` in the server, settings-schema, cli, client-core, sdk, desktop, web-client and web-admin trees (the test tree holds it only in copied evidence text) and no `CREDENTIAL_VOCABULARY` / `envNameView` reader in the server, cli, client-core, sdk and desktop trees. *Compensation:* `envValueView().tokenHead` — the same branch set, built from the rows; a hand-built vocabulary adds `flagWords` and `names` (spread them from `CREDENTIAL_VOCABULARY`).
403
+ - **Newly withheld forms (one line each; synthetic examples, every value a filler).**
404
+ - `gitlab-pat`: `gldt-` `glrt-` `glrtr-` `glcbt-` `glptt-` `gloas-` `glft-` `glimt-` `glagent-` `glwt-` `glsoat-` `glffct-` + ≥ 20 token characters (deploy, runner, CI build, trigger, OAuth app, feed, incoming-mail, agent, workspace, service-account, feature-flag tokens); `glpat-` was already withheld.
405
+ - `pypi-token`: `pypi-` + ≥ 85 characters (an upload token), with or without a digit.
406
+ - `slack-token`: `xoxe-` + ≥ 10 characters (a refresh token). The wide form is broad, as it was for `xoxb-`: a prose slug behind the head (`xoxe-session-expiry-notes`) is withheld too; the strict form and the memory door leave it.
407
+ - `slack-app-token`: `xapp-<digit>-` + ≥ 20 characters (an app-level token); the same for a slug (`xapp-1-setup-guide-for-the-team`), withheld on egress, admitted by the memory door.
408
+ - `private-key`: an SSH2 `---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----` block, a PuTTY `PuTTY-User-Key-File-<n>:` container through its `Private-MAC:` line, and a headless `Private-Lines: <n>` body; public blocks and the field names in prose are not read.
409
+ - `basic-credential`: `Basic` (any case) + ≥ 8 base64 characters holding a digit, two humps or `+` / `/` / `=` (`Basic auth is disabled` and `a basic understanding` are not read).
410
+ - `token-scheme`: `token` / `Token` / `TOKEN` + ≥ 20 token characters holding a digit, not followed by `/` or `.` (a path segment after it is not read).
411
+ - `sonar-login`: `sonar.login` `=` / `:` a value of ≥ 8 characters, quoted or not, in JSON too.
412
+ - `webhook-url`: an `https://` Slack (`hooks.slack.com/services|workflows|triggers/`), Discord (`discord.com` / `discordapp.com`, `ptb.` / `canary.`, `/api/webhooks/<id>/`) or Teams (`<tenant>.webhook.office.com/webhookb2/`) webhook URL's secret path, ≥ 16 characters; the bare head and a docs path are not read. On the `human` tier the URL was already withheld whole.
413
+ - `signed-url-param`: a URL query or fragment parameter named by any of the twenty-four URL credential names (#3340 below; was `sig`, `signature`, `sas`, `code`) — e.g. `X-Amz-Signature=…`, `X-Amz-Security-Token=…`, `apikey=…`, `access_token=…`, `client_secret=…` — the name and `=` kept, the value withheld.
414
+ - **Old fixtures.** One verdict moved: `gitlab-cc` (a `glpat-` token with a digit, from the reference implementation's rule) is now refused by the memory write door as `gitlab_pat` (it was let through; egress already withheld it). No other base fixture moved on any face (egress, host tier, activity summary, refuse, env value, env name).
415
+ - **Rules.** Six rows of data (+6) and five widened rows (data); seven env value rules moved onto rows (−7 rules, +1 view); `tokenPrefix` retired (−1).
416
+ - **Consumers.** @server: the union rows are the server's own shapes — your redaction can read `CREDENTIAL_VOCABULARY` instead of its copies at S3b; the memory refusals above reach your memory routes as the engine's `secret` rejection (`scanMemoryWrite`, `detected <family>`). @ss: the private-key containers are yours; the S2b retirement of your copies reads the rows. @cli @client-core: re-pin any test that asserts a raw form above survives egress. @test: the egress, refuse and env faces per form are in the pins.
417
+ - **Pins.** `test/backlog3339-union-rows.test.ts` — U0 the fixture gate over every row, grade and the env view · U1 each newly withheld fixture is gone from every egress face (24 fixtures) · U1b this section names each newly withheld family · U2 / U2b the eight newly refused fixtures by the detector and by the engine's write scan, and their prose neighbours admitted · U3 the thirteen GitLab prefixes · U4 the scheme tokens and the three-segment JWT · U5 / U6 the env value view on the real seat, no value form spelled in `secret-env.ts` · U7 / U7b / U7c the token head built from the rows and equal to the reference implementation's branch set, no `tokenPrefix` anywhere · U8 / U8b every URL credential parameter at nesting depths 1–6 and the SonarQube login in nested JSON keep the documents parseable. Fixtures: `test/fixtures/secret-detect-fixtures.json` (synthetic fillers only), gated by `scripts/verify-credential-vocabulary.mjs`.
418
+
419
+ ### Secret readings are a closed set of named readings in `@sema-agent/primitives` — `percent-layers` (its depth the caller's), `percent-boundary` and `form-plus` join `raw` and `format-free`, each a pure view of the text with a way back to written coordinates; and one names table answers which name marks a credential in an assignment or a URL parameter (#3340 = #3223 S2a, ruled C-R1084 K2 / K7 and addendum 1; behavior change: none on any engine face — the engine reads no text reading; hard-breaking: one, type level — `CredentialVocabulary` gains the required member `names` (told with `flagWords` in the #3339 section's type-level sentence); closed sets: `SECRET_READING_KINDS` +3 (`percent-layers`, `percent-boundary`, `form-plus`), new `CredentialNamePlace` (`assignment`, `url-param`); exports: `@sema-agent/primitives` +1 value `secretReadingViews`, +5 types `SecretReadingKind` `SecretReadingView` `SecretReadingViews` `CredentialNameRow` `CredentialNamePlace`; members: `CredentialVocabulary` +`names`; the `SecretReading` union +3 members) (@ss @server @client-core @test)
420
+
421
+ - **Before.** The settings package scanned a text through three readings of its own (`secret-scan.ts`: percent-decoded layers, a run of `%HH` escapes read as UTF-8, `+` read as a space) with no way back to the written text's coordinates; its URL credential parameter names (`CREDENTIAL_PARAM_NAMES`, twenty-three), the engine's signed-URL parameter list (four) and the engine's keyword words (six) were three lists answering one question.
422
+ - **Now.** `src/primitives/secret-readings.ts`: `SECRET_READING_KINDS` = `raw`, `format-free` (character readings: how one text is scanned) and `percent-layers` (`{ kind: "percent-layers", depth }`, depth an integer 1 … 8), `percent-boundary`, `form-plus` (text readings: each derives more texts, scanned the same way). `secretReadingViews(text, readings)` answers the views — the written text first, each text once — each with `toOriginalSpan(start, end)`, the whole written units a span was read from (a decoded escape's three characters, every escape of a decoded code point: a mapped-back span never cuts an escape), and `unresolved`: the layers ran out while one more would still decode. `scanSecrets` / `renderSecrets` read a policy's text readings the same way (spans in written coordinates; a hit in a view withholds its written units), and answer `{ outcome: "whole", reason: "reading-unresolved" }` / the over-strip mark only under `onUnresolvedReading: "secret"`; under `"ignore"` the views read are scanned. A reading is checked whole: an unknown kind, a member a kind does not take, a missing or out-of-range depth, `percent-layers` listed twice, or no character reading throws a `TypeError`. The views equal the settings package's own `forms` / `unresolved` on its cases and on 6000 seeded strings (frozen oracle in the pin). `CREDENTIAL_VOCABULARY.names` (`{ name, places }`, `places` ⊆ `assignment` / `url-param`) is the one names table: twenty-five names — the settings package's twenty-three and `code` read as URL parameters, `token` `secret` `key` `password` `passwd` `credential` read in an assignment; the keyword row reads the `assignment` names, the signed-URL row the `url-param` names.
423
+ - **Narrowing / widening.** None on any engine face from the readings: the engine's own policies read `raw` and `format-free` only. The widening of the URL parameter row by the merged names is told in the #3339 section above; the renderer change the review of this section found (kept parts, #3483) is the next section.
424
+ - **Rules.** Three readings move into the package as closed-set members (no new rule); the three name lists become one (−2).
425
+ - **Consumers.** @ss: S2b replaces your three readings and `CREDENTIAL_PARAM_NAMES` with `secretReadingViews` (at the `percent-layers` depth you read today, 3) and `names`; until then your copies and the package's answer the same (the pin's frozen oracle is your code at origin/main `30bceb5`). Open to veto (@ss), the one point of this section: the names merge — your `CREDENTIAL_PARAM_NAMES` retires at S2b in favour of `names`. @client-core: the depth is a parameter, as asked. @server: nothing to change.
426
+ - **Pins.** `test/backlog3340-readings.test.ts` — R0 the closed set and the reading checks · R1 / R2 the settings package's cases and 6000 seeded strings against its frozen normalization · R3 the depth is the caller's · R4 the way back covers whole written units · R5 / R6 the renderer and the matcher read through the text readings, spans in written coordinates · R7 `reading-unresolved` only under `secret` · R8 / R8b / R8c one names table, read by the URL parameter row (every `url-param` name, any case, whole names) and the keyword row.
427
+
428
+ ### A part a pass keeps — a URL username, a key name, a header label — is the written text, read by every other scan: a key another scan finds inside it is withheld, and a format character inside it survives (#3483, found by the review of the #3340 section on the format-free renderer; behavior change: egress withholds one form it printed, prints a kept label as written, and returns a long text it threw on; hard-breaking: none; closed sets: none; exports: none) (@server @cli @ss @client-core @test)
429
+
430
+ - **Before.** With the `format-free` reading on — the engine's egress policy reads it — each match on the format-free view was spliced back whole, its kept parts written from the view, and a hit the raw text or a format-character cut found inside a kept part was absorbed into that match. `redactSecrets("https://x<U+200B>sk-<20 characters>:pw@host/")` returned `https://xsk-<20 characters>:[redacted-credentials]@host/`: the key in clear (7.63.0 and 7.64.0 alike). The kept part lost its own format characters (`pass<U+200B>word=<value>` → `password=[redacted]`), or the whole match went, label included (`Authorization: Bear<U+200B>er <value>` → `[redacted]`). With the text readings on (the section above), a hit a derived text found inside a kept username was counted as already removed (`https://%73k-<value>:pw@host/<U+200B>` kept the encoded key).
431
+ - **Now.** Every scan's removals are the part its pass withholds — a kept label or username outside it — in the written text's coordinates, and the output is rendered from their union (`renderOneText`, `src/primitives/secret-scan.ts`): `https://x<U+200B>[redacted]:[redacted-credentials]@host/`, `pass<U+200B>word=[redacted]`, `Authorization: [redacted]`. In a text rendered from the union, touching removals that write the same marker write it once (`renderRemovals`), so a rendered text renders to itself: `passw<U+200B>ord=abcd,Authorization:<U+200B> Bearer <value>` → `passw<U+200B>ord=[redacted] [redacted]`, and the same again with no finding. A text the sequential run renders alone still writes one marker per pass, as before: two touching keys read `[redacted][redacted]`, and `[redacted]` once a format character sits elsewhere in the text (the characters withheld are the same; only the marker count differs).
432
+ - **Also fixed (same review).** A long text holding a format character and some 130 000 hits — `"x<U+200B> " + "password=abcd ".repeat(130000)` — made `redactSecrets` throw `RangeError: Maximum call stack size exceeded` instead of returning the redacted text (7.63.0 and 7.64.0 alike): every scan's removals were spread into one call. They are appended one at a time; the text renders. (#3486 — the shipped `RangeError` on a long text with one format character, 7.63.0 / 7.64.0; fixed by the same render law.)
433
+ - **Newly withheld form.** `url-userinfo` + a vendor token: a token in a kept URL username that only the raw text or a format-character cut reads (a format character right before its head).
434
+ - **Narrowing (open to veto, @server @cli @ss).** The newly withheld form above.
435
+ - **Widening (open to veto, @server @cli @ss).** A kept label's own characters — a format character inside it, a label a cut scan's hit used to swallow — are printed as written. No credential character is among them.
436
+ - **Rules.** A removal is the withheld part, for every scan; the merge that absorbed a hit into a kept part goes (−1). The join rule of the union render gains one clause: a removal that touches the one it continues and writes the same marker joins it (+1). Net 0.
437
+ - **Consumers.** @server @cli @client-core @test: a test that pins an egress output of a text holding a format character inside a kept label re-pins to the label as written, and one that pins two touching markers in a text holding a format character re-pins to one.
438
+ - **Pins.** `test/backlog3340-readings.test.ts` — R9a a derived text's key inside a kept username · R9b a raw-only / cut-only key inside a kept username, at the renderer (with its finding) and on `redactSecrets` · R9c a kept label printed as written, a format character outside every hit kept · R9d the long text renders (format-free alone, and raw + format-free) · R9e two scans' touching removals write one marker; the output renders to itself with no finding.
439
+
440
+ ### A credential cut inside its body is read by its family's fragment form — the server's residue arms sit in the rows' `fragment` slots, read by a `fragment` grade of their own (#3341 = #3223 S3a, ruled C-R1084 K5; behavior change: none on any engine face — the engine reads no fragment grade; hard-breaking: none; closed sets: `SecretGrade` +1 (`fragment`); exports: none (members: `ValueFamilyRow` +`fragment?`)) (@server @test)
441
+
442
+ - **Before.** What is left of a vendor token after a text was cut inside its body (a head and a short residue: the shape a truncated preview leaves) was read only by the server's redaction, by arms of its own.
443
+ - **Now.** Nine rows carry a `fragment` form (global): `github-token`, `github-fine-grained-pat`, `openai-api-key`, `stripe-secret-key`, `gitlab-pat`, `pypi-token`, `slack-token`, `slack-app-token`, `aws-access-key-id` — the server's residue arms, the same spans on a seeded corpus, plus the `xoxe-` head the union adds. `scanSecrets` / `renderSecrets` with `grade: "fragment"` read those forms (one pass per row, in the table's order) under the same readings and marks as the other grades; a residue below the wide floor is a fragment hit and no wide one.
444
+ - **Narrowing / widening.** None on any engine face. One reading differs from the server's arms at the left edge: the slot accepts the same quote spellings before a head as the wide forms do, where the server's arm also reads an escaped separator's tail (KNOWN-LIMITS KL-3341-a). The left edge is every wide form's too; widening it to an escape's tail is #3482, and the slot reads the same edge when that lands.
445
+ - **Rules.** Nine slots of data on existing rows, one grade member; no new rule.
446
+ - **Consumers.** @server: S3b reads the slots with `grade: "fragment"` in place of your arms. @test: the residue fixtures state `fragment`.
447
+ - **Pins.** `test/backlog3341-fragment-slots.test.ts` — F0 exactly the nine families, every form global · F1 each slot reads what the server's arm reads (frozen arms, seeded corpus) · F2 the union head · F3 every fixture that states `fragment`, at the matcher and the renderer · F4 the grade is its own · F5 the left boundary · F6 the readings apply · F7 one pass per row, in the table's order.
448
+
449
+ ### A deny or ask entry that names a tool the engine retired with no successor is left out of the run's name audit and told — one `config.legacy_tool_name` notice per audited layer replaces the refusal of the whole run (#3437; ruled C-R1110; behavior change; behavior narrowing: none; widening — one, open to veto; hard-breaking: none; closed sets: `EngineNoticeCode` +1, `config.legacy_tool_name` (audience `user`, minter `engine`; the spelling was already a thrown code and still is); exports: none; wire: notice code +1, additive) (@cli @server @client-core @test)
450
+
451
+ - **Before.** The prepare-time policy-name audit refused the whole run (`config.legacy_tool_name`) for any retired tool name on a `deny` or `ask` list — the run's own policy (`--disallowedTools`, a deployment's deny list), the session's stored rules, or the rules an ancestor's session handed down. A user's own `TaskOutput` or `TeamCreate` line, copied from an older setup, stopped every run (cli L-2316). The reference accepts such a name and never matches it, without a word.
452
+ - **Now.** One reading of the retirement table's own grammar. A retired name whose line says `removed` or `folded` — it has no `currentName`, no tool answers to it now or later — is left out of the audit's pass and told: ONE notice `config.legacy_tool_name` (audience `user`: the person who wrote the entry believes it guards a tool) per audited layer per prepared task, minted by `retiredToolNameNotice` and nowhere else, said only when the run goes on. `detail: { layer, entries: [{ field, entry, layer, guidance }], total, sessionId }` — `layer` is `caller_policy` / `session_rules` / `ancestor_session_rules`, `field` is `deny` / `ask`, `guidance` the retirement table's own line, `entries` unique by (field, entry) in scan order and at most 32, `total` counting every one. Every other row of the same list is audited and enforced as before; the entry itself stays where it was written and matches nothing. A retired name that was RENAMED (it has a successor, `bash` → `Bash`) is not this: its entry guarded a tool that is still mounted, so leaving it out would widen the surface, and it is refused as before with the name to write. Every other bad name (an unprefixed namespace name, an unmintable segment, a case twin of a mounted tool) is refused as before; an `allow` list keeps its advisory; a deployment that mounts its own tool under a removed name is unaffected (the roster clears it).
453
+ - **Widening — one (open to veto).** A run whose `deny` or `ask` list holds a removed or folded name starts where it was refused. The only thing that entry could have guarded is a tool no roster mounts; the notice is the loud half. This is one step past the reference, which says nothing (a deviation, open to veto: the bad-value rule asks for a loud answer).
454
+ - **Rules.** Added: the notice (the catalog, its audience and minter rows), one factory. Retired: the refusal of a `removed` / `folded` name on a restricting list. The retirement table stays the one table.
455
+ - **Consumers.** @cli: `config.legacy_tool_name` now also arrives as an engine notice (user audience) — render it where session notices render; the thrown code on a renamed name is unchanged, so a line that matched the thrown error for a removed name no longer fires — drop it. @server: pass-through, nothing to change; a policy compiled from settings with a removed name now starts. @client-core: if you mirror the engine notice catalog (`EngineNoticeCode`), add `config.legacy_tool_name` (audience `user`) — whether you mirror it was not checked. @test (black box): `deny: ["TeamCreate"]` ⇒ the run completes and one `config.legacy_tool_name` notice names the entry; `deny: ["bash"]` ⇒ refused as before, no notice.
456
+ - **Claude Code 2.1.316.** Anchored for the name's acceptance: the command-line deny list goes into the rule set unchecked (`cli316.js:277082`, `Yu(disallowedToolsCli)`), where the allow side is filtered and an unusable rule is reported as "Ignoring --allowedTools rule" (same line); the renamed-name alias table is `:260527` (eight names, mapped to the current tool) and the removed-name set `:270313` (`TeamCreate`, `TaskOutput`, … — kept for transcript consistency), the two classes the split above follows. The notice is the one addition (a deviation, registered with the divergences). All read in the corpus for this change, not run.
457
+ - **Pins.** `test/backlog3437-retired-name-left-out.test.ts` — N1 / N2 a removed name on a deny / ask list · N3 the other rows still bind · N4 a renamed name is still refused, alone and beside a removed one, with no notice · N5 every other bad name is refused · N6 an allow list keeps its advisory · N7 / N8 a session row, and one notice per layer · N9 one notice per pass · N10 a deployment's own tool under a removed name · N11 the catalog rows · N12 the factory's bound; `test/backlog3026-taskoutput-retired.test.ts` T5 re-pinned to the new reading. Mutations (receipt).
458
+
459
+ ### The approval-record store's failures at the entries that make and settle a record are refusals — `confirmRuleApproval` and the card edit answer `store_read` / `store_write`, and `prepareCardApproval`, `prepareCcImport` and `prepareStarterBatch` answer the refused arm, where they let the rejection out (#3430; ruled C-R1111; behavior change; behavior narrowing — one, open to veto; hard-breaking: one, type level, three sentences below, open to veto; closed sets: `ConfirmRefusalReason` +2, `store_read` and `store_write` (words `RuleRefusalCode` already holds); exports: none; wire: no key added) (@server @cli @client-core @test)
460
+
461
+ - **Before.** Since #3428 the redemption leg answers a failure of the approval-record store as `store_read` / `no` (a read) and `store_write` / `unknown` (a compare-and-set, a dot allocation). The entries that make and settle the record let the same store's rejection out as a bare throw: `prepareCardApproval`, `prepareCcImport`, `prepareStarterBatch` (`create`), `confirmRuleApproval` (`get`, `cas`, the re-read after a lost `cas`) and the card edit (`cas`, the re-read). One store, two failure readings.
462
+ - **Now.** One reading, one mint (`refusal()` through `storeStep`), no new code. `ConfirmRefusalReason` takes `store_read` (a read threw — nothing of this confirmation was written) and `store_write` (the compare-and-set threw — a backend can commit and lose its acknowledgement, so the record may or may not be settled; repeating the same confirmation is the idempotent yes), with the store's own message in `detail.message`; a confirmation carries no `committed` of its own, the word says it. The three prepare entries answer the redemption leg's refused arm, `{ status: "refused", code: "store_write", committed: "no", retriable: true, reason }` (`committed` read the store table's one way, #3492's section: a prepare writes no rule), where they rejected (a record that failed to create may still exist; nobody holds its id, so a repeat prepares a fresh card). The sentence names the step and carries the store's own message. An import with nothing importable creates no record and refuses nothing, as before.
463
+ - **Narrowing — one (open to veto).** The five entries resolve with a refusal where they rejected, for a failure of the approval-record store. A host that caught the rejection reads the result now.
464
+ - **Hard-breaking — one, type level, three sentences (open to veto).** *What changed:* the results of `prepareCardApproval`, `prepareCcImport` and `prepareStarterBatch` gain the refused arm (a union member), and `ConfirmRefusalReason` gains two words. *Who is affected:* any host that destructures `approvalId` (or `preview`) from a prepare result, or switches exhaustively over `ConfirmRefusalReason`, no longer compiles until the refused arm and the two words are handled — @server (the rules-consent door, read at its origin/main checkout, not compiled against this tree), @cli and @client-core where they mirror the types; no engine-internal caller exists. *Compensation:* branch on `"status" in result` (or `result.status === "refused"`) before reading the prepare result, treat `store_read` as a retry-safe read failure and `store_write` as "reconcile with a repeat of the same call" (a prepare's refused arm says whether to repeat in `retriable`; read that, not the code).
465
+ - **Rules.** Retired: the rejection escape of the approval-record store at these five entries (`storeStep` routes them). Added: none (three sentence constants; the helper that puts a store refusal in the confirmation's shape reads the one mint's output).
466
+ - **Consumers.** @server @cli @client-core: map `store_read` / `store_write` on a confirmation as for a redemption, and the refused arm on a prepare as for a redemption's. @test (black box): an approval-record store whose `create` throws ⇒ every prepare entry answers the refused arm; whose `get` throws ⇒ the confirmation answers `store_read`; whose `cas` throws ⇒ `store_write`.
467
+ - **Claude Code 2.1.316.** No anchor: Claude Code keeps no persisted permission-rule approval record.
468
+ - **Pins.** `test/backlog3430-approvals-record-store-failure.test.ts` — P1–P3 the three prepare entries over a throwing `create` · P4 the record read · P5 / P6 / P7 the compare-and-set that throws, that commits and loses its acknowledgement, that loses and meets a throwing re-read · P8 the card edit · P9 the census · P10 controls · P11 one mint; `test/backlog3428-approvals-store-failure.test.ts` header sentence updated. Mutations (receipt).
469
+
470
+ ### The instruction-hold ledger and its captured bytes ride the governance store — a hold's row is the `holds` document's, its custody the `hold` object, its disposal a move to a `quarantine` object, an orphan of an older disposer adopted from the objects; `resolveHold` and `readInstructionHolds` answer Promises (#3485, C-R1119 S2a′ = addendum 5; behavior change: one — for a backend that carries a governance store which is not the File store over the engine's control plane, the hold family now lives in that store; behavior narrowing — three, open to veto; hard-breaking: one (HB-2, two faces), three sentences below, open to veto; closed sets: none; exports: none — the hold functions are module functions, not on the package root; members: `MemoryEngine.resolveHold` returns `Promise<void>`, `MemoryEngine.readInstructionHolds` returns `Promise<HoldRow[]>`; wire: none) (@server @dgx @test)
471
+
472
+ - **Rule.** The last control-plane family the engine still read and wrote as files moves onto the seat 7.64.0 laid down, under the same law as the families #3466 moved: the hold ledger is read and written through `readDoc("holds")` / `updateDoc("holds", …)`, a hold's custody bytes are the `hold` object `<captureName>`, a disposal moves that object to the `quarantine` object the row names (`holdQuarantineNameOf`, #3464), and a staged generation that retires into custody is a `hold` object too. Every capture is the write-once put every first-record writer asks (`putControlObjectOnce`) read back through the store and hashed against the capture; every "what stands here against this digest?" — custody and seat alike — is one reading (nothing / the captured bytes / anything else, an entry the store will not read counted as anything else, never as missing). No reader or writer of the hold family joins a directory name onto a control-plane path any more.
473
+ - **Before.** In 7.64.0 `delegation-settlement.ts` read and wrote `<the engine's control dir>/holds.json`, `hold/` and the hold seats in `quarantine/` itself, whatever store the backend carried: a replica over a backend carrying another store kept its holds beside itself, so a second replica neither listed them (`readInstructionHolds`) nor settled them (KL-3308-b). The custody write was its own `wx` + fsync + read-back (`writeCustodyVerified`), a retire into custody its own function (`retireStagingToCustody`, beside `retireStagingToObject`), the disposal move its own link-then-unlink with a rename fallback (`moveNoReplace`, KL-3464-a), and the seat's state its own `lstat` reading (`quarantineSeatState`). The reconciliation read the memory root's anchor once at its head and then made every plane act synchronously.
474
+ - **Now.** The engine hands the hold functions `this.governanceStore` (the backend's `governance`, else the File store over its control dir) — for a File backend, and for a backend without a store, the same `holds.json`, `hold/` and `quarantine/` and the same bytes as before. Because every step now awaits the store, the engine's anchor gate (`actRefused: (path, act) => this.storeActRefusedText(path, act, handle)`, the one predicate and call form every other plane act of the engine uses) is asked immediately before each act on the memory plane that follows an await: the intake's rename after the custody write (`"holding an instruction-form file"`; a refusal disposes the row `discarded`, the custody bytes go to the row's seat, the plane file stays for the caller's containment), the reconciliation's removal of a half-captured hold's plane file (`"removing a held file from the plane"`; a refusal is that arm's ordinary removal failure), the sweep's claim of a staged generation and its drop after a custody write (`"recovering a hold's staged copy"`), and every unlink of a staged copy after it retired (`"removing a hold's staged copy"`). A custody object already standing with the captured bytes is the capture, so a twin intake of the same bytes in the same millisecond (one row, one holdId) no longer disposes the other's hold, which `wx` refused. A disposal and the orphan adoption read what stands at the custody and seat objects just before the ledger's update and decide inside it on the fresh row (the update's callback runs synchronously and reads no object — KL-3308-c covers the window); the bytes move after it. Three disclosure lines name an object, not a path: a retire's coordinate is `hold object <name> in the memory control plane` (was `hold/<name> in …`), the foreign-seat refusal names the seat by its object name (was its absolute path), and a move the store refused says the bytes `stay at the custody seat (hold object <captureName> in the memory control plane)` and carries the store's fault code where the refusal has one, else `move refused` (was the custody file's absolute path and `move refused`).
475
+ - **Narrowing — three (open to veto).**
476
+ 1. On a filesystem **without hard links**, an instruction file is no longer held, and **no copy of it is kept**: the File store publishes an object by a hard link (since 7.64.0, #3465), so the custody write fails and the hold is refused (`hold capture verification failed …`); the file then takes the ordinary containment, whose quarantine copy is the same publication (#3466) and fails too, and the containment removes the file all the same — a failed capture never stopped a containment — so the session's bytes are gone (an `update` gets its committed version back) and the report says so (the rejection's `quarantine copy FAILED; file removal succeeded`, a `quarantineFailures` row and a `quarantine escalation` warning). 7.64.0 held the file (custody written with `open(wx)`) and released or quarantined it on the delegation's verdict. A disposal move the store refuses leaves the bytes at the custody seat, readable by `readHoldCustody`, retried and disclosed at every harvest; 7.64.0 fell back to a `rename` for the move (which could replace a seat taken in the instant after the look — KL-3464-a, retired). Every quarantine copy and pollution mark on such a control plane already met this with #3466. In this same release (the #3512 section) a File store refuses to open on such a file system (`memory.control_plane_links_unsupported`), so a File control plane no longer reaches this path; it remains the path of a containment whose copy fails for another reason (except a backend a host composes around the root-exported `fileGovernanceStore`, which neither holder probes — KL-3512-c, #3519).
477
+ 2. A half-captured hold whose custody name stands as **an entry the store will not read** (a directory, a dangling link) converges to `capture_lost` at the reconciliation. 7.64.0 already did so for a dangling link (its existence test follows the link and finds the name absent); for a directory it found the name standing and read it, so the reconciliation threw (`EISDIR`, `reconcileHolds` at `delegation-settlement.ts:1245` of 7.64.0, measured on the 7.64.0 dist) and the harvest was refused — an incident naming the error, the row left `capturing` — until a person removed the entry. The narrowing is for a directory only. The bytes it could not read were never trusted as the capture either way.
478
+ 3. The File store's `moveObject` over a target that already stands **as a link** (or as anything but a file of its own) is refused and the source kept: when both names stand, the move finishes by dropping the source only onto the same file under a second name (an interrupted move) or a second file holding the same bytes. 7.64.0's move read both names through their links, so a link at the target that reached the source read as the same file and the source — the only copy — was unlinked (nothing in core called the move before this change; a host that calls it directly meets the refusal). A hold whose quarantine seat is such a link keeps its custody bytes: the disposal lands its verdict, and the move it cannot make is disclosed on the stranded lane and retried at every harvest. 7.64.0's hold code read any link at the seat as foreign and refused the disposal.
479
+ - **Hard-breaking — one (HB-2, two faces), three sentences (open to veto).** *What changed:* `MemoryEngine.resolveHold(holdId, action, requestId)` returns `Promise<void>` and `MemoryEngine.readInstructionHolds()` returns `Promise<HoldRow[]>` (the ledger is a document of the governance store, whose verbs are asynchronous), and a refused valve call (`memory.hold_resolve_unattributed` / `_invalid` / `_unknown` / `_invalid_state`) rejects the Promise instead of throwing. *Who is affected:* a host that calls either without `await` — reads the rows as an array, relies on the verdict being written when the call returns, or catches the refusal with `try` around a synchronous call (none in the server's, the cli's, client-core's or the sdk's tree at origin/main as read before this change; test's `repro/c3463-20261102` drives `resolveHold`). *Compensation:* `await` both, and catch the refusal on the Promise.
480
+ - **Consumers.** @server @dgx: HB-2 above; a store you carry receives the `holds` document and `hold` / `quarantine` objects from engines whose backend carries it (the document and kinds 7.64.0 defined; no new kind). A deployment that switches a running backend to a store carrying `governance` adopts each replica's holds first: `adoptReplicaControlPlane(controlDir, store)` copies the `holds` document and the `hold` and `quarantine` objects (pinned: a replica's hold reads `[]` over the carrier before the adoption and `held` after it); the replica's files stay where they are (the source removal rides #3484, S2b). @test — black box: two engines over one shared store, each with its own control dir: a hold captured through one is listed, resolved, released and disposed through the other, and no `holds.json` or `hold/` appears beside either; control: a File backend keeps `<control dir>/holds.json` and `hold/` as before; HB-2's two faces answer Promises.
481
+ - **Known limits.** KL-3485-a — with several replicas sharing the hold ledger, another replica's reconciliation can read a row in the instant between an intake's row and its custody write, find the custody absent and the file not on its own memory plane, and mark the row `capture_lost`; the intake then writes the custody and still answers held, so the row is disposed while its bytes stay at the custody seat (orphaned custody bytes). It needs a replica identity this change does not add; no such deployment in tree. The release review reproduced the race with a delayed object write; the fix is #3520 (7.66.0, capture ownership / a lease, reviewed with #3359). KL-3465-c now covers only the capture opt-out readers and the adoption's source removal (#3484).
482
+ - **Retired.** KL-3466-a (the hold family on the File control-plane directory until this change), KL-3308-b (a held instruction seen and settled only by the replica that captured it — row and bytes now ride the store together, the ask #3311 recorded, folded into C-R1119 S1) and KL-3464-a (the rename fallback's replacement window — the fallback is gone, narrowing 1).
483
+ - **Rules.** Five fewer: the second write-once-and-verify law (`writeCustodyVerified`), the second retire-into-the-control-plane function (`retireStagingToCustody`, its three hold callers now on `retireStagingToObject`), the second no-replace move (`moveNoReplace`, the store's `moveObject` is the one), the second "what stands at this seat" reading (`quarantineSeatState`'s `lstat` judgment, beside the reconciliation's own read of the custody file), and the disposal's own deletion of a custody object it judged a second copy (whether two names are two copies is the store's move alone, narrowing 3). Added: none — the two helpers (`heldBytesAt`, `holdCustodyVerified`) ask the store's laws, the act gate is the engine's existing predicate in its existing call form, asked where the acts now follow an await, and the store's move keeps its one "both names stand" rule, reading the target without following it.
484
+ - **Claude Code 2.1.316.** No divergence of its own: the reference has no instruction-hold ledger or governance control plane (D-3407-a covers the seat).
485
+ - **Pins.** `test/backlog3485-holds-two-tree.test.ts` imports only names both trees export: on 7.64.0's stage head its eight two-replica rows are red (the hold lands beside the replica that captured it, the faces answer synchronously), here green; its two File-backend controls are green on both. `test/backlog3485-holds-on-the-carrier.test.ts` — the custody write is the write-once put (a custody object standing with the captured bytes opens the hold; other bytes, a damaged slot, a directory at the name refuse it and leave the plane file; an entry the store will not read at the seat refuses the disposal with no seat recorded, and at the custody name of a half-captured hold converges `capture_lost` without throwing) · the gate at each plane act (the intake asks it after the custody write and a refusal disposes `discarded` with the bytes at the seat; the reconciliation's removal, its sweep's claim, its drop after a custody write and a retire's unlink each ask it and a refusal leaves the file where it is; an engine whose memory root is re-pointed while the custody write is in flight never moves the file the re-pointed root reaches) · no verb needs a directory (over a carrier that keeps its objects in memory a hold opens, disposes to its row-derived seat and reads back; an older disposer's orphan is adopted by digest; a ledger the carrier cannot read rejects the read) · a link at the target is never a second copy (the File store's move refuses a target that is a link back to the source or to another file holding the same bytes and keeps the source; a second file of its own and the same file under a second name each finish the move; a hold whose quarantine seat links back to its custody keeps the bytes, lands its verdict and is disclosed on the stranded lane). Re-pinned to the store-shaped, awaited signatures: `backlog1103-memory-root-anchor` (②a, the primitive list), `backlog1105-hardlink-second-name`, `backlog1841-frontmatter-fence`, `backlog3308-governance-doc-seat` (P9: the ledger now moves with its custody — the File control dir holds neither, the store's `holds` document and `hold` object do), `backlog3465-control-plane-carrier` (C11: a replica's hold is read only after the adoption), `backlog3464-quarantine-name-deterministic` (T3d: without hard links the move is refused and the bytes stay at custody, disclosed, a later move finishing it; T5b's stranded line names the seat object), `backlog778-cross-filesystem-control-plane` (the retire is `retireStagingToObject`), `design336-backfill-hardening`, `design336-slice2-settlement-hold`, `memory-layout-migration`.
486
+
487
+ ### A head word right behind a JSON escape starts where it starts behind the character the escape stands for — `\n`, `\t`, `\r`, `\b`, `\f` and `\uXXXX` are word starts on the wide side, for every row that starts a head word (#3482; behavior change: egress withholds a token, a scheme credential or an assignment right behind such an escape, and leaves the azure placeholder behind one to its row, and the keyword row reads every spelling of the azure field the azure row does not read; narrowing: two, security, open to veto; widening: one, open to veto; hard-breaking: three sentences below, open to veto; closed sets: none; exports: none) (@server @cli @ss @client-core @test)
488
+
489
+ - **Before.** The wide side's word start (`WORD_START`, `src/primitives/secret-vocabulary.ts`) read the character before a head word as written: after no letter or digit, or right after a quote in any spelling. In a JSON string an escaped control character is two characters, a backslash and a letter (`\n`, `\t`) or a hex digit (`\u000a`); the letter read as the tail of a word, so the head word behind it did not start: `redactSecrets('{"m":"line\nghp_<36 characters>"}')` returned the token in clear, while the same token behind a space was withheld (7.64.0 alike). The same held for `sk-` and every vendor head, `Bearer`, `token`, a keyword assignment (`\npassword=<value>`) and the fragment forms. The keyword row's check that leaves a value row's field to its row (the azure row's `Account` + `Key`) spelled its own copy of the word start, as written, so `\nAccountKey=<your-key>` was withheld by the keyword row where `AccountKey=<your-key>` behind a space is the azure row's and stays clean.
490
+ - **Now.** The word start holds one more spelling: right after an escape whose last character is a letter or digit (`ESCAPE_TAIL`: a backslash and `b` `f` `n` `r` `t`, or `\u` and four hex digits of either case; the percent escape `%HH` is the same spelling's third form, #3487 below), whatever character the escape stands for. `\"`, `\\` and `\/` end in no letter or digit and were starts already; two layers of escaping (`\\n`) read as one. The front-word check reads the same word start. Every fixture of the table (188 texts) behind each of `\n` `\t` `\r` `\b` `\f` `\u000a` `\u00AB` `\u00e9` `\\n` renders as it does behind a space. The strict grade (the durable memory write door) is unchanged: it anchors with `\b`.
491
+ - **Hard-breaking — three sentences (open to veto, @server @cli @ss).** *What changed:* the engine's egress pass (`egressText`, both tiers — `redactSecrets`, `redactHostLeaks` and every face that writes through it) and the wide and fragment grades of `scanSecrets` / `renderSecrets` withhold a credential right behind a JSON escape whose last character is a letter or digit, and an azure account key in a spelling the azure row does not read (`AccountKey =`, `AccountKey: `, `AccountKEY=`, a quoted value), where they let it through. *Who is affected:* a host that pins "egress equals input" for a JSON-encoded text holding such a form; the server's own egress seat already withholds these forms (its escaped-separator table), so the output that changes is that of a host embedding the engine's pass. *Compensation / migration:* re-pin the assertion to the `[redacted]` form; nothing else moves (no verb, frame, code, option or type changed).
492
+ - **Narrowing (open to veto, @server @cli @ss).** Two. (1) The forms above. Over-strip, stated: an escape of a letter or digit right before a head word (`\u0041sk-<value>`) and a literal backslash-`n` in a Windows path (`C:\nsk-dev-environment-config`) read as starts too. (2) The keyword row left the azure field (`Account` + `Key`) to the azure row whatever followed the keyword, while the azure row reads only `AccountKey=` and a body of its class: `AccountKey =<key>`, `AccountKey: <key>`, `AccountKEY=<key>`, `AccountKey="<key>"`, `AccountKey= <key>`, `AccountKey=%2B<key>` were read by neither row and printed behind a space (7.64.0 alike), and — once the escapes are word starts — behind an escape too. The keyword row now leaves the field to its row only where it is spelled as that row reads it (`VALUE_ROW_FIELDS` carries the row's separator and the class of a value's first character, with the placeholder's `<`), and reads every other spelling itself. Over-strip, stated: a placeholder written in a spelling the row does not read (`AccountKey =<your-key>`) is withheld, as it was behind an escape in 7.64.0. Measured: of 100 forms (ten spellings × two values × five left neighbours) none prints the key on this tree where 7.64.0 withheld it; `Accountkey=` (lower-case `k`) prints on both trees and is not this check (#3497).
493
+ - **Widening (open to veto, @server @cli @ss).** The azure placeholder `AccountKey=<your-key>` right behind an escape or a spelled quote (`\n`, `\u0022`, `%22`, `\x22`) is left to the azure row and printed, as behind a space; the keyword row withheld it. A key of 40 characters or more is withheld by the azure row as before. No credential character is among the widened form.
494
+ - **Rules.** The word start gains one spelling (+1); the front-word check's own copy of the word start goes (−1); the front-word check reads the field as its row spells it (the table entry gains two columns, the check stays one), and the azure field's name, separator and body class are one constant the row and the table entry both read (the row's expressions byte-identical). Net 0.
495
+ - **Consumers.** @server: your escaped-separator table's JSON row is this spelling; nothing to change. @cli @ss @client-core: re-pin a test that asserts such a form survives egress (@client-core: where you consume the scan from `@sema-agent/primitives`). @test: the forms per row are in the pins.
496
+ - **Pins.** `test/backlog3482-escape-tail-left-edge.test.ts` — E1 the three forms and the space control · E2 the matcher's span behind an escape · E3 every fixture behind every letter-tail escape renders as behind a space · E4 `\"` `\\` `\/` starts as before · E5 an escaped letter starts, a written one does not · E6 the azure placeholder and key behind an escape · E7 the fragment grade · E8 a JSON text stays JSON · E9 the azure field left to its row only in the row's spelling, behind a space and behind each escape. `test/backlog954-credential-vocabulary-parity.test.ts` (#954, the ledger that pins the regex text) re-spells the head start and the keyword row's front-word check.
497
+
498
+ ### A URL username whose vendor head is percent-encoded is read one decode layer down, and a percent escape is a word start as a JSON escape is — `https://%73k-<value>:pw@host/` withholds the userinfo whole; `?q=%20sk-<value>` withholds the key (#3487; behavior change: egress withholds the whole userinfo of a URL whose kept username, decoded once, reads as a credential, and a credential right behind a `%HH` escape; narrowing: two, security, open to veto; widening: one, open to veto; rendered form: one, no credential character printed by either form; hard-breaking: three sentences below, open to veto; closed sets: none; exports: none) (@server @cli @ss @client-core @test)
499
+
500
+ - **Before.** Under `urlUserinfo: "keep-username"` (the engine's egress policy) the username was kept as written; only the password, a bare username of 20 characters or more, or a userinfo holding a second `@` was withheld. A URL userinfo is percent-encoded by its grammar (RFC 3986 §3.2.1), so a vendor head can be spelled with its own first byte encoded: `redactSecrets("https://%73k-<value>:pw@host/")` returned `https://%73k-<value>:[redacted-credentials]@host/` — `sk-<value>` for any reader that decodes the URL (7.64.0 alike; `%67hp_`, `%6Epm_` / `%6epm_` the same). No left boundary reaches this form: the encoded byte is the head's own. Separately, the word start (`WORD_START`, `src/primitives/secret-vocabulary.ts`) read a percent escape's last hex digit as a word's tail: `?q=%20sk-<value>` and `a%2Fsk-<value>` printed the key, where `?q= sk-<value>` withheld it.
501
+ - **Now.** Two parts, each one rule. (1) The word start's escape spelling (`ESCAPE_TAIL`) holds the percent escape: `%` and two hex digits of either case, whatever byte it stands for. Every fixture of the table (188 texts) behind each of `%20` `%0A` `%2f` renders as it does behind a space; a `%` that starts no escape (`%G1`, `%2` at a word) is no word start. (2) The URL userinfo pass (`userinfoWithheld`, `src/primitives/secret-scan.ts`) reads the username it would keep once more, one tolerant percent-decode layer down — the same layer the `percent-layers` reading decodes (`percentDecodedOnce`, `src/primitives/secret-readings.ts`, no second decoder); a username holding no `%`, or one the layer leaves unchanged, is not re-read. When any wide form reads the decoded text, the userinfo is withheld whole, as one holding a second `@` is. Only the username is read: the password is withheld already. Controls: `%53k-` decodes to `Sk-`, which no row reads, and is kept as a written `Sk-` is; an encoded e-mail (`john%40example.com`) is kept. Depth: the pass decodes one layer of each text it scans. The engine's faces read raw + format-free and so reach one layer of encoding; a caller reading `percent-layers` at depth N scans each derived text the same way and so reaches N + 1 encodings of a username, and no more.
502
+ - **Rendered form (not a narrowing; @server @cli @ss).** Where the decoded username reads as a credential, one marker for the whole userinfo replaces the two (username, password) that a percent reading's hit inside the username used to render: `https://[hidden]@host/` where `https://[hidden]:[hidden]@host/` was printed. Neither form prints a credential character.
503
+ - **Hard-breaking — three sentences (open to veto, @server @cli @ss).** *What changed:* the engine's egress pass (`egressText`, both tiers — `redactSecrets`, `redactHostLeaks` and every face that writes through it) and the wide grade of `scanSecrets` / `renderSecrets` / `isSecretShaped` withhold the whole userinfo of a URL whose username, decoded once, reads as a credential, and a credential right behind a `%HH` escape, where they printed them; under a percent reading such a userinfo renders as one marker where it rendered as two. *Who is affected:* a host that pins "egress equals input" for such a URL or a percent-encoded query value, or pins the two-marker userinfo form under a percent reading; the server's egress seat already withholds these forms (its union view), so the output that changes is that of a host embedding the engine's pass and of a direct `renderSecrets` caller. *Compensation / migration:* re-pin the assertion to the withheld form; nothing else moves (no verb, frame, code, option or type changed).
504
+ - **Narrowing (open to veto, @server @cli @ss).** Two, the forms above. Over-strip, stated: an escape of a letter or digit right before a head word (`a%41sk-<value>`) and a head after an encoded separator in a path segment (`a%2Fsk-dev-environment-config`) read as starts; a username whose decoded text any wide form reads is withheld whole, a decoded keyword assignment (`password%3D<value>`) included.
505
+ - **Widening (open to veto, @server @cli @ss).** The azure placeholder `AccountKey=<your-key>` right behind a percent escape (`%0A`, `%20`, `%2f`) is left to the azure row and printed, as behind a space; the keyword row withheld it (both trees measured). A key of 40 characters or more is withheld by the azure row as before. No credential character is among the widened form.
506
+ - **Known limit.** KNOWN-LIMITS KL-3487-a: the percent reading decodes one layer per text; a vendor head encoded twice or more is out of the engine faces' reach, and outside a URL userinfo the engine faces decode no layer — the host's egress seat covers both.
507
+ - **Rules.** The word start's escape spelling gains one form (+1); the userinfo pass reads the kept username one layer down (+1), on the decode layer the readings already have. Net +2, no per-row case.
508
+ - **Consumers.** @server: your union view (S-103 ①) withholds these forms already and is the cover KL-3487-a names — please name it in your arrival post; nothing to change. @cli @ss @client-core: re-pin a test that asserts such a URL or query survives egress, or the two-marker userinfo form (@client-core: where you consume the scan from `@sema-agent/primitives`). @test: the forms per row are in the pins.
509
+ - **Pins.** `test/backlog3487-userinfo-percent-decoded.test.ts` — P1 the encoded heads, renderer and matcher · P2 the plain head, `%53k-`, an encoded e-mail, an undecodable `%` · P3 one layer per text and the depth rule (depth 1 reaches `%2573k-`, not `%252573k-`) · P4 only the kept username is decoded · P5 `whole` as before · P6 every fixture behind a percent escape renders as behind a space · P7 a `%` that starts no escape · P8 a rendered text renders to itself. `test/backlog3340-readings.test.ts` R5 (a percent escape's tail starts a head for the raw text too; a form only the boundary reading reads, `x %73k-<value>`) and R9a (`%73k-` and `%2573k-` under three layers render one marker). `test/backlog954-credential-vocabulary-parity.test.ts` re-spells the head start.
510
+
511
+ ### The pollution markers, the import completion receipts and the quarantine captures outside the hold ledger are read and written through the governance store's control objects — the engine and the File backend no longer derive a control-plane path for them, the delegation settlement seat carries no directory, and `MemoryEngine.sessionPollution` answers a Promise (#3466, C-R1119 S2a and addenda 4 and 5; behavior change: one — for a backend that carries a governance store which is not the File store over the engine's control plane, these records now live in that store; behavior narrowing — four, open to veto; hard-breaking: two, three sentences each below, open to veto — HB-2 on one face, HB-3 second half; closed sets: none; exports: none by name; members: `MemoryEngine.sessionPollution` returns `Promise<SessionPollutionRecord | undefined>`, `DelegationSettlementSeat` −`controlDir` (reached through `ToolExecuteContext.delegationSettlement`); wire: none) (@server @dgx @test)
512
+
513
+ - **Rule.** The three record families move onto the seat 7.64.0 laid down: a pollution marker is the `pollution` object `<session>.json` (an occupant's own slot `<session>@<incarnation>.json`), a bundle import's completion receipt is the `import-receipt` object `<bundleHash>.json`, and a suspect file's copy kept by a containment — the harvest rungs, the inbound gate, the residue capture at mount, a staged copy dropped at mount — is a `quarantine` object `<now>-<basename>` (then `.1` … on a name that stands). Each is read and written through `putObject` / `getObject` / `listObjects` / `deleteObject` and their law (written once, a standing name never replaced, a name that stands but cannot be read never read as missing, an enumeration that fails never read as empty); no reader or writer of these families joins a directory name onto a control-plane path any more.
514
+ - **Before.** In 7.64.0 the engine read and wrote `<its control dir>/session-pollution/`, `import-receipts/` and `quarantine/` itself, whatever store its backend carried, and the File backend did the same under its own root; the pollution read, the import latch release and the two quarantine writers (`quarantineAndTombstone` in the engine's rungs, a twin in the backend's gate) each spelled the law for itself. A replica whose backend carried another store wrote its markers beside itself, so a second replica over the same store did not see them. The delegation settlement seat handed a tool the control-plane directory beside the store (`{ governance, sessionId, controlDir }`), and the seat's pollution check read the marker files there. The committed-shadow reads had a second, file arm (`<control dir>/shadow/<id>.md`) beside the backend's own `readCommittedShadow`.
515
+ - **Now.** The engine reads its markers through `this.governanceStore` (the backend's `governance`, else the File store over its control dir) and the File backend through `this.governance` (the File store over `controlPlaneRoot`) — for a File backend, and for a backend without a store, the same directories and the same bytes as before. A capture is one function over the store's verbs (`captureIntoQuarantine`, with a synchronous twin `captureIntoFileQuarantine` for the backend's synchronous paths, minting the same names in the same order), and the removal that follows is one function (`clearContainedPath`), shared by the engine's rungs and the backend's gate. A staged copy dropped at mount is retired into a `quarantine` object (written, read back and compared, the anchor read, then the unlink). The import latch release reads the receipt object; the re-import short-circuit reads it the same way. The erasure reads the quarantine objects, counts one it cannot read as unattributed and goes on. The evidence chain's torn-tail fragment is a `quarantine` object too (written once, suffixed on a standing name, where it was overwritten), and the degradation marker's `fragment` field names that object where it held the fragment's absolute path (nothing in core reads the field; it is for the operator's rebuild). The settlement seat is `{ governance, sessionId }`. The committed-shadow reads ask `readCommittedShadow` only. A pollution mark's durable write is held with its retroactive sweep from before its first await, so an exclusion read that follows a mark nobody awaited still waits for both; the `memory.session_polluted` notice follows the write's outcome, so it can land after the invoking tool's result. A writer whose record is first-record-wins — the pollution mint, the strict import, a capture, a staged copy's retirement, the torn-tail fragment — asks one function, `putControlObjectOnce` (its synchronous twin `putFileControlObjectOnce`): a put the store refuses over a name that already holds a readable record answers `existed` (the standing record wins, as before), and a refusal over a name it cannot read back is the put's refusal. The File backend's readers that must see damage rather than be spared it — the export's pollution roster and its quarantine enumeration, the erasure's count, the governance fingerprint — read every name standing in the kind's directory (`standingFileControlObjectNames`), not the store's objects-only listing: a marker or copy that stands as no readable object is carried as the fail-closed record or counted unattributed, never dropped.
516
+ - **Narrowing — four (open to veto).**
517
+ 1. A store that cannot answer whether a pollution slot stands reads the session as **polluted**. 7.64.0 took any refusal of the probe (`lstat`) as no marker — a `session-pollution` that is a file, a directory that cannot be searched — and read the session clean. A marker that stands but cannot be read was polluted before and still is.
518
+ 2. A containment that finds the suspect path **rewritten after it read it** (the copy is a store write now, so the window is an await wide) leaves the newer bytes in place and reports the rung incomplete (`removed: false`, "the file was rewritten after it was read"), and every restore that follows — the withheld file's committed copy, the rejected file's committed copy, the boundary sweep's index baseline — keeps its hands off them (`restoreWithheld` names the path); 7.64.0 removed or overwrote whatever stood at the path. The copy of the bytes that were read is kept as before. The derived index is the one file an overwrite follows anyway (the gate's clear, then the rebuild; a polluted session's restore): there the newer bytes are kept as a copy too before the clear or the restore (at most three copies, each re-read never following a link; an index still being rewritten after that is cleared or restored all the same — for the index the containment wins over the copy, as a capture that failed never stopped it — and the report says its last version was not captured).
519
+ 3. A File control object is created **owner-only (0o600)**. A pollution marker or a quarantine copy written by 7.64.0 took the process umask (0o644 under the usual 022); a tool running as another OS user that read them no longer can for new objects.
520
+ 4. A pollution slot that **stands as no readable object** — a dangling link, a directory, an entry the store cannot read to tell — is no longer answered as a marker that already stood: the mark answers that it could not be persisted (the `memory.pollution_mark_failed` incident; the delegation settlement's replay of that session retries at its next reconciliation instead of sweeping). 7.64.0's exclusive create answered `existed` over any entry at the name; the store's put refuses an entry it cannot read to tell, and a store that cannot answer at all refuses the same way, so `existed` there would leave a session clean once that store recovered. The session reads polluted for every occupant either way. The capture opt-out records keep 7.64.0's answer until they move onto the store (#3484, the first slot of the 7.66.0 window; KL-3466-b). The same law reaches a copy: a quarantine capture whose name stands as no readable object fails (the containment still runs, as after any failed capture), where 7.64.0 passed over the name; the names carry the clock's millisecond, so this needs an entry planted at that exact name.
521
+ - **Hard-breaking — two, three sentences each (open to veto).**
522
+ - (HB-2, one face) *What changed:* `MemoryEngine.sessionPollution(sessionId)` returns `Promise<SessionPollutionRecord | undefined>` (it reads the store, whose verbs are asynchronous). *Who is affected:* a host that calls it and reads the answer without `await` (none in the server's, the cli's, client-core's or the sdk's tree at origin/main). *Compensation:* `await` it. The two other synchronous control-plane faces the design names, `resolveHold` and `readInstructionHolds`, become Promises with the hold ledger's move in this same release (#3485, the section above).
523
+ - (HB-3, second half) *What changed:* the delegation settlement seat (`ToolExecuteContext.delegationSettlement()` → `DelegationSettlementSeat`) loses `controlDir`; the pollution and the hold ledger it settles against are read through `governance`. *Who is affected:* a tool that read `controlDir` off the seat (none in the four trees at origin/main). *Compensation:* read and write through `governance`.
524
+ - **Consumers.** @server: HB-2 and HB-3 above, zero hits at origin/main; your S-3068 store receives `pollution`, `import-receipt` and `quarantine` objects from engines whose backend carries it (the kinds 7.64.0 defined; no new kind). @dgx: the same if you carry a store. @test — black box: two engines over one shared store, each with its own control dir: a session marked through one is polluted on the other, and no `session-pollution/` appears beside either engine; control: a File backend reads and writes `<control dir>/session-pollution/` and `quarantine/` as before.
525
+ - **Known limits.** KL-3466-a (the hold family still on the File control-plane directory) is retired in this same release by #3485 (the section above). KL-3466-b — until #3484 (S2b) the capture opt-out mint, still a control-plane file, answers `existed` over a slot that stands as a dangling link, where the pollution mint now answers `unpersisted` (narrowing 4): the two twin records read one damaged slot two ways, and the transitional reading retires with #3484 (the first slot of the 7.66.0 window); this release ships with the transitional double reading, a written exception (C-R1119 addendum 6, open to veto). KL-3465-c now covers only the capture opt-out readers and the adoption's source removal (#3484, S2b); its hold readers moved with #3485. KL-3466-d — narrowing 2 does not reach the File backend's inbound gate yet: after the containment leaves bytes rewritten after its read, the gate still writes the committed shadow over them (the bytes nobody kept are lost, as in 7.64.0, so this is no regression), and its `quarantine_failed` escalation says they were left in place, which is not true on that path; the path is synchronous, so only a writer in another process landing between the scan's read and the clear reaches it. The reading that closes it — the shadow goes back only over what the containment left there, by the atomic rename that replaces a link at the path — is #3509.
526
+ - **Rules.** Retired: the engine's and the backend's own spellings of the three families' paths, the two quarantine writers (one capture, one removal), the shadow reads' file arm (three sites), the seat's directory, the two restores that wrote over whatever stood (the scan-finding rung, the opt-out sweep's index), the pollution owner reader's arm that read a refusal over a gone target as an unstamped owner. Added: the read-back check before a containment removes a path, the receipt object's read through the store at both readers, the index's keep-the-window's-bytes step before its two overwrites, the one put-once reading every first-record writer asks (`putControlObjectOnce` and its synchronous twin).
527
+ - **Claude Code 2.1.316.** No divergence of its own: the reference has no governance control plane (D-3407-a covers the seat).
528
+ - **Pins.** `test/backlog3466-carrier-s2a.test.ts` — P1–P8 the pollution objects (an unreadable object and a store that cannot answer read polluted; an enumeration fault refuses the roster; the mint written once, a refused write `unpersisted`; occupant slots; a slot that stands as no readable object answers `unpersisted` and still reads polluted for every occupant, and a record whose bytes cannot be read never vouches (narrowing 4); the strict import; the engine's public face over a store that cannot answer) · R1–R3 the receipt object (a completed import leaves it and a re-import answers the recorded report; a malformed one refuses the import by name; the latch release refuses a read fault and an absence) · Q1–Q9 the captures (names and their failures, the synchronous twin mints the same names, the last name unique in the process, the removal, narrowing 2 with the restore, narrowing 3, the erasure counts an entry that is no readable object and goes on, the export snapshot carries an unreadable marker as the fail-closed record, narrowing 4's capture half: a name standing as no object fails the capture and one holding other bytes is passed over, both twins) · S1–S3 a staged copy retired into an object (settled; the anchor read refuses after the store's awaits; a standing name or a different read-back leaves the copy) · F1–F4 the faces (HB-2, HB-3 type level, the File fault code, a source pin that the moved families' paths are gone from the engine and the backend) · K1–K6 the awaited copy (a writer that replaces the path while the copy is a store write: the index gate keeps both versions before it clears, a polluted session's index restore keeps both before it restores, a rejected file's committed copy is not written over the newer bytes and `restoreWithheld` names it; an index rewritten at every copy is still cleared and still restored, with three versions kept and the last named as not captured; a link swapped in at the index path during the copy is not followed). `test/backlog3466-carrier-s2a-two-tree.test.ts` imports only names both trees export: on 7.64.0 its two-replica rows are red (the marker and the capture land beside the replica), here green; its File-backend controls are green on both. Re-pinned to the store-shaped signatures: `178v2c-import-latch` (a squatted marker directory reads fail-closed, narrowing 1), `178v2c-import-roundtrip`, `backlog3465-control-plane-carrier` (C20, #3478, still green: the marker is born in the carrier, and a marker an older engine left beside itself decides only after the adoption), `a005-memory-engine-nofollow` (no bare `writeFileSync` is left in the engine; the scan-finding restore is counted with the containment module's), `backlog783-containment-no-replace` (four restore sites go through the one function), `prepare-memory-engine-session-transcript` (the notice follows the marker write: the pin waits on an exclusion read), `backlog514-session-incarnation` (a dangling id-level slot: still read fail-closed by every reader, the mark now `unpersisted`, narrowing 4), `design336-origin-carriage`, `design336-slice2-settlement-hold`, `memory-engine-pollution`, `memory-pollution-loudness`, `refactor-r5-quarantine-collision`, `backlog1103-memory-root-anchor` (the new primitive and gate row), and the `sessionPollution` substitutions in `backlog2424-forget-is-delete`, `design336-backfill-hardening`.
529
+ - **After the merge (#3506, #3507).** `memory-engine-s20` C-F9's TOCTOU cell pinned 7.64.0's removal of whatever stood at the path: its fixture rewrites the file inside the capture window, so under narrowing 2 the newer bytes stay where they are and the rung reports itself not contained. Its custody half is unchanged (the copy is the scanned bytes, never the swapped ones); its removal half is re-pinned to narrowing 2 (the path is not in `movedToQuarantine`, one `quarantineFailures` row says "rewritten after it was read", the newer bytes are untouched, nothing reached the backend), with two controls: the same world without the swap moves the file and keeps one copy, and a File backend opened with no control dir keeps the copy in its own `controlPlaneRoot`, which is the engine's default control dir — one place. No source changed for it. The tool texts that now splice `(await pollutionSentence())` read to `gate:error-surface` as one more uncapped arm in `src/core/memory-engine/` (the not-found card's is the one minting site): the gate reads an `await` through as it reads a parenthesis — the awaited value is bounded exactly when what it awaits is — pinned both ways in `test/error-surface-gate.test.ts` ③; no bucket was raised.
530
+
531
+ ### An erasure deletes the erased entry's quarantine copies from the governance store the backend carries, through the store's own verbs, and says what it did — `quarantineCopy` answers removed / remaining / unreadable on both lanes (#3499; behavior change: the degraded lane deletes the copies and its `quarantineCopy` and `quarantineUnattributed` answer counts where they answered `unverified`; narrowing: one, below, open to veto; widening: none; hard-breaking: none; closed sets: none; exports: none; members: +1 optional `unreadable` on the counted arm of `ErasureCarrierAnswer`; wire: `residuals.carriers.quarantineCopy` gains `unreadable`, and on the degraded lane both classes change from `{ unverified: true }` to counts) (@server @dgx @test)
532
+
533
+ - **Before.** After #3466 the quarantine captures ride the governance store the backend carries (`MemoryBackend.governance`), but the erasure still read only the File directory `<control dir>/quarantine/`: the File face (`FileMemoryEngineBackend.eraseWithEvidence`) through its own directory, and the degraded lane (`eraseMemoryEntries({ allowUnevidenced: true })` over a backend with no evidence face — every database-shaped store) not at all: it answered `quarantineCopy: { unverified: true }` and left every copy of the erased entry in the store. A copy the harvest gate kept of a refused edit (the entry's body with the secret in it) outlived the entry's erasure on every carrier but the File backend's own. On the File face, an object it could not read (a directory or a dangling link at an object's name) was counted in `quarantineUnattributed`, which does not decide the status, so a request over a damaged copy could answer `complete`.
534
+ - **Now.** One law, `eraseQuarantineCopies(objects, ids)` (`src/core/memory-engine/layout.ts`), for both lanes and every carrier: list the store's `quarantine` objects (`listObjects`), read each (`getObject`), and delete (`deleteObject`) the ones whose bytes name an erased id in their frontmatter. Per object: the delete answers `true` ⇒ `removed`; `false` (already gone) ⇒ not counted; it throws or answers anything but a boolean ⇒ `remaining`; the read throws or answers something that is not bytes ⇒ `remaining` and `unreadable`; the read answers the object absent (gone since the listing) ⇒ not counted; bytes that name no id ⇒ `quarantineUnattributed` (left); another id ⇒ untouched. A listing that fails or is not a list of names (a hole in it included): the File face refuses the attestation (`ControlPlaneCorruptError`; the replay converges, as before); the degraded lane, which never throws once its deletes are committed, answers both classes `unverified` and deletes no copy. The File carrier's damage stays visible through one standing view, `standingControlObjectsOf(store)` (`consolidation.ts`): over a File store it lists every name standing in the kind's directory (`standingFileControlObjectNames`), over any other store the store's own listing; the pollution roster reads the same view (its hand-built twin is gone). The two-store receipt merge (`mergeErasureAttestations`) adds `unreadable` when both stores say it.
535
+ - **Narrowing (open to veto, @server @dgx).** A damaged entry in the File backend's quarantine (a directory, a dangling link at an object's name) was counted unattributed and the request could answer `complete`; it is now `remaining` and `unreadable`, and the request answers `partial` until the entry is gone. A copy that was never read was never deleted, so the class is not claimed clean over it — the attestation's rule that `unverified` never reads as clean, for a class that is counted.
536
+ - **Consumers.** @server: the degraded lane is the one your database legs run. Read `residuals.carriers.quarantineCopy` as counts (`removed`, `remaining`, `unreadable` — a share of `remaining`, never added to it) and `quarantineUnattributed` as `{ count }`; both stay `{ unverified: true }` when your store's quarantine listing fails. Code that assumed the degraded lane answers these two classes `unverified` changes; the status law does not (the degraded lane still never answers `complete`). @dgx: the same if you carry a governance store. @test: black-box faces — erase an entry whose edit the harvest gate refused (its copy leaves the carrier with it); a quarantine row the store cannot decode (`remaining: 1, unreadable: 1`); a row it will not delete (`remaining: 1, unreadable: 0`).
537
+ - **Known limits.** The sweep reads the carrier's `quarantine` kind and nothing else: a disposed hold, which #3485 (above) makes a `quarantine` object of the carrier, is read like any other copy (its bytes decide), while a hold still pending is a `hold` object and is not an erasure's to delete. KL-3466-c — over a non-File store (a File store wrapped in another object included), whether a damaged row is listed (and so counted) is that store's own listing law. The sweep is one listing at one moment: a copy captured after it is swept by the request's replay, and the store's verbs delete by name only, so a name deleted and reused by another writer between the sweep's read and its delete is not told apart (no conditional delete in the seat's contract).
538
+ - **Rules.** Retired: the File face's own scan of its quarantine directory (one law for both lanes now), the pollution roster's hand-built standing view, and the degraded lane's `unverified` arm for the quarantine class. Added: the optional `unreadable` sub-count. The listing-failure answer stays one per lane contract (the File face refuses, the degraded lane says `unverified`).
539
+ - **Claude Code 2.1.316.** No divergence: the reference has no erasure attestation and no governance control plane.
540
+ - **Pins.** `test/backlog3499-carrier-quarantine-erasure-two-tree.test.ts` (two-tree: red on the stage tree before the fix, green here) — the degraded lane deletes the carrier's copy and counts it · a copy the harvest gate kept of a refused edit leaves with its entry · a copy one replica's harvest kept is erased by another replica's request · only the erased id's copies go (another entry's copy, a fragment, the pollution and import-receipt objects stay) · an object the store cannot read is remaining and unreadable · one it will not delete is remaining, not unreadable · a delete answered with neither yes nor no is remaining · a directory and a dangling link in a File carrier are unreadable · the File face answers the three counts · the File face's damaged entry keeps the request partial (the narrowing); controls, green on both trees — a failing listing, a listing with a non-name and a sparse listing leave the class unverified and delete nothing, a File fragment is unattributed and the request completes. Changed pins: `test/backlog3466-carrier-s2a.test.ts` Q7 (the narrowing), `test/backlog1917-erasure-attestation-v2.test.ts` (the clean table, the quarantine row, the degraded lane's two classes), `test/design178-v2b-erasure-evidence.test.ts` B-4; `test/backlog3172-3175-memory-deployment-judge.test.ts` gains the merge cell.
541
+
542
+ ### The file rule store's census takes the owners the host can name — `listBucketOwners({ knownOwners })` reconciles them by the engine's one digest, and `unnamedBuckets` counts only the buckets neither side can name (#3494; behavior change: none for a call without an argument; hard-breaking: none; closed sets: none; exports: none — an optional parameter on an existing method, no root name) (@server @test)
543
+
544
+ - **Before.** `FileDurableRulePartitionProvider.listBucketOwners()` (7.64.0, #3286) named an owner only by what the directory records — the local-owner file and the principals an adoption marker names — and counted every other digest-named bucket in `unnamedBuckets`. A host whose File store has one more source of names (the owners its import records derive) read and visited those buckets, and the engine still counted them as nobody-can-name-them: `unnamedBuckets > 0` was a gap the operator did not have. The only way to close it from outside was to compute a bucket's file name — a second reading of the one digest.
545
+ - **Now.** `listBucketOwners(opts?: { knownOwners?: readonly string[] })`. The host hands over the principal names it can speak; the engine matches each by the same digest (`principalRuleFileName`) against the files present, lists the ones whose bucket is here in `owners` (after the directory's own names, in the order given), and `unnamedBuckets` is then the count of buckets neither the directory nor the host names. A name whose bucket is absent lists nothing and changes nothing; a name given twice, or one the marker already names, is one owner. Nothing is opened, nothing is written, no lock is taken. `opts` is received by the engine's receipt law: a plain object taking `knownOwners` and nothing else, the list read once off the engine's copy, each element judged by the one principal-name reading; a value that is not that — a bag that is not a plain object, a misspelled member, a `knownOwners` that is not a plain array (a Set, a typed array, an Array subclass or another realm's array is not taken — pass a plain array), an element that is not a principal name (a number, `null`, a hole, `""`, a blank string, a control character) — is refused `config.invalid_argument` before the directory is looked at, in a sentence that names the position and the kind and never the text. The digest function stays off the package root: a host reconciles through this call and does not compute a bucket's name.
546
+ - **Narrowing / widening.** None for a caller that passes no argument (the answer is the 7.64.0 answer). The method ignored a surplus argument before; an argument that is not the one option is now refused — no caller of 7.64.0 can have relied on it, since the argument did nothing.
547
+ - **Consumers.** @server (S-2935, the M36 File leg, [12906] ②): pass the owners your import records derive as `knownOwners`; then report `unnamedBuckets` as the buckets nobody names. @test: seed buckets for principals the directory does not record, call with and without the list, read `unnamedBuckets` fall by one per named bucket present.
548
+ - **Pins.** `test/backlog3494-known-bucket-owners.test.ts` — K1 a known owner present is listed and not counted, the directory's names first then the host's in the order given · K2 an absent bucket changes nothing · K3 one owner once (a repeat, a marker-named principal) · K4 absent / `undefined` / `{}` / `{ knownOwners: undefined }` / `[]` are the call with no argument · K5 twenty-two bad values refused `config.invalid_argument` with no name's text in a sentence · K6 the refusal comes before the directory is looked at · K7 names only (entries unchanged, no lock) · K8 the digest function is no root export · K9 elements read once off the engine's copy (a getter, a throwing getter, a Proxy; an Array subclass, another realm's array, a Set and a typed array are no list) · K10 the real adoption arc. `test/backlog3286-bucket-owners.test.ts` (L1–L9) is unchanged and green.
549
+
550
+ ### `DISCARDED_DELIVERY_PATHS` is on the package root — the four words of `delegation.delivery_discarded`'s `detail.path` as a value, and the `DiscardedDeliveryPath` type is derived from it (#3505; behavior change: none; hard-breaking: none; closed sets: +1 registry row, no word added or removed; exports: +1, `DISCARDED_DELIVERY_PATHS`) (@client-core @server @test)
551
+
552
+ - **Before.** `delegation.delivery_discarded` says in `detail.path` which seat a discarded delivery would have reached: `live`, `box`, `drain` and (7.65.0, #3479) `notice`. The set was a type (`DiscardedDeliveryPath`) in a module the package root does not export, so a host reading the notice against its closed set copied the four words by hand — and the next word the engine added would not reach its copy.
553
+ - **Now.** `export const DISCARDED_DELIVERY_PATHS = Object.freeze(["live", "box", "drain", "notice"] as const)` in `src/core/task-notification.ts`, exported from the root; the `DiscardedDeliveryPath` type is `(typeof DISCARDED_DELIVERY_PATHS)[number]`, so the type, the value and every mint site (a literal or the store's own choice among them) are one set checked by `tsc`. The set is a registry row in `docs/CLOSED-SETS.md` (`array:DISCARDED_DELIVERY_PATHS`, no disposition table), so the release manifest reads its words from source. The type itself stays off the root: a host derives it from the value.
554
+ - **Narrowing / widening.** None. No word was added or removed; no mint, no notice and no `detail` member changed.
555
+ - **Consumers.** @client-core: validate `detail.path` against `DISCARDED_DELIVERY_PATHS` instead of a hand-written list. @server @test: nothing changes in the running engine; the black-box face is the import (`SMOKE_CHECKED_EXPORTS` proves the name reachable from a stranger install).
556
+ - **Pins.** `test/backlog3505-discarded-delivery-paths.test.ts` — P1 the value is exactly the four words, frozen, and the root export is that value · P2 the real mints (the store's live / box / drain / notice discards) say every word of the set and nothing outside it · P3 every literal mint site in `src/` spells a word of the set. `test/export-surface.test.ts` re-baselined (Δ +1) and `gate:closed-sets` reads the new row.
557
+
558
+ ### A File memory store opens only where its control plane can make a hard link — on a file system that cannot, the open is refused with `memory.control_plane_links_unsupported`, before the journal or any control object is written (#3512; ruled C-R1139; behavior change: a File store over a control plane without hard links is refused at its open where it opened and then lost every quarantine copy; narrowing: one, below, open to veto; widening: none; hard-breaking: one, three sentences below, open to veto; closed sets: `STORE_FORM_REFUSAL_CODES` +1 (`memory.control_plane_links_unsupported`), `NON_GOVERNANCE_MEMORY_CODES` +1 (the same code, CONTROL-PLANE IO), `STORE_OPEN_ARTIFACTS.filePrefixes` +1 (`.link-probe-`); exports: +1, `CONTROL_PLANE_LINKS_UNSUPPORTED`; wire: one code added to a closed family, additive) (@server @dgx @cli @client-core @test)
559
+
560
+ - **Rule.** The File governance store publishes every control object with `link` — a put stages the bytes and links them to their name, a move links the target and drops the source (7.64.0, #3465) — so on a file system that cannot make a hard link no object can be written. One judge, `probeControlPlaneLinks(controlDir)` (`src/core/memory-engine/control-objects.ts`), asked at each open and never cached: it creates one file at the control plane's top level (`.link-probe-<uuid>`), links a second name to it, and removes both. A link the file system refuses — whatever errno it answers (`EPERM`, `ENOTSUP` / `EOPNOTSUPP`, `EXDEV`, …) — refuses the open with the fourth seat of the store-form refusal family (`controlPlaneLinksRefusal`; the sentence leads with the code and names the errno, never a path; `detail.path` is the control plane). The judge claims nothing when it could not try: a first file that cannot be created (a plane that is read-only, full or not writable) and a link name that already stands leave the open as it was. A File store has three holders and two of them ask it: the File backend's construction, after the root anchor check and before the journal recovery, and an engine whose backend carries no store of its own, at its mount, after it creates its control plane and before it writes in it. The third — a backend a host composes itself around `fileGovernanceStore(dir)` (a package-root export, a pure factory that reads no disk) — is asked by neither: the engine skips its mount probe for a backend that carries a store of its own, and the factory has nothing to ask with (KL-3512-c, #3519).
561
+ - **Before.** In 7.64.0 a File store opened on such a file system, and the first object it wrote failed (`link` answered the errno). Since this release's #3466 / #3485 every quarantine copy, pollution marker and held instruction is such an object, and a containment whose copy fails still takes the suspect content off the model-visible plane (C-F9: containment never waits on its copy) — so the suspect file was removed and no copy of it was kept anywhere, the report saying `quarantine copy FAILED; file removal succeeded` with a `quarantineFailures` row and a `quarantine escalation` warning. The #3485 section's narrowing 1 described this.
562
+ - **Now.** The store does not open there. `new FileMemoryEngineBackend(dir)` throws the refusal; a Runner whose engine opens its own store over a plane without hard links degrades the session as for any mount that does not complete. The containment's order is unchanged: on a store that opened, a copy that fails still leaves the suspect off the plane, as before.
563
+ - **Runner actual form.** The fail-open arm of the memory phase, with no event of its own: `deps.onError(err, { phase: "memory", sessionId })` receives the refusal (`err.code === "memory.control_plane_links_unsupported"`), and the run's `effectiveMemoryScopes` is `{ state: "memoryless", reason: "mount-failed" }`; the session runs.
564
+ - **Narrowing — one (open to veto).** A deployment whose memory control plane is on a file system without hard links no longer opens its File memory store: the File backend throws at its construction, and a Runner over an engine that opens its own store runs memoryless. In 7.64.0 it opened, wrote nothing it could not link, and lost every suspect file a containment took off the plane.
565
+ - **Hard-breaking — one, three sentences (open to veto).** *What changed:* a File memory store whose control plane is on a file system that cannot make a hard link is refused at its open (`memory.control_plane_links_unsupported`, a store-form refusal) instead of opening and losing the copies its containments keep. *Who is affected:* a deployment whose memory control plane (`controlDir`, or the memory engine root it derives from) lives on such a file system — some network shares, FAT / exFAT volumes, some container overlay configurations — and a host that reads `STORE_FORM_REFUSAL_CODES` as exactly two codes. *Compensation:* put the control plane on a volume that supports hard links (the File stores' tool results, file history and mailbox lock already need them); nothing to migrate — the store's files are not touched by the refusal.
566
+ - **Consumers.** @server: `STORE_FORM_REFUSAL_CODES` is read as a family at run time (`memory-store-refusal.ts:47` / `:90`), so the third code joins the family without a change; the fail-open arm above is the Runner form to register (the discriminant is the `onError` code and phase, and the memoryless observation). A server replica's engine over a backend that carries no store opens the File store over its own control plane, so it is judged at its mount. @dgx: the same if your control plane is a File store; a store you carry is not judged (the judge is the File store's own), and neither is the File store you build yourself with `fileGovernanceStore(dir)` for a backend you compose (KL-3512-c). @cli @client-core: if you call `fileGovernanceStore` directly, the same; the server and cli checkouts read here have no such call, the others were not searched. @test — black box: a control plane whose `link` refuses ⇒ the File backend's construction throws the code with `detail.path` = the control plane and the store's files are untouched; control: a plane that can link opens and leaves no `.link-probe-*` behind.
567
+ - **Known limits.** KL-3512-a — the judge asks the control plane's top level; a kind directory (`quarantine/`, `hold/`, …) mounted from another volume is not asked, and a put into it that answers `EXDEV` takes the containment's ordinary path (C-F9). KL-3512-b — a process that dies between the probe's create and its removal leaves `.link-probe-*` at the control plane's top level: a named artifact of the open (`STORE_OPEN_ARTIFACTS`), never read as a record, removed by nothing. KL-3512-c — the third holder above: a File store built with `fileGovernanceStore(dir)` into a backend the host composes is not judged at its open, so on a file system without hard links it meets the #3485 section's narrowing 1 (the held file is removed and no copy is kept) where 7.64.0 held that file; on that one path this release is a regression against 7.64.0 (#3519, 7.66.0).
568
+ - **Rules.** Added: the judge (one), one code in an existing family, one artifact prefix; no per-path case. Retired: none.
569
+ - **Claude Code 2.1.316.** No divergence of its own: the reference has no memory control plane.
570
+ - **Pins.** `test/backlog3512-no-hardlink-control-plane.test.ts` (a `node:fs` whose `linkSync` refuses every link under the control plane by errno; it imports only names both trees export) — the File backend's construction refused for `EPERM`, `ENOTSUP`, `EOPNOTSUPP` and `EXDEV` (code, `detail.path`, errno in the sentence, no path, no probe file left), a store with content keeps every byte, and the lost-bytes cell (on the base tree the harvest removes the rejected file and keeps no copy; here the store does not open); the controls — a plane that links opens and leaves nothing, a probe file that cannot be created is not judged, an `EEXIST` link is not judged, each open asks again; the engine's mount refused for the four errnos with only the root anchor standing, a File backend's own store not judged again at the mount, and on a fresh engine `resolveHold` and the degraded `eraseMemoryEntries` ask no link and touch nothing they were not asked to; the Runner's fail-open arm (`onError` code and phase, `memoryless` / `mount-failed`, the run completes); the code in both families and a left `.link-probe-*` is no record. On the base tree 15 of its 19 cells are red, the four controls that do not need the judge green. `test/backlog1409-store-form-refusal-closed-set.test.ts` re-pinned to three codes and the fourth seat; `test/export-surface.test.ts` re-baselined (Δ +1).
571
+
1
572
  ## 7.64.0 — 2026-11-02
2
573
 
3
574
  ### A held instruction's quarantine seat is a function of its row, not of the clock — the row is written first, the custody bytes move second, and a death between the two converges instead of orphaning the bytes (#3464; behavior change: the seat's file name is `<first 16 hex of the content digest>-hold-<captureName>` and the row records it before the move; narrowing: none; widening: none; hard-breaking: none; closed sets: none; exports: none) (@server @test)