@ericrisco/rsc 3.7.5 → 4.0.1

package/skills/implement/scripts/task-brief

@@ -1,10 +1,12 @@
 #!/bin/sh
 # task-brief PLAN_FILE N
-# Extracts task number N from a plan/tasks markdown file into a brief file in the
-# sdd-workspace dir, and prints its path.
+# Extracts task N from a plan/tasks markdown file into a brief file in the sdd-workspace dir, and
+# prints its path. N may be written 2, 002 or T002: ids compare as numbers.
 #
-# A task starts at a heading matching: ### T<N> / ### T<N>( / ### T<N> — / ## T<N>
-# and ends just before the next ### T / ## heading.
+# Two task shapes are read, because `tasks` prescribes a table and older plans used headings:
+#   - a table row `| T002 | ... |` → the table's header, its separator and that row;
+#   - a heading `### T2 …` / `## T002 …` → the block up to the next ## / ### heading.
+# Both are printed when both exist (the row is the contract, the heading its detail).
 # If task N is not found, exits nonzero with a clear message.
 
 # Resolve the directory of this script portably.
@@ -13,7 +15,7 @@ _SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 usage() {
   printf 'Usage: task-brief <PLAN_FILE> <N>\n' >&2
   printf '  PLAN_FILE  path to the tasks markdown file\n' >&2
-  printf '  N          task number to extract (e.g. 2 for T2)\n' >&2
+  printf '  N          task id to extract: 2, 002 or T002\n' >&2
   exit 1
 }
 
@@ -23,41 +25,44 @@ if [ $# -lt 2 ]; then
 fi
 
 PLAN_FILE="$1"
-N="$2"
+N="${2#T}"
+N="${N#t}"
 
 if [ ! -f "$PLAN_FILE" ]; then
   printf 'error: plan file not found: %s\n' "$PLAN_FILE" >&2
   exit 1
 fi
 
-# Validate N is a positive integer.
 case "$N" in
   ''|*[!0-9]*)
-    printf 'error: N must be a positive integer, got: %s\n' "$N" >&2
+    printf 'error: N must be a task number (2, 002 or T002), got: %s\n' "$2" >&2
     exit 1
     ;;
 esac
 
-# Use awk to extract the task block.
-# Match start: a heading line (## or ###) followed by T<N> then space, (, —, or end of line.
-# Match end: the next heading line starting with ## (which includes ###).
-# Exit code: 0 if found, 1 if not found.
 CONTENT="$(awk -v n="$N" '
-  BEGIN { printing=0; found=0 }
+  function idnum(s) { sub(/^[Tt]/, "", s); return s + 0 }
+  BEGIN { n = n + 0; printing = 0; found = 0; head = ""; sep = "" }
+  # Table rows: remember the latest header + separator, print the matching row.
+  /^\|/ {
+    split($0, cell, "|"); id = cell[2]; gsub(/[[:space:]]/, "", id)
+    if (id ~ /^[Tt][0-9]+$/) {
+      if (idnum(id) == n) { if (!printing) { if (head != "") print head; if (sep != "") print sep }; print; found = 1; next }
+    } else if ($0 ~ /^\|[-:| ]+\|[[:space:]]*$/) { sep = $0 }
+    else { head = $0; sep = "" }
+    if (!printing) next
+  }
   /^#{2,3}[[:space:]]/ {
-    # Check if this heading is the target task T<n>
-    line=$0
-    pat="^#{2,3}[[:space:]]+T" n "([[:space:](]|[-]|$)"
-    if (match(line, pat)) {
-      printing=1; found=1; print; next
+    if (printing) { printing = 0 }
+    if (match($0, /^#{2,3}[[:space:]]+[Tt][0-9]+([[:space:](]|-|$)/)) {
+      t = $0; sub(/^#{2,3}[[:space:]]+/, "", t); sub(/[^Tt0-9].*$/, "", t)
+      if (idnum(t) == n) { printing = 1; found = 1; print ""; print; next }
     }
-    # Any other ## / ### heading stops printing
-    if (printing) { exit }
   }
   { if (printing) print }
   END { if (!found) exit 1 }
 ' "$PLAN_FILE")" || {
-  printf 'error: task T%s not found in %s\n' "$N" "$PLAN_FILE" >&2
+  printf 'error: task T%s not found in %s (looked for a "| T%s |" table row and a "### T%s" heading)\n' "$N" "$PLAN_FILE" "$N" "$N" >&2
   exit 1
 }
 
@@ -71,7 +76,8 @@ SCRATCH="$(sh "$_SCRIPT_DIR/sdd-workspace")"
 
 # Derive a readable unique name from the plan file basename and task number.
 PLAN_BASENAME="$(basename "$PLAN_FILE" .md)"
-OUT="$SCRATCH/brief-${PLAN_BASENAME}-T${N}.txt"
+NUM="$(printf %s "$N" | sed "s/^0*//")"
+OUT="$SCRATCH/brief-${PLAN_BASENAME}-T${NUM:-0}.txt"
 
 printf '%s\n' "$CONTENT" > "$OUT"
 printf '%s\n' "$OUT"

package/skills/nextjs/SKILL.md

@@ -14,7 +14,7 @@ origin: risco
 > behaviour change** and there is **no approved spec + plan** under `02-DOCS/wiki/sdd/`, STOP and
 > hand off to `../specify/SKILL.md` (brainstorm → spec → plan → tasks); it routes back here once the
 > plan is approved. Build directly only for a genuinely one-line / low-risk change. Method:
-> `../sdd/SKILL.md`.
+> `../asdd/SKILL.md`.
 
 **Not this skill:** Pages Router (`pages/`) — note the difference, defer to the Next.js Pages docs.
 A pure React SPA (Vite/CRA) → `../react/SKILL.md`; React Native / Expo → `../react-native/SKILL.md`;

package/skills/parallel/SKILL.md

@@ -73,7 +73,7 @@ SUBAGENT BRIEF (one per unit)
 
 Each subagent still owns its own discipline inside its scope — TDD via `implement`, the stack skill's test mechanics, decision logging. This skill does not relax any of that; it just runs several of them at once.
 
-**Per-unit model tier (when routing is enabled).** `parallel` has *no fixed tier* — this is the most concrete place per-phase model routing pays off. When `models.enabled: true` in `02-DOCS/wiki/sdd/config.yaml`, give each unit the tier of the *kind of work it does*, not one tier for the whole fan-out: an implement-type unit → `balanced`, a scan/research/boilerplate unit → `light`, a unit doing genuine design or root-cause reasoning → `heavy`. Resolve the tier to a concrete model via `models.tiers` and **dispatch that subagent on that model** (e.g. Claude Code's `model` field on the Task/subagent) — real routing, independent of the session model. If routing is off or no profile exists, dispatch on the session model and say nothing. Full protocol: `../sdd/references/model-routing.md`.
+**Per-unit model tier (when routing is enabled).** `parallel` has *no fixed tier* — this is the most concrete place per-phase model routing pays off. When `models.enabled: true` in `02-DOCS/wiki/sdd/config.yaml`, give each unit the tier of the *kind of work it does*, not one tier for the whole fan-out: an implement-type unit → `balanced`, a scan/research/boilerplate unit → `light`, a unit doing genuine design or root-cause reasoning → `heavy`. Resolve the tier to a concrete model via `models.tiers` and **dispatch that subagent on that model** (e.g. Claude Code's `model` field on the Task/subagent) — real routing, independent of the session model. If routing is off or no profile exists, dispatch on the session model and say nothing. Full protocol: `../asdd/references/model-routing.md`.
 
 **Set the model on every dispatch — an omitted model silently inherits the session's, usually the most expensive one, and that is how a fan-out's cost quietly explodes.** rsc installs a `developer` subagent pinned to the **balanced** tier (Sonnet by default; the user's onboarding choice in `.rsc/developer.json`, never `light`). For implement-type units, **dispatch to the `developer` agent** (e.g. Claude Code `subagent_type: developer`) — that's the deliberate cost cap the user asked for. Only escalate a genuinely heavy unit (real design / root-cause) to a heavy model, and only when routing is enabled; otherwise balanced is the floor and the ceiling. If you dispatch a raw subagent instead, name its tier explicitly.
 

package/skills/plan/SKILL.md

@@ -85,7 +85,7 @@ Three of them carry the weight and fail quietly:
 
 Write `02-DOCS/wiki/sdd/plans/<slug>.md`, `<slug>` matching the spec's slug exactly — one plan per
 spec, same name, because that is how `tasks`, `analyze` and `implement` find it. Then index it in
-`02-DOCS/wiki/index.md` (the Knowledge map; root `CLAUDE.md` keeps only a pointer). If a plan for
+`02-DOCS/wiki/index.md` (the Knowledge map) — never the root `CLAUDE.md`. If a plan for
 this slug already exists, update it in place and note what changed — never fork a `-v2`.
 
 ## Model tier — `heavy` (opt-in routing)
@@ -93,7 +93,7 @@ this slug already exists, update it in place and note what changed — never for
 Architecture, interfaces, data flow and risk are the heaviest reasoning in the chain, so this
 phase's default tier is **`heavy`**. Routing is off unless `models.enabled: true` in
 `02-DOCS/wiki/sdd/config.yaml`; the resolution order, the announce rule and the model table live in
-`../sdd/references/model-routing.md`. Routing off or no profile → session model, silently.
+`../asdd/references/model-routing.md`. Routing off or no profile → session model, silently.
 
 ## Talking about the plan
 
@@ -140,7 +140,7 @@ regardless. (`implement` re-checks this as a hard gate before its first commit.)
 ## Result envelope
 
 End with the parseable block every SDD phase shares, so the dispatcher can chain without
-interpreting prose (contract: `../sdd/SKILL.md`):
+interpreting prose (contract: `../asdd/SKILL.md`):
 
 ```json result-envelope
 {

package/skills/plan/evals/cases.yaml

@@ -46,4 +46,4 @@ capability:
       - "Testing strategy maps each acceptance criterion to a test level (unit/contract/integration/e2e), states what each asserts and what it mocks (e.g. the payments provider), and defers the test runner/tooling to the stack skill"
       - "Risks section is ranked with trigger + impact + mitigation per risk (e.g. payments timeout, double-reservation race); does NOT claim zero risk"
       - "Stays stack-neutral above the seam — no framework route decorators, ORM session code, or test-runner flags in the plan"
-      - "Ends by pointing to the tasks phase and notes indexing the plan in the root CLAUDE.md Knowledge map"
+      - "Ends by pointing to the tasks phase and notes indexing the plan in 02-DOCS/wiki/index.md (the Knowledge map), never the root CLAUDE.md"

package/skills/plan/references/plan-template.md

@@ -145,8 +145,8 @@ unit / contract / integration / e2e. Tooling is the stack skill's job — name t
   defend it, not to enumerate every option without choosing.
 - **Empty section = defect.** Every one of the seven must say something real before `tasks` runs.
   If a section genuinely has no content (e.g. no migration), write "none — <why>", not silence.
-- **Index it.** After writing, add the plan to the root `CLAUDE.md` `## Knowledge map` so the
-  harness wiki and later phases can find it.
+- **Index it.** After writing, add the plan to `02-DOCS/wiki/index.md` (the Knowledge map) so the
+  harness wiki and later phases can find it. Never edit the root `CLAUDE.md` — that is `harness`'s, and tier 2.
 - **Global Constraints carry the verbatim values.** §0 is not a summary of §1 — §1 explains *which*
   constraints shape the design and *why*; §0 lists the exact values a blind implementer and the
   reviewer must honor. A value that lives only in prose ("use the project's naming rule") is a value

package/skills/postgresdb/SKILL.md

@@ -13,7 +13,7 @@ fix slow SQL, run zero-downtime migrations, and operate/secure the database. Too
 example is runnable.
 
 New, non-trivial feature with no approved spec + plan under `02-DOCS/wiki/sdd/`? Hand off to
-[`specify`](../specify/SKILL.md) before writing feature code (method: [`sdd`](../sdd/SKILL.md)); build
+[`specify`](../specify/SKILL.md) before writing feature code (method: [`asdd`](../asdd/SKILL.md)); build
 straight from here only for a genuinely one-line, low-risk change.
 
 Deep dives: [schema-and-indexing](references/schema-and-indexing.md) (types, constraints, every index

package/skills/react/SKILL.md

@@ -17,7 +17,7 @@ or screen, and its motion layer, is `../design/SKILL.md`'s.
 
 > Build or review a fast, typed, correctly-architected **client-side** React single-page app bundled by Vite. No server runtime, no RSC tree, no framework router. Server-rendered React (App Router, server actions, SSR/SSG) is not this skill — that is `../nextjs/SKILL.md`.
 
-**SDD gate — before writing feature code.** If this skill fired on a **new, non-trivial feature or behaviour change** and there is **no approved spec + plan** under `02-DOCS/wiki/sdd/`, stop and hand off to `../specify/SKILL.md`: it runs brainstorm → spec → plan → tasks, then routes back here once the plan is approved. Build directly only for a genuinely one-line / low-risk change. Method: `../sdd/SKILL.md`.
+**SDD gate — before writing feature code.** If this skill fired on a **new, non-trivial feature or behaviour change** and there is **no approved spec + plan** under `02-DOCS/wiki/sdd/`, stop and hand off to `../specify/SKILL.md`: it runs brainstorm → spec → plan → tasks, then routes back here once the plan is approved. Build directly only for a genuinely one-line / low-risk change. Method: `../asdd/SKILL.md`.
 
 ## First: confirm it's a Vite SPA, not a framework
 

package/skills/review/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: review
-description: "Use when a green diff needs adversarial judgment in the rsc SDD chain, between verify and ship — give a review keyed to the spec/plan/constitution in 02-DOCS/wiki/sdd/, or receive one and verify each comment before agreeing. NOT running lint/type/tests (that is `verify`), NOT the spec-less standalone pass (that is `code-review`), NOT merging (that is `ship`)."
-tags: [sdd, review, code-review]
+description: "Use when a diff needs adversarial judgment in rsc ASDD — per task inside implement's loop (depth set by `rsc risk`: none, one fresh-context reviewer, or the three-refuter panel) or as the closing review of the whole branch against the spec — keyed to the spec/plan/constitution in 02-DOCS/wiki/sdd/ and the project's REVIEW.md; or receive a review and verify each comment before agreeing. Converges via `rsc review ledger` (max 3 rounds, no repeated finding). NOT running lint/type/tests (that is `verify`), NOT the spec-less standalone pass (that is `code-review`), NOT merging (that is `ship`)."
+tags: [asdd, review, code-review, risk]
 recommends: [ship]
 profiles: [core, full]
 origin: risco
@@ -9,7 +9,10 @@ origin: risco
 
 # Review — adversarial code review, both directions
 
-Review is the **penultimate gate** of the rsc SDD chain: `constitution → specify → clarify → plan → tasks → analyze → implement → verify → **review** → ship`. By the time a diff reaches review, the `verify` phase has already proven that lint, types, tests and the stack `verify.sh` are green. Review answers a different question: **is the green diff actually correct, well-scoped, and faithful to the spec — or did it pass for the wrong reasons?**
+Tests prove the code works, not that it does what was asked. Review answers that other question: **is the diff correct, well-scoped and faithful to the spec — or did it pass for the wrong reasons?** In ASDD (`../asdd/SKILL.md`) it runs in two modes:
+
+- **Per task** — called from `implement`'s loop after each task's self-check. Depth comes from `npx @ericrisco/rsc risk [--base <ref>] [paths…]` (same path table as the sello, works with the sello off): **tier 0** → no review; **tier 1** → one fresh-context reviewer (a subagent that never saw the implementation conversation); **tier 2** → the three-refuter panel below, and the branch will wait for human approval at ship.
+- **Closing review** — once, before `ship`: the whole branch against the spec. Forty individually-correct tasks can still fail to be the feature together: a criterion nobody owned, two tasks that each assumed the other handled an edge, scope that crept in a slice at a time. Read the spec's acceptance criteria and "must respect" list against `git diff <base>...HEAD`, not the task reviews. Its record — tier, counts, verdict, each finding with its outcome — goes to `02-DOCS/wiki/sdd/reviews/<slug>.md`.
 
 This skill owns **two roles that share one discipline**:
 
@@ -22,9 +25,10 @@ The discipline is the same in both directions: **every finding and every rebutta
 
 ## Read these first
 
-1. `02-DOCS/wiki/sdd/specs/<slug>.md` and `02-DOCS/wiki/sdd/plans/<slug>.md` — what the diff was *supposed* to do. A review with no spec is a review of vibes.
-2. `02-DOCS/wiki/sdd/constitution.md` — the project's non-negotiables (stack canon, quality bars, conventions). Constitution violations are findings even when the code "works".
-3. `02-DOCS/wiki/harness/user-profile.md` — `technical_level`, the register (see "How a review reads" below).
+1. `REVIEW.md` at the project root, if present (drafted by `constitution`): what failure looks like in this repo, paths to skip, the nit cap, and that the summary starts with a count ("3 findings: 1 blocker, 2 nits"). Where it differs from this skill's defaults, it wins.
+2. `02-DOCS/wiki/sdd/specs/<slug>.md` and `02-DOCS/wiki/sdd/plans/<slug>.md` — what the diff was *supposed* to do. A review with no spec is a review of vibes.
+3. `02-DOCS/wiki/sdd/constitution.md` — the project's non-negotiables (stack canon, quality bars, conventions). Constitution violations are findings even when the code "works".
+4. `02-DOCS/wiki/harness/user-profile.md` — `technical_level`, the register (see "How a review reads" below).
 
 If there is no spec/plan (someone jumped straight to code), say so and review against the constitution + the diff's own stated intent. Don't pretend a spec exists.
 
@@ -126,12 +130,14 @@ Every state transition is deterministic CLI, never tokens:
 gap deliberately with `--accept-partial-lenses` (it is recorded). Every approval also appends to
 `.rsc/sello-log.jsonl`, so what shipped under which verdict survives the next freeze.
 
-**Lenses by risk tier** — tier 0 never reaches you (the gate passes docs/copy silently);
-tier 1 → run the single most relevant pass from the table above yourself; tier 2 → dispatch
-**three parallel fresh-context subagents** (`refuter-correctness` · `refuter-security` ·
-`refuter-tests`), each told
-to *refute* readiness, not confirm it. Fresh context is the point: a reviewer who inherits the
-implementer's context inherits its blind spots.
+### Depth by risk — who reviews
+
+`rsc risk` and `sello freeze` read the same path table, so the tier is the same with the sello on
+or off. Tier 0 never reaches you (docs/copy pass silently); tier 1 → **one fresh-context
+reviewer** running the most relevant pass from the table above; tier 2 → **three parallel
+fresh-context subagents** (`refuter-correctness` · `refuter-security` · `refuter-tests`), each
+told to *refute* readiness, not confirm it. Fresh context is the point: a reviewer who inherits the
+implementer's context inherits its blind spots. The closing review is always at least tier 1.
 
 **Give each refuter exactly four inputs — no more, no less.** The diff alone is not enough, and
 that is not a detail: with only the diff, the one failure class no test suite can structurally
@@ -169,21 +175,28 @@ Two extra finding classes the four inputs unlock, neither reachable from a diff:
 report one defect three ways, and a lens hunting for something can overstate what it found. Two
 steps, in this order:
 
-1. **Group (deterministic).** Each lens ends its report with a ` ```json findings ` block. Save the
-   three reports and run `npx @ericrisco/rsc review consolidate <reports…>`. It merges findings on
-   the same file within 3 lines, or quoting the same evidence; keeps the highest severity and every
-   lens that saw it; and downgrades a blocker or should-fix with no `file:line` or failure scenario to
-   a question. Several lenses on one finding is a reason to look first, never a reason to raise its
-   severity.
-2. **Verify (judgement).** For each finding it marks `verify`, dispatch the **`finding-verifier`**
-   agent with that one finding plus the same four inputs, in parallel. It starts from "this is false"
-   and returns **CONFIRMED** (reproduced or traced, with the proof), **REFUTED** (cites the guard that
-   makes it impossible), or **UNPROVEN** (becomes a question). It never gets the lens's reasoning.
+1. **Group (deterministic).** Each lens ends its report with a ` ```json findings ` block — an
+   array of objects in exactly this shape (give it to every reviewer verbatim):
+
+   ```json
+   {"severity":"blocker|should-fix|nit|question","file":"path","line":N,"claim":"…","failure_scenario":"concrete input → wrong result","evidence":"quoted code","class":"bug class"}
+   ```
+
+   Save the reports and run `npx @ericrisco/rsc review consolidate <reports…>`. It merges findings
+   on the same place that say the same thing, or that quote the same evidence; keeps the highest
+   severity and every lens that saw it; and **downgrades a blocker or should-fix with no
+   `file:line` or no `failure_scenario` to a question**. Several lenses on one finding is a reason
+   to look first, never a reason to raise its severity.
+2. **Verify (judgement).** Consolidate marks `verify` on **every blocker and every should-fix**.
+   For each, dispatch the **`finding-verifier`** agent with that one finding plus the same four
+   inputs, in parallel. It starts from "this is false" and returns **CONFIRMED** (reproduced or
+   traced, with the proof), **REFUTED** (cites the guard that makes it impossible), or **UNPROVEN**
+   (becomes a question). It never gets the lens's reasoning.
 
 Report the consolidated count honestly ("11 reported → 4 unique → 2 confirmed"), and list what was
 refuted and why: a refuted finding hidden from the author is a review nobody can audit. At tier 1
-(one pass, run by you) there is nothing to group, but a blocker still goes to `finding-verifier`
-before it blocks.
+(one reviewer) there is nothing to group, but run `review consolidate` on its one report anyway:
+it applies the downgrade, and every blocker and should-fix still goes to `finding-verifier`.
 
 **A finding blocks only if it survives all three filters** — no exceptions, and eagerness to
 find something is not evidence:
@@ -195,11 +208,38 @@ find something is not evidence:
 3. **Evidence** — `finding-verifier` returned **CONFIRMED** with its proof. REFUTED is dropped (with
    its reason in the report); UNPROVEN is a `[question]`, and questions don't block.
 
-**Fixing a blocker is budgeted, one attempt.** Before touching anything: estimate the fix and
-declare it — `npx @ericrisco/rsc sello budget --lines <N>`. After the fix:
-`sello budget-check` (over budget → justify with `--justify "…"` or shrink; an unexplained
-overrun is how over-engineering enters disguised as a fix). Then `sello freeze` + re-review
-**only the divergence**, and approve. Still broken after one attempt → stop, hand it to the human.
+**Fixing a blocker is budgeted.** Before touching anything: estimate the fix and declare it —
+`npx @ericrisco/rsc sello budget --lines <N>`. After the fix: `sello budget-check` (over budget →
+justify with `--justify "…"` or shrink; an unexplained overrun is how over-engineering enters
+disguised as a fix). Then `sello freeze` + re-review **only the divergence**, and approve. Each
+fix-and-re-review is one round of the loop below.
+
+### Convergence — the fix loop ends
+
+A review loop that never converges is worse than none: Anthropic saw a single PR take 50 rounds.
+Four rules, enforced by `npx @ericrisco/rsc review ledger` (`.rsc/review-ledger.jsonl`) rather
+than by memory:
+
+1. **Max 3 rounds per task.** Call `review ledger round <slug>/<task>` before **every** review of
+   the task, the first included: round 1 is the task's first review, not its first fix. It exits
+   non-zero on the 4th. That is not "try harder": rethink the approach, or park the task in the
+   decision queue (a `blocking` entry) and continue with independent work.
+2. **From round 2, re-review only the new diff** — what changed since the last round, not the task
+   again from scratch.
+3. **Flag the bug class, not the line.** "Every handler in this file trusts `req.params.id`" — so
+   one fix covers every instance and round 3 does not find the sibling.
+4. **Never repeat a finding.** Record each round's findings with `review ledger record
+   <findings.json>` (the consolidate output works). A finding already seen — same file, class and
+   normalized title — comes back marked `repeat`; it is never re-raised as new. A repeat means the
+   last fix missed the class, so say that instead.
+
+**Every finding closes with an outcome**: `review ledger outcome <id> fixed|false|intentional|irrelevant|parked`
+— `parked` when the finding's task went to the decision queue (neither fixed nor dismissed; a human
+decides). `review ledger stats` then shows totals per outcome, the false rate and mean rounds per
+task — the only way to tell whether a change to the reviewer made it better or worse.
+
+The ledger is **local**: it lives in `.rsc/` and is never committed, so it does not travel between
+machines or clones. What lasts is what you write from it — review-evals cases and rules (below).
 
 ---
 
@@ -276,26 +316,25 @@ In the `orient` voice: the verdict first, then the blocker list — e.g. `CHANGE
 
 ## Model tier — `heavy` (opt-in routing)
 
-This phase's default model tier is **`heavy`** — adversarial diff reading is where the strongest model pays off most. Routing is **off** unless `models.enabled: true` in `02-DOCS/wiki/sdd/config.yaml`. When on: resolve this phase's tier (`models.overrides` wins over `models.phases`), map it to a model via `models.tiers`, and apply per `../sdd/references/model-routing.md` — announce the switch in one line when it differs from the session model, and dispatch any `Task`/`parallel` subagents on that model. Routing off or no profile → honor the session model silently. Never fake a switch a tool can't make; skip routing on a one-line change.
-
-## Where this writes
+This phase's default model tier is **`heavy`** — adversarial diff reading is where the strongest model pays off most. Routing is **off** unless `models.enabled: true` in `02-DOCS/wiki/sdd/config.yaml`. When on: resolve this phase's tier (`models.overrides` wins over `models.phases`), map it to a model via `models.tiers`, and apply per `../asdd/references/model-routing.md` — announce the switch in one line when it differs from the session model, and dispatch any `Task`/`parallel` subagents on that model. Routing off or no profile → honor the session model silently. Never fake a switch a tool can't make; skip routing on a one-line change.
 
-Review is mostly a conversation, but two artifacts persist into the harness wiki so the knowledge model grows:
+## Where this writes — and how the reviewer learns
 
 - **Accepted/declined findings** of consequence → append to `02-DOCS/wiki/sdd/decisions.md` (e.g. "declined NPE finding on documents.py:42 — guarded by require_auth; added regression test"). This is the same append-only log `implement` writes to.
-- If a finding reveals a **missing constitution rule** (a defect class the project keeps hitting), propose adding it to `02-DOCS/wiki/sdd/constitution.md` so the next review catches it earlier.
+- **Escapes become cases.** `npx @ericrisco/rsc review escapes [--since <ref>]` lists every revert commit and whether it has a case at `02-DOCS/wiki/sdd/review-evals/<shortsha>.md`. Write the missing ones: the diff that shipped, where the bug was, and what the reviewer should have said. Only `Revert "…"` / `revert:` commits are seen; a hand-made revert is invisible.
+- **A finding that keeps repeating becomes a rule** — a lint rule, a constitution principle (`02-DOCS/wiki/sdd/constitution.md`, amended via `constitution`) or a line in `REVIEW.md`. Ask what the model didn't have in front of it: a repeat is almost always missing context, not a careless reviewer.
 
-Index both in `02-DOCS/wiki/index.md` (the Knowledge map; root `CLAUDE.md` keeps only a short pointer) under the `sdd/` topic — the harness owns that map; this skill just keeps its rows honest.
+Index them in `02-DOCS/wiki/index.md` (the Knowledge map; root `CLAUDE.md` keeps only a short pointer) under the `sdd/` topic — the harness owns that map; this skill just keeps its rows honest.
 
 ## Result envelope
 
-End with the parseable block every SDD phase shares, so the dispatcher can chain without
-interpreting prose (contract: `../sdd/SKILL.md`):
+End with the parseable block every phase shares, so the dispatcher can chain without
+interpreting prose (contract: `../asdd/SKILL.md`):
 
 ```json result-envelope
 {
   "status": "complete|blocked|failed",
-  "executive_summary": "Adversarial review against spec/plan/constitution; verdict and blocking findings.",
+  "executive_summary": "Per-task or closing review against spec/plan/constitution/REVIEW.md; tier, round, verdict and blocking findings.",
   "artifact": "02-DOCS/wiki/sdd/reviews/<slug>.md",
   "next_recommended": "ship",
   "risk": "low|medium|high",
@@ -303,12 +342,12 @@ interpreting prose (contract: `../sdd/SKILL.md`):
     "used": ["review"],
     "missing": [],
     "fallback": [],
-    "compact_rules": ["Rank or it is noise: blocker / should-fix / nit.", "A finding without a repro is a question, not a defect."]
+    "compact_rules": ["Rank or it is noise: blocker / should-fix / nit.", "A finding without a repro is a question, not a defect.", "Max 3 rounds; never repeat a finding."]
   },
-  "evidence": ["verdict stated (APPROVE | APPROVE WITH NITS | CHANGES REQUESTED)", "each blocker carries location + repro + fix"]
+  "evidence": ["rsc risk tier", "verdict stated (APPROVE | APPROVE WITH NITS | CHANGES REQUESTED)", "each blocker carries location + repro + fix", "every finding has a ledger outcome"]
 }
 ```
 
 ## Next in the chain
 
-When the diff carries an **APPROVE** / **APPROVE WITH NITS** verdict and every blocker is resolved, hand off to **ship** — close the branch via PR / merge / cleanup, with **git authorship as Eric, never Claude**. If the review came back **CHANGES REQUESTED**, the loop goes back to **implement** (fix), then **verify** (re-prove green), then back here for re-review. Don't ship a diff that hasn't earned its verdict.
+Per task: **APPROVE** returns to `implement`'s loop for the next task; **CHANGES REQUESTED** goes back to the fix step of the same task, as the next round. Closing review: **APPROVE** / **APPROVE WITH NITS** with every blocker resolved hands off to **ship**, with **git authorship as the human, never an AI**; anything else goes back to `implement`. Don't ship a diff that hasn't earned its verdict.

package/skills/sdd-init/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: sdd-init
-description: "Use when calibrating an existing repo for the rsc SDD chain: detect stack, package manager, test runners and apply/verify commands, refresh the skill registry, and write the runtime config at 02-DOCS/wiki/sdd/config.yaml. NOT the dispatcher that routes SDD phases (that is `sdd`), NOT first-contact user/workspace bootstrap (that is `init`)."
+description: "Use when calibrating an existing repo for the rsc SDD chain: detect stack, package manager, test runners and apply/verify commands, refresh the skill registry, and write the runtime config at 02-DOCS/wiki/sdd/config.yaml. NOT the dispatcher that routes SDD phases (that is `asdd`), NOT first-contact user/workspace bootstrap (that is `init`)."
 tags: [sdd, init, config, testing, registry]
-recommends: [sdd, specify, implement, verify]
+recommends: [asdd, constitution, specify, verify]
 profiles: [core, full]
 origin: risco
 ---
@@ -15,7 +15,7 @@ Step zero for technical SDD work: read the repo, detect how it should be built a
 02-DOCS/wiki/sdd/config.yaml
 ```
 
-That config is the runtime contract later phases read before choosing commands, TDD strictness, artifact paths, review budget or skill briefs. `sdd` dispatches the phases that consume it, `init` owns first contact and user profiling, `harness` owns `01-TOOLS/` and `02-DOCS/` scaffolding. This skill only calibrates.
+That config is the runtime contract later phases read before choosing commands, TDD strictness, artifact paths, review budget or skill briefs. `asdd` dispatches the phases that consume it, `init` owns first contact and user profiling, `harness` owns `01-TOOLS/` and `02-DOCS/` scaffolding. This skill only calibrates.
 
 ## Inputs
 
@@ -28,18 +28,20 @@ Read-only first:
 
 If `02-DOCS/` does not exist, create only the `02-DOCS/wiki/sdd/` path needed for the config. Do not run full harness scaffolding unless the user asked for `harness`.
 
+**Empty repo — nothing to detect?** Then there is nothing to calibrate yet: `constitution` runs first and decides the stack, and this skill calibrates against that decision (or re-runs once the first manifest exists). Never invent runners for an empty tree.
+
 ## Preflight Choices
 
 Ask only when the answer changes behavior; explain each trade-off in one line, in the register `technical_level` sets.
 
 | Setting | Default | Options |
 | --- | --- | --- |
-| `execution_mode` | `interactive` | `interactive` pauses at review-risk gates; `automatic` chains phases until a blocker/risk appears. |
+| `execution_mode` | `interactive` | `interactive` pauses at review-risk gates; `automatic` chains phases until a blocker/risk appears. `sdd.execution_mode: automatic` is the switch `asdd`'s autopilot reads. |
 | `artifact_store` | `02-DOCS/wiki/sdd` | Keep RSC artifacts in `02-DOCS`; do not create an `openspec/` parallel tree. |
 | `review_budget.line_budget` | `400` | Lower for solo tight review; higher only with explicit approval. |
 | `delivery_strategy.default` | `ask-on-risk` | `ask-on-risk`, `single-pr`, `autochain`, `exception`. |
 | `models.enabled` | `false` | Per-phase model routing is opt-in; leave off unless the user asks for it. |
-| `models.provider` | `anthropic` | Which provider the tiers resolve to. Set from the detected assistant when obvious, else `anthropic`. See `../sdd/references/model-routing.md` for other providers. |
+| `models.provider` | `anthropic` | Which provider the tiers resolve to. Set from the detected assistant when obvious, else `anthropic`. See `../asdd/references/model-routing.md` for other providers. |
 
 ## Detection
 
@@ -145,7 +147,7 @@ models:
   overrides: {}               # per-phase tier overrides set by the user
 ```
 
-The `models` block is the **per-phase model routing** profile: each phase declares a tier (`heavy`/`balanced`/`light`) and the tiers resolve to concrete models for `provider`. The full protocol — how phases apply it, the per-assistant switch mechanism, the provider→model table — lives in `../sdd/references/model-routing.md`. Keep this block byte-for-byte in sync with that reference.
+The `models` block is the **per-phase model routing** profile: each phase declares a tier (`heavy`/`balanced`/`light`) and the tiers resolve to concrete models for `provider`. The full protocol — how phases apply it, the per-assistant switch mechanism, the provider→model table — lives in `../asdd/references/model-routing.md`. Keep this block byte-for-byte in sync with that reference.
 
 Preserve user edits if the file exists: update detected facts and leave comments/custom policy fields intact when possible. **Never flip `models.enabled` or drop `models.overrides` on re-calibration** — a calibration pass that silently switches the user's models is the one failure they cannot detect from the diff, so preserve both verbatim and only refresh `tiers`/`provider` if the user asks. If preservation is risky, write a proposed replacement next to it as `config.proposed.yaml` and ask.
 
@@ -158,7 +160,7 @@ End with the standard SDD result envelope:
   "status": "complete",
   "executive_summary": "SDD config calibrated and registry refreshed.",
   "artifact": "02-DOCS/wiki/sdd/config.yaml",
-  "next_recommended": "sdd",
+  "next_recommended": "constitution|specify",
   "risk": "low",
   "skill_resolution": {
     "used": ["sdd-init"],
@@ -181,9 +183,9 @@ End with the standard SDD result envelope:
 | "I'll skip config and remember the commands in chat." | Chat is not source of truth. Write `config.yaml`. |
 | "No test command detected, but I'll still say strict TDD is active." | Strict TDD needs a runner. Record the gap. |
 | "Load all skills so the agent has context." | That pollutes context. Use registry -> selected skills -> compact rules. |
-| "This is the same as init." | No. `init` profiles user/workspace, `sdd` dispatches the phases, `sdd-init` calibrates the technical SDD runtime they both rely on. |
+| "This is the same as init." | No. `init` profiles user/workspace, `asdd` dispatches the phases, `sdd-init` calibrates the technical SDD runtime they both rely on. |
 | "Create openspec/ because Gentle does." | RSC uses `02-DOCS/wiki/sdd/` as source of truth. |
 
 ## Next
 
-After `sdd-init`, return to `sdd`. If no spec exists, route to `specify`. If the work is ambiguous or architectural, write a proposal first under `02-DOCS/wiki/sdd/proposals/`.
+After `sdd-init`, return to `asdd` with `next_recommended` set to the next phase: `constitution` if there is none (or it is `status: draft`), else `specify` when no spec exists. If the work is ambiguous or architectural, write a proposal first under `02-DOCS/wiki/sdd/proposals/`.