@bli-cockpit/cli 0.2.48 → 0.2.49

package/dist/commands/session-sync.js

@@ -2,12 +2,15 @@
 // of commands/local.ts so the command runners read as a table of contents; this
 // is the core dual-source (Codex + Claude) scan/attribute/upload/report pass.
 //
-// Behavior-preserving extraction: moved verbatim from local.ts, no logic change.
+// `runAttributedWorktreeSync` is the whole story in nine steps, in the order the
+// pass runs them; everything below it is one of those steps. What a run REPORTS
+// — the per-session rows and the CLI funnel counts — lives next door in
+// `agent-session-report.ts` and is re-exported from here (BLI-3572).
 import os from "node:os";
 import path from "node:path";
 import { getCollectorRuntimePaths, readLocalCollectorConfig, startLocalWorkContext, startLocalWorkContextForAttributedTarget, } from "../local-state.js";
 import { describeError } from "../health-detail.js";
-import { CODEX_SESSION_ATTRIBUTION_STATE_RANK, NO_UPLOAD_ATTEMPT_RECORDED, notUploadableAttributionStateReason, } from "@bli-cockpit/telemetry-core";
+import { buildAgentSessionReport, buildAgentSessionSummary, claudeAttributionReadFailureCount, codexAttributionReadFailureCount, } from "./agent-session-report.js";
 import { flushPendingCodexSessionReports, LocalUploadBlockedError, queueCodexSessionReport, syncLocalAmbientEnvelope, } from "../upload.js";
 import { CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT, CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES, defaultCodexSessionDirs, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
 import { scanAndAttributeClaudeSessions } from "../adapters/claude-attribution.js";
@@ -15,7 +18,10 @@ import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET }
 import { CLAUDE_CURSOR_FILENAME, countStaleSessions, emptyRawEvidenceCursorState, readRawEvidenceCursor, recordSessionObservation, writeRawEvidenceCursor } from "../cursors/raw-evidence-cursor.js";
 import { normalizeCollectionRoots } from "../root-normalization.js";
 import { clearSourceRetryFailure, readLocalUploadSpoolState, recordSourceRetryFailure, } from "../spool/local-spool.js";
-import { isLiveRawEvidenceSyncAttribution, isRawEvidenceUploadableAttributionState, } from "../raw-evidence-attribution-policy.js";
+import { isLiveRawEvidenceSyncAttribution } from "../raw-evidence-attribution-policy.js";
+// What a run reports lives in `agent-session-report.ts`; it is re-exported here
+// because `./session-sync.js` is the address every caller already knows.
+export { ATTRIBUTION_STATE_RANK, buildAgentSessionReport, } from "./agent-session-report.js";
 /**
  * The label used when a sync fails and nothing on the way there said why.
  *
@@ -132,15 +138,6 @@ async function scanClaudeSessionsForSync(options) {
     }
     return scan;
 }
-function codexAttributionReadFailureCount(scan) {
-    return scan.directory_read_failed_count + scan.stat_failed_count;
-}
-function claudeAttributionReadFailureCount(scan) {
-    return (scan.project_dir_read_failed_count +
-        scan.session_stat_failed_count +
-        scan.sidecar_dir_read_failed_count +
-        scan.sidecar_stat_failed_count);
-}
 export function sourceScanRetryReason(source, scan) {
     const reasons = new Set();
     const failure = sourceScanFailureReason(source, scan);
@@ -225,265 +222,516 @@ export function liveSyncTargetWorktrees(discovered, results) {
  * Outside-root sessions remain diagnostic-only. The session row's upload state
  * maps ONLY from the main-file outcome (D3); sidecar outcomes aggregate into
  * CLI counts.
+ *
+ * The order of the steps below IS the contract, and two of them are load
+ * bearing: the session report is queued before either cursor advances, and the
+ * run is judged last, after everything that could have a reason has recorded
+ * one.
  */
 export async function runAttributedWorktreeSync(options) {
     const now = new Date();
     const homeDir = options.homeDir ?? os.homedir();
     const paths = getCollectorRuntimePaths(options.homeDir);
-    const config = await readLocalCollectorConfig(paths).catch(() => null);
+    const plan = await planSyncFromLocalState({
+        paths,
+        now,
+        approvedCollectionRoots: options.collectionRoots,
+    });
+    const scan = await scanAndAttributeBothSources({
+        paths,
+        homeDir,
+        now,
+        worktrees: options.worktrees,
+        plan,
+    });
+    const worktreePass = await syncEveryTargetWorktree({
+        run: options,
+        now,
+        plan,
+        scan,
+    });
+    const sessions = buildAgentSessionReport({
+        codexResults: scan.codexAttribution.results,
+        claudeResults: scan.claudeAttribution.results,
+        outcomes: worktreePass.outcomes,
+        now,
+        claudePriorDurablePointers: worktreePass.claudePriorDurablePointers,
+    });
+    const delivery = await reportSessionsAndAdvanceCursors({
+        run: options,
+        paths,
+        now,
+        plan,
+        scan,
+        sessions,
+        outcomes: worktreePass.outcomes,
+    });
+    const summary = buildAgentSessionSummary({
+        codexAttribution: scan.codexAttribution,
+        claudeAttribution: scan.claudeAttribution,
+        outcomes: worktreePass.outcomes,
+        codexStaleCount: delivery.codexStaleCount,
+        claudeStaleCount: delivery.claudeStaleCount,
+        firstRunBackfill: scan.firstRunBackfill,
+        growthDamped: worktreePass.growthDampedSessionCount,
+        report: delivery.report,
+    });
+    const health = decideSyncHealth({
+        worktreePass,
+        scan,
+        sessions,
+        delivery,
+        collectionRootCount: plan.collectionRoots.length,
+    });
+    return {
+        ok: health.ok,
+        failure_reasons: health.failure_reasons,
+        failure_records: health.failure_records,
+        notice: health.notice,
+        sessions_observed: sessions.length,
+        sessions_outside_root: health.sessions_outside_root,
+        outcomes: worktreePass.outcomes,
+        codexAttribution: scan.codexAttribution,
+        claudeAttribution: scan.claudeAttribution,
+        summary,
+    };
+}
+/**
+ * Read the local state this sync is bound by — config, both cursors, the upload
+ * spool — and turn it into the decisions the rest of the pass reads.
+ *
+ * Every read here degrades on purpose: a missing or corrupt local file becomes
+ * an empty cursor or a null spool, because a collector that cannot read its own
+ * bookkeeping must still collect.
+ */
+async function planSyncFromLocalState(options) {
+    const config = await readLocalCollectorConfig(options.paths).catch(() => null);
     const claudeEnabled = config?.collect_claude_jsonl !== false;
-    const collectionRoots = normalizeCollectionRoots(options.collectionRoots ?? config?.default_repo_paths ?? []);
+    const collectionRoots = normalizeCollectionRoots(options.approvedCollectionRoots ?? config?.default_repo_paths ?? []);
     const [codexCursorBefore, claudeCursorBefore, uploadSpool] = await Promise.all([
-        readRawEvidenceCursor(paths).catch(() => emptyRawEvidenceCursorState()),
+        readRawEvidenceCursor(options.paths).catch(() => emptyRawEvidenceCursorState()),
         claudeEnabled
-            ? readRawEvidenceCursor(paths, {
+            ? readRawEvidenceCursor(options.paths, {
                 filename: CLAUDE_CURSOR_FILENAME,
             }).catch(() => emptyRawEvidenceCursorState())
             : Promise.resolve(emptyRawEvidenceCursorState()),
-        readLocalUploadSpoolState(paths).catch(() => null),
+        readLocalUploadSpoolState(options.paths).catch(() => null),
     ]);
+    // A spooled upload from a CLI old enough not to have recorded its source
+    // could have come from either one, so both sources own it until it clears.
     const legacyRetryPending = Boolean(uploadSpool?.pending_uploads.some((entry) => entry.raw_evidence_file_count > 0 && entry.retry_sources.length === 0));
     const codexSourceRetryPending = sourceScanRetryIsPending(uploadSpool, "codex");
     const claudeSourceRetryPending = sourceScanRetryIsPending(uploadSpool, "claude_code");
-    const codexRetryPending = sourceHasPendingRetries("codex", uploadSpool, legacyRetryPending, codexSourceRetryPending, codexCursorBefore);
-    const claudeRetryPending = claudeEnabled &&
-        sourceHasPendingRetries("claude_code", uploadSpool, legacyRetryPending, claudeSourceRetryPending, claudeCursorBefore);
-    const allHistorySinceMinutes = allLocalHistorySinceMinutes(now);
+    return {
+        claudeEnabled,
+        collectionRoots,
+        codexCursorBefore,
+        claudeCursorBefore,
+        uploadSpool,
+        codexSourceRetryPending,
+        claudeSourceRetryPending,
+        codexRetryPending: sourceHasPendingRetries("codex", uploadSpool, legacyRetryPending, codexSourceRetryPending, codexCursorBefore),
+        claudeRetryPending: claudeEnabled &&
+            sourceHasPendingRetries("claude_code", uploadSpool, legacyRetryPending, claudeSourceRetryPending, claudeCursorBefore),
+        allHistorySinceMinutes: allLocalHistorySinceMinutes(options.now),
+    };
+}
+/**
+ * Scan and attribute both session sources, then settle each source's scan-retry
+ * bookkeeping against what the scan actually found.
+ *
+ * Codex first, Claude second, and Claude's first-run window is decided between
+ * them because it depends on whether the Claude cursor file exists yet.
+ */
+async function scanAndAttributeBothSources(options) {
+    const { plan } = options;
     const codexAttribution = await scanCodexSessionsForSync({
-        homeDir,
+        homeDir: options.homeDir,
         worktrees: options.worktrees,
-        now,
-        collectionRoots,
-        retryPending: codexRetryPending,
-        allHistorySinceMinutes,
+        now: options.now,
+        collectionRoots: plan.collectionRoots,
+        retryPending: plan.codexRetryPending,
+        allHistorySinceMinutes: plan.allHistorySinceMinutes,
     });
     // 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;
+    const claudeCursorExists = await fileExists(path.join(options.paths.cursors_dir, CLAUDE_CURSOR_FILENAME));
+    const firstRunBackfill = plan.claudeEnabled && !claudeCursorExists;
     const claudeAttribution = await scanClaudeSessionsForSync({
-        claudeEnabled,
-        homeDir,
+        claudeEnabled: plan.claudeEnabled,
+        homeDir: options.homeDir,
         worktrees: options.worktrees,
-        now,
-        collectionRoots,
-        retryPending: claudeRetryPending,
-        allHistorySinceMinutes,
+        now: options.now,
+        collectionRoots: plan.collectionRoots,
+        retryPending: plan.claudeRetryPending,
+        allHistorySinceMinutes: plan.allHistorySinceMinutes,
         firstRunBackfill,
     });
     await reconcileSourceScanRetry({
-        paths,
+        paths: options.paths,
         source: "codex",
-        attemptedAt: now.toISOString(),
-        pendingBefore: codexSourceRetryPending,
+        attemptedAt: options.now.toISOString(),
+        pendingBefore: plan.codexSourceRetryPending,
         reason: sourceScanRetryReason("codex", codexAttribution),
     });
-    if (claudeEnabled) {
+    if (plan.claudeEnabled) {
         await reconcileSourceScanRetry({
-            paths,
+            paths: options.paths,
             source: "claude_code",
-            attemptedAt: now.toISOString(),
-            pendingBefore: claudeSourceRetryPending,
+            attemptedAt: options.now.toISOString(),
+            pendingBefore: plan.claudeSourceRetryPending,
             reason: sourceScanRetryReason("claude_code", claudeAttribution),
         });
     }
-    const syncWorktrees = liveSyncTargetWorktrees(options.worktrees, [
-        ...codexAttribution.results,
-        ...claudeAttribution.results,
+    return { codexAttribution, claudeAttribution, firstRunBackfill };
+}
+/**
+ * Sync every worktree this tick is responsible for, in order, under one shared
+ * raw-evidence budget.
+ *
+ * The budget is per-sync (D7b), not per-worktree: a parent-folder sync over
+ * many worktrees honors a single byte/object cap rather than N times it.
+ */
+async function syncEveryTargetWorktree(options) {
+    const { run, scan } = options;
+    const syncWorktrees = liveSyncTargetWorktrees(run.worktrees, [
+        ...scan.codexAttribution.results,
+        ...scan.claudeAttribution.results,
     ]);
-    const discoveredWorktreeKeys = new Set(options.worktrees.map(liveSyncTargetKey));
+    const discoveredWorktreeKeys = new Set(run.worktrees.map(liveSyncTargetKey));
     // sessionId -> prior durable pointer for damped sessions (drives the
     // growth_damped count + the skip_main decision).
     const dampedClaudePointers = new Map();
-    // sessionId -> prior durable pointer for EVERY already-durable Claude session
-    // (superset of damped). A session that was durable before but had no fresh
-    // upload this sync (damped, spooled, budget-deferred) reports reused_existing
-    // with this pointer instead of not_uploaded, so the store row never flips.
-    const claudePriorDurablePointers = new Map();
-    for (const [sessionId, entry] of Object.entries(claudeCursorBefore.sessions)) {
-        if (entry.uploaded_object_key) {
-            claudePriorDurablePointers.set(sessionId, entry.uploaded_object_key);
-        }
-    }
-    // One shared budget for the whole sync (D7b is per-sync): a parent-folder
-    // sync over many worktrees honors a single byte/object cap rather than N×.
     const rawEvidenceBudget = {
         remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET,
         remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET,
     };
     const outcomes = [];
-    let ok = true;
+    let everyWorktreeUploaded = true;
     for (const worktree of syncWorktrees) {
-        const attributedSyntheticTarget = discoveredWorktreeKeys.has(liveSyncTargetKey(worktree))
-            ? null
-            : worktree;
-        const contextOptions = {
-            homeDir: options.homeDir,
-            repoRoot: worktree.repo_root,
-            activeTicketId: options.activeTicketId,
-            operatorId: options.operatorId,
-            sessionId: options.sessionId,
-            ...(attributedSyntheticTarget ? {} : { branch: options.branch }),
-        };
-        const ensureContext = () => attributedSyntheticTarget
-            ? startLocalWorkContextForAttributedTarget(contextOptions, attributedSyntheticTarget)
-            : startLocalWorkContext(contextOptions);
-        let context = null;
-        if (options.startContexts || attributedSyntheticTarget) {
-            context = await ensureContext();
-        }
-        const claudeSessionFiles = claudeAttribution.results
-            .filter((result) => matchesLiveSyncWorktree(result, worktree))
-            .map((result) => {
-            const damped = !result.main_file_oversized &&
-                shouldDampClaudeMain(result, claudeCursorBefore, now);
-            if (damped) {
-                dampedClaudePointers.set(result.claude_session_id, claudeCursorBefore.sessions[result.claude_session_id]
-                    ?.uploaded_object_key ?? null);
-            }
-            return {
-                local_path: result.file_path,
-                claude_session_id: result.claude_session_id,
-                main_file_oversized: result.main_file_oversized,
-                skip_main: damped,
-                sidecar_files: result.sidecar_files
-                    .filter((sidecar) => !sidecar.skipped_reason)
-                    .map((sidecar) => ({ local_path: sidecar.local_path })),
-            };
-        });
-        const syncOptions = {
-            homeDir: options.homeDir,
-            repoRoot: worktree.repo_root,
-            dashboardUrl: options.dashboardUrl,
-            worktreeInventory: worktreeInventoryForRepo(worktree, syncWorktrees),
-            codexSessionFiles: codexAttribution.results
-                .filter((result) => matchesLiveSyncWorktree(result, worktree))
-                .map((result) => ({
-                local_path: result.file_path,
-                codex_session_id: result.codex_session_id,
-            })),
-            codexAttributionScan: codexAttribution,
-            claudeSessionFiles,
-            claudeAttributionScan: claudeAttribution,
+        const outcome = await syncOneWorktree({
+            run,
+            now: options.now,
+            plan: options.plan,
+            scan,
+            worktree,
+            syncWorktrees,
             rawEvidenceBudget,
-            fetch: options.fetchImpl,
-        };
-        let sync;
-        try {
+            // A target git discovery never produced is one the fallback attribution
+            // synthesized, and it syncs through its own attributed work context.
+            isDiscoveredWorktree: discoveredWorktreeKeys.has(liveSyncTargetKey(worktree)),
+            recordDampedClaudeSession: (sessionId, priorPointer) => {
+                dampedClaudePointers.set(sessionId, priorPointer);
+            },
+        });
+        everyWorktreeUploaded =
+            everyWorktreeUploaded && outcome.sync.status === "uploaded";
+        outcomes.push(outcome);
+    }
+    return {
+        outcomes,
+        everyWorktreeUploaded,
+        claudePriorDurablePointers: claudeDurablePointersFromCursor(options.plan.claudeCursorBefore),
+        growthDampedSessionCount: dampedClaudePointers.size,
+    };
+}
+/** Every Claude session the cursor already holds a durable pointer for. */
+function claudeDurablePointersFromCursor(claudeCursorBefore) {
+    const pointersBySessionId = new Map();
+    for (const [sessionId, entry] of Object.entries(claudeCursorBefore.sessions)) {
+        if (entry.uploaded_object_key) {
+            pointersBySessionId.set(sessionId, entry.uploaded_object_key);
+        }
+    }
+    return pointersBySessionId;
+}
+/**
+ * Sync one worktree's attributed transcripts, starting a work context first
+ * when this target needs one.
+ *
+ * A newly cloned repo has no work context yet. Capture is permissive and ticket
+ * binding comes later, so a `missing_context` refusal starts general ambient
+ * capture for that repo and retries, instead of blocking every other repo's
+ * sync until someone runs `cockpit start` by hand.
+ */
+async function syncOneWorktree(options) {
+    const { run, worktree } = options;
+    const attributedSyntheticTarget = options.isDiscoveredWorktree
+        ? null
+        : worktree;
+    const contextOptions = {
+        homeDir: run.homeDir,
+        repoRoot: worktree.repo_root,
+        activeTicketId: run.activeTicketId,
+        operatorId: run.operatorId,
+        sessionId: run.sessionId,
+        ...(attributedSyntheticTarget ? {} : { branch: run.branch }),
+    };
+    const ensureContext = () => attributedSyntheticTarget
+        ? startLocalWorkContextForAttributedTarget(contextOptions, attributedSyntheticTarget)
+        : startLocalWorkContext(contextOptions);
+    let context = null;
+    if (run.startContexts || attributedSyntheticTarget) {
+        context = await ensureContext();
+    }
+    const syncOptions = ambientEnvelopeForWorktree(options);
+    let sync;
+    try {
+        sync = await syncLocalAmbientEnvelope(syncOptions);
+    }
+    catch (error) {
+        if (error instanceof LocalUploadBlockedError &&
+            error.blocker === "missing_context") {
+            context = await ensureContext();
             sync = await syncLocalAmbientEnvelope(syncOptions);
         }
-        catch (error) {
-            // A newly cloned repo has no work context yet. Capture is permissive
-            // and ticket binding comes later, so start general ambient capture for
-            // it instead of blocking every other repo's sync until someone runs
-            // `cockpit start` by hand.
-            if (error instanceof LocalUploadBlockedError &&
-                error.blocker === "missing_context") {
-                context = await ensureContext();
-                sync = await syncLocalAmbientEnvelope(syncOptions);
-            }
-            else {
-                throw error;
-            }
+        else {
+            throw error;
         }
-        ok = ok && sync.status === "uploaded";
-        outcomes.push({ worktree, context, sync });
     }
-    const sessions = buildAgentSessionReport({
-        codexResults: codexAttribution.results,
-        claudeResults: claudeAttribution.results,
-        outcomes,
-        now,
-        claudePriorDurablePointers,
+    return { worktree, context, sync };
+}
+/**
+ * Assemble what one worktree is about to upload: its sibling worktree
+ * inventory, its Codex mains, its Claude mains and sidecars, and its share of
+ * the sync-wide raw-evidence budget.
+ */
+function ambientEnvelopeForWorktree(options) {
+    const { run, worktree, scan } = options;
+    const claudeSessionFiles = claudeSessionFilesForWorktree({
+        worktree,
+        claudeResults: scan.claudeAttribution.results,
+        claudeCursorBefore: options.plan.claudeCursorBefore,
+        now: options.now,
+        recordDampedClaudeSession: options.recordDampedClaudeSession,
     });
-    // Persist the metadata-only report before advancing either source cursor.
-    // If the process exits after this point, the spool keeps an exact retry copy.
-    // If queueing itself fails, the cursors remain at their prior retryable
-    // positions instead of aging an unreported session out of the live window.
-    const firstUploaded = outcomes.find((outcome) => outcome.sync.status === "uploaded");
-    const hadPendingSessionReports = (uploadSpool?.pending_session_reports.length ?? 0) > 0;
-    let queuedCurrentSessionReport = false;
-    if (firstUploaded && sessions.length > 0) {
-        const queued = await queueCodexSessionReport({
-            homeDir: options.homeDir,
-            dashboardUrl: firstUploaded.sync.dashboard_url,
-            generatedAt: now.toISOString(),
-            workContextId: firstUploaded.sync.work_context_id,
-            repoLabel: firstUploaded.worktree.repo_label,
-            branch: firstUploaded.worktree.branch,
-            repoFingerprint: firstUploaded.worktree.repo_fingerprint,
-            repoOriginUrl: firstUploaded.worktree.repo_origin_url,
-            worktreeLabel: firstUploaded.worktree.worktree_label,
-            worktreeFingerprint: firstUploaded.worktree.worktree_fingerprint,
-            worktreeIsPrimary: firstUploaded.worktree.worktree_is_primary,
-            sessions,
-        });
-        queuedCurrentSessionReport = Boolean(queued);
-    }
-    const reportRequired = sessions.length > 0 ||
-        hadPendingSessionReports ||
-        queuedCurrentSessionReport;
-    // The sessions cursor is an optimization; a broken local state dir must not
-    // turn already-completed syncs into a CLI crash.
+    return {
+        homeDir: run.homeDir,
+        repoRoot: worktree.repo_root,
+        dashboardUrl: run.dashboardUrl,
+        worktreeInventory: worktreeInventoryForRepo(worktree, options.syncWorktrees),
+        codexSessionFiles: scan.codexAttribution.results
+            .filter((result) => matchesLiveSyncWorktree(result, worktree))
+            .map((result) => ({
+            local_path: result.file_path,
+            codex_session_id: result.codex_session_id,
+        })),
+        codexAttributionScan: scan.codexAttribution,
+        claudeSessionFiles,
+        claudeAttributionScan: scan.claudeAttribution,
+        rawEvidenceBudget: options.rawEvidenceBudget,
+        fetch: run.fetchImpl,
+    };
+}
+/**
+ * This worktree's Claude mains and sidecars, with the growth damper applied.
+ *
+ * A damped main is still reported — `skip_main` means "do not re-upload the
+ * body this tick", not "forget this session" — and its prior durable pointer is
+ * recorded so the session report can say `reused_existing` instead of flipping
+ * the row to not_uploaded.
+ */
+function claudeSessionFilesForWorktree(options) {
+    return options.claudeResults
+        .filter((result) => matchesLiveSyncWorktree(result, options.worktree))
+        .map((result) => {
+        const damped = !result.main_file_oversized &&
+            shouldDampClaudeMain(result, options.claudeCursorBefore, options.now);
+        if (damped) {
+            options.recordDampedClaudeSession(result.claude_session_id, options.claudeCursorBefore.sessions[result.claude_session_id]
+                ?.uploaded_object_key ?? null);
+        }
+        return {
+            local_path: result.file_path,
+            claude_session_id: result.claude_session_id,
+            main_file_oversized: result.main_file_oversized,
+            skip_main: damped,
+            sidecar_files: result.sidecar_files
+                .filter((sidecar) => !sidecar.skipped_reason)
+                .map((sidecar) => ({ local_path: sidecar.local_path })),
+        };
+    });
+}
+/**
+ * Report this tick's sessions and advance both cursors — in that order, which
+ * is the load-bearing part.
+ *
+ * The report is queued to the spool BEFORE either cursor moves. If the process
+ * exits in between, the spool keeps an exact retry copy; if queueing itself
+ * fails, the cursors stay at their prior retryable positions instead of aging
+ * an unreported session out of the live window.
+ */
+async function reportSessionsAndAdvanceCursors(options) {
+    const hadPendingSessionReports = (options.plan.uploadSpool?.pending_session_reports.length ?? 0) > 0;
+    const queuedCurrentSessionReport = await queueSessionReportForDelivery({
+        homeDir: options.run.homeDir,
+        outcomes: options.outcomes,
+        sessions: options.sessions,
+        now: options.now,
+    });
+    const staleCounts = await recordBothSourceCursorObservations({
+        paths: options.paths,
+        plan: options.plan,
+        scan: options.scan,
+        sessions: options.sessions,
+        now: options.now,
+    });
+    const report = await deliverOrExplainSessionReport({
+        hadPendingSessionReports,
+        queuedCurrentSessionReport,
+        sessionCount: options.sessions.length,
+        homeDir: options.run.homeDir,
+        fetchImpl: options.run.fetchImpl,
+        now: options.now,
+    });
+    return {
+        report,
+        reportRequired: options.sessions.length > 0 ||
+            hadPendingSessionReports ||
+            queuedCurrentSessionReport,
+        ...staleCounts,
+    };
+}
+/**
+ * Persist the metadata-only session report to the spool, before either source
+ * cursor advances.
+ *
+ * If the process exits after this point, the spool keeps an exact retry copy.
+ * If queueing itself fails, the cursors remain at their prior retryable
+ * positions instead of aging an unreported session out of the live window.
+ * Returns whether a report for THIS tick was queued.
+ */
+async function queueSessionReportForDelivery(options) {
+    const firstUploaded = options.outcomes.find((outcome) => outcome.sync.status === "uploaded");
+    if (!firstUploaded || options.sessions.length === 0)
+        return false;
+    const queued = await queueCodexSessionReport({
+        homeDir: options.homeDir,
+        dashboardUrl: firstUploaded.sync.dashboard_url,
+        generatedAt: options.now.toISOString(),
+        workContextId: firstUploaded.sync.work_context_id,
+        repoLabel: firstUploaded.worktree.repo_label,
+        branch: firstUploaded.worktree.branch,
+        repoFingerprint: firstUploaded.worktree.repo_fingerprint,
+        repoOriginUrl: firstUploaded.worktree.repo_origin_url,
+        worktreeLabel: firstUploaded.worktree.worktree_label,
+        worktreeFingerprint: firstUploaded.worktree.worktree_fingerprint,
+        worktreeIsPrimary: firstUploaded.worktree.worktree_is_primary,
+        sessions: options.sessions,
+    });
+    return Boolean(queued);
+}
+/**
+ * Advance both source cursors to what this tick observed.
+ *
+ * The sessions cursor is an optimization; a broken local state dir must not
+ * turn an already-completed sync into a CLI crash, so each side is best-effort
+ * and names its own failure.
+ */
+async function recordBothSourceCursorObservations(options) {
     const codexStaleCount = await recordCodexSessionObservationsForSync({
-        paths,
-        codexAttribution,
-        sessions,
-        now,
-        priorCursor: codexCursorBefore,
-        codexRetryPending,
+        paths: options.paths,
+        codexAttribution: options.scan.codexAttribution,
+        sessions: options.sessions,
+        now: options.now,
+        priorCursor: options.plan.codexCursorBefore,
+        codexRetryPending: options.plan.codexRetryPending,
     });
     const claudeStaleCount = await recordClaudeSessionObservationsForSync({
-        claudeEnabled,
-        paths,
-        claudeAttribution,
-        sessions,
-        now,
-        claudeCursorBefore,
-        claudeRetryPending,
+        claudeEnabled: options.plan.claudeEnabled,
+        paths: options.paths,
+        claudeAttribution: options.scan.claudeAttribution,
+        sessions: options.sessions,
+        now: options.now,
+        claudeCursorBefore: options.plan.claudeCursorBefore,
+        claudeRetryPending: options.plan.claudeRetryPending,
     });
-    const report = hadPendingSessionReports || queuedCurrentSessionReport
-        ? await flushPendingCodexSessionReports({
-            homeDir: options.homeDir,
-            fetch: options.fetchImpl,
-            now,
-        })
-        : {
+    return { codexStaleCount, claudeStaleCount };
+}
+/**
+ * Flush the queued session reports — or, when there is nothing queued, say why
+ * nothing was posted instead of returning a bare false.
+ */
+async function deliverOrExplainSessionReport(options) {
+    if (!options.hadPendingSessionReports && !options.queuedCurrentSessionReport) {
+        return {
             posted: false,
-            reason: sessions.length === 0 ? "no_sessions_observed" : "no_successful_sync",
+            reason: options.sessionCount === 0
+                ? "no_sessions_observed"
+                : "no_successful_sync",
         };
-    const summary = buildAgentSessionSummary({
-        codexAttribution,
-        claudeAttribution,
+    }
+    return flushPendingCodexSessionReports({
+        homeDir: options.homeDir,
+        fetch: options.fetchImpl,
+        now: options.now,
+    });
+}
+/**
+ * Decide whether this tick failed, and record every condition that decided it.
+ *
+ * This used to be one boolean chain: correct, and completely mute — a failed
+ * sync exited 1 saying only `sync_failed` (BLI-2526). The conditions are the
+ * same; they now write down what they decided, each beside the closed-registry
+ * LABEL the health receipt is classified by (BLI-3551). Nothing parses the
+ * rendered sentence back apart.
+ */
+function decideSyncHealth(options) {
+    const { outcomes } = options.worktreePass;
+    const report = options.delivery.report;
+    const ledger = createSyncFailureLedger();
+    recordWorktreeDeliveryFailures(ledger, outcomes);
+    recordSourceScanFailures(ledger, options.scan.codexAttribution, options.scan.claudeAttribution);
+    const sessionsOutsideRoot = options.sessions.filter((session) => OUTSIDE_APPROVED_ROOT_REASONS.has(session.attribution_reason)).length;
+    const nothingInRoot = nothingInRootCount({
+        sessionCount: options.sessions.length,
+        outsideRootCount: sessionsOutsideRoot,
         outcomes,
-        codexStaleCount,
-        claudeStaleCount,
-        firstRunBackfill,
-        growthDamped: dampedClaudePointers.size,
-        report,
+        reportPosted: report.posted,
+        reportReason: report.reason,
     });
-    // Same conditions as before, one per line, each writing down its own reason.
-    // The old version was a single boolean chain: correct, and completely mute.
-    //
-    // Since BLI-3551 each condition also writes down the LABEL it is classified
-    // by, beside the rendered string a person reads. The health receipt reads the
-    // label; nothing parses the sentence back apart.
-    const failureRecords = new Map();
-    const add = (record) => {
-        if (!failureRecords.has(record.rendered)) {
-            failureRecords.set(record.rendered, record);
-        }
-    };
-    const fail = (condition, label, rendered = label) => {
-        if (condition)
-            add({ label, rendered });
+    // BLI-3551: a tick that observed only sessions from outside the operator's
+    // approved roots has nothing to post, and that is the consent boundary
+    // working — not a failure. It used to fail as
+    // `session_report_unposted:no_successful_sync`, whose word "session" then
+    // classified as `auth_failed`; one machine reported a broken credential 377
+    // times in 38 hours while its token had eleven weeks left. The withhold
+    // decision itself is untouched (adapters/attribution-core.ts) — only what it
+    // is CALLED.
+    ledger.fail(options.delivery.reportRequired && !report.posted && nothingInRoot === null, "session_report_unposted", `session_report_unposted:${report.reason ?? "unknown"}`);
+    // `everyWorktreeUploaded` may already be false; the delivery recorder above
+    // re-derives that from the same outcomes, so the two agree by construction.
+    const ok = options.worktreePass.everyWorktreeUploaded && ledger.isEmpty();
+    if (!ok && ledger.isEmpty()) {
+        ledger.add({
+            label: SYNC_FAILED_WITHOUT_REASON,
+            rendered: SYNC_FAILED_WITHOUT_REASON,
+        });
+    }
+    const notice = ok && nothingInRoot !== null ? `nothing_in_root:${nothingInRoot}` : null;
+    if (nothingInRoot !== null && notice) {
+        announceNothingInRoot(nothingInRoot, options.collectionRootCount);
+    }
+    const records = ledger.sortedRecords();
+    return {
+        ok,
+        failure_reasons: records.map((record) => record.rendered),
+        failure_records: records,
+        notice,
+        sessions_outside_root: sessionsOutsideRoot,
     };
+}
+/**
+ * Every worktree that did not finish, and every raw-evidence gap it reported.
+ *
+ * The spooled reason is the most specific thing anyone has, so it leads, and it
+ * names the worktree it belongs to — a fleet failure is usually one repo, and
+ * "which one" is the first question asked.
+ */
+function recordWorktreeDeliveryFailures(ledger, outcomes) {
     for (const { worktree, sync } of outcomes) {
         if (sync.status !== "uploaded") {
-            // The spooled reason is the most specific thing anyone has, so lead with
-            // it and name the worktree it belongs to — a fleet failure is usually one
-            // repo, and "which one" is the first question asked.
-            add(sync.status === "spooled" && sync.failure_reason
+            ledger.add(sync.status === "spooled" && sync.failure_reason
                 ? {
                     label: sync.failure_class,
                     rendered: `${worktree.worktree_label}:${sync.failure_reason}`,
@@ -495,91 +743,80 @@ export async function runAttributedWorktreeSync(options) {
                 });
         }
         for (const reason of sync.raw_evidence_failure_reasons ?? []) {
-            add({
+            ledger.add({
                 label: "raw_evidence_upload_failed",
                 rendered: `raw_evidence:${reason}`,
             });
         }
         for (const reason of sync.raw_evidence_retry_reasons ?? []) {
-            add({
+            ledger.add({
                 label: "raw_evidence_retry_required",
                 rendered: `raw_evidence_retry:${reason}`,
             });
         }
-        fail(sync.raw_evidence_deferred_byte_budget > 0, "deferred_byte_budget");
-        fail(sync.raw_evidence_deferred_object_budget > 0, "deferred_object_budget");
+        ledger.fail(sync.raw_evidence_deferred_byte_budget > 0, "deferred_byte_budget");
+        ledger.fail(sync.raw_evidence_deferred_object_budget > 0, "deferred_object_budget");
     }
-    fail(codexAttribution.session_limit_applied, "codex_session_limit_applied");
-    fail(claudeAttribution.session_limit_applied, "claude_session_limit_applied");
-    fail(codexAttributionReadFailureCount(codexAttribution) > 0, "codex_session_read_failed");
-    fail(claudeAttributionReadFailureCount(claudeAttribution) > 0, "claude_session_read_failed");
-    // BLI-3551: the scan's RETRY reason and the scan's FAILURE reason are two
-    // different questions, and answering both with one function is what put
-    // `claude_scan:repo_not_on_disk` on every tick of three machines. A repo that
-    // is not on disk is a label on the session (the attribution umbrella finding:
-    // nothing was deleted, the transcript simply names a path git no longer
-    // knows). It still widens the next scan window; it is not a failed sync.
+}
+/**
+ * What the scan itself got wrong: a window that hit its cap, sessions that
+ * could not be read, or a session store that could not be read at all.
+ *
+ * BLI-3551: the scan's RETRY reason and the scan's FAILURE reason are two
+ * different questions, and answering both with one function is what put
+ * `claude_scan:repo_not_on_disk` on every tick of three machines. A repo that
+ * is not on disk is a label on the session (the attribution umbrella finding:
+ * nothing was deleted, the transcript simply names a path git no longer
+ * knows). It still widens the next scan window; it is not a failed sync.
+ */
+function recordSourceScanFailures(ledger, codexAttribution, claudeAttribution) {
+    ledger.fail(codexAttribution.session_limit_applied, "codex_session_limit_applied");
+    ledger.fail(claudeAttribution.session_limit_applied, "claude_session_limit_applied");
+    ledger.fail(codexAttributionReadFailureCount(codexAttribution) > 0, "codex_session_read_failed");
+    ledger.fail(claudeAttributionReadFailureCount(claudeAttribution) > 0, "claude_session_read_failed");
     const codexScanFailure = sourceScanFailureReason("codex", codexAttribution);
     if (codexScanFailure) {
-        add({ label: "codex_scan_read_failed", rendered: `codex_scan:${codexScanFailure}` });
+        ledger.add({
+            label: "codex_scan_read_failed",
+            rendered: `codex_scan:${codexScanFailure}`,
+        });
     }
     const claudeScanFailure = sourceScanFailureReason("claude_code", claudeAttribution);
     if (claudeScanFailure) {
-        add({
+        ledger.add({
             label: "claude_scan_read_failed",
             rendered: `claude_scan:${claudeScanFailure}`,
         });
     }
-    // BLI-3551: a tick that observed only sessions from outside the operator's
-    // approved roots has nothing to post, and that is the consent boundary
-    // working — not a failure. It used to fail as
-    // `session_report_unposted:no_successful_sync`, whose word "session" then
-    // classified as `auth_failed`; one machine reported a broken credential 377
-    // times in 38 hours while its token had eleven weeks left. The withhold
-    // decision itself is untouched (adapters/attribution-core.ts) — only what it
-    // is CALLED.
-    const sessionsOutsideRoot = sessions.filter((session) => OUTSIDE_APPROVED_ROOT_REASONS.has(session.attribution_reason)).length;
-    const nothingInRoot = nothingInRootCount({
-        sessionCount: sessions.length,
-        outsideRootCount: sessionsOutsideRoot,
-        outcomes,
-        reportPosted: report.posted,
-        reportReason: report.reason,
-    });
-    fail(reportRequired && !report.posted && nothingInRoot === null, "session_report_unposted", `session_report_unposted:${report.reason ?? "unknown"}`);
-    // `ok` may already be false from the per-worktree loop above; the outcome
-    // scan re-derives that, so the two agree by construction.
-    ok = ok && failureRecords.size === 0;
-    if (!ok && failureRecords.size === 0) {
-        add({
-            label: SYNC_FAILED_WITHOUT_REASON,
-            rendered: SYNC_FAILED_WITHOUT_REASON,
-        });
-    }
-    const notice = ok && nothingInRoot !== null ? `nothing_in_root:${nothingInRoot}` : null;
-    if (notice) {
-        // The success branch says something too: this is the receipt that proves a
-        // quiet machine is a working machine, and the count is what tells a coach
-        // that someone is working entirely outside the approved boundary.
-        console.error("[session-sync] nothing to collect inside the approved roots", JSON.stringify({
-            reason: "nothing_in_root",
-            sessions_outside_root: nothingInRoot,
-            collection_root_count: collectionRoots.length,
-            next_action: "widen the approved roots (an operator decision) if this machine should be collecting here",
-        }));
-    }
-    const records = [...failureRecords.values()].sort((a, b) => a.rendered.localeCompare(b.rendered));
-    return {
-        ok,
-        failure_reasons: records.map((record) => record.rendered),
-        failure_records: records,
-        notice,
-        sessions_observed: sessions.length,
+}
+/**
+ * The success branch says something too: this is the receipt that proves a
+ * quiet machine is a working machine, and the count is what tells a coach that
+ * someone is working entirely outside the approved boundary.
+ */
+function announceNothingInRoot(sessionsOutsideRoot, collectionRootCount) {
+    console.error("[session-sync] nothing to collect inside the approved roots", JSON.stringify({
+        reason: "nothing_in_root",
         sessions_outside_root: sessionsOutsideRoot,
-        outcomes,
-        codexAttribution,
-        claudeAttribution,
-        summary,
+        collection_root_count: collectionRootCount,
+        next_action: "widen the approved roots (an operator decision) if this machine should be collecting here",
+    }));
+}
+function createSyncFailureLedger() {
+    const recordsByRenderedReason = new Map();
+    const add = (record) => {
+        if (!recordsByRenderedReason.has(record.rendered)) {
+            recordsByRenderedReason.set(record.rendered, record);
+        }
+    };
+    return {
+        add,
+        fail(condition, label, rendered = label) {
+            if (condition)
+                add({ label, rendered });
+        },
+        isEmpty: () => recordsByRenderedReason.size === 0,
+        sortedRecords: () => [...recordsByRenderedReason.values()].sort((a, b) => a.rendered.localeCompare(b.rendered)),
     };
 }
 /**
@@ -617,209 +854,6 @@ export function nothingInRootCount(options) {
         ? options.outsideRootCount
         : null;
 }
-export const ATTRIBUTION_STATE_RANK = CODEX_SESSION_ATTRIBUTION_STATE_RANK;
-function normalizeCodexResult(result) {
-    return {
-        source: "codex",
-        session_id: result.codex_session_id,
-        state: result.state,
-        reason: result.reason,
-        signals: result.signals,
-        attribution_score: result.attribution_score,
-        path_score: result.path_score,
-        content_hash_sha256: result.content_hash_sha256,
-        byte_size: result.byte_size,
-        session_file_mtime: result.session_file_mtime,
-        session_file_mtime_ms: result.session_file_mtime_ms,
-        worktree: result.worktree,
-        cwd_basename: result.cwd_basename,
-        cwd_hash: result.cwd_hash,
-    };
-}
-function normalizeClaudeResult(result) {
-    return {
-        source: "claude_code",
-        session_id: result.claude_session_id,
-        state: result.state,
-        reason: result.reason,
-        signals: result.signals,
-        attribution_score: result.attribution_score,
-        path_score: result.path_score,
-        content_hash_sha256: result.content_hash_sha256,
-        byte_size: result.byte_size,
-        session_file_mtime: result.session_file_mtime,
-        session_file_mtime_ms: result.session_file_mtime_ms,
-        worktree: result.worktree,
-        cwd_basename: result.cwd_basename,
-        cwd_hash: result.cwd_hash,
-    };
-}
-/**
- * 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.
- */
-function bestAttributedSessionsByKey(codexResults, claudeResults) {
-    const normalized = [
-        ...codexResults.map(normalizeCodexResult),
-        ...claudeResults.map(normalizeClaudeResult),
-    ];
-    const bestByKey = new Map();
-    for (const result of normalized) {
-        const key = `${result.source}:${result.session_id}`;
-        const existing = bestByKey.get(key);
-        if (!existing ||
-            (ATTRIBUTION_STATE_RANK[result.state] ?? 0) >
-                (ATTRIBUTION_STATE_RANK[existing.state] ?? 0) ||
-            ((ATTRIBUTION_STATE_RANK[result.state] ?? 0) ===
-                (ATTRIBUTION_STATE_RANK[existing.state] ?? 0) &&
-                result.session_file_mtime_ms > existing.session_file_mtime_ms)) {
-            bestByKey.set(key, result);
-        }
-    }
-    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();
-    const noUploadReasonByKey = new Map();
-    let anySyncIncomplete = false;
-    for (const outcome of outcomes) {
-        if (outcome.sync.status !== "uploaded") {
-            anySyncIncomplete = true;
-            continue;
-        }
-        for (const upload of outcome.sync.raw_evidence_outcomes) {
-            if (!upload.codex_session_id)
-                continue;
-            const source = upload.kind === "claude_jsonl"
-                ? "claude_code"
-                : upload.kind === "codex_jsonl"
-                    ? "codex"
-                    : null;
-            if (!source)
-                continue; // sidecars and other kinds do not set session state
-            const key = `${source}:${upload.codex_session_id}`;
-            if (!upload.raw_evidence_pointer_id) {
-                // An outcome with no pointer is a failure that named itself. Keep the
-                // reason even though there is nothing to point at.
-                if (upload.reason)
-                    noUploadReasonByKey.set(key, upload.reason);
-                continue;
-            }
-            uploadByKey.set(key, 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: priorDurablePointer,
-                    upload_state: "reused_existing",
-                }
-                : 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: context.noUploadReasonByKey.get(key) ??
-                            (context.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: 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
@@ -988,61 +1022,6 @@ function shouldDampClaudeMain(result, cursor, now) {
         Number.isFinite(ageMs) &&
         ageMs <= CLAUDE_DAMP_MAX_AGE_MS);
 }
-function buildAgentSessionSummary(options) {
-    const sidecarOutcomes = options.outcomes.flatMap((outcome) => outcome.sync.raw_evidence_outcomes.filter((upload) => upload.kind === "claude_jsonl_sidecar"));
-    const attributedClaude = options.claudeAttribution.results.filter((result) => isLiveRawEvidenceSyncAttribution(result.state, result.reason));
-    const sidecarsCollected = attributedClaude.reduce((total, result) => total +
-        result.sidecar_files.filter((sidecar) => !sidecar.skipped_reason).length, 0);
-    const sidecarsSkipped = options.claudeAttribution.results.reduce((total, result) => total +
-        result.sidecar_files.filter((sidecar) => sidecar.skipped_reason).length, 0);
-    const codex = {
-        scanned: options.codexAttribution.scanned_file_count,
-        attributed: options.codexAttribution.counts.attributed,
-        attributed_fallback: options.codexAttribution.counts.attributed_fallback,
-        ambiguous: options.codexAttribution.counts.ambiguous,
-        unattributed: options.codexAttribution.counts.unattributed,
-        skipped: options.codexAttribution.counts.skipped,
-        stale: options.codexStaleCount,
-        read_failures: codexAttributionReadFailureCount(options.codexAttribution),
-    };
-    const claude = {
-        scanned: options.claudeAttribution.scanned_session_count,
-        attributed: options.claudeAttribution.counts.attributed,
-        attributed_fallback: options.claudeAttribution.counts.attributed_fallback,
-        ambiguous: options.claudeAttribution.counts.ambiguous,
-        unattributed: options.claudeAttribution.counts.unattributed,
-        skipped: options.claudeAttribution.counts.skipped,
-        stale: options.claudeStaleCount,
-        read_failures: claudeAttributionReadFailureCount(options.claudeAttribution),
-        sidecars_collected: sidecarsCollected,
-        sidecars_uploaded: sidecarOutcomes.filter((upload) => upload.upload_state === "uploaded" ||
-            upload.upload_state === "reused_existing").length,
-        sidecars_skipped: sidecarsSkipped,
-        sidecars_capped: options.claudeAttribution.counts.sidecars_capped,
-        sidecars_failed: sidecarOutcomes.filter((upload) => upload.upload_state === "upload_failed").length,
-        mains_oversized: options.claudeAttribution.counts.mains_oversized,
-        oversized_lines_skipped: options.claudeAttribution.counts.oversized_lines_skipped,
-        project_dirs_skipped: options.claudeAttribution.project_dirs_skipped,
-        sessions_schema_drift: options.claudeAttribution.counts.sessions_schema_drift,
-        growth_damped: options.growthDamped,
-        first_run_backfill: options.firstRunBackfill,
-    };
-    return {
-        scanned: codex.scanned,
-        attributed: codex.attributed,
-        attributed_fallback: codex.attributed_fallback,
-        ambiguous: codex.ambiguous,
-        unattributed: codex.unattributed,
-        skipped: codex.skipped,
-        stale: codex.stale,
-        report_posted: options.report.posted,
-        report_reason: options.report.reason,
-        codex,
-        claude,
-        files_deferred_byte_budget: options.outcomes.reduce((total, outcome) => total + outcome.sync.raw_evidence_deferred_byte_budget, 0),
-        files_deferred_object_budget: options.outcomes.reduce((total, outcome) => total + outcome.sync.raw_evidence_deferred_object_budget, 0),
-    };
-}
 function emptyClaudeScan() {
     return {
         results: [],