agentera 0.0.0 → 3.0.0-dev.1

package/dist/analytics/extractCorpus.js

@@ -0,0 +1,1791 @@
+/**
+ * Section 22 corpus extractor — faithful TypeScript port of
+ * scripts/extract_corpus.py (git 1389867~1).
+ *
+ * Reads local AI runtime history (JSONL files + SQLite stores via node:sqlite)
+ * across Codex / Claude Code / Cursor / Cursor-agent / OpenCode / GitHub Copilot,
+ * plus instruction documents and project config signals, and emits the
+ * corpus.json envelope that profilera synthesizes PROFILE.md from and that
+ * `report`/`stats` analytics read.
+ *
+ * SQLite uses Node's built-in node:sqlite (DatabaseSync), imported lazily so the
+ * one experimental warning only appears when a SQLite store is actually read.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+export const ADAPTER_VERSION = "agentera-v2-corpus-1";
+export const FAMILIES = [
+    "instruction_document",
+    "history_prompt",
+    "conversation_turn",
+    "tool_call",
+    "project_config_signal",
+];
+export const RUNTIME_STORE_GLOBS = {
+    codex: "*.jsonl",
+    "claude-code": "*.jsonl",
+    cursor: "*.jsonl",
+    "cursor-agent": "store.db",
+    opencode: "opencode.db",
+    "github-copilot": "session-store.db",
+};
+const MAX_TOOL_ARG_TEXT = 500;
+const MAX_SQLITE_ROWS = 100_000;
+const MAX_SQLITE_SESSIONS = 60;
+const COPILOT_SPARSE_REMEDIATION = "/chronicle reindex";
+const DECISION_RE = /\b(decide|decision|prefer|preference|instead|avoid|don't|do not|should|trade[- ]?off|scope|plan|commit|review|fix|why|question|blocked|stuck|approve|reject|change|keep|remove)\b/i;
+const CORRECTION_RE = /\b(no|not quite|actually|rather|instead|wrong|correction|that's not|that is not|don't|do not)\b/i;
+const QUESTION_RE = /\?|^\s*(why|what|how|should|can|could|would)\b/i;
+// ── core helpers ───────────────────────────────────────────────────
+export function isoNow() {
+    // Python datetime.now(utc).isoformat() -> microseconds + "+00:00" -> "Z".
+    // JS gives milliseconds; corpus extracted_at is a wall-clock stamp, not a
+    // parity-critical record value.
+    return new Date().toISOString().replace(/Z$/, "Z");
+}
+export function isoFromMtime(p) {
+    const ms = fs.statSync(p).mtimeMs;
+    return new Date(ms).toISOString().replace(/Z$/, "Z");
+}
+export function stableId(...parts) {
+    const raw = parts.map((p) => pyStr(p)).join("\0");
+    return crypto.createHash("sha256").update(raw, "utf-8").digest("hex").slice(0, 24);
+}
+/** Python str() for the scalar/None values stable_id receives. */
+function pyStr(value) {
+    if (value === null || value === undefined)
+        return "None";
+    if (value === true)
+        return "True";
+    if (value === false)
+        return "False";
+    return String(value);
+}
+export function projectIdFromPath(p) {
+    if (p === null)
+        return "global";
+    const name = path.basename(p) || p;
+    const slug = name
+        .replace(/[^A-Za-z0-9._-]+/g, "-")
+        .replace(/^-+/, "")
+        .replace(/-+$/, "")
+        .toLowerCase();
+    return slug || "global";
+}
+export function defaultAgenteraHome(env = process.env, platform = process.platform) {
+    const override = env.AGENTERA_HOME;
+    if (override)
+        return 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");
+    }
+    const xdg = env.XDG_DATA_HOME || path.join(os.homedir(), ".local", "share");
+    return path.join(xdg, "agentera");
+}
+export function defaultProfileDir(env = process.env, platform = process.platform) {
+    const override = env.PROFILERA_PROFILE_DIR;
+    if (override)
+        return 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 };
+    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.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;
+    return item;
+}
+function isDir(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function isFilePath(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** Recursive glob for a simple pattern ("*.jsonl" or an exact filename). */
+function rglob(root, pattern) {
+    const out = [];
+    const matchesExt = pattern.startsWith("*.") ? pattern.slice(1) : null; // ".jsonl"
+    const exact = matchesExt ? null : pattern;
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory())
+                walk(full);
+            else if (e.isFile()) {
+                if (matchesExt ? e.name.endsWith(matchesExt) : e.name === exact)
+                    out.push(full);
+            }
+        }
+    };
+    walk(root);
+    return out.sort();
+}
+export function discoverRuntimeStore(runtime, storePath) {
+    if (storePath === null) {
+        return runtimeStatus(runtime, { status: "skipped", reason: "disabled", storePath: null });
+    }
+    if (!fs.existsSync(storePath)) {
+        return runtimeStatus(runtime, {
+            status: "missing",
+            reason: "store_absent",
+            storePath,
+            remediationLabels: runtime === "github-copilot" ? [COPILOT_SPARSE_REMEDIATION] : null,
+        });
+    }
+    if ((runtime === "opencode" || runtime === "github-copilot") && isFilePath(storePath)) {
+        return runtimeStatus(runtime, {
+            status: "available",
+            reason: "candidate_files_found",
+            storePath,
+            candidateCount: 1,
+        });
+    }
+    if (!isDir(storePath)) {
+        return runtimeStatus(runtime, { status: "degraded", reason: "store_not_directory", storePath });
+    }
+    let candidates;
+    try {
+        candidates = rglob(storePath, RUNTIME_STORE_GLOBS[runtime]);
+    }
+    catch {
+        return runtimeStatus(runtime, { status: "degraded", reason: "store_unreadable", storePath });
+    }
+    if (candidates.length === 0) {
+        return runtimeStatus(runtime, {
+            status: "sparse",
+            reason: "no_candidate_files",
+            storePath,
+            candidateCount: 0,
+            remediationLabels: runtime === "github-copilot" ? [COPILOT_SPARSE_REMEDIATION] : null,
+        });
+    }
+    return runtimeStatus(runtime, {
+        status: "available",
+        reason: "candidate_files_found",
+        storePath,
+        candidateCount: candidates.length,
+    });
+}
+// ── record builders + content helpers ──────────────────────────────
+import { resolvePath } from "../core/paths.js";
+function splitLines(text) {
+    const parts = text.split(/\r\n|\r|\n/);
+    if (parts.length > 0 && parts[parts.length - 1] === "")
+        parts.pop();
+    return parts;
+}
+export function record(opts) {
+    const item = {
+        source_id: stableId(opts.sourceKind, ...opts.sourceParts),
+        timestamp: opts.timestamp,
+        project_id: projectIdFromPath(opts.projectPath),
+        source_kind: opts.sourceKind,
+        runtime: opts.runtime,
+        adapter_version: ADAPTER_VERSION,
+        data: opts.data,
+    };
+    if (opts.projectPath !== null && opts.projectPath !== undefined)
+        item.project_path = opts.projectPath;
+    if (opts.sessionId) {
+        item.session_id = opts.sessionId;
+        item.conversation_key = opts.sessionId;
+    }
+    return item;
+}
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+export function payloadItem(event) {
+    const payload = event.payload;
+    if (isPlainObject(payload)) {
+        const nested = payload.item;
+        if (isPlainObject(nested))
+            return nested;
+        return payload;
+    }
+    return event;
+}
+export function eventKind(event) {
+    for (const key of ["type", "event", "name"]) {
+        const value = event[key];
+        if (typeof value === "string")
+            return value;
+    }
+    return "";
+}
+export function eventTimestamp(item, fallback) {
+    const payload = isPlainObject(item.payload) ? item.payload : {};
+    const nested = isPlainObject(payload.item) ? payload.item : {};
+    for (const source of [item, payload, nested]) {
+        for (const key of ["timestamp", "created_at", "createdAt", "time"]) {
+            const value = source[key];
+            if (typeof value === "string" && value)
+                return value;
+            if (typeof value === "number") {
+                return new Date(value * 1000).toISOString();
+            }
+        }
+    }
+    return fallback;
+}
+export function textFromContent(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value)) {
+        const parts = value.map((it) => textFromContent(it));
+        return parts.filter((p) => p).join("\n");
+    }
+    if (isPlainObject(value)) {
+        for (const key of ["text", "input_text", "output_text", "message", "content"]) {
+            const text = textFromContent(value[key]);
+            if (text)
+                return text;
+        }
+        return "";
+    }
+    return pyStr(value);
+}
+export function claudeContentItems(event) {
+    const items = [];
+    const msg = isPlainObject(event.message) ? event.message : null;
+    for (const source of [event, msg]) {
+        if (!isPlainObject(source))
+            continue;
+        const content = source.content;
+        if (Array.isArray(content)) {
+            for (const it of content)
+                if (isPlainObject(it))
+                    items.push(it);
+        }
+        else if (isPlainObject(content)) {
+            items.push(content);
+        }
+    }
+    return items;
+}
+export function* iterJsonl(p, errors) {
+    let text;
+    try {
+        text = fs.readFileSync(p, "utf-8");
+    }
+    catch (exc) {
+        errors.push(`${p}: cannot read: ${exc.message}`);
+        return;
+    }
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const stripped = lines[i].trim();
+        if (!stripped)
+            continue;
+        let item;
+        try {
+            item = JSON.parse(stripped);
+        }
+        catch (exc) {
+            errors.push(`${p}:${i + 1}: invalid jsonl: ${exc.message}`);
+            continue;
+        }
+        if (isPlainObject(item))
+            yield item;
+    }
+}
+export function signalType(text) {
+    if (!text || !DECISION_RE.test(text))
+        return null;
+    if (CORRECTION_RE.test(text))
+        return "correction";
+    if (QUESTION_RE.test(text))
+        return "question";
+    return "decision";
+}
+function toolCallRecordFromItem(args) {
+    const { item, event } = args;
+    const kind = eventKind(event);
+    const itemType = item.type;
+    if (!["tool_call", "function_call"].includes(kind) &&
+        !["tool_call", "function_call", "tool_use"].includes(itemType)) {
+        return null;
+    }
+    const toolName = item.tool_name || item.name || item.tool;
+    if (typeof toolName !== "string" || !toolName)
+        return null;
+    let argumentsVal = item.arguments || item.input || item.args || {};
+    if (typeof argumentsVal === "string") {
+        try {
+            argumentsVal = JSON.parse(argumentsVal);
+        }
+        catch {
+            argumentsVal = { raw: argumentsVal };
+        }
+    }
+    if (!isPlainObject(argumentsVal))
+        argumentsVal = { value: argumentsVal };
+    return record({
+        sourceKind: "tool_call",
+        timestamp: eventTimestamp(event, args.fallbackTimestamp),
+        projectPath: args.projectPath,
+        runtime: args.runtime,
+        sourceParts: [resolvePath(args.sourcePath), args.index, "tool", toolName],
+        sessionId: args.sessionId,
+        data: { tool_name: toolName, arguments: argumentsVal },
+    });
+}
+function toolCallRecord(args) {
+    return toolCallRecordFromItem({ ...args, item: payloadItem(args.event) });
+}
+// ── instruction documents + project config signals ─────────────────
+export function extractInstructionDocuments(projectRoots, errors) {
+    const records = [];
+    const docNames = [
+        ["AGENTS.md", "agents_md"],
+        ["CLAUDE.md", "claude_md"],
+    ];
+    for (const root of projectRoots) {
+        for (const [filename, docType] of docNames) {
+            const p = path.join(root, filename);
+            if (!fs.existsSync(p))
+                continue;
+            let content;
+            try {
+                content = fs.readFileSync(p, "utf-8");
+            }
+            catch (exc) {
+                errors.push(`${p}: cannot read instruction document: ${exc.message}`);
+                continue;
+            }
+            records.push(record({
+                sourceKind: "instruction_document",
+                timestamp: isoFromMtime(p),
+                projectPath: root,
+                runtime: "filesystem",
+                sourceParts: [resolvePath(p)],
+                data: { doc_type: docType, name: filename, content, scope: "project" },
+            }));
+        }
+    }
+    return records;
+}
+function packageJsonSignals(p) {
+    const data = JSON.parse(fs.readFileSync(p, "utf-8"));
+    if (!isPlainObject(data))
+        return [];
+    const signals = [];
+    const name = data.name;
+    if (typeof name === "string" && name)
+        signals.push(`name=${name}`);
+    for (const section of ["scripts", "dependencies", "devDependencies"]) {
+        const sectionData = data[section];
+        if (!isPlainObject(sectionData))
+            continue;
+        for (const key of Object.keys(sectionData).sort().slice(0, 30)) {
+            signals.push(`${section}:${key}`);
+        }
+    }
+    return signals;
+}
+function textConfigSignals(p, configType) {
+    let lines;
+    try {
+        lines = splitLines(fs.readFileSync(p, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+    const signals = [];
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#") || line.startsWith("//"))
+            continue;
+        if (configType === "gomod" && (line.startsWith("module ") || line.startsWith("go ") || line.startsWith("require "))) {
+            signals.push(line);
+        }
+        else if (configType === "pyproject" &&
+            (line.startsWith("[") || line.startsWith("requires-python") || line.startsWith("dependencies") || line.startsWith("name"))) {
+            signals.push(line);
+        }
+        else if (configType === "cargo_toml" && (line.startsWith("[") || line.startsWith("name") || line.startsWith("edition"))) {
+            signals.push(line);
+        }
+        else if (configType === "lefthook" && line.includes(":")) {
+            signals.push(line);
+        }
+        if (signals.length >= 40)
+            break;
+    }
+    return signals;
+}
+export function extractProjectConfigSignals(projectRoots, errors) {
+    const records = [];
+    const configFiles = [
+        ["package.json", "package_json", packageJsonSignals],
+        ["pyproject.toml", "pyproject", (p) => textConfigSignals(p, "pyproject")],
+        ["go.mod", "gomod", (p) => textConfigSignals(p, "gomod")],
+        ["Cargo.toml", "cargo_toml", (p) => textConfigSignals(p, "cargo_toml")],
+        [".lefthook.yml", "lefthook", (p) => textConfigSignals(p, "lefthook")],
+        ["lefthook.yml", "lefthook", (p) => textConfigSignals(p, "lefthook")],
+    ];
+    for (const root of projectRoots) {
+        for (const [filename, configType, extractor] of configFiles) {
+            const p = path.join(root, filename);
+            if (!fs.existsSync(p))
+                continue;
+            let signals;
+            try {
+                signals = extractor(p);
+            }
+            catch (exc) {
+                errors.push(`${p}: cannot extract config signals: ${exc.message}`);
+                continue;
+            }
+            if (signals.length === 0)
+                continue;
+            records.push(record({
+                sourceKind: "project_config_signal",
+                timestamp: isoFromMtime(p),
+                projectPath: root,
+                runtime: "filesystem",
+                sourceParts: [resolvePath(p), configType],
+                data: { config_type: configType, file_path: path.relative(root, p), signals },
+            }));
+        }
+    }
+    return records;
+}
+// ── JSONL session extractors (codex, claude-code) ──────────────────
+function pathStem(p) {
+    const base = path.basename(p);
+    const ext = path.extname(base);
+    return ext ? base.slice(0, -ext.length) : base;
+}
+export function extractCodexSessions(sessionsDir, errors) {
+    if (sessionsDir === null || !fs.existsSync(sessionsDir))
+        return [];
+    const records = [];
+    for (const p of rglob(sessionsDir, "*.jsonl")) {
+        const fallbackTimestamp = isoFromMtime(p);
+        let sessionId = pathStem(p);
+        let projectPath = null;
+        let previousAssistant = "";
+        let index = 0;
+        for (const event of iterJsonl(p, errors)) {
+            index += 1;
+            const kind = eventKind(event);
+            const payload = isPlainObject(event.payload) ? event.payload : {};
+            if (kind === "session_meta") {
+                const sid = payload.id || event.id;
+                if (typeof sid === "string" && sid)
+                    sessionId = sid;
+                const cwd = payload.cwd || payload.working_directory;
+                if (typeof cwd === "string" && cwd)
+                    projectPath = cwd;
+                continue;
+            }
+            if (kind === "turn_context") {
+                const cwd = payload.cwd || payload.working_directory;
+                if (typeof cwd === "string" && cwd)
+                    projectPath = cwd;
+                continue;
+            }
+            const toolRecord = toolCallRecord({ event, fallbackTimestamp, projectPath, runtime: "codex", sourcePath: p, index, sessionId });
+            if (toolRecord !== null) {
+                records.push(toolRecord);
+                continue;
+            }
+            const item = payloadItem(event);
+            const itemType = item.type;
+            let role = item.role || item.actor;
+            if (kind === "user_msg")
+                role = "user";
+            if (role !== "user" && role !== "assistant")
+                continue;
+            const skipType = itemType !== undefined && itemType !== null && itemType !== "message";
+            if (skipType && !["response_item", "user_msg"].includes(kind))
+                continue;
+            const content = textFromContent(item.content || item.text || item.message);
+            if (!content)
+                continue;
+            const timestamp = eventTimestamp(event, fallbackTimestamp);
+            const data = { actor: role, content };
+            if (role === "user") {
+                if (previousAssistant)
+                    data.preceding_context = previousAssistant.slice(-2000);
+                const sig = signalType(content);
+                if (sig)
+                    data.signal_type = sig;
+            }
+            else {
+                previousAssistant = content;
+            }
+            records.push(record({
+                sourceKind: "conversation_turn",
+                timestamp,
+                projectPath,
+                runtime: "codex",
+                sourceParts: [resolvePath(p), index, role, content.slice(0, 80)],
+                sessionId,
+                data,
+            }));
+            if (role === "user") {
+                const sig = signalType(content);
+                if (sig) {
+                    records.push(record({
+                        sourceKind: "history_prompt",
+                        timestamp,
+                        projectPath,
+                        runtime: "codex",
+                        sourceParts: [resolvePath(p), index, "history", content.slice(0, 120)],
+                        sessionId,
+                        data: { prompt: content, signal_type: sig },
+                    }));
+                }
+            }
+        }
+    }
+    return records;
+}
+export function extractClaudeProjectSessions(projectsDir, errors) {
+    if (projectsDir === null || !fs.existsSync(projectsDir))
+        return [];
+    const records = [];
+    for (const p of rglob(projectsDir, "*.jsonl")) {
+        const fallbackTimestamp = isoFromMtime(p);
+        let sessionId = pathStem(p);
+        let projectPath = null;
+        let previousAssistant = "";
+        let index = 0;
+        for (const event of iterJsonl(p, errors)) {
+            index += 1;
+            const sid = event.sessionId || event.session_id || event.sessionID;
+            if (typeof sid === "string" && sid)
+                sessionId = sid;
+            const cwd = event.cwd || event.workingDirectory || event.working_directory;
+            if (typeof cwd === "string" && cwd)
+                projectPath = cwd;
+            const toolRecord = toolCallRecord({ event, fallbackTimestamp, projectPath, runtime: "claude-code", sourcePath: p, index, sessionId });
+            if (toolRecord !== null) {
+                records.push(toolRecord);
+                continue;
+            }
+            let contentIndex = 0;
+            for (const item of claudeContentItems(event)) {
+                contentIndex += 1;
+                const tr = toolCallRecordFromItem({
+                    item,
+                    event,
+                    fallbackTimestamp,
+                    projectPath,
+                    runtime: "claude-code",
+                    sourcePath: p,
+                    index: index * 1000 + contentIndex,
+                    sessionId,
+                });
+                if (tr !== null)
+                    records.push(tr);
+            }
+            let role = event.role || event.type;
+            if (role !== "user" && role !== "assistant") {
+                const message = event.message;
+                if (isPlainObject(message))
+                    role = message.role;
+            }
+            if (role !== "user" && role !== "assistant")
+                continue;
+            const content = textFromContent(event.content || event.text || (isPlainObject(event.message) ? event.message : null));
+            if (!content)
+                continue;
+            const timestamp = eventTimestamp(event, fallbackTimestamp);
+            const data = { actor: role, content };
+            if (role === "user") {
+                if (previousAssistant)
+                    data.preceding_context = previousAssistant.slice(-2000);
+                const sig = signalType(content);
+                if (sig)
+                    data.signal_type = sig;
+            }
+            else {
+                previousAssistant = content;
+            }
+            records.push(record({
+                sourceKind: "conversation_turn",
+                timestamp,
+                projectPath,
+                runtime: "claude-code",
+                sourceParts: [resolvePath(p), index, role, content.slice(0, 80)],
+                sessionId,
+                data,
+            }));
+            if (role === "user") {
+                const sig = signalType(content);
+                if (sig) {
+                    records.push(record({
+                        sourceKind: "history_prompt",
+                        timestamp,
+                        projectPath,
+                        runtime: "claude-code",
+                        sourceParts: [resolvePath(p), index, "history", content.slice(0, 120)],
+                        sessionId,
+                        data: { prompt: content, signal_type: sig },
+                    }));
+                }
+            }
+        }
+    }
+    return records;
+}
+// ── SQLite (node:sqlite, lazy) ──────────────────────────────────────
+import { createRequire } from "node:module";
+const requireCjs = createRequire(import.meta.url);
+/** Lazy open a read-only SQLite db via node:sqlite (warning only fires here). */
+function openSqlite(p) {
+    const { DatabaseSync } = requireCjs("node:sqlite");
+    return new DatabaseSync(resolvePath(p), { readOnly: true });
+}
+function sqliteTimestamp(value, fallback) {
+    if (typeof value === "string" && value)
+        return value;
+    if (typeof value === "number") {
+        let numeric = value;
+        if (numeric > 10_000_000_000)
+            numeric /= 1000;
+        return new Date(numeric * 1000).toISOString();
+    }
+    return fallback;
+}
+function jsonDict(value) {
+    if (isPlainObject(value))
+        return value;
+    if (typeof value === "string" && value) {
+        try {
+            const parsed = JSON.parse(value);
+            return isPlainObject(parsed) ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    return {};
+}
+function nestedTimeCreated(data) {
+    const timeData = data.time;
+    if (isPlainObject(timeData))
+        return timeData.created || timeData.start;
+    return data.time_created || data.timestamp;
+}
+function tableColumns(conn, table) {
+    const rows = conn.prepare(`PRAGMA table_info(${table})`).all();
+    return new Set(rows.map((r) => String(r.name)));
+}
+function firstColumn(columns, candidates) {
+    for (const c of candidates)
+        if (columns.has(c))
+            return c;
+    return null;
+}
+function qualified(alias, column, label) {
+    if (column === null)
+        return `NULL AS ${label}`;
+    const escaped = column.replace(/"/g, '""');
+    return `${alias}."${escaped}" AS ${label}`;
+}
+function opencodeRows(conn) {
+    const tables = new Set(conn.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((r) => String(r.name)));
+    for (const t of ["session", "message", "part"]) {
+        if (!tables.has(t)) {
+            const missing = ["session", "message", "part"].filter((x) => !tables.has(x)).sort().join(",");
+            throw new Error(`missing opencode tables: ${missing}`);
+        }
+    }
+    const sessionCols = tableColumns(conn, "session");
+    const messageCols = tableColumns(conn, "message");
+    const partCols = tableColumns(conn, "part");
+    const sessionId = firstColumn(sessionCols, ["id", "session_id", "sessionID"]);
+    const messageId = firstColumn(messageCols, ["id", "message_id", "messageID"]);
+    const messageSession = firstColumn(messageCols, ["sessionID", "session_id", "session", "sessionId"]);
+    const partMessage = firstColumn(partCols, ["messageID", "message_id", "message", "messageId"]);
+    if (!(sessionId && messageId && messageSession && partMessage))
+        throw new Error("missing opencode join columns");
+    const messageData = firstColumn(messageCols, ["data"]);
+    const partData = firstColumn(partCols, ["data"]);
+    const roleCol = firstColumn(messageCols, ["role", "actor", "author"]);
+    if (roleCol === null && messageData === null)
+        throw new Error("missing opencode message role column");
+    const messageTime = firstColumn(messageCols, ["time_created", "time", "timestamp", "created_at", "createdAt"]);
+    const partTime = firstColumn(partCols, ["time_created", "time", "timestamp", "created_at", "createdAt"]);
+    const sessionTime = firstColumn(sessionCols, ["time_created", "time", "timestamp", "created_at", "createdAt"]);
+    const sessionUpdated = firstColumn(sessionCols, ["time_updated", "updated_at", "updatedAt", "time_created", "time"]);
+    const projectCol = firstColumn(sessionCols, ["cwd", "project_path", "projectPath", "directory", "path"]);
+    const messageText = firstColumn(messageCols, ["content", "text", "message"]);
+    const partText = firstColumn(partCols, ["text", "content", "input", "output"]);
+    const partType = firstColumn(partCols, ["type", "kind"]);
+    const partId = firstColumn(partCols, ["id", "part_id", "partID"]);
+    const sortExpr = `COALESCE(m."${messageTime || messageId}", p."${partTime || partMessage}", s."${sessionTime || sessionId}")`;
+    const recentSessionExpr = `s."${sessionUpdated || sessionTime || sessionId}"`;
+    const query = `
+        WITH recent_sessions AS (
+            SELECT s."${sessionId}" AS recent_session_id
+            FROM session s
+            ORDER BY ${recentSessionExpr} DESC,
+                     s."${sessionId}" DESC
+            LIMIT ?
+        ),
+        recent AS (
+            SELECT
+                ${qualified("s", sessionId, "session_id")},
+                ${qualified("s", projectCol, "project_path")},
+                ${qualified("m", messageId, "message_id")},
+                ${qualified("m", roleCol, "role")},
+                ${qualified("m", messageTime, "message_time")},
+                ${qualified("m", messageText, "message_text")},
+                ${qualified("m", messageData, "message_data")},
+                ${qualified("p", partId, "part_id")},
+                ${qualified("p", partTime, "part_time")},
+                ${qualified("p", partType, "part_type")},
+                ${qualified("p", partText, "part_text")},
+                ${qualified("p", partData, "part_data")},
+                ${sortExpr} AS sort_time
+            FROM message m
+            JOIN session s ON m."${messageSession}" = s."${sessionId}"
+            JOIN recent_sessions rs ON rs.recent_session_id = s."${sessionId}"
+            LEFT JOIN part p ON p."${partMessage}" = m."${messageId}"
+            ORDER BY sort_time DESC,
+                     m."${messageId}" DESC,
+                     p."${partId || partMessage}" DESC
+            LIMIT ?
+        )
+        SELECT
+            session_id, project_path, message_id, role, message_time,
+            message_text, message_data, part_id, part_time, part_type,
+            part_text, part_data
+        FROM recent
+        ORDER BY sort_time, message_id, part_id
+    `;
+    return conn.prepare(query).all(MAX_SQLITE_SESSIONS, MAX_SQLITE_ROWS);
+}
+function opencodeDbCandidates(storePath) {
+    if (isFilePath(storePath))
+        return [storePath];
+    return rglob(storePath, "opencode.db");
+}
+export function extractOpencodeSessions(storePath, errors) {
+    if (storePath === null || !fs.existsSync(storePath))
+        return [];
+    const records = [];
+    for (const dbPath of opencodeDbCandidates(storePath).slice(0, 1)) {
+        const fallbackTimestamp = isoFromMtime(dbPath);
+        let rows;
+        let conn = null;
+        try {
+            conn = openSqlite(dbPath);
+            rows = opencodeRows(conn);
+        }
+        catch (exc) {
+            const msg = exc.message || "";
+            if (/lock|busy/i.test(msg))
+                throw new PermissionDeniedError(msg);
+            errors.push(`${dbPath}: opencode sqlite read failed: ${exc.name || "Error"}`);
+            continue;
+        }
+        finally {
+            try {
+                conn?.close();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        const messages = new Map();
+        for (const row of rows) {
+            const messageData = jsonDict(row.message_data);
+            const partData = jsonDict(row.part_data);
+            const messageId = String(row.message_id);
+            const role = row.role || messageData.role;
+            const messageTime = row.message_time || nestedTimeCreated(messageData);
+            let item = messages.get(messageId);
+            if (item === undefined) {
+                item = {
+                    role,
+                    session_id: String(row.session_id),
+                    project_path: row.project_path,
+                    timestamp: sqliteTimestamp(messageTime, fallbackTimestamp),
+                    parts: [],
+                    tools: [],
+                };
+                messages.set(messageId, item);
+            }
+            const partType = row.part_type || partData.type;
+            const partText = textFromContent(row.part_text || partData.text);
+            if (partText)
+                item.parts.push(partText);
+            else if (row.message_text)
+                item.parts.push(textFromContent(row.message_text));
+            if (partType === "tool" || partData.tool) {
+                const state = isPlainObject(partData.state) ? partData.state : {};
+                const argumentsVal = isPlainObject(state.input) ? state.input : {};
+                const toolName = partData.tool || partData.name;
+                if (typeof toolName === "string" && toolName) {
+                    item.tools.push({
+                        part_id: row.part_id,
+                        tool_name: toolName,
+                        arguments: argumentsVal,
+                        timestamp: sqliteTimestamp(row.part_time || nestedTimeCreated(partData), item.timestamp),
+                    });
+                }
+            }
+        }
+        let previousAssistant = "";
+        let index = 0;
+        for (const item of messages.values()) {
+            index += 1;
+            const role = String(item.role).toLowerCase();
+            if (role !== "user" && role !== "assistant")
+                continue;
+            const content = item.parts.filter((p) => p).join("\n");
+            if (!content && item.tools.length === 0)
+                continue;
+            const projectPath = item.project_path ? String(item.project_path) : null;
+            if (content) {
+                const data = { actor: role, content };
+                if (role === "user") {
+                    if (previousAssistant)
+                        data.preceding_context = previousAssistant.slice(-2000);
+                    const sig = signalType(content);
+                    if (sig)
+                        data.signal_type = sig;
+                }
+                else {
+                    previousAssistant = content;
+                }
+                records.push(record({
+                    sourceKind: "conversation_turn",
+                    timestamp: item.timestamp,
+                    projectPath,
+                    runtime: "opencode",
+                    sourceParts: [resolvePath(dbPath), index, role, content.slice(0, 80)],
+                    sessionId: item.session_id,
+                    data,
+                }));
+            }
+            let toolIndex = 0;
+            for (const toolItem of item.tools) {
+                toolIndex += 1;
+                records.push(record({
+                    sourceKind: "tool_call",
+                    timestamp: toolItem.timestamp,
+                    projectPath,
+                    runtime: "opencode",
+                    sourceParts: [resolvePath(dbPath), index, toolIndex, "tool", toolItem.tool_name, toolItem.part_id],
+                    sessionId: item.session_id,
+                    data: { tool_name: toolItem.tool_name, arguments: toolItem.arguments },
+                }));
+            }
+            if (role === "user" && content) {
+                const sig = signalType(content);
+                if (sig) {
+                    records.push(record({
+                        sourceKind: "history_prompt",
+                        timestamp: item.timestamp,
+                        projectPath,
+                        runtime: "opencode",
+                        sourceParts: [resolvePath(dbPath), index, "history", content.slice(0, 120)],
+                        sessionId: item.session_id,
+                        data: { prompt: content, signal_type: sig },
+                    }));
+                }
+            }
+        }
+    }
+    return records;
+}
+/** Mirrors Python raising PermissionError on a locked/busy store. */
+export class PermissionDeniedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PermissionDeniedError";
+    }
+}
+// ── Copilot SQLite extractor ────────────────────────────────────────
+function copilotDbCandidates(storePath) {
+    if (isFilePath(storePath))
+        return [storePath];
+    return rglob(storePath, "session-store.db");
+}
+function copilotRows(conn) {
+    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)) {
+            const missing = ["sessions", "turns"].filter((x) => !tables.has(x)).sort().join(",");
+            throw new Error(`missing copilot tables: ${missing}`);
+        }
+    }
+    const sessionCols = tableColumns(conn, "sessions");
+    const turnCols = tableColumns(conn, "turns");
+    const sessionId = firstColumn(sessionCols, ["id", "session_id", "sessionID"]);
+    const turnId = firstColumn(turnCols, ["id", "turn_id", "turnID"]);
+    const turnSession = firstColumn(turnCols, ["session_id", "sessionID", "session", "sessionId"]);
+    if (!(sessionId && turnSession))
+        throw new Error("missing copilot join columns");
+    const roleCol = firstColumn(turnCols, ["role", "actor", "author"]);
+    const textCol = firstColumn(turnCols, ["content", "text", "message", "prompt", "response"]);
+    if (roleCol === null)
+        throw new Error("missing copilot turn role column");
+    if (textCol === null)
+        throw new Error("missing copilot turn text column");
+    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 projectCol = firstColumn(sessionCols, ["cwd", "project_path", "projectPath", "directory", "path"]);
+    const turnData = firstColumn(turnCols, ["data", "payload", "json"]);
+    const turnType = firstColumn(turnCols, ["type", "kind"]);
+    const toolNameCol = firstColumn(turnCols, ["tool_name", "toolName", "tool", "name", "command_name", "commandName"]);
+    const toolArgs = firstColumn(turnCols, [
+        "arguments", "args", "input", "tool_input", "toolInput", "command", "command_line", "commandLine",
+    ]);
+    const orderExpr = turnOrder ? `t."${turnOrder}"` : `t."${turnTime || turnSession}"`;
+    const idExpr = turnId ? `t."${turnId}"` : "t.rowid";
+    const query = `
+        SELECT
+            ${qualified("s", sessionId, "session_id")},
+            ${qualified("s", projectCol, "project_path")},
+            ${qualified("t", turnId, "turn_id")},
+            ${qualified("t", roleCol, "role")},
+            ${qualified("t", turnTime, "turn_time")},
+            ${qualified("s", sessionTime, "session_time")},
+            ${qualified("t", textCol, "turn_text")},
+            ${qualified("t", turnData, "turn_data")},
+            ${qualified("t", turnType, "turn_type")},
+            ${qualified("t", toolNameCol, "tool_name")},
+            ${qualified("t", toolArgs, "tool_args")}
+        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 ?
+    `;
+    return conn.prepare(query).all(MAX_SQLITE_ROWS);
+}
+function copilotArgumentDict(value) {
+    if (isPlainObject(value)) {
+        const stateInput = value.input;
+        if (isPlainObject(stateInput) && !("command" in value))
+            return stateInput;
+        return value;
+    }
+    if (typeof value === "string" && value) {
+        try {
+            const parsed = JSON.parse(value);
+            return isPlainObject(parsed) ? parsed : { value: parsed };
+        }
+        catch {
+            return { command: value };
+        }
+    }
+    return {};
+}
+function copilotJsonTools(value, errors, malformedLabel) {
+    if (typeof value === "string" && value) {
+        const raw = value;
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            if (errors && malformedLabel && /^\s*[{[]/.test(raw))
+                errors.push(malformedLabel);
+            return [];
+        }
+    }
+    if (Array.isArray(value)) {
+        const tools = [];
+        for (const item of value)
+            tools.push(...copilotJsonTools(item, errors, malformedLabel));
+        return tools;
+    }
+    if (!isPlainObject(value))
+        return [];
+    const toolName = value.tool_name || value.toolName || value.tool || value.name;
+    const valueType = String(value.type || value.kind || "").toLowerCase();
+    if (typeof toolName === "string" &&
+        toolName &&
+        ["", "tool", "tool_call", "function_call", "tool_use", "command"].includes(valueType)) {
+        return [
+            {
+                tool_name: toolName,
+                arguments: copilotArgumentDict(value.arguments || value.args || value.input || value.state || {}),
+            },
+        ];
+    }
+    const tools = [];
+    for (const key of ["tool_calls", "toolCalls", "tools", "content", "parts", "items"]) {
+        const nested = value[key];
+        if (isPlainObject(nested) || Array.isArray(nested))
+            tools.push(...copilotJsonTools(nested, errors, malformedLabel));
+    }
+    return tools;
+}
+function copilotRowTools(row, errors) {
+    const tools = copilotJsonTools(row.turn_data, errors, "copilot malformed json tool payload");
+    tools.push(...copilotJsonTools(row.turn_text));
+    const toolName = row.tool_name;
+    if (typeof toolName === "string" && toolName) {
+        tools.push({ tool_name: toolName, arguments: copilotArgumentDict(row.tool_args) });
+    }
+    else if (String(row.turn_type || "").toLowerCase() === "command") {
+        const command = row.tool_args || row.turn_text;
+        if (typeof command === "string" && command)
+            tools.push({ tool_name: "bash", arguments: { command } });
+    }
+    return tools.filter((t) => typeof t.tool_name === "string" && t.tool_name);
+}
+export function extractCopilotSessions(storePath, errors) {
+    if (storePath === null || !fs.existsSync(storePath))
+        return [];
+    const records = [];
+    for (const dbPath of copilotDbCandidates(storePath).slice(0, 1)) {
+        const fallbackTimestamp = isoFromMtime(dbPath);
+        let rows;
+        let conn = null;
+        try {
+            conn = openSqlite(dbPath);
+            rows = copilotRows(conn);
+        }
+        catch (exc) {
+            const msg = exc.message || "";
+            if (/lock|busy/i.test(msg))
+                throw new PermissionDeniedError(msg);
+            errors.push(`${dbPath}: copilot sqlite read failed: ${exc.name || "Error"}`);
+            continue;
+        }
+        finally {
+            try {
+                conn?.close();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        let previousAssistant = "";
+        let index = 0;
+        for (const row of rows) {
+            index += 1;
+            const role = String(row.role).toLowerCase();
+            if (role !== "user" && role !== "assistant")
+                continue;
+            const content = textFromContent(row.turn_text);
+            const toolItems = copilotRowTools(row, errors);
+            if (!content && toolItems.length === 0)
+                continue;
+            const projectPath = row.project_path ? String(row.project_path) : null;
+            const timestamp = sqliteTimestamp(row.turn_time || row.session_time, fallbackTimestamp);
+            if (content) {
+                const data = { actor: role, content };
+                if (role === "user") {
+                    if (previousAssistant)
+                        data.preceding_context = previousAssistant.slice(-2000);
+                    const sig = signalType(content);
+                    if (sig)
+                        data.signal_type = sig;
+                }
+                else {
+                    previousAssistant = content;
+                }
+                records.push(record({
+                    sourceKind: "conversation_turn",
+                    timestamp,
+                    projectPath,
+                    runtime: "github-copilot",
+                    sourceParts: [resolvePath(dbPath), index, role, content.slice(0, 80)],
+                    sessionId: String(row.session_id),
+                    data,
+                }));
+            }
+            let toolIndex = 0;
+            for (const toolItem of toolItems) {
+                toolIndex += 1;
+                records.push(record({
+                    sourceKind: "tool_call",
+                    timestamp,
+                    projectPath,
+                    runtime: "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 || {} },
+                }));
+            }
+            if (role === "user") {
+                const sig = signalType(content);
+                if (sig) {
+                    records.push(record({
+                        sourceKind: "history_prompt",
+                        timestamp,
+                        projectPath,
+                        runtime: "github-copilot",
+                        sourceParts: [resolvePath(dbPath), index, "history", content.slice(0, 120)],
+                        sessionId: String(row.session_id),
+                        data: { prompt: content, signal_type: sig },
+                    }));
+                }
+            }
+        }
+    }
+    return records;
+}
+// ── runtime path resolvers ──────────────────────────────────────────
+import { execFileSync } from "node:child_process";
+import { expanduser } from "../core/paths.js";
+export function resolveOpencodeDbPath(env = process.env) {
+    let out;
+    try {
+        out = execFileSync("opencode", ["db", "path"], { encoding: "utf-8", timeout: 2000 });
+    }
+    catch {
+        return null;
+    }
+    const trimmed = out.trim();
+    if (!trimmed)
+        return null;
+    const candidate = trimmed.split(/\r\n|\r|\n/)[0];
+    return candidate ? expanduser(candidate) : null;
+}
+export function resolveCopilotStorePath(env = process.env) {
+    return expanduser(env.COPILOT_HOME || path.join(os.homedir(), ".copilot"));
+}
+export function resolveCursorProjectsPath(env = process.env) {
+    return path.join(expanduser(env.CURSOR_HOME || path.join(os.homedir(), ".cursor")), "projects");
+}
+export function resolveCursorChatsPath(env = process.env) {
+    const configHome = env.CURSOR_CONFIG_HOME;
+    if (configHome)
+        return path.join(expanduser(configHome), "chats");
+    return path.join(os.homedir(), ".config", "cursor", "chats");
+}
+// ── cursor helpers ──────────────────────────────────────────────────
+function pathParents(p) {
+    const parents = [];
+    let cur = p;
+    for (;;) {
+        const parent = path.dirname(cur);
+        if (parent === cur)
+            break;
+        parents.push(parent);
+        cur = parent;
+    }
+    return parents;
+}
+export function cursorWorkspaceHash(projectRoot) {
+    return crypto.createHash("md5").update(resolvePath(projectRoot), "utf-8").digest("hex");
+}
+export function cursorProjectDirSlug(projectRoot) {
+    const resolved = resolvePath(projectRoot);
+    // Python Path.parts: ("/", "a", "b") for absolute; drop the leading "/" anchor.
+    let segs = resolved.split(path.sep).filter((s) => s !== "");
+    // (leading-"/" anchor already dropped by filtering empties)
+    const slug = segs.join("-").toLowerCase();
+    const cleaned = slug.replace(/[^a-z0-9._-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+    return cleaned || "global";
+}
+function cursorProjectPathFromDir(projectDir) {
+    const name = path.basename(projectDir);
+    if (!name || /^\d+$/.test(name) || name === "empty-window")
+        return null;
+    const parts = name.split("-");
+    if (parts.length > 1 && parts[0] === "home")
+        return "/" + parts.join("/");
+    return null;
+}
+function boundToolArguments(args) {
+    const bounded = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (typeof value === "string" && value.length > MAX_TOOL_ARG_TEXT) {
+            bounded[key] = value.slice(0, MAX_TOOL_ARG_TEXT) + "…";
+        }
+        else if (isPlainObject(value)) {
+            bounded[key] = boundToolArguments(value);
+        }
+        else if (Array.isArray(value)) {
+            bounded[key] = value.map((it) => typeof it === "string" && it.length > MAX_TOOL_ARG_TEXT ? it.slice(0, MAX_TOOL_ARG_TEXT) + "…" : it);
+        }
+        else {
+            bounded[key] = value;
+        }
+    }
+    return bounded;
+}
+function cursorContentItems(event) {
+    const message = event.message;
+    if (!isPlainObject(message))
+        return [];
+    const content = message.content;
+    if (Array.isArray(content))
+        return content.filter((it) => isPlainObject(it));
+    if (isPlainObject(content))
+        return [content];
+    return [];
+}
+function iterCursorTranscriptPaths(projectsDir, projectRoots) {
+    if (!isDir(projectsDir))
+        return [];
+    let searchDirs;
+    if (projectRoots.length > 0) {
+        searchDirs = [];
+        for (const root of projectRoots) {
+            const candidate = path.join(projectsDir, cursorProjectDirSlug(root));
+            if (isDir(candidate))
+                searchDirs.push(candidate);
+        }
+    }
+    else {
+        searchDirs = fs
+            .readdirSync(projectsDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => path.join(projectsDir, e.name));
+    }
+    const paths = [];
+    for (const projectDir of searchDirs) {
+        const transcriptsDir = path.join(projectDir, "agent-transcripts");
+        if (!isDir(transcriptsDir))
+            continue;
+        paths.push(...rglob(transcriptsDir, "*.jsonl"));
+    }
+    return paths;
+}
+export function extractCursorSessions(projectsDir, errors, projectRoots = null) {
+    if (projectsDir === null || !fs.existsSync(projectsDir))
+        return [];
+    const roots = projectRoots || [];
+    const slugToRoot = new Map();
+    for (const root of roots)
+        slugToRoot.set(cursorProjectDirSlug(root), root);
+    const records = [];
+    for (const p of iterCursorTranscriptPaths(projectsDir, roots)) {
+        const fallbackTimestamp = isoFromMtime(p);
+        const sessionId = path.basename(path.dirname(p)) || pathStem(p);
+        const parents = pathParents(p);
+        const projectDir = parents.length > 2 ? parents[2] : null;
+        let projectPath = null;
+        if (projectDir) {
+            projectPath = slugToRoot.get(path.basename(projectDir)) || cursorProjectPathFromDir(projectDir);
+        }
+        let previousAssistant = "";
+        let index = 0;
+        for (const event of iterJsonl(p, errors)) {
+            index += 1;
+            const role = event.role;
+            if (role !== "user" && role !== "assistant")
+                continue;
+            let contentIndex = 0;
+            for (const item of cursorContentItems(event)) {
+                contentIndex += 1;
+                const tr = toolCallRecordFromItem({
+                    item,
+                    event,
+                    fallbackTimestamp,
+                    projectPath,
+                    runtime: "cursor",
+                    sourcePath: p,
+                    index: index * 1000 + contentIndex,
+                    sessionId,
+                });
+                if (tr !== null) {
+                    if (isPlainObject(tr.data) && isPlainObject(tr.data.arguments)) {
+                        tr.data.arguments = boundToolArguments(tr.data.arguments);
+                    }
+                    records.push(tr);
+                }
+            }
+            const items = cursorContentItems(event);
+            const content = textFromContent(items.length > 0 ? items : event.message);
+            if (!content)
+                continue;
+            const timestamp = eventTimestamp(event, fallbackTimestamp);
+            const data = { actor: role, content };
+            if (role === "user") {
+                if (previousAssistant)
+                    data.preceding_context = previousAssistant.slice(-2000);
+                const sig = signalType(content);
+                if (sig)
+                    data.signal_type = sig;
+            }
+            else {
+                previousAssistant = content;
+            }
+            records.push(record({
+                sourceKind: "conversation_turn",
+                timestamp,
+                projectPath,
+                runtime: "cursor",
+                sourceParts: [resolvePath(p), index, role, content.slice(0, 80)],
+                sessionId,
+                data,
+            }));
+            if (role === "user") {
+                const sig = signalType(content);
+                if (sig) {
+                    records.push(record({
+                        sourceKind: "history_prompt",
+                        timestamp,
+                        projectPath,
+                        runtime: "cursor",
+                        sourceParts: [resolvePath(p), index, "history", content.slice(0, 120)],
+                        sessionId,
+                        data: { prompt: content, signal_type: sig },
+                    }));
+                }
+            }
+        }
+    }
+    return records;
+}
+function cursorJsonlSessionIds(projectsDir, projectRoots) {
+    if (projectsDir === null)
+        return new Set();
+    const ids = new Set();
+    for (const p of iterCursorTranscriptPaths(projectsDir, projectRoots)) {
+        ids.add(path.basename(path.dirname(p)) || pathStem(p));
+    }
+    return ids;
+}
+function cursorAgentMessageText(message) {
+    const content = message.content;
+    if (typeof content === "string")
+        return content.trim();
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const item of content) {
+            if (!isPlainObject(item))
+                continue;
+            if (item.type === "text") {
+                const text = item.text;
+                if (typeof text === "string" && text.trim())
+                    parts.push(text.trim());
+            }
+        }
+        return parts.join("\n");
+    }
+    return textFromContent(content);
+}
+function cursorAgentToolItems(message) {
+    const items = [];
+    const content = message.content;
+    if (!Array.isArray(content))
+        return items;
+    for (const item of content) {
+        if (!isPlainObject(item))
+            continue;
+        if (item.type !== "tool-call")
+            continue;
+        const toolName = item.toolName || item.tool_name || item.name;
+        if (typeof toolName !== "string" || !toolName)
+            continue;
+        const args = item.args || item.arguments || item.input || {};
+        items.push({ type: "tool_use", name: toolName, input: isPlainObject(args) ? args : { value: args } });
+    }
+    return items;
+}
+function iterCursorAgentStorePaths(chatsDir, projectRoots, jsonlSessionIds) {
+    if (!isDir(chatsDir))
+        return [];
+    const workspaceDirs = [];
+    if (projectRoots.length > 0) {
+        for (const root of projectRoots) {
+            const workspace = path.join(chatsDir, cursorWorkspaceHash(root));
+            if (isDir(workspace))
+                workspaceDirs.push([workspace, resolvePath(root)]);
+        }
+    }
+    else {
+        for (const name of fs.readdirSync(chatsDir).sort()) {
+            const workspace = path.join(chatsDir, name);
+            if (isDir(workspace))
+                workspaceDirs.push([workspace, null]);
+        }
+    }
+    const items = [];
+    for (const [workspace, projectPath] of workspaceDirs) {
+        for (const name of fs.readdirSync(workspace).sort()) {
+            const sessionDir = path.join(workspace, name);
+            if (!isDir(sessionDir))
+                continue;
+            const sessionId = name;
+            if (jsonlSessionIds.has(sessionId))
+                continue;
+            const storeDb = path.join(sessionDir, "store.db");
+            if (isFilePath(storeDb))
+                items.push([storeDb, projectPath, sessionId]);
+        }
+    }
+    return items;
+}
+function cursorAgentBlobMessages(storeDb, errors) {
+    const messages = [];
+    let conn = null;
+    let rows;
+    try {
+        conn = openSqlite(storeDb);
+    }
+    catch (exc) {
+        errors.push(`${storeDb}: cursor-agent sqlite open failed: ${exc.name || "Error"}`);
+        return messages;
+    }
+    try {
+        rows = conn.prepare("SELECT id, data FROM blobs ORDER BY id").all();
+    }
+    catch (exc) {
+        errors.push(`${storeDb}: cursor-agent sqlite read failed: ${exc.name || "Error"}`);
+        conn.close();
+        return messages;
+    }
+    conn.close();
+    for (const row of rows) {
+        const blobId = row.id;
+        const payload = row.data;
+        let raw;
+        if (payload instanceof Uint8Array)
+            raw = Buffer.from(payload);
+        else if (typeof payload === "string")
+            raw = Buffer.from(payload, "utf-8");
+        else {
+            errors.push(`${storeDb}: cursor-agent blob payload not bytes: ${blobId}`);
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw.toString("utf-8"));
+        }
+        catch {
+            errors.push(`${storeDb}: cursor-agent blob not json: ${blobId}`);
+            continue;
+        }
+        if (isPlainObject(parsed))
+            messages.push([String(blobId), parsed]);
+    }
+    return messages;
+}
+export function extractCursorAgentSessions(chatsDir, errors, projectRoots = null, cursorProjectsDir = null) {
+    if (chatsDir === null || !fs.existsSync(chatsDir))
+        return [];
+    const roots = projectRoots || [];
+    const jsonlSessionIds = cursorJsonlSessionIds(cursorProjectsDir, roots);
+    const records = [];
+    for (const [storeDb, projectPath, sessionId] of iterCursorAgentStorePaths(chatsDir, roots, jsonlSessionIds)) {
+        const fallbackTimestamp = isoFromMtime(storeDb);
+        let previousAssistant = "";
+        let index = 0;
+        for (const [blobId, message] of cursorAgentBlobMessages(storeDb, errors)) {
+            index += 1;
+            const role = message.role;
+            let toolIndex = 0;
+            for (const toolItem of cursorAgentToolItems(message)) {
+                toolIndex += 1;
+                const tr = toolCallRecordFromItem({
+                    item: toolItem,
+                    event: message,
+                    fallbackTimestamp,
+                    projectPath,
+                    runtime: "cursor-agent",
+                    sourcePath: storeDb,
+                    index: index * 1000 + toolIndex,
+                    sessionId,
+                });
+                if (tr !== null) {
+                    if (isPlainObject(tr.data) && isPlainObject(tr.data.arguments)) {
+                        tr.data.arguments = boundToolArguments(tr.data.arguments);
+                    }
+                    records.push(tr);
+                }
+            }
+            if (role !== "user" && role !== "assistant")
+                continue;
+            const content = cursorAgentMessageText(message);
+            if (!content)
+                continue;
+            const timestamp = eventTimestamp(message, fallbackTimestamp);
+            const data = { actor: role, content };
+            if (role === "user") {
+                if (previousAssistant)
+                    data.preceding_context = previousAssistant.slice(-2000);
+                const sig = signalType(content);
+                if (sig)
+                    data.signal_type = sig;
+            }
+            else {
+                previousAssistant = content;
+            }
+            records.push(record({
+                sourceKind: "conversation_turn",
+                timestamp,
+                projectPath,
+                runtime: "cursor-agent",
+                sourceParts: [resolvePath(storeDb), blobId, role, content.slice(0, 80)],
+                sessionId,
+                data,
+            }));
+            if (role === "user") {
+                const sig = signalType(content);
+                if (sig) {
+                    records.push(record({
+                        sourceKind: "history_prompt",
+                        timestamp,
+                        projectPath,
+                        runtime: "cursor-agent",
+                        sourceParts: [resolvePath(storeDb), blobId, "history", content.slice(0, 120)],
+                        sessionId,
+                        data: { prompt: content, signal_type: sig },
+                    }));
+                }
+            }
+        }
+    }
+    return records;
+}
+// ── dispatch + envelope + main ──────────────────────────────────────
+import { pyJsonIndent } from "../core/pyjson.js";
+export class ExtractionNotImplementedError extends Error {
+}
+function extractRuntimeStore(runtime, storePath, errors, extractor) {
+    const discovery = discoverRuntimeStore(runtime, storePath);
+    if (discovery.status !== "available")
+        return [[], discovery];
+    const errorStart = errors.length;
+    let records;
+    try {
+        records = extractor(storePath, errors);
+    }
+    catch (exc) {
+        const cc = discovery.candidate_count ?? null;
+        if (exc instanceof ExtractionNotImplementedError) {
+            return [[], runtimeStatus(runtime, { status: "degraded", reason: "extractor_unimplemented", storePath, candidateCount: cc, recordCount: 0, errorCount: 0 })];
+        }
+        if (exc instanceof PermissionDeniedError) {
+            return [[], runtimeStatus(runtime, { status: "degraded", reason: "store_locked", storePath, candidateCount: cc })];
+        }
+        return [[], runtimeStatus(runtime, { status: "degraded", reason: "store_unreadable", storePath, candidateCount: cc })];
+    }
+    const cc = discovery.candidate_count ?? null;
+    const errorCount = errors.length - errorStart;
+    if (errorCount) {
+        return [records, runtimeStatus(runtime, { status: "degraded", reason: "schema_divergent", storePath, candidateCount: cc, recordCount: records.length, errorCount })];
+    }
+    if (records.length === 0) {
+        return [records, runtimeStatus(runtime, {
+                status: "sparse",
+                reason: "no_matching_records",
+                storePath,
+                candidateCount: cc,
+                recordCount: 0,
+                remediationLabels: runtime === "github-copilot" ? [COPILOT_SPARSE_REMEDIATION] : null,
+            })];
+    }
+    return [records, runtimeStatus(runtime, { status: "ok", reason: "records_extracted", storePath, candidateCount: cc, recordCount: records.length, errorCount: 0 })];
+}
+export function dedupeRecords(records) {
+    const byId = new Map();
+    for (const item of records)
+        byId.set(item.source_id, item);
+    const actorOrder = (item) => {
+        const actor = isPlainObject(item.data) ? item.data.actor : null;
+        return actor === "user" ? 0 : actor === "assistant" ? 1 : 2;
+    };
+    return Array.from(byId.values()).sort((a, b) => {
+        const at = (a.timestamp ?? "");
+        const bt = (b.timestamp ?? "");
+        if (at !== bt)
+            return at < bt ? -1 : 1;
+        const ak = (a.source_kind ?? "");
+        const bk = (b.source_kind ?? "");
+        if (ak !== bk)
+            return ak < bk ? -1 : 1;
+        const ao = actorOrder(a);
+        const bo = actorOrder(b);
+        if (ao !== bo)
+            return ao - bo;
+        const ai = (a.source_id ?? "");
+        const bi = (b.source_id ?? "");
+        return ai < bi ? -1 : ai > bi ? 1 : 0;
+    });
+}
+export function buildMetadata(records, errors, runtimeStatuses) {
+    const counts = new Map();
+    for (const item of records) {
+        const sk = item.source_kind;
+        if (FAMILIES.includes(sk))
+            counts.set(sk, (counts.get(sk) ?? 0) + 1);
+    }
+    const families = {};
+    for (const family of FAMILIES) {
+        const count = counts.get(family) ?? 0;
+        families[family] = { count, status: count ? "ok" : "missing" };
+        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();
+    return {
+        extracted_at: isoNow(),
+        runtimes,
+        adapter_version: ADAPTER_VERSION,
+        families,
+        runtime_statuses: runtimeStatuses,
+        total_records: records.length,
+        errors,
+    };
+}
+export function buildCorpus(opts) {
+    const errors = [];
+    const normalizedRoots = [];
+    for (const root of opts.projectRoots) {
+        if (fs.existsSync(root))
+            normalizedRoots.push(resolvePath(root));
+        else
+            errors.push(`${root}: project root does not exist`);
+    }
+    const records = [];
+    records.push(...extractInstructionDocuments(normalizedRoots, errors));
+    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)],
+        [
+            "cursor-agent",
+            opts.cursorChatsDir ?? null,
+            (sp, err) => extractCursorAgentSessions(sp, err, normalizedRoots, opts.cursorProjectsDir ?? null),
+        ],
+        ["opencode", opts.opencodeConversationsDir ?? null, extractOpencodeSessions],
+        ["github-copilot", opts.copilotConversationsDir ?? null, extractCopilotSessions],
+    ];
+    for (const [runtime, storePath, extractor] of runtimes) {
+        const [runtimeRecords, status] = extractRuntimeStore(runtime, storePath, errors, extractor);
+        records.push(...runtimeRecords);
+        runtimeStatuses.push(status);
+    }
+    const deduped = dedupeRecords(records);
+    return { metadata: buildMetadata(deduped, errors, runtimeStatuses), records: deduped };
+}
+export function parseExtractArgs(argv, env = process.env, platform = process.platform) {
+    const home = os.homedir();
+    const args = {
+        output: defaultOutputPath(env, platform),
+        projectRoot: [],
+        codexSessionsDir: path.join(home, ".codex", "sessions"),
+        claudeProjectsDir: path.join(home, ".claude", "projects"),
+        opencodeConversationsDir: null,
+        copilotConversationsDir: null,
+        cursorProjectsDir: null,
+        cursorChatsDir: null,
+        noCodex: false,
+        noClaude: false,
+        noOpencode: false,
+        noCopilot: false,
+        noCursor: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const val = (name) => {
+            if (a === name)
+                return argv[++i] ?? null;
+            if (a.startsWith(name + "="))
+                return a.slice(name.length + 1);
+            return null;
+        };
+        let v;
+        if ((v = val("--output")) !== null)
+            args.output = 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)
+            args.claudeProjectsDir = v;
+        else if ((v = val("--opencode-conversations-dir")) !== null)
+            args.opencodeConversationsDir = v;
+        else if ((v = val("--copilot-conversations-dir")) !== null)
+            args.copilotConversationsDir = v;
+        else if ((v = val("--cursor-projects-dir")) !== null)
+            args.cursorProjectsDir = v;
+        else if ((v = val("--cursor-chats-dir")) !== null)
+            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
+            throw new Error(`extract-corpus: unrecognized argument: ${a}`);
+    }
+    return args;
+}
+/** Engine entry point mirroring scripts/extract_corpus.py main(). */
+export function extractCorpusMain(argv, io = {}) {
+    const out = io.out ?? ((t) => process.stdout.write(t + "\n"));
+    const err = io.err ?? ((t) => process.stderr.write(t + "\n"));
+    const env = io.env ?? process.env;
+    const platform = io.platform ?? process.platform;
+    const cwd = io.cwd ?? process.cwd();
+    let args;
+    try {
+        args = parseExtractArgs(argv, env, platform);
+    }
+    catch (exc) {
+        err(exc.message);
+        return 2;
+    }
+    const projectRoots = args.projectRoot.length > 0 ? args.projectRoot : [cwd];
+    const skipCursor = args.noCursor;
+    const corpus = buildCorpus({
+        projectRoots,
+        codexSessionsDir: args.noCodex ? null : args.codexSessionsDir,
+        claudeProjectsDir: args.noClaude ? null : args.claudeProjectsDir,
+        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),
+    });
+    fs.mkdirSync(path.dirname(args.output), { recursive: true });
+    fs.writeFileSync(args.output, pyJsonIndent(corpus) + "\n", "utf-8");
+    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})`);
+    return 0;
+}
+//# sourceMappingURL=extractCorpus.js.map