feat(review): the review is a gate - verdict in the file, CC engine, project memory

Ordre 5 (wave 1, P11 + P5), review_version 1.1.

- K7: `verdict: ALLOW | WARN | BLOCK` is required in review.md (strict
  error, soft warning for 1.0 reviews). New CLI lib/review/verdict-gate.mjs:
  0 = ALLOW/WARN, 1 = BLOCK, 2 = could not decide (never green); a verdict
  greener than the file's own BLOCKERs or JSON block is exit 2. Realpath
  main guard (the old file:// guard exits 0 under a symlink - measured).
- No finding is struck for length: succinctness trims only MINOR/SUGGESTION
  text (catalogue tier), keeps BLOCKER/MAJOR whole, counts trims; the
  coordinator lists what it declined to judge.
- Claude Code's /code-review and /security-review run as the engine via the
  Skill tool (never --fix/--comment/--post/ultra); lib/review/engine-findings.mjs
  turns their findings into a reviewer payload; two catalogue keys
  (CODE_REVIEW_DEFECT, SECURITY_REVIEW_VULNERABILITY), catalogue 12 -> 14.
  An engine that did not run forbids ALLOW.
- Every BLOCKER is written as a numbered `### Step R<n>` with its source
  finding (strict error REVIEW_MISSING_REMEDIATION_STEP).
- P5: lib/review/recurrence.mjs - a finding class in two review.md files
  (current + git history, no new store) becomes one proposal, routed by the
  catalogue's memory_route; written only between Voyage markers in
  .claude/rules/voyage-review-lessons.md under a size budget, CLAUDE.md gets
  a pointer only; the operator approves every line (Phase 8.7).
- Workflow substrate: catalogue enum in step; a missing reviewer or engine
  forbids ALLOW there too (it returned ALLOW on zero findings before).
- Fixtures review-run-A/B said WARN over a BLOCKER; now BLOCK.

Borrowed and credited in code: Superpowers (declined-to-judge), ai-native-sdlc
(cap only nits; mistake/fix/check), Spec Kit (managed block; converge steps),
Pocock (retro routing), Kiro (verdict file + gate; evidence per lesson),
Cherny (engine -> brief control order; review -> memory; budget).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tests/lib/verdict-gate.test.mjs

@@ -0,0 +1,153 @@
+// tests/lib/verdict-gate.test.mjs
+// K7 — the review verdict gate (ordre 5, P11). One command decides on the
+// verdict written in review.md: 0 = ALLOW/WARN, 1 = BLOCK, 2 = could not read.
+// Exit 2 is never green: a missing file, a missing verdict, or a verdict the
+// file contradicts all land there.
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, rmSync, existsSync, symlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const GATE = join(ROOT, 'lib', 'review', 'verdict-gate.mjs');
+
+function review({ verdict, jsonVerdict, severities = [] }) {
+  const ids = severities.map((_, i) => String(i + 1).padStart(40, 'a'));
+  const fmVerdict = verdict === undefined ? '' : `verdict: ${verdict}\n`;
+  const findings = severities.map((s, i) => ({
+    id: ids[i], severity: s, rule_key: 'MISSING_TEST', file: 'a.mjs', line: i + 1, title: 't', detail: 'd', recommended_action: 'Add a test.',
+  }));
+  const counts = { BLOCKER: 0, MAJOR: 0, MINOR: 0, SUGGESTION: 0 };
+  for (const s of severities) counts[s] += 1;
+  const json = JSON.stringify({ verdict: jsonVerdict ?? verdict, counts, findings }, null, 2);
+  return `---
+type: trekreview
+review_version: "1.1"
+task: "t"
+slug: s
+project_dir: .claude/projects/2026-10-06-s/
+brief_path: .claude/projects/2026-10-06-s/brief.md
+scope_sha_end: abc
+reviewed_files_count: 1
+${fmVerdict}findings:
+${ids.map((id) => `  - ${id}`).join('\n')}
+---
+
+# Review: t
+
+## Executive Summary
+
+x
+
+## Coverage
+
+| File | Treatment | Reason |
+|------|-----------|--------|
+| a.mjs | summary-only | default |
+
+## Remediation Summary
+
+x
+
+\`\`\`json
+${json}
+\`\`\`
+`;
+}
+
+function runGate(text, { name = 'review.md', write = true } = {}) {
+  const dir = mkdtempSync(join(tmpdir(), 'verdict-gate-'));
+  try {
+    const p = join(dir, name);
+    if (write) writeFileSync(p, text);
+    const r = spawnSync(process.execPath, [GATE, p], { encoding: 'utf-8' });
+    return r;
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+test('verdict-gate — the CLI exists', () => {
+  assert.ok(existsSync(GATE), 'lib/review/verdict-gate.mjs must exist (K7)');
+});
+
+test('verdict-gate — BLOCK → exit 1', () => {
+  const r = runGate(review({ verdict: 'BLOCK', severities: ['BLOCKER'] }));
+  assert.equal(r.status, 1, r.stdout + r.stderr);
+});
+
+test('verdict-gate — ALLOW → exit 0', () => {
+  const r = runGate(review({ verdict: 'ALLOW', severities: ['MINOR'] }));
+  assert.equal(r.status, 0, r.stdout + r.stderr);
+});
+
+test('verdict-gate — WARN → exit 0', () => {
+  const r = runGate(review({ verdict: 'WARN', severities: ['MAJOR'] }));
+  assert.equal(r.status, 0, r.stdout + r.stderr);
+});
+
+test('verdict-gate — missing file → exit 2', () => {
+  const r = runGate('', { write: false });
+  assert.equal(r.status, 2, r.stdout + r.stderr);
+});
+
+test('verdict-gate — a review.md without verdict → exit 2, never ALLOW', () => {
+  const r = runGate(review({ verdict: undefined, jsonVerdict: 'ALLOW', severities: ['MINOR'] }));
+  assert.equal(r.status, 2, r.stdout + r.stderr);
+});
+
+test('verdict-gate — an unknown verdict value → exit 2', () => {
+  const r = runGate(review({ verdict: 'PASS', severities: ['MINOR'] }));
+  assert.equal(r.status, 2, r.stdout + r.stderr);
+});
+
+test('verdict-gate — frontmatter ALLOW over a BLOCKER finding is a contradiction → exit 2', () => {
+  const r = runGate(review({ verdict: 'ALLOW', severities: ['BLOCKER'] }));
+  assert.equal(r.status, 2, r.stdout + r.stderr);
+});
+
+test('verdict-gate — frontmatter and trailing JSON disagree → exit 2', () => {
+  const r = runGate(review({ verdict: 'WARN', jsonVerdict: 'BLOCK', severities: ['MAJOR'] }));
+  assert.equal(r.status, 2, r.stdout + r.stderr);
+});
+
+test('verdict-gate — not a review (wrong type) → exit 2', () => {
+  const r = runGate(review({ verdict: 'ALLOW', severities: ['MINOR'] }).replace('type: trekreview', 'type: trekbrief'));
+  assert.equal(r.status, 2, r.stdout + r.stderr);
+});
+
+test('verdict-gate — --json prints the decision as JSON', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'verdict-gate-'));
+  try {
+    const p = join(dir, 'review.md');
+    writeFileSync(p, review({ verdict: 'BLOCK', severities: ['BLOCKER'] }));
+    const r = spawnSync(process.execPath, [GATE, '--json', p], { encoding: 'utf-8' });
+    assert.equal(r.status, 1);
+    const out = JSON.parse(r.stdout);
+    assert.equal(out.verdict, 'BLOCK');
+    assert.equal(out.exit, 1);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('verdict-gate — run through a symlink and a path with a space it still decides (realpath main guard)', () => {
+  // The old `file://${argv[1]}` guard is a no-op under a symlink or a space:
+  // the CLI would exit 0 without reading anything — a silent green.
+  const dir = mkdtempSync(join(tmpdir(), 'verdict gate '));
+  try {
+    const link = join(dir, 'gate link.mjs');
+    symlinkSync(GATE, link);
+    const p = join(dir, 'my review.md');
+    writeFileSync(p, review({ verdict: 'BLOCK', severities: ['BLOCKER'] }));
+    const r = spawnSync(process.execPath, [link, p], { encoding: 'utf-8' });
+    assert.equal(r.status, 1, r.stdout + r.stderr);
+    assert.match(r.stdout, /BLOCK/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});