tumwater 0.1.2 → 0.2.0

package/dist/src/scheduling/once-round.js

@@ -8,9 +8,9 @@ import { stateSkipReason } from "../loop/loop-state.js";
  * with a persistent reason (backoff, paused, disabled mid-round, or the director's empty inbox —
  * nothing a poll can change). The value is the skip reason, for the caller's summary. A role
  * whose tick is merely in flight is NOT settled — the orchestrator only fires its stop once
- * every role is settled AND no tick is in flight AND the land queue has been empty with no
- * landing in flight for one full poll cycle (the guard against dropping a
- * queued-but-not-yet-started landing: a stop that lands during the shutdown drain drops the
+ * every role is settled AND no tick is in flight AND the merge queue has been empty with no
+ * merge in flight for one full poll cycle (the guard against dropping a
+ * queued-but-not-yet-started merge: a stop that arrives during the shutdown drain drops the
  * queue entry, so the slot gets one poll to pick the entry up before the stop is trusted).
  */
 export class OnceRound {
@@ -24,7 +24,7 @@ export class OnceRound {
         this.runners = runners;
         this.active = active;
         for (const r of runners)
-            this.tickSnapshots.set(r.role, r.state.ticks);
+            this.tickSnapshots.set(r.role, r.state.runs);
     }
     /** The runner's pre-round tick baseline. Snapshotted at construction for the startup
      * runners — and at FIRST SIGHT for a runner appended later: the live config reload
@@ -39,17 +39,17 @@ export class OnceRound {
         const known = this.tickSnapshots.get(runner.role);
         if (known !== undefined)
             return known;
-        this.tickSnapshots.set(runner.role, runner.state.ticks);
-        return runner.state.ticks;
+        this.tickSnapshots.set(runner.role, runner.state.runs);
+        return runner.state.runs;
     }
     /** A role is settled once it ran its tick or a settle reason was recorded for it. */
     isSettled(runner) {
-        return runner.state.ticks > this.snapshotOf(runner) || this.settled.has(runner.role);
+        return runner.state.runs > this.snapshotOf(runner) || this.settled.has(runner.role);
     }
     /** Ticks this round advanced the runner past its snapshot — the exit summary's per-role
      * count, exact even for a role the caller's own pre-round snapshot never named. */
     ticksRun(runner) {
-        return runner.state.ticks - this.snapshotOf(runner);
+        return runner.state.runs - this.snapshotOf(runner);
     }
     /** Record the role's once-round answer (why it ran no tick, or that it deferred). */
     settle(role, reason) {
@@ -72,14 +72,14 @@ export class OnceRound {
         return this.settled;
     }
     /** True on the SECOND consecutive quiet poll — every role settled, no role or director tick
-     * in flight, no landing task running, land queue empty — and false otherwise (resetting the
+     * in flight, no merge task running, merge queue empty — and false otherwise (resetting the
      * quiet streak). The orchestrator fires its internal stop when this returns true. */
     exitReady(flight) {
         const quiet = this.runners.every((r) => this.isSettled(r)) &&
             flight.roleTicks === 0 &&
             flight.directorTicks === 0 &&
-            flight.landings === 0 &&
-            flight.queuedLandings === 0;
+            flight.merges === 0 &&
+            flight.queuedMerges === 0;
         if (!(this.active && quiet)) {
             this.idlePolls = 0;
             return false;

package/dist/src/scheduling/quiet-hours.js

@@ -1,60 +1,53 @@
+// vocabulary: plain
 /** Quiet hours (plans: "Quiet hours … part 1/2, the gate"): a config-driven daily local-time
  * window — `"23:00-07:00"` — during which role loops start no new ticks, so an operator can
- * put the fleet on a nightly schedule once instead of typing `tumwater pause` every evening.
+ * put the team on a nightly schedule once instead of typing `tumwater pause` every evening.
  * Extracted from the orchestrator's concerns the same way the pause gate is
  * (src/gates/pause-gates.ts): the parsing, the membership decision, and the edge-triggered
  * quiet/awake events live here; the orchestrator owns only the wiring. The director is
  * exempt — a human steering outranks a schedule — exactly as under the budget gate and the
  * operator pause. In-flight ticks finish; the gate sits before eligibility, so a tick due
  * inside the window simply starts at window end. */
-import { logEventBestEffort } from "../events/events.js";
+import { logEventBestEffort, TUMWATER_SOURCE } from "../events/events.js";
 import { gotSuffix, isNonBlankString } from "../text/text.js";
+/** The error arm of ParsedQuietHours — one home for the `{ ok: false, error }` constructor
+ * every parse-failure path of parseQuietHours returns, so the shape cannot drift between
+ * the five rejection messages. (The same-named helper in config-write.ts serves the config
+ * writers' parallel union; the type here is narrower, so each module owns its own.) */
+function fail(error) {
+    return { ok: false, error };
+}
 /** Parse one `quietHours` value: `"HH:MM-HH:MM"` in local time, 24-hour clock, a wrapping
  * window (`start > end`) is the overnight case the format exists for. `key` is the config key
- * the value came from, named verbatim in every error; it defaults to the fleet-wide
+ * the value came from, named verbatim in every error; it defaults to the team-wide
  * `quietHours`, and the per-role map passes `quietHoursPerRole.<id>` so a rejected entry names
  * the key the operator actually set rather than a different one. */
 export function parseQuietHours(value, key = "quietHours") {
     if (value === undefined || value === null)
         return { ok: true, window: null };
     if (typeof value !== "string")
-        return {
-            ok: false,
-            error: `${key} must be a string like "23:00-07:00"${gotSuffix(value)}`,
-        };
+        return fail(`${key} must be a string like "23:00-07:00"${gotSuffix(value)}`);
     if (value.trim() === "")
         return { ok: true, window: null }; // empty means off
     const parts = value.split("-");
     if (parts.length !== 2)
-        return {
-            ok: false,
-            error: `${key} must be "HH:MM-HH:MM" with exactly one dash, e.g. "23:00-07:00"${gotSuffix(value)}`,
-        };
+        return fail(`${key} must be "HH:MM-HH:MM" with exactly one dash, e.g. "23:00-07:00"${gotSuffix(value)}`);
     const ends = [];
     for (const part of parts) {
         const trimmed = part.trim();
         const m = /^(\d{1,2}):(\d{2})$/.exec(trimmed);
         if (!m)
-            return {
-                ok: false,
-                error: `${key} times must be 24-hour "HH:MM", e.g. "23:00"${gotSuffix(trimmed)}`,
-            };
+            return fail(`${key} times must be 24-hour "HH:MM", e.g. "23:00"${gotSuffix(trimmed)}`);
         const hours = Number(m[1]);
         const minutes = Number(m[2]);
         if (hours > 23 || minutes > 59)
-            return {
-                ok: false,
-                error: `${key} times must be 24-hour "HH:MM" — hours 00-23, minutes 00-59${gotSuffix(trimmed)}`,
-            };
+            return fail(`${key} times must be 24-hour "HH:MM" — hours 00-23, minutes 00-59${gotSuffix(trimmed)}`);
         ends.push(hours * 60 + minutes);
     }
     // parts.length === 2 above, so both ends are present (the non-null assertions are safe).
     const [startMin, endMin] = [ends[0], ends[1]];
     if (startMin === endMin)
-        return {
-            ok: false,
-            error: `${key} start and end must differ — a zero-length window means nothing schedulable${gotSuffix(value)}`,
-        };
+        return fail(`${key} start and end must differ — a zero-length window means nothing schedulable${gotSuffix(value)}`);
     return { ok: true, window: { startMin, endMin } };
 }
 /** Is `date` (its LOCAL wall clock — the operator reads the schedule off their own clock)
@@ -68,7 +61,7 @@ export function inQuietHours(window, date) {
     }
     return minutes >= window.startMin || minutes < window.endMin; // wraps midnight
 }
-/** A fresh gate state: outside the window (the default for a fleet without quiet hours), so
+/** A fresh gate state: outside the window (the default for a team without quiet hours), so
  * the first poll of an unset window logs nothing. */
 export function newQuietHoursGateState() {
     return { prevIn: false };
@@ -76,16 +69,16 @@ export function newQuietHoursGateState() {
 /** Poll the quiet-hours gate for one orchestrator cycle — the pause gate's scheduled sibling
  * (src/gates/pause-gates.ts pollPauseGates): parse the config value fresh (a live edit applies on
  * the next poll), decide membership for `now`, and log exactly one `quiet_hours_started` /
- * `quiet_hours_ended` event (`loop: "harness"`, with the effective window string) per
+ * `quiet_hours_ended` event (`source: TUMWATER_SOURCE`, with the effective window string) per
  * crossing. An unset/off window is simply "outside", so nothing is ever logged for it.
- * Returns whether the fleet is inside the window right now. */
+ * Returns whether the team is inside the window right now. */
 export function pollQuietHoursGate(root, quietHours, state, now) {
     const parsed = parseQuietHours(quietHours);
     const inNow = parsed.ok && parsed.window !== null && inQuietHours(parsed.window, now);
     if (inNow !== state.prevIn) {
         state.prevIn = inNow;
         logEventBestEffort(root, {
-            loop: "harness",
+            source: TUMWATER_SOURCE,
             type: inNow ? "quiet_hours_started" : "quiet_hours_ended",
             window: typeof quietHours === "string" ? quietHours : undefined,
         });
@@ -93,11 +86,11 @@ export function pollQuietHoursGate(root, quietHours, state, now) {
     return inNow;
 }
 /** Per-role quiet hours (PLANS.md, `quietHoursPerRole`): is `role`'s own window holding at
- * `now`? The membership decision reuses the fleet window's own parser and predicate, so a
- * per-role window means exactly what the same string means fleet-wide (wrapping included).
+ * `now`? The membership decision reuses the team window's own parser and predicate, so a
+ * per-role window means exactly what the same string means team-wide (wrapping included).
  * An absent key, a non-string, or an unparseable value reads as off here — validation is
  * config-validation.ts's job, not this helper's, and a malformed value must never hold a
- * loop the operator did not schedule. Stateless: unlike the fleet-wide gate there is no
+ * loop the operator did not schedule. Stateless: unlike the team-wide gate there is no
  * edge-triggered event — a per-role hold is an anonymous verdict recomputed per poll,
  * exactly like `capPaused`'s set (role-cap-gates.ts). */
 export function roleQuietHold(perRole, role, now) {
@@ -108,11 +101,11 @@ export function roleQuietHold(perRole, role, now) {
     return parsed.ok && parsed.window !== null && inQuietHours(parsed.window, now);
 }
 /** The window's end time exactly as the operator wrote it — the text after the dash, trimmed —
- * for the surfaces that say "quiet until <end>" (badges.ts's quietBadge, fleet-alerts' quiet
+ * for the surfaces that say "quiet until <end>" (badges.ts's quietBadge, team-alerts' quiet
  * alert). parseQuietHours enforces exactly one dash, so reading the end back out of the string
  * is well-defined and preserves the operator's spelling instead of reformatting parsed
  * minutes. The GUI page's client-side script re-derives the same text from the payload's raw
- * quietHours field (gui-client-fleet.ts), since browser code cannot import this module. */
+ * quietHours field (gui-client-team.ts), since browser code cannot import this module. */
 export function quietWindowEnd(quietHours) {
     return quietHours.split("-")[1]?.trim() ?? "";
 }

package/dist/src/scheduling/scheduling.js

@@ -1,12 +1,13 @@
 /** Tick-scheduling POLICY, split out of orchestrator.ts (the poll-loop runtime that calls it):
  * pure decisions over a runner's state and the world — when a loop may tick, in what order
- * eligible loops take slots, and whether landed work or an open backlog defers idle
+ * eligible loops take slots, and whether merged work or an open backlog defers idle
  * maintenance. No I/O, no process state: every function
  * takes plain data (a LoopRunner's observable fields, timestamps, commit subjects) so the
  * policy is unit-tested without running an orchestrator, and a future change to how ticks are
- * driven (e.g. the merge queue's async landing, PLANS.md 3/5) reuses these decisions instead of
+ * driven (e.g. the merge queue's async merge, PLANS.md 3/5) reuses these decisions instead of
  * re-deriving them inside the loop. Dependency direction: orchestrator → scheduling; this
  * module only reads LoopRunner through its public fields and imports no runtime from it. */
+import { hasOutstandingWork } from "../loop/loop-state.js";
 import { scheduleConfigForRole } from "../config/config-views.js";
 import { BUGFIX_ROLE, DEFERRABLE_ROLES, DIRECTOR_ROLE, roleTier, } from "../roles/roles.js";
 import { baseRoleOf, loopEnabled } from "../roles/loop-ids.js";
@@ -56,32 +57,32 @@ export function isEligible(runner, now, mainHead, inboxCount, opts = {}) {
     // finding nothing slows down, and the multiplication gates the "main moved" wake below
     // too, which is where the cost actually comes from (the gap check above runs first, so a
     // scaled role inside its stretched gap neither ticks on schedule nor on a main move).
-    // One landing in the last ten counted ticks restores the plain gap; error-class results
+    // One merge in the last ten counted ticks restores the plain gap; error-class results
     // never enter the ring (backoff.ts), so a failing backend does not stretch anything;
     // `--once`, an operator wake, and a queued prompt all bypass the gap check entirely.
     const mult = yieldMultiplierFor(runner.state);
     // The same bootstrap rule (scheduleConfigForRole) loop-tick.ts schedules nextRunAt from: during a
-    // young project's bootstrap, plan runs on the fleet's global clock rather than its 3600 s
+    // young project's bootstrap, plan runs on the team's global clock rather than its 3600 s
     // default. Yield scaling still applies to whatever gap is chosen.
-    const minGapSeconds = scheduleConfigForRole(runner.config, runner.role, opts.bootstrapActive === true).minTickIntervalSeconds;
+    const minGapSeconds = scheduleConfigForRole(runner.config, runner.role, opts.bootstrapActive === true, opts.descriptionIncomplete === true).minRunIntervalSeconds;
     const minGap = opts.once ? 0 : minGapSeconds * 1000 * mult;
-    const sinceLast = now - (s.lastTickEndedAt ?? 0);
+    const sinceLast = now - (s.lastRunEndedAt ?? 0);
     // An operator wake newer than the gap window's opening tick overrides the interval
     // (LoopState.wokenAt): an explicit "try again now" with an empty queue must not silently
     // wait out the remaining slow clock it ticked inside — a queued prompt carries its own
     // due-ness in the inbox check above, so it never depends on this stamp surviving.
-    const woken = s.wokenAt !== undefined && s.wokenAt > (s.lastTickEndedAt ?? 0);
+    const woken = s.wokenAt !== undefined && s.wokenAt > (s.lastRunEndedAt ?? 0);
     if (sinceLast < minGap && !woken)
         return { run: false };
     // Once mode's clock override, second half: a raised backoffSeconds means nextRunAt is a
     // backoff deadline, not the scheduled clock, and is honored; at zero it is the clock a
     // productive tick scheduled, and the explicit round demand overrides it.
     if (now >= s.nextRunAt || (opts.once && s.backoffSeconds === 0)) {
-        return { run: true, reason: s.ticks === 0 ? "startup" : "scheduled" };
+        return { run: true, reason: s.runs === 0 ? "startup" : "scheduled" };
     }
     // The world changed under a sleeping loop: main moved since its last tick. The stretched
     // gap above gates this wake too (the gap check runs first), so a role whose recent ticks
-    // landed nothing does not re-check on every landing — the multiplier's whole point.
+    // merged nothing does not re-check on every merge — the multiplier's whole point.
     if (s.lastMainHead && mainHead && mainHead !== s.lastMainHead) {
         return { run: true, reason: "main moved" };
     }
@@ -90,7 +91,7 @@ export function isEligible(runner, now, mainHead, inboxCount, opts = {}) {
 /** Fair scheduling order for one poll's eligible loops: the director always leads (it runs
  * the user's prompts), then the work tier (feature/bugfix/plan) before maintenance — a stale-
  * ticked feature takes a slot over a fresh-ticked steward, because shipping work is what the
- * fleet exists to do — and within a tier least-recently-ticked first, so loops alternate
+ * team exists to do — and within a tier least-recently-ticked first, so loops alternate
  * instead of the same ones re-claiming freed slots. Never-run loops tie at zero and the stable
  * sort keeps them in role-catalog (priority) order. */
 export function fairOrder(runners) {
@@ -101,20 +102,23 @@ export function fairOrder(runners) {
         const tier = roleTier(a.role) - roleTier(b.role);
         if (tier !== 0)
             return tier;
-        return (a.state.lastTickEndedAt ?? 0) - (b.state.lastTickEndedAt ?? 0);
+        return (a.state.lastRunEndedAt ?? 0) - (b.state.lastRunEndedAt ?? 0);
     });
 }
-/** Did work land on main since a head? (Need-based prioritization, PLANS.md "Prioritize loops
+/** Did work merge on main since a head? (Need-based prioritization, PLANS.md "Prioritize loops
  * by need".) A commit counts when its subject starts with `tumwater(feature):`,
- * `tumwater(bugfix):`, or `tumwater(director):` — the harness stamps that prefix itself
- * (buildCommitMessage), so attribution needs no new metadata; a director commit is user-directed
+ * `tumwater(bugfix):`, `tumwater(director):`, or `tumwater(operator):` — the harness stamps
+ * that prefix itself (buildCommitMessage), so attribution needs no new metadata; a director
+ * commit is user-directed
  * work, and after a pure-director burst the maintenance roles must resync. Or the subject
  * carries no `tumwater(` prefix at all: a human commit, where the world changed in a way the
- * fleet cannot generate itself. Every other role's landing is markdown or hygiene; waking
+ * team cannot generate itself. An operator commit (the stamp the CLI, TUI and dashboard
+ * backlog/brief edits write) is the human's own change made through tumwater, so it counts like
+ * an unstamped human commit. Every other role's merge is markdown or hygiene; waking
  * maintenance roles on it is exactly the cascade deferral removes.
  */
-export function workLanded(subjects) {
-    return subjects.some((subject) => /^tumwater\((feature|bugfix|director)\):/.test(subject) || !subject.startsWith("tumwater("));
+export function workMerged(subjects) {
+    return subjects.some((subject) => /^tumwater\((feature|bugfix|director|operator)\):/.test(subject) || !subject.startsWith("tumwater("));
 }
 /** How long a due maintenance tick may stay deferred before it is forced to run anyway. The
  * deferral predicate keys off `lastResult`, which only a completed tick updates, so without a
@@ -133,15 +137,30 @@ export const DEFER_MAX_MS = 3 * 3600 * 1000;
 function deferralExpired(s, now) {
     return s.nextRunAt > 0 && now - s.nextRunAt >= DEFER_MAX_MS;
 }
+/** The plan loop's own deferral: a due tick (no fresh wake, nothing outstanding, main seen
+ * before, inside DEFER_MAX_MS) while PLANS.md already holds its eligible-plan target
+ * (planBacklogFull). `lastResult` does not matter: the charter would stop either way. */
+function planDeferral(s, planBacklogFull, now) {
+    const woken = s.wokenAt !== undefined && s.wokenAt > (s.lastRunEndedAt ?? 0);
+    return planBacklogFull &&
+        !woken &&
+        !hasOutstandingWork(s) &&
+        s.lastMainHead !== "" &&
+        !deferralExpired(s, now)
+        ? "plans-full"
+        : null;
+}
 /** The deferral verdict as its clause, or null when the tick is admitted. The one home of the
  * predicate (deferTick is this function's null test) and of the clause order: a deferrable
- * maintenance role with the backlog open reports "backlog" even when work also landed — the
- * backlog clause stands in for the landing verdict, which the caller short-circuits — while the
+ * maintenance role with the backlog open reports "backlog" even when work also merged — the
+ * backlog clause stands in for the merge verdict, which the caller short-circuits — while the
  * bugfix-in-search-mode branch ignores the backlog and reports "no-work". */
-export function deferTickReason(s, role, workLandedSinceLast, workBacklogOpen, openBugsNow, now) {
+export function deferTickReason(s, role, workMergedSinceLast, workBacklogOpen, openBugsNow, now, planBacklogFull = false) {
     const base = baseRoleOf(role);
+    if (base === "plan")
+        return planDeferral(s, planBacklogFull, now);
     const searchBugfix = base === BUGFIX_ROLE && !openBugsNow;
-    const due = !(s.wokenAt !== undefined && s.wokenAt > (s.lastTickEndedAt ?? 0)) &&
+    const due = !(s.wokenAt !== undefined && s.wokenAt > (s.lastRunEndedAt ?? 0)) &&
         (DEFERRABLE_ROLES.has(base) || searchBugfix) &&
         s.lastResult === "no_change" &&
         s.lastMainHead !== "" &&
@@ -150,9 +169,9 @@ export function deferTickReason(s, role, workLandedSinceLast, workBacklogOpen, o
         return null;
     if (!searchBugfix && workBacklogOpen)
         return "backlog";
-    return workLandedSinceLast ? null : "no-work";
+    return workMergedSinceLast ? null : "no-work";
 }
 /** The boolean projection of deferTickReason: does this due maintenance tick defer? */
-export function deferTick(s, role, workLandedSinceLast, workBacklogOpen, openBugsNow, now) {
-    return deferTickReason(s, role, workLandedSinceLast, workBacklogOpen, openBugsNow, now) !== null;
+export function deferTick(s, role, workMergedSinceLast, workBacklogOpen, openBugsNow, now) {
+    return deferTickReason(s, role, workMergedSinceLast, workBacklogOpen, openBugsNow, now) !== null;
 }

package/dist/src/scheduling/{work-landed-cache.js → work-merged-cache.js}

@@ -1,23 +1,23 @@
-/** The need-based deferral's cached "did qualifying work land on main since <head>?" check,
+/** The need-based deferral's cached "did qualifying work merge on main since <head>?" check,
  * split out of orchestrator.ts (whose runOrchestrator had grown it as an inline closure over
- * the poll-loop state) — it now lives in scheduling/ next to the workLanded policy it caches.
+ * the poll-loop state) — it now lives in scheduling/ next to the workMerged policy it caches.
  * This module adds only the caching layer around it plus the one git query that feeds it.
  *
  * Caching rule: verdicts are cached per base head so a
- * quiet fleet pays no git cost in steady state. A TRUE verdict is monotone under
- * fast-forward-only main movement — once work has landed in (sinceHead, main] it stays
+ * quiet team pays no git cost in steady state. A TRUE verdict is monotone under
+ * fast-forward-only main movement — once work has merged in (sinceHead, main] it stays
  * there — so true heads never re-evaluate. A FALSE verdict is valid exactly while main sits at
  * the head it was checked against: the range cannot grow until main moves, so a cached false
  * skips the `git log` entirely and re-checks once when main's head changes (a false can flip to
  * true only on such movement — caching it unconditionally would defer a role forever after the
- * very commit that should wake it). Both caches are bounded, so a long-running fleet cannot
+ * very commit that should wake it). Both caches are bounded, so a long-running team cannot
  * grow them unbounded. */
 import { subjectsBetween } from "../git/git.js";
-import { workLanded } from "./scheduling.js";
-export class WorkLandedCache {
+import { workMerged } from "./scheduling.js";
+export class WorkMergedCache {
     root;
     mainBranch;
-    workLandedHeads = new Set();
+    workMergedHeads = new Set();
     /** sinceHead -> main head at which "no work" held */
     noWorkAtHead = new Map();
     constructor(root, mainBranch) {
@@ -25,7 +25,7 @@ export class WorkLandedCache {
         this.mainBranch = mainBranch;
     }
     async since(sinceHead, mainHeadNow) {
-        if (this.workLandedHeads.has(sinceHead))
+        if (this.workMergedHeads.has(sinceHead))
             return true;
         const checkedAt = this.noWorkAtHead.get(sinceHead);
         // Main has not moved since the last check for this head — the range is unchanged. An empty
@@ -33,13 +33,13 @@ export class WorkLandedCache {
         if (mainHeadNow !== "" && checkedAt === mainHeadNow)
             return false;
         const subjects = await subjectsBetween(this.root, sinceHead, this.mainBranch);
-        // A range that cannot be evaluated is treated as work landed — conservative: run the tick.
-        const verdict = subjects === null ? true : workLanded(subjects);
+        // A range that cannot be evaluated is treated as work merged — conservative: run the tick.
+        const verdict = subjects === null ? true : workMerged(subjects);
         if (verdict) {
             this.noWorkAtHead.delete(sinceHead);
-            if (this.workLandedHeads.size >= 200)
-                this.workLandedHeads.clear();
-            this.workLandedHeads.add(sinceHead);
+            if (this.workMergedHeads.size >= 200)
+                this.workMergedHeads.clear();
+            this.workMergedHeads.add(sinceHead);
         }
         else if (mainHeadNow !== "") {
             if (this.noWorkAtHead.size >= 200)

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

@@ -0,0 +1,115 @@
+// vocabulary: plain
+import { claudeWindowEntries, readClaudeAccount, } from "../agent/claude/claude-account.js";
+import { budgetReached, teamDailyCost, modelPairName, projectCapHit } from "../budget/budget.js";
+import { roleCapVerdicts } from "../gates/role-cap-gates.js";
+import { configForRole, resolverConfig, reviewConfig, roleSeamTier, } from "../config/config-views.js";
+import { resolveTierFallbacks, tierFallbackLabels, tiersResolveDistinctPairs } from "../config/config-fallbacks.js";
+import { enabledRoleIds } from "../config/config.js";
+import { fallbackModelFree, piPairFree, readPiProviders, seamFree, teamModelsFree } from "../pi/pi-models.js";
+import { readOpencodeCache } from "../agent/opencode/opencode-catalog.js";
+import { DIRECTOR_ROLE } from "../roles/roles.js";
+/** The claude subscription-window block for a poll (see StatusSnapshot.claudeWindow): absent
+ * unless the account reads subscription billing with at least one window AND a resolved seam
+ * routes to claude. `only` is the free-ness classification the display needs: every paying seam
+ * is a subscription claude seam exactly when no other seam is priced — a pi seam judged by
+ * piPairFree, any other backend's billing unseen so it counts as paying too. The reviewer and
+ * the strong-tier resolver are included, like teamModelsFree, since they can spend. The
+ * account is the poll's single readClaudeAccount result, so the window and every piPairFree
+ * verdict judge the same reading. */
+function claudeWindowBlock(cfg, providers, account, catalog) {
+    if (account?.billing !== "subscription")
+        return undefined;
+    const windows = claudeWindowEntries(account);
+    if (windows.length === 0)
+        return undefined;
+    const seams = enabledRoleIds(cfg).map((role) => configForRole(cfg, role));
+    if (cfg.review.enabled)
+        seams.push(reviewConfig(cfg));
+    if (seams.length > 0)
+        seams.push(resolverConfig(cfg));
+    if (!seams.some((s) => s.agent === "claude"))
+        return undefined;
+    const priced = seams.some((s) => {
+        if (s.agent === undefined || s.agent === "pi")
+            return !piPairFree(providers, s.provider, s.model, account, catalog);
+        // An opencode seam is subscription-paid only when the catalog prices it at zero (part
+        // 6b/7); any other agent the account cannot bill is never subscription-paid.
+        if (s.agent === "opencode")
+            return !seamFree(providers, s, account, catalog);
+        return s.agent !== "claude"; // a backend the account cannot bill is never subscription-paid
+    });
+    const heldUntil = windows
+        .filter((w) => w.status === "rejected" && w.isUsingOverage !== true && typeof w.resetsAt === "number")
+        .reduce((max, w) => Math.max(max, w.resetsAt), 0) || null;
+    return { windows, primary: windows[0], only: !priced, heldUntil };
+}
+/** The spend/billing block for a poll: the one materialized `spentUsd` (the scheduler's own
+ * published figure while running — BUGS.md 2026-09-30 — the persisted states' sum otherwise)
+ * that the budget object, the burn-rate projection and `free`/`fallback`/`tiers` all read;
+ * the per-tier pause set (part 5c/8) and the per-role daily-cap set, each the gate's own
+ * verdict over the same last-known-good config and one `now`. Owns the price-aware pair logic
+ * (piPairFree, fallbackModelFree, teamModelsFree, resolveTierFallbacks) so it has one home:
+ * models.json is read once (readPiProviders) and the claude account once (readClaudeAccount,
+ * on the snapshot's own pinned `now`), and every free-ness verdict and the window judge that
+ * single reading. The director is exempt from both pause sets, exactly as the gates exempt it. */
+export function collectBudget(root, cfg, loops, roles, running, info, modelsPath, now) {
+    // The running orchestrator's published gate figures (read once above, with the pid and the
+    // demotion): the scheduler's own sum over its live runner states. Only while running — the
+    // exit removes the info file, so a stale file beside a dead pid must not speak for a team
+    // whose persisted files are final.
+    const publishedSpend = running && info?.budget ? info.budget.spentUsd : null;
+    // The one materialized spend the budget block renders and the burn-rate projection both
+    // read — the scheduler's published figure while running, the persisted states' sum otherwise.
+    const spentUsd = publishedSpend ?? teamDailyCost(loops, now);
+    // The persisted billing answer (6a/7), read once for every free-ness verdict below: a
+    // subscription claude seam is free, so the badge and the pause set judge it as such.
+    const account = readClaudeAccount(root, now);
+    const budgetReachedNow = budgetReached({ spentUsd, capUsd: cfg.maxDailyCostUsd });
+    const providers = readPiProviders(modelsPath);
+    // The cached opencode models catalog (part 6b/7), seeded at the startup gate and read once per
+    // poll so every free-ness verdict below prices opencode seams against the same snapshot.
+    const catalog = readOpencodeCache(root);
+    const publishedDemotions = info?.fallbackDemotions ?? {};
+    const usable = (p) => piPairFree(providers, p.provider, p.model, account, catalog) && !(modelPairName(p) in publishedDemotions);
+    const servingResolved = resolveTierFallbacks(cfg, usable);
+    // The subscription usage window (part 6d/7): one account read per poll serves the block.
+    const claudeWindow = claudeWindowBlock(cfg, providers, account, catalog);
+    // The per-tier budget pause set (part 5c/8): the same resolution the scheduler's gate folds,
+    // over the SAME usable predicate an observer can re-derive — the price check, and the pair
+    // not among the running orchestrator's published per-pair demotions. Computed only while the
+    // cap is reached — the hold never stands under an open gate — and the director exempt.
+    const budgetPausedRoles = budgetReachedNow
+        ? roles.filter((r) => r !== DIRECTOR_ROLE && servingResolved[roleSeamTier(cfg, r)].pair === null)
+        : [];
+    const capPaused = [
+        ...roleCapVerdicts(loops.map((l) => ({ role: l.role, state: l })), cfg.maxDailyCostUsdPerRole, now).values(),
+    ]
+        .filter((v) => v.over)
+        .flatMap((v) => v.roleIds);
+    return {
+        budget: {
+            spentUsd,
+            capUsd: cfg.maxDailyCostUsd,
+            // One projection per poll, from the same spend the field above renders: null exactly
+            // when no forecast may be stated (no cap, no spend, cap reached, burn misses midnight).
+            capHitAt: projectCapHit({ spentUsd, capUsd: cfg.maxDailyCostUsd }, now),
+            free: teamModelsFree(cfg, modelsPath, account, catalog),
+            backend: cfg.backend ?? "pi",
+            // Null unless the gate could actually engage it (configured AND priced at zero AND not
+            // demoted by the running orchestrator's breaker): a fallback the scheduler would refuse
+            // must not be advertised as one that will save the team — and a demoted one is refused
+            // until its probe serves, so the dashboards read `budget paused` exactly while the
+            // scheduler is (BUGS.md 2026-09-20). The pair is the price-aware default tier's
+            // resolution, so a map with no `default` entry names the pair the gate actually runs.
+            fallback: fallbackModelFree(cfg, modelsPath, account, catalog) && !(running && info?.fallbackDemoted)
+                ? (servingResolved.default.pair ?? null)
+                : null,
+            tiers: budgetReachedNow && tiersResolveDistinctPairs(servingResolved)
+                ? tierFallbackLabels(servingResolved)
+                : null,
+        },
+        claudeWindow,
+        budgetPausedRoles,
+        capPaused,
+    };
+}