agentera 3.0.0-dev.72 → 3.0.0-dev.74

package/bundle/references/cli/update-channels.yaml

@@ -3,7 +3,7 @@ status: active_authority
 purpose: >-
   Define dual update channels that select which published Agentera line upgrade,
   doctor, and prime resolve: stable tracks the supported 2.x line; development
-  tracks 3.x alphas and release candidates.
+  tracks 3.x prereleases.
 sources:
   prose:
     - references/cli/vocabulary.md#update-channels
@@ -60,7 +60,7 @@ channels:
   development:
     concept: v3_pre_release_line
     definition: >-
-      Tracks 3.x alphas, betas, and release candidates for early adopters and
+      Tracks 3.x prereleases for early adopters and
       maintainers testing the npm self-contained TypeScript distribution. The
       feat/v3 branch and v3 CLI are npm-only; v2→v3 is a one-way upgrade through
       npx @next, not through uvx or git checkout installs.

package/bundle/references/cli/vocabulary.md

@@ -399,7 +399,7 @@ for upgrade, doctor, prime, docs, and tests.
 
 Use this prose as guidance only: **stable** tracks the supported 2.x npm line
 and, for maintainers, `uvx --from git+...@main` (Python
-CLI). **development** tracks 3.x alphas and release candidates on **npm only**
+CLI). **development** tracks 3.x prereleases on **npm only**
 (`npx -y agentera@next`); feat/v3 is TypeScript-only and has no uv/git install
 path. v2→v3 is a one-way upgrade through the development npm channel. Default
 channel is stable. Override with `--channel`, `AGENTERA_UPDATE_CHANNEL`, or

package/bundle/references/meta/retained-reference-authority.yaml

@@ -19,6 +19,21 @@ inventory:
     production_owner: { module: packages/cli/src/registries/evidenceTierContract.ts, symbol: loadEvidenceTierContract }
     consumers:
       - { kind: runtime, module: packages/cli/src/registries/evidenceTierContract.ts, symbol: loadEvidenceTierContract, consumption: loads }
+  - path: references/analysis/personal-glossary-evaluation-authority.yaml
+    classification: current
+    production_owner: { module: packages/cli/src/eval/glossaryEvaluation.ts, symbol: loadGlossaryEvaluationAuthority }
+    consumers:
+      - { kind: runtime, module: packages/cli/src/eval/glossaryEvaluationSuccessReport.ts, symbol: validateGlossaryEvaluationSuccessReport, consumption: loads }
+  - path: references/analysis/personal-glossary-holdout.yaml
+    classification: current
+    production_owner: { module: packages/cli/src/eval/glossaryEvaluation.ts, symbol: loadGlossaryEvaluationHoldout }
+    consumers:
+      - { kind: runtime, module: packages/cli/src/eval/glossaryEvaluationSuccessReport.ts, symbol: validateGlossaryEvaluationSuccessReport, consumption: loads }
+  - path: references/analysis/personal-glossary-evaluation-corpus.yaml
+    classification: current
+    production_owner: { module: packages/cli/src/eval/glossaryEvaluation.ts, symbol: loadGlossaryEvaluationBehaviorFixture }
+    consumers:
+      - { kind: runtime, module: packages/cli/src/eval/glossaryEvaluationSuccessReport.ts, symbol: validateGlossaryEvaluationSuccessReport, consumption: loads }
   - path: references/analysis/verification-policy.yaml
     classification: current
     production_owner: { module: packages/cli/scripts/verify-lane.mjs, symbol: loadContract }

package/bundle/skills/agentera/capabilities/profile/schemas/artifacts.yaml

@@ -5,13 +5,17 @@ ARTIFACTS:
     local_role: produces_and_consumes
     description: >-
       Decision profile with per-entry confidence scoring, permanence
-      classification, and temporal metadata. Profile Full also owns one
-      deterministic personal Glossary section containing shared glossary entries
-      and lifecycle metadata; rendering and persistence are active while lookup
-      remains deferred. Profile writes this in both Full and Validate modes,
-      then reads it for validation and update context. Prime exposes its
-      canonical resolved path only inside `prime --context profile`; no other
-      Prime context or profile-grounding failure may serialize that path.
+      classification, and temporal metadata. After writing the base profile,
+      Profile Full consumes one existing consent-bound user-local personal
+       glossary generation. Only complete current coverage reaches bounded
+       classification and current explicit CLI decisions can replace its
+       deterministic owned Glossary section; inferred or ambiguous candidates
+       use the bounded review lifecycle. Unavailable, stale, or degraded coverage
+       preserves the base and owned section and requires explicit refresh. Lookup remains deferred. Profile writes
+      this in both Full and Validate modes, then reads it for validation and
+      update context. Prime exposes its canonical resolved path only inside
+      `prime --context profile`; no other Prime context or profile-grounding
+      failure may serialize that path.
   2:
     id: A2
     artifact: decisions

package/bundle/skills/agentera/capabilities/profile/schemas/exit.yaml

@@ -4,8 +4,10 @@ EXIT_CONDITIONS:
     condition: complete
     description: >-
       PROFILE.md was written (Full mode) or updated (Validate mode).
-      In Full mode its owned personal Glossary section was rendered and persisted,
-      metadata changes were applied, prediction accuracy was assessed, and
+      In Full mode the base profile was written first, then any existing personal
+      glossary generation produced only current authorized explicit publication;
+      remaining review work was queued or bounded for a question channel.
+      Metadata changes were applied, prediction accuracy was assessed, and
       changes were summarized.
     exit_signal: complete
   2:
@@ -16,7 +18,8 @@ EXIT_CONDITIONS:
       issues: available runtime history was skipped without explicit
       acceptance, extraction failed for one or more sources, prediction
       accuracy was below 3/5, or significant unresolved tensions were
-      found.
+      found. Full mode is also flagged when its existing consent-bound personal
+      glossary generation is unavailable, stale, degraded, or review-only.
     exit_signal: flagged
   3:
     id: E3

package/bundle/skills/agentera/capabilities/profile/schemas/validation.yaml

@@ -87,17 +87,22 @@ VALIDATION:
     id: V7
     rule: personal_glossary_output
     description: >-
-      Profile Full MUST render and persist exactly one owned Glossary section
-      through `npx -y agentera@next report profile-glossary`. Entries use only the shared
-      primitive and personal provenance variants. Replacement preserves every
-      non-glossary byte, malformed or ambiguous boundaries fail before effects,
-      and personal production never reads a project glossary.
+      After writing the base profile, Profile Full MUST consume only one existing
+      consent-bound user-local generation. The canonical publication operation
+      may render and persist exactly one owned Glossary section only after current
+      decision revalidation, and only for an explicit automatic admission.
+      Entries use only the shared primitive and personal provenance variants.
+      Replacement preserves every non-glossary byte, malformed or ambiguous
+      boundaries fail before effects, and personal production never reads a
+      project glossary.
     severity: critical
     checks:
-      - "Explicit entries retain exactly one evidence anchor"
-      - "Inferred entries retain exactly two pairwise-distinct evidence anchors"
+      - "Explicit publication retains exactly one current user-authored evidence anchor"
+      - "Inferred entries cannot receive automatic publication"
       - "Non-glossary PROFILE.md bytes and decision-pattern confidence are unchanged"
       - "No project glossary identity, path, parameter, import, or read is used"
+      - "Missing, failed, empty, degraded, or review-only mining preserves the base and owned section"
+      - "Degraded coverage performs no candidate classification, decision, review queue, or publication"
   8:
     id: V8
     rule: personal_glossary_lifecycle
@@ -113,3 +118,4 @@ VALIDATION:
       - "Stable, durable, and situational classes use their existing lambdas and floor"
       - "Fresh evidence refreshes only matching meaning and provenance kind"
       - "Glossary confidence never mutates decision-pattern confidence"
+      - "Question-capable hosts present only a bounded queued review set; other hosts use the durable queue"

package/bundle/skills/agentera/schemas/artifacts/glossary.yaml

@@ -19,6 +19,11 @@ CONFORMANCE:
   ownership_contract: project
   provenance_variant: project_file
   term_identity_runtime: packages/cli/src/registries/glossaryTermIdentity.ts#unicodeCaselessExact
+  personal_mining_authority: references/artifacts/glossary-entry-contract.yaml#personal_mining_authority
+  stable_term_identity_runtime: packages/cli/src/registries/glossaryTermIdentity.ts#stableGlossaryTermIdentity
+  candidate_revision_runtime: packages/cli/src/registries/glossaryTermIdentity.ts#glossaryCandidateRevision
+  candidate_contracts_authority: references/artifacts/glossary-entry-contract.yaml#candidate_contracts
+  candidate_contracts_runtime: packages/cli/src/registries/glossaryCandidateContracts.ts#validatePersonalCandidateContracts
   term_occurrence_runtime: packages/cli/src/registries/glossaryTermOccurrence.ts#containsGlossaryTerm
 
 DOCUMENT:

package/bundle/skills/agentera/schemas/artifacts/plan.yaml

@@ -623,6 +623,13 @@ LIFECYCLE_CONTRACT:
       roots:
         - .
       symlinks: Excluded because their targets may leave the repository boundary.
+      generated_output:
+        owner: packages/cli/scripts/generated-output.mjs#generatedOutputRoot
+        package_roots: [packages/cli]
+        treatment: exclude_exact_generated_root_subtree
+        reason: >-
+          Generated verification and build evidence is retained for bounded
+          downstream readers, but is not a tracked lifecycle-bearing source surface.
       excluded_directory_names:
         names:
           - .git

package/dist/.agentera-build-source.json

@@ -0,0 +1,8 @@
+{
+  "schemaVersion": "agentera.generatedBuildSource.v1",
+  "commit": "15c2b8d04ef350ff9e09bc5f40a0d079aeedc399",
+  "tree": "0e0c77c6fc7da5b3da9b6b92eaa6117e669658ef",
+  "files": 6724,
+  "workingTreeSha256": "634b717f526f20689aa5fa08cf3c268675617f59e56d77e1555b9e49cab07606",
+  "identitySha256": "b94b49cdad8c10a7f99ee0189b1981a8d8f3217b345b7e18e29e1f9a8de3c7ed"
+}

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") {
@@ -237,6 +240,9 @@ export function extractCopilotSessions(storePath, errors, ctx) {
                     sourceProduct: "github-copilot",
                     sourceParts: [resolvePath(dbPath), index, role, content.slice(0, 80)],
                     sessionId: String(row.session_id),
+                    originId,
+                    authorClass,
+                    content,
                     data,
                 }));
             }
@@ -265,6 +271,9 @@ export function extractCopilotSessions(storePath, errors, ctx) {
                         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 },
                     }));
                 }

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-v3-corpus-2";
+export const ADAPTER_VERSION = "agentera-v3-corpus-3";
 export const FAMILIES = [
     "instruction_document",
     "history_prompt",
@@ -27,6 +27,19 @@ 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;
@@ -44,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)
@@ -112,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) {
@@ -184,7 +392,7 @@ export function discoverRuntimeStore(runtime, storePath, opts = {}) {
         });
     }
     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 {
@@ -194,7 +402,7 @@ export function discoverRuntimeStore(runtime, storePath, opts = {}) {
         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, {
@@ -241,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) {
@@ -383,6 +601,8 @@ export function toolCallRecordFromItem(args) {
         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
     });
 }

package/dist/analytics/extractCorpus/corpus.js

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import { ADAPTER_VERSION, FAMILIES, isoNow, runtimeStatus, discoverRuntimeStore, COPILOT_SPARSE_REMEDIATION, } from "./core.js";
+import { ADAPTER_VERSION, FAMILIES, isoNow, runtimeStatus, discoverRuntimeStore, COPILOT_SPARSE_REMEDIATION, assessProvenance, } from "./core.js";
 import { isPlainObject } from "./core.js";
 import { extractInstructionDocuments, extractProjectConfigSignals } from "./filesystemSources.js";
 import { extractCodexSessions, extractClaudeProjectSessions } from "./jsonlSessions.js";
@@ -36,6 +36,23 @@ function extractRuntimeStore(runtime, storePath, errors, extractor, sqliteCaps,
     }
     const fc = (discovery.file_count ?? null); // cast: discovery payload IO boundary
     const errorCount = errors.length - errorStart;
+    const recordProvenance = assessProvenance(records);
+    if (!recordProvenance.complete) {
+        return [
+            records,
+            runtimeStatus(runtime, {
+                status: "degraded",
+                reason: "provenance_missing",
+                storePath,
+                fileCount: fc,
+                recordCount: records.length,
+                errorCount,
+                provenanceMissingFields: recordProvenance.missingFields,
+                provenanceMissingRecords: recordProvenance.missingRecords,
+                ...provenance,
+            }),
+        ];
+    }
     if (errorCount) {
         return [records, runtimeStatus(runtime, { status: "degraded", reason: "schema_divergent", storePath, fileCount: fc, recordCount: records.length, errorCount, ...provenance })];
     }

package/dist/analytics/extractCorpus/cursorSessions.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import crypto from "node:crypto";
 import { execFileSync } from "node:child_process";
 import { expanduser, resolvePath } from "../../core/paths.js";
-import { MAX_TOOL_ARG_TEXT, eventTimestamp, isFilePath, isoFromMtime, iterJsonl, record, signalType, textFromContent, toolCallRecordFromItem, } from "./core.js";
+import { authorClassForRole, MAX_TOOL_ARG_TEXT, eventTimestamp, isFilePath, isoFromMtime, iterJsonl, record, signalType, textFromContent, transportProvenance, toolCallRecordFromItem, } from "./core.js";
 import { isPlainObject, rglob, isDir } from "./core.js";
 import { openSqlite, } from "./sqliteSessions.js";
 function pathStem(p) {
@@ -153,7 +153,7 @@ export function extractCursorSessions(projectsDir, errors, projectRoots = null)
         for (const event of iterJsonl(p, errors)) {
             index += 1;
             const role = event.role;
-            if (role !== "user" && role !== "assistant")
+            if (typeof role !== "string" || role.length === 0)
                 continue;
             let contentIndex = 0;
             for (const item of cursorContentItems(event)) {
@@ -180,6 +180,9 @@ export function extractCursorSessions(projectsDir, errors, projectRoots = null)
             if (!content)
                 continue;
             const timestamp = eventTimestamp(event, fallbackTimestamp);
+            const transport = transportProvenance(event, ...items);
+            const originId = transport.originId;
+            const authorClass = authorClassForRole(role, transport.authorClass, transport.originId);
             const data = { actor: role, content };
             if (role === "user") {
                 if (previousAssistant)
@@ -198,6 +201,9 @@ export function extractCursorSessions(projectsDir, errors, projectRoots = null)
                 runtime: "cursor",
                 sourceParts: [resolvePath(p), index, role, content.slice(0, 80)],
                 sessionId,
+                originId,
+                authorClass,
+                content,
                 data,
             }));
             if (role === "user") {
@@ -210,6 +216,9 @@ export function extractCursorSessions(projectsDir, errors, projectRoots = null)
                         runtime: "cursor",
                         sourceParts: [resolvePath(p), index, "history", content.slice(0, 120)],
                         sessionId,
+                        originId,
+                        authorClass,
+                        content,
                         data: { prompt: content, signal_type: sig },
                     }));
                 }
@@ -356,6 +365,8 @@ export function extractCursorAgentSessions(chatsDir, errors, projectRoots = null
         for (const [blobId, message] of cursorAgentBlobMessages(storeDb, errors)) {
             index += 1;
             const role = message.role;
+            if (typeof role !== "string" || role.length === 0)
+                continue;
             let toolIndex = 0;
             for (const toolItem of cursorAgentToolItems(message)) {
                 toolIndex += 1;
@@ -377,12 +388,13 @@ export function extractCursorAgentSessions(chatsDir, errors, projectRoots = null
                     records.push(tr);
                 }
             }
-            if (role !== "user" && role !== "assistant")
-                continue;
             const content = cursorAgentMessageText(message);
             if (!content)
                 continue;
             const timestamp = eventTimestamp(message, fallbackTimestamp);
+            const transport = transportProvenance(message);
+            const originId = transport.originId;
+            const authorClass = authorClassForRole(role, transport.authorClass, transport.originId);
             const data = { actor: role, content };
             if (role === "user") {
                 if (previousAssistant)
@@ -402,6 +414,9 @@ export function extractCursorAgentSessions(chatsDir, errors, projectRoots = null
                 sourceProduct: "cursor-agent",
                 sourceParts: [resolvePath(storeDb), blobId, role, content.slice(0, 80)],
                 sessionId,
+                originId,
+                authorClass,
+                content,
                 data,
             }));
             if (role === "user") {
@@ -415,6 +430,9 @@ export function extractCursorAgentSessions(chatsDir, errors, projectRoots = null
                         sourceProduct: "cursor-agent",
                         sourceParts: [resolvePath(storeDb), blobId, "history", content.slice(0, 120)],
                         sessionId,
+                        originId,
+                        authorClass,
+                        content,
                         data: { prompt: content, signal_type: sig },
                     }));
                 }