agentera 3.0.0-dev.72 → 3.0.0-dev.75

package/dist/analytics/extractCorpus/evidenceTiers.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { pyJsonIndentSorted } from "../../core/pyjson.js";
 import { writeFileAtomic } from "../../core/atomicWriter.js";
-import { stableId, defaultProfileDir } from "./core.js";
+import { assessProvenance, stableId, defaultProfileDir, } from "./core.js";
 import { evidenceTierBounds, loadEvidenceTierContract } from "../../registries/evidenceTierContract.js";
 /**
  * Bounded tier publication and direct retrieval (plan Task 2).
@@ -87,8 +87,16 @@ export function deriveSignalRecords(fullRecords) {
             project_id: asStringField(r, "project_id"),
             runtime: typeof r.runtime === "string" ? r.runtime : null,
             source_product: asStringField(r, "source_product"),
+            source_class: asStringField(r, "source_class"),
             evidence_anchor: sourceId,
+            active_runtime: r.active_runtime === true,
         };
+        if (typeof r.origin_id === "string")
+            rec.origin_id = r.origin_id;
+        if (typeof r.content_fingerprint === "string")
+            rec.content_fingerprint = r.content_fingerprint;
+        if (typeof r.author_class === "string")
+            rec.author_class = r.author_class;
         if (typeof r.conversation_key === "string")
             rec.conversation_key = r.conversation_key;
         if (typeof r.session_id === "string")
@@ -280,6 +288,9 @@ function coverageFromStatuses(runtimeStatuses) {
         }
         if (GAP.has(status)) {
             const entry = { runtime, reason: reason || status };
+            if (Array.isArray(s.provenance_missing_fields) && s.provenance_missing_fields.length > 0) {
+                entry.reason += ` (missing provenance: ${s.provenance_missing_fields.join(",")})`;
+            }
             if (typeof s.store_path === "string")
                 entry.store_path = s.store_path;
             skipped.push(entry);
@@ -297,6 +308,31 @@ export function publishEvidenceTiers(records, opts, contractPath) {
     const bounds = evidenceTierBounds(contractPath);
     const productFamily = productFamilyIndex(contractPath);
     const sortedRecords = records.slice().sort(tierSortKey);
+    const provenance = assessProvenance(sortedRecords);
+    const runtimeStatuses = [...(opts.runtimeStatuses ?? [])];
+    if (!provenance.complete) {
+        const gapProducts = new Map();
+        for (const record of sortedRecords) {
+            if (Object.keys(record).length === 0)
+                continue;
+            if (assessProvenance([record]).complete)
+                continue;
+            const product = typeof record.source_product === "string" ? record.source_product : "unknown";
+            if (!gapProducts.has(product)) {
+                gapProducts.set(product, {
+                    runtime: typeof record.runtime === "string" ? record.runtime : null,
+                    source_product: product,
+                    source_class: typeof record.source_class === "string" ? record.source_class : "unknown",
+                    active_runtime: record.active_runtime === true,
+                    status: "degraded",
+                    reason: "provenance_missing",
+                    provenance_missing_fields: provenance.missingFields,
+                    provenance_missing_records: provenance.missingRecords,
+                });
+            }
+        }
+        runtimeStatuses.push(...gapProducts.values());
+    }
     const signals = deriveSignalRecords(sortedRecords);
     const { records: selectedSignals, selection } = selectSignalsForBound(signals, bounds.signalByteCap);
     const shards = shardFullEvidence(sortedRecords, bounds.shardByteCap, productFamily);
@@ -342,7 +378,7 @@ export function publishEvidenceTiers(records, opts, contractPath) {
         families: familiesAgg,
         shards: shardDescriptors,
         signal: { path: signalRel, record_count: selectedSignals.length, bytes: signalBytes, selection },
-        coverage: coverageFromStatuses(opts.runtimeStatuses),
+        coverage: coverageFromStatuses(runtimeStatuses),
         corpus_metadata: opts.corpusMetadata,
     };
     writeFileAtomic(path.join(stageDir, "manifest.json"), encodeSorted(manifest) + "\n");
@@ -433,6 +469,68 @@ function isEvidenceTierManifest(value) {
         Array.isArray(shard.source_ids) &&
         shard.source_ids.every((sourceId) => typeof sourceId === "string"));
 }
+function lowerSha256(value) {
+    return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+/** Validate bounded signal provenance without reading any full-evidence shard. */
+export function missingSignalProvenanceFields(record) {
+    const missing = [];
+    const required = [
+        ["source_id", typeof record.source_id === "string" && record.source_id.length > 0],
+        ["source_kind", typeof record.source_kind === "string" && record.source_kind.length > 0],
+        ["signal_type", typeof record.signal_type === "string" && record.signal_type.length > 0],
+        ["timestamp", typeof record.timestamp === "string" && record.timestamp.length > 0],
+        ["project_id", typeof record.project_id === "string" && record.project_id.length > 0],
+        ["source_product", typeof record.source_product === "string" && record.source_product.length > 0],
+        ["active_runtime", typeof record.active_runtime === "boolean"],
+        ["source_class", typeof record.source_class === "string" && record.source_class.length > 0],
+        ["evidence_anchor", record.evidence_anchor === record.source_id && record.evidence_anchor.length > 0],
+    ];
+    for (const [field, present] of required)
+        if (!present)
+            missing.push(field);
+    if (CONVERSATION_SIGNAL_SOURCE_KINDS.has(record.source_kind)) {
+        if (!lowerSha256(record.origin_id))
+            missing.push("origin_id");
+        if (!lowerSha256(record.content_fingerprint))
+            missing.push("content_fingerprint");
+        if (typeof record.author_class !== "string" || record.author_class.length === 0)
+            missing.push("author_class");
+        if (typeof record.session_id !== "string" || record.session_id.length === 0)
+            missing.push("session_id");
+    }
+    return [...new Set(missing)];
+}
+const CONVERSATION_SIGNAL_SOURCE_KINDS = new Set(["conversation_turn", "history_prompt"]);
+function signalProvenanceGaps(records) {
+    const gaps = new Set();
+    for (const record of records) {
+        if (!isMapping(record)) {
+            gaps.add("record");
+            continue;
+        }
+        for (const field of missingSignalProvenanceFields(record))
+            gaps.add(field);
+    }
+    return [...gaps].sort();
+}
+function readSignalPayload(gen) {
+    const signalPath = path.join(gen.dir, gen.manifest.signal.path);
+    if (!fs.existsSync(signalPath))
+        return null;
+    try {
+        const bytes = fs.statSync(signalPath).size;
+        if (bytes > evidenceTierBounds().signalByteCap)
+            return null;
+        const data = JSON.parse(fs.readFileSync(signalPath, "utf-8"));
+        if (!data || !Array.isArray(data.records))
+            return null;
+        return { records: data.records, bytes };
+    }
+    catch {
+        return null;
+    }
+}
 /** Resolve the current generation directory and manifest, or null. */
 export function readCurrentGeneration(tiersDir) {
     const pointer = readCurrentPointer(tiersDir);
@@ -453,26 +551,16 @@ export function readCurrentGeneration(tiersDir) {
     }
 }
 /** Read the bounded signal tier records for the current generation. */
-export function readSignalTier(tiersDir) {
+export function readSignalTier(tiersDir, options = {}) {
     const gen = readCurrentGeneration(tiersDir);
     if (!gen)
         return null;
-    const signalPath = path.join(gen.dir, gen.manifest.signal.path);
-    if (!fs.existsSync(signalPath))
+    const payload = readSignalPayload(gen);
+    if (!payload)
         return null;
-    try {
-        const bytes = fs.statSync(signalPath).size;
-        const signalByteCap = evidenceTierBounds().signalByteCap;
-        if (bytes > signalByteCap)
-            return null;
-        const data = JSON.parse(fs.readFileSync(signalPath, "utf-8"));
-        if (!data || !Array.isArray(data.records))
-            return null;
-        return { records: data.records, bytes, manifest: gen.manifest };
-    }
-    catch {
+    if (!options.allowProvenanceGaps && signalProvenanceGaps(payload.records).length > 0)
         return null;
-    }
+    return { ...payload, manifest: gen.manifest };
 }
 /** Resolve a bounded signal's identity (evidence_anchor) to its full record. */
 export function resolveEvidenceAnchor(anchor, tiersDir) {
@@ -543,6 +631,24 @@ export function evidenceTierCompatibility(tiersDir, corpusPath) {
         gen.manifest.signal.bytes > evidenceTierBounds().signalByteCap) {
         return { state: "oversized", reason: "oversized", artifact: gen.manifest.signal.path };
     }
+    let signalPayload;
+    try {
+        const data = JSON.parse(fs.readFileSync(signalPath, "utf-8"));
+        signalPayload = data && Array.isArray(data.records) ? { records: data.records, bytes: actualSignalBytes } : null;
+    }
+    catch {
+        signalPayload = null;
+    }
+    if (!signalPayload)
+        return { state: "corrupt", reason: "unreadable_or_schema_divergent" };
+    const provenanceGaps = signalProvenanceGaps(signalPayload.records);
+    if (provenanceGaps.length > 0) {
+        return {
+            state: "incomplete",
+            reason: "provenance_missing",
+            detail: provenanceGaps.map((field) => `signal: missing ${field}`),
+        };
+    }
     // Incomplete: a supported source family is skipped/sparse/missing.
     const skipped = gen.manifest.coverage.skipped;
     if (skipped.length > 0) {

package/dist/analytics/extractCorpus/filesystemSources.js

@@ -23,7 +23,9 @@ export function extractInstructionDocuments(projectRoots, errors) {
                 timestamp: isoFromMtime(p),
                 projectPath: root,
                 runtime: "filesystem",
+                origin: resolvePath(p),
                 sourceParts: [resolvePath(p)],
+                content,
                 data: { doc_type: docType, name: filename, content, scope: "project" },
             }));
         }
@@ -109,7 +111,9 @@ export function extractProjectConfigSignals(projectRoots, errors) {
                 timestamp: isoFromMtime(p),
                 projectPath: root,
                 runtime: "filesystem",
+                origin: resolvePath(p),
                 sourceParts: [resolvePath(p), configType],
+                content: signals.join("\n"),
                 data: { config_type: configType, file_path: path.relative(root, p), signals },
             }));
         }

package/dist/analytics/extractCorpus/index.js

@@ -1,4 +1,4 @@
-export { ADAPTER_VERSION, FAMILIES, RUNTIME_STORE_GLOBS, isoNow, isoFromMtime, stableId, projectIdFromPath, defaultAgenteraHome, defaultProfileDir, defaultOutputPath, runtimeStatus, discoverRuntimeStore, record, payloadItem, eventKind, eventTimestamp, textFromContent, claudeContentItems, iterJsonl, signalType, } from "./core.js";
+export { ADAPTER_VERSION, FAMILIES, RUNTIME_STORE_GLOBS, isoNow, isoFromMtime, stableId, originIdentity, contentFingerprint, transportProvenance, authorClassForRole, missingProvenanceFields, assessProvenance, countIndependentOrigins, projectIdFromPath, defaultAgenteraHome, defaultProfileDir, defaultOutputPath, runtimeStatus, discoverRuntimeStore, record, payloadItem, eventKind, eventTimestamp, textFromContent, claudeContentItems, iterJsonl, signalType, } from "./core.js";
 export { extractInstructionDocuments, extractProjectConfigSignals } from "./filesystemSources.js";
 export { extractCodexSessions, extractClaudeProjectSessions } from "./jsonlSessions.js";
 export { extractOpencodeSessions, PermissionDeniedError } from "./sqliteSessions.js";
@@ -8,7 +8,7 @@ export { ExtractionNotImplementedError, dedupeRecords, buildMetadata, buildCorpu
 export { formatTruncationWarnings, resolveSqliteCaps, } from "./sqliteCaps.js";
 export { COVERAGE_EXIT_FLAGGED, corpusEnvelopeCoverage, formatCoverageSummaryText, resolveRuntimeStoreConfigs, runCoverageAudit, } from "./coverageAudit.js";
 export { parseExtractArgs, extractCorpusMain } from "./cli.js";
-export { TIER_SCHEMA_VERSION, CURRENT_POINTER_VERSION, defaultTiersDir, familyOf, deriveSignalRecords, shardFullEvidence, selectSignalsForBound, generationId, publishEvidenceTiers, readCurrentPointer, readCurrentGeneration, readSignalTier, getFullRecord, resolveEvidenceAnchor, evidenceTierCompatibility, iterTierRecords, readTierCorpusMetadata, } from "./evidenceTiers.js";
+export { TIER_SCHEMA_VERSION, CURRENT_POINTER_VERSION, defaultTiersDir, familyOf, deriveSignalRecords, shardFullEvidence, selectSignalsForBound, generationId, publishEvidenceTiers, readCurrentPointer, readCurrentGeneration, readSignalTier, missingSignalProvenanceFields, getFullRecord, resolveEvidenceAnchor, evidenceTierCompatibility, iterTierRecords, readTierCorpusMetadata, } from "./evidenceTiers.js";
 export { tiersDirForCorpusPath, resolveTiersDir, isAnalyzable, recoveryForState, assessTiers, readBoundedMetadata, iterBoundedRecords, legacyCorpusReadable, } from "./tierReader.js";
 export { EXTRACT_CORPUS_PARITY_SCHEMA, buildExtractCorpusParityManifest, opencodeParitySnapshot, } from "./extractCorpusParity.js";
 export { readProfileSignals, resolveProfileEvidence, profileSignalsStatus, assessProfileSufficiency, } from "../profileSignals.js";

package/dist/analytics/extractCorpus/jsonlSessions.js

@@ -1,12 +1,43 @@
 import fs from "node:fs";
 import path from "node:path";
 import { resolvePath } from "../../core/paths.js";
-import { claudeContentItems, eventKind, eventTimestamp, isPlainObject, isoFromMtime, iterJsonl, payloadItem, record, rglob, signalType, textFromContent, toolCallRecord, toolCallRecordFromItem, } from "./core.js";
+import { claudeContentItems, authorClassForRole, eventKind, eventTimestamp, inspectTransportProvenance, isPlainObject, isoFromMtime, iterJsonl, payloadItem, record, rglob, signalType, textFromContent, transportProvenance, toolCallRecord, toolCallRecordFromItem, } from "./core.js";
 function pathStem(p) {
     const base = path.basename(p);
     const ext = path.extname(base);
     return ext ? base.slice(0, -ext.length) : base;
 }
+function updateSessionProvenance(current, update) {
+    if (update.originState === "invalid")
+        return current;
+    const originId = update.originState === "valid" ? update.originId : current.originId;
+    const originChanged = update.originState === "valid" && originId !== current.originId;
+    if (originChanged) {
+        return {
+            originId,
+            authorClass: update.authorState === "valid" ? update.authorClass : null,
+        };
+    }
+    if (originId !== null && update.authorState === "valid") {
+        return { originId, authorClass: update.authorClass };
+    }
+    return { originId, authorClass: current.authorClass };
+}
+function codexMessageProvenance(role, message, session) {
+    const originId = message.originState === "valid" ? message.originId : session.originId;
+    if (message.originState === "invalid" || message.authorState === "invalid") {
+        return { originId, authorClass: null };
+    }
+    const explicitAuthorClass = message.authorState === "valid"
+        ? message.authorClass
+        : originId !== null && originId === session.originId
+            ? session.authorClass
+            : null;
+    return {
+        originId,
+        authorClass: authorClassForRole(role, explicitAuthorClass, originId),
+    };
+}
 export function extractCodexSessions(sessionsDir, errors) {
     if (sessionsDir === null || !fs.existsSync(sessionsDir))
         return [];
@@ -14,6 +45,7 @@ export function extractCodexSessions(sessionsDir, errors) {
     for (const p of rglob(sessionsDir, "*.jsonl")) {
         const fallbackTimestamp = isoFromMtime(p);
         let sessionId = pathStem(p);
+        let sessionProvenance = { originId: null, authorClass: null };
         let projectPath = null;
         let previousAssistant = "";
         let index = 0;
@@ -25,6 +57,7 @@ export function extractCodexSessions(sessionsDir, errors) {
                 const sid = payload.id || event.id;
                 if (typeof sid === "string" && sid)
                     sessionId = sid;
+                sessionProvenance = updateSessionProvenance(sessionProvenance, inspectTransportProvenance(event, payload));
                 const cwd = payload.cwd || payload.working_directory;
                 if (typeof cwd === "string" && cwd)
                     projectPath = cwd;
@@ -46,7 +79,7 @@ export function extractCodexSessions(sessionsDir, errors) {
             let role = item.role || item.actor;
             if (kind === "user_msg")
                 role = "user";
-            if (role !== "user" && role !== "assistant")
+            if (typeof role !== "string" || role.length === 0)
                 continue;
             const skipType = itemType !== undefined && itemType !== null && itemType !== "message";
             if (skipType && !["response_item", "user_msg"].includes(kind))
@@ -55,6 +88,7 @@ export function extractCodexSessions(sessionsDir, errors) {
             if (!content)
                 continue;
             const timestamp = eventTimestamp(event, fallbackTimestamp);
+            const transport = codexMessageProvenance(role, inspectTransportProvenance(event, item), sessionProvenance);
             const data = { actor: role, content };
             if (role === "user") {
                 if (previousAssistant)
@@ -73,6 +107,9 @@ export function extractCodexSessions(sessionsDir, errors) {
                 runtime: "codex",
                 sourceParts: [resolvePath(p), index, role, content.slice(0, 80)],
                 sessionId,
+                originId: transport.originId,
+                authorClass: transport.authorClass,
+                content,
                 data,
             }));
             if (role === "user") {
@@ -85,6 +122,9 @@ export function extractCodexSessions(sessionsDir, errors) {
                         runtime: "codex",
                         sourceParts: [resolvePath(p), index, "history", content.slice(0, 120)],
                         sessionId,
+                        originId: transport.originId,
+                        authorClass: transport.authorClass,
+                        content,
                         data: { prompt: content, signal_type: sig },
                     }));
                 }
@@ -152,12 +192,15 @@ export function extractClaudeProjectSessions(projectsDir, errors) {
                 if (isPlainObject(message))
                     role = message.role;
             }
-            if (role !== "user" && role !== "assistant")
+            if (typeof role !== "string" || role.length === 0)
                 continue;
             const content = textFromContent(event.content || event.text || (isPlainObject(event.message) ? event.message : null));
             if (!content)
                 continue;
             const timestamp = eventTimestamp(event, fallbackTimestamp);
+            const transport = transportProvenance(event, isPlainObject(event.message) ? event.message : null);
+            const originId = transport.originId;
+            const authorClass = authorClassForRole(role, transport.authorClass, transport.originId);
             const data = { actor: role, content };
             if (role === "user") {
                 if (previousAssistant)
@@ -179,6 +222,9 @@ export function extractClaudeProjectSessions(projectsDir, errors) {
                 activeRuntime: false,
                 sourceParts: [resolvePath(p), index, role, content.slice(0, 80)],
                 sessionId,
+                originId,
+                authorClass,
+                content,
                 data,
             }));
             if (role === "user") {
@@ -194,6 +240,9 @@ export function extractClaudeProjectSessions(projectsDir, errors) {
                         activeRuntime: false,
                         sourceParts: [resolvePath(p), index, "history", content.slice(0, 120)],
                         sessionId,
+                        originId,
+                        authorClass,
+                        content,
                         data: { prompt: content, signal_type: sig },
                     }));
                 }

package/dist/analytics/extractCorpus/sqliteSessions.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import { createRequire } from "node:module";
 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, isFilePath, rglob } from "./core.js";
 import { resolveSqliteCaps, } from "./sqliteCaps.js";
 const requireCjs = createRequire(import.meta.url);
@@ -271,8 +271,11 @@ export function extractOpencodeSessions(storePath, errors, ctx) {
             const messageTime = row.message_time || nestedTimeCreated(messageData);
             let item = messages.get(messageId);
             if (item === undefined) {
+                const transport = transportProvenance(messageData);
                 item = {
                     role,
+                    origin_id: transport.originId,
+                    author_class: authorClassForRole(role, transport.authorClass, transport.originId),
                     session_id: String(row.session_id),
                     project_path: row.project_path,
                     timestamp: sqliteTimestamp(messageTime, fallbackTimestamp),
@@ -305,9 +308,9 @@ export function extractOpencodeSessions(storePath, errors, ctx) {
         let index = 0;
         for (const item of messages.values()) {
             index += 1;
-            const role = String(item.role).toLowerCase();
-            if (role !== "user" && role !== "assistant")
+            if (typeof item.role !== "string" || item.role.length === 0)
                 continue;
+            const role = item.role.toLowerCase();
             const content = item.parts.filter((p) => p).join("\n");
             if (!content && item.tools.length === 0)
                 continue;
@@ -331,6 +334,9 @@ export function extractOpencodeSessions(storePath, errors, ctx) {
                     runtime: "opencode",
                     sourceParts: [resolvePath(dbPath), index, role, content.slice(0, 80)],
                     sessionId: item.session_id,
+                    originId: item.origin_id,
+                    authorClass: item.author_class,
+                    content,
                     data,
                 }));
             }
@@ -357,6 +363,9 @@ export function extractOpencodeSessions(storePath, errors, ctx) {
                         runtime: "opencode",
                         sourceParts: [resolvePath(dbPath), index, "history", content.slice(0, 120)],
                         sessionId: item.session_id,
+                        originId: item.origin_id,
+                        authorClass: item.author_class,
+                        content,
                         data: { prompt: content, signal_type: sig },
                     }));
                 }

package/dist/analytics/personalGlossaryAdmission.js

@@ -1,34 +1,7 @@
 import { personalGlossaryAdmissionContract } from "../registries/glossaryEntryContract.js";
 import { readSignalTier, resolveEvidenceAnchor, } from "./extractCorpus/evidenceTiers.js";
 import { assessTiers, recoveryForState } from "./extractCorpus/tierReader.js";
-function trimMeaning(value) {
-    return value
-        .trim()
-        .replace(/[.!?]+$/, "")
-        .trim();
-}
-/** Classify only authority-supported explicit correction or clarification forms. */
-export function classifyExplicitGlossaryLanguage(text) {
-    const correction = /\b(?:actually|not quite|instead|correction)\b[^`"']*([`"'])([^`"']+)\1\s+means\s+(.+)$/i.exec(text);
-    const clarification = /\bto clarify\b.*?\bprefer\s+([`"'])([^`"']+)\1\s+to mean\s+(.+)$/i.exec(text);
-    const match = correction ?? clarification;
-    if (!match)
-        return null;
-    const term = match[2].trim();
-    const meaning = trimMeaning(match[3]);
-    return term && meaning ? { term, meaning } : null;
-}
-function recordText(record) {
-    const data = record.data;
-    if (!data || typeof data !== "object" || Array.isArray(data))
-        return "";
-    const object = data;
-    for (const field of ["text", "prompt", "content"]) {
-        if (typeof object[field] === "string")
-            return object[field];
-    }
-    return "";
-}
+import { mineExplicitGlossaryCandidates } from "./personalGlossaryExplicitMining.js";
 function semanticValues(record) {
     const data = record.data;
     if (!data || typeof data !== "object" || Array.isArray(data))
@@ -50,6 +23,10 @@ function containsCompleteTerm(text, term) {
     const escaped = term.trim().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     return escaped.length > 0 && new RegExp(`(^|[^a-z0-9])${escaped}(?=$|[^a-z0-9])`, "i").test(text);
 }
+function hasInferredProvenance(signal) {
+    return (/^[a-f0-9]{64}$/.test(signal.origin_id ?? "") &&
+        /^[a-f0-9]{64}$/.test(signal.content_fingerprint ?? ""));
+}
 function unavailable(state) {
     return { state, status: "unavailable", candidates: [], recovery: recoveryForState(state) };
 }
@@ -75,6 +52,8 @@ export function admitPersonalGlossaryEvidence(input, resolveAnchor = resolveEvid
             inferredKinds.has(signal.source_kind)));
     const resolved = new Map();
     for (const signal of selected) {
+        if (explicitTypes.has(signal.signal_type))
+            continue;
         if (resolved.has(signal.evidence_anchor))
             continue;
         const record = resolveAnchor(signal.evidence_anchor, input.tiersDir);
@@ -85,28 +64,24 @@ export function admitPersonalGlossaryEvidence(input, resolveAnchor = resolveEvid
         }
     }
     const candidates = [];
-    for (const { signal, record } of resolved.values()) {
-        if (!explicitTypes.has(signal.signal_type))
-            continue;
-        const classified = classifyExplicitGlossaryLanguage(recordText(record));
-        if (!classified)
-            continue;
+    const explicitMining = mineExplicitGlossaryCandidates({ tiersDir: input.tiersDir }, resolveAnchor);
+    for (const { capsule } of explicitMining.candidates) {
         candidates.push({
             kind: "personal_explicit_definition",
-            ...classified,
-            evidence: [
-                {
-                    source_id: signal.source_id,
-                    evidence_anchor: signal.evidence_anchor,
-                    signal_type: signal.signal_type,
-                },
-            ],
+            term: capsule.term,
+            meaning: capsule.meaning,
+            evidence: capsule.evidence.map((evidence) => ({
+                source_id: String(evidence.source_id),
+                evidence_anchor: String(evidence.evidence_anchor),
+                signal_type: String(evidence.signal_type),
+            })),
         });
     }
     for (const term of new Set(input.requestedTerms.map((value) => value.trim()).filter(Boolean))) {
         const evidence = [...resolved.values()]
             .filter(({ signal, record }) => inferredTypes.has(signal.signal_type) &&
             inferredKinds.has(signal.source_kind) &&
+            hasInferredProvenance(signal) &&
             semanticValues(record).some((value) => containsCompleteTerm(value, term)))
             .map(({ signal }) => ({
             source_id: signal.source_id,
@@ -116,10 +91,10 @@ export function admitPersonalGlossaryEvidence(input, resolveAnchor = resolveEvid
             .filter((item, index, all) => all.findIndex((candidate) => candidate.source_id === item.source_id ||
             candidate.evidence_anchor === item.evidence_anchor) === index)
             .sort((left, right) => left.source_id.localeCompare(right.source_id));
-        if (evidence.length >= 2 &&
-            new Set(evidence.map((item) => item.source_id)).size >= 2 &&
-            new Set(evidence.map((item) => item.evidence_anchor)).size >= 2) {
-            candidates.push({ kind: "personal_inferred_usage", term, evidence: evidence.slice(0, 2) });
+        if (evidence.length === 2 &&
+            new Set(evidence.map((item) => item.source_id)).size === 2 &&
+            new Set(evidence.map((item) => item.evidence_anchor)).size === 2) {
+            candidates.push({ kind: "personal_inferred_usage", term, evidence });
         }
     }
     return candidates.length > 0
@@ -131,3 +106,8 @@ export function admitPersonalGlossaryEvidence(input, resolveAnchor = resolveEvid
             recovery: authority.insufficientRecovery,
         };
 }
+export { classifyExplicitGlossaryLanguage, discoverExplicitGlossaryCues, mineExplicitGlossaryCandidates, mineExplicitGlossaryEvidence, minePersonalExplicitGlossaryCandidates, EXPLICIT_GLOSSARY_REASONS, } from "./personalGlossaryExplicit.js";
+export { mineRecurringGlossaryCandidates, mineRecurringGlossaryEvidence, PERSONAL_GLOSSARY_MINING_POLICY_VERSION, RECURRING_MEANING_PENDING_REVIEW, RECURRING_REASONS, } from "./personalGlossaryRecurrence.js";
+export { maintainPersonalGlossaryCandidateProjection, personalGlossaryCandidateProjectionPath, personalGlossaryProjectionProjectIdentity, persistPersonalGlossaryCandidateProjection, projectPersonalGlossaryCandidates, readPersonalGlossaryCandidateProjection, } from "./personalGlossaryCandidateProjection.js";
+export { decidePersonalGlossaryCandidate, } from "./personalGlossaryDecision.js";
+export { currentPersonalGlossaryReviewRecords, maintainPersonalGlossaryReviewRecords, personalGlossaryReviewRecordsPath, queuePersonalGlossaryReviewRecord, readPersonalGlossaryReviewRecords, } from "./personalGlossaryReviewRecords.js";