@bli-cockpit/cli 0.2.236 → 0.2.238

package/dist/commands/brief-edit.js

@@ -41,54 +41,20 @@ export async function runBriefEdit(command, io) {
     const log = (line) => writeLine(io.stderr, line);
     const startedAt = Date.now();
     // ── 1. The page, as a document ────────────────────────────────────────────
-    const read = await towerJsonRequest({
-        dashboardUrl,
-        path: `/api/jarvis/brief${briefQuery(command)}`,
-        deviceToken: session.device_token,
-        fetch: io.fetch,
-        method: "GET",
-        label: "brief:edit",
-        timeoutMs: REQUEST_DEADLINE_MS,
-        log,
-    });
-    if (!read.ok)
-        return fail(command, io, read.reason, read.detail);
-    const brief = read.body;
-    const personId = brief.page?.personId;
-    const original = brief.editable?.document;
-    const lines = (brief.editable?.lines ?? []).filter((line) => typeof line.claimId === "string" && typeof line.text === "string");
-    if (!brief.ok || !personId || typeof original !== "string" || lines.length === 0) {
-        return fail(command, io, brief.error ?? "no_page", brief.reply ?? "There is no page to edit.");
-    }
+    const page = await readEditablePage(command, io, session, dashboardUrl, log);
+    if (!page.ok)
+        return fail(command, io, page.reason, page.detail);
     // ── 2. Their editor, or their stdin ───────────────────────────────────────
-    const edited = await collectEditedDocument(io, original, log);
+    const edited = await collectEditedDocument(io, page.original, log);
     if (!edited.ok)
         return fail(command, io, edited.reason, edited.detail);
     // ── 3. The diff, here ─────────────────────────────────────────────────────
-    const diff = diffDocument(lines, edited.text);
-    if (diff.invented.length > 0) {
-        return fail(command, io, "invented_claim", `The page has no line called “${diff.invented[0]}”. Change the words after an id, never the id ` +
-            "itself — nothing has been sent to Tower.");
-    }
-    if (diff.deleted.length > 0) {
-        return fail(command, io, "deleted_claim", `The line [${diff.deleted[0]}] is missing from what you saved. Put it back — a line you delete ` +
-            "reads as no opinion at all, not as a sentence to remove, and Tower cannot tell those apart. " +
-            "Nothing has been sent.");
-    }
-    if (diff.edits.length === 0) {
-        const styled = colorEnabled(io);
-        if (command.json) {
-            writeLine(io.stdout, JSON.stringify({ ok: true, saved: 0, reason: "nothing_changed" }));
-        }
-        else {
-            writeLine(io.stdout, dim("Nothing changed, so nothing was written.", styled));
-        }
-        writeLine(io.stderr, `[brief edit] nothing changed ${JSON.stringify({
-            lines: lines.length,
-            elapsed_ms: Date.now() - startedAt,
-        })}`);
-        return 0;
-    }
+    const diff = diffDocument(page.lines, edited.text);
+    const refusal = refuseBadDiff(diff);
+    if (refusal)
+        return fail(command, io, refusal.reason, refusal.detail);
+    if (diff.edits.length === 0)
+        return reportNothingChanged(command, io, page.lines.length, startedAt);
     // ── 4. The same door the browser's save posts to ──────────────────────────
     const saved = await towerJsonRequest({
         dashboardUrl,
@@ -99,8 +65,8 @@ export async function runBriefEdit(command, io) {
         timeoutMs: REQUEST_DEADLINE_MS,
         log,
         body: {
-            personId,
-            pageId: brief.page?.pageId ?? null,
+            personId: page.personId,
+            pageId: page.pageId,
             edits: diff.edits,
             ...(command.reason ? { reason: command.reason } : {}),
         },
@@ -122,6 +88,65 @@ export async function runBriefEdit(command, io) {
     })}`);
     return 0;
 }
+async function readEditablePage(command, io, session, dashboardUrl, log) {
+    const read = await towerJsonRequest({
+        dashboardUrl,
+        path: `/api/jarvis/brief${briefQuery(command)}`,
+        deviceToken: session.device_token,
+        fetch: io.fetch,
+        method: "GET",
+        label: "brief:edit",
+        timeoutMs: REQUEST_DEADLINE_MS,
+        log,
+    });
+    if (!read.ok)
+        return { ok: false, reason: read.reason, detail: read.detail };
+    const brief = read.body;
+    const personId = brief.page?.personId;
+    const original = brief.editable?.document;
+    const lines = (brief.editable?.lines ?? []).filter((line) => typeof line.claimId === "string" && typeof line.text === "string");
+    if (!brief.ok || !personId || typeof original !== "string" || lines.length === 0) {
+        return {
+            ok: false,
+            reason: brief.error ?? "no_page",
+            detail: brief.reply ?? "There is no page to edit.",
+        };
+    }
+    return { ok: true, personId, pageId: brief.page?.pageId ?? null, original, lines };
+}
+/** The refusal for a diff that invented or deleted a claim id, or null when the diff may be sent. */
+function refuseBadDiff(diff) {
+    if (diff.invented.length > 0) {
+        return {
+            reason: "invented_claim",
+            detail: `The page has no line called “${diff.invented[0]}”. Change the words after an id, never the id ` +
+                "itself — nothing has been sent to Tower.",
+        };
+    }
+    if (diff.deleted.length > 0) {
+        return {
+            reason: "deleted_claim",
+            detail: `The line [${diff.deleted[0]}] is missing from what you saved. Put it back — a line you delete ` +
+                "reads as no opinion at all, not as a sentence to remove, and Tower cannot tell those apart. " +
+                "Nothing has been sent.",
+        };
+    }
+    return null;
+}
+function reportNothingChanged(command, io, lineCount, startedAt) {
+    const styled = colorEnabled(io);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: true, saved: 0, reason: "nothing_changed" }));
+    }
+    else {
+        writeLine(io.stdout, dim("Nothing changed, so nothing was written.", styled));
+    }
+    writeLine(io.stderr, `[brief edit] nothing changed ${JSON.stringify({
+        lines: lineCount,
+        elapsed_ms: Date.now() - startedAt,
+    })}`);
+    return 0;
+}
 function briefQuery(command) {
     const params = new URLSearchParams({ editable: "1" });
     if (command.subject)

package/dist/commands/cal-detail.js

@@ -0,0 +1,35 @@
+import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
+import { writeLine } from "./cli-io.js";
+export async function runCalDetail(command, door) {
+    const query = new URLSearchParams({ tz: command.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone });
+    if (command.occurrenceStart)
+        query.set("occurrence_start", command.occurrenceStart);
+    const path = `/api/cal/events/${encodeURIComponent(command.subjectId)}${command.action === "export" ? "/export" : ""}?${query}`;
+    const answer = await askAgentDoor(door, { method: "GET", path, label: `cal ${command.action}`, timeoutMs: 30000 });
+    if (!answer.ok)
+        return failAgentDoor(door, "[cal cli]", answer.reason, answer.detail);
+    if (door.json)
+        return emitAgentDoor(door, answer.body);
+    if (command.action === "export") {
+        writeLine(door.io.stdout, String(answer.body.content));
+        return 0;
+    }
+    const event = answer.body.event;
+    const zone = command.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const date = new Date(event.starts_at).toLocaleDateString("en-CA", { timeZone: event.all_day ? "UTC" : zone });
+    const clock = (value) => new Intl.DateTimeFormat("en-GB", { timeZone: zone, hour: "2-digit", minute: "2-digit", hourCycle: "h23" }).format(new Date(value));
+    writeLine(door.io.stdout, `${event.title} · ${date} · ${event.all_day ? "All day" : `${clock(event.starts_at)}–${clock(event.ends_at)}`} · ${zone} · ${event.calendar_name}`);
+    writeLine(door.io.stdout, event.recurrence_summary);
+    if (event.recurrence_coverage_note)
+        writeLine(door.io.stdout, event.recurrence_coverage_note);
+    writeLine(door.io.stdout, `Organizer: ${event.organizer_detail?.name ?? "Unknown"}`);
+    for (const guest of event.guests)
+        writeLine(door.io.stdout, `${guest.name} · ${guest.rsvp}${guest.optional ? " · Optional" : ""}`);
+    if (event.meeting_url)
+        writeLine(door.io.stdout, `Join: ${event.meeting_url}`);
+    if (event.location)
+        writeLine(door.io.stdout, `Location: ${event.location}`);
+    if (event.capabilities.reason)
+        writeLine(door.io.stdout, event.capabilities.reason);
+    return 0;
+}

package/dist/commands/cal-overlay.js

@@ -0,0 +1,106 @@
+import { askAgentDoor, emitAgentDoor, failAgentDoor } from "./agent-door.js";
+import { readPipedText, isInteractiveStdin, writeLine } from "./cli-io.js";
+const FAIL_TAG = "[cal cli]";
+const REQUEST_TIMEOUT_MS = 30000;
+export async function runCalOverlay(command, door) {
+    if (command.action === "calendar-change")
+        return changeCalendarPreferences(command, door);
+    return showConflicts(command, door);
+}
+async function changeCalendarPreferences(command, door) {
+    let body = command.color ? { color_override: command.color === "provider" ? null : command.color } : {};
+    if (!command.color && !isInteractiveStdin(door.io)) {
+        const piped = await readPipedPreferences(door);
+        if (piped === null) {
+            return failAgentDoor(door, FAIL_TAG, "invalid_body", "Pipe JSON preferences or use --color '#4285f4' (provider resets).");
+        }
+        body = piped;
+    }
+    if (!Object.keys(body).length) {
+        return failAgentDoor(door, FAIL_TAG, "invalid_body", "Use --color '#4285f4', --color provider, or pipe JSON with color_override/selected.");
+    }
+    const answer = await askAgentDoor(door, {
+        method: "PATCH",
+        path: `/api/cal/calendars/${encodeURIComponent(command.subjectId)}`,
+        body,
+        label: "cal calendar-change",
+        timeoutMs: REQUEST_TIMEOUT_MS,
+    });
+    if (!answer.ok)
+        return failAgentDoor(door, FAIL_TAG, answer.reason, answer.detail);
+    if (door.json)
+        return emitAgentDoor(door, answer.body);
+    writeLine(door.io.stdout, "Calendar preferences saved. Provider sync preserves your colour override.");
+    return 0;
+}
+/** Piped JSON preferences, or null when the pipe is unreadable or not a JSON object. */
+async function readPipedPreferences(door) {
+    try {
+        const parsed = JSON.parse(await readPipedText(door.io.stdin, { maxChars: 4000, overflowMessage: "Preferences are too large." }));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+async function showConflicts(command, door) {
+    const query = new URLSearchParams({ tz: command.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone });
+    if (command.from)
+        query.set("from", command.from);
+    if (command.to)
+        query.set("to", command.to);
+    if (command.offset !== undefined)
+        query.set("offset", String(command.offset));
+    if (command.includeDeselected)
+        query.set("all", "true");
+    const answer = await askAgentDoor(door, { method: "GET", path: `/api/cal/conflicts?${query}`, label: "cal conflicts", timeoutMs: REQUEST_TIMEOUT_MS });
+    if (!answer.ok)
+        return failAgentDoor(door, FAIL_TAG, answer.reason, answer.detail);
+    if (door.json)
+        return emitAgentDoor(door, answer.body);
+    const result = answer.body;
+    const zone = result.window?.time_zone ?? command.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+    writeConflictGroups(door, result, zone);
+    writeCoverage(door, result);
+    return 0;
+}
+function writeConflictGroups(door, result, zone) {
+    writeLine(door.io.stdout, `${result.groups.length} double-bookings · own calendars`);
+    for (const group of result.groups) {
+        const parts = new Intl.DateTimeFormat("en-GB", { timeZone: zone, weekday: "short", day: "numeric", month: "short", hour: "2-digit", minute: "2-digit", hourCycle: "h23" }).formatToParts(new Date(group.from));
+        const part = (name) => parts.find(item => item.type === name)?.value;
+        const meetingTitles = group.meetings.map(meeting => `${meeting.event.title} · ${meeting.event.calendar_name}`).join(" / ");
+        writeLine(door.io.stdout, `${part("weekday")} ${part("day")} ${part("month")} ${part("hour")}:${part("minute")}: ${meetingTitles}`);
+    }
+}
+function describeSyncAge(checked) {
+    const oldest = Math.min(...checked.map(calendar => calendar.lastSyncAt ? Date.parse(calendar.lastSyncAt) : NaN));
+    const minutes = Math.max(0, Math.floor((Date.now() - oldest) / 60000));
+    if (!checked.length)
+        return "none checked";
+    if (!Number.isFinite(oldest))
+        return "sync age unknown";
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes} min ago`;
+    if (minutes < 1440)
+        return `${Math.floor(minutes / 60)} h ago`;
+    return `${Math.floor(minutes / 1440)} days ago`;
+}
+function writeCoverage(door, result) {
+    const checked = result.coverage.calendars.filter(calendar => calendar.checked);
+    writeLine(door.io.stdout, `Checked ${checked.length} calendar${checked.length === 1 ? "" : "s"} · ${describeSyncAge(checked)}`);
+    for (const calendar of result.coverage.calendars.filter(calendar => calendar.hidden || !calendar.checked)) {
+        writeLine(door.io.stdout, `${calendar.name}: ${calendar.hidden ? "hidden; " : ""}${calendar.checked ? "included by request" : `not checked (${(calendar.excludedReason ?? "unavailable").replaceAll("_", " ")})`}`);
+    }
+    for (const account of result.coverage.accounts ?? []) {
+        if (!account.calendars)
+            writeLine(door.io.stdout, `${account.label}: no discovered calendars (${account.status.replaceAll("_", " ")})`);
+    }
+    if (result.coverage.incomplete || result.coverage.truncated || result.coverage.notes.length) {
+        writeLine(door.io.stdout, "Incomplete window. This check cannot confirm free time.");
+    }
+}

package/dist/commands/cal.js

@@ -22,6 +22,8 @@
  */
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor, } from "./agent-door.js";
 import { runCalAddIcal, runCalDetach, runCalShare, runCalSync } from "./cal-calendars-write.js";
+import { runCalDetail } from "./cal-detail.js";
+import { runCalOverlay } from "./cal-overlay.js";
 import { runCalDelete } from "./cal-delete.js";
 import { runCalSyncStatus } from "./cal-sync-status.js";
 import { writeLine } from "./cli-io.js";
@@ -32,6 +34,12 @@ const WRITE_DEADLINE_MS = 60_000;
 export async function runCal(command, io) {
     const door = await openAgentDoor("cal", command, io);
     switch (command.action) {
+        case "event":
+        case "export":
+            return runCalDetail(command, door);
+        case "conflicts":
+        case "calendar-change":
+            return runCalOverlay(command, door);
         case "today":
         case "week":
         case "next":
@@ -91,6 +99,19 @@ function windowQuery(command) {
     return query;
 }
 async function window(command, door) {
+    const answer = await askForWindow(command, door);
+    if (!answer.ok)
+        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+    const body = answer.body;
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, ...body, ...cacheCoverage(answer) });
+    if (answer.fromCache) {
+        writeLine(door.io.stderr, `(${cacheAgeLabel(answer.ageMs ?? 0)}, refreshing in the background)`);
+    }
+    writeWindow(body, door);
+    return 0;
+}
+async function askForWindow(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;
@@ -105,33 +126,27 @@ async function window(command, door) {
         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, ...cacheCoverage(answer) });
-    if (answer.fromCache) {
-        writeLine(door.io.stderr, `(${cacheAgeLabel(answer.ageMs ?? 0)}, refreshing in the background)`);
-    }
+    if (!cached)
+        return { ...(await ask()), fromCache: false, ageMs: null };
+    return readThroughCache({
+        io: door.io,
+        homeDir: door.homeDir,
+        deviceToken: door.deviceToken,
+        surface: "cal",
+        label: "cal today",
+        path: apiPath,
+        json: door.json,
+        ask,
+    });
+}
+function writeWindow(body, door) {
     const zone = body.window?.time_zone ?? localTimeZone();
     const events = body.events ?? [];
     if (events.length === 0) {
         writeLine(door.io.stdout, (body.calendars ?? []).length === 0
             ? "No calendars attached yet. `cockpit cal add-ical` for a personal one, or connect Google in the browser."
             : `Nothing on ${describeWindow(body, zone)}.`);
-        return 0;
+        return;
     }
     writeLine(door.io.stdout, describeWindow(body, zone));
     writeLine(door.io.stdout, "");
@@ -152,7 +167,6 @@ async function window(command, door) {
     for (const note of body.notes ?? []) {
         writeLine(door.io.stdout, `Note: "${note.title}" repeats on a rule Tower does not expand (${note.detail.join(", ")}), so only its first occurrence is shown.`);
     }
-    return 0;
 }
 function describeWindow(body, zone) {
     if (!body.window)
@@ -293,6 +307,10 @@ async function create(command, door) {
     const event = answer.body.event;
     if (door.json)
         return emitAgentDoor(door, { ok: true, event });
+    writeCreated(command, door, event);
+    return 0;
+}
+function writeCreated(command, door, event) {
     const zone = command.timeZone ?? localTimeZone();
     writeLine(door.io.stdout, `Created "${event?.title ?? command.title}" on ${event ? `${dayLabel(event.starts_at, zone)} ${clock(event.starts_at, zone)}` : "that calendar"}.`);
     if (event?.event_id) {
@@ -313,7 +331,6 @@ async function create(command, door) {
     if (command.attendees.length > 0) {
         writeLine(door.io.stdout, `Invitations went to ${command.attendees.join(", ")} from Google.`);
     }
-    return 0;
 }
 function meetingLinkText(event) {
     const label = { meet: "Meet link", zoom: "Zoom link", teams: "Teams link" }[event.meeting_kind ?? ""] ?? "Meeting link";

package/dist/commands/clean.js

@@ -83,11 +83,14 @@ export async function runClean(command, io) {
         writeLine(io.stdout, cleanJson(footprint, plan, vaults, pruned, reconciled));
         return pruned.status === "fail" ? 1 : 0;
     }
+    writeFreedSummary(io, pruned, removedVaults);
+    return pruned.status === "fail" ? 1 : 0;
+}
+function writeFreedSummary(io, pruned, removedVaults) {
     writeLine(io.stdout, `Freed ${mb(pruned.deleted_bytes)} MB across ${pruned.deleted_files} file(s) and ${pruned.removed_packs} pack(s)${removedVaults > 0 ? `, plus ${removedVaults} evidence vault(s)` : ""}.`);
     if (pruned.cap_blocked_by_uncommitted) {
         writeLine(io.stdout, `Still ${mb(pruned.bytes_after)} MB over a ${mb(pruned.cap_bytes)} MB cap, held by ${pruned.cap_blocked_count} object(s) the upload ledger cannot vouch for. Run \`cockpit sync\` to try delivering them; nothing here will delete them.`);
     }
-    return pruned.status === "fail" ? 1 : 0;
 }
 /** The bucket table a person reads before anything is deleted. */
 export function cleanLines(footprint, plan, vaults, command, logArchives = []) {

package/dist/commands/docs-read.js

@@ -166,8 +166,11 @@ export async function readDoc(command, door) {
         writeDocumentBlock(door.io, result.document);
         return 0;
     }
-    // Several refs: `{ ok, documents: [{ ref, ok, document|error }] }` — one bad
-    // ref never loses the rest of the batch.
+    return reportSeveralDocuments(door, results);
+}
+// Several refs: `{ ok, documents: [{ ref, ok, document|error }] }` — one bad
+// ref never loses the rest of the batch.
+function reportSeveralDocuments(door, results) {
     const failed = results.filter((result) => !result.ok);
     if (door.json) {
         return emitAgentDoor(door, {

package/dist/commands/doctor-backfill.js

@@ -36,91 +36,108 @@ export async function checkBackfillState(context) {
  */
 export async function fixBackfillState(context) {
     const started = Date.now();
-    const deadline = started + doctorBackfillBudgetSeconds(context, started) * 1000;
-    let caughtUp = 0;
-    let chunks = 0;
-    let live = null;
-    let remaining = null;
-    const receipt = () => `caught up on ${caughtUp} old sessions in ${chunks} chunk${chunks === 1 ? "" : "s"} over ${clock(Date.now() - started)}`;
-    const unfinished = (code, reason) => ({
-        ...needsFix("backfill-complete", code, `${receipt()}, ${remaining ?? "unknown"} still to go; ${reason}; run \`cockpit doctor\` again to continue`),
+    const run = {
+        started,
+        deadline: started + doctorBackfillBudgetSeconds(context, started) * 1000,
+        caughtUp: 0,
+        chunks: 0,
+        live: null,
+        remaining: null,
+    };
+    const stopProgress = startProgress((text) => context.io.stderr.write(text), progressReporter(run));
+    try {
+        return await catchUpChunkByChunk(context, run);
+    }
+    catch (error) {
+        console.error("[doctor] backfill-complete failed", JSON.stringify({ reason: "backfill_threw", error_name: error instanceof Error ? error.name : "unknown" }));
+        return unfinishedRow(run, "backfill_threw", "backfill failed");
+    }
+    finally {
+        stopProgress();
+    }
+}
+function describeReceipt(run) {
+    return `caught up on ${run.caughtUp} old sessions in ${run.chunks} chunk${run.chunks === 1 ? "" : "s"} over ${clock(Date.now() - run.started)}`;
+}
+function unfinishedRow(run, code, reason) {
+    return {
+        ...needsFix("backfill-complete", code, `${describeReceipt(run)}, ${run.remaining ?? "unknown"} still to go; ${reason}; run \`cockpit doctor\` again to continue`),
         nextAction: "cockpit doctor",
-    });
+    };
+}
+function progressReporter(run) {
     let lastLine = null;
-    const stopProgress = startProgress((text) => context.io.stderr.write(text), (elapsedMs) => {
+    return (elapsedMs) => {
+        const { live } = run;
         const snapshot = {
-            caughtUp: live === null ? caughtUp : caughtUp + live.uploaded,
-            remaining: live?.remaining ?? remaining,
+            caughtUp: live === null ? run.caughtUp : run.caughtUp + live.uploaded,
+            remaining: live?.remaining ?? run.remaining,
         };
         console.error("[doctor] backfill-complete progress", JSON.stringify({
             status: live === null ? "between_chunks" : "running", processed: live?.processed ?? null,
-            uploaded: live === null ? null : caughtUp + live.uploaded,
-            caught_up: snapshot.caughtUp, remaining: snapshot.remaining, chunks, elapsed_seconds: Math.floor(elapsedMs / 1000),
+            uploaded: live === null ? null : run.caughtUp + live.uploaded,
+            caught_up: snapshot.caughtUp, remaining: snapshot.remaining, chunks: run.chunks, elapsed_seconds: Math.floor(elapsedMs / 1000),
         }));
         const line = backfillProgressLine(snapshot, lastLine, elapsedMs);
         lastLine = snapshot;
         return line;
-    });
-    try {
-        while (Date.now() < deadline) {
-            const row = await withCollectionGate(context, "backfill-complete", async () => {
-                if (Date.now() >= deadline)
-                    return unfinished("backfill_budget_timeout", "backfill time budget reached");
-                const capture = capturedIo(context.io, false);
-                live = null;
-                chunks += 1;
-                const code = await runBackfillCommand({
-                    homeDir: context.command.homeDir, repoRoot: context.command.repoRoot,
-                    all: true, dryRun: false, yes: true, json: true,
-                    deadlineMs: deadline,
-                    // Doctor never waits for the collection lock (BLI-12872): the gate
-                    // above looked at it, and a busy answer here is reported, not retried.
-                    syncLockWaitMs: 0,
-                    onProgress: (progress) => { live = progress; },
-                }, capture.io);
-                const parsed = parseDoctorBackfillJson(capture.stdout());
-                const counts = asRecord(parsed?.counts);
-                const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
-                caughtUp += count(counts?.["backfilled"]) ?? 0;
-                remaining = count(counts?.["remaining"]) ?? remaining;
-                live = null;
-                if (code === 0 && parsed?.status === "complete") {
-                    // Reporting totals include permanent caps. Preserve their marker
-                    // note instead of retrying history the collector says is complete.
-                    const checked = await checkBackfillState(context);
-                    return ok("backfill-complete", checked.status === "ok" ? checked.code : "complete", receipt() + (checked.status === "ok" ? `; ${checked.message}` : ""));
-                }
-                const verdict = backfillFixVerdict(parsed, jsonField(capture.stderr(), "failure_reason"));
-                if (parsed?.status === "partial" &&
-                    (parsed.failure_reason === "deferred_budget_exhausted" || !parsed.failure_reason)) {
-                    return needsFix("backfill-complete", "backfill_chunk_pending", "more history remains");
-                }
-                return { ...verdict, message: typeof parsed?.failure_reason === "string" ? parsed.failure_reason : "backfill failed without a valid completion receipt" };
-            });
-            if (row.status === "ok") {
-                console.error("[doctor] backfill-complete finished", JSON.stringify({ caught_up: caughtUp, remaining, chunks, elapsed_seconds: Math.floor((Date.now() - started) / 1000) }));
-                return row;
-            }
-            if (row.status === "skipped") {
-                // A running sync (or another catch-up) owns the lock. Doctor does not
-                // wait; it says what this run managed before it stood aside.
-                console.error("[doctor] backfill-complete stood aside", JSON.stringify({ reason: row.code, caught_up: caughtUp, remaining, chunks }));
-                return caughtUp > 0 ? { ...row, message: `${receipt()}; ${row.message}` } : row;
-            }
-            if (row.code === "sync_stuck_not_ended")
-                return row;
-            if (row.code !== "backfill_chunk_pending")
-                return unfinished(row.code, row.message);
+    };
+}
+async function catchUpChunkByChunk(context, run) {
+    while (Date.now() < run.deadline) {
+        const row = await withCollectionGate(context, "backfill-complete", () => runOneChunk(context, run));
+        if (row.status === "ok") {
+            console.error("[doctor] backfill-complete finished", JSON.stringify({ caught_up: run.caughtUp, remaining: run.remaining, chunks: run.chunks, elapsed_seconds: Math.floor((Date.now() - run.started) / 1000) }));
+            return row;
         }
-        return unfinished("backfill_budget_timeout", "backfill time budget reached");
+        if (row.status === "skipped") {
+            // A running sync (or another catch-up) owns the lock. Doctor does not
+            // wait; it says what this run managed before it stood aside.
+            console.error("[doctor] backfill-complete stood aside", JSON.stringify({ reason: row.code, caught_up: run.caughtUp, remaining: run.remaining, chunks: run.chunks }));
+            return run.caughtUp > 0 ? { ...row, message: `${describeReceipt(run)}; ${row.message}` } : row;
+        }
+        if (row.code === "sync_stuck_not_ended")
+            return row;
+        if (row.code !== "backfill_chunk_pending")
+            return unfinishedRow(run, row.code, row.message);
     }
-    catch (error) {
-        console.error("[doctor] backfill-complete failed", JSON.stringify({ reason: "backfill_threw", error_name: error instanceof Error ? error.name : "unknown" }));
-        return unfinished("backfill_threw", "backfill failed");
+    return unfinishedRow(run, "backfill_budget_timeout", "backfill time budget reached");
+}
+async function runOneChunk(context, run) {
+    if (Date.now() >= run.deadline)
+        return unfinishedRow(run, "backfill_budget_timeout", "backfill time budget reached");
+    const capture = capturedIo(context.io, false);
+    run.live = null;
+    run.chunks += 1;
+    const code = await runBackfillCommand({
+        homeDir: context.command.homeDir, repoRoot: context.command.repoRoot,
+        all: true, dryRun: false, yes: true, json: true,
+        deadlineMs: run.deadline,
+        // Doctor never waits for the collection lock (BLI-12872): the gate
+        // above looked at it, and a busy answer here is reported, not retried.
+        syncLockWaitMs: 0,
+        onProgress: (progress) => { run.live = progress; },
+    }, capture.io);
+    const parsed = parseDoctorBackfillJson(capture.stdout());
+    const counts = asRecord(parsed?.counts);
+    run.caughtUp += nonNegativeCount(counts?.["backfilled"]) ?? 0;
+    run.remaining = nonNegativeCount(counts?.["remaining"]) ?? run.remaining;
+    run.live = null;
+    if (code === 0 && parsed?.status === "complete") {
+        // Reporting totals include permanent caps. Preserve their marker
+        // note instead of retrying history the collector says is complete.
+        const checked = await checkBackfillState(context);
+        return ok("backfill-complete", checked.status === "ok" ? checked.code : "complete", describeReceipt(run) + (checked.status === "ok" ? `; ${checked.message}` : ""));
     }
-    finally {
-        stopProgress();
+    const verdict = backfillFixVerdict(parsed, jsonField(capture.stderr(), "failure_reason"));
+    if (parsed?.status === "partial" &&
+        (parsed.failure_reason === "deferred_budget_exhausted" || !parsed.failure_reason)) {
+        return needsFix("backfill-complete", "backfill_chunk_pending", "more history remains");
     }
+    return { ...verdict, message: typeof parsed?.failure_reason === "string" ? parsed.failure_reason : "backfill failed without a valid completion receipt" };
+}
+function nonNegativeCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
 }
 function capturedIo(io, forward) {
     const stdoutChunks = [];