@bli-cockpit/cli 0.2.34 → 0.2.36

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.34");
+    writeLine(io?.stdout ?? process.stdout, "0.2.36");
     return 0;
   }
 

package/dist/commands/session-sync.js

@@ -46,6 +46,92 @@ function allLocalHistorySinceMinutes(now) {
     // Claude session files while keeping date arithmetic finite and portable.
     return Math.ceil(now.getTime() / 60_000) + 24 * 60;
 }
+/** Whether the spool already recorded a source-scan retry for this source. */
+function sourceScanRetryIsPending(uploadSpool, source) {
+    return Boolean(uploadSpool?.pending_source_retries.some((entry) => entry.source === source));
+}
+/**
+ * Does this source have a reason to widen its scan window to all local
+ * history instead of the normal live-sync window? Used to be two separately
+ * written boolean chains, one per source, that happened to agree on shape by
+ * hand — asymmetric to read even though the rule is identical for both
+ * (BLI-3394): a legacy spooled upload with no recorded source, a scan-retry
+ * the spool already remembers, a spooled upload that names this source, or an
+ * undurable session this source's own cursor is still carrying.
+ */
+function sourceHasPendingRetries(source, uploadSpool, legacyRetryPending, sourceScanRetryPending, cursor) {
+    return (legacyRetryPending ||
+        sourceScanRetryPending ||
+        Boolean(uploadSpool?.pending_uploads.some((entry) => entry.retry_sources.includes(source))) ||
+        cursorHasUndurableCollectableSession(cursor));
+}
+/**
+ * Scan and attribute Codex sessions for this sync, widening the window to all
+ * local history when a retry is pending. Codex has no first-run backfill
+ * concept (that is a Claude-only window, see `scanClaudeSessionsForSync`) and
+ * is always scanned, unlike Claude which can be disabled entirely.
+ */
+async function scanCodexSessionsForSync(options) {
+    const sinceMinutes = options.retryPending
+        ? options.allHistorySinceMinutes
+        : CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES;
+    let scan = await scanAndAttributeCodexSessions({
+        sessionsDirs: defaultCodexSessionDirs(options.homeDir),
+        worktrees: options.worktrees,
+        now: options.now,
+        sinceMinutes,
+        limit: CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT,
+        collectionRoots: options.collectionRoots,
+    });
+    if (scan.session_limit_applied) {
+        // Re-run once, bounded by exactly what the first pass discovered, so a
+        // capped scan still returns every session it found instead of silently
+        // truncating at the window's default limit.
+        scan = await scanAndAttributeCodexSessions({
+            sessionsDirs: defaultCodexSessionDirs(options.homeDir),
+            worktrees: options.worktrees,
+            now: options.now,
+            sinceMinutes,
+            limit: scan.discovered_file_count,
+            collectionRoots: options.collectionRoots,
+        });
+    }
+    return scan;
+}
+/**
+ * Scan and attribute Claude sessions for this sync — the Claude counterpart to
+ * `scanCodexSessionsForSync`. Disabled collection returns an empty scan
+ * up front; a first sync (no cursor yet) widens the window to 14 days instead
+ * of the normal 24h so it captures retroactive history.
+ */
+async function scanClaudeSessionsForSync(options) {
+    if (!options.claudeEnabled)
+        return emptyClaudeScan();
+    const sinceMinutes = options.retryPending
+        ? options.allHistorySinceMinutes
+        : options.firstRunBackfill
+            ? CLAUDE_FIRST_RUN_BACKFILL_MINUTES
+            : undefined;
+    const projectsDir = path.join(options.homeDir, ".claude", "projects");
+    let scan = await scanAndAttributeClaudeSessions({
+        projectsDir,
+        worktrees: options.worktrees,
+        now: options.now,
+        collectionRoots: options.collectionRoots,
+        sinceMinutes,
+    });
+    if (scan.session_limit_applied) {
+        scan = await scanAndAttributeClaudeSessions({
+            projectsDir,
+            worktrees: options.worktrees,
+            now: options.now,
+            collectionRoots: options.collectionRoots,
+            sinceMinutes,
+            limit: scan.discovered_session_count,
+        });
+    }
+    return scan;
+}
 function codexAttributionReadFailureCount(scan) {
     return scan.directory_read_failed_count + scan.stat_failed_count;
 }
@@ -140,71 +226,34 @@ export async function runAttributedWorktreeSync(options) {
         readLocalUploadSpoolState(paths).catch(() => null),
     ]);
     const legacyRetryPending = Boolean(uploadSpool?.pending_uploads.some((entry) => entry.raw_evidence_file_count > 0 && entry.retry_sources.length === 0));
-    const codexSourceRetryPending = Boolean(uploadSpool?.pending_source_retries.some((entry) => entry.source === "codex"));
-    const claudeSourceRetryPending = Boolean(uploadSpool?.pending_source_retries.some((entry) => entry.source === "claude_code"));
-    const codexRetryPending = legacyRetryPending ||
-        codexSourceRetryPending ||
-        Boolean(uploadSpool?.pending_uploads.some((entry) => entry.retry_sources.includes("codex"))) ||
-        cursorHasUndurableCollectableSession(codexCursorBefore);
+    const codexSourceRetryPending = sourceScanRetryIsPending(uploadSpool, "codex");
+    const claudeSourceRetryPending = sourceScanRetryIsPending(uploadSpool, "claude_code");
+    const codexRetryPending = sourceHasPendingRetries("codex", uploadSpool, legacyRetryPending, codexSourceRetryPending, codexCursorBefore);
     const claudeRetryPending = claudeEnabled &&
-        (legacyRetryPending ||
-            claudeSourceRetryPending ||
-            Boolean(uploadSpool?.pending_uploads.some((entry) => entry.retry_sources.includes("claude_code"))) ||
-            cursorHasUndurableCollectableSession(claudeCursorBefore));
+        sourceHasPendingRetries("claude_code", uploadSpool, legacyRetryPending, claudeSourceRetryPending, claudeCursorBefore);
     const allHistorySinceMinutes = allLocalHistorySinceMinutes(now);
-    let codexAttribution = await scanAndAttributeCodexSessions({
-        sessionsDirs: defaultCodexSessionDirs(homeDir),
+    const codexAttribution = await scanCodexSessionsForSync({
+        homeDir,
         worktrees: options.worktrees,
         now,
-        sinceMinutes: codexRetryPending
-            ? allHistorySinceMinutes
-            : CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES,
-        limit: CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT,
         collectionRoots,
+        retryPending: codexRetryPending,
+        allHistorySinceMinutes,
     });
-    if (codexAttribution.session_limit_applied) {
-        codexAttribution = await scanAndAttributeCodexSessions({
-            sessionsDirs: defaultCodexSessionDirs(homeDir),
-            worktrees: options.worktrees,
-            now,
-            sinceMinutes: codexRetryPending
-                ? allHistorySinceMinutes
-                : CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES,
-            limit: codexAttribution.discovered_file_count,
-            collectionRoots,
-        });
-    }
     // First run (D B.4 §8): without a Claude cursor yet, widen the window to 14
     // days so the first sync captures retroactive history instead of only 24h.
     const claudeCursorExists = await fileExists(path.join(paths.cursors_dir, CLAUDE_CURSOR_FILENAME));
     const firstRunBackfill = claudeEnabled && !claudeCursorExists;
-    let claudeAttribution = claudeEnabled
-        ? await scanAndAttributeClaudeSessions({
-            projectsDir: path.join(homeDir, ".claude", "projects"),
-            worktrees: options.worktrees,
-            now,
-            collectionRoots,
-            sinceMinutes: claudeRetryPending
-                ? allHistorySinceMinutes
-                : firstRunBackfill
-                    ? CLAUDE_FIRST_RUN_BACKFILL_MINUTES
-                    : undefined,
-        })
-        : emptyClaudeScan();
-    if (claudeAttribution.session_limit_applied) {
-        claudeAttribution = await scanAndAttributeClaudeSessions({
-            projectsDir: path.join(homeDir, ".claude", "projects"),
-            worktrees: options.worktrees,
-            now,
-            collectionRoots,
-            sinceMinutes: claudeRetryPending
-                ? allHistorySinceMinutes
-                : firstRunBackfill
-                    ? CLAUDE_FIRST_RUN_BACKFILL_MINUTES
-                    : undefined,
-            limit: claudeAttribution.discovered_session_count,
-        });
-    }
+    const claudeAttribution = await scanClaudeSessionsForSync({
+        claudeEnabled,
+        homeDir,
+        worktrees: options.worktrees,
+        now,
+        collectionRoots,
+        retryPending: claudeRetryPending,
+        allHistorySinceMinutes,
+        firstRunBackfill,
+    });
     await reconcileSourceScanRetry({
         paths,
         source: "codex",
@@ -359,67 +408,23 @@ export async function runAttributedWorktreeSync(options) {
         queuedCurrentSessionReport;
     // The sessions cursor is an optimization; a broken local state dir must not
     // turn already-completed syncs into a CLI crash.
-    let codexStaleCount = 0;
-    let claudeStaleCount = 0;
-    try {
-        const codexCursor = await readRawEvidenceCursor(paths);
-        codexStaleCount = recordSourceObservations({
-            cursor: codexCursor,
-            results: codexAttribution.results,
-            sessions,
-            source: "codex",
-            sessionIdOf: (result) => result.codex_session_id,
-            now,
-            priorCursor: codexCursorBefore,
-            terminalizeMissingUndurable: codexRetryPending &&
-                codexAttributionReadFailureCount(codexAttribution) === 0,
-        });
-        codexCursor.updated_at = now.toISOString();
-        await writeRawEvidenceCursor(paths, codexCursor);
-    }
-    catch (error) {
-        // Best-effort: stale counts read 0 and observations re-record next sync —
-        // which is fine ONCE. A cursor write that keeps failing means the sessions
-        // cursor never advances, every sync re-does the same work, and the only
-        // symptom is a stale count that is permanently zero (BLI-3238).
-        console.error("[session-sync] Codex session observations were not recorded", JSON.stringify({
-            reason: "session_cursor_update_failed",
-            source: "codex",
-            session_count: sessions.length,
-            ...describeError(error),
-        }));
-    }
-    if (claudeEnabled) {
-        try {
-            claudeStaleCount = recordSourceObservations({
-                cursor: claudeCursorBefore,
-                results: claudeAttribution.results,
-                sessions,
-                source: "claude_code",
-                sessionIdOf: (result) => result.claude_session_id,
-                now,
-                priorCursor: claudeCursorBefore,
-                terminalizeMissingUndurable: claudeRetryPending &&
-                    claudeAttributionReadFailureCount(claudeAttribution) === 0,
-            });
-            claudeCursorBefore.updated_at = now.toISOString();
-            await writeRawEvidenceCursor(paths, claudeCursorBefore, {
-                filename: CLAUDE_CURSOR_FILENAME,
-                sessionsOnly: true,
-            });
-        }
-        catch (error) {
-            // Best-effort: a broken Claude cursor must not fail the sync. It must
-            // still say it is broken — otherwise the Claude half of collection
-            // quietly repeats itself forever.
-            console.error("[session-sync] Claude session observations were not recorded", JSON.stringify({
-                reason: "session_cursor_update_failed",
-                source: "claude_code",
-                session_count: sessions.length,
-                ...describeError(error),
-            }));
-        }
-    }
+    const codexStaleCount = await recordCodexSessionObservationsForSync({
+        paths,
+        codexAttribution,
+        sessions,
+        now,
+        priorCursor: codexCursorBefore,
+        codexRetryPending,
+    });
+    const claudeStaleCount = await recordClaudeSessionObservationsForSync({
+        claudeEnabled,
+        paths,
+        claudeAttribution,
+        sessions,
+        now,
+        claudeCursorBefore,
+        claudeRetryPending,
+    });
     const report = hadPendingSessionReports || queuedCurrentSessionReport
         ? await flushPendingCodexSessionReports({
             homeDir: options.homeDir,
@@ -529,17 +534,16 @@ function normalizeClaudeResult(result) {
     };
 }
 /**
- * Generalizes the per-session report across sources. Dedupe is per
- * `(source, session_id)` so a Codex session and a Claude session that happen to
- * share an id are never collapsed. Upload state maps ONLY from the main-file
- * outcome (kind `codex_jsonl` / `claude_jsonl`); sidecar outcomes never set a
- * session's upload state (D3). Damped Claude sessions report `reused_existing`
- * carrying their prior durable pointer.
+ * Dedupe every source's attributed results down to the single best result per
+ * `(source, session_id)`. Best means highest attribution-state rank, ties
+ * broken by the newer file mtime. Codex and Claude sessions that happen to
+ * share an id are never collapsed into each other because the key carries the
+ * source.
  */
-export function buildAgentSessionReport(options) {
+function bestAttributedSessionsByKey(codexResults, claudeResults) {
     const normalized = [
-        ...options.codexResults.map(normalizeCodexResult),
-        ...options.claudeResults.map(normalizeClaudeResult),
+        ...codexResults.map(normalizeCodexResult),
+        ...claudeResults.map(normalizeClaudeResult),
     ];
     const bestByKey = new Map();
     for (const result of normalized) {
@@ -554,20 +558,19 @@ export function buildAgentSessionReport(options) {
             bestByKey.set(key, result);
         }
     }
-    // Main-file outcomes only (D3): a sidecar making it must never mark a session
-    // uploaded when the main did not.
+    return bestByKey;
+}
+/**
+ * Which sessions this sync actually uploaded, and why the rest did not — read
+ * ONLY from main-file outcomes (kind `codex_jsonl` / `claude_jsonl`); a
+ * sidecar making it must never mark a session uploaded when the main did not
+ * (D3).
+ */
+function sessionUploadOutcomesByKey(outcomes) {
     const uploadByKey = new Map();
-    // BLI-2107: why a session got no pointer, keyed the same way. The reasons
-    // already existed — file_too_large, deferred_byte_budget, the redaction
-    // guards — but only as aggregate skip counts in the health report, so no
-    // individual session could say what happened to it.
     const noUploadReasonByKey = new Map();
-    // A worktree sync that did not finish carries no per-session outcomes, and
-    // WorktreeSyncOutcome does not record which sessions it was going to cover.
-    // So this pass knows only that it was degraded, not which session each
-    // failure belonged to — and says exactly that rather than picking one.
     let anySyncIncomplete = false;
-    for (const outcome of options.outcomes) {
+    for (const outcome of outcomes) {
         if (outcome.sync.status !== "uploaded") {
             anySyncIncomplete = true;
             continue;
@@ -593,84 +596,194 @@ export function buildAgentSessionReport(options) {
             uploadByKey.set(key, upload);
         }
     }
-    return [...bestByKey.values()].map((result) => {
-        const key = `${result.source}:${result.session_id}`;
-        const upload = uploadByKey.get(key);
-        // A previously-durable Claude session with no fresh main upload this sync
-        // (damped / spooled / budget-deferred) reports reused_existing + its prior
-        // pointer rather than not_uploaded, so the store row never flips.
-        const priorDurablePointer = result.source === "claude_code"
-            ? (options.claudePriorDurablePointers.get(result.session_id) ?? null)
-            : null;
-        return {
-            codex_session_id: result.session_id,
-            source: result.source,
-            observed_at: options.now.toISOString(),
-            attribution_state: result.state,
-            attribution_reason: result.reason,
-            attribution_score: result.attribution_score,
-            path_score: result.path_score,
-            signals: result.signals,
-            ...(result.content_hash_sha256
-                ? { session_file_hash_sha256: result.content_hash_sha256 }
-                : {}),
-            session_file_byte_size: result.byte_size,
-            session_file_mtime: result.session_file_mtime,
-            ...(result.worktree
-                ? {
-                    repo_fingerprint: result.worktree.repo_fingerprint,
-                    worktree_fingerprint: result.worktree.worktree_fingerprint,
-                    repo_label: result.worktree.repo_label,
-                    branch: result.worktree.branch,
-                }
-                : {}),
-            ...(result.cwd_basename ? { cwd_basename: result.cwd_basename } : {}),
-            ...(result.cwd_hash ? { cwd_hash: result.cwd_hash } : {}),
-            ...(upload
+    return { uploadByKey, noUploadReasonByKey, anySyncIncomplete };
+}
+/** Turn one deduped, best-ranked session result into its report row. */
+function sessionReportEntry(result, context) {
+    const key = `${result.source}:${result.session_id}`;
+    const upload = context.uploadByKey.get(key);
+    // A previously-durable Claude session with no fresh main upload this sync
+    // (damped / spooled / budget-deferred) reports reused_existing + its prior
+    // pointer rather than not_uploaded, so the store row never flips.
+    const priorDurablePointer = result.source === "claude_code"
+        ? (context.claudePriorDurablePointers.get(result.session_id) ?? null)
+        : null;
+    return {
+        codex_session_id: result.session_id,
+        source: result.source,
+        observed_at: context.now.toISOString(),
+        attribution_state: result.state,
+        attribution_reason: result.reason,
+        attribution_score: result.attribution_score,
+        path_score: result.path_score,
+        signals: result.signals,
+        ...(result.content_hash_sha256
+            ? { session_file_hash_sha256: result.content_hash_sha256 }
+            : {}),
+        session_file_byte_size: result.byte_size,
+        session_file_mtime: result.session_file_mtime,
+        ...(result.worktree
+            ? {
+                repo_fingerprint: result.worktree.repo_fingerprint,
+                worktree_fingerprint: result.worktree.worktree_fingerprint,
+                repo_label: result.worktree.repo_label,
+                branch: result.worktree.branch,
+            }
+            : {}),
+        ...(result.cwd_basename ? { cwd_basename: result.cwd_basename } : {}),
+        ...(result.cwd_hash ? { cwd_hash: result.cwd_hash } : {}),
+        ...(upload
+            ? {
+                raw_evidence_pointer_id: upload.raw_evidence_pointer_id,
+                upload_state: upload.upload_state,
+                // A failed upload names itself; a successful one has nothing to
+                // explain.
+                ...(upload.upload_state === "upload_failed"
+                    ? {
+                        upload_reason: upload.reason ?? NO_UPLOAD_ATTEMPT_RECORDED,
+                    }
+                    : {}),
+            }
+            : priorDurablePointer
                 ? {
-                    raw_evidence_pointer_id: upload.raw_evidence_pointer_id,
-                    upload_state: upload.upload_state,
-                    // A failed upload names itself; a successful one has nothing to
-                    // explain.
-                    ...(upload.upload_state === "upload_failed"
-                        ? {
-                            upload_reason: upload.reason ?? NO_UPLOAD_ATTEMPT_RECORDED,
-                        }
-                        : {}),
+                    raw_evidence_pointer_id: priorDurablePointer,
+                    upload_state: "reused_existing",
                 }
-                : priorDurablePointer
+                : isRawEvidenceUploadableAttributionState(result.state, result.worktree !== null)
                     ? {
-                        raw_evidence_pointer_id: priorDurablePointer,
-                        upload_state: "reused_existing",
+                        upload_state: "not_uploaded",
+                        // BLI-2107: `not_uploaded` used to be the branch of last
+                        // resort, recording that nothing happened and never why. It
+                        // now always carries a cause, even when the cause is that we
+                        // have none — a session labelled NO_UPLOAD_ATTEMPT_RECORDED
+                        // is a path that still needs instrumenting, and saying so is
+                        // the point.
+                        upload_reason: context.noUploadReasonByKey.get(key) ??
+                            (context.anySyncIncomplete
+                                ? "sync_incomplete_this_pass"
+                                : NO_UPLOAD_ATTEMPT_RECORDED),
                     }
-                    : isRawEvidenceUploadableAttributionState(result.state, result.worktree !== null)
-                        ? {
-                            upload_state: "not_uploaded",
-                            // BLI-2107: `not_uploaded` used to be the branch of last
-                            // resort, recording that nothing happened and never why. It
-                            // now always carries a cause, even when the cause is that we
-                            // have none — a session labelled NO_UPLOAD_ATTEMPT_RECORDED
-                            // is a path that still needs instrumenting, and saying so is
-                            // the point.
-                            upload_reason: noUploadReasonByKey.get(key) ??
-                                (anySyncIncomplete
-                                    ? "sync_incomplete_this_pass"
-                                    : NO_UPLOAD_ATTEMPT_RECORDED),
-                        }
-                        : {
-                            // BLI-3272: the upload policy refused this session's
-                            // attribution state. That refusal used to spread `{}` here, so
-                            // the row landed with upload_state NULL and upload_reason NULL
-                            // — a withhold that named nothing, on 1,256 production
-                            // sessions. It is a decision like any other and it says so.
-                            // Any reason the pipeline did record still wins: it is the more
-                            // specific answer.
-                            upload_state: "not_uploaded",
-                            upload_reason: noUploadReasonByKey.get(key) ??
-                                notUploadableAttributionStateReason(result.reason),
-                        }),
-        };
-    });
+                    : {
+                        // BLI-3272: the upload policy refused this session's
+                        // attribution state. That refusal used to spread `{}` here, so
+                        // the row landed with upload_state NULL and upload_reason NULL
+                        // — a withhold that named nothing, on 1,256 production
+                        // sessions. It is a decision like any other and it says so.
+                        // Any reason the pipeline did record still wins: it is the more
+                        // specific answer.
+                        upload_state: "not_uploaded",
+                        upload_reason: context.noUploadReasonByKey.get(key) ??
+                            notUploadableAttributionStateReason(result.reason),
+                    }),
+    };
+}
+/**
+ * Generalizes the per-session report across sources. Dedupe is per
+ * `(source, session_id)` so a Codex session and a Claude session that happen to
+ * share an id are never collapsed. Upload state maps ONLY from the main-file
+ * outcome (kind `codex_jsonl` / `claude_jsonl`); sidecar outcomes never set a
+ * session's upload state (D3). Damped Claude sessions report `reused_existing`
+ * carrying their prior durable pointer.
+ *
+ * The pass, named: pick the best-ranked result per session
+ * (`bestAttributedSessionsByKey`), read back what this sync actually uploaded
+ * (`sessionUploadOutcomesByKey`), then render one report row per session
+ * (`sessionReportEntry`).
+ */
+export function buildAgentSessionReport(options) {
+    const bestByKey = bestAttributedSessionsByKey(options.codexResults, options.claudeResults);
+    const uploadOutcomes = sessionUploadOutcomesByKey(options.outcomes);
+    return [...bestByKey.values()].map((result) => sessionReportEntry(result, {
+        ...uploadOutcomes,
+        claudePriorDurablePointers: options.claudePriorDurablePointers,
+        now: options.now,
+    }));
+}
+/**
+ * Record this sync's Codex session observations into the Codex cursor and
+ * return the stale count. Best-effort by design: a broken local state dir
+ * must not turn an already-completed sync into a CLI crash, so a failure here
+ * only logs — the stale count simply keeps whatever value it had when the
+ * failure happened (0 if the read itself failed).
+ *
+ * Reads the cursor fresh from disk right before recording rather than reusing
+ * `priorCursor`, so a concurrent writer's update is not clobbered. Claude's
+ * counterpart does not do this extra read (see
+ * `recordClaudeSessionObservationsForSync`) — a real, intentional asymmetry
+ * kept as-is rather than forced to match.
+ */
+async function recordCodexSessionObservationsForSync(options) {
+    let staleCount = 0;
+    try {
+        const codexCursor = await readRawEvidenceCursor(options.paths);
+        staleCount = recordSourceObservations({
+            cursor: codexCursor,
+            results: options.codexAttribution.results,
+            sessions: options.sessions,
+            source: "codex",
+            sessionIdOf: (result) => result.codex_session_id,
+            now: options.now,
+            priorCursor: options.priorCursor,
+            terminalizeMissingUndurable: options.codexRetryPending &&
+                codexAttributionReadFailureCount(options.codexAttribution) === 0,
+        });
+        codexCursor.updated_at = options.now.toISOString();
+        await writeRawEvidenceCursor(options.paths, codexCursor);
+    }
+    catch (error) {
+        // Best-effort: stale counts read 0 and observations re-record next sync —
+        // which is fine ONCE. A cursor write that keeps failing means the sessions
+        // cursor never advances, every sync re-does the same work, and the only
+        // symptom is a stale count that is permanently zero (BLI-3238).
+        console.error("[session-sync] Codex session observations were not recorded", JSON.stringify({
+            reason: "session_cursor_update_failed",
+            source: "codex",
+            session_count: options.sessions.length,
+            ...describeError(error),
+        }));
+    }
+    return staleCount;
+}
+/**
+ * Record this sync's Claude session observations into the Claude cursor and
+ * return the stale count — the Claude counterpart to
+ * `recordCodexSessionObservationsForSync`. A no-op returning 0 when Claude
+ * collection is disabled, matching the source-scan side's own disabled state.
+ */
+async function recordClaudeSessionObservationsForSync(options) {
+    if (!options.claudeEnabled)
+        return 0;
+    let staleCount = 0;
+    try {
+        staleCount = recordSourceObservations({
+            cursor: options.claudeCursorBefore,
+            results: options.claudeAttribution.results,
+            sessions: options.sessions,
+            source: "claude_code",
+            sessionIdOf: (result) => result.claude_session_id,
+            now: options.now,
+            priorCursor: options.claudeCursorBefore,
+            terminalizeMissingUndurable: options.claudeRetryPending &&
+                claudeAttributionReadFailureCount(options.claudeAttribution) === 0,
+        });
+        options.claudeCursorBefore.updated_at = options.now.toISOString();
+        await writeRawEvidenceCursor(options.paths, options.claudeCursorBefore, {
+            filename: CLAUDE_CURSOR_FILENAME,
+            sessionsOnly: true,
+        });
+    }
+    catch (error) {
+        // Best-effort: a broken Claude cursor must not fail the sync. It must
+        // still say it is broken — otherwise the Claude half of collection
+        // quietly repeats itself forever.
+        console.error("[session-sync] Claude session observations were not recorded", JSON.stringify({
+            reason: "session_cursor_update_failed",
+            source: "claude_code",
+            session_count: options.sessions.length,
+            ...describeError(error),
+        }));
+    }
+    return staleCount;
 }
 /**
  * Records per-source session observations into its cursor and returns the stale

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.34",
+  "version": "0.2.36",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,6 +27,6 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/telemetry-core": "0.1.24"
+    "@bli-cockpit/telemetry-core": "0.1.25"
   }
 }