tumwater 0.4.0 → 0.4.2

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

@@ -47,6 +47,8 @@ export function createTuiPanes(deps) {
         session.dropBrokenPinsArmed = false;
         session.armedRetireLeftovers = session.retireLeftoversArmed;
         session.retireLeftoversArmed = false;
+        session.armedArchiveBacklog = session.archiveBacklogArmed;
+        session.archiveBacklogArmed = false;
         session.armedRevert = session.revertArmed;
         session.revertArmed = null;
         session.armedQueue = session.queueArmed;
@@ -114,57 +116,47 @@ export function createTuiPanes(deps) {
         }
         session.requestRender();
     };
-    /** Run the pane arms of the key dispatch; true when one consumed the key. `es` is the
-     * editors' state, so the exclusion guards read the flags the editors hold. Each pane module
-     * checks its own view/guard and returns true only when it consumed the key; this router keeps
-     * the keys that multiple panes serve in today's priority order. */
-    const handleKey = (key, es) => {
-        // The editor flags below are all false here — the editors consume every key that reads or
-        // writes the line and return true whenever one is open — but each module restates its
-        // mutual-exclusion guard so it reads on its own instead of leaning on the routing order.
-        const ctx = { es };
-        if (key.ctrl && key.name === "n") {
-            // Ctrl+N means four different things. The Health arm is routed first so its notify-test
-            // action is reachable on Health; the History trail arm second, which falls through
-            // (returns false) unless the History view is selected; the Pending overlap drill-down
-            // third, with the same fall-through; the transcript pane's notes/change arm last.
-            // The order among them is NOT immaterial: the transcript arm
-            // consumes Ctrl+N whenever it is reached — it returns true with a render even off a
-            // transcript view — so it must sit last, as the fallback, or it would swallow the key
-            // before the Health or History arm ever saw it.
-            if (health.handleKey?.(key, ctx))
-                return true;
-            if (history.handleKey?.(key, ctx))
-                return true;
-            if (pending.handleKey?.(key, ctx))
-                return true;
-            return transcript.handleKey?.(key, ctx) ?? false;
-        }
-        if (key.ctrl && key.name === "g") {
-            // Ctrl+G's scope arm is routed by view: Activity on 0, the History exact-role scope on
-            // N+4, the Pending overlap scope on N+5, and the report team/base-role scope
-            // everywhere else — the priority the original else-branch chain kept, so the
-            // report arm never steals the History view's slot.
-            if (session.view === 0)
-                return activity.handleKey?.(key, ctx) ?? false;
-            if (session.view === session.roleIds.length + 4)
-                return history.handleKey?.(key, ctx) ?? false;
-            if (session.view === session.roleIds.length + 5)
-                return pending.handleKey?.(key, ctx) ?? false;
-            return report.handleKey?.(key, ctx) ?? false;
-        }
-        if (key.ctrl && key.name === "e") {
-            // Ctrl+E's Health reclaim arm is routed ahead of the report panes' trailing-window
-            // cycle; the Health arm's own view guard keeps Usage/Failures on their cycle, and the
-            // Backlog/Inbox edit arms (which live in the editors) are untouched.
-            if (health.handleKey?.(key, ctx))
-                return true;
-            return report.handleKey?.(key, ctx) ?? false;
-        }
-        if (key.ctrl && key.name === "k")
-            return health.handleKey?.(key, ctx) ?? false;
-        if (key.ctrl && key.name === "w")
+    const routeCtrlN = (key, ctx) => {
+        // Ctrl+N means four different things. The Health arm is routed first so its notify-test
+        // action is reachable on Health; the History trail arm second, which falls through
+        // (returns false) unless the History view is selected; the Pending overlap drill-down
+        // third, with the same fall-through; the transcript pane's notes/change arm last.
+        // The order among them is NOT immaterial: the transcript arm
+        // consumes Ctrl+N whenever it is reached — it returns true with a render even off a
+        // transcript view — so it must sit last, as the fallback, or it would swallow the key
+        // before the Health or History arm ever saw it.
+        if (health.handleKey?.(key, ctx))
+            return true;
+        if (history.handleKey?.(key, ctx))
+            return true;
+        if (pending.handleKey?.(key, ctx))
+            return true;
+        return transcript.handleKey?.(key, ctx) ?? false;
+    };
+    const routeCtrlG = (key, ctx) => {
+        // Ctrl+G's scope arm is routed by view: Activity on 0, the History exact-role scope on
+        // N+4, the Pending overlap scope on N+5, and the report team/base-role scope
+        // everywhere else — the priority the original else-branch chain kept, so the
+        // report arm never steals the History view's slot.
+        if (session.view === 0)
+            return activity.handleKey?.(key, ctx) ?? false;
+        if (session.view === session.roleIds.length + 4)
             return history.handleKey?.(key, ctx) ?? false;
+        if (session.view === session.roleIds.length + 5)
+            return pending.handleKey?.(key, ctx) ?? false;
+        return report.handleKey?.(key, ctx) ?? false;
+    };
+    const routeCtrlE = (key, ctx) => {
+        // Ctrl+E's Health reclaim arm is routed ahead of the report panes' trailing-window
+        // cycle; the Health arm's own view guard keeps Usage/Failures on their cycle, and the
+        // Backlog/Inbox edit arms (which live in the editors) are untouched.
+        if (health.handleKey?.(key, ctx))
+            return true;
+        return report.handleKey?.(key, ctx) ?? false;
+    };
+    const routeCtrlK = (key, ctx) => health.handleKey?.(key, ctx) ?? false;
+    const routeCtrlW = (key, ctx) => history.handleKey?.(key, ctx) ?? false;
+    const routeCtrlS = (key, ctx) => {
         // Health owns Ctrl+S (drop broken pins) ahead of the pane router's fallthrough; off the
         // Health view it falls through so the quiet-hours (Activity), trailing-window (History)
         // and min-run-interval (Transcript) arms keep their current meanings.
@@ -177,15 +169,20 @@ export function createTuiPanes(deps) {
         }
         if (key.ctrl && key.name === "s")
             return history.handleKey?.(key, ctx) ?? false;
+        return false;
+    };
+    const routeCtrlP = (key, ctx) => {
         // Ctrl+P on Usage/Failures steps the report window back; every other view is History's.
         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;
+    };
+    const routeCtrlA = (key, ctx) => {
         // Health owns Ctrl+A (commit-backlog) ahead of the pane router's fallthrough; the Backlog
         // view's Ctrl+A (the answer editor) is handled by tui-editor-answer.ts, which the key
         // dispatcher consults before this router, so this case never shadows it.
@@ -195,10 +192,24 @@ export function createTuiPanes(deps) {
         // Health's so the Health commit-backlog arm keeps its view's slot.
         if (key.ctrl && key.name === "a" && session.view === session.roleIds.length + 5)
             return pending.handleKey?.(key, ctx) ?? false;
+        return false;
+    };
+    const routeCtrlU = (key, ctx) => {
         // Health owns Ctrl+U (re-sync install) ahead of the pane router's fallthrough; off the
         // Health view it falls through so the prompt-line editor keeps Ctrl+U (kill-to-start).
         if (key.ctrl && key.name === "u" && session.view === session.roleIds.length + 7)
             return health.handleKey?.(key, ctx) ?? false;
+        return false;
+    };
+    const routeCtrlB = (key, ctx) => {
+        // Health owns Ctrl+B (archive backlog) ahead of the pane router's fallthrough; the prompt-
+        // line editors are consulted first, so the budget editor keeps Ctrl+B where it applies,
+        // and off the Health view Ctrl+B is otherwise unbound.
+        if (key.ctrl && key.name === "b" && session.view === session.roleIds.length + 7)
+            return health.handleKey?.(key, ctx) ?? false;
+        return false;
+    };
+    const routeCtrlL = (key, ctx) => {
         // Health owns Ctrl+L (retire leftovers) ahead of the pane router's fallthrough; off the
         // Health view it falls through so the Activity fallback shift (view 0) and the
         // instructions editor on a role's Transcript keep their current meanings.
@@ -209,104 +220,153 @@ export function createTuiPanes(deps) {
         // (handled in the editors ahead of this router) keep their current meanings.
         if (key.ctrl && key.name === "l")
             return history.handleKey?.(key, ctx) ?? false;
-        if (key.ctrl && key.name === "y") {
-            // Ctrl+Y's transcript change-step arm (the diffstat toggle) is routed first and falls
-            // through off it, so History keeps its Summary cycle on every other view.
-            if (transcript.handleKey?.(key, ctx))
-                return true;
-            return history.handleKey?.(key, ctx) ?? false;
-        }
-        if (key.ctrl && key.name === "o") {
-            // The Activity type cycle is routed first on its own view (0); on the Health view the
-            // problems-only toggle precedes the History outcome cycle; on the Pending view the
-            // post-merge review state filter is routed ahead of History's outcome cycle (its own arm
-            // consumes the key on Pending); on the Backlog view the Ready-only filter is routed
-            // ahead of History's outcome cycle, and every other view keeps the History outcome cycle.
-            if (session.view === 0)
-                return activity.handleKey?.(key, ctx) ?? false;
-            if (session.view === session.roleIds.length + 7)
-                return health.handleKey?.(key, ctx) ?? false;
-            if (session.view === session.roleIds.length + 5)
-                return pending.handleKey?.(key, ctx) ?? false;
-            if (session.view === session.roleIds.length + 1)
-                return backlog.handleKey?.(key, ctx) ?? false;
-            return history.handleKey?.(key, ctx) ?? false;
-        }
-        if (key.ctrl && key.name === "x") {
-            // The armed-clear Ctrl+X arms: the transcript notes first, then the History model filter,
-            // then the queued cancel, then the Pending merge cancel, then the backlog cancel — each
-            // returns false when its view/selection does not apply.
-            if (transcript.handleKey?.(key, ctx))
-                return true;
-            if (history.handleKey?.(key, ctx))
-                return true;
-            if (queued.handleKey?.(key, ctx))
-                return true;
-            if (pending.handleKey?.(key, ctx))
-                return true;
-            return backlog.handleKey?.(key, ctx) ?? false;
-        }
-        if (key.ctrl && key.name === "r") {
-            // The Ctrl+R arms: the Pending pane's queue/roster re-read, the Health pane's doctor
-            // re-run, the History trail's transcript cycle, then the backlog's release — each returns
-            // false when its view does not apply, so the order among them is immaterial.
-            if (pending.handleKey?.(key, ctx))
-                return true;
-            if (health.handleKey?.(key, ctx))
-                return true;
-            if (history.handleKey?.(key, ctx))
-                return true;
-            return backlog.handleKey?.(key, ctx) ?? false;
-        }
-        if (key.ctrl && key.name === "v") {
-            // The Ctrl+V arms, routed like Ctrl+X's: the History trail's revert, the queued
-            // prompt's move-to-top, then the Pending pane's merge move-to-top, and the backlog
-            // entry's move-to-top last — each returns false when its view/selection does not
-            // apply. The Activity attach editor's own Ctrl+V arm is guarded to view 0, so it
-            // still fires there ahead of this router.
-            if (history.handleKey?.(key, ctx))
-                return true;
-            if (queued.handleKey?.(key, ctx))
-                return true;
-            if (pending.handleKey?.(key, ctx))
-                return true;
+        return false;
+    };
+    const routeCtrlY = (key, ctx) => {
+        // Ctrl+Y's transcript change-step arm (the diffstat toggle) is routed first and falls
+        // through off it, so History keeps its Summary cycle on every other view.
+        if (transcript.handleKey?.(key, ctx))
+            return true;
+        return history.handleKey?.(key, ctx) ?? false;
+    };
+    const routeCtrlO = (key, ctx) => {
+        // The Activity type cycle is routed first on its own view (0); on the Health view the
+        // problems-only toggle precedes the History outcome cycle; on the Pending view the
+        // post-merge review state filter is routed ahead of History's outcome cycle (its own arm
+        // consumes the key on Pending); on the Backlog view the Ready-only filter is routed
+        // ahead of History's outcome cycle, and every other view keeps the History outcome cycle.
+        if (session.view === 0)
+            return activity.handleKey?.(key, ctx) ?? false;
+        if (session.view === session.roleIds.length + 7)
+            return health.handleKey?.(key, ctx) ?? false;
+        if (session.view === session.roleIds.length + 5)
+            return pending.handleKey?.(key, ctx) ?? false;
+        if (session.view === session.roleIds.length + 1)
             return backlog.handleKey?.(key, ctx) ?? false;
-        }
+        return history.handleKey?.(key, ctx) ?? false;
+    };
+    const routeCtrlX = (key, ctx) => {
+        // The armed-clear Ctrl+X arms: the transcript notes first, then the History model filter,
+        // then the queued cancel, then the Pending merge cancel, then the backlog cancel — each
+        // returns false when its view/selection does not apply.
+        if (transcript.handleKey?.(key, ctx))
+            return true;
+        if (history.handleKey?.(key, ctx))
+            return true;
+        if (queued.handleKey?.(key, ctx))
+            return true;
+        if (pending.handleKey?.(key, ctx))
+            return true;
+        return backlog.handleKey?.(key, ctx) ?? false;
+    };
+    const routeCtrlR = (key, ctx) => {
+        // The Ctrl+R arms: the Pending pane's queue/roster re-read, the Health pane's doctor
+        // re-run, the History trail's transcript cycle, then the backlog's release — each returns
+        // false when its view does not apply, so the order among them is immaterial.
+        if (pending.handleKey?.(key, ctx))
+            return true;
+        if (health.handleKey?.(key, ctx))
+            return true;
+        if (history.handleKey?.(key, ctx))
+            return true;
+        return backlog.handleKey?.(key, ctx) ?? false;
+    };
+    const routeCtrlV = (key, ctx) => {
+        // The Ctrl+V arms, routed like Ctrl+X's: the History trail's revert, the queued
+        // prompt's move-to-top, then the Pending pane's merge move-to-top, and the backlog
+        // entry's move-to-top last — each returns false when its view/selection does not
+        // apply. The Activity attach editor's own Ctrl+V arm is guarded to view 0, so it
+        // still fires there ahead of this router.
+        if (history.handleKey?.(key, ctx))
+            return true;
+        if (queued.handleKey?.(key, ctx))
+            return true;
+        if (pending.handleKey?.(key, ctx))
+            return true;
+        return backlog.handleKey?.(key, ctx) ?? false;
+    };
+    const routeArrow = (key, ctx) => {
+        // Entry-browse arrows: the backlog pane, then the Pending pane (merge-row selection),
+        // then the queued pane; every other view falls through so the editors' prompt-history
+        // recall keeps the arrows.
+        if (backlog.handleKey?.(key, ctx))
+            return true;
+        if (pending.handleKey?.(key, ctx))
+            return true;
+        if (queued.handleKey?.(key, ctx))
+            return true;
+        return false;
+    };
+    const routePage = (key, ctx) => {
+        // Within-body page routing in today's order: the Activity tail, the notes/change
+        // (transcript) and run-trail (history) bodies, the Markdown panes from report on, then
+        // the backlog entry body.
+        if (activity.handleKey?.(key, ctx))
+            return true;
+        if (transcript.handleKey?.(key, ctx))
+            return true;
+        if (history.handleKey?.(key, ctx))
+            return true;
+        if (report.handleKey?.(key, ctx))
+            return true;
+        if (backlog.handleKey?.(key, ctx))
+            return true;
+        return false;
+    };
+    const routeEscape = (key, ctx) => {
+        if (pending.handleKey?.(key, ctx))
+            return true;
+        return queued.handleKey?.(key, ctx) ?? false;
+    };
+    /** Run the pane arms of the key dispatch; true when one consumed the key. `es` is the
+     * editors' state, so the exclusion guards read the flags the editors hold. Each pane module
+     * checks its own view/guard and returns true only when it consumed the key; this router keeps
+     * the keys that multiple panes serve in today's priority order. */
+    const handleKey = (key, es) => {
+        // The editor flags below are all false here — the editors consume every key that reads or
+        // writes the line and return true whenever one is open — but each module restates its
+        // mutual-exclusion guard so it reads on its own instead of leaning on the routing order.
+        const ctx = { es };
+        if (key.ctrl && key.name === "n")
+            return routeCtrlN(key, ctx);
+        if (key.ctrl && key.name === "g")
+            return routeCtrlG(key, ctx);
+        if (key.ctrl && key.name === "e")
+            return routeCtrlE(key, ctx);
+        if (key.ctrl && key.name === "k")
+            return routeCtrlK(key, ctx);
+        if (key.ctrl && key.name === "w")
+            return routeCtrlW(key, ctx);
+        if (key.ctrl && key.name === "s")
+            return routeCtrlS(key, ctx);
+        if (key.ctrl && key.name === "p")
+            return routeCtrlP(key, ctx);
+        if (key.ctrl && key.name === "a")
+            return routeCtrlA(key, ctx);
+        if (key.ctrl && key.name === "u")
+            return routeCtrlU(key, ctx);
+        if (key.ctrl && key.name === "b")
+            return routeCtrlB(key, ctx);
+        if (key.ctrl && key.name === "l")
+            return routeCtrlL(key, ctx);
+        if (key.ctrl && key.name === "y")
+            return routeCtrlY(key, ctx);
+        if (key.ctrl && key.name === "o")
+            return routeCtrlO(key, ctx);
+        if (key.ctrl && key.name === "x")
+            return routeCtrlX(key, ctx);
+        if (key.ctrl && key.name === "r")
+            return routeCtrlR(key, ctx);
+        if (key.ctrl && key.name === "v")
+            return routeCtrlV(key, ctx);
         const arrow = arrowDir(key.name);
-        if (arrow !== null) {
-            // Entry-browse arrows: the backlog pane, then the Pending pane (merge-row selection),
-            // then the queued pane; every other view falls through so the editors' prompt-history
-            // recall keeps the arrows.
-            if (backlog.handleKey?.(key, ctx))
-                return true;
-            if (pending.handleKey?.(key, ctx))
-                return true;
-            if (queued.handleKey?.(key, ctx))
-                return true;
-            return false;
-        }
+        if (arrow !== null)
+            return routeArrow(key, ctx);
         const page = pageDir(key.name);
-        if (page !== null) {
-            // Within-body page routing in today's order: the Activity tail, the notes/change
-            // (transcript) and run-trail (history) bodies, the Markdown panes from report on, then
-            // the backlog entry body.
-            if (activity.handleKey?.(key, ctx))
-                return true;
-            if (transcript.handleKey?.(key, ctx))
-                return true;
-            if (history.handleKey?.(key, ctx))
-                return true;
-            if (report.handleKey?.(key, ctx))
-                return true;
-            if (backlog.handleKey?.(key, ctx))
-                return true;
-            return false;
-        }
-        if (key.name === "escape") {
-            if (pending.handleKey?.(key, ctx))
-                return true;
-            return queued.handleKey?.(key, ctx) ?? false;
-        }
+        if (page !== null)
+            return routePage(key, ctx);
+        if (key.name === "escape")
+            return routeEscape(key, ctx);
         return false;
     };
     /** Shift, clamp, and prune the pane state against a new roster. */
@@ -396,6 +456,9 @@ export function createTuiPanes(deps) {
         refreshQueued: queued.refreshQueued,
         refreshNotes: (role) => transcript.refreshNotes?.(role),
         refreshBrief: () => brief.refreshBrief?.(),
+        refreshReport: () => {
+            report.enter?.();
+        },
         clearBacklogSelection: backlog.clearBacklogSelection,
         applyHistorySearch: history.applySearch,
         applyActivitySearch: activity.applySearch,

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, mainRuleFailures, notifyFailures, planDependencyAlert, postMergeChurnAlert, postReviewRiskAlert, primaryOverwriteBlocks, qaCoverageAlert, quarantineAlert, regressedFixesAlert, skippedMergeFiles, staleMerges, staleOpenBugs, staleOpenQuestions, stalePrompts, staleWaitingBugs, staleWorkspacePins } from "../status-payload.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)), 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
@@ -124,7 +124,7 @@ export async function runTui(root, seams = {}) {
         // The frame as the ink tree draws it (tui-app.tsx): the same composed lines the
         // hand-painted string frame joined, as clipped StatusLines — one column row per line,
         // one styled Text per span, colors through tui-app.tsx's toneColor.
-        const mode = { budget: s.budgetMode, concurrencyMode: s.concurrencyMode, checksMode: s.checksMode, checkMode: s.checkMode, fallbackMode: s.fallbackMode, modelMode: s.modelMode, rolePromptFor: s.rolePromptFor, attachMode: s.attachMode, pauseEditMode: s.pauseEditMode, pauseEditRole: s.pauseEditRole, pauseEditWake: s.pauseEditWake, pauseEditStop: s.pauseEditStop, queuedEditFor: s.queuedEditFor, answerFor: s.answerFor, entryEditFor: s.entryEditFor, notesEditFor: s.notesEditFor, briefEditMode: s.briefEditMode, retireMode: s.retireMode, roleEnabledMode: s.roleEnabledMode, quietMode: s.quietMode, quietTeam: s.quietTeam, providerCapsMode: s.providerCapsMode, claudeReserveMode: s.claudeReserveMode, intervalMode: s.intervalMode, roleModelMode: s.roleModelMode, instructionsEditFor: s.instructionsEditFor, slotsMode: s.slotsMode, images: s.images, notifyMode: s.notifyMode, backendsMode: s.backendsMode, instancesMode: s.instancesMode };
+        const mode = { budget: s.budgetMode, concurrencyMode: s.concurrencyMode, checksMode: s.checksMode, checkMode: s.checkMode, fallbackMode: s.fallbackMode, modelMode: s.modelMode, rolePromptFor: s.rolePromptFor, attachMode: s.attachMode, pauseEditMode: s.pauseEditMode, pauseEditRole: s.pauseEditRole, pauseEditWake: s.pauseEditWake, pauseEditStop: s.pauseEditStop, queuedEditFor: s.queuedEditFor, answerFor: s.answerFor, entryEditFor: s.entryEditFor, notesEditFor: s.notesEditFor, briefEditMode: s.briefEditMode, retireMode: s.retireMode, releaseMode: s.releaseMode, roleEnabledMode: s.roleEnabledMode, quietMode: s.quietMode, quietTeam: s.quietTeam, providerCapsMode: s.providerCapsMode, claudeReserveMode: s.claudeReserveMode, intervalMode: s.intervalMode, roleModelMode: s.roleModelMode, instructionsEditFor: s.instructionsEditFor, slotsMode: s.slotsMode, images: s.images, notifyMode: s.notifyMode, backendsMode: s.backendsMode, instancesMode: s.instancesMode };
         const lines = [...statusLines, []]; // a blank row below the header
         for (const [i, preview] of queued.entries())
             lines.push(toneLine(`${i + 1}. ${preview}`, width));

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

@@ -3,7 +3,8 @@ import path from "node:path";
 import { commitPathsAndDiscardRest, fileContentAt } from "../git/git.js";
 import { writeTextAtomic } from "../files/files.js";
 import { parseEntryDetails } from "../backlog/backlog-md.js";
-import { actionableEntryRanges, stripEntryStamp } from "../backlog/backlog-structure.js";
+import { actionableEntryRanges } from "../backlog/backlog-index-data.js";
+import { stripEntryStamp } from "../backlog/backlog-structure.js";
 import { entryHoldAgainst, refusalNote, withoutRefusalNotes } from "../backlog/backlog-eligibility.js";
 import { entryKey, plannedPartKeys } from "../backlog/backlog-parts.js";
 import { baseRoleOf } from "../roles/runner-ids.js";
@@ -87,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)) {
@@ -117,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;
@@ -130,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;
     }
@@ -155,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.0",
+  "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",