@sema-agent/core 7.63.0 → 7.65.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 (239) hide show
  1. package/CHANGELOG.md +725 -0
  2. package/dist/agents/cc-peer-directory.js +1 -0
  3. package/dist/agents/cc-peer-wire.d.ts +4 -0
  4. package/dist/agents/cc-peer-wire.js +1 -0
  5. package/dist/agents/cc-uds-peer-channel.js +5 -0
  6. package/dist/agents/cross-session-judge.d.ts +3 -1
  7. package/dist/agents/cross-session-judge.js +4 -1
  8. package/dist/agents/peer-directory.d.ts +8 -0
  9. package/dist/agents/peer-directory.js +4 -0
  10. package/dist/agents/peer-held-queue.d.ts +9 -3
  11. package/dist/agents/peer-held-queue.js +12 -9
  12. package/dist/agents/peer-idle.d.ts +20 -1
  13. package/dist/agents/peer-idle.js +23 -12
  14. package/dist/agents/peer-notice-route.d.ts +16 -5
  15. package/dist/agents/peer-notice-route.js +11 -9
  16. package/dist/agents/peer-notices.d.ts +25 -8
  17. package/dist/agents/peer-notices.js +6 -1
  18. package/dist/agents/peer-session-drain.d.ts +32 -6
  19. package/dist/agents/peer-session-drain.js +100 -26
  20. package/dist/agents/send-message-tool.d.ts +7 -0
  21. package/dist/agents/send-message-tool.js +18 -6
  22. package/dist/agents/subagent.js +25 -5
  23. package/dist/core/allow-entry.d.ts +4 -0
  24. package/dist/core/ask-origin.d.ts +1 -1
  25. package/dist/core/ask-origin.js +2 -2
  26. package/dist/core/ask-unresolvable-notice.d.ts +13 -4
  27. package/dist/core/ask-unresolvable-notice.js +10 -3
  28. package/dist/core/auto-compaction.d.ts +7 -5
  29. package/dist/core/auto-promote.d.ts +3 -2
  30. package/dist/core/background-agent-store.d.ts +14 -0
  31. package/dist/core/background-agent-store.js +3 -0
  32. package/dist/core/checkpoint-queries.d.ts +9 -6
  33. package/dist/core/checkpoint-queries.js +8 -3
  34. package/dist/core/checkpoint-store.d.ts +7 -4
  35. package/dist/core/context-settings.d.ts +39 -9
  36. package/dist/core/context-settings.js +32 -10
  37. package/dist/core/engine-attestation.d.ts +26 -6
  38. package/dist/core/engine-attestation.js +5 -1
  39. package/dist/core/engine-notice.d.ts +37 -2
  40. package/dist/core/engine-notice.js +3 -1
  41. package/dist/core/extension-requester.d.ts +9 -0
  42. package/dist/core/extension-requester.js +7 -0
  43. package/dist/core/file-history-store.d.ts +30 -2
  44. package/dist/core/file-history-store.js +48 -9
  45. package/dist/core/fs-write-gate-policy.js +1 -1
  46. package/dist/core/gate-fold.js +5 -1
  47. package/dist/core/gate-lanes.js +2 -0
  48. package/dist/core/gate-outcome.d.ts +39 -2
  49. package/dist/core/gate-outcome.js +20 -1
  50. package/dist/core/governance-codes.d.ts +8 -4
  51. package/dist/core/governance-codes.js +8 -3
  52. package/dist/core/leg-identity.d.ts +35 -1
  53. package/dist/core/leg-identity.js +10 -0
  54. package/dist/core/mailbox-store.d.ts +39 -4
  55. package/dist/core/mailbox-store.js +14 -2
  56. package/dist/core/memory-engine/consolidation.d.ts +13 -6
  57. package/dist/core/memory-engine/consolidation.js +26 -0
  58. package/dist/core/memory-engine/control-objects.d.ts +58 -0
  59. package/dist/core/memory-engine/control-objects.js +273 -0
  60. package/dist/core/memory-engine/control-plane-adoption.d.ts +51 -0
  61. package/dist/core/memory-engine/control-plane-adoption.js +161 -0
  62. package/dist/core/memory-engine/delegation-settlement.d.ts +73 -40
  63. package/dist/core/memory-engine/delegation-settlement.js +271 -107
  64. package/dist/core/memory-engine/dual-root.d.ts +3 -2
  65. package/dist/core/memory-engine/dual-root.js +7 -3
  66. package/dist/core/memory-engine/engine.d.ts +54 -33
  67. package/dist/core/memory-engine/engine.js +150 -157
  68. package/dist/core/memory-engine/file-backend.d.ts +58 -76
  69. package/dist/core/memory-engine/file-backend.js +111 -268
  70. package/dist/core/memory-engine/index.d.ts +3 -2
  71. package/dist/core/memory-engine/index.js +2 -1
  72. package/dist/core/memory-engine/layout.d.ts +135 -50
  73. package/dist/core/memory-engine/layout.js +214 -89
  74. package/dist/core/memory-engine/memory-age.d.ts +12 -0
  75. package/dist/core/memory-engine/memory-age.js +17 -0
  76. package/dist/core/memory-engine/memory-backend-contract.d.ts +10 -3
  77. package/dist/core/memory-engine/memory-backend-contract.js +159 -2
  78. package/dist/core/memory-engine/memory-deployment.d.ts +12 -4
  79. package/dist/core/memory-engine/memory-deployment.js +31 -6
  80. package/dist/core/memory-engine/origin-clearance.d.ts +12 -3
  81. package/dist/core/memory-engine/origin-clearance.js +64 -9
  82. package/dist/core/memory-engine/session-write-home.d.ts +34 -1
  83. package/dist/core/memory-engine/session-write-home.js +37 -10
  84. package/dist/core/memory-engine/tools.d.ts +2 -2
  85. package/dist/core/memory-engine/tools.js +7 -7
  86. package/dist/core/memory-engine/types.d.ts +55 -12
  87. package/dist/core/memory-engine/types.js +2 -1
  88. package/dist/core/memory-vector.d.ts +6 -14
  89. package/dist/core/memory.d.ts +0 -462
  90. package/dist/core/memory.js +0 -333
  91. package/dist/core/mode-policy.js +3 -3
  92. package/dist/core/mods/agent-stations.d.ts +18 -0
  93. package/dist/core/mods/agent-stations.js +8 -6
  94. package/dist/core/mods/extension-call.d.ts +4 -0
  95. package/dist/core/mods/extension-call.js +8 -0
  96. package/dist/core/mods/tool-call.js +3 -4
  97. package/dist/core/parent-spec-seat.d.ts +2 -2
  98. package/dist/core/peer-channel.d.ts +5 -0
  99. package/dist/core/permission-rule-consent.d.ts +64 -22
  100. package/dist/core/permission-rule-consent.js +106 -58
  101. package/dist/core/permission-rule-store.d.ts +56 -21
  102. package/dist/core/permission-rule-store.js +2 -0
  103. package/dist/core/refusal-echo.d.ts +20 -0
  104. package/dist/core/refusal-echo.js +33 -0
  105. package/dist/core/retention.d.ts +175 -10
  106. package/dist/core/retention.js +44 -0
  107. package/dist/core/retired-keys.d.ts +5 -0
  108. package/dist/core/retired-keys.js +3 -0
  109. package/dist/core/rule-offer-read.d.ts +0 -4
  110. package/dist/core/rule-offer-read.js +2 -18
  111. package/dist/core/runner/classifier-ladder.d.ts +10 -2
  112. package/dist/core/runner/classifier-ladder.js +4 -2
  113. package/dist/core/runner/compact-session.js +10 -7
  114. package/dist/core/runner/compaction-call-options.d.ts +7 -7
  115. package/dist/core/runner/compaction-call-options.js +3 -2
  116. package/dist/core/runner/contracts.d.ts +28 -9
  117. package/dist/core/runner/delegation-owner.d.ts +2 -3
  118. package/dist/core/runner/delegation-owner.js +2 -1
  119. package/dist/core/runner/gate-exit.d.ts +6 -0
  120. package/dist/core/runner/gate-exit.js +11 -2
  121. package/dist/core/runner/memory-consolidation-driver.d.ts +4 -2
  122. package/dist/core/runner/memory-consolidation-driver.js +8 -5
  123. package/dist/core/runner/prepare-ask-lane.js +3 -3
  124. package/dist/core/runner/prepare-caps-and-workflow.d.ts +3 -1
  125. package/dist/core/runner/prepare-caps-and-workflow.js +2 -2
  126. package/dist/core/runner/prepare-config-doors.js +4 -0
  127. package/dist/core/runner/prepare-delegation-surface.d.ts +3 -0
  128. package/dist/core/runner/prepare-delegation-surface.js +2 -2
  129. package/dist/core/runner/prepare-gate-stations.d.ts +8 -0
  130. package/dist/core/runner/prepare-gate-stations.js +15 -7
  131. package/dist/core/runner/prepare-hands-readface.js +1 -1
  132. package/dist/core/runner/prepare-inherited-gate.d.ts +3 -1
  133. package/dist/core/runner/prepare-inherited-gate.js +4 -2
  134. package/dist/core/runner/prepare-memory-engine-session.js +1 -1
  135. package/dist/core/runner/prepare-memory.d.ts +4 -0
  136. package/dist/core/runner/prepare-memory.js +22 -28
  137. package/dist/core/runner/prepare-policy-chain.js +18 -10
  138. package/dist/core/runner/prepare-prompt-inputs.js +1 -1
  139. package/dist/core/runner/prepare-task.d.ts +5 -1
  140. package/dist/core/runner/prepare-task.js +16 -11
  141. package/dist/core/runner/prepare-wiring-manifest.d.ts +3 -1
  142. package/dist/core/runner/prepare-wiring-manifest.js +3 -2
  143. package/dist/core/runner/resume-admission.d.ts +2 -2
  144. package/dist/core/runner/resume-admission.js +2 -23
  145. package/dist/core/runner/role-resolution-table.d.ts +98 -0
  146. package/dist/core/runner/role-resolution-table.js +62 -0
  147. package/dist/core/runner/run-compaction-machinery.js +2 -2
  148. package/dist/core/runner/run-identity-wiring.js +12 -9
  149. package/dist/core/runner/run-leg.js +8 -4
  150. package/dist/core/runner/run-notification-lane.js +23 -23
  151. package/dist/core/runner/run-recovery-lanes.js +3 -3
  152. package/dist/core/runner/run-terminal-adoption.js +1 -1
  153. package/dist/core/runner/run-turn-boundary.js +14 -15
  154. package/dist/core/runner/runtask.js +1 -1
  155. package/dist/core/runner/sub-agent-deny-lists.d.ts +19 -0
  156. package/dist/core/runner/sub-agent-deny-lists.js +25 -0
  157. package/dist/core/runner/tool-occurrence.d.ts +4 -2
  158. package/dist/core/runner/tool-occurrence.js +2 -2
  159. package/dist/core/runner-deps.d.ts +1 -1
  160. package/dist/core/secret-env.d.ts +2 -2
  161. package/dist/core/secret-env.js +6 -20
  162. package/dist/core/session-checkout.d.ts +63 -3
  163. package/dist/core/session-checkout.js +152 -58
  164. package/dist/core/session-store.d.ts +6 -6
  165. package/dist/core/session-store.js +3 -3
  166. package/dist/core/shell-read-silence.js +8 -0
  167. package/dist/core/store-contracts/background-agent-store-contract.js +13 -0
  168. package/dist/core/store-contracts/peer-directory-contract.js +8 -1
  169. package/dist/core/task-event.d.ts +9 -5
  170. package/dist/core/task-notification.d.ts +137 -31
  171. package/dist/core/task-notification.js +198 -100
  172. package/dist/core/task-registry-agent.d.ts +11 -0
  173. package/dist/core/task-registry-agent.js +12 -3
  174. package/dist/core/task-registry-shared.d.ts +11 -0
  175. package/dist/core/task-registry.d.ts +18 -0
  176. package/dist/core/task-registry.js +27 -8
  177. package/dist/core/task-spec.d.ts +7 -2
  178. package/dist/core/tool-errors.d.ts +17 -9
  179. package/dist/core/tool-errors.js +1 -1
  180. package/dist/core/tool-policy.d.ts +18 -1
  181. package/dist/core/tool-policy.js +16 -7
  182. package/dist/core/tool-result-store.d.ts +20 -0
  183. package/dist/core/tool-spec.d.ts +10 -6
  184. package/dist/core/trace.d.ts +3 -2
  185. package/dist/core/workflow-journal-store.d.ts +11 -0
  186. package/dist/core/workflow-journal-store.js +7 -0
  187. package/dist/core/workflow-run-store.d.ts +9 -0
  188. package/dist/core/workflow-run-store.js +6 -0
  189. package/dist/core/write-protect.d.ts +16 -0
  190. package/dist/core/write-protect.js +10 -0
  191. package/dist/engine/compaction/compaction.d.ts +2 -1
  192. package/dist/engine/harness/types.d.ts +1 -0
  193. package/dist/engine/session/repo-utils.d.ts +14 -4
  194. package/dist/engine/session/repo-utils.js +5 -4
  195. package/dist/engine/session/session.d.ts +7 -1
  196. package/dist/engine/session/session.js +5 -2
  197. package/dist/index.d.ts +13 -11
  198. package/dist/index.js +13 -11
  199. package/dist/orchestration/run-workflow-tool.d.ts +4 -0
  200. package/dist/orchestration/run-workflow-tool.js +7 -0
  201. package/dist/orchestration/workflow-types.d.ts +2 -1
  202. package/dist/orchestration/workflow.d.ts +3 -0
  203. package/dist/orchestration/workflow.js +2 -1
  204. package/dist/prompts/default.d.ts +1 -2
  205. package/dist/scenarios/full-body.d.ts +1 -1
  206. package/dist/stores/file/adoption/adopt.d.ts +1 -1
  207. package/dist/stores/file/checkpoint-store.d.ts +6 -0
  208. package/dist/stores/file/checkpoint-store.js +4 -1
  209. package/dist/stores/file/file-history-store.d.ts +13 -0
  210. package/dist/stores/file/file-history-store.js +75 -13
  211. package/dist/stores/file/index.d.ts +12 -16
  212. package/dist/stores/file/index.js +7 -25
  213. package/dist/stores/file/permission-rule-store.d.ts +34 -0
  214. package/dist/stores/file/permission-rule-store.js +104 -9
  215. package/dist/stores/file/session-store.js +1 -1
  216. package/dist/stores/file/tool-result-store.d.ts +14 -0
  217. package/dist/stores/file/tool-result-store.js +39 -2
  218. package/dist/stores/file/workflow-journal-store.d.ts +4 -0
  219. package/dist/stores/file/workflow-journal-store.js +17 -0
  220. package/dist/stores/file/workflow-run-store.d.ts +3 -0
  221. package/dist/stores/file/workflow-run-store.js +15 -0
  222. package/dist/tools/fs/read-deny.d.ts +15 -2
  223. package/dist/tools/fs/read-deny.js +10 -2
  224. package/dist/tools/fs/shell-read-check.d.ts +8 -2
  225. package/dist/tools/fs/shell-read-check.js +7 -7
  226. package/package.json +2 -2
  227. package/test/export-surface.snapshot.json +71 -73
  228. package/wire-changes/core-stores-sql@7.64.0.json +30 -0
  229. package/wire-changes/core-stores-sql@7.65.0.json +30 -0
  230. package/wire-changes/core@7.64.0.json +2653 -0
  231. package/wire-changes/core@7.65.0.json +1650 -0
  232. package/wire-changes/mods-kernel@7.64.0.json +30 -0
  233. package/wire-changes/mods-kernel@7.65.0.json +30 -0
  234. package/wire-changes/primitives@7.64.0.json +30 -0
  235. package/wire-changes/primitives@7.65.0.json +337 -0
  236. package/dist/core/memory-recall.d.ts +0 -208
  237. package/dist/core/memory-recall.js +0 -136
  238. package/dist/stores/file/memory-store.d.ts +0 -124
  239. package/dist/stores/file/memory-store.js +0 -353
package/CHANGELOG.md CHANGED
@@ -1,3 +1,728 @@
1
+ ## 7.65.0 — 2026-11-03
2
+
3
+ ### Errata to the 7.64.0 section and to the errata it carries (those sections are frozen; the corrections live here)
4
+
5
+ - **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.
6
+ - **"@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.
7
+ - **"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.
8
+ - **"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.
9
+
10
+ ### 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)
11
+
12
+ - **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.
13
+ - **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.
14
+ - **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`.
15
+ - **Rules.** Retired: the store step's own word (it derived `committed` from the code). Added: one derivation, one call site.
16
+ - **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`.
17
+ - **Claude Code 2.1.316.** No anchor: Claude Code keeps no persisted approval record and no redemption.
18
+ - **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).
19
+
20
+ ### 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)
21
+
22
+ - **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.
23
+ - **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.
24
+ - **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.
25
+ - **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.
26
+ - **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.
27
+ - **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`.
28
+ - **Claude Code 2.1.316.** No anchor, as above.
29
+ - **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).
30
+
31
+ ### 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)
32
+
33
+ - **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).
34
+ - **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`.
35
+ - **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)).
36
+ - **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.
37
+ - **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.
38
+ - **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`).
39
+ - **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.
40
+ - **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.
41
+
42
+ ### 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)
43
+
44
+ - **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.
45
+ - **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.
46
+ - **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).
47
+ - **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).
48
+ - **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.
49
+ - **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`.
50
+ - **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).
51
+ - **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.
52
+
53
+ ### 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)
54
+
55
+ - **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.
56
+ - **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.
57
+ - **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.
58
+ - **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.
59
+ - **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.
60
+ - **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).
61
+ - **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.
62
+ - **Claude Code 2.1.316.** Not applicable: a Claude Code session carries no occupant token. Inferred, not checked against the corpus.
63
+ - **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.
64
+ - **Pins.** `test/backlog3433-one-occupant-reading.test.ts`:
65
+ - 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.
66
+ - 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`.
67
+ - 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.
68
+ - 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.
69
+ - Q5: a token-less row rewritten to name another owner lends nothing.
70
+
71
+ The base tree (stage-7650 at v7.64.0) fails Q1 (it has no predicate in the row module), Q2, Q3 and Q4.
72
+
73
+ 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.
74
+
75
+ ### 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)
76
+
77
+ - **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.
78
+ - **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`).
79
+ - **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.
80
+ - **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).
81
+ - **Rules.** Retired: the judge's second member read and its refusal, and the retirement row. Added: none.
82
+ - **Claude Code 2.1.316.** No anchor (inferred): Claude Code has no blob-exchange seat on a file-history store.
83
+ - **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).
84
+
85
+ ### 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)
86
+
87
+ - **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.
88
+ - **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.
89
+ - **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.
90
+ - **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.
91
+ - **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).
92
+ - **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.
93
+ - **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.
94
+ - **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.
95
+ - **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.
96
+ - **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).
97
+ - **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.
98
+ - **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.
99
+ - **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.
100
+ - **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).
101
+
102
+ ### 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)
103
+
104
+ - **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.
105
+ - **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.
106
+ - **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).
107
+ - **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.
108
+ - **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).
109
+
110
+ ### `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)
111
+
112
+ - **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).
113
+ - **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`).
114
+ - **Narrowing / widening.** None. One export added; nothing it reads changed.
115
+ - **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.
116
+ - **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).
117
+
118
+ ### "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)
119
+
120
+ - **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.
121
+ - **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).
122
+ - **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.
123
+ - **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.
124
+ - **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.
125
+ - **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.
126
+
127
+ ### 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)
128
+
129
+ - **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"`.
130
+ - **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.
131
+ - **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).
132
+ - **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.
133
+ - **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`).
134
+
135
+ ### `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)
136
+
137
+ - **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.
138
+ - **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.
139
+ - **Narrowing / widening.** None. No word was added to or removed from the set; no read or refusal changed.
140
+ - **Consumers.** None outside the repository's own gates.
141
+ - **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).
142
+
143
+ ### 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)
144
+
145
+ - **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.
146
+ - **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).
147
+ - **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).
148
+ - **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`).
149
+ - **Newly withheld forms (one line each; synthetic examples, every value a filler).**
150
+ - `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.
151
+ - `pypi-token`: `pypi-` + ≥ 85 characters (an upload token), with or without a digit.
152
+ - `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.
153
+ - `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.
154
+ - `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.
155
+ - `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).
156
+ - `token-scheme`: `token` / `Token` / `TOKEN` + ≥ 20 token characters holding a digit, not followed by `/` or `.` (a path segment after it is not read).
157
+ - `sonar-login`: `sonar.login` `=` / `:` a value of ≥ 8 characters, quoted or not, in JSON too.
158
+ - `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.
159
+ - `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.
160
+ - **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).
161
+ - **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).
162
+ - **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.
163
+ - **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`.
164
+
165
+ ### 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)
166
+
167
+ - **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.
168
+ - **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.
169
+ - **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.
170
+ - **Rules.** Three readings move into the package as closed-set members (no new rule); the three name lists become one (−2).
171
+ - **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.
172
+ - **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.
173
+
174
+ ### 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)
175
+
176
+ - **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).
177
+ - **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).
178
+ - **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.)
179
+ - **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).
180
+ - **Narrowing (open to veto, @server @cli @ss).** The newly withheld form above.
181
+ - **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.
182
+ - **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.
183
+ - **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.
184
+ - **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.
185
+
186
+ ### 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)
187
+
188
+ - **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.
189
+ - **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.
190
+ - **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.
191
+ - **Rules.** Nine slots of data on existing rows, one grade member; no new rule.
192
+ - **Consumers.** @server: S3b reads the slots with `grade: "fragment"` in place of your arms. @test: the residue fixtures state `fragment`.
193
+ - **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.
194
+
195
+ ### 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)
196
+
197
+ - **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.
198
+ - **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).
199
+ - **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).
200
+ - **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.
201
+ - **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.
202
+ - **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.
203
+ - **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).
204
+
205
+ ### 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)
206
+
207
+ - **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.
208
+ - **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.
209
+ - **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.
210
+ - **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).
211
+ - **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).
212
+ - **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`.
213
+ - **Claude Code 2.1.316.** No anchor: Claude Code keeps no persisted permission-rule approval record.
214
+ - **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).
215
+
216
+ ### 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)
217
+
218
+ - **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.
219
+ - **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.
220
+ - **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`).
221
+ - **Narrowing — three (open to veto).**
222
+ 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).
223
+ 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.
224
+ 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.
225
+ - **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.
226
+ - **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.
227
+ - **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).
228
+ - **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).
229
+ - **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.
230
+ - **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).
231
+ - **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`.
232
+
233
+ ### 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)
234
+
235
+ - **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.
236
+ - **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`.
237
+ - **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).
238
+ - **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).
239
+ - **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.
240
+ - **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.
241
+ - **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.
242
+ - **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.
243
+
244
+ ### 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)
245
+
246
+ - **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.
247
+ - **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.
248
+ - **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.
249
+ - **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).
250
+ - **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.
251
+ - **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.
252
+ - **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.
253
+ - **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.
254
+ - **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.
255
+ - **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.
256
+
257
+ ### 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)
258
+
259
+ - **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.
260
+ - **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`.
261
+ - **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.
262
+ - **Narrowing — four (open to veto).**
263
+ 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.
264
+ 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).
265
+ 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.
266
+ 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.
267
+ - **Hard-breaking — two, three sentences each (open to veto).**
268
+ - (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).
269
+ - (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`.
270
+ - **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.
271
+ - **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.
272
+ - **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).
273
+ - **Claude Code 2.1.316.** No divergence of its own: the reference has no governance control plane (D-3407-a covers the seat).
274
+ - **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`.
275
+ - **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.
276
+
277
+ ### 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)
278
+
279
+ - **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`.
280
+ - **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.
281
+ - **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.
282
+ - **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`).
283
+ - **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).
284
+ - **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`).
285
+ - **Claude Code 2.1.316.** No divergence: the reference has no erasure attestation and no governance control plane.
286
+ - **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.
287
+
288
+ ### 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)
289
+
290
+ - **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.
291
+ - **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.
292
+ - **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.
293
+ - **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.
294
+ - **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.
295
+
296
+ ### `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)
297
+
298
+ - **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.
299
+ - **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.
300
+ - **Narrowing / widening.** None. No word was added or removed; no mint, no notice and no `detail` member changed.
301
+ - **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).
302
+ - **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.
303
+
304
+ ### 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)
305
+
306
+ - **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).
307
+ - **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.
308
+ - **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.
309
+ - **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.
310
+ - **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.
311
+ - **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.
312
+ - **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.
313
+ - **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).
314
+ - **Rules.** Added: the judge (one), one code in an existing family, one artifact prefix; no per-path case. Retired: none.
315
+ - **Claude Code 2.1.316.** No divergence of its own: the reference has no memory control plane.
316
+ - **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).
317
+
318
+ ## 7.64.0 — 2026-11-02
319
+
320
+ ### 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)
321
+
322
+ - **Before.** `disposeHold` named the seat `<now()>-hold-<captureName>`, renamed the custody file there, and only then wrote the row. A process killed between the two left the bytes in quarantine under a clock-derived name no row recorded; the re-call minted a different name, found custody gone, and recorded the disposal with no name — an orphan file (its sha256 the row's `contentDigest`), `readHoldCustody` blind to it, the row `disposed` with no seat. For an `expired` hold the host valve's `resolveHold(holdId, "release")` then answered `capture_lost` and committed nothing; for a hold disposed inside a harvest the warning lost its second half ("captured bytes moved to control-plane quarantine (…)"). `reconcileHolds` swept only `capturing` rows and could not find any of it (test, 7.62.0 and 7.63.0).
323
+ - **Now.** One function, `holdQuarantineNameOf(row)` (`src/core/memory-engine/delegation-settlement.ts`): the seat is `<first 16 hex of contentDigest>-hold-<captureName>` — the same row names the same seat in every process after any crash. `disposeHold` takes no clock any more and writes the row first (`disposed` + the terminal + that name), then moves the custody file there; a seat already holding the row's bytes means the move happened (the custody leftover is dropped), a seat holding anything else records the terminal with no seat (the verdict always lands — a refused intake stays terminal), leaves the custody bytes where they are, replaces nothing, and refuses with `ControlPlaneCorruptError` after the row is written; a row with no custody bytes anywhere records its terminal with no seat, as before. A death at either point leaves a row whose bytes are at the custody seat or the quarantine seat — both of which `readHoldCustody` tries — and `reconcileHolds` finishes the move at the next harvest (a seat it cannot use is disclosed on the same lane as a stranded copy, never thrown). The move is a no-replace hard link then an unlink; on a filesystem without hard links it is a rename after a look at the seat, so a stranger who writes the digest-derived name in the instant between the look and the rename is the one window left (never a content copy: a copy is not durable before the custody name goes and can stop half-way). Bytes the older writer already orphaned are found by what they are: a `-hold-` file no row names whose sha256 is a row's `contentDigest` — a `disposed` row with no seat (or a seat nothing stands at) records it as its seat, a `held` row with its custody gone takes the bytes back into custody and the next verdict disposes them under the row-derived name. The lost-bytes message of the release leg now carries the digest it looked for.
324
+ - **Narrowing / widening.** None on any surface a host drives. The seat's file name changes shape for rows disposed from here on; rows already carrying a recorded name keep it (the name on the row is what readers use). A host that listed the quarantine directory by the `<ms>-hold-` prefix sees `<digest16>-hold-` for new disposals.
325
+ - **Consumers.** @server @test: no verb, frame or wire member changed. `disposeHold`'s `now` parameter is gone (it only ever minted the name); it is not on the package root.
326
+ - **Pins.** `test/backlog3464-quarantine-name-deterministic.test.ts` — T1 two constructions of one row name one seat at any disposal clock · T2 / T3 / T3b a real SIGKILL right after / before the move into quarantine, and between the link and the unlink: the row already names the seat, a re-call changes nothing, `readHoldCustody` reads, exactly one file, `reconcileHolds` finishes a move that did not happen or drops the duplicate · T3d no hard links: a rename, never a copy · T4 / T4a / T4b / T4c a seat with other bytes (there before, or taken between the look and the move) is never replaced, the verdict still lands with no seat and the refusal is loud; the hold's own bytes at the seat are the idempotent "already moved" and a custody file with other bytes is never dropped; no custody means no name · T5b a move the seat cannot take is disclosed on the stranded lane · T6 an expired hold whose disposal died at the rename: the valve release commits it · T7 the same deaths inside a real harvest converge on one row, one seat, one file; T7b the live warning carries its whole sentence · T8 orphans of the older writer: a disposed row without a seat records the orphan, a held row takes its bytes back, another row's seat and a decoy with other bytes are left alone, two rows of one digest each get their own file whatever the ledger order, a row that met an old-order disposer takes the clock-named file, a file name that is not a safe segment is never recorded, and a refused intake stays terminal even with a stranger at its seat.
327
+
328
+ ### Errata to the 7.63.0 section (that section is frozen; the corrections live here)
329
+
330
+ - The #2292 / #3004 section's Known limits sentence said "A bounded-tail store that has cut the first leg's entry answers `workspace.checkout_unavailable` (fail-closed …)", and `docs/INTEGRATION-CORE.md` §1.8a said the same. Untrue. A store that loads a window of the log (`SessionStorage.getFloorId`) and has cut the `session_checkout` entry is read as no record at all (`readSessionCheckout`, `src/engine/session/session.ts` at 7.63.0). A leg that declares `TaskSpec.workspace` is then refused `config.session_workspace_changed` as a session "that already ran without it" (`src/core/session-checkout.ts:359-360` at 7.63.0); a leg that declares nothing runs in the base checkout (`:356`); `releaseSessionCheckout` answers no trees. Nothing answers `workspace.checkout_unavailable`. The entry is still not restated at compaction. The true text is now in INTEGRATION-CORE §1.8a and KNOWN-LIMITS KL-3468-a; the record surviving the floor is #3468.
331
+
332
+ ### Errata to the 7.56.0 section (that section is frozen; the correction lives here)
333
+
334
+ - The "The MCP failure text takes the request out of an endpoint's echo" section's "How to migrate" said "your second redaction that rewrites the engine's `[redacted]` to `«redacted»` is yours to retire (S-2027)". The ticket number is wrong: the server's second-redaction retirement is **S-2026**; S-2027 is the ticket for the `Cookie` / `Set-Cookie` header lines and the `x-amz-security-token` header. The instruction itself (the server retires its own second redaction) stands. Source: @server direct message, 11-02.
335
+
336
+ ### The roles a task's prepare resolves itself are one table, and "will this model face make a prepare refuse on a role?" is one question — `ROLE_RESOLUTION_TABLE` and `modelFaceResolvable(face, { spec?, when? })` answer `{ ok: true }` or `{ ok: false, role, code }` by asking each row's own hop, the function prepare calls (#2672; behavior change: none that a plain deps object can see — the hops are the engine's own and run as before; hard-breaking: none; closed sets: +2, both new (`RoleResolutionWhen` `per-task` / `deployment`, `RoleResolutionAbsence` `throws` / `falls-back`; no existing set moved); exports: +2 root values `ROLE_RESOLUTION_TABLE`, `modelFaceResolvable` and 7 types) (@server @test)
337
+
338
+ - **Before.** A host that wanted to refuse, at adoption, a model face every task would meet a refusal on had `resolveTaskModel` (wider than the per-task compaction hop: its fallback chain reaches `default`) and a copy of the role walk — a role map cut down to one key, probed with the engine's resolver (S-2204). The copy answers a different question the day the walk moves. Inside the engine the same absence was also asked twice: the consolidation chain (`consolidate`, then `summarize`) was read by `consolidationSeatResolvable` and by the resolve verb as two written-out copies, and its list of roles was spelled in three places.
339
+ - **Now.** `src/core/runner/role-resolution-table.ts`: `ROLE_RESOLUTION_TABLE` has one row per role the engine resolves itself where a refusal can come — `default` (per task: `resolveTaskModel`, the task's own model), `summarize` (per task: `resolveCompactionModel`, also `Runner.compactSession`'s), `consolidate` (the deployment's own door `assertAutoConsolidationWirable`, read from the face alone) — in the order prepare reaches them, each with when it is read, the hop, and what an absent role does (`throws` / `falls-back`). The face is what a host hands `new Runner` for models, `{ models, tiers?, roles? }`, and the question applies the Runner's catalog door to it (so the tier bindings go in as `tiers`; a catalog the caller expanded by hand is a plain catalog, to a Runner and to the question alike). `modelFaceResolvable` receives the catalog and the role maps once, walks the rows the options select (`when`: `["per-task"]` by default, add `"deployment"` to ask the consolidation seat as armed), calls each row's hop, and answers the first that throws: its role and the `code` the hop's refusal carries (`config.unknown_role`, `config.auto_consolidation`; no code is minted, and a throw with no code is rethrown, not given one). `spec` is the task asked about; omitted, a task naming no model. Each member of the face and of the task is read once. A `summarize` seat that is unset or names a word the catalog does not hold is `ok: true` (the compaction pass rides the task's model); a face is refused only where the hop refuses.
340
+ - **What the table settles.** Which roles are resolved when: nothing resolves a role at `new Runner` (the constructor copies the deployment's seats; every role-map entry is judged at the first prepare). At prepare, the role map is screened as a whole by the hops, so one entry that is no model reference refuses a task whichever role it sits on, `compactionModel` named or not — a question that asked only the `summarize` hop would have said `ok` for such a face. The classifier seat and the next-prompt suggestion pass resolve a role and take the main model when it supplies none (they never refuse); the `subagent` and `verifier` seats resolve when a child is spawned; `sideQuery` resolves at the caller's call. None of them is a row.
341
+ - **Narrowing / widening.** None on any plain deps object. No hop changed; `consolidationSeatResolvable` and the resolve verb now read one `consolidationRoleModel` and one chain list, and take the seat's slice of the deployment (`ConsolidationSeatDeps`, no brain) instead of the whole. The one visible difference: `deps.roles` is read once per seat question where the two written-out reads read it twice, so a deps bag whose `roles` is an accessor answering differently on a second read now gets one reading (a Runner's own deps are copied at construction and never showed it).
342
+ - **Rules.** +1 table, +1 question, −1 (the consolidation chain written out in two reads, now one), −1 (the chain's list spelled three times, now once) = 0 net on the judgment side: the question holds no judgment of its own.
343
+ - **Consumers.** @server (S-2204 state B): replace the "roles cut to one key" probe with `modelFaceResolvable(face, { spec })` over the adopted `{ models, tiers, roles }` (what you hand `new Runner`, not a catalog you expanded yourself); refuse the face on `ok: false` and carry `role` / `code` as the refusal's words. A face with no `summarize` role is `ok: true` — whether a deployment must have a cheap compaction seat is a separate rule the engine does not hold. @test: nothing to change.
344
+ - **Pins.** `test/backlog2672-model-face-resolvable.test.ts` — A1 the rows frozen with their `when` / `absence` · A2 each hop exists where the row says · A3 every `roleModelIfSet` call in `src/` is one of the three hops' reads (AST census) · A4 `resolveTaskModel` callers are the `default` hop and the named non-rows · A5 prepare calls the three hops from one function; `Runner.compactSession` calls the same compaction hop · A6 the `absence` column against what each hop does · B1–B9 the verdicts (unset / unheld summarize, `compactionModel` held / unheld, malformed role entries, the default chain with and without a named model, the task's own role map, the rows asked, first refusing row in prepare's order, a face or option that is no object — or names a word that cannot be shown — refused coded, a code-less throw rethrown, each member read once) · C1 `roles.summarize = 42` with a compaction model named: the summarize hop returns, the question says not ok at `default` · C2 a face the summarize hop passes and `default` refuses · C3 over 25 faces × tasks, the verdict is `ok` exactly when a real Runner's prepare does not refuse, with the prepare refusal's code, and no battery face is refused at `new Runner` · C4 both answers and both refusing roles appear · C5 a face with tier bindings answers as a Runner built with them (a hand-expanded catalog is a plain catalog to both) · C6 a catalog `new Runner` would not accept is thrown, not a verdict · D1–D4 the consolidation row against `consolidationSeatResolvable`, the arming door's code, a real Runner armed with and without a seat (also under tier bindings, and with two rows refusing at once), the resolve verb's chain order.
345
+
346
+ ### A session tree whose allocation mark reads leaves the disk through two doors only — a first leg whose record cannot be written keeps its tree and names it; `listOrphanSessionTrees` lists the trees no record holds and `releaseOrphanSessionTree` releases one (#3462, design #3420 / #3423; ruled C-R1118 K1–K5 and addenda 1–2; behavior change: the refused first leg's tree is kept, and a task root with no place in the tree is refused before the mint; narrowing: one, open to veto; hard-breaking: none; closed sets: +1 set `OrphanSessionTreeWhy` (3 words), no code added, no `ReleasedTree["kept"]` word added; exports: +2 root values `listOrphanSessionTrees`, `releaseOrphanSessionTree`, +1 type `OrphanSessionTree`; wire: frames +0) (@server @cli @test)
347
+
348
+ - **Before.** When a session's first leg minted its tree and the conditional append of its `session_checkout` record threw, the leg read the session back and decided from that snapshot: no record, or a record of this allocation, or (the 7.63.0 fix, #3419) a record whose cell named this tree's directory ⇒ keep; anything else ⇒ remove the tree and its branch. The snapshot was the race: another leg of the same session could take the clean tree back and record it after the read and before the removal, and the first leg then deleted a tree a record held (7.63.0 KNOWN-LIMITS KL-3419-a; an append that times out and lands late is the same form). A tree kept by that path, or left by a session the host deleted without releasing it, had no door at all: `releaseSessionCheckout` releases only the tree its own record holds. The one reader of a tree's allocation mark answered `undefined` for "no mark", "cannot read it" and "not this tree's own git directory" alike. A task root with no place in the session's tree was refused after the mint, removing the tree it had just made.
349
+ - **Now.** The rule is one sentence: a session tree whose allocation mark reads leaves the disk only through `releaseSessionCheckout` (the record's allocation is the mark's) or `releaseOrphanSessionTree` (it is not), and the engine's own failure paths remove only a tree whose mark is proved absent. A refused append reads nothing back and removes nothing: `workspace.checkout_unavailable`, its sentence naming the kept tree ("The tree is kept at <path>. If the record was written, the next leg reopens it and releaseSessionCheckout releases it; if not, the next leg of this session with the same declaration takes it back; a tree no record holds is listed by listOrphanSessionTrees."); an allocation with no tree (a declared source in place) names none. The mark reader answers three ways — marked, absent, unreadable — and a directory that is not its own checkout top answers absent (under the managed parent a plain directory's git directory is the base repository's). The failure path before the record (the mark write threw) removes the tree only when the mark reads absent; a mark that was written, or cannot be read, keeps the tree and says so. "Does this record hold this tree" is one predicate, allocation equality, read by the reopen, the release and the orphan doors; the 7.63.0 "or a cell names this directory" reading is retired with the read-back. `listOrphanSessionTrees(env, root, { sessionOf })` answers `{ repository, trees }`, each `{ path, branch?, sessionId, allocationId, baseSha, why, detail?, modifiedAt }`, `why` one of `unrecorded` · `record_unreadable` · `record_elsewhere` (CLOSED-SETS). `releaseOrphanSessionTree(env, path, { sessionOf })` judges the tree again and removes an orphan by the release's own judgment; the release (both doors) reads the mark once more just before `git worktree remove` and keeps the tree `not_owned` when another allocation's mark is there. `sessionOf` is the host's durable lookup: `undefined` asserts absence (contract sentence `session_checkout.session_of.absence_is_authority`), a throw is `record_unreadable`, which neither door removes. A log loaded from a bounded window that cut the record reads as no record carrying the window (`SessionCheckoutRead` none `window?: { floor }`, internal), and the doors read that as `record_unreadable`; a leg's open and the release read it as before.
350
+ - **Narrowing N1 (open to veto, @server @cli @test).** A first leg whose record append is refused and whose read-back would have answered no record (or another allocation's record) used to have its fresh tree and branch removed; now the tree is kept and listed by `listOrphanSessionTrees` (`unrecorded` / `record_elsewhere`), and a tree whose mark write reported failure but whose mark cannot be read back is kept too. The code is unchanged (`workspace.checkout_unavailable`, `workspace.isolation_unavailable` for the mark write); the sentence is rewritten by whether a tree exists. Of two first legs of one session at once, the refused one's tree now stays until a host releases it through the orphan door.
351
+ - **Behavior change N2 (no visible face).** A first leg whose task root has no place in the session's tree is refused before the tree is minted (`workspace.isolation_unavailable`), instead of after the mint with the new tree removed.
352
+ - **Not changed (K3).** `releaseSessionCheckout` still answers no trees when the session's log holds no record. The J9 start-site row of `session-checkout.ts` stays `run: false` (#3313).
353
+ - **Consumers.** @server S-1950 (the host carrier of the orphan list and the release door, C-R1118 K4): after `releaseSessionCheckout` in a session delete, list the repository's orphans, filter `sessionId` = the deleted session and release each; a retention sweep may release `unrecorded` / `record_elsewhere` trees past its own age by `modifiedAt` (a hint, not liveness); run one repository's removals — release, orphan door, cascade — one at a time and call the orphan door only for a session that runs no leg (KNOWN-LIMITS KL-3462-a); give `sessionOf` your durable store and throw when unsure; before a same-name retry in a new session after `checkout_unavailable`, release the old tree; show the new refusal sentences as they are. @cli: a startup sweep or a listing over the same two doors for a local repository. @client-core: nothing unless the server puts the list on the wire. @test: the cells below; the narrowing is the black-box case.
354
+ - **Rules.** K1: retired seven — the read-back, a read-back that throws read as unreadable, the two `holds` clauses (allocation, cell directory), the three-way undo decision, the three refusal sentences of the read-back (one now), the post-mint `placeInTree` removal arm; added two — the undo's "mark proved absent" guard and the three-valued mark reader (net −5). K2: one predicate where reopen and the release kept their own (−1); added the reason mapping, the door's re-judgment, the own-checkout-top guard and the mark read before removal (+4) (net +3). Total net −2.
355
+ - **Claude Code 2.1.316.** Deviation (inferred, D-3420-a / D-3423-a, to be registered): Claude Code's retention cleanup removes engine-named trees by name pattern on its own, and guards a take-back against a removal with a live lock (process id and start time, a one-machine fact); this engine sweeps nothing on its own, gives the host a list and an explicit door, and keeps no lock — it removes no tree another leg can read a mark of, and the host serializes the doors.
356
+ - **Pins.** `test/backlog3462-orphan-tree-doors.test.ts` (real git, the in-memory session store, zero model) — K1: X1 / T1 the first leg's append refused while the session's other leg takes the tree back and records it ⇒ the tree is kept and named, the next leg reopens it, nothing is read back · the append never landed ⇒ kept, next leg takes it back · the acknowledgement lost ⇒ kept, next leg reopens · a source-only allocation names no tree · T12 / T14 the mark write fails: written ⇒ kept, absent ⇒ removed, unreadable ⇒ kept · T13 a task root with no place ⇒ refused with no `git worktree add`. K2: T2 + T8 `unrecorded` listed with its mark, branch and mtime, the door removes it and its branch · T8 dirty / commits kept · T3 two first legs both minted before either recorded ⇒ the loser's `record_elsewhere`, the door releases it, the winner reopens · T4 `record_unreadable` ⇒ `unverifiable`, kept · T5 a held tree not listed, `not_owned` (also after a dirty release) · T6 the lookup's `undefined` and throw · T7 a mark-less worktree and a plain directory over a planted base-repository mark not listed · T9 taken back after listing ⇒ `not_owned` · T10 a cell spelled through a symlink alias still holds · T11 `name_in_use` names the doors · T15 a paused door, a removal by another door and a new session's tree at the same path ⇒ the new tree `not_owned` · a bounded window that cut the record ⇒ doors `record_unreadable`, open / release unchanged · bad values `config.invalid_argument`, a gone tree removed · control: the release is unchanged. Re-pinned: `test/backlog3419-checkout-undo-inconclusive.test.ts` (every refused-append form keeps the tree and reads nothing back), `test/backlog2292-session-checkout-ownership.test.ts` (the refused first leg's tree is kept, listed `record_elsewhere` and released by the orphan door), `test/backlog2944-read-floor-kept.test.ts` (the J9 row's reason names the doors). Mutations M1–M12 in the pin file's header; X1 (T1) and T13 are red on the 7.63.0 code.
357
+ - **Known limits.** KNOWN-LIMITS KL-3462-a (no lock between the doors, or between a door and the same session's take-back: the host serializes one repository's removals), KL-3462-b (a tree whose mark cannot be read is in neither door), KL-3468-a (a bounded window that cut the record; #3468). KL-3419-a is closed by this entry.
358
+
359
+ ### What deleting a session erases is one table — `RETENTION_CASCADE` gives every engine store one row (the legs that erase its rows: domain, store verb, what it selects, the session-tree step; or the reason it is exempt), the bundled stores carry every verb it names, and the file backend takes the sweep runner's `retention` word (#2878; ruled C-R983 K5 / K6 and addendum 1; behavior change: four optional erase verbs, and the file backend accepts a word it refused; narrowing: one, open to veto; widening: one, open to veto; hard-breaking: none; closed sets: +1 set name `RetentionCascadeDomain`, the type of the three words `RETENTION_CASCADE_DOMAINS` already held — no word added to or removed from any set; exports: +2 root values `RETENTION_CASCADE`, `RETENTION_SESSION_TREE_STEPS`, +4 types `RetentionCascadeDomain`, `RetentionCascadeLeg`, `RetentionCascadeRow`, `RetentionCascadeStores`; members: +`WorkflowRunStore.deleteBySession?`, +`WorkflowJournalStore.deleteRun?`, +`FileHistoryStore.deleteBySession?`, +`ToolResultStore.deleteUnattributable?`, all optional, +`FileStorageBackendOptions.retention?`, +`FileCheckpointStoreOptions.retention?`, +`FileToolResultStoreOptions.retention?`, +`retention` on `FileCheckpointStore` and `FileToolResultStore`) (@server @cli @test)
360
+
361
+ - **Before.** The order of a session purge lived in the server's coordinator and in prose: `RETENTION_CASCADE_DOMAINS` named three domains and no store, verb or order, and the file backend held stores no domain covered (session rules, the workflow journal, file history, the roster, the mailbox, background-agent rows) with nothing saying whether they go with a session. File history had only `reap`, which keeps the v1 pristine baselines while a scope lives, so a deleted session's rewind history stayed on disk; a tool result stored with no owner record had only the age-only `reap`, which does not consult ownership; a workflow run and its journal outlived the session that started them; and `FileStorageBackend` refused a `retention` key by its presence (7.58.0), so a local deployment that runs the sweep could not say its stores' rows are deleted on schedule.
362
+ - **Now.** `RETENTION_CASCADE` (`src/core/retention.ts`) is the one table, typed complete against the backend's store members plus the memory store and the workflow-run store: a store left out, or a verb that is not the store's, fails to compile, and `test/backlog2878-local-retention.test.ts` Q7 holds the same against a real `FileStorageBackend`. One session's erasure is `RETENTION_SESSION_TREE_STEPS` — fences first, then: workflow journals → workflow runs → the background agents' boxes → background-agent rows → roster entries → checkpoints (guarded by the session row, so while it exists) → tool results → session rules → file history → the session's box → the session row last, so a failed leg leaves the row and a retry converges; a leg that finds what it erases through another store's rows (the journals through the run rows, the agents' boxes through the agent rows) runs before that store's leg, so a retry still finds them. Each executor domain has its legs (`checkpoints`: the scope's expiry `reap` and the session `unpin`; `orphan-tool-results`: `deleteUnattributable`). Exempt, with the reason in the row: the usage-window ledger (principal-keyed token and cost counts, no session content) and memory (not session data; the governance records about it stay `RETENTION_CASCADE_EXEMPT`). The new verbs, each in both twins where the store keeps the fact it needs: `FileHistoryStore.deleteBySession(scope)` erases the whole scope — boundaries, version records, the v1 baselines, the consumed-id ledger — and the blobs no other scope holds, refused (`conflict`) while this store runs a write of the scope (a capture, a first-touch record, a retraction or an import, counted from the call), and thrown when the File twin's blob pass cannot collect every blob only the scope referenced (another scope's history it cannot judge, a blob that will not unlink) — the records are gone and a repeat runs the pass again; `ToolResultStore.deleteUnattributable(cutoffMs)` deletes the entries with no owner record stored before the call's cutoff (an owned entry, or one whose owner record is present but unreadable, is never this verb's; a cutoff that is not a finite number is refused `config.retention_policy_invalid`; the in-memory store records no write time and does not implement it); `WorkflowRunStore.deleteBySession(sessionId, scope)` deletes the session's terminal runs and answers their ids (a running run is a live reference); `WorkflowJournalStore.deleteRun(runId, scope)` keeps the load wall. Every operation takes its own `cutoffMs`; `RetentionPolicy.maxAgeDays` is read by the startup check alone (pinned in the source). `FileStorageBackendOptions.retention` is one word for the three declaring stores (session, checkpoint, tool result), judged before the root is touched; the backend still carries no executor, so a deployment that says `"managed"` passes the executor it runs to `assertRetentionCapability`, which refuses `"managed"` beside `executor: null`. Image bytes (C-R983 K6): `retention.image_bytes_live_in_the_session_store` — one holder, the engine's session store, gone with the session row's leg.
363
+ - **Narrowing (open to veto, @server @cli).** A workflow run started in a deleted session goes with it, journal included. Before, the run and its journal outlived the session and a resume of the run from another session replayed it; now, where a run store is wired, that resume is refused `workflow.park_truth_unreadable` with `detail.reason: "record_missing"` — the word an absent prior record already answered, its message now naming deletion among the absences ("never recorded under it, reaped, or deleted with the session that started it"). No code was added. A deployment that wires a journal store without a run store has nothing that indexes runs by session, so the cascade cannot reach those journals and such a resume still replays (stated on the table's contract sentence).
364
+ - **Widening (open to veto).** `FileStorageBackend` accepts `retention` (7.58.0 refused the key by presence, `config.retention_capability`; C-R878 ⑥ read "the file backend runs no executor" and is amended by C-R983 K5: the party that runs the sweep states the word). A stray key beside it is now the options door's `config.invalid_argument`.
365
+ - **Not in core.** The executor is the server's — its first version audit-only, the deletion log its own. Host stores are not rows of the core table: with the core table as the skeleton, the server's E21 coordinator appends three host legs — resume anchors, the session-map projection, the run ledger (the server reports `boot/session-faces.ts:253` and `:438`; not verified here). The fence of the mailbox leg is the optional `retireRecipient` pair's; the bundled two stores keep no recipient lifecycle and have the box dropped. Moving a shell transcript's image bytes to a reference is the cli half of K6.
366
+ - **Consumers.** @server: run the legs from `RETENTION_SESSION_TREE_STEPS` instead of a hand-kept order and add your three host legs around them; give a local `FileStorageBackend` `retention: "managed"` when your local executor runs over it; the `record_missing` refusal passes through unchanged. @cli: a transcript keeps a reference to an image (session id, entry id, block index), never a copy; a resume of a run whose session was deleted is refused as above. @test: Q1–Q3 and Q7 below are the design's cells.
367
+ - **Pins.** `test/backlog2878-local-retention.test.ts` — Q1 both file-history twins erase a scope whole (boundaries, versions, the v1 baseline; the File twin collects the scope's blobs) and the other scope restores · Q1 both twins refuse while an import of the scope is still fetching its blobs, then erase it once the import settles · Q1 the File twin throws when another scope's damaged history stops the blob pass, and a repeat after the repair collects the blobs · Q1 tool results by owner · Q2 two cutoffs, two results; bad cutoffs refused before anything is touched; `maxAgeDays` read only by the startup check · Q3 unowned past the cutoff goes (both namespaces), unowned new / owned old / damaged-owner old stay · Q7 one row per store of a real backend plus the run store, each verb a function on the bundled store, one reading of the order (the agents' boxes before the agent rows, the journals before the runs), and the table's type as its coverage (a store left out or a verb the store does not carry does not compile) · W the run store's terminal-only, scope-walled, session-strict delete (both twins), the journal's load wall (both twins), and end to end a resume replays before the deletion and is refused `record_missing` after it with nothing spawned. `test/backlog1468-t4-retention-declaration.test.ts` re-pinned: the file stores join the construction matrix, and the backend's word reaches its three stores. `test/backlog3186-store-options-gate.test.ts` and `test/backlog2847-store-options-door.test.ts` re-pinned: `retention` is a backend option like the others (an accessor on it is read once, off the copy; one that throws is the door's `config.invalid_argument`). Mutations M1–M15 in the pin file's header.
368
+
369
+ ### A steer queued while a run ends: read by the same run, or named by its `inputId` on the run's undrained row — the handoff a host re-sends from, stated as one contract and pinned on a real Runner (#3457; behavior change: none — contract sentences and pins; hard-breaking: none; closed sets: none; exports: none) (@cli @client-core @server @test)
370
+
371
+ - **Before.** The engine already read a steer queued while the run's final turn was in flight (the loop drains it after that turn and runs one more), and a steer still queued when a stop ended the run was on the leg's `task.user_steer_undrained` row with its `inputId` in `detail.inputIds`. Neither half was stated where a host reads it, and the row's sentence ("They are NOT redelivered; re-send against a live run if still wanted") was the only word on what a host may do next.
372
+ - **Now.** One contract, `notice.user_input_undrained.handoff`, on `undrainedUserInputNotices` (`src/core/engine-notice.ts`), and an INTEGRATION-CORE paragraph ("A steer queued while a run ends"): the extra turn for a steer queued during the final turn counts toward `limits.maxTurns`; a steer still queued when `maxTurns`, the token / $ budget, `interrupt()` or the task `signal` ends the run is not read and is not handed to the session's next run by the engine (a durable park is the one carrier: the resume delivers it under the same id, or — when the deployment's prompt screen withholds it on redelivery — `steering.parked_input_blocked` names it by that id, not the row); `detail.inputIds` names the unread inputs; re-sent under the same `inputId` to a later run, an input is read there (no row) or is on that run's own row (same id, that run's `runId`) — the leg's own rows naming one id count the runs that ended with it unread (a parent's copy, the row carrying `childSessionId`, repeats its child's row), with no engine state across runs. The row's sentence is unchanged, byte for byte.
373
+ - **Narrowing / widening.** None. No line of the loop, the gates or the notice changed.
374
+ - **Consumers.** @cli @client-core (L-2347): the key is the `inputId` the caller hands the steer verb. A steer sent without one gets an engine-minted id that appears only on its `human_input` frames (no text on them), and neither `steer()` nor `CheckpointStore.setPendingSteer` returns it, so it cannot be tied back to the call — a host embedding core directly sends every steer with its own `inputId` if it means to re-send from the row. An input parked on a checkpoint keeps its id through the resume. @server: the id on the row is the `inputId` you hand `live.steer` — by the cli's reading of 7.144.0 your receipt's `messageId` (not checked here); please confirm the parked-for-wake receipt carries the same one. A `crashed` row you mint is the same family and the same key. A host counting rows per `inputId` counts the leg's own rows (a copy addressed to a parent carries `childSessionId`), and reads a withheld parked input from `steering.parked_input_blocked`. @test: the shapes below on your side — the row count per `inputId` after a re-send that is read (stays 1) and one that is not (becomes 2).
375
+ - **Pins.** `test/backlog3457-steer-at-end.test.ts` — P0 no steer: one call, no row · P1 queued during the final turn: the same run reads it in one more turn, `applied` frame, no row · P2 `maxTurns: 1` and queued during that turn: one call, the row carries `inputIds: ["in-p2"]`, `cause: "leg_end"`, the run's `runId` · P3 the token budget spent at that turn's end: the same · P4 a durable park carries it: no row on the parked leg, the resumed leg's model reads it under an `applied` frame naming `in-p4`, no row · P4b the deployment's prompt screen withholds it on redelivery: no row, one `steering.parked_input_blocked` naming `in-p4b`, a `blocked` frame · P5 the task `signal` stops the run with it queued: the row names it, the session's next run never sees it · P6 re-sent under the same id: read ⇒ still one row for the id; not read again ⇒ a second row under the later run's `runId`.
376
+
377
+ ### The listing names the tool a parked approval's binding digests — `CheckpointSummary.toolName` is the name the row's `boundInputHash` is over, so two parks of one call id over the same arguments by two tools list two names (#3285; behavior change: none — #3302 moved the digest and this states and pins the listing's half; hard-breaking: none; closed sets: none; exports: none) (@server @cli @test)
378
+
379
+ - **Before.** A host reconciling a decision against the listing (S-2918) saw `toolCallId` and `toolName` on the summary and `boundInputHash` only on the drilled-in row, and 7.62.0's hash digested the arguments alone — a call of another tool over the same arguments under the same call id carried the same hash. 7.63.0 (#3302) bound the tool into the digest; no sentence said that the listing's `toolName` is the name the digest is over.
380
+ - **Now.** Stated on the type (`CheckpointSummary.toolName`) and in INTEGRATION-CORE (the `boundInputHash` row of the resume-outcome table): the listing's `toolName` is the tool name as the row records it — the name `exactBoundInputHashOf(toolName, args)` was minted over (an alias call records the tool's own name) — so a listing row and its drilled-in row hold both halves of the binding, and the hash stays opaque, echoed and never re-derived by a host. No second reading was added: the ticket's two candidates (fold the name into the digest / a separate `boundToolName` position) were one question, and #3302's digest is the first.
381
+ - **Narrowing / widening.** None; no line of the digest or of the projection changed.
382
+ - **Consumers.** @server (S-2918): nothing to change — the ask identity you bound in 7.143.0 and the engine's digest now agree on the tool. @cli @test: nothing to change.
383
+ - **Pins.** `test/backlog3285-summary-tool-name.test.ts` — S1 the hash recomputed from the summary's own tool name and the row's arguments is the row's · S2 one call id and the same arguments by two tools list two names and hold two hashes, each reproduced by its own name only · S3 an alias call lists and digests the tool's own name, not the alias · S4 the listing and the one-call projection read the same name.
384
+
385
+ ### A refusal from the second store of a deployment erasure says which stores had already executed — a copy of the refusing store's own error, class and code and cause unchanged, with its message opened by the stores that executed and how many entries they erased (#3288; behavior change: the message of a later store's refusal gains an opening sentence — no code, class or member moved; hard-breaking: none; closed sets: none; exports: none) (@server @test)
386
+
387
+ - **Before.** `MemoryDeployment.eraseMemoryEntries` executes its reached stores in order (project plane first). A later store's refusal — most plainly `memory.erasure_census_incomplete` from a personal store whose scope directory cannot be read — carried the store's own sentence, "nothing was deleted, nothing was recorded", which was true of that store and read as the request's: the project store had already executed and kept its anchor. S-2937.
388
+ - **Now.** One function in `memory-deployment.ts` opens such a refusal with the sentence that says what stands: "this request had already executed in the project store (N entries erased there; each keeps its anchor and a replay of the same requestId converges every store) when the personal store refused it — what follows describes the refusing store alone: ", then the store's own sentence. The thrown value is a copy of the store's own error — its class (a `ControlPlaneCorruptError` stays one), `code`, `cause` and every other own member kept — and the store's object itself is left as it was, so an error object a store throws again for another request carries no earlier request's sentence; a value that is not an `Error` is handed back unchanged. A refusal in the FIRST store executed nothing and keeps only its own sentence. The ticket's other candidate — judge every store's census before any store executes — was not taken: it needs a new probe face on `MemoryBackend`, and covers only the census, while the sentence is right for every later-store failure.
389
+ - **Narrowing / widening.** None. Who is refused, and by which code, is unchanged; only the message grows.
390
+ - **Consumers.** @server (S-2937): the `409 memory.erasure_census_incomplete` you map is the same code; show the message as it comes — it now tells the operator that a replay of the same requestId converges the stores that did not execute. Do not parse it. @test: a two-store erasure with an unreadable personal scope ends with the project entry gone, the personal ones standing and the code unchanged; after the fault clears, a replay of the same requestId completes.
391
+ - **Pins.** `test/backlog3288-erasure-later-store-refusal.test.ts` — E1 project executes and the personal census cannot read a scope (a real mode-000 directory; skipped as root): the code, the opening, the executed count, the entries' state, and the replay after the fault clears · E2 a first-store refusal carries no opening · E3 control: a clean erasure across both stores is one merged receipt · E4 a `ControlPlaneCorruptError` stays one with its cause and `facet` (a copy; the store's object keeps its own sentence) · E5 a thrown value that is not an `Error` is handed back · E6 one error object thrown for several requests carries none of them and accumulates nothing.
392
+
393
+ ### `screenAllowedToolsValue` is on the package root — the allow list's own screen, the one judgment of its declared bases, so an admission door meets the run's refusal (`config.invalid_permission_rules`, `unsupported.path_base`) in the run's words (#3289; behavior change: none; hard-breaking: none; closed sets: none; exports: +1 root value `screenAllowedToolsValue`) (@server @cli @test)
394
+
395
+ - **Before.** A user layer's `/`-form allow entry under a configuration directory that is not an absolute path (a relative `SEMA_CONFIG_DIR`) was refused only when the run started — `config.invalid_permission_rules` with one `unsupported.path_base` issue — while a deny / ask rule of the same form is refused at the host's admission door by the engine's dry-run (`validatePermissionRules`). The allow list's screen was internal, so the door had nothing to call for the allow side (S-2951; S-2790 waits on it).
396
+ - **Now.** The root exports the screen the run reads: `screenAllowedToolsValue(list, seat)` with `seat` `"TaskSpec.allowedTools"` or `"RunnerDeps.allowedTools"`. It returns the frozen copy the run would hold (`undefined` for `undefined`) or throws what the run refuses with — the same `code`, the same `issues`, the same sentence naming the entry's index and the list in words. It is the same function as the run's, not a copy; no second judgment exists to drift.
397
+ - **Narrowing / widening.** None; the run's refusal is unchanged and now reachable from a door.
398
+ - **Consumers.** @server (S-2951 / S-2790): call it at the allow-list admission with `"TaskSpec.allowedTools"` and answer the thrown `code` / `issues` as your deny / ask door answers its own (422); read `issues[].code`, never the message text. @cli @test: nothing to change.
399
+ - **Pins.** `test/backlog3289-allow-screen-root-export.test.ts` — A1 the root export is the run's function · A2 a user layer's `/` allow under a relative configuration directory is refused with the run's code and one `unsupported.path_base` issue naming the rule · A3 the run's failed terminal (request list) and a Runner's construction (deployment list) answer the door's code and sentence · A4 the deny / ask dry-run meets the same issue code for the same base · A5 controls: an absolute base reads, a command rule reads no base, no list is no list.
400
+
401
+ ### A file bucket's refusal tells its kind by code — `permission_rules.bucket_damaged` for a bucket the engine deterministically refuses, `permission_rules.bucket_unreadable` (with the system error's name in `errno`) for a read that failed (#3287; behavior change: additive — a refusal that carried no code now carries one, and a failed read now carries its `errno`; hard-breaking: none; closed sets: +2 codes beside `permission_rules.later_grammar`, same table; exports: +2 root values `PERMISSION_RULES_DAMAGED_BUCKET_CODE`, `PERMISSION_RULES_UNREADABLE_BUCKET_CODE`) (@server @test)
402
+
403
+ - **Before.** The file rule store's read leg threw one bare `Error` for a bucket it refuses on its bytes (a link, not JSON, a shape or a checksum that does not hold, a grammar stamp that is no whole number, a behavior word outside the set, an unusable store directory) and for a read that failed (`EIO`, `EACCES`, …). Only a bucket a newer engine wrote had a code (`permission_rules.later_grammar`). A host that must tell "this bucket will not read until a person acts" from "the read failed, it may read next time" could only read the sentence (S-2936: the server's one-time migration could not decide to skip a damaged bucket and refuse start on an I/O failure, as its SQL leg does by the refusal's type).
404
+ - **Now.** Every face of a file bucket (`list`, `quarantined`, a write's read of its base, `readRaw`) refuses with one of three codes: `permission_rules.bucket_damaged` (deterministic: the same bytes are refused the same way on every read), `permission_rules.bucket_unreadable` (the read failed; the system error's name is the refusal's own member `errno`, a string as the system gave it, absent when the failure carried none — never inside `code`, which keeps one vocabulary), and the unchanged `permission_rules.later_grammar`. No new error class. The sentence, the disclosure and the zero-rules posture are unchanged. The two new codes are exported beside `PERMISSION_RULES_LATER_GRAMMAR_CODE` (package root). A directory this engine refuses to use (a link, another user's, group- or world-writable, or a file where the directory should be — `EEXIST` / `ENOTDIR`) is the first kind, on the read faces and on the write path's directory check alike: it is a verdict about the location, repeated on every read. The org state file and the adoption marker are not buckets and keep their own refusals.
405
+ - **Narrowing / widening.** None: nothing is read or refused differently. A caller that tested "the refusal has no code" to mean damage (the old pin on a non-integer grammar stamp did) now reads `permission_rules.bucket_damaged`.
406
+ - **Consumers.** @server (S-2936, the M36 File leg): decide on `code` — `bucket_damaged` ⇒ skip that bucket by name (it loads zero rules, so it allows nothing); `bucket_unreadable` ⇒ refuse start (the bucket is not known to be empty; `errno` says why); `later_grammar` as before. Never read the sentence. @test: a mode-000 bucket file answers `bucket_unreadable` / `errno: "EACCES"`; a file that is not JSON answers `bucket_damaged` with no `errno`.
407
+ - **Pins.** `test/backlog3287-bucket-refusal-codes.test.ts` — D1 eight deterministic faults (not JSON; a shape that is no bucket; an older schema; a checksum that does not match; a non-integer grammar stamp; a behavior word outside the set; a link at the path; a directory at the path), each on the read, the quarantine read and the write's base read: `bucket_damaged`, no `errno` · D2 a mode-000 bucket (skipped as root): `bucket_unreadable`, `errno: "EACCES"`, bytes untouched · D3 controls: a later grammar keeps its code, an absent bucket is no refusal · D4 / D5 the codes are exact words on the root, three distinct, `errno` beside `code`. `test/backlog2229-rule-store-grammar-stamp.test.ts` R2 is re-pinned from "no code" to `bucket_damaged`.
408
+
409
+ ### The file rule store lists the owners its directory can name and counts the buckets it cannot — `FileDurableRulePartitionProvider.listBucketOwners()` answers `{ owners, unnamedBuckets }` (#3286; behavior change: none — a new read-only method; hard-breaking: none; closed sets: none; exports: +1 method on the exported class, no new root name) (@server @test)
410
+
411
+ - **Before.** A bucket's file is named by a one-way digest of its owner and holds no owner name, so the File provider had no way to list buckets, and the server's one-time migration over every owner's rules (M36) could visit only the owners its own approval records named. A bucket an adoption renamed to an identity no record names was never visited (MIGRATION item 37, known gap ⑤; S-2935): a mis-anchored global allow in it kept allowing in every project.
412
+ - **Now.** `listBucketOwners()` (a method of the provider, not a root export) answers `{ owners: readonly RuleOwner[], unnamedBuckets: number }`, names only — no bucket is opened, nothing is written, no lock is taken. `owners` are the owners the directory can name that hold a bucket here: `{ kind: "local-owner" }` when the local-owner bucket file is present, and the principals the adoption marker names (the adopted principal, and a principal source) when their bucket file is present — so after an adoption the renamed bucket is listed as the adopted principal whether or not any approval record names it. Every other digest-named bucket file is counted in `unnamedBuckets`: present, not nameable by the directory, and not dropped. Only an ABSENT directory lists nothing (and it is not created) — a directory that cannot be looked at for any other reason (a parent that cannot be searched, …) is told, never read as an empty census; an unusable directory refuses `permission_rules.bucket_damaged`; a directory that cannot be examined or listed refuses `permission_rules.bucket_unreadable` with its `errno` (#3287); a corrupt adoption marker refuses with the marker's own refusal. The choice recorded: a listing that returns owners can only return the names the directory records — handing back a handle per digest-named file (opening a bucket without its owner) was not taken, since it widens the API for buckets whose owner nobody can state.
413
+ - **Narrowing / widening.** None; no existing face changed.
414
+ - **Consumers.** @server (S-2935, M36 File leg): `candidateOwners()` = the import-record owners ∪ `listBucketOwners().owners` (dedupe by owner key as you do), each visited through `forPrincipal` / `forLocalOwner` as now; `unnamedBuckets > 0` means the census is incomplete by that many — say it in the start-up report (as an unnamed-bucket count), do not treat the buckets as empty. The migration's known gap ⑤ closes for the adopted bucket; a digest-named bucket no marker and no record names stays unnamed and counted. @test: adopt local-owner → alice with no approval record, then `listBucketOwners()` lists alice.
415
+ - **Pins.** `test/backlog3286-bucket-owners.test.ts` — L1 an absent directory lists nothing and is not created · L2 the local-owner bucket · L3 digest-named buckets no marker names are counted · L4 the real adoption arc (local-owner → alice): the renamed bucket is listed as alice with no approval record, the local-owner file is gone so it is not listed, another principal's bucket is counted, alice's partition reads the rule · L5 a marker naming a principal source and its target (before the rename only the source; both once both files are present) · L6 names only: a damaged bucket is listed, nothing is written · L7 refusals: an unusable directory (`bucket_damaged`), a corrupt marker, an unlistable directory (`bucket_unreadable`, `EACCES`; skipped as root) · L8 files that are not buckets are not counted.
416
+
417
+ ### A background agent's row says when an extension started it — `requestedBy?: ExtensionRequester` on the registry row, the durable record and its summary and `TaskRegistry.list()`, and the concurrency refusal names the extension; an extension's call ids come from one mint and are read by one predicate (#3262; ruled C-R1113; wire +1 additive; behavior change: the concurrency refusal's occupant clause gains `started by extension "X"` for such a row; hard-breaking: none; closed sets: none; exports: none — one optional key on `TaskListRow`, `BackgroundAgentRecord`, `BackgroundAgentRowSummary` and `DelegationOccupant`) (@server @client-core @test)
418
+
419
+ - **Before.** A running `background_agent` row recorded the leg that spawned it and nothing about who asked: the model's own spawn and an extension's `$.agent.spawn` read alike on the row (`TaskRegistry.list()`, the durable record), so the concurrency refusal could name an occupant by task id and addressing name but not say that an extension held the slot (core762a, the refusal naming the occupant without its origin). The `ext-` prefix of an extension's call ids was spelled at two mint sites (`$.tool.call`, `$.agent.spawn`) and read nowhere.
420
+ - **Now.** The row carries `requestedBy?: ExtensionRequester` (`{ kind: "extension", name }`, the shape `tool_start` / `tool_end` and the approval card already carry): written once at the registration from the extension's own `$.agent.spawn`, on the live row, the durable record, the record's summary and `TaskRegistry.list()`'s row; ABSENT on every other row — the model's own spawn, the host's, and every row an earlier release wrote. That is the one reading: no word exists for "the model" or "the host". A revival keeps it (the row's origin, not the waker's). A stored value that is not exactly an extension's requester (another `kind`, a blank, whitespace-only or missing `name`, a list) is read as none, by one function (`readExtensionRequester`). The refusal's occupant clause reads `task_id a… ("worker", started by extension "ext")`; the extension name is the sanitized registration name. `mintExtensionCallId()` is the one mint of an extension's call id (both doors call it) and `isExtensionCallId(id)` its one reading; the agent station's `extensionSpawn` asks it before it looks up the call's record.
421
+ - **Narrowing / widening.** None: nothing is refused, allowed or ordered differently. The one visible difference is the occupant clause of the concurrency sentence for a row an extension started.
422
+ - **Wire / exports.** One optional key `requestedBy` on `TaskListRow`, `BackgroundAgentRecord`, `BackgroundAgentRowSummary` and `DelegationOccupant`; the package root gains no name. The key is additive and absent on an old row: a store that files the record as columns needs a nullable `requested_by` (or keeps the record's JSON as it does for the other optional members); a reader reads the key's absence as "not an extension's spawn".
423
+ - **Consumers.** @server (the row projection): project `requestedBy` beside `agentType` on the background-task row when present, and drop nothing when it is absent; a SQL record store carries the optional member. @client-core ([11937], the background task list): `requestedBy.name` is the label for "started by extension X"; its absence is "not an extension's". @test: an extension's `$.agent.spawn` ⇒ the row names it; the model's spawn ⇒ no key.
424
+ - **Choice recorded.** The ticket listed three origins (extension / model / host); only the extension is a word. Both other origins are the absence of the member — a second reading ("model" written on the row) would make an old row's absence mean "unknown" instead of "not an extension's".
425
+ - **Pins.** `test/backlog3262-requested-by.test.ts` — Q1 the mint and the predicate (minted ids are extension ids; a model's ids and non-strings are not) · Q2 a real extension's `$.agent.spawn` on a real Runner: the live row, the durable record and the list row name it, the extension's own second spawn meets a sentence that does, and the frames of `$.tool.call` and `$.agent.spawn` carry ids the predicate reads · Q3 an extension-started and a model-started row side by side: only the first carries the member (list row, record, summary) and the sentence names it for that row alone · Q3b a stored value that is not exactly an extension's requester is read as none · Q4 a revival keeps the row's origin · Q5 the reading function.
426
+
427
+ ### A hold receipt says which hold it is — a hold a person there can answer is still `held`; a hold by the recipient's own settings or state is `held_by_policy`, which asks no one and runs no deadline, so the sender is no longer told to expect an approval that cannot come (#3335; behavior change; hard-breaking: one, three sentences below, open to veto; closed sets: `PeerDeliveryReceiptState` +1 and `MailboxPeerNoticeState` +1, the same word `held_by_policy`, appended; exports: none new; wire: +1 additive closed-set member, no key added) (@server @cli @client-core @test)
428
+
429
+ - **Before.** Every hold sent its sender `held`, rendered "… was held for the recipient user's approval … its user must approve first" (v7.63.0 `src/agents/peer-held-queue.ts:498` / `:505`). For a hold by the recipient's own settings or state — a managed `crossSessionInbound: "hold"` (server's `CROSS_SESSION_INBOUND=hold`), the user's or a repository's `hold`, an unrecognized value, a permission mode that could not be determined — no deadline was armed (`armDeadline` runs for `PEER_HELD_REVIEW_CAUSES` only) and a host review face presents only those causes (server's `peer-inbound-face.ts` reads that set): the sender was told to wait for an approval nobody was asked for, and the letter did not expire on a clock either. On the recipient side the held disclosure said "expires with a receipt under dialogExpiry" for every session-lane hold, and the judge's `cross-principal-default` sentence said "held for your review" of a cause that is not a review cause.
430
+ - **Now.** The hold receipt's word is read from the hold's cause by one reading, `peerHeldReceiptStateOf` (beside `PEER_HELD_REVIEW_CAUSES` in `src/agents/peer-notices.ts`): a review cause (`mode-mismatch`, `no-mode-asserted`, `invalid-mode-attestation`) is `held`, its line, deadline and every byte unchanged; every other cause (`explicit-setting`, `managed-setting`, `repo-setting`, `invalid-setting`, `mode-unknown`, `bypass-default`, `cross-principal-default`) is `held_by_policy`, rendered "[Cross-session delivery notice] Your message to another session was held by the recipient session's own settings or state (recipient: …), not for anyone's approval. Not delivered to that session's assistant; no one there is asked to approve it and there is no expiry deadline: it waits for those settings or that state to change. Do not wait for a reply; continue, or choose another approach." Both places a hold sends its receipt read it (a fresh card, and a hold the full queue could not card). Expiry is unchanged: no deadline is armed for a policy cause; a review hold whose deadline is already firing when that deadline's own re-judgment finds a policy cause is still ended `expired`, as before (KL-3335-c); and eviction at the cap and a graceful shutdown still end any hold with an `expired` receipt. The recipient's held disclosure names the dialogExpiry deadline only for a review cause and otherwise says "has no expiry deadline: its cause is this session's own settings or state, not a review". The `cross-principal-default` sentence says "… so it is held until that setting says how to treat it (it is not put up for review and has no expiry deadline)" — the cause stays a policy cause; `PEER_HELD_REVIEW_CAUSES` is unchanged and is the one set the deadline, the receipt word and a review face read.
431
+ - **Wire.** `PEER_DELIVERY_RECEIPT_STATES` gains `held_by_policy` as its seventh member and `MAILBOX_PEER_NOTICE_STATES` as its tenth (appended; the store validator admits it, and the drain renders it on a `delivery_notice` only). The receipt body keeps its keys (`state`, `refSeq`, `recipient`); the record's `content` mirror is the new line. A record written by an engine before this release is read as before.
432
+ - **Hard-breaking — one, three sentences (open to veto).** *What changed:* the receipt-state closed set gains `held_by_policy`, so a hold by the recipient's settings or state reaches its sender under that word instead of `held`. *Who is affected:* a TypeScript consumer with an exhaustive switch over `PeerDeliveryReceiptState` or `MailboxPeerNoticeState` (it no longer compiles until it names the word), a reader that takes `state === "held"` to mean "any hold", and a mixed fleet on one mailbox — an older engine reading the sender's box settles such a receipt `notice_unrouted` (shown to its host, not to the model), and on server's SQL mailbox an older replica's `readMailboxPeerMeta` refuses the record so its `claimLease` of that box fails closed until it upgrades (KL-3335-a, the KL-969c form). @server reads `PEER_HELD_REVIEW_CAUSES` and no receipt state (`src/peer-inbound-face.ts` on origin/main); @cli and @client-core draw `crossSessionNotice.text` whole and hold no receipt-state set (grep of their checkouts; not compiled against this tree). *Compensation:* add the arm (a hold no one is asked to approve, or the engine's line as it is); read "any hold" as `held` or `held_by_policy`; upgrade every replica that drains a shared mailbox before this release writes receipts into it.
433
+ - **Rules.** Added: one reading (`peerHeldReceiptStateOf`) of the one set, so the set answers three questions — whether the deadline runs, which hold word the sender gets, whether a review face presents the card. Retired: the second reading of `cross-principal-default` (a sentence promising review against a set that does not hold it) and the held disclosure's unconditional deadline clause. No second table of reviewable causes.
434
+ - **Known limits.** KL-3335-b — the receipt is the word at hold time: a re-judgment that moves the cause across the line re-announces it to the recipient's host and sends the sender nothing new (the reference's form). KL-3335-a — the rolling upgrade above. KL-3335-c — the deadline callback re-judges and then expires what is still held whatever its cause, so a review hold whose recipient turned on a `hold` setting after the last boundary and before the deadline is expired instead of kept (unchanged; a change to expiry is another ticket). KL-3335-d — the lines that end a policy hold still name an approval: `delivered` ("approved and released") when a setting change releases it, and `expired` ("not approved before expiry") at eviction or shutdown; and `PeerHeldQueue.settle(seq, "approve")` does not read the cause, so a host that presents a policy card to a person releases it (server's approval face lists and accepts only review cards, `peer-inbound-face.ts`). Neither is part of this change.
435
+ - **Consumers.** @server: nothing to change — `peer-inbound-face.ts` already reads core's `PEER_HELD_REVIEW_CAUSES`, and the review face, the deadline and the receipt word now agree by construction; a replica fleet sharing the SQL mailbox upgrades before this release writes receipts. @cli @client-core: the line is engine-rendered and drawn whole; a renderer that switches on `notice.state` adds the arm. @test (black box): with the recipient on a managed `crossSessionInbound: "hold"`, the sender's box holds a `delivery_notice` whose `notice.state` is `held_by_policy` and whose line is the one above, no approval row appears, and nothing expires after the dialogExpiry window; with a mode-parity hold, `held`, the old line, an approval row, and an `expired` receipt after the window.
436
+ - **Claude Code 2.1.316.** Divergence (a sema split the reference does not make): Claude Code sends `held` for every hold cause (the hold arm's `sendPeerReceipt(…, "held")`, `cli316.js:288223`) and renders it as awaiting the recipient user's approval "(permission-mode parity)" (`mn("held")`, `cli316.js:289027`), so its sender cannot tell a setting hold from a parity hold; the recipient-side host frame does carry the cause (`peer_message_hold.cause`, `cli316.js:261649`).
437
+ - **Pins.** `test/backlog3335-held-receipt-reviewable.test.ts` — R1 / R2 every cause classified once and the `held` half equal to the review set · W1–W3 the receipt-state set, the store's notice-state set as the union of the lane's two, the validator · T1 / T2 the new line (one and several), the `held` line byte for byte, the judge's sentences agreeing with the set · Q1–Q4 both mint points, no deadline for a policy hold, eviction and shutdown still `expired`, a cause move re-arms the deadline and re-sends nothing · K1 / K2 the two known limits held as they are (KL-3335-c: a firing deadline that re-judges onto a policy cause still expires; KL-3335-d: `settle` approves a policy card) · D1–D3 over a real file mailbox: a managed hold reaches the sender `held_by_policy` and renders, a parity hold stays `held` (control), a user `hold` then `next-turn` is `held_by_policy` then `delivered`. Re-pinned: the setting-cause receipt cells of the slice-4 suite (receipt section). Mutations (receipt).
438
+
439
+ ### `TaskRegistry.countRunningBackgroundShells({ includeRetained })` — one process-level, read-only number: how many background shells the exit-boundary hard face would take down now, counted by the hard face's own row reading (#3425; behavior change: none; hard-breaking: none; closed sets: none; exports: none — one new member on the existing `TaskRegistry`, additive) (@server @cli)
440
+
441
+ - **Before.** The registry counted running shell rows only per reach: `list(access)` (the caller's own tasks, every type and status, capped at its `limit`), `liveTasks(access)`, `countRunningBackgroundForOwner(owner)` (one owner key, background agents included), `runningShellIds(env)` (one env). None is process-level and none speaks the hard face's rule for retained rows, so a host that wanted the number a coming `killAllBackgroundShellsNow({ includeRetained: false })` would take down (server S-750, the handover lane: how many background shells the exit would end) had to walk `list` per session — a walk that misses every session it holds no access for and stops at the display cap — and then re-derive the retained rule, a second copy of the rule the hard face holds.
442
+ - **Now.** `countRunningBackgroundShells({ includeRetained })` — `includeRetained` required, no default, the same shape as the hard face — answers a number: the registry's `running` `background_bash` and `monitor` rows over the WHOLE registry (no owner, session, scope or env narrowing), a retained row counted only under `includeRetained: true`. The hard face and the count choose their rows through one function (`hardFaceVisitOf`): a row that is not a shell-lane row, or is `completed`, is not visited; a retained row not already settled `killed` by an explicit stop is left alone under `includeRetained: false`; every other row is visited, and a visited `running` row is the one the seat's kill settles. The walk of `killAllBackgroundShellsNow` reads its rows through the same function, so the count equals the reaping set row state by row state. Synchronous and read-only: the count calls no seat and changes no row; like the hard face it reads each row's env declaration of retention (`backgroundCapabilities.retainBackgroundProcesses`, host-provided data), so a host whose env makes that read throw makes the count throw as it makes the hard face throw. It counts registry rows, not process truth — a row whose seat later answers `already_gone` or `no_pgid` stays `running` and stays counted until its watcher settles it; a `killed` row inside a softer stop's grace window and a `failed` row (a watcher that lost its process) are visited by the hard face but are not running, so they are not counted.
443
+ - **Not these numbers.** Not `list(access)`'s length (the caller's reach, capped, every type and status), not `liveTasks(access)` (the caller's reach, every live type), not `countRunningBackgroundForOwner(owner)` (one owner key, agents included; owner-equality, not reach), not `runningShellIds(env).length` (one env).
444
+ - **Narrowing / widening.** None. The hard face's receipts, row states and the order of its checks are unchanged; only where the selection is written moved. The one difference only an accessor-backed options object could tell: `opts.includeRetained` is now read when a row is considered, before the type test, where it used to be read after the retained test.
445
+ - **Wire / exports.** `TaskRegistry` gains one public member. The package root gains no name (`TaskRegistry` is already exported); the type keys of the published class grow by one.
446
+ - **Consumers.** @server (S-750, the che-S750 handover lane): read `countRunningBackgroundShells({ includeRetained: false })` for "how many background shells the exit would take down" and `{ includeRetained: true }` for "how many the exit with the retained ones would"; the difference is the retained running rows. It is the number for THIS process's registry, over every session it holds — not a per-session number; for one session keep `countRunningBackgroundForOwner` (owner key) or the session-narrowed hard face's own receipts. @cli (L-686): `list()`'s `retained` still splits "will stop" from "keeps running" per row; this is the same split as a number.
447
+ - **Rules.** Retired: none. Added: none. The hard face's selection (shell-lane type, session reach, `completed`, the retained skip) was one inline block of `killAllBackgroundShellsNow`; it is one function now, read by the walk and by the count, and the skip rule is written once.
448
+ - **Claude Code 2.1.316.** No anchor claimed: the count reads this engine's own exit-boundary reap (`docs/background-process-lifetime.md`); not checked against the corpus.
449
+ - **Pins.** `test/backlog3425-running-shell-count.test.ts` — C1 the contract table, cell by cell: `background_bash` and `monitor` × {running, killed, failed, completed}, each unretained / task-retained / env-retained, under `includeRetained` false and true — the count and the hard face's receipt class match the table, the count equals the running rows the hard face acted on, and the count leaves the row in the state it found it · C2 a mixed registry: both modes, receipts and counts agree, after the walk only the spared retained rows remain · C3 both shell lanes count, a background agent row does not · C4 process-level: two sessions in two scopes (count 2, each owner's count 1, the session-narrowed hard face visits one, the count stays whole) · C5 rows on different envs and run owners all count · C6 not `list`'s length (60 own rows + 1 other: list 50, live tasks 60, count 61) · C7 read-only: a number, no seat call, no row change, same answer twice, a throwing seat never called and a throwing seat accessor never read · C8 registry rows, not process truth (`already_gone` / `no_pgid` rows stay counted) · C9 `includeRetained` is required (`@ts-expect-error` on the empty options and on no argument) · C10 the skip rule is spelled once and both faces walk with `hardFaceVisitOf` (source fence).
450
+
451
+ ### A deny refusal files the literals its sentence quotes — `tool_end.gate.disposition.echoed` lists the refused path (with its canonical target), the spelling the row matched, and the row, minted with the sentence from one finding (#3410; wire +1 additive; behavior change: none; hard-breaking: none; closed sets: +1 set `RefusalEchoKind` (`path`, `command`, `pattern`); exports: +2 root values `REFUSAL_ECHO_KINDS`, `isRefusalEchoKind`, +2 types `RefusalEchoKind`, `RefusalEcho`) (@cli @server @client-core)
452
+
453
+ - **Before.** When the read station refused a shell command on a deny row (`deniedBy: "read_boundary"`, no ask raised), the refused path, the spelling the row matched and the row's pattern reached a consumer inside one sentence (`readDenySentence`, `src/tools/fs/read-deny.ts`) and nowhere else on the record: a consumer that draws the path by itself — one line, hidden characters made visible — had to take the sentence apart to find where the path starts and ends. For a read the call's `read_path_denied` card named the target and the pattern; a refused write carried no card.
454
+ - **Now.** The denied arm of `GateDisposition` gains `echoed?: ReadonlyArray<{ kind: "path" | "command" | "pattern"; value: string; canonical?: string }>`: the literals the sentence quotes, in the order it quotes them — the target as a `path` (with `canonical` where the sentence names a canonical target that differs), the view the row actually matched as a second `path` when that is another spelling, and the row as a `pattern`. The sentence and the list are one mint (`readDenyRefusal`: one finding, two readings; `readDenySentence` is its sentence and is byte for byte what it was). `value` is whole where the sentence elides the middle of a long operand. Present when `deniedBy` is `read_boundary` and the refusal is a deny-row hit (and, by the next section's change in the same release, beside `ask_resolution`), on every exit that refuses so: the first pass, the approved edit's re-judge, the shell read admission after the gate let the call go (live leg and resumed leg) and the resumed leg's belt — the frame and the filed `executionOutcome` hold the same value. Absent beside every other layer word, beside a read-boundary refusal that quotes no deny row (a containment or identity finding), and on a record from an engine before this release: absence reads as "the sentence is the whole account". The station's answer (`ShellReadVerdict`) carries it on a refusal; an answer carrying a malformed list is not received and the call is refused fail-closed with the engine's own sentence. Invariant I13 screens it against one table (`DENIED_BY_MAY_ECHO`) the mint and the archive reading both read.
455
+ - **Consumers.** @cli: the refused path of a deny refusal can be drawn from `value` / `canonical` instead of taking the sentence apart. The sentence of a person's refusal of an approval (`approval denied for "<tool>": approve write to "<path>"?`) is a different sentence, minted by the ask and not by the deny table: its list is the next section's (#3442, the same release). @server: projects `gate` whole — no key to add. @client-core: mirrors the type. `command` is in the set and has no minting site yet.
456
+ - **Rules.** Retired: none. Added: one table (`DENIED_BY_MAY_ECHO`) and one invariant (I13); `readDenySentence` is now the sentence reading of the one mint, not a second mint.
457
+ - **Known limit.** The list holds the path exactly as the sentence quotes it, so a path whose name has the shape of a key is the same literal on both; the sentence never redacted its operands and the list opens nothing it did not.
458
+ - **Claude Code 2.1.316.** No anchor claimed: the member annotates this engine's own gate record (not checked against the corpus).
459
+ - **Pins.** `test/backlog3410-refusal-echoed.test.ts` — the mint over eight forms (a plain read, a different canonical, a matched spelling, both together, a canonical equal to the target not repeated, a write-list hit, a read row reached through a link, a read row reached directly); the sentence's quoted spans equal the list's literals in order, both ways, on every form; a 5 kB path whole in the list and elided in the sentence; a key-shaped name one literal on both; I13 in both readings (nine wrong lists, a wrong layer, an allowed arm); absence screens clean and the mint writes no key; the station's answer received whole or not believed; the real lane (a denied `cat`, a redirection into a write-list path, a write through a link whose chain passes a read row, the text quoting every literal, the sentence's bytes as the mint's); controls (a policy refusal, an allowed read, an identity refusal carry none); the admission refusing after the gate allowed the call, the resumed leg's belt and its admission (frame equals the filed row).
460
+
461
+ ### A person's refusal of the engine's own question files the path the question quotes — `tool_end.gate.disposition.echoed` beside `deniedBy: "ask_resolution"` when the refused question is the write gate's or the plan mode's generic question about a path (#3442; wire: the existing `echoed` member gains a second layer, additive; behavior change: an ask-resolution refusal of such a question now carries `echoed`; hard-breaking: one, type level, three sentences below, open to veto — the wire member is not one: `echoed` ships with #3410 in this release, so no released contract named its layer; closed sets: none (the list's kinds are #3410's `RefusalEchoKind`); exports: none by name; members: `EngineAttestation` −`genericQuestion` +`sentence?`) (@cli @server @client-core)
462
+
463
+ - **Before.** A person who refused the write gate's question (`approve write to "<path>"?`) or the plan mode's (`Cannot write to <path> while in plan mode.`) left a refusal whose sentence quotes that question whole (`approval denied for "<tool>": approve write to "<path>"?` …), and the path it names lived only inside that sentence: a consumer that draws the path by itself — one line, hidden characters made visible — had to take the engine's sentence apart to find where the path starts and ends. The record told the generic question apart (`genericQuestion`, read by the policy chain's entry mint so the engine's own question names no asker) but carried nothing of what it quotes.
464
+ - **Now.** The engine's record of a sentence it composed is one member, `sentence: { text, generic?, echoed? }` (it retires `genericQuestion`: `generic` is that bit, `echoed` the literals the sentence quotes in #3410's list form), read through one function (`engineSentenceOf`) that answers only while the decision's `message` IS `text`. The write gate's generic question and the plan mode's write question list their path (as the call spells it — the tool's declared target, so a NotebookEdit's `notebook_path` and never a decoy `file_path`; not a canonical path); the plan mode's call question is generic and quotes nothing. The resolver's arms whose refusal sentence quotes the question — a person's no (boolean or object arm, with or without a note), the approver's own window, the deployment policy's or a PermissionRequest hook seat's no, nobody reachable, no approver wired (headless), the denial-limit fallback's window, and the refusal of a blanket or policy allow on an ask that needs a person — carry the question's list on the refusal's record when the question the engine's station put to the approver is still the engine's sentence; the gate's exit files it as `GateDisposition.echoed` beside `ask_resolution`. Arms whose sentence does not quote the question (an abort, an approver that threw, an out-of-contract answer, arguments or an edit no approval binds) carry none.
465
+ - **When the list is absent.** The list stands only while the sentence does: a card that appended to the question (an outranked allow rule's account), a persisted rule's appended account, a hook's or a policy's own words folded over it, a layer that rewrote the refusal's sentence on the way out, and a question the engine did not compose (a deployment policy's ask, even one that copies the engine's words) — none files a list. A policy that calls the exported `resolveAsk` itself never gets one, whatever it puts on the request: the list's only source is the record of the station that composed the question. The durable leg's refusal (the parked call refused on resume) quotes no question and files none. The contract-failure refusals the gate's exit composes itself (a resolution with the retired `settlement` member, an allow over a refusal record) file none.
466
+ - **Narrowing / widening.** None of the call: what runs, what is refused and every sentence's bytes are unchanged. The policy chain's entry mint (#3203) reads the generic bit through the new member exactly as it read `genericQuestion`.
467
+ - **Wire / exports.** `GateDisposition.echoed` (#3410, this release) is present beside `ask_resolution` as described above; it never was released beside `read_boundary` alone, so its contract simply names two layers. The engine record's type is on the package root (`EngineAttestation`, type only — no mint is exported); its member change is the hard-breaking item below. `resolveAsk`'s signature is unchanged. The package root gains no name.
468
+ - **Hard-breaking — one, type level, three sentences (open to veto).** *What changed:* `EngineAttestation` loses its optional `genericQuestion` member, and gains the optional `sentence` member, whose `generic` bit is what it carried; no record carries `genericQuestion` again. *Who is affected:* no repository reads the member — grep of the server / cli / client-core / sdk / test / desktop / web-client / web-admin / connectors / settings-schema origin/main finds it only in the cli's consumption manifest text and the web-admin's list of a past release's type keys, no code; a host that read it off a decision's record no longer compiles against this release. *Compensation:* a host reads `attestation.sentence` and holds it only while the decision's `message` is `sentence.text` (the engine's own reading, `engineSentenceOf`, is not exported) — the same equality `genericQuestion` was read under; `sentence.generic === true` is the old member's meaning.
469
+ - **Consumers.** @cli (KL0382): the consumption rule is three sentences — when the list is present, draw the refused path from it; when it is absent, draw what was asked from the call's own arguments; in neither case take the sentence apart. `value` is the call's spelling (it may be relative) — never read it as a canonical path. It rides the wire byte for byte as the call spelled it: control characters (an ESC or a CR in a directory name reaches `value` as it is) are neither escaped nor stripped, so a shell that prints a `value` escapes them itself. @server: projects `gate` whole — no key to add; a server policy layer that calls `resolveAsk` itself gets refusals with no list by design (its consumer falls back to the call). @client-core: mirrors `GateDisposition` — no new member; the `EngineAttestation` member change (above) has no client-core reader.
470
+ - **Rules.** Retired: the record member `genericQuestion` and its inline reading. Added: one record member (`sentence`, net zero), one reading of it (`engineSentenceOf`, used by the entry mint, the resolver and the gate's exit), one resolver flag spread by the arms that quote the question (`quotesQuestion`, never on the resolution), one module-level resolver entry that takes the asked decision (`resolveAskFor`, the four engine stations; the exported `resolveAsk` is it with none), one exit reading (`refusalEchoOf`, both channels through the one layer table); the layer table admits `ask_resolution`. The merge of records is unchanged (a later decision missing the sentence group takes the earlier's; the equality decides whether it is read).
471
+ - **Claude Code 2.1.316.** Claude Code's refusal text quotes no literal (`cli316.js:261614`) and its interface draws a rejected call from the call's input (`cli316.js:294724`): it answers "how does the shell draw a refusal" from structure, never from the sentence — the same rule; this engine's refusal quotes its question, so the engine lists what the question quotes, the half Claude Code gets from the input. No divergence entry (additive metadata, model-facing bytes unchanged).
472
+ - **Pins.** `test/backlog3442-ask-refusal-echo.test.ts` — J1 the real Runner: Write's generic question refused with a path holding a tab and a newline (the list, the text's bytes, the JSON round trip), NotebookEdit's target with a decoy `file_path`, the plan mode's write question (listed) and call question (nothing), headless with the remedy after the mint (listed); A every resolver arm table-driven (eleven quoting arms listed and quoting the question, seven non-quoting arms bare; the exported resolver bare on every arm; an approval bare); K7 a card's appended account, a persisted rule's appended account, a hook's folded question, the exit's own equality over a rewritten refusal; J3 a policy's literal copy of the engine's words, a policy calling the exported resolver with forged keys, the exported resolver handed a forged fifth argument; K10 the merge fills the group and the equality decides; controls (the read station's list unchanged, a policy-layer deny carrying the question's record bare, the minted literals frozen, `genericQuestion` gone from the record and from every source file). `test/backlog3203-ask-reasons.test.ts` holds the generic bit's reading unchanged. Three source censuses of the resolver's request mints — `test/backlog1214-ask-class-on-request.test.ts` F1, `test/backlog1688-bound-grant-absence.test.ts` B4 and the two ask-mint scans of `test/permission-rule-wiring.test.ts` — count the stations' calls of `resolveAskFor` (the same sites, counts and carries). Mutations: `.gate-logs/criteria-3442-mutations.md` (receipt).
473
+
474
+ ### The execution environment's namespace is one class — every terminal code in `env.` (the platform lifetime stop and a factory's refusal to mint, such as `env.home_unconfirmed`) folds to `config` by prefix, and the exact row is retired (#3336; behavior change — `errorClassOf` answers `config` instead of `unknown` for an `env.` code other than `env.lifetime_expired`; hard-breaking: none; closed sets: none; exports: none; widening: one, open to veto) (@server)
475
+
476
+ - **Before.** In 7.63.0 `errorClassOf` knew exactly one code of the namespace, `env.lifetime_expired`, as an exact row; every other `env.*` code folded to `unknown` — including the code a deployment's `executionEnvFactory` throws to refuse to mint, which the run's terminal carries verbatim (#3230, below), such as `env.home_unconfirmed`. The prefix had been kept out because `env.context`, `env.get` and `env.set` are not error codes. That is true and was never a reason: those strings never reach a terminal code, and a terminal code is the fold's whole domain.
477
+ - **Now.** One rule: `env.` is a row of the prefix table (`DOTTED_PREFIX_CLASS`, `src/core/tool-errors.ts`) with the class `config` — the class of a refusal or a limit answered by changing the environment or the configuration and retrying, which `env.lifetime_expired` always had. The exact row for `env.lifetime_expired` is deleted (the prefix answers it, the same class). A code a later deployment mints in the namespace (`env.home_mismatch`) needs no registration here. `memory.*` is unchanged and stays a mixed bag on purpose: most of its codes are tool-call incidents, not task rejections.
478
+ - **Narrowing / widening.** One widening of the fold, open to veto: an `env.`-prefixed terminal code other than `env.lifetime_expired` reads `config` where it read `unknown`. Nothing is rewritten — the fold is derived and read-side, no code and no result changes.
479
+ - **Who needs it / who is affected / compensation.** *Needs it:* a host that classifies a failed run by class and wants a factory's refusal to read as what it is — a configuration answer, not an engine fault. *Affected:* a host that read `unknown` as "an engine fault" and alerted or retried on a factory's `env.*` refusal. *Compensation:* none needed; a host that switches on the code itself sees the same code.
480
+ - **Wire / exports.** None. `TaskResult.terminal.code` is unchanged and `WorkerErrorClass` gains no member.
481
+ - **Consumers.** @server: the S-2997 observation ticket that waited on this can be resolved — `env.home_unconfirmed` reads `config`, and the `config` bucket your side already consumes needs no change.
482
+ - **Rules.** Retired: the exact row `env.lifetime_expired`, the comment that `env.` cannot be a prefix, and the pin that asked the fold to answer `unknown` for `env.context` (a string outside its domain). Added: one prefix row — the namespace is answered by one rule instead of a rule plus a copy of its first member, and no deployment's code is registered in this module.
483
+ - **Claude Code 2.1.316.** No anchor (inferred): `errorClassOf` folds this engine's own terminal codes and Claude Code has no counterpart of it; nothing to register.
484
+ - **Pins.** `test/backlog3336-env-namespace-class.test.ts` — E1 the namespace's codes read `config` (the lifetime stop, `env.home_unconfirmed`, `env.home_mismatch`, an unseen `env.something_new`) · E2 the exact row is gone and the prefix row is the one rule · E3 the dotless word, a longer word, another case and a leading character stay `unknown` · E4 `memory.*`, `model.*` and the other prefixes keep their answers · E5 no code, an empty code and an unrecognised dotted code stay `unknown` · E6 src sets no `env.context` / `env.get` / `env.set` as a code and every `env.` code it does mint reads `config`; `test/error-class-of.test.ts` — the cases moved from the exact-code list to the prefix list.
485
+
486
+ ### A factory that refuses to mint ends the run at prepare with its own code and sentence — stated as a contract in INTEGRATION-CORE §4.5b′ and pinned over a real Runner (#3230; behavior change: none — 7.63.0 already carried the refusal, this release states and pins it; hard-breaking: none; closed sets: none; exports: none) (@server @test)
487
+
488
+ - **Before.** In 7.63.0 an `executionEnvFactory` that threw an error with a `code` ended the run at prepare with that code, but no document said so and no pin held the code and the sentence on the terminal (the existing factory-throw pins hold the session's cleanup and that the run fails): the integration note spoke of a typed refusal for a device-bound factory and nothing of what the caller then receives, so a deployment choosing between refusing at the factory and refusing per command had no sentence to build on.
489
+ - **Now.** §4.5b′ of `docs/INTEGRATION-CORE.md` states it. On a task's first leg the refusal is the run's whole account: the factory ran once, no environment was built, the model was never asked (so no command reaches a read boundary), the run is `failed`, `result.terminal.code` is the code the factory threw (read down the `cause` chain) and `result.terminal.message` its sentence, after the credential screen every failed terminal's sentence goes through. The engine rewrites neither and mints no code of its own; a refusal with no code is a `failed` run with no `code`. A code the factory refuses with MUST be in the `env.` namespace, which reads `config` by prefix (#3336, above); a code outside it is carried the same way and classified by its own namespace.
490
+ - **Narrowing / widening.** None. No line of the prepare path changed.
491
+ - **Wire / exports.** None.
492
+ - **Consumers.** @server (S-2778): refuse at the factory — throw an `env.*`-coded error (`env.home_unconfirmed`); it reaches the caller as the run's `failed` terminal with that code, and the same sentence for a first command that names a path and one that does not, because no command is ever run. @test: pins F1–F9 hold the carried refusal over a real Runner, with a factory that mints an environment as the control.
493
+ - **Rules.** None added or retired; this release states a rule the engine already followed.
494
+ - **Claude Code 2.1.316.** No anchor (inferred): Claude Code has no execution-environment factory; the refusal and its code are this engine's.
495
+ - **Pins.** `test/backlog3230-factory-refusal-carried.test.ts` — F1 `env.home_unconfirmed` is the terminal's code, its sentence is carried, class `config` · F2 the factory ran once, no environment was built, the model was asked zero times · F3 a rejected promise is carried the same way · F4 an unseen `env.something_new` is carried and reads `config` · F5 a code outside `env.` is carried as stated and keeps its own class · F6 a refusal with no code is `failed` with no `code` (class `unknown`) · F7 a factory that mints an environment runs to completion with the same harness · F8 the code is read down the `cause` chain · F9 the sentence goes through the credential screen · D1 / D2 §4.5b′ sits between §4.5b and §4.5c and states the carried refusal and the namespace rule.
496
+
497
+ ### The single-ticket door says why a ticket was refused in the same two closed words a batch member's row carries — `redeemRuleTicket`'s refused arm is `{ status, code, committed, reason }`, and the shell that stripped the words off the leg's own refusal is gone (#3414; behavior change: none at runtime; hard-breaking: one, type level, three sentences below, open to veto; closed sets: none new; exports: none; members: `RedeemResult` refused arm +`code`, +`committed`, both required in type; wire: `redeemRuleTicket` refused result +2 keys, redeemed result unchanged) (@server @cli)
498
+
499
+ - **Before.** The redemption leg minted `code: RuleRefusalCode` and `committed: RuleWriteCommitted` for every refusal (7.63.0, #3363), and the single-ticket door `redeemRuleTicket` dropped both before answering `{ status: "refused", reason }`. The same fact — "this ticket was refused, and for this cause, and the store did or did not change" — had two faces: a member row of `redeemRuleBatch` said it in two words, the door said it only in a sentence a host may not parse. A host that needed the cause of a single ticket had to walk a one-member batch and read its row.
500
+ - **Now.** One shape. The door returns the leg's refusal as it was minted: `{ status: "refused", code, committed, reason }`, `code` one of the 17 words of `RULE_REFUSAL_CODES`, `committed` `"no"` | `"unknown"`, `reason` the unchanged sentence. The stripping shell (`redeemRuleTicket` over a private `redeemTicketLeg`) and the leg-only refusal type are retired: `redeemRuleTicket` is the leg, and the batch walk calls it per member. The redeemed arm is untouched.
501
+ - **Narrowing / widening.** None. Nothing is refused that was not refused; no sentence changes; the words were already computed.
502
+ - **Hard-breaking — one, type level, three sentences (open to veto).** *What changed:* `RedeemResult`'s refused arm gains `code` and `committed`, required in type (every refused result carries both); at runtime no key is removed or changed and the redeemed arm is untouched. *Who is affected:* a TypeScript consumer that constructs a refused `RedeemResult` literal (a mock, a test fixture) no longer compiles until it names both; a consumer that only reads the result is unaffected — @server reads `redeemed.reason` after `status !== "redeemed"` (`src/rules-consent.ts:1456-1457`, read in its local checkout at `96a91d82`, not fetched, not compiled against this tree) and builds no refused literal there. *Compensation:* add `code` (a word of `RULE_REFUSAL_CODES`) and `committed` (`"no"` | `"unknown"`) to the literal; read `committed` for retry-versus-reconcile and `code` for the cause, and stop reading the start of `reason`.
503
+ - **Consumers.** Affected: @server — the single-ticket arm may branch on `committed` / `code` instead of the sentence (its card lane today answers `redeem-refused` with the sentence). Not affected: @cli @client-core (no match for `redeemRuleTicket` in their `src`, grep of the local checkouts, not compiled; they consume the wire receipt).
504
+ - **Rules.** Retired: the stripping shell and the second refusal type (`LegRefusal`, `RedeemLegResult`), and the known limit of 7.63.0 that said the door answers the sentence alone. Added: none. One refusal shape, one mint (`refusal()`).
505
+ - **Claude Code 2.1.316.** No anchor (inferred): Claude Code keeps no approval-record or ticket-redemption protocol; nothing to register.
506
+ - **Pins.** `test/backlog3414-refusal-one-shape.test.ts` — S1 one case per refusing cause of the single-ticket door, through the real `redeemRuleTicket` (15: eleven leg causes, four landing causes, both claims) · S2 the door and a batch member's row, built over the same fixture, carry the same words and sentence (4) · S3 control: a redeemed ticket — first time and replay — carries exactly its old keys and neither word · S4 the refused arm is exactly `{ status, code, committed, reason }`, and one built without the words does not compile. `test/backlog3363-refused-arm-closed-keys.test.ts` K7 (the door answers the sentence alone) is retired with it.
507
+
508
+ ### The batch's own refusal, before it has a member table, says why in the same two closed words — `redeemRuleBatch` on a record it cannot walk answers `{ status, code, committed, reason }`, and every refusal this module mints, the single ticket's, the walk's member rows' and this one's, comes from the same function (#3415; behavior change: none at runtime; hard-breaking: one, type level, three sentences below, open to veto; closed sets: none new, no word added; exports: none; members: `redeemRuleBatch` refused result +`code`, +`committed`, both required in type; wire: `redeemRuleBatch` record-level refusal +2 keys, member table unchanged) (@server)
509
+
510
+ - **Before.** A batch that could not start — the record missing, another principal's, stale, pending or malformed, or the owner's store not resolvable — answered `{ status: "refused", reason }`, minted by seven hand-written literals beside the refusal function the rest of the module used. 7.63.0 (#3363) gave a refused member row the two words and left this arm out, so "the batch could not start" was the one refusal of the redemption protocol a host could only tell by the start of a sentence.
511
+ - **Now.** The same shape and the same words, all already in `RULE_REFUSAL_CODES` (no word is added): `record_missing`, `wrong_principal`, `record_schema_stale`, `not_confirmed`, `record_malformed` (the structural precondition, and a settled record that names no valid chosen offer), `store_unavailable`; `committed` is `"no"` at all seven — nothing was written. The sentences are unchanged. The walk's member rows are minted by the same `refusal()` (a row is the refusal plus the member's identity), so no hand-written refused literal is left in the module.
512
+ - **Narrowing / widening.** None. The same records are refused for the same reasons; the arm gains two keys.
513
+ - **Hard-breaking — one, type level, three sentences (open to veto).** *What changed:* the refused result of `redeemRuleBatch` (the arm without a member table) gains `code` and `committed`, required in type (the wire manifest reads it as `signature changed: redeemRuleBatch — return type`, its refused arm now being `Extract<RedeemResult, { status: "refused" }>`); at runtime no key is removed or changed and the member table is untouched. *Who is affected:* a TypeScript consumer that constructs that arm as a literal (a mock, a test fixture) no longer compiles until it names both; a consumer that tests `"status" in result` and reads `result.reason` is unaffected — @server does exactly that at `src/rules-consent.ts:1379` and `:1641` (read in its local checkout at `96a91d82`, not fetched, not compiled against this tree) and builds no such literal. *Compensation:* add `code` (a word of `RULE_REFUSAL_CODES`) and `committed` (`"no"` | `"unknown"`) to the literal; read `code` for the cause and stop reading the start of `reason`.
514
+ - **Consumers.** Affected: @server — the import lane's top-level refusal (`indeterminate(result.reason)`, released for retry because "the engine refused before any member loop") may read `committed: "no"` and `code` instead of reading that off the arm's position; its cause classification stops depending on the sentence. Not affected: @cli @client-core (no match for `redeemRuleBatch` in their `src`, grep of the local checkouts, not compiled).
515
+ - **Rules.** Retired: seven hand-written `{ status: "refused", reason }` literals and five hand-written member-row literals (`withheld`, `store_read` ×2, `dot_removed`, the copy of the leg's words) — all now `refusal()`; the 7.63.0 known limit that the batch-level refusal answers the sentence alone. Added: none.
516
+ - **Claude Code 2.1.316.** No anchor (inferred): Claude Code keeps no approval-record or ticket-redemption protocol; nothing to register.
517
+ - **Pins.** `test/backlog3414-refusal-one-shape.test.ts` — B1 one case per record-level refusing site of `redeemRuleBatch`, each with its word, its claim and its sentence (7), plus the census of the seven sites · B2 one cause, one word at the batch and at the door (three causes) · B3 control: a batch that walks answers its member table (`members`, `rev`), a refused row is the leg's refusal plus the member's identity (eight keys), and the refused result built without the words does not compile.
518
+
519
+ ### `committed` is read one way — `no` is "the store settled that nothing this call wrote stands", which a `dot_removed` member (its add landed, a read that succeeded found it removed) is, and the table's own sentence now says so once (#3416; behavior change: none; hard-breaking: none; closed sets: none; exports: none; contract sentence: the definition of `RuleWriteCommitted` in `permission-rule-store.ts` and in `docs/CLOSED-SETS.md`) (@server)
520
+
521
+ - **Before.** `RuleWriteCommitted` was defined twice. The table's sentence (`permission-rule-store.ts`, `docs/CLOSED-SETS.md`) read `no` as "the store itself answered that nothing landed"; the batch member's doc (`RedeemedBatchMember`, 7.63.0) read it as "the rule does not stand because of this call". 7.63.0's `dot_removed` row is `committed: "no"` for a member whose add HAD landed and was then found removed — true under the second reading, false under the first: one word, two definitions (7.63.0 review R-1).
522
+ - **Now.** One reading, written once, in the table's own sentence: the word answers "has the store itself settled whether anything this call wrote stands?" `no` = it has, and nothing does — nothing was written, or the store answered that nothing landed, or what landed is found removed by a read that succeeded (`dot_removed`); `unknown` = it has not (the apply threw or answered unreadably, or the read-back that would have settled it could not be taken). The member row's doc and the closed-set entry point at it, and the add and remove doors' failed-arm docs say they read it as the table reads it. No word, key or value changes.
523
+ - **Why `dot_removed` stays `no` and is not `unknown`.** Two readings were open: widen `no`'s sentence, or give `dot_removed` `unknown`. The second does not hold, on two facts. (1) The read-back that finds the dot removed SUCCEEDED, so the question is settled; `unknown` is the word for a look that did not settle, and saying it here sends a caller to reconcile with `list()` for an answer the store already gave. (2) `unknown`'s own domain is `store_read` / `store_write` (the apply threw, answered unreadably or left no trace, or the read-back could not be taken; #3363's K3 pins it): `dot_removed` would be the one `unknown` with nothing indeterminate in it, and `unknown`'s sentence would need widening as well. The first reading touches one sentence and no code.
524
+ - **Narrowing / widening.** None.
525
+ - **Hard-breaking — none.** No type, key, value or word changes; a consumer that mapped `committed: "no"` to "refused, nothing to reconcile" reads a `dot_removed` row exactly as it did.
526
+ - **Known limit.** `no` on a `dot_removed` row is about the rule's standing, not about the bytes' history: the add's dot is in the raw state under its tombstone (pinned). A host that wants the history reads the store; a retry of the same ticket re-reads the same tombstone — what lands the rule again is a new consent, which is what `code: "dot_removed"` says.
527
+ - **Consumers.** @server: per the 7.63.0 entry above, `ImportMemberOutcome` maps `committed: "no"` to `refused` with `code` as the reason, so a `dot_removed` row maps as before; nothing to change (not re-read in its checkout).
528
+ - **Rules.** Retired: the second definition of `no` (the member row's) and the first one's "nothing landed" as the whole of `no`. Added: none.
529
+ - **Claude Code 2.1.316.** No anchor (inferred): Claude Code keeps no permission-rule write table; nothing to register.
530
+ - **Pins.** `test/backlog3414-refusal-one-shape.test.ts` — D1 a `dot_removed` row is `no`, its add IS in the raw state under a tombstone, the effective view does not hold the rule · D2 the contrast: a write that committed and lost its acknowledgement is `unknown` and the rule DOES stand · D3 over every `no` the single-ticket door answers, the redeemed candidate does not stand afterwards · D4 the table's sentence names the removed-since case, the closed-set entry carries the same reading, the member row's doc restates no second definition.
531
+
532
+ ### The member-shape table names the resource ledger and the checkpoint id — a row whose ledger is not an object or whose id is not a string is `damaged` on the judge and on every listing face, where a `null` ledger listed `damaged` while the judge said `ok` and `listBySession` handed the row back whole (#3411; behavior change; behavior narrowing — one, open to veto; hard-breaking: one, three sentences below, open to veto; closed sets: none; exports: none; wire: no key added) (@server @client-core @cli @test)
533
+
534
+ - **Before.** `ROW_MEMBER_SHAPES` (7.63.0) named five members; the summary projection reads two more, and those two had no entry. Measured on `bbc88f833` (an unstamped row over an in-memory store): a `resourceLedger` that is `null` — the form a JSON column left as `null` hands back — made the projection throw on `ledger.spentMicroUsd`, so `listByScope` and `listOverdue` listed the row in the unreadable form (`damaged`) while `judgeCheckpointRow` said `ok` and `listBySession` answered the row whole: a card the list called damaged could be approved. A ledger that is a number, a string or a list, and a `checkpointId` that is `null`, a number or a record, were `ok` on every face and the summary echoed the id as it was (`checkpointId: 7` on a summary typed `string`); a `checkpointId` that is a BigInt threw in the projection's own disclosure and listed unreadable while the judge said `ok`.
535
+ - **Now.** Two entries, after `deadline` (the table's order is its reading order, so the older members are still told first): `resourceLedger` absent or a record ("its resource ledger is not an object"), `checkpointId` absent or a string ("its checkpoint id is not a string"; a non-empty one since #3429, below). `rowMemberProblem` reads the seven members, each once. For every such row the judge, `summarizeCheckpoint`, `listByScope`, `listOverdue` and `listBySession` answer `damaged` / `unreadable` in the table's words, and the resume's diagnostic carries the session face's `problem` verbatim. A shape, never a particular value: `{}` is a record (the empty string stood as a string here and is no id since #3429). This closes the Known limit of the 7.63.0 section on the member-shape table (the `resourceLedger: null` disagreement).
536
+ - **Narrowing — one (open to veto).** A row whose `resourceLedger` is not a record, or whose `checkpointId` is not a string, is refused before the claim at the resume (`checkpoint.invalid_outcome` / `requirements_damaged`, the member named; the row stays `pending` and byte-identical) and lists `damaged`; it resumed before. No release of this engine writes either member in another shape (the id is `mintCheckpointId()`'s string or absent; the ledger is a record or absent).
537
+ - **Hard-breaking — one, three sentences (open to veto).** *What changed:* a parked row whose `resourceLedger` is not an object (a `null` a JSON column left) or whose `checkpointId` is not a string is no longer resumable on this release, and every face reads it `damaged` / `unreadable`. *Who is affected:* a deployment writing its own rows with such a value, and a mixed fleet whose 7.63.0 workers still resume such a row (the row is left pending and byte-identical here, so it can still finish there). *Compensation:* write the member absent, not `null`; finish the row on a worker of the release that parked it, or expire it (`CheckpointStore.expire`) and run the task again.
538
+ - **Affected.** A deployment or store that hands back a row with a `null` / non-object ledger or a non-string id (none known in-tree; no release of this engine writes either shape). Every row with a ledger record or none, a string id or none, reads and resumes exactly as before.
539
+ - **Rules.** One table where the projection and the judge each had a member the other did not read: the ledger's and the id's reading is the table's entry, and the projection's own throw on a `null` ledger is no longer the only thing that says so. Added: two entries. Retired: none.
540
+ - **Consumers.** @server: a store's listing built on `summarizeCheckpoint` carries the judge's verdict for these rows; an SQL-backed store that rehydrates an absent id or ledger as `null` must hand it back absent (read, not run — no in-tree store does). @client-core @cli: nothing new to render — such a row is a `damaged` row. @test (black box): a v1 plan review row with `resourceLedger: null` ⇒ its approval is refused `checkpoint.invalid_outcome` / `requirements_damaged` naming `resourceLedger`, the row pending; `listBySession` lists it `unreadable`.
541
+ - **Claude Code 2.1.316.** No anchor: Claude Code keeps no durable park row store or listing.
542
+ - **Pins.** `test/backlog3411-row-shape-ledger-id.test.ts` — A1–A5 the judge, the projection and the listing faces over eight forms (a `null` / number / string / list ledger; a `null` / number / record / BigInt id), the File store over the forms its JSON keeps · P1 the refusal names the member in the listing's words · K1–K3 a ledger record and a string id read, absent members are no damage, an empty record reads · O1–O2 the table's order, newer before damaged · R0 / R1 a legacy plan review with such a member is refused, the row pending. Mutations (receipt).
543
+
544
+ ### The member-shape table reads the gate × pending-action pair the pause registry declares — a row whose pending action is not the one its gate kind pairs with is `damaged` on the judge and on every face and is refused at the resume, where a decide consumed it and ran nothing (#3412; ruled C-R1104; behavior change; behavior narrowing — three, open to veto; hard-breaking: one, three sentences below, open to veto; closed sets: none; exports: none; wire: no key added) (@server @client-core @cli @test)
545
+
546
+ - **Before.** The registry (`PAUSE_REGISTRY`) pairs each gate kind with one pending kind and `pauseOf` refuses any other pair at the mint, but nothing read the pair on a row a store hands back: the judge and every listing face answered `ok` to a `human` gate holding a `plan_review` pending action, and the resume ran on it. Measured on `bbc88f833` (a legacy row over a real session leaf, real `Runner`): (M1) a `human` gate holding a `plan_review` pending action, a person's bare `policy_ask` allow (no bound call: the lane keys on the gate, the call binding on the pending action, and an absent bound call equals the absent one) ⇒ resumed, the row `resolved`, the parked tool not run — a person's approval consumed and nothing done; (M2) a `plan_review` gate holding a tool approval, a plan approval ⇒ resumed, `resolved`, the parked tool call dropped; (M3) a `human` gate holding a `resource_limit` pending action ⇒ refused only because that row has no origin word (`checkpoint.unsupported_version`), by accident; (M4) a `task_done` gate holding a tool approval, a wake ⇒ refused `wake.gate_pending` by the wake screen's own belt ("inconsistent row") — the one place that called the pair a row fact.
547
+ - **Now.** One more clause in the pending action's entry of the table, read after the gate's entry and after "a registered pending kind": the kind is the one the gate kind's registry row names ("its pending action is not the one its gate kind pairs with"). For all 24 pairs of the registry's six gate kinds × five pending kinds that the registry does not declare, the judge, `summarizeCheckpoint`, `listByScope`, `listOverdue` and `listBySession` answer `damaged` / `unreadable` in those words, and the resume (a decide or a wake) is refused before the claim — all four of M1–M4 are `checkpoint.invalid_outcome` / `requirements_damaged`, the row `pending`, nothing run. The six declared pairs are unchanged.
548
+ - **Narrowing — three (open to veto).** (1) A stored row whose pair the registry does not declare is refused at the resume and lists `damaged`; M1 and M2 resumed before, consuming the row. (2) `listBySession` answers `unreadable` where it answered the row. (3) A wake over a `task_done` gate holding a gate-typed pending action is refused `checkpoint.invalid_outcome` / `requirements_damaged` by the row's verdict, where the wake screen refused it `wake.gate_pending` (the row stays pending both ways).
549
+ - **Hard-breaking — one, three sentences (open to veto).** *What changed:* a parked row whose pending action is not the one its gate kind pairs with is no longer resumable on this release, and every face reads it `damaged` / `unreadable`. *Who is affected:* a deployment that writes its own rows with a pair `pauseOf` would refuse, and a store holding rows an engine from before the pause registry wrote (a `needs_review` row on another arm's seat, a `plan_review` row on a `resource_limit` placeholder — `checkpoint-store.ts`'s own account of that history); which release introduced the registry's pairing is inferred, not measured, and no row of this shape is known to exist; a mixed fleet whose 7.63.0 workers still resume such a row. *Compensation:* finish the row on a worker of the release that parked it, or expire it (`CheckpointStore.expire`) and run the task again; a deployment writing rows builds them with `checkpointFrom` / `pauseOf`.
550
+ - **Affected.** A store that holds, or a deployment that writes, a row whose pair the registry does not declare (`pauseOf` and `checkpointFrom` refuse such a pair at the mint, so this engine writes none; the old-engine shapes above are inferred). A person who approved a `human` gate over a `plan_review` pending action on 7.63.0 got a consumed row and no action; the same decide is now refused with the row pending. The six declared pairs, and every wake over a `task_done` park, read and resume as before.
551
+ - **Rules.** One pair read, by the verdict, where the wake screen read it for one gate kind and the resume lanes assumed it (`decide-continuation.ts`'s own "unreachable by the gate-match invariant"). Retired with it: the wake screen's pending-action switch (see the section below). Added: one clause of an existing entry.
552
+ - **Consumers.** @server: a store's listing carries the judge's verdict for these rows; the question is whether any stored row holds a pair the registry does not declare — a census of the stored rows (`gate.kind` × `pendingAction.kind`) answers it. @client-core @cli: `rowVerdict` damaged is rendered as it is; its "why" words gain one cause. @test (black box): a v1 row with a `human` gate and a `plan_review` pending action ⇒ a bare allow is refused `checkpoint.invalid_outcome` / `requirements_damaged`, the row pending; a wake over a `task_done` gate holding a tool approval is refused the same way.
553
+ - **Claude Code 2.1.316.** No anchor: Claude Code keeps no durable park row store or listing.
554
+ - **Pins.** `test/backlog3412-gate-pending-pairing.test.ts` — P0 the written-out pairs are the registry's column · A1–A3 all 24 undeclared pairs on the judge, the projection, `listByScope`, `listOverdue`, `listBySession` · K1 the six declared pairs read · O1–O4 the table's order (gate, pending kind, pair, tool call id; newer before damaged) · P1 the refusal's words · R0 controls (a plan review approved, a `task_done` park woken) · R1 M1–M4 on a real `Runner` (base: M1 and M2 resumed). Re-pinned: `wake-resume` (6) and (9) (the belt is now the verdict's: `checkpoint.invalid_outcome` / `requirements_damaged`, the row pending). Mutations (receipt).
555
+
556
+ ### The wake screen is the gate whitelist alone — the arms the row's verdict made unreachable are retired: the fallback decide for a gate kind the registry does not hold, the runtime `default:` for a pending kind it does not hold, and the pending-action switch's four gate-typed arms (#3413; behavior change: none for any row a store can hand to the screen — a wake over a row the registry does not hold, or whose pair it does not declare, is refused `checkpoint.invalid_outcome` by the verdict, as #3412 and 7.63.0 state; hard-breaking: none; closed sets: none; exports: none) (@test)
557
+
558
+ - **Before.** The wake pre-ladder of the resume's admission rung ran after the row's verdict (`checkpointRowRefusal`) and still carried arms for rows the verdict had already refused: the decide-entry copy fell back to "its own gate outcome" for a gate kind the registry does not hold; the pending-action switch refused `task_done`-gate rows holding a gate-typed pending action with "inconsistent row", and its `default:` refused a pending kind the registry does not hold as "unrecognized pendingAction kind (newer-version row?)". With #3383 the last and the fallback were unreachable; with #3412 reading the pair, the four gate-typed arms are too (the one test that reached them, `wake-resume` (6) / (9), now meets the verdict).
559
+ - **Now.** The screen is `gk !== "task_done"` ⇒ `wake.gate_pending` with the decide that answers the gate, taken from the registry's `resume` column (five gate kinds, four decide copies); the pending action needs no look of its own — a `task_done` gate pairs with a `task_done` pending action, and the verdict refuses every row that does not. The copy table drops its `task_done: undefined` placeholder (a wake is the answer to that gate). Adding a pending kind to the registry no longer needs a classification here: the pair is the registry's.
560
+ - **Rules.** Retired: the decide-entry fallback, the `isGateKind` ternary beside it, the switch with its runtime `default:` and four gate-typed arms, the table's placeholder entry. Added: none.
561
+ - **Affected.** No row a store can hand to this screen sees a different answer; the sentences that left are reachable only through a row the verdict refuses first. A reader who matched the retired sentences ("inconsistent row", "unrecognized pendingAction kind") now meets `checkpoint.invalid_outcome` / `requirements_damaged` for those rows.
562
+ - **Consumers.** @test (black box): a wake over a registered non-park gate is still `wake.gate_pending` naming the decide; over a row the registry does not hold, `checkpoint.invalid_outcome`.
563
+ - **Claude Code 2.1.316.** No anchor: Claude Code keeps no durable park row store or wake verb.
564
+ - **Pins.** `test/backlog3413-wake-screen-judge-first.test.ts` — W1 / W2 a row of a pending / gate kind the registry does not hold is refused by the verdict, the screen not asked · W3 the five registered non-park gates still get `wake.gate_pending` with their decide · W4 the retired wording is gone from the source. Mutations (receipt).
565
+
566
+ ### The background fork lane's terminal notifier takes no `ending` because the only ending it can receive is `killed` — pinned, with the half it cannot reach pinned as well (#3417; behavior change: none; hard-breaking: none; closed sets: none; exports: none) (@test)
567
+
568
+ - **Before.** A review of 7.63.0 read the notifier the fork lane hangs on its row (`attachAgentTerminalNotifier(taskId, () => …)`, `src/agents/subagent.ts`) as one with no caller after #3346: it ignores the landed `ending` and always sends `killed`, while the agent lane's reads `ending.status`, `ending.error` and `ending.parkLane`. The ticket's premise ("no caller") does not hold: the registry calls it for a RUNNING row it reaps — a session release (`reapSessionBackground`) and a stale-row sweep (`reapStaleSessionBackgroundAgents`) — and `killed` is the only ending such a row has. What this lane cannot receive is a `failed` ending or a park lane: the fork lane never parks its row (`parkBackgroundAgent`, with its `completionSink`, is called only from the agent lane), and the registry announces a parked ending only to the lane a park recorded.
569
+ - **Now.** No change to the notifier. Two cells pinned: the notifier is live (both reaps send exactly one `killed` frame on both faces, the instant the reap returns, and the child's later unwind stays silent), and the unreachable half is a tripwire: a fork lane that starts to park or to record a completion lane fails the pin until its notifier reads `ending` as the agent lane's does.
570
+ - **Affected.** Nobody: nothing a consumer can see changes.
571
+ - **Pins.** `test/backlog3417-fork-terminal-notifier.test.ts` — F1 a session release reaps a running fork (one `killed` frame at once, the row's own facts, silent after) · F2 the stale sweep does the same · F3 the fork lane records no park and no completion lane, so a notifier that ignores `ending` is correct there · F4 the control for F3's reading of the source. Mutations (receipt).
572
+
573
+ ### A frame for a session goes to the session's occupant, not to its id — a session deleted and created again under the same id (by another principal or the same one) is another destination, and what the earlier occupant's background work sends after that is discarded and said once, `delegation.delivery_discarded` (#3431, ruled C-R1109; behavior change; behavior narrowing — four, below, open to veto; hard-breaking: none; closed sets: `EngineNoticeCode` +1 (`delegation.delivery_discarded`), additive; new `DiscardedDeliveryPath` (`live` | `box` | `drain`, the notice's `detail.path`); exports: none; members: +1 optional `rootSessionIncarnation` on each of `ToolExecuteContext`, `RunInternals`, `RunWorkflowOptions`, `RunWorkflowToolDeps` (there a getter, `() => string | undefined`); wire: one notice code added) (@server @cli @client-core @test)
574
+
575
+ - **Before.** 7.62.0 completed a parked background agent that a host's decide drive resumed through the mount's own sink (`resolveCompletionSink(ctx.onTaskNotification, opts.background.notify)`, `src/agents/subagent.ts` :3830 at v7.62.0) — the server's relay into its session door, which checks the session's owner again (the server reports its completion inbox purges on delete and checks the owner on drain, `session-faces.ts:309-314` in the server; not read here). 7.63.0 (#3334) sent that completion to the lane the park recorded instead (`ctx.onTaskNotification ?? parkedLane`, :3836-3837 at v7.63.0): the spawning run's lane, which once that run has ended routes by the session id alone, to the id's live lane or its parked store. A session id the server lets its caller choose can be deleted and created again, and the in-process seat could not tell the new row from the old one, so the earlier occupant's background agent's completion, its summary with it, reached the new occupant's conversation: on its live turn boundary, or at its next run's turn-open drain. For the parked-resume completion this is a 7.63.0 regression. The id-only route itself is older: in 7.62.0 the run's lane already parked by id (`routeOrParkNotification(…, ownSession, …)`, `src/core/runner/run-notification-lane.ts` :210 at v7.62.0), and the live lanes, the parked records, the durable box binding and the delegation root anchor's escalation were keyed the same way, so a never-parked background task's late completion or a monitor event took the same road.
576
+ - **Now.** A session address is (session id, occupant). The occupant is the row's `SessionMetadata.incarnation` as the run's acquire read it; the repository mints one per created row, and a row created again under the id gets another. Every seat of the Runner's in-process notification store is held for one address. A live lane is registered under its run's address and offered only frames addressed to it. A parked record, its eviction tombstone and its delivered and durable keys belong to one occupant. The durable box a frame parks into is the one its own occupant's leg bound. The session's current occupant is the one its latest leg in this process acquired (the leg's drain mount admits it). From then on a frame addressed to another occupant of the id is refused before any lane, box or record (the injector answers `refused`), and what the store still keeps for the earlier occupant is discarded at the admission. That covers a dead producer's late completion, the parked-resume completion (the park's recorded lane captured its run's address) and a root-anchor escalation (the tree carries its root's occupant beside the root anchor). Each discarded frame is said once: `delegation.delivery_discarded` (operator; minted by the engine, in one place). Its `detail` is `{ taskId, taskType, sessionId, path, addressed, current }`. `path` is the seat the frame would have reached under the current occupant (`live`, `box` or `drain`); `addressed` / `current` say whether each side carried an occupant (`known` / `unknown`), never the token. The frame's text never rides the notice. A session no leg of which this process admitted (a restart) keeps parking frames under their own address, and the leg that drains it discards what belongs to another occupant. A seat ages out of its bound only while the store keeps no record for its session, so a parked record is always judged against the occupant that parked it, never replaced by whichever frame arrives next. The parked-resume drive still completes into the park's recorded lane, not the mount's relay (C-R1085). The relay still carries only the cross-process shape.
577
+ - **Narrowing (open to veto).** (1) A frame addressed to an earlier occupant is no longer delivered to the session's later occupant. It was delivered to that occupant's model, which is the defect. (2) A revived background agent's tree records no root occupant: a claim-driven revival, the parked-resume drive included, builds its child's root anchor from the durable row, and the row carries none. So a terminal frame such a tree escalates to the delegation root anchor is discarded whenever the root has an occupant on record, said with `addressed: unknown`. It used to reach the root's next run. The copy on the child's own session is kept (KL-3431-a; #3434 records the root occupant on the row). (3) A host that mounts `createRunWorkflowTool` itself and names the root only through `originatingSessionId` (no `rootSessionId` / `rootSessionIncarnation` on its deps, and a ctx that does not name that session) addresses the same unknown root occupant, with the same result (KL-3431-a). (4) A leg whose own occupant read throws (the session's metadata read at prepare) is no admission: it moves no current occupant and is drained nothing, and what the store keeps for the session waits for the next leg that reads its occupant. Its address is nobody's: no live lane is registered for it, and a frame routed to it (its background tasks, its parked lane) is discarded and said. Its children's root-anchor escalations carry an unknown occupant and are discarded and said whenever the session has an occupant on record. They used to be delivered (KL-3431-a).
578
+ - **Rules.** The comparison is the one the delegation owner already reads (`sameOccupant`, `src/core/runner/delegation-owner.ts`: equal tokens, and both absent is one row, the literal reading). Every seat of the store calls it; no seat carries a copy. The address is minted in one place (`sessionAddressOf`). Retired: the session id alone standing for its row on the store's seats. Added: one rule, that a leg which could not read its occupant holds nobody's address: no admission, no drain, no live lane, and what is routed to it is discarded. This is the fail-closed reading of a read fault, so that a fault neither discards what the session's occupant is owed nor delivers it to a leg that cannot say which row it holds.
579
+ - **Claude Code 2.1.316.** Not checked against the corpus. Inferred: a Claude Code process holds one conversation, and a task notification goes to that process's queue, so an id re-created under another owner is not a destination there.
580
+ - **Consumers.** @server: add `delegation.delivery_discarded` to the operator notice whitelist (audience `operator`, minter `engine`; the `detail` shape above), and keep it off the user wire. Its `detail` names the earlier occupant's task id and task type, and the notice throat lifts `detail.sessionId` to the top level, which is the id the new occupant also holds, so a router that sends by session id alone would show those two values to the new occupant's viewers. The session door's owner check does not retire. The engine's store judges only the in-process seat; a completion that crosses processes (another replica, a restart) still reaches your relay and your door, and the engine holds no record of the earlier occupant there. @cli: an operator notice; no user-face text is expected. @client-core: the `EngineNoticeCode` mirror gains one member. @test (black box): delete a session and create it again under the same id as another principal while the earlier occupant's background agent is still running (or parked on an approval and then decided). When it completes, the new occupant's conversation never contains its report, and the operator sink carries one `delegation.delivery_discarded` with `addressed: known, current: known`.
581
+ - **Known limits.** KL-3431-a (a revived tree's root occupant is unknown; a leg whose occupant read threw sends under an unknown occupant). KL-3431-b (a durable box record carried no occupant, so the box drain did not judge it) is closed in this release by #3453 (its section below, ruled C-R1114): a box record names the occupant it is for, and the drain hands it only to that occupant. This section covers the in-process seats and which box a frame parks into; what a box already holds was left as it was when #3431 landed, and #3453 completes it.
582
+ - **Pins.** `test/backlog3431-session-occupant-address.test.ts` — P1 real Runner: deleted and created again by another principal ⇒ the earlier occupant's parked child terminal is discarded at the new occupant's first leg, never in its model, one notice (`drain`); a later frame from the dead producer is refused · P2 the same principal ⇒ still another occupant · P3 control: the same occupant ⇒ delivered at the next leg, no notice · P4 control: the same occupant live ⇒ queued on its boundary · P5 the new occupant live ⇒ refused before any lane, one notice (`live`) · P6 control: the root anchor under the root's own occupant ⇒ delivered · P7 the root's id created again ⇒ discarded at the root address, the child's own session keeps its copy · P8 a tree with no root occupant ⇒ discarded, `addressed: unknown` · P9 a delegated child's ctx carries the spawner's root occupant · P13 the parked-resume drive (#3334), a real host decide on a background child the same caller spawned: the park's recorded lane after the spawner's id was created again ⇒ discarded, the relay untouched · P10 the earlier occupant's task ids never reach the later one through the drop disclosure · P11 a lane of one occupant is never offered another's frame, even with no current occupant on record · P12 one occupant's durable box is never another's park target; a token-less pair is one occupant · P14 a route that asks for no receipt still parks (the root anchor's escalation asks none) · P15 a drain with no admission before it hands out only its own occupant's record · P16 real Runner: a leg whose prepare-time occupant read throws is handed nothing and discards nothing; the next leg gets the session's own frame · P17 a seat that holds a record survives the bound filling up, and a stale arrival is judged against it · P18 an unread address moves no seat and drains nothing · P19 an unread leg is no destination: a token-less occupant's frame never reaches its lane, and a frame routed to it is discarded and said. Re-pinned to the address (string ids → `at(…)`; a root anchor test now opens the root first and passes its occupant): `test/backlog1279-…` (the closed-set count 117 → 118), `backlog1608-…`, `backlog2940-…`, `backlog3025-…`, `backlog7300-fix-2-…`, `backlog744-…`, `backlog969-engine-frame-codec`, `backlog969-main-park-seat`, `backlog988-…`, `defectscan-div-team-storeseams`, `defectscan-mutation-survivors`, `defectscan-notify-budget-surface`, `defectscan-rt-team-b`, `design393-s5-run-seat-lanes`, `injection-ladder-373`, `monitor-pending-notifications`, `prepare-caps-and-workflow`, `prepare-inherited-gate`, `rb375-a2-descendant-terminal-anchor`, `send-message-tool`.
583
+
584
+ ### Compaction is switched by two seats — `autoCompact` for the passes the engine starts by itself, `manualCompact` for the passes a caller asks for — on a task, on a `Runner.compactSession` request and on the deployment's `contextSettings` overlay; the single switch `enabled` is retired and refused by name (#3426; ruled C-R1106; behavior change; behavior narrowing — one, below, open to veto; hard-breaking: one, three sentences below, open to veto; closed sets: one new internal pair, `CompactionSeat` (`autoCompact`, `manualCompact` — the seat argument of `compactionEnabled`; module-private, not on the package root; told in the notes of `docs/CLOSED-SETS.md`, not a registry row) — no word added to or removed from any published set; exports: none; members: `TaskSpec.compaction` +`autoCompact` +`manualCompact` −`enabled`, `ContextWindowOverlay` +`autoCompact` +`manualCompact` −`enabled`, `Runner.compactSession` request `compaction` +`manualCompact` −`enabled`; contract sentence: `compaction.two_seats`) (@server @cli @client-core @sdk)
585
+
586
+ - **Before.** One switch gated every pass. `compaction: { enabled: false }` (and its deployment twin `contextSettings[word].enabled: false`) turned off the threshold pass, the prompt-too-long recovery pass, the end-of-task summary *and* every requested pass together — `stream.compact()` answered `"disabled"`, `Runner.compactSession` answered `"disabled"` (measured on `c559a781f`). A host that wanted "no automatic compaction, but `/compact` still works" — the reference's `autoCompactEnabled: false` / `DISABLE_AUTO_COMPACT` — had no way to say it; a request that wrote `autoCompact: false` was read as nothing at all (the member was not one, and the run compacted as usual).
587
+ - **Now.** Two seats, each a boolean, each on when nothing declares it. Which pass reads which seat is the contract sentence `compaction.two_seats` on `compactionEnabled`, the one function every lane asks with the seat of the pass it is about to run:
588
+ - `autoCompact` — the three lanes the engine starts: the turn-boundary pass at the window threshold (with the trim-pressure pass it forces), the recovery pass (a provider's prompt-too-long rejection, the request guard's compaction arm) and the end-of-task summary; also the within-task line of the system prompt, which says whether a mid-task pass can come. The trim-pressure force (a boundary after the request layer had to drop messages) is read under the same admission as the threshold pass (`withinTaskCompaction`: `autoCompact` and `withinTask`), so a requested pass on a run whose automatic passes are off is never upgraded to it — it keeps `trigger: "manual"` and a `preCompact` block holds.
589
+ - `manualCompact` — the passes a caller asks for: `TaskStream.compact`, an extension's `$.session.compact` (from `turn.complete`) and `Runner.compactSession` (whose request takes `manualCompact` only — `autoCompact` there is an unknown member, `compact.invalid_request`).
590
+ - Per seat, the request authors it, the deployment overlay's twin of the same seat fills an unset one, nothing declared is on. Switching one seat off never switches off the other: with `autoCompact: false` a requested pass runs at the next boundary (or out of run) and lands with `trigger: "manual"`; with `manualCompact: false` a requested pass is answered `"disabled"` with its `compaction_outcome` frame (`trigger: "manual"`) and no model call, and the boundary goes on with its own pass.
591
+ - With `autoCompact: false` no recovery pass runs: a request the provider rejects as too long is neither summarized nor retried, and the run ends on the rejection as its terminal failure — the provider's code and sentence (in the pin, `failed` / `invalid_request` / "prompt is too long: …") — the same terminal `enabled: false` produced (measured on `c559a781f`), never a silent retry.
592
+ - The event vocabulary is unchanged: `"disabled"` is still the outcome word and `compaction.disabled` the trace kind; the frame's `trigger` names the seat (a pass the engine starts is not started under `autoCompact: false`, so a `"disabled"` frame is always a requested pass's).
593
+ - **Retired, refused by name.** `enabled`, with no alias and no translation: a task that carries it — `true` and `false` alike, and beside the new seats too — ends at prepare `config.spec_retired_key` (the resume's pre-claim screen refuses it the same way, the door being shared); a `compactSession` request is refused `compact.invalid_request`; a `Runner` construction or `swapDeps` whose overlay carries it throws, the current settings staying in force. Each sentence names the two seats and what each switches. A seat with a value other than a boolean is refused the same way (`config.invalid_argument` on a task), naming the seat; an explicit `undefined` reads as absent.
594
+ - **Hard-breaking — one, three sentences (open to veto).** *What changed:* the single switch `enabled` is retired on three doors — `TaskSpec.compaction.enabled`, `RunnerDeps.contextSettings[word].enabled` and the `compactSession` request's `compaction.enabled` — and refused by name instead of read, and its meaning is split across two seats, `autoCompact` and `manualCompact`. *Who is affected:* a host that writes `enabled` — its runs fail at prepare, its out-of-run compaction requests are refused, its Runner does not construct — and a TypeScript consumer whose literal or type mirror names it; no `enabled` write was found in the `src` of @server (`96a91d82`), @cli (`f973e484`), @client-core (`426331e`) or @sdk (`d5aed66`) — grep of the local checkouts, not compiled against this tree. *Compensation:* drop `enabled: true` (the default); write `autoCompact: false` for "no automatic compaction"; where `enabled: false` also meant "and refuse `/compact`", write `manualCompact: false` beside it.
595
+ - **Narrowing / widening.** Widening — one (open to veto): `autoCompact: false` with `manualCompact` unset now lets a requested pass run where `enabled: false` refused it; a host gets that only by writing the new seat. Narrowing — one (open to veto): under `withinTask: false` a requested pass at a boundary where trim pressure was armed and the trim-force backoff not engaged ran as the trim-pressure force — `trigger: "forced"` on its `preCompact` call and frames, a `preCompact` block ignored, the pass went on to its summary (unless it found nothing to cut or failed); it now runs as the requested pass it is — `trigger: "manual"`, a block holds (the pass answers `"blocked"`, no summary) — because the force is the automatic lane's and `withinTask: false` turns those passes off (read on base `c559a781f` `run-turn-boundary.ts`: `trimPressure` was the armed bit and the backoff only; not run there).
596
+ - **Consumers.** @server (S-3131 / S-1073): the prompt-too-long recovery arm hangs on `autoCompact` — "only auto off" switches recovery off too, and an overflowing request ends the run with the provider's rejection as its terminal failure, loudly, as `enabled: false` did; a settings surface that offers "auto-compact off" maps to `autoCompact: false`, and one that offers "compaction off" to both seats `false`. @cli: the shell's `autoCompactEnabled` setting (taken out because the engine had no seat for it) now has one, `autoCompact`; `DISABLE_COMPACT` maps to both seats `false`, `DISABLE_AUTO_COMPACT` to `autoCompact: false`. @client-core @sdk: type mirrors of `TaskSpec.compaction` / `ContextWindowOverlay` drop `enabled` and gain the two members; a renderer of `compaction_outcome: "disabled"` reads it as "requested pass refused by the manual seat".
597
+ - **Rules.** Retired: the one-switch reading and its two copies (the request's `enabled`, the overlay's `enabled`). The same `compactionEnabled` reads both seats (one function, a seat argument), and one judgment (`compactionSeatsDefect`) refuses the retired name and a non-boolean seat on all three doors, each door minting its own code. The boundary's in-pass `"disabled"` arms are gone: the boundary answers a parked request `"disabled"` before its pass when the manual seat is off, so a pass it runs is never a disabled one. The engine's per-pass `CompactionSettings.enabled` stays: it is the gate of one pass, which each lane now fills from the seat of that pass — not a third switch a host writes.
598
+ - **Claude Code 2.1.316.** `cli316.js:268490` (`vp()` gates the automatic passes on `autoCompactEnabled` and the two environment variables), `:271413` (`R7n`, the reactive prompt-too-long compaction, is gated on `vp()` — the recovery lane is the auto seat's), `:272006` (`spr`, the threshold check, returns false unless `vp()`), `:269593` (`/compact` is enabled iff `DISABLE_COMPACT` is unset, and `$.session.compact` is refused with "compaction is switched off in this session (DISABLE_COMPACT), for /compact and plugins alike" — the manual passes are not gated on `autoCompactEnabled`), `:261651` (the worker's `autocompact_state` says the same: "DISABLE_COMPACT also disables manual /compact"). Divergence D-3426-a: the reference switches its manual `/compact` off only together with its automatic passes, by one environment variable; here the manual seat is its own, on a task and on the deployment, independent of the automatic one.
599
+ - **Pins.** `test/backlog3426-compaction-two-seats.test.ts` — real Runner, scripted brain: T1–T2 the threshold pass under each seat · T3 prompt-too-long recovery under each seat, the rejection ending the run loudly under `autoCompact: false` · T4 the end-of-task summary under each seat · T5–T7 `stream.compact()` under each seat, a disabled request beside a landing threshold pass · T8 `compactSession` · T9 `$.session.compact` from `turn.complete` · T10 both off · T11–T13 the deployment default and the request's override, per seat · T14–T17 the retired name and a non-boolean seat on the task, `compactSession` and overlay doors · T18 a requested pass at a trim-pressure boundary under a blocking `preCompact` hook: `autoCompact: false` and `withinTask: false` keep it `"manual"` and blocked, the default seats run it `"forced"`. Mutations: `.gate-logs/criteria-3426-mutations.md` (receipt). Every test that wrote `enabled` is re-pinned to the seat it meant (receipt lists them).
600
+
601
+ ### `DeploymentSessionMemoryStatus` answers the session's write home at the top level — `writeHome?`, the `writeHome` of the one store whose row names the newest home, chosen and never merged (#3427; ruled C-R1107; wire +1 additive; behavior change: none; hard-breaking: none; closed sets: none; exports: +1 method `MemoryEngine.sessionMemoryStatusRead` (on the engine class) and one type-level reading `SessionWriteHomeReading` (module-level, not on the package root)) (@server @cli @client-core @test)
602
+
603
+ - **Before.** `writeHome` is a fact of one store (the directory of the session's write home IN that store), so a deployment of two stores (project plane, personal plane) answered it per store only, in `planes[].status.writeHome`, and the top level carried the five folded keys. A host that wanted "where does this session write" chose a store itself — a second reading of which store holds the session's write, outside the engine.
604
+ - **Now.** The top level carries `writeHome?: string` beside the folded keys: the `writeHome` of one `planes[]` row, handed back unchanged. Which row: the law one store applies to its own two sources (the account row's (re-)open and the newest committed contribution, the newer wins), taken across the stores — the row naming the newest home. Absent when no store names one (a session that never opened an account and never committed); absent while any store's reading could not be taken (a `fault` row because the store could not be opened, a source of it faulted, or its scope registry cannot derive a home — that store may hold the newer write, and another store's word would be a stand-in); absent when two stores name theirs at the same instant (there is no newer one; one store's own tie goes to its account row). A deployment of one store answers its row's key. `planes[]` is byte-for-byte what it was. To read the instant of the winning source without a second pass, the engine gains `sessionMemoryStatusRead(sessionId)` — the status (exactly what `sessionMemoryStatus` answers, which now calls it) beside one reading, `named` (the home and its instant) / `none` / `unreadable`; the choice is the one function `chooseSessionWriteHome` and its ranking is the function the store's own two sources are ranked by.
605
+ - **Known limit (KL-1222-b, across stores).** A store holds no account row for the session and its newest contribution's note cannot be read — deleted, or a read that failed (the file backend skips an unreadable note and cannot tell the two apart) — reads `none`, so the key names the other store's older home where a store alone would have answered absent; the fix is #1261 (the scope recorded on the contribution row), as for the single-store reading. Pinned (D9).
606
+ - **Rules.** One choice where the host made its own: the deployment's answer is the store's own value, picked by the store's own law. Added: one function (the choice), one engine face (the read), one contract sentence (`memory.deployment_status.write_home`); the store-bound key's note now reads "never merged across stores; the session-level key is one store's own value". Retired: none.
607
+ - **Affected.** Nothing a consumer read changes: no existing key moves, and the new key is optional (absent = nothing to say, not a version signal). A host that chose a store from `planes[]` itself may read the key instead.
608
+ - **Consumers.** @server: `GET /v1/sessions/:id/memory-status` projects the key as it does the folded ones and chooses nothing (zero new code; the three pins that read `planes[].writeHome` may read the top level). @cli: L-855 reads the top-level key. @client-core: nothing new. @test (black box): a session that wrote under a project scope and then a personal scope answers the newer one; faulting one store's lineage makes the key absent while the other row still answers its own home.
609
+ - **Claude Code 2.1.316.** No anchor: Claude Code keeps no two-store memory deployment or per-session memory status.
610
+ - **Pins.** `test/backlog3427-deployment-write-home.test.ts` — U1 the choice over readings (none / one / several / tie / unreadable) · U2 one store's tie goes to its account, two stores' tie names nobody · E1 / E2 the engine's read face, one pass · D1–D8 the deployment over real stores (one store, the newer of two, a tie, a faulted store either side, an unopenable personal store, a session that wrote nowhere, the key is the row's value, a one-store deployment unchanged). Mutations (receipt).
611
+
612
+ ### The member-shape table reads an empty checkpoint id as damaged — `checkpointId` is absent or a non-empty string, where `""` passed as a string and each reader took it its own way (#3429; behavior change; behavior narrowing — one, open to veto; hard-breaking: none; closed sets: none; exports: none; wire: no key added) (@server @client-core @cli @test)
613
+
614
+ - **Before.** `ROW_MEMBER_SHAPES` (#3411) read `checkpointId` as absent or a string, so a row carrying `checkpointId: ""` was `ok` on the judge and every listing face, and the member's readers each did something different with the empty string: the summary echoed `checkpointId: ""`, the disclosure sentences named the row `checkpoint ""`, and the background-agent card read (a raw row, never judged) dropped it as absent. Measured on `c559a781f`: the judge answered `ok`, the summary carried `checkpointId: ""`.
615
+ - **Now.** The entry reads absent or a non-empty string ("its checkpoint id is not a non-empty string"): for a row with `checkpointId: ""` the judge, `summarizeCheckpoint`, `listByScope`, `listOverdue` and `listBySession` answer `damaged` / `unreadable` in those words and the resume refuses it before the claim (`checkpoint.invalid_outcome` / `requirements_damaged`). The one predicate is the table's; no reader gets a guard of its own, and the background-agent card read's own existing guard (a raw row that never passes the judge) is unchanged. The empty string is the only value the entry names; a one-character id reads.
616
+ - **Narrowing — one (open to veto).** A stored row whose `checkpointId` is `""` is refused at the resume and lists `damaged`; it resumed before. No release of this engine writes one (`mintCheckpointId()` is `cp_<uuid>`; a legacy row has no id, which is absent) and the server's trust boundary already reads an empty id as no id.
617
+ - **Affected.** A store holding, or a deployment writing, a row with an empty-string `checkpointId` (none known in-tree or in the server; only a hand-edited or damaged row). A row with a minted id or none reads and resumes exactly as before.
618
+ - **Rules.** Added: none — the entry's predicate is stricter by one value. Retired: none.
619
+ - **Consumers.** @server: a store that rehydrates an absent id as `""` must hand it back absent (read, not run — no in-tree store does). @client-core @cli: nothing new to render — such a row is a `damaged` row. @test (black box): a row with `checkpointId: ""` lists `damaged`.
620
+ - **Claude Code 2.1.316.** No anchor: Claude Code keeps no durable park row store or listing.
621
+ - **Pins.** `test/backlog3429-checkpoint-id-non-empty.test.ts` — Z1 the judge, the summary and every listing face over an empty id, in the table's words · Z2 absent, a minted id and a one-character id still read · Z3 the summary echoes no empty id · Z4 no writer mints one · Z5 the File store hands the same verdict · Z6 control: the card read's own answer; `test/backlog3411-row-shape-ledger-id.test.ts` — the empty id joins the damaged forms (A1–A5, P1) and K3 no longer reads it. Mutations (receipt).
622
+
623
+ ### A failure of the approval-record store inside a redemption is a refusal — `redeemRuleTicket` and `redeemRuleBatch` answer a throwing `get` as `store_read` / `no` and a throwing `cas` or `nextDot` as `store_write` / `unknown`, where they let the rejection out (#3428; behavior change; behavior narrowing — one, open to veto; hard-breaking: none; closed sets: none (two definitions widened by a clause); exports: none; wire: no key added) (@server @cli @test)
624
+
625
+ - **Before.** The redemption leg answered a permission-rule store that could not be resolved as `store_unavailable` and one whose read failed as `store_read`, but a failure of the approval-record store it reads and compare-and-sets the record in (`get`, `cas`) and of the writer's `nextDot()` escaped as a bare rejection from `redeemRuleTicket` and `redeemRuleBatch` (cx-small-b X5). A rejection midway through a batch walk lost the member table the walk promises complete, and the members already landed had no row.
626
+ - **Now.** One reading, the closed-set table's own, one mint (`refusal()`), no new word: a `get` that throws is `store_read` / `no` (a read that failed before anything was written); the `cas` that records the redemption's dot, and the writer's `nextDot`, that throw are `store_write` / `unknown` (a backend can commit and lose its acknowledgement — reconcile with `list()`, or retry the ticket: a replay reuses a recorded dot). The batch's first record read answers the refused arm (no table, as for its other record-level refusals); a member's failure answers that member's row and the walk goes on, so the table stays complete. The sentence names the step and carries the store's own message. The `store_read` / `store_write` definitions beside `RULE_REFUSAL_CODES` say they cover the approval-record store's failures as well.
627
+ - **Narrowing — one (open to veto).** `redeemRuleTicket` and `redeemRuleBatch` resolve with a refused result where they rejected, for a failure of the approval-record store or of the writer's dot allocation. A host that caught the rejection reads the result now.
628
+ - **Rules.** Retired: the rejection escape of the redemption leg's store steps. Added: none (one helper, `storeStep`, routes the steps through the one mint). The confirm, prepare and card-edit entries keep their rejection on that store: their closed sets name no storage word, so naming one is a ruling (#3430).
629
+ - **Affected.** @server: the single-ticket path (`redeemRuleTicket`) of a rules-consent door whose approval-record store fails answers `redeem-refused` with `store_read` (or `store_write`) where it answered its route's error arm (a 5xx) — a behavior narrowing, open to veto; the batch path (`redeemRuleBatch`) is unchanged for the server: a top-level refusal and a rejection are both put back for a retry there, and no code is read.
630
+ - **Consumers.** @server @cli: map `store_read` / `store_write` as for a permission-rule store failure (retry / reconcile by `committed`). @test (black box): an approval-record store whose read throws ⇒ the redemption is refused `store_read` / `no`, nothing landed, a retry redeems.
631
+ - **Claude Code 2.1.316.** No anchor: Claude Code keeps no persisted permission-rule redemption protocol.
632
+ - **Pins.** `test/backlog3428-approvals-store-failure.test.ts` — R1–R4 the single-ticket door over a throwing read, a throwing compare-and-set, a lost compare-and-set then a throwing re-read, a throwing dot allocation · R5–R7 the batch over a first read, a member's read and a member's compare-and-set (the table complete) · R8 `unknown` only with `store_write` · R9 controls · R10 the two definitions. Mutations (receipt).
633
+
634
+ ### Retired (C-R1075 ②): a stored batch member with no `kind` is no longer read — `readRuleOffers` drops its batch as `malformed`, and the reading's `kindlessForm` mark is gone with it (#2164, retirement line RL-2164-kindless-batch-member; behavior change; behavior narrowing — one, open to veto; hard-breaking: one, type level, three sentences below, open to veto; closed sets: none; exports: none by name; members: `RuleOfferRead` −`kindlessForm`) (@server @test)
635
+
636
+ - **Before.** `readRuleOffers` kept a second reading for one stored form: a batch member with no `kind` and the four text members of a command member (rows written before batch members carried a `kind`) read as a `command` member, and the offer's reading was marked `kindlessForm: true` so a backend holding parked rows could count how many still depended on it. The retirement line waited on that count.
637
+ - **Now.** One reading. A batch member's `kind` is a closed-set word read like the offer's own: absent, `undefined`, or not a string is `malformed`, so the whole batch is dropped with its index (never shortened), siblings stand, and the drop is in `dropped` like any other. The mark has nothing left to mark and is removed from `RuleOfferRead`. The consumer census the line waited on is in ([12603], [12800]): the server mints neither form any more (its own writes carry `kind`; the parked-row blob is the engine's, which carries `kind`), its SQL stores have counted kind-less rows at every start since server 7.141.0 (`approval_batch_kindless_rows`; the local store has no such count), and dgx has no reader.
638
+ - **Narrowing / widening.** Narrowing — one (open to veto): a stored offer list holding a kind-less batch member no longer offers that batch; a card built from it shows the other offers, and the backend's dropped count (`problem: "malformed"`) is what discloses it. The ask itself, and every other offer of the list, is unchanged. A kind-less member whose `match` was outside the closed set was `unknown_word` and is now `malformed` (its other members are not read).
639
+ - **Hard-breaking — one, type level, three sentences (open to veto).** *What changed:* `RuleOfferRead` loses its optional `kindlessForm` member, and no reading carries it. *Who is affected:* @server — `countKindlessBatchOffers` reads `o.kindlessForm` (`src/approval-card.ts:210`) for the startup census `runApprovalBatchKindlessCensus` (`src/approval-batch-census.ts`, S-2684), so it no longer compiles against this release (read in its local checkout at origin/main `96a91d82`, not compiled against this tree); no other repository reads the member (grep of the cli / client-core / sdk / web-client / desktop origin/main and the dgx checkouts, zero matches). *Compensation:* retire the census with the line it measured — a kind-less member is now counted where every unreadable offer already is, the `dropped` list with `problem: "malformed"` (`server.rule-offers.offer-dropped`).
640
+ - **Consumers.** Affected: @server (above). @test — black box: a parked row whose `pendingAction.ruleOffers` holds a batch with a kind-less member reads back with that batch in `dropped` as `malformed` and no `kindlessForm` anywhere. Not affected: @cli @client-core (they read the wire card with their own readers, which never accepted a kind-less member).
641
+ - **Rules.** Retired: the kind-less member reading (`readKindlessBatchMember`), the mark that counted it, and the retirement row. Added: none.
642
+ - **Claude Code 2.1.316.** No anchor (inferred): Claude Code persists no rule-offer list; nothing to register.
643
+ - **Pins.** `test/backlog2164-kindless-member-retired.test.ts` — K1 the kind-less form at the head, middle and tail of a batch and alone drops its batch as `malformed`, siblings keep their indices · K2 `kind` present but `undefined` / `null` / a number / an object / a list reads the same way; a string outside the set stays `unknown_word` · K3 control: the same four members with `kind: "command"` read · K4 no reading carries a key beyond `index`, `offer`, `uncoveredDetailDropped` · K5 no src reader or mark, no retirement row, the integration guide row says `malformed`. `test/backlog1468-p1-checkpoint-facts.test.ts` R5 re-pinned to the retired form (`p1-offers-kindless-mark` → `p1-offers-kindless-retired`). Mutations: `.gate-logs/criteria-rl-7640-mutations.md` (receipt).
644
+
645
+ ### Retired (C-R1075 ②): the pre-binding committed-rev ledger form — a file memory store reads only the enveloped `revs.json`; a bare id → rev map, and a transaction journal whose ledger snapshot is one, are refused with `ControlPlaneCorruptError`, and `readMemoryLedgerForm` answers three words (#1654, retirement line RL-1654-ledger-v1; behavior change; behavior narrowing — three, open to veto; hard-breaking: two, three sentences each below, open to veto; closed sets: `readMemoryLedgerForm`'s answer −`"v1"`; exports: none by name) (@server @dgx @test)
646
+
647
+ - **Before.** The file backend kept a second reading of its own ledger file: a `revs.json` that was the bare id → rev map (the form before rows carried a scope and slug, upgraded since 5.33.0) was served in a compatibility window and upgraded in place at the next uncontended entry — a census rebind under the txn lock, a one-off `revs.v1.json.bak` beside it, and one `migration` summary row in `transfers.jsonl`; a journal carrying the v1 snapshot (`ledger`) was restored and announced as an old writer. `readMemoryLedgerForm` answered four words, `"v1"` for the bare map.
648
+ - **Now.** One reading. The ledger is the `{ v: 2, rows }` envelope or it is refused: a bare map (any JSON object with no `v`, the empty object included) and a journal whose snapshot is the `ledger` key are refused with `ControlPlaneCorruptError` at every seat that reads the ledger as the store's account, the message naming the form and the way out ("open the store once with an engine at or below 7.63.0, whose locked migration upgrades it to the v2 envelope"); nothing is upgraded, backed up or written. Two seats read the ledger otherwise and keep their own posture. The lock-free retrieval view (`retrievalView`: `listHeaders`, `getByIds`, `search`) serves the entry files on disk and reads no account; only its resurrection guard reads the ledger, when delete evidence exists, and it takes the refusal as it takes every unreadable ledger: ids carrying delete evidence are withheld, the other entries serve, and the host is told once (the operator notice quotes the refusal). A journal that an engine ≤ 7.63.0 committed for its own upgrade (its snapshot the v2 `ledger2`) over a still-bare `revs.json` is a committed transaction: recovery rolls it forward like any other, installing the v2 snapshot and appending its evidence, and the bare map is replaced without being read. The unbound rows such a migration left still converge from the census, each with its `migration-bind` row (design/186 §3.4); the `migration` summary row is no longer minted (an engine ≤ 7.63.0 appended it, and the evidence reader still reads it). `readMemoryLedgerForm` answers `"absent"`, `"v2"` or `"malformed"`, the bare map `"malformed"` — the answer the contract paragraph already promised for the day the form retired. The census the line waited on is in ([12603], [12800]): the server mints neither form and never writes `revs.json` itself, and dgx has no reader (sema-home runs with the memory engine off).
649
+ - **Narrowing — three (open to veto; @server @dgx).** (1) A file store whose `revs.json` is still the bare map — one no engine since 5.33.0 has opened — is no longer served or upgraded: every read and write seat that reads the account refuses it with `ControlPlaneCorruptError` where the reads served it and the first uncontended entry upgraded it (the lock-free retrieval view above excepted). A journal with a v1 snapshot is kept and refused instead of replayed with a warning. (2) Over such a store the governance slice `governanceExport` throws `ControlPlaneCorruptError` where it answered `{ complete: false }` with the reason "the committed-rev ledger is still schema v1 (migrate first)": a caller that branched on `complete` meets a throw. (3) The custody read `custodyOf` throws `ControlPlaneCorruptError` for an id no evidence row names — that branch reads the ledger for its evidence-loss check — where it answered the empty chain without judging a v1 ledger; for an id the evidence log names it reads no ledger and answers from the log, as before, whatever the ledger's form. The faces that already refused such a store refuse it with the one class now: the export composite `exportSnapshotOf` throws `ControlPlaneCorruptError` where it threw the coded `memory.export_incomplete` refusal, and the two audit reads `committedSnapshotOf` / `committedSnapshotsOfScopes` throw it where they threw a plain `Error` ("still schema v1 … migrate first").
650
+ - **Hard-breaking — two, three sentences each (open to veto).** (1) *What changed:* a file memory store holding the pre-binding ledger (or a crashed pre-v2 writer's journal) does not open on this release. *Who is affected:* a deployment whose file store no engine since 5.33.0 has opened — the server's file memory engine on a local data root, a dgx home deployment that runs a file memory store, a cli user's store left untouched since before 5.33.0. *Compensation:* open the store once with an engine at or below 7.63.0 (its locked migration upgrades it to the envelope) and then move to this release; `readMemoryLedgerForm(controlDir)` answers `"malformed"` for such a store, so a census can find it first (`docs/INTEGRATION-CORE.md`, "Upgrading a file store that still holds the pre-binding ledger"). (2) *What changed:* `readMemoryLedgerForm`'s answer type narrows from four words to three (`"v1"` removed). *Who is affected:* a caller that switches over the answer (zero callers found in the server / cli / client-core / sdk / dgx checkouts). *Compensation:* drop the `"v1"` arm; a bare map is `"malformed"`.
651
+ - **Consumers.** @server — the file memory engine opens a pre-5.33.0 store only after the upgrade step above (the server's SQL stores do not hold this file); over such a store the bundle export route, which maps `memory.export_incomplete` to 409 (`src/http/routes/memory-bundle.ts`, `sentCoreCode`), now receives an uncoded `ControlPlaneCorruptError` and answers it as an unclassified error (read at origin/main `96a91d82`, not run). @dgx — none today (memory engine off); a future file store is created in the envelope. @test — black box: a `revs.json` written as the bare map ⇒ the store's reads reject with `ControlPlaneCorruptError` naming "pre-binding v1 form" and 7.63.0, the file byte-identical, no `revs.v1.json.bak`; `readMemoryLedgerForm` ⇒ `"malformed"`. Not affected: @cli @client-core (no reader of the file or the function).
652
+ - **Rules.** Retired: the v1 parse arm (the second reading of `revs.json`), the v1 journal restore arm, the v1 writer and its one-off backup, the compatibility-window announcement, the old-writer journal notice, the v1 branches of the export composite, the governance slice, the custody read and the audit faces' ledger read, and the retirement row. Kept: the unbound-row convergence (its own rows, one reading). Added: none.
653
+ - **Claude Code 2.1.316.** No anchor (inferred): Claude Code's memory files carry no committed-rev ledger.
654
+ - **Pins.** `test/backlog1654-ledger-v1-retired.test.ts` — L1 a bare-map ledger refused at five read seats with the form and the way out, bytes kept, no backup, no evidence; the form reader says `"malformed"` · L1b the export composite (not the coded `export_incomplete` refusal), the governance slice (no `complete: false`), the per-scope snapshot and the custody read for an id no evidence row names refuse with the same class and message; the custody read for an id the log names answers from the log · L1c the lock-free retrieval view serves the disk entries over a bare map; with delete evidence its guard withholds the re-added id, the bystander serves, one host notice names the form · L2b an older engine's committed v2 journal over the bare map rolls forward (v2 snapshot installed, its `migration` evidence row appended, the store serves) · L2 a v1 journal refused by recovery, journal and ledger untouched · L3 controls (a v2 envelope reads at the same seats; an unbound v2 row converges with one `migration-bind` row) · L4 no row, no v1 writer or backup name in the tree, the contract paragraph answers three words. Re-pinned to the retired form: `memory-ledger-v2` (§3 → unbound-row convergence; the #251 notice → the refusal), `backlog3310-memory-ledger-form` (F / J / R), `backlog3329-ledger-form-unreadable` (C: the closed outcomes are three words), `memory-txn-lock` (the convergence's swap fence), `design178-v2a-provenance` (the audit faces' refusal; the `__proto__`-keyed journal cell now over the `ledger2` snapshot, the v1 one refused), and three journal fixtures (`memory-engine`, `memory-engine-s20`, `hardening-memory-engine`) moved to the `ledger2` snapshot. Mutations: `.gate-logs/criteria-rl-1654-mutations.md` (receipt).
655
+
656
+ ### A session's box is drained for one occupant — every record names the occupant it is for, the drain hands it only to that occupant, and a record for an earlier occupant of the id is discarded and accounted for, `delegation.delivery_discarded` with `path: "box"` (#3453, with #3454; ruled C-R1114; behavior change; behavior narrowing — two, the first and the fourth hard-breaking items below, open to veto; hard-breaking: four, three sentences each below, open to veto; closed sets: none; exports: none by name; members: `MailboxPeerMeta` +`occupant?` +`fromOccupant?`, `PeerSessionRecord` +`occupant` (required, `string | null`), `PeerChannelSelf` +`occupant` (required, `string | null`), the options of `peerHeldQueueFor` and `peerIdleMachineFor` +`occupant?`, the second parameter of `routePeerDeliveryReceipt`, `routePeerDroppedReceipt` and `routePeerIdleNotice` is the addressee `{ sessionId, occupant }` where it was the session id; contract sentence +1 `mailbox.session_box_outlives_its_occupant`; wire: a box record's `peerMeta` +2 optional keys, a directory row +1 required key, the socket listener's registration row +1 key) (@server @client-core @cli @test)
657
+
658
+ - **Rule.** Every delivery seat of a session holds things by one address, (session id, occupant). Each durable mailbox record states which occupant it is for. The drain hands a record only to the occupant `sameOccupant` judges the same. Any other record is discarded, accounted for, and announced as `delegation.delivery_discarded`.
659
+ - **Before.** In 7.63.0 a durable box record carried no occupant: `MailboxPeerMeta` named its sender (`fromSession`, `fromRoot`, `senderKey`, `fromScope`, `gateReceiptId`, `src/core/mailbox-store.ts` :234 at v7.63.0) and nothing about its recipient, and the drain judged no recipient. #3431, earlier in this release, holds the in-process seats by address and left the box as it was (KL-3431-b). A session deleted and created again under the same id drained, into the later occupant's model and with no notice, whatever the earlier occupant's children (`agentMessage`, parked into the box whether or not `sessionBoxEngineFrames` is set), its engine frames, its peers' letters and receipts and its idle subscriptions had left there. The server's session delete drops the box, which left the window between the delete and the later occupant's first leg; a host that embeds core and has no box-clearing hook leaked the stock outright. The same-tree skip of the parity hold (`fromRoot` equal to the draining session, #969) compared the id alone, so a teammate's words for the earlier occupant also skipped the hold under the later one.
660
+ - **Now.** All seven writers of a session box stamp the recipient's occupant (`peerMeta.occupant`): the park seat's peer words and engine frames, a cross-session `SendMessage` letter and `notify_when_idle` subscription (from the recipient's directory row), the delivery and dropped receipts and the idle notices (from the letter's or the subscription's `fromOccupant`), and the socket listener (from its `PeerChannelSelf`). A writer that wants an answer stamps its own (`peerMeta.fromOccupant`). One validator (`readMailboxPeerMeta`) reads both keys, a non-empty string each, a bad value refused `mailbox.invalid_peer_meta`. The drain judges every claimed snapshot by address before anything else is decided on it (`adoptAddressedOccupant`, beside the final decisions, on the session lane only; `src/agents/peer-session-drain.ts`). A record whose occupant `sameOccupant` judges the leg's own is the leg's. Any other record is discarded only after one `SessionStore.headOf` read per claim confirmed that the leg's session still holds the occupant the leg acquired: it is acked out of the box, told once on `delegation.delivery_discarded` (`detail.path: "box"`, `addressed` / `current` say `known` or `unknown`, never the token; no body), and a peer's letter (a `peer_message` with no `fromRoot`) answers its sender's occupant with a `refused` receipt: "that session was deleted and created again before the message was read" when the record named an occupant, "the message did not say which session of that id it was for" when it named none. A receipt or an idle notice for another occupant is discarded the same way and answered with nothing. A leg that cannot confirm (it is stale — its session's row now holds another occupant —, the row is gone, or the read failed, the last one reported on `onError` as `peer-box-occupant`) leaves the record exactly as it is, for the session's current occupant. The process-level held queue and idle machine are seated by address (`peerHeldQueueFor` / `peerIdleMachineFor` take `occupant`; a seat of another occupant of the id is crashed and replaced), so a letter held for the earlier occupant is taken off at the later occupant's first claim and never released to it, and the earlier occupant's idle subscriber is never told the later occupant's idle. A seat is replaced only where a leg is admitted as the session's occupant (its drain mount, the point #3431 reads the session's current occupant at); a leg still running after its session was deleted and created again never takes the seat back from the leg admitted after it — its `notify_when_idle` is refused (`peer_send.other`, "this session was deleted and created again after this run started …") and the admitted occupant's machine keeps its asks. #3454: the same-tree skip now sees only records the address judged the leg's own (the judgment runs before the per-record loop), so the skip compares two trees of one occupant.
661
+ - **Hard-breaking — four, three sentences each (open to veto).**
662
+ - (1) *What changed:* a record in a session box that is not for the draining occupant is no longer delivered; it is discarded, acked out and accounted for — and that includes every record a writer of 7.63.0 or earlier parked, which names no occupant, whenever the draining session's row holds one (the bundled stores mint one per created row). *Who is affected:* a deployment that mounts the session-box lane (a `crossProcessSafe` mailbox and a grammatical session id; every server `DB_BACKEND` deployment): the first drain after the upgrade drops what the older engine parked and had not delivered — unread cross-session letters, a background child's parked words — with one operator notice each and a `refused` receipt to each letter's sender. *Compensation:* let the old workers drain their boxes before the upgrade (INTEGRATION-CORE §5.5, "A session's box is drained for one occupant"); the notice code is the one #3431 adds in this release, whitelisted once for both (C-R1109).
663
+ - (2) *What changed:* a record written by this release carries two keys an older engine's validator refuses (`carries an unknown key`, `src/core/mailbox-store.ts` :276 at v7.63.0). *Who is affected:* an engine of 7.63.0 or earlier that shares one mailbox with an upgraded one during a rolling upgrade: its claim of a box holding such a record fails (the server reports it as `mailbox_message_column_corrupt`; reported by the server, not run here), and the records stay in the box. *Compensation:* finish the rollout; nothing is lost, the upgraded engines drain the box, and no schema changes (the keys ride the existing `peerMeta` column). @server: one MIGRATION sentence for multi-replica deployments — replicas of mixed releases over one mailbox fail each other's claims of a box until every replica runs this release.
664
+ - (3) *What changed:* the host's side of the address is required — `PeerSessionRecord.occupant` and `PeerChannelSelf.occupant` are `string | null` (the session row's `SessionMetadata.incarnation`, or `null` for a row the store mints no occupant for), and the three root-exported notice routes (`routePeerDeliveryReceipt`, `routePeerDroppedReceipt`, `routePeerIdleNotice`) take their addressee as `{ sessionId, occupant }` (`occupant` the occupant of the record the notice answers, `undefined` when that record named none) where they took the session id. *Who is affected:* a host that writes directory rows (a row without the key is refused `field_invalid: occupant` by the engine's row reader and faults the whole listing), calls `PeerChannel.listen` (a value that is neither a non-empty string nor `null` throws a `TypeError` at `listen`) or routes a notice itself (a string addressee no longer compiles); TypeScript hosts see all three at compile time — the server's directory projects its rows from `listSessions` (`src/peer-directory.ts`, design coordinate, not compiled here), and no call of the three routes was found in the `src` of @server, @cli, @client-core or @sdk (grep of `origin/main`). *Compensation:* project the session row's occupant, the one the session's legs acquire, in the same release that takes this core (a directory that projects another column makes every letter to that session a letter for another occupant, discarded on arrival), and pass a route the record's `fromOccupant` beside its `fromSession`.
665
+ - (4) *What changed:* the session-box lane mounts only over a session store that reads a row by id (`SessionStore.headOf`) beside a `crossProcessSafe` mailbox — one judgment, `sessionBoxMountVerdict`, read by the drain mount, the peer-lane mount and the send face. *Who is affected:* a third-party deployment whose session store has no `headOf`: no session box is drained or appended to, a cross-session send is refused with the verdict's reason, and `config.peer_lane_unmounted` names the missing read where a directory is wired (the bundled stores have the read; the server reports its stores have it). *Compensation:* implement `headOf` (the `SessionStore` contract; `sessionStoreContract` carries its cases).
666
+ - **Rules.** Readings: two → one (the box held "for the session id" while every in-process seat held "for the address"; now every seat and every record hold for the address). Predicates: +0 (`sameOccupant`, `src/core/runner/delegation-owner.ts`, the one the delegation owner and the in-process seats read; absent on both sides is one occupant, absent on one side is another). Mount conditions: +1 (the by-id read). Contract sentence: +1 — deleting a session does not delete its box, and clearing it on delete is a retention obligation only, since what stays behind is never handed to another occupant (`MailboxStore.drop`). No verb added: the engine still ships no "delete the session's box" hook. Retired: the id alone standing for the recipient of a box record, and the same-tree skip's id-only comparison.
667
+ - **Claude Code 2.1.316.** Divergence D-3435-a (a superset, open to veto): the reference has no durable session box that outlives its session (a session id is usable only while no transcript file stands under it and `--session-id` refuses an id in use, a teammate's inbox is read once and deleted, a cross-session message rides a socket) — coordinates from the design, `cli316.js` :269489 / :280671 / :268241 / :268024, not re-read here. Sema keeps the durable box (design/385) and a session id its caller chooses and may reuse, so a record says which occupant it is for.
668
+ - **Consumers.** @server: project `occupant` on every directory row from the session's `session_meta.incarnation` and give a listener its session's occupant; add the MIGRATION sentence of (2); the `delegation.delivery_discarded` whitelist entry #3431 asks for also carries `path: "box"` from this seat; your stores' `headOf` is the read the mount requires. @client-core: the `PeerSessionRecord` / `PeerChannelSelf` / `MailboxPeerMeta` mirrors gain the members above; the token is an addressing fact on rows and frames, never rendered (KL-3453-a). @cli: no user-face text; `ListAgents` renders no occupant. @test (black box): with a cross-session letter unread in session X's box, delete X and create it again under the same id; X's next run never shows the letter, the operator sink carries one `delegation.delivery_discarded` with `path: "box"`, `addressed: known`, `current: known`, and the sender's next run reads a `refused` receipt that says the session was deleted and created again. Control: the same without the delete delivers the letter and announces nothing.
669
+ - **Known limits.** KL-3431-b is closed. KL-3453-a (the occupant token is an addressing fact visible to same-scope peers and on frame provenance, not a secret and not a credential). KL-3453-b (a host that calls `peerHeldQueueFor` / `peerIdleMachineFor` without `occupant` over a token-minting store replaces the live leg's seat). KL-3453-c (the review face reads the held seat by id, so between the delete and the later occupant's first leg it still lists the earlier occupant's cards; a decision on one reaches no one).
670
+ - **Pins.** `test/backlog3453-durable-box-occupant.test.ts` — real Runner over a file mailbox and one shared session store: P1 / P14 a teammate's record for occupant A, the id deleted and created again as B: never injected, the same-tree skip never reached, one notice (`box`, known / known), acked out · P2 the same for an engine frame · P3 a letter for A drained by B: discarded, the sender's occupant gets a `refused` receipt ("deleted and created again"), which its next leg reads · P4 a record that names no occupant under a token-holding drainer: discarded, `addressed: unknown`, the receipt says the message did not say which session it was for · P6 control: the same occupant delivers. Drain level: P5 control, a store that mints no tokens: delivered, no by-id read · P15 a stale leg leaves B's letter as it is, and B reads it · P16 a by-id read that faults or finds no row leaves the record, the fault disclosed at each claim that asked · P7 a letter held under A is taken off at B's first claim, never released to B, acked out · P19 the pull face (a pass that delivers and never settles) judges the address before it hands anything over · P8 the idle machine by address: A's subscriber never told B's idle · P20 a leg whose session was created again never takes the idle seat from the leg admitted after it, its `notify_when_idle` refused, the admitted occupant's own call served · P9 a receipt for A discarded, no receipt answers it · P12 a delivered frame's provenance carries the record's `peerMeta` member for member · P13 the account carries no token and no body · P17 the receiving station's consume (pull face and live lane) answers the sender's occupant · P11 a directory row without `occupant` refused, `null` and a token read · HB-2 the validator refuses a non-string occupant · P18 a session store without `headOf` mounts no box, the send side and the drain side answer one sentence, the default store has the read. `test/design385-s3-cc-uds-channel.test.ts` P10: the listener stamps its occupant, refuses a bad one at `listen`, and a `null` listener's frame under a token-holding drainer is discarded as `unknown`. Re-pinned to the address (seed after the session row exists via `bornOccupant`, multi-leg worlds share one session store, directory rows carry their occupant, seats read with `…IfAny`): `backlog969-session-box-drain`, `backlog969-peer-directory-contract` and `backlog971-session-where` (the directory kit gains a sixth case: a row's occupant is listed as written), `backlog2589-2591-…`, `backlog2616-2617-…`, `backlog2940-mailbox-window` (a run's reads are what it added after the previous run's reply — two processes over one session store share one transcript), `backlog7300-fix-b4-…`, `design385-slice4-held-idle`, `design385-slice7-principal-inbox`. Mutations: `.gate-logs/criteria-3453-mutations.md` (receipt).
671
+
672
+ ### The control-plane carrier seat — a governance store keeps the engine's control objects (five verbs, one law: written once, never overwritten, damage refused rather than read as absence) and two more documents (`holds`, `origin-clearances`); the File store is today's directories and bytes, an origin clearance's custody text leaves the account's row, and a replica's records can be named and copied into a store by an explicit call, which removes nothing from the replica (#3465, #3478, C-R1119 S1 and addenda 2 and 3; behavior change: one — the custody text's place on disk, HB-6; behavior narrowing — one, open to veto; hard-breaking: three, three sentences each below, open to veto — HB-1 type level, HB-6, HB-3 first half zero behavior; closed sets: +1 set `MemoryControlObjectKind` (six kinds), `MemoryGovernanceDocName` +2 (`holds`, `origin-clearances`), governance codes +1 `memory.control_object_unknown`; exports: +3 root values `MEMORY_CONTROL_OBJECT_KINDS`, `adoptReplicaControlPlane`, `replicaControlPlaneStrays`, +3 types `MemoryControlObjectKind`, `ControlPlaneAdoptionReport`, `ReplicaControlPlaneStrays`; members: `MemoryGovernanceStore` +`putObject` +`getObject` +`listObjects` +`moveObject` +`deleteObject` (required), `MemoryEngine` −`controlPlaneDir`; contract sentence +1 `memory.governance.object_written_once`; wire: none) (@server @dgx @client-core @test)
673
+
674
+ - **Rule.** What an engine keeps in its control plane that decides what may enter a prompt, be written or travel with a bundle — the pollution markers, import receipts, the bytes moved aside or captured by a hold, the origin clearances' custody text, the capture opt-outs, the hold ledger and the clearance account — is kept through one seat, the backend's `MemoryGovernanceStore`, under one law: an object is written once under a kind and a name core minted and is never replaced; an object that stands but cannot be read is refused, never read as missing; an enumeration that fails is refused, never answered empty.
675
+ - **Before.** In 7.63.0 the seat kept five documents (`readDoc` / `updateDoc`). The hold ledger was named as an exception (a row and its captured bytes were one record, the bytes control-plane files), and the origin-clearance account, the pollution markers, the import receipts, the quarantine and hold captures and the capture opt-outs had no seat: each was a directory or a file the engine read and wrote in its own control plane, by a law each module spelled for itself. An origin clearance's row carried the full text of the cleared entry inline (`entryText`). The rebuild targets (`lineage`, `challenges`) were named twice, once as two file constants and once as ternaries over the ledger name, beside the document table that already located them. The engine answered its control plane on two accessors, `controlPlaneDir` and `controlPlaneRoot`, with the same value.
676
+ - **Now.** `MemoryGovernanceStore` has five more required members — `putObject(kind, name, bytes, meta?)` (`"created"` | `"existed"`), `getObject` (a copy, or `undefined` only when nothing stands), `listObjects` (sorted), `moveObject(from, to)` (`"moved"` | `"already-moved"`, never over other bytes) and `deleteObject` — over a closed set of six kinds (`MEMORY_CONTROL_OBJECT_KINDS`: `pollution`, `import-receipt`, `quarantine`, `hold`, `clearance-custody`, `capture`); a kind outside it, or a name that is not one opaque segment, is refused `memory.control_object_unknown`. The documents are seven: `holds` and `origin-clearances` join, and the exception sentence is gone. `fileGovernanceStore` keeps each kind in the directory its records have always lived in (`session-pollution/`, `import-receipts/`, `quarantine/`, `hold/`, `session-capture-optout/`, and `origin-clearance-custody/` for the one kind that rode a row), stages a write under `.control-object-stage/` and publishes it with `link` (exclusive, never a half object), and keeps the two documents at `holds.json` / `origin-clearances.json` under the lock-and-journal protocol — the same bytes. The rebuild targets are one table beside the document table (`STRICT_CONTROL_PLANE_LEDGERS`, located by `fileGovernanceDocOf`; the export fence reads the same list, in the same order). `memoryGovernanceStoreContract` carries the object law, the two documents and the adoption cells. The package root carries two operator faces for a replica whose backend comes to carry a store that is not the File store over its control plane: `replicaControlPlaneStrays(controlDir)` names the documents with a file or a journal and the objects by kind, and `adoptReplicaControlPlane(controlDir, store)` copies them one record at a time, objects before documents and no document while any object is refused — written where the store lacks it, converged where it holds the same value, refused by name where it holds another (no merge invented) — and, once the store's copy reads back the same, writes its row in a body-less receipt (`control-plane-adoption.json`, one row per record and digest; a re-run converges and adds no row). `adopted` says the store now holds the replica's value, nothing more: the replica's records stay where they are, because the engine's readers still read them there — removing them would drop a pollution marker or a capture opt-out out of the runtime verdict after a restart (#3478). It is an explicit call over a replica no engine is running on; over the File store of that same directory it answers an empty report. In this release the engine still reads and writes these records in its own control plane: its readers and writers move onto the seat with S2 (#3466), and with them the removal of an adopted record from the replica, the construction refusal over a store that is not the File store over that plane while the plane still holds such records (`memory.control_plane_strays`, HB-5) and the settlement seat losing its directory (HB-3, second half). Nothing constructs, adopts or refuses on its own in this release.
677
+ - **Narrowing — one (open to veto).** A 7.63.0 engine refuses an origin-clearance account a 7.64.0 engine wrote (`ControlPlaneCorruptError`, "row is malformed"): its reader requires the inline text. Replicas sharing one control plane upgrade together; an account no 7.64.0 engine has written to reads on both.
678
+ - **Hard-breaking — three, three sentences each (open to veto).**
679
+ - (HB-1, type level) *What changed:* `MemoryGovernanceStore` gains five required members and `MemoryGovernanceDocName` two names, and the kit's `corrupt` hook (`MemoryGovernanceStoreContractHooks.corrupt`) is also handed `{ object, name }` (make that object stand unreadable) and `{ listing }` (make that kind's enumeration fail). *Who is affected:* an implementation of the store outside core, and its kit run (none in the server's or the cli's or client-core's `src` at origin/main — grep for `readDoc(` / `claimRun` / `MemoryGovernanceStore` implementations; dgx inferred none, it runs with the memory engine off) and a caller that switches over the document names exhaustively. *Compensation:* add the five members (`memoryGovernanceStoreContract` checks them; a SQL store keeps one row per object with an optional scope column) and the two names' storage.
680
+ - (HB-6) *What changed:* an origin clearance's row stores the custody text's sha-256 (`custodyDigest`) and the text stands as its `clearance-custody` object, written before the row; a row written before this release still reads, and the account's next locked write moves its text out (object first, then the row). *Who is affected:* anything that reads `origin-clearances.json` directly rather than through `listOriginClearances`, and a 7.63.0 replica over the same control plane (the narrowing above); `listOriginClearances` answers `entryText` exactly as before, so @server's `memory-origin` route reads what it read. *Compensation:* read through `listOriginClearances`; upgrade replicas that share a control plane together.
681
+ - (HB-3, first half, zero behavior) *What changed:* `MemoryEngine.controlPlaneDir` is removed; `controlPlaneRoot` answers the same value and is the one accessor (the runner's settlement handle and the capture floor's plane coordinate read it). *Who is affected:* a host that read `controlPlaneDir` (none in the server's, the cli's or client-core's `src` at origin/main). *Compensation:* read `controlPlaneRoot`.
682
+ - **Consumers.** @server — HB-1 and HB-6 above; the two operator faces are what the switch to a carried store will call (S2 wires the refusal; your S-3068 package store implements the five members). @dgx — HB-1 if you implement the seat; an object row carries `meta.scope` when the writer knows one (`dgx` §1: no body column in documents — HB-6 moves the last one out). @client-core — no wire change (`OriginClearanceRow` is unchanged). @test — black box: open an origin clearance, then read `origin-clearances.json`: no `entryText` on the row, a `custodyDigest`, and `origin-clearance-custody/<id>.md` holding the cleared entry's text; `listOriginClearances` answers the text. Control: an account written by 7.63.0 reads unchanged until the next clearance call, which moves its text out.
683
+ - **Known limits (rows to be registered with the merge).** KL-3465-a — a pre-7.64.0 row whose account is never written again keeps its text inline and is read by the inline arm (the dual read retires with a census of zero such rows). KL-3465-b — the erasure census does not yet sweep the `clearance-custody` kind (the custody of an erased entry stands until #3463). KL-3465-c — after an adoption a record stands in the replica and in the store; the readers still read the replica's copy, a document the engine rewrites afterwards differs from the store's (a re-run refuses it by name), and S2 (#3466) switches the readers and removes the source.
684
+ - **Rules.** Retired: the hold-ledger exception, the two-constant and ternary naming of the rebuild targets (one table), the hand-listed fence files (derived), the nine literal copies of the hold ledger's label (one table row), the second control-plane accessor. Added: the object law (one, for six kinds; their per-module laws retire as S2 moves each writer onto it), the custody seat's two forms (KL-3465-a), the two operator faces.
685
+ - **Claude Code 2.1.316.** Divergence D-3407-a (a superset, open to veto; to be registered with the merge): the reference's memory has no governance control plane (lineage, challenges, pollution, holds, clearances, quarantine, receipts) and so no seat for one; its one memory control artifact, the consolidation lock, sits in the same key space as the entries, which is the direction this seat takes (the design's reading, `3407-control-plane-carrier-r1` §K6, not re-read against `cli316.js` here).
686
+ - **Pins.** `test/backlog3465-control-plane-carrier.test.ts` — C1 each kind lands in its 7.63.0 directory with the bytes handed in, once, owner-only, no stage file left; a record a 7.63.0 writer put there is the object the seat reads · C2 a directory, a dangling link, a file where the kind's directory is: refused, never missing · C3 a kind or a name outside the sets refused `memory.control_object_unknown`, nothing on disk · C4 a crashed move resumes, equal bytes converge, other bytes refuse and leave both · C5 the two documents at their 7.63.0 files, the seat reads what the hold writer wrote · C6 the rebuild targets located by the document table · C7 the strays (a journal-only document counts; a broken listing refuses) · C8 adoption, objects before documents, a body-less receipt, the replica's records and documents unchanged · C9 adoption refuses another value by name, holds every document back while an object is refused, and converges what an earlier run wrote (one receipt row per record) · C10 adoption into the File store of the same directory, however spelled, is a no-op · C11 construction adopts and refuses nothing (the wiring rides S2) · C12–C14 HB-6: the digest row, the custody object, refusal of a missing / unreadable / different / non-UTF-8 custody, a legacy row read and moved at the next locked write · C15 adoption moves inline custody out first · C16 one accessor · C17 the kit refuses an overwriting store, a store that reads damage as absence, and a store that keeps every kind in one map · C18 a receipt that cannot be written leaves the record refused only; a re-run converges and writes its row once; a committed journal over a stale main file is what is adopted, and both files stay; a document the engine rewrites after the adoption is refused by name on a re-run, the store's copy left as adopted · C19 a journal-only clearance account has its inline text moved out; a custody the store holds with other bytes keeps the account in the replica · C20 (#3478) adopt, then an engine restarted over the same plane with its backend carrying the store: the pollution marker and the capture opt-out still decide (red on the pre-fix module: the marker reads `undefined`). The kit runs over the File store and in-memory stores in `backlog3308-governance-doc-seat`, `backlog900-governance-store` and `backlog3307-announcement-queue-doc`; `backlog3308` P6 / P9 re-pinned (`holds` is a document name; its writer moves with S2). Mutations: `.gate-logs/mutations-1.md` / `-2.md` (receipt).
687
+
688
+ ### A memory write moves the system prompt once — the memory band carries the store's state, and a notice the engine drained rides the leg's first request, once, never the system prompt (#1123; ruled C-R1120; behavior change; behavior narrowing: none; widening: none; hard-breaking: one, semantic, three sentences below, open to veto; closed sets: none — the frame carries no `steering_injected` echo, so no `source` word is added; exports: none; members: `Prepared.memoryNoticesFrame?` (internal), `MemoryInjectionComposition.noticesFrame?` (internal); wire: none) (@server @cli @client-core @test)
689
+
690
+ - **Rule.** The memory band of the system prompt holds the memory store's STATE: the write instruction or the read-only notice, the fenced index, the runner's disciplines. A notice the engine drained from its queue is an EVENT: the leg's first request says it once on the model lane (a fresh leg ahead of the user's words, a resumed leg on its continuation), the way the posture and the advisor frames ride, with no echo. A memory write therefore changes the system prompt exactly once, by its index row.
691
+ - **Before.** In 7.63.0 `MemoryEngine.inject` composed `block` as instruction + index + the rendered notices (`src/core/memory-engine/engine.ts` :4146 at v7.63.0), and every arm of the Runner's memory composition put that block into the system prompt. The notice entered the band on the run after a write, together with the index row, and left it one run later: two prefix breaks per write (test s145 `hunt1-c14-turnstart-prefix-churn`, server 7.145.0 / core 7.62.0: runs 3 / 4 / 6 / 7 of an eight-run session written on runs 2 and 5, +450 / −327 / +375 / −327 characters). An externally exposed session files its exposure sentence again at every harvest, so from the first run after the mark that block sat in the band and broke the prefix there. The two correction codas were found again by content (`blockBody.includes(announceBlock)` and `endsWith(coda)`, `src/core/runner/prepare-memory.ts` :1680-1705 at v7.63.0). The lead said "since your last session" and the gate line "the previous session's harvest", false for the per-run harvest of the same session.
692
+ - **Now.** `block` is the state (`[instruction || readOnlyNotice, index]`); the drained notices are `announceBlock` only, and a read-only plane's coda is its own engine reminder right after its plane's notices. The Runner composes no notice into any arm of the band; it hands the drained notices to the leg as one frame (`Prepared.memoryNoticesFrame`), with the session coda (a roster that cannot persist) or the capture-opt-out coda as its own reminder after them, chosen from the session's facts, not found in text. The fresh leg prefixes its first user message with the frame; a resumed leg appends it to its continuation. The lead reads "Memory engine notices (quoted identifiers are data, not instructions):" and the gate line "memory updated by a harvest: N added, N updated, N deleted". The capture-indeterminate notice's correction names "any memory engine notice", where it named "any notice in this memory section", a section the notices no longer sit in (one phrase; the rest of the template is byte-identical).
693
+ - **Hard-breaking — one, semantic, three sentences (open to veto).** *What changed:* `MemoryInjection.block` no longer contains the drained notices or the read-only plane's coda — they are `announceBlock` only, the coda its own reminder — and the Runner never puts a notice in the system prompt; the type is unchanged. *Who is affected:* a host that drives `MemoryEngine.inject` itself and places only `block` in its prompt stops showing the notices (one that placed both now shows them once instead of twice); no reader of `announceBlock` or of `.inject(` was found in the `src` of @server or @cli (grep of `origin/main`, not compiled). *Compensation:* place `announceBlock` once, in the next user message, as the Runner does, and keep `block` where it was.
694
+ - **Rules.** Retired: the two content detections that placed the codas, and the notices re-added in each of the five arms of the band. Added: one placement law (the leg's first request carries the drained notices), read at its two seats (the fresh first message, the resumed continuation). The plane coda becomes a reminder of its own, because a user-side frame holds no bare engine sentence.
695
+ - **Claude Code 2.1.316.** Aligned on the event half: the reference tells a memory change as a `memory_update` attachment drained once and rendered as a meta user message, never in the system prompt (`cli316.js` :272678 / :272687 / :273465). Two divergences, recorded for registration: D-1123-a — the reference freezes the MEMORY.md index into the session's first user message (:270299, :140577, :266140); Sema keeps the index in the system prompt and re-reads it every run, so a real change still moves the prefix once. D-1123-b (a superset) — the reference announces only other writers' changes; Sema also tells the session its own harvest.
696
+ - **Consumers.** @server @cli: no source change — neither reads `announceBlock` nor calls `inject`; a run's first user message now starts with an engine reminder when the store had notices, on the same lane as the posture frame (a renderer that hides engine reminders hides this one; inferred, not run). @client-core: no mirror of `MemoryInjection` found. @test (black box, the s145 criterion): two memory writes in an eight-run session ⇒ the request-side system prompt changes exactly once per write, by the index row; no notice in any system prompt; the notice in the next run's first user message, once; a control with no write ⇒ zero changes; a later run on the same session (`--resume`) neither restates the notice nor moves the prefix.
697
+ - **Known limits.** A leg whose first message is never sent — a `userPromptSubmit` hook blocks it, the usage window or a pre-call budget refuses it, the walltime is already spent, or an abort lands first — drops the notices its prepare drained, as it did when they rode that leg's system prompt: the queue is drained at prepare, and this frame is not settled on a receipt the way the git-status and listing frames are (`frames.commit_on_receipt`). An externally exposed session's harvest files its exposure sentence again every run, so each later run's first message carries one more copy of it in the transcript (before, the band held one; the cached prefix no longer pays, the history does).
698
+ - **Pins.** `test/backlog1123-memory-notice-prefix.test.ts` — real Runner over a file memory store: P1 eight runs written on runs 2 and 5 move the system prompt on runs 3 and 6 only, by the index row, each notice in that run's first message once · P2 control, no write, zero moves · P3 a later Runner on the same session neither restates nor moves · P4 a roster that cannot persist: the session coda its own reminder after the notices · P8 (carry, off) a session marked externally exposed: zero moves, the exposure sentence in the first post-mark run's first message · P9 a resumed leg (an approval answered) carries the notices its prepare drained on its continuation, once, never in its system prompt, never echoed · P5 / P6 the engine face (the plane coda its own reminder; `block` is instruction + index) · P7 the wording. Re-pinned to the event face (the notices read off `announceBlock` or the first user message; privacy and secret checks read `block` and `announceBlock` together, so no negative check went vacuous): `backlog3307-announcement-queue-doc`, `design383-capture-optout-rescan` (the indeterminate notice's byte pin, with the one phrase swapped back reproducing the old bytes), `memory-dual-root`, `memory-engine-runner`, `memory-engine-s2-announce`, `backlog1896-announcement-scope`, `hardening-memory-engine`. Mutations M1–M7 (receipt).
699
+
700
+ ### A delegated agent's refused call is told to the session a person watches — the gate station's user-face notices on a delegated leg are addressed to the delegation tree's root session and name the leg they came from (`detail.sourceSessionId`, `detail.agentId`), so `delegation.ask_unresolvable` and its three siblings reach the parent's stream where they reached only the child's (#3083; ruled C-R1121 K1 and scope (b); behavior change; hard-breaking: one, three sentences below, open to veto; closed sets: none; exports: none; wire: +2 optional detail keys on four notice codes, and the value of `detail.sessionId` on a delegated leg moves) (@server @cli @client-core @test)
701
+
702
+ - **Before.** The gate station minted its user-face notices with the leg's own session id, and the throat lifts that id onto the notice's typed `sessionId`, the key a deployment routes a notice by. A delegated child's session has no reader, so a child's fail-closed refusal was said to nobody: measured on `bd3b14137` (real `Runner`, five child forms — a roster child, the same with `forwardSubagentEvents`, with `retainSubagentSessions`, the built-in general-purpose child, a background child — under no approver and under an approver that answers `unavailable`), 0 / 10 notices addressed to the parent's session; the parent's model read the refusal only inside its child's transcript (test s145: 0 / 5 forms on the parent's SSE, session read and durable event stream).
703
+ - **Now.** One rule, one helper (`noticeAddressOf`, `src/core/leg-identity.ts`, minted once per leg beside the ask source): a top-level leg's user-face notice is addressed to its own session and carries no source keys — byte-identical to before; a delegated leg's is addressed to the tree's root (`rootSessionId`; an intermediate parent at depth ≥ 2 has no host leg of its own) and carries `sourceSessionId` (the leg whose call it is) and `agentId` (the id the spawner's card and the leg's events carry). The station's four user-face notices take it: `delegation.ask_unresolvable` (whose sentence adds "a delegated agent's call"), `permission.ask_released_by_mode`, `permission.read_deny_unapplied`, `classifier.unavailable` (the gate station's; the ancestor station's in `prepare-policy-chain.ts` and the user-face codes minted outside the gate station keep the leg's own session — census #3469). One notice per refused call, through the one throat; no second route, no new code.
704
+ - **Hard-breaking — one, three sentences (open to veto).** *What changed:* on a delegated leg, `detail.sessionId` (and the typed `sessionId` lifted from it) of these four codes names the delegation tree's root session, no longer the delegated leg's own; the leg's own session moves to `detail.sourceSessionId`. *Who is affected:* a consumer that read `detail.sessionId` of these codes as "the session whose call was refused" on a delegated leg, and a deployment's documentation that says `delegation.ask_unresolvable` on a delegated child does not reach the parent's stream, or that on a delegated child the detail's session is the child's own. *Compensation:* read `detail.sourceSessionId ?? detail.sessionId` for the session the call ran in; route on `sessionId` as before.
705
+ - **Affected.** Every notice of a top-level leg is unchanged. A background child refused after its parent's leg ended is addressed to a root with no live leg; what a deployment does with a notice for a session it holds no leg for is the deployment's (KL-3083-a).
706
+ - **Rules.** Readings: two → one (the station addressed user-face notices by the leg's session while the ask source already named the leg; now every station notice reads one address). Added: one helper, two optional detail keys. Retired: the bare session id at the four mint sites.
707
+ - **Consumers.** @server: the router needs no change (it routes on `sessionId`), but what it routes on has moved on a delegated leg: `detail.sessionId` of these four codes is now the delegation tree's root, so a router that sends notices by session alone delivers a child's refusal to the root session's viewers, and the child's own session is `detail.sourceSessionId` (its agent id `detail.agentId`) for any route that wants the child. The address names the root's session id and no occupant, so a router that holds per-viewer state across a session's delete and re-create judges the occupant itself. The session-detail sentence for a delegated child in the engine-notice wire and the usage guide's sentence that `delegation.ask_unresolvable` on a delegated child does not reach the parent's stream are stale. @client-core: two optional keys on these four codes' detail. @cli: render "a delegated agent's call was refused" from `sourceSessionId` / `agentId`. @test (black box): a roster child under no approver calling a gated tool ⇒ one `delegation.ask_unresolvable` on the parent's stream, `detail.sourceSessionId` = the child card's `sessionId`, `detail.agentId` = its `taskId`, non-empty `remedies`.
708
+ - **Claude Code 2.1.316.** Same shape: a subagent's permission denial is one `system/permission_denied` message on the top-level session (`session_id`) naming the subagent (`agent_id`) (`cli316.js:288215`, and the engine's own at `:278324`). Divergence D-3083-a (a superset): this notice also carries the ways out (`remedy` / `remedies`) where the reference carries the message and the decision reason.
709
+ - **Known limits.** KL-3083-a (a background child refused after its parent's leg ended: the notice is addressed to the root, which a deployment may hold no live leg for).
710
+ - **Pins.** `test/backlog3083-3084-delegation-refusal.test.ts` — five child forms × two no-approval-seat deployments, each over four faces (the routing key, the detail's session, delivery inside the parent run's window, the source attribution) and the parent's Agent result carrying no second copy of the remedies · the card's `sessionId` / `taskId` equal the notice's source keys · depth 2 addressed to the root · positive control: a top-level refusal's detail keys unchanged · the mode-release notice on a delegated child · the classifier notice's address · the station's four sites spread the address. Base: 15 of these 16 cells red (the positive control is the green one). Mutations M1–M9 (receipt). Re-pinned: `test/backlog642-workflow-park-lane.test.ts` ① (the #642 six-grid) — the three no-park lanes (sync, background, workflow) asserted the notice named the child's session at the top level; they now assert the parent's session there and the child's in `detail.sourceSessionId`, beside `detail.agentId`.
711
+
712
+ ### A failed delegation's tool result is an error on every face — the synchronous card and the fork card read `isError` from the same predicate the background polls already answered with, `agentOutcomeIsError` (#3084; ruled C-R1121 K2 and addendum 1; behavior change; behavior narrowing — one, open to veto; hard-breaking: none; closed sets: none; exports: none; wire: `isError: true` on a failed `Agent` tool result) (@server @cli)
713
+
714
+ - **Before.** A synchronous or fork delegation whose child failed returned its card with `status: failed` and no `isError`, while the background lane's poll, live and durable, answered `isError: true` for a failed row: measured on `bd3b14137`, a roster child that cannot start (`denyTools: ["*"]`, `config.tool_face_control`) and a child whose model request was refused (`invalid_request`) both reached the parent as `isError: false` (test s145 e1 / e3).
715
+ - **Now.** One predicate, `agentOutcomeIsError` (`src/core/task-registry-agent.ts`): a failed outcome is an error result. The synchronous card and the fork card read it over the card's own status word; the live poll and the durable poll read it over the row's. A completed child is not an error; nor is a synchronous child that ended `blocked` (a cut-off with its partial output — C-R1121 addendum 1, the reference's partial-history shape); the refusals that never start a child (a refused call, a held park, an unavailable isolation) keep their own constructors and are unchanged.
716
+ - **Narrowing — one (open to veto).** A failed synchronous or fork delegation now reaches `PostToolUseFailure` instead of `PostToolUse`, and the parent's model sees the result as an error.
717
+ - **Affected.** A hook keyed on `PostToolUse` for the `Agent` tool no longer sees a failed delegation there; a host that read `isError: false` beside `status: failed` as "the call itself succeeded". A background child's row that ended `blocked` still settles `failed` and polls `isError: true` (KL-3084-a: the row's word set has no `blocked`; root fix #3470).
718
+ - **Rules.** Readings: two → one (the polls' inline `failed ⇒ isError` and the cards' none). Added: one predicate. Retired: two inline reads.
719
+ - **Consumers.** @server: the usage guide's account that a synchronous delegation's failure reads `isError: false` is stale; `tool_end.isError` is `true` for it. @cli: a `-p` script reading `is_error` on a failed delegation now reads `true`.
720
+ - **Claude Code 2.1.316.** Same shape for a child that failed with nothing to hand back (`cli316.js:276866`: the error is thrown, the tool result is an error); a child with partial history returns completed with a cut-off note. Divergence D-3084-a (stricter): a `failed` child with salvaged partial output is an error here.
721
+ - **Known limits.** KL-3084-a (a background `blocked` row polls `isError: true` where the synchronous card's `blocked` does not — the row's words, not the predicate; root fix #3470).
722
+ - **Pins.** `test/backlog3083-3084-delegation-refusal.test.ts` — the synchronous card for a child that cannot start and for a refused model request, the fork card, the real chain (a roster child with every tool removed ⇒ the parent's `Agent` result is an error), the live and the durable poll, controls (completed, `blocked`, an unknown subagent type). Base: 4 of 6 cells red. Mutations K2-M1–K2-M5 (receipt).
723
+
724
+ no-notes: #2424(the 91f03555c stage bookkeeping re-read the released 7.63.0 state for two pins; no behaviour), #2913(the RL-2164 merge head names it; retired with RL-2164 in that section)
725
+
1
726
  ## 7.63.0 — 2026-11-01
2
727
 
3
728
  ### A parked row's members are read one way by every reader — the row judge and the listing faces share one member-shape table, so over the five members it names (the gate, the pending action, the state, `createdAt`, `deadline`) a row a listing calls damaged is refused at the resume with the row's sentence, and no face lets through a row another cannot read (#3383; behavior change; behavior narrowing — four, below, open to veto; hard-breaking: one, three sentences below, open to veto; closed sets: none; exports: none; wire: no key added) (@server @client-core @cli @test)