cool-workflow 0.1.80 → 0.1.82

package/docs/control-plane-scheduling.7.md

@@ -114,3 +114,6 @@ Migration DAG with reversible edges (v0.1.45), capability auto-discovery (v0.1.4
 ## Fast Architecture Review (v0.1.80)
 
 Adds the opt-in fast architecture-review lane: scoped JSONL source contexts, diff-aware exports, reusable Map and Assess results, measurable wrapper metrics, actionable background full-review handoff, and userland model policy flags for routing fast/strong workers without changing the full review contract.
+
+_No changes to the control-plane scheduling surface in v0.1.81._
+_No behavioral change in v0.1.82 (schedule/run ids are now deterministic-but-unique via a monotonic counter + pid instead of Math.random; ids stay collision-free)._

package/docs/dogfood/resume-drive-real-agent-2026-06-14.md

@@ -0,0 +1,40 @@
+# Dogfood: real `builtin:claude` agent + `run resume --drive` (2026-06-14)
+
+A live dogfood run with a REAL external agent (`CW_AGENT_COMMAND=builtin:claude`, the
+bundled read-only claude wrapper). The model ran in the agent's own process; CW
+spawned it and recorded the attested output — CW holds no API key and imports no
+model SDK. This run had two purposes and delivered both: it confirmed the real-agent
+delegation path works end to end, and — because it exercised the **CLI** rather than
+the unit-test function path — it **caught a real shipped bug** in `run resume --drive`.
+
+## What ran
+
+- `cw run architecture-review --drive --once --repo <tmp> --question "…"` with a real
+  `builtin:claude` agent: **1 worker completed** end-to-end with zero hand-written
+  result.md — the worker's `result.md` was produced by real claude, passed the
+  evidence-gated acceptance, and a `report.md` (7.5 KB, "# Architecture Review …")
+  + 3 state commits were written. The real-agent path (spawn → attested output →
+  evidence gate → commit) works.
+- Run: `architecture-review-20260614T104416Z-upkor2`, status `in-progress` (1/14)
+  after the single `--once` step.
+
+## The bug it caught (and the fix)
+
+Resuming the partway run with `cw run resume <id> --drive` failed:
+`cw: Workflow app not found: resume`. The `run` command's early `--drive` branch
+(the `cw run <app> --drive` one-command form) intercepted the invocation *before* the
+subcommand switch, so the `resume` keyword was misread as an app name and never
+reached the `runResume` continuation shipped in #155.
+
+The A1 unit smoke (`run-resume-drive-smoke`) had tested `runResume()` **directly**, so
+it never exercised the CLI dispatch — only a real CLI run surfaced it. Fixed by
+guarding the early app-drive route so a leading run-registry subcommand keyword
+(resume/show/export/…) falls through to the switch; `run-resume-drive-smoke` now drives
+`cw run resume <id> --drive` through the actual CLI and asserts it routes to the verb,
+plus a regression guard that `run <app> --drive` still routes to the app drive.
+
+## Takeaway
+
+Unit tests that call the capability function directly can miss CLI-dispatch bugs.
+Every both-surface verb that adds a flag wants at least one test through the real CLI
+argv path, not just the exported function.

package/docs/durable-state-and-locking.7.md

@@ -111,3 +111,8 @@ Migration DAG with reversible edges (v0.1.45), capability auto-discovery (v0.1.4
 ## Fast Architecture Review (v0.1.80)
 
 Adds the opt-in fast architecture-review lane: scoped JSONL source contexts, diff-aware exports, reusable Map and Assess results, measurable wrapper metrics, actionable background full-review handoff, and userland model policy flags for routing fast/strong workers without changing the full review contract.
+
+## Deterministic Tombstone Hash (v0.1.81)
+
+The reclamation tombstone's freed-manifest is now path-sorted before it feeds `tombstoneHash`, so the same freed set always yields the same hash regardless of filesystem enumeration order. This removes a non-determinism from the write-ahead chain (v0.1.39/v0.1.40), keeping the per-run tombstone hash-chain replayable and stable across hosts. Atomicity, locking, and the durable re-point seam are unchanged. v0.1.81 also adds import-time refusal (`CW_REQUIRE_ARCHIVE_INTEGRITY=1`) and restore-time trust-audit re-proving — see run-registry-control-plane(7).
+_No changes in v0.1.82._

package/docs/evidence-adoption-reasoning-chain.7.md

@@ -274,3 +274,6 @@ Migration DAG with reversible edges (v0.1.45), capability auto-discovery (v0.1.4
 ## Fast Architecture Review (v0.1.80)
 
 Adds the opt-in fast architecture-review lane: scoped JSONL source contexts, diff-aware exports, reusable Map and Assess results, measurable wrapper metrics, actionable background full-review handoff, and userland model policy flags for routing fast/strong workers without changing the full review contract.
+
+_No changes to the Evidence Adoption Reasoning Chain surface in v0.1.81. The v0.1.81 trust-audit `computeEventHash` fix hardens the underlying audit records this chain links to by reference, but the derived reasoning view, its commands, and its eval gates are unchanged._
+_No changes in v0.1.82._

package/docs/execution-backends.7.md

@@ -304,3 +304,6 @@ Migration DAG with reversible edges (v0.1.45), capability auto-discovery (v0.1.4
 ## Fast Architecture Review (v0.1.80)
 
 Adds the opt-in fast architecture-review lane: scoped JSONL source contexts, diff-aware exports, reusable Map and Assess results, measurable wrapper metrics, actionable background full-review handoff, and userland model policy flags for routing fast/strong workers without changing the full review contract.
+
+_No changes to the execution-backends surface in v0.1.81._
+_No behavioral change in v0.1.82 (the delegated child programs moved from inline `node -e` strings to `scripts/children/`; spawn argv and shell:false behavior are byte-identical)._

package/docs/index.md

@@ -7,6 +7,7 @@ Read these in order when you are new to CW:
 3. [Workflow App framework](workflow-app-framework.7.md) - userland app manifests, entrypoints, compatibility, and validation.
 4. [Sandbox Profiles](sandbox-profiles.7.md) - named worker policy contracts for read/write/execute/network/env handling.
 5. [Security / Trust Hardening](security-trust-hardening.7.md) - audit records, provenance, sandbox attestations, and acceptance rationale.
+   - [Trust Model & Limitations](trust-model.md) - what the ed25519 + hash-chain tamper-evidence proves and, honestly, what it does **not** (the single-keyholder ceiling). Read this before relying on a green verdict.
 6. [Multi-Agent Runtime Core](multi-agent-runtime-core.7.md) - first-class MultiAgentRun, roles, groups, memberships, fanout, fanin, and lifecycle state.
 7. [Coordinator / Blackboard](coordinator-blackboard.7.md) - shared topics, messages, context frames, artifact refs, snapshots, decisions, conflicts, and fanin evidence.
 8. [Multi-Agent Topologies](multi-agent-topologies.7.md) - official map-reduce, debate, and judge-panel recipes built on multi-agent and blackboard records.

package/docs/launch/launch-kit.md

@@ -9,7 +9,7 @@ Everything leads with the 30-second `npx cool-workflow demo tamper` proof.
 ## ✅ FINAL — Show HN (copy-paste ready)
 
 **Pre-flight (do these first):**
-1. Record the demo GIF: `vhs plugins/cool-workflow/docs/launch/demo.tape` → swap it into the README hero (replace the fenced output block with the GIF).
+1. Record the demo GIF: `vhs plugins/cool-workflow/docs/launch/demo.tape` → add it to the README hero (insert the GIF near the badges/intro).
 2. Confirm on a clean machine: `npx cool-workflow demo tamper` runs and prints `VERDICT: tamper-evidence holds ✓`.
 3. Post during US morning (HN traffic peak); reply to the first comment with the npm + provenance link.
 
@@ -34,25 +34,33 @@ agent you configure (claude -p, codex exec, an HTTP endpoint) and never embeds a
 model SDK or holds an API key. What it owns is the audit trail: each agent hop's
 reported usage is signed (ed25519) and appended to a hash-chained ledger, so
 editing any record — or even recomputing its local hash to cover the edit — breaks
-the chain downstream. You re-verify a finished run offline, with only the public
-key. No telemetry service to trust or breach.
+the chain downstream. You re-verify a finished run offline — no telemetry service
+to trust or breach.
 
 30-second proof, no install:
 
   npx cool-workflow demo tamper
 
 It builds a real signed ledger, forges it two ways (flip a verdict + re-seal its
-hash; inflate reported tokens + reuse the signature), and shows both caught. On a
-real run, `cw telemetry verify <run>` does the same against what's on disk.
+hash; inflate reported tokens + reuse the signature), and catches both offline with
+only the public key. On a real run, `cw telemetry verify <run>` re-proves the
+recorded ledger on disk — recomputing the chain so any later edit to a verdict or
+usage digest is caught; add `--pubkey <public.pem>` to re-run each attested hop's
+signature check offline too. I keep an
+honest trust-model doc (what it does and does NOT prove, incl. the single-keyholder
+ceiling): https://github.com/coo1white/cool-workflow/blob/main/plugins/cool-workflow/docs/trust-model.md
 
 Also: concurrent parallel() phases with declared collapse semantics (collect-all +
 kill-on-timeout — 16 agents with a forced hang/crash/dirty-return finish without
 deadlock and replay who-passed-who-failed), per-task output-schema gates, token
-budgets enforced against attested usage, and a one-way executor boundary welded
+budgets enforced against the host's recorded usage (opt-in gate fails closed on
+unattested telemetry), and a one-way executor boundary welded
 into the type system (a callable that could reach a model API fails `npm run
-build`). Zero runtime deps, BSD-2, published to npm with provenance.
+build`). Zero runtime deps, BSD-2, published to npm with provenance. Ships generated
+plugin manifests for 5 agent platforms (claude, codex, agents, gemini, opencode);
+`npm run manifest:load-check` boots all five from one source of truth.
 
-It's early (v0.1.79) — I'd genuinely like to hear where the "delegate, prove,
+It's early (v0.1.81) — I'd genuinely like to hear where the "delegate, prove,
 replay" model breaks down for your workflows.
 
 npm: https://www.npmjs.com/package/cool-workflow
@@ -64,8 +72,8 @@ npm: https://www.npmjs.com/package/cool-workflow
 
 > Cool Workflow is an auditable control-plane for multi-agent workflows. It
 > *delegates* model execution — never embeds it — and makes every recorded agent
-> telemetry verdict tamper-evident: anyone can re-verify a run offline with only a
-> public key.
+> telemetry verdict tamper-evident: anyone can re-verify a run's integrity offline,
+> and check the ed25519 attribution with the public key alone.
 
 ## Elevator (2 sentences)
 
@@ -94,8 +102,8 @@ npm: https://www.npmjs.com/package/cool-workflow
 > holds an API key. What it *does* own is the audit trail: each agent hop's reported
 > usage is signed (ed25519) and appended to a hash-chained ledger, so editing any
 > record — or even recomputing its local hash to cover the edit — breaks the chain
-> downstream. You can re-verify a finished run with only the public key, no network,
-> no trusted server.
+> downstream. You can re-verify a finished run offline — no network, no trusted
+> server.
 >
 > The 30-second proof, no install:
 >
@@ -104,18 +112,23 @@ npm: https://www.npmjs.com/package/cool-workflow
 > ```
 >
 > It builds a real signed ledger, forges it two ways (flip a verdict + re-seal its
-> hash; inflate reported tokens + reuse the signature), and shows both forgeries
-> caught offline. On a real run, `cw telemetry verify <run>` does the same against
-> what's on disk.
+> hash; inflate reported tokens + reuse the signature), and catches both offline with
+> only the public key. On a real run, `cw telemetry verify <run>` re-proves the
+> recorded ledger on disk — recomputing the chain so any later edit to a verdict or
+> usage digest is caught; add `--pubkey <public.pem>` to re-run each attested hop's
+> signature check offline too. I keep an
+> honest [trust model & limitations](https://github.com/coo1white/cool-workflow/blob/main/plugins/cool-workflow/docs/trust-model.md)
+> doc, including the single-keyholder ceiling.
 >
 > Other things it does: concurrent `parallel()` phases with declared collapse
 > semantics (collect-all + kill-on-timeout — 16 agents with a forced hang/crash/
 > dirty-return finish without deadlock and replay "who passed/who failed"), per-task
-> output-schema gates, token budgets enforced against attested usage, and a one-way
+> output-schema gates, token budgets enforced against the host's recorded usage
+> (an opt-in gate fails closed on unattested telemetry), and a one-way
 > executor boundary welded into the type system (a callable that could reach a model
 > API fails `npm run build`).
 >
-> Runs anywhere Node runs; `dist/` is committed; BSD-2. It's early (v0.1.79) and I'd
+> Runs anywhere Node runs; `dist/` is committed; BSD-2. It's early (v0.1.81) and I'd
 > genuinely like to hear where the "delegate, prove, replay" model breaks down for
 > your workflows.
 >
@@ -134,8 +147,9 @@ catches both offline with only the public key. A control-plane that delegates
 model execution but can still prove the bill is real.
 
 3/ Also: concurrent batches that don't deadlock when an agent hangs, schema-gated
-outputs, token budgets vs *attested* usage, and a red line (never call a model
-API) enforced at compile time. Zero deps, BSD-2.
+outputs, token budgets vs the host's recorded usage (attested-telemetry gate is
+opt-in), and a red line (never call a model API) enforced at compile time. Zero
+deps, BSD-2.
 → https://github.com/coo1white/cool-workflow
 
 ---
@@ -146,20 +160,29 @@ API) enforced at compile time. Zero deps, BSD-2.
   reported usage. The thing that *spends the money* is not the thing that *keeps
   the books* — the property auditors require everywhere except, so far, agent
   infra.
-- **Offline, public-key verification.** No telemetry service to trust or breach.
-  The record proves its own integrity; the verifier needs only the public key.
+- **Offline verification.** No telemetry service to trust or breach. The record
+  proves its own integrity offline — re-proving the chain needs no key at all — and
+  the ed25519 attribution checks against the public key alone.
 - **Replayable, not just logged.** CW breaks at dispatch and writes to disk, so a
   run replays deterministically — "who passed / who failed" is reconstructable, not
-  a scrollback of a fused process.
+  a scrollback of a fused process. A finished run is portable and self-proving:
+  `cw run inspect-archive <archive>` re-proves every file digest, the manifest, and
+  the whole-archive hash without importing it; `cw run import` then
+  `cw run verify-import <run-id>` restores it and re-proves the restored digests +
+  telemetry chain — a tampered archive is caught before it is trusted.
 - **Fail-closed by default where it counts.** Schema mismatch parks the hop;
   unverifiable usage can be refused (opt-in); an empty-capture result can't be
   presented as a clean commit.
+- **Cross-vendor, and it actually boots.** One source manifest
+  (`manifest/plugin.manifest.json`) generates Claude / Codex / Gemini / OpenCode /
+  agents adapters, and `npm run manifest:load-check` boots all five (184 tools each)
+  — the neutrality moat is executable, not aspirational.
 
 ## Assets to capture before posting
 
 - [ ] **Demo GIF** — reproducible, no manual screen-recording: `vhs
       plugins/cool-workflow/docs/launch/demo.tape` → `docs/launch/demo-tamper.gif`,
-      then swap it into the README hero (replace the fenced output block). The
+      then add it to the README hero (insert it near the badges/intro). The
       ✗ DETECTED lines are the hook.
 - [ ] Confirm `npx cool-workflow demo tamper` works from a clean machine (no clone).
 - [ ] Pin the npm version badge / release + provenance link in the first comment.

package/docs/launch/pre-launch-checklist.md

@@ -1,26 +1,20 @@
 # Pre-Launch Checklist — Cool Workflow Show HN
 
-Tick top to bottom; when it's done, post. The one non-negotiable gate is ③.
+Tick top to bottom; when it's done, post. The one non-negotiable gate is ②.
 Copy for the post itself lives in [launch-kit.md](launch-kit.md) (the **✅ FINAL**
 block).
 
-## ① Fix the machine (prerequisite)
-
-- [ ] **Reboot the Mac** — clears the leaked ptys (`kern.tty.ptmx_max` was 511 with
-      527 allocated), so Terminal / VS Code can spawn shells again. Required before
-      the verification below.
-
-## ② Prepare assets (optional, recommended)
+## ① Prepare assets (optional, recommended)
 
 - [ ] Install [vhs](https://github.com/charmbracelet/vhs) (`brew install vhs`).
 - [ ] Record the GIF: `vhs plugins/cool-workflow/docs/launch/demo.tape` →
       `docs/launch/demo-tamper.gif`.
-- [ ] Swap it into the README hero (replace the fenced demo output block with
-      `![demo](plugins/cool-workflow/docs/launch/demo-tamper.gif)`), commit + push.
+- [ ] Add it to the README hero (insert
+      `![demo](plugins/cool-workflow/docs/launch/demo-tamper.gif)` near the badges/intro), commit + push.
   > Shippable without the GIF — the README's text `✗ DETECTED` hook already stands;
   > the GIF is upside, not a blocker.
 
-## ③ Verify — the make-or-break gate (do not skip)
+## ② Verify — the make-or-break gate (do not skip)
 
 - [ ] On a **clean machine / fresh terminal**: `npx cool-workflow demo tamper`
       prints `VERDICT: tamper-evidence holds ✓`.
@@ -28,20 +22,26 @@ block).
   > non-negotiable check.
 - [ ] Sanity: `npx cool-workflow quickstart architecture-review --repo . --question "risks?"`
       → `status: blocked` with no agent configured (fails closed, no crash).
+- [ ] Resumable sanity: `cw quickstart architecture-review --resume` advances one step
+      then stops; `cw run resume <run-id> --drive` continues a stopped run — proving
+      runs break at dispatch and replay from disk.
 
-## ④ Post (US morning, ~9–11am ET is peak)
+## ③ Post (US morning, ~9–11am ET is peak)
 
 - [ ] Open the **✅ FINAL** block in [launch-kit.md](launch-kit.md).
 - [ ] HN title: `Show HN: Cool Workflow – tamper-evident telemetry for agent pipelines (npx demo)`
 - [ ] URL field: `https://github.com/coo1white/cool-workflow`
 - [ ] Immediately after posting, paste the FINAL "first comment" as the first reply.
 
-## ⑤ First hour (decides the outcome)
+## ④ First hour (decides the outcome)
 
 - [ ] Watch and reply fast — early engagement weighs most on HN.
 - [ ] On the "single key holder / no second party" critique (the audit flagged it
       too): concede it honestly and frame it as exactly why you're looking for early
       integration partners. **Turn the critique into an invitation; don't argue.**
+  > The canned, linkable answer is already written: [docs/trust-model.md](../trust-model.md)
+  > states the ceiling plainly (integrity ≠ source honesty; one party holding both
+  > roles; full local re-chain) and frames the partner ask. Link it; don't re-argue it.
 - [ ] No vote-rigging, no asking friends to upvote, no deleting critical comments —
       HN's anti-abuse will sink the post.
 
@@ -49,5 +49,5 @@ block).
 
 ### Go / no-go
 
-> If **③ — `npx cool-workflow demo tamper` prints `✓` on a clean machine** — passes,
+> If **② — `npx cool-workflow demo tamper` prints `✓` on a clean machine** — passes,
 > you can post. Everything else is upside.

package/docs/multi-agent-cli-mcp-surface.7.md

@@ -269,3 +269,8 @@ Migration DAG with reversible edges (v0.1.45), capability auto-discovery (v0.1.4
 ## Fast Architecture Review (v0.1.80)
 
 Adds the opt-in fast architecture-review lane: scoped JSONL source contexts, diff-aware exports, reusable Map and Assess results, measurable wrapper metrics, actionable background full-review handoff, and userland model policy flags for routing fast/strong workers without changing the full review contract.
+
+## New Both-Surface Verbs (v0.1.81)
+
+v0.1.81 adds `audit verify` (`cw_audit_verify`) and `run inspect-archive` (`cw_run_inspect_archive`) — both declared once in the capability registry and exposed identically on the CLI and MCP, fail-closed (non-zero exit / `ok:false` on an unverified chain or a tampered archive).
+_No changes in v0.1.82._

package/docs/multi-agent-eval-replay-harness.7.md

@@ -306,3 +306,6 @@ Migration DAG with reversible edges (v0.1.45), capability auto-discovery (v0.1.4
 ## Fast Architecture Review (v0.1.80)
 
 Adds the opt-in fast architecture-review lane: scoped JSONL source contexts, diff-aware exports, reusable Map and Assess results, measurable wrapper metrics, actionable background full-review handoff, and userland model policy flags for routing fast/strong workers without changing the full review contract.
+
+_No changes to the multi-agent eval/replay harness in v0.1.81 (the multi-agent-eval module was carved into behavior-preserving siblings; replay output is byte-identical)._
+_v0.1.82 — replay now RE-DERIVES the projection from the raw captured state instead of copying the baseline, so a nondeterministic projection is caught instead of silently passing; a new regression smoke (including an intrinsic-nondeterminism case) proves the moat has teeth._

package/docs/multi-agent-operator-ux.7.md

@@ -318,3 +318,6 @@ Migration DAG with reversible edges (v0.1.45), capability auto-discovery (v0.1.4
 ## Fast Architecture Review (v0.1.80)
 
 Adds the opt-in fast architecture-review lane: scoped JSONL source contexts, diff-aware exports, reusable Map and Assess results, measurable wrapper metrics, actionable background full-review handoff, and userland model policy flags for routing fast/strong workers without changing the full review contract.
+
+_No changes to the multi-agent operator UX surface in v0.1.81 (the operator-ux module was carved into behavior-preserving siblings; output is byte-identical)._
+_No changes in v0.1.82._

package/docs/multi-agent-trust-policy-audit.7.md

@@ -115,6 +115,32 @@ Human output includes stable panels:
 - Policy Violations
 - Next Action
 
+## Verify (fail-closed)
+
+`audit summary` embeds an `integrity` field but is a *reader* — it always exits 0,
+so it cannot gate a script. `audit verify` is the gate:
+
+```bash
+node scripts/cw.js audit verify <run-id>        # exit 1 if the chain is forged
+node scripts/cw.js audit verify <run-id> --json
+```
+
+It re-proves the run's trust-audit hash chain offline: it recomputes every event
+hash from genesis, checks `prevEventHash` linkage, and catches the unchained-event
+forgery (an `eventHash`-less line slipped into a chained log to be waved through as
+"legacy"). The JSON reports `present`, `verified`, `eventCount`, `chained`,
+`unchained`, `corruptLines`, and `failedChecks[]`.
+
+Exit-code contract (the peer of `telemetry verify`):
+
+- ANY **unverified** chain exits **1** — forged / edited / truncated / unchained-injected,
+  *and* a fully-corrupt log (every line unparseable, which reports `present:false` but
+  `verified:false`). The gate keys on `verified`, not `present`, so the most severe
+  tamper — garbling the whole log — cannot escape by looking "absent". So
+  `cw audit verify <run> && deploy` stops on tampering.
+- Only a truly **absent / empty** chain is `verified:true` / exit **0** — a run with
+  no audit log (or a blank one) has nothing to prove (no false-red).
+
 ## MCP
 
 MCP parity tools:
@@ -128,6 +154,7 @@ MCP parity tools:
 The older audit tools remain available:
 
 - `cw_audit_summary`
+- `cw_audit_verify` — fail-closed re-prove of the trust-audit hash chain (peer of `cw_telemetry_verify`)
 - `cw_audit_worker`
 - `cw_audit_provenance`
 - `cw_audit_attest`

package/docs/node-snapshot-diff-replay.7.md

@@ -139,3 +139,6 @@ Migration DAG with reversible edges (v0.1.45), capability auto-discovery (v0.1.4
 ## Fast Architecture Review (v0.1.80)
 
 Adds the opt-in fast architecture-review lane: scoped JSONL source contexts, diff-aware exports, reusable Map and Assess results, measurable wrapper metrics, actionable background full-review handoff, and userland model policy flags for routing fast/strong workers without changing the full review contract.
+
+_No changes to node-snapshot diff/replay in v0.1.81._
+_No behavioral change in v0.1.82 (the node projection field set was unified into one source of truth; snapshot/replay digests are byte-identical)._

package/docs/observability-cost-accounting.7.md

@@ -198,3 +198,6 @@ Migration DAG with reversible edges (v0.1.45), capability auto-discovery (v0.1.4
 ## Fast Architecture Review (v0.1.80)
 
 Adds the opt-in fast architecture-review lane: scoped JSONL source contexts, diff-aware exports, reusable Map and Assess results, measurable wrapper metrics, actionable background full-review handoff, and userland model policy flags for routing fast/strong workers without changing the full review contract.
+
+_No changes to the observability + cost-accounting surface in v0.1.81 (the observability module was carved into behavior-preserving siblings; output is byte-identical)._
+_No changes in v0.1.82._

package/docs/project-index.md

@@ -1,15 +1,15 @@
 # Cool Workflow Project Index
 
-Generated from the current repository code on 2026-06-13 by `npm run sync:project-index`.
+Generated from the current repository code on 2026-06-15 by `npm run sync:project-index`.
 
 ## Snapshot
 
 - Package: `cool-workflow`
-- Version: `0.1.80`
-- Source modules: `58`
+- Version: `0.1.82`
+- Source modules: `61`
 - Workflow apps: `7`
-- Docs: `47`
-- Smoke tests: `75`
+- Docs: `49`
+- Smoke tests: `87`
 - Repository: https://github.com/coo1white/cool-workflow
 
 ## Architecture
@@ -82,17 +82,19 @@ multi-agent host -> topology -> blackboard/coordinator
 
 - [agent-config.ts](../src/agent-config.ts)
 - [capability-core.ts](../src/capability-core.ts)
-- [capability-dispatcher.ts](../src/capability-dispatcher.ts)
 - [capability-registry.ts](../src/capability-registry.ts)
 - [collaboration.ts](../src/collaboration.ts)
+- [compare.ts](../src/compare.ts)
 - [contract-migration.ts](../src/contract-migration.ts)
 - [drive.ts](../src/drive.ts)
 - [evidence-grounding.ts](../src/evidence-grounding.ts)
 - [evidence-reasoning.ts](../src/evidence-reasoning.ts)
 - [execution-backend.ts](../src/execution-backend.ts)
+- [gates.ts](../src/gates.ts)
 - [multi-agent-eval.ts](../src/multi-agent-eval.ts)
 - [multi-agent-operator-ux.ts](../src/multi-agent-operator-ux.ts)
 - [multi-agent-trust.ts](../src/multi-agent-trust.ts)
+- [node-projection.ts](../src/node-projection.ts)
 - [node-snapshot.ts](../src/node-snapshot.ts)
 - [observability.ts](../src/observability.ts)
 - [reclamation.ts](../src/reclamation.ts)
@@ -107,6 +109,7 @@ multi-agent host -> topology -> blackboard/coordinator
 - [telemetry-attestation.ts](../src/telemetry-attestation.ts)
 - [telemetry-demo.ts](../src/telemetry-demo.ts)
 - [telemetry-ledger.ts](../src/telemetry-ledger.ts)
+- [validation.ts](../src/validation.ts)
 - [verifier-registry.ts](../src/verifier-registry.ts)
 - [workbench-host.ts](../src/workbench-host.ts)
 - [workbench.ts](../src/workbench.ts)
@@ -167,7 +170,9 @@ multi-agent host -> topology -> blackboard/coordinator
 - [State Explosion Management](state-explosion-management.7.md)
 - [STATE-NODE(7)](state-node.7.md)
 - [Team Collaboration](team-collaboration.7.md)
+- [Trust Model & Limitations](trust-model.md)
 - [Unix-Inspired Workflow Principles](unix-principles.md)
+- [Vendor Manifest Loadability](vendor-manifest-loadability.7.md)
 - [VERIFIER-GATED-COMMIT(7)](verifier-gated-commit.7.md)
 - [Web / Desktop Workbench](web-desktop-workbench.7.md)
 - [WORKER-ISOLATION(7)](worker-isolation.7.md)
@@ -181,17 +186,20 @@ Smoke tests mirror the public contracts. The high-signal suites are:
 - [architecture-review-fast-automation-smoke.js](../test/architecture-review-fast-automation-smoke.js)
 - [architecture-review-fast-smoke.js](../test/architecture-review-fast-smoke.js)
 - [artifact-integrity-smoke.js](../test/artifact-integrity-smoke.js)
+- [audit-verify-smoke.js](../test/audit-verify-smoke.js)
 - [backend-registry-smoke.js](../test/backend-registry-smoke.js)
 - [block-unapproved-tag-smoke.js](../test/block-unapproved-tag-smoke.js)
 - [candidate-scoring-smoke.js](../test/candidate-scoring-smoke.js)
 - [canonical-workflow-apps-smoke.js](../test/canonical-workflow-apps-smoke.js)
 - [claude-p-agent-wrapper-smoke.js](../test/claude-p-agent-wrapper-smoke.js)
+- [cli-jsonmode-parity-smoke.js](../test/cli-jsonmode-parity-smoke.js)
 - [cli-mcp-parity-smoke.js](../test/cli-mcp-parity-smoke.js)
 - [concurrent-failure-semantics-smoke.js](../test/concurrent-failure-semantics-smoke.js)
 - [concurrent-workflow-dsl-smoke.js](../test/concurrent-workflow-dsl-smoke.js)
 - [contract-migration-tooling-smoke.js](../test/contract-migration-tooling-smoke.js)
 - [control-plane-scheduling-smoke.js](../test/control-plane-scheduling-smoke.js)
 - [coordinator-blackboard-smoke.js](../test/coordinator-blackboard-smoke.js)
+- [det-ids-b-smoke.js](../test/det-ids-b-smoke.js)
 - [dogfood-release-smoke.js](../test/dogfood-release-smoke.js)
 - [durable-atomic-write-smoke.js](../test/durable-atomic-write-smoke.js)
 - [end-to-end-demo-smoke.js](../test/end-to-end-demo-smoke.js)
@@ -201,8 +209,11 @@ Smoke tests mirror the public contracts. The high-signal suites are:
 - [evidence-adoption-reasoning-smoke.js](../test/evidence-adoption-reasoning-smoke.js)
 - [evidence-content-extraction-smoke.js](../test/evidence-content-extraction-smoke.js)
 - [execution-backends-smoke.js](../test/execution-backends-smoke.js)
+- [freebsd-audit-fixes-smoke.js](../test/freebsd-audit-fixes-smoke.js)
+- [h7-custom-profile-persist-smoke.js](../test/h7-custom-profile-persist-smoke.js)
 - [mcp-app-surface-smoke.js](../test/mcp-app-surface-smoke.js)
 - [multi-agent-cli-mcp-surface-smoke.js](../test/multi-agent-cli-mcp-surface-smoke.js)
+- [multi-agent-eval-determinism-regression-smoke.js](../test/multi-agent-eval-determinism-regression-smoke.js)
 - [multi-agent-eval-replay-harness-smoke.js](../test/multi-agent-eval-replay-harness-smoke.js)
 - [multi-agent-eval-replay-smoke.js](../test/multi-agent-eval-replay-smoke.js)
 - [multi-agent-operator-ux-smoke.js](../test/multi-agent-operator-ux-smoke.js)
@@ -229,7 +240,10 @@ Smoke tests mirror the public contracts. The high-signal suites are:
 - [run-export-restore-rerun-smoke.js](../test/run-export-restore-rerun-smoke.js)
 - [run-export-restore-resume-smoke.js](../test/run-export-restore-resume-smoke.js)
 - [run-fixture-compat-smoke.js](../test/run-fixture-compat-smoke.js)
+- [run-import-tamper-failclosed-smoke.js](../test/run-import-tamper-failclosed-smoke.js)
+- [run-inspect-archive-smoke.js](../test/run-inspect-archive-smoke.js)
 - [run-registry-control-plane-smoke.js](../test/run-registry-control-plane-smoke.js)
+- [run-resume-drive-smoke.js](../test/run-resume-drive-smoke.js)
 - [run-retention-reclamation-smoke.js](../test/run-retention-reclamation-smoke.js)
 - [sandbox-profile-smoke.js](../test/sandbox-profile-smoke.js)
 - [schedule-routine-daemon-smoke.js](../test/schedule-routine-daemon-smoke.js)
@@ -246,8 +260,11 @@ Smoke tests mirror the public contracts. The high-signal suites are:
 - [telemetry-fail-closed-smoke.js](../test/telemetry-fail-closed-smoke.js)
 - [telemetry-ledger-smoke.js](../test/telemetry-ledger-smoke.js)
 - [telemetry-metrics-coverage-smoke.js](../test/telemetry-metrics-coverage-smoke.js)
+- [telemetry-verify-signatures-smoke.js](../test/telemetry-verify-signatures-smoke.js)
 - [token-budget-enforcement-smoke.js](../test/token-budget-enforcement-smoke.js)
+- [vendor-manifest-load-smoke.js](../test/vendor-manifest-load-smoke.js)
 - [verifier-gated-commit-smoke.js](../test/verifier-gated-commit-smoke.js)
+- [verify-import-audit-chain-smoke.js](../test/verify-import-audit-chain-smoke.js)
 - [web-desktop-workbench-smoke.js](../test/web-desktop-workbench-smoke.js)
 - [worker-isolation-smoke.js](../test/worker-isolation-smoke.js)
 - [worker-retry-count-smoke.js](../test/worker-retry-count-smoke.js)

package/docs/real-execution-backends.7.md

@@ -146,3 +146,6 @@ Migration DAG with reversible edges (v0.1.45), capability auto-discovery (v0.1.4
 ## Fast Architecture Review (v0.1.80)
 
 Adds the opt-in fast architecture-review lane: scoped JSONL source contexts, diff-aware exports, reusable Map and Assess results, measurable wrapper metrics, actionable background full-review handoff, and userland model policy flags for routing fast/strong workers without changing the full review contract.
+
+_No changes to the real execution backends in v0.1.81._
+_No behavioral change in v0.1.82 (delegated child programs extracted to `scripts/children/`; spawn behavior byte-identical)._

package/docs/release-and-migration.7.md

@@ -284,3 +284,8 @@ Migration DAG with reversible edges (v0.1.45), capability auto-discovery (v0.1.4
 ## Fast Architecture Review (v0.1.80)
 
 Adds the opt-in fast architecture-review lane: scoped JSONL source contexts, diff-aware exports, reusable Map and Assess results, measurable wrapper metrics, actionable background full-review handoff, and userland model policy flags for routing fast/strong workers without changing the full review contract.
+
+## Migration Compatibility (v0.1.81)
+
+v0.1.81 is additive: every change is a new flag/verb/env (`audit verify`, `run inspect-archive`, `verify-import --strict`, `CW_REQUIRE_ARCHIVE_INTEGRITY`, `quickstart --resume`, `run resume --drive`) or an internal behavior-preserving carve. Run-state schema, existing outputs, files, and exit codes are byte-identical, so runs and archives from prior versions load and verify unchanged. No migration action is required.
+_No changes in v0.1.82._

package/docs/release-tooling.7.md

@@ -133,8 +133,10 @@ inherits the agent's own credentials, and imports no model SDK — the red line.
 ```bash
 # check only (gate + independent review, no mutation):
 node plugins/cool-workflow/scripts/release-flow.js --check
-# cut a tag once review is green:
-node plugins/cool-workflow/scripts/release-flow.js --cut --version 0.1.77 [--push]
+# cut a tag once review is green (when --push, also creates the GitHub Release):
+node plugins/cool-workflow/scripts/release-flow.js --cut --version 0.1.77 [--push] [--no-release]
+# backfill / re-create the GitHub Release for an already-pushed tag (no gate/cut):
+node plugins/cool-workflow/scripts/release-flow.js --release --version 0.1.77 [--soft]
 ```
 
 The per-platform difference is config, not code — set the reviewer agent:
@@ -152,6 +154,34 @@ also get generated MCP manifests (`.gemini-plugin/`, `.opencode-plugin/`) so the
 `cw_*` tools are available as MCP tools in those hosts. The verdict path
 (`.cw-release/review-<sha>.verdict`) and the tag-push CI backstop are unchanged.
 
+### GitHub Release finishing step
+
+A `--cut --push` finishes by creating the **GitHub Release** for the tag, and
+`--release --version x.y.z` creates-or-skips one for an already-pushed tag
+(backfill). The notes body is assembled from the `## x.y.z` CHANGELOG section as
+shipped at the tag, the independent reviewer's one-line capability, and a
+"Provenance & audit" footer linking the reviewed commit, the **committed** reviewer
+verdict, the full diff, and the provenance-attested npm version.
+
+This step is **distribution upside, not a correctness gate**: the load-bearing
+artifacts (the tag and the provenance-attested npm publish) already exist when it
+runs. Therefore `gh` is **not** part of the node/git portability floor — it runs
+ONLY in the human `--cut --push` / `--release` paths (never a gate or CI path) and
+is **idempotent** (skips if the Release already exists).
+
+Failure semantics differ by mode: in the **`--cut --push` finishing step** an
+absent/unauthenticated/erroring `gh` **skips with a stderr note and never fails the
+cut** (the tag and npm publish stand) — opt out entirely with `--no-release`. In the
+explicit **`--release` backfill** it **fails closed** (exit 1) with guidance, since
+the operator asked for it directly; add `--soft` to downgrade `--release` to the same
+best-effort skip-not-fail behavior.
+
+Honesty: the notes claim the gated flow ("independent release-reviewer, verdict
+above") **only when a committed `APPROVED` verdict is found at the tag**; backfilling
+an ungated tag emits a neutral caveat instead and warns on stderr — the notes never
+assert a review that isn't there. Test seam: `CW_RELEASE_FLOW_GH_CMD` swaps the `gh`
+binary for a stub (spawned `shell:false`) so the smoke exercises it offline.
+
 0.1.51
 
 0.1.76
@@ -163,3 +193,6 @@ also get generated MCP manifests (`.gemini-plugin/`, `.opencode-plugin/`) so the
 ## Fast Architecture Review (v0.1.80)
 
 Adds the opt-in fast architecture-review lane: scoped JSONL source contexts, diff-aware exports, reusable Map and Assess results, measurable wrapper metrics, actionable background full-review handoff, and userland model policy flags for routing fast/strong workers without changing the full review contract.
+
+_No changes to the release-flow tooling in v0.1.81; this release was cut through the existing gate->review->tag flow._
+_No changes to the release-tooling contract in v0.1.82._