@bli-cockpit/cli 0.2.149 → 0.2.154

package/dist/commands/cal-calendars-write.js

@@ -0,0 +1,107 @@
+import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
+import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
+const TAG = "[cal cli]";
+const WRITE_DEADLINE_MS = 60_000;
+/** A first read of a crowded calendar can take a while. */
+const SYNC_DEADLINE_MS = 120_000;
+const URL_MAX_CHARS = 2_000;
+export async function runCalAddIcal(command, door) {
+    // The address comes from stdin and nowhere else. An interactive terminal
+    // with nothing piped in is told how, rather than left waiting on a prompt
+    // that would echo a permanent credential into the scrollback.
+    if (isInteractiveStdin(door.io)) {
+        return failAgentDoor(door, TAG, "address_required_on_stdin", 'The calendar\'s secret address is read from stdin, never from a flag. Try: printf "%s" "https://calendar.google.com/calendar/ical/…/basic.ics" | cockpit cal add-ical --name "Personal"');
+    }
+    let icalUrl;
+    try {
+        icalUrl = (await readPipedText(door.io.stdin, {
+            maxChars: URL_MAX_CHARS,
+            overflowMessage: "That is longer than any calendar address; nothing was attached.",
+        })).trim();
+    }
+    catch (error) {
+        return failAgentDoor(door, TAG, "address_unreadable", error instanceof Error ? error.message : String(error));
+    }
+    if (icalUrl === "") {
+        return failAgentDoor(door, TAG, "address_required_on_stdin", "Nothing arrived on stdin, so nothing was attached.");
+    }
+    const answer = await askAgentDoor(door, {
+        path: "/api/cal/calendars",
+        method: "POST",
+        label: "cal add-ical",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: {
+            ical_url: icalUrl,
+            name: command.name ?? null,
+            ...(command.orgVisible ? { org_visible: true } : {}),
+        },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const calendar = answer.body.calendar;
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, calendar });
+    writeLine(door.io.stdout, `Attached (${calendar?.id ?? "no id returned"}).`);
+    writeLine(door.io.stdout, `Nothing is read until a sync runs: \`cockpit cal sync ${calendar?.id ?? "<id>"}\`, or wait for the cron.`);
+    return 0;
+}
+export async function runCalShare(command, door) {
+    const orgVisible = command.orgVisible && !command.makePrivate;
+    const answer = await askAgentDoor(door, {
+        path: `/api/cal/calendars?calendar_id=${encodeURIComponent(command.subjectId ?? "")}`,
+        method: "PATCH",
+        label: "cal share",
+        timeoutMs: WRITE_DEADLINE_MS,
+        body: { org_visible: orgVisible },
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const calendar = answer.body.calendar;
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, calendar });
+    writeLine(door.io.stdout, orgVisible
+        ? `"${calendar?.name ?? command.subjectId}" is now readable by everyone at BLI. Nobody but you can change it.`
+        : `"${calendar?.name ?? command.subjectId}" is private again — only you can read it.`);
+    return 0;
+}
+export async function runCalDetach(command, door) {
+    const answer = await askAgentDoor(door, {
+        path: `/api/cal/calendars?calendar_id=${encodeURIComponent(command.subjectId ?? "")}`,
+        method: "DELETE",
+        label: "cal detach",
+        timeoutMs: WRITE_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, detached: command.subjectId });
+    writeLine(door.io.stdout, `Detached ${command.subjectId}. Its stored events went with it; the calendar itself is untouched at Google.`);
+    return 0;
+}
+export async function runCalSync(command, door) {
+    const answer = await askAgentDoor(door, {
+        path: `/api/cal/calendars/${encodeURIComponent(command.subjectId ?? "")}/sync${command.full ? "?full=1" : ""}`,
+        method: "POST",
+        label: "cal sync",
+        timeoutMs: SYNC_DEADLINE_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const run = answer.body.run;
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, run });
+    if (!run) {
+        writeLine(door.io.stdout, "Tower answered without a run. Nothing to report.");
+        return 0;
+    }
+    if (run.reason === "ok") {
+        writeLine(door.io.stdout, run.detail === "feed_unchanged"
+            ? "Nothing has changed on that calendar since the last read."
+            : `Synced: ${run.eventsAdded} new, ${run.eventsUpdated} updated, ${run.eventsDeleted} gone.`);
+        return 0;
+    }
+    // A failure names itself; the exit code says it failed.
+    writeLine(door.io.stderr, `${TAG} sync ${JSON.stringify({ reason: run.reason, detail: run.detail })}`);
+    writeLine(door.io.stdout, `That calendar did not sync: ${run.reason}${run.detail ? ` (${run.detail})` : ""}.`);
+    return 1;
+}

package/dist/commands/cal.js

@@ -21,15 +21,14 @@
  *   computed in UTC and "today" would end at 5pm in Vancouver.
  */
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
+import { runCalAddIcal, runCalDetach, runCalShare, runCalSync } from "./cal-calendars-write.js";
 import { runCalDelete } from "./cal-delete.js";
 import { runCalSyncStatus } from "./cal-sync-status.js";
-import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
+import { writeLine } from "./cli-io.js";
+import { cacheAgeLabel, readThroughCache } from "./read-cache.js";
 const TAG = "[cal cli]";
 const READ_DEADLINE_MS = 30_000;
 const WRITE_DEADLINE_MS = 60_000;
-/** A first read of a crowded calendar can take a while. */
-const SYNC_DEADLINE_MS = 120_000;
-const URL_MAX_CHARS = 2_000;
 export async function runCal(command, io) {
     const door = await openAgentDoor("cal", command, io);
     switch (command.action) {
@@ -42,15 +41,15 @@ export async function runCal(command, io) {
         case "calendars":
             return listCalendars(door);
         case "add-ical":
-            return addIcal(command, door);
+            return runCalAddIcal(command, door);
         case "create":
             return create(command, door);
         case "share":
-            return share(command, door);
+            return runCalShare(command, door);
         case "detach":
-            return detach(command, door);
+            return runCalDetach(command, door);
         case "sync":
-            return sync(command, door);
+            return runCalSync(command, door);
         case "sync-status":
             return runCalSyncStatus(command, door);
         case "delete":
@@ -92,17 +91,37 @@ async function window(command, door) {
     // `--from`/`--to` beat a named window, on any of the three verbs: somebody
     // who named two dates meant them.
     const path = command.from && command.to ? "events" : command.action;
-    const answer = await askAgentDoor(door, {
-        path: `/api/cal/${path}?${windowQuery(command).toString()}`,
+    const apiPath = `/api/cal/${path}?${windowQuery(command).toString()}`;
+    // BLI-10746: `cal today` is the one read this ticket measured; the warm
+    // route and the cache both apply to it (and only it).
+    const cached = command.action === "today";
+    const ask = () => askAgentDoor(door, {
+        path: apiPath,
         method: "GET",
         label: `cal ${command.action}`,
         timeoutMs: READ_DEADLINE_MS,
+        warmRoute: cached,
     });
+    const answer = cached
+        ? await readThroughCache({
+            io: door.io,
+            homeDir: door.homeDir,
+            deviceToken: door.deviceToken,
+            surface: "cal",
+            label: "cal today",
+            path: apiPath,
+            json: door.json,
+            ask,
+        })
+        : { ...(await ask()), fromCache: false, ageMs: null };
     if (!answer.ok)
         return failAgentDoor(door, TAG, answer.reason, answer.detail);
     const body = answer.body;
     if (door.json)
         return emitAgentDoor(door, { ok: true, ...body });
+    if (answer.fromCache) {
+        writeLine(door.io.stderr, `(${cacheAgeLabel(answer.ageMs ?? 0)}, refreshing in the background)`);
+    }
     const zone = body.window?.time_zone ?? localTimeZone();
     const events = body.events ?? [];
     if (events.length === 0) {
@@ -246,46 +265,6 @@ async function listCalendars(door) {
     writeLine(door.io.stdout, `${calendars.length} calendar(s). ids: ${calendars.map((calendar) => calendar.id).join(", ")}`);
     return 0;
 }
-async function addIcal(command, door) {
-    // The address comes from stdin and nowhere else. An interactive terminal
-    // with nothing piped in is told how, rather than left waiting on a prompt
-    // that would echo a permanent credential into the scrollback.
-    if (isInteractiveStdin(door.io)) {
-        return failAgentDoor(door, TAG, "address_required_on_stdin", 'The calendar\'s secret address is read from stdin, never from a flag. Try: printf "%s" "https://calendar.google.com/calendar/ical/…/basic.ics" | cockpit cal add-ical --name "Personal"');
-    }
-    let icalUrl;
-    try {
-        icalUrl = (await readPipedText(door.io.stdin, {
-            maxChars: URL_MAX_CHARS,
-            overflowMessage: "That is longer than any calendar address; nothing was attached.",
-        })).trim();
-    }
-    catch (error) {
-        return failAgentDoor(door, TAG, "address_unreadable", error instanceof Error ? error.message : String(error));
-    }
-    if (icalUrl === "") {
-        return failAgentDoor(door, TAG, "address_required_on_stdin", "Nothing arrived on stdin, so nothing was attached.");
-    }
-    const answer = await askAgentDoor(door, {
-        path: "/api/cal/calendars",
-        method: "POST",
-        label: "cal add-ical",
-        timeoutMs: WRITE_DEADLINE_MS,
-        body: {
-            ical_url: icalUrl,
-            name: command.name ?? null,
-            ...(command.orgVisible ? { org_visible: true } : {}),
-        },
-    });
-    if (!answer.ok)
-        return failAgentDoor(door, TAG, answer.reason, answer.detail);
-    const calendar = answer.body.calendar;
-    if (door.json)
-        return emitAgentDoor(door, { ok: true, calendar });
-    writeLine(door.io.stdout, `Attached (${calendar?.id ?? "no id returned"}).`);
-    writeLine(door.io.stdout, `Nothing is read until a sync runs: \`cockpit cal sync ${calendar?.id ?? "<id>"}\`, or wait for the cron.`);
-    return 0;
-}
 async function create(command, door) {
     const answer = await askAgentDoor(door, {
         path: "/api/cal/events",
@@ -328,64 +307,4 @@ async function create(command, door) {
         writeLine(door.io.stdout, `Invitations went to ${command.attendees.join(", ")} from Google.`);
     }
     return 0;
-}
-async function share(command, door) {
-    const orgVisible = command.orgVisible && !command.makePrivate;
-    const answer = await askAgentDoor(door, {
-        path: `/api/cal/calendars?calendar_id=${encodeURIComponent(command.subjectId ?? "")}`,
-        method: "PATCH",
-        label: "cal share",
-        timeoutMs: WRITE_DEADLINE_MS,
-        body: { org_visible: orgVisible },
-    });
-    if (!answer.ok)
-        return failAgentDoor(door, TAG, answer.reason, answer.detail);
-    const calendar = answer.body.calendar;
-    if (door.json)
-        return emitAgentDoor(door, { ok: true, calendar });
-    writeLine(door.io.stdout, orgVisible
-        ? `"${calendar?.name ?? command.subjectId}" is now readable by everyone at BLI. Nobody but you can change it.`
-        : `"${calendar?.name ?? command.subjectId}" is private again — only you can read it.`);
-    return 0;
-}
-async function detach(command, door) {
-    const answer = await askAgentDoor(door, {
-        path: `/api/cal/calendars?calendar_id=${encodeURIComponent(command.subjectId ?? "")}`,
-        method: "DELETE",
-        label: "cal detach",
-        timeoutMs: WRITE_DEADLINE_MS,
-    });
-    if (!answer.ok)
-        return failAgentDoor(door, TAG, answer.reason, answer.detail);
-    if (door.json)
-        return emitAgentDoor(door, { ok: true, detached: command.subjectId });
-    writeLine(door.io.stdout, `Detached ${command.subjectId}. Its stored events went with it; the calendar itself is untouched at Google.`);
-    return 0;
-}
-async function sync(command, door) {
-    const answer = await askAgentDoor(door, {
-        path: `/api/cal/calendars/${encodeURIComponent(command.subjectId ?? "")}/sync${command.full ? "?full=1" : ""}`,
-        method: "POST",
-        label: "cal sync",
-        timeoutMs: SYNC_DEADLINE_MS,
-    });
-    if (!answer.ok)
-        return failAgentDoor(door, TAG, answer.reason, answer.detail);
-    const run = answer.body.run;
-    if (door.json)
-        return emitAgentDoor(door, { ok: true, run });
-    if (!run) {
-        writeLine(door.io.stdout, "Tower answered without a run. Nothing to report.");
-        return 0;
-    }
-    if (run.reason === "ok") {
-        writeLine(door.io.stdout, run.detail === "feed_unchanged"
-            ? "Nothing has changed on that calendar since the last read."
-            : `Synced: ${run.eventsAdded} new, ${run.eventsUpdated} updated, ${run.eventsDeleted} gone.`);
-        return 0;
-    }
-    // A failure names itself; the exit code says it failed.
-    writeLine(door.io.stderr, `${TAG} sync ${JSON.stringify({ reason: run.reason, detail: run.detail })}`);
-    writeLine(door.io.stdout, `That calendar did not sync: ${run.reason}${run.detail ? ` (${run.detail})` : ""}.`);
-    return 1;
 }

package/dist/commands/docs.js

@@ -32,6 +32,7 @@ import { isInteractiveStdin, readPipedText, writeLine } from "./cli-io.js";
 import { readDoc } from "./docs-read.js";
 import { linkDoc, syncStatusDocs } from "./docs-notion.js";
 import { readNoteFile } from "./notes-file.js";
+import { cacheAgeLabel, readThroughCache } from "./read-cache.js";
 const TAG = "[docs cli]";
 const READ_DEADLINE_MS = 30_000;
 const WRITE_DEADLINE_MS = 60_000;
@@ -74,17 +75,32 @@ export function docsListPath(command) {
     return search.length > 0 ? `/api/docs/documents?${search}` : "/api/docs/documents";
 }
 async function listDocs(command, door) {
-    const answer = await askAgentDoor(door, {
-        path: docsListPath(command),
-        method: "GET",
+    const listPath = docsListPath(command);
+    const answer = await readThroughCache({
+        io: door.io,
+        homeDir: door.homeDir,
+        deviceToken: door.deviceToken,
+        surface: "docs",
         label: "docs list",
-        timeoutMs: READ_DEADLINE_MS,
+        path: listPath,
+        json: door.json,
+        ask: () => askAgentDoor(door, {
+            path: listPath,
+            method: "GET",
+            label: "docs list",
+            timeoutMs: READ_DEADLINE_MS,
+            // BLI-10746: route through the resident memory daemon's warm connection.
+            warmRoute: true,
+        }),
     });
     if (!answer.ok)
         return failAgentDoor(door, TAG, answer.reason, answer.detail);
     const documents = (answer.body.documents ?? []);
     if (door.json)
         return emitAgentDoor(door, { ok: true, documents });
+    if (answer.fromCache) {
+        writeLine(door.io.stderr, `(${cacheAgeLabel(answer.ageMs ?? 0)}, refreshing in the background)`);
+    }
     if (documents.length === 0) {
         writeLine(door.io.stdout, command.query ? `No document matches "${command.query}".` : "No documents.");
         return 0;

package/dist/commands/doctor-budget.js

@@ -0,0 +1,69 @@
+/**
+ * BLI-11101: `cockpit doctor --json` answers within one bounded budget.
+ *
+ * A person at a terminal gets the long defaults (a 900-second catch-up and a
+ * 600-second wait for the collection lock) with progress every 30 seconds. An
+ * agent or script calling `--json` gets one answer: on Edward's Mac the long
+ * defaults ran past 9.5 minutes behind the 15-minute scheduled sync, and a
+ * caller that times out learns nothing. So `--json` without `--lock-wait` or
+ * `--backfill-budget` runs every repair under one deadline measured from the
+ * start of the run, and a repair that does not fit says so by name instead of
+ * queueing. Passing either flag opts back into the long run.
+ */
+export const DOCTOR_JSON_BUDGET_SECONDS = 45;
+export const DEFAULT_LOCK_WAIT_SECONDS = 600;
+export const DEFAULT_BACKFILL_BUDGET_SECONDS = 900;
+/** A repair that execs a whole sync or catch-up chunk is not started with less than this left. */
+export const SLOW_FIX_MIN_SECONDS = {
+    "backfill-complete": 10,
+    "sync-fresh": 15,
+};
+/** The run deadline in epoch ms, or `null` when the caller gets the long defaults. */
+export function doctorRunDeadline(command, startedMs) {
+    if (!command.json)
+        return null;
+    if (command.lockWaitSeconds !== undefined || command.backfillBudgetSeconds !== undefined)
+        return null;
+    return startedMs + DOCTOR_JSON_BUDGET_SECONDS * 1000;
+}
+function remainingSeconds(context, now) {
+    if (context.deadlineMs === undefined || context.deadlineMs === null)
+        return null;
+    return Math.max(0, (context.deadlineMs - now) / 1000);
+}
+/** How long a repair may wait for the collection lock. */
+export function doctorLockWaitSeconds(context, now = Date.now()) {
+    if (context.command.lockWaitSeconds !== undefined)
+        return context.command.lockWaitSeconds;
+    const remaining = remainingSeconds(context, now);
+    return remaining === null ? DEFAULT_LOCK_WAIT_SECONDS : Math.min(DEFAULT_LOCK_WAIT_SECONDS, remaining);
+}
+/** How long the catch-up repair may run, lock waiting included. */
+export function doctorBackfillBudgetSeconds(context, now = Date.now()) {
+    if (context.command.backfillBudgetSeconds !== undefined)
+        return context.command.backfillBudgetSeconds;
+    const remaining = remainingSeconds(context, now);
+    return remaining === null ? DEFAULT_BACKFILL_BUDGET_SECONDS : Math.min(DEFAULT_BACKFILL_BUDGET_SECONDS, remaining);
+}
+/**
+ * The row a slow repair returns instead of starting when the run budget cannot
+ * hold it; `null` means go ahead. Logged either way the budget decides.
+ */
+export function budgetSpentRow(context, row, now = Date.now()) {
+    const floor = SLOW_FIX_MIN_SECONDS[row.id];
+    const remaining = remainingSeconds(context, now);
+    if (floor === undefined || remaining === null)
+        return null;
+    if (remaining >= floor) {
+        console.error("[doctor] repair fits the json budget", JSON.stringify({ row: row.id, remaining_seconds: Math.floor(remaining), floor_seconds: floor }));
+        return null;
+    }
+    console.error("[doctor] repair skipped, json budget spent", JSON.stringify({ reason: "doctor_budget_spent", row: row.id, remaining_seconds: Math.floor(remaining), floor_seconds: floor, budget_seconds: DOCTOR_JSON_BUDGET_SECONDS }));
+    return {
+        ...row,
+        status: "needs_fix",
+        code: "doctor_budget_spent",
+        nextAction: "cockpit doctor",
+        message: `\`cockpit doctor --json\` answers within ${DOCTOR_JSON_BUDGET_SECONDS}s and this repair needs at least ${floor}s; ${Math.floor(remaining)}s were left (was: ${row.code}). Run \`cockpit doctor\` to let it finish.`,
+    };
+}

package/dist/commands/doctor-lock-wait.js

@@ -1,12 +1,13 @@
 import { inspectBackfillLock } from "../backfill-lock.js";
 import { getCollectorRuntimePaths } from "../local-state.js";
 import { inspectSyncLock } from "../sync-lock.js";
-const BUSY = new Set(["sync_already_running", "backfill_already_running", "live_sync_paused_during_backfill"]);
+import { doctorLockWaitSeconds } from "./doctor-budget.js";
+const BUSY = new Set(["sync_already_running", "sync_lock_held", "backfill_already_running", "live_sync_paused_during_backfill"]);
 /** Retry the operation itself: its existing exclusive lock acquisition owns the
  * handoff. Merely observing a free lock never grants permission to collect. */
 export async function withDoctorLockWait(context, run, timing = { now: () => Date.now(), sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)) }) {
     const started = timing.now();
-    const limit = (context.command.lockWaitSeconds ?? 600) * 1000;
+    const limit = doctorLockWaitSeconds(context) * 1000;
     let nextProgress = 0;
     let row = await run();
     while (BUSY.has(row.code)) {
@@ -27,7 +28,15 @@ export async function withDoctorLockWait(context, run, timing = { now: () => Dat
                 if (result.code === 0 && result.stdout.trim())
                     name = result.stdout.trim().split("\n")[0] ?? name;
             }
-            return { ...row, status: "needs_fix", code: "lock_wait_timeout", nextAction: "cockpit doctor --lock-wait 600", message: `Waited ${Math.round(elapsed / 1000)}s for the collection lock; owner pid ${pid ?? "unknown"}, ${name}. Run \`cockpit doctor --lock-wait 600\`.` };
+            // BLI-11101: the scheduled sync holding the lock is not a fault; it is
+            // doing the upload this row would prove. Say so by name.
+            const syncOwns = !backfill.held && Boolean(sync?.held);
+            const code = syncOwns ? "sync_running" : "lock_wait_timeout";
+            console.error(`[doctor] ${row.id} lock wait ended`, JSON.stringify({ reason: code, owner_pid: pid ?? null, waited_seconds: Math.round(elapsed / 1000), limit_seconds: Math.round(limit / 1000) }));
+            const message = syncOwns
+                ? `The background sync (pid ${pid ?? "unknown"}, ${name}) is running and holds the collection lock; waited ${Math.round(elapsed / 1000)}s. Run \`cockpit doctor\` after it finishes, or \`cockpit doctor --lock-wait 600\` to wait for it.`
+                : `Waited ${Math.round(elapsed / 1000)}s for the collection lock; owner pid ${pid ?? "unknown"}, ${name}. Run \`cockpit doctor --lock-wait 600\`.`;
+            return { ...row, status: "needs_fix", code, nextAction: "cockpit doctor --lock-wait 600", message };
         }
         if (elapsed >= nextProgress) {
             const seconds = Math.floor(elapsed / 1000);

package/dist/commands/doctor-pipeline-verdicts.js

@@ -43,6 +43,8 @@ const COLLECTION_BUSY_REASONS = new Set([
     "live_sync_paused_during_backfill",
     // `cockpit backfill` stood aside for another backfill.
     "backfill_already_running",
+    // `cockpit backfill` waited for the collection lock and gave up (BLI-11091).
+    "sync_lock_held",
 ]);
 export function isCollectionBusyReason(reason) {
     return typeof reason === "string" && COLLECTION_BUSY_REASONS.has(reason);

package/dist/commands/doctor-pipeline.js

@@ -1,4 +1,5 @@
 import { withDoctorLockWait } from "./doctor-lock-wait.js";
+import { doctorBackfillBudgetSeconds, doctorLockWaitSeconds } from "./doctor-budget.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { inspectBackfillLock } from "../backfill-lock.js";
@@ -48,7 +49,7 @@ export async function checkBackfillState(context) {
 }
 export async function fixBackfillState(context) {
     const started = Date.now();
-    const deadline = started + (context.command.backfillBudgetSeconds ?? 900) * 1000;
+    const deadline = started + doctorBackfillBudgetSeconds(context, started) * 1000;
     let caughtUp = 0;
     let chunks = 0;
     let live = null;
@@ -79,7 +80,7 @@ export async function fixBackfillState(context) {
             // Every chunk reacquires the collector's locks. Bound lock waiting by
             // the overall budget too; never abandon an in-flight cursor write.
             const chunkContext = { ...context, command: { ...context.command,
-                    lockWaitSeconds: Math.min(context.command.lockWaitSeconds ?? 600, (deadline - Date.now()) / 1000),
+                    lockWaitSeconds: Math.min(doctorLockWaitSeconds(context), (deadline - Date.now()) / 1000),
                 } };
             const row = await withDoctorLockWait(chunkContext, async () => {
                 if (Date.now() >= deadline)
@@ -91,6 +92,8 @@ export async function fixBackfillState(context) {
                     homeDir: context.command.homeDir, repoRoot: context.command.repoRoot,
                     all: true, dryRun: false, yes: true, json: true,
                     deadlineMs: deadline,
+                    // Doctor's own `withDoctorLockWait` owns the waiting (BLI-11091).
+                    syncLockWaitMs: 0,
                     onProgress: (progress) => { live = progress; },
                 }, capture.io);
                 const parsed = parseDoctorBackfillJson(capture.stdout());

package/dist/commands/doctor.js

@@ -5,6 +5,7 @@ import { withStage } from "../crash-guard.js";
 import { checkSingleInstallState, readRootsCoverWork, fixAuthState, fixRootState, readAuthState, readRootState, } from "./doctor-access.js";
 import { backfillCompletionStepState, backfillFixVerdict, checkBackfillState, checkDiskState, checkGcState, checkSyncState, fixBackfillState, fixDiskState, fixGcState, fixSyncState, syncBacklogDrainingVerdict, syncStandAsideVerdict, } from "./doctor-pipeline.js";
 import { checkMcpAnswersState } from "./doctor-mcp.js";
+import { budgetSpentRow, doctorRunDeadline, DOCTOR_JSON_BUDGET_SECONDS } from "./doctor-budget.js";
 import { checkMemoryDaemonState } from "./doctor-memory-daemon.js";
 import { checkDoctorAgentRules, fixDoctorAgentRules, checkAutostartState, checkMemoryState, fixAutostartState, fixMemoryState, } from "./doctor-registration.js";
 import { dryRunPreview, isInteractiveDoctorFix, maybeReportDoctorEvents, writeDoctorOutput, doctorNeedsPerson, } from "./doctor-report.js";
@@ -15,12 +16,19 @@ export async function runDoctor(command, io, hooks, overrides = {}) {
     return runDoctorWithDeps(command, io, deps);
 }
 export async function runDoctorWithDeps(command, io, deps) {
-    const context = { command, io, deps };
+    const runStarted = Date.now();
+    const deadlineMs = doctorRunDeadline(command, runStarted);
+    const context = { command, io, deps, deadlineMs };
+    console.error("[doctor] run started", JSON.stringify({ json: command.json, check_only: Boolean(command.dryRun || command.checkOnly), budget_seconds: deadlineMs === null ? null : DOCTOR_JSON_BUDGET_SECONDS }));
     const rows = [];
     const repairs = [];
     const diagnoseOnly = command.dryRun || command.checkOnly;
     const diagnosed = new Map();
+    // BLI-11101: every row says how long it took, so the next slow run names
+    // the row without a profiler. A killed run still leaves every finished row.
+    const checkMs = new Map();
     for (const invariant of doctorInvariants()) {
+        const started = Date.now();
         try {
             diagnosed.set(invariant.id, await withStage(`doctor:check:${invariant.id}`, () => invariant.check(context)));
         }
@@ -28,16 +36,24 @@ export async function runDoctorWithDeps(command, io, deps) {
             console.error(`[doctor] ${invariant.id} diagnosis_failed`, JSON.stringify({ reason: "check_threw", ...describeError(error) }));
             diagnosed.set(invariant.id, { id: invariant.id, status: "fail", code: "check_threw", message: "Run `cockpit doctor` to retry this check." });
         }
+        checkMs.set(invariant.id, Date.now() - started);
+        console.error("[doctor] row checked", JSON.stringify({ row: invariant.id, elapsed_ms: checkMs.get(invariant.id), verdict: diagnosed.get(invariant.id)?.status, reason: diagnosed.get(invariant.id)?.code }));
     }
     for (const invariant of doctorInvariants()) {
         let row;
+        const fixStarted = Date.now();
         try {
             row = diagnosed.get(invariant.id);
             const needsCollection = ["backfill-complete", "sync-fresh"].includes(invariant.id);
             const prerequisitesReady = !needsCollection || rows.filter((prior) => prior.id === "authed" || prior.id === "roots-ok").every((prior) => prior.status === "ok");
             const canFix = !diagnoseOnly && prerequisitesReady && invariant.fix &&
                 (!invariant.requiresInteractiveFix || isInteractiveDoctorFix(context) || Boolean(command.collectionRoots?.length));
-            if (row.status !== "ok" && row.status !== "skipped" && canFix && invariant.fix) {
+            const spent = row.status !== "ok" && row.status !== "skipped" && canFix ? budgetSpentRow(context, row) : null;
+            if (spent) {
+                row = spent;
+                repairs.push({ step: invariant.id, outcome: "needs_person", reason: row.code });
+            }
+            else if (row.status !== "ok" && row.status !== "skipped" && canFix && invariant.fix) {
                 row = await withStage(`doctor:fix:${invariant.id}`, () => invariant.fix(context, row));
                 repairs.push({ step: invariant.id, outcome: row.status === "ok" ? "repaired" : "needs_person", reason: row.code });
                 // The replacement process owns the one final receipt, including JSON.
@@ -57,6 +73,9 @@ export async function runDoctorWithDeps(command, io, deps) {
             repairs.push({ step: invariant.id, outcome: "needs_person", reason: row.code });
         }
         console.error(`[doctor] ${invariant.id} ${row.status}`, JSON.stringify({ reason: row.code, repaired: row.fixed ?? false }));
+        const fixMs = Date.now() - fixStarted;
+        const rowCheckMs = checkMs.get(invariant.id) ?? 0;
+        console.error("[doctor] row done", JSON.stringify({ row: invariant.id, elapsed_ms: rowCheckMs + fixMs, check_ms: rowCheckMs, fix_ms: fixMs, verdict: row.status, reason: row.code }));
         rows.push(row);
     }
     // Re-read host state after repairs. Sync is proven by its upload receipts;
@@ -68,10 +87,11 @@ export async function runDoctorWithDeps(command, io, deps) {
             const index = rows.findIndex((row) => row.id === invariant.id);
             if (rows[index]?.status === "fail")
                 continue;
+            const verifyStarted = Date.now();
             try {
                 const checked = await invariant.check(context);
                 rows[index] = { ...checked, fixed: rows[index]?.fixed && checked.status === "ok" };
-                console.error(`[doctor] ${invariant.id} verified`, JSON.stringify({ reason: checked.code, status: checked.status }));
+                console.error(`[doctor] ${invariant.id} verified`, JSON.stringify({ reason: checked.code, status: checked.status, elapsed_ms: Date.now() - verifyStarted }));
                 if (checked.status === "needs_fix" || checked.status === "fail") {
                     const repair = repairs.find((entry) => entry.step === invariant.id);
                     if (repair) {
@@ -102,8 +122,10 @@ export async function runDoctorWithDeps(command, io, deps) {
             rows.push({ id: "memory-registered", status: "needs_fix", code: "receipt_read_threw", message: "Run `cockpit doctor` to read the final setup receipt." });
         }
     }
+    const needsPerson = doctorNeedsPerson(rows, receipt).length;
+    console.error("[doctor] run done", JSON.stringify({ elapsed_ms: Date.now() - runStarted, rows: rows.length, needs_person: needsPerson, check_only: Boolean(diagnoseOnly) }));
     writeDoctorOutput(command, io, rows, receipt, repairs);
-    return doctorNeedsPerson(rows, receipt).length === 0 ? 0 : 1;
+    return needsPerson === 0 ? 0 : 1;
 }
 function doctorInvariants() {
     return [

package/dist/commands/issue-directory.js

@@ -22,6 +22,13 @@ async function fetchTeamDirectory(door) {
         method: "GET",
         label: "issue assignee directory",
         timeoutMs: TEAM_DIRECTORY_TIMEOUT_MS,
+        // BLI-10746: this runs IN PARALLEL with `work list`'s own issues fetch
+        // (BLI-10579) — measured live, an un-warmed directory call was the
+        // reason `work list`'s end-to-end time did not show the daemon's own
+        // ~300ms handshake saving (its own fetch dropped from 749ms cold to
+        // ~420-500ms warm; the command's total didn't, because this parallel
+        // call was still paying a cold connection every time).
+        warmRoute: true,
     });
     if (!answer.ok)
         return { ok: false, people: [], reason: answer.reason };

package/dist/commands/issue.js

@@ -28,6 +28,7 @@
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { writeLine } from "./cli-io.js";
 import { assigneeLabel, beginAssigneeDirectoryFetch, finishAssigneeDirectory, withAssigneeIdentity } from "./issue-directory.js";
+import { cacheAgeLabel, readThroughCache } from "./read-cache.js";
 import { showIssue } from "./issue-show.js";
 import { READ_DEADLINE_MS, TAG, resolveProjectId, sizeForEstimate, withSizeLabel, } from "./issue-contracts.js";
 import { commentIssue, createIssue, moveIssue, updateIssue } from "./issue-write.js";
@@ -111,11 +112,26 @@ async function listIssues(command, door) {
     // instead of waiting for that answer first (measured ~580ms of the ~580ms
     // `work list` p50 was exactly this serial second call).
     const directoryFetch = beginAssigneeDirectoryFetch(door);
-    const answer = await askAgentDoor(door, {
-        path: `/api/work/issues${suffix ? `?${suffix}` : ""}`,
-        method: "GET",
+    const listPath = `/api/work/issues${suffix ? `?${suffix}` : ""}`;
+    const answer = await readThroughCache({
+        io: door.io,
+        homeDir: door.homeDir,
+        deviceToken: door.deviceToken,
+        surface: "work",
         label: "issue list",
-        timeoutMs: READ_DEADLINE_MS,
+        path: listPath,
+        json: door.json,
+        ask: () => askAgentDoor(door, {
+            path: listPath,
+            method: "GET",
+            label: "issue list",
+            timeoutMs: READ_DEADLINE_MS,
+            // BLI-10746: `work list` was the slowest of the six reads measured
+            // from Vietnam (1,682 ms p50) — route it through the resident memory
+            // daemon's warm connection so this command skips a fresh TCP+TLS
+            // handshake.
+            warmRoute: true,
+        }),
     });
     if (!answer.ok) {
         // Not awaited for its own sake — `finishAssigneeDirectory` always awaits
@@ -123,6 +139,9 @@ async function listIssues(command, door) {
         await finishAssigneeDirectory(door, directoryFetch, []);
         return failAgentDoor(door, TAG, answer.reason, answer.detail);
     }
+    if (answer.fromCache && !door.json) {
+        writeLine(door.io.stderr, `(${cacheAgeLabel(answer.ageMs ?? 0)}, refreshing in the background)`);
+    }
     const body = answer.body;
     const issues = body.issues ?? [];
     // BLI-10447: the gaps go to stderr in both modes, so `--json` stdout stays one object.