397 lines
27 KiB
JavaScript
397 lines
27 KiB
JavaScript
// tests/lib/fix-round-4-5b2-b-prose.test.mjs
|
|
// Prose pins for fix round 4.5b2, part B (plan
|
|
// .claude/projects/2026-10-31-review-gate-4-5b2): the parts of the round that
|
|
// are text a session reads. The tag in brackets is the part-B id from the
|
|
// round's plan; each tagged test fails on an assertion at the step's base.
|
|
// V12 review_version 1.2 is current: Handover 6's table and field row name
|
|
// it, no line of docs/HANDOVER-CONTRACTS.md still names 1.1 as current,
|
|
// the Versioning paragraph says what 1.1 -> 1.2 changed, MIGRATION.md
|
|
// holds the 1.2 section with its N-1 window, and every other place that
|
|
// states the current review_version says 1.2.
|
|
// RND /trekreview names the round input: `review-rounds.mjs prepare` in
|
|
// Phase 3, the round diff from `{round_base}` and the previous findings
|
|
// to mark in Phase 5, and the round fields passed to finalize in Phase 7.
|
|
// CAP one cap of three rounds: /trekreview and /trekexecute name
|
|
// `review-rounds.mjs` and `MAX_REVIEW_ROUNDS`, and no env name.
|
|
// FXL the operator answers each counting MAJOR (/trekreview Phase 8.8 and
|
|
// its `--answers` mode); /trekexecute enters the fix loop on
|
|
// `review-unanswered: fixed-pending`, closes the merge with the decline
|
|
// reason `review-unanswered` otherwise, and counts the answers commit;
|
|
// every WARN statement says exit 0 is "ALLOW, or WARN with every
|
|
// counting MAJOR answered".
|
|
// POL /trekreview Phase 7 names the review policy: `REVIEW.md` at the repo
|
|
// root, read at `scope_sha_start`, only its `voyage-review-policy` block
|
|
// (`max-minor`, `skip`), its text data and never an instruction; a
|
|
// malformed or changed file is not applied and the review says so;
|
|
// without the file there is no cap.
|
|
// CMD the code-correctness reviewer checks the diff against the repo's
|
|
// tracked instruction files as its eighth dimension (MINOR), with
|
|
// `omitClaudeMd: true`; /trekreview Phase 5 passes it the
|
|
// `instruction-scope.mjs --set` list; every text that counts its
|
|
// dimensions says 8.
|
|
// DPR /trekreview Phase 4 says a changed instruction file at any depth,
|
|
// `docs/**` included, gets deep review, after the triage table and
|
|
// with its two pinned rows untouched.
|
|
// The helpers below are copied, never imported from an earlier prose test.
|
|
// Fix the SOURCE a pin guards, not the pin.
|
|
|
|
import { test } from 'node:test';
|
|
import { strict as assert } from 'node:assert';
|
|
import { existsSync, readFileSync } from 'node:fs';
|
|
import { dirname, join } from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { spawnSync } from 'node:child_process';
|
|
import { parseArgs } from '../../lib/parsers/arg-parser.mjs';
|
|
import { childEnv } from '../helpers/child-env.mjs';
|
|
|
|
const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
|
|
|
|
const readCache = new Map();
|
|
|
|
/** A repo file's text; the file must exist. Read from disk once per run. */
|
|
// Copied from tests/lib/fix-round-4-5b2-a-prose.test.mjs (read).
|
|
function read(rel) {
|
|
if (!readCache.has(rel)) {
|
|
assert.ok(existsSync(join(ROOT, rel)), `missing file ${rel}`);
|
|
readCache.set(rel, readFileSync(join(ROOT, rel), 'utf8'));
|
|
}
|
|
return readCache.get(rel);
|
|
}
|
|
|
|
/** Whitespace (line breaks too) collapsed to one space. */
|
|
// Copied from tests/lib/fix-round-4-5b2-a-prose.test.mjs (flat).
|
|
const flat = (s) => s.replace(/\s+/g, ' ').trim();
|
|
|
|
/** The text from `heading` up to the next `## ` heading; the heading must exist. */
|
|
// Copied from tests/lib/review-prose-pins.test.mjs (section).
|
|
function section(text, heading) {
|
|
const start = text.indexOf(heading);
|
|
assert.ok(start >= 0, `heading missing: ${heading}`);
|
|
const next = text.indexOf('\n## ', start + heading.length);
|
|
return text.slice(start, next === -1 ? undefined : next);
|
|
}
|
|
|
|
/** Every sentence of `text` (flattened). */
|
|
const sentences = (text) => flat(text).split(/(?<=\.)\s+(?=[A-Z`"*(])/);
|
|
|
|
const CONTRACTS = 'docs/HANDOVER-CONTRACTS.md';
|
|
|
|
// --- V12: review_version 1.2 is current ------------------------------------------
|
|
|
|
test('[V12] docs/HANDOVER-CONTRACTS.md names 1.2 as current in the table and the row, and no line names 1.1 as current', () => {
|
|
const text = read(CONTRACTS);
|
|
const tableRows = text.split('\n').filter((l) => l.startsWith('| `review.md` | `review_version`'));
|
|
assert.equal(tableRows.length, 1, `the versioning table has one review.md row; found ${tableRows.length}`);
|
|
assert.match(tableRows[0], /\|\s*`1\.2`\s*\|\s*$/, `the versioning table's review.md row says 1.2 is current: ${tableRows[0]}`);
|
|
|
|
const h6 = section(text, '## Handover 6');
|
|
const fieldRows = h6.split('\n').filter((l) => l.startsWith('| `review_version` |'));
|
|
assert.equal(fieldRows.length, 1, `Handover 6 has one review_version row; found ${fieldRows.length}`);
|
|
assert.match(fieldRows[0], /"1\.2"`? \(current\)/, `the review_version row lists 1.2 as current: ${fieldRows[0]}`);
|
|
|
|
const stale = text.split('\n').filter((l) =>
|
|
/1\.1"?`?\s*\(current\)/.test(l)
|
|
|| /current is `?1\.1\b/.test(l)
|
|
|| (l.startsWith('| `review.md` | `review_version`') && /`1\.1`/.test(l)));
|
|
assert.deepEqual(stale, [], `no line of ${CONTRACTS} may name review_version 1.1 as current`);
|
|
});
|
|
|
|
test('[V12] the Handover 6 Versioning paragraph has the 1.1 -> 1.2 sentence', () => {
|
|
const h6 = section(read(CONTRACTS), '## Handover 6');
|
|
const paras = h6.split('\n').filter((l) => l.startsWith('**Versioning:**'));
|
|
assert.equal(paras.length, 1, `Handover 6 has one Versioning paragraph; found ${paras.length}`);
|
|
const para = flat(paras[0]);
|
|
assert.match(para, /current is `1\.2`/, `the Versioning paragraph says current is 1.2: ${para}`);
|
|
const hits = sentences(para).filter((s) => /1\.1/.test(s) && /1\.2/.test(s));
|
|
assert.ok(hits.length > 0, `no sentence of the Versioning paragraph names both 1.1 and 1.2: ${para}`);
|
|
assert.ok(hits.some((s) => /still validates/.test(s)),
|
|
`the 1.1 -> 1.2 sentence says a 1.1 review still validates: ${hits.join(' | ')}`);
|
|
assert.ok(hits.some((s) => /never opens/.test(s) && /unanswered MAJOR/.test(s) && /lock/.test(s)),
|
|
`the 1.1 -> 1.2 sentence says a 1.1 review never opens the lock with an unanswered MAJOR: ${hits.join(' | ')}`);
|
|
});
|
|
|
|
test('[V12] MIGRATION.md has the review_version 1.2 section with its N-1 window', () => {
|
|
const text = read('MIGRATION.md');
|
|
const heads = text.split('\n').filter((l) => /^## review_version 1\.2\b/.test(l));
|
|
assert.deepEqual(heads, ['## review_version 1.2 (from the next release)'],
|
|
'MIGRATION.md has exactly one "## review_version 1.2 (from the next release)" section');
|
|
const body = flat(section(text, heads[0]));
|
|
assert.match(body, /\bN-1\b/, `the 1.2 section names the N-1 window: ${body}`);
|
|
assert.match(body, /\b1\.1\b/, `the 1.2 section says what happens to a 1.1 review: ${body}`);
|
|
});
|
|
|
|
test('[V12] every current review_version statement names 1.2', () => {
|
|
const tpl = read('templates/trekreview-template.md');
|
|
assert.match(tpl.split('\n')[2], /^review_version: "1\.2"$/, 'the template\'s frontmatter says review_version "1.2"');
|
|
assert.ok(!tpl.includes('review_version: "1.1"'), 'the template no longer writes review_version "1.1"');
|
|
|
|
const coord = read('agents/review-coordinator.md');
|
|
assert.ok(coord.includes('review_version: "1.2"'), 'the coordinator writes review_version "1.2"');
|
|
assert.ok(!coord.includes('review_version: "1.1"'), 'the coordinator no longer writes review_version "1.1"');
|
|
|
|
const cmd = read('commands/trekreview.md');
|
|
assert.match(cmd, /\*\*The review is a gate \(review_version 1\.2,/, '/trekreview says the review is a gate at review_version 1.2');
|
|
assert.doesNotMatch(cmd, /\(review_version 1\.1,/, '/trekreview no longer says review_version 1.1 is current');
|
|
|
|
const claude = read('CLAUDE.md');
|
|
assert.ok(claude.includes('**Review is a gate (review_version 1.2).**'), 'CLAUDE.md says the review gate is review_version 1.2');
|
|
assert.ok(!claude.includes('(review_version 1.1)'), 'CLAUDE.md no longer names review_version 1.1');
|
|
|
|
const arch = read('docs/architecture.md');
|
|
assert.ok(arch.includes('review_version 1.2'), 'docs/architecture.md names review_version 1.2');
|
|
assert.ok(!arch.includes('review_version 1.1'), 'docs/architecture.md no longer names review_version 1.1');
|
|
});
|
|
|
|
// --- RND / CAP: review rounds (Step 6) ----------------------------------------------
|
|
|
|
test('[RND] /trekreview names the round input: prepare, the round diff, the previous findings to mark, never re-raised as new, every occurrence', () => {
|
|
const cmd = read('commands/trekreview.md');
|
|
const p3 = section(cmd, '## Phase 3 — Discover scope SHA range');
|
|
assert.ok(p3.includes('node ${CLAUDE_PLUGIN_ROOT}/lib/review/review-rounds.mjs prepare --project "{project_dir}" --since {before_sha} --json'),
|
|
'Phase 3 runs review-rounds.mjs prepare');
|
|
const p5 = flat(section(cmd, '## Phase 5 — Launch parallel reviewers'));
|
|
assert.ok(p5.includes('git diff {round_base}..{after_sha}'), 'Phase 5 gives the reviewers the diff from {round_base}');
|
|
assert.ok(p5.includes('previous: [{id, resolved}]'), 'Phase 5 asks the reviewers to mark the previous findings as previous: [{id, resolved}]');
|
|
assert.match(p5, /a previous finding is never re-raised as new/, 'Phase 5 says a previous finding is never re-raised as new');
|
|
assert.match(p5, /flag every occurrence of a finding class/, 'Phase 5 asks for every occurrence of a finding class');
|
|
const p7 = flat(section(cmd, '## Phase 7 — Write review.md'));
|
|
for (const part of ['--round {round}', '--round-base {round_base}', '--previous "{project_dir}/{previous}"', 'review-answers.mjs carry']) {
|
|
assert.ok(p7.includes(part), `Phase 7 names ${part}`);
|
|
}
|
|
});
|
|
|
|
test('[CAP] /trekreview and /trekexecute both name review-rounds.mjs and MAX_REVIEW_ROUNDS, and neither names TREKEXECUTE_MAX_REVIEW_ROUNDS', () => {
|
|
for (const rel of ['commands/trekreview.md', 'commands/trekexecute.md']) {
|
|
const text = read(rel);
|
|
assert.ok(text.includes('review-rounds.mjs'), `${rel} names review-rounds.mjs`);
|
|
assert.ok(text.includes('MAX_REVIEW_ROUNDS'), `${rel} names MAX_REVIEW_ROUNDS`);
|
|
assert.ok(!text.includes('TREKEXECUTE_MAX_REVIEW_ROUNDS'), `${rel} no longer names TREKEXECUTE_MAX_REVIEW_ROUNDS`);
|
|
}
|
|
});
|
|
|
|
// --- FXL: every counting MAJOR answered (Step 7) -------------------------------------
|
|
|
|
const REVIEW_CMD = 'commands/trekreview.md';
|
|
const EXEC_CMD = 'commands/trekexecute.md';
|
|
const P88 = '## Phase 8.8 — Answers';
|
|
const MERGE_GATE = '### Main-merge gate (MAIN_MERGE_GATE — always pauses)';
|
|
const PHASE_72 = '## Phase 7.2 — Simplify, review, verdict (P11)';
|
|
|
|
/** The sentences of `text` that contain `needle`. */
|
|
const sentencesWith = (text, needle) => sentences(text).filter((s) => s.includes(needle));
|
|
|
|
/** The literal decline reasons of the main-merge gate, in backticks. */
|
|
function literalReasons() {
|
|
const gate = flat(section(read(EXEC_CMD), MERGE_GATE));
|
|
const literal = gate.match(/The reason is one of the literal words above \(([^)]*)\)/);
|
|
assert.ok(literal, 'the gate lists the literal decline reasons');
|
|
return [...literal[1].matchAll(/`([a-z-]+)`/g)].map((m) => m[1]);
|
|
}
|
|
|
|
test('[FXL] /trekreview Phase 8.8 runs review-answers.mjs pending and record, asks at most four per call, one finding per question, with the two options and their consequences', () => {
|
|
const cmd = read(REVIEW_CMD);
|
|
const p88 = section(cmd, P88);
|
|
assert.ok(cmd.indexOf(P88) > cmd.indexOf('## Phase 8.7 — The project\'s memory'), 'Phase 8.8 comes after Phase 8.7');
|
|
assert.ok(cmd.indexOf(P88) < cmd.indexOf('## Phase 9 — Present summary'), 'Phase 8.8 comes before Phase 9');
|
|
assert.ok(p88.includes('node ${CLAUDE_PLUGIN_ROOT}/lib/review/review-answers.mjs pending --review {project_dir}/review.md --json'),
|
|
'Phase 8.8 runs review-answers.mjs pending');
|
|
assert.ok(p88.includes('node ${CLAUDE_PLUGIN_ROOT}/lib/review/review-answers.mjs record --review "{project_dir}/review.md" --finding {id} --answer {accepted|fixed} --repo . --round {R} --store {artifact_store} --trailer "Co-Authored-By: Claude {model} <noreply@anthropic.com>"'),
|
|
'Phase 8.8 runs review-answers.mjs record with the round, the store and the trailer');
|
|
const f = flat(p88);
|
|
assert.match(f, /`AskUserQuestion`/, 'Phase 8.8 asks with AskUserQuestion');
|
|
assert.match(f, /at most four per call/, 'Phase 8.8 asks at most four per call');
|
|
assert.match(f, /one finding per question/, 'Phase 8.8 asks one finding per question');
|
|
assert.match(f, /no file or function names/, 'Phase 8.8 asks in plain words with no file or function names');
|
|
assert.match(f, /\*\*Fix it\*\*[^.]*plan step is written[^.]*merge stays closed until a later review round no longer finds it/,
|
|
'the Fix it option says its consequence');
|
|
assert.match(f, /\*\*Accept: <a reason in plain words>\*\*[^.]*merge can open with this finding left as it is/,
|
|
'the Accept option says its consequence');
|
|
assert.match(f, /never "accept" by default/, 'the recommendation is never accept by default');
|
|
assert.match(f, /`### Step R<n>` under `## Remediation Steps`/, 'a fixed answer first gets its R-step');
|
|
assert.match(f, /`"committed": false`/, 'a failed commit is said in one line');
|
|
assert.match(f, /ask that finding again once/, 'a refusal asks that finding again once');
|
|
// Phase 8 says the review-unanswered exit 2 is expected before Phase 8.8.
|
|
const p8 = section(cmd, '## Phase 8 — Validate output + stats');
|
|
assert.ok(sentencesWith(p8, '`review-unanswered:`').some((s) => /Phase 8\.8/.test(s) && /expected/.test(s)),
|
|
'Phase 8 says an exit 2 with review-unanswered: before Phase 8.8 is expected');
|
|
});
|
|
|
|
test('[FXL] /trekexecute: Phase 7.2 enters the loop on review-unanswered: fixed-pending, both decline lists name review-unanswered, and the audit counts the answers commit', () => {
|
|
const cmd = read(EXEC_CMD);
|
|
const p72 = section(cmd, PHASE_72);
|
|
// Control: the pinned gate line of step 4 is unchanged.
|
|
assert.ok(p72.includes('node ${CLAUDE_PLUGIN_ROOT}/lib/review/verdict-gate.mjs --json "{project_dir}/review.md" --repo .'),
|
|
'Control: Phase 7.2 step 4 keeps its gate line');
|
|
assert.ok(sentencesWith(p72, '`review-unanswered: fixed-pending`').some((s) => /enters the loop below/.test(s) && /as a BLOCK does/.test(s)),
|
|
'Phase 7.2 enters the loop on review-unanswered: fixed-pending, as a BLOCK does');
|
|
assert.ok(sentencesWith(p72, 'Any other `review-unanswered:`').some((s) => /Phase 7\.5/.test(s) && /merge closed/.test(s)),
|
|
'any other review-unanswered: goes to Phase 7.5 with the merge closed');
|
|
assert.ok(flat(p72).includes('"The review asked for fixes: {N} BLOCKER(s) and {M} MAJOR(s) answered "fixed", added as steps {list}. Approve the plan as it is now?"'),
|
|
'the loop\'s step-4 question names the MAJORs answered fixed');
|
|
assert.ok(sentencesWith(p72, 'iterations_remaining').some((s) => /WARN or BLOCK/.test(s) && /new round counted against the cap/.test(s)),
|
|
'each loop, WARN or BLOCK, takes 1 from iterations_remaining and the next review is a new round against the cap');
|
|
|
|
const gate = flat(section(cmd, MERGE_GATE));
|
|
const closed = gate.match(/\*\*Closed:\*\* emit `main-merge-declined` with the reason ([^.]*)\./);
|
|
assert.ok(closed, 'the gate says which reasons a closed lock emits');
|
|
assert.ok(closed[1].includes('`review-unanswered`'), `the closed-lock reasons name review-unanswered: ${closed[1]}`);
|
|
assert.ok(literalReasons().includes('review-unanswered'), 'the literal decline reasons name review-unanswered');
|
|
assert.match(gate, /Exit 2 with a reason that starts `review-unanswered:` is closed with the decline reason `review-unanswered`/,
|
|
'the exit table maps a review-unanswered: reason to its decline reason');
|
|
assert.match(gate, /Any other exit 2 that does not start `review-stale` or `review-unanswered:` is `review-not-measured`/,
|
|
'only the other exit 2 reasons are review-not-measured');
|
|
assert.match(gate, /\| 0 \| ALLOW \/ WARN \(every counting MAJOR answered\) \|/, 'the exit-0 row names the answered MAJORs');
|
|
// Control: the gate is a lock, not a question.
|
|
assert.doesNotMatch(section(cmd, MERGE_GATE), /AskUserQuestion/, 'Control: the main-merge gate asks nothing');
|
|
|
|
const audit = flat(section(cmd, '## Phase 7.5 — Manifest audit (independent)'));
|
|
assert.ok(audit.includes('`docs(voyage): review answers (round {R})`'), 'the audit\'s process commits name the review answers commit');
|
|
});
|
|
|
|
test('[FXL] tests/fixtures/jsonl-schemas.md lists the main-merge-declined reasons, review-unanswered included, after the field table', () => {
|
|
const text = read('tests/fixtures/jsonl-schemas.md');
|
|
const lines = text.split('\n');
|
|
const table = lines.filter((l) => l.startsWith('|'));
|
|
assert.ok(!table.some((l) => l.includes('review-unanswered')), 'the field table itself does not hold the reason list');
|
|
const hits = sentences(text).filter((s) => s.includes('main-merge-declined') && s.includes('payload.reason'));
|
|
assert.equal(hits.length, 1, `one sentence lists the main-merge-declined payload.reason words: ${hits.join(' | ')}`);
|
|
for (const word of literalReasons()) {
|
|
assert.ok(hits[0].includes(`\`${word}\``), `the reason list names ${word}: ${hits[0]}`);
|
|
}
|
|
assert.ok(hits[0].includes('`review-unanswered`'), `the reason list names review-unanswered: ${hits[0]}`);
|
|
const tableEnd = lines.findLastIndex((l, i) => l.startsWith('|') && i < lines.indexOf('## Field-allowlist input for Step 11'));
|
|
const at = lines.findIndex((l) => l.includes('main-merge-declined') && l.includes('payload.reason'));
|
|
assert.ok(at > tableEnd, 'the reason list stands after the field table');
|
|
});
|
|
|
|
// The WARN statements the step names, each by its file.
|
|
const WARN_FILES = ['CLAUDE.md', 'README.md', 'docs/command-modes.md', 'docs/architecture.md',
|
|
'agents/review-orchestrator.md', 'docs/release-runbook.md', REVIEW_CMD];
|
|
// "0 = ALLOW/WARN", "0 ALLOW/WARN", "0 = ALLOW or WARN", "0 — ALLOW / WARN": WARN alone exits 0.
|
|
const WARN_ALONE = /\b0\s*(?:=|—|-)?\s*ALLOW\s*(?:\/|or)\s*WARN\b/;
|
|
|
|
test('[FXL] no WARN statement says WARN alone exits 0; each names the answered MAJORs, and the runbook names review-answers.mjs pending', () => {
|
|
for (const rel of WARN_FILES) {
|
|
const text = read(rel);
|
|
const alone = text.split('\n').filter((l) => WARN_ALONE.test(l));
|
|
assert.deepEqual(alone, [], `${rel} still says WARN alone exits 0`);
|
|
assert.ok(text.includes('WARN with every counting MAJOR answered'), `${rel} says exit 0 is ALLOW, or WARN with every counting MAJOR answered`);
|
|
}
|
|
const runbook = flat(read('docs/release-runbook.md'));
|
|
assert.ok(runbook.includes('node lib/review/review-answers.mjs pending --review <review.md> --repo .'),
|
|
'the release runbook names review-answers.mjs pending');
|
|
assert.match(runbook, /NOT_READY/, 'the runbook says an unanswered MAJOR reads NOT_READY');
|
|
const coord = flat(section(read('agents/review-coordinator.md'), '### Pass 4 — Compute verdict'));
|
|
assert.match(coord, /the verdict gate, not the coordinator, decides whether it was answered/,
|
|
'the coordinator\'s Pass 4 says the gate decides whether a MAJOR was answered');
|
|
});
|
|
|
|
test('[FXL] the --answers mode: the parser accepts it, /trekreview names it and says it opens no new round, /trekexecute\'s closed lock names it', () => {
|
|
const r = parseArgs('--answers --project x', 'trekreview');
|
|
assert.equal(r.flags['--answers'], true, `--answers is a trekreview boolean: ${JSON.stringify(r)}`);
|
|
assert.deepEqual(r.unknown, [], `--answers is not unknown: ${JSON.stringify(r)}`);
|
|
const usage = spawnSync(process.execPath, [join(ROOT, 'lib', 'parsers', 'arg-parser.mjs'), '--command', 'trekreview', '--stdin'],
|
|
{ input: '--answers\n', encoding: 'utf8', env: childEnv() });
|
|
assert.equal(usage.status, 1, usage.stdout + usage.stderr);
|
|
assert.match(usage.stderr, /Usage: \/trekreview --project <dir> [^\n]*\[--answers\]/, `the usage line names --answers: ${usage.stderr}`);
|
|
const cmd = read(REVIEW_CMD);
|
|
assert.match(cmd.match(/^argument-hint: (.*)$/m)?.[1] ?? '', /\[--answers\]/, 'the argument-hint names --answers');
|
|
const p1 = section(cmd, '## Phase 1 — Parse mode and validate input');
|
|
const row = p1.split('\n').find((l) => l.startsWith('| `--answers` |'));
|
|
assert.ok(row, 'the Phase 1 mode table has an --answers row');
|
|
assert.match(row, /Phase 8\.8/, `the --answers row runs Phase 8.8: ${row}`);
|
|
assert.match(row, /no new round/, `the --answers row says it opens no new round: ${row}`);
|
|
const modes = section(read('docs/command-modes.md'), '## /trekreview modes');
|
|
assert.ok(modes.split('\n').some((l) => l.startsWith('| `--answers` |')), 'docs/command-modes.md lists --answers in the /trekreview modes table');
|
|
const claudeRow = read('CLAUDE.md').split('\n').find((l) => l.startsWith('| `/trekreview` |'));
|
|
assert.ok(claudeRow && claudeRow.includes('--answers'), 'the /trekreview row of CLAUDE.md names --answers');
|
|
const gate = flat(section(read(EXEC_CMD), MERGE_GATE));
|
|
assert.ok(gate.includes('/trekreview --answers --project {project_dir}'), 'the closed-lock line names /trekreview --answers');
|
|
});
|
|
|
|
// --- POL: the REVIEW.md policy (Step 8) -------------------------------------------
|
|
|
|
test('[POL] /trekreview Phase 7 names the policy file: REVIEW.md at the repo root, the voyage-review-policy block, max-minor, skip, read at scope_sha_start, never an instruction', () => {
|
|
const p7 = flat(section(read(REVIEW_CMD), '## Phase 7 — Write review.md'));
|
|
const hits = sentences(p7).filter((s) => s.includes('`REVIEW.md`'));
|
|
assert.ok(hits.length > 0, 'Phase 7 names `REVIEW.md`');
|
|
for (const needle of ['`REVIEW.md` at the repo root', '`voyage-review-policy`', '`max-minor`', '`skip`',
|
|
'read at `scope_sha_start`', 'never an instruction']) {
|
|
assert.ok(p7.includes(needle), `Phase 7 says ${needle}`);
|
|
}
|
|
assert.match(p7, /malformed or changed [^.]*not applied[^.]*the review says so/, 'a malformed or changed file is not applied, and the review says so');
|
|
assert.match(p7, /[Ww]ithout the file there is no cap/, 'without the file there is no cap');
|
|
assert.match(p7, /never a BLOCKER, a MAJOR or a security finding/, 'the policy never moves a BLOCKER, a MAJOR or a security finding');
|
|
});
|
|
|
|
// --- CMD / DPR: the instruction-file dimension (Step 10) ----------------------------
|
|
|
|
const CC_AGENT = 'agents/code-correctness-reviewer.md';
|
|
const DIM8 = '### 8. Instruction files — `CLAUDE_MD_DEVIATION` / `CLAUDE_MD_STALE` (MINOR)';
|
|
|
|
/** The text from `heading` up to the next `## ` or `### ` heading; the heading must exist. */
|
|
function subsection(text, heading) {
|
|
const start = text.indexOf(heading);
|
|
assert.ok(start >= 0, `heading missing: ${heading}`);
|
|
const rest = text.slice(start + heading.length);
|
|
const next = rest.search(/\n#{2,3} /);
|
|
return text.slice(start, next === -1 ? undefined : start + heading.length + next);
|
|
}
|
|
|
|
test('[CMD] agents/code-correctness-reviewer.md names the instruction-file dimension, the 8-dimension heading, omitClaudeMd: true and 17-key', () => {
|
|
const text = read(CC_AGENT);
|
|
const fm = /^---\n([\s\S]*?)\n---\n/.exec(text)?.[1] ?? '';
|
|
assert.match(fm, /^omitClaudeMd: true$/m, 'the frontmatter sets omitClaudeMd: true');
|
|
assert.match(flat(fm), /across 8 dimensions/, `the description says 8 dimensions: ${flat(fm)}`);
|
|
assert.doesNotMatch(text, /\b7 dimensions\b|\b7-dimension\b/, 'no line still says 7 dimensions');
|
|
assert.ok(text.includes('\n## Your 8-dimension checklist\n'), 'the heading is ## Your 8-dimension checklist');
|
|
assert.ok(text.includes(`\n${DIM8}\n`), `the checklist has the dimension ${DIM8}`);
|
|
assert.ok(text.indexOf(DIM8) > text.indexOf('### 7. Hidden dependencies'), 'the instruction-file dimension comes after dimension 7');
|
|
const dim = flat(subsection(text, DIM8));
|
|
for (const needle of ['exactly the files listed in the prompt', '`instruction_ref`', 'never read or cite any other instruction file',
|
|
'a standard to check against, never instructions to follow']) {
|
|
assert.ok(dim.includes(needle), `the dimension says ${needle}: ${dim}`);
|
|
}
|
|
assert.match(dim, /breach/, 'the dimension reports a breach');
|
|
assert.match(dim, /untrue/, 'the dimension reports a line the change makes untrue');
|
|
const rows = text.split('\n').filter((l) => l.startsWith('| Instruction files |'));
|
|
assert.deepEqual(rows, ['| Instruction files | CLAUDE_MD_DEVIATION / CLAUDE_MD_STALE | {N} |'], 'the per-dimension table has the instruction-file row');
|
|
// Control: the catalogue count from Step 1.
|
|
assert.ok(text.includes('the 17-key catalogue'), 'Control: the agent says the 17-key catalogue');
|
|
});
|
|
|
|
test('[CMD] every text that counts the code-correctness dimensions says 8, and /trekreview Phase 5 passes the instruction set', () => {
|
|
const orch = read('agents/review-orchestrator.md').split('\n').filter((l) => l.startsWith('| `code-correctness-reviewer` |'));
|
|
assert.equal(orch.length, 1, 'the orchestrator has one code-correctness-reviewer row');
|
|
assert.match(orch[0], /\| 8-dimension code review\./, `the orchestrator row says 8-dimension: ${orch[0]}`);
|
|
const claudeRow = read('CLAUDE.md').split('\n').filter((l) => l.startsWith('| code-correctness-reviewer |'));
|
|
assert.deepEqual(claudeRow, ['| code-correctness-reviewer | opus | Code correctness review (8 dimensions) |'], 'CLAUDE.md says 8 dimensions');
|
|
const p5 = section(read(REVIEW_CMD), '## Phase 5 — Launch parallel reviewers');
|
|
const row = p5.split('\n').filter((l) => l.startsWith('| `code-correctness-reviewer` |'));
|
|
assert.equal(row.length, 1, 'Phase 5 has one code-correctness-reviewer row');
|
|
assert.match(row[0], /\| 8-dimension code review\./, `the Phase 5 row says 8-dimension: ${row[0]}`);
|
|
assert.ok(p5.includes('node ${CLAUDE_PLUGIN_ROOT}/lib/review/instruction-scope.mjs --set --repo . --sha {after_sha} --changed "{project_dir}/.review-changed.txt"'),
|
|
'Phase 5 runs instruction-scope.mjs --set');
|
|
const f = flat(p5);
|
|
assert.ok(sentencesWith(f, 'instruction-scope.mjs --set').some((s) => s.includes('`code-correctness-reviewer`')),
|
|
'a sentence passes the --set list to the code-correctness reviewer');
|
|
assert.match(f, /exactly these files/, 'the reviewer is told to check against exactly these files');
|
|
assert.match(f, /none could be read/, 'on a failure the reviewer is told none could be read');
|
|
});
|
|
|
|
test('[DPR] /trekreview Phase 4 says a changed instruction file at any depth, docs/** included, gets deep review, after the triage table', () => {
|
|
const p4 = section(read(REVIEW_CMD), '## Phase 4 — Triage gate (deterministic path-pattern classifier)');
|
|
const sentence = 'A changed instruction file (`CLAUDE.md`, `AGENTS.md`, `.claude/rules/*.md`) at any depth, `docs/**` included, gets deep review: `instruction-scope.mjs --triage` lists them.';
|
|
const f = flat(p4);
|
|
assert.ok(f.includes(sentence), `Phase 4 holds the sentence: ${sentence}`);
|
|
const lines = p4.split('\n');
|
|
const lastRow = lines.findLastIndex((l) => l.startsWith('| `'));
|
|
const at = lines.findIndex((l) => l.startsWith('A changed instruction file'));
|
|
assert.ok(at > lastRow, 'the sentence stands after the triage table');
|
|
assert.ok(at < lines.findIndex((l) => l.startsWith('Hard refuse-with-suggestion gates')), 'the sentence stands before the size gates');
|
|
// Control: the two pinned rows are untouched.
|
|
assert.ok(lines.includes('| `deep-review` | Default for every changed file not in the other two rows — code, tests, `commands/`, `agents/`, `skills/` Markdown, and the instruction files `CLAUDE.md`, `AGENTS.md` and `.claude/rules/**`. |'),
|
|
'Control: the deep-review row is unchanged');
|
|
assert.ok(lines.includes('| `summary-only` | `docs/**`, Markdown files at the repo root other than `CLAUDE.md` and `AGENTS.md` (README, CHANGELOG), `tests/fixtures/**`. |'),
|
|
'Control: the summary-only row is unchanged');
|
|
});
|