tumwater 0.4.2 → 0.4.4

package/dist/src/doctor/doctor-orphans.js

@@ -2,12 +2,14 @@ import fs from "node:fs";
 import path from "node:path";
 import { worktreesDir } from "../paths.js";
 import { pidAlive } from "../process/process.js";
+import { rootToken } from "../process/run-marker.js";
 import { GROUP_POLL_MS, KILL_GRACE_MS } from "../process/process-group.js";
 import { systemProcessProbe } from "../process/process-table.js";
 import { warnEventBestEffort, TUMWATER_SOURCE } from "../events/events.js";
 import { errorMessage, truncate } from "../text/text.js";
 import { plural } from "../text/phrases.js";
-import { failOutcome, okOutcome, warnOutcome } from "./outcome.js";
+import { failOutcome, okOutcome, warnOutcome } from "./doctor-outcome.js";
+import { distinctOrdered } from "../collections.js";
 /** The orphan-process check of `tumwater doctor`, split out of doctor.ts: it is the one
  * doctor check that inspects the operating system's process table (argv, cwd, parent-child
  * tree) rather than the repo's own files, so it carries a different shape of logic — path
@@ -92,6 +94,36 @@ function harnessGone(marker) {
     const m = /^(\d+)-/.exec(marker);
     return m ? !pidAlive(Number(m[1])) : null;
 }
+/** The repo-identity token in a run marker's third dash segment — the team root tag
+ * `makeRunMarker` stamps when it knows one — or null for a rootless two-segment mark
+ * (`<pid>-<hex>`, or a torn or foreign value with no third segment): there is no evidence of
+ * which checkout's harness minted it. */
+export function markRootToken(mark) {
+    const third = mark.split("-")[2];
+    return third === undefined ? null : third;
+}
+/** The repo-identity token `makeRunMarker` stamps into a team-rooted mark — the same `rootToken`
+ * run-marker.ts mints, re-exported here so the orphan scan can spell this root's side of the
+ * comparison without importing process/run-marker. */
+export { rootToken };
+/** ps's elapsed-time field (`[[D-]HH:]MM:SS`, the string the doctor line already prints) in
+ * milliseconds, the minimum-age gate the automatic reap uses so a just-leaked — still
+ * possibly owned — process is not killed. Any shape that does not parse, or that carries an
+ * out-of-range minute or second, reads 0: the conservative reading that keeps the reap from
+ * acting on uncertain evidence. */
+export function parseEtimeMs(etime) {
+    const m = /^(?:\d+-)?(?:(\d+):)?(\d{1,2}):(\d{2})$/.exec(etime.trim());
+    if (!m)
+        return 0;
+    const hh = Number(m[1] ?? 0);
+    const mm = Number(m[2]);
+    const ss = Number(m[3]);
+    if (mm > 59 || ss > 59)
+        return 0;
+    const days = /^(\d+)-/.exec(etime.trim());
+    const d = days ? Number(days[1]) : 0;
+    return ((d * 24 + hh) * 3600 + mm * 60 + ss) * 1000;
+}
 /** A parent pid → child pids map of the table. */
 function childrenOf(rows) {
     const children = new Map();
@@ -111,8 +143,10 @@ function shownCommand(command, root) {
     return truncate(cut.reduce((c, rt) => c.split(`${rt}/`).join(""), command), ORPHAN_COMMAND_MAX);
 }
 /** The detection half of checkOrphans, shared with killOrphans so the check and the kill cannot
- * disagree about the set. */
-async function findOrphans(root, probe) {
+ * disagree about the set. Exported so the always-on orphan alert feed (src/ui/alert-feeds.ts)
+ * runs the exact same scan the doctor row reads — the alert and the row cannot drift on the
+ * orphan set. */
+export async function findOrphans(root, probe) {
     const roots = rootSpellings(root);
     let rows;
     try {
@@ -148,12 +182,24 @@ async function findOrphans(root, probe) {
             // Best-effort per the probe contract: argv and cwd still carry the check alone.
         }
     }
+    const ours = rootToken(root);
     const byMark = new Set();
     for (const r of parentless) {
         if (byArgv.has(r.pid))
             continue;
-        const verdicts = (marks.get(r.pid) ?? []).map(harnessGone);
-        if (verdicts.length > 0 && verdicts.every((v) => v === true))
+        const rMarks = marks.get(r.pid) ?? [];
+        const verdicts = rMarks.map(harnessGone);
+        // A dead-marked process is this checkout's only when no mark names a different root: a
+        // token that is present and not `ours` proves another checkout's harness stamped that
+        // process, and signalling it would break the "never signal a process not attributable"
+        // rule (BUGS.md, "Reap the doctor's orphans, part 1/3"). A rootless mark keeps today's
+        // report — whatever started it, nothing else will reap it.
+        if (verdicts.length > 0 &&
+            verdicts.every((v) => v === true) &&
+            rMarks.every((m) => {
+                const t = markRootToken(m);
+                return t === null || t === ours;
+            }))
             byMark.add(r.pid);
     }
     const orphans = parentless.filter((r) => {
@@ -199,16 +245,17 @@ async function findOrphans(root, probe) {
  * never a crashed doctor; unreadable cwds degrade to the argv match and say so. Any orphan is
  * a fail — the exit code is the point: a scripted doctor must notice. `probe` is injectable so
  * tests run against a fake table. */
-export async function checkOrphans(root, probe = systemProcessProbe) {
-    const scan = await findOrphans(root, probe);
+/** The orphan-problem sentence for the standing alert feed, shared with checkOrphans so the
+ * alert and the doctor row cannot drift on the wording: the count, each listed orphan's pid,
+ * age, cpu and command (with its descendant count and the run mark that caught it), and the
+ * nothing-reaps-these remediation. null when the scan errored or found no orphans. Public so
+ * the feed (src/ui/alert-feeds.ts) can stage a scan and get exactly the row's message. */
+export function orphanFailDetail(root, scan) {
     if ("error" in scan)
-        return warnOutcome(`could not scan the process table — ${scan.error}`);
+        return null;
     const { rows, orphans, marks, cwdProblem } = scan;
-    if (orphans.length === 0) {
-        if (cwdProblem !== null)
-            return warnOutcome(`none named in argv, but process cwds are unreadable (${cwdProblem}) — an orphan started inside a worktree, like a leaked test runner, would be missed`);
-        return okOutcome("none — no process reparented to PID 1 runs from .tumwater/worktrees/ or carries only dead runs' marks");
-    }
+    if (orphans.length === 0)
+        return null;
     const children = childrenOf(rows);
     const listed = orphans.slice(0, ORPHANS_LISTED_MAX).map((r) => {
         const n = descendantPids(children, r.pid).length;
@@ -221,9 +268,22 @@ export async function checkOrphans(root, probe = systemProcessProbe) {
     });
     const more = orphans.length - listed.length;
     const count = `${plural(orphans.length, "orphaned process", "orphaned processes")} (PPID 1)`;
-    return failOutcome(`${count}: ${listed.join("; ")}${more > 0 ? `; and ${more} more` : ""}` +
+    return `${count}: ${listed.join("; ")}${more > 0 ? `; and ${more} more` : ""}` +
         " — nothing reaps these; `tumwater doctor --kill-orphans` (or the dashboard Health card's Kill orphans, or the TUI Health tab's Ctrl+K pressed twice) kills each with its descendants" +
-        (cwdProblem !== null ? ` (process cwds unreadable — ${cwdProblem}; argv matched only)` : ""));
+        (cwdProblem !== null ? ` (process cwds unreadable — ${cwdProblem}; argv matched only)` : "");
+}
+/** The doctor's `orphans` row. */
+export async function checkOrphans(root, probe = systemProcessProbe) {
+    const scan = await findOrphans(root, probe);
+    if ("error" in scan)
+        return warnOutcome(`could not scan the process table — ${scan.error}`);
+    const { orphans, cwdProblem } = scan;
+    if (orphans.length === 0) {
+        if (cwdProblem !== null)
+            return warnOutcome(`none named in argv, but process cwds are unreadable (${cwdProblem}) — an orphan started inside a worktree, like a leaked test runner, would be missed`);
+        return okOutcome("none — no process reparented to PID 1 runs from .tumwater/worktrees/ or carries only dead runs' marks");
+    }
+    return failOutcome(orphanFailDetail(root, scan));
 }
 const systemSignals = {
     kill: (pid, signal) => void process.kill(pid, signal),
@@ -271,7 +331,7 @@ async function killTrees(root, rows, chosen, signals) {
         }
     };
     const trees = chosen.map((r) => ({ r, pids: [r.pid, ...descendantPids(children, r.pid)] }));
-    const all = [...new Set(trees.flatMap((t) => t.pids))];
+    const all = distinctOrdered(trees.flatMap((t) => t.pids));
     for (const pid of all)
         send(pid, "SIGTERM");
     const stillAlive = () => all.filter((pid) => !refused.has(pid) && signals.alive(pid));
@@ -291,6 +351,20 @@ async function killTrees(root, rows, chosen, signals) {
     }
     return { killed, failed };
 }
+/** The `pid N (+N descendant) command` line per killed tree and the `could not kill` line per
+ * refused tree, in the read the reapers' best-effort warning logs — the one shape both
+ * reapPreviousTeamOrphans and reapAttributableOrphans report, so the two cannot drift on the
+ * itemized wording. Callers join `[...items, ...refused]` with "; " behind their own verb
+ * phrase. */
+function orphanKillReportLines(killed, failed) {
+    return {
+        items: killed.map((k) => {
+            const tree = k.descendants > 0 ? ` (+${plural(k.descendants, "descendant")})` : "";
+            return `pid ${k.pid}${tree} ${k.command}`;
+        }),
+        refused: failed.map((f) => `could not kill pid ${f.pid}: ${f.reason}`),
+    };
+}
 /** Team start's reap of a crashed predecessor's leaks: kill the parentless processes whose run
  * marks all name dead harnesses and at least one names `previousPid`, the orchestrator the
  * info file recorded. Safe without an operator's judgment: a mark proves a tumwater start
@@ -314,11 +388,7 @@ export async function reapPreviousTeamOrphans(root, previousPid, probe = systemP
         if (chosen.length === 0)
             return 0;
         const { killed, failed } = await killTrees(root, scan.rows, chosen, signals);
-        const items = killed.map((k) => {
-            const tree = k.descendants > 0 ? ` (+${plural(k.descendants, "descendant")})` : "";
-            return `pid ${k.pid}${tree} ${k.command}`;
-        });
-        const refused = failed.map((f) => `could not kill pid ${f.pid}: ${f.reason}`);
+        const { items, refused } = orphanKillReportLines(killed, failed);
         warnEventBestEffort(root, TUMWATER_SOURCE, `killed ${plural(killed.length, "orphaned process", "orphaned processes")} left by tumwater ` +
             `${previousPid}'s runs at team start: ${[...items, ...refused].join("; ")}`);
         return killed.length;
@@ -327,3 +397,34 @@ export async function reapPreviousTeamOrphans(root, previousPid, probe = systemP
         return 0;
     }
 }
+/** How long an orphan must have been running before the automatic reap may kill it: a young
+ * orphan may still be a live run's process that findOrphans read as parentless mid-hand-off,
+ * and ten minutes is far longer than any such attribution would hold. The operator's
+ * `--kill-orphans`/dashboard/TUI click bypasses this — doctors judge with their eyes. */
+const ORPHAN_REAP_MIN_AGE_MS = 10 * 60_000;
+/** The orchestrator's once-per-interval sweep of the orphans `checkOrphans` already reports:
+ * kill the same set the operator's `--kill-orphans` kills, once each is old enough that no
+ * live run can still own it. Reuses findOrphans' attribution and killTrees' signal-and-wait,
+ * so the automatic reap cannot drift from the doctor row or the operator kill and never
+ * signals a process findOrphans does not list. An unreadable table, or no old-enough orphan,
+ * kills nothing and logs nothing; it never throws. Returns the number of orphan trees killed. */
+export async function reapAttributableOrphans(root, probe = systemProcessProbe, signals = systemSignals) {
+    try {
+        const scan = await findOrphans(root, probe);
+        if ("error" in scan)
+            return 0;
+        const chosen = scan.orphans.filter((r) => parseEtimeMs(r.etime) >= ORPHAN_REAP_MIN_AGE_MS);
+        if (chosen.length === 0)
+            return 0;
+        const { killed, failed } = await killTrees(root, scan.rows, chosen, signals);
+        if (killed.length === 0)
+            return 0;
+        const { items, refused } = orphanKillReportLines(killed, failed);
+        warnEventBestEffort(root, TUMWATER_SOURCE, `reaped ${plural(killed.length, "orphaned process", "orphaned processes")}: ` +
+            [...items, ...refused].join("; "));
+        return killed.length;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/src/doctor/{outcome.js → doctor-outcome.js}

@@ -9,6 +9,13 @@
 export function okOutcome(detail) {
     return { level: "ok", detail };
 }
+/** The doctor's stand-down on a missing or unreadable tumwater.json: an ok outcome saying
+ * there is nothing to verify, because the config check reports the broken file itself. Shared
+ * by the four checks that skip their walk when config is unavailable, so the message reads
+ * identically across them. */
+export function noConfigOutcome() {
+    return okOutcome("no readable tumwater.json — nothing to verify");
+}
 export function warnOutcome(detail) {
     return { level: "warn", detail };
 }

package/dist/src/doctor/doctor-pi-checks.js

@@ -1,5 +1,5 @@
 import { childEnv } from "../process/process.js";
-import { boundedProbe, AUTH_CHECK_MAX_OUTPUT_BYTES, AUTH_CHECK_TIMEOUT_MS } from "./probe.js";
+import { boundedProbe, AUTH_CHECK_MAX_OUTPUT_BYTES, AUTH_CHECK_TIMEOUT_MS } from "./doctor-probe.js";
 import { parseJsonObject } from "../files/json-object.js";
 import { envPath } from "../files/files.js";
 import { resolveBackendBin } from "../pi/pi-bin.js";
@@ -12,7 +12,7 @@ import { parsePiModelImages, parsePiModelTable, writePiListedModels } from "../p
  * a crash, so readiness is read from the body alone and a reply that did not run or does not
  * parse is the only "unknown" (never not-ready, which would blame credentials). Never throws;
  * every failure mode ends on "unknown". The bounded subprocess is the shared boundedProbe
- * (probe.ts), also used by the claude probes. */
+ * (doctor-probe.ts), also used by the claude probes. */
 export async function piProviderAuth(config, provider, pathEnv = envPath(), timeoutMs = AUTH_CHECK_TIMEOUT_MS) {
     const resolved = resolveBackendBin(config);
     const result = await boundedProbe(resolved.bin, ["auth", "check", "--provider", provider, "--json"], childEnv({ PATH: pathEnv }), timeoutMs, AUTH_CHECK_MAX_OUTPUT_BYTES);

package/dist/src/doctor/doctor-principles.js

@@ -1,7 +1,7 @@
 import path from "node:path";
-import { readTextOrNull } from "../files/files.js";
+import { readRegularTextOrNull } from "../files/files.js";
 import { PRINCIPLES_MAX_CHARS } from "../prompt/principles.js";
-import { okOutcome, warnOutcome } from "./outcome.js";
+import { okOutcome, warnOutcome } from "./doctor-outcome.js";
 /** Doctor check for PRINCIPLES.md's injection cap. readPrinciples caps the trimmed text at
  * PRINCIPLES_MAX_CHARS for every prompt's <principles> block, and principleBullets keeps only
  * its leading bullets; a file over the cap loses its tail (and a long header eats bullet
@@ -9,7 +9,7 @@ import { okOutcome, warnOutcome } from "./outcome.js";
  * truncate, naming the trimmed count, the cap, the marker, and the fix. Read-only, like every
  * doctor check — it never edits PRINCIPLES.md. */
 export function checkPrinciples(root) {
-    const raw = readTextOrNull(path.join(root, "PRINCIPLES.md"));
+    const raw = readRegularTextOrNull(path.join(root, "PRINCIPLES.md"));
     if (raw === null)
         return okOutcome("no PRINCIPLES.md");
     const length = raw.trim().length;

package/dist/src/doctor/doctor-project-checks.js

@@ -17,7 +17,7 @@ import { buildStaleness, isSelfHosted, readBuildInfo, STALE_INPUTS_LABEL } from
 import { dirEntryNames, statOrNull } from "../files/files.js";
 import { refSha } from "../git/git.js";
 import { STATE_DIR, eventsArchivePath, eventsLogPath } from "../paths.js";
-import { BYTES_PER_GB, diskVolumePath, sampleFreeBytes } from "../gates/disk-gate.js";
+import { BYTES_PER_GB, diskVolumePath, sampleFreeBytes } from "../gates/disk-gates.js";
 import { DAY_MS, dayKey } from "../text/datetime.js";
 import { errorMessage } from "../text/text.js";
 import { lowerMedian } from "../collections.js";
@@ -25,7 +25,7 @@ import { formatGB, shortSha } from "../text/format.js";
 import { eventLogState, readEventsSince } from "../events/event-window.js";
 import { EVENTS_KEEP } from "../events/events.js";
 import { finiteNumber } from "../files/json-object.js";
-import { agree, plural, shortSpanPhrase } from "../text/phrases.js";
+import { agree, plural, shortSpanPhrase, trailingDayMedianPhrase } from "../text/phrases.js";
 import { andMore } from "./doctor-backlog.js";
 import { KNOWN_FLAKE_WINDOW_MS, loadQuarantine, repeatedFlakeCounts } from "../review/known-flakes.js";
 import { POST_MERGE_REJECT_WINDOW_MS, postMergeChurn } from "../review/post-merge-review.js";
@@ -33,7 +33,7 @@ import { roleLabel } from "../roles/role-labels.js";
 import { quarantineWarning } from "../baseline/main-guardrails.js";
 import { readCiParity, currentCiParityState, parityIsCurrent, ciParityStalled, CI_PARITY_STALE_MS } from "../run/ci-parity.js";
 import { readQaCoverage, qaCoverageStalled, QA_COVERAGE_STALE_MS } from "../run/qa-coverage.js";
-import { failOutcome, okOutcome, warnOutcome } from "./outcome.js";
+import { failOutcome, okOutcome, warnOutcome } from "./doctor-outcome.js";
 /** .tumwater writable — absent is fine (created on first run); present, prove it by writing
  * and deleting a temp file inside. The probe leaves the dir's listing unchanged after the run.
  * The write is the property under test: only a write that fails is "not writable", so the
@@ -204,7 +204,7 @@ export function checkDurationPhrase(events) {
         return undefined;
     const median = lowerMedian(durations);
     const slowest = Math.max(...durations);
-    return `passing merge checks in the last 24h took ${shortSpanPhrase(median)} median, ${shortSpanPhrase(slowest)} slowest (${plural(durations.length, "run")})`;
+    return `passing merge checks in the last 24h took ${trailingDayMedianPhrase(median, slowest, "slowest", durations.length, "run")}`;
 }
 /** Declared project check — names what the review gate's deterministic pre-check, the
  * red-main baseline, and redeploy's green check will run, without running it: a configured
@@ -251,7 +251,7 @@ export function checkBuildCheck(root, config) {
  * once, so a routine one-off flake stays quiet. ok/warn only — never a fail — so a flaky suite
  * cannot fail a scripted doctor pre-flight (the checkStalledEntries precedent; the exit-code
  * rule is
- * outcome.ts's). */
+ * doctor-outcome.ts's). */
 export function checkFlakyChecks(root, now = Date.now()) {
     const { events } = readEventsSince(root, KNOWN_FLAKE_WINDOW_MS);
     const flapped = repeatedFlakeCounts(events);
@@ -278,7 +278,7 @@ export function checkPostMergeChurn(root) {
         return okOutcome("no post-merge rejection burst in the last day");
     return warnOutcome(`${plural(churn.count, "post-merge review rejection")} in the last day (${churn.roles
         .map((r) => `${roleLabel(r.role)} ×${r.count}`)
-        .join(", ")}) — each commit had already reached main and stays there with the reviewer's reasons; narrow \`review.afterMerge\` for the noisy role or raise the authoring bar`);
+        .join(", ")}) — each commit had already reached main and stays there with the reviewer's reasons; raise the authoring bar`);
 }
 /** The one home of the doctor's `flaky checks` sentence: names each check that flapped more than
  * once, most frequent first, with how many times it flapped — the one sentence the doctor's
@@ -321,7 +321,10 @@ running = null) {
             ? `; auto-restart is BLOCKED (${running.restartBlocked}) and will not retry until main moves or the block clears`
             : running?.restartPending
                 ? "; auto-restart is under way"
-                : "; run `npm run build` and restart `tumwater start` (auto-restart does this for a running team)";
+                : running?.waitingForCheck
+                    ? `; auto-restart waits for a commit that passes main's check — none newer than ` +
+                        `${shortSha(running.checkedHead ?? info.sha)} has yet (the main's check row says why)`
+                    : "; run `npm run build` and restart `tumwater start` (auto-restart does this for a running team)";
         return warnOutcome(`dist/ from ${sha} is stale — main has ${plural(stale.aheadCommits, "later commit")} touching ${STALE_INPUTS_LABEL}${next}`);
     }
     return okOutcome(`dist/ from ${sha}, matches main`);
@@ -396,7 +399,7 @@ export function checkQaCoverage(root, now = Date.now()) {
 /** How far back the `main diff rules` row looks — one day, the same 24 h trailing-day convention
  * every event-reading doctor row uses, so a diff-rule failure the main watch logged stays a
  * standing warn until a day passes. Owned here (the check that reads it). */
-const MAIN_RULE_FAILURE_WINDOW_MS = 24 * 60 * 60_000;
+const MAIN_RULE_FAILURE_WINDOW_MS = DAY_MS;
 /** The exact substring src/baseline/main-watch.ts's `watchRules` logs in its warning, so this
  * check matches a real rule failure and cannot drift from the wording the watch writes. */
 const MAIN_RULE_FAILURE_MARKER = "fails the diff rules";
@@ -407,9 +410,19 @@ const MAIN_RULE_FAILURE_MARKER = "fails the diff rules";
  * blind spot sits on main with only this event log to say so. Reads only the `warning` event
  * the watch already writes, so the row cannot drift from the watch's wording; the most recent
  * hit names the tip and the rule. ok/warn only — it never fails a scripted pre-flight. */
+/** The `warning` events whose message contains `marker` — the read both marker-driven
+ * project rows (checkMainDiffRules and checkDroppedPostMergeReviews) ask for, so their
+ * filter predicate cannot drift: a warning whose message is absent (an older event) is
+ * never a hit, and the marker match is a plain substring like the watch's wording.
+ * `e.type === "warning"` gates on the literal type, mirroring the warn shape warnEvent
+ * writes. Since every hit is a `warning`, `String` on its message downstream reads safely
+ * for the events this returns. */
+function warningEventsWithMarker(events, marker) {
+    return events.filter((e) => e.type === "warning" && typeof e.message === "string" && e.message.includes(marker));
+}
 export function checkMainDiffRules(root) {
     const { events } = readEventsSince(root, MAIN_RULE_FAILURE_WINDOW_MS);
-    const hits = events.filter((e) => e.type === "warning" && typeof e.message === "string" && e.message.includes(MAIN_RULE_FAILURE_MARKER));
+    const hits = warningEventsWithMarker(events, MAIN_RULE_FAILURE_MARKER);
     if (hits.length === 0)
         return okOutcome("no diff-rule failure on main in the last day");
     const latest = hits[hits.length - 1];
@@ -426,7 +439,7 @@ export function checkMainDiffRules(root) {
 const DROPPED_REVIEW_MARKER = "dropping the post-merge review of";
 /** How far back the `dropped post-merge reviews` row looks — one day, the same 24 h trailing-day
  * convention every event-reading doctor row uses. Owned here (the check that reads it). */
-const DROPPED_REVIEW_WINDOW_MS = 24 * 60 * 60_000;
+const DROPPED_REVIEW_WINDOW_MS = DAY_MS;
 /** The doctor's `dropped post-merge reviews` row: a `warning` the post-merge-review drain
  * (src/merge/merge-post-review-drain.ts) wrote when it dropped a review at
  * POST_REVIEW_FAILURE_LIMIT — after failed runs its commit stays on main unreviewed, and
@@ -439,7 +452,7 @@ const DROPPED_REVIEW_WINDOW_MS = 24 * 60 * 60_000;
  * unreviewed commit is operator signal, not a broken environment. */
 export function checkDroppedPostMergeReviews(root) {
     const { events } = readEventsSince(root, DROPPED_REVIEW_WINDOW_MS);
-    const hits = events.filter((e) => e.type === "warning" && typeof e.message === "string" && e.message.includes(DROPPED_REVIEW_MARKER));
+    const hits = warningEventsWithMarker(events, DROPPED_REVIEW_MARKER);
     if (hits.length === 0)
         return okOutcome("no post-merge review was dropped in the last day");
     const latest = hits[hits.length - 1];

package/dist/src/doctor/doctor-role-notes.js

@@ -1,7 +1,7 @@
 import { readRoleNotesOverCap } from "../status/status-role-notes.js";
 import { ROLE_NOTES_MAX_BYTES } from "../agent/role-notes-write.js";
 import { agree, plural } from "../text/phrases.js";
-import { okOutcome, warnOutcome } from "./outcome.js";
+import { okOutcome, warnOutcome } from "./doctor-outcome.js";
 /** How many oversized notes the `role notes` row names before appending "and N more", the
  * cap the other multi-role observer rows (e.g. workspaces) use so a long tail does not drown
  * the report. */

package/dist/src/doctor/doctor.js

@@ -1,23 +1,23 @@
 import { loadConfigSafe } from "../config/config.js";
 import { envPath } from "../files/files.js";
-import { orchestratorAlive, readOrchestratorInfo } from "../team/orchestrator-info.js";
+import { orchestratorAlive, readOrchestratorInfo } from "../team/team-orchestrator-info.js";
 import { systemProcessProbe } from "../process/process-table.js";
 import { checkOrphans } from "./doctor-orphans.js";
-import { checkBudget, checkErrorStreaks, checkMainRed, checkMaintenanceQuota, checkPause, checkProviderHolds, checkQuietHours, checkSubscriptionWindow } from "./doctor-holds.js";
+import { checkBudget, checkErrorStreaks, checkMainRed, checkMaintenanceQuota, checkPause, checkProviderHolds, checkQuietHours } from "./doctor-holds.js";
 import { checkRootInstall } from "./doctor-install.js";
 import { checkNotify } from "./doctor-notify.js";
 import { checkRoleNotes } from "./doctor-role-notes.js";
 import { checkLaunchServicesPorts } from "./doctor-launch-services.js";
 import { plural } from "../text/phrases.js";
 import { shortSha } from "../text/format.js";
-import { failOutcome } from "./outcome.js";
+import { failOutcome } from "./doctor-outcome.js";
 import { errorMessage } from "../text/text.js";
 import { checkBackendBinary, checkBrief, checkBootstrap, checkClaudeTranscripts, checkExecPath, checkFunes, checkGitBinary, checkConfigKeyNames, checkInit, checkOpencodeVersion, checkNodeVersion, checkPiExtensions, checkRepo, } from "./doctor-checks.js";
 import { checkPrinciples } from "./doctor-principles.js";
 import { checkBuild, checkBuildCheck, checkCiParity, checkDiskSpace, checkDroppedPostMergeReviews, checkEventLog, checkFlakyChecks, checkMainDiffRules, checkPostMergeChurn, checkQaCoverage, checkStateDir, } from "./doctor-project-checks.js";
-import { sampleFreeBytes } from "../gates/disk-gate.js";
-import { checkCheckContention, checkLeftoverRoleBranches, checkMergeLock, checkProviderConcurrency, checkProviderContention, checkTumwaterPins, checkWorkInstances, checkWorktreePool, } from "./doctor-contention-checks.js";
-import { checkFeedbackFiling, checkTierModels } from "./doctor-model-checks.js";
+import { sampleFreeBytes } from "../gates/disk-gates.js";
+import { checkCheckContention, checkLeftoverRoleBranches, checkMergeLock, checkProviderContention, checkTumwaterPins, checkWorkInstances, checkWorktreePool, } from "./doctor-contention-checks.js";
+import { checkFeedbackFiling, checkImageInput, checkTierModels } from "./doctor-model-checks.js";
 import { checkFallbackChain, checkFallbackModel } from "./doctor-fallback-checks.js";
 import { checkAnthroApiKey, checkClaudeAuth, checkClaudeVersion } from "./doctor-claude-checks.js";
 import { checkOpencode } from "./doctor-opencode-checks.js";
@@ -95,11 +95,8 @@ export async function runDoctor(root, pathEnv = envPath(), probe = systemProcess
         { name: "pause", run: () => checkPause(root) },
         { name: "quiet hours", run: () => checkQuietHours(config) },
         { name: "budget", run: () => checkBudget(root, config, (orchestratorAlive(root, info) && info?.budget) || null) },
-        { name: "claude window", run: () => checkSubscriptionWindow("claude", root, undefined, (orchestratorAlive(root, info) && info?.chain) || undefined, config) },
-        { name: "codex window", run: () => checkSubscriptionWindow("codex", root, undefined, (orchestratorAlive(root, info) && info?.chain) || undefined, config) },
         { name: "provider waits", run: () => checkProviderHolds(root) },
         { name: "maintenance allowance", run: () => checkMaintenanceQuota(root, config, orchestratorAlive(root, info)) },
-        { name: "provider concurrency", run: () => checkProviderConcurrency(config, root) },
         { name: "provider contention", run: () => checkProviderContention(root, config) },
         { name: "check contention", run: () => checkCheckContention(root, config) },
         { name: "repeated failures", run: () => checkErrorStreaks(root, config) },
@@ -107,6 +104,7 @@ export async function runDoctor(root, pathEnv = envPath(), probe = systemProcess
         { name: "over-cap model", run: () => checkFallbackModel(root, undefined, (orchestratorAlive(root, info) && info?.fallbackDemoted) || null) },
         { name: "fallback chain", run: () => checkFallbackChain(root) },
         { name: "models for each tier", run: () => checkTierModels(root) },
+        { name: "image input", run: () => checkImageInput(root) },
         { name: "claude auth", run: () => checkClaudeAuth(root, pathEnv) },
         { name: "claude api key", run: () => checkAnthroApiKey(root, undefined, pathEnv) },
         { name: "claude version", run: () => checkClaudeVersion(root, pathEnv) },
@@ -127,8 +125,7 @@ export async function runDoctor(root, pathEnv = envPath(), probe = systemProcess
         // The receive-side guards name what a running team skips, so an operator tool meant for the
         // team (a pi package, an extension file, an mcp.json server, or funes) does not vanish
         // silently. Each check returns null to omit its row: the pi row for a team with no pi seam,
-        // the funes row when funes is not on PATH, and the claude/codex window rows when that backend
-        // has no subscription account.
+        // the funes row when funes is not on PATH.
         { name: "pi extensions", run: () => checkPiExtensions(config, undefined, pathEnv) },
         { name: "funes", run: () => checkFunes(config, pathEnv) },
         { name: "state dir", run: () => checkStateDir(root) },