@sema-agent/core 7.61.0 → 7.62.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 (176) hide show
  1. package/CHANGELOG.md +312 -0
  2. package/dist/agents/cascade.d.ts +11 -3
  3. package/dist/agents/cascade.js +1 -1
  4. package/dist/agents/peer-held-queue.d.ts +27 -4
  5. package/dist/agents/peer-held-queue.js +81 -36
  6. package/dist/agents/peer-session-drain.js +13 -3
  7. package/dist/agents/subagent.d.ts +6 -1
  8. package/dist/agents/subagent.js +66 -12
  9. package/dist/agents/suspend-guard.d.ts +38 -16
  10. package/dist/agents/suspend-guard.js +9 -4
  11. package/dist/agents/verify.js +4 -3
  12. package/dist/core/checkpoint-features.d.ts +722 -0
  13. package/dist/core/checkpoint-features.js +98 -0
  14. package/dist/core/checkpoint-requirements.d.ts +9 -2
  15. package/dist/core/checkpoint-requirements.js +9 -4
  16. package/dist/core/checkpoint-row-verdict.d.ts +99 -0
  17. package/dist/core/checkpoint-row-verdict.js +225 -0
  18. package/dist/core/checkpoint-store.d.ts +55 -745
  19. package/dist/core/checkpoint-store.js +39 -141
  20. package/dist/core/engine-notice.d.ts +19 -3
  21. package/dist/core/engine-notice.js +9 -2
  22. package/dist/core/gate-fold.js +2 -2
  23. package/dist/core/governance-codes.d.ts +3 -1
  24. package/dist/core/governance-codes.js +3 -0
  25. package/dist/core/hooks.d.ts +13 -0
  26. package/dist/core/human-input-projection.d.ts +1 -0
  27. package/dist/core/human-input-projection.js +3 -0
  28. package/dist/core/image-admission.d.ts +1 -1
  29. package/dist/core/locked-config.d.ts +2 -2
  30. package/dist/core/mcp-host-seat.js +6 -1
  31. package/dist/core/memory-engine/consolidation-driver.d.ts +1 -1
  32. package/dist/core/memory-vector.d.ts +1 -1
  33. package/dist/core/memory.d.ts +10 -10
  34. package/dist/core/mode-policy.js +1 -1
  35. package/dist/core/mods/classic-events.d.ts +9 -1
  36. package/dist/core/mods/dollar.d.ts +32 -1
  37. package/dist/core/mods/dollar.js +13 -1
  38. package/dist/core/mods/kernel/events.d.ts +11 -3
  39. package/dist/core/mods/kernel/events.js +13 -10
  40. package/dist/core/mods/lifecycle-stations.d.ts +36 -4
  41. package/dist/core/mods/lifecycle-stations.js +44 -9
  42. package/dist/core/mods/session-append.d.ts +4 -1
  43. package/dist/core/mods/session-append.js +7 -0
  44. package/dist/core/mods/session-receive.js +12 -15
  45. package/dist/core/mods/stations.d.ts +51 -6
  46. package/dist/core/mods/stations.js +124 -0
  47. package/dist/core/own-property-receipt.d.ts +7 -0
  48. package/dist/core/own-property-receipt.js +3 -0
  49. package/dist/core/read-root-candidate.js +1 -1
  50. package/dist/core/resume-startup-cause.d.ts +5 -4
  51. package/dist/core/runner/compact-session.js +5 -2
  52. package/dist/core/runner/contracts.d.ts +18 -8
  53. package/dist/core/runner/delegation-owner.d.ts +43 -0
  54. package/dist/core/runner/delegation-owner.js +59 -0
  55. package/dist/core/runner/lineage-reroot-view.d.ts +56 -0
  56. package/dist/core/runner/lineage-reroot-view.js +108 -0
  57. package/dist/core/runner/permission-rule-lanes.d.ts +2 -1
  58. package/dist/core/runner/permission-rule-lanes.js +2 -2
  59. package/dist/core/runner/person-path-rows.d.ts +15 -0
  60. package/dist/core/runner/person-path-rows.js +26 -3
  61. package/dist/core/runner/prepare-acquire-reconcile.d.ts +4 -1
  62. package/dist/core/runner/prepare-acquire-reconcile.js +7 -2
  63. package/dist/core/runner/prepare-caps-and-workflow.d.ts +1 -0
  64. package/dist/core/runner/prepare-caps-and-workflow.js +1 -1
  65. package/dist/core/runner/prepare-config-doors.d.ts +6 -6
  66. package/dist/core/runner/prepare-config-doors.js +3 -4
  67. package/dist/core/runner/prepare-hands-readface.d.ts +1 -1
  68. package/dist/core/runner/prepare-hands-readface.js +28 -7
  69. package/dist/core/runner/prepare-inherited-gate.d.ts +2 -0
  70. package/dist/core/runner/prepare-inherited-gate.js +7 -3
  71. package/dist/core/runner/prepare-task.js +10 -7
  72. package/dist/core/runner/resume-admission.d.ts +3 -3
  73. package/dist/core/runner/resume-admission.js +6 -3
  74. package/dist/core/runner/resume-apply.d.ts +4 -0
  75. package/dist/core/runner/resume-apply.js +11 -4
  76. package/dist/core/runner/resume-checkpoint-screen.d.ts +9 -0
  77. package/dist/core/runner/resume-checkpoint-screen.js +4 -84
  78. package/dist/core/runner/run-git-lane.d.ts +2 -0
  79. package/dist/core/runner/run-git-lane.js +4 -1
  80. package/dist/core/runner/run-harness-handlers.d.ts +2 -0
  81. package/dist/core/runner/run-harness-handlers.js +3 -2
  82. package/dist/core/runner/run-leg.js +24 -7
  83. package/dist/core/runner/run-settle-and-teardown.js +3 -2
  84. package/dist/core/runner/run-stop-and-final-verify.js +2 -1
  85. package/dist/core/runner/run-turn-boundary.js +7 -4
  86. package/dist/core/runner/runtask.js +6 -6
  87. package/dist/core/runner/steering-preview.d.ts +9 -0
  88. package/dist/core/runner/steering-preview.js +5 -0
  89. package/dist/core/runner/stream-steer-verb.js +8 -0
  90. package/dist/core/runner/tool-face-overlay.js +2 -0
  91. package/dist/core/runner/turn-attachments.d.ts +5 -0
  92. package/dist/core/runner/turn-attachments.js +1 -1
  93. package/dist/core/runner-deps.d.ts +2 -2
  94. package/dist/core/secret-env.d.ts +8 -5
  95. package/dist/core/secret-env.js +37 -18
  96. package/dist/core/session-store.d.ts +1 -1
  97. package/dist/core/session-store.js +5 -1
  98. package/dist/core/session.d.ts +14 -4
  99. package/dist/core/store-contracts/checkpoint-store-contract.d.ts +6 -0
  100. package/dist/core/store-contracts/checkpoint-store-contract.js +68 -0
  101. package/dist/core/store-contracts/session-store-contract.js +22 -8
  102. package/dist/core/task-event.d.ts +7 -1
  103. package/dist/core/task-notification.js +2 -1
  104. package/dist/core/task-registry-agent.d.ts +27 -7
  105. package/dist/core/task-registry-agent.js +12 -5
  106. package/dist/core/task-registry-shared.d.ts +7 -0
  107. package/dist/core/task-registry-workflow.js +4 -3
  108. package/dist/core/task-registry.d.ts +13 -2
  109. package/dist/core/task-registry.js +11 -4
  110. package/dist/core/task-result.d.ts +5 -5
  111. package/dist/core/task-spec.d.ts +1 -1
  112. package/dist/core/terminal-cause.d.ts +6 -6
  113. package/dist/core/tool-face.d.ts +6 -2
  114. package/dist/core/tool-face.js +1 -1
  115. package/dist/core/tool-policy.d.ts +2 -1
  116. package/dist/core/tool-roster.d.ts +4 -4
  117. package/dist/core/tool-spec.d.ts +4 -0
  118. package/dist/core/types.d.ts +1 -1
  119. package/dist/core/types.js +1 -1
  120. package/dist/engine/execution-env/node-execution-env.d.ts +3 -0
  121. package/dist/engine/execution-env/node-execution-env.js +12 -5
  122. package/dist/engine/harness/types.d.ts +11 -0
  123. package/dist/engine/session/parent-chain-guard.d.ts +3 -3
  124. package/dist/engine/session/parent-chain-guard.js +1 -1
  125. package/dist/engine/session/path-to-root.d.ts +18 -3
  126. package/dist/engine/session/path-to-root.js +15 -1
  127. package/dist/engine/session/repo-utils.d.ts +12 -1
  128. package/dist/engine/session/repo-utils.js +41 -0
  129. package/dist/engine/session/session.js +1 -1
  130. package/dist/engine/session/storage-base.d.ts +20 -0
  131. package/dist/engine/session/storage-base.js +28 -9
  132. package/dist/index.d.ts +9 -8
  133. package/dist/index.js +4 -4
  134. package/dist/internal/harness.d.ts +4 -3
  135. package/dist/internal/harness.js +3 -2
  136. package/dist/orchestration/run-workflow-tool.d.ts +3 -0
  137. package/dist/orchestration/run-workflow-tool.js +27 -11
  138. package/dist/orchestration/workflow-governance.d.ts +1 -1
  139. package/dist/orchestration/workflow.d.ts +3 -0
  140. package/dist/orchestration/workflow.js +2 -7
  141. package/dist/stores/file/checkpoint-store.d.ts +2 -0
  142. package/dist/stores/file/checkpoint-store.js +7 -6
  143. package/dist/stores/file/fs-atomic.d.ts +0 -22
  144. package/dist/stores/file/fs-atomic.js +0 -17
  145. package/dist/stores/file/index.d.ts +2 -9
  146. package/dist/stores/file/index.js +2 -4
  147. package/dist/stores/file/session-store.d.ts +13 -7
  148. package/dist/stores/file/session-store.js +40 -17
  149. package/dist/tools/fs/bash-program-position.d.ts +3 -2
  150. package/dist/tools/fs/bash-program-position.js +7 -7
  151. package/dist/tools/fs/removal-targets.js +2 -2
  152. package/dist/tools/fs/shell-read-argv.d.ts +4 -2
  153. package/dist/tools/fs/shell-read-argv.js +14 -3
  154. package/dist/tools/fs/shell-read-bindings.d.ts +18 -2
  155. package/dist/tools/fs/shell-read-bindings.js +148 -68
  156. package/dist/tools/fs/shell-read-check.js +20 -4
  157. package/dist/tools/fs/shell-read-establish.js +22 -8
  158. package/dist/tools/fs/shell-read-functions.js +2 -2
  159. package/dist/tools/fs/shell-read-object-path.d.ts +59 -0
  160. package/dist/tools/fs/shell-read-object-path.js +119 -0
  161. package/dist/tools/fs/shell-read-plan.d.ts +8 -0
  162. package/dist/tools/fs/shell-read-plan.js +47 -30
  163. package/dist/tools/fs/shell-read-start.d.ts +66 -13
  164. package/dist/tools/fs/shell-read-start.js +89 -17
  165. package/dist/tools/fs/shell-read-workdir.d.ts +29 -8
  166. package/dist/tools/fs/shell-read-workdir.js +31 -8
  167. package/package.json +2 -2
  168. package/test/export-surface.snapshot.json +21 -33
  169. package/wire-changes/core-stores-sql@7.62.0.json +30 -0
  170. package/wire-changes/core@7.62.0.json +2181 -0
  171. package/wire-changes/mods-kernel@7.62.0.json +42 -0
  172. package/wire-changes/primitives@7.62.0.json +30 -0
  173. package/dist/core/consolidate-scope.d.ts +0 -93
  174. package/dist/core/consolidate-scope.js +0 -98
  175. package/dist/core/runner/memory-consolidation.d.ts +0 -109
  176. package/dist/core/runner/memory-consolidation.js +0 -251
package/CHANGELOG.md CHANGED
@@ -1,3 +1,315 @@
1
+ ## 7.62.0 — 2026-10-31
2
+
3
+ ### The store contract type and the two store consolidation passes leave the package — `MemoryStore`, `consolidateScope`, `runMemoryConsolidation` and the thirteen root names only they read (#1654; retirement lines RL-1654-memorystore / RL-1654-consolidate-scope / RL-1654-run-memory-consolidation, ruled C-R1075 ① and its 加注 1; behavior change: none on the Runner path; hard-breaking: one, three sentences below, open to veto; closed sets: none; exports: −16 root names; members: −1 `FileStorageBackend.consolidationLock`) (@server @dgx @client-core @test)
4
+
5
+ - **Retired (C-R1075 ①).** hard-breaking: three exports removed (open to veto) — MemoryStore (type) / consolidateScope / runMemoryConsolidation — and, in the same cut, every root name only those two passes read: `CONSOLIDATION_SYSTEM_PROMPT`, `DEFAULT_CONSOLIDATION_BAND`, `DEFAULT_CONSOLIDATION_SEARCH_LIMIT`, `DEFAULT_CONSOLIDATION_MAX_NOTES`, `normalizeForExactMatch`, `advanceCursorAfterInline`, `createFileConsolidationLock`, and the types `ConsolidationParams`, `ConsolidationStats`, `ConsolidationNote`, `ConsolidationLLM`, `ConsolidateScopeDeps`, `ConsolidateScopeOptions` (`npm run handoff:diff origin/stage-7620 HEAD`: 16 removed / 0 added). `src/core/consolidate-scope.ts` and `src/core/runner/memory-consolidation.ts` are deleted; the file backend's per-scope consolidation lock (`FileStorageBackend.consolidationLock`, the `consolidation-locks/` directory it created under the data root) goes with its factory.
6
+ - **Hard-breaking — HB-1, sixteen root names and one backend member removed (open to veto).** *What changed:* the names above are no longer exported from `@sema-agent/core`, and a `FileStorageBackend` no longer carries `consolidationLock` nor creates `consolidation-locks/`. *Who is affected:* a host that imports any of the sixteen names, or calls `backend.consolidationLock`, fails to compile (a JavaScript caller reads `undefined`); the origin/main of server, cli, client-core, sdk and test, and the HEAD of the dgx checkouts that import core, carry no code reader of any of them. *What to read instead:* memory is the MemoryEngine behind `RunnerDeps.memoryBackend` and its consolidation is the engine driver (`runMemoryConsolidationDriver`, `resolveMemoryConsolidationDriver`); a host injects an engine backend, not a store.
7
+ - **What does not change.** The Runner never read these names (design/157 B19 removed `RunnerDeps.memoryStore`). The store implementations `InMemoryMemoryStore`, `FileMemoryStore`, `guardedMemoryStore`, `FileStorageBackend.memoryStore` and the store helpers of `src/core/memory.ts` stay exported until the store family retires (their faces now sit on one retirement line, RL-1654-store-family, `retireBy` 7.63.0, which also groups the ledger-v1 row). The anchor backfill arm is not touched: a control plane that holds a store but no root anchor still records the anchor at its next open and says `memory.root_anchor_backfilled` (RL-1103-anchor-backfill re-windowed to 7.63.0 with the store family's persisted-form retirement). The checkpoint version ladder is not touched: a v≤9 checkpoint row is read by its number as before (RL-1333-checkpoint-numeric re-windowed to 7.63.0, on the backends' census of v≤9 parked rows).
8
+ - **Who needs it / compensation.** *Needs it:* every reader of the root surface — sixteen names that read as a supported second memory path while no engine path used them. *Compensation:* none needed; zero code readers downstream.
9
+ - **Consumers.** @server: zero code readers on origin/main; the memory backend injection is unchanged. @dgx: zero readers; engine memory backends are injected as before. @client-core: zero readers; a generated export table regenerates on pickup. @test (black box): none of the sixteen names is a root export of the 7.62.0 dist (`import { consolidateScope } from "@sema-agent/core"` is a compile error, a runtime read is `undefined`).
10
+ - **Pins.** `test/backlog1654-store-exports-retired.test.ts` — R1 (the nine value names are no runtime export of the root; control: the engine driver is) · R2 (none of the sixteen names is spelled in `src/index.ts` outside a comment; control: the three store implementations still are) · R3 (the two pass modules are gone) · R4 (a file backend has no `consolidationLock` and creates no `consolidation-locks/`; control: `memoryStore` stays) · R5 (the retirement table: the three rows gone, RL-1654-store-family due 7.63.0 and grouping the ledger-v1 row, the three lines left for 7.63.0 untouched). The pins that exercised the retired passes and the lock are deleted with them (`consolidate-scope.test.ts`, `consolidate-scope-property.test.ts`, `memory-consolidation.test.ts`, `effect-seamB-mech.test.ts`, and the consolidation blocks of six mixed files).
11
+
12
+ ### An extension sees the leg open, each model turn start, the context measured and a person's prompt before the classic screen, and may rewrite or drop that prompt — `session.start`, `turn.start`, `session.measure`, `prompt.submit`, `classic.SessionStart` / `classic.SessionEnd`; `$.session.turns` / `usage` / `version`, `$.session.messages({ agentId })` (#3010 / #3011, the last two slices of #1933; ruled C-R985 Q2 A / Q3′ A / Q7 A and C-R1071; behavior change; hard-breaking: four, three sentences each below, open to veto; closed sets: the event table +3 names (`prompt.change`, `session.identity`, `ui.view`, named only), +6 stations, +3 methods; exports: +5 root types `SessionStartEvent`, `SessionEndEvent`, `SessionUsage`, `SessionVersion`, `ContextOccupancy`; members: +1 optional `human_input.rewrittenBy` (wire +1 optional key), +1 method `TaskRegistry.anchoredSession`, `TaskRegistry.bindBackgroundAgentSession` +1 required parameter) (@server @cli @client-core @test)
13
+
14
+ - **Before.** The leg's opening, a model turn's start, the context measurement and a person's prompt before the classic screen had no station; `classic.SessionStart` and `classic.SessionEnd` were names with no station; `$.session.usage`, `turns` and `version` threw "not callable on the engine bus in this version"; `$.session.messages()` took no argument; an extension could only `block` a prompt through `classic.UserPromptSubmit`, never rewrite it.
15
+ - **Now — the leg's lifecycle.** `session.start` is raised first thing in the leg's body (its `$` seats bound, before its first model request) with `{ cwd, sessionId, agentId? }`, and its bottom raises `classic.SessionStart` with the same `e`; `turn.start` once per model turn, before that turn's request, with `{ turn }` (the number `turn.complete` carries for it); `session.measure` at a turn boundary whose context occupancy moved, with `{ context: { usedTokens, windowTokens, compactAtTokens }, changed: ["context"] }` — the boundary's `context_usage` numbers, so not where no `context_usage` is emitted (within-task compaction off, the leg ending, the compaction circuit open; KL-3010-c); `session.end` (unchanged place) now raises `classic.SessionEnd` in its bottom, and a resumed leg refused because its approved call's tool is gone (`resume.tool_unavailable` / `resume.tool_contract_mismatch`, the one exit that leaves without the settle) raises it too, `reason: "failed"`, before the error comes out. Every one is an observation (skip · grace); each is raised only when a handler hangs on it or on its classic event.
16
+ - **Now — the prompt's screen.** `prompt.submit` is raised at the four entrances that screen a person's prompt (an operator's objective, a live steer, a wake's message before its claim, a parked steer redelivered), before `classic.UserPromptSubmit`, which its bottom raises on the text handed down. `next({ ...e, text })` rewrites the prompt and the entrance delivers the rewritten text; `{ drop: <reason> }` refuses it as the classic screen's `block` does there; a failing handler refuses it (refuse · immediate; `source`, `inputId`, `actor` pinned). The classic screen's own refusal is final. The `human_input` account the entrance mints carries `rewrittenBy` (the `"applied"` frame of an objective, a wake's message or a parked steer; the `"queued"` frame of a live steer). Who changed the text is read off the chain as it runs, one reading for `prompt.submit` and `session.receive` (`received.rewrittenBy`): a handler is named when it hands on a different text, or answers a different text than the one that came up to it — **fix for `session.receive` (7.61.0)**: an outer handler that only carried an inner one's rewritten answer up (`return { ...(await next(e)) }`) was named as the rewriter and the inner one was not; now the inner one is named and the copier is not. One predicate decides whether an entrance screens: a handler on `prompt.submit` or on `classic.UserPromptSubmit` (the wake's pre-claim screen read only the classic event before). `$.prompt.submit` is not in this version; see #3284.
17
+ - **Now — the session's read faces.** `$.session.turns()` counts the transcript's prompts from its people (a row whose door is `prompt`; a steer is the engine's note, not one — KL-3010-a); `$.session.usage()` answers `{ context? }`, the leg's latest boundary measurement (none before the first boundary, none on `Runner.compactSession`); `$.session.version()` answers `{ version }`, the package's; `$.session.messages({ agentId })` reads a subagent's stored rows through the leg's own task list row (`TaskRegistry.anchoredSession`, the access the leg's task tools read with) and rejects with the reason for a row the leg does not reach, a row with no session, or a session its store cannot read (KL-3010-b). The child's rows are read in the store its row carries — the store the child's run holds its session through, bound with the session id when the spawn binds the row — never in the leg's own: a child the Agent tool runs on a runner of its own is read in that runner's store, and a leg-side session that happens to share the child's id is not read.
18
+ - **Hard-breaking — HB-1, the kernel contract is 8 (open to veto).** *What changed:* `KERNEL_CONTRACT_VERSION` is 8 (7 since 7.61.0): the closed set is the reference's 145 names (Claude Code 2.1.309 `_De`, cli309.js:253322), six events gained stations and three methods have bottoms. *Who is affected:* a mod package whose `hooks/hooks.json` says `"contract": 7` is refused by `loadModPackage` (server S-2388's real package, cli MODS155, test C-R915 fixtures; server `test/mods-loader-pickup.test.ts` pins 6); a host comparing a kernel copy's table (client-core's table generation: +6 stations, +3 methods, +3 names). *How to migrate:* write `"contract": 8`; regenerate the table copy from `MOD_EVENT_TABLE`; compensation = the kernel table and the station table (`docs/INTEGRATION-CORE.md` §10.16) ride the arrival post.
19
+ - **Hard-breaking — HB-2, `session.end`'s bottom raises `classic.SessionEnd` (open to veto).** *What changed:* a `session.end` handler wraps the `classic.SessionEnd` handlers (R-W4); one that answers without calling `next` keeps `classic.SessionEnd` from being raised. *Who is affected:* a deployment hanging both events and assuming they are independent (none in this tree or in the three neighbour repositories). *How to migrate:* call `next(e)` in a `session.end` handler that should let the classic event run; order-sensitive observers read `classic.SessionEnd` as inside `session.end`.
20
+ - **Hard-breaking — HB-3, `$.session.messages` takes `{ agentId }` (open to veto).** *What changed:* the method takes one optional key; with it, it answers the subagent's stored rows, and any other key is the caller's throw. *Who is affected:* code that passed an argument the method used to refuse (it still refuses every key but `agentId`), and type-level code that implements `EngineDollar["session"]["messages"]` (an overload was added). *How to migrate:* nothing for a call with no argument; a host's own `$` implementation adds the overload.
21
+ - **Hard-breaking — HB-4, `TaskRegistry.bindBackgroundAgentSession(id, sessionId, store)` (open to veto).** *What changed:* the bind takes the store the child's run holds that session through, keeps it on the row beside the id (process-local; the durable record keeps the id alone) and the release ends both; the store is judged where it is read (`$.session.messages` refuses, naming why, a row bound without a store or with one it cannot read through). *Who is affected:* a caller of the two-argument form — none in this tree outside the Agent tool's three bind sites; @server two test files bind directly (`test/background-session-reap-s745.test.ts`, `test/core-probe-parked-registry.test.ts`). *How to migrate:* pass the store the child's session lives in (the runner's `sessions` that runs the child); a test that never reads the transcript passes any `{ acquire }`. This closes #3293 (the 7.62.0 review leg's finding: the `$.session.messages({ agentId })` face read the parent runner's `sessions` for every child, so a child run on its own store answered "not a child", and a parent-store row with the same id answered an unrelated transcript — the anchor is now the (id, store) pair on the row, read through one function, `childSessionAnchorOf`); and the registry's `rowsUnder` reads that one source again (#2861 I1), nothing else of #2861 lands here.
22
+ - **Who needs it / who is affected / compensation.** *Needs it:* an extension that redacts or tags a prompt before the model sees it, or that observes the leg's lifecycle the way the reference's mods do. *Affected:* HB-1–HB-4. *Compensation:* the station table rides the arrival post; divergences D-3010-a (turns without steers), D-3011-a (the lifecycle classic answers are not read — `additionalContext` / `initialUserMessage` not taken), D-3011-b (a failing `prompt.submit` handler refuses where the reference skips) and D-3011-c (`turn.start` carries the turn's number, as `turn.complete` does, not the reference's `turnId`) are open to veto.
23
+ - **Consumers.** @server: the contract is 8 — S-2388's package and the `mods-loader-pickup` pin move from 6 to 8 at pickup; `human_input.rewrittenBy` passes through (additive); the two test files that call `bindBackgroundAgentSession` directly pass the store (HB-4). @cli: MODS155 at contract 8; the six stations render in the station view; a rewritten prompt's account names the extension. @client-core: the kernel table copy +6 stations, +3 methods, +3 names; `rewrittenBy` enters the `human_input` frame type. @test: black box — each station fires once where §10.16 says, in order; `$.session.messages({ agentId })` refuses another owner's agent; a rewritten objective is what the model reads.
24
+ - **Pins.** `test/backlog3010-3011-mods-s4.test.ts` — K1 (the six stations, the three methods, the three named-only names, contract 8) · S1 (order and shapes on a real Runner: `session.start` with `classic.SessionStart` inside before the first request, `turn.start` per turn, `session.end` with `classic.SessionEnd` inside last) · S2 (a cancelled leg: each once) · S3 (R-W4: a typed handler without `next` keeps the classic event from being raised; a classic handler alone is raised) · S4 (a throw on any of the six changes nothing) · S5 (a resume refused with `resume.tool_unavailable`: `session.end` `failed` pairs the resumed leg's `session.start`) · E1 (no registration and pass-through handlers on all seven send the same requests, store the same rows, end the same way; no frame carries `rewrittenBy`) · T1 (`turn.start` before the turn's request, the number `turn.complete` carries) · M1 (`session.measure` and `$.session.usage()` read the `context_usage` numbers) · M2 (the seat is written at every measuring boundary, the event raised only when the occupancy moved) · M3 (within-task compaction off: no `context_usage`, no `session.measure`, `usage()` is `{}`) · R1 (`$.session.turns()` = 1 with a live steer; `$.session.version()` = package.json) · A1 (`$.session.messages({ agentId })`: a reached row reads its rows; another owner's, an unknown id and an unbound row are refused, naming why) · A2 (a child the Agent tool runs on a runner of its own: the leg, whose store never held the child's session, reads the child's rows in the store the row carries) · A3 (the same session id in the leg's store with other rows: the read answers the child's transcript) · A4 (the bind keeps the store with the id, reached under the row's access only; the release ends both; A1 also reads a row bound without a store and one whose store cannot read, each refused naming why) · P1–P3 (the objective: rewritten text delivered and stored, the classic screen on it, `rewrittenBy`; a drop and a throw refuse; the classic block is final) · P4 (a live steer: the frame rewritten, the queued account names the rewriter) · P5 (a wake's message, screened once, before the claim) · P6 (a parked steer redelivered; the sibling unchanged, no `rewrittenBy`) · P7 (a `prompt.submit` handler alone screens the wake's message; `$` throws there) · P8 (`rewrittenBy` names a handing-on rewriter and an answering one, in order; the classic screen is then not asked) · P9 (an outer handler copying an inner redactor's answer up is not named; the redactor is) · P10 (the shared reading, unit). Mutations per fixture: `.gate-logs/criteria-3010-3011-mutations.md`. Re-pinned: `mods-kernel-296` (the 145-name fixture `cc309-mod-events.json` replaces `cc296-mod-events.json`), `mods-kernel-wave2` (the classic map's two keys; `prompt.*` selects `prompt.submit`; the not-callable sample is `session.identity`), `mods-kernel-registration` (the stationless classic sample is `classic.Notification`), `mods-methods` (the three read faces and `messages({ agentId })`), and the three mod package fixtures (`"contract": 8`).
25
+
26
+ ### A place a substitution or a launched shell's text names itself stays where it is — the read boundary and the removal guard no longer move an absolute `cd`, `git -C` or `-C ~` at or under the working directory onto the segment the text sits in (#3235; behavior narrowing — security, thirteen forms below, the last one (an `eval` climb) open to veto; behavior widening — one form, open to veto; hard-breaking: none; closed sets: none; exports: none) (@cli @server @test)
27
+
28
+ - **Before.** A nested text — a `$( … )` body, a here-document's substitution, a launched shell's command string (`bash -c '…'`) — was planned as if it stood in the declared working directory, then re-based onto the segment it sits in by prefix: every base spelled at or under the declared working directory was taken to come from where the text starts and was moved. So a place the text names itself moved too. With the working directory at the home, `cd proj && echo $(cd <home> && cat .mcp.json)` was judged as reading the project's `.mcp.json`, while bash read the home's. The station vouched; on the default seat the substitution's own ask was the only question; on a seat that puts no ask the home's file was printed. The same happened to `git -C <home> show HEAD:.mcp.json`, `git -C <home> show HEAD:./.mcp.json` and `git -C ~ show HEAD:.mcp.json` in a substitution. With the working directory at `/`, every absolute place moved: `cd ./tmp && echo "$(cd / && rm -rf ./usr)"` was judged as removing `/tmp/usr`.
29
+ - **Now — one rule.** A nested text with no working directory of its own starts at a placeholder no text can spell (`nestedStartOf`, `src/tools/fs/shell-read-start.ts`). A base is moved onto the enclosing segment exactly when it was derived from that placeholder: the start itself, a relative move from it, a `-C` / `..` walk from it. Every other place stays where it is — an absolute `cd`, `git -C <dir>`, `-C ~`, `cd ~`, a `CDPATH` entry, the place a closed scope went that the held thread hands in. No `cd` or `-C` word is special-cased. A base is read as derived by the placeholder's own segment, not by the spelling above it, so a working directory spelled `/w/.` or `/w//` changes nothing. A lost `cd` target's deny floor keeps its `..` walk, so a climb from the start stays derived from it. `PWD` reads no start that holds the placeholder — the nested text's own, and an `eval` text's that the nested text runs: a climb there is lost and judged on its floor, never folded past the start. A derived floor with nowhere to land is no floor, and the judge reads the declared working directory as before.
30
+ - **Narrowing (security), by form.** Working directory at the home, deny row `~/.mcp.json` or `**/home/.mcp.json`; bash 3.2 reads the home's `.mcp.json` in each. On stage-7620 70cdb9681 the station vouched or could not place these, the default seat asked once, and the bypass seat printed the home's file. They are now refused:
31
+ - `cd proj && echo $(cd <home> && cat .mcp.json)`
32
+ - `cd proj && echo $(git -C <home> show HEAD:.mcp.json)`
33
+ - `cd proj && echo $(git -C <home> show HEAD:./.mcp.json)`
34
+ - `cd proj && echo $(git -C ~ show HEAD:.mcp.json)`
35
+ - the same read in a here-document's substitution: `cd proj && cat <<EOF` ⏎ `$(cd <home> && cat .mcp.json)` ⏎ `EOF`
36
+ - in a child shell's text: `cd proj && bash -c 'cd <home> && cat .mcp.json'`
37
+ - `cd proj && echo $(cd ~ && cat .mcp.json)`
38
+ - a substitution inside a substitution: `cd proj && echo $(echo $(cd <home> && cat .mcp.json))`
39
+ - `cd proj && echo $(cd <home>/proj && cat ../.mcp.json)`
40
+
41
+ Two more are refused under an unanchored row:
42
+ - `f(){ cd <home>; }; cd proj && echo "$(f; cat .mcp.json)"` — the home the body went to is on the floor, not moved onto the project.
43
+ - `cd proj/deep && echo $(cd ../.. && cat .mcp.json)` — the lost climb's floor.
44
+
45
+ The removal guard reads the same plan: `cd ./tmp && echo "$(cd / && rm -rf ./usr)"` (working directory `/`) is `dangerous_delete`.
46
+
47
+ One more is unplaced where it was placed (open to veto — such a text is judged on its floor and so asks more often): `echo "$(eval 'cd /x && cd ..' && cat f)"` was judged at `/`; an `eval` text inside a substitution now reads `PWD` as the substitution does, so the climb is lost and `f` is judged on its floor, as `echo $(cd /x && cd .. && cat f)` already was.
48
+ - **Widening — one form (open to veto).** `cd noproj && echo $(git -C <home>/proj show HEAD:.mcp.json)` (working directory at the home) was refused, and now asks on the default seat and runs on a seat that puts no ask. The absolute `-C` was moved under `noproj`, the repository-top probe started where nothing is, and every ancestor met the home's row. Git prints the project's own file. `KL-1726-c` is closed.
49
+ - **Who needs it / who is affected / compensation.** *Needs it:* every deployment that guards a file under the working directory — the home most of all — from a model that can spell the file's directory absolutely in a substitution. *Affected:* a text that reads a guarded file through its own absolute `cd` / `-C` inside a substitution or a launched shell's text: refused where it ran or asked. *Compensation:* none needed; a project's own file read through an absolute `-C` runs (the widening above).
50
+ - **Consumers.** @cli @server: the engine you embed (7.61.0 and earlier) moves those places. The forms above vouch there, and on a seat with no ask they read the guarded file. They are refused once you take this engine. No wire change, no new code (`read_path_denied`). @test: please re-run the car-1726 cx-probe forms X1 / X2 / X3 / X6 (now refused) and X8 (now runs), and try the nested doors this pin does not cover. Not this root: the directory a launcher's own `-C` names was not where its shell's text started (`env -C <home> bash -c 'cat .mcp.json'` from a project, under an unanchored row) — closed in this release by #3275, the next section.
51
+ - **Pins.** `test/backlog3235-rebase-plan-nested.test.ts` has 119 cells. 27 forms are each read four ways: the station's verdict, the real Runner lane on the bypass and the default seat (`B3235_COLUMN=base` re-reads stage-7620 70cdb9681), and `/bin/bash` in the same world — a stand-in home that is a git repository, a project repository under it, and no host environment. Beside them sit the plan cells: an absolute place stays, a derived one follows; the working directory at `/`; a Windows-family working directory; the held-thread floor and the lost climb; an `eval` climb inside a substitution; a working directory spelled with `.`, `//` or `..` (and the station under `<home>/.`); no plan names the placeholder; a derived floor with nowhere to land; the removal guard; a command that spells the placeholder itself (the station asks, the executor does not start it). Eight mutations (M1–M8), each red on its own fixtures — M1–M3, M7 and M8 on the final tree, M4–M6 on an earlier tree of the same branch.
52
+
53
+ ### A text a launcher hands a shell starts in the working directory the launcher settles — `env -C <dir> bash -c '…'` is judged in `<dir>`, not where the command line stands (#3275; behavior narrowing — security, ten forms below; behavior widening — four forms, open to veto; divergence D-3275-a, open to veto; hard-breaking: none; closed sets: none; exports: none) (@cli @server @test)
54
+
55
+ - **Before.** A launcher that moves the working directory its program runs in (`env -C <dir>`, `env --chdir=<dir>`, `sudo -D <dir>`, `unshare -w <dir>`) was read only as "moved". The text it hands a shell, and the program's own relative words, were left unplaced, with the directory the command line stood in as their deny floor. From a project under the home, `env -C <home> bash -c 'cat .mcp.json'` was checked at `<home>/proj/.mcp.json`. Under a row anchored to the home (`~/.mcp.json`) it was refused anyway. Under an unanchored row (`**/home/.mcp.json`) the station could not place the read and did not meet the row. The default seat asked once, and a seat that puts no ask printed the home's file. `env -C <home> cat .mcp.json` did the same.
56
+ - **Now — one rule.** A launcher option whose value is a working directory (the row table's `base: "working-directory"` role; no launcher is special-cased) is where the text that launcher hands a shell starts, as after `cd <dir>`. The directory is taken from where the command line stands, by the kernel's walk of the spelling (`..` kept). Each launcher of a chain applies in turn. Of several such options on one launcher the last wins — so macOS `env` reads them (measured); GNU `env`, `sudo` and `unshare` are inferred, not run. The reference's worktree guard (Claude Code 2.1.309, `cli309.js:266249`) refuses an `env` with more than one ("passes more than one -C/--chdir to env (last-wins semantics), which cannot be verified"): divergence D-3275-a, open to veto. Which word is whose option is read off the program-position walk's own steps, the one reading of it: env steps a lone `-` and reads on, so `env -C <proj> - -C <home> …` runs in the home. The same chdir step now serves `git -C` (`chdirFrom`, `src/tools/fs/shell-read-object-path.ts`). The text is planned from its placeholder start and re-based onto that directory, so a place it names itself (`cd /x`) stays where it is. The segment's own relative words may belong to the launcher (`-C sub` is relative to the command line) or to the program. They stay unplaced, and their deny floor is now both places. Where the text does not say where the launcher runs the program, everything stays as before: a value that expands, an empty one, `~user`, a root or program-search move in the chain (`sudo -R`, `env -P`), `nsenter -w` with no value, an optional value attached as `=V` (`nsenter -w=V`, `--wd==V`: util-linux 2.41 drops the `=`, 2.38 keeps it, two places). A walk that already lost track stays lost, and the launcher's directory moves its floor. A redirection, and a substitution the shell runs itself, stay where the command line stands.
57
+ - **Narrowing (security), by form.** Working directory `<home>/proj`, unanchored row `**/home/.mcp.json`; bash 3.2 reads the home's `.mcp.json` in each. On stage-7620 092bfda61 the station could not place these and did not meet the row: the default seat asked, the bypass seat printed the file. They are now refused (`read_path_denied`):
58
+ - `env -C <home> bash -c 'cat .mcp.json'`
59
+ - `env -C <home> sh -c 'cat .mcp.json'`
60
+ - `env -C .. bash -c 'cat .mcp.json'` (and `cd proj && env -C .. bash -c 'cat .mcp.json'` from the home)
61
+ - `env -C ~ bash -c 'cat .mcp.json'`
62
+ - `env -C <home>/proj -C <home> bash -c 'cat .mcp.json'` — the last `-C` wins
63
+ - `nice env -C <home> bash -c 'cat .mcp.json'`
64
+ - `env -C <home> cat .mcp.json` — the program's own word, the launcher's directory on its floor
65
+ - `env --chdir=<home> bash -c 'cat .mcp.json'` — GNU env; the macOS env refuses the long spelling and runs nothing
66
+ - `env -C <home>/proj - -C <home> bash -c 'cat .mcp.json'` — the `-C` after env's lone `-`
67
+ - `env -C <home> -S 'cat .mcp.json'` — env's own split string; on that tree the default seat asked and the bypass seat refused it too
68
+
69
+ The removal guard reads the same plan: `cd ./tmp && env -C / bash -c 'rm -rf ./usr'` (working directory `/`) is `dangerous_delete`, not `unverifiable_delete`.
70
+ - **Widening — four forms (open to veto).** Each was refused, and now asks on the default seat and runs on a seat that puts no ask, as any child shell's text that meets no row does. Bash reads the project's own `.mcp.json` in each. The old floor — where the command line stood, or a walk from there — met the home's row. The text now starts where the launcher put it, the project.
71
+ - `env -C <home>/proj bash -c 'cat .mcp.json'` — working directory the home, row `~/.mcp.json`
72
+ - `env -C <home> env -C proj bash -c 'cat .mcp.json'` — the same
73
+ - `env -C <home>/proj bash -c 'cd deep && cat ../.mcp.json'` — working directory `<home>/noproj`
74
+ - `env -C <home> -C <home>/proj bash -c 'cat .mcp.json'` — working directory the home, row `~/.mcp.json`; the last `-C` wins (D-3275-a above)
75
+ - **Who needs it / who is affected / compensation.** *Needs it:* a deployment whose deny rows are not anchored to the home (`**/name/file`), against a model that reaches the file by handing its directory to a launcher. *Affected:* a command that reads a guarded file through `env -C`, `sudo -D` or `unshare -w`: refused where it ran or asked. *Compensation:* none needed; a project's own file read through a launcher's `-C` asks instead of being refused (the widening above).
76
+ - **Consumers.** @cli @server: the engine you embed (7.61.0 and earlier) leaves these texts unplaced, so a seat with no ask reads the guarded file under an unanchored row. They are refused once you take this engine. No wire change, no new code. @test: please run the narrowing forms black-box on the bypass seat (no output, `read_path_denied`), the four widening forms (asked / run), and a launcher this pin runs only in the plan (`sudo -D`, `unshare -w`). Not this root: a directory the text computes at runtime (`env -C "$(…)"`, `cd "$(…)"`) stays unplaced, as before, and so does a `-C` written inside env's split string (`env -S '-C <home> cat .mcp.json'`: env reads it, the plan reads the string as a command line; the default seat asks, the bypass seat refuses it). Also not read: where `chroot <root>` runs a text — `env -C <dir> chroot <root> bash -c '…'` is placed at `<dir>` while chroot runs it at `<root>` (KL-3295-a, #3295; it needs root).
77
+ - **Pins.** `test/backlog3235-rebase-plan-nested.test.ts`, a `#3275` section in the #3235 world: 19 forms, each read four ways (`B3275_COLUMN=base` re-reads stage-7620 092bfda61); the #3235 table's `S2` cell is now refused. Plan cells cover each spelling of the family (`-C`, `-C/x`, `-iC`, `--chdir`, `--chdir=`, `sudo -D`, `sudo --chdir=`, `unshare -w`, `nsenter -w/x`, `nsenter --wd=/x`, a `-C` after env's lone `-`), relative, `..`, `~` and bound values, the last option winning, a chain, a substitution around the launcher, a place the launched text names, the moves left unsaid, a lost walk, the segment's own words, a redirection and a substitution, and no placeholder left. Removal-guard cells, the `=V` forms among them. Eight mutations (MA–MH), each red on its own fixtures. What bash opens for `env --chdir=` and for a `-C` after env's lone `-` is probed once on the host, since GNU env and the macOS env read the two apart (GNU takes `--chdir=` and ends its options at `-`); the engine's own readings are the same on both.
78
+
79
+ ### Errata to the 7.61.0 section (that section is frozen; the corrections live here)
80
+
81
+ - The #3212 section's Consumers sentence "@cli (L-2225): the latch definition sentence reads `sourceSessionId`" was untrue. The shell's interrupt-marker latch compares `detail.taskId` and keeps comparing it: @cli (L-2225): no key change — the latch keeps comparing `detail.taskId`; L-2225 rewrites its comment only. (The #3213 section's sentence that the latch compares `detail.taskId` was true.)
82
+ - A #3155 sentence said the server, cli and client-core build none of the delegation handles outside a Runner and call no such verb; the server half was untrue: the server drives delegation tools outside a Runner at parked redemption and at operator resume.
83
+ - The #2940 / #2760 section said of `judgeMailboxAppendById`'s new signature "@server's twins today call it nowhere, so the version that will"; that was untrue of the server: its SQL mailbox store calls it (`mailbox-store-sql.ts:154`), so the new first parameter `{ held, consumed }` is a hit there, to be met at its pickup.
84
+ - The Before sentence of the #3059 section said an inherited `permissionMode` or `appendSystemPrompt` stopped at the first copy; only an inherited `appendSystemPrompt` did — `permissionMode` was already read through the prototype.
85
+ - The #3079 section said the placement probe reads one 64 KiB block whatever the log's size; that holds only when the row's header fits one block (a 100 KiB header reads two). The true bound is the header's size, not the log's.
86
+ - The #3202 section's Consumers named no change for the server's `TaskSpec`s. The server carries three host facts on a spec as symbol-keyed members (`sema-server.handsLane`, `runSkills`, `legSessionWitness`), and an engine at 7.61.0 refuses such a spec `config.spec_unknown_key`: a symbol own key is an own key (C-R996 K6, the #3059 section; ruling note 2 keeps that reading). @server: move the three facts to a side table keyed by the spec object (SPECCARRIER, server 7.143.0); nothing else moves.
87
+ - The #3156 section said "Claude Code … has no durable park" for a session note held to the serialization point. That was too strong: Claude Code 2.1.309 does carry a parked approval across workers (`cli309.js:289257`, read for #3255, divergence D-3156-a). The corrected reading: the reference keeps the note in place at once, and its cross-worker handoff reads a transcript that already holds the kept note, so no row rides the park there — the handoff chain was read from the entry point, not hop by hop (an inference). Sema's choice (the note rides the park checkpoint as `heldRows`) stands as a registered divergence; the sentence, not the design, is corrected.
88
+
89
+ ### A row the engine parks says an absent member one way — by leaving it out — on every store, and a member is present exactly when its value is not `undefined` (#3277 = #3254 S1, ruled C-R1066 option B, open to veto; behavior change — the keys an in-process store holds for an engine-written row; hard-breaking: none; closed sets: none; exports: none) (@server @test)
90
+
91
+ - **Before.** The state serializer names every member of a parked row's `state`, an absent one as a key holding `undefined`, and the stamp kept such keys: an in-memory store held a fresh approval park with 26 of them in `state` and 2 at the top (`deadline`, `humanReview`), the File store none. Both stores' resolve wrote `reopenReason: undefined`, after which the File store answered `"reopenReason" in row` true before a compaction and false after it. By value every store already answered alike; by key no answer was stable, and the documentation held both readings (INTEGRATION-CORE: never branch on `in`; `CheckpointSummary`: test presence with `in`).
92
+ - **Now.** One reading: a member is present exactly when its value is not `undefined` — the receipt law's member half (which names a caller handed over stays the name half, read by key). One absence form on the rows the engine writes: the one stamp (`stampCheckpointRequirements`) writes a row's top level and its `state` with an absent member omitted, and a resolve removes `reopenReason`. Below those two levels the row is written as given — a tool call's arguments, a decision-read record and the resource ledger keep a key holding `undefined`, which the binding hash, the row digest and the park's argument comparison read (`StoreFidelity` keeps that loss on its list and now says its reach). A store's `put` is not normalized.
93
+ - **Who needs it / who is affected / compensation.** *Needs it:* an in-process reader of a row (`Object.keys`, a spread over defaults, `in`) that answered differently on the in-memory store, and the File store's own answer across a compaction. *Affected:* the bytes an in-memory or structured-clone store holds for an engine-written row (fewer keys). The requirement words and the row digest do not move (they read by value), so a row a 7.61.0 engine parked — its keys holding `undefined` included — judges `ok` on this engine; the wire is unchanged (JSON never carried those keys). *Compensation:* none needed.
94
+ - **Known limit (KL-3277-a).** A row a host `put`s itself with a member holding `undefined` is stored as given: the in-memory store keeps the key, the File store drops it — by key the two still differ, by value they agree.
95
+ - **Consumers.** @server (SQL twin, cc): a JSON store already reads this way; the contract kit's new cell holds while `get` and the listing read members by value. @test: two black-box cells — a row put with `deadline` / `state.compositionLeg` / `state.runOrigin` holding `undefined` reads them absent on both stores and judges as its twin without the keys; a row a 7.61.0 engine parked on a structured-clone store judges `ok`. A reading that counted keys on an in-memory row turns: read it by value.
96
+ - **Pins.** `test/backlog3277-member-presence.test.ts` C1–C9 (two stores, one answer; the 7.61.0 row `ok` bare, through InMemory and its listing, and through a v8 round trip; a real park leaves no key holding `undefined` at the two levels on InMemory and File, before and after a compaction and a restart; the stamp stops at the two levels (control); digest and words unchanged, bytes changed; no `reopenReason` key after a resolve on InMemory and on File live, replayed and compacted; a host's own put keeps the key on InMemory only (the known limit); the row judge reads every member of the row and state tables by the one presence; the predicate); contract kit cell "member presence" (`checkpointStoreContract`).
97
+
98
+ ### The `steering_injected` echo has one display bound and one cut, and the post-compaction background-task table is echoed whole (#3232; behavior change — the length of one echo; hard-breaking: none; closed sets: none; exports: none)
99
+
100
+ - **Before.** Six places in the runner minted an echo's `preview` with a literal 220: four through the redact-then-cut (`redactThenCut`), two (`limit_approach`, `final_verification`) through a raw `slice(0, 220)` — one fact, two readings of the cut (the raw cut can leave a credential fragment or a lone surrogate at the bound; neither of those two texts carries a secret today, which is why it never showed). And the post-compaction `background_tasks` frame opens with a 126-character header, so the 220 bound left about 94 characters of the table: a client that renders the preview's rows saw one row, often cut inside its description, however many tasks were running. The table's own 80-character clip of a task description was a raw `slice` of the stored text, so a credential the bound split (for instance a registry token whose last character fell past it) left a fragment no later pass could match — in the table the model reads and in any echo made from it.
101
+ - **Now — one seat.** `STEERING_PREVIEW_BUDGET` (220) and `steeringPreview(body, bound?)` (`src/core/runner/steering-preview.ts`): redact, then a marker-aware cut. Every echo the runner pushes that carries text — the boundary bundle, a leg's first frames, the resumed leg's continuation frames, the limit-approach notice, the final-verification injection — reads its preview through it, and the raw cuts are gone. The three `git_status` echoes carry a fixed string per kind (`GIT_STATUS_ECHO_PREVIEW`), which no bound touches. The 220 is unchanged for every prose frame, and the text the two engine-minted notices echo is byte-identical to before.
102
+ - **Now — the table.** `TurnAttachment.echoBound`: a frame whose body is a list its renderer already bounds states its own echo bound. The `background_tasks` frame states the per-boundary attachment byte cap (`ATTACHMENT_BYTE_CAP`, 8 KiB), so its preview is the table the model received — the header, every listed row (at most 50, each description at most 80 characters) and the "(+N more …)" line — not the first 220 characters of it. No other frame declares a bound, and the cut does not branch on the frame's source.
103
+ - **Now — the table's own clip.** `renderBackgroundTaskTable` (the one renderer of every model-facing list of a run's background tasks) redacts a description and then clips it to 80 characters, marker-aware (`redactThenCut`), so a credential-shaped part of a description reads `[redacted]` in the post-compaction table, the echo and a whole-session loss line alike, and no bound can leave a fragment of it. A description with no such part is byte-identical to before, except one whose cut at 80 falls inside a surrogate pair (an emoji, say): the old raw cut left a lone surrogate there, the new one does not.
104
+ - **Wire.** `preview` is still a string and the contract still says "clipped to a display bound"; the `steering_injected` sentence of `docs/INTEGRATION-CORE.md` §1.12 now names the bound (220) and the one wider one. Only a `background_tasks` preview is longer (up to 8 KiB, once per compaction). No new key, no type change, no exported name.
105
+ - **Who needs it / who is affected / compensation.** *Needs it:* a client that renders the post-compaction table from the echo (it parses one row per line). *Affected:* a consumer that assumed every echo is at most 220 characters — only `background_tasks` is longer; and a task description that carries a credential-shaped part now reads `[redacted]` there. *Compensation:* none needed; the bound stays on every other frame.
106
+ - **Consumers.** @client-core @cli @web-client: a `background_tasks` preview now carries every row of the table, so a row parser sees all of them (its "last row may be cut" tolerance only fires at the cap now); the package-side gap that the echo shows a row or two is closed on this engine's side. @server: persisted `steering_injected` frames of that source are longer. @test: a cell that read the table preview as at most 220 characters reads the whole table.
107
+ - **Pins.** `test/backlog3232-steering-preview-budget.test.ts` — the seat (budget 220, the cut is the marker-aware one; no src file mints an echo with a raw slice or a literal bound, every push's preview comes from the seat, the six minted sites by file) · the frame declares its bound (the table frame the lane cap, every other frame nothing) · six tasks: every row, every full description, the header, a substring of the model's request · an empty description and a description past the row bound · sixty tasks: 50 rows and the "N more" line inside the cap · a credential crossing the description bound (80) and one beside the lane cap's clip: no fragment in the model's table or the echo · redact-before-cut at the echo's own bound · an output style past the bound: first-frame and boundary echoes are the 220 cut, and a key straddling column 220 ships no fragment at the first-frame, the boundary and the resumed-continuation sites · the limit-approach and final-verification echoes are the first 220 characters of what the model received. Mutations redden their fixtures (`.gate-logs/criteria-3232-mutations.md`).
108
+
109
+ ### A cut staging name carries a digest of the whole target name, so a write's sweep of a dead process's staging files claims only its own (#3239; behavior change; hard-breaking: none; closed sets: none; exports: none)
110
+
111
+ - **Before.** A target whose name would pass 255 bytes with its staging tail stages under a cut name (#3106), and the sweep of a dead process's staging files (#3160) claimed a name when it equalled that cut. Two long names that differ only at their tails cut to one prefix, so a write of one removed the other's dead-pid staging file and counted it in its own `fs.staging_file_swept` count.
112
+ - **Now.** A name whose staging name would be 252 bytes or more (three short of the maximum) is cut — whole characters, from its end — and followed by `~` and the first twelve hex digits of the SHA-256 of the whole target name, then `.tmp.<pid>.<hex12>`. A cut name is never shorter than 252 bytes and a whole one never reaches it, so no two targets mint one name (a file named like another target's cut prefix stages under its own cut name). The one function that mints the staging name is the one the sweep claims by, so a name is claimed only by the target it was cut from; a name whose staging name stays under 252 bytes is spelled as before. A cut name without the digest (a file an older build left) is no target's claim and stays.
113
+ - **Who needs it / who is affected / compensation.** *Needs it:* a directory of long generated names, where one write's sweep reached into a sibling's dead-process file and its count said so. *Affected:* a target whose name is within three bytes of the point where #3106 started to cut (staging name 252–255 bytes, a target name of about 223–226 bytes) now stages cut and marked, where it staged whole; and a dead process's staging file for a long-named target that an older build left stays in place (it is neither swept nor counted). The staged sibling's name is seen only in a "preserved at" sentence and a residue notice, as free text. *Compensation:* none — such a file was never recoverable, only a leftover.
114
+ - **Known limit.** The claim is exact for a target up to the digest (two names that share the kept prefix and 48 bits of digest), not unforgeable: a file somebody spells exactly like a target's own staging name under a dead pid is claimed by spelling, as for any staging name.
115
+ - **Consumers.** None: engine-internal; the name is free text in a sentence.
116
+ - **Pins.** `test/backlog3239-staging-name-owner.test.ts` (two 251-byte names differing only at the tail: a write of one leaves the other's dead file and counts nothing, each write removes and counts only its own; an older build's unmarked cut stays under either name; a name whose staging stays under 252 bytes is swept as before at its longest; the first cut length; a multi-byte name cut on whole characters; a file named like another target's cut prefix mints its own name and neither write sweeps the other's file; the minted name read off the staging open for every name length from 200 to 255); `test/backlog3160-dead-staging-sweep.test.ts` and `test/backlog3106-writefile-staging-edges.test.ts` re-pinned to the marked shape.
117
+
118
+ ### A host pipe the engine holds reads closed once and carries nothing after: a message the host delivers is dropped, a send is refused (#3236; behavior change; hard-breaking: none; closed sets: none; exports: none)
119
+
120
+ - **Before.** The engine's hold of a host pipe (`McpHostSeat.open`) read as closed at the engine's close, but a message the host delivered afterwards still went on to the engine's handler and a send still went on to the host's pipe. Through an SDK client this was not reachable (the client guards a closed transport), so nothing user-visible followed.
121
+ - **Now.** One fact — the connection reads closed, set by the engine's close or by the host pipe's own — is read by both arms: a message delivered after it is dropped (the pipe's own earlier callback still hears it), and a send after it is refused with `McpHostSeatFailure` (delivered `no`, nothing handed on) in the sentence the request-level adapter already used for the same state, now spelled once.
122
+ - **Who needs it / who is affected / compensation.** *Needs it:* the "the engine's close is immediate" contract of a host pipe, which should include "after it, nothing is forwarded or sent" without leaning on the client library's guard. *Affected:* nobody — no connected client reached either arm. *Compensation:* none needed.
123
+ - **Consumers.** None: engine-internal.
124
+ - **Pins.** `test/backlog3236-taken-pipe-closed-gate.test.ts` (open: a message and a send go through; after the engine's close: the late message does not reach the engine and a send is refused with the host's forwarded count at none; after the host's own close the same, and the engine's close then rings `onclose` once; the pipe's own callback still hears; the late answer to a request sent before the close; the taken pipe and the request-level adapter refuse in the same words).
125
+
126
+ ### `FileSessionRepo.create` judges the placement tuple it writes by the form judge that reads it back, so a tuple a reader would refuse is refused at the write (#3260; behavior change; hard-breaking: none; closed sets: none; exports: none)
127
+
128
+ - **Before.** `create({ placement })` took the caller's tuple as it stood, stamping only `placedAt` when it was absent. A `kind` outside the placement kinds or a `placedAt` that is no finite number was written, and every reader of the row then refused it `corrupt_session` — a row the repo could write and could not read.
129
+ - **Now.** The create judges the tuple before the first byte by the very judgment the readers use (#3233): `kind` a placement kind, `placedAt` a finite number, `scope` / `handle` / `rootSessionId` / `parentSessionId` each a string when there; a cell that is no tuple (`null`, a string, an array) is refused too. A tuple that fails is refused `config.invalid_argument` naming the cell (`placement.kind`, `placement.placedAt`, …) and never the value, and nothing is written, so the id stays free. Only the exit differs from the read: a read refuses the row it found, a write refuses the call it was given. The re-open path of a create over an existing id still ignores a placement argument, as before.
130
+ - **Who needs it / who is affected / compensation.** *Needs it:* a deployment or store swap that writes placed rows through the File repo. *Affected:* a caller that passed a tuple of a bad form (the engine's own spawner passes kind `"subagent"`, string members, and lets the store stamp `placedAt`). *Compensation:* none — the refusal is at the call, where the bad value is.
131
+ - **Consumers.** @server (the File session store's users): `create` with a placement of a bad form now rejects `config.invalid_argument` instead of writing a row that reads back `corrupt_session`. @test: the black-box face is `create({ id, placement })` with `kind: "other"` or `placedAt: "5"` — the call rejects naming the cell and `placementOf(id)` stays `undefined`.
132
+ - **Pins.** `test/backlog3260-placement-write-judge.test.ts` W1 (good tuples written and read back as given; `placedAt` stamped when absent; zero kept) · W2 / W3 (fourteen bad forms refused `config.invalid_argument` naming the cell, nothing on disk, value never echoed) · W4 (the writer and the reader name the same cell for the same form; a form the reader accepts the writer accepts) · W5 (a refused create leaves the id free) · W6 (the re-open path ignores a placement argument) · W7 (rows without a placement unchanged).
133
+
134
+ ### A listing says whether this engine resumes a parked row, and the resume refuses it with the same sentence first — `CheckpointSummary.rowVerdict`, `judgeCheckpointRow` (#3265 = #3255 S1; behavior change — the order of refusals on a row that is faulty twice; hard-breaking: one, three sentences below, open to veto; closed sets: +1 `CheckpointRowVerdict["kind"]` (`ok` / `lacking` / `damaged`); exports: +1 root function `judgeCheckpointRow`, +1 root type `CheckpointRowVerdict`; members: +1 required `CheckpointSummary.rowVerdict` (wire +1 key on every summary), +1 optional trailing parameter `verdict` on `summarizeCheckpoint`) (@server @cli @client-core @test @sdk)
135
+
136
+ - **Before.** Only the resume judged whether this engine could resume a parked row, in a pre-CAS ladder spread over the admission rung, the gate screen and the checkpoint screen; a listing judged nothing, so every pending row listed as an approvable card. An approval parked by an earlier release whose reading this release changed (the rows a 7.60.0 engine parked, read by 7.61.0) was refused `requirements_damaged` only after a person approved it, and the sentence said no worker could resume it — untrue for a row a worker of the release that parked it still reads.
137
+ - **Now — one judge.** `judgeCheckpointRow(cp): CheckpointRowVerdict` (root export; pure, total, the verdict frozen) holds every resume refusal the row and this engine decide alone, in one order, the specific before the general: the version ceiling; a reader word this engine lacks; the retired mode-seed members, the retired single steer seat and the retired wall-clock axis; the reader-requirement list and the row digest; the recorded mode words; the real-approval bit; the read face, the write face, the skill grants, the skill scopes, the hands' coordinates; the frozen chain's tool names; the recorded run origin; the parent-constraint chain missing on a row of v7 or later, and the row's own chain against its digest. Each moved verbatim; the halves of those rungs that read the deployment, the re-supplied configuration, the inputs or the decision stay where they were (the checkpoint screen keeps `governed_unwired`, `resume_aborted`, `env_factory_missing`, `cwd_conflicts_restore`, the renamed mounts and the parent-constraint re-supply). The resume asks it first, right after it reads the row `pending`; the screen and the resume's configuration doors no longer repeat those rungs (the doors read nothing off the row; prepare still reads the run-origin word the leg runs under). Not in the judge: the row's recorded tool ceiling and own tool lists, which the checkpoint screen still reads at the resume — a row whose list holds a tool name in a form a row never records (`Read()`, say) lists `ok` and is refused `config.tool_face_control` when the resume runs, so those two faces answer differently there.
138
+ - **Now — the listing carries it.** Every `CheckpointSummary` carries `rowVerdict`: `{ kind: "ok" }`, or `{ kind: "lacking" | "damaged", code, reason?, requires?, sentence }` — `lacking` exactly for `checkpoint.unsupported_version` / `version_newer` (a newer engine's row), `damaged` for every other row refusal. `code` / `reason` are the refusal the resume throws; `sentence` is a fixed sentence per (`code`, `reason`) or per configuration refusal code, and it opens the resume's `message`. The verdict holds no row content: `requires` keeps only words spelled `^[a-z][a-z_]{0,39}$`, at most eight, never the row's token. `ok` is not "the resume will run": a deployment fact (`env_factory_missing`, `governed_unwired`) or a decision fault is still told when the resume runs. A listing and a `get` judge the same bytes. The in-tree stores keep each row's verdict with the row object they hold (a replaced row is judged again); the resume never answers from that memo. A store keeping its own memo keys it by the row's bytes and the engine build, `CONTRACT_KIT_ENGINE_VERSION` — never `MAX_SUPPORTED_CHECKPOINT_VERSION`, which two releases with different readings share — and passes it as `summarizeCheckpoint(cp, disclose, verdict)`; an external store keys it by the stored blob's sha256 plus that identity. A whole-row reader (`listBySession`, an operator queue) calls `judgeCheckpointRow(row)`.
139
+ - **Hard-breaking — HB-1, `CheckpointSummary.rowVerdict` is required (open to veto).** *What changed:* every summary carries the row's verdict, and `CheckpointSummary` declares it required. *Who is affected:* code that builds a `CheckpointSummary` by hand instead of through `summarizeCheckpoint` — a store's own projection, a test double — fails to compile, and the store-contract kit's two `rowVerdict` cases fail a listing that drops or rewrites the member (zero hand-built summaries in this tree); a BFF that re-projects summaries through a key allow-list carries no verdict until it adds the key (nothing breaks, the user-visible face is unchanged). *How to migrate:* build every summary through `summarizeCheckpoint` (a store with a memo passes it as the third argument, keyed as above); a reader of whole rows calls `judgeCheckpointRow(row)`; render a non-`ok` row with its `sentence`, not as an answerable card (`docs/INTEGRATION-CORE.md` §5.4, "A parked row across engine upgrades").
140
+ - **B-1 — the damaged-content sentence.** The `requirements_damaged` refusal opens with "This engine cannot resume this checkpoint: its content does not read the way it was written — it was parked by an earlier engine release whose reading this release changed, or it was changed in storage. The checkpoint stays pending; start the task again (a worker of the release that parked it may still resume it)." The sentence "no worker can resume it" is retired; code and reason are unchanged. A downstream pin that matches the old text reddens.
141
+ - **B-2 — the order on a row that is faulty twice (open to veto; C-R1065 note 3, the order law).** A row refusal is now told before any decision, deployment or signal refusal and before the configuration refusals that come after the resume config is read (the config's own door — a container that is no record, a member that cannot be read, a retired or unknown key, a store seat the engine cannot accept — and a token already consumed are still told first, as before): a bad decision on a damaged row reports the row's sentence (it reported the decision's); a v7+ row whose parent-constraint chain is missing, resumed without the parent constraints, reports `constraint_chain_missing` (it reported `resume.parent_constraint_missing`); an approval row that lost its bound input hash reports `requirements_damaged` (it reported `bound_input_hash_missing`); a row with the retired wall-clock axis on a worker with no organization wired reports `checkpoint.walltime_axis_retired` (it reported `governed_unwired`). Among the row's own refusals the order is one law, the specific before the general: a row that is newer (the version ceiling, or a reader word this engine lacks) reports `version_newer` first (a newer row that also carries a retired seat was told `seat_retired` by 7.61.0, and is told `version_newer` now); then a seat or axis a release retired (`seat_retired` for a retired mode-seed member or the retired steer seat, as in 7.61.0; `walltime_axis_retired`, which 7.61.0 told after the digest); then the reader-requirement list and the row digest (`requirements_damaged`, which says only that the content does not read the way it was written); then the rest. A row that was changed after it was parked and still carries a retired seat is told the seat — what to do about it — not the digest. A row with one fault is told as before.
142
+ - **B-3 — the judge is total.** A row the judge cannot read (a member that throws when read, a `state` that is not an object), which the resume used to throw raw (`TypeError`), is `damaged` / `checkpoint.invalid_outcome` / `requirements_damaged` on both faces; the resume's refusal says "the row could not be read" and names what was thrown in `detail.thrownName`, never its message. A listing whose projection reads past the judge (`state: null`) still throws as before.
143
+ - **B-4 — the message structure.** A row refusal's `message` is its fixed sentence, then `" Diagnostic: "`, then the message the rung used to throw; `code` and `detail` are unchanged. A downstream pin that compares the whole message compares the sentence prefix instead.
144
+ - **B-5 — a summary is a copy.** A summary no longer hands out a reference into the stored row: its `preview` is a copy (a preview that cannot be copied is disclosed and omitted), so editing a summary no longer edits the stored row.
145
+ - **Who needs it / who is affected / compensation.** *Needs it:* an operator or approval surface that lists parked rows across an engine upgrade. *Affected:* see HB-1 and B-1–B-5. *Compensation:* the verdict is the answer the resume would give; nothing about the row changes.
146
+ - **Consumers.** @server: the approval inbox's summary allow-list adds `rowVerdict`; the SQL store's `get` refuses a row above its version column with a bare `Error` before the judge reads it — align it so a listing and a resume give one answer; a memo, if kept, is keyed by blob sha256 + `CONTRACT_KIT_ENGINE_VERSION`; `listPending`'s subtree face judges as it decides. @cli: a card is rendered by its verdict (the shell decides how). @client-core: the three kinds and the sentence enter the render model; an unknown `kind` reads as not `ok`. @test: rows minted by 7.60.0 and 7.61.0, loaded under 7.62.0, black-box on the listing and the resume. @sdk: one additive key on the summary frame.
147
+ - **Pins.** `test/backlog3265-row-verdict.test.ts` — P0 (a real v10 park minus its bound input hash, approved with the parked call's own binding: both faces `requirements_damaged`, the row byte-identical; with a bad decision / a bad configuration / an aborted signal the row's sentence first) · P0′ (`requires` keeps words only, never the token, at most eight) · P1 (the 7.60.0 approval rows: damaged on both faces; the v9 row's read-face arm as before) · P2 (`lacking` for a newer format, an unknown word, a newer row with a retired seat) · P3 (seventeen row-only arms: listing = resume code / reason, the sentence first) · P4 (an `ok` park resumes) · P5 (total: a throwing member, `state: null`) · P6 (the member is required: a type error, and the kit fails a listing that drops it) · P7 (a row fault before a deployment fault) · P8 (`listOverdue` = `listByScope` = the judge) · P9 (the sentences; the closed set's three words) · P10 (`ok` with a deployment refusal at the resume) · memo (judged once per stored object, a replaced row judged again, the resume judges now). Mutations M1–M11 each redden their fixture (`.gate-logs/criteria-3265-mutations.md`). Re-pinned for B-2 / B-4: `backlog959` (the reference ladder runs the row's rungs first), `backlog1285` (sentence + diagnostic), `backlog1320` (the screen helper asks the judge first; the kit's preview reads registered), `concurrent-seam-scale` and `file-cross-backend` (the summaries carry `rowVerdict`), `checkpoint-bidi-projection` (the projection reads the preview once), and the pins that call the resume's configuration doors directly (the internal `refuseResumeDoors` no longer takes the row). The order law: `test/backlog3265-fix1-judge-order.test.ts` — a retired mode-seed member, the retired steer seat and the retired wall-clock axis on a v10 row whose digest no longer matches are told as themselves on both faces · a newer row (the ceiling, an unknown reader word) is told newer ahead of all of them · every pair of faults is told the first in order · the controls (the digest fault alone, a row with no fault, each fault alone). `backlog959` is re-pinned once more: its reference ladder tells the retired wall-clock axis ahead of the requirement list.
148
+
149
+ ### A workflow script that throws a value that cannot be read still ends its run with its terminal frame — the failure summary reads the thrown value member by member (#3240; behavior change; hard-breaking: none; closed sets: none; exports: none)
150
+
151
+ - **Before.** A workflow run's failure summary read the script's thrown value with plain property reads (`code`, then `message`). A script that threw a value whose reads throw — a `Proxy` whose `get` trap throws, a revoked proxy, an object whose `code` or `message` getter throws — made the summary builder throw inside the run's failure callback; the callback's own safety net swallowed that, and no terminal frame was ever sent. The run itself settled `failed` (durable row, registry row), but nobody listening for its completion was told: the model's turn and a host's notifier waited on a frame that could not come. One line of script text could hold a run's observer for good.
152
+ - **Now.** Every member of the thrown value is read once through the engine's one guarded member read (`readMember`): a member whose read throws is an absent member. The frame is always sent — `failed`, with the fixed sentence and the resume guide, plus the code and message words when those members are readable (a readable script error `code` survives a throwing `message`; a throwing `code` leaves the fixed sentence). The failure block of the run reads the thrown `code` through the same read (the hand-written guard beside it is retired). The frame has a floor that reads nothing (failed, the fixed sentence, the record unread): what the run and the thrown value add is read after, and a read that throws leaves the floor — a getter on the thrown value is script code and can reach the run the value rides out on (a direct caller of `runWorkflow` has no other vessel for it), so it can break the settle id the frame is built from; the frame goes out either way. The registry row reads the run's settle id before the thrown value's words, for the same reason. The registry row's failure text and the durable run's text were already total (`thrownText`) and are pinned beside the frame. The frame still carries no word of the thrown value beyond what a script error code already surfaced.
153
+ - **Who needs it / who is affected / compensation.** *Needs it:* a deployment that runs scripts a model wrote, where a throw is a script's own object. *Affected:* only a run whose script threw such a value — it now ends with a `failed` frame instead of none; every other thrown value reads the same bytes as before. *Compensation:* none needed.
154
+ - **Consumers.** @server (workflow execution face): the run lane and the durable notifier now receive the `failed` frame for a hostile-thrown run; a deployment timeout that was the only way out of that wait sees the frame first. @test: a script that throws a throwing `Proxy` / revoked proxy / throwing-getter object ends with a `failed` frame (summary: the fixed failed sentence).
155
+ - **Pins.** `test/backlog3240-workflow-hostile-throw.test.ts` (a real `Runner`, the `Workflow` tool and the repo's vm script runner) — a throwing proxy · a revoked proxy · every trap throwing · a symbol · a prototype-less object · throwing `code` and `message` getters · a readable message beside a throwing `code` · a readable script `code` beside a throwing `message` (and the parked sentence's message read) · a typed script error and a plain `Error` (controls: unchanged bytes) · no thrown word in the summary or diagnostics · the registry row's text and no escaping rejection · a getter that breaks the run's settle id (the floor frame is sent; the row keeps the id and nothing escapes).
156
+
157
+ ### A delegation tree binds a row's owner only when it is a name or anonymous — a number, an object or an absent owner cell does not bind (#3257; behavior change; hard-breaking: none; closed sets: none; exports: none)
158
+
159
+ - **Before.** `ownRowDelegationOwner` (a run nobody spawned) and `rowOwnerReading` (a revived child's own row) bound whatever `headOf` answered as `owner`: a store answering `owner: 42`, `{}` or no cell at all made that value the tree's owner, and every row created for a child recorded it. The revival reading also folded an absent cell into anonymous (`head?.owner ?? null`).
160
+ - **Now.** One judge of the cell (`ownerCellReading`, `src/core/runner/delegation-owner.ts`) serves both readings: a string or `null` binds as it reads; any other shape is `{ bound: false, reason }` — the delegation is refused `delegation.owner_unbound`, nothing starts and no row is created. The reason names the kind of value (`number`, `object`, `none`) and never the value. A missing row (`undefined`), a store without the by-id read and a read that throws read as before; one exception, on a revival: a store that answers `null` for a missing row (off the `SessionHead | undefined` contract) read as anonymous before and is refused now, as a row that could not be read. The seat's first answer, bound or refused, still stands for every later read.
161
+ - **Who needs it / who is affected / compensation.** *Needs it:* a deployment whose store could answer a malformed owner cell would have written it as the owner of every child's rows. *Affected:* only a store that answers an owner that is neither a string nor `null`, or a `null` head on a revival (the bundled stores never do either; a blank string stays the stores' own read fault). *Compensation:* none needed — answer a name or `null`.
162
+ - **Consumers.** @server: the two SQL stores' `headOf` answer the owner column as a string or `null`; nothing to do. @cli @test: a delegation over a row with a malformed owner cell is refused `delegation.owner_unbound` (it used to proceed with the malformed value recorded).
163
+ - **Pins.** `test/backlog3257-owner-cell-shape.test.ts` — S1 number (the reason names the kind, never the value) · S2 object · S3 absent cell · S4 a name and the anonymous owner bind · S5 the refusal stands for later reads · S6 a foreign occupant is told as the occupant, before the cell is judged · V1 revival: number / object / none · V2 revival controls (name, anonymous, missing row, no read, no session id) · V3 a read that throws. Mutations M1–M3 each redden their fixtures (`.gate-logs/criteria-small-h-mutations.md`).
164
+
165
+ ### A refused delegation says who holds the tree's slots — task ids, addressing names, synchronous children, and how a slot comes back (#3252; text change; hard-breaking: none; closed sets: none; exports: none; members: +1 method `TaskRegistry.activeDelegationOccupants` on the exported class, its return type not a root export)
166
+
167
+ - **Before.** The concurrency refusal answered "this session tree already has N agents running — the concurrency cap (…) refuses another" and a generic "wait or stop one". A model whose tree was full of agents it had not started — an extension's `$.agent.spawn`, an earlier turn's background children — read it as its own and retried for a cause it could not see.
168
+ - **Now.** The sentence adds the occupants the count was taken from: each registered agent the caller can address, by its `task_id` with its addressing name, up to five (the rest counted: "N more registered"), and the children running synchronously inside calls of the tree ("N running synchronously inside a call of this tree, no task_id"). When a task id is listed the way back says so: wait for one to complete, or stop a listed one with `TaskStop` and its `task_id`, then relaunch. The pool is the tree root's, so a nested agent's refusal counts rows of other branches too; those are counted and never named, and no `TaskStop` is offered for them — the registry's access predicate (the one the agent's own tools hold) decides what is addressable. The count, the cap, the code (`delegation.concurrency_cap`) and `details` are as they were. One mint (`concurrencyOccupants`, `src/agents/subagent.ts`) serves the four spawn lanes; `TaskRegistry.activeDelegationOccupants(scope, rootSessionId, caller?)` reads the rows `activeDelegationHandles` counts, each with its name and whether `caller` reaches it (same selection, same synchronous segment). A registry without that face, or whose face throws, names nobody and the refusal stands.
169
+ - **Known limit.** The sentence names the occupant, not who started it: a row records the leg that spawned it, and an extension's `$.agent.spawn` runs on that leg, so the model's own spawn and the extension's read alike there. Naming the origin needs the requester recorded on the row and its durable record.
170
+ - **Who needs it / who is affected / compensation.** *Needs it:* a model, or its operator, reading a refusal for a tree it did not fill. *Affected:* only the text of that refusal; a consumer that matched the whole sentence rather than its code sees the longer text. *Compensation:* none needed — read `details.code`.
171
+ - **Consumers.** @cli @server @test: assert and route on `delegation.concurrency_cap` by code; the sentence now carries `task_id`s a front end may link to running rows; `TaskRegistry.activeDelegationOccupants` is a new method on the exported class (additive).
172
+ - **Pins.** `test/backlog3252-concurrency-refusal-occupants.test.ts` — R1 one registered occupant (id, name, the way back) · R2 two listed · R3 past five counted · R4 a synchronous child counted without an id, no `TaskStop` offered · R5 both kinds together · R6 a registry without the naming face · R7 the naming face reads the rows the count does, and which of them a caller reaches · R8 a naming face that throws · R9 a nested agent is told the count and nothing it cannot address · R10 the root session of the tree reaches every row. Mutations M4–M8, M13, M14 each redden their fixtures (`.gate-logs/criteria-small-h-mutations.md`).
173
+
174
+ ### The warning for a `spec.tools` entry that collides with the built-in hands band says what the dispatcher does (#3250; text change; hard-breaking: none; closed sets: none; exports: none)
175
+
176
+ - **Before.** For a colliding entry the warning said "the built-in wins (registered later; the harness tool Map is last-write-wins) and the caller tool never dispatches this task". That is true for a caller tool sharing a band tool's NAME (it is replaced and never dispatches) and false for a caller tool whose ALIAS names a band tool: the alias resolves to the built-in (a canonical name outranks an alias) but the tool stays mounted under its own name, the model reads it in its tool block and runs it by that name — which a black-box run saw as the caller's alias tool running.
177
+ - **Now.** The warning is built from the dispatcher's own resolver over the mounted set the leg's tool valve leaves (`toolNameIndex` over `survivorsByName`, the rule a call is resolved by; a built-in the allow / deny lists unmount contests no name, and a caller tool they unmount is not warned about either: the warning is for a caller tool and a built-in that both stay mounted) and names each entry by its form: `"Read" is replaced by the built-in "Read", which serves that name (the caller tool never dispatches)`, or `"my_read" stays mounted under its own name, but its alias "Read" serves the built-in "Read"`. Still one warning per prepare (`onError`, phase `config`). Who serves each contested name is unchanged — the built-in — so no call resolves differently; only the sentence changes.
178
+ - **Who needs it / who is affected / compensation.** *Needs it:* an operator reading the warning to learn which of a deployment's tools the model can still call. *Affected:* only a consumer that matched the old sentence's wording. *Compensation:* none needed.
179
+ - **Consumers.** @cli @server @test: the warning is the `onError` text (phase `config`) — a cell that read "never dispatches" for the alias form reads the corrected sentence now.
180
+ - **Pins.** `test/backlog3250-hands-collision-notice.test.ts` (a real `Runner` with an `executionEnv`) — C1 same name: replaced, the call runs the built-in · C2 alias naming a band tool: the alias serves the built-in · C3 the same alias form: the caller tool IS called by its own name and runs · C4 the old claim is gone · C5 two entries of both forms are one warning · C6 two aliases of one entry · C7 no collision is silent · C8 an alias that names no band tool is not a band collision · C9 the valve removes the built-in the alias names: no warning, the call of that name runs the caller tool · C10 the valve removes the caller tool: no warning, the built-in runs · C11 the valve leaves both: the warning stands. Mutations M9–M12, M15, M16 each redden their fixtures (`.gate-logs/criteria-small-h-mutations.md`).
181
+
182
+ ### A placement cell that is no placement tuple is refused, and a placed row whose owner cell cannot be read is still in the placed listing — `FileSessionRepo` (#3233 / #3234; behavior change; hard-breaking: none; closed sets: none; exports: none)
183
+
184
+ - **Before.** A header's placement cell was passed through as it stood: `placement: "nope"` or `{ kind: 1 }` came back from `placementOf` and `open` verbatim, `placement: null` made `listPlaced` throw a `TypeError`, and a listing dropped such a row without a word. Separately, a PLACED row whose owner cell was neither a principal nor anonymous made the listings' whole-header decoding refuse, so `listPlaced` skipped it: a placed sub-agent transcript the deployment's review could neither see nor sweep.
185
+ - **Now — one form judge (#3233).** The header record's one read (the first-record rule every reader of the row goes through: `placementOf`, `open`, `headOf`, `exportEntries`, the listings) judges the placement cell: absent is no placement; otherwise it must be an object whose `kind` is a placement kind (`"subagent"`), whose `placedAt` is a finite number, and whose `scope`, `handle`, `rootSessionId` and `parentSessionId` are each a string when there. A tuple missing a join half stays a legal tuple (consumers still read it as `tupleIncomplete`, fail-closed); a member this reader does not know is tolerated as an additive one. Any other cell is `corrupt_session` naming the cell (`placement cell`, `placement.kind`, `placement.placedAt`, …) and never its value; a listing skips such a row and discloses it on `onCorruptRead`.
186
+ - **Now — the placed row with an unreadable owner (#3234).** The listings' one row reader answers such a row as what it is: `listPlaced` lists it (its tuple, or the `tupleIncomplete` variant; its age from the log's modification time, so `scope` and `olderThanMs` apply), the host `list` still leaves it out (placed rows never ride the host listing), and `onCorruptRead` is told once per listing, in one sentence that says the row is placed and its owner cell unreadable. The readers of the owner (`open`, `headOf`, `exportEntries`) still refuse the row. A row that is not placed, or whose placement cell is itself bad, is skipped and disclosed as before.
187
+ - **Behavior change.** A stored placement cell of a form above, which the repo used to answer as written, is now refused; and a placed row with an unreadable owner, which `listPlaced` used to omit, is now listed. The engine's own spawner writes none of the refused forms (kind `"subagent"`, string members, `placedAt` stamped by the store at creation), so only a hand-edited or damaged log is affected.
188
+ - **Who needs it / who is affected / compensation.** *Needs it:* a deployment whose placed-row sweep or store swap enumerates placed rows. *Affected:* a damaged or hand-edited log; a joint reap that now sees an unreadable-owner placed row and tries to release it (the release reads the head first and is refused, caught, and retried next sweep, as for any release fault). *Compensation:* none — the row is reported, not repaired.
189
+ - **Consumers.** @server: the swap gate that enumerates placed rows now sees a placed row whose owner cell is unreadable (its release stays refused `corrupt_session`); a placement cell of a bad form is `corrupt_session` on every by-id read instead of an answer. @test: the black-box faces are `placementOf` / `open` on a cell of each bad form, and `listPlaced` / `list` over a directory with a bad-cell row and an unreadable-owner placed row (the sink's sentence is the observable).
190
+ - **Pins.** `test/backlog3233-placement-cell-form.test.ts` P1 (fourteen bad forms ⇒ the four by-id readers refuse naming the cell) · P2 (the value is never echoed) · P3 (good forms answered as written) · P4 (no cell ⇒ `undefined`) · P5 (both listings disclose; `null` no longer throws) · P6 (neighbours unharmed); `test/backlog3234-placed-row-owner-unreadable.test.ts` Q1 (three unreadable-owner forms ⇒ listed, disclosed as placed) · Q2 (`tupleIncomplete`) · Q3 (host `list` leaves it out, same sentence) · Q4 (scope and age filters) · Q5 (unplaced bad owner still skipped) · Q6 (healthy placed row, silent) · Q7 (the owner's readers still refuse) · Q8 (bad owner beside bad placement ⇒ skipped) · Q9 (mixed directory).
191
+
192
+ ### A delegated child's rows belong to its delegation tree's owner — the engine mints the owner once and every row created for a child records it; `SessionPlacement.owner` is required (#3149, ruled C-R1016; BREAKING; behavior change; hard-breaking: three, three sentences each below, open to veto — the bundled stores' placed rows, `SessionPlacement.owner` required, a fork child's row; closed sets: none — `delegation.owner_unbound` is a new code string outside any registered set; exports: none; members: `SessionPlacement.owner` becomes required, +1 optional `RunInternals.delegationOwner`, +1 optional `ToolExecuteContext.delegationOwner`, +1 optional second parameter on the `ensureChildSessionDurable` hook) (@server @cli @test)
193
+
194
+ - **Before.** A background child's placed transcript recorded the owner its store's placing write chose: the bundled stores recorded none (`null`, whatever the tree root's owner), and a deployment's store could derive one of its own (the root's, else the parent's, else a sentinel). A fork child's row recorded the principal the run executed as. Three answers to "whose is this child's row".
195
+ - **Now — one owner, minted once.** The delegation tree's owner is the owner cell of the tree root's row, as the root run read it: a run nobody spawned (a top-level run, a revived child, a parked child resumed on its own) reads its OWN row once, by id through its own store's `headOf`, and takes it only while the row still holds the occupant it acquired (`incarnation` equal to the acquired session's; both absent = a row written before occupants were minted). Every run it spawns — background, foreground, fork, workflow agents and their descendants — holds the same reading by reference, so the tree binds once; deleting or re-creating the root row after that changes nothing for the tree. Every row a delegation creates for a child records that value: the placed transcript (`SessionPlacement.owner`), the fork (`SessionStore.fork(source, owner)` is called with it), and the durable row a park promotes (`ensureChildSessionDurable(id, { owner })`). A revived child creates no row: its re-open declares no placement, and a park it makes promotes its own row with the owner that row records.
196
+ - **Now — a tree whose owner does not bind starts nothing.** When the first read finds the row gone, or holding another occupant (the same owner name included), the child is not started and no row is created for it: the tool result is the not-started form with `details.code` = `details.error` = `delegation.owner_unbound` (new code; a read fault refuses the same way and binds nothing, so a later spawn reads again; what the read threw rides `details.cause`, never the model's text). There is no sentinel owner.
197
+ - **Hard breaking 1 — the bundled stores' placed rows (behavior; open to veto with 3).** *Changed:* a placed row on `TtlSessionStore` / `FileStorageBackend` records the tree owner instead of `null`; rows placed before 7.62.0 keep their `null`. *Who is hurt:* an embedder that authorizes by `headOf(id).owner` on the File lane and relied on a child's row reading anonymous (open to every principal). *How to move:* judge a child's row by the owner it records, as any owned row.
198
+ - **Hard breaking 2 — `SessionPlacement.owner: string | null` is required; placement obligation 7 (type + store contract; open to veto).** *Changed:* the member is required; a store that declares `placements` records exactly `placement.owner` in the row's owner cell on the placing write (never in the persisted tuple — `SessionPlacementRecord` has no owner — and never an owner of its own), and answers `headOf` for its sessions with the occupant the acquired session carries. `sessionStoreContract` judges it ("the placing write records exactly placement.owner …"). The contract sentence on `headOf` that let a store's own placing write record a principal is retired. *Who is hurt:* a store whose placing write derives an owner (the kit's new case reddens), a routing store that declares placements and forwards no `headOf`, code that builds a `SessionPlacement` literal (tsc). *How to move:* the INSERT records `placement.owner` (drop the derivation and the claim of ownerless placed rows); forward `headOf` by id the way `acquire` is routed; add `owner` to the literal.
199
+ - **Hard breaking 3 — a fork child's row (behavior; open to veto).** *Changed:* a fork child's row records the tree owner, no longer the principal the run executes as. *Who is hurt:* an operator or delegated principal that read a fork child's transcript through an owner gate under its own name. *How to move:* read it as the tree owner; an operator arm that admits by role is untouched.
200
+ - **Additive.** `ensureChildSessionDurable` receives a second argument `{ owner }`; a one-argument hook keeps compiling and working (the root witness a deployment's hook needed to derive the owner is no longer needed). `RunInternals.delegationOwner?` / `ToolExecuteContext.delegationOwner?` are the trusted seat (Runner-filled; never a `TaskSpec` key).
201
+ - **Known limit (P-9).** A child placed on the bundled stores before 7.62.0 recorded `null`; revived, it reads that `null` off its own row, so the children it spawns record `null` too, whatever its tree root's owner — the same reading as 7.61.0, not a regression (`docs/KNOWN-LIMITS.md` KL-3149-a).
202
+ - **Consumers.** @server (the store-boundary stage two, S-2667–S-2670, waits on this): the two SQL stores' placing INSERT records `placement.owner` (the root / parent / sentinel derivation and the ownerless-placed claim retire); `ForkRoutingSessionStore` forwards `headOf` by the same id routing as `acquire` (it declares placements, so obligation 7 holds it); every `SessionPlacement` literal gains `owner`; the park hook's root witness retires (record `given.owner`). Read points: the session gate's owner cell (`sessionOwnerReadable` / `ownerlessRowOpen`) now reads the tree owner on new placed rows (the ownerless placed arm keeps serving rows placed before 7.62.0 and anonymous trees); a child transcript read goes through the same gate; an owner-guarded delete still answers `false` for a placed row. @cli: the local lane's root rows are created by `acquire` and never registered, so their children keep reading `null` — no visible change. @test: black-box cells — root registered alice ⇒ `headOf(child).owner === "alice"`; anonymous root ⇒ `null`; the root row replaced (same owner name too) before the first delegation ⇒ refused `delegation.owner_unbound`, no child row; replaced after a delegation ⇒ later children still record alice; fork child under an operator principal ⇒ alice.
203
+ - **Pins.** `test/backlog3149-delegation-owner.test.ts` (real `Runner` over a real `FileStorageBackend`: T1 / T1′ / T1″ background child, nested background grandchild, and a background grandchild under a foreground child — all alice; T2 anonymous; T5 / T5b a run nobody spawned on a placed row named alice / `null`; HB-3 fork; R1 / R3 read points; the seat: T4a / T4a′ replaced before the first read, T4b after, row gone; the tool with an unbound tree, background and fork lanes, and a read that throws; the seat's read fault binds nothing; the type pin) · `test/backlog1468-s1-session-store-kit.test.ts` (obligation 7 mutants M7a–M7c; K6 now pins the tree owner on both bundled File lanes). Mutations M1–M11 each redden their fixture (M9: `test/backlog1796-transcript-corrupt-cause.test.ts` T2 — a revival reads no owner before its re-open stood). Re-pinned with Hard breaking 3: the #2265 b7 fork cell (`test/backlog2265-principal-name-one-judge.test.ts`: the principal, a name included, never names a fork's owner — no seat ⇒ the source's, a seat ⇒ the tree's), `agent-tool-consolidation` and `agent-fork-governance` FG2c. (`.gate-logs/criteria-3149-mutations.md`).
204
+
205
+ ### A host receives, structured, what the engine says where it holds no seat — `setDefaultEngineNoticeSeat`; and a credential value the host's own declaration refused is not said a second time by the engine's intake (#3248 / #3247; behavior change; additive wire; hard-breaking: none; closed sets: none; exports: +1 root function `setDefaultEngineNoticeSeat`) (@server @cli)
206
+
207
+ - **Before.** Four places take a credential value in without a notice seat in hand — a brain's construction `apiKey` and credential headers, a model entry's credential header (the route's read), a protocol peer's answer, a directly built distiller seat's key — and `RunnerDeps.onNotice` is not reachable from any of them. A placeholder or short key there (`EMPTY`, `lm-studio`, fewer than eight characters, one character repeated) made `config.credential_not_withheld` leave the one notice throat through its seatless arm as a bare `console.warn` line, so a server that starts the engine saw loose text it could not route. And the declaration (`declareWithheldEnv`) that refused the same value had already told the host, in its refusal, that it is no credential value; the intake's said-once account did not know, and the host got the fact twice, once structured and once as loose text.
208
+ - **Now — one default seat.** `setDefaultEngineNoticeSeat(seat | undefined)` (root export, `(notice: EngineNotice) => void`) installs the process's default notice seat; a second call replaces it, `undefined` removes it, anything else is refused (`config.invalid_argument`) and leaves the standing seat. The one throat (`deliverEngineNotice`) reads it where a notice arrives with no seat of its own — a seat that is present always wins (the `new Runner` receipt keeps delivering to its `onNotice`), and a present non-function seat is still a loud bad wiring on `console.warn`, never a fall-through to the default. A throw or a rejected promise from the default seat is swallowed as for every seat. With none installed nothing changes: the same line on `console.warn`. The four intakes take no new parameter.
209
+ - **Now — one account.** `declareWithheldEnv` refusing a value as no credential (the sentence that names `values[i]`) records that value on the same per-process said-once account the intake keeps (`config.credential_not_withheld`, once per value, keyed on the judged text); the intake then does not say it again. Only the member the refusal names is recorded, and only when the refusal is the no-credential reading (a NUL or unpaired surrogate, a non-string, an empty or blank string are told as something else or not said by the intake at all). One table, one writer.
210
+ - **Behavior change.** With a default seat installed, EVERY notice that reaches the throat with no seat of its own goes to it instead of `console.warn` — not only this one (the seatless arm of every station: fs timeout discards, listing truncations, and the rest). Route by `code` / `noticeAudienceOf` as for any notice sink. Install it before the first construction: a line a station already printed (and ledgered once per process) is not repeated to a seat installed later.
211
+ - **Who needs it / who is affected / compensation.** *Needs it:* a host that starts the engine and wants every engine notice as data. *Affected:* only a host that installs the seat (its seatless notices stop printing); everyone else is byte-identical. *Compensation:* none needed — the seat is the structured form of the line.
212
+ - **Consumers.** @server (S-2864): `setDefaultEngineNoticeSeat` is the one place to receive the line that was a bare `console.warn` at start-up (`config.credential_not_withheld`, operator audience, `detail: { reason }`, never the value); your own refusal line stands alone for a value your declaration refused, so the zero-bare-line cells you hold as expected failures turn once the seat is installed. @cli: the same seat for a CLI that wants these as data; nothing to do otherwise.
213
+ - **Pins.** `test/backlog3247-credential-intake-one-account.test.ts` — A1 (three refusal kinds, then a brain built on the value: nothing on the seat, nothing on the console) · A1d (another padding of a refused value is the same value) · A2 (one row per door) · A3 (a value not told is still said once) · A4 (only the named member is told) · A5 (a refusal for another reason tells nothing) · A6 (the test seam clears the account) · B1 (one row per door: the notice arrives on the default seat, the kind and never the value) · B2 (removal returns to the console line) · B3 (a seat a station holds wins) · B4 (reinstall replaces) · B5 (null / string / object refused, standing seat kept) · B6 (a throwing or rejecting seat is swallowed) · B7 (a present non-function seat stays on the console) · B8 (any seatless notice reaches the seat through the one throat) · B9 (a host's start-up end to end).
214
+
215
+ ### A host lists every held queue of its process, a held card says when it expires, and a held queue's shutdown answers once its receipts are in the senders' boxes — `listPeerHeldQueues()`, `PeerHeldEntry.deadlineAt`, `PeerHeldQueueSink.receipt` answers a promise (#3244 / #3245 / #3246; server S-1370; behavior change — `PeerHeldQueue.shutdown()` waits for its receipts and may reject; hard-breaking: two, three sentences each below; closed sets: none; exports: +1 root function `listPeerHeldQueues`, +1 root type `PeerHeldQueueSnapshot`; members: +1 optional `PeerHeldEntry.deadlineAt` (wire +1 optional key on a held card)) (@server @cli @client-core @test)
216
+
217
+ - **Before.** A host review face could reach a held queue only by its three coordinates (`peerHeldQueueIfAny(scope, sessionId, box)`): the registry was private, so a host listing the held letters of all its sessions kept its own table of (session, box) pairs fed from the notices. A card carried `heldAt` but not its deadline — the timer's instant lived only in the queue, so a host had to add `dialogExpiry` to `heldAt` itself, a second reading that is wrong after a cause move or a re-bind restarts the timer. `shutdown()` settled every held card and returned while the `expired` receipts it had sent were still being written: the drain's receipt seat was fire-and-forget, so a host that closed its pool after `shutdown()` could lose a receipt and had no handle to wait on.
218
+ - **Now — the enumeration face (#3244).** `listPeerHeldQueues(): readonly PeerHeldQueueSnapshot[]` (root export) — every held queue of the process's registry (the queues `peerHeldQueueFor` opened, which is how every drain opens its own; a bare `createPeerHeldQueue` is not listed), as a snapshot that opens none: `{ scope, sessionId, box, size, entries }`, `entries` as `PeerHeldQueue.list()` shows them and `size` their count at the same moment. The coordinates are the ones the registry minted the queue's key from (one reading for the key and the row), so a row's `(scope, sessionId, box)` handed to `peerHeldQueueIfAny` reaches that queue for its settle face; `sessionId` is the spelling the queue was first opened with (the key folds case), `box` is the session's own box or the principal inbox it also drains. An opened queue with no card is listed with `size: 0`. The notices `peer.inbound_disposition` / `peer.held_settled` do not carry a scope: the listing is where a queue's coordinates are read.
219
+ - **Now — the card's deadline (#3245).** `PeerHeldEntry.deadlineAt?: number` (ms epoch) — the instant the card's review deadline expires it unless someone answers first. It is written where the deadline timer is armed and removed where the timer ends, so it is present exactly while one runs: a review cause (`PEER_HELD_REVIEW_CAUSES`) ∧ a finite `dialogExpiry` ∧ the card still `held`. A re-judgment that moves the cause out of review clears it, one that moves it into review re-arms it from that instant; an approval, a hand-over, a `never` bind, the deadline itself and the card leaving clear it; a deadline whose expiry the store refused leaves the card held with none until the next bind re-arms it. `hold()`'s input does not take it (a caller's value is never carried onto a card).
220
+ - **Now — shutdown waits for its receipts (#3246).** `PeerHeldQueueSink.receipt` answers `Promise<void>`: it resolves once the receipt is in the sender's box, or has no reader there, and rejects when it could not be written. `shutdown()` settles every card as before, then waits for the receipts THAT settle sent (`Promise.allSettled`): it resolves when all landed, and rejects with an `AggregateError` whose message names each seq whose receipt did not (`PeerHeldQueue.shutdown: every held card was settled, but the expired receipt of seq 3, 7 did not reach its sender's box`) and whose `errors` are the receipts' own rejections. A receipt seat that throws instead of rejecting is the same refusal. A deadline's, a re-judgment's, an eviction's and an approval's receipt is still sent without waiting, and its rejection is never left unhandled. The drain's receipt seat now answers its route's append: a write fault on the sender's box is reported on `onError` (`peer-receipt-route`, once, as before) and is the receipt's rejection; a sender whose box is retired absorbs the receipt (no reader is not a fault).
221
+ - **Hard-breaking — HB-1, the receipt seat's answer.** *What changed:* `PeerHeldQueueSink.receipt` is `(entry, state) => Promise<void>` (was `=> void`). *Who is affected:* a host that implements the sink itself (`configure({ sink })` of its own) — it fails to compile; zero such implementations on server, cli and client-core `origin/main` (`git grep "receipt:"` there: 21 / 19 / 26 hits, none a held-queue sink; no file names `PeerHeldQueueSink`), and the server's S-1370 face reads the engine's own drain binding. *What to do:* return the write's promise — resolve when the receipt is stored or has no reader, reject when the write failed; an implementation with nothing to wait for returns `Promise.resolve()`.
222
+ - **Hard-breaking — HB-2, `shutdown()` may reject.** *What changed:* `PeerHeldQueue.shutdown()` used to resolve once the cards were settled; it now resolves once their receipts landed and rejects when one did not (every card is settled either way). *Who is affected:* a host that awaits `shutdown()` of several queues in one loop and lets a rejection end the loop — the queues after it would not be shut down (the server's S-1370 face shuts its queues down that way). *What to do:* shut each queue down on its own (`Promise.allSettled` over the queues, or a `try` per queue) and read a rejection as "these senders were not told"; the cards are settled.
223
+ - **Consumers.** @server (S-1370): `GET /v1/approvals` can list held letters from `listPeerHeldQueues()` and retire the coordinate table fed from the notices; a `peer_inbound` row can carry the card's `deadlineAt` instead of `heldAt + dialogExpiry`; the ordered shutdown can drop its fixed waiting window — `shutdown()` answers once the receipts are in the boxes — and reads HB-2 above. @cli: an approval card for a held letter can render `deadlineAt` (absent ⇒ no deadline runs). @client-core: a projection of the held card gains the optional `deadlineAt`. @test: a review-cause hold under `dialogExpiry: 60s` lists `deadlineAt = heldAt + 60000` and expires at that instant; a setting-cause hold has none; after a host's `shutdown()` resolves, the sender's box holds the `expired` receipt with no wait.
224
+ - **Pins.** `test/backlog3244-3246-held-queue-host-face.test.ts` (L1 three queues — two sessions' own boxes and a principal-inbox lane — listed with coordinates, size and cards; L2 the listing opens none and hands out copies; L3 a mixed-case session id, an explicit own box and the principal lane hand back to `peerHeldQueueIfAny` / `peerHeldQueueKey`; L4 no notice carries a scope; D1 `deadlineAt = heldAt + expiry` and the card expires at that instant; D2 none for a setting cause; D3 none under `never`, armed from a later finite bind, cleared by a `never` bind; D4 cleared by an approval, absent on a card adopted as approved; D5 cleared by a cause move out of review, re-armed by a move back; D6 a refused expiry leaves none until the next bind; D7 a caller's value is not carried; S1 a slow receipt holds shutdown's answer; S2 a rejecting receipt makes it reject naming only that seq, every card settled; S3 a throwing seat the same; S4 a deadline's and a re-judgment's receipt never waited on, no unhandled rejection; S5 shutdown waits only for its own receipts; S6 the drain's own seat — the `expired` receipt is in the sender's box when shutdown resolves, a write fault rejects it naming the seq with one `onError`, a retired sender's box does not; S7 a void-returning receipt seat is a compile error). Re-pinned on the new seat type: the receipt seats of `design385-slice4-held-idle`, `design385-slice4-receiving`, `backlog972b-fix1-delivered-uninjected`, `backlog1025-peer-inbox-wake` answer a promise.
225
+
226
+ ### A session log that lost a record in its middle resumes from the break and says what it lost — `session.lineage_rerooted`; a stored log that does not hold together is `corrupt_session`, and `invalid_session` is the import gate's word only (#1077; behavior change; behavior narrowing and wire-meaning narrowing — `invalid_session` no longer reaches a resume, hard-breaking: none; that narrowing is open to veto; closed sets: `EngineNoticeCode` +1 `session.lineage_rerooted`, wire-additive; `SessionErrorCode` unchanged; exports: none) (@server @cli @client-core @test)
227
+
228
+ - **Before.** The file store's replay skips a record it cannot read and counts it (#1041's partial arm), and the session opens. The run's first branch read then walked from the leaf up into the skipped record and was refused `SessionError("invalid_session", "Entry <id> not found")` — the code the import gate refuses a caller's log with. A resume of a session whose second or third line was damaged failed with no model call and nothing said which history was lost; a damaged LAST line resumed (the leaf falls back one entry). The same code answered every other stored-log fault too (a leaf or a floor the loaded log does not hold, a parent chain that loops, a checkpoint leaf a lost tail took, a compaction whose first kept entry is not on the path), so `invalid_session` read two ways: this file's 7.30.0 entry says it stays "a caller-submitted log failed validation", its 7.52.0 entry reads it as "a leaf or parent entry is missing from the log".
229
+ - **Now — the run re-roots, loudly.** A run reads its session through the leg's view of the storage. When a branch read breaks at a parent the log does not hold AND the replay that loaded the log dropped at least one record, the branch ends at the entry that names the missing parent: the entries that survive below the break are the conversation the run continues, and the run announces `session.lineage_rerooted` once per break per leg — `detail: { break: true, missingParentId, rootedAt, recordsDropped, recordsTotal, leaf, entriesOnPath, entriesCut, sessionId, runId }` (`break` and `leaf` are the #3237 section's, which also says the notice for a branch that did not break) (audience `user`, minted by the engine on `RunnerDeps.onNotice`; `entriesCut` = the entries the log holds that do not descend from `rootedAt`). The stop is the walk's own floor stop applied at the break (one `pathToRoot`, no second walk); `rerootIfHeadless` (a fork copy's re-root at a declared floor) is unchanged. A break the replay cannot account for — it dropped nothing, so the log was written with a parent it never held — is refused `corrupt_session` and never re-rooted. A walk outside a run (a fork, the compact verb, the store kit) has no announcement and so no re-root: a break is refused `corrupt_session`, so a damaged log is never copied into a healthy-looking child.
230
+ - **Now — one meaning per session word.** `not_found` = no such session, or an entry id this session never held; `corrupt_session` = the session is stored but cannot be read as one (no header its store wrote, or a tree that does not hold together); `invalid_session` = a log a caller hands in did not pass the import gate (`validateEntriesForImport`, a log transfer's staging), and nothing else among `SessionError`'s codes (`CompactionError`'s own `invalid_session` — an entry on the path with no id — is a separate closed set and is unchanged). The 7.52.0 entry's reading of `invalid_session` as "a leaf or parent entry is missing from the log" does not hold from this version. Each place that answered otherwise, its old code → its new code: the walk's missing parent (`src/engine/session/path-to-root.ts`, every `getPathToRoot` and `selectForkRows`) `invalid_session` → `corrupt_session`, the sentence naming the entry that names it and, from a store whose replay dropped records, the count (`(1 of 4 records skipped as corrupt)`); a parent chain that loops (`ParentChainGuard`: `getPathToRoot`, the resume-at scan, `settledForkOptions`, `selectForkRows`) `invalid_session` → `corrupt_session`, the sentence unchanged; a loaded log whose leaf it does not hold (the `BaseSessionStorage` constructor) `invalid_session` → `corrupt_session`; a bounded window whose floor the loaded log does not hold (the constructor) `invalid_session` → `corrupt_session`; a leaf entry a write appended naming an entry the log does not hold (`getLeafId`) `invalid_session` → `corrupt_session`, the load's sentence — the stored fact is the one a cold load of the same log refuses, and a resume's acquire reads a cached session's leaf, where a `not_found` would read as "no such session" (`resume.session_not_found`); a checkpoint cut at an entry the transcript no longer holds (the resume rewind) `invalid_session` → `corrupt_session` (its `transcript_corrupt` cause is unchanged); a compaction whose first kept entry is not on its path (`buildSessionContext`) `invalid_session` → `corrupt_session`.
231
+ - **Who is hurt.** A host that branches on `invalid_session` to tell "the stored log is broken" now gets `corrupt_session` for it; the import gate's 422 is untouched. A store that implements `SessionStore` and walks the parent chain itself fails the two `[tree]` kit cases (a parent missing above the floor, a looping chain) until its walk answers `corrupt_session` — a store on `BaseSessionStorage` / `pathToRoot` / `selectForkRows` answers it already. A user who resumes a damaged session gets a run on the surviving history instead of a failure, and a notice that names what was cut.
232
+ - **Deviation from the reference (stated; open to veto).** The reference's chain builder (CC 2.1.309) also ends at a missing parent, but first bridges to the nearest earlier record of the same chain within 5 s, and says nothing to the user. This engine bridges nothing — a dropped record's content is unknowable, a timestamp neighbour is not its parent, and a bridged history can split a tool call from its result — and announces the cut.
233
+ - **Consumers.** @server: the session-open fault words — `invalid_session` is no longer minted by this package on an open, a resume or a fork walk (your `UnusableArchiveWord` reading and the `local-session-window` comment that read it as "the stored log's structure is broken" now meet `corrupt_session` for that fact); `selectForkRows` in the pg / tidb fork paths refuses a missing parent and a loop `corrupt_session`; the import gate's `invalid_session` → 422 mapping is unchanged; forward `session.lineage_rerooted` to the session's user stream (audience `user`). @cli / @client-core: render `session.lineage_rerooted` — its message says which entry is missing, where the conversation continues from and how many entries were cut. @test: a damaged middle line ⇒ the resume completes with a model call and one `session.lineage_rerooted` carrying the count, never `invalid_session`; a dangling parent with no record dropped ⇒ `corrupt_session`.
234
+ - **Pins.** `test/backlog1077-chain-walk-reroot.test.ts` (real `FileStorageBackend` + `Runner` resumes over hand-written logs: R1 / R2 the second / third line damaged in three forms — torn, wrong shape, truncated — completes on the surviving branch with one notice and its exact detail; R3 the last line damaged: nothing re-rooted, and (#3237) the run says the replay dropped a record; R13 a second run re-roots again; R14 a side branch below the break is not counted as cut; R4 a damaged header `corrupt_session`; R5 an import of a dangling log `invalid_session`; R6 an id never held `not_found`; R7a / R7a′ / R7b / R7c the constructor and leaf refusals by their class, the file store's carrying the count; R7d a resume of a cached session whose appended leaf names an entry the log does not hold fails `corrupt_session`, never `resume.session_not_found`, and a cold reopen answers the same; R8 no resume of any damaged shape answers `invalid_session` on its terminal, `onError` or a notice, and R8′ only `import-validate.ts` and `session-log-transfer.ts` mint it in `src/`; R9 a dangling parent with nothing dropped refused, no re-root; R10 a fork below the break refused, nothing written; R11 a looping log; R12 a compaction off its path). Re-pinned on the new codes: `backlog2239-session-path-cycle`, `backlog2565-fork-row-selection`, `backlog2092-path-to-root-linear`, `engine-internals-coverage`, `backlog1796-transcript-corrupt-cause` (#1796's cells: T3's sentence; T3b: an interior entry garbled in place re-roots a parked resume instead of failing its startup); the notice catalog count in `backlog1279-child-undrained-to-parent`.
235
+
236
+ ### `git show HEAD:<path>` in a project under the home names the project's file, not the home's: an object path is judged where git resolves it — relative to the repository's top, or (spelled `./` / `../`) to where git starts — not at every ancestor of the command's directory (#1726; security widening — one placement, open to veto; behavior narrowing — `-C` and `--work-tree`, open to veto; hard-breaking: none; closed sets: none; exports: none; members: +2 optional — `ExecutionEnv.receivedEnvNames`, `ReadCandidate.repositoryTop`) (@cli @server @client-core @test)
237
+
238
+ - **Before.** The read station placed the path of a `<rev>:<path>` word (`git show`, `git cat-file`, `git archive`) at every directory the command may stand in and at each of their ancestors, because the text does not say where the repository's top is. A project under the home therefore met the home's rows: `git show HEAD:.mcp.json` was refused naming `~/.mcp.json` while `cat .mcp.json` ran, and so were `HEAD:./.mcp.json` and `:0:.mcp.json`. `git -C <dir>` was not read for the object path: the path stood where the command stood.
239
+ - **Now.** One rule — where git resolves it (gitrevisions(7)): spelled `./` / `../` ⇒ relative to where git starts; any other spelling ⇒ relative to the repository's top. Git starts in the command's directory moved by each `-C`. The top is `--work-tree`'s value where the text names it, else the one git's discovery finds walking up from where it starts — a filesystem fact the establishment reads through the station's door (`repositoryTopOf`, `src/tools/fs/shell-read-object-path.ts`): the first directory holding a `.git` DIRECTORY that is a repository (`HEAD` naming a ref or an object id as git reads it — `ref:` and `refs/` spelled exactly, case and all, with only a space, a tab, a line feed or a carriage return between them, or an object id in hex of either case; git skips a `.git` whose `HEAD` says `REF: refs/heads/main`, `ref: REFS/heads/main` or puts a vertical tab after `ref:`, and walks on to the repository above — #3292, a security fix on the repository-top probe: `HEAD` is judged on its first 255 bytes, as git reads it, and case-sensitively; a nested `.git` git would skip no longer counts as a repository top, open to veto —, `objects/` and `refs/` directories) whose own `config` names no work tree. Nothing is narrowed — every ancestor meets the rows, as before — where the text names the repository otherwise (`--git-dir`, `--bare`), the command's environment may carry a `GIT_*` variable (bound in the text, or received from the environment that runs it: `ExecutionEnv.receivedEnvNames` below), a `-C` / `--work-tree` value is one the text does not settle, the working directory is lost, the environment is an isolated sandbox, or the probe finds anything git might walk past or that names a repository kept elsewhere (a `.git` that is a `gitdir:` file or a link — a linked work tree's, a submodule's, or the home's own git directory, whose history git then reads under the project's name —, an empty or broken `.git`, a directory that is itself a repository, a configured work tree, no repository, a lookup with no answer). A home that is itself the repository's top keeps refusing `HEAD:.mcp.json`.
240
+ - **New member — `ExecutionEnv.receivedEnvNames?: readonly string[]` (additive).** The names of the environment the shell child receives, never a value — the one source for "may git read a `GIT_*` variable the text does not bind" (`GIT_DIR` inherited from a `vcsh` / `yadm enter` shell or a git hook points `git show HEAD:<path>` at the home's repository). `NodeExecutionEnv` declares it live off the same merge each exec gets (as `homeDir` and `cdPath`); omitted ⇒ the adapter cannot say, any name may be there, and an object path keeps every ancestor; a value that is not a list of names is read as omitted. Any `GIT_*` name keeps every ancestor (`GIT_PAGER` too: the rule does not track which variables git reads for its repository). Residual: a per-exec `env` adding one.
241
+ - **Narrowing 1 — `-C`.** An object path now stands where `git -C <dir>` starts, not where the command stands: `git -C ~ show HEAD:.mcp.json` from a directory outside the home ran and is now refused by the home's row (open to veto).
242
+ - **Narrowing 2 — `--work-tree`.** An object path is relative to the top `--work-tree=<dir>` names: `git --work-tree=<home> show HEAD:.mcp.json` from a project outside the home ran and is now refused by the home's row (open to veto).
243
+ - **Who needs it / who is affected / compensation.** *Needs it:* a person in a project under the home who reads a committed file of a name the home's rows guard through git. *Affected:* the two narrowed forms. *Compensation:* none for the widened form; a person who means the home's file asks for it as such.
244
+ - **Consumers.** @cli @test: a cell pinned to the refusal of `git show HEAD:<file>` in a project under the home now runs on a `NodeExecutionEnv` whose shell receives no `GIT_*` name; the home's own repository, a linked work tree or submodule under the home, the narrowed forms and `cat ~/<file>` stay refused. @server @client-core: an adapter of your own keeps the reading it had (every ancestor) until it declares `receivedEnvNames`; an `ExecutionEnv` the station reads through answers a few more lookups per object path (`fileInfo` of `.git`, `HEAD`, `objects`, `refs`, `config`; `readTextFile` of `HEAD` / `config` up to 64 KiB); a lookup with no answer leaves the command `unanswered`, as any lookup does. Known limits: `KL-1726-a` (linked work trees and submodules), `KL-1726-b` (undeclared adapters), `KL-1726-c` (a substitution's absolute `-C` — closed in this release by #3235).
245
+ - **Pins.** `test/backlog1726-object-path-repository-top.test.ts` (each layout checked against what the real `git show` prints there: a project under the home at its top and from a subdirectory, `./`, `:0:`, `:`, `cat-file`, git listed and unlisted; outside the home; the home as the top, from below it and from a project with no repository; the home inside a larger repository; `-C` to another repository, `-C ~` from outside, relative and chained `-C`; a lost working directory; `--git-dir`, `--bare`, `GIT_*`, `--work-tree`; an empty `.git/`, a garbage `HEAD`, a `HEAD` git does not read (`REF:`, `REFS/`, a vertical tab or a form feed after `ref:`) and three it does (a tab and a space after `ref:`, an object id in upper and in lower case), a dangling `.git` link, a configured work tree, a linked work tree's `.git` file, a `gitdir:` file and a `.git` link naming the home's git directory, the inside of a `.git`, a bare repository with the home as its work tree, a working directory reached through a link; a `GIT_DIR` the shell receives, an adapter that declares no names or a malformed list, one that declares none received; `git grep` with no operand and with a pathspec).
246
+
247
+ ### A slow or silent store of the person's permission rules holds the first model request once, not twice — the first request's tool table stands on the prepare read, and a request after a read the store left silent stands on that read (#3249; behavior change — wait time, and the first request's tool table stands on the prepare read (#3272); hard-breaking: none; closed sets: none; exports: none) (@cli @server @test)
248
+
249
+ - **Before (7.61.0).** The run's prepare read of the person's persisted rules and the first request's tool-table read (#3126) ran one after the other, each bounded by the reader's 14 s bound: a store answering every read in 3 s held the first model request 6 s (7.60.0: 3 s); a store that never answers held it two bounds (≈ 28 s), and two requests with a tool call between them were two bounds apart (the call's read, then the next request's own).
250
+ - **Now.** A request's tool table reads the store when the request is sent (a read asked earlier — a call's, a visibility probe's — may predate a rule a tool wrote, which binds the next request as in 7.61.0), except where an earlier read stands for it and asks the store nothing new: the prepare read, for the first request while no read has started after it; and the newest read asked since the previous request that the store left unanswered past its bound, while no read started after it has been answered — its verdict is the failure law's, the one a new read of the silent store would give. A read still pending is not joined. Readings on a virtual clock: a 3 s store — the first request at 3 s (7.61.0: 6 s); a store that never answers — the first request at one bound (7.61.0: two), the next request one bound after it, the tool call's own read (7.61.0: two).
251
+ - **Unchanged.** Every call takes a read of its own, pinned to its attempt; a visibility probe takes one; the failure law (a partition that could not be read lends the deny and ask rows of its last successful read, none of its allow rows), the run's one `permission.rule_store_unavailable` notice and the bound's value are as they were. Two requests with a tool call between them still read a store that answers twice (the call's read, then the next request's): a 3 s store, 6 s.
252
+ - **One consequence (KL-3272-a, #3272).** A whole-tool deny row written after the prepare read and before the first request (one a hook writes, say) is not in that request's tool table, because the request stands on the prepare read; in 7.61.0 the request read anew and saw it. The next request's table has it, and the call itself, which reads for itself, is still refused. So the model may be shown a tool for one request that the person's deny rows already refuse. Tracked as #3272 (7.63.0).
253
+ - **Who needs it / who is affected / compensation.** *Needs it:* a person whose rule store is slow or unreachable — the first answer comes one store latency (or one bound) sooner. *Affected:* no call's decision changes (every call reads for itself); the first request's tool table can lack a whole-tool deny row written just before it (the consequence above); a silent store is said to be unreadable once per read asked, so a run's trace carries fewer such lines. *Compensation:* none needed.
254
+ - **Consumers.** @cli @server: user-visible wait — a rule store that never answers holds the first model request ≤ 14 s (was ≈ 28 s) and each later request ≤ 14 s beyond its tool calls' own reads; nothing to change in code. One more thing a black box can see (#3272): a deny row written between the prepare read and the first request is in the second request's tool table, not the first's. @test: re-check the first-request cell — ≤ 15 s against a store that never answers (was 28.02–28.04 s); a 3 s store's first request ≈ 3 s (was 6.05 s); in the two-request run the second request comes one bound after the first.
255
+ - **Pins.** `test/backlog3249-rule-store-one-bound.test.ts` (a real Runner, its store and every wait of 1–60 s on a virtual clock: F1–F4 the first request, H1 the clock's own control, B1–B3 two requests with a tool call between them, C1–C3 the judgments unchanged, R1–R8 the reader's request read); `test/backlog1293b-person-path-rows.test.ts` read numbering and `test/backlog3126-deny-tools-out-of-table.test.ts` ⑤d count re-pinned (the prepare read is the first request's).
256
+
257
+ ### A run that continues a session whose log lost records says so whether or not the branch broke — `session.lineage_rerooted` with `break: false`, and `SessionStorage.getReplayLoss` (#3237; behavior change; wire-additive — `detail.break` and `detail.leaf` on the #1077 notice, a second form of it; hard-breaking: none; closed sets: none — no new code; exports: none; members: +1 optional `SessionStorage.getReplayLoss`) (@cli @client-core @server @test)
258
+
259
+ - **Before.** The #1077 notice (`session.lineage_rerooted`) was said only when a branch read met a parent the log did not hold. A log whose replay dropped records and whose surviving branch was whole resumed in silence: the log's last records unreadable (its head falls back to the last one still readable — a model shown `one` of a conversation of `one two three`), the middle and the last together, or damage off the branch. The person's latest turns were gone from the context and nothing said so.
260
+ - **Now.** The leg asks the storage it continues what the replay that loaded the log dropped — `SessionStorage.getReplayLoss(): { dropped, total } | undefined`, a new optional member (`BaseSessionStorage` answers it; the file store's storage carries its replay's tally, fixed at the load) — at the run's first branch read, and `dropped > 0` is one `session.lineage_rerooted` a leg (the acquire may read again after a lost write race and keeps one attempt: what the attempts found is said once the attempt that holds is known, so a discarded attempt's branch is never described). One code, two forms told apart by `detail.break`: `false` — the branch is whole: `detail: { break: false, recordsDropped, recordsTotal, leaf, entriesOnPath, sessionId, runId }`, `leaf` the entry the first branch read started from — the head, at every call site in this tree (`null` when nothing of the log is readable), and the message says the run continues from there and that what the unreadable records said, possibly its latest turns, is not in its context; `true` — the branch broke, as in the #1077 section, with `break` and `leaf` added to its members; a leg whose branch broke says that one notice and no whole-branch notice besides, as far as the acquire's own reads go (KL-3237-a: a whole-branch notice already said is not withdrawn if a later read from another leaf finds a break, which would give that leg two notices; every branch read after the acquire in this tree starts from the head, so no instance is built — inferred from the call sites). Counts and entry ids only, never a record's words. The log is not repaired by the run, so every leg over it says it again (the #1077 rule, now for both forms).
261
+ - **Unchanged.** A log whose replay dropped nothing says nothing; a break the replay cannot account for is refused `corrupt_session`; the count's sentence (`N of M records skipped as corrupt`); an unterminated crash tail is not a record and is not counted (the replay's rule).
262
+ - **Who needs it / who is affected / compensation.** *Needs it:* a person who resumes a session whose file lost its latest records. *Affected:* a front end that renders this code's notices shows one more line per such resume (audience `user`); a consumer that read the #1077 notice's `detail` as always carrying `missingParentId` now branches on `detail.break` first. *Compensation:* none needed; a store of rows read whole has no replay to lose from and need not implement the member.
263
+ - **Consumers.** @cli @client-core: render `session.lineage_rerooted` for both forms — `detail.break` says which members are there (`missingParentId`, `rootedAt`, `entriesCut` only when `true`); the message is complete as it stands. @server: forward it to the session's user stream as the #1077 notice (audience `user`); a SQL store of yours that skips rows it cannot read may answer `getReplayLoss`. @test: a log with its last records damaged ⇒ the resume completes on the surviving turns with one `session.lineage_rerooted`, `detail.break: false`, the count and the head; a healthy log ⇒ none.
264
+ - **Pins.** `test/backlog3237-replay-dropped-notice.test.ts` (a real `Runner` over the file backend: D1 the second and third of three messages damaged in three forms, written by the real repo ⇒ one notice, count 2, head = the first message · D2 only the last damaged · D3 only a middle one (the break form: one notice, `break: true`) · D4 a middle and the last under a surviving child ⇒ one notice · D5 a healthy log, two legs ⇒ none · D6 nothing readable ⇒ no head · D7 no record's words in the notice · D8 each leg says it again · D9 the wire face · S1 / S2 the storage's account · V1 the finding is the read's own, a head that moves under the read does not suppress it · V2 the seat's dedup · L1 the leg holds an attempt's findings until the acquire settles · D10 / D11 a lost write race in the acquire (whole then broken, broken then whole) says the branch that holds, once); `test/backlog1077-chain-walk-reroot.test.ts` R1's detail (`break: true`, `leaf`) and R3 (the last line damaged now says so).
265
+
266
+ ### A `cd` inside a subshell, a pipeline member or an uncalled function no longer moves the command, and an array element the shell binds is never an environment value — the read boundary and the removal guard read where bash stands, and a `case` arm's command is read where its pattern really ends (#1082, with #3269; behavior change, relaxing by form and narrowing by form (security: #3269); the refusal says how a deny row was met; hard-breaking: none; closed sets: none; exports: none) (@cli @server @test)
267
+
268
+ - **Before.** The working-directory walk read a move inside a `( … )` group, a non-last pipeline member, a background job or an uncalled function body as a move of the whole command (KL-1554-a), so a relative read after it was also judged where the move went: `(cd && ls >/dev/null); cat .npmrc` was refused by the home's `.npmrc` row though bash reads the project's `.npmrc`; `(cd /); rm -rf ./usr` was a `dangerous_delete`. A subscripted element assignment (`a[0]=~/.npmrc`) was a deny candidate of its own, while a compound one (`a=(~/.npmrc)`) was not — one fact, two readings: `a[0]=~/.npmrc; cat ~/other.txt` was refused, `a=(~/.npmrc); cat ~/other.txt` asked.
269
+ - **Now — one visibility rule.** A move reaches a later segment exactly where a binding of the same segment would (the binding thread's rule): a move in a subshell group, a non-last pipeline member, a background job or a function body is no move outside it; the walk holds again what it held before it. The places such a scope went stay on the deny floor of a walk that later loses track (a call of the body, `source`, a text the walk does not follow), so `f(){ cd; }; f; cat .npmrc` and `f(){ cd; }; echo "$(f; cat .npmrc)"` are still refused. The last member of a pipeline may run in this shell (`lastpipe`): its move stays a candidate. A scope closes only where its own group or body does: a segment of closing words alone (`fi`, `esac`, `}`, a loop's `done)`), a function definition nested in the body (`f(){ cd userhome; g(){ :; }; cat .npmrc; }; f`) and a `case` arm's `)` leave the move standing. A `case` command's own words are read once, across the text's segments, for both the block structure and the argv projection: `case` at command position, its subject, `in` (a newline may stand before it), then each pattern — an optional `(` of its own, alternatives joined by `|`, ending at its first `)` whatever follows (`(cd userhome; case x in x) (true);; esac; cat .npmrc)`, `(cd userhome; case x in x|y) ;; esac; cat .npmrc)`) — and an arm ends at `;;` / `;&` / `;;&` or `esac`. The operands of a conditional `[[ … ]]`, an arithmetic command `(( … ))` and an extended glob `@( … )` are read once too, across the segments an `&&` / `||` / `|` inside them splits: no word there is a reserved word and no parenthesis a group's (`[[ x == x || case == in ]]`, `[[ x || } ]]`, `(( 1 || 0 ))`, `[[ x == @(a|b) ]]` close or open nothing). The old same-segment guess (a `)` a word follows ends a pattern) is retired, with the per-segment arithmetic and extended-glob skips.
270
+ - **Now — one predicate for array elements.** A compound value and a subscripted name (`a[k]=v`, `declare a[k]=v`) store array elements: where the shell itself binds them (an assignment statement) never an environment candidate (bash never exports an array — an element assigned to an inherited exported name makes it an array, gone from every child's environment), always the element floor a later `${a[k]}` / `${a[@]}` read meets. `a[0]=~/.npmrc; cat "${a[0]}"` is refused as before, now through the element floor. A word the shell may hand on keeps its candidate as before: a prefix `a[0]=~/.npmrc prog` (bash 3.2 puts `a[0]=<home>/.npmrc` in the program's environment; 5.x refuses the word and runs the program), a launcher's operand (`env a[0]=~/.npmrc prog`) and a declaration builtin's operand (`declare a[0]=~/.npmrc`: the name may be a function, which receives the word — `declare(){ cat "${1#*=}"; }; declare a[0]=~/.npmrc` reads the deny row on both bash versions) are still refused; the declaration builtin's element also leaves the element floor. A scalar statement assignment keeps its deny candidate (an inherited exported name stays exported): `A=~/.npmrc; cat ~/other.txt` is still refused.
271
+ - **Now — the refusal names how the row was met.** A deny refusal reached through a home word spelled with the declared home ends "The word was judged as spelled with the environment's declared home: …"; one reached through the floor of a move the command does not settle ends "The working directory at this word is not settled — …". A refusal of a word as the command places it is unchanged.
272
+ - **Behavior change — relaxing, by form (bash 3.2.57 / 5.3.15 in an isolated tree read the project's file or nothing):** refused → asked: `(cd && ls); cat .npmrc`, `(cd userhome && ls); cat .npmrc`, `(cd); cat .npmrc`, `cd | true; cat .npmrc`, `f() { cd; }; cat .npmrc`, `(pushd ~); cat .npmrc`, `(cd userhome; case x in x) ;; esac); cat .npmrc`, `f(){ g(){ cd userhome; }; cat .npmrc; }; f` (the nested body is never called), `a[0]=~/.npmrc; cat ~/other.txt` (the out-of-root read of `other.txt` is the ask); `a[0]=~/.npmrc; echo done` vouches on the read face. The removal guard reads the same walk: `(cd /); rm -rf ./usr`, `cd / | true; rm -rf ./usr`, `f(){ cd /; }; rm -rf ./usr` are judged as `rm -rf ./usr`.
273
+ - **Behavior change — narrowing (the removal guard):** a subscripted element now leaves the element floor a compound one always left, so `D[0]=/; rm -rf "$D"` and `declare D[0]=/; rm -rf "${D[@]}"` (bash removes `/`) are `dangerous_delete` instead of `unverifiable_delete`, as `D=(/); rm -rf "$D"` already was.
274
+ - **Behavior change — narrowing (a group's or an arm's command the old pattern guess hid, #3269):** the same-segment guess read a `)` with no word after it as a group's and one with a word after it as a pattern's, wherever it stood, so a command went unread: a `case` arm's command behind a group, a redirection or a newline before `in` (`case a in a) (cat ~/.npmrc);; esac`, `case a in a) 2>/dev/null cat ~/.npmrc;; esac`, `case a` ⏎ `in a) (cat ~/.npmrc);; esac`), and — with no `case` at all — a group a reserved word follows (`{ (cat ~/.npmrc) }`, `if (cat ~/.npmrc) then :; fi`, `while (cat ~/.npmrc) do break; done`). On stage-7620 1ca4d7b9f the read face vouched for all six and the default seat asked once (an answered yes printed the deny row; bash 3.2 / 5.3 read it); they are refused.
275
+ - **Behavior change — narrowing (a loop that loses track):** a loop whose first beat loses track of the working directory (`source`, a `cd -` with no settled previous directory, a bare `cd` the walk cannot follow) no longer keeps its body's reads placed where the first beat stood — a later beat runs where the loss left the shell, so the body's words are judged against the loss's floor, as an uncountable loop's body already was. `(for i in 1 2; do cat .npmrc; cd userhome; done); true` (bash reads the home's `.npmrc` on the second beat) was asked and is refused.
276
+ - **Still refused, by design (KL-994l, rewritten form by form):** the return move of `cd; cd - ; cat .npmrc`, `cd; cd "$OLDPWD"; …`, `pushd ~; popd; …` may fail like every move, so the home stays a candidate (open to veto: bash reads the project's file, so the home stays a candidate where bash would not need it; the reference appears to refuse these forms by its own deny rows too — an inference from its directory-candidate walk (`cKt`, `cli309.js:263950`), not run on the reference; D-1082-a); a prefix or a statement that rebinds HOME (`HOME=<x> bash -c 'cat ~/.npmrc'`, `HOME=<x>; cat ~/.npmrc`, its glob / traversal / symlink / `..` forms); a literal tilde (KL-1100a); `~+` / `~-` / `~user`, which the plan does not expand. KL-994l's old sentence "pushd / popd destinations do not enter the deny floor" was untrue and is withdrawn; KL-1554-a is closed.
277
+ - **Who needs it / who is affected / compensation.** *Needs it:* a user whose `( … )` / pipeline / function-definition text was refused or flagged dangerous where bash never left the project. *Affected:* a host or test that pinned those refusals (they now ask or pass). *Compensation:* none needed — every form bash really reads a deny row through is refused as before (the controls in the pin).
278
+ - **Consumers.** @cli: the refusal text gains one closing sentence on the shadow and floor arms (no code changes: `read_path_denied`). @test: please re-run the 21 home-shadow forms (bt1-core `core1082-still-red-forms`, fal1103 H25 / H12 / H13) — H10 / H22 now M; H09 / H16 / H25 R by design (KL-994l ①); H12 / H13 documented (KL-994l ④); and the six forms of #3269 (refused now; one approvable ask before). @server: no wire change; the removal guard's answers for the three KL-1554-a forms relax; a `case` arm's command and a group a reserved word follows are read now (#3269: a text that asked may be refused). @cli: the same — a refusal where such a text asked before (`read_path_denied`, no new code).
279
+ - **Pins.** `test/backlog1082-shell-read-shadow.test.ts` — the 21 forms and 48 scope / case-arm / operand / array-element / control forms on the real Runner lane (one letter column per tree: `B1082_COLUMN=base` re-reads stage-7620 1ca4d7b9f), 42 `/bin/bash` ground-truth cells in an isolated tree, the export behaviour of an element assignment (bound, and a prefix handed on), the two refusal sentences, the plan's scope, closing-word, nested-definition, case-arm and element cells, the removal guard's element floor, lost-scope floor, loop beat, nested definition and case arm, the read face on disk. Mutations, red cells per fixture (`.gate-logs/criteria-1082-mutations.md`, M1 – M20): every rule above reds a cell written for it. Re-expressed (old → new meaning): `test/backlog1554-where-the-command-stands.test.ts` — the four KL-1554-a removal cells (dangerous → the unmoved control's answer), `(cd /); cat ./x` (`/` and the start → the start), the two uncalled `eval`-defined bodies (`..` too → the start alone). The equivalence allow-lists: `program-read-model-equivalence.allowed.json` (192 entries gain `1082-case-words-one-reader`, 15 removed — their reading equals the baseline again) and `program-read-model-equivalence-1102c.allowed.json` (191 entries gain `1082-case-words-one-reader/write/{tighter,looser,same standing}` — 165 / 8 / 18 —, 16 removed); every moved entry is a corpus text bash does not parse (a `)` a plain word follows), and the new reading keeps the words the old guess dropped.
280
+
281
+ ### The sentence of a nested durable pause names the entry that continues it — `resumeCascade` for a cascade, `resumeWithVerification` for a verification gate (#3276 = #3253 S1; text change; hard-breaking: none; closed sets: none; exports: none)
282
+
283
+ - **Before.** When a cascade rung or a verification gate's leg durably paused, the failed terminal (`unexpected.suspended` / `unexpected.needs_review`, the pause on `nestedPause`) said that durable suspend / resume and plan / dry-run review are "only supported at the top-level runTask". That was false for both: `resumeCascade` continues a parked rung from its card and `resumeWithVerification` continues a gate's leg. Five restatements repeated it (the mint's module header, `TerminalCause.failed.code` / `nestedPause`, the `TaskStatus` doc, INTEGRATION-CORE, the service guide) and `TaskSpec.durableApproval`'s doc said it a sixth time; three of the five also said the repair loop, a workflow and a subagent map the pause too — they do not (the repair loop hands the paused terminal back as it is, a workflow parks the run, a subagent reports `suspended.awaiting_approval`).
284
+ - **Now.** One mint, `mapNestedSuspend(result, resume)` (`src/agents/suspend-guard.ts`), takes the entry from its caller, and the sentence is one template: "…once the pause is decided, continue it with `resumeCascade` | `resumeWithVerification`, handing it this pause's token (`nestedPause.token`) and the decision…". A cascade also says where the parked leg comes from: the card's `CheckpointState.compositionLeg` when the task spec named a session; when it named none and the caller handed the run no leg through `internals`, the card records none (a known limit), and the sentence says the caller supplies the leg itself — `{ entry: "cascade", leg: <the result's finalRung>, hostSessionId: <a session of its own> }` is what `resumeCascade` takes. The mint's header is the one place that says which orchestrators map and how the pause continues; the other places point at it. `CascadeRunResult.cascadeOutcome`'s doc lists the four ways `"exhausted"` happens.
285
+ - **Unchanged.** The code, the `nestedPause` seat and its token, `cascadeOutcome: "exhausted"`, `finalRung`, `attempts[].errorCode`, the held session. Nothing is added to or removed from the exported surface (`mapNestedSuspend` is internal).
286
+ - **Behavior change — B-1.** `failed.message` on both codes is a different sentence. A consumer that matched the old words breaks; one that branches on `code` / `nestedPause` does not.
287
+ - **Who needs it / who is affected / compensation.** *Needs it:* a host or an operator that read the old sentence and concluded a nested pause could only be resumed from a top-level run. *Affected:* only a consumer that matched the sentence. *Compensation:* none needed — branch on `code` and `nestedPause`.
288
+ - **Consumers.** @test: the cascade-park black-box cell that matched "only supported at the top-level runTask" (core761a G4.d) now reads `resumeCascade`, and `resumeWithVerification` for a gate. @cli @client-core: a front end that renders `failed.message` of these two codes shows the new sentence; nothing to change.
289
+ - **Pins.** `test/backlog3276-nested-suspend-sentence.test.ts` — P1 a cascade with a host session (the sentence; code, `nestedPause` and `cascadeOutcome` as before; `resumeCascade` continues the rung) · P2 a cascade without one (the "supply it yourself" clause; resuming that way works) · P2c a resumed rung that parks again (the supplied leg is now the card's first record, so the sentence points at the card) · P2b a cascade without a session but handed a leg through `internals` (the card records that leg, so the sentence points at the card; supplying another host is refused) · P3–P5 the gate's three stops (implementation leg, resumed leg, fix round; each continued through `resumeWithVerification`) · P6 one template · P7 the leg clause comes from the argument alone · P8 what the mapping keeps · P9–P11 the five places point at the mint and carry no retired phrase, the header names who does not map, exactly the cascade and the gate call the mint; `test/suspend-guard.test.ts` re-pinned on the new sentence.
290
+
291
+ ### The closed set of approval card words gains `computer-access` and `computer-control`, the two consent cards of a tool that hands the model the user's screen; what either grants is per connection (#3282; additive wire; hard-breaking: type-level — `ToolApprovalCard` gains two members, so a consumer's `Record<ToolApprovalCard, …>` or exhaustive `switch` needs two keys, three sentences below; closed sets: +2 `TOOL_APPROVAL_CARDS` (10 → 12), +2 rows of `APPROVAL_CARD_REQUIRED_KEYS`; exports: none) (@client-core @computer-use @cli @server @test)
292
+
293
+ - **Before.** `TOOL_APPROVAL_CARDS` held ten words. A tool that asks the person to let the model use their screen had no word of its own: it asked under `generic`, so a shell had no way to pre-select its two consent dialogs, and a declaration of any other word was refused at the door with `config.tool_face_invalid`.
294
+ - **Now.** `computer-access` (the consent to use a named set of applications; the call carries `apps`, the list asked for) and `computer-control` (the consent to take the screen over; the call carries no member the card needs) are members of the set, with their rows in the required-keys table (`["apps"]` / `[]`). Neither is reserved: a caller tool or an MCP server's `toolFaces` overlay may declare either, on a schema that carries what the card needs (`computer-access` on a schema without `apps` is refused by the same judge as any other card). The word reaches the ask, the parked gate and the pending row through the one stamp, as every other word does, and it decides nothing: a parked row with either word reads the gate kind's deadline facet, never a question's. No existing word, row or answer moves, and nothing mints either word until a tool declares it.
295
+ - **Closed set +2, three sentences (open to veto).** *What changed:* `TOOL_APPROVAL_CARDS` gains `computer-access` and `computer-control` (10 → 12), and `APPROVAL_CARD_REQUIRED_KEYS` gains `["apps"]` and `[]`; both names follow the object-action kebab form of the ten (`file-edit`, `notebook-edit`). *Who is affected:* @client-core @cli @server @test — a reader that enumerates the card words, or that validates an ask, roster or checkpoint frame against the ten-word list, reads two more; a consumer's own `Record<ToolApprovalCard, …>` or exhaustive `switch` needs the two keys. An engine older than this version refuses a declaration of either word at the door (`config.tool_face_invalid`, the prepare fails), so a deployment declares them to an engine at this version or later. *Compensation:* none needed beyond the rows. `TOOL_APPROVAL_CARDS` is not registered in `docs/CLOSED-SETS.md` today — an existing bookkeeping gap this change does not widen.
296
+ - **Lifetime: per connection.** The card word adds no expiry of its own, and the engine's part is the connection's lifetime. What a person grants on either card is meant to last as long as the MCP connection the call was made on; that the grant follows the connection is the screen tool's (computer-use's) behavior, which this engine neither holds nor checks. The legs of one run tree share a connection and it closes when the last holder lets go (`release` and `close` of `src/core/mcp-connection-pool.ts`; a leg's materialization `dispose` releases its lease and closes the pool it owns, `src/core/mcp.ts:2501-2509`): ordinarily the end of the run that dialled it, but a background sub-agent still using it holds it, and the grant on it, open past that end (`test/backlog1433b-pool-background.test.ts`). A later run dials its own connection and asks again, a new card. `docs/sdk/04-tools-and-mcp.md`, "Approval card words", states it once. Not "valid for the session".
297
+ - **Claude Code 2.1.309.** No card-word layer to copy (a card is a shell component there); the required members agree with its tools: `request_access` takes `apps: string[]` (`cli309.js:279294`) and `request_full_control` takes no member (`:279298`). Its description of `request_full_control` says "for THIS SESSION" (`:279298`); this engine's consent is the connection's, which ends with its last holder, ordinarily the run (the pool's lifetime, `src/core/mcp-connection-pool.ts`): a divergence in the lifetime sentence only, open to veto.
298
+ - **Who needs it / who is affected / compensation.** *Needs it:* the client that renders the screen tool's two dialogs by word instead of by tool name or server name. *Affected:* only a deployment that declares either word; nothing else reads a different answer. *Compensation:* none.
299
+ - **Consumers.** @client-core: regenerate the card-word table from ten words to twelve (read the word from the ask, never from a tool name). @computer-use: declare `renderHints.approvalCard` as `computer-access` on `request_access` and `computer-control` on `request_full_control` (the final names), to an engine at this version or later. @cli @server: the closed set is `TOOL_APPROVAL_CARDS`; a mixed-version fleet declares the words only to engines that carry them. @test: the G-CU skeleton can pin both words and the per-connection lifetime (a grant ends with the connection's last holder, not with the run when a background sub-agent still holds it).
300
+ - **Pins.** `test/backlog3282-computer-card-words.test.ts` (the set holds both words and the screen admits exactly them, other spellings and non-strings are no card; the required-keys rows and the key set equal to the closed set; neither word reserved; the overlay door over `apps` present, absent and empty, the schema-free reader, a reserved word and an unknown word; a real Runner over a real stdio MCP server — each tool asks under its card, an undeclared one under `generic`, an unknown word fails the prepare with `config.tool_face_invalid`; a real Runner over a caller tool; a parked `human` / `irreversible_ask` row with either word reads the gate kind's facet and is no question; the connection a pool lends is closed by its last holder's release and a pool's `close` leaves a held one open; the doc block states the lifetime once, by connection and last holder, with no session word).
301
+
302
+ ### A resume's server lists are the deployment's current ones: the contract says so, and a parked call whose server was removed is refused, never dialed (#3242, ruled C-R1068 option A, open to veto; contract sentence; behavior change: none; hard-breaking: none; closed sets: none; exports: none; wire: none)
303
+
304
+ - **Before.** `ResumeTaskConfig`'s contract told the caller to re-supply "the same `TaskSpec` it ran with", and the admission note called the config's MCP / A2A entries "the frozen ones the doors judged". Both read as "replay the parked run's server lists". A host that did so — rebuilding the resume config from its record of the parked run — re-dialed a server its user had since removed (`sema mcp remove`) and ran the parked call on it.
305
+ - **Now.** The sentence says what the engine does. The checkpoint records no tool implementation, hand band or server list. The caller supplies the deployment's CURRENT `tools`, `mcp`, `a2a` and `skills` specs (the row keeps the names of the skills in force and their frozen grants and scopes — `state.skillGrants`, `state.skillScopes`). The resumed leg dials the `mcp` / `a2a` entries the resume hands, as the config doors judge them (a deployment-locked list in their place); an absent list declares none. The parked call is judged against what the resume mounts: a server the resume no longer declares ⇒ `resume.tool_unavailable` (that server never dialed, the call not run, the checkpoint reopened `pending`; a deny still resolves it); a replacement wearing the tool's name ⇒ `resume.tool_contract_mismatch`; a moved face or declaration ⇒ `resume.target_moved`, as before. Identity is kept: a contradicting `principal` is refused (`resume.principal_mismatch`), an absent one inherits the row's. The admission note (`ResumeAdmissionResult.config`) now says its MCP / A2A lists are "the doors' judged copies of THIS resume's (the row records none)". `docs/INTEGRATION-CORE.md` §4.1 says the same.
306
+ - **Who needs it / who is affected / compensation.** *Needs it:* a user who removes an MCP server or A2A peer while a call to it is parked. *Affected:* nobody in the engine (no code path changed). A host that replays the parked run's lists keeps re-dialing removed servers until it sends the current ones. *Compensation:* none needed; the refusal word is the existing one.
307
+ - **Known limit.** The same server name redefined to another command or URL, serving a tool with the same contract and face, runs the parked call on the new definition: the configuration in force decides, keyed by name, as in the reference.
308
+ - **Consumers.** @server (S-2883): the resume route sends the request's current `mcpServers` into `ResumeTaskConfig.mcp` (and its A2A peers into `a2a`), not the parked leg's lists. The refusal is the existing `resume.tool_unavailable`; no new code joins the closed set. @cli (L-2232): a resume request carries the current server lists. @test: black box — park an MCP call, remove the server, resume with the current lists ⇒ `resume.tool_unavailable`, the server never started again, the call not run, the row `pending`; a deny resolves it.
309
+ - **Pins.** `test/backlog3242-resume-mcp-current-config.test.ts` (real Runner, real stdio MCP servers and a real HTTP A2A peer, every start and call counted outside the engine). R1: server removed from the resume's `mcp` ⇒ never started on the resume, call not run, row `pending`, `resume.tool_unavailable`. R2: no `mcp` handed ⇒ no server started. R3: same server still declared ⇒ runs once (control). R4: A2A peer removed ⇒ its card never fetched on the resume, nothing sent. R5: A2A control. R6: a parked caller tool, `mcp` emptied ⇒ unaffected. R7: same name redefined ⇒ runs on the handed definition. R8: deny ⇒ resolves, server never started. Mutations (`.gate-logs/criteria-3242-mutations.md`): the resume dials the parked leg's MCP list instead of its own ⇒ R1 / R2 / R6 / R7 / R8 red; the same for A2A ⇒ R4 red; the session station takes an unmounted tool as a match ⇒ R1 / R2 / R4 red.
310
+
311
+ no-notes: #3079(named only by a merge header inside the car-1726-colon-form branch: the ticket shipped in 7.61.0 and nothing for it changes here), #3215(named only by a merge header inside the car-1726-colon-form branch: the ticket shipped in 7.61.0 and nothing for it changes here), #9(not a ticket: a number quoted in a merge-commit subject), #956(named by a #3275 commit only: the two start spellings of the shell-read start module reach the one path prelude through the existing anchor step `anchorSpelling` instead of joining a path themselves; no behavior beyond #3275, the prelude pin unchanged), #1498(named by a #3275 commit only: the launcher-base-move pins re-pinned to the #3275 reading, a text an `env -C /` launch hands a shell is judged at `/`; told in the #3275 section; one test file)
312
+
1
313
  ## 7.61.0 — 2026-10-30
2
314
 
3
315
  ### A placed row whose owner cell is damaged still says it is placed — `FileSessionRepo.placementOf` reads the placement cell by its own reader (#3215; behavior change)