@xopcai/xopc 0.0.248 → 0.0.249

package/dist/src/storage/sqlite/connection-wait-repository.d.ts

@@ -0,0 +1,30 @@
+import type { ConnectionCheckpoint, ConnectionNeed, ConnectionWait } from '@xopcai/gateway-contract';
+import { type SessionInput } from './session-input-repository.js';
+export declare function onConnectionWaitChanged(listener: (sessionKey: string) => void): () => void;
+export declare function publishConnectionWait(sessionKey: string): void;
+export declare function getConnectionWait(id: string): ConnectionWait | undefined;
+export declare function getActiveConnectionWait(sessionKey: string): ConnectionWait | undefined;
+export declare function isConnectionSuspended(sessionKey: string, runId: string): boolean;
+export declare function updateConnectionWait(wait: ConnectionWait, expectedVersion: number): ConnectionWait;
+export declare function requireSessionConnection(input: {
+    sessionKey: string;
+    principalId: string;
+    agentId: string;
+    summary: string;
+    needs: ConnectionNeed[];
+    checkpoint?: Omit<ConnectionCheckpoint, 'entryId'>;
+}): {
+    status: 'connection_required' | 'skipped' | 'objective_conflict';
+    waitId?: string;
+};
+/** The input and the wait transition commit together, using the existing queue's unique key. */
+export declare function queueConnectionResolution(wait: ConnectionWait, resolution: 'continued' | 'skipped'): ConnectionWait;
+export declare function consumeConnectionResume(input: SessionInput): boolean;
+export declare function connectionBindings(sessionKey: string): ConnectionNeed[];
+export declare function connectionBinding(sessionKey: string, connectorId: string): string | undefined;
+/** New input wins over an outstanding auto-resume intent, including an already queued resume. */
+export declare function invalidateConnectionResumeIntent(sessionKey: string): void;
+export declare function reviseCurrentConnectionObjective(sessionKey: string, summary: string | undefined): void;
+export declare function cancelConnectionObjective(sessionKey: string): void;
+export declare function getConnectionResumeInput(sessionKey: string, runId: string): SessionInput | undefined;
+export declare function listConnectionWaitsToCheck(): ConnectionWait[];

package/dist/src/storage/sqlite/connection-wait-repository.js

@@ -0,0 +1,338 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { isXopcDatabaseOpen } from "./connection.js";
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { TaskRunRepository } from "../../tasks/task-run-repository.js";
+import { readCurrentSessionId } from "./session-repository.js";
+import { bumpSessionInputRevision, getSessionInputById, getSessionInputState, insertSessionInput, setSessionInputStatus } from "./session-input-repository.js";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+//#region src/storage/sqlite/connection-wait-repository.ts
+init_logger();
+const log = createLogger("Connectors:Wait");
+const events = new EventEmitter();
+function onConnectionWaitChanged(listener) {
+	events.on("changed", listener);
+	return () => {
+		events.off("changed", listener);
+	};
+}
+function publishConnectionWait(sessionKey) {
+	events.emit("changed", sessionKey);
+}
+function getConnectionWait(id) {
+	if (!isXopcDatabaseOpen()) return void 0;
+	const row = getSqliteDatabase().prepare("SELECT data_json FROM session_connection_waits WHERE id = ?").get(id);
+	return row ? JSON.parse(row.data_json) : void 0;
+}
+function getActiveConnectionWait(sessionKey) {
+	if (!isXopcDatabaseOpen()) return void 0;
+	const db = getSqliteDatabase();
+	const row = db.prepare(`SELECT data_json FROM session_connection_waits WHERE session_key = ? AND session_id = ?
+    AND status IN ('open','queued')`).get(sessionKey, readCurrentSessionId(db, sessionKey) ?? "");
+	return row ? JSON.parse(row.data_json) : void 0;
+}
+function isConnectionSuspended(sessionKey, runId) {
+	const wait = getActiveConnectionWait(sessionKey);
+	return Boolean(wait && wait.originRunId === runId);
+}
+function updateConnectionWait(wait, expectedVersion) {
+	return runSqliteWriteTransaction((db) => {
+		if (readCurrentSessionId(db, wait.sessionKey) !== wait.sessionId) throw new Error("SESSION_CHANGED");
+		const next = {
+			...wait,
+			version: expectedVersion + 1,
+			updatedAt: Date.now()
+		};
+		if (!db.prepare(`UPDATE session_connection_waits SET status = ?, version = ?, data_json = ? WHERE id = ? AND version = ?`).run(next.status, next.version, JSON.stringify(next), next.id, expectedVersion).changes) throw new Error("WAIT_CHANGED");
+		bumpSessionInputRevision(db, wait.sessionKey);
+		return next;
+	});
+}
+function requireSessionConnection(input) {
+	return runSqliteWriteTransaction((db) => {
+		const sessionId = readCurrentSessionId(db, input.sessionKey);
+		const runtime = getSessionInputState(input.sessionKey);
+		const origin = runtime.activeInputId ? getSessionInputById(input.sessionKey, runtime.activeInputId) : void 0;
+		if (!sessionId || !origin || !runtime.activeRunId) throw new Error("Connection recovery requires a queued chat execution.");
+		const resumed = origin.payload ? getConnectionWait(origin.payload.waitId) : void 0;
+		if (resumed?.resolution === "skipped") return { status: "skipped" };
+		const active = getActiveConnectionWait(input.sessionKey);
+		if (active) {
+			if (active.originInputId !== origin.id && active.objectiveId !== resumed?.objectiveId) return {
+				status: "objective_conflict",
+				waitId: active.id
+			};
+			const needs = new Map(active.needs.map((need) => [need.key, need]));
+			for (const need of input.needs) {
+				const previous = needs.get(need.key);
+				needs.set(need.key, previous ? {
+					...previous,
+					capabilities: [...new Set([...previous.capabilities, ...need.capabilities])]
+				} : need);
+			}
+			if (JSON.stringify([...needs.values()]) !== JSON.stringify(active.needs)) updateConnectionWait({
+				...active,
+				needs: [...needs.values()]
+			}, active.version);
+			return {
+				status: "connection_required",
+				waitId: active.id
+			};
+		}
+		const lastEntry = db.prepare("SELECT entry_id FROM transcript_entries WHERE session_id = ? ORDER BY seq DESC LIMIT 1").get(sessionId);
+		const wait = {
+			...input,
+			needs: [...new Map(input.needs.map((need) => [need.key, need])).values()],
+			id: randomUUID(),
+			sessionId,
+			objectiveId: resumed?.objectiveId ?? origin.id,
+			objectiveRevision: (resumed?.objectiveRevision ?? 0) + 1,
+			objectiveUpdatedAt: resumed?.objectiveUpdatedAt ?? origin.createdAtMs,
+			originInputId: origin.id,
+			originRunId: runtime.activeRunId,
+			taskRunId: origin.taskRunId,
+			checkpoint: {
+				entryId: lastEntry?.entry_id,
+				completedSteps: input.checkpoint?.completedSteps ?? [],
+				pendingSteps: input.checkpoint?.pendingSteps ?? [input.summary],
+				timeRange: input.checkpoint?.timeRange ?? resumed?.checkpoint.timeRange
+			},
+			summary: resumed?.summary ?? origin.content,
+			status: "open",
+			version: 1,
+			createdAt: Date.now(),
+			updatedAt: Date.now()
+		};
+		db.prepare(`INSERT INTO session_connection_waits(id,principal_id,session_key,session_id,status,version,data_json) VALUES (?,?,?,?,?,?,?)`).run(wait.id, wait.principalId, wait.sessionKey, wait.sessionId, wait.status, wait.version, JSON.stringify(wait));
+		if (wait.taskRunId) {
+			const runs = new TaskRunRepository();
+			const run = runs.get(wait.taskRunId);
+			if (run) {
+				runs.createWait({
+					taskId: run.taskId,
+					taskRunId: run.id,
+					kind: "user_input",
+					reason: input.summary,
+					condition: {
+						type: "connection",
+						connectionWaitId: wait.id
+					}
+				});
+				runs.setStatus({
+					runId: run.id,
+					expectedVersion: run.version,
+					from: [run.status],
+					to: "waiting",
+					actor: { kind: "system" }
+				});
+			}
+		}
+		bumpSessionInputRevision(db, wait.sessionKey);
+		log.info({
+			sessionKey: wait.sessionKey,
+			waitId: wait.id,
+			objectiveRevision: wait.objectiveRevision,
+			runId: wait.originRunId,
+			phase: "waiting"
+		}, "Connection requirement saved");
+		return {
+			status: "connection_required",
+			waitId: wait.id
+		};
+	});
+}
+/** The input and the wait transition commit together, using the existing queue's unique key. */
+function queueConnectionResolution(wait, resolution) {
+	return runSqliteWriteTransaction(() => {
+		const current = getConnectionWait(wait.id);
+		if (!current || current.version !== wait.version || current.status !== "open") throw new Error("WAIT_CHANGED");
+		const origin = getSessionInputById(wait.sessionKey, wait.originInputId);
+		if (!origin) throw new Error("Original input is unavailable.");
+		const input = insertSessionInput({
+			id: randomUUID(),
+			sessionKey: wait.sessionKey,
+			expectedSessionId: wait.sessionId,
+			clientMessageId: `connection:${wait.id}:${wait.objectiveRevision}:${resolution}`,
+			requestedDelivery: "next",
+			effectiveDelivery: "next",
+			status: "queued",
+			content: resolution === "skipped" ? `The user skipped the requested connection. Continue this objective using only available information: ${wait.summary}. Do not request these connections again or claim to have read their data.` : `Recovery checkpoint: ${JSON.stringify(wait.checkpoint)}. The user chose to continue the request originally made at ${new Date(wait.objectiveUpdatedAt).toISOString()}: ${wait.summary}. Interpret relative dates against that original request time, unless the user explicitly changed them. The connection requirement has been checked. Search and describe tools again before using them. Use the explicitly selected account. Do not repeat already completed actions.`,
+			origin: {
+				type: "system",
+				source: "internal"
+			},
+			thinking: origin.thinking,
+			contextRefs: origin.contextRefs,
+			contextSnapshots: origin.contextSnapshots,
+			kind: "connection_resume",
+			taskRunId: wait.taskRunId,
+			payload: {
+				waitId: wait.id,
+				objectiveRevision: wait.objectiveRevision,
+				resolution
+			}
+		});
+		return updateConnectionWait({
+			...wait,
+			status: "queued",
+			resolution,
+			queuedInputId: input.id
+		}, wait.version);
+	});
+}
+function consumeConnectionResume(input) {
+	if (input.kind !== "connection_resume") return true;
+	return runSqliteWriteTransaction(() => {
+		const wait = input.payload ? getConnectionWait(input.payload.waitId) : void 0;
+		if (!wait || wait.status !== "queued" || wait.queuedInputId !== input.id || wait.objectiveRevision !== input.payload?.objectiveRevision) return false;
+		if (readCurrentSessionId(getSqliteDatabase(), input.sessionKey) !== wait.sessionId) return false;
+		if (wait.taskRunId) {
+			const runs = new TaskRunRepository();
+			const run = runs.get(wait.taskRunId);
+			if (!run || run.status !== "waiting") return false;
+			const taskWaits = runs.listActiveWaits(run.taskId);
+			if (taskWaits.some((item) => item.taskRunId === run.id && item.condition.connectionWaitId !== wait.id)) {
+				updateConnectionWait({
+					...wait,
+					status: "open",
+					intent: void 0,
+					queuedInputId: void 0,
+					objectiveRevision: wait.objectiveRevision + 1
+				}, wait.version);
+				return false;
+			}
+			for (const taskWait of taskWaits) if (taskWait.condition.connectionWaitId === wait.id) runs.resolveWait({
+				waitId: taskWait.id,
+				actor: { kind: "system" },
+				resolution: { connectionWaitId: wait.id }
+			});
+			runs.setStatus({
+				runId: run.id,
+				expectedVersion: run.version,
+				from: ["waiting"],
+				to: "running",
+				actor: { kind: "system" }
+			});
+		}
+		updateConnectionWait({
+			...wait,
+			status: "closed"
+		}, wait.version);
+		return true;
+	});
+}
+function connectionBindings(sessionKey) {
+	if (!isXopcDatabaseOpen()) return [];
+	const state = getSessionInputState(sessionKey);
+	const input = state.activeInputId ? getSessionInputById(sessionKey, state.activeInputId) : void 0;
+	return input?.payload ? getConnectionWait(input.payload.waitId)?.needs ?? [] : [];
+}
+function connectionBinding(sessionKey, connectorId) {
+	const matches = connectionBindings(sessionKey).filter((need) => need.connectorId === connectorId);
+	return matches.length === 1 ? matches[0].connectionId : void 0;
+}
+/** New input wins over an outstanding auto-resume intent, including an already queued resume. */
+function invalidateConnectionResumeIntent(sessionKey) {
+	const wait = getActiveConnectionWait(sessionKey);
+	if (!wait) return;
+	runSqliteWriteTransaction(() => {
+		if (wait.queuedInputId) setSessionInputStatus(wait.queuedInputId, "cancelled");
+		updateConnectionWait({
+			...wait,
+			status: "open",
+			intent: void 0,
+			queuedInputId: void 0,
+			objectiveRevision: wait.objectiveRevision + 1,
+			scopeConfirmedAt: void 0,
+			reviewRequired: true
+		}, wait.version);
+	});
+	publishConnectionWait(sessionKey);
+}
+function reviseCurrentConnectionObjective(sessionKey, summary) {
+	const wait = getActiveConnectionWait(sessionKey);
+	if (!wait) throw new Error("No connection objective is waiting.");
+	if (!summary) {
+		cancelConnectionObjective(sessionKey);
+		return;
+	}
+	runSqliteWriteTransaction(() => {
+		if (wait.queuedInputId) setSessionInputStatus(wait.queuedInputId, "cancelled");
+		updateConnectionWait({
+			...wait,
+			summary,
+			objectiveUpdatedAt: Date.now(),
+			checkpoint: {
+				...wait.checkpoint,
+				pendingSteps: [summary],
+				timeRange: void 0
+			},
+			status: "open",
+			resolution: void 0,
+			intent: void 0,
+			queuedInputId: void 0,
+			scopeConfirmedAt: void 0,
+			reviewRequired: true,
+			objectiveRevision: wait.objectiveRevision + 1
+		}, wait.version);
+	});
+	publishConnectionWait(sessionKey);
+}
+function cancelConnectionObjective(sessionKey) {
+	const wait = getActiveConnectionWait(sessionKey);
+	if (!wait) return;
+	runSqliteWriteTransaction(() => {
+		if (wait.queuedInputId) setSessionInputStatus(wait.queuedInputId, "cancelled");
+		if (wait.taskRunId) {
+			const runs = new TaskRunRepository();
+			const run = runs.get(wait.taskRunId);
+			if (run?.status === "waiting") {
+				for (const taskWait of runs.listActiveWaits(run.taskId)) if (taskWait.condition.connectionWaitId === wait.id) runs.resolveWait({
+					waitId: taskWait.id,
+					actor: { kind: "system" },
+					resolution: { cancelled: true }
+				});
+				runs.finalize({
+					runId: run.id,
+					expectedVersion: run.version,
+					receipt: {
+						status: "cancelled",
+						summary: "Connection objective cancelled",
+						changes: [],
+						evidence: [],
+						verification: {
+							status: "unverified",
+							checks: []
+						},
+						remainingWork: [],
+						needsUser: false,
+						completionVerdict: "not_achieved"
+					}
+				});
+			}
+		}
+		updateConnectionWait({
+			...wait,
+			status: "closed",
+			resolution: "cancelled",
+			intent: void 0
+		}, wait.version);
+	});
+	publishConnectionWait(sessionKey);
+}
+function getConnectionResumeInput(sessionKey, runId) {
+	if (!isXopcDatabaseOpen()) return void 0;
+	const state = getSessionInputState(sessionKey);
+	if (state.activeRunId !== runId || !state.activeInputId) return void 0;
+	const input = getSessionInputById(sessionKey, state.activeInputId);
+	return input?.kind === "connection_resume" ? input : void 0;
+}
+function listConnectionWaitsToCheck() {
+	if (!isXopcDatabaseOpen()) return [];
+	return getSqliteDatabase().prepare(`SELECT wait.data_json FROM session_connection_waits wait
+    JOIN sessions session ON session.session_id = wait.session_id
+    WHERE wait.status = 'open'`).all().map((row) => JSON.parse(row.data_json)).filter((wait) => wait.principalId === "local-owner" && wait.intent && wait.intent.validUntil > Date.now());
+}
+//#endregion
+export { cancelConnectionObjective, connectionBinding, connectionBindings, consumeConnectionResume, getActiveConnectionWait, getConnectionResumeInput, getConnectionWait, invalidateConnectionResumeIntent, isConnectionSuspended, listConnectionWaitsToCheck, onConnectionWaitChanged, publishConnectionWait, queueConnectionResolution, requireSessionConnection, reviseCurrentConnectionObjective, updateConnectionWait };

package/dist/src/storage/sqlite/connector-account-repository.js

@@ -59,7 +59,7 @@ function mergeAccountSourceData(db, connectorId, sourceAccountId, targetAccountI
   `).run(targetId, sourceId);
 	db.prepare("DELETE FROM knowledge_consumer_watermarks WHERE source_instance_id = ?").run(sourceId);
 	db.prepare(`
-    UPDATE memory_records
+    UPDATE knowledge_items
     SET source_json = json_set(source_json, '$.sourceInstanceId', ?)
     WHERE json_extract(source_json, '$.sourceInstanceId') = ?
   `).run(targetId, sourceId);

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

@@ -0,0 +1,24 @@
+export interface ContextEvidence {
+    id: string;
+    sourceType: 'conversation' | 'connector' | 'user' | 'runtime';
+    sourceInstanceId?: string;
+    sourceRef: string;
+    sourceRunId?: string;
+    sourceItemId?: string;
+    sessionId?: string;
+    turnId?: string;
+    messageId?: string;
+    contentHash?: string;
+    retentionPolicy?: string;
+    processingPolicy?: 'local_only' | 'remote_allowed';
+    extractorId?: string;
+    extractorVersion?: string;
+    redactedExcerpt?: string;
+    trustLevel: 'owner' | 'trusted' | 'untrusted';
+    observedAt: number;
+    ingestedAt: number;
+    createdAt: number;
+}
+export declare function createContextEvidence(input: Omit<ContextEvidence, 'id' | 'ingestedAt' | 'createdAt'> & {
+    ingestedAt?: number;
+}, principalId?: string): ContextEvidence;

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

@@ -0,0 +1,52 @@
+import { getSqliteDatabase } from "./transaction.js";
+import { USER_MODEL_PRINCIPAL_ID } from "../../user-model/domain.js";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/storage/sqlite/context-evidence-repository.ts
+function fromRow(row) {
+	return {
+		id: row.evidence_id,
+		sourceType: row.source_type,
+		...row.source_instance_id ? { sourceInstanceId: row.source_instance_id } : {},
+		sourceRef: row.source_ref,
+		...row.source_run_id ? { sourceRunId: row.source_run_id } : {},
+		...row.source_item_id ? { sourceItemId: row.source_item_id } : {},
+		...row.session_id ? { sessionId: row.session_id } : {},
+		...row.turn_id ? { turnId: row.turn_id } : {},
+		...row.message_id ? { messageId: row.message_id } : {},
+		...row.content_hash ? { contentHash: row.content_hash } : {},
+		...row.retention_policy ? { retentionPolicy: row.retention_policy } : {},
+		...row.processing_policy ? { processingPolicy: row.processing_policy } : {},
+		...row.extractor_id ? { extractorId: row.extractor_id } : {},
+		...row.extractor_version ? { extractorVersion: row.extractor_version } : {},
+		...row.redacted_excerpt ? { redactedExcerpt: row.redacted_excerpt } : {},
+		trustLevel: row.trust_level,
+		observedAt: row.observed_at,
+		ingestedAt: row.ingested_at ?? row.created_at,
+		createdAt: row.created_at
+	};
+}
+function createContextEvidence(input, principalId = USER_MODEL_PRINCIPAL_ID) {
+	const db = getSqliteDatabase();
+	const existing = db.prepare(`SELECT * FROM context_evidence WHERE principal_id = ?
+    AND source_type = ? AND COALESCE(source_instance_id, '') = COALESCE(?, '') AND source_ref = ?`).get(principalId, input.sourceType, input.sourceInstanceId ?? null, input.sourceRef);
+	const contentHash = input.contentHash ?? (input.redactedExcerpt ? createHash("sha256").update(input.redactedExcerpt).digest("hex") : void 0);
+	if (existing) {
+		db.prepare(`UPDATE context_evidence SET
+      source_run_id = ?, source_item_id = ?, session_id = ?, turn_id = ?, message_id = ?,
+      content_hash = ?, retention_policy = ?, processing_policy = ?, extractor_id = ?,
+      extractor_version = ?, redacted_excerpt = ?, trust_level = ?, observed_at = ?, ingested_at = ?
+      WHERE evidence_id = ?`).run(input.sourceRunId ?? null, input.sourceItemId ?? null, input.sessionId ?? null, input.turnId ?? null, input.messageId ?? null, contentHash ?? null, input.retentionPolicy ?? null, input.processingPolicy ?? null, input.extractorId ?? null, input.extractorVersion ?? null, input.redactedExcerpt ?? null, input.trustLevel, input.observedAt, input.ingestedAt ?? Date.now(), existing.evidence_id);
+		return fromRow(db.prepare("SELECT * FROM context_evidence WHERE evidence_id = ?").get(existing.evidence_id));
+	}
+	const createdAt = Date.now();
+	const id = randomUUID();
+	db.prepare(`INSERT INTO context_evidence (
+    evidence_id, principal_id, source_type, source_instance_id, source_ref, source_run_id,
+    source_item_id, session_id, turn_id, message_id, content_hash, retention_policy,
+    processing_policy, extractor_id, extractor_version, redacted_excerpt, trust_level,
+    observed_at, ingested_at, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, principalId, input.sourceType, input.sourceInstanceId ?? null, input.sourceRef, input.sourceRunId ?? null, input.sourceItemId ?? null, input.sessionId ?? null, input.turnId ?? null, input.messageId ?? null, contentHash ?? null, input.retentionPolicy ?? null, input.processingPolicy ?? null, input.extractorId ?? null, input.extractorVersion ?? null, input.redactedExcerpt ?? null, input.trustLevel, input.observedAt, input.ingestedAt ?? createdAt, createdAt);
+	return fromRow(db.prepare("SELECT * FROM context_evidence WHERE evidence_id = ?").get(id));
+}
+//#endregion
+export { createContextEvidence };

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

@@ -11,9 +11,8 @@ export { clearGatewayIdentityForTest, getOrCreateGatewayIdentity, signGatewayPay
 export { consumeDevicePairingToken, createDevicePairingSetup, isDevicePairingSetupActive, type DevicePairingSetup, type DeviceRoute, type PairingConsumeResult, } from './device-pairing-repository.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, closeUnderstandingValidity, consumeContextConsent, deleteCollaborationRule, deleteUnderstanding, decideContextConsent, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, listCollaborationRules, listUnderstandingEvidence, listUnderstandingStatusEvents, listUnderstandings, linkUnderstandingEvidence, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, searchActiveUnderstandings, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile, type CreateUnderstandingInput, type UnderstandingStatusEvent, } from './user-context-repository.js';
+export { createCollaborationRule, getCollaborationRule, listCollaborationRules, setCollaborationRuleStatus, type CollaborationRule, } from './collaboration-rule-repository.js';
+export { createContextEvidence, type ContextEvidence } from './context-evidence-repository.js';
 export { getUserPerson, getUserPeopleIndexState, listUserPeople, mergeUserPeople, replaceUserPeopleIndex, summarizeUserPeople, updateUserPerson, } from './user-people-repository.js';
 export { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputState, getSessionInputById, insertSessionInput, listActiveSessionInputRuns, 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';
@@ -31,8 +30,7 @@ export { deleteSessionRecord, ensureSessionRecord, getCurrentSessionId, getGloba
 export { appendCompactionBoundaryIfUnchanged, appendTranscriptEntry, listCompactionBoundaries, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRows, loadTranscriptRowsForSession, loadCompactionSourceSnapshot, paginateTranscriptMessages, replaceTranscriptRows, restoreBeforeCompactionBoundary, searchSessionTranscript, type CompactionSourceSnapshot, type SessionTranscriptRecallMatch, type TranscriptSourceEntry, } from './transcript-repository.js';
 export { deleteNoteRecord, getNoteRecord, listNoteRecords, upsertNoteRecord, } from './notes-repository.js';
 export { deleteNoteAgentContextRecord, getNoteAgentContextRecord, upsertNoteAgentContextRecord, type NoteAgentContextRecord, } from './note-agent-context-repository.js';
-export { appendMemorySignal, appendMemoryTraceEvent, countMemoryRecordsBySourceInstanceId, deleteMemoryRecordsBySourceInstanceId, deleteMemoryRecord, getMemoryProviderState, getMemoryTurnFeedback, getMemoryRecord, hasUnresolvedMemoryConflict, listMemorySignals, listMemoryTraceEvents, listMemoryRecords, markMemoryRecordsConflicted, searchMemoryRecords, setMemoryRecordStatus, setMemoryProviderState, setMemoryTurnFeedback, summarizeMemoryRecallFeedback, upsertMemoryRecord, type AppendMemorySignalInput, type AppendMemoryTraceEventInput, type ListMemoryRecordsOptions, type MemoryRecallFeedbackSummary, type MemorySignalRowPayload, type MemoryFeedback, type MemoryFeedbackRating, type MemoryTraceEventPayload, type SearchMemoryRecordsOptions, type SetMemoryTurnFeedbackInput, type UpsertMemoryRecordInput, } from './memory-records-repository.js';
-export { attachMemoryEvidence, claimKnowledgeSourceItems, countKnowledgeSourceItems, completeKnowledgeSourceItemSynthesis, deleteMemoryEvidenceForRecord, deleteKnowledgeSourceItems, finishKnowledgeSyncRun, getKnowledgeConsumerWatermark, getKnowledgeSourceCursor, getKnowledgeSourceItem, listKnowledgeSourceItems, listKnowledgeSourceChanges, listKnowledgeSyncRuns, listMemoryEvidence, pruneBoundedKnowledgeSourceItems, setKnowledgeSourceItemSynthesisStatus, setKnowledgeConsumerWatermark, setKnowledgeSourceCursor, startKnowledgeSyncRun, upsertKnowledgeSourceItems, } from './knowledge-repository.js';
+export { claimKnowledgeSourceItems, countKnowledgeSourceItems, completeKnowledgeSourceItemSynthesis, deleteKnowledgeSourceItems, finishKnowledgeSyncRun, getKnowledgeConsumerWatermark, getKnowledgeSourceCursor, getKnowledgeSourceItem, listKnowledgeSourceItems, listKnowledgeSourceChanges, listKnowledgeSyncRuns, pruneBoundedKnowledgeSourceItems, setKnowledgeSourceItemSynthesisStatus, setKnowledgeConsumerWatermark, setKnowledgeSourceCursor, startKnowledgeSyncRun, upsertKnowledgeSourceItems, } from './knowledge-repository.js';
 export { deleteSessionConfig, getSessionConfig, hasSessionConfig, setSessionConfig, updateSessionConfig, } from './config-repository.js';
 export { createObjectLinkRecord, deleteObjectLinkRecord, getActivityEventRecord, listActivityRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, recordActivityEvent, } from './activity-repository.js';
 export { appendConnectorExecutionAudit, claimConnectorWebhookDelivery, completeConnectorWebhookDelivery, consumeConnectorApproval, createConnectorApproval, decideConnectorApproval, deleteConnectorConnection, deleteConnectorInstallation, getConnectorConnection, getConnectorApproval, getConnectorInstallation, getCachedConnectorCatalogEntry, listCachedConnectorCatalogEntries, listConnectorActionMetadata, listConnectorApprovals, listConnectorConnections, listConnectorExecutionAudit, listConnectorInstallations, releaseConnectorWebhookDelivery, replaceConnectorCatalogEntries, upsertConnectorActionMetadata, upsertConnectorCatalogEntry, upsertConnectorConnection, upsertConnectorInstallation, type CachedConnectorCatalogEntry, } from './connector-repository.js';

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

@@ -12,9 +12,8 @@ import { clearGatewayIdentityForTest, getOrCreateGatewayIdentity, signGatewayPay
 import { consumeDevicePairingToken, createDevicePairingSetup, isDevicePairingSetupActive } from "./device-pairing-repository.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 { closeUnderstandingValidity, consumeContextConsent, createCollaborationRule, createContextEvidence, createUnderstanding, decideContextConsent, deleteCollaborationRule, deleteUnderstanding, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, linkUnderstandingEvidence, listCollaborationRules, listUnderstandingEvidence, listUnderstandingStatusEvents, listUnderstandings, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, searchActiveUnderstandings, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile } from "./user-context-repository.js";
+import { createCollaborationRule, getCollaborationRule, listCollaborationRules, setCollaborationRuleStatus } from "./collaboration-rule-repository.js";
+import { createContextEvidence } from "./context-evidence-repository.js";
 import { getUserPeopleIndexState, getUserPerson, listUserPeople, mergeUserPeople, replaceUserPeopleIndex, summarizeUserPeople, updateUserPerson } from "./user-people-repository.js";
 import { buildDefaultSessionMetadata } from "./session-metadata.js";
 import { buildGlobalSessionStats, classifyStoredRow, estimateTokensFromMessages, extractFtsContent, metadataToSessionInsert, sessionConfigRowToConfig, sessionRowToMetadata, transcriptEntryRowToStoredRow } from "./row-mappers.js";
@@ -32,12 +31,11 @@ import { buildRelationshipPrompt, getRelationshipSettings, isProactiveSupportAll
 import { appendCompactionBoundaryIfUnchanged, appendTranscriptEntry, listCompactionBoundaries, loadCompactionSourceSnapshot, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRows, loadTranscriptRowsForSession, paginateTranscriptMessages, replaceTranscriptRows, restoreBeforeCompactionBoundary, searchSessionTranscript } from "./transcript-repository.js";
 import { deleteNoteRecord, getNoteRecord, listNoteRecords, upsertNoteRecord } from "./notes-repository.js";
 import { deleteNoteAgentContextRecord, getNoteAgentContextRecord, upsertNoteAgentContextRecord } from "./note-agent-context-repository.js";
-import { attachMemoryEvidence, claimKnowledgeSourceItems, completeKnowledgeSourceItemSynthesis, countKnowledgeSourceItems, deleteKnowledgeSourceItems, deleteMemoryEvidenceForRecord, finishKnowledgeSyncRun, getKnowledgeConsumerWatermark, getKnowledgeSourceCursor, getKnowledgeSourceItem, listKnowledgeSourceChanges, listKnowledgeSourceItems, listKnowledgeSyncRuns, listMemoryEvidence, pruneBoundedKnowledgeSourceItems, setKnowledgeConsumerWatermark, setKnowledgeSourceCursor, setKnowledgeSourceItemSynthesisStatus, startKnowledgeSyncRun, upsertKnowledgeSourceItems } from "./knowledge-repository.js";
-import { appendMemorySignal, appendMemoryTraceEvent, countMemoryRecordsBySourceInstanceId, deleteMemoryRecord, deleteMemoryRecordsBySourceInstanceId, getMemoryProviderState, getMemoryRecord, getMemoryTurnFeedback, hasUnresolvedMemoryConflict, listMemoryRecords, listMemorySignals, listMemoryTraceEvents, markMemoryRecordsConflicted, searchMemoryRecords, setMemoryProviderState, setMemoryRecordStatus, setMemoryTurnFeedback, summarizeMemoryRecallFeedback, upsertMemoryRecord } from "./memory-records-repository.js";
+import { claimKnowledgeSourceItems, completeKnowledgeSourceItemSynthesis, countKnowledgeSourceItems, deleteKnowledgeSourceItems, finishKnowledgeSyncRun, getKnowledgeConsumerWatermark, getKnowledgeSourceCursor, getKnowledgeSourceItem, listKnowledgeSourceChanges, listKnowledgeSourceItems, listKnowledgeSyncRuns, pruneBoundedKnowledgeSourceItems, setKnowledgeConsumerWatermark, setKnowledgeSourceCursor, setKnowledgeSourceItemSynthesisStatus, startKnowledgeSyncRun, upsertKnowledgeSourceItems } from "./knowledge-repository.js";
 import { deleteSessionConfig, getSessionConfig, hasSessionConfig, setSessionConfig, updateSessionConfig } from "./config-repository.js";
 import { createObjectLinkRecord, deleteObjectLinkRecord, getActivityEventRecord, listActivityRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, recordActivityEvent } from "./activity-repository.js";
 import { appendConnectorExecutionAudit, claimConnectorWebhookDelivery, completeConnectorWebhookDelivery, consumeConnectorApproval, createConnectorApproval, decideConnectorApproval, deleteConnectorConnection, deleteConnectorInstallation, getCachedConnectorCatalogEntry, getConnectorApproval, getConnectorConnection, getConnectorInstallation, listCachedConnectorCatalogEntries, listConnectorActionMetadata, listConnectorApprovals, listConnectorConnections, listConnectorExecutionAudit, listConnectorInstallations, releaseConnectorWebhookDelivery, replaceConnectorCatalogEntries, upsertConnectorActionMetadata, upsertConnectorCatalogEntry, upsertConnectorConnection, upsertConnectorInstallation } from "./connector-repository.js";
 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, authenticateDeviceAccessToken, bindEndpointPrincipal, buildDefaultSessionMetadata, buildGlobalSessionStats, buildRefreshProofMessage, buildRelationshipPrompt, cancelQueuedSessionInput, claimConnectorWebhookDelivery, claimContextExtractionRun, claimKnowledgeSourceItems, claimNextConnectorLearningJob, claimNextSessionInput, classifyStoredRow, clearComposerInputHistory, clearGatewayIdentityForTest, closeTemporalAssertions, closeUnderstandingValidity, closeXopcDatabase, completeConnectorWebhookDelivery, completeKnowledgeSourceItemSynthesis, consumeConnectorApproval, consumeContextConsent, consumeDevicePairingToken, countKnowledgeSourceItems, countMemoryRecordsBySourceInstanceId, createCollaborationRule, createConnectorApproval, createContextEvidence, createDevice, createDevicePairingSetup, createEndpointPrincipal, createObjectLinkRecord, createTemporalAssertion, createUnderstanding, decideConnectorApproval, decideContextConsent, deleteCollaborationRule, deleteConnectorConnection, deleteConnectorInstallation, deleteEndpointSessionBinding, deleteKnowledgeSourceItems, deleteMemoryEvidenceForRecord, deleteMemoryRecord, deleteMemoryRecordsBySourceInstanceId, 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, getDevice, getEndpointPrincipal, getEndpointSessionBinding, getGlobalSessionStats, getInteractionState, getKnowledgeConsumerWatermark, getKnowledgeSourceCursor, getKnowledgeSourceItem, getMemoryProviderState, getMemoryRecord, getMemoryTurnFeedback, getNoteAgentContextRecord, getNoteRecord, getOrCreateGatewayIdentity, getRelationshipSettings, getSessionConfig, getSessionInputById, getSessionInputState, getSessionMetadata, getSessionPersistedLevels, getSessionTaskPlan, getSqliteDatabase, getTurnPersonalization, getUnderstanding, getUserPeopleIndexState, getUserPerson, getUserProfile, getUserTrustPolicy, getXopcDatabase, hasContextConsent, hasIndependentExtractionOutput, hasSessionConfig, hasUnresolvedMemoryConflict, incrementSessionStatsOnAppend, insertSessionInput, inspectSchemaMigrationStatus, isDevicePairingSetupActive, isHomeAttentionAcknowledged, isProactiveSupportAllowed, isUnderstandingSuppressed, isXopcDatabaseOpen, issueDeviceTokenPair, linkContextObjects, linkUnderstandingEvidence, listActiveSessionInputRuns, listActivityRecords, listCachedConnectorCatalogEntries, listCollaborationRules, listCompactionBoundaries, listComposerInputHistory, listConnectorAccounts, listConnectorActionMetadata, listConnectorApprovals, listConnectorConnections, listConnectorExecutionAudit, listConnectorInstallations, listConnectorLearningJobs, listConnectorSyncPolicies, listContextConsolidationDecisions, listContextConsolidationRuns, listContextExtractionOutputs, listContextExtractionRuns, listContextObjectRelations, listDevices, listEndpointPrincipals, listEndpointToolInvocationAudits, listKnowledgeSourceChanges, listKnowledgeSourceItems, listKnowledgeSyncRuns, listMemoryEvidence, listMemoryRecords, listMemorySignals, listMemoryTraceEvents, listNoteRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, listRegisteredMigrationTargets, listSessionMetadata, listSessionsByAgent, listTemporalAssertions, listUnderstandingEvidence, listUnderstandingStatusEvents, listUnderstandings, listUserPeople, loadCompactionSourceSnapshot, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRows, loadTranscriptRowsForSession, markMemoryRecordsConflicted, mergeUserPeople, metadataToSessionInsert, mutateQueuedSessionInput, openXopcDatabase, paginateTranscriptMessages, patchSessionMetadata, pruneBoundedKnowledgeSourceItems, readSchemaVersion, readSchemaVersionForTest, reconcileConnectorAccount, recordActivityEvent, recordContextConsolidationDecision, recordContextFeedback, recordContextRun, recoverSessionInputState, recoverStaleConnectorLearningJobs, refreshConnectorAccountCurrent, rejectUnderstanding, releaseConnectorWebhookDelivery, replaceConnectorCatalogEntries, replaceLatestSessionTurnAndQueueInput, replaceTranscriptRows, replaceUserPeopleIndex, requireXopcDatabase, resetSessionRecord, resetXopcDatabaseSingletonForTest, resolveMigrationsDir, resolveSessionAgentId, resolveXopcDatabasePath, restoreBeforeCompactionBoundary, reviseCollaborationRule, reviseUnderstanding, revokeDevice, revokeEndpointPrincipal, rotateDeviceRefreshToken, runSqliteWriteTransaction, searchActiveUnderstandings, searchMemoryRecords, searchSessionTranscript, sessionConfigRowToConfig, sessionRowToMetadata, setCollaborationRuleStatus, setConnectorLearningPaused, setEndpointSessionBinding, setInteractionState, setKnowledgeConsumerWatermark, setKnowledgeSourceCursor, setKnowledgeSourceItemSynthesisStatus, setMemoryProviderState, setMemoryRecordStatus, setMemoryTurnFeedback, setSessionConfig, setSessionInputStatus, setSessionTaskPlan, setUnderstandingStatus, setUserTrustPolicy, signGatewayPayload, startContextConsolidationRun, startEndpointToolInvocationAudit, startKnowledgeSyncRun, summarizeMemoryRecallFeedback, summarizeUnderstandingFeedback, summarizeUserPeople, summarizeUserUnderstandingQuality, touchEndpointPrincipal, transcriptEntryRowToStoredRow, updateConnectorLearningJob, updateInteractionStateFromMessage, updateRelationshipSettings, updateSessionConfig, updateSessionStats, updateUserPerson, 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, appendTranscriptEntry, applyPendingMigrations, authenticateDeviceAccessToken, bindEndpointPrincipal, buildDefaultSessionMetadata, buildGlobalSessionStats, buildRefreshProofMessage, buildRelationshipPrompt, cancelQueuedSessionInput, claimConnectorWebhookDelivery, claimContextExtractionRun, claimKnowledgeSourceItems, claimNextConnectorLearningJob, claimNextSessionInput, classifyStoredRow, clearComposerInputHistory, clearGatewayIdentityForTest, closeTemporalAssertions, closeXopcDatabase, completeConnectorWebhookDelivery, completeKnowledgeSourceItemSynthesis, consumeConnectorApproval, consumeDevicePairingToken, countKnowledgeSourceItems, createCollaborationRule, createConnectorApproval, createContextEvidence, createDevice, createDevicePairingSetup, createEndpointPrincipal, createObjectLinkRecord, createTemporalAssertion, decideConnectorApproval, deleteConnectorConnection, deleteConnectorInstallation, deleteEndpointSessionBinding, deleteKnowledgeSourceItems, deleteNoteAgentContextRecord, deleteNoteRecord, deleteObjectLinkRecord, deleteSessionConfig, deleteSessionRecord, discoverSqlMigrations, enqueueConnectorLearningJob, ensureSessionRecord, ensureXopcDatabaseSchema, estimateTokensFromMessages, extractFtsContent, findSessionInput, findSessionKeyBySessionId, finishContextExtractionRun, finishEndpointToolInvocationAudit, finishKnowledgeSyncRun, finishSessionInputRun, getActivityEventRecord, getCachedConnectorCatalogEntry, getCollaborationRule, getConnectorAccount, getConnectorApproval, getConnectorConnection, getConnectorInstallation, getConnectorSyncPolicy, getConnectorSyncPolicyForConnection, getContextExtractionRun, getCurrentSessionId, getDevice, getEndpointPrincipal, getEndpointSessionBinding, getGlobalSessionStats, getInteractionState, getKnowledgeConsumerWatermark, getKnowledgeSourceCursor, getKnowledgeSourceItem, getNoteAgentContextRecord, getNoteRecord, getOrCreateGatewayIdentity, getRelationshipSettings, getSessionConfig, getSessionInputById, getSessionInputState, getSessionMetadata, getSessionPersistedLevels, getSessionTaskPlan, getSqliteDatabase, getUserPeopleIndexState, getUserPerson, getUserTrustPolicy, getXopcDatabase, hasIndependentExtractionOutput, hasSessionConfig, incrementSessionStatsOnAppend, insertSessionInput, inspectSchemaMigrationStatus, isDevicePairingSetupActive, isHomeAttentionAcknowledged, isProactiveSupportAllowed, isXopcDatabaseOpen, issueDeviceTokenPair, linkContextObjects, listActiveSessionInputRuns, listActivityRecords, listCachedConnectorCatalogEntries, listCollaborationRules, listCompactionBoundaries, listComposerInputHistory, listConnectorAccounts, listConnectorActionMetadata, listConnectorApprovals, listConnectorConnections, listConnectorExecutionAudit, listConnectorInstallations, listConnectorLearningJobs, listConnectorSyncPolicies, listContextExtractionOutputs, listContextExtractionRuns, listContextObjectRelations, listDevices, listEndpointPrincipals, listEndpointToolInvocationAudits, listKnowledgeSourceChanges, listKnowledgeSourceItems, listKnowledgeSyncRuns, listNoteRecords, listObjectActivityRecords, listObjectLinkRecords, listProjectActivityRecords, listRegisteredMigrationTargets, listSessionMetadata, listSessionsByAgent, listTemporalAssertions, listUserPeople, loadCompactionSourceSnapshot, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRows, loadTranscriptRowsForSession, mergeUserPeople, metadataToSessionInsert, mutateQueuedSessionInput, openXopcDatabase, paginateTranscriptMessages, patchSessionMetadata, pruneBoundedKnowledgeSourceItems, readSchemaVersion, readSchemaVersionForTest, reconcileConnectorAccount, recordActivityEvent, recoverSessionInputState, recoverStaleConnectorLearningJobs, refreshConnectorAccountCurrent, releaseConnectorWebhookDelivery, replaceConnectorCatalogEntries, replaceLatestSessionTurnAndQueueInput, replaceTranscriptRows, replaceUserPeopleIndex, requireXopcDatabase, resetSessionRecord, resetXopcDatabaseSingletonForTest, resolveMigrationsDir, resolveSessionAgentId, resolveXopcDatabasePath, restoreBeforeCompactionBoundary, revokeDevice, revokeEndpointPrincipal, rotateDeviceRefreshToken, runSqliteWriteTransaction, searchSessionTranscript, sessionConfigRowToConfig, sessionRowToMetadata, setCollaborationRuleStatus, setConnectorLearningPaused, setEndpointSessionBinding, setInteractionState, setKnowledgeConsumerWatermark, setKnowledgeSourceCursor, setKnowledgeSourceItemSynthesisStatus, setSessionConfig, setSessionInputStatus, setSessionTaskPlan, setUserTrustPolicy, signGatewayPayload, startEndpointToolInvocationAudit, startKnowledgeSyncRun, summarizeUserPeople, touchEndpointPrincipal, transcriptEntryRowToStoredRow, updateConnectorLearningJob, updateInteractionStateFromMessage, updateRelationshipSettings, updateSessionConfig, updateSessionStats, updateUserPerson, upsertConnectorActionMetadata, upsertConnectorCatalogEntry, upsertConnectorConnection, upsertConnectorInstallation, upsertConnectorSyncPolicy, upsertKnowledgeSourceItems, upsertNoteAgentContextRecord, upsertNoteRecord, validateLatestSessionTurnTarget };

package/dist/src/storage/sqlite/knowledge-repository.d.ts

@@ -1,6 +1,4 @@
-import type { DatabaseSync } from 'node:sqlite';
 import type { KnowledgeSourceChange, KnowledgeSourceItem, KnowledgeSourceItemInput, KnowledgeSyncRun, KnowledgeSyncRunStatus, KnowledgeSynthesisPipeline, KnowledgeSynthesisStatus, KnowledgeRetentionClass } from '../../knowledge/types.js';
-import type { MemoryEvidence, MemoryEvidenceRelation } from '../../agent/memory/types.js';
 export declare function startKnowledgeSyncRun(input: {
     sourceInstanceId: string;
     cursorBefore?: string;
@@ -74,20 +72,3 @@ export declare function completeKnowledgeSourceItemSynthesis(input: {
     error?: string;
     nowMs?: number;
 }): boolean;
-export interface AttachMemoryEvidenceInput {
-    recordId: string;
-    sourceItemId?: string;
-    relation?: MemoryEvidenceRelation;
-    excerpt?: string;
-    confidence?: number;
-    observedAt?: string;
-    sessionKey?: string;
-    turnId?: string;
-    toolCallId?: string;
-    nowMs?: number;
-}
-export declare function attachMemoryEvidence(input: AttachMemoryEvidenceInput): MemoryEvidence;
-export declare function replaceMemoryEvidenceForRecord(db: DatabaseSync, recordId: string, evidence: MemoryEvidence[], nowMs?: number): void;
-export declare function deleteMemoryEvidenceForRecord(recordId: string, relation?: MemoryEvidenceRelation): number;
-export declare function listMemoryEvidence(recordId: string): MemoryEvidence[];
-export declare function listMemoryEvidenceForRecords(recordIds: string[]): Map<string, MemoryEvidence[]>;