@getrift/rift 0.1.0-beta.20 → 0.1.0-beta.22

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

@@ -21,12 +21,16 @@ import os from "node:os";
 import { z } from "zod";
 import { discoverClaudeCodeSessions, parseClaudeCodeSession, } from "../ingestion/parsers/claude-code-jsonl.js";
 import { discoverCodexSessions, parseCodexSession, } from "../ingestion/parsers/codex-jsonl.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 { addToReview } from "./review-queue.js";
 import { atomicWrite } from "../storage/atomic.js";
-import { CodexCliTriageProvider } from "./codex-cli-triage-provider.js";
+import { createConfiguredTriageProvider, getConfiguredTriageProviderName, } from "./triage-provider-factory.js";
 import { CodexCliTimeoutError } from "../providers/codex-cli-runner.js";
-import { DEFAULT_AUTO_CAPTURE_SOURCES, } from "./sources.js";
+import { ClaudeCliTimeoutError } from "../providers/claude-cli-runner.js";
+import { AUTO_CAPTURE_SOURCE_VALUES, 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
@@ -36,6 +40,16 @@ import { DEFAULT_AUTO_CAPTURE_SOURCES, } from "./sources.js";
  * 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";
 /**
@@ -54,6 +68,16 @@ 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, `rift 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
@@ -66,11 +90,62 @@ 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";
+/**
+ * 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.cursor) {
+        return crypto
+            .createHash("sha256")
+            .update(session.cursor.fingerprintInput)
+            .digest("hex")
+            .slice(0, 16);
+    }
+    return contentFingerprint(session.path);
+}
 export function zeroCounts() {
     return {
         discovered: 0,
@@ -134,19 +209,20 @@ function shouldBootstrapSource(state, source, dryRun) {
     return !hasPriorStateForSource(state, source);
 }
 /**
- * Whether a preflight failure is transient (a Codex timeout/termination) and
+ * 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;
+    return (err instanceof CodexCliTimeoutError || err instanceof ClaudeCliTimeoutError);
 }
 async function ensureAutoCaptureTriageReady() {
-    // This is intentionally a tiny real Codex CLI model call, not a cheap
-    // version check: it catches expired auth and runtime/model failures before
-    // a capture run starts mutating state.
-    await new CodexCliTriageProvider({ timeoutMs: 120_000 }).triage({
+    // 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",
     });
@@ -181,7 +257,11 @@ function backupUnreadableState(statePath, error) {
 }
 function normalizeBootstrappedSources(sources) {
     const bootstrappedSources = {};
-    for (const source of DEFAULT_AUTO_CAPTURE_SOURCES) {
+    // 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;
@@ -236,9 +316,20 @@ function loadState(dataDir) {
             : {}),
     };
 }
-function discoverAllSessions(allowedSources, claudeDir, codexDir) {
+function discoverAllSessions(allowedSources, claudeDir, codexDir, cursor) {
     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;
     if (!allowedSources || allowedSources.has("claude_code")) {
+        liveSources.add("claude_code");
         sessions.push(...discoverClaudeCodeSessions(claudeDir).map((session) => ({
             source: "claude_code",
             sessionId: session.sessionId,
@@ -247,6 +338,7 @@ function discoverAllSessions(allowedSources, claudeDir, codexDir) {
         })));
     }
     if (!allowedSources || allowedSources.has("codex_cli")) {
+        liveSources.add("codex_cli");
         sessions.push(...discoverCodexSessions(codexDir).map((session) => ({
             source: "codex_cli",
             sessionId: session.sessionId,
@@ -254,18 +346,78 @@ function discoverAllSessions(allowedSources, claudeDir, codexDir) {
             project: session.root,
         })));
     }
-    return sessions;
+    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 } : {}),
+    };
 }
-function applyBootstrap(ctx, sessions, enabledSources, dryRun) {
+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;
+        // 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 = contentFingerprint(session.path);
+            const fingerprint = sessionFingerprint(session);
             ctx.state.processed[stateKey(session.source, session.sessionId)] = {
                 fingerprint,
                 idempotency_key: "",
@@ -290,6 +442,8 @@ function deriveTopLevelTotals(report) {
         review: 0,
         quarantined: 0,
         errors: 0,
+        deferred: 0,
+        bootstrapped: 0,
     };
     for (const counts of Object.values(report.counts_by_source)) {
         if (!counts)
@@ -301,6 +455,8 @@ function deriveTopLevelTotals(report) {
         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;
@@ -309,6 +465,8 @@ function deriveTopLevelTotals(report) {
     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) {
@@ -320,6 +478,7 @@ function applySessionOutcome(ctx, outcome) {
     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;
@@ -389,19 +548,22 @@ async function saveState(dataDir, state, initialProcessed) {
 async function writeOversizedQuarantineRecord(opts) {
     const dir = path.join(opts.dataDir, "quarantine");
     fs.mkdirSync(dir, { recursive: true });
-    const filename = `codex_cli_${opts.sessionId}_${opts.fingerprint}.json`;
+    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: "codex_cli",
+        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: "Raise capture.codex_cli.max_session_bytes (and restart the daemon), or use the future opt-in chunked-summarize backfill.",
+        remediation,
         quarantined_at: new Date().toISOString(),
     };
     await atomicWrite(target, JSON.stringify(record, null, 2));
@@ -436,7 +598,27 @@ async function processSession(session, state, deps) {
         stateChanged: false,
     });
     try {
-        const fingerprint = contentFingerprint(session.path);
+        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;
@@ -454,6 +636,7 @@ async function processSession(session, state, deps) {
                 outcome.counts.quarantined = 1;
                 if (!deps.dryRun) {
                     await writeOversizedQuarantineRecord({
+                        source: session.source,
                         dataDir: deps.dataDir,
                         sessionId: session.sessionId,
                         sessionPath: session.path,
@@ -473,12 +656,18 @@ async function processSession(session, state, deps) {
         const isUpdate = prevFingerprint !== undefined;
         const outcome = empty();
         outcome.counts.new = 1;
-        const data = fs.readFileSync(session.path, "utf-8");
-        const parsed = session.source === "claude_code"
-            ? parseClaudeCodeSession(session.sessionId, data)
-            : parseCodexSession(session.sessionId, data);
+        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)
+                : parseCodexSession(session.sessionId, data);
+        }
         if (!parsed || parsed.content.length < 100) {
-            if (!deps.dryRun) {
+            if (writesAllowed) {
                 state.processed[stateKey(session.source, session.sessionId)] = {
                     fingerprint,
                     idempotency_key: "",
@@ -489,36 +678,97 @@ async function processSession(session, state, deps) {
             outcome.results.push({
                 source: session.source,
                 sessionId: session.sessionId,
-                title: parsed?.title ?? "(empty)",
+                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: parsed.title,
+            title: displayTitle(parsed.title),
             decision: triage.decision,
             confidence: triage.confidence,
             model: triage.model,
             provider: triage.provider,
             summary: triage.summary,
+            ...cursorResultFields,
         };
         outcome.results.push(result);
-        if (deps.dryRun) {
+        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 `rift capture` reaches the health ledger (capture.ts), and
+            //     `rift 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":
-                    outcome.counts.saved = 1;
+                    if (persistable)
+                        outcome.counts.saved = 1;
+                    else
+                        outcome.counts.deferred = 1;
                     break;
                 case "review":
-                    outcome.counts.review = 1;
+                    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;
             }
@@ -592,6 +842,7 @@ async function processSession(session, state, deps) {
 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 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
@@ -600,8 +851,25 @@ export async function runAutoCapture(deps) {
     // run never touched.
     const initialProcessed = { ...state.processed };
     const allowedSources = deps.sources ? new Set(deps.sources) : null;
-    const enabledSources = deps.sources ?? DEFAULT_AUTO_CAPTURE_SOURCES;
-    const sessions = discoverAllSessions(allowedSources, claudeDir, codexDir);
+    // 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 } = discoverAllSessions(allowedSources, claudeDir, codexDir, {
+        enabled: cursorOn,
+        cursorDir,
+        ...(deps.cursorReader ? { reader: deps.cursorReader } : {}),
+    });
     const report = {
         total_discovered: 0,
         new_conversations: 0,
@@ -610,10 +878,13 @@ export async function runAutoCapture(deps) {
         review: 0,
         quarantined: 0,
         errors: 0,
+        deferred: 0,
+        bootstrapped: 0,
         preflight_ok: true,
         counts_by_source: {},
         results: [],
         error_details: [],
+        ...(cursorDiscovery ? { cursor_discovery: cursorDiscovery } : {}),
     };
     for (const source of enabledSources) {
         ensureCounts(report, source);
@@ -626,18 +897,26 @@ export async function runAutoCapture(deps) {
         report,
         stateChanged: false,
     };
-    const bootstrappedSessionKeys = applyBootstrap(ctx, sessions, enabledSources, Boolean(deps.dryRun));
+    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 Codex health probe, 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.)
+            // 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