cool-workflow 0.2.4 → 0.2.6

package/docs/agent-framework.md

@@ -1,177 +0,0 @@
-# Workflow App framework
-
-CW is made as an independent agent workflow control-plane.
-
-The aim is to make agent development feel like building inside a platform
-ecosystem. CW gives the runtime, contracts, storage, CLI, MCP bridge, and
-package structure. Developers make workflow apps that keep to those contracts.
-
-The framework is guided by five useful systems rules: small kernel, explicit
-state, pipes you can put together, separate workers, and commits that a verifier
-lets through. See
-[unix-principles.md](unix-principles.md).
-
-## Platform Contract
-
-Every CW workflow keeps to this loop:
-
-```text
-interpret -> act -> observe -> adjust -> checkpoint
-```
-
-The loop maps to real framework operations:
-
-| Loop stage | framework operation | Responsibility |
-| --- | --- | --- |
-| Interpret | `plan()` | Load workflow, check inputs, make tasks |
-| Act | `dispatch()` | Move tasks that can run from pending to running |
-| Observe | `recordResult()` | Read Markdown/JSON-RPC result evidence |
-| Adjust | verifier gates | Check evidence and pick the next phase |
-| Checkpoint | `commitState()` | Take a snapshot of state after important changes |
-
-The v0.1.12 operator UX layer makes read-only summaries over run state:
-human `status`, graph maps, report summaries, resource summaries, and
-fixed next-step suggestions. Scripts can go on using `--json` or
-`--format json`.
-
-The v0.1.13 MCP app surface gives the same runtime operations to agent hosts
-with stable JSON tools: app run, dispatch, worker inspection/output, candidate
-scoring/selection, sandbox profile resolution, verifier-gated commit, and
-operator status/graph/report summaries.
-
-The v0.1.13 canonical app matrix checks and plans the kept userland
-apps with public CLI commands:
-
-```bash
-npm run canonical-apps
-```
-
-The golden path runs the full integration chain from start to end:
-
-```bash
-npm run golden-path
-```
-
-It checks an app, plans a run, dispatches a readonly worker, takes a
-worker-local `cw:result`, scores and picks a candidate, makes a
-verifier-gated commit, and makes a report. See
-[end-to-end-golden-path.7.md](end-to-end-golden-path.7.md).
-
-## Developer Contract
-
-A workflow app defines:
-
-- `id`, `title`, and `summary`
-- `schemaVersion`, app `version`, compatibility, and metadata when using the
-  first-class Workflow App framework contract
-- needed and repeated inputs
-- phase order
-- agent tasks
-- artifact tasks
-- concurrency limits
-- evidence requirements
-- sandbox profile hints
-
-Example:
-
-```js
-const {
-  defineWorkflowApp,
-  workflow,
-  phase,
-  agent,
-  artifact,
-  input
-} = require("../dist/workflow-app-framework");
-
-const inputs = [input("repo", { type: "path", required: true })];
-
-module.exports = defineWorkflowApp({
-  schemaVersion: 1,
-  id: "example-review",
-  title: "Example Review",
-  summary: "Review a repository with evidence.",
-  version: "0.1.0",
-  inputs,
-  sandboxProfiles: ["readonly"],
-  compatibility: {
-    minVersion: "0.1.9"
-  },
-  workflow: workflow({
-    id: "example-review",
-    title: "Example Review",
-    inputs,
-    sandboxProfiles: ["readonly"],
-    phases: [
-      phase("Map", [
-        agent("map:system", "Map the system boundaries.", {
-          sandboxProfileId: "readonly"
-        })
-      ]),
-      phase("Verdict", [
-        artifact("verdict", "Write the final evidence-backed verdict.", {
-          requiresEvidence: true,
-          sandboxProfileId: "readonly"
-        })
-      ])
-    ]
-  })
-});
-```
-
-Legacy `module.exports = ({ workflow, phase, agent, artifact }) => workflow(...)`
-files can still be loaded. CW wraps them as compatibility apps with version `0.0.0`
-so workflow files still plan and dispatch. When a canonical app owns the public
-id, compatibility wrappers use explicit ids such as `legacy-research-synthesis`.
-
-## Language Contract
-
-The CW platform is TypeScript:
-
-```text
-src/*.ts -> dist/*.js
-```
-
-Workflow apps are JavaScript modules:
-
-```text
-workflows/*.workflow.js
-apps/<app-id>/app.json
-apps/<app-id>/workflow.js
-```
-
-This is done on purpose. The runtime is strongly typed so it is simple to keep
-up, while workflow scripts can run without `ts-node`.
-
-See [workflow-app-framework.7.md](workflow-app-framework.7.md) for the full app contract,
-the rules for checking, CLI commands, MCP tools, and state/report fields.
-See [mcp-app-surface.7.md](mcp-app-surface.7.md) for the agent-host runtime
-surface over MCP.
-See [operator-ux.7.md](operator-ux.7.md) for the operator inspection surface.
-See [canonical-workflow-apps.7.md](canonical-workflow-apps.7.md) for the
-official app matrix.
-See [end-to-end-golden-path.7.md](end-to-end-golden-path.7.md) for the
-fixed release proof that those parts connect.
-
-## Evidence Contract
-
-Verification and verdict tasks should give back:
-
-````text
-```cw:result
-{
-  "summary": "short summary",
-  "findings": [],
-  "evidence": ["/absolute/path/file.ts:42"]
-}
-```
-````
-
-CW says no to high-priority findings without evidence. This keeps agent work
-nearer to engineering output you can look into than to free talk.
-
-## Boundary
-
-CW is an independent workflow control-plane by COOLWHITE LLC. It puts into effect
-workflows that change, scheduled tasks, local scheduling, routine triggers, state
-checkpoints, and multi-agent verification.

package/docs/designs/handoff-ledger.md

@@ -1,145 +0,0 @@
-# Design — Cross-agent handoff ledger
-
-Status: DRAFT / proposal. Nothing here is built yet. This file ships no
-behavior, no new command, no man-page contract, and changes no existing
-output. It exists so two people (the operator and the reviewer agent) can
-agree on the shape before any code is written.
-
-North Star track: **Track B** (portable, verifiable state — the same
-`run export` → `run restore` recovery story, now used as the channel
-between two agents).
-
-## Goal
-
-Two agents work on two repositories:
-
-- one agent scoped to repo **A** (for example `cool-workflow`),
-- one agent scoped to repo **B** (for example `chime`).
-
-The operator wants them to "share data, review each other, and each be
-able to raise a pull request to the other". In plain terms:
-
-- each side can hand the other a **change proposal**, and
-- each side can hand the other a **review verdict** on a diff or PR,
-- with saved, inspectable, fail-closed state — never a fabricated hand-off.
-
-## The hard constraint (why the obvious design does not work)
-
-The first idea is a shared local folder (for example `~/.chime/handoff/`)
-that both agents read and append to. That only works when both agents run
-on **one machine** with **one filesystem**.
-
-In the operator's setup the two agents run as **two separate cloud
-sessions**. Each session is a fresh, throwaway VM. Two facts follow, and
-the design must respect both:
-
-1. **No shared filesystem.** A file the B-agent writes to `~/.chime/handoff/`
-   in its VM is invisible to the A-agent's VM, and is gone when the session
-   ends. A local folder cannot be the channel.
-2. **Single-repo scope.** Each session's GitHub reach is scoped to one repo
-   at launch (A-agent → repo A, B-agent → repo B). The A-agent cannot read
-   repo B through its GitHub tools, and the reverse is also true. Scope is
-   fixed at launch and cannot be widened mid-session.
-
-The only medium both sessions can durably reach is **git / GitHub**. So the
-ledger is a set of committed files, not a local folder — and the scope wall
-means the hand-off still needs either a shared repo or a human relay for the
-cross-repo step. This document is honest about that; it does not pretend the
-wall is not there.
-
-## What we reuse (no new trust machinery)
-
-CW already has the parts this needs. The design adds a thin verb layer over
-them; it invents no new crypto and no new state format.
-
-- `run export` produces a **verifiable bundle** (file digests, telemetry
-  ledger, trust-audit hash chains).
-- `run restore` **imports fail-closed**: it inspects first, refuses a corrupt
-  or tampered bundle without writing anything, and exits non-zero when the
-  chain does not verify. (`run import` is the exit-0 sibling; the hand-off
-  path must use the fail-closed `restore` contract.)
-- `report verify` checks a run's evidence and citations.
-
-A hand-off entry is therefore just a CW bundle. The receiving side trusts it
-the same way it trusts any restored run: by verification, not by good faith.
-
-## Two verbs
-
-Both live under a single new `cw ledger` verb, so the existing surface is
-untouched and the new behavior is opt-in (POLA). (The name `handoff` was already
-taken by an unrelated collaboration primitive — ownership transfer of a run/task
-— so the cross-agent verb is `ledger`, not `handoff`.) Stage 1 ships as
-`cw ledger propose|review|verify`; see
-[cross-agent-ledger](../cross-agent-ledger.7.md) for the contract.
-
-- **`propose`** — the read-only side writes a structured *change proposal*
-  (title, rationale, target files, suggested diff) as a ledger entry. It does
-  **not** mutate the other repo. The write-capable side picks the entry up,
-  verifies it, and turns it into a **real GitHub pull request**.
-- **`review`** — the reviewing side writes a structured *review verdict*
-  (`APPROVED` / `REJECTED`, findings, the diff or PR it judged) as a ledger
-  entry. The other side surfaces it and can act on it.
-
-This keeps a read-only agent honest: it emits proposals and verdicts as
-**data**, and the write-capable side is the only one that opens PRs. Neither
-side has to be trusted to have mutated the other's code.
-
-## Transports (how an entry actually crosses)
-
-The verbs above produce and consume entries; the transport is how an entry
-moves from one VM to the other. Two are in scope, smallest first.
-
-- **T1 — Human relay (MVP, works today, zero infra).** The producing side
-  prints the entry (a verifiable bundle, or its safe text form) to stdout;
-  the operator carries it to the other session; the consuming side verifies
-  it fail-closed and acts (opens the PR, or records the verdict). This is
-  exactly the loop the operator is already running by hand. It needs no new
-  code beyond a stable print/parse shape.
-- **T2 — Git-as-ledger.** Each entry is committed to a repo under a known
-  path (for example `handoff/<from>-<to>/<id>.bundle`). Because scope is
-  single-repo, this needs one of:
-  - **T2a — a shared handoff repo** both agents are scoped to (cleanest, but
-    the operator must create it and launch both sessions against it), or
-  - **T2b — each side writes to its own repo** and a bridge (the operator, or
-    a scheduled job that *is* scoped to both) moves entries across. The
-    cross-repo read cannot be automatic inside a single scoped session — this
-    is the scope wall, stated plainly, not a gap to be quietly filled.
-
-## Fail-closed rules (non-negotiable)
-
-- An entry that does not verify is **refused**, never acted on. No PR is
-  opened, no verdict is recorded, and the refusal is explicit on stderr with
-  a non-zero exit — the same contract as `run restore`.
-- A proposal is a **suggestion only**. It never edits the target repo by
-  itself; a human-or-agent on the write side always makes the real PR, so the
-  read-only vow of the proposing side holds.
-- stdout stays data (the entry / the machine result); stderr stays
-  diagnostics; a piped run is silent on success. `--json` is stable and
-  decoration-free.
-
-## Non-goals / POLA
-
-- No existing command, output byte, exit code, or file layout changes.
-- No new runtime dependency (zero-dependency red line holds).
-- No vendor-specific logic in core; the verbs move opaque bundles.
-- Nothing ships until its own cycle lands with a test that fails before and
-  passes after, and a `docs/*.7.md` contract page — this design file is not
-  that contract and claims no shipped behavior.
-
-## Suggested rollout (each stage its own reviewed cycle)
-
-0. **This design doc** (no behavior). ← you are here.
-1. **T1 human-relay shape** — a stable, documented print/parse form for a
-   proposal and a verdict, plus a smoke that round-trips one of each and
-   proves a tampered entry is refused.
-2. **`cw ledger propose` / `review`** over `run export` / `restore`, with the
-   fail-closed refusal test.
-3. **T2 git-ledger** (shared-repo first), then optionally a scoped bridge job
-   for T2b.
-
-## Open decisions for the operator
-
-- T2a (shared handoff repo) or T2b (own repos + bridge)? T2a is simpler and
-  should be the default unless a shared repo is not acceptable.
-- Should a verdict be able to **block** a PR merge on the other side, or only
-  advise? Advise-only is the safer default and matches "review as data".

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

@@ -1,40 +0,0 @@
-# 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/launch/launch-kit.md

@@ -1,195 +0,0 @@
-# Launch Kit — Cool Workflow
-
-Copy for announcing CW. The through-line is the one thing no other agent-pipeline
-tool ships: **you can prove the telemetry, offline, with only a public key.**
-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` → 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.
-
-**Title** (exactly — HN strips most formatting):
-
-```
-Show HN: Cool Workflow – tamper-evident telemetry for agent pipelines (npx demo)
-```
-
-**URL field:** `https://github.com/coo1white/cool-workflow`
-
-**First comment (paste right after posting):**
-
-```
-I kept seeing agent-orchestration tools treat the model's self-reported token
-usage and results as ground truth. For anything auditable that's backwards — a
-control-plane that trusts unverified self-reports audits claims, not facts, and a
-forged "green" run looks identical to a real one.
-
-Cool Workflow takes the opposite stance. It DELEGATES model execution to whatever
-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 — 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 three ways (flip a verdict + re-seal its
-hash; inflate reported tokens + reuse the signature; edit a signed finding), and
-catches all three 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 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. 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.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
-```
-
----
-
-## One-liner
-
-> 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's integrity offline,
-> and check the ed25519 attribution with the public key alone.
-
-## Elevator (2 sentences)
-
-> Most agent-pipeline tools log what the model reported and trust it. CW signs and
-> hash-chains every telemetry verdict, so a forged or edited record fails
-> verification — provably, offline — which is what "auditable" has to mean before
-> you let agents touch production work.
-
----
-
-## Show HN
-
-**Title:**
-`Show HN: Cool Workflow – tamper-evident telemetry for agent pipelines (npx demo)`
-
-**Body:**
-
-> I kept seeing agent-orchestration tools treat the model's self-reported token
-> usage and results as ground truth. For anything auditable that's backwards — a
-> control-plane that trusts unverified self-reports audits *claims*, not facts, and
-> a forged "green" run looks identical to a real one.
->
-> Cool Workflow is a small, zero-dependency CLI + MCP runtime that takes the
-> opposite stance. It **delegates** model execution to whatever agent you configure
-> (`claude -p`, `codex exec`, an HTTP endpoint) and never embeds a model SDK or
-> 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 offline — no network, no trusted
-> server.
->
-> The 30-second proof, no install:
->
-> ```
-> npx cool-workflow demo tamper
-> ```
->
-> It builds a real signed ledger, forges it three ways (flip a verdict + re-seal its
-> hash; inflate reported tokens + reuse the signature; edit a signed finding), and
-> catches all three 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 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.81) and I'd
-> genuinely like to hear where the "delegate, prove, replay" model breaks down for
-> your workflows.
->
-> Repo: https://github.com/coo1white/cool-workflow
-> npm: https://www.npmjs.com/package/cool-workflow
-
----
-
-## Short post / tweet thread
-
-1/ Your agent pipeline trusts what the model *says* it did. Cool Workflow proves
-it instead. `npx cool-workflow demo tamper` — 30s, no install:
-
-2/ It builds a real ed25519-signed telemetry ledger, forges it three ways (incl.
-editing a signed finding), and catches all three 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 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
-
----
-
-## Why this matters (the wedge, for a longer post)
-
-- **Separation of duties.** CW never runs the model, yet can verify the executor's
-  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 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 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 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.
-
-## Channels
-
-Hacker News (Show HN), the MCP / agent-tooling communities, r/LocalLLaMA &
-r/MachineLearning (the offline-verification angle), and the npm listing itself
-(keywords already set). Lead every one with the demo command, not the feature
-list.

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

@@ -1,53 +0,0 @@
-# Pre-Launch Checklist — Cool Workflow Show HN
-
-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).
-
-## ① 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`.
-- [ ] 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)
-
-- [ ] On a **clean machine / fresh terminal**: `npx cool-workflow demo tamper`
-      prints `VERDICT: tamper-evidence holds ✓`.
-  > Every click from HN runs this. One crash wastes that traffic. This is the only
-  > 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)
-
-- [ ] 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)
-
-- [ ] 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.
-
----
-
-### Go / no-go
-
-> If **② — `npx cool-workflow demo tamper` prints `✓` on a clean machine** — passes,
-> you can post. Everything else is upside.