@sema-agent/core 7.59.0 → 7.60.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.
- package/CHANGELOG.md +564 -0
- package/dist/agents/agent-definition.d.ts +7 -0
- package/dist/agents/agent-definition.js +12 -0
- package/dist/agents/agent-transcript-tool.d.ts +2 -1
- package/dist/agents/agent-transcript-tool.js +3 -1
- package/dist/agents/child-model-seat.js +6 -3
- package/dist/agents/cumulative-stats.js +0 -1
- package/dist/agents/inherited-tool-pool.d.ts +26 -1
- package/dist/agents/inherited-tool-pool.js +22 -0
- package/dist/agents/retain-ledger.d.ts +11 -1
- package/dist/agents/retain-ledger.js +13 -2
- package/dist/agents/roster-store.d.ts +1 -1
- package/dist/agents/roster-store.js +3 -1
- package/dist/agents/send-message-tool.d.ts +8 -19
- package/dist/agents/send-message-tool.js +11 -38
- package/dist/agents/subagent.d.ts +51 -17
- package/dist/agents/subagent.js +117 -78
- package/dist/agents/tool-filter.d.ts +1 -3
- package/dist/agents/tool-filter.js +4 -12
- package/dist/bench/metrics.d.ts +3 -5
- package/dist/bench/metrics.js +0 -1
- package/dist/brain/degrading.js +3 -1
- package/dist/brain/route-adjudicator.js +3 -1
- package/dist/brain/status-sink.d.ts +7 -1
- package/dist/brain/status-sink.js +6 -0
- package/dist/brain/timeout.d.ts +3 -1
- package/dist/brain/timeout.js +18 -5
- package/dist/core/a2a.d.ts +15 -5
- package/dist/core/a2a.js +34 -19
- package/dist/core/agent-definition.d.ts +20 -0
- package/dist/core/allow-entry.d.ts +2 -0
- package/dist/core/allow-entry.js +3 -1
- package/dist/core/artifact-host.d.ts +0 -2
- package/dist/core/artifact-host.js +0 -1
- package/dist/core/auto-mode-defaults.d.ts +8 -0
- package/dist/core/auto-mode-defaults.js +1 -0
- package/dist/core/auto-mode-rebuild.d.ts +2 -1
- package/dist/core/auto-mode.d.ts +39 -4
- package/dist/core/auto-mode.js +63 -12
- package/dist/core/background-agent-store.d.ts +10 -1
- package/dist/core/background-agent-store.js +3 -2
- package/dist/core/background-shell.d.ts +12 -1
- package/dist/core/background-shell.js +12 -0
- package/dist/core/checkpoint-store.d.ts +8 -13
- package/dist/core/checkpoint-store.js +4 -3
- package/dist/core/compliance.d.ts +1 -1
- package/dist/core/credential-echo.d.ts +52 -0
- package/dist/core/credential-echo.js +65 -0
- package/dist/core/credential-vocabulary.d.ts +13 -3
- package/dist/core/credential-vocabulary.js +12 -4
- package/dist/core/cross-boundary-taint.d.ts +4 -5
- package/dist/core/engine-notice.d.ts +58 -15
- package/dist/core/frame-settlement.d.ts +5 -0
- package/dist/core/frame-settlement.js +4 -0
- package/dist/core/gate-fold.js +7 -5
- package/dist/core/gate-lanes.js +39 -8
- package/dist/core/governance-codes.d.ts +9 -1
- package/dist/core/governance-codes.js +12 -0
- package/dist/core/hands-band-screen.js +0 -1
- package/dist/core/hands-band.d.ts +0 -3
- package/dist/core/hooks.d.ts +39 -56
- package/dist/core/hooks.js +123 -77
- package/dist/core/image-admission.d.ts +104 -51
- package/dist/core/image-admission.js +170 -46
- package/dist/core/image-downsample.d.ts +36 -69
- package/dist/core/image-downsample.js +111 -73
- package/dist/core/integer-option.d.ts +21 -0
- package/dist/core/integer-option.js +13 -0
- package/dist/core/locked-config.d.ts +54 -3
- package/dist/core/locked-config.js +81 -50
- package/dist/core/mcp-call-meta.d.ts +2 -2
- package/dist/core/mcp-call-meta.js +9 -10
- package/dist/core/mcp-failure.d.ts +9 -3
- package/dist/core/mcp-failure.js +10 -0
- package/dist/core/mcp-host-seat.d.ts +92 -0
- package/dist/core/mcp-host-seat.js +131 -0
- package/dist/core/mcp-probe.d.ts +7 -2
- package/dist/core/mcp-probe.js +7 -2
- package/dist/core/mcp-server-spec.d.ts +38 -9
- package/dist/core/mcp-server-spec.js +55 -21
- package/dist/core/mcp.d.ts +17 -6
- package/dist/core/mcp.js +67 -55
- package/dist/core/memory-admission.d.ts +23 -6
- package/dist/core/memory-admission.js +19 -9
- package/dist/core/memory-engine/content-origin.d.ts +13 -0
- package/dist/core/memory-engine/content-origin.js +21 -3
- package/dist/core/memory-engine/index.d.ts +2 -1
- package/dist/core/memory-engine/index.js +2 -1
- package/dist/core/memory-engine/scope-contract.d.ts +13 -3
- package/dist/core/memory-engine/scope-contract.js +2 -2
- package/dist/core/memory-engine/sync-client.d.ts +45 -11
- package/dist/core/memory-engine/sync-client.js +82 -11
- package/dist/core/memory-engine/sync-report.d.ts +103 -0
- package/dist/core/memory-engine/sync-report.js +119 -0
- package/dist/core/memory-engine/sync.d.ts +4 -2
- package/dist/core/mode-policy.d.ts +9 -1
- package/dist/core/mode-policy.js +11 -1
- package/dist/core/model-receipt.d.ts +39 -0
- package/dist/core/model-receipt.js +139 -0
- package/dist/core/mods/agent-stations.d.ts +65 -0
- package/dist/core/mods/agent-stations.js +105 -0
- package/dist/core/mods/kernel/dispatch.d.ts +5 -1
- package/dist/core/mods/kernel/dispatch.js +4 -4
- package/dist/core/mods/kernel/events.d.ts +10 -4
- package/dist/core/mods/kernel/events.js +10 -6
- package/dist/core/mods/kernel/receive.d.ts +5 -0
- package/dist/core/mods/kernel/receive.js +10 -0
- package/dist/core/mods/lifecycle-stations.d.ts +41 -0
- package/dist/core/mods/lifecycle-stations.js +35 -0
- package/dist/core/mods/stations.d.ts +51 -59
- package/dist/core/mods/stations.js +32 -42
- package/dist/core/mods/tool-call.d.ts +10 -4
- package/dist/core/mods/tool-call.js +28 -12
- package/dist/core/mounted-mcp.d.ts +5 -0
- package/dist/core/mounted-mcp.js +2 -2
- package/dist/core/namespaced-rule-name.d.ts +7 -1
- package/dist/core/namespaced-rule-name.js +13 -2
- package/dist/core/oracle-isolation.js +1 -1
- package/dist/core/own-property-receipt.d.ts +3 -0
- package/dist/core/own-property-receipt.js +3 -0
- package/dist/core/park-selfcheck.js +8 -8
- package/dist/core/peer-seat.d.ts +63 -8
- package/dist/core/peer-seat.js +179 -34
- package/dist/core/permission-rule-consent.d.ts +0 -21
- package/dist/core/permission-rule-consent.js +1 -2
- package/dist/core/permission-rule-model.d.ts +4 -2
- package/dist/core/permission-rule-model.js +7 -6
- package/dist/core/protocol-http-auth.d.ts +14 -2
- package/dist/core/protocol-http-auth.js +16 -7
- package/dist/core/read-face-seats.d.ts +7 -5
- package/dist/core/read-face-seats.js +4 -1
- package/dist/core/redaction-marks.d.ts +4 -3
- package/dist/core/redaction-marks.js +2 -2
- package/dist/core/remote-env.d.ts +146 -98
- package/dist/core/remote-env.js +113 -14
- package/dist/core/retention.js +37 -12
- package/dist/core/retired-keys.d.ts +6 -1
- package/dist/core/retired-keys.js +4 -1
- package/dist/core/rewrite-rejudge.d.ts +12 -5
- package/dist/core/rewrite-rejudge.js +9 -5
- package/dist/core/roles.d.ts +37 -3
- package/dist/core/roles.js +126 -78
- package/dist/core/rule-owner.d.ts +3 -0
- package/dist/core/runner/assemble-result.d.ts +0 -5
- package/dist/core/runner/assemble-result.js +0 -1
- package/dist/core/runner/call-hook-stations.d.ts +17 -10
- package/dist/core/runner/call-hook-stations.js +21 -10
- package/dist/core/runner/child-tree.d.ts +7 -8
- package/dist/core/runner/child-tree.js +6 -6
- package/dist/core/runner/classifier-ladder.d.ts +10 -2
- package/dist/core/runner/classifier-ladder.js +39 -8
- package/dist/core/runner/construction-doors.js +5 -0
- package/dist/core/runner/contracts.d.ts +62 -41
- package/dist/core/runner/cross-boundary-lane.d.ts +3 -5
- package/dist/core/runner/cross-boundary-lane.js +11 -2
- package/dist/core/runner/env-capability-census.d.ts +15 -20
- package/dist/core/runner/env-capability-census.js +25 -34
- package/dist/core/runner/file-history-request.d.ts +2 -2
- package/dist/core/runner/file-history-request.js +0 -8
- package/dist/core/runner/gate-exit.d.ts +75 -7
- package/dist/core/runner/gate-exit.js +20 -1
- package/dist/core/runner/git-status-frame.d.ts +5 -2
- package/dist/core/runner/git-status-frame.js +3 -4
- package/dist/core/runner/image.d.ts +7 -2
- package/dist/core/runner/image.js +14 -8
- package/dist/core/runner/inline-image.d.ts +10 -8
- package/dist/core/runner/inline-image.js +11 -9
- package/dist/core/runner/memory-consolidation-driver.js +4 -4
- package/dist/core/runner/permission-rule-lanes.js +1 -1
- package/dist/core/runner/prepare-boundary-parks.d.ts +2 -2
- package/dist/core/runner/prepare-boundary-parks.js +3 -3
- package/dist/core/runner/prepare-caps-and-workflow.d.ts +4 -0
- package/dist/core/runner/prepare-caps-and-workflow.js +4 -3
- package/dist/core/runner/prepare-config-doors.d.ts +6 -1
- package/dist/core/runner/prepare-config-doors.js +14 -9
- package/dist/core/runner/prepare-delegation-surface.d.ts +5 -3
- package/dist/core/runner/prepare-delegation-surface.js +4 -4
- package/dist/core/runner/prepare-file-history.d.ts +10 -12
- package/dist/core/runner/prepare-file-history.js +3 -12
- package/dist/core/runner/prepare-gate-stations.d.ts +4 -3
- package/dist/core/runner/prepare-gate-stations.js +4 -3
- package/dist/core/runner/prepare-hands-readface.d.ts +3 -1
- package/dist/core/runner/prepare-hands-readface.js +15 -7
- package/dist/core/runner/prepare-inherited-gate.d.ts +5 -4
- package/dist/core/runner/prepare-inherited-gate.js +9 -5
- package/dist/core/runner/prepare-memory-engine-session.js +1 -1
- package/dist/core/runner/prepare-memory.d.ts +2 -2
- package/dist/core/runner/prepare-memory.js +2 -2
- package/dist/core/runner/prepare-park-ask.d.ts +3 -5
- package/dist/core/runner/prepare-park-ask.js +3 -8
- package/dist/core/runner/prepare-policy-chain.d.ts +5 -4
- package/dist/core/runner/prepare-policy-chain.js +120 -108
- package/dist/core/runner/prepare-project-context.js +8 -5
- package/dist/core/runner/prepare-prompt-inputs.d.ts +4 -1
- package/dist/core/runner/prepare-prompt-inputs.js +3 -2
- package/dist/core/runner/prepare-protocol-tools.d.ts +5 -3
- package/dist/core/runner/prepare-protocol-tools.js +9 -2
- package/dist/core/runner/prepare-suspend-saga.d.ts +0 -2
- package/dist/core/runner/prepare-suspend-saga.js +5 -7
- package/dist/core/runner/prepare-task.js +41 -27
- package/dist/core/runner/prepare-turn-wiring.d.ts +2 -0
- package/dist/core/runner/prepare-turn-wiring.js +7 -2
- package/dist/core/runner/prepare-wiring-manifest.d.ts +4 -3
- package/dist/core/runner/prepare-wiring-manifest.js +32 -18
- package/dist/core/runner/prepare-workspace-restore.js +3 -3
- package/dist/core/runner/resume-checkpoint-screen.js +4 -4
- package/dist/core/runner/retired-runner-deps.js +4 -1
- package/dist/core/runner/run-attachment-seats.js +3 -3
- package/dist/core/runner/run-brain-sinks.js +1 -0
- package/dist/core/runner/run-git-lane.d.ts +3 -1
- package/dist/core/runner/run-git-lane.js +1 -1
- package/dist/core/runner/run-harness-handlers.d.ts +3 -1
- package/dist/core/runner/run-harness-handlers.js +3 -1
- package/dist/core/runner/run-identity-wiring.js +1 -1
- package/dist/core/runner/run-leg.js +26 -28
- package/dist/core/runner/run-notification-lane.d.ts +3 -1
- package/dist/core/runner/run-notification-lane.js +16 -10
- package/dist/core/runner/run-settle-and-teardown.js +5 -1
- package/dist/core/runner/run-stop-and-final-verify.d.ts +4 -0
- package/dist/core/runner/run-stop-and-final-verify.js +12 -4
- package/dist/core/runner/run-turn-boundary.js +12 -7
- package/dist/core/runner/runtask.d.ts +7 -4
- package/dist/core/runner/runtask.js +19 -11
- package/dist/core/runner/skills-seat.js +2 -2
- package/dist/core/runner/sub-agent-deny-lists.js +10 -7
- package/dist/core/runner/synthetic-tools.js +2 -2
- package/dist/core/runner/tool-disclosure.js +0 -2
- package/dist/core/runner/tool-face-overlay.d.ts +1 -1
- package/dist/core/runner/tool-face-overlay.js +26 -19
- package/dist/core/runner/tool-result-media-seat.d.ts +9 -1
- package/dist/core/runner/tool-result-media-seat.js +17 -1
- package/dist/core/runner/turn-attachments.d.ts +3 -5
- package/dist/core/runner/turn-attachments.js +3 -16
- package/dist/core/runner-deps.d.ts +31 -18
- package/dist/core/secret-env.d.ts +3 -2
- package/dist/core/session-policy-store.d.ts +9 -2
- package/dist/core/session-policy-store.js +16 -1
- package/dist/core/session-store.d.ts +3 -2
- package/dist/core/session-store.js +50 -11
- package/dist/core/skill-grant.d.ts +9 -0
- package/dist/core/skill-grant.js +18 -0
- package/dist/core/store-contracts/tool-result-store-contract.d.ts +1 -1
- package/dist/core/store-contracts/tool-result-store-contract.js +37 -0
- package/dist/core/stub-env.d.ts +5 -5
- package/dist/core/stub-env.js +11 -1
- package/dist/core/swappable-deps.d.ts +17 -43
- package/dist/core/swappable-deps.js +15 -5
- package/dist/core/synthetic-read-verdict.d.ts +1 -1
- package/dist/core/task-event.d.ts +18 -2
- package/dist/core/task-notification.d.ts +88 -5
- package/dist/core/task-notification.js +130 -7
- package/dist/core/task-registry-agent.d.ts +18 -12
- package/dist/core/task-registry-agent.js +18 -6
- package/dist/core/task-registry-monitor.d.ts +7 -0
- package/dist/core/task-registry-monitor.js +28 -1
- package/dist/core/task-registry-shared.d.ts +38 -3
- package/dist/core/task-registry-shared.js +21 -7
- package/dist/core/task-registry-workflow.js +1 -1
- package/dist/core/task-registry.d.ts +50 -35
- package/dist/core/task-registry.js +64 -23
- package/dist/core/task-result.d.ts +3 -12
- package/dist/core/task-spec.d.ts +3 -6
- package/dist/core/task-stream.d.ts +1 -1
- package/dist/core/tool-catalog-entries.js +1 -1
- package/dist/core/tool-face-reader.d.ts +7 -6
- package/dist/core/tool-face-reader.js +4 -3
- package/dist/core/tool-name-aliases.d.ts +19 -0
- package/dist/core/tool-name-aliases.js +54 -2
- package/dist/core/tool-policy.d.ts +5 -4
- package/dist/core/tool-policy.js +1 -1
- package/dist/core/tool-registry.d.ts +5 -5
- package/dist/core/tool-registry.js +2 -2
- package/dist/core/tool-result-store.d.ts +88 -5
- package/dist/core/tool-result-store.js +51 -12
- package/dist/core/tool-spec.d.ts +20 -4
- package/dist/core/trace.d.ts +0 -1
- package/dist/core/types.d.ts +3 -3
- package/dist/core/types.js +1 -1
- package/dist/core/untrusted-text.js +1 -1
- package/dist/core/user-attachment.d.ts +10 -5
- package/dist/core/user-attachment.js +14 -6
- package/dist/engine/execution-env/node-execution-env.d.ts +7 -2
- package/dist/engine/execution-env/node-execution-env.js +12 -1
- package/dist/engine/harness/agent-harness.d.ts +1 -1
- package/dist/engine/harness/agent-harness.js +8 -4
- package/dist/engine/harness/types.d.ts +112 -29
- package/dist/engine/loop/agent-loop.d.ts +12 -12
- package/dist/engine/loop/agent-loop.js +153 -21
- package/dist/engine/loop/types.d.ts +9 -2
- package/dist/engine/lsp/node-lsp-manager.d.ts +3 -3
- package/dist/engine/lsp/node-lsp-manager.js +32 -13
- package/dist/index.d.ts +22 -14
- package/dist/index.js +15 -10
- package/dist/internal/harness-types.d.ts +1 -1
- package/dist/orchestration/run-workflow-tool.d.ts +9 -3
- package/dist/orchestration/run-workflow-tool.js +59 -29
- package/dist/orchestration/workflow-governance.d.ts +1 -1
- package/dist/orchestration/workflow-governance.js +2 -1
- package/dist/orchestration/workflow.d.ts +4 -0
- package/dist/orchestration/workflow.js +25 -4
- package/dist/prompts/default.d.ts +1 -10
- package/dist/prompts/default.js +0 -2
- package/dist/stores/file/background-agent-store.d.ts +1 -1
- package/dist/stores/file/background-agent-store.js +3 -1
- package/dist/stores/file/checkpoint-store.d.ts +127 -2
- package/dist/stores/file/checkpoint-store.js +19 -14
- package/dist/stores/file/file-history-store.d.ts +1 -1
- package/dist/stores/file/file-history-store.js +3 -1
- package/dist/stores/file/index.d.ts +4 -3
- package/dist/stores/file/index.js +17 -8
- package/dist/stores/file/mailbox-store.d.ts +1 -1
- package/dist/stores/file/mailbox-store.js +3 -1
- package/dist/stores/file/memory-store.d.ts +1 -1
- package/dist/stores/file/memory-store.js +3 -1
- package/dist/stores/file/session-policy-store.d.ts +1 -1
- package/dist/stores/file/session-policy-store.js +3 -1
- package/dist/stores/file/session-store.d.ts +1 -1
- package/dist/stores/file/session-store.js +3 -1
- package/dist/stores/file/shared-ledger.d.ts +26 -0
- package/dist/stores/file/shared-ledger.js +38 -9
- package/dist/stores/file/tool-result-store.d.ts +20 -2
- package/dist/stores/file/tool-result-store.js +74 -6
- package/dist/stores/file/usage-window-store.d.ts +1 -1
- package/dist/stores/file/usage-window-store.js +3 -1
- package/dist/stores/file/workflow-journal-store.d.ts +1 -11
- package/dist/stores/file/workflow-journal-store.js +3 -2
- package/dist/tools/fs/containment-face.d.ts +5 -0
- package/dist/tools/fs/encoding.d.ts +13 -4
- package/dist/tools/fs/encoding.js +17 -2
- package/dist/tools/fs/fs-bash-background-text.d.ts +7 -0
- package/dist/tools/fs/fs-bash-background-text.js +1 -0
- package/dist/tools/fs/fs-bash.d.ts +8 -4
- package/dist/tools/fs/fs-bash.js +26 -35
- package/dist/tools/fs/fs-pdf.d.ts +2 -2
- package/dist/tools/fs/fs-pdf.js +26 -21
- package/dist/tools/fs/fs-read.d.ts +5 -4
- package/dist/tools/fs/fs-read.js +35 -18
- package/dist/tools/fs/fs-search-tools.js +4 -1
- package/dist/tools/fs/fs-shared.d.ts +11 -13
- package/dist/tools/fs/fs-shared.js +11 -7
- package/dist/tools/fs/fs-write.js +5 -5
- package/dist/tools/fs/index.d.ts +14 -8
- package/dist/tools/fs/index.js +8 -4
- package/dist/tools/fs/read-floor.d.ts +44 -1
- package/dist/tools/fs/read-floor.js +35 -0
- package/dist/tools/fs/removal-targets.d.ts +9 -4
- package/dist/tools/fs/removal-targets.js +17 -9
- package/dist/tools/fs/search.d.ts +3 -3
- package/dist/tools/fs/search.js +4 -4
- package/dist/tools/monitor.d.ts +5 -4
- package/dist/tools/monitor.js +15 -8
- package/dist/tools/scheduler-tools.js +42 -4
- package/dist/tools/web.d.ts +0 -10
- package/dist/tools/web.js +1 -4
- package/package.json +4 -2
- package/test/export-surface.snapshot.json +75 -21
- package/wire-changes/core-stores-sql@7.60.0.json +30 -0
- package/wire-changes/core@7.60.0.json +3274 -0
- package/wire-changes/mods-kernel@7.60.0.json +62 -0
- package/wire-changes/primitives@7.60.0.json +30 -0
package/CHANGELOG.md
CHANGED
|
@@ -1,3 +1,567 @@
|
|
|
1
|
+
## 7.60.0 — 2026-10-28
|
|
2
|
+
|
|
3
|
+
### One image admission, one processor, one table: every image a run hands the model is compressed toward 512,000 bytes, and the bytes that ship must state a size within 2000 px (#2987, C-R974 S1 — Q3, Q5's hard rows, Q6, addenda 1 / 2 / 3; behavior change; behavior narrowing open to veto; divergence candidates D-2987-a and D-2987-b, open to veto; hard-breaking: ③ the processor seats and ④ the constant exports, three sentences each below; closed sets: `MediaRefusalReason` +2 `dimensions_unreadable` / `dimensions_too_large`, `EngineNoticeCode` +1 `config.image_processor_unavailable` (operator, engine); exports: −4 root `MCP_IMAGE_MAX_BASE64`, `IMAGE_TARGET_RAW_SIZE`, `sharpImageResizer`, type `McpImageResizer`, +1 root `IMAGE_ADMISSION`) (@server @client-core @cli @test)
|
|
4
|
+
|
|
5
|
+
- **Before.** The limits lived in five places (the single-image base64 limit, the 3.75 MB / 2000-px frame, the 5 / 64 MiB read caps, the 20 MiB URL body, the request budget). Two processor seats — `RunnerDeps.mcpImageResizer` (MCP) and `RunnerDeps.hands.readImageDownsampler` (Read, PDF pages) — each with its own sharp detection. The processor stopped at the frame ladder, so a 1206 × 2622 phone screenshot of 2.9 MB reached the model as a 920 × 2000 PNG of about 2 MB. PDF pages called the processor directly behind their own 5 MiB gate; MCP resized only above 5 MiB of base64 and spilled to disk otherwise; a Bash data URI over 5 MiB of base64 fell to the text path; the tool-result seat, `TaskSpec.images` and attachments admitted with no processor; a URL image was not admitted at all. Bytes with no processor went out on their base64 length alone, whatever their pixel size.
|
|
6
|
+
- **Now.** One table, `IMAGE_ADMISSION` (root export, frozen): `hard` = `formats` (the four header rows), `readBytes` (`withoutProcessor` 5 MiB, `withProcessor` 64 MiB), `urlBytes` 20 MiB, `rejectEdge` 2000, `imageBase64Chars` 5 MiB; `soft` = `frameEdge` 2000, `rawBytes` 3,932,160, `targetBytes` 512,000. `admitImageBytes(bytes, mime, processor)` takes the processor as a required `ImageDownsampler | "none"`: the hard checks, then the processor — the frame ladder, then the byte-target step (Claude Code 2.1.309's form: a non-JPEG tries JPEG quality 90 first, then at most five binary probes over [1, 89] — [1, 90] for a JPEG — keep the best quality at or under the target, else the smallest bytes seen; a failure of the step keeps the ladder's bytes) — then the base64 limit. What ships is the processor's bytes when they are one of the four formats, their type read off them (Claude Code's form; a processor's declared type is not taken), else the bytes as they came; whatever produced them, the bytes that ship must state their pixel size in their own header within `rejectEdge`, else `dimensions_unreadable` / `dimensions_too_large` (one sentence, `unprocessedSizeClause`, for every carrier) — a processor that hands the bytes back unchanged does not carry a frame past the edge. A processor runs once over bytes: what it shipped is remembered by digest (per processor, its latest 256), and those bytes admitted again — by the tool-result seat after a carrier, through the tool door's rebuilt block — take every hard check and no second encode, so a best-effort image (no quality reaches the target) is not re-encoded at each admission. Every carrier admits with the run's processor: Read, and a notebook's image outputs in the reader the Read tool and an attachment share (a refused one is a marker naming the refusal); PDF pages (their own gate retired); a Bash data URI (any size up to the read cap is admitted and compressed); MCP (its own resize retired — only bytes still over a hard limit after processing are spilled, any other refusal stays an image block for the seat's placeholder); the tool-result seat (every result's images); `TaskSpec.images` inline and by URL (the URL arm now passes the admission); attachments. An image inside the frame and at or under the target passes byte-identical, so the seat's second admission of what a carrier sent changes nothing. The seat is `RunnerDeps.imageProcessor?: ImageDownsampler | false` — a processor; `false` = none; absent = detect sharp once per process (`resolveImageProcessor`, one cache); any other value is refused at `new Runner` (`config.invalid_argument`). With no processor, the run's first image over the soft target — wherever it entered — emits `config.image_processor_unavailable` once (`detail: { bytes, targetBytes, sessionId, runId }`).
|
|
7
|
+
- **Hard-breaking ③ — the processor seats (open to veto).** *What changed*: `RunnerDeps.mcpImageResizer` and `RunnerDeps.hands.readImageDownsampler` are retired (refused at `new Runner` with `config.deps_retired_key`, naming the replacement); `sharpImageResizer` and `McpImageResizer` are removed; `materializeMcpTools`' fourth parameter is the seat's value (`ImageDownsampler | false`). *Who is hurt*: a deployment or test fixture that injected either seat — @test's `readImageDownsampler: false` fixture (repro core548); @server where it wires either. *Compensation*: set `RunnerDeps.imageProcessor` once — `false` keeps the no-sharp fixture's shape, an `ImageDownsampler` replaces either seat, `createImageDownsampler` / `sharpImageDownsampler` are unchanged.
|
|
8
|
+
- **Hard-breaking ④ — the constant exports (open to veto).** *What changed*: the root exports `MCP_IMAGE_MAX_BASE64` and `IMAGE_TARGET_RAW_SIZE` are removed. *Who is hurt*: @server — the entry check `src/http/admission.ts:9 / :178` no longer compiles; @client-core — `scripts/gen-upstream-tables.mjs:586 / :1045` (the tenth batch) reads a missing name. *Compensation*: read `IMAGE_ADMISSION.hard.imageBase64Chars` (the same 5,242,880 characters) and `IMAGE_ADMISSION.soft.rawBytes`; the other rows are named above; one pick-up car each.
|
|
9
|
+
- **Behavior narrowing, open to veto.** *Who needs it*: a deployment with no image processor — an image over 2000 px went out as it was, and the provider resized it or refused the request; the admission now refuses it at the source, naming its size and the limit (Claude Code 2.1.309's fallback arm refuses the same). *Who is hurt*: a deployment without sharp, or with `imageProcessor: false`, that sends images over 2000 px — Read, an attachment, a task image, a PDF page rendered over 2000 px; an MCP image of that size is spilled to disk with its path instead of inlined. A JPEG whose header states no frame size is refused when it would go on unprocessed. *Compensation*: install the optional `sharp`, or set a processor.
|
|
10
|
+
- **Behavior change.** An image the processor brings toward the target arrives as a JPEG (a PNG screenshot's mime changes).
|
|
11
|
+
- **Divergence candidate D-2987-a, open to veto (C-R974 addendum 2).** Every JPEG encode of the processor — the ladder's rungs and the byte-target step, one place — merges an alpha channel onto white first. Claude Code 2.1.309's `N$o` encodes with no merge, and sharp then drops the alpha onto black: a transparent PNG whose marks are dark (a line drawing, a logo, a diagram) became an all-black JPEG; the old ladder did this only above 3.75 MB, the byte-target step would have done it above 512,000 B. A frame with no alpha is unchanged.
|
|
12
|
+
- **Divergence candidate D-2987-b, open to veto (C-R974 addendum 3).** The processor auto-orients before re-encoding (Claude Code 2.1.309 does not): a frame whose header asks to be shown turned (EXIF orientation 2–8) is turned upright once, at the top of the processor, before its size is read or anything re-encodes it, so the frame, the dimensions and the coordinate caption are the upright ones and the tag is gone. Without it a re-encode drops the tag and a phone photo reaches the model sideways — the old ladder re-encoded only above 3.75 MB, the byte-target step re-encodes every photo above 512,000 B. A frame with orientation 1 or none is unchanged.
|
|
13
|
+
- **Not in this change (with #2988).** The request-budget rows (`mediaByteCapBytes` → `mediaBudgetBase64Chars`), the retirement of `onMediaStripped` and the rename `context.image_removed` → `context.media_removed`.
|
|
14
|
+
- **Consumers.** @server: the entry check reads `IMAGE_ADMISSION.hard.imageBase64Chars`; a deployment that wires a processor sets `RunnerDeps.imageProcessor`; `config.image_processor_unavailable` joins the operator notices. @client-core: the generated table reads `IMAGE_ADMISSION.hard.imageBase64Chars`. @cli: no code reads either name; L-2122 waits on #2988. @test: fixtures move to `imageProcessor: false`; the two refusal words and the notice code are new.
|
|
15
|
+
- **Pins.** `test/backlog2987-image-admission-one-processor.test.ts` (a deterministic encoder under the production pipeline: the 2.9 MB screenshot leaves Read, an attachment, an inline and a URL task image, MCP, a Bash data URI, a rendered PDF page and the tool-result seat at or under 700,000 base64 characters; over the old 5 MiB pass-through it is compressed by MCP and Bash, not spilled or dropped; a second admission is byte-identical, and a best-effort image passes MCP or Read then the seat with no second encode while other bytes in the same block are encoded; a pass-through processor does not carry a 3000 × 10 frame past the edge; a processor's mislabeled or non-image answer is not shipped; every JPEG encode merges alpha onto white; a notebook's image output is framed by the reader, refused as a marker with no processor, and rides byte-identical inside the frame and the target; no processor and a 2622-px edge ⇒ `dimensions_too_large` by every carrier, a failing or throwing processor alike; no frame header ⇒ `dimensions_unreadable`; `false` ⇒ none, the bytes ride unchanged and one notice per run across two tool results and a task image, a processor ⇒ none; the retired seats refused by name, a bad seat value refused; type pins). `test/image-downsample-real-sharp.test.ts` (real sharp: the byte-target step on a noisy frame and a screenshot-shaped PNG; a fixed point; a transparent PNG's dark marks survive the JPEG encode; an EXIF-orientation-6 camera JPEG comes out upright with no tag, orientation 1 untouched; a best-effort black-and-white frame passes the seat unchanged). Re-pinned: `test/read-image-pipeline.test.ts`, `test/mcp-content-mapping.test.ts`, `test/backlog1719-media-admission-one-seat.test.ts`, `test/backlog1829-engine-below-tools.test.ts`, `test/backlog2874-image-reject.test.ts` and `test/backlog1795-time-cut-consumers.test.ts` (their JPEG fixtures state a frame size), the toolkit-option fixtures (`imageProcessor: false`), `test/public-knob-liveness.test.ts`, `test/export-surface.snapshot.json` (−4 +1), `test/skip-baseline.json` (the real-sharp names), `test/backlog1279-child-undrained-to-parent.test.ts` (109 codes).
|
|
16
|
+
- **A tool result with no media awaits nothing.** The tool-result seat reads the executed call's content once (`toolResultMediaBlocks`) and resolves the run's processor only when a block claims media (`admitToolResultMediaBlocks`); a call whose result carries none no longer waits on the absent seat's one-time detection of sharp (a dynamic import — real I/O on the first tool call of a process, which a fake clock cannot advance). Behavior unchanged. Pins: `test/walltime-telemetry.test.ts` (件2a, both cells) and `test/backlog258-cycle-seq-outline.test.ts` ((1b) F3), red on the stage merge and green again. (#3078)
|
|
17
|
+
|
|
18
|
+
### A resumed approval runs exactly the bytes the person approved: the resumed leg's PreToolUse re-screen no longer hands back the bytes that run (#2975; approval integrity, aligned with Claude Code; behavior change open to veto; hard-breaking: none; closed sets: none; exports: none) (@server @test @cli)
|
|
19
|
+
|
|
20
|
+
- **Before.** On a durable resume the approved call's `classic.PreToolUse` re-screen supplied the bytes that ran. For an unedited approval the hook's rewrite ran in place of the bytes the person approved, so a rewriter that is not idempotent (one that appends a mark on every application) was applied twice: `tool_start.args` named one form and the tool ran another. A rewrite of the person's edit refused the call instead (since 7.56.0, #1022).
|
|
21
|
+
- **Now.** The re-screen has three outlets: a refusal (deny, crash, silence, an answer outside the contract, a person-only ask under a policy decide), an ask (the decide already answered it) and `additionalContext`. Its `updatedInput` is not adopted, for an edited approval and an unedited one alike. What runs is the decide's approved bytes — the edit, or the call as shown — and `tool_start.args` is those bytes, held as one engine-owned frozen value: a host that writes into the start frame's `args` while the re-screen waits no longer moves what runs. The tool itself gets a detached copy, as a live call does, so a preparation that edits its input in place still works. This is Claude Code 2.1.309's form for a permission answer that arrives after its turn: the call passes the PreToolUse hooks again, and the answer's own input is what runs. Nothing announces the dropped form.
|
|
22
|
+
- **Who needs it / who is affected / compensation (open to veto).** *Needs it:* approval integrity — the executed bytes are the approved bytes. *Affected:* a deployment whose PreToolUse handler enforces by rewriting instead of denying on the resumed leg. That covers a rewrite it would add only after the park (a handler installed or changed between park and resume) and a rewrite of a person's edit: neither reaches the call any more. The handler can still deny or ask there. A rewriter that is not idempotent is no longer applied twice. *Compensation:* the park leg's screening already folded its rewrite into the bytes the person approved, so an idempotent rewriter sees no change, and a resume-time guard keeps its deny. *Not taken:* refusing the call whenever the re-screen hands back other bytes. That would refuse every resume under a rewriter that is not idempotent, and a re-issue could never converge.
|
|
23
|
+
- **Consumers.** @server (mods hosts): a PreToolUse rewrite that must hold for a resumed approval belongs on the park leg, or becomes a deny. @test: K9b's construction now runs the call once on the approved bytes (sha256 of the executed args = of the row's = of `tool_start.args`). @cli: nothing new to render.
|
|
24
|
+
- **Pins.** `test/backlog2975-approved-bytes.test.ts` (a fresh Runner redeems a park: a non-idempotent and an idempotent rewriter both run the approved bytes once; a person's edit runs as written; deny / ask / context outlets beside a dropped rewrite; a write into `tool_start.args` during the re-screen does not land; an in-place preparation runs on a resumed call; controls with no handler and a watching one). Re-pinned to the new reading: `test/backlog1294-approved-call-hooks.test.ts` ③c ③d ⑨b ⑪, `test/backlog1022-rewrite-recheck.test.ts` R10 R12, `test/backlog1974b-keyless-and-unreadable-resume.test.ts` ⑥, `test/backlog1328-parked-skill-rescreen-swap.test.ts` ① ③ ④ ④b ⑥ ⑦ ⑧b ⑨ ⑨b (a re-screen's skill swap is dropped and the card's skill activates), `test/backlog1391-approval-object.test.ts` B6 SH-h K-sur K-sur-key (the approved destination / command / value runs).
|
|
25
|
+
|
|
26
|
+
### A memory sync round's peer is the identity its transport carries, and a cursor taken against another peer is refused before it can delete local entries (#2968, P1 data loss; C-R969 addendum 1 Q3 A; hard-breaking: `MemorySyncTransport` is `{ peer, post }` and `SyncMemoryScopeOptions.peer` with its `"central"` default is gone, three sentences below, open to veto; closed sets: none — the refusal reuses `config.memory_sync_cursor_mismatch`; exports: none added or removed, `MemorySyncTransport` changes kind type → interface) (@server @client-core)
|
|
27
|
+
|
|
28
|
+
- **Before.** `syncMemoryScope` took its peer from `opts.peer`, else the cursor's own `peer`, else the constant `"central"`, and the transport was a bare `(path, body)` function with no identity. A deployment that never sets `peer` (the server's sync runner) bound every cursor to `"central"`, whichever center its transport reached. Re-point the transport (a new `MEMORY_SYNC_URL`, another engine declaration) and keep the layer's cursor: the judge compared the cursor's peer with a value read from that same cursor and passed; the new center, not holding the baselined entries, read each as deleted centrally and unchanged on the device and answered it in `serverDeletes`; the client CAS-checked it against the same baseline and deleted the entry locally — every entry left unchanged on the device since the last round was gone. Reproduced against an in-process twin of the server's round (the same pure reconcile it imports): request `{ peer: "central", baseRevs: { X }, entries: [], deletes: [] }` → `serverDeletes: [X]` → local delete, empty local plane; the same center as control deletes nothing.
|
|
29
|
+
- **Now.** `MemorySyncTransport` = `{ readonly peer: string; post(path, body): Promise<unknown> }`. `peer` is the identity of the peer `post` reaches (for a central sync API, its base URL in the deployment's normalized form) and the round's only source of its peer: the request's `peer`, the returned cursor's `peer`, and the value a persisted cursor is judged against. A cursor for another peer — or one with no peer binding — is refused with `config.memory_sync_cursor_mismatch` (the judge and code that already covered scope and store) before any read or request, and the sentence names two ways out: (1) re-bind — run the layer over a transport that reaches the peer the cursor was taken against, or, only when this transport reaches that same peer under a new identity, set the cursor's peer to that identity; (2) drop the cursor to accept re-convergence from an empty baseline — entries changed on both sides are reported as conflicts, and entries deleted on one side since the last round come back from the other side. The round never re-binds or drops a cursor itself. A transport without a non-empty string `peer` — the previous function shape included — is refused before any read or request (`memory sync: transport.peer must be a non-empty string …`). The identities are compared raw and quoted through the same-principal egress pass, in the refusal and in the protocol error a response cursor answering for another peer raises: a URL credential reads `[redacted-credentials]`.
|
|
30
|
+
- **Hard-breaking, open to veto (@server).** *What changed*: `MemorySyncTransport` is an object with `peer` and `post` (it was a function); `SyncMemoryScopeOptions.peer` and the `"central"` default are gone, so a round's peer can no longer come from anywhere but its transport. *Who is hurt*: @server — `createMemorySyncTransport` (`src/memory-sync-client.ts`) returns the function shape and must return `{ peer, post }`; the `peer` option of `createMemorySyncRunner` and `DEFAULT_MEMORY_SYNC_PEER` lose their reader; both wiring sites (`src/boot/stores.ts` and `src/run-local.ts`, which never set a peer) build the transport; every cursor file persisted under `sync-cursors/central/…` holds `peer: "central"`, which the new identity will not equal; the central side's request `peer` (`parseMemorySyncRequest`, at most 190 characters) changes from `"central"` to the identity, so the `sync_cursors` rows it writes get a new partition value. *Compensation*: the compile error names every call site; the identity is the deployment's to mint (normalize the base URL once, keep credentials out of it — it rides the wire, the cursor and refusal sentences); an existing `"central"` cursor must still be handed to the round — looking it up only under the new identity's path and finding nothing runs an empty-baseline round nobody chose, the reconvergence C-R967 refuses to run unasked — where it is refused with the two ways out, so the operator re-binds it after confirming it was taken against the current center, or deletes it; nothing re-binds it automatically (that would stamp a cursor of unknown origin as this center's and run the deletion path above). The runner's own downgrade of a peer-mismatched cursor to a first round (`loadCursor` → `cursorOf`) goes for the same reason. If the C-R967 operator step ships in the same window, it can be one step.
|
|
31
|
+
- **Consumers.** @server as above. @client-core: no `syncMemoryScope` / `MemorySyncTransport` reference in its source (origin/main `45c9279`); the refusal it may relay through the server keeps its code. @cli: one test string names `syncMemoryScope` in prose; no call.
|
|
32
|
+
- **Known limit (stated).** The identity is what the deployment says it is. One center reachable under two identities (an alias host, a port change) reads as two peers and is refused — the safe side, answered by way out (1). A different center behind the same identity (a central store wiped and rebuilt at the same address) reads as the same peer, and the deletion path above stays open for that form until a center can state its own incarnation. The engine takes `peer` at its word (read once per round): a transport whose `peer` names one center while its `post` delivers to another passes the judge, and that other center's `serverDeletes` land — the judge cannot see where `post` sends. The backstop is the server's local-side door, which compares the engine the session goes to with the peer its sync leg reaches (`config.memory_sync_target_mismatch`, design/2897 §2); the engine adds no second reading of the identity (KL-2968-a).
|
|
33
|
+
- **Pins.** `test/backlog2968-sync-peer-binding.test.ts` (a real File store, an in-process twin of the server's round per center): same peer runs and carries the identity on the wire and in the cursor; another peer is refused with zero requests and zero backend calls, the entry stays, both ways out in the sentence; way out (2) pushes and deletes nothing; way out (1) back to the cursor's peer runs, and the same center under a new identity runs once the cursor's peer is rewritten; an upgrade cursor holding `"central"` against an empty new center is refused with zero requests; a cursor with no peer binding is refused, never run as an empty baseline; a transport with no identity (function shape, missing, empty, non-string) is refused before any read; an identity carrying a URL credential is never quoted — in a cursor it is another peer, on the transport it is refused before any request (#3020), in a response cursor it is a protocol error; a response cursor answering for another peer stays a protocol error with no local write. `test/memory-sync-client.test.ts`, `test/backlog2836-sync-cursor-store-binding.test.ts`, `test/backlog2818-typed-scope-sync-store.test.ts`, `test/backlog2956-memory-sync-store-root-export.test.ts` and `test/design336-origin-carriage.test.ts` build `{ peer, post }`; the liveness row for the retired option is gone (`test/public-knob-liveness.test.ts`); `test/export-surface.snapshot.json` records the kind change.
|
|
34
|
+
|
|
35
|
+
### A memory sync round is reported one way — `memorySyncReportOf` folds each layer's calls to one outcome, a refusal carries its axis and its two ways out from one table, and `memoryTravelGapOf` reads what did not travel from that report alone (#2969, design/2897 S1, C-R969 and its addenda 1 / 2; behavior change: the cursor and store refusal sentences are worded from one table — codes unchanged, the error gains `detail` and `outs`; hard-breaking: none; closed sets: the round report's own refusal codes, two — `config.memory_sync_target_mismatch` (new, worded by the engine) and `session_active` (the server's code and sentence); exports: +2 root values `memorySyncReportOf`, `memoryTravelGapOf`, +2 root types `MemorySyncLayerReport`, `MemorySyncRoundReport`) (@server @client-core @cli)
|
|
36
|
+
|
|
37
|
+
- **Before.** A host that ran a round read `syncMemoryScope`'s result by hand: `ok` (which is true on a clean round that `maxPushEntries` or the server's `pull.limit` cut — `ok` does not look at truncation), the two truncation flags, `conflicts`, and for a refusal the error's `code` and a sentence whose ways out lived only in its words (one function per axis, and a separate sentence for the store plane). Each consumer would have assembled its own reading of "did this layer arrive".
|
|
38
|
+
- **Now.** `memorySyncReportOf({ target, sourceRevision, scopes, layers | refused })` is the one reading. `layers` lists each `syncMemoryScope` call as it settled — `{ scope, result }` or `{ scope, thrown }`, a layer continued after a cut once per call, in order — and each layer folds to one outcome: `synced` (the last call `ok` and nothing withheld for a later call), `incomplete` (`why: "conflicts"` with the last call's conflicts, or `why: "truncated"` — a half cut under a limit, or an entry the server advanced in its cursor without delivering it, which the call keeps at its old baseline and discloses in `warnings`; `ok` looks at neither), `refused` (a refusal the engine minted: `code`, `detail`, `outs`, `message`), `failed` (anything else thrown — a transport or protocol error, a bad argument — as `error`). Every text in the report the engine did not mint — a conflict's `reason` from the server, an applied entry's `slug`, a warning, a thrown message — passes the same-principal egress pass; ids and revs are carried as they are; a name the report carries verbatim (`target`, `sourceRevision`, a scope key, the `reaches` of a target mismatch) that holds a credential is refused with a `TypeError` that does not quote it — the same test as the transport's `peer` (#3020). The last call decides the outcome; all four outcomes carry `applied` (`{ server, local }`, verbatim) — what every call of the layer returned as landed, in order — so a layer continued and then refused or failed still reports what its earlier calls landed (a refused call lands nothing; a call that throws returns no account of what it landed, #3047). A replay lands nothing and is still `synced`: whether a layer arrived is its outcome, never its counts. `refused` instead of `layers` is the round's own refusal, no layer run: `{ code: "config.memory_sync_target_mismatch", reaches }` (the machine's sync reaches another peer than the engine the session goes to — the engine words the sentence) or `{ code: "session_active", message }` (the host's code and sentence). `memoryTravelGapOf(report, readAtDestination?)` lists every scope of the read set that did not arrive whole, once, with why — `refused`, `failed`, `incomplete`, `not_replicated` (no layer run for it), `not_read_at_destination` (synced, and the destination's read set, when given, does not hold it); it reads the report alone, so a party that knows no scope key (the shell) can call it on the report it was handed, and the same report after a JSON round trip gives the same gap. The quarantine is a control-plane directory with no key: no sync round reads it and no read set holds it, so its bytes reach neither the wire nor the gap.
|
|
39
|
+
- **Refusal detail.** `config.memory_sync_cursor_mismatch` gains `detail: { axis: "scope" | "peer" | "store", found: "absent" | "other" }` (`absent` = the cursor carries no binding on that axis — for the store, a cursor written before cursors carried one; `other` = it carries another value) and `outs` (the two ways out); `config.memory_sync_store` gains `outs`, no `detail`. Ways out come from one table, one row per thing a round is refused on: the way out depends on the axis alone — absent and other are answered alike, which of the two it was rides `detail.found` — so the store axis's pair (rebind / clear, #2957) answers both the moved store and the legacy cursor, and the peer axis's pair (re-bind / drop, #2968) both a cursor for another peer and one with none. The sentence is `memory sync: <what was found> — <why>; two ways out: (1) <outs[0]>; (2) <outs[1]>`, built from the same row, so `outs` and the sentence cannot disagree. A value it quotes that holds a credential (a URL with userinfo, or anything the same-principal pass would redact) is quoted as `[redacted-credentials]` alone, never as a cleaned copy — a password with a quote in it is spelled out by no redaction pattern; the protocol error for a response cursor that answers for another peer quotes the same way. Only a refusal the engine minted reads as `refused`: an error that merely carries one of the codes (a transport's own) is `failed`.
|
|
40
|
+
- **Consumers.** @server (S-2540): the local-side door answers with `memorySyncReportOf`'s report — the read set = the session's latest settled leg's `effectiveMemoryScopes` (`done.result`; mounted → its scope keys, none / memoryless → `[]`), never the normalized `TaskSpec.memory` (which says what the session asked to read, not what it reads; C-R969 addendum 3), one entry per call per layer, the target mismatch and the in-flight fence as `refused`; the executor's own pre-judgment of a cursor without a store and its sentences can read `detail` / `outs` instead (S2). @client-core (CC-1052): map `why` from the report — `incomplete` → `memory_sync_conflict`, `failed` → `transport`, plus `refused` and the round's refusal; one message for `config.memory_sync_target_mismatch` in the catalog. @cli (L-2149 ①′): the fork step's memory sync reads the report's outcomes and `memoryTravelGapOf(report)` — "these layers are not readable in the cloud yet" — and treats `refused` / `failed` as failure (relay `outs`, no retry for `refused`).
|
|
41
|
+
- **Exports (S-2540 D-8, #3046, C-R991).** +1 root value `carriesCredential` — the one test the sync client and its report already use for a name a sync carries verbatim (a peer identity, a target, a scope key): a URL with any userinfo (a bare user name included), or anything the same-principal egress pass would redact. @server judges `target` / layer names / the centre's `peer` with it and never re-derives it (the consumer smoke list records it). The in-flight fence code is `session_active` — the host's own 409 code — not `conflict.session_active` (design/2897 r1 :52 named a code the host never had; renamed before this member ever shipped, so no reader changes).
|
|
42
|
+
- **Known limits (stated).** The report is as true as the calls the host hands it: a call left out is a layer reported `not_replicated`, never a guess. `localOnly` (the `userlocal:` layer, design/2897 S3) is not in this report yet; it lands with the key family (#2970).
|
|
43
|
+
- **Pins.** `test/backlog2969-sync-round-report.test.ts` (a real File store, real `syncMemoryScope`, transports that count their calls): a clean round cut by `maxPushEntries` is `incomplete/truncated`, the continued round `synced`, the two calls fold to one layer holding both rounds' `applied`; a replay is `synced` with nothing applied; server conflicts are `incomplete/conflicts`; a server that advances its cursor past an entry it did not deliver is `incomplete/truncated` and the scope stays in the gap; a server's conflict reason, an applied slug and a warning carrying a token reach the report redacted; a credential-bearing target, scope key or `reaches` (a quote inside the password included) is refused unquoted; a cursor with no store binding is refused with zero requests and zero store reads, `{ store, absent }`, its outs verbatim in the sentence and equal to the moved store's; a moved store is `{ store, other }`; all six axis × found pairs read their axis's row; the store plane has its own row; a transport error carrying a refusal code is `failed`; a credential in a cursor's peer is redacted in the sentence; a gate-failing file is quarantined and the round's request carries none of its bytes; every way a call settles has one outcome, a secret in a thrown message is erased; the gap over a refused round, a scope with no layer, each outcome and a destination read set, and after a JSON round trip; the round's refusals and bad inputs (`TypeError`), and a report the engine could not have minted (a layer with no scope, outside the read set, listed twice, an outcome it does not read) refused by the gap; the two root values are the leaf's. `test/backlog2957-sync-store-move-refused.test.ts` builds `{ peer, post }` and keeps its scope-axis cell (the peer axis is #2968's); `test/export-surface.snapshot.json` +4; `scripts/consumer-smoke-probe.mjs` decides the two values.
|
|
44
|
+
|
|
45
|
+
### A memory sync transport's `peer` is refused when it is only whitespace or carries a credential — userinfo in a URL, or anything the same-principal egress pass would redact (#3020, with #2968; behavior narrowing, open to veto; hard-breaking: none beyond #2968's transport shape; closed sets: none — the transport refusal keeps its sentence family, no code; exports: none) (@server)
|
|
46
|
+
|
|
47
|
+
- **Before.** The transport's `peer` was checked for a non-empty string only. `" "` ran a round (one request, a cursor bound to `" "`); `https://ops:<password>@host` rode the request body and the persisted cursor verbatim, though the contract says the identity is never a credential.
|
|
48
|
+
- **Now.** Before any read or request, a `peer` that is only whitespace is refused with the empty peer's sentence (`memory sync: transport.peer must be a non-empty string …`), and one that carries a credential — a URL with userinfo (a bare user name included: the slot is the credential's) or anything the same-principal egress pass would redact (a token in a query, a vendor key) — is refused with `memory sync: transport.peer [redacted-credentials] carries a credential …` — the identity itself is never quoted. The identity is refused, never cleaned: a cleaned identity is another identity, and the cursor taken under it would not be this peer's. A plain base URL, one with a port or a path, and an opaque identity run as before.
|
|
49
|
+
- **Behavior narrowing, three sentences (open to veto).** *Who needs it*: anyone whose sync cursors and request bodies are stored or logged — the identity rides both verbatim. *Who is hurt*: a deployment that builds the transport's identity from a URL with credentials in it (@server `createMemorySyncTransport`, which #2968 already asks to mint the identity from the normalized base URL without credentials). *Compensation*: the refusal comes before any read or request, so nothing is sent or written; the fix is the identity's mint, once.
|
|
50
|
+
- **Pins.** `test/backlog2969-sync-round-report.test.ts` (#3020 / #2968 follow-up cells): `" "`, `"\t\n"` and `""` are refused alike with zero requests and zero store reads; a URL with a password, one with a bare user name, a non-http URL with userinfo, and a URL with a token in its query are refused, quoted redacted, zero requests; a password holding a quote is absent from the refusal on the transport, the cursor refusal and the response-cursor protocol error alike; a plain base URL, one with a port and a path, `"central"` and an opaque `engine:` identity run and bind the cursor to themselves. `test/backlog2968-sync-peer-binding.test.ts`: a credential-bearing identity on the transport is refused — also against a cursor holding the same string.
|
|
51
|
+
|
|
52
|
+
### A `tool.call` extension that fails once the tool ran withholds the result, and a `classic.PostToolUse` raise that cannot hand the result to its handlers withholds it too — kernel contract 6, `tool.call`'s failure column is `refuse` (#2675; security narrowing, open to veto; hard-breaking: yes, open to veto; closed sets: none; exports: none) (@server @dgx @test)
|
|
53
|
+
|
|
54
|
+
- **Before.** `tool.call`'s failure column `refuse_until_run` refused a call while the body had not started and, once it had, let the body's real result through with the failure reported beside it: a checking extension that crashed, overran or broke the form after `next(e)` left the result it was there to check in the model's context. `classic.PostToolUse` swallowed a dispatch that could not be raised for a result and passed the original result on (the gap CC 2.1.299 closed: "a tool that already ran has its result withheld").
|
|
55
|
+
- **Now.** A `refuse` station refuses on a handler's failure whether or not its bottom has started, and the dispatch's `failed` outcome carries `bottomStarted: true` when it had (as `aborted` already did); `refuse_until_run` stays the column of a go-ahead bottom (`agent.spawn`, whose subagent starts only after the station answers). `tool.call` — column `refuse` — withholds the result of a body that ran: `isError`, "a tool.call extension … after this call to "<tool>" ran: a hook that checks this result could not hand back its answer, so the result is withheld — the call ran (fail-closed)", the gate's allow and no `notExecuted` (the call ran; it stays in the PostToolBatch; the failure is on `onError`). The call settles only once its body has (a handler that failed while its `next(e)` still runs waits for it), and a frame the result carried (a ReadInbox message) is withheld with it — never handed over again through another lane. A body that threw produced no result: its throw stands. The withholding sentence names the extension and what it did, never the bus's reason (a thrown message may quote the result) — the reason is on `onError`. `classic.PostToolUse` withholds a result the bus refused to raise or whose dispatch broke (content replaced, `details` emptied); a PostToolUse handler that fails is still skipped and the result kept.
|
|
56
|
+
- **Hard-breaking (open to veto).** *What changed:* `MOD_EVENT_TABLE["tool.call"].station.failure` is `refuse` (was `refuse_until_run`); `KERNEL_CONTRACT_VERSION` is 6 (one number with the 7.60.0 kernel additions); a result a late-failing `tool.call` extension let through is withheld. *Who needs it:* a deployment whose `tool.call` or PostToolUse extension checks results (a redactor, a data-loss filter) — its failure no longer hands the model what it was checking. *Who is hurt and how to migrate:* code that reads `tool.call`'s row as `"refuse_until_run"` reads `"refuse"`; a host pinning the contract number re-pins 6; an extension that answered `{ deny }` or `{ result }` after `next(e)` now sees the result withheld instead of standing — answer before `next`, or hand on what came up.
|
|
57
|
+
- **Consumers.** @server @dgx: the mods-kernel package face (the `tool.call` row, the contract number); no wire key changes. @test: a fixture reading a result through a late-failing `tool.call` handler re-pins to the withheld sentence.
|
|
58
|
+
- **Pins.** `test/backlog2675-withheld-after-run.test.ts` (real Runner: a throw, an overrun, a non-data answer and a late deny after the body ⇒ withheld, ran once, allow + no `notExecuted`, named on `onError`; before the body ⇒ refused; a body's throw stands; a PostToolUse raise that could not be given the result ⇒ withheld; a throwing PostToolUse handler ⇒ skipped; the call stays in the batch); re-pinned `test/mods-tool-call.test.ts` C2 / C3 / C7 / L5 and `test/mods-kernel-wave2.test.ts` (failure answers, contract 6).
|
|
59
|
+
|
|
60
|
+
### Edit, Write and NotebookEdit refuse a file that is not valid UTF-8 instead of rewriting its every undecodable byte as U+FFFD (#2676; security narrowing — data loss, open to veto; hard-breaking: none; closed sets: none; exports: none)
|
|
61
|
+
|
|
62
|
+
- **Before.** Encoding detection was BOM-only and a body read as UTF-8 was never checked: a Windows-1252, Shift-JIS or GBK file decoded with each legacy byte as U+FFFD, Read showed it (when under its binary threshold), and an Edit — or a Write over it, or a NotebookEdit — wrote the whole file back as UTF-8 with every such byte replaced by EF BF BD (the loss CC 2.1.296 / 2.1.299 closed by refusing).
|
|
63
|
+
- **Now.** The decoder's one "cannot be written back byte for byte" fact (`malformed`, which already named a truncated UTF-16 body) has a second why, `not_utf8`, and every write lane refuses on it: "… is not valid UTF-8: it uses an older encoding such as Windows-1252, Shift-JIS or GBK, or it is binary. … nothing was written", with the ways out (a shell command that keeps the encoding, asking the user to convert, or delete-then-Write). Read is unchanged; a valid file that holds U+FFFD itself edits as before.
|
|
64
|
+
- **Consumers.** none to change; a host that relied on an Edit converting a legacy file to UTF-8 now gets the refusal.
|
|
65
|
+
- **Pins.** `test/backlog2676-not-utf8-write-lanes.test.ts` (Windows-1252 Edit / Write / NotebookEdit refused with the bytes untouched; Shift-JIS and a BOM'd file with a legacy byte; controls; the decoder's fact).
|
|
66
|
+
|
|
67
|
+
### An `rm` that walks into a mounted drive is a protected removal — `dangerous_delete` for the folder that holds drives, a drive, or an entry at a drive's top level (#2674; security narrowing, open to veto; hard-breaking: none; closed sets: none — the kind is the card's sentence, not a wire word; exports: none)
|
|
68
|
+
|
|
69
|
+
- **Before.** The protected locations were the filesystem root, a home, a workspace directory or its ancestor, and a top-level directory: `rm -rf /Volumes/USB`, `rm -rf /mnt/c/Users`, `rm -rf /media/alice/USB` and `rm /Volumes/USB/*` were ordinary removals an allow rule cleared and bypassPermissions released (the gap CC 2.1.304 closed).
|
|
70
|
+
- **Now.** The one dangerous-removal predicate reads one more kind for an `rm` that walks what it removes — a recursive option in its row's reading of the argv, or an operand naming every entry of a directory: `/Volumes` and `/System/Volumes` down to `<drive>/<entry>`, `/mnt/<drive>` and `/mnt/<letter>/<entry>`, `/media` and `/run/media` down to `<user>/<drive>/<entry>` (folded case, POSIX paths). The card says "would remove a mounted drive, the folder that holds mounted drives, or a file or folder at the top level of a drive … if you meant something deeper inside, name it by its full path"; it is the `dangerous_delete` class every protected removal mints, which no mode, rule or classifier answers. A non-walking `rm` of one file, `rmdir`, and anything deeper read as before.
|
|
71
|
+
- **Consumers.** none to change (one more sentence on an existing class).
|
|
72
|
+
- **Pins.** `test/backlog2674-mounted-drive-removal.test.ts` (real Runner: nine walking removals × three modes × with and without `Bash(rm:*)`; five controls an allow clears; an unsettled program word read as `rm`; the predicate's roots, walk condition, folds and win-form paths; `/Volumes` itself stays top-level).
|
|
73
|
+
|
|
74
|
+
### A background fork started without a description shows no part of a credential from its prompt (#2678; security narrowing, open to veto; hard-breaking: none; closed sets: none; exports: none)
|
|
75
|
+
|
|
76
|
+
- **Before.** The description shown for a background fork (`Agent` with `subagent_type: "fork"`) with an empty description was the prompt's first 180 characters, cut BEFORE any redaction: a cut that landed inside a key left a head shorter than any recognizer reads (`AKIA` + nine characters), and that head passed every later pass into the registry row, the launch receipt and the completion notification (the gap CC 2.1.299 closed for teammates).
|
|
77
|
+
- **Now.** The description — or, with none, the prompt — goes through the same-principal egress pass first and is cut after it, the law every bounded operator line already keeps. A clean prompt reads exactly as before.
|
|
78
|
+
- **Consumers.** none to change.
|
|
79
|
+
- **Pins.** `test/backlog2678-fork-description-redaction.test.ts` (empty and blank descriptions over a prompt whose head ends inside a key: no piece of the key in the receipt, the registry row or the notification; a clean prompt and a given description read as before).
|
|
80
|
+
|
|
81
|
+
### The no-run MCP probe judges a declared endpoint by the deployment's host floor — `McpProbeOptions.hostFloor` (#2677; security narrowing, open to veto; hard-breaking: none; closed sets: none; exports: none — a member of an exported type) (@server)
|
|
82
|
+
|
|
83
|
+
- **Before.** `probeMcpServers` had no floor seat: it dialed every declared http endpoint with no floor, so a health check contacted a server a task under `RunnerDeps.hostFloor` refuses to contact (the gap CC 2.1.299 closed for `claude mcp list` / `get`).
|
|
84
|
+
- **Now.** `McpProbeOptions.hostFloor` takes the declaration `RunnerDeps.hostFloor` takes, compiled by the one compile (a declaration that does not read is refused `config.host_floor_invalid` before anything is dialed) and judged at the one dial: a refused endpoint is never contacted and its row reads `failed` / `invalid_config` with the sentence a task's warning carries. A delegated leg's servers already read the run's floor (the child's spec goes through the same preparation).
|
|
85
|
+
- **Consumers.** @server: pass the deployment's `hostFloor` to `probeMcpServers` wherever the health check runs beside a Runner that declares one — absent, the probe still dials with no floor.
|
|
86
|
+
- **Pins.** `test/backlog2677-probe-host-floor.test.ts` (deny and `only` never contact the endpoint; controls contact it; a floor that does not read is refused before any dial; the probe's row and the Runner's warning carry one sentence).
|
|
87
|
+
|
|
88
|
+
### A key behind an escaped quote names its value: JSON written inside a shell string is redacted like the bare object (#2679; security narrowing, open to veto; hard-breaking: none; closed sets: none; exports: none)
|
|
89
|
+
|
|
90
|
+
- **Before.** The keyword row of the credential vocabulary took a bare `"` / `'` on either side of its separator, so `echo "{\"secret\":\"…\"}"` and `bash -c "echo {\"api_key\":\"…\"}"` left `redactSecrets` / `redactHostLeaks` — and every engine face that reads the same-principal pass — with the value in clear, while the bare `{"secret": "…"}` was redacted (the gap CC 2.1.296 closed for shared transcripts and debug logs).
|
|
91
|
+
- **Now.** The quotes around the separator are read the way the `Authorization` header row reads them — a quote behind up to 63 backslashes — so an escaped key, at any depth the escape reading follows, names its value as the bare key does. No new row and no second reading of an escape.
|
|
92
|
+
- **Consumers.** none to change; a host that pins the exact output of `redactSecrets` over such text now sees the value replaced by the marker.
|
|
93
|
+
- **Pins.** `test/backlog2679-escaped-key-quote.test.ts` (three shell-string forms × both tiers; two escape layers; controls; a key with no value then a keyed value; idempotence).
|
|
94
|
+
|
|
95
|
+
### The peer seat is told what the engine keeps — `RunnerDeps.peerSeat` is one object `{ answer, hold, release }`, and the engine holds each credential reference from the moment it takes a declaration naming it until nothing it keeps can dial with it (#2864; hard-breaking, open to veto)
|
|
96
|
+
|
|
97
|
+
- **Before.** `PeerSeat` was a function `(question, signal) => Promise<PeerAnswer>`: the seat was asked per send and told nothing else. A deployment that registers a credential behind the opaque reference it hands the engine could not know when the engine had stopped needing it — a session-scoped background child, a retained child revived later in the process and a cascade's rungs all kept asking after the call that handed the declaration had returned, so the registration's lifetime could only be guessed (by session deletion, by run id, by process lifetime) and each guess was wrong for one of them.
|
|
98
|
+
- **Now.** The seat is `{ answer(question, signal), hold(ref), release(ref) }`, all three required. An engine object that keeps a declaration it can still dial from calls `hold(ref)` once for each distinct reference its declarations name and `release(ref)` once for each it held. Two keepers: a run leg — from the `runTaskStream` call (fresh, resumed, child, cascade rung and repair attempt alike) until its stream has settled, through the failure backstop included — and a retained child's ledger entry — from its registration until it leaves the ledger (eviction, abandonment, replacement; a row not taken releases at once). A taker holds within the call its giver is alive for, so a reference handed along is never unheld in between. The engine counts nothing (two keepers of one reference are two holds); a checkpoint and a background-agent row keep no declaration. A leg's `mcp` / `a2a` lists are received once, at the call, by the door's own receipt (each list read once, each entry a frozen copy — a getter on a declaration now runs at the call, once, not after the leg's session lock): the leg holds what that copy names and its door judges that same copy, so what a leg holds and what it dials are one read. A `hold` that throws or whose promise rejects is reported (`onError`, phase `config`, classification `peer-seat-hold`) in the engine's words and gets no `release`; a `hold` that returns a promise is held once it fulfils (a release due before then is sent then). Scope: this process; no registration across processes is assumed.
|
|
99
|
+
- **Hard-breaking (open to veto).** *What changed:* `PeerSeat` is an interface of three required members instead of a function type, everywhere it is taken (`RunnerDeps.peerSeat`, `materializeMcpTools`' twelfth parameter, `materializeA2aTools`' fifth, `probeMcpServers({ peerSeat })`); a function — the 7.59.0 form — is refused there (`config.invalid_argument`, naming the form); `RunnerSelfSeat` gains a required `holdDeclarations(declared)`. *Who is hurt:* a deployment that implements the seat (tsc red; at run time `new Runner` refuses), and a hand-built `RunnerSelfSeat` (tsc red). *What to do:* put the former function under `answer` and add `hold` / `release` (no-ops for a seat that keeps no per-reference state; a counting seat reads "more holds than releases" as "the engine still has a consumer"); a hand-built `RunnerSelfSeat` forwards `holdDeclarations` to the Runner it stands for — one cast past the compiler without it is refused by name (`config.invalid_argument`, naming `holdDeclarations`) where a retained child's row would take its hold, not left to a bare TypeError from the middle of the delegation.
|
|
100
|
+
- **Consumers.** @server: the desk's seat object gains its engine half (`hold` / `release` on each entry's engine count; a hold of a dropped entry should not revive it); the transitional reading by session deletion retires. The server hands the seat over at four places, each a bare function until now and refused (`config.invalid_argument`) once the object is required (read from the server's tree before its 7.60.0 pickup): `src/boot/runner-deps.ts:748` (`RunnerDeps.peerSeat`), `src/capabilities/mcp-probe.ts:503` (`probeMcpServers`), `src/http/routes/sessions.ts:350` (`materializeMcpTools`, twelfth parameter) and `:420` (`materializeA2aTools`, fifth). @client-core / @cli: no code (the seat is the server's). @test: the hold / release pairing is observable only through a seat; the four shapes are pinned below.
|
|
101
|
+
- **Exports.** `PeerSeat` kind type → interface; +2 root types `PeerDeclarations` / `PeerDeclarationHold`; `RunnerSelfSeat` +`holdDeclarations`.
|
|
102
|
+
- **Pins.** `test/backlog2864-peer-seat-hold.test.ts` (S: the form refused at the reader and the four entrances; K: once per distinct reference, data members only, a throwing or rejecting hold gets no release and is reported (through the seat `new Runner` keeps too), no engine-side count; L: the host lets go right after the call and the leg's sends are answered and nothing is asked after its release — and the counterexample, a host that lets go before the call: the leg's late hold does not revive the entry and the send is refused; a door-refused leg still pairs; a getter declaration received and held at the call, a named-session leg included, the getter run once; C: a cascade's rungs pair each; B: a session-scoped background child keeps the entry after the spawning leg lets go — and the counterexample, a parent that lets go before the spawn; R: a retained entry holds across its legs and releases on eviction / abandonment / replacement / refusal — and the counterexample, an entry registered after its giver let go; H: a hand-built seat without `holdDeclarations` is refused by name at both retention registrations, and one that answers is asked once per row).
|
|
103
|
+
- **Known limits.** A session-scoped background child spawned by a tool call that outlives its own aborted leg may take its hold after that leg released (the abort orphan window) — KL-2864-a; a leg whose prepare never settles never releases — KL-2864-b; a connection whose close outlived the bounded teardown may reconnect once after the release (the seat then refuses — nothing is sent) — KL-2864-c; an asynchronous `hold` whose promise never settles keeps its release waiting — KL-2864-d.
|
|
104
|
+
|
|
105
|
+
### Four more extension events are raised: `agent.offer` and `agent.spawn` around a delegation, `turn.complete` and `session.end` as a model turn and a leg end (#2457, #2458; mods wave three S2 / S3a, design/1398 waves 2–3, C-R704 / C-R940; behavior change only where a handler hangs on one of them; hard-breaking: the kernel contract 5 → 6 — a mod package written against 5 is refused, three sentences below, open to veto; closed sets: four station rows; exports: none) (@server @cli @client-core @test)
|
|
106
|
+
|
|
107
|
+
- **Before.** The four names were in `MOD_EVENT_TABLE` with no station: a registration that selected only them was refused at admission, and a workflow script's agent had no extension seat of its own (#1500 named this gap).
|
|
108
|
+
- **Now — `agent.offer`.** One offered set, read by the agent listing a leg renders (its first request and each boundary that owes the frame) and by the type a delegation names at dispatch. A handler answers `next(e)` or `{ isOffered: false }`: the type is left off the listing, and a delegation naming it anyway is refused before anything is allocated (`Sub-agent not started: subagent_type "<type>" is not offered here …`). `e = { agent, description, provider }`, `agent` and `provider` pinned; a failing handler is skipped and the type stays offered (the reference: "A hook that fails passes it through"). A revival is no offer. Known limit: the delegation tool's own description (the cached tool block, which names the built-in `fork` lane) and its refusal of an unknown type (which lists every accepted type) are fixed before any extension runs and do not read the offered set.
|
|
109
|
+
- **Now — `agent.spawn`.** Raised on the delegating leg's bus once the delegation tool has judged the call and before anything is allocated for the child, and for each agent a workflow script spawns (on the host leg's bus, `workflow: true`). Every member is pinned — the spawn's identity, its parent's, the identity envelope and every argument the gate judged (`prompt`, `description`, `subagentType`, `model`, `background`, `cwd`, `name`, …) — so the only answer is a refusal: `{ deny: <reason> }` instead of `next` starts no child and the model reads which extension refused; `next(e)` lets it start and comes up as `{ model }` (the model the delegation named, `inherit` when the child's own prepare decides). Failure column `refuse_until_run`: a throw, a timeout, a changed member or an answer of its own refuses while the child has not been let start; once it has, the spawn stands and the failure is reported on `onError` (`phase: "hook"`). No spawn is raised for a revival of a parked or retained agent, a drive of a parked workflow agent, or an observer leg a definition starts beside its child. Known limit: the observed spawn's `e` does not name its observer, so neither hiding the observer's type nor a refusal keeps an observer from running beside a child the chain let start.
|
|
110
|
+
- **Now — `turn.complete` and `session.end`.** Observations. `turn.complete` once per `turn_end` the leg emits, in order, at the next await point — the boundary after it, or the leg's settle for turns no boundary followed (a recovery re-prompt, an interrupted last turn) — at the start of the boundary's own pass and before the leg's `classic.Stop`, `e = { answer, reason, turn, isAborted, usage?, agentId? }` (`usage` absent when the brain reported none; `reason: "aborted"` when the leg's cancel was in force or the reply's own stop reason says so, as a reply cut while streaming does — a turn whose tool batch an immediate steer cut reads `"answer"`); `session.end` once per leg as its terminal settles, `e = { reason, sessionId, agentId? }` with the terminal status word — like the delegation lifecycle's terminal, never for a leg that throws out of the runner. A handler's answer changes nothing and a failing handler is skipped. No handler on an event: nothing is raised and nothing is awaited on its path.
|
|
111
|
+
- **Failure columns, station by station** (the contract's fourth trigger): `agent.offer` skip · grace · pinned `agent`, `provider`; `agent.spawn` refuse_until_run · immediate · sixteen pinned members; `turn.complete` skip · grace · pinned `answer`, `agentId`, `turn`; `session.end` skip · grace · pinned `reason`, `sessionId`, `agentId`. None has a `call` column: `$.agent.spawn` is not on `$` in this version.
|
|
112
|
+
- **Hard-breaking, open to veto: a mod package written against contract 5 is refused (@server @cli @test @client-core).** What changed: `KERNEL_CONTRACT_VERSION` is 6, and `loadModPackage` loads only a package whose `hooks.json` states `"contract": 6` (`src/core/mods/package.ts:72-73`); 7.59.0 shipped 5. Who is hurt: every mod package written for 7.59.0 — a deployment loading a real package (server S-2388), the CLI's package leg (MODS155), test's real-package fixtures (C-R915), and a host comparing two kernel copies for equality (client-core's generated table gains four station rows); the server's own hard-coded `5` is in four places, none on its runtime path (its deployment loader reads the engine constant, `src/boot/deployment-mods.ts:33` and `:111`): the acceptance harness's fixture contract number (`acceptance/s2388-mods-deployment/run.mjs`), the version pin `test/mods-loader-pickup.test.ts`, the 7.59.0 pickup case in `test/mods-deployment-loader.test.ts`, and one sentence of `docs/ASSISTANT-WIRE-CONTRACT.md` (read from the server's tree before its 7.60.0 pickup); this repo's three fixtures (`test/fixtures/mods/{diff,sec-default,telemetry}/hooks/hooks.json`) were raised to 6. What to do instead: set `"contract": 6`; contract 6 adds these four stations and changes `tool.call`'s failure column (#2675, above: a failure once the body ran withholds the result), so a package whose handlers name none of the four, and none on `tool.call` that fails after `next(e)`, needs no other change.
|
|
113
|
+
- **Pins.** `test/backlog2457-2458-mods-wave3-stations.test.ts` — real Runner, a parent delegating once: a hidden type is off the listing and refused when named; a failing offer handler leaves it offered; spawn's `e`, `{ model }` coming up, a deny / a changed member / an own answer / an early throw refusing with no child started, a late throw or late deny reported beside a child that ran; the workflow lane's raise; `turn.complete` per turn before `classic.Stop` and `session.end` last; observations that throw change nothing; the rows and the contract number. `test/mods-kernel-296.test.ts` counts the four new stations and names `turn.step` as the station-less example.
|
|
114
|
+
|
|
115
|
+
### What an execution environment can do is one required block on every environment — `ExecutionEnv.capabilities` (`ExecutionEnvCapabilities`, eight keys), each key read through its one reader, a key left out or of the wrong shape announced and read on its safe side (#2947, design/2891 S1, ruled C-R965 and C-R964; hard-breaking: the block is required on the base type and the two loose booleans are retired, three sentences each below, open to veto; closed sets: `config.execution_env_capability_invalid` `detail.key` +4 words and minted for any environment; exports: +1 root type, +2 root values) (@server @cli @client-core @test)
|
|
116
|
+
|
|
117
|
+
- **Before.** The capability block lived on `RemoteExecutionEnv` alone (`isolation`, `suspendable`, `canonicalPathAuthoritative?`, `sharesProcessTable`); every reader asked the remote interface first and gave any other environment a fixed answer, so an environment without the remote seam could declare nothing (KL-2348-b). Two more facts sat on the base type as loose optional booleans with absent readings of their own (`hostLocalPaths?` — absent fell back to the remote shape or `instanceof NodeExecutionEnv`; `externalContentTarget?` — absent read as trusted). The admission census looked at remote environments only, and absence of three of the four keys was a silent reading.
|
|
118
|
+
- **Now.** `ExecutionEnv.capabilities: ExecutionEnvCapabilities` is required on every environment: `isolation`, `suspendable`, `sharesProcessTable`, `canonicalPathAuthoritative`, `hostLocalPaths`, `externalContentTarget`, `io` (the filesystem and shell faces reach a target), `keepsReadFloor` (#2944, the next section). `RemoteExecutionEnv` inherits the block. Each key has one reader (`isIsolated`, `declaredSuspend` / `isSuspendable`, `processTableOf`, `canonicalPathIsAuthoritative`, `pathsAreHostLocal`, `targetIsExternal`, `performsIo`, `keepsReadFloor`), none of which asks the interface. Every key is required and has no default reading: absent, not a boolean, unreadable — or a block that is not an object or cannot be read — is one `config.execution_env_capability_invalid` per key per run at admission (`detail: { key, valueType }`, the sentence naming the reading) and the reader's safe side: isolation false, suspendable undeclared (never snapshot), process table undeclared (pattern kills refused), canonical authority true (silence refuses), host-local undeclared (no path presented as the host's; a worktree child refused — #2948 below), external undeclared (the content fold reads it as outside; a call that reaches it owes what reaching the target and what leaving it both owe on the cross-boundary lane), io undeclared (no shell face; the project marker still read through the environment — #2948 below), floor not kept. `NodeExecutionEnv` declares `{ isolation: false, suspendable: false, sharesProcessTable: true, canonicalPathAuthoritative: true, hostLocalPaths: true, externalContentTarget: false, io: true, keepsReadFloor: false }`; `StubExecutionEnv` the same but `canonicalPathAuthoritative: false`, `io: false`, `keepsReadFloor: true` (it refuses every start). The frame's `remote` and the file-history identity read `pathsAreHostLocal` where they read the loose `hostLocalPaths`; the run's content fold and the cross-boundary lane read `targetIsExternal` (`BoundaryLegsGiven.env` is `Pick<ExecutionEnv, "capabilities">`). An oracle grader is `out_of_process` only when it declares isolation AND has the remote interface whose sandbox identity the check compares.
|
|
119
|
+
- **Behavior on the lanes that exist.** None on `NodeExecutionEnv` (its new `canonicalPathAuthoritative: true` moves no read-boundary verdict: its resolver always answers `/`) or on a TypeScript adapter that states its block. A run without hands (the Stub) now has file-history identity `"host"` (it writes no file). An adapter that leaves a key out — a JS adapter, or one written against 7.59.0 — gets a notice per key and the safe side above: for an undeclared `hostLocalPaths` its frame reads `remote: true`, for an undeclared `externalContentTarget` its content is treated as from outside (the memory session mark) and its tree is armed, and a call reaching it owes both the on-target and the off-target obligations (a person's confirmation on a governed tree, the off-target read record).
|
|
120
|
+
- **Hard-breaking, open to veto — the block is required on every environment (@server).** *What changed:* `ExecutionEnv` gains the required member `readonly capabilities: ExecutionEnvCapabilities` (eight keys, `keepsReadFloor` and `io` among them); `RemoteExecutionEnv.capabilities` is that member, with `canonicalPathAuthoritative` required where it was optional. *Why there is no default:* each reader would have to guess one side for an environment that says nothing, and that side is wrong for some other environment (assuming isolation is a hole, assuming a shared process table refuses an ordinary `pkill` in a sandbox, assuming a kept floor hides bytes that reach the model). *Who is hurt:* every host that implements `ExecutionEnv` — the server's seven remote adapters and any adapter written against 7.59.0 — fails `tsc` until it states the block; a JS adapter that leaves a key out compiles, is announced at admission and is read on the key's safe side. *Migration:* each of the seven remote adapters adds `hostLocalPaths` (the host lane `true`, the others `false`), `externalContentTarget` (the device lane `true`, the others `false`), `io: true`, `keepsReadFloor: false` (until a lane keeps the floor or refuses the start, §11.1) and states `sharesProcessTable` and `canonicalPathAuthoritative` explicitly; the two subclasses of `StubExecutionEnv` inherit the Stub's block and compile unchanged (override it where an operation does real I/O); a JS adapter that leaves a key out is announced at admission and read on the key's safe side.
|
|
121
|
+
- **Hard-breaking, open to veto — the two loose base-type booleans are retired (@server).** *What changed:* `ExecutionEnv.hostLocalPaths?` and `ExecutionEnv.externalContentTarget?` (and `StubExecutionEnv.externalContentTarget?`) are removed; the facts are `capabilities.hostLocalPaths` / `capabilities.externalContentTarget`. *Why:* one fact in two places is two sources that can disagree. *Who is hurt:* an adapter or host that sets or reads `hostLocalPaths` / `externalContentTarget` on the environment itself (the device adapter's top-level `externalContentTarget` is one) fails `tsc` on the removed members. *Migration:* the device adapter moves its top-level `externalContentTarget` into `capabilities`; a host that read either member reads `pathsAreHostLocal(env)` (root export) or the block.
|
|
122
|
+
- **Consumers.** @server: the seven blocks and the device lane's move above; the execution-lane table's `hostFilePlane` can agree with `pathsAreHostLocal` (#2891 X-1 retires the duplicate bits when it lands). @client-core / @cli: `config.execution_env_capability_invalid` `detail.key` gains `hostLocalPaths`, `externalContentTarget`, `io`, `keepsReadFloor` (and `capabilities`) and arrives for local environments too — a table that pins the key set adds the rows. @test: a NON-remote environment that declares `isolation: true` is now read as isolated by every reader (the remote interface is no longer a precondition), except the oracle's out-of-process class.
|
|
123
|
+
- **Same release.** The structural readings that answered capability questions off the remote interface or the Stub's class retire to the readers in #2948 (design/2891 S2, the next-but-one section), with the host lane's five readings that move there.
|
|
124
|
+
- **Exports.** +1 root type `ExecutionEnvCapabilities`; +2 root values `pathsAreHostLocal`, `keepsReadFloor`. Removed members: `ExecutionEnv.hostLocalPaths`, `ExecutionEnv.externalContentTarget`, `StubExecutionEnv.externalContentTarget`.
|
|
125
|
+
- **Pins.** `test/backlog2947-capability-table.test.ts` (P1 the source scan: every remote-predicate call, class check and direct key read left in src/ is a row — the interface whitelist or a reading #2948 retires — and no loose member survives; P2 Node's eight answers, its read-boundary verdicts unchanged by `canonicalPathAuthoritative: true`, its frame and file-history readings; P5 no block / `"true"` / `1` / `null` / a throwing key or block ⇒ one notice per key and every reader on its safe side, a non-remote env declaring isolation, the oracle's interface conjunct; P7 the Stub's answers and no notice for a run with no env or a Stub; P7b the marker read through a limited host-disk env; P8 the census walks exactly the type's keys, a block missing a key does not compile); the remote doubles mint their blocks through `test/env-capability-block.ts`.
|
|
126
|
+
|
|
127
|
+
### A run whose read-deny table holds rows on an environment that does not keep the byte floor is announced once — or refused at prepare when the deployment requires the floor (`readDenyFloorRequired`); the engine's own starts whose output reaches the model carry the floor (#2944, #2937 ①, design/2936, ruled C-R964; behavior change: one operator notice per run on `NodeExecutionEnv` with the default tiers; hard-breaking: none beyond the required `keepsReadFloor` key above; closed sets: `ENGINE_NOTICE_CODES` +1, `SWAPPABLE_DEP_SEATS` +1; exports: `keepsReadFloor` (above); members: `RunnerDeps.readDenyFloorRequired?`, `HandsToolkitOptions.readDenyFloorRequired?`) (@server @cli @client-core @test)
|
|
128
|
+
|
|
129
|
+
- **Before.** `NodeExecutionEnv` ignored the floor every shell start carries, in silence (INTEGRATION-CORE §11.1 said so in two sentences), so on the local lane a recursive read under the root carried a deny row's bytes into the conversation with nothing said (KL-r2-a), and nothing could declare that a lane does or does not keep the floor. The env facts probe, the git status frame and the Grep tool's ripgrep — starts the engine makes itself, whose output it relays to the model — carried no floor at all: a repository's `include.path` pointing at a deny-listed file put its fields into the git frame on any lane.
|
|
130
|
+
- **Now.** Judged per table owner, as each table is compiled: the Runner for every table a run compiles — the prepare's, and each one a person's persisted rows bring mid-run (with the requirement such a table fails to compile, so the call that would judge with it is refused; the notice is said once per run) — each delegated child on its own environment, and a library-direct band for a table it compiles itself (a band handed the Runner's face judges nothing). The table holds rows and the environment does not declare `keepsReadFloor: true` ⇒ with `RunnerDeps.readDenyFloorRequired: true` the prepare refuses with `config.read_deny_floor_unkept` before any command starts; otherwise one operator notice under the same code (`detail: { rowCount, sessionId, runId }`). An empty table is not judged. A run without hands runs on the Stub, which keeps the floor (it refuses every start), so it is never judged unkept. The requirement is the read-deny family's deployment seat: a boolean, absent = not required; any other value refuses (`config.read_face_seat`) at the prepare and at `swapDeps`, which now takes it (`config.read_deny_swapped` `detail.floorRequired`). The three relaying starts carry the run's floor (the Grep tool the call's own); an environment that keeps the floor and cannot keep it for one of them refuses it, and the probe's facts are missing / the frame degraded by the arms each already had.
|
|
131
|
+
- **Honest scope.** On `NodeExecutionEnv` a deny row's bytes still reach the conversation through a recursive read: this release makes that visible (the notice) and refusable (the requirement), not prevented. A lane that keeps the floor is a future one (the server's sandboxed lanes, S-2218; a local OS confinement, #2945 T3).
|
|
132
|
+
- **Consumers.** @server: each remote adapter declares `keepsReadFloor` (above); a deployment that must not run without the floor sets `readDenyFloorRequired: true` — on the local lane every run is then refused while the default tiers are on. @cli: every session on the local lane carries one operator notice `config.read_deny_floor_unkept` while the default tiers are on — how it is shown is the shell's. @client-core / @test: `ENGINE_NOTICE_CODES` +1 (audience `operator`); the same word is a prepare `errorCode`.
|
|
133
|
+
- **Deviations from the reference (registered as candidates).** `read-floor-rides-relaying-engine-starts` — ours: the env facts probe, the git status frame and the Grep tool's ripgrep carry the floor; the reference sandboxes the Bash tool's commands only. `read-floor-unkept-announced-when-table-nonempty` — ours: a non-empty deny table is the request, and an environment that does not keep it is announced; the reference warns only when its sandbox was asked for and cannot start.
|
|
134
|
+
- **Pins.** `test/backlog2944-read-floor-kept.test.ts` (J1 Node + default tiers: one notice, `rowCount ≥ 1`, and a recursive grep still reads a fake `.netrc` in a temp directory; J2 an empty table: no notice, the requirement refuses nothing; J3 the requirement on Node: the run fails with the code and nothing started, a self-compiling band refuses the same; J3b an empty table at prepare that gains a person's Read deny mid-run: no start carries a floor on Node; J4 a declared keeper is silent, `"true"` and a missing key are the census's notice and the floor's; J5 bad requirement values refuse at the prepare and the swap, a good one swaps and the next run reads it; J6 a library-direct band once per construction, the Runner's path once; J7 no env / an injected Stub: no notice, the requirement refuses nothing; J7b a delegated child judges its own environment, both ways; J7c rows with no floor for the starts refused as an engine defect; J8 the probe, the git frame and ripgrep carry the run's rows; J9 every environment start in src/ classified relayed or not; J10 a keeper refuses the git frame's start that would read a deny row through `include.path`, and the field is not shown).
|
|
135
|
+
|
|
136
|
+
### Where an environment's actions land is read off its declaration alone — the remote interface and the Stub's class stop answering capability questions, and a host lane reads as the host it drives (#2948, design/2891 S2, ruled C-R965 and its addendum 1; behavior change: the host lane's five readings below, and smaller ones — the worktree exemption's narrowing open to veto; hard-breaking: HB-3 the host lane's readings flip, and `PersistenceFacts.remoteHands` is renamed `handsOffHost`, three sentences each below, open to veto; closed sets: none; exports: none) (@server @cli @client-core @test)
|
|
137
|
+
|
|
138
|
+
- **Before.** Four questions had more than one reading. *Is a path this environment names the host's?* — the frame's `remote` was `isRemoteExecutionEnv(env) || !pathsAreHostLocal(env)`; the file history asked the remote handle before the declaration; the memory write instruction, the capture carrier and the roster's persistence judgment asked the remote interface; a worktree child on the remote interface had to declare isolation (shape (d)) and one off it was compared by path; the delegated child's placement hint asked the interface. *Is there I/O?* — four `instanceof StubExecutionEnv` checks. *Can it snapshot or park?* — one strict reader, three truthy reads of `capabilities.suspendable`, and a park-only target of "remote and not snapshot-capable", which parked an environment that never said `false`.
|
|
139
|
+
- **Now.** One reader per question. Where paths land is `pathsAreHostLocal`: the frame `workspace_changed.remote` (and `ResolvedWorkspace.remote`) is `!pathsAreHostLocal(env)`; the file history is the host's one tree for a host-disk environment, else the remote handle's identity, else its own; the memory write instruction and the roster's persistence judgment drop the hand band's tools when the band is off the host's disk; a `capture: "off"` declaration needs a supplied carrier store when the environment is off the host's disk; a worktree child is compared by physical path whenever its environment is on the host's disk (isolated or not), exempt only when it declares itself off the host's disk (`hostLocalPaths: false`) and a sandbox (`isolation: true`), and refused otherwise — an environment that does not say where its paths land can be neither compared nor exempted (`isolation.unavailable`); the delegated child's placement hint follows. Whether a shell face mounts (the band's shell, the shell seat, the full shell's reachability) is a declared `io: true` (`performsIo`, now three states); the project marker is read through the environment unless it declares `io: false`. Whether a run can snapshot or park is `declaredSuspend` (three states): `true` (with the restore surface) is the snapshot target, `false` the park-only target, undeclared neither — such a run cannot suspend durably: a resource or platform suspend is INACTIVE, a durable ask is refused, a plan review is skipped, each naming the declaration; a snapshot-less handle not marked park-only is tolerated on resume only by an environment that declares `false`. The remote interface is read only where a remote method is called (the whitelist in backlog2947 P1).
|
|
140
|
+
- **Behavior on the lanes that exist.** None on `NodeExecutionEnv`, on the injected Stub, or on a sandbox lane that states its block. The host lane — the remote interface with `hostLocalPaths: true`, `isolation: false` (the server's default lane) — moves on five readings (HB-3 below). Three smaller moves: an environment off the host's disk WITHOUT the remote interface (an in-memory class) is no longer taught the memory write instruction, refuses `capture: "off"` without a carrier store, and refuses a worktree child (it was compared by path); a declared sandbox ON the host's disk (a bind-mounted container) has its worktree child compared by path (it was exempt); an environment that does not declare `io` mounts no shell face, one that does not declare `suspendable` as a boolean is not parked, and an isolated one that does not declare `hostLocalPaths` (a JS adapter) has its worktree child refused (it was exempt on the remote interface).
|
|
141
|
+
- **Hard-breaking, open to veto — a host lane is no longer read as remote (HB-3) (@server @cli @client-core).** *What changed:* an environment that declares `hostLocalPaths: true` on the remote interface (the server's host lane) now reads `workspace_changed.remote: false`, shares the host's file-history tree (`"host"`), is taught the memory write instruction, accepts `capture: "off"` without a supplied carrier store, and has a worktree child compared by physical path and accepted when it is its own directory (it was refused `isolation.unavailable`). *Why:* each of these asked the interface, and the host lane drives the engine's own machine and disk through it, so it got a sandbox's answers (no memory writes, no worktree children, a refused opt-out). *Who is hurt:* a projection that reads `workspace_changed.remote` (or `ResolvedWorkspace.remote`) to tell the host lane from a sandbox now reads `false` for the host lane — none downstream today — and a deployment that relied on the host lane being refused a worktree child or `capture: "off"` sees it accepted. *Migration:* none on the server side to get the new readings — the declaration already present (`hostLocalPaths: true`, #2947) is read; the explicit carrier store and `memoryPersistenceCapable` stay valid; the execution-lane table's `coreRemoteExecutionEnv` bit and the memory-boundary note that the file plane is a second axis can retire (#2891 X-1); the frame value change has no reader downstream today (the server projects `cwd` only; the CLI and client-core read `cwd`).
|
|
142
|
+
- **Behavior narrowing, open to veto — an isolated environment that does not say where its paths land gets no worktree exemption.** *What changed:* an environment declaring `isolation: true` whose `hostLocalPaths` is left out, not a boolean or unreadable has its worktree child refused (`isolation.unavailable`, a new sentence, no new code); on the remote interface it was exempt, off it it was compared by path. *Why:* the exemption stands on the environment's paths not being the host's, and an undeclared location is neither that nor something the engine can compare — `hostLocalPaths` has two consumers with opposite safe sides (no path presented as the host's; no exemption), read through one three-state reader. *Reach:* a JavaScript adapter only — a TypeScript adapter must state the key (the block is required, #2947); declare `hostLocalPaths: false` on a sandbox lane.
|
|
143
|
+
- **Behavior narrowing, open to veto — a plan review on a per-task environment in neither suspend target is skipped, not parked.** *What changed:* every durable suspend lane — the resource and platform lanes, a durable ask, a plan review — refuses on one fact, a per-task environment in neither the snapshot nor the park-only target, and that fact now names a per-task environment without the remote seam too (a factory-minted host env, a block that is absent, no object or unreadable); a plan review on one is skipped with a notice where it was parked with no workspace handle. *Why:* that checkpoint resumed onto a fresh environment, and the other lanes already refused it. *Reach:* a factory that mints environments without the remote seam; a static environment still suspends in process.
|
|
144
|
+
- **Hard-breaking, open to veto — `PersistenceFacts.remoteHands` is renamed `handsOffHost` (@server @cli @client-core).** *Who needs it:* the roster judgment's facts now say whether the hand band is off the host's disk, which is no longer "remote" — a host lane is remote and on the host's disk — so the old name would state the reading this release retires. *Who is hurt:* a host calling `rosterCanPersistMemory` or `persistenceCapableToolNames` with a facts literal naming `remoteHands` no longer compiles (no reader in the server, CLI or client-core sources today). *Compensation:* rename the member; the value is the same question asked of the declaration (`handsEnabled && !pathsAreHostLocal(env)`).
|
|
145
|
+
- **Consumers.** @server: the host lane gets the five readings above with no code change; the shell faces now mount only on a declared `io: true` — every adapter states it since #2947, and the two `StubExecutionEnv` subclasses inherit `io: false` (no shell, as before). @cli: a local session is unchanged; a session on the server's host lane sees the memory write instruction and worktree children it did not see. @client-core: the frame key is unchanged and its value is `false` on the host lane. @test: P3 / P3b / P4 / P6 / P7 below read the host lane against a sandbox lane item by item.
|
|
146
|
+
- **Pins.** `test/backlog2948-four-readings-one.test.ts` (P3 the host lane's frame, file history, write instruction, capture carrier and worktree child; P3b `isolation` × `hostLocalPaths` on and off the remote interface — a compared env refused at the shared root and accepted at its own, a sandbox off the host exempt, anything else refused, and an isolated env whose `hostLocalPaths` is left out, a string or a throwing getter refused; P4 the sandbox lane as before; P6 `suspendable: "false"` neither snapshot nor parked on the ask lane and the plan-review lane, each refusal naming the declaration, a declared `false` parking, and a per-task env without a usable remote seam (a throwing, absent or non-object block, a plain host env) refused on both lanes; P7 the injected Stub and an env without `io` keep their file tools without a shell; P7b an env without `io` has the marker read through it); `test/backlog2947-capability-table.test.ts` P1 (the interface whitelist is the only structural reading left; no class check, no direct key read).
|
|
147
|
+
|
|
148
|
+
### An environment's capability block is received once — copied, frozen and the only thing any reader reads — and a member outside the eight keys is announced; a read face is a deployment statement on every lane (#2964, #3030; behavior narrowing, three sentences below, open to veto; hard-breaking: none; closed sets: `config.execution_env_capability_invalid` `detail.key` may name a member outside the eight keys; exports: none) (@server @cli @client-core)
|
|
149
|
+
|
|
150
|
+
- **Before.** One run read the adapter's `capabilities` getter several times (the census, each reader, the remote predicate's block conjunct), so what the census judged and what a reader acted on could differ for a block that changed; a member outside the eight keys (a misspelled `isolaton`) was ignored in silence, leaving the key it meant undeclared with no word about why. A read face's default on a multi-lane deployment, and how a governed deployment sets it, were not written down.
|
|
151
|
+
- **Now.** The block goes through the engine's one receipt of a caller's object (the reading a Model and an options bag get): read once per environment object — at its first read, a run's admission point — its own members each read once, copied and frozen; every reader, the census and the remote predicate read that copy. A member outside the eight keys is one `config.execution_env_capability_invalid` under its own name (`detail: { key, valueType }`), and no reader takes it. A read face is a deployment's trust statement, never an environment capability: no declaration of the environment (a sandbox's `isolation` included) enters the face's resolution order, so every lane's default is `roots`, and a lane that is to read open says so at a seat allowed to open — the deployment seat in force for its run, or the task seat where no organization governance is declared; under governance only the deployment seat opens.
|
|
152
|
+
- **Behavior narrowing, open to veto.** *What changed:* a host that changes an environment's block after the engine first read it is no longer read (the block is a constant of the adapter, as documented); a Proxy block is refused by the receipt before any trap runs (one notice under `capabilities`, every key on its safe side), and a member the receipt cannot copy (a function, a getter that throws) is `unreadable`; a member outside the eight keys is announced. *Why:* one reading — what was judged is what is read, as for a Model (#2846) and a store's options (#2847). *Migration:* none for a TypeScript adapter whose block is a plain data member (the server's seven); an adapter that rebuilt its block per read keeps the first one per environment object — mint a new environment object to change it.
|
|
153
|
+
- **Consumers.** @client-core / @cli: `detail.key` of `config.execution_env_capability_invalid` may now name any member the adapter wrote — a table that pins the key set reads an unknown word as a member that is no capability. @server: the seven adapters declare plain data blocks and see no change; a multi-lane engine under governance has one deployment read-face seat per Runner (the open question is #3035).
|
|
154
|
+
- **Pins.** `test/backlog2964-capability-receipt.test.ts` (R1 one getter read for a run with hands and a shell call, none for a second run, a member getter once; R2 `isolaton` announced under its own name beside the undeclared `isolation`; R3 a block mutated and replaced after the receipt changes no reader and the census repeats the received findings; R4 a Proxy block refused with no trap run); `test/backlog3030-read-face-lanes.test.ts` (the engine's own host, a host lane and an isolated sandbox × no seat / deployment open / task open / both, ungoverned and governed: roots by default on every lane, the deployment seat opens, the task seat opens only ungoverned and only tightens a deployment's open); `test/backlog787-capability-shape-census.test.ts` H6 (a lying Proxy block hides nothing: the receipt refuses it).
|
|
155
|
+
|
|
156
|
+
### Org memory admission is asked by who asks — the resolver's input is discriminated by caller presence, read once the way the task door reads it, and the memory of an owner with no identity is written down as an opaque key, never a sentinel principal (#900 C0 / C1; hard-breaking: the seat's input type, open to veto; behavior narrowing, open to veto: a task whose principal is the empty string, and a resolver that rewrites its own input; closed sets: none; exports: +2 root types `MemoryScopeAdmissionInput`, `DeploymentMemoryScopeRequest`) (@server @cli)
|
|
157
|
+
|
|
158
|
+
- **Before.** `MemoryScopeAdmission` took `{ principal: string | undefined; requested; requestedWriteScope }`, any origin either way. The door refused a request-origin org scope without a caller only when the principal was `undefined`, while the task door reads the empty string as no principal too (`TaskSpec.principal: ""` passes it as absent): such a task put its request-origin org scopes to the resolver as if `""` were a caller, and a deployment-only request reached the resolver with `principal: ""`. Nothing in the type said the door had already refused the caller-less request-origin shape, so a resolver kept its own refusal arm for it (the server's does, with two cells that build that shape).
|
|
159
|
+
- **Now.** `MemoryScopeAdmissionInput` = `{ principal: string; requested: ReadonlyArray<MemoryScopeRequest>; requestedWriteScope: MemoryScopeRequest | null } | { principal: undefined; requested: ReadonlyArray<DeploymentMemoryScopeRequest>; requestedWriteScope: DeploymentMemoryScopeRequest | null }`, and `MemoryScopeAdmission` takes it. The door reads caller presence once, through `readPrincipal`: a principal name is the caller, handed as written; omitted or `""` is no caller — a request-origin read scope or write slot is refused `memory.admission_denied` before the resolver is asked (the sentence is unchanged), and a deployment-only request is put with `principal: undefined` (the key present, as before); a provided value that is no name is refused `memory.admission_denied` before the resolver (reachable only through the library entrance `admitMemoryScopes` — a task's prepare refuses it earlier as `config.invalid_argument`). The write slot's origin is read once, with the rest of `requested` (it used to be read a second time; a plain origin-stamp record answers the same either way), and the resolver is handed copies: a resolver that rewrote the origins of its input used to change the door's own later reading of them — a deployment scope it granted nothing for then stayed mounted — and now changes nothing the door decides. The resolver-absent leg reads no caller and is unchanged. Not changed here: the compliance posture resolver, consulted before admission, still receives the task's principal as given (`""` included).
|
|
160
|
+
- **The identity-absence contract** (`@contract memory.identity_absence.opaque_key`, on `isCentralAuthorityScope`; one pointer each in the scope-contract module header and on `RuleOwner`): the memory of an owner with no identity lives under an opaque, unprefixed key the deployment chooses (such as `local`), never a sentinel principal or a `user:` key (`user:local` is the key of a principal named `local`), so its authority is not central, and the engine mints no key for it; read as an owner it is `RuleOwner`'s `local-owner` arm; moving it to a principal is a re-keying of its entries (`migrateScope`), and the engine never reads the opaque name as a principal; admission authorizes by the caller, never by a layer's owner. Comments and the registry row only — no key is reserved, no value is refused for being `local`, and the sync client still syncs whatever scope a host hands it.
|
|
161
|
+
- **Hard-breaking (open to veto), three sentences.** *What breaks*: a call that builds a caller-less admission input holding a request-origin scope (read or write slot) no longer type-checks, and a task whose principal is `""` is refused `memory.admission_denied` where its request-origin org scopes used to reach the resolver (its deployment-only request now reaches the resolver with `principal: undefined` instead of `""`); absence is never spelled as a principal string on this seat, `local` included. *Who is hurt*: a host whose tests call its resolver directly with `principal: undefined` and request-origin items; a resolver that narrows on `input.principal === undefined` and then compares an item's origin with `"request"` (the comparison now has no overlap — that is the arm to delete); and a host that sends `principal: ""` with request-origin org scopes. A resolver typed against the wider earlier input is still a seat, and a destructuring one that filters by origin before it checks the principal keeps compiling, its caller-less arm now dead code. *Migration*: delete the resolver's own "principal absent" refusal arm and the cells that build the impossible shape — narrow on `input.principal === undefined`, whose arm holds deployment-origin scopes only — and send a principal name for any request that needs a tenant plane.
|
|
162
|
+
- **Consumers.** @server S-2394: `src/org-memory-admission.ts` keeps a "principal absent" arm (outcome `principal_missing`) that the type now proves unreachable, and `test/org-memory-admission.test.ts` builds the caller-less request-origin shape twice (read and write slot) — those two cells stop compiling and retire with the arm; the resolver's own source compiles unchanged (read in the server checkout and mirrored as a type cell, not compiled there); its `attributed` details lose `principal: ""` on a caller-less deployment-only request. @cli: no call of the seat in the cli source; no change. The memory-owner reading itself (an owner function that names the global layer's owner, the re-keying arc) is the server's and a later core slice; this section changes neither.
|
|
163
|
+
- **Pins.** `test/backlog900-admission-actor-seam.test.ts` (the real Runner over a File memory store, caller {name, omitted, `""`} × request {deployment only, request-origin read, request-origin write slot} × resolver {present, absent}: the caller is handed by name with every origin, a padded or non-ASCII name exactly as written; a provided value that is no name stops at the task door (`config.invalid_argument`, the resolver not asked); no caller ⇒ deployment-only reaches the resolver with `principal: undefined` and the key present, request-origin is refused before the resolver; no resolver ⇒ unchanged: deployment-only mounts and request-origin is `memory.admission_required`; through the library entrance a provided principal that is no name is refused before the resolver, and a resolver that rewrites its input's origins and grants nothing leaves the deployment scope dropped; the refusal sentence names each request-origin scope once; type cells: the caller-less arm cannot hold a request-origin scope, a narrowed resolver's "no caller but request-origin" comparison has no overlap, a wider and a destructuring resolver still compile). `test/export-surface.snapshot.json` +2 types; `docs/CONTRACT-SENTENCES.md` +1 row.
|
|
164
|
+
|
|
165
|
+
### Retirements — fifteen faces on the retirement line are deleted; sixteen more are re-windowed to 7.61.0 with their reason on the row (RL-1336, #2100, #2909; hard-breaking: fifteen, three sentences each below, open to veto; closed sets: the `loadProjectMemory` phase union −1 (`post-clear`), the prepare refusal codes −1 (`rewind.rewind_files_retired`, now `config.spec_retired_key`); exports: −4 root values (`ARTIFACT_CARD`, `MEMORY_GUIDANCE`, `CODE_SYSTEM_PROMPT`, `createWebFetchTool`); members: −1 `ImportPreview.translated`, −1 `TaskStats.costBreakdown.memoryConsolidationMicroUsd`, −1 `stats.mechanisms.finalVerifyInjected` (and the same member on `task.end`'s mechanisms summary), `CheckpointStore.listByScope` optional → required, `RunnerDeps.loadProjectMemory` return narrowed to `ProjectMemoryLoad`) (@server @cli @client-core @test @sdk)
|
|
166
|
+
|
|
167
|
+
Every row here was on `docs/RETIREMENT-LINES.json` with `retireBy: 7.59.0`; the commit that deletes a face deletes its row, so the table now holds sixteen rows, none due before 7.61.0. `gate:retirement-lines` reads 16 rows online and 35 survival claims in `src/` (11 governed by a row, 24 exempted).
|
|
168
|
+
|
|
169
|
+
- **RL-1336-rewindfiles — `TaskSpec.rewindFiles` is refused by name in both senses.** *What changed:* the key joins `RETIRED_TASK_SPEC_KEYS`; any defined value refuses prepare with `config.spec_retired_key` (a resume whose re-supplied config carries it is refused before the claim as `checkpoint.config_refused` with `detail.code: "config.spec_retired_key"`) whose sentence names the replacement — the capture sense's tolerated no-op with its `config`-phase disclosure is gone, and the restore sense's own code `rewind.rewind_files_retired` is retired with it. *Who is hurt:* @server, whose request resolver forwards `rewindFiles: true` from the HTTP body into the spec (`src/boot/resolve-spec.ts:964`): every request that still carries it now fails prepare; @sdk's `TaskRequest.rewindFiles?` (`packages/sdk/src/types.ts:591`) keeps advertising it; any consumer that branches on `rewind.rewind_files_retired` (@server's `test/resume-anchor.test.ts:148` pins it). *How to migrate:* stop forwarding the key (refuse or strip it at admission, `src/http/admission.ts:700` already reads it); capture needs no request; restore with the conversation is `resumeAt` + `restoreFiles: true`, a code-only restore is `rewindFilesTo`; read `config.spec_retired_key` where you read the retired code.
|
|
170
|
+
- **RL-1336-import-translated — `ImportPreview` has no `translated` member.** *What changed:* the always-empty array is gone from the type and from every preview `prepareCcImport` returns; an entry imports as the file writes it. *Who is hurt:* @server, whose rules-consent face imports `prepareCcImport` and `ImportPreview` (`src/rules-consent.ts:51,60`), and @sdk, which declares `translated` required (`packages/sdk/src/resources/rules.ts:183`, `spec/openapi.yaml:22587`) and pins its presence (`packages/sdk/test/s177-server-767-wire.test.ts:258`); any client rendering a "rewritten spellings" column. *How to migrate:* drop the member from the wire type (or emit `[]` from your own layer if your contract must keep it for a release); render `candidates` and `skipped` only.
|
|
171
|
+
- **RL-1336-artifact-card — the root no longer exports `ARTIFACT_CARD`.** *What changed:* the constant is deleted; the Artifact tool's card id is the string `"artifact"` in `details.type`, as it always was. *Who is hurt:* a host that imports `ARTIFACT_CARD` (none found in @server / @cli / @client-core `src`). *How to migrate:* compare `details.type === "artifact"`.
|
|
172
|
+
- **RL-1336-toolsearch-matched — ToolSearch `details` carries one list of matched names, `matches`.** *What changed:* the second list `matched` (same content) is gone from both the match and the no-match result. *Who is hurt:* a renderer reading `details.matched` (none found in the four neighbours' `src`). *How to migrate:* read `details.matches`.
|
|
173
|
+
- **RL-1336-finalverify-bool — `stats.mechanisms.finalVerifyInjected` is gone; `finalVerifyInjections` is the reading.** *What changed:* the boolean is no longer minted on `TaskResult.stats.mechanisms` nor on `task.end`'s mechanisms summary; the count, present iff at least one injection fired, stays. *Who is hurt:* @server's run-terminal projection table, which lists the key (`src/observability/run-terminal.ts:1221`), and its scan script (`scripts/tb-1249-scan.py:215,230`); dashboards that read the boolean. *How to migrate:* drop the key from the table; read `(stats.mechanisms?.finalVerifyInjections ?? 0) > 0`.
|
|
174
|
+
- **RL-1336-memory-guidance — the root no longer exports `MEMORY_GUIDANCE`.** *What changed:* the concatenation constant is deleted; its two parts `MEMORY_SAFETY` and `MEMORY_HYGIENE` stay exported (core injects none of them). *Who is hurt:* a host that composed its prompt from the one constant. *How to migrate:* `${MEMORY_SAFETY}\n\n${MEMORY_HYGIENE}` is the same text.
|
|
175
|
+
- **RL-1336-code-system-prompt — the root no longer exports `CODE_SYSTEM_PROMPT`.** *What changed:* the alias is deleted; `CODE_AGENT_PROMPT` is the one name of the code prompt (the same catalog text). *Who is hurt:* a host that imports the alias — @server's golden pin imports it (`test/prompt-assembly-golden-7512.test.ts:26,111`); no `src` import found. *How to migrate:* import `CODE_AGENT_PROMPT`.
|
|
176
|
+
- **RL-1336-consolidation-cost — `TaskStats.costBreakdown` has no `memoryConsolidationMicroUsd`.** *What changed:* the permanently-0 line is gone from the type and from every assembled breakdown (and from the delegated child's cumulative breakdown); the breakdown is `{ llmRootMicroUsd, nestedSubagentMicroUsd, compactionMicroUsd }` plus the optional lines. *Who is hurt:* @server's bench arms that build and sum it (`src/bench/s1/arms.ts:155,184,224`, `src/bench/s1/run-firm.ts:208,365`, `test/cost-taxonomy.test.ts:35`) and its run wire, @sdk whose `types.ts:2418` and `openapi.yaml:9163-9167` require it, @client-core's projection (`src/adapter/downstream/terminalToSdkResult.ts:797`, optional there). *How to migrate:* drop the member from the objects you build; a wire that must keep it for a release emits `0` from its own layer, which is what core sent.
|
|
177
|
+
- **RL-1336-post-clear-public / RL-1336-post-clear-local — the `loadProjectMemory` phase union is `"fresh" | "resume" | "post-compact"`.** *What changed:* the reserved word `post-clear`, never emitted, leaves the public `ctx.phase` union and the engine's local one. *Who is hurt:* a loader whose `switch` handles `post-clear` (@server's `src/project-memory.ts:31` declares a wider union of its own, which still accepts the narrower one). *How to migrate:* delete the arm; a session clear starts a new session, which reads `fresh`.
|
|
178
|
+
- **RL-1336-git-mark-param — `stripGitStatusUnits(text)` takes no mark.** *What changed:* the ignored second parameter is gone (internal function; not on the package root). *Who is hurt:* nobody outside the engine. *How to migrate:* none.
|
|
179
|
+
- **RL-1336-journal-reexport — the journal cap has one import path.** *What changed:* `MAX_JOURNAL_RESULT_BYTES` and `oversizeJournalResult` are no longer re-exported by the file backend module `stores/file/workflow-journal-store`; the root keeps both names (now taken from the contract module `core/workflow-journal-store`). *Who is hurt:* a deep import of the file backend module for those two names. *How to migrate:* import them from the package root.
|
|
180
|
+
- **RL-1336-checkpoint-listbyscope — `CheckpointStore.listByScope` is required.** *What changed:* the member is no longer optional; the engine calls it without an optional probe, the store contract kit still names a JavaScript backend that lacks it, and the park self-check (`probeParkRoundTrip`) now reports such a store as `row_not_enumerable` where it used to pass with the step "NOT exercised". *Who is hurt:* a host's own `CheckpointStore` implementation or wrapper that omits it — it no longer type-checks (@server's SQL store implements it; a wrapper elsewhere in your tree may not). *How to migrate:* implement it (pending rows of the scope, the `summarizeCheckpoint` projection) or forward it to the store you wrap.
|
|
181
|
+
- **RL-1336-webfetch-factory — the root no longer exports `createWebFetchTool`.** *What changed:* the second construction path is deleted; `webFetchToolSpec` handed to `spec.tools` is the one path, and the Runner wraps it with its trusted context (host floor, reminder defuse) — a product built outside a Runner never had them. *Who is hurt:* a host that mounted the defined product directly (@server's consumption ledger names it; no `src` call found); tests that execute the tool outside a Runner. *How to migrate:* hand `webFetchToolSpec(config)` to `spec.tools`; to execute it outside a Runner, `defineTool(webFetchToolSpec(config))` (core's own tests do this through one helper).
|
|
182
|
+
- **RL-1336-project-memory-bare — `RunnerDeps.loadProjectMemory` answers a `ProjectMemoryLoad`.** *What changed:* the seam's return type is `ProjectMemoryLoad | Promise<ProjectMemoryLoad>`; a bare string, `null` or any non-object is not read — it is disclosed on `onError` (phase `config`, the sentence names the shape and `{ content: null }`) and the leg runs with no project layer, exactly as when the loader throws. *Who is hurt:* @server, whose `makeLoadProjectMemory` returns `string | null | ProjectMemoryLoad` (`src/project-memory.ts:126,236-263`): its bare-string and `null` answers stop injecting and say so once per prepare; any host loader returning a string. *How to migrate:* answer `{ content: text }`, and `{ content: null }` for no project layer.
|
|
183
|
+
|
|
184
|
+
**Not retired, re-windowed 7.59.0 → 7.61.0 with the reason written on each row** (the rows stay until their carrier lands): RL-1608 ×9 (the TaskOutput tool, its env-direct factory, two catalog rows, five retired-name hints) — deleting the tool before the replacement read seats of design/1056 §2.5 (R1–R7) exist leaves five lanes with no read path; carrier = the #1608 design + split car. RL-1654 ×4 (`MemoryStore`, `consolidateScope`, `runMemoryConsolidation`, the v1 ledger reading) — the three names are one face of a store family still exported under other names, and the v1 arm sits in the locked migration's retry machinery; carrier = the #1654 design section. RL-1103 (the anchor backfill arm) — with it gone a legacy repo partition adopted by `adoptLegacyRepoDirs` refuses at its first open, so the adoption must record the anchor first. RL-1333 (the v1–v9 checkpoint ladder) — a v≤9 row carries no requirement words, so the change needs the parked-row census of the backends holding checkpoints. RL-2164 (the kind-less batch member reading) — its own condition, the server's confirmation that no stored row carries the form, is open.
|
|
185
|
+
|
|
186
|
+
- **Consumers.** @server: `resolve-spec.ts:964` (stop forwarding `rewindFiles`), `project-memory.ts` (answer `{ content }`), `bench/s1` (drop the consolidation line), `observability/run-terminal.ts:1221` (drop the `finalVerifyInjected` key), any `CheckpointStore` wrapper (add `listByScope`; `SqlCheckpointStore` already has it), the rules-consent face's `translated`, and the tests that pin the retired faces (`prompt-assembly-golden-7512`, `resume-anchor`, `cost-taxonomy`); and two requests ride the 7.60.0 pickup sheet — the parked-checkpoint census for RL-1333 and the kind-less batch-member confirmation for RL-2164. @sdk: `TaskRequest.rewindFiles?`, `costBreakdown.memoryConsolidationMicroUsd`, `ImportPreview.translated` in the types, the OpenAPI spec and two tests (`runs-supervisor-cost`, `s177-server-767-wire`). @client-core: the optional consolidation member in the SDK-result projection. @cli: no `src` read of any retired face was found (its `rewindFiles` hits are the out-of-run verb and wire-manifest notes). @test: black-box readings that pin `rewind.rewind_files_retired`, `details.matched` or the bare-string loader are now red by design.
|
|
187
|
+
- **Pins.** `test/retirement-lines-gate.test.ts` (the shipped table: every row's face present, so a row kept for a deleted face reds as STALE; the dangling-citation discriminance now reads RL-2164 / RL-1654 rows), `test/rewind-files.test.ts` and `test/prepare-file-history-transcript.test.ts` (both senses refused by name, `true` and `false`, nothing restored), `test/backlog1050-file-history-capture-off.test.ts` (the refusal sentence names the capture switch), `test/prepare-project-context-transcript.test.ts` (a bare string, `null` and a number each disclosed once, no project layer), `test/tool-disclosure.test.ts` (no `matched` on either branch), `test/final-verification.test.ts` (no `finalVerifyInjected` on the result or on `task.end`, the count is 1), `test/design252-park-selfcheck.test.ts` (a store without `listByScope` is `row_not_enumerable`; with it, `round_trip_ok`), `test/budget-readcontext-and-taxonomy.test.ts` and `test/side-call-usage-account.test.ts` (no consolidation line), `test/full-body.test.ts` (no `CODE_SYSTEM_PROMPT` on the root), `test/backlog490-cc-wildcard-import.test.ts` / `test/permission-rule-consent.test.ts` (no `translated`), `test/export-surface.snapshot.json` −4.
|
|
188
|
+
|
|
189
|
+
### A judge's refusal sentence never carries text the caller wrote — one shape for a caller's key or value, `[redacted] (N characters)` (#2888; behavior change: the wording of the declaration judges' sentences; codes unchanged; exports: none) (@server @cli)
|
|
190
|
+
|
|
191
|
+
- **Before.** The judges of a declaration quoted what the caller wrote: the `sessionMetaKey` judge its key, the request-meta judge a member's name, `readToolAxes` / `readToolFaces` the tool name and an unknown member's name, the face judge the word a closed table refused and the parameter names and list entries it could not place, the preparation door the `contentOrigin` value, an entry or a task list that was a string, a lock key outside the registry, a credential reference's kind, and every key on a refused member path. A credential pasted into the wrong field rode the sentence into logs, panels and probes; a host could only redact after the fact.
|
|
192
|
+
- **Now.** One rule for the table: a sentence says where (the declaration's own member names, a list index), why (the closed vocabulary, a kind, a count and its bound) and whose (the declarer's name — the entry's published identity, already minted into every tool name the engine mounts). Text the caller wrote — a key or a value — is shown as `callerText`: the redaction mark (`REDACTION_MARKS.whole`) and its length in code points (`[redacted] (12 characters)`), or its kind when it is no string. A closed-set refusal now lists the closed words instead of echoing the word it refused (`pathTarget.access [redacted] (5 characters) is outside the closed set (read | create | edit)`). A member path spells the declaration's member names and shows any other key in the same shape (`toolFaces.[redacted] (9 characters).pathTarget`). The mount's announcement of a face that does not fit reads the same judge, so it changes the same way.
|
|
193
|
+
- **Consumers.** @server S-2476: `src/task-mcp.ts` passes the engine's reason sentences through `redactSecrets` at `:499` only and the deployment leg's two warns (`web-admin-client/skills-mcp.ts:267/283`) not at all — with this release no engine sentence of the table carries the caller's text, so the special case can go; a pin that matched a quoted tool name, key or word in an engine sentence re-pins to the mark. @cli: a pin on one of these sentences re-pins the same way.
|
|
194
|
+
- **Pins.** `test/backlog2888-judge-sentences-withhold-caller-text.test.ts` — one cell per refusal of the table (the `sessionMetaKey` judge's four refusals and the preparation door's; the request meta's two; `toolAxes` unknown member / word / receipt fault; `toolFaces` eleven shapes; the face judge with a schema five; the door's content class, receipt path, string entry and list, lock key and credential kind): the sentinel never appears, nor a prefix of it, and the shape does. Existing sentence pins re-pinned in place.
|
|
195
|
+
|
|
196
|
+
### A peer that echoes its connection's credential into what it says about itself is read without it — one eraser, one needle (#2946; behavior change: an echoed credential is erased in a peer's account of itself, a name holding one is refused; closed sets: `ENGINE_NOTICE_CODES` +1 `mcp.credential_echoed`; exports: none) (@server @cli @client-core)
|
|
197
|
+
|
|
198
|
+
- **Before.** The request-echo eraser covered only failure text. A server that echoed the bearer it was sent into `serverInfo.version`, its instructions or a tool description, or an A2A peer that echoed it into its card, handed the credential to the status record, the model's tool card and every panel and probe downstream (server S-2476, v7.137.0 the same).
|
|
199
|
+
- **Now.** One eraser (`eraseSentCredentials`), one needle: the credential values the connection's seat answered that the withheld table holds (`PeerCarrier.credentials` — a value that names a secret, `namesASecret`: never a blank one, a placeholder word or a key shorter than eight characters, which would otherwise erase ordinary words from every description). Every remote text a successful dial or listing hands the engine — an MCP server's `serverInfo`, instructions and tool listing; an A2A peer's card — is read through it before anything bounds or neutralizes it: free text holding the needle, in any spelling the request-echo derivation gives it, is erased in place (the redaction mark); a NAME holding it is never rewritten, and neither is a tool's input schema (its structure: the property names the model sends) — the tool is not mounted (dropped through the disclosed lane, the drop record carrying the name erased), an A2A skill is not minted, an interface URL the card names is not used, a `serverInfo` record or a card name is not projected (a transport label a refusal names is free text, erased). Nothing else is taken: an account with no needle in it reads byte for byte.
|
|
200
|
+
- **The notice, three sentences.** *Who needs it*: the operator of a deployment wired to an endpoint that repeats what it is sent — its own logs and panels may hold the credential. *Who is hurt*: a consumer that pins `ENGINE_NOTICE_CODES`' cardinality (+1, nothing removed) or the operator-notice audience table. *Compensation*: `mcp.credential_echoed`, audience `operator`, `detail: { protocol: "mcp" | "a2a", server, where, sessionId, runId }`, `where` the closed set `CREDENTIAL_ECHO_SITES` (`server_info` / `instructions` / `tool_listing` / `agent_card`), never a value; once per (materialization, server, site) for MCP, once per (materialization, peer) for A2A.
|
|
201
|
+
- **The same family, the text pass (#2953).** `redactSecrets` / `redactHostLeaks` took `api_key=…` out of a text but let `apiKey=…`, `{"accessToken":"…"}` and `{"clientSecret":"…"}` through on both tiers, and the escaped form of a JSON string inside a JSON string (`\"api_key\":\"…\"`) for every name: the keyword row now starts a keyword where a name's words start — a camel hump included, the one hump `splitCamelCase` cuts the record-key view's names at — and reads its quotes escaped as well, so a name the record-key view calls a credential is taken out of a text too; a word that only spells a keyword (`hockey`, `myKeyboard=`) is still none. Pins: `test/backlog2953-camel-credential-names.test.ts` (three camel names × bare / escaped / nested × two tiers; the snake-case names unchanged; the controls; one name, one reading) and seven fixtures in `test/fixtures/secret-detect-fixtures.json` (marked tightening).
|
|
202
|
+
- **Consumers.** @server S-2476: the panel and probe faces that publish `serverInfo` and the tool listing now receive the erased account; the notice joins the operator lane's allow list if it filters by code. @cli / @client-core: a renderer of the operator notice lane gains one code.
|
|
203
|
+
- **Pins.** `test/backlog2946-credential-echo-in-metadata.test.ts` — a real Streamable HTTP MCP server and a real A2A peer on loopback, the seat answering a sentinel bearer: `serverInfo.version`, instructions and a tool description erased in place, a tool named with it not mounted and its drop record erased, one notice per site; a `serverInfo.name` holding it drops the record; the positive control reads byte for byte with no notice, and so does an account echoing a short dev key (no needle); the A2A card's description erased before its 240-character bound could cut inside the value, a skill id and the card name holding it refused; the Runner path's notice (operator, the detail above, no value).
|
|
204
|
+
|
|
205
|
+
### A seat answer the engine refuses is indexed before it is judged — the S-2463 shapes (#2868; behavior change: refused answers' credentials are withheld from every child; exports: none) (@server)
|
|
206
|
+
|
|
207
|
+
- **Before.** Since the peer seat (7.58.0), the seat's answer was judged first (`readPeerAnswer`) and only an accepted answer's credentials were taken into the withheld-value table; the release before took the credential headers in first and judged after. An answer refused for a value with a line break at its edge, a header named twice in two letter cases, or a line break inside a value therefore left its credential unindexed, and a variable of this host holding the same value reached every child (server S-2463).
|
|
208
|
+
- **Now.** One intake (`PeerCarrier`, C-R946 A): the answer's credential values are read from the answer as given — a header member by the credential vocabulary over its value as written and as the transport would send it, an environment member by the env entry reading, both lanes whichever the peer is — held, and only then judged. A blank value indexes nothing. Each value is held on its own, so one that cannot be withheld does not keep the others out (the answer is then refused after the rest were held). The header resolution (`resolveProtocolHttpHeaders`) no longer holds anything: the intake is the one place.
|
|
209
|
+
- **Pins.** `test/backlog2955-seat-answer-indexed-before-judged.test.ts` S1–S3 (one cell per S-2463 shape: refused, and the value held); `test/backlog1754-held-values.test.ts` re-pinned to the intake (the five call sites of `holdOwnCredentialValues(`; the protocol door cells drive a carrier).
|
|
210
|
+
|
|
211
|
+
### A worker variable equal to a refused request credential no longer reaches the host shell (#2955; behavior change: the 7.56 order restored; exports: none) (@server)
|
|
212
|
+
|
|
213
|
+
- **Before.** The same order as above (judge first, hold after) let a worker variable whose value equals a credential the seat answered in a refused answer reach a `Bash printenv` on the host lane (server S-2535, 7.138.0 review H5: `{ Authorization: V, authorization: V }`).
|
|
214
|
+
- **Now.** The intake above holds the refused answer's credentials first, so the variable is withheld from the child, as it was before 7.58.0; a plain variable is handed on.
|
|
215
|
+
- **Consumers.** @server S-2535: the 🚧 cell (row 12 of the real-process group D) turns green on this release (PICK7600).
|
|
216
|
+
- **Pins.** `test/backlog2955-seat-answer-indexed-before-judged.test.ts` S4 (a real dial through the public probe, a real `NodeExecutionEnv` child under `"all"`: the refused credential's worker variables do not reach the child, the control does), S5 (a member of the other lane), S6 (blank values index nothing), S7 (an accepted answer held once, at the same intake).
|
|
217
|
+
|
|
218
|
+
### A sync cursor refused on its store names two ways out and takes neither — rebind or clear (#2957; behavior narrowing: the documented answer to a store-axis refusal changes; open to veto, C-R(随发车帖); exports: none) (@server)
|
|
219
|
+
|
|
220
|
+
- **Before.** #2836 (7.59.0) refused a cursor bound to another store — or to none — and named one answer for every refusal: run the round from no cursor. A host that took it after a store moved re-converged from an empty baseline: an entry deleted on either side since the last completed round came back from the other side, and no conflict was reported.
|
|
221
|
+
- **Now.** The store-axis refusal (`config.memory_sync_cursor_mismatch`, the same judge and code) names two ways out and what each costs, and the engine takes neither: *rebind* — when this store holds the entries the baseline was taken over (the same store moved to another root), persist the cursor with `store` set to this store's identity (`memorySyncStoreOf`) and sync again; *clear* — delete the cursor and sync from none, accepting that an entry deleted on either side since the last completed round comes back. A cursor with no store binding (written before cursors carried one) reads the same sentence. A scope mismatch names the partition's own cursor instead (a partition key, not a binding); a peer mismatch names its own two ways out (#2968).
|
|
222
|
+
- **Behavior narrowing, three sentences (open to veto).** *Who needs it*: a deployment whose sync layer's store moved, which must not have its deletes resurrected without being told. *Who is hurt*: a host that answers every `config.memory_sync_cursor_mismatch` by running from no cursor — @server's layer executor (`src/memory-sync-client.ts`, the `memory_sync_cursor_rebound` arm) — which now has to pick a way out per layer, as it already does for a cursor written before the binding (its `memory_sync_cursor_predates_store` arm). *Compensation*: the refusal is raised before any read or transport call, so a layer that stops on it loses nothing; rebind is one member set from `memorySyncStoreOf` (root export, #2956), and the two arms of the server's executor read one sentence.
|
|
223
|
+
- **Pins.** `test/backlog2957-sync-store-move-refused.test.ts` — a store moved whole to another root with a local and a central delete since the last round: the old cursor is refused with zero calls on the wire and the sentence names rebind and clear; rebind sends the local delete and lands the central one (neither comes back); clear costs what it says (no delete sent, the local delete undone); the unbound cursor reads the same way out; a scope mismatch names the partition's own cursor. `test/backlog2836-sync-cursor-store-binding.test.ts` comments re-worded (the cells unchanged).
|
|
224
|
+
|
|
225
|
+
### An MCP server can be mounted on a pipe the host supplies — `transport: { kind: "host" }` plus the leg's host seat (`RunInternals.mcpHostSeats`), through the one MCP pipeline every server uses; a seat that did not hand a request on is one failure word, `host_refused` (#2841, design/2825 §3 Q1-B, C-R932 + addendum 1; hard-breaking: two closed sets widen, open to veto)
|
|
226
|
+
|
|
227
|
+
- **Before.** A host that carries MCP over its own channel (a device bridge) had no mount: it could stand up a loopback HTTP MCP server per leg — where "the request never left" could only read as an HTTP status (`unknown`) or a JSON-RPC error (`yes`) — or pre-fill the exported connection pool under a stdio / http declaration that was not the connection's truth.
|
|
228
|
+
- **Now.** A declaration `{ name, transport: { kind: "host" } }` (no other transport member; no `elicitation`) dials through `RunInternals.mcpHostSeats.get(name)` — an `McpHostSeat` with one method, `request("tools/list" | "tools/call", params, signal)`. The engine's one adapter answers `initialize` itself (server name = the declaration's `name`, version `""` = not declared, capabilities `tools` only, no instructions), hands list / call to the seat with the request's own signal (aborted by the engine's abort, timeout or idle watchdog, and by the connection's close), drops an answer that arrives after its request was cancelled, and refuses any other method without handing it on. Listed `_meta`, the call's `_meta` (`sema/toolUseId`, the request meta, the session key), the intake, the manifest row and `tool_end` are the ones a stdio / http server gets. A seat that throws `McpHostSeatFailure({ delivered: "no", condition })` ⇒ `host_refused` / `delivered: "no"` / no liveness observation, the line "was not sent … sending it again is safe"; `{ delivered: "unknown", condition }` (or any other throw, in the engine's own words) ⇒ `unknown` / `unknown`, the outcome-unknown line and, for a write-capable tool, the verify-first warning; the remote's own `{ error }` ⇒ `protocol` / `yes`. A host seat's connection never enters the run tree's pool. A delegated child is handed the seats of the host servers it inherits; a retained child's snapshot keeps none and each wake hands the waker's (`createSubagentResume({ currentMcpHostSeats })`, filled by SendMessage and the steer-handle resume); a checkpoint resume reads the row from its config and the seat from its internals. No seat for a host declaration ⇒ that server fails its dial (`invalid_config` / `no`, `config.mcp_host_seat_missing`), siblings mount; a seat no host declaration names ⇒ one `config.mcp_host_seat_undeclared` operator line, nothing refused.
|
|
229
|
+
- **Hard-breaking (open to veto).** *What changed:* `McpServerSpec.transport` gains a third arm `{ kind: "host" }` (`MCP_TRANSPORT_KINDS` = `stdio` | `http` | `host`) and `McpFailureKind` gains `host_refused` (wire: `mcp[].errorCode`, `tool_end.errorCode`, a request error's `details.code`); `unknown` widens to "or the host seat cannot tell how the request ended". *Who is hurt:* a consumer that switches exhaustively over `transport.kind` or over the failure words fails to compile, and a runtime closed table sends the new words to its default arm. *How to migrate:* add the `host` arm (it names no command or url — render it as a host-supplied pipe) and a `host_refused` row (`delivered: "no"`, no liveness: not sent by the host, safe to retry); read `unknown` with its widened definition. @server (S-2426: implement the seat, hand it on every entry's internals, keep the hub's verify-first tail out of `condition` — the engine adds the tail once) @client-core @cli (projection / rendering of both words).
|
|
230
|
+
- **Closed sets.** `MCP_FAILURE_KINDS` +1 `host_refused` (delivery `"no"`, liveness none); new frozen list `MCP_TRANSPORT_KINDS` (lockstep with the union).
|
|
231
|
+
- **Exports.** +2 root values `McpHostSeatFailure`, `MCP_TRANSPORT_KINDS`; +4 root types `McpHostSeat`, `McpHostSeatMethod`, `McpHostSeatAnswer`, `McpTransportKind`; `RunInternals.mcpHostSeats`; `materializeMcpTools` +1 trailing parameter (`hostSeats`).
|
|
232
|
+
- **Pins.** `test/backlog2841-host-seat.test.ts` (real Runner: mount + list/call only + the call id in `_meta`; a refused listing ⇒ failed / host_refused / no, no liveness; an unknown call ⇒ unknown / unknown, the warning once for the write-class tool only; the remote's error ⇒ protocol / yes; a child dials the parent's seat itself; a retained wake uses the waker's seat, never the spawn's; a checkpoint resume dials the resume's seat; an undeclared seat ⇒ one line. Adapter under the SDK client: 1 000 failures leave no handler; an answer the protocol cannot carry (six shapes), an answer rewritten after it was returned, and a thrown value the engine cannot inspect each settle at once as `unknown` with no handler left and nothing unhandled; abort / timeout / close reach the seat's signal, a late answer is dropped; a method outside list / call is not handed on; a malformed declaration beside a seat of its name does not end the prepare. The door and the library entrance refuse a host transport with another member or with elicitation; no seat ⇒ that server fails, siblings mount; the probe reads it failed; a remote's error shaped like the verdict is `protocol`; the pre-filled pool path as it stands (#2843)).
|
|
233
|
+
- **Known limits.** Requests only (CC's SDK servers carry any message both ways) — no progress notifications, so a host call sits in the 5-minute idle bucket; the pre-filled pool path still leases a host-made connection and a re-dial dials its declaration (#2843 decides). C-R986 has ruled: from 7.61.0 a host-made connection entering the exported pool is refused loudly (`config.*` +1, with car-2929-fix1); do not rely on this path in 7.60.0.
|
|
234
|
+
|
|
235
|
+
### A Model the engine is handed is read once into a frozen snapshot, judged there, and only the snapshot is read afterwards — the model door at every seat, the catalog door at `new Runner` / `swapDeps`, `modelOriginOf(snapshot)` for a host's own identity lookups (#2846, with #2781 / #2778; design 2772-2781, C-R933 and its addenda 1 / 2; behavior narrowing; hard-breaking: three sentences below, open to veto; closed sets: none; exports: +1 root value) (@server @client-core @cli)
|
|
236
|
+
|
|
237
|
+
- **Before.** One resolution read the caller's Model object two to four times — the role-seat test, the identity judgment, a `select`'s judgment of every candidate and of the pick, the tier default's re-judgment — and each read ran the caller's code on the live object. An object whose members came from its prototype and threw read as an empty role record and fell to the default without a word; an accessor that deleted `id` between two judgments passed both; a Proxy throwing on `cost` surfaced from a `select` as a bare `TypeError`; a getter inside `cost` threw past the judgment. A catalog entry was judged only when a task named it, a tier binding a catalog key shadowed was never judged, the classifier seat's tier-relative pick handed on an entry no judgment read (#2778), and a degrading brain's fallback was deduplicated by an `id` read before the one it was dispatched with.
|
|
238
|
+
- **Now.** A Model is received by the model door wherever it is written — `TaskSpec.model`, a role seat, a role record's `model`, a tier binding, a catalog entry, a degrading brain's fallback — through the engine's one receipt in the declaration mode: a plain record, every own member read once, every level copied and frozen; then judged on the copy: every member one of the `Model` contract's (a retired one keeps its own `config.deps_retired_key`), a non-empty string `id`, a string `api`. Every refusal is `config.unknown_role` / `not_a_model_ref` naming the seat (the code and reason unchanged; the sentence now names what could not be read). The code does change for a member value the receipt cannot copy (an object of another prototype, a function, a bigint, a symbol) that a member's own judge refused before: on a task's model, a `Model.extraBody` (`config.invalid_argument`) or `Model.promptTraits` (`config.prompt_trait_unknown`) of that kind is now refused at the seat by the model door's code first (a host brain's own request-time model spec, no seat of the door, still meets `extraBody`'s judge). The catalog door receives a catalog generation whole where a Runner takes one — `new Runner` and `swapDeps` (atomic, as before) — every entry and every tier binding (a shadowed one included), then expands the bindings over the received catalog and freezes it. Every read of a catalog entry hands its snapshot (an entry of a catalog a host built and hands an exported function is received at that read). A `select` reads frozen data. A role map stays the caller's between operations (a deployment may change it in place) and is read once per operation — a task's resolution, a role's model if set, the preset's role base, the classifier seat, the deployment's subagent tier — so a branch and the resolution it takes read the same copy.
|
|
239
|
+
- **`headers` is a read port.** An own accessor at `Model.headers` is never called by the receipt: the snapshot's `headers` calls the caller's getter at each read — each request — so a credential the deployment rotates without a restart is read at the next request, and a getter that throws throws at that request, not at construction. A data `headers` is received like any other member.
|
|
240
|
+
- **Identity.** A snapshot is a fixed point (handed back as itself), and snapshots are interned by origin and content: the same unchanged object received again (a swap that keeps it, a tool-local roster that shares it) is the same snapshot, so "this word names the very model the child was seated with" answers as before; an object changed in place and received again is a new snapshot. The engine hands back its snapshots, never the caller's objects: `modelOriginOf(snapshot)` (root export) is the object a snapshot was received from; a value the engine never received is its own origin.
|
|
241
|
+
- **Hard-breaking, open to veto (@server @client-core @cli).** ① A Model that is a Proxy, a class instance or an `Object.create(…)` value, or that holds a member the receipt cannot copy (a function, a getter that throws, an object of another prototype), ran as long as its members could be read; it is now refused at the seat it is written. Who needs it: every reader that judged a Model and then used it (what was judged is what is used). Who is hurt: a host building Models from classes, Proxies or prototypes, and test fixtures doing the same (server's Models are object literals). Compensation: build the Model as a plain record (`{ ...instance }`). ② A catalog entry or tier binding that is no Model was refused only when a task first named it; it is now refused when the catalog is received (`new Runner`, `swapDeps`), naming `RunnerDeps.models.<key>` / `swapDeps.models.<key>` / `tiers.<name>`. Who is hurt: a deployment carrying a broken entry nothing selects (it now fails at boot or at the swap); server's entry judge drops such entries before they reach the engine. Compensation: remove or fix the entry the refusal names. ③ A Model member outside the contract was ignored; it is now refused. Who is hurt: a JS host or fixture carrying a key of its own on the Model. Compensation: put a provider's own parameters in `Model.params`. And one reading: a host that compares a Model the engine returns with its own Model objects by `===` (server: the `{ select }` default's catalog name lookup, the consolidation seat's billing comparison) reads `modelOriginOf(model)` instead.
|
|
242
|
+
- **Not in this change.** `roles` is not a hot-swappable seat (#2845, its three preconditions are a separate cut); between operations the role map is the caller's live object, as before.
|
|
243
|
+
- **Pins.** `test/backlog2846-model-door.test.ts` (five hostile forms × nine seats through the real Runner where the seat is the Runner's; the accessor that deletes `id`; a never-named entry; the member set; fixed point, interning in four forms and `modelOriginOf`; the classifier role read once; the `headers` read port, its poison and a real degrading chain rotating per hop; the tier marks; the tier-relative pick; the workflow allowlist).
|
|
244
|
+
|
|
245
|
+
### A store's constructor options and the retention door's input are read once, by the receipt law — no store keeps the caller's bag, and a TTL, sweep interval, eviction word, durability word or size bound that had no exit is refused (#2847, design 2772-2781 §1.3 / §1.4; behavior narrowing; hard-breaking: one reading, three sentences below, open to veto; closed sets: none; exports: none) (@server @client-core)
|
|
246
|
+
|
|
247
|
+
- **Before.** The bundled stores read their options off the caller's bag as they went: `InMemoryCheckpointStore` read its judge twice (once for the judgment, once for the `fence` declaration), `TtlSessionStore` read `repo` three times, re-read `opts.hooks` at every deletion and held `placements` as the caller's object, `InMemoryToolResultStore` held the caller's bag and read its bound at every write, `FileStorageBackend` asked a `retention` presence through the `in` trap, read three options twice and spread three nested records off the caller's objects. A getter that threw was a bare throw; a Proxy ran its traps; `defaultTtlDays: "abc"` never expired a session, a negative TTL expired every one, `evict: "nuke"` read as `forget`, `maxTotalChars: "abc"` read as unbounded. `assertRetentionCapability` / `assertRetentionWords` read `policy.maxAgeDays` two or three times and each store item twice.
|
|
248
|
+
- **Now.** Every bundled store — `InMemoryCheckpointStore`, `TtlSessionStore`, `InMemoryToolResultStore`, `FileStorageBackend` and each File store it builds (`FileCheckpointStore`, `FileSessionRepo`, `FileMemoryStore`, `FileToolResultStore`, `FileSessionPolicyStore`, `FileWorkflowJournalStore`, `FileUsageWindowStore`, `FileBackgroundAgentStore`, `FileMailboxStore`, `FileRosterStore`, `FileFileHistoryStore`) — receives its options through the options door (the receipt law: a plain record, every member read once; `config.invalid_argument`) and reads them only off that copy; a nested record is received where it is read; faces (a repo, an embedder, a hooks object, a judge) are kept as they are and called as they are. `TtlSessionStore` calls its deletion hook on the hooks object read at construction and holds `placements` as a frozen copy. The retention door receives its input bag, its policy (a receipt fault is `config.retention_policy`) and each store item once; a store is a face, its `retention` read once where it is judged (on its prototype too) — a getter that throws is `config.retention_capability`, as the executor's members already were. Refused, `config.invalid_argument`: `defaultTtlDays` not a finite non-negative number, `sweepIntervalMs` not a finite number, `evict` outside `delete` / `forget`, `durability` (and `placements.subagent.durability`) outside `durable` / `process-local`, `maxTotalChars` not a number.
|
|
249
|
+
- **Hard-breaking, open to veto (@server @client-core).** What changed: an options bag that is a Proxy, a class instance or an `Object.create(…)` value — and a nested options record of `FileStorageBackend` of those shapes — was read through; it is refused. Who is hurt: a host that builds store options from a class or wraps them in a Proxy, and one passing one of the bad values above (it ran with the silent reading). What to do: hand a plain record (server builds every store's options as object literals); write the value in its domain.
|
|
250
|
+
- **Pins.** `test/backlog2847-store-options-door.test.ts` (per store: a getter that throws, a Proxy that must not be asked, a class instance; an accessor that rewrites another option while read; the bound not held from the caller's bag; the judge read once with its `fence`; the hooks face read once; the placements copy; eleven bad values and their controls; the retention input: a Proxy list, an item getter, a store's prototype declaration admitted and one that throws refused, a policy read once, a Proxy policy).
|
|
251
|
+
|
|
252
|
+
### A host that takes a peer seat's answer at its own door reads it with the engine's own reader — `readPeerAnswer` is on the package root (#2863; behavior narrowing: none; hard-breaking: none; closed sets: none; exports: +1 root value, +2 root types; members: none) (@server)
|
|
253
|
+
|
|
254
|
+
- **Before.** The reader of a seat's answer (the kind and members, the lane's own member only, header and variable names, no line break or NUL in a value, `expiresAt`, the `authorizeUrl` law) lived in the leaf module; the package root exported the five answer types but not the function, so a deployment's intake gate that wanted to refuse a bad answer before dialing had to write the rules a second time, and a bad name could only fail loudly at the dial.
|
|
255
|
+
- **Now.** `readPeerAnswer(raw, lane)` is a root export, with `PeerLane` and `CarriedPieces` (its parameter and result types). It is the very function the engine's send runs: `{ carry }` (frozen pieces and their digest), `{ unauthorized }` (the seat's validated URL, if any) or `{ problem }` (names a member, never a value). The root name is the leaf's function (`===`), and the problem it returns is the sentence a failed send carries.
|
|
256
|
+
- **Consumers.** exports +1 value, +2 types, nothing else changes. @server: the 7.138.0 acceptance gate reads an answer with this function instead of its own copy of the rules; delete the copy.
|
|
257
|
+
- **Pins.** `test/backlog2863-small-root-exports.test.ts` P1–P4 (identity; sixteen refusals each naming the member and none echoing the value; the pieces an accepted answer gives are the pieces a real `PeerCarrier` send carries, same digest; a refused answer's problem is the failed send's text). Smoke decision: `readPeerAnswer` in `SMOKE_CHECKED_EXPORTS`.
|
|
258
|
+
|
|
259
|
+
### An A2A peer's failed row carries the failure record an MCP server's failed status carries — `errorCode` from the same closed set, `delivered`, `authorization` — read by one classifier and written by one row writer (#2865; behavior narrowing: none; hard-breaking: none; closed sets: none new — `MCP_FAILURE_KINDS` is now read by a second protocol; exports: +1 root type (`McpFailureFields`); members: +4 optional on `A2aPeerStatus` and on a failed `A2aRefreshResult`) (@server @cli @client-core)
|
|
260
|
+
|
|
261
|
+
- **Before.** A failed A2A peer row had `name`, `status` and `error` only, while the same seat refusal on an MCP server read `credential_unavailable` (or `unauthorized`) with `delivered: "no"` on the status, the manifest row and `tool_end`: one fact, two protocols, two readings — a consumer could promise "the same word on every face" for MCP only.
|
|
262
|
+
- **Now.** A peer whose materialization (or whose refresh) threw gets `errorCode`, `delivered` and, for `unauthorized`, `authorization` (`{ reason: "none", authorizeUrl }` for a seat that answered `unauthorized`), minted by `classifyMcpFailure` at the dial and spread by `failureFields` — the same two functions an MCP status row uses, so a member the record gains rides both. A seat that throws, times out or answers what the engine cannot carry is `credential_unavailable`; a card naming an endpoint outside the declared origins is `invalid_config`; a refused connection is `connect_refused`. **Stated reading:** an error the A2A client itself raises for a non-2xx status or a JSON-RPC error carries no structure the classifier reads, so it reads `unknown` (delivered `no` at the dial) — `error` stays the text to show, never the field to key on. A ready row, a successful refresh entry and the refresh entry for an undeclared peer name (nothing was attempted) carry none of the members.
|
|
263
|
+
- **Consumers.** members +4 optional on `A2aPeerStatus` / `A2aRefreshResult`, present iff the row records a thrown failure; `McpFailureFields` joins the root types. @server: the "same word on three faces" promise can cover A2A rows for the seat refusals; @cli @client-core: a roster that already keys on an MCP status's `errorCode` reads A2A rows the same way.
|
|
264
|
+
- **Pins.** `test/backlog2865-a2a-failure-code.test.ts` (three seat refusals on a real loopback card peer, each compared with the MCP status of the same seat — equal records; invalid_config, connect_refused, the stated `unknown`; a ready row has no member; every word is in `MCP_FAILURE_KINDS` and `authorization` rides `unauthorized` only; the refresh receipt's failed, refreshed and undeclared entries).
|
|
265
|
+
|
|
266
|
+
### The redaction mark table is a root export and frozen — `REDACTION_MARKS` (#2887; behavior narrowing: the table is frozen (a write throws in strict code); hard-breaking: none; closed sets: none; exports: +1 root value; members: none) (@server)
|
|
267
|
+
|
|
268
|
+
- **Before.** The root carried only the bare mark (`REDACTION_MARK`); the three shape marks (`[redacted-credentials]`, `[redacted-url]`, `[redacted-path]`) were spelled by hosts that needed to tell which shape the engine withheld — a second copy of strings the engine's passes read from one table.
|
|
269
|
+
- **Now.** `REDACTION_MARKS` (`whole`, `credentials`, `url`, `path`) is exported from the root and is `Object.freeze`d: every pass reads it at call time, so a writable exported table would let a host change what the engine writes. `REDACTION_MARK` is the table's `whole`.
|
|
270
|
+
- **Consumers.** exports +1 value. @server: delete the hand-written marks in the workflow notify journal and read the table.
|
|
271
|
+
- **Pins.** `test/backlog2863-small-root-exports.test.ts` M1–M4 (identity with the leaf and four spellings, frozen; each shape's spelling is what `redactSecrets` / `redactHostLeaks` write for that shape; every write, delete and add on the table throws and the engine's output does not move). Smoke decision: a presence row and an identity row (`SMOKE_IDENTITY_EXPORTS`, which also asserts frozen).
|
|
272
|
+
|
|
273
|
+
### A store twin outside the package folds a rule-store sync-join delta with the engine's own landing pipeline — `applySyncJoin` and `RuleSyncJoinBase` are root exports (#2831; behavior narrowing: none; hard-breaking: none; closed sets: none; exports: +1 root value, +1 root type; members: none) (@server)
|
|
274
|
+
|
|
275
|
+
- **Before.** `RuleWriteDelta` exported the `sync-join` arm "for out-of-repo store twins" and the declaration said `applySyncJoin` was for them, but only the function's own module exported it, and the package exposes no deep path: a SQL backend meeting the arm could only refuse it.
|
|
276
|
+
- **Now.** `applySyncJoin(current, delta, nowMs)` and the type of the current raw facts it takes and returns (`RuleSyncJoinBase`) are exported from the root — the function both bundled stores run in their write step, with its refusals and drops (a tombstone naming no observed add refuses the whole delta; an inbound record claiming this replica's actor above its counter is dropped) unchanged.
|
|
277
|
+
- **Consumers.** exports +1 value, +1 type. @server: the SQL rule store can implement the `sync-join` arm with it and stop refusing.
|
|
278
|
+
- **Pins.** `test/backlog2863-small-root-exports.test.ts` J1–J5 (identity with the leaf; an inbound rule lands beside the current one; the whole-delta refusal for a tombstone with no observed add reaches the twin; a delta of another kind is refused by name). Smoke decision: `applySyncJoin` in `SMOKE_CHECKED_EXPORTS`.
|
|
279
|
+
|
|
280
|
+
### A session's offloaded tool results can be enumerated for a move — `ToolResultStore.listBySession` on the memory, file and example Postgres stores, with a contract-kit leg (#2894; behavior narrowing: none; hard-breaking: none; closed sets: the contract kit's optional-member report word `member` +1 (`"listBySession"`); exports: +2 root types; members: +1 optional on `ToolResultStore`; the file backend's `*.owner.json` record gains a `ref` member) (@server @client-core)
|
|
281
|
+
|
|
282
|
+
- **Before.** A store had `put`, `get`, `ownerOf` and the sweep `deleteBySession`, and nothing that named what a session owns: the results a transcript points at by reference could not leave the store they were offloaded to, so a session moved to another store read references it could not dereference.
|
|
283
|
+
- **Now.** `listBySession?(sessionId)` answers `{ entries: [{ ref, provenance }], unattributable, unaddressable }`, selected exactly as `deleteBySession` selects: by the owner recorded at the winning write, never by parsing the ref, `taskId` ignored in the match (the entry's `provenance` keeps the one recorded), an unowned entry never listed and counted in `unattributable` (store-wide, the figure a sweep reports). There is no second content path: the bytes are read with `get` (bounded slices) and written to the other store with `put(ref, content, entry.provenance)`, whose write-once election makes a repeated move a no-op and a ref already owned by a different owner a typed refusal. No order is promised. The scope wrapper does not forward the member, as it does not forward the sweep. The file backend's folded file names are a digest of the ref, so its owner record now states the ref (`{ sessionId, taskId?, ref }`; a reader that ignores members it does not know — this version's, unchanged since 5.28.0 — reads it as before).
|
|
284
|
+
- **Reading the two counts.** `unattributable` is rows no session can claim (store-wide); `unaddressable` is one thing only: rows this session owns that were written **before** the record carried the ref (file backend, versions before this one) — their ref cannot be recovered from a digest, so they are counted and not listed (never under a guessed ref); they are still deleted by the sweep, so `entries.length + unaddressable` is what a sweep of the session then deletes. A store whose rows were all written by this version or later reports `unaddressable === 0` for every ref form; it is not a second kind of entry and there is no migration for old records. A move that must be complete should check `unaddressable === 0`.
|
|
285
|
+
- **Consumers.** members +1 optional on `ToolResultStore` (implementers are not broken); `ToolResultSessionListing` / `ToolResultListedEntry` join the root types. The contract kit's `onOptionalMember` report word widens from `"deleteBySession"` to `"deleteBySession" | "listBySession"`: a caller that annotated its callback with the narrower literal type needs the wider one (an inferred callback is unaffected). @server: your `toolResultStoreContract` call sites, and the session-sync manifest can include the external results of a session (list, then `get`/`put`); @client-core: the orchestration of that move reads the two counts above. Out of scope here: a fork to a new session id does not carry offloaded results, and the orchestration.
|
|
286
|
+
- **Pins.** `test/backlog2894-tool-result-list-by-session.test.ts` (L: a session moved between two stores through the listing alone on memory and file — bytes, owners, idempotent repeat, typed refusal, other session's and unowned rows stay, listing = what the sweep deletes; F: the file layout — ref read from the record for folded names, a record without the member unaddressable and still swept, a record naming a ref stored elsewhere not believed, identity-named entries, damage and owner-less content unattributable, an owner record whose content an interrupted sweep removed listed as the sweep counts it, seven ref forms all listed with `unaddressable === 0`; W: the scope wrapper) and the contract kit's new optional leg run on all three bundled backends (`test/cross-backend-shared.ts` reports `verified`).
|
|
287
|
+
|
|
288
|
+
### The file checkpoint ledger's event kinds are one exported closed set, and a data root's ledger reads with the store's own fold and no store — `CHECKPOINT_LEDGER_EVENT_KINDS`, `readCheckpointLedger` (#2832; behavior narrowing: none; hard-breaking: none; closed sets: one new, `CheckpointLedgerEventKind` (7 words); exports: +2 root values, +3 root types) (@server)
|
|
289
|
+
|
|
290
|
+
- **Before.** The seven event kinds the file checkpoint store folds out of `checkpoints.jsonl` (`put`, `resolve`, `reopen`, `execution`, `expire`, `delete`, `steer_append`) lived in a private registry, and the fold ran only inside the store, behind the ledger directory's writer fence. A program that wanted to know what a data root's ledger held without opening the store (the server's drain check) copied the kinds and wrote its own fold. Its copy had six kinds; `delete` has been a seventh since 7.56.0, so the first `delete` line in a ledger counted as an event nobody understood.
|
|
291
|
+
- **Now.** `CHECKPOINT_LEDGER_EVENT_KINDS` (frozen, seven words) is the one list: the store's discriminator fence reads it, and it is total over the event union both ways at compile time (`CheckpointLedgerKindsAreTheEventUnion`). `readCheckpointLedger(root, { onCorruptRead? })` replays snapshot and ledger through the store's own fold — `applyCheckpointEvent` behind the same fence, via `replayLedger`, the one function the authority's own bootstrap now runs after taking its fence — and answers `{ settled: true, rows: ReadonlyMap<token, Checkpoint>, events }`. It takes no writer fence (`checkpoints/LOCK` is neither created nor consulted: a live store keeps its directory, a dead owner's fence is not pruned), opens no append handle and creates nothing (a root with no ledger reads as no rows and the directory stays absent). A kind outside the list refuses the read as it refuses the store's replay (`checkpoint.unsupported_version`, `detail.reason` `ledger_event_unknown`); an adoption in flight refuses it (`adoption_in_flight`). Beside a compacting writer the pair is bracketed by the snapshot's version: a snapshot replaced between the two reads is redone, at most three times, and a directory that will not hold still answers `{ settled: false }` — never the last read.
|
|
292
|
+
- **Closed sets.** New `CHECKPOINT_LEDGER_EVENT_KINDS` / `CheckpointLedgerEventKind` (registered, `docs/CLOSED-SETS.md`); no existing set moves.
|
|
293
|
+
- **Consumers.** exports +2 values (`CHECKPOINT_LEDGER_EVENT_KINDS`, `readCheckpointLedger`), +3 types (`CheckpointLedgerEventKind`, `CheckpointLedgerReading`, `ReadCheckpointLedgerOptions`); nothing else changes. @server: in `scripts/drain-check-local.mjs` delete the hand-copied `KNOWN_LEDGER_EVENTS` and the fold; call `readCheckpointLedger(root, { onCorruptRead })`, count `pending` off `rows`, take `corrupt` from the sink, read `settled: false` as your existing "files kept changing" answer and a thrown refusal as rc 2.
|
|
294
|
+
- **Pins.** `test/backlog2832-checkpoint-ledger-reader.test.ts` (A: the seven words, frozen, in the root, each admitted by reader and store and the retired `steer` refused; B: a six-word ledger reads, a `delete` removes its row and a snapshot row too, the rows equal a real store's after real operations; C: a root with no ledger creates nothing, a live store's fence is neither contended with nor disturbed, a dead owner's fence is not pruned; D: unknown kind / adoption in flight refuse like the store, damage reaches the sink; E: a snapshot replaced under the read is redone and never served, three replacements yield `settled: false`).
|
|
295
|
+
- **Known limits.** The reading is a view at one instant, not a lease: a live store may resolve a row a moment later.
|
|
296
|
+
|
|
297
|
+
### A task whose role chain supplies no model is refused with the roles family's code — `config.unknown_role` with `detail { field, reason: "no_model_for_role" }` — instead of a bare `Error` (#2833; hard-breaking, open to veto: type only; behavior narrowing: the refusal gains a code and a detail, its sentence is unchanged; closed sets: `CheckpointErrorReason` +1 (`no_model_for_role`, 31 → 32); exports: none) (@server @client-core)
|
|
298
|
+
|
|
299
|
+
- **Before.** A task that names no model, whose requested role and every role down its fallback chain supply none, ended `resolveTaskModel` in `throw new Error('No model for role "…": …')`: no `code`, no `detail`. Every other refusal of that family — a word the catalog does not hold, a value that is no model reference, a role word outside the vocabulary — was already `config.unknown_role` with `detail { field, reason }`, so a host telling a caller's configuration fault (400) from an engine fault (500) matched the sentence's opening words for this one arm, and the run's terminal carried the message alone.
|
|
300
|
+
- **Now.** The arm is the family's fourth: the one constructor (`modelBindingRefusal`) builds `config.unknown_role` with `detail { field: "roles.<requested role>", reason: "no_model_for_role" }` (`roles.default` for a task that names no role); the sentence is unchanged, so a text match still holds. A fresh run's terminal states it as every sibling arm does (`terminal.code`, `terminal.detail.detail.{ field, reason }`); a seat that names a word the catalog does not hold still wins with its own `unknown_model_ref`.
|
|
301
|
+
- **Hard-breaking (type only, open to veto).** *What changed:* the closed set `CheckpointErrorReason` gains `no_model_for_role`, and a refusal that had no `code` has one. *Who is hurt:* a host or a backend that keeps an exhaustive table over the type (`Record<CheckpointErrorReason, …>`, a `switch` ending in a `never` default) is tsc-red until it places the word; a consumer that treated a failed terminal with no `code` and this sentence as an engine fault now sees a caller's configuration fault. *Compensation:* place the word beside `unknown_model_ref` (same disposition: the caller's configuration, fix the roles or name a model); read `code` / `detail.reason`, not the sentence — the sentence is unchanged, so nothing is lost while you move.
|
|
302
|
+
- **Closed sets.** `CheckpointErrorReason` +1, `no_model_for_role` (31 → 32; `docs/CLOSED-SETS.md`, `docs/INTEGRATION-CORE.md`).
|
|
303
|
+
- **Consumers.** @server: `side-query.ts` classifies the two arms of this refusal by the sentence's English prefix; read `code` (`config.unknown_role`, with `detail.reason` where you need the arm) for both, and retire the prefix table. @client-core: a failed terminal with `code: "config.unknown_role"` now also arrives for a task that named no model, with the `coded` account its siblings carry.
|
|
304
|
+
- **Pins.** `test/backlog2833-no-model-for-role.test.ts` (A: a fresh run with no model — `failed` / `config.unknown_role` and the `coded` account on the result, the done event and the resolved result, the seat the requested role's; B: the direct throw carries code and pair and keeps its opening words; C: an unheld word still wins with `unknown_model_ref`, a bound role runs; D: the set and the registry name the word).
|
|
305
|
+
|
|
306
|
+
### `delegation.transcript_integrity` is announced only where transcript durability is declared — the `full` subagent transcript tier — and is no longer minted under `rows` (#2919; behavior narrowing: one notice stops being minted on one tier; hard-breaking: none; closed sets: none; exports: none) (@server)
|
|
307
|
+
|
|
308
|
+
- **Before.** The notice says a durable agent row binds a transcript session the session store attests gone — "the declared transcript durability is being contradicted" — and it was minted on every deployment that kept agent rows, whatever the deployment declared. Under `rows` (rows and terminal snapshots survive a restart, transcripts follow a process-local store's fate) a gone transcript is the declared fate, not a contradiction: the notice was false there, and a deployment on that tier met it for each agent it read after a restart.
|
|
309
|
+
- **Now.** The three sites that meet a gone transcript — SendMessage's backlog-drain preflight, SendMessage's revival preflight and AgentTranscript's durable leg — hand the announcer the tier their mount derived (`resolveSubagentTranscriptTier`, the derivation the wiring manifest's `fleet.subagentTranscripts` rides), and the announcer asks one predicate, `declaresTranscriptDurability` (`full` only). `full`: unchanged (once per (scope, handle) per process). `rows` / `none`: no notice, and a `rows` call does not spend the once-per-handle latch. The per-call refusals the model reads (`resume.session_not_found`, `not_found`, the `queue_full` drain sentence) are unchanged on every tier. `createAgentTranscriptTool` now derives its tier at mount from its own seats, as the SendMessage mount already did: a `sessions.placements.subagent.durability` that is no `StoreDurability` is refused there (`config.store_durability_invalid`), as the prepare-time manifest refuses it.
|
|
310
|
+
- **Consumers.** @server: expect no `delegation.transcript_integrity` from a deployment whose session store declares `process-local` subagent placement (or declares none); one from a `full` deployment is now a true statement of a contradiction — alert on it.
|
|
311
|
+
- **Pins.** `test/backlog2919-transcript-integrity-tier.test.ts` (A: the predicate over the three tiers, the announcer per tier, the latch not spent under `rows`; B / C / D: each of the three sites at `full` (one notice, the refusal intact) and `rows` (no notice, the same refusal byte for byte); E: the first-party mount through `prepareDelegationSurface` with the real factories — the notice reaches `deps.onNotice` at `full`, neither mounted tool delivers it at `rows`).
|
|
312
|
+
|
|
313
|
+
### `config.models_swapped` names the catalog generation it announces — `detail.generation`, a digest of the candidate's key material — so one swap announced by N Runners folds to one (#2920; wire +1 detail key, additive; behavior narrowing: none; hard-breaking: none; closed sets: none; exports: none) (@server @client-core)
|
|
314
|
+
|
|
315
|
+
- **Before.** A host that hot-swaps the model catalog on several Runners at once (the server's four boot Runners) announced one event as four lines: each line mints its own `occurrenceId` — the identity of THIS delivery — and the rest of the payload was two counts, so nothing in a line said which lines were the same swap.
|
|
316
|
+
- **Now.** `detail` is `{ models, tiers, generation, occurrenceId }`. `generation` is `cgv1:` + a sha-256 over the catalog's key material: the model names the candidate declares (sorted) and the tier bindings in force over them (each tier word with the catalog word it binds, sorted; a binding that is a `Model` object has no word and stands as `null`) — never the catalog's content. Every Runner swapped to the same model names under the same tier bindings announces the same `generation` (and its own `occurrenceId`, unchanged); a swap that ends on another model name or another tier binding announces another; the order the names were spelled in does not matter. Equal key material is one generation — two swaps that change only what a name points at read alike, because the line is an operator breadcrumb, not a content fingerprint. A swap with `tiers` omitted digests the Runner's current bindings.
|
|
317
|
+
- **Wire +1 (additive).** *What changed:* one detail key on the existing `config.models_swapped` line (an untyped `detail` record: no exported type moves). *Who needs it:* a consumer that deduplicates one swap announced by several Runners — fold by (`code`, `generation`). *Who is hurt:* none — a consumer that ignores unknown detail keys is untouched; one that pinned the line's key set (`models`, `tiers`, `occurrenceId`) must add `generation`. *Compensation:* none needed beyond the key.
|
|
318
|
+
- **Consumers.** @server: S-2497 — the notice allow-list reads `generation` and folds the four boot Runners' lines to one row by (`code`, `generation`); keep the per-delivery `occurrenceId` for exact-duplicate suppression. @client-core: forward `generation` with the line if you project the detail.
|
|
319
|
+
- **Pins.** `test/backlog2920-swap-generation.test.ts` (A: four Runners swapped to one candidate — one generation, four occurrence ids; Runners booted on different catalogs still agree; one Runner swapped twice; B: one model name more / different, a tier binding or tier word moved or dropped, none declared ⇒ another generation; tiers omitted ⇒ the current bindings' generation; spelling order and content do not move it; C: counts and `occurrenceId` unchanged, no catalog content in the line, the face lines carry no `generation`; D: the digest's shape and the object-binding `null`).
|
|
320
|
+
|
|
321
|
+
### A background agent's task-list row names the session its child runs on — `TaskRegistry.list()` rows gain `sessionId?`, read from one anchor that every successful release of that session ends (#2924 / #2925, design/2861 r1 ①, ruled C-R958 ①; additive wire key; hard-breaking: one engine method's signature, open to veto; closed sets: none; exports: +1 root type `TaskListRow`) (@server @client-core @cli)
|
|
322
|
+
|
|
323
|
+
- **Before.** A list row carried no child session id, so a serving layer that wanted to open a background agent's conversation had no way to get there from the row. The id existed twice inside the engine — on the in-process handle and on the durable record — and they could drift: releasing the child's session cleared only the durable copy, and each place that released a bound child session wrote its own "release, then clear" (four of them; the stillborn background fork's never cleared, and the orphan-placement sweep's release cleared nothing).
|
|
324
|
+
- **Now.** A `background_agent` row carries `sessionId` while its anchor stands: absent in the startup window before the bind (the key is not there at all — not an `undefined` value), present from the bind (fork rows: the branch; other rows: the child's pre-minted session), still present on a terminal row whose session was kept (until its release or the terminal GC), absent once a release of that session succeeded; absent on every other task type (a workflow's originating session is not this key). One reading: `childSessionAnchorOf(handle)`. One law: a successful release of the child's session ends the anchor on the handle and the durable record together, matched on the pair (row, session) — a late clear for a session the row no longer names leaves the current anchor alone. Every release of a bound child session in the delegation lanes goes through one helper handed the release of the store that OWNS the session (a host-forked branch releases through the host store); the orphan-placement sweep's release ends a terminal handle's anchor too.
|
|
325
|
+
- **Also fixed (#2925, existing defect).** A background child whose retention degraded — the pin failed, or the retain ledger was disposed while the pin was in flight — had its pre-minted session released and its anchor cleared, yet still launched on that same id: the running child's durable record carried no transcript anchor (a store that recovered later kept it that way). The lane now binds the launch session again right before the launch (a no-op when the row already names it; `bindBackgroundAgentSession` leaves a row already anchored to that session as it is). And a disposal that dropped the entry but was still releasing it when the pin landed is now waited for: the entry's release runs once, and both degrade arms wait for it — before, the launch could overtake it, so the late release deleted the session the child had just created on that id and ended the running row's anchor.
|
|
326
|
+
- **Hard-breaking (open to veto).** *What changed:* `TaskRegistry.releaseDurableTranscriptAnchor(id)` is now `releaseDurableTranscriptAnchor(id, sessionId)` — the session id is required and the clear happens only while the row still names that session. *Who is hurt:* a caller of the old one-argument form; outside core there is none (`git grep releaseDurableTranscriptAnchor origin/main` in sema-server `772c2943`, sema-cli `7fb306ab`, sema-client-core `45c9279`, sema-sdk `65d8beb`, sema-connectors `fa0cbcb`, sema-desktop `32d66de`: 0 hits). *How to migrate:* pass the id of the session whose release just succeeded.
|
|
327
|
+
- **Consumers.** wire +1, additive and optional: `TaskRegistry.list()` / `liveTasks()` rows `sessionId?` (present-iff above). @server S-2450: `ROW_KEY_DISPOSITION` in `src/http/routes/background.ts` turns compile-red on the new key by design — state `keep` and project `rows[].sessionId?`; the server's `ReturnType<TaskRegistry["list"]>[number]` is unaffected, `TaskListRow` names the same type. @client-core CC-1054: the session row's navigable id. @cli: a row may now carry `sessionId`; nothing to change unless you render it. Only this process's handles are listed — a row known only to another process's durable store is not in `list()` (KL-2924-a).
|
|
328
|
+
- **Deviation candidate.** CC 2.1.309's SDK task rows (`background_tasks_changed`) carry no session id; its `local_agent` task id is the transcript key itself, and its `remote_agent` state carries `sessionId` — the nearest precedent. sema's child transcript key is a separately minted session id, so the row carries it; to be registered in the divergence ledger.
|
|
329
|
+
- **Exports.** +1 root type `TaskListRow` (the named row of `list()` / `liveTasks()`; zero behavior).
|
|
330
|
+
- **Pins.** `test/backlog2861-task-list-session-anchor.test.ts` (I1 source scan: the row mints the key only from `childSessionAnchorOf`; absent before the bind / bound after; store-less registration carries it; a release ends it on row, handle and durable record; a late clear for an earlier session leaves the current one; shell / monitor / workflow rows never carry it; the orphan sweep's release ends a terminal handle's anchor, a failed one keeps it; each bound release site — retained ledger disposal, resolve leg, reject leg, stillborn fork — ends it on success and keeps it on a throwing release; a host-forked branch is released through the host store; a fork row keeps its branch once terminal; #2925: after a failed pin and after a disposal mid-pin the running row names the session the child runs on, a disposal still releasing when the pin lands is waited for (nothing releases the child's session after its launch), and with the store down through the window the recovered store's record names that session; real load path: the root-exported `defaultTaskRegistry` under the session's own `{ owner: sid, sessionId: sid, scope }` lists the child's session and drops it with the release).
|
|
331
|
+
- **Known limits.** KL-2924-a — `list()` lists this process's handles only; a row carrying `sessionId` says the registry has not released the anchor, not that the session store still holds the session.
|
|
332
|
+
|
|
333
|
+
### An ancestor's extensions judge a delegated child's call at the child's gate, on their own bus, as the child's — `createPreToolUseConstraintPolicy` is removed and a screening entry is `{ installation, hookEnv?, …regime }` (#2429, mods wave three S2b, design/1398 wave 3 §3.3 B, C-R777 / C-R940; HARD-BREAKING, open to veto: a host that rebuilds a screening entry with the factory, or assembles its own screening policy for `runToolGate`, no longer compiles; behavior change V1–V8 below)
|
|
334
|
+
|
|
335
|
+
- **Before.** An ancestor's `classic.PreToolUse` chain rode a child's delegation as a **policy layer** folded after the child's caller policy (`createPreToolUseConstraintPolicy`), while the same installation's `tool.check` was raised at the child's gate: one fact (an ancestor's installation judges a descendant's call), two mechanisms. The policy form carried no identity (`agentId` absent), dropped the screen's `additionalContext`, recorded its deny as `deniedBy: "policy"` with a `classic.PermissionDenied` `source: "policy"`, said nothing when it allowed, and judged only the bytes the child's policy had rewritten.
|
|
336
|
+
- **Now.** Each inherited installation is one judge at the child's gate, on its own bus (`InheritedInstallation`, `inheritedInstallations` — one list read by both judging events): `classic.PreToolUse` at phase 1 right after the child's own bus (and at every re-screen: the fold's second look, the approved-edit pass), `tool.check` at the verdict read as before. V1 the e is the child's (`agentId`, `identity`, `permissionMode`, `cwd`) with the environment the installation was installed against (`env`); V2 its `additionalContext` reaches the child's call result; V3 its deny is the hook's own refusal — `deniedBy: "hook"`, `extension` = the registration, no `classic.PermissionDenied`; V4 its allow is no objection (an installation answers only its own leg's questions) and is disclosed as the `hook` member's shadow on the child's card (`allowRuleShadowed`); V5 it judges the bytes it is given, before the child's policy, and the policy's rewrite of them once more (a deny or another form there refuses); V6 its ask is settled where it was frozen (the installation's approver, durable mandates, classifier) at phase 1 — refused ⇒ the call is refused, approved ⇒ that question is answered, approved with an edit ⇒ the gate's approved-edit pass takes the edit, floated ⇒ the call stays marked for the park; V7 the synthetic read / consolidation-write judges no longer see the screen as an inherited policy (it refused every probe as "nobody can be asked"); like the child's own PreToolUse, it is not consulted for synthetic probes. When the installations rewrite one after another, each earlier judge of the call sees the new bytes once; a refusal is recorded over the bytes its judge judged. V8 the screen's waits — every raise, the leg's own included, and every installation's settlement — end with the run or with the call (the per-call signal, as the gate's other synchronous waits): a turn that cancels a call no longer leaves a PreToolUse hook pending on the run's lifetime (the call is refused, fail-closed, "cancelled").
|
|
337
|
+
- **Hard-breaking (open to veto) — H2.** *What changed:* the inherited screen is no longer a policy layer: `createPreToolUseConstraintPolicy` is removed from the root, and `InheritedGate.parentConstraints[]` is `{ policy, …regime }` (a caller policy) or `{ installation, hookEnv?, …regime }` (a screening installation: the bus `admitModChain` returned, or a leg's own); an entry carrying both, neither, or an installation no engine admission mounted is refused (`config.mods_invalid` at prepare, `resume.parent_constraint_mismatch` before a resume's claim); the entry member `mods` is retired. *Who is hurt:* a host that rebuilds a screening entry across processes with the factory (@server `createParkedReviveInheritedGate`, if it rebuilds one), or that assembles a screening policy of its own for `runToolGate` — a compile error. *How to migrate:* rebuild with `{ installation: await admitModChain({ deployment, task }), hookEnv: <the env>, …the frozen regime }`; the checkpoint's constraint digest and the park format are unchanged (the entry still projects opaque).
|
|
338
|
+
- **Behavior change (open to veto) — H3.** *What changed:* an ancestor's screen judges a descendant's call in the gate's phase 1 (V1–V6). *Who is hurt:* a host reading the child's `classic.PermissionDenied` `source: "policy"` as "the ancestor's screen refused" (that observation is gone; the call's `tool_end.gate.disposition` reads `deniedBy: "hook"` with `extension`), and a screen written for post-policy bytes only (it now sees the original bytes first, then the rewrite). *How to migrate:* read `tool_end.gate.disposition.deniedBy` / `.extension`; make the screen idempotent over two judgments of one call.
|
|
339
|
+
- **Consumers.** @server: a parked revive that rebuilds an inherited chain rebuilds a screening entry as above (S2a found no factory call in `src`); trace projection of an ancestor's screen deny moves `policy` → `hook`. @cli: a child's card / refusal text for an ancestor's screen deny is the hook's sentence (via server). @client-core: no closed-set change; `ToolGateInput.inheritedToolChecks` is renamed `inheritedInstallations` (a host driving `runToolGate` directly). @test: the cells below are the black-box criteria.
|
|
340
|
+
- **Exports.** −1 root value `createPreToolUseConstraintPolicy`. `ToolGateInput.inheritedToolChecks` → `inheritedInstallations`; `ConstraintChainLayerView.policy` optional.
|
|
341
|
+
- **Pins.** `test/backlog2429-mods-w3-s2b.test.ts` (real Runner, the root delegating through a spawn tool: V1 the child's `agentId` / identity on the ancestor's e; V2 its context in the child's result; V3 `deniedBy: "hook"` + `extension`, no PermissionDenied on the child; V4 the child's own question stands, the card's hook shadow names the ancestor's registration; V5 original then rewritten bytes, a refusal of the rewrite refuses; V6 refused / approved at the frozen approver with the child's approver never asked, an approved edit judged and run; K2′ two judgments both the child's; stand-in one judgment; C1 a cancelled call ends a pending inherited screen; C2–C4 a refusal in phase 1, in the fold's second look and in the approved-edit round is recorded over the bytes its judge judged; S the entry fault and a leg refusing a malformed chain). The inherited-gate / mods families are re-pinned, each change marked intended (V1–V8, H2) in place; `gate-station-boundary-ticks` "screening → fold" counts 11 microtask ticks, was 9 — two awaits inside the screening face (one look per seat), none between station groups.
|
|
342
|
+
- **Known limits.** The ancestor's approver is asked at phase 1, before the child's caller policy runs — a call the child's policy then refuses has already put one card to the ancestor's person (before, the policy's refusal came first), and a policy rewrite of the call puts the installation's question again over the rewritten bytes. An ancestor's handlers now see the model's bytes before the child's policy rewrites them (as the child's own handlers always have): a child policy that redacts an argument no longer hides it from them. The resumed leg's re-screen of an approved call raises the leg's own bus only, as before.
|
|
343
|
+
|
|
344
|
+
### A background task's output or full result has a reader that is not TaskOutput — a cut agent report and a workflow's full record are stored and named by a `ReadToolResult` ref, a Monitor watch writes its stdout and stderr to an output file, and every list of tasks names each task's read handle (#1608 R2 / R3 / R4 / R7 with the #469 placement of the new reader, design/1056 §2.5, ruled C-R675 / C-R976; behavior change: notification, receipt and table text; the TaskOutput tool itself is still mounted — its removal is a later step; hard-breaking: none; closed sets: none; exports: none; members: +1 optional `ToolExecuteContext.taskArtifacts`, +1 optional `SendMessageToolOptions.taskArtifacts`, +1 optional `RunWorkflowToolDeps.taskArtifacts`, +2 `TaskRegistry` methods `recordArtifactRef` / `readHandleOf`, `formatWorkflowRun` takes an optional bounds argument) (@server @cli @client-core @test)
|
|
345
|
+
|
|
346
|
+
- **Before.** A background agent's completion frame carried 2 000 characters and said "read it with TaskOutput where mounted"; the overflow reached a store only when a TaskOutput poll happened, and a report between 2 000 and 4 000 characters was never stored. A workflow's per-agent rows were only in TaskOutput (and capped at 60 rows / 5 partial outputs there). A Monitor watch had no output file — its stderr was read only through TaskOutput's spool. The post-compaction table said "check output with TaskOutput", and a task whose every pending notification was evicted was told TaskOutput "may still serve its spool".
|
|
347
|
+
- **Now.** A report longer than the frame carries is stored whole (redacted, content-addressed: task id + a digest of the text) in the run's offload store BEFORE the frame is announced, and the cut line names it: `read the full text with ReadToolResult (ref "…")`; with no store, or a write that failed, the cut names no ref and says so (and keeps the SendMessage / TaskOutput readings while TaskOutput is mounted). A workflow completion stores its full record — the result and every agent's row and finished output, with no display bound — the same way and names it in `diagnostics`, lists the agents that did not complete inline (up to five), and names the journal apart, with its own use (the step log `resumeFromRunId` replays); a rejection whose thrown value carries no run of its own reads the run store's record, and building the record can never cost the failure frame. A Monitor watch mirrors stdout and stderr into an output file minted by the background Bash's one mint; the start receipt and the terminal frame name it, its last writes land after TaskStop's kill and before the terminal frame, and Read's root-fence exemption covers it as it covers a background command's. Each row of the post-compaction table names the task's read handle (`output: Read <path>` / `result: ReadToolResult (ref "…")`; a revived agent drops its previous cycle's), and a dropped task's disclosure names its read handle or says its row is no longer readable. TaskStop's "already finished" receipt says the completion notification carries the final state. A page-back of a task's stored result is placed as a poll of that task is (`ReadToolResult`'s boundary legs are per call now: another tree's agent, a workflow run or a row gone read as an off-target read; the calling tree's own agent and any other ref travel none) — the new reader is no way around the cross-boundary table.
|
|
348
|
+
- **Behavior change (open to veto) — a retired name on an allow list.** *What changed:* a retired tool name on a `toolPolicy` allow list (the caller's policy or a session's stored `toolAllow`) no longer refuses the run with `config.legacy_tool_name`; it is reported by the `config.toolpolicy.unmatched_names` advisory with the name's retirement line (it grants nothing, so the policy is narrower than written). A retired name on a deny or ask list still refuses. *Who is hurt:* nobody loses a guard — a host that relied on the refusal to find a stale allow entry now finds it in the advisory. *How to migrate:* nothing; rewrite the entry to the current name when the advisory names it.
|
|
349
|
+
- **Consumers.** @server: the workflow completion notifier's `diagnostics` now carries the record's ref sentence, but the completion-inbox journal drops `diagnostics` (`workflow-notify-journal.ts`, on the premise "TaskOutput reads it") — that premise ends with the TaskOutput removal, so the bridge should carry `diagnostics` (or the ref) before then. @cli / @client-core: completion text changes only; no wire key changes; the wiring manifest's roster entry for `ReadToolResult` reads `boundaryLegs: "per_call"` (was `[]`). @test: the lanes below are the black-box shapes.
|
|
350
|
+
- **Pins.** `test/backlog1608-agent-result-artifact.test.ts` P1–P6 (a 3 000-character report stored whole; content-addressed refs; the frame after a slow put; failed and absent stores; the real Runner lane reading the ref with TaskOutput excluded); `test/run-workflow-tool.test.ts` "#1608 R4" R4a–R4f (rows inline, the record past the display bounds, a bare and a forged throw, the frame after a slow put); `test/backlog1608-monitor-output-file.test.ts` P1–P6 (stdout + stderr in the file, the exemption's access and env tests, no-file and failed-append disclosure, a stalled append never holding the kill, an in-flight append landing before the terminal frame, the real Runner lane reading the watch's stderr with TaskOutput excluded); `test/backlog1608-task-read-handles.test.ts` T0–T5 (T5: the page-back's placement against a poll's); `test/design469-r3-boundary-legs.test.ts` (the catalog row); `test/backlog1355b-unmintable-segment-judge.test.ts` "#1608 M9" M9a–M9c.
|
|
351
|
+
- **Behavior narrowing (open to veto) — a stored result's origin is in its ref (#3092).** *What changed:* the task whose result an artifact holds is a segment of the artifact's ref (`tr_<session>~fold.task~<task>~<digest>`, a segment the tool-output mint never produces), and the process-local ref → task table that remembered the newest 4 096 refs is gone; a page-back of a stored result whose task row is gone, belongs to another tree, or was stored by another process now reads as an off-target read — before, a ref that table had forgotten or never saw travelled no legs, so under an armed, governed tree the read went unrecorded and the next device call did not ask. *Who is hurt:* a governed run that pages back a stored task result after its row is gone, or after a restart, now owes the record and the confirmation an off-target read owes; offloaded tool output is unchanged (it never carries the segment). *How to migrate:* nothing; a ref stays an opaque handle — read it back verbatim, never parse it (the segment is the engine's own reading, not a format promise). Pins: `test/backlog3092-artifact-origin-in-ref.test.ts` A0–A6. The edge table that mapped a ref to its task only inside one process is gone with it, so a ref read in another process or after eviction is accounted against its task like any other (#3027).
|
|
352
|
+
- **Known limits.** A running background agent's progress is not readable before it ends (its completion frame is the reader). A missing or incomplete command output file is the next entry's (#3025). TaskStop on a watch waits for the file's last append after the kill (the bash lane's order) — an append that never settles holds the stop's receipt. A background agent's output spill (the overflow a TaskOutput poll stores under its own ref) is not a result artifact, and its page-back still travels no legs. The one-shot wait (R5) and the completion-sink resolution (R1) are the next entry's (#3025); the TaskOutput removal is a later step.
|
|
353
|
+
|
|
354
|
+
### A one-shot submission waits for the background agents and workflow runs it started before it ends; a background command's missing or incomplete output file names a ref for what was retained; a whole-session notification loss carries the background-task table (#3025 = #1608 C1: R5 / R1 / R6 / R7 and the R2 gap arm of design/1056 §2.5.3; the CC 309 print-mode split, `cli309.js` :289218-289219; behavior change: the one-shot ending and receipt / notification text — open to veto; hard-breaking: four option members removed; closed sets: none; exports: none; members: −4 (below), +1 optional `taskArtifacts` on the background-command and Monitor registration inputs) (@server @cli @client-core)
|
|
355
|
+
|
|
356
|
+
- **Before.** A one-shot submission (`TaskSpec.oneShot`, e.g. headless `-p`) ended as soon as the model's turn did. Every loop-type launch receipt (background `Agent`, a forked background agent, `SendMessage` continuing an agent, `Workflow`, a still-running agent's poll) therefore told the model to block on `TaskOutput({ task_id, block: true })` itself, and a model that ended its turn lost the result; a background command's receipt said the same. Each background producer read its own completion sink (the call's run lane for an agent, the mount's sink for a command, a watch and a workflow). A command whose output file could not be created, or whose append failed, kept its retained output reachable only through TaskOutput. A whole-session notification loss said only that the lost tasks were no longer known. A read handle of `""` was named as one.
|
|
357
|
+
- **Now.** A loop-type background task (a background agent, a continued agent, a workflow run) admitted onto a run's lane owes that lane its terminal frame; where a one-shot run would end, it waits for the next such frame — already on the steer lane when the wait wakes — and hands it a turn. A cancel ends the wait (the run's walltime timer included: the answer the run gave stands and `task.interrupt_unconsumed` reports the stop), and so does a 600 s ceiling counted from the first wait — the reference's print-mode ceiling (`cli309.js` `mFt=600000`), a constant, not a knob. A background command or a Monitor watch is never waited for — its lifetime is its process's — and a one-shot command receipt says: "This is a one-shot submission — the engine does not wait for background commands; run it in the foreground (with a timeout) if you need its output before the submission ends." The loop-type receipts carry their ordinary notified wording in a one-shot run; none teaches a blocking wait. Every background producer resolves its completion sink through one function (the call's run lane, else the mount's sink). A command whose output file is missing or incomplete stores what the engine retained (the spool's head and tail, its gaps stated) and its terminal frame names the `ReadToolResult` ref — on every terminal face, the Monitor run-teardown face included. A whole-session loss line carries the run's background-task table — live and finished rows, each with its read handle (the post-compaction announce's renderer) — or says the run has none to read; a blank output path or ref names nothing. The wait owes per cycle (an agent continued while its earlier frame is on its way owes two; a parked frame a continuation voids releases its cycle), and any input reaching the run while it waits (a steer, a child's message) wakes it to take that turn first.
|
|
358
|
+
- **Hard-breaking (four option members).** *What changed:* `SendMessageToolOptions.oneShot`, `SendMessageToolOptions.retrievalToolMounted`, `TaskToolOptions.oneShot` (`createTaskOutputTool`) and `TaskPollOptions.oneShot` (`TaskRegistry.pollTask`) are removed — nothing reads them any more (a one-shot submission is no completion mode of its own; the retrieval-tool seat steered only the one-shot advice). *Who is affected:* a library caller that passes one of them in an object literal gets a TypeScript excess-property error; server, cli and client-core (origin/main) pass none of them. *What to do:* delete the argument — the behavior it chose is now the engine's own (the one-shot ending waits).
|
|
359
|
+
- **Behavior change (open to veto).** *What changed:* a one-shot run no longer ends while a background agent or workflow run it started is still owed to it — it waits for the completion (bounded by its own walltime, a cancel and the 600 s ceiling); a host that mounts Bash, Monitor or Workflow inside a run with its own notification sink now has completions delivered to the run's lane the call carries (the Agent lane's precedence). *Who is affected:* a `-p` caller whose submission used to return right after a background launch now returns after the background work finishes; a host relying on its own sink receiving a run-launched command's completion. *What to do:* bound a one-shot submission with `limits.maxWalltimeMs` if it must return by a deadline; a host that needs its own copy of completions observes them through `RunInternals.onTaskNotification` (the lane calls it first) rather than a per-tool sink.
|
|
360
|
+
- **Consumers.** @server: the one-shot contract text the SDK carries for `oneShot` ("guidance only … block-wait via TaskOutput") no longer describes the engine — the engine now waits for loop-type background completions before the submission ends; a request-level timeout on `-p` submissions meets the background work's duration. @client-core: `src/oneShotWireCaps.ts`'s header ("core 换发 block-wait 指引", "谁受害:无 —— 键只改模型指引文案") — the key now changes when a submission ends. @cli: a local port of the one-shot receipt wording, if kept, should drop the blocking-wait sentence.
|
|
361
|
+
- **Pins.** `test/backlog3025-oneshot-ending.test.ts` O1–O11 (real Runner: a child released from the parent's own Stop station — the one-shot ending waits for its completion and answers from it, an interactive run does not wait, a completion that never comes runs to the walltime, a background `sleep 60` is not waited for, a held workflow run is waited for, a steer during the wait gets its turn first; the obligation book: per-cycle debts, a voided cycle, its bound and the 600 s ceiling); `test/backlog3025-completion-sink.test.ts` S0–S3 (the one resolution; a Bash and a Monitor started by a call carrying the run lane complete into it, not into their mount's sink); `test/backlog3025-command-record-gap.test.ts` C1–C5; `test/backlog3025-session-loss-table.test.ts` E0–E5 (E4 / E5 real Runner: a running command's file, a finished agent's stored result); re-pinned: `run-workflow-mount` (the real mount now waits for the workflow's completion), `run-workflow-tool`, `rb288-295-agents-face`, `task-registry`, `bg-lifecycle-fidelity`, `hands-fs`, `design385-rescan-fixes` G, `up424-a-tier-ports`, `prepare-delegation-surface`.
|
|
362
|
+
- **Known limits.** A wait the walltime or the ceiling ends does not name the task ids still owed (`KL-3025-a`). TaskStop on a Monitor watch waits for the output file's last append after the kill with no bound (`KL-3025-b`). A loop-type task launched by an EARLIER run of the session completes into that run's lane — a one-shot run does not wait for it.
|
|
363
|
+
- **Fix (before release).** The obligation book names a task by its lane key (`taskNotificationLaneKey`, the pending store's own bucket key) at admission, discharge and release, so a frame of another lane that carries a background agent's `task_id` settles nothing; an operator resume of a retained child (`SubagentSteerHandle.resume`) completes into the mount's own sink, as it did before this entry — no call of a run launches it, so it has no run lane to resolve (design/122) — while a resume through `SendMessage` completes into the waking run's lane. No wire change. Pins: `defectscan-notify-budget-surface` F3 (the book is a per-task bucket, and a cross-lane cell), `rb201-handback-review` FO-3 retained-resume ×2, `subagent-resume` ⑦ (unchanged, green again).
|
|
364
|
+
|
|
365
|
+
### `memorySyncStoreOf(backend)` is a root export — the one mint of a sync cursor's store identity, for a host binding a cursor taken before the binding existed (#2956)
|
|
366
|
+
|
|
367
|
+
- **Before.** The identity a sync cursor binds to (`file:<root of the store's directory>`) was minted only by `memorySyncStoreOf` in the memory-engine module, reachable by a deep path; a host that carries cursors persisted before `MemorySyncCursor.store` existed had to import that path or copy the formula to bind them.
|
|
368
|
+
- **Now.** The function is exported from the package root — the leaf's own function (one mint, pinned `===`), unchanged in behavior: a store without a directory still has no identity and is refused as a sync plane (`config.memory_sync_store`).
|
|
369
|
+
- **Exports.** +1 root value `memorySyncStoreOf` (a function; the consumer smoke list records it). @server S-2537: bind a legacy cursor before the round with `{ ...legacy, store: memorySyncStoreOf(backend) }` — `backend` is the store that layer's sync actually ran against when the cursor was written (the old executor's single `opts.backend`), not the store the layer resolves to today (S-2394 / #2818 move the global layer): binding to today's store reopens the #2836 deletion shape (C-R991 D-4 reading).
|
|
370
|
+
- **Pins.** `test/backlog2956-memory-sync-store-root-export.test.ts` — the root, the memory-engine barrel and the leaf hold one function; the smoke list decides it; the identity of a real File store and of a second instance over it; a legacy cursor is refused unbound and accepted bound through the root's function; a directory-less store refuses by code.
|
|
371
|
+
|
|
372
|
+
### Two store options are read by one integer reading — `TtlSessionStoreOptions.sweepIntervalMs` is a whole number of milliseconds from 1 to 2147483647 and `InMemoryToolResultStore.maxTotalChars` a whole number of characters from 0 (#2959)
|
|
373
|
+
|
|
374
|
+
- **Before.** `sweepIntervalMs` was judged finite-and-positive only, so `1.5` (Node truncates it to 1 ms) and any value past 2147483647 (Node reads it as 1 ms) armed a background sweep that ran back to back, silently; `0` and a negative were read as "no sweep". `maxTotalChars` was judged "a number, not NaN" only, so `-1`, `1.5` and `Infinity` were taken as bounds (`Infinity` read as "no bound").
|
|
375
|
+
- **Now.** One reader (`readIntegerOption`, `src/core/integer-option.ts`) judges both: absent is the option's default (no sweep; an unbounded store), a whole number inside the range is itself, anything else refuses at construction with `config.invalid_argument`, naming the option and spelling a number (any other value is named by its type only, never repeated). The bound is read once at construction. `0` for `maxTotalChars` is still the tightest bound (everything but the just-written ref is evicted).
|
|
376
|
+
- **Behavior narrowing (open to veto).** *What changed*: a sweep interval of `0`, a negative, a fraction, a non-number or past 2147483647, and a result-store bound that is negative, fractional, infinite, past 2^53-1 or a non-number, now throw where they were accepted. *Who is hurt*: a deployment that passed `sweepIntervalMs: 0` to mean "off", `maxTotalChars: -1` to mean "tightest" or `maxTotalChars: Infinity` to mean "unbounded" (none in sema-server, whose result store passes 64000000 and whose own caching store has its own option; sema-cli's `sessionManager` has its own too — local checkouts read, inferred for the rest). *Compensation*: omit the option for "off" / "unbounded", and write `0` for the tightest bound; the refusal sentence says which.
|
|
377
|
+
- **Pins.** `test/backlog2959-integer-option-gates.test.ts` — eight bad sweep values and nine bad bound values, each refused with the code and with no timer armed (fake timers); the bundled and the Runner-shared store alike; the controls that stay green (1, 1000, 2147483647 arm exactly that delay; `0`, a real cap and the largest exact integer hold; omitted is unbounded); the bound is read once; the sentence spells numbers and never repeats a secret-shaped string; both constructors read through the one reader.
|
|
378
|
+
|
|
379
|
+
### A peer seat's answer is held to the grammar of the send that carries it, read from its own members only, with `expiresAt` from 0 (#2961)
|
|
380
|
+
|
|
381
|
+
- **Before.** The engine's judge carried a header value the send then refused — U+2028, a character past U+00FF (Node's HTTP layer throws on it when the request is built), a control byte inside Latin-1, DEL — so "can carry" and "can send" disagreed; an `expiresAt` below zero was a finite number and was carried; an env value holding a lone surrogate was carried and the child read U+FFFD in its place; and the answer's members (`kind`, `headers`, `env`, `expiresAt`, `authorizeUrl`) were read through the prototype chain, so a member the answer's prototype (or a polluted `Object.prototype`) supplied was taken as the seat's own.
|
|
382
|
+
- **Now.** A header value is held to Node's own HTTP header-value grammar (tab, printable ASCII, U+0080–U+00FF; the empty value and U+0085 are carried as they are on the wire); an env value is held to what a spawn hands the child unchanged (no NUL, no line break, no lone surrogate); `expiresAt` is a finite number from 0 (a stamp past every clock, `Number.MAX_VALUE` included, still never expires, as an absent one); the answer's members are its own enumerable members, read once into an inert snapshot. A refusal is `config.peer_answer_invalid`, names the member and never repeats the value.
|
|
383
|
+
- **Behavior narrowing (open to veto).** *What changed*: an answer holding a header value outside the grammar, an env value holding a lone surrogate, a negative `expiresAt`, or a member supplied only by a prototype now refuses the send (`credential_unavailable`, delivered `no`, nothing sent) at the ask instead of failing at the send or being read as the seat's. *Who is hurt*: a seat whose vault holds a credential with a character past U+00FF (it already failed when the request was built), a seat that built its answer as `Object.create(base)` with members on `base`, and a seat that answered a negative `expiresAt`; sema-server's seat (`src/peer-seat.ts`) answers plain objects with own members (local checkout read). *Compensation*: put the members on the answer itself; encode a credential into the header grammar (ASCII, base64); omit `expiresAt` or answer 0 or a real stamp.
|
|
384
|
+
- **Pins.** `test/backlog2961-peer-answer-value-grammar.test.ts` — the judge against Node's `validateHeaderValue` for every character up to U+02FF and for the shapes beyond it on both header lanes (http, a2a); the exact boundary; prototype-supplied answer / headers / `expiresAt` / `env` / `authorizeUrl` members and a polluted `Object.prototype` not read; `expiresAt` from 0; the env lane (a lone surrogate, NUL, line breaks refused; every carried value reaches a real child byte for byte); and through the real MCP http entrance a value the send cannot carry is `credential_unavailable` with no call sent while an upper-Latin-1 value reaches the endpoint.
|
|
385
|
+
|
|
386
|
+
### A background agent's session anchor changes by release and a fresh bind, never by being written over; an empty session id is no anchor (#2963)
|
|
387
|
+
|
|
388
|
+
- **Before.** `bindBackgroundAgentSession(id, sessionId)` on a row already anchored to another session overwrote the anchor without a release (the earlier session lost its owner row, nothing said so), and an empty session id was taken as an anchor (`sessionId: ""` on the row and its durable record).
|
|
389
|
+
- **Now.** A bind of another id onto an anchored row throws (the row keeps its anchor on the row, the handle and the durable record, and nothing is written); an id that is no non-empty string throws whatever the row holds; the same id again is still the no-op it was; a bind for a row that is gone or is not a background agent's is still silent. The sanctioned change is `releaseDurableTranscriptAnchor(id, sessionId)` then a bind. CC 2.1.309's `remote_agent` rows are built with their session id once (and rebuilt from the sidecar on restore); it has no re-anchor path, so there is nothing to follow.
|
|
390
|
+
- **Behavior narrowing (open to veto).** *What changed*: the two binds above throw where they were accepted. *Who is hurt*: a caller that re-bound a row to a different session without releasing the first (the engine's three bind sites bind the same id again or an unanchored row — none re-binds), and a caller that passed `""`. *Compensation*: release the first anchor, then bind; pass the real session id. Two existing pins are re-pinned to the new law (the late-clear pair-match pin and the tier-3 late old-lane write pin): the first now releases before the second bind, the second enqueues its late write as the release of the anchor.
|
|
391
|
+
- **Pins.** `test/backlog2963-bind-session-anchor-law.test.ts` — the second bind throws naming the row and no session id, with row / handle / durable record on the first and no durable write; repeated refusals; the same id is a no-op with no write; release then bind works; a store-less registration holds the law; five bad ids on a fresh and on an anchored row; a missing row and a workflow row stay silent.
|
|
392
|
+
|
|
393
|
+
### A woken retained child is a running agent in its tree's delegation pool — a resume cycle is counted for exactly its own life, so the concurrency cap sees every child that runs (#2998, ruled C-R982 (a); security narrowing — runaway fan-out, open to veto; hard-breaking: none; closed sets: none; exports: none)
|
|
394
|
+
|
|
395
|
+
- **Before.** The delegation concurrency cap counted a running child by its registry row or, on a lane with no row, by the pool's local in-flight count — and only the spawn doors charged that count. A synchronous child retained for its steer handle and woken with `handle.resume(…)` ran with no row and no charge: invisible to the cap, so a full pool still admitted a fresh spawn (cap 1: two running). A child woken by SendMessage revived its row and was counted.
|
|
396
|
+
- **Now.** The gate's one reservation, `occupy(kind)`, is split from its verdict: `admit` is the two cap verdicts in front of `occupy`, and a resume cycle occupies without the verdicts — a cycle that revived its row is counted by the row, a cycle with no row is charged to the pool's local half (the handle's own spawn gate), given back where the retained entry's running claim is (the settle, and a launch that throws). A launched wake always reaches its settle: cancelling the previous cycle's parked completion frame is contained and disclosed on the resume's notifier (site `subagent.resume.park_cancel`), where a throwing registry unsubscribe used to leave the cycle undrained and its entry running for good. A woken child is still never refused by a full pool: CC 2.1.309's resume path takes a concurrency slot without reading the cap.
|
|
397
|
+
- **Behavior narrowing (open to veto).** *What changed*: while a handle-woken child runs, the tree's next Agent spawn is refused at a full pool (`delegation.concurrency_cap`), where it was admitted. *Who is hurt*: a deployment that wakes synchronous children through steer handles and spawns beside them at the cap (no sema-server or sema-cli reader of the in-flight count; the count is engine-internal). *Compensation*: none needed beyond waiting for a woken child to settle; the cap is the deployment's `RunnerDeps.delegationEntryCaps`.
|
|
398
|
+
- **Not done, put to clay.** Refusing a wake at a full pool (C-R982 (b)) diverges from CC 2.1.309 and is not done. A tier-3 revival of the same row is refused at a full pool today while a retained wake is not; which way the two are made one is the same question.
|
|
399
|
+
- **Consumers.** none to change (@server @cli: no reader of the in-flight count).
|
|
400
|
+
- **Pins.** `test/backlog2998-resume-occupies-pool.test.ts` (real Runner: the SendMessage wake at a full pool resumes and is counted — 3 and 5 running read 3 and 5; the handle wake at a full pool runs and the gate reads 2 for 2 running; a handle wake on an empty cap-1 pool refuses the next spawn and its settle gives the slot back; a launch that throws gives it back and the child stays resumable; a parked frame whose cancel throws after the launch still lets the cycle settle and give the slot back, the throw disclosed; the occupancy kind follows the row and is given back once).
|
|
401
|
+
|
|
402
|
+
### A caller's write-capable tool that declares no permission seat is named at load under every asking mode, whatever policy layers are wired — the auto classifier never rules on it unless a rule or a policy asks (#2966; disclosure only, the routing is unchanged — C-R218 ②, registered divergence `caller-tools-self-seat`; hard-breaking: none; closed sets: none; exports: none) (@server @test)
|
|
403
|
+
|
|
404
|
+
- **Before.** The load-time ungated-write warning (`RunnerDeps.onError`, phase `config`) named a caller's tool (`TaskSpec.tools`) only when it declared `effect: "write"` and the leg wired no policy layer and no PreToolUse judge. A tool with no `permissionSeat` answers for itself (C-R218 ②): under `default`, `auto` and every other asking mode the mode's question never reaches its calls, so in `auto` the classifier never saw it — and once any policy layer was wired the operator was told nothing; a caller's tool answering to `Bash` / `Monitor` without a declared write was never named. A caller write tool the mode's question does reach was named UNGATED when no layer was wired — one declaring `permissionSeat: "passthrough"` (its `unstated` question; the classifier, in `auto`), one under `plan` (plan's own question), one declaring a write path target (the write gate) — and a request tool the run excluded was named too, spending the deployment's one warning for that shape.
|
|
405
|
+
- **Now.** One reading for a request tool (`spec.tools`, mounted under its own name — an excluded or displaced entry is not named): it is a surface when it is write-capable (declares `effect: "write"`, or answers under its name or an alias to a shell-face name) and carries no egress / irreversibility mark. A caller's own tool (one the engine does not define) under a mode that asks is named when no question of the mode reaches it (`modeQuestionReaches`, `src/core/mode-policy.ts`: the unstated question reaches a tool declaring the `passthrough` seat, the write gate a declared path write and, under `plan`, every tool that is not read-only), whatever policy layers are wired (a layer that does not name it covers nothing, the reading the server-tool arm already gives); every other request tool — and every one under `bypassPermissions` — is named when no effect-aware layer is wired, as before. The component reads `write tools under <mode> [...]`, and the warning adds that such a tool answers for itself, that in `auto` the classifier rules only on what a rule or a policy asks, and that `permissionSeat: "passthrough"` puts each call to the mode's question. When an effect-aware layer is wired, the warning's lead says no question of the mode reaches the named calls instead of telling the operator to wire a policy. Once per deployment and tool-set shape, at prepare; never per call.
|
|
406
|
+
- **Not changed.** The auto classifier answers every ask that survives the fold, as before; a seatless caller tool still runs unasked by the mode (the reference mounts a host's tool as an in-process MCP tool whose `passthrough` permission check asks and, in auto mode, is classified — sema keeps the self-answering seat, C-R218 ②). The engine's removal guard still asks a person for a protected removal on a call that answers to a shell-face name, a caller's tool included (`dangerous_delete`, every mode).
|
|
407
|
+
- **Consumers.** @server: the warning text gains the caller-tool component and sentence; a log reader keyed on `UNGATED` keeps matching. @test: black box — a seatless `effect: "write"` caller tool under `auto` with a policy layer runs, the classifier is called 0 times, one warning names it; the same tool declaring `permissionSeat: "passthrough"` is classified and not named.
|
|
408
|
+
- **Pins.** `test/backlog2966-caller-tools-unasked.test.ts` ①–⑨ (real Runner; base readings in the file head); `test/major1-ungated-write-tools.test.ts` unchanged.
|
|
409
|
+
|
|
410
|
+
### The auto strip's protocol-namespace arm is deleted: a covering allow entry is judged like a path / name / host entry (#2967; rule −1, no behavior change on any call a prepared leg mints; hard-breaking: none; closed sets: none; exports: none) (@test)
|
|
411
|
+
|
|
412
|
+
- **Before.** `autoStripped` stood a covering entry (`mcp__srv__*`, `mcp__srv`) down in `auto` when the call answered to a shell-face name — an arm no call reaches: a covering allow entry reaches only names in a protocol namespace, a caller tool's name or alias carrying `__` is refused at prepare (`config.tool_name_invalid`), and a server's or a peer's tool is minted without aliases.
|
|
413
|
+
- **Now.** A covering entry stands down on a shell call only under `TaskSpec.classifyAllShell`, as every non-shell kind does. 7.59.0's criterion G9.d carries a correction: its last clause (the protocol-namespace entry reaching a shell alias) is retired, not observed — the package face cannot build it.
|
|
414
|
+
- **Pins.** `test/backlog2558-classify-all-shell.test.ts` A1 re-pinned (A1a the door refuses a caller name / alias in a protocol namespace, A1b a materialized server tool has no alias, A1c the covering entry's strip reads only the declaration).
|
|
415
|
+
|
|
416
|
+
### An agent definition declares the MCP servers its leg connects to — `AgentDefinition.mcp`, in the `TaskSpec.mcp` form, judged by the door that judges a task's own list (#2595; additive; behavior: two choices stricter than the reference, open to veto; hard-breaking: none; closed sets: none; exports: none; members: +1 optional `AgentDefinition.mcp?`, +1 optional `servers?` on `ToolSpec.agentToolFaces` entries; internal, not index-exported: `snapshotAndValidateMcpEntries` (locked-config), `MCP_RESOURCE_FACES` (mounted-mcp), `withDefinitionServers` / `definitionAllowTools` (inherited-tool-pool), and `delegationCallIsExternal` takes an optional `inheritedServers`) (@server @cli @client-core)
|
|
417
|
+
|
|
418
|
+
- **Before.** A definition had no MCP seat: the leg spawned as an agent held only the servers its spawning run declared and its
|
|
419
|
+
lists admitted, so a host holding an agent's own servers (an agent file's `mcpServers`, a request's `agents[].mcpServers`)
|
|
420
|
+
could only refuse them, and an agent restricted to a few tools lost the servers it was meant to bring.
|
|
421
|
+
- **Now.** `AgentDefinition.mcp?: McpServerSpec[]` — the entries a task's `mcp` takes, copied and judged where the definition
|
|
422
|
+
is received (the delegation tool's assembly, the `TaskSpec.agents` door) by the same judge, code and sentence as the task's
|
|
423
|
+
own list (the list-level sentence names `AgentDefinition.mcp of "<agent>"`), and judged again at the leg's prepare. They are
|
|
424
|
+
declared on the leg spawned as the agent alone — its children inherit them as they inherit any spawner's servers, the
|
|
425
|
+
spawning run never mounts them — after the servers the leg inherits: a definition server whose `mcp__<server>__` namespace an
|
|
426
|
+
inherited one already holds is not declared (the spawning run's server holds the name); two of the definition's own under one
|
|
427
|
+
namespace refuse the leg's mount (`config.mcp_server_name_collision`), as a task's own pair does. The definition's own allow
|
|
428
|
+
list, when it has one, admits every tool of each of its own servers; its deny list still wins. Dialling, the shared connection
|
|
429
|
+
pool of the run tree, a host-transport server's seat (the spawning run's seat of that name, read off the same mount as the
|
|
430
|
+
pool, as a wake hands one; no seat ⇒ `config.mcp_host_seat_missing` on the leg, as for a task's own), `skipped`, the
|
|
431
|
+
`mcp_unavailable` notice on the leg's first request (#1551) and refresh / re-dial are the leg's as for any server it declares. The workflow lane's
|
|
432
|
+
`agent(…, {agentType})` judges and folds the definition's servers by the same rules. The memory content-origin judgment
|
|
433
|
+
counts a delegation to the agent as reaching, through the child's own valve readings over the face's lists, the namespace of
|
|
434
|
+
each of its own servers (classified by the server's declared `contentOrigin`; under a namespace the child also inherits a
|
|
435
|
+
server for, that server too, by its own class) and the cross-server resource readers those lists leave (external, as their
|
|
436
|
+
mint marks them). The judgment before the run reads `mcp__<server>…` entries naming a definition's own server as naming a
|
|
437
|
+
declared server, on the definition's lists and on the spawning run's own (a ceiling that admits a definition's server).
|
|
438
|
+
- **Stricter than the reference (open to veto).** *Ceiling*: the layers above the agent's leg (the spawning run's tool lists
|
|
439
|
+
and the ones it inherits) still bound its own servers — a server they leave the leg's valve nothing of is never dialled (the
|
|
440
|
+
reference appends an agent's server tools past its parent's tool pool). *Lock / compliance*: under an `mcp` configuration
|
|
441
|
+
lock or a compliance deny of MCP servers the leg's door refuses the spawn (`config.locked_key` / the compliance refusal; the
|
|
442
|
+
reference skips the servers, notifies and runs the agent). *Bad entries* are refused (the reference drops them with a debug
|
|
443
|
+
warning). *Name references* (the reference's string form) have no form: a definition that should hold a server its spawning
|
|
444
|
+
run declares names it in `allowTools` (`mcp__<server>`).
|
|
445
|
+
- **Today's form, not the contract (KL-2595-a; temporary, retires with #3007).** A spawning run that declares no MCP server
|
|
446
|
+
of its own has no mount: the host seats it holds reach no leg (a definition's own host-transport server fails its dial,
|
|
447
|
+
`config.mcp_host_seat_missing`), and two legs spawned as the same agent in one turn dial a connection each instead of sharing
|
|
448
|
+
one. With any server declared by the spawning run, both hold as above.
|
|
449
|
+
- **Today's form, not the contract (KL-2595-b; temporary, retires with #3017).** A per-task definition's MCP credential
|
|
450
|
+
references (`TaskSpec.agents[i].mcp`) are held by no one between the return of `runTaskStream` and the start of the leg
|
|
451
|
+
spawned as that agent: a host that releases its hold in that window makes the leg's dial fail loud with
|
|
452
|
+
`credential_unavailable`. The fix is the receipt taking `spec.agents[i].mcp` with `spec.mcp` and the door judging that copy.
|
|
453
|
+
- **Consumers.** @server: project the request face `agents[].mcpServers` onto `AgentDefinition.mcp` (one `McpServerSpec` per
|
|
454
|
+
record key; a name-only item maps to an `allowTools` entry `mcp__<name>`) and the agents wire projection lists the declared
|
|
455
|
+
server names — S-2182 is unblocked; the request's per-key judges for `mcpServers[i]` apply to `agents[j].mcpServers[i]`
|
|
456
|
+
unchanged, and a refused entry is the same refusal a task's own gets. @cli: an agent file's `mcpServers` reaches the engine
|
|
457
|
+
through that request face (CC-996); an item the reference would have skipped is now a refusal. @client-core: the agents wire's
|
|
458
|
+
server names are a projection position; no core call.
|
|
459
|
+
- **Pins.** `test/backlog2595-agent-mcp.test.ts` (real Runner + stdio servers: own server offered and called, allow list,
|
|
460
|
+
deny list, ceiling, namespace clash and an own duplicate pair, inheritance beside own, pool sharing, grandchild, per-task
|
|
461
|
+
definition, `mcp_unavailable`, a host-transport server through the spawning run's seat in both lanes and without one; one
|
|
462
|
+
judge at the definition, at the workflow fold and at the lock; the list judgment on the definition's lists and the spawning
|
|
463
|
+
run's own; the memory face, resource readers and an inherited server of the same namespace included).
|
|
464
|
+
|
|
465
|
+
### The classifier seat is not asked again once its provider has rate limited it on three classifications in a row, and a status frame says whose model call it is about (#2876; behavior change, open to veto; hard-breaking: none; closed sets: +1 notice code `classifier.seat_rate_limited` (108 → 109), +1 knob refusal code `config.auto_mode_rate_limit_break_invalid`, +1 word set `BrainStatusSeat`; exports: none — the word set reads as `BrainStatus["seat"]`; wire +1 optional key `seat` on `status` events)
|
|
466
|
+
|
|
467
|
+
- **Before.** Every gated call walked the classifier ladder from its first rung. A classifier seat whose gateway answered HTTP 429 slept the brain's whole backoff ladder (`AUTO_MODE_CLASSIFIER_MAX_RETRIES`, 4 waits) on every call before the walk reached the main model behind it, and never recovered inside the run: a field run of 296 turns spent 5 133 s that way. The backoff's liveness frames (`status`, `phase: "rate_limited"`) carried nothing that said they were about the classifier's call, so on a client's screen the countdown read as the person's own turn's model being limited.
|
|
468
|
+
- **Now.** A rung whose dispatch ended on the provider's rate limit (an HTTP 429 that outlived the brain's own backoff, read from the reply's structured `apiErrorStatus`, not from prose) on `RunnerDeps.autoMode.rateLimitBreakAfter` classifications in a row (default 3) is not asked again for the rest of the run: the walk starts behind it, on the main model, and the record on each gate says the move it is (`GateDisposition.classifier`: requested the seat, used the main model, `fallback` `{ from, to, cause: "error" }`). One operator notice, `classifier.seat_rate_limited` (`detail: { model, to, rung, consecutive }`), is minted on the classification that tripped it. Any other outcome of the seat (a ruling, a timeout, a different failure) zeroes the count; an outcome that ends after the run's signal aborted neither counts nor zeroes (a 429 the seat answered while the run was live counts, whatever becomes of the classification after it). A retired rung is skipped wherever it sits on the ladder, and a walk that retires several rungs reports each once. Only a rung with a rung behind it retires: under `classifierFallback: "none"` (one rung) the seat is asked every time and the round stays fail-closed exactly as before. The count is the run's own, in memory — never persisted, never shared; a later run asks the seat afresh. A bad `rateLimitBreakAfter` (not a whole number of at least 1) refuses every leg's prepare with `config.auto_mode_rate_limit_break_invalid` — never clamped, never read as the default. Every `status` event for a call made for the classifier lane (the seat's model, or the main model standing in behind it) now carries `seat: "classifier"`; the frames of the run's own turn carry no `seat` key at all, byte for byte as before.
|
|
469
|
+
- **Who needs it / who is affected / compensation (open to veto).** *Needs it:* every deployment whose classifier seat shares a gateway or a quota that can answer 429 — it stops paying a full backoff per gated call for an answer that does not change, and its person stops reading the classifier's wait as their own turn's. *Affected:* a deployment that wants the cheaper seat to keep judging through a sustained rate limit — after three in a row the run's judgments come from the main model (dearer, and its judgment stands in for the seat's) until the run ends. *Compensation:* the count is a knob (a larger `rateLimitBreakAfter` asks the seat for longer), `classifierFallback: "none"` keeps asking the seat every time, the notice names the seat and the model now judging, and the next run asks the seat again.
|
|
470
|
+
- **Wire +1 (@cli @server @client-core).** `BrainStatus.seat?: "classifier"` on `status` events (a one-word closed union): present exactly on a frame about a classifier-lane call, absent for the run's own turn — a consumer reads absence as "the main loop", never "unknown". Additive and optional: a client that never reads it renders every frame as before; a client that does can show the classifier's backoff as the classifier's. The notice `classifier.seat_rate_limited` is a new operator-audience code (`ENGINE_NOTICE_CODES` 108 → 109): a host that pins the code count or renders operator notices from a closed table adds the row.
|
|
471
|
+
- **Consumers.** @cli: render a `status` frame with `seat: "classifier"` as the classifier's wait, not the turn's. @server: no change required; a deployment that maps its own auto-mode face from settings may pass `rateLimitBreakAfter` through. @client-core: the `status` frame gains the optional key. @test: construction — a gateway that answers 429 for the classifier model only; N+1 gated calls in one run dispatch the seat N times and the main model on every call; the notice appears once.
|
|
472
|
+
- **Known limits (stated).** (1) The memory is the run's: a session that spans several runs asks the seat once per run until it retires again. (2) A 429 whose `Retry-After` pushes the dispatch past `RunnerDeps.autoMode.timeoutMs` ends as a `timeout`, which is not counted. (3) The cross-process redemption's rebuilt decider (`rebuildAutoModeDecider`) has one rung and so never retires. (4) The frame names the lane, not the rung: the main model standing in behind the seat is also `seat: "classifier"`.
|
|
473
|
+
- **Pins.** `test/backlog2876-classifier-rate-limit-breaker.test.ts` (real Runner: two rate-limited classifications keep asking the seat, the third retires it and later calls never dispatch it; one notice; the record per call; a plain failure, a ruling and a timeout each zero the count; `none` and a one-rung ladder never retire; the last model is never retired; a cancel neither counts nor zeroes; the knob's default, values and refusals including through the Runner's prepare; the 429 marker comes from the structured status only; every classifier-lane frame carries the seat and the turn's own frames do not; `withStatusSeat` stamps through the active sink, a timer-fired frame included).
|
|
474
|
+
|
|
475
|
+
### A retired `TaskSpec` key the caller's object carries by lookup is refused on every prepare path — the door reads the caller's spec before any rebind (#2914; behavior narrowing, open to veto; hard-breaking: none; closed sets: none; exports: none) (@server @cli @client-core)
|
|
476
|
+
|
|
477
|
+
- **Before.** The retired-key door (`config.spec_retired_key`) and the mode word's door ran on the spec after prepare had rebound it. Two of those rebinds — the per-task agents rebuild (`TaskSpec.agents` with a delegation tool mounted) and the tool model gate — copy the spec by spreading it, which keeps only its own enumerable members. On those paths a retired key the caller's object inherits (a class instance's prototype, a spec built with `Object.create`, a proxy answering by lookup) or holds as a non-enumerable member was dropped unseen — for every row of the retired table — and an inherited `permissionMode` read as absent, so the leg ran in the default mode.
|
|
478
|
+
- **Now.** The door runs once, on the caller's spec as handed (the roster snapshot's copy keeps the prototype and every own descriptor), before the config doors — the order the resume ladder's pre-claim screen already uses. On every path the door judges what lookup finds on the caller's object, and the leg's mode is the mode word that object answers. A spec holding a retired key and another fault now reports the retired key first, as a resume already did.
|
|
479
|
+
- **Behavior narrowing, three sentences (open to veto).** *Who needs it*: a host that builds specs as class instances or proxies and relies on a retired seat it still writes being refused rather than ignored. *Who is hurt*: a host whose prototype-backed spec still carries a retired key on a task that declares `agents` or trips the tool model gate — prepare now fails with `config.spec_retired_key` where the run used to go ahead without the seat — and a spec whose first fault was another door's now reads the retired-key refusal first. *Compensation*: the refusal names the key and its replacement (the sentence and code the plain path has always given), it comes before the session is acquired, and dropping the key fixes it.
|
|
480
|
+
- **Consumers.** @server @cli @client-core: a host that hands a Proxy or a class-instance spec — look for a retired key on its prototype; nothing else changes.
|
|
481
|
+
- **Not in this release.** The other members of a spec, read after those two rebinds, still lose an inherited or non-enumerable value on those paths (#3039).
|
|
482
|
+
- **One reader per retired row.** The retired `skills[].manifest` row moved out of the spec door's table into the skills seat's own (`RETIRED_SKILLS_SEAT_KEYS`, internal), judged only by the seat's one reader over its one read of `skills`. Moved ahead of the config doors, the spec door had become a second reader of the caller's `skills` (a `skills` accessor answering differently on its second read failed a run that the seat's reader would have prepared); the resume ladder's pre-claim screen had the same second read. Same sentence, same code; a retired skill member is reported where the skills seat is read, as before this release.
|
|
483
|
+
- **Pins.** `test/backlog2914-retired-keys-caller-spec.test.ts` ① an inherited, a non-enumerable and a dotted retired key on the agents path; ② an inherited mode word read, a bad one refused; ③ the clean spec prepares, the path with no rebind refuses as before. `test/backlog2003-seat-totality.test.ts`: a `skills` accessor is read once on a fresh run; the spec door reads no member of the skills seat; the two retired tables are disjoint and together the former table. `test/backlog2914-retired-keys-caller-spec.test.ts` ①: an inherited `skills` entry carrying `manifest` on the agents path is refused by name. `test/backlog1303b-loader-and-surface.test.ts` ③: the skills seat's reader and the resume ladder refuse `manifest` with the same code.
|
|
484
|
+
|
|
485
|
+
### The Bash tool's description states one fact about the working directory — each call starts where the previous one ended (#2873; prompt text only; hard-breaking: none; closed sets: none; exports: none) (@cli)
|
|
486
|
+
|
|
487
|
+
- **Before.** "Working directory persists between calls … a `cd` carries over" stood beside "the shell is re-initialized each call, starting at the configured root". Only the first describes the tool: a call runs in the tracked per-task directory and the directory it ends in is read back. Models read the second sentence and put a `cd` into the project in front of every command (cli: 1 202 times in one session).
|
|
488
|
+
- **Now.** "Working directory persists between calls, but prefer absolute paths — each call starts in the directory the previous call ended in, so a `cd` carries over and moves the base for every later command. Shell state (env vars, functions) does not persist; the shell is re-initialized each call." This is the reference's sentence shape (`Working directory persists between calls, but prefer absolute paths — …`) with sema's reason kept. The tool listing's prompt-cache fingerprint changes once.
|
|
489
|
+
- **Pins.** `test/backlog2873-bash-cwd-sentence.test.ts` (the real tool's description, and a `cd` in one call setting where the next call starts on a real shell); `test/prompt-golden-1302.json` refrozen for this one sentence.
|
|
490
|
+
|
|
491
|
+
### The `workspace_changed` contract says who receives the frame: the leg's own event stream (#2890; contract text only, no engine change; hard-breaking: none; closed sets: none; exports: none) (@server)
|
|
492
|
+
|
|
493
|
+
- **Now.** docs/INTEGRATION-CORE.md §1.8 adds one sentence to the frame's row: the frame rides the leg's own event stream, so `Runner.runTask` and the compositions that drain their legs' streams themselves (`runWithVerification` / `resumeWithVerification` / `runDeveloperTask`, `runCascade`) hand their caller no leg stream, and that caller receives no `workspace_changed` frame from those legs. This is within the contract (server [11986] ④). A deployment that needs where a verify or cascade leg stood would need a frame hook, which is a separate design request and is not in this release.
|
|
494
|
+
- **Pins.** `test/backlog2890-workspace-frame-contract-sentence.test.ts` (the row's sentence; the stream half: a consumer of a prepared leg's stream gets the leg-start frame).
|
|
495
|
+
|
|
496
|
+
### A URL password holding `'` is taken out of a text, and the brain's request-error strip reads the same userinfo grammar (#3018; security narrowing — a credential leak, open to veto; hard-breaking: none; closed sets: none; exports: none) (@server @cli)
|
|
497
|
+
|
|
498
|
+
- **Before.** The vocabulary's userinfo row read a userinfo as characters that are no `/`, white space, `"`, `'` or `@`. `'` is one of RFC 3986's sub-delims, so `https://user:pa'ss@host` matched nothing, and the password left through every exit that reads the egress pass (`redactSecrets`, a sync refusal sentence, a response error, a tool result). On the human tier the whole-URL pass then stopped at the `'` and left `ss@host…` in the text. The brain's `stripUrlCredentials` (a request-build failure's text) kept its own copy of the class and stopped at the first `@`, so `https://u:p@ss@host` kept `ss@` of the password.
|
|
499
|
+
- **Now.** One grammar, `URL_USERINFO_SOURCE` (`credential-vocabulary.ts`): characters that are no `/`, white space, `"` or `@`, up to the last `@` before the host. It covers every RFC 3986 userinfo character (`'` included) and what an unencoded password carries (`#`, `?`, …), so it narrows nothing the row took before. Both readers match it and each renders its own way: the egress pass keeps the username, the brain's strip removes the whole userinfo — and `https://u:p@ss@host` is now removed whole. The two readers share the scheme grammar too (`URI_SCHEME_SOURCE`, as does the human tier's whole-URL pass), now of any length: it is read from the start of its run of scheme characters, so each run is tried once (linear), where the 64-character cap it replaces missed a longer scheme — a scheme glued behind digits keeps them in the text. The vendor-prefix rows keep their front boundary: `sk-…` glued behind a letter (`losk-…`, `xsk-…`) is still no credential.
|
|
500
|
+
- **Narrowing, three sentences (open to veto).** *Who needs it*: anyone whose URL password holds a `'`. *Who is hurt*: a text holding `scheme://` and then, with no white space, a `'` and an `@` that is no credential — a single-quoted list with no spaces (`'https://a','b@c'`) — now has the span between `://` and that `@` replaced; on the human tier a URL glued behind digits or marks (`1https://…`) is replaced together with them. *Compensation*: the span is replaced by the credentials mark, never refused, and double-quoted (JSON) text reads as before.
|
|
501
|
+
- **Pins.** `test/backlog3018-userinfo-grammar.test.ts` ① four passwords (`'`, `;`, `=`, a percent escape) replaced on the egress pass with the username kept, a password holding `@`, one written unencoded with `#` / `?`, a JSON string's closing quote; ② the human tier leaves no part of the password; ③ the brain's strip on the same passwords and on `@`; ③b a 65-character scheme in both readers, a scheme glued behind digits; ④ the front boundary kept.
|
|
502
|
+
|
|
503
|
+
### A language server's root is a project directory, never the home directory — a file with no project marker below the home directory gets no server, and the LSP tool says why (#2872; behavior narrowing, open to veto; divergence from the reference D-2872, open to veto; hard-breaking: none; closed sets: none — the degrade reuses the tool's `LSP is unavailable` line; exports: none; members: `NodeLspManagerOptions.resolveRoot` may answer `undefined`) (@cli @server)
|
|
504
|
+
|
|
505
|
+
- **Before.** `NodeLspManager`'s default root was the environment's cwd whenever it had one (else the nearest marker above the file, else the file's own directory). A session started in the home directory therefore rooted every language server there — a Swift server indexing the whole home directory (cli IMG156-11).
|
|
506
|
+
- **Now.** The default root is read from the project markers the manager already keeps (`ROOT_MARKERS`: `.git`, `package.json`, `go.mod`, `Cargo.toml`, `pyproject.toml`, `Package.swift`, …): the cwd when it holds one (as before), else the nearest directory holding one above the file. The home directory (the environment's declared `homeDir`, else this process's) and every directory above it are never a root, marker or not — a dotfiles `.git` makes the home directory look like a project; directories are compared by their physical paths (the one physical-path mint, `physicalPathOf`), so a symlinked spelling of the home directory is the home directory. A file with no marker below them has no root: no server starts, the LSP tool answers `LSP is unavailable for "<file>" (no project root: …). Fall back to Grep/Read for this lookup.`, and the manager's `log` hook receives `lsp_root_refused`. A custom `resolveRoot` may answer `undefined` for the same outcome.
|
|
507
|
+
- **Behavior narrowing, three sentences (open to veto).** *Who needs it*: a person who starts a session in the home directory — no language server indexes everything under it. *Who is hurt*: a file outside every project (a loose script in a folder with no marker), which had a server rooted at its folder or the cwd and now has none; and a host whose `evict(root)` passes a cwd that holds no marker — that task's servers are rooted at the files' project directories and are reclaimed by the idle sweep instead. *Compensation*: the degrade line names the cause; any marker in the folder (`git init`, an empty `package.json`) brings the server back; a host that wants the old reading passes its own `resolveRoot`.
|
|
508
|
+
- **Divergence (D-2872, open to veto).** The reference roots a language server at its configured workspace folder or the session's cwd, home directory included (cli309.js:266959, `n.workspaceFolder||pe()`). sema refuses the home directory because a server rooted there indexes everything under it (cli IMG156-11): this is about what gets read and its privacy, not a feature trade.
|
|
509
|
+
- **Consumers.** @cli (the L-2122 family): a session started in the home directory gets the degrade line for a file outside a project, and a server rooted at the project for a file inside one. @server: a host lane that calls `evict(env.cwd)` at task end keeps working for a cwd that holds a marker.
|
|
510
|
+
- **Pins.** `test/backlog2872-lsp-root-not-home.test.ts` ①–⑥ (cwd = home with a file in it and under a markerless folder; home holding `.git`, also under a symlinked spelling of the cwd or of the declared home; a project below home; a project cwd with a nested package; a markerless cwd; the LSP tool over a real `NodeExecutionEnv` started in a declared home). `test/backlog1073-lsp-child-env.test.ts` and `test/backlog1753-lsp-withheld.test.ts` re-pinned: their temporary folders now hold a `package.json`.
|
|
511
|
+
|
|
512
|
+
### A stop reaches the main model call whether or not the brain looks at the signal (#2882; behavior change: a halt, an interrupt or a cancel no longer waits for a brain that ignores the abort; hard-breaking: none; closed sets: none; exports: none) (@server @cli @test)
|
|
513
|
+
|
|
514
|
+
- **Before.** The loop read the brain's stream and waited for it. A halt (and an interrupt, a caller's abort, the walltime cut) aborted the turn's signal and left the rest to the brain. A brain that does not honour the signal — a third-party or wrapped brain, a transport that stalls — held the run until it answered. The compaction pass's summary call had the same gap until 7.59.0 (#2875).
|
|
515
|
+
- **Now.** One rule for both lanes: the model call is an await of the turn, settled by the turn's signal. The loop reads the brain's answer through one relay (`engine/loop/agent-loop.ts`); every await of the call is one — the stream's opening, each event and the final, which is read while the brain's iterator is still open, as before (the Runner's call guardrail stays armed until it is in). The brain's events pass as they come. When the signal fires and the brain's final is not in by the next macrotask turn, the turn ends with the loop's own aborted final — the shape the pre-dispatch gate already answers with: no content, `usageMissing` — and whatever the brain sends later is dropped. A brain that answers its own abort through the abort's own continuations keeps its answer, as the first-party brain does. A halt still reads as the person's stop (`haltedByUser`, completed); a caller's abort that the loop's final answered reads `run aborted`.
|
|
516
|
+
- **Known limit.** The ignored call keeps running: the engine cannot stop a call that does not look at its signal. Its turn's usage reads as unknown (`usageMissing`), and its late answer is never counted (KL-2875-a, now both lanes).
|
|
517
|
+
- **Consumers.** @server @cli: a stop on a provider that hangs now ends the run promptly; nothing to change. @test: black box — a brain that never answers and ignores the signal, halted while its call is open, ends the run within a second with `haltedByUser`.
|
|
518
|
+
- **Pins.** `test/backlog2882-halt-main-lane.test.ts` ①–⑦ (a silent brain, one that streamed part of an answer, one whose call never returns a stream; a caller's abort; the late answer reaching nothing; a brain that answers its own abort keeping its own words, and a halt on it as before; a brain whose final never comes after its terminal event, and one whose `result()` throws — the throw fails the run as it always did).
|
|
519
|
+
- **A delivery that throws lets the brain go (#3093).** When the loop's handling of a model event throws before the terminal event (a `message_start` or `message_update` sink), the relay stops reading the brain, calls its iterator's `return()` once without waiting on it, and drops its abort listener — before, the relay's producer kept reading the provider's stream with nothing consuming it until the stream ended on its own. A brain whose own read throws is not returned (its iteration is over, as a `for await` over it read it), and a call whose events were read to their end keeps its final cuttable by the turn's signal. Behavior fix; hard-breaking: none. Pins: `test/backlog3093-relay-consumer-exit.test.ts` R1–R5.
|
|
520
|
+
- **A guarded call left before its answer is cancelled (#3103).** Letting a brain's iterator go does not stop its request — a stream's own `return()` need not cancel it — and under the call guardrail (on by default) that `return()` also disarmed the gate, dropping the forward from the turn's signal into the signal the brain holds; so after a sink threw, the provider request ran on and nothing could cancel it any more. The guardrail's `return()` now aborts the signal the brain holds before it disarms, when the brain's terminal event has not passed yet; after the terminal event, or once the call ended (its iteration over, its result settled), it only disarms, so a call that ends on its own is never aborted. The run still fails with the sink's own error. With the guardrail off, the brain holds the turn's signal itself and the relay's exit does not cancel its request: the provider request runs to its own end — after the sink failure nothing holds a handle to cancel it (KL-3103-a). Behavior fix; hard-breaking: none. Pins: `test/backlog3103-guardrail-abandon-aborts.test.ts` G1–G6.
|
|
521
|
+
- **Wake cycles.** A wake cycle's first tool call can now land after the parent run's teardown abort (the relay adds one producer/consumer hand-off before dispatch); a parent's end aborting in-flight resume cycles is the existing D4 contract — hosts must not rely on the first tool racing ahead of the parent's end.
|
|
522
|
+
|
|
523
|
+
### CronCreate and CronList report the job's next run when the scheduler backend knows it — `details.nextFireAt` and a sentence in the result (#2682; aligned with Claude Code; wire +1 optional key; hard-breaking: none; closed sets: none; exports: none)
|
|
524
|
+
|
|
525
|
+
- **Before.** The tools returned the schedule and the id; the backend's `ScheduledTaskSummary.nextRunMs` was read by nobody, so a model that scheduled a reminder could not say when it would fire.
|
|
526
|
+
- **Now.** CronList prints `, next run <ISO instant>` on a row and puts `nextFireAt` (epoch ms) on that row of `details.jobs`; CronCreate appends ` Next run: <ISO instant>.` to its receipt and puts `nextFireAt` on `details`, read with one more `list()` of the same leg inside the call's serialized section (the seam's `schedule()` returns only the handle, and the next-run fact has one reading: the listed summary). Only what the backend reported is shown: absent, non-finite or above `Date`'s upper bound ⇒ no clause and no key, never a guess; an instant already past — one below `Date`'s lower bound too — is clamped to now, as the reference clamps it. A listing that fails after the schedule landed leaves the clause out; the created job is never reported as an error. The call's own context is read for its cancellation only: whether a session-scoped job has a session to bind to is still read from the identity the tools were mounted with.
|
|
527
|
+
- **Consumers.** @cli @client-core: `details.nextFireAt?: number` on `cron-create` and on each `cron-list` job (the upstream output schema's own optional key); a card that ignores it is unchanged. A backend that never fills `nextRunMs` changes nothing for its users.
|
|
528
|
+
- **Pins.** `test/backlog2682-schedule-next-fire.test.ts` (the instant on both tools and in the text, absent / replaced / failing-listing / past / non-finite and out-of-range cells); `test/rb449-scatter-review-fixes.test.ts` (the serialization fixture does not count the read-back as a section opening).
|
|
529
|
+
|
|
530
|
+
### An unparseable tool call is retried up to twice in a row, and a turn whose tool calls ran clears the count (#2684; aligned with Claude Code 2.1.307; behavior change, open to veto; hard-breaking: none; closed sets: none; exports: none)
|
|
531
|
+
|
|
532
|
+
- **Before.** With the malformed-tool-use recovery on (the Runner's default), the engine nudged once per RUN: the second turn whose every tool call was dropped as malformed ended the run as `malformed_tool_use_exhausted`, however many working turns lay between the two.
|
|
533
|
+
- **Now.** `recovery.malformedToolUse.maxRetries` defaults to 2 and counts consecutive malformed turns: any turn with a parseable tool call (the tools ran) resets it, so the terminal reason now says "this many in a row" and no longer "this many over the run".
|
|
534
|
+
- **Who needs it / who is affected / compensation (open to veto).** *Needs it:* a long task where a model emits a truncated call now and then no longer dies on the second one. *Affected:* a run that would have ended on its second malformed turn now spends one more turn (and tokens) before `malformed_tool_use_exhausted`; a host reading that reason as "twice in the run" reads it as "three in a row" now. *Compensation:* an explicit `maxRetries: 1` keeps the old budget (still counted in a row).
|
|
535
|
+
- **Pins.** `test/loop-transitions.test.ts` (the default budget is two nudges then exhausted; an explicit budget; recovery on the last of the default two; the streak clears across working turns and still ends after a fresh budget of two).
|
|
536
|
+
|
|
537
|
+
### A missed `Skill` call says which listed skill it likely meant (#2688; aligned with Claude Code 2.1.299; hard-breaking: none; closed sets: none; exports: none)
|
|
538
|
+
|
|
539
|
+
- **Before.** `Unknown skill "<name>". Available skills: …` for every miss, including a model that asked for `anthropic-skills:pdf` where the listing says `pdf`.
|
|
540
|
+
- **Now.** The refusal adds `Did you mean <listed name>? Invoke it by that full name.` when a listed name is within two edits of the asked one, else when the asked name minus the other product's `anthropic-skills:` prefix is listed. The suggestion is a sentence: the one name resolution is unchanged, so nothing activates, binds or digests under an inexact name.
|
|
541
|
+
- **Pins.** `test/backlog2688-skill-name-suggestion.test.ts` (prefix, typo and transposition, no suggestion for a far or blank name, the nearest name before the prefix reading, nothing activated, an exact name served).
|
|
542
|
+
|
|
543
|
+
### A deny / ask rule on an MCP name reads it as the reference does — a server whose own name carries `__` is covered — and an allow entry on an ambiguous spelling is refused with the reference's sentence (#2980 ①; security; behavior narrowing of grants, widening of restrictions; open to veto; hard-breaking: the session rule grammar is 7, open to veto; closed sets: none; exports: none)
|
|
544
|
+
|
|
545
|
+
- **Before.** The mint folds a server segment's run of `_` (`a__b` is spelled `a_b`), and every rule name was split once at its first `__`. A rule written the reference's way, `mcp__a__b` for the server `a__b`, read as tool `b` of server `a` and matched none of that server's tools: a deny / ask that looked protective and was inert.
|
|
546
|
+
- **Now.** A deny / ask MCP name with `__` in its body reads every way it can be read — a cut at each `__` (server = before, tool = after, the server spelled as the mint spells it) and the whole body as a server — so `mcp__a__b` covers tool `b` of server `a` AND every tool of server `a__b`, and `mcp__a__b__t` covers tool `t` of server `a__b` and tool `b__t` of server `a`. The same reading serves the policy rule lanes, the covering name lists, a sub-agent's denied list and a stored whole-tool row. A granting list keeps the one exact name: `mcp__a` never covers `a__b`'s tools, and an allow entry the run's roster shows to read as another server's spelling (no tool of that exact name, a tool on another reading) is read as nothing in the reference's words — "the name reads as more than one MCP server's. To allow it, use the tool's full name." — with the spelling the roster carries; a toolPolicy allow list reports it as an unmatched name instead of refusing the run. The mint is unchanged. A stored whole-tool rule still names one tool (the stored-rule grammar asks `namesASetOfTools`, not the covering predicate).
|
|
547
|
+
- **Behavior change, three sentences (open to veto).** *Who needs it:* anyone who carries rules written for the reference's server spelling. *Who is affected:* a restricting list now also matches tools of a server named like the rule's whole body (more deny / ask, never less); an allow entry that was silently inert next to a roster that shows the other reading is now named. *Compensation:* write the minted spelling (`mcp__a_b__<tool>`) — the sentence names it.
|
|
548
|
+
- **Consumers.** @server @cli @client-core: no wire key; `RuleToolNameVerdict`'s `unmintable_segment` gains an optional `ambiguous?: true`, and `isCoveringRuleName(name, "deny" | "ask")` is true for a name with two readings (it was false for an exact tool name); a host that stored the old reading of `isCoveringRuleName` for exact MCP names re-pins.
|
|
549
|
+
- **The rule grammar moved with the meaning: `SESSION_RULES_GRAMMAR` is 7.** A session's stored `toolDeny` entry `mcp__a__b` meant the one exact tool in every earlier grammar, so a row stamped 6 or below keeps that meaning and is announced once per layer (`config.session_rules_earlier_grammar`, reader `grammar_revised`: what its writer read, what this grammar reads, the stored meaning stands); a row this engine writes is stamped 7 and covers both spellings. Globs, protocol peers and allow entries are not revised. The persisted rule store and the rule-sync wire carry the same stamp; that store keeps no earlier-stamp reading, so a whole-tool deny / ask `mcp__a__b` in a bucket stamped 6 reads the grammar-7 way (wider; the earlier reading it is owed is #3085). So does a stored session row handed back to a write (an export → import replay): the write stamps 7, and the entry takes the wider reading unannounced — the same as a row kept by an earlier revision (a grammar-4 `toolDeny: ["Re*d"]` replayed reads the pattern); #3085 too.
|
|
550
|
+
- **Hard-breaking, three sentences (open to veto).** *What changed:* session rule rows, persisted rule buckets and rule-sync states this engine writes carry grammar 7. *Who is hurt:* a mixed-version fleet — a 7.59.0 engine (grammar 6) reading a session row or a persisted bucket a 7.60.0 engine wrote refuses it loudly (the row refuses every call; the bucket loads zero rules with `permission_rules.later_grammar`; a sync round is refused whole) instead of reading the deny as the narrower exact tool; @server (a shared session store or rule bucket across engine versions; the rule-sync twin), @cli, @test (fixtures that pin the number 6). *Migration:* upgrade the engines that share a store in one step; the refusal sentence names both grammars ("written in rule grammar 7, newer than this engine reads (grammar 6)").
|
|
551
|
+
- **Known limits (stated).** The allow-side refusal is as true as the roster the entry is read against: a server that connects after the roster is read leaves an ambiguous entry as it was (inert for the other reading). `peerReadingsOf` reads MCP names only; other protocols' peers are named as the roster spells them.
|
|
552
|
+
- **Pins.** `test/backlog2980-mcp-server-spelling.test.ts` (the readings; deny and ask each on both readings; the tool-level spelling; stored rule and sub-agent list; `mcp__a` does not cover `a__b`'s tools; the allow verdict, entry and sentence); `test/backlog1879-rule-name-one-reader.test.ts` F4 (a grammar-6 row's exact MCP deny keeps the one tool, announced; a grammar-7 row covers both spellings; the write mints 7; the later-stamp sentence); `test/backlog1385-entry-grammar-one-render.test.ts` / `test/backlog7480-smallfix.test.ts` (a deny list compiles the exact MCP name to a covering row, an allow list to a tool row).
|
|
553
|
+
|
|
554
|
+
### A file `writeFile` replaces is staged owner-only until the target's own mode is applied — the new content of a 0600 file is never readable by another user while it is written (#3120; security fix; behavior change: a replace only, a create is unchanged; hard-breaking: none; closed sets: none; exports: none) (@server)
|
|
555
|
+
|
|
556
|
+
- **Before.** `NodeExecutionEnv.writeFile` stages a whole-file replace in a same-directory `.tmp.<pid>.<hex12>` sibling and renames it over the target. The sibling was opened with no mode — 0o666 under the umask, 0644 on a typical host — and the whole new content was written before the fchmod to the target's mode, so replacing an owner-only (0600) file left its new content readable by every other user of the machine, in the same directory, for the length of the write (seconds for a large file). A host lane that writes through this primitive inherited the window; the in-place `O_TRUNC` write it replaced kept the file's inode and mode.
|
|
557
|
+
- **Now.** A replace opens the sibling owner-only (0o600) and applies the target's mode before the rename, as before: the sibling is never more readable than the file it replaces, and a 0755 script is already 0755 when it is renamed. A create still opens the sibling with 0o666 and leaves the umask (or the directory's default ACL) to the kernel, so a new file's mode is byte-for-byte what it was; it has no older content to protect, and its final mode is what it carries while written. A process that dies mid-write now leaves its staging residue 0600 instead of a half-written 0644 file holding the new content.
|
|
558
|
+
- **Behavior change, three sentences.** *What changed:* replacing an existing regular file stages it 0o600 instead of the umask mode. *Who is affected:* a filesystem that refuses the fchmod with the support errors the replace already tolerated (EINVAL / ENOTSUP / EPERM / ENOSYS) yet honours the open mode now ends a replaced file 0600 instead of the umask mode — fail closed (KL-3120-a); directory watchers and indexers can still list the staged sibling, and what they see is now owner-only. *What to do:* nothing on the engine path; @server, in the server's words: server 7.139.0: the five remote lanes stage a sibling that is never more readable than the target from creation (FIXSTAGEMODE moves staging into a writer-private 0700 directory and brings the adb / docker host-side `os.tmpdir` relay files under the same rule); the host lane inherits this fix through core 7.60.0 #3120.
|
|
559
|
+
- **Divergence (open to veto).** The staging mode is a 0o600 constant where CC 309 uses `existingMode & 0o777 | 0o200`; 7.61.0 #3121 moves to the CC form.
|
|
560
|
+
- **Pins.** `test/backlog3120-staging-tmp-private-mode.test.ts` — the staged sibling's mode observed right after open, right after the content write and right before rename: P1 replacing a 0600 file (4 MiB) and P1b through a one-hop symlink stay owner-only throughout; P2 a 0755 script is staged owner-only and is 0755 at rename; P3 a create ends at the umask create mode (022 → 0644, 002 → 0664); P4 a create under umask 077 ends 0600; P5 an fchmod the mount refuses (EPERM) ends the replaced 0644 file 0600, owner-only throughout; a multi-hop symlink chain keeps the in-place write; the Write tool reaches the same rule.
|
|
561
|
+
|
|
562
|
+
no-notes: #454(repo tool scripts/probe-external-go.mjs and its package.json script `probe:external-go`: the SDK v2 external-condition probe, exit 0 GO / 1 NO-GO / 2 could not judge; not in the package, no gate-all roster row), #2916(repo release tooling: the car reader of the ship lint and the re-window reads a fast-forwarded car as in the release; scripts/release/lib.mjs, not in the package), #2921(repo tool post-ship: the PLANS row it writes opens the next window; not in the package), #2922(new repo gate gate:changelog-released-blocks with a frozen baseline docs/changelog-released-blocks.baseline.json; not in the package), #2923(repo release tooling: the chain's r-commit gate table asks gate:debts:rc at the release's own version; not in the package), #2932(repo gate verify-debts: a hex string stuck to digest: / sha256: / sha1: / integrity: / md5: is a content digest, not a commit coordinate; not in the package), #954(the credential-vocabulary parity pin's ledger text names the new keyword row; a test-file text change only, no engine behavior), #2979(the module-size ratchet rows of three oversize files cite the 7.61.0 split design ticket; test-file bookkeeping only; not in the package), #2861(the flaky-fix car only re-pins three merged tests; test files only, no behavior), #1549(the fix-2846 car re-pins the class-instance extraBody arm against the model door snapshot; test files only; no behavior beyond #2846), #1663(the fix-2846 car adds cells to the prompt-traits pin for the model door snapshot; one test file only; no behavior beyond #2846), #2966(the chain3-fix car re-pins four merged tests whose fixtures mount a seatless caller write tool or a caller Bash under default: each cell now sets aside exactly the load-time ungated-write notice this section documents; test files only, no behavior beyond #2966), #2994(docs/INTEGRATION-CORE.md Steer paragraph names which judgments read a steer, plus three pins; no engine change, the verb has read the live mode since 7.34.0), #2899(repo gate gate:changelog-coverage: a merge commit's subject line and a ledger row RESOLVED-PENDING-TEST-VERIFY at a commit of the range now count as tickets the range delivered; scripts only, not in the package), #2971(repo gate gate:backlog-ledger: a passed MM-DD window is a warning row naming the row, never red; red stays for format, closed sets and a second source of one fact; scripts only, not in the package), #2974(repo gate verify-debts: the pending-window category set drops the state word 候裁, seven words to six; scripts only, not in the package), #2494(repo gates and release tooling: the ledger gate caps the cars in flight (eleven, FIX cars not counted) and no longer the rows a window holds, a leftover window-cap declaration is red by line, rewindow writes no capacity and reports the next window's count; scripts and docs only, not in the package), #3037(the 2944 read-floor pin reaches git through the scripts/git-cli.mjs seam; one test file only, no behavior), #697(a #3025 commit re-pinned the parent-spec-seat pin's launch-note line — the one-shot note arm it read is the #3025 entry's; one test line only), #3041(repo tools only: the ledger gate accepts the terminal status word CLOSED-DESIGN-LANDED as a landed state and the release re-window no longer refuses a DESIGN-DONE row for lacking a car coordinate and lists per design what its implementation tickets say; scripts and pins; not in the package), #3045(repo tool scripts/wire-changes.mjs: the manifest generator reports a moved version literal — an exported VERSION integer constant or a version-named integer-literal member — as a version literal changed line of breakingItems and a versionLiterals row; WIRE: none cannot cover one; scripts and pins; not in the package), #3080(the chain-8 fix car's changes are told in the #2682 entry — the call context is read for its cancellation only — and the #2980 entry — the rule grammar 7 and its hard-breaking sentences; no entry of its own), #7(not a ticket: the number is a release-chain run label in the subject of the #2987 fix commit that follows chain 7; that fix is told in the #2987 entry — the tool-result seat resolves the run's image processor only once a block claims media; no entry of its own), #3096(a comment-only sentence on `SubagentToolOptions.background.notify`: an operator resume completes into that sink whether or not a run drives the mount; no entry of its own)
|
|
563
|
+
no-notes: #3065(a fix inside this window's own #3025 code: the delivery-obligation ledger keyed on the bare task_id instead of the notification lane key and routed an operator's resume completion into the spawn run lane; both corrected before release; no released behavior changed), #3066(a fix inside this window's own #2914 move: the retired-key table is split by reader `RETIRED_SKILLS_SEAT_KEYS` and five continuation pins re-pinned; no released behavior changed), #3067(a stale pin re-pinned after #2948; zero src), #3069(repo tool scripts/verify-debts.mjs: two new ledger states read; not in the package)
|
|
564
|
+
|
|
1
565
|
## 7.59.0 — 2026-10-27
|
|
2
566
|
|
|
3
567
|
### A model call waiting on a gateway gives up within 599 s however large the request, and a host that slept through a wait reconnects at the first second after waking — `sleptMs` on the reconnect frame, `waitSegment` on the wait frame (#2870; behavior narrowing: the first-byte window's upload allowance is capped; hard-breaking: none; closed sets: one new, `BrainStatus.waitSegment`; exports: none; members: +2 optional on `BrainStatus` / the `status` event) (@cli @server @client-core)
|