@abelxiaoxing/cadence 1.1.0 → 1.1.1

package/README.md

@@ -21,11 +21,21 @@ Implement 只暴露 `start`、`status`、`resume`、`rebind`、`cancel` 和 `dis
 
 普通 artifact、错误 Red、transport、environment、stale、conflict、baseline 与验证失败都留在同一 Implement run 中恢复。
 累计验证发现 introduced failure 时会自动重开责任任务做有界修复；自动预算耗尽后 `resume` 复用已有 baseline 和 phase facts。
-只有继续工作确实需要新增行为、架构/策略、依赖、路径、资源、验证或 AGENTS 权限时才进入 `approval-needed`；结果不会携带返回 `/abel-design` 的阶段路由。
+Design 证据包必须绑定 durable `runId`；接受后的有界证据、决策版本、Gate 证明与 canonical plan 身份写入 owner-private journal。
+Design 激活期间，父模型只保留进入前已启用的 `read`、`grep`、`find`、`ls` 与 `abel_dispatch`；原工具集合会在 finalize、finish、切换阶段或 session 结束时精确恢复。
+OpenSpec change 制品只能通过私有 `write-artifact` / `delete-artifact` 原子操作变更；产品文件、AGENTS、`gate-a.yaml`、`ready.yaml` 和 `implement-plan.json` 对该通道不可达。
+Gate A/B 收据使用 schema v4，并在 Implement admission 时同时对照同一 root/change 的私有批准事实与 finalization revision/hash 事实验证。
+
+只有继续工作确实需要新增行为、架构/策略、依赖、路径、资源、验证或 AGENTS 权限时才进入 `approval-needed`。
+结果保留原 Implement run，明确给出 authority category、所需 Gate、引用和 `/abel-design --change <change>` 用户指引；不会自动调用另一阶段。
+`resume` 只作为带有更高 `deliveryRevision` 与匹配 `receiptHash` 的条件命令出现。
+用户显式完成 Design 后，新的 Implement 上下文会通过本地 `status` 自动发现 proof-bound 的精确 revision/hash，再对同一 run 做完整 admission 与 resume；不依赖复制上一次会话内容。
 
 交互式 TUI、print、JSON 和 RPC 都以 durable semantic state 为准。
 queued、connecting、waiting-first-response、running、validating、retrying、verifying、paused、approval-needed、applying 和 recovering 都不是完成；operation-cancelled 表示本次操作取消但 run 仍可恢复，discarded 与 rejected 是非成功终态。
 只有最终 apply 与 post-apply verification 提交后的 `completed` 才显示成功。
+Design finalization、Implement 终态、Diagnose/显式 `finish` 或 session shutdown 会清除 active stage 与 parent bridge；Design 还会恢复进入前的精确父工具集合，其他阶段只撤下 `abel_dispatch`。
+Gate 等待和可恢复暂停保持激活以接收直接后续操作。
 
 私有 journal、artifact 与 change workspace 位于 consumer repository 之外的 owner-private state root。
 暂停会保留最小结构化恢复事实；完成或显式 discard 后安全清理。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abelxiaoxing/cadence",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Four explicit Abel workflow prompts with stage-isolated design and diagnosis, durable resumable implementation, and package-owned professional Agents.",
   "license": "MIT",
   "type": "module",

package/prompts/abel-design.md

@@ -25,29 +25,46 @@ An explicit `--change <name>` resumes only that existing change; never reinterpr
 
 ## Write boundary
 
+- During verified Design, the parent tool set is mechanically limited to the previously active `read`, `grep`, `find`, and `ls` tools plus `abel_dispatch`.
+  Shell, edit, write, and unknown tools are unavailable until Design exits; never try to recover them or write through another tool.
 - Before explicit Gate A approval, all repository work is read-only.
   A provisional Design run may exist only in the repository-external private run store.
-- After Gate A, write only inside the canonical `openspec/changes/<change>/` root and only the next schema-ready artifact or a mechanically invalidated receipt.
+- After Gate A, mutate only the canonical `openspec/changes/<change>/` root through the private `write-artifact` or `delete-artifact` Design operations.
+  Use a path relative to the active change root; it may be only `.openspec.yaml`, `proposal.md`, `design.md`, `tasks.md`, `plan-draft.json`, or `specs/<safe-segments>/spec.md`.
+  Content is exact bounded UTF-8 text; send it directly, never as Base64.
+- Code-owned `gate-a.yaml` and `ready.yaml` receipts are forbidden targets.
+  Code-owned `implement-plan.json` is also unreachable through artifact mutation; only `compile-plan` may install it.
 - Every repository `AGENTS.md` remains read-only throughout Design.
   Audit it and seal any needed `none | update-existing | create-index | remove-index` operation into the implementation plan; never edit the index here.
 - Never edit OpenSpec schemas, `openspec/config.yaml`, generated OpenSpec skills/commands, product code, tests, package manifests, or repository state outside the change root.
 
+Write one artifact per operation and use a unique operation id.
+Delete only an obsolete allowed artifact; no directory is ever removed.
+Identical replay is idempotent and conflicting reuse of an operation id fails closed.
+
+```json
+{"action":"design","request":{"operation":"write-artifact","runId":"<run-id>","operationId":"<unique-operation>","path":"proposal.md","content":"<exact-utf8-content>"}}
+{"action":"design","request":{"operation":"delete-artifact","runId":"<run-id>","operationId":"<unique-operation>","path":"specs/<capability>/spec.md"}}
+```
+
 ## Durable Design identity
 
 Use `start` once to create or recover the Design run identity and `status` to inspect it.
 A new requirement may begin with a code-generated SHA-256 `provisionalKey`; after Gate A fixes the change name, a named `start` binds the same provisional run.
 These commands record lifecycle only and do not execute implementation work.
+A completed Design run is immutable; an explicit later `--change <change>` starts the next durable Design revision for that change while preserving prior approval facts for receipt verification.
 
 ```json
-{"version":2,"command":"start","stage":"abel-design","provisionalKey":"<sha256>","operationId":"<unique-operation>"}
-{"version":2,"command":"start","stage":"abel-design","change":"<change>","provisionalKey":"<same-sha256>","operationId":"<unique-operation>"}
-{"version":2,"command":"status","stage":"abel-design","change":"<change>"}
+{"command":"start","stage":"abel-design","provisionalKey":"<sha256>","operationId":"<unique-operation>"}
+{"command":"start","stage":"abel-design","change":"<change>","provisionalKey":"<same-sha256>","operationId":"<unique-operation>"}
+{"command":"status","stage":"abel-design","change":"<change>"}
 ```
 
 ## Read-only evidence packets
 
 Use `abel_dispatch` with `action: "run"` only for bounded Design evidence.
 Each packet is one tool call, has `stage: "abel-design"`, role `design-explorer`, phase `evidence`, an exact read scope, an empty write set, and output `evidence`.
+It must include the exact `runId` returned by Design `start`.
 Never send an implementation phase to a Design packet.
 
 ```json
@@ -56,6 +73,7 @@ Never send an implementation phase to a Design packet.
   "request":{
     "stage":"abel-design",
     "role":"design-explorer",
+    "runId":"<durable-design-run-id>",
     "id":"<unique-packet-id>",
     "phase":"evidence",
     "objective":"<bounded evidence question>",
@@ -69,6 +87,8 @@ Never send an implementation phase to a Design packet.
 
 When two or more independent packets are needed, issue all sibling calls in the same assistant turn.
 Do not wrap them in a `requests` array.
+The control plane validates the run before launch and records only a bounded normalized evidence fact after structural acceptance.
+An identical packet/result replay is idempotent; a conflicting result for one packet id fails closed.
 Validate packet id, scope, citations, and structure before synthesis; uncited, conflicting, or out-of-scope claims require a bounded follow-up or a minimal parent check.
 
 Evidence packets may read code and tests but may not execute validation.
@@ -76,7 +96,14 @@ Design may inspect manifests and verification capability statically; it must not
 
 ## Decision ledger and Gate A
 
-Maintain a decision ledger with id, `behavior | technical`, question, cited evidence, alternatives, recommendation, user decision, status, and affected artifacts.
+Maintain the conversational decision presentation with id, `behavior | technical`, question, cited evidence, alternatives, recommendation, user decision, status, and affected artifacts.
+After the user resolves a substantive decision, record only its normalized identity, category, canonical contract hash, and artifact references through the durable private journal:
+
+```json
+{"action":"design","request":{"operation":"record-decision","runId":"<run-id>","operationId":"<unique-operation>","decisionId":"<stable-id>","category":"behavior","contractHash":"<sha256>","refs":["<artifact-anchor>"]}}
+```
+
+Do not put prompts, transcripts, hidden reasoning, credentials, environment values, or raw model output in this request.
 
 Ask the user only for substantive choices: observable behavior, scope/non-goals, data/security/privacy/compatibility/migration policy, new dependencies, architecture/policy, irreversible changes, and technical choices with real trade-offs.
 Resolve reversible details mechanically from one established repository convention and do not ask them repeatedly.
@@ -86,9 +113,16 @@ Before approval, present the unresolved behavior decisions together.
 After explicit approval:
 
 1. resolve the final kebab-case change name and schema;
-2. create the change only if it does not already exist;
+2. create the change only if it does not already exist and bind the named Design run;
 3. materialize schema-ready behavior artifacts one at a time;
-4. compile `gate-a.yaml` with code-owned canonical serialization and raw SHA-256 bindings.
+4. compute the canonical behavior-contract hash and record approval with:
+
+```json
+{"action":"design","request":{"operation":"approve-gate","runId":"<run-id>","operationId":"<unique-operation>","gate":"gate-a","contractHash":"<behavior-contract-sha256>"}}
+```
+
+The returned proof contains the approval revision, contract hash, and owner-private record hash.
+`gate-a.yaml` is installed later by code-owned finalization, not hand-authored here.
 
 Gate A is not tool permission and carries no session/model/timestamp identity.
 
@@ -114,8 +148,15 @@ The plan admits only shell-free `vitest`, `package-script`, `static-check`, or o
 Pin local runners, package scripts, arguments, `minTests`, classifications, and `noInstall` behavior.
 Reject shell operators, implicit downloads, absolute/escaping paths, missing local capability, and unsupported verification shapes during Design readiness.
 
-Compile one canonical `ImplementPlan` with `compileImplementPlan`.
-It contains:
+After current Gate A approval, send the complete draft through `write-artifact` only to the relative path `plan-draft.json`, then invoke code-owned compilation:
+
+```json
+{"action":"design","request":{"operation":"compile-plan","runId":"<run-id>","operationId":"<unique-operation>"}}
+```
+
+The compiler reads only that fixed safe path, validates capability and graph closure, atomically installs canonical `implement-plan.json`, and returns its raw and canonical hashes.
+Do not hand-assemble canonical plan bytes, hashes, generated task Markdown, or receipts.
+The canonical `ImplementPlan` contains:
 
 - tasks and regular-file outputs;
 - target/affected/full-suite baselines and normalized failure identity policy;
@@ -134,12 +175,24 @@ Every absent future input must be a unique declared output from a transitive dep
 Gate B approves the complete HOW: substantive technical choices, task DAG, exact boundaries, verification/repair contracts, output postconditions, dependency changes, scheduling declarations, tracking, and AGENTS operations.
 Do not request approval while any capability, closure, traceability, or blocking decision is unresolved.
 
-After explicit approval, write remaining schema artifacts one at a time, run OpenSpec strict validation, then generate in this order:
+After explicit approval, materialize any remaining schema artifacts through `write-artifact` one at a time and complete the code-owned sequence below.
+First record Gate B against the exact canonical plan hash returned by `compile-plan`:
+
+```json
+{"action":"design","request":{"operation":"approve-gate","runId":"<run-id>","operationId":"<unique-operation>","gate":"gate-b","contractHash":"<exact-plan-canonical-sha256>"}}
+```
+
+Then request finalization:
+
+```json
+{"action":"design","request":{"operation":"finalize-delivery","runId":"<run-id>","operationId":"<unique-operation>"}}
+```
 
-1. canonical `implement-plan.json`;
-2. canonical Gate A/plan/artifact/traceability bindings;
-3. `ready.yaml` last, using `compileReadyReceipt`.
+Finalization revalidates both current private Gate proofs, the stored plan, strict/planning-complete OpenSpec state, artifact coverage, exact traceability, and executable verification closure.
+It atomically installs canonical `gate-a.yaml`, writes `ready.yaml` last, rereads the installed delivery, removes `plan-draft.json`, marks the Design run completed, and returns `deliveryRevision` plus `receiptHash`.
+Any failure leaves Design nonterminal and installs no new `ready.yaml`.
 
+Receipt schema version 4 binds the Gate A and Gate B approval revisions, canonical contract hashes, and owner-private record hashes.
 `ready.yaml` references the plan path, schema version, raw-byte hash, canonical plan hash, executable verification closure, Gate A hash, artifact hashes, and traceability hash.
 It does not embed caller-owned runtime task state, completed/blocked arrays, snapshots, launch identities, or retry budgets.
 
@@ -149,6 +202,7 @@ Every other byte remains bound.
 ## Recovery without approval loops
 
 On resume, validate current artifacts and receipts first.
+Use Design `status` to recover bounded accepted-evidence identities/hashes, latest decision revisions, Gate currentness, and compiled-plan identity without relying on a prior child session.
 Preserve decisions whose bound content did not change.
 A mechanical hash, formatting, checkbox, stale path, or traceability repair regenerates only invalidated artifacts and does not reopen a Gate.
 Reopen Gate A only for changed behavior authority; reopen Gate B only for changed technical authority.
@@ -158,6 +212,8 @@ Endpoint/transport failure in an evidence packet pauses that packet and retains
 Missing package scripts/runners or a non-executable verification contract must be corrected before Gate B; they must not be deferred as an Implement surprise.
 
 Report `READY_TO_IMPLEMENT` only when strict validation passes, both Gates have zero unresolved decisions, all artifacts/hashes/traceability resolve, and the canonical plan is executable.
+Successful finalization deactivates private dispatch before an unrelated later request.
+Gate waits remain active for direct follow-up; if the user explicitly ends an unfinished Design interaction, send `{"action":"finish"}`.
 Otherwise report the current Design state, retained evidence, and the one unresolved decision or artifact that prevents readiness.
 
 Do not implement product code and do not archive, publish, release, stage, or commit implicitly.

package/prompts/abel-diagnose.md

@@ -51,4 +51,6 @@ Do not silently widen Diagnose and do not transform an ordinary repair failure i
 When an approved browser E2E check requires `dev-browser` and it is unavailable, pause only that check and provide executable remediation; continue independent non-browser evidence when safe.
 
 Finish only when reproduction, falsification, failing regression, minimum repair, affected verification, and baseline comparison are all evidenced.
+After presenting the final structural diagnosis/repair result, send `{"action":"finish"}` so private dispatch is deactivated.
+A resumable evidence or capability pause remains active for direct follow-up and must not send finish.
 Never archive, publish, or commit implicitly.

package/prompts/abel-implement.md

@@ -37,15 +37,15 @@ A fresh context validates existing approval facts and does not ask the user to a
 
 ## Closed control surface
 
-Use `abel_dispatch` only with the versioned change commands below; never send `action: "run"`, `admit-graph`, `task-attempt`, caller-owned snapshots, completed/blocked arrays, or apply identities.
+Use `abel_dispatch` only with the change commands below; never send `version`; never send `action: "run"`; and never send `admit-graph`, `task-attempt`, caller-owned snapshots, completed/blocked arrays, or apply identities.
 
 ```json
-{"version":2,"command":"start","stage":"abel-implement","change":"<change>","operationId":"<unique-operation>"}
-{"version":2,"command":"status","stage":"abel-implement","change":"<change>"}
-{"version":2,"command":"resume","stage":"abel-implement","change":"<change>","operationId":"<unique-operation>"}
-{"version":2,"command":"rebind","stage":"abel-implement","change":"<change>","operationId":"<unique-operation>","routeId":"<approved-route>"}
-{"version":2,"command":"cancel","stage":"abel-implement","change":"<change>","operationId":"<unique-operation>"}
-{"version":2,"command":"discard","stage":"abel-implement","change":"<change>","operationId":"<unique-operation>"}
+{"command":"start","stage":"abel-implement","change":"<change>","operationId":"<unique-operation>"}
+{"command":"status","stage":"abel-implement","change":"<change>"}
+{"command":"resume","stage":"abel-implement","change":"<change>","operationId":"<unique-operation>"}
+{"command":"rebind","stage":"abel-implement","change":"<change>","operationId":"<unique-operation>","routeId":"<approved-route>"}
+{"command":"cancel","stage":"abel-implement","change":"<change>","operationId":"<unique-operation>"}
+{"command":"discard","stage":"abel-implement","change":"<change>","operationId":"<unique-operation>"}
 ```
 
 When the user approves a revised delivery boundary, resume the same run with both `deliveryRevision` and `receiptHash`.
@@ -55,6 +55,11 @@ The engine revalidates retained phase/repair facts, invalidates only incompatibl
 Repeating the same operation id returns its committed outcome.
 Use a new operation id for a new attempt.
 
+For an approval-needed retained run, a later explicit Implement invocation must inspect local `status`.
+When a newer owner-private-proof-bound receipt is present, status exposes its exact pair in `availableDelivery`, adds `resume` to `legalCommands`, and fills the matching `conditionalCommands` arguments.
+Resume with that discovered pair; do not require the user to copy revision or hash data from a prior Design conversation.
+Discovery never admits the delivery: `resume` still performs the full artifact, traceability, capability, and currentness validation before any Worker starts.
+
 ## Execution and verification
 
 Before any candidate, the engine records target-contract, task-affected, and full-suite baselines with normalized failure identities.
@@ -98,9 +103,14 @@ No item above carries stage-routing metadata or asks the user to restart the app
 
 Use `approval-needed` only when continuing requires authority not present in the sealed delivery: new observable behavior, architecture or policy; a new/changed dependency; an undeclared write/delete/read target; expanded conflict/resource authority; a changed verification contract; an AGENTS target/impact/managed block change; or another irreversible scope decision.
 
+Classify only codes in the closed authority table.
+An unknown Worker, verifier, or internal approval code is an `approval-code-invalid` integrity pause; never guess a category or Gate from keywords.
+
 Report the exact missing authority and retained run state.
 Do not discard compatible work.
-If the user supplies a newly approved receipt revision, resume that same run with the revision/hash pair.
+Expose `approval.category`, `approval.requiredGates`, safe `approval.refs`, and `approval.designRequest` as `/abel-design --change <change>` user guidance only; never invoke Design automatically.
+Bare `resume` is not immediately executable progress while approval is missing, so keep it out of `legalCommands` and expose it only in `conditionalCommands` with a `deliveryRevision` greater than the retained revision and the matching `receiptHash` precondition.
+If the user supplies that newly approved receipt revision, resume the same run with the revision/hash pair.
 A generated artifact defect, endpoint outage, stale snapshot, environment failure, pre-existing failure, introduced in-boundary repair, approved documentation/test edit, or approved AGENTS checkpoint is never `approval-needed`.
 
 ## AGENTS and tracking
@@ -118,6 +128,7 @@ Treat `queued`, `connecting`, `waiting-first-response`, `running`, `validating`,
 `operation-cancelled` ends only the current operation; `discarded` and `rejected` are non-success terminal run states.
 Tool-call settlement is not success.
 Report success only when the durable state is `completed`, final application and post-apply verification committed, and private run content was cleaned.
+Terminal `completed`, `discarded`, or `rejected` settlement deactivates private dispatch; a nonterminal pause or approval wait keeps it active for direct follow-up.
 
 On a nonterminal result, report the safe code, affected task/scope when present, retained progress, and the exact legal command that continues or inspects the same run.
 Never hide an incomplete run behind a success checkmark.

package/skills/abel-workflow/SKILL.md

@@ -21,7 +21,8 @@ Neither Gate grants tool permission, repository permission, identity, or authori
 Design and Implement may run in fresh contexts.
 Trusted delivery requires:
 
-- canonical Gate A and Gate B receipts for the same change/schema;
+- canonical receipt-schema-v4 Gate A and Gate B proofs for the same root/change/schema, each binding its approval revision, canonical contract hash, and owner-private journal record hash;
+- an owner-private finalization fact binding the exact delivery revision, ready-receipt raw hash, both Gate proofs, and canonical plan hash;
 - safe relative artifact paths and exact raw SHA-256 bindings;
 - a canonical `implement-plan.json` with schema version, raw hash, and canonical hash;
 - OpenSpec strict validity and planning completeness;
@@ -40,16 +41,40 @@ A new receipt revision is needed only when approved authority changes.
   It uses no Subagent dispatch, preserves dirty/human content and nested repositories, and is idempotent.
 - **Design** is evidence and delivery compilation only.
   Product code, tests, implementation candidates, and AGENTS files are read-only.
+  The parent sees only its previously active `read`, `grep`, `find`, and `ls` tools plus `abel_dispatch` while Design is active.
   Design may use bounded read-only `design-explorer` packets.
 - **Implement** uses only the durable change command surface.
   It executes the sealed plan in private immutable revisions and applies the complete change once.
 - **Diagnose** independently follows reproduce → falsify → failing regression → minimum repair.
   It does not inherit Implement state, retry policy, or approval classification.
 
-Design and Diagnose bounded packets use `action: "run"` with their own stage.
+Design and Diagnose bounded packets use `action: "run"` with their own stage; every Design packet also binds the durable Design `runId` that requested it.
 Implement never uses that packet protocol.
 Cross-stage calls fail closed.
 
+## Durable Design control
+
+Design uses one closed private `action: "design"` family with `record-decision`, `approve-gate`, `write-artifact`, `delete-artifact`, `compile-plan`, and `finalize-delivery`.
+The owner-private SQLite journal retains only normalized evidence identities/hashes, versioned decision hashes and refs, Gate proof facts, canonical compiled-plan identity/bytes, finalization identity, and idempotent operation outcomes.
+It never retains prompts, transcripts, hidden reasoning, credentials, environment values, or raw model output.
+
+Accepted evidence is recorded only after structural validation.
+Same packet/result replay is idempotent; conflicting evidence for one packet id fails closed.
+A later behavior decision invalidates both Gates; a later technical decision or plan compilation invalidates Gate B only.
+
+The extension snapshots the exact pre-Design non-dispatch tool set; during Design it retains only the previously active `read`, `grep`, `find`, and `ls` tools plus `abel_dispatch`.
+It removes every write-capable or unknown tool and restores the snapshot on finalization, explicit finish, verified stage switch, session start, or shutdown.
+Private artifact mutation accepts bounded UTF-8 only at `.openspec.yaml`, `proposal.md`, `design.md`, `tasks.md`, `plan-draft.json`, and `specs/<safe-segments>/spec.md` relative to the active change root.
+It creates missing directories component-wise without following symlinks, writes atomically, deletes only an allowed regular file, journals only bounded path/hash outcomes, and replays idempotently.
+Code-owned `gate-a.yaml` and `ready.yaml` receipts remain forbidden; `implement-plan.json` remains unreachable except through compilation.
+
+All filesystem-mutating Design operations serialize against the durable expiring finalization lease.
+A competing or stale owner cannot inspect, replace, remove, or commit another operation's receipt bytes, and cleanup is fenced by the current operation's raw receipt hash.
+After current Gate A, the parent sends the fixed `plan-draft.json` input only through `write-artifact`.
+`compile-plan` owns canonical plan construction and installation.
+Gate B binds that exact stored canonical plan hash.
+`finalize-delivery` validates current proofs, OpenSpec, artifacts, traceability, and executable closure, writes Gate A and ready receipts atomically with `ready.yaml` last, rereads them, removes the draft, and completes Design.
+
 ## Canonical ImplementPlan
 
 `ImplementPlan` is the only machine source for implementation mechanics.
@@ -80,7 +105,8 @@ Arbitrary shell, `&&`, path escape, and implicit downloads are forbidden.
 
 ## Durable control
 
-Implement accepts only `start`, `status`, `resume`, `rebind`, `cancel`, and `discard` with protocol version 2, stage, change, and operation identity where required.
+Implement accepts only `start`, `status`, `resume`, `rebind`, `cancel`, and `discard` with stage, change, and operation identity where required.
+The internal-development command surface has no caller-supplied protocol version.
 
 - `start` is idempotent for one change run.
 - `status` is local and requires no Worker endpoint.
@@ -135,6 +161,12 @@ Use `approval-needed` only when continuing requires new authority: observable be
 Report the exact missing authority.
 After the user approves a new canonical delivery revision, resume the same run and preserve compatible work.
 
+An approval-needed status exposes the closed authority category, required Gate set, safe refs, retained run/revision, and `/abel-design --change <change>` as user guidance only.
+It never invokes Design automatically.
+Bare `resume` or `rebind` is not an immediately legal approval continuation; `conditionalCommands` exposes resume only with a newer `deliveryRevision` and matching `receiptHash`.
+Authority classification uses one exhaustive typed code map; an unknown approval code becomes an `approval-code-invalid` integrity pause rather than a guessed Gate.
+A later explicit Implement status may locally discover a newer receipt only when its change, revision/hash, both current Gate proofs, and owner-private finalization fact match; it exposes the exact pair without admitting it or mutating the run.
+
 Do not label an approved AGENTS checkpoint, documentation/test edit, endpoint outage, artifact error, stale snapshot, environment problem, baseline failure, or in-boundary repair as approval-needed.
 
 ## AGENTS indexes
@@ -163,4 +195,6 @@ Its absence pauses that verification only and does not block unrelated tasks or
 `operation-cancelled` ends only the current operation; `discarded` and `rejected` are non-success terminal run states.
 Tool settlement is not completion.
 Only durable `completed` after cumulative apply and postconditions receives success.
+Successful Design finalization, terminal Implement settlement, Diagnose `finish`, explicit stage finish, and session shutdown deactivate only `abel_dispatch`, drain packets, clear the parent bridge, and clear active stage identity.
+Gate waits and resumable pauses remain active for direct follow-up.
 Never archive, publish, release, stage, or commit implicitly.

package/src/contracts.ts

@@ -10,7 +10,6 @@ export type {
 export {
   assertControlCommand,
   CONTROL_COMMANDS,
-  CONTROL_PROTOCOL_VERSION,
   CONTROL_STAGES,
   controlRunKey,
   validateControlCommand,
@@ -146,8 +145,10 @@ export const APPROVAL_BOUNDARY_CODES = [
   "behavior-contract-insufficient",
   "architecture-contract-insufficient",
   "task-scope-insufficient",
+  "conflict-resource-authority-insufficient",
   "verification-contract-insufficient",
   "agents-contract-insufficient",
+  "irreversible-scope-insufficient",
 ] as const;
 export const VERIFICATION_ADAPTER_CODES = [
   "input-missing",
@@ -439,6 +440,7 @@ export type ImplementGraphReadinessDiagnostic =
 export interface PacketEnvelope {
   stage: "abel-design" | "abel-diagnose";
   role: "design-explorer" | "diagnosis-worker";
+  runId?: string;
   id: string;
   phase: string;
   objective: string;
@@ -1230,7 +1232,7 @@ export function validatePacketEnvelope(
     return { ok: false, reason: "missing request envelope" };
   }
   const packet = value as Record<string, unknown>;
-  const required = [
+  const baseRequired = [
     "stage",
     "role",
     "id",
@@ -1241,6 +1243,14 @@ export function validatePacketEnvelope(
     "declared",
     "output",
   ] as const;
+  const required =
+    packet.stage === "abel-design"
+      ? ([
+          ...baseRequired.slice(0, 2),
+          "runId",
+          ...baseRequired.slice(2),
+        ] as const)
+      : baseRequired;
   for (const field of required) {
     if (packet[field] === undefined) {
       return { ok: false, reason: `missing required field: ${field}` };
@@ -1262,6 +1272,12 @@ export function validatePacketEnvelope(
   ) {
     return { ok: false, reason: "packet role does not match stage" };
   }
+  if (
+    (packet.stage === "abel-design" && !validIdentifier(packet.runId)) ||
+    (packet.stage === "abel-diagnose" && packet.runId !== undefined)
+  ) {
+    return { ok: false, reason: "invalid Design run identity" };
+  }
   if (
     typeof packet.id !== "string" ||
     packet.id.length === 0 ||

package/src/control-contracts.ts

@@ -2,8 +2,6 @@
 // Mechanical graph, snapshot, task, and apply identities are intentionally not
 // part of this surface: the control plane derives them from approved delivery.
 
-export const CONTROL_PROTOCOL_VERSION = 2 as const;
-
 export const CONTROL_COMMANDS = [
   "start",
   "status",
@@ -23,7 +21,6 @@ const CHANGE_NAME = /^[a-z0-9](?:[a-z0-9-]{0,126}[a-z0-9])?$/u;
 const SHA256 = /^[a-f0-9]{64}$/u;
 
 interface ControlBase {
-  version: typeof CONTROL_PROTOCOL_VERSION;
   command: ControlCommandName;
   stage: ControlStage;
 }
@@ -86,10 +83,7 @@ export type ControlCommand =
 
 export type ControlCommandValidation =
   | { ok: true; value: ControlCommand }
-  | {
-      ok: false;
-      code: "invalid-control-command" | "unsupported-control-version";
-    };
+  | { ok: false; code: "invalid-control-command" };
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -110,7 +104,6 @@ function hasExactKeys(
 
 function validCommon(value: Record<string, unknown>): boolean {
   return (
-    value.version === CONTROL_PROTOCOL_VERSION &&
     (CONTROL_COMMANDS as readonly unknown[]).includes(value.command) &&
     (CONTROL_STAGES as readonly unknown[]).includes(value.stage)
   );
@@ -128,17 +121,11 @@ export function validateControlCommand(
   value: unknown,
 ): ControlCommandValidation {
   if (!isRecord(value)) return { ok: false, code: "invalid-control-command" };
-  if (
-    Object.hasOwn(value, "version") &&
-    value.version !== CONTROL_PROTOCOL_VERSION
-  ) {
-    return { ok: false, code: "unsupported-control-version" };
-  }
   if (!validCommon(value)) {
     return { ok: false, code: "invalid-control-command" };
   }
 
-  const common = ["version", "command", "stage"] as const;
+  const common = ["command", "stage"] as const;
   const named = [...common, "change"] as const;
   switch (value.command) {
     case "status":

package/src/delivery-compiler.ts

@@ -21,7 +21,7 @@ import { validateVerificationAdapterCapability } from "./verification-capability
 
 export const IMPLEMENT_PLAN_SCHEMA_VERSION = 3 as const;
 export const IMPLEMENT_PLAN_PATH = "implement-plan.json" as const;
-export const DELIVERY_RECEIPT_VERSION = 3 as const;
+export const DELIVERY_RECEIPT_VERSION = 4 as const;
 export const GATE_A_RECEIPT_PATH = "gate-a.yaml" as const;
 export const READY_RECEIPT_PATH = "ready.yaml" as const;
 
@@ -35,14 +35,17 @@ export interface DeliveryArtifactBinding {
   rawSha256: string;
 }
 
+export interface GateApprovalProof {
+  revision: number;
+  contractHash: string;
+  recordHash: string;
+}
+
 export interface GateAReceipt {
   receiptVersion: typeof DELIVERY_RECEIPT_VERSION;
   change: string;
   schema: string;
-  approval: {
-    approved: true;
-    blockingDecisions: 0;
-  };
+  approval: GateApprovalProof;
   artifacts: DeliveryArtifactBinding[];
 }
 
@@ -65,8 +68,9 @@ export interface ReadyReceipt {
       rawSha256: string;
     };
     gateB: {
-      approved: true;
-      blockingDecisions: 0;
+      revision: number;
+      contractHash: string;
+      recordHash: string;
     };
   };
   artifacts: DeliveryArtifactBinding[];
@@ -320,6 +324,22 @@ function requireReceiptIdentity(
   }
 }
 
+function normalizeGateProof(value: GateApprovalProof): GateApprovalProof {
+  if (
+    !isRecord(value) ||
+    !exactKeys(value, ["revision", "contractHash", "recordHash"]) ||
+    !Number.isSafeInteger(value.revision) ||
+    value.revision < 1 ||
+    typeof value.contractHash !== "string" ||
+    !SHA256.test(value.contractHash) ||
+    typeof value.recordHash !== "string" ||
+    !SHA256.test(value.recordHash)
+  ) {
+    throw new Error("delivery-gate-proof-invalid");
+  }
+  return structuredClone(value);
+}
+
 function parseCanonicalReceipt<T>(bytes: Uint8Array, code: string): T {
   const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
   let parsed: unknown;
@@ -335,6 +355,7 @@ function parseCanonicalReceipt<T>(bytes: Uint8Array, code: string): T {
 export function compileGateAReceipt(input: {
   change: string;
   schema: string;
+  approval: GateApprovalProof;
   artifacts: readonly DeliveryArtifactBinding[];
 }): { receipt: GateAReceipt; bytes: Uint8Array; rawSha256: string } {
   requireReceiptIdentity(input.change, input.schema);
@@ -342,7 +363,7 @@ export function compileGateAReceipt(input: {
     receiptVersion: DELIVERY_RECEIPT_VERSION,
     change: input.change,
     schema: input.schema,
-    approval: { approved: true, blockingDecisions: 0 },
+    approval: normalizeGateProof(input.approval),
     artifacts: normalizeArtifactBindings(input.artifacts),
   };
   const bytes = canonicalBytes(receipt);
@@ -369,15 +390,17 @@ export function parseGateAReceipt(bytes: Uint8Array): GateAReceipt {
     ]) ||
     receipt.receiptVersion !== DELIVERY_RECEIPT_VERSION ||
     !isRecord(receipt.approval) ||
-    !exactKeys(receipt.approval, ["approved", "blockingDecisions"]) ||
-    receipt.approval.approved !== true ||
-    receipt.approval.blockingDecisions !== 0
+    !exactKeys(receipt.approval, ["revision", "contractHash", "recordHash"])
   ) {
     throw new Error("gate-a-receipt-invalid");
   }
   requireReceiptIdentity(receipt.change, receipt.schema);
+  const approval = normalizeGateProof(receipt.approval);
   const artifacts = normalizeArtifactBindings(receipt.artifacts);
-  if (canonicalJson(artifacts) !== canonicalJson(receipt.artifacts)) {
+  if (
+    canonicalJson(approval) !== canonicalJson(receipt.approval) ||
+    canonicalJson(artifacts) !== canonicalJson(receipt.artifacts)
+  ) {
     throw new Error("gate-a-receipt-invalid");
   }
   return structuredClone(receipt);
@@ -415,6 +438,7 @@ export function compileReadyReceipt(input: {
   schema: string;
   deliveryRevision: number;
   gateA: { rawSha256: string };
+  gateB: GateApprovalProof;
   artifacts: readonly DeliveryArtifactBinding[];
   compiledPlan: CompiledDelivery;
   traceability: DeliveryTraceability;
@@ -424,7 +448,8 @@ export function compileReadyReceipt(input: {
     !Number.isSafeInteger(input.deliveryRevision) ||
     input.deliveryRevision < 1 ||
     !SHA256.test(input.gateA.rawSha256) ||
-    input.compiledPlan.plan.changeId !== input.change
+    input.compiledPlan.plan.changeId !== input.change ||
+    input.gateB.contractHash !== input.compiledPlan.planHash
   ) {
     throw new Error("delivery-receipt-invalid");
   }
@@ -438,7 +463,7 @@ export function compileReadyReceipt(input: {
         path: GATE_A_RECEIPT_PATH,
         rawSha256: input.gateA.rawSha256,
       },
-      gateB: { approved: true, blockingDecisions: 0 },
+      gateB: normalizeGateProof(input.gateB),
     },
     artifacts: normalizeArtifactBindings(input.artifacts),
     plan: structuredClone(input.compiledPlan.receipt.plan),
@@ -485,9 +510,11 @@ export function parseReadyReceipt(bytes: Uint8Array): ReadyReceipt {
     receipt.approvals.gateA.path !== GATE_A_RECEIPT_PATH ||
     !SHA256.test(receipt.approvals.gateA.rawSha256) ||
     !isRecord(receipt.approvals.gateB) ||
-    !exactKeys(receipt.approvals.gateB, ["approved", "blockingDecisions"]) ||
-    receipt.approvals.gateB.approved !== true ||
-    receipt.approvals.gateB.blockingDecisions !== 0 ||
+    !exactKeys(receipt.approvals.gateB, [
+      "revision",
+      "contractHash",
+      "recordHash",
+    ]) ||
     !isRecord(receipt.plan) ||
     !exactKeys(receipt.plan, [
       "path",
@@ -513,8 +540,11 @@ export function parseReadyReceipt(bytes: Uint8Array): ReadyReceipt {
   }
   requireReceiptIdentity(receipt.change, receipt.schema);
   const artifacts = normalizeArtifactBindings(receipt.artifacts);
+  const gateB = normalizeGateProof(receipt.approvals.gateB);
   const traceability = normalizeTraceability(receipt.traceability);
   if (
+    gateB.contractHash !== receipt.plan.canonicalHash ||
+    canonicalJson(gateB) !== canonicalJson(receipt.approvals.gateB) ||
     canonicalJson(artifacts) !== canonicalJson(receipt.artifacts) ||
     canonicalJson(traceability) !== canonicalJson(receipt.traceability)
   ) {