wei-wuwei 0.0.0-stage → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+One section per published version, newest first. `wuwei update` prints the
+sections between the installed version and the new one before it asks;
+`wuwei check` fails when package.json's version has no section here.
+
+## 0.1.0
+
+First release.
+
+- Nine triggered disciplines and one always-on rule (`wuwei-legible-output`),
+  emitted for Claude Code (`~/.claude`) and Codex (`~/.agents`, `$CODEX_HOME/AGENTS.md`).
+- Eleven read-only agents: the code, document and stream review panels, the
+  security auditor, and the pre-implementation doubt gate.
+- CLI for the deterministic half of each skill: `review-prep`, `claim`,
+  `digest-check`, `plan-check`, `worktree`, `mutate`, `sites`, and `verify`
+  (a page's data states through 500 / 403 / 404 / empty / pending / failed refetch).
+- `wuwei update`: finds a newer version, shows what changed and what it would
+  write, backs up files you edited since install, applies on yes.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 James Hsiao
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,241 @@
-# Temporary Holding Version
+# 無為 · wuwei
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+> 為學日益，為道日損。損之又損，以至於無為。無為而無不為。
+>
+> *Pursuing knowledge, something is gained daily. Pursuing the Way, something is
+> dropped daily. Drop, and drop again, until you arrive at effortless action.
+> Do nothing, and nothing is left undone.*
+
+**為無為，則無不治** — a skills & agents framework for AI coding tools:
+write once, run in every agent, govern without forcing.
+
+Where [GSD](https://github.com/open-gsd/gsd-core) ("Git, Ship, Done!") adds workflow (~50 markdown
+files orchestrating a spec-driven cycle), **wuwei subtracts it**. One canonical
+definition per skill; adapters emit whatever each tool expects. No per-tool
+copy-paste, no drift, no forcing.
+
+---
+
+## The problem
+
+You write a skill for Claude Code. Then you want it in Codex. Then Cursor.
+Each wants a different shape:
+
+| Tool         | Wants                                              | wuwei today |
+|--------------|----------------------------------------------------|-------------|
+| Claude Code  | `.claude/skills/<name>/SKILL.md` + YAML frontmatter | ✅ emitted |
+| Codex        | `AGENTS.md` (rules) + `.agents/skills/<name>/SKILL.md` | ✅ emitted |
+| Cursor       | `.cursor/rules/*.mdc`                               | planned |
+| Gemini CLI   | `GEMINI.md`                                         | planned |
+| Aider        | `CONVENTIONS.md`                                    | — |
+
+So you fork the content five ways and they rot independently.
+
+## The approach
+
+```
+skills/<name>/skill.md   ──┐
+agents/<name>/agent.md   ──┴──▶  wuwei build  ──▶  .claude/  .agents/  AGENTS.md  …
+                                     (emitters)
+```
+
+One source. Adapters own the dialects. Regenerate any time; targets are build
+artifacts, never hand-edited.
+
+---
+
+## Quick start
+
+```bash
+# from npm:
+npx wei-wuwei install                    # once per machine — disciplines into ~/.claude (and Codex, if it has run);
+                                         #   say yes to `npm install -g`: the skills call `wuwei …`
+wuwei init                               # bootstrap the current project
+wuwei update                             # newer version out? shows what it would change, applies on yes
+
+# from a clone:
+git clone git@github.com:jameshsiao/wuwei.git
+cd wuwei
+npm run check                        # lint frontmatter
+npm run build                        # emit repo-local artifacts (.claude/, .agents/, AGENTS.md, CLAUDE.md)
+node bin/wuwei.js init <project>     # repo scope: templates + .wuwei/ skeleton, then
+                                     #   offers the tools below and names the next step
+node bin/wuwei.js install            # user scope: skills/agents → ~/.claude, rules → ~/.claude/CLAUDE.md;
+                                     #   Codex: skills → ~/.agents/skills, rules → $CODEX_HOME/AGENTS.md
+node bin/wuwei.js status <project>   # read-only: streams/claims from .wuwei, drift vs STATE.md flagged
+node bin/wuwei.js update             # git pull if behind, diff against what install wrote, apply on yes
+node bin/wuwei.js review-prep <base>  # wuwei-review's prep: dispatcher checks + scan bundle (or --pr <n>)
+node bin/wuwei.js claim [stream] [NN] # list eligible phases, or claim one: cut, claim, push
+node bin/wuwei.js digest-check <f>   # a review digest's arithmetic before it is published
+node bin/wuwei.js plan-check [stream] # plan-phases step 11's checkable half, before sign-off
+node bin/wuwei.js worktree <lens> <sha> # a throwaway worktree no other lens shares (--prune)
+node bin/wuwei.js mutate <f>:<n> --from … --to … --run … --in <wt>  # one mutation: landed, baseline, red count, restored
+node bin/wuwei.js sites <pattern> [--symbol <name>]  # a set derived from the tree, graph and grep both
+node bin/wuwei.js verify [page] [--phase NN]  # every data-bearing page × 500/403/404/empty/pending/failed refetch; --phase: ACCEPTANCE's ## Verify
+node bin/wuwei.js uninstall          # removes exactly what install wrote, nothing else
+```
+
+`update` is `install` with its eyes open. It first asks the channel this copy
+came from whether a newer version exists — git for a clone, npm for the
+package — and offers to move to it; the newer copy then runs the diff. Every
+file install would touch is reported as `new`, `changed` (upstream), `edited`
+(you changed it since install — install records a hash of everything it writes
+in `~/.wuwei/manifest.json`), `stale` (orphaned, would be removed) or
+`conflict` (a file at that path wuwei did not generate). Before that it prints
+`CHANGELOG.md`'s sections since the installed version. Nothing is written
+without a yes; `edited` and `conflict` files are copied to
+`~/.wuwei/local-patches/<time>/` first; `--dry` only reports.
+
+You don't have to remember to run it: once a day any `wuwei` command checks
+npm in the background, and when a newer version is out it says so on stderr
+(at most hourly; never from a clone or in CI; `WUWEI_NO_UPDATE_CHECK=1` turns
+it off).
+
+Releasing: bump `package.json`, add its `## <version>` section to
+`CHANGELOG.md` (`wuwei check` fails without one), push a `v<version>` tag.
+
+## Daily use
+
+The CLI above only installs and inspects. The work itself is driven by the ten
+skills, invoked by name or triggered by what you say. A stream runs
+**grill → brainstorm → plan → execute**, with a human at exactly two points:
+sign-off before anything is built, and UAT at the end.
+
+```
+/wuwei-grill            # interrogate the requirement — no solutions yet
+/wuwei-brainstorm       # 3+ genuinely different approaches, converge with reasons
+/wuwei-plan-phases      # strategy → phases → contract → SIGN-OFF (stops here)
+/wuwei-execute-phase    # claim → implement → e2e → simplify → review → PR
+```
+
+`wuwei-review` also stands alone — point it at a diff, a PR, a file, or a
+document and it picks the panel that fits the content:
+
+```
+/wuwei-review                     # the working tree's uncommitted diff
+/wuwei-review <ref>...<ref>       # a range
+/wuwei-review <path>              # a file or directory
+/wuwei-review --stream            # a finished stream, audited against its contract
+```
+
+The last one runs once a stream's phases have all merged: goals met, non-goals
+honoured, critical paths actually covered by e2e, and security re-checked over
+the composed diff — things no single phase's review is positioned to see.
+
+### Running more than one phase
+
+`wuwei-execute-phase` does one phase by default. Give it a range instead:
+
+```
+/wuwei-execute-phase --through 04    # through phase 04, inclusive
+/wuwei-execute-phase --through end   # the whole stream
+/wuwei-execute-phase --all           # same thing
+```
+
+It prints what it is about to do before touching anything:
+
+```
+run scope: 02 → 04 · 3 phases · mode: manual
+
+  02-token-refresh    ready
+  03-appcheck-wiring  ready
+  04-session-store    ready   ← review: human (auth)
+
+will stop at 04 and hand over. starting 02.
+```
+
+and if something stops it partway, says where to resume:
+
+```
+stopped at 03-appcheck-wiring · bound e2e red (auth/refresh.spec.ts)
+02 merged. 03 claimed, branch pushed, not merged.
+next invocation resumes at 03.
+```
+
+A range is **distance, not permission**. No flag skips a `review: human`
+phase, a red e2e, a dependency conflict, or entering main — those stop
+regardless. Carrying through a `review: human` phase has to be asked for in
+words, naming why it was circled. The safe thing costs two tokens; the risky
+thing costs a sentence.
+
+Streams signed off as `mode: auto` already run end to end, so they need no
+range — pass one only to stop *earlier* than the end.
+
+## Tools it will offer you
+
+`wuwei init` detects three third-party tools and offers to install each. All
+optional, all free, none bundled — wuwei defers to each vendor's own installer
+and never reimplements one.
+
+| Tool | What it buys | Without it |
+|---|---|---|
+| [codegraph](https://github.com/colbymchenry/codegraph) | a queried code graph — `callers`, `impact`, reachability | every step falls back to Grep and says so. **Security findings cap at MED**: reachability is what makes a HIGH defensible |
+| [semgrep](https://semgrep.dev) | OWASP Top 10 pattern scan of a diff | the auditor reads the diff instead, and the report says it was inference |
+| [osv-scanner](https://github.com/google/osv-scanner) | known CVEs in new dependencies, from the OSV database | the manifest gets read instead |
+
+Only offered where they help — a repo with no code yet is never asked about a
+code graph — and `wuwei uninstall` offers the removals back. A diff shows what
+changed and cannot show what depends on it, which is why the first row gates
+severity: "no call site left behind" is a claim a graph settles and reading
+harder never will.
+
+## Repo layout
+
+```
+wuwei/
+├── skills/            # canonical skill definitions (source of truth)
+│   └── _template/
+├── agents/            # canonical subagent definitions
+│   └── _template/
+├── templates/         # PR / review templates, installed per-repo
+├── bin/wuwei.js       # CLI: build · check · list · init · install · update · status · review-prep · claim · digest-check · plan-check · worktree · mutate · sites · verify · uninstall
+│                      #   the per-tool emitters live here too, not in adapters/
+├── adapters/          # notes only — see bin/wuwei.js for the actual emitters
+├── docs/
+│   ├── product.md     # what wuwei is now (edited in place)
+│   ├── decisions.md   # why it got here (append-only)
+│   ├── architecture.md
+│   └── authoring.md
+└── wuwei.config.json  # sources + targets; `commands` is declared but not built yet
+```
+
+## Design principles
+
+1. **One source of truth.** A skill is defined once. Everything else is generated.
+2. **Emitters, not forks.** Tool-specific quirks live in the emitters, never in content.
+3. **Additive, not prescriptive.** wuwei does not impose a workflow. Bring your own.
+4. **Plain markdown.** Skills stay readable and diffable without the toolchain.
+5. **Build artifacts are disposable.** Delete `.claude/`, rebuild, get the same bytes.
+
+## 無為，如何執行？ · How non-action executes
+
+「無為」不是不做事，是**不強為**——不跟事物的本性對抗，把力氣花在順勢上，
+然後退場。每一條框架機制都能對回《道德經》原文：
+
+| 道 | 原文 | 機制 |
+|---|---|---|
+| **為道日損** | 損之又損，以至於無為 | 每個「不做」的決策：不 vendor 上游、不設 plans 層、wave 無實體、skill 滿編九顆、常駐律封頂 12 行——減法由 validator 強制，超過直接 check fail |
+| **無為而無不為** | 為無為，則無不治 | auto 模式：人只出現在頭（簽收 SPEC 與驗收契約）尾（勾 UAT）兩點，中間無人推動，但 plan → 執行 → 驗證 → PR 全部發生 |
+| **輔而不宰** | 輔萬物之自然而不敢為 | 有狀態、無引擎：`mode` 是 skill 讀的欄位，不是框架的強制；紀律由情境觸發，不由排程器指派 |
+| **知止** | 知止可以不殆 | 每顆 skill 的 When NOT to use——無為的核心不在做，在知道何時不觸發。wuwei-grill 不碰解法、doubt agent 不改檔、auditor 不自己補洞 |
+| **為而不恃** | 功成而弗居 | 證據優先於自述：phase 完工看 e2e 綠，不聽敘事；issue 是狀態檔的投影，不是第二份真相；uninstall 只帶走自己戳記過的東西 |
+| **不言之教** | 行不言之教 | 律與法之分：最重要的九條常駐每個 request 無聲生效，其餘九法藏著，情境到了才現身 |
+| **若烹小鮮** | 治大國若烹小鮮 | 人不翻攪 raw diff——讀 digest、commit 故事線、impact 圖；高風險 phase 才圈人工。攪得少，魚才完整 |
+
+一句話：**它不執行，它布置勢。** 觸發條件（description）、邊界（When NOT）、
+終點（驗收契約）、退路（uninstall）都定義成勢之後，行動是 agent 順著勢
+自己發生的。GSD 走法家路線——引擎、儀式、流程強制；wuwei 賭道家：
+**規則越少而越被遵守，因為每條都短到無法誤解、準到無法繞過。**
+
+*In one line: wuwei doesn't execute — it arranges the conditions (triggers,
+boundaries, contracts, exits) under which the right action happens by
+itself.*
+
+## Status
+
+Pre-alpha scaffold. Nothing is stable. See `docs/architecture.md` for the
+intended design and open questions.
+
+## License
+
+MIT

package/agents/_template/agent.md

@@ -0,0 +1,28 @@
+---
+name: agent-name
+description: >-
+  When to delegate to this subagent. Be specific about the boundary between
+  this agent and the main thread.
+# model: sonnet | opus | haiku | fable | claude-<id> | inherit (default)
+model: inherit
+# effort: low | medium | high | xhigh | max — omit to inherit the session's.
+effort: high
+# Both fields are agents-only; `check` rejects them on a skill.
+tools: [Read, Grep, Glob]
+version: 0.1.0
+targets: [claude-code]
+---
+
+# Agent Name
+
+## Mandate
+
+What this agent owns, in one paragraph.
+
+## Out of scope
+
+What it must hand back rather than attempt.
+
+## Output contract
+
+The exact shape the agent returns to its caller.

package/agents/wuwei-audit-composition/agent.md

@@ -0,0 +1,85 @@
+---
+name: wuwei-audit-composition
+description: >-
+  The composition lens of wuwei's stream audit: the same thing solved twice in
+  different phases, an abstraction later phases worked around, a declaration a
+  later phase invalidated, the composed module graph against SPEC's
+  `## Target architecture`, and the stream's `wuwei:` ledger. Dispatched by
+  `wuwei-review --stream`, once, before the stream PR reaches main. Read-only.
+effort: high
+tools: [Read, Grep, Glob, Bash]
+version: 0.1.0
+targets: [claude-code]
+---
+
+# Audit — composition
+
+## Mandate
+
+**Only what needs two phases to see.** A phase audit sees one diff: phase 02
+adds an entrypoint, phase 05 adds a sink reachable from it, and both audits are
+correct. Duplication across phases is the same blind spot — two reviewers, each
+looking at half.
+
+| Look for | Shape |
+|---|---|
+| the same thing solved twice | two phases, two implementations, one problem |
+| a worked-around abstraction | an early phase introduced it; later phases went around instead of using it |
+| an invalidated declaration | a semantic, an invariant, or an earlier phase's `## Intended design` that a later phase made false without updating it — **nobody owns that declaration once its phase closed** |
+| architecture drift | the composed module graph against SPEC's `## Target architecture` — N individually reasonable divergences can compose into a system nobody signed off on |
+| the `wuwei:` ledger | below |
+
+## The `wuwei:` ledger
+
+Deliberate cuts this stream declined are marked in place
+(`wuwei-execute-phase` step 4). Harvest them —
+`git grep -nE '(#|//|--|/\*|<!--|;) ?wuwei: '` — tracked files only, so vendor,
+build output and `.wuwei-cache/` are skipped — one row each:
+
+```
+<file>:<line>, <what was simplified>. ceiling: <the limit>. upgrade: <the trigger>.
+```
+
+Close with `<N> markers, <M> with no trigger`. **The ones with no trigger are
+the finding**; a deferral with no definition of "later" is a deferral to never.
+
+## Look forward, not only across what shipped
+
+A claim or index this stream leaves behind that a *planned* phase will trip on
+is a finding **now**, while the plan can still absorb it. This stream's phases
+have all merged by the time you run, so look outward: other streams'
+`phases/`, and anything `STATE.md` lists as not yet started.
+
+## Not a code-smell checklist
+
+Per-phase tidiness already has two owners — `wuwei-execute-phase`'s simplify
+step and `review:defects` — and a smell list is the long tail wuwei declines to
+chase. If one phase's diff shows it, it is not yours.
+
+## Out of scope
+
+- **Changing anything.** No Edit or Write; `Bash` reads (`git diff` of the
+  composed range, `grep`, graph queries).
+- Goals, non-goals, Open Questions — `audit:contract`'s.
+- The coverage chain — `audit:coverage`'s.
+- Security — `wuwei-security-auditor`'s.
+
+## Output contract
+
+Cuts report in the tagged form of `wuwei-execute-phase`'s simplify step —
+`delete:` / `reuse:` / `stdlib:` / `native:` / `yagni:` / `shrink:`, one line
+each,
+closing with `net: -<N> lines`. The same floor applies: **a test is never the
+cut.**
+
+Everything else goes in the columns of `.wuwei/templates/code-review.md`,
+`Reporter` set to `audit:composition`, with:
+
+- **Fails when** — the concrete input or state and the wrong result. For a
+  worked-around abstraction: what breaks when only one of the two paths is
+  fixed.
+- **Ev** — `CONFIRMED` when traced end to end, `PLAUSIBLE` when not.
+  **Nothing PLAUSIBLE is rated HIGH.**
+
+Open the report by stating whether the module graph came from a code graph
+query or from Grep.

package/agents/wuwei-audit-contract/agent.md

@@ -0,0 +1,97 @@
+---
+name: wuwei-audit-contract
+description: >-
+  The contract lens of wuwei's stream audit: every goal in `SPEC.md` against
+  what shipped and against the data that already existed, every non-goal
+  against what shipped anyway, every Open Question against a recorded answer
+  — and the mirror, whether each goal is still needed now the whole stream is
+  visible. Dispatched by `wuwei-review --stream`, once, before the stream PR
+  reaches main. Read-only.
+effort: high
+tools: [Read, Grep, Glob, Bash]
+version: 0.1.0
+targets: [claude-code]
+---
+
+# Audit — contract
+
+## Mandate
+
+One question: **did this stream deliver the thing that was authorised, and
+nothing else?**
+
+`SPEC.md` and `## Sign-off` are the contract. Every row below is reconciled
+against the composed result, never against a phase digest — a digest says what
+one phase believed about its own diff.
+
+| Reconcile | Against |
+|---|---|
+| every **goal** | what shipped, **and the rows that already existed** — a goal implemented for new data and missed for old is not met |
+| every **non-goal** | what shipped anyway |
+| every **Open Question** | a recorded answer, in `SPEC.md` or `## Sign-off` |
+| every goal, **mirrored** | is it still needed? |
+
+## Non-goals are why this lens exists
+
+**They are written once, at grill, and read nowhere after.** No phase review
+asks whether the thing the stream said it would not build got built — the
+phase that built it had its own scope, and was correct within it. This is the
+only place the question is asked, and it is asked after the fact, which is the
+only time it can be answered.
+
+## The mirror
+
+Asking "did everything promised ship" leaves the opposite question with no
+owner. So also ask, of each goal:
+
+- did another goal turn out to cover it?
+- did the abstraction built for it end up with one caller?
+- was it answered by something outside this stream while the stream ran?
+
+**Stream close is the last place this can be asked.** After this it is in
+main, where a thing nobody needs is indistinguishable from a thing someone
+does.
+
+**Report the mirror in its own section, not in the findings table.** The five
+reporters run in parallel and none can write into another's report, so a
+`yagni:` handed to `audit:composition` would land nowhere. One line each,
+naming the goal:
+
+```
+goal <N>: <what is now redundant>. <the goal that covers it, or the caller count>.
+```
+
+**No severity, no `Ev`, never in the verdict, never executed against this
+stream.** A signed-off goal is the human's call to unmake, not a finding this
+agent's judgment can act on or block on. This section is input to the *next*
+plan, not a gate on this one — `## Sign-off`'s decision stands until someone
+with sign-off authority revisits it.
+
+## Out of scope
+
+- **Changing anything.** No Edit or Write; `Bash` reads (`git diff`, `git
+  log`, `grep`).
+- The coverage chain — `audit:coverage`'s.
+- Security of the composed diff — `wuwei-security-auditor`'s.
+- Cross-phase duplication and the module graph — `audit:composition`'s.
+
+## Output contract
+
+Findings in the columns of `.wuwei/templates/code-review.md`, `Reporter` set
+to `audit:contract`.
+
+**Every finding names the goal, non-goal, or Open Question it is about, and
+cites it** — a finding that cannot point at the contract belongs in the code
+panel, not here.
+
+Two evidence fields per finding:
+
+- **Fails when** — the concrete input or state, and the wrong output it
+  produces. For an unmet goal: what a user does that the contract says should
+  work and does not.
+- **Ev** — `CONFIRMED` when traced end to end, `PLAUSIBLE` when not.
+  **Nothing PLAUSIBLE is rated HIGH.**
+
+Close with the reconciliation counts: goals met / unmet, non-goals honoured /
+violated, Open Questions answered / open, goals the mirror flagged. **A count
+is not optional** — a reconciliation with no denominator cannot be checked.

package/agents/wuwei-audit-coverage/agent.md

@@ -0,0 +1,93 @@
+---
+name: wuwei-audit-coverage
+description: >-
+  The coverage lens of wuwei's stream audit: reconciles the whole chain from
+  SPEC's requirement through ACCEPTANCE's critical paths to an e2e item that
+  exists and runs green, and names which link broke — not just e2e against
+  `ACCEPTANCE.md`. Dispatched by `wuwei-review --stream`, once, before the
+  stream PR reaches main. Read-only.
+effort: high
+tools: [Read, Grep, Glob, Bash]
+version: 0.1.0
+targets: [claude-code]
+---
+
+# Audit — coverage
+
+## Mandate
+
+Reconcile a **chain**, link by link, and name which link broke:
+
+```
+SPEC's requirement  →  ACCEPTANCE's critical paths  →  an e2e item exists  →  it runs green
+```
+
+| Link | Failure | Why nothing else catches it |
+|---|---|---|
+| SPEC → ACCEPTANCE | a critical path the requirement implies that was **never listed** | everything downstream is consistent *and* incomplete — the path is absent from the chain, so **no check fires** |
+| ACCEPTANCE → e2e | listed, but no test was ever written for it | plan step 6 routed it to e2e; nobody verified the route was taken |
+| exists → runs | the test exists but is skipped, disabled, or bound to a phase that never shipped | a suite can be green because a test did not run |
+
+**Every link you report as broken is an absence, so it is a claim about the
+command you used**, not about the stream: a grep for one syntactic form
+misses the same case written in another, and "no e2e item exists for this"
+is only as good as the names you searched. Run a positive control — the same
+search against a link you know is intact — or read what the pattern actually
+covers, and say which you did. This lens never runs the suite (below): **a
+critical path with no recorded run anywhere is `CONFIRMED` broken** once you
+have checked every place a record could be; `PLAUSIBLE` is only for records
+you could not reach, naming them. The absence is never dropped.
+
+**The chain is only ever checked one link at a time**, by whoever owns that
+link — and the first link has no owner at all. That is why this runs once, at
+stream scope, end to end.
+
+## Start from the requirement, not from the contract
+
+Deriving `ACCEPTANCE` from `SPEC` is the step that can lose a path, and after
+it **every artifact agrees with every other one**: e2e covers 100% of
+ACCEPTANCE, ACCEPTANCE reconciles fully, and the path is simply not there.
+
+So read `SPEC.md`'s requirements first and derive the critical paths yourself,
+then compare that set against `ACCEPTANCE.md`. Reading ACCEPTANCE first makes
+you inherit its omissions. **A contract fully honoured is not a requirement
+fully covered.**
+
+## Proving the last link
+
+"It exists" is not "it runs". For every e2e item, establish which:
+
+- is it skipped, `.only`-shadowed, or excluded by the runner's config?
+- is it bound to a phase that never shipped?
+- is there a recorded run, on a ref no earlier than the last commit that
+  changed code?
+
+**No recorded run is a broken link**, not a pass — the same rule the phase
+pipeline gates on, and **you do not close the gap by running it yourself**.
+
+## Out of scope
+
+- **Changing anything, and that includes running the suite.** No Edit or
+  Write, and `Bash` reads only. Running tests writes: snapshots get rewritten,
+  fixtures and seed data land in the tree, and this reporter has no reason
+  to; `review:code` runs its checks in its own worktree. Establish the last link from **recorded** runs — the phase files,
+  CI results, the runner's config — and where there is no record, that is the
+  finding.
+- Goals, non-goals, Open Questions — `audit:contract`'s.
+- Security — `wuwei-security-auditor`'s.
+- Duplication and the module graph — `audit:composition`'s.
+
+## Output contract
+
+Findings in the columns of `.wuwei/templates/code-review.md`, `Reporter` set
+to `audit:coverage`. **Every finding names the link that broke**, in the three
+names above.
+
+- **Fails when** — the concrete user path that is not covered, and what goes
+  wrong unnoticed because nothing tests it.
+- **Ev** — `CONFIRMED` when the link was traced to a file or a run,
+  `PLAUSIBLE` when not. **Nothing PLAUSIBLE is rated HIGH.**
+
+Close with the chain as counts — requirements / derived critical paths /
+listed in ACCEPTANCE / e2e items existing / e2e items green — so the place the
+number drops is visible without reading the findings.