cool-workflow 0.2.3 → 0.2.5

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.

package/docs/readme-v0.1.87-full.md

@@ -1,301 +0,0 @@
-<div align="center">
-
-# Cool Workflow
-
-**Point an AI coding agent at a repo, get a saved report with real citations — not a chat message you lose.**
-
-[![CI](https://img.shields.io/github/actions/workflow/status/coo1white/cool-workflow/ci.yml?branch=main&style=flat-square&label=CI)](https://github.com/coo1white/cool-workflow/actions/workflows/ci.yml)
-[![npm](https://img.shields.io/npm/v/cool-workflow?style=flat-square&label=npm&color=cb3837)](https://www.npmjs.com/package/cool-workflow)
-[![downloads](https://img.shields.io/npm/dm/cool-workflow?style=flat-square&label=downloads)](https://www.npmjs.com/package/cool-workflow)
-[![provenance](https://img.shields.io/badge/npm-provenance-3178C6?style=flat-square)](https://www.npmjs.com/package/cool-workflow)
-[![release](https://img.shields.io/github/v/tag/coo1white/cool-workflow?style=flat-square&label=release&color=brightgreen&sort=semver)](https://github.com/coo1white/cool-workflow/tags)
-[![license](https://img.shields.io/badge/license-BSD--2--Clause-blue?style=flat-square)](LICENSE)
-
-<img src="docs/assets/cool-workflow-readme-promo.png" alt="Cool Workflow turns AI agent repo questions into saved, cited, tamper-evident reports." width="100%">
-
-</div>
-
-## What is this, really?
-
-You put a question to an AI coding agent, it gives an answer in the chat, and
-then the answer is gone. Next week you put the same question and have to start
-all over again.
-
-**Cool Workflow (CW) makes that lost question into a kept job.** You point it at
-a code store with a question like *"what are the security risks here?"* It runs
-your AI agent over all the code in ordered steps and puts a **report file** on
-disk — every point backed by an exact `file.js:42` pointer to the line. You are
-able to run it again, give it to others, and even give proof that the report was
-not changed by anyone.
-
-```
-        you ask once                          CW gives you
-   "what are the risks in my repo?"     →   a saved report.md with
-                                              cited findings, repeatable
-```
-
-It does **not** run the AI model itself. You give your own agent (for one, the
-`claude` command line) and CW keeps it working, makes a record of what took
-place, and checks the answer. Take CW as the *project manager*, and your agent
-as the *worker*.
-
-> New to this? You're in the right place — this README is a step-by-step start.
-> Deeper/advanced docs live in the [wiki](https://github.com/coo1white/cool-workflow/wiki).
-
----
-
-## Project rule
-
-CW should stay a small, trusted tool, not a platform.
-
-```text
-ask simple -> run simple -> verify simple -> resume simple
-```
-
-The engineering base is FreeBSD-like: POLA first, fail closed, no silent
-fallback, stdout as data, stderr as diagnostics, and documented stable
-surfaces. The user-facing spirit is close to Homebrew: a small command
-surface, a strong `doctor` check, and clear next steps when a run is
-blocked or a report does not verify.
-
-That means CW should hide orchestration detail behind clear commands,
-keep `.cw/` state open to check, make recovery boring, and prefer a
-small tool that can be trusted over a broad agent platform.
-
----
-
-## What you need
-
-1. **Node.js** (v18+). Make a check with `node --version`.
-2. **An AI agent on the command line.** The most simple is **Claude Code** —
-   after you put it in you will have a `claude` command. Make a check with
-   `claude --version`. (CW also works with `codex`, or any command/HTTP agent —
-   but make your start with `claude`.)
-
-> No agent yet? You are still able to **see CW work** (next part, step 1)
-> without one. The full report needs an agent, because CW never makes a call to
-> a model itself.
-
----
-
-## Quick start (3 steps)
-
-### 1. See it run — no install, no agent, no API key
-
-```bash
-npx cool-workflow demo tamper
-```
-
-This gives proof of CW's chief trick in 30 seconds (more on that
-[below](#can-i-trust-the-report)). If you see `VERDICT: tamper-evidence holds ✓`,
-all is working.
-
-Not sure what to run next?
-
-```bash
-npx cool-workflow doctor --onramp
-```
-
-This prints the short path for a first run, the fast checks for source work, and
-the full gate to use before a release.
-
-From a source checkout, use:
-
-```bash
-cd plugins/cool-workflow
-node scripts/cw.js doctor --onramp --changed-from origin/main
-```
-
-### 2. Check, then run a real review on your own repo
-
-First make a zero-write check. It does not make a run, write `.cw/`, or call
-your agent:
-
-```bash
-npx cool-workflow quickstart architecture-review --check \
-  --repo /path/to/your/project \
-  --question "What are the main risks in this codebase?" \
-  --agent-command builtin:claude
-```
-
-If the check is good, run the review:
-
-```bash
-npx cool-workflow quickstart architecture-review \
-  --repo /path/to/your/project \
-  --question "What are the main risks in this codebase?" \
-  --agent-command builtin:claude
-```
-
-If the report has to go to someone else, make the checked bundle in the same
-run:
-
-```bash
-npx cool-workflow quickstart architecture-review \
-  --repo /path/to/your/project \
-  --question "What are the main risks in this codebase?" \
-  --agent-command builtin:claude \
-  --bundle
-```
-
-- `--repo` — the folder you have a wish to get looked at.
-- `--question` — what you have a wish to be certain of.
-- `--agent-command builtin:claude` — make use of the Claude wrapper that comes
-  with it (read-only; it never makes changes to your code).
-- `--agent-command builtin:codex` — make use of the Codex wrapper that comes
-  with it (read-only; it never makes changes to your code).
-
-CW makes a plan of the work, keeps your agent working over your repo in steps,
-and gives out where it kept the report. For a living view in the window while
-every worker is at work, take it up with `CW_AGENT_STREAM=1`; the view goes to
-stderr only and the kept answer is not changed.
-
-> **No agent put in place?** CW comes to a safe stop and says so
-> (`status: blocked`) — it never makes up an answer. Put in `claude` and run it
-> again.
-
-### 3. Read the report
-
-```bash
-cat /path/to/your/project/.cw/runs/<run-id>/report.md
-```
-
-You get a short account, ordered points, and **clickable pointers** like
-`src/server.js:18` for every point made — so you are able to make a check of
-each one yourself.
-
----
-
-## Install it (optional)
-
-`npx` is ever working with no need to put it in. To get the short `cw` command
-everywhere:
-
-```bash
-npm install -g cool-workflow      # then use:  cw …   instead of  npx cool-workflow …
-```
-
----
-
-## What else can it do?
-
-CW comes with a number of ready-made "jobs" (run `cw list` to see them all):
-
-| Command | What it does |
-|---|---|
-| `architecture-review` | Make a map of a repo's structure and put its true risks in order, with facts. |
-| `pr-review-fix-ci` | Go over a pull request, put forward fixes, make a check of CI. |
-| `research-synthesis` | Get together and make into one a fact-backed answer to a question. |
-| `release-cut` | Keep a gated, gone-over release moving. |
-
-It also puts the same acts out over **MCP**, so editors like Claude Desktop /
-Cursor / VS Code are able to make a call to CW as a tool. See the
-[wiki](https://github.com/coo1white/cool-workflow/wiki) for that and for
-multi-agent runs.
-
----
-
-## Can I trust the report?
-
-This is what makes CW not the same as the rest. Because CW only *gives the work
-over* to your agent, it keeps a record of every step that makes any false change
-come to light: every agent's given token use is signed by secret-key science and
-chained by hash, so **changing the record after the fact has the chain broken** —
-and anyone is able to make the check again offline with only a public key.
-
-See it for yourself — the `demo tamper` from step 1 makes a false record in two
-ways and gets both:
-
-```text
-▶ LEDGER tamper
-  after:  ✗ DETECTED — the hash chain caught it: chain-link[2]: telemetry-chain-broken
-▶ SIGNATURE tamper
-  after:  ✗ DETECTED — signature does not match reported usage
-VERDICT: tamper-evidence holds ✓ — every forgery caught offline, with only the public key.
-```
-
-On a true run, make a check of any run's record yourself:
-
-```bash
-cw telemetry verify <run-id>
-```
-
-CW makes use of this on its own code — see the kept living-run proof in
-[`plugins/cool-workflow/docs/dogfood/`](plugins/cool-workflow/docs/dogfood/).
-
-The plain point: *the thing that uses up the tokens is not the thing that keeps
-the books.* That keeping-apart is normal in account-keeping — CW gives it to AI
-agents.
-
----
-
-## Hand the report to someone — they can check it on their own
-
-A report you keep on your own machine is one thing. A report you can **give to
-someone** who then makes the check themselves is what you are really after. Add
-`--bundle` to the one command and CW seals the finished run into a single,
-self-checking file:
-
-```bash
-npx cool-workflow quickstart architecture-review \
-  --repo /path/to/your/project --question "What are the main risks?" \
-  --agent-command builtin:claude --bundle --with-trust-key ./trust-pub.pem
-```
-
-This puts a `report.cwrun.json` file **where you are** (not in the looked-at
-repo). The one file holds the report, the `file.js:42` pointers, the signed and
-hash-chained record, **and the public key**.
-
-Give that file to anyone. With no need for your repo, your keys given over on the
-side, or a put-in past `npx`, they make the check on their own — offline, with
-only the file:
-
-```bash
-npx cool-workflow report verify-bundle report.cwrun.json
-```
-
-If the bundle was changed in any way after the fact — the record, a signature, or
-the bytes — the check says so and comes to a stop (it gives back `ok: false` and a
-non-zero code), so a bundle you send on can never be a quiet lie. CW still never
-runs the model itself; it only keeps the books and makes the check.
-
-Want to see the whole thing in 30 seconds, with no agent and no key of your own?
-
-```bash
-npx cool-workflow demo bundle
-```
-
-It makes a real sealed bundle, makes two false changes to it, and shows the check
-getting **both** — offline, with only the public key the bundle carries.
-
----
-
-## Troubleshooting
-
-| Problem | Fix |
-|---|---|
-| `status: blocked`, `agentConfigured: false` | No agent is in place. Put in `claude` (or give `--agent-command`). |
-| `claude: command not found` | Put in Claude Code so the `claude` command is there, then run again. |
-| Want to see the plan without running the AI | Put in `--preview` — it gives the steps and starts nothing. |
-| Want a live agent trace | Put `CW_AGENT_STREAM=1`. It is stderr-only, TTY-gated, and `CW_NO_STREAM=1` puts it off. |
-| Where did my report go? | The command gives out `reportPath`; it is under `<your-repo>/.cw/runs/<id>/report.md`. |
-
----
-
-## How it works (one paragraph)
-
-CW is a small TypeScript/Node run-time that needs no other parts. It makes a
-record of the agent loop out in the open — *plan → dispatch → record → verify →
-commit → report* — as long-lasting files on disk, so a run is open to looking-at
-and able to be played again in place of a chat you let go. It never puts a model
-SDK inside and keeps no API key; your put-in-place agent does the thinking, CW
-does the book-keeping and the checking. For the structure, multi-agent
-working-together, execution backends, and the full CLI/MCP face, see the
-**[wiki](https://github.com/coo1white/cool-workflow/wiki)** and
-[`plugins/cool-workflow/docs/`](plugins/cool-workflow/docs/).
-
----
-
-## License
-
-BSD-2-Clause. See [LICENSE](LICENSE). Built by COOLWHITE LLC.

package/docs/routines.md

@@ -1,101 +0,0 @@
-# Routines
-
-A CW routine has a trigger, an event payload, match rules, and a prompt it makes
-for an agent host to run.
-
-CW keeps routine data in:
-
-```text
-.cw/routines/triggers.json
-.cw/routines/payloads/
-```
-
-## Commands
-
-Create an API trigger:
-
-```bash
-cw routine create \
-  --kind api \
-  --prompt "Handle this API event."
-```
-
-Create a GitHub trigger:
-
-```bash
-cw routine create \
-  --kind github \
-  --prompt "Review this GitHub event." \
-  --match '{"action":"opened"}'
-```
-
-Fire a trigger from a payload file:
-
-```bash
-cw routine fire github payload.json
-```
-
-Inspect events:
-
-```bash
-cw routine events
-```
-
-## Long Architecture Reviews
-
-Use `architecture-review-fast` for the foreground user path. Then put the
-full `architecture-review` app in line as background work when a deep look-over
-should not get in the way of a back-and-forth session:
-
-```bash
-node scripts/architecture-review-fast.js \
-  --repo /path/to/repo \
-  --question "Is this architecture sound?" \
-  --metrics \
-  --schedule-full
-```
-
-The wrapper makes a one-shot reminder schedule whose `workflowId` is
-`architecture-review`. The schedule prompt is policy. CW keeps the schedule and
-notes down due events; the outside agent host says how to run the long review.
-The prompt has in it the foreground fast run id, fast report path, source-context
-digest/profile, and it asks the background agent to give back the full review
-report path and digest.
-The `--metrics` flag is not required and it gives back foreground time used plus
-agent-spawn and result-cache-hit counts for the fast run.
-
-## PDCA Blackboard Development Lessons
-
-When a task asks for agents to work together, first try the parts CW already
-has:
-
-- workflow apps give the work shape
-- worker output gives checked facts
-- the blackboard gives shared state
-- MCP gives tool access to the same state
-- smoke tests prove the loop
-
-Do not make a new MCP server when the existing server can show the same run
-state. Add a workflow app first, then prove the app with one smoke that uses
-both CLI and MCP.
-
-For a three-agent loop, keep the order plain:
-
-```text
-plan -> build -> audit -> next action
-```
-
-Each agent should write one blackboard message and, when there is a result
-file, one artifact ref. Take a snapshot after the audit and after the next
-action. If audit evidence is missing, let the worker evidence gate refuse the
-result instead of adding a new policy layer.
-
-Before a PR, base the branch on `origin/main`, run the generated-doc checks,
-and sync generated docs when the gate says they are stale. This keeps unrelated
-local commits and generated README/index drift out of the work.
-
-## Boundary
-
-CW v0.1.1 does not give managed cloud infrastructure. It gives a local
-routine bridge that may be joined to GitHub Actions, webhooks, cron, or a
-small HTTP adapter in a later release.