@sema-agent/core 7.58.0 β†’ 7.59.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 (284) hide show
  1. package/CHANGELOG.md +776 -0
  2. package/README.md +6 -4
  3. package/dist/agents/cc-peer-directory.js +8 -8
  4. package/dist/agents/child-model-seat.d.ts +4 -2
  5. package/dist/agents/child-model-seat.js +5 -3
  6. package/dist/agents/peer-directory.d.ts +9 -0
  7. package/dist/agents/peer-directory.js +6 -2
  8. package/dist/agents/send-message-tool.js +21 -12
  9. package/dist/agents/subagent.js +33 -34
  10. package/dist/brain/anthropic.js +161 -45
  11. package/dist/brain/errors.d.ts +9 -3
  12. package/dist/brain/errors.js +7 -1
  13. package/dist/brain/failover.js +2 -1
  14. package/dist/brain/open-responses.js +3 -3
  15. package/dist/brain/openai.js +103 -53
  16. package/dist/brain/provider-dialect.d.ts +11 -0
  17. package/dist/brain/provider-dialect.js +5 -2
  18. package/dist/brain/reasoning-request.js +5 -4
  19. package/dist/brain/reasoning.d.ts +19 -0
  20. package/dist/brain/reasoning.js +17 -2
  21. package/dist/brain/request-route.d.ts +4 -1
  22. package/dist/brain/request-route.js +4 -1
  23. package/dist/brain/route-adjudicator.d.ts +84 -18
  24. package/dist/brain/route-adjudicator.js +87 -21
  25. package/dist/brain/route-conformance.js +1 -1
  26. package/dist/brain/stream-engine.js +84 -49
  27. package/dist/brain/stream-shared.d.ts +30 -0
  28. package/dist/brain/stream-shared.js +34 -1
  29. package/dist/brain/timeout.d.ts +62 -5
  30. package/dist/brain/timeout.js +93 -6
  31. package/dist/core/account-row.d.ts +61 -0
  32. package/dist/core/account-row.js +51 -0
  33. package/dist/core/advisor-verdict.d.ts +2 -1
  34. package/dist/core/advisor-verdict.js +1 -1
  35. package/dist/core/allow-entry.d.ts +18 -6
  36. package/dist/core/allow-entry.js +16 -8
  37. package/dist/core/approval-object.d.ts +29 -15
  38. package/dist/core/approval-object.js +47 -19
  39. package/dist/core/auto-compaction.js +1 -1
  40. package/dist/core/background-agent-store.d.ts +16 -3
  41. package/dist/core/checkpoint-requirements.d.ts +13 -1
  42. package/dist/core/checkpoint-requirements.js +3 -1
  43. package/dist/core/checkpoint-store.d.ts +58 -12
  44. package/dist/core/checkpoint-store.js +18 -6
  45. package/dist/core/child-clamp-seats.d.ts +29 -0
  46. package/dist/core/child-clamp-seats.js +56 -1
  47. package/dist/core/compliance.d.ts +2 -2
  48. package/dist/core/compliance.js +1 -1
  49. package/dist/core/effective-path-target.d.ts +8 -2
  50. package/dist/core/effective-path-target.js +8 -3
  51. package/dist/core/engine-notice.d.ts +98 -8
  52. package/dist/core/engine-notice.js +19 -5
  53. package/dist/core/gate-fold.js +1 -1
  54. package/dist/core/gate-lanes.js +8 -4
  55. package/dist/core/gate-outcome.d.ts +32 -3
  56. package/dist/core/gate-outcome.js +19 -1
  57. package/dist/core/governance-codes.d.ts +9 -1
  58. package/dist/core/governance-codes.js +13 -0
  59. package/dist/core/hooks.d.ts +31 -3
  60. package/dist/core/hooks.js +5 -6
  61. package/dist/core/image-admission.d.ts +6 -5
  62. package/dist/core/image-admission.js +18 -14
  63. package/dist/core/locked-config.d.ts +5 -2
  64. package/dist/core/locked-config.js +2 -1
  65. package/dist/core/mailbox-store.d.ts +45 -1
  66. package/dist/core/mailbox-store.js +53 -9
  67. package/dist/core/mcp-failure.d.ts +114 -18
  68. package/dist/core/mcp-failure.js +63 -5
  69. package/dist/core/mcp-server-link.d.ts +22 -1
  70. package/dist/core/mcp-server-link.js +25 -1
  71. package/dist/core/mcp.d.ts +12 -8
  72. package/dist/core/mcp.js +42 -25
  73. package/dist/core/memory-engine/consolidation-driver.d.ts +2 -4
  74. package/dist/core/memory-engine/consolidation-driver.js +3 -3
  75. package/dist/core/memory-engine/consolidation.d.ts +4 -0
  76. package/dist/core/memory-engine/consolidation.js +1 -0
  77. package/dist/core/memory-engine/delegation-settlement.js +5 -12
  78. package/dist/core/memory-engine/distiller.js +2 -2
  79. package/dist/core/memory-engine/dual-root.d.ts +50 -1
  80. package/dist/core/memory-engine/dual-root.js +44 -1
  81. package/dist/core/memory-engine/engine.d.ts +67 -14
  82. package/dist/core/memory-engine/engine.js +384 -212
  83. package/dist/core/memory-engine/export-bundle.d.ts +23 -0
  84. package/dist/core/memory-engine/export-bundle.js +23 -4
  85. package/dist/core/memory-engine/file-backend.d.ts +128 -55
  86. package/dist/core/memory-engine/file-backend.js +290 -117
  87. package/dist/core/memory-engine/index.d.ts +1 -1
  88. package/dist/core/memory-engine/layout.d.ts +59 -11
  89. package/dist/core/memory-engine/layout.js +190 -40
  90. package/dist/core/memory-engine/memory-backend-contract.d.ts +1 -1
  91. package/dist/core/memory-engine/memory-backend-contract.js +39 -2
  92. package/dist/core/memory-engine/sync-client.d.ts +9 -1
  93. package/dist/core/memory-engine/sync-client.js +31 -8
  94. package/dist/core/memory-engine/sync.d.ts +5 -0
  95. package/dist/core/memory-engine/types.d.ts +6 -0
  96. package/dist/core/mods/classic-events.d.ts +5 -1
  97. package/dist/core/mods/kernel/dispatch.js +2 -1
  98. package/dist/core/mods/kernel/events.d.ts +2 -1
  99. package/dist/core/mods/kernel/events.js +2 -2
  100. package/dist/core/mods/kernel/registration.d.ts +4 -0
  101. package/dist/core/mods/kernel/registration.js +3 -0
  102. package/dist/core/mods/stations.d.ts +31 -10
  103. package/dist/core/mods/stations.js +44 -10
  104. package/dist/core/mods/tool-call.js +1 -1
  105. package/dist/core/parent-spec-seat.d.ts +8 -3
  106. package/dist/core/parent-spec-seat.js +2 -0
  107. package/dist/core/park-selfcheck.js +6 -0
  108. package/dist/core/peer-seat.d.ts +70 -8
  109. package/dist/core/peer-seat.js +143 -11
  110. package/dist/core/permission-rule-consent.js +10 -4
  111. package/dist/core/permission-rule-model.d.ts +16 -0
  112. package/dist/core/permission-rule-model.js +1 -1
  113. package/dist/core/present-plan-tool.d.ts +11 -3
  114. package/dist/core/present-plan-tool.js +2 -2
  115. package/dist/core/resume-startup-cause.js +1 -0
  116. package/dist/core/rewrite-rejudge.d.ts +1 -0
  117. package/dist/core/rewrite-rejudge.js +2 -2
  118. package/dist/core/roles.d.ts +34 -2
  119. package/dist/core/roles.js +43 -4
  120. package/dist/core/runner/announce-once-ledger.d.ts +5 -4
  121. package/dist/core/runner/announce-once-ledger.js +4 -2
  122. package/dist/core/runner/call-hook-stations.js +2 -2
  123. package/dist/core/runner/contracts.d.ts +20 -16
  124. package/dist/core/runner/credential-origin-seat.js +4 -3
  125. package/dist/core/runner/cwd-alignment-probe.d.ts +20 -0
  126. package/dist/core/runner/cwd-alignment-probe.js +21 -0
  127. package/dist/core/runner/decide-continuation.d.ts +2 -2
  128. package/dist/core/runner/gate-exit.d.ts +12 -4
  129. package/dist/core/runner/gate-exit.js +10 -7
  130. package/dist/core/runner/image-removed-seat.d.ts +12 -0
  131. package/dist/core/runner/image-removed-seat.js +19 -0
  132. package/dist/core/runner/inline-image.js +1 -1
  133. package/dist/core/runner/memory-consolidation-driver.js +3 -3
  134. package/dist/core/runner/park-commit.d.ts +1 -1
  135. package/dist/core/runner/park-commit.js +3 -0
  136. package/dist/core/runner/prepare-ask-lane.d.ts +1 -1
  137. package/dist/core/runner/prepare-ask-lane.js +2 -1
  138. package/dist/core/runner/prepare-boundary-parks.js +2 -2
  139. package/dist/core/runner/prepare-caps-and-workflow.d.ts +3 -5
  140. package/dist/core/runner/prepare-caps-and-workflow.js +2 -0
  141. package/dist/core/runner/prepare-config-doors.js +2 -0
  142. package/dist/core/runner/prepare-context-lane.js +2 -0
  143. package/dist/core/runner/prepare-delegation-surface.d.ts +4 -0
  144. package/dist/core/runner/prepare-delegation-surface.js +1 -0
  145. package/dist/core/runner/prepare-hands-readface.d.ts +4 -0
  146. package/dist/core/runner/prepare-hands-readface.js +5 -0
  147. package/dist/core/runner/prepare-inherited-gate.d.ts +1 -3
  148. package/dist/core/runner/prepare-inherited-gate.js +14 -27
  149. package/dist/core/runner/prepare-memory.js +10 -17
  150. package/dist/core/runner/prepare-park-ask.d.ts +1 -1
  151. package/dist/core/runner/prepare-park-ask.js +2 -1
  152. package/dist/core/runner/prepare-policy-chain.d.ts +3 -3
  153. package/dist/core/runner/prepare-policy-chain.js +16 -13
  154. package/dist/core/runner/prepare-project-context.d.ts +2 -2
  155. package/dist/core/runner/prepare-project-context.js +2 -2
  156. package/dist/core/runner/prepare-prompt-inputs.d.ts +1 -1
  157. package/dist/core/runner/prepare-prompt-inputs.js +8 -19
  158. package/dist/core/runner/prepare-protocol-tools.js +9 -1
  159. package/dist/core/runner/prepare-run-refs.d.ts +2 -3
  160. package/dist/core/runner/prepare-run-refs.js +4 -1
  161. package/dist/core/runner/prepare-task.js +4 -2
  162. package/dist/core/runner/prepare-wiring-manifest.d.ts +1 -1
  163. package/dist/core/runner/prepare-wiring-manifest.js +2 -1
  164. package/dist/core/runner/reply-pricing.d.ts +30 -0
  165. package/dist/core/runner/reply-pricing.js +19 -0
  166. package/dist/core/runner/resume-admission.js +4 -2
  167. package/dist/core/runner/resume-apply.js +6 -1
  168. package/dist/core/runner/resume-policy-outcome.js +5 -5
  169. package/dist/core/runner/role-seat-defaulted.d.ts +44 -0
  170. package/dist/core/runner/role-seat-defaulted.js +40 -0
  171. package/dist/core/runner/run-brain-sinks.js +2 -0
  172. package/dist/core/runner/run-identity-wiring.d.ts +2 -5
  173. package/dist/core/runner/run-identity-wiring.js +5 -4
  174. package/dist/core/runner/run-leg.d.ts +2 -0
  175. package/dist/core/runner/run-leg.js +37 -28
  176. package/dist/core/runner/run-stop-and-final-verify.js +2 -2
  177. package/dist/core/runner/run-terminal-adoption.d.ts +2 -5
  178. package/dist/core/runner/run-terminal-adoption.js +9 -3
  179. package/dist/core/runner/run-turn-boundary.js +77 -70
  180. package/dist/core/runner/runtask.d.ts +1 -1
  181. package/dist/core/runner/runtask.js +2 -2
  182. package/dist/core/runner/side-call-account.d.ts +1 -1
  183. package/dist/core/runner/side-call-account.js +3 -18
  184. package/dist/core/runner/sub-agent-deny-lists.d.ts +24 -0
  185. package/dist/core/runner/sub-agent-deny-lists.js +10 -0
  186. package/dist/core/runner/tool-end-body.js +2 -2
  187. package/dist/core/runner/tool-occurrence.d.ts +1 -1
  188. package/dist/core/runner/tool-occurrence.js +2 -2
  189. package/dist/core/runner/turn-attachments.d.ts +26 -22
  190. package/dist/core/runner/turn-attachments.js +24 -26
  191. package/dist/core/runner-deps.d.ts +1 -1
  192. package/dist/core/secret-env.d.ts +32 -2
  193. package/dist/core/secret-env.js +65 -3
  194. package/dist/core/sensitive-path-policy.js +3 -3
  195. package/dist/core/session-policy-store.d.ts +3 -1
  196. package/dist/core/session-policy-store.js +13 -9
  197. package/dist/core/session-store.d.ts +2 -5
  198. package/dist/core/side-query.d.ts +11 -1
  199. package/dist/core/side-query.js +9 -0
  200. package/dist/core/skill-grant-binding.d.ts +31 -2
  201. package/dist/core/skill-grant-binding.js +31 -1
  202. package/dist/core/skill-grant.d.ts +8 -5
  203. package/dist/core/skill-grant.js +6 -6
  204. package/dist/core/store-contracts/background-agent-store-contract.js +27 -0
  205. package/dist/core/store-contracts/checkpoint-store-contract.js +3 -2
  206. package/dist/core/store-contracts/mailbox-store-contract.js +31 -1
  207. package/dist/core/synthetic-read-verdict.js +2 -1
  208. package/dist/core/task-event.d.ts +32 -8
  209. package/dist/core/task-notification.js +16 -10
  210. package/dist/core/task-registry-agent.js +1 -0
  211. package/dist/core/task-registry-shared.d.ts +5 -0
  212. package/dist/core/task-spec.d.ts +12 -1
  213. package/dist/core/terminal-cause.d.ts +10 -0
  214. package/dist/core/tool-check-reading.d.ts +1 -0
  215. package/dist/core/tool-check-reading.js +3 -3
  216. package/dist/core/tool-policy.d.ts +16 -0
  217. package/dist/core/tool-roster.d.ts +112 -5
  218. package/dist/core/tool-roster.js +42 -1
  219. package/dist/core/tool-spec.d.ts +3 -1
  220. package/dist/core/types.d.ts +2 -2
  221. package/dist/core/types.js +1 -1
  222. package/dist/core/user-attachment.js +1 -1
  223. package/dist/core/wiring-manifest.d.ts +6 -3
  224. package/dist/engine/compaction/compaction.js +29 -3
  225. package/dist/engine/execution-env/node-execution-env.d.ts +4 -3
  226. package/dist/engine/execution-env/node-execution-env.js +9 -12
  227. package/dist/engine/harness/agent-harness.d.ts +25 -2
  228. package/dist/engine/harness/agent-harness.js +41 -12
  229. package/dist/engine/harness/messages.d.ts +3 -1
  230. package/dist/engine/harness/messages.js +3 -2
  231. package/dist/engine/harness/types.d.ts +8 -0
  232. package/dist/engine/llm/rejected-images.d.ts +46 -0
  233. package/dist/engine/llm/rejected-images.js +54 -0
  234. package/dist/engine/llm/tool-turns.d.ts +2 -1
  235. package/dist/engine/llm/types.d.ts +18 -7
  236. package/dist/engine/loop/agent-loop.d.ts +8 -0
  237. package/dist/engine/loop/agent-loop.js +52 -15
  238. package/dist/engine/loop/types.d.ts +3 -1
  239. package/dist/engine/session/path-to-root.d.ts +38 -0
  240. package/dist/engine/session/path-to-root.js +39 -0
  241. package/dist/engine/session/storage-base.js +4 -21
  242. package/dist/index.d.ts +16 -10
  243. package/dist/index.js +11 -7
  244. package/dist/internal/harness-types.d.ts +1 -1
  245. package/dist/internal/harness.d.ts +1 -0
  246. package/dist/internal/llm.d.ts +1 -0
  247. package/dist/orchestration/workflow-observe.d.ts +17 -1
  248. package/dist/orchestration/workflow-observe.js +20 -0
  249. package/dist/orchestration/workflow-types.d.ts +32 -7
  250. package/dist/orchestration/workflow.js +739 -489
  251. package/dist/shell/counting-pass.d.ts +50 -0
  252. package/dist/shell/counting-pass.js +502 -0
  253. package/dist/shell/lex.d.ts +4 -2
  254. package/dist/shell/lex.js +93 -34
  255. package/dist/shell/shell-words.d.ts +1 -1
  256. package/dist/shell/shell-words.js +7 -6
  257. package/dist/stores/file/mailbox-store.js +6 -10
  258. package/dist/tools/fs/fs-bash.d.ts +6 -0
  259. package/dist/tools/fs/fs-bash.js +6 -3
  260. package/dist/tools/fs/index.js +6 -2
  261. package/dist/tools/fs/program-read-model.d.ts +13 -0
  262. package/dist/tools/fs/program-read-model.js +15 -0
  263. package/dist/tools/fs/program-read-model.rows.js +1 -1
  264. package/dist/tools/fs/read-deny.d.ts +13 -10
  265. package/dist/tools/fs/read-deny.js +25 -5
  266. package/dist/tools/fs/read-floor.d.ts +19 -0
  267. package/dist/tools/fs/read-floor.js +23 -0
  268. package/dist/tools/fs/shell-read-check.d.ts +1 -1
  269. package/dist/tools/fs/shell-read-check.js +2 -1
  270. package/dist/tools/fs/shell-read-judge.d.ts +16 -8
  271. package/dist/tools/fs/shell-read-judge.js +10 -6
  272. package/dist/tools/fs/shell-read-plan.d.ts +6 -1
  273. package/dist/tools/fs/shell-read-plan.js +22 -15
  274. package/dist/tools/fs/shell-read-start.js +1 -0
  275. package/dist/tools/fs/shell-reentry-text.d.ts +15 -1
  276. package/dist/tools/fs/shell-reentry-text.js +25 -3
  277. package/dist/tools/monitor.d.ts +4 -0
  278. package/dist/tools/monitor.js +2 -0
  279. package/package.json +3 -2
  280. package/test/export-surface.snapshot.json +87 -1
  281. package/wire-changes/core-stores-sql@7.59.0.json +29 -0
  282. package/wire-changes/core@7.59.0.json +2459 -0
  283. package/wire-changes/mods-kernel@7.59.0.json +29 -0
  284. package/wire-changes/primitives@7.59.0.json +29 -0
package/CHANGELOG.md CHANGED
@@ -1,3 +1,779 @@
1
+ ## 7.59.0 β€” 2026-10-27
2
+
3
+ ### A model call waiting on a gateway gives up within 599 s however large the request, and a host that slept through a wait reconnects at the first second after waking β€” `sleptMs` on the reconnect frame, `waitSegment` on the wait frame (#2870; behavior narrowing: the first-byte window's upload allowance is capped; hard-breaking: none; closed sets: one new, `BrainStatus.waitSegment`; exports: none; members: +2 optional on `BrainStatus` / the `status` event) (@cli @server @client-core)
4
+
5
+ - **Before.** The first-byte window was `knob + 1 s per 32 KiB of body` with no bound but the timer ceiling: a 40 MB request (a context full of screenshots) armed 300 s + ~1 280 s and its retry 600 s + ~1 280 s β€” about 26 minutes of silence before the first retry. And no wait looked at the wall clock: a host that slept (a laptop closed over lunch) woke up still waiting on the connection the sleep took, until a TCP error happened to arrive or the window armed before the sleep ran out.
6
+ - **Now.** The upload allowance grows a window up to `FIRST_BYTE_WINDOW_CAP_MS` = 599 000 and no further (40 MB: 599 000, retry 600 000; 2 KB unchanged at 301 000; a knob already at or above the cap is the window as set). While any of the three engine waits is armed β€” response headers, first token, the silence between deltas β€” the wall clock is read once a second; a gap over five seconds is counted as slept, and at the first reading where a wait's sleep exceeds half its window the attempt ends and is re-sent on a fresh connection (shared retry budget; in the stream, the mid-stream tiers), announced as `reconnecting` / `errClass: "stall"` with `detail: "the host was suspended for <s>s during the <…> wait, reconnecting on a fresh connection"`.
7
+ - **Consumers.** wire +2, additive and optional: `sleptMs` β€” present exactly on a retry-wait frame for an attempt a host suspend ended (absent on a deadline's stall); `waitSegment` β€” present on every `waiting_first_token` frame (`response_headers` | `first_token`), absent on every other phase. @cli: render the wake line off `sleptMs` and the wait row's segment off `waitSegment`; @server / @client-core: project both members on the `status` face.
8
+ - **Pins.** `test/backlog2870-first-byte-sleep.test.ts` (the cap pure and at the call: 40 MB cut at 599 s, 2 KB at 301 s; a 15-minute suspend in each of the three waits β‡’ the frame within 1 s of waking and the new request within 1 s of the frame, text already streamed kept as incomplete; a deadline that runs before the next reading names the suspend; half-window threshold from both sides (200 s / 100 s of 301 s); five-second gaps never add up to a suspend; both members on the task stream's `status` event). KL-1121e retired; KL-2870-a (a forward wall-clock step, or an event loop blocked for more than five seconds at a time, reads as a suspend once it adds up past half the window: one reconnect).
9
+
10
+ ### An MCP server the user must authorize is one failure word, `unauthorized`, with one authorization fact that every face reads β€” the status record, the wiring manifest, a refused call's error and `tool_end`, a `mcp.authorization_required` notice, and the model's needs-authorization line (#2295, slice S2 of the MCP credential seat, design/1494; hard-breaking, open to veto; closed sets: `MCP_FAILURE_KINDS` +1 (`unauthorized`), `ENGINE_NOTICE_CODES` +1 (`mcp.authorization_required`), new `MCP_AUTHORIZATION_REASONS`; exports: +1 root value, +2 root types) (@server @cli @client-core @connectors)
11
+
12
+ - **Before.** A 401 from an MCP server's HTTP endpoint was `errorCode: "http_status"` with `httpStatus: 401` β€” read like a gateway outage, with the endpoint's `WWW-Authenticate` challenge dropped β€” and a refused call told the model that the endpoint "answered 401 instead of an MCP response" and that the request "may or may not have executed". A 403 whose challenge said `insufficient_scope` was the same status word. A deployment seat answering `unauthorized` (#2294) was `credential_unavailable`, the deployment's-fault word. The model was never told a server needed authorization: the needs-authorization arm of the reference's tool-delta notice had no state to read.
13
+ - **Now.** One word, `unauthorized`, carries `authorization: { reason, authorizeUrl?, resourceMetadataUrl? }` (`McpAuthorization`; `reason` ∈ `MCP_AUTHORIZATION_REASONS`): `rejected` β€” the endpoint answered 401 and the seat's re-ask did not answer a credential that passed (`delivered: "unknown"`); `scope` β€” a 403 with `Bearer error="insufficient_scope"` (the seat is not asked again, nothing is sent again; `"unknown"`); `none` β€” the seat answered `unauthorized` (nothing sent; `"no"`, no liveness observation). A 403 without that challenge stays `http_status`. `authorizeUrl` comes only from the seat β€” its answer to the send or to the re-ask after a 401 β€” and must be an absolute http(s) URL (≀ 2048, no control character) or the answer is refused (`credential_unavailable`); `resourceMetadataUrl` comes only from the endpoint's challenge, kept under the same URL law as the parser serializes it, and is never rendered to the model. The engine's one HTTP fetch reads the challenge off the 401 / scope-403 response and raises the refusal itself (the SDK's own error keeps no header). The faces: the status record (`MaterializedMcp.statuses`, a re-dial's `status`) and the manifest's `mcp[]` row carry `authorization` (no `httpStatus`), through the record's one projection; a refused call's `details.authorization` and its `tool_end.errorCode`; the notice `mcp.authorization_required` (user audience; `detail: { server, reason, authorizeUrl?, principal?, sessionId, runId }`) once per (leg, server); the `mcp_unavailable` frame on the leg's first request lists a server whose dial failed `unauthorized` in its own needs-authorization arm β€” the reference's `needsAuthMcpServers` sentence (CC 2.1.309, minted `cli309.js:265582`, read and worded `cli309.js:267398-267401`), always its cannot-start-the-flow form, `<where>` = the seat's URL or the deployment's connector settings, "Do not ask the user for authorization codes, tokens, or callback URLs" β€” and never in the failed-to-connect arm; a refused call's line says the user needs to authorize the server (and where), with the delivery tail its verdict owes. A refusal is announced when it is the request's answer: a repeat-safe call refused 401 and sent once more on a renewed credential announces only if that second send is refused too; a write-class 401 after which the seat answered another credential is announced, and its line says a new call carries that credential and that only its refusal is the user's (a seat that answers a fresh assertion on every ask must still reach the user). Nothing parks on it and a resume replays nothing (C-R725 加注 4: a deployment that waits keys on the notice).
14
+ - **Hard-breaking (open to veto) β€” sentence 3 of design/1494 Β§8.3.** *What changed:* an MCP 401, and a 403 with an `insufficient_scope` challenge, are no longer `errorCode: "http_status"` + `httpStatus`; they are `errorCode: "unauthorized"` + `authorization` on every face (status, manifest, error `details`, `tool_end`), and a seat's `unauthorized` answer is no longer `credential_unavailable`; a write-class call answered 401 is still sent again by no layer (#2294). *Who is hurt:* every consumer that branches on `errorCode === "http_status" && httpStatus === 401` (or 403) β€” @server's MCP status face, @client-core's `engineErrorCodes.ts` 401 classification, @cli's rendering β€” and every `switch` over `MCP_FAILURE_KINDS` (one more word; the "previously only" 401 reading moved to it). *How to migrate:* read `errorCode === "unauthorized"` and `authorization.reason`; send the user to `authorization.authorizeUrl` when present (your seat's own URL), else to your connector settings; treat `resourceMetadataUrl` as the remote's untrusted claim; key a wait-for-authorization flow on `mcp.authorization_required`.
15
+ - **Closed sets.** `MCP_FAILURE_KINDS` +1 `unauthorized` (its delivery and liveness rows read the status class's: `"unknown"`, kept at the dial); a refusal by the engine's own seat is `"no"` / no observation by one rule over both seat words. `ENGINE_NOTICE_CODES` +1 `mcp.authorization_required` (audience `user`, minter `engine`). New `MCP_AUTHORIZATION_REASONS` (`rejected` / `scope` / `none`). Consumers that pin these sets closed: @server (notice whitelist, MCP status projection), @client-core, @cli.
16
+ - **Consumers.** @server: project `unauthorized` + `authorization` on the MCP status face; forward `mcp.authorization_required` to the user (route by `sessionId`; `authorizeUrl` is your seat's) and, for a managed wait, key the authorization callback on it β€” no park gate exists for it; your `peerSeat` answering `{ kind: "unauthorized", authorizeUrl }` (to a send or to the `rejected` re-ask) is how the user is sent to your authorization page. @client-core: `engineErrorCodes.ts` reads `unauthorized`; your local seat's `unauthorized` answer is the same. @cli: render `unauthorized` and the notice. @connectors: answer 401 with `WWW-Authenticate: Bearer resource_metadata="…"` per RFC 9728 and it rides `resourceMetadataUrl`; a scope shortfall as 403 `error="insufficient_scope"`.
17
+ - **Exports.** +1 root value `MCP_AUTHORIZATION_REASONS`, +2 root types `McpAuthorization` / `McpAuthorizationReason`; `McpServerStatus` / `WiringManifestMcpEntry` +`authorization`; `McpFailure` +`authorization`; `materializeMcpTools` +1 trailing parameter (`onAuthorizationRequired`).
18
+ - **Pins.** `test/backlog2295-unauthorized.test.ts` (W: 401 not renewed β‡’ rejected / unknown with the challenge's resource_metadata and the user's line; 403 scope β‡’ scope, no re-ask, not sent again; 403 without the challenge stays a status; the seat's `unauthorized` β‡’ none / no, nothing sent; the re-ask's URL on a 401's record; a renewed write 401 β‡’ the same word, the "a new call carries it; if refused too, the user" line, announced; a re-send that passes announces nothing; a seat renewing on every ask still announces. T: the challenge never supplies `authorizeUrl`, its resource_metadata is percent-encoded, a non-http(s) one dropped; a seat URL off the URL law refused loudly; a Bearer challenge after another scheme is read, `not_error=` and an `error=` inside a quoted description are not its error; markup in a seat URL percent-encoded, user-info refused; a control character in resource_metadata dropped. F: the status record and the announcer one fact; the seat's dial refusal no observation; through the Runner the manifest row, the needs-authorization arm with the server in it only, one notice; two refused calls β‡’ two frames, one notice; a listing refresh refused for scope announces; a changed authorize URL is told again on the session's next run, the same one is not; the receipt files the told pair only; the closed sets. P: a durable leg that parked after a refused call does not send it again on resume β€” a control, green before and after). Re-pinned to the new word: `backlog2294-peer-seat` (R2 / R3 / R4; F's `unauthorized` row moved here), `backlog562-manifest-mcp-face`, `backlog610-connect-delivery`, `backlog874-mcp-liveness`, `mcp-failure-record`.
19
+ - **Known limits.** A write-class call refused 401 once with a credential the seat then renewed still tells the user to authorize (it is the call's answer; a seat that renews on every ask must still reach the user) β€” KL-2295-a; a 403 scope refusal never re-asks the seat, so it carries no `authorizeUrl` β€” KL-2295-b; an unauthorized dial still raises the operator's `mcp.server_unavailable`, and A2A peers have no `unauthorized` word β€” KL-2295-c.
20
+
21
+ ### A frame's delivery record advances on the receipt of the message that carried it, never at collection β€” every turn-boundary attachment and the limit-approach notice (#565, design/565 slice S1, ruled C-R882; behavior narrowing, open to veto; hard-breaking: none; closed sets: none; exports: none; members: none) (@server @cli @test)
22
+
23
+ - **Before.** The turn boundary collects its attachment bundle, then awaits the postToolBatch dispatch and the instructions probe, then issues one steer that the next request drains. Several frames recorded "delivered" at collection: the `mcp_dropped_tools` batch (its entries left the lane and their once-per-session digests joined the session's announced record), the post-compaction `background_tasks` latch, the `tools_delta` pending lists, the `instructions_change` / `workflow_size_guideline_change` announced values, the `changed_files` surfaced marks, the todo / task / tool-search reminder windows and the limit-approach threshold. Every bundled frame's `steering_injected` echo and `stats.mechanisms.attachmentsInjected` count went out at collection too. A stop landing after the collection (`TaskStream.halt()` or a tool's stop-after-turn, inside the postToolBatch dispatch or the probe) still let the steer be issued, and the loop exited before draining it: the session never heard the dropped MCP tool again (its digest was recorded), and the background-task restatement vanished without its settle-time `compaction.announce_dropped` disclosure.
24
+ - **Now.** One rule: collection records nothing; each frame registers a receipt on the steer that carries it, and the run loop's `message_end` walk settles it when the drained steer is in the transcript β€” the frame's echo, its count and its record step run there (the rule the listings, the date and the leg's first-request frames already followed). A frame on its way is not collected again. A steer that never drains, or is refused, records nothing: the frame is said again at the next quiet boundary, or the next run on the session (`mcp_dropped_tools`), or β€” the background-task latch β€” it is still owed when the run settles and the loss is disclosed. A frame the bundle cap drops is due again at the next quiet boundary (it used to spend its reminder window or its latch). An empty background-task registry still consumes the latch at collection (nothing to deliver).
25
+ - **Open to veto β€” the echo.** `steering_injected` for a turn-boundary frame (and for `limit_approach`) is now emitted when the drained steer's message is committed β€” after that message's `message_committed`, at the next request β€” not at collection; a frame that never reached the transcript emits none, and `stats.mechanisms.attachmentsInjected` counts delivered frames only. Who is hurt: a consumer that rendered the echo as "injected" at the boundary, or a test that expected an echo for an undelivered frame. Migrate: read the echo as delivered; order it after the message it rode.
26
+ - **Not in this slice (stated).** The `mcp_instructions` frame still records at collection (its told-ledger is written by asynchronous MCP lifecycle events and needs an in-flight state); a background-task restatement lost to an undrained steer is disclosed but not re-armed on the session's next run (the re-arm seed reads "an assistant message follows the compaction" as consumed); the LSP diagnostics drain and the memory announcement queue (drained at prepare into the system prompt) record before delivery. Each has its own design ticket.
27
+ - **Consumers.** @cli: the boundary lane's `steering_injected` rows arrive with the next request, not at the boundary; none for a frame a stop swept. @server: `announced_listing.advisories` (the dropped-tool digest arm) is written later β€” at the leg's exit after a delivered batch β€” and not at all for an undelivered one; the key shape is unchanged. @test: a halted boundary's frames are announced again by the next run.
28
+ - **Pins.** `test/backlog565-commit-on-receipt.test.ts` (real Runner: a halt inside the postToolBatch dispatch β‡’ the dropped-tool batch is not recorded and the next run announces it; a drained batch is recorded; the post-compaction restatement swept by the same halt is disclosed; a drained one is seen once; unit: the producers' record steps ride their frames, a cap-dropped frame hands nothing over, a clipped one keeps its step).
29
+
30
+ ### A parked approval covers the tool its roster row was, read whole: one classification of every roster member (identity / face / declaration / unbound), the declaration bound as one digest, a row that does not carry a whole tool member refused before the claim (#639 / #2345, C-R883; BREAKING β€” behavior narrowing, open to veto)
31
+
32
+ - **Before.** The tool member of a parked approval was a hand-picked subset of its roster row, and each member added later had its own reading of absence: a row with none of the four identity members bound the tool's NAME alone (a replacement wearing the name ran on resume); one with some of them reopened as a replacement after the claim; a path target without its resolution members was compared as `cwd` / `none` by a second statement of those defaults (a row parked before #635 by a tool that resolved against the root was read as a face it never had, and vetoed with "the face changed" after its approval was spent); the recorded mount site (`engineMounted`) was never compared; and the tool's declaration β€” its effect, egress, irreversibility, content origin, boundary legs, rule face, model gate (an MCP server's `destructiveHint` folds into `irreversibility`) β€” was not part of the approval: a tool re-declared between the park and the resume ran under the new declaration.
33
+ - **Now.** `ROSTER_APPROVAL_BINDING` classifies every member of `ToolRosterEntry` once (a new roster member is a compile error until it is classified; the judge's identity and face lists are fenced to it at compile time). Unbound, each with its reason: aliases, the server's declaring origin, the two value provenances no decision reads (`egressProvenance`, `contentOriginProvenance`), the card id, the wire schema's prose and the input keys (the schema's shape is identity), result storage and transcript handling, the preview / validator flags, loading, render hints. The park writes the identity (the four members and the mount site) and the face by value, and the declaration members as one digest, `pendingAction.declarationDigest` (`toolDeclarationDigestOf`, requirement word `tool_declaration`). `judgeApprovalObject` reads the tool member whole or not at all: at the claim station (now `["tool", "grants"]`) a row missing any member the park always writes (the four identity members, `family`, `declarationDigest`) is refused β€” `checkpoint.unsupported_version`, `detail.reason: "tool_identity_missing"`, the row pending, a deny is not judged by it (a member present in another shape β€” `engineMounted` not `true`, a slot that is not a record naming its `param` β€” is read as damage the same way; past the claim the same reading vetoes); with a whole member, another identity (the mount site included) reopens (`resume.tool_contract_mismatch`) and another face or declaration vetoes (`resume.target_moved`). A face is compared as it resolves, through the one reader of a slot's silences (`pathTargetResolutionOf`): a definition that spells its default base matches one that states none.
34
+ - **What changes / who is hurt / how to migrate.** (1) Every tool approval parked before 7.59.0 carries no declaration digest: an allow of it is refused before the claim β€” deny it so the model can re-issue the call and its new card is asked (a row that also predates the ask's origin, 7.5.x, refuses a deny too), finish it on a worker of the release that parked it, or expire it. (2) A deployment that writes its own `tool_approval` rows must mint the tool member as the park does (`ROSTER_APPROVAL_BINDING` / `toolDeclarationDigestOf`), or its rows bind no tool. (3) A tool re-declared after the approval (a caller axis; an MCP annotation the engine folds into an axis β€” `destructiveHint`, `openWorldHint`) no longer runs on that approval: the call is vetoed and the model may re-issue it. (4) Consumers listing `CheckpointErrorReason` gain `tool_identity_missing`; those listing the requirement words gain `tool_declaration` (a 7.58.x worker refuses a 7.59.0 approval row `version_newer`, pre-CAS, retryable on a newer worker).
35
+ - **Consumers.** @server: the row gains `pendingAction.declarationDigest` and the word `tool_declaration` (a store that drops the member fails `probeParkRoundTrip`, whose representative row now carries the whole tool member, and every such row reads `requirements_damaged`); pending approvals across the upgrade must be re-asked (three exits above); the reason closed set +1. @dgx: the same through the server's store. @cli / @client-core: the new veto sentence rides the existing `resume.target_moved`; the reason word +1 where the error-code tables list it.
36
+ - **Exports.** +3: `ROSTER_APPROVAL_BINDING`, `type RosterApprovalBinding`, `toolDeclarationDigestOf`. `APPROVAL_STATION_MEMBERS.claim` is `["tool", "grants"]`; `ApprovalObject.tool` is the whole member or `{ missing }`; `ApprovalTool`'s always-written members are required.
37
+ - **Pins.** `test/backlog639-parked-identity-face.test.ts` (real Runner: base-only face move vetoed; a row before the resolution members, a row with no identity and a replacement, a row with a lost member β€” each refused before the claim, pending, nothing ran; a deny settles; a caller tool re-declared irreversible and an MCP tool re-listed `destructiveHint` β€” vetoed, never run; the controls; the classification covers every roster member, the digest moves with each declaration member and with no unbound one, the mount site is identity, the face resolves its silences once, a member present in another shape is damage at every station).
38
+
39
+ ### A revived background agent runs under the restrictions it was born with β€” the durable row records the clamp table's projection of the child's spawn spec (`policyFloor`), and a cross-process revival folds it with the waker's own clamps; a row that states no floor is not revived (#887, design/887; behavior narrowing and security fix; hard-breaking, open to veto; closed sets: none; exports: none β€” one optional member `BackgroundAgentRecord.policyFloor`, one on `RegisterBackgroundAgentInput`) (@server @dgx)
40
+
41
+ - **Before.** A background child woken across processes (SendMessage's durable rung, or a host's parked-approval drive through `ctx.reviveClaim.parkedResume`) had its spec rebuilt from the WAKER's mount: every tighten-only seat of the clamp table β€” `handsReadOnly`, `interactiveTools`, `approvalReach`, both containment faces, the three add-only deny lists, `oneShot`, `memoryPersistenceCapable`, `memory.enabled`, `fileHistory`, `projectMemory`, `promptForm` β€” came from whoever woke it, and the row carried none of the spawning run's. A child spawned by a read-only parent and woken after a restart by its unclamped root wrote files. The in-process wake already folded the spawn snapshot with the waker's clamps; the two wakes followed two rules.
42
+ - **Now.** One rule for both wakes: a woken cycle runs under the table's fold of the floor it was born under and the waker's clamps β€” a restriction either side carries stands, add-only lists union, the waker can narrow and never widen. The registration that creates a row writes `policyFloor` (`{}` when nothing was clamped) and nothing rewrites it. `readClampFloor` (internal) is the one reader: a floor that is absent, not plain data, names a seat this build's table lacks, states a non-restricting value, or carries an entry its seat's law refuses is unreadable. A revived cycle's interaction posture is read under the folded clamps (a floor that brings the hard-headless clamp onto a cycle woken by an interactive caller, or by a host's bare drive that states no posture, runs it headless instead of tripping the posture door). A parked-resume refusal's receipt names its cause (`configuration`). "A clamp leaves nobody to ask" is one predicate (`clampsReachNoPerson`, internal) that `postureUnderClamps` and the revival read; the two other lanes that read `postureUnderClamps` (the in-process wake, the workflow lane) are unchanged β€” an absent posture under such a clamp still falls through to the deployment default there (a known gap, #2748: the workflow lane's spec is a journal key, so its fix is its own design).
43
+ - **Hard-breaking (open to veto).** *What changed:* a revival of a row without a readable `policyFloor` β€” rows written by 7.58.x and earlier, or by a host store that does not persist the member β€” is refused `revive.policy_floor_unreadable` instead of running under the waker's clamps: SendMessage refuses before its claim (the row is untouched, nothing is charged), the Agent tool's revive arm refuses before any allocation, and a parked-resume drive refuses before the consume and rolls its claim back (the approval stays pending). *Who is hurt:* a deployment with its own `BackgroundAgentStore` that maps columns by hand (server's SQL twin) β€” without a column for the member every revival is refused; rows in flight across the upgrade cannot be revived by the new engine. *How to migrate:* persist `policyFloor` verbatim (JSON; `{}` must read back as `{}`, absent as absent) and run the contract kit's new case; for in-flight rows, let them finish, start a new agent, or continue them on an older worker during a rolling deploy; a parked old row is expired.
44
+ - **Consumers.** @server: add the column to the SQL `BackgroundAgentStore` and its local twin; the contract kit's new case names a store that drops it; `revive.policy_floor_unreadable` is a new `details.error` on the SendMessage receipt and the Agent tool's not-started result. @dgx: a deployment store persists the member.
45
+ - **Not in this release.** The inherited gate chain (permission-mode ceiling, `shellGate`, ancestor rules and constraints) and the tool-selector ceiling of a cross-process revival still come from the waker (#2739).
46
+ - **Pins.** `test/backlog887-revive-policy-floor.test.ts` (the floor recorded at spawn, `{}` for an unclamped spawn; six tier-3 shapes over a real Runner β€” write hands with a real `Write`, `oneShot`, both faces, memory off, the add-only union, posture β€” and a second wake still held to the birth floor; the waker's own clamp lands and an unclamped floor tightens nothing (positive control: the probe observes a write); an old-shape row refused before the claim with the row untouched, the Agent arm's own refusal of a directly handed claim, a parked-resume drive's refusal with the claim rolled back; the reader's accepted shape and sixteen refusals, one read per accessor; `clampsReachNoPerson` row by row; a waker that states no posture on an interactive-default deployment); the store contract kit's round-trip case (each CAS on a floor-bearing row must land and keep the floor). Re-pinned: `agent-revive-tier3` (a hand-built row states its floor), `flaky-guard` (the new file's bounded effect poll declared). `gate:error-surface` `src/agents` 92 β†’ 93 (the floor refusal names the agent like its sibling receipts).
47
+
48
+ ### A call an extension refused names that extension on the gate's record β€” `tool_end.gate.disposition.extension` (#2810), one reading for every hook-layer refusal
49
+
50
+ - **Before.** An extension's refusal at `tool.check` β€” and its failure, which the engine fails closed β€” told the model "denied by extension "<n>": <reason>" and recorded `{ kind: "denied", deniedBy: "hook" }`: the registration name lived in the sentence alone, so a card or an audit trail stripped it back out of prose. A `classic.PreToolUse` deny and a `tool.call` refusal had the same gap (the latter only on `answeredBy`).
51
+ - **Now.** The denied arm of `GateDisposition` gains `extension?: string`: the registration whose handler refused the call at the hook layer β€” its `deny` answer at `tool.check`, `classic.PreToolUse` or `tool.call`, or its failure. Present exactly when `deniedBy` is `hook` and the refusing handler's registration is known; absent beside every other layer word, beside an ask a person refused, and beside a `hook` refusal that names no registration (the engine's own failed raise, a cancel, the engine's refusal of a form an extension rewrote). The record is the gate's one mint: the `tool_end` frame, the `classic.PermissionDenied` observer and the durable row hold the same value. Invariant I12 screens it against one table (`DENIED_BY_MAY_NAME_EXTENSION`) the mint and the archive reading both read.
52
+ - **Consumers.** wire +1 (additive, present-iff the hook layer refused through a named registration): @cli the "denied by" line reads the member instead of the sentence; @server projects `gate` whole (no key to add); @client-core reads it where it renders a refusal. `answeredBy` (and `gate.disposition.extension`) names the handler whose run produced the answer β€” when a `.catch` hands back the very answer the run below it already produced, the producer below keeps the name (`src/core/mods/kernel/dispatch.ts:830`; before, the `.catch`'s handler was named); otherwise the `.catch`'s own handler is named, as before. A `tool.call` refusal carries both, the same name.
53
+ - **Exports.** none (a member of an exported type).
54
+ - **Pins.** `test/backlog2810-hook-layer-extension.test.ts` (a `tool.check` deny, a deny beside an allowing bystander, a throwing handler, a `classic.PreToolUse` deny and throw, a `tool.call` refusal, the approved edit's re-screen, a resumed leg's re-screen, the observer's record equal to the frame's; policy / ask-refused / allow carry none; I12 in both readings).
55
+
56
+ ### A call the loop refuses after its gate let it go is `notExecuted` β€” and keeps its `rewrite` (#2817; hard-breaking: two wire invariants reversed, open to veto; closed sets: none; exports: none) (@cli @client-core @server)
57
+
58
+ - **Before.** When an extension (or the policy, or an approver) replaced the arguments and the loop then refused the form the gate cleared β€” its re-validation, the tool's own input check, its re-reading of the bytes, a run aborted before the body β€” the frame was `isError` with no `notExecuted`: the body had not run and the frame did not say so.
59
+ - **Now.** The loop marks the end of such a call `notExecuted` on the same loop-authored channel a batch-halted sibling uses, and the runner projects it (frame and persisted row). The same mark covers a call the host's execution station (`tool.call`) settled without running the body. No member and no status word is added. `tool_end.rewrite` now stays beside the mark: it is dropped only on the engine's own evidence that the call was never let go or was answered in place. A call refused before any gate saw it (an unknown tool, arguments the model's own call got wrong) carries no mark.
60
+ - **Consumers.** `notExecuted` is now present on frames whose `gate.disposition` is `allowed` and `isError` is true (it was always present only beside a gate refusal or an answer in place): @cli @client-core read it as "the body did not run", never as "the gate refused"; the persisted row repeats it as `details.notExecuted`, so a reloaded transcript agrees. Such a call no longer arms the final-verification gate (`wroteThisRun`) and no longer enters the post-tool batch.
61
+ - **Hard-breaking, open to veto (@cli @client-core @server).** What changed: two invariants of the 7.58.0 wire are reversed β€” `tool_end.notExecuted` was present only beside a gate refusal, a halted batch, a reconcile close or an answer in place, and is now also present on a frame whose `gate.disposition` is `allowed` with `isError`; and `tool_end.rewrite` was present only on a frame that carried no `notExecuted` (the contract sentence 7.58.0 shipped with C-R922, `src/core/task-event.ts`), and now stands beside `notExecuted` on a call the loop refused after the gate let it go with other arguments. Who is hurt: a consumer that reads `notExecuted` as "the gate refused" (a card or audit line worded as a refusal, a replay guard that treats the mark as a gate verdict) or that infers whether `rewrite` is present from the mark's absence (a "the arguments were changed" line dropped whenever `notExecuted` is on). What to read instead: the two keys independently β€” `notExecuted` as "the body did not run", `gate.disposition` for who decided, `rewrite` for whether the gate replaced the arguments β€” and never infer one key from the other's absence.
62
+ - **Pins.** `test/backlog2817-loop-refusal-not-executed.test.ts` (a rewrite the schema refuses, a rewrite the tool's input check refuses β€” both with `rewrite` beside the mark; the row; controls: a body that runs and fails, a gate refusal, a pre-gate refusal, an answer in place; the loop's own end event for a gate that throws / blocks / is absent, a station that runs or does not run the body, a run aborted before the body).
63
+
64
+ ### A parked entry has one identity, the one its producer minted β€” a mailbox record carries an `id` and a store's `append` is a compare-and-set on it, the session park seat re-asks a store whose reply was lost instead of keeping a second copy, and a wake message under a parked steer's `inputId` is judged by the parked queue's own rule (#988, #2705; design/988, ruled C-R886; behavior change; hard-breaking, open to veto: the store contract gains the id obligation; closed sets: +2 mailbox store codes; exports: +8 root values, +1 type) (@server @dgx @cli @test)
65
+
66
+ - **Before.** When the session park seat's durable append was rejected, it read the rejection as "nothing was written" and parked the frame in process too. A store can commit and lose its reply, so the box then held the record AND the process held a copy under a different key (`task_notification:<child>:event:<seq>` beside `session.<id>`/box seq): the session's next run read the message twice β€” once as `<cross-session-message>`, once as an `<agent-message>` twin β€” and the worker's receipt said "parked in process … a restart of this process loses it" for a message the box held. A second seat (another process, or this one restarted) parking the same frame wrote a second record. A wake message sent under the `inputId` of a steer the row already held was delivered as a second instruction (identical) or delivered beside it (different), where `setPendingSteer` replays the first and refuses the second.
67
+ - **Now β€” one rule, two seats, one judge each.** An identical write under an identity the seat holds is a replay (one entry, one delivery); a different record under it is refused by name; it is never a second entry.
68
+ - `MailboxAppendMessage.id` / `MailboxMessage.id` (optional): the record's producer-minted identity, persisted and handed back on `claimLease`. While a box holds a record under that id, `append` answers through `judgeMailboxAppendById`: identical on `MAILBOX_REPLAY_FACETS` (`from`, `content`, `hopChain`, `peerMeta` β€” what the record says; `sentAt` is when a write happened) β‡’ the held `seq`, nothing written; any facet different β‡’ `mailbox.duplicate_record_id` naming the facets. A malformed id (not a 1–1024 character string) β‡’ `mailbox.invalid_record_id`, before any side effect. After the record is acked its id is free again: a box answers for what it holds. Both bundled backends run the judgment inside their write critical section; an absent id is a new record each time (unchanged).
69
+ - The park seat's two record forms (the peer-words `peer_message` record and the `engine_frame` record) carry the frame's key as `id`. A rejected append is disclosed once and asked again with the same record; only a second fault parks the frame in process (`parked`).
70
+ - The in-process receipt says what the seat knows: "this copy does not survive a restart of this process" (it no longer asserts that nothing else holds the message).
71
+ - The wake entrance reads `judgeParkedSteerRepeat`, the parked queue's identity judgment now shared with `appendPendingSteer` (which calls it; no change there): an identical repeat of a parked entry is that entry, delivered once; a different one is `steering.duplicate_input_id` (`detail.differs`) before the claim, the row pending and byte-identical.
72
+ - **Limits, stated.** A box answers for the records it HOLDS. Two paths still deliver one message twice (KL-969j, narrowed): the re-ask faults too while the first append had committed (the box and the process each hold it); and a consumer drains and acks the record between the first ask's commit and the re-ask (the re-ask then writes a new record) β€” a store whose rejection arrives a whole turn after its commit. A record the producer re-parks after it was consumed is a new record (at-least-once, unchanged). A different record under a held id is kept, not folded: the seat parks it in process (it is not lost, and the receipt says in process).
73
+ - **A replayed wake message is screened as the entry it replays.** When the wake message folds into the parked entry, the deployment's prompt screen runs once, on the parked entry's redelivery (post-claim), not on the wake message (pre-claim) β€” exactly what `setPendingSteer` of the same steer followed by a message-less wake does.
74
+ - **Hard-breaking (open to veto).**
75
+ - **The store contract gains the record-id obligation** β€” changed: every `MailboxStore` persists `id` and, inside the append's critical section, answers an id it holds through `judgeMailboxAppendById` (held seq / `mailbox.duplicate_record_id`) and refuses a malformed id with `mailbox.invalid_record_id`; who is hurt: a backend outside this package (@server's SQL store, @dgx if it ships one) β€” `mailboxStoreContract` has a new T1 case that is red until it does; migration: read the caller's record once with `readMailboxAppend` (it validates `peerMeta` and `id`), store the `id` column, constrain `(scope, handle, id)` among held rows, read the held rows in the append's transaction and call `judgeMailboxAppendById`.
76
+ - **The park seat re-asks** β€” changed: a rejected session-box append is appended again with the same record; who is hurt: a backend that has not met the obligation above writes a second record where today a second copy waited in process (the delivery count is the same, the twin moves into the box); migration: meet the obligation first.
77
+ - **A wake message under a parked `inputId`** β€” changed: identical β‡’ delivered once; different β‡’ `steering.duplicate_input_id` from `resume` before the claim; who is hurt: a host that resends a parked steer's id on a wake to deliver it again, or that branches on the wake's refusal codes; migration: a new instruction takes a new `inputId` (the `setPendingSteer` rule).
78
+ - **Exports.** +8 root values: `MAILBOX_INVALID_RECORD_ID_CODE`, `MAILBOX_DUPLICATE_RECORD_ID_CODE`, `MAILBOX_RECORD_ID_MAX_CHARS`, `MAILBOX_REPLAY_FACETS`, `readMailboxRecordId`, `readMailboxAppend` (one read of a caller's record: validated, detached β€” what a backend judges and stores), `judgeMailboxAppendById`, `judgeParkedSteerRepeat`; +1 type `MailboxReplayFacet`; `MailboxStoreErrorCode` +2 members. None removed.
79
+ - **Consumers.** @server: the SQL mailbox store implements the obligation (the kit case names it); the daemon's wake handler gets `steering.duplicate_input_id` from `resume` for a colliding wake message. @dgx: a store you ship runs the kit. @cli / @test: the `parked` receipt sentence changed; a wake that replays a parked steer delivers it once.
80
+ - **Pins.** `test/backlog988-park-idempotent.test.ts` β€” both bundled backends behind a store that loses the reply of a committed append: the seat answers `parked_durably` with one record under the frame's key and nothing in process (peer-words and engine-frame forms); a genuine fault parks in process with one disclosure; a second seat parking the same frame writes no second record; two frames keep two ids; the store's id judgment facet by facet, the malformed ids, the round trip and the acked-id-is-free cell; end to end over a real Runner per backend: the worker's receipt is durable and the leader's next run reads one cross-session frame and no `<agent-message>` twin; #2705 β€” replay delivered once, a different record refused pre-claim with the row untouched, a fresh id delivers both in order. `test/backlog969-main-park-seat.test.ts` re-pinned on the receipt sentence.
81
+
82
+ ### What a literal printer spells for a shell is read for what it refuses β€” `echo 'cat ~/.ssh/id_rsa' | bash` is refused by the deny table again; nothing that text reads clears the produced-text question (#1539 S1, design/1539, ruled C-R872; behavior narrowing, open to veto; hard-breaking: none; closed sets: none; exports: no new name β€” the exported type `ShellReadSegment` gains the optional member `printed`, and each entry of its `stdin` the optional member `printed`) (@server @cli @test)
83
+
84
+ - **Before.** Since 7.49.0 (#1505) a text a program produces for a shell β€” what a pipe carries, what a `<(…)` prints, a `< <(…)`
85
+ input β€” is not read at all: the call is one `unverifiable_shell_text` card (bypass-immune; a person may confirm it), whatever
86
+ the text says. 7.47.0 – 7.48.0 read a literal printer's text and refused `echo 'cat ~/.ssh/id_rsa' | bash` by the deny table;
87
+ that refusal became a card a person can approve. The literal reading was removed because it was used to EXEMPT harmless text,
88
+ and a redefined printer, a second writer on another descriptor or an inherited DEBUG trap made the stream differ from what the
89
+ printer's words say.
90
+ - **Now.** The read station also reads what a LITERAL PRINTER spells for the shell β€” one simple `echo` / `printf` of literal
91
+ words with no redirection (no backslash; a `printf` format with no `%` and no option), as the producer before a pipe, the body
92
+ of a `<(…)` script file or of a `< <(…)` input β€” and only a deny hit in it counts: that refuses the call; whatever else the
93
+ text finds, or fails to find, counts for nothing. The text is never known to be what the shell receives, so it is planned
94
+ beside the texts that run (`ShellReadSegment.printed`), never among them (`nested`), and judged on its spelling alone (no
95
+ environment is asked about it: a lookup it cannot finish cannot make the command's answer silence). The removal guard, the
96
+ standard-device marks, the kill guard, the write guards and the card do not read it, and the produced-text question stands
97
+ whatever it finds. The reading is monotone: it can only refuse β€” making the text look more dangerous only gets the call
98
+ refused. (The command's own re-entered texts β€” a `-c` string, a here-document, a here-string β€” keep their reading: their deny
99
+ relation, a hit or an unanswered lookup, counts.)
100
+ - **Behavior narrowing (open to veto).** *What changed*: `echo 'cat ~/.ssh/id_rsa' | bash`, `printf 'cat ~/.ssh/id_rsa' | sh`,
101
+ `bash <(echo 'cat ~/.ssh/id_rsa')`, `bash < <(printf 'cat ~/.ssh/id_rsa')` β€” a literal printer's text naming a deny-listed
102
+ path, on either face β€” are refused by the deny table on every arm (no card; the 7.48.0 refusal) where they were one
103
+ approvable card. *Who is hurt*: a command whose printer is redefined or whose stream is something else than the printer's words
104
+ (a function or an alias of `echo`, a trap), or whose shell does not run what it reads (`… | bash -n`, `… | bash 0<&-`), and
105
+ that would not read the path is refused too β€” the reading is the printer's words, not the stream; a path the text spells
106
+ through a link is not followed (the spelling is judged). *Compensation*: a text that does not read the path need not spell
107
+ it (drop the path from what the printer prints); a check that runs nothing (`bash -n`) can be run on a file; the deny table
108
+ is the deployment's to edit.
109
+ - **Unchanged (pinned).** A harmless printed text keeps its card (`echo 'echo hi' | bash`); every form the literal exemption
110
+ could not close (a function of the printer's name, `enable -n`, `BASH_ENV`, a second writer on another descriptor, an
111
+ inherited DEBUG trap, a here-string in the substitution body, a named `coproc`) keeps exactly one card, bypass included;
112
+ `echo 'rm -rf ~' | sh` stays `unverifiable_shell_text` (the removal guard reads what runs); a format the reader does not read
113
+ (`printf 'cat %s' ~/.ssh/id_rsa | bash`) keeps the card; a printed deny path no shell runs (`… | cat`) is no refusal.
114
+ - **Limits (stated).** Only the three producers above are read; `bash -c "$(echo …)"` and `… | xargs -I{} bash -c '{}'` are
115
+ candidate slices. What a stream carries beyond the printer's words (a trap's output, a second writer, a file's content) is not
116
+ read, and the printed text is judged on its spelling (a link in it is not followed: `echo 'cat ./link' | bash` stays the card
117
+ where `bash -c 'cat ./link'` is refused; a pattern is judged by its spelling, as the rows judge any pattern β€” `echo 'cat
118
+ ~/.s*/id_rsa' | bash` is refused): such a call stays the approvable card (KL-1417-c). The printed
119
+ text rides where the shell's input goes, so it is also read where another reader drains the stream first (`… | { read l;
120
+ bash; }`), where a here-document stands beside the pipe (`… | bash <<'EOF'`), and in a `-c` child that reads it (`… | bash
121
+ -c 'bash'`) β€” refusals in the safe direction.
122
+ - **Consumers.** @server: the exported type `ShellReadSegment` gains the optional member `printed` (additive: a value built
123
+ without it is the same plan; no engine seat hands a plan to a host). @cli: a refusal now arrives
124
+ where a card did for the forms above β€” the deny refusal's sentence and `read_path_denied` details, as for `bash -c '…'`. @test:
125
+ `core-1505-streamfed-shell-recheck` keeps its must-judge cell (bypass Γ— an unread produced text is still a card); add
126
+ `echo 'cat ~/.ssh/id_rsa' | bash` β‡’ refused, no card.
127
+ - **Pins.** `test/backlog1539-printed-text.test.ts` (β‘  the refusal back, five forms Γ— three arms Γ— two faces; β‘‘ seven hole forms
128
+ keep one card on every arm; β‘’ controls) and `test/backlog1539-printed-plan.test.ts` (β‘£ the plan: `printed`, never `nested`; the
129
+ producers not read; `printedText`). Re-pinned: `backlog1417` β‘§ (`echo 'cat ~/.ssh/id_rsa' | bash` refused by the deny table,
130
+ as through 7.48.0).
131
+
132
+ ### A delegated child opens on `classic.SubagentStart`, not `classic.UserPromptSubmit`: the prompt a parent's model wrote for its child is no longer screened as a person's prompt (#1500, design/1500, C-R888; behavior narrowing; hard-breaking: two readings, three sentences each below (the prompt screen; the mod-package contract), open to veto; closed sets: one station row; exports: +2 types)
133
+
134
+ - **Before.** A delegated child's objective β€” the prompt the parent's model handed the Agent tool (and a workflow, fork or retained child's next prompt) β€” passed the child leg's `classic.UserPromptSubmit` screen as `source: "objective"`. A deployment's intercepting prompt filter therefore refused every child whose prompt it did not like, and its context was injected into children; the reference runs that hook only on what a person submits (CC 2.1.309: the prompt-submit path and cross-session / poll intake; the subagent runner raises no UserPromptSubmit). `classic.SubagentStart` was named in the event table but had no station.
135
+ - **Now.** Both ends of a leg read one table (`legEventsOf`; `stopEventOf` is retired into it). The delegation fact picks the lifecycle: a delegated child opens on `classic.SubagentStart` and ends on `classic.SubagentStop`, a top-level leg ends on `classic.Stop`. Who wrote the objective picks the screen: a person's prompt passes `classic.UserPromptSubmit` β€” a top-level leg's objective, and a retained child's resume through its steer handle (the deployment routes an operator's words there; a trusted run fact, `RunInternals.operatorObjective`, says so; that leg is screened first and then opens on SubagentStart); a delegated objective its delegator wrote (a parent model's Agent prompt, a workflow script's, a peer's SendMessage resume) is not screened as a person's. `classic.SubagentStart` is raised on the child's own leg as it opens on its objective, before its first request β€” never on a top-level leg, never on a checkpoint resume. Its `e` carries `agentId` and `agentType` (both pinned; `agentType` is absent on a workflow-lane agent) and the base; no prompt. Its answer is `{ additionalContext? }`, delivered ahead of the child's prompt as a `<system-reminder>` (the shape UserPromptSubmit's context had). It never keeps a child from starting (CC: a SubagentStart hook "can't block subagent creation"): failure column `skip`, abort `immediate`; a handler that throws or overruns is skipped and reported on `onError` (`phase: "hook"`); an answer carrying `block` is an answer the station cannot take β€” skipped and reported, the sentence pointing at `classic.PreToolUse`; a cancel during it ends the child as any cancel does (no `prompt_blocked_by_hook`).
136
+ - **A resume's origin is its caller's.** `createSubagentResume` hands out one face per origin: the face it returns speaks for its creator (a SendMessage: a peer; otherwise an operator), and the steer handle a resumed cycle re-emits is always the operator's face. Before, a handle re-emitted by a SendMessage-woken cycle reused the peer's face, so an operator's words sent through it were framed as a teammate's (`teammate resume`) β€” and, with this change, would have skipped the person's-prompt screen; now they are framed `operator resume` and screened.
137
+ - **Where a child's prompt is refused.** The parent's `classic.PreToolUse` on the delegating `Agent` call reads `input.prompt`; its deny keeps the child from starting and answers the parent, and a throwing handler refuses the call (fail-closed) β€” the reference's seat, unchanged here, now the documented one. A workflow agent's individual prompt has no such seat until `agent.spawn` (#2457).
138
+ - **Hard-breaking, open to veto (@server @cli @client-core).** What changed: `classic.UserPromptSubmit` no longer sees a delegated objective its delegator wrote (an operator's resume of a retained child is still screened). Who is hurt: a deployment that screened or refused child prompts, or injected context into children, through UserPromptSubmit (a settings-hook bridge mapping the reference's `UserPromptSubmit` command hooks onto `classic.UserPromptSubmit` now matches the reference's own reach; a probe pinning `source: "objective"` on a child leg turns red). What to read instead: refuse at `classic.PreToolUse` with `tool === "Agent"` (`input.prompt`); inject at `classic.SubagentStart` (`agentType` is the reference's `agent_type` matcher word) β€” a bridge carrying the reference's `SubagentStart` hooks has a station to land on from this release.
139
+ - **Closed sets / contract.** `MOD_EVENT_TABLE["classic.SubagentStart"]` gains its station (`skip` Β· `immediate` Β· pinned `agentId`, `agentType`); `ClassicEventMap` gains the key; `KERNEL_CONTRACT_VERSION` 4 β†’ 5 (`@sema-agent/mods-kernel`: a host comparing two kernel copies for equality sees the raise; 7.58.0 shipped 4). A consumer holding the set of raised events (client-core's generated table) gains one row.
140
+ - **Hard-breaking, open to veto: a mod package written against contract 4 is refused (@server @cli @test @client-core).** What changed: `loadModPackage` loads only a package whose `hooks.json` states `"contract": 5` β€” any other value is refused with `config.mods_invalid` naming `hooks.json` and the contract (`src/core/mods/package.ts:72-73`); the 7.58.0 engine's kernel was contract 4, so every package written for it is now a refused one. Who is hurt: every mod package written for 7.58.0 on 7.59.0 β€” a deployment loading a real package (server S-2388), the CLI's package leg (MODS155) and test's real-package L1 fixtures (C-R915); this repo's own three fixtures (`test/fixtures/mods/{diff,sec-default,telemetry}/hooks/hooks.json`) were raised to 5 for the same reason. What to do instead: set `"contract": 5` in the package's `hooks.json`; contract 5 adds only the `classic.SubagentStart` station (`src/core/mods/kernel/events.ts:28-29`), so a package whose handlers do not name that event needs no other change.
141
+ - **Exports.** +2 types: `SubagentStartEvent`, `SubagentStartResult`.
142
+ - **Known limit.** KL-1500-a: a retained child's every new leg re-raises SubagentStart and prepends its context again (the reference injects once while the copy is still in the child's context) β€” the same count UserPromptSubmit gave those legs before.
143
+ - **Pins.** `test/backlog1500-subagent-prompt-hooks.test.ts` β€” real Runner, a parent delegating once: an intercepting UserPromptSubmit filter screens the root only and the child starts (base: it screened and refused `CHILD go`); the root's screen still fails closed; SubagentStart raised once for the child with its id, type and identity, never for the root; its context ahead of the child's prompt and never in the root's; `agentType` pinned; `block`, a throw and an overrun each skipped and reported with the child started; a cancel ends the child as an aborted run, never as a held prompt; PreToolUse on the Agent call reads the prompt and its deny or throw keeps the child from starting; a fork child opens on SubagentStart unscreened; an operator's resume through the steer handle is screened (its block keeps the words from the child and the leg never opens) and, let through, opens the leg on SubagentStart again β€” screen first, start second, the start's context leading; a SendMessage-woken background child opens on SubagentStart unscreened, and the handle that cycle re-emits screens an operator's words; the table's ends; the station's columns and the contract number. `test/mods-classic-redo.test.ts` S3 reads the stop end off the same table; `test/delegation-lifecycle-seat.test.ts` makes its non-completed child fail at the model instead of blocking it with a UserPromptSubmit filter.
144
+
145
+ ### A stream frame is read once, by the wire's shape, at the parser's door β€” a member in no shape is absent and said, never coerced, dereferenced or run (#1529, design/1529; behavior change and security narrowing, open to veto; hard-breaking: none; closed sets: none; exports: none β€” the reader lives in `src/brain/stream-shared.ts`, not index-exported) (@server @cli @test)
146
+
147
+ - **Before.** Each read site of an OpenAI-family chunk and an Anthropic event guarded (or did not guard) its own member: a `data: null` frame, a `content_block_delta` with no `delta`, a `content_block_start` with no block or `tool_calls: [null]` threw inside the parser and the turn failed with its streamed text and usage lost β€” after the stream's end too, losing a finished turn; a `choices` object, a `tool_calls` object, a `usage` number were dropped in silence; `delta.content` as an array became `"[object Object]"` in the answer, a `text_delta` number became digits; a usage count that was a string reached the usage seats as a string (`totalTokens` `"1002"`); an argument fragment that was a number or an object was coerced into the call's arguments β€” a numeric fragment between two string fragments ran the call with arguments the model never sent (both wires); an Anthropic `stop_reason` that was not a string ended the turn as a silent clean stop.
148
+ - **Now.** The OpenAI-family parser reads each chunk once (`readChunk`), the Anthropic parser each event once (`readEvent`), through one member reader: an object, an array, a string, a count β€” `null` and absent state nothing; any other value reads as absent and its loss is said where that member's loss is already said. A content-bearing member in no shape (or a frame that is not an object) counts the frame with the unparseable ones β€” the one dropped-frame note to the model (its sentence now reads "were not valid JSON or not in the stream's frame shape; what could not be read was dropped") and the person's `task.tool_turn_incomplete` (`bad_frame`). A call-stream member in no shape β€” or a container of the call stream (`choices`, the choice, its `delta`; an Anthropic block frame not placed on a text / thinking block, an event object with no `type` word) β€” leaves none of the response's still-open calls runnable: a call that closed in full before keeps its cached call, every call still open lands in the invalid-arguments drop. An Anthropic `error` event's envelope members are read as words (a member in no shape no longer throws while the error is worded). A usage in no shape makes the turn's usage unknown (`usageMissing`). An ending seat holding a non-word is an ending in no word (`?`) on both wires β€” the Anthropic wire now carries `finishReasonUnknown: "?"` and the run announces `route.finish_reason_unknown`. After the stream's first ending a frame that offered nothing readable and held a member in no shape is refused like any late frame (`route.stream_end_ignored`, content `?`); a late offer is still named by what it offered. A falsy `finish_reason` still states no ending, and a provider that spells its stop word `?` is a word, not a non-word; a stream whose every frame is in its shape reads as before (pinned on both wires, including the nulls real gateways send).
149
+ - **Behavior change (open to veto).** More turns carry the dropped-frame note and `task.tool_turn_incomplete` (`bad_frame`); more turns carry `usageMissing`; the Anthropic wire can now raise `route.finish_reason_unknown` (`?` only β€” an unknown `stop_reason` WORD still folds to a stop, a named follow-up). **Security narrowing (open to veto).** A tool call whose argument stream held a fragment in no shape no longer runs.
150
+ - **Consumers.** No new code, key or detail member: `task.tool_turn_incomplete`, `route.finish_reason_unknown`, `route.stream_end_ignored` and `turn_end.usageMissing` carry their existing shapes on more occasions. @server @cli: a pin or renderer that matched the old note words in full (`"were not valid JSON and were dropped"`) reads the new sentence; the first words (`"N provider stream frame(s) were not valid JSON"`) are unchanged. @test: the fake-gateway cells below are the black-box forms.
151
+ - **Pins.** `test/backlog1529-chunk-decoder.test.ts` β€” a local fake gateway fed frame by frame through the real `fetch`: O1–O14 (OpenAI-family: `data: null` before / after the end, the r4 / r7 controls, `choices` / `tool_calls` / `usage` / `delta.content` / a usage count / an argument fragment in no shape, one note for many frames and one person notice per run, an all-in-shape control, the gateway nulls control) and A1–A12 (Anthropic: `data: null`, a missing `delta` / `content_block`, a numeric `text`, a numeric `stop_reason`, a numeric usage, a numeric `partial_json`, a typeless event carrying a fragment, an `error` envelope in no shape, a late `message_delta` in no shape, a late `data: null`, a reference-endpoint control, a control); S1 the reader, the ending word and the one sentence. Re-pinned: `test/backlog7490-brain.test.ts` (a `tool_calls: {}` frame β€” the turn still goes on and nothing runs; it now carries the note).
152
+
153
+ ### A credential-origin refusal names the no-credential door β€” the request's fix hint and the run's announcement carry one clause: an endpoint that takes no credential is handed none (#1853; no behaviour change β€” the wording of two refusal texts; hard-breaking: none; closed sets: none; exports: none in the package root)
154
+
155
+ - **Before.** `route.credential_origin_mismatch` told an operator two ways out β€” change the entry's credential reference together with its `baseUrl`, or point the entry back at the bound origin β€” and, for a provider that only moved domains, a restart. A local multi-node catalog that hands every node the placeholder word `EMPTY` met the refusal on its second node and neither way applied: the nodes need no credential, and the way out the law serves (hand the node an empty key; the integration guide says "none where the endpoint needs none", the refusal said nothing) was in neither text. The run's announcement was worse: it said the deployment "has to give the model a credential for" the new host.
156
+ - **Now.** One clause, `KEYLESS_EXIT` (`src/brain/route-adjudicator.ts`), is in both texts: the verdict's `fixHint` β€” the text of the request's own failure (`[invalid_request] route.credential_origin_mismatch: …`) and the `fixHint` (and the sentence that ends the message) of a derived seat's fallback notice β€” reads "…or point the entry back at <origin>; if the endpoint takes no credential, hand it none β€” answer an empty apiKey and no credential header (this works under any brain; a brain configured with neither a baseUrl nor a credential of its own also accepts no apiKey at all), because a placeholder word handed in its place is still a credential and binds like any other; a binding lasts as long as the engine process, …"; the run's announcement (`src/core/runner/credential-origin-seat.ts`) ends its advice with "If <origin> takes no credential, <the same clause>." The three older suggestions are unchanged word for word.
157
+ - **What it does not say.** The clause is the same for every refusal of this code: the engine cannot tell a placeholder from a real key by its spelling and does not try (a short real key and `EMPTY` bind alike), so the text is advice, not a diagnosis. The door it names is read off the law: an empty `apiKey` is a per-model answer with no secret, so it binds nothing, never falls back to the brain's own key or root, and none of the three lanes writes a key header for it; leaving the answer out reaches the same door only under a brain with no credential of its own whose `baseUrl` is absent or is the endpoint itself β€” under a brain with a root on another host it is refused `route.credential_missing`, under one with a key or credential header meant for another host `route.credential_mismatch`, and under one whose key or credential header is paired with this very endpoint it is the brain's own credential that goes out. The entry and the hook's answer must carry no credential header either: a placeholder carried in a header binds like one carried in the key. The other pairing refusals (`route.credential_mismatch`, `route.credential_missing`, `route.credential_answer_conflict`) keep their hints.
158
+ - **Known limits.** KL-1821-c stays: a value handed over on two origins still refuses the one sent second, `EMPTY` included β€” that is the law, unchanged; the row now says the refusal names the door.
159
+ - **Consumers.** No one is asked to change. @server @cli @web-admin: a program that matches `fixHint` or the announcement's `message` as text matches each older sentence still (kept word for word and in order; one clause is inserted, so a program that compares the whole text sees it); `detail` is unchanged (`{ modelId, boundOrigin, requestOrigin, sessionId, runId }`).
160
+ - **Pins.** `test/backlog1821-credential-origin-binding.test.ts` K1 – K5 (the second `EMPTY` node's request fails naming the door, and both doors the text names serve it under a bare brain with no credential header on the wire; the hint holds the clause beside the three older suggestions verbatim and the other three pairing hints do not hold it; the real Runner's failure and its one user-audience notice carry the same clause, the notice's `detail` keys unchanged; K4 β€” under seven brain configurations (bare; a root on another host, alone / with a key / with a credential header; the endpoint itself as the root, alone / with a key / with a credential header), with the placeholder carried in the hook's `apiKey`, in its `Authorization` header and in the entry's own β€” the second node is refused naming the door, the empty key serves it under every brain with no credential header and none of the brain's own, and leaving the answer out does what the law says for that brain; K5 β€” the same seven configurations on the openai, anthropic and open-responses lanes against a stubbed transport).
161
+
162
+ ### A blank credential is the keyless door, one reading for every source β€” a key or a credential header with nothing but white space in it is no credential: its source keeps its rank and nothing of it goes out, and the route a refused request states is what it carried (#1882, ruled C-R894 and its note 1; behavior change, open to veto; hard-breaking: none β€” one exported function's output shape narrows, open to veto; closed sets: none; exports: +1 root value `isBlankCredential`) (@server @dgx @web-admin)
163
+
164
+ - **Before.** Three readings of "an empty credential". The empty `apiKey` (`""`) was the keyless door: the hook answer or `config.apiKey` that held it kept its rank, no key header went out, nothing was bound. A key of white space only (`" "`, `"\t\n"`) was a key: the lanes' truthy lock wrote it (`Authorization: Bearer <spaces>`, which `fetch` sends as `Authorization: Bearer`; `x-api-key: <spaces>`, sent empty; a non-Latin-1 space made `fetch` throw and the request failed), and beside the lane's own key header it was a conflict (`route.credential_answer_conflict`). A credential header whose value was blank rode as an empty header. The withheld table's entry rule already read white space only as no credential, and the memory distiller's chat seat refused `""` but took a white-space key.
165
+ - **Now.** One predicate, `isBlankCredential` (a string `String.prototype.trim` empties β€” the empty string, white space only), read everywhere the question is asked. `resolveRouteCredential` reads what was handed ONCE: the rank is still the source's presence (a key handed, a credential header named β€” no fall-through), and the credential it returns holds only what rides β€” a blank key is no `apiKey`, a bag whose credential headers are all blank is no `headersBorne` (`{ source: "per-model" }` carries nothing). So every first-party lane's key lock writes no header for a blank key, no identity is bound, a blank key beside the lane's own key header conflicts with nothing (the header is the credential and rides), the header strip keeps a blank credential header off the wire whichever source it came from, and the route a request states (`requestRouteOf` β†’ `AssistantMessage.apiErrorRoute`, `terminal.detail.route`) is `{ credentialSource: "absent" }` when nothing went out. The withheld table's entry rule, the credential intake (a blank value is not said: no request carries it) and the distiller's chat seat (a blank key is no key) read the same predicate. A key that is not blank rides as written, padding included. The published conformance corpus is unchanged except the `per-model-empty-string-key` intent sentence; its expectations are the same.
166
+ - **Who sees a difference.** A request handed a white-space key (per-call, from the hook, or as `config.apiKey`) now goes out with no key header instead of a junk one; a white-space key beside the key header now rides the header instead of being refused; a blank credential header no longer goes out empty; a provider refusal after a blank key or a blank credential header states the absent route (it said `carrier: "apiKey"` / `"header"`); the distiller's chat seat refuses a white-space key as it refuses `""`; a white-space `config.apiKey` no longer prints the `config.credential_not_withheld` line. `resolveRouteCredential({ optionsApiKey: "" })` returns `{ source: "per-model" }` (it returned `{ source: "per-model", apiKey: "" }`), and a blank `configApiKey` likewise loses its `apiKey` member (open to veto).
167
+ - **Consumers.** @server: `src/hooks/hook-llm.ts` writes `x-api-key` from `credential.apiKey ?? ""` for a per-model credential β€” the same empty value as before for a blank key; `model-route-gap.ts` reads `""` as unset but white space as set (`declaredValue`), and reading the same predicate (`isBlankCredential` from the root) makes its env reading the engine's. @dgx: the keyless door for several local nodes is unchanged β€” hand no key, or a blank one; white space now reads as `""` does. @web-admin: no action; a catalog field saved as white space is keyless, as an empty one is.
168
+ - **Pins.** `test/backlog1882-blank-credential.test.ts` β€” real Runner over real local listeners: a blank hook key (three spellings), a blank `config.apiKey`, a blank hook credential header and a blank `config.headers` credential header are served with no credential header and no deployment key; a blank key beside the key header rides the header; a blank key and a blank credential header bind nothing (the entry moves origin and is served keyless twice); controls: no key β‡’ the deployment key rides, `""` reads as white space does, a padded key rides; every lane's lock and every lane's stated route after a 401 (OpenAI, Anthropic, Open Responses); the predicate from the package root, `keyCarriedBy`, resolution's rank and carried shape, `requestRouteOf` on a hand-built credential, the withheld table's refusal and the distiller seat's. Re-pinned: `route-adjudication` (a blank per-call key resolves to `{ source: "per-model" }`), `backlog1754-held-values` (a blank construction key is not said). `backlog1399-terminal-detail-projection`'s "a route that is not absent leaked a credential" cell now holds for blank keys too.
169
+
170
+ ### A host moves a per-model credential's origin binding without a restart β€” `rebindCredentialOrigin(model, perModelAuth, config, onNotice?)`, announced to the operator as `route.credential_rebound` (#1844; additive verb; hard-breaking: one notice word, two sentences reworded; open to veto)
171
+
172
+ - **Before.** (7.52.0, #1821) A per-model credential (the per-model hook's key, a credential header on the entry) is bound to the origin of the first request the engine sends carrying it; a catalog that moves the entry to another host with the same credential is refused there (`route.credential_origin_mismatch`). Inside a process nothing could move a binding: a provider that only changed domains and accepts the same key on the new one needed an engine restart β€” also after the control plane's audited "this key is valid for the new address" (web-admin `rebindCredential: true`), which the engine never saw.
173
+ - **Now.** `rebindCredentialOrigin(model, perModelAuth, config, onNotice?)` (package root) is the one way a binding moves inside a process. The host hands the entry as it is in force now (`id`, `baseUrl`, `headers`), the per-model hook's answer the request will get for it (`{ apiKey?, headers? }`, or `undefined` when the entry's own credential header is the credential) and the brain's pairing config (`{ baseUrl?, laneDefault? }`, as for `admitRouteRequest`). The engine resolves the credential itself, by the request's own resolution (the answer outranks the entry's headers; the brain's deployment credential is never the verb's), and binds every secret it carries β€” the key and each credential header of the winning bag β€” to the origin the entry's request goes to: the root judged by the brains' own root judge (`resolveRequestRootOf`), the origin folded as the request gate folds it. It returns `{ origin, previous, changed }` (display spellings). A call that changed the table announces `route.credential_rebound` once β€” audience `operator`, minter `engine`, `detail: { modelId, origin, previous, occurrenceId }`, through `onNotice` (else as the notice's line on `console.warn`), never a credential or a digest of one; a call that finds every secret already there writes and announces nothing. Refused with `config.invalid_argument`, nothing written: an entry with no per-model credential, an answer that carries no secret (the keyless door), an entry whose request has no servable root (none at all, a non-http(s) root, a fragment, userinfo β€” the lane default the host hands judged like the entry's and the brain's roots when it is the root chosen). A non-string id, URL half or key is a `TypeError`. The notice is delivered just before the write, in the same synchronous step: a console that throws in the no-sink arm leaves the table as it was and the call throws (a retry rebinds). The rebind moves the credential, not the entry: another entry carrying the same value and still targeting the old host is refused from then on (one credential, one root, KL-1821-c). A request the gate judged before the rebind and commits after it is judged again at its commit and refused there.
174
+ - **Unchanged.** Nothing a request, a catalog swap or an entry's own members carry moves a binding: re-publishing the moved catalog stays refused (the #1821 W2 shape, kept as this change's control). `adjudicateModelRoute` and `routePairingStatus` stay reads. `__resetCredentialOriginBindings()` stays the test seam (it empties the whole table; the rebind moves one credential). A restart still empties the table.
175
+ - **Hard-breaking.** (1) *What changed:* `EngineNoticeCode` gains `route.credential_rebound`. *Who is hurt:* a consumer that keys a record by `EngineNoticeCode` β€” a notice allowlist or router, an audience table, a renderer β€” gets a compile error until it gives the word a row. *Migration:* add the row (operator; minted outside any run, so it carries no `sessionId` / `runId`). (2) *What changed:* two sentences say the binding's other source and the new way out: the refusal's fix (`route.credential_origin_mismatch`'s `fixHint`, carried in the request's failure text) now reads "bound to X, the origin it was first sent to or the host rebound it to … needs the host's explicit rebind (rebindCredentialOrigin) where the host offers one, otherwise an engine restart", and the run's `route.credential_origin_mismatch` notice sentence says "(the host it was first sent to, or the one the deployment rebound it to)". *Who is hurt:* a test or reader that pins those sentences' words. *Migration:* re-pin; codes, audiences and every `detail` member are unchanged.
176
+ - **Consumers.** @server: when applying a catalog whose control plane recorded an audited rebind for an entry, call `rebindCredentialOrigin(entry, keyResolver(entry), { baseUrl: declaredRoot })` with the entry of the catalog generation in force (dedupe by the control plane's own event; the verb's target is the entry as handed, so a stale copy rebinds to a stale host, KL-1844-a), and give `route.credential_rebound` its notice-wire row (operator, logs only). @web-admin: publish the audited `rebindCredential` act as a signal the server can read beside the catalog (which cell is the control plane's to choose); until the server consumes it, the console's "confirm rebind" is still met by the engine's refusal until restart. @dgx: a host that runs the engine directly can call the verb; `EngineNoticeCode` +1.
177
+ - **Exports.** +2 root names: `rebindCredentialOrigin` (function, tier advanced), `CredentialRebind` (type). Nothing removed.
178
+ - **Limits (stated).** KL-1844-a (ordering and replay are the host's), KL-1844-b (the notice is the table's account, not an audit of attempts; the call's return value is the result), KL-1844-c (the rebind shares the table's one write, so it refreshes and, at the 16 384 bound, evicts like a send). KL-1821-a (no in-process rebind) is closed.
179
+ - **Pins.** `test/backlog1844-credential-rebind.test.ts` (real Runner, real OpenAI brain, real local listeners: R1 moved β†’ refused β†’ rebound β†’ served at Y with the key, X untouched, one operator notice; R2 a rebind moves, pointing back is refused naming Y; R3 control: no explicit act, three re-publishes stay refused, nothing announced; R4 a second rebind changes and announces nothing; R5 rebind ahead of the first send; R6 the refusal arms and the `TypeError`s write nothing; R7 a shared key moves for both entries; R8 the fix names the rebind and the restart; R9 key + gateway header both move; R10 judged before, committed after β‡’ refused at commit; R11 an entry with no root rebinds to the brain's declared root; R12 the `console.warn` arm, the audience and minter rows; R13 an entry's own credential header; R14 the hook's answer outranks the entry's header; R15 a console that throws in the no-sink arm leaves the table unmoved and a retry rebinds; R6 also refuses a lane default that is not servable). Fourteen of the fifteen are red on the base tree (the verb did not exist); R3 is green there by design β€” it is the positive control for the rule this change must not move (a mutation that lets a request move its binding turns it red).
180
+
181
+ ### Where the shell releases end a substitution body is read off their own parsers: the 4.0 – 5.1 counting pass is ported, every `$( )` / `<( )` / `>( )` / `${ list; }` body is compared, and an arithmetic command reads no here-document (#2792, #2787, #2788, #2789; behavior narrowing and security narrowing, open to veto; hard-breaking: none; closed sets: none; exports: none) (@server @cli @test)
182
+
183
+ - **Before.** The previous section's comparison read the counting pass of bash 4.0 – 5.1 through four approximations, and a reading that ran off the end of the text counted as agreement β€” so where an approximation was wrong the text was read as data although a release closes the body elsewhere and runs what follows (a document line ending in a backslash, a comment line right after a comment that followed a word, a comment right after a nested substitution, a quote in a here-document header's comment β€” that last one introduced by the previous section). A body holding no here-document was not compared at all, and the same comment rule leaves such bodies open to the same split. Bash 3.2 – 5.2 read `${ list; }` as a parameter expansion ending at its first `}` and run the lines after it; a `$((` that is not arithmetic was delimited with comments read, where 4.2 and later count none; a `<( )` was not compared with the scanner 3.2 – 4.2 re-read it with as the word expands; `((…))` was read as holding here-documents. Separately, the previous section refused texts every release delivers alike (a `#` comment after a word holding a `)`, a pair of quotes after a commented `)` in double quotes).
184
+ - **Now.** One rule, every body: a body is read only where each release's reading closes it at the same place, or never closes it (that release refuses the whole command). Bash 4.0 – 5.1's counting pass is ported state for state from their parsers (`src/shell/counting-pass.ts`, one flag row per release; a state it does not follow claims no close), 3.2's count and its expansion-time scanner, the count with no comment where a release reads so (`$((`, `<( )` / `>( )`), and the releases before 5.3 for `${ list; }`; bash 5.2 and later are the lexer's own reading. Two places the releases rewrite a body before it runs are refused outright: a backslash-newline in a here-document line of the body, and a comment ending in one. An arithmetic command β€” bash's own test, its matched pair followed by `)` β€” reads no here-document and no comment (two subshell parentheses still do). In double quotes, 3.2's early close is harmless only while its double-quoted word runs on to the same close. A refusal where the readings split a body the full reading reads a here-document in carries `undelimited_substitution_heredoc` (now also for `${ list; }`), whose sentence says the way out; a comment ending in a backslash-newline keeps `undelimited_substitution`.
185
+ - **Measured.** Ten binaries (3.2.57, 4.0 – 4.4, 5.0 – 5.2 built from the GNU releases with every published patch, 5.3.15) over the review's shapes, this change's table (`test/fixtures/backlog2792-measured.json`) and three random generators: no text the lexer reads has a release run what the reading holds as data (counts in the car receipt); the baseline reads such texts on every generator. Limits: KL-2792-a (the two rewrite places are refused even where every release agrees), KL-2792-b (the model's boundary). KL-1547-a is closed.
186
+ - **Who is hurt.** A command whose substitution body the releases split differently is refused where it was read; a commit message with a line ending in a backslash inside `$(cat <<'EOF' … )` is refused (way out: `git commit -F -`). In the loosening direction, the previous section's refusals of a comment after a word and of quote pairs after a commented `)` in double quotes read again; `((x<<2))` and `for ((…<<…))` read as arithmetic. @server @cli: the `unverifiable_shell_text` card text (the heredoc sentence is reworded, still naming `git commit -F -`). @test: the table is the differential to re-run on another host's bash.
187
+ - **Pins.** `test/backlog2792-lexer-shapes.test.ts` (the measured table, the host's bashes live, what every release delivers read, the release table and its merging, structure, a 1 MiB body in linear time, a seeded random differential); `test/backlog1547-heredoc-prefix.test.ts` re-pinned where the previous section's approximations pinned the wrong reading (its `${ list; }` block, a double-quoted row) and its structure cell; `test/backlog994-s2-one-lexer.test.ts` FIX4 re-pinned (the `${ list; }` forms the releases before 5.3 end at an earlier `}` are refused; 5.3's own reading of them is unchanged); `test/backlog1504-shell-words.test.ts` +1 role of the one word table (`pass_keeps_reserved`, the four-letter words the 4.4 – 5.1 pass keeps its reserved-word state after; internal, not on the package root); the #1102 equivalence ledgers' one entry re-hashed for the reworded sentence; the per-mutation table is in the car receipt.
188
+ - **Linear time (#2867).** The comparison first asked about the rest of the text once per adjacent `((` (where the pair it opens closes) and once per body (which releases read the rest alike, whether a `#` follows): a run of 9 999 `(` took 2 s where it took 4 ms. Each text is now read once for all of them, for as long as the lexer reads it (a compound value or a here-document opens its own; nothing is kept afterwards); no reading changes (the lexer's output is byte-identical to the previous head on 3 182 texts). Pins: `test/backlog2792-lexer-shapes.test.ts` Z (a run of `(`, a `((` that opens no arithmetic command, many bodies, and bodies between compound values: each under a ratio bound for a text four times longer and under three times the earlier tree's time) and R (the per-text answers equal a fresh read, three places where something is carried over, a trigger a backslash-newline splits).
189
+
190
+ ### A here-document in a substitution body is read by every bash version it can run under β€” a line that merely begins with the delimiter is data unless a `)` follows it, the counting passes of bash 4.0 – 5.1 are compared with the full reading, and the refusal says the way out (`git commit -F -`) (#1547, #2777; behavior narrowing and security narrowing, open to veto; hard-breaking: none; closed sets: +1 `ParseFailureReason` member `undelimited_substitution_heredoc` (not on the package root); exports: none) (@server @cli @test)
191
+
192
+ - **Before.** Any line in a here-document body inside `$( )` / `<( )` / `>( )` that began with the document's delimiter without being it made the whole command text unreadable, whatever the line said (`EOF marker handling changed`), and the card for it (`unverifiable_shell_text`) did not say how to write the text so it is read. Separately, a body whose here-documents share one header line was read as data by the lexer where bash 4.1 – 5.1 execute part of it.
193
+ - **Now.** The rule is measured, not assumed: ten real binaries (3.2.57, 4.0 – 4.4, 5.0 – 5.2 built from the GNU releases with every published patch, 5.3.15) were run over 61 body shapes and the table is the pin fixture (`test/fixtures/backlog1547-heredoc-measured.json`). A substitution body that holds a here-document closes only where every reading closes it at the same `)` β€” bash 5.x's full reading, bash 4.0 – 5.1's counting passes (as ported by the section above, which replaces this section's approximations of them), and bash 3.2's count β€” or where one of them never closes it (that bash refuses the text). In a body in double quotes the bash 3.2 parser reads no comment, and that count is compared too (its early close is harmless only while its double-quoted word runs on to the same close; the section above). A line that begins with the delimiter and holds a `)` anywhere after it stays refused (bash 5.2 and 5.3 end the document there and run the rest of the line); a line that begins with the delimiter and holds none is data and is read as data. In a `${ list; }` body (bash 5.3) a line that begins with the delimiter and is followed, after blanks, by a `}` is refused too (reason `undelimited_substitution_heredoc`, since the section above). A text no reading can place is refused, never read as data. The security narrowing holds as measured with the section above (its generators and shapes: no text the lexer reads runs on any release); what is left is KL-2792-a / b.
194
+ - **The refusal's own reason.** Every refusal of a here-document in a substitution body now carries `undelimited_substitution_heredoc` (the other undelimited forms β€” a `case` pattern, a body nested past the bound β€” keep `undelimited_substitution`), and its sentence β€” the card's account β€” says the way out: feed the text as stdin outside the substitution (`git commit -F -`), or reword the line / change the delimiter. It fits the card's 200-character cut.
195
+ - **Consumers.** @server @cli: the `unverifiable_shell_text` card text for these texts changes (it now names `git commit -F -`); a commit written `git commit -m "$(cat <<'EOF' … EOF)"` whose message has a line beginning with the delimiter and no `)` after it is read and no longer draws that card. @test: the pin fixture's table is the differential to re-run on another bash if your host has one the table lacks.
196
+ - **Pins.** `test/backlog1547-heredoc-prefix.test.ts` β€” the measured table (every shape Γ— every version, one cell per shape: the lexer reads a text only where no measured version runs its marker), the same differential live on every bash the host has (versions it lacks skip with their column recorded), the lexer's reading of the shapes, the way out (reads, and runs as data on every host bash), the card through the real Runner lane in three arms, and a seeded random differential; the 1542 and 753 pins read the new reason.
197
+
198
+ ### The store that carries a memory scope has one reader, and the root exports it β€” a host's sync leg and a session now read and write a typed personal scope in the same store (#2818, #900 C2b; additive export; exports: +1 `resolveMemoryScopeStore`, +2 types)
199
+
200
+ - **Before.** On a deployment whose backend is a directory-pinned File store (`<root>/memory`), a session under the v2 scope contract runs its personal-plane scopes (`user:` / `userproj:` / `org:`) on a SECOND File store, `<root>/personal/memory` (the in-repo projection guard: personal memory must never be projected under a repo root). That choice was a closure inside the session assembly. A host leg working outside a session (the single-user sync executor, the operator faces) had no way to ask it and read "the deployment's backend" instead: with `MEMORY_SCOPE=user:<P>` and sync on, a round pushed nothing the sessions wrote into the global layer (or an older copy, if the pinned store held one), and pulled entries landed in the store no session reads. There is no workaround: sync on requires a typed `MEMORY_SCOPE`.
201
+ - **Now.** `resolveMemoryScopeStore({ scope, scopeContract, backend, memoryEngineDir, onIncident? })` β†’ `{ plane: "project" | "personal", backend }` answers "which store holds this scope's entries", and the session assembly uses the same reading: `src/core/memory-engine/dual-root.ts` holds the plane reading (`scopePlanesOf`) and the plane's store (`memoryPlaneStore`), and `prepare-memory.ts` builds no store of its own any more. The session face and the sync leg resolve a scope to one store from now on. `backend` and `memoryEngineDir` are the values given as `RunnerDeps.memoryBackend` / `RunnerDeps.memoryEngineDir`; `scopeContract` is a required key (`undefined` written out), because it is what moves a typed key to the personal plane. On a directory-pinned deployment a personal-plane answer is a freshly constructed File store over the personal mount (resolve once per scope and keep it); every other answer is the deployment's backend itself.
202
+ - **Bad input is refused, never folded to the deployment's backend** (`config.memory_scope_key`): a blank or non-string key, a contract other than `"v2"` / `undefined`, a left-out `scopeContract` or `memoryEngineDir` key (`undefined` written out is the statement of absence), an engine dir that is not a non-empty string, and under v2 a typed key the scope contract cannot read (its own refusal kept as `cause`). The key is read through the Runner's own normalization, so a spelling a session trims and runs with resolves to the store that session uses. Without the opt-in a typed-looking key stays opaque and on the project plane β€” the same no-sniffing rule the session applies. Two values the Runner itself still reads silently β€” a `scopeContract` other than `"v2"` (read as no opt-in) and an empty `memoryEngineDir` (read as the working directory) β€” are refused here and recorded for the Runner's own door.
203
+ - **Not changed (stated).** Where a session's planes live (`<root>/personal/memory` + `<root>/personal/.engine`), which scopes route where, and every byte a session writes; the untyped default scope (`local`) keeps living in the deployment's backend.
204
+ - **Consumers.** @server S-2394: the sync executor (`createMemorySyncRunner`, today `backend: memoryEngine.backend`) and the three operator faces read the store per layer from `resolveMemoryScopeStore` β€” the global layer `user:<P>` resolves to the personal store, a host-minted project layer (`userrepo:…`, opaque under v2) to the deployment's backend; the layer enumeration of project layers keeps reading the deployment's backend (the plane they live on). Switching a layer's store relies on #2836 (next section, same release): the layer's old cursor is refused, and the round runs from no cursor. Until S-2394 lands, typed-scope sync stays broken on a pinned File deployment.
205
+ - **Pins.** `test/backlog2818-typed-scope-sync-store.test.ts` (the real Runner over a pinned File store laid out as a single-user host does: a typed session's write lands in the store the reader names, its ledger is that store's, a sync round over it pushes the entry and a pulled entry is served by the next session; the deployment's backend pushes nothing; untyped and both-planes layouts, the personal plane as the write face of a two-plane session; a store without a directory, through a real session; fifteen bad inputs refused with nothing constructed, padded spellings read as the Runner reads them; the session assembly holds no store construction of its own).
206
+
207
+ ### BREAKING β€” a memory sync cursor is bound to the local store it was taken against, and a round refuses a cursor from any other store (#2836; `MemorySyncCursor.store` required; behavior narrowing; hard-breaking: yes)
208
+
209
+ - **Before.** `MemorySyncCursor` was `{ scope, peer, baseRevs, updatedAtMs }`, and `syncMemoryScope` checked only scope and peer. A host that moved a layer to another local store (the typed global layer moving from the deployment's pinned store to the personal store, #2818) and kept the layer's persisted cursor ran the new store against the old store's baseline: every baselined id the new store lacks is "deleted here" to the push half (`src/core/memory-engine/sync-client.ts`, the baseline-stub reconcile), so the round sent DELETEs for entries the user still has on other devices.
210
+ - **Now.** A cursor carries `store` β€” the local File store's physical root (`file:<path>`, the path its root anchor records; minted once, by `memorySyncStoreOf`). `syncMemoryScope` mints the store identity of the backend it is given, binds every cursor it returns to it, and refuses a cursor for another scope, peer or store β€” or one with no store binding β€” with `config.memory_sync_cursor_mismatch`, before any read or transport call. The scope and peer checks are the same judge and now carry the same code (their sentences keep their opening words). A store without a directory has no root to bind a baseline to and is refused as a sync plane (`config.memory_sync_store`); the sync client's documented plane was always the File store. The store identity never goes on the wire. The pull half commits pinned to the root the cursor was judged against (`applyPatches(…, { anchoredRoot })`, the session engine's own discipline): a store re-pointed and re-anchored during the transport takes no entry (`memory.target_outside_store`). Known limit (stated): the identity is the root's physical path, so a different store later created at the very same path β€” the old one moved away with its cursor left behind β€” reads as the same store.
211
+ - **The host's answer to a refusal is a round from no cursor** (then persist the cursor that round returns). It pushes what the store holds and no deletes. Its one cost: a delete made locally since the last completed round has no baseline to travel on, so that entry comes back from the peer.
212
+ - **Hard-breaking, three sentences.** *What breaks*: `MemorySyncCursor` gains a required `store` member; a cursor persisted by an earlier release (no `store`) is refused once; a round over a backend without a directory is refused. *Who is hurt*: a host that rebuilds cursors from a fixed key list (it drops `store`, so every later round is refused) and any host that syncs a non-File backend. *Migration*: persist the returned cursor verbatim, `store` included; on `config.memory_sync_cursor_mismatch` run the round with no cursor and replace the persisted file with what it returns.
213
+ - **Consumers.** @server S-2394: `cursorOf` in `src/memory-sync-client.ts` rebuilds `{ scope, peer, baseRevs, updatedAtMs }` and must carry `store` through (shape check: a string; the comparison stays in core); the layer round answers the code by running from no cursor. After the upgrade each layer's first round is refused once (its cursor predates the binding), and the global layer's switch to the personal store (#2818) is refused for the same reason β€” both are the same one-time fresh round.
214
+ - **Pins.** `test/backlog2836-sync-cursor-store-binding.test.ts` (a minted cursor names its store and is accepted over that store, also through a linked spelling; the old cursor over the personal store is refused with zero transport calls and a fresh round pushes no deletes; an unbound or garbage `store` is refused; a refusal reads nothing from the store; a pull that arrives after the store was re-pointed and re-anchored lands nowhere; scope / peer mismatches carry the same code; a store without a directory is refused). `test/memory-sync-client.test.ts` re-pinned: its cursors are minted over the test's own store.
215
+
216
+ ### The store boundary is written down once β€” INTEGRATION-CORE Β§5.11–§5.13 say what core ships and what a deployment ships, list what a store-owning deployment reads from core at 7.58.0, and read the four packages against each other; four claims of a shipped database store are corrected (#2770; documentation only, no behaviour change; hard-breaking: none; closed sets: none; exports: none) (@server @dgx)
217
+
218
+ - **Before.** The line was implied across INTEGRATION-CORE Β§5.2–§5.7 and the CHANGELOG sections of #1468 S4, S4b and T4; no sentence said what core ships. Four places said more than was true: `docs/sdk/10-extension-points.md` Β§3 named `src/stores/pg.ts` (no such file) as ready-made PostgreSQL implementations, the root README offered Postgres as a `CheckpointStore` and `MemoryBackend` backing and counted two runtime dependencies (the package declares four), and `docs/ARCHITECTURE.md` drew `src/stores/pg` in its diagram. INTEGRATION-CORE carried two sections numbered 5.7.
219
+ - **Now.** Β§5.11 draws the line once: core owns the seat contracts, the facts a backend must not restate and the kits that accept a backend; it ships the in-memory defaults and the file family (`FileStorageBackend`) and **no database store** β€” the PostgreSQL / TiDB adapters under `src/examples/adapters/` are repository examples (not a root export, not in `dist/`), and `@sema-agent/core-stores-sql` carries the neutral factories without stores. Β§5.12 is the one list of what a deployment that owns session and checkpoint stores reads from core β€” each export with the reading it retires β€” followed by the five readings that changed in 7.58.0 (the owner-only import, the head an import answers and the conditional write, the two kit report words, the required `executor`, the retention word as a construction argument) and what a deployment that implements `SessionStore` itself, a local lane and the startup call each do. Β§5.13 reads the four packages against each other: one boundary sentence and one install form each, the exact-version rule between them, and that core does not depend on `@sema-agent/mods-kernel`. The second Β§5.7 heading is Β§5.7a. The four stale claims above are corrected, and the `@sema-agent/core-stores-sql` and `@sema-agent/mods-kernel` READMEs each gain the one sentence that places them against core.
220
+ - **Consumers.** @server: Β§5.12 is the list to read the 7.58.0 store faces from; its hard-breaking readings are stated, with migrations, in the #1468 S4 / S4b / T4 sections in the 7.58.0 notes below, which this does not restate; 7.59.0's own store-face changes are in the #2818 / #2836 sections. @dgx: the File lane's two readings (`FileSessionRepo.importEntries` as the row's owner, `FileStorageBackendOptions.sessions.beforeSessionDelete`) are in Β§5.12 and Β§5.5. No code, export or behaviour moves.
221
+ - **Pins.** None added (documentation). The existing document pins (`test/docs-contract-pins.test.ts`, `test/backlog1009-store-read-back-shape.test.ts`) read headings and anchors this change leaves in place; the package README pins (`test/backlog2104-mods-kernel-publish.test.ts`, `test/backlog2673-core-stores-sql-publish.test.ts`) read their READMEs' install lines, forbidden words and Exports tables, none of which moved; the front-door export tiers (`test/export-surface.test.ts` reads the root README) are unchanged β€” no root export name enters or leaves that file.
222
+
223
+ ### Seven gaps the 7.58.0 release found in its own chain are closed β€” `scripts/release/` and `scripts/verify-tmp-hygiene.mjs` (#2852, #2853, #2856, #2857, #2858, #2859, #2860; release tooling only, `src/` untouched; no behaviour change; hard-breaking: none; closed sets: none; exports: none)
224
+
225
+ - **#2852.** A live stamp and `RC_GREEN_SHA` now vouch for a commit only when its build inputs are the same too β€” every `package.json` with its dependencies, the lockfile, `tsconfig*.json`, `.npmrc` and the scripts the build runs β€” with the version cells a bump writes as the only thing allowed to move; before, only the source trees were compared.
226
+ - **#2853.** A `tag-push` whose push exits non-zero keeps the local tag and reads the destination's `main` and tag through the push URL: both there is a lost acknowledgement and the step goes on, neither is a refusal whose rerun pushes the same tag object, anything else is refused by name.
227
+ - **#2856.** `r-commit --dry-run` now runs the re-window half (nothing written) and prints its moved / refused / kept counts, on the CHANGELOG as the release commit would leave it.
228
+ - **#2857.** `gate:tmp-hygiene` prints every failed test file of a red run with its failing tests (it kept the last lines of the output before) and `--full` takes `--workers N`.
229
+ - **#2858.** The re-window keeps a car row only when the row's own car is in the release β€” the first car name of its status head, judged by the car's own head named in its `DONE` clause (before or after the word) when it has one β€” a sha that is the stage commit the row waits to be merged onto, or not the car's work, is passed over; a neighbour car named later in the head no longer counts.
230
+ - **#2859.** `gate:criteria` is one of `r-commit`'s heading-sensitive gates, and each gate's exit is kept in the step's chain-state record.
231
+ - **#2860.** The chain gains `post-publish` after `ship-post-lint`: the ship post, the criteria post and the pickup list reach the board only after the lint passed, in the body it passed; `ship-number` only claims the number.
232
+ - **Pins.** `test/release-chain-gaps.test.ts` and `test/backlog2857-tmp-hygiene-failed-files.test.ts`; `test/release-chain-steps.test.ts` re-pinned (a failed push keeps the tag; the step order).
233
+ - **Who is hurt.** The R operator: `post-publish` is a new step between `ship-post-lint` and `post-ship` (`--with-posts` names the extra posts), `r-commit` runs `gate:criteria`, and a stamp taken before a dependency change no longer carries over it.
234
+
235
+ ### An inherited screening entry carries its installation on the minted policy; one frozen regime per installing leg (#2428; structure only, no behaviour change; hard-breaking: none; closed sets: none; exports: none) (@server @cli @client-core)
236
+
237
+ - **Before.** The bus a screening constraint was minted over (`createPreToolUseConstraintPolicy`) lived in a module-level side table keyed by the minted policy object. The mint wrote it, and the installation identity (`sameInstallation`), the carrier check (`screeningInstallationsOf` / `unraisableGuardsOf`) and the inherited `tool.check` raise (`inheritedToolChecks`) looked it up there. A leg's frozen regime (its approver, its two durable mandates, its classifier) was spread twice when the leg handed its chain down: once onto its screening entry and once onto its caller-policy entry.
238
+ - **Now.** The minted policy carries its installation as a member of its own. The member is fixed and not enumerable, the mint is its only writer and one reader (`installationOf`) reads it, so the side table is retired. A copy, a wrapper, a prototype heir or a Proxy of the minted policy carries none, which is what the side table recognised before. That includes a clone that copies every own descriptor, and a deep clone as well, because the member holds the object it was minted on in a closure that no clone can redirect. The regime is minted once each time a leg hands its chain down, and both of the leg's entries carry that same regime. As a result the two entries' `autoMode` containers are now one object; the engine never mutates them, and the `decider` and the denial tracker inside were already shared.
239
+ - **Unchanged.** What runs, what asks and what is refused. The entry's keys and the policy's enumerable face (`Object.keys` is `["check"]`) are the same. Hosts rebuild the entry the same way: `createPreToolUseConstraintPolicy(chain, env)` over the same registrations. What a park records about the chain is unchanged too: `constraintChain` and `constraintDigest` are byte-equal to what the previous tree writes (pin K1).
240
+ - **Consumers.** @server (S-2388; `createParkedReviveInheritedGate`), @cli (MODS155) and @client-core (CC-1042) have nothing to change for this entry. **Announced, not in this entry (#2429):** inherited `classic.PreToolUse` will be raised in the gate's first phase on each installation's own bus, and the screening entry's folded-policy form will retire. The constraint channel stays, as the carrier of each installation's obligations. That change is a hard-break candidate for hosts that rebuild the screening entry with `createPreToolUseConstraintPolicy`, and its three sentences ship with it.
241
+ - Pins: `test/backlog2428-mods-w3-s2a.test.ts` (M / R / C / W / U / S / K).
242
+
243
+ ### Wording only: a recursive shell read's contract sentences say what 7.52.0 made of it, the program-text deny reading is written down (KL-1102-n), and four notes of 7.56.0 are corrected (#2499, #2504, #1714; no behaviour change; hard-breaking: none; closed sets: none; exports: none; members: none)
244
+
245
+ - **Recursive reads.** Five statements still described the tree walk that 7.52.0 retired (its #1714 section, which says it right, is unchanged). The `shell.read_boundary.friction_floor` contract sentence (`src/tools/fs/shell-read-judge.ts`, mirrored in `docs/CONTRACT-SENTENCES.md`) said "traversal roots enumerated, each within a bound"; the `traversal_root` line of `docs/CLOSED-SETS.md` said "enumerated within a bound"; the header of `src/tools/fs/read-deny.ts` called the active rows "the floor of EVERY read face … and their traversals"; and two JSDoc lines (`ReadEstablishment` in the judge, the account of what `env` answers in `shell-read-check.ts`) spoke of a traversal that is enumerated or cannot be. They now say what the code does and has done since 7.52.0: a recursive read's root is judged by what the command names, the root itself and the placed rows it contains, never by a tree walked below it; a credential row that is only spelled (`.netrc`, `.ssh/`) and lies below a root is met where a command names it, not on the walk (KL-r2-a); only a glob root's own expansion keeps its bound. Comments and documents only, the reading is unchanged. #2499 reported a client fence written for the refusal before 7.52.0; whether the walk should be judged again is a separate question, and #2505 is the filed direction (a credential floor in a sandboxed `ExecutionEnv`).
246
+ - **Program text (KL-1102-n, #2504).** The text of an inline program (`python3 -c "…"`, `perl -e '…'`, an `awk` program) meets the read deny rows as ONE spelling, not as the paths written inside it: it is one deny-only candidate (`src/tools/fs/shell-read-argv.ts`, `programTextReads`) resolved like an operand (`src/tools/fs/shell-read-establish.ts`, `lexicalReadsOf`; `src/tools/fs/bash-readonly-classifier.ts`, `resolveOperandSpellings`), so a text that starts with `/` is that absolute path (the working directory plays no part), one that starts with `~/` is judged both at its literal spelling under the working directory and expanded against the declared home, and any other text is placed under the working directory and judged together with the directory's own segments (a program run inside a guarded directory is refused whatever its text: under a `.ssh` directory even `open('.netrc')` is). The judge reads those spellings' segments, splitting at `/` and `\`, and a row is a run of whole segments (`segmentRowMeets`, `src/tools/fs/read-deny.ts`; the ends of the text are boundaries, and a quote, parenthesis or letter touching a segment makes it another segment). So (1) an unanchored spelled row (a built-in `.netrc` / `.ssh/` / `.aws/` / `.git-credentials`, a deployment's `secrets/**`) meets the text only where one of its segments stands whole: `open('<home>/.ssh/id_rsa')`, `open('<home>/.netrc/')` and `perl -e '/.netrc'` are refused; `open('<home>/.netrc')` (the closing `')` touches the last segment) and `open('.netrc')` are not, under an ordinary working directory and the default rows. (2) An anchored row (a home-anchored built-in such as `~/.npmrc`, a rooted deployment row `/abs/x`, a `Read(/…)` rule) meets it only where the resolved spelling really lies under the anchor: a text placed under the working directory only when the directory itself lies under it, a text that starts with `/` only when it lies under it itself; a path written inside the text does not. A home-anchored row compiled with no known home is read as unanchored. (3) When no row meets it, only a text that may open a file (any text of a language the station does not name, such as `python3`, `perl`; a token language's text, `awk` or `jq`, only with an opening token, so `awk 'BEGIN {print 1}'` is not) is `unestablishable`, and only where the read or the write face guards something; with both faces open and no deny row at all it is let through (`foldShellReadFindings`, `src/tools/fs/shell-read-judge.ts`; `programTextMayOpen`, `src/tools/fs/program-read-model.ts`). The question is mandated on the full shell's roots read face and ordinary on its open read face (a deny row wired, or a guarded write face); the read-only and the re-judging seats refuse it. This is how it has read; nothing changed. Whether program text should meet the operand judge, or the scan should be retired, is #2504.
247
+ - **Four 7.56.0 sentences, corrected.** The released notes stand as published; these replace the sentences named.
248
+ - #2302, *Before*: "the default mode handed the call to the classifier and `bypassPermissions` ran it". The classifier is auto mode's (`src/core/classifier-unavailable-arm.ts`). A misspelled deny read as "no rule speaks", so the call went on as if no rule had spoken: in `default` it took its ordinary path (a question a policy had raised reached the approver as an ordinary question), and `bypassPermissions` ran it.
249
+ - #1329, *Who is hurt*: "A policy that caches an ASK answer across calls and returns it for another call id has that call refused." Only an ask that carries the engine's record of another call (a guard policy's or a fold's record, bound to its `toolCallId` and `toolName`, `src/core/engine-attestation.ts`) is refused. A cached ask with no such record is asked or released as it was before. The *Behavior narrowing* paragraph of that section states it right.
250
+ - #971, *Now*: "So a socket is dialed and a pid probed for a local process and nothing else." That holds for a row of plain data members. `readPeerSessionRecord` does not snapshot an accessor member, so a getter that answers differently on each read can pass the check without it (the JSDoc of `PEER_SESSION_WHERE_VALUES` and `docs/sdk/07-multi-agent.md` already say so).
251
+ - #1551, *How to migrate*: "the switch rides the parent spec seat, so the request's engine-built child legs are switched off with it". True because an engine-built child authors no `attachments`. A delegation path that authors its own `attachments` keeps exactly what it authored (`src/core/parent-spec-seat.ts`; the *Behavior change* bullet of the same 7.56.0 section says it), so the parent's switch does not reach its legs: a lane its declaration leaves out takes the default, `mcp_unavailable` on (`mcpUnavailableOn`, `src/core/runner/turn-attachments.ts`), and an explicit `mcpUnavailable: false` of its own stays off.
252
+
253
+ ### A path segment is compared by canonical equivalence, not by code points: a deny row meets the other spelling of its own name (#2577; behavior narrowing, open to veto; hard-breaking: none; closed sets: none; exports: none) (@server @cli @client-core)
254
+
255
+ - **Before.** The segment engine behind the read deny rows and the sensitive-path write list folded case and separators but
256
+ composed nothing. A filesystem that compares names by canonical equivalence (APFS, HFS+) serves `ΓΌ` written as one code
257
+ point and `u` plus a combining diaeresis as one file, so a credential row `schlΓΌssel/**` judged the composed spelling of a
258
+ path and answered `null` for the decomposed one β€” the same file, read or written past the row. The same held for a
259
+ home-anchored or rooted row whose home or run carried such a name, and for a configuration root with a non-ASCII name.
260
+ - **Now.** Both sides of every comparison are composed (NFC) before the fold of the row applies β€” the pattern at compile,
261
+ the anchors a placed row carries (a home, a rooted location, a configuration root) and the path's segments β€” under every
262
+ fold (`caseSensitive: true` rows and the write list's host-keyed fold included), by the one fold table
263
+ (`SEGMENT_FOLDS`) every consumer already read. Nothing else changes: ASCII case still folds, non-ASCII case does not
264
+ (the deny set's documented contract), a compatibility form (a ligature) is another name, and a canonical singleton is the
265
+ letter it decomposes to (the Kelvin sign is `K`, which the ASCII fold then lowers).
266
+ - **Behavior narrowing (open to veto).** *What changed*: a deny row or write-list entry with a non-ASCII name now also
267
+ refuses the other composition of that name; the write list and the read set share the compiler, so both widen the same way.
268
+ *Who is hurt*: a deployment whose directory holds two distinct files that differ only in composition (possible on a
269
+ filesystem that does not fold them, such as ext4) and guards one of them β€” the twin is now guarded too; one extra
270
+ refusal, never a missed one. *How to migrate*: nothing; list the name once, in either spelling.
271
+ - **Limits (stated).** ripgrep compares bytes: its exclusion globs stay spelled as the row is written, and a path it returns
272
+ under the other spelling is caught by the output tripwire (the judge now names it), which hands the search to the JS
273
+ scanner that prunes with the same judge. The data-root exemption's comparison stays byte-exact on purpose (an exemption
274
+ widened by a fold is a guard bypassed). Composition costs what the platform's NFC costs on the spelled segment: a name a
275
+ filesystem can hold (at most 255 units) takes well under a millisecond, but a hostile spelling of tens of thousands of
276
+ combining marks takes seconds (it grows with the square of the segment's length) β€” the same cost the tool gate's own path
277
+ normalization already pays; the judgment memoizes it per spelling and does not bound it.
278
+ - **Consumers.** @server @cli @client-core: no API or wire change; a deployment's non-ASCII deny entries and write patterns
279
+ now cover both compositions of a name.
280
+ - **Pins.** `test/backlog2577-segment-names-canonical-equivalence.test.ts` (N1 a row against the other spelling of its own
281
+ name under the ASCII and the case-sensitive fold, both directions, deeper paths, a wildcard row, and the names that only
282
+ start like the row; N2 what does not change: ASCII case, separators, dot segments, non-ASCII case, a ligature; N3 a
283
+ home-anchored and a rooted row, any spelling of the home; N4 the target judgment, a recursive read's root, a row at or
284
+ below a path; N5 the write list under all three folds and through `createSensitivePathPolicy`; N6 a configuration root with
285
+ a non-ASCII name still guards its own settings file). `backlog2117-read-deny-star-fold` F5 re-pinned: the `unicode` fold's
286
+ reference is the engine's own `i` flag over the composed name.
287
+
288
+ ### The read-deny table travels with every shell start β€” an environment that confines processes keeps those bytes from every program the command runs (#2505; behavior change only for a library-direct band: its shell starts wait for the band's deny placement; new field for environment adapters) (@server)
289
+
290
+ - **Before.** The shell read station judges what a command NAMES β€” its operands, its expansions, a recursive read's root (since 7.52.0 never the tree below a root: `grep -r x .` reads a `.netrc` the root holds, KL-r2-a β‘ ). The documented hard floor under it β€” "a sandboxed ExecutionEnv" β€” had no way to learn which paths to keep: nothing handed the environment the table.
291
+ - **Now.** Every command start the shell faces make (Bash foreground and background, the read-only Bash, Monitor) carries `readFloor` in its exec options: the read-deny table in force for that call (built-in tiers, deployment and task rows, a person's `Read(...)` deny rules β€” the call's own pinned table), as `rows` (the strings the engine's refusals cite) and `denies(absolutePath)` (the same judgment the read station asks). One table, two readers: the station judges names, the environment judges bytes; the station does not loosen when an environment keeps the floor. A library-direct band (no Runner) whose own deny placement is still settling now holds its shell starts until it settles, as its read tools always did. New root type export `ReadFloor`.
292
+ - **Contract for an adapter that confines processes** (sandbox / container / microVM / remote agent): every program the command runs must be unable to read a path `denies` answers non-null for, judged where the environment resolves it; an environment that cannot keep the whole table for a start refuses the start (`spawn_error`, naming the row) rather than run with fewer rows β€” a runtime configured from the static `rows` that cannot place a row (one with no anchored directory) refuses too. An environment that cannot confine a process (the host, ssh, a device) ignores the field β€” no byte floor there, KL-r2-a unchanged. `NodeExecutionEnv` ignores it.
293
+ - **Consumers.** @server: the sandboxed lanes (e2b / k8s / local-docker) can now implement the deny floor from `ExecutionEnvExecOptions.readFloor` (and `BackgroundSpawnOptions.readFloor`); no change is needed to keep compiling β€” the field is optional.
294
+ - **Pins.** `test/backlog2505-read-floor-lane.test.ts` (real Runner; a confining environment's test double: `grep -r` / `find -exec cat` / `tar` keep the credential file's bytes out, a command naming the file is still refused by the station and never starts, deployment rows travel and an excluded built-in row does not, background and Monitor starts carry the floor, the host env reads nothing new), `test/backlog2505-read-floor-seat.test.ts` (the seat: rows = the refusals' strings, the table's own judgment, fail-closed on an unreadable path, the call's pinned table).
295
+
296
+ ### A role seat that names a model the catalog does not hold is read as an unset seat and said once, where it refused every turn (#2571; behavior change, open to veto; follows the reference implementation's split β€” the main model's seat refuses, helper and subagent seats retreat and say so; hard-breaking: the notice catalog, open to veto; closed sets: `ENGINE_NOTICE_CODES` 102 β†’ 103, +`model.role_defaulted` (audience `operator`, minted by the engine); exports: none; members: none) (@cli @server @client-core)
297
+
298
+ - **Before.** A deployment that named a model its catalog does not hold at a role seat β€” the field shape is a host that maps
299
+ `MODEL_CHEAP_ID` onto `roles.summarize` / `roles.subagent` while the id it names is not a catalog key β€” had every run refused:
300
+ the compaction seat (`roles.summarize`) is read at every prepare, so each turn ended `failed` with `config.unknown_role`
301
+ (`detail { field: "roles.summarize", reason: "unknown_model_ref" }`) and no answer; a `roles.subagent` word failed each
302
+ delegation the same way. *Erratum:* this is not a 7.53.0 change. The refusal is older β€” in 7.52.0 and before the same read threw
303
+ `Unknown model ref "<id>". Provide it in RunnerDeps.models or pass a Model object.` (uncoded) from the same seat at every
304
+ prepare; 7.53.0 made it coded and gave it `detail`, and 7.55.0 (#2152) built it in one place. What a shell saw change between
305
+ its builds was the code and the text, not whether the run was refused.
306
+ - **Now.** One reading, `seatRead` in `src/core/roles.ts`: a seat other than `default` and `classifier` whose word the catalog
307
+ does not hold supplies no model and is read as the same seat without its `model` member β€” a `select` beside it still answers,
308
+ then the role's tier default, then its fallback chain (`summarize` β†’ `default`, `subagent` β†’ the parent run's model,
309
+ `verifier` β†’ `default`). The walk (`resolveTaskModel`), the compaction seat (`roleModelIfSet`), the subagent seat
310
+ (`deploymentStatesSubagentModel` / `deploymentSubagentTierModel`, which now take the catalog) and the consolidation chain read
311
+ it through the one test `unheldSeatWord`. The person is told: at the root leg's prepare the engine says `model.role_defaulted`
312
+ for each such seat of the deployment's own map and of the merged deployment-and-task map, **once per session per (seat, word)** (the session's announced
313
+ record, as `model.capability_downgraded` is), with the seat, the word and what stands in. Still refused, by the seat's own
314
+ `config.unknown_role`: `roles.default` (the main model's seat), `TaskSpec.model`, `TaskSpec.compactionModel`, a value that is
315
+ no model reference (`not_a_model_ref`), and a chain that ends with no model (the first unheld seat's refusal, not "no model for
316
+ role"; the memory-consolidation chain `consolidate` β†’ `summarize` reads the same way: a written-but-unheld `consolidate` now falls to
317
+ a held `summarize`, and with neither the refusal is still `config.unknown_role` naming the first). The `classifier` seat keeps its existing stand-in and its line,
318
+ `classifier.role_defaulted`; this line is not minted for it.
319
+ - **Behavior change (open to veto).** *What changed*: a run, a compaction and a delegation whose role seat names an unknown word
320
+ now go on (on the fallback model) and say it once, where they were refused at every prepare. *Who is hurt*: a deployment that
321
+ relied on the refusal to find a typo in a role seat β€” it now sees one operator notice per conversation instead of a failed run
322
+ (the cost of the fallback model is the deployment's to watch; `summarize` falls to the run's own model, `subagent` to the
323
+ parent's). *How to migrate*: fix the seat or declare the word in `RunnerDeps.models`; a host that wants the old refusal reads
324
+ `model.role_defaulted` and fails the session itself.
325
+ - **Limits (stated).** The line is said at a leg's prepare, from the catalog that prepare reads. A word that becomes unheld afterwards β€” a
326
+ catalog swap during a run, then a delegation that reads the live catalog β€” takes the retreat at once (the child runs on the parent's
327
+ model) and is said at the session's next prepare, not before; the old behaviour there was the spawn's refusal. A `subagent` seat is
328
+ read, at a spawn, from the deployment's own role map, so a task's own `roles.subagent` does not change which model its children use
329
+ (it never did); the line names the deployment's seat for that reason.
330
+ - **Hard-breaking (open to veto) β€” the notice catalog.** What changed: `ENGINE_NOTICE_CODES` gains `model.role_defaulted` (audience
331
+ `operator`, minted by the engine; it always carries `sessionId`). Who is hurt: a consumer switching exhaustively over the catalog
332
+ or holding a whitelist of notice codes. How to migrate: add the row; show the message by code (`detail.seat`, `detail.model`).
333
+ - **Consumers.** @cli (L-1984): read `model.role_defaulted` for the start-up line about a role seat that names a model outside the
334
+ catalog (`MODEL_CHEAP_ID` and the like) β€” the engine now falls back and says so once, so the shell's own pre-flight can drop its
335
+ copy of the refusal. @server: no change; `roles.summarize` / `roles.subagent` written from `MODEL_CHEAP_ID` now fall back with a
336
+ line instead of failing every task. @client-core: show the notice by code like any operator row.
337
+ - **Pins.** `test/backlog2571-role-seat-unheld-word.test.ts` (R1 the cheap seat unheld: the run completes and says it once; R2 once
338
+ per session per (seat, word), a re-pointed seat again, a task's own seat on the merged map; R3 the subagent seat: the child runs on
339
+ the parent's model and one line is said; R4 held words and a bare deployment say nothing; R5 `roles.default` still refuses, also with a tier table bound; R6 the
340
+ walk, the tier stand-in and the compaction seat read, and the end of a chain; R7 the listing and the one test; R8 the classifier seat keeps its stand-in; R9 the consolidation
341
+ chain; R10 what still refuses; R11 the closed sets). Re-pinned to the new reading: `backlog641-child-model-seat` (a dead tier
342
+ word is an unset seat), `backlog1279-child-undrained-to-parent` (the catalog count).
343
+
344
+ ### `TaskSpec.classifyAllShell` β€” in auto mode no shell allow entry clears a call, whichever source holds it: the classifier judges (#2558; behavior narrowing, opt-in)
345
+
346
+ - **Before.** The engine had no counterpart of the reference implementation's `autoMode.classifyAllShell` (KL-1327-c, retired by this entry). In `auto`, the allow layer's strip removed only the shell entries that hand over arbitrary code (the whole shell, an interpreter or launcher prefix); a narrow rule such as `Bash(git:*)` kept clearing its calls with no classifier β€” from a person's stored rules, a skill's `allowed-tools`, the request's `allowedTools` and the deployment's `RunnerDeps.allowedTools` alike. A host that honours the setting had no engine seat to say so: its shell allow lists reached the engine and cleared calls the person had asked the classifier to judge.
347
+ - **Now.** `TaskSpec.classifyAllShell?: boolean`. `true` β‡’ while the leg's mode is `auto`, no shell allow entry clears a call: the whole shell tool, a tool name that reaches the shell and every `Bash(…)` command rule stand down whatever they name, in all four allow members (one predicate, `strippedInAuto`; the mode is read on every call, so a steer into or out of `auto` applies on the next call β€” a steer that lands while a call's stored rules are still being read applies from the call after it). Under the key no allow entry of any kind clears a call on the shell face: a path, name or host entry β€” a list's or a person's stored row (stored rows are now read as the entry kind of their grammar) β€” that a shell-face tool's declared path target reaches stands down too. The Skill card no longer names shell entries in `auto` under it. A command the read-only reader waves through still runs without the classifier, as before (it never reaches the allow layer). Outside `auto` nothing changes; deny and ask rules, a hook's allow, non-shell entries and every question an allow rule may not clear read exactly as before. A tighten-only seat (one more row of the clamp table): `tightenTaskSpec` keeps a baseline's `true`, an engine-built child inherits `true` and its own `false` cannot lift it, a governed workflow script may declare it for its child. A present value that is not a boolean refuses the run before it starts (`config.invalid_argument`). Absent or `false` β‡’ byte-identical to 7.58.0, but for one shape of the existing strip: a protocol-namespace entry (`mcp__srv` / `mcp__srv__*`) that reaches a shell call through an alias the deployment gave the shell tool now stands down in `auto` like the whole shell does under every other name (it used to clear the call unclassified; narrowing, with or without the key).
348
+ - **Behavior narrowing (opt-in).** Only a caller that sends `true` sees a change: its shell calls in `auto` are classified (more classifier calls; a classifier block where an allow rule used to clear; the denial limit is reached sooner). Measured on a real Runner, 7.56.0 vs this head, `auto` with a blocking classifier and `Bash(git:*)` + `git add -A`: request / stored / deployment / person-invoked skill rows each cleared the call unclassified and now each is classified (and blocked); the same with the key absent, the same under `default`, and a `Write` entry under the key read the same in both trees.
349
+ - **Consumers.** @client-core (CC-997): carry `classifyAllShell: true` when the user, flag or managed settings plane says `autoMode.classifyAllShell: true` β€” the reference reads it from those three only, never from a repository's project or local settings β€” and keep projecting the allow buckets (settings `permissions.allow`, `--allowedTools`, a skill's `allowed-tools`) unchanged; do not build an arm that drops shell entries from the request (it cannot reach the engine's own rule store or the deployment list, and cannot follow a mid-run mode change). @server: pass the request field through to `TaskSpec.classifyAllShell`; a managed policy that forces it = a `tightenTaskSpec` baseline carrying `true`. @cli: D-081 / L-1961's remaining difference retires once the bundled engine and client-core carry the bit; no shell code change. A test or a table that pins the clamp table's rows (`CLAMP_SEATS`) or `ParentSpecSeat`'s members sees one more.
350
+ - **Pins.** `test/backlog2558-classify-all-shell.test.ts` (real Runner quadrants Q1–Q4, the four members S1–S3 / S1β€², a mid-run steer into `auto` M1, the namespace entry through an alias A1, the path / name / host arms and the stored row's grammar P1, the bad-value door D1, the Skill card K1–K3, the seat's travel U1–U4); the resume door table row in `test/backlog1950-resume-config-doors-preclaim.test.ts`; the strip's unit calls in `backlog1327-allow-entry-unit` / `backlog1517-b-bash-pattern-rules` / `backlog1303-skill-grant-unit` re-spelled for the new parameter (same readings).
351
+
352
+ ### An image the provider cannot process no longer poisons its session: admission checks each format's header, and a provider's image refusal removes the image from what the model sees and re-sends the turn (#2874; hard-breaking: one notice word (`ENGINE_NOTICE_CODES` +1 `context.image_removed`, the #1844 / #2571 reading); closed sets: three +1 (`ENGINE_NOTICE_CODES` `context.image_removed`, `AssistantMessage.errorKind` `image_unprocessable`, `LoopContinueReason` `image_refusal_retry`); behavior narrowing, open to veto β€” an Apple-optimized CgBI PNG (a PNG whose first chunk is not a 13-byte `IHDR` of non-zero size), a JPEG whose fourth byte is below 0xC0, a GIF of zero width or height and a WebP without a `VP8 ` / `VP8L` / `VP8X` chunk were all admitted before and are refused now) (@cli @server @client-core)
353
+
354
+ - **Now.** An image's bytes must open with their format's header (one table: PNG = signature + `IHDR` first chunk, so an Apple-optimized `CgBI` PNG is refused; JPEG = SOI + marker; GIF = version + screen descriptor; WebP = `RIFF`/`WEBP` + `VP8 `/`VP8L`/`VP8X`), same refusal word `magic_mismatch`. A provider 400/422 whose envelope says an image could not be processed (OpenAI- and Anthropic-form) types the failed turn `AssistantMessage.errorKind: "image_unprocessable"` (+1 member); that failure and its persisted record make every request view replace the images of the newest message still carrying any with `[image N removed: rejected by provider: image_unprocessable]` (the transcript keeps them), the turn is re-sent in-turn (≀ 3), and later turns / resumed sessions read the same removal. Closed sets: `ENGINE_NOTICE_CODES` +1 `context.image_removed` (audience `user`, `detail: { images, sessionId, runId }`, once per run per refusal); `LoopContinueReason` +1 `image_refusal_retry`. Consumers: @cli @server @client-core β€” a closed-set pin on notice codes or `errorKind` goes red; show `context.image_removed` to the person. Pins: `test/backlog2874-image-reject.test.ts`.
355
+
356
+ ### Erasure takes the import's scope authorization seat β€” `eraseMemoryEntries({ …, expectedScopes })` is judged after resolution, inside the store's lock, and a refusal names nothing (#2304; security fix; behavior narrowing, open to veto; hard-breaking: one type-only edge)
357
+
358
+ - **Before.** `importMemoryBundle(bundle, { expectedScopes })` let a service endpoint pin its principal's grant set; `eraseMemoryEntries` had no such seat, so the question "which scopes may this caller erase" had two answerers β€” the import seat in core and an envelope a service built for itself, which could only read a `{ scope }` selector's literal and had to refuse `ids` / `sessionId` selectors outright (it cannot see what they resolve to).
359
+ - **Now.** One seat, one shape rule (`expectedScopesInvalid`: an array of non-empty scope names) and one membership predicate (`firstOutsideExpectedScopes`), both in `src/core/memory-engine/export-bundle.ts`, read by both verbs. On erasure, present β‡’ the selector's own scope (a place selector, judged before anything is read) and the **binding scope of every resolved id** must be members; an id the store cannot attribute to a scope β€” no account row, an unbound row, a non-entry-id ledger key, an unledgered file on disk, an id that never existed β€” is not a member. Any violation refuses the whole request with the new code `config.memory_erasure_scope`: nothing deleted, nothing recorded, and the refusal carries no count, no id and no scope (an out-of-set id and a never-existing id answer the same text, so the refusal is no existence oracle). The evidence lane judges in the lock, records the canonical set (sorted, de-duplicated) on the request's anchor row, refuses a replay under another set first (absent and present differ), and judges what a replay deletes where it is now: an id still (or again) holding an account row is judged by its current binding β€” an erased id the host re-added in another scope is not deleted by a replay of the old request β€” while an id the request already erased (no row, no bytes) is judged by the scope its first execution recorded on the request's own projection rows (one assignment under the anchor's selector hash; a conflicting record attributes nothing), so a commit-then-crash replay converges without a live row. The recorded set is held to the shape rule by the row validator and judged only where it is used β€” a record no first execution could have written authorizes nothing at replay. The degraded lane (no evidence face, `allowUnevidenced`) runs the same predicate over the read faces' answer before its CAS'd deletes. The seat authorizes erasure only; it never changes a session's memory scopes or write scope.
360
+ - **A declaration, never duck-typing.** An evidence face honours the seat only when its backend declares `judgesErasureScopes: true` (the File backend does); the engine refuses a grant-bearing erasure over an evidence face that does not declare it (`config.memory_erasure_scope`, the face is never called) β€” a face that predates the seat would otherwise ignore the set and erase outside it. Without `expectedScopes` every path is byte-identical (the anchor row carries no new key).
361
+ - **Other behavior changes (every caller).** The `memory.erasure_selector_mismatch` text no longer prints the two selector hashes (the first request's hash stays on its anchor row). The degraded lane deletes only the ids it was asked about: a read face that returns extra entries no longer widens the delete set.
362
+ - **Behavior narrowing (open to veto).** *Import*: a malformed `expectedScopes` β€” a `Set` or other non-array iterable (accepted before), a string (read character by character before), an empty or non-string member β€” is refused as `config.memory_import_request` before the package is read; the pure `memoryBundleInvalid` answers the same violation for a direct caller. *Erasure*: under a grant, a `{ scope }` erase of a scope holding an unledgered file refuses until a read adopts the file (the host, with no set, erases it as before).
363
+ - **Hard-breaking (type-only).** *What changed*: `MemoryBackendContractHooks.onOptionalMember`'s `member` union gains `"judgesErasureScopes"` (the suite reports a backend without the declaration as `absent`, a declaring one as `verified` after its new case). *Who is hurt*: a TypeScript hook that switches exhaustively over `member` with a `never` default stops compiling. *How to migrate*: add the arm.
364
+ - **Downgrade, stated.** The anchor's `expectedScopes` key is tolerated by an older binary's row validator (it refuses only the keys it names), so an older engine replaying an authorized request does not judge the set.
365
+ - **What still stands (named, not closed; KL-2304-a).** The degraded lane holds no lock between its read and its delete: an entry moved to another scope with unchanged content in that window is not seen. Two principals that present the same grant set share the requestId namespace (the engine holds no principal; the set is the identity it can compare). Under a grant, a `{ scope }` erase of a scope holding an unledgered file refuses without saying which (the behavior narrowing above).
366
+ - **Consumers.** @server: `POST /v1/memory/erase` can pass the principal's set as `expectedScopes` and retire `erasureEnvelopeRefusal` (`memory-operator-faces.ts`), which today refuses every `ids` / `sessionId` selector under an envelope; add `config.memory_erasure_scope` to the compliance failure code table (unclassified, it would answer 500). The two SQL twins have no evidence face β€” they ride the degraded lane, judged by the engine, and need no declaration; a twin that gains `eraseWithEvidence` must declare `judgesErasureScopes: true` and pass the contract's new case. @dgx: a self-hosted backend certified through `memoryBackendContract` that offers `eraseWithEvidence` declares the seat and passes the same case.
367
+ - **Pins.** `test/backlog2304-erasure-scope-seat.test.ts`: the three selector forms out of set / unattributable / place selector including an empty scope, the ghost-file cost, the canonical anchor record, replay under same / other / no set with the set check ahead of the selector check, two commit-then-crash forms converging without a live row, forged authorization records authorizing nothing at replay and a malformed recorded set failing the row validator, the shape rule on both verbs, the undeclared evidence face, the direct File face call, the degraded lane, a host re-add in another scope surviving a replay, conflicting projection records, the hash-free selector-mismatch text, an over-returning degraded read face, and the three actor counterexamples (no memory path reads an actor; lineage keyed by session; the seat leaves no standing state). `memoryBackendContract` gains the seat case (File verified; it judges the refusal by code β€” its text is pinned for core's own lanes, which mint one refusal).
368
+
369
+ ### The erasure attestation is version 2 β€” `complete` means every carrier of an erased entry in this store is gone, each carrier class answers what it removed and what remains, and no slug reaches the attestation or the evidence chain (#1917 S1b-1; hard-breaking, open to veto; behavior change, open to veto; closed sets: +1 `ERASURE_CARRIER_CLASSES` (eight words); exports: +3 type names `ErasureCarrierClass`, `ErasureCarrierAnswer`, `ErasureCountAnswer`; `MemoryErasureAttestation` and `ErasedBinding` reshaped) (@server @dgx @test)
370
+
371
+ - **Before.** `complete` judged only the selected ids' account rows: a quarantined copy of an erased entry stayed in the quarantine directory ("preserve-not-delete") and was listed by file name; the consolidation archive and plan workbook kept the text untouched and unmentioned; the attestation (`erased[].binding.slug`, `erasedPreviously[].from`) and every delete row on the append-only evidence chain kept the entry's slug β€” a model-chosen file name that can restate what was erased; and the degraded lane (no evidence face, the two SQL twins) answered `complete` with an empty, unenumerated residual set.
372
+ - **Now.** `v: 2`. `erased[].binding` is `{ state: "bound", scope }` or `{ state: "unbound" }`; `erasedPreviously` rows are `{ id, ev, at }`. `residuals` is the carrier table β€” `carriers` answers each of `projection`, `shadow`, `indexLine`, `quarantineCopy`, `planArchive`, `planWorkbook`, `evidenceBinding`, `backendDerived` with `{ removed, remaining }` or `{ unverified: true }` β€” plus `quarantineUnattributed` and `derivedEntries` (store-level counts that do not decide status), `replay` (`"converges"` on the evidence lane, `"unsupported"` on the degraded lane) and `propagation`. `status` is one law for every lane (`erasureStatusOf`): the v1 conditions, and every carrier class answering `remaining: 0`. A quarantine file whose frontmatter id is erased is deleted under the request's lock; a file no id can be read from is counted and left. A new delete row lands on the chain with its `scope` and no slug (the transaction journal keeps the full binding for recovery and is deleted at close). The paths the derived-index sweep owes live only in a transient control-plane record (`erasure-sweeps.json`, by requestId; each path relative to the store root and read at the root the store is opened at now), written from the request's journal right after its commit point β€” and by recovery from any erasure journal it rolls forward, including one an older binary left; `MemoryEngine.eraseMemoryEntries` sweeps every MEMORY.md line naming one of those paths β€” whoever holds the path now, an occupant's line returns in mechanical form at the next materialize β€” fsyncs each rewritten index, and drops the record row, all under the store's transaction lock and the record's lock (two sweeps of one index never interleave, and a commit, a recovery or a re-anchor never lands inside a sweep). The engine answers the index class on its own copy of the face's attestation (a frozen third-party object can no longer keep a failed sweep `complete`). The degraded lane answers every store class `unverified` and is never `complete`.
373
+ - **Contract sentences (the attestation's JSDoc).** The evidence chain is append-only and a delete row never expires with any retention period; on the evidence lane a replay of the same requestId converges with no time limit (a β‰₯ 24 h replay window holds); the degraded lane promises no replay convergence and says so.
374
+ - **Behavior change, open to veto.** *Until S1b-2 lands (same window)*: a File store with any file under `distiller-plans/` or `consolidation-plans/` answers `planArchive` / `planWorkbook` `unverified`, so **every erasure on a store with consolidation history is `partial`** β€” true: the archive keeps the prompts and answers verbatim and the workbook keeps product text, and this lane does not read them yet. *Permanently*: an erased entry that was ever renamed or moved, or whose delete was recorded before this version, keeps `evidenceBinding.remaining > 0` (the chain keeps those rows β€” KL-1917-a) and stays `partial`, and a replay cannot clear it. The store face called directly (`eraseWithEvidence`) answers `indexLine: { unverified: true }` β€” `partial` β€” while its record waits for the engine's sweep. A failed index sweep keeps the request `partial` (v1 said `complete` and listed the file on `indexUncleared`).
375
+ - **Hard-breaking.** *What changed*: `MemoryErasureAttestation.v` is `2`; `ErasedBinding` loses `slug`; `erasedPreviously[].from` is gone; `residuals.quarantineHits`, `residuals.quarantineOpaque` and `residuals.indexUncleared` are replaced by `residuals.carriers`, `quarantineUnattributed`, `derivedEntries` and `replay`; quarantine copies of an erased entry are deleted; a delete row on the chain carries `scope` instead of `from`. *Who is hurt*: a host that reads the attestation's v1 fields β€” @server `memory-operator-faces.ts` / `memory-compliance.ts` read `erased[].binding` and `residuals.quarantineHits` β€” and a reader of `transfers.jsonl` that takes a delete row's projection path from `from`; an operator who relied on quarantine keeping a copy of an erased entry for forensics. *How to migrate*: dispatch on `v` (a reader of `v > 2` refuses); read the carrier table; locate an erased entry by `requestId` in your own task state, never by slug; read a delete row's scope as `scope ?? from.scope`; export a quarantined copy before erasing if you need it.
376
+ - **Downgrade, stated.** An older binary reads a chain-form delete row (it does not refuse the unknown `scope` key), and its own recovery of a journal this version wrote is unchanged (the journal keeps `from`). An older binary that appends a journal's rows writes the slug-bearing form again, and its scoped export reads a chain-form delete row as unbound (counted as unsliceable; a full-store export carries it).
377
+ - **What still stands (KL-1917-a, KL-1917-b).** Chain rows minted before this version and every move / migration-bind row keep their slugs (exit: the candidate ticket that gives move forms a slug-free chain form). The record is keyed by requestId alone: when two executions of one requestId overlap (a host retry over a still-running first call), the first sweep settles the whole row, and an index line an outside actor restores between that sweep and the second execution's own sweep is not seen by the second β€” which then answers `complete`. A record that cannot be read or written, or a row whose path is absolute or leaves the store root, refuses like every strict control-plane file (the erasure, or the recovery leg). A non-File evidence face keeps no record, so the engine sweeps no index line for it β€” its own `indexLine` answer stands.
378
+ - **A store move while a sweep is owed.** A record row binds no root, so a store moved and re-anchored with a sweep still owed (its erasure answered `partial` on `indexLine`) replays that erasure at the new location: the sweep removes the line there and the row goes only then. `reanchorMemoryStoreRoot` refuses what it refused in 7.58.0 β€” a committed transaction pending recovery β€” and nothing more; 7.58.0 kept no sweep record, so a re-anchor is not narrowed. The erasure's settlement does narrow one thing: it now waits for the store's transaction lock (15 s, extended to a held lock's 30 s stale line), and one that does not get it in time answers `partial` (7.58.0 did not wait). The row goes only if the store root is still the anchored one after the sweep (read at that act): an engine still open at the old root when another holder moves and re-anchors the store β€” between the store's commit and the engine's sweep, or while the sweep reads β€” keeps the row and answers `partial` (`indexLine: unverified`), and a replay at the new root settles it. The settlement proves the store's transaction lock is still its own before it sweeps and again before the row goes, the same check a commit and a re-anchor make: an engine that held the lock past its stale line and had it taken keeps the row and answers `partial` the same way. A row path is split into segments the way the platform splits paths, so on POSIX a file name holding `\..\` is one segment and its row is recorded; the row is derived before the commit point, so a target it cannot name refuses with nothing committed. Pins: `test/backlog1068-sweep-reanchor.test.ts` (move, damaged anchor in place, move behind a link; the absolute row form refused; the stale holder after a re-anchor, a transaction in progress, a move during the sweep, the lock taken during the sweep; a `\..\` file name). The degraded lane (a sweep with no request id) answers `indexLine: unverified` when its holder loses the transaction lock mid-sweep β€” it cannot vouch for `remaining: 0` β€” where it answered `{ removed: 0, remaining: 0 }` before.
379
+ - **Consumers.** @server: the two SQL twins ride the degraded lane β€” their attestations are now always `partial` with `replay: "unsupported"`; read `erased[].binding.scope` and the carrier table, retire the `quarantineHits` / slug reads, and take erased-entry location from `requestId`. @dgx: the core counterpart of ha's `source_tombstones (root, source_event, …)` is the attestation plus the chain's anchor / request / delete rows β€” request (`requestId`), subject (`expectedScopes`, `erased[].binding.scope`, `sessions`) and entry ids, never text or a hash; a self-hosted evidence face answers the eight classes and `replay: "converges"` (`memoryBackendContract` checks the shape and that no slug or text appears). @test: the S1b-1 cells below are the black-box handles.
380
+ - **Pins.** `test/backlog1917-erasure-attestation-v2.test.ts` (14 cells; baseline 13 red; 17 mutations, all killed): an older binary's pending erasure journal rolled forward with its record and swept on replay; every sweep under the record's lock; the clean table; projection copies; a quarantined copy erased and an unattributable file counted; the consolidation plane answered `unverified`; a rename keeping `evidenceBinding` and the request `partial` across a replay; `derivedEntries` counted; slug-free attestation and new chain rows on the engine and organic lanes (byte search); commit-then-crash with the path reused by a new entry, the replay removing every line naming the path and the next materialize restoring the occupant's; a record surviving a reopen until the engine settles it; recovery accepting a journal row the chain already holds in its older full form; the degraded lane never `complete`. `test/design178-v2b-erasure-evidence.test.ts` re-pinned to v2 (quarantine, index sweep, frozen third-party attestation); the neighbour cells `backlog1094` β‘₯ (an erasure through a linked root of an entry renamed earlier in the cell: `evidenceBinding` 1, partial) and β‘²d (the index class, not a file name) and `backlog1103` β‘ͺ (the source scan's row for the sweep's new method) read v2. `memoryBackendContract`'s erasure case asserts v2: every class answered, `replay: "converges"`, no slug or text in the deliverable.
381
+
382
+ ### Memory notices are filed per scope β€” a session reads the notices of the scopes it mounts and no other (#1896 / #2423; hard-breaking, open to veto; security)
383
+
384
+ - **Before.** The memory notice queue was one queue per control plane. Every enqueue (harvest tail, read-side adoption, consolidation, erasure, challenges) appended to it with no scope, and a session's first injection drained the whole queue: a session that mounted only a shared `home` scope read another member's private-scope notices β€” the rejected file names (`write rejected [secret] <path>`) and the counts (`N added, M updated`) β€” and, because the drain is destructive, the session that owned those notices never saw them. The bound (20) and its fold count were shared too, so one scope flooding the queue pushed every other scope's notices out and the fold count told every reader how busy the others were.
385
+ - **Now.** One bounded queue per scope inside the same `announcements.json` (each with its own bound, fold count and standing-condition sweep). `MemoryAnnouncement.scope` is required: a notice is filed under the one scope it reports on. `drainMemoryAnnouncements(controlDir, scopes)` / `peekMemoryAnnouncements(controlDir, scopes)` take a required scope list and read only those queues; the engine's injection drains the scopes the session mounts plus its write scope, and every other queue stays for the session that mounts it. A harvest that reports on its write home and on a read-only layer at once files each line under the scope that owns the path (the write face's own facts β€” patch counts, a refused harvest, a conflict, a degraded run β€” under the write scope; a held entry's warnings under the hold's scope; a link is judged by the directory it sits in, never by what it points at); a count over several layers is split per layer, and a count over the whole control plane (expired settlement rows, unsettled lineage transactions) is the host's. A fact of the whole store that names no scope, path or count (a ledger reset, a torn evidence tail, a v1-compat window) is filed under every registered scope; a notice that names no single scope β€” a count or ids over the whole store (the v2 ledger upgrade line, the unbound-row disclosure, an ambiguous projection across scopes) β€” reaches no model face and goes to the host's incident sink as `memory.announcement_withheld`; a session-level event with no scope in hand (an external delegation settlement, a failed settlement write) reaches no model face either and is written only to the process log (`console.warn`), not to the incident sink. A challenge notice is filed under the challenged entry's scope, read from the committed store after the synchronous ledger append; each filing is bounded on its own (5 s β€” past it the lines go to the host and a late answer files nothing) and the next mount waits for the filings at most as long (a wait that runs out, and a filing that fails, are said as `memory.announce_failed`). A store-read fault that relays its error text is the host's (the text can name any scope's rows). A cross-scope move or duplicate-projection notice no longer names the other scope's path.
386
+ - **Hard-breaking (open to veto).** *What changed*: `MemoryAnnouncement.scope` is required; `drainMemoryAnnouncements` and `peekMemoryAnnouncements` take a required `scopes` array (no every-scope spelling) and answer `{ folded, queue, unscopedDiscarded }`; `enqueueMemoryAnnouncement` throws a `TypeError` on a line without a scope; a queue file written before this version is discarded unread at its first locked rewrite and its line count is said once to the incident sink (`memory.announcement_withheld`); the unbound-row disclosure, the v2 ledger upgrade line and the two delegation-settlement lines are no longer model notices. *Who is hurt*: a host that calls the package-root `drainMemoryAnnouncements` / `peekMemoryAnnouncements` / `enqueueMemoryAnnouncement` directly, and test fixtures that write queue lines or the queue file by hand. *How to migrate*: pass the session's scopes to the readers (`[...memory.scopes, memory.writeScope]`), add `scope` to every hand-built line, and read the host-only notices from the engine's `onIncident` sink (code `memory.announcement_withheld`; the two delegation-settlement lines are in the process log only).
387
+ - **Consumers.** @server: no call of the three queue functions was found in the server source read for this change (a local checkout, not the release head) β€” a host that does call them passes the session's scopes and adds `scope` to its fixtures; the incident sink gains `memory.announcement_withheld` (a posture code β€” not a governance verdict). Whether a multi-tenant deployment shares one control plane across tenants was not read here β€” with this version it no longer decides who reads a notice. @cli: no call site found either (same reading); no change.
388
+ - **Pins.** `test/backlog1896-announcement-scope.test.ts` (per-scope drain / flood / sweep / required scope / upgrade discard / transfer; HOME-only session reads none of the private scope's notices while their owner still does; every model face of a HOME-only session — injection index, `memory_search`, `memory_get`, `memory_index`, the notice block, the read-only notice — free of the private scope after a privileged read proves the private rows exist; one harvest's write-home and read-only-layer lines each in their own queue; a rejected link in the private home pointing at a HOME file stays the private scope's line; a transfer whose destination cannot be written leaves the source whole; challenge notices in the entry's scope, the unknown id to the host, a hung filing bounded on its own and not holding the next one, the mount's wait bounded however many are queued, a failed filing said); re-pinned to scopes: `memory-engine-s2-announce`, `rb495-t1-occurrence-identity` (the unbound-row disclosure is now the operator's: said once per reading, A→B→A included, never queued), `memory-ledger-v2`, `design383-slice1-security`, `design178-v2b-erasure-evidence`, `memory-dual-root` and the other queue readers (through `test/helpers/memory-announcements.ts`, a test-only reader of every registered scope).
389
+
390
+ ### The A2A lock key and the A2A capability are words of the closed sets β€” `LockedKey` gains `a2a`, `ComplianceCapability` gains `a2a_peers`, so a deployment's A2A veto can be written and a task that declares a peer is refused under it (#2500; additive; behavior narrowing for a deployment whose posture resolver can fault, open to veto; hard-breaking: none; closed sets: `LockedKey` / `LOCKED_KEY_REGISTRY` +1 word `a2a`, `ComplianceCapability` / `COMPLIANCE_CAPABILITIES` +1 word `a2a_peers`; exports: no root name added or removed) (@server)
391
+
392
+ - **Before.** The two words did not exist, so neither veto could be written. A lock declaration listing `a2a` was an unknown key: `config.locked_registry` on every prepare of that deployment (measured on a real Runner at the previous release: a task with no peer at all failed), not a lock on peers. A posture naming `a2a_peers` was an unparseable posture, which prepare treats as a resolver fault; that fault denies every capability the engine manages, and none of them was the peers, so a task declaring a peer completed under it (measured: a posture denying `a2a_peers` and a thrown resolver both ended `completed`, the recording listener hit twice). A task that added `a2a_peers` to its own `complianceAdditionalDenies` was refused as `config.invalid_argument` (an unknown word), not as a denial.
393
+ - **Now.** One registry row and one capability word, each read by the code that already reads its set. `LOCKED_KEY_REGISTRY.a2a = { specFields: ["a2a"] }` β€” the `mcp` row's twin: a task that carries `TaskSpec.a2a` under the lock is refused wholesale (`config.locked_key`) before any peer is contacted, and the preflight reads the peers seat once β€” the lock check's read β€” and resolves nothing from it under the lock (a seat that answers differently to a second read reaches nothing). `a2a_peers` is a member of `COMPLIANCE_CAPABILITIES`: a posture's `additionalDenies`, a task's `complianceAdditionalDenies` and a governed script's list accept it through the one array they already read; prepare's conflict check beside `mcp_servers` refuses a task whose preflight snapshot declares a peer while the capability is denied (`config.compliance_denied`; `config.compliance_required` when the denial is the resolver fault's) before any peer is dialed (the check sits in task preparation, which every leg β€” fresh run, resume, delegated child β€” enters). No builtin profile floor names it (`BUILTIN_COMPLIANCE_DENIES` follows the policy-limits table, which has no A2A row), so a deployment that asks for nothing sees nothing.
394
+ - **Behavior narrowing (open to veto).** A resolver that throws, or returns a posture the engine cannot parse, now also denies `a2a_peers` (the fault arm denies the whole closed set), so a task that declares an A2A peer is refused `config.compliance_required` where it used to run and dial the peer. Measured on a real Runner against a recording loopback listener, previous release vs this one: thrown resolver + `a2a: [peer]` β€” `completed`, listener hit twice (the card probes) β†’ refused, listener not hit. The narrowing reaches only a task that declares a peer under a faulting resolver (the newly valid words are additive: a lock declaration listing `a2a` no longer fails every prepare, and a task or posture may now name `a2a_peers`). Hard-breaking: none; a consumer that switches or builds a `Record` exhaustively over `ComplianceCapability` or `LockedKey` sees one more word to handle at compile time.
395
+ - **Reach, stated.** The veto rides the task's preparation: the public library entrance `materializeA2aTools` (like `materializeMcpTools`) passes no prepare, so no posture and no lock reaches a host that calls it directly β€” the module header of `compliance.ts` now says so; a refresh re-dials the peers prepare admitted and admits no new one. `TaskSpec.a2a` is the only channel that declares peers (`RunnerDeps.a2a` carries only `isolatePeers`).
396
+ - **Consumers.** @server: `task-a2a.ts` (`a2aInjectionHonored`) reads both words as spelled strings (`lockedConfigKeys?.includes("a2a")`, `denies.has("a2a_peers")`) and says in its header that the env channel could not write them; with this release it can (`lockedConfigKeys` is read against `LOCKED_KEY_REGISTRY`, `complianceAdditionalDenies` against `COMPLIANCE_CAPABILITIES`) β€” read the typed members (`LockedKey`, `ComplianceCapability`) instead of spelling the words, and retire the "not in core yet" notes there; a request body that adds `a2a_peers` through the tighten-only seat is now accepted by the same array. Read in the server checkout, not run by this car. @test: a black-box cell for a deployment that locks `a2a` (a task carrying `a2a` is refused `config.locked_key`, a task without one runs) and for a posture that denies `a2a_peers` (refused `config.compliance_denied`; resolver fault refused `config.compliance_required`; no peer contacted).
397
+ - **Pins.** `test/backlog2500-a2a-closed-set-words.test.ts` (12 cells; 8 red on the previous release's tree, 4 controls green on both); `test/prepare-caps-and-workflow.test.ts` (the degraded deny set gains the word; the conflict check on the preflight snapshot, with the empty-list and no-denial controls). `docs/CLOSED-SETS.md` registers both sets (rows and notes); the governed-agent README, the `RunnerDeps.lockedConfig` JSDoc and KL-469-k list the registry by hand and now say `a2a`; `test/backlog1473-task-tighten-seat-family.test.ts` quotes the closed-capability sentence and now lists `a2a_peers`.
398
+
399
+ ### A parked workflow call is a call that has not been answered yet β€” a decision delivered to the still-running run drives the parked child on in place (`redeemWorkflowParks`), and the run suspends only when nothing but a person can move it (#2561; hard-breaking, open to veto)
400
+
401
+ - **Before.** The first workflow child to park at an approval gate threw `WorkflowAgentParkedError` into the script at once, every later spawn was refused (a call queued behind the concurrency slot included), and the run ended on that park after its in-flight siblings drained. The only way to apply a decision was a second run resuming from the first β€” which `startWorkflow` refuses while the source is still active in the process. So a decision taken while a sibling leg was still running could not be delivered: the card kept reading `parked: true` until the run ended.
402
+ - **Now.** The parked call waits. The run keeps running its other calls (siblings, chains, calls queued behind the slot). `redeemWorkflowParks(runId, scope, decisions)` (package root) hands decisions β€” the same `WorkflowParkedResume` a resume takes β€” to a run that is live in this process: each decision whose token names a park the run is waiting on is disposed exactly as a resume disposes a parked ordinal (the checkpoint store's word, then one disposition): a pending checkpoint with an outcome drives the parked child on the same record and ordinal and the call returns its result; an acknowledgement without an outcome keeps the park; a checkpoint the store no longer calls pending settles the call failed (`workflow.park_not_pending`). The answer says what the run did per decision (`driving` / `settled` / `kept_parked` / `already_taken` / `not_parked_here` / `unreadable`), or that it cannot take decisions: `suspending` (with `ended`, settling at the run's end), `not_active` (no run of that id and scope runs here), `not_armed` (no checkpoint store to prove a park against). The run suspends when every call it still has unanswered is a parked one β€” checked one macrotask after any change, so the script's own continuations run first β€” or at once when it is cancelled or its deadline fires; then each waiting call is answered with `WorkflowAgentParkedError`, later spawns are refused with it, and the park is the run's terminal, as before. A body that returns while a call of its run is parked or being driven from a park waits for the run to suspend or for every call to be answered. The parked row reads `running` again (its token cleared, a fresh `agent_start`) the moment the drive starts, so `WorkflowRunSummary.parked` goes absent while the run is still running. The fork guard on `resumeFromRunId` of an active run is unchanged.
403
+ - **One journal rule.** The entries of one call reach the journal store in the order they were issued (an append for a call waits for the store's answer to that call's previous append; calls are not ordered against each other) β€” a park entry whose bounded wait gave up but which commits late can no longer replace the result the same call was driven to.
404
+ - **Hard-breaking (open to veto).** *What changed*: `ctx.agent` / `ctx.agentStream().result()` of a call whose child parks no longer reject at the park; they wait for a decision delivered to the live run or for the run to suspend. Spawns made after a park and before the suspension run instead of being refused. *Who is affected*: scripts that use the park error as control flow (a `catch` that does something else right after the park β€” it now runs only at suspension); tests and criteria that pin "the sibling queued behind the slot is refused after a park". *Migration*: none for a script that lets the park error propagate (same error, same terminal); write work that should happen while a call is parked in parallel with it rather than in its `catch`.
405
+ - **What still stands (named, not closed).** Calls that chain off concurrent answers (`A β†’ A2` beside `B β†’ B2`) get ordinals in completion order β€” the existing reason `pipeline` forces divergence; a run that keeps spawning after a park makes it likelier that a later resume of that run finds a live call on another call's parked ordinal and refuses loudly (`workflow.parked_call_changed`) β€” nothing runs twice. A park-capable run that crashed while running is still not resumable (`record_not_terminal`). A run whose claim grant was superseded drives with its own holder and re-parks on the lost CAS. A revived wa* row restarts its `seq` at 1.
406
+ - **Consumers.** @server (S-2092): the decide route's workflow arm calls `redeemWorkflowParks(runId, scope, [{ token, outcome }])` first β€” `live` + `driving` / `settled` β‡’ accepted; `kept_parked` / `unreadable` β‡’ the card stays pending; `already_taken` β‡’ an idempotent repeat; `suspending` β‡’ await `ended`, then the existing resume lane; `not_active` β‡’ the existing resume lane. No new bit: `parked` is still `runParkedOf`. @test: G23 / TF3 ("absent after the decision") read as above.
407
+ - **Pins.** `test/backlog2561-in-run-park-redemption.test.ts` (real Runner, R1–R12: both lanes, acknowledgement, delivery answers, replay of a redeemed ordinal, late park append, seat before publish, body return, a resume's re-parked ordinal, chain continuations, an expired checkpoint, a cancel while a body-returned run waits on a driven park); re-pinned to the new law: `backlog642` (a sibling queued behind a park runs; a hung failed-entry append still does not hold a suspending run) and `backlog1514` C13 (a refused drive's slot goes back before its park record is waited on β€” the queued sibling's leg runs at once).
408
+
409
+ ### The card-edit face reads a command rule's content through the validator's one spacing fold β€” a stray blank inside the parentheses no longer lands another row than the clean spelling (#2564; behavior change, open to veto; closed sets: none; exports: none) (@server)
410
+
411
+ - **Before.** The edit face's muscle-memory rewrite (one trailing ` *` becomes the canonical `:*`) looked for the star in the text as typed, while the validator reads a command rule's content with its spacing folded β€” two readings of one spelling. So a stray blank inside the parentheses changed the outcome: `Bash(adb *)`, `Bash(adb *)` and `Bash( adb *)` persisted the prefix row `Bash(adb:*)`; `Bash(adb * )`, `Bash(adb<TAB>*)`, `Bash(adb *<TAB>)` and `Bash( adb * )` reached the validator unrewritten and persisted the wildcard row `Bash(adb *)`; on a chain card `Bash(cd /tmp && adb pull *)` was accepted as the compound prefix while `Bash(cd /tmp && adb pull * )` was refused `unsupported.wildcard`. Blanks AROUND the rule or before its `(` (` Bash(adb *)`, `Bash(adb *) `, `Bash (adb *)`) are not part of this: since 7.56.0 (padded rule names) they are refused `invalid.grammar` with the spelling to copy (`respelling`), on the edit face as everywhere the rule syntax is read.
412
+ - **Now.** One reading: the normalizer folds a command rule's content with the validator's own `foldSpacing`, then looks for the trailing ` *` β€” one sentence, one canonical row (`Bash(adb:*)`, `Bash(cd /tmp && adb pull:*)`). A blank inside quotes stays data (the rule admits only the command spelled that way); unbalanced quoting passes through to the validator's own refusal; a non-command tool's content is not folded (a path's blank is part of the path). Blanks around the rule stay refused as written β€” the reference's editor trims what a person typed before it validates, so a surface trims before it submits; `precheckEditedRuleText` and the confirmation answer the same. The settled-replay arm reads a retry through the same normalizer (a retry spelled with a stray inner blank is the same choice). Consequence of the form space probed (the pin states it by corpus, not proof): the card-edit face lands no `wildcard` row for a command text β€” `exact`, `prefix` and `pattern` remain; the store, import and sync doors read `wildcard` as before.
413
+ - **Behavior change (open to veto).** (1) *What changed:* the four inner-blank forms above that persisted the wildcard row `Bash(adb *)` persist the prefix row `Bash(adb:*)`; the chain form with a blank before the closing paren is accepted as the compound prefix instead of refused. (2) *Who is hurt:* a host whose test pins the wildcard row as reachable through the edit gate (server's `permission-rules-lane` G2w pins the 7.55.0 form, ` Bash(adb *)` β†’ wildcard: on 7.56.0 that text is refused, and here the inner-blank forms land prefix); a wildcard row an earlier version stored from such an edit is not rewritten (it still reads as it did). A settled card edit minted before this version keeps its receipt on a byte-for-byte retry; a retry spelled differently (the same sentence with another blank) no longer recovers it from a stored wildcard row β€” it reads as the prefix row now, a different row (`selection_mismatch`). (3) *How to migrate:* read the edit gate's reachable matches as `exact` / `prefix` / `pattern`; trim what a person typed before submitting.
414
+ - **Consumers.** @server: the S-2071 question is answered β€” blanks around a rule: not accepted, since 7.56.0 (loud, `invalid.grammar` + `respelling`); the edit gate's `wildcard` reachability ends with this version β€” flip the G2w pin to the refusal and narrow the contract's reachable words (Β§968) to `exact` / `prefix` / `pattern`.
415
+ - **Pins.** `test/backlog2564-edit-spelling-one-fold.test.ts` (E1 seven spellings of `adb *`, each a confirmation on a real card and the redeemed row, one canonical spelling; E2 no wildcard row, the validator itself still reading it; E3 chain card, three spellings; E4 a blank inside quotes is data; E5 unbalanced quoting passes through; E6 a star the body carries is not rewritten; E7 a path rule is not folded; O1 five spellings with a blank around the rule, refused on both faces with the card left open; O2 the respelling is accepted; R1 a settled retry through the fold; R2 a record settled before the fold keeps its receipt on a byte-for-byte retry, and another spelling of its sentence is `selection_mismatch`) β€” nine cells red on the base, and each guard family red under its own mutation.
416
+
417
+ ### `thinkingOffSpelled` is the one answer to "can this model's thinking be turned off" β€” derived from the wire table, no catalog key for it; a completions model whose `thinkingFormat` names no dialect now answers `false`
418
+
419
+ - **What changed.** `thinkingOffSpelled(model)` (already on the package root) is the one reader of whether the wire carries a disable
420
+ key for a model, and the one answer a host that lists models serves. It is derived from the entry's wire table (API family,
421
+ `compat`, `thinkingLevelMap.off`, `reasoning`), so `Model` grows no key for it, the way `reasoningEffortLevelsOf` derives the
422
+ supported effort tiers (Claude Code derives its catalog row's `supportsThinkingOff` the same way β€” it declares nothing per row).
423
+ The reader's JSDoc states the contract, and `docs/sdk/03-brains-and-models.md` and `INTEGRATION-CORE.md` Β§1.10f say how a host
424
+ wraps it. The chat-completions dialect names are now ONE closed table (`completionsFormatOf`, `brain/reasoning.ts`) that both the
425
+ reader and the wire applier's dialect lookup read, so what the reader claims and what the wire carries are one judgement of the
426
+ name.
427
+ - **Behaviour change (a malformed `compat` corrected; open to veto).** What changed: a completions-family model whose
428
+ `compat.thinkingFormat` names no dialect β€” a string outside the closed set (`openai`, `openrouter`, `deepseek`, `together`,
429
+ `zai`, `qwen`, `qwen-chat-template`), or a value that is not a string (an array, an object, a boxed string) β€” answered `true`
430
+ ("the wire spells off") while its wire carried no thinking key of any tier; it now answers `false`. Who is hurt: a host that
431
+ handed the engine such a model object and relied on the `true` β€” the classifier's answer-only seat then takes the `low` tier with
432
+ the thinking allowance in its output cap where it took `off` before, the `classifier.role_defaulted` line says "cannot turn
433
+ thinking off" for it, and a listing that wraps the reader serves `false`. A server's catalog never reached this: its compat
434
+ reader drops a bad format before the engine sees the model. How to migrate: declare `compat.thinkingFormat` as one of the seven
435
+ names (or leave it undeclared for the stock `openai` rules); nothing else changes β€” an undeclared format and every well-formed
436
+ one answer as before.
437
+ - **Consumers.** @server: a model row served by `GET /v1/models` can carry `supportsThinkingOff` as `thinkingOffSpelled(model)`
438
+ (the same wrapping as `supportedEffortLevels` from `reasoningEffortLevelsOf`), next to the row's `reasoning`. @client-core: read
439
+ that key where it is served instead of probing, and a probe's `cannot_disable` verdict need not delete the entry's
440
+ `thinkingFormat` to be recorded. @test: the reader and the applier's `off` arm answer alike for every model of the reasoning wire
441
+ matrix.
442
+ - **Pins.** `test/backlog2566-thinking-off-reader.test.ts` (R1 the root carries the reader and a `supportsThinkingOff` on the entry
443
+ changes nothing; R2 reader ⇔ the applier writes a disable key, every matrix model; R3 the same through the real brains; R4 a
444
+ malformed `thinkingFormat` answers `false` from the shared judge; KL a malformed format is still accepted and writes nothing on
445
+ every tier).
446
+ - **Known limit.** A bad `thinkingFormat` is read as "no dialect" and accepted: nothing refuses it where the model enters the
447
+ catalog and nothing announces that no thinking key will go out for it.
448
+
449
+ ### A case twin stored in a session's rules can be taken out by its owner: the write judge and the tighten comparison read one roster (#2573; behavior change (one refusal retired), open to veto; hard-breaking: none; closed sets: none; exports: none) (@client-core @server)
450
+
451
+ - **Before.** A session's stored rules holding a case twin of an engine tool (`toolDeny: ["BASH"]` beside the catalog's `Bash`,
452
+ written past the write gate by an older release) could be neither kept nor removed by the session's owner. The write judge
453
+ read an entry's tool name against the engine's catalog βˆͺ the names the store declares (`mountedToolNames`) β€” `BASH` reads as
454
+ nothing there, so a write that kept it was refused `inert_entry` β€” while the tighten comparison (`loosenReasons`) read it
455
+ against the declared names alone, where `BASH` is a tool's name: taking it out was a loosening, so the owner's (non-operator)
456
+ write was refused `loosen_forbidden`. Every run of that session was refused at the policy audit (`config.legacy_tool_name`)
457
+ in the meantime; only an operator write cleared the row. Two readers answered one question two ways.
458
+ - **Now.** One roster, defined once (`storeRoster`: the engine's catalog βˆͺ the store's declared names) and read by both: the
459
+ write judge's refusal of an entry that reads as nothing and the comparison's effective set. A case twin of an engine tool is
460
+ nothing on both seats, like a retired name already was (#1156): the owner's write that drops it is accepted (the deny list
461
+ guarded nothing), and adding one to an allowlist widens nothing. A write that KEEPS the twin is still refused `inert_entry`
462
+ (the entry names nothing; the way out is to drop it). A twin the store declares is a real tool's name on both seats and
463
+ guards as before.
464
+ - **Behavior change (open to veto).** *What changed*: removing a case twin of an engine tool's name from a stored session deny
465
+ list is no longer a loosening (the exported `loosenReasons` and the write judge it feeds, both bundled stores). *Who is
466
+ hurt*: a deployment that mounts its own tool under a case twin of an engine tool's name (its own `BASH` beside `Bash`, or a
467
+ tool alias spelled so) and did not declare it in the store β€” the write judge already refused writing such a deny (it read the
468
+ name as nothing); a stored one (an operator's, written before the write gate read catalog twins) can now be removed by a
469
+ non-operator write, as a retired name's already could (KL-2573-a). The store has no run's roster, so only its declaration can
470
+ tell a live twin from a dead one. *How to migrate*: declare the name in the store's `mountedToolNames` (the store then guards it
471
+ as before).
472
+ - **Consumers.** @client-core: a removal write for a stored case twin (the `nothing_to_remove` class) is accepted now, in the
473
+ same write that may tighten; a write that keeps the twin is still refused. @server: no change β€” a durable backend calling
474
+ `judgeSessionRulesWrite` / `loosenReasons` reads the one roster with the new engine; a backend that re-implemented the
475
+ comparison keeps its own reading.
476
+ - **Pins.** `test/backlog2573-store-roster-one-reader.test.ts` (A the twin is removable through the write judge, the file
477
+ store on disk and the pure predicate, the allow side too; B a write that keeps the twin, a real loosening beside it, a
478
+ declared twin and a retired name keep their answers; C the one-answer law over a 28-entry corpus Γ— five declarations: refused
479
+ as written ⟺ removal is no loosening / adding widens nothing). `test/backlog1930-near-miss-refuses.test.ts` D3 re-pinned to
480
+ the surviving reading (the owner takes the twin out and the session runs again).
481
+
482
+ ### The policy-name refusal carries its problems as data: `config.legacy_tool_name` `detail.problems` with the layer (#2574; additive; hard-breaking: none; closed sets: none; exports: none) (@client-core @server)
483
+
484
+ - **Before.** The prepare-time policy-name audit refused a run at the first entry it met (`config.legacy_tool_name`) with a
485
+ sentence and no `detail`; a shell that wanted to say which entries of which layer were refused had to parse the sentence,
486
+ and a layer with several refused entries showed one per rejected attempt.
487
+ - **Now.** The audit reads one layer's whole pass before it refuses. The sentence and the code are the first entry's, unchanged;
488
+ `detail` is `{ problems, total }`: one problem per refused entry in scan order (list by list, entry by entry), each
489
+ `{ code: "config.legacy_tool_name", field, entry, reason, layer }` β€” the four keys of an entry problem of a rejection body
490
+ plus the layer: `field` the policy list (`deny` / `ask` / `allow`), `reason` the name judgment's verdict word (`retired` Β·
491
+ `unprefixed_namespace` Β· `unmintable_segment`, and `near_miss` for another spelling of a carried name), `layer` one of
492
+ `caller_policy` Β· `session_rules` Β· `ancestor_session_rules` (an ancestor's rules are not asked for case twins, as before).
493
+ At most 32 problems are listed and `total` is the real count; an entry longer than 128 characters (a sentence, not a name) is
494
+ counted in `total` and not listed β€” never shown cut (the failed terminal's `coded` snapshot drops a string past its bounds and
495
+ a list that does not fit whole, so the list is bounded where it is minted). A single refused entry is a list of one.
496
+ - **Limits (stated).** The layers are read in order (the run's own policy, then the session's rules, then each ancestor's):
497
+ the layer that refuses first is the one listed, and a later layer's entries show once it is fixed (KL-2574-a).
498
+ - **Consumers.** @client-core: read `detail.problems[].layer` instead of the sentence. @server: the same shape for the body
499
+ it mints (`detail.problems` of the rejection body, A.1f β€” `layer` is core's one addition: the layers are core's).
500
+ - **Pins.** `test/backlog2574-legacy-name-problems.test.ts` (A one pass lists every refused entry with its verdict word, the
501
+ ask list a list of its own, a list of one is the same shape; B the layer word on each of the three layers; C the sentence and
502
+ code are the first entry's; D the first refusing layer is the one listed; E through a real Runner the failed terminal carries
503
+ the detail, cut at 32 with `total` 40, thirty-two names of 128 characters all kept, an entry past 128 counted and not listed).
504
+
505
+ ### A halt reaches a compaction pass's summary call whatever the brain does with the signal (#2875; behavior change: a summary call that ignores the abort is no longer waited out)
506
+
507
+ - **Before.** Since 7.52.0 (#1828) every stop verb cuts every compaction pass, and the first-party brains end the summary call on the abort in every wait (connect, first byte, stream, a 429 / 503 `Retry-After` backoff). But the summary call itself trusted the brain to look at `options.signal`: a brain or gateway wrapper that did not held the pass β€” and `done` β€” until it answered (KL-1828-d).
508
+ - **Now.** The summary call is an await of the pass like the summary-provider consult and the credential callback: the pass signal firing first answers the call's abort outcome at once (a signal already fired dispatches nothing), the late answer is dropped, and the pass reads `compaction_outcome{outcome: "mooted", reason: "cancelled"}` with its `trigger` and the `pass` its `compaction_started` carried, as every cut pass does. One site (`completeSummarization`), every lane (turn boundary, prompt-too-long recovery, guard chain, end of task, `compactSession`). A halted run reads `haltedByUser: true`, `terminal.kind: "completed"`. KL-1828-d is closed.
509
+ - **Consumers.** @server @cli: no wire change, no new word. A halt landing while auto-compaction is summarizing ends the run within a second on every brain; where it landed is the open pass (`compaction_started` without its concluding frame until the `mooted` / `cancelled` one).
510
+ - **Pins.** `test/backlog2875-halt-compaction.test.ts` (β‘  the turn-boundary auto pass: the summary request held open, a brain that ignores the signal; β‘‘ the recovery pass, both forms; β‘’ the summary call in a 429 backoff, a brain that sleeps a 429 out without the signal, the main call in a 429 backoff with its `gave_up` / "cancelled while retrying" status; β‘£ controls; β‘€ the call site: an already-fired signal dispatches nothing, a held call is cut, a stop inside the call's setup wins over the setup's throw, a late rejection goes nowhere, no listener per call); `test/backlog1828-stop-during-pass.test.ts` W1 re-pinned; `test/manual-compact-cancel.test.ts` β‘‘c re-pinned to its own case β€” a real failure whose answer arrives before the cancel stays a failure (a cancel that fires before the answer is the call's abort outcome).
511
+ - **Limits.** A brain that ignores the signal keeps its call running after the cut, and its usage may be booked after the result is assembled (KL-2875-a). The main model call still trusts the brain to look at the signal (#2882).
512
+
513
+ ### Every refusal of an approval decide names where the fault is β€” a defect of the caller's payload carries `detail.field`, a damaged row carries `detail.reason`, and `detail.reason` on `checkpoint.invalid_outcome` is a row-integrity word and only that (#2592; additive wire words; hard-breaking for a host's total table over `CheckpointErrorField`, open to veto; closed sets: `CheckpointErrorField` 10 β†’ 14 (+`outcome`, `updatedInput`, `decision`, `reason`), `CheckpointErrorReason` 29 β†’ 30 (+`bound_input_hash_missing`); exports: none β€” two exported types gain members) (@client-core @server @cli @sdk)
514
+
515
+ - **Before.** Seven refusals on the approval decide's path carried no word at all: the resume's outcome that is not an object, a person's edit (`updatedInput`) that is not plain JSON data, a decision word outside `allow` / `deny`, a deny `reason` that is not a string, a deny `reason` carrying the engine's `<system-reminder>` tag β€” and a binding-version row whose pending call has no persisted `boundInputHash`, the one refusal of the seven that is a damaged row (the seventh, the admission's "no lane captured it" belt, is an engine invariant). A host that told a dead row from a fixable decide by "no `field` β‡’ row integrity" β€” a reading from absence β€” took the five payload defects for dead rows and hid cards a person could have fixed.
516
+ - **Now.** One rule. A refusal of an approval decide carries at most one of two words: `detail.field` when the decision, or the live state it was bound to, is what is at fault (`outcome`, `updatedInput`, `decision`, `reason` join `boundCallId` / `boundInputHash` / `boundGrantDigest` / `answer` / `hostDecision` / `approver` / `feedback` β€” each word's entry in the registry gives its recovery: correct the cell, re-fetch the pending list, deny and re-activate), or `detail.reason` when a facet of the stored row is damaged (`bound_input_hash_missing` joins the ten row-integrity words the resume screen already spelled β€” no re-decide of that row helps). `detail.reason` on `checkpoint.invalid_outcome` is therefore a row-integrity word and only that, which is what lets a host read "`reason` present, `field` absent" as positive evidence of a damaged row. A refusal with neither word is never a damaged row: it is a payload of a lane the set does not word yet (the review lanes' text payloads and the resource-limit lane's decision word) or an engine-invariant belt (the admission's lane-capture belt and the two post-claim belts of the resumed leg), and `docs/CLOSED-SETS.md` says so. The sentences are unchanged and a refused decide still leaves the row pending and redeemable.
517
+ - **Hard-breaking (open to veto).** *What changed:* `CheckpointErrorField` gains four words (`outcome`, `updatedInput`, `decision`, `reason`), 10 β†’ 14; `CheckpointErrorReason` gains `bound_input_hash_missing`, 29 β†’ 30. *Who is hurt:* a deployment that holds a `Record<CheckpointErrorField, …>` (the server's `CHECKPOINT_ERROR_FIELD_ROLE`) is tsc-red on the four new words until it places them, and a host that switches over `detail.field` without a default meets an unplaced word at run time; a host that read the missing `reason` of the damaged-row refusal as "not a row" now reads it as a row. *Migration:* add four rows β€” all four are cells of the decision whose recovery is the one `feedback` / `hostDecision` already have (re-decide the same token with the cell corrected); treat `reason: "bound_input_hash_missing"` like the other row-integrity words (no re-decide of that row helps, and no worker version redeems a row that lost its hash: expire it and start the task again).
518
+ - **Consumers.** @client-core: `refusedParkFromError` can delete its "no `field` β‡’ row integrity" inference and judge on the positive evidence β€” `field` present = an intact row whose decision is what to act on (by the word's own recovery), `reason` present and `field` absent = a damaged row, neither = not a row; the five payload refusals above stop reading as dead rows once the engine ships. @server: the HTTP 409 for `checkpoint.invalid_outcome` passes `detail.field` / `detail.reason` through unchanged (add the four field rows to the role table). @cli, @sdk: nothing to place; the two words are the ones the decision card already branches on.
519
+ - **Docs made true.** `docs/CLOSED-SETS.md`: the `CheckpointErrorReason` bullet said twenty-eight words while the union held twenty-nine (7.56.0's `skill_scopes_damaged` was not counted) and now says thirty and names every word, the three `installation_record_*` words by their full names; the one rule and the line of row-integrity words are registered there, and the pin reads them against the source.
520
+ - **Pins.** `test/backlog2592-policy-ask-refusal-words.test.ts` (F1–F5 each payload refusal on a real Runner over a durable park β€” `detail` exactly `{ field }`, the sentence as before, the row pending and then redeemed; R1 / R2 the damaged-row refusal `{ reason: "bound_input_hash_missing" }` against its control; C the words that already existed; T1–T4 the registry's counts and member names, the line of row-integrity words equal to what the source's `invalid_outcome` constructions spell, no construction spelling both words; Z1 / Z2 the census of constructions with neither word β€” the review lanes and the belts β€” exactly as registered); re-pinned: `backlog2240-feedback-refusal-field` T (the total table, 10 β†’ 14 rows).
521
+
522
+ ### One composition for the environment a child spawned on this host starts with β€” the tool shell's children and a settings command hook's children read the same `hostChildEnv(policy, ...grants)`, so a hook starts from what the run's shell starts from (#2607; behavior narrowing, open to veto; the hook-runner widening it enables is a security widening, open to veto; hard-breaking: none; closed sets: none; exports: +3 `hostChildEnv`, `hostChildEnvProblem`, type `HostChildEnv`) (@server @cli @test)
523
+
524
+ - **Before.** The same settings hook saw two environments. A hook the engine host runs (the nine engine-owned events) started from a fixed list of twelve names (`PATH`, `HOME`, `SHELL`, `USER`, `LOGNAME`, `TERM`, `TZ`, `LANG`, `LC_ALL`, `LC_CTYPE`, `LC_MESSAGES`, `TMPDIR`) plus the request's `settings.env` and the hook's own variables β€” a list kept beside the server's hook runner, not by the engine; a hook the terminal client runs itself started from its whole process environment. The client documents the split as undecided (its KL0157). The engine composed its tool shell's child in `NodeExecutionEnv` alone (`inheritedHostEnv(policy)`, then `shellEnv`, then a per-exec `env`), so a hook runner that wanted the shell's reading had no function to call and wrote its own. A `shellEnv` / per-exec `env` entry whose value was not a string reached the child as Node's string of it (`[object Object]`, `8080`), and a name holding `=` became another name / value pair in the child.
525
+ - **Now.** `hostChildEnv(policy, ...grants)` (`src/core/secret-env.ts`, root export) is the one composition: `inheritedHostEnv(policy)` (a deployment's own credential is never inherited, under any policy, by name or by value), then each grant in order, each read once and after the inherited part (a later grant's value wins, names compared as the platform compares them β€” case-blind on Windows, the value landing under the spelling the name first had; an `undefined` value unsets; a grant is the host's explicit act and is not read against the declaration, as before), and `withheld` = the inheritance's findings the composed environment does not set. `NodeExecutionEnv` composes every shell and background-shell child through it, and its `withheldEnv` / `homeDir` / `cdPath` reads read it. The reading for a command hook (INTEGRATION-CORE Β§11, "A hook's child"): `hostChildEnv(<the run's inheritEnv>, <the run's settings-env grant>, <the hook's own variables>)` β€” the same policy the run's tool shell inherits under (absent β‡’ `"scrub"`; where no tool shell runs on the hook's host, the run's word applied there), never a hook-specific list; the one place that configures it is the run's `inheritEnv`; no hook-specific knob. The reference's ordinary command hook builds its child on the same base as its Bash tool (`cli309.js:266734`, `:266386`; base `:253905`: the process environment with the trusted settings env, its own credentials removed); its exceptions β€” a first-party plugin allowlist handed the reference's own token as an explicit grant (`:266738`), organization hooks composed over the pre-plugin settings env (`:266737`), a hook run inside a served sandbox β€” have no counterpart here. `hostChildEnvProblem(policy, ...grants)` answers the same judgment without throwing. A grant that is not an object or throws while read, a name that is empty or cannot keep its spelling in a child's environment (`=`, NUL, an unpaired surrogate), and a value that is not a string or cannot keep its spelling (NUL, an unpaired surrogate) are refused with a sentence that names the grant and the variable (never a value, nor a bad name).
526
+ - **Behavior narrowing (open to veto).** *What changed:* `NodeExecutionEnv` refuses a `shellEnv` that is not a map of variable names to strings at construction (`NodeExecutionEnv: env grant 1: X must be a string (got number)`), and a per-exec `env` or a `shellEnv` made bad later makes that spawn answer `spawn_error` with the same sentence (the reads answer "none"). *Who is hurt:* a JavaScript host passing a number, a boolean or an object as an environment value (it reached the child as Node's string of it), a name holding `=` (the child read another pair), or a name or value holding an unpaired surrogate (the child read U+FFFD); a `shellEnv` whose read throws. *How to migrate:* pass strings (`String(port)`) and names the platform keeps. Smaller changes, same direction (the account and the child now agree): a withheld name the child does not receive is counted withheld even when a grant mentions it β€” a per-exec `env` entry set to `undefined` over a `shellEnv` re-supply, or a grant property a spread never copies (non-enumerable, inherited), used to count as re-supplied; on Windows a later grant spelling a name in another case now sets that name's value (Node kept whichever spelling sorted first, so the earlier value could win); the inherited part is read before any grant, so a grant's getter cannot change what is inherited.
527
+ - **Security widening the hook runner adopts (open to veto).** *What changes when a hook runner reads it:* an engine-run hook sees what the run's tool shell sees β€” on the terminal client's interactive lane (`inheritEnv: "all"`) the host's whole environment less the deployment's own credentials, under the default `"scrub"` every variable whose name and value are not credential-shaped β€” instead of twelve names. A server runs settings hooks on its worker in every single-user deployment, whatever the tool lane, so the widening reaches a single-user sandbox or in-process lane too (the run's word there; `"all"` is refused outside the host lane, so `"scrub"`). *Who is hurt:* a deployment that relied on the short list to keep a non-credential variable of the worker from a request-supplied hook command β€” a capability or routing variable such as `DOCKER_HOST` pointing at an administrative daemon is neither a declared own credential nor credential-shaped, and reaches the hook as it reaches the shell (a hook is a command run on that host with the host's user; nothing here changes what such a command can otherwise reach). *How to migrate:* declare such a variable with `declareWithheldEnv` (it is never inherited by any child, the shell's included), or narrow the run's `inheritEnv` to a list.
528
+ - **Consumers.** @server: the hook runner (`src/hooks/hook-runner.ts`, `HOOK_ENV_ALLOWLIST` and its two readers) composes the command leg and the HTTP interpolation with the word the same request carries for its shell (bound when the request's hook registration is minted, not read later from the mutable session map) and the request's `settings.env` grant, the hook's own variables last β€” its `CLAUDE_PROJECT_DIR` rule (the request's value when it sets one, else the hook's directory) becomes how that last grant's value is computed, not an order; the twelve-name list retires; a `settings.env` name the composition refuses (`=`, NUL, an unpaired surrogate) is best refused at intake, where the request can be told; the host-lane shell's own composition (`composeHostSubprocessEnv` with `collapseWin32EnvKeys`) can read `hostChildEnv` so the shell and the hooks share one. @cli: the local executor (`localHookChildEnv`) and the HTTP hook's interpolation (it reads the raw process environment) compose with `hostChildEnv(<the word the session hands the engine>, <the settings env grant>, <the hook's variables>)`; the engine needs the same settings env grant for one reading (the default rules projection does not send `env`); the client process declares its own credentials (`declareWithheldEnv` β€” none is declared in the client today), which takes the place of the conditional subprocess list for hook children; on the interactive lane (`"all"`) the local hooks keep the whole environment less those, and where the client sends no word (non-interactive, missing capability evidence) the local hooks narrow to the scrub β€” the client's to rule on under C-R284 β‘£ (send the word, or accept); KL0157's environment half retires when both runners land (its compaction and run-placement halves stay). @test: one hook configuration run in the shell and in the engine reads the same terminal-exported variable and the same settings-env variable, and neither reads a declared own credential.
529
+ - **Pins.** `test/backlog2607-host-child-env.test.ts` (C1 the root export; C2–C4 the three policies with a declared own name and a value copy; C5 grant order, re-supply, unset and a `__proto__` name; C5b Windows name comparison, platform stubbed; C6 the hook composition = the shell's plus the hook's variables, the withheld account the composition's (a hook variable re-supplying a withheld name); C7 / C7b thirteen bad shapes, a throwing grant, a revoked Proxy, a throwing policy element and the problem reader; C8 a grant read once, after the inherited part, a non-enumerable property not composed; C9 / C9b a real shell child and a real background child print what `hostChildEnv` composed; C10 the shell's refusal at construction and at the spawn, the reads composing once; C11 the shell's composition site calls the one reading).
530
+
531
+ ### Every model call the engine prices has one account line, and a host reads its lines through one fold: `Runner.sideQuery`'s result carries its engine-priced `account` (origin `side_query`), `accountRowOfResult` derives a finished run's line, `foldAccount` is the only reading (#2608; additive; hard-breaking: none; closed sets: +1 `AccountOrigin` = `run` | `side_query`; exports: +7) (@server @cli @client-core)
532
+
533
+ - **Before.** A one-shot side query (`Runner.sideQuery`: an auto title, a recap) belongs to no run, so its spend never reached a run's `stats`, and the result carried only the provider's own `usage.cost` (an adapter amount: higher than the engine's figure whenever a cache hit is priced at the full rate). A host that kept a session total had nothing to add for it, and every host that summed run results wrote its own sum, with its own reading of an unpriced run.
534
+ - **Now.** One pricing function, `priceReply`, prices a reply for both readers: the run's side-call lanes (`recordSideCallUsage`: compaction, classifier, mods, advisor β€” same arithmetic, telemetry marks and trace row as before) and the side query. `SideQueryResult.account` is the query's line β€” `{ origin: "side_query", tokens, costMicroUsd?, usageMissing? }` β€” priced from the deployment's table (`RunnerDeps.pricing`, else the model's own `cost`) on the raw provider usage and the model that ANSWERED (a degraded reply is priced at the fallback). `costMicroUsd` is absent when that model has no price table (unknown, not a fabricated 0 β€” the run's law), and a reply that reported no usage gives `tokens: 0` with `usageMissing`. `accountRowOfResult(result)` is a finished run's line (`origin: "run"`): its own usage plus its delegated sub-agents' β€” the reconciled spend. `foldAccount(rows)` is the one reading: a total and one total per origin; an unknown cost makes every total containing it unknown; a malformed line (origin outside the closed set, a negative or non-finite number, a cost spelled as anything but an absent key) is refused with `TypeError` naming the line. The engine does not keep the lines: the host does.
535
+ - **Limits (stated, not exceptions).** A run's line is exactly what the result's `stats` says, and `stats` is not one interval across a durable resume chain, so the line is exact for a run that did not durably resume and that no background delegate outlived. (1) The lines of ONE durably resumed chain are not additive: a leg's own usage is per leg (a `resource_limit` chain folds the earlier slices into its result), its delegated usage is cumulative over the chain, so one line per result double-counts the delegates and one line per chain loses the earlier legs' own spend. (2) An unknown cost does not survive a `resource_limit` chain (the resource ledger folds a slice's cost as a number) or the delegation rollup (a delegate's `usageMissing` mark has no seat in the nested usage), so a line can read complete when it is a lower bound. (3) Spend a background delegate books after the parent's result settled is in no line. (4) The prompt-suggestion pass and memory consolidation book after the result on their own budget-excluded faces and are not in it. (5) A malformed price table prices at its arithmetic on a side query, as it does for a run whose deployment governs no money. The structural fix for (1)–(3), an account the engine keeps and mints at each interval, with persistence and restore on resume, is its own design ticket (#2620).
536
+ - **Consumers.** @server: a session-level aggregate is `foldAccount` over per-run `accountRowOfResult` lines plus the side-query lines you receive from your side-query verb (carry `account` through; a layer that rebuilds `SideQueryResult` must now supply it). @cli: the auto-title side query keeps the returned `account` line beside the run lines; the result frame field is the second section below. @client-core: the history-lines read port supplies rows, not transcript `usage.cost.total` (the adapter amount).
537
+ - **Pins.** `test/backlog2608-session-account.test.ts` (the line's price, the table read from the Runner, the model's own cost with a cache subset, parity with the run's side-call pricing, usageMissing, the degraded reply priced at the fallback, the run line before and after a side query, the fold's totals / unknown propagation / loud refusals, the import graph: one pricing function with two readers, one mint per origin).
538
+
539
+ ### A session's total is the fold of the lines the host kept: a result frame's `total_cost_usd` is the run lines including a resumed session's history, and a side query's line is in the session's cumulative figure but not in that field (#2610; behavior change for a host that adopts the reading, open to veto; hard-breaking: none; engine behavior unchanged) (@cli @server @client-core)
540
+
541
+ - **Before.** A `-p` result frame's `total_cost_usd` was this run's cost only: resuming a session showed the new run's number as if the session had spent nothing before, and a side query's spend was in no number.
542
+ - **Now.** The reading is fixed once, in `foldAccount`'s output, and every host maps its fields from it: a result frame's `total_cost_usd` = `byOrigin.run` over the history lines the host supplies plus this run's line (a new session = this run; a resumed session = history + this run; a fork's seed lines under the cli's fork ruling are ordinary `run` lines), `byOrigin.side_query` is kept apart, and a session's cumulative figure = the whole fold. This is the Claude Code 2.1.309 split: one cost ledger whose result-frame total is the main-loop total including the restored history, with a separate side-query line that enters only the cumulative metadata.
543
+ - **Behavior change (open to veto).** A host that adopts the reading shows a larger `total_cost_usd` on a resumed session than before (history is now in it). One erratum against the ticket wording "a side query's cost enters the session account": the line IS in the account; what differs from the wording is only which host field reads it (frame total = `byOrigin.run`, cumulative = the whole fold). The engine itself changes no behavior in this section: it supplies the lines and the fold.
544
+ - **Consumers.** @cli: map the frame field from `byOrigin.run`, the `/cost` cumulative from the whole fold, and supply fork / resume history as `run` lines; the numbers on resumed sessions grow. @server: the session-level aggregate states which total it serves ("includes fork inheritance" per the cli ruling). @client-core: the read port returns the lines.
545
+
546
+ ### The cwd-alignment observation asks the env's shell whether its directory is the task root instead of comparing two path strings β€” no misreport on a Windows Git Bash shell, and the sentence states only what was read (#1734; behavior change, open to veto; hard-breaking: none; closed sets: none; exports: none) (@test)
547
+
548
+ - **Before.** The env probe's `pwd -P` line and the task root were each passed through the env's `canonicalPath` and compared
549
+ as strings. On Windows the task root is a native path (`C:\Users\x\proj`) while a Git Bash shell reports the same directory
550
+ in its own POSIX spelling (`/c/Users/x/proj`, `/tmp/…`), which no engine-side canonicalizer maps β€” so every session (an
551
+ ordinary `C:\` root as much as a TEMP-mapped one, and a host-lane remote env) reported `execution-env cwd misalignment …`
552
+ through `onError` (`phase: "config"`) while the shell sat in the task root. The sentence also said an exec or an artifact
553
+ "can land outside the workspace root", which was untrue on every such report. A POSIX host has one spelling and never saw it.
554
+ - **Now.** The probe's plain `pwd -P` line becomes one self-framed line, `cwd-alignment:<word>:<the shell's pwd -P>`, found
555
+ by its marker (a banner a login shell prints first moves nothing, and a reading that holds the separator stays one
556
+ reading). The shell itself asks whether its working directory and the task root are one directory β€” `test . -ef <root>`,
557
+ the same filesystem object, links followed, spelling and case irrelevant β€” and the word is `same`, `differ` or `unknown`.
558
+ The engine reads only that word; no path mapping and no second canonicalizer exist on the engine side. `differ` reports;
559
+ `same` is silent (a symlinked root, a differently cased spelling on a case-insensitive volume and an msys-spelled pwd are
560
+ one directory to the shell); `unknown` β€” the root is not a directory in the shell's view, or its `test` has no `-ef` β€” and
561
+ an absent framed line are no judgment and report nothing. The sentence now states the two readings and the shell's
562
+ finding and nothing about where an exec or an artifact would land.
563
+ - **Behavior change (open to veto).** *What changed*: (1) the observation no longer fires on a spelling difference β€” only on
564
+ the shell's own `differ`; (2) a shell that cannot see the task root as a directory answers `unknown` and is silent (before:
565
+ any string difference reported); (3) the sentence lost its cause and landing clauses; (4) the guard no longer calls
566
+ `canonicalPath` (one round trip less per prepare on a remote lane); (5) the probe's ninth output line is the framed line, so
567
+ a scripted `exec` double that answers the probe with a bare `pwd` line yields no observation (before: it was compared).
568
+ *Who is hurt*: a deployment that matched the old sentence text beyond `cwd misalignment`, a test double of that shape,
569
+ and a lane whose real fall-through also happens to hide the root from its shell (the observation is advisory β€” the
570
+ sandbox fence is unchanged). *How to migrate*: match on `cwd misalignment` only; a double that wants the observation
571
+ answers the framed line.
572
+ - **Consumers.** @test (the Windows machine): run two shapes with Git Bash as the env shell β€” an ordinary `C:\` task root and
573
+ a TEMP-mapped one, expecting zero `cwd misalignment` observations; and a lane that starts the shell elsewhere, expecting
574
+ exactly one with the fact-only sentence. @server: the host-lane remote env needs no change β€” the question runs in the
575
+ host's own shell, in the same POSIX-`sh` family as the rest of the probe.
576
+ - **Limits (stated).** Pinned on a real bash with an msys-shaped `pwd` / `test` stand-in; the real Windows reading is the test
577
+ seat's. A shell that cannot parse a native `C:\…` root at all (a WSL bash) answers `unknown` β€” silent, not a false report.
578
+ The probe's earlier lines are still read by position, so a login banner shifts those facts as before; only the
579
+ alignment line is immune.
580
+ - **Pins.** `test/backlog1734-cwd-alignment-same-directory.test.ts` (Runner: one directory in two spellings is silent; the
581
+ shell's word is read, not two strings β€” `same` over unequal strings silent, `differ` over equal strings reports, `unknown`
582
+ and an absent framed line silent; a really different directory reports once with a fact-only sentence, also behind a login
583
+ banner; a symlinked root silent; the same two shapes behind the remote seam; the fragment on a real bash: Windows-style
584
+ root Γ— msys-style shell `same`, different directories `differ`, unenterable root `unknown`, symlink `same`, a case alias
585
+ under an inherited `PWD` `same`, hostile spelling stays data, a reading holding the separator or a newline; the reader's
586
+ closed set); re-pinned: `env-git-probe` ([1451] drop-cwd sentence).
587
+
588
+ ### A store that copies a fork's rows as bytes picks them with the engine's own parent-chain walk: `selectForkRows` is exported from the package root (#2565; additive exports; behavior change: none; hard-breaking: none; closed sets: none; exports: +3 (1 runtime: `selectForkRows`; 2 types: `ForkPoint`, `ForkRowShape`); members: none; signatures: none) (@server)
589
+
590
+ - **Before.** A session store with no `SessionRepo.fork` to hand `settledForkOptions`' answer to (the two SQL stores move rows as bytes) had to pick the rows itself: the path from the root to the fork point, the loop refusal and the missing-parent refusal. Server wrote that walk a second time (`forkCopyOf`, copied from `getPathToRoot` and its `ParentChainGuard`, which is not a root export).
591
+ - **Now.** `selectForkRows(rows, sourceLeafId, point, { idOf, parentOf })` answers `{ rows, leafId }`: `{}` copies every row and keeps the source leaf; `{ entryId, position: "at" }` copies the rows on the path from the root to that entry (the path, not a prefix of the log) in the log's order, and the leaf is that entry. It runs the very walk `getPathToRoot` now runs (one `pathToRoot` in `src/engine/session/path-to-root.ts`; the storage keeps no parent-chain loop of its own), so a loop is refused `invalid_session` with the shared sentence, a parent the log does not hold is `invalid_session` naming it, and a fork point the log does not hold is `invalid_fork_target`. A fork point that names an entry with a `position` other than `at` is refused `invalid_fork_target` (a point with no entry id is the whole-log form, as `getEntriesToFork` reads it). `ForkPoint` (the answer `settledForkOptions` gives, now its declared return type) and `ForkRowShape` ride with it. No behavior change on any existing call: `getPathToRoot` answers as before, including an empty parent id reading as "no parent" there (a separate ticket makes that a refusal).
592
+ - **Who is hurt.** Nobody: one added runtime export and two types, no existing name or shape touched.
593
+ - **How to migrate.** *server*: delete the hand-written walk in `forkCopyOf` (`src/plugins/session-fork.ts:34-61` at `e1ea5bd2`, line numbers move) and answer it with `selectForkRows(rows, sourceLeafId, point, { idOf: (r) => r.entry_id, parentOf: (r) => r.parent_id })`; the two call sites (`tidb-session-store.ts`, `pg-session-storage.ts`) stay. The refusals are byte-identical (loop, missing parent, missing fork point, an empty `parent_id` refused as a missing parent); the one sentence that changes is a non-`at` position's (same code `invalid_fork_target`, worded for the reader rather than for a store), and one corner tightens: a row whose id is the empty string is no longer followed as the parent of a row whose `parent_id` is the empty string (the copy followed it; the reader refuses, as it does when no such row exists). `type ForkPoint = Awaited<ReturnType<typeof settledForkOptions>>` may become the root's `ForkPoint` (the same shape). Server deletes its copy on arrival.
594
+ - **Pins.** `test/backlog2565-fork-row-selection.test.ts` (R1 the root exports; R2 `{}`; R3 `at` copies the path not a prefix, log order kept, rows not cloned; R4 the sound / loop / broken shapes and a missing point answer as `getEntriesToFork` does over a storage holding the same log; R5 the refusals in full; R6 an empty parent id; R7 one walk β€” the storage takes it from the module and keeps no `ParentChainGuard` loop, a floor still ends its walk); `test/export-surface.snapshot.json` (+3).
595
+
596
+ ### A refused MCP call says what happened to this call and how a later one is judged, not that every later call is refused the same way (#2589; behavior change in the text the model reads, open to veto; hard-breaking: none; closed sets: none; exports: none; members: none) (@server @cli @test)
597
+
598
+ - **Before.** A call the connection's listing refuses before it is sent (`mcp.tool_declaration_changed`, `mcp.tool_listing_unreached`,
599
+ `delivered: "no"`) ended: "Every call to this tool is refused the same way until a listing of the connection reaches the tool, so
600
+ don't retry it." A host's re-dial or refresh lands between two calls, and the call after it runs: the sentence foretold the
601
+ opposite of what happened, and its advice made an agent give up a tool that worked again (reported by the black-box acceptance:
602
+ the next call after `reconnectMcpServer` ran).
603
+ - **Now.** The same two refusals end: "The server did not execute it. This refusal is for this call only: each later call to this
604
+ tool is checked again against the connection's latest listing." β€” the fact about this call, and the rule a later one meets (the
605
+ rule `reach` asks on every call), never its outcome and no advice. One mint (`listingRefusal`, `src/core/mcp-server-link.ts`) for
606
+ both refusals; the codes, `details`, `delivered` and `isError` are unchanged.
607
+ - **Behavior change (open to veto).** *What changed*: the closing sentence of the two refusals. *Who is hurt*: a host or a test that
608
+ matches the old sentence by its text. *How to migrate*: read `details.code`, as the refusals have always carried it.
609
+ - **The same shape elsewhere.** The four revoked-server refusals and the task-required refusal said the same thing and are closed
610
+ by the next section (#2616); the closing sentence is now one writer, `refusalScope`, for all six.
611
+ - **Consumers.** @server @cli: nothing to do; a surface that shows the tool result's text shows the new sentence. @test: the
612
+ refusal text now holds neither "refused the same way", "don't retry" nor "until a listing" (pin A).
613
+ - **Pins.** `test/backlog2589-2591-one-sentence-one-reader.test.ts` A1 (a re-listing that stopped before the tool: the fact, the rule,
614
+ none of the foretelling words; after the host's refresh the same object runs), A2 (a changed declaration: the same sentence; the
615
+ tool the refresh minted runs while the one minted before is still refused), A3 (the foretelling words are minted nowhere in `src`,
616
+ the new sentence once).
617
+
618
+ ### A directory fault is worded once: the fault states what is wrong with the directory, and the reader of the fault states what it does about it (#2590; behavior change in the text the model reads, open to veto; hard-breaking: none; closed sets: none; exports: none β€” one internal function, `peerRowFault` in `peer-directory`, not index-exported) (@server @cli @test)
619
+
620
+ - **Before.** The row reader's fault ended "; no peer row is used until its host fixes it", and ListAgents added "β€” no peer row is
621
+ listed until its host fixes it": one fact said twice in one line ("…(s-odd: name_invalid); no peer row is used until its host fixes
622
+ it β€” no peer row is listed until its host fixes it)"). The reference registry's vetting fault ended "β€” nothing was listed" under the
623
+ same suffix.
624
+ - **Now.** A fault states the fault: "the directory listed a row this engine cannot read (<id>: <reason>)" (one function,
625
+ `peerRowFault`, for a host's rows and for the reference registry's) and "the reference agent's session registry is not a
626
+ directory this engine can trust (<code>: <path>)". Whoever reads the fault states its own consequence once: ListAgents "β€” no peer
627
+ row is listed until its host fixes it", SendMessage its refusal frame "Message not sent:" (the arm no longer repeats it, #2617
628
+ below). The consequence tail of the row reader's fault and of the registry's vetting fault is gone.
629
+ - **Behavior change (open to veto).** *What changed*: the text of a directory fault, as thrown and as shown by ListAgents and SendMessage.
630
+ *Who is hurt*: a host that matches the thrown message for "no peer row is used" or "nothing was listed" (`CcPeerDirectoryError.code`
631
+ and `.path` are unchanged). *How to migrate*: match the code, or the first clause.
632
+ - **Pins.** `test/backlog2589-2591-one-sentence-one-reader.test.ts` B1 (ListAgents over a host's directory: the one fault sentence and the
633
+ tool's own line, "until its host fixes it" once), B2 (the same over the reference registry), B3 (a registry that fails its vetting: the
634
+ thrown fault, read whole, carries no consequence, and ListAgents states it once), B4 (SendMessage: the whole text is the frame and the
635
+ fault sentence, the fact that nothing was sent said once).
636
+
637
+ ### The reference registry's directory reads its rows through the engine's one row reader β€” a row the reader refuses faults the whole listing, as a host's rows do, instead of being repaired or skipped (#2591; behavior narrowing, open to veto; hard-breaking: none; closed sets: none; exports: none; members: none) (@server @cli @test)
638
+
639
+ - **Before.** One question, two answers. A host's directory hands its rows to the engine as written and the engine reads each through
640
+ `readPeerSessionRecord`: a row it refuses stops the listing (ListAgents lists no peer row and names the refusal, SendMessage sends
641
+ nothing). `createCcPeerDirectory` read the reference's registry file first and repaired what that reader judges: a name that reads as
642
+ nothing (only invisible characters, only blanks) became "(unnamed session)", an `agent` label over 120 characters was dropped, and
643
+ a row the reader still refused (a session id outside the address grammar) was skipped (`invalid_row`). The same row was listed by
644
+ one seat and refused by the other.
645
+ - **Now.** A string name and a string `agent` are carried as the row wrote them and the reader decides; a row it refuses throws the
646
+ same fault a host's row does (`peerRowFault`) out of `listPeerSessions`, so no seat holds half a set (refs are minted and names
647
+ resolved over the full set). `invalid_row` is left for a registry file that is not an object. What the registry directory keeps is the
648
+ reference's own reading of its own file: a row that states no name, or a name that is not a string, is the reference's unnamed
649
+ session, listed and addressed by "(unnamed session)" (the reference's rows for non-interactive sessions state none); a member of
650
+ another type is not carried; capability bits are read by the reference's grammar (`/^[a-z0-9_]{1,32}$/`, at most 16). Liveness
651
+ comes before validity: a row of a dead process, a file with no socket, a file that fails the ownership / mode / size check is skipped as before.
652
+ - **Behavior narrowing (open to veto).** *What changed*: a registry row whose name is only invisible characters or blanks, whose `agent`
653
+ label is over 120 characters, or whose session id is outside `^[A-Za-z0-9_-]{1,80}$` stops the listing of the whole registry
654
+ (ListAgents names the row, SendMessage sends nothing) until that row is fixed or its file removed; it used to be listed repaired or
655
+ skipped. *Who is hurt*: a deployment that reads the reference's registry beside a peer whose row states such a value (a row the
656
+ reference writes states a name only from a flag or a derived name, so the name cases come from another writer; the label and
657
+ session-id cases were not checked against the reference's writer) β€” for as long as the row stands, which the owning process's
658
+ exit ends. *How to migrate*: nothing in the engine; fix the writer of the row.
659
+ Divergence from the reference's tolerant reading of the same file (every ill-typed member read as nothing): candidate, registered under #2862 before the next release.
660
+ - **Consumers.** @server @cli: a host that composes `createCcPeerDirectory` beside its own directory now sees a thrown fault for these
661
+ rows where it saw a listing; its `onSkip` no longer reports `invalid_row` for a row the reader refuses. Which seat a given cli or
662
+ server mount uses is not checked here (inferred: both seats exist).
663
+ - **Pins.** `test/backlog2589-2591-one-sentence-one-reader.test.ts` C1 (five rows the reader refuses β€” a zero-width title, a
664
+ direction-mark title, a blank title, a 121-character label, and a session id outside the grammar β€” read from a host's directory and
665
+ from the reference registry: the same fault sentence, the whole listing, the directory itself throwing, ListAgents showing it and no
666
+ good sibling), C2 (the two seats' fault texts equal across every fixture), C3 (what is not a row's fault stays a skip: a non-object
667
+ file, a row with no socket, a dead process), C4 (what the reference reads is kept: no name / a non-string name is the unnamed session;
668
+ a 120-character label is the cap and reads). `design385-s3-cc-uds-channel` D1 no longer carries a bad-id row (it faults now, C1).
669
+
670
+ ### A revoked server's four refusals and the task-required refusal end as the listing's do β€” what happened to this call and what judges the next one, never "every call to it is refused the same way, so don't retry it" (#2616; behavior change in the text the model reads, open to veto; hard-breaking: none; closed sets: none; exports: none β€” one internal function, `refusalScope` in `mcp-server-link`, not index-exported; members: none) (@server @cli @test)
671
+
672
+ - **Before.** The four outlets of a server the operator revoked (the tool call, the resource read, the resource directory listing, the
673
+ aggregate resource listing) ended "This server stays on this run's tool roster β€” every call to it is refused the same way, so
674
+ don't retry it", and a tool that requires task-based execution ended "Every call to this tool is refused the same way, so don't
675
+ retry it." Both foretold the next call. The revocation ledger is asked on every call, and a server the operator un-revokes runs on
676
+ the very next call (`test/mcp-revocation.test.ts`, the first case); a tool's task-required declaration is the listing's as
677
+ mounted, and the tool a host's refresh mints from a listing that no longer requires tasks runs. The advice made an agent give up
678
+ a server that worked again.
679
+ - **Now.** Six call sites end with the one sentence `refusalScope` writes β€” the listing's refusal (#2589; its two codes), a revoked
680
+ server's four outlets and the task-required refusal: "This refusal is for this call only: <each later call to this tool is
681
+ checked again against the connection's latest listing | each later call to this server is checked again against the operator's
682
+ current revocation list | each later call to this tool is judged by the declaration of the listing it was mounted from, until a
683
+ refresh or reconnect of the server mints the tool anew>." A revoked server's sentence keeps the standing fact it carried, "This
684
+ server stays on this run's tool roster." (the roster is materialized once per run; a refresh of a revoked server does not unmount
685
+ its tools). The task-required rule is a re-read of a mount-time fact, not a re-evaluation, and the sentence says so: the same
686
+ mounted object is refused until something mints the tool anew. No site words any of it: `mcp.ts` calls the writer five times,
687
+ `listingRefusal` once; the codes, `details`, `delivered` and `isError` are unchanged.
688
+ - **Not changed here β€” the same shape, one more text.** The refusal of a call to a server whose transport is gone
689
+ (`throwDeadServer`, `src/core/mcp.ts`; the tool call, the resource read and the directory listing) and the HTTP "request was not
690
+ delivered" refusal end "will keep failing until the server is available again β€” do not retry them". For the tool call, a host's
691
+ re-dial replaces the live connection and the same tool object runs on it (`reach` reads the live connection on every call), so
692
+ that sentence is overturned the same way (the resource outlets were not checked here); it is a thrown error with its own pins and
693
+ is left for its own change.
694
+ - **Behavior change (open to veto).** *What changed*: the closing sentence of five refusals. *Who is hurt*: a host or a test that
695
+ matches the old sentence by its text. *How to migrate*: read `details.code` (`mcp.server_revoked`, `mcp.task_required`), as the
696
+ refusals have always carried it.
697
+ - **Consumers.** @server @cli: nothing to do; a surface that shows the tool result's text shows the new sentence. @test: the refusal
698
+ text now holds none of "refused the same way", "don't retry" or "every call to it is" (pin A).
699
+ - **Pins.** `test/backlog2616-2617-refusal-scope-one-writer.test.ts` A1 (each of the four revoked outlets: the sentence, the standing
700
+ roster, no foretelling words, no request of any kind reached the server; after the operator's un-revoke the same object runs and
701
+ reaches it), A2 (the task-required
702
+ tool: the sentence, the call never reaches the server), A2b (a host's refresh that takes in a listing without the requirement mints a
703
+ tool that runs), A3 (a run: revoked before the model's first call, un-revoked before its second β€” the first answer is the sentence,
704
+ the second call runs), A4 (the scope sentence is minted in one file and the foretelling words nowhere in the engine);
705
+ `test/up424-a-tier-ports.test.ts` A-5 now pins the roster clause in the writer, and the four outlets calling it.
706
+
707
+ ### A SendMessage refusal says once that the message was not sent β€” the frame says it, the arm states why (#2617; behavior change in the text the model reads, open to veto; hard-breaking: none; closed sets: none; exports: none; members: none) (@server @cli @test)
708
+
709
+ - **Before.** A refusal opens with the tool's frame "Message not sent:" and eleven arms closed with the same fact again: "Nothing was
710
+ sent." (the rebound-name refusal, the three socket-reached peer arms, the four `notify_when_idle` and cross-session addressing arms),
711
+ "Nothing was delivered." (a socket that refused the connection), "β€” nothing was sent." (the directory fault) and "β€” the message was
712
+ not delivered." (an agent that is still starting up). One fact, said twice in one sentence.
713
+ - **Now.** The frame says it and the arm does not: the arms state the reason alone. What stays is another fact β€” the state of the
714
+ mailbox ("nothing was parked", "the message was NOT queued") and the warning on a send that may have arrived ("It may have arrived:
715
+ do not resend the same content blindly") β€” because a refusal that leaves a message queued ("Message not sent now: … Your message
716
+ is queued") is a different answer from one that leaves nothing behind. One exception stays as it was: a socket send of uncertain
717
+ outcome (`peer_send.send_uncertain`) still opens with the frame "Message not sent:" and then says it may have arrived β€” an older
718
+ contradiction this change does not touch.
719
+ - **Behavior change (open to veto).** *What changed*: the text of those arms, and with it `details.verdict.message` of the peer arms
720
+ (the same text as the arm, minus the frame). *Who is hurt*: a host or a test that matches "Nothing was sent." in a SendMessage
721
+ result or in that field. *How to migrate*: read `details.code` / `details.error`, which the arms have always carried, or match the
722
+ frame.
723
+ - **Consumers.** @server @cli: nothing to do. @test: the reference's own rebound-name arm reads "Nothing was sent." (its text has no
724
+ frame); here the frame carries it.
725
+ - **Pins.** `test/backlog2616-2617-refusal-scope-one-writer.test.ts` B1 – B4 (a `notify_when_idle` with no directory mounted, a socket-
726
+ reached peer with no channel wired, a `notify_when_idle` to a socket-reached peer, a socket that refuses: each text is the frame and the
727
+ reason, the fact once), B5 (the mailbox fact stays, once, under the same frame), B6 (no arm of the tool says it again);
728
+ `send-message-name-rebind-guard`, `backlog971-session-where` W6 and `backlog2589-2591-one-sentence-one-reader` B4 read the arms they
729
+ covered without the tail.
730
+
731
+ ### The request a Runner hands a policy carries the call's grant-binding words β€” the members its cards carry, from the same factory, over the request's own args (#1955, design/1955, C-R896; no behaviour change; hard-breaking: none; closed sets: none; exports: none; members: `ToolCallRequest` +3 optional) (@server)
732
+
733
+ - **Before.** Every card of a call carried the engine's binding words β€” `boundGrantDigest` + `boundGrants` on an activation of the engine's
734
+ `Skill` tool, `boundGrantAbsence: "not_bindable"` on every other call β€” but the `ToolCallRequest` a deployment policy layer is handed carried
735
+ none, so a layer deciding before it asks whether an answer kept by tool name may answer the call had to infer the binding from the tool name.
736
+ - **Now.** `ToolCallRequest.boundGrantDigest?` / `.boundGrants?` / `.boundGrantAbsence?` β€” the `AskRequest` members by name and type, exactly one
737
+ arm. **Present** on every request a Runner hands a policy: the gate's adjudication (every gate request β€” the first look, the post-screen
738
+ re-mint, the approved-edit re-check), the resume belt, the park's stored-shape re-check, the pre-claim edit re-check (minted with the skills
739
+ that resume serves), the synthetic read / write probes (`not_bindable`), and every copy a composed policy, the inherited edit chain or the
740
+ inherited classifier makes over moved args β€” the copy carries the answer for ITS args. **Absent** on a bare request (a host driving a policy
741
+ outside a Runner). On a request `boundGrants` is a frozen copy. A copy whose digest the engine did not mint for that call (a clone, a
742
+ host-built request) keeps the digest over the same bytes and reads `boundGrantAbsence: "unreadable"` over moved ones.
743
+ - **Behaviour.** No change: no engine judgment reads the request's members (a parked approval is judged by its row's digest). The cards, the
744
+ parked row and the inbox projection are unchanged; `tool_start` / `tool_end` carry no binding (no consumer reads one there).
745
+ - **Consumers.** @server: the deployment-list gate and the workflow question gate can read the request through the card reader
746
+ (`grantBindingOf`) and retire `callGrantBindingOf` and the carrier choice in `questionGrantBindingOf`; a request you build yourself outside a
747
+ Runner carries no word β€” copy the row's members when you re-judge a parked call. The exemption list filter reads store rows that keep only a
748
+ tool name: this change does not reach it. @cli @client-core: nothing to render.
749
+ - **Pins.** `test/backlog1955-call-grant-binding.test.ts` (C1 card form, C2 no card, C3 park β†’ edited resume, C4 a composed policy's rewrite,
750
+ C5 the probes, C6 the mover, C7 the inherited classifier's copies).
751
+
752
+ ### A plan-review pause names the call that presented the plan β€” `requestedByCallId` on the parked row, the paused cause and the inbox summary (#2593; additive; no behavior change for a consumer that ignores the key; hard-breaking: none; closed sets: none; exports: none) (@client-core @server)
753
+
754
+ - **Before.** A plan-review pause gated no call and named none: the parked row was `{ kind: "plan_review" }`, and the paused cause carried the gate, the token and the checkpoint id. A card that had to know which transcript call carried the plan under review joined the pause to the `ExitPlanMode` call by adjacency or by tool name.
755
+ - **Now.** The park mint writes `requestedByCallId` β€” the id of the call that asked for the review β€” onto the `plan_review` pending action, once. For the first-party plan tool that is the `ExitPlanMode` call's own id (the one its `tool_start` / `tool_end` frames carry); a caller tool's `ctx.requestReview()` is rebuilt per call, so the id is the calling call's and a tool cannot name another call's (a revive context's id is minted for the revival and names no transcript call, so it is not attributed). The paused cause (`terminal.requestedByCallId` on a `paused` cause) and the inbox summary (`CheckpointSummary.requestedByCallId`, also on `listByScope`) echo it through one reader (`planReviewRequesterOf`). First request in a batch wins, and so does its id; a plan re-presented after a reject parks a new row carrying the new call's id. The key is OMITTED, never `null`, on a row whose requester carried no call id (a row a deployment minted itself, a row from an earlier engine, a revive context) and on every other kind of pause.
756
+ - **What it is not.** Provenance, not a binding: the review still gates no call, so `toolCallId` (on the pending action and on the summary) and `gatedCallId` stay absent on a plan review, and nothing on the resume path reads the id β€” it is classified SHOWN in the reader-requirements table, so a lost or changed id damages no row. The distinct name is deliberate: `toolCallId` means "the call this pause gates", and a reader that tests its presence reads "this is a tool approval".
757
+ - **Limits (stated).** A store that whitelists the keys of a `plan_review` pending action drops the member on read-back (the in-memory and file stores keep it β€” pinned; the server's SQL store keeps the checkpoint row as one JSON column and reads `pendingAction` members out of it β€” read in that checkout, not exercised here); the live run's paused cause carries it regardless. The id names the FIRST requester of a batch only.
758
+ - **Consumers.** @client-core: join the pause to the plan card by `terminal.requestedByCallId` (live frame) or `CheckpointSummary.requestedByCallId` (inbox row) against the card's own `toolCallId` β€” equality, no adjacency. @server: the paused cause rides your seal unchanged (the token is the only key stripped); no store change; your `parkToolCallId` still answers absence for a plan review, by design.
759
+ - **Pins.** `test/backlog2593-plan-review-requester.test.ts` (β‘  row / cause / summary / `listByScope` carry the `ExitPlanMode` call's id, the id on its own frames, `toolCallId` and `gatedCallId` absent; β‘ b the file store round-trips it; β‘‘ two gates, two ids; β‘’ a caller tool's id is the calling call's, a forged one is not honored; β‘£ first request wins; β‘€ the reader β€” absent / empty / non-string / other kinds; β‘₯ an approval park carries none; ⑦ SHOWN: the row judges ok with the id lost or changed); `test/prepare-inherited-gate.test.ts` (the per-call ctx wrapper: own id bound, a forged option ignored, a revive context's and an empty id attribute nothing). Re-pinned: `prepare-boundary-parks-transcript` (the committed plan review's row now names its requester), `backlog1320-reader-requirements` (the SHOWN read-site registry gains the member).
760
+
761
+ ### The `leg_end` rows of the undrained-input notices name WHICH inputs they count β€” `detail.inputIds` (#2594; additive; no behavior change for a consumer that ignores the key; hard-breaking: none; closed sets: none; exports: none) (@client-core @server)
762
+
763
+ - **Before.** `task.user_steer_undrained` / `task.user_followup_undrained` said how many inputs were never consumed (`detail.steer` / `detail.followUp`) and not which. A client that tracks each input by the id its receipt carried could say only "something I sent was lost", and had to fold every unconfirmed input into "could not confirm".
764
+ - **Now.** The engine's own (`cause: "leg_end"`) rows carry `detail.inputIds`: the id of EACH counted input, in the order the run would have served them (queue order: an `immediate`-tier input leads the ones accepted before it) β€” the same value the live `human_input` frame carries as `inputId` and a parked entry as `inputId`, taken from the same queue frames the count is. It follows the account's own arithmetic: the live queue's inputs less the ones a durable park carried onto the checkpoint, plus a resumed leg's continuation frames the reopen did not bring back and the park did not carry (those lead: they were accepted first). A park that carries one entry and is refused another names only the refused one. The list rides only where it names exactly the counted inputs; a lane with an input that carried no id keeps its count and loses the list, so a reader never mistakes a partial list for the whole. A child leg's copy on the parent's session carries the same list. An `approval_feedback` row (the words an approving person wrote) never carries one β€” it is no input; the `crashed` arm is the serving layer's and is not minted here.
765
+ - **Behavior change.** None for a consumer that ignores the key; a notice's `detail` gains one array key on a real stranded input (an exact-`detail` comparison in a consumer's test would see it).
766
+ - **Consumers.** @client-core: key a stranded input by `detail.inputIds` against the receipt's `messageId` (the `inputId` you sent, or the one the `human_input` frame returned); where the key is absent the count is the whole account, as before. @server: the `crashed` arm you mint is unchanged and carries none; you may spell the same key for it when you can name the inputs.
767
+ - **Pins.** `test/backlog2594-undrained-input-ids.test.ts` (β‘  real lane: two steers β€” one caller id, one minted β€” and a `later` steer cut by `interrupt()`, each family lists the ids the `human_input` frames carried; β‘ b the harness seam β€” the sink's park records are the same predicate's frames, person inputs only, an input with no record leaves its lane's list short, an `immediate`-tier input leads in service order; β‘‘ a park that carries one and is refused one names the refused one, a park that carries nothing names all, a full carry announces nothing; β‘’ the account arithmetic as ids β€” held less migrated, continuation first, a reopened row's frames dropped, a short list is the count alone, no ids recorded is the count alone, the approval row carries none; β‘£ the minter β€” complete lists only, follow-up lane keeps its own ids, the parent's copy carries the list and nothing aliases the caller's array or the other notice's; β‘€ every row with ids is `leg_end`).
768
+
769
+
770
+ ### Corrections
771
+ - The 7.58.0 notes carry the #2670 section (checkpoint-store contract kit judges the run origin) inside their `## 7.57.0` block; #2670 shipped in 7.58.0 (merged 10-25 21:15, after the v7.57.0 tag) β€” the released blocks are left byte-identical to their tags, so the misplacement stays where it is and is stated here instead.
772
+
773
+ - #902: the 7.58.0 note said the divergence was registered; it was registered 2026-10-26, after the release, as `fs-throat-dotdot-resolved-by-filesystem`.
774
+
775
+ no-notes: #2613(repo tool verify-debts.mjs closed-row sha existence; not in the package), #1068(a two-line src deletion only: the memory engine's two awaited rescue timers stay ref'd and are cleared when the race settles, the RB-466 form; its two functions are new in this window, so there is no behaviour relative to 7.58.0), #2352(repo tooling only: package.json test:affected + scripts/affected-tests.*; no package face)
776
+
1
777
  ## 7.58.0 β€” 2026-10-26
2
778
 
3
779
  ### The release re-window refuses the rows it cannot decide and keeps each row's first promised window β€” `scripts/release/rewindow.mjs` (#2835; release tooling only, `src/` untouched; no behaviour change; hard-breaking: none; closed sets: none; exports: none)