@bli-cockpit/cli 0.2.237 → 0.2.239

package/dist/local-state-pairing-code.js

@@ -32,20 +32,7 @@ export async function pairLocalCollectorViaLink(options = {}) {
     if (!fetchImpl) {
         throw new PairingCodeError("fetch_unavailable", "global fetch is unavailable; use Node.js 20 or newer.");
     }
-    const minted = options.pairCode
-        ? null
-        : await mintPairingCode(fetchImpl, dashboardUrl, {
-            device_id: deviceId,
-            device_name: deviceName,
-            claimed_owner_email: options.claimedOwnerEmail,
-            collector_version: LOCAL_COLLECTOR_VERSION,
-        });
-    if (minted) {
-        options.onLinkReady?.({
-            connect_url: minted.connect_url,
-            expires_at: minted.expires_at,
-        });
-    }
+    const minted = await preparePairingLink(options, fetchImpl, dashboardUrl, deviceId, deviceName);
     const session = await pollExchange(fetchImpl, dashboardUrl, {
         paths,
         code: options.pairCode ?? minted?.code ?? "",
@@ -66,6 +53,23 @@ export async function pairLocalCollectorViaLink(options = {}) {
         direction: minted ? "cli_first" : "browser_first",
     };
 }
+async function preparePairingLink(options, fetchImpl, dashboardUrl, deviceId, deviceName) {
+    const minted = options.pairCode
+        ? null
+        : await mintPairingCode(fetchImpl, dashboardUrl, {
+            device_id: deviceId,
+            device_name: deviceName,
+            claimed_owner_email: options.claimedOwnerEmail,
+            collector_version: LOCAL_COLLECTOR_VERSION,
+        });
+    if (minted) {
+        options.onLinkReady?.({
+            connect_url: minted.connect_url,
+            expires_at: minted.expires_at,
+        });
+    }
+    return minted;
+}
 async function mintPairingCode(fetchImpl, dashboardUrl, body) {
     const response = await fetchImpl(`${dashboardUrl}/api/devices/pair/code`, {
         method: "POST",
@@ -107,23 +111,7 @@ async function pollExchange(fetchImpl, dashboardUrl, options) {
     let attempts = 0;
     while (Date.now() <= deadline) {
         attempts += 1;
-        const response = await fetchImpl(`${dashboardUrl}/api/devices/pair/exchange`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                code: options.code,
-                ...(options.clientSecret ? { client_secret: options.clientSecret } : {}),
-                device_id: options.deviceId,
-                device_name: options.deviceName,
-                collector_version: LOCAL_COLLECTOR_VERSION,
-            }),
-        });
-        const parsed = await readResponseJson(response, "exchange");
-        const record = asRecord(parsed);
-        const status = readString(record, "status");
-        if (!response.ok) {
-            throw refusalFrom(readString(record, "reason") ?? "pair_exchange_refused", response, parsed);
-        }
+        const { record, status } = await requestPairingExchange(fetchImpl, dashboardUrl, options);
         if (status === "paired") {
             const session = parseExchangedSession(record, options.paths.session_file);
             await writeJsonFile(options.paths.session_file, session);
@@ -141,6 +129,26 @@ async function pollExchange(fetchImpl, dashboardUrl, options) {
     console.error(`${TAG} gave up waiting`, JSON.stringify({ reason: "pair_exchange_timeout", attempts }));
     throw new PairingCodeError("pair_exchange_timeout", "Timed out waiting for the browser sign-in. Run `cockpit login` again.");
 }
+async function requestPairingExchange(fetchImpl, dashboardUrl, options) {
+    const response = await fetchImpl(`${dashboardUrl}/api/devices/pair/exchange`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            code: options.code,
+            ...(options.clientSecret ? { client_secret: options.clientSecret } : {}),
+            device_id: options.deviceId,
+            device_name: options.deviceName,
+            collector_version: LOCAL_COLLECTOR_VERSION,
+        }),
+    });
+    const parsed = await readResponseJson(response, "exchange");
+    const record = asRecord(parsed);
+    const status = readString(record, "status");
+    if (!response.ok) {
+        throw refusalFrom(readString(record, "reason") ?? "pair_exchange_refused", response, parsed);
+    }
+    return { record, status };
+}
 function parseExchangedSession(record, sessionFilePath) {
     const session = record?.["session"];
     if (!session || typeof session !== "object") {

package/dist/local-state-status.js

@@ -18,6 +18,9 @@ import { readLocalWorkContextForRepo, workDisplayLabel, } from "./local-state-wo
 export async function inspectLocalCollectorStatus(options = {}) {
     const now = options.now ?? new Date();
     const reading = await readCollectorStatus(options, now);
+    return collectorStatusFromReading(reading, now);
+}
+function collectorStatusFromReading(reading, now) {
     const { paths, config, session, identity, context, branch } = reading;
     const { uploadSpool, healthOutbox, stuckEvidence } = reading;
     const freshness = classifyCollectorFreshness(context, uploadSpool.last_upload_success_at, now);
@@ -132,7 +135,7 @@ function classifyUploadState(config, uploadSpool, session) {
  * queue, and each names its own reason and count.
  */
 function describeCollectorStatus(reading) {
-    const { paths, config, session, context, uploadSpool, healthOutbox, stuckEvidence } = reading;
+    const { paths, config, session, context, uploadSpool, healthOutbox } = reading;
     const details = [];
     details.push(config
         ? `Config exists at ${paths.config_file}.`
@@ -158,6 +161,11 @@ function describeCollectorStatus(reading) {
     if (healthOutbox.pending_count > 0) {
         details.push(`Collector health retry pending: ${healthOutbox.pending_count} sanitized receipt(s) queued since ${healthOutbox.oldest_created_at ?? "unknown"}.`);
     }
+    appendEvidenceStatus(details, reading);
+    return details;
+}
+function appendEvidenceStatus(details, reading) {
+    const { stuckEvidence } = reading;
     // BLI-3797: the line above only sees objects whose delivery FAILED. This one
     // sees evidence that is on this disk and not in the bucket, however it got
     // that way — which is the only question that answers "has everything landed?".
@@ -176,7 +184,6 @@ function describeCollectorStatus(reading) {
     if (stuckEvidence.ghost_record_count > 0) {
         details.push(`${stuckEvidence.ghost_record_count} old delivery record(s) have nothing left to send; no action needed.`);
     }
-    return details;
 }
 /**
  * Whether this machine looks alive right now. A successful upload counts as

package/dist/onboarding-roots.js

@@ -11,14 +11,8 @@ import { isSamePath, normalizeCollectionRoots, } from "./root-normalization.js";
 export { HOME_ROOT_DECLINE_PATH_PROMPT, HOME_ROOT_NO_FOLDER_CHOSEN_MESSAGE, homeRootConsentPrompt, missingCollectionRootMessage, rootRejectionExplanation, } from "./onboarding-root-guidance.js";
 export const COLLECTION_ROOT_REQUIRED = "collection_root_required";
 /**
- * No approved collection root, so there is nothing this machine may look at.
- *
- * A type rather than a message prefix (BLI-3551): the health-receipt classifier
- * used to recognise this by searching the error text, which is the same habit
- * that filed `session_report_unposted` as an auth failure. The message is
- * unchanged — `collection_root_required: <what to do about it>` — so every
- * operator-facing string and every test that reads one still matches; what
- * changed is that the classifier reads the type.
+ * Keep root failures typed so health classification never guesses from message text.
+ * The existing collection_root_required prefix remains a public contract.
  */
 export class CollectionRootRequiredError extends Error {
     reason = COLLECTION_ROOT_REQUIRED;
@@ -64,6 +58,9 @@ export async function resolveOnboardingRoots(options) {
         }
         return promptForRoots(options, "Collection root(s), comma-separated: ");
     }
+    return resolveSuggestedOrLikelyRoots(options);
+}
+async function resolveSuggestedOrLikelyRoots(options) {
     const suggestions = normalizeRootsDetailed(options.suggestedRoots ?? [], { homeDir: options.homeDir, allowHomeRoot: options.allowHomeRoot }).roots;
     if (options.interactive && suggestions.length > 0 && await requirePrompt(options).confirm(`Sessions were found in:\n${suggestions.join("\n")}\nCollect from these folders? [Y/n] `)) {
         return resolvedRoots(options, suggestions, "prompt", true);

package/dist/process-runner.js

@@ -37,14 +37,7 @@ export function createCapturedExecRunner(options = {}) {
             windowsVerbatimArguments: invocation.windowsVerbatimArguments,
             ...(runOptions?.timeoutMs ? { timeout: runOptions.timeoutMs } : {}),
         }, (error, stdout, stderr) => {
-            // A child ended by `timeoutMs` reports code 124, never a bare 1.
-            const code = error == null
-                ? 0
-                : error.killed === true && runOptions?.timeoutMs
-                    ? 124
-                    : typeof error.code === "number"
-                        ? error.code
-                        : 1;
+            const code = capturedExitCode(error, runOptions?.timeoutMs);
             resolve({
                 code,
                 stdout: stdout ?? "",
@@ -142,4 +135,11 @@ function escapeWindowsCmdArgument(value) {
     escaped = `"${escaped}"`;
     escaped = escaped.replace(CMD_META_CHARS, "^$1");
     return escaped.replace(CMD_META_CHARS, "^$1");
+}
+function capturedExitCode(error, timeoutMs) {
+    if (error == null)
+        return 0;
+    if (error.killed === true && timeoutMs)
+        return 124;
+    return typeof error.code === "number" ? error.code : 1;
 }

package/dist/raw-evidence-gc.js

@@ -83,23 +83,10 @@ export function rawEvidenceGcSummary(result) {
     return `Cleaned up: removed ${result.removed_dirs} old folders, freed ~${formatMb(result.freed_bytes)} MB`;
 }
 /**
- * Collapse byte-identical staged packs down to one survivor.
- *
- * Runs at the START of every sync, unthrottled and with no age requirement,
- * because it is the only thing that drains a machine that already holds 559
- * copies of the same rollout (BLI-3066). The GC proper cannot: it only deletes
- * packs whose every file is already committed, and these were never committed —
- * that is precisely why they piled up.
- *
- * Deleting an uncommitted copy is safe here and only here: the survivor holds
- * the identical bytes, by content hash, so no evidence is lost. Identity comes
- * from the manifest's recorded file hashes — cheap (one small JSON per pack)
- * and exact. A pack with no readable manifest is counted and left alone rather
- * than guessed at.
- *
- * The survivor is the newest directory: it is the one the current content-keyed
- * pack id resolves to, so a fleet machine converges in one extra sync instead
- * of oscillating between an old name and a new one.
+ * Remove byte-identical staged packs without losing their surviving evidence.
+ * Fingerprint manifest hashes, never guess unreadable packs. Prefer a pack the
+ * staging index references, then the newest directory, so future collection
+ * reuses the survivor instead of recreating and deleting copies each tick.
  */
 export async function sweepDuplicateStagedRawEvidence(paths, env = process.env, now = new Date()) {
     const empty = {
@@ -123,6 +110,31 @@ export async function sweepDuplicateStagedRawEvidence(paths, env = process.env,
     // that would look like the sweep working while the bytes moved every cycle.
     const staging = await readRawEvidenceStagingState(paths.state_dir);
     const referencedPackIds = new Set(Object.values(staging.staged).map((entry) => entry.pack_id));
+    const { packs, removedStagingDirs } = await inspectStagedPacks(rawEvidenceRoot, dirEntries, referencedPackIds, now);
+    const { duplicateGroups, removedDirs, freedBytes, unfingerprintable } = await removeDuplicatePacks(packs);
+    const result = {
+        skipped: false,
+        duplicate_groups: duplicateGroups,
+        removed_dirs: removedDirs,
+        freed_bytes: freedBytes,
+        removed_staging_dirs: removedStagingDirs,
+        unfingerprintable_dirs: unfingerprintable,
+    };
+    // stderr, which launchd captures to `sync.err.log`. Logged on every sweep,
+    // including the boring one: "0 duplicates today" is the only evidence that
+    // the drain is still running at all.
+    console.error("[raw-evidence] dedup sweep", JSON.stringify({
+        reason: removedDirs > 0 ? "dedup_removed" : "dedup_clean",
+        pack_count: packs.length,
+        duplicate_groups: duplicateGroups,
+        removed_dirs: removedDirs,
+        freed_bytes: freedBytes,
+        removed_staging_dirs: removedStagingDirs,
+        unfingerprintable_dirs: unfingerprintable,
+    }));
+    return result;
+}
+async function inspectStagedPacks(rawEvidenceRoot, dirEntries, referencedPackIds, now) {
     let removedStagingDirs = 0;
     const packs = [];
     for (const entry of dirEntries) {
@@ -151,6 +163,9 @@ export async function sweepDuplicateStagedRawEvidence(paths, env = process.env,
             preferred: referencedPackIds.has(entry.name),
         });
     }
+    return { packs, removedStagingDirs };
+}
+async function removeDuplicatePacks(packs) {
     const groups = new Map();
     let unfingerprintable = 0;
     for (const pack of packs) {
@@ -186,27 +201,7 @@ export async function sweepDuplicateStagedRawEvidence(paths, env = process.env,
             freedBytes += byteSize;
         }
     }
-    const result = {
-        skipped: false,
-        duplicate_groups: duplicateGroups,
-        removed_dirs: removedDirs,
-        freed_bytes: freedBytes,
-        removed_staging_dirs: removedStagingDirs,
-        unfingerprintable_dirs: unfingerprintable,
-    };
-    // stderr, which launchd captures to `sync.err.log`. Logged on every sweep,
-    // including the boring one: "0 duplicates today" is the only evidence that
-    // the drain is still running at all.
-    console.error("[raw-evidence] dedup sweep", JSON.stringify({
-        reason: removedDirs > 0 ? "dedup_removed" : "dedup_clean",
-        pack_count: packs.length,
-        duplicate_groups: duplicateGroups,
-        removed_dirs: removedDirs,
-        freed_bytes: freedBytes,
-        removed_staging_dirs: removedStagingDirs,
-        unfingerprintable_dirs: unfingerprintable,
-    }));
-    return result;
+    return { duplicateGroups, removedDirs, freedBytes, unfingerprintable };
 }
 export function rawEvidenceDedupSummary(result) {
     return `raw-evidence dedup: removed ${result.removed_dirs} duplicate pack(s) across ${result.duplicate_groups} group(s), freed ~${formatMb(result.freed_bytes)} MB`;

package/dist/raw-evidence-stuck-summary.js

@@ -1,18 +1,8 @@
 /**
- * "Is anything stuck, and is anything being held right now?" — the two
- * questions `cockpit status`, the health receipt and the fleet board ask of the
- * delivery-attempt history, split out of `raw-evidence-staging.ts` (BLI-4022)
- * so that file stays under the repo's readability band.
- *
- * The distinction this file exists to keep: an object with a live failure
- * history is STUCK, and an object whose next attempt is still in the future is
- * HELD. Every held object is stuck and most stuck objects are held, but the two
- * answer different questions — "has anything been failing for nine days" versus
- * "what did this tick withhold, and when does it try again" — and BLI-4022
- * needed the second one, which nothing computed.
- *
- * Metadata only, like the rest of this family: content hashes, byte sizes,
- * reason labels, timestamps. Never content, never an absolute path.
+ * Report live delivery failures separately from evidence currently held by backoff.
+ * A hold carries its own oldest failure and next retry time. Delivery records
+ * without staged bytes are counted as ghosts, never as stuck evidence.
+ * Logs contain only metadata, never content or absolute paths.
  */
 import { deliveryRetryAtMs, terminalDeliveryReason } from "./raw-evidence-staging.js";
 /**
@@ -40,6 +30,9 @@ export function summarizeStuckEvidence(state, now) {
             reason: "object_no_longer_staged",
         }));
     }
+    return summarizeLiveDeliveryAttempts(entries, ghostCount, now);
+}
+function summarizeLiveDeliveryAttempts(entries, ghostCount, now) {
     const reasons = new Set();
     let heldCount = 0;
     let maxAttempts = 0;

package/dist/repo-identity.js

@@ -113,29 +113,7 @@ export async function discoverGitWorktreesWithStatus(root, options = {}) {
             discovered.set(identity.worktree_fingerprint, identity);
             continue;
         }
-        // A failed read is recorded, never swallowed: anything beneath this folder
-        // is missing from the scan, and the operator has to be able to see that.
-        let entries;
-        try {
-            entries = await fs.readdir(current.dir, { withFileTypes: true });
-        }
-        catch (error) {
-            if (unreadableDirs.length < MAX_REPORTED_UNREADABLE_DIRS) {
-                unreadableDirs.push({ path: current.dir, code: errorCode(error) });
-            }
-            continue;
-        }
-        if (current.depth >= maxDepth) {
-            if (entries.some((entry) => entry.isDirectory() && !shouldSkipDirectory(entry.name))) {
-                incompleteReasons.add("max_depth_reached");
-            }
-            continue;
-        }
-        for (const entry of entries) {
-            if (!entry.isDirectory() || shouldSkipDirectory(entry.name))
-                continue;
-            stack.push({ dir: path.join(current.dir, entry.name), depth: current.depth + 1 });
-        }
+        await enqueueChildDirectories(current, maxDepth, stack, unreadableDirs, incompleteReasons);
     }
     const expanded = await expandLinkedWorktrees([...discovered.values()].sort(compareIdentity), maxWorktrees, allowedRoots);
     for (const reason of expanded.incomplete_reasons) {
@@ -150,6 +128,31 @@ export async function discoverGitWorktreesWithStatus(root, options = {}) {
         unreadable_dirs: unreadableDirs,
     };
 }
+async function enqueueChildDirectories(current, maxDepth, stack, unreadableDirs, incompleteReasons) {
+    // A failed read is recorded, never swallowed: anything beneath this folder
+    // is missing from the scan, and the operator has to be able to see that.
+    let entries;
+    try {
+        entries = await fs.readdir(current.dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (unreadableDirs.length < MAX_REPORTED_UNREADABLE_DIRS) {
+            unreadableDirs.push({ path: current.dir, code: errorCode(error) });
+        }
+        return;
+    }
+    if (current.depth >= maxDepth) {
+        if (entries.some((entry) => entry.isDirectory() && !shouldSkipDirectory(entry.name))) {
+            incompleteReasons.add("max_depth_reached");
+        }
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory() || shouldSkipDirectory(entry.name))
+            continue;
+        stack.push({ dir: path.join(current.dir, entry.name), depth: current.depth + 1 });
+    }
+}
 /**
  * Discovers and deduplicates git worktrees across the exact roots supplied by
  * the caller. An approved root with no current git checkout intentionally

package/dist/scheduled-self-update.js

@@ -4,14 +4,8 @@ import { describeError } from "./health-detail.js";
 const SELF_UPDATE_MIN_INTERVAL_MS = 24 * 60 * 60 * 1000;
 export const SELF_UPDATE_THROTTLE_MARKER = ".last-self-update-check";
 /**
- * launchd starts the scheduled tick with a bare PATH (`/usr/bin:/bin:...`) —
- * the plist hardcodes absolute node/CLI paths for exactly that reason — so a
- * bare `npm` spawn that works in every interactive shell resolves to nothing
- * inside the tick, and every scheduled update would fail `npm_install_failed`
- * on the whole Mac fleet while interactive `cockpit doctor` kept working. The
- * npm shim ships beside the node binary in the standard layouts on both host
- * families, so the running node's own directory is the one PATH entry that is
- * always right.
+ * Put the running node binary's directory on PATH for scheduled npm commands.
+ * Schedulers use a bare PATH; npm's shim ships beside node on both host families.
  */
 export function envWithNodeRuntimeOnPath(env, nodeExecutable = process.execPath) {
     const nodeBinDir = path.dirname(nodeExecutable);
@@ -24,13 +18,9 @@ export function envWithNodeRuntimeOnPath(env, nodeExecutable = process.execPath)
     };
 }
 /**
- * BLI-2601. Runs at most once per day from inside `cockpit sync`'s
- * post-collection tail, so the fleet converges on npm `latest` without
- * anyone re-running `npm i -g @bli-cockpit/cli && cockpit doctor` by hand after day 0.
- *
- * Installation is verified with npm's installed-version probe. The sync caller
- * re-executes the tick on `updated`, carrying a guard that skips another update
- * attempt in the replacement process.
+ * Converge scheduled collectors on npm latest, throttled to one attempt per day.
+ * Verify npm's installed version before callers re-execute the tick. A server
+ * floor bypasses the throttle; an operator's incident freeze still wins.
  */
 export async function runScheduledSelfUpdate(paths, deps, options = {}) {
     const env = options.env ?? process.env;
@@ -72,6 +62,9 @@ export async function runScheduledSelfUpdate(paths, deps, options = {}) {
         // this machine on purpose, and the server must not be able to unpin it.
         return { status: "skipped", reason: "disabled_by_env", ...forcedFields };
     }
+    return installScheduledUpdate(deps, tag, forced, minVersion, forcedFields);
+}
+async function installScheduledUpdate(deps, tag, forced, minVersion, forcedFields) {
     const targetVersion = await latestCliVersionFromNpm(deps.exec, tag);
     if (forced &&
         targetVersion &&
@@ -105,6 +98,9 @@ export async function runScheduledSelfUpdate(paths, deps, options = {}) {
             ...forcedFields,
         };
     }
+    return verifyScheduledUpdate(deps, targetVersion, forcedFields);
+}
+async function verifyScheduledUpdate(deps, targetVersion, forcedFields) {
     // Verify against what the platform returns, not the exit code npm handed
     // back (BLI-2541 lesson: a green exit code is not proof). Read the
     // globally installed package's version back off disk via `npm ls -g

package/dist/second-install.js

@@ -53,6 +53,9 @@ export async function detectSecondCockpitInstall(options) {
             paths: installs,
         };
     }
+    return compareRunningInstall(installs, options, platform);
+}
+async function compareRunningInstall(installs, options, platform) {
     // Exactly one on PATH. It can still be a DIFFERENT install from the one
     // running now — the scheduler holds an absolute path to whichever prefix it
     // was registered with. Only decidable where the bin is a symlink into the

package/dist/slim/codex-rules.js

@@ -1,30 +1,12 @@
 /**
- * The slim rules for one Codex rollout line (BLI-16977). Entry point: `slimCodexRecord`.
- *
- * A Codex line is `{timestamp, type, payload}`. The envelope never changes; only payload goes.
- * Measured on 80 local rollouts, almost all the bulk is images (turned into markers before this
- * runs) and a second copy of each finished item (`event_msg` `item_completed`) next to the
- * `response_item` the model saw. The survey and its skeptic agree on what is a copy:
- *
- *  - `item_completed` CommandExecution: `formatted_output` and `parsed_cmd` go, and `stdout` goes
- *    when it equals `aggregated_output`. `aggregated_output` and `command` STAY: they are the only
- *    full copy of what the shell printed.
- *  - `item_completed` UserMessage, AgentMessage, Reasoning: any long string identical to one in an
- *    EARLIER `response_item` becomes a reference. A copy that came first in the file is kept.
- *  - McpToolCall results, FileChange contents, `compacted.replacement_history`, image generations:
- *    kept (their images are markers by now). `compacted.guardian_history` keeps only what an
- *    earlier `response_item` did not already hold.
- *  - `token_count`: `last_token_usage` and `rate_limits` go; `total_token_usage` and
- *    `model_context_window` stay (the session facts read them).
- *  - `token_usage_record`: payload emptied (17,964 of 18,109 were byte-equal to a `token_count`).
- *  - `thread_settings_applied`: reduced to `service_tier`.
- *  - `response_item`: `internal_chat_message_metadata_passthrough` goes; a developer message, the
- *    `session_meta` `base_instructions` and each `world_state` block are kept once per distinct
- *    text and become references after.
- *  - `task_complete.last_agent_message`: a reference when an earlier message holds the same text.
- *
- * `task_started`/`task_complete` durations, `session_meta.forked_from_id` and every unnamed shape
- * pass through untouched.
+ * Remove only proven duplicate Codex payloads, preserving the envelope.
+ * Keep command/aggregated_output, unique file/tool content, replacement_history,
+ * images after marker replacement, durations, fork identity and unknown shapes.
+ * Remember earlier response_item strings; later long copies become references.
+ * Keep total usage/context window; drop repeated usage/rate-limit bookkeeping.
+ * Keep one distinct developer message, base instructions and world-state block.
+ * Guardian history and task_complete messages deduplicate only against earlier
+ * response items; a copy appearing first is retained.
  */
 import { SLIM_COPY_MIN_CHARS, canonicalText, contentHash, isJsonObject, isSlimRef, slimRefFor, stripKey, } from "./slim-support.js";
 /** Strings from `response_item` lines remembered for comparison. Past this, new strings are not added. */
@@ -136,16 +118,18 @@ function rememberLongStrings(value, state, depth) {
     if (typeof value === "string") {
         if (value.length >= SLIM_COPY_MIN_CHARS)
             state.earlierStrings.add(contentHash(value));
+        return;
     }
-    else if (Array.isArray(value)) {
+    if (Array.isArray(value)) {
         for (const item of value)
             rememberLongStrings(item, state, depth + 1);
+        return;
     }
-    else if (isJsonObject(value)) {
-        for (const [key, item] of Object.entries(value)) {
-            if (key !== "encrypted_content")
-                rememberLongStrings(item, state, depth + 1);
-        }
+    if (!isJsonObject(value))
+        return;
+    for (const [key, item] of Object.entries(value)) {
+        if (key !== "encrypted_content")
+            rememberLongStrings(item, state, depth + 1);
     }
 }
 function refIfEarlierCopy(holder, key, state, rule, edits) {
@@ -167,13 +151,16 @@ function refEarlierCopiesIn(node, state, rule, edits, depth) {
         const holder = node;
         const child = holder[key];
         if (typeof child === "string") {
-            if (child.length >= SLIM_COPY_MIN_CHARS && state.earlierStrings.has(contentHash(child))) {
-                holder[key] = slimRefFor(contentHash(child));
-                edits.strip(rule, child.length);
-            }
+            refEarlierString(holder, key, child, state, rule, edits);
         }
         else if ((Array.isArray(child) || isJsonObject(child)) && !isSlimRef(child)) {
             refEarlierCopiesIn(child, state, rule, edits, depth + 1);
         }
     }
+}
+function refEarlierString(holder, key, child, state, rule, edits) {
+    if (child.length < SLIM_COPY_MIN_CHARS || !state.earlierStrings.has(contentHash(child)))
+        return;
+    holder[key] = slimRefFor(contentHash(child));
+    edits.strip(rule, child.length);
 }

package/dist/spool/local-spool-parse.js

@@ -65,24 +65,25 @@ function parseSourceRetryEntry(value, fieldPath) {
 function parsePendingSessionReport(value, fieldPath) {
     const record = requireRecord(value, fieldPath);
     const sessions = parseMetadataOnlySessionReportRows(record["sessions"], `${fieldPath}.sessions`);
+    const text = (key) => requireString(record[key], `${fieldPath}.${key}`);
     return {
-        report_id: requireString(record["report_id"], `${fieldPath}.report_id`),
-        created_at: requireString(record["created_at"], `${fieldPath}.created_at`),
-        last_attempt_at: requireString(record["last_attempt_at"], `${fieldPath}.last_attempt_at`),
-        dashboard_url: requireString(record["dashboard_url"], `${fieldPath}.dashboard_url`),
-        generated_at: requireString(record["generated_at"], `${fieldPath}.generated_at`),
-        work_context_id: requireString(record["work_context_id"], `${fieldPath}.work_context_id`),
-        repo_label: requireString(record["repo_label"], `${fieldPath}.repo_label`),
-        branch: requireString(record["branch"], `${fieldPath}.branch`),
-        repo_fingerprint: requireString(record["repo_fingerprint"], `${fieldPath}.repo_fingerprint`),
+        report_id: text("report_id"),
+        created_at: text("created_at"),
+        last_attempt_at: text("last_attempt_at"),
+        dashboard_url: text("dashboard_url"),
+        generated_at: text("generated_at"),
+        work_context_id: text("work_context_id"),
+        repo_label: text("repo_label"),
+        branch: text("branch"),
+        repo_fingerprint: text("repo_fingerprint"),
         repo_origin_url: record["repo_origin_url"] === undefined
             ? null
             : requireNullableString(record["repo_origin_url"], `${fieldPath}.repo_origin_url`),
-        worktree_label: requireString(record["worktree_label"], `${fieldPath}.worktree_label`),
-        worktree_fingerprint: requireString(record["worktree_fingerprint"], `${fieldPath}.worktree_fingerprint`),
+        worktree_label: text("worktree_label"),
+        worktree_fingerprint: text("worktree_fingerprint"),
         worktree_is_primary: requireBoolean(record["worktree_is_primary"], `${fieldPath}.worktree_is_primary`),
         sessions,
-        failure_reason: requireString(record["failure_reason"], `${fieldPath}.failure_reason`),
+        failure_reason: text("failure_reason"),
     };
 }
 export function parseMetadataOnlySessionReportRows(value, fieldPath) {

package/dist/sync-lock.js

@@ -3,21 +3,8 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { describeError } from "./health-detail.js";
 /**
- * Single-flight lock for `cockpit sync`. A launchd timer and a manual sync can
- * fire at the same time and interleave the cursor read-modify-write; this lock
- * lets the second invocation exit cleanly with `sync_already_running` instead.
- *
- * A held lock refreshes a heartbeat every 30 s. Takeover happens only when the
- * heartbeat is more than 2 minutes stale — a fixed short timeout would fire
- * during a legitimate long first sync and recreate the interleaving it
- * prevents (D33). The lock file stays local and stores a pid, a heartbeat and
- * (BLI-12872) when the holder started and when it last finished a unit of
- * work; no paths or content.
- *
- * The heartbeat only proves the process is alive. `started_ms` and
- * `progress_ms` are what let `sync-lock-holder.ts` tell a slow tick from a
- * stuck one: a holder that keeps finishing work is never called stuck, however
- * long it has been running.
+ * Serialize collection ticks while tracking heartbeat ownership and progress.
+ * A stale owner may neither refresh nor release a replacement owner's lock.
  */
 const LOCK_FILENAME = "sync.lock";
 const HEARTBEAT_INTERVAL_MS = 30_000;
@@ -79,6 +66,9 @@ export async function acquireSyncLock(paths, now = new Date(), options = {}) {
     }
     logAcquired(held, takeover, existing, now);
     heldStates.add(held);
+    return maintainOwnedLock(lockPath, token, held);
+}
+function maintainOwnedLock(lockPath, token, held) {
     const timer = setInterval(() => {
         // Refresh only while the lock is still ours; if we were taken over, stop
         // touching the file so we cannot steal it back from the new owner.