agentera 3.0.0-dev.6 → 3.0.0-dev.69

package/dist/analytics/extractCorpus/cli.js

@@ -1,14 +1,16 @@
-import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { pyJsonIndent } from "../../core/pyjson.js";
 import { defaultOutputPath, } from "./core.js";
+import { defaultTiersDir, publishEvidenceTiers } from "./evidenceTiers.js";
 import { buildCorpus } from "./corpus.js";
+import { COVERAGE_EXIT_FLAGGED, corpusEnvelopeCoverage, formatCoverageSummaryText, runCoverageAudit, } from "./coverageAudit.js";
+import { formatTruncationWarnings, resolveSqliteCaps } from "./sqliteCaps.js";
 import { resolveCopilotStorePath, resolveCursorChatsPath, resolveCursorProjectsPath, resolveOpencodeDbPath, } from "./cursorSessions.js";
 export function parseExtractArgs(argv, env = process.env, platform = process.platform) {
-    const home = os.homedir();
+    const home = env.HOME || (platform === "win32" ? env.USERPROFILE : undefined) || os.homedir();
     const args = {
         output: defaultOutputPath(env, platform),
+        tierOutput: null,
         projectRoot: [],
         codexSessionsDir: path.join(home, ".codex", "sessions"),
         claudeProjectsDir: path.join(home, ".claude", "projects"),
@@ -17,11 +19,15 @@ export function parseExtractArgs(argv, env = process.env, platform = process.pla
         cursorProjectsDir: null,
         cursorChatsDir: null,
         noCodex: false,
-        noClaude: false,
+        importSources: [],
         noOpencode: false,
         noCopilot: false,
         noCursor: false,
+        acceptCoverageGap: false,
+        coverageAuditOnly: false,
+        format: "text",
     };
+    let claudeProjectsDirExplicit = false;
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
         const val = (name) => {
@@ -32,14 +38,28 @@ export function parseExtractArgs(argv, env = process.env, platform = process.pla
             return null;
         };
         let v;
+        // `--output` is a deprecated no-op for back-compat: it targeted the
+        // eliminated monolithic corpus.json write. Refresh now publishes bounded
+        // tiers via `--tier-output` (default: `defaultTiersDir`). `--output` is
+        // accepted to keep older callers from hard-crashing but has no effect.
         if ((v = val("--output")) !== null)
             args.output = v;
+        else if ((v = val("--tier-output")) !== null)
+            args.tierOutput = v;
         else if ((v = val("--project-root")) !== null)
             args.projectRoot.push(v);
         else if ((v = val("--codex-sessions-dir")) !== null)
             args.codexSessionsDir = v;
-        else if ((v = val("--claude-projects-dir")) !== null)
+        else if ((v = val("--claude-projects-dir")) !== null) {
             args.claudeProjectsDir = v;
+            claudeProjectsDirExplicit = true;
+        }
+        else if ((v = val("--import-source")) !== null) {
+            if (v !== "claude")
+                throw new Error(`extract-corpus: unsupported historical import source '${v}'; valid source: claude`);
+            if (!args.importSources.includes(v))
+                args.importSources.push(v);
+        }
         else if ((v = val("--opencode-conversations-dir")) !== null)
             args.opencodeConversationsDir = v;
         else if ((v = val("--copilot-conversations-dir")) !== null)
@@ -50,17 +70,39 @@ export function parseExtractArgs(argv, env = process.env, platform = process.pla
             args.cursorChatsDir = v;
         else if (a === "--no-codex")
             args.noCodex = true;
-        else if (a === "--no-claude")
-            args.noClaude = true;
         else if (a === "--no-opencode")
             args.noOpencode = true;
         else if (a === "--no-copilot")
             args.noCopilot = true;
         else if (a === "--no-cursor")
             args.noCursor = true;
+        else if (a === "--accept-coverage-gap")
+            args.acceptCoverageGap = true;
+        else if (a === "--coverage-audit-only")
+            args.coverageAuditOnly = true;
+        else if ((v = val("--max-sqlite-sessions")) !== null) {
+            args.maxSqliteSessions = Number.parseInt(v, 10);
+            if (!Number.isFinite(args.maxSqliteSessions) || args.maxSqliteSessions < 1) {
+                throw new Error(`extract-corpus: invalid --max-sqlite-sessions: ${v}`);
+            }
+        }
+        else if ((v = val("--max-sqlite-rows")) !== null) {
+            args.maxSqliteRows = Number.parseInt(v, 10);
+            if (!Number.isFinite(args.maxSqliteRows) || args.maxSqliteRows < 1) {
+                throw new Error(`extract-corpus: invalid --max-sqlite-rows: ${v}`);
+            }
+        }
+        else if ((v = val("--format")) !== null) {
+            if (v !== "text" && v !== "json")
+                throw new Error(`extract-corpus: unsupported format '${v}'`);
+            args.format = v;
+        }
         else
             throw new Error(`extract-corpus: unrecognized argument: ${a}`);
     }
+    if (claudeProjectsDirExplicit && !args.importSources.includes("claude")) {
+        throw new Error("extract-corpus: --claude-projects-dir requires explicit --import-source claude");
+    }
     return args;
 }
 /** Engine entry point mirroring scripts/extract_corpus.py main(). */
@@ -79,23 +121,70 @@ export function extractCorpusMain(argv, io = {}) {
         return 2;
     }
     const projectRoots = args.projectRoot.length > 0 ? args.projectRoot : [cwd];
+    if (args.importSources.includes("claude")) {
+        err("Historical import warning: Claude transcripts can contain secrets, file contents, and command output. " +
+            "Import is local and read-only; records are labeled historical_import and excluded from active-runtime analytics.");
+    }
+    const audit = runCoverageAudit(args, env, platform, args.acceptCoverageGap);
+    if (args.format === "json") {
+        out(JSON.stringify({ coverage_audit: audit }, null, 2));
+    }
+    else {
+        out(formatCoverageSummaryText(audit));
+    }
+    if (audit.coverage_gap_flagged) {
+        err("coverage gap flagged (EX2): available runtime(s) skipped; pass --accept-coverage-gap to proceed");
+        return COVERAGE_EXIT_FLAGGED;
+    }
+    if (args.coverageAuditOnly)
+        return 0;
+    const sqliteCaps = resolveSqliteCaps(env, {
+        maxSessions: args.maxSqliteSessions,
+        maxRows: args.maxSqliteRows,
+    });
     const skipCursor = args.noCursor;
     const corpus = buildCorpus({
         projectRoots,
         codexSessionsDir: args.noCodex ? null : args.codexSessionsDir,
-        claudeProjectsDir: args.noClaude ? null : args.claudeProjectsDir,
+        claudeProjectsDir: args.importSources.includes("claude") ? args.claudeProjectsDir : null,
         opencodeConversationsDir: args.noOpencode ? null : args.opencodeConversationsDir || resolveOpencodeDbPath(env),
         copilotConversationsDir: args.noCopilot ? null : args.copilotConversationsDir || resolveCopilotStorePath(env),
         cursorProjectsDir: skipCursor ? null : args.cursorProjectsDir || resolveCursorProjectsPath(env),
         cursorChatsDir: skipCursor ? null : args.cursorChatsDir || resolveCursorChatsPath(env),
+        coverage: corpusEnvelopeCoverage(audit),
+        sqliteCaps,
     });
-    fs.mkdirSync(path.dirname(args.output), { recursive: true });
-    fs.writeFileSync(args.output, pyJsonIndent(corpus) + "\n", "utf-8");
+    const truncationWarning = formatTruncationWarnings(corpus.metadata.runtime_statuses);
+    if (truncationWarning)
+        err(truncationWarning);
     const total = corpus.metadata.total_records;
     const familyBits = Object.entries(corpus.metadata.families)
         .map(([name, summary]) => `${name}=${summary.count}`)
         .join(", ");
-    out(`wrote corpus: ${args.output} (${total} records; ${familyBits})`);
+    // Publish bounded evidence tiers as the canonical bounded publication output.
+    // The monolithic corpus envelope write is eliminated: all bounded consumers
+    // (usage, report, prime coverage, startup analysis, profile synthesis) read
+    // the signal tier and full-evidence shards directly. Legacy monolithic state
+    // receives deterministic refresh guidance rather than read compatibility.
+    const tiersDir = args.tierOutput ?? defaultTiersDir(env, platform);
+    const publication = publishEvidenceTiers(corpus.records, {
+        tiersDir,
+        adapterVersion: corpus.metadata.adapter_version,
+        runtimeStatuses: corpus.metadata.runtime_statuses,
+        env,
+        platform,
+        corpusMetadata: {
+            extracted_at: corpus.metadata.extracted_at,
+            runtime_statuses: corpus.metadata.runtime_statuses,
+            coverage_envelope: {
+                available_runtimes: corpus.metadata.available_runtimes,
+                selected_runtimes: corpus.metadata.selected_runtimes,
+                available_but_not_selected: corpus.metadata.available_but_not_selected,
+            },
+        },
+    });
+    out(`published tiers: ${tiersDir} (generation ${publication.generation}; ` +
+        `${publication.shard_count} shards; ${publication.signal_count} signals; ` +
+        `${publication.signal_bytes} bytes${publication.signal_selection.capped ? "; selection applied" : ""}) [${total} records; ${familyBits}]`);
     return 0;
 }
-//# sourceMappingURL=cli.js.map

package/dist/analytics/extractCorpus/copilotSessions.js

@@ -1,14 +1,15 @@
 import fs from "node:fs";
 import { resolvePath } from "../../core/paths.js";
-import { MAX_SQLITE_ROWS, isoFromMtime, record, signalType, textFromContent, } from "./core.js";
+import { isoFromMtime, record, signalType, textFromContent, } from "./core.js";
 import { isPlainObject, rglob, isFilePath } from "./core.js";
+import { resolveSqliteCaps, } from "./sqliteCaps.js";
 import { PermissionDeniedError, openSqlite, sqliteTimestamp, tableColumns, firstColumn, qualified, } from "./sqliteSessions.js";
 function copilotDbCandidates(storePath) {
     if (isFilePath(storePath))
         return [storePath];
     return rglob(storePath, "session-store.db");
 }
-function copilotRows(conn) {
+function copilotRows(conn, caps) {
     const tables = new Set(conn.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((r) => String(r.name)));
     for (const t of ["sessions", "turns"]) {
         if (!tables.has(t)) {
@@ -61,7 +62,44 @@ function copilotRows(conn) {
                  ${idExpr}
         LIMIT ?
     `;
-    return conn.prepare(query).all(MAX_SQLITE_ROWS);
+    return conn.prepare(query).all(caps.maxRows);
+}
+export function probeCopilotTruncation(conn, caps, fallback) {
+    const tables = new Set(conn.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((r) => String(r.name)));
+    if (!tables.has("sessions") || !tables.has("turns"))
+        return null;
+    const sessionCols = tableColumns(conn, "sessions");
+    const turnCols = tableColumns(conn, "turns");
+    const sessionId = firstColumn(sessionCols, ["id", "session_id", "sessionID"]);
+    const turnSession = firstColumn(turnCols, ["session_id", "sessionID", "session", "sessionId"]);
+    const roleCol = firstColumn(turnCols, ["role", "actor", "author"]);
+    if (!(sessionId && turnSession && roleCol))
+        return null;
+    const turnId = firstColumn(turnCols, ["id", "turn_id", "turnID"]);
+    const sessionTime = firstColumn(sessionCols, ["time", "timestamp", "created_at", "createdAt"]);
+    const turnTime = firstColumn(turnCols, ["time", "timestamp", "created_at", "createdAt"]);
+    const turnOrder = firstColumn(turnCols, ["turn_index", "turnIndex", "idx", "position", "sequence"]);
+    const orderExpr = turnOrder ? `t."${turnOrder}"` : `t."${turnTime || turnSession}"`;
+    const idExpr = turnId ? `t."${turnId}"` : "t.rowid";
+    const turnCount = Number(conn.prepare("SELECT COUNT(*) AS c FROM turns t JOIN sessions s ON t.\"" + turnSession + "\" = s.\"" + sessionId + "\"").get()?.c ?? 0);
+    if (turnCount <= caps.maxRows)
+        return null;
+    const timeExpr = `COALESCE(t."${turnTime || turnSession}", s."${sessionTime || sessionId}")`;
+    const query = `
+    SELECT MIN(turn_ts) AS truncated_at
+    FROM (
+      SELECT ${timeExpr} AS turn_ts
+      FROM turns t
+      JOIN sessions s ON t."${turnSession}" = s."${sessionId}"
+      ORDER BY COALESCE(${orderExpr}, t."${turnSession}"),
+               CASE LOWER(t."${roleCol}") WHEN 'user' THEN 0 WHEN 'assistant' THEN 1 ELSE 2 END,
+               ${idExpr}
+      LIMIT -1 OFFSET ?
+    )
+  `;
+    const row = conn.prepare(query).get(caps.maxRows);
+    const truncatedAt = sqliteTimestamp(row?.truncated_at, fallback);
+    return { truncatedAt, cap: "rows", limit: caps.maxRows };
 }
 function copilotArgumentDict(value) {
     if (isPlainObject(value)) {
@@ -135,9 +173,10 @@ function copilotRowTools(row, errors) {
     }
     return tools.filter((t) => typeof t.tool_name === "string" && t.tool_name);
 }
-export function extractCopilotSessions(storePath, errors) {
+export function extractCopilotSessions(storePath, errors, ctx) {
     if (storePath === null || !fs.existsSync(storePath))
         return [];
+    const caps = ctx?.sqliteCaps ?? resolveSqliteCaps();
     const records = [];
     for (const dbPath of copilotDbCandidates(storePath).slice(0, 1)) {
         const fallbackTimestamp = isoFromMtime(dbPath);
@@ -145,7 +184,10 @@ export function extractCopilotSessions(storePath, errors) {
         let conn = null;
         try {
             conn = openSqlite(dbPath);
-            rows = copilotRows(conn);
+            const truncation = probeCopilotTruncation(conn, caps, fallbackTimestamp);
+            if (truncation && ctx)
+                ctx.truncation = truncation;
+            rows = copilotRows(conn, caps);
         }
         catch (exc) {
             const msg = exc.message || "";
@@ -191,7 +233,8 @@ export function extractCopilotSessions(storePath, errors) {
                     sourceKind: "conversation_turn",
                     timestamp,
                     projectPath,
-                    runtime: "github-copilot",
+                    runtime: "copilot",
+                    sourceProduct: "github-copilot",
                     sourceParts: [resolvePath(dbPath), index, role, content.slice(0, 80)],
                     sessionId: String(row.session_id),
                     data,
@@ -204,7 +247,8 @@ export function extractCopilotSessions(storePath, errors) {
                     sourceKind: "tool_call",
                     timestamp,
                     projectPath,
-                    runtime: "github-copilot",
+                    runtime: "copilot",
+                    sourceProduct: "github-copilot",
                     sourceParts: [resolvePath(dbPath), index, toolIndex, "tool", toolItem.tool_name, row.turn_id],
                     sessionId: String(row.session_id),
                     data: { tool_name: String(toolItem.tool_name), arguments: toolItem.arguments || {} },
@@ -217,7 +261,8 @@ export function extractCopilotSessions(storePath, errors) {
                         sourceKind: "history_prompt",
                         timestamp,
                         projectPath,
-                        runtime: "github-copilot",
+                        runtime: "copilot",
+                        sourceProduct: "github-copilot",
                         sourceParts: [resolvePath(dbPath), index, "history", content.slice(0, 120)],
                         sessionId: String(row.session_id),
                         data: { prompt: content, signal_type: sig },
@@ -228,4 +273,3 @@ export function extractCopilotSessions(storePath, errors) {
     }
     return records;
 }
-//# sourceMappingURL=copilotSessions.js.map

package/dist/analytics/extractCorpus/core.js

@@ -1,9 +1,11 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { resolveProfileDirOverride, resolveXdgDataHome } from "../../core/envPaths.js";
+import { expanduser } from "../../core/paths.js";
 import crypto from "node:crypto";
 import { resolvePath } from "../../core/paths.js";
-export const ADAPTER_VERSION = "agentera-v2-corpus-1";
+export const ADAPTER_VERSION = "agentera-v3-corpus-2";
 export const FAMILIES = [
     "instruction_document",
     "history_prompt",
@@ -13,12 +15,14 @@ export const FAMILIES = [
 ];
 export const RUNTIME_STORE_GLOBS = {
     codex: "*.jsonl",
-    "claude-code": "*.jsonl",
     cursor: "*.jsonl",
-    "cursor-agent": "store.db",
     opencode: "opencode.db",
-    "github-copilot": "session-store.db",
+    copilot: "session-store.db",
+};
+export const HISTORICAL_IMPORT_STORE_GLOBS = {
+    "claude-code": "*.jsonl",
 };
+const ACTIVE_ANALYTICS_RUNTIMES = new Set(["opencode", "codex", "cursor", "copilot"]);
 export const MAX_TOOL_ARG_TEXT = 500;
 export const MAX_SQLITE_ROWS = 100_000;
 export const MAX_SQLITE_SESSIONS = 60;
@@ -64,37 +68,50 @@ export function projectIdFromPath(p) {
 export function defaultAgenteraHome(env = process.env, platform = process.platform) {
     const override = env.AGENTERA_HOME;
     if (override)
-        return override;
+        return expanduser(override);
     if (platform === "darwin")
         return path.join(os.homedir(), "Library", "Application Support", "agentera");
     if (platform === "win32") {
         const appdata = env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
-        return path.join(appdata, "agentera");
+        return path.join(expanduser(appdata), "agentera");
     }
-    const xdg = env.XDG_DATA_HOME || path.join(os.homedir(), ".local", "share");
-    return path.join(xdg, "agentera");
+    return path.join(resolveXdgDataHome(env), "agentera");
 }
 export function defaultProfileDir(env = process.env, platform = process.platform) {
-    const override = env.PROFILERA_PROFILE_DIR;
+    const override = resolveProfileDirOverride(env);
     if (override)
-        return override;
+        return expanduser(override);
     return defaultAgenteraHome(env, platform);
 }
 export function defaultOutputPath(env = process.env, platform = process.platform) {
     return path.join(defaultProfileDir(env, platform), "intermediate", "corpus.json");
 }
 export function runtimeStatus(runtime, opts) {
-    const item = { runtime, status: opts.status, reason: opts.reason };
+    const activeRuntime = opts.activeRuntime ?? (runtime !== null && ACTIVE_ANALYTICS_RUNTIMES.has(runtime));
+    const item = {
+        runtime,
+        source_class: opts.sourceClass ?? (activeRuntime ? "active_runtime" : "historical_import"),
+        source_product: opts.sourceProduct ?? runtime ?? "unknown",
+        active_runtime: activeRuntime,
+        status: opts.status,
+        reason: opts.reason,
+    };
     if (opts.storePath !== null && opts.storePath !== undefined)
         item.store_path = opts.storePath;
-    if (opts.candidateCount !== null && opts.candidateCount !== undefined)
-        item.candidate_count = opts.candidateCount;
+    if (opts.fileCount !== null && opts.fileCount !== undefined)
+        item.file_count = opts.fileCount;
     if (opts.recordCount !== null && opts.recordCount !== undefined)
         item.record_count = opts.recordCount;
     if (opts.errorCount !== null && opts.errorCount !== undefined)
         item.error_count = opts.errorCount;
     if (opts.remediationLabels && opts.remediationLabels.length > 0)
         item.remediation_labels = opts.remediationLabels;
+    if (opts.truncatedAt)
+        item.truncated_at = opts.truncatedAt;
+    if (opts.truncationCap)
+        item.truncation_cap = opts.truncationCap;
+    if (opts.truncationLimit !== null && opts.truncationLimit !== undefined)
+        item.truncation_limit = opts.truncationLimit;
     return item;
 }
 function isDir(p) {
@@ -139,24 +156,31 @@ function rglob(root, pattern) {
     walk(root);
     return out.sort();
 }
-export function discoverRuntimeStore(runtime, storePath) {
+export function discoverRuntimeStore(runtime, storePath, opts = {}) {
+    const statusOpts = {
+        sourceProduct: opts.sourceProduct,
+        sourceClass: opts.sourceClass,
+        activeRuntime: opts.activeRuntime,
+    };
     if (storePath === null) {
-        return runtimeStatus(runtime, { status: "skipped", reason: "disabled", storePath: null });
+        return runtimeStatus(runtime, { status: "skipped", reason: "disabled", storePath: null, ...statusOpts });
     }
     if (!fs.existsSync(storePath)) {
         return runtimeStatus(runtime, {
             status: "missing",
             reason: "store_absent",
             storePath,
-            remediationLabels: runtime === "github-copilot" ? [COPILOT_SPARSE_REMEDIATION] : null,
+            remediationLabels: runtime === "copilot" ? [COPILOT_SPARSE_REMEDIATION] : null,
+            ...statusOpts,
         });
     }
-    if ((runtime === "opencode" || runtime === "github-copilot") && isFilePath(storePath)) {
+    if (isFilePath(storePath)) {
         return runtimeStatus(runtime, {
             status: "available",
             reason: "candidate_files_found",
             storePath,
-            candidateCount: 1,
+            fileCount: 1,
+            ...statusOpts,
         });
     }
     if (!isDir(storePath)) {
@@ -164,7 +188,10 @@ export function discoverRuntimeStore(runtime, storePath) {
     }
     let candidates;
     try {
-        candidates = rglob(storePath, RUNTIME_STORE_GLOBS[runtime]);
+        const pattern = opts.pattern ?? (runtime === null ? undefined : RUNTIME_STORE_GLOBS[runtime]);
+        if (!pattern)
+            throw new Error("no declared store pattern");
+        candidates = rglob(storePath, pattern);
     }
     catch {
         return runtimeStatus(runtime, { status: "degraded", reason: "store_unreadable", storePath });
@@ -174,15 +201,17 @@ export function discoverRuntimeStore(runtime, storePath) {
             status: "sparse",
             reason: "no_candidate_files",
             storePath,
-            candidateCount: 0,
-            remediationLabels: runtime === "github-copilot" ? [COPILOT_SPARSE_REMEDIATION] : null,
+            fileCount: 0,
+            remediationLabels: runtime === "copilot" ? [COPILOT_SPARSE_REMEDIATION] : null,
+            ...statusOpts,
         });
     }
     return runtimeStatus(runtime, {
         status: "available",
         reason: "candidate_files_found",
         storePath,
-        candidateCount: candidates.length,
+        fileCount: candidates.length,
+        ...statusOpts,
     });
 }
 // ── record builders + content helpers ──────────────────────────────
@@ -193,12 +222,16 @@ export function splitLines(text) {
     return parts;
 }
 export function record(opts) {
+    const activeRuntime = opts.activeRuntime ?? (opts.runtime !== null && ACTIVE_ANALYTICS_RUNTIMES.has(opts.runtime));
     const item = {
         source_id: stableId(opts.sourceKind, ...opts.sourceParts),
         timestamp: opts.timestamp,
         project_id: projectIdFromPath(opts.projectPath),
         source_kind: opts.sourceKind,
         runtime: opts.runtime,
+        source_class: opts.sourceClass ?? (activeRuntime ? "active_runtime" : "project"),
+        source_product: opts.sourceProduct ?? opts.runtime ?? "unknown",
+        active_runtime: activeRuntime,
         adapter_version: ADAPTER_VERSION,
         data: opts.data,
     };
@@ -345,13 +378,15 @@ export function toolCallRecordFromItem(args) {
         timestamp: eventTimestamp(event, args.fallbackTimestamp),
         projectPath: args.projectPath,
         runtime: args.runtime,
+        sourceClass: args.sourceClass,
+        sourceProduct: args.sourceProduct,
+        activeRuntime: args.activeRuntime,
         sourceParts: [resolvePath(args.sourcePath), args.index, "tool", toolName],
         sessionId: args.sessionId,
-        data: { tool_name: toolName, arguments: argumentsVal },
+        data: { tool_name: toolName, arguments: argumentsVal }, // cast: parsed JSON IO boundary
     });
 }
 export function toolCallRecord(args) {
     return toolCallRecordFromItem({ ...args, item: payloadItem(args.event) });
 }
 export { isPlainObject, rglob, isDir, isFilePath };
-//# sourceMappingURL=core.js.map

package/dist/analytics/extractCorpus/corpus.js

@@ -7,43 +7,53 @@ import { extractOpencodeSessions, PermissionDeniedError } from "./sqliteSessions
 import { extractCopilotSessions } from "./copilotSessions.js";
 import { extractCursorSessions, extractCursorAgentSessions, } from "./cursorSessions.js";
 import { resolvePath } from "../../core/paths.js";
+import { applyTruncationToStatus } from "./sqliteCaps.js";
 export class ExtractionNotImplementedError extends Error {
 }
-function extractRuntimeStore(runtime, storePath, errors, extractor) {
-    const discovery = discoverRuntimeStore(runtime, storePath);
+function extractRuntimeStore(runtime, storePath, errors, extractor, sqliteCaps, provenance = {
+    sourceProduct: runtime ?? "unknown",
+    sourceClass: "active_runtime",
+    activeRuntime: true,
+}) {
+    const discovery = discoverRuntimeStore(runtime, storePath, provenance);
     if (discovery.status !== "available")
         return [[], discovery];
     const errorStart = errors.length;
+    const ctx = { sqliteCaps };
     let records;
     try {
-        records = extractor(storePath, errors);
+        records = extractor(storePath, errors, ctx);
     }
     catch (exc) {
-        const cc = discovery.candidate_count ?? null;
+        const fc = (discovery.file_count ?? null); // cast: discovery payload IO boundary
         if (exc instanceof ExtractionNotImplementedError) {
-            return [[], runtimeStatus(runtime, { status: "degraded", reason: "extractor_unimplemented", storePath, candidateCount: cc, recordCount: 0, errorCount: 0 })];
+            return [[], runtimeStatus(runtime, { status: "degraded", reason: "extractor_unimplemented", storePath, fileCount: fc, recordCount: 0, errorCount: 0, ...provenance })];
         }
         if (exc instanceof PermissionDeniedError) {
-            return [[], runtimeStatus(runtime, { status: "degraded", reason: "store_locked", storePath, candidateCount: cc })];
+            return [[], runtimeStatus(runtime, { status: "degraded", reason: "store_locked", storePath, fileCount: fc, ...provenance })];
         }
-        return [[], runtimeStatus(runtime, { status: "degraded", reason: "store_unreadable", storePath, candidateCount: cc })];
+        return [[], runtimeStatus(runtime, { status: "degraded", reason: "store_unreadable", storePath, fileCount: fc, ...provenance })];
     }
-    const cc = discovery.candidate_count ?? null;
+    const fc = (discovery.file_count ?? null); // cast: discovery payload IO boundary
     const errorCount = errors.length - errorStart;
     if (errorCount) {
-        return [records, runtimeStatus(runtime, { status: "degraded", reason: "schema_divergent", storePath, candidateCount: cc, recordCount: records.length, errorCount })];
+        return [records, runtimeStatus(runtime, { status: "degraded", reason: "schema_divergent", storePath, fileCount: fc, recordCount: records.length, errorCount, ...provenance })];
     }
     if (records.length === 0) {
         return [records, runtimeStatus(runtime, {
                 status: "sparse",
                 reason: "no_matching_records",
                 storePath,
-                candidateCount: cc,
+                fileCount: fc,
                 recordCount: 0,
-                remediationLabels: runtime === "github-copilot" ? [COPILOT_SPARSE_REMEDIATION] : null,
+                remediationLabels: runtime === "copilot" ? [COPILOT_SPARSE_REMEDIATION] : null,
+                ...provenance,
             })];
     }
-    return [records, runtimeStatus(runtime, { status: "ok", reason: "records_extracted", storePath, candidateCount: cc, recordCount: records.length, errorCount: 0 })];
+    return [
+        records,
+        applyTruncationToStatus(runtimeStatus(runtime, { status: "ok", reason: "records_extracted", storePath, fileCount: fc, recordCount: records.length, errorCount: 0, ...provenance }), ctx.truncation),
+    ];
 }
 export function dedupeRecords(records) {
     const byId = new Map();
@@ -71,7 +81,7 @@ export function dedupeRecords(records) {
         return ai < bi ? -1 : ai > bi ? 1 : 0;
     });
 }
-export function buildMetadata(records, errors, runtimeStatuses) {
+export function buildMetadata(records, errors, runtimeStatuses, coverage) {
     const counts = new Map();
     for (const item of records) {
         const sk = item.source_kind;
@@ -85,15 +95,27 @@ export function buildMetadata(records, errors, runtimeStatuses) {
         if (count === 0)
             families[family].error = "no records extracted for this family";
     }
-    const runtimes = Array.from(new Set(records.filter((i) => i.runtime).map((i) => String(i.runtime)))).sort();
+    const runtimes = Array.from(new Set(records.filter((item) => item.active_runtime === true && item.runtime).map((item) => String(item.runtime)))).sort();
+    const sourceClasses = Array.from(new Set(records.map((item) => String(item.source_class)))).sort();
+    const sourceProducts = Array.from(new Set(records.map((item) => String(item.source_product)))).sort();
+    const coverageFields = coverage ?? {
+        available_runtimes: [],
+        selected_runtimes: [],
+        available_but_not_selected: [],
+    };
     return {
         extracted_at: isoNow(),
         runtimes,
         adapter_version: ADAPTER_VERSION,
         families,
         runtime_statuses: runtimeStatuses,
+        available_runtimes: coverageFields.available_runtimes,
+        selected_runtimes: coverageFields.selected_runtimes,
+        available_but_not_selected: coverageFields.available_but_not_selected,
         total_records: records.length,
         errors,
+        source_classes: sourceClasses,
+        source_products: sourceProducts,
     };
 }
 export function buildCorpus(opts) {
@@ -110,23 +132,36 @@ export function buildCorpus(opts) {
     records.push(...extractProjectConfigSignals(normalizedRoots, errors));
     const runtimeStatuses = [];
     const runtimes = [
-        ["codex", opts.codexSessionsDir, extractCodexSessions],
-        ["claude-code", opts.claudeProjectsDir, extractClaudeProjectSessions],
-        ["cursor", opts.cursorProjectsDir ?? null, (sp, err) => extractCursorSessions(sp, err, normalizedRoots)],
+        ["codex", "codex", "active_runtime", true, opts.codexSessionsDir, extractCodexSessions, undefined],
+        ["cursor", "cursor", "active_runtime", true, opts.cursorProjectsDir ?? null, (sp, err) => extractCursorSessions(sp, err, normalizedRoots), undefined],
         [
+            "cursor",
             "cursor-agent",
+            "active_runtime",
+            true,
             opts.cursorChatsDir ?? null,
             (sp, err) => extractCursorAgentSessions(sp, err, normalizedRoots, opts.cursorProjectsDir ?? null),
+            "store.db",
         ],
-        ["opencode", opts.opencodeConversationsDir ?? null, extractOpencodeSessions],
-        ["github-copilot", opts.copilotConversationsDir ?? null, extractCopilotSessions],
+        ["opencode", "opencode", "active_runtime", true, opts.opencodeConversationsDir ?? null, extractOpencodeSessions, undefined],
+        ["copilot", "github-copilot", "active_runtime", true, opts.copilotConversationsDir ?? null, extractCopilotSessions, undefined],
     ];
-    for (const [runtime, storePath, extractor] of runtimes) {
-        const [runtimeRecords, status] = extractRuntimeStore(runtime, storePath, errors, extractor);
+    if (opts.claudeProjectsDir !== null) {
+        runtimes.push([
+            null,
+            "claude-code",
+            "historical_import",
+            false,
+            opts.claudeProjectsDir,
+            extractClaudeProjectSessions,
+            "*.jsonl",
+        ]);
+    }
+    for (const [runtime, sourceProduct, sourceClass, activeRuntime, storePath, extractor, pattern] of runtimes) {
+        const [runtimeRecords, status] = extractRuntimeStore(runtime, storePath, errors, extractor, opts.sqliteCaps, { sourceProduct, sourceClass, activeRuntime, pattern });
         records.push(...runtimeRecords);
         runtimeStatuses.push(status);
     }
     const deduped = dedupeRecords(records);
-    return { metadata: buildMetadata(deduped, errors, runtimeStatuses), records: deduped };
+    return { metadata: buildMetadata(deduped, errors, runtimeStatuses, opts.coverage), records: deduped };
 }
-//# sourceMappingURL=corpus.js.map