tumwater 0.4.2 → 0.4.4

package/dist/src/ui/run-progress-model.js

@@ -1,3 +1,4 @@
+import { callBuffersOutput } from "../pi/command-shape.js";
 import { readLiveProgress } from "./progress-data.js";
 import { compactTokens } from "../text/format.js";
 import { pad2 } from "../text/datetime.js";
@@ -56,13 +57,14 @@ function progressOfRun(s, p) {
     return { ...p, quietMs: Math.min(p.quietMs, elapsed) };
 }
 /** The stall phrases a phase label can carry — inFlightDetail appends "tool call stalled:
- * <tool>" and "no agent output for <duration>" to the head — as a regex SOURCE string plus the
+ * <tool>", "no model reply for <duration>", and "no agent output for <duration>" to the head — as
+ * a regex SOURCE string plus the
  * compiled matcher, single-homed beside the code that renders those phrases. Every consumer
  * that must recognize a stall inside a rendered phase label goes through these two, so the
  * server-side alert (team-alert-status.ts) and the dashboard's browser twin (gui-client-model.ts,
  * interpolating the source into its String.raw script) cannot drift from the wording the cell
  * actually renders. */
-export const STALL_SOURCE = String.raw `tool call stalled[^·]*|no agent output for [^·]*`;
+export const STALL_SOURCE = String.raw `tool call stalled[^·]*|no model reply for [^·]*|no agent output for [^·]*`;
 /** STALL_SOURCE compiled — the server-side matcher (team-alert-status.ts's stuck alert). */
 export const STALL_RE = new RegExp(STALL_SOURCE);
 /** The shared parts assembly for an in-flight state cell: `head` (the phase label with its
@@ -83,9 +85,23 @@ export function inFlightDetail(head, p) {
     else if (p.lastTool)
         parts.push(p.lastTool);
     // Silence under five minutes is normal (slow local-model prefills, long tool calls);
-    // only flag a stall once at least five minutes have passed without any pi output.
-    if (p.quietMs >= 300_000)
+    // only flag a stall once at least five minutes have passed without any pi output. While a
+    // tool call that buffers its output (a redirect or pipe — the run prompt's prescribed
+    // `> check.log` verify shape) is open, that flat threshold would cry wolf inside the call's
+    // own generous wall-clock stall window: the silence is the prescribed shape, not a hang,
+    // and a real stall past that window has already named itself as `tool call stalled: <tool>`
+    // above. Defer to the call so a slow suite stops being read as a hang (BUGS.md 2026-10-28).
+    const hasOpenBuffered = p.openToolCalls?.some((call) => callBuffersOutput(p.agent, call.command || call.label)) ?? false;
+    // A model request left unanswered past the stall threshold names the cause instead: the
+    // provider has not replied (BUGS.md 2026-10-29). pi's retries write to the log, so the bare
+    // silence measure restarts with each attempt, while this one spans the whole wait.
+    if (p.unansweredReply) {
+        const { waitedMs, attempts } = p.unansweredReply;
+        parts.push(`no model reply for ${duration(waitedMs)}${attempts > 1 ? ` (${attempts} attempts)` : ""}`);
+    }
+    else if (p.quietMs >= 5 * 60_000 && !hasOpenBuffered) {
         parts.push(`no agent output for ${duration(p.quietMs)}`);
+    }
     return parts.join(" · ");
 }
 /** Which pi run kind (progress-data.ts's ProgressRunKind) a role's in-flight cells should read:

package/dist/src/ui/status-model.js

@@ -84,7 +84,7 @@ export function onErrorStreak(s) {
     return (errorStreakAtWarn(s) ||
         (s.lastResult === "quiet_killed" && (s.quietKillStreak ?? 0) >= QUIET_KILL_RESUME_LIMIT));
 }
-export function rolePhase(s, orchestratorRunning, root, budgetPaused = false, live, userPaused = false, merge, mainCheck, capPaused = false, quietHold, diskHeld = false, bootstrapHeld = false, maintenanceQuotaHold, permits, pausedUntilMs) {
+export function rolePhase(s, orchestratorRunning, root, budgetPaused = false, live, userPaused = false, merge, mainCheck, capPaused = false, quietHold, diskHeld = false, bootstrapHeld = false, maintenanceQuotaHold, pausedUntilMs) {
     if (!orchestratorRunning)
         return "stopped";
     // Merge queue 4/5 — the marker-driven merge label: only a role whose change record was
@@ -114,16 +114,6 @@ export function rolePhase(s, orchestratorRunning, root, budgetPaused = false, li
         // parked waiter visibly does not (BUGS.md 2026-09-24).
         if (s.parkedSince) {
             const parkedTime = duration(Date.now() - s.parkedSince);
-            // The parked waiter's provider key, named only while that key is the binding limit in
-            // the published permit snapshot (plans/provider-concurrency.md §8): the key is at its
-            // cap, so THIS waiter is queued on its provider, not on the team total — `awaiting
-            // omlx slot` tells the operator exactly which cap is full. A role parked on the total
-            // (no key, or an uncapped one) reads today's `awaiting slot` as before.
-            if (s.parkedOn !== undefined &&
-                permits !== undefined &&
-                isBindingLimit(permits, s.parkedOn)) {
-                return `waiting for ${s.parkedOn} ${parkedTime}`;
-            }
             return `waiting to start ${parkedTime}`;
         }
         // The director bypasses maxConcurrent (`usesSlot` is false for it), so its in-flight run
@@ -322,9 +312,6 @@ export function roleRowCells(snap, root, s) {
     snap.maintenanceQuota.held.includes(s.role)
         ? `waiting: maintenance allowance used ${snap.maintenanceQuota.used}/${snap.maintenanceQuota.allowance}`
         : undefined, 
-    // The permit pool's live state (plans/provider-concurrency.md §8): names the parked
-    // waiter's provider key in `awaiting <key> slot` when that key is at its cap.
-    snap.permits, 
     // A timed per-role pause's deadline — only when the role itself is individually paused
     // (in `pausedRoles`) and not under a team-wide pause, matching the GUI's phaseDetail
     // guard, so the team pause (whose countdown rides the header badge) never double-appends.
@@ -336,15 +323,6 @@ export function roleRowCells(snap, root, s) {
  * gui-client-model.ts interpolates ROLE_RANK_RULES, so the two dashboards cannot disagree
  * about which phases are in flight. */
 export const ACTIVE_PHASE_PREFIXES = ["working", "reviewing", "merging"];
-/** Whether `key` is the binding limit in the published permit snapshot: its cap is set and
- * its in-use already meets or exceeds it, so the pool is granting nothing more on that key and
- * a waiter carrying it is queued on the key, not on the team total. A key without a cap in
- * the snapshot (uncapped) is never binding. One home for the rule, shared by status-model's
- * `awaiting <key> slot` and the GUI chip's provider detail. */
-function isBindingLimit(permits, key) {
-    const entry = permits.byKey[key];
-    return entry?.limit !== undefined && entry.inUse >= entry.limit;
-}
 /** Is this phase one of the PERMIT-HOLDER in-flight states — the rows an operator counts
  * against maxConcurrent? The three labels come from rolePhase: `working …`, `reviewing …`,
  * and the marker-driven `merge …` (merge queue 4/5) — an approved change waiting for the merge
@@ -375,7 +353,7 @@ export function isActivePhase(phase) {
 export const ROLE_RANK_RULES = [
     { rank: -1, prefixes: ["director working"] },
     { rank: 0, active: true },
-    { rank: 1, prefixes: ["approved", "waiting to start", "waiting for "] },
+    { rank: 1, prefixes: ["approved", "waiting to start"] },
     { rank: 2, phases: ["failing", "main's check is failing"] },
     { rank: 3, phases: ["paused"] },
     { rank: 3, prefixes: ["paused", "waiting:"] },

package/dist/src/ui/status-payload.js

@@ -1,9 +1,8 @@
-import { answeredQuestionSummaries } from "../backlog/question-answer.js";
+import { answeredQuestionSummaries } from "../backlog/backlog-question-answer.js";
 import { completionDate, donePlanEntries, DONE_DATE_RE, FIXED_DATE_RE, fixedBugEntries, openBugs, openQuestions, plannedPlans } from "../backlog/backlog.js";
-import { backlogHolds, backlogInProgress, backlogMarks, refusedEntries, stalledEntries } from "../backlog/backlog-eligibility.js";
-import { finishedTitle, strandedPlanEntriesFor } from "../backlog/backlog-structure.js";
+import { backlogHolds, backlogInProgress, backlogMarks, refusedEntries } from "../backlog/backlog-eligibility.js";
+import { finishedTitle } from "../backlog/backlog-structure.js";
 import { groupBlockedSeries, partsLabel } from "../backlog/backlog-index-data.js";
-import { fixClaimProblems, validationGapProblems } from "../doctor/doctor-backlog-plans.js";
 import { readEvents } from "../events/event-read.js";
 import { eventFeedItem, formatEvent } from "../events/event-format.js";
 import { projectName } from "../project-name.js";
@@ -15,11 +14,9 @@ import { scopeSnapshotToRoles, snapshot } from "../status/status-data.js";
 import { bootstrapBadge, buildBadge, budgetBadge, diskBadge, mergeBadge, mainCheckBadge, mainCountsFragment, ciParityBadge, ciParityTone, permitsBadge, checksBadge, quietBadge, runWindowBadge, workspacesBadge } from "./badges.js";
 import { isActivePhase, roleRowCells, onErrorStreak } from "./status-model.js";
 import { yieldMultiplierFor } from "../scheduling/backoff.js";
-import { staleClaimEntries } from "../scheduling/claim-entries.js";
 import { teamAlerts } from "./team-alerts.js";
-import { duplicatedBacklogHeadings, liveFinishedEntriesFor } from "../doctor/doctor-backlog-plans.js";
 import { readPostReviews } from "../review/post-merge-review.js";
-import { capacityContention, instancePoolProblems, planDependencyAlert, providerCapProblems, regressedFixesAlert, staleOpenQuestions, staleWorkspacePins } from "./alert-feeds.js";
+import { getOrphanAlert } from "./alert-feeds.js";
 /** How many recent events the payload carries — enough for the dashboard's activity feed to
  * still show a screenful of notable events (merges, failures, questions) after it filters
  * out the routine ones (run starts, wakes, passing checks). */
@@ -61,9 +58,6 @@ function roleRows(snap, root) {
             // the dashboard can mark a row whose model tumwater.json did not name. Same conditional
             // spread as `model`, present on exactly the rows that carry the flag.
             ...(s.modelFromPi ? { modelFromPi: true } : {}),
-            // Model failure fallback (PLANS.md "Model failure fallback, part 2/2"): present only
-            // while the role's runs use another model, so the common row shape is unchanged.
-            ...(s.fallback ? { fallback: s.fallback } : {}),
             ...(s.slot ? { slot: s.slot, slotPinned: s.slotPinned === true } : {}),
             // Parallel work instances (plans/parallel-work-instances.md "Observability", part
             // 6/7): the backlog entry this instance claimed, shown by the dashboards while it is
@@ -173,7 +167,7 @@ function headerFields(root, snap, now) {
         // The header's daily-cost-budget badge preformatted through badges.ts's budgetBadge —
         // the same string the TUI/status table renders (n/a for an all-free team; `· no cap`
         // when disabled). Sent display-ready like buildBadge so the page cannot re-derive it.
-        budgetBadge: budgetBadge(snap.budget, snap.subscriptionWindows, snap.subscriptionOnly, now, snap.chain),
+        budgetBadge: budgetBadge(snap.budget, snap.chain),
         // The disk floor (plans/disk-floor.md, part 4/4): the raw block is machine-readable for
         // `status --json`, and the header badge is preformatted through badges.ts's diskBadge —
         // the same string the TUI/status header renders. Omitted (not null) when no orchestrator
@@ -294,7 +288,7 @@ function inboxFields(snap) {
     };
 }
 /** Budget and pause/scheduling state (status-payload.ts's field-group split): the daily
- * budget, its subscription windows, the fallback chain, operator/per-role pauses, the
+ * budget, the fallback chain, operator/per-role pauses, the
  * cap/maintenance holds, scheduled wakes, quiet hours, and the quiet badge. */
 function budgetAndPauseFields(snap) {
     return {
@@ -302,19 +296,6 @@ function budgetAndPauseFields(snap) {
         // reported) — machine-readable for `status --json`; the display-ready header badge is
         // the preformatted `budgetBadge`.
         budget: snap.budget,
-        // The subscription usage-window block (part 6d/7), absent on a pi-only or API-claude
-        // team — the same raw shape `status --json` carries, which the GUI's spend card reads
-        // to render the window (the preformatted budgetBadge above already folds it into the
-        // header for the TUI/status). Raw data, like budget.
-        ...(snap.claudeWindow ? { claudeWindow: snap.claudeWindow } : {}),
-        // The per-backend window blocks (part 3a/9): one entry per subscription backend in use,
-        // machine-readable for `status --json` beside claudeWindow. As of part 3b/9 the preformatted
-        // budgetBadge above folds the per-backend blocks — the most-constrained first — into the
-        // header, naming each backend's own window.
-        ...(snap.subscriptionWindows && snap.subscriptionWindows.length > 0 ? { subscriptionWindows: snap.subscriptionWindows } : {}),
-        // The team-global free-ness answer (part 3a/9); budgetBadge reads it to decide whether the
-        // window lines stand alone (subscription-only) beside the daily spend.
-        subscriptionOnly: snap.subscriptionOnly,
         // Each tier's fallback step (fallback chain part 7c/7), raw for the GUI side card.
         ...(snap.chain ? { chain: snap.chain } : {}),
         // Operator pause (`tumwater pause` marker present): every idle role's phase reads
@@ -419,7 +400,7 @@ function alertFields(root, snap, questions, roles, now) {
     return {
         // What needs the operator (team-alerts.ts's teamAlerts): the dashboard's alert banners and
         // the TUI's attention lines, phrased once.
-        alerts: teamAlerts(snap, questions, roles, now, refusedEntries(root), planDependencyAlert(root), stalledEntries(root), strandedPlanEntriesFor(root), duplicatedBacklogHeadings(root), validationGapProblems(root), capacityContention(root, now), regressedFixesAlert(root, now), staleClaimEntries(root, roles.map((r) => r.role), now), staleOpenQuestions(root, now), fixClaimProblems(root), staleWorkspacePins(root, now), liveFinishedEntriesFor(root), instancePoolProblems(root), providerCapProblems(root)),
+        alerts: teamAlerts(snap, questions, roles, now, refusedEntries(root), getOrphanAlert(root)),
     };
 }
 /** The one team-state document both observer surfaces carry: `GET /api/status` (gui/gui-server.ts)
@@ -446,12 +427,12 @@ export function statusPayload(root, now = Date.now(), scope = null, modelsPath =
     // Why each plan/bug is held (src/backlog/backlog-eligibility.ts): the same hold decision
     // the prompt's backlog index and `tumwater backlog` render, projected to the mark each
     // surface appends. Read once here, consumed as the parallel planHolds/bugHolds arrays below.
-    const marks = backlogMarks(root);
+    // Which blocked plans fold into a series row (computed before marks so credit, the same
+    // claims walk feeding both, is done once per poll — see backlogMarks' optional working arg).
+    const working = backlogInProgress(root);
+    const marks = backlogMarks(root, working);
     const holds = backlogHolds(root);
     const plans = plannedPlans(root);
-    // Which blocked plans fold into a series row: the grouping `plan --list` and the prompt's
-    // backlog index use, as a slot per plan (null for a plan that stays an ordinary row).
-    const working = backlogInProgress(root);
     const planSeries = planSeriesSlots(plans, holds, working);
     const roles = roleRows(snap, root);
     return {

package/dist/src/ui/status-render.js

@@ -1,22 +1,19 @@
 import { dailyCost } from "../budget/budget.js";
 import { clipToWidth, displayWidth } from "../text/text-width.js";
 import { compactTokens, contextShareLabel, usd } from "../text/format.js";
-import { formatTime, humanAgo, nextRunPhrase, pad2, secondsUntil } from "../text/datetime.js";
+import { DAY_MS, formatTime, humanAgo, nextRunPhrase, pad2, secondsUntil } from "../text/datetime.js";
 import { projectName } from "../project-name.js";
-import { bootstrapBadge, buildBadge, budgetBadge, subscriptionWindowTone, diskBadge, mergeBadge, mainCheckBadge, mainCheckVerdict, ciParityBadge, ciParityTone, pauseBadge, roleWakeMarker, permitsBadge, checksBadge, quietBadge, runWindowBadge, wakeBadge, workspacesBadge } from "./badges.js";
+import { bootstrapBadge, buildBadge, budgetBadge, diskBadge, mergeBadge, mainCheckBadge, mainCheckVerdict, ciParityBadge, ciParityTone, pauseBadge, roleWakeMarker, permitsBadge, checksBadge, quietBadge, runWindowBadge, wakeBadge, workspacesBadge } from "./badges.js";
 import { idleClaimText, isActivePhase, roleRowCells, onErrorStreak, sortRolesByState } from "./status-model.js";
 import { runProgress } from "./run-progress-model.js";
 import { eventTypeLabel } from "../events/event-labels.js";
 import { roleLabel } from "../roles/role-labels.js";
 import { yieldMultiplierFor, yieldMultiplierSuffix } from "../scheduling/backoff.js";
-import { staleClaimEntries } from "../scheduling/claim-entries.js";
 import { phaseTone, resultTone } from "./tone.js";
 import { teamAlerts } from "./team-alerts.js";
 import { openQuestions } from "../backlog/backlog.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 { refusedEntries } from "../backlog/backlog-eligibility.js";
+import { getOrphanAlert } from "./alert-feeds.js";
 /** The status RENDER layer: time/token cell formatters and the width-aware table shared by
  * `tumwater status` and the TUI. The labels, badges, and metrics it draws come from the shared
  * display model (status-model.ts); this module decides column widths and layout. Depends on
@@ -37,7 +34,7 @@ export function lastRunCell(ts) {
         return "-";
     const d = new Date(ts);
     let s = formatTime(d);
-    if (Date.now() - ts > 86_400_000)
+    if (Date.now() - ts > DAY_MS)
         s = `${pad2(d.getMonth() + 1)}-${pad2(d.getDate())} ${s}`;
     return `${s} · ${ago(ts)}`;
 }
@@ -174,13 +171,8 @@ function badgeSpans(badge, tone) {
     const sep = /^(?: · |, )/.exec(badge)?.[0] ?? "";
     return [{ text: sep }, { text: badge.slice(sep.length), ...(tone ? { tone } : {}) }];
 }
-/** The daily budget badge's tone: yellow from 85% of the cap, red once it is spent; the
- * subscription window's own severity (amber near its limit, red when a rejected window holds
- * the seams) wins when it stands beside the daily spend. */
-function budgetTone(budget, windows) {
-    const window = subscriptionWindowTone(windows);
-    if (window !== undefined)
-        return window;
+/** The daily budget badge's tone: yellow from 85% of the cap, red once it is spent. */
+function budgetTone(budget) {
     if (budget.free || !(budget.capUsd > 0))
         return undefined;
     const share = budget.spentUsd / budget.capUsd;
@@ -222,7 +214,7 @@ function statusHeaderLine(root, snap, now) {
     // empty unless the team marker's deadline stands in the future, so a role-only or
     // indefinite pause keeps today's header byte-identical.
     const running = snap.running
-        ? [{ text: "running", tone: "green" }, { text: ` (pid ${snap.pid}` }, ...badgeSpans(buildBadge(snap.build), snap.build?.stale ? "yellow" : undefined), { text: ")" }]
+        ? [{ text: "running", tone: "green" }, { text: ` (pid ${snap.pid}` }, ...badgeSpans(buildBadge(snap.build), snap.build?.stale || snap.build?.waitingForCheck ? "yellow" : undefined), { text: ")" }]
         : [{ text: "not running — start with `tumwater start`", tone: "dim" }];
     return [
         { text: "tumwater", tone: "brand" },
@@ -232,14 +224,14 @@ function statusHeaderLine(root, snap, now) {
         ...badgeSpans(mergeBadge(snap.mergeQueue), "blue"),
         ...(snap.inbox ? [{ text: ` · inbox: ${snap.inbox}` }] : []),
         ...(snap.questions ? badgeSpans(` · questions: ${snap.questions}`, "magenta") : []),
-        ...badgeSpans(budgetBadge(snap.budget, snap.subscriptionWindows, snap.subscriptionOnly, now, snap.chain), budgetTone(snap.budget, snap.subscriptionWindows)),
+        ...badgeSpans(budgetBadge(snap.budget, snap.chain), budgetTone(snap.budget)),
         // The disk floor (plans/disk-floor.md, part 4/4): `disk 8.2 GB free — holding new work`
         // while the hold is on, or the bare reading below the reclaim threshold. Empty in every
         // comfortable or unmeasured state, so an unaffected header stays byte-identical.
         ...badgeSpans(diskBadge(snap.disk), snap.disk?.held ? "yellow" : "blue"),
         // The permit pool's live state (plans/provider-concurrency.md §8): the team line reads
-        // `slots 5/8 · omlx 3/3` only while the per-provider cap map is set (permitsBadge already
-        // omits the providers on a map-less team, so the header stays byte-identical).
+        // `running 5 of 8` — the team total's in-use/cap — for any team with a published permit
+        // snapshot; empty until one has been published.
         ...badgeSpans(permitsBadge(snap.permits), "blue"),
         // Checks running/waiting for a check permit; empty while the check pool is idle.
         ...badgeSpans(checksBadge(snap.checkPermits), snap.checkPermits && snap.checkPermits.waiting > 0 ? "yellow" : "blue"),
@@ -306,14 +298,11 @@ function statusRoleRows(root, snap, now, withMetrics, sharedModel) {
         // today's.
         const inner = roleModelLabel(s);
         const modelSuffix = inner && !sharedModel ? ` (${inner})` : "";
-        // Model failure fallback, part 2/2: while the role runs off-model its name cell says so,
-        // so the operator can see which roles the fallback pair is carrying without reading logs.
-        const fallbackSuffix = s.fallback ? " (over-cap model)" : "";
         // User-defined roles (snapshot's `custom` flag) get an asterisk beside their name — the
         // dashboards' at-a-glance marker. The name column (index 0) is not in FLEXIBLE_COLUMNS;
         // its width derives from row content and it shrinks only after those,
         // so the extra character widens it.
-        const name = (s.custom ? `${roleLabel(s.role)}*` : roleLabel(s.role)) + modelSuffix + fallbackSuffix;
+        const name = (s.custom ? `${roleLabel(s.role)}*` : roleLabel(s.role)) + modelSuffix;
         const state = stateCell(root, s, phase, live);
         const tone = phaseTone(phase);
         // The whole state cell carries the phase's tone: a work item leads the cell (so it
@@ -509,7 +498,7 @@ export function renderStatus(root, snap, maxWidth, scoped = false) {
     // Composed here, NOT inside renderStatusSpans: the TUI re-slices that function's shared
     // `lines` (lines[0], its own attention block, then lines.slice(1)), so a banner embedded
     // there would render twice in the TUI.
-    const alerts = teamAlerts(snap, openQuestions(root), roles, Date.now(), refusedEntries(root), planDependencyAlert(root), stalledEntries(root), strandedPlanEntriesFor(root), duplicatedBacklogHeadings(root), validationGapProblems(root), capacityContention(root), regressedFixesAlert(root, Date.now()), staleClaimEntries(root, roles.map((r) => r.role), Date.now()), staleOpenQuestions(root), fixClaimProblems(root), staleWorkspacePins(root, Date.now()), liveFinishedEntriesFor(root), instancePoolProblems(root), providerCapProblems(root)).filter((a) => a.key !== "stopped");
+    const alerts = teamAlerts(snap, openQuestions(root), roles, Date.now(), refusedEntries(root), getOrphanAlert(root)).filter((a) => a.key !== "stopped");
     const banner = alertLines(alerts, maxWidth ?? Number.MAX_SAFE_INTEGER, alerts.length).map(plainText);
     const text = lines.map(plainText);
     return [...text.slice(0, 2), ...banner, ...text.slice(2)].join("\n");

package/dist/src/ui/team-alert-backlog.js

@@ -1,14 +1,11 @@
-/** The backlog team alerts, in emission order: open questions, refused entries, stalled
- * entries, a broken plan-dependency clause, stranded plans, duplicated backlog
- * headings, finished history still in the live backlog files, and Fixed records with a bad
- * Validation gap trace. One of the per-domain builders split out of src/ui/team-alerts.ts; the
- * shared types and wording helpers live in team-alert-shared.ts. */
-import { entryListDetail, firstAndMore, openBacklogAction } from "./team-alert-shared.js";
+/** The backlog team alerts, in emission order: open questions, refused entries. The two
+ * per-domain builders split out of src/ui/team-alerts.ts; the shared types and wording helpers
+ * live in team-alert-shared.ts. The stale questions, stalled entries, plan dependencies,
+ * stranded plans, duplicated headings, live finished history, validation gaps and false fixes
+ * banners moved to `tumwater doctor` rows (Subtract part 1e/6), each printing its row. */
+import { entryListDetail, openBacklogAction } from "./team-alert-shared.js";
 import { entryKindLabel } from "../backlog/backlog-eligibility.js";
-import { missingSymbolNames } from "../verdict/fix-claim.js";
-import { joinWithMore } from "../text/text.js";
 import { plural } from "../text/phrases.js";
-import { liveFinishedRowList } from "../backlog/backlog-archive.js";
 function pushQuestionsAlert(out, questions) {
     if (questions.length) {
         out.push({
@@ -20,29 +17,6 @@ function pushQuestionsAlert(out, questions) {
         });
     }
 }
-// A stale question (doctor's STALE_QUESTION_DAYS rule, src/doctor/doctor-backlog-bugs.ts
-// checkStaleQuestions) has waited a week without an answer — a role is stuck behind a decision,
-// the exact class every other backlog row raises as an amber alert — so it asks (amber), naming
-// the oldest question, its age, and the `tumwater questions
-// answer` fix. Its callers pass it oldest-first (alert-feeds.ts staleOpenQuestions sorts
-// most-days-waited first), so the first element is the most-stale question and is named with its
-// position and days; the rest are folded through entryListDetail like the questions and refused
-// alerts, so the wording and counts cannot drift. The `questions` action opens the Questions tab,
-// so the alert carries no row address.
-function pushStaleQuestionsAlert(out, staleQuestions) {
-    if (staleQuestions.length) {
-        const { first, more } = firstAndMore(staleQuestions, (q) => q.title);
-        out.push({
-            key: "stale-questions", // vocabulary-ok: the stale-questions amber alert's key
-            tone: "amber",
-            title: `${plural(staleQuestions.length, "open question waited", "open questions waited")} 7+ days for an answer`,
-            detail: `#${first.position} "${first.title}" has waited ${first.days}d for an answer` +
-                more +
-                ` · answer it with \`tumwater questions answer ${first.position} "<decision>"\`, or close it in QUESTIONS.md`,
-            actions: [{ label: "Answer", act: "questions" }],
-        });
-    }
-}
 // Refused entries hold until a human decides; amber because the operator has to act.
 function pushRefusedAlert(out, refused) {
     if (refused.length) {
@@ -56,181 +30,17 @@ function pushRefusedAlert(out, refused) {
         });
     }
 }
-// An entry parked by a Needs-review note (the doctor's `stalled entries` row)
-// sits until the plan role splits or replans it — amber because the plan role is the only
-// one that can clear it, naming the first such entry in file order, its file, its note kind,
-// and the fix. Same `entryHold` classification as `stalledEntries` and
-// `checkStalledEntries`, so the always-on alert and the doctor cannot disagree on which
-// holds are role-resolvable.
-function pushStalledEntriesAlert(out, stalledEntries) {
-    if (stalledEntries.length) {
-        const first = stalledEntries[0];
-        out.push({
-            key: "stalled-entries",
-            tone: "amber",
-            title: `${plural(stalledEntries.length, "backlog entry is stalled", "backlog entries are stalled")} in review`,
-            detail: `${entryKindLabel(first.file)} ${entryListDetail(stalledEntries.map((p) => p.title))} — a Needs review note parks it; the plan role splits or replans the entry, so one that keeps sitting here means the plan role is not running or keeps deferring`,
-            actions: openBacklogAction(first),
-        });
-    }
-}
-// A broken plan-dependency clause (the doctor's `plan dependencies` rule,
-// src/doctor/doctor-backlog-plans.ts planDependencyProblem, via alert-feeds.ts's
-// planDependencyAlert) is invisible in the backlog listings — the claim allocator keeps
-// acting on the misread clause — so it asks (amber), named by type
-// and carrying the doctor's exact message. One alert at most (the problem set is the single
-// most serious rule), and the fix is editing PLANS.md's heading, so there are no actions.
-function pushPlanDependencyAlert(out, planDependency) {
-    if (planDependency !== null) {
-        const titles = {
-            cycle: "Plan dependency cycle blocks a whole series",
-            dangling: "A plan requires a part no heading carries",
-            unparsed: "A plan's requires clause names no readable part",
-            misworded: "A plan's dependency wording holds nothing",
-        };
-        out.push({
-            key: "plan-dependencies",
-            tone: "amber",
-            title: titles[planDependency.kind],
-            detail: planDependency.message,
-            // The fix is editing PLANS.md, and the message names the heading and ref.
-            actions: [],
-        });
-    }
-}
-// A plan heading filed under the wrong ## section (the doctor's `plans stuck in Planned`
-// rule, checkStrandedPlans, src/doctor/doctor-backlog-plans.ts, via the shared
-// strandedPlanEntriesFor) sits invisible to every reader that scans the right section: a
-// `(planned …)` heading under ## Done never enters a Planned reader, and a done-dated heading
-// still under ## Planned invites a second implementation. The clean role repairs it only when
-// it happens to run and the doctor warns only on request, so it asks (amber) the way the
-// plan-dependency alert does, naming the first stranded heading, its file, its section, and
-// the section it belongs under; the rest are folded through joinWithMore.
-function pushStrandedPlansAlert(out, strandedPlans) {
-    if (strandedPlans.length) {
-        const { first, more } = firstAndMore(strandedPlans, (e) => `"${e.title}" in ${e.file ?? "PLANS.md"} ## ${e.section}`, (labels) => joinWithMore(labels, 3));
-        out.push({
-            key: "stranded-plans",
-            tone: "amber",
-            title: `${strandedPlans.length === 1 ? "A plan sits" : "Plans sit"} under the wrong backlog section`,
-            detail: `${first.file ?? "PLANS.md"} has a plan stranded under ## ${first.section}: "${first.title}"${more} — move it under ## ${first.section === "Done" ? "Planned" : "Done"}${first.file === undefined || first.file === "PLANS.md" ? "" : " in PLANS.md"} (the clean role repairs these)`,
-            // The fix is editing a backlog file, and a PLANS-DONE.md entry has no PLANS.md drawer index.
-            actions: [],
-        });
-    }
-}
-// A duplicated `## ` section heading already on main (the doctor's `backlog headings` row,
-// checkBacklogHeadings, src/doctor/doctor-backlog-plans.ts, via the shared
-// duplicatedBacklogHeadings) sits until a deliberate removal edit — the merge gate blocks
-// only a merge that ADDS another copy, so a duplicate already on main persists and hides
-// every later entry under its name from the `## ` section readers. It asks (amber) the way
-// the stranded-plan alert does, naming the first file-heading pair and folding the rest
-// through joinWithMore; the fix is editing a backlog file, so there are no actions.
-function pushBacklogHeadingsAlert(out, duplicatedHeadings) {
-    if (duplicatedHeadings.length) {
-        const { first, more } = firstAndMore(duplicatedHeadings, (d) => `"## ${d.heading}" in ${d.file}`, (labels) => joinWithMore(labels, 3));
-        out.push({
-            key: "backlog-headings",
-            tone: "amber",
-            title: plural(duplicatedHeadings.length, "duplicated backlog heading", "duplicated backlog headings"),
-            detail: `${first.file} "## ${first.heading}" appears more than once${more} — readers take the first section of a name, so later entries are invisible; remove the duplicate in a deliberate edit`,
-            actions: [],
-        });
-    }
-}
-// Finished history still in the live backlog files (the doctor's `backlog archive` rule,
-// checkLiveFinished, src/doctor/doctor-backlog-plans.ts, via the shared liveFinishedEntriesFor)
-// is the one backlog-hygiene rule the doctor warned but no always-on alert surfaced — every
-// other rule (stranded plans, duplicated headings, validation gaps, plan dependencies, stale
-// bugs and questions) has one, so an operator watching `tumwater status` or the dashboard never
-// sees the growing finished sections until they run `tumwater doctor`. It asks (amber) the way
-// the duplicated-heading alert does, naming each live file, its finished section, its entry
-// count, and its size in KB; the fix is the `tumwater archive` command, so there are no actions.
-function pushBacklogArchiveAlert(out, liveFinished) {
-    if (liveFinished.length) {
-        out.push({
-            key: "backlog-archive",
-            tone: "amber",
-            title: `${plural(liveFinished.length, "live backlog file still holds", "live backlog files still hold")} finished history`,
-            detail: liveFinishedRowList(liveFinished) +
-                " — every run that reads the file pays for them; `tumwater archive` moves them to the archive files",
-            // The fix is a command, not a drawer row.
-            actions: [],
-        });
-    }
-}
-// A Fixed record with a bad Validation gap trace (the doctor's `validation gaps` check,
-// src/doctor/doctor-backlog-plans.ts checkValidationGaps) is the always-on twin of that
-// doctor row: a newest Fixed record that omits its **Validation gap:** line, names a tag
-// outside the closed vocabulary, or declares `unclear-invariant` without pinning a
-// docs/invariants.md section is invisible or misleading to every closed-vocabulary consumer,
-// so it asks (amber) the way the stranded-plan alert does, naming the first offending record
-// and the fix. It is fed from the same scan (validationGapProblems over validationGapRecords)
-// the doctor's check uses, so the alert and the doctor cannot drift on the problem set, and
-// that scan runs no sourceHaystack walk, so it adds only the same two backlog-file reads the
-// doctor's check already makes to the poll path. The fix is editing BUGS.md, so it has no
-// buttons.
-function pushValidationGapsAlert(out, validationGaps) {
-    if (validationGaps.length) {
-        const { first, more } = firstAndMore(validationGaps, (v) => `"${v.title}"`, (labels) => joinWithMore(labels, 3));
-        const reason = first.kind === "missing"
-            ? "has no **Validation gap:** line"
-            : first.kind === "unrecognized"
-                ? `names unrecognized Validation gap tag "${first.tag}"`
-                : "is an unclear-invariant fix but names no docs/invariants.md section";
-        out.push({
-            key: "validation-gaps",
-            tone: "amber",
-            title: plural(validationGaps.length, "Fixed record has a validation-gap problem", "Fixed records have validation-gap problems"),
-            detail: `BUGS.md "${first.title}" ${reason}${more} — every Fixed entry writes exactly one known **Validation gap:** tag (write \`none\` rather than omitting it), and an unclear-invariant fix pins its reconstructed guarantee in docs/invariants.md`,
-            // The fix is editing BUGS.md.
-            actions: [],
-        });
-    }
-}
-// A newest Fixed record whose Fix paragraph names only code absent from the tree (the
-// doctor's `claimed bugs` check, src/doctor/doctor-backlog-plans.ts checkFixClaims) is the
-// always-on twin of that doctor row: a fix claim that names no live symbol is invisible to
-// every consumer that reads BUGS.md (BUGS-FIXED.md's long fight over an already-fixed entry),
-// so it asks (amber) the way the validation-gaps alert does, naming the first record and the
-// missing symbols. It is fed from the same scan (fixClaimProblems over fixClaimRecords) the
-// doctor's check uses, so the alert and the doctor cannot drift on the problem set, and that
-// scan reads the tree only when a file changed (cachedSourceHaystack), so it adds no re-read
-// to the 1 Hz poll path. The fix is editing BUGS.md, so it has no buttons.
-function pushFalseFixesAlert(out, fixClaims) {
-    if (fixClaims.length) {
-        const { first, more } = firstAndMore(fixClaims, (p) => `"${p.heading}"`, (labels) => joinWithMore(labels, 3));
-        out.push({
-            key: "false-fixes",
-            tone: "amber",
-            title: plural(fixClaims.length, "Fixed record names code that is not on this tree", "Fixed records name code that is not on this tree"),
-            detail: `BUGS.md records "${first.heading}" as Fixed, but none of the symbols its Fix paragraph names exist on this tree: ${missingSymbolNames(first.missing)}${more} — land the fix or keep the bug Open / refresh a stale record`,
-            // The fix is editing BUGS.md.
-            actions: [],
-        });
-    }
-}
-/** The backlog alerts, in emission order: open questions, refused entries, stalled
- * entries, a broken plan-dependency clause, stranded plans, duplicated backlog
- * headings, finished history still in the live backlog files, and Fixed records with a
- * bad Validation gap trace. Extracted from
- * teamAlerts (part 2/5 of the teamAlerts split) so the shared module stays small; the input
- * names exactly the fields this run reads. The caller pushes the returned alerts at the
- * position this run used to occupy, so the emitted key order is unchanged. Each alert arm is a
- * module-private builder named for its alert, in this same emission order, so a backlog alert
- * is found by name. */
+/** The backlog alerts, in emission order: open questions, refused entries. The conditions that
+ * used to raise the removed backlog banners each print their `tumwater doctor` row instead
+ * (Subtract part 1e/6). Extracted from teamAlerts (part 2/5 of the teamAlerts split) so the
+ * shared module stays small; the input names exactly the fields this run reads. The caller
+ * pushes the returned alerts at the position this run used to occupy, so the emitted key order
+ * is unchanged. Each alert arm is a module-private builder named for its alert, in this same
+ * emission order, so a backlog alert is found by name. */
 export function buildBacklogAlerts(input) {
     const out = [];
-    const { questions, staleQuestions, refused, stalledEntries, planDependency, strandedPlans, duplicatedHeadings, liveFinished, validationGaps, fixClaims, } = input;
+    const { questions, refused } = input;
     pushQuestionsAlert(out, questions);
-    pushStaleQuestionsAlert(out, staleQuestions);
     pushRefusedAlert(out, refused);
-    pushStalledEntriesAlert(out, stalledEntries);
-    pushPlanDependencyAlert(out, planDependency);
-    pushStrandedPlansAlert(out, strandedPlans);
-    pushBacklogHeadingsAlert(out, duplicatedHeadings);
-    pushBacklogArchiveAlert(out, liveFinished);
-    pushValidationGapsAlert(out, validationGaps);
-    pushFalseFixesAlert(out, fixClaims);
     return out;
 }

package/dist/src/ui/team-alert-shared.js

@@ -15,30 +15,6 @@ export function entryListDetail(titles) {
     const first = titles[0] === undefined ? "" : stripEntryStamp(titles[0]);
     return titles.length > 1 ? `${first} — and ${titles.length - 1} more` : first;
 }
-/** Append the folded names of the entries past an alert's first one, after a ` · ` separator,
- * when there are any, and the empty string otherwise — the shared idiom every amber
- * "name the oldest, fold the rest" alert (stale-questions, stranded-plans,
- * backlog-headings, validation-gaps, false-fixes) uses to compose its
- * `detail`, so the separator, the empty case, and the default fold (entryListDetail;
- * joinWithMore for the alerts that fold their rest labels with a count) cannot
- * drift. Callers pre-map each
- * rest element to the label the first clause already named. */
-function moreDetail(restLabels, fold = entryListDetail) {
-    return restLabels.length > 0 ? ` · ${fold(restLabels)}` : "";
-}
-/** Split a bounded entry list into its first (oldest, named) item and the " · rest" suffix
- * moreDetail builds for the entries past it — the shared shape every amber "name the oldest,
- * fold the rest" alert (stale-questions, stranded-plans,
- * backlog-headings, validation-gaps, false-fixes) composes, so
- * the split and the separator/empty case have one home beside moreDetail. `label` maps each
- * rest element to the string its clause already named; `fold` defaults to entryListDetail
- * (moreDetail's own default), with joinWithMore(labels, 3) for the alerts that fold their rest
- * labels with a count. */
-export function firstAndMore(items, label, fold = entryListDetail) {
-    const first = items[0];
-    const rest = items.slice(1);
-    return { first, more: moreDetail(rest.map(label), fold) };
-}
 /** The dashboard's "Open <role>" buttons for an alert about a set of roles: one button per
  * role (capped to the first three so the banner does not overflow), each opening that role's
  * pane. Shared by the failing, stuck, and no-image-target alerts, so the button shape and its
@@ -54,8 +30,8 @@ export function seeFailures() {
 }
 /** The dashboard's "Open backlog" button for an alert naming one backlog entry: opens the
  * entry's backlog-card tab and that row (the dashboard's backlog arm reads `file:index`).
- * Shared by the refused and stalled-entries alerts,
- * so the button shape and the `file:index` contract cannot drift between them. */
+ * Used by the refused alert,
+ * so the button shape and the `file:index` contract cannot drift. */
 export function openBacklogAction(entry) {
     return [{ label: "Open backlog", act: "backlog", arg: `${entry.file}:${entry.index}` }];
 }
@@ -77,11 +53,12 @@ export function listRoleIds(ids) {
 /** The stuck alert's per-role detail: the stall phrase the phase rendered, plus — when that
  * phrase does not already carry one — the honest silence span from the live tail (stuckMs,
  * ms since the role's last pi log write, capped to the run by progressOfRun). A
- * "no agent output for <d>" phrase already carries its duration, so only a tool-call stall gets
- * a " for <duration>" suffix, and only when the caller holds a live tail (stuckMs present). */
+ * "no agent output for <d>" or "no model reply for <d>" phrase already carries its duration, so
+ * only a tool-call stall gets a " for <duration>" suffix, and only when the caller holds a live
+ * tail (stuckMs present). */
 export function stuckDetail(l) {
     const cause = (STALL_RE.exec(l.phase)?.[0] ?? "").trim();
-    if (cause && !cause.startsWith("no agent output for") && l.stuckMs !== undefined) {
+    if (cause.startsWith("tool call stalled") && l.stuckMs !== undefined) {
         return `${roleLabel(l.role)}: ${cause} for ${duration(l.stuckMs)}`;
     }
     return `${roleLabel(l.role)}: ${cause}`;