@sema-agent/core 7.64.0 → 7.65.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (103) hide show
  1. package/CHANGELOG.md +317 -0
  2. package/dist/agents/peer-held-queue.js +1 -1
  3. package/dist/agents/peer-idle.js +1 -1
  4. package/dist/agents/peer-session-drain.js +3 -3
  5. package/dist/agents/subagent.js +5 -2
  6. package/dist/core/auto-promote.d.ts +3 -2
  7. package/dist/core/background-agent-store.d.ts +7 -0
  8. package/dist/core/checkpoint-store.d.ts +2 -3
  9. package/dist/core/context-settings.d.ts +1 -2
  10. package/dist/core/context-settings.js +1 -1
  11. package/dist/core/engine-attestation.d.ts +2 -2
  12. package/dist/core/engine-notice.d.ts +13 -1
  13. package/dist/core/engine-notice.js +3 -1
  14. package/dist/core/file-history-store.d.ts +2 -2
  15. package/dist/core/file-history-store.js +0 -4
  16. package/dist/core/gate-fold.js +3 -1
  17. package/dist/core/governance-codes.d.ts +6 -4
  18. package/dist/core/governance-codes.js +4 -3
  19. package/dist/core/leg-identity.d.ts +18 -2
  20. package/dist/core/leg-identity.js +5 -7
  21. package/dist/core/mailbox-store.d.ts +1 -1
  22. package/dist/core/memory-engine/consolidation.d.ts +10 -4
  23. package/dist/core/memory-engine/consolidation.js +11 -1
  24. package/dist/core/memory-engine/control-objects.d.ts +36 -3
  25. package/dist/core/memory-engine/control-objects.js +134 -12
  26. package/dist/core/memory-engine/control-plane-adoption.d.ts +5 -2
  27. package/dist/core/memory-engine/control-plane-adoption.js +5 -3
  28. package/dist/core/memory-engine/delegation-settlement.d.ts +59 -42
  29. package/dist/core/memory-engine/delegation-settlement.js +175 -202
  30. package/dist/core/memory-engine/dual-root.d.ts +3 -2
  31. package/dist/core/memory-engine/dual-root.js +5 -1
  32. package/dist/core/memory-engine/engine.d.ts +16 -10
  33. package/dist/core/memory-engine/engine.js +138 -145
  34. package/dist/core/memory-engine/file-backend.d.ts +17 -11
  35. package/dist/core/memory-engine/file-backend.js +53 -103
  36. package/dist/core/memory-engine/layout.d.ts +129 -49
  37. package/dist/core/memory-engine/layout.js +202 -82
  38. package/dist/core/memory-engine/memory-age.d.ts +12 -0
  39. package/dist/core/memory-engine/memory-age.js +17 -0
  40. package/dist/core/memory-engine/memory-backend-contract.js +5 -4
  41. package/dist/core/memory-engine/memory-deployment.d.ts +1 -1
  42. package/dist/core/memory-engine/origin-clearance.js +1 -5
  43. package/dist/core/memory-engine/tools.d.ts +2 -2
  44. package/dist/core/memory-engine/tools.js +7 -7
  45. package/dist/core/memory-engine/types.d.ts +16 -10
  46. package/dist/core/memory-vector.d.ts +6 -14
  47. package/dist/core/memory.d.ts +0 -462
  48. package/dist/core/memory.js +0 -333
  49. package/dist/core/permission-rule-consent.d.ts +49 -18
  50. package/dist/core/permission-rule-consent.js +59 -38
  51. package/dist/core/permission-rule-store.d.ts +24 -14
  52. package/dist/core/retention.d.ts +2 -7
  53. package/dist/core/retention.js +0 -1
  54. package/dist/core/runner/classifier-ladder.d.ts +3 -1
  55. package/dist/core/runner/classifier-ladder.js +2 -2
  56. package/dist/core/runner/contracts.d.ts +9 -9
  57. package/dist/core/runner/delegation-owner.d.ts +0 -8
  58. package/dist/core/runner/delegation-owner.js +1 -3
  59. package/dist/core/runner/prepare-gate-stations.d.ts +8 -5
  60. package/dist/core/runner/prepare-gate-stations.js +13 -5
  61. package/dist/core/runner/prepare-memory-engine-session.js +1 -1
  62. package/dist/core/runner/prepare-memory.js +9 -9
  63. package/dist/core/runner/prepare-policy-chain.js +11 -3
  64. package/dist/core/runner/prepare-task.d.ts +5 -1
  65. package/dist/core/runner/prepare-task.js +3 -3
  66. package/dist/core/runner/run-notification-lane.js +1 -1
  67. package/dist/core/runner/sub-agent-deny-lists.d.ts +19 -0
  68. package/dist/core/runner/sub-agent-deny-lists.js +25 -0
  69. package/dist/core/secret-env.d.ts +2 -2
  70. package/dist/core/secret-env.js +6 -20
  71. package/dist/core/session-store.d.ts +6 -6
  72. package/dist/core/session-store.js +3 -3
  73. package/dist/core/store-contracts/background-agent-store-contract.js +13 -0
  74. package/dist/core/task-notification.d.ts +35 -8
  75. package/dist/core/task-notification.js +31 -13
  76. package/dist/core/task-registry-agent.js +1 -0
  77. package/dist/core/task-registry-shared.d.ts +4 -0
  78. package/dist/core/tool-errors.d.ts +3 -3
  79. package/dist/core/tool-spec.d.ts +7 -7
  80. package/dist/core/write-protect.d.ts +16 -0
  81. package/dist/core/write-protect.js +10 -0
  82. package/dist/engine/session/repo-utils.d.ts +14 -4
  83. package/dist/engine/session/repo-utils.js +5 -4
  84. package/dist/index.d.ts +6 -6
  85. package/dist/index.js +6 -6
  86. package/dist/prompts/default.d.ts +1 -2
  87. package/dist/scenarios/full-body.d.ts +1 -1
  88. package/dist/stores/file/adoption/adopt.d.ts +1 -1
  89. package/dist/stores/file/index.d.ts +1 -15
  90. package/dist/stores/file/index.js +1 -15
  91. package/dist/stores/file/permission-rule-store.d.ts +12 -1
  92. package/dist/stores/file/permission-rule-store.js +31 -4
  93. package/dist/stores/file/session-store.js +1 -1
  94. package/package.json +2 -2
  95. package/test/export-surface.snapshot.json +9 -73
  96. package/wire-changes/core-stores-sql@7.65.0.json +30 -0
  97. package/wire-changes/core@7.65.0.json +1650 -0
  98. package/wire-changes/mods-kernel@7.65.0.json +30 -0
  99. package/wire-changes/primitives@7.65.0.json +337 -0
  100. package/dist/core/memory-recall.d.ts +0 -208
  101. package/dist/core/memory-recall.js +0 -136
  102. package/dist/stores/file/memory-store.d.ts +0 -124
  103. package/dist/stores/file/memory-store.js +0 -353
package/CHANGELOG.md CHANGED
@@ -1,3 +1,320 @@
1
+ ## 7.65.0 — 2026-11-03
2
+
3
+ ### Errata to the 7.64.0 section and to the errata it carries (those sections are frozen; the corrections live here)
4
+
5
+ - **The ticket that carries the server's second-redaction retirement.** The 7.56.0 section's "How to migrate" named S-2027 for it, and the 7.64.0 erratum for that section corrected it to S-2026. Neither is the live ticket: the retirement of the server's own second redaction is carried by **S-3162** (its exit seat's second redaction; it is blocked on this engine's vocabulary reaching the same forms, #2570). S-2026 is the server's 7.138.0 delivery of two single mint points, closed and not reopened; S-2027 stays the ticket for the `Cookie` / `Set-Cookie` header lines and the `x-amz-security-token` header, as the 7.64.0 erratum says. The instruction itself (the server retires its own second redaction) stands. Source: @server direct message, 11-03.
6
+ - **"@server: projects `gate` whole — no key to add".** The Consumers paragraphs of the 7.64.0 sections for #3410 and #3442 said so. Untrue: the server rebuilds the refused arm of `tool_end.gate.disposition` key by key (`screenedGate`, `src/trace/project.ts`) and guards the members it knows (`_GuardGateDisposition`, `src/trace/core-keyset-guard.ts`), so a new member of `GateDisposition` is stripped until the server adds it to its projection and its guard. `echoed` is such a member: the server's pickup of 7.64.0 added it (each element rebuilt as `{ kind, value, canonical? }`, `value` and `canonical` through its exit-seat text redaction), and the guard was red on 7.64.0 until then. The 7.59.0 section for #2810 has the same projection sentence about `gate.disposition.extension`; it was not re-checked here. Source: @server review of the 7.64.0 pickup, 11-02.
7
+ - **"The batch path (`redeemRuleBatch`) is unchanged for the server".** The Affected paragraph of the 7.64.0 section for #3428 said so. It held for a top-level refusal and a rejection; it did not hold for an import walk's member rows. A member whose compare-and-set or dot allocation threw answered `store_write` / `unknown`, and the server read that as settled-with-an-unknown-outcome and recorded the member indeterminate, where nothing had been written and a repeat was right. The word is corrected in this release (#3492: those steps answer `committed: "no"`, and `retriable` says whether the same call may be repeated). Source: @server review of the 7.64.0 pickup, 11-02.
8
+ - **"The parked tool call dropped".** The Before paragraph of the 7.64.0 section for #3412 said that on 7.63.0 a `plan_review` gate holding a tool approval, given a plan approval, resumed, was `resolved` and "the parked tool call dropped" (M2). The black-box reading on 7.63.0 (a real Runner through the package surface, no server or shell) is different in its last step: the person's approval was consumed and the row `resolved`, the tool did not run, and the run then asked again — a second approval card for the same `toolCallId`. The call is not lost; the approval is consumed without effect and the question is put a second time. The 7.64.0 refusal and every other sentence of that section stand. Source: @test, 11-03.
9
+
10
+ ### A redemption refusal's `committed` is read one way — a store step before the rule write is `no` — and whether the same call may be repeated is its own member, `retriable` (#3492; ruled C-R1135; behavior change: the refusals of a dot allocation, of the approval record's compare-and-set that records the redemption's dot and of a prepare entry's record creation answer `committed: "no"` where they answered `"unknown"` (a confirmation's and a card edit's answer carry no `committed` and are unchanged); narrowing: none; widening: none; hard-breaking: one, type level, three sentences below, open to veto; closed sets: none (no word added); exports: none; members: `RedeemResult` refused arm +`retriable`, `RedeemedBatchMember` refused arm +`retriable`, both required in type; wire: the refused result and a refused member row +1 key, additive) (@server @client-core @cli @test)
11
+
12
+ - **Before.** `RuleWriteCommitted` is defined as "has the store settled whether the call's rule stands", but the redemption leg's store step minted the word from the step's verb: a dot allocation and the record's compare-and-set that records the dot answered `store_write` / `unknown` (7.64.0, #3428), and so did a prepare entry's record creation (this release's #3430 section), although each runs before the rule write and the rule cannot stand. A host reads `unknown` as "reconcile, do not repeat": an import walk whose member's dot allocation threw answered a complete table with an `unknown` row, which a host lands as indeterminate and never retries. A `dot_removed` row answered `no` like a store failure before the write, with nothing but the code to tell them apart.
13
+ - **Now.** One reading, the store table's: every step before the rule write is `no`, whatever that step's own bytes did; `unknown` only for a rule write that was issued and did not settle (the apply threw, answered unreadably, or left no trace of its dot) or the read-back after it that could not be taken. The member code set is unchanged. Beside the word, every refusal carries `retriable`, derived once (`refusalRetriable`) in the one function that mints the refused arm: `true` exactly for `store_read` / `store_write` with `no` (a store failed before the rule write; repeating the same call can land it), `false` for every other refusal (`dot_removed`, a cause the record or the person decided, a write the store refused or lost, a write issued with an unknown outcome). A confirmation's answer carries neither word; a landed row carries none.
14
+ - **Hard-breaking — one, type level, three sentences (open to veto).** *What changed:* the refused arm of `RedeemResult` and the refused arm of `RedeemedBatchMember` gain the required member `retriable: boolean`. *Who is affected:* a host that builds such a value (a fake door in a test, a mirrored type) no longer compiles until it sets the member — @server where its tests construct refused results, @client-core where it mirrors the types; code that reads results is unaffected. *Compensation:* carry the engine's `retriable` through; never derive it from `committed`.
15
+ - **Rules.** Retired: the store step's own word (it derived `committed` from the code). Added: one derivation, one call site.
16
+ - **Consumers.** @server: 7.147.0 reads `retriable` to decide a repeat and `committed` to decide a reconcile; the 7.146.0 settlement rollback is unaffected. The 7.64.0 #3428 section's "the batch path (`redeemRuleBatch`) is unchanged for the server" stops holding here: a member row's `store_write` for a compare-and-set or a dot allocation is `no` now. @client-core: mirror the member. @test (black box): an import walk whose member's dot allocation throws ⇒ `store_write` / `no` / `retriable: true`, and walking it again lands the rule once; `dot_removed` ⇒ `no` / `retriable: false`; a rule write that commits and loses its acknowledgement ⇒ `store_write` / `unknown` / `retriable: false`.
17
+ - **Claude Code 2.1.316.** No anchor: Claude Code keeps no persisted approval record and no redemption.
18
+ - **Pins.** `test/backlog3492-committed-word-retriable.test.ts` C1–C10; re-pinned (`committed` literal only, reason in each cell): `test/backlog3428-approvals-store-failure.test.ts` R2 / R2b / R4 / R7 / R8, `test/backlog3430-approvals-record-store-failure.test.ts` P1–P3 / P9 / P11, `test/backlog3414-refusal-one-shape.test.ts` S4 / B4; whole-object refused pins gain `retriable` in `test/permission-rule-consent.test.ts`, `test/permission-rule-adopt.test.ts`, `test/permission-rule-owner-consent.test.ts`, `test/design375-batch-consent.test.ts`. Mutations (receipt).
19
+
20
+ ### A redemption reports landed only while its dot is live — an allow member of a batch walked again, and a single ticket redeemed again, after the person removed the rule answer `dot_removed` where they answered `persisted` / `deduped` and `redeemed` (#3493, #3495; behavior change; narrowing — one, open to veto; widening — one, open to veto; hard-breaking: none; closed sets: none; exports: none; wire: no key added) (@server @cli @client-core @test)
21
+
22
+ - **Before.** The batch walk read a member's standing after its redemption only for a deny / ask member; the single ticket did not read it. The landing's witness reads the raw state, where a dot the person removed since is still present under its tombstone, so a replay of that dot answered `persisted` / `deduped` (an allow member) or `redeemed` / `alreadyRedeemed: true` (any single ticket) while the rule did not stand.
23
+ - **Now.** One read-back, in the redemption leg every entry takes: a dot that a read which succeeded finds not live answers `dot_removed` / `no` / `retriable: false`; a read-back that cannot be taken answers `store_read` / `unknown` / `retriable: false`. A batch member carries the leg's answer, and the walk keeps no check of its own. An allow that does not stand withholds nothing (it leaves the store narrower than the list); only a deny / ask member's failure withholds the allows, as before. Each redemption takes one store read more. The look asks one question, the same for the leg and for the single ticket's check of an allow's deny / ask siblings: is the record's redeemed dot a live add on a row of the candidate's behavior and scope? It reads the dot (the add's audit identity, the one fact the record keeps of the write), never the rule text, because the row carries the parser's spelling of the candidate and a record can spell it otherwise.
24
+ - **Widening — one (open to veto).** A record whose deny / ask candidate is spelled otherwise than the row the parser writes for it (`Bash(curl -s:*)`, stored `Bash(curl -s:*)`): a record persisted under an earlier parser's spelling, or one a host built — the engine's own card, import and starter records carry the parser's spelling. 7.64.0 compared the text, so it read that deny, once landed, as not standing: the walk answered its row `dot_removed` and withheld the record's allows, and the single ticket withheld an allow whose deny sibling stood, on every repeat. The deny's row is `persisted` now and those allows land. @server: a lane that tracked such a record as "withheld until a fresh card" sees it complete.
25
+ - **Narrowing — one (open to veto).** An allow batch can now carry `dot_removed` rows, and a replayed ticket can answer `dot_removed` where it answered `redeemed`. @server: a lane batch guard that reads `committed: "no"` as "untouched" must read `retriable` and the member code the same day — a `dot_removed` row is `no` and not retriable.
26
+ - **Rules.** Moved: the standing read-back, from the walk's loop into the leg (one site). Retired: its `behavior !== "allow"` condition, and the rule-text comparison of the look. Merged: the two copies of "is this dot live" (the read-back and the siblings' check) into one predicate.
27
+ - **Consumers.** @server @cli @client-core: render a single ticket's `dot_removed` as a member row's ("removed since — a new consent is required"). @test (black box): redeem a ticket, remove its rule, redeem the same ticket ⇒ `dot_removed`; walk a batch, remove one allow, walk again ⇒ that row `dot_removed`, the other allow `deduped`.
28
+ - **Claude Code 2.1.316.** No anchor, as above.
29
+ - **Pins.** `test/backlog3492-committed-word-retriable.test.ts` A1–A3 (the walk) and B1–B6 (the single ticket; B4 the live-replay control, B6 a rule added again under a new dot), B7–B9 (a folded spelling at the door, in the walk and as a sibling; B7's control: the engine's card mints the parser's spelling). Mutations (receipt).
30
+
31
+ ### A background agent's durable row records its tree's root occupant beside the root anchor, and a revival reads both back — what a revived tree escalates to its root is addressed to the occupant the tree was born under (#3434, ruled C-R1109 addendum 2; behavior change; narrowing: none; widening: one, below, open to veto; hard-breaking: none; closed sets: none; exports: none; members: +1 optional `rootSessionIncarnation` on `BackgroundAgentRecord` and on the background registration input; wire: none) (@server @test)
32
+
33
+ - **Before.** 7.64.0 wrote a background agent's root anchor on its durable row (`BackgroundAgentRecord.rootSessionId`) but not the occupant of that root's row, though the spawning run's ctx carried both. A claim-driven revival (another process claiming the row, the parked-resume drive a host decide starts) rebuilt the child's root anchor from the row, so its `RunInternals.rootSessionIncarnation` was absent. A terminal frame its subtree escalated to the root (a grandchild's completion with no live lane to take it) was addressed to an unknown occupant and, the root having an occupant on record, discarded with `delegation.delivery_discarded` (`addressed: unknown`) even when the root was never deleted. This was the narrowing (2) of #3431 (KL-3431-a).
34
+ - **Now.** The registration that creates the row writes `rootSessionIncarnation` beside `rootSessionId`, from the spawner's `ctx.rootSessionIncarnation`. It is written only together with the anchor, never alone. A revival from a row reads it back beside the anchor; a row whose anchor is the parent fallback, or that records no occupant, revives a tree whose root occupant is unknown, as before. So a revived tree's escalation reaches the root's next run while the root holds the occupant the tree was born under. Once the root's id was deleted and created again, it is discarded with `addressed: known`.
35
+ - **Widening (open to veto).** A revived tree's root-anchor escalation is delivered again when the root still holds the occupant its row recorded. 7.64.0 discarded it. A row written before this release records no occupant and keeps the 7.64.0 reading (discarded, `addressed: unknown`; C-R1109 Q2 (A)).
36
+ - **Rules.** The address stays one rule: (session id, occupant), judged by `sameOccupant` at the store's seat. No new reading is added: the revival restores the member the spawn already carried in memory. Retired: the root anchor travelling on the row without its occupant.
37
+ - **Claude Code 2.1.316.** Not applicable: a Claude Code process revives no background agent from a row in another process. Inferred, not checked against the corpus.
38
+ - **Consumers.** @server: a `BackgroundAgentStore` gains an optional member to store and return as written. The SQL agent store keeps the whole record as `record_json` (`src/stores-sql/background-agent-store-sql.ts` :21 / :100 at server origin/main 96a91d82, read here), so the member round-trips with no column change; the store contract kit gains a cell that says so (put, read, CAS, absent stays absent). @test (black box): a background agent parked on an approval and decided by the host after its own run has ended; a report its subtree sends after that reaches the root session's next run, and with the root deleted and created again it does not, with one operator `delegation.delivery_discarded` (`addressed: known`).
39
+ - **Known limits.** KL-3431-a is rewritten: the revived-tree shape is closed for rows this release writes. Rows an earlier release wrote, a host-mounted workflow tool that names its root only through `originatingSessionId`, and a leg whose occupant read threw keep discarding under an unknown occupant.
40
+ - **Pins.** `test/backlog3434-root-occupant-row.test.ts` — O1 a background spawn writes the root occupant beside the anchor · O2 real Runner, a host decide revives the parked child under the same root occupant ⇒ its ctx names that occupant and the subtree report reaches the root's next leg, no notice · O3 the root's id created again before the revival ⇒ discarded, `addressed: known`, no token and no report text on the notice, never in the new occupant's model · O4 control, a row with no recorded occupant ⇒ discarded, `addressed: unknown` · O5 the registration records an occupant only beside an anchor, never alone · O6 the fork lane's background spawn records it too. The base tree (stage-7650 at v7.64.0) fails O1–O3, O5 and O6; O2 is discarded there with `addressed: unknown`. The store contract kit (`src/core/store-contracts/background-agent-store-contract.ts`) gains the round-trip cell, run against both bundled stores by `test/background-agent-store.test.ts`. `test/backlog3431-session-occupant-address.test.ts` P8 (a tree whose internals name no root occupant) is unchanged: it is the earlier-row shape.
41
+
42
+ ### A delegated leg's user-face notice is for the root occupant its tree was born under — once the root's id was deleted and created again, the old tree's notice is discarded and said, `delegation.delivery_discarded` with `path: "notice"`, not delivered to the root's later occupant (#3479, ruled C-R1109 addendum 2; behavior change; behavior narrowing — two, below, open to veto; hard-breaking: none; closed sets: `DiscardedDeliveryPath` +1 (`notice`), additive; exports: none — the delivery throat `deliverEngineNotice` takes an optional third parameter, and it is not on the package surface (`src/index.ts` does not export it; the export-surface snapshot and the wire report carry no signature change); wire: one word added to `delegation.delivery_discarded` `detail.path`) (@server @cli @client-core @test)
43
+
44
+ - **Before.** 7.64.0 addressed a delegated leg's user-face notices to its delegation tree's root session (#3083, C-R1121): `delegation.ask_unresolvable`, `permission.ask_released_by_mode`, `permission.read_deny_unapplied` and `classifier.unavailable` carry the root's id as `detail.sessionId`, lifted to the notice's top-level `sessionId`, and a deployment routes a notice by that id. The address was the id alone (`noticeAddressOf`, `src/core/leg-identity.ts` :90-98 at v7.64.0). Frames addressed to the same root were already judged by occupant (#3431). So when the root's id had been deleted and created again while a background child of the earlier occupant still ran, that child's notices — which tool of which child was refused, released or unclassified — reached the later occupant's route.
45
+ - **Now.** The root is a session address like every other destination: its id and the root occupant the tree was born under (`internals.rootSessionIncarnation`). `noticeAddressOf` answers both: the keys the notice carries (unchanged) and, on a delegated leg addressed to its root, the destination. The destination is never spread into a notice; no occupant token rides the wire. A leg delivers its four user-face notices through the one throat under one admission (`legNoticeAdmission`, `src/core/runner/prepare-gate-stations.ts`), handed to the throat as its new optional third parameter. A notice with a destination is first judged by the Runner's in-process notification store (`discardsStaleNotice`), with the same judgement that decides a frame addressed there. If the root's current occupant is another, the notice is discarded and `delegation.delivery_discarded` is said once (operator), with `path: "notice"`, `taskId` = the leg it came from (its agent id, else its session), `taskType` = the discarded notice's code, and `addressed` / `current` as for frames. Otherwise, and for a root no leg of which this process admitted, the notice is delivered as before. A top-level leg's notice goes to its own session and is never judged.
46
+ - **Narrowing (open to veto).** (1) A delegated leg's user-face notice addressed to a root whose id was deleted and created again (the later occupant admitted in this process) is no longer delivered. It reached the later occupant's route, which is the defect. (2) A delegated leg whose tree's root occupant is unknown (its internals name none: a tree revived from a row an earlier release wrote, a host-mounted workflow tool that names its root only through `originatingSessionId`) has its user-face notices discarded and said with `addressed: unknown` whenever the root has an occupant on record here. They used to be delivered. The refusal itself is unchanged, and the child's tool result still says it; what the root's viewer loses is the notice (KL-3479-a).
47
+ - **Rules.** One address rule, (session id, occupant), judged in one place for frames and notices alike (the store's `staleAgainst`, read by `discardsStale` and `discardsStaleNotice`). One mint of the discard account (`deliveryDiscardedNotice`); its input is the discarded delivery's name (`DiscardedDelivery`, `{ taskId, taskType }`), and a frame passes `frameDelivery(payload)`. Retired: a delegated leg's notice addressed by the root's id alone. Added: the throat's admission, `deliverEngineNotice(onNotice, notice, admission?)` (an engine-internal function; named `admission`, since `admits` is a tool-selector predicate whose reads the valve guard of #1971 counts). The third parameter is optional; a call that passes none behaves as in 7.64.0. When one is passed, a notice it answers `false` for is handed to no seat, and the predicate must already have said so on its own account (here the judge mints `delegation.delivery_discarded`). It only judges and never rewrites the notice, so the mint stays at the call site. Net rules: zero (the throat gains the admission; no forwarder is built, so every throat call still mints its notice in place, where the notice-catalog scan of #433 reads it). The classifier station's notice seat (`classifierUnavailableSeat`) gains the same optional `admission` beside its sink; the inherited station passes none, as before. The judge reaches prepare as the last positional parameter of the internal `PrepareTaskFn` contract (absent outside a Runner: every notice delivered).
48
+ - **Claude Code 2.1.316.** Not checked against the corpus. Inferred: a Claude Code process holds one conversation, and a subagent's permission notice goes to that process's own stream, so an id re-created under another owner is not a destination there.
49
+ - **Consumers.** @server: `delegation.delivery_discarded` gains `path: "notice"`; with it, `detail.taskType` is a notice code (for example `delegation.ask_unresolvable`) and `detail.taskId` the delegated leg's agent id. Audience and minter are unchanged (`operator`, `engine`), so keep it off the user wire. The session door's owner check does not retire: the store judges only this process's seats, and a root no leg of which this process admitted is not known to have been created again. @cli: an operator notice; no user-face text expected. @client-core: a mirror of `detail.path`'s words gains `notice`. @test (black box): delete a session and create it again under the same id while the earlier occupant's background child is running, then let the child call a tool the deployment cannot approve. The new occupant's stream never carries that `delegation.ask_unresolvable`, and the operator sink carries one `delegation.delivery_discarded` with `path: notice, addressed: known, current: known`.
50
+ - **Known limits.** KL-3479-a: a notice cannot wait the way a frame parks, so a root created again but not yet admitted in this process (or one whose legs run in another process) still takes the earlier tree's notice by id; and a delegated leg with an unknown root occupant has its notices discarded (narrowing 2).
51
+ - **Pins.** `test/backlog3479-notice-root-occupant.test.ts` — N1 real Runner, two trees: the root deleted and created again while its background child waits ⇒ the child's refusal is discarded, `path: notice`, the agent id named, no token and no ask text on the notice, never delivered · N2 control: the same root occupant ⇒ delivered to the root, naming the child · N3 the route: a top-level leg has no destination; a delegated one carries the root's address beside its keys, never in them · N4 a delegated leg judged against the root's current occupant: (a) same ⇒ delivered, (b) a root no leg of which was admitted here ⇒ delivered, (c) an earlier occupant ⇒ discarded `addressed: known`, (d) an unknown occupant ⇒ discarded `addressed: unknown` · N5 another of the leg's notices takes the same judge: a bypass release on a leg of the earlier tree still runs the tool, and its `permission.ask_released_by_mode` notice is discarded and named · N6 (structural) every throat call in the gate station carries the leg's admission, and the classifier seat is handed it beside the deployment's sink · N7 the throat's admission: absent ⇒ delivered as in 7.64.0, `false` ⇒ no seat (nor the default seat) hears it, asked once with the notice as it leaves. The base tree (stage-7650 at v7.64.0) fails N1, N3, N4 (c) / (d), N5, N6 and N7.
52
+
53
+ ### One occupant reading — `sameOccupant` decodes each side as a stored cell is decoded and is the only answer to "one occupant?"; `compareOccupants` keeps its name and signature as the predicate's row-level face, `"unknown"` only when a side has no row (#3433, ruled C-R1109 addendum 2; behavior change; behavior narrowing — three, below, open to veto; widening — two, below, open to veto; hard-breaking: one, semantic, three sentences below, open to veto; closed sets: none; exports: none added or removed — `compareOccupants` keeps its name, signature and three answers; wire: no key, `delegation.delivery_discarded` `detail.addressed` / `detail.current` say `unknown` for an empty or non-string cell) (@server @test)
54
+
55
+ - **Before.** 7.64.0 answered the question with two readings. The delegation seats, the notification store, the session-box drain and the peer idle / held-queue seats compared the cells as written (`sameOccupant`, `held === current`), so an empty cell and an absent one were two occupants. `compareOccupants` answered `"unknown"` whenever a side had no token, so each of its readers decided that case its own way: the File repo joined the live authority ("a row without a token cannot say, and the file decides"), and the cached-session store dropped its view over a repo with a by-id read and kept it over one without.
56
+ - **Now.** `sameOccupant` lives beside the cell decoder (`src/engine/session/repo-utils.ts`). Each side is decoded as `readIncarnationCell` decodes a stored cell: a non-empty string is the token, and absent, `""` or a non-string is no token. The same token, or no token on either side, is one occupant; a token on one side only is another. `compareOccupants(before, after)` is `"unknown"` when a side has no row, otherwise `sameOccupant` of the two cells as `"same"` or `"different"`. The File repo joins a live authority only on `"same"`. The cached-session store's view stands on `"same"` unless the row names another owner, falls on `"different"`, and with no row answers the repo's default as before. The discarded-delivery notice says whether each side names an occupant through the same predicate.
57
+ - **Narrowing (open to veto).** (1) A File session row with no token whose file is rewritten in place with a header naming a token — the row created again under the id, by a writer this process does not see — is no longer joined to the live authority. The authority is evicted, a handle on it is refused (`log_closed`), and the occupant the header names is served from disk. 7.64.0 joined it and served the earlier occupant's transcript to whoever the row now admits. (2) Over a repo with no by-id read, a listing no longer lends a cached view's run (`lastTaskId` / `lastTaskRunId`) to a row whose occupant cell differs from the view's by having or lacking a token. 7.64.0 answered `"unknown"` there and the view stood. (3) A `delegation.delivery_discarded` account whose address or current occupant cell is `""` or a non-string now says `addressed: "unknown"` / `current: "unknown"`, where 7.64.0 said `"known"`: such a cell names nobody by the one reading, so the account no longer claims an occupant was named.
58
+ - **Widening (open to veto).** (1) Over a repo with a by-id read, a cached view of a row with no token stands for that row while it names the same owner and, on acquire, the same leaf: acquire serves the view and the listing lends it its run. 7.64.0 dropped it and resolved the id from the row again. Every write that creates a row mints a token, so two token-less readings of one id are one generation. (2) A frame, a box record or a seat addressed under an empty or non-string cell is the occupant of a seat with no token, and is delivered to it. 7.64.0 discarded it as another occupant's. A token against no token stays another occupant everywhere: no token is never a wildcard.
59
+ - **Hard-breaking — one, semantic, three sentences (open to veto).** *What changed:* `compareOccupants` answers `"same"` for two heads that both have a row and no occupant token (absent, `""` or a non-string cell), and `"different"` for a token on one side only, where 7.64.0 answered `"unknown"` for both; only a side with no row is still `"unknown"`, and the name, the signature and the three answers are unchanged. *Who is affected:* @server's warm-session cache takes a cached view only on `"same"` (`src/plugins/caching-session-store.ts:324` `freshHit`). A head with no token beside a cached view with no token is now a hit where it was a stale miss; the leaf must still match, and a token against no token is still a miss. Three server sentences no longer describe the core answer: the cache's head note (`:35`, "`unknown` included"), `src/security.ts:225`, and `src/session-incarnation.ts:31-35` ("任一侧没有行或没有令牌 ⇒ `unknown`"). These were read on server origin/main `96a91d82` and not compiled against this tree. No other repository calls it: grep of the cli / client-core / sdk / test origin/main finds no `compareOccupants`. *Compensation:* read whether a head carries a token from the head itself (`head.incarnation`), not from `compareOccupants`. A reader that must refuse a token-less row keeps its own refusal, as the server's write path does (`sessionFaceOfHead` → `SessionIncarnationMissingError`); that refusal was never `compareOccupants`'s answer. Update the three sentences.
60
+ - **Rules.** Two readings become one: the predicate beside the decoder, with `compareOccupants` a row-presence wrapper over it. The delegation-owner module no longer defines its own copy, and the notification store, the drain and the peer seats import the one predicate. The discarded-delivery notice's `addressed` / `current` stop testing `!== undefined` and ask the predicate. The cached-session judgement keeps its owner check on every non-`"different"` answer, so a token-less row naming another owner never stands (Q5). A row with a token has one owner, so the check changes nothing reachable there (inferred).
61
+ - **Interplay with #3461 (inferred, not pinned).** A session-box drain whose by-id read answers a non-string `incarnation` and whose leg holds no token now confirms itself the current occupant: records named for another occupant are discarded with their account instead of staying in the box. A head answering a non-string beside a leg that holds a token remains #3461's form, unchanged.
62
+ - **Claude Code 2.1.316.** Not applicable: a Claude Code session carries no occupant token. Inferred, not checked against the corpus.
63
+ - **Consumers.** @server: the semantic hard-breaking item above. @test: the empty-cell and in-place shapes below are the constructions to retry against a real deployment.
64
+ - **Pins.** `test/backlog3433-one-occupant-reading.test.ts`:
65
+ - Q1: the two faces agree on every pair of six cells (absent / `""` / `7` / `null` / two tokens). No row ⇒ unknown; otherwise `"same"` exactly when the predicate says one occupant.
66
+ - Q2: a seat admitted under an empty cell takes a frame addressed with no token (parked, drained, nothing discarded). Control: a token against an empty cell is refused and said, with `addressed: unknown`.
67
+ - Q3 (two trees): a token-less row rewritten in place with a token is not joined. The earlier transcript is not served, the new occupant's turn reaches the file, and the held handle is refused.
68
+ - Q4 (two trees): a token-less view over a repo with a by-id read still lends its run, and acquire serves the same view.
69
+ - Q5: a token-less row rewritten to name another owner lends nothing.
70
+
71
+ The base tree (stage-7650 at v7.64.0) fails Q1 (it has no predicate in the row module), Q2, Q3 and Q4.
72
+
73
+ Re-pinned (a re-pin, not a widening): `test/backlog1468-s2-session-row-head.test.ts` H9. Its three pairs of rows with no token each (absent, `""`, `7`) answered `"unknown"` and answer `"same"`. Two pairs with a token on one side only are added, and answer `"different"`. Also re-pinned: `test/backlog1468-s3-list.test.ts` L8b cell (4). Over a repo with a by-id read, a row and a view with no token each now stand on both call sites, where they refused; this is widening (1) above, read by the same judgement. L8c is unchanged: a token-less row created again under another owner, or under none, still lends nothing.
74
+
75
+ ### Retired (C-R1075 加注 3 ④): the `syncBlobFaces` word means nothing to the blob-exchange judge — `fileHistoryBlobExchangeOf` reads the `blobExchange` group alone, so a store that still carries the word is read by its group like any other (#3148, retirement line RL-3148-sync-blob-faces; behavior change; behavior widening — one, open to veto; hard-breaking: none; closed sets: none; exports: none) (@server @test)
76
+
77
+ - **Before.** In 7.64.0 the judge read two members: the `blobExchange` group, and the retired marker word `syncBlobFaces`. A store carrying the word, with or without a whole group beside it, was refused `config.invalid_argument` ("FileHistoryStore carries the retired syncBlobFaces marker …", `src/core/file-history-store.ts` :903 / :908 at v7.64.0), so that a deployment store still built on the 7.60.x marker was told, rather than read, while its readers moved to the group.
78
+ - **Now.** One reading. The capability is the `blobExchange` group: present and whole ⇒ the three members, bound; absent ⇒ none; anything else ⇒ the group's own coded refusal. No other member of the store is read, so `syncBlobFaces` alone is no capability and beside a whole group changes nothing. The line's condition holds — no store carries the word: zero carriers in the `src` of @server (`96a91d82`), @cli (`feda7f7c`), @client-core (`426331e`) and @sdk (`d5aed66`); the server reads the capability only through this judge (`src/session-sync.ts:88-94`, `src/capability-facts.ts:263`) and its SQL twins carry the group; the remaining mentions are CHANGELOG / MIGRATION prose, @sdk documentation and tests (grep of each `origin/main`).
79
+ - **Widening — one (open to veto; @server).** A store carrying `syncBlobFaces` is no longer refused: alone it reads as no blob exchange (where it was refused), beside a whole group it exchanges blobs (where it was refused). Nothing that answered before answers differently.
80
+ - **Consumers.** @server — `test/capability-facts.test.ts` asserts the retired refusal in three places, all to re-pin at pickup (coordinates on the pickup branch `che-PICK764` `275b010b`; on `origin/main` `96a91d82` they sit two lines earlier): the shape row `:107` ("🔴 PICK7610 还带退役标记词 syncBlobFaces(整组也在)", `reaches: "refused"`, built at `:100`), which now reaches `true` (the group is whole) — re-pin it to the group's reading or drop it; the refused arm's sentence `:115` ("判官拒(半组 / 退役标记词)") and the head note `:80`, which name the word as a refusal reason — only the half group is one now. @test — black box: a file-history store carrying `syncBlobFaces: true` and a whole `blobExchange` group exchanges blobs; the same store without the group reads as no exchange; a half group beside the word is refused with the group's own sentence, which does not name the word. Not affected: @cli @client-core @sdk (no reader).
81
+ - **Rules.** Retired: the judge's second member read and its refusal, and the retirement row. Added: none.
82
+ - **Claude Code 2.1.316.** No anchor (inferred): Claude Code has no blob-exchange seat on a file-history store.
83
+ - **Pins.** `test/backlog3148-write-faces.test.ts` — "RL-3148 retired: the syncBlobFaces word is no reading at all" (the word alone ⇒ no exchange, either value; beside a whole group ⇒ the group, bound and working; beside a half group ⇒ the group's own refusal, which does not name the word) · "RL-3148 retired: no source file names the retired word, and the retirement table has no row for it". Mutations: `.gate-logs/criteria-rl-7650-mutations.md` (receipt).
84
+
85
+ ### Retired (C-R1075 加注 3 ③): the memory store family leaves the package — the store implementations, their write gates and selective-recall helpers, the file backend's memory member and its two options, the retention table's row for that member, and the three error codes only the family minted; the engine behind `RunnerDeps.memoryBackend` is the one memory (#1654 / #2910 / #3031, retirement line RL-1654-store-family; behavior change; behavior narrowing — one, open to veto; hard-breaking: four, three sentences each below, open to veto; closed sets: `NON_GOVERNANCE_MEMORY_CODES` −3 (`memory.secret_detected`, `memory.promotable_ungated`, `memory.projection_failed`), `RETENTION_CASCADE` −1 row (`memoryStore`); exports: −35 root names (21 values, 14 types); members: −1 `FileStorageBackend.memoryStore`, −2 `FileStorageBackendOptions.utilityGate` / `embedder`, −1 `RetentionCascadeStores.memoryStore`) (@server @cli @test)
86
+
87
+ - **Before.** In 7.64.0 the root still exported a second memory path that no Runner path had read since `RunnerDeps.memoryStore` was removed (design/138 S4, design/157 B19): the store implementations `InMemoryMemoryStore` / `FileMemoryStore` and the wrapper `guardedMemoryStore`; their write gates (`enforceSecretWriteGate` / `enforceStructuredNoteSecretGate`, refusing with `memory.secret_detected`; `classifyPromotable` / `enforcePromotableWriteGate`, refusing with `memory.promotable_ungated`) and error classes (`MemoryGateError`, `MemoryProjectionError` — `memory.projection_failed`); the consolidation probes (`supportsConsolidation`, `supportsPeriodicConsolidation`), the lexical helpers (`expandLexicalTerms`, `lexicalSearchMatch`) and the selective-recall helpers of `src/core/memory-recall.ts`. A `FileStorageBackend` carried `memoryStore` — a `FileMemoryStore` writing under `<root>/memory/`, shaped by the backend's options `utilityGate` / `embedder` — and the retention table carried an exempt row for that member.
88
+ - **Now.** `npm run handoff:diff v7.64.0 HEAD`: 35 removed / 0 added. Values: `FileMemoryStore`, `InMemoryMemoryStore`, `guardedMemoryStore`, `MemoryGateError`, `MemoryProjectionError`, `enforceSecretWriteGate`, `enforceStructuredNoteSecretGate`, `classifyPromotable`, `enforcePromotableWriteGate`, `supportsConsolidation`, `supportsPeriodicConsolidation`, `expandLexicalTerms`, `lexicalSearchMatch`, `encodeSurfacedKey`, `buildManifestText`, `validateSelectedIds`, `composeSelectiveBody`, `resolveLinkedIds`, `RECALL_CAVEAT`, `DEFAULT_MAX_SELECTED`, `DEFAULT_MAX_LINKED`. Types: `Embedder`, `UtilityGate`, `MemoryVectorMode`, `ScoredMemory`, `MemoryNoteHeader`, `MemoryNoteRecord`, `MemoryNoteType`, `StructuredNoteInput`, `MemorySelector`, `MemorySelectRequest`, `SelectiveRecallOptions`, `SelectiveRecallResult`, `LayeredRecallOptions`, `LayeredRecallResult`. `src/core/memory-recall.ts` and `src/stores/file/memory-store.ts` are deleted; `formatMemoryAge` moves to `src/core/memory-engine/memory-age.ts` and stays a root export. A `FileStorageBackend` has no `memoryStore`, creates no `<root>/memory/`, and refuses `utilityGate` / `embedder` at construction the way it refuses any key outside its option table — one door, `receiveOptions` (`config.invalid_argument`: `FileStorageBackend options: "embedder" is not an option it takes — the options it takes are …`). Notes an older backend wrote under `<root>/memory/<scope>/` (`notes.jsonl`, `vectors.jsonl`, `MEMORY.md`) stay on disk byte for byte and are read by nothing. No migration verb is minted for them (the one-off v1 migration verb is superseded, C-R1075 加注 2); as with 7.64.0's ledger retirement, the way out is an older engine — a host that still wants those notes reads them with an engine at or below 7.64.0, whose `FileMemoryStore` serves them, and writes what it keeps through its memory backend. The retention table loses the `memoryStore` row; it was an exempt row, so the session-tree erasure order is unchanged (steps 1–11). `NON_GOVERNANCE_MEMORY_CODES` loses the three codes no source file mints any more, and the gate that keeps that list honest reads mint sites only: it used to read the list's own file as a mint site, so its stale-entry check could not fail.
89
+ - **Narrowing — one (open to veto; @server @test).** `new FileStorageBackend({ root, utilityGate })` and `new FileStorageBackend({ root, embedder })` throw `config.invalid_argument` naming the key, where 7.64.0 built a memory store with them.
90
+ - **Hard-breaking — HB-1, thirty-five root names removed (open to veto).** *What changed:* the names above are no longer exported from `@sema-agent/core`. *Who is affected:* a host that imports any of them fails to compile (a JavaScript caller reads `undefined`); the origin/main of server (`96a91d82`), cli (`feda7f7c`), client-core (`9069705`) and sdk (`d5aed66`) carry no code reader of any of them. *What to read instead:* memory is the MemoryEngine behind `RunnerDeps.memoryBackend` (`MemoryBackend`, `FileMemoryEngineBackend`, `memoryBackendContract`); secret screening of memory writes is the engine's own, and `formatMemoryAge` is still exported.
91
+ - **Hard-breaking — HB-2, the file backend's memory member and its two options (open to veto).** *What changed:* `FileStorageBackend` has no `memoryStore`, makes no `<root>/memory/` directory, and its options type has no `utilityGate` / `embedder` (passing either throws, as above). *Who is affected:* a host that read `backend.memoryStore` (it reads `undefined`) or passed either option; none in the four repositories above. *What to read instead:* inject a memory backend into `RunnerDeps.memoryBackend`; notes left under `<root>/memory/` are not migrated (see Now).
92
+ - **Hard-breaking — HB-3, the retention table's `memoryStore` row (open to veto).** *What changed:* `RETENTION_CASCADE` has no `memoryStore` row and `RetentionCascadeStores` has no `memoryStore` member. *Who is affected:* code that enumerates the table's rows or builds a `RetentionCascadeStores` value with a `memoryStore` (a TypeScript excess-property error); the server reads only `RETENTION_CASCADE_DOMAINS` / `RETENTION_CASCADE_EXEMPT` (`test/retention-declaration.test.ts:26`), which are unchanged. *What to read instead:* the table as it stands — the row was an exemption, so no erasure step moved.
93
+ - **Hard-breaking — HB-4, `NON_GOVERNANCE_MEMORY_CODES` −3 (open to veto).** *What changed:* `memory.secret_detected`, `memory.promotable_ungated` and `memory.projection_failed` are no members. *Who is affected:* a host that asks the set about one of the three strings reads `false`; no repository above spells any of them in code, and `errorClassOf` answers `unknown` for each, as before. *What to read instead:* nothing — no engine path mints the three codes.
94
+ - **Exports, tiers.** `cosineDistance` and `firstSentence` move from `stable` to `advanced` in the export-surface layering: their only front-door demonstration was the retired PostgreSQL memory example.
95
+ - **Repository (not in the package).** The PostgreSQL reference adapter loses `PgMemoryStore`, `PgEmbedder`, `PgAgentSchemaOptions`, the two memory tables and `ensurePgAgentSchema`'s options parameter (`ensurePgAgentSchema(query)`). The consumer smoke probe no longer checks `MemoryProjectionError`. The live gate's conditional-file mechanism goes with its only row (`test/live-memory-embed.test.ts`, deleted with the store): `scripts/run-live-gate.mjs` runs every live file, so the R live reading changes from `N / 0 / 0 / OMITTED 1` to one with no OMITTED item; the summary's `omitted` field stays (now `[]`), and the ship post and the live stamp read it generically.
96
+ - **Consumers.** @server — no code reader; the comment `test/core-dependency-floor.test.ts:1362` names `MemoryProjectionError` as a `skip` row of the export ledger, which drops at pickup. @cli — the wire-consumption manifest rows `scripts/wire-consumption-manifest.json:5370` / `:5377` (`MemoryProjectionError`) go stale and drop at pickup. @client-core @sdk — no reader. @test — black box: `import { FileMemoryStore } from "@sema-agent/core"` is a compile error and a runtime read is `undefined`; `new FileStorageBackend({ root, embedder: {} })` throws naming `embedder`; a fresh backend has no `memoryStore` and leaves no `<root>/memory/`; a `<root>/memory/<scope>/notes.jsonl` written beforehand is untouched after open and dispose. The historical repros under `repro/` that import these names run against their own pinned dists. @dgx — the local dgx checkout's HEAD carries no code reader (a checkout of 10-24, not origin).
97
+ - **The credential-table section below.** Its hard-breaking sentence (2), its Consumers line and its U2 pin were written against 7.64.0, where the memory write door also had `enforceSecretWriteGate`, the guarded store and `memory.secret_detected`; with this retirement those read false in 7.65.0, so they are rewritten to the door that remains (`detectSecret`, read by `scanMemoryWrite`, answering the engine's `secret` rejection). The refused shapes are unchanged.
98
+ - **Rules.** Retired: the second memory path whole (its stores, gates, recall helpers, the backend member and its two options, the retention row, three codes), and the live gate's conditional-file rule. Repaired: the non-governance list's stale-entry check reads mint sites only. Added: none.
99
+ - **Claude Code 2.1.316.** No anchor (inferred): Claude Code's memory is one file set read at session start; it has no second, store-shaped memory seat.
100
+ - **Pins.** `test/backlog1654-store-exports-retired.test.ts` — S1 (none of the twenty-one value names is a runtime export, none of the thirty-five is spelled in `src/index.ts`; control: `MemoryEngine` is) · S2 (the two modules are gone; `formatMemoryAge` lives with the engine and is still a root export) · S3 (a file backend carries no memory member and makes no `memory/`) · S4 (an older backend's notes stay byte for byte) · S5 (the two options are refused by name) · S6 (no retention row for the member; erasure steps 1–11 unchanged) · S7 (the three codes are no members and no source file mints them; control: `memory.announce_failed` is) · R5 (the retirement table holds no `RL-1654` row; RL-1103 / RL-1333 untouched); `test/governance-codes.test.ts` (the stale-entry check reads mint sites only). Deleted with the family: `test/file-memory-store.test.ts`, `test/file-memory-searchscored-property.test.ts`, `test/memory-promotable-gate.test.ts`, `test/backlog784-legacy-store-projection.test.ts`, `test/live-memory-embed.test.ts`, `test/live-gate-conditional-registry.test.ts`. Re-pinned off the retired faces: the RSI L6 bench and its harness (`test/rsi-l6-bench.test.ts`, `test/rsi-tier-on-harness.ts` — the Gate-2 step and the store axis go; `gate2Verdict` is the profile's own input; 20 cells → 16), `test/pg-stores.test.ts` / `test/pg-live.test.ts` (no memory table), `test/error-class-of.test.ts`, `test/backlog3336-env-namespace-class.test.ts`, `test/backlog3406-landing-admission-root-exports.test.ts` (a live member stands for the list), and the memory / file-backend files that built the store; `test/retirement-lines-gate.test.ts` (the cited-row discriminance runs on RL-1103, the one row src comments still cite) and the sleep allow list of `test/flaky-guard.test.ts` (the recall rebuild file sleeps no more). Two shipped criteria observations are annotated `retiredIn: "7.65.0"` instead of rewritten: 7.20.0 G4.c (`MemoryProjectionError.committed`) and 7.62.0 G4.c (`FileStorageBackend.memoryStore`). Mutations: `.gate-logs/criteria-rl-7650-mutations.md` (receipt).
101
+
102
+ ### A write onto the write-protection table that a surviving ask is about is asked once, with the table's sentence in it — the ask keeps its own question and gains `(tool "Write" writes to a write-protected path (table entry "N") — explicit approval required)` (#3474; behavior change: the message of a surviving ask over a protected target gains the table's sentence; narrowing: none; widening: none; hard-breaking: none; closed sets: none; exports: none) (@cli @client-core @test)
103
+
104
+ - **Before.** A deployment whose write face asks first (`defaultWrite: "ask"`, no admitting root) met a write onto the write-protection table with two questions on one call: the write face's (`approve write to "<path>"?`) and the table's (`tool "Write" writes to a write-protected path (table entry "N") …`). The gate folded them into one ask and kept the write face's words (the post-fold tighten replaced a surviving allow and nothing else, and said so in its comment and in three pins); the table's finding rode only as the ask's class and its mandate (no standing allow rule retires it). The ask's `message` named no table entry: it said the table's sentence only where the write face allowed first (a root that admits the path, a worktree) — the 7.58.0 black-box reading G3.b. The same held for a deployment layer's own ask or a hook's.
105
+ - **Now.** One mint of the sentence, `writeProtectionTightenDecision` (unchanged); one placement, `askWithTableSentence` (`src/core/write-protect.ts`): over a surviving ask the fold keeps the ask's action, provenance, class and disclosures — `decisionReason`, `askReasons` (the asker's own words) and the mandate are what they were — and its message becomes `<standing message> (<the table's sentence>)`, the form the persisted-rule tightening appends its account in, once (a message that already says the sentence is not told it twice; an ask with no message takes the sentence alone). The tighten's deny (a target whose destination cannot be determined) still outranks a question and appends nothing; a policy's deny is left as it is. The fold's rule is one sentence: the tighten's ask replaces a surviving allow and is the sentence a surviving ask is said with.
106
+ - **Narrowing / widening.** None on any decision: the same call asks (or is refused) as before, the same mandate rides, the same approvers answer. The visible difference is the text: an ask raised by the write face, a deployment's policy or a hook, over a target the table meets, now ends with the table's sentence (and the reach clause when the row is met only where the path resolves on disk, #2793). The standing ask keeps its echoed paths; the table's sentence rides in parentheses (#3498): when the standing ask's message IS the engine's own sentence (the write gate's generic question, `engineSentenceOf`, #3442), `askWithTableSentence` restates that account over the merged text — `text` is the merged message, `generic` and the listed `echoed` path ride along — so a person's refusal of the merged question still files `disposition.echoed` beside `deniedBy: "ask_resolution"` (the first cut of this change dropped the account and with it the list; #1216 2.2 caught it on the stage). A standing ask that is a layer's or a hook's own words keeps them and gains no account, as before. A persisted rule's appended account (`persisted-rule-arms.ts`) is a different placement and is unchanged: its refusal still quotes the message whole (#3442 K7).
107
+ - **Consumers.** @cli @client-core: an ask's `message` over a write-protected path can be longer and names the table entry; a surface that renders `askReasons` and the typed members (the structured approval surface) is unchanged. A host that matched `approve write to "<path>"?` byte for byte on a protected path matches its prefix now. @test: the black-box face is the approval card of `Write` onto `.bashrc` / `.claude/**` in `default` mode with no admitting root (G3.b): one card, both sentences.
108
+ - **Pins.** `test/backlog3474-write-protect-merged-ask.test.ts` — D1 the write face asks first onto the table ⇒ one ask, its question then the table's sentence in parentheses · D2 control: an ordinary path keeps the generic question byte for byte and the engine's account of it · D3 control: a surviving allow demoted by the table says the sentence alone · D4 a deployment layer's own ask over a protected path ⇒ its words then the sentence, its reason and its asker's words kept · D5 a message that already says the sentence is not told it twice · D6 the mandate is untouched (a standing allow rule does not clear the merged ask; the approver is asked once) · D7 the merged ask carries the engine's account of its own longer message (`text` = the merged message, `generic`, the quoted path; #3498) · D8 a link onto the table ⇒ the sentence carries the one reach clause · D9 an undeterminable target is still a refusal · D10 a policy's deny over a protected path is not given a question appended · D11 a standing ask with no words of its own takes the sentence alone. Changed pins (they asserted the old rule): `test/backlog286-write-protect-default.test.ts` (a policy's ask over `.npmrc`), `test/backlog850-write-protection-rule-immune.test.ts` G6a (byte-identical but for the mandate stamps and the appended sentence), `test/backlog839-tighten-order-and-membership.test.ts` ① (a hit over a standing ask). `test/backlog3498-merged-ask-keeps-echoed.test.ts` (#3498) — G1 the write face onto the table, a person refuses ⇒ the record files the path and the approver was handed the merged question · G2 control: an ordinary path, the same record, the generic question byte for byte · G3 a link onto the table ⇒ the reach clause in the question, the path still filed · G4 a deployment layer's own ask ⇒ its words then the sentence, no list · G5 a demoted allow ⇒ the sentence alone, no list · U1–U6 the placement itself (the account follows the merged text; no account for a layer's words, a stale account or a replayed record; `generic` rides). `src/core/gate-fold.ts` stays at 575 lines (the placement lives in `write-protect.ts`, +19).
109
+
110
+ ### `sessionBoxMountVerdict` is on the package root — a host can ask, before it wires a deployment, whether its mailbox store and session store will be refused the session-box mount (#3480; behavior change: none; hard-breaking: none; closed sets: none; exports: +1, `sessionBoxMountVerdict`) (@server @cli @test)
111
+
112
+ - **Before.** The session-box lane (a session's own `session.<id>` box, the drain that consumes it and every seat that appends to it) mounts only over a mailbox that declares `crossProcessSafe: true` and a session store that reads a session's row by id (`SessionStore.headOf`). One function judges it — `sessionBoxMountVerdict(mailbox, sessions)`, read by the drain mount, the peer-lane mount and the send face — but only its mailbox half, `mailboxCrossProcessMountVerdict`, was on the root. A host that wanted to know whether its own store pair would be refused a mount had to run a leg and read `config.peer_lane_unmounted` afterwards, or copy the `headOf` test (a second source).
113
+ - **Now.** `sessionBoxMountVerdict` is exported from the root next to `mailboxCrossProcessMountVerdict` and answers the same `MailboxCrossProcessVerdict`: `{ ok: true }`, or `{ ok: false, code, reason }` — the mailbox half's reason first, then the missing by-id read named. The function, its signature and its answers are the engine's own and did not change; `SMOKE_CHECKED_EXPORTS` proves the name reachable from a stranger install, and the frozen export surface carries it (`count` 3190 → 3191, tier `advanced`).
114
+ - **Narrowing / widening.** None. One export added; nothing it reads changed.
115
+ - **Consumers.** @server @cli: call it with the mailbox store and session store you wire and show `reason` when `ok` is `false`, instead of discovering the unmounted lane at run time. @test: nothing changes in the running engine; the black-box face is the import.
116
+ - **Pins.** `test/backlog3480-session-box-verdict-root.test.ts` — B1 the root value is the module's function · B2 the verdict over both halves (the mailbox half judged first, its reason with no word of `headOf`; an absent store, `{}`, a non-function, `null` and a misnamed read each name the missing read) · B3 a passing pair is exactly the mailbox verdict's own answer · B4 the engine's seats call this function and its judgment is written once · B5 the smoke list · B6 the frozen surface. `test/export-surface.test.ts` re-baselined (Δ +1).
117
+
118
+ ### "Is this entry a control object?" is one question — a kind's listing names regular files under legal names, `getObject` / `deleteObject` / `putObject` refuse any other entry by name, a name is at most 255 UTF-8 bytes, and adopting from a directory that is not there is refused (#3476; behavior change: the File store's listing, read, delete and put over a non-object entry, a name over 255 bytes, and `adoptReplicaControlPlane` over a missing directory; narrowing: two, for the implementers of the seat and for adoption callers, open to veto; hard-breaking: none (no type changed); closed sets: none; exports: none) (@server @dgx @test)
119
+
120
+ - **Before.** The File store answered "what is in this kind?" by `readdir` alone: a subdirectory or a dangling link was listed as an object name, `getObject` met the same entry with an errno read as "stands but cannot be read", `deleteObject` met it with a raw `EPERM` and no code, and a 20 KB name passed `isControlObjectName` and failed as `ENAMETOOLONG` read as "the control plane cannot be probed" — a store fault, not a refused name. `adoptReplicaControlPlane` over a directory that was never there reported nothing adopted, so a mistyped path read as a finished handover.
121
+ - **Now.** One reading, `entryAt` (`src/core/memory-engine/control-objects.ts`): `absent` (only an `lstat` that finds nothing), `object` (a regular file, or a link whose target is one) or `other`. `listObjects` names the `object` entries under legal names, sorted; `getObject`, `deleteObject` and `putObject` over an `other` entry throw `ControlPlaneCorruptError` in one sentence (`… stands but is not a control object (a regular file under a legal name) — … (fail-closed)`), with no raw errno, and leave the entry standing; an object whose unlink fails is a `ControlPlaneCorruptError` with its errno as `cause`. `isControlObjectName` adds the bound: at most 255 UTF-8 bytes (a file name on the systems the store runs on), so an over-long name is `memory.control_object_unknown` on every verb, in the File store, in the test kit's in-memory twin and in the contract suite's clause. `adoptReplicaControlPlane(controlDir, …)` over a `controlDir` that does not exist throws `ControlPlaneCorruptError` naming the path (the File store over that same directory still answers an empty report); `replicaControlPlaneStrays` is unchanged and answers empty for it — a plane nothing was written to holds nothing, and the engine's construction-time probe (S2) must be able to ask. The filter is the store verb's alone: adoption and the strays reader read `standingFileControlObjectNames` (every name standing in a kind's directory), so an entry standing where an object belongs — a directory at a hold's custody name, a dangling link at a marker's — is still counted as a stray and still refused by name in adoption, which withholds the documents behind it (a document row never reaches the carrier ahead of the bytes it names); skipping it there would have copied the hold ledger without its custody (the one finding of the branch's codex round, fixed).
122
+ - **Narrowing 1 (open to veto, @server @dgx).** A store outside core that accepts a name longer than 255 UTF-8 bytes fails `memoryGovernanceStoreContract`'s "one opaque segment" clause; refuse it `memory.control_object_unknown`. A name over that length already failed on the File store (`ENAMETOOLONG`, read as an unprobeable control plane), so nothing that worked stops working; it now fails as a refused name instead of a store fault (inferred from the File store's behaviour; the minters of core's names were not audited here). **Narrowing 2 (open to veto, @server @cli).** A host that called `adoptReplicaControlPlane` on a directory that may not exist now gets a refusal there: ask `replicaControlPlaneStrays` first (it answers empty), or catch it.
123
+ - **Known limit.** An entry is an object by its kind (a regular file) and its name's shape, never by what it is called: a stray `.DS_Store` file in a kind's directory is a regular file under a legal name and is still listed (`.hidden` is a legal object name, so the predicate cannot drop it without refusing names a writer may use). A subdirectory, a link to one and a dangling link are no longer listed.
124
+ - **Consumers.** @server @dgx: the name bound is a clause of the suite your SQL / PG leg runs; a column that holds a name needs 255 bytes. @test: black-box faces are `listObjects` over a directory with a subdirectory in it, `deleteObject` over one (a coded refusal where it was a raw `EPERM`), and the adoption refusal.
125
+ - **Pins.** `test/backlog3476-control-object-entry.test.ts` — L1 a listing answers regular files under legal names only · L2 a backslash name is not listed · L3 get over absent / file / subdirectory / dangling link / link to a directory · L4 delete over the same: refused by name, no raw errno, left standing · L5 one predicate: every entry is listed exactly when get answers bytes, and delete refuses exactly the present unlisted · L6 255 bytes work end to end, 256 bytes (and 258 bytes in 86 characters) are `memory.control_object_unknown` on every verb, nothing written · L7 the in-memory twin · L8 the strays reader still counts every standing entry while the store's verb names objects only · L9 adoption from a missing directory is refused by name, the strays reader answers empty, the same-directory File store answers an empty report, nothing is created · L10 an existing empty directory is an empty report · L11 an object whose unlink fails is a coded refusal carrying the errno as its cause · L12 adoption refuses a directory at a hold's custody name and a dangling link at a marker's, withholds the hold ledger behind them, and converges once the damage is gone. The contract suite's "one opaque segment" clause carries the two over-long names.
126
+
127
+ ### A put over a standing name is answered for the same bytes only — `putObject` refuses other bytes, and an entry it cannot read to tell, the way `moveObject` refuses a target holding other bytes (#3475; behavior change: the File store's `putObject` over a standing name holding other bytes throws `ControlPlaneCorruptError` where it answered `"existed"`; narrowing: one, for the implementers of the seat, open to veto; hard-breaking: none (no type changed); closed sets: none; exports: none) (@server @dgx @test)
128
+
129
+ - **Before.** The File store's `putObject` answered `"existed"` for any name that stood, without looking at what it held: a caller whose bytes differed had them dropped and was told the name existed (put `AAAA`, put `BBBBBBBB`: `"existed"`, the disk still `AAAA`). `moveObject` over a target holding other bytes refused. One seat, two readings of "the name stands with other bytes". The same held for an entry that stood but could not be read (a directory on the name): the put answered `"existed"`.
130
+ - **Now.** `"existed"` means the name holds exactly the bytes handed in. Other bytes — and an entry that cannot be read to compare — throw `ControlPlaneCorruptError` in the sentence the move uses (`… the name already stands with different bytes — refusing to overwrite it (fail-closed)`); no new code, nothing is written, no stage file is left. The comparison reads the standing name through `getObject`'s own reader, and also runs when the name was not there at the probe but won the `link` (a lost race). The contract sentence `memory.governance.object_written_once` and the `putObject` JSDoc say it; `memoryGovernanceStoreContract` asserts it ("an object is written once", "an object that stands but cannot be read"). The origin-clearance account's custody writer relied on a second look after `"existed"`; the put's own comparison made it dead, and it is gone.
131
+ - **Narrowing (open to veto, @server @dgx).** An implementation of `MemoryGovernanceStore.putObject` outside core that answers `"existed"` for a standing name whatever it holds now fails the contract suite's two clauses above. The fix on their side is the one comparison: byte-equal ⇒ `"existed"`, other bytes ⇒ throw your `ControlPlaneCorruptError`. The bundled File store and the test kit's in-memory twin do it. Adoption (`adoptReplicaControlPlane`) onto a carrier that holds an object of that name with other bytes now reports the carrier's own refusal sentence as the record's reason (the record is refused and left in the replica, as before).
132
+ - **Consumers.** @server @dgx: the SQL / PG leg of the seat (S-3068) implements the clause above before it takes the suite. @test: the visible surface is the seat's own verbs and `adoptReplicaControlPlane`'s `refused` reason (`already stands with different bytes`); the engine's own writers still call the File helper directly (S2 moves them onto the seat), and the helper has the same comparison.
133
+ - **Pins.** `test/backlog3475-put-other-bytes.test.ts` — P1 same bytes ⇒ existed, nothing changes · P2 other bytes ⇒ refused by kind/name, standing bytes stand, no stage file · P3 empty vs non-empty both ways · P4 every kind · P5 the put's and the move's refusal are one class, one sentence stem, no code · P6 the probe misses, the link finds the name (lost race): other bytes refused, same bytes existed · P7 the name is gone between the lost link and the comparison: nothing written, said so · P8 a directory on the name: refused, never existed · P9 the in-memory twin · P10 the contract sentence and its registry row. Changed pins: `test/backlog3465-control-plane-carrier.test.ts` C1 / C2 / C9 (the old ones asserted `"existed"` for other bytes and for a directory), the kit's two clauses (`src/core/memory-engine/memory-backend-contract.ts`).
134
+
135
+ ### `CompactionSeat` is a registry row — `COMPACTION_SEATS` is exported from its module, so the closed-sets registry and the release manifest read the two seat words from one source (#3481; behavior change: none; hard-breaking: none; closed sets: +1 registry row, no word added or removed; exports: none — the array leaves its module, not the package root) (@test)
136
+
137
+ - **Before.** `COMPACTION_SEATS` (`src/core/context-settings.ts`) was a module-private `const`. The release manifest's reader (`scripts/wire-changes.mjs`) enumerates exported closed-set arrays only, so the 7.64.0 section could state the seat words only as a note under "Notes per row" of `docs/CLOSED-SETS.md`, not as a registry row — a second place a reader had to know about.
138
+ - **Now.** `export const COMPACTION_SEATS` (frozen where it is declared, as before) and the registry row `| CompactionSeat | src/core/context-settings.ts | array:COMPACTION_SEATS | — | live |`; the note's closing sentence ("Not a registry row … the row waits for the array to be exported") is gone because the row it was waiting for is there. `src/index.ts` is untouched: the type and the array are still not on the package root.
139
+ - **Narrowing / widening.** None. No word was added to or removed from the set; no read or refusal changed.
140
+ - **Consumers.** None outside the repository's own gates.
141
+ - **Pins.** `gate:closed-sets` (the new row's file, set and members are read from source) · `test/closed-sets-literal-members.test.ts` (the registry's reader and the manifest's reader agree word for word over every row, this one included) · `test/closed-sets-frozen-exports.test.ts` (the exported array is frozen).
142
+
143
+ ### The credential table is the union of the engine's, the server's and the settings package's shapes — six new rows and five widened ones; each family's strict, wide and environment-value forms sit on its one row, and the environment scrub's seven value rules and token head are read off the rows (`tokenPrefix` retired) (#3339 = #3223 S1b, ruled C-R1084 K5 / K6 / K12; behavior change: egress withholds the forms listed below, the durable memory write door refuses five more strict shapes; narrowing: those forms, security, open to veto; widening: none; hard-breaking: three sentences below, plus one type-level sentence (the `@sema-agent/primitives` wire manifest's three breaking items: `CredentialVocabulary` +`flagWords` +`names` required, −`tokenPrefix`; `EnvNameView` −`tokenPrefix`); closed sets: none; exports: `@sema-agent/primitives` +1 value `envValueView`, +1 type `EnvValueView`; members: `CredentialVocabulary` −`tokenPrefix` +`flagWords`, `ValueFamilyRow` +`envValue?` +`envValueHead?`, `EnvNameView` −`tokenPrefix`; `@sema-agent/core` none) (@server @ss @cli @client-core @test)
144
+
145
+ - **Before.** The table held twenty rows. The server's redaction recognised shapes the table did not (the GitLab token kinds beyond `glpat-`, PyPI upload tokens, Slack refresh and app-level tokens, `sk_org_` keys, `Basic` / `token` scheme credentials, signed-URL parameters such as `X-Amz-Signature`), the settings package held its own private-key containers, and the engine's environment scrub (`src/core/secret-env.ts`) spelled seven value rules of its own (credential assignment, webhook URL, SonarQube login, private-key header, `Authorization:` header, `token <value>`, `Bearer` / `Basic <value>`) and read a token head from a `tokenPrefix` member of the table that no row owned.
146
+ - **Now.** `CREDENTIAL_VOCABULARY` has twenty-six rows (`src/primitives/secret-vocabulary.ts`). New: `pypi-token`, `slack-app-token`, `basic-credential`, `token-scheme`, `sonar-login`, `webhook-url`. Widened: `gitlab-pat` (thirteen prefixes, and a strict form: a body holding a digit), `slack-token` (`xoxe-`), `stripe-secret-key` (strict `sk_org_` / `rk_org_`), `private-key` (SSH2 and PuTTY containers), `signed-url-param` (every URL credential name, below). A row's environment-value form (`envValue`) and token head (`envValueHead`) are members of the row; the env scrub reads them through `envValueView()` — `forms` (each row's `envValue`, table order), `tokenHead` (each row's `envValueHead` as one anchored alternation, the same ten heads `tokenPrefix` held: `gh[opusr]_` `github_pat_` `sk-` `pk-` `glpat-` `npm_` `ya29.` `xox[abpr]-` `AKIA` `eyJ`) and `flagWords` (the table's). The environment faces answer as before on every base fixture and on 270 texts (`looksLikeCredentialValue` and `isSecretEnvKey`: zero changes, base `c9bc43b3b` against this tree; the scrub reads those two). The signed-URL row's value run (and the new SonarQube row's) ends where every value run ends, so a backslash-escaped closing quote stays whole: such a parameter inside a JSON string inside a JSON string no longer breaks the outer document (KNOWN-LIMITS KL-958-d, its signed-URL clause closed).
147
+ - **Hard-breaking — three sentences (open to veto, @server @ss @cli @client-core).** *What changed:* (1) the engine's one egress pass (`egressText`, both tiers — so `redactSecrets`, `redactHostLeaks`, the activity-argument summary and every face that writes through it) now withholds the forms listed below, where it let them through; (2) the durable memory write door (`detectSecret`, read by the engine's write scan `scanMemoryWrite`) refuses five more strict shapes — a `secret` finding naming the family, so the engine refuses the write: `gitlab_pat` (thirteen prefixes, a body holding a digit — `glpat-` included, which the door let through before), `pypi_token`, `slack_token` (`xoxe-`), `slack_app_token` and `stripe_secret_key` (`sk_org_` / `rk_org_`). *Who is affected:* a host that pins "egress equals input" for one of these forms, and a host whose memory writes held one of these strict shapes. *Compensation / migration:* re-pin the egress assertion to the `[redacted]` form; remove the credential from the memory write (nothing else moves — no verb, frame, code or option changed).
148
+ - **Hard-breaking — type level (open to veto, @server @cli @client-core).** *What changed:* `CredentialVocabulary.tokenPrefix` and `EnvNameView.tokenPrefix` are gone from `@sema-agent/primitives` (exported since 7.63.0), and `CredentialVocabulary` gains the required member `flagWords` (`names`, below, is the other required addition). *Who is affected:* a reader of either removed member, and a caller that builds a `CredentialVocabulary` literal by hand to pass to `envNameView` / `envValueView` — none in core; at origin/main a name search finds no `tokenPrefix` in the server, settings-schema, cli, client-core, sdk, desktop, web-client and web-admin trees (the test tree holds it only in copied evidence text) and no `CREDENTIAL_VOCABULARY` / `envNameView` reader in the server, cli, client-core, sdk and desktop trees. *Compensation:* `envValueView().tokenHead` — the same branch set, built from the rows; a hand-built vocabulary adds `flagWords` and `names` (spread them from `CREDENTIAL_VOCABULARY`).
149
+ - **Newly withheld forms (one line each; synthetic examples, every value a filler).**
150
+ - `gitlab-pat`: `gldt-` `glrt-` `glrtr-` `glcbt-` `glptt-` `gloas-` `glft-` `glimt-` `glagent-` `glwt-` `glsoat-` `glffct-` + ≥ 20 token characters (deploy, runner, CI build, trigger, OAuth app, feed, incoming-mail, agent, workspace, service-account, feature-flag tokens); `glpat-` was already withheld.
151
+ - `pypi-token`: `pypi-` + ≥ 85 characters (an upload token), with or without a digit.
152
+ - `slack-token`: `xoxe-` + ≥ 10 characters (a refresh token). The wide form is broad, as it was for `xoxb-`: a prose slug behind the head (`xoxe-session-expiry-notes`) is withheld too; the strict form and the memory door leave it.
153
+ - `slack-app-token`: `xapp-<digit>-` + ≥ 20 characters (an app-level token); the same for a slug (`xapp-1-setup-guide-for-the-team`), withheld on egress, admitted by the memory door.
154
+ - `private-key`: an SSH2 `---- BEGIN SSH2 ENCRYPTED PRIVATE KEY ----` block, a PuTTY `PuTTY-User-Key-File-<n>:` container through its `Private-MAC:` line, and a headless `Private-Lines: <n>` body; public blocks and the field names in prose are not read.
155
+ - `basic-credential`: `Basic` (any case) + ≥ 8 base64 characters holding a digit, two humps or `+` / `/` / `=` (`Basic auth is disabled` and `a basic understanding` are not read).
156
+ - `token-scheme`: `token` / `Token` / `TOKEN` + ≥ 20 token characters holding a digit, not followed by `/` or `.` (a path segment after it is not read).
157
+ - `sonar-login`: `sonar.login` `=` / `:` a value of ≥ 8 characters, quoted or not, in JSON too.
158
+ - `webhook-url`: an `https://` Slack (`hooks.slack.com/services|workflows|triggers/`), Discord (`discord.com` / `discordapp.com`, `ptb.` / `canary.`, `/api/webhooks/<id>/`) or Teams (`<tenant>.webhook.office.com/webhookb2/`) webhook URL's secret path, ≥ 16 characters; the bare head and a docs path are not read. On the `human` tier the URL was already withheld whole.
159
+ - `signed-url-param`: a URL query or fragment parameter named by any of the twenty-four URL credential names (#3340 below; was `sig`, `signature`, `sas`, `code`) — e.g. `X-Amz-Signature=…`, `X-Amz-Security-Token=…`, `apikey=…`, `access_token=…`, `client_secret=…` — the name and `=` kept, the value withheld.
160
+ - **Old fixtures.** One verdict moved: `gitlab-cc` (a `glpat-` token with a digit, from the reference implementation's rule) is now refused by the memory write door as `gitlab_pat` (it was let through; egress already withheld it). No other base fixture moved on any face (egress, host tier, activity summary, refuse, env value, env name).
161
+ - **Rules.** Six rows of data (+6) and five widened rows (data); seven env value rules moved onto rows (−7 rules, +1 view); `tokenPrefix` retired (−1).
162
+ - **Consumers.** @server: the union rows are the server's own shapes — your redaction can read `CREDENTIAL_VOCABULARY` instead of its copies at S3b; the memory refusals above reach your memory routes as the engine's `secret` rejection (`scanMemoryWrite`, `detected <family>`). @ss: the private-key containers are yours; the S2b retirement of your copies reads the rows. @cli @client-core: re-pin any test that asserts a raw form above survives egress. @test: the egress, refuse and env faces per form are in the pins.
163
+ - **Pins.** `test/backlog3339-union-rows.test.ts` — U0 the fixture gate over every row, grade and the env view · U1 each newly withheld fixture is gone from every egress face (24 fixtures) · U1b this section names each newly withheld family · U2 / U2b the eight newly refused fixtures by the detector and by the engine's write scan, and their prose neighbours admitted · U3 the thirteen GitLab prefixes · U4 the scheme tokens and the three-segment JWT · U5 / U6 the env value view on the real seat, no value form spelled in `secret-env.ts` · U7 / U7b / U7c the token head built from the rows and equal to the reference implementation's branch set, no `tokenPrefix` anywhere · U8 / U8b every URL credential parameter at nesting depths 1–6 and the SonarQube login in nested JSON keep the documents parseable. Fixtures: `test/fixtures/secret-detect-fixtures.json` (synthetic fillers only), gated by `scripts/verify-credential-vocabulary.mjs`.
164
+
165
+ ### Secret readings are a closed set of named readings in `@sema-agent/primitives` — `percent-layers` (its depth the caller's), `percent-boundary` and `form-plus` join `raw` and `format-free`, each a pure view of the text with a way back to written coordinates; and one names table answers which name marks a credential in an assignment or a URL parameter (#3340 = #3223 S2a, ruled C-R1084 K2 / K7 and addendum 1; behavior change: none on any engine face — the engine reads no text reading; hard-breaking: one, type level — `CredentialVocabulary` gains the required member `names` (told with `flagWords` in the #3339 section's type-level sentence); closed sets: `SECRET_READING_KINDS` +3 (`percent-layers`, `percent-boundary`, `form-plus`), new `CredentialNamePlace` (`assignment`, `url-param`); exports: `@sema-agent/primitives` +1 value `secretReadingViews`, +5 types `SecretReadingKind` `SecretReadingView` `SecretReadingViews` `CredentialNameRow` `CredentialNamePlace`; members: `CredentialVocabulary` +`names`; the `SecretReading` union +3 members) (@ss @server @client-core @test)
166
+
167
+ - **Before.** The settings package scanned a text through three readings of its own (`secret-scan.ts`: percent-decoded layers, a run of `%HH` escapes read as UTF-8, `+` read as a space) with no way back to the written text's coordinates; its URL credential parameter names (`CREDENTIAL_PARAM_NAMES`, twenty-three), the engine's signed-URL parameter list (four) and the engine's keyword words (six) were three lists answering one question.
168
+ - **Now.** `src/primitives/secret-readings.ts`: `SECRET_READING_KINDS` = `raw`, `format-free` (character readings: how one text is scanned) and `percent-layers` (`{ kind: "percent-layers", depth }`, depth an integer 1 … 8), `percent-boundary`, `form-plus` (text readings: each derives more texts, scanned the same way). `secretReadingViews(text, readings)` answers the views — the written text first, each text once — each with `toOriginalSpan(start, end)`, the whole written units a span was read from (a decoded escape's three characters, every escape of a decoded code point: a mapped-back span never cuts an escape), and `unresolved`: the layers ran out while one more would still decode. `scanSecrets` / `renderSecrets` read a policy's text readings the same way (spans in written coordinates; a hit in a view withholds its written units), and answer `{ outcome: "whole", reason: "reading-unresolved" }` / the over-strip mark only under `onUnresolvedReading: "secret"`; under `"ignore"` the views read are scanned. A reading is checked whole: an unknown kind, a member a kind does not take, a missing or out-of-range depth, `percent-layers` listed twice, or no character reading throws a `TypeError`. The views equal the settings package's own `forms` / `unresolved` on its cases and on 6000 seeded strings (frozen oracle in the pin). `CREDENTIAL_VOCABULARY.names` (`{ name, places }`, `places` ⊆ `assignment` / `url-param`) is the one names table: twenty-five names — the settings package's twenty-three and `code` read as URL parameters, `token` `secret` `key` `password` `passwd` `credential` read in an assignment; the keyword row reads the `assignment` names, the signed-URL row the `url-param` names.
169
+ - **Narrowing / widening.** None on any engine face from the readings: the engine's own policies read `raw` and `format-free` only. The widening of the URL parameter row by the merged names is told in the #3339 section above; the renderer change the review of this section found (kept parts, #3483) is the next section.
170
+ - **Rules.** Three readings move into the package as closed-set members (no new rule); the three name lists become one (−2).
171
+ - **Consumers.** @ss: S2b replaces your three readings and `CREDENTIAL_PARAM_NAMES` with `secretReadingViews` (at the `percent-layers` depth you read today, 3) and `names`; until then your copies and the package's answer the same (the pin's frozen oracle is your code at origin/main `30bceb5`). Open to veto (@ss), the one point of this section: the names merge — your `CREDENTIAL_PARAM_NAMES` retires at S2b in favour of `names`. @client-core: the depth is a parameter, as asked. @server: nothing to change.
172
+ - **Pins.** `test/backlog3340-readings.test.ts` — R0 the closed set and the reading checks · R1 / R2 the settings package's cases and 6000 seeded strings against its frozen normalization · R3 the depth is the caller's · R4 the way back covers whole written units · R5 / R6 the renderer and the matcher read through the text readings, spans in written coordinates · R7 `reading-unresolved` only under `secret` · R8 / R8b / R8c one names table, read by the URL parameter row (every `url-param` name, any case, whole names) and the keyword row.
173
+
174
+ ### A part a pass keeps — a URL username, a key name, a header label — is the written text, read by every other scan: a key another scan finds inside it is withheld, and a format character inside it survives (#3483, found by the review of the #3340 section on the format-free renderer; behavior change: egress withholds one form it printed, prints a kept label as written, and returns a long text it threw on; hard-breaking: none; closed sets: none; exports: none) (@server @cli @ss @client-core @test)
175
+
176
+ - **Before.** With the `format-free` reading on — the engine's egress policy reads it — each match on the format-free view was spliced back whole, its kept parts written from the view, and a hit the raw text or a format-character cut found inside a kept part was absorbed into that match. `redactSecrets("https://x<U+200B>sk-<20 characters>:pw@host/")` returned `https://xsk-<20 characters>:[redacted-credentials]@host/`: the key in clear (7.63.0 and 7.64.0 alike). The kept part lost its own format characters (`pass<U+200B>word=<value>` → `password=[redacted]`), or the whole match went, label included (`Authorization: Bear<U+200B>er <value>` → `[redacted]`). With the text readings on (the section above), a hit a derived text found inside a kept username was counted as already removed (`https://%73k-<value>:pw@host/<U+200B>` kept the encoded key).
177
+ - **Now.** Every scan's removals are the part its pass withholds — a kept label or username outside it — in the written text's coordinates, and the output is rendered from their union (`renderOneText`, `src/primitives/secret-scan.ts`): `https://x<U+200B>[redacted]:[redacted-credentials]@host/`, `pass<U+200B>word=[redacted]`, `Authorization: [redacted]`. In a text rendered from the union, touching removals that write the same marker write it once (`renderRemovals`), so a rendered text renders to itself: `passw<U+200B>ord=abcd,Authorization:<U+200B> Bearer <value>` → `passw<U+200B>ord=[redacted] [redacted]`, and the same again with no finding. A text the sequential run renders alone still writes one marker per pass, as before: two touching keys read `[redacted][redacted]`, and `[redacted]` once a format character sits elsewhere in the text (the characters withheld are the same; only the marker count differs).
178
+ - **Also fixed (same review).** A long text holding a format character and some 130 000 hits — `"x<U+200B> " + "password=abcd ".repeat(130000)` — made `redactSecrets` throw `RangeError: Maximum call stack size exceeded` instead of returning the redacted text (7.63.0 and 7.64.0 alike): every scan's removals were spread into one call. They are appended one at a time; the text renders. (#3486 — the shipped `RangeError` on a long text with one format character, 7.63.0 / 7.64.0; fixed by the same render law.)
179
+ - **Newly withheld form.** `url-userinfo` + a vendor token: a token in a kept URL username that only the raw text or a format-character cut reads (a format character right before its head).
180
+ - **Narrowing (open to veto, @server @cli @ss).** The newly withheld form above.
181
+ - **Widening (open to veto, @server @cli @ss).** A kept label's own characters — a format character inside it, a label a cut scan's hit used to swallow — are printed as written. No credential character is among them.
182
+ - **Rules.** A removal is the withheld part, for every scan; the merge that absorbed a hit into a kept part goes (−1). The join rule of the union render gains one clause: a removal that touches the one it continues and writes the same marker joins it (+1). Net 0.
183
+ - **Consumers.** @server @cli @client-core @test: a test that pins an egress output of a text holding a format character inside a kept label re-pins to the label as written, and one that pins two touching markers in a text holding a format character re-pins to one.
184
+ - **Pins.** `test/backlog3340-readings.test.ts` — R9a a derived text's key inside a kept username · R9b a raw-only / cut-only key inside a kept username, at the renderer (with its finding) and on `redactSecrets` · R9c a kept label printed as written, a format character outside every hit kept · R9d the long text renders (format-free alone, and raw + format-free) · R9e two scans' touching removals write one marker; the output renders to itself with no finding.
185
+
186
+ ### A credential cut inside its body is read by its family's fragment form — the server's residue arms sit in the rows' `fragment` slots, read by a `fragment` grade of their own (#3341 = #3223 S3a, ruled C-R1084 K5; behavior change: none on any engine face — the engine reads no fragment grade; hard-breaking: none; closed sets: `SecretGrade` +1 (`fragment`); exports: none (members: `ValueFamilyRow` +`fragment?`)) (@server @test)
187
+
188
+ - **Before.** What is left of a vendor token after a text was cut inside its body (a head and a short residue: the shape a truncated preview leaves) was read only by the server's redaction, by arms of its own.
189
+ - **Now.** Nine rows carry a `fragment` form (global): `github-token`, `github-fine-grained-pat`, `openai-api-key`, `stripe-secret-key`, `gitlab-pat`, `pypi-token`, `slack-token`, `slack-app-token`, `aws-access-key-id` — the server's residue arms, the same spans on a seeded corpus, plus the `xoxe-` head the union adds. `scanSecrets` / `renderSecrets` with `grade: "fragment"` read those forms (one pass per row, in the table's order) under the same readings and marks as the other grades; a residue below the wide floor is a fragment hit and no wide one.
190
+ - **Narrowing / widening.** None on any engine face. One reading differs from the server's arms at the left edge: the slot accepts the same quote spellings before a head as the wide forms do, where the server's arm also reads an escaped separator's tail (KNOWN-LIMITS KL-3341-a). The left edge is every wide form's too; widening it to an escape's tail is #3482, and the slot reads the same edge when that lands.
191
+ - **Rules.** Nine slots of data on existing rows, one grade member; no new rule.
192
+ - **Consumers.** @server: S3b reads the slots with `grade: "fragment"` in place of your arms. @test: the residue fixtures state `fragment`.
193
+ - **Pins.** `test/backlog3341-fragment-slots.test.ts` — F0 exactly the nine families, every form global · F1 each slot reads what the server's arm reads (frozen arms, seeded corpus) · F2 the union head · F3 every fixture that states `fragment`, at the matcher and the renderer · F4 the grade is its own · F5 the left boundary · F6 the readings apply · F7 one pass per row, in the table's order.
194
+
195
+ ### A deny or ask entry that names a tool the engine retired with no successor is left out of the run's name audit and told — one `config.legacy_tool_name` notice per audited layer replaces the refusal of the whole run (#3437; ruled C-R1110; behavior change; behavior narrowing: none; widening — one, open to veto; hard-breaking: none; closed sets: `EngineNoticeCode` +1, `config.legacy_tool_name` (audience `user`, minter `engine`; the spelling was already a thrown code and still is); exports: none; wire: notice code +1, additive) (@cli @server @client-core @test)
196
+
197
+ - **Before.** The prepare-time policy-name audit refused the whole run (`config.legacy_tool_name`) for any retired tool name on a `deny` or `ask` list — the run's own policy (`--disallowedTools`, a deployment's deny list), the session's stored rules, or the rules an ancestor's session handed down. A user's own `TaskOutput` or `TeamCreate` line, copied from an older setup, stopped every run (cli L-2316). The reference accepts such a name and never matches it, without a word.
198
+ - **Now.** One reading of the retirement table's own grammar. A retired name whose line says `removed` or `folded` — it has no `currentName`, no tool answers to it now or later — is left out of the audit's pass and told: ONE notice `config.legacy_tool_name` (audience `user`: the person who wrote the entry believes it guards a tool) per audited layer per prepared task, minted by `retiredToolNameNotice` and nowhere else, said only when the run goes on. `detail: { layer, entries: [{ field, entry, layer, guidance }], total, sessionId }` — `layer` is `caller_policy` / `session_rules` / `ancestor_session_rules`, `field` is `deny` / `ask`, `guidance` the retirement table's own line, `entries` unique by (field, entry) in scan order and at most 32, `total` counting every one. Every other row of the same list is audited and enforced as before; the entry itself stays where it was written and matches nothing. A retired name that was RENAMED (it has a successor, `bash` → `Bash`) is not this: its entry guarded a tool that is still mounted, so leaving it out would widen the surface, and it is refused as before with the name to write. Every other bad name (an unprefixed namespace name, an unmintable segment, a case twin of a mounted tool) is refused as before; an `allow` list keeps its advisory; a deployment that mounts its own tool under a removed name is unaffected (the roster clears it).
199
+ - **Widening — one (open to veto).** A run whose `deny` or `ask` list holds a removed or folded name starts where it was refused. The only thing that entry could have guarded is a tool no roster mounts; the notice is the loud half. This is one step past the reference, which says nothing (a deviation, open to veto: the bad-value rule asks for a loud answer).
200
+ - **Rules.** Added: the notice (the catalog, its audience and minter rows), one factory. Retired: the refusal of a `removed` / `folded` name on a restricting list. The retirement table stays the one table.
201
+ - **Consumers.** @cli: `config.legacy_tool_name` now also arrives as an engine notice (user audience) — render it where session notices render; the thrown code on a renamed name is unchanged, so a line that matched the thrown error for a removed name no longer fires — drop it. @server: pass-through, nothing to change; a policy compiled from settings with a removed name now starts. @client-core: if you mirror the engine notice catalog (`EngineNoticeCode`), add `config.legacy_tool_name` (audience `user`) — whether you mirror it was not checked. @test (black box): `deny: ["TeamCreate"]` ⇒ the run completes and one `config.legacy_tool_name` notice names the entry; `deny: ["bash"]` ⇒ refused as before, no notice.
202
+ - **Claude Code 2.1.316.** Anchored for the name's acceptance: the command-line deny list goes into the rule set unchecked (`cli316.js:277082`, `Yu(disallowedToolsCli)`), where the allow side is filtered and an unusable rule is reported as "Ignoring --allowedTools rule" (same line); the renamed-name alias table is `:260527` (eight names, mapped to the current tool) and the removed-name set `:270313` (`TeamCreate`, `TaskOutput`, … — kept for transcript consistency), the two classes the split above follows. The notice is the one addition (a deviation, registered with the divergences). All read in the corpus for this change, not run.
203
+ - **Pins.** `test/backlog3437-retired-name-left-out.test.ts` — N1 / N2 a removed name on a deny / ask list · N3 the other rows still bind · N4 a renamed name is still refused, alone and beside a removed one, with no notice · N5 every other bad name is refused · N6 an allow list keeps its advisory · N7 / N8 a session row, and one notice per layer · N9 one notice per pass · N10 a deployment's own tool under a removed name · N11 the catalog rows · N12 the factory's bound; `test/backlog3026-taskoutput-retired.test.ts` T5 re-pinned to the new reading. Mutations (receipt).
204
+
205
+ ### The approval-record store's failures at the entries that make and settle a record are refusals — `confirmRuleApproval` and the card edit answer `store_read` / `store_write`, and `prepareCardApproval`, `prepareCcImport` and `prepareStarterBatch` answer the refused arm, where they let the rejection out (#3430; ruled C-R1111; behavior change; behavior narrowing — one, open to veto; hard-breaking: one, type level, three sentences below, open to veto; closed sets: `ConfirmRefusalReason` +2, `store_read` and `store_write` (words `RuleRefusalCode` already holds); exports: none; wire: no key added) (@server @cli @client-core @test)
206
+
207
+ - **Before.** Since #3428 the redemption leg answers a failure of the approval-record store as `store_read` / `no` (a read) and `store_write` / `unknown` (a compare-and-set, a dot allocation). The entries that make and settle the record let the same store's rejection out as a bare throw: `prepareCardApproval`, `prepareCcImport`, `prepareStarterBatch` (`create`), `confirmRuleApproval` (`get`, `cas`, the re-read after a lost `cas`) and the card edit (`cas`, the re-read). One store, two failure readings.
208
+ - **Now.** One reading, one mint (`refusal()` through `storeStep`), no new code. `ConfirmRefusalReason` takes `store_read` (a read threw — nothing of this confirmation was written) and `store_write` (the compare-and-set threw — a backend can commit and lose its acknowledgement, so the record may or may not be settled; repeating the same confirmation is the idempotent yes), with the store's own message in `detail.message`; a confirmation carries no `committed` of its own, the word says it. The three prepare entries answer the redemption leg's refused arm, `{ status: "refused", code: "store_write", committed: "no", retriable: true, reason }` (`committed` read the store table's one way, #3492's section: a prepare writes no rule), where they rejected (a record that failed to create may still exist; nobody holds its id, so a repeat prepares a fresh card). The sentence names the step and carries the store's own message. An import with nothing importable creates no record and refuses nothing, as before.
209
+ - **Narrowing — one (open to veto).** The five entries resolve with a refusal where they rejected, for a failure of the approval-record store. A host that caught the rejection reads the result now.
210
+ - **Hard-breaking — one, type level, three sentences (open to veto).** *What changed:* the results of `prepareCardApproval`, `prepareCcImport` and `prepareStarterBatch` gain the refused arm (a union member), and `ConfirmRefusalReason` gains two words. *Who is affected:* any host that destructures `approvalId` (or `preview`) from a prepare result, or switches exhaustively over `ConfirmRefusalReason`, no longer compiles until the refused arm and the two words are handled — @server (the rules-consent door, read at its origin/main checkout, not compiled against this tree), @cli and @client-core where they mirror the types; no engine-internal caller exists. *Compensation:* branch on `"status" in result` (or `result.status === "refused"`) before reading the prepare result, treat `store_read` as a retry-safe read failure and `store_write` as "reconcile with a repeat of the same call" (a prepare's refused arm says whether to repeat in `retriable`; read that, not the code).
211
+ - **Rules.** Retired: the rejection escape of the approval-record store at these five entries (`storeStep` routes them). Added: none (three sentence constants; the helper that puts a store refusal in the confirmation's shape reads the one mint's output).
212
+ - **Consumers.** @server @cli @client-core: map `store_read` / `store_write` on a confirmation as for a redemption, and the refused arm on a prepare as for a redemption's. @test (black box): an approval-record store whose `create` throws ⇒ every prepare entry answers the refused arm; whose `get` throws ⇒ the confirmation answers `store_read`; whose `cas` throws ⇒ `store_write`.
213
+ - **Claude Code 2.1.316.** No anchor: Claude Code keeps no persisted permission-rule approval record.
214
+ - **Pins.** `test/backlog3430-approvals-record-store-failure.test.ts` — P1–P3 the three prepare entries over a throwing `create` · P4 the record read · P5 / P6 / P7 the compare-and-set that throws, that commits and loses its acknowledgement, that loses and meets a throwing re-read · P8 the card edit · P9 the census · P10 controls · P11 one mint; `test/backlog3428-approvals-store-failure.test.ts` header sentence updated. Mutations (receipt).
215
+
216
+ ### The instruction-hold ledger and its captured bytes ride the governance store — a hold's row is the `holds` document's, its custody the `hold` object, its disposal a move to a `quarantine` object, an orphan of an older disposer adopted from the objects; `resolveHold` and `readInstructionHolds` answer Promises (#3485, C-R1119 S2a′ = addendum 5; behavior change: one — for a backend that carries a governance store which is not the File store over the engine's control plane, the hold family now lives in that store; behavior narrowing — three, open to veto; hard-breaking: one (HB-2, two faces), three sentences below, open to veto; closed sets: none; exports: none — the hold functions are module functions, not on the package root; members: `MemoryEngine.resolveHold` returns `Promise<void>`, `MemoryEngine.readInstructionHolds` returns `Promise<HoldRow[]>`; wire: none) (@server @dgx @test)
217
+
218
+ - **Rule.** The last control-plane family the engine still read and wrote as files moves onto the seat 7.64.0 laid down, under the same law as the families #3466 moved: the hold ledger is read and written through `readDoc("holds")` / `updateDoc("holds", …)`, a hold's custody bytes are the `hold` object `<captureName>`, a disposal moves that object to the `quarantine` object the row names (`holdQuarantineNameOf`, #3464), and a staged generation that retires into custody is a `hold` object too. Every capture is the write-once put every first-record writer asks (`putControlObjectOnce`) read back through the store and hashed against the capture; every "what stands here against this digest?" — custody and seat alike — is one reading (nothing / the captured bytes / anything else, an entry the store will not read counted as anything else, never as missing). No reader or writer of the hold family joins a directory name onto a control-plane path any more.
219
+ - **Before.** In 7.64.0 `delegation-settlement.ts` read and wrote `<the engine's control dir>/holds.json`, `hold/` and the hold seats in `quarantine/` itself, whatever store the backend carried: a replica over a backend carrying another store kept its holds beside itself, so a second replica neither listed them (`readInstructionHolds`) nor settled them (KL-3308-b). The custody write was its own `wx` + fsync + read-back (`writeCustodyVerified`), a retire into custody its own function (`retireStagingToCustody`, beside `retireStagingToObject`), the disposal move its own link-then-unlink with a rename fallback (`moveNoReplace`, KL-3464-a), and the seat's state its own `lstat` reading (`quarantineSeatState`). The reconciliation read the memory root's anchor once at its head and then made every plane act synchronously.
220
+ - **Now.** The engine hands the hold functions `this.governanceStore` (the backend's `governance`, else the File store over its control dir) — for a File backend, and for a backend without a store, the same `holds.json`, `hold/` and `quarantine/` and the same bytes as before. Because every step now awaits the store, the engine's anchor gate (`actRefused: (path, act) => this.storeActRefusedText(path, act, handle)`, the one predicate and call form every other plane act of the engine uses) is asked immediately before each act on the memory plane that follows an await: the intake's rename after the custody write (`"holding an instruction-form file"`; a refusal disposes the row `discarded`, the custody bytes go to the row's seat, the plane file stays for the caller's containment), the reconciliation's removal of a half-captured hold's plane file (`"removing a held file from the plane"`; a refusal is that arm's ordinary removal failure), the sweep's claim of a staged generation and its drop after a custody write (`"recovering a hold's staged copy"`), and every unlink of a staged copy after it retired (`"removing a hold's staged copy"`). A custody object already standing with the captured bytes is the capture, so a twin intake of the same bytes in the same millisecond (one row, one holdId) no longer disposes the other's hold, which `wx` refused. A disposal and the orphan adoption read what stands at the custody and seat objects just before the ledger's update and decide inside it on the fresh row (the update's callback runs synchronously and reads no object — KL-3308-c covers the window); the bytes move after it. Three disclosure lines name an object, not a path: a retire's coordinate is `hold object <name> in the memory control plane` (was `hold/<name> in …`), the foreign-seat refusal names the seat by its object name (was its absolute path), and a move the store refused says the bytes `stay at the custody seat (hold object <captureName> in the memory control plane)` and carries the store's fault code where the refusal has one, else `move refused` (was the custody file's absolute path and `move refused`).
221
+ - **Narrowing — three (open to veto).**
222
+ 1. On a filesystem **without hard links**, an instruction file is no longer held, and **no copy of it is kept**: the File store publishes an object by a hard link (since 7.64.0, #3465), so the custody write fails and the hold is refused (`hold capture verification failed …`); the file then takes the ordinary containment, whose quarantine copy is the same publication (#3466) and fails too, and the containment removes the file all the same — a failed capture never stopped a containment — so the session's bytes are gone (an `update` gets its committed version back) and the report says so (the rejection's `quarantine copy FAILED; file removal succeeded`, a `quarantineFailures` row and a `quarantine escalation` warning). 7.64.0 held the file (custody written with `open(wx)`) and released or quarantined it on the delegation's verdict. A disposal move the store refuses leaves the bytes at the custody seat, readable by `readHoldCustody`, retried and disclosed at every harvest; 7.64.0 fell back to a `rename` for the move (which could replace a seat taken in the instant after the look — KL-3464-a, retired). Every quarantine copy and pollution mark on such a control plane already met this with #3466. In this same release (the #3512 section) a File store refuses to open on such a file system (`memory.control_plane_links_unsupported`), so a File control plane no longer reaches this path; it remains the path of a containment whose copy fails for another reason (except a backend a host composes around the root-exported `fileGovernanceStore`, which neither holder probes — KL-3512-c, #3519).
223
+ 2. A half-captured hold whose custody name stands as **an entry the store will not read** (a directory, a dangling link) converges to `capture_lost` at the reconciliation. 7.64.0 already did so for a dangling link (its existence test follows the link and finds the name absent); for a directory it found the name standing and read it, so the reconciliation threw (`EISDIR`, `reconcileHolds` at `delegation-settlement.ts:1245` of 7.64.0, measured on the 7.64.0 dist) and the harvest was refused — an incident naming the error, the row left `capturing` — until a person removed the entry. The narrowing is for a directory only. The bytes it could not read were never trusted as the capture either way.
224
+ 3. The File store's `moveObject` over a target that already stands **as a link** (or as anything but a file of its own) is refused and the source kept: when both names stand, the move finishes by dropping the source only onto the same file under a second name (an interrupted move) or a second file holding the same bytes. 7.64.0's move read both names through their links, so a link at the target that reached the source read as the same file and the source — the only copy — was unlinked (nothing in core called the move before this change; a host that calls it directly meets the refusal). A hold whose quarantine seat is such a link keeps its custody bytes: the disposal lands its verdict, and the move it cannot make is disclosed on the stranded lane and retried at every harvest. 7.64.0's hold code read any link at the seat as foreign and refused the disposal.
225
+ - **Hard-breaking — one (HB-2, two faces), three sentences (open to veto).** *What changed:* `MemoryEngine.resolveHold(holdId, action, requestId)` returns `Promise<void>` and `MemoryEngine.readInstructionHolds()` returns `Promise<HoldRow[]>` (the ledger is a document of the governance store, whose verbs are asynchronous), and a refused valve call (`memory.hold_resolve_unattributed` / `_invalid` / `_unknown` / `_invalid_state`) rejects the Promise instead of throwing. *Who is affected:* a host that calls either without `await` — reads the rows as an array, relies on the verdict being written when the call returns, or catches the refusal with `try` around a synchronous call (none in the server's, the cli's, client-core's or the sdk's tree at origin/main as read before this change; test's `repro/c3463-20261102` drives `resolveHold`). *Compensation:* `await` both, and catch the refusal on the Promise.
226
+ - **Consumers.** @server @dgx: HB-2 above; a store you carry receives the `holds` document and `hold` / `quarantine` objects from engines whose backend carries it (the document and kinds 7.64.0 defined; no new kind). A deployment that switches a running backend to a store carrying `governance` adopts each replica's holds first: `adoptReplicaControlPlane(controlDir, store)` copies the `holds` document and the `hold` and `quarantine` objects (pinned: a replica's hold reads `[]` over the carrier before the adoption and `held` after it); the replica's files stay where they are (the source removal rides #3484, S2b). @test — black box: two engines over one shared store, each with its own control dir: a hold captured through one is listed, resolved, released and disposed through the other, and no `holds.json` or `hold/` appears beside either; control: a File backend keeps `<control dir>/holds.json` and `hold/` as before; HB-2's two faces answer Promises.
227
+ - **Known limits.** KL-3485-a — with several replicas sharing the hold ledger, another replica's reconciliation can read a row in the instant between an intake's row and its custody write, find the custody absent and the file not on its own memory plane, and mark the row `capture_lost`; the intake then writes the custody and still answers held, so the row is disposed while its bytes stay at the custody seat (orphaned custody bytes). It needs a replica identity this change does not add; no such deployment in tree. The release review reproduced the race with a delayed object write; the fix is #3520 (7.66.0, capture ownership / a lease, reviewed with #3359). KL-3465-c now covers only the capture opt-out readers and the adoption's source removal (#3484).
228
+ - **Retired.** KL-3466-a (the hold family on the File control-plane directory until this change), KL-3308-b (a held instruction seen and settled only by the replica that captured it — row and bytes now ride the store together, the ask #3311 recorded, folded into C-R1119 S1) and KL-3464-a (the rename fallback's replacement window — the fallback is gone, narrowing 1).
229
+ - **Rules.** Five fewer: the second write-once-and-verify law (`writeCustodyVerified`), the second retire-into-the-control-plane function (`retireStagingToCustody`, its three hold callers now on `retireStagingToObject`), the second no-replace move (`moveNoReplace`, the store's `moveObject` is the one), the second "what stands at this seat" reading (`quarantineSeatState`'s `lstat` judgment, beside the reconciliation's own read of the custody file), and the disposal's own deletion of a custody object it judged a second copy (whether two names are two copies is the store's move alone, narrowing 3). Added: none — the two helpers (`heldBytesAt`, `holdCustodyVerified`) ask the store's laws, the act gate is the engine's existing predicate in its existing call form, asked where the acts now follow an await, and the store's move keeps its one "both names stand" rule, reading the target without following it.
230
+ - **Claude Code 2.1.316.** No divergence of its own: the reference has no instruction-hold ledger or governance control plane (D-3407-a covers the seat).
231
+ - **Pins.** `test/backlog3485-holds-two-tree.test.ts` imports only names both trees export: on 7.64.0's stage head its eight two-replica rows are red (the hold lands beside the replica that captured it, the faces answer synchronously), here green; its two File-backend controls are green on both. `test/backlog3485-holds-on-the-carrier.test.ts` — the custody write is the write-once put (a custody object standing with the captured bytes opens the hold; other bytes, a damaged slot, a directory at the name refuse it and leave the plane file; an entry the store will not read at the seat refuses the disposal with no seat recorded, and at the custody name of a half-captured hold converges `capture_lost` without throwing) · the gate at each plane act (the intake asks it after the custody write and a refusal disposes `discarded` with the bytes at the seat; the reconciliation's removal, its sweep's claim, its drop after a custody write and a retire's unlink each ask it and a refusal leaves the file where it is; an engine whose memory root is re-pointed while the custody write is in flight never moves the file the re-pointed root reaches) · no verb needs a directory (over a carrier that keeps its objects in memory a hold opens, disposes to its row-derived seat and reads back; an older disposer's orphan is adopted by digest; a ledger the carrier cannot read rejects the read) · a link at the target is never a second copy (the File store's move refuses a target that is a link back to the source or to another file holding the same bytes and keeps the source; a second file of its own and the same file under a second name each finish the move; a hold whose quarantine seat links back to its custody keeps the bytes, lands its verdict and is disclosed on the stranded lane). Re-pinned to the store-shaped, awaited signatures: `backlog1103-memory-root-anchor` (②a, the primitive list), `backlog1105-hardlink-second-name`, `backlog1841-frontmatter-fence`, `backlog3308-governance-doc-seat` (P9: the ledger now moves with its custody — the File control dir holds neither, the store's `holds` document and `hold` object do), `backlog3465-control-plane-carrier` (C11: a replica's hold is read only after the adoption), `backlog3464-quarantine-name-deterministic` (T3d: without hard links the move is refused and the bytes stay at custody, disclosed, a later move finishing it; T5b's stranded line names the seat object), `backlog778-cross-filesystem-control-plane` (the retire is `retireStagingToObject`), `design336-backfill-hardening`, `design336-slice2-settlement-hold`, `memory-layout-migration`.
232
+
233
+ ### A head word right behind a JSON escape starts where it starts behind the character the escape stands for — `\n`, `\t`, `\r`, `\b`, `\f` and `\uXXXX` are word starts on the wide side, for every row that starts a head word (#3482; behavior change: egress withholds a token, a scheme credential or an assignment right behind such an escape, and leaves the azure placeholder behind one to its row, and the keyword row reads every spelling of the azure field the azure row does not read; narrowing: two, security, open to veto; widening: one, open to veto; hard-breaking: three sentences below, open to veto; closed sets: none; exports: none) (@server @cli @ss @client-core @test)
234
+
235
+ - **Before.** The wide side's word start (`WORD_START`, `src/primitives/secret-vocabulary.ts`) read the character before a head word as written: after no letter or digit, or right after a quote in any spelling. In a JSON string an escaped control character is two characters, a backslash and a letter (`\n`, `\t`) or a hex digit (`\u000a`); the letter read as the tail of a word, so the head word behind it did not start: `redactSecrets('{"m":"line\nghp_<36 characters>"}')` returned the token in clear, while the same token behind a space was withheld (7.64.0 alike). The same held for `sk-` and every vendor head, `Bearer`, `token`, a keyword assignment (`\npassword=<value>`) and the fragment forms. The keyword row's check that leaves a value row's field to its row (the azure row's `Account` + `Key`) spelled its own copy of the word start, as written, so `\nAccountKey=<your-key>` was withheld by the keyword row where `AccountKey=<your-key>` behind a space is the azure row's and stays clean.
236
+ - **Now.** The word start holds one more spelling: right after an escape whose last character is a letter or digit (`ESCAPE_TAIL`: a backslash and `b` `f` `n` `r` `t`, or `\u` and four hex digits of either case; the percent escape `%HH` is the same spelling's third form, #3487 below), whatever character the escape stands for. `\"`, `\\` and `\/` end in no letter or digit and were starts already; two layers of escaping (`\\n`) read as one. The front-word check reads the same word start. Every fixture of the table (188 texts) behind each of `\n` `\t` `\r` `\b` `\f` `\u000a` `\u00AB` `\u00e9` `\\n` renders as it does behind a space. The strict grade (the durable memory write door) is unchanged: it anchors with `\b`.
237
+ - **Hard-breaking — three sentences (open to veto, @server @cli @ss).** *What changed:* the engine's egress pass (`egressText`, both tiers — `redactSecrets`, `redactHostLeaks` and every face that writes through it) and the wide and fragment grades of `scanSecrets` / `renderSecrets` withhold a credential right behind a JSON escape whose last character is a letter or digit, and an azure account key in a spelling the azure row does not read (`AccountKey =`, `AccountKey: `, `AccountKEY=`, a quoted value), where they let it through. *Who is affected:* a host that pins "egress equals input" for a JSON-encoded text holding such a form; the server's own egress seat already withholds these forms (its escaped-separator table), so the output that changes is that of a host embedding the engine's pass. *Compensation / migration:* re-pin the assertion to the `[redacted]` form; nothing else moves (no verb, frame, code, option or type changed).
238
+ - **Narrowing (open to veto, @server @cli @ss).** Two. (1) The forms above. Over-strip, stated: an escape of a letter or digit right before a head word (`\u0041sk-<value>`) and a literal backslash-`n` in a Windows path (`C:\nsk-dev-environment-config`) read as starts too. (2) The keyword row left the azure field (`Account` + `Key`) to the azure row whatever followed the keyword, while the azure row reads only `AccountKey=` and a body of its class: `AccountKey =<key>`, `AccountKey: <key>`, `AccountKEY=<key>`, `AccountKey="<key>"`, `AccountKey= <key>`, `AccountKey=%2B<key>` were read by neither row and printed behind a space (7.64.0 alike), and — once the escapes are word starts — behind an escape too. The keyword row now leaves the field to its row only where it is spelled as that row reads it (`VALUE_ROW_FIELDS` carries the row's separator and the class of a value's first character, with the placeholder's `<`), and reads every other spelling itself. Over-strip, stated: a placeholder written in a spelling the row does not read (`AccountKey =<your-key>`) is withheld, as it was behind an escape in 7.64.0. Measured: of 100 forms (ten spellings × two values × five left neighbours) none prints the key on this tree where 7.64.0 withheld it; `Accountkey=` (lower-case `k`) prints on both trees and is not this check (#3497).
239
+ - **Widening (open to veto, @server @cli @ss).** The azure placeholder `AccountKey=<your-key>` right behind an escape or a spelled quote (`\n`, `\u0022`, `%22`, `\x22`) is left to the azure row and printed, as behind a space; the keyword row withheld it. A key of 40 characters or more is withheld by the azure row as before. No credential character is among the widened form.
240
+ - **Rules.** The word start gains one spelling (+1); the front-word check's own copy of the word start goes (−1); the front-word check reads the field as its row spells it (the table entry gains two columns, the check stays one), and the azure field's name, separator and body class are one constant the row and the table entry both read (the row's expressions byte-identical). Net 0.
241
+ - **Consumers.** @server: your escaped-separator table's JSON row is this spelling; nothing to change. @cli @ss @client-core: re-pin a test that asserts such a form survives egress (@client-core: where you consume the scan from `@sema-agent/primitives`). @test: the forms per row are in the pins.
242
+ - **Pins.** `test/backlog3482-escape-tail-left-edge.test.ts` — E1 the three forms and the space control · E2 the matcher's span behind an escape · E3 every fixture behind every letter-tail escape renders as behind a space · E4 `\"` `\\` `\/` starts as before · E5 an escaped letter starts, a written one does not · E6 the azure placeholder and key behind an escape · E7 the fragment grade · E8 a JSON text stays JSON · E9 the azure field left to its row only in the row's spelling, behind a space and behind each escape. `test/backlog954-credential-vocabulary-parity.test.ts` (#954, the ledger that pins the regex text) re-spells the head start and the keyword row's front-word check.
243
+
244
+ ### A URL username whose vendor head is percent-encoded is read one decode layer down, and a percent escape is a word start as a JSON escape is — `https://%73k-<value>:pw@host/` withholds the userinfo whole; `?q=%20sk-<value>` withholds the key (#3487; behavior change: egress withholds the whole userinfo of a URL whose kept username, decoded once, reads as a credential, and a credential right behind a `%HH` escape; narrowing: two, security, open to veto; widening: one, open to veto; rendered form: one, no credential character printed by either form; hard-breaking: three sentences below, open to veto; closed sets: none; exports: none) (@server @cli @ss @client-core @test)
245
+
246
+ - **Before.** Under `urlUserinfo: "keep-username"` (the engine's egress policy) the username was kept as written; only the password, a bare username of 20 characters or more, or a userinfo holding a second `@` was withheld. A URL userinfo is percent-encoded by its grammar (RFC 3986 §3.2.1), so a vendor head can be spelled with its own first byte encoded: `redactSecrets("https://%73k-<value>:pw@host/")` returned `https://%73k-<value>:[redacted-credentials]@host/` — `sk-<value>` for any reader that decodes the URL (7.64.0 alike; `%67hp_`, `%6Epm_` / `%6epm_` the same). No left boundary reaches this form: the encoded byte is the head's own. Separately, the word start (`WORD_START`, `src/primitives/secret-vocabulary.ts`) read a percent escape's last hex digit as a word's tail: `?q=%20sk-<value>` and `a%2Fsk-<value>` printed the key, where `?q= sk-<value>` withheld it.
247
+ - **Now.** Two parts, each one rule. (1) The word start's escape spelling (`ESCAPE_TAIL`) holds the percent escape: `%` and two hex digits of either case, whatever byte it stands for. Every fixture of the table (188 texts) behind each of `%20` `%0A` `%2f` renders as it does behind a space; a `%` that starts no escape (`%G1`, `%2` at a word) is no word start. (2) The URL userinfo pass (`userinfoWithheld`, `src/primitives/secret-scan.ts`) reads the username it would keep once more, one tolerant percent-decode layer down — the same layer the `percent-layers` reading decodes (`percentDecodedOnce`, `src/primitives/secret-readings.ts`, no second decoder); a username holding no `%`, or one the layer leaves unchanged, is not re-read. When any wide form reads the decoded text, the userinfo is withheld whole, as one holding a second `@` is. Only the username is read: the password is withheld already. Controls: `%53k-` decodes to `Sk-`, which no row reads, and is kept as a written `Sk-` is; an encoded e-mail (`john%40example.com`) is kept. Depth: the pass decodes one layer of each text it scans. The engine's faces read raw + format-free and so reach one layer of encoding; a caller reading `percent-layers` at depth N scans each derived text the same way and so reaches N + 1 encodings of a username, and no more.
248
+ - **Rendered form (not a narrowing; @server @cli @ss).** Where the decoded username reads as a credential, one marker for the whole userinfo replaces the two (username, password) that a percent reading's hit inside the username used to render: `https://[hidden]@host/` where `https://[hidden]:[hidden]@host/` was printed. Neither form prints a credential character.
249
+ - **Hard-breaking — three sentences (open to veto, @server @cli @ss).** *What changed:* the engine's egress pass (`egressText`, both tiers — `redactSecrets`, `redactHostLeaks` and every face that writes through it) and the wide grade of `scanSecrets` / `renderSecrets` / `isSecretShaped` withhold the whole userinfo of a URL whose username, decoded once, reads as a credential, and a credential right behind a `%HH` escape, where they printed them; under a percent reading such a userinfo renders as one marker where it rendered as two. *Who is affected:* a host that pins "egress equals input" for such a URL or a percent-encoded query value, or pins the two-marker userinfo form under a percent reading; the server's egress seat already withholds these forms (its union view), so the output that changes is that of a host embedding the engine's pass and of a direct `renderSecrets` caller. *Compensation / migration:* re-pin the assertion to the withheld form; nothing else moves (no verb, frame, code, option or type changed).
250
+ - **Narrowing (open to veto, @server @cli @ss).** Two, the forms above. Over-strip, stated: an escape of a letter or digit right before a head word (`a%41sk-<value>`) and a head after an encoded separator in a path segment (`a%2Fsk-dev-environment-config`) read as starts; a username whose decoded text any wide form reads is withheld whole, a decoded keyword assignment (`password%3D<value>`) included.
251
+ - **Widening (open to veto, @server @cli @ss).** The azure placeholder `AccountKey=<your-key>` right behind a percent escape (`%0A`, `%20`, `%2f`) is left to the azure row and printed, as behind a space; the keyword row withheld it (both trees measured). A key of 40 characters or more is withheld by the azure row as before. No credential character is among the widened form.
252
+ - **Known limit.** KNOWN-LIMITS KL-3487-a: the percent reading decodes one layer per text; a vendor head encoded twice or more is out of the engine faces' reach, and outside a URL userinfo the engine faces decode no layer — the host's egress seat covers both.
253
+ - **Rules.** The word start's escape spelling gains one form (+1); the userinfo pass reads the kept username one layer down (+1), on the decode layer the readings already have. Net +2, no per-row case.
254
+ - **Consumers.** @server: your union view (S-103 ①) withholds these forms already and is the cover KL-3487-a names — please name it in your arrival post; nothing to change. @cli @ss @client-core: re-pin a test that asserts such a URL or query survives egress, or the two-marker userinfo form (@client-core: where you consume the scan from `@sema-agent/primitives`). @test: the forms per row are in the pins.
255
+ - **Pins.** `test/backlog3487-userinfo-percent-decoded.test.ts` — P1 the encoded heads, renderer and matcher · P2 the plain head, `%53k-`, an encoded e-mail, an undecodable `%` · P3 one layer per text and the depth rule (depth 1 reaches `%2573k-`, not `%252573k-`) · P4 only the kept username is decoded · P5 `whole` as before · P6 every fixture behind a percent escape renders as behind a space · P7 a `%` that starts no escape · P8 a rendered text renders to itself. `test/backlog3340-readings.test.ts` R5 (a percent escape's tail starts a head for the raw text too; a form only the boundary reading reads, `x %73k-<value>`) and R9a (`%73k-` and `%2573k-` under three layers render one marker). `test/backlog954-credential-vocabulary-parity.test.ts` re-spells the head start.
256
+
257
+ ### The pollution markers, the import completion receipts and the quarantine captures outside the hold ledger are read and written through the governance store's control objects — the engine and the File backend no longer derive a control-plane path for them, the delegation settlement seat carries no directory, and `MemoryEngine.sessionPollution` answers a Promise (#3466, C-R1119 S2a and addenda 4 and 5; behavior change: one — for a backend that carries a governance store which is not the File store over the engine's control plane, these records now live in that store; behavior narrowing — four, open to veto; hard-breaking: two, three sentences each below, open to veto — HB-2 on one face, HB-3 second half; closed sets: none; exports: none by name; members: `MemoryEngine.sessionPollution` returns `Promise<SessionPollutionRecord | undefined>`, `DelegationSettlementSeat` −`controlDir` (reached through `ToolExecuteContext.delegationSettlement`); wire: none) (@server @dgx @test)
258
+
259
+ - **Rule.** The three record families move onto the seat 7.64.0 laid down: a pollution marker is the `pollution` object `<session>.json` (an occupant's own slot `<session>@<incarnation>.json`), a bundle import's completion receipt is the `import-receipt` object `<bundleHash>.json`, and a suspect file's copy kept by a containment — the harvest rungs, the inbound gate, the residue capture at mount, a staged copy dropped at mount — is a `quarantine` object `<now>-<basename>` (then `.1` … on a name that stands). Each is read and written through `putObject` / `getObject` / `listObjects` / `deleteObject` and their law (written once, a standing name never replaced, a name that stands but cannot be read never read as missing, an enumeration that fails never read as empty); no reader or writer of these families joins a directory name onto a control-plane path any more.
260
+ - **Before.** In 7.64.0 the engine read and wrote `<its control dir>/session-pollution/`, `import-receipts/` and `quarantine/` itself, whatever store its backend carried, and the File backend did the same under its own root; the pollution read, the import latch release and the two quarantine writers (`quarantineAndTombstone` in the engine's rungs, a twin in the backend's gate) each spelled the law for itself. A replica whose backend carried another store wrote its markers beside itself, so a second replica over the same store did not see them. The delegation settlement seat handed a tool the control-plane directory beside the store (`{ governance, sessionId, controlDir }`), and the seat's pollution check read the marker files there. The committed-shadow reads had a second, file arm (`<control dir>/shadow/<id>.md`) beside the backend's own `readCommittedShadow`.
261
+ - **Now.** The engine reads its markers through `this.governanceStore` (the backend's `governance`, else the File store over its control dir) and the File backend through `this.governance` (the File store over `controlPlaneRoot`) — for a File backend, and for a backend without a store, the same directories and the same bytes as before. A capture is one function over the store's verbs (`captureIntoQuarantine`, with a synchronous twin `captureIntoFileQuarantine` for the backend's synchronous paths, minting the same names in the same order), and the removal that follows is one function (`clearContainedPath`), shared by the engine's rungs and the backend's gate. A staged copy dropped at mount is retired into a `quarantine` object (written, read back and compared, the anchor read, then the unlink). The import latch release reads the receipt object; the re-import short-circuit reads it the same way. The erasure reads the quarantine objects, counts one it cannot read as unattributed and goes on. The evidence chain's torn-tail fragment is a `quarantine` object too (written once, suffixed on a standing name, where it was overwritten), and the degradation marker's `fragment` field names that object where it held the fragment's absolute path (nothing in core reads the field; it is for the operator's rebuild). The settlement seat is `{ governance, sessionId }`. The committed-shadow reads ask `readCommittedShadow` only. A pollution mark's durable write is held with its retroactive sweep from before its first await, so an exclusion read that follows a mark nobody awaited still waits for both; the `memory.session_polluted` notice follows the write's outcome, so it can land after the invoking tool's result. A writer whose record is first-record-wins — the pollution mint, the strict import, a capture, a staged copy's retirement, the torn-tail fragment — asks one function, `putControlObjectOnce` (its synchronous twin `putFileControlObjectOnce`): a put the store refuses over a name that already holds a readable record answers `existed` (the standing record wins, as before), and a refusal over a name it cannot read back is the put's refusal. The File backend's readers that must see damage rather than be spared it — the export's pollution roster and its quarantine enumeration, the erasure's count, the governance fingerprint — read every name standing in the kind's directory (`standingFileControlObjectNames`), not the store's objects-only listing: a marker or copy that stands as no readable object is carried as the fail-closed record or counted unattributed, never dropped.
262
+ - **Narrowing — four (open to veto).**
263
+ 1. A store that cannot answer whether a pollution slot stands reads the session as **polluted**. 7.64.0 took any refusal of the probe (`lstat`) as no marker — a `session-pollution` that is a file, a directory that cannot be searched — and read the session clean. A marker that stands but cannot be read was polluted before and still is.
264
+ 2. A containment that finds the suspect path **rewritten after it read it** (the copy is a store write now, so the window is an await wide) leaves the newer bytes in place and reports the rung incomplete (`removed: false`, "the file was rewritten after it was read"), and every restore that follows — the withheld file's committed copy, the rejected file's committed copy, the boundary sweep's index baseline — keeps its hands off them (`restoreWithheld` names the path); 7.64.0 removed or overwrote whatever stood at the path. The copy of the bytes that were read is kept as before. The derived index is the one file an overwrite follows anyway (the gate's clear, then the rebuild; a polluted session's restore): there the newer bytes are kept as a copy too before the clear or the restore (at most three copies, each re-read never following a link; an index still being rewritten after that is cleared or restored all the same — for the index the containment wins over the copy, as a capture that failed never stopped it — and the report says its last version was not captured).
265
+ 3. A File control object is created **owner-only (0o600)**. A pollution marker or a quarantine copy written by 7.64.0 took the process umask (0o644 under the usual 022); a tool running as another OS user that read them no longer can for new objects.
266
+ 4. A pollution slot that **stands as no readable object** — a dangling link, a directory, an entry the store cannot read to tell — is no longer answered as a marker that already stood: the mark answers that it could not be persisted (the `memory.pollution_mark_failed` incident; the delegation settlement's replay of that session retries at its next reconciliation instead of sweeping). 7.64.0's exclusive create answered `existed` over any entry at the name; the store's put refuses an entry it cannot read to tell, and a store that cannot answer at all refuses the same way, so `existed` there would leave a session clean once that store recovered. The session reads polluted for every occupant either way. The capture opt-out records keep 7.64.0's answer until they move onto the store (#3484, the first slot of the 7.66.0 window; KL-3466-b). The same law reaches a copy: a quarantine capture whose name stands as no readable object fails (the containment still runs, as after any failed capture), where 7.64.0 passed over the name; the names carry the clock's millisecond, so this needs an entry planted at that exact name.
267
+ - **Hard-breaking — two, three sentences each (open to veto).**
268
+ - (HB-2, one face) *What changed:* `MemoryEngine.sessionPollution(sessionId)` returns `Promise<SessionPollutionRecord | undefined>` (it reads the store, whose verbs are asynchronous). *Who is affected:* a host that calls it and reads the answer without `await` (none in the server's, the cli's, client-core's or the sdk's tree at origin/main). *Compensation:* `await` it. The two other synchronous control-plane faces the design names, `resolveHold` and `readInstructionHolds`, become Promises with the hold ledger's move in this same release (#3485, the section above).
269
+ - (HB-3, second half) *What changed:* the delegation settlement seat (`ToolExecuteContext.delegationSettlement()` → `DelegationSettlementSeat`) loses `controlDir`; the pollution and the hold ledger it settles against are read through `governance`. *Who is affected:* a tool that read `controlDir` off the seat (none in the four trees at origin/main). *Compensation:* read and write through `governance`.
270
+ - **Consumers.** @server: HB-2 and HB-3 above, zero hits at origin/main; your S-3068 store receives `pollution`, `import-receipt` and `quarantine` objects from engines whose backend carries it (the kinds 7.64.0 defined; no new kind). @dgx: the same if you carry a store. @test — black box: two engines over one shared store, each with its own control dir: a session marked through one is polluted on the other, and no `session-pollution/` appears beside either engine; control: a File backend reads and writes `<control dir>/session-pollution/` and `quarantine/` as before.
271
+ - **Known limits.** KL-3466-a (the hold family still on the File control-plane directory) is retired in this same release by #3485 (the section above). KL-3466-b — until #3484 (S2b) the capture opt-out mint, still a control-plane file, answers `existed` over a slot that stands as a dangling link, where the pollution mint now answers `unpersisted` (narrowing 4): the two twin records read one damaged slot two ways, and the transitional reading retires with #3484 (the first slot of the 7.66.0 window); this release ships with the transitional double reading, a written exception (C-R1119 addendum 6, open to veto). KL-3465-c now covers only the capture opt-out readers and the adoption's source removal (#3484, S2b); its hold readers moved with #3485. KL-3466-d — narrowing 2 does not reach the File backend's inbound gate yet: after the containment leaves bytes rewritten after its read, the gate still writes the committed shadow over them (the bytes nobody kept are lost, as in 7.64.0, so this is no regression), and its `quarantine_failed` escalation says they were left in place, which is not true on that path; the path is synchronous, so only a writer in another process landing between the scan's read and the clear reaches it. The reading that closes it — the shadow goes back only over what the containment left there, by the atomic rename that replaces a link at the path — is #3509.
272
+ - **Rules.** Retired: the engine's and the backend's own spellings of the three families' paths, the two quarantine writers (one capture, one removal), the shadow reads' file arm (three sites), the seat's directory, the two restores that wrote over whatever stood (the scan-finding rung, the opt-out sweep's index), the pollution owner reader's arm that read a refusal over a gone target as an unstamped owner. Added: the read-back check before a containment removes a path, the receipt object's read through the store at both readers, the index's keep-the-window's-bytes step before its two overwrites, the one put-once reading every first-record writer asks (`putControlObjectOnce` and its synchronous twin).
273
+ - **Claude Code 2.1.316.** No divergence of its own: the reference has no governance control plane (D-3407-a covers the seat).
274
+ - **Pins.** `test/backlog3466-carrier-s2a.test.ts` — P1–P8 the pollution objects (an unreadable object and a store that cannot answer read polluted; an enumeration fault refuses the roster; the mint written once, a refused write `unpersisted`; occupant slots; a slot that stands as no readable object answers `unpersisted` and still reads polluted for every occupant, and a record whose bytes cannot be read never vouches (narrowing 4); the strict import; the engine's public face over a store that cannot answer) · R1–R3 the receipt object (a completed import leaves it and a re-import answers the recorded report; a malformed one refuses the import by name; the latch release refuses a read fault and an absence) · Q1–Q9 the captures (names and their failures, the synchronous twin mints the same names, the last name unique in the process, the removal, narrowing 2 with the restore, narrowing 3, the erasure counts an entry that is no readable object and goes on, the export snapshot carries an unreadable marker as the fail-closed record, narrowing 4's capture half: a name standing as no object fails the capture and one holding other bytes is passed over, both twins) · S1–S3 a staged copy retired into an object (settled; the anchor read refuses after the store's awaits; a standing name or a different read-back leaves the copy) · F1–F4 the faces (HB-2, HB-3 type level, the File fault code, a source pin that the moved families' paths are gone from the engine and the backend) · K1–K6 the awaited copy (a writer that replaces the path while the copy is a store write: the index gate keeps both versions before it clears, a polluted session's index restore keeps both before it restores, a rejected file's committed copy is not written over the newer bytes and `restoreWithheld` names it; an index rewritten at every copy is still cleared and still restored, with three versions kept and the last named as not captured; a link swapped in at the index path during the copy is not followed). `test/backlog3466-carrier-s2a-two-tree.test.ts` imports only names both trees export: on 7.64.0 its two-replica rows are red (the marker and the capture land beside the replica), here green; its File-backend controls are green on both. Re-pinned to the store-shaped signatures: `178v2c-import-latch` (a squatted marker directory reads fail-closed, narrowing 1), `178v2c-import-roundtrip`, `backlog3465-control-plane-carrier` (C20, #3478, still green: the marker is born in the carrier, and a marker an older engine left beside itself decides only after the adoption), `a005-memory-engine-nofollow` (no bare `writeFileSync` is left in the engine; the scan-finding restore is counted with the containment module's), `backlog783-containment-no-replace` (four restore sites go through the one function), `prepare-memory-engine-session-transcript` (the notice follows the marker write: the pin waits on an exclusion read), `backlog514-session-incarnation` (a dangling id-level slot: still read fail-closed by every reader, the mark now `unpersisted`, narrowing 4), `design336-origin-carriage`, `design336-slice2-settlement-hold`, `memory-engine-pollution`, `memory-pollution-loudness`, `refactor-r5-quarantine-collision`, `backlog1103-memory-root-anchor` (the new primitive and gate row), and the `sessionPollution` substitutions in `backlog2424-forget-is-delete`, `design336-backfill-hardening`.
275
+ - **After the merge (#3506, #3507).** `memory-engine-s20` C-F9's TOCTOU cell pinned 7.64.0's removal of whatever stood at the path: its fixture rewrites the file inside the capture window, so under narrowing 2 the newer bytes stay where they are and the rung reports itself not contained. Its custody half is unchanged (the copy is the scanned bytes, never the swapped ones); its removal half is re-pinned to narrowing 2 (the path is not in `movedToQuarantine`, one `quarantineFailures` row says "rewritten after it was read", the newer bytes are untouched, nothing reached the backend), with two controls: the same world without the swap moves the file and keeps one copy, and a File backend opened with no control dir keeps the copy in its own `controlPlaneRoot`, which is the engine's default control dir — one place. No source changed for it. The tool texts that now splice `(await pollutionSentence())` read to `gate:error-surface` as one more uncapped arm in `src/core/memory-engine/` (the not-found card's is the one minting site): the gate reads an `await` through as it reads a parenthesis — the awaited value is bounded exactly when what it awaits is — pinned both ways in `test/error-surface-gate.test.ts` ③; no bucket was raised.
276
+
277
+ ### An erasure deletes the erased entry's quarantine copies from the governance store the backend carries, through the store's own verbs, and says what it did — `quarantineCopy` answers removed / remaining / unreadable on both lanes (#3499; behavior change: the degraded lane deletes the copies and its `quarantineCopy` and `quarantineUnattributed` answer counts where they answered `unverified`; narrowing: one, below, open to veto; widening: none; hard-breaking: none; closed sets: none; exports: none; members: +1 optional `unreadable` on the counted arm of `ErasureCarrierAnswer`; wire: `residuals.carriers.quarantineCopy` gains `unreadable`, and on the degraded lane both classes change from `{ unverified: true }` to counts) (@server @dgx @test)
278
+
279
+ - **Before.** After #3466 the quarantine captures ride the governance store the backend carries (`MemoryBackend.governance`), but the erasure still read only the File directory `<control dir>/quarantine/`: the File face (`FileMemoryEngineBackend.eraseWithEvidence`) through its own directory, and the degraded lane (`eraseMemoryEntries({ allowUnevidenced: true })` over a backend with no evidence face — every database-shaped store) not at all: it answered `quarantineCopy: { unverified: true }` and left every copy of the erased entry in the store. A copy the harvest gate kept of a refused edit (the entry's body with the secret in it) outlived the entry's erasure on every carrier but the File backend's own. On the File face, an object it could not read (a directory or a dangling link at an object's name) was counted in `quarantineUnattributed`, which does not decide the status, so a request over a damaged copy could answer `complete`.
280
+ - **Now.** One law, `eraseQuarantineCopies(objects, ids)` (`src/core/memory-engine/layout.ts`), for both lanes and every carrier: list the store's `quarantine` objects (`listObjects`), read each (`getObject`), and delete (`deleteObject`) the ones whose bytes name an erased id in their frontmatter. Per object: the delete answers `true` ⇒ `removed`; `false` (already gone) ⇒ not counted; it throws or answers anything but a boolean ⇒ `remaining`; the read throws or answers something that is not bytes ⇒ `remaining` and `unreadable`; the read answers the object absent (gone since the listing) ⇒ not counted; bytes that name no id ⇒ `quarantineUnattributed` (left); another id ⇒ untouched. A listing that fails or is not a list of names (a hole in it included): the File face refuses the attestation (`ControlPlaneCorruptError`; the replay converges, as before); the degraded lane, which never throws once its deletes are committed, answers both classes `unverified` and deletes no copy. The File carrier's damage stays visible through one standing view, `standingControlObjectsOf(store)` (`consolidation.ts`): over a File store it lists every name standing in the kind's directory (`standingFileControlObjectNames`), over any other store the store's own listing; the pollution roster reads the same view (its hand-built twin is gone). The two-store receipt merge (`mergeErasureAttestations`) adds `unreadable` when both stores say it.
281
+ - **Narrowing (open to veto, @server @dgx).** A damaged entry in the File backend's quarantine (a directory, a dangling link at an object's name) was counted unattributed and the request could answer `complete`; it is now `remaining` and `unreadable`, and the request answers `partial` until the entry is gone. A copy that was never read was never deleted, so the class is not claimed clean over it — the attestation's rule that `unverified` never reads as clean, for a class that is counted.
282
+ - **Consumers.** @server: the degraded lane is the one your database legs run. Read `residuals.carriers.quarantineCopy` as counts (`removed`, `remaining`, `unreadable` — a share of `remaining`, never added to it) and `quarantineUnattributed` as `{ count }`; both stay `{ unverified: true }` when your store's quarantine listing fails. Code that assumed the degraded lane answers these two classes `unverified` changes; the status law does not (the degraded lane still never answers `complete`). @dgx: the same if you carry a governance store. @test: black-box faces — erase an entry whose edit the harvest gate refused (its copy leaves the carrier with it); a quarantine row the store cannot decode (`remaining: 1, unreadable: 1`); a row it will not delete (`remaining: 1, unreadable: 0`).
283
+ - **Known limits.** The sweep reads the carrier's `quarantine` kind and nothing else: a disposed hold, which #3485 (above) makes a `quarantine` object of the carrier, is read like any other copy (its bytes decide), while a hold still pending is a `hold` object and is not an erasure's to delete. KL-3466-c — over a non-File store (a File store wrapped in another object included), whether a damaged row is listed (and so counted) is that store's own listing law. The sweep is one listing at one moment: a copy captured after it is swept by the request's replay, and the store's verbs delete by name only, so a name deleted and reused by another writer between the sweep's read and its delete is not told apart (no conditional delete in the seat's contract).
284
+ - **Rules.** Retired: the File face's own scan of its quarantine directory (one law for both lanes now), the pollution roster's hand-built standing view, and the degraded lane's `unverified` arm for the quarantine class. Added: the optional `unreadable` sub-count. The listing-failure answer stays one per lane contract (the File face refuses, the degraded lane says `unverified`).
285
+ - **Claude Code 2.1.316.** No divergence: the reference has no erasure attestation and no governance control plane.
286
+ - **Pins.** `test/backlog3499-carrier-quarantine-erasure-two-tree.test.ts` (two-tree: red on the stage tree before the fix, green here) — the degraded lane deletes the carrier's copy and counts it · a copy the harvest gate kept of a refused edit leaves with its entry · a copy one replica's harvest kept is erased by another replica's request · only the erased id's copies go (another entry's copy, a fragment, the pollution and import-receipt objects stay) · an object the store cannot read is remaining and unreadable · one it will not delete is remaining, not unreadable · a delete answered with neither yes nor no is remaining · a directory and a dangling link in a File carrier are unreadable · the File face answers the three counts · the File face's damaged entry keeps the request partial (the narrowing); controls, green on both trees — a failing listing, a listing with a non-name and a sparse listing leave the class unverified and delete nothing, a File fragment is unattributed and the request completes. Changed pins: `test/backlog3466-carrier-s2a.test.ts` Q7 (the narrowing), `test/backlog1917-erasure-attestation-v2.test.ts` (the clean table, the quarantine row, the degraded lane's two classes), `test/design178-v2b-erasure-evidence.test.ts` B-4; `test/backlog3172-3175-memory-deployment-judge.test.ts` gains the merge cell.
287
+
288
+ ### The file rule store's census takes the owners the host can name — `listBucketOwners({ knownOwners })` reconciles them by the engine's one digest, and `unnamedBuckets` counts only the buckets neither side can name (#3494; behavior change: none for a call without an argument; hard-breaking: none; closed sets: none; exports: none — an optional parameter on an existing method, no root name) (@server @test)
289
+
290
+ - **Before.** `FileDurableRulePartitionProvider.listBucketOwners()` (7.64.0, #3286) named an owner only by what the directory records — the local-owner file and the principals an adoption marker names — and counted every other digest-named bucket in `unnamedBuckets`. A host whose File store has one more source of names (the owners its import records derive) read and visited those buckets, and the engine still counted them as nobody-can-name-them: `unnamedBuckets > 0` was a gap the operator did not have. The only way to close it from outside was to compute a bucket's file name — a second reading of the one digest.
291
+ - **Now.** `listBucketOwners(opts?: { knownOwners?: readonly string[] })`. The host hands over the principal names it can speak; the engine matches each by the same digest (`principalRuleFileName`) against the files present, lists the ones whose bucket is here in `owners` (after the directory's own names, in the order given), and `unnamedBuckets` is then the count of buckets neither the directory nor the host names. A name whose bucket is absent lists nothing and changes nothing; a name given twice, or one the marker already names, is one owner. Nothing is opened, nothing is written, no lock is taken. `opts` is received by the engine's receipt law: a plain object taking `knownOwners` and nothing else, the list read once off the engine's copy, each element judged by the one principal-name reading; a value that is not that — a bag that is not a plain object, a misspelled member, a `knownOwners` that is not a plain array (a Set, a typed array, an Array subclass or another realm's array is not taken — pass a plain array), an element that is not a principal name (a number, `null`, a hole, `""`, a blank string, a control character) — is refused `config.invalid_argument` before the directory is looked at, in a sentence that names the position and the kind and never the text. The digest function stays off the package root: a host reconciles through this call and does not compute a bucket's name.
292
+ - **Narrowing / widening.** None for a caller that passes no argument (the answer is the 7.64.0 answer). The method ignored a surplus argument before; an argument that is not the one option is now refused — no caller of 7.64.0 can have relied on it, since the argument did nothing.
293
+ - **Consumers.** @server (S-2935, the M36 File leg, [12906] ②): pass the owners your import records derive as `knownOwners`; then report `unnamedBuckets` as the buckets nobody names. @test: seed buckets for principals the directory does not record, call with and without the list, read `unnamedBuckets` fall by one per named bucket present.
294
+ - **Pins.** `test/backlog3494-known-bucket-owners.test.ts` — K1 a known owner present is listed and not counted, the directory's names first then the host's in the order given · K2 an absent bucket changes nothing · K3 one owner once (a repeat, a marker-named principal) · K4 absent / `undefined` / `{}` / `{ knownOwners: undefined }` / `[]` are the call with no argument · K5 twenty-two bad values refused `config.invalid_argument` with no name's text in a sentence · K6 the refusal comes before the directory is looked at · K7 names only (entries unchanged, no lock) · K8 the digest function is no root export · K9 elements read once off the engine's copy (a getter, a throwing getter, a Proxy; an Array subclass, another realm's array, a Set and a typed array are no list) · K10 the real adoption arc. `test/backlog3286-bucket-owners.test.ts` (L1–L9) is unchanged and green.
295
+
296
+ ### `DISCARDED_DELIVERY_PATHS` is on the package root — the four words of `delegation.delivery_discarded`'s `detail.path` as a value, and the `DiscardedDeliveryPath` type is derived from it (#3505; behavior change: none; hard-breaking: none; closed sets: +1 registry row, no word added or removed; exports: +1, `DISCARDED_DELIVERY_PATHS`) (@client-core @server @test)
297
+
298
+ - **Before.** `delegation.delivery_discarded` says in `detail.path` which seat a discarded delivery would have reached: `live`, `box`, `drain` and (7.65.0, #3479) `notice`. The set was a type (`DiscardedDeliveryPath`) in a module the package root does not export, so a host reading the notice against its closed set copied the four words by hand — and the next word the engine added would not reach its copy.
299
+ - **Now.** `export const DISCARDED_DELIVERY_PATHS = Object.freeze(["live", "box", "drain", "notice"] as const)` in `src/core/task-notification.ts`, exported from the root; the `DiscardedDeliveryPath` type is `(typeof DISCARDED_DELIVERY_PATHS)[number]`, so the type, the value and every mint site (a literal or the store's own choice among them) are one set checked by `tsc`. The set is a registry row in `docs/CLOSED-SETS.md` (`array:DISCARDED_DELIVERY_PATHS`, no disposition table), so the release manifest reads its words from source. The type itself stays off the root: a host derives it from the value.
300
+ - **Narrowing / widening.** None. No word was added or removed; no mint, no notice and no `detail` member changed.
301
+ - **Consumers.** @client-core: validate `detail.path` against `DISCARDED_DELIVERY_PATHS` instead of a hand-written list. @server @test: nothing changes in the running engine; the black-box face is the import (`SMOKE_CHECKED_EXPORTS` proves the name reachable from a stranger install).
302
+ - **Pins.** `test/backlog3505-discarded-delivery-paths.test.ts` — P1 the value is exactly the four words, frozen, and the root export is that value · P2 the real mints (the store's live / box / drain / notice discards) say every word of the set and nothing outside it · P3 every literal mint site in `src/` spells a word of the set. `test/export-surface.test.ts` re-baselined (Δ +1) and `gate:closed-sets` reads the new row.
303
+
304
+ ### A File memory store opens only where its control plane can make a hard link — on a file system that cannot, the open is refused with `memory.control_plane_links_unsupported`, before the journal or any control object is written (#3512; ruled C-R1139; behavior change: a File store over a control plane without hard links is refused at its open where it opened and then lost every quarantine copy; narrowing: one, below, open to veto; widening: none; hard-breaking: one, three sentences below, open to veto; closed sets: `STORE_FORM_REFUSAL_CODES` +1 (`memory.control_plane_links_unsupported`), `NON_GOVERNANCE_MEMORY_CODES` +1 (the same code, CONTROL-PLANE IO), `STORE_OPEN_ARTIFACTS.filePrefixes` +1 (`.link-probe-`); exports: +1, `CONTROL_PLANE_LINKS_UNSUPPORTED`; wire: one code added to a closed family, additive) (@server @dgx @cli @client-core @test)
305
+
306
+ - **Rule.** The File governance store publishes every control object with `link` — a put stages the bytes and links them to their name, a move links the target and drops the source (7.64.0, #3465) — so on a file system that cannot make a hard link no object can be written. One judge, `probeControlPlaneLinks(controlDir)` (`src/core/memory-engine/control-objects.ts`), asked at each open and never cached: it creates one file at the control plane's top level (`.link-probe-<uuid>`), links a second name to it, and removes both. A link the file system refuses — whatever errno it answers (`EPERM`, `ENOTSUP` / `EOPNOTSUPP`, `EXDEV`, …) — refuses the open with the fourth seat of the store-form refusal family (`controlPlaneLinksRefusal`; the sentence leads with the code and names the errno, never a path; `detail.path` is the control plane). The judge claims nothing when it could not try: a first file that cannot be created (a plane that is read-only, full or not writable) and a link name that already stands leave the open as it was. A File store has three holders and two of them ask it: the File backend's construction, after the root anchor check and before the journal recovery, and an engine whose backend carries no store of its own, at its mount, after it creates its control plane and before it writes in it. The third — a backend a host composes itself around `fileGovernanceStore(dir)` (a package-root export, a pure factory that reads no disk) — is asked by neither: the engine skips its mount probe for a backend that carries a store of its own, and the factory has nothing to ask with (KL-3512-c, #3519).
307
+ - **Before.** In 7.64.0 a File store opened on such a file system, and the first object it wrote failed (`link` answered the errno). Since this release's #3466 / #3485 every quarantine copy, pollution marker and held instruction is such an object, and a containment whose copy fails still takes the suspect content off the model-visible plane (C-F9: containment never waits on its copy) — so the suspect file was removed and no copy of it was kept anywhere, the report saying `quarantine copy FAILED; file removal succeeded` with a `quarantineFailures` row and a `quarantine escalation` warning. The #3485 section's narrowing 1 described this.
308
+ - **Now.** The store does not open there. `new FileMemoryEngineBackend(dir)` throws the refusal; a Runner whose engine opens its own store over a plane without hard links degrades the session as for any mount that does not complete. The containment's order is unchanged: on a store that opened, a copy that fails still leaves the suspect off the plane, as before.
309
+ - **Runner actual form.** The fail-open arm of the memory phase, with no event of its own: `deps.onError(err, { phase: "memory", sessionId })` receives the refusal (`err.code === "memory.control_plane_links_unsupported"`), and the run's `effectiveMemoryScopes` is `{ state: "memoryless", reason: "mount-failed" }`; the session runs.
310
+ - **Narrowing — one (open to veto).** A deployment whose memory control plane is on a file system without hard links no longer opens its File memory store: the File backend throws at its construction, and a Runner over an engine that opens its own store runs memoryless. In 7.64.0 it opened, wrote nothing it could not link, and lost every suspect file a containment took off the plane.
311
+ - **Hard-breaking — one, three sentences (open to veto).** *What changed:* a File memory store whose control plane is on a file system that cannot make a hard link is refused at its open (`memory.control_plane_links_unsupported`, a store-form refusal) instead of opening and losing the copies its containments keep. *Who is affected:* a deployment whose memory control plane (`controlDir`, or the memory engine root it derives from) lives on such a file system — some network shares, FAT / exFAT volumes, some container overlay configurations — and a host that reads `STORE_FORM_REFUSAL_CODES` as exactly two codes. *Compensation:* put the control plane on a volume that supports hard links (the File stores' tool results, file history and mailbox lock already need them); nothing to migrate — the store's files are not touched by the refusal.
312
+ - **Consumers.** @server: `STORE_FORM_REFUSAL_CODES` is read as a family at run time (`memory-store-refusal.ts:47` / `:90`), so the third code joins the family without a change; the fail-open arm above is the Runner form to register (the discriminant is the `onError` code and phase, and the memoryless observation). A server replica's engine over a backend that carries no store opens the File store over its own control plane, so it is judged at its mount. @dgx: the same if your control plane is a File store; a store you carry is not judged (the judge is the File store's own), and neither is the File store you build yourself with `fileGovernanceStore(dir)` for a backend you compose (KL-3512-c). @cli @client-core: if you call `fileGovernanceStore` directly, the same; the server and cli checkouts read here have no such call, the others were not searched. @test — black box: a control plane whose `link` refuses ⇒ the File backend's construction throws the code with `detail.path` = the control plane and the store's files are untouched; control: a plane that can link opens and leaves no `.link-probe-*` behind.
313
+ - **Known limits.** KL-3512-a — the judge asks the control plane's top level; a kind directory (`quarantine/`, `hold/`, …) mounted from another volume is not asked, and a put into it that answers `EXDEV` takes the containment's ordinary path (C-F9). KL-3512-b — a process that dies between the probe's create and its removal leaves `.link-probe-*` at the control plane's top level: a named artifact of the open (`STORE_OPEN_ARTIFACTS`), never read as a record, removed by nothing. KL-3512-c — the third holder above: a File store built with `fileGovernanceStore(dir)` into a backend the host composes is not judged at its open, so on a file system without hard links it meets the #3485 section's narrowing 1 (the held file is removed and no copy is kept) where 7.64.0 held that file; on that one path this release is a regression against 7.64.0 (#3519, 7.66.0).
314
+ - **Rules.** Added: the judge (one), one code in an existing family, one artifact prefix; no per-path case. Retired: none.
315
+ - **Claude Code 2.1.316.** No divergence of its own: the reference has no memory control plane.
316
+ - **Pins.** `test/backlog3512-no-hardlink-control-plane.test.ts` (a `node:fs` whose `linkSync` refuses every link under the control plane by errno; it imports only names both trees export) — the File backend's construction refused for `EPERM`, `ENOTSUP`, `EOPNOTSUPP` and `EXDEV` (code, `detail.path`, errno in the sentence, no path, no probe file left), a store with content keeps every byte, and the lost-bytes cell (on the base tree the harvest removes the rejected file and keeps no copy; here the store does not open); the controls — a plane that links opens and leaves nothing, a probe file that cannot be created is not judged, an `EEXIST` link is not judged, each open asks again; the engine's mount refused for the four errnos with only the root anchor standing, a File backend's own store not judged again at the mount, and on a fresh engine `resolveHold` and the degraded `eraseMemoryEntries` ask no link and touch nothing they were not asked to; the Runner's fail-open arm (`onError` code and phase, `memoryless` / `mount-failed`, the run completes); the code in both families and a left `.link-probe-*` is no record. On the base tree 15 of its 19 cells are red, the four controls that do not need the judge green. `test/backlog1409-store-form-refusal-closed-set.test.ts` re-pinned to three codes and the fourth seat; `test/export-surface.test.ts` re-baselined (Δ +1).
317
+
1
318
  ## 7.64.0 — 2026-11-02
2
319
 
3
320
  ### A held instruction's quarantine seat is a function of its row, not of the clock — the row is written first, the custody bytes move second, and a death between the two converges instead of orphaning the bytes (#3464; behavior change: the seat's file name is `<first 16 hex of the content digest>-hold-<captureName>` and the row records it before the move; narrowing: none; widening: none; hard-breaking: none; closed sets: none; exports: none) (@server @test)