@sabaiway/agent-workflow-kit 5.4.0 → 5.6.0

package/CHANGELOG.md

@@ -4,6 +4,136 @@ Semantically versioned ([semver](https://semver.org)), newest first. The `versio
 is the current release. `upgrade` mode reads a project's `docs/ai/.workflow-version` and applies
 every `migrations/<version>-<slug>.md` newer than it, in semver order.
 
+## 5.6.0 — a source-size practice your project declares, and a record that is debt rather than permission (AD-091; engine 2.1.0)
+
+**A big module is expensive long before anyone calls it a problem, and nothing in the kit ever said
+so.** This release adds the practice: a checker your project declares scope for, a cap it can hold
+you to, and — for the files already over it — a recorded baseline that can shrink for free but can
+only GROW with a written reason. Nothing is guessed and nothing is imposed: a project that declares
+no scope gets no cap, and the one manual step is a scope file you author from the starter template
+the tool prints — its `roots`/`extensions` placeholders are deliberately invalid until you replace
+them. With a valid, judgeable scope, `--adopt` then mints the record and attempts the gate
+declaration, reporting the second half if it is refused.
+
+- **`source-size-check.mjs` — the checker, and it refuses rather than assumes.** In scope is what
+  you DECLARE: git-tracked files under your roots, with your extensions, minus your excluded
+  prefixes. New files stay within 400 lines and 1000 bytes per line by default (both overridable,
+  because a multi-KB single line hides from a line count). There is no default root list, no default
+  file-type list and no content sniffing — a fixed extension list would silently exempt every
+  language it forgot. Run it with no config and it tells you the exact path to author and prints a
+  template; the placeholders in that template are rejected by the validator until you replace them,
+  so the printed starting point can never be pasted into a scope that matches nothing and passes.
+- **A recorded size is DEBT, not permission — that is the whole design.** Adopting on a real
+  codebase records today's oversized files instead of demanding a refactor you did not plan. From
+  then on the record only moves under rules: it may not grow without `--reason "<text>"` (recorded
+  verbatim in the entry it raised), it may not sit ABOVE what the tree now measures (a stale record
+  is headroom nobody earned, so the checker tells you to tighten it), and it disappears when the
+  file finally comes back under the cap. A record whose file is GONE is an error — that is what
+  makes a split or a rename visible rather than silent. **Every declared root also carries a line
+  budget**, so splitting 3000 lines across six modules buys exactly zero headroom.
+- **Every ratchet refusal hands you the next step, and it is a step this build can actually
+  perform.** Shrunk below the record? You get the regenerator command exactly as it should be pasted
+  — no reason asked, because shrinking is progress. Growing something? You get the same command as a
+  template with the reason placeholder and a plain statement that it is required: the tool cannot
+  invent your reason. On a project path that would not survive quoting, no command is printed at all
+  — the file, the actual, the allowed and the manual lane are stated instead, because a rendered
+  command that runs somewhere else is worse than none. Inputs the checker cannot judge at all — a
+  malformed config, a failed git enumeration — exit 2 stating what is unusable, with no rendered
+  recovery command.
+- **Adoption is one consented line.** `--adopt --reason "<text>"` records the baseline AND declares
+  the gate in `docs/ai/gates.json` in a single step, is idempotent once adopted, and reports exactly
+  what it did and did not do if the declaration is refused. Existing projects meet it as a
+  Recommendations item at upgrade; new ones meet it the same way on their first upgrade.
+- **The practice arrives BEFORE the code, not after it.** The plan-authoring and plan-execution
+  procedure renders now print your declared caps, your recorded debt and the reason the caps exist;
+  the checker's green line says the same thing on the enforced path. The point is a layout decided
+  while a plan is written, with the gate as the backstop rather than the teacher. A project that
+  declares no practice gets no invented
+  limits: the render's declared-practice block stays empty and `gates-init` offers no candidate. The
+  canon rule it does still print is conditional by construction — no declared cap, no limit to
+  state.
+- **The gate declaration learned where to place things.** A consented non-checker gate is now written
+  BEFORE a trailing canonical coverage checker instead of after it, which is what makes adopting on a
+  final-capable declaration work at all; entries you already declared are never reordered. The fill's
+  result gained `placed`, and `appended` remains as an alias of it.
+- **Scope, counting and the gate matcher live in a pure read core**, so the surfaces that ask about
+  the practice — the advisor, the gate declaration, the procedure render — never reach the writer.
+  Counting is pinned by literal fixtures: LF, and the CR of a CRLF, never count; a file with no final
+  newline still counts its last line.
+- **Housekeeping shipped alongside:** `flow-check.mjs` became a 254-line facade over two pure
+  decision modules and a git-I/O leaf (the decision cores and the evidence rungs, plus the git lane
+  that is deliberately the only one allowed to spawn `git`) with its behaviour and its declared gate
+  command unchanged — the first tranche of the cleanup this practice arms, and the first proof that
+  the record notices a split.
+
+## 5.5.0 — delegating a sub-task stops being a feeling and becomes a record (AD-090; codex-cli-bridge 3.5.0, antigravity-cli-bridge 5.1.1)
+
+**"How much does handing this off actually buy?" had no answer, because nothing wrote the answer
+down.** A delegated task went out, something came back, and whether it was worth it was a judgement
+made from memory. This release gives the handoff an **identity**, a **deadline** and an
+**accounting**: the wrapper that runs your delegate now claims its work before spending anything and
+publishes what it can prove afterwards, and the kit absorbs that into an append-only ledger you can
+read back per task class. The number it reports is deliberately hard to fake and easy to refuse — it
+would rather print INELIGIBLE with a reason than a figure it cannot stand behind.
+
+- **A delegated run now has a name, and the name is claimed BEFORE the money is spent.** Pass
+  `codex-exec --nonce <n>` and the wrapper writes a reservation beside the ledger, atomically and
+  no-clobber, before it starts the CLI: a second dispatch on the same nonce refuses while it is still
+  free to refuse. At exit the reservation is replaced by the finished receipt, and the ORDER is the
+  guarantee — the delegate's report is published first, the receipt last, so anything that has
+  arrived always has a complete report behind it. A run that cannot publish exits nonzero and says
+  the tree is dirtied rather than leaving you to discover it. **An invocation without `--nonce` is
+  byte-for-byte what it always was**: no reservation, no receipt, no extra process.
+- **Five new verbs on `dispatch` — four that write, one that only reads — and none of them invents a
+  second rulebook.** `open` puts a thread on the record with every mint-time field copied from the
+  task brief's own header; `await` waits for that one dispatch to answer; `return` absorbs the
+  wrapper's receipt; `fold` is the acceptance; and `degrade` closes a thread that never earned one,
+  on the record and with its reason. The ledger's
+  existing preflight stays the single legality door — the four WRITER verbs assemble a record and
+  pass its refusals through in the store's own words, while `await` writes nothing at all.
+- **`dispatch await` waits, and a wait that ends without an answer authorizes nothing.** Only the
+  FINISHED receipt satisfies it; a run still holding the nonce means keep waiting; an artifact from a
+  neighbouring feature refuses rather than pretending to answer. The bound is the deadline recorded
+  when the thread opened — not a fresh timer per wait — so `--timeout` defaults to the time actually
+  remaining, and while nothing has arrived and the dispatch is still inside its deadline one reaching
+  past it is refused rather than quietly shortened; a terminal receipt already on disk returns
+  ARRIVED before any bound is evaluated at all. An unanswered wait exits **3**, names which bound
+  ended it, and says in as many words that **no writer slot was released**: it is a question for you,
+  never permission to dispatch again.
+- **The metric refuses rather than flatters.** The two sides of the ratio are different byte
+  quantities — the numerator sums the image bytes of the returned objects, the denominator is the
+  framed bundle of the change set's payload and its report — bound not by one buffer but by one
+  observable change set: the same HEAD→index→worktree domain, bracketed by digests that refuse when
+  drift is detectable. Start from a dirty tree and the result is recorded INELIGIBLE by name instead
+  of counted. A change set carrying a binary, a non-regular path or a submodule is REFUSED outright
+  at `return` and `fold`, because the shared fingerprint carries no content for those and their bytes
+  could move underneath it. Gate output is not accounted at all in this version, and the mode doc
+  says so rather than leaving you to find out.
+- **`aggregate` reports one wave and refuses to guess.** Per task class it prints the finished
+  threads with the inclusion rules applied — a folded success with provable bytes contributes its
+  ratio, one whose bytes are unprovable is excluded from the mean but still counts in the first-pass
+  rate, and a failed, degrade-closed or acceptance-failed thread counts as a real zero. Below the
+  registered minimum nothing is computed. No pre-registration, an unfinished thread, a recorded
+  refusal-to-delegate, an ambiguous wave: each stops the computation by name.
+- **Both bridges ship a version anchor.** Every wrapper that stamps a version into a receipt now
+  declares it on one marked line — at least one per bridge, at most one per file, and the requirement
+  follows the USE, so a wrapper that never reads the constant is not asked for one. Every scalar
+  `AW_BRIDGE_VERSION=` or `+=` occurrence anywhere else in a shipped `bin/*.sh` — comment, help text
+  and heredoc body included — is refused by the version-sync verifier. What it deliberately does not
+  model is stated rather than implied: a form that sets the name WITHOUT that literal token — an
+  array-element setter, a spaced arithmetic assignment, an eval-constructed name — is out of scope,
+  so this closes the drift that actually happened, not every drift imaginable.
+  agy's wrapper gains only that marker — hence the PATCH — while codex's gains the whole dispatch
+  identity.
+
+Honest limits, all stated where they bite rather than in a footnote: a receipt is forgeable exactly
+like every record in this family, so what these doors defend against is a buggy or interrupted
+producer and never a hostile one; the fold's binding is equality of the visible canonical payload,
+which is a change detector rather than a cryptographic identity of the tree; and at most ONE in-tree
+delegated dispatch at a time remains a bar you keep, not a mechanism that enforces it.
+
+
+
 ## 5.4.0 — a check that certifies nothing now says so, and the render stops promising what no host guarantees (AD-089)
 
 **A gate matrix could run green while verifying nothing, and the kit itself was what built it.**

package/README.md

@@ -243,6 +243,7 @@ file), or run the guarded `/agent-workflow-kit uninstall`.
 | `/agent-workflow-kit commit-guard` | any time | **the read-only pre-commit guard** (D10) — makes the commit capture the whole current working tree, so «verified» and «about to be committed» are the same bytes (the receipt itself has a stated residual — see the mode doc). FIRST it refuses an **INDEX that lags the verified working tree** (the gates and the fingerprint describe the WORKING tree while `git commit` takes the INDEX alone, and the fingerprint cannot tell them apart — so a lagging index used to ship a strict subset of what was verified): unstaged tracked paths or reviewable untracked-not-ignored paths, named up to a bounded cap with the remainder stated, a dirty tracked **submodule** named separately with its own recovery, and fail-closed on an undecidable probe. This deliberately blocks a partial commit. Then it binds the LATEST completed `run-gates --final` receipt to the EXACT current tree: refuses on a missing/red/stale receipt, fingerprint drift under the run, a dangling later attempt, declaration content drift, evidence-hash or lcov drift, or unsatisfied review obligations (the same review-state decision, recomputed over a sanitized env — forged out-of-repo stores never satisfy). Re-runs NO gate or test. Wire it into `.git/hooks/pre-commit` (the installer writes the RESOLVED invocation). `git commit --no-verify` stays the stated residual. |
 | `/agent-workflow-kit recommendations` | any time (every `upgrade` ends with it) | **read-only deployment advisor** (AD-044) — computes what in THIS deployment is configured sub-optimally (allowlist not seeded, autonomy render drifted, OS sandbox unavailable, gates undeclared, bridge friction, sandbox-mask clutter, an unacknowledged sandbox recipe) and renders **verdict-first**: one composed verdict line (does anything need attention?), then each item as **{severity · what · one-line benefit · an optional `recipe:` line (the sandbox-lane live recipe, the worktrees-dir hand-apply-first grant advice, or the agents hidden-mode reconcile follow-up) · the exact consent-gated apply one-liner}**. The agent PRESENTS the section in the user's conversational language — every fact and count, nothing added or dropped; commands, paths, hosts and rule strings byte-exact; raw tool block on request — and runs EXACTLY the rendered one-liners only on your yes, surfacing each item's posture note first. Renders **present-even-when-empty** (`no recommendations — flow optimal.`); a failed probe degrades to a stated skip line. Registry strings are fact-true frozen one-line data (posture/risk notes live in the mode doc at the consent moment); the kit never seeds `sandbox.network.allowedDomains` / `filesystem.allowWrite` (**HAND-APPLY** territory), and the sandbox-lane item's convergence is a neutral fingerprint acknowledgement recorded by a consent-gated ack writer into `docs/ai/acks.json` — never a security key (the recipe is documented per bridge in `capability.json` `networkHosts` + `writableDirs`). `--cwd` is required (the target project is explicit); never writes, never commits, never runs a subscription CLI. |
 | `/agent-workflow-kit doc-parity` | any time | **read-only doc-parity lint** (AD-049) — kills the doc-drift class where a mode-contract doc silently lags a code constant (a `--check` doc still reading `300` after the diff cap moved to `400`): a **closed, exported registry** binds each live constant (review caps, schema versions, the ledger's own class/scope vocabulary, and the autonomy-doctor EXIT/status/trusted-dir contract) to the exact token its `references/modes/*.md` contract must carry, and asserts the CURRENT value renders into every bound file — a drifted doc, an unreadable file, or an absent token **fails closed**. The values are sourced from the live imports (never re-typed), so the lint can't itself go stale; adding a binding is adding a checked entry (closed-world, edit-safe). `--check` is a gate exit code for `docs/ai/gates.json`. Never writes, never commits, never runs a subscription CLI. |
+| `/agent-workflow-kit dispatch` | any time | **the delegation engine** — makes "how much does delegating a sub-task actually buy?" a measured number instead of a feeling. `check <file>` validates a sub-task brief's contract block and exits 0/1 naming the first violated field — **form only**: whether the task is genuinely bounded, its design decided and its acceptance adequate stays your judgment, and a well-formed absurdity passes here by construction. `register` pre-registers an acceptance wave (step classes, pairing key, minimum observations per class, the mean and first-pass thresholds) so the bar can never be chosen after the results it judges — immutable per wave. `observe` records ONE hand-written observation (`solo-construction`, the baseline whose ratio is 1 by construction — except over a scope measuring zero bytes, which has no ratio at all and is recorded ineligible by name — or `self-reported`) — delegated numbers are never hand-written, they are derived. The writer verbs are where that derivation happens: `open` puts a delegated thread on the record with every mint-time field copied from the brief's own header, refusing a deadline the wrapper's cap plus its kill grace would not fit inside, and recording whether the tree it started from was clean (a dirty one makes the result honestly unmeasurable rather than quietly counted); `await` waits for that one dispatch to answer and writes nothing — only the finished receipt satisfies it, a run still holding the nonce means keep waiting, and a wait that runs out says so with its own exit code, names whether the deadline or your own timeout ended it, and authorizes nothing: a wait that ended without an answer is a question for you, never permission to dispatch again; `return` absorbs the receipt the wrapper minted — only a finished one, checked against the contract it actually ran, its deadline and its own report, and refused outright when the tree hides changes from git or moves while the return is being computed — and derives the bytes from git rather than from anyone's claim; `fold` is the acceptance, and it refuses if the tree moved since the return — precisely, it re-confirms **equality of the visible canonical payload**, which is a change detector rather than a cryptographic identity of the tree: that payload is unframed and carries no file mode, so a content or symlink target that imitates the marker opening the next entry can alias two trees, and an executable-bit flip moves nothing (both named as residuals in the mode doc, with the fix queued). Where the payload cannot follow an object's bytes at all — a binary, a non-regular path, a submodule, a symlink whose target is not valid UTF-8 — `return` and `fold` **refuse** rather than promise what they cannot check. `degrade` closes a thread that never earned a fold, on the record and with its reason. `aggregate` prints one wave: the registered thresholds, every observation as context, and per step class the finished threads — a folded success with git-provable bytes contributes its ratio, one whose bytes are unprovable is excluded from the mean but still counts in the first-pass rate, and a failed thread, a degrade-closed one, or one folded after failing acceptance each count as a real zero. Below the registered minimum nothing is computed (insufficient); at or above it is computed and labeled PILOT evidence. It REFUSES rather than guessing: no pre-registration, an unfinished thread in scope, a recorded refusal-to-delegate that never opened a thread, or an ambiguous wave each stop the computation by name. Writes only its own append-only ledger inside the git dir (never committable); never commits, never runs a subscription CLI. |
 | `/agent-workflow-kit worktrees` | any time | **parallel feature worktrees** — run several features in DIFFERENT agent sessions on one repo, zero interference on working-tree files (the ONE exception is the dependency cache, below): `provision <slug> --plan <file>` creates a sibling git worktree on branch `aw/<slug>` and populates it (registry-derived footprint copy-if-missing — a tracked file is never overwritten; EXACTLY ONE seeded feature plan; the `handoff-<slug>.md` record from minute zero; `node_modules` symlinked where the link stays ignored — a shared MUTABLE dependency cache: writes through it hit MAIN's node_modules; for isolation run the printed isolated-install command (`--install` only PRINTS it; on `--resume` run the printed unlink-first recovery first); absolute root-pinned gate commands rebased on untracked copies only, and only while their bytes equal the MAIN source or its rebased form — user-modified copies stay untouched); `list` is read-only (slug, branch, base, dirty, handoff); `land <slug> --prepare` locks the common git dir, fail-closes on divergence or incomplete satellite state, transfers the complete accepted satellite diff onto a CLEAN main, runs sync plus the declared gates, and reports HEAD/TRANSFER/PREPARED OIDs — the commit ALWAYS stays a dialogue ask; `cleanup <slug>` takes the same lock and removes a LANDED worktree only after live landed-verification against main HEAD, while `--abandon` is the ONE destructive arm (destroys unlanded work; **no preview step** on any writer). The parent dir is the `docs/ai/worktrees.json` `parentDir` setting (default: the repo's sibling parent); an unwritable parent degrades to printed maintainer-pasted commands, and the one-time host consent that makes it promptless surfaces via `recommendations`. Never commits, never pushes, never runs a subscription CLI. |
 | `/agent-workflow-kit uninstall` | opt-in, any time | **guarded teardown** — the inverse of `init` / `setup`. Removes only what's **provably ours** (managed skill dirs + bridge wrappers; in a project, the hidden-mode git-ignore block it added + the pre-commit hook it installed); **never deletes** your `docs/ai` / `AGENTS.md` (prints the exact `rm` to run by hand) or your `.claude/settings.json` (prints an **edit** — remove the attribution key, review any velocity `permissions.*` — never an `rm`). Always `--dry-run` first; preflight-then-mutate; never commits. |
 | `/agent-workflow-kit velocity` | Claude Code · opt-in | **onboarding velocity profile** — seeds a fixed, audited **read-only** allowlist into `.claude/settings.json` so routine read-only commands stop idling on approval prompts while you're away; opt-in `acceptEdits`; plus a **read-only advisory** of likely project gate commands to add by hand. Writes **only** `.claude/settings.json` — **never** allowlists commit/push/publish, never writes `settings.local.json`, never commits. A seeded entry is a **trust posture, not a sandbox** (a runtime residual remains at the settings level — its guard ships as the opt-in `hook` command); a direct commit/push/publish still asks. `--dry-run` first. |

package/SKILL.md

@@ -3,7 +3,7 @@ name: agent-workflow-kit
 description: Deploy or upgrade a portable AI-agent memory-and-workflow system in any project. Use when the user wants to bootstrap `docs/ai/` + an entry-point `AGENTS.md` (+ `CLAUDE.md` alias) + cap/archive/index enforcement in a new or existing repo, set up the Memory Map and session protocols, install the docs-rotation pre-commit hook, or run `/agent-workflow-kit` / `/agent-workflow-kit upgrade`. Triggers on phrases like "set up the memory system", "deploy the AI workflow here", "bootstrap docs/ai", "upgrade the workflow".
 disable-model-invocation: true
 metadata:
-  version: '5.4.0'
+  version: '5.6.0'
 ---
 
 # agent-workflow-kit
@@ -203,6 +203,10 @@ read-only — read `${CLAUDE_SKILL_DIR}/references/modes/commit-guard.md` before
 
 read-only — read `${CLAUDE_SKILL_DIR}/references/modes/doc-parity.md` before acting.
 
+### Mode: dispatch
+
+writer — read `${CLAUDE_SKILL_DIR}/references/modes/dispatch.md` before acting.
+
 ### Mode: worktrees
 
 writer — read `${CLAUDE_SKILL_DIR}/references/modes/worktrees.md` before acting.

package/bridges/antigravity-cli-bridge/SKILL.md

@@ -2,7 +2,7 @@
 name: antigravity-cli-bridge
 description: Delegate work to Google's Antigravity CLI (`agy`) — the successor to Gemini CLI — to reach Gemini, Claude, and GPT-OSS models under a Google AI Pro/Ultra subscription from the terminal. Use when the user wants to run a headless `agy` prompt, hand a focused task or second-opinion review to `agy`, install or authenticate Antigravity CLI, check or economise its quota/models, bridge project context into `agy`, set up a second delegated-execution backend beside Codex, or troubleshoot `agy` flags, models, auth, conversations, or its no-JSON headless behaviour.
 metadata:
-  version: '5.1.0'
+  version: '5.1.1'
 ---
 
 # antigravity-cli-bridge

package/bridges/antigravity-cli-bridge/bin/agy-review.sh

@@ -326,7 +326,7 @@ DEFAULT_AGY_REVIEW_MODEL="Gemini 3.1 Pro (High)"
 # Review-receipt identity (AD-038). AW_BRIDGE_VERSION mirrors this bridge's SKILL.md/capability.json
 # version (drift-guarded by agy-review.test.mjs against capability.json).
 AW_RECEIPT_BACKEND="agy"
-AW_BRIDGE_VERSION="5.1.0"
+AW_BRIDGE_VERSION="5.1.1"  # aw-version-anchor
 # `-` not `:-` so an EXPLICIT empty AGY_MODEL= survives (drop --model, use settings.json — agy.sh:52).
 AGY_MODEL="${AGY_MODEL-$DEFAULT_AGY_REVIEW_MODEL}"
 # D5 control-byte screen — IMMEDIATELY after resolution, BEFORE the off-frontier advisory (or any

package/bridges/antigravity-cli-bridge/capability.json

@@ -3,7 +3,7 @@
   "schema": 1,
   "name": "antigravity-cli-bridge",
   "kind": "execution-backend",
-  "version": "5.1.0",
+  "version": "5.1.1",
   "provides": ["review", "probe"],
   "posture": { "model": "Gemini 3.1 Pro (High)" },
   "roles": {

package/bridges/codex-cli-bridge/SKILL.md

@@ -2,7 +2,7 @@
 name: codex-cli-bridge
 description: Delegate work to the OpenAI Codex CLI (`codex`) under a ChatGPT subscription — run plan/instruction EXECUTION in a sandboxed workspace, or get a read-only ADVISORY review of a plan or working-tree diff — as a second delegated-execution backend beside Antigravity. Use when the user wants to hand a bounded coding task or plan to `codex exec`, get a second-opinion review from codex, install or authenticate Codex CLI, understand its sandbox/network/approval policy, drive codex efficiently from the main agent (exec vs review, resume, the commit boundary), bridge project context (`AGENTS.md`) into codex, or troubleshoot codex flags, models, auth, or its no-TTY headless behaviour.
 metadata:
-  version: '3.4.1'
+  version: '3.5.0'
 ---
 
 # codex-cli-bridge
@@ -90,6 +90,9 @@ codex-exec <file|-> -- <extra codex flags...>     # GUARDED passthrough after `-
 codex-exec --resume-last docs/plans/<slug>.md    # continue the last session (id from the sidecar)
 echo "now do step 2 ..." | codex-exec --resume <session-id> -
 
+# ACCOUNTED EXECUTION (the delegation ledger's exec lane — see "Dispatch identity" below):
+codex-exec --nonce <n> docs/plans/<slug>-dispatch.md   # mints a fail-closed exec receipt
+
 # REVIEW (read-only sandbox — codex cannot edit anything, only emits findings):
 codex-review plan docs/plans/<slug>.md           # critique a plan
 codex-review code                                # review the current working-tree diff (precomputed)
@@ -135,17 +138,53 @@ defeat a policy is guarded — see [§ Models](#models-quality-first-pinned).
 |---|---|---|
 | `CODEX_MODEL` | `gpt-5.6-sol` (pinned) | model; non-default REFUSED unless `CODEX_PROBE=1` |
 | `CODEX_EFFORT` | `xhigh` (pinned) | reasoning effort; non-default REFUSED unless `CODEX_PROBE=1` |
-| `CODEX_HARD_TIMEOUT` | `3600` (exec) / `1800` (review) | hard wall-clock cap (seconds) via `timeout`/`gtimeout`; exit 124/137 ⇒ "exceeded hard cap". No `timeout` binary ⇒ exec warns loudly + runs uncapped; `codex-review` REFUSES pre-spend (fail-closed preflight). |
+| `CODEX_HARD_TIMEOUT` | `3600` (exec) / `1800` (review) | hard wall-clock cap (seconds) via `timeout`/`gtimeout`; exit 124/137 ⇒ "exceeded hard cap". No `timeout` binary ⇒ a nonce-less exec warns loudly + runs uncapped, a **nonced** exec REFUSES pre-spend (an accounted dispatch that cannot be capped can never honour the terminal-exit rule), and `codex-review` REFUSES pre-spend (fail-closed preflight). |
 | `CODEX_SERVICE_TIER` | unset (standard tier) | **SPEND knob**: `priority` (catalog name "Fast") = ~1.5× token speed at a **2.5× credit rate** on gpt-5.6-sol — quality-neutral (same model). codex accepts any `-c service_tier` string silently (probe-pinned 2026-07-05), so the wrapper validates: an unsupported value warns and runs standard. Env or settings file. |
 | `CODEX_SESSION_FILE` | `./.codex-last-session` | where `codex-exec` records the session id and where `--resume-last` reads it |
 | `CODEX_REVIEW_MAX_TOTAL_BYTES` | `1500000` | `codex-review code`: above this the assembled diff goes via a git-dir temp file instead of inline — never truncated |
 | `AW_REVIEW_NONCE` | unset | the flow dispatch nonce (safe grammar `[A-Za-z0-9._-]{1,64}` — anything else refuses pre-spend). `codex-review … --nonce <n>` is the plain-argument equivalent (one seam; flag and a non-empty env must agree, a disagreeing pair refuses pre-spend) — the lane for hosts whose dispatch policy has no env-prefix form. When supplied, a successful review first mints the finding MANIFEST `agent-workflow-finding-manifest-codex-<nonce>.json` beside the receipts file (atomic, no-clobber, ORDERED before the receipt append) — a failed mint EXCLUDES the receipt, so a nonce-supplied dispatch never lands a receipt without its readable manifest; nonce-less runs add no nonce field and mint nothing (the `wrapperVersion` field every receipt carries moves with each release) |
+| `AW_DISPATCH_NONCE` | unset | the **delegation** dispatch nonce (same safe grammar; anything else refuses pre-spend). `codex-exec [--nonce <n>] <plan-file>` is the plain-argument equivalent — ONE seam, recognised only BEFORE the prompt operand (after it, or after a literal `--`, it is passthrough payload). When supplied, the run is ACCOUNTED: see [§ Dispatch identity](#dispatch-identity-the-accounted-exec-lane). |
+| `AW_DELEGATION_STORE` | unset (the git common dir) | absolute path of the delegation ledger; its **dirname** is where a nonced run's receipt and report land. Relative, or ending in a path separator, refuses pre-spend — the same rule the kit's store applies. |
 | `CODEX_REVIEW_SCHEMA` | unset | `codex-review`: `=1` returns findings as a validated JSON object (`--output-schema`), with a raw-text fallback. Default off. |
 | `CODEX_PROBE` | unset | `=1` ⇒ throwaway-probe mode: relaxes the model/effort guard AND the tier-2 passthrough guard (echoed loudly). Never for real work. |
 
 The git-write shim, `--ignore-user-config`, and the `*_API_KEY` scrub are NOT env-tunable — they are
 fixed invariants.
 
+### Dispatch identity — the accounted exec lane
+
+A **nonced** `codex-exec` run has an identity the delegation ledger can absorb. Everything here is
+skipped entirely without a nonce: the wrapper is byte-unchanged, writes no artifact and needs no
+`node`.
+
+- **Pre-spend, it RESERVES the nonce.** Immediately before the CLI runs — after every preflight and
+  after the posture banner — it publishes `agent-workflow-exec-receipt-<len>-<backend>-<nonce>.json`
+  in state `reserved`, atomically and **no-clobber**, beside the delegation store. A second dispatch
+  on the same nonce (or a leftover report under that name) refuses **before any spend**. So does a
+  run with no capping binary, without `node`, with the prompt on stdin instead of a contract file, or
+  with a file carrying no ` ```aw-dispatch-contract ` block.
+- **`contractDigest` is computed HERE**, by the wrapper, from the dispatch file it was handed — an
+  independent value, never a copy of what the ledger holds, so `dispatch return` can refuse a run
+  that executed a *different* contract than the one it opened.
+- **At exit it publishes, in this ORDER**: verify the reservation is still ours → write the
+  delegate's final message to `agent-workflow-exec-report-<len>-<backend>-<nonce>.txt` → verify
+  again → replace the reservation with the `terminal` receipt. An artifact that has arrived therefore
+  always has a complete report behind it, and a **foreign owner publishes nothing at all**.
+- **The outcome is a SUBSET** the run can prove about itself: exit 0 with a session id → `success`,
+  exit 0 without one → `missing-identity`, any nonzero exit (124/137 included) →
+  `transport-failure`. Every orchestrator judgment is recorded later, at absorb time.
+- **FAIL-CLOSED, unlike the review receipt.** A review receipt that cannot be written only warns; an
+  exec receipt that cannot be written leaves an EDITED tree with no accounting, so the wrapper exits
+  nonzero and calls the tree partial/dirtied — never untouched. The two statuses carry **different**
+  recoveries:
+  - **71** — a publication stopped. The reservation is the run's own, so absorb the thread with
+    `dispatch return --nonce <n> --no-receipt --exit-status <n> --outcome <o>`. The message says
+    whether the report reached disk: if it did the absorb reads it, if it did not the absorb records
+    `reportLength 0` and the metric is ineligible by the name `empty-report`.
+  - **70** — the reservation could not be verified *before* anything was published, so nothing was.
+    `--no-receipt` is **not** the recovery here: it would source `wrapperVersion` and `posture` from
+    an artifact that belongs to another run. Establish what replaced the reservation first.
+
 ### Settings file (host-level, survives kit upgrades)
 
 `${XDG_CONFIG_HOME:-~/.config}/agent-workflow/bridge-settings.conf` holds `KEY=VALUE` lines,
@@ -233,8 +272,16 @@ The wrappers work in any git repo where `codex` is installed and authenticated.
   restates it via `-c`; only a *raw* `codex exec resume` (bypassing the wrapper) loses the posture.
 - **Hard timeout** — a hung run is killed at `CODEX_HARD_TIMEOUT` (exec 3600s / review 1800s) and
   reported (exit 124/137); raise it for a known-healthy slow run. If neither `timeout` nor `gtimeout`
-  is on `PATH`, `codex-exec` warns loudly and runs uncapped; `codex-review` refuses pre-spend
-  (the fail-closed preflight — an uncapped review run no longer exists).
+  is on `PATH`, a nonce-less `codex-exec` warns loudly and runs uncapped, a **nonced** one refuses
+  pre-spend, and `codex-review` refuses pre-spend (the fail-closed preflight — an uncapped review run
+  no longer exists).
+- **The wrapper cannot enforce an ABSOLUTE deadline** — it applies its own cap from ITS start and
+  never reads the ledger, so a dispatch started long after `dispatch open` is caught at absorb time
+  (the return refuses a late receipt), not pre-spend. Keeping that window small is the
+  orchestrator's rule: `open` is the last act before the dispatch.
+- **The gate output is not accounted** — the run trace is a temp file the EXIT trap removes, so a
+  nonced run's report carries the delegate's final message only; the metric counts the returned
+  change set, never what the gates printed.
 - **Native `codex review` is out of scope** — it rejects `--ignore-user-config` (would load a personal
   `config.toml` and break the subscription/config-isolation invariant) and can't be cleanly captured;
   `codex-review` runs `codex exec` over a precomputed diff instead.