tumwater 0.4.2 → 0.4.4

package/dist/src/run/stage-name-checks.js

@@ -8,7 +8,7 @@
  * not run any of them. */
 import path from "node:path";
 import { gitTry } from "../git/git-run.js";
-import { JS_FILE, MAX_STALE_HITS, MAX_STALE_PATHS, cappedList, gitGrepHits, isRecordProse, standalonePathIndexes, } from "./stage-checks-shared.js";
+import { JS_FILE, MAX_STALE_HITS, MAX_STALE_PATHS, cappedList, diffRemovedAdded, gitGrepHits, isRecordProse, standalonePathIndexes, } from "./stage-checks-shared.js";
 /** How many removed identifiers one stale-name check looks up. */
 const MAX_STALE_NAMES = 40;
 /** The most characters between a moved name and its old file's name for a line to count as
@@ -59,86 +59,114 @@ function insideStringLiteral(line, index) {
 /** (d) Compound identifiers the change removed from JS/TS source that a comment or doc still
  * names. Candidates come from removed `-U0` lines; one `git grep -w --cached` covers them all. */
 export async function staleNameFindings(wt, diff) {
-    const removed = [];
-    const added = new Set();
-    let jsFile = false;
-    for (const line of diff.split("\n")) {
-        const header = /^diff --git a\/.* b\/(.*)$/.exec(line);
-        if (header) {
-            jsFile = JS_FILE.test(header[1]);
-            continue;
-        }
-        if (!jsFile)
-            continue;
-        if (line.startsWith("-") && !line.startsWith("---")) {
-            removed.push(...declaredNames(line.slice(1)));
-        }
-        else if (line.startsWith("+") && !line.startsWith("+++")) {
-            for (const n of declaredNames(line.slice(1)))
-                added.add(n);
-        }
-    }
-    const candidates = [...new Set(removed)]
-        .filter((n) => isCompoundName(n) && !added.has(n))
-        .slice(0, MAX_STALE_NAMES);
+    const { removedIn, addedIn } = declaredNameDeltas(diff);
+    const candidates = staleNameCandidates(removedIn, addedIn);
     if (candidates.length === 0)
         return [];
-    const out = await gitTry(wt, "grep", "-n", "-w", "-I", "--cached", ...candidates.flatMap((n) => ["-e", n]));
-    if (!out)
-        return [];
-    const lines = gitGrepHits(out);
+    const lines = await wholeWordGrep(wt, candidates);
     const findings = [];
     for (const name of candidates) {
         if (findings.length >= MAX_STALE_PATHS)
             break;
-        const word = new RegExp(`(?<![\\w$])${name.replace(/\$/g, "\\$")}(?![\\w$])`, "g");
-        const mine = lines.filter((l) => [...l.text.matchAll(word)].length > 0);
+        const word = staleNameWord(name);
+        const mine = staleNameMatches(word, lines);
         // Another module may still own the name.
-        if (mine.some((l) => JS_FILE.test(l.file) && declaredNames(l.text).includes(name)))
+        if (ownedElsewhere(name, mine))
             continue;
-        const hits = [];
-        for (const l of mine) {
-            if (isRecordProse(l.file) || l.text.includes("retired-name-ok"))
-                continue;
-            if ([...l.text.matchAll(word)].some((m) => !insideStringLiteral(l.text, m.index))) {
-                hits.push(`${l.file}:${l.no}`);
-            }
-        }
+        const hits = staleNameHits(word, mine);
         if (hits.length === 0)
             continue;
         findings.push(`\`${name}\` was removed by this change but is still named at: ${cappedList(hits, MAX_STALE_HITS)}`);
     }
     return findings;
 }
+/** The candidates this check looks up: compound names the change removed from JS/TS source that
+ * were not also added, capped. (`declaredNameDeltas` keeps only compound names, so every key is
+ * one.) */
+function staleNameCandidates(removedIn, addedIn) {
+    return [...removedIn.keys()].filter((n) => !addedIn.has(n)).slice(0, MAX_STALE_NAMES);
+}
+/** A whole-word, case-sensitive matcher for `name`. */
+function staleNameWord(name) {
+    return new RegExp(`(?<![\\w$])${name.replace(/\$/g, "\\$")}(?![\\w$])`, "g");
+}
+/** `git grep -w --cached` for every name in `names`, returning its `file:line` hit records;
+ * `null` (gitTry maps a clean no-match and a real failure the same way) becomes `[]`. Shared by
+ * the stale-name and moved-name sweeps, which both grep the staged tree for a batch of compound
+ * names exactly the same way before each filters its own subset of the hits. */
+async function wholeWordGrep(wt, names) {
+    const out = await gitTry(wt, "grep", "-n", "-w", "-I", "--cached", ...names.flatMap((n) => ["-e", n]));
+    if (!out)
+        return [];
+    return gitGrepHits(out);
+}
+/** The hits whose text has at least one whole-word occurrence of `word`. */
+function staleNameMatches(word, lines) {
+    return lines.filter((l) => [...l.text.matchAll(word)].length > 0);
+}
+/** True when a JS/TS hit still declares `name` — another module may still own it. */
+function ownedElsewhere(name, mine) {
+    return mine.some((l) => JS_FILE.test(l.file) && declaredNames(l.text).includes(name));
+}
+/** The `file:line` hits that still name `word` outside a string literal, skipping record prose
+ * and retired-name-ok lines. */
+function staleNameHits(word, mine) {
+    const hits = [];
+    for (const l of mine) {
+        if (isRecordProse(l.file) || l.text.includes("retired-name-ok"))
+            continue;
+        if ([...l.text.matchAll(word)].some((m) => !insideStringLiteral(l.text, m.index))) {
+            hits.push(`${l.file}:${l.no}`);
+        }
+    }
+    return hits;
+}
 /** (g) A compound name the change moved out of one JS/TS file into another that a comment or doc
  * still places in the old file: the line has the name within MOVED_NAME_GAP_MAX characters of the
  * old file's name (full path or basename), with no `,` or `;` between them. An old file that
  * still names the moved name (a re-export or import) and record prose are skipped. */
 export async function movedNameFindings(wt, diff) {
+    const { removedIn, addedIn } = declaredNameDeltas(diff);
+    const picked = movedNames(removedIn, addedIn);
+    if (picked.length === 0)
+        return [];
+    const lines = await wholeWordGrep(wt, picked.map((m) => m.name));
+    const findings = [];
+    for (const move of picked) {
+        if (findings.length >= MAX_STALE_PATHS)
+            break;
+        const hits = movedNameHits(move, lines);
+        if (hits.length === 0)
+            continue;
+        findings.push(`\`${move.name}\` moved from ${move.from} to ${cappedList(move.to, MAX_STALE_PATHS)}, but ${hits.join(", ")} ` +
+            `still place it in ${path.basename(move.from)} — point each at its new file`);
+    }
+    return findings;
+}
+/** Record that `file` declares `name` into the per-name file set of `map`. */
+function noteDeclaredName(map, name, f) {
+    const set = map.get(name) ?? new Set();
+    set.add(f);
+    map.set(name, set);
+}
+/** Split a `-U0` diff into the compound names each JS/TS file removed and added. */
+function declaredNameDeltas(diff) {
     const removedIn = new Map();
     const addedIn = new Map();
-    let file = null;
-    const note = (map, name, f) => {
-        const set = map.get(name) ?? new Set();
-        set.add(f);
-        map.set(name, set);
-    };
-    for (const line of diff.split("\n")) {
-        const header = /^diff --git a\/.* b\/(.*)$/.exec(line);
-        if (header) {
-            file = JS_FILE.test(header[1]) ? header[1] : null;
+    for (const f of diffRemovedAdded(diff)) {
+        if (!JS_FILE.test(f.path))
             continue;
+        for (const n of f.removed.flatMap((l) => declaredNames(l)).filter(isCompoundName)) {
+            noteDeclaredName(removedIn, n, f.path);
         }
-        if (file === null)
-            continue;
-        const isRemoved = line.startsWith("-") && !line.startsWith("---");
-        const isAdded = line.startsWith("+") && !line.startsWith("+++");
-        if (!isRemoved && !isAdded)
-            continue;
-        for (const n of declaredNames(line.slice(1)).filter(isCompoundName)) {
-            note(isRemoved ? removedIn : addedIn, n, file);
+        for (const n of f.added.flatMap((l) => declaredNames(l)).filter(isCompoundName)) {
+            noteDeclaredName(addedIn, n, f.path);
         }
     }
+    return { removedIn, addedIn };
+}
+/** The names removed from one JS/TS file that the change moved into another, capped. */
+function movedNames(removedIn, addedIn) {
     const moves = [];
     for (const [name, froms] of removedIn) {
         const added = addedIn.get(name);
@@ -151,44 +179,35 @@ export async function movedNameFindings(wt, diff) {
             break;
         }
     }
-    const picked = moves.slice(0, MAX_STALE_NAMES);
-    if (picked.length === 0)
-        return [];
-    const out = await gitTry(wt, "grep", "-n", "-w", "-I", "--cached", ...picked.flatMap((m) => ["-e", m.name]));
-    if (!out)
+    return moves.slice(0, MAX_STALE_NAMES);
+}
+/** True when `text` sits near a standalone occurrence of the old file's basename `base`. */
+function placesMovedNameInOldFile(text, word, name, base) {
+    const names = [...text.matchAll(word)].map((m) => m.index);
+    const bases = standalonePathIndexes(text, base);
+    return names.some((i) => bases.some((j) => {
+        const gap = j >= i + name.length ? text.slice(i + name.length, j) : text.slice(j + base.length, i);
+        const overlaps = j < i + name.length && i < j + base.length;
+        return !overlaps && gap.length <= MOVED_NAME_GAP_MAX && !/[,;]/.test(gap);
+    }));
+}
+/** The staged-index hits that still place `move.name` in its old file, capped. */
+function movedNameHits(move, lines) {
+    const word = staleNameWord(move.name);
+    const mine = lines.filter((l) => l.text.search(word) !== -1);
+    if (mine.some((l) => l.file === move.from))
         return [];
-    const lines = gitGrepHits(out);
-    const findings = [];
-    for (const { name, from, to } of picked) {
-        if (findings.length >= MAX_STALE_PATHS)
-            break;
-        const word = new RegExp(`(?<![\\w$])${name.replace(/\$/g, "\\$")}(?![\\w$])`, "g");
-        const mine = lines.filter((l) => l.text.search(word) !== -1);
-        if (mine.some((l) => l.file === from))
+    const base = path.basename(move.from);
+    const hits = [];
+    for (const l of mine) {
+        if (isRecordProse(l.file))
             continue;
-        const base = path.basename(from);
-        const hits = [];
-        for (const l of mine) {
-            if (isRecordProse(l.file))
-                continue;
-            const text = l.text.split(from).join(base);
-            const names = [...text.matchAll(word)].map((m) => m.index);
-            const bases = standalonePathIndexes(text, base);
-            const near = names.some((i) => bases.some((j) => {
-                const gap = j >= i + name.length ? text.slice(i + name.length, j) : text.slice(j + base.length, i);
-                const overlaps = j < i + name.length && i < j + base.length;
-                return !overlaps && gap.length <= MOVED_NAME_GAP_MAX && !/[,;]/.test(gap);
-            }));
-            if (!near)
-                continue;
-            hits.push(`${l.file}:${l.no}`);
-            if (hits.length >= MAX_STALE_HITS)
-                break;
-        }
-        if (hits.length === 0)
+        const text = l.text.split(move.from).join(base);
+        if (!placesMovedNameInOldFile(text, word, move.name, base))
             continue;
-        findings.push(`\`${name}\` moved from ${from} to ${cappedList(to, MAX_STALE_PATHS)}, but ${hits.join(", ")} ` +
-            `still place it in ${base} — point each at its new file`);
+        hits.push(`${l.file}:${l.no}`);
+        if (hits.length >= MAX_STALE_HITS)
+            break;
     }
-    return findings;
+    return hits;
 }

package/dist/src/run/stage-path-checks.js

@@ -12,7 +12,7 @@
 import { changeBaseRev } from "../git/git.js";
 import { gitTry } from "../git/git-run.js";
 import { pathTokens } from "../text/text.js";
-import { MAX_STALE_HITS, MAX_STALE_PATHS, cappedList, diffPlusPath, gitGrepHits, hasStandalonePathOccurrence, isRecordProse, } from "./stage-checks-shared.js";
+import { MAX_STALE_HITS, MAX_STALE_PATHS, cappedList, diffPlusPath, diffRemovedAdded, gitGrepHits, hasStandalonePathOccurrence, isRecordProse, } from "./stage-checks-shared.js";
 import { movedNameFindings, staleNameFindings } from "./stage-name-checks.js";
 import { detachedDocFindings, garbledWordingFindings, newlineFindings } from "./stage-prose-checks.js";
 /** How many nonexistent added paths one finding names before it stops. */
@@ -94,6 +94,34 @@ async function pathGrepHits(wt, needle, excludeFile) {
     }
     return hits;
 }
+/** The moved-line delta per changed file, from `diffRemovedAdded(diff)`: each file's removed
+ * lines and added set, trimmed and filtered at MOVED_LINE_MIN_CHARS. The single place the
+ * walk and its threshold live, so a reader asking what counts as a moved line finds it here. */
+function movedLineDeltas(diff) {
+    const files = new Map();
+    for (const f of diffRemovedAdded(diff)) {
+        const removed = f.removed.map((l) => l.trim()).filter((l) => l.length >= MOVED_LINE_MIN_CHARS);
+        const added = new Set(f.added.map((l) => l.trim()).filter((l) => l.length >= MOVED_LINE_MIN_CHARS));
+        files.set(f.path, { removed, added });
+    }
+    return files;
+}
+/** Which files count as receivers of a move source: the other files whose added set contains
+ * at least one of the source's removed lines, in diff order. */
+function movedLineReceivers(src, others) {
+    return others.filter(([, v]) => src.removed.some((l) => v.added.has(l))).map(([f]) => f);
+}
+/** How many of the source's removed lines another file added verbatim. */
+function movedLineCount(src, others) {
+    return src.removed.filter((l) => others.some(([, v]) => v.added.has(l))).length;
+}
+/** The moved-source finding wording: the source path, its moved-line count, the receiving
+ * files (capped at MAX_STALE_PATHS) and the still-matching `file:line` hits to re-check. */
+function movedSourceFinding(path, moved, receivers, hits) {
+    return (`${path} had ${moved} lines moved to ${cappedList(receivers, MAX_STALE_PATHS)}, but it is ` +
+        `still named at: ${hits.join(", ")} — check each still describes what stays in ${path}, ` +
+        `and point any that describes the moved code at its new file`);
+}
 /** (f) References to a file the change moved code out of. A modified (`M`) file is a source
  * when at least MOVED_LINES_MIN of its removed `-U0` lines (trimmed, at least MOVED_LINE_MIN_CHARS
  * long) were added verbatim to another file. Each hit of the source's path outside record prose
@@ -104,29 +132,7 @@ async function pathGrepHits(wt, needle, excludeFile) {
  * and revision runs that rightly changed nothing were rejected until the review chain ran out
  * (6 of 7 exhausted chains on 2026-10-20 and -21). */
 async function movedSourceFindings(wt, diff, entries) {
-    const files = new Map();
-    let cur;
-    for (const line of diff.split("\n")) {
-        const header = /^diff --git a\/.* b\/(.*)$/.exec(line);
-        if (header) {
-            cur = { removed: [], added: new Set() };
-            files.set(header[1], cur);
-            continue;
-        }
-        if (!cur)
-            continue;
-        const isRemoved = line.startsWith("-") && !line.startsWith("---");
-        const isAdded = line.startsWith("+") && !line.startsWith("+++");
-        if (!isRemoved && !isAdded)
-            continue;
-        const text = line.slice(1).trim();
-        if (text.length < MOVED_LINE_MIN_CHARS)
-            continue;
-        if (isRemoved)
-            cur.removed.push(text);
-        else
-            cur.added.add(text);
-    }
+    const files = movedLineDeltas(diff);
     const findings = [];
     for (const e of entries) {
         if (e.status !== "M" || isRecordProse(e.path))
@@ -137,18 +143,13 @@ async function movedSourceFindings(wt, diff, entries) {
         if (!src)
             continue;
         const others = [...files].filter(([f]) => f !== e.path);
-        const receivers = others
-            .filter(([, v]) => src.removed.some((l) => v.added.has(l)))
-            .map(([f]) => f);
-        const moved = src.removed.filter((l) => others.some(([, v]) => v.added.has(l))).length;
+        const moved = movedLineCount(src, others);
         if (moved < MOVED_LINES_MIN)
             continue;
         const hits = await pathGrepHits(wt, e.path, e.path);
         if (hits.length === 0)
             continue;
-        findings.push(`${e.path} had ${moved} lines moved to ${cappedList(receivers, MAX_STALE_PATHS)}, but it is ` +
-            `still named at: ${hits.join(", ")} — check each still describes what stays in ${e.path}, ` +
-            `and point any that describes the moved code at its new file`);
+        findings.push(movedSourceFinding(e.path, moved, movedLineReceivers(src, others), hits));
     }
     return findings;
 }
@@ -174,10 +175,9 @@ async function staleReferenceFindings(wt, entries) {
     }
     return findings;
 }
-/** (b) Nonexistent paths: every path-shaped token on an added diff line whose first segment is
- * a tracked top-level directory but which is absent from the staged tree. Rename origins and
- * deleted paths are excluded — "moved from X" prose names them legitimately. */
-async function missingPathFindings(wt, diff, entries) {
+/** The staged tree as the added-path check needs it: the set of every tracked path and the set
+ * of its top-level directories, from `git ls-files`. */
+async function readStagedIndex(wt) {
     const ls = await gitTry(wt, "ls-files");
     const staged = new Set();
     const topDirs = new Set();
@@ -189,6 +189,11 @@ async function missingPathFindings(wt, diff, entries) {
         if (slash > 0)
             topDirs.add(p.slice(0, slash));
     }
+    return { staged, topDirs };
+}
+/** The paths a change moved code away from and must not flag: every rename origin and every
+ * deleted path in `entries`, which "moved from X" prose names legitimately. */
+function renameOriginPaths(entries) {
     const oldPaths = new Set();
     for (const e of entries) {
         if (e.oldPath)
@@ -196,6 +201,25 @@ async function missingPathFindings(wt, diff, entries) {
         if (e.status === "D")
             oldPaths.add(e.path);
     }
+    return oldPaths;
+}
+/** The path-shaped tokens an added line names that are absent from the staged tree: a token whose
+ * first segment is a tracked top-level directory, not a rename origin or deleted path, not
+ * already staged, and not already seen. Each returned token is added to `seen` as it goes. */
+function missingPathTokens(line, staged, topDirs, oldPaths, seen) {
+    const found = [];
+    for (const p of pathTokens(line.slice(1))) {
+        const top = p.slice(0, p.indexOf("/"));
+        if (!topDirs.has(top) || oldPaths.has(p) || staged.has(p) || seen.has(p))
+            continue;
+        seen.add(p);
+        found.push(p);
+    }
+    return found;
+}
+/** Every added diff line's missing-path tokens, tracking the current file to spare added lines in
+ * test/ and in record prose (isRecordProse). */
+function missingPathsInDiff(diff, staged, topDirs, oldPaths) {
     const seen = new Set();
     const missing = [];
     let file = null;
@@ -212,14 +236,17 @@ async function missingPathFindings(wt, diff, entries) {
         // test/ and in record prose (isRecordProse).
         if (file !== null && (file.startsWith("test/") || isRecordProse(file)))
             continue;
-        for (const p of pathTokens(line.slice(1))) {
-            const top = p.slice(0, p.indexOf("/"));
-            if (!topDirs.has(top) || oldPaths.has(p) || staged.has(p) || seen.has(p))
-                continue;
-            seen.add(p);
-            missing.push(p);
-        }
+        missing.push(...missingPathTokens(line, staged, topDirs, oldPaths, seen));
     }
+    return missing;
+}
+/** (b) Nonexistent paths: every path-shaped token on an added diff line whose first segment is
+ * a tracked top-level directory but which is absent from the staged tree. Rename origins and
+ * deleted paths are excluded — "moved from X" prose names them legitimately. */
+async function missingPathFindings(wt, diff, entries) {
+    const { staged, topDirs } = await readStagedIndex(wt);
+    const oldPaths = renameOriginPaths(entries);
+    const missing = missingPathsInDiff(diff, staged, topDirs, oldPaths);
     if (missing.length === 0)
         return [];
     return [

package/dist/src/run/stage-prose-checks.js

@@ -196,64 +196,79 @@ function spanningGarbled(joined, joinAt, patterns) {
     }
     return null;
 }
-/** (e) Added lines, outside record prose, that match GARBLED_WORDING: at most one hit per line,
- * reported as `file:line "matched text"` in a single finding. A phrase split across two
- * consecutive added lines is reported as `file:N-M`. */
-export function garbledWordingFindings(diff) {
-    const hits = [];
+/** The added lines of a diff, in order, each with the added line that precedes it. */
+function addedDiffLines(diff) {
+    const out = [];
     let file = null;
     let lineNo = 0;
-    let prevAdded = null;
+    let prev = null;
     for (const line of diff.split("\n")) {
         const header = /^diff --git a\/.* b\/(.*)$/.exec(line);
         if (header) {
             file = header[1];
-            prevAdded = null;
+            prev = null;
             continue;
         }
         const hunk = /^@@ .*\+(\d+)(?:,\d+)? @@/.exec(line);
         if (hunk) {
             lineNo = Number(hunk[1]);
-            prevAdded = null;
+            prev = null;
             continue;
         }
         if (!line.startsWith("+") || line.startsWith("+++ ")) {
-            prevAdded = null;
+            prev = null;
             continue;
         }
-        const cur = line.slice(1);
-        if (file !== null && !isRecordProse(file)) {
-            let hit = false;
-            for (const re of GARBLED_WORDING) {
-                const m = re.exec(cur);
-                if (m) {
-                    hits.push(`${file}:${lineNo} "${m[0]}"`);
-                    hit = true;
-                    break;
-                }
-            }
-            const prose = proseOf(file, cur);
-            if (!hit && prose !== null) {
-                const m = DOUBLED_WORD.exec(prose);
-                if (m) {
-                    hits.push(`${file}:${lineNo} "${m[0]}"`);
-                    hit = true;
-                }
-            }
-            if (!hit && prevAdded !== null) {
-                const head = prevAdded.trimEnd();
-                const joined = head + " " + cur.replace(/^\s*(?:\/\/+|\*|#)\s*/, "");
-                let split = spanningGarbled(joined, head.length, GARBLED_WORDING);
-                if (!split && prose !== null && proseOf(file, prevAdded) !== null) {
-                    split = spanningGarbled(joined, head.length, [DOUBLED_WORD]);
-                }
-                if (split)
-                    hits.push(`${file}:${lineNo - 1}-${lineNo} "${split}"`);
-            }
-        }
-        prevAdded = cur;
+        const text = line.slice(1);
+        if (file !== null)
+            out.push({ file, lineNo, text, prev });
+        prev = text;
         lineNo++;
     }
+    return out;
+}
+/** The first GARBLED_WORDING hit on a single added line, or the DOUBLED_WORD hit in its prose. */
+function singleLineGarbledHit(file, lineNo, cur) {
+    for (const re of GARBLED_WORDING) {
+        const m = re.exec(cur);
+        if (m)
+            return `${file}:${lineNo} "${m[0]}"`;
+    }
+    const prose = proseOf(file, cur);
+    if (prose !== null) {
+        const m = DOUBLED_WORD.exec(prose);
+        if (m)
+            return `${file}:${lineNo} "${m[0]}"`;
+    }
+    return null;
+}
+/** A garbled or doubled phrase split across two consecutive added lines, joined at their seam. */
+function spanningGarbledHit(file, lineNo, cur, prevAdded) {
+    if (prevAdded === null)
+        return null;
+    const head = prevAdded.trimEnd();
+    const joined = head + " " + cur.replace(/^\s*(?:\/\/+|\*|#)\s*/, "");
+    let split = spanningGarbled(joined, head.length, GARBLED_WORDING);
+    const prose = proseOf(file, cur);
+    if (!split && prose !== null && proseOf(file, prevAdded) !== null) {
+        split = spanningGarbled(joined, head.length, [DOUBLED_WORD]);
+    }
+    if (split)
+        return `${file}:${lineNo - 1}-${lineNo} "${split}"`;
+    return null;
+}
+/** (e) Added lines, outside record prose, that match GARBLED_WORDING: at most one hit per line,
+ * reported as `file:line "matched text"` in a single finding. A phrase split across two
+ * consecutive added lines is reported as `file:N-M`. */
+export function garbledWordingFindings(diff) {
+    const hits = [];
+    for (const { file, lineNo, text, prev } of addedDiffLines(diff)) {
+        if (isRecordProse(file))
+            continue;
+        const hit = singleLineGarbledHit(file, lineNo, text) ?? spanningGarbledHit(file, lineNo, text, prev);
+        if (hit !== null)
+            hits.push(hit);
+    }
     if (hits.length === 0)
         return [];
     const lead = 'added lines carry garbled rename wording (reword them; a rote word swap such as "tick" → "run" reads wrong here or leaves a word doubled): '; // vocabulary-ok: quotes the retired word

package/dist/src/runner/{leftover.js → runner-leftover.js}

@@ -16,8 +16,8 @@ import { shortSha } from "../text/format.js";
  * holds whether or not the pin survived. Split out of runner.ts — which keeps the run lifecycle
  * around it — because this is a self-contained concern with its own entry condition and git
  * surface; the only things it borrows from the runner are identity, the run number, the
- * worktree (for the no-pin fallback), and three pieces of the role's merge state: its
- * conflict streak, outstanding hand-back, and permanent-reviewer hold. */
+ * worktree (for the no-pin fallback), and two pieces of the role's merge state: its conflict
+ * streak and outstanding hand-back. */
 /** Consecutive merges of one pinned sha that may end `merge_conflict` before recovery stops
  * re-queuing it (RunnerState.mergeConflicts). Each attempt costs a conflict-resolution run, and
  * a role holding a pin never authors: without a cap an unmergeable change would re-queue
@@ -43,19 +43,14 @@ async function dropDanglingPin(root, role, ref, sha) {
     warnEventBestEffort(root, role, `dropped merge pin ${shortSha(sha)}: its commit is missing from the repository, so it can never merge`);
     return true;
 }
-/** The permanent-reviewer-config hold when it names `sha`, else undefined. */
-function reviewHold(held, sha) {
-    return held?.sha === sha ? held : undefined;
-}
 /** Consecutive conflict-ended merges of `sha` (0 when the streak names another sha). */
 function conflictAttempts(streak, sha) {
     return streak?.sha === sha ? streak.count : 0;
 }
 /** The sha of a role's kept pin when the merge pipeline may re-queue it itself: the pin exists,
- * main does not already contain it (a stale pin is deleted, as recovery does), no reviewer
- * configuration hold names it, and its conflict streak is under MERGE_CONFLICT_LIMIT. Null
- * otherwise — a pin at the limit is the author's conflict hand-back, a held one waits for a
- * config change, and both stay with recoverLeftover. */
+ * main does not already contain it (a stale pin is deleted, as recovery does), and its conflict
+ * streak is under MERGE_CONFLICT_LIMIT. Null otherwise — a pin at the limit is the author's
+ * conflict hand-back, and it stays with recoverLeftover. */
 export async function pinnedRetrySha(root, role, mainBranch, state) {
     const ref = mergeRefName(role);
     const sha = await refSha(root, ref).catch(() => null);
@@ -65,8 +60,6 @@ export async function pinnedRetrySha(root, role, mainBranch, state) {
         return null;
     if (await dropStalePin(root, ref, sha, mainBranch))
         return null;
-    if (reviewHold(state.mergeReviewError, sha))
-        return null;
     if (conflictAttempts(state.mergeConflicts, sha) >= MERGE_CONFLICT_LIMIT)
         return null;
     return sha;
@@ -130,13 +123,10 @@ export async function recoverLeftover(ctx) {
         sha = await headOf(ctx.wt, "HEAD").catch(() => null);
         if (!sha)
             return null;
-        // Hold checks BEFORE adopting: when a reviewer-config hold or a main_red retry names this
-        // tip, adopting it into the merge ref would create/repoint the pin and lose the kept sha
-        // the wait exists to preserve. Return the hold path without touching the ref (BUGS.md
-        // 2026-10-06, the main_red wait), leaving the commit on the branch.
-        const heldTip = reviewHold(ctx.mergeReviewError, sha);
-        if (heldTip)
-            return { kind: "held", sha, message: heldTip.message };
+        // Hold checks BEFORE adopting: when a main_red retry names this tip, adopting it into the
+        // merge ref would create/repoint the pin and lose the kept sha the wait exists to preserve.
+        // Return the wait path without touching the ref (BUGS.md 2026-10-06, the main_red wait),
+        // leaving the commit on the branch.
         if (ctx.mainRedRetry) {
             return mainRedWait(sha, ctx.mainRedRetry.head);
         }
@@ -150,13 +140,6 @@ export async function recoverLeftover(ctx) {
         }
     }
     const meta = await recoveredMetadata(ctx.root, sha);
-    // A permanent reviewer configuration error holds the pin: re-queuing it would pay another
-    // full gate check for a request that can never succeed until the model config changes. The
-    // caller clears the hold (and re-queues) once the resolved reviewer selector differs, so a
-    // fixed config recovers automatically (BUGS.md 2026-10-06).
-    const held = reviewHold(ctx.mergeReviewError, sha);
-    if (held)
-        return { kind: "held", sha, message: held.message };
     // `requeueMainRedPin` owns the re-queue of a main_red pin, once main's head moves. Queuing it
     // here would pay a full gate check against the same red head, whose result is already known.
     if (ctx.mainRedRetry) {

package/dist/src/runner/runner-outcome.js

@@ -10,7 +10,7 @@ import { mergeToMain } from "../merge/merge-to-main.js";
 import { MERGE_LOCK_WAIT_MS } from "../paths.js";
 import { resolveRunVerdict } from "../run/run-verdict.js";
 import { modelTrailerLine } from "../git/commit-message.js";
-import { seamAgent } from "../config/model-selector.js";
+import { seamAgent } from "../config/config-model-selector.js";
 import { stageRunMerge } from "../run/run-stage.js";
 import { stageCheckFindings } from "../run/stage-check.js";
 /** Merge the worktree branch on main (see src/merge/merge-to-main.ts for the
@@ -62,6 +62,11 @@ export async function handlePiResultPhase(ctx, pi, userPrompt, revisionRound, wt
         flow,
         filed,
         ci,
+        // The image-reroute arm resolves its target from the live config and the current
+        // regime, and names the model this run ran on as the handoff's `from`.
+        config: ctx.config,
+        rerouteRegime: ctx.rerouteRegime(),
+        runModel: cfg.model,
         warn: (message) => ctx.warn(message),
         merge: (w, sum) => mergePhase(ctx, w, sum),
         finishAbortedRun: () => ctx.finishAbortedRun(userPrompt, wt),
@@ -96,7 +101,7 @@ export async function handlePiResultPhase(ctx, pi, userPrompt, revisionRound, wt
         piStartedAt,
         warn: (message) => ctx.warn(message),
         requestSummary: (w, n) => ctx.pi.requestSummary(w, cfg, n),
-        stageCheck: (w) => stageCheckFindings(w, ctx.mainBranch, ctx.config.review.exemptPaths, ctx.role),
+        stageCheck: (w) => stageCheckFindings(w, ctx.mainBranch, ctx.role),
         requestStageFix: (w, findings, change) => ctx.pi.requestStageFix(w, findings, change, cfg),
         pinAndReset: (w, sha) => ctx.pinAndReset(w, sha),
         finishAbortedRun: () => ctx.finishAbortedRun(userPrompt, wt),