tumwater 0.4.1 → 0.4.2

package/dist/src/ui/tui/tui-pane.js

@@ -47,207 +47,234 @@ export function roleInspectMarkdown(root, role) {
  * the head with the selected entry's full body in entry mode, usage/failures re-window
  * the cached Markdown set on view entry, and the activity pane keeps the event tail. */
 export function paneBody(pane, opts) {
-    const { root, width, eventBudget, entryBudget, state } = opts;
-    if (pane.kind === "transcript") {
-        // The notes view (Ctrl+N) windows the cached inspection Markdown exactly like the
-        // usage/failures panes, headings bold; the live transcript keeps the tail.
-        if (pane.note) {
-            const win = entryBodyWindow(state.noteCache ?? "", state.paneScroll, eventBudget, width);
-            return {
-                body: win.lines.map((l) => toneLine(l, width, l.startsWith("#") ? "bold" : undefined)),
-                emptyNote: "(nothing to inspect yet)",
-            };
-        }
-        // The change view (the second Ctrl+N step) windows the collected unmerged-change text the
-        // same way; its async collector leaves the cache null for the first frames, so the pane
-        // paints the loading note rather than entryBodyWindow's "no details" placeholder.
-        if (pane.change) {
-            if (state.changeCache === null)
-                return { body: [], emptyNote: "(loading pending change…)" };
-            const win = entryBodyWindow(state.changeCache, state.paneScroll, eventBudget, width);
-            return {
-                body: win.lines.map((l) => toneLine(l, width, l.startsWith("#") ? "bold" : undefined)),
-                emptyNote: "(loading pending change…)",
-            };
-        }
-        if (pane.grep) {
-            // Filtered: scan the drawer's 200 entries with the shared keep rule (a lowercased needle).
-            return {
-                body: readTranscript(root, pane.role, 200, { grep: pane.grep.toLowerCase() }).slice(-eventBudget).map((l) => toneLine(l, width, transcriptTone(l))),
-                emptyNote: `(no transcript entries match "${pane.grep}")`,
-            };
-        }
+    if (pane.kind === "transcript")
+        return transcriptBody(pane, opts);
+    if (pane.kind === "backlog")
+        return backlogBody(pane, opts);
+    if (pane.kind === "history")
+        return historyBody(pane, opts);
+    if (pane.kind === "pending")
+        return pendingBody(pane, opts);
+    if (pane.kind === "health")
+        return healthBody(pane, opts);
+    if (pane.kind === "brief")
+        return briefBody(pane, opts);
+    if (pane.kind === "queued")
+        return queuedBody(pane, opts);
+    if (pane.kind === "usage" || pane.kind === "failures")
+        return reportBody(pane, opts);
+    return activityBody(pane, opts);
+}
+function transcriptBody(pane, opts) {
+    const { root, width, eventBudget, state } = opts;
+    // The notes view (Ctrl+N) windows the cached inspection Markdown exactly like the
+    // usage/failures panes, headings bold; the live transcript keeps the tail.
+    if (pane.note) {
+        const win = entryBodyWindow(state.noteCache ?? "", state.paneScroll, eventBudget, width);
         return {
-            body: readTranscript(root, pane.role, eventBudget).slice(-eventBudget).map((l) => toneLine(l, width, transcriptTone(l))),
-            emptyNote: "(no transcript yet)",
+            body: win.lines.map((l) => toneLine(l, width, l.startsWith("#") ? "bold" : undefined)),
+            emptyNote: "(nothing to inspect yet)",
         };
     }
-    if (pane.kind === "backlog") {
-        // The flat, labeled entry list is the one backlog read this frame needs: it carries every
-        // planned feature, open bug, and open question (then the newest answered questions, done
-        // plans and fixed bugs)
-        // from PLANS.md/BUGS.md/QUESTIONS.md with its section label and eligibility mark (the same
-        // entryHold verdict `tumwater backlog` renders). List and entry mode share this one pass;
-        // entry mode used to read the three sections and derive the holds directly and
-        // then again inside the flat list, so every render paid twice for the same reads and verdicts.
-        const flat = browsableBacklogEntries(root);
-        // A `/` search narrows the browsable list to the matching open entries (the answered/done/
-        // fixed rows are read-only and hidden while a search is applied); entry mode still opens
-        // `flat[sel]`, the unfiltered index the selection holds.
-        const grep = state.backlogGrep ?? null;
-        const shown = flat.filter((e) => {
-            if (grep !== null && !(isOpenBacklogLabel(e.label) && entryMatches(e, grep)))
-                return false;
-            if (state.backlogReadyOnly && isOpenBacklogLabel(e.label) && e.hold !== null)
-                return false;
-            return true;
-        });
-        // A stale selection (an entry removed since the last render) clamps to the last; no
-        // entries at all falls back to list mode.
-        const sel = state.selectedEntry === null || flat.length === 0 ? null : Math.min(state.selectedEntry, flat.length - 1);
-        if (sel === null) {
-            // List mode: section headings stand out, empty sections read dim. Keeps the HEAD of the
-            // list when it overflows — file order is newest-first, unlike events which keep the tail.
-            const listed = (label) => shown.filter((e) => e.label === label).map((e) => e.title + e.mark);
-            // Plans list a series' blocked parts as one line (as `plan --list` does); the selection
-            // below still walks the flat list, one entry per part.
-            const plans = shown.filter((e) => e.label === "plan");
-            // A `/` search active: the answered/done/fixed sections are hidden, the sections build
-            // only from the matching open entries under a `search: "<grep>"` header, and nothing
-            // matching paints a self-explanatory line.
-            if (grep !== null) {
-                const prefix = [`search: "${grep}"`];
-                const rest = shown.length === 0
-                    ? [`(no entries match "${grep}")`]
-                    : backlogLines(planListLines(plans), listed("bug"), listed("question"), plans.length);
-                return {
-                    body: [...prefix, ...rest]
-                        .slice(0, eventBudget)
-                        .map((l) => toneLine(l, width, /^(?:plans|open bugs|open questions) \(\d+\):$/.test(l) ? "bold" : l.startsWith("(") ? "dim" : undefined)),
-                    emptyNote: "(no events yet)",
-                };
-            }
-            // The newest answered questions follow the open ones: they are in `flat` (up/down open
-            // their bodies), but no edit key acts on them.
-            const answered = answeredQuestionSummaries(root, DASHBOARD_ANSWERED_QUESTIONS).map((q) => q.decision ? `${q.title} — ${q.decision}` : q.title);
-            // Done plans and fixed bugs follow, browsable and read-only the same way.
-            const finishedRows = (rows, verb) => rows.map((r) => (r.completedOn ? `${r.title} — ${verb} ${r.completedOn}` : r.title));
-            const finished = {
-                done: finishedRows(recentFinished(donePlanEntries(root), DONE_DATE_RE), "done"),
-                fixed: finishedRows(recentFinished(fixedBugEntries(root), FIXED_DATE_RE), "fixed"),
-            };
-            return {
-                body: backlogLines(planListLines(plans), listed("bug"), listed("question"), plans.length, answered, finished)
-                    .slice(0, eventBudget)
-                    .map((l) => toneLine(l, width, /^(?:plans|open bugs|open questions|answered recently|done recently|fixed recently) \(\d+\):$/.test(l) ? "bold" : l.startsWith("(") ? "dim" : undefined)),
-                emptyNote: "(no events yet)",
-            };
-        }
-        // Entry browsing: the selected entry's full body under a line naming its section and
-        // title.
-        const e = flat[sel];
-        const win = entryBodyWindow(e.body, state.entryScroll, entryBudget, width);
+    // The change view (the second Ctrl+N step) windows the collected unmerged-change text the
+    // same way; its async collector leaves the cache null for the first frames, so the pane
+    // paints the loading note rather than entryBodyWindow's "no details" placeholder.
+    if (pane.change) {
+        if (state.changeCache === null)
+            return { body: [], emptyNote: "(loading pending change…)" };
+        const win = entryBodyWindow(state.changeCache, state.paneScroll, eventBudget, width);
         return {
-            body: [toneLine(`${e.label}: ${e.title}${e.mark}`, width, "bold"), ...win.lines.map((l) => toneLine(l, width))],
-            emptyNote: "(no events yet)",
+            body: win.lines.map((l) => toneLine(l, width, l.startsWith("#") ? "bold" : undefined)),
+            emptyNote: "(loading pending change…)",
         };
     }
-    if (pane.kind === "history") {
-        // The run trail (Ctrl+N) windows the cached renderRunDetail text; a null cache (the
-        // read found no run) paints the pane's own note rather than entryBodyWindow's placeholder.
-        if (pane.trail) {
-            if (state.trailCache === null)
-                return { body: [], emptyNote: "(no run trail)" };
-            const win = entryBodyWindow(state.trailCache, state.paneScroll, eventBudget, width);
-            return {
-                body: win.lines.map((l) => toneLine(l, width)),
-                emptyNote: "(no run trail)",
-            };
-        }
-        // historyPaneText returns "" when the log holds no completed runs; return no lines
-        // (rather than windowing an empty string, which entryBodyWindow replaces with its
-        // "no details" placeholder) so the frame prints the pane's own empty note instead.
-        const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, eventBudget, width) : { lines: [] };
+    if (pane.grep) {
+        // Filtered: scan the drawer's 200 entries with the shared keep rule (a lowercased needle).
         return {
-            body: win.lines.map((l) => toneLine(l, width)),
-            emptyNote: "(no runs yet)",
+            body: readTranscript(root, pane.role, 200, { grep: pane.grep.toLowerCase() }).slice(-eventBudget).map((l) => toneLine(l, width, transcriptTone(l))),
+            emptyNote: `(no transcript entries match "${pane.grep}")`,
         };
     }
-    if (pane.kind === "pending") {
-        // A selected queued merge shows its detail in place of the queue list; otherwise paneCache
-        // stays null until the async collector resolves (the Ctrl+T handler kicks it off
-        // fire-and-forget); like history, return no lines while null so the frame prints the
-        // loading note rather than windowing an empty string into the "no details" placeholder.
-        if (state.queueDetail) {
-            const detail = state.queueDetail;
-            const sel = entryBodyWindow(detail, state.paneScroll, eventBudget, width);
+    return {
+        body: readTranscript(root, pane.role, eventBudget).slice(-eventBudget).map((l) => toneLine(l, width, transcriptTone(l))),
+        emptyNote: "(no transcript yet)",
+    };
+}
+function backlogBody(_pane, opts) {
+    const { root, width, eventBudget, entryBudget, state } = opts;
+    // The flat, labeled entry list is the one backlog read this frame needs: it carries every
+    // planned feature, open bug, and open question (then the newest answered questions, done
+    // plans and fixed bugs)
+    // from PLANS.md/BUGS.md/QUESTIONS.md with its section label and eligibility mark (the same
+    // entryHold verdict `tumwater backlog` renders). List and entry mode share this one pass;
+    // entry mode used to read the three sections and derive the holds directly and
+    // then again inside the flat list, so every render paid twice for the same reads and verdicts.
+    const flat = browsableBacklogEntries(root);
+    // A `/` search narrows the browsable list to the matching open entries (the answered/done/
+    // fixed rows are read-only and hidden while a search is applied); entry mode still opens
+    // `flat[sel]`, the unfiltered index the selection holds.
+    const grep = state.backlogGrep ?? null;
+    const shown = flat.filter((e) => {
+        if (grep !== null && !(isOpenBacklogLabel(e.label) && entryMatches(e, grep)))
+            return false;
+        if (state.backlogReadyOnly && isOpenBacklogLabel(e.label) && e.hold !== null)
+            return false;
+        return true;
+    });
+    // A stale selection (an entry removed since the last render) clamps to the last; no
+    // entries at all falls back to list mode.
+    const sel = state.selectedEntry === null || flat.length === 0 ? null : Math.min(state.selectedEntry, flat.length - 1);
+    if (sel === null) {
+        // List mode: section headings stand out, empty sections read dim. Keeps the HEAD of the
+        // list when it overflows — file order is newest-first, unlike events which keep the tail.
+        const listed = (label) => shown.filter((e) => e.label === label).map((e) => e.title + e.mark);
+        // Plans list a series' blocked parts as one line (as `plan --list` does); the selection
+        // below still walks the flat list, one entry per part.
+        const plans = shown.filter((e) => e.label === "plan");
+        // A `/` search active: the answered/done/fixed sections are hidden, the sections build
+        // only from the matching open entries under a `search: "<grep>"` header, and nothing
+        // matching paints a self-explanatory line.
+        if (grep !== null) {
+            const prefix = [`search: "${grep}"`];
+            const rest = shown.length === 0
+                ? [`(no entries match "${grep}")`]
+                : backlogLines(planListLines(plans), listed("bug"), listed("question"), plans.length);
             return {
-                body: sel.lines.map((l) => toneLine(l, width)),
-                emptyNote: "(loading pending changes…)",
+                body: [...prefix, ...rest]
+                    .slice(0, eventBudget)
+                    .map((l) => toneLine(l, width, /^(?:plans|open bugs|open questions) \(\d+\):$/.test(l) ? "bold" : l.startsWith("(") ? "dim" : undefined)),
+                emptyNote: "(no events yet)",
             };
         }
-        const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, eventBudget, width) : { lines: [] };
+        // The newest answered questions follow the open ones: they are in `flat` (up/down open
+        // their bodies), but no edit key acts on them.
+        const answered = answeredQuestionSummaries(root, DASHBOARD_ANSWERED_QUESTIONS).map((q) => q.decision ? `${q.title} — ${q.decision}` : q.title);
+        // Done plans and fixed bugs follow, browsable and read-only the same way.
+        const finishedRows = (rows, verb) => rows.map((r) => (r.completedOn ? `${r.title} — ${verb} ${r.completedOn}` : r.title));
+        const finished = {
+            done: finishedRows(recentFinished(donePlanEntries(root), DONE_DATE_RE), "done"),
+            fixed: finishedRows(recentFinished(fixedBugEntries(root), FIXED_DATE_RE), "fixed"),
+        };
         return {
-            body: win.lines.map((l) => toneLine(l, width)),
-            emptyNote: "(loading pending changes…)",
+            body: backlogLines(planListLines(plans), listed("bug"), listed("question"), plans.length, answered, finished)
+                .slice(0, eventBudget)
+                .map((l) => toneLine(l, width, /^(?:plans|open bugs|open questions|answered recently|done recently|fixed recently) \(\d+\):$/.test(l) ? "bold" : l.startsWith("(") ? "dim" : undefined)),
+            emptyNote: "(no events yet)",
         };
     }
-    if (pane.kind === "health") {
-        const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, eventBudget, width) : { lines: [] };
+    // Entry browsing: the selected entry's full body under a line naming its section and
+    // title.
+    const e = flat[sel];
+    const win = entryBodyWindow(e.body, state.entryScroll, entryBudget, width);
+    return {
+        body: [toneLine(`${e.label}: ${e.title}${e.mark}`, width, "bold"), ...win.lines.map((l) => toneLine(l, width))],
+        emptyNote: "(no events yet)",
+    };
+}
+function historyBody(pane, opts) {
+    const { width, eventBudget, state } = opts;
+    // The run trail (Ctrl+N) windows the cached renderRunDetail text; a null cache (the
+    // read found no run) paints the pane's own note rather than entryBodyWindow's placeholder.
+    if (pane.trail) {
+        if (state.trailCache === null)
+            return { body: [], emptyNote: "(no run trail)" };
+        const win = entryBodyWindow(state.trailCache, state.paneScroll, eventBudget, width);
         return {
             body: win.lines.map((l) => toneLine(l, width)),
-            emptyNote: "(running health checks…)",
+            emptyNote: "(no run trail)",
         };
     }
-    if (pane.kind === "brief") {
-        const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, eventBudget, width) : { lines: [] };
+    // historyPaneText returns "" when the log holds no completed runs; return no lines
+    // (rather than windowing an empty string, which entryBodyWindow replaces with its
+    // "no details" placeholder) so the frame prints the pane's own empty note instead.
+    const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, eventBudget, width) : { lines: [] };
+    return {
+        body: win.lines.map((l) => toneLine(l, width)),
+        emptyNote: "(no runs yet)",
+    };
+}
+function pendingBody(_pane, opts) {
+    const { width, eventBudget, state } = opts;
+    // A selected queued merge shows its detail in place of the queue list; otherwise paneCache
+    // stays null until the async collector resolves (the Ctrl+T handler kicks it off
+    // fire-and-forget); like history, return no lines while null so the frame prints the
+    // loading note rather than windowing an empty string into the "no details" placeholder.
+    if (state.queueDetail) {
+        const detail = state.queueDetail;
+        const sel = entryBodyWindow(detail, state.paneScroll, eventBudget, width);
         return {
-            body: win.lines.map((l) => toneLine(l, width)),
-            emptyNote: "(no project brief with a prompt block — run `tumwater init` first)",
+            body: sel.lines.map((l) => toneLine(l, width)),
+            emptyNote: "(loading pending changes…)",
         };
     }
-    if (pane.kind === "queued") {
-        // A set selection shows the row's full prompt under a cancel header (the numbered list
-        // clips long prompts); list mode windows the cached renderQueuedList string, which is
-        // computed synchronously on Ctrl+T entry over the same queue `tumwater prompt --list`
-        // prints, so paneCache is already set this frame. An empty queue falls to the pane's
-        // own note either way.
-        const sel = state.selectedQueued === null || state.queuedRows.length === 0
-            ? null
-            : Math.min(state.selectedQueued, state.queuedRows.length - 1);
-        if (sel !== null) {
-            const row = state.queuedRows[sel];
-            const win = entryBodyWindow(row.text, state.paneScroll, entryBudget, width);
-            return {
-                body: [
-                    toneLine(`${row.role}'s inbox #${row.position} (Ctrl+X to cancel)`, width, "bold"),
-                    ...win.lines.map((l) => toneLine(l, width)),
-                ],
-                emptyNote: "(inbox empty)",
-            };
-        }
-        // An applied search names itself above the list; one that matched nothing says so instead
-        // of claiming the inbox is empty.
-        const searchLine = pane.grep ? [toneLine(`search: "${pane.grep}"`, width, "bold")] : [];
-        if (pane.grep && state.queuedRows.length === 0) {
-            return { body: [...searchLine, toneLine(`(no queued prompt matches "${pane.grep}")`, width)], emptyNote: "(inbox empty)" };
-        }
-        const listBudget = Math.max(1, eventBudget - searchLine.length);
-        const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, listBudget, width) : { lines: [] };
+    const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, eventBudget, width) : { lines: [] };
+    return {
+        body: win.lines.map((l) => toneLine(l, width)),
+        emptyNote: "(loading pending changes…)",
+    };
+}
+function healthBody(_pane, opts) {
+    const { width, eventBudget, state } = opts;
+    const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, eventBudget, width) : { lines: [] };
+    return {
+        body: win.lines.map((l) => toneLine(l, width)),
+        emptyNote: "(running health checks…)",
+    };
+}
+function briefBody(_pane, opts) {
+    const { width, eventBudget, state } = opts;
+    const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, eventBudget, width) : { lines: [] };
+    return {
+        body: win.lines.map((l) => toneLine(l, width)),
+        emptyNote: "(no project brief with a prompt block — run `tumwater init` first)",
+    };
+}
+function queuedBody(pane, opts) {
+    const { width, eventBudget, entryBudget, state } = opts;
+    // A set selection shows the row's full prompt under a cancel header (the numbered list
+    // clips long prompts); list mode windows the cached renderQueuedList string, which is
+    // computed synchronously on Ctrl+T entry over the same queue `tumwater prompt --list`
+    // prints, so paneCache is already set this frame. An empty queue falls to the pane's
+    // own note either way.
+    const sel = state.selectedQueued === null || state.queuedRows.length === 0
+        ? null
+        : Math.min(state.selectedQueued, state.queuedRows.length - 1);
+    if (sel !== null) {
+        const row = state.queuedRows[sel];
+        const win = entryBodyWindow(row.text, state.paneScroll, entryBudget, width);
         return {
-            body: [...searchLine, ...win.lines.map((l) => toneLine(l, width))],
+            body: [
+                toneLine(`${row.role}'s inbox #${row.position} (Ctrl+X to cancel)`, width, "bold"),
+                ...win.lines.map((l) => toneLine(l, width)),
+            ],
             emptyNote: "(inbox empty)",
         };
     }
-    if (pane.kind === "usage" || pane.kind === "failures") {
-        // The Markdown `tumwater report`/`report --failures` prints, windowed like backlog entry
-        // mode. The cache is set on view entry by the Ctrl+T handler, so this only re-windows a string.
-        const win = entryBodyWindow(state.paneCache ?? "", state.paneScroll, eventBudget, width);
-        return {
-            body: win.lines.map((l) => toneLine(l, width, l.startsWith("#") ? "bold" : undefined)),
-            emptyNote: "(no events yet)",
-        };
+    // An applied search names itself above the list; one that matched nothing says so instead
+    // of claiming the inbox is empty.
+    const searchLine = pane.grep ? [toneLine(`search: "${pane.grep}"`, width, "bold")] : [];
+    if (pane.grep && state.queuedRows.length === 0) {
+        return { body: [...searchLine, toneLine(`(no queued prompt matches "${pane.grep}")`, width)], emptyNote: "(inbox empty)" };
     }
+    const listBudget = Math.max(1, eventBudget - searchLine.length);
+    const win = state.paneCache ? entryBodyWindow(state.paneCache, state.paneScroll, listBudget, width) : { lines: [] };
+    return {
+        body: [...searchLine, ...win.lines.map((l) => toneLine(l, width))],
+        emptyNote: "(inbox empty)",
+    };
+}
+function reportBody(_pane, opts) {
+    const { width, eventBudget, state } = opts;
+    // The Markdown `tumwater report`/`report --failures` prints, windowed like backlog entry
+    // mode. The cache is set on view entry by the Ctrl+T handler, so this only re-windows a string.
+    const win = entryBodyWindow(state.paneCache ?? "", state.paneScroll, eventBudget, width);
+    return {
+        body: win.lines.map((l) => toneLine(l, width, l.startsWith("#") ? "bold" : undefined)),
+        emptyNote: "(no events yet)",
+    };
+}
+function activityBody(pane, opts) {
+    const { root, width, eventBudget, state } = opts;
     // The Activity pane loads a fixed tail once per read, narrows it by the active role scope
     // and text search, and windows it: null follows the live tail (the newest eventBudget
     // events), a stored offset pages back through the loaded events. Both clamp to

package/dist/src/ui/tui/tui-panes.js

@@ -176,9 +176,8 @@ export function createTuiPanes(deps) {
         if (key.ctrl && key.name === "p" && (session.view === session.roleIds.length + 2 || session.view === session.roleIds.length + 3)) {
             return report.handleKey?.(key, ctx) ?? false;
         }
-        // Health owns Ctrl+P (re-probe image-input models) ahead of History's fallback.
-        if (key.ctrl && key.name === "p" && session.view === session.roleIds.length + 7)
-            return health.handleKey?.(key, ctx) ?? false;
+        // Health owns none of the Ctrl+P cycle now that the image-model re-probe is gone; it
+        // falls through to History's Ctrl+P below.
         if (key.ctrl && key.name === "p")
             return history.handleKey?.(key, ctx) ?? false;
         return false;

package/dist/src/ui/tui/tui.js

@@ -2,8 +2,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { render as inkRender } from "ink";
 import { TuiApp } from "./tui-app.js";
 import { openQuestions } from "../../backlog/backlog.js";
-import { operatorHeldEntries, refusedEntries, stalledEntries } from "../../backlog/backlog-eligibility.js";
-import { capacityContention, droppedPostReviewsAlert, flappedChecksAlert, instancePoolProblems, mainRuleFailures, notifyFailures, planDependencyAlert, postMergeChurnAlert, postReviewRiskAlert, primaryOverwriteBlocks, providerCapProblems, qaCoverageAlert, quarantineAlert, regressedFixesAlert, skippedMergeFiles, staleMerges, staleOpenBugs, staleOpenQuestions, stalePrompts, staleWaitingBugs, staleWorkspacePins } from "../alert-feeds.js";
+import { refusedEntries, stalledEntries } from "../../backlog/backlog-eligibility.js";
+import { capacityContention, instancePoolProblems, planDependencyAlert, providerCapProblems, regressedFixesAlert, staleOpenQuestions, staleWorkspacePins } from "../alert-feeds.js";
 import { strandedPlanEntriesFor } from "../../backlog/backlog-structure.js";
 import { duplicatedBacklogHeadings, fixClaimProblems, liveFinishedEntriesFor, validationGapProblems } from "../../doctor/doctor-backlog-plans.js";
 import { snapshot } from "../../status/status-data.js";
@@ -93,7 +93,7 @@ export async function runTui(root, seams = {}) {
         const view = s.view;
         // What needs the operator — the dashboard's alert banners (team-alerts.ts's teamAlerts), as
         // attention lines under the header. Each consumes one line of the height budget.
-        const attention = alertLines(teamAlerts(snap, openQuestions(root), status.roles, Date.now(), refusedEntries(root), operatorHeldEntries(root), staleOpenBugs(root), stalePrompts(root), staleMerges(root), planDependencyAlert(root), staleWaitingBugs(root), skippedMergeFiles(root), stalledEntries(root), quarantineAlert(root), strandedPlanEntriesFor(root), duplicatedBacklogHeadings(root), validationGapProblems(root), notifyFailures(root), primaryOverwriteBlocks(root), capacityContention(root), flappedChecksAlert(root), regressedFixesAlert(root, Date.now()), postMergeChurnAlert(root), postReviewRiskAlert(root), droppedPostReviewsAlert(root), mainRuleFailures(root, Date.now()), staleClaimEntries(root, status.roles.map((r) => r.role), Date.now()), staleOpenQuestions(root), fixClaimProblems(root), qaCoverageAlert(root, Date.now()), staleWorkspacePins(root, Date.now()), liveFinishedEntriesFor(root), instancePoolProblems(root), providerCapProblems(root)), width);
+        const attention = alertLines(teamAlerts(snap, openQuestions(root), status.roles, Date.now(), refusedEntries(root), planDependencyAlert(root), stalledEntries(root), strandedPlanEntriesFor(root), duplicatedBacklogHeadings(root), validationGapProblems(root), capacityContention(root), regressedFixesAlert(root, Date.now()), staleClaimEntries(root, status.roles.map((r) => r.role), Date.now()), staleOpenQuestions(root), fixClaimProblems(root), staleWorkspacePins(root, Date.now()), liveFinishedEntriesFor(root), instancePoolProblems(root), providerCapProblems(root)), width);
         const statusLines = [status.lines[0] ?? [], ...attention, ...status.lines.slice(1)];
         // Numbered previews of prompts queued for the director, between the table and the
         // activity pane: what will run next, in execution order. Each line consumes exactly

package/dist/src/verdict/fix-claim.js

@@ -43,7 +43,7 @@
  * - A `path:line` location (`status-roles.ts:66`) was checked as a symbol, and no file is named
  *   that. A location now claims its file, a bare line reference (`:368`) claims nothing, and a
  *   bare file name is backed by a file of that name anywhere in the walked source dirs. */
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync, statSync } from "node:fs";
 import { extname, join } from "node:path";
 import { readTextOrNull, statOrNull, walkFiles } from "../files/files.js";
 import { fenceTracker, finishedArchiveOf, parseEntryDetails, sectionLines, trailingParenthetical, } from "../backlog/backlog-md.js";
@@ -307,11 +307,23 @@ export async function falseFixReason(wt, mainBranch, files) {
     // is no claim at all. Both sides of the comparison read both files.
     if (!files.includes("BUGS.md") && !files.includes(BUGS_ARCHIVE))
         return undefined;
-    // A deleted or unreadable file reads as empty: there is no Fixed transition to verify,
-    // so this check passes and lets the gate's sibling structural check (backlog-structure.ts)
-    // report the dropped section. Reading it raw would throw ENOENT out of the gate instead —
-    // and a file the change deletes is exactly the input the sibling check already handles.
-    const heads = ["BUGS.md", BUGS_ARCHIVE].map((f) => readTextOrNull(join(wt, f)) ?? "");
+    // A deleted, unreadable, or non-regular (symlinked) file reads as empty: there is no Fixed
+    // transition to verify, so this check passes and lets the gate's sibling structural check
+    // (backlog-structure.ts) report the dropped section. Reading a symlink raw would pull an
+    // outside host file's `## Fixed` heading into this gate's verdict (the same lstat policy the
+    // backlog-conflict resolver and backlogStructureReason pin under INV-G3), so a head is read
+    // only when lstat shows a regular file; ENOENT and symlinks both read as empty.
+    const heads = ["BUGS.md", BUGS_ARCHIVE].map((f) => {
+        const full = join(wt, f);
+        try {
+            if (!lstatSync(full).isFile())
+                return "";
+        }
+        catch {
+            return "";
+        }
+        return readTextOrNull(full) ?? "";
+    });
     if (!heads.some((head) => head.includes("## Fixed")))
         return undefined;
     // The diff's own base, not main's tip: the gate diffs `mainBranch...HEAD` against the

package/dist/src/verdict/refusal.js

@@ -88,6 +88,15 @@ export function newlyRefusedTitles(baseMd, headMd, section) {
  * logs a warning and leaves PLANS.md out of the commit, so the other notes still merge. */
 export async function handleRefusal(ctx, state, wt, pi) {
     const reason = (pi.refusedReason ?? "").trim() || "no reason given";
+    const plansUnstripped = await stripBlockedPlanRefusalNotes(ctx, wt);
+    const notes = await collectRefusalNotes(wt, plansUnstripped);
+    const entries = await collectRefusedEntryTitles(ctx, wt, notes);
+    return mergeRefusalNotes(ctx, state, wt, reason, notes, entries);
+}
+/** Strip this run's newly added Refused notes from any `## Planned` entry main still holds as
+ * blocked by a planned prerequisite. Returns whether the strip write failed: a throw leaves the
+ * flag set and PLANS.md out of the commit, so the other notes still merge. */
+async function stripBlockedPlanRefusalNotes(ctx, wt) {
     const plansFile = path.join(wt, "PLANS.md");
     let plansUnstripped = false;
     if (fs.existsSync(plansFile)) {
@@ -118,9 +127,17 @@ export async function handleRefusal(ctx, state, wt, pi) {
             }
         }
     }
-    const notes = (await changedFiles(wt)).filter((f) => f.toLowerCase().endsWith(".md") && !(plansUnstripped && f === "PLANS.md"));
+    return plansUnstripped;
+}
+/** The markdown notes this refusal may commit: changed `.md` files, PLANS.md dropped only when
+ * the blocked-plan strip write failed. */
+async function collectRefusalNotes(wt, plansUnstripped) {
+    return (await changedFiles(wt)).filter((f) => f.toLowerCase().endsWith(".md") && !(plansUnstripped && f === "PLANS.md"));
+}
+/** Best-effort names for the entry_refused event, per changed file's section — it must never
+ * fail the refusal, so a read error swallows and leaves that file unnamed. */
+async function collectRefusedEntryTitles(ctx, wt, notes) {
     const entries = [];
-    // Best-effort naming for the entry_refused event; it must never fail the refusal.
     for (const { file, section } of [{ file: "PLANS.md", section: "Planned" }, { file: "BUGS.md", section: "Open" }]) {
         if (!notes.includes(file))
             continue;
@@ -131,10 +148,19 @@ export async function handleRefusal(ctx, state, wt, pi) {
             // Unnamed is fine: the event still carries reason and files.
         }
     }
+    return entries;
+}
+/** Merge this refusal's notes onto main: commit only the markdown notes (subject + trailer only —
+ * a refusal carries no WHY/RISK/VERIFIED body; the reason is the subject, and the trailer's turn
+ * count is the same field the friction flag reads), then merge directly. A failed note merge (a
+ * throw such as a lock timeout, or a non-"changed" result) is recorded in `state.lastError` and
+ * reported through the "refused" result like any other non-merge. A merged refusal note supersedes
+ * a stale rejection exactly as applyMergeOutcome's merged branch does (this path merges directly,
+ * bypassing that fold), then pages the operator: the entry stays held until a human or the
+ * director lifts it. */
+async function mergeRefusalNotes(ctx, state, wt, reason, notes, entries) {
     let commit;
     if (notes.length > 0) {
-        // Subject + trailer only — a refusal carries no WHY/RISK/VERIFIED body; the reason is
-        // the subject, and the trailer's turn count is the same field the friction flag reads.
         const message = buildCommitMessage(stampedSubject(baseRoleOf(ctx.role), `refuse — ${reason}`), null, commitTrailer(ctx.role, state.runs, ctx.turns, state.peakContextTokens, undefined, undefined, ctx.modelLine));
         commit = (await commitPathsAndDiscardRest(wt, message, notes)) ?? undefined;
     }
@@ -156,8 +182,6 @@ export async function handleRefusal(ctx, state, wt, pi) {
     }
     if (result !== "changed")
         state.lastError = `refusal note merge failed: ${result}`;
-    // A merged refusal note is a merged change too: it supersedes a stale rejection exactly as
-    // applyMergeOutcome's merged branch does (this path merges directly, bypassing that fold).
     else {
         clearSupersededRejection(state);
         // Page the operator: the entry stays held until a human or the director lifts it. Best-effort —

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tumwater",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Opinionated autonomous development harness built on pi. You write the initial prompt; role-driven loops build the project.",
   "type": "module",
   "license": "MIT",