tumwater 0.4.3 → 0.4.5

package/dist/src/backlog/backlog-eligibility.js

@@ -53,19 +53,22 @@ export function needsReviewNote(body) {
  * which the plan role clears by splitting or replanning (role-catalog.ts `plan` find). False
  * for the bugfix role's wait-for-the-next-failure note ("by bugfix: …"), which parks the
  * entry for selfcheck to lift when the cluster fails again (selfcheck step 4) and which no
- * role can act on until then. entryHold returns "needs-review" for every such note (all of
- * them park the entry), so the stalled-with-the-plan-role surfaces — the stalled-entries team
- * alert (team-alert-backlog.ts) and the doctor's `stalled entries` row
- * (checkStalledEntries) — classify by this agreed subset, keeping the bugfix parks out of the
- * plan-role blame. Reads the note's text after the NEEDS_REVIEW_PREFIX once, so the alert and
- * the doctor row cannot disagree on which notes the plan role clears; the eligibility mark
+ * role can act on until then, and for the director's user fallback ("by director: …", the
+ * director-request handoff's final park) — the director has already reviewed the entry and the
+ * park names what the user must decide, so it is not plan-role work either. entryHold returns
+ * "needs-review" for every such note (all of them park the entry), so the doctor's `stalled
+ * entries` row (checkStalledEntries) — the
+ * stalled-with-the-plan-role surface — classifies by this agreed subset, keeping the bugfix
+ * parks out of the plan-role blame. Reads the note's text after the NEEDS_REVIEW_PREFIX once,
+ * so the row cannot disagree on which notes the plan role clears; the eligibility mark
  * (holdMark) continues to hold every needs-review note, a by-bugfix park included. */
 export function isPlanStalled(entry) {
     const note = needsReviewNote(entry.body);
     if (note === null)
         return false;
-    // A "by bugfix:" note is a wait for evidence that selfcheck clears, not plan-role work.
-    return !note.includes("by bugfix");
+    // A "by bugfix:" note is a wait for evidence that selfcheck clears, and a "by director:"
+    // note is the director's reviewed user fallback (INV-B8) — neither is plan-role work.
+    return !note.includes("by bugfix") && !note.includes("by director");
 }
 /** `lines` without any line starting with `prefix` (the same line-prefix rule hasNoteLine
  * applies). When a dropped note sat between two blank lines, the blank line after it goes too,
@@ -279,49 +282,28 @@ export function backlogHolds(root) {
  * `tumwater backlog` prints. A surface derives its marks from the one hold decision and the
  * one claim lookup rather than re-walking the entries. An eligible entry nobody is working on
  * renders as the empty string, so a client can append the mark without a separate check.
- * Questions carry no holds. backlogHolds alone still drives the allocator. */
-export function backlogMarks(root) {
+ * Questions carry no holds. backlogHolds alone still drives the allocator. A caller that
+ * already resolved the claim lookup (for the same poll's marks AND its own parallel checks,
+ * e.g. statusPayload's `working` or the TUI's `runners`) passes it as `working` so the claims
+ * walk is done once, not re-run inside both calls — the same shared single read the module's
+ * other single-home polls observe. */
+export function backlogMarks(root, working) {
     const holds = backlogHolds(root);
-    const working = backlogInProgress(root);
+    const inProgress = working ?? backlogInProgress(root);
     const mark = (hold, runner) => holdMark(hold) + inProgressMark(runner ?? null);
     return {
-        plans: holds.plans.map((h, i) => mark(h, working.plans[i])),
-        bugs: holds.bugs.map((h, i) => mark(h, working.bugs[i])),
+        plans: holds.plans.map((h, i) => mark(h, inProgress.plans[i])),
+        bugs: holds.bugs.map((h, i) => mark(h, inProgress.bugs[i])),
     };
 }
 /** The display noun for a backlog-file discriminator — the `"plans" | "bugs"` `file` on
- * RefusedEntry and StalledEntry (and the same discriminator the prompt's named-hold wording
+ * RefusedEntry (and the same discriminator the prompt's named-hold wording
  * and the doctor's Stalled row take): BUGS.md is a "Bug" and PLANS.md a "Plan", and the
  * lowercase form is the `Refused plan|bug:` label and the `tumwater plan|bug --release`
  * command noun. */
 export function entryKindLabel(file) {
     return file === "bugs" ? "Bug" : "Plan";
 }
-/** The planned plans and open bugs parked with the plan role — whose Needs-review hold the plan
- * role clears by splitting or replanning (the feature role's too-large note, the convergence hold,
- * a final-round rejection), in file order: the `stalled-entries` team alert's input, each
- * carrying its backlog file, 0-based index and the hold. Same `backlogHolds(root)` + the
- * planned/`openBugEntries` readers `refusedEntries` uses, so the alert and the doctor's
- * `stalled entries` row classify through the same `entryHold` + `isPlanStalled` and cannot
- * disagree on which holds are role-resolvable. The bugfix role's wait-for-the-next-failure
- * parks ("by bugfix:") are excluded: selfcheck lifts them, not the plan role. A missing
- * file yields `[]`. */
-export function stalledEntries(root) {
-    const holds = backlogHolds(root);
-    const out = [];
-    const entriesOf = (entries, held, file) => {
-        entries.forEach((e, i) => {
-            const hold = held[i];
-            // Only holds the plan role can clear surface as stalled: the bugfix role's
-            // wait-for-the-next-failure parks stay out of the plan-role blame.
-            if (hold === "needs-review" && isPlanStalled(e))
-                out.push({ file, index: i, title: e.title, hold });
-        });
-    };
-    entriesOf(plannedPlanEntries(root), holds.plans, "plans");
-    entriesOf(openBugEntries(root), holds.bugs, "bugs");
-    return out;
-}
 /** The planned plans, then the open bugs, whose hold is `"refused"`, in file order: the
  * entries that wait on an operator decision (the `refused` team alert's input), each carrying
  * the backlog file and its 0-based position so a surface opening the row can land on it.

package/dist/src/backlog/backlog-index.js

@@ -15,7 +15,7 @@ import { collapseWhitespace, truncate } from "../text/text.js";
 import { actionableEntryRanges, groupBlockedSeries, partsLabel, } from "./backlog-index-data.js";
 import { stripEntryStamp } from "./backlog-structure.js";
 import { entryHoldAgainst, holdMark } from "./backlog-eligibility.js";
-import { plannedPartKeys } from "./backlog-parts.js";
+import { entryKey, plannedPartKeys } from "./backlog-parts.js";
 import { plannedPlanEntries } from "./backlog.js";
 /** Max characters an index title keeps before a trailing ellipsis, so one very long BUGS.md
  * heading cannot dominate the block. */
@@ -110,7 +110,7 @@ export function renderBacklogIndexBlock(root) {
         // plan) — BUGS.md and QUESTIONS.md sections keep every entry on its own line.
         const rows = entries.map((e) => {
             const hold = entryHoldAgainst({ title: e.title, body: e.body }, plannedParts);
-            const key = collapseWhitespace(stripEntryStamp(e.title)).toLowerCase();
+            const key = entryKey(e.title);
             return {
                 start: e.start,
                 end: e.end,

package/dist/src/backlog/backlog-md.js

@@ -342,9 +342,20 @@ export function entryLags(md, sectionTitle, dateRe, filingRe) {
 export function headingMetadata(lines, start) {
     const line = lines[start] ?? "";
     const meta = [line];
+    const j = collectHeadingContinuation(lines, start, meta, headingIsWrapped(line));
+    return { text: meta.join(" "), next: j };
+}
+/** Whether a `### ` heading line opens an unbalanced parenthetical: the only shape whose
+ * metadata runs beyond its first line. */
+function headingIsWrapped(line) {
     // A wrapped heading's first line opens a parenthetical its continuation will close; an
     // unbalanced count is therefore the only shape that has metadata beyond the first line.
-    const wrapped = (line.match(/\(/g) ?? []).length > (line.match(/\)/g) ?? []).length;
+    return (line.match(/\(/g) ?? []).length > (line.match(/\)/g) ?? []).length;
+}
+/** Append a wrapped `### ` heading's continuation lines to `meta`, stopping at the next entry
+ * start, the 3-line cap, or a line ending in `)`; returns the first line index not consumed. */
+function collectHeadingContinuation(lines, start, meta, wrapped) {
+    const line = lines[start] ?? "";
     let closed = line.endsWith(")");
     let j = start + 1;
     // Continuation is a heading-only concern (wrapped headings); bullets are single-line.
@@ -356,7 +367,7 @@ export function headingMetadata(lines, start) {
         j++;
         closed = next.endsWith(")");
     }
-    return { text: meta.join(" "), next: j };
+    return j;
 }
 /** A `- ` line's or `### ` heading's trailing parenthetical's inner text, nesting-aware: a
  * backward scan from the text's closing ")" to its matching "(" returns the group's FULL inner

package/dist/src/backlog/backlog-question-answer.js

@@ -7,7 +7,7 @@
  * output helpers, so every surface can drive it without ending the process.
  *
  * Shared by every read/answer surface: the CLI's `tumwater questions` command body wraps it in
- * src/cli/question-commands.ts (the say/fail/editor layer), while the TUI's answer box
+ * src/cli/cli-question-commands.ts (the say/fail/editor layer), while the TUI's answer box
  * (src/ui/tui/tui-keys.ts) and the dashboard's POST route (src/gui/gui-endpoint-commands.ts)
  * import the non-exiting answer core directly. It lives with the rest of the BUGS/PLANS/QUESTIONS
  * markdown (src/backlog/), not under src/cli/, so the non-command surfaces never depend on the

package/dist/src/backlog/backlog-release.js

@@ -4,7 +4,7 @@
  * section. Each comes as an exiting writer (the CLI) and a non-exiting `try…` core that refuses as
  * data (the TUI and dashboard); entry lookup and the section's file target are
  * backlog-write.ts's. */
-import { backlogTarget, findEntry, locateDashboardEntry, readEntryLines } from "./backlog-write.js";
+import { backlogTarget, findEntry, readEntryLines, withLocatedEntry } from "./backlog-write.js";
 import { withoutNeedsReviewNotes, withoutRefusalNotes } from "./backlog-eligibility.js";
 import { writeTextAtomic } from "../files/files.js";
 import { fail } from "../cli/cli-output.js";
@@ -38,11 +38,7 @@ function liftRefusal(lines, entry) {
  * title check, all decided inside the lock. */
 export function tryReleaseEntry(root, kind, n, expectedTitle) {
     const { fileName, sectionTitle } = backlogTarget(kind);
-    return withPrimaryWorktreeLock(root, () => {
-        const located = locateDashboardEntry(root, fileName, sectionTitle, n, expectedTitle);
-        if (located.status !== "ok")
-            return located;
-        const { file, md, entry } = located;
+    return withLocatedEntry(root, fileName, sectionTitle, n, expectedTitle, ({ file, md, entry }) => {
         const lines = md.split("\n");
         const lifted = liftRefusal(lines, entry);
         if (lifted === null)
@@ -104,11 +100,7 @@ function spliceEntryToTop(lines, sectionTitle, entry) {
  * title check, all decided inside the lock. */
 export function tryMoveEntryToTop(root, kind, n, expectedTitle) {
     const { fileName, sectionTitle } = backlogTarget(kind);
-    return withPrimaryWorktreeLock(root, () => {
-        const located = locateDashboardEntry(root, fileName, sectionTitle, n, expectedTitle);
-        if (located.status !== "ok")
-            return located;
-        const { file, md, entry } = located;
+    return withLocatedEntry(root, fileName, sectionTitle, n, expectedTitle, ({ file, md, entry }) => {
         if (n === 1)
             return { status: "already_first", title: entry.title };
         const lines = md.split("\n");

package/dist/src/backlog/backlog-write.js

@@ -147,7 +147,7 @@ export function readEntryLines(root, fileName, sectionTitle, n) {
  * refuse as data without writing; on success returns the `ok` file path, raw markdown and entry
  * for the caller to splice and write its own outcome. A pure lookup, decided inside the caller's
  * lock. */
-export function locateDashboardEntry(root, fileName, sectionTitle, n, expectedTitle) {
+function locateDashboardEntry(root, fileName, sectionTitle, n, expectedTitle) {
     const file = path.join(root, fileName);
     const md = readTextIfExists(file) ?? "";
     const entry = findEntry(md, sectionTitle, n);
@@ -157,6 +157,22 @@ export function locateDashboardEntry(root, fileName, sectionTitle, n, expectedTi
         return { status: "moved", title: entry.title };
     return { status: "ok", file, md, entry };
 }
+/** The shared lock-and-locate prologue of the four non-exiting dashboard writers (tryCancelEntry
+ * and tryEditEntry here; tryReleaseEntry and tryMoveEntryToTop in backlog-release.ts): take the
+ * cross-process lock, locate the `n`th entry by position and expected title, and refuse as data —
+ * returning `located`'s `gone`/`moved` verbatim when the lookup fails — without writing. On a
+ * match it calls `splice` with the located file, markdown and entry and returns whatever the
+ * splice returns, so each writer keeps its own `ok`-branch outcome; the return is the union of the
+ * two refusals and `splice`'s own return, which is exactly each writer's outcome type. The
+ * `splice` runs inside the lock, the same window the inline prologue held. */
+export function withLocatedEntry(root, fileName, sectionTitle, n, expectedTitle, splice) {
+    return withPrimaryWorktreeLock(root, () => {
+        const located = locateDashboardEntry(root, fileName, sectionTitle, n, expectedTitle);
+        if (located.status !== "ok")
+            return located;
+        return splice({ file: located.file, md: located.md, entry: located.entry });
+    });
+}
 /** The section-remove entry point, the appendEntry analogue: the same cross-process lock, so a
  * cancel and a merge's working-tree fast-forward cannot each clobber the other's
  * read-modify-write. */
@@ -189,11 +205,7 @@ function spliceOutEntry(file, lines, entry) {
  * `plans`/`bugs` strings, the same `### ` text as ActionableEntryRange.title). */
 export function tryCancelEntry(root, kind, n, expectedTitle) {
     const { fileName, sectionTitle } = backlogTarget(kind);
-    return withPrimaryWorktreeLock(root, () => {
-        const located = locateDashboardEntry(root, fileName, sectionTitle, n, expectedTitle);
-        if (located.status !== "ok")
-            return located;
-        const { file, md, entry } = located;
+    return withLocatedEntry(root, fileName, sectionTitle, n, expectedTitle, ({ file, md, entry }) => {
         spliceOutEntry(file, md.split("\n"), entry);
         return { status: "cancelled", file: fileName, title: entry.title };
     });
@@ -264,11 +276,7 @@ export function tryEditEntry(root, kind, n, expectedTitle, rawTitle, rawBody) {
     const { fileName, sectionTitle } = backlogTarget(kind);
     const title = stripEntryStamp(collapseWhitespace(rawTitle));
     const body = rawBody.replace(/\r\n?/g, "\n").trim();
-    return withPrimaryWorktreeLock(root, () => {
-        const located = locateDashboardEntry(root, fileName, sectionTitle, n, expectedTitle);
-        if (located.status !== "ok")
-            return located;
-        const { file, md, entry } = located;
+    return withLocatedEntry(root, fileName, sectionTitle, n, expectedTitle, ({ file, md, entry }) => {
         const wrote = spliceInEditedEntry(file, md.split("\n"), entry, title, body);
         return { status: wrote ? "edited" : "unchanged", file: fileName, title };
     });

package/dist/src/backlog/backlog.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { cachedTextByStat } from "../files/stat-cache.js";
+import { DAY_MS } from "../text/datetime.js";
 import { entryDates, entryLags, finishedArchiveOf, firstDate, lastDate, parseEntryDetails } from "./backlog-md.js";
 import { CHECK_DECLARATION_MARKER } from "../roles/role-guidance.js";
 /** The stat-cached file readers of the project backlog data shown on both dashboards: planned
@@ -104,7 +105,7 @@ export function completionDate(title, dateRe) {
 /** Whole days between a filing stamp and `now`, floored at 0 so a future-dated entry reads as
  * fresh (0d) rather than negative. Shared by the suffix and the `--list --json` `ageDays` field. */
 export function ageInDays(since, now = Date.now()) {
-    return Math.max(0, Math.floor((now - Date.parse(since)) / 86400000));
+    return Math.max(0, Math.floor((now - Date.parse(since)) / DAY_MS));
 }
 /** The ` · since YYYY-MM-DD (Nd)`/`(today)` tail a listing line gains for its entry's filing
  * stamp — the one place the wording and the today/`Nd` choice live, so the plans/bugs list

package/dist/src/baseline/main-baseline.js

@@ -9,10 +9,14 @@ import { treeDiffFiles } from "../git/git-diff.js";
 import { isExemptDiff } from "../review/exemptions.js";
 import { readJsonFile, writeJsonAtomic } from "../files/json-files.js";
 import { isJsonObject } from "../files/json-object.js";
-import { baselineVerdictsPath, mirrorWorktreePath } from "../paths.js";
+import { baselineVerdictsPath } from "../paths.js";
 import { memoSetLru } from "../collections.js";
-/** Team-shared verdict cache, keyed by main SHA. In-memory only: after a restart the cache is cold
- * and one re-check per red SHA happens — cheap and deterministic, mirroring the budget gate's
+/** Team-shared verdict cache, keyed by main SHA. Exported read-only to the one consumer outside
+ * this module that decides redeploy's target from it (src/redeploy/redeploy-target.ts's
+ * `redeployTarget`); writes stay here — `rememberBaseline`, `noteGreenBaseline` and
+ * `noteInheritedGreen` — so the cache's write policy has one home. In-memory only: after a
+ * restart the cache is cold and one re-check per red SHA happens — cheap and deterministic,
+ * mirroring the budget gate's
  * stateless resume. Entries come from two sources: checkMainBaseline's own runs, and
  * noteGreenBaseline seeding a green verdict for a SHA that just became main
  * (src/merge/merge-to-main.ts: either its in-lock post-rebase re-check passed on exactly that
@@ -33,7 +37,7 @@ import { memoSetLru } from "../collections.js";
  * not opt-in only: a red carries the worktrees that observed it (`redFrom`) and is re-run by the
  * next DIFFERENT worktree to consult it, so a single environmental red can no longer block every
  * role until main moves — see shouldRerunRed. */
-const baselineCache = new Map();
+export const baselineCache = new Map();
 /** Safety cap so the per-process verdict cache can never grow unbounded: it is keyed by every
  * merged code SHA and a red entry carries the failed run's output tail, so a team running for
  * weeks would accumulate one entry per merge forever. Evicting the oldest entry (Map's insertion
@@ -150,15 +154,10 @@ function shouldRerunRed(cached, wt, reverifyRed) {
     const seen = cached.redFrom ?? [];
     return seen.length < 2 && !seen.includes(wt);
 }
-/** Record a green baseline verdict for `sha` WITHOUT running anything. The callers are the merge
- * path (src/merge/merge-to-main.ts's verifyMerge) and the stack lander
- * (src/merge/merge-stack.ts' mergeStack) — both call it only after their fast-forward SUCCEEDED,
- * with the exact SHA that just became main: verifyMerge with the POST-rebase head in two cases —
- * its own in-lock re-check just ran this project's declared check green on that tree, or the
- * rebase was a no-op so the review gate's pre-check (which runs outside the merge lock) had
- * already run green on exactly this tree — and mergeStack with the stacked tip when a
- * scope-`batch` check ran green on exactly it (a skipped check seeds nothing, and neither does a
- * merge_blocked stack or a doc-only re-stack that merged without a check of its own). Seeding
+/** Record a green baseline verdict for `sha` WITHOUT running anything. The caller is the merge
+ * path (src/merge/merge-to-main.ts's mergeToMain), called only after its fast-forward SUCCEEDED,
+ * with the exact SHA that just became main.
+ * Seeding
  * here means that once the merge completes — main now points at this very SHA — the next fresh
  * run's checkMainBaseline is a cache hit instead of re-running the full suite on an
  * already-verified tree: for tumwater itself that saves one redundant `npm test` (~1 min) per
@@ -171,11 +170,23 @@ function shouldRerunRed(cached, wt, reverifyRed) {
 export function noteGreenBaseline(sha) {
     rememberBaseline(sha, { status: "green", sha });
 }
+/** Settle `sha`'s red verdict by a re-run of only its failing tests on the same tree
+ * (build-check-rerun.ts; the main watch's confirmation, which replaced a second full run): with
+ * none failing again the SHA is promoted green, as the full re-run's green promoted it — every test
+ * has now passed on this tree — and otherwise the red narrows to the tests that failed again.
+ * Returns the settled verdict, or null when `sha` holds no red to settle. */
+export function settleRedByRerun(sha, failing) {
+    const red = baselineCache.get(sha);
+    if (red?.status !== "red")
+        return null;
+    const settled = failing.length === 0 ? { status: "green", sha } : { ...red, failingTests: [...failing] };
+    rememberBaseline(sha, settled);
+    return settled;
+}
 /** Record an INHERITED green for `sha` (MainBaseline.inheritedFrom): a tree no check ran on, whose
- * only difference from the green-verified `from` is in review-exempt paths. The caller is
- * merge-to-main.ts's verifyMerge, after it skipped the in-lock check because main moved
- * under the gate-verified head only by doc commits. It seeds the head about to become main, as
- * verifyMerge's own noteGreenBaseline calls do. If the fast-forward then fails, the entry is
+ * only difference from the green-verified `from` is in review-exempt paths. It seeds the head
+ * about to become main, as
+ * noteGreenBaseline calls do. If the fast-forward then fails, the entry is
  * still true of that tree and simply never consulted. It never displaces an observed verdict: a
  * check that actually ran on this tree knows more than the carry-over. */
 export function noteInheritedGreen(sha, from) {
@@ -193,7 +204,7 @@ const INHERIT_WALK_MAX = 64;
  * first-parent scans in this module share, spelled the same on purpose so a change to the walk
  * shape (the bound, the `--first-parent` flag) lands once. `inheritedGreen` and `watchedBaseline`
  * walk a commit's ancestors (`${sha}^` / `${tip}^`, the commit itself excluded);
- * `newestGreenAboveBuild` walks `tip` itself and down. Never throws: a git failure is an empty
+ * `newestObservedBaseline` walks `tip` itself and down. Never throws: a git failure is an empty
  * list, and every caller already treats that as a no-inheritance / no-verdict answer. */
 async function firstParentWalk(wt, ref, max) {
     return gitLines(await gitTry(wt, "rev-list", "--first-parent", `--max-count=${max}`, ref));
@@ -261,8 +272,21 @@ export async function watchedBaseline(wt, sha) {
     }
     return null;
 }
-/** How many first-parent commits below main's tip redeployTarget looks at. */
-const REDEPLOY_WALK_MAX = 64;
+/** The newest verdict a check OBSERVED on `tip` or its first-parent ancestors — `tip` itself
+ * first, looking at most INHERIT_WALK_MAX commits down — WITHOUT running anything; null when
+ * there is none. An inherited green is walked past: no check ran on that tree, and a doc edit can
+ * break a test that reads the docs (checkMainBaseline's `observedOnly`). The review gate's
+ * attribution reads this when the main watch verifies main (main-red.ts's watchedMainVerdict):
+ * with `check.mergeCommand` in effect every observed verdict is a full check the watch or
+ * another consumer ran. Never throws: a git failure reads as no verdict. */
+export async function newestObservedBaseline(wt, tip) {
+    for (const sha of await firstParentWalk(wt, tip, INHERIT_WALK_MAX)) {
+        const verdict = baselineCache.get(sha);
+        if (verdict && verdict.inheritedFrom === undefined)
+            return verdict;
+    }
+    return null;
+}
 /** True when the main watch (src/baseline/main-watch.ts) verifies main — the configs where no
  * merge seeds a green verdict (`watchedBaseline`'s doc) and the watch has a check to run: a
  * declared check and a `check.mergeCommand` (or its gate-command fallback) in effect. In this
@@ -273,56 +297,6 @@ const REDEPLOY_WALK_MAX = 64;
 export function watchVerifiesMain(root, config) {
     return detectBuildCheck(root, config) !== null && mergeCommandOf(config) !== undefined;
 }
-/** The newest first-parent commit below `tip`, down to and through `buildSha`, with a green
- * cached verdict — the walk+scan redeployTarget's watched and un-watched branches share. Only
- * their fallback differs: `notOnHistory` when `buildSha` is not on the first-parent walk at all
- * (the caller keeps today's answer, `tip`), `onHistoryNone` when it is but nothing above it is
- * green (watched keeps the build; un-watched keeps `tip`). Never throws: a git failure leaves
- * the walk empty, so the fallback answers. */
-async function newestGreenAboveBuild(wt, tip, buildSha, notOnHistory, onHistoryNone) {
-    const walk = await firstParentWalk(wt, tip, REDEPLOY_WALK_MAX);
-    const buildAt = walk.indexOf(buildSha);
-    if (buildAt === -1)
-        return notOnHistory;
-    for (const sha of walk.slice(0, buildAt)) {
-        if (baselineCache.get(sha)?.status === "green")
-            return sha;
-    }
-    return onHistoryNone;
-}
-/** The commit self-redeploy should run: main's newest first-parent commit with a green full-check
- * verdict in the cache (observed or inherited) that is newer than the running build `buildSha`,
- * looking at most REDEPLOY_WALK_MAX commits down from `tip`.
- *
- * With `watched` false (the default, a project whose main the watch does not verify), a tip the
- * cache has no verdict for is the target as is — the redeployer checks it. A tip whose cached red
- * was observed in the redeployer's mirror worktree (mirrorWorktreePath of `wt`) falls back to the
- * newest older green above the build. Any other red may be another worktree's environmental one,
- * which the redeployer re-verifies; a build that is not a first-parent ancestor of `tip`, or no
- * green, also leaves the tip the target, and the redeployer blocks that commit alone.
- *
- * With `watched` true (watchVerifiesMain), the watch supplies the verdicts and the redeployer only
- * reads them: walk `tip`'s first-parent history down to `buildSha` and return the first commit
- * whose cached verdict is green — a cached red is walked past, never targeted. With no green
- * above the build, target `buildSha` itself, so buildStaleness reads it as not stale and no
- * episode, hold or pre-warm starts until the watch calls a newer commit green. A build that is
- * not a first-parent ancestor of `tip` keeps today's answer (`tip`, which the redeployer
- * checks), as does `watched` false. Every target `watched` picks has a cached green, so
- * mainIsGreen on it is a cache hit and the redeployer starts no suite.
- * The cache holds only full-check verdicts, so a cheaper command's green never makes a commit
- * deployable.
- * Never throws: a git failure leaves the tip as the target. */
-export async function redeployTarget(wt, tip, buildSha, watched = false) {
-    if (watched) {
-        if (tip === "")
-            return tip;
-        return newestGreenAboveBuild(wt, tip, buildSha, tip, buildSha);
-    }
-    const red = baselineCache.get(tip);
-    if (tip === "" || red?.status !== "red" || !(red.redFrom ?? []).includes(mirrorWorktreePath(wt)))
-        return tip;
-    return newestGreenAboveBuild(wt, tip, buildSha, tip, tip);
-}
 /** Verify main's own build/test suite at `wt`'s HEAD — which must be pristine main (the caller
  * is the fresh-run path right after resetWorktreeToMain; a dirty or ahead worktree would
  * measure the wrong thing). Cache hit returns immediately; on miss runs detectBuildCheck +
@@ -451,6 +425,7 @@ function baselineFromOutcome(sha, wt, outcome) {
             script: outcome.script,
             outputTail: outcome.outputTail,
             failingTests: outcome.failingTests ?? [],
+            ...(outcome.failingTestFiles ? { failingTestFiles: outcome.failingTestFiles } : {}),
             redFrom: priorRedFrom.includes(wt) ? priorRedFrom : [...priorRedFrom, wt],
         };
 }
@@ -495,8 +470,8 @@ async function runBaselineOnce(sha, wt, config, onRun, sampleSleep, tier) {
     return { baseline };
 }
 /** Is main green at the mirror worktree's HEAD? The merge path seeds a green verdict for every
- * merged code SHA (noteGreenBaseline — its in-lock post-rebase re-check, or the gate's pre-check
- * when the rebase was a no-op), so the common case is a cache hit. A head that only added doc
+ * merged code SHA (noteGreenBaseline — the stack lander's scope-`batch` check on the merged tip,
+ * or a no-op gate pre-check, so the common case is a cache hit. A head that only added doc
  * commits on top of such a SHA inherits its green (checkMainBaseline's inheritedGreen). The
  * redeployer's cooldown pre-warm asks this for every new head, and those doc heads were most of the
  * harness's baseline runs (247 of 319 over 2026-10-02..12). Otherwise the project's declared check

package/dist/src/baseline/main-guardrails.js

@@ -13,7 +13,7 @@
  * Both take an injected `now` so tests never read the clock. */
 import { readEventsSince } from "../events/event-window.js";
 import { loadQuarantine } from "../review/known-flakes.js";
-import { DAY_MS, clockHm, humanAgo } from "../text/datetime.js";
+import { DAY_MS, HOUR_MS, clockHm, humanAgo } from "../text/datetime.js";
 import { shortSha } from "../text/format.js";
 import { roleLabel } from "../roles/role-labels.js";
 import { plural } from "../text/phrases.js";
@@ -115,13 +115,17 @@ function redFailingTest(newest) {
     return Array.isArray(newest.failingTests) && typeof newest.failingTests[0] === "string" ? newest.failingTests[0] : undefined;
 }
 /** The blame clause naming the merge the main watch blamed, when the newest `culprit` in the
- * window blames the same sha the phrase names. Owns the blame clause. */
-function redBlameClause(culprit, newest) {
+ * window names the spell's opener or its newest red. Owns the blame clause. */
+function redBlameClause(culprit, startEv, newest) {
     // The blame names the merge the main watch blamed for the red — the same `main_culprit`
     // commit-equals-tip rule the dashboard alert uses (status-polls only publishes a blame whose
     // commit is the derived tip sha), so a red the watch did not blame never borrows another
     // head's culprit. A culprit naming another commit, or none, leaves the phrase as today.
-    const shouldBlame = culprit !== undefined && culprit.commit === newest.sha;
+    // The watch names the commit that OPENED the red (its first red tip since the last green)
+    // even when a later tip re-checks red, so the match accepts the spell's opener as well as the
+    // newest red tip: the opener is what the watch blames for the ongoing spell, and a
+    // pre-fix log that named the newest tip instead still matches its own newest red.
+    const shouldBlame = culprit !== undefined && (culprit.commit === newest.sha || culprit.commit === startEv.sha);
     return shouldBlame
         ? typeof culprit.runner === "string" && culprit.runner.length > 0
             ? `; the main watch blames ${roleLabel(culprit.runner)}'s merge ${shortSha(culprit.commit)}`
@@ -134,9 +138,9 @@ function redBlameClause(culprit, newest) {
  * ignored; a pass (including one naming only quarantined tests, recorded passed) ends the red.
  * The phrase names how long main has had no passing full check, the sha it has been red since,
  * its clock time, the newest red's first failing test when one is named, and — when the newest
- * `main_culprit` in the window blames the same sha the phrase names — the merge the main watch
- * blamed (`; the main watch blames <role>'s merge <sha>`, or `; the main watch blames merge
- * <sha>` when no runner is named), the one rule the dashboard alert and this phrase share.
+ * `main_culprit` in the window names the spell's opener or its newest red tip — the merge the
+ * main watch blamed (`; the main watch blames <role>'s merge <sha>`, or `; the main watch blames
+ * merge <sha>` when no runner is named), the one rule the dashboard alert and this phrase share.
  * Returns null when main is green, or red for RED_MAIN_WARN_MS or less. The per-job work is
  * split into the module-private helpers `scanRedWindow`, `redSpell`, `redSpellDuration`,
  * `redFailingTest` and `redBlameClause`, one per job, so each is found by name. */
@@ -148,7 +152,7 @@ export function redMainWarning(events, now) {
     const duration = redSpellDuration(spell);
     const head = `main has had no passing full check for ${duration}: red since ${shortSha(spell.startEv.sha)} at ${clockHm(spell.startEv.ts)}`;
     const failing = redFailingTest(spell.newest);
-    const blame = redBlameClause(window.culprit, spell.newest);
+    const blame = redBlameClause(window.culprit, spell.startEv, spell.newest);
     return failing ? `${head} — ${squash(failing, 120)}${blame}` : `${head}${blame}`;
 }
 /** G3 over `entries` (the loadQuarantine list): warns when the list holds more than
@@ -193,5 +197,5 @@ function redDurationPhrase(ms) {
     const minutes = Math.round(ms / 60_000);
     if (minutes < 24 * 60)
         return `${minutes} min`;
-    return `${Math.round(ms / 3_600_000)} h`;
+    return `${Math.round(ms / HOUR_MS)} h`;
 }