tumwater 0.4.2 → 0.4.4

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

@@ -1,20 +1,16 @@
 /** The status/capacity and role-phase team alerts, in emission order: a spent budget
- * (chain/fallback/budget), per-role cap, disk, install, and main-red holds, roles failing run
- * after run or stuck, and a stale running build. 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 { staleClaimDetail } from "../scheduling/claim-entries.js";
-import { openRoleActions, seeFailures, listRoles, listRoleIds, stuckDetail, localizeInstants, } from "./team-alert-shared.js";
+ * (chain/fallback/budget), disk, install, and main-red holds, roles failing run after run or
+ * stuck. 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 { openRoleActions, seeFailures, listRoles, listRoleIds, stuckDetail, } from "./team-alert-shared.js";
 import { chainFragments } from "./badges.js";
 import { fallbackTierEntries } from "../budget/budget.js";
 import { fallbackDisplayPair } from "../config/config-views.js";
 import { agree, plural } from "../text/phrases.js";
-import { BRIEF_TEXT_MAX_CHARS } from "../brief/brief.js";
 import { formatGB, shortSha, usd, usdCap } from "../text/format.js";
 import { joinWithMore, squash } from "../text/text.js";
 import { roleLabel } from "../roles/role-labels.js";
 import { STALL_RE } from "./run-progress-model.js";
-import { ROLE_NOTES_MAX_BYTES } from "../agent/role-notes-write.js";
-import { PRINCIPLES_MAX_CHARS } from "../prompt/principles.js";
 function pushChainAlert(out, snap) {
     const onFallback = chainFragments(snap.chain);
     if (onFallback) {
@@ -60,23 +56,6 @@ function pushSpentBudgetAlert(out, snap) {
             });
     }
 }
-// A role over its maxDailyCostUsdPerRole cap (status-model.ts "waiting: daily cap spent") is
-// a per-role hold — one role sits idle while the rest of the team keeps working — so the team
-// banner names it the way the budget, disk, and quiet banners name theirs, instead of leaving
-// an operator to read every row. An amber ask (it needs a raise to resume); clears on its own
-// at local midnight when the spend window rolls over.
-function pushRoleCapAlert(out, snap, roles) {
-    const capPausedRoles = roles.filter((l) => snap.capPaused.includes(l.role));
-    if (snap.capPaused.length > 0) {
-        out.push({
-            key: "role-cap",
-            tone: "amber",
-            title: `${listRoleIds(snap.capPaused)} ${agree(snap.capPaused.length, "is over its daily cap", "are over their daily caps")}`,
-            detail: `The daily cap (maxDailyCostUsdPerRole) holds ${listRoleIds(snap.capPaused)}: no new runs until local midnight. Raise the cap to resume ${agree(snap.capPaused.length, "it", "them")}.`,
-            actions: openRoleActions(capPausedRoles),
-        });
-    }
-}
 // The disk floor holding new work (plans/disk-floor.md, part 4/4): the header badge and the
 // role rows say what is happening, but the banner names the threshold and the way out, so an
 // operator hitting a full volume does not have to read events. An amber ask — the team is
@@ -109,86 +88,6 @@ function pushInstallDriftAlert(out, snap) {
         });
     }
 }
-// No deterministic build check is declared (detectBuildCheck returned null): the review
-// gate's build pre-check, the red-main baseline and redeploy's green check have nothing to
-// run, and the header badge renders nothing (mainCheckBadge needs a build_check event).
-// The same state the doctor `check` row warns on, raised as a standing alert on the always-on
-// surfaces. Independent of team state (running or stopped), like the install alert beside it.
-function pushNoCheckAlert(out, snap) {
-    if (snap.noDeclaredCheck) {
-        out.push({
-            key: "no-check",
-            tone: "amber",
-            title: "No project check is declared — the safety gates are off",
-            detail: "The review gate's build pre-check, the red-main baseline and redeploy's green check have nothing to run. The plan role will plan this project's check and the feature role declare it — a test/typecheck/build npm script, or check.command. To skip the wait, declare it yourself; a project with nothing to verify yet stays as it is.",
-            actions: [],
-        });
-    }
-}
-// A brief candidate exists but none resolves to a usable prompt block (briefBlockMissing):
-// every run reaches its model with no project prompt, so the team burns tokens producing
-// work unrelated to the project. The same marker-less/unreadable/empty-block state the doctor
-// `brief` row warns on, raised as a standing alert on the always-on surfaces (the bare
-// pre-init repo stays silent). Independent of team state, like the no-check alert beside it.
-function pushNoBriefAlert(out, snap) {
-    if (snap.noBrief) {
-        out.push({
-            key: "no-brief",
-            tone: "amber",
-            title: "The project brief's prompt block is missing or empty — every role runs without its project prompt",
-            detail: "A brief file exists but carries no usable tumwater:prompt block (no markers, or no text between them), so each run's prompt reaches the model with no project brief. Restore the block in the file the doctor `brief` row names, or re-run `tumwater init`.",
-            actions: [],
-        });
-    }
-}
-// A brief block past the read cap (briefBlockOverCap): every run's prompt silently carries
-// only the head plus a truncation marker, so each role plans and codes against a cut brief.
-// The same over-cap state the doctor `brief` row warns on, raised as a standing alert on the
-// always-on surfaces; mutually exclusive with `no-brief` (an over-cap block is non-empty).
-function pushBriefTruncatedAlert(out, snap) {
-    if (snap.briefTruncated) {
-        out.push({
-            key: "brief-truncated",
-            tone: "amber",
-            title: "The project brief is over its prompt cap — every role runs on a truncated brief",
-            detail: "The brief block exceeds the read cap, so each run's prompt carries only its head plus a truncation marker. Shorten the block to at most " + BRIEF_TEXT_MAX_CHARS + " characters in the file the doctor `brief` row names (a hand edit, or the dashboard's Brief card), then save it.",
-            actions: [],
-        });
-    }
-}
-// A role note past the read bound (collectRoleNotesOverCap's predicate, the doctor `role
-// notes` row's own): `readRoleNote` truncates that role's note on read, so the role's next
-// prompt carries only the note's head plus a truncation marker while the operator sees the
-// file whole — a silently degraded next run on a green-looking status. The standing twin of
-// the doctor `role notes` row's warn, raised as an amber alert on the always-on surfaces.
-// Independent of team state, like the no-brief alert beside it.
-function pushRoleNotesTruncatedAlert(out, snap) {
-    const notesOver = snap.roleNotesOverCap ?? [];
-    if (notesOver.length > 0) {
-        out.push({
-            key: "role-notes-truncated",
-            tone: "amber",
-            title: `${plural(notesOver.length, "role note is", "role notes are")} over the read bound — those roles run on truncated notes`,
-            detail: `${joinWithMore(notesOver.map((o) => `${o.role} (${o.chars})`), 3)} exceed the ${ROLE_NOTES_MAX_BYTES}-character read bound, so each of those roles' prompt carries only the note's head plus a truncation marker. Rewrite them under the cap (the run's \`tumwater-notes write\` shim, \`tumwater role <id> --notes-file <path>\`, the dashboard drawer, or the TUI notes editor).`,
-            actions: [],
-        });
-    }
-}
-// PRINCIPLES.md is over its prompt cap (principlesBlockOverCap): every role's <principles>
-// block carries only its head plus a truncation marker, so the team runs on truncated design
-// guidance. The same over-cap state the doctor `principles` row warns on, raised as a standing
-// alert on the always-on surfaces. Independent of team state, like the no-brief alert beside it.
-function pushPrinciplesTruncatedAlert(out, snap) {
-    if (snap.principlesTruncated) {
-        out.push({
-            key: "principles-truncated",
-            tone: "amber",
-            title: "PRINCIPLES.md is over its prompt cap — every role runs on truncated design guidance",
-            detail: "The file exceeds the " + PRINCIPLES_MAX_CHARS + "-character prompt cap, so every run's <principles> block carries only its head plus a truncation marker and only the leading bullets survive. Keep PRINCIPLES.md to its list bullets and move long-form rationale into docs/, which is not injected.",
-            actions: [],
-        });
-    }
-}
 function pushMainRedAlert(out, snap, roles) {
     const red = roles.filter((l) => l.phase === "main's check is failing");
     if (red.length) {
@@ -246,81 +145,21 @@ function pushStuckRoleAlert(out, roles) {
         });
     }
 }
-function pushBuildAlert(out, snap) {
-    if (snap.build?.stale) {
-        const behind = plural(snap.build.aheadCommits ?? 0, "commit");
-        // The cooldown scopes the deferral to the redeploy, not the team (PLANS.md 2026-10-23): a
-        // restart held by the cooldown leaves the roles running on the stale build, so its alert
-        // reads blue "work continues" with the deadline, while a genuinely blocked restart (red main,
-        // a failed build, a boot refusal) stays the amber "restart blocked", and the momentary drain
-        // of an in-flight restart — the one stale state that actually holds new runs and merges —
-        // keeps the plain wording.
-        const deferred = snap.build.restartBlocked?.startsWith("cooldown until ");
-        out.push(deferred
-            ? {
-                key: "build",
-                tone: "blue",
-                title: `Update available (${behind} behind) — restarts after cooldown; work continues`,
-                detail: `Work continues on the running build; the restart lands when the cooldown lapses or you force it (${localizeInstants(snap.build.restartBlocked ?? "")}).`,
-                actions: [],
-            }
-            : snap.build.restartBlocked
-                ? {
-                    key: "build",
-                    tone: "amber",
-                    title: `Update available (${behind} behind) — restart blocked`,
-                    detail: localizeInstants(snap.build.restartBlocked),
-                    actions: [],
-                }
-                : {
-                    key: "build",
-                    tone: "blue",
-                    title: `Update available (${behind} behind)${snap.build.restartPending ? " — restarts when idle" : ""}`,
-                    detail: snap.build.restartPending ? "The team restarts onto it once running work finishes." : "Restart tumwater start to pick it up.",
-                    actions: [],
-                });
-    }
-}
-// A work-instance claim the operator should act on without running `tumwater doctor`
-// (src/scheduling/claim-entries.ts, the doctor's `parallel instances` row): a stopped
-// instance holding an entry that left its role's section, or idle past the scheduler's
-// release window, is an amber ask. One detail line per claim, worded like the doctor row so
-// the two cannot drift; actions open the first three claimed roles. Nothing when empty.
-function pushStaleClaimsAlert(out, staleClaims) {
-    if (staleClaims.length > 0) {
-        out.push({
-            key: "stale-claims",
-            tone: "amber",
-            title: `${plural(staleClaims.length, "work-instance claim is", "work-instance claims are")} stale`,
-            detail: staleClaims.map(staleClaimDetail).join("; "),
-            actions: openRoleActions(staleClaims.map((c) => ({ role: c.id }))),
-        });
-    }
-}
 /** The status/capacity and role-phase alerts, in emission order: a spent budget
- * (chain/fallback/budget), per-role cap, disk, install, and main-red holds, roles
- * failing run after run or stuck, and a stale running build. Extracted from
- * teamAlerts (part 1/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
+ * (chain/fallback/budget), disk, install, and main-red holds, roles failing run after run or
+ * stuck. Extracted from teamAlerts (part 1/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. */
 export function buildStatusAlerts(input) {
-    const { snap, roles, staleClaims } = input;
+    const { snap, roles } = input;
     const out = [];
     pushChainAlert(out, snap);
     pushSpentBudgetAlert(out, snap);
-    pushRoleCapAlert(out, snap, roles);
     pushDiskAlert(out, snap);
     pushInstallDriftAlert(out, snap);
-    pushNoCheckAlert(out, snap);
-    pushNoBriefAlert(out, snap);
-    pushBriefTruncatedAlert(out, snap);
-    pushRoleNotesTruncatedAlert(out, snap);
-    pushPrinciplesTruncatedAlert(out, snap);
     pushMainRedAlert(out, snap, roles);
     pushFailingStreakAlert(out, roles);
     pushStuckRoleAlert(out, roles);
-    pushBuildAlert(out, snap);
-    pushStaleClaimsAlert(out, staleClaims);
     return out;
 }

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

@@ -1,173 +1,6 @@
-/** The tail team alerts, in emission order: a run of quiet hours holding the team, a maintenance
- * allowance held at its rolling cap, a standing provider failure hold, an operator pause with
- * its countdown, the last day's capacity contention, a stale workspace pin, a fixed test that
- * regressed, a stopped tumwater, and roles that cannot or may not read images. 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 { listRoleIds, listRoles, openRoleActions, seeFailures } from "./team-alert-shared.js";
-import { stalePinPhrase } from "../doctor/doctor-contention-checks.js";
-import { quietWindowEnd } from "../scheduling/quiet-hours.js";
-import { pauseCountdown } from "./badges.js";
-import { agree, pauseReasonSuffix, plural } from "../text/phrases.js";
-import { humanUntil } from "../text/datetime.js";
-import { squash } from "../text/text.js";
-function pushQuietAlert(out, snap) {
-    // Quiet hours (plans: "Quiet hours … part 2/2, observability") informs rather than asks:
-    // the team holding to a schedule is not a problem, but an operator watching idle roles
-    // inside the window needs the same explanation the pause alert gives a paused team —
-    // why nothing runs, and when it starts again. The window end comes from quiet-hours.ts's
-    // quietWindowEnd, the same helper quietBadge uses for the header.
-    if (snap.inQuietHours && snap.quietHours) {
-        const end = quietWindowEnd(snap.quietHours);
-        out.push({
-            key: "quiet",
-            tone: "blue",
-            title: `Quiet hours — roles start no new runs until ${end}`,
-            detail: `The schedule (${snap.quietHours} local time, quietHours in tumwater.json) holds them. Runs in progress finish, and the director still runs your prompts.`,
-            actions: [],
-        });
-    }
-}
-function pushMaintenanceAlert(out, snap) {
-    // The maintenance allowance (plans/work-ratio.md, part 1b/4): by design and self-clearing —
-    // the scheduler holds maintenance roles at the rolling 24 h allowance until merges free room,
-    // then they run again on their own — so it informs (gray, no actions), the quiet alert's
-    // tone, rather than amber like the failed/refused asks. An operator watching idle maintenance
-    // roles gets the same explanation the hold's own row carries, team-wide.
-    if (snap.maintenanceQuota.held.length > 0) {
-        const mq = snap.maintenanceQuota;
-        out.push({
-            key: "maintenance",
-            tone: "gray",
-            title: "Maintenance is held at its rolling allowance",
-            detail: `${mq.used} of ${mq.allowance} maintenance allowance used over the last 24 h; ${listRoleIds(mq.held)} ${agree(mq.held.length, "resumes", "resume")} as work merges.`,
-            actions: [],
-        });
-    }
-}
-function pushProviderHoldAlert(out, snap, now) {
-    // A standing provider failure hold (src/team/team-hold.ts `standingHolds`, published through
-    // the orchestrator info file): a provider storm holds roles on that provider, so an operator
-    // watching idle roles with no log open sees why nothing new starts there. Self-clearing by
-    // design — the hold re-opens at its own deadline — so it informs (blue, no actions), the
-    // quiet and maintenance alerts' tone, rather than asking. The snapshot carries the holds only
-    // while a live orchestrator publishes one.
-    if (snap.providerHolds && snap.providerHolds.length > 0) {
-        const phrased = snap.providerHolds
-            .map((h) => `${h.provider ?? "pi's default backend"} (${h.kind}) until it re-opens in ${humanUntil(h.until, now)}`)
-            .join("; ");
-        out.push({
-            key: "provider-hold",
-            tone: "blue",
-            title: agree(snap.providerHolds.length, "Provider limit is holding new runs", "Provider limits are holding new runs"),
-            detail: `${phrased}. Runs in progress finish; roles on a held provider start no new runs until it re-opens.`,
-            actions: [],
-        });
-    }
-}
-function pushProviderCapsAlert(out, providerCaps) {
-    // A `maxConcurrentPerProvider` map that cannot do its job — the always-on twin of the doctor's
-    // `provider concurrency` row (doctor-contention-checks.ts checkProviderConcurrency): a cap key
-    // no seam resolves to, a cap at or above maxConcurrent, or a keyless seam in a capped team.
-    // The provider-hold and contention alerts cover a cap that is merely too small; this one
-    // names the static misconfiguration itself, which the doctor row is the only other surface
-    // that exposes. alert-feeds.ts's providerCapProblems feeds it the row's own warning strings,
-    // so the alert and the row cannot drift on the trigger or the wording.
-    if (providerCaps.length > 0) {
-        out.push({
-            key: "provider-caps",
-            tone: "amber",
-            title: "maxConcurrentPerProvider is misconfigured",
-            detail: `${providerCaps.join("; ")} — fix the map in tumwater.json (each key must name a provider the team runs on, and each cap must sit below maxConcurrent); the provider-hold and contention alerts cover a cap that is merely too small.`,
-            actions: [],
-        });
-    }
-}
-function pushPausedAlert(out, snap, now) {
-    if (snap.paused) {
-        const left = pauseCountdown(snap.pausedUntil, now);
-        out.push({
-            key: "paused",
-            tone: "amber",
-            // The operator's pause reason (`pause --reason <text>`) states verbatim, so an
-            // operator returning to a paused team knows why without digging through history.
-            title: left
-                ? `The team is paused and resumes in ${left}${pauseReasonSuffix(snap.pauseReason)}`
-                : `The team is paused${pauseReasonSuffix(snap.pauseReason)}`,
-            detail: "Roles start no new runs. Runs in progress finish, and the director still runs your prompts.",
-            actions: [{ label: "Resume now", act: "resume" }],
-        });
-    }
-}
-function pushContentionAlert(out, contention) {
-    // Last day's capacity contention — the always-on twin of the doctor's `workspaces`,
-    // `provider contention` and `check contention` rows (doctor-contention-checks.ts). The
-    // instantaneous badges show only current waits, and the 24 h total is the tuning signal that
-    // says a cap is too small; alert-feeds.ts's capacityContention feeds it from the same
-    // `*_wait` events and ten-minute thresholds the doctor sums, so the alert and the doctor
-    // cannot drift on the trigger or the knob-raising advice.
-    if (contention.length > 0) {
-        out.push({
-            key: "contention",
-            tone: "amber",
-            title: plural(contention.length, "capacity bottleneck in the last day", "capacity bottlenecks in the last day"),
-            detail: contention.map((c) => `${c.name}: ${squash(c.detail, 200)}`).join(" · "),
-            actions: [],
-        });
-    }
-}
-function pushWorkspacePinsAlert(out, workspacePins) {
-    // A stale workspace pin — the always-on twin of the doctor's `worktree pool` row's stuck-pin
-    // clause (doctor-contention-checks.ts checkWorktreePool): a slot pinned past a day by a run
-    // that never resumed silently shrinks the pool, and no other observer surface names it until
-    // an operator runs `tumwater doctor`. alert-feeds.ts feeds it the same staleWorkspacePins
-    // predicate the doctor's row uses, so the alert and the row cannot drift on what is stale;
-    // the "Open <role>" buttons reach the role drawer like the other role alerts.
-    if (workspacePins.length > 0) {
-        out.push({
-            key: "workspace-pins",
-            tone: "amber",
-            title: plural(workspacePins.length, "workspace pinned past a day", "workspaces pinned past a day"),
-            detail: `${workspacePins
-                .map(stalePinPhrase)
-                .join("; ")} — a pinned workspace is held out of the pool; resume the role, or retire its leftovers and run \`tumwater doctor\``,
-            actions: openRoleActions(workspacePins),
-        });
-    }
-}
-function pushInstancePoolAlert(out, instancePool) {
-    // An enabled multi-instance role sharing a workspace pool smaller than the run cap — the
-    // always-on twin of the doctor `parallel instances` row's pool-mismatch clause
-    // (doctor-contention-checks.ts smallPoolProblems): instances then contend for the same
-    // pooled checkouts, unseen until an operator runs `tumwater doctor`. alert-feeds.ts feeds
-    // it the same smallPoolProblems selector the row uses, so the alert and the row cannot
-    // drift on the trigger, the role list, or the wording.
-    if (instancePool.length > 0) {
-        out.push({
-            key: "instance-pool",
-            tone: "amber",
-            title: "Parallel instances share a workspace pool smaller than the run cap",
-            detail: `${instancePool.join("; ")} — runs wait for a pooled checkout; raise worktreeSlots to at least maxConcurrent, or lower maxConcurrent.`,
-            actions: [],
-        });
-    }
-}
-function pushRegressedFixesAlert(out, regressedFixes) {
-    // A Fixed record whose quoted test failed again in the trailing day — the always-on twin of
-    // the doctor's `regressed fixes` row (doctor-backlog-bugs.ts checkRegressedFixes).
-    // alert-feeds.ts's regressedFixesAlert feeds it the same candidate selection, failureMentions
-    // match and verbatim sentence, so the alert and the doctor cannot drift on the trigger or the
-    // wording; the Failures view shows the naming events.
-    if (regressedFixes) {
-        out.push({
-            key: "regressed-fixes",
-            tone: "amber",
-            title: plural(regressedFixes.count, "Fixed test has regressed", "Fixed tests have regressed"),
-            detail: regressedFixes.detail,
-            actions: seeFailures(),
-        });
-    }
-}
+/** The tail team alerts: a stopped tumwater. 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 { plural } from "../text/phrases.js";
 function pushStoppedAlert(out, snap) {
     if (!snap.running) {
         out.push({
@@ -179,60 +12,31 @@ function pushStoppedAlert(out, snap) {
         });
     }
 }
-function pushImagesAlert(out, roles) {
-    // Image input (plans/image-input.md "Surfaces", part 5/5): a role whose model cannot read
-    // images. Blue when every text-only role has a reroute target (a run that reads an image
-    // stops and reruns — nothing fails); amber when some text-only role has none (a blind read
-    // fails and image submissions are refused). No alert
-    // when every enabled role reads images (imageInput true or unknown — an unknown seam is not
-    // counted as text-only, mirroring the submit gate and the doctor's `tier models` stance).
-    const textOnly = roles.filter((l) => l.imageInput === false);
-    const noTarget = textOnly.filter((l) => l.imageReroute == null || l.imageReroute === "");
-    if (noTarget.length > 0) {
+function pushOrphansAlert(out, orphans) {
+    // Orphaned worktree processes — the always-on twin of the doctor's `orphans` row
+    // (doctor-orphans.ts checkOrphans): a detected orphan holds no lock, writes no event and
+    // touches no state file, so nothing else on the always-on surfaces names it until an operator
+    // runs `tumwater doctor`, and it then burns CPU for days unnoticed. alert-feeds.ts's
+    // getOrphanAlert feeds it the doctor's own orphanFailDetail sentence and count, so the alert
+    // and the row cannot drift on the trigger, the cpu, or the remediation.
+    if (orphans) {
         out.push({
-            key: "images",
+            key: "orphans",
             tone: "amber",
-            title: `No configured model can read images for ${listRoles(noTarget)}`,
-            detail: "A run that reads an image fails, and image attachments to these roles are refused. Declare image input on a vision model in pi's models.json, or point a tier at one.",
-            actions: openRoleActions(noTarget),
-        });
-    }
-    else if (textOnly.length > 0) {
-        const targets = [...new Set(textOnly.map((l) => l.imageReroute ?? ""))].filter(Boolean);
-        out.push({
-            key: "images",
-            tone: "blue",
-            title: `${listRoles(textOnly)} ${agree(textOnly.length, "runs", "run")} on models that can't read images`,
-            detail: `A run that reads an image stops and reruns on ${targets.join(", ")}.`,
+            title: `${plural(orphans.count, "orphaned process", "orphaned processes")} are burning CPU (PPID 1)`,
+            detail: orphans.detail,
             actions: [],
         });
     }
 }
-/** The quiet-hours, maintenance, provider-hold, pause, capacity-contention, provider-cap,
- * instance-pool, stale-workspace-pin, regressed-fix, stopped and image-input alerts, in
- * emission order: a run of quiet hours
- * holding the team, a
- * maintenance allowance held at its rolling cap, a standing provider failure hold, an operator
- * pause with its countdown, the last day's capacity contention, a stale workspace pin, a
- * fixed test that regressed, a
- * stopped tumwater, and roles that cannot or may not read images. Extracted from teamAlerts
+/** The stopped-tumwater alert, in emission order: a stopped team. Extracted from teamAlerts
  * (part 5/5 of the teamAlerts split) so the shared module stays small; the input names exactly
- * the fields this run reads, including `now`, which the pause countdown and provider-hold
- * re-open time need. The caller pushes the returned alerts at the position this run used to
- * occupy, so the emitted key order is unchanged. */
+ * 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. */
 export function buildTailAlerts(input) {
     const out = [];
-    const { snap, now, contention, regressedFixes, roles, workspacePins, instancePool, providerCaps } = input;
-    pushQuietAlert(out, snap);
-    pushMaintenanceAlert(out, snap);
-    pushProviderHoldAlert(out, snap, now);
-    pushProviderCapsAlert(out, providerCaps);
-    pushPausedAlert(out, snap, now);
-    pushContentionAlert(out, contention);
-    pushWorkspacePinsAlert(out, workspacePins);
-    pushInstancePoolAlert(out, instancePool);
-    pushRegressedFixesAlert(out, regressedFixes);
+    const { snap, orphans } = input;
+    pushOrphansAlert(out, orphans);
     pushStoppedAlert(out, snap);
-    pushImagesAlert(out, roles);
     return out;
 }

package/dist/src/ui/team-alerts.js

@@ -15,22 +15,15 @@ import { buildStatusAlerts } from "./team-alert-status.js";
 import { buildBacklogAlerts } from "./team-alert-backlog.js";
 import { buildTailAlerts } from "./team-alert-tail.js";
 /** Everything about the team that needs the operator, most urgent first: a spent budget, a red
- * main, roles failing run after run, roles that look stuck, a stale running build, open
- * questions, refused entries, a plan stalled by a Needs
- * review note, the team
- * waiting on capacity slots (workspace, provider or
- * check), parallel instances sharing a workspace pool smaller than the run cap, a plan
- * filed under the wrong backlog section, a duplicated
- * backlog section heading, finished history still under a live backlog file's `## Done` or
- * `## Fixed`, a Fixed record with a bad Validation gap trace, a pause, a
- * stopped team.
- * `now` is passed so a timed
- * pause's countdown agrees with the rest of the frame. */
-export function teamAlerts(snap, questions, roles, now, refused = [], planDependency = null, stalledEntries = [], strandedPlans = [], duplicatedHeadings = [], validationGaps = [], contention = [], regressedFixes = null, staleClaims = [], staleQuestions = [], fixClaims = [], workspacePins = [], liveFinished = [], instancePool = [], providerCaps = []) {
+ * main, roles failing run after run, roles that look stuck, disk and install drift, open
+ * questions, refused entries, the team waiting on capacity slots (workspace, provider or
+ * check), and a stopped team.
+ */
+export function teamAlerts(snap, questions, roles, _now, refused = [], orphans = null) {
     const out = [];
-    out.push(...buildStatusAlerts({ snap, roles, staleClaims }));
-    out.push(...buildBacklogAlerts({ questions, staleQuestions, refused, stalledEntries, planDependency, strandedPlans, duplicatedHeadings, liveFinished, validationGaps, fixClaims }));
-    out.push(...buildTailAlerts({ snap, now, contention, regressedFixes, roles, workspacePins, instancePool, providerCaps }));
+    out.push(...buildStatusAlerts({ snap, roles }));
+    out.push(...buildBacklogAlerts({ questions, refused }));
+    out.push(...buildTailAlerts({ snap, orphans }));
     return out;
 }
 /** Does this alert ask something of the operator (red, amber, indigo), rather than inform? */

package/dist/src/ui/transcript-run.js

@@ -8,6 +8,31 @@ import { parsePiEventLine } from "../pi/pi-event-line.js";
  * renderer stamps its separator from). A segment with neither is skipped. */
 const MARKER_ONLY = new Set(["tumwater_run"]);
 const MESSAGE_ONLY = new Set(["message_end"]);
+function segmentsInText(text) {
+    const segments = [];
+    for (const line of text.split("\n")) {
+        if (line === "")
+            continue;
+        if (line.includes('"tumwater_run"') && parsePiEventLine(line, MARKER_ONLY))
+            segments.push([line]);
+        else
+            segments.at(-1)?.push(line);
+    }
+    return segments;
+}
+function keepInWindow(segments, fromTs, toTs) {
+    const kept = [];
+    for (const seg of segments) {
+        const start = segmentStart(seg);
+        if (start !== null && start >= fromTs && start <= (toTs ?? Infinity))
+            kept.push(...seg);
+    }
+    return kept;
+}
+function applyTranscriptGrep(entries, grep) {
+    const keep = createTranscriptFilter(grep);
+    return entries.flatMap((e) => keep(e) ?? []);
+}
 function segmentStart(lines) {
     const marker = parsePiEventLine(lines[0], MARKER_ONLY);
     if (typeof marker?.ts === "number")
@@ -35,24 +60,10 @@ export function readRunTranscript(file, fromTs, toTs, opts = {}) {
         catch {
             continue;
         }
-        const segments = [];
-        for (const line of text.split("\n")) {
-            if (line === "")
-                continue;
-            if (line.includes('"tumwater_run"') && parsePiEventLine(line, MARKER_ONLY))
-                segments.push([line]);
-            else
-                segments.at(-1)?.push(line);
-        }
-        for (const seg of segments) {
-            const start = segmentStart(seg);
-            if (start !== null && start >= fromTs && start <= (toTs ?? Infinity))
-                kept.push(...seg);
-        }
+        kept.push(...keepInWindow(segmentsInText(text), fromTs, toTs));
     }
     const entries = formatTranscript(kept, opts);
     if (opts.grep === undefined)
         return entries.flat();
-    const keep = createTranscriptFilter(opts.grep);
-    return entries.flatMap((e) => keep(e) ?? []);
+    return applyTranscriptGrep(entries, opts.grep);
 }

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

@@ -15,9 +15,9 @@ import { DASHBOARD_ANSWERED_QUESTIONS, DASHBOARD_RECENT_FINISHED } from "../stat
  * — the one definition shared by the keypress handlers and the render (src/ui/tui/tui-keys.ts,
  * src/ui/tui/tui-pane.ts), so stale-selection clamping cannot drift. */
 export function labeledBacklogEntries(root) {
-    const marks = backlogMarks(root);
-    const holds = backlogHolds(root);
     const runners = backlogInProgress(root);
+    const marks = backlogMarks(root, runners);
+    const holds = backlogHolds(root);
     return [
         ...plannedPlanEntries(root).map((e, i) => ({
             label: "plan",

package/dist/src/ui/tui/tui-editor-answer.js

@@ -1,12 +1,14 @@
-import { questionAsker, tryAnswerQuestion, UNCLOSED_FENCE_MESSAGE, } from "../../backlog/question-answer.js";
+import { questionAsker, tryAnswerQuestion, UNCLOSED_FENCE_MESSAGE, } from "../../backlog/backlog-question-answer.js";
 import { wakeQuestionAsker } from "../../operator/operator-intent.js";
+import { savedPromptDraft } from "./tui-editor-session.js";
+import { guardError } from "./tui-guard.js";
 /** The backlog pane's answer editor (Ctrl+A on a selected open question) on the shared prompt
  * line. It owns its target (`answerFor`), its saved-draft pair, its exit helper, and the
  * tryAnswerQuestion / wake arms that record the decision. Mutually exclusive with the other
  * editors via the session's held registry. */
 export function createAnswerEditor(session) {
     let answerFor = null;
-    let restoreDraft = () => { };
+    const draft = savedPromptDraft(session);
     // Leave the backlog pane's answer editor (Esc, a recorded answer, or Ctrl+T): restore the
     // saved prompt text and reset the recall state, mirroring exitQueuedEdit.
     const exitAnswerMode = () => {
@@ -14,7 +16,7 @@ export function createAnswerEditor(session) {
             return;
         answerFor = null;
         session.held.answer = null;
-        restoreDraft();
+        draft.restore();
     };
     // Ctrl+A opens the answer editor on the selected open question (mnemonic: **A**nswer);
     // Enter records the decision through tryAnswerQuestion, the core `tumwater questions
@@ -23,26 +25,26 @@ export function createAnswerEditor(session) {
     const answerOpenEdit = (ctx) => {
         if (!session.anyEditorHeld() &&
             ctx.view === ctx.roleIds.length + 1 && ctx.selectedEntry !== null) {
-            try {
+            const selected = ctx.selectedEntry;
+            if (selected === null)
+                return false;
+            guardError(session, () => {
                 const entries = session.flat();
-                const sel = Math.min(ctx.selectedEntry, entries.length - 1);
+                const sel = Math.min(selected, entries.length - 1);
                 const entry = entries[sel];
                 if (entry?.label !== "question") {
                     session.flashMessage("only an open question can be answered here");
                 }
                 else {
                     const position = sel - entries.filter((e) => e.label === "plan" || e.label === "bug").length + 1;
-                    restoreDraft = session.takeDraft();
+                    draft.save();
                     answerFor = { position, title: entry.title };
                     session.held.answer = answerFor;
                     session.input = "";
                     session.cursor = 0;
                     session.flashMessage(`answering question #${position} — Enter to record, Esc to cancel`);
                 }
-            }
-            catch (err) {
-                session.flashError(err);
-            }
+            });
             return true;
         }
         return false;