onadit 0.0.1 → 1.0.0

package/dist/src/capture/auto-capture.js

@@ -0,0 +1,1167 @@
+/**
+ * Auto-capture orchestrator for local CLI conversations.
+ *
+ * Scans local conversation stores (currently Claude Code + Codex),
+ * deduplicates against previously processed sessions,
+ * triages each new conversation, and routes the result:
+ *
+ * - save: calls the daemon's POST /save with full content
+ * - review: writes to the file-backed review queue
+ * - discard: marks as processed, no further action
+ *
+ * Deduplication state is persisted to data/capture-state.json.
+ * The dedupe key is the session UUID + a content hash, so
+ * reprocessing the same conversation is idempotent, but
+ * a significantly updated conversation is re-evaluated.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { z } from "zod";
+import { discoverClaudeCodeSessions, parseClaudeCodeSession, } from "../ingestion/parsers/claude-code-jsonl.js";
+import { discoverClaudeDesktopSessions, parseClaudeDesktopSession, } from "../ingestion/parsers/claude-desktop-sessions.js";
+import { discoverCodexSessions, parseCodexSession, } from "../ingestion/parsers/codex-jsonl.js";
+import { discoverGrokSessions, parseGrokSession } from "../ingestion/parsers/grok-cli.js";
+import { parseCursorComposerSession } from "../ingestion/cursor/cursor-store.js";
+import { defaultCursorDir } from "../ingestion/cursor/vscdb-reader.js";
+import { cursorCaptureEnabled, cursorCapturePersistEnabled, cursorTitlesRevealed, discoverCursorCaptureSessions, redactedCursorTitle, } from "./cursor-capture.js";
+import { triageConversation } from "./triage.js";
+import { encodeUserStatement, ownsPassage, sealUserStatements, verifyUserStatementsWithEvidence, } from "./user-statements.js";
+import { createStoredStatementsLookup } from "./stored-statements.js";
+import { addToReview } from "./review-queue.js";
+import { createAssistantTextLookup, sessionRoots, } from "./assistant-text-lookup.js";
+import { atomicWrite } from "../storage/atomic.js";
+import { createConfiguredTriageProvider, getConfiguredTriageProviderName, } from "./triage-provider-factory.js";
+import { CodexCliTimeoutError } from "../providers/codex-cli-runner.js";
+import { ClaudeCliTimeoutError } from "../providers/claude-cli-runner.js";
+import { AUTO_CAPTURE_SOURCE_VALUES, CLAUDE_DESKTOP_CAPTURE_SOURCE, CURSOR_CAPTURE_SOURCE, DEFAULT_AUTO_CAPTURE_SOURCES, } from "./sources.js";
+/**
+ * Default upper bound for a Codex CLI session that auto-capture will hand
+ * to the triage subprocess. Real sessions in `~/.codex/sessions/` are tens
+ * of KB to ~2 MB; 8 MB is well above healthy traffic and well below the
+ * 25 MB outliers that have been observed to make Codex CLI exit 1.
+ *
+ * Operators raise this in `config.json` under `capture.codex_cli.max_session_bytes`.
+ */
+export const DEFAULT_CODEX_MAX_SESSION_BYTES = 8 * 1024 * 1024;
+/**
+ * Default upper bound for a native Cursor session's PARSED transcript before the
+ * size guard quarantines it instead of handing it to the triage subprocess.
+ * Unlike Codex (a session file we can `stat`), Cursor content is reassembled
+ * from `state.vscdb` bubbles in memory, so the bound is measured on the merged
+ * user+assistant text. 4 MB of text is ~1M tokens — far past any healthy
+ * session and well past what triage should ever receive. Overridable per run
+ * via `AutoCaptureDeps.cursorMaxSessionBytes`.
+ */
+export const DEFAULT_CURSOR_MAX_SESSION_BYTES = 4 * 1024 * 1024;
+/** Sentinel idempotency_key written into capture-state.json for oversized sessions. */
+export const QUARANTINED_OVERSIZED_KEY = "quarantined:oversized";
+/**
+ * Translate the operator-facing `capture.codex_cli.max_session_bytes` config
+ * field into the partial `AutoCaptureDeps` shape that every entry point
+ * (daemon scheduled run, `onadit capture`, `onadit onboard` first-capture) must
+ * spread into its `runAutoCapture()` call. Centralizing this resolution
+ * keeps the three call sites from drifting and gives behavioral tests a
+ * single observable contract.
+ *
+ * Returns an empty object (so the spread is a no-op) when the override is
+ * absent — the consuming `runAutoCapture` then falls through to
+ * `DEFAULT_CODEX_MAX_SESSION_BYTES`.
+ */
+export function resolveCodexCaptureDeps(config) {
+    const override = config.capture?.codex_cli?.max_session_bytes;
+    return override !== undefined ? { codexMaxSessionBytes: override } : {};
+}
+/**
+ * Resolve the native-Cursor size override into the partial deps every call site
+ * (daemon scheduled run, `onadit capture`) spreads into `runAutoCapture()`. Mirrors
+ * `resolveCodexCaptureDeps`. Returns an empty object (no-op spread) when absent,
+ * so `runAutoCapture` falls through to `DEFAULT_CURSOR_MAX_SESSION_BYTES`.
+ */
+export function resolveCursorCaptureDeps(config) {
+    const override = config.capture?.cursor?.max_session_bytes;
+    return override !== undefined ? { cursorMaxSessionBytes: override } : {};
+}
+/**
+ * Build the full daemon-scheduled `runAutoCapture` deps from config + the
+ * job-queue-backed `saveFn`. The factory exists so the daemon path is
+ * directly unit-testable: callers can assert the returned shape without
+ * standing up the full daemon. The CLI paths (`onadit capture`, `onadit onboard
+ * --first-capture`) build their deps inline because they vary per-invocation
+ * (source filter, dry-run, claudeDir/codexDir overrides, HTTP-client save).
+ */
+export function buildDaemonAutoCaptureDeps(opts) {
+    return {
+        dataDir: opts.config.data_paths.data_dir,
+        sources: opts.config.capture.sources,
+        // Config membership IS the Cursor opt-in: when the daemon's configured
+        // sources include cursor_composer, authorize discovery + persistence for
+        // this run without the env flags.
+        cursorConfigEnabled: opts.config.capture.sources.includes(CURSOR_CAPTURE_SOURCE),
+        ...resolveCodexCaptureDeps(opts.config),
+        ...resolveCursorCaptureDeps(opts.config),
+        saveFn: opts.saveFn,
+    };
+}
+const STATE_FILE = "capture-state.json";
+/**
+ * Committed ledger generations (`<N>.json`, immutable). The newest is the
+ * ledger; `capture-state.json` is a mirror kept for older readers and humans.
+ * See saveState for why.
+ */
+const STATE_GENERATIONS_DIR = "capture-state.gen";
+/** Generations are kept at least this long, and the newest few always. */
+const STATE_GENERATION_KEEP_MS = 60 * 60 * 1000;
+const STATE_GENERATION_KEEP_COUNT = 3;
+/** Commit attempts before a run gives up (each retry means another run committed). */
+const STATE_COMMIT_ATTEMPTS = 50;
+/**
+ * Whether a source may be PERSISTED. Claude/Codex always persist. Native Cursor
+ * persists when EITHER:
+ *   - it is scheduled via config (`cursorConfigEnabled`, i.e. `cursor_composer`
+ *     is in `config.capture.sources`) — the deliberate, persisted opt-in that
+ *     authorizes the daemon (and a config-driven manual run) to capture + save
+ *     Cursor without any env flags; OR
+ *   - BOTH env flags are set (`RIFT_CURSOR_CAPTURE=1` discovery master switch and
+ *     `CURSOR_CAPTURE_PERSIST=1`) — the ad-hoc/dogfood path for an explicit
+ *     `--source cursor_composer` run with no config opt-in.
+ *
+ * The env discovery flag is part of the env gate on purpose: persisting a source
+ * we are not even discovering is incoherent, and — critically — it would let an
+ * explicit `--source cursor_composer` run with persist on but discovery OFF write
+ * a bootstrap watermark for zero discovered sessions, falsely marking history as
+ * "already baselined." A later run with discovery on would then skip bootstrap
+ * and save real existing sessions as new — the exact historical backfill this
+ * gate exists to prevent. Requiring both env flags (or a config opt-in, which
+ * always also enables discovery — see `cursorOn`) closes that hole.
+ *
+ * With persistence off, Cursor sessions are discovered, fingerprinted, and
+ * triaged, but never saved, queued for review, or written to capture-state —
+ * "no writes" by construction, independent of `--dry-run`. The check reads the
+ * env at call time, so it is consistent within a single run.
+ */
+function writesEnabledForSource(source, cursorConfigEnabled) {
+    if (source === CURSOR_CAPTURE_SOURCE) {
+        return (cursorConfigEnabled ||
+            (cursorCaptureEnabled() && cursorCapturePersistEnabled()));
+    }
+    return true;
+}
+/**
+ * Content fingerprint for a discovered session. Cursor sessions hash their
+ * precomputed ordered-bubble material; file-backed sources hash size + tail.
+ */
+function sessionFingerprint(session) {
+    if (session.grok) {
+        return crypto.createHash("sha256")
+            .update(contentFingerprint(session.path))
+            .update(JSON.stringify(session.grok.metadata))
+            .digest("hex").slice(0, 16);
+    }
+    if (session.cursor) {
+        return crypto
+            .createHash("sha256")
+            .update(session.cursor.fingerprintInput)
+            .digest("hex")
+            .slice(0, 16);
+    }
+    return contentFingerprint(session.path);
+}
+export function zeroCounts() {
+    return {
+        discovered: 0,
+        bootstrapped: 0,
+        new: 0,
+        skipped: 0,
+        saved: 0,
+        review: 0,
+        discarded: 0,
+        quarantined: 0,
+        errors: 0,
+        deferred: 0,
+    };
+}
+export function makeErrorCounts(errors = 1) {
+    return {
+        ...zeroCounts(),
+        errors,
+    };
+}
+function ensureCounts(report, source) {
+    const existing = report.counts_by_source[source];
+    if (existing)
+        return existing;
+    const counts = zeroCounts();
+    report.counts_by_source[source] = counts;
+    return counts;
+}
+function stateKey(source, sessionId) {
+    return `${source}:${sessionId}`;
+}
+function getPreviousEntry(state, source, sessionId) {
+    const keyed = state.processed[stateKey(source, sessionId)];
+    if (keyed !== undefined)
+        return keyed;
+    // Backward compatibility: early capture-state files keyed Claude-only
+    // sessions by bare UUID. Reuse that state so Claude auto-capture does not
+    // unexpectedly re-import an already-processed corpus.
+    return source === "claude_code" ? state.processed[sessionId] : undefined;
+}
+function hasSourcePrefixedEntries(state, source) {
+    const prefix = `${source}:`;
+    return Object.keys(state.processed).some((key) => key.startsWith(prefix));
+}
+function hasClaudeLegacyBareEntries(state) {
+    return Object.keys(state.processed).some((key) => !key.includes(":"));
+}
+function hasPriorStateForSource(state, source) {
+    if (state.bootstrapped_sources?.[source])
+        return true;
+    if (hasSourcePrefixedEntries(state, source))
+        return true;
+    // Claude was the only original live source, and older state files used
+    // bare UUID keys. Treat those as Claude prior state so a migrated install
+    // does not re-import an already-captured corpus.
+    return source === "claude_code" && hasClaudeLegacyBareEntries(state);
+}
+function shouldBootstrapSource(state, source, dryRun) {
+    if (dryRun)
+        return false;
+    return !hasPriorStateForSource(state, source);
+}
+/**
+ * Whether a preflight failure is transient (a worker timeout/termination) and
+ * therefore safe to continue past, vs. a hard auth/path failure that should
+ * abort the run. Timeouts are already retried once at the runner; if the probe
+ * still timed out, individual sessions may still succeed, so we let them try.
+ * Covers both worker runtimes (Codex and Claude).
+ */
+function isTransientPreflightError(err) {
+    return (err instanceof CodexCliTimeoutError || err instanceof ClaudeCliTimeoutError);
+}
+async function ensureAutoCaptureTriageReady() {
+    // This is intentionally a tiny real CLI model call on the CONFIGURED worker
+    // (codex_cli or claude_code), not a cheap version check: it catches expired
+    // auth and runtime/model failures before a capture run starts mutating state.
+    await createConfiguredTriageProvider({ timeoutMs: 120_000 }).triage({
+        content: "User: Auto-capture preflight check.\n\nAssistant: Ready.",
+        source: "codex_cli",
+    });
+}
+/**
+ * Load the capture state from disk.
+ */
+const CaptureStateEntrySchema = z.object({
+    fingerprint: z.string(),
+    idempotency_key: z.string().default(""),
+});
+const CaptureStateSchema = z.object({
+    processed: z
+        .record(z.string(), z.union([z.string(), CaptureStateEntrySchema]))
+        .default({}),
+    bootstrapped_sources: z.record(z.string(), z.string()).optional(),
+});
+const LenientCaptureStateSchema = z.object({
+    processed: z.record(z.string(), z.unknown()).default({}),
+    bootstrapped_sources: z.record(z.string(), z.string()).optional(),
+});
+function backupUnreadableState(statePath, error) {
+    const suffix = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupPath = `${statePath}.corrupt-${suffix}`;
+    try {
+        fs.copyFileSync(statePath, backupPath);
+        process.stderr.write(`Auto-capture state parse failed for ${statePath}; backed up to ${backupPath}: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+    catch (backupErr) {
+        process.stderr.write(`Auto-capture state parse failed for ${statePath}; backup failed: ${backupErr instanceof Error ? backupErr.message : String(backupErr)}\n`);
+    }
+}
+function normalizeBootstrappedSources(sources) {
+    const bootstrappedSources = {};
+    // Iterate ALL auto-capture sources, not just the scheduled defaults: a
+    // flag-gated source that persists (Cursor, when CURSOR_CAPTURE_PERSIST is on)
+    // writes a bootstrap watermark, and that marker must survive a state reload —
+    // otherwise the source re-bootstraps every run and never captures anything.
+    for (const source of AUTO_CAPTURE_SOURCE_VALUES) {
+        const value = sources?.[source];
+        if (typeof value === "string") {
+            bootstrappedSources[source] = value;
+        }
+    }
+    return bootstrappedSources;
+}
+/** Committed generation numbers, oldest first. */
+function listStateGenerations(genDir) {
+    let names;
+    try {
+        names = fs.readdirSync(genDir);
+    }
+    catch {
+        return [];
+    }
+    return names
+        .map((n) => /^(\d+)\.json$/.exec(n)?.[1])
+        .filter((n) => n !== undefined)
+        .map(Number)
+        .sort((a, b) => a - b);
+}
+/**
+ * The current ledger and its generation: the newest committed generation, or
+ * the legacy `capture-state.json` (generation 0) before the first commit.
+ */
+function loadCurrentState(dataDir) {
+    const genDir = path.join(dataDir, STATE_GENERATIONS_DIR);
+    const newest = listStateGenerations(genDir).at(-1);
+    if (newest === undefined) {
+        return { state: loadStateFile(path.join(dataDir, STATE_FILE)), generation: 0 };
+    }
+    return { state: loadStateFile(path.join(genDir, `${newest}.json`)), generation: newest };
+}
+function loadState(dataDir) {
+    return loadCurrentState(dataDir).state;
+}
+function loadStateFile(statePath) {
+    if (!fs.existsSync(statePath)) {
+        return { processed: {} };
+    }
+    let decoded;
+    try {
+        decoded = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+    }
+    catch (err) {
+        backupUnreadableState(statePath, err);
+        return { processed: {} };
+    }
+    const parsed = CaptureStateSchema.safeParse(decoded);
+    if (parsed.success) {
+        const bootstrappedSources = normalizeBootstrappedSources(parsed.data.bootstrapped_sources);
+        return {
+            processed: parsed.data.processed,
+            ...(Object.keys(bootstrappedSources).length > 0
+                ? { bootstrapped_sources: bootstrappedSources }
+                : {}),
+        };
+    }
+    backupUnreadableState(statePath, parsed.error);
+    const lenient = LenientCaptureStateSchema.safeParse(decoded);
+    if (!lenient.success) {
+        return { processed: {} };
+    }
+    const processed = {};
+    for (const [key, value] of Object.entries(lenient.data.processed)) {
+        if (typeof value === "string") {
+            processed[key] = value;
+            continue;
+        }
+        const entry = CaptureStateEntrySchema.safeParse(value);
+        if (entry.success) {
+            processed[key] = entry.data;
+        }
+    }
+    const bootstrappedSources = normalizeBootstrappedSources(lenient.data.bootstrapped_sources);
+    return {
+        processed,
+        ...(Object.keys(bootstrappedSources).length > 0
+            ? { bootstrapped_sources: bootstrappedSources }
+            : {}),
+    };
+}
+function discoverAllSessions(allowedSources, claudeDir, codexDir, cursor, claudeDesktopDir, grokDir) {
+    const sessions = [];
+    // Sources whose discovery actually RAN (and, for sources that catch their own
+    // errors, SUCCEEDED) this run. Only these may be bootstrapped: writing a
+    // first-enable watermark for a source we never read — because its flag was off
+    // or its store was unreadable — would falsely baseline real history and let a
+    // later run save it as new. Claude/Codex don't catch discovery errors, so a
+    // failure aborts the whole run before any watermark; they are live whenever
+    // attempted. Cursor catches (opt-in, best-effort), so it is live only when
+    // enabled AND its read succeeds.
+    const liveSources = new Set();
+    let cursorDiscovery;
+    let claudeDesktopDiscovery;
+    if (!allowedSources || allowedSources.has("claude_code")) {
+        liveSources.add("claude_code");
+        sessions.push(...discoverClaudeCodeSessions(claudeDir).map((session) => ({
+            source: "claude_code",
+            sessionId: session.sessionId,
+            path: session.path,
+            project: session.projectDir,
+        })));
+    }
+    if (!allowedSources || allowedSources.has("codex_cli")) {
+        liveSources.add("codex_cli");
+        sessions.push(...discoverCodexSessions(codexDir).map((session) => ({
+            source: "codex_cli",
+            sessionId: session.sessionId,
+            path: session.path,
+            project: session.root,
+        })));
+    }
+    // Opt-in only: gated on EXPLICIT membership (not `!allowedSources`), so the
+    // null/"all defaults" path never reads the Claude desktop store. FAIL CLOSED:
+    // mark the source live (and therefore bootstrappable) ONLY after a clean scan.
+    // An unreadable store throws in discovery; we skip it for this run rather than
+    // watermark a store we couldn't read — otherwise a later, readable run would
+    // import that private Cowork history as new. This matches Cursor's fail-closed
+    // *watermark* behaviour (live only after a clean read), and records the
+    // outcome so `onadit status` can be honest about an explicit Cowork opt-in.
+    if (allowedSources?.has(CLAUDE_DESKTOP_CAPTURE_SOURCE)) {
+        try {
+            for (const session of discoverClaudeDesktopSessions(claudeDesktopDir)) {
+                sessions.push({
+                    source: CLAUDE_DESKTOP_CAPTURE_SOURCE,
+                    sessionId: session.sessionId,
+                    path: session.path,
+                    project: "cowork",
+                });
+            }
+            liveSources.add(CLAUDE_DESKTOP_CAPTURE_SOURCE);
+            claudeDesktopDiscovery = { ok: true };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const code = err.code;
+            claudeDesktopDiscovery = {
+                ok: false,
+                error: message,
+                ...(typeof code === "string" ? { error_code: code } : {}),
+            };
+            process.stderr.write(`Claude desktop capture: skipped (store unreadable): ${message}\n`);
+        }
+    }
+    if (allowedSources?.has("grok_cli")) {
+        for (const grok of discoverGrokSessions(grokDir)) {
+            sessions.push({ source: "grok_cli", sessionId: grok.sessionId,
+                path: grok.path, project: grok.project, grok });
+        }
+        liveSources.add("grok_cli");
+    }
+    if (cursor.enabled &&
+        (!allowedSources || allowedSources.has(CURSOR_CAPTURE_SOURCE))) {
+        try {
+            const disco = discoverCursorCaptureSessions({
+                cursorDir: cursor.cursorDir,
+                ...(cursor.reader ? { reader: cursor.reader } : {}),
+            });
+            for (const s of disco.sessions) {
+                sessions.push({
+                    source: CURSOR_CAPTURE_SOURCE,
+                    sessionId: s.composerId,
+                    path: disco.dbPath,
+                    project: s.project,
+                    cursor: {
+                        raw: disco.raw,
+                        fingerprintInput: s.fingerprintInput,
+                        projectRoot: s.projectRoot,
+                        projectRootStatus: s.projectRootStatus,
+                        stableKey: s.stableKey,
+                    },
+                });
+            }
+            // Reached only on a clean read — now Cursor is safe to bootstrap. If the
+            // store throws below, we deliberately leave it OUT of liveSources so a
+            // transient read failure on the first-enable run cannot watermark (and
+            // thereby skip) real history that a later, readable run would discover.
+            liveSources.add(CURSOR_CAPTURE_SOURCE);
+            cursorDiscovery = { ok: true };
+        }
+        catch (err) {
+            // Cursor not installed / sqlite3 missing / store read failed: a benign
+            // skip for the RUN (the opt-in must never fail the whole capture), but NO
+            // LONGER a silent one. Record the outcome so status can warn that a
+            // scheduled Cursor opt-in physically can't read its store — instead of
+            // claiming "capture on" off the file-presence probe alone.
+            const message = err instanceof Error ? err.message : String(err);
+            const code = err.code;
+            cursorDiscovery = {
+                ok: false,
+                error: message,
+                ...(typeof code === "string" ? { error_code: code } : {}),
+            };
+            process.stderr.write(`Cursor capture: skipped (store unreadable): ${message}\n`);
+        }
+    }
+    return {
+        sessions,
+        liveSources,
+        ...(cursorDiscovery ? { cursorDiscovery } : {}),
+        ...(claudeDesktopDiscovery ? { claudeDesktopDiscovery } : {}),
+    };
+}
+function applyBootstrap(ctx, sessions, enabledSources, liveSources, cursorConfigEnabled, dryRun) {
+    const bootstrappedSessionKeys = new Set();
+    const nowIso = new Date().toISOString();
+    for (const source of enabledSources) {
+        // Only bootstrap a source whose discovery actually ran (and succeeded) this
+        // run — see `liveSources` in discoverAllSessions. A source that was listed
+        // but not read (flag off, or store unreadable) must NOT get a watermark, or
+        // it would falsely baseline history we never looked at.
+        if (!liveSources.has(source))
+            continue;
+        // Grok opt-in explicitly covers existing and future sessions.
+        if (source === "grok_cli")
+            continue;
+        // Skip sources that don't persist (Cursor with neither the config opt-in nor
+        // both env flags): a watermark is a write we must not make for a triage-only
+        // source.
+        if (!writesEnabledForSource(source, cursorConfigEnabled))
+            continue;
+        if (!shouldBootstrapSource(ctx.state, source, dryRun)) {
+            continue;
+        }
+        const sourceSessions = sessions.filter((session) => session.source === source);
+        for (const session of sourceSessions) {
+            const fingerprint = sessionFingerprint(session);
+            ctx.state.processed[stateKey(session.source, session.sessionId)] = {
+                fingerprint,
+                idempotency_key: "",
+            };
+            bootstrappedSessionKeys.add(stateKey(session.source, session.sessionId));
+        }
+        ensureCounts(ctx.report, source).bootstrapped += sourceSessions.length;
+        ctx.state.bootstrapped_sources = {
+            ...(ctx.state.bootstrapped_sources ?? {}),
+            [source]: nowIso,
+        };
+        ctx.stateChanged = true;
+    }
+    return bootstrappedSessionKeys;
+}
+function deriveTopLevelTotals(report) {
+    const totals = {
+        total_discovered: 0,
+        new_conversations: 0,
+        saved: 0,
+        discarded: 0,
+        review: 0,
+        quarantined: 0,
+        errors: 0,
+        deferred: 0,
+        bootstrapped: 0,
+    };
+    for (const counts of Object.values(report.counts_by_source)) {
+        if (!counts)
+            continue;
+        totals.total_discovered += counts.discovered;
+        totals.new_conversations += counts.new;
+        totals.saved += counts.saved;
+        totals.discarded += counts.discarded;
+        totals.review += counts.review;
+        totals.quarantined += counts.quarantined;
+        totals.errors += counts.errors;
+        totals.deferred += counts.deferred;
+        totals.bootstrapped += counts.bootstrapped;
+    }
+    report.total_discovered = totals.total_discovered;
+    report.new_conversations = totals.new_conversations;
+    report.saved = totals.saved;
+    report.discarded = totals.discarded;
+    report.review = totals.review;
+    report.quarantined = totals.quarantined;
+    report.errors = totals.errors;
+    report.deferred = totals.deferred;
+    report.bootstrapped = totals.bootstrapped;
+    return report;
+}
+function applySessionOutcome(ctx, outcome) {
+    const counts = ensureCounts(ctx.report, outcome.source);
+    counts.new += outcome.counts.new ?? 0;
+    counts.skipped += outcome.counts.skipped ?? 0;
+    counts.saved += outcome.counts.saved ?? 0;
+    counts.review += outcome.counts.review ?? 0;
+    counts.discarded += outcome.counts.discarded ?? 0;
+    counts.quarantined += outcome.counts.quarantined ?? 0;
+    counts.errors += outcome.counts.errors ?? 0;
+    counts.deferred += outcome.counts.deferred ?? 0;
+    ctx.report.results.push(...outcome.results);
+    ctx.report.error_details.push(...outcome.errorDetails);
+    ctx.stateChanged ||= outcome.stateChanged;
+}
+/** True when two processed-ledger entries carry the same fingerprint+key. */
+function processedEntriesEqual(a, b) {
+    if (a === undefined || b === undefined)
+        return a === b;
+    if (typeof a === "string" || typeof b === "string")
+        return a === b;
+    return (a.fingerprint === b.fingerprint && a.idempotency_key === b.idempotency_key);
+}
+/**
+ * Persist the capture state, merging with the ledger as it is now.
+ *
+ * The ledger is read once at run start and written once at run end. Other
+ * capture runs — the daemon tick, `onadit capture`, scripted captures of other
+ * agent homes — may commit in between, from other processes. A blind
+ * overwrite would erase what they ADDED (sessions we never saw) and revert
+ * what they UPDATED (keys we hold but didn't reprocess). So we overlay ONLY
+ * the keys this run changed, detected by diffing against the run-start
+ * snapshot (`initialProcessed`), onto the current ledger. (Two runs changing
+ * the SAME key resolve last-committer-wins; both hold a valid entry.)
+ *
+ * The commit is a compare-and-swap, with no lock: generation N+1 is published
+ * with link(2), which is atomic and fails if N+1 already exists. Losing that
+ * race means another run committed after our read, so we reload, merge again
+ * and retry. A successful link is then checked against the newest generation
+ * (see below), so a save paused long enough for cleanup to free the name it
+ * links cannot pass with an obsolete snapshot. Every generation readers use is
+ * therefore merged from the one before it, and no interleaving can drop an
+ * entry. There is nothing to
+ * recover after a crash — a dead writer leaves at most a temp file — so no
+ * process ever has to judge or delete another's state.
+ */
+async function saveState(dataDir, state, initialProcessed, hooks = {}) {
+    const genDir = path.join(dataDir, STATE_GENERATIONS_DIR);
+    fs.mkdirSync(genDir, { recursive: true });
+    for (let attempt = 0; attempt < STATE_COMMIT_ATTEMPTS; attempt++) {
+        const { state: current, generation } = loadCurrentState(dataDir);
+        await hooks.afterRead?.(attempt);
+        const body = JSON.stringify(mergeCaptureState(current, state, initialProcessed), null, 2);
+        const tmp = path.join(genDir, `.tmp-${process.pid}-${crypto.randomUUID()}`);
+        fs.writeFileSync(tmp, body, "utf-8");
+        try {
+            fs.linkSync(tmp, path.join(genDir, `${generation + 1}.json`));
+        }
+        catch (err) {
+            if (err.code === "EEXIST")
+                continue;
+            throw err;
+        }
+        finally {
+            fs.rmSync(tmp, { force: true });
+        }
+        // link() only proves the name was free, not that it was never used:
+        // cleanup frees old names, so a save paused past the retention window
+        // could land on one with an obsolete snapshot. Cleanup never removes the
+        // newest generation, so in that case a newer one is still on disk. Any
+        // newer generation means "maybe obsolete": merge again from the newest.
+        // (It may instead be a run that already built on ours; re-applying our
+        // changes is then a no-op.)
+        if ((listStateGenerations(genDir).at(-1) ?? 0) > generation + 1)
+            continue;
+        // Mirror for readers that predate generations. It can lag when runs
+        // overlap, so the ledger itself is never read from it once generations exist.
+        await atomicWrite(path.join(dataDir, STATE_FILE), body);
+        pruneStateGenerations(genDir, generation + 1);
+        return;
+    }
+    throw new Error(`Auto-capture state: gave up after ${STATE_COMMIT_ATTEMPTS} commit attempts (other capture runs kept committing)`);
+}
+function mergeCaptureState(current, state, initialProcessed) {
+    const mergedProcessed = { ...current.processed };
+    for (const [key, value] of Object.entries(state.processed)) {
+        if (!processedEntriesEqual(initialProcessed[key], value)) {
+            mergedProcessed[key] = value;
+        }
+    }
+    const mergedBootstrapped = {
+        ...(current.bootstrapped_sources ?? {}),
+        ...(state.bootstrapped_sources ?? {}),
+    };
+    return {
+        processed: mergedProcessed,
+        ...(Object.keys(mergedBootstrapped).length > 0
+            ? { bootstrapped_sources: mergedBootstrapped }
+            : {}),
+    };
+}
+/**
+ * Drop old generations and stray temp files. A file is removed only when it
+ * is older than STATE_GENERATION_KEEP_MS and not among the newest few, far
+ * beyond a normal read-to-commit window (milliseconds). A save paused longer
+ * than that is caught by saveState's post-link check. Best-effort.
+ */
+function pruneStateGenerations(genDir, newest) {
+    const cutoff = Date.now() - STATE_GENERATION_KEEP_MS;
+    let names;
+    try {
+        names = fs.readdirSync(genDir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        const gen = /^(\d+)\.json$/.exec(name)?.[1];
+        if (gen !== undefined && Number(gen) > newest - STATE_GENERATION_KEEP_COUNT)
+            continue;
+        if (gen === undefined && !name.startsWith(".tmp-"))
+            continue;
+        const file = path.join(genDir, name);
+        try {
+            if (fs.statSync(file).mtimeMs < cutoff)
+                fs.rmSync(file, { force: true });
+        }
+        catch {
+            // already gone
+        }
+    }
+}
+/** Test hooks: the ledger save and load, callable from a separate process. */
+export async function saveCaptureStateForTests(dataDir, state, initialProcessed, hooks = {}) {
+    await saveState(dataDir, state, initialProcessed, hooks);
+}
+export function loadCaptureStateForTests(dataDir) {
+    return loadState(dataDir);
+}
+/**
+ * Write an operator-recovery record for a Codex session that was skipped
+ * before triage because it exceeds the configured byte-size threshold.
+ *
+ * Filename is deterministic (`codex_cli_<sessionId>_<fingerprint>.json`) so
+ * repeated runs collide on the same path; the existsSync gate makes the
+ * write a no-op on retry. The source jsonl is never read or mutated — the
+ * record only carries metadata the operator needs to backfill or raise the
+ * threshold later.
+ */
+async function writeOversizedQuarantineRecord(opts) {
+    const dir = path.join(opts.dataDir, "quarantine");
+    fs.mkdirSync(dir, { recursive: true });
+    const filename = `${opts.source}_${opts.sessionId}_${opts.fingerprint}.json`;
+    const target = path.join(dir, filename);
+    if (fs.existsSync(target))
+        return;
+    const remediation = opts.source === CURSOR_CAPTURE_SOURCE
+        ? "Raise AutoCaptureDeps.cursorMaxSessionBytes for the run, or split the Cursor session."
+        : "Raise capture.codex_cli.max_session_bytes (and restart the daemon), or use the future opt-in chunked-summarize backfill.";
+    const record = {
+        source: opts.source,
+        session_id: opts.sessionId,
+        session_path: opts.sessionPath,
+        size_bytes: opts.sizeBytes,
+        threshold_bytes: opts.thresholdBytes,
+        fingerprint: opts.fingerprint,
+        reason: "oversized-session",
+        remediation,
+        quarantined_at: new Date().toISOString(),
+    };
+    await atomicWrite(target, JSON.stringify(record, null, 2));
+}
+/**
+ * Compute a content hash for deduplication.
+ * Uses file size + last few bytes as a fast fingerprint.
+ * A full content hash would be too slow for large files.
+ */
+function contentFingerprint(filePath) {
+    const stat = fs.statSync(filePath);
+    const size = stat.size;
+    // Read last 4KB for fingerprinting (captures recent messages)
+    const fd = fs.openSync(filePath, "r");
+    const tailSize = Math.min(size, 4096);
+    const buf = Buffer.alloc(tailSize);
+    fs.readSync(fd, buf, 0, tailSize, Math.max(0, size - tailSize));
+    fs.closeSync(fd);
+    return crypto
+        .createHash("sha256")
+        .update(`${size}:`)
+        .update(buf)
+        .digest("hex")
+        .slice(0, 16);
+}
+async function processSession(session, state, deps) {
+    const empty = () => ({
+        source: session.source,
+        counts: {},
+        results: [],
+        errorDetails: [],
+        stateChanged: false,
+    });
+    try {
+        const skip = (reason) => ({
+            ...empty(), counts: { skipped: 1 },
+            skipDetails: [{ source: session.source, sessionId: session.sessionId, path: session.path, reason }],
+        });
+        if (session.grok?.skipReason)
+            return skip(session.grok.skipReason);
+        const fingerprint = sessionFingerprint(session);
+        // Cursor is triage-only this slice: no /save, no review-queue, no
+        // capture-state write — regardless of --dry-run. See writesEnabledForSource.
+        const writesAllowed = !deps.dryRun &&
+            writesEnabledForSource(session.source, Boolean(deps.cursorConfigEnabled));
+        const cursorResultFields = session.cursor
+            ? {
+                projectRootStatus: session.cursor.projectRootStatus,
+                stableKey: session.cursor.stableKey,
+            }
+            : {};
+        // Cursor titles are private (user's session name / first prompt), and even
+        // the triage-only dry-run prints result titles to the terminal and JSON.
+        // Redact to a non-identifying label by default; reveal only behind an
+        // explicit opt-in. Claude/Codex titles are untouched.
+        const displayTitle = (parsedTitle) => {
+            if (session.cursor && !cursorTitlesRevealed()) {
+                return redactedCursorTitle(session.sessionId);
+            }
+            return parsedTitle ?? "(empty)";
+        };
+        const prev = getPreviousEntry(state, session.source, session.sessionId);
+        const prevFingerprint = typeof prev === "string" ? prev : prev?.fingerprint;
+        const prevKey = typeof prev === "object" ? prev?.idempotency_key : undefined;
+        if (prevFingerprint === fingerprint) {
+            if (session.grok)
+                return skip("Unchanged since previous capture");
+            return {
+                ...empty(),
+                counts: { skipped: 1 },
+            };
+        }
+        if (session.source === "codex_cli") {
+            const maxBytes = deps.codexMaxSessionBytes ?? DEFAULT_CODEX_MAX_SESSION_BYTES;
+            const sizeBytes = fs.statSync(session.path).size;
+            if (sizeBytes > maxBytes) {
+                const outcome = empty();
+                outcome.counts.quarantined = 1;
+                if (!deps.dryRun) {
+                    await writeOversizedQuarantineRecord({
+                        source: session.source,
+                        dataDir: deps.dataDir,
+                        sessionId: session.sessionId,
+                        sessionPath: session.path,
+                        sizeBytes,
+                        thresholdBytes: maxBytes,
+                        fingerprint,
+                    });
+                    state.processed[stateKey(session.source, session.sessionId)] = {
+                        fingerprint,
+                        idempotency_key: QUARANTINED_OVERSIZED_KEY,
+                    };
+                    outcome.stateChanged = true;
+                }
+                return outcome;
+            }
+        }
+        const isUpdate = prevFingerprint !== undefined;
+        const outcome = empty();
+        outcome.counts.new = 1;
+        let parsed;
+        if (session.cursor) {
+            parsed = parseCursorComposerSession(session.cursor.raw, session.sessionId);
+        }
+        else {
+            const data = fs.readFileSync(session.path, "utf-8");
+            parsed =
+                session.source === "claude_code"
+                    ? parseClaudeCodeSession(session.sessionId, data)
+                    : session.grok
+                        ? parseGrokSession(session.sessionId, data, session.grok.metadata)
+                        : session.source === CLAUDE_DESKTOP_CAPTURE_SOURCE
+                            ? parseClaudeDesktopSession(session.sessionId, data)
+                            : parseCodexSession(session.sessionId, data);
+        }
+        if (!parsed || parsed.content.length < 100) {
+            if (writesAllowed) {
+                state.processed[stateKey(session.source, session.sessionId)] = {
+                    fingerprint,
+                    idempotency_key: "",
+                };
+                outcome.stateChanged = true;
+            }
+            outcome.counts.discarded = 1;
+            outcome.results.push({
+                source: session.source,
+                sessionId: session.sessionId,
+                title: displayTitle(parsed?.title),
+                decision: "discard",
+                confidence: 1.0,
+                model: "n/a",
+                provider: "auto-capture",
+                summary: "Too short or empty",
+                ...cursorResultFields,
+            });
+            return outcome;
+        }
+        // Cursor size guard. Cursor has no file to stat (its content lives in a
+        // shared `state.vscdb`), so the guard runs on the PARSED transcript — the
+        // exact text triage would feed the subprocess — and fires BEFORE any triage
+        // or save. Mirrors the codex oversized path: quarantine, never triage. The
+        // quarantine record + capture-state sentinel are writes, so they only land
+        // when writes are allowed (persist on, non-dry); otherwise it is a pure skip.
+        //
+        // TERMINAL by design (decided pre-scheduling): unlike Codex, an oversized
+        // Cursor session has NO auto-recovery path — `recover-quarantine` globs only
+        // `codex_cli_` records, so it never touches the `cursor_composer_` record we
+        // write here, and `countParkedOversizedSessions` never raises a "run repair"
+        // advisory for it. The record is operator-visible metadata only; the sole
+        // remediation is to raise the byte limit or split the session, after which
+        // the grown/changed fingerprint re-discovers it on a later run. Cursor
+        // chunked-summarize backfill is deferred to the scheduling slice.
+        if (session.cursor) {
+            const sizeBytes = Buffer.byteLength(parsed.content, "utf8");
+            const maxBytes = deps.cursorMaxSessionBytes ?? DEFAULT_CURSOR_MAX_SESSION_BYTES;
+            if (sizeBytes > maxBytes) {
+                const oversized = empty();
+                oversized.counts.quarantined = 1;
+                if (writesAllowed) {
+                    await writeOversizedQuarantineRecord({
+                        source: session.source,
+                        dataDir: deps.dataDir,
+                        sessionId: session.sessionId,
+                        sessionPath: session.path,
+                        sizeBytes,
+                        thresholdBytes: maxBytes,
+                        fingerprint,
+                    });
+                    state.processed[stateKey(session.source, session.sessionId)] = {
+                        fingerprint,
+                        idempotency_key: QUARANTINED_OVERSIZED_KEY,
+                    };
+                    oversized.stateChanged = true;
+                }
+                return oversized;
+            }
+        }
+        const triage = await triageConversation(parsed.content);
+        const result = {
+            source: session.source,
+            sessionId: session.sessionId,
+            title: displayTitle(parsed.title),
+            decision: triage.decision,
+            confidence: triage.confidence,
+            model: triage.model,
+            provider: triage.provider,
+            summary: triage.summary,
+            ...cursorResultFields,
+        };
+        outcome.results.push(result);
+        // Only quotes found inside a turn the user typed are kept; see
+        // user-statements.ts. The worker's claims alone are never stored. What
+        // the session's previous capture stored is checked again alongside them.
+        const earlier = await deps.storedStatements?.(session.source, session.sessionId);
+        const userStatements = (await verifyUserStatementsWithEvidence({
+            content: parsed.content,
+            userSpans: parsed.userSpans,
+            decisions: triage.user_decisions,
+            constraints: triage.user_constraints,
+            earlier,
+        }, deps.assistantText)).map(encodeUserStatement);
+        const saidByUser = userStatements.length > 0 && writesAllowed
+            ? {
+                decisions: userStatements,
+                user_statements_seal: sealUserStatements(deps.dataDir, userStatements, parsed.content),
+            }
+            : {};
+        if (!writesAllowed) {
+            // Writes are off for one of two reasons, and they are NOT equivalent:
+            //   - dry-run of a persistable source: a faithful preview of what a real
+            //     run WOULD persist, so save/review count as saved/review.
+            //   - a source whose persistence is gated off this slice (Cursor): a real
+            //     run would not persist it either, so reporting "saved" is a lie. Even
+            //     a non-dry `onadit capture` reaches the health ledger (capture.ts), and
+            //     `onadit status` would then sum those as real saved sessions. Bucket
+            //     these as `deferred` so neither the ledger nor status ever inflates.
+            // Bucketing keys on the SOURCE (writesEnabledForSource), not --dry-run, so
+            // a gated source reads `deferred` consistently in dry and non-dry runs.
+            const persistable = writesEnabledForSource(session.source, Boolean(deps.cursorConfigEnabled));
+            switch (triage.decision) {
+                case "save":
+                    if (persistable)
+                        outcome.counts.saved = 1;
+                    else
+                        outcome.counts.deferred = 1;
+                    break;
+                case "review":
+                    if (persistable)
+                        outcome.counts.review = 1;
+                    else
+                        outcome.counts.deferred = 1;
+                    break;
+                case "discard":
+                    // A discard persists nothing regardless of the gate, so it is honest
+                    // in either case and never inflates a "saved" count.
+                    outcome.counts.discarded = 1;
+                    break;
+            }
+            return outcome;
+        }
+        switch (triage.decision) {
+            case "save": {
+                const newKey = `auto-capture:${session.source}:${session.sessionId}:${fingerprint}`;
+                await deps.saveFn({
+                    source: session.source,
+                    summary: triage.summary,
+                    content: parsed.content,
+                    topics: triage.topics,
+                    ...saidByUser,
+                    idempotency_key: newKey,
+                    ...(isUpdate && prevKey ? { replace_idempotency_key: prevKey } : {}),
+                    ...(parsed.cwd ? { cwd: parsed.cwd } : {}),
+                });
+                outcome.counts.saved = 1;
+                break;
+            }
+            case "review": {
+                await addToReview(deps.dataDir, {
+                    source: session.source,
+                    conversationId: session.sessionId,
+                    summary: triage.summary,
+                    content: parsed.content,
+                    triage,
+                    ...saidByUser,
+                    project: session.project,
+                });
+                outcome.counts.review = 1;
+                break;
+            }
+            case "discard": {
+                outcome.counts.discarded = 1;
+                break;
+            }
+        }
+        const savedKey = triage.decision === "save"
+            ? `auto-capture:${session.source}:${session.sessionId}:${fingerprint}`
+            : undefined;
+        state.processed[stateKey(session.source, session.sessionId)] = {
+            fingerprint,
+            idempotency_key: savedKey ?? "",
+        };
+        outcome.stateChanged = true;
+        return outcome;
+    }
+    catch (err) {
+        return {
+            source: session.source,
+            counts: { errors: 1 },
+            results: [],
+            errorDetails: [{
+                    sessionId: session.sessionId,
+                    source: session.source,
+                    error: `[${session.source}] ${err instanceof Error ? err.message : String(err)}`,
+                }],
+            stateChanged: false,
+        };
+    }
+}
+/**
+ * Run the auto-capture pipeline.
+ *
+ * 1. Discover all supported local CLI conversation files
+ * 2. Filter out already-processed conversations (by session UUID + content hash)
+ * 3. Parse each new conversation
+ * 4. Triage via Haiku (with Sonnet escalation)
+ * 5. Route: save/review/discard
+ * 6. Update dedupe state
+ */
+export async function runAutoCapture(deps) {
+    const claudeDir = deps.claudeDir ?? path.join(os.homedir(), ".claude");
+    const codexDir = deps.codexDir ?? path.join(os.homedir(), ".codex");
+    const cursorDir = deps.cursorDir ?? defaultCursorDir();
+    const claudeDesktopDir = deps.claudeDesktopDir ??
+        path.join(os.homedir(), "Library", "Application Support", "Claude");
+    const assistantText = deps.assistantText ??
+        createAssistantTextLookup({
+            ownedBy: ownsPassage,
+            roots: sessionRoots({
+                sources: deps.sources ?? ["claude_code", "codex_cli"],
+                claudeDir,
+                codexDir,
+                claudeDesktopDir,
+                grokDir: deps.grokDir,
+            }),
+        });
+    const state = loadState(deps.dataDir);
+    // Snapshot the ledger exactly as loaded so the end-of-run merge can overlay
+    // ONLY the keys this run actually changed (see saveState). Capturing it here
+    // — before bootstrap or processing mutates `state.processed` — is what lets
+    // a slow run avoid clobbering a concurrent run's newer entry for a key this
+    // run never touched.
+    const initialProcessed = { ...state.processed };
+    const allowedSources = deps.sources ? new Set(deps.sources) : null;
+    // Cursor is enabled for this run via EITHER the config opt-in
+    // (`cursorConfigEnabled` — cursor_composer in config.capture.sources, the
+    // scheduled path) OR the `RIFT_CURSOR_CAPTURE` env flag (the ad-hoc/dogfood
+    // path). Config enablement also authorizes persistence (see
+    // writesEnabledForSource); the env path still needs CURSOR_CAPTURE_PERSIST.
+    const cursorConfigEnabled = Boolean(deps.cursorConfigEnabled);
+    const cursorOn = cursorConfigEnabled || cursorCaptureEnabled();
+    // When no explicit source filter was given and Cursor is on (config or env),
+    // it joins the default run so its sessions show up alongside claude/codex.
+    const enabledSources = deps.sources
+        ? deps.sources
+        : cursorOn
+            ? [...DEFAULT_AUTO_CAPTURE_SOURCES, CURSOR_CAPTURE_SOURCE]
+            : DEFAULT_AUTO_CAPTURE_SOURCES;
+    const { sessions, liveSources, cursorDiscovery, claudeDesktopDiscovery } = discoverAllSessions(allowedSources, claudeDir, codexDir, {
+        enabled: cursorOn,
+        cursorDir,
+        ...(deps.cursorReader ? { reader: deps.cursorReader } : {}),
+    }, claudeDesktopDir, deps.grokDir ?? path.join(os.homedir(), ".grok"));
+    const report = {
+        total_discovered: 0,
+        new_conversations: 0,
+        saved: 0,
+        discarded: 0,
+        review: 0,
+        quarantined: 0,
+        errors: 0,
+        deferred: 0,
+        bootstrapped: 0,
+        preflight_ok: true,
+        counts_by_source: {},
+        results: [],
+        error_details: [],
+        skipped_details: [],
+        ...(cursorDiscovery ? { cursor_discovery: cursorDiscovery } : {}),
+        ...(claudeDesktopDiscovery
+            ? { claude_desktop_discovery: claudeDesktopDiscovery }
+            : {}),
+    };
+    for (const source of enabledSources) {
+        ensureCounts(report, source);
+    }
+    for (const session of sessions) {
+        ensureCounts(report, session.source).discovered++;
+    }
+    const ctx = {
+        state,
+        report,
+        stateChanged: false,
+    };
+    const bootstrappedSessionKeys = applyBootstrap(ctx, sessions, enabledSources, liveSources, cursorConfigEnabled, Boolean(deps.dryRun));
+    const sessionsToProcess = sessions.filter((session) => !bootstrappedSessionKeys.has(stateKey(session.source, session.sessionId)));
+    if (enabledSources.length > 0) {
+        // Stamp the worker that this run's preflight will use (and did use, on
+        // failure) BEFORE running it, so the recorded outcome is attributable to the
+        // worker that actually ran — never re-inferred later from drifting config or
+        // ambiguous error text. `deps.preflightTriage` (test seam) stands in for the
+        // configured provider, so the configured name is still the right label.
+        report.preflight_worker =
+            getConfiguredTriageProviderName() === "claude_code" ? "claude" : "codex";
+        try {
+            await (deps.preflightTriage ?? ensureAutoCaptureTriageReady)();
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            // Preflight is a triage-worker health probe (Codex or Claude), NOT a
+            // conversation. Record it on its own field + the preflight_ok health flag,
+            // never as per-source conversation errors — so the "N failed" count
+            // reflects only real sessions. (autoCaptureRunFailed still flags the run
+            // via preflight_ok.)
+            report.preflight_ok = false;
+            report.preflight_error = error;
+            // A timeout/termination is transient (cold start, brief contention) and
+            // has already been retried once at the runner. Don't abort the whole run
+            // over a flaky probe — continue and let each session's own bounded-retry
+            // triage decide; failures that remain are recorded as real per-session
+            // errors and self-heal next run. A genuine auth/path failure (ENOENT,
+            // non-zero exit) is fatal: abort rather than hammer every session with an
+            // identical failure that would only bury the root cause.
+            if (!isTransientPreflightError(err)) {
+                if (ctx.stateChanged) {
+                    await saveState(deps.dataDir, state, initialProcessed);
+                }
+                return deriveTopLevelTotals(report);
+            }
+        }
+    }
+    const storedStatements = deps.storedStatements ?? createStoredStatementsLookup(deps.dataDir);
+    for (const session of sessionsToProcess) {
+        const outcome = await processSession(session, state, { ...deps, assistantText, storedStatements });
+        applySessionOutcome(ctx, outcome);
+        if (outcome.skipDetails)
+            report.skipped_details.push(...outcome.skipDetails);
+    }
+    // Persist updated state
+    if (!deps.dryRun && ctx.stateChanged) {
+        await saveState(deps.dataDir, state, initialProcessed);
+    }
+    return deriveTopLevelTotals(report);
+}
+//# sourceMappingURL=auto-capture.js.map