@crown-dev-studios/review-council 0.1.0 → 0.2.0

package/README.md

@@ -1,13 +1,12 @@
 # Review Council
 
-Review Council is a package-first CLI for multi-agent code review orchestration. It runs Claude, Codex, or other local reviewer CLIs against the same target, collects raw artifacts, runs a judge pass, and renders a static review bundle.
+Review Council is a standalone skill repo for model-parallel code review. It runs Claude and Codex in parallel with selected skill references (architecture-review, testing-philosophy, plan-compliance) passed into reviewer prompts as additional review lenses, then synthesizes all findings through an LLM judge with semantic deduplication, contradiction detection, and dependency ordering.
 
 Use it when you want:
 
-- side-by-side raw reviews before creating final todos
-- isolated reviewer runs or separate worktrees
-- a judge step that confirms, contests, or rejects findings
-- a static HTML report plus machine-readable JSON output
+- model-parallel review where Claude and Codex each independently apply specialized review skills
+- a judge that deduplicates across both models, detects contradictions, and orders findings by dependency
+- automated self-review integrated into agentic workflows
 
 ## Status
 
@@ -15,7 +14,6 @@ The orchestrator handles the happy path and common failure modes:
 
 - Stage timeouts with two-phase kill (SIGTERM then SIGKILL) prevent hung runs
 - Automatic retry with exponential backoff handles transient failures
-- Schema validation catches malformed reviewer and judge output
 - Interactive prompts from reviewer CLIs are detected and relayed to the user
 - Partial reviewer failure still allows the judge to run on available data
 - Failed stages surface stderr excerpts and validation errors in the HTML report
@@ -23,24 +21,14 @@ The orchestrator handles the happy path and common failure modes:
 ## Requirements
 
 - Node.js 20+
+- `pnpm` 10.30.3+
 - `claude` and/or `codex` on `PATH`
 - a Git working tree to review
-- reviewer CLIs authenticated and able to run non-interactively when possible
 
 ## Install
 
-Run it directly:
-
 ```bash
-npx @crown-dev-studios/review-council --help
-```
-
-Other package install paths:
-
-```bash
-pnpm dlx @crown-dev-studios/review-council --help
-npm install -g @crown-dev-studios/review-council
-review-council --help
+npx @crown-dev-studios/review-council --target "staged changes" --open-html
 ```
 
 ## Quick Start
@@ -50,62 +38,48 @@ From the project root you want to review:
 ```bash
 npx @crown-dev-studios/review-council \
   --target "staged changes" \
-  --review-id staged-changes-review \
-  --claude-command 'claude -p --disable-slash-commands --permission-mode acceptEdits "$(cat "$CLAUDE_DIR/claude-review-export.md")" < /dev/null' \
-  --codex-command 'codex exec --sandbox workspace-write -o "$CODEX_DIR/last-message.txt" "$(cat "$CODEX_DIR/codex-review-export.md")"' \
-  --judge-command 'codex exec --sandbox workspace-write -o "$JUDGE_DIR/last-message.txt" "$(cat "$JUDGE_DIR/judge.md")"'
+  --open-html
 ```
 
-That writes a run bundle under `docs/reviews/<review-id>/runs/<run-id>/` in the project being reviewed. Pass `--review-id` explicitly when you want the same review to be easy to correlate across reruns.
+That's it. Claude + Codex review in parallel, Codex judge, HTML report opens in your browser. Output goes to `docs/reviews/<run-id>/`.
 
 Main outputs:
 
 - `judge/summary.md`
 - `judge/verdict.json`
+- `follow-ups.md`
 - `bundle.json`
 - `index.html`
 
-## Skill Install
-
-Optional: install it as a slash-invocable skill by copying or symlinking this directory:
-
-```bash
-cp -R ~/src/review-council ~/.claude/skills/review-council
-cp -R ~/src/review-council ~/.codex/skills/review-council
-```
-
-The skill docs and the published package describe the same runtime: invoke `npx @crown-dev-studios/review-council ...` from the repo you want to review so outputs stay rooted in that caller repo.
-
 ## CLI Options
 
 ```
 --target <target>                 Review target label (required)
---review-id <id>                  Stable review identifier
 --run-dir <dir>                   Output directory for this run
---review-profile <id>             Reviewer prompt profile (default: default)
---judge-profile <id>              Judge prompt profile (default: default)
---claude-prompt-template <path>   Override Claude reviewer prompt template
---codex-prompt-template <path>    Override Codex reviewer prompt template
---judge-prompt-template <path>    Override judge prompt template
---claude-command <command>        Shell command for the Claude reviewer
---codex-command <command>         Shell command for the Codex reviewer
---judge-command <command>         Shell command for the judge stage
---allow-missing-sentinel          Treat exit code 0 as success without done.json
+--no-claude                       Skip Claude reviewer
+--no-codex                        Skip Codex reviewer
 --skip-judge                      Skip the judge stage
---skip-html                       Skip HTML rendering
+--skill-paths <paths>             Comma-separated paths to skill directories
 --open-html                       Open index.html after rendering (macOS)
+--skip-html                       Skip HTML rendering
 --timeout <ms>                    Stage timeout in ms (default: 300000)
 --retries <n>                     Max retries per stage on failure (default: 2)
 ```
 
-## Operating Notes
+### Overrides (optional)
+
+```
+--claude-command <command>        Override default Claude reviewer command
+--codex-command <command>         Override default Codex reviewer command
+--judge-command <command>         Override default judge command
+--allow-missing-sentinel          Treat exit code 0 as success without done.json
+```
+
+## Operational Rules
 
 - Use non-interactive reviewer commands when possible. Interactive prompts are detected and relayed to the user, but explicit non-interactive mode is more reliable.
-- Use `claude -p --disable-slash-commands --permission-mode acceptEdits ... < /dev/null` for Claude reviewer runs. This keeps the run in headless mode, disables skills, allows artifact writes into the stage directory without interactive approval prompts, and prevents Claude from waiting on stdin during fully non-interactive runs.
-- Codex reviewer and judge commands must run with a writable sandbox, for example `codex exec --sandbox workspace-write ...`, because they need to write review artifacts into the run directory.
-- `--skip-judge` disables judge prompt rendering, judge command validation, and judge execution.
 - Keep reviewer artifacts inside the run directory.
-- Every reviewer and judge JSON artifact should carry the same `review_id` and `run_id` as `run.json`.
+- Selected skills are passed into reviewer prompts as additional review lenses for the run; the orchestrator does not inline local `SKILL.md` contents.
 - Do not create authoritative files in `todos/` during raw review.
 - If you reuse `workflows-review`, run each reviewer in a separate worktree.
 
@@ -118,53 +92,47 @@ If a run fails or stalls, inspect:
 - `<run>/judge/status.json`
 - each stage's `stdout.log` and `stderr.log`
 
-The `status.json` for each stage includes `review_id`, `run_id`, `exit_code`, `timed_out`, `attempts`, `missing_artifacts`, `failure_reason`, and `validation_errors`. The HTML report surfaces missing artifacts, stderr excerpts, and validation errors for failed stages in a diagnostics section.
+The `status.json` for each stage includes `exit_code`, `timed_out`, `attempts`, `retried`, and `validation_errors` fields. The HTML report surfaces stderr excerpts and validation errors for failed stages in a diagnostics section.
 
 If a stage exits `0` but does not write `done.json`, the stage is incomplete and the run should be treated as failed.
 
-## Development
+## Publishing (maintainers)
 
-Contributor workflow from a source checkout:
+Canonical release version lives in the [`VERSION`](VERSION) file and must match `version` in [`package.json`](package.json).
 
-```bash
-cd ~/src/review-council
-pnpm install
-pnpm typecheck
-pnpm test
-```
+**Prerequisites**
 
-Package verification:
+- [`npm login`](https://docs.npmjs.com/cli/v11/commands/npm-login) (or another auth method `pnpm publish` can use for the public registry)
+- A **clean** git working tree in this repository
+- Git tag `vX.Y.Z` present locally before deploy (created by the bump script or manually)
+- Permission to publish `@crown-dev-studios/review-council` on npm
 
-```bash
-pnpm verify:package
-```
+**Scripts (same idea as `simple-auth`)**
 
-That verification path:
+| Step | Command |
+|------|---------|
+| Preflight only (build, test, pack dry-run) | `pnpm run release:preflight` or `./scripts/prepare-release.sh` |
+| Confirm `VERSION` ↔ `package.json` | `pnpm run release:check-version` or `./scripts/check-version.sh` |
+| Require local tag exists | `./scripts/check-version.sh --require-tag` |
+| Bump version, refresh lockfile, commit + tag (+ push) | `pnpm run release:bump -- patch` (or `major` / `minor` / `1.2.3`) |
+| Publish to npm | `pnpm run release:deploy` or `./scripts/deploy.sh` |
 
-- builds `dist/`
-- inspects `npm pack --dry-run` output with a repo-local npm cache
-- installs the local tarball into a temporary caller repo
-- verifies `review-council --help` and a minimal end-to-end run
+**Typical release**
 
-First publish and post-publish checks:
+1. `./scripts/bump-version.sh patch` — updates `VERSION`, `package.json`, `pnpm-lock.yaml`, commits, tags `v…`, pushes (omit `--no-push` / `--no-tag` as needed).
+2. `./scripts/check-version.sh --require-tag`
+3. `./scripts/deploy.sh --dry-run` (optional)
+4. `./scripts/deploy.sh` — pushes branch + tag (unless `--skip-git`), runs install/build/test/verify, then `pnpm publish --access public`.
 
-```bash
-pnpm release:manual
-npm view @crown-dev-studios/review-council version
-npx @crown-dev-studios/review-council --help
-```
+Options: `./scripts/deploy.sh --dry-run` (no push/publish), `./scripts/deploy.sh --skip-git` (publish only; you already pushed).
+
+Update [`package.json`](package.json) `repository` / `homepage` / `bugs` if the GitHub repo URL differs from `@crown-dev-studios/review-council` on GitHub.
 
 ## Files
 
 - [SKILL.md](SKILL.md)
 - [references/cli-integration.md](references/cli-integration.md)
 - [references/output-contract.md](references/output-contract.md)
-- [src/cli.ts](src/cli.ts)
 - [src/orchestrate-review-council.ts](src/orchestrate-review-council.ts)
 - [src/render-review-html.ts](src/render-review-html.ts)
 - [src/interaction-queue.ts](src/interaction-queue.ts)
-- [src/review-session.ts](src/review-session.ts)
-- [src/schemas.ts](src/schemas.ts)
-- [src/types.ts](src/types.ts)
-- [test/package-smoke.test.mjs](test/package-smoke.test.mjs)
-- [test/validate-schema.test.ts](test/validate-schema.test.ts)

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: review-council
-description: Orchestrate Claude, Codex, or other local CLI reviewers against the same target, wait for their exported findings, run a judge pass, and generate a static HTML plus markdown review bundle. Use when you want side-by-side raw reviews before creating final todos.
+description: Orchestrate model-parallel code review with selected skill references. Runs Claude and Codex in parallel with those skill references listed in reviewer prompts as additional review lenses, then synthesizes all findings through an LLM judge with semantic deduplication, contradiction detection, and dependency ordering.
 argument-hint: [staged|branch main..HEAD|pr 123|commit abc123]
 disable-model-invocation: true
 ---
@@ -9,254 +9,140 @@ disable-model-invocation: true
 
 ## Purpose
 
-`/review-council` is the manual entrypoint for multi-agent code review orchestration.
+`/review-council` orchestrates multi-source code review:
 
-This directory is intended to be both a standalone skill repo and the source for the published npm package. The prompt templates, schemas, renderer, and orchestrator all live here.
+- **Model reviewers** (Claude + Codex) provide general-purpose parallel review via CLI processes
+- **Selected review skills** (architecture-review, testing-philosophy, plan-compliance) are listed in each model reviewer's prompt for that run
+- **Judge** synthesizes all findings with semantic dedup, contradiction detection, and dependency ordering
 
-It is intentionally separate from `workflows-review`:
-
-- `workflows-review` is optimized for single-agent review and immediate todo creation
-- `review-council` is optimized for parallel raw review, adjudication, and artifact rendering
-
-Use this when you want:
-
-- a Claude review and a Codex review on the same target
-- isolated worktrees or isolated CLI runs per reviewer
-- raw reviewer artifacts stored outside `todos/`
-- a judge step that decides which findings are valid
-- a static HTML page next to the final markdown judge summary
+All reviewers run in parallel. The judge adjudicates the combined results. A static HTML report is rendered for human review.
 
 ## Prerequisites
 
-- Node.js 20+
-- `claude` and/or `codex` on `PATH` for the stages you want to run
+- Node.js and pnpm (for the TS orchestrator)
+- `claude` and/or `codex` on `PATH` for model reviewers
 - A Git working tree to review
-- Reviewer CLIs must already be authenticated and able to run non-interactively
-
-## Quick Start
+- Skill directories available for `--skill-paths` (e.g., `~/.agents/skills/architecture-review`)
 
-1. Put this directory somewhere stable, for example `~/src/review-council`.
-
-2. Optional: install it as a slash-invocable skill by copying or symlinking this directory to one or both skill locations:
-
-```bash
-cp -R ~/src/review-council ~/.claude/skills/review-council
-cp -R ~/src/review-council ~/.codex/skills/review-council
-```
-
-3. Review or customize the command templates in [cli-integration.md](references/cli-integration.md).
-
-No external `/review-export` command is required. The orchestrator renders self-contained prompt files into each stage directory before launching reviewer CLIs.
-
-4. From the project root you want to review, run the published CLI. By default it writes each run under `docs/reviews/<review-id>/runs/<run-id>/` in the current project:
-
-```bash
-npx @crown-dev-studios/review-council \
-  --target "staged changes" \
-  --review-id staged-changes-review \
-  --claude-command 'claude -p --disable-slash-commands --permission-mode acceptEdits "$(cat "$CLAUDE_DIR/claude-review-export.md")" < /dev/null' \
-  --codex-command 'codex exec --sandbox workspace-write -o "$CODEX_DIR/last-message.txt" "$(cat "$CODEX_DIR/codex-review-export.md")"' \
-  --judge-command 'codex exec --sandbox workspace-write -o "$JUDGE_DIR/last-message.txt" "$(cat "$JUDGE_DIR/judge.md")"' \
-  --timeout 300000 \
-  --retries 2
-```
-
-- `--timeout <ms>`: per-stage timeout (default 300000 — 5 minutes). On timeout the process receives SIGTERM, then SIGKILL after a 5-second grace period.
-- `--retries <n>`: max retries per stage on non-timeout failure (default 2). Uses exponential backoff starting at 2 seconds.
-- For Claude reviewer runs, use `claude -p --disable-slash-commands --permission-mode acceptEdits ... < /dev/null`. This keeps the run headless, disables skills, allows artifact writes into the stage directory without interactive approval prompts, and avoids stdin wait warnings.
-- When using Codex for reviewer or judge stages, include `--sandbox workspace-write` so it can write artifacts into the run directory.
-- `--skip-judge` disables judge prompt rendering, judge command validation, and judge execution.
-- Pass `--review-id` explicitly when you want the same review to be easy to correlate across reruns.
-
-If the package is already installed globally, `review-council --target ...` is equivalent.
+## Workflow
 
-### Development from a Source Checkout
+### Step 1: Scope Detection
 
-The packaged CLI is the supported runtime. Contributor workflow remains source-first:
+Normalize the argument into one of these forms:
 
-```bash
-cd ~/src/review-council
-pnpm install
-pnpm typecheck
-pnpm test
-pnpm verify:package
-```
-
-This produces:
-
-- `docs/reviews/<review-id>/runs/<run-id>/judge/summary.md`
-- `docs/reviews/<review-id>/runs/<run-id>/judge/verdict.json`
-- `docs/reviews/<review-id>/runs/<run-id>/bundle.json`
-- `docs/reviews/<review-id>/runs/<run-id>/index.html`
-
-### Example findings.json
-
-```json
-{
-  "review_id": "staged-changes-review",
-  "run_id": "20260318-143000123-abc12345",
-  "reviewer": "claude",
-  "target": "staged changes",
-  "generated_at": "2026-03-07T18:30:00Z",
-  "summary": "Found two issues: one SQL injection and one missing index.",
-  "findings": [
-    {
-      "id": "F001",
-      "title": "SQL injection in search endpoint",
-      "severity": "p1",
-      "confidence": "high",
-      "category": "security",
-      "description": "Unsanitized user input passed directly to raw SQL query.",
-      "evidence": "db.query(`SELECT * FROM users WHERE name = '${input}'`)",
-      "recommended_fix": "Use parameterized queries instead of string interpolation.",
-      "files": [
-        { "path": "src/routes/search.ts", "line": 42 }
-      ]
-    },
-    {
-      "id": "F002",
-      "title": "Missing index on users.email",
-      "severity": "p3",
-      "confidence": "medium",
-      "category": "performance",
-      "description": "The users.email column is queried frequently but has no index.",
-      "evidence": "Query plan shows sequential scan on users table.",
-      "recommended_fix": "Add a B-tree index on users.email.",
-      "files": [
-        { "path": "db/migrations/001_create_users.sql" }
-      ]
-    }
-  ]
-}
-```
+- `staged changes` — review staged (cached) changes
+- `branch main..feature-branch` — review branch diff
+- `pr 123` — review a pull request
+- `commit abc123` — review a specific commit
 
-### Example verdict.json
-
-```json
-{
-  "review_id": "staged-changes-review",
-  "run_id": "20260318-143000123-abc12345",
-  "target": "staged changes",
-  "generated_at": "2026-03-07T14:30:00Z",
-  "overall_verdict": "needs-fixes",
-  "summary_markdown": "Two confirmed issues require attention before merge.",
-  "confirmed_findings": [
-    {
-      "title": "SQL injection in search endpoint",
-      "status": "confirmed",
-      "reason": "Both reviewers flagged unsanitized user input passed to raw query.",
-      "final_priority": "p1",
-      "reviewer_ids": ["claude", "codex"]
-    }
-  ],
-  "contested_findings": [
-    {
-      "title": "Missing index on users.email",
-      "status": "contested",
-      "reason": "Claude flagged as p2 but Codex noted the table has <1k rows.",
-      "final_priority": "p3",
-      "reviewer_ids": ["claude"]
-    }
-  ],
-  "rejected_findings": [
-    {
-      "title": "Unused import in helpers.ts",
-      "status": "rejected",
-      "reason": "Import is used in a type-only context; no runtime impact."
-    }
-  ],
-  "todo_recommendations": [
-    {
-      "title": "Parameterize search query to prevent SQL injection",
-      "priority": "p1",
-      "reason": "Confirmed by both reviewers as a security vulnerability."
-    }
-  ]
-}
-```
+Generate the diff for analysis:
+- Staged: `git diff --cached`
+- Branch: `git diff main..HEAD`
+- PR: `gh pr diff 123`
+- Commit: `git show abc123`
 
-## Workflow
+### Step 2: Intent Discovery
 
-### Step 1: Choose the Review Target
+Analyze the diff to understand what changed and guide reviewer selection:
 
-Normalize the target into one of these forms:
+1. **Categorize changed files:** source code, tests, config, docs, migrations, schemas.
+2. **Identify modules/services touched:** which packages, directories, or service boundaries are affected.
+3. **Classify change nature:** new feature, bug fix, refactor, test addition, config change.
+4. **Gather stated intent:**
+   - PR mode: read the PR description and linked issues.
+   - Branch mode: read commit messages.
+5. **Check for a plan:** look in `docs/plans/active/` and `docs/plans/` for a plan that references the changed files.
 
-- `staged changes`
-- `branch main..feature-branch`
-- `pr 123`
-- `commit abc123`
+Output a brief intent summary that will be included in all reviewer prompts.
 
-### Step 2: Spawn Reviewer CLIs
+### Step 3: Select Review Skills
 
-The parent agent is the orchestrator. It should not do the review itself.
+Based on intent discovery, select which review skills to include:
 
-Its job is to:
+| Signal | Skill |
+|--------|-------|
+| Service boundary, data model, or migration files changed | `architecture-review` |
+| Test files or test-adjacent source code changed | `testing-philosophy` |
+| Plan exists in `docs/plans/` or ticket has a linked plan | `plan-compliance` |
 
-1. Create a run directory
-2. Spawn reviewer CLIs with explicit commands
-3. Wait for both reviewers to finish
-4. Confirm each reviewer wrote `done.json`
-5. Run the judge step
-6. Render HTML
+If the diff is trivial (<20 lines, single file, obvious fix), skip additional review skills.
 
-Use the environment variables documented in [cli-integration.md](references/cli-integration.md). Prefer the rendered stage prompt files under `$CLAUDE_DIR`, `$CODEX_DIR`, and `$JUDGE_DIR` over the source templates under `templates/`.
+### Step 4: Run Review
 
-### Step 3: Export Raw Reviewer Artifacts
+Run the orchestrator with `--skill-paths` pointing at the selected skill directories:
 
-Each reviewer should write only raw artifacts:
+```bash
+npx @crown-dev-studios/review-council \
+  --target "<target>" \
+  --skill-paths "/path/to/architecture-review,/path/to/plan-compliance" \
+  --open-html
+```
 
-- `report.md`
-- `findings.json`
-- `done.json`
+This single invocation:
+1. Lists the selected review skills in both Claude and Codex reviewer prompts
+2. Runs Claude + Codex in parallel — each applies the selected skills independently
+3. Runs the judge to merge, deduplicate, and resolve contradictions across both outputs
+4. Renders the HTML report
 
-Do not create authoritative todos during raw review.
+Use `--no-claude` or `--no-codex` to skip one model reviewer.
 
-If you want to reuse the heuristics from `workflows-review`, copy its review bar and agent choices into the reviewer prompts, but stop before todo creation.
+The judge performs:
+- **Semantic deduplication** — merges equivalent findings across Claude and Codex
+- **Contradiction detection** — flags disagreements between reviewers
+- **Dependency ordering** — orders findings so foundational issues come first
+- **Confidence from corroboration** — findings flagged by both reviewers carry higher confidence
 
-### Step 4: Judge the Combined Result
+### Step 5: Present Findings
 
-The judge reads both raw reviewer outputs and decides:
+Present findings to the user in this order:
+1. **Contradictions** — need human resolution
+2. **Confirmed P1 findings** — in dependency order
+3. **Confirmed P2 findings** — in dependency order
+4. **Contested findings** — plausible but unverified
+5. **Summary of rejected/low-confidence findings** — counts only
 
-- which findings are confirmed
-- which findings are contested
-- which findings are rejected
-- which findings are worth turning into final todos
+## Mode Parameter
 
-The judge writes:
+The skill supports a mode argument (design for all, only interactive is implemented):
 
-- `summary.md`
-- `verdict.json`
-- `done.json`
+- **Default (interactive):** present findings, user responds
+- **`mode:autofix`** (future): apply safe fixes automatically
+- **`mode:report-only`** (future): generate artifacts without interaction
 
-### Step 5: Render the Reading View
+## Output
 
-Render `index.html` after the judge completes.
+All artifacts are written to `docs/reviews/<run-id>/`:
 
-The HTML page should make these easy to scan:
+```
+docs/reviews/<run-id>/
+  run.json                       # Run metadata
+  bundle.json                    # Consolidated data for HTML
+  follow-ups.md                  # Human-readable next-step list from the judge verdict
+  index.html                     # Static review report
+  claude/                        # Claude model reviewer
+    report.md, findings.json, done.json, status.json
+  codex/                         # Codex model reviewer
+    report.md, findings.json, done.json, status.json
+  judge/                         # Judge adjudication
+    summary.md, verdict.json, done.json, status.json
+```
 
-- judge summary
-- candidate findings from each reviewer
-- confirmed versus contested verdicts
-- raw markdown reports from Claude and Codex
+Add `docs/reviews/` to `.gitignore` to keep review artifacts out of version control.
 
-## Important Constraints
+## Constraints
 
-- Do not run `workflows-review` twice in the same working tree if it will write directly to `todos/`
-- If you must reuse `workflows-review` unchanged, run each reviewer in a separate worktree so each run has its own local `todos/`
-- Keep final todo creation as a later, explicit step owned by the judge or a follow-up workflow
-- Interactive prompts from reviewer CLIs are detected and relayed to the user one at a time; explicit non-interactive commands such as `claude -p --disable-slash-commands --permission-mode acceptEdits < /dev/null` or `codex exec` remain the standard mode for raw review runs
+- The parent agent is the orchestrator. It should not do the review itself.
+- Do not create files in `todos/` — the judge recommends todos and Review Council derives `follow-ups.md`, but neither creates authoritative todo files.
+- Skills are passed to each model reviewer as additional review lenses for the run, not inlined prompt bodies.
+- Model reviewers (Claude, Codex) run as CLI processes via the TS orchestrator.
+- Interactive prompts from reviewer CLIs are detected and relayed; prefer explicit non-interactive mode (`claude --dangerously-skip-permissions -p`, `codex exec --full-auto`) for reliability.
 
 ## Supporting Files
 
 - Output contract: [output-contract.md](references/output-contract.md)
 - CLI examples: [cli-integration.md](references/cli-integration.md)
-- Review schema: [review-findings.schema.json](schemas/review-findings.schema.json)
-- Judge schema: [judge-verdict.schema.json](schemas/judge-verdict.schema.json)
-- Reviewer template: [reviewer-export.md](templates/reviewer-export.md)
+- Review findings schema: [review-findings.schema.json](schemas/review-findings.schema.json)
+- Judge verdict schema: [judge-verdict.schema.json](schemas/judge-verdict.schema.json)
+- Model reviewer template: [reviewer-export.md](templates/reviewer-export.md)
 - Judge template: [judge.md](templates/judge.md)
 - HTML template: [report.html](templates/report.html)
-- CLI entrypoint: [src/cli.ts](src/cli.ts)
-- Orchestrator runtime: [src/orchestrate-review-council.ts](src/orchestrate-review-council.ts)
-- Renderer: [src/render-review-html.ts](src/render-review-html.ts)
-- TypeScript package: [package.json](package.json)
-- TypeScript config: [tsconfig.json](tsconfig.json)