@pareto4/pp-core 1.20.0 → 1.21.0

package/pp-core/bin/lib/test-substance.cjs

@@ -0,0 +1,3190 @@
+"use strict";
+/**
+ * Test Substance: plan-time analysis of whether a phase's tasks assert behaviour (Phase 38).
+ *
+ * ADR-457 build-at-publish: this TypeScript file is the SOURCE OF TRUTH. It
+ * compiles to the gitignored `pp-core/bin/lib/test-substance.cjs`; do NOT
+ * hand-edit the compiled output.
+ *
+ * `check test-substance <phase>` reads every PLAN.md of a phase and reports, per
+ * task: a missing, empty or generic `<behavior>` (D-01, D-02); an `<automated>`
+ * command that can pass without asserting (D-06); a MISSING marker left as the
+ * verify, which the executor cannot run (D-03); a test file a real command runs that is
+ * not on disk and that no earlier task, earlier-wave plan or the task itself creates
+ * (`orderFinding`, D-03, D-06); and a scaffold whose action describes an empty,
+ * placeholder, todo, skip or tautological test (D-03). Every finding is a blocker
+ * (D-07). With `workflow.nyquist_validation: false` the verb reports `enforced:
+ * false`, keeps the findings listed and does not block (D-08). Tasks that touch a
+ * source file without `tdd="true"` are listed as information and never set `block`
+ * (D-12). It reads plans, and stats (never runs) the test files they run, so it runs
+ * with or without RESEARCH.md (D-05).
+ *
+ * The second half is the test-file scanner (`scanTestFiles`, D-14, D-16): it counts
+ * assertions per test case in JS/TS, Python and Go files and reports the cases that
+ * assert nothing, for validate-phase and the Nyquist auditor.
+ *
+ * The module is static text analysis. It never runs a plan's command or a test
+ * file, and it imports no process-spawning built-in (T-38-05). Every input is
+ * size-capped and every scan is linear: child elements are found with `indexOf`
+ * loops, never a lazy whole-task regex, and commands are split on separators with
+ * no whitespace quantifier around them (T-38-01).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASSERTION_VOCABULARY = exports.JS_NON_CASE_MEMBERS = exports.JS_CASE_PRODUCING_MEMBERS = exports.JS_CASE_MODIFIERS = exports.SCAN_UNKNOWN_REASONS = exports.FILE_STATES = exports.CASE_STATES = exports.MAX_LISTED_CASES = exports.MAX_SCAN_FILES = exports.MAX_SCAN_FILE_BYTES = exports.MAX_QUOTED_CHARS = exports.MAX_COMMAND_CHARS = exports.MAX_PLAN_BYTES = exports.MAX_PLAN_CHARS = exports.ORDER_SKIP_RUNNERS = exports.ORDER_SKIP_VERBS = exports.CWD_OPTIONS = exports.MAX_ORDER_PATHS = exports.TEST_PATH_PATTERNS = exports.TEST_FILE_PATTERNS = exports.SCAFFOLD_NEGATIONS = exports.SCAFFOLD_VACUOUS_PATTERNS = exports.TAUTOLOGY_LITERALS = exports.GENERIC_BEHAVIORS = exports.BEHAVIOR_MIN_WORDS = exports.BEHAVIOR_MIN_CHARS = exports.SCAFFOLD_VACUOUS_KINDS = exports.VACUOUS_COMMAND_KINDS = exports.FINDING_CODES = void 0;
+exports.isTestPath = isTestPath;
+exports.segmentCommand = segmentCommand;
+exports.classifyCommand = classifyCommand;
+exports.checkBehavior = checkBehavior;
+exports.parsePlanTasks = parsePlanTasks;
+exports.isMissingMarker = isMissingMarker;
+exports.commandTestPaths = commandTestPaths;
+exports.analyzeTestSubstance = analyzeTestSubstance;
+exports.readPhaseSubstancePlans = readPhaseSubstancePlans;
+exports.projectPathExists = projectPathExists;
+exports.computeTestSubstance = computeTestSubstance;
+exports.languageOf = languageOf;
+exports.maskJs = maskJs;
+exports.maskPython = maskPython;
+exports.maskGo = maskGo;
+exports.scanTestSource = scanTestSource;
+exports.scanTestFile = scanTestFile;
+exports.scanTestFiles = scanTestFiles;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const coreUtilsMod = require("./core-utils.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const phaseScopeMod = require("./phase-scope.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const taskCommandMod = require("./task-command-router.cjs");
+const security_cjs_1 = require("./security.cjs");
+const { extractCanonicalPlanId } = coreUtilsMod;
+const { resolvePhaseForRead } = phaseScopeMod;
+const { isBehaviorAddingTaskContent } = taskCommandMod;
+// ─── Constants (cited by pp-core/references/test-substance.md) ─────────────────
+exports.FINDING_CODES = ['behavior_missing', 'behavior_generic', 'verify_vacuous',
+    'scaffold_uncreated', 'scaffold_empty', 'over_cap', 'unreadable'];
+exports.VACUOUS_COMMAND_KINDS = ['existence_only', 'grep_test_file', 'or_true',
+    'semicolon_true', 'exit_zero', 'pass_with_no_tests', 'echo_only', 'no_command'];
+exports.SCAFFOLD_VACUOUS_KINDS = ['empty_body', 'placeholder', 'todo', 'skip', 'tautology'];
+exports.BEHAVIOR_MIN_CHARS = 20;
+exports.BEHAVIOR_MIN_WORDS = 4;
+/** Whole-statement denylist, compared with the NORMALISED statement (never as a substring). */
+exports.GENERIC_BEHAVIORS = ['tests pass', 'test passes', 'the tests pass', 'all tests pass',
+    'all the tests pass', 'it works', 'works', 'works as expected', 'it works as expected',
+    'everything works', 'file exists', 'the file exists', 'files exist', 'is implemented',
+    'it is implemented', 'implemented', 'done', 'passes', 'complete', 'build passes',
+    'the build passes'];
+/** Case-sensitive substrings, matched after collapsing whitespace runs to one space. */
+exports.TAUTOLOGY_LITERALS = ['assert.ok(true)', 'assert(true)', 'expect(true).toBe(true)',
+    'expect(true).toBeTruthy()', 'assert.equal(1, 1)', 'assert.strictEqual(1, 1)', 'assert True',
+    'self.assertTrue(True)', 'assert.True(t, true)'];
+/**
+ * A writing verb and at most `words` more words before the vacuous phrase, so prose
+ * forms match "write a placeholder test" but not "counts skipped tests" or "rejects
+ * an empty test name" (WR-02). The phrase is group 1, so the negation check can read
+ * the words right before it. Matched per collapsed sentence; `[^ ]+` cannot cross a
+ * space, so each repetition is one word and the match is linear.
+ */
+function scaffoldVerb(words) {
+    return `\\b(?:write|writes|create|creates|add|adds|leave|leaves|scaffold|scaffolds|stub|stubs|keep|keeps|put|insert|generate|mark|marks)(?: [^ ]+){0,${words}} `;
+}
+/** Four words for the phrases with a descriptive reading ("counts skipped tests"); "placeholder test" has none, so eight (WR-04). */
+const VERB_WINDOW = scaffoldVerb(4);
+const PLACEHOLDER_VERB_WINDOW = scaffoldVerb(8);
+exports.SCAFFOLD_VACUOUS_PATTERNS = [
+    { kind: 'empty_body', pattern: new RegExp(`${VERB_WINDOW}(empty (?:test )?(?:body|bodies|callback))\\b`, 'i') },
+    { kind: 'empty_body', pattern: new RegExp(`${VERB_WINDOW}(empty tests?)\\b`, 'i') },
+    { kind: 'placeholder', pattern: new RegExp(`${PLACEHOLDER_VERB_WINDOW}(placeholder (?:tests?|assertions?|specs?|cases?))\\b`, 'i') },
+    { kind: 'todo', pattern: /\b(?:test|it|describe)\.todo\b/i },
+    { kind: 'todo', pattern: new RegExp(`${VERB_WINDOW}(todo (?:tests?|assertions?|cases?))\\b`, 'i') },
+    { kind: 'skip', pattern: /\b(?:test|it|describe)\.skip\b/i },
+    { kind: 'skip', pattern: new RegExp(`${VERB_WINDOW}(skipped (?:tests?|assertions?|cases?))\\b`, 'i') },
+    { kind: 'skip', pattern: /@pytest\.mark\.skip\b/ },
+    { kind: 'skip', pattern: /\bt\.Skip(?:Now|f)?\(/ },
+];
+/**
+ * Words that state what NOT to write ("never a placeholder test"). `no-op` is not a
+ * negation. Listed in pp-core/references/test-substance.md.
+ */
+exports.SCAFFOLD_NEGATIONS = ['never', 'not', 'no', "don't", 'dont', 'without', 'avoid', 'instead of'];
+const SCAFFOLD_NEGATION = new RegExp(`\\b(?:${exports.SCAFFOLD_NEGATIONS.join('|')})\\b(?!-)`, 'i');
+/**
+ * A negation reaches no further back than the start of its clause, which "then" or
+ * "but" opens. A comma does not: "never a placeholder test, test.skip or
+ * assert.ok(true)" negates the whole list.
+ */
+const CLAUSE_BREAK = /\b(?:then|but)\b/i;
+/**
+ * A verb that removes the placeholder it governs ("replaces the placeholder test",
+ * "in place of the placeholder test"): the remedy, not a scaffold (WR-02). It must
+ * stand right before the phrase, with only determiners between, so "replaces it
+ * with a placeholder test" still blocks.
+ */
+const PLACEHOLDER_REMEDY = /\b(?:replace|replaces|replaced|replacing|remove|removes|removed|removing|delete|deletes|deleted|deleting|in place of)(?: (?:the|a|an|that|this|these|those|each|every|any|all|its|their|existing|old|legacy))*$/i;
+/** The three test-file-name patterns; the order check reads a path only when one matches. */
+exports.TEST_FILE_PATTERNS = [
+    /\.(?:test|spec)\.[A-Za-z0-9]+$/, /(?:^|\/)test_[^/]+\.py$/, /_test\.(?:go|py)$/,
+];
+exports.TEST_PATH_PATTERNS = [...exports.TEST_FILE_PATTERNS, /(?:^|\/)(?:tests?|__tests__)\//];
+/** Test paths read from one command by the order check (T-38-25). */
+exports.MAX_ORDER_PATHS = 20;
+/** Options that change where a command runs: the order check skips the command (T-38-27). */
+exports.CWD_OPTIONS = ['--prefix', '--cwd', '--root', '--dir', '--chdir', '--workspace', '-C',
+    '--rootDir', '--project', '--projects', '--testFile'];
+/** Verbs that name a path without running it, or write one; the order check skips their steps. */
+exports.ORDER_SKIP_VERBS = ['grep', 'rg', 'echo', 'printf', 'test', '[', 'ls', 'cat', 'head', 'tail', 'wc',
+    'git', 'cmp', 'diff', 'stat', 'find', 'tee', 'cp', 'mv', 'touch'];
+/** Runners that pick a workspace, project or container: the order check skips the command (WR-04). */
+exports.ORDER_SKIP_RUNNERS = ['nx', 'turbo', 'lerna', 'docker', 'docker-compose', 'podman'];
+/** Over the cap: a plan-level over_cap blocker, never clean. */
+exports.MAX_PLAN_CHARS = 200000;
+/**
+ * A PLAN.md file over this many bytes is not read (38-UF-1). UTF-8 decodes to at least one
+ * UTF-16 unit per three bytes (a replacement character also covers at most three bytes), so
+ * a file over this size is over MAX_PLAN_CHARS characters and got `over_cap` when it was
+ * read; skipping the read keeps that finding.
+ */
+exports.MAX_PLAN_BYTES = 3 * exports.MAX_PLAN_CHARS;
+/** Over the cap: a task-level over_cap blocker. */
+exports.MAX_COMMAND_CHARS = 4000;
+/** Task names echoed back are sanitized and cut to this. */
+exports.MAX_QUOTED_CHARS = 120;
+// ─── Small linear helpers ─────────────────────────────────────────────────────
+function mk(code, detail) {
+    return { code, severity: 'blocker', detail };
+}
+/** Whitespace runs collapse to one space. `\s+` alone has nothing to backtrack into. */
+function collapse(s) {
+    return s.split(/\s+/).filter((w) => w !== '').join(' ');
+}
+/** A string echoed back to an agent: collapsed, sanitized and cut (T-38-03). */
+function quoted(s, max = exports.MAX_QUOTED_CHARS) {
+    const flat = collapse(s.length > max * 4 ? s.slice(0, max * 4) : s);
+    const clean = (0, security_cjs_1.sanitizeForPrompt)(flat);
+    return clean.length > max ? clean.slice(0, max) : clean;
+}
+function isWordChar(ch) {
+    return /^[A-Za-z0-9_]$/.test(ch);
+}
+/** Surrounding backticks and quotes, backslashes and a leading `./` removed. */
+function normPath(p) {
+    let s = p.trim();
+    let a = 0;
+    let b = s.length;
+    const wrap = '`\'"';
+    while (a < b && wrap.includes(s.charAt(a)))
+        a++;
+    while (b > a && wrap.includes(s.charAt(b - 1)))
+        b--;
+    s = s.slice(a, b).split('\\').join('/');
+    while (s.startsWith('./'))
+        s = s.slice(2);
+    return s;
+}
+function isTestPath(p) {
+    const s = normPath(p);
+    if (s.length === 0 || s.length > 1000)
+        return false;
+    return exports.TEST_PATH_PATTERNS.some((re) => re.test(s));
+}
+// ─── Commands ─────────────────────────────────────────────────────────────────
+const ENTITY_PAIRS = [
+    ['&lt;', '<'], ['&gt;', '>'], ['&quot;', '"'], ['&amp;', '&'],
+];
+/** Plans are XML, so `&amp;&amp;` is `&&`. Fixed-string replacements, `&amp;` last so it never double-decodes. */
+function decodeEntities(s) {
+    let out = s;
+    for (const [from, to] of ENTITY_PAIRS)
+        out = out.split(from).join(to);
+    return out;
+}
+/**
+ * The command cut to MAX_COMMAND_CHARS, entities decoded, split on `&&`, `;`, `||`
+ * and newline. The alternation has no quantifier and no whitespace around the
+ * separators: `\s*&&\s*` costs 12-30 s on a long run of spaces (research Pitfall 3).
+ */
+function segmentCommand(raw) {
+    return commandParts(raw).map((p) => p.text);
+}
+/**
+ * `s` without its shell comments (WR-01): an unquoted, unescaped `#` that starts a
+ * word (at the start, or after whitespace, `;`, `&`, `|`, `(` or `)`) runs to the end
+ * of its line, so `# npm test` runs nothing. Quotes are tracked, so `grep "# fail 0"`
+ * keeps its text, and `$#` or `${#x}` is not a comment; after an unclosed quote the
+ * rest is kept as it is. One character loop.
+ */
+function stripComments(s) {
+    if (!s.includes('#'))
+        return s;
+    const keep = [];
+    let quote = '';
+    let start = 0;
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charAt(i);
+        if (quote !== '') {
+            if (c === '\\' && quote === '"')
+                i++;
+            else if (c === quote)
+                quote = '';
+            continue;
+        }
+        if (c === '\\') {
+            i++;
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            quote = c;
+            continue;
+        }
+        if (c === '#' && (i === 0 || /[\s;&|()]/.test(s.charAt(i - 1)))) {
+            keep.push(s.slice(start, i));
+            const nl = s.indexOf('\n', i);
+            if (nl === -1) {
+                start = s.length;
+                break;
+            }
+            start = nl;
+            i = nl - 1;
+        }
+    }
+    keep.push(s.slice(start));
+    return keep.join('');
+}
+/** Each non-empty segment with the separator before it (`''` for the first). One character loop. */
+function commandParts(raw) {
+    return splitParts(commandText(raw));
+}
+/** The command cut to MAX_COMMAND_CHARS, entities decoded and comments dropped. */
+function commandText(raw) {
+    const cut = raw.length > exports.MAX_COMMAND_CHARS ? raw.slice(0, exports.MAX_COMMAND_CHARS) : raw;
+    return stripComments(decodeEntities(cut));
+}
+/** `commandParts` over already decoded text. */
+function splitParts(s) {
+    const out = [];
+    let sep = '';
+    let start = 0;
+    const flush = (end, next) => {
+        const text = s.slice(start, end).trim();
+        if (text !== '')
+            out.push({ sep, text });
+        // `npm test ||` + newline + `echo x`: the empty line between keeps the `||`.
+        if (text !== '' || (sep !== '||' && sep !== '&&'))
+            sep = next;
+    };
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charAt(i);
+        const two = s.slice(i, i + 2);
+        if (two === '&&' || two === '||') {
+            flush(i, two);
+            start = i + 2;
+            i++;
+            continue;
+        }
+        if (c === ';' || c === '\n') {
+            flush(i, c);
+            start = i + 1;
+        }
+    }
+    flush(s.length, '');
+    return out;
+}
+/** True when `needle` occurs in `c` and the next character is the end or a non-word character. */
+function hasNeedle(c, needles, leadingBoundary) {
+    for (const needle of needles) {
+        let from = 0;
+        for (;;) {
+            const i = c.indexOf(needle, from);
+            if (i === -1)
+                break;
+            const next = c.charAt(i + needle.length);
+            const prev = i === 0 ? '' : c.charAt(i - 1);
+            const endOk = next === '' || !isWordChar(next);
+            const startOk = !leadingBoundary || prev === '' || !isWordChar(prev);
+            if (endOk && startOk)
+                return true;
+            from = i + 1;
+        }
+    }
+    return false;
+}
+const NEUTRAL_VERBS = new Set(['cd', 'export', 'set']);
+const EXISTENCE_FLAGS = new Set(['-f', '-e', '-d', '-s']);
+function segmentKind(seg) {
+    const toks = collapse(seg).split(' ');
+    const t0 = toks[0] ?? '';
+    const t1 = toks[1] ?? '';
+    if (NEUTRAL_VERBS.has(t0))
+        return 'neutral';
+    // Only `VAR=val` words, none running a command substitution: an assignment, nothing runs (WR-01).
+    if (isAssignmentOnly(seg))
+        return 'neutral';
+    if ((t0 === 'test' || t0 === '[' || t0 === '[[') && EXISTENCE_FLAGS.has(t1))
+        return 'existence_only';
+    if (t0 === 'ls')
+        return 'existence_only';
+    // A pipeline stays one segment: `echo x | node cli.cjs | grep -qx y` feeds stdin
+    // to a real check, so an echo or printf is echo_only only when nothing reads it (WR-01).
+    if ((t0 === 'echo' || t0 === 'printf' || t0 === 'env' || t0 === 'printenv') && seg.includes('|'))
+        return null;
+    if (t0 === 'echo' || t0 === 'printf' || t0 === 'true' || t0 === ':' || t0 === '/bin/true' || t0 === '/usr/bin/true') {
+        return 'echo_only';
+    }
+    // `env` with nothing left to run, and a bare `printenv`, only print the environment (WR-01).
+    if (t0 === 'printenv' && toks.length === 1)
+        return 'echo_only';
+    if (t0 === 'env' && stepWords(seg).rest.length === 0)
+        return 'echo_only';
+    if ((t0 === 'grep' || t0 === 'rg') && toks.slice(1).some((t) => isTestPath(t)))
+        return 'grep_test_file';
+    return null;
+}
+/** True when every word of `seg` is a `VAR=val` assignment and none runs a command substitution. */
+function isAssignmentOnly(seg) {
+    if (seg.includes('$(') || seg.includes('`'))
+        return false;
+    const toks = collapse(seg).split(' ').filter((t) => t !== '');
+    return toks.length > 0 && toks.every((t) => /^[A-Za-z_][A-Za-z0-9_]*=/.test(t));
+}
+/** Commands that check nothing about a test run: as its fallback or last step they replace its exit status. */
+const NON_CHECKING_VERBS = new Set(['cat', 'head', 'tail', 'wc', 'pwd', 'date', 'sleep', 'env', 'printenv',
+    'whoami', 'sort', 'uniq', 'tee']);
+/** `git` subcommands that exit 0 whatever the tree holds; `diff` only without `--exit-code`, `--quiet` or `--check`. */
+const NON_CHECKING_GIT = new Set(['status', 'log', 'show', 'branch', 'add', 'diff']);
+/**
+ * `sed`, `awk` and `git` steps that check nothing (WR-01): an `awk` without `exit`, a
+ * `sed` without a `q`/`Q` exit code, and a read-only `git` subcommand. An `awk` that
+ * exits 1 on a red line or a `git diff --exit-code` is a check and keeps the status.
+ */
+function toolChecksNothing(rest) {
+    const t0 = rest[0] ?? '';
+    const text = rest.join(' ');
+    if (t0 === 'awk')
+        return !/\bexit\b/.test(text);
+    if (t0 === 'sed')
+        return !/[qQ] ?[0-9]/.test(text);
+    if (t0 === 'git') {
+        const sub = rest.slice(1).find((w) => !w.startsWith('-')) ?? '';
+        if (!NON_CHECKING_GIT.has(sub))
+            return false;
+        return !rest.some((w) => w === '--exit-code' || w === '--quiet' || w === '--check');
+    }
+    return false;
+}
+/**
+ * True when `seg`, run as an `||` fallback or as the last `;` / newline step, ends
+ * with status 0 whatever the test run did: any vacuous segment kind, a
+ * non-checking command (`cat`, `tail`, ...) or `! false` (WR-05). A real command
+ * (`node`, `npm`, `pytest`, `go`, `exit $?`, `exit 1`) keeps the status.
+ */
+function discardsStatus(seg) {
+    // A pipeline's status is its last stage's (WR-01): it discards the status only when
+    // its first and its last stage both check nothing, so `cat out | grep -q x` and
+    // `cat in.json | node check.js` keep it. A real first stage piped to `tail` stays a
+    // named residual.
+    const stages = pipeStages(seg);
+    if (stages.length > 1)
+        return stepDiscards(stages[0] ?? '') && stepDiscards(stages[stages.length - 1] ?? '');
+    return stepDiscards(seg);
+}
+/** `seg` split on each `|` that is outside quotes, not escaped and not part of `||`. One character loop. */
+function pipeStages(seg) {
+    const out = [];
+    let quote = '';
+    let start = 0;
+    for (let i = 0; i < seg.length; i++) {
+        const c = seg.charAt(i);
+        if (quote !== '') {
+            if (c === '\\' && quote === '"')
+                i++;
+            else if (c === quote)
+                quote = '';
+            continue;
+        }
+        if (c === '\\') {
+            i++;
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            quote = c;
+            continue;
+        }
+        if (c === '|' && seg.charAt(i + 1) !== '|' && seg.charAt(i - 1) !== '|') {
+            out.push(seg.slice(start, i));
+            start = i + 1;
+        }
+    }
+    out.push(seg.slice(start));
+    return out;
+}
+/** `env` options that take the next word as their argument. */
+const ENV_ARG_OPTIONS = new Set(['-u', '-C', '-S', '--unset', '--chdir', '--split-string']);
+/**
+ * The words of one pipeline stage after its `env [-opt] [VAR=val ...]` or bare
+ * `VAR=val` prefix. `viaEnv` is true for an `env` prefix; `chdir` is true when that
+ * prefix changed the working directory (`-C`, `--chdir`).
+ */
+function stepWords(step) {
+    const toks = collapse(step).split(' ').filter((t) => t !== '');
+    const viaEnv = toks[0] === 'env';
+    let chdir = false;
+    let i = viaEnv ? 1 : 0;
+    while (i < toks.length) {
+        const t = toks[i] ?? '';
+        if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(t))
+            i++;
+        else if (viaEnv && ENV_ARG_OPTIONS.has(t)) {
+            if (t === '-C' || t === '--chdir')
+                chdir = true;
+            i += 2;
+        }
+        else if (viaEnv && t.startsWith('-')) {
+            if (t.startsWith('--chdir=') || (t.startsWith('-C') && !t.startsWith('--')))
+                chdir = true;
+            i++;
+        }
+        else
+            break;
+    }
+    return { rest: toks.slice(i), viaEnv, chdir };
+}
+/**
+ * One pipeline stage, judged by the command it runs: a leading `env [-opt] [VAR=val ...]`
+ * or bare `VAR=val` prefix is dropped first, because `env CI=1 node --test x` returns
+ * node's status (WR-01). `env` with nothing left to run only prints, so it checks nothing.
+ */
+function stepDiscards(step) {
+    const { rest, viaEnv } = stepWords(step);
+    if (rest.length === 0)
+        return viaEnv;
+    const kind = segmentKind(rest.join(' '));
+    if (kind === 'echo_only' || kind === 'existence_only' || kind === 'grep_test_file')
+        return true;
+    const t0 = rest[0] ?? '';
+    // The stage has no unquoted pipe, so an echo here feeds nothing (`echo "a|b"`).
+    if (t0 === 'echo' || t0 === 'printf')
+        return true;
+    if (t0 === '!')
+        return rest[1] === 'false' || rest[1] === '/bin/false' || rest[1] === '/usr/bin/false';
+    return NON_CHECKING_VERBS.has(t0) || toolChecksNothing(rest);
+}
+/** `set -e`, `set -euo pipefail` or `set -o errexit`: a failing step stops the script. */
+function setsErrexit(seg) {
+    const toks = collapse(seg).split(' ');
+    if (toks[0] !== 'set')
+        return false;
+    for (let i = 1; i < toks.length; i++) {
+        if (toks[i] === '-o' && toks[i + 1] === 'errexit')
+            return true;
+        if (/^-[A-Za-z]*e[A-Za-z]*$/.test(toks[i]))
+            return true;
+    }
+    return false;
+}
+/** `set -o pipefail` or `set -euo pipefail`: a failing pipeline stage fails the pipeline. */
+function setsPipefail(seg) {
+    const toks = collapse(seg).split(' ');
+    if (toks[0] !== 'set')
+        return false;
+    for (let i = 1; i < toks.length - 1; i++) {
+        if (/^-[A-Za-z]*o$/.test(toks[i]) && toks[i + 1] === 'pipefail')
+            return true;
+    }
+    return false;
+}
+/** `sh -c`, `bash -c`, `bash -ec`, `/bin/sh -c` and the like: a child shell running a script argument. */
+const CHILD_SHELL = /(?:^|[\s;&|(/])(?:ba|z|da|k)?sh -[A-Za-z]*c(?: |$)/;
+/** True when a `;` or a newline sits inside quotes. Same quote rules as `pipeStages`. One character loop. */
+function separatorInQuotes(s) {
+    let quote = '';
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charAt(i);
+        if (quote !== '') {
+            if (c === '\\' && quote === '"')
+                i++;
+            else if (c === quote)
+                quote = '';
+            else if (c === ';' || c === '\n')
+                return true;
+            continue;
+        }
+        if (c === '\\') {
+            i++;
+            continue;
+        }
+        if (c === '"' || c === "'")
+            quote = c;
+    }
+    return false;
+}
+/**
+ * True only when `set -e` really stops the script on every failing step (CR-01). Bash
+ * does not exit on a failure in an `&&` / `||` list, in a pipeline without `pipefail`,
+ * in a `!`, `if`, `elif`, `while` or `until` condition, in a background job, or inside
+ * the `$(...)` of an `export` / `local` / `declare` / `readonly` / `typeset`; and
+ * `set +e` turns errexit off. Any such shape anywhere in the command withdraws the
+ * exemption, so when in doubt the `; true` and last-step checks still run.
+ */
+function errexitCovers(parts, pipefail, text) {
+    // The split ignores quotes, so a `;` inside `bash -c "...; echo ok"` reads as a
+    // top-level step, and errexit does not reach a child shell's script or a `<(...)`
+    // process substitution (WR-02): either shape withdraws the exemption. A child shell
+    // whose quoted script has no `;` or newline returns that script's status, so it keeps it.
+    if (text.includes('<('))
+        return false;
+    if (CHILD_SHELL.test(collapse(text)) && separatorInQuotes(text))
+        return false;
+    for (const p of parts) {
+        if (p.sep === '&&' || p.sep === '||')
+            return false;
+        const flat = collapse(p.text);
+        if (!pipefail && /(?:^|[^|])\|(?:[^|]|$)/.test(flat))
+            return false;
+        if (/^(?:!|(?:if|elif|while|until)\b)/.test(flat))
+            return false;
+        // A lone `&` (not `&&`, `>&`, `&>` or `<&`) sends the job to the background.
+        if (/(?:^|[^<>&])&(?:[^&>]|$)/.test(flat))
+            return false;
+        if (/^(?:export|local|declare|readonly|typeset)\b/.test(flat) && (flat.includes('$(') || flat.includes('`')))
+            return false;
+        if (/^set\b/.test(flat) && / \+[A-Za-z]*e|\+o errexit|\+o pipefail/.test(flat))
+            return false;
+    }
+    return true;
+}
+/** `exit N` or `return N` with N non-zero, or with a `$VAR` operand, or `false`: a step that fails the script. */
+const LOUD_STEP = /^(?:(?:exit|return) (?:"?[1-9][0-9]*"?|"?\$\{?[A-Za-z_])|false(?:$| ))/;
+/** `exit $?` as the first step of an `||` fallback: `$?` is still the failed run's status. */
+const EXIT_STATUS = /^(?:exit|return) "?\$\{?\?/;
+/** A step's words after a leading `{`, `then` or `else`. */
+function guardStep(text) {
+    let t = collapse(text);
+    for (;;) {
+        if (t.startsWith('{'))
+            t = t.slice(1).trimStart();
+        else if (t.startsWith('then '))
+            t = t.slice(5);
+        else if (t.startsWith('else '))
+            t = t.slice(5);
+        else
+            return t;
+    }
+}
+/**
+ * True when the last real step is followed by a guard that exits the script non-zero
+ * when that step failed, and only steps that check nothing follow the guard, so the
+ * trailing `echo ok` cannot replace a red run's status (WR-03). A guard is:
+ * - `|| exit 1`, `|| exit $?`, `|| exit $rc`, `|| return 1` or `|| false`;
+ * - `|| { ...; exit 1; }`: a brace group, which runs in this shell, holding a loud
+ *   step (`exit $?` only as its first step, since later `$?` is the echo's status);
+ * - `if [ $? -ne 0 ]; then exit 1; fi`: an `if` on `$?` whose body holds a loud step.
+ * A `( ... )` subshell is not a guard: its `exit` leaves only the subshell. A guard
+ * on an earlier step (`npm run build || exit 1; node --test x; echo ok`) does not
+ * count. The closing `}` / `fi` and the loud steps are indexed once, so the scan is
+ * linear in the number of parts.
+ */
+function failsLoudly(parts) {
+    const n = parts.length;
+    const flats = parts.map((p) => collapse(p.text));
+    const inert = (k) => {
+        const text = parts[k]?.text ?? '';
+        return discardsStatus(text) || segmentKind(text) === 'neutral' || isAssignmentOnly(text);
+    };
+    // The first index from which every part is inert: the guard must end there or later.
+    let tail = n;
+    while (tail > 0 && inert(tail - 1))
+        tail--;
+    // nextClose[k] / nextFi[k]: the first index >= k that closes a brace group / is `fi`;
+    // loudBefore[k]: loud steps in parts[0..k).
+    const nextClose = new Array(n + 1).fill(-1);
+    const nextFi = new Array(n + 1).fill(-1);
+    const loudBefore = new Array(n + 1).fill(0);
+    for (let k = 0; k < n; k++) {
+        const flat = flats[k] ?? '';
+        const loud = LOUD_STEP.test(guardStep(flat.endsWith('}') ? flat.slice(0, -1) : flat));
+        loudBefore[k + 1] = (loudBefore[k] ?? 0) + (loud ? 1 : 0);
+    }
+    for (let k = n - 1; k >= 0; k--) {
+        const flat = flats[k] ?? '';
+        nextClose[k] = flat.endsWith('}') ? k : (nextClose[k + 1] ?? -1);
+        nextFi[k] = flat === 'fi' ? k : (nextFi[k + 1] ?? -1);
+    }
+    const louds = (from, to) => (loudBefore[to] ?? 0) - (loudBefore[from] ?? 0);
+    for (let i = 1; i < n; i++) {
+        const head = parts[i];
+        const flat = flats[i] ?? '';
+        if (head === undefined)
+            continue;
+        let end = -1;
+        if (head.sep === '||' && !flat.startsWith('{')) {
+            const first = guardStep(flat);
+            if (LOUD_STEP.test(first) || EXIT_STATUS.test(first))
+                end = i + 1;
+        }
+        else if (head.sep === '||') {
+            const close = nextClose[i] ?? -1;
+            const first = guardStep(flat);
+            if (close !== -1 && (LOUD_STEP.test(first) || EXIT_STATUS.test(first) || louds(i + 1, close + 1) > 0))
+                end = close + 1;
+        }
+        else if (/^if /.test(flat) && flat.includes('$?')) {
+            const fi = nextFi[i + 1] ?? -1;
+            if (fi !== -1 && louds(i + 1, fi) > 0)
+                end = fi + 1;
+        }
+        if (end === -1 || end < tail)
+            continue;
+        const before = parts[i - 1]?.text ?? '';
+        if (segmentKind(before) === null && !discardsStatus(before))
+            return true;
+    }
+    return false;
+}
+/** `exit` with a literal zero, bare or quoted, as a whole word. Linear: no nested quantifier. */
+const EXIT_ZERO = /(?:^|[^A-Za-z0-9_])exit (["']?)0+\1(?![A-Za-z0-9_])/;
+/**
+ * The vacuous kind of a verify command, or null. `|| true`, `exit 0` and the
+ * pass-with-no-tests flags are vacuous anywhere; so is `; true` unless `set -e` runs
+ * first. The existence, echo and grep-over-test-file kinds are vacuous only when
+ * every non-neutral segment is, so `test -f x && node --test y` is a real check.
+ * A command with no non-neutral segment (empty, or only `cd`, `export`, `set`) is
+ * `no_command`. The exit status is also discarded by an `||` fallback, or a final segment after
+ * `;` or a newline, that checks nothing (`discardsStatus`, CR-03, WR-05); a `set -e`
+ * before the first real step keeps the status through `;` where errexit really stops
+ * the script (`errexitCovers`). A pipe to `tail`,
+ * `head`, `wc` or `tee` is not flagged (a named residual).
+ */
+function classifyCommand(raw) {
+    const cut = raw.length > exports.MAX_COMMAND_CHARS ? raw.slice(0, exports.MAX_COMMAND_CHARS) : raw;
+    const flat = collapse(stripComments(decodeEntities(cut)));
+    const parts = commandParts(cut);
+    let errexit = false;
+    let pipefail = false;
+    for (const part of parts) {
+        if (segmentKind(part.text) !== 'neutral')
+            break;
+        if (setsErrexit(part.text))
+            errexit = true;
+        if (setsPipefail(part.text))
+            pipefail = true;
+    }
+    errexit = errexit && errexitCovers(parts, pipefail, stripComments(decodeEntities(cut)));
+    if (hasNeedle(flat, ['|| true', '||true'], false))
+        return 'or_true';
+    if (!errexit && hasNeedle(flat, ['; true', ';true'], false))
+        return 'semicolon_true';
+    // `exit 0`, `exit "0"`, `exit '0'` and `exit 00` (WR-01).
+    if (EXIT_ZERO.test(flat))
+        return 'exit_zero';
+    if (flat.includes('--passWithNoTests') || flat.includes('--pass-with-no-tests'))
+        return 'pass_with_no_tests';
+    let first = null;
+    let judged = 0;
+    let allVacuous = true;
+    for (const part of parts) {
+        const kind = segmentKind(part.text);
+        if (kind === 'neutral')
+            continue;
+        judged++;
+        if (kind === null)
+            allVacuous = false;
+        else if (first === null)
+            first = kind;
+    }
+    if (judged > 0 && allVacuous)
+        return first;
+    // Empty, or only `cd`, `export` and `set`: the command runs nothing (WR-05).
+    if (judged === 0)
+        return 'no_command';
+    if (parts.some((p) => p.sep === '||' && discardsStatus(p.text)))
+        return 'or_true';
+    const last = parts[parts.length - 1];
+    // A bare `VAR=val` last step is status 0 (WR-01). As an `||` fallback it is the
+    // `cmd || rc=1; ...; exit $rc` idiom, which records the failure, so only the last step counts.
+    if (!errexit && last !== undefined && (last.sep === ';' || last.sep === '\n')
+        && (discardsStatus(last.text) || isAssignmentOnly(last.text)) && !failsLoudly(parts)) {
+        return 'semicolon_true';
+    }
+    return null;
+}
+// ─── Behaviour statements ─────────────────────────────────────────────────────
+/** Lower-cased, list markers and backticks removed, whitespace collapsed, trailing `.`/`!` trimmed. */
+function normaliseStatement(raw) {
+    const lines = raw.split('\n').map((line) => {
+        let s = line.trim();
+        if (s.startsWith('- ') || s.startsWith('* ') || s.startsWith('+ '))
+            s = s.slice(2);
+        return s;
+    });
+    let flat = collapse(lines.join(' ').toLowerCase().split('`').join(''));
+    let end = flat.length;
+    while (end > 0 && (flat.charAt(end - 1) === '.' || flat.charAt(end - 1) === '!'))
+        end--;
+    flat = flat.slice(0, end).trim();
+    return flat;
+}
+/** Dropped before the denylist compare, so "All of the tests pass now." is `tests pass`. */
+const BEHAVIOR_FILLER = new Set(['all', 'of', 'the', 'a', 'an', 'now', 'correctly', 'successfully', 'properly',
+    'fully', 'just', 'still', 'should', 'will']);
+/** A denylist phrase may follow at most this many other words ("the feature is implemented"). */
+const GENERIC_LEAD_WORDS = 2;
+/**
+ * A template placeholder left in the statement: a `[...]` of letters and spaces
+ * (with `:`, `→`, `->` or `-`) holding at least two words, outside backticks and not
+ * a markdown link. `[a, b]`, `['x']` and `[1]` are code, not placeholders (WR-03).
+ */
+function hasPlaceholder(raw) {
+    const prose = raw.split('`').filter((_, i) => i % 2 === 0).join(' ');
+    const re = /\[([A-Za-z][A-Za-z :→>-]{0,200})\](?!\()/g;
+    for (let m = re.exec(prose); m !== null; m = re.exec(prose)) {
+        if ((m[1] ?? '').trim().includes(' '))
+            return true;
+    }
+    return false;
+}
+/** The statement's words with filler dropped equal a denylist phrase, after at most GENERIC_LEAD_WORDS other words. */
+function isGenericStatement(norm) {
+    const core = norm.split(' ').filter((w) => !BEHAVIOR_FILLER.has(w));
+    for (const phrase of exports.GENERIC_BEHAVIORS) {
+        const p = phrase.split(' ').filter((w) => !BEHAVIOR_FILLER.has(w));
+        if (p.length === 0 || core.length < p.length || core.length > p.length + GENERIC_LEAD_WORDS)
+            continue;
+        if (core.slice(core.length - p.length).join(' ') === p.join(' '))
+            return true;
+    }
+    return false;
+}
+/** D-01 / D-02: absent, empty, a template placeholder, too short, or a generic phrase. */
+function checkBehavior(raw) {
+    if (raw === null)
+        return mk('behavior_missing', 'absent');
+    if (raw.trim() === '')
+        return mk('behavior_missing', 'empty');
+    if (hasPlaceholder(raw))
+        return mk('behavior_generic', 'placeholder');
+    const norm = normaliseStatement(raw);
+    const words = norm === '' ? 0 : norm.split(' ').length;
+    if (norm.length < exports.BEHAVIOR_MIN_CHARS || words < exports.BEHAVIOR_MIN_WORDS)
+        return mk('behavior_generic', 'too_short');
+    if (exports.GENERIC_BEHAVIORS.includes(norm) || isGenericStatement(norm)) {
+        return mk('behavior_generic', 'denylisted');
+    }
+    return null;
+}
+// ─── Plan parsing ─────────────────────────────────────────────────────────────
+function isOpenLine(line, open) {
+    const t = line.trimStart();
+    if (t.length <= open.length)
+        return false;
+    if (t.slice(0, open.length).toLowerCase() !== open)
+        return false;
+    const ch = t.charAt(open.length);
+    return ch === '>' || ch === ' ' || ch === '\t';
+}
+/** Units of `tag` by line scan: an opening line, then the first line carrying the close. One failed search stops the scan. */
+function scanUnits(lines, tag) {
+    const open = `<${tag}`;
+    const close = `</${tag}>`;
+    const units = [];
+    let i = 0;
+    while (i < lines.length) {
+        if (!isOpenLine(lines[i], open)) {
+            i++;
+            continue;
+        }
+        const at = lines[i].toLowerCase().indexOf(open);
+        let end = lines[i].indexOf(close, at < 0 ? 0 : at) === -1 ? -1 : i;
+        for (let j = i + 1; end === -1 && j < lines.length; j++) {
+            if (lines[j].includes(close))
+                end = j;
+        }
+        if (end === -1)
+            return { units, unterminated: true };
+        units.push([i, end]);
+        i = end + 1;
+    }
+    return { units, unterminated: false };
+}
+/**
+ * The first element named `name` whose opening tag starts a line (left-trimmed), up
+ * to its closing tag. A mention inside prose is not an element. Lines in `skip`
+ * (the task's action body) are ignored.
+ */
+function findElement(lines, name, skip) {
+    const open = `<${name}`;
+    const close = `</${name}>`;
+    for (let i = 0; i < lines.length; i++) {
+        if (skip && i >= skip[0] && i <= skip[1])
+            continue;
+        if (!isOpenLine(lines[i], open))
+            continue;
+        const t = lines[i].trimStart();
+        const gt = t.indexOf('>');
+        if (gt === -1)
+            continue;
+        const rest = t.slice(gt + 1);
+        const sameLine = rest.indexOf(close);
+        if (sameLine !== -1)
+            return { inner: rest.slice(0, sameLine), start: i, end: i };
+        const parts = [rest];
+        for (let j = i + 1; j < lines.length; j++) {
+            const k = lines[j].indexOf(close);
+            if (k !== -1) {
+                parts.push(lines[j].slice(0, k));
+                return { inner: parts.join('\n'), start: i, end: j };
+            }
+            parts.push(lines[j]);
+        }
+        return null;
+    }
+    return null;
+}
+function parseFiles(inner) {
+    if (inner === null)
+        return [];
+    const out = [];
+    for (const part of inner.split(/[\n,]/)) {
+        let s = part.trim();
+        if (s.startsWith('- ') || s.startsWith('* '))
+            s = s.slice(2);
+        s = s.split('`').join('').trim();
+        if (s !== '')
+            out.push(s);
+    }
+    return out;
+}
+function attr(openLine, name) {
+    const m = new RegExp(`\\b${name}\\s{0,3}=\\s{0,3}["']([^"']{0,200})["']`, 'i').exec(openLine);
+    return m ? (m[1] ?? '') : null;
+}
+function parseUnit(unitLines, index, isFeature) {
+    const openLine = unitLines[0] ?? '';
+    const typeAttr = attr(openLine, 'type');
+    const tdd = isFeature || (attr(openLine, 'tdd') ?? '').toLowerCase() === 'true';
+    const actionEl = findElement(unitLines, 'action');
+    const skip = actionEl ? [actionEl.start, actionEl.end] : undefined;
+    const nameEl = findElement(unitLines, 'name', skip);
+    const filesEl = findElement(unitLines, 'files', skip);
+    const behaviorEl = findElement(unitLines, 'behavior', skip);
+    const verifyEl = findElement(unitLines, 'verify', skip);
+    // An `<automated>` element that is present but empty stays `''`, so the verb reports
+    // it as `no_command` (WR-05); no command at all stays null.
+    let command = null;
+    if (verifyEl) {
+        const automated = findElement(verifyEl.inner.split('\n'), 'automated');
+        if (automated) {
+            command = automated.inner.trim();
+        }
+        else {
+            const text = (/<[A-Za-z]/.test(verifyEl.inner) ? '' : verifyEl.inner).trim();
+            command = text === '' ? null : text;
+        }
+    }
+    const filesInner = filesEl ? filesEl.inner : null;
+    const behavior = behaviorEl ? behaviorEl.inner : null;
+    return {
+        index,
+        name: nameEl && nameEl.inner.trim() !== '' ? quoted(nameEl.inner) : `Task ${index}`,
+        type: quoted(typeAttr ?? 'auto', 40),
+        tdd,
+        behavior,
+        files: parseFiles(filesInner),
+        command,
+        action: actionEl ? actionEl.inner : '',
+        // The D-12 predicate runs its regexes over whole input; give it only the opening
+        // line, the files and the behaviour, never the action prose (research Pitfall 5).
+        snippet: `${openLine}\n<files>${filesInner ?? ''}</files>\n<behavior>${behavior ?? ''}</behavior>`,
+    };
+}
+/**
+ * Task units of a PLAN.md. A `type: tdd` plan holds `<feature>` blocks instead of
+ * task elements; each is one unit. Over the size cap, an unterminated element or a
+ * markdown-only plan is a plan-level finding, never a clean parse.
+ */
+function parsePlanTasks(content) {
+    if (content.length > exports.MAX_PLAN_CHARS)
+        return { tasks: [], findings: [mk('over_cap', 'plan')] };
+    const lines = content.split('\r\n').join('\n').split('\n');
+    const findings = [];
+    let scan = scanUnits(lines, 'task');
+    let isFeature = false;
+    if (scan.units.length === 0 && !scan.unterminated) {
+        scan = scanUnits(lines, 'feature');
+        isFeature = scan.units.length > 0 || scan.unterminated;
+    }
+    if (scan.unterminated)
+        findings.push(mk('unreadable', 'unterminated_task'));
+    const tasks = scan.units.map(([start, end], i) => parseUnit(lines.slice(start, end + 1), i + 1, isFeature));
+    // Any plan with no task element is a finding, whatever its prose looks like
+    // (`## Task 1`, `### 1. Build`, `**Task 1:**`): never a clean parse (WR-04).
+    if (tasks.length === 0 && !scan.unterminated)
+        findings.push(mk('behavior_missing', 'no_xml_tasks'));
+    return { tasks, findings };
+}
+/**
+ * The `wave:` value of the frontmatter: the content starts with a `---` line, and at
+ * most 200 following lines are read up to the closing `---`. Null when absent or not
+ * 1 to 4 digits. Reads only the head of the plan, one line at a time.
+ */
+function planWave(content) {
+    const head = (content.length > 50000 ? content.slice(0, 50000) : content).split('\r\n').join('\n').split('\n', 202);
+    if ((head[0] ?? '').trimEnd() !== '---')
+        return null;
+    for (let i = 1; i < head.length && i <= 200; i++) {
+        const line = head[i] ?? '';
+        if (line.trimEnd() === '---')
+            return null;
+        const m = /^wave:\s{0,3}["']?([0-9]{1,4})(?![0-9])/.exec(line);
+        if (m)
+            return Number(m[1]);
+    }
+    return null;
+}
+function fileKeys(entry) {
+    const whole = normPath(entry);
+    const first = normPath(entry.trim().split(/\s/)[0] ?? '');
+    return first === whole ? [whole] : [whole, first];
+}
+function parsePlan(plan) {
+    const id = quoted(plan.id, 60);
+    const base = { plan, id, tasks: [], findings: [], firstPos: new Map(), wave: planWave(plan.content) };
+    if (plan.overCap === true) {
+        base.findings.push(mk('over_cap', 'plan'));
+        return base;
+    }
+    if (plan.content.length === 0) {
+        base.findings.push(mk('unreadable', 'read_error'));
+        return base;
+    }
+    const parsed = parsePlanTasks(plan.content);
+    base.tasks = parsed.tasks;
+    base.findings = parsed.findings;
+    parsed.tasks.forEach((task, pos) => {
+        for (const entry of task.files) {
+            for (const key of fileKeys(entry)) {
+                if (key !== '' && !base.firstPos.has(key))
+                    base.firstPos.set(key, pos);
+            }
+        }
+    });
+    return base;
+}
+function cleanToken(t) {
+    const lead = '`\'"([{';
+    const trail = '`\'")].,;:!?}';
+    let a = 0;
+    let b = t.length;
+    while (a < b && lead.includes(t.charAt(a)))
+        a++;
+    while (b > a && trail.includes(t.charAt(b - 1)))
+        b--;
+    return t.slice(a, b);
+}
+/**
+ * A MISSING marker is a command that STARTS with the word `MISSING` after optional
+ * wrapping, list or quote characters (`` `MISSING … ` ``, `- MISSING …`,
+ * `(MISSING …)`, `> MISSING …`, `"missing: …"`). The all-caps word may be followed
+ * by the end or any character but a word character or `=` (`MISSING.`, `MISSING-…`,
+ * WR-03); any other case only by the end, a space, `:`, a dash or a quote (WR-02).
+ * Any other command, including one that merely contains the word (`echo MISSING x
+ * || true`, `--expect-MISSING-key`), starts with a longer word (`missing-deps.sh`,
+ * `MISSINGNO`) or assigns a variable (`MISSING=1 cmd`), is classified as a command
+ * (CR-01). Every marker is a finding (`missingFinding`), so a shell suffix
+ * (`MISSING x || true`) cannot make one pass.
+ */
+const MISSING_MARKER_CAPS = /^[`'"*\-\s(>]*MISSING(?![A-Za-z0-9_=])/;
+const MISSING_MARKER = /^[`'"*\-\s(>]*missing(?:$|[\s:—–`'"])/i;
+function isMissingMarker(command) {
+    return MISSING_MARKER_CAPS.test(command) || MISSING_MARKER.test(command);
+}
+/**
+ * The test-file paths a `MISSING — Wave 0 must create {file} first` marker names:
+ * only the tokens between `create` and `first`, so a trailing remark that names a
+ * second file is not a path the marker asks for. Without `create`, every token
+ * after `MISSING`; without `first`, every token to the end.
+ */
+function markerPaths(command) {
+    const toks = command.trim().split(/\s+/).slice(1).map(cleanToken);
+    const createAt = toks.indexOf('create');
+    const from = createAt === -1 ? 0 : createAt + 1;
+    const firstAt = toks.indexOf('first', from);
+    const out = [];
+    for (const tok of toks.slice(from, firstAt === -1 ? toks.length : firstAt)) {
+        if (tok === '' || out.includes(tok))
+            continue;
+        if (isTestPath(tok) || tok.includes('/') || /^[^\s]+\.[A-Za-z0-9]{2,8}$/.test(tok))
+            out.push(tok);
+    }
+    return out;
+}
+/**
+ * D-03: a MISSING marker is never a task's final verify. The executor has no MISSING
+ * handling, so it would run the marker as a command ("command not found", or an
+ * improvised check). Every marker is therefore a finding, and the detail names the
+ * fix (WR-03):
+ * - the file is created by an earlier task of the same plan or by the task itself:
+ *   it exists when this verify runs, so write its real test command
+ *   (`marker_not_replaced`);
+ * - created by a later task, another plan or no task: move the scaffold before the
+ *   task (`later_task`, `other_plan:<id>`, `no_creator`); `no_path` names no file.
+ */
+function missingFinding(task, pos, self, all) {
+    const candidates = markerPaths(task.command ?? '');
+    if (candidates.length === 0)
+        return mk('scaffold_uncreated', 'no_path');
+    for (const tok of candidates) {
+        const key = normPath(tok);
+        const at = self.firstPos.get(key);
+        if (at !== undefined && at <= pos)
+            continue;
+        if (at !== undefined)
+            return mk('scaffold_uncreated', 'later_task');
+        const other = all.find((p) => p !== self && p.firstPos.has(key));
+        if (other)
+            return mk('scaffold_uncreated', `other_plan:${other.id}`);
+        return mk('scaffold_uncreated', 'no_creator');
+    }
+    return mk('scaffold_uncreated', 'marker_not_replaced');
+}
+/** Characters that make a word something other than a plain relative path. */
+const NON_PATH_CHARS = [':', '*', '?', '[', ']', '{', '}', '$', '~', '<', '>', '|', '`', '"', "'"];
+/** Shell words that open a step but do not run anything themselves. */
+const STEP_OPENERS = new Set(['!', 'if', 'elif', 'while', 'until', 'then', 'do', 'else']);
+/** The directory of a leading `cd <dir>`, or null when its target cannot be followed. */
+function followableDir(word) {
+    if (word === '' || word.startsWith('/') || word.startsWith('-'))
+        return null;
+    if (NON_PATH_CHARS.some((c) => word.includes(c)))
+        return null;
+    const dir = node_path_1.default.posix.normalize(normPath(word));
+    if (dir === '..' || dir.startsWith('../') || dir.startsWith('/'))
+        return null;
+    return dir;
+}
+/** The verb of a stage: its first word, after any opener (`!`, `if`, `then`, ...) and subshell characters. */
+function stageVerb(rest) {
+    const bare = (w) => {
+        let i = 0;
+        while (i < w.length && (w.charAt(i) === '(' || w.charAt(i) === '{'))
+            i++;
+        return w.slice(i);
+    };
+    let at = 0;
+    while (at < rest.length - 1) {
+        const w = bare(rest[at] ?? '');
+        if (w !== '' && !STEP_OPENERS.has(w))
+            break;
+        at++;
+    }
+    return bare(rest[at] ?? '');
+}
+/** A package manager's own workspace options: `npm -w app`, `pnpm -F app`, `pnpm --filter app`. */
+const PM_WORKSPACE_OPTIONS = { npm: ['-w'], pnpm: ['-F', '--filter'] };
+/** Words that hand the rest of the step to another tool (`npx nx`, `pnpm exec turbo`, `yarn dlx lerna`). */
+const RUNNER_LAUNCHERS = new Set(['npx', 'pnpx', 'bunx', 'npm', 'pnpm', 'yarn', 'bun', 'exec', 'dlx']);
+/**
+ * True when a step runs in a working directory the order check cannot follow (WR-04):
+ * a child shell's `-c` script, a workspace runner or container (`ORDER_SKIP_RUNNERS`,
+ * reached through `npx` / `pnpm exec` / `yarn dlx`), `yarn workspace`, `npm -w` or
+ * `pnpm -F` / `--filter`. Only that step is skipped: it does not move the steps after it.
+ */
+function stepRunsElsewhere(rest, verb) {
+    const base = verb.slice(verb.lastIndexOf('/') + 1);
+    if (/^(?:ba|z|da|k)?sh$/.test(base) && rest.some((w) => /^-[A-Za-z]*c$/.test(w)))
+        return true;
+    const own = PM_WORKSPACE_OPTIONS[base];
+    if (own !== undefined && rest.some((w) => own.includes(w) || (w.startsWith('--') && own.some((o) => w.startsWith(`${o}=`))))) {
+        return true;
+    }
+    let prev = '';
+    for (const raw of rest) {
+        if (raw.startsWith('-'))
+            continue;
+        const w = raw.replace(/^[({]+/, '');
+        if (w === '' || STEP_OPENERS.has(w))
+            continue;
+        const name = w.slice(w.lastIndexOf('/') + 1);
+        if (exports.ORDER_SKIP_RUNNERS.includes(name))
+            return true;
+        if (prev === 'yarn' && (name === 'workspace' || name === 'workspaces'))
+            return true;
+        if (!RUNNER_LAUNCHERS.has(name))
+            return false;
+        prev = name;
+    }
+    return false;
+}
+/** `sh -c`, `bash -lc`, `/bin/sh -c` ... in raw text, followed by the script argument. */
+const CHILD_SHELL_RAW = /(?:^|[\s;&|(/])(?:ba|z|da|k)?sh[ \t]+-[A-Za-z]*c(?=[ \t])/g;
+/**
+ * `s` with the quoted script of every child shell (`bash -c "cd app && ..."`) emptied
+ * to `""`, so its `&&` and `;` are not read as steps of this shell (WR-04). Null when
+ * a script's quote never closes. One pass: each script is skipped once.
+ */
+function dropShellScripts(s) {
+    const re = new RegExp(CHILD_SHELL_RAW.source, 'g');
+    const keep = [];
+    let from = 0;
+    for (let m = re.exec(s); m !== null; m = re.exec(s)) {
+        let i = m.index + m[0].length;
+        while (s.charAt(i) === ' ' || s.charAt(i) === '\t')
+            i++;
+        const q = s.charAt(i);
+        if (q !== '"' && q !== "'")
+            continue;
+        let j = i + 1;
+        while (j < s.length && s.charAt(j) !== q)
+            j += q === '"' && s.charAt(j) === '\\' ? 2 : 1;
+        if (j >= s.length)
+            return null;
+        keep.push(s.slice(from, i), q, q);
+        from = j + 1;
+        re.lastIndex = j + 1;
+    }
+    keep.push(s.slice(from));
+    return keep.join('');
+}
+/** An option whose value is a file the command writes (`--test-reporter-destination`, `--outputFile`, `--junit-xml`). */
+const OUTPUT_OPTION = /destination|output|junit/i;
+/** A redirection operator that writes the next word: `>`, `>>`, `2>`, `&>`, `>|`. */
+const WRITE_REDIRECT = /^[0-9&]?>>?\|?$/;
+/**
+ * The test files a real command runs, as project-relative paths, for the order check
+ * (D-03). Null means the working directory cannot be followed and the command is
+ * skipped. A leading `cd <dir> &&` is followed; any other `cd` or `pushd`, a
+ * `CWD_OPTIONS` option and an `env -C` skip the command. A workspace runner, a
+ * container or a child shell's script skips its own step (`stepRunsElsewhere`), and a
+ * child shell's quoted script is never split into steps (`dropShellScripts`). Steps
+ * whose verb is in `ORDER_SKIP_VERBS` name a path without running it, and the word
+ * after `>` / `>>` or an output option (`OUTPUT_OPTION`) is written, not run (WR-04).
+ * A word counts only when it is a
+ * relative path with a directory and a test-file name (`TEST_FILE_PATTERNS`); a
+ * glob, a variable, a `:` token, a bare name and a path outside the project are not
+ * read. At most `MAX_ORDER_PATHS` paths come back. One pass over at most
+ * `MAX_COMMAND_CHARS` characters, split on literal separators (T-38-25).
+ */
+function commandTestPaths(command) {
+    const text = dropShellScripts(commandText(command));
+    if (text === null)
+        return null;
+    const parts = splitParts(text);
+    let prefix = '';
+    let from = 0;
+    const lead = parts[0];
+    if (lead !== undefined) {
+        const words = collapse(lead.text).split(' ');
+        if (words[0] === 'cd' && words.length === 2 && parts[1]?.sep === '&&') {
+            const dir = followableDir(words[1] ?? '');
+            if (dir === null)
+                return null;
+            prefix = dir;
+            from = 1;
+        }
+    }
+    const out = [];
+    for (let pi = from; pi < parts.length; pi++) {
+        for (const stage of pipeStages(parts[pi]?.text ?? '')) {
+            const { rest, chdir } = stepWords(stage);
+            const verb = stageVerb(rest);
+            if (verb === 'cd' || verb === 'pushd')
+                return null;
+            if (exports.ORDER_SKIP_VERBS.includes(verb))
+                continue;
+            if (chdir)
+                return null;
+            if (stepRunsElsewhere(rest, verb))
+                continue;
+            for (const raw of rest) {
+                for (const opt of exports.CWD_OPTIONS) {
+                    if (raw === opt || (opt.startsWith('--') && raw.startsWith(`${opt}=`)))
+                        return null;
+                }
+                if (raw.startsWith('-C') && !raw.startsWith('--') && raw.length > 2)
+                    return null;
+            }
+            let skipNext = false;
+            for (const raw of rest) {
+                // The word after `>` / `>>` or an output option is a file the command writes (WR-04).
+                if (skipNext) {
+                    skipNext = false;
+                    continue;
+                }
+                if (WRITE_REDIRECT.test(raw)) {
+                    skipNext = true;
+                    continue;
+                }
+                let word = cleanToken(raw);
+                if (word.startsWith('-')) {
+                    const eq = word.indexOf('=');
+                    if (OUTPUT_OPTION.test(eq === -1 ? word : word.slice(0, eq))) {
+                        skipNext = eq === -1;
+                        continue;
+                    }
+                    if (eq === -1)
+                        continue;
+                    word = cleanToken(word.slice(eq + 1));
+                }
+                const cut = word.indexOf('::');
+                if (cut !== -1)
+                    word = word.slice(0, cut);
+                if (word === '' || NON_PATH_CHARS.some((c) => word.includes(c)))
+                    continue;
+                if (!word.includes('/') || word.startsWith('/'))
+                    continue;
+                const clean = normPath(word);
+                const joined = node_path_1.default.posix.normalize(prefix === '' ? clean : `${prefix}/${clean}`);
+                if (joined === '..' || joined.startsWith('../') || joined.startsWith('/'))
+                    continue;
+                if (!exports.TEST_FILE_PATTERNS.some((re) => re.test(joined)))
+                    continue;
+                if (out.includes(joined))
+                    continue;
+                out.push(joined);
+                if (out.length >= exports.MAX_ORDER_PATHS)
+                    return out;
+            }
+        }
+    }
+    return out;
+}
+/**
+ * D-03 for a real command: every test file it runs must exist when the task runs. A
+ * path is fine when it is on disk, or listed by this task, an earlier task of this
+ * plan, or a plan of an earlier wave. Otherwise: `later_task` (only a later task of
+ * the plan lists it), `other_plan:<id>` (only a plan of the same or a later wave, or
+ * of an unparsed wave) or `no_creator`. Returns the first finding. The earlier-wave
+ * creator is accepted whatever it holds: the plan checker judges that (check 8d).
+ */
+function orderFinding(task, pos, self, all, exists) {
+    const found = commandTestPaths(task.command ?? '');
+    if (found === null)
+        return null;
+    for (const file of found) {
+        const at = self.firstPos.get(file);
+        if (at !== undefined && at <= pos)
+            continue;
+        if (exists(file))
+            continue;
+        const others = all.filter((p) => p !== self && p.firstPos.has(file));
+        // An earlier-wave creator runs before this plan starts, so it settles the file
+        // before a later task of this plan can make it `later_task` (CR-02).
+        const selfWave = self.wave;
+        if (selfWave !== null && others.some((o) => o.wave !== null && o.wave < selfWave))
+            continue;
+        if (at !== undefined)
+            return mk('scaffold_uncreated', 'later_task');
+        const first = others[0];
+        if (first === undefined)
+            return mk('scaffold_uncreated', 'no_creator');
+        return mk('scaffold_uncreated', `other_plan:${first.id}`);
+    }
+    return null;
+}
+/** Start offsets of every match of `re` in `s`, ascending. */
+function matchStarts(s, re) {
+    const out = [];
+    const g = new RegExp(re.source, `${re.flags}g`);
+    for (let m = g.exec(s); m !== null; m = g.exec(s))
+        out.push(m.index);
+    return out;
+}
+/** End offsets of every match of `re` in `s`, ascending. */
+function matchEnds(s, re) {
+    const out = [];
+    const g = new RegExp(re.source, `${re.flags}g`);
+    for (let m = g.exec(s); m !== null; m = g.exec(s))
+        out.push(m.index + m[0].length);
+    return out;
+}
+/** D-03: a task that writes a test file must not describe an empty, placeholder, todo, skipped or tautological test. */
+function scaffoldContentFinding(task) {
+    if (!task.files.some((f) => isTestPath(f)))
+        return null;
+    // Sentence by sentence. A match is negated ("never a placeholder test or test.skip",
+    // "write no placeholder tests") when a negation sits earlier in its own clause, or in
+    // the three words right before the phrase. A negation in an earlier clause ("does not
+    // crash, then add a placeholder test") does not reach it (WR-04). Negation and clause
+    // positions are found once per sentence, so many matches stay linear (T-38-01).
+    const sentences = task.action.split(/[.;!?](?=\s|$)|\n/).map(collapse).filter((s) => s !== '').map((s) => ({
+        s, negations: matchStarts(s, SCAFFOLD_NEGATION), breaks: matchEnds(s, CLAUSE_BREAK),
+    }));
+    const affirmed = ({ s, negations, breaks }, at, phraseAt = at) => {
+        const b = lowerBound(breaks, at + 1) - 1;
+        const clauseStart = b >= 0 ? breaks[b] : 0;
+        if (countBetween(negations, clauseStart - 1, at) > 0)
+            return false;
+        const lead = s.slice(at, phraseAt).split(' ').filter((w) => w !== '').slice(-3).join(' ');
+        return !SCAFFOLD_NEGATION.test(lead);
+    };
+    for (const { kind, pattern } of exports.SCAFFOLD_VACUOUS_PATTERNS) {
+        const every = new RegExp(pattern.source, `${pattern.flags}g`);
+        for (const sentence of sentences) {
+            every.lastIndex = 0;
+            for (let m = every.exec(sentence.s); m !== null; m = every.exec(sentence.s)) {
+                const phraseAt = m[1] === undefined ? m.index : m.index + m[0].length - m[1].length;
+                if (kind === 'placeholder' && PLACEHOLDER_REMEDY.test(sentence.s.slice(m.index, phraseAt).trimEnd()))
+                    continue;
+                if (affirmed(sentence, m.index, phraseAt))
+                    return mk('scaffold_empty', kind);
+            }
+        }
+    }
+    for (const literal of exports.TAUTOLOGY_LITERALS) {
+        for (const sentence of sentences) {
+            for (let at = sentence.s.indexOf(literal); at !== -1; at = sentence.s.indexOf(literal, at + literal.length)) {
+                if (affirmed(sentence, at))
+                    return mk('scaffold_empty', 'tautology');
+            }
+        }
+    }
+    return null;
+}
+function taskFindings(task, pos, self, all, exists) {
+    if (task.type.startsWith('checkpoint:'))
+        return [];
+    const findings = [];
+    const behavior = checkBehavior(task.behavior);
+    if (behavior)
+        findings.push(behavior);
+    if (task.command !== null) {
+        if (task.command.length > exports.MAX_COMMAND_CHARS) {
+            findings.push(mk('over_cap', 'command'));
+        }
+        else if (isMissingMarker(task.command)) {
+            findings.push(missingFinding(task, pos, self, all));
+        }
+        else {
+            const kind = classifyCommand(task.command);
+            if (kind)
+                findings.push(mk('verify_vacuous', kind));
+            const order = exists === undefined ? null : orderFinding(task, pos, self, all, exists);
+            if (order)
+                findings.push(order);
+        }
+    }
+    const scaffold = scaffoldContentFinding(task);
+    if (scaffold)
+        findings.push(scaffold);
+    return findings;
+}
+/**
+ * The verdict over already-read plans. `block` is `enforced && finding_count > 0`;
+ * only plans without a SUMMARY count. `tdd_candidates_without_tdd` is information.
+ * With `exists`, a test file a real command runs that is not on disk is also checked
+ * against the plans that create it (`orderFinding`); without it the order check does
+ * not run, so pure callers see only the text-level findings.
+ */
+function analyzeTestSubstance(plans, enforced, exists) {
+    const parsed = plans.map(parsePlan);
+    const reports = [];
+    const candidates = [];
+    let findingCount = 0;
+    for (const p of parsed) {
+        const tasks = p.tasks.map((task, pos) => ({
+            index: task.index, name: task.name, type: task.type, tdd: task.tdd,
+            findings: taskFindings(task, pos, p, parsed, exists),
+        }));
+        if (!p.plan.executed) {
+            findingCount += p.findings.length + tasks.reduce((n, t) => n + t.findings.length, 0);
+            for (const task of p.tasks) {
+                if (task.tdd || task.type.startsWith('checkpoint:'))
+                    continue;
+                if (isBehaviorAddingTaskContent(task.snippet).checks.has_source_files) {
+                    candidates.push({ plan: p.id, index: task.index, name: task.name });
+                }
+            }
+        }
+        reports.push({ id: p.id, executed: p.plan.executed, findings: p.findings, tasks });
+    }
+    return {
+        enforced,
+        block: enforced && findingCount > 0,
+        finding_count: findingCount,
+        plans: reports,
+        tdd_candidates_without_tdd: candidates,
+    };
+}
+// ─── Disk and the phase-scoped check ──────────────────────────────────────────
+/**
+ * Every `*-PLAN.md` of a phase directory, sorted, with the executed flag taken from
+ * the matching `*-SUMMARY.md` (the rule `readPhasePlans` uses). A plan file that
+ * cannot be read comes back with empty content, which `analyzeTestSubstance` reports
+ * as `unreadable` / `read_error` rather than as a clean plan (T-38-04). Each entry is
+ * `lstat`ed first (38-UF-1): one that is not a regular file (a symbolic link, FIFO,
+ * directory, socket or device) is never opened, so a link cannot pull in text from outside
+ * the phase and a FIFO cannot hang the check; a regular file over `MAX_PLAN_BYTES` is not
+ * read either and comes back with `overCap: true`, which is reported as `over_cap` / `plan`
+ * as it was when the file was read. `lstat` checks only the last path component, so a
+ * symlinked `.planning` or phase directory (a worktree) still reads. Read-only.
+ */
+function readPhaseSubstancePlans(phaseDirAbs) {
+    let names;
+    try {
+        names = node_fs_1.default.readdirSync(phaseDirAbs);
+    }
+    catch {
+        // An unreadable phase directory is `unreadable` / `read_error`, never a clean phase (WR-04).
+        return [{ id: '(phase)', executed: false, content: '' }];
+    }
+    const planFiles = names.filter((f) => f.endsWith('-PLAN.md') || f === 'PLAN.md').sort();
+    const completed = new Set();
+    for (const s of names) {
+        if (!(s.endsWith('-SUMMARY.md') || s === 'SUMMARY.md'))
+            continue;
+        completed.add(s.replace('-SUMMARY.md', '').replace('SUMMARY.md', ''));
+        completed.add(extractCanonicalPlanId(s));
+    }
+    const out = [];
+    for (const file of planFiles) {
+        const full = node_path_1.default.join(phaseDirAbs, file);
+        let content = '';
+        let overCap = false;
+        try {
+            const stat = node_fs_1.default.lstatSync(full);
+            if (!stat.isFile())
+                content = '';
+            else if (stat.size > exports.MAX_PLAN_BYTES)
+                overCap = true;
+            else
+                content = node_fs_1.default.readFileSync(full, 'utf8');
+        }
+        catch {
+            content = '';
+        }
+        const id = file.replace('-PLAN.md', '').replace('PLAN.md', '');
+        out.push({
+            id,
+            executed: completed.has(id) || completed.has(extractCanonicalPlanId(file)),
+            content,
+            ...(overCap ? { overCap: true } : {}),
+        });
+    }
+    return out;
+}
+/** Symlinks followed for one lookup before it gives up (answers true, probes nothing more). */
+const MAX_LINK_HOPS = 40;
+const PATH_SPLIT = node_path_1.default.sep === '\\' ? /[\\/]+/ : /\/+/;
+/** True when `p` is `root` or below it. Both are absolute. */
+function isWithin(root, p) {
+    const rel = node_path_1.default.relative(root, p);
+    return rel === '' || (rel !== '..' && !rel.startsWith(`..${node_path_1.default.sep}`) && !node_path_1.default.isAbsolute(rel));
+}
+/**
+ * One lookup of `projectPathExists`: walks `parts` from the real project root one
+ * component at a time with `lstat`, which never follows the component it stats. A
+ * symlink before the last component is read with `readlink` (which touches only the
+ * link) and followed only while its target stays inside the project; a target outside
+ * it, a link that cannot be read and a chain longer than MAX_LINK_HOPS answer true and
+ * stop the walk, so nothing outside the project is ever statted (CR-01). The last
+ * component is an entry: a symlink there is never followed.
+ */
+function walkExists(root, parts) {
+    let cur = root;
+    const queue = parts.slice();
+    let hops = 0;
+    while (queue.length > 0) {
+        const name = queue.shift();
+        if (name === '' || name === '.')
+            continue;
+        if (name === '..') {
+            cur = node_path_1.default.dirname(cur);
+            if (!isWithin(root, cur))
+                return true;
+            continue;
+        }
+        const next = node_path_1.default.join(cur, name);
+        let st;
+        try {
+            st = node_fs_1.default.lstatSync(next);
+        }
+        catch {
+            return false;
+        }
+        if (queue.length === 0)
+            return true;
+        if (st.isSymbolicLink()) {
+            hops++;
+            if (hops > MAX_LINK_HOPS)
+                return true;
+            let target;
+            try {
+                target = node_fs_1.default.readlinkSync(next);
+            }
+            catch {
+                return true;
+            }
+            if (node_path_1.default.isAbsolute(target)) {
+                // An absolute target is placed lexically, so a `..` in it could hide a symlink: skip.
+                if (target.split(PATH_SPLIT).includes('..') || !isWithin(root, node_path_1.default.resolve(target)))
+                    return true;
+                queue.unshift(...node_path_1.default.relative(root, node_path_1.default.resolve(target)).split(node_path_1.default.sep));
+                cur = root;
+            }
+            else {
+                // `cur` is always a real directory, so the target's `..` steps are walked physically.
+                queue.unshift(...target.split(PATH_SPLIT));
+            }
+            continue;
+        }
+        if (!st.isDirectory())
+            return false;
+        cur = next;
+    }
+    return true;
+}
+/**
+ * Whether a project-relative path exists on disk, memoised. A path that resolves to
+ * the project root or outside it answers true without touching the disk, so a token
+ * from a plan can never make the verb probe the filesystem elsewhere. Inside the
+ * project the path is walked component by component (`walkExists`): a symlinked
+ * directory is followed only while it stays inside the project, and a symlink as the
+ * last component is an entry that is never followed (T-38-24, CR-01).
+ */
+function projectPathExists(projectDir) {
+    const memo = new Map();
+    let root = null;
+    try {
+        root = node_fs_1.default.realpathSync(projectDir);
+    }
+    catch {
+        root = null;
+    }
+    return (relPath) => {
+        const cached = memo.get(relPath);
+        if (cached !== undefined)
+            return cached;
+        const abs = node_path_1.default.resolve(projectDir, relPath);
+        const rel = node_path_1.default.relative(projectDir, abs);
+        let answer;
+        if (root === null || rel === '' || rel === '..' || rel.startsWith(`..${node_path_1.default.sep}`) || node_path_1.default.isAbsolute(rel)) {
+            answer = true;
+        }
+        else {
+            answer = walkExists(root, rel.split(node_path_1.default.sep));
+        }
+        memo.set(relPath, answer);
+        return answer;
+    };
+}
+/**
+ * The phase-scoped check. The enforcement flag is `resolveGateConfig(projectDir).nyquist`,
+ * the one reader the ceremony and the nyquist capability share, so only a real boolean
+ * `false` turns it off (T-38-06). The phase directory comes from `resolvePhaseForRead`;
+ * the raw argument is never joined into a path (T-38-02). An unknown phase blocks.
+ * Nothing here looks for RESEARCH.md (D-05).
+ */
+function computeTestSubstance(projectDir, phase) {
+    // WR-04: ceremony.cjs is loaded here, not at module load, so a missing
+    // ceremony-gates.json cannot take down every `check` verb.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { resolveGateConfig } = require('./ceremony.cjs');
+    const enforced = resolveGateConfig(projectDir).nyquist;
+    const result = resolvePhaseForRead(projectDir, phase);
+    const relDir = result && typeof result['directory'] === 'string' ? result['directory'] : '';
+    if (!relDir) {
+        return { phase, phase_found: false, ...analyzeTestSubstance([], enforced), block: true };
+    }
+    const phaseDir = node_path_1.default.resolve(projectDir, relDir);
+    const plans = readPhaseSubstancePlans(phaseDir);
+    const report = analyzeTestSubstance(plans, enforced, projectPathExists(projectDir));
+    if (plans.length === 0) {
+        // A found phase with no PLAN.md has nothing to vouch for: a plan-level finding, never clean (WR-04).
+        report.plans.push({ id: '(phase)', executed: false, findings: [mk('unreadable', 'no_plans')], tasks: [] });
+        report.finding_count += 1;
+        report.block = enforced;
+    }
+    return { phase, phase_found: true, ...report };
+}
+// ─── Test-file scanner (TEST-04, D-14, D-16) ───────────────────────────────────
+//
+// Validation-time half of the module: `scanTestSource` counts assertions per test
+// case in JS/TS, Python and Go text. Counting is deterministic; whether a project
+// helper asserts is the auditor's judgement, so a case with no recognised assertion
+// is reported and anything the scanner cannot read reports `unknown`, never `ok`
+// (T-38-14). Every pass is a single linear walk: literals are masked by one
+// character loop, brackets are paired by one stack pass, and per-case counts are
+// binary searches over sorted position arrays, so nested or unterminated input
+// cannot make the work quadratic (T-38-11). The scanner reads text only. The JS
+// tautology rules mirror eslint-rules/no-tautological-assert.cjs.
+/** A test file over this many characters is `unknown` / `over_cap`; `scanTestFile` checks `stat` before reading. */
+exports.MAX_SCAN_FILE_BYTES = 1048576;
+/** Files scanned per call; the rest report `unknown` / `over_file_cap`. */
+exports.MAX_SCAN_FILES = 200;
+/** Entries per list (`asserts_nothing`, `skipped`) in one file's report. */
+exports.MAX_LISTED_CASES = 20;
+exports.CASE_STATES = ['asserts', 'asserts_nothing', 'todo', 'skip'];
+exports.FILE_STATES = ['ok', 'no_cases', 'unknown'];
+exports.SCAN_UNKNOWN_REASONS = ['unsupported_language', 'over_cap', 'outside_project', 'not_found',
+    'not_regular_file', 'over_file_cap', 'unbalanced', 'unrecognised_shape', 'unreadable'];
+/** `test.<m>(` and `it.<m>(`. */
+exports.JS_CASE_MODIFIERS = ['only', 'skip', 'todo'];
+/** `test.<m>(` / `it.<m>(` members that produce cases the scanner cannot read: the file is `unknown`. */
+exports.JS_CASE_PRODUCING_MEMBERS = ['each', 'for', 'concurrent', 'sequential', 'runIf', 'skipIf',
+    'failing', 'fails'];
+/** `test.<m>(` / `it.<m>(` members that are hooks, steps or configuration, never a case (WR-01). */
+exports.JS_NON_CASE_MEMBERS = ['beforeEach', 'afterEach', 'beforeAll', 'afterAll', 'before', 'after',
+    'step', 'use', 'extend', 'info', 'setTimeout', 'slow', 'expect', 'mock'];
+/** Display tokens, one per recognised assertion form (the reference doc and its parity test use these). */
+exports.ASSERTION_VOCABULARY = {
+    js: ['assert(', 'assert.*', 't.assert', 'expect(', '.should', 'assert*()', 'expect*()'],
+    python: ['assert', 'self.assert*', 'pytest.raises', 'assert*()', 'expect*()'],
+    go: ['t.Error*', 't.Fatal*', 't.Fail*', 'assert.*', 'require.*', 'assert*()', 'expect*()'],
+};
+/** A call or definition longer than this is never a literal tautology; its arguments are not parsed. */
+const MAX_TAUTOLOGY_SPAN = 2000;
+function languageOf(file) {
+    const ext = node_path_1.default.extname(String(file)).toLowerCase();
+    if (['.js', '.cjs', '.mjs', '.jsx', '.ts', '.cts', '.mts', '.tsx'].includes(ext))
+        return 'js';
+    if (ext === '.py')
+        return 'python';
+    if (ext === '.go')
+        return 'go';
+    return 'unknown';
+}
+// ─── Shared scanner helpers ───────────────────────────────────────────────────
+const CH_NL = 10;
+const CH_SPACE = 32;
+function toCodes(src) {
+    const out = new Uint16Array(src.length);
+    for (let i = 0; i < src.length; i++)
+        out[i] = src.charCodeAt(i);
+    return out;
+}
+function fromCodes(codes) {
+    const parts = [];
+    for (let i = 0; i < codes.length; i += 8192) {
+        parts.push(String.fromCharCode.apply(null, codes.subarray(i, i + 8192)));
+    }
+    return parts.join('');
+}
+/** Blank `[from, to)` to spaces, newlines kept so line numbers survive. */
+function blankRange(codes, from, to) {
+    const end = to > codes.length ? codes.length : to;
+    for (let i = from < 0 ? 0 : from; i < end; i++)
+        if (codes[i] !== CH_NL)
+            codes[i] = CH_SPACE;
+}
+function isIdentCode(c) {
+    return (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95 || c === 36 || c > 127;
+}
+function isIdentStartCode(c) {
+    return (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95 || c === 36 || c > 127;
+}
+function isSpaceCode(c) {
+    return c === 32 || c === 9 || c === 10 || c === 13;
+}
+function skipSpaces(text, from) {
+    let j = from;
+    while (j < text.length && isSpaceCode(text.charCodeAt(j)))
+        j++;
+    return j;
+}
+/** True when the word `word` ends just before `at`, with only whitespace between. */
+function precededByWord(text, at, word) {
+    let j = at - 1;
+    while (j >= 0 && isSpaceCode(text.charCodeAt(j)))
+        j--;
+    const start = j - word.length + 1;
+    if (start < 0 || text.slice(start, j + 1) !== word)
+        return false;
+    return start === 0 || !isIdentCode(text.charCodeAt(start - 1));
+}
+/** Positions of every `\n`, ascending. */
+function newlineIndexes(text) {
+    const out = [];
+    let from = 0;
+    for (;;) {
+        const i = text.indexOf('\n', from);
+        if (i === -1)
+            return out;
+        out.push(i);
+        from = i + 1;
+    }
+}
+/** First index of `arr` whose value is >= x (arr ascending). */
+function lowerBound(arr, x) {
+    let lo = 0;
+    let hi = arr.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        if (arr[mid] < x)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+/** How many values of `arr` lie strictly between `lo` and `hi`. */
+function countBetween(arr, lo, hi) {
+    const n = lowerBound(arr, hi) - lowerBound(arr, lo + 1);
+    return n > 0 ? n : 0;
+}
+/** 1-based line of the offset `pos`. */
+function lineOf(newlines, pos) {
+    return lowerBound(newlines, pos) + 1;
+}
+/** One stack pass: `pair[i]` is the index of the closer matching the opener at `i`, or -1. */
+function pairDelims(masked, open, close) {
+    const pair = new Int32Array(masked.length).fill(-1);
+    const stack = [];
+    for (let i = 0; i < masked.length; i++) {
+        const c = masked.charCodeAt(i);
+        if (c === open)
+            stack.push(i);
+        else if (c === close && stack.length > 0)
+            pair[stack.pop()] = i;
+    }
+    return pair;
+}
+/** Visit every identifier of a masked text. A number literal is skipped whole, so `1test` is not `test`. */
+function eachIdent(masked, visit) {
+    const n = masked.length;
+    let i = 0;
+    while (i < n) {
+        const c = masked.charCodeAt(i);
+        if (isIdentStartCode(c)) {
+            let j = i + 1;
+            while (j < n && isIdentCode(masked.charCodeAt(j)))
+                j++;
+            visit(i, j, masked.slice(i, j));
+            i = j;
+        }
+        else if (c >= 48 && c <= 57) {
+            let j = i + 1;
+            while (j < n && isIdentCode(masked.charCodeAt(j)))
+                j++;
+            i = j;
+        }
+        else {
+            i++;
+        }
+    }
+}
+/** Top-level argument ranges (at most `max`) of the call whose parens enclose `[from, to)`. Brackets nest. */
+function splitTopArgs(masked, from, to, max) {
+    const out = [];
+    let depth = 0;
+    let start = from;
+    for (let i = from; i < to && out.length < max; i++) {
+        const c = masked.charCodeAt(i);
+        if (c === 40 || c === 91 || c === 123)
+            depth++;
+        else if (c === 41 || c === 93 || c === 125)
+            depth--;
+        else if (c === 44 && depth === 0) {
+            out.push([start, i]);
+            start = i + 1;
+        }
+    }
+    if (out.length < max && (start < to || out.length > 0))
+        out.push([start, to]);
+    return out;
+}
+const NUMBER_LITERAL = /^(?:0[xX][0-9a-fA-F]+|\d+(?:\.\d+)?(?:[eE][+-]?\d+)?|\.\d+)$/;
+function isNumberLiteral(s) {
+    return s.length <= 64 && NUMBER_LITERAL.test(s);
+}
+/** One quote-delimited literal: the masked text is quote, blanks, the same quote. */
+function isQuotedLiteral(masked, quotes = '\'"') {
+    if (masked.length < 2)
+        return false;
+    const q = masked.charAt(0);
+    if (!quotes.includes(q) || masked.charAt(masked.length - 1) !== q)
+        return false;
+    const inner = masked.slice(1, -1);
+    return !inner.includes(q) && inner.trim() === '';
+}
+/** The original and masked text of one operand, both cut by the whitespace the MASKED text has at its ends. */
+function trimBoth(orig, mask) {
+    let a = 0;
+    let b = mask.length;
+    while (a < b && isSpaceCode(mask.charCodeAt(a)))
+        a++;
+    while (b > a && isSpaceCode(mask.charCodeAt(b - 1)))
+        b--;
+    return [orig.slice(a, b), mask.slice(a, b)];
+}
+/** `m` starts with `open` and the matching closer is its last character. */
+function wholeDelimited(m, open, close) {
+    if (m.length < 2 || m.charAt(0) !== open || m.charAt(m.length - 1) !== close)
+        return false;
+    let depth = 0;
+    for (let i = 0; i < m.length; i++) {
+        const ch = m.charAt(i);
+        if (ch === open)
+            depth++;
+        else if (ch === close) {
+            depth--;
+            if (depth === 0)
+                return i === m.length - 1;
+        }
+    }
+    return false;
+}
+function emptyScan(language, state, reason) {
+    return reason ? { language, state, reason, cases: [] } : { language, state, cases: [] };
+}
+/** The case name: the first argument's text, quotes stripped, sanitized and cut. */
+function caseName(masked, text, open, close) {
+    const limit = Math.min(close, open + 1 + exports.MAX_QUOTED_CHARS * 4);
+    const [first] = splitTopArgs(masked, open + 1, limit, 1);
+    let raw = first ? text.slice(first[0], first[1]).trim() : '';
+    const q = raw.charAt(0);
+    if (q === '\'' || q === '"' || q === '`') {
+        raw = raw.slice(1);
+        if (raw.charAt(raw.length - 1) === q)
+            raw = raw.slice(0, -1);
+    }
+    const name = quoted(raw);
+    return name === '' ? '(unnamed)' : name;
+}
+/**
+ * A project assertion helper: `assert*`, or `expect` followed by an upper-case
+ * letter or `_` (`expectNoError`, `expect_called`). `expected*` and `expectation*`
+ * are fixture builders, not assertions (WR-05).
+ */
+function isAssertHelperName(w) {
+    if (w.startsWith('assert'))
+        return true;
+    if (!w.startsWith('expect'))
+        return false;
+    const next = w.charCodeAt(6);
+    return Number.isNaN(next) || (next >= 65 && next <= 90) || next === 95;
+}
+function caseState(modifier, assertions) {
+    if (modifier === 'todo')
+        return 'todo';
+    if (modifier === 'skip')
+        return 'skip';
+    return assertions > 0 ? 'asserts' : 'asserts_nothing';
+}
+// ─── JS / TS ──────────────────────────────────────────────────────────────────
+// `<` is not a regex prefix: in a .jsx/.tsx file `</p>` is a closing tag, and reading
+// its `/` as a regex start masked the rest of the line, parens included (CR-02).
+const REGEX_PREFIX_CHARS = '(,=:[!&|?{};+-*%>~^';
+const REGEX_PREFIX_WORDS = new Set(['return', 'typeof', 'case', 'in', 'of', 'new', 'delete', 'void', 'throw']);
+/**
+ * A string of the same length as `src` in which comments, string literals,
+ * template-literal text and regex-literal bodies are spaces (newlines kept) and the
+ * delimiters stay. `${...}` expressions inside a template are scanned as code. A
+ * quote or a regex ends at its newline; a block comment or a template with no
+ * closer masks to the end of input. One character loop, linear in the input.
+ */
+function maskJs(src) {
+    const n = src.length;
+    const out = toCodes(src);
+    const stack = [];
+    let i = 0;
+    let prevSig = -1;
+    let wordStart = 0;
+    const scanTemplate = (from) => {
+        let j = from;
+        while (j < n) {
+            const c = src.charCodeAt(j);
+            if (c === 92) {
+                j += 2;
+                continue;
+            }
+            if (c === 96) {
+                blankRange(out, from, j);
+                i = j + 1;
+                prevSig = j;
+                return;
+            }
+            if (c === 36 && src.charCodeAt(j + 1) === 123) {
+                blankRange(out, from, j);
+                stack.push(0);
+                i = j + 2;
+                prevSig = j + 1;
+                return;
+            }
+            j++;
+        }
+        blankRange(out, from, n);
+        i = n;
+    };
+    while (i < n) {
+        const c = src.charCodeAt(i);
+        if (c === 47) { // '/'
+            const next = src.charCodeAt(i + 1);
+            if (next === 47) {
+                const e = src.indexOf('\n', i);
+                const end = e === -1 ? n : e;
+                blankRange(out, i, end);
+                i = end;
+                continue;
+            }
+            if (next === 42) {
+                const e = src.indexOf('*/', i + 2);
+                const end = e === -1 ? n : e + 2;
+                blankRange(out, i, end);
+                i = end;
+                continue;
+            }
+            const prevCh = prevSig === -1 ? '' : src.charAt(prevSig);
+            // `}` then `/>` closes a JSX self-closing tag after an expression or spread
+            // attribute (`<Button onClick={fn} />`, `<Foo {...p} />`), never a regex (WR-06).
+            // After `(`, `,` or `=` a `/>/` is still a regex (`s.split(/>/)`).
+            const jsxSelfClose = next === 62 && prevCh === '}';
+            const regexAllowed = !jsxSelfClose && (prevSig === -1
+                || REGEX_PREFIX_CHARS.includes(prevCh)
+                || (isIdentCode(src.charCodeAt(prevSig)) && REGEX_PREFIX_WORDS.has(src.slice(wordStart, prevSig + 1))));
+            if (!regexAllowed) {
+                prevSig = i;
+                i++;
+                continue;
+            }
+            let j = i + 1;
+            let inClass = false;
+            let closed = false;
+            while (j < n) {
+                const cj = src.charCodeAt(j);
+                if (cj === 92) {
+                    j += 2;
+                    continue;
+                }
+                if (cj === CH_NL)
+                    break;
+                if (inClass) {
+                    if (cj === 93)
+                        inClass = false;
+                }
+                else if (cj === 91) {
+                    inClass = true;
+                }
+                else if (cj === 47) {
+                    closed = true;
+                    break;
+                }
+                j++;
+            }
+            const stop = j > n ? n : j;
+            blankRange(out, i + 1, stop);
+            if (closed) {
+                prevSig = stop;
+                i = stop + 1;
+            }
+            else {
+                prevSig = i;
+                i = stop;
+            }
+            continue;
+        }
+        if (c === 39 || c === 34) { // ' "
+            let j = i + 1;
+            let closed = false;
+            while (j < n) {
+                const cj = src.charCodeAt(j);
+                if (cj === 92) {
+                    j += 2;
+                    continue;
+                }
+                if (cj === c) {
+                    closed = true;
+                    break;
+                }
+                if (cj === CH_NL)
+                    break;
+                j++;
+            }
+            const stop = j > n ? n : j;
+            blankRange(out, i + 1, stop);
+            if (closed) {
+                prevSig = stop;
+                i = stop + 1;
+            }
+            else {
+                prevSig = i;
+                i = stop;
+            }
+            continue;
+        }
+        if (c === 96) { // `
+            scanTemplate(i + 1);
+            continue;
+        }
+        if (c === 123) { // {
+            if (stack.length > 0)
+                stack[stack.length - 1]++;
+            prevSig = i;
+            i++;
+            continue;
+        }
+        if (c === 125) { // }
+            if (stack.length > 0) {
+                if (stack[stack.length - 1] === 0) {
+                    stack.pop();
+                    scanTemplate(i + 1);
+                    continue;
+                }
+                stack[stack.length - 1]--;
+            }
+            prevSig = i;
+            i++;
+            continue;
+        }
+        if (isIdentCode(c)) {
+            if (i === 0 || !isIdentCode(src.charCodeAt(i - 1)))
+                wordStart = i;
+            prevSig = i;
+            i++;
+            continue;
+        }
+        if (!isSpaceCode(c))
+            prevSig = i;
+        i++;
+    }
+    return fromCodes(out);
+}
+/** Positions of every `=>`. */
+function arrowPositions(masked) {
+    const out = [];
+    let from = 0;
+    for (;;) {
+        const i = masked.indexOf('=>', from);
+        if (i === -1)
+            return out;
+        out.push(i);
+        from = i + 2;
+    }
+}
+/** `.ident(` chain after an `assert` identifier: the member names and the index of the call's open paren. */
+function readCallChain(masked, end) {
+    let j = skipSpaces(masked, end);
+    const methods = [];
+    for (let hops = 0; hops < 6; hops++) {
+        const c = masked.charCodeAt(j);
+        if (c === 40)
+            return { methods, open: j };
+        if (c !== 46)
+            return null;
+        const k = skipSpaces(masked, j + 1);
+        let m = k;
+        while (m < masked.length && isIdentCode(masked.charCodeAt(m)))
+            m++;
+        if (m === k)
+            return null;
+        methods.push(masked.slice(k, m));
+        j = skipSpaces(masked, m);
+    }
+    return null;
+}
+function endsWithOrTrue(m) {
+    if (!m.endsWith('true'))
+        return false;
+    const before = m.slice(0, -4);
+    if (before !== '' && isIdentCode(before.charCodeAt(before.length - 1)))
+        return false;
+    return before.trimEnd().endsWith('||');
+}
+function startsWithTrueOr(m) {
+    if (!m.startsWith('true'))
+        return false;
+    const after = m.slice(4);
+    if (after !== '' && isIdentCode(after.charCodeAt(0)))
+        return false;
+    return after.trimStart().startsWith('||');
+}
+/** An always-truthy literal, per the lint rule's category (a); `onlyTrue` is chai `isTrue`. */
+function jsTruthyLiteral(orig, mask, onlyTrue) {
+    let [o, m] = trimBoth(orig, mask);
+    if (m === 'true')
+        return true;
+    if (onlyTrue)
+        return false;
+    while (m.startsWith('!!')) {
+        o = o.slice(2).trim();
+        m = m.slice(2).trim();
+    }
+    if (m === 'true')
+        return true;
+    if (isNumberLiteral(o))
+        return Number(o) !== 0;
+    if (isQuotedLiteral(m))
+        return o.length > 2;
+    if (m.length >= 3 && /^\/ +\/[a-z]*$/.test(m))
+        return true;
+    if (wholeDelimited(m, '[', ']') || wholeDelimited(m, '{', '}'))
+        return true;
+    return endsWithOrTrue(m) || startsWithTrueOr(m);
+}
+/** A comparable key for a literal operand, per the lint rule's category (b); null when it is not a plain literal. */
+function jsLiteralKey(orig, mask) {
+    const [o, m] = trimBoth(orig, mask);
+    if (m === 'true' || m === 'false' || m === 'null')
+        return `k:${m}`;
+    if (isNumberLiteral(o))
+        return `n:${Number(o)}`;
+    if (isQuotedLiteral(m))
+        return `s:${o.slice(1, -1)}`;
+    if (m.length >= 2 && m.replace(/\s/g, '') === '[]')
+        return '[]';
+    if (m.length >= 2 && m.replace(/\s/g, '') === '{}')
+        return '{}';
+    return null;
+}
+const JS_EQUALITY_METHODS = new Set(['strictEqual', 'equal', 'deepEqual', 'deepStrictEqual']);
+/** True when the assertion call opening at `open` is a literal tautology (never fails). */
+function jsAssertCallIsTautology(masked, text, open, close, methods) {
+    if (close < 0 || close - open > MAX_TAUTOLOGY_SPAN)
+        return false;
+    const last = methods.length > 0 ? methods[methods.length - 1] : '';
+    const args = splitTopArgs(masked, open + 1, close, 2);
+    if (last === '' || last === 'ok' || last === 'isTrue') {
+        const a = args[0];
+        return a !== undefined && jsTruthyLiteral(text.slice(a[0], a[1]), masked.slice(a[0], a[1]), last === 'isTrue');
+    }
+    if (JS_EQUALITY_METHODS.has(last)) {
+        const a = args[0];
+        const b = args[1];
+        if (a === undefined || b === undefined)
+            return false;
+        const ka = jsLiteralKey(text.slice(a[0], a[1]), masked.slice(a[0], a[1]));
+        const kb = jsLiteralKey(text.slice(b[0], b[1]), masked.slice(b[0], b[1]));
+        return ka !== null && ka === kb;
+    }
+    return false;
+}
+/** `expect(X).toBe(Y)` / `.toEqual` / `.toStrictEqual` of identical literals, or `.toBeTruthy()` of a truthy literal. */
+function jsExpectIsTautology(masked, text, open, close, parenClose) {
+    if (close < 0 || close - open > MAX_TAUTOLOGY_SPAN)
+        return false;
+    const k = skipSpaces(masked, close + 1);
+    if (masked.charCodeAt(k) !== 46)
+        return false;
+    const n0 = skipSpaces(masked, k + 1);
+    let n1 = n0;
+    while (n1 < masked.length && isIdentCode(masked.charCodeAt(n1)))
+        n1++;
+    const matcher = masked.slice(n0, n1);
+    const open2 = skipSpaces(masked, n1);
+    if (masked.charCodeAt(open2) !== 40)
+        return false;
+    const close2 = parenClose[open2];
+    if (close2 < 0 || close2 - open2 > MAX_TAUTOLOGY_SPAN)
+        return false;
+    const [x] = splitTopArgs(masked, open + 1, close, 1);
+    if (x === undefined)
+        return false;
+    if (matcher === 'toBeTruthy') {
+        return jsTruthyLiteral(text.slice(x[0], x[1]), masked.slice(x[0], x[1]), false);
+    }
+    if (matcher === 'toBe' || matcher === 'toEqual' || matcher === 'toStrictEqual') {
+        const [y] = splitTopArgs(masked, open2 + 1, close2, 1);
+        if (y === undefined)
+            return false;
+        const kx = jsLiteralKey(text.slice(x[0], x[1]), masked.slice(x[0], x[1]));
+        const ky = jsLiteralKey(text.slice(y[0], y[1]), masked.slice(y[0], y[1]));
+        return kx !== null && kx === ky;
+    }
+    return false;
+}
+/**
+ * `skip` or `todo` from a node:test options object `{ skip: true }` / `{ todo: 'why' }`
+ * passed as the case's second argument, or null. Only a literal truthy value counts;
+ * a shorthand or an expression is a conditional skip and is left to the case's
+ * assertions. The object is read only when it is at most MAX_TAUTOLOGY_SPAN long (WR-06).
+ */
+function jsOptionsModifier(masked, text, open, close, braceClose) {
+    const [, second] = splitTopArgs(masked, open + 1, Math.min(close, open + 1 + exports.MAX_QUOTED_CHARS * 4), 2);
+    if (second === undefined)
+        return null;
+    const b = skipSpaces(masked, second[0]);
+    if (masked.charCodeAt(b) !== 123)
+        return null;
+    const end = braceClose[b];
+    if (end < 0 || end - b > MAX_TAUTOLOGY_SPAN)
+        return null;
+    for (const [x, y] of splitTopArgs(masked, b + 1, end, 50)) {
+        const entry = masked.slice(x, y);
+        const colon = entry.indexOf(':');
+        if (colon === -1)
+            continue;
+        const key = entry.slice(0, colon).trim();
+        if (key !== 'skip' && key !== 'todo')
+            continue;
+        if (jsTruthyLiteral(text.slice(x + colon + 1, y), entry.slice(colon + 1), false))
+            return key;
+    }
+    return null;
+}
+/** The first parameter name of the callback whose `=>` or `function` is at `at`, or ''. */
+function jsCallbackParam(masked, at, isArrow, parenOpen) {
+    if (isArrow) {
+        let q = at - 1;
+        while (q >= 0 && isSpaceCode(masked.charCodeAt(q)))
+            q--;
+        if (q < 0)
+            return '';
+        if (masked.charCodeAt(q) !== 41)
+            return identBefore(masked, q + 1);
+        const po = parenOpen[q];
+        if (po < 0)
+            return '';
+        const k = skipSpaces(masked, po + 1);
+        let m = k;
+        while (m < q && isIdentCode(masked.charCodeAt(m)))
+            m++;
+        return masked.slice(k, m);
+    }
+    let j = skipSpaces(masked, at + 8);
+    if (masked.charCodeAt(j) === 42)
+        j = skipSpaces(masked, j + 1);
+    while (j < masked.length && isIdentCode(masked.charCodeAt(j)))
+        j++;
+    j = skipSpaces(masked, j);
+    if (masked.charCodeAt(j) !== 40)
+        return '';
+    const k = skipSpaces(masked, j + 1);
+    let m = k;
+    while (m < masked.length && isIdentCode(masked.charCodeAt(m)))
+        m++;
+    return masked.slice(k, m);
+}
+function scanJs(text) {
+    const masked = maskJs(text);
+    const parenClose = pairDelims(masked, 40, 41);
+    const newlines = newlineIndexes(text);
+    const arrows = arrowPositions(masked);
+    const fnPos = [];
+    const assertPos = [];
+    const tautPos = [];
+    const calls = [];
+    /** `<receiver>.skip(` / `<receiver>.todo(` call positions, by receiver name (WR-06). */
+    const memberMods = { skip: new Map(), todo: new Map() };
+    let describeTokens = 0;
+    let unrecognised = 0;
+    /**
+     * Open parens of calls that name a case the scanner cannot read (`Deno.test('a', …)`,
+     * `test.fixme('a', …)`). Each counts as unrecognised only when a callback sits
+     * inside its parens, decided after the walk: `re.test('x')` and `it.includes('a')`
+     * carry none (WR-01).
+     */
+    const namedCallOpens = [];
+    /** `(` then a quoted first argument right after the identifier ending at `e`: a named test call. */
+    const opensNamedCall = (e) => {
+        const j = skipSpaces(masked, e);
+        if (masked.charCodeAt(j) !== 40)
+            return false;
+        const q = masked.charCodeAt(skipSpaces(masked, j + 1));
+        return q === 39 || q === 34 || q === 96;
+    };
+    /** `test.<word>` / `it.<word>` that is not a case modifier; `e` ends the member name. */
+    const otherMember = (word, e) => {
+        const open = skipSpaces(masked, e);
+        if (masked.charCodeAt(open) !== 40)
+            return; // `it.status`: a variable named `it`, not a call
+        if (word === 'describe') {
+            describeTokens++;
+            return;
+        }
+        if (exports.JS_NON_CASE_MEMBERS.includes(word))
+            return;
+        if (exports.JS_CASE_PRODUCING_MEMBERS.includes(word)) {
+            unrecognised++;
+            return;
+        }
+        if (opensNamedCall(e))
+            namedCallOpens.push(open);
+    };
+    eachIdent(masked, (s, e, w) => {
+        const prevCode = s > 0 ? masked.charCodeAt(s - 1) : 0;
+        const afterDot = prevCode === 46;
+        if (w === 'function') {
+            fnPos.push(s);
+            return;
+        }
+        if ((w === 'skip' || w === 'todo') && afterDot && masked.charCodeAt(skipSpaces(masked, e)) === 40) {
+            const receiver = identBefore(masked, s - 1);
+            if (receiver !== '' && receiver !== 'test' && receiver !== 'it' && receiver !== 'describe') {
+                const byName = memberMods[w];
+                const list = byName.get(receiver);
+                if (list)
+                    list.push(s);
+                else
+                    byName.set(receiver, [s]);
+            }
+            return;
+        }
+        if (w === 'test' || w === 'it' || w === 'describe') {
+            const memberOfT = w === 'test' && afterDot && s >= 2 && masked.charAt(s - 2) === 't'
+                && (s < 3 || (!isIdentCode(masked.charCodeAt(s - 3)) && masked.charCodeAt(s - 3) !== 46));
+            const bare = !afterDot && !(s > 0 && isIdentCode(prevCode));
+            if (bare || memberOfT) {
+                let j = skipSpaces(masked, e);
+                let modifier = null;
+                if (masked.charCodeAt(j) === 46) {
+                    const k = skipSpaces(masked, j + 1);
+                    let m = k;
+                    while (m < masked.length && isIdentCode(masked.charCodeAt(m)))
+                        m++;
+                    const word = masked.slice(k, m);
+                    if (w !== 'describe' && exports.JS_CASE_MODIFIERS.includes(word)) {
+                        modifier = word;
+                        j = skipSpaces(masked, m);
+                        // `test.skip.each(rows)(…)`: a modifier on a table the scanner cannot read.
+                        if (masked.charCodeAt(j) === 46) {
+                            unrecognised++;
+                            return;
+                        }
+                    }
+                    else {
+                        if (w === 'describe')
+                            describeTokens++;
+                        else
+                            otherMember(word, m);
+                        return;
+                    }
+                }
+                if (masked.charCodeAt(j) === 40) {
+                    if (w === 'describe')
+                        describeTokens++;
+                    else
+                        calls.push({ at: s, open: j, modifier });
+                }
+            }
+            else if (w !== 'describe' && afterDot && s >= 2 && isIdentCode(masked.charCodeAt(s - 2)) && opensNamedCall(e)) {
+                // `Deno.test('a', () => …)`, `tap.test('a', (t) => …)`: a test file the scanner cannot
+                // read, so `unknown`, never `no_cases` (WR-07), once a callback confirms it is a case.
+                namedCallOpens.push(skipSpaces(masked, e));
+            }
+            return;
+        }
+        if ((w === 'specify' || w === 'context') && !afterDot && !(s > 0 && isIdentCode(prevCode)) && opensNamedCall(e)) {
+            unrecognised++;
+            return;
+        }
+        if (w === 'assert') {
+            const chain = readCallChain(masked, e);
+            if (chain === null)
+                return;
+            const close = parenClose[chain.open];
+            if (jsAssertCallIsTautology(masked, text, chain.open, close, chain.methods))
+                tautPos.push(s);
+            else
+                assertPos.push(s);
+            return;
+        }
+        if (w === 'expect') {
+            const j = skipSpaces(masked, e);
+            if (masked.charCodeAt(j) !== 40)
+                return;
+            // A bare `expect(x);` has no matcher and asserts nothing (WR-05).
+            const close = parenClose[j];
+            if (close >= 0 && masked.charCodeAt(skipSpaces(masked, close + 1)) !== 46)
+                return;
+            if (jsExpectIsTautology(masked, text, j, close, parenClose))
+                tautPos.push(s);
+            else
+                assertPos.push(s);
+            return;
+        }
+        if (w === 'should') {
+            if (afterDot)
+                assertPos.push(s);
+            return;
+        }
+        if (isAssertHelperName(w)) {
+            const j = skipSpaces(masked, e);
+            if (masked.charCodeAt(j) === 40 && !precededByWord(masked, s, 'function'))
+                assertPos.push(s);
+        }
+    });
+    for (const open of namedCallOpens) {
+        const close = parenClose[open];
+        if (close < 0 || countBetween(arrows, open, close) > 0 || countBetween(fnPos, open, close) > 0)
+            unrecognised++;
+    }
+    const braceClose = pairDelims(masked, 123, 125);
+    const parenOpen = new Int32Array(masked.length).fill(-1);
+    for (let i = 0; i < parenClose.length; i++)
+        if (parenClose[i] >= 0)
+            parenOpen[parenClose[i]] = i;
+    /**
+     * The callback parameter, memoised by the callback's position. Nested cases share
+     * their innermost callback, so without the memo each case re-walks the same
+     * whitespace run around `=>` or `function` and the scan turns quadratic (T-38-11).
+     */
+    const paramCache = new Map();
+    const paramAt = (at, isArrow) => {
+        let p = paramCache.get(at);
+        if (p === undefined) {
+            p = jsCallbackParam(masked, at, isArrow, parenOpen);
+            paramCache.set(at, p);
+        }
+        return p;
+    };
+    /** `skip`/`todo` from a `t.skip()` / `t.todo()` call (or mocha `this.skip()`) on the case's own callback parameter. */
+    const bodyModifier = (open, close) => {
+        const ai = lowerBound(arrows, open + 1);
+        const fi = lowerBound(fnPos, open + 1);
+        const arrow = ai < arrows.length && arrows[ai] < close ? arrows[ai] : -1;
+        const fn = fi < fnPos.length && fnPos[fi] < close ? fnPos[fi] : -1;
+        if (arrow === -1 && fn === -1)
+            return null;
+        const isArrow = fn === -1 || (arrow !== -1 && arrow < fn);
+        const names = [paramAt(isArrow ? arrow : fn, isArrow)];
+        if (!isArrow)
+            names.push('this');
+        for (const mod of ['skip', 'todo']) {
+            for (const name of names) {
+                const list = name === '' ? undefined : memberMods[mod].get(name);
+                if (list && countBetween(list, open, close) > 0)
+                    return mod;
+            }
+        }
+        return null;
+    };
+    const cases = [];
+    let unbalanced = 0;
+    let noCallback = 0;
+    for (const call of calls) {
+        const close = parenClose[call.open];
+        if (close < 0) {
+            unbalanced++;
+            continue;
+        }
+        const hasCallback = countBetween(arrows, call.open, close) > 0 || countBetween(fnPos, call.open, close) > 0;
+        if (call.modifier !== 'todo' && !hasCallback) {
+            noCallback++;
+            continue;
+        }
+        const assertions = countBetween(assertPos, call.open, close);
+        const modifier = call.modifier === 'skip' || call.modifier === 'todo' ? call.modifier
+            : (jsOptionsModifier(masked, text, call.open, close, braceClose) ?? bodyModifier(call.open, close) ?? call.modifier);
+        cases.push({
+            name: caseName(masked, text, call.open, close),
+            line: lineOf(newlines, call.at),
+            assertions,
+            tautologies: countBetween(tautPos, call.open, close),
+            state: caseState(modifier, assertions),
+        });
+    }
+    // A case the scanner could not read never disappears behind the ones it could:
+    // any dropped case makes the file `unknown`, with the readable cases still listed (T-38-14).
+    const dropped = unbalanced + noCallback + unrecognised;
+    if (cases.length > 0 && dropped === 0)
+        return { language: 'js', state: 'ok', cases };
+    if (cases.length > 0) {
+        return { language: 'js', state: 'unknown', reason: unrecognised + noCallback === 0 ? 'unbalanced' : 'unrecognised_shape', cases };
+    }
+    if (calls.length === 0 && describeTokens === 0 && unrecognised === 0)
+        return emptyScan('js', 'no_cases');
+    const shapeProblems = unrecognised + noCallback + describeTokens;
+    return emptyScan('js', 'unknown', shapeProblems === 0 && unbalanced > 0 ? 'unbalanced' : 'unrecognised_shape');
+}
+// ─── Python ───────────────────────────────────────────────────────────────────
+/**
+ * Python text with `#` comments and string contents (single, double and triple
+ * quoted, escapes honoured) blanked, delimiters and newlines kept. A one-line
+ * string ends at its newline; a triple-quoted string with no closer masks to the
+ * end of input. A prefix letter (`r`, `b`, `f`, `u`) is ordinary code.
+ */
+function maskPython(src) {
+    const n = src.length;
+    const out = toCodes(src);
+    let i = 0;
+    while (i < n) {
+        const c = src.charCodeAt(i);
+        if (c === 35) {
+            const e = src.indexOf('\n', i);
+            const end = e === -1 ? n : e;
+            blankRange(out, i, end);
+            i = end;
+            continue;
+        }
+        if (c === 39 || c === 34) {
+            if (src.charCodeAt(i + 1) === c && src.charCodeAt(i + 2) === c) {
+                let j = i + 3;
+                let closed = false;
+                while (j < n) {
+                    const cj = src.charCodeAt(j);
+                    if (cj === 92) {
+                        j += 2;
+                        continue;
+                    }
+                    if (cj === c && src.charCodeAt(j + 1) === c && src.charCodeAt(j + 2) === c) {
+                        closed = true;
+                        break;
+                    }
+                    j++;
+                }
+                const stop = j > n ? n : j;
+                blankRange(out, i + 3, stop);
+                i = closed ? stop + 3 : n;
+                continue;
+            }
+            let j = i + 1;
+            let closed = false;
+            while (j < n) {
+                const cj = src.charCodeAt(j);
+                if (cj === 92) {
+                    j += 2;
+                    continue;
+                }
+                if (cj === c) {
+                    closed = true;
+                    break;
+                }
+                if (cj === CH_NL)
+                    break;
+                j++;
+            }
+            const stop = j > n ? n : j;
+            blankRange(out, i + 1, stop);
+            i = closed ? stop + 1 : stop;
+            continue;
+        }
+        i++;
+    }
+    return fromCodes(out);
+}
+/** `[a, b)` of the masked text with its end whitespace removed. */
+function trimRange(masked, a, b) {
+    let lo = a;
+    let hi = b;
+    while (lo < hi && isSpaceCode(masked.charCodeAt(lo)))
+        lo++;
+    while (hi > lo && isSpaceCode(masked.charCodeAt(hi - 1)))
+        hi--;
+    return [lo, hi];
+}
+/** A string prefix (`r`, `b`, `u`, `f`, two at most) in front of a quote is cut from both texts. */
+function stripPyPrefix(orig, mask) {
+    let k = 0;
+    while (k < 2 && k < mask.length && 'rRbBuUfF'.includes(mask.charAt(k)))
+        k++;
+    const q = mask.charAt(k);
+    if (k > 0 && (q === '"' || q === '\''))
+        return [orig.slice(k), mask.slice(k)];
+    return [orig, mask];
+}
+function unwrapParens(orig, mask) {
+    let [o, m] = trimBoth(orig, mask);
+    for (let depth = 0; depth < 3 && wholeDelimited(m, '(', ')'); depth++) {
+        [o, m] = trimBoth(o.slice(1, -1), m.slice(1, -1));
+    }
+    return [o, m];
+}
+function isWordBefore(text, end, word) {
+    if (end < word.length || text.slice(end - word.length, end) !== word)
+        return false;
+    return end === word.length || !isIdentCode(text.charCodeAt(end - word.length - 1));
+}
+function pyOrTrue(m) {
+    if (m.endsWith('True') && (m.length === 4 || !isIdentCode(m.charCodeAt(m.length - 5)))) {
+        const before = m.slice(0, -4).trimEnd();
+        if (isWordBefore(before, before.length, 'or'))
+            return true;
+    }
+    if (m.startsWith('True') && (m.length === 4 || !isIdentCode(m.charCodeAt(4)))) {
+        const after = m.slice(4).trimStart();
+        return after.startsWith('or') && (after.length === 2 || !isIdentCode(after.charCodeAt(2)));
+    }
+    return false;
+}
+/** `True`, a non-zero number, a non-empty string, or an expression with an `or True` side. */
+function pyTruthyLiteral(orig, mask) {
+    const [o, m] = unwrapParens(orig, mask);
+    if (m === 'True')
+        return true;
+    if (isNumberLiteral(o))
+        return Number(o) !== 0;
+    const [o2, m2] = stripPyPrefix(o, m);
+    if (isQuotedLiteral(m2))
+        return o2.length > 2;
+    return pyOrTrue(m);
+}
+function pyLiteralKey(orig, mask) {
+    const [o, m] = unwrapParens(orig, mask);
+    if (m === 'True' || m === 'False' || m === 'None')
+        return `k:${m}`;
+    if (isNumberLiteral(o))
+        return `n:${Number(o)}`;
+    const [o2, m2] = stripPyPrefix(o, m);
+    if (isQuotedLiteral(m2))
+        return `s:${o2.slice(1, -1)}`;
+    return null;
+}
+const PY_EQUALITY_METHODS = new Set(['assertEqual', 'assertEquals', 'assertIs']);
+const PY_SKIP_MARKERS = ['mark.skip', 'unittest.skip', 'skipUnless', 'skipIf'];
+/** True when the unittest call `assertTrue(...)` / `assertEqual(...)` opening at `open` is a literal tautology. */
+function pyCallIsTautology(masked, text, word, open, close) {
+    if (close < 0 || close - open > MAX_TAUTOLOGY_SPAN)
+        return false;
+    if (word === 'assertTrue') {
+        const [a] = splitTopArgs(masked, open + 1, close, 1);
+        return a !== undefined && pyTruthyLiteral(text.slice(a[0], a[1]), masked.slice(a[0], a[1]));
+    }
+    if (PY_EQUALITY_METHODS.has(word)) {
+        const args = splitTopArgs(masked, open + 1, close, 2);
+        const a = args[0];
+        const b = args[1];
+        if (a === undefined || b === undefined)
+            return false;
+        const ka = pyLiteralKey(text.slice(a[0], a[1]), masked.slice(a[0], a[1]));
+        const kb = pyLiteralKey(text.slice(b[0], b[1]), masked.slice(b[0], b[1]));
+        return ka !== null && ka === kb;
+    }
+    return false;
+}
+/** `assert <expr>`: the first top-level operand of the statement, as `[start, end)`, or null when empty or too long. */
+function pyStatementOperand(masked, end) {
+    const nl = masked.indexOf('\n', end);
+    const eol = nl === -1 ? masked.length : nl;
+    const [a, b] = trimRange(masked, end, eol);
+    if (a >= b || b - a > MAX_TAUTOLOGY_SPAN)
+        return null;
+    const [first] = splitTopArgs(masked, a, b, 1);
+    return first ?? null;
+}
+function scanPython(text) {
+    const masked = maskPython(text);
+    const n = masked.length;
+    const newlines = newlineIndexes(text);
+    const lineCount = newlines.length + 1;
+    const starts = new Array(lineCount);
+    starts[0] = 0;
+    for (let k = 1; k < lineCount; k++)
+        starts[k] = newlines[k - 1] + 1;
+    const lineEnd = (k) => (k < newlines.length ? newlines[k] : n);
+    const indent = new Int32Array(lineCount);
+    const blank = new Uint8Array(lineCount);
+    const found = [];
+    const ends = [];
+    const stack = [];
+    let sawClassTest = false;
+    for (let k = 0; k < lineCount; k++) {
+        const end = lineEnd(k);
+        let p = starts[k];
+        while (p < end && (masked.charCodeAt(p) === 32 || masked.charCodeAt(p) === 9))
+            p++;
+        indent[k] = p - starts[k];
+        let onlySpace = true;
+        for (let q = p; q < end; q++) {
+            if (!isSpaceCode(masked.charCodeAt(q))) {
+                onlySpace = false;
+                break;
+            }
+        }
+        if (onlySpace) {
+            blank[k] = 1;
+            continue;
+        }
+        while (stack.length > 0 && found[stack[stack.length - 1]].indent >= indent[k]) {
+            ends[stack.pop()] = k;
+        }
+        if (masked.startsWith('class', p) && (masked.charCodeAt(p + 5) === 32 || masked.charCodeAt(p + 5) === 9)) {
+            const q = skipSpaces(masked, p + 5);
+            if (masked.startsWith('Test', q))
+                sawClassTest = true;
+            continue;
+        }
+        if (masked.startsWith('async', p) && (masked.charCodeAt(p + 5) === 32 || masked.charCodeAt(p + 5) === 9)) {
+            p = skipSpaces(masked, p + 5);
+        }
+        if (!masked.startsWith('def', p) || (masked.charCodeAt(p + 3) !== 32 && masked.charCodeAt(p + 3) !== 9))
+            continue;
+        let q = skipSpaces(masked, p + 3);
+        const nameStart = q;
+        while (q < end && isIdentCode(masked.charCodeAt(q)))
+            q++;
+        if (!masked.startsWith('test', nameStart))
+            continue;
+        let r = q;
+        while (r < end && (masked.charCodeAt(r) === 32 || masked.charCodeAt(r) === 9))
+            r++;
+        if (masked.charCodeAt(r) !== 40)
+            continue;
+        stack.push(found.length);
+        found.push({ name: masked.slice(nameStart, q), defLine: k, nameEnd: q, indent: indent[k] });
+    }
+    while (stack.length > 0)
+        ends[stack.pop()] = lineCount;
+    const parenClose = pairDelims(masked, 40, 41);
+    const assertPos = [];
+    const tautPos = [];
+    eachIdent(masked, (s, e, w) => {
+        const prev = s > 0 ? masked.charCodeAt(s - 1) : 0;
+        if (w === 'assert') {
+            let b = s - 1;
+            while (b >= 0 && (masked.charCodeAt(b) === 32 || masked.charCodeAt(b) === 9))
+                b--;
+            if (prev !== 46 && (b < 0 || masked.charCodeAt(b) === CH_NL)) {
+                const operand = pyStatementOperand(masked, e);
+                if (operand !== null
+                    && pyTruthyLiteral(text.slice(operand[0], operand[1]), masked.slice(operand[0], operand[1])))
+                    tautPos.push(s);
+                else
+                    assertPos.push(s);
+                return;
+            }
+        }
+        if (w === 'raises') {
+            const j = skipSpaces(masked, e);
+            if (masked.charCodeAt(j) === 40 && s >= 7 && masked.slice(s - 7, s) === 'pytest.')
+                assertPos.push(s);
+            return;
+        }
+        if (isAssertHelperName(w)) {
+            const j = skipSpaces(masked, e);
+            if (masked.charCodeAt(j) !== 40 || precededByWord(masked, s, 'def'))
+                return;
+            if (pyCallIsTautology(masked, text, w, j, parenClose[j]))
+                tautPos.push(s);
+            else
+                assertPos.push(s);
+        }
+    });
+    const cases = [];
+    found.forEach((c, idx) => {
+        const lo = c.nameEnd;
+        const endLine = ends[idx];
+        const hi = endLine >= lineCount ? n : starts[endLine];
+        const assertions = countBetween(assertPos, lo, hi);
+        let skipped = false;
+        for (let k = c.defLine - 1; k >= 0 && !skipped && blank[k] === 0; k--) {
+            const at = starts[k] + indent[k];
+            if (masked.charCodeAt(at) !== 64)
+                break;
+            const deco = masked.slice(at, lineEnd(k));
+            skipped = PY_SKIP_MARKERS.some((marker) => deco.includes(marker));
+        }
+        cases.push({
+            name: quoted(c.name),
+            line: c.defLine + 1,
+            assertions,
+            tautologies: countBetween(tautPos, lo, hi),
+            state: caseState(skipped ? 'skip' : null, assertions),
+        });
+    });
+    if (cases.length > 0)
+        return { language: 'python', state: 'ok', cases };
+    if (!sawClassTest)
+        return emptyScan('python', 'no_cases');
+    return emptyScan('python', 'unknown', 'unrecognised_shape');
+}
+// ─── Go ───────────────────────────────────────────────────────────────────────
+/**
+ * Go text with `//` and block comments blanked and the contents of double-quoted
+ * strings, rune literals and backtick raw strings blanked; delimiters and newlines
+ * kept. A quote or rune ends at its newline; a block comment or raw string with no
+ * closer masks to the end of input.
+ */
+function maskGo(src) {
+    const n = src.length;
+    const out = toCodes(src);
+    let i = 0;
+    while (i < n) {
+        const c = src.charCodeAt(i);
+        if (c === 47) {
+            const next = src.charCodeAt(i + 1);
+            if (next === 47) {
+                const e = src.indexOf('\n', i);
+                const end = e === -1 ? n : e;
+                blankRange(out, i, end);
+                i = end;
+                continue;
+            }
+            if (next === 42) {
+                const e = src.indexOf('*/', i + 2);
+                const end = e === -1 ? n : e + 2;
+                blankRange(out, i, end);
+                i = end;
+                continue;
+            }
+            i++;
+            continue;
+        }
+        if (c === 34 || c === 39) {
+            let j = i + 1;
+            let closed = false;
+            while (j < n) {
+                const cj = src.charCodeAt(j);
+                if (cj === 92) {
+                    j += 2;
+                    continue;
+                }
+                if (cj === c) {
+                    closed = true;
+                    break;
+                }
+                if (cj === CH_NL)
+                    break;
+                j++;
+            }
+            const stop = j > n ? n : j;
+            blankRange(out, i + 1, stop);
+            i = closed ? stop + 1 : stop;
+            continue;
+        }
+        if (c === 96) {
+            const e = src.indexOf('`', i + 1);
+            const stop = e === -1 ? n : e;
+            blankRange(out, i + 1, stop);
+            i = e === -1 ? n : e + 1;
+            continue;
+        }
+        i++;
+    }
+    return fromCodes(out);
+}
+function goLiteralKey(orig, mask) {
+    const [o, m] = trimBoth(orig, mask);
+    if (m === 'true' || m === 'false' || m === 'nil')
+        return `k:${m}`;
+    if (isNumberLiteral(o))
+        return `n:${Number(o)}`;
+    if (isQuotedLiteral(m, '"`\''))
+        return `s:${o.slice(1, -1)}`;
+    return null;
+}
+const GO_RECEIVER_ASSERTIONS = new Set(['Error', 'Errorf', 'Fatal', 'Fatalf', 'Fail', 'FailNow']);
+const GO_RECEIVER_SKIPS = new Set(['Skip', 'Skipf', 'SkipNow']);
+const GO_EQUALITY_METHODS = new Set(['Equal', 'EqualValues']);
+/** `.Name(` after the identifier ending at `end`: the member name and its open paren, or null. */
+function readMemberCall(masked, end) {
+    const j = skipSpaces(masked, end);
+    if (masked.charCodeAt(j) !== 46)
+        return null;
+    const k = skipSpaces(masked, j + 1);
+    let m = k;
+    while (m < masked.length && isIdentCode(masked.charCodeAt(m)))
+        m++;
+    if (m === k)
+        return null;
+    const open = skipSpaces(masked, m);
+    if (masked.charCodeAt(open) !== 40)
+        return null;
+    return { name: masked.slice(k, m), open };
+}
+/** The identifier that ends just before `at` (whitespace skipped), or ''. */
+function identBefore(masked, at) {
+    let j = at - 1;
+    while (j >= 0 && isSpaceCode(masked.charCodeAt(j)))
+        j--;
+    const end = j + 1;
+    while (j >= 0 && isIdentCode(masked.charCodeAt(j)))
+        j--;
+    return masked.slice(j + 1, end);
+}
+/** Testify `assert.X(t, ...)` / `require.X(t, ...)`: True(t, true) and Equal(t, lit, same lit) pass whatever the code does. */
+function goTestifyIsTautology(masked, text, name, open, close) {
+    if (close < 0 || close - open > MAX_TAUTOLOGY_SPAN)
+        return false;
+    const args = splitTopArgs(masked, open + 1, close, 3);
+    if (name === 'True') {
+        const a = args[1];
+        return a !== undefined && trimBoth(text.slice(a[0], a[1]), masked.slice(a[0], a[1]))[1] === 'true';
+    }
+    if (GO_EQUALITY_METHODS.has(name)) {
+        const a = args[1];
+        const b = args[2];
+        if (a === undefined || b === undefined)
+            return false;
+        const ka = goLiteralKey(text.slice(a[0], a[1]), masked.slice(a[0], a[1]));
+        const kb = goLiteralKey(text.slice(b[0], b[1]), masked.slice(b[0], b[1]));
+        return ka !== null && ka === kb;
+    }
+    return false;
+}
+/** The receiver name of `(<name> *testing.T)` parameters, or null for any other signature. */
+function goTestReceiver(masked, open, close) {
+    if (close < 0 || close - open > 300)
+        return null;
+    const inner = masked.slice(open + 1, close);
+    const m = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*\*\s*testing\.T\s*$/.exec(inner);
+    return m ? (m[1] ?? null) : null;
+}
+function scanGo(text) {
+    const masked = maskGo(text);
+    const n = masked.length;
+    const newlines = newlineIndexes(text);
+    const braceClose = pairDelims(masked, 123, 125);
+    const parenClose = pairDelims(masked, 40, 41);
+    const receivers = new Set();
+    const testifyObjects = new Set();
+    const found = [];
+    let testTokens = 0;
+    let unbalanced = 0;
+    eachIdent(masked, (s, e, w) => {
+        if (w === 'testing') {
+            const j = skipSpaces(masked, e);
+            if (masked.charCodeAt(j) === 46) {
+                const k = skipSpaces(masked, j + 1);
+                let m = k;
+                while (m < n && isIdentCode(masked.charCodeAt(m)))
+                    m++;
+                const kind = masked.slice(k, m);
+                if (kind === 'T' || kind === 'TB' || kind === 'B') {
+                    let b = s - 1;
+                    while (b >= 0 && isSpaceCode(masked.charCodeAt(b)))
+                        b--;
+                    if (b >= 0 && masked.charCodeAt(b) === 42)
+                        b--;
+                    const name = identBefore(masked, b + 1);
+                    if (name !== '')
+                        receivers.add(name);
+                }
+            }
+            return;
+        }
+        if (w === 'assert' || w === 'require') {
+            const call = readMemberCall(masked, e);
+            if (call !== null && call.name === 'New') {
+                let b = s - 1;
+                while (b >= 0 && isSpaceCode(masked.charCodeAt(b)))
+                    b--;
+                if (b >= 0 && masked.charCodeAt(b) === 61) {
+                    b--;
+                    if (b >= 0 && masked.charCodeAt(b) === 58)
+                        b--;
+                    const name = identBefore(masked, b + 1);
+                    if (name !== '')
+                        testifyObjects.add(name);
+                }
+            }
+            return;
+        }
+        if (w !== 'func')
+            return;
+        let j = skipSpaces(masked, e);
+        if (masked.charCodeAt(j) === 40) {
+            const pc = parenClose[j];
+            if (pc < 0)
+                return;
+            j = skipSpaces(masked, pc + 1);
+            let m = j;
+            while (m < n && isIdentCode(masked.charCodeAt(m)))
+                m++;
+            const method = masked.slice(j, m);
+            if (method.startsWith('Test') && method !== 'TestMain' && masked.charCodeAt(skipSpaces(masked, m)) === 40)
+                testTokens++;
+            return;
+        }
+        let m = j;
+        while (m < n && isIdentCode(masked.charCodeAt(m)))
+            m++;
+        const fn = masked.slice(j, m);
+        if (!fn.startsWith('Test') || fn === 'TestMain')
+            return;
+        const open = skipSpaces(masked, m);
+        if (masked.charCodeAt(open) !== 40)
+            return;
+        testTokens++;
+        const recv = goTestReceiver(masked, open, parenClose[open]);
+        if (recv === null)
+            return;
+        const brace = skipSpaces(masked, parenClose[open] + 1);
+        if (masked.charCodeAt(brace) !== 123)
+            return;
+        if (braceClose[brace] < 0) {
+            unbalanced++;
+            return;
+        }
+        receivers.add(recv);
+        found.push({ name: fn, at: j, open: brace });
+    });
+    const assertPos = [];
+    const tautPos = [];
+    const skipPos = [];
+    eachIdent(masked, (s, e, w) => {
+        const afterDot = s > 0 && masked.charCodeAt(s - 1) === 46;
+        if (receivers.has(w) && !afterDot) {
+            const call = readMemberCall(masked, e);
+            if (call === null)
+                return;
+            if (GO_RECEIVER_ASSERTIONS.has(call.name))
+                assertPos.push(s);
+            else if (GO_RECEIVER_SKIPS.has(call.name))
+                skipPos.push(s);
+            return;
+        }
+        if ((w === 'assert' || w === 'require') && !afterDot) {
+            const call = readMemberCall(masked, e);
+            if (call !== null) {
+                if (call.name === 'New')
+                    return;
+                if (goTestifyIsTautology(masked, text, call.name, call.open, parenClose[call.open]))
+                    tautPos.push(s);
+                else
+                    assertPos.push(s);
+                return;
+            }
+        }
+        if (testifyObjects.has(w) && !afterDot) {
+            if (readMemberCall(masked, e) !== null)
+                assertPos.push(s);
+            return;
+        }
+        if (isAssertHelperName(w)) {
+            const j = skipSpaces(masked, e);
+            if (masked.charCodeAt(j) === 40 && !precededByWord(masked, s, 'func'))
+                assertPos.push(s);
+        }
+    });
+    const cases = found.map((c) => {
+        const close = braceClose[c.open];
+        const assertions = countBetween(assertPos, c.open, close);
+        return {
+            name: quoted(c.name),
+            line: lineOf(newlines, c.at),
+            assertions,
+            tautologies: countBetween(tautPos, c.open, close),
+            state: caseState(countBetween(skipPos, c.open, close) > 0 ? 'skip' : null, assertions),
+        };
+    });
+    // Every `Test*` token that did not become a case (a suite method, another
+    // signature, an unpaired brace) makes the file `unknown`, cases still listed (T-38-14).
+    const dropped = testTokens - found.length;
+    if (cases.length > 0 && dropped === 0)
+        return { language: 'go', state: 'ok', cases };
+    if (cases.length > 0) {
+        return { language: 'go', state: 'unknown', reason: unbalanced === dropped ? 'unbalanced' : 'unrecognised_shape', cases };
+    }
+    if (testTokens === 0)
+        return emptyScan('go', 'no_cases');
+    return emptyScan('go', 'unknown', unbalanced > 0 && unbalanced === testTokens ? 'unbalanced' : 'unrecognised_shape');
+}
+// ─── Dispatch ─────────────────────────────────────────────────────────────────
+/**
+ * Per-case assertion counts of one test file's text. Over MAX_SCAN_FILE_BYTES
+ * characters, another language, or a scanner failure is `unknown`; a file with no
+ * test case token is `no_cases`; `ok` only when at least one case was found.
+ */
+function scanTestSource(text, language) {
+    if (language !== 'js' && language !== 'python' && language !== 'go') {
+        return emptyScan('unknown', 'unknown', 'unsupported_language');
+    }
+    if (typeof text !== 'string')
+        return emptyScan(language, 'unknown', 'unreadable');
+    if (text.length > exports.MAX_SCAN_FILE_BYTES)
+        return emptyScan(language, 'unknown', 'over_cap');
+    try {
+        if (language === 'js')
+            return scanJs(text);
+        if (language === 'python')
+            return scanPython(text);
+        return scanGo(text);
+    }
+    catch {
+        return emptyScan(language, 'unknown', 'unrecognised_shape');
+    }
+}
+/** A file path echoed to an agent: posix separators, sanitized and cut. */
+function displayPath(p) {
+    return quoted(p.split('\\').join('/'), 200);
+}
+function unknownFile(file, language, reason) {
+    return {
+        file, language, state: 'unknown', reason, cases_total: 0, asserting: 0, asserts_nothing_total: 0,
+        skip_total: 0, asserts_nothing: [], skipped: [], truncated: false,
+    };
+}
+function toFileScan(file, scan) {
+    const nothing = scan.cases.filter((c) => c.state === 'asserts_nothing' || c.state === 'todo');
+    const skipped = scan.cases.filter((c) => c.state === 'skip');
+    const out = {
+        file,
+        language: scan.language,
+        state: scan.state,
+        cases_total: scan.cases.length,
+        asserting: scan.cases.filter((c) => c.state === 'asserts').length,
+        asserts_nothing_total: nothing.length,
+        skip_total: skipped.length,
+        asserts_nothing: nothing.slice(0, exports.MAX_LISTED_CASES).map((c) => ({
+            name: c.name, line: c.line, state: c.state === 'todo' ? 'todo' : 'asserts_nothing',
+        })),
+        skipped: skipped.slice(0, exports.MAX_LISTED_CASES).map((c) => ({ name: c.name, line: c.line })),
+        truncated: nothing.length > exports.MAX_LISTED_CASES || skipped.length > exports.MAX_LISTED_CASES,
+    };
+    if (scan.reason)
+        out.reason = scan.reason;
+    return out;
+}
+/** True when a relative path leaves its root (`..`, `../x`) or is on another drive. */
+function leavesRoot(rel) {
+    return rel === '..' || rel.startsWith(`..${node_path_1.default.sep}`) || node_path_1.default.isAbsolute(rel);
+}
+function errorCode(err) {
+    return err !== null && typeof err === 'object' && 'code' in err ? String(err.code) : '';
+}
+/**
+ * Scan one test file for the project at `projectDir`. The path is resolved against
+ * the project root and must stay inside it twice: lexically, then after
+ * `fs.realpathSync` of both sides so a symlink cannot escape (T-38-10). It must be a
+ * regular file within MAX_SCAN_FILE_BYTES, checked by `stat` before any read
+ * (T-38-11). The file is read as text and never executed (T-38-13).
+ */
+function scanTestFile(projectDir, file) {
+    const raw = String(file);
+    const language = languageOf(raw);
+    const root = node_path_1.default.resolve(projectDir);
+    const abs = node_path_1.default.resolve(root, raw);
+    const rel = node_path_1.default.relative(root, abs);
+    const shown = displayPath(rel);
+    if (leavesRoot(rel))
+        return unknownFile(shown, language, 'outside_project');
+    let real;
+    let realRoot;
+    try {
+        realRoot = node_fs_1.default.realpathSync(root);
+        real = node_fs_1.default.realpathSync(abs);
+    }
+    catch (err) {
+        const code = errorCode(err);
+        return unknownFile(shown, language, code === 'ENOENT' || code === 'ENOTDIR' ? 'not_found' : 'unreadable');
+    }
+    if (leavesRoot(node_path_1.default.relative(realRoot, real)))
+        return unknownFile(shown, language, 'outside_project');
+    let size = 0;
+    try {
+        const stat = node_fs_1.default.statSync(real);
+        if (!stat.isFile())
+            return unknownFile(shown, language, 'not_regular_file');
+        size = stat.size;
+    }
+    catch {
+        return unknownFile(shown, language, 'unreadable');
+    }
+    if (size > exports.MAX_SCAN_FILE_BYTES)
+        return unknownFile(shown, language, 'over_cap');
+    if (language === 'unknown')
+        return unknownFile(shown, language, 'unsupported_language');
+    let text;
+    try {
+        text = node_fs_1.default.readFileSync(real, 'utf8');
+    }
+    catch {
+        return unknownFile(shown, language, 'unreadable');
+    }
+    return toFileScan(shown, scanTestSource(text, language));
+}
+/**
+ * Scan several test files. The first MAX_SCAN_FILES are scanned; the rest report
+ * `unknown` / `over_file_cap`. The totals are exact; the per-file lists are capped.
+ */
+function scanTestFiles(projectDir, files) {
+    const list = Array.isArray(files) ? files : [];
+    const scanned = list.map((f, i) => (i < exports.MAX_SCAN_FILES
+        ? scanTestFile(projectDir, f)
+        : unknownFile(displayPath(String(f)), languageOf(String(f)), 'over_file_cap')));
+    const sum = (pick) => scanned.reduce((n, f) => n + pick(f), 0);
+    return {
+        mode: 'scan',
+        files: scanned,
+        totals: {
+            files: scanned.length,
+            cases: sum((f) => f.cases_total),
+            asserts_nothing: sum((f) => f.asserts_nothing_total),
+            skipped: sum((f) => f.skip_total),
+            unknown_files: sum((f) => (f.state === 'unknown' ? 1 : 0)),
+            no_case_files: sum((f) => (f.state === 'no_cases' ? 1 : 0)),
+        },
+    };
+}