@bli-cockpit/cli 0.1.29 → 0.1.31

package/dist/commands/backfill.js

@@ -0,0 +1,964 @@
+import { containsSecretLikeContent, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES } from "@bli-cockpit/telemetry-core";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { scanAndAttributeClaudeSessions } from "../adapters/claude-attribution.js";
+import { defaultCodexSessionDirs, scanAndAttributeCodexSessions } from "../adapters/codex-attribution.js";
+import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET } from "../adapters/raw-evidence.js";
+import { acquireBackfillLock } from "../backfill-lock.js";
+import { emptyBackfillCursorState, readBackfillCursor, recordBackfillCursorObservations, writeBackfillCompletionMarker, writeBackfillCursor } from "../cursors/backfill-cursor.js";
+import { getCollectorRuntimePaths, readLocalCollectorConfig, readLocalCollectorSessionFile, readLocalSessionReference, startLocalWorkContext } from "../local-state.js";
+import { discoverGitWorktrees } from "../repo-identity.js";
+import { normalizeCollectionRoots } from "../root-normalization.js";
+import { LocalUploadBlockedError, postCodexSessionReport, syncLocalAmbientEnvelope } from "../upload.js";
+const BACKFILL_UPLOAD_BATCH_SESSIONS = 25;
+const BACKFILL_MAX_CONSECUTIVE_FAILURES = 3;
+const ALL_BACKFILL_SINCE_MINUTES = 20 * 365 * 24 * 60;
+const DEFAULT_DISCOVERY_MAX_DEPTH = 3;
+const DEFAULT_DISCOVERY_MAX_REPOS = 50;
+const RETRY_COMMAND = "cockpit backfill";
+export async function runBackfillCommand(command, io) {
+    if (!command.all && command.sinceDays === undefined) {
+        const message = bareBackfillMessage();
+        writeLine(io.stderr, message);
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({
+                status: "blocked",
+                reason: "missing_window",
+                retry_command: RETRY_COMMAND,
+            }, null, 2));
+        }
+        return 1;
+    }
+    if (command.all && !command.yes && !isInteractiveStdin(io)) {
+        const message = "--all requires TTY confirmation; pass --yes for agent runs.";
+        writeLine(io.stderr, message);
+        if (command.json) {
+            writeLine(io.stdout, JSON.stringify({
+                status: "blocked",
+                reason: "all_requires_confirmation",
+                retry_command: RETRY_COMMAND,
+            }, null, 2));
+        }
+        return 1;
+    }
+    const result = await runBackfill(command, io);
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(result, null, 2));
+        return result.status === "complete" ? 0 : 1;
+    }
+    writeHumanBackfillResult(result, io);
+    return result.status === "complete" ? 0 : 1;
+}
+export async function runBackfill(command, io) {
+    const now = new Date();
+    const paths = getCollectorRuntimePaths(command.homeDir);
+    const config = await readLocalCollectorConfig(paths);
+    const sessionFile = await readLocalCollectorSessionFile(paths);
+    const session = await readLocalSessionReference(paths);
+    if (session.session_state !== "valid") {
+        return blockedBackfillResult(command, {
+            now,
+            dashboardUrl: sessionFile.dashboard_url ?? config.dashboard_url,
+            reason: "collector_not_paired",
+            cursor: await readBackfillCursor(paths),
+        });
+    }
+    const pairedAt = parseRequiredDate(sessionFile.paired_at, "paired_at");
+    const dashboardUrl = normalizeDashboardUrl(sessionFile.dashboard_url ?? config.dashboard_url);
+    const roots = backfillCollectionRoots(command, config.default_repo_paths);
+    const worktrees = await discoverBackfillWorktrees(roots);
+    const collectionRoots = normalizeCollectionRoots(roots);
+    const sources = selectedSources(command.source);
+    const window = backfillWindow(command, now, pairedAt);
+    await validateBackfillReachability({
+        fetchImpl: io.fetch,
+        dashboardUrl,
+        dryRun: command.dryRun,
+    });
+    const cursor = command.dryRun
+        ? emptyBackfillCursorState()
+        : await readBackfillCursor(paths);
+    const scan = await scanBackfillSessions({
+        command,
+        homeDir: command.homeDir ?? os.homedir(),
+        worktrees,
+        collectionRoots,
+        sources,
+        window,
+        cursor,
+        now,
+    });
+    const guardCounts = await countReadOnlyGuards(scan.candidates);
+    const reasonCounts = reasonCountsFor(scan.candidates, guardCounts);
+    if (command.all && !command.yes) {
+        if (!command.json) {
+            writeDryRunSummary(io, {
+                candidates: scan.candidates,
+                reasonCounts,
+                dashboardUrl,
+                dryRunOnly: false,
+            });
+        }
+        const confirmed = await confirmAllBackfill(io);
+        if (!confirmed) {
+            return {
+                ...baseBackfillResult(command, {
+                    now,
+                    dashboardUrl,
+                    sources,
+                    window,
+                    cursor,
+                    scan,
+                    reasonCounts,
+                }),
+                status: "blocked",
+                counts: {
+                    ...baseBackfillResult(command, {
+                        now,
+                        dashboardUrl,
+                        sources,
+                        window,
+                        cursor,
+                        scan,
+                        reasonCounts,
+                    }).counts,
+                    remaining: scan.candidates.length,
+                },
+                failure_reason: "confirmation_declined",
+            };
+        }
+    }
+    if (command.dryRun) {
+        if (!command.json) {
+            writeDryRunSummary(io, {
+                candidates: scan.candidates,
+                reasonCounts,
+                dashboardUrl,
+                dryRunOnly: true,
+            });
+        }
+        return {
+            ...baseBackfillResult(command, {
+                now,
+                dashboardUrl,
+                sources,
+                window,
+                cursor,
+                scan,
+                reasonCounts,
+            }),
+            status: scan.candidates.length === 0 ? "blocked" : "complete",
+            dry_run: true,
+        };
+    }
+    const lock = await acquireBackfillLock(paths, now);
+    if (!lock.acquired) {
+        return {
+            ...baseBackfillResult(command, {
+                now,
+                dashboardUrl,
+                sources,
+                window,
+                cursor,
+                scan,
+                reasonCounts,
+            }),
+            status: "blocked",
+            failure_reason: "backfill_already_running",
+            blocked_at: {
+                what: "backfill lock held",
+                batch_index: 0,
+                batch_total: 0,
+                done: 0,
+                total: scan.candidates.length,
+            },
+        };
+    }
+    try {
+        const uploadable = uploadableCandidates(scan.candidates);
+        const batches = buildBackfillBatches(uploadable);
+        const rawEvidenceBudget = {
+            remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET,
+            remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET,
+        };
+        const syncResults = [];
+        let completedBatches = 0;
+        let failedBatches = 0;
+        let consecutiveFailures = 0;
+        let done = 0;
+        let failed = 0;
+        let deferred = 0;
+        let uploadedObjects = 0;
+        let uploadedChunks = 0;
+        let backfilledSessions = 0;
+        let blockedAt;
+        let failureReason;
+        for (const [index, batch] of batches.entries()) {
+            await lock.handle.heartbeat();
+            const sync = await syncBackfillBatch({
+                command,
+                batch,
+                worktrees,
+                codexAttribution: scan.codexAttribution,
+                claudeAttribution: scan.claudeAttribution,
+                rawEvidenceBudget,
+                fetchImpl: io.fetch,
+            });
+            syncResults.push(sync);
+            done += batch.candidates.length;
+            uploadedObjects += sync.raw_evidence_uploaded_object_count;
+            uploadedChunks += sync.raw_evidence_uploaded_chunk_count;
+            failed += sync.raw_evidence_failed_count;
+            deferred +=
+                sync.raw_evidence_deferred_byte_budget +
+                    sync.raw_evidence_deferred_object_budget;
+            backfilledSessions += countBackfilledSessions(sync);
+            const batchFailed = sync.status !== "uploaded" || sync.raw_evidence_failed_count > 0;
+            const batchDeferred = sync.raw_evidence_deferred_byte_budget +
+                sync.raw_evidence_deferred_object_budget >
+                0;
+            if (batchFailed) {
+                failedBatches += 1;
+                consecutiveFailures += 1;
+            }
+            else {
+                consecutiveFailures = 0;
+            }
+            if (!batchFailed && !batchDeferred) {
+                completedBatches += 1;
+                recordBackfillCursorObservations(cursor, batch.candidates.map((candidate) => ({
+                    source: candidate.source,
+                    state: candidate.state,
+                    reason: candidate.reason,
+                    session_file_mtime_ms: candidate.session_file_mtime_ms,
+                    session_file_mtime: candidate.session_file_mtime,
+                })), now);
+                await writeBackfillCursor(paths, cursor);
+            }
+            writeLine(io.stdout, `Uploaded ${done}/${uploadable.length} (batch ${index + 1}/${batches.length})`);
+            await yieldToEventLoop();
+            if (batchDeferred) {
+                blockedAt = {
+                    what: "raw evidence budget exhausted",
+                    batch_index: index + 1,
+                    batch_total: batches.length,
+                    done,
+                    total: uploadable.length,
+                };
+                failureReason = "deferred_budget_exhausted";
+                break;
+            }
+            if (consecutiveFailures >= BACKFILL_MAX_CONSECUTIVE_FAILURES) {
+                blockedAt = {
+                    what: "consecutive upload failures",
+                    batch_index: index + 1,
+                    batch_total: batches.length,
+                    done,
+                    total: uploadable.length,
+                };
+                failureReason =
+                    sync.status === "spooled" ? sync.failure_reason : "upload_failed";
+                break;
+            }
+        }
+        const sessions = buildBackfillSessionReport({
+            candidates: scan.candidates,
+            syncResults,
+            now,
+        });
+        const report = sessions.length
+            ? await postCodexSessionReport({
+                homeDir: command.homeDir,
+                repoRoot: worktrees[0]?.repo_root,
+                dashboardUrl,
+                sessions,
+                fetch: io.fetch,
+                now,
+            })
+            : emptyReport("no_sessions_observed");
+        if (sessions.length > 0 && !report.posted && !blockedAt) {
+            blockedAt = {
+                what: "session report failed",
+                batch_index: completedBatches,
+                batch_total: batches.length,
+                done,
+                total: uploadable.length,
+            };
+            failureReason = report.reason;
+        }
+        const remaining = Math.max(0, uploadable.length - done);
+        const status = blockedAt
+            ? remaining > 0 || deferred > 0
+                ? "partial"
+                : "blocked"
+            : scan.candidates.length === 0
+                ? "blocked"
+                : "complete";
+        if (status === "complete" && deferred === 0 && failed === 0) {
+            await writeBackfillCompletionMarker(paths, {
+                schema_version: "cockpit-backfill-complete.v1",
+                completed_at: now.toISOString(),
+                cursor,
+            });
+        }
+        return {
+            ...baseBackfillResult(command, {
+                now,
+                dashboardUrl,
+                sources,
+                window,
+                cursor,
+                scan,
+                reasonCounts,
+            }),
+            status,
+            counts: {
+                ...baseBackfillResult(command, {
+                    now,
+                    dashboardUrl,
+                    sources,
+                    window,
+                    cursor,
+                    scan,
+                    reasonCounts,
+                }).counts,
+                backfilled: backfilledSessions,
+                failed,
+                deferred,
+                remaining,
+            },
+            batches: {
+                total: batches.length,
+                completed: completedBatches,
+                failed: failedBatches,
+            },
+            report,
+            server_acknowledged: {
+                codex_session_report_recorded_count: report.recorded_count,
+                raw_evidence_uploaded_object_count: uploadedObjects,
+                raw_evidence_uploaded_chunk_count: uploadedChunks,
+            },
+            blocked_at: blockedAt,
+            failure_reason: failureReason,
+        };
+    }
+    finally {
+        await lock.handle.release();
+    }
+}
+function bareBackfillMessage() {
+    return [
+        "cockpit backfill needs an explicit window.",
+        "Use `cockpit backfill --since-days N` for post-pairing history; the effective start is capped at the collector paired_at timestamp.",
+        "Use `cockpit backfill --all` only after reviewing a dry-run; on headless agent runs add `--yes`.",
+    ].join("\n");
+}
+function backfillCollectionRoots(command, savedRoots) {
+    if (command.repoRoot)
+        return [path.resolve(command.repoRoot)];
+    const roots = normalizeCollectionRoots(savedRoots);
+    if (roots.length === 0) {
+        throw new Error("No saved collection roots. Run `cockpit onboard --workspace <path>` or pass `cockpit backfill --workspace <path>`.");
+    }
+    return roots;
+}
+async function discoverBackfillWorktrees(roots) {
+    const discovered = [];
+    for (const root of roots) {
+        discovered.push(...(await discoverGitWorktrees(root, {
+            maxDepth: DEFAULT_DISCOVERY_MAX_DEPTH,
+            maxWorktrees: DEFAULT_DISCOVERY_MAX_REPOS,
+        })));
+    }
+    const seen = new Set();
+    const deduped = [];
+    for (const worktree of discovered) {
+        const key = worktree.worktree_fingerprint || path.resolve(worktree.repo_root);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(worktree);
+    }
+    if (deduped.length === 0) {
+        throw new Error("No git repos found in the backfill collection roots.");
+    }
+    return deduped;
+}
+function selectedSources(source) {
+    if (source === "codex")
+        return ["codex"];
+    if (source === "claude")
+        return ["claude_code"];
+    return ["codex", "claude_code"];
+}
+function backfillWindow(command, now, pairedAt) {
+    if (command.all) {
+        return {
+            mode: "all",
+            since_days: null,
+            started_at: new Date(now.getTime() - ALL_BACKFILL_SINCE_MINUTES * 60_000)
+                .toISOString(),
+            paired_at: pairedAt.toISOString(),
+            since_minutes: ALL_BACKFILL_SINCE_MINUTES,
+        };
+    }
+    const requestedMs = now.getTime() - (command.sinceDays ?? 1) * 24 * 60 * 60_000;
+    const startedAtMs = Math.max(requestedMs, pairedAt.getTime());
+    const sinceMinutes = Math.max(1, Math.ceil((now.getTime() - startedAtMs) / 60_000));
+    return {
+        mode: "since_days",
+        since_days: command.sinceDays ?? null,
+        started_at: new Date(startedAtMs).toISOString(),
+        paired_at: pairedAt.toISOString(),
+        since_minutes: sinceMinutes,
+    };
+}
+async function validateBackfillReachability(options) {
+    if (!options.dryRun)
+        return;
+    const response = await options.fetchImpl(options.dashboardUrl, {
+        method: "HEAD",
+    });
+    if (response.status >= 500) {
+        throw new Error(`Dashboard reachability failed with HTTP ${response.status}.`);
+    }
+}
+async function scanBackfillSessions(options) {
+    const scanLimit = options.command.maxFiles ?? 10_000;
+    const codexAttribution = options.sources.includes("codex")
+        ? await scanAndAttributeCodexSessions({
+            sessionsDirs: defaultCodexSessionDirs(options.homeDir),
+            worktrees: options.worktrees,
+            now: options.now,
+            sinceMinutes: options.window.since_minutes,
+            limit: scanLimit,
+            collectionRoots: options.collectionRoots,
+        })
+        : null;
+    const claudeAttribution = options.sources.includes("claude_code")
+        ? await scanAndAttributeClaudeSessions({
+            projectsDir: path.join(options.homeDir, ".claude", "projects"),
+            worktrees: options.worktrees,
+            now: options.now,
+            sinceMinutes: options.window.since_minutes,
+            limit: scanLimit,
+            collectionRoots: options.collectionRoots,
+        })
+        : null;
+    const candidates = [
+        ...(codexAttribution?.results.map(normalizeCodexCandidate) ?? []),
+        ...(claudeAttribution?.results.map(normalizeClaudeCandidate) ?? []),
+    ]
+        .filter((candidate) => isAfterCursor(candidate, options.cursor))
+        .sort((a, b) => b.session_file_mtime_ms - a.session_file_mtime_ms)
+        .slice(0, options.command.maxFiles ?? Number.MAX_SAFE_INTEGER);
+    return { candidates, codexAttribution, claudeAttribution };
+}
+function normalizeCodexCandidate(result) {
+    return {
+        source: "codex",
+        session_id: result.codex_session_id,
+        file_path: result.file_path,
+        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 normalizeClaudeCandidate(result) {
+    return {
+        source: "claude_code",
+        session_id: result.claude_session_id,
+        file_path: result.file_path,
+        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,
+        claude: result,
+    };
+}
+function isAfterCursor(candidate, cursor) {
+    const oldest = cursor.sources[candidate.source]?.oldest_mtime_ms_processed;
+    return oldest === null || oldest === undefined || candidate.session_file_mtime_ms < oldest;
+}
+async function countReadOnlyGuards(candidates) {
+    const counts = new Map();
+    for (const candidate of candidates) {
+        if (candidate.reason === "repo_not_on_disk")
+            increment(counts, "repo_not_on_disk");
+        if (candidate.source === "claude_code" && candidate.claude?.main_file_oversized) {
+            increment(counts, "file_too_large");
+            continue;
+        }
+        if (candidate.byte_size > RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES) {
+            increment(counts, "file_too_large");
+            continue;
+        }
+        if (!isUploadableState(candidate.state))
+            continue;
+        try {
+            const raw = await fs.readFile(candidate.file_path, "utf8");
+            if (containsSecretLikeContent(raw)) {
+                increment(counts, "secret_like_content_guard");
+            }
+        }
+        catch {
+            increment(counts, "file_read_failed");
+        }
+    }
+    return counts;
+}
+function reasonCountsFor(candidates, guardCounts) {
+    const counts = new Map();
+    for (const candidate of candidates)
+        increment(counts, candidate.reason);
+    for (const [reason, count] of guardCounts) {
+        counts.set(reason, Math.max(counts.get(reason) ?? 0, count));
+    }
+    for (const required of [
+        "secret_like_content_guard",
+        "file_too_large",
+        "repo_not_on_disk",
+    ]) {
+        counts.set(required, counts.get(required) ?? 0);
+    }
+    return [...counts.entries()]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([reason, count]) => ({
+        reason,
+        count,
+        ...reasonClassification(reason),
+    }));
+}
+function reasonClassification(reason) {
+    if (reason === "secret_like_content_guard" || reason === "secret_redaction_failed") {
+        return {
+            classification: "permanent",
+            note: "secret-guarded permanent by design",
+        };
+    }
+    if (reason === "file_too_large") {
+        return {
+            classification: "retryable",
+            note: "until the evidence file cap is raised",
+        };
+    }
+    if (reason === "repo_not_on_disk") {
+        return {
+            classification: "retryable",
+            note: "repo must exist on disk",
+        };
+    }
+    if (reason.startsWith("deferred_")) {
+        return {
+            classification: "retryable",
+            note: "rerun cockpit backfill to continue",
+        };
+    }
+    return {
+        classification: "retryable",
+        note: "rerun after fixing source or collector state",
+    };
+}
+function uploadableCandidates(candidates) {
+    return candidates.filter((candidate) => isUploadableState(candidate.state) && candidate.worktree);
+}
+function isUploadableState(state) {
+    return state === "attributed" || state === "attributed_fallback";
+}
+function buildBackfillBatches(candidates) {
+    const byWorktree = new Map();
+    for (const candidate of candidates) {
+        if (!candidate.worktree)
+            continue;
+        const key = candidate.worktree.worktree_fingerprint;
+        byWorktree.set(key, [...(byWorktree.get(key) ?? []), candidate]);
+    }
+    const batches = [];
+    for (const group of byWorktree.values()) {
+        const worktree = group[0]?.worktree;
+        if (!worktree)
+            continue;
+        for (let offset = 0; offset < group.length; offset += BACKFILL_UPLOAD_BATCH_SESSIONS) {
+            batches.push({
+                worktree,
+                candidates: group.slice(offset, offset + BACKFILL_UPLOAD_BATCH_SESSIONS),
+            });
+        }
+    }
+    return batches;
+}
+async function syncBackfillBatch(options) {
+    const syncOptions = {
+        homeDir: options.command.homeDir,
+        repoRoot: options.batch.worktree.repo_root,
+        worktreeInventory: worktreeInventoryForRepo(options.batch.worktree, options.worktrees),
+        codexSessionFiles: options.batch.candidates
+            .filter((candidate) => candidate.source === "codex")
+            .map((candidate) => ({
+            local_path: candidate.file_path,
+            codex_session_id: candidate.session_id,
+        })),
+        codexAttributionScan: options.codexAttribution ?? undefined,
+        claudeSessionFiles: options.batch.candidates
+            .filter((candidate) => candidate.source === "claude_code")
+            .map((candidate) => ({
+            local_path: candidate.file_path,
+            claude_session_id: candidate.session_id,
+            main_file_oversized: Boolean(candidate.claude?.main_file_oversized),
+            skip_main: false,
+            sidecar_files: candidate.claude?.sidecar_files
+                .filter((sidecar) => !sidecar.skipped_reason)
+                .map((sidecar) => ({ local_path: sidecar.local_path })) ?? [],
+        })),
+        claudeAttributionScan: options.claudeAttribution ?? undefined,
+        rawEvidenceBudget: options.rawEvidenceBudget,
+        fetch: options.fetchImpl,
+    };
+    try {
+        return await syncLocalAmbientEnvelope(syncOptions);
+    }
+    catch (error) {
+        if (error instanceof LocalUploadBlockedError &&
+            error.blocker === "missing_context") {
+            await startLocalWorkContext({
+                homeDir: options.command.homeDir,
+                repoRoot: options.batch.worktree.repo_root,
+                branch: options.batch.worktree.branch,
+            });
+            return await syncLocalAmbientEnvelope(syncOptions);
+        }
+        throw error;
+    }
+}
+function buildBackfillSessionReport(options) {
+    const uploadByKey = new Map();
+    for (const sync of options.syncResults) {
+        if (sync.status !== "uploaded")
+            continue;
+        for (const outcome of sync.raw_evidence_outcomes) {
+            if (!outcome.codex_session_id || !outcome.raw_evidence_pointer_id)
+                continue;
+            const source = outcome.kind === "claude_jsonl"
+                ? "claude_code"
+                : outcome.kind === "codex_jsonl"
+                    ? "codex"
+                    : null;
+            if (!source)
+                continue;
+            uploadByKey.set(`${source}:${outcome.codex_session_id}`, {
+                upload_state: outcome.upload_state,
+                raw_evidence_pointer_id: outcome.raw_evidence_pointer_id,
+            });
+        }
+    }
+    const bestByKey = new Map();
+    for (const candidate of options.candidates) {
+        const key = `${candidate.source}:${candidate.session_id}`;
+        const existing = bestByKey.get(key);
+        if (!existing || rank(candidate.state) > rank(existing.state)) {
+            bestByKey.set(key, candidate);
+        }
+        else if (existing &&
+            rank(candidate.state) === rank(existing.state) &&
+            candidate.session_file_mtime_ms > existing.session_file_mtime_ms) {
+            bestByKey.set(key, candidate);
+        }
+    }
+    return [...bestByKey.values()].map((candidate) => {
+        const upload = uploadByKey.get(`${candidate.source}:${candidate.session_id}`);
+        return {
+            codex_session_id: candidate.session_id,
+            source: candidate.source,
+            observed_at: options.now.toISOString(),
+            attribution_state: candidate.state,
+            attribution_reason: candidate.reason,
+            attribution_score: candidate.attribution_score,
+            path_score: candidate.path_score,
+            signals: candidate.signals,
+            ...(candidate.content_hash_sha256
+                ? { session_file_hash_sha256: candidate.content_hash_sha256 }
+                : {}),
+            session_file_byte_size: candidate.byte_size,
+            session_file_mtime: candidate.session_file_mtime,
+            ...(candidate.worktree
+                ? {
+                    repo_fingerprint: candidate.worktree.repo_fingerprint,
+                    worktree_fingerprint: candidate.worktree.worktree_fingerprint,
+                    repo_label: candidate.worktree.repo_label,
+                    branch: candidate.worktree.branch,
+                }
+                : {}),
+            ...(candidate.cwd_basename ? { cwd_basename: candidate.cwd_basename } : {}),
+            ...(candidate.cwd_hash ? { cwd_hash: candidate.cwd_hash } : {}),
+            ...(upload
+                ? {
+                    raw_evidence_pointer_id: upload.raw_evidence_pointer_id,
+                    upload_state: upload.upload_state,
+                }
+                : isUploadableState(candidate.state)
+                    ? { upload_state: "not_uploaded" }
+                    : {}),
+        };
+    });
+}
+function rank(state) {
+    switch (state) {
+        case "attributed":
+            return 5;
+        case "attributed_fallback":
+            return 4;
+        case "ambiguous":
+            return 3;
+        case "unattributed":
+            return 2;
+        case "skipped":
+            return 1;
+        default:
+            return 0;
+    }
+}
+function countBackfilledSessions(sync) {
+    const keys = new Set();
+    for (const outcome of sync.raw_evidence_outcomes) {
+        if ((outcome.kind === "codex_jsonl" || outcome.kind === "claude_jsonl") &&
+            outcome.codex_session_id &&
+            (outcome.upload_state === "uploaded" ||
+                outcome.upload_state === "reused_existing")) {
+            keys.add(`${outcome.kind}:${outcome.codex_session_id}`);
+        }
+    }
+    return keys.size;
+}
+function worktreeInventoryForRepo(current, worktrees) {
+    return worktrees
+        .filter((worktree) => worktree.repo_fingerprint
+        ? worktree.repo_fingerprint === current.repo_fingerprint
+        : worktree.repo_label === current.repo_label)
+        .map((worktree) => ({
+        repo: worktree.repo_root,
+        repo_label: worktree.repo_label,
+        repo_fingerprint: worktree.repo_fingerprint,
+        repo_origin_url: worktree.repo_origin_url ?? undefined,
+        head_sha: worktree.head_sha ?? undefined,
+        worktree_label: worktree.worktree_label,
+        worktree_fingerprint: worktree.worktree_fingerprint,
+        worktree_is_primary: worktree.worktree_is_primary,
+        branch: worktree.branch,
+    }));
+}
+function baseBackfillResult(command, options) {
+    const states = countBy(options.scan.candidates, (candidate) => candidate.state);
+    const uploadable = uploadableCandidates(options.scan.candidates);
+    const perSource = {
+        codex: sourceCounts("codex", options.scan),
+        claude_code: sourceCounts("claude_code", options.scan),
+    };
+    return {
+        status: "complete",
+        dry_run: command.dryRun,
+        dashboard_url: options.dashboardUrl,
+        verify_url: `${options.dashboardUrl}/my-work`,
+        sources: options.sources,
+        window: options.window,
+        counts: {
+            total: options.scan.candidates.length,
+            uploadable: uploadable.length,
+            backfilled: 0,
+            skipped: options.scan.candidates.length - uploadable.length,
+            failed: 0,
+            deferred: 0,
+            remaining: 0,
+            states,
+            reasons: options.reasonCounts,
+            per_source: perSource,
+        },
+        batches: {
+            total: Math.ceil(uploadable.length / BACKFILL_UPLOAD_BATCH_SESSIONS),
+            completed: 0,
+            failed: 0,
+        },
+        resume_cursor: options.cursor,
+        retry_command: RETRY_COMMAND,
+        report: emptyReport("not_posted"),
+        server_acknowledged: {
+            codex_session_report_recorded_count: 0,
+            raw_evidence_uploaded_object_count: 0,
+            raw_evidence_uploaded_chunk_count: 0,
+        },
+    };
+}
+function blockedBackfillResult(command, options) {
+    return {
+        status: "blocked",
+        dry_run: command.dryRun,
+        dashboard_url: options.dashboardUrl,
+        verify_url: `${options.dashboardUrl}/my-work`,
+        sources: selectedSources(command.source),
+        window: {
+            mode: command.all ? "all" : "since_days",
+            since_days: command.sinceDays ?? null,
+            started_at: options.now.toISOString(),
+            paired_at: options.now.toISOString(),
+            since_minutes: 0,
+        },
+        counts: {
+            total: 0,
+            uploadable: 0,
+            backfilled: 0,
+            skipped: 0,
+            failed: 0,
+            deferred: 0,
+            remaining: 0,
+            states: {},
+            reasons: [],
+            per_source: {
+                codex: emptySourceCounts(),
+                claude_code: emptySourceCounts(),
+            },
+        },
+        batches: { total: 0, completed: 0, failed: 0 },
+        resume_cursor: options.cursor,
+        retry_command: RETRY_COMMAND,
+        report: emptyReport("not_posted"),
+        server_acknowledged: {
+            codex_session_report_recorded_count: 0,
+            raw_evidence_uploaded_object_count: 0,
+            raw_evidence_uploaded_chunk_count: 0,
+        },
+        failure_reason: options.reason,
+    };
+}
+function sourceCounts(source, scan) {
+    const candidates = scan.candidates.filter((candidate) => candidate.source === source);
+    const scanned = source === "codex"
+        ? (scan.codexAttribution?.scanned_file_count ?? 0)
+        : (scan.claudeAttribution?.scanned_session_count ?? 0);
+    return {
+        scanned,
+        selected: candidates.length,
+        uploadable: uploadableCandidates(candidates).length,
+        states: countBy(candidates, (candidate) => candidate.state),
+    };
+}
+function emptySourceCounts() {
+    return { scanned: 0, selected: 0, uploadable: 0, states: {} };
+}
+function emptyReport(reason) {
+    return {
+        posted: false,
+        reason,
+        chunk_count: 0,
+        recorded_count: 0,
+        failed_count: 0,
+        chunks: [],
+    };
+}
+function countBy(items, keyOf) {
+    const counts = {};
+    for (const item of items) {
+        const key = keyOf(item);
+        counts[key] = (counts[key] ?? 0) + 1;
+    }
+    return counts;
+}
+function increment(counts, key) {
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+}
+function writeDryRunSummary(io, options) {
+    const uploadable = uploadableCandidates(options.candidates);
+    writeLine(io.stdout, `${options.dryRunOnly ? "DRY-RUN" : "Review"}: ${options.candidates.length} session(s), ${uploadable.length} uploadable, ${options.candidates.length - uploadable.length} skipped.`);
+    writeReasonTable(io, options.reasonCounts);
+    if (options.dryRunOnly) {
+        writeLine(io.stdout, "DRY-RUN: wrote nothing (no cursor, marker, report, or upload).");
+    }
+    writeLine(io.stdout, `Verify after upload: ${options.dashboardUrl}/my-work`);
+}
+function writeHumanBackfillResult(result, io) {
+    if (result.status === "complete") {
+        writeLine(io.stdout, `PASS: ${result.counts.backfilled} backfilled, ${result.counts.skipped} skipped (table). Verify: ${result.verify_url}`);
+        writeReasonTable(io, result.counts.reasons);
+        return;
+    }
+    if (result.status === "partial") {
+        const at = result.blocked_at;
+        if (at) {
+            writeLine(io.stderr, `BLOCKED: ${at.what} at batch ${at.batch_index}/${at.batch_total}, ${at.done}/${at.total} done`);
+        }
+        writeLine(io.stderr, `Failure: ${result.failure_reason ?? "partial_backfill"}`);
+        writeLine(io.stderr, `Retry: ${result.retry_command}`);
+        writeLine(io.stderr, `Stopped: ${result.counts.remaining} remaining — rerun cockpit backfill to continue`);
+        writeReasonTable(io, result.counts.reasons);
+        return;
+    }
+    const at = result.blocked_at;
+    if (at) {
+        writeLine(io.stderr, `BLOCKED: ${at.what} at batch ${at.batch_index}/${at.batch_total}, ${at.done}/${at.total} done`);
+    }
+    else {
+        writeLine(io.stderr, "BLOCKED: backfill could not run.");
+    }
+    writeLine(io.stderr, `Failure: ${result.failure_reason ?? "no_sessions"}`);
+    writeLine(io.stderr, `Retry: ${result.retry_command}`);
+}
+function writeReasonTable(io, reasons) {
+    if (reasons.length === 0)
+        return;
+    writeLine(io.stdout, "Skip/reason table:");
+    for (const reason of reasons) {
+        writeLine(io.stdout, `- ${reason.reason}: ${reason.count} (${reason.classification}; ${reason.note})`);
+    }
+}
+async function confirmAllBackfill(io) {
+    const answer = await readLine(io, "Proceed with --all backfill upload? [y/N] ");
+    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+}
+async function readLine(io, prompt) {
+    io.stdout.write(prompt);
+    io.stdin.setEncoding("utf8");
+    return new Promise((resolve) => {
+        const onData = (chunk) => {
+            io.stdin.removeListener("data", onData);
+            io.stdin.pause();
+            resolve(chunk);
+        };
+        io.stdin.resume();
+        io.stdin.on("data", onData);
+    });
+}
+function isInteractiveStdin(io) {
+    return Boolean(io.stdin.isTTY);
+}
+function parseRequiredDate(value, label) {
+    const date = new Date(value);
+    if (!Number.isFinite(date.getTime())) {
+        throw new Error(`Collector session ${label} is invalid.`);
+    }
+    return date;
+}
+function normalizeDashboardUrl(value) {
+    return value.trim().replace(/\/+$/, "");
+}
+function writeLine(stream, text) {
+    stream.write(`${text}\n`);
+}
+function yieldToEventLoop() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}