tumwater 0.4.2 → 0.4.3

package/dist/src/run/stage-check.js

@@ -93,35 +93,24 @@ const pushReason = async (findings, check) => {
     if (reason)
         findings.push(reason);
 };
-/** The findings likely to get this uncommitted change rejected at merge, or an empty list when
- * it is clean: the merge gate's own deterministic checks plus the staging-only heuristics (plan
- * dependencies, path drift). Checks the worktree at `wt` against
- * `mainBranch`'s merge-base; `exemptPaths` are the config's review-exemption globs that scope
- * the false-fix check.
- *
- * Never throws: a check that fails yields no finding, so a git hiccup at staging time defers to
- * the gate instead of failing the run. */
-export async function stageCheckFindings(wt, mainBranch, exemptPaths, role) {
-    const files = await changedFiles(wt).catch(() => null);
-    if (files === null || files.length === 0)
-        return [];
-    const findings = [];
-    await pushReason(findings, backlogStructureReason(wt, mainBranch, files));
-    if (files.includes("PLANS.md")) {
-        const { head, base } = await headAndBase(wt, mainBranch, "PLANS.md");
-        // Finished plans are archived in PLANS-DONE.md (plans/backlog-archive.md): a requires clause
-        // naming a merged part resolves there, on both sides of the comparison alike.
-        const archived = parseEntryDetails(readTextOrNull(path.join(wt, PLANS_ARCHIVE)) ?? "", "Done").map((e) => e.title);
-        const dependency = base === undefined ? undefined : planDependencyFinding(head, base, archived);
-        if (dependency !== undefined)
-            findings.push(dependency);
-        const refusal = base === undefined ? undefined : ungroundedRefusalFinding("PLANS.md", head, base);
-        if (refusal !== undefined)
-            findings.push(refusal);
-    }
+/** The PLANS.md record findings: a requires clause naming a part the archive lacks, and an
+ * ungrounded refusal that cites another part. */
+async function plansFindings(wt, mainBranch) {
+    const { head, base } = await headAndBase(wt, mainBranch, "PLANS.md");
+    // Finished plans are archived in PLANS-DONE.md (plans/backlog-archive.md): a requires clause
+    // naming a merged part resolves there, on both sides of the comparison alike.
+    const archived = parseEntryDetails(readTextOrNull(path.join(wt, PLANS_ARCHIVE)) ?? "", "Done").map((e) => e.title);
+    const dependency = base === undefined ? undefined : planDependencyFinding(head, base, archived);
+    const refusal = base === undefined ? undefined : ungroundedRefusalFinding("PLANS.md", head, base);
+    return [dependency, refusal].filter((f) => f !== undefined);
+}
+/** The finished-archive findings: duplicates of entries the archive already holds, plus the
+ * acceptance greps of the plan entries the change finished (for a PLANS.md change). */
+async function archiveFindings(wt, mainBranch, files) {
     const baseRev = FINISHED_ARCHIVES.some((s) => files.includes(s.file) || files.includes(s.archive))
         ? await changeBaseRev(wt, mainBranch).catch(() => undefined)
         : undefined;
+    const findings = [];
     for (const spec of FINISHED_ARCHIVES) {
         if (baseRev === undefined || !(files.includes(spec.file) || files.includes(spec.archive)))
             continue;
@@ -144,12 +133,18 @@ export async function stageCheckFindings(wt, mainBranch, exemptPaths, role) {
         })().catch(() => []);
         findings.push(...greps);
     }
-    if (files.includes("BUGS.md")) {
-        const { head, base } = await headAndBase(wt, mainBranch, "BUGS.md");
-        const refusal = base === undefined ? undefined : ungroundedRefusalFinding("BUGS.md", head, base);
-        if (refusal !== undefined)
-            findings.push(refusal);
-    }
+    return findings;
+}
+/** The BUGS.md record finding: an ungrounded refusal that cites another bug. */
+async function bugsFindings(wt, mainBranch) {
+    const { head, base } = await headAndBase(wt, mainBranch, "BUGS.md");
+    const refusal = base === undefined ? undefined : ungroundedRefusalFinding("BUGS.md", head, base);
+    return refusal === undefined ? [] : [refusal];
+}
+/** The stray-placeholder findings: a `_None yet._` line a changed record still leaves in a
+ * section that holds entries. */
+async function placeholderFindings(wt, mainBranch, files) {
+    const findings = [];
     for (const file of PLACEHOLDER_FILES) {
         if (!files.includes(file))
             continue;
@@ -158,6 +153,28 @@ export async function stageCheckFindings(wt, mainBranch, exemptPaths, role) {
         if (stray !== undefined)
             findings.push(stray);
     }
+    return findings;
+}
+/** The findings likely to get this uncommitted change rejected at merge, or an empty list when
+ * it is clean: the merge gate's own deterministic checks plus the staging-only heuristics (plan
+ * dependencies, path drift). Checks the worktree at `wt` against
+ * `mainBranch`'s merge-base; `exemptPaths` are the config's review-exemption globs that scope
+ * the false-fix check.
+ *
+ * Never throws: a check that fails yields no finding, so a git hiccup at staging time defers to
+ * the gate instead of failing the run. */
+export async function stageCheckFindings(wt, mainBranch, exemptPaths, role) {
+    const files = await changedFiles(wt).catch(() => null);
+    if (files === null || files.length === 0)
+        return [];
+    const findings = [];
+    await pushReason(findings, backlogStructureReason(wt, mainBranch, files));
+    if (files.includes("PLANS.md"))
+        findings.push(...(await plansFindings(wt, mainBranch)));
+    findings.push(...(await archiveFindings(wt, mainBranch, files)));
+    if (files.includes("BUGS.md"))
+        findings.push(...(await bugsFindings(wt, mainBranch)));
+    findings.push(...(await placeholderFindings(wt, mainBranch, files)));
     await pushReason(findings, protectedEditReason(wt, mainBranch, files, role));
     await pushReason(findings, secretLeakReason(wt, mainBranch, files));
     if (isExemptDiff(files, exemptPaths))

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

@@ -16,6 +16,34 @@ export const MAX_STALE_PATHS = 10;
 export function diffPlusPath(line) {
     return line.slice(4).replace(/^b\//, "");
 }
+/** Parse a `-U0` unified diff into each file's removed and added content lines, marker-stripped.
+ * The `diff --git` header names the file, and git's `---`/`+++` old/new path headers carry no
+ * content; `@@` hunk headers, context lines and the `\ No newline` marker match neither branch,
+ * so the walk records only real `-`/`+` content lines. Consumers keep only what they want — a
+ * JS-file filter, a trim-and-min-length rule, a compound-name extraction — from the per-file
+ * removed/added lists; stage-path-checks's movedSourceFindings and stage-name-checks's
+ * declaredNameDeltas each walked this same grammar before the helper. stage-prose-checks's
+ * detachedDocFindings and addedDiffLines are deliberately not folded here: both need each hunk's
+ * start-line count from the `@@` header, which this shape drops. */
+export function diffRemovedAdded(diff) {
+    const files = [];
+    let cur;
+    for (const line of diff.split("\n")) {
+        const header = /^diff --git a\/.* b\/(.*)$/.exec(line);
+        if (header) {
+            cur = { path: header[1], removed: [], added: [] };
+            files.push(cur);
+            continue;
+        }
+        if (!cur)
+            continue;
+        if (line.startsWith("-") && !line.startsWith("---"))
+            cur.removed.push(line.slice(1));
+        else if (line.startsWith("+") && !line.startsWith("+++"))
+            cur.added.push(line.slice(1));
+    }
+    return files;
+}
 /** Parse `git grep -n` stage output into `file:line:text` hits. `git grep -n` prints one
  * `path:line:text` per match, and the four name/path checks (stage-name-checks.ts's
  * staleNameFindings and movedNameFindings, stage-path-checks.ts's movedSourceFindings and

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 [