// tests/lib/doc-consistency.test.mjs
// Pin invariants between prose (CLAUDE.md, README.md) and source files
// (agents/*.md, commands/*.md, templates/).
//
// When this test fails, fix the source-of-truth — do NOT rewrite the test to
// hide drift. Borrowed pattern from llm-security commit 97c5c9d.
//
// Two kinds of pin live here (devil's-advocate audit §Top changes #8, S19):
//   • STRUCTURAL cross-file invariants — derive one side from a source-of-truth
//     (file counts, dimension counts from `### N.` headers, version-sync) and
//     survive harmless rewording. These are the
//     load-bearing ones; keep and grow them.
//   • PROSE / EXISTENCE pins — assert a literal string or file fact. Most still
//     guard a real wiring (CLI shims, annotate.mjs, anti-stale CHANGELOG,
//     anti-false-claim), but they break on reword. Prefer a structural form
//     when one exists; do not add a prose-pin that a structural test subsumes.
// All tests in this file are documentation pins, not behavior coverage.

import { test } from 'node:test';
import { strict as assert } from 'node:assert';
import { readFileSync, readdirSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';
import { parseDocument } from '../../lib/util/frontmatter.mjs';

const HERE = dirname(fileURLToPath(import.meta.url));
const ROOT = join(HERE, '..', '..');

function read(rel) { return readFileSync(join(ROOT, rel), 'utf-8'); }
function listMd(rel) { return readdirSync(join(ROOT, rel)).filter(f => f.endsWith('.md')); }
function listMjs(rel) { return readdirSync(join(ROOT, rel)).filter(f => f.endsWith('.mjs')); }

// Normalize a "<N|word> dimensions" descriptor to an integer (four..ten + digits).
const NUMWORDS = { four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9, ten: 10 };
function dimCounts(text, anchor) {
  // Every dimension count stated on a line mentioning `anchor`.
  return text.split('\n')
    .filter(l => l.includes(anchor) && /dimensions/.test(l))
    .map(l => l.match(/(\d+|four|five|six|seven|eight|nine|ten)\s+(?:numbered\s+)?dimensions/i))
    .filter(Boolean)
    .map(m => /^\d+$/.test(m[1]) ? Number(m[1]) : NUMWORDS[m[1].toLowerCase()]);
}

test('CLAUDE.md agents table row count == agents/*.md file count', () => {
  const md = read('CLAUDE.md');
  const agentFiles = listMd('agents');
  const agentTable = md.split('## Agents')[1] || '';
  const tableSection = agentTable.split('\n## ')[0];
  const dataRows = tableSection
    .split('\n')
    .filter(l => l.startsWith('|') && !l.match(/^\|[\s-]+\|/) && !l.match(/^\|\s*Agent\s*\|/));
  assert.equal(
    dataRows.length,
    agentFiles.length,
    `Drift: ${agentFiles.length} agent files vs ${dataRows.length} CLAUDE.md table rows. ` +
    `Sync agents/ ↔ CLAUDE.md.`,
  );
});

test('README architecture block agent-count == agents/*.md file count', () => {
  const md = read('README.md');
  const m = md.match(/agents\/\s+(\d+)\s+specialized agents/);
  assert.ok(m, 'README architecture block must state "N specialized agents"');
  assert.equal(
    Number(m[1]),
    listMd('agents').length,
    `Drift: README says ${m[1]} specialized agents vs ${listMd('agents').length} agents/*.md files.`,
  );
});

test('README architecture block hook-count == hooks/scripts/*.mjs file count', () => {
  const md = read('README.md');
  const m = md.match(/hooks\/\s+(\d+)\s+hooks\s*\(/);
  assert.ok(m, 'README architecture block must state "N hooks (...)"');
  assert.equal(
    Number(m[1]),
    listMjs('hooks/scripts').length,
    `Drift: README says ${m[1]} hooks vs ${listMjs('hooks/scripts').length} hooks/scripts/*.mjs files.`,
  );
});

test('plan-critic dimension count: README + CLAUDE.md match the agent definition', () => {
  const dims = (read('agents/plan-critic.md').match(/^### \d+\./gm) || []).length;
  assert.ok(dims > 0, 'agents/plan-critic.md must define numbered "### N." dimensions');
  const stated = [...dimCounts(read('README.md'), 'plan-critic'), ...dimCounts(read('CLAUDE.md'), 'plan-critic')];
  assert.ok(stated.length >= 2, 'README + CLAUDE.md must cite plan-critic (N dimensions)');
  for (const n of stated) {
    assert.equal(n, dims, `Drift: a doc cites plan-critic (${n} dimensions) vs ${dims} numbered dims in agents/plan-critic.md.`);
  }
});

test('brief-reviewer dimension count: README matches the agent definition', () => {
  const agentDims = dimCounts(read('agents/brief-reviewer.md'), 'dimensions');
  assert.ok(agentDims.length >= 1, 'agents/brief-reviewer.md must state "N dimensions"');
  const expected = agentDims[0];
  // Only the line stating brief-reviewer's OWN count — exclude agent-list lines
  // that co-mention `plan-critic (N dimensions)` (those carry plan-critic's count).
  const readmeDims = read('README.md').split('\n')
    .filter(l => l.includes('brief-reviewer') && /dimensions/.test(l) && !l.includes('plan-critic'))
    .map(l => l.match(/(\d+|four|five|six|seven|eight|nine|ten)\s+dimensions/i))
    .filter(Boolean)
    .map(m => /^\d+$/.test(m[1]) ? Number(m[1]) : NUMWORDS[m[1].toLowerCase()]);
  assert.ok(readmeDims.length >= 1, 'README must cite brief-reviewer (N dimensions)');
  for (const n of readmeDims) {
    assert.equal(n, expected, `Drift: README cites brief-reviewer (${n} dimensions) vs ${expected} in agents/brief-reviewer.md.`);
  }
});

test('CLAUDE.md commands table mentions every commands/*.md file', () => {
  const md = read('CLAUDE.md');
  const commandFiles = listMd('commands');
  for (const f of commandFiles) {
    const cmdName = `/${f.replace(/\.md$/, '')}`;
    assert.ok(
      md.includes(cmdName),
      `commands/${f} not mentioned in CLAUDE.md (looked for ${cmdName})`,
    );
  }
});

test('every command frontmatter name matches its filename', () => {
  for (const f of listMd('commands')) {
    const text = read(`commands/${f}`);
    const doc = parseDocument(text);
    if (!doc.valid) continue;
    const expected = f.replace(/\.md$/, '');
    if (doc.parsed.frontmatter && doc.parsed.frontmatter.name !== undefined) {
      assert.equal(
        doc.parsed.frontmatter.name,
        expected,
        `commands/${f} frontmatter.name="${doc.parsed.frontmatter.name}" should be "${expected}"`,
      );
    }
  }
});

test('templates/plan-template.md declares plan_version: 1.9', () => {
  const tpl = read('templates/plan-template.md');
  assert.match(tpl, /plan_version:\s*['"]?1\.9['"]?/);
});

test('HANDOVER-CONTRACTS.md locates plan_version in the plan header line, not frontmatter (S28)', () => {
  // The plan template emits plan_version only in the prose "Generated by"
  // header line; brief-generated plans carry no frontmatter at all (the sole
  // frontmatter block, `source_findings`, is trekreview-only and additive).
  // The contract must therefore not label plan_version a frontmatter field.
  const t = read('docs/HANDOVER-CONTRACTS.md');
  assert.doesNotMatch(t, /`plan_version`\s*\(frontmatter\)/,
    'HANDOVER-CONTRACTS.md must not call plan_version a (frontmatter) field — it lives in the plan header line');
  assert.doesNotMatch(t, /Mirrors plan's frontmatter/,
    "progress.json's plan_version mirrors the plan header line, not frontmatter");
  assert.match(t, /`plan_version`\s*\(plan header line\)/,
    'HANDOVER-CONTRACTS.md versioning table must locate plan_version in the plan header line');
});

// S19 prune (audit §Top changes #8): removed a tautological prose-pin —
// "commands/trekexecute.md still parses v1.7 plan schema" was an OR-chain
// (`includes('plan_version') || includes('Step N:') || includes('### Step ')`)
// that is ~always true and asserts almost nothing. The real v1.7 coverage lives
// in the structural pin "templates/plan-template.md declares plan_version: 1.9"
// (above; 1.8 and 1.7 plans stay valid) + the plan-validator / plan-schema behavior tests.

// S19 prune (audit §Top changes #8): removed "CLAUDE.md mentions all six
// pipeline commands" — a hardcoded six-string list fully subsumed by the
// structural pin "CLAUDE.md commands table mentions every commands/*.md file"
// above, which derives the command set from the filesystem and auto-covers any
// new command. The hardcoded list was the weaker, reword-fragile form.

test('HANDOVER-CONTRACTS.md contains Handover 6 section', () => {
  const text = read('docs/HANDOVER-CONTRACTS.md');
  assert.ok(
    text.includes('## Handover 6'),
    'docs/HANDOVER-CONTRACTS.md should document Handover 6 (review → plan)',
  );
});

test('HANDOVER-CONTRACTS.md contains Handover 7 section (session-state)', () => {
  const text = read('docs/HANDOVER-CONTRACTS.md');
  assert.ok(
    text.includes('## Handover 7'),
    'docs/HANDOVER-CONTRACTS.md should document Handover 7 (.session-state.local.json) ' +
    'consumed by /trekcontinue',
  );
  assert.ok(
    text.includes('.session-state.local.json'),
    'Handover 7 section should name the artifact path',
  );
});

test('review-validator has CLI shim', () => {
  // Ordre 5: the realpath form (no-op-free under a symlink or a space), shared
  // since 6.3.1 (lib/util/is-main.mjs); the run through a symlink is proven in
  // tests/validators/review-validator.test.mjs.
  const text = read('lib/validators/review-validator.mjs');
  assert.ok(
    text.includes('if (isMain(import.meta.url))'),
    'lib/validators/review-validator.mjs should expose the realpath CLI shim so commands can call it from Bash',
  );
});

test('session-state-validator has CLI shim', () => {
  const text = read('lib/validators/session-state-validator.mjs');
  assert.ok(
    text.includes('if (isMain(import.meta.url))'),
    'lib/validators/session-state-validator.mjs should expose the standard CLI shim ' +
    '(if (isMain(import.meta.url))) so /trekcontinue can call it from Bash',
  );
});

test('HANDOVER-CONTRACTS.md Handover 7 documents § Lifecycle subsection', () => {
  const text = read('docs/HANDOVER-CONTRACTS.md');
  const h7Start = text.indexOf('## Handover 7');
  assert.ok(h7Start >= 0, 'Handover 7 heading missing');
  const h7End = text.indexOf('## Stability summary', h7Start);
  assert.ok(h7End > h7Start, 'Stability summary heading missing — could not bound Handover 7');
  const h7 = text.slice(h7Start, h7End);
  assert.ok(
    h7.includes('Lifecycle'),
    'Handover 7 section should include a § Lifecycle subsection (SC-5 stale-file principle)',
  );
});

test('HANDOVER-CONTRACTS.md Handover 7 § Lifecycle names --cleanup and produced_by contract', () => {
  const text = read('docs/HANDOVER-CONTRACTS.md');
  const h7Start = text.indexOf('## Handover 7');
  const h7End = text.indexOf('## Stability summary', h7Start);
  const h7 = text.slice(h7Start, h7End);
  assert.ok(
    h7.includes('--cleanup'),
    'Handover 7 § Lifecycle should mention --cleanup as the operator-invoked stale-file remover',
  );
  assert.ok(
    h7.includes('produced_by'),
    'Handover 7 § Lifecycle should document the produced_by frontmatter contract for NEXT-SESSION-PROMPT.local.md',
  );
});

// S19 prune (audit §Top changes #8): removed "CLAUDE.md mentions /trekcontinue
// command" — subsumed by "CLAUDE.md commands table mentions every commands/*.md
// file" (commands/trekcontinue.md exists, so that loop already asserts the
// /trekcontinue reference). Single-command existence pin → redundant.

test('rule-catalogue has exactly 17 entries', async () => {
  const mod = await import('../../lib/review/rule-catalogue.mjs');
  assert.strictEqual(
    mod.RULE_CATALOGUE.length,
    17,
    'lib/review/rule-catalogue.mjs RULE_CATALOGUE size invariant: must be 17 (12 v1.0 baseline + 2 engine keys, ordre 5, + CODE_REVIEW_IMPROVEMENT, lekerepo trial 2, + CLAUDE_MD_DEVIATION and CLAUDE_MD_STALE, decision 98)',
  );
});

test('Phase 2.6 hands waves over as session orders; no launch template ships', () => {
  // The coupling pin for the PM way: the prose must call the order writer and
  // the status reader (tests/lib/session-orders.test.mjs proves they work), keep
  // push-before-cleanup, and carry the never-start rule.
  assert.ok(!existsSync(join(ROOT, 'templates', 'headless-launch-template.md')),
    'templates/headless-launch-template.md must stay removed');
  const exec = read('commands/trekexecute.md');
  const p26 = exec.slice(exec.indexOf('## Phase 2.6'), exec.indexOf('## Phase 3 '));
  for (const needle of [
    'lib/util/session-orders.mjs" write',
    'lib/util/session-orders.mjs" status',
    'GIT_OPTIONAL_LOCKS',
    'git push origin',
    'Voyage never starts a Claude Code',
  ]) {
    assert.ok(p26.includes(needle), `trekexecute.md Phase 2.6 must include "${needle}"`);
  }
  assert.match(exec, /21\. \*\*Never start Claude Code\.\*\*/, 'trekexecute.md Hard rule 21 missing');
});

test('Phase 9 prose mandates parallel single-message dispatch + inline dedup', () => {
  const cmd = read('commands/trekplan.md');
  assert.ok(
    cmd.includes('single assistant message turn'),
    'commands/trekplan.md Phase 9 should reinforce single-message parallel dispatch',
  );
  assert.ok(
    cmd.includes('plan-review-dedup.mjs'),
    'commands/trekplan.md Phase 9 should call lib/review/plan-review-dedup.mjs after both reviewers complete',
  );
});

// --- S23 — Phase-9 dedup hand-off is executable (defect #1 fix) ---
//
// The read-only reviewers (plan-critic, scope-guardian: Read/Glob/Grep, no Write)
// cannot write the temp files the old prose told them to. Pin the A′ fix so the
// broken /tmp-write instruction cannot creep back:
//   1. The Phase-9 prose of commands/trekplan.md must use --stdin, not the dead
//      /tmp/*-out.json file path the reviewers can't produce.
//   2. BOTH reviewer agents must declare a machine-readable json findings block
//      with the keys the dedup helper consumes (agent + findings + rule_key).
test('S23: Phase-9 dedup hand-off uses --stdin and the reviewers emit a json findings block', () => {
  const cmd = read('commands/trekplan.md');
  assert.ok(
    cmd.includes('--stdin'),
    'commands/trekplan.md Phase 9 must pipe reviewer findings into plan-review-dedup.mjs via --stdin (reviewers are read-only)',
  );
  assert.ok(
    !cmd.includes('/tmp/plan-critic-out.json') && !cmd.includes('/tmp/scope-guardian-out.json'),
    'commands/trekplan.md must NOT instruct the read-only reviewers to Write /tmp/*-out.json — they have no Write tool (defect #1)',
  );
  for (const agentFile of ['agents/plan-critic.md', 'agents/scope-guardian.md']) {
    const a = read(agentFile);
    assert.ok(
      a.includes('"findings"') && a.includes('"rule_key"') && a.includes('"agent"'),
      `${agentFile} must declare a machine-readable json findings block (agent + findings + rule_key) for the Phase-9 dedup helper`,
    );
  }
});

// --- S24 — anti-false-claim: operations.md + command-modes.md autonomy-gate truth-pass ---
//
// autonomy-gate.mjs is the --gates flag parser: --gates [true|false|closed|open]
// → {"ok":true,"gates":true|false}. It has no state machine (R9).
// The old prose (operations.md:15 / command-modes.md gates rows) (1) fabricated a
// state machine `idle → approved → executing → merge-pending → main-merged`, and
// later named the removed one (gates_on, auto_running, paused_for_gate); (3) advertised `--gates {open|closed|adaptive}` —
// there is no strictness policy and no `adaptive` value: the flag is boolean, and
// the CLI shim + all 4 command docs take `--gates [true|false|closed|open]`
// (bare, true, closed = on; false, open = off; fix round 4.5a, #1).
test('operations.md + command-modes.md describe the real autonomy-gate, not a fabricated one [S24]', () => {
  const ops = read('docs/operations.md');
  const modes = read('docs/command-modes.md');

  // F1 — state names: fabricated (merge-pending/main-merged) or removed with the state machine (R9)
  for (const bad of ['merge-pending', 'main-merged', 'gates_on', 'auto_running', 'paused_for_gate']) {
    assert.ok(
      !ops.includes(bad),
      `docs/operations.md: fabricated autonomy state "${bad}" — autonomy-gate.mjs has no such state; fix the prose, not this test`,
    );
  }

  // F1 — the module is documented as what it is: the flag parser
  assert.ok(
    ops.includes('`lib/util/autonomy-gate.mjs` is the `--gates` flag parser'),
    'docs/operations.md must describe lib/util/autonomy-gate.mjs as the --gates flag parser',
  );

  // F3 — --gates is boolean; there is no open/closed/adaptive strictness enum
  const GATES_ENUM_FORMS = ['{open|closed|adaptive}', '{open\\|closed\\|adaptive}'];
  for (const [label, txt] of [['operations.md', ops], ['command-modes.md', modes]]) {
    for (const bad of GATES_ENUM_FORMS) {
      assert.ok(
        !txt.includes(bad),
        `docs/${label}: --gates flag enum "${bad}" is false — the flag is boolean: bare, true or closed = on, false or open = off, and there is no adaptive; fix the prose, not this test`,
      );
    }
  }
});

test('CHANGELOG.md has v4.1.0 entry', () => {
  const cl = read('CHANGELOG.md');
  assert.match(
    cl,
    /## v4\.1\.0\b/,
    'CHANGELOG.md must include "## v4.1.0" entry per Keep-a-Changelog 1.1.0',
  );
});

test('commands/trekplan.md Phase 8 seals Opus-4.7 schema-drift defense', () => {
  const cmd = read('commands/trekplan.md');
  // Locate Phase 8 section
  const phase8Start = cmd.indexOf('## Phase 8');
  assert.ok(phase8Start >= 0, 'Phase 8 heading missing');
  const phase8End = cmd.indexOf('## Phase 9', phase8Start);
  assert.ok(phase8End > phase8Start, 'Phase 9 heading missing — could not bound Phase 8');
  const phase8 = cmd.slice(phase8Start, phase8End);
  // Required regex source-of-truth references
  assert.ok(
    phase8.includes('STEP_HEADING_REGEX'),
    'Phase 8 should inline STEP_HEADING_REGEX so format contract survives without orchestrator-doc loading',
  );
  assert.ok(
    phase8.includes('FORBIDDEN_HEADING_REGEX'),
    'Phase 8 should inline FORBIDDEN_HEADING_REGEX (Step 7 — schema-drift seal)',
  );
  // Required validator self-check
  assert.ok(
    phase8.includes('plan-validator.mjs --strict'),
    'Phase 8 should mandate post-write `plan-validator.mjs --strict` self-check',
  );
  // Forbidden-headings list (literal "FORBIDDEN" appears more than once: in regex const + in human-readable list)
  assert.ok(
    /FORBIDDEN/.test(phase8),
    'Phase 8 should explicitly enumerate FORBIDDEN headings',
  );
});

// --- v5.0.0 / v5.0.1 — bespoke playground removed; /playground invocation explicit ---
//
// v5.0.0 removed the bespoke playground SPA, /trekrevise, and Handover 8.
// v5.0.1 dropped the v5.0.0 stop-gap (scripts/render-artifact.mjs) and made
// the producing commands print a literal, copy-paste-ready /playground
// document-critique invocation instead. These pins lock both removals in
// AND pin the new copy-paste invocation as the operator-facing contract.

import { existsSync } from 'node:fs';

test('playground/ directory no longer exists (removed in v5.0.0)', () => {
  assert.ok(
    !existsSync(join(ROOT, 'playground')),
    'plugins/voyage/playground/ should be deleted — the bespoke playground was retired in v5.0.0',
  );
});

test('commands/trekrevise.md no longer exists (removed in v5.0.0)', () => {
  assert.ok(
    !existsSync(join(ROOT, 'commands/trekrevise.md')),
    '/trekrevise was removed in v5.0.0 — its command file should be gone',
  );
});

test('Handover 8 deleted from HANDOVER-CONTRACTS.md (back to seven handovers)', () => {
  const text = read('docs/HANDOVER-CONTRACTS.md');
  assert.ok(!text.includes('## Handover 8'), 'Handover 8 section should be removed in v5.0.0');
  assert.ok(text.includes('## Handover 7'), 'Handover 7 must remain');
});

test('scripts/render-artifact.mjs is still removed (v5.0.1 + v5.0.2)', () => {
  assert.ok(
    !existsSync(join(ROOT, 'scripts/render-artifact.mjs')),
    'scripts/render-artifact.mjs should be deleted — v5.0.1 dropped the standalone HTML render; v5.0.2 kept it removed (annotate.mjs is the replacement)',
  );
});

test('scripts/annotate.mjs exists (v5.0.2 operator-annotation HTML generator)', () => {
  assert.ok(
    existsSync(join(ROOT, 'scripts/annotate.mjs')),
    'scripts/annotate.mjs is required — producing commands call it to build the operator-annotation HTML',
  );
});

test('producing commands reference scripts/annotate.mjs (v5.0.2 render-and-link step)', () => {
  // v5.0.0 → v5.0.1 → v5.0.2 chain: v5.0.0 added an HTML render that didn't
  // afford annotation; v5.0.1 pointed at /playground document-critique (which
  // pre-generates Claude's suggestions, not operator-driven annotation); v5.0.2
  // ships scripts/annotate.mjs — an operator-driven annotation surface where
  // the OPERATOR clicks lines and writes their own notes. Pin the wiring.
  for (const f of ['trekbrief.md', 'trekplan.md', 'trekreview.md']) {
    assert.ok(
      read(`commands/${f}`).includes('scripts/annotate.mjs'),
      `commands/${f} must invoke scripts/annotate.mjs to build the operator-annotation HTML (v5.0.2)`,
    );
  }
});

test('producing commands no longer print the v5.0.1 /playground document-critique line', () => {
  // v5.0.1 told operators to copy-paste "/playground build a document-critique
  // playground for X" — but that flow pre-generates Claude's suggestions. The
  // operator asked for their own annotations, not a critique of Claude's.
  // v5.0.2 removes that line from the producing commands' final report.
  for (const f of ['trekbrief.md', 'trekplan.md', 'trekreview.md']) {
    assert.ok(
      !read(`commands/${f}`).includes('/playground build a document-critique'),
      `commands/${f} must not print the v5.0.1 /playground document-critique invocation — v5.0.2 replaces it with annotate.mjs`,
    );
  }
});

test('producing commands tell the operator the flow is THEIR own annotations', () => {
  // Pin language: every producing command's prose must mention that the
  // OPERATOR drives annotation, not Claude. Phrase variants are allowed
  // ("YOUR OWN note", "operator drives", etc.) — we look for the operator-
  // ownership signal.
  for (const f of ['trekbrief.md', 'trekplan.md', 'trekreview.md']) {
    const text = read(`commands/${f}`);
    assert.ok(
      /YOUR OWN|operator drives|your own/i.test(text),
      `commands/${f} must signal that the operator drives annotation (v5.0.2 contract)`,
    );
  }
});

test('producing commands emit file:// link in final report (operator-UX contract, 2026-05-13)', () => {
  // Operator runs Ghostty / iTerm2 / modern Terminal.app — all support cmd+click
  // on file:// URLs. Producing commands MUST emit both forms: (a) plain file://
  // line in the report block, (b) `open file://...` copy-pasteable command.
  // Both must reference $ANNOT_HTML (absolute path from scripts/annotate.mjs).
  for (const f of ['trekbrief.md', 'trekplan.md', 'trekreview.md']) {
    const text = read(`commands/${f}`);
    assert.ok(
      /file:\/\/\{\$ANNOT_HTML\}/.test(text),
      `commands/${f} must include "file://{$ANNOT_HTML}" plain URL in the final report block`,
    );
    assert.ok(
      /open file:\/\/\{\$ANNOT_HTML\}/.test(text),
      `commands/${f} must include "open file://{$ANNOT_HTML}" copy-pasteable command in the final report block`,
    );
  }
});

test('package.json is marked private — the npm name `voyage` belongs to a third party', () => {
  // D-census 2026-08-20/21: registry.npmjs.org/voyage answers 200, but that is
  // NOT this package — it is "Advanced HTTP Routing System for Node.js"
  // (NEURS/voyage, v0.0.1, 2022, maintainer kevin.martin). This manifest is test
  // tooling for a Claude Code plugin distributed through the marketplace catalogue
  // (`ref: vX.Y.Z`), never through npm. Without `private`, nothing in the manifest
  // stops an accidental `npm publish` against a name someone else owns — a one-way
  // action. Sibling non-package manifests (okr, repo-mailbox, repo-standard) all
  // carry the flag; voyage was the exception. Operator decision (S93): option A.
  const pkg = JSON.parse(read('package.json'));
  assert.equal(
    pkg.private,
    true,
    'package.json must declare "private": true — the npm name `voyage` is owned by a third party',
  );
});

test('package.json still has no "npm run render" script (removed in v5.0.1)', () => {
  const pkg = JSON.parse(read('package.json'));
  assert.equal(
    pkg.scripts && pkg.scripts.render,
    undefined,
    'package.json scripts.render should remain gone',
  );
});

test('CHANGELOG.md has v5.0.0 entry', () => {
  const cl = read('CHANGELOG.md');
  assert.match(cl, /## v5\.0\.0\b/, 'CHANGELOG.md must include "## v5.0.0" entry');
});

test('CHANGELOG.md has v5.0.1 entry', () => {
  const cl = read('CHANGELOG.md');
  assert.match(cl, /## v5\.0\.1\b/, 'CHANGELOG.md must include "## v5.0.1" entry');
});

test('CHANGELOG.md has v5.0.2 entry', () => {
  const cl = read('CHANGELOG.md');
  assert.match(cl, /## v5\.0\.2\b/, 'CHANGELOG.md must include "## v5.0.2" entry');
});

test('CHANGELOG.md retains v4.2.0 entry (history is not rewritten)', () => {
  const cl = read('CHANGELOG.md');
  assert.match(cl, /## v4\.2\.0\b/, 'CHANGELOG.md must keep the historical "## v4.2.0" entry');
});

test('CHANGELOG.md has v5.5.0 entry (S13 coordinated release)', () => {
  const cl = read('CHANGELOG.md');
  assert.match(cl, /## v5\.5\.0\b/, 'CHANGELOG.md must include "## v5.5.0" entry — the coordinated release that lands brief_version 2.2 + NW1–NW3');
});

test('version is consistent across plugin.json, package.json, README badge, and CHANGELOG top entry', () => {
  // versjonssync invariant (CLAUDE.md rule): every file that names the plugin
  // version must agree. Bumping one without the others is a release defect.
  const pluginVersion = JSON.parse(read('.claude-plugin/plugin.json')).version;
  const pkgVersion = JSON.parse(read('package.json')).version;
  const badgeVersion = (read('README.md').match(/badge\/version-([\d.]+)-/) || [])[1];
  const changelogTop = (read('CHANGELOG.md').match(/## v(\d+\.\d+\.\d+)\b/) || [])[1];
  assert.ok(pluginVersion, 'plugin.json missing version');
  assert.equal(pkgVersion, pluginVersion, `package.json version ${pkgVersion} != plugin.json ${pluginVersion}`);
  assert.equal(badgeVersion, pluginVersion, `README badge ${badgeVersion} != plugin.json ${pluginVersion}`);
  assert.equal(changelogTop, pluginVersion, `CHANGELOG top entry v${changelogTop} != plugin.json ${pluginVersion}`);
});

test('operational files no longer reference trekrevise (v5.0.0 removal)', () => {
  // Templates, the touched command files, and the
  // handover-contracts doc must be fully scrubbed. CLAUDE.md / README.md are
  // intentionally allowed to mention /trekrevise in their "removed in v5.0.0"
  // prose — those are historical notes, not live references.
  const targets = [
    'docs/HANDOVER-CONTRACTS.md',
    'templates/plan-template.md', 'templates/trekbrief-template.md', 'templates/trekreview-template.md',
    'commands/trekplan.md', 'commands/trekbrief.md', 'commands/trekreview.md',
  ];
  for (const t of targets) {
    assert.ok(
      !read(t).includes('trekrevise'),
      `${t} still references trekrevise — it was removed in v5.0.0`,
    );
  }
});

// --- v5.5 — brief_version 2.2 ---

test('v5.5 — templates/trekbrief-template.md declares brief_version: "2.2" (quoted)', () => {
  const t = read('templates/trekbrief-template.md');
  assert.match(t, /^brief_version: "2\.2"$/m,
    'trekbrief-template.md must declare brief_version: "2.2" (quoted) — unquoted parses as Number and bypasses the version gate; v5.5 bumped 2.1→2.2 for framing enforcement');
});

// --- v5.4 — brief.md formalized as PUBLIC CONTRACT (Handover 1) ---
// S5: the brief schema is the only public producer↔Voyage integration boundary
// (Trinity asymmetry invariant). These pin the formalization as enforced doc-truth,
// not prose — same pattern as the v5.1 Handover-1 pins above. Freeze, not promote:
// brief_version 2.1 is the frozen baseline (S3 decision).

test('v5.4 — HANDOVER-CONTRACTS.md Handover 1 heading is labeled (PUBLIC CONTRACT)', () => {
  const t = read('docs/HANDOVER-CONTRACTS.md');
  assert.match(t, /^## Handover 1 —.*\(PUBLIC CONTRACT\)\s*$/m,
    'Handover 1 heading must carry the (PUBLIC CONTRACT) label — symmetric with Handover 3 (EXTERNAL CONTRACT)');
});

test('v5.4 — Handover 1 declares the PUBLIC CONTRACT callout + breaking-for-downstream guarantee', () => {
  const t = read('docs/HANDOVER-CONTRACTS.md');
  assert.ok(t.includes('Stability tier: PUBLIC CONTRACT'),
    'Handover 1 must open with a "Stability tier: PUBLIC CONTRACT" callout');
  assert.ok(t.includes('breaking change for every downstream consumer'),
    'the callout must state that a brief-schema change is a breaking change for every downstream consumer');
});

test('v5.5 — brief_version 2.2 is current in the public-contract schema table (no stale 2.0/2.1)', () => {
  const t = read('docs/HANDOVER-CONTRACTS.md');
  assert.ok(!t.includes('`"2.0"` (current)'),
    'Handover 1 schema table must not still mark brief_version "2.0" as current (stale)');
  assert.ok(!t.includes('`"2.1"` (current)'),
    'Handover 1 schema table must not still mark brief_version "2.1" as current (stale — v5.5 bumped to 2.2)');
  assert.ok(t.includes('`"2.2"` (current)'),
    'Handover 1 schema table must mark brief_version "2.2" as current');
});

test('v5.5 — the Versioning note cites no phantom v5.4 and records the 2.1 baseline', () => {
  const t = read('docs/HANDOVER-CONTRACTS.md');
  assert.ok(!/v5\.4/.test(t),
    'the contract doc must not cite the phantom v5.4 release (v5.2–5.4 never shipped; S16 → v5.5.0)');
  assert.ok(t.includes('established `2.1` as the public-contract baseline'),
    'the Versioning note must record the v5.5.0 contract formalization establishing 2.1 as the baseline');
});

// --- v5.5 — framing enforcement: brief_version 2.2 (Handover 1 contract evolution) ---
// S6: the framing-alignment invariant (CLAUDE.md) ships as a controlled brief_version
// bump 2.1→2.2 adding two required-at-2.2 elements (framing field + ## TL;DR section),
// version-gated so 2.0/2.1 briefs stay valid. These pin the contract-doc evolution.

test('v5.5 — Handover 1 schema table adds the framing field row', () => {
  const t = read('docs/HANDOVER-CONTRACTS.md');
  assert.ok(t.includes('| `framing` |'),
    'HANDOVER-CONTRACTS must add a framing row to the Handover 1 schema table');
  assert.ok(t.includes('preserve \\| refine \\| replace \\| new-direction'),
    'the framing row must list the four canonical enum values');
});

test('v5.5 — Handover 1 documents the framing gate + required-at-2.2 TL;DR section', () => {
  const t = read('docs/HANDOVER-CONTRACTS.md');
  assert.ok(t.includes('v5.5 framing gate'),
    'validation-strategy table must add a v5.5 framing gate row');
  assert.ok(/##\s*TL;DR.*required at `brief_version ≥ 2\.2`/.test(t) || t.includes('`## TL;DR` — **required at `brief_version ≥ 2.2`**'),
    'body-invariants must mark ## TL;DR as required at brief_version ≥ 2.2');
});

test('v5.5 — Versioning note records the 2.2 framing-enforcement evolution', () => {
  const t = read('docs/HANDOVER-CONTRACTS.md');
  assert.ok(t.includes('v5.5 → `2.2` (framing enforcement)'),
    'the Versioning note must document the v5.5 → 2.2 framing-enforcement evolution');
});

test('v5.5 — voyage README.md mentions framing enforcement / brief_version 2.2', () => {
  const t = read('README.md');
  assert.ok(t.includes('framing') && t.includes('brief_version 2.2'),
    'voyage README.md must carry a "What\'s new" note for framing enforcement (brief_version 2.2)');
});

test('S15: README cost prose does not resurrect the false Sonnet-swarm claim', () => {
  // All 24 sub-agents are model: opus (operator-pinned, commit 40d8742) and the
  // model is uniform per phase — there is no "Opus orchestrates / Sonnet runs
  // the swarms" split. These phrases asserted the false split and must stay out.
  const md = read('README.md');
  const BANNED = [
    'Sonnet exploration',
    'Sonnet runs the exploration',
    'front-loads cheap Sonnet',
    'exploration agents stay on Sonnet',
  ];
  for (const phrase of BANNED) {
    assert.ok(
      !md.includes(phrase),
      `README.md must not claim "${phrase}" — sub-agents are opus-pinned`,
    );
  }
});

// ── S18: framing-hardening cross-file invariants ───────────────────────────

test('S18: --min-brief-version is documented at the trekplan + trekresearch boundary', () => {
  // The opt-in version floor must be discoverable wherever flags live: both
  // consuming commands and the central flag reference.
  for (const f of ['commands/trekplan.md', 'commands/trekresearch.md', 'docs/command-modes.md']) {
    assert.ok(
      read(f).includes('--min-brief-version'),
      `${f} must document the --min-brief-version flag (S18 framing-hardening)`,
    );
  }
});

test('README research-dimension prose stays at the existing 3–8 ceiling', () => {
  // /trekresearch Phase 2 determines 3-8 research dimensions; the README must not raise it.
  assert.ok(
    read('README.md').includes('3–8 research dimensions'),
    'README.md must keep the "3–8 research dimensions" prose — it matches the Phase 2 ceiling, it does not raise it',
  );
});

test('no banned Sonnet-swarm phrase on the reference surfaces', () => {
  const BANNED = [
    'Sonnet exploration',
    'Sonnet runs the exploration',
    'front-loads cheap Sonnet',
    'exploration agents stay on Sonnet',
  ];
  for (const f of ['docs/command-modes.md', 'CLAUDE.md', 'README.md', 'docs/architecture.md']) {
    const t = read(f);
    for (const phrase of BANNED) {
      assert.ok(!t.includes(phrase), `${f} must not claim "${phrase}" — sub-agents are opus-pinned`);
    }
  }
});

test('S18: HANDOVER-CONTRACTS documents the pre-2.2 zero-framing-enforcement hole', () => {
  // The framing defense is producer-elective: a brief declaring ≤ 2.1 sidesteps
  // it entirely. Handover 1 (PUBLIC CONTRACT) must disclose this and name the remedy.
  const h = read('docs/HANDOVER-CONTRACTS.md');
  assert.ok(
    /BRIEF_VERSION_BELOW_MINIMUM/.test(h),
    'HANDOVER-CONTRACTS.md must name the BRIEF_VERSION_BELOW_MINIMUM gate as the pre-2.2 remedy',
  );
  assert.ok(
    /zero framing enforcement|no framing enforcement|sidestep/i.test(h),
    'HANDOVER-CONTRACTS.md must state that pre-2.2 briefs receive zero framing enforcement',
  );
});

// ── S32 — "delegate the engine, keep the policy": native-delegation hygiene ──
//
// Balance-analysis V01 / V07 / V08 / V11 / V24 audit (2026-06-20): the brief
// interview and the research / exploration / reviewer swarms must ride NATIVE
// Claude Code primitives — parallel `Agent` spawn in a single message +
// `AskUserQuestion` for interviews — and re-implement no scheduler /
// concurrency-loop / menu engine of their own. The audit found all five ALREADY
// native (no code change), so these pins are the standing guard against an
// engine creeping back in, plus the documented principle in docs/architecture.md.
// Fix the SOURCE (command prose / the architecture.md note), not the test.

const SWARM_COMMANDS = ['commands/trekresearch.md', 'commands/trekplan.md', 'commands/trekreview.md'];

test('S32: docs/architecture.md records the "delegate the engine, keep the policy" principle', () => {
  const t = read('docs/architecture.md');
  assert.ok(
    /delegate the engine, keep the policy/i.test(t),
    'docs/architecture.md must name the "delegate the engine, keep the policy" principle (V01/V07/V08/V11/V24 audit, S32)',
  );
  // The note must name the native primitives it delegates to (so the principle is
  // anchored to real CC tools, not abstract prose).
  assert.ok(
    /AskUserQuestion/.test(t) && /\bAgent\b/.test(t),
    'the principle note must name the native primitives delegated to (Agent + AskUserQuestion)',
  );
});

test('S32: each swarm command lists the Agent tool and mandates native parallel single-message spawn', () => {
  for (const f of SWARM_COMMANDS) {
    const text = read(f);
    assert.ok(
      /^allowed-tools:.*\bAgent\b/m.test(text),
      `${f}: allowed-tools frontmatter must list Agent (the native swarm-spawn engine)`,
    );
    assert.ok(
      /in parallel/i.test(text),
      `${f}: must instruct parallel swarm spawn (native delegation, not a hand-rolled scheduler)`,
    );
    assert.ok(
      /single (assistant )?message|one message|multiple tool calls/i.test(text),
      `${f}: must mandate single-message multi-tool-call dispatch (the native parallel-Agent pattern)`,
    );
  }
});

test('S32: trekbrief Phase 3 delegates Q&A turn-taking to AskUserQuestion (V01 — selection rule is policy, asking is native)', () => {
  const text = read('commands/trekbrief.md');
  assert.ok(
    /^allowed-tools:.*AskUserQuestion/m.test(text),
    'commands/trekbrief.md: allowed-tools must list AskUserQuestion (the native Q&A engine)',
  );
  const p3Start = text.indexOf('## Phase 3 — Completeness loop');
  assert.ok(p3Start >= 0, 'trekbrief.md must have a "## Phase 3 — Completeness loop" section');
  const p3End = text.indexOf('## Phase 4', p3Start);
  const p3 = text.slice(p3Start, p3End > p3Start ? p3End : undefined);
  assert.ok(
    /Use `AskUserQuestion` for every question/.test(p3),
    'Phase 3 must delegate Q&A turn-taking to AskUserQuestion — the selection rule picks WHICH ' +
      'question to ask (policy); AskUserQuestion does the asking (engine). No hand-rolled menu loop.',
  );
});

// ── S38 — fan-out hedge harmonization + relief-assertion forward-guard (SC d) ──
//
// The brief's SC(d) premise — an unhedged "fan-out relieves main context" string
// present in ~23 files awaiting a removal diff — is factually false: plan-time
// enumeration shows the unhedged set is ∅. Every live relief mention is already
// hedged (the sole one is CLAUDE.md:5, hedged since S18), and the
// T2 bake-off record's "frees the main context" lines were a DIFFERENT, true
// background-execution claim (must NOT be touched). SC(d) therefore ships as:
//   (1) one surgical harmonization at CLAUDE.md:5 making the replacement phrase
//       "parallel wall-clock" grep-positive (the Δ≈0 / "not yet demonstrated"
//       qualifier kept intact), and
//   (2) this durable forward-guard — a PRECISE relief-assertion matcher (verb-of-
//       relief + main-context, NOT a bare "main context" grep that would false-fail
//       benign locatives like "runs inline in main context") scoped to product-
//       facing docs, requiring an adjacent hedge token on any match.
// Fix the SOURCE prose (add the hedge / drop the claim), never this test.

test('S38: CLAUDE.md carries the harmonized fan-out phrase "parallel wall-clock" (SC d)', () => {
  assert.ok(
    read('CLAUDE.md').includes('parallel wall-clock'),
    'CLAUDE.md:5 must state the replacement phrase "parallel wall-clock + structured artifact handoffs" (SC d harmonization)',
  );
});

test('S38: forward-guard — no product-facing doc asserts main-context relief unhedged (SC d)', () => {
  // Banned form: a verb of relief adjacent to "main context" (or "main-context …
  // relief"), NOT a plain locative ("runs in main context"). Decision/research
  // records (docs/*) are append-only history and out of scope by design.
  const RELIEF = /(relieve|relieves|relieving|free|frees|offload|offloads)\b[^.\n]{0,40}\bmain[-\s]context\b|\bmain[-\s]context\b[^.\n]{0,20}\brelief\b|swarm\s+relieves\s+context/i;
  const HEDGE = /Δ|not measured|asserted-by-design|not yet demonstrated|not demonstrated/i;
  const productFacing = ['README.md', 'CLAUDE.md', ...listMd('commands').map((f) => `commands/${f}`)];
  const offenders = [];
  for (const rel of productFacing) {
    read(rel).split('\n').forEach((ln, i) => {
      if (RELIEF.test(ln) && !HEDGE.test(ln)) offenders.push(`${rel}:${i + 1}  ${ln.trim().slice(0, 100)}`);
    });
  }
  assert.equal(
    offenders.length,
    0,
    'Unhedged main-context-relief assertion(s) in product-facing docs — add an adjacent hedge ' +
      '(Δ / "not measured" / "asserted-by-design" / "not yet demonstrated") or drop the claim:\n' +
      offenders.join('\n'),
  );
});

// ── v5.9 (fable-tier step 7) — orchestrator model-pin ABSENCE pin ───────────
// Command frontmatter deliberately omits `model:` — omission is the only
// session-inheritance spelling documented by BOTH official surfaces (AP2-2:
// the `inherit` literal is disputed between skills.md and the plugin-dev
// command-frontmatter reference). Re-adding a pin locks the orchestrator to a
// fixed model in every session; if deterministic pinning is ever wanted again,
// do it consciously and update this pin's rationale.

// ── S85 — every spawn site must forbid the Agent tool's `name` parameter ────
// MEASURED 2026-08-17 (this repo, session c37b89f7), after akashic-intelligence
// lost a whole Phase 9 to it. Passing `name` does not rename a subagent — it
// changes its kind: the meta record flips from a real subagent
// (`spawnDepth: 1`) to `taskKind: "in_process_teammate"` (`spawnDepth: 0`).
// A teammate's final assistant text is NOT a return value; it reaches the
// parent only if the teammate itself calls SendMessage(to: "main").
// voyage's reviewers declare `tools: ["Read","Glob","Grep"]` — no SendMessage —
// so as teammates they are STRUCTURALLY incapable of returning, whatever the
// prompt says. Denominators: named 0/5 returned, named-with-explicit-
// SendMessage 1/1, unnamed 3/3 (plan-critic + scope-guardian both returned
// full findings + JSON block in ~110s). Full measurement:
// docs/agent-return-channel-defect.md.
//
// The derived set is asserted exactly, so the pin cannot go vacuous if a
// command stops spawning or a new spawning command is added.

// Wave 1 (P8): /trekexecute joined the set - one fresh step helper per plan step
// plus one controller - so the no-name rule now covers five commands.
const SPAWNING_COMMANDS = ['trekbrief', 'trekexecute', 'trekplan', 'trekresearch', 'trekreview'];

test('S85: the set of agent-spawning commands is exactly the five that carry the no-name rule', () => {
  const spawns = listMd('commands')
    .filter((f) => /^Launch\b/m.test(read(`commands/${f}`)))
    .map((f) => f.replace(/\.md$/, ''))
    .sort();
  assert.deepEqual(spawns, [...SPAWNING_COMMANDS].sort(),
    'a command started or stopped spawning agents — add/remove it from SPAWNING_COMMANDS and give it the no-name rule');
});

for (const cmd of SPAWNING_COMMANDS) {
  test(`S85: commands/${cmd}.md forbids the Agent tool's name parameter at its spawn sites`, () => {
    const text = read(`commands/${cmd}.md`);
    assert.ok(
      text.includes('in_process_teammate'),
      `commands/${cmd}.md must name the mechanism (in_process_teammate) so the rule is not mistaken for style`,
    );
    assert.ok(
      /never pass .*`name`/i.test(text),
      `commands/${cmd}.md must state that the Agent tool's \`name\` parameter is never passed — a named agent completes its work but its result never reaches the orchestrator`,
    );
  });
}

test('v5.9: no commands/*.md frontmatter carries a model: key (session inheritance by omission)', () => {
  const offenders = [];
  for (const f of listMd('commands')) {
    const doc = parseDocument(read(`commands/${f}`));
    const fm = doc.parsed && doc.parsed.frontmatter;
    if (fm && 'model' in fm) offenders.push(f);
  }
  assert.deepEqual(offenders, [],
    `command frontmatter must omit model: (orchestrator follows the session model); offenders: ${offenders.join(', ')}`);
});

// --- S95 (③): gemini-bridge is DROPPED from the pipeline (operator directive) ---
//
// Operator directive, three repetitions: gemini-mcp and voyage:gemini-bridge are
// never to be used. The drop is permanent, not a wait-for-upgrade — so the pin is
// on the LIVE pipeline surfaces only. Historical records (CHANGELOG entries,
// measurement/decision docs) must KEEP their references: they say what a past
// version did or what was measured then, and rewriting them is the same defect
// class as bumping a version string inside a measurement doc.
//
// BLIND SPOT, stated rather than hidden: THIS file cannot be in the live-surface
// list, because the S95 block below is necessarily full of the word.

// Live = anything that can still steer a run. Explicit, so a new file forces a decision.
const GEMINI_LIVE_SURFACES = [
  'README.md',
  'CLAUDE.md',
  'docs/architecture.md',
  'docs/command-modes.md',
  'templates/research-brief-template.md',
  'templates/trekbrief-template.md',
  ...listMd('commands').map((f) => `commands/${f}`),
  ...listMd('agents').map((f) => `agents/${f}`),
];

// Historical/measurement records that MUST keep their gemini references.
const GEMINI_HISTORICAL = [
  'CHANGELOG.md',
  'examples/02-real-cli/REGENERATED.md',
];

test('S95: agents/gemini-bridge.md is removed from the agent inventory', () => {
  assert.ok(
    !listMd('agents').includes('gemini-bridge.md'),
    'gemini-bridge is dropped by operator directive — agents/gemini-bridge.md must not exist',
  );
});

test('S95: no live pipeline surface still names the gemini-bridge agent', () => {
  const offenders = [];
  for (const rel of GEMINI_LIVE_SURFACES) {
    const hits = read(rel).match(/gemini[\w-]*/gi) || [];
    if (hits.length) offenders.push(`${rel} (${[...new Set(hits)].join(', ')})`);
  }
  assert.deepEqual(
    offenders, [],
    `gemini-bridge is dropped — these live surfaces still reference it: ${offenders.join(' · ')}`,
  );
});

test('S95: known-positive control — the historical records still DO carry gemini references', () => {
  // Verifiseringsloven ansikt 4: a scanner that finds nothing anywhere proves
  // nothing. This pins that the same query CAN find, so the empty result above
  // is a measurement and not a broken query.
  const silent = GEMINI_HISTORICAL.filter((rel) => !/gemini/i.test(read(rel)));
  assert.deepEqual(
    silent, [],
    `these historical records lost their gemini references — history must not be rewritten: ${silent.join(', ')}`,
  );
});

// End-state defect D-07: since v5.9.0 no command pins `model:`, so the orchestrator follows
// the session model; a Voyage agent's spawn passes no model (its own `model: opus` applies)
// and a built-in agent's spawn passes `model: "opus"`. No user-facing doc may claim
// otherwise. Fix the SOURCE.
test('D-07: no doc claims an opus orchestrator or ships a recipe for model: lines no command has', () => {
  const readme = read('README.md');
  assert.ok(
    !/\^model: opus\$/.test(readme),
    'README.md must not ship a sed recipe for `model: opus` frontmatter lines — 0 of 7 command files have one',
  );
  assert.ok(
    !/default for `\/trekbrief`[\s\S]{0,80}?is `opus`/.test(readme),
    'README.md must not claim the command orchestrators default to opus — they follow the session model',
  );
  for (const f of ['README.md', 'CLAUDE.md', 'commands/trekresearch.md']) {
    assert.ok(!/orchestrator runs on Opus/i.test(read(f)), `${f}: the orchestrator follows the session model`);
  }
});

test('D-07: trekresearch launch rules leave a Voyage agent on its own pin, with no blanket opus rule', () => {
  const t = read('commands/trekresearch.md');
  const rules = (t.split('\n### Launch rules\n')[1] || '').split('\n## ')[0];
  assert.ok(rules.length > 0, 'trekresearch.md must still carry the Launch rules sub-section');
  assert.ok(
    !/model: "opus" for all sub-agents/i.test(rules),
    'a blanket opus rule contradicts the file\'s own rule: a Voyage agent keeps its own pin, only a built-in agent gets opus',
  );
  const flatRules = rules.replace(/\s+/g, ' ');
  assert.ok(flatRules.includes("Pass no model at a Voyage agent's spawn: the agent's own frontmatter `model: opus` applies."),
    'the launch rules must say a Voyage agent\'s spawn passes no model');
  assert.ok(t.replace(/\s+/g, ' ').includes('Spawn it with `model: "opus"`: a built-in agent has no Voyage pin.'),
    'a built-in follow-up agent is spawned with model opus');
});

// End-state defect D-03: a trekplan's `## Verification` is where the brief's success
// criteria land. Phase 7 used to say "Skip for trekplans", so on the single-session path
// the criteria were never run and `completed` meant "the executor believed it". The
// behaviour lives in lib/verification/criteria-runner.mjs; this pin guards the WIRING —
// a capability no phase calls is the same defect wearing a lib/ file. Fix the SOURCE.
test('D-03: trekexecute Phase 7 runs the plan Verification on the single-session path', () => {
  const t = read('commands/trekexecute.md');
  const phase7 = (t.split('\n## Phase 7 — ')[1] || '').split('\n## ')[0];
  assert.ok(phase7.length > 0, 'trekexecute.md must still carry a Phase 7 section');
  assert.ok(
    !/^\*\*Skip for trekplans\.\*\*/m.test(phase7),
    'Phase 7 may no longer skip trekplans — that skip IS defect D-03',
  );
  assert.match(
    phase7, /criteria-runner\.mjs" --plan/,
    'Phase 7 must invoke the criteria runner over the plan file, not describe the check in prose',
  );
  assert.match(
    phase7, /MUST NOT emit `result: completed`/,
    'a failing criterion must fell the run, not be noted in the final report',
  );
});

// End-state defect D-04: the rubric required brief-conformance-reviewer to decide whether a
// Success Criterion's verification command "exists and passes" — with Read/Glob/Grep. The
// command now runs the commands and hands over the result; the reviewer stays read-only.
// Fix the SOURCE.
// Re-measured 2026-09-18, minor: /trekreview passed --cwd and Phase 7 did not,
// so the same criterion could resolve two ways in the two phases. It is no longer
// cosmetic - --cwd is where every allowlisted command is executed and where a
// `bash tests/<script>.sh` criterion resolves, so an unset one silently moves
// the ground the criteria are measured on to the process cwd.
test('both phases pin the criteria runner to the working tree with --cwd', () => {
  const phase7 = (read('commands/trekexecute.md').split('\n## Phase 7 — ')[1] || '').split('\n## ')[0];
  const phase45 = (read('commands/trekreview.md').split('\n## Phase 4.5 — ')[1] || '').split('\n## ')[0];
  for (const [label, phase] of [['trekexecute Phase 7', phase7], ['trekreview Phase 4.5', phase45]]) {
    assert.ok(phase.length > 0, `${label} must still exist`);
    assert.match(phase, /--cwd "\$CRITERIA_CWD"/, `${label} must pass --cwd, and the same resolved value`);
    assert.match(
      phase, /CRITERIA_CWD="\$\(git rev-parse --show-toplevel 2>\/dev\/null \|\| pwd\)"/,
      `${label} must resolve the working tree with a fallback — an empty --cwd is a moved boundary, not an error`,
    );
  }
});

test('D-04: the conformance reviewer judges a supplied result, and never runs a command', () => {
  const a = read('agents/brief-conformance-reviewer.md');
  assert.ok(
    !/exists and passes/.test(a),
    'the rubric may no longer ask a Read/Glob/Grep agent whether a command passes — that ask IS defect D-04',
  );
  assert.match(a, /^tools: \["Read", "Glob", "Grep"\]$/m, 'the reviewer stays read-only: no Bash');
  assert.match(a, /You never run a command/, 'the reviewer must be told in-band that it does not execute');
  assert.match(a, /Success-criteria check results/, 'the reviewer must document the supplied evidence as an input');
});

// Follow-up to D-04 (re-measured 2026-09-18): the runner now reports a criterion
// whose sentence named a flag or a path as NOT RUN with reason `not-a-command`,
// instead of running it and reporting exit 2 / exit 126. The rubric must not turn
// that absent measurement into a finding of its own - it judges delivered code.
test('D-04b: a NOT RUN check result is never, on its own, a defect in the rubric', () => {
  const a = read('agents/brief-conformance-reviewer.md');
  assert.ok(
    !/NOT RUN` because the criterion declares no command/.test(a),
    'a criterion that declares no runnable command may no longer read as an incomplete verification path',
  );
  assert.match(
    a, /A `NOT RUN` result is never on its own a finding/,
    'the rubric must say in-band that an absent measurement is not a defect',
  );
  assert.match(
    a, /not-a-command/,
    'the reviewer must be told the reason string the runner emits for a sentence that named a flag or a path',
  );
});

test('D-04: trekreview runs the success-criteria commands and hands the reviewer the result', () => {
  const t = read('commands/trekreview.md');
  const phase = (t.split("\n## Phase 4.5 — ")[1] || '').split('\n## ')[0];
  assert.ok(phase.length > 0, 'trekreview.md must carry the phase that runs the success-criteria checks');
  assert.match(phase, /criteria-runner\.mjs" \\\n  --brief .* --evidence/, 'the phase must invoke the runner in --evidence mode');
  assert.match(phase, /sc_evidence_block/, 'the phase must name the captured block the reviewer prompt carries');
  assert.match(
    t.split('\n## Phase 5 — ')[1] || '', /sc_evidence_block/,
    'the reviewer-launch phase must hand the block over — a block nobody passes is not evidence',
  );
});

// Re-measured 2026-09-18: the plan's `## Verification` section
// is the one artifact BOTH /trekplan (writer) and lib/verification/criteria-runner.mjs
// (reader) touch, and nothing pinned them to the same format. Measured: nine
// ordinary shapes of that section parsed to zero criteria, which fells the
// single-session run. The writer must pin the heading string and the two forms
// the reader reads. Fix the SOURCE: if the runner learns a new form, say so here.
test('trekplan pins the ## Verification heading and a format the criteria runner reads', () => {
  const t = read('commands/trekplan.md');
  const section = (t.split('8. **Verification**')[1] || '').split('\n9. ')[0];
  assert.ok(section.length > 0, 'trekplan.md must still carry the Verification instruction');
  assert.match(
    section, /exactly `## Verification`/,
    'the heading string is load-bearing: `## Verification (acceptance)` and `### Verification` parse to nothing',
  );
  assert.match(
    section, /criteria runner|criteria-runner/,
    'the instruction must name the reader it is writing for',
  );
  assert.match(
    section, /- \[ \] `/,
    'the bullet form the runner reads must be shown, not described',
  );
  assert.match(section, /```bash/, 'the shell-tagged fence form must be shown too');
});

test('trekexecute Phase 7 says NO_CRITERIA out loud instead of failing silently', () => {
  const phase7 = (read('commands/trekexecute.md').split('\n## Phase 7 — ')[1] || '').split('\n## ')[0];
  assert.match(
    phase7, /NO_CRITERIA/,
    'a section the runner could not read must be reported as such, not as a bare exit 1',
  );
  assert.match(
    phase7, /source line|`\{plan_path\}:/,
    'the report must carry the line the unreadable section starts on',
  );
});

// Model-alias facts, verified 2026-10-02 against code.claude.com/docs/en/model-config
// (Anthropic API) and code.claude.com/docs/en/sub-agents: `opus` -> Opus 5.5 and
// `sonnet` -> Sonnet 5.5, both default effort `medium`; `fable` -> Fable 5.1, default
// `high`; a subagent without `effort:` inherits the session level. Live surfaces state
// what is true now; historical records keep what was true when written and are never
// rewritten. When an alias moves again, re-verify against the docs and fix the SOURCE.
const ALIAS_LIVE_SURFACES = [
  'CLAUDE.md', 'README.md', 'docs/architecture.md', 'docs/operations.md',
  ...listMd('commands').map((f) => `commands/${f}`),
  ...listMd('agents').map((f) => `agents/${f}`),
];
const RETIRED_ALIAS_TARGETS = [
  { term: 'Opus 4.8', re: /Opus 4\.8/g },
  { term: 'Sonnet 4.6', re: /Sonnet 4\.6/g },
  { term: 'Fable 5', re: /Fable 5(?!\.\d)/g },
];
// History inside a live surface: an entry must hit EXACTLY its count (a stale one fails).
const ALIAS_HISTORY_EXEMPT = [
  { path: 'docs/operations.md', term: 'Sonnet 4.6', count: 1, reason: 'Path C measurement, closed 2026-05-05 on CC v2.1.128' },
];
const ALIAS_HISTORICAL = ['CHANGELOG.md'];

function aliasHits(rel, re) { return (read(rel).match(re) || []).length; }

test('model aliases: no live surface names a retired alias target as current', () => {
  const offenders = [];
  for (const rel of ALIAS_LIVE_SURFACES) {
    for (const { term, re } of RETIRED_ALIAS_TARGETS) {
      const n = aliasHits(rel, re);
      const ex = ALIAS_HISTORY_EXEMPT.find((e) => e.path === rel && e.term === term);
      const allowed = ex ? ex.count : 0;
      if (n !== allowed) offenders.push(`${rel}: ${term} x${n} (allowed ${allowed})`);
    }
  }
  assert.deepEqual(offenders, [], `retired alias targets on live surfaces: ${offenders.join(' · ')}`);
});

test('model aliases: known-positive control — the same query still finds every retired term in history', () => {
  // Verifiseringsloven ansikt 4: the empty result above is a measurement only if the
  // query CAN find. Every retired term must still hit in a historical record or an
  // exact-count exemption.
  const silent = RETIRED_ALIAS_TARGETS.filter(({ term, re }) =>
    !ALIAS_HISTORICAL.some((rel) => aliasHits(rel, re) > 0)
    && !ALIAS_HISTORY_EXEMPT.some((e) => e.term === term)).map(({ term }) => term);
  assert.deepEqual(silent, [], `no known-positive left for: ${silent.join(', ')}`);
});

test('model aliases: architecture.md states the current targets, defaults and session inheritance', () => {
  const t = read('docs/architecture.md');
  const axes = (t.split('\n## Model & effort\n')[1] || '').split('\n## ')[0];
  assert.ok(axes.length > 0, 'docs/architecture.md must still carry the Model & effort section');
  assert.match(axes, /Opus 5\.5[^\n]*\n?[^\n]*`medium`/, 'opus -> Opus 5.5, default effort `medium`');
  assert.match(axes, /Sonnet 5\.5/, 'sonnet -> Sonnet 5.5');
  assert.match(axes, /Fable 5\.1[\s\S]{0,120}`high`/, 'fable -> Fable 5.1, default effort `high`');
  assert.match(axes, /inherits? the session/i, 'a subagent without `effort:` inherits the session level');
  assert.ok(!/inherit the model default/.test(axes), 'unset `effort:` inherits the session, not the model default');
  assert.ok(!/overrides effort entirely/.test(axes),
    '`MAX_THINKING_TOKENS=0` has no effect on Opus 5.5, Sonnet 5.5 or the Fable models');
  assert.match(axes, /maxEffortLevel/, 'effort is capped by `maxEffortLevel` / an organization cap, not by `availableModels`');
  // README's alias sentence went with its §Cost profile (cleanup R-b).
  for (const f of ['CLAUDE.md']) {
    for (const target of ['Opus 5.5', 'Sonnet 5.5', 'Fable 5.1']) {
      assert.ok(read(f).includes(target), `${f} must name the current alias target ${target}`);
    }
  }
});

// A `## Brief Quality` section belongs to the exhausted and force-stopped
// branches only; the passed-gate branch must not tell the model to write one.
test('trekbrief: the passed-gate branch names no `## Brief Quality`, the exhausted branch still does', () => {
  const text = read('commands/trekbrief.md');
  const passStart = text.indexOf('**If gate passes:**');
  const passEnd = text.indexOf('**If gate fails AND iteration count < the class cap:**');
  assert.ok(passStart >= 0 && passEnd > passStart, 'passed-gate branch markers');
  assert.ok(!text.slice(passStart, passEnd).includes('## Brief Quality'), 'the passed-gate branch names `## Brief Quality`');
  const exStart = text.indexOf('**If gate fails AND iteration count == the class cap (loop exhausted):**');
  const exEnd = text.indexOf('### Step 4f', exStart);
  assert.ok(exStart > passEnd && exEnd > exStart, 'exhausted branch markers');
  assert.ok(text.slice(exStart, exEnd).includes('## Brief Quality'), 'the exhausted branch must still name `## Brief Quality`');
});

// --- effort floor: no live doc claims retrieval agents run at medium ------------
// Operator rule (2026-10-05): no agent is pinned below `high`. The model DEFAULT
// sentence ("Opus 5.5 ... default reasoning effort `medium`") stays true and is not a pin.
const RETRIEVAL_MEDIUM = /retrieval(?: agents)?\s*(?:→|->|at)\s*`medium`/i;

test('effort floor: no live doc claims retrieval agents run at medium', () => {
  const hits = [];
  for (const f of ['docs/architecture.md', 'CLAUDE.md', 'README.md']) {
    read(f).split('\n').forEach((l, i) => { if (RETRIEVAL_MEDIUM.test(l)) hits.push(`${f}:${i + 1}`); });
  }
  assert.deepEqual(hits, [], 'the four retrieval agents pin `high` now');
});

test('effort floor: known-positive control — the query finds the old phrases, not the model default', () => {
  for (const phrase of ['**Retrieval agents → `medium`:**', '(retrieval → `medium`, adversarial', 'retrieval at `medium`, adversarial']) {
    assert.match(phrase, RETRIEVAL_MEDIUM, phrase);
  }
  assert.doesNotMatch('both with default reasoning effort `medium`', RETRIEVAL_MEDIUM);
});

test('effort floor: architecture.md names the four retrieval agents as high', () => {
  const axes = (read('docs/architecture.md').split('\n## Model & effort\n')[1] || '').split('\n## ')[0];
  const bullet = axes.split('\n- ').find((b) => ['task-finder', 'git-historian', 'dependency-tracer', 'architecture-mapper'].every((a) => b.includes(a)));
  assert.ok(bullet, 'one bullet in §Model & effort names all four retrieval agents');
  assert.match(bullet, /`high`/);
  assert.doesNotMatch(bullet, /`medium`/);
});