@mjasnikovs/pi-task 0.29.1 → 0.29.3

package/dist/task/auto-orchestrator.js

@@ -45,7 +45,8 @@ import { CONTRACT_EXTRACT_PROMPT, parseContractLines, keepGroundedContracts, app
 import { reconcileTitleSources } from './decompose-fidelity.js';
 import { granularityFloor, granularitySplitHint, isPlanShapeQuestion, isTooCoarse, planShapeIsHostsToAnswer, PLAN_SHAPE_ANSWER } from './decompose-granularity.js';
 import { mandatesTestsInSameChange, rewriteBatchTestPlan } from './batch-test-task.js';
-import { REQUIREMENT_EXTRACT_PROMPT, COVERAGE_MAP_PROMPT, parseRequirementLines, keepGroundedRequirements, capRequirements, writeOwnedRequirements, enumerateObligationPassages, uncoveredPassages, extractionRetryHint, parseCoverageMap, accountCoverage, isCrossCuttingRequirement, appendCarriedRequirements, buildRequirementsLedger } from './requirements.js';
+import { REQUIREMENT_EXTRACT_PROMPT, COVERAGE_MAP_PROMPT, parseRequirementLines, keepGroundedRequirements, capRequirements, writeOwnedRequirements, enumerateObligationPassages, uncoveredPassages, extractionRetryHint, parseCoverageMap, accountCoverage, isCrossCuttingRequirement, appendCarriedRequirements, buildRequirementsLedger, readOwnedRequirements } from './requirements.js';
+import { unclaimedPendingRequirements } from './owned-freeze-reassign.js';
 import { decideAdoption, groundedCoverage } from './coverage-loop.js';
 import { findSpecDanglingArtifacts, titlesCoverArtifact, danglingMissingText, danglingCarryText } from './artifact-closure.js';
 import { LAUNCH_EXTRACT_PROMPT, enumerateScriptCandidates, parseScriptLines, keepGroundedScripts, appendDeclaredScripts } from './launch-contract.js';
@@ -1239,6 +1240,22 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                     // compared against it rather than blindly re-printed.
                     let reportedDebts = fin.openDebts ?? [];
                     await surfaceOpenDebts(reportedDebts);
+                    // An owned obligation a task DETACHED (its own spec froze the
+                    // only file that could satisfy it, nexttask 2) and no later
+                    // task claimed. Detach never deletes the quote, so the run
+                    // ends holding it — say so, or the resolution would be a
+                    // quieter version of the deletion it exists to prevent.
+                    const unclaimed = unclaimedPendingRequirements(await readOwnedRequirements(cwd).catch(() => []));
+                    for (const o of unclaimed) {
+                        await recGate(`owned requirement UNCLAIMED — "${o.quote.slice(0, 200)}"`
+                            + ` [frozen in "${o.title.slice(0, 60)}"; no task claimed`
+                            + ` ${(o.pending ?? []).join(', ')}]`);
+                    }
+                    if (unclaimed.length > 0) {
+                        active.ui.notify(`${id}: ${unclaimed.length} authoritative design requirement(s) ended the run`
+                            + ' owned by NO task — the task they were mapped to could not touch the'
+                            + ' file, and nothing else claimed it. See the gate trail.', 'warning');
+                    }
                     /**
                      * nexttask 6 (mx5 run 18). The lines above are emitted from the
                      * FIRST gate result; the converged-autofix paths below used to

package/dist/task/command-shrink.d.ts

@@ -0,0 +1,105 @@
+/**
+ * SCOPE-SHRINK detection for the final-gate fix pass.
+ *
+ * The label guard (final-gate-fix.ts) compares the SET of discoverable gate
+ * commands before and after the fix child. mx5 run 19 walked straight through
+ * it: the autofix rewrote `"test": "AGENT=1 bun test"` to
+ * `"AGENT=1 bun test ./test"`, the label `bun run test` existed before and
+ * after, the set difference was empty, and the gate re-ran a suite that no
+ * longer covered the repository — then reported "autofix converged".
+ *
+ * What changed was not the command's NAME but its SCOPE. This module compares
+ * the RESOLVED BODIES (`scripts[name]` for package.json, the recipe lines for a
+ * Makefile target) and classifies each change as narrow / widen / neutral.
+ *
+ * A narrowing is defined MECHANICALLY, four shapes only:
+ *   1. a path/glob argument is ADDED to a command member that had none
+ *      (`bun test` → `bun test ./test`);
+ *   2. an existing path/glob argument is replaced by a strict SUBPATH of itself
+ *      (`eslint src` → `eslint src/server`);
+ *   3. an exclusion flag/pattern is ADDED (`--ignore`, `--exclude`,
+ *      `--testPathIgnorePatterns`, `-x`, …);
+ *   4. a config-file argument is swapped for one the fix pass itself created.
+ *
+ * With ONE excuse, measured on mx5@a9c6145 and documented at
+ * `excusedByRelocation`: rule 3 does not fire when the same pass hands the
+ * excluded input to another command the gate already runs.
+ *
+ * Everything else passes: new env vars, added flags that do not restrict the
+ * input set, reordering, added chain members, whole new scripts. The guard's
+ * job is to stop the fix pass from silently redefining the gate's own success
+ * criterion — not to review the fix.
+ *
+ * PURE by construction (no fs, no git): the live guard feeds it two body maps
+ * from `discoverGateCommandBodies`, the replay harness feeds it two maps built
+ * from git blobs. Same code decides both.
+ */
+/** Which of the four mechanical shapes fired. */
+export type ShrinkKind = 'path-added' | 'path-narrowed' | 'exclusion-added' | 'config-swapped';
+export type BodyChangeClass = 'narrow' | 'widen' | 'neutral';
+export interface BodyChange {
+    cls: BodyChangeClass;
+    /** Every narrowing shape found (empty unless cls === 'narrow'). */
+    kinds: ShrinkKind[];
+    /** Human-readable one-liners, most specific first. */
+    reasons: string[];
+    /** Non-deciding observations (e.g. a chain member disappeared) — reported by
+     *  the base-rate harness, never a rejection on their own. */
+    notes: string[];
+}
+export interface ShrinkEnv {
+    /** Did the fix pass itself CREATE this path? Powers rule 4 only. Absent →
+     *  rule 4 is inert (a config swap with no provenance is not evidence). */
+    createdByFix?: (p: string) => boolean;
+    /** The resolved bodies of the OTHER gate commands after the pass. Powers the
+     *  RELOCATION excuse on rule 3 (see excusedByRelocation). Absent → no
+     *  exclusion is ever excused. */
+    siblingBodies?: string[];
+}
+export interface Narrowing {
+    /** The gate command label whose body narrowed (`bun run test`). */
+    label: string;
+    before: string;
+    after: string;
+    kinds: ShrinkKind[];
+    reasons: string[];
+}
+/** Split a shell body into chain members, quote-aware: `&&`, `||`, `;`, `|`,
+ *  and newlines (Makefile recipes arrive as multiple lines). */
+export declare function splitChainMembers(body: string): string[];
+/** Is this token SYNTACTICALLY a path or glob? Deliberately lexical: no fs. */
+export declare function looksLikePath(tok: string): boolean;
+interface MemberShape {
+    /** Alignment key: `bin verb` (`bun test`, `bun run lint`, `eslint`). */
+    key: string;
+    /** Path/glob arguments, excluding flag values. */
+    paths: string[];
+    /** Every flag seen, normalized to its name (`--ignore=x` → `--ignore`). */
+    flags: Set<string>;
+    /** Value-flag name → its value (last wins). */
+    flagValues: Map<string, string>;
+    text: string;
+}
+/** Decompose one chain member into the shape the rules compare. */
+export declare function shapeMember(member: string): MemberShape;
+/** Is `child` strictly INSIDE `parent`? (`''` is the repo root.) */
+export declare function isStrictSubpath(parent: string, child: string): boolean;
+/**
+ * The recipe lines of `target:` in a Makefile, joined by newlines (which
+ * splitChainMembers treats as member separators), or null when the target has
+ * no rule. Continuations (`\` at end of line) are folded into one line.
+ */
+export declare function makefileRecipe(makefileText: string, target: string): string | null;
+/**
+ * Classify one command body change. Deterministic, no side conditions beyond
+ * the optional `createdByFix` provenance used by rule 4.
+ */
+export declare function classifyBodyChange(before: string, after: string, env?: ShrinkEnv): BodyChange;
+/**
+ * Every gate command whose resolved body NARROWED across the fix pass. Labels
+ * present on only one side are the label guard's business, not this one's.
+ */
+export declare function findNarrowedCommands(before: Record<string, string>, after: Record<string, string>, env?: ShrinkEnv): Narrowing[];
+/** One-line rejection text for the guard and the log. */
+export declare function narrowingRejectionText(narrowed: Narrowing[]): string;
+export {};

package/dist/task/command-shrink.js

@@ -0,0 +1,410 @@
+/**
+ * SCOPE-SHRINK detection for the final-gate fix pass.
+ *
+ * The label guard (final-gate-fix.ts) compares the SET of discoverable gate
+ * commands before and after the fix child. mx5 run 19 walked straight through
+ * it: the autofix rewrote `"test": "AGENT=1 bun test"` to
+ * `"AGENT=1 bun test ./test"`, the label `bun run test` existed before and
+ * after, the set difference was empty, and the gate re-ran a suite that no
+ * longer covered the repository — then reported "autofix converged".
+ *
+ * What changed was not the command's NAME but its SCOPE. This module compares
+ * the RESOLVED BODIES (`scripts[name]` for package.json, the recipe lines for a
+ * Makefile target) and classifies each change as narrow / widen / neutral.
+ *
+ * A narrowing is defined MECHANICALLY, four shapes only:
+ *   1. a path/glob argument is ADDED to a command member that had none
+ *      (`bun test` → `bun test ./test`);
+ *   2. an existing path/glob argument is replaced by a strict SUBPATH of itself
+ *      (`eslint src` → `eslint src/server`);
+ *   3. an exclusion flag/pattern is ADDED (`--ignore`, `--exclude`,
+ *      `--testPathIgnorePatterns`, `-x`, …);
+ *   4. a config-file argument is swapped for one the fix pass itself created.
+ *
+ * With ONE excuse, measured on mx5@a9c6145 and documented at
+ * `excusedByRelocation`: rule 3 does not fire when the same pass hands the
+ * excluded input to another command the gate already runs.
+ *
+ * Everything else passes: new env vars, added flags that do not restrict the
+ * input set, reordering, added chain members, whole new scripts. The guard's
+ * job is to stop the fix pass from silently redefining the gate's own success
+ * criterion — not to review the fix.
+ *
+ * PURE by construction (no fs, no git): the live guard feeds it two body maps
+ * from `discoverGateCommandBodies`, the replay harness feeds it two maps built
+ * from git blobs. Same code decides both.
+ */
+// ── tokenizing ──────────────────────────────────────────────────────────────
+/** Split a shell body into chain members, quote-aware: `&&`, `||`, `;`, `|`,
+ *  and newlines (Makefile recipes arrive as multiple lines). */
+export function splitChainMembers(body) {
+    const out = [];
+    let cur = '';
+    let quote = null;
+    for (let i = 0; i < body.length; i++) {
+        const c = body[i];
+        if (quote) {
+            cur += c;
+            if (c === quote && body[i - 1] !== '\\')
+                quote = null;
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            quote = c;
+            cur += c;
+            continue;
+        }
+        if (c === '\n' || c === ';') {
+            out.push(cur);
+            cur = '';
+            continue;
+        }
+        if ((c === '&' || c === '|') && body[i + 1] === c) {
+            out.push(cur);
+            cur = '';
+            i++;
+            continue;
+        }
+        if (c === '|') {
+            out.push(cur);
+            cur = '';
+            continue;
+        }
+        cur += c;
+    }
+    out.push(cur);
+    return out.map(s => s.trim()).filter(s => s.length > 0);
+}
+/** Quote-aware word split; surrounding quotes are stripped from each token. */
+function tokenize(member) {
+    const out = [];
+    let cur = '';
+    let quote = null;
+    let started = false;
+    for (let i = 0; i < member.length; i++) {
+        const c = member[i];
+        if (quote) {
+            if (c === quote && member[i - 1] !== '\\')
+                quote = null;
+            else
+                cur += c;
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            quote = c;
+            started = true;
+            continue;
+        }
+        if (/\s/.test(c)) {
+            if (started || cur.length > 0)
+                out.push(cur);
+            cur = '';
+            started = false;
+            continue;
+        }
+        cur += c;
+    }
+    if (started || cur.length > 0)
+        out.push(cur);
+    return out;
+}
+/** Leading `FOO=bar` env assignments and `sudo`/`exec`/`env`/`time` wrappers,
+ *  and a Makefile recipe's `@`/`-`/`+` prefix, carry no verb. */
+function stripPrefixes(tokens) {
+    const t = [...tokens];
+    if (t.length > 0)
+        t[0] = t[0].replace(/^[@\-+]+(?=[A-Za-z_./])/, '');
+    while (t.length > 0
+        && (/^[A-Za-z_][A-Za-z0-9_]*=/.test(t[0]) || /^(?:sudo|exec|env|time|nice)$/.test(t[0]))) {
+        t.shift();
+    }
+    return t;
+}
+// ── argument classification ─────────────────────────────────────────────────
+const GLOB_RE = /[*?[\]{}]/;
+/** A conservative source/config extension set — enough to catch a bare file
+ *  argument (`jest.config.js`) without calling `--log-level 1.2` a path. */
+const EXT_RE = /\.(?:[cm]?[jt]sx?|json|jsonc|toml|ya?ml|md|html?|css|scss|py|go|rs|rb|java|kt|swift|c|cc|cpp|h|hpp|sh|sql|lock|cfg|ini|conf|xml|txt)$/i;
+/** Is this token SYNTACTICALLY a path or glob? Deliberately lexical: no fs. */
+export function looksLikePath(tok) {
+    if (tok.length === 0)
+        return false;
+    if (tok === '.' || tok === '..')
+        return true;
+    if (tok.startsWith('-'))
+        return false;
+    return tok.includes('/') || tok.includes('\\') || GLOB_RE.test(tok) || EXT_RE.test(tok);
+}
+const RUNNER_RE = /^(?:bun|bunx|npm|npx|pnpm|pnpx|yarn|deno|node|make|cargo|go|uv|poetry|pipenv)$/;
+const RUN_VERB_RE = /^(?:run|run-script|exec|dlx|x|task)$/;
+/** Flags whose next token is their VALUE (so it is not itself a path argument).
+ *  Every exclusion flag that takes a PATTERN belongs here too — otherwise
+ *  `mocha -x slow` reads as a path argument as well as an exclusion. The
+ *  boolean-ish exclusions (`--skip`, `--no-tests`) are deliberately absent: they
+ *  take no value, and consuming the next token would swallow a real path. */
+const VALUE_FLAG_RE = /^--?(?:config|configfile|config-file|c|project|tsconfig|ignore|ignores|ignore-pattern|ignore-patterns|ignore-path|ignorePath|exclude|excludes|excludePattern|testPathIgnorePatterns|path-ignore-patterns|deselect|x|reporter|log-level|loglevel|outdir|outfile|out|target|env-file)$/;
+/** Flags that REMOVE input from the command's set. Adding one narrows scope. */
+const EXCLUSION_FLAG_RE = /^--?(?:ignore|ignores|ignore-pattern|ignore-patterns|ignore-path|ignorePath|exclude|excludes|excludePattern|testPathIgnorePatterns|path-ignore-patterns|deselect|skip|skip-tests|no-tests|x)$/;
+/** Flags that point the command at a configuration file. */
+const CONFIG_FLAG_RE = /^--?(?:config|configfile|config-file|c|project|tsconfig)$/;
+/** Decompose one chain member into the shape the rules compare. */
+export function shapeMember(member) {
+    const tokens = stripPrefixes(tokenize(member));
+    const shape = {
+        key: '',
+        paths: [],
+        flags: new Set(),
+        flagValues: new Map(),
+        text: member.trim()
+    };
+    if (tokens.length === 0)
+        return shape;
+    const bin = basename(tokens[0]);
+    shape.key = bin;
+    let verb = '';
+    for (let i = 1; i < tokens.length; i++) {
+        const tok = tokens[i];
+        if (tok.startsWith('-') && tok.length > 1) {
+            const eq = tok.indexOf('=');
+            const name = eq >= 0 ? tok.slice(0, eq) : tok;
+            shape.flags.add(name);
+            if (eq >= 0) {
+                shape.flagValues.set(name, tok.slice(eq + 1));
+            }
+            else if (VALUE_FLAG_RE.test(name) && i + 1 < tokens.length) {
+                shape.flagValues.set(name, tokens[i + 1]);
+                i++;
+            }
+            continue;
+        }
+        // The verb slot — the token IMMEDIATELY after the bin (`bun TEST …`,
+        // `ruff CHECK .`) — and, for a runner, the script-name slot after it
+        // (`bun run TEST`) name a target, not a path, unless written as one
+        // (`bun run src/x.ts`). Both ride in the alignment key instead. The slot
+        // is POSITIONAL on purpose: making it "the first non-flag token" would
+        // swallow the first path of `eslint --fix src`, and then reading a
+        // second one (`eslint --fix src tests`) as a scope shrink — measured as
+        // a false positive on dace-pro@45b6fa0.
+        if (!looksLikePath(tok)) {
+            if (i === 1) {
+                verb = tok;
+                shape.key = `${bin} ${tok}`;
+                continue;
+            }
+            if (i === 2 && verb !== '' && RUNNER_RE.test(bin) && RUN_VERB_RE.test(verb)) {
+                shape.key = `${bin} ${verb} ${tok}`;
+                continue;
+            }
+            // A BARE word elsewhere is a filter/path argument (`bun test test`,
+            // `pytest -q tests`) — without this the guard's own lead is one
+            // keystroke from a dodge, since `bun test ./test` and `bun test
+            // test` do the same thing. Numbers and booleans are flag values, not
+            // paths (`jest --maxWorkers 2`).
+            if (!/^(?:[\d.]+|true|false)$/.test(tok))
+                shape.paths.push(tok);
+            continue;
+        }
+        shape.paths.push(tok);
+    }
+    return shape;
+}
+function basename(p) {
+    const i = Math.max(p.lastIndexOf('/'), p.lastIndexOf('\\'));
+    return i >= 0 ? p.slice(i + 1) : p;
+}
+/** Normalized comparable form: drop `./`, trailing `/`, and everything from the
+ *  first glob metacharacter on (so `src/**\/*.ts` compares as `src/`). */
+function pathPrefix(p) {
+    let s = p.replace(/\\/g, '/');
+    const g = s.search(GLOB_RE);
+    if (g >= 0)
+        s = s.slice(0, g);
+    s = s.replace(/^\.\//, '').replace(/\/+$/, '');
+    if (s === '.' || s === '')
+        return '';
+    return s;
+}
+/** Is `child` strictly INSIDE `parent`? (`''` is the repo root.) */
+export function isStrictSubpath(parent, child) {
+    const a = pathPrefix(parent);
+    const b = pathPrefix(child);
+    if (a === b)
+        return false;
+    if (a === '')
+        return b.length > 0;
+    return b.startsWith(`${a}/`);
+}
+/**
+ * The recipe lines of `target:` in a Makefile, joined by newlines (which
+ * splitChainMembers treats as member separators), or null when the target has
+ * no rule. Continuations (`\` at end of line) are folded into one line.
+ */
+export function makefileRecipe(makefileText, target) {
+    const lines = makefileText.split(/\r?\n/);
+    const head = new RegExp(`^${target.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*:(?!=)`);
+    let i = lines.findIndex(l => head.test(l));
+    if (i < 0)
+        return null;
+    const recipe = [];
+    for (i++; i < lines.length; i++) {
+        const l = lines[i];
+        if (l.trim() === '' || l.startsWith('#'))
+            continue;
+        if (!/^\t/.test(l))
+            break;
+        let cur = l.replace(/^\t+/, '');
+        while (/\\$/.test(cur) && i + 1 < lines.length) {
+            cur = `${cur.replace(/\\$/, '')} ${lines[++i].replace(/^\t+/, '')}`;
+        }
+        recipe.push(cur);
+    }
+    return recipe.length > 0 ? recipe.join('\n') : null;
+}
+// ── the rules ───────────────────────────────────────────────────────────────
+/**
+ * RELOCATION EXCUSE (rule 3 only, measured on mx5@a9c6145).
+ *
+ * That autofix rewrote `test` from `AGENT=1 bun test` to `AGENT=1 bun test
+ * --path-ignore-patterns '**\/*.spec.tsx' && playwright test -c
+ * playwright-ct.config.ts`. Read by hand: `test:ct` was ALREADY
+ * `playwright test -c playwright-ct.config.ts` and already a discovered gate
+ * command, so the excluded specs never left the gate's coverage — the pass
+ * separated two runners that collide, it did not shrink what is measured.
+ * Rejecting it would be a false positive, and the rule as first written did.
+ *
+ * The excuse is deliberately narrow and hard to game: the pass must have added
+ * a chain member that is VERBATIM (whitespace-normalized) a member of another
+ * discovered gate command's body. `&& echo ok` does not qualify; neither does a
+ * near-copy pointed at a different config. Nothing excuses rules 1, 2 or 4 —
+ * a path narrowing stands on its own.
+ *
+ * Returns the matching sibling member, or null.
+ */
+function excusedByRelocation(addedMembers, siblingBodies) {
+    if (addedMembers.length === 0 || siblingBodies.length === 0)
+        return null;
+    const norm = (s) => s.trim().replace(/\s+/g, ' ');
+    const sibling = new Set(siblingBodies.flatMap(b => splitChainMembers(b)).map(m => norm(m)));
+    for (const m of addedMembers) {
+        if (sibling.has(norm(m.text)))
+            return m.text.trim();
+    }
+    return null;
+}
+/** Align members of two bodies by key; duplicates align in declaration order. */
+function alignMembers(before, after) {
+    const pairs = [];
+    const pool = [...after];
+    const onlyBefore = [];
+    for (const b of before) {
+        const i = pool.findIndex(a => a.key === b.key);
+        if (i < 0)
+            onlyBefore.push(b);
+        else
+            pairs.push([b, pool.splice(i, 1)[0]]);
+    }
+    return { pairs, onlyBefore, onlyAfter: pool };
+}
+/**
+ * Classify one command body change. Deterministic, no side conditions beyond
+ * the optional `createdByFix` provenance used by rule 4.
+ */
+export function classifyBodyChange(before, after, env = {}) {
+    const out = { cls: 'neutral', kinds: [], reasons: [], notes: [] };
+    if (before.trim() === after.trim())
+        return out;
+    const { pairs, onlyBefore, onlyAfter } = alignMembers(splitChainMembers(before).map(shapeMember), splitChainMembers(after).map(shapeMember));
+    let widened = false;
+    const narrow = (kind, reason) => {
+        out.cls = 'narrow';
+        if (!out.kinds.includes(kind))
+            out.kinds.push(kind);
+        out.reasons.push(reason);
+    };
+    for (const [b, a] of pairs) {
+        // RULE 1 — a path/glob argument added to a member that had none.
+        if (b.paths.length === 0 && a.paths.length > 0) {
+            narrow('path-added', `\`${b.key}\` ran over the whole project and now runs over ${a.paths.map(p => `\`${p}\``).join(', ')}`);
+        }
+        else if (b.paths.length > 0 && a.paths.length === 0) {
+            widened = true;
+        }
+        // RULE 2 — an existing path replaced by a strict subpath of itself.
+        const goneFromA = b.paths.filter(p => !a.paths.includes(p));
+        const newInA = a.paths.filter(p => !b.paths.includes(p));
+        for (const p of goneFromA) {
+            const sub = newInA.find(q => isStrictSubpath(p, q));
+            if (sub) {
+                narrow('path-narrowed', `\`${b.key}\` argument \`${p}\` was replaced by its subpath \`${sub}\``);
+            }
+            else if (newInA.some(q => isStrictSubpath(q, p))) {
+                widened = true;
+            }
+        }
+        // RULE 3 — an exclusion flag/pattern added, unless the same pass handed
+        // the excluded input to another command the gate already runs.
+        for (const f of a.flags) {
+            if (!EXCLUSION_FLAG_RE.test(f) || b.flags.has(f))
+                continue;
+            const v = a.flagValues.get(f);
+            const relocation = excusedByRelocation(onlyAfter, env.siblingBodies ?? []);
+            if (relocation) {
+                out.notes.push(`exclusion \`${f}${v ? ` ${v}` : ''}\` excused — relocated to \`${relocation}\``);
+                continue;
+            }
+            narrow('exclusion-added', `\`${b.key}\` gained the exclusion \`${f}${v ? ` ${v}` : ''}\`, removing input from what the gate measures`);
+        }
+        for (const f of b.flags) {
+            if (EXCLUSION_FLAG_RE.test(f) && !a.flags.has(f))
+                widened = true;
+        }
+        // RULE 4 — a config argument swapped for a file the fix pass created.
+        for (const f of a.flags) {
+            if (!CONFIG_FLAG_RE.test(f))
+                continue;
+            const av = a.flagValues.get(f);
+            const bv = b.flagValues.get(f);
+            if (!av || av === bv)
+                continue;
+            if (env.createdByFix?.(av)) {
+                narrow('config-swapped', `\`${b.key}\` was pointed at \`${av}\`, a config file this fix pass created`);
+            }
+        }
+    }
+    // Observations only — a vanished chain member is a scope change the four
+    // pre-registered rules do not cover. Reported, never rejected on.
+    for (const b of onlyBefore)
+        out.notes.push(`member-removed: \`${b.text}\``);
+    for (const a of onlyAfter)
+        out.notes.push(`member-added: \`${a.text}\``);
+    if (out.cls === 'neutral' && widened)
+        out.cls = 'widen';
+    return out;
+}
+/**
+ * Every gate command whose resolved body NARROWED across the fix pass. Labels
+ * present on only one side are the label guard's business, not this one's.
+ */
+export function findNarrowedCommands(before, after, env = {}) {
+    const out = [];
+    for (const [label, body] of Object.entries(before)) {
+        const now = after[label];
+        if (now === undefined)
+            continue;
+        const siblingBodies = Object.entries(after)
+            .filter(([l]) => l !== label)
+            .map(([, b]) => b);
+        const c = classifyBodyChange(body, now, { siblingBodies, ...env });
+        if (c.cls !== 'narrow')
+            continue;
+        out.push({ label, before: body, after: now, kinds: c.kinds, reasons: c.reasons });
+    }
+    return out;
+}
+/** One-line rejection text for the guard and the log. */
+export function narrowingRejectionText(narrowed) {
+    const first = narrowed[0];
+    const more = narrowed.length > 1 ? ` (+${narrowed.length - 1} more)` : '';
+    return (`fix pass NARROWED the gate's own command \`${first.label}\`${more}: ${first.reasons[0]}`
+        + ` — \`${first.before}\` → \`${first.after}\``);
+}

package/dist/task/final-gate-fix.d.ts

@@ -136,6 +136,10 @@ export interface FinalFixDeps {
     /** Labels of every currently-discoverable gate command (static + integration),
      *  for the shrink guard. Pure discovery — nothing is executed. */
     discoverLabels: (cwd: string) => string[];
+    /** The same commands' RESOLVED BODIES (`label → scripts[name]` / Makefile
+     *  recipe), for the scope-shrink half of the guard. Absent → only the label
+     *  comparison runs, i.e. the pre-run-19 behaviour. */
+    discoverBodies?: (cwd: string) => Record<string, string>;
     /** Discard the fix child's working-tree edits (guard trips only). Absent
      *  → the violation is still rejected, edits are left for inspection. */
     discard?: (cwd: string) => Promise<void>;

package/dist/task/final-gate-fix.js

@@ -45,6 +45,7 @@
  */
 import { USER_CANCELLED } from './child-runner.js';
 import { findForbiddenDeletions } from './write-guard.js';
+import { findNarrowedCommands, narrowingRejectionText } from './command-shrink.js';
 /** Same bounded-fix contract as lint-fix: edit in place, bash exists to RUN the
  *  failing command (and the project's own tooling), not to mutate git state. */
 export const FINAL_FIX_TOOLS = 'read,edit,bash';
@@ -213,6 +214,7 @@ export function strandedFixNote(paths) {
  */
 export async function runFinalGateAutofix(deps) {
     const before = deps.discoverLabels(deps.cwd);
+    const bodiesBefore = deps.discoverBodies?.(deps.cwd) ?? {};
     let text;
     try {
         text = await deps.runChild(FINAL_FIX_TOOLS, buildFinalFixPrompt(deps.failReason), deps.signal);
@@ -246,8 +248,9 @@ export async function runFinalGateAutofix(deps) {
     }
     // DELETION GUARD (post-revert state): a tracked file the pass deleted without
     // relocating it is a committed deliverable destroyed — reject the attempt.
-    if (deps.treeChanges) {
-        const gone = findForbiddenDeletions(await deps.treeChanges());
+    const changes = deps.treeChanges ? await deps.treeChanges() : null;
+    if (changes) {
+        const gone = findForbiddenDeletions(changes);
         if (gone.length > 0) {
             if (deps.discard)
                 await deps.discard(deps.cwd);
@@ -267,6 +270,30 @@ export async function runFinalGateAutofix(deps) {
             await deps.discard(deps.cwd);
         return rejected(`fix pass removed the gate's own command(s) (${vanished.join(', ')})`);
     }
+    // SCOPE-SHRINK GUARD (mx5 run 19): the label surviving is not enough. The
+    // autofix kept `bun run test` and rewrote its BODY from `AGENT=1 bun test`
+    // to `AGENT=1 bun test ./test`, so the set difference above was empty while
+    // the suite stopped covering the repository — and the gate re-ran, went
+    // green, and reported "converged". Compare the resolved bodies and reject a
+    // fix that shrinks what the gate measures (command-shrink.ts: four
+    // mechanical shapes, measured at 3 hits in 274 manifest-touching corpus
+    // commits, all three read by hand as real narrowings).
+    if (deps.discoverBodies) {
+        const addedByFix = new Set((changes?.added ?? []).map(p => p.replace(/^\.\//, '')));
+        const narrowed = findNarrowedCommands(bodiesBefore, deps.discoverBodies(deps.cwd), {
+            createdByFix: p => {
+                const n = p.replace(/^\.\//, '');
+                return addedByFix.has(n) || [...addedByFix].some(a => a.endsWith(`/${n}`));
+            }
+        });
+        if (narrowed.length > 0) {
+            if (deps.discard)
+                await deps.discard(deps.cwd);
+            const r = rejected(narrowingRejectionText(narrowed));
+            deps.log?.(`final-fix SCOPE-SHRINK GUARD — ${r.reason}`);
+            return r;
+        }
+    }
     // PROBE SCAN (F6): added lines whose stated purpose is to make a check pass
     // rather than meet the requirement reject the attempt — there is no verify
     // child downstream of this pass to judge the finding, and the probe is

package/dist/task/final-gate.d.ts

@@ -321,6 +321,21 @@ export declare function runBootCheck(cwd: string, [bin, args]: HealthCommand, gr
  * gaming the gate, not fixing the defect.
  */
 export declare function discoverGateCommandLabels(cwd: string): string[];
+/**
+ * The RESOLVED BODY of every discoverable gate command, keyed by the same label
+ * `discoverGateCommandLabels` produces.
+ *
+ * The label is what the gate CALLS; the body is what actually runs. mx5 run 19's
+ * autofix changed `scripts.test` from `AGENT=1 bun test` to `AGENT=1 bun test
+ * ./test` — the label `bun run test` was identical before and after, so the
+ * label guard saw nothing while the suite stopped covering the repository. The
+ * shrink guard compares these bodies (see command-shrink.ts).
+ *
+ * A command with no indirection (`cargo test --quiet`, `pytest -q`) resolves to
+ * itself: it cannot be narrowed without changing the label, which the label
+ * guard already owns.
+ */
+export declare function discoverGateCommandBodies(cwd: string): Record<string, string>;
 /**
  * A non-zero exit whose output shows the EXTERNAL INFRASTRUCTURE a launch script
  * talks to is absent HERE — a database/daemon that is not running or not