tumwater 0.1.2 → 0.2.0

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

@@ -1,198 +1,100 @@
-import path from "node:path";
 import { readSlotsState } from "../git/slots-state.js";
 import { openBugs, openQuestions } from "../backlog/backlog.js";
-import { enabledRoleIds, isCustomRole } from "../config/config.js";
-import { baseRoleOf, loopIds } from "../roles/loop-ids.js";
-import { modelFallbackView, modelSelectorField, resolveTierFallbacks, roleSeamTier, configForRole, reviewConfig, resolverConfig, tierFallbackLabels, tiersResolveDistinctPairs, } from "../config/config-views.js";
-import { claudeWindowEntries, readClaudeAccount } from "../agent/claude/claude-account.js";
-import { isJsonObject } from "../files/json-object.js";
-import { fallbackModelFree, fleetModelsFree, piModelsPath, piPairFree, readPiProviders } from "../pi/pi-models.js";
-import { configForStatus, liveLandingMarker, loopStateForPoll, mainCheckForPoll, maintenanceQuotaForPoll } from "./status-polls.js";
-import { queuedRolePromptEntries } from "../inbox/inbox.js";
-import { deliverableAt } from "../inbox/prompt-not-before.js";
+import { baseRoleOf, loopIds, loopPaused } from "../roles/loop-ids.js";
+import { piModelsPath } from "../pi/pi-models.js";
+import { configForStatus, queueInFlight, mainCheckForPoll, maintenanceQuotaForPoll } from "./status-polls.js";
 import { quietHoursStatus, roleQuietHold } from "../scheduling/quiet-hours.js";
 import { DIRECTOR_ROLE } from "../roles/roles.js";
-import { pausedRoles, pausedRolesUntil, scheduledWakes, standingFleetPause } from "../fleet/fleet-state.js";
-import { orchestratorAlive, readOrchestratorInfo, } from "../fleet/orchestrator-info.js";
-import { readLandingMarker } from "../landing/landing-slot.js";
-import { budgetReached, fleetDailyCost, modelPairName, projectCapHit } from "../budget/budget.js";
-import { roleCapVerdicts } from "../gates/role-cap-gates.js";
+import { pausedRoles, pausedRolesUntil, scheduledStopAt, scheduledWakes, standingTeamPause } from "../team/team-state.js";
+import { orchestratorAlive, readOrchestratorInfo, } from "../team/orchestrator-info.js";
 import { bootstrapHoldsRole, bootstrapStatus } from "../gates/bootstrap-gates.js";
-import { readLandingQueue } from "../landing/landing-queue.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 fleetModelsFree, since they can spend. */
-function claudeWindowBlock(cfg, providers, root, now) {
-    const account = readClaudeAccount(root, now);
-    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);
-        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 };
+import { readMergeQueue } from "../merge/merge-queue.js";
+import { collectImageProbeFailures, collectRoleRows } from "./status-roles.js";
+import { collectInboxes } from "./status-inbox.js";
+import { collectBudget } from "./status-budget.js";
+import { collectRootInstallDrift } from "./status-install.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);
 }
-/** One fresh fleet snapshot for observers. `modelsPath` overrides pi's model definitions
+/** 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
  * projection) — one instant for the whole block, and the seam that keeps a test's expected
  * projection from racing the snapshot's own `Date.now()`; production callers take the default
- * and read the live clock, as always. */
+ * and read the live clock, as always. The three per-domain collectors (status-roles, status-
+ * inbox, status-budget) each take the shared reads and the pinned `now` as parameters, so
+ * every poll still reads a shared resource exactly once and the one `now` pins the whole
+ * snapshot — the consistency property the per-collector comments call out. */
 export function snapshot(root, modelsPath = piModelsPath(), now = Date.now()) {
     const cfg = configForStatus(root);
+    const rootDrift = collectRootInstallDrift(root, now);
     // The gate's read-only bootstrap verdict (plans/work-ratio.md, part 2/2), computed over the
     // same last-known-good config the caps read, so the dashboards show the hold the scheduler
     // enforces. Null when no bootstrap is configured.
     const bootstrapNow = bootstrapStatus(root, cfg);
     // One row per loop id (part 5b/7): an instance role shows `feature` and `feature-2`.
     const roles = loopIds(cfg);
+    const markerRoles = pausedRoles(root);
+    const markerSet = new Set(markerRoles);
     // One read of the orchestrator info file per poll: it serves both the displayed pid and the
     // liveness check (passing it to orchestratorAlive skips its own re-read).
     const info = readOrchestratorInfo(root);
     // One slots.json read per poll serves every row: the pooled slot a role leases (a running
-    // tick or vet) or is pinned to.
+    // tick or verification) or is pinned to — threaded into the roles collector so `running`,
+    // `disk` and the rows agree.
     const slots = readSlotsState(root).slots;
-    const loops = roles.map((r) => {
-        const base = { ...loopStateForPoll(root, r), custom: isCustomRole(cfg, r) };
-        const leased = slots.find((slot) => slot.lease?.role === r);
-        const pinned = slots.find((slot) => slot.pinnedFor === r);
-        const slot = leased ?? pinned;
-        // Every row carries the selector its config resolves to, so the dashboards show which
-        // model a role rides even with a single string `model`. A tier-name `roles.<id>.model`
-        // and a role selector override both resolve through configForRole — the same view the
-        // seam consumes. Part 7a (model-tiers.md "Observability"): the seam tier tag is added
-        // only with a tier map declared, where it names the tier a role rides.
-        const eff = configForRole(cfg, r);
-        // Model failure fallback, part 2/2: while the role's episode is active its ticks run on
-        // the tier-resolved fallback pair, so the row names that pair, the episode's start, and
-        // the failure that tripped it. `now` is the poll's own clock (the snapshot seam), so
-        // every row agrees on what "active" means.
-        const episode = modelFallbackView(base.modelFallback, cfg, r, now);
-        return {
-            ...base,
-            ...modelSelectorField(eff),
-            ...(isJsonObject(cfg.model) ? { modelTier: roleSeamTier(cfg, r) } : {}),
-            ...(episode !== null ? { fallback: episode } : {}),
-            ...(slot ? { slot: path.basename(slot.dir), slotPinned: pinned !== undefined } : {}),
-            ...(baseRoleOf(r) === r ? {} : { instanceOf: baseRoleOf(r) }),
-        };
-    });
-    // One inbox pass per poll serves all four director fields (queuedRolePromptEntries lists
-    // the directory and reads each file once): the count is the entries' length, so a prompt
-    // enqueued or dequeued mid-snapshot can never make the header badge disagree with its
-    // numbered previews, and each preview keeps its queue-file address beside it.
-    const queued = queuedRolePromptEntries(root, DIRECTOR_ROLE);
-    const inboxPrompts = queued.map((e) => e.preview);
-    const inboxFiles = queued.map((e) => e.file);
-    const inboxQueuedAt = queued.map((e) => e.queuedAtMs);
-    const inboxNotBefore = queued.map((e) => e.notBeforeMs);
-    // One directory listing pass per role per poll (below) fills the per-role counts; the
-    // director is excluded because its queue is the shared inbox above.
-    // A role with prompts queued also fills its cancel-addressable entries — the
-    // stat-keyed prompt cache keeps an unchanged file at one stat per poll. Entries follow the
-    // full list, deferred prompts included (the Queued tab lists and cancels them; only the
-    // deliverable count above excludes them).
-    const roleInbox = {};
-    const roleInboxPrompts = {};
-    // One listing pass per role serves both the deliverable count and the cancel-addressable
-    // entries: queuedRolePromptRecords already carries each readable prompt's notBeforeMs, and
-    // deliverableAt is exactly `notBeforeMs === null || notBeforeMs <= now` (prompt-not-before.ts)
-    // over the same cached text — so the old second pass (queuedRolePromptCount's own readdir +
-    // deliverability filter, once per role per poll across all 12 non-director loops) repeated
-    // work the entries pass had just done. One instant — the snapshot's own pinned `now` — pins
-    // the count and the entries to the same moment, so a caller that pins the clock sees
-    // deliverability advance with it instead of the wall clock.
-    for (const r of roles) {
-        if (r === DIRECTOR_ROLE)
-            continue;
-        const entries = queuedRolePromptEntries(root, r);
-        roleInbox[r] = entries.filter((e) => deliverableAt(e.notBeforeMs, now)).length;
-        if (entries.length)
-            roleInboxPrompts[r] = entries;
-    }
+    const loops = collectRoleRows(root, cfg, now, slots, modelsPath);
+    // 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);
+    // 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);
     const running = orchestratorAlive(root, info);
-    // One fleet-pause-marker read per poll serves both the paused flag and its deadline:
-    // isFleetPaused + pausedUntil would each re-read the same marker file every second.
-    const fleetPause = standingFleetPause(root);
-    // One read of the pending scheduled wakes feeds both the earliest and the full list, so they cannot disagree.
+    // One team-pause-marker read per poll serves both the paused flag and its deadline:
+    // isTeamPaused + pausedUntil would each re-read the same marker file every second.
+    const teamPause = standingTeamPause(root);
+    // One read of the pending scheduled wakes feeds both the earliest and the full list, so they
+    // cannot disagree.
     const wakes = scheduledWakes(root, now);
-    // One land-queue pass per poll (landing-queue.ts's stat cache keeps an unchanged queue at one
+    // One merge queue pass per poll (merge-queue.ts's stat cache keeps an unchanged queue at one
     // stat per file) serves the depth; inFlight is the 4/5 marker only when a live orchestrator
     // still has a queue entry for what the marker names (per change, for a batch) — the
     // cross-check makes every crash ordering self-healing (a stale marker alone never displays,
     // and needs no cleanup pass).
-    const queue = readLandingQueue(root);
-    const landings = queue.entries;
-    const landingMarker = readLandingMarker(root);
-    const landQueue = {
-        depth: landings.length + queue.unreadable,
+    const queue = readMergeQueue(root);
+    const merges = queue.entries;
+    const mergeQueue = {
+        depth: merges.length + queue.unreadable,
     };
-    if (landings.length > 0) {
-        landQueue.entries = landings.map((e) => ({
+    if (merges.length > 0) {
+        mergeQueue.entries = merges.map((e) => ({
             role: e.role,
             sha: e.sha,
-            tick: e.tick,
+            run: e.run,
             summary: e.summary,
             enqueuedAt: e.enqueuedAt,
+            ...(e.revisionRound !== undefined ? { revisionRound: e.revisionRound } : {}),
+            ...(Array.isArray(e.priorReview?.reasons) && e.priorReview.reasons.length > 0 ? { priorObjections: e.priorReview.reasons.length } : {}),
         }));
     }
-    const inFlight = running && landingMarker ? liveLandingMarker(landingMarker, new Set(landings.map((e) => e.sha))) : undefined;
+    const inFlight = queueInFlight(root, merges, running);
     if (inFlight)
-        landQueue.inFlight = inFlight;
-    // 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 fleet
-    // 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 ?? fleetDailyCost(loops, now);
+        mergeQueue.inFlight = inFlight;
     // Quiet hours 2/2 — one parse and one clock read per poll serve both the window string the
     // header badge renders and the in-window boolean the active reading turns on; the value is
     // read fresh from the same cached config load the budget block uses, so a live edit shows
     // on the next poll exactly when the gate applies it.
     const quiet = quietHoursStatus(cfg.quietHours, new Date());
-    // 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 (a demotion lives in
-    // the orchestrator's memory, so it publishes them; the legacy single-pair field
-    // `fallbackDemoted` is the engaged pair's entry of the same map). Computed only while the
-    // cap is reached — the hold never stands under an open gate — and the director exempt.
-    const budgetReachedNow = budgetReached({ spentUsd, capUsd: cfg.maxDailyCostUsd });
-    const providers = readPiProviders(modelsPath);
-    // 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);
-    const publishedDemotions = info?.fallbackDemotions ?? {};
-    const usable = (p) => piPairFree(providers, p.provider, p.model, account) && !(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, root, now);
-    const budgetPausedRoles = budgetReachedNow
-        ? roles.filter((r) => r !== DIRECTOR_ROLE && servingResolved[roleSeamTier(cfg, r)].pair === null)
-        : [];
+    // The spend/billing block (status-budget.ts): the budget object, the claude window, and the
+    // two per-role pause verdicts, all from one readPiProviders and one readClaudeAccount per poll.
+    const { budget, claudeWindow, budgetPausedRoles, capPaused } = collectBudget(root, cfg, loops, roles, running, info, modelsPath, now);
     return {
         running,
         pid: info?.pid,
         build: running && info?.build ? info.build : null,
-        inbox: inboxPrompts.length,
+        inbox,
         inboxPrompts,
         inboxFiles,
         inboxQueuedAt,
@@ -200,42 +102,26 @@ export function snapshot(root, modelsPath = piModelsPath(), now = Date.now()) {
         roleInbox,
         roleInboxPrompts,
         questions: openQuestions(root).length,
+        imageProbeFailures,
         loops,
-        // Unconditional (never null): a disabled fleet still shows its spend and the badge is
+        // 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: {
-            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: fleetModelsFree(cfg, modelsPath, account),
-            agent: cfg.agent ?? "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 fleet — 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) && !(running && info?.fallbackDemoted)
-                ? (servingResolved.default.pair ?? null)
-                : null,
-            tiers: budgetReachedNow && tiersResolveDistinctPairs(servingResolved)
-                ? tierFallbackLabels(servingResolved)
-                : null,
-        },
+        budget,
         ...(claudeWindow ? { claudeWindow } : {}),
-        paused: fleetPause !== null,
-        pausedRoles: pausedRoles(root),
-        capPaused: [...roleCapVerdicts(loops.map((l) => ({ role: l.role, state: l })), cfg.maxDailyCostUsdPerRole, now).values()]
-            .filter((v) => v.over)
-            .flatMap((v) => v.roleIds),
+        ...(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,
+        pausedLoops: roles.filter((id) => loopPaused(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. `landings` is the one land-queue snapshot read above, so in-flight maintenance
-        // landings count once here and in landQueue.
-        maintenanceQuota: maintenanceQuotaForPoll(root, cfg.maintenancePerWorkLanding, loops, new Set(landings.map((e) => e.role)), now),
+        // 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, loops, 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 loop list.
@@ -247,26 +133,33 @@ export function snapshot(root, modelsPath = piModelsPath(), now = Date.now()) {
             : [],
         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 fleet
+        // window, so the dashboards can render the same `quiet until <end>` wording the team
         // badge uses, scoped to the loop'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(loops
             .filter((l) => l.role !== DIRECTOR_ROLE && roleQuietHold(cfg.quietHoursPerRole, baseRoleOf(l.role), new Date()))
             .map((l) => [l.role, cfg.quietHoursPerRole?.[baseRoleOf(l.role)] ?? ""])),
-        pausedUntil: fleetPause?.until,
+        pausedUntil: teamPause?.until,
         pausedRolesUntil: pausedRolesUntil(root),
         scheduledWake: wakes[0],
         scheduledWakes: wakes.length > 0 ? wakes : undefined,
-        pauseReason: fleetPause?.reason,
+        pauseReason: teamPause?.reason,
         quietHours: quiet.window ?? undefined,
         inQuietHours: quiet.inWindow,
-        landQueue,
+        mergeQueue,
         mainCheck: mainCheckForPoll(root, cfg),
         // 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 fleet — and only when the last poll could measure the
+        // 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,
+        // 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,
     };
 }

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

@@ -0,0 +1,47 @@
+import { queuedRolePromptEntries } from "../inbox/inbox.js";
+import { deliverableAt } from "../inbox/prompt-not-before.js";
+import { DIRECTOR_ROLE } from "../roles/roles.js";
+/** One inbox pass per poll serves all four director fields (queuedRolePromptEntries lists the
+ * directory and reads each file once): the count is the deliverable entries' length, so a
+ * prompt enqueued or dequeued mid-snapshot can never make the header badge disagree with its
+ * numbered previews, and each preview keeps its queue-file address beside it. A second
+ * listing pass per role (all non-director loops) fills the per-role counts and their
+ * cancel-addressable entries from the same `queuedRolePromptEntries` records, with
+ * deliverableAt (prompt-not-before.ts) over the same cached text. `roles` is the
+ * already-computed loop list so one `loopIds` read serves the caller and both passes; `now`
+ * is the snapshot's pinned clock, so deliverability and the counts advance together instead
+ * of racing the wall clock. */
+export function collectInboxes(root, roles, now) {
+    const queued = queuedRolePromptEntries(root, DIRECTOR_ROLE);
+    const inboxPrompts = queued.map((e) => e.preview);
+    const inboxFiles = queued.map((e) => e.file);
+    const inboxQueuedAt = queued.map((e) => e.queuedAtMs);
+    const inboxNotBefore = queued.map((e) => e.notBeforeMs);
+    // The director and the per-role queues count queued prompts by the one rule — deliverableAt
+    // (prompt-not-before.ts) over the same cached text — so a deferred prompt never inflates
+    // either the header badge or a per-role marker while it is still listed and cancelable.
+    // One directory listing pass per role per poll fills the per-role counts; the director is
+    // excluded because its queue is the shared inbox above. A role with prompts queued also
+    // fills its cancel-addressable entries — the stat-keyed prompt cache keeps an unchanged
+    // file at one stat per poll. Entries follow the full list, deferred prompts included (the
+    // Queued tab lists and cancels them; only the deliverable count above excludes them).
+    const roleInbox = {};
+    const roleInboxPrompts = {};
+    for (const r of roles) {
+        if (r === DIRECTOR_ROLE)
+            continue;
+        const entries = queuedRolePromptEntries(root, r);
+        roleInbox[r] = entries.filter((e) => deliverableAt(e.notBeforeMs, now)).length;
+        if (entries.length)
+            roleInboxPrompts[r] = entries;
+    }
+    return {
+        inbox: queued.filter((e) => deliverableAt(e.notBeforeMs, now)).length,
+        inboxPrompts,
+        inboxFiles,
+        inboxQueuedAt,
+        inboxNotBefore,
+        roleInbox,
+        roleInboxPrompts,
+    };
+}

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

@@ -0,0 +1,27 @@
+// vocabulary: plain
+import { installDrift } from "../build/dep-install.js";
+/** How long a computed drift answer is reused. The answer depends on two files (the lockfile and
+ * each installed manifest), so it is throttled by time rather than keyed by stat: the dashboard
+ * polls every second and must not re-parse a large lockfile each time. */
+const ROOT_INSTALL_POLL_MS = 60_000;
+/** Safety cap, as in files/stat-cache.ts: many short-lived roots (tests) cannot grow the map
+ * unbounded. */
+const MAX_ROOTS_CACHED = 64;
+const cache = new Map();
+/** Direct dependencies `root`'s node_modules does not hold at package-lock.json's pin (the
+ * doctor's `root install` row), recomputed at most once per ROOT_INSTALL_POLL_MS per root.
+ * `[]` when there is no readable lockfile. The caller owns the returned array. */
+export function collectRootInstallDrift(root, now) {
+    const hit = cache.get(root);
+    if (hit && now - hit.at < ROOT_INSTALL_POLL_MS)
+        return [...hit.drift];
+    const drift = installDrift(root);
+    if (cache.size >= MAX_ROOTS_CACHED)
+        cache.clear();
+    cache.set(root, { at: now, drift });
+    return [...drift];
+}
+/** Forget every cached answer (tests). */
+export function resetRootInstallCache() {
+    cache.clear();
+}