agentera 3.0.0-dev.7 → 3.0.0-dev.74

package/dist/analytics/extractCorpus/cli.js

@@ -1,8 +1,7 @@
-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";
@@ -11,6 +10,7 @@ export function parseExtractArgs(argv, env = process.env, platform = process.pla
     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"),
@@ -19,7 +19,7 @@ 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,
@@ -27,6 +27,7 @@ export function parseExtractArgs(argv, env = process.env, platform = process.pla
         coverageAuditOnly: false,
         format: "text",
     };
+    let claudeProjectsDirExplicit = false;
     for (let i = 0; i < argv.length; i++) {
         const a = argv[i];
         const val = (name) => {
@@ -37,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)
@@ -55,8 +70,6 @@ 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")
@@ -87,6 +100,9 @@ export function parseExtractArgs(argv, env = process.env, platform = process.pla
         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(). */
@@ -105,6 +121,10 @@ 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));
@@ -126,7 +146,7 @@ export function extractCorpusMain(argv, io = {}) {
     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),
@@ -134,8 +154,6 @@ export function extractCorpusMain(argv, io = {}) {
         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);
@@ -143,7 +161,30 @@ export function extractCorpusMain(argv, io = {}) {
     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,9 +1,9 @@
 import fs from "node:fs";
 import { resolvePath } from "../../core/paths.js";
-import { isoFromMtime, record, signalType, textFromContent, } from "./core.js";
+import { authorClassForRole, isoFromMtime, record, signalType, textFromContent, transportProvenance, } 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";
+import { PermissionDeniedError, openSqlite, jsonDict, sqliteTimestamp, tableColumns, firstColumn, qualified, } from "./sqliteSessions.js";
 function copilotDbCandidates(storePath) {
     if (isFilePath(storePath))
         return [storePath];
@@ -208,15 +208,18 @@ export function extractCopilotSessions(storePath, errors, ctx) {
         let index = 0;
         for (const row of rows) {
             index += 1;
-            const role = String(row.role).toLowerCase();
-            if (role !== "user" && role !== "assistant")
+            if (typeof row.role !== "string" || row.role.length === 0)
                 continue;
+            const role = row.role.toLowerCase();
             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);
+            const transport = transportProvenance(row, jsonDict(row.turn_data));
+            const originId = transport.originId;
+            const authorClass = authorClassForRole(role, transport.authorClass, transport.originId);
             if (content) {
                 const data = { actor: role, content };
                 if (role === "user") {
@@ -233,9 +236,13 @@ export function extractCopilotSessions(storePath, errors, ctx) {
                     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),
+                    originId,
+                    authorClass,
+                    content,
                     data,
                 }));
             }
@@ -246,7 +253,8 @@ export function extractCopilotSessions(storePath, errors, ctx) {
                     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 || {} },
@@ -259,9 +267,13 @@ export function extractCopilotSessions(storePath, errors, ctx) {
                         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),
+                        originId,
+                        authorClass,
+                        content,
                         data: { prompt: content, signal_type: sig },
                     }));
                 }
@@ -270,4 +282,3 @@ export function extractCopilotSessions(storePath, errors, ctx) {
     }
     return records;
 }
-//# sourceMappingURL=copilotSessions.js.map

package/dist/analytics/extractCorpus/core.js

@@ -5,7 +5,7 @@ import { resolveProfileDirOverride, resolveXdgDataHome } from "../../core/envPat
 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-3";
 export const FAMILIES = [
     "instruction_document",
     "history_prompt",
@@ -15,16 +15,31 @@ 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;
 export const COPILOT_SPARSE_REMEDIATION = "/chronicle reindex";
+const ORIGIN_ID_RE = /^[a-f0-9]{64}$/;
+const CONTENT_FINGERPRINT_RE = /^[a-f0-9]{64}$/;
+const CONVERSATION_SOURCE_KINDS = new Set(["conversation_turn", "history_prompt"]);
+const PROVENANCE_NESTED_KEYS = ["payload", "item", "metadata", "meta", "provenance", "source"];
+const PROVENANCE_ORIGIN_KEYS = [
+    "origin_id",
+    "original_origin_id",
+    "original_origin",
+    "origin",
+    "source_origin",
+    "instruction_origin",
+];
+const PROVENANCE_AUTHOR_KEYS = ["author_class", "authorClass", "author"];
 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;
@@ -42,6 +57,195 @@ 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);
 }
+/** A bounded, deterministic identity for the source that originally supplied a record. */
+export function originIdentity(origin) {
+    if (typeof origin !== "string" || origin.length === 0) {
+        throw new TypeError("origin must be a non-empty string");
+    }
+    return crypto
+        .createHash("sha256")
+        .update("agentera.corpus.origin.v1\0", "utf-8")
+        .update(origin, "utf-8")
+        .digest("hex");
+}
+/** A lowercase SHA-256 of the exact source text, without normalization or truncation. */
+export function contentFingerprint(content) {
+    if (typeof content !== "string")
+        throw new TypeError("content must be a string");
+    return crypto.createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function provenanceObjects(sources) {
+    const out = [];
+    const pending = sources.slice();
+    const seen = new Set();
+    while (pending.length > 0 && out.length < 24) {
+        const value = pending.shift();
+        if (!isPlainObject(value) || seen.has(value))
+            continue;
+        seen.add(value);
+        out.push(value);
+        for (const key of PROVENANCE_NESTED_KEYS) {
+            const nested = value[key];
+            if (isPlainObject(nested))
+                pending.push(nested);
+        }
+    }
+    return out;
+}
+function inspectStringField(sources, keys) {
+    for (const source of sources) {
+        for (const key of keys) {
+            if (!Object.prototype.hasOwnProperty.call(source, key))
+                continue;
+            const value = source[key];
+            return nonEmptyString(value)
+                ? { state: "valid", key, value }
+                : { state: "invalid", key, value: null };
+        }
+    }
+    return { state: "absent", key: null, value: null };
+}
+function transportOriginId(key, value) {
+    return ORIGIN_ID_RE.test(value) && key.endsWith("_id") ? value : originIdentity(value);
+}
+/** Inspect the first explicit transport fields without collapsing malformed values into absence. */
+export function inspectTransportProvenance(...sources) {
+    const objects = provenanceObjects(sources);
+    const origin = inspectStringField(objects, PROVENANCE_ORIGIN_KEYS);
+    const author = inspectStringField(objects, PROVENANCE_AUTHOR_KEYS);
+    return {
+        originId: origin.state === "valid" ? transportOriginId(origin.key, origin.value) : null,
+        authorClass: author.state === "valid" ? author.value : null,
+        originState: origin.state,
+        authorState: author.state,
+    };
+}
+/**
+ * Read only explicit transport metadata. Content is never inspected to infer
+ * either ownership or origin. An adapter may provide an origin digest directly,
+ * or a bounded source label that is converted to one.
+ */
+export function transportProvenance(...sources) {
+    let origin = null;
+    let authorClass = null;
+    for (const source of provenanceObjects(sources)) {
+        if (origin === null) {
+            for (const key of PROVENANCE_ORIGIN_KEYS) {
+                const value = source[key];
+                if (nonEmptyString(value)) {
+                    origin = transportOriginId(key, value);
+                    break;
+                }
+            }
+        }
+        if (authorClass === null) {
+            for (const key of PROVENANCE_AUTHOR_KEYS) {
+                const value = source[key];
+                if (nonEmptyString(value)) {
+                    authorClass = value;
+                    break;
+                }
+            }
+        }
+        if (origin !== null && authorClass !== null)
+            break;
+    }
+    return { originId: origin, authorClass };
+}
+/**
+ * Map a transport role to a source-author class without examining its text.
+ * A claimed transported origin requires the original author to be explicit;
+ * the envelope role is not evidence for the source that was transported.
+ */
+export function authorClassForRole(role, explicitAuthorClass = null, transportedOriginId = null) {
+    const explicit = nonEmptyString(explicitAuthorClass);
+    if (!explicit && nonEmptyString(transportedOriginId))
+        return null;
+    const value = explicit ? explicitAuthorClass : nonEmptyString(role) ? role : null;
+    if (value === null)
+        return null;
+    switch (value.toLowerCase()) {
+        case "user":
+            return "user";
+        case "assistant":
+        case "model":
+        case "tool":
+            return "agent";
+        case "system":
+        case "developer":
+        case "instruction":
+            return "injected_instruction";
+        default:
+            return explicit ? value : null;
+    }
+}
+/** Return the bounded provenance fields missing from one retained record. */
+export function missingProvenanceFields(item) {
+    const missing = [];
+    const required = [
+        ["source_id", nonEmptyString(item.source_id)],
+        ["source_kind", nonEmptyString(item.source_kind)],
+        ["timestamp", nonEmptyString(item.timestamp)],
+        ["project_id", nonEmptyString(item.project_id)],
+        ["source_class", nonEmptyString(item.source_class)],
+        ["source_product", nonEmptyString(item.source_product)],
+        ["adapter_version", nonEmptyString(item.adapter_version)],
+        ["data", isPlainObject(item.data)],
+    ];
+    for (const [field, present] of required)
+        if (!present)
+            missing.push(field);
+    if (typeof item.runtime !== "string" && item.runtime !== null)
+        missing.push("runtime");
+    if (typeof item.active_runtime !== "boolean")
+        missing.push("active_runtime");
+    if (CONVERSATION_SOURCE_KINDS.has(String(item.source_kind))) {
+        if (!ORIGIN_ID_RE.test(String(item.origin_id ?? "")))
+            missing.push("origin_id");
+        if (!nonEmptyString(item.author_class))
+            missing.push("author_class");
+        if (!CONTENT_FINGERPRINT_RE.test(String(item.content_fingerprint ?? ""))) {
+            missing.push("content_fingerprint");
+        }
+        if (!nonEmptyString(item.session_id))
+            missing.push("session_id");
+    }
+    return [...new Set(missing)];
+}
+export function assessProvenance(records) {
+    const fields = new Set();
+    let missingRecords = 0;
+    for (const record of records) {
+        const missing = missingProvenanceFields(record);
+        if (missing.length === 0)
+            continue;
+        missingRecords += 1;
+        for (const field of missing)
+            fields.add(field);
+    }
+    return { complete: missingRecords === 0, missingFields: [...fields].sort(), missingRecords };
+}
+/**
+ * Count independent conversation origins without using record IDs or copy
+ * counts. Repeated transport of one origin and fingerprint contributes once;
+ * a different origin remains independent even when its text is identical.
+ */
+export function countIndependentOrigins(records) {
+    const identities = new Set();
+    for (const record of records) {
+        if (!CONVERSATION_SOURCE_KINDS.has(String(record.source_kind)))
+            continue;
+        const originId = record.origin_id;
+        const fingerprint = record.content_fingerprint;
+        if (!ORIGIN_ID_RE.test(String(originId ?? "")) || !CONTENT_FINGERPRINT_RE.test(String(fingerprint ?? "")))
+            continue;
+        identities.add(`${originId}\0${fingerprint}`);
+    }
+    return identities.size;
+}
 /** Python str() for the scalar/None values stable_id receives. */
 function pyStr(value) {
     if (value === null || value === undefined)
@@ -85,7 +289,15 @@ 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.fileCount !== null && opts.fileCount !== undefined)
@@ -102,6 +314,12 @@ export function runtimeStatus(runtime, opts) {
         item.truncation_cap = opts.truncationCap;
     if (opts.truncationLimit !== null && opts.truncationLimit !== undefined)
         item.truncation_limit = opts.truncationLimit;
+    if (opts.provenanceMissingFields && opts.provenanceMissingFields.length > 0) {
+        item.provenance_missing_fields = opts.provenanceMissingFields;
+    }
+    if (opts.provenanceMissingRecords !== null && opts.provenanceMissingRecords !== undefined) {
+        item.provenance_missing_records = opts.provenanceMissingRecords;
+    }
     return item;
 }
 function isDir(p) {
@@ -146,35 +364,45 @@ 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,
             fileCount: 1,
+            ...statusOpts,
         });
     }
     if (!isDir(storePath)) {
-        return runtimeStatus(runtime, { status: "degraded", reason: "store_not_directory", storePath });
+        return runtimeStatus(runtime, { status: "degraded", reason: "store_not_directory", storePath, ...statusOpts });
     }
     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 });
+        return runtimeStatus(runtime, { status: "degraded", reason: "store_unreadable", storePath, ...statusOpts });
     }
     if (candidates.length === 0) {
         return runtimeStatus(runtime, {
@@ -182,7 +410,8 @@ export function discoverRuntimeStore(runtime, storePath) {
             reason: "no_candidate_files",
             storePath,
             fileCount: 0,
-            remediationLabels: runtime === "github-copilot" ? [COPILOT_SPARSE_REMEDIATION] : null,
+            remediationLabels: runtime === "copilot" ? [COPILOT_SPARSE_REMEDIATION] : null,
+            ...statusOpts,
         });
     }
     return runtimeStatus(runtime, {
@@ -190,6 +419,7 @@ export function discoverRuntimeStore(runtime, storePath) {
         reason: "candidate_files_found",
         storePath,
         fileCount: candidates.length,
+        ...statusOpts,
     });
 }
 // ── record builders + content helpers ──────────────────────────────
@@ -200,12 +430,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,
     };
@@ -215,6 +449,16 @@ export function record(opts) {
         item.session_id = opts.sessionId;
         item.conversation_key = opts.sessionId;
     }
+    if (opts.originId)
+        item.origin_id = opts.originId;
+    else if (opts.origin)
+        item.origin_id = originIdentity(opts.origin);
+    else if (opts.sessionId)
+        item.origin_id = originIdentity(`session:${opts.sessionId}`);
+    if (opts.authorClass)
+        item.author_class = opts.authorClass;
+    if (typeof opts.content === "string")
+        item.content_fingerprint = contentFingerprint(opts.content);
     return item;
 }
 function isPlainObject(v) {
@@ -352,8 +596,13 @@ 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,
+        originId: transportProvenance(args.event, args.item).originId,
+        authorClass: "agent",
         data: { tool_name: toolName, arguments: argumentsVal }, // cast: parsed JSON IO boundary
     });
 }
@@ -361,4 +610,3 @@ export function toolCallRecord(args) {
     return toolCallRecordFromItem({ ...args, item: payloadItem(args.event) });
 }
 export { isPlainObject, rglob, isDir, isFilePath };
-//# sourceMappingURL=core.js.map