tumwater 0.4.0 → 0.4.2

package/dist/src/runner/runner-run.js

@@ -6,16 +6,12 @@ import { abortSync, ensureWorktree, resetWorktreeToMain } from "../git/worktree.
 import { leaseSlot } from "../git/worktree-pool.js";
 import { slotCount } from "../config/config.js";
 import { useWorktree } from "../git/worktree-use.js";
-import { readPiListedModels } from "../pi/pi-listed-models.js";
 import { branchName, worktreePath, mergeRefName, rejectedRefName } from "../paths.js";
 import { logEventBestEffort } from "../events/events.js";
 import { buildConflictHandbackNote, buildSalvageRestoreNote } from "../prompt/gate-prompts.js";
 import { buildConflictDiscardNote, buildMainKnownRedNote, buildRevisionNote, buildRejectedReviewNote, } from "../prompt/gate-notes.js";
-import { modelSelectorField, resolvedBackendConfig, reviewRunConfig, reviewedAfterMerge, scheduleConfigForRole, seamHoldKey, withModelOverrides, } from "../config/config-views.js";
+import { modelSelectorField, resolvedBackendConfig, reviewRunConfig, reviewedAfterMerge, scheduleConfigForRole, seamHoldKey, } from "../config/config-views.js";
 import { fallbackRoleConfig } from "../config/config-fallbacks.js";
-import { imageReroute, seamImageInput } from "../agent/image-input.js";
-import { piModelsPath, readPiProviders } from "../pi/pi-models.js";
-import { peekPrompt, peekRolePrompt } from "../inbox/inbox.js";
 import { planRunStart, planWithSalvagedWork, takesSalvagedWork } from "../run/run-resume.js";
 import { restoreSalvagedWork } from "../git/slot-salvage.js";
 import { DEFAULT_BACKEND } from "../agent/agent-backend.js";
@@ -30,7 +26,8 @@ import { applyRevision, applyWithConflicts } from "./revision.js";
 import { conflictedFileHunks, hasConflictMarkers, mainCommitsTouching } from "../merge/merge-git.js";
 import { changedFiles } from "../git/git-diff.js";
 import { handlePiResultPhase } from "./runner-outcome.js";
-import { mainRedGate, mainRedHealNote } from "../baseline/main-red.js";
+import { mainRedHealNote, namedFailures } from "../baseline/main-red.js";
+import { watchedBaseline } from "../baseline/main-baseline.js";
 import { extractCiResult, extractFlow, extractFiled } from "../verdict/reply-contract.js";
 /** The intent the author needs to resolve a handed-back change: the change's own commit message
  * and the main commits that touched its conflicted files since its merge-base. Mirrors what
@@ -90,60 +87,6 @@ export async function runPhase(ctx) {
     let cfg = onFallback && fallback !== null
         ? { ...fallback, minRunIntervalSeconds: primaryCfg.minRunIntervalSeconds }
         : primaryCfg;
-    // Image-input reroute (plans/image-input.md part 4/5). A pending one-shot marker means
-    // THIS run is the blind-read reroute: start directly on the image-capable target the
-    // prior run recorded, over the kept worktree, in a fresh session. The marker is consumed
-    // (cleared) here so it does not route a later run; imageRerouteActive stays true for the
-    // whole run so the verdict's one-hop guard fails a second blind read instead of
-    // rerouting again. A preflight (below) sets the same active flag without a marker.
-    s.imageRerouteActive = false;
-    let preflightBlocked = false;
-    if (s.imageReroute) {
-        const r = s.imageReroute;
-        cfg = withModelOverrides(ctx.config, r.tier, {
-            backend: r.backend,
-            provider: r.provider,
-            model: r.model,
-            thinking: r.thinking,
-        });
-        // The marker is NOT cleared here: planRunStart reads its `from`/`path` when it builds
-        // the handoff note (and clears it then), so a run skipped before the plan (an empty
-        // inbox) leaves the reroute pending for the next eligible run.
-        s.imageRerouteActive = true;
-    }
-    else {
-        // Preflight (plans/image-input.md "Attachments"): a queued prompt carrying an
-        // `[image attached: …]` line needs a model that can read images BEFORE any run starts,
-        // so a text-only run hops straight to the target instead of spending a failed run
-        // learning it; with no target the run errors without spawning pi.
-        const nextPrompt = ctx.role === DIRECTOR_ROLE ? peekPrompt(ctx.root) : peekRolePrompt(ctx.root, ctx.role);
-        const carriesImages = nextPrompt !== null && /^\[image attached: .+\]$/m.test(nextPrompt);
-        if (carriesImages) {
-            const providers = readPiProviders(piModelsPath());
-            const listed = readPiListedModels(ctx.root);
-            if (seamImageInput(cfg, providers, undefined, listed) !== true) {
-                const target = imageReroute(ctx.config, ctx.role, ctx.rerouteRegime(now), undefined, null, undefined, null, listed);
-                if (target !== null) {
-                    cfg = target.config;
-                    s.imageRerouteActive = true;
-                    logEventBestEffort(ctx.root, {
-                        source: ctx.role,
-                        type: "image_reroute",
-                        run: s.runs + 1,
-                        from: primaryCfg.model,
-                        to: target.config.model,
-                        tier: target.tier,
-                        preflight: true,
-                    });
-                }
-                else {
-                    preflightBlocked = true;
-                    s.lastError =
-                        `an inbox message for ${ctx.role} attaches an image, but no configured tier can read it`;
-                }
-            }
-        }
-    }
     // Capture what this run runs on (the orchestrator's budget handback matches it against
     // the fallback pair) and clear any stale handback flag: an abort request that lands while
     // the runner is idle must not name a later run's resume.
@@ -179,19 +122,11 @@ export async function runPhase(ctx) {
         source: ctx.role,
         type: "run_start",
         run: runNumber,
-        // A run routed onto the image-capable target — a blind-read handoff or an attachment
-        // preflight — is stamped so the feed shows the reroute and the model it landed on.
-        ...(s.imageRerouteActive ? { reroute: "image" } : {}),
         ...modelSelectorField(cfg),
     });
     let outcome;
     try {
-        // The preflight can end the run before any pi spawns: a text-only runner with an image
-        // attachment and no image-capable target has nothing to run, so it errors without
-        // spending a model call. Everything else runs the pipeline as usual.
-        outcome = preflightBlocked
-            ? { result: "error" }
-            : await ctx.runOnce(cfg, { fallback, probe: probing, primary: primaryCfg });
+        outcome = await ctx.runOnce(cfg, { fallback, probe: probing, primary: primaryCfg });
     }
     catch (err) {
         outcome = { result: "error" };
@@ -257,17 +192,6 @@ export async function runOncePhase(ctx, cfg, fallbackCtx) {
     if (plan === null)
         return { result: "skipped" };
     if (ctx.role === DIRECTOR_ROLE) {
-        // The image-reroute one-shot marker routes exactly ONE run onto the image-capable
-        // target (plans/image-input.md part 4/5, INV-J2): for a role runner, planRunStart consumes
-        // it after reading its handoff-note facts. The director never resumes, so planRunStart's
-        // image-reroute branch never runs for it and the marker would otherwise linger and
-        // re-route every later director run off its own tier. It is cleared here — after this
-        // run is confirmed to run (an empty-inbox skip above returns before this, leaving the
-        // reroute pending for the next eligible run) — so the rerouted director prompt is
-        // delivered exactly once and the director is back on its own tier next.
-        // A promptless recovery run delivers no prompt, so it leaves a pending reroute for the next.
-        if (plan.prompt !== null)
-            s.imageReroute = undefined;
         // The director keeps its dedicated worktree (it runs outside the permit, consumes its
         // config-request file at that exact path, and never resumes). Hold it from before
         // ensureWorktree — creating or resetting it is part of the use — to the run's end
@@ -391,7 +315,7 @@ leasedDir) {
         // recovery merge raced the slot's batches into `merge_blocked`). A salvaged leftover
         // ENDS the run: the role holds one merge ref, and the leftover owns it until its
         // merge resolves. With nothing to salvage the branch holds nothing either, so the reset
-        // below leaves pristine main for the red-main gate.
+        // below leaves pristine main.
         // A permanent reviewer config error — held from re-queueing — clears once the resolved
         // reviewer selector changes, so fixing the model config recovers the pin automatically
         // (BUGS.md 2026-10-06).
@@ -452,33 +376,26 @@ leasedDir) {
         // nothing, so it ends here rather than reach the authoring run with a null prompt.
         if (plan.prompt === null)
             return { result: "skipped" };
-        // Red-main baseline gate (src/baseline/main-red.ts): the worktree is pristine main right
-        // now — verify main's own suite before spending an authoring run on top of it. Only roles
-        // whose diff can carry code changes are blocked; resume runs skip this by construction
-        // (their worktree is not pristine main). The `ci` healer is exempt because its fix is
-        // the team's only way back to green, so instead of blocking it we hand it the failure
-        //the same check runs, but a red main appends a <main-red>
-        // note to this run's prompt so it reproduces and fixes that failure rather than hunting
-        // blind.
+        // The `ci` healer's red-main hand-off (src/baseline/main-red.ts): the worktree is pristine
+        // main right now, so a red main appends a <main-red> note to this run's prompt and the
+        // healer reproduces and fixes that failure rather than hunting blind. Every other role
+        // authors on the red main unblocked — the red-main authoring block came off with the
+        // pre-merge blocks, parts 3g/3–3j/3 and 3d/3–3f/3.
         if (ctx.baseRole === "ci") {
             const note = await mainRedHealNote(ctx.root, ctx.role, wt);
             if (note)
                 prompt = appendPromptNote(prompt, note);
         }
         else {
-            const knownRed = [];
-            const blocked = await mainRedGate(ctx.root, ctx.role, wt, undefined, (tests) => knownRed.push(tests));
-            if (blocked) {
-                // The dequeued prompt never ran: put it back in its queue before returning, so it is
-                // not lost to a restart (the pending field is memory-only) or dropped by the next
-                // run's outcome handling — the queue is the durable store, and once main is green
-                // the next run dequeues it again (criterion b).
-                ctx.pending.requeueUnfulfilled(userPrompt);
-                ctx.pending.clear();
-                return blocked;
-            }
-            if (knownRed[0])
-                prompt = appendPromptNote(prompt, buildMainKnownRedNote(knownRed[0]));
+            // Every other role proceeds on the red main, told which tests already fail (the
+            // <main-known-red> note, restored 2026-10-25): a pure read of the main watch's persisted
+            // verdict (watchedBaseline runs no check), so the block appears only when a verdict names
+            // failures and a role's start pays nothing for it. `ci` owns the repair without
+            // monopolizing it — a fix from any role lands like any other change.
+            const baseline = await watchedBaseline(wt);
+            const tests = baseline?.status === "red" ? namedFailures(baseline) : [];
+            if (tests.length > 0)
+                prompt = appendPromptNote(prompt, buildMainKnownRedNote(tests));
         }
     }
     // A change handed back after its merges kept conflicting — or a persisted hand-back the

package/dist/src/runner/runner-state-load.js

@@ -208,16 +208,6 @@ export function loadRunnerState(root, role) {
             v.probeAt = healNumber(v.probeAt, 0);
             v.cooldownMs = healNumber(v.cooldownMs, 0);
         });
-    // The image-reroute marker is a one-shot nested record consumed by the next run; a torn
-    // scalar is dropped (its consumers read/mutate fields), and the tier is repaired to a
-    // known tier name so a corrupt tier cannot route a rerouted run to a phantom seam.
-    if (s.imageReroute !== undefined) {
-        const healed = healRecord(s.imageReroute, () => { });
-        s.imageReroute =
-            healed && (healed.tier === "small" || healed.tier === "default" || healed.tier === "strong")
-                ? healed
-                : undefined;
-    }
     return s;
 }
 /** Per-role cache of the persisted live claim, keyed by the state file's stat — one stat per

package/dist/src/runner/runner.js

@@ -6,7 +6,7 @@ import { logEventBestEffort, warnEventBestEffort } from "../events/events.js";
 import { promptPreview } from "../inbox/inbox.js";
 import { assembleRunPrompt } from "../run/run-prompt.js";
 import { RunnerPi } from "./runner-pi.js";
-import { configForRole, seamHoldKey, withModelOverrides, } from "../config/config-views.js";
+import { configForRole, seamHoldKey, } from "../config/config-views.js";
 import { fallbackRoleConfig } from "../config/config-fallbacks.js";
 import { PendingPrompt } from "../inbox/pending-prompt.js";
 import { modelFallbackActive } from "./model-fallback.js";
@@ -73,13 +73,6 @@ export class RoleRunner {
      * resolve to, since different roles may run on different pairs.
      * Transient — never persisted — and captured fresh at every run start. */
     runPair;
-    /** Whether the budget gate currently has the team on its free fallback pairs (src/gates/
-     * budget-gates.ts onFallback, set alongside `config` by the orchestrator's poll): an
-     * image reroute may then look only among the free fallback pairs, never a priced primary
-     * (plans/image-input.md "Reroute target" "Regime"). Pure scheduler input, never whether
-     * the runner itself is mid-fallback; defaults false, so standalone-runner tests stay on the
-     * primary regime unless they set it. */
-    budgetFallbackActive = false;
     /** The merge failure this run's leftover recovery is retrying, if any (a retriable merger
      * outcome that kept the pin, which recovery re-queued): set in finishRecoveryRun and
      * attached to the returned RunOutcome so applyRunOutcome can feed it into the error streak
@@ -185,30 +178,7 @@ export class RoleRunner {
      * active (a due probe runs the primary), else the role's own resolved config. The hold and
      * start passes read this so a role mid-episode is keyed by the provider it will actually use.
      * Pure read of config + state + the caller's clock. */
-    /** Which pair set an image reroute may look among (plans/image-input.md "Reroute target"
-     * "Regime"): the free fallback pairs while the budget gate is on fallback OR the role is
-     * in a model-fallback episode; otherwise the primary tiers. One home for the rule, shared
-     * by the target-resolution sites (the verdict's reroute arm, the attachment preflight). */
-    rerouteRegime(now) {
-        if (this.budgetFallbackActive)
-            return "fallback";
-        if (modelFallbackActive(this.state.modelFallback, now))
-            return "fallback";
-        return "primary";
-    }
     runConfig(now) {
-        // A pending image-input reroute (plans/image-input.md part 4/5) outranks the role's own
-        // tier and its model fallback: the next run starts on the image-capable target the
-        // blind-read run recorded, rebuilt from the stored seam over the live config.
-        if (this.state.imageReroute) {
-            const r = this.state.imageReroute;
-            return withModelOverrides(this.config, r.tier, {
-                backend: r.backend,
-                provider: r.provider,
-                model: r.model,
-                thinking: r.thinking,
-            });
-        }
         const fallback = fallbackRoleConfig(this.config, this.role);
         if (fallback !== null && modelFallbackActive(this.state.modelFallback, now))
             return fallback;
@@ -323,7 +293,6 @@ export class RoleRunner {
             warn: (message) => this.warn(message),
             runSignal: () => this.runSignal(),
             runPrompt: (backend) => this.runPrompt(backend),
-            rerouteRegime: (now) => this.rerouteRegime(now),
             get recoveryFailure() {
                 return self.recoveryFailure;
             },

package/dist/src/scheduling/claims.js

@@ -8,9 +8,9 @@
 import path from "node:path";
 import { DAY_MS } from "../text/datetime.js";
 import { hasOutstandingWork } from "../runner/runner-state.js";
-import { backlogHolds, eligibleEntries } from "../backlog/backlog-eligibility.js";
+import { backlogHolds, eligibleEntries, roleSection } from "../backlog/backlog-eligibility.js";
 import { entryKey } from "../backlog/backlog-parts.js";
-import { actionableEntryRanges, actionableEntryRangesFor } from "../backlog/backlog-structure.js";
+import { actionableEntryRanges, actionableEntryRangesFor } from "../backlog/backlog-index-data.js";
 import { readTextOrNull } from "../files/files.js";
 import { changeBaseRev, fileContentAt } from "../git/git.js";
 import { INSTANCE_ROLES, baseRoleOf, configuredInstances } from "../roles/runner-ids.js";
@@ -27,20 +27,13 @@ export function planBacklogTarget(config) {
     return configuredInstances(config, "feature") + 1;
 }
 /** Does PLANS.md already hold the plan role's target (planBacklogTarget eligible plans), with no
- * plan marked needs-review or needs-replan? The charter makes splitting or replanning a marked
+ * plan marked needs-review? The charter makes splitting or replanning a marked
  * plan outrank the stop, so a marked entry keeps the plan role running; otherwise a plan run can
  * only end in TUMWATER_NOTHING_TO_DO and the scheduler defers it (deferRunReason). */
 export function planBacklogFull(root, config) {
     if (eligibleEntries(root, "feature").length < planBacklogTarget(config))
         return false;
-    return !backlogHolds(root).plans.some((h) => h === "needs-review" || h === "needs-replan");
-}
-/** The backlog file and section a role's entries live under: PLANS.md's `## Planned` for
- * feature, BUGS.md's `## Open` for bugfix. An instance id resolves through its base role. */
-function roleSection(role) {
-    return baseRoleOf(role) === "bugfix"
-        ? { file: "BUGS.md", section: "Open" }
-        : { file: "PLANS.md", section: "Planned" };
+    return !backlogHolds(root).plans.some((h) => h === "needs-review");
 }
 /** Every entry key listed under a role's backlog section, held or not: the set that separates a
  * claim whose entry left the section (`left`) from one that is still listed but ineligible

package/dist/src/status/status-data.js

@@ -9,11 +9,14 @@ import { pausedRoles, pausedRolesUntil, scheduledStopAt, scheduledWakes, standin
 import { orchestratorAlive, readOrchestratorInfo, } from "../team/orchestrator-info.js";
 import { bootstrapHoldsRole, bootstrapStatus } from "../gates/bootstrap-gates.js";
 import { readMergeQueue } from "../merge/merge-queue.js";
-import { collectImageProbeFailures, collectRoleRows } from "./status-roles.js";
+import { collectRoleRows } from "./status-roles.js";
 import { collectInboxes } from "./status-inbox.js";
+import { collectRoleNotesOverCap } from "./status-role-notes.js";
 import { collectBudget } from "./status-budget.js";
 import { collectRootInstallDrift } from "./status-install.js";
 import { detectBuildCheck } from "../build/build-check-detect.js";
+import { briefBlockMissing, briefBlockOverCap } from "../brief/brief.js";
+import { principlesBlockOverCap } from "../prompt/principles.js";
 /** The earlier of the two optional stop deadlines (`run --for`'s and a scheduled stop's). */
 function earliestStop(a, b) {
     return a === undefined ? b : b === undefined ? a : Math.min(a, b);
@@ -23,6 +26,128 @@ function earliestStop(a, b) {
 export function scopeSnapshotToRoles(snap, roles) {
     return { ...snap, roles: snap.roles.filter((s) => roleInScope(s.role, roles)) };
 }
+/** The run-state header fields (running/pid/build) of the snapshot. */
+function snapshotRunFields(running, info) {
+    return {
+        running,
+        pid: info?.pid,
+        build: running && info?.build ? info.build : null,
+    };
+}
+/** The director and per-role inbox fields and the open question count of the snapshot. The
+ * `collectInboxes` read stays in `snapshot`; the
+ * builder recomposes the destructured values and reads the open question count from `root`. */
+function snapshotInboxFields(root, inboxes) {
+    return {
+        inbox: inboxes.inbox,
+        inboxPrompts: inboxes.inboxPrompts,
+        inboxFiles: inboxes.inboxFiles,
+        inboxQueuedAt: inboxes.inboxQueuedAt,
+        inboxNotBefore: inboxes.inboxNotBefore,
+        roleInbox: inboxes.roleInbox,
+        roleInboxPrompts: inboxes.roleInboxPrompts,
+        questions: openQuestions(root).length,
+    };
+}
+/** The spend/billing fields of the snapshot: the budget, the per-backend subscription windows
+ * (and their claude-window spelling) and the running-only chain/provider holds. */
+function snapshotBudgetFields(budget, subscriptionWindows, subscriptionOnly, claudeBlock, running, info) {
+    return {
+        // Unconditional (never null): a disabled team still shows its spend and the badge is
+        // the affordance for SETTING a cap. models.json itself is stat-cached inside pi-models.ts,
+        // so an unchanged catalog costs one stat per poll, not a re-read plus parse.
+        budget,
+        // One window block per subscription backend in use, raw for `status --json` and the
+        // parts 3b/9–3e/9 displays; omitted when no subscription backend reported a window.
+        ...(subscriptionWindows.length > 0 ? { subscriptionWindows } : {}),
+        subscriptionOnly,
+        ...(claudeBlock
+            ? {
+                claudeWindow: {
+                    windows: claudeBlock.windows,
+                    primary: claudeBlock.primary,
+                    only: subscriptionOnly,
+                    heldUntil: claudeBlock.heldUntil,
+                },
+            }
+            : {}),
+        ...(running && info?.chain && Object.keys(info.chain).length > 0 ? { chain: info.chain } : {}),
+        // Only while running: a stale info file beside a dead pid must not speak for a stopped
+        // team, and only while a hold stands (an empty list is the same as none).
+        ...(running && info?.providerHolds && info.providerHolds.length > 0 ? { providerHolds: info.providerHolds } : {}),
+    };
+}
+/** The pause/quiet-hours fields of the snapshot: the paused flags and their deadlines, the
+ * maintenance quota and bootstrap holds, and the per-role quiet windows. */
+function snapshotPauseFields(teamPause, markerRoles, roles, markerSet, capPaused, maintenanceQuota, bootstrapNow, roleRows, budgetPausedRoles, cfg, root, wakes, quiet) {
+    return {
+        paused: teamPause !== null,
+        pausedRoles: markerRoles,
+        pausedRunners: roles.filter((id) => runnerPaused(markerSet, id)),
+        capPaused,
+        maintenanceQuota,
+        // The new-project bootstrap hold (plans/work-ratio.md, part 2/2): the same read-only
+        // verdict the gate computes (bootstrapStatus), so the dashboards and the scheduler agree.
+        // The held set is computed with the gate's own predicate over the same role list.
+        bootstrap: bootstrapNow?.active
+            ? { plansDone: bootstrapNow.plansDone, untilPlansDone: bootstrapNow.untilPlansDone }
+            : undefined,
+        bootstrapHeld: bootstrapNow?.active
+            ? roleRows.filter((l) => bootstrapHoldsRole(l.role, openBugs(root).length > 0)).map((l) => l.role)
+            : [],
+        budgetPausedRoles,
+        // The per-role quiet windows' held roles (PLANS.md quietHoursPerRole): keyed role →
+        // window, so the dashboards can render the same `quiet until <end>` wording the team
+        // badge uses, scoped to the role's own schedule. The window string comes back out of
+        // the same config the hold was decided from, so the label cannot name a window that is
+        // not holding (roleQuietHold true implies a parseable, non-empty string there).
+        roleQuietPaused: Object.fromEntries(roleRows
+            .filter((l) => l.role !== DIRECTOR_ROLE && roleQuietHold(cfg.quietHoursPerRole, baseRoleOf(l.role), new Date()))
+            .map((l) => [l.role, cfg.quietHoursPerRole?.[baseRoleOf(l.role)] ?? ""])),
+        pausedUntil: teamPause?.until,
+        pausedRolesUntil: pausedRolesUntil(root),
+        scheduledWake: wakes[0],
+        scheduledWakes: wakes.length > 0 ? wakes : undefined,
+        pauseReason: teamPause?.reason,
+        quietHours: quiet.window ?? undefined,
+        inQuietHours: quiet.inWindow,
+    };
+}
+/** The merge-queue and doctor health fields of the snapshot (main-check, ci-parity and the
+ * build-check/brief/principles flags, plus the role notes over cap). */
+function snapshotHealthFields(root, cfg, mergeQueue, roleNotesOverCap) {
+    return {
+        mergeQueue,
+        mainCheck: mainCheckForPoll(root, cfg),
+        ciParity: ciParityForPoll(root, cfg),
+        noDeclaredCheck: detectBuildCheck(root, cfg) === null ? true : undefined,
+        noBrief: briefBlockMissing(root) ? true : undefined,
+        briefTruncated: briefBlockOverCap(root) ? true : undefined,
+        ...(roleNotesOverCap.length > 0 ? { roleNotesOverCap } : {}),
+        principlesTruncated: principlesBlockOverCap(root) ? true : undefined,
+    };
+}
+/** The running-only resource fields of the snapshot (disk floor, install drift, permits and
+ * the run stop deadlines). */
+function snapshotResourceFields(root, running, info, rootDrift) {
+    return {
+        // The disk floor's published state (plans/disk-floor.md, part 4/4): only while the
+        // orchestrator runs — the exit removes the info file, so a stale file beside a dead pid
+        // must not speak for a stopped team — and only when the last poll could measure the
+        // volume. Absent otherwise, so the surfaces render exactly as before.
+        disk: running && info?.disk ? info.disk : undefined,
+        // Independent of the team running: a stopped team's worktrees still borrow the root install.
+        rootInstallDrift: rootDrift.length ? rootDrift : undefined,
+        // Only while running: a stale info file beside a dead pid must not speak for a stopped team.
+        permits: running && info?.permits ? info.permits : undefined,
+        slotPool: running && info?.slotPool ? info.slotPool : undefined,
+        // Only while running: a stale info file beside a dead pid must not speak for a stopped team.
+        checkPermits: running && info?.checkPermits ? info.checkPermits : undefined,
+        // Only while running: a stale info file beside a dead pid must not speak for a stopped team.
+        runStopsAt: running ? earliestStop(info?.stopsAt, scheduledStopAt(root)) : undefined,
+        scheduledStopAt: running ? scheduledStopAt(root) : undefined,
+    };
+}
 /** One fresh team snapshot for observers. `modelsPath` overrides pi's model definitions
  * location (default ~/.pi/agent/models.json) — a test seam, like doctor's pathEnv. `now` pins
  * the poll's clock for the budget figures (the persisted day-stamp check and the burn-rate
@@ -51,9 +176,9 @@ export function snapshot(root, modelsPath = piModelsPath(), now = Date.now()) {
     // `disk` and the rows agree.
     const slots = readSlotsState(root).slots;
     const roleRows = collectRoleRows(root, cfg, now, slots, modelsPath, markerSet);
-    // The doctor's cached image-probe failures (part 5/5): one read per snapshot, labelled, so
-    // the amber probe alert and `status --json` both answer from the same collector.
-    const imageProbeFailures = collectImageProbeFailures(root, now);
+    // Every role whose notes file runs past the read bound (status-role-notes.ts): the standing
+    // twin of the doctor `role notes` row, raised as the amber role-notes-truncated alert.
+    const roleNotesOverCap = collectRoleNotesOverCap(root);
     // One inbox pass per poll (status-inbox.ts) serves all four director fields and the per-role
     // counts/entries from the same queuedRolePromptEntries reads.
     const { inbox, inboxPrompts, inboxFiles, inboxQueuedAt, inboxNotBefore, roleInbox, roleInboxPrompts } = collectInboxes(root, roles, now);
@@ -104,94 +229,18 @@ export function snapshot(root, modelsPath = piModelsPath(), now = Date.now()) {
     // The one-release claude spelling (see StatusSnapshot.claudeWindow), derived from the claude
     // block so `subscriptionWindows` stays the single source of the window data.
     const claudeBlock = subscriptionWindows.find((b) => b.backend === "claude");
+    // The maintenance allowance (plans/work-ratio.md, part 1b/4): the same pure verdict the
+    // gate folds, over the same event log, so the dashboards show the hold the scheduler
+    // enforces. `merges` is the one merge queue snapshot read above, so in-flight maintenance
+    // merges count once here and in mergeQueue.
+    const maintenanceQuota = maintenanceQuotaForPoll(root, cfg.maintenancePerWorkMerge, roleRows, new Set(merges.map((e) => e.role)), now);
     return {
-        running,
-        pid: info?.pid,
-        build: running && info?.build ? info.build : null,
-        inbox,
-        inboxPrompts,
-        inboxFiles,
-        inboxQueuedAt,
-        inboxNotBefore,
-        roleInbox,
-        roleInboxPrompts,
-        questions: openQuestions(root).length,
-        imageProbeFailures,
+        ...snapshotRunFields(running, info),
+        ...snapshotInboxFields(root, { inbox, inboxPrompts, inboxFiles, inboxQueuedAt, inboxNotBefore, roleInbox, roleInboxPrompts }),
         roles: roleRows,
-        // Unconditional (never null): a disabled team still shows its spend and the badge is
-        // the affordance for SETTING a cap. models.json itself is stat-cached inside pi-models.ts,
-        // so an unchanged catalog costs one stat per poll, not a re-read plus parse.
-        budget,
-        // One window block per subscription backend in use, raw for `status --json` and the
-        // parts 3b/9–3e/9 displays; omitted when no subscription backend reported a window.
-        ...(subscriptionWindows.length > 0 ? { subscriptionWindows } : {}),
-        subscriptionOnly,
-        ...(claudeBlock
-            ? {
-                claudeWindow: {
-                    windows: claudeBlock.windows,
-                    primary: claudeBlock.primary,
-                    only: subscriptionOnly,
-                    heldUntil: claudeBlock.heldUntil,
-                },
-            }
-            : {}),
-        ...(running && info?.chain && Object.keys(info.chain).length > 0 ? { chain: info.chain } : {}),
-        // Only while running: a stale info file beside a dead pid must not speak for a stopped
-        // team, and only while a hold stands (an empty list is the same as none).
-        ...(running && info?.providerHolds && info.providerHolds.length > 0 ? { providerHolds: info.providerHolds } : {}),
-        paused: teamPause !== null,
-        pausedRoles: markerRoles,
-        pausedRunners: roles.filter((id) => runnerPaused(markerSet, id)),
-        capPaused,
-        // The maintenance allowance (plans/work-ratio.md, part 1b/4): the same pure verdict the
-        // gate folds, over the same event log, so the dashboards show the hold the scheduler
-        // enforces. `merges` is the one merge queue snapshot read above, so in-flight maintenance
-        // merges count once here and in mergeQueue.
-        maintenanceQuota: maintenanceQuotaForPoll(root, cfg.maintenancePerWorkMerge, roleRows, new Set(merges.map((e) => e.role)), now),
-        // The new-project bootstrap hold (plans/work-ratio.md, part 2/2): the same read-only
-        // verdict the gate computes (bootstrapStatus), so the dashboards and the scheduler agree.
-        // The held set is computed with the gate's own predicate over the same role list.
-        bootstrap: bootstrapNow?.active
-            ? { plansDone: bootstrapNow.plansDone, untilPlansDone: bootstrapNow.untilPlansDone }
-            : undefined,
-        bootstrapHeld: bootstrapNow?.active
-            ? roleRows.filter((l) => bootstrapHoldsRole(l.role, openBugs(root).length > 0)).map((l) => l.role)
-            : [],
-        budgetPausedRoles,
-        // The per-role quiet windows' held roles (PLANS.md quietHoursPerRole): keyed role →
-        // window, so the dashboards can render the same `quiet until <end>` wording the team
-        // badge uses, scoped to the role's own schedule. The window string comes back out of
-        // the same config the hold was decided from, so the label cannot name a window that is
-        // not holding (roleQuietHold true implies a parseable, non-empty string there).
-        roleQuietPaused: Object.fromEntries(roleRows
-            .filter((l) => l.role !== DIRECTOR_ROLE && roleQuietHold(cfg.quietHoursPerRole, baseRoleOf(l.role), new Date()))
-            .map((l) => [l.role, cfg.quietHoursPerRole?.[baseRoleOf(l.role)] ?? ""])),
-        pausedUntil: teamPause?.until,
-        pausedRolesUntil: pausedRolesUntil(root),
-        scheduledWake: wakes[0],
-        scheduledWakes: wakes.length > 0 ? wakes : undefined,
-        pauseReason: teamPause?.reason,
-        quietHours: quiet.window ?? undefined,
-        inQuietHours: quiet.inWindow,
-        mergeQueue,
-        mainCheck: mainCheckForPoll(root, cfg),
-        ciParity: ciParityForPoll(root, cfg),
-        noDeclaredCheck: detectBuildCheck(root, cfg) === null ? true : undefined,
-        // The disk floor's published state (plans/disk-floor.md, part 4/4): only while the
-        // orchestrator runs — the exit removes the info file, so a stale file beside a dead pid
-        // must not speak for a stopped team — and only when the last poll could measure the
-        // volume. Absent otherwise, so the surfaces render exactly as before.
-        disk: running && info?.disk ? info.disk : undefined,
-        // Independent of the team running: a stopped team's worktrees still borrow the root install.
-        rootInstallDrift: rootDrift.length ? rootDrift : undefined,
-        // Only while running: a stale info file beside a dead pid must not speak for a stopped team.
-        permits: running && info?.permits ? info.permits : undefined,
-        slotPool: running && info?.slotPool ? info.slotPool : undefined,
-        // Only while running: a stale info file beside a dead pid must not speak for a stopped team.
-        checkPermits: running && info?.checkPermits ? info.checkPermits : undefined,
-        // Only while running: a stale info file beside a dead pid must not speak for a stopped team.
-        runStopsAt: running ? earliestStop(info?.stopsAt, scheduledStopAt(root)) : undefined,
-        scheduledStopAt: running ? scheduledStopAt(root) : undefined,
+        ...snapshotBudgetFields(budget, subscriptionWindows, subscriptionOnly, claudeBlock, running, info),
+        ...snapshotPauseFields(teamPause, markerRoles, roles, markerSet, capPaused, maintenanceQuota, bootstrapNow, roleRows, budgetPausedRoles, cfg, root, wakes, quiet),
+        ...snapshotHealthFields(root, cfg, mergeQueue, roleNotesOverCap),
+        ...snapshotResourceFields(root, running, info, rootDrift),
     };
 }