// tests/lib/review-630.test.mjs
// The findings of the release review of 6.3.0 (2026-10-10), each held by a
// test that failed on f669b87. The guard's and the release check's own tests
// live next to their files (tests/commands/trekexecute-coupling.test.mjs,
// tests/hooks/guards-review-regressions.test.mjs, tests/scripts/release-check.test.mjs).

import { test, mock } from 'node:test';
import { strict as assert } from 'node:assert';
import { spawnSync } from 'node:child_process';
import fs from 'node:fs';
import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
import { syncBuiltinESMExports } from 'node:module';
import { tmpdir } from 'node:os';
import { dirname, join } from 'node:path';
import { fileURLToPath } from 'node:url';
import { buildPlan } from '../helpers/plan-v18-builder.mjs';
import { pathWith } from '../helpers/bin-path.mjs';
import { validatePlanContent } from '../../lib/validators/plan-validator.mjs';
import { stepTestsOnly } from '../../lib/parsers/plan-schema.mjs';
import { validateFindings } from '../../lib/review/findings-schema.mjs';
import { lintSkill } from '../../lib/skills/skill-lint.mjs';
import * as routing from '../../lib/skills/routing.mjs';
import { childEnv } from '../helpers/child-env.mjs';
import * as timing from '../helpers/timing.mjs';

const awaitImportSync = () => routing;

const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
const read = (rel) => readFileSync(join(ROOT, rel), 'utf8');
const VALIDATOR = join(ROOT, 'lib', 'validators', 'plan-validator.mjs');

// The review template's own Step R1, appended the Phase 7.2 way.
function withTemplateStep(plan, n) {
  const r1 = /### Step R1:[^\n]*\n[\s\S]*?(?=\n> )/.exec(read('templates/trekreview-template.md'));
  assert.ok(r1, 'templates/trekreview-template.md carries a ### Step R1');
  // Phase 7.2 step 2 also adds the manifest the legacy rule synthesizes (expected_paths ← Files).
  const appended = r1[0].replace(/^### Step R1:/, `### Step ${n}:`) +
    '- **Checkpoint:** `git commit -m "fix(review): x [01234567]"`\n' +
    '- **Manifest:**\n  ```yaml\n  manifest:\n    expected_paths:\n      - lib/foo.mjs\n    min_file_count: 1\n' +
    '    commit_message_pattern: "^fix\\\\(review\\\\):"\n    bash_syntax_check: []\n    forbidden_paths: []\n    must_contain: []\n  ```\n';
  return plan.replace('\n## Test Strategy', `\n${appended}\n## Test Strategy`);
}

// ---- BLOCKER 1b25ba56: appended review steps hold the 1.8 step rules on any plan

test('review 630 / 1b25ba56: on a 1.7 plan, an appended review step that cannot run is refused (--steps-from)', () => {
  const dir = mkdtempSync(join(tmpdir(), 'r630-'));
  try {
    const plan = withTemplateStep(buildPlan({ version: '1.7', design: false }), 3);
    const p = join(dir, 'plan.md');
    writeFileSync(p, plan);
    const plain = spawnSync(process.execPath, [VALIDATOR, '--strict', '--json', p], { encoding: 'utf8' });
    assert.equal(plain.status, 0, 'the control: a 1.7 plan is not held to the 1.8 step rules');
    const r = spawnSync(process.execPath, [VALIDATOR, '--strict', '--json', '--steps-from', '3', p], { encoding: 'utf8' });
    assert.equal(r.status, 1, `the appended step is held to them: ${r.stdout}`);
    const codes = JSON.parse(r.stdout).errors.map((e) => e.code);
    assert.ok(codes.includes('PLAN_STEP_VERIFY_NOT_RUNNABLE') || codes.includes('PLAN_STEP_NO_TEST_FIRST'), codes.join(','));
  } finally { rmSync(dir, { recursive: true, force: true }); }
});

test('review 630 / 1b25ba56: --steps-from leaves the earlier steps of a 1.7 plan alone', () => {
  const plan = buildPlan({ version: '1.7', design: false, steps: [{ testFirst: false }, { endToEnd: 'bash tests/e2e.sh' }] });
  assert.deepEqual(validatePlanContent(plan, { strict: true, stepsFrom: 3 }).errors, [],
    'step 1 has no Test first, and it is not one of the appended steps');
});

test('review 630 / 1b25ba56: Phase 7.2 validates the appended steps with --steps-from', () => {
  const cmd = read('commands/trekexecute.md');
  assert.match(cmd, /plan-validator\.mjs --strict --json --steps-from \{total \+ 1\} "\{plan_path\}"/);
});

// ---- 57a5e67c: the wave path names the guard's refusal ------------------------

test('review 630 / 57a5e67c: the wave merge path says what to do when the guard refused because no one can be asked', () => {
  const cmd = read('commands/trekexecute.md');
  const at = cmd.indexOf('**Merge session branches back (SEQUENTIAL, one at a time):**');
  const before = cmd.slice(cmd.lastIndexOf('- **`all_completed: true`:**', at), at);
  assert.match(before, /no one to ask/, 'the guard-refused case is named on the wave path');
  assert.match(before, /by hand/, 'and the way on: the operator runs the merge by hand');
  assert.match(before, /wave\.json/, 'wave.json is kept');
});

// ---- 2cf29d6f / 727924c0: what counts as a step of only tests ------------------

test('review 630: a comma inside a Files: note is not a path', () => {
  const body = '- **Files:** `tests/a.test.mjs` (new: covers x, y)\n- **Changes:** add the test\n';
  assert.deepEqual(stepTestsOnly(body), { testsOnly: true, files: ['tests/a.test.mjs'] });
});

test('review 630: a data file under specs/ is not a test', () => {
  const body = '- **Files:** `api/specs/openapi.yaml`\n- **Changes:** add the endpoint\n';
  assert.equal(stepTestsOnly(body).testsOnly, false);
  const fixture = '- **Files:** `tests/fixtures/users.json`\n- **Changes:** add the fixture\n';
  assert.equal(stepTestsOnly(fixture).testsOnly, true, 'the control: a fixture under tests/ is a test file');
});

test('review 630: a tests-only End-to-end step is told where End-to-end belongs', () => {
  const plan = buildPlan({ steps: [{}, { file: 'tests/e2e.sh', test: 'tests/e2e.sh', endToEnd: 'bash tests/e2e.sh' }] });
  const w = validatePlanContent(plan, { strict: true }).warnings.find((x) => x.code === 'PLAN_STEP_TESTS_ONLY');
  assert.ok(w, 'the warning fires: red proof would reject this step');
  assert.match(`${w.message} ${w.hint ?? ''}`, /`End-to-end:` (rides|belongs) on the last step that builds/);
  assert.match(read('templates/plan-template.md'), /`End-to-end:` (rides|belongs) on the last step that builds/);
});

// ---- c4623362: a removed line can still be cited --------------------------------

test('review 630 / c4623362: the out-of-range hint says how to cite a line that no longer exists', () => {
  const r = validateFindings({ reviewer: 'r', findings: [{
    id: 'a'.repeat(40), severity: 'MAJOR', rule_key: 'MISSING_TEST', file: 'package.json', line: 1,
    brief_ref: 'x', title: 't', recommended_action: 'a',
    detail: 'the check formerly at package.json:9999 was removed',
  }] }, { repoRoot: ROOT });
  const e = r.errors.find((x) => x.code === 'FINDING_PROSE_LINE_OUT_OF_RANGE');
  assert.ok(e, 'the control: the plain citation is still checked');
  assert.match(e.hint, /<rev>:<path>:<line>/);
  const ok = validateFindings({ reviewer: 'r', findings: [{
    id: 'a'.repeat(40), severity: 'MAJOR', rule_key: 'MISSING_TEST', file: 'package.json', line: 1,
    brief_ref: 'x', title: 't', recommended_action: 'a',
    detail: 'the check formerly at v6.2.0:package.json:9999 was removed',
  }] }, { repoRoot: ROOT });
  assert.deepEqual(ok.errors, [], 'a revision-qualified citation is not judged against today\'s file');
  assert.match(read('commands/trekreview.md'), /<rev>:<path>:<line>/, 'the re-ask names the form');
});

// ---- 2261016d: a 499-line SKILL.md is under the 500-line limit -------------------

test('review 630 / 2261016d: a SKILL.md of 499 lines ending in a newline passes the size rule', () => {
  const dir = mkdtempSync(join(tmpdir(), 'r630-skill-'));
  try {
    const skill = join(dir, 'test-first');
    cpSync(join(ROOT, 'skills', 'test-first'), skill, { recursive: true });
    const text = readFileSync(join(skill, 'SKILL.md'), 'utf8').replace(/\n+$/, '\n');
    const lines = text.split('\n').length - 1;
    assert.ok(lines < 499, `the fixture pads the real skill (${lines} lines)`);
    const padded = text.replace('\n## Credits', `${'\n'.repeat(499 - lines)}\n## Credits`);
    assert.equal(padded.split('\n').length - 1, 499);
    writeFileSync(join(skill, 'SKILL.md'), padded);
    const codes = lintSkill(skill).errors.map((e) => e.code);
    assert.ok(!codes.includes('SKILL_TOO_LONG'), codes.join(','));
    writeFileSync(join(skill, 'SKILL.md'), padded + '\n');
    assert.ok(lintSkill(skill).errors.map((e) => e.code).includes('SKILL_TOO_LONG'), 'the control: 500 lines fail');
  } finally { rmSync(dir, { recursive: true, force: true }); }
});

// ---- cb34c32e: regression-check takes commandEnv from the shared util ------------

test('review 630 / cb34c32e: regression-check takes commandEnv from lib/util/command-env.mjs', () => {
  // Round 5 (MINOR 0e98d5c7): regression-check has no exec of its own any more;
  // it runs through the criteria runner's runCommand, which takes commandEnv
  // from lib/util/command-env.mjs.
  const src = read('lib/verification/regression-check.mjs');
  assert.doesNotMatch(src, /from '\.\/red-proof\.mjs'/);
  assert.match(src, /runCriteria\(c, o\)/);
  assert.match(read('lib/verification/criteria-runner.mjs'), /import \{ commandEnv \} from '\.\.\/util\/command-env\.mjs';/);
});

// ---- CLAUDE.md names the mode-read exemptions as they are -----------------------

test('review 630: CLAUDE.md counts the mode-read exemptions the launch test holds', () => {
  const src = read('tests/lib/no-claude-code-launch.test.mjs');
  const n = (src.match(/\['mode-read', \d+,/g) || []).length;
  assert.equal(n, 4, 'the launch test holds four mode-read entries');
  assert.match(read('CLAUDE.md'), /four files that only read\s+(?:> )?the session's permission mode/);
});

// ---- /security-review, older than v6.2.0: a read-only git that writes a file ----

test('review 630 / security: `git diff --output=<path>` is not a read-only check', async () => {
  const { allowedCommand } = await import('../../lib/verification/criteria-runner.mjs');
  assert.equal(allowedCommand('git diff --stat').allowed, true, 'the control: a read-only git check runs');
  assert.equal(allowedCommand('git log --output-indicator-new=+ -1').allowed, true, 'an option that only starts with --output is not it');
  for (const cmd of ['git diff --output=../../.zshrc', 'git diff --output ../x', 'git log -p --output=x', 'git show HEAD --output=x']) {
    const r = allowedCommand(cmd);
    assert.equal(r.allowed, false, `${cmd} writes a file`);
    assert.match(r.reason, /--output/);
  }
});

// ==== round 2 of the release review (2026-10-10), each red on 0d044f6 ===========

test('review 630 r2 / BLOCKER: a quoted, escaped or expanded --output is refused too', async () => {
  const { allowedCommand } = await import('../../lib/verification/criteria-runner.mjs');
  for (const cmd of [
    'git diff "--output=/tmp/x"', "git log -p '--output'=x", "git diff '--output=q1'", 'git log "--output" q1',
    'git diff --output\\=x', 'git diff --\\output=q1', 'git diff --out{put,x}=y', 'git diff --outp$EMPTY=x',
    'git diff --outp?t=x', 'git diff --outpu=x', 'git log --out x',
  ]) {
    assert.equal(allowedCommand(cmd).allowed, false, `${cmd} must not reach the shell`);
  }
  for (const cmd of ['git log --oneline -1', 'git diff --stat HEAD~1', 'git show HEAD^:package.json', 'git log --format=%h -1',
    'git ls-files tests/', 'git log --output-indicator-new=+ -1']) {
    assert.equal(allowedCommand(cmd).allowed, true, `the control: ${cmd} is a read-only check`);
  }
});

test('review 630 r2: a Files: entry without backticks names every path in it', () => {
  const body = '- **Files:** tests/a.test.mjs + src/b.mjs\n- **Changes:** x\n';
  assert.deepEqual(stepTestsOnly(body), { testsOnly: false, files: ['tests/a.test.mjs', 'src/b.mjs'] });
  const and = '- **Files:** tests/a.test.mjs and src/b.mjs\n- **Changes:** x\n';
  assert.equal(stepTestsOnly(and).testsOnly, false);
  const plain = '- **Files:** Makefile\n- **Changes:** x\n';
  assert.deepEqual(stepTestsOnly(plain).files, ['Makefile'], 'the control: a bare file name is still a path');
});

test('review 630 r2: a backticked path with parentheses keeps them', () => {
  const body = '- **Files:** `app/(auth)/login.check.sh` (new)\n- **Changes:** x\n' +
    '- **Test first:**\n  - File: `app/(auth)/login.check.sh` (new)\n  - Verifies: y\n';
  assert.deepEqual(stepTestsOnly(body), { testsOnly: true, files: ['app/(auth)/login.check.sh'] });
});

test('review 630 r2: --steps-from reads the plan\'s ## Verification for an appended End-to-end step', () => {
  const plan = buildPlan({ version: '1.7', design: false });
  const e2e = '### Step 3: Run it\n\n- **Files:** `src/run.mjs`\n- **Changes:** wire it\n' +
    '- **Test first:**\n  - File: `tests/run.test.mjs` (new)\n  - Verifies: it runs\n' +
    '- **Verify:** `node --test tests/run.test.mjs` → expected: exit 0\n' +
    '- **End-to-end:** `bash tests/e2e.sh` → expected: the CLI prints ok\n' +
    '- **Manifest:**\n  ```yaml\n  manifest:\n    expected_paths:\n      - src/run.mjs\n    min_file_count: 1\n' +
    '    commit_message_pattern: "^fix"\n    bash_syntax_check: []\n    forbidden_paths: []\n    must_contain: []\n  ```\n';
  const edited = plan.replace('\n## Test Strategy', `\n${e2e}\n## Test Strategy`);
  assert.match(edited, /- \[ \] `bash tests\/e2e\.sh`/, 'the fixture lists the command under ## Verification');
  const r = validatePlanContent(edited, { strict: true, stepsFrom: 3 });
  assert.deepEqual(r.errors.map((e) => e.code), [], JSON.stringify(r.errors));
});

test('review 630 r2: --soft --steps-from warns instead of failing', () => {
  const plan = withTemplateStep(buildPlan({ version: '1.7', design: false }), 3);
  const soft = validatePlanContent(plan, { strict: false, stepsFrom: 3 });
  assert.equal(soft.valid, true, JSON.stringify(soft.errors));
  assert.ok(soft.warnings.some((w) => /VERIFY_NOT_RUNNABLE|TEST_FIRST/.test(w.code)), 'the issue is still reported');
  assert.equal(validatePlanContent(plan, { strict: true, stepsFrom: 3 }).valid, false, 'the control: strict fails');
});

test('review 630 r2: regression-check prints the status progress.json takes', async () => {
  const { checkRegression } = await import('../../lib/verification/regression-check.mjs');
  const { PROGRESS_REGRESSION_VALUES } = await import('../../lib/validators/progress-validator.mjs');
  const plan = '## Implementation Plan\n\n### Step 1: x\n\n- **Regression:** `npm test`\n';
  const blocked = checkRegression({ planText: plan, step: 1, run: () => [{ status: 'blocked', command: 'npm test' }] });
  assert.equal(blocked.progress_status, 'unrunnable');
  const missing = checkRegression({ planText: plan, step: 9 });
  assert.equal(missing.progress_status, 'not-run');
  for (const r of [blocked, missing]) assert.ok(PROGRESS_REGRESSION_VALUES.includes(r.progress_status));
  assert.match(read('commands/trekexecute.md'), /`progress_status`/, 'the executor writes that field');
});

test('review 630 r2: a skill is found by its name even when an agent has the same name', () => {
  const dir = mkdtempSync(join(tmpdir(), 'r630-route-'));
  try {
    for (const d of ['skills', 'commands', 'agents', 'evals']) cpSync(join(ROOT, d), join(dir, d), { recursive: true });
    writeFileSync(join(dir, 'agents', 'debugging.md'),
      '---\nname: debugging\ndescription: Bakes sourdough loaves and schedules oven time for the shared kitchen rota.\nmodel: opus\n---\n\nBread.\n');
    const { checkRouting } = awaitImportSync();
    const codes = checkRouting(dir).errors.map((e) => e.code);
    assert.ok(!codes.includes('ROUTING_UNKNOWN_SKILL'), codes.join(','));
  } finally { rmSync(dir, { recursive: true, force: true }); }
});

test('review 630 r2: rank() does not rebuild the document vectors per call', () => {
  const { buildCorpus, rank } = awaitImportSync();
  const corpus = buildCorpus([
    { id: 'a', name: 'alpha', description: 'parses plans and validates steps' },
    { id: 'b', name: 'beta', description: 'runs tests and reports failures' },
  ]);
  let calls = 0;
  const idf = corpus.idf;
  corpus.idf = (t) => { calls++; return idf(t); };
  rank('validates plans', corpus);
  rank('reports failures', corpus);
  assert.ok(calls <= 4, `idf was called ${calls} times for two two-word prompts`);
});

test('review 630 r2 (operator 2026-10-10): Phase 7.2 says plainly that template-form steps stop with a re-plan', () => {
  const cmd = read('commands/trekexecute.md');
  assert.match(cmd, /Today the loop runs only for steps written as\s+runnable plan steps/);
  assert.match(cmd, /re-plan from the review" — the\s+usual outcome until a later order/);
});

// ==== round 3 of the release review (2026-10-10), each red on 96cb977 ===========

test('review 630 r3 / BLOCKER: no runner takes an option that writes a file or loads code', async () => {
  const { allowedCommand } = await import('../../lib/verification/criteria-runner.mjs');
  for (const cmd of [
    'node --test --test-reporter=tap --test-reporter-destination=/tmp/x',
    'node --test --import=data:text/javascript,1',
    'node --test "--import=data:text/javascript,import(\'node:fs\')"',
    'node --test --require ./evil.cjs',
    'node --test --test-reporter=./evil-reporter.mjs',
    'node --test --test-reporter ./evil-reporter.mjs',
    'jest --json --outputFile=/tmp/x',
    'jest --config=evil.js',
    'vitest --outputFile=/tmp/x',
    'vitest run --reporter=./evil.mjs',
    'pytest --junitxml=/tmp/x',
    'pytest --basetemp=/tmp/anydir',
    'pytest -p evil_plugin',
    'python -m pytest --junitxml=/tmp/x',
    'uv run pytest --basetemp=/tmp/x',
    'go test -o /tmp/x',
    'go test -exec /tmp/evil ./...',
    'cargo test --target-dir=/tmp/x',
    'npm test -- --test-reporter-destination=/tmp/x',
    'npm test --script-shell=/tmp/evil',
    'npm run verify -- --outputFile=/tmp/x',
    'make test SHELL=/tmp/evil',
    'make test -f /tmp/evil.mk',
    'bash tests/x.sh "$(id)"',
  ]) {
    assert.equal(allowedCommand(cmd, { cwd: ROOT }).allowed, false, `${cmd} must not reach the shell`);
  }
  for (const cmd of [
    'npm test', 'npm test -- tests/lib/criteria-runner.test.mjs', 'node --test tests/lib/criteria-runner.test.mjs',
    'node --test tests/lib/*.test.mjs', 'node --test --test-reporter=tap tests/lib/review-630.test.mjs', 'node --test --test-reporter dot', 'node --test --test-name-pattern=review tests/lib/review-630.test.mjs',
    'vitest run', 'jest --ci', 'pytest -q', 'pytest -x -q tests/', 'python3 -m pytest tests/', 'uv run pytest',
    'cargo test', 'cargo test --release', 'go test ./...', 'go test -run TestX -count=1 ./pkg', 'make test',
    'bash tests/fixtures/criteria-exit-0.sh', 'bash tests/fixtures/criteria-exit-0.sh --fast',
  ]) {
    const r = allowedCommand(cmd, { cwd: ROOT });
    assert.equal(r.allowed, true, `the control: ${cmd} is a test run (${r.reason})`);
  }
});

test('review 630 r3: a restore the guard refuses is never recorded as reverted', async () => {
  const { PROGRESS_SIMPLIFY_VALUES } = await import('../../lib/validators/progress-validator.mjs');
  assert.ok(PROGRESS_SIMPLIFY_VALUES.includes('revert-refused'), 'progress.json can say the restore was refused');
  assert.match(read('docs/HANDOVER-CONTRACTS.md'), /`applied \\| clean \\| reverted \\| revert-refused \\| not-run`/);
  const cmd = read('commands/trekexecute.md');
  const onFailure = cmd.slice(cmd.indexOf('**`On failure: revert`** and **`On failure: retry`**'), cmd.indexOf('**`On failure: skip`**'));
  assert.match(onFailure, /guard refuses the restore/, 'the step revert says what happens when the guard refuses it');
  const simplify = cmd.slice(cmd.indexOf('2. **`/simplify`**'), cmd.indexOf('3. **`/trekreview`**'));
  assert.match(simplify, /simplify = "revert-refused"/);
  assert.match(simplify, /never `"reverted"`/);
});

test('review 630 r3: a fixture document under tests/ is a test file, and "e.g." is not a path', () => {
  const step = (files) => `- **Files:** ${files}\n- **Changes:** x\n`;
  assert.equal(stepTestsOnly(step('`tests/a.test.mjs`, `tests/fixtures/sample.md`')).testsOnly, true);
  assert.deepEqual(stepTestsOnly(step('tests/a.test.mjs (new), e.g. the fixture tests/fixtures/x.json')),
    { testsOnly: true, files: ['tests/a.test.mjs', 'tests/fixtures/x.json'] });
  assert.equal(stepTestsOnly(step('`docs/specs/api.md`')).testsOnly, false, 'a document outside tests/ is still not a test');
  assert.deepEqual(stepTestsOnly(step('`./tests/a.test.mjs`')).files, ['tests/a.test.mjs'], './ is stripped');
});

test('review 630 r3: the plan-file sweep and the tests-only check both drop a leading ./', async () => {
  // Round 3 had the sweep read Files: through the tests-only reader; the
  // operator reversed that on 2026-10-11 (the K6 sweep keeps v6.2.0's reader,
  // round 5). What the round-3 finding named still holds: `./` is dropped by both.
  const { plannedPaths } = await import('../../lib/verification/plan-scope-sweep.mjs');
  const plan = '## Implementation Plan\n\n### Step 1: x\n\n- **Files:** `./src/a.mjs`, `./tests/b.test.mjs`\n- **Changes:** x\n';
  const body = plan.slice(plan.indexOf('### Step 1'));
  assert.deepEqual(plannedPaths(plan), ['src/a.mjs', 'tests/b.test.mjs']);
  assert.deepEqual(stepTestsOnly(body).files, ['src/a.mjs', 'tests/b.test.mjs']);
});

test('review 630 r3: --steps-from refuses an appended step with no Verify: on a 1.8 plan too', () => {
  const plan = buildPlan({});
  const step = '### Step 3: Fix it\n\n- **Files:** `src/fix.mjs`, `tests/fix.test.mjs`\n- **Changes:** fix it\n' +
    '- **Test first:**\n  - File: `tests/fix.test.mjs` (new)\n  - Verifies: it is fixed\n- **On failure:** escalate\n';
  const edited = plan.replace('\n## Test Strategy', `\n${step}\n## Test Strategy`);
  assert.ok(edited.includes('### Step 3: Fix it'), 'the fixture appends the step');
  const r = validatePlanContent(edited, { strict: true, stepsFrom: 3 });
  assert.ok(r.errors.some((e) => e.code === 'PLAN_STEP_VERIFY_NOT_RUNNABLE' && /Step 3/.test(e.message)),
    JSON.stringify(r.errors.map((e) => e.code)));
});

test('review 630 r3: the plan validator hands its parsed fields to the tests-only check', async () => {
  const schema = await import('../../lib/parsers/plan-schema.mjs');
  assert.equal(typeof schema.stepTestsOnlyFromFields, 'function');
  const body = '- **Files:** `tests/a.test.mjs`\n- **Changes:** x\n';
  assert.deepEqual(schema.stepTestsOnlyFromFields(schema.parseStepFields(body)), stepTestsOnly(body));
  assert.match(read('lib/validators/plan-validator.mjs'), /stepTestsOnlyFromFields\(f, planVersion\)/);
});

test('review 630 r3: skill frontmatter - a value starting with # is a hazard, an escaped backslash closes a quote', async () => {
  const { plainScalarHazards, readFrontmatterFields } = await import('../../lib/skills/skill-frontmatter.mjs');
  assert.ok(plainScalarHazards('#1 helper. Use when testing.').length > 0, 'YAML reads "#..." as a comment: the value is null');
  const r = readFrontmatterFields('---\nname: x\ndescription: "Path C:\\\\"\n---\nbody\n');
  assert.equal(r.fields.description?.value, 'Path C:\\', JSON.stringify(r));
  const open = readFrontmatterFields('---\nname: x\ndescription: "a \\"\n---\nbody\n');
  assert.ok(JSON.stringify(open).includes('unclosed double quote'), 'a quote escaped by one backslash is still open');
});

test('review 630 r3: routing reads a kind tag only from its own table, never Object.prototype', () => {
  const dir = mkdtempSync(join(tmpdir(), 'r630-proto-'));
  try {
    for (const d of ['skills', 'commands', 'agents', 'evals']) cpSync(join(ROOT, d), join(dir, d), { recursive: true });
    const c = join(dir, 'evals', 'zz-proto');
    cpSync(join(ROOT, 'evals', 'skill-test-first-quiet-1'), c, { recursive: true });
    writeFileSync(join(c, 'prompt.md'), '---\ntags: [constructor, owner=nobody, from=test]\n---\n\nWhat time is it?\n');
    const { checkRouting } = awaitImportSync();
    const r = checkRouting(dir);
    assert.ok(!r.errors.some((e) => String(e.message ?? '').includes('zz-proto') || e.case === 'zz-proto'), JSON.stringify(r.errors));
  } finally { rmSync(dir, { recursive: true, force: true }); }
});

// ==== round 4 of the release review (2026-10-10), each red on 41ea8fc ===========

test('review 630 r4: the Files: reader keeps every path the field names, and only those', async () => {
  const { fieldPaths } = await import('../../lib/parsers/plan-schema.mjs');
  const cases = [
    ['`src/a.mjs` (fixture: `tests/fixtures/a.json`)', ['src/a.mjs', 'tests/fixtures/a.json']],
    ['`tests/a.test.mjs`, `src/a.mjs`.', ['tests/a.test.mjs', 'src/a.mjs']],
    ['`src/cli.mjs`: add the flag; `src/b.mjs`.', ['src/cli.mjs', 'src/b.mjs']],
    ['`tests/a.test.mjs` — covers parse, format', ['tests/a.test.mjs']],
    ['docs/ and README.md', ['docs/', 'README.md']],
    ['app/(auth)/x.ts', ['app/(auth)/x.ts']],
    ['src/*.mjs (all of them)', ['src/*.mjs']],
    ['notes for v6.3.0, src/x.mjs', ['src/x.mjs']],
    ['Makefile', ['Makefile']],
    ['tests/a.test.mjs + src/b.mjs', ['tests/a.test.mjs', 'src/b.mjs']],
  ];
  for (const [text, want] of cases) assert.deepEqual(fieldPaths(text), want, text);
  const body = '- **Files:** `tests/a.test.mjs`, `src/a.mjs`.\n- **Changes:** x\n';
  assert.equal(stepTestsOnly(body).testsOnly, false, 'a step that changes src/a.mjs is not tests-only');
  const { plannedPaths } = await import('../../lib/verification/plan-scope-sweep.mjs');
  const plan = '## Implementation Plan\n\n### Step 1: x\n\n- **Files:** `src/cli.mjs`: add the flag; `src/b.mjs`.\n- **Changes:** x\n';
  assert.deepEqual(plannedPaths(plan), ['src/b.mjs', 'src/cli.mjs'], 'K6 plans what v6.2.0 planned');
});

test('review 630 r4: a quoted frontmatter value may carry a YAML comment', async () => {
  const { readFrontmatterFields } = await import('../../lib/skills/skill-frontmatter.mjs');
  const r = readFrontmatterFields('---\nname: "debugging" # pinned\ndescription: \'Use it.\' # note\n---\nbody\n');
  assert.equal(r.fields.name?.value, 'debugging', JSON.stringify(r));
  assert.equal(r.fields.description?.value, 'Use it.', JSON.stringify(r));
  const bad = readFrontmatterFields('---\nname: "debugging" trailing\n---\nbody\n');
  assert.ok(JSON.stringify(bad).includes('unclosed double quote') || bad.fields.name?.value !== 'debugging',
    'text after the closing quote that is not a comment is not accepted silently');
});

test('review 630 r4: no tilde word, and nothing after `make test`', async () => {
  const { allowedCommand } = await import('../../lib/verification/criteria-runner.mjs');
  for (const cmd of ['node --test ~/x.test.mjs', 'node --test --test-name-pattern=~x', 'git log ~/x', 'git diff ~root/x',
    'make test install', 'make test deploy']) {
    assert.equal(allowedCommand(cmd, { cwd: ROOT }).allowed, false, `${cmd} must not reach the shell`);
  }
  for (const cmd of ['git diff --stat HEAD~1', 'git show HEAD~2:package.json', 'make test']) {
    assert.equal(allowedCommand(cmd, { cwd: ROOT }).allowed, true, `the control: ${cmd}`);
  }
});

// ==== round 5 of the release review (2026-10-11), each red on d37e538 ===========
// Operator 2026-10-11: no more patching of the same two places. A check runs
// with no shell (its words reach the runner as written), and the K6 sweep has
// its own v6.2.0 reader again; the shared reader stays for the tests-only check.

const PASS_SCREENS = { allow: () => ({ allowed: true, reason: '' }), screen: () => ({ allowed: true, rule: '' }) };

test('review 630 r5 / da7584e7: a check runs without a shell - its words reach the runner as written', async () => {
  const { runCriteria } = await import('../../lib/verification/criteria-runner.mjs');
  const dir = mkdtempSync(join(tmpdir(), 'r630-noshell-'));
  try {
    mkdirSync(join(dir, 'tests'));
    writeFileSync(join(dir, 'tests', 'args.sh'), 'printf "%s\\n" "$@"\n');
    const [r] = runCriteria([{ label: 'X1', text: 'x', command: 'bash tests/args.sh ~/x *.sh $HOME' }], { cwd: dir, ...PASS_SCREENS });
    assert.equal(r.status, 'passed', r.output);
    assert.equal(r.output, '~/x\n*.sh\n$HOME\n', 'no shell expanded a tilde, a glob or a variable');
    const [missing] = runCriteria([{ label: 'X2', text: 'x', command: 'no-such-runner-r630 --x' }], { cwd: dir, ...PASS_SCREENS });
    // Round 6: a runner that could not start is NOT RUN (no measurement), never a pass and never a red.
    assert.equal(missing.status, 'unrunnable', 'a runner that is not installed is not run, never a pass');
    assert.match(missing.output, /could not start.*ENOENT/i, missing.output);
  } finally { rmSync(dir, { recursive: true, force: true }); }
});

test('review 630 r5 / c25f8704: a glob cannot climb out of tests/ or the repo', async () => {
  const { runCriteria, allowedCommand } = await import('../../lib/verification/criteria-runner.mjs');
  const base = mkdtempSync(join(tmpdir(), 'r630-escape-'));
  const repo = join(base, 'repo');
  try {
    mkdirSync(join(repo, 'tests'), { recursive: true });
    mkdirSync(join(repo, 'outside'));
    writeFileSync(join(repo, 'outside', 'evil.sh'), 'echo ESCAPED > escaped-bash.txt\n');
    writeFileSync(join(repo, 'tests', 'a.test.mjs'), "import { test } from 'node:test';\ntest('in', () => {});\n");
    writeFileSync(join(base, 'outside.test.mjs'),
      `import { test } from 'node:test';\nimport { writeFileSync } from 'node:fs';\ntest('out', () => { writeFileSync(${JSON.stringify(join(base, 'escaped-node.txt'))}, 'x'); });\n`);
    const results = runCriteria([
      { label: 'E1', text: 'x', command: 'bash tests/.?/outside/evil.sh' },
      { label: 'E2', text: 'x', command: 'node --test .*' },
    ], { cwd: repo });
    assert.equal(existsSync(join(repo, 'escaped-bash.txt')), false, `bash ran a script outside tests/: ${JSON.stringify(results[0])}`);
    assert.equal(existsSync(join(base, 'escaped-node.txt')), false, `node --test ran a test file outside the repo: ${JSON.stringify(results[1])}`);
    assert.notEqual(results[0].status, 'passed');
    for (const cmd of ['node --test ../outside.test.mjs', 'node --test tests/../../outside.test.mjs', 'node --test /tmp/x.test.mjs',
      'pytest ../tests', 'go test ../...', 'npm test -- ../x.test.mjs', 'jest /abs/x.test.js', 'vitest run ../x', 'bash tests/*.sh',
      'pytest tests/test_*.py', 'jest src/*.test.js', 'npm test -- tests/*.mjs']) {
      assert.equal(allowedCommand(cmd, { cwd: ROOT }).allowed, false, `${cmd} must not run`);
    }
    for (const cmd of ['node --test tests/lib/*.test.mjs', 'node --test tests/**/*.test.mjs', 'go test ./...', '/bin/bash tests/fixtures/criteria-exit-0.sh',
      'node --test tests/', 'pytest tests/', 'git diff HEAD~1..HEAD --stat']) {
      const r = allowedCommand(cmd, { cwd: ROOT });
      assert.equal(r.allowed, true, `the control: ${cmd} (${r.reason})`);
    }
  } finally { rmSync(base, { recursive: true, force: true }); }
});

test('review 630 r5 / 8f3cf84d: a word starting with @ is refused (pytest reads @file as more arguments)', async () => {
  const { allowedCommand } = await import('../../lib/verification/criteria-runner.mjs');
  for (const cmd of ['pytest @tests/args.txt', 'python -m pytest @tests/args.txt', 'python3 -m pytest -q @a', 'uv run pytest @a', 'node --test @a', 'jest @a']) {
    const r = allowedCommand(cmd, { cwd: ROOT });
    assert.equal(r.allowed, false, `${cmd} must not run`);
    assert.match(r.reason, /@/);
  }
});

test('review 630 r5 / da7584e7: every place that runs a check runs it with no shell', () => {
  for (const rel of ['lib/verification/criteria-runner.mjs', 'lib/verification/regression-check.mjs', 'lib/verification/red-proof.mjs',
    'lib/verification/done-line.mjs', 'lib/util/test-lock.mjs']) {
    const src = read(rel);
    assert.doesNotMatch(src, /spawnSync\(\s*['"](?:\/bin\/)?(?:ba)?sh['"]/, `${rel} starts a shell`);
    assert.doesNotMatch(src, /shell:\s*true/, `${rel} asks spawn for a shell`);
    if (rel !== 'lib/verification/criteria-runner.mjs') assert.match(src, /\brunCommand\b/, `${rel} runs through criteria-runner's runCommand`);
  }
  assert.doesNotMatch(read('lib/verification/regression-check.mjs'), /function exec\(/, 'regression-check has no exec of its own (MINOR 0e98d5c7)');
});

test('review 630 r5 / da7584e7: the done line runs its command with no shell', async () => {
  // sh reads `**` as `*` (one level); node --test expands its own pattern at
  // every depth. Only with no shell does the top-level test run.
  const { writeDoneLine } = await import('../../lib/verification/done-line.mjs');
  const repo = mkdtempSync(join(tmpdir(), 'r630-done-'));
  try {
    mkdirSync(join(repo, 'tests', 'sub'), { recursive: true });
    writeFileSync(join(repo, 'tests', 'sub', 'deep.test.mjs'), "import { test } from 'node:test';\ntest('deep', () => {});\n");
    writeFileSync(join(repo, 'tests', 'top.test.mjs'),
      `import { test } from 'node:test';\nimport { writeFileSync } from 'node:fs';\ntest('top', () => { writeFileSync(${JSON.stringify(join(repo, 'top-ran.txt'))}, 'x'); });\n`);
    for (const args of [['init', '-q'], ['-c', 'user.email=t@example.invalid', '-c', 'user.name=t', 'commit', '-q', '--allow-empty', '-m', 'x']]) {
      assert.equal(spawnSync('git', args, { cwd: repo }).status, 0);
    }
    const r = writeDoneLine({ cwd: repo, step: 1, cmd: 'node --test tests/**/*.test.mjs', report: join(repo, 'report.md') });
    assert.equal(r.status, 'written', JSON.stringify(r));
    assert.equal(existsSync(join(repo, 'top-ran.txt')), true, 'the pattern reached node as written');
  } finally { rmSync(repo, { recursive: true, force: true }); }
});

test('review 630 r5 / ff80c7ef 5dc53c7e 02cea4aa: the K6 sweep plans what v6.2.0 planned, with its own reader', async () => {
  const { plannedPaths } = await import('../../lib/verification/plan-scope-sweep.mjs');
  const plan = (files) => `## Implementation Plan\n\n### Step 1: x\n\n- **Files:** ${files}\n- **Changes:** x\n`;
  const cases = [
    ['`src/a.mjs` — replaces the helper in lib/util.mjs and touches config.json; see Node.js docs', ['src/a.mjs']],
    ['`src/cli.mjs` — follows the pattern in lib/', ['src/cli.mjs']],
    ['.gitignore, src/a.mjs', ['.gitignore', 'src/a.mjs']],
    ['src\\cli.mjs', ['src/cli.mjs']],
    ['`src/a.mjs`/`src/b.mjs`', ['src/a.mjs', 'src/b.mjs']],
    ['`src/a.mjs`—adds', ['src/a.mjs']],
    ['`src/cli.mjs`: add the flag; `src/b.mjs`.', ['src/b.mjs', 'src/cli.mjs']],
  ];
  for (const [files, want] of cases) assert.deepEqual(plannedPaths(plan(files)), want, files);
  assert.doesNotMatch(read('lib/verification/plan-scope-sweep.mjs'), /import \{[^}]*\bfieldPaths\b/, 'K6 does not read Files: through the tests-only reader');
});

test('review 630 r5 / a4c8005d 02cea4aa: the tests-only check takes only what passes a path test', () => {
  const step = (files) => `- **Files:** ${files}\n- **Changes:** x\n`;
  const cases = [
    ['`tests/parse.test.mjs` (asserts `parse()` throws)', true, ['tests/parse.test.mjs']],
    ['`tests/a.test.mjs` — covers pass/fail', true, ['tests/a.test.mjs']],
    ['`tests/a.test.mjs` — covers JSON, YAML', true, ['tests/a.test.mjs']],
    ['`tests/a.test.mjs` — calls `parser.parse()` twice', true, ['tests/a.test.mjs']],
    ['`tests/a.test.mjs`, .gitignore', false, ['tests/a.test.mjs', '.gitignore']],
    ['tests/a.test.mjs, .gitignore', false, ['tests/a.test.mjs', '.gitignore']],
    ['`tests/a.test.mjs`/`src/b.mjs`', false, ['tests/a.test.mjs', 'src/b.mjs']],
    ['`tests\\a.test.mjs`', true, ['tests/a.test.mjs']],
    ['tests\\a.test.mjs, src\\cli.mjs', false, ['tests/a.test.mjs', 'src/cli.mjs']],
    ['Makefile.', false, ['Makefile']],
  ];
  for (const [files, testsOnly, want] of cases) assert.deepEqual(stepTestsOnly(step(files)), { testsOnly, files: want }, files);
});

test('review 630 r5 / e1ff583a f582b9c2: frontmatter reads trailing space and a comment after a plain value as YAML does', async () => {
  const { readFrontmatterFields } = await import('../../lib/skills/skill-frontmatter.mjs');
  const r = readFrontmatterFields('---\nname: "debugging"  \nmodel: opus # operator pin\neffort: high   # pinned\ntags: [a]  \n' +
    'allowed-tools: [Read, Grep] # read only\ndescription: | # folded below\n  Use when x.\n---\nbody\n');
  assert.deepEqual(r.hazards, [], JSON.stringify(r.hazards));
  assert.equal(r.fields.name.value, 'debugging');
  assert.equal(r.fields.model.value, 'opus');
  assert.equal(r.fields.effort.value, 'high');
  assert.deepEqual(r.fields.tags.value, ['a']);
  assert.deepEqual(r.fields['allowed-tools'].value, ['Read', 'Grep']);
  assert.equal(r.fields.description.value, 'Use when x.\n');
  // The control: a description is the text Claude Code routes on, so a comment
  // that cuts it is still a hazard (quote it), and so is a value that is only a comment.
  for (const fm of ['description: Use when x happens #1.', 'description: Use when x # note', 'name: # x']) {
    assert.ok(readFrontmatterFields(`---\n${fm}\n---\nbody\n`).hazards.length > 0, fm);
  }
});

test('review 630 r5 / 41c43285 (operator 2026-10-09): the example plan keeps steps 1-2, and step 2 no longer says it must fail', () => {
  const plan = read('examples/01-add-verbose-flag/plan.md');
  const heading = plan.match(/^### Step 2: .*$/m)[0];
  assert.doesNotMatch(heading, /must FAIL/i, heading);
  assert.match(plan.slice(plan.indexOf(heading)), /should PASS today/, 'the step body still says it passes today');
  const progress = JSON.parse(read('examples/01-add-verbose-flag/progress.json'));
  const title = JSON.stringify(progress).match(/"title":"(Add stability test[^"]*)"/)?.[1];
  assert.equal(`### Step 2: ${title}`, heading, 'progress.json carries the same step title');
  const r = validatePlanContent(plan, { strict: false });
  const warned = r.warnings.filter((w) => w.code === 'PLAN_STEP_TESTS_ONLY').map((w) => w.message);
  assert.equal(warned.length, 2, `the operator kept the warning on steps 1-2: ${JSON.stringify(warned)}`);
});

// ==== round 6 of the release review (2026-10-11), each red on c3641ff ===========

function gitRepo(prefix) {
  const dir = mkdtempSync(join(tmpdir(), prefix));
  for (const args of [['init', '-q'], ['config', 'user.email', 't@example.invalid'], ['config', 'user.name', 't'], ['config', 'commit.gpgsign', 'false']]) {
    assert.equal(spawnSync('git', args, { cwd: dir }).status, 0);
  }
  return dir;
}
const commitAll = (dir, msg) => {
  assert.equal(spawnSync('git', ['add', '-A'], { cwd: dir }).status, 0);
  assert.equal(spawnSync('git', ['commit', '-q', '-m', msg], { cwd: dir }).status, 0);
  return spawnSync('git', ['rev-parse', 'HEAD'], { cwd: dir, encoding: 'utf8' }).stdout.trim();
};

test('review 630 r6 / criteria-runner.mjs:464: a git check stays in the repo too', async () => {
  const { allowedCommand } = await import('../../lib/verification/criteria-runner.mjs');
  for (const cmd of ['git diff /etc/hosts /dev/null', 'git diff ../x tests/a.test.mjs', 'git show HEAD:../x', 'git log -- /etc',
    'git diff --no-index tests/a tests/b']) {
    assert.equal(allowedCommand(cmd, { cwd: ROOT }).allowed, false, `${cmd} must not run`);
  }
  for (const cmd of ['git diff HEAD~1..HEAD --stat', 'git show HEAD:package.json', 'git log -- lib/', 'git show @~1 --stat']) {
    const r = allowedCommand(cmd, { cwd: ROOT });
    assert.equal(r.allowed, true, `the control: ${cmd} (${r.reason})`);
  }
});

test('review 630 r6 / criteria-runner.mjs:168: a trailing # comment in a shell fence is not part of the command', async () => {
  const { parsePlanVerification, allowedCommand } = await import('../../lib/verification/criteria-runner.mjs');
  const plan = '## Verification\n\n```bash\nnpm test                      # all green\nnode --test tests/a.test.mjs #1\n```\n';
  assert.deepEqual(parsePlanVerification(plan).map((c) => c.command), ['npm test', 'node --test tests/a.test.mjs']);
  const example = parsePlanVerification(read('examples/01-add-verbose-flag/plan.md'))[0];
  assert.equal(example.command, 'node --test tests/');
  assert.equal(allowedCommand(example.command, { cwd: ROOT }).allowed, true, "the shipped example's first check runs again");
});

test('review 630 r6 / criteria-runner.mjs:466: a glob reaches node --test only where node expands it (Node 21+)', async () => {
  const { allowedCommand } = await import('../../lib/verification/criteria-runner.mjs');
  const old = allowedCommand('node --test tests/lib/*.test.mjs', { cwd: ROOT, nodeMajor: 20 });
  assert.equal(old.allowed, false);
  assert.match(old.reason, /21/);
  assert.equal(allowedCommand('node --test tests/lib/*.test.mjs', { cwd: ROOT, nodeMajor: 22 }).allowed, true);
  assert.equal(allowedCommand('node --test tests/lib/review-630.test.mjs', { cwd: ROOT, nodeMajor: 20 }).allowed, true, 'the control: no glob, any Node');
});

test('review 630 r6 / plan-schema.mjs:318: a backticked file name with no extension is a path', () => {
  const step = (files) => `- **Files:** ${files}\n- **Changes:** x\n`;
  assert.deepEqual(stepTestsOnly(step('`tests/build.test.mjs`, `Makefile`')), { testsOnly: false, files: ['tests/build.test.mjs', 'Makefile'] });
  assert.deepEqual(stepTestsOnly(step('`spec/a_spec.rb`, `Gemfile`')).testsOnly, false);
  assert.deepEqual(stepTestsOnly(step('`tests/a.test.mjs` — covers `parse` and `JSON`')).files, ['tests/a.test.mjs'], 'a span inside a description is no path');
});

// Round 6 had red proof overrule the plan with the step's diff; the operator
// reversed that on 2026-10-11 (round 7): the plan's Files: alone decides, and a
// plain Makefile beside a backticked test is now read from Files: itself.
test('review 630 r6 / plan-schema.mjs:329 (reversed in r7): a Makefile beside a backticked test is read from Files:, not from the diff', async () => {
  const { proveRed } = await import('../../lib/verification/red-proof.mjs');
  const work = mkdtempSync(join(tmpdir(), 'r630-diff-'));
  const repo = gitRepo('r630-diff-repo-');
  try {
    writeFileSync(join(repo, 'README.md'), 'x\n');
    const base = commitAll(repo, 'base');
    mkdirSync(join(repo, 'tests'));
    writeFileSync(join(repo, 'tests', 'a.test.mjs'), "import { test } from 'node:test';\ntest('a', () => {});\n");
    writeFileSync(join(repo, 'Makefile'), 'test:\n\tnode --test tests/\n');
    const plan = join(work, 'plan.md');
    writeFileSync(plan, '## Implementation Plan\n\n### Step 1: x\n\n- **Files:** `tests/a.test.mjs`, Makefile\n- **Changes:** x\n');
    const o = { cwd: repo, base, cmd: 'node --test tests/a.test.mjs', tests: ['tests/a.test.mjs'], plan, step: 1 };
    const r = proveRed(o);
    assert.equal(r.reason, 'not-red-at-base', JSON.stringify(r));
    assert.equal(r.tests_only, false, 'Files: names Makefile');
    rmSync(join(repo, 'Makefile'));
    assert.equal(proveRed(o).tests_only, false, 'the diff is not read: without Makefile in the tree the plan still names it');
  } finally { rmSync(work, { recursive: true, force: true }); rmSync(repo, { recursive: true, force: true }); }
});

test('review 630 r6 / red-proof.mjs:129: exit 127 from the test program itself is a red, not "could not run"', async () => {
  const { proveRed } = await import('../../lib/verification/red-proof.mjs');
  const { writeDoneLine } = await import('../../lib/verification/done-line.mjs');
  const repo = gitRepo('r630-127-');
  try {
    writeFileSync(join(repo, 'README.md'), 'x\n');
    const base = commitAll(repo, 'base');
    mkdirSync(join(repo, 'tests'));
    mkdirSync(join(repo, 'bin'));
    writeFileSync(join(repo, 'tests', 'e2e.sh'), './bin/tool\n');
    writeFileSync(join(repo, 'bin', 'tool'), '#!/bin/sh\nexit 0\n', { mode: 0o755 });
    const r = proveRed({ cwd: repo, base, cmd: 'bash tests/e2e.sh', tests: ['tests/e2e.sh'], redOnly: true });
    assert.equal(r.status, 'proven', JSON.stringify(r));
    assert.equal(r.base.exit, 127);
    rmSync(join(repo, 'bin'), { recursive: true });
    const d = writeDoneLine({ cwd: repo, step: 1, cmd: 'bash tests/e2e.sh', report: join(repo, 'report.md') });
    assert.equal(d.status, 'failed', `a test that exits 127 failed: ${JSON.stringify(d)}`);
  } finally { rmSync(repo, { recursive: true, force: true }); }
});

test('review 630 r6 / regression-check.mjs:64: a Regression: whose runner cannot start is not-run, not a red suite', async () => {
  const { checkRegression } = await import('../../lib/verification/regression-check.mjs');
  const empty = mkdtempSync(join(tmpdir(), 'r630-path-'));
  const saved = process.env.PATH;
  try {
    process.env.PATH = empty;
    const planText = '## Implementation Plan\n\n### Step 1: x\n\n- **Files:** `src/a.mjs`\n- **Regression:** `vitest run`\n';
    const r = checkRegression({ planText, step: 1, cwd: ROOT });
    assert.equal(r.status, 'error', JSON.stringify(r));
    assert.equal(r.progress_status, 'not-run');
    assert.equal(r.exit, 2);
    assert.match(r.output, /could not start/);
  } finally { process.env.PATH = saved; rmSync(empty, { recursive: true, force: true }); }
});

test('review 630 r6 / hooks are ASCII: the lines this release added to pre-bash-executor.mjs', () => {
  const src = read('hooks/scripts/pre-bash-executor.mjs');
  const block = src.slice(src.indexOf('Everything this guard would ask about') - 200, src.indexOf('Everything this guard would ask about') + 300);
  assert.ok(block.includes('Everything this guard would ask about'));
  assert.doesNotMatch(block, /[^\x00-\x7f]/, 'a hook script is ASCII (~/.claude/CLAUDE.md, Miljø)');
});

// ==== round 7 of the release review (2026-10-11), fixed in 6.3.1; each red on 0f400d3 ====

test('review 630 r7 / 48939bcb d20c5619 (operator 2026-10-11): the plan\'s Files: alone decides tests-only, whatever else is in the tree', async () => {
  const { proveRed } = await import('../../lib/verification/red-proof.mjs');
  const repo = gitRepo('r630-r7-files-');
  try {
    writeFileSync(join(repo, 'README.md'), 'x\n');
    const base = commitAll(repo, 'base');
    // Work the plan does not know about, there before the step began (trekexecute
    // Sub-step 0 lets a step start on a dirty tree and logs it as a decision).
    writeFileSync(join(repo, 'README.md'), 'edited before the step\n');
    writeFileSync(join(repo, 'notes.txt'), 'untracked, not ignored\n');
    // A plan placed outside .claude/, with the executor's files beside it (brief note 2).
    mkdirSync(join(repo, 'plans', 'steps'), { recursive: true });
    const plan = join(repo, 'plans', 'plan.md');
    writeFileSync(plan, '## Implementation Plan\n\n### Step 1: x\n\n- **Files:** `tests/a.test.mjs`\n- **Changes:** x\n\n' +
      '### Step 2: y\n\n- **Files:** `tests/a.test.mjs`, `src/a.mjs`\n- **Changes:** y\n');
    writeFileSync(join(repo, 'plans', 'progress.json'), '{}\n');
    writeFileSync(join(repo, 'plans', 'steps', 'step-1.report.md'), 'report\n');
    // The helper wrote the step's test alone (step-implementer, mode build, step 1); it passes at the start point.
    mkdirSync(join(repo, 'tests'));
    writeFileSync(join(repo, 'tests', 'a.test.mjs'), "import { test } from 'node:test';\ntest('a', () => {});\n");
    const o = { cwd: repo, base, cmd: 'node --test tests/a.test.mjs', tests: ['tests/a.test.mjs'], plan };
    for (const redOnly of [true, false]) {
      const one = proveRed({ ...o, step: 1, redOnly });
      assert.equal(one.reason, 'not-red-at-base', JSON.stringify(one));
      assert.equal(one.tests_only, true, `step 1's Files: names only its test (redOnly ${redOnly}): ${JSON.stringify(one.tests_only_note ?? null)}`);
      const two = proveRed({ ...o, step: 2, redOnly });
      assert.equal(two.reason, 'not-red-at-base', JSON.stringify(two));
      assert.equal(two.tests_only, false, `step 2's Files: names src/a.mjs, though the tree holds only its test (redOnly ${redOnly})`);
    }
  } finally { rmSync(repo, { recursive: true, force: true }); }
});

test('review 630 r7 / 48939bcb (operator 2026-10-11): the text says plainly that the plan\'s Files: alone decides', () => {
  for (const rel of ['commands/trekexecute.md', 'agents/step-implementer.md', 'lib/verification/red-proof.mjs', 'docs/HANDOVER-CONTRACTS.md']) {
    const text = read(rel);
    assert.match(text, /`Files:` alone decides/, `${rel} says that the plan's Files: alone decides`);
    assert.doesNotMatch(text, /every file (?:the step|it) changed since (?:its|the) start point/, `${rel} no longer reads the step's diff for tests-only`);
  }
  const row = read('commands/trekexecute.md').split('\n').find((l) => l.startsWith('| 1, `not-red-at-base`, `tests_only: true`'));
  assert.match(row, /`Files:` alone decides/, 'the routing row itself says it');
});

test('review 630 r7 / 0180a979: a file named without backticks beside a backticked path is read', () => {
  const step = (files) => `- **Files:** ${files}\n- **Changes:** x\n`;
  for (const [files, paths] of [
    ['`tests/x.test.mjs`, Dockerfile', ['tests/x.test.mjs', 'Dockerfile']],
    ['`tests/x.test.mjs`, the CLI entry src/cli.mjs', ['tests/x.test.mjs', 'src/cli.mjs']],
    ['`tests/x.test.mjs` and Makefile', ['tests/x.test.mjs', 'Makefile']],
    ['`tests/x.test.mjs` and `Makefile`', ['tests/x.test.mjs', 'Makefile']],
  ]) {
    assert.deepEqual(stepTestsOnly(step(files)), { testsOnly: false, files: paths }, files);
  }
  // The control: a description beside a backticked path is still no path.
  for (const files of ['`tests/a.test.mjs` — covers `parse` and `JSON`', '`tests/a.test.mjs` — covers pass/fail, JSON, YAML',
    '`tests/a.test.mjs` (v6.3.0 format)', '`tests/a.test.mjs`: Covers the Parser, e.g. its Profile']) {
    assert.deepEqual(stepTestsOnly(step(files)), { testsOnly: true, files: ['tests/a.test.mjs'] }, files);
  }
});

test('review 630 r7 / 633546914: a command its timeout killed is reported as killed by the timeout, not as "could not start"', async () => {
  const { proveRed } = await import('../../lib/verification/red-proof.mjs');
  const repo = gitRepo('r630-r7-hang-');
  try {
    writeFileSync(join(repo, 'README.md'), 'x\n');
    const base = commitAll(repo, 'base');
    mkdirSync(join(repo, 'tests'));
    writeFileSync(join(repo, 'tests', 'hang.test.mjs'), "import { test } from 'node:test';\ntest('hangs', () => new Promise((r) => setTimeout(r, 6000)));\n");
    const r = proveRed({ cwd: repo, base, cmd: 'node --test tests/hang.test.mjs', tests: ['tests/hang.test.mjs'], redOnly: true, timeoutMs: 2000 });
    assert.equal(r.status, 'not-run', JSON.stringify(r));
    assert.doesNotMatch(r.reason, /could not start/, r.reason);
    assert.match(r.reason, /killed .*after the 2 s timeout/, r.reason);
  } finally { rmSync(repo, { recursive: true, force: true }); }
});

test('review 630 r7 / 5b2063e2: a trailing # comment is no part of a backticked check either, and never reaches the runner', async () => {
  const { firstCommand, allowedCommand, runCommand } = await import('../../lib/verification/criteria-runner.mjs');
  assert.equal(firstCommand('`npm test  # full suite`').command, 'npm test');
  assert.equal(firstCommand('`node --test tests/a.test.mjs #1` — expected: pass').command, 'node --test tests/a.test.mjs');
  const plan = '## Implementation Plan\n\n### Step 1: x\n\n- **Files:** `src/a.mjs`\n- **Changes:** x\n' +
    '- **Regression:** `npm test  # full suite`\n';
  const r = validatePlanContent(plan, { strict: false });
  const codes = [...r.errors, ...r.warnings].map((i) => i.code);
  assert.ok(!codes.includes('PLAN_STEP_REGRESSION_NOT_RUNNABLE'), JSON.stringify(codes));
  // The executor passes the Verify span to red proof, the done line and the test lock as written.
  assert.equal(allowedCommand('npm test  # full suite', { cwd: ROOT }).allowed, true);
  assert.equal(runCommand('node -e process.exit(process.argv.length-1)  # two words', { cwd: ROOT }).status, 0, 'the comment\'s words reach no program');
  assert.equal(firstCommand('`node --test tests/a#b.test.mjs`').command, 'node --test tests/a#b.test.mjs', 'the control: a # inside a word is no comment');
});

test('review 630 r7 / aa08f47f: the 15-minute timeout is defined once', async () => {
  const files = spawnSync('git', ['ls-files', 'lib', 'scripts', 'hooks'], { cwd: ROOT, encoding: 'utf8' }).stdout.split('\n').filter((p) => p.endsWith('.mjs'));
  assert.ok(files.length > 50, `listed ${files.length} files`);
  assert.deepEqual(files.filter((p) => /\b900_?000\b/.test(read(p))), ['lib/verification/criteria-runner.mjs']);
  const rp = await import('../../lib/verification/red-proof.mjs');
  const cr = await import('../../lib/verification/criteria-runner.mjs');
  assert.equal(rp.DEFAULT_TIMEOUT_MS, cr.DEFAULT_TIMEOUT_MS);
});

test('review 630 r7 / efa7de84: a file cited many times is read once per validation', () => {
  const cite = 'commands/trekexecute.md:1';
  const findings = Array.from({ length: 40 }, (_, i) => ({
    severity: 'MINOR', rule_key: 'MISSING_TEST', file: 'commands/trekexecute.md', line: 1 + i,
    title: `see ${cite} and ${cite}0`, detail: `${cite}2`, recommended_action: 'Add a test.',
  }));
  let reads = 0;
  const real = fs.readFileSync;
  mock.method(fs, 'readFileSync', function (p, ...rest) {
    if (String(p).endsWith(`${'/'}commands/trekexecute.md`)) reads++;
    return real.call(this, p, ...rest);
  });
  syncBuiltinESMExports();
  let r;
  try { r = validateFindings({ reviewer: 'r', findings }, { repoRoot: ROOT }); }
  finally { mock.restoreAll(); syncBuiltinESMExports(); }
  assert.equal(r.valid, true, JSON.stringify(r.errors));
  assert.equal(reads, 1, `commands/trekexecute.md was read ${reads} times for one validation`);
});

test('review 630 r7 / d5ab7698: one isMain helper, and a CLI started through a symlinked path with a space does its work', () => {
  const files = spawnSync('git', ['ls-files', 'lib', 'scripts', 'hooks'], { cwd: ROOT, encoding: 'utf8' }).stdout.split('\n').filter((p) => p.endsWith('.mjs'));
  const local = files.filter((p) => p !== 'lib/util/is-main.mjs' &&
    /function isMain\b|import\.meta\.url === `file:\/\/\$\{process\.argv\[1\]\}`/.test(read(p)));
  assert.deepEqual(local, [], 'every CLI uses lib/util/is-main.mjs');
  const base = mkdtempSync(join(tmpdir(), 'r630 r7 main '));
  const link = join(base, 'voyage link');
  try {
    symlinkSync(ROOT, link);
    // The first had the file:// guard (a silent exit 0 here), the second the realpath copy.
    for (const cli of ['lib/validators/session-state-validator.mjs', 'lib/validators/plan-validator.mjs']) {
      const r = spawnSync(process.execPath, [join(link, cli)], { encoding: 'utf8', input: '', timeout: 30_000 });
      assert.equal(r.status, 2, `${cli} through "${link}": ${r.stdout}${r.stderr}`);
      assert.match(r.stderr, /usage/i);
    }
  } finally { fs.rmSync(link, { force: true }); rmSync(base, { recursive: true, force: true }); }
});

test('review 630 r7 / 4f8a69e7: the guard writes its no-one-to-ask refusal once, on a direct condition', () => {
  const src = read('hooks/scripts/pre-bash-executor.mjs');
  assert.doesNotMatch(src, /const unattended = /);
  assert.equal(src.split('permission mode where Claude Code asks nothing').length - 1, 1, 'one refusal text for both cases');
});

test('review 630 r7 / findings-schema.mjs:41: a triple backtick inside a JSON string does not end the block', async () => {
  const { extractFindingsBlock } = await import('../../lib/review/findings-schema.mjs');
  const { fillFindingIds } = await import('../../lib/review/fill-finding-ids.mjs');
  const payload = { verdict: 'WARN', findings: [{ id: '@@ID_1@@', severity: 'MAJOR', rule_key: 'MISSING_TEST', file: 'a.mjs', line: 1,
    title: 'x', detail: 'write the check as ```bash\nnpm test\n``` and run it', recommended_action: 'Add a test.' }] };
  const text = `# Review\n\nProse with a \`\`\`json fence quoted in it.\n\n\`\`\`json\n${JSON.stringify(payload, null, 2)}\n\`\`\`\n`;
  const block = extractFindingsBlock(text);
  assert.match(block, /"recommended_action": "Add a test\."\s*\}\s*\]\s*\}\s*$/, `the block runs to its own closing fence, not to the backticks in a string: …${block.slice(-60)}`);
  assert.deepEqual(JSON.parse(block), payload);
  const r = fillFindingIds(text);
  assert.equal(r.ok, true, JSON.stringify(r.errors));
  assert.doesNotMatch(r.text, /@@ID_1@@/);
});

test('review 630 r7 / brief note 3: the prose says a git revision may start with @, as the screen allows', async () => {
  const { allowedCommand } = await import('../../lib/verification/criteria-runner.mjs');
  assert.equal(allowedCommand('git show @~1 --stat', { cwd: ROOT }).allowed, true);
  assert.equal(allowedCommand('pytest @args.txt', { cwd: ROOT }).allowed, false, 'the control: a runner word with a leading @');
  // The runner's rules for writing a criterion moved from brief-reviewer and
  // /trekplan into the writing-criteria skill (order 7c, 17.10).
  for (const rel of ['skills/writing-criteria/SKILL.md']) {
    assert.match(read(rel), /`@~1`/, `${rel} names the git revision as the exception`);
  }
});

// ==== round 8 of the release review of 6.3.0 (0f400d3..29b4ac9, 2026-10-11), fixed in 6.3.1 ====

test('review 630 r8 / BLOCKER criteria-runner.mjs:158: a Verify comment that a shell would read inside double quotes is refused', () => {
  // The executor and the helper hand the Verify span to red proof, the test lock
  // and the done line as `--cmd "{Verify command}"`: inside double quotes a `$`,
  // a backtick or a backslash still means something, and a `"` ends the argument.
  const verify = (span) => buildPlan().replace('`node --test tests/mod1.test.mjs` → expected: pass', () => `\`${span}\` → expected: pass`);
  const codes = (span) => {
    const r = validatePlanContent(verify(span), { strict: false });
    return [...r.errors, ...r.warnings].filter((i) => i.code === 'PLAN_STEP_VERIFY_NOT_RUNNABLE').map((i) => i.message);
  };
  for (const span of ['node --test tests/mod1.test.mjs # $(touch x)', 'node --test tests/mod1.test.mjs # expect "fail 1"',
    'node --test tests/mod1.test.mjs # a back\\slash', 'node --test tests/mod1.test.mjs # ${HOME}']) {
    assert.equal(codes(span).length, 1, `${span} is refused: ${JSON.stringify(codes(span))}`);
  }
  // The control: a plain comment is still dropped, and the check stays runnable.
  assert.deepEqual(codes('node --test tests/mod1.test.mjs  # all green'), []);
  assert.deepEqual(codes("node --test tests/mod1.test.mjs  # it's green"), [], 'a single quote means nothing inside double quotes');
});

test('review 630 r8 / criteria-runner.mjs:158: a span that is only a comment is not-a-command, not a placeholder', async () => {
  const { firstCommand } = await import('../../lib/verification/criteria-runner.mjs');
  assert.equal(firstCommand('` # fill in`').reason, 'not-a-command');
  assert.equal(firstCommand('`{exact command}`').reason, 'placeholder', 'the control');
});

test('review 630 r8 / criteria-runner.mjs:175: a # inside a word is kept by dropComment and refused by the allowlist, and the text says so', async () => {
  const { firstCommand, allowedCommand } = await import('../../lib/verification/criteria-runner.mjs');
  assert.equal(firstCommand('`node --test tests/a#b.test.mjs`').command, 'node --test tests/a#b.test.mjs');
  assert.equal(allowedCommand('node --test tests/a#b.test.mjs', { cwd: ROOT }).allowed, false);
  const doc = /\/\*\*\n((?: \*[^\n]*\n)+) \*\/\nexport function dropComment/.exec(read('lib/verification/criteria-runner.mjs'));
  assert.ok(doc, 'dropComment has its doc comment');
  assert.match(doc[1].replace(/\n \* ?/g, ' '), /a#b\.test\.mjs`?[^.]*\bkept\b[^.]*\ballowlist\b[^.]*\brefuses\b/,
    'the doc says the allowlist still refuses the word');
});

test('review 630 r8 / criteria-runner.mjs:890: no CLI compares process.argv[1] itself, and the three that did work through a symlinked path with a space', () => {
  const files = spawnSync('git', ['ls-files', 'lib', 'scripts', 'hooks'], { cwd: ROOT, encoding: 'utf8' }).stdout.split('\n').filter((p) => p.endsWith('.mjs'));
  assert.deepEqual(files.filter((p) => p !== 'lib/util/is-main.mjs' && /process\.argv\[1\]/.test(read(p))), [],
    'only lib/util/is-main.mjs reads process.argv[1]');
  const base = mkdtempSync(join(tmpdir(), 'r630 r8 main '));
  const link = join(base, 'voyage link');
  try {
    symlinkSync(ROOT, link);
    for (const cli of ['lib/verification/criteria-runner.mjs', 'scripts/comparison-gate.mjs', 'scripts/end-state-gate.mjs']) {
      const r = spawnSync(process.execPath, [join(link, cli), '--no-such-flag'], { encoding: 'utf8', input: '', timeout: 30_000 });
      assert.equal(r.status, 2, `${cli} through "${link}": ${r.stdout}${r.stderr}`);
      assert.match(r.stderr, /unknown argument --no-such-flag/);
    }
  } finally { fs.rmSync(link, { force: true }); rmSync(base, { recursive: true, force: true }); }
});

test('review 630 r8 / plan-schema.mjs:353 + :322: a description beside a backticked path names no file; a build file in its own entry does', () => {
  const step = (files) => `- **Files:** ${files}\n- **Changes:** x\n`;
  // A description after a dash, or a word inside a sentence, is no path (code-review, code-correctness).
  for (const files of ['`tests/lib/x.test.mjs` — mocks fs.readFileSync', '`tests/foo.test.mjs` — covers lib/foo.mjs',
    '`tests/a.test.mjs`, runs on Node.js 22.x', '`tests/a.test.mjs` — exercises the parser in index.js',
    '`tests/a.test.mjs`, no change to package.json', '`tests/a.test.mjs` - asserts JSON.parse behaviour',
    '`tests/a.test.mjs`: covers src/a.mjs and Makefile']) {
    assert.deepEqual(stepTestsOnly(step(files)), { testsOnly: true, files: ['tests/a.test.mjs', 'tests/foo.test.mjs', 'tests/lib/x.test.mjs'].filter((t) => files.startsWith(`\`${t}\``)) }, files);
  }
  // A file in its own entry, after "and", or a path with a slash before any description, still counts (round 7).
  for (const [files, paths] of [
    ['`tests/a.test.mjs`, makefile', ['tests/a.test.mjs', 'makefile']],
    ['`tests/a.test.mjs`, justfile', ['tests/a.test.mjs', 'justfile']],
    ['`tests/a.test.mjs`, package.json', ['tests/a.test.mjs', 'package.json']],
    ['`tests/a.test.mjs` and package.json', ['tests/a.test.mjs', 'package.json']],
    ['`tests/a.test.mjs`, the CLI entry src/cli.mjs — reads argv', ['tests/a.test.mjs', 'src/cli.mjs']],
  ]) {
    assert.deepEqual(stepTestsOnly(step(files)), { testsOnly: false, files: paths }, files);
  }
});

test('review 630 r8 / done-line.mjs:61 + test-lock.mjs:183: a stopped command is read by stoppedBy, the one reading', async () => {
  const { writeDoneLine } = await import('../../lib/verification/done-line.mjs');
  const repo = gitRepo('r630-r8-done-');
  try {
    writeFileSync(join(repo, 'README.md'), 'x\n');
    commitAll(repo, 'base');
    mkdirSync(join(repo, 'tests'));
    writeFileSync(join(repo, 'tests', 'hang.test.mjs'), "import { test } from 'node:test';\ntest('hangs', () => new Promise((r) => setTimeout(r, 6000)));\n");
    const r = writeDoneLine({ cwd: repo, step: 1, cmd: 'node --test tests/hang.test.mjs', report: join(repo, 'report.md'), timeoutMs: 2000 });
    assert.equal(r.status, 'not-run', JSON.stringify(r));
    assert.match(r.reason, /killed .*after the 2 s timeout/, r.reason);
  } finally { rmSync(repo, { recursive: true, force: true }); }
  for (const rel of ['lib/verification/done-line.mjs', 'lib/util/test-lock.mjs', 'lib/verification/red-proof.mjs']) {
    const src = read(rel);
    assert.match(src, /\bstoppedBy\(/, `${rel} reads a stop with stoppedBy`);
    assert.doesNotMatch(src, /r\.error \|\| r\.status === null/, `${rel} does not read the spawn result by hand`);
  }
});

test('review 630 r8 / red-proof.mjs:101: a run reports one reading of a stop, not a second spawnError beside it', () => {
  const repo = gitRepo('r630-r8-spawn-');
  // `jest` is on the allowlist; the PATH finds only git, so it cannot start on
  // any machine, one with jest installed too (round 9, brief note 4).
  const bin = pathWith(['git']);
  try {
    writeFileSync(join(repo, 'README.md'), 'x\n');
    const base = commitAll(repo, 'base');
    mkdirSync(join(repo, 'tests'));
    writeFileSync(join(repo, 'tests', 'a.test.mjs'), 'x\n');
    const out = spawnSync(process.execPath, [join(ROOT, 'lib', 'verification', 'red-proof.mjs'), '--cwd', repo, '--base', base,
      '--cmd', 'jest tests/a.test.mjs', '--tests', 'tests/a.test.mjs', '--red-only', '--json'],
    { encoding: 'utf8', env: childEnv({ PATH: bin.path }), timeout: 60_000 });
    const r = JSON.parse(out.stdout);
    assert.equal(r.status, 'not-run', JSON.stringify(r));
    assert.match(r.reason, /could not start/, r.reason);
    const runs = [r.base, r.result].filter(Boolean);
    assert.ok(runs.length > 0, JSON.stringify(r));
    for (const run of runs) assert.ok(!('spawnError' in run), `no spawnError beside stopped: ${JSON.stringify(run)}`);
  } finally { bin.cleanup(); rmSync(repo, { recursive: true, force: true }); }
});

test('review 630 r8 / findings-schema.mjs:46: the block reader and the verdict gate agree on what a fence is', async () => {
  const { extractFindingsBlock } = await import('../../lib/review/findings-schema.mjs');
  const json = '{\n  "findings": []\n}';
  // Markdown: a closing fence may be longer than the opening one.
  assert.equal(extractFindingsBlock(`x\n\n\`\`\`json\n${json}\n\`\`\`\`\n`), `${json}\n`, 'a ```` closer ends the block');
  // Not a fence in Markdown, and not in the verdict gate either: three backticks
  // after text on the same line.
  assert.equal(extractFindingsBlock(`\`\`\`json\n${json}\`\`\`\n`), null, 'a closer after JSON on its line');
  assert.equal(extractFindingsBlock(`see \`\`\`json\n${json}\n\`\`\`\n`), null, 'an opener after prose on its line');
  const { decideVerdict } = await import('../../lib/review/verdict-gate.mjs');
  const fm = ['---', 'type: trekreview', 'review_version: "1.1"', 'created: 2026-10-11', 'task: "t"', 'slug: s',
    'project_dir: p/', 'brief_path: p/brief.md', `scope_sha_start: ${'b'.repeat(40)}`, `scope_sha_end: ${'c'.repeat(40)}`,
    'reviewed_files_count: 1', 'verdict: WARN', 'findings: []', '---', ''].join('\n');
  const payload = JSON.stringify({ verdict: 'WARN', counts: { BLOCKER: 0, MAJOR: 0, MINOR: 0, SUGGESTION: 0 }, allow_blocked_by: [], findings: [] }, null, 2);
  for (const closer of ['```', '````']) {
    const v = decideVerdict(`${fm}\n# R\n\n## Executive Summary\n\nx\n\n## Coverage\n\nx\n\n## Declined to Judge\n\nNone.\n\nTrimmed: 0\n\n` +
      `## Remediation Summary\n\nx\n\n\`\`\`json\n${payload}\n${closer}\n`);
    assert.equal(v.exit, 0, `closer ${closer}: ${v.reason}`);
  }
});

test('review 630 r8 / review-validator.mjs:36 + synthesis-digest-schema.mjs:59: three backticks in a JSON string do not end the block there either', async () => {
  const { validateReviewContent } = await import('../../lib/validators/review-validator.mjs');
  const { extractDigestBlock } = await import('../../lib/plan/synthesis-digest-schema.mjs');
  const id = 'a'.repeat(40);
  const payload = { verdict: 'BLOCK', counts: { BLOCKER: 1, MAJOR: 0, MINOR: 0, SUGGESTION: 0 }, allow_blocked_by: [],
    findings: [{ id, severity: 'BLOCKER', rule_key: 'MISSING_TEST', file: 'a.mjs', line: 1, title: 'x',
      detail: 'write the check as ```bash\nnpm test\n``` and run it', recommended_action: 'Add a test.' }] };
  const review = ['---', 'type: trekreview', 'review_version: "1.1"', 'created: 2026-10-11', 'task: "t"', 'slug: s',
    'project_dir: p/', 'brief_path: p/brief.md', 'scope_sha_start: ' + 'b'.repeat(40), 'scope_sha_end: ' + 'c'.repeat(40),
    'reviewed_files_count: 1', 'verdict: BLOCK', 'findings:', `  - ${id}`, '---', '', '# Review', '',
    '## Executive Summary', '', 'x', '', '## Coverage', '', 'x', '', '## Declined to Judge', '', 'None.', '', 'Trimmed: 0', '',
    '## Remediation Summary', '', 'x', '', '```json', JSON.stringify(payload, null, 2), '```', ''].join('\n');
  const r = validateReviewContent(review);
  assert.ok([...r.errors, ...r.warnings].some((i) => i.code === 'REVIEW_MISSING_REMEDIATION_STEP'),
    `a BLOCKER with no ### Step R<n> is found although its detail holds a fence: ${JSON.stringify(r.errors.map((e) => e.code))}`);
  const digest = '```json\n{"note": "a ```bash fence"}\n```\n';
  assert.equal(extractDigestBlock(digest), '{"note": "a ```bash fence"}\n');
});

// ==== round 9 of the release review of 6.3.0 (0f400d3..a10018f, 2026-10-11), fixed in 6.3.1 ====

test('review 630 r9 / f8087ca4 criteria-runner.mjs:172: a check refused for its comment stays a command, refused out loud', async () => {
  const { parsePlanVerification, runCriteria } = await import('../../lib/verification/criteria-runner.mjs');
  const { validateBriefContent } = await import('../../lib/validators/brief-validator.mjs');
  const nestedPlan = (comment) => buildPlan().replace('- [ ] `npm test` → expected: exit 0', () =>
    `- [ ] \`npm test\` → expected: exit 0\n  - [ ] \`node --test tests/e2e.test.mjs  # ${comment}\` → expected: exit 0`);
  // (1) A nested ## Verification bullet under a parent with its own command is
  // a criterion of its own, never a sub-point, and it is NOT RUN with the reason.
  const plan = nestedPlan('expect "3 pass"');
  const nested = parsePlanVerification(plan).find((c) => c.text.includes('tests/e2e.test.mjs'));
  assert.ok(nested, `the nested check is a criterion: ${JSON.stringify(parsePlanVerification(plan))}`);
  const ran = [];
  const [r] = runCriteria([nested], {
    exec: (c) => { ran.push(c); return { status: 0, stdout: '', stderr: '' }; },
    screen: () => ({ allowed: true, rule: '' }),
  });
  assert.equal(r.status, 'unrunnable', JSON.stringify(r));
  assert.match(r.output, /trailing comment/, r.output);
  assert.deepEqual(ran, [], 'a refused check never runs, its comment dropped or not');
  const issues = (p) => { const v = validatePlanContent(p, { strict: false }); return [...v.errors, ...v.warnings]; };
  assert.ok(issues(plan).some((i) => i.code === 'PLAN_VERIFICATION_NOT_RUNNABLE' && /tests\/e2e\.test\.mjs/.test(i.message)),
    JSON.stringify(issues(plan).map((i) => i.code)));
  // The control: a plain comment is still dropped, and the nested check still runs.
  assert.ok(!issues(nestedPlan('all green')).some((i) => i.code === 'PLAN_VERIFICATION_NOT_RUNNABLE'));
  // (2) A brief SC with such a comment is BRIEF_SC_NOT_RUNNABLE, not prose-only.
  const brief = (sc) => [
    '---', 'type: trekbrief', 'brief_version: "2.2"', 'task: t', 'slug: s',
    'research_topics: 0', 'research_status: skipped', 'framing: new-direction', 'phase_signals_partial: true', '---', '',
    '## TL;DR', '', 'A toy.', '', '## Intent', '', 'Why.', '', '## Goal', '', 'What.', '',
    '## Success Criteria', '', sc, '',
  ].join('\n');
  const notRunnable = (sc) => validateBriefContent(brief(sc)).warnings.filter((w) => w.code === 'BRIEF_SC_NOT_RUNNABLE');
  assert.equal(notRunnable('- `npm test  # prints "ok"` exits 0.').length, 1);
  assert.equal(notRunnable('- `npm test  # prints ok` exits 0.').length, 0, 'the control');
});

// One review.md: a clean WARN block, then `tail` (what the last block is).
const B3 = '`'.repeat(3);
const B4 = '`'.repeat(4);
function r9Review(tail, { eol = '\n' } = {}) {
  const fm = ['---', 'type: trekreview', 'review_version: "1.1"', 'created: 2026-10-11', 'task: "t"', 'slug: s',
    'project_dir: p/', 'brief_path: p/brief.md', `scope_sha_start: ${'b'.repeat(40)}`, `scope_sha_end: ${'c'.repeat(40)}`,
    'reviewed_files_count: 1', 'verdict: WARN', 'findings: []', '---', ''].join('\n');
  const body = '# R\n\n## Executive Summary\n\nx\n\n## Coverage\n\nx\n\n## Declined to Judge\n\nNone.\n\nTrimmed: 0\n\n## Remediation Summary\n\nx\n\n';
  return `${fm}${body}${tail}`.replace(/\n/g, eol);
}
const R9_WARN = JSON.stringify({ verdict: 'WARN', counts: { BLOCKER: 0, MAJOR: 0, MINOR: 0, SUGGESTION: 0 }, allow_blocked_by: [], findings: [] }, null, 2);
const R9_BLOCK = JSON.stringify({ verdict: 'BLOCK', counts: { BLOCKER: 1, MAJOR: 0, MINOR: 0, SUGGESTION: 0 }, allow_blocked_by: [],
  findings: [{ id: 'a'.repeat(40), severity: 'BLOCKER', rule_key: 'MISSING_TEST', file: 'a.mjs', line: 1 }] }, null, 2);
const r9Clean = `${B3}json\n${R9_WARN}\n${B3}\n`;

test('review 630 r9 / 5fb0d492 verdict-gate.mjs:123: the last fence\'s language and body come from one reading', async () => {
  const { decideVerdict } = await import('../../lib/review/verdict-gate.mjs');
  // The controls: a clean review passes, LF and CRLF, indented or not.
  for (const [name, text] of [['LF', r9Review(r9Clean)], ['CRLF', r9Review(r9Clean, { eol: '\r\n' })],
    ['indented', r9Review(`  ${B3}json\n  ${R9_WARN.replace(/\n/g, '\n  ')}\n  ${B3}\n`)]]) {
    assert.equal(decideVerdict(text).exit, 0, `${name}: ${decideVerdict(text).reason}`);
  }
  // A last block whose info string is not exactly `json` held a BLOCKER the
  // block reader skipped: the gate read the earlier clean block and exited 0.
  for (const opener of [`${B3}json {x}`, `${B3} json`, `${B3}json\t{"x": 1}`]) {
    for (const eol of ['\n', '\r\n']) {
      for (const indent of ['', '  ']) {
        const tail = `${r9Clean}\n${indent}${opener}\n${R9_BLOCK}\n${indent}${B3}\n`;
        const v = decideVerdict(r9Review(tail, { eol }));
        assert.equal(v.exit, 2, `${JSON.stringify(indent + opener)} (${JSON.stringify(eol)}): ${v.reason}`);
        assert.match(v.reason, /last fenced block/, v.reason);
      }
    }
  }
  // An indented last block is read as the last block: its BLOCKER is seen.
  const indented = `${r9Clean}\n  ${B3}json\n  ${R9_BLOCK.replace(/\n/g, '\n  ')}\n  ${B3}\n`;
  assert.equal(decideVerdict(r9Review(indented)).exit, 2, decideVerdict(r9Review(indented)).reason);
  // A last block that is never closed runs to the end of the file, as in Markdown.
  const unclosed = decideVerdict(r9Review(`${r9Clean}\n${B3}json\n${R9_BLOCK}\n`));
  assert.equal(unclosed.exit, 2, unclosed.reason);
  assert.match(unclosed.reason, /never closed/, unclosed.reason);
});

test('review 630 r9 / 2eb4b921 verdict-gate.mjs:123: a fence is closed only by a run at least as long as its opener', async () => {
  const { decideVerdict } = await import('../../lib/review/verdict-gate.mjs');
  const { extractFindingsBlock } = await import('../../lib/review/findings-schema.mjs');
  const example = `${B4}markdown\n${B3}json\n{"example": true}\n${B3}\n${B4}\n`;
  // A four-backtick example of a json block, then the review's own block: valid.
  const before = r9Review(`${example}\n${r9Clean}`);
  assert.equal(decideVerdict(before).exit, 0, decideVerdict(before).reason);
  assert.equal(extractFindingsBlock(before), `${R9_WARN}\n`);
  // The same example after it: the last block is the markdown block, and the
  // block reader does not take the example inside it.
  const after = r9Review(`${r9Clean}\n${example}`);
  const v = decideVerdict(after);
  assert.equal(v.exit, 2, v.reason);
  assert.match(v.reason, /"markdown"/, v.reason);
  assert.equal(extractFindingsBlock(after), `${R9_WARN}\n`, 'the review\'s own block, not the example');
  // A four-backtick json block is one block; three backticks inside do not end it.
  assert.equal(extractFindingsBlock(`${B4}json\n{"a": 1}\n${B3}\n${B4}\n`), `{"a": 1}\n${B3}\n`);
});

test('review 630 r9 / c0465ecd plan-schema.mjs:350: a description runs on past a comma and onto the next line', () => {
  const step = (files) => `- **Files:** ${files}\n- **Changes:** x\n`;
  for (const files of ['`tests/a.test.mjs` — mocks fs, child_process.spawnSync and path.join',
    '`tests/a.test.mjs` — covers parse, Node.js 22 only',
    '`tests/a.test.mjs` — mocks fs and\n  child_process.spawnSync, path.join']) {
    assert.deepEqual(stepTestsOnly(step(files)), { testsOnly: true, files: ['tests/a.test.mjs'] }, files);
  }
  // A new entry starts with a backticked path, or on a new list line.
  for (const [files, paths] of [
    ['`tests/a.test.mjs` — new test, `src/a.mjs` — the fix', ['tests/a.test.mjs', 'src/a.mjs']],
    ['\n  - `tests/a.test.mjs` — new test, mocks fs\n  - src/a.mjs — the fix', ['tests/a.test.mjs', 'src/a.mjs']],
    ['\n  - `tests/a.test.mjs` — new test\n  - package.json', ['tests/a.test.mjs', 'package.json']],
  ]) {
    assert.deepEqual(stepTestsOnly(step(files)), { testsOnly: false, files: paths }, files);
  }
});

test('review 630 r9 / 7b3750e9 plan-schema.mjs:372: a plain path that ends with a colon starts its description', () => {
  const step = (files) => `- **Files:** ${files}\n- **Changes:** x\n`;
  for (const [files, paths] of [
    ['`tests/a.test.mjs`, src/cli.mjs: wires parse and README.md', ['tests/a.test.mjs', 'src/cli.mjs']],
    ['`tests/a.test.mjs`, Makefile: a target and package.json', ['tests/a.test.mjs', 'Makefile']],
  ]) {
    assert.deepEqual(stepTestsOnly(step(files)).files, paths, files);
  }
  // The control: a word that is no path, with a colon, is a label, not a description.
  assert.deepEqual(stepTestsOnly(step('`tests/a.test.mjs`, note: Makefile and package.json')).files, ['tests/a.test.mjs', 'package.json']);
});

// Review 703d87e1: under full-suite load the criteria runner saw this test's
// start-point run killed at the old 2 s timeout ("at the start point"), not the
// control run. Its numbers live in tests/helpers/timing.mjs (CONTROL_RUN): the
// timeout leaves headroom over a slow start, the hang outlasts it. Every run
// but the control starts slowly on purpose (slowStartMs), so a timeout without
// headroom fails here on demand, not only under load. BEFORE_703D87E1 is the
// record of the numbers before the fix, taken only when the export is absent.
const BEFORE_703D87E1 = Object.freeze({ timeoutMs: 2000, hangMs: 6000, slowStartMs: 2500 });

test('review 630 r9 / brief note 3 + 703d87e1: red proof reports a control run it stopped as not-run, in the control run, when every other run starts slowly', async () => {
  const c = timing.CONTROL_RUN ?? BEFORE_703D87E1;
  const { proveRed } = await import('../../lib/verification/red-proof.mjs');
  const repo = gitRepo('r630-r9-control-');
  try {
    writeFileSync(join(repo, 'README.md'), 'x\n');
    const base = commitAll(repo, 'base');
    mkdirSync(join(repo, 'tests'));
    mkdirSync(join(repo, 'src'));
    // Red at the start point (no src/impl.mjs), green in the working tree, and
    // it hangs only in the control: the start-point copy with the change laid
    // on. Every other run waits slowStartMs before its one test.
    writeFileSync(join(repo, 'tests', 'a.test.mjs'), [
      "import { test } from 'node:test';",
      "import { existsSync } from 'node:fs';",
      "const control = process.cwd().includes('voyage-red-proof-') && existsSync('src/impl.mjs');",
      `if (!control) await new Promise((r) => setTimeout(r, ${c.slowStartMs}));`,
      "test('impl', async () => {",
      "  if (!existsSync('src/impl.mjs')) throw new Error('no impl');",
      `  if (control) await new Promise((r) => setTimeout(r, ${c.hangMs}));`,
      '});', ''].join('\n'));
    writeFileSync(join(repo, 'src', 'impl.mjs'), 'export const x = 1;\n');
    const r = proveRed({ cwd: repo, base, cmd: 'node --test tests/a.test.mjs', tests: ['tests/a.test.mjs'], timeoutMs: c.timeoutMs });
    assert.equal(r.status, 'not-run', JSON.stringify(r));
    assert.match(r.reason, new RegExp(`^in the control run: the command was killed .*after the ${c.timeoutMs / 1000} s timeout`), r.reason);
    assert.equal(r.base.exit, 1, 'red at the start point');
    assert.equal(r.result.exit, 0, 'green at the result');
    assert.ok(r.control, 'the control run is reported');
  } finally { rmSync(repo, { recursive: true, force: true }); }
});

test('review 630 r9 / brief note 8: the Files: reader states one count of plan files, the one measured', () => {
  const doc = /\/\*\*\n((?: \*[^\n]*\n)+) \*\/\nconst SEG = /.exec(read('lib/parsers/plan-schema.mjs'));
  assert.ok(doc, 'fieldPaths has its doc comment');
  const text = doc[1].replace(/\n \* ?/g, ' ');
  assert.match(text, /520 Files: fields in 48 plan files at rounds 7-8/);
  assert.match(text, /560 fields in 48 plan files at round 9/);
  assert.doesNotMatch(text.replace(/round 7 wrote "182 plans" here/, ''), /182/, 'the round-7 count is named only as the one replaced');
});

// ==== round 10 of the release review of 6.3.0 (0f400d3..a1e0e50, 2026-10-11), fixed in 6.3.1 ====

test('review 630 r10 / ecd9da6f plan-schema.mjs:363: a new line that opens with a plain file starts a new entry', () => {
  const step = (files) => `- **Files:** ${files}\n- **Changes:** x\n`;
  for (const [files, paths] of [
    ['`tests/a.test.mjs`: the test\n  src/cli.mjs', ['tests/a.test.mjs', 'src/cli.mjs']],
    ['`tests/a.test.mjs` — the test\n  src/cli.mjs: the fix', ['tests/a.test.mjs', 'src/cli.mjs']],
    ['`tests/a.test.mjs` — the test\n  src/a.mjs, src/b.mjs', ['tests/a.test.mjs', 'src/a.mjs', 'src/b.mjs']],
    ['`tests/a.test.mjs` — the test\n  package.json', ['tests/a.test.mjs', 'package.json']],
    ['`tests/a.test.mjs` — the test\n  Makefile — a target', ['tests/a.test.mjs', 'Makefile']],
  ]) {
    assert.deepEqual(stepTestsOnly(step(files)), { testsOnly: false, files: paths }, files);
  }
  // The control: a description that runs onto the next line names no file
  // there (round 9), unless the line opens with one in an entry's own shape.
  for (const files of ['`tests/a.test.mjs` — mocks fs and\n  child_process.spawnSync, path.join',
    '`tests/a.test.mjs` — runs on\n  Node.js 22 only', '`tests/a.test.mjs` — covers\n  index.js and the CLI']) {
    assert.deepEqual(stepTestsOnly(step(files)), { testsOnly: true, files: ['tests/a.test.mjs'] }, files);
  }
});

test('review 630 r10 / b4215783 plan-schema.mjs:365: a numbered list item is an entry, `1.` or `1)`', () => {
  const step = (files) => `- **Files:** ${files}\n- **Changes:** x\n`;
  for (const [files, paths] of [
    ['`tests/a.test.mjs`\n  1. package.json\n  2. src/b.mjs', ['tests/a.test.mjs', 'package.json', 'src/b.mjs']],
    ['`tests/a.test.mjs`\n  1) package.json', ['tests/a.test.mjs', 'package.json']],
    ['`tests/a.test.mjs` — the test, mocks fs\n  2) Makefile', ['tests/a.test.mjs', 'Makefile']],
  ]) {
    assert.deepEqual(stepTestsOnly(step(files)), { testsOnly: false, files: paths }, files);
  }
});

test('review 630 r10 / 39a57fee plan-schema.mjs:371: a backticked capitalised name inside a description is no file', () => {
  const step = (files) => `- **Files:** ${files}\n- **Changes:** x\n`;
  for (const files of ['`tests/a.test.mjs` — covers `parse`, `Parser`, `ParseError`',
    '`tests/a.test.mjs` — mocks fs, `Date`, and child_process.spawnSync']) {
    assert.deepEqual(stepTestsOnly(step(files)), { testsOnly: true, files: ['tests/a.test.mjs'] }, files);
  }
  // The control: alone in its own entry, before any description, it is a file (round 6).
  assert.deepEqual(stepTestsOnly(step('`tests/a.test.mjs`, `Parser`')), { testsOnly: false, files: ['tests/a.test.mjs', 'Parser'] });
});

test('review 630 r10 / 882cc82a plan-schema.mjs:385: a backticked span that is no path starts no description with a colon', () => {
  const step = (files) => `- **Files:** ${files}\n- **Changes:** x\n`;
  for (const [files, paths] of [
    ['`tests/a.test.mjs` adds `x()`: y, package.json', ['tests/a.test.mjs', 'package.json']],
    ['`tests/a.test.mjs` adds `parse()`: y and Makefile', ['tests/a.test.mjs', 'Makefile']],
  ]) {
    assert.deepEqual(stepTestsOnly(step(files)), { testsOnly: false, files: paths }, files);
  }
  // The control: a backticked path with a colon still starts its description.
  assert.deepEqual(stepTestsOnly(step('`tests/a.test.mjs`: y and package.json')), { testsOnly: true, files: ['tests/a.test.mjs'] });
});

test('review 630 r10 / a6bd9c8c plan-schema.mjs:391: a plain file with a colon starts its description wherever it stands', () => {
  const step = (files) => `- **Files:** ${files}\n- **Changes:** x\n`;
  for (const files of ['`tests/a.test.mjs`, the entry cli.mjs: wires parse and README.md',
    '`tests/a.test.mjs`, exercises cli.mjs: argv and package.json',
    '`tests/a.test.mjs`, then index.js: reads argv and .env']) {
    assert.deepEqual(stepTestsOnly(step(files)), { testsOnly: true, files: ['tests/a.test.mjs'] }, files);
  }
});

test('review 630 r10 / 0d94c5fe findings-schema.mjs:53: a ~~~ fence is a fence; a fence four spaces in still counts, so the gate fails closed', async () => {
  const { extractFindingsBlock, fencedBlocks } = await import('../../lib/review/findings-schema.mjs');
  const { decideVerdict } = await import('../../lib/review/verdict-gate.mjs');
  const { validateReviewContent } = await import('../../lib/validators/review-validator.mjs');
  const asBlock = (text) => text.replace('verdict: WARN\nfindings: []', `verdict: BLOCK\nfindings:\n  - ${'a'.repeat(40)}`);
  // A ~~~ example that holds a ```json line, then the review's own block: the
  // ```json line opens nothing, so the block, the gate and the BLOCKER ids are read.
  const tilde = `~~~\n${B3}json\n~~~\n\n`;
  assert.equal(extractFindingsBlock(`${tilde}${B3}json\n{"findings": []}\n${B3}\n`), '{"findings": []}\n');
  const v = decideVerdict(r9Review(`${tilde}${r9Clean}`));
  assert.equal(v.exit, 0, v.reason);
  const r = validateReviewContent(asBlock(r9Review(`${tilde}${B3}json\n${R9_BLOCK}\n${B3}\n`)));
  assert.ok([...r.errors, ...r.warnings].some((i) => i.code === 'REVIEW_MISSING_REMEDIATION_STEP'),
    `a BLOCKER with no ### Step R<n> is found: ${JSON.stringify([...r.errors, ...r.warnings].map((i) => i.code))}`);
  // A ~~~ block is one block, closed only by ~~~; a ~~~json last block is read.
  assert.deepEqual(fencedBlocks(`~~~md\n${B3}json\n{}\n~~~\n`).map((b) => [b.info, b.body, b.closed]), [['md', `${B3}json\n{}\n`, true]]);
  const tildeJson = decideVerdict(r9Review(`${r9Clean}\n~~~json\n${R9_BLOCK}\n~~~\n`));
  assert.notEqual(tildeJson.exit, 0, `a ~~~json block after the clean one is the last block: ${tildeJson.reason}`);
  // Indented or not, a fence counts. A BLOCKER block inside a list item, four
  // spaces in, after the clean block is the last block and is never passed...
  const listItem = `${r9Clean}\n1.  The payload:\n\n${`${B3}json\n${R9_BLOCK}\n${B3}`.replace(/^/gm, '    ')}\n`;
  assert.notEqual(decideVerdict(r9Review(listItem)).exit, 0, decideVerdict(r9Review(listItem)).reason);
  // ...and a ```json line in a code block four spaces in fails the gate closed, never open.
  const coded = decideVerdict(r9Review(`x\n\n    ${B3}json\n\nx\n\n${r9Clean}`));
  assert.equal(coded.exit, 2, coded.reason);
});