@xopcai/xopc 0.0.217 → 0.0.219

package/dist/src/storage/sqlite/context-extraction-repository.js

@@ -0,0 +1,119 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import "../../user-context/domain.js";
+import { randomUUID } from "node:crypto";
+//#region src/storage/sqlite/context-extraction-repository.ts
+function runFromRow(row) {
+	return {
+		id: row.extraction_run_id,
+		principalId: row.principal_id,
+		sourceRef: row.source_ref,
+		extractorId: row.extractor_id,
+		extractorVersion: row.extractor_version,
+		processingPolicy: row.processing_policy,
+		destination: row.destination,
+		inputHash: row.input_hash,
+		status: row.status,
+		...row.error_code ? { errorCode: row.error_code } : {},
+		startedAt: row.started_at,
+		...row.completed_at == null ? {} : { completedAt: row.completed_at }
+	};
+}
+function outputFromRow(row) {
+	return {
+		id: row.output_id,
+		runId: row.extraction_run_id,
+		ordinal: row.ordinal,
+		candidateKey: row.candidate_key,
+		...row.object_type ? { objectType: row.object_type } : {},
+		...row.object_id ? { objectId: row.object_id } : {},
+		...row.version_id ? { versionId: row.version_id } : {},
+		outcome: row.outcome,
+		createdAt: row.created_at
+	};
+}
+function claimContextExtractionRun(input) {
+	const principalId = input.principalId ?? "local-owner";
+	const now = input.nowMs ?? Date.now();
+	return runSqliteWriteTransaction((db) => {
+		const existing = db.prepare(`SELECT * FROM context_extraction_runs
+      WHERE principal_id = ? AND source_ref = ? AND extractor_id = ? AND extractor_version = ?`).get(principalId, input.sourceRef, input.extractorId, input.extractorVersion);
+		if (existing) {
+			if (existing.input_hash !== input.inputHash) throw new Error("Extraction source changed without a new source reference");
+			if (existing.status !== "failed") return {
+				run: runFromRow(existing),
+				shouldExecute: false
+			};
+			db.prepare(`UPDATE context_extraction_runs
+        SET status = 'running', error_code = NULL, started_at = ?, completed_at = NULL
+        WHERE extraction_run_id = ?`).run(now, existing.extraction_run_id);
+			return {
+				run: runFromRow(db.prepare("SELECT * FROM context_extraction_runs WHERE extraction_run_id = ?").get(existing.extraction_run_id)),
+				shouldExecute: true
+			};
+		}
+		const id = randomUUID();
+		db.prepare(`INSERT INTO context_extraction_runs (
+      extraction_run_id, principal_id, source_ref, extractor_id, extractor_version,
+      processing_policy, destination, input_hash, status, started_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'running', ?)`).run(id, principalId, input.sourceRef, input.extractorId, input.extractorVersion, input.processingPolicy, input.destination, input.inputHash, now);
+		return {
+			run: runFromRow(db.prepare("SELECT * FROM context_extraction_runs WHERE extraction_run_id = ?").get(id)),
+			shouldExecute: true
+		};
+	});
+}
+function finishContextExtractionRun(input) {
+	const now = input.nowMs ?? Date.now();
+	return runSqliteWriteTransaction((db) => {
+		if (!db.prepare(`UPDATE context_extraction_runs SET status = ?, error_code = ?, completed_at = ?
+      WHERE extraction_run_id = ?`).run(input.status, input.errorCode ?? null, now, input.runId).changes) return null;
+		db.prepare("DELETE FROM context_extraction_outputs WHERE extraction_run_id = ?").run(input.runId);
+		const insert = db.prepare(`INSERT INTO context_extraction_outputs (
+      output_id, extraction_run_id, ordinal, candidate_key, object_type, object_id,
+      version_id, outcome, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+		for (const [ordinal, output] of (input.outputs ?? []).entries()) insert.run(randomUUID(), input.runId, ordinal, output.candidateKey, output.objectType ?? null, output.objectId ?? null, output.versionId ?? null, output.outcome, now);
+		return runFromRow(db.prepare("SELECT * FROM context_extraction_runs WHERE extraction_run_id = ?").get(input.runId));
+	});
+}
+function listContextExtractionRuns(filter = {}) {
+	const clauses = [];
+	const values = [];
+	if (filter.sourceRef) {
+		clauses.push("source_ref = ?");
+		values.push(filter.sourceRef);
+	}
+	if (filter.extractorId) {
+		clauses.push("extractor_id = ?");
+		values.push(filter.extractorId);
+	}
+	if (filter.extractorVersion) {
+		clauses.push("extractor_version = ?");
+		values.push(filter.extractorVersion);
+	}
+	if (filter.status) {
+		clauses.push("status = ?");
+		values.push(filter.status);
+	}
+	values.push(Math.max(1, Math.min(500, filter.limit ?? 100)));
+	return getSqliteDatabase().prepare(`SELECT * FROM context_extraction_runs
+    ${clauses.length ? `WHERE ${clauses.join(" AND ")}` : ""} ORDER BY started_at DESC LIMIT ?`).all(...values).map(runFromRow);
+}
+function getContextExtractionRun(id) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM context_extraction_runs WHERE extraction_run_id = ?").get(id);
+	return row ? runFromRow(row) : null;
+}
+function listContextExtractionOutputs(runId) {
+	return getSqliteDatabase().prepare(`SELECT * FROM context_extraction_outputs
+    WHERE extraction_run_id = ? ORDER BY ordinal`).all(runId).map(outputFromRow);
+}
+function hasIndependentExtractionOutput(runIds, objectType, objectId) {
+	if (!runIds.length) return false;
+	const placeholders = runIds.map(() => "?").join(", ");
+	return Boolean(getSqliteDatabase().prepare(`SELECT 1 FROM context_extraction_outputs o
+    JOIN context_extraction_runs r ON r.extraction_run_id = o.extraction_run_id
+    WHERE o.extraction_run_id NOT IN (${placeholders}) AND o.object_type = ? AND o.object_id = ?
+      AND r.status = 'completed' LIMIT 1`).get(...runIds, objectType, objectId));
+}
+//#endregion
+export { claimContextExtractionRun, finishContextExtractionRun, getContextExtractionRun, hasIndependentExtractionOutput, listContextExtractionOutputs, listContextExtractionRuns };

package/dist/src/storage/sqlite/context-relation-repository.d.ts

@@ -0,0 +1,50 @@
+import type { ContextObjectType } from './context-extraction-repository.js';
+export type ContextObjectRelation = {
+    id: string;
+    subjectType: ContextObjectType;
+    subjectId: string;
+    subjectVersionId?: string;
+    predicate: 'supersedes' | 'supports' | 'contradicts' | 'related_to';
+    objectType: ContextObjectType;
+    objectId: string;
+    objectVersionId?: string;
+    factual: boolean;
+    extractionRunId?: string;
+    createdAt: number;
+};
+export type ContextTemporalAssertion = {
+    id: string;
+    objectType: 'focus' | 'understanding';
+    objectId: string;
+    objectVersionId?: string;
+    assertionType: 'current_state' | 'routine' | 'relationship' | 'project_status';
+    value: Record<string, unknown>;
+    confidence: number;
+    validFrom?: number;
+    validTo?: number;
+    status: 'candidate' | 'active' | 'closed' | 'rejected';
+    extractionRunId?: string;
+    createdAt: number;
+    updatedAt: number;
+};
+export declare function linkContextObjects(input: Omit<ContextObjectRelation, 'id' | 'createdAt'> & {
+    nowMs?: number;
+}): ContextObjectRelation;
+export declare function listContextObjectRelations(input?: {
+    objectType?: ContextObjectType;
+    objectId?: string;
+    extractionRunId?: string;
+}): ContextObjectRelation[];
+export declare function createTemporalAssertion(input: Omit<ContextTemporalAssertion, 'id' | 'createdAt' | 'updatedAt'> & {
+    nowMs?: number;
+}): ContextTemporalAssertion;
+export declare function closeTemporalAssertions(input: {
+    objectType: ContextTemporalAssertion['objectType'];
+    objectId: string;
+    validTo?: number;
+}): number;
+export declare function listTemporalAssertions(input?: {
+    objectType?: ContextTemporalAssertion['objectType'];
+    objectId?: string;
+    status?: ContextTemporalAssertion['status'];
+}): ContextTemporalAssertion[];

package/dist/src/storage/sqlite/context-relation-repository.js

@@ -0,0 +1,97 @@
+import { getSqliteDatabase } from "./transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/storage/sqlite/context-relation-repository.ts
+function relationFromRow(row) {
+	return {
+		id: row.relation_id,
+		subjectType: row.subject_type,
+		subjectId: row.subject_id,
+		...row.subject_version_id ? { subjectVersionId: row.subject_version_id } : {},
+		predicate: row.predicate,
+		objectType: row.object_type,
+		objectId: row.object_id,
+		...row.object_version_id ? { objectVersionId: row.object_version_id } : {},
+		factual: row.factual === 1,
+		...row.extraction_run_id ? { extractionRunId: row.extraction_run_id } : {},
+		createdAt: row.created_at
+	};
+}
+function assertionFromRow(row) {
+	return {
+		id: row.assertion_id,
+		objectType: row.object_type,
+		objectId: row.object_id,
+		...row.object_version_id ? { objectVersionId: row.object_version_id } : {},
+		assertionType: row.assertion_type,
+		value: JSON.parse(row.value_json),
+		confidence: row.confidence,
+		...row.valid_from == null ? {} : { validFrom: row.valid_from },
+		...row.valid_to == null ? {} : { validTo: row.valid_to },
+		status: row.status,
+		...row.extraction_run_id ? { extractionRunId: row.extraction_run_id } : {},
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function linkContextObjects(input) {
+	const now = input.nowMs ?? Date.now();
+	const factual = input.predicate !== "related_to";
+	getSqliteDatabase().prepare(`INSERT INTO context_object_relations (
+    relation_id, subject_type, subject_id, subject_version_id, predicate,
+    object_type, object_id, object_version_id, factual, extraction_run_id, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  ON CONFLICT DO UPDATE SET factual = excluded.factual, extraction_run_id = excluded.extraction_run_id`).run(randomUUID(), input.subjectType, input.subjectId, input.subjectVersionId ?? null, input.predicate, input.objectType, input.objectId, input.objectVersionId ?? null, factual ? 1 : 0, input.extractionRunId ?? null, now);
+	return relationFromRow(getSqliteDatabase().prepare(`SELECT * FROM context_object_relations
+    WHERE subject_type = ? AND subject_id = ? AND COALESCE(subject_version_id, '') = COALESCE(?, '')
+      AND predicate = ? AND object_type = ? AND object_id = ?
+      AND COALESCE(object_version_id, '') = COALESCE(?, '')`).get(input.subjectType, input.subjectId, input.subjectVersionId ?? null, input.predicate, input.objectType, input.objectId, input.objectVersionId ?? null));
+}
+function listContextObjectRelations(input = {}) {
+	const clauses = [];
+	const values = [];
+	if (input.objectType && input.objectId) {
+		clauses.push("((subject_type = ? AND subject_id = ?) OR (object_type = ? AND object_id = ?))");
+		values.push(input.objectType, input.objectId, input.objectType, input.objectId);
+	}
+	if (input.extractionRunId) {
+		clauses.push("extraction_run_id = ?");
+		values.push(input.extractionRunId);
+	}
+	return getSqliteDatabase().prepare(`SELECT * FROM context_object_relations
+    ${clauses.length ? `WHERE ${clauses.join(" AND ")}` : ""} ORDER BY created_at DESC`).all(...values).map(relationFromRow);
+}
+function createTemporalAssertion(input) {
+	const now = input.nowMs ?? Date.now();
+	const id = randomUUID();
+	getSqliteDatabase().prepare(`INSERT INTO context_temporal_assertions (
+    assertion_id, object_type, object_id, object_version_id, assertion_type, value_json,
+    confidence, valid_from, valid_to, status, extraction_run_id, created_at, updated_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.objectType, input.objectId, input.objectVersionId ?? null, input.assertionType, JSON.stringify(input.value), input.confidence, input.validFrom ?? null, input.validTo ?? null, input.status, input.extractionRunId ?? null, now, now);
+	return assertionFromRow(getSqliteDatabase().prepare("SELECT * FROM context_temporal_assertions WHERE assertion_id = ?").get(id));
+}
+function closeTemporalAssertions(input) {
+	const now = input.validTo ?? Date.now();
+	return Number(getSqliteDatabase().prepare(`UPDATE context_temporal_assertions
+    SET status = 'closed', valid_to = COALESCE(valid_to, ?), updated_at = ?
+    WHERE object_type = ? AND object_id = ? AND status = 'active'`).run(now, now, input.objectType, input.objectId).changes);
+}
+function listTemporalAssertions(input = {}) {
+	const clauses = [];
+	const values = [];
+	if (input.objectType) {
+		clauses.push("object_type = ?");
+		values.push(input.objectType);
+	}
+	if (input.objectId) {
+		clauses.push("object_id = ?");
+		values.push(input.objectId);
+	}
+	if (input.status) {
+		clauses.push("status = ?");
+		values.push(input.status);
+	}
+	return getSqliteDatabase().prepare(`SELECT * FROM context_temporal_assertions
+    ${clauses.length ? `WHERE ${clauses.join(" AND ")}` : ""} ORDER BY created_at DESC`).all(...values).map(assertionFromRow);
+}
+//#endregion
+export { closeTemporalAssertions, createTemporalAssertion, linkContextObjects, listContextObjectRelations, listTemporalAssertions };

package/dist/src/storage/sqlite/index.d.ts

@@ -5,10 +5,12 @@ export { DatabaseSchemaMigrationGapError, DatabaseSchemaTooNewError, } from './m
 export { discoverSqlMigrations, listRegisteredMigrationTargets } from './migrations/discover.js';
 export { closeXopcDatabase, getXopcDatabase, isXopcDatabaseOpen, openXopcDatabase, requireXopcDatabase, resetXopcDatabaseSingletonForTest, type OpenXopcDatabaseOptions, type XopcDatabase, } from './connection.js';
 export { getSqliteDatabase, runSqliteWriteTransaction } from './transaction.js';
+export { claimContextExtractionRun, finishContextExtractionRun, getContextExtractionRun, hasIndependentExtractionOutput, listContextExtractionOutputs, listContextExtractionRuns, type ContextExtractionOutput, type ContextExtractionRun, type ContextExtractionStatus, type ContextObjectType, } from './context-extraction-repository.js';
+export { closeTemporalAssertions, createTemporalAssertion, linkContextObjects, listContextObjectRelations, listTemporalAssertions, type ContextObjectRelation, type ContextTemporalAssertion, } from './context-relation-repository.js';
 export { finishContextConsolidationRun, getContextConsolidationRun, listContextConsolidationDecisions, listContextConsolidationRuns, recordContextConsolidationDecision, startContextConsolidationRun, type ContextConsolidationDecision, type ContextConsolidationRun, } from './context-consolidation-repository.js';
 export { summarizeUnderstandingFeedback, summarizeUserUnderstandingQuality, type UnderstandingFeedbackSummary, type UserUnderstandingQualityMetrics, } from './user-context-quality-repository.js';
-export { createCollaborationRule, createContextEvidence, createUnderstanding, consumeContextConsent, deleteCollaborationRule, deleteUnderstanding, decideContextConsent, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, listCollaborationRules, listUnderstandingEvidence, listUnderstandings, linkUnderstandingEvidence, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, searchActiveUnderstandings, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile, type CreateUnderstandingInput, } from './user-context-repository.js';
-export { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputState, insertSessionInput, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus, type SessionInput, type SessionInputDelivery, type SessionInputState, type SessionInputStatus, } from './session-input-repository.js';
+export { createCollaborationRule, createContextEvidence, createUnderstanding, closeUnderstandingValidity, consumeContextConsent, deleteCollaborationRule, deleteUnderstanding, decideContextConsent, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, listCollaborationRules, listUnderstandingEvidence, listUnderstandings, linkUnderstandingEvidence, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, searchActiveUnderstandings, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile, type CreateUnderstandingInput, } from './user-context-repository.js';
+export { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputState, getSessionInputById, insertSessionInput, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus, type SessionInput, type SessionInputDelivery, type SessionInputState, type SessionInputStatus, } from './session-input-repository.js';
 export { replaceLatestSessionTurnAndQueueInput, validateLatestSessionTurnTarget, type ReplaceLatestSessionTurnInput, type ReplaceLatestSessionTurnResult, } from './session-turn-replace-repository.js';
 export { acknowledgeHomeAttention, isHomeAttentionAcknowledged, type HomeAttentionSubjectKind, } from './home-attention-repository.js';
 export { claimNextConnectorLearningJob, enqueueConnectorLearningJob, listConnectorLearningJobs, recoverStaleConnectorLearningJobs, setConnectorLearningPaused, updateConnectorLearningJob, type ConnectorLearningJob, type ConnectorLearningMode, type ConnectorLearningPhase, type ConnectorLearningStatus, } from './connector-learning-repository.js';

package/dist/src/storage/sqlite/index.js

@@ -6,10 +6,12 @@ import { XOPC_DB_BASELINE_SCHEMA_VERSION, XOPC_DB_SCHEMA_VERSION, applyPendingMi
 import { ensureXopcDatabaseSchema } from "./schema.js";
 import { closeXopcDatabase, getXopcDatabase, isXopcDatabaseOpen, openXopcDatabase, requireXopcDatabase, resetXopcDatabaseSingletonForTest } from "./connection.js";
 import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { claimContextExtractionRun, finishContextExtractionRun, getContextExtractionRun, hasIndependentExtractionOutput, listContextExtractionOutputs, listContextExtractionRuns } from "./context-extraction-repository.js";
+import { closeTemporalAssertions, createTemporalAssertion, linkContextObjects, listContextObjectRelations, listTemporalAssertions } from "./context-relation-repository.js";
 import { finishContextConsolidationRun, getContextConsolidationRun, listContextConsolidationDecisions, listContextConsolidationRuns, recordContextConsolidationDecision, startContextConsolidationRun } from "./context-consolidation-repository.js";
 import { summarizeUnderstandingFeedback, summarizeUserUnderstandingQuality } from "./user-context-quality-repository.js";
-import { consumeContextConsent, createCollaborationRule, createContextEvidence, createUnderstanding, decideContextConsent, deleteCollaborationRule, deleteUnderstanding, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, linkUnderstandingEvidence, listCollaborationRules, listUnderstandingEvidence, listUnderstandings, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, searchActiveUnderstandings, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile } from "./user-context-repository.js";
-import { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputState, insertSessionInput, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus } from "./session-input-repository.js";
+import { closeUnderstandingValidity, consumeContextConsent, createCollaborationRule, createContextEvidence, createUnderstanding, decideContextConsent, deleteCollaborationRule, deleteUnderstanding, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, linkUnderstandingEvidence, listCollaborationRules, listUnderstandingEvidence, listUnderstandings, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, searchActiveUnderstandings, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile } from "./user-context-repository.js";
+import { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputById, getSessionInputState, insertSessionInput, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus } from "./session-input-repository.js";
 import { buildDefaultSessionMetadata } from "./session-metadata.js";
 import { buildGlobalSessionStats, classifyStoredRow, estimateTokensFromMessages, extractFtsContent, metadataToSessionInsert, sessionConfigRowToConfig, sessionRowToMetadata, transcriptEntryRowToStoredRow } from "./row-mappers.js";
 import { replaceLatestSessionTurnAndQueueInput, validateLatestSessionTurnTarget } from "./session-turn-replace-repository.js";
@@ -33,4 +35,4 @@ import { appendConnectorExecutionAudit, claimConnectorWebhookDelivery, completeC
 import { getConnectorAccount, listConnectorAccounts, reconcileConnectorAccount, refreshConnectorAccountCurrent } from "./connector-account-repository.js";
 import { getConnectorSyncPolicy, getConnectorSyncPolicyForConnection, listConnectorSyncPolicies, upsertConnectorSyncPolicy } from "./connector-sync-policy-repository.js";
 import { getUserTrustPolicy, setUserTrustPolicy } from "./user-trust-repository.js";
-export { COMPOSER_INPUT_HISTORY_LIMIT, DatabaseSchemaMigrationGapError, DatabaseSchemaTooNewError, SCHEMA_META_SCHEMA_VERSION_KEY, XOPC_DB_BASELINE_SCHEMA_VERSION, XOPC_DB_FILENAME, XOPC_DB_SCHEMA_VERSION, acknowledgeHomeAttention, appendCompactionBoundaryIfUnchanged, appendComposerInputHistory, appendConnectorExecutionAudit, appendMemorySignal, appendMemoryTraceEvent, appendTranscriptEntry, applyPendingMigrations, attachMemoryEvidence, bindEndpointPrincipal, buildDefaultSessionMetadata, buildGlobalSessionStats, buildRelationshipPrompt, cancelQueuedSessionInput, claimConnectorWebhookDelivery, claimKnowledgeSourceItems, claimNextConnectorLearningJob, claimNextSessionInput, classifyStoredRow, clearComposerInputHistory, closeXopcDatabase, completeConnectorWebhookDelivery, completeKnowledgeSourceItemSynthesis, consumeConnectorApproval, consumeContextConsent, createCollaborationRule, createConnectorApproval, createContextEvidence, createEndpointPrincipal, createObjectLinkRecord, createUnderstanding, decideConnectorApproval, decideContextConsent, deleteCollaborationRule, deleteConnectorConnection, deleteConnectorInstallation, deleteMemoryEvidenceForRecord, deleteMemoryRecord, deleteNoteAgentContextRecord, deleteNoteRecord, deleteObjectLinkRecord, deleteSessionConfig, deleteSessionRecord, deleteUnderstanding, discoverSqlMigrations, enqueueConnectorLearningJob, ensureContextConsent, ensureSessionRecord, ensureXopcDatabaseSchema, estimateTokensFromMessages, extractFtsContent, findSessionInput, findSessionKeyBySessionId, finishContextConsolidationRun, finishEndpointToolInvocationAudit, finishKnowledgeSyncRun, finishSessionInputRun, getActivityEventRecord, getCachedConnectorCatalogEntry, getCollaborationRule, getConnectorAccount, getConnectorApproval, getConnectorConnection, getConnectorInstallation, getConnectorSyncPolicy, getConnectorSyncPolicyForConnection, getContextConsolidationRun, getCurrentSessionId, getEndpointPrincipal, getGlobalSessionStats, getInteractionState, getKnowledgeConsumerWatermark, getKnowledgeSourceCursor, getKnowledgeSourceItem, getMemoryProviderState, getMemoryRecord, getMemoryTurnFeedback, getNoteAgentContextRecord, getNoteRecord, getRelationshipSettings, getSessionConfig, getSessionInputState, getSessionMetadata, getSessionPersistedLevels, getSessionTaskPlan, getSqliteDatabase, getTurnPersonalization, getUnderstanding, getUserProfile, getUserTrustPolicy, getXopcDatabase, hasContextConsent, hasSessionConfig, hasUnresolvedMemoryConflict, incrementSessionStatsOnAppend, insertSessionInput, inspectSchemaMigrationStatus, isHomeAttentionAcknowledged, isProactiveSupportAllowed, isUnderstandingSuppressed, isXopcDatabaseOpen, linkUnderstandingEvidence, listActivityRecords, listCachedConnectorCatalogEntries, listCollaborationRules, listCompactionBoundaries, listComposerInputHistory, listConnectorAccounts, listConnectorActionMetadata, listConnectorApprovals, listConnectorConnections, listConnectorExecutionAudit, listConnectorInstallations, listConnectorLearningJobs, listConnectorSyncPolicies, listContextConsolidationDecisions, listContextConsolidationRuns, listEndpointPrincipals, listEndpointToolInvocationAudits, listKnowledgeSourceChanges, listKnowledgeSourceItems, listKnowledgeSyncRuns, listMemoryEvidence, listMemoryRecords, listMemorySignals, listMemoryTraceEvents, listNoteRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, listRegisteredMigrationTargets, listSessionMetadata, listSessionsByAgent, listUnderstandingEvidence, listUnderstandings, loadCompactionSourceSnapshot, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRows, loadTranscriptRowsForSession, markMemoryRecordsConflicted, metadataToSessionInsert, mutateQueuedSessionInput, openXopcDatabase, paginateTranscriptMessages, patchSessionMetadata, pruneBoundedKnowledgeSourceItems, readSchemaVersion, readSchemaVersionForTest, reconcileConnectorAccount, recordActivityEvent, recordContextConsolidationDecision, recordContextFeedback, recordContextRun, recoverSessionInputState, recoverStaleConnectorLearningJobs, refreshConnectorAccountCurrent, rejectUnderstanding, releaseConnectorWebhookDelivery, replaceConnectorCatalogEntries, replaceLatestSessionTurnAndQueueInput, replaceTranscriptRows, requireXopcDatabase, resetSessionRecord, resetXopcDatabaseSingletonForTest, resolveMigrationsDir, resolveSessionAgentId, resolveXopcDatabasePath, restoreBeforeCompactionBoundary, reviseCollaborationRule, reviseUnderstanding, revokeEndpointPrincipal, runSqliteWriteTransaction, searchActiveUnderstandings, searchMemoryRecords, searchSessionTranscript, sessionConfigRowToConfig, sessionRowToMetadata, setCollaborationRuleStatus, setConnectorLearningPaused, setInteractionState, setKnowledgeConsumerWatermark, setKnowledgeSourceCursor, setKnowledgeSourceItemSynthesisStatus, setMemoryProviderState, setMemoryRecordStatus, setMemoryTurnFeedback, setSessionConfig, setSessionInputStatus, setSessionTaskPlan, setUnderstandingStatus, setUserTrustPolicy, startContextConsolidationRun, startEndpointToolInvocationAudit, startKnowledgeSyncRun, summarizeMemoryRecallFeedback, summarizeUnderstandingFeedback, summarizeUserUnderstandingQuality, touchEndpointPrincipal, transcriptEntryRowToStoredRow, updateConnectorLearningJob, updateInteractionStateFromMessage, updateRelationshipSettings, updateSessionConfig, updateSessionStats, updateUserProfile, upsertConnectorActionMetadata, upsertConnectorCatalogEntry, upsertConnectorConnection, upsertConnectorInstallation, upsertConnectorSyncPolicy, upsertKnowledgeSourceItems, upsertMemoryRecord, upsertNoteAgentContextRecord, upsertNoteRecord, validateLatestSessionTurnTarget };
+export { COMPOSER_INPUT_HISTORY_LIMIT, DatabaseSchemaMigrationGapError, DatabaseSchemaTooNewError, SCHEMA_META_SCHEMA_VERSION_KEY, XOPC_DB_BASELINE_SCHEMA_VERSION, XOPC_DB_FILENAME, XOPC_DB_SCHEMA_VERSION, acknowledgeHomeAttention, appendCompactionBoundaryIfUnchanged, appendComposerInputHistory, appendConnectorExecutionAudit, appendMemorySignal, appendMemoryTraceEvent, appendTranscriptEntry, applyPendingMigrations, attachMemoryEvidence, bindEndpointPrincipal, buildDefaultSessionMetadata, buildGlobalSessionStats, buildRelationshipPrompt, cancelQueuedSessionInput, claimConnectorWebhookDelivery, claimContextExtractionRun, claimKnowledgeSourceItems, claimNextConnectorLearningJob, claimNextSessionInput, classifyStoredRow, clearComposerInputHistory, closeTemporalAssertions, closeUnderstandingValidity, closeXopcDatabase, completeConnectorWebhookDelivery, completeKnowledgeSourceItemSynthesis, consumeConnectorApproval, consumeContextConsent, createCollaborationRule, createConnectorApproval, createContextEvidence, createEndpointPrincipal, createObjectLinkRecord, createTemporalAssertion, createUnderstanding, decideConnectorApproval, decideContextConsent, deleteCollaborationRule, deleteConnectorConnection, deleteConnectorInstallation, deleteMemoryEvidenceForRecord, deleteMemoryRecord, deleteNoteAgentContextRecord, deleteNoteRecord, deleteObjectLinkRecord, deleteSessionConfig, deleteSessionRecord, deleteUnderstanding, discoverSqlMigrations, enqueueConnectorLearningJob, ensureContextConsent, ensureSessionRecord, ensureXopcDatabaseSchema, estimateTokensFromMessages, extractFtsContent, findSessionInput, findSessionKeyBySessionId, finishContextConsolidationRun, finishContextExtractionRun, finishEndpointToolInvocationAudit, finishKnowledgeSyncRun, finishSessionInputRun, getActivityEventRecord, getCachedConnectorCatalogEntry, getCollaborationRule, getConnectorAccount, getConnectorApproval, getConnectorConnection, getConnectorInstallation, getConnectorSyncPolicy, getConnectorSyncPolicyForConnection, getContextConsolidationRun, getContextExtractionRun, getCurrentSessionId, getEndpointPrincipal, getGlobalSessionStats, getInteractionState, getKnowledgeConsumerWatermark, getKnowledgeSourceCursor, getKnowledgeSourceItem, getMemoryProviderState, getMemoryRecord, getMemoryTurnFeedback, getNoteAgentContextRecord, getNoteRecord, getRelationshipSettings, getSessionConfig, getSessionInputById, getSessionInputState, getSessionMetadata, getSessionPersistedLevels, getSessionTaskPlan, getSqliteDatabase, getTurnPersonalization, getUnderstanding, getUserProfile, getUserTrustPolicy, getXopcDatabase, hasContextConsent, hasIndependentExtractionOutput, hasSessionConfig, hasUnresolvedMemoryConflict, incrementSessionStatsOnAppend, insertSessionInput, inspectSchemaMigrationStatus, isHomeAttentionAcknowledged, isProactiveSupportAllowed, isUnderstandingSuppressed, isXopcDatabaseOpen, linkContextObjects, linkUnderstandingEvidence, listActivityRecords, listCachedConnectorCatalogEntries, listCollaborationRules, listCompactionBoundaries, listComposerInputHistory, listConnectorAccounts, listConnectorActionMetadata, listConnectorApprovals, listConnectorConnections, listConnectorExecutionAudit, listConnectorInstallations, listConnectorLearningJobs, listConnectorSyncPolicies, listContextConsolidationDecisions, listContextConsolidationRuns, listContextExtractionOutputs, listContextExtractionRuns, listContextObjectRelations, listEndpointPrincipals, listEndpointToolInvocationAudits, listKnowledgeSourceChanges, listKnowledgeSourceItems, listKnowledgeSyncRuns, listMemoryEvidence, listMemoryRecords, listMemorySignals, listMemoryTraceEvents, listNoteRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, listRegisteredMigrationTargets, listSessionMetadata, listSessionsByAgent, listTemporalAssertions, listUnderstandingEvidence, listUnderstandings, loadCompactionSourceSnapshot, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRows, loadTranscriptRowsForSession, markMemoryRecordsConflicted, metadataToSessionInsert, mutateQueuedSessionInput, openXopcDatabase, paginateTranscriptMessages, patchSessionMetadata, pruneBoundedKnowledgeSourceItems, readSchemaVersion, readSchemaVersionForTest, reconcileConnectorAccount, recordActivityEvent, recordContextConsolidationDecision, recordContextFeedback, recordContextRun, recoverSessionInputState, recoverStaleConnectorLearningJobs, refreshConnectorAccountCurrent, rejectUnderstanding, releaseConnectorWebhookDelivery, replaceConnectorCatalogEntries, replaceLatestSessionTurnAndQueueInput, replaceTranscriptRows, requireXopcDatabase, resetSessionRecord, resetXopcDatabaseSingletonForTest, resolveMigrationsDir, resolveSessionAgentId, resolveXopcDatabasePath, restoreBeforeCompactionBoundary, reviseCollaborationRule, reviseUnderstanding, revokeEndpointPrincipal, runSqliteWriteTransaction, searchActiveUnderstandings, searchMemoryRecords, searchSessionTranscript, sessionConfigRowToConfig, sessionRowToMetadata, setCollaborationRuleStatus, setConnectorLearningPaused, setInteractionState, setKnowledgeConsumerWatermark, setKnowledgeSourceCursor, setKnowledgeSourceItemSynthesisStatus, setMemoryProviderState, setMemoryRecordStatus, setMemoryTurnFeedback, setSessionConfig, setSessionInputStatus, setSessionTaskPlan, setUnderstandingStatus, setUserTrustPolicy, startContextConsolidationRun, startEndpointToolInvocationAudit, startKnowledgeSyncRun, summarizeMemoryRecallFeedback, summarizeUnderstandingFeedback, summarizeUserUnderstandingQuality, touchEndpointPrincipal, transcriptEntryRowToStoredRow, updateConnectorLearningJob, updateInteractionStateFromMessage, updateRelationshipSettings, updateSessionConfig, updateSessionStats, updateUserProfile, upsertConnectorActionMetadata, upsertConnectorCatalogEntry, upsertConnectorConnection, upsertConnectorInstallation, upsertConnectorSyncPolicy, upsertKnowledgeSourceItems, upsertMemoryRecord, upsertNoteAgentContextRecord, upsertNoteRecord, validateLatestSessionTurnTarget };

package/dist/src/storage/sqlite/migrations/126_focus_context_governance.sql

@@ -0,0 +1,72 @@
+UPDATE understanding_source_grants
+SET processing_policy = 'local_only'
+WHERE adapter_id = 'local-work-folders'
+   OR source_key LIKE 'understanding-source:%';
+
+CREATE TABLE user_focuses_v126 (
+  focus_id TEXT PRIMARY KEY,
+  principal_id TEXT NOT NULL DEFAULT 'local-owner',
+  canonical_key TEXT NOT NULL UNIQUE,
+  title TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  horizon TEXT NOT NULL CHECK (horizon IN ('current', 'ongoing', 'long_term')),
+  status TEXT NOT NULL CHECK (status IN ('candidate', 'active', 'paused', 'completed', 'rejected')),
+  confidence REAL NOT NULL CHECK (confidence >= 0 AND confidence <= 1),
+  scope_type TEXT NOT NULL CHECK (scope_type IN ('global', 'workspace', 'project', 'session')),
+  scope_id TEXT,
+  explicitness TEXT NOT NULL CHECK (explicitness IN ('explicit', 'observed', 'inferred')),
+  sensitivity TEXT NOT NULL CHECK (sensitivity IN ('normal', 'personal', 'secret', 'regulated')),
+  disclosure_policy TEXT NOT NULL CHECK (disclosure_policy IN ('silent', 'referenceable', 'ask_before_reference')),
+  valid_from INTEGER,
+  valid_to INTEGER,
+  review_at INTEGER,
+  evidence_refs_json TEXT NOT NULL DEFAULT '[]',
+  source_run_id TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  FOREIGN KEY (source_run_id) REFERENCES understanding_source_runs(run_id) ON DELETE SET NULL,
+  CHECK ((scope_type = 'global' AND scope_id IS NULL) OR (scope_type <> 'global' AND scope_id IS NOT NULL))
+);
+
+INSERT INTO user_focuses_v126 (
+  focus_id, principal_id, canonical_key, title, summary, horizon, status, confidence,
+  scope_type, scope_id, explicitness, sensitivity, disclosure_policy,
+  evidence_refs_json, source_run_id, created_at, updated_at
+)
+SELECT
+  focus_id, 'local-owner', canonical_key, title, summary, horizon, status, confidence,
+  CASE WHEN project_id IS NULL THEN 'global' ELSE 'project' END,
+  project_id,
+  CASE WHEN status = 'candidate' THEN 'inferred' ELSE 'explicit' END,
+  'normal', 'referenceable', evidence_refs_json, source_run_id, created_at, updated_at
+FROM user_focuses;
+
+DROP TABLE user_focuses;
+ALTER TABLE user_focuses_v126 RENAME TO user_focuses;
+
+CREATE INDEX idx_user_focuses_status
+  ON user_focuses(principal_id, status, horizon, updated_at DESC);
+CREATE INDEX idx_user_focuses_scope
+  ON user_focuses(principal_id, scope_type, scope_id, status);
+
+CREATE TABLE context_run_items_v126 (
+  context_run_id TEXT NOT NULL REFERENCES context_runs(context_run_id) ON DELETE CASCADE,
+  object_type TEXT NOT NULL CHECK (object_type IN ('profile', 'rule', 'focus', 'understanding')),
+  object_id TEXT NOT NULL,
+  version_id TEXT,
+  decision TEXT NOT NULL CHECK (decision IN (
+    'selected', 'irrelevant', 'expired', 'scope_mismatch', 'sensitive',
+    'needs_consent', 'budget_exceeded', 'conflicted', 'disabled'
+  )),
+  reason TEXT NOT NULL,
+  content_snapshot TEXT NOT NULL,
+  source_label TEXT NOT NULL,
+  rank INTEGER,
+  score REAL,
+  injected_chars INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (context_run_id, object_type, object_id)
+);
+
+INSERT INTO context_run_items_v126 SELECT * FROM context_run_items;
+DROP TABLE context_run_items;
+ALTER TABLE context_run_items_v126 RENAME TO context_run_items;

package/dist/src/storage/sqlite/migrations/127_context_object_origin.sql

@@ -0,0 +1,36 @@
+ALTER TABLE context_run_items ADD COLUMN origin TEXT NOT NULL DEFAULT 'inferred'
+  CHECK (origin IN ('told_by_user', 'observed', 'inferred', 'connected_source'));
+
+UPDATE context_run_items SET origin = 'told_by_user' WHERE object_type IN ('profile', 'rule');
+UPDATE context_run_items SET origin = 'told_by_user'
+WHERE object_type = 'understanding' AND source_label = 'You told xopc';
+UPDATE context_run_items SET origin = 'observed'
+WHERE object_type = 'understanding' AND source_label = 'Observed across prior work';
+
+CREATE TABLE session_config_next (
+  session_key TEXT PRIMARY KEY,
+  thinking_level TEXT,
+  reasoning_level TEXT,
+  verbose_level TEXT,
+  elevated_mode TEXT,
+  model_override TEXT,
+  provider_override TEXT,
+  working_directory_override TEXT,
+  response_language TEXT,
+  user_context_mode TEXT CHECK (user_context_mode IN ('enabled', 'off', 'temporary')),
+  updated_at INTEGER NOT NULL,
+  FOREIGN KEY (session_key) REFERENCES sessions(session_key) ON DELETE CASCADE
+);
+
+INSERT INTO session_config_next (
+  session_key, thinking_level, reasoning_level, verbose_level, elevated_mode,
+  model_override, provider_override, working_directory_override, response_language,
+  user_context_mode, updated_at
+)
+SELECT session_key, thinking_level, reasoning_level, verbose_level, elevated_mode,
+  model_override, provider_override, working_directory_override, response_language,
+  user_context_mode, updated_at
+FROM session_config;
+
+DROP TABLE session_config;
+ALTER TABLE session_config_next RENAME TO session_config;

package/dist/src/storage/sqlite/migrations/128_context_extraction.sql

@@ -0,0 +1,73 @@
+CREATE TABLE context_extraction_runs (
+  extraction_run_id TEXT PRIMARY KEY,
+  principal_id TEXT NOT NULL,
+  source_ref TEXT NOT NULL,
+  extractor_id TEXT NOT NULL,
+  extractor_version TEXT NOT NULL,
+  processing_policy TEXT NOT NULL CHECK (processing_policy IN ('local_only', 'remote_allowed')),
+  destination TEXT NOT NULL CHECK (destination IN ('deterministic', 'local_model', 'remote_model')),
+  input_hash TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('running', 'completed', 'skipped', 'failed')),
+  error_code TEXT,
+  started_at INTEGER NOT NULL,
+  completed_at INTEGER,
+  UNIQUE (principal_id, source_ref, extractor_id, extractor_version)
+);
+
+CREATE INDEX idx_context_extraction_runs_lookup
+  ON context_extraction_runs(extractor_id, status, started_at DESC);
+
+CREATE TABLE context_extraction_outputs (
+  output_id TEXT PRIMARY KEY,
+  extraction_run_id TEXT NOT NULL REFERENCES context_extraction_runs(extraction_run_id) ON DELETE CASCADE,
+  ordinal INTEGER NOT NULL,
+  candidate_key TEXT NOT NULL,
+  object_type TEXT CHECK (object_type IN ('profile', 'rule', 'focus', 'understanding')),
+  object_id TEXT,
+  version_id TEXT,
+  outcome TEXT NOT NULL CHECK (outcome IN ('created', 'deduplicated', 'rejected')),
+  created_at INTEGER NOT NULL,
+  UNIQUE (extraction_run_id, ordinal)
+);
+
+CREATE INDEX idx_context_extraction_outputs_object
+  ON context_extraction_outputs(object_type, object_id);
+
+CREATE TABLE context_object_relations (
+  relation_id TEXT PRIMARY KEY,
+  subject_type TEXT NOT NULL CHECK (subject_type IN ('profile', 'rule', 'focus', 'understanding')),
+  subject_id TEXT NOT NULL,
+  subject_version_id TEXT,
+  predicate TEXT NOT NULL CHECK (predicate IN ('supersedes', 'supports', 'contradicts', 'related_to')),
+  object_type TEXT NOT NULL CHECK (object_type IN ('profile', 'rule', 'focus', 'understanding')),
+  object_id TEXT NOT NULL,
+  object_version_id TEXT,
+  factual INTEGER NOT NULL DEFAULT 1 CHECK (factual IN (0, 1)),
+  extraction_run_id TEXT REFERENCES context_extraction_runs(extraction_run_id) ON DELETE SET NULL,
+  created_at INTEGER NOT NULL
+);
+
+CREATE UNIQUE INDEX idx_context_object_relations_unique
+  ON context_object_relations(
+    subject_type, subject_id, COALESCE(subject_version_id, ''), predicate,
+    object_type, object_id, COALESCE(object_version_id, '')
+  );
+
+CREATE TABLE context_temporal_assertions (
+  assertion_id TEXT PRIMARY KEY,
+  object_type TEXT NOT NULL CHECK (object_type IN ('focus', 'understanding')),
+  object_id TEXT NOT NULL,
+  object_version_id TEXT,
+  assertion_type TEXT NOT NULL CHECK (assertion_type IN ('current_state', 'routine', 'relationship', 'project_status')),
+  value_json TEXT NOT NULL,
+  confidence REAL NOT NULL CHECK (confidence >= 0 AND confidence <= 1),
+  valid_from INTEGER,
+  valid_to INTEGER,
+  status TEXT NOT NULL CHECK (status IN ('candidate', 'active', 'closed', 'rejected')),
+  extraction_run_id TEXT REFERENCES context_extraction_runs(extraction_run_id) ON DELETE SET NULL,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE INDEX idx_context_temporal_assertions_active
+  ON context_temporal_assertions(object_type, object_id, assertion_type, status);

package/dist/src/storage/sqlite/migrations/129_focus_versions.sql

@@ -0,0 +1,51 @@
+ALTER TABLE user_focuses ADD COLUMN current_version_id TEXT;
+
+CREATE TABLE user_focus_versions (
+  version_id TEXT PRIMARY KEY,
+  focus_id TEXT NOT NULL REFERENCES user_focuses(focus_id) ON DELETE CASCADE,
+  title TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  snapshot_json TEXT NOT NULL,
+  created_by TEXT NOT NULL CHECK (created_by IN ('user', 'runtime', 'connector')),
+  change_reason TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+);
+
+INSERT INTO user_focus_versions (
+  version_id, focus_id, title, summary, snapshot_json, created_by, change_reason, created_at
+)
+SELECT
+  lower(hex(randomblob(16))), focus_id, title, summary,
+  json_object(
+    'horizon', horizon, 'status', status, 'confidence', confidence,
+    'scopeType', scope_type, 'scopeId', scope_id, 'explicitness', explicitness,
+    'sensitivity', sensitivity, 'disclosurePolicy', disclosure_policy,
+    'validFrom', valid_from, 'validTo', valid_to, 'reviewAt', review_at,
+    'evidenceRefs', json(evidence_refs_json)
+  ),
+  CASE WHEN explicitness = 'explicit' THEN 'user' ELSE 'runtime' END,
+  'Migrated existing focus', created_at
+FROM user_focuses;
+
+UPDATE user_focuses
+SET current_version_id = (
+  SELECT version_id FROM user_focus_versions v WHERE v.focus_id = user_focuses.focus_id LIMIT 1
+);
+
+CREATE INDEX idx_user_focus_versions_focus
+  ON user_focus_versions(focus_id, created_at DESC);
+
+CREATE TABLE user_focus_evidence_links (
+  version_id TEXT NOT NULL REFERENCES user_focus_versions(version_id) ON DELETE CASCADE,
+  evidence_id TEXT NOT NULL REFERENCES context_evidence(evidence_id) ON DELETE CASCADE,
+  relation TEXT NOT NULL CHECK (relation IN ('supports', 'contradicts', 'supersedes')),
+  confidence REAL NOT NULL CHECK (confidence >= 0 AND confidence <= 1),
+  PRIMARY KEY (version_id, evidence_id, relation)
+);
+
+INSERT OR IGNORE INTO user_focus_evidence_links (version_id, evidence_id, relation, confidence)
+SELECT f.current_version_id, e.evidence_id, 'supports', f.confidence
+FROM user_focuses f
+JOIN json_each(f.evidence_refs_json) refs
+JOIN context_evidence e ON e.source_ref = refs.value
+WHERE f.current_version_id IS NOT NULL;

package/dist/src/storage/sqlite/migrations/130_context_evidence_provenance.sql

@@ -0,0 +1,18 @@
+ALTER TABLE context_evidence ADD COLUMN source_run_id TEXT;
+ALTER TABLE context_evidence ADD COLUMN source_item_id TEXT;
+ALTER TABLE context_evidence ADD COLUMN session_id TEXT;
+ALTER TABLE context_evidence ADD COLUMN turn_id TEXT;
+ALTER TABLE context_evidence ADD COLUMN message_id TEXT;
+ALTER TABLE context_evidence ADD COLUMN content_hash TEXT;
+ALTER TABLE context_evidence ADD COLUMN retention_policy TEXT;
+ALTER TABLE context_evidence ADD COLUMN processing_policy TEXT;
+ALTER TABLE context_evidence ADD COLUMN extractor_id TEXT;
+ALTER TABLE context_evidence ADD COLUMN extractor_version TEXT;
+ALTER TABLE context_evidence ADD COLUMN ingested_at INTEGER;
+
+UPDATE context_evidence SET ingested_at = created_at WHERE ingested_at IS NULL;
+
+CREATE INDEX idx_context_evidence_run
+  ON context_evidence(source_run_id, observed_at DESC);
+CREATE INDEX idx_context_evidence_message
+  ON context_evidence(session_id, turn_id, message_id);

package/dist/src/storage/sqlite/migrations/131_session_input_contexts.sql

@@ -0,0 +1,2 @@
+ALTER TABLE session_inputs ADD COLUMN context_refs_json TEXT;
+ALTER TABLE session_inputs ADD COLUMN context_snapshots_json TEXT;

package/dist/src/storage/sqlite/migrations/132_transcript_source_context_metadata.sql

@@ -0,0 +1,34 @@
+UPDATE transcript_entries AS entry
+SET payload_json = json_set(
+  entry.payload_json,
+  '$.metadata.sourceContexts',
+  json((
+    SELECT input.context_refs_json
+    FROM session_inputs AS input
+    JOIN transcripts AS transcript
+      ON transcript.session_id = entry.session_id
+     AND transcript.session_key = input.session_key
+    WHERE input.run_id = json_extract(entry.payload_json, '$.turnId')
+      AND input.context_refs_json IS NOT NULL
+      AND json_valid(input.context_refs_json)
+      AND json_type(input.context_refs_json) = 'array'
+    LIMIT 1
+  ))
+)
+WHERE entry.role = 'user'
+  AND json_type(entry.payload_json, '$.metadata.sourceContexts') IS NULL
+  AND (
+    json_type(entry.payload_json, '$.metadata') IS NULL
+    OR json_type(entry.payload_json, '$.metadata') = 'object'
+  )
+  AND EXISTS (
+    SELECT 1
+    FROM session_inputs AS input
+    JOIN transcripts AS transcript
+      ON transcript.session_id = entry.session_id
+     AND transcript.session_key = input.session_key
+    WHERE input.run_id = json_extract(entry.payload_json, '$.turnId')
+      AND input.context_refs_json IS NOT NULL
+      AND json_valid(input.context_refs_json)
+      AND json_type(input.context_refs_json) = 'array'
+  );

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 125;
+export declare const XOPC_DB_SCHEMA_VERSION = 132;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.