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/validators/review-validator.test.mjs

@@ -1,7 +1,14 @@
 import { test } from 'node:test';
 import { strict as assert } from 'node:assert';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, rmSync, symlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { validateReviewContent } from '../../lib/validators/review-validator.mjs';
 
+const VALIDATOR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'lib', 'validators', 'review-validator.mjs');
+
 const GOOD_REVIEW = `---
 type: trekreview
 review_version: "1.0"
@@ -13,6 +20,7 @@ brief_path: .claude/projects/2026-04-30-jwt-auth/brief.md
 scope_sha_start: abc123
 scope_sha_end: def456
 reviewed_files_count: 7
+verdict: ALLOW
 findings:
   - 0123456789abcdef0123456789abcdef01234567
   - fedcba9876543210fedcba9876543210fedcba98
@@ -112,3 +120,88 @@ test('validateReview — empty findings array is acceptable (no findings = ALLOW
   const r = validateReviewContent(t);
   assert.equal(r.valid, true, JSON.stringify(r.errors));
 });
+
+// ---- K7: the verdict is required in review.md (ordre 5) ----------------------
+
+const NO_VERDICT = GOOD_REVIEW.replace(/^verdict: .*\n/m, '');
+
+test('validateReview — strict mode rejects a review.md without verdict (REVIEW_MISSING_VERDICT)', () => {
+  assert.ok(!/^verdict:/m.test(NO_VERDICT), 'fixture control: the verdict line is gone');
+  const r = validateReviewContent(NO_VERDICT, { strict: true });
+  assert.equal(r.valid, false, 'a review without a verdict must not pass the write-time check');
+  assert.ok(r.errors.find(e => e.code === 'REVIEW_MISSING_VERDICT'), JSON.stringify(r.errors));
+});
+
+test('validateReview — soft (read-time) mode only warns on a missing verdict (N-1 window for 1.0 reviews)', () => {
+  const r = validateReviewContent(NO_VERDICT, { strict: false });
+  assert.equal(r.valid, true, JSON.stringify(r.errors));
+  assert.ok(r.warnings.find(w => w.code === 'REVIEW_MISSING_VERDICT'));
+});
+
+test('validateReview — a verdict outside ALLOW|WARN|BLOCK is an error in both modes', () => {
+  const t = GOOD_REVIEW.replace('verdict: ALLOW', 'verdict: PASS');
+  for (const strict of [true, false]) {
+    const r = validateReviewContent(t, { strict });
+    assert.equal(r.valid, false);
+    assert.ok(r.errors.find(e => e.code === 'REVIEW_BAD_VERDICT'));
+  }
+});
+
+// ---- A BLOCKER is written as a plan step Handover 6 can append (ordre 5) ----
+
+const BLOCKER_ID = '763d174e6c519fafbadcba5d1706708479e36e61';
+const WITH_BLOCKER = GOOD_REVIEW.replace('verdict: ALLOW', 'verdict: BLOCK') + `
+\`\`\`json
+{"verdict": "BLOCK", "counts": {"BLOCKER": 1, "MAJOR": 0, "MINOR": 0, "SUGGESTION": 0},
+ "findings": [{"id": "${BLOCKER_ID}", "severity": "BLOCKER", "rule_key": "UNIMPLEMENTED_CRITERION", "file": "lib/login.mjs", "line": 23}]}
+\`\`\`
+`;
+const STEP = `
+## Remediation Steps
+
+### Step R1: Return 401 on a bad password
+
+- **Files:** \`lib/login.mjs\`
+- **Source finding:** \`${BLOCKER_ID}\`
+- **Verify:** re-run /trekreview → finding \`${BLOCKER_ID}\` absent
+`;
+
+test('validateReview — strict: a BLOCKER without a numbered remediation step is an error', () => {
+  const r = validateReviewContent(WITH_BLOCKER, { strict: true });
+  assert.equal(r.valid, false);
+  assert.ok(r.errors.find(e => e.code === 'REVIEW_MISSING_REMEDIATION_STEP'), JSON.stringify(r.errors));
+});
+
+test('validateReview — strict: a BLOCKER with its "Step R1 … Source finding" passes', () => {
+  const t = WITH_BLOCKER.replace('## Remediation Summary', `${STEP}\n## Remediation Summary`);
+  const r = validateReviewContent(t, { strict: true });
+  assert.equal(r.valid, true, JSON.stringify(r.errors));
+});
+
+test('validateReview — soft: a missing remediation step only warns', () => {
+  const r = validateReviewContent(WITH_BLOCKER, { strict: false });
+  assert.equal(r.valid, true);
+  assert.ok(r.warnings.find(w => w.code === 'REVIEW_MISSING_REMEDIATION_STEP'));
+});
+
+test('validateReview — a clean review with zero findings validates with `findings: []` (a bare `findings:` does not)', () => {
+  const ids = /findings:\n(?:  - [0-9a-f]{40}\n)+/;
+  assert.match(GOOD_REVIEW, ids, 'fixture control');
+  assert.equal(validateReviewContent(GOOD_REVIEW.replace(ids, 'findings: []\n'), { strict: true }).valid, true);
+  assert.equal(validateReviewContent(GOOD_REVIEW.replace(ids, 'findings:\n'), { strict: true }).valid, false);
+});
+
+test('review-validator CLI — run through a symlink and a path with a space it still validates (exit 1, not a silent 0)', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'review validator '));
+  try {
+    const link = join(dir, 'validator link.mjs');
+    symlinkSync(VALIDATOR, link);
+    const p = join(dir, 'no verdict.md');
+    writeFileSync(p, NO_VERDICT);
+    const r = spawnSync(process.execPath, [link, p], { encoding: 'utf-8' });
+    assert.equal(r.status, 1, r.stdout + r.stderr);
+    assert.match(r.stderr, /REVIEW_MISSING_VERDICT/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});