@bli-cockpit/cli 0.2.99 → 0.2.101

package/dist/commands/notes-folders.js

@@ -0,0 +1,35 @@
+import { writeLine } from "./cli-io.js";
+import { ask, emit, fail, READ_DEADLINE_MS } from "./notes-door.js";
+export async function runFolderCommand(command, door) {
+    const path = command.folder?.split("/").map(part => part.trim()).join("/");
+    const answer = await ask(door, {
+        path: "/api/notes/folders", method: command.action === "mkdir" ? "POST" : "GET",
+        label: `notes ${command.action}`, timeoutMs: READ_DEADLINE_MS,
+        ...(command.action === "mkdir" ? { body: { path } } : {}),
+    });
+    if (!answer.ok)
+        return fail(door, answer.reason, answer.detail);
+    const body = answer.body;
+    if (command.action === "rmdir" || command.action === "rename") {
+        const folder = body.folders?.find(folder => folder.path === path);
+        if (!folder)
+            return fail(door, "folder_not_found", "That folder could not be found.");
+        const removed = await ask(door, { path: `/api/notes/folders/${encodeURIComponent(folder.id)}`, method: command.action === "rename" ? "PATCH" : "DELETE", label: `notes ${command.action}`, timeoutMs: READ_DEADLINE_MS, ...(command.action === "rename" ? { body: { name: command.name } } : {}) });
+        if (!removed.ok)
+            return fail(door, removed.reason, removed.detail);
+        if (door.json)
+            return emit(door, removed.body);
+        writeLine(door.io.stdout, removed.body.headline);
+        return 0;
+    }
+    if (door.json)
+        return emit(door, body);
+    if (command.action === "mkdir")
+        writeLine(door.io.stdout, body.headline ?? "Folder ready.");
+    else
+        for (const folder of body.folders ?? []) {
+            const label = command.tree ? `${"  ".repeat(folder.path.split("/").length - 1)}${folder.name}` : folder.path;
+            writeLine(door.io.stdout, `${label} (${folder.note_count})`);
+        }
+    return 0;
+}

package/dist/commands/notes-writes.js

@@ -4,7 +4,7 @@
  * `notes.ts`, named in its header.
  */
 import { isInteractiveStdin, readLine, readPipedText, writeLine, yesByDefault } from "./cli-io.js";
-import { NOTE_SLOW_UPLOAD_BYTES, decodeTextBytes, noteFileRefusalSentence, readNoteFile, } from "./notes-file.js";
+import { NOTE_SLOW_UPLOAD_BYTES, noteAudioMime, decodeTextBytes, noteFileRefusalSentence, readNoteFile, } from "./notes-file.js";
 import { ask, emit, fail, sayUpload, errorText, TAG, READ_DEADLINE_MS } from "./notes-door.js";
 /**
  * The upload route's own ceiling is `maxDuration = 300` — reading a note is one
@@ -36,9 +36,11 @@ export async function uploadNotes(command, door) {
             writeLine(door.io.stderr, `Reading ${read.fileName} (${Math.round(read.bytes.byteLength / 1024)} KB). This can take a couple of minutes.`);
         }
         const form = new FormData();
-        form.set("file", new File([new Uint8Array(read.bytes)], read.fileName));
+        form.set("file", new File([new Uint8Array(read.bytes)], read.fileName, { type: noteAudioMime(read.fileName) ?? "" }));
         if (command.exclude)
             form.set("exclusions", command.exclude);
+        if (command.folder)
+            form.set("folder_path", command.folder);
         const answer = await ask(door, {
             path: "/api/notes/upload",
             method: "POST",
@@ -55,7 +57,14 @@ export async function uploadNotes(command, door) {
             continue;
         }
         const body = answer.body;
-        results.push({ path: filePath, ok: body.stored === true, body });
+        if (command.wait && body.noteId && body.transcription?.status === "pending") {
+            body.transcription = await waitForTranscription(door, body.noteId);
+        }
+        if (body.transcription?.status === "failed")
+            worstExit = 1;
+        if (!door.json && body.transcription)
+            writeLine(door.io.stdout, `${body.noteId}: transcription ${body.transcription.status}${body.transcription.reason ? ": " + body.transcription.reason : ""}`);
+        results.push({ path: filePath, ok: body.stored === true && body.transcription?.status !== "failed", body });
         if (body.stored !== true)
             worstExit = 1;
         if (!door.json)
@@ -114,6 +123,8 @@ export async function pasteNote(command, door) {
         form.set("name", command.name);
     if (command.exclude)
         form.set("exclusions", command.exclude);
+    if (command.folder)
+        form.set("folder_path", command.folder);
     // Bytes, not `.length` (BLI-3482). `NOTE_SLOW_UPLOAD_BYTES` is a BYTE
     // threshold, and the file path above already compares `bytes.byteLength`
     // against it; `text.length` counts UTF-16 units, so a note in any non-Latin
@@ -225,7 +236,10 @@ export async function moveNote(command, door) {
         timeoutMs: READ_DEADLINE_MS,
         // `--clear-shelf` sends the empty string, which is what the browser's own
         // move box sends when a person empties it.
-        body: { note_id: command.noteId, category: command.clearShelf ? "" : command.to },
+        body: { note_id: command.noteId,
+            ...(command.folder ? { folder_path: command.folder } : {}),
+            ...(command.to || command.clearShelf ? { category: command.clearShelf ? "" : command.to } : {}),
+        },
     });
     if (!answer.ok)
         return fail(door, answer.reason, answer.detail);
@@ -242,4 +256,23 @@ export async function moveNote(command, door) {
     for (const line of body.lines ?? [])
         writeLine(door.io.stdout, line);
     return body.ok === true ? 0 : 1;
+}
+/** Bounded polling of the same note read used by the browser and MCP. */
+async function waitForTranscription(door, noteId) {
+    const deadline = Date.now() + 330_000;
+    for (let attempt = 0; attempt < 110 && Date.now() < deadline; attempt++) {
+        const answer = await ask(door, { path: `/api/notes/library/${encodeURIComponent(noteId)}`,
+            method: "GET", label: "notes transcription", timeoutMs: Math.min(10_000, deadline - Date.now()) });
+        if (!answer.ok)
+            return { status: "failed", reason: answer.reason };
+        const status = answer.body.audio?.transcription_status;
+        if (status === "done")
+            return { status: "done" };
+        if (status?.startsWith("failed:"))
+            return { status: "failed", reason: status.slice(7) };
+        if (status !== "pending")
+            return { status: "failed", reason: "transcription_status_unavailable" };
+        await new Promise((resolve) => setTimeout(resolve, Math.min(3000, Math.max(0, deadline - Date.now()))));
+    }
+    return { status: "failed", reason: "transcription_wait_timeout" };
 }

package/dist/commands/notes.js

@@ -36,6 +36,7 @@
 import { loadPairedSession } from "../tower-client.js";
 import { listNotes, listShelves, showNote, showShelf } from "./notes-reads.js";
 import { uploadNotes, pasteNote, shareNote, moveNote, placeNote } from "./notes-writes.js";
+import { runFolderCommand } from "./notes-folders.js";
 export { listNotes, listShelves, showNote, showShelf } from "./notes-reads.js";
 export { uploadNotes, pasteNote, shareNote, moveNote, placeNote } from "./notes-writes.js";
 export { ask, emit, fail, sayUpload, sayScope, errorText, TAG, } from "./notes-door.js";
@@ -48,6 +49,11 @@ export async function runNotes(command, io) {
         json: command.json,
     };
     switch (command.action) {
+        case "folders":
+        case "mkdir":
+        case "rmdir":
+        case "rename":
+            return runFolderCommand(command, door);
         case "list":
             return listNotes(command, door);
         case "shelves":

package/dist/commands/public-root.js

@@ -15,7 +15,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.99");
+    writeLine(io?.stdout ?? process.stdout, "0.2.101");
     return 0;
   }
 
@@ -40,12 +40,12 @@ function cockpitHelp() {
     localCommandHelp(),
     "",
     "Install: `npm install -g @bli-cockpit/cli@latest`.",
-    "Fix everything: run `cockpit do-everything` to update, verify auth/roots, refresh autostart, backfill, GC, and sync.",
+    "Fix everything: run `cockpit doctor`. `do-everything` and `fix` are exact aliases; --check diagnoses without repairs.",
     "Update: run `cockpit update` to refresh the global CLI and rerun onboarding checks.",
     "Intern path: run `cockpit onboard`; it confirms a `/BLI` collection root before syncing.",
     "Headless/reused laptop path: `cockpit onboard --email <email> --workspace ~/BLI`.",
-    "Already onboarded: run `cockpit update` from anywhere to refresh pairing, roots, agent rules, autostart, and sync.",
-    "Agent setup: `cockpit onboard` refreshes AGENTS.md/CLAUDE.md rules; use `cockpit agent-rules install --workspace ~/BLI` for repair.",
+    "Already onboarded: run `cockpit doctor` from anywhere to repair and verify this machine.",
+    "Agent setup: `cockpit doctor` installs and verifies AGENTS.md/CLAUDE.md rules.",
     "Dashboard URL is optional for normal production use; pass `--dashboard-url` only for staging/custom dashboards or forced re-pairing.",
     "Manual collector path: `install`, `login`, `start [--ticket <id>] [--topic <label>] [--intent <intent>] [--phase <phase>]`, `sync`, `status`, `agent-rules`.",
     "Maintainer release path: merge to main, publish to `next` with `cockpit release`, canary Windows plus Apple Silicon, then deliberately promote that exact version to `latest`.",

package/dist/commands/usage-format.js

@@ -0,0 +1,18 @@
+/** Compact counts for human-facing usage tables. JSON keeps the original numbers. */
+export function formatCount(value) {
+    if (value === null)
+        return "Unavailable";
+    // Promote rounded values at unit boundaries instead of printing 1000K or 1000M.
+    if (value >= 999_950_000)
+        return `${Number((value / 1_000_000_000).toFixed(1))}B`;
+    if (value >= 999_500)
+        return `${Number((value / 1_000_000).toFixed(1))}M`;
+    if (value >= 1_000)
+        return `${Math.round(value / 1_000)}K`;
+    return String(value);
+}
+export function formatUsageDollars(value) {
+    return new Intl.NumberFormat("en-US", {
+        style: "currency", currency: "USD", maximumFractionDigits: 0,
+    }).format(value);
+}

package/dist/commands/usage.js

@@ -1,3 +1,4 @@
+import { formatCount, formatUsageDollars } from "./usage-format.js";
 import { askAgentDoor, emitAgentDoor, failAgentDoor, openAgentDoor } from "./agent-door.js";
 import { writeLine } from "./cli-io.js";
 export async function runUsage(command, io) {
@@ -13,9 +14,18 @@ export async function runUsage(command, io) {
     const body = answer.body;
     if (door.json)
         return emitAgentDoor(door, body);
-    writeLine(io.stdout, "PERSON                 TOKENS       OUTPUT       LIST EQUIVALENT  COVERAGE");
-    for (const row of body.people ?? [])
-        writeLine(io.stdout, `${(row.display_name ?? row.email ?? "Unknown").slice(0, 20).padEnd(20)}  ${String(row.tokens_total).padStart(11)}  ${String(row.output_tokens).padStart(11)}  ${`$${row.api_list_price_equivalent_usd.toFixed(2)}`.padStart(15)}  ${row.sessions_extracted}/${row.sessions_observed}`);
+    const widths = [20, 8, 15, 12, 10, 10, 12, 14];
+    const printRow = (cells) => writeLine(io.stdout, cells.map((cell, index) => index === 0 ? cell.padEnd(widths[index]) : cell.padStart(widths[index])).join("  ").trimEnd());
+    printRow(["Person", "Tokens", "List equivalent", "Coverage", ...(command.detail ? ["Output", "Input", "Cache read", "Cache creation"] : [])]);
+    for (const row of body.people ?? []) {
+        printRow([
+            (row.display_name ?? row.email ?? "Unknown").slice(0, 20),
+            formatCount(row.tokens_total),
+            formatUsageDollars(row.api_list_price_equivalent_usd),
+            `${row.sessions_extracted}/${row.sessions_observed}`,
+            ...(command.detail ? [row.output_tokens, row.input_tokens, row.cache_read_input_tokens, row.cache_creation_input_tokens].map(formatCount) : []),
+        ]);
+    }
     writeLine(io.stdout, "");
     writeLine(io.stdout, body.api_list_price_equivalent_label ?? "API list-price equivalent (not actual spend)");
     writeLine(io.stdout, `${body.coverage?.sessions_extracted ?? 0} of ${body.coverage?.sessions_observed ?? 0} sessions extracted`);

package/dist/cursors/backfill-completion-marker.js

@@ -0,0 +1,135 @@
+/**
+ * The all-history completion marker: the one document that says an `--all`
+ * backfill finished, and the only proof `cockpit doctor` accepts for its
+ * `backfill-complete` row.
+ *
+ * It lives beside the cursor and not inside it because it answers a different
+ * question. The cursor is where the sweep GOT TO and is rewritten constantly;
+ * the marker is a claim about a finished scope, with its own schema version,
+ * its own 24-hour revalidation, and its own rule about which leftovers are
+ * allowed to ride along on a run that still counts as complete (a file over
+ * the upload cap, BLI-2727; helper transcripts over the per-session sidecar
+ * cap, BLI-4303). Both of those are recorded here, never silently dropped.
+ *
+ * Every name is re-exported from `./backfill-cursor.js`, the address its
+ * callers already know.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { describeError, isMissingFileFailure } from "../health-detail.js";
+import { backfillCollectionScopeId, parseBackfillCursor, writePrivateBackfillJson, } from "./backfill-cursor.js";
+export const BACKFILL_COMPLETION_MARKER_FILENAME = "backfill-complete.json";
+export const BACKFILL_COVERAGE_VERSION = "redacted-session-backfill.v3";
+export const BACKFILL_COMPLETION_RECHECK_MS = 24 * 60 * 60 * 1_000;
+export async function writeBackfillCompletionMarker(paths, marker) {
+    await writePrivateBackfillJson(backfillCompletionMarkerPath(paths), marker);
+}
+export async function readBackfillCompletionMarker(paths) {
+    try {
+        const raw = JSON.parse(await fs.readFile(backfillCompletionMarkerPath(paths), "utf8"));
+        return parseBackfillCompletionMarker(raw);
+    }
+    catch (error) {
+        // No marker means backfill has not finished, which is the ordinary state.
+        // A marker that cannot be read means a finished backfill will be re-run,
+        // and the machine should say so rather than quietly redo a day of work.
+        if (!isMissingFileFailure(error)) {
+            console.error("[backfill-cursor] completion marker unreadable, treating backfill as unfinished", JSON.stringify({
+                reason: "backfill_marker_unreadable",
+                marker_file: BACKFILL_COMPLETION_MARKER_FILENAME,
+                ...describeError(error),
+            }));
+        }
+        return null;
+    }
+}
+export function backfillCompletionCovers(marker, collectionRoots, requiredSources, now = new Date()) {
+    if (!marker)
+        return false;
+    if (marker.coverage_version !== BACKFILL_COVERAGE_VERSION)
+        return false;
+    if (marker.collection_scope_id !== backfillCollectionScopeId(collectionRoots)) {
+        return false;
+    }
+    const revalidateAfter = Date.parse(marker.revalidate_after);
+    if (!Number.isFinite(revalidateAfter) || now.getTime() >= revalidateAfter) {
+        return false;
+    }
+    const completedSources = new Set(marker.sources);
+    return requiredSources.every((source) => completedSources.has(source));
+}
+export function backfillCompletionMarkerPath(paths) {
+    return path.join(paths.cursors_dir, BACKFILL_COMPLETION_MARKER_FILENAME);
+}
+function parseBackfillCompletionMarker(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (record["schema_version"] !== "cockpit-backfill-complete.v2" ||
+        record["coverage_version"] !== BACKFILL_COVERAGE_VERSION) {
+        return null;
+    }
+    const collectionScopeId = optionalString(record["collection_scope_id"]);
+    const completedAt = optionalString(record["completed_at"]);
+    const revalidateAfter = optionalString(record["revalidate_after"]);
+    const rawSources = record["sources"];
+    if (!collectionScopeId ||
+        !completedAt ||
+        !revalidateAfter ||
+        !Number.isFinite(Date.parse(revalidateAfter)) ||
+        !Array.isArray(rawSources)) {
+        return null;
+    }
+    const sources = [
+        ...new Set(rawSources.filter((source) => source === "codex" || source === "claude_code")),
+    ];
+    if (sources.length === 0)
+        return null;
+    return {
+        schema_version: "cockpit-backfill-complete.v2",
+        coverage_version: BACKFILL_COVERAGE_VERSION,
+        collection_scope_id: collectionScopeId,
+        sources,
+        completed_at: completedAt,
+        revalidate_after: revalidateAfter,
+        cursor: parseBackfillCursor(record["cursor"]),
+        ...(parseOversizedSkips(record["oversized_skips"])
+            ? { oversized_skips: parseOversizedSkips(record["oversized_skips"]) }
+            : {}),
+        ...(parseSidecarCapSkips(record["sidecar_cap_skips"])
+            ? { sidecar_cap_skips: parseSidecarCapSkips(record["sidecar_cap_skips"]) }
+            : {}),
+    };
+}
+function parseSidecarCapSkips(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (record["reason"] !== "claude_sidecar_limit_applied")
+        return null;
+    const count = optionalNumber(record["count"]);
+    if (count === null || count <= 0)
+        return null;
+    return { reason: "claude_sidecar_limit_applied", count };
+}
+function parseOversizedSkips(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    if (record["reason"] !== "file_too_large")
+        return null;
+    const count = optionalNumber(record["count"]);
+    if (count === null || count <= 0)
+        return null;
+    const rawByteSizes = record["byte_sizes"];
+    const byteSizes = Array.isArray(rawByteSizes)
+        ? rawByteSizes.filter((entry) => typeof entry === "number" && Number.isFinite(entry) && entry >= 0)
+        : [];
+    return { reason: "file_too_large", count, byte_sizes: byteSizes };
+}
+function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function optionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

package/dist/cursors/backfill-cursor.js

@@ -1,11 +1,19 @@
+/**
+ * Where the historical sweep got to, per source: the backfill cursor.
+ *
+ * Two things live in this folder and they are deliberately separate. This one
+ * is a moving position — a newest/oldest watermark, the identities sitting
+ * exactly on each boundary, and the census of what was seen — rewritten by
+ * every run. Its sibling `backfill-completion-marker.ts` is the claim that a
+ * whole scope is FINISHED, with its own schema and its own rules; every name
+ * it owns is re-exported at the bottom of this file, so callers keep one
+ * address.
+ */
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { describeError, isMissingFileFailure } from "../health-detail.js";
 export const BACKFILL_CURSOR_FILENAME = "backfill.json";
-export const BACKFILL_COMPLETION_MARKER_FILENAME = "backfill-complete.json";
-export const BACKFILL_COVERAGE_VERSION = "redacted-session-backfill.v3";
-export const BACKFILL_COMPLETION_RECHECK_MS = 24 * 60 * 60 * 1_000;
 export function emptyBackfillCursorState() {
     return {
         schema_version: "cockpit-backfill-cursor.v1",
@@ -37,29 +45,7 @@ export async function readBackfillCursor(paths) {
 }
 export async function writeBackfillCursor(paths, state) {
     const filePath = backfillCursorPath(paths);
-    await writePrivateJson(filePath, state);
-}
-export async function writeBackfillCompletionMarker(paths, marker) {
-    await writePrivateJson(backfillCompletionMarkerPath(paths), marker);
-}
-export async function readBackfillCompletionMarker(paths) {
-    try {
-        const raw = JSON.parse(await fs.readFile(backfillCompletionMarkerPath(paths), "utf8"));
-        return parseBackfillCompletionMarker(raw);
-    }
-    catch (error) {
-        // No marker means backfill has not finished, which is the ordinary state.
-        // A marker that cannot be read means a finished backfill will be re-run,
-        // and the machine should say so rather than quietly redo a day of work.
-        if (!isMissingFileFailure(error)) {
-            console.error("[backfill-cursor] completion marker unreadable, treating backfill as unfinished", JSON.stringify({
-                reason: "backfill_marker_unreadable",
-                marker_file: BACKFILL_COMPLETION_MARKER_FILENAME,
-                ...describeError(error),
-            }));
-        }
-        return null;
-    }
+    await writePrivateBackfillJson(filePath, state);
 }
 /**
  * The cursor is only reusable inside the exact approved-root scope that
@@ -83,21 +69,6 @@ export function prepareBackfillCursorForScope(cursor, collectionRoots, sources)
         reset,
     };
 }
-export function backfillCompletionCovers(marker, collectionRoots, requiredSources, now = new Date()) {
-    if (!marker)
-        return false;
-    if (marker.coverage_version !== BACKFILL_COVERAGE_VERSION)
-        return false;
-    if (marker.collection_scope_id !== backfillCollectionScopeId(collectionRoots)) {
-        return false;
-    }
-    const revalidateAfter = Date.parse(marker.revalidate_after);
-    if (!Number.isFinite(revalidateAfter) || now.getTime() >= revalidateAfter) {
-        return false;
-    }
-    const completedSources = new Set(marker.sources);
-    return requiredSources.every((source) => completedSources.has(source));
-}
 export function backfillCollectionScopeId(collectionRoots) {
     const normalized = [...new Set(collectionRoots.map(normalizeScopeRoot))].sort();
     return `scope-${crypto
@@ -178,9 +149,6 @@ export function recordBackfillScanCoverage(cursor, sources, coveredThrough, now)
 export function backfillCursorPath(paths) {
     return path.join(paths.cursors_dir, BACKFILL_CURSOR_FILENAME);
 }
-export function backfillCompletionMarkerPath(paths) {
-    return path.join(paths.cursors_dir, BACKFILL_COMPLETION_MARKER_FILENAME);
-}
 function emptySourceCursor(collectionScopeId = null) {
     return {
         collection_scope_id: collectionScopeId,
@@ -194,7 +162,7 @@ function emptySourceCursor(collectionScopeId = null) {
         reason_counts: {},
     };
 }
-function parseBackfillCursor(value) {
+export function parseBackfillCursor(value) {
     if (!value || typeof value !== "object")
         return emptyBackfillCursorState();
     const record = value;
@@ -228,58 +196,6 @@ function parseSourceCursor(value) {
         reason_counts: parseNumberRecord(record["reason_counts"]),
     };
 }
-function parseBackfillCompletionMarker(value) {
-    if (!value || typeof value !== "object")
-        return null;
-    const record = value;
-    if (record["schema_version"] !== "cockpit-backfill-complete.v2" ||
-        record["coverage_version"] !== BACKFILL_COVERAGE_VERSION) {
-        return null;
-    }
-    const collectionScopeId = optionalString(record["collection_scope_id"]);
-    const completedAt = optionalString(record["completed_at"]);
-    const revalidateAfter = optionalString(record["revalidate_after"]);
-    const rawSources = record["sources"];
-    if (!collectionScopeId ||
-        !completedAt ||
-        !revalidateAfter ||
-        !Number.isFinite(Date.parse(revalidateAfter)) ||
-        !Array.isArray(rawSources)) {
-        return null;
-    }
-    const sources = [
-        ...new Set(rawSources.filter((source) => source === "codex" || source === "claude_code")),
-    ];
-    if (sources.length === 0)
-        return null;
-    return {
-        schema_version: "cockpit-backfill-complete.v2",
-        coverage_version: BACKFILL_COVERAGE_VERSION,
-        collection_scope_id: collectionScopeId,
-        sources,
-        completed_at: completedAt,
-        revalidate_after: revalidateAfter,
-        cursor: parseBackfillCursor(record["cursor"]),
-        ...(parseOversizedSkips(record["oversized_skips"])
-            ? { oversized_skips: parseOversizedSkips(record["oversized_skips"]) }
-            : {}),
-    };
-}
-function parseOversizedSkips(value) {
-    if (!value || typeof value !== "object")
-        return null;
-    const record = value;
-    if (record["reason"] !== "file_too_large")
-        return null;
-    const count = optionalNumber(record["count"]);
-    if (count === null || count <= 0)
-        return null;
-    const rawByteSizes = record["byte_sizes"];
-    const byteSizes = Array.isArray(rawByteSizes)
-        ? rawByteSizes.filter((entry) => typeof entry === "number" && Number.isFinite(entry) && entry >= 0)
-        : [];
-    return { reason: "file_too_large", count, byte_sizes: byteSizes };
-}
 function normalizeScopeRoot(value) {
     const windowsStyle = path.win32.isAbsolute(value) && !path.posix.isAbsolute(value);
     if (windowsStyle)
@@ -305,7 +221,7 @@ function parseStringArray(value) {
         ...new Set(value.filter((entry) => typeof entry === "string" && entry.trim().length > 0)),
     ].sort();
 }
-async function writePrivateJson(filePath, value) {
+export async function writePrivateBackfillJson(filePath, value) {
     await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
     const tempPath = `${filePath}.tmp-${process.pid}-${crypto.randomUUID()}`;
     const serialized = `${JSON.stringify(value, null, 2)}\n`;
@@ -334,4 +250,7 @@ function optionalString(value) {
 }
 function optionalNumber(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
+}
+// Re-exported so every caller keeps importing the completion marker from
+// `./backfill-cursor.js`, the address it has always had.
+export { BACKFILL_COMPLETION_MARKER_FILENAME, BACKFILL_COMPLETION_RECHECK_MS, BACKFILL_COVERAGE_VERSION, backfillCompletionCovers, backfillCompletionMarkerPath, readBackfillCompletionMarker, writeBackfillCompletionMarker, } from "./backfill-completion-marker.js";

package/dist/scheduled-self-update.js

@@ -146,7 +146,7 @@ function parseSemverTriple(value) {
         return null;
     return [Number(match[1]), Number(match[2]), Number(match[3])];
 }
-function isSemverBelow(left, right) {
+export function isSemverBelow(left, right) {
     const parsedLeft = parseSemverTriple(left);
     const parsedRight = parseSemverTriple(right);
     if (!parsedLeft || !parsedRight)

package/dist/sync-lock.js

@@ -15,7 +15,16 @@ import { describeError } from "./health-detail.js";
  */
 const LOCK_FILENAME = "sync.lock";
 const HEARTBEAT_INTERVAL_MS = 30_000;
-const STALE_TAKEOVER_MS = 2 * 60_000;
+/**
+ * How long a lock may go without a heartbeat before the next sync takes it
+ * over. Exported because it is also what "the owner is still alive" MEANS on
+ * this machine: a receipt that says `sync_already_running` and carries a
+ * heartbeat inside this window was refused by a process that is still running
+ * (BLI-4303). Doctor reads it that way instead of calling a contended lock a
+ * failure.
+ */
+export const SYNC_LOCK_STALE_TAKEOVER_MS = 2 * 60_000;
+const STALE_TAKEOVER_MS = SYNC_LOCK_STALE_TAKEOVER_MS;
 export async function acquireSyncLock(paths, now = new Date()) {
     const lockPath = path.join(paths.state_dir, LOCK_FILENAME);
     await fs.mkdir(paths.state_dir, { recursive: true, mode: 0o700 });
@@ -133,4 +142,9 @@ async function readLock(lockPath) {
         // ACQUIRE above is the branch that owns the reporting.
         return null;
     }
+}
+/** Read owner metadata without acquiring or disturbing the collection lock. */
+export async function inspectSyncLock(paths) {
+    const record = await readLock(path.join(paths.state_dir, LOCK_FILENAME));
+    return record ? { pid: record.pid, heartbeat_at: record.heartbeat_at, held: Date.now() - record.heartbeat_ms <= STALE_TAKEOVER_MS } : null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.99",
+  "version": "0.2.101",
   "private": false,
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@bli-cockpit/memory-mcp": "0.1.26",
-    "@bli-cockpit/mcp": "0.1.30",
+    "@bli-cockpit/mcp": "0.1.32",
     "@bli-cockpit/telemetry-core": "0.1.43"
   }
 }