@xopcai/xopc 0.0.207 → 0.0.210

package/dist/src/session/store.js

@@ -2,8 +2,8 @@ import { init_paths_state, resolveStateDir } from "../config/paths-state.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { requireXopcDatabase } from "../storage/sqlite/connection.js";
-import "./types.js";
 import { buildSessionContextForLlm, buildSessionDisplayMessages, isRuntimeOnlyTranscriptMessage, isTranscriptCompactionEntry, mergeLlmMessagesPreservingContextRows, transcriptRowsFromJsonArray } from "./session-context-for-llm.js";
+import "./types.js";
 import { estimateTokensFromMessages } from "../storage/sqlite/row-mappers.js";
 import { deleteSessionRecord, ensureSessionRecord, findSessionKeyBySessionId, getGlobalSessionStats, getSessionMetadata, listSessionMetadata, listSessionsByAgent, patchSessionMetadata, resetSessionRecord } from "../storage/sqlite/session-repository.js";
 import { appendCompactionBoundaryIfUnchanged, appendTranscriptEntry, listCompactionBoundaries, loadCompactionSourceSnapshot, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRowsForSession, paginateTranscriptMessages, replaceTranscriptRows, restoreBeforeCompactionBoundary, searchSessionTranscript } from "../storage/sqlite/transcript-repository.js";

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

@@ -4,7 +4,3 @@ export declare function escapeFts5Query(raw: string): string;
 export declare function buildFts5SearchQuery(raw: string): string;
 /** Normalize FTS5 BM25 ranks, where a more-negative rank is a better match. */
 export declare function fts5RankToScore(rank: number, bestRank: number, worstRank: number): number;
-/** Bounded lexical fallback for reformulations unsupported by unicode61 tokenization. */
-export declare function memoryLexicalSimilarity(query: string, content: string): number;
-/** Local deterministic embedding used to complement FTS without network or model coupling. */
-export declare function memoryVectorSimilarity(query: string, content: string): number;

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

@@ -40,7 +40,7 @@ const FTS_SEARCH_STOP_WORDS = new Set([
 ]);
 /** Build a syntax-safe, recall-oriented query for natural-language memory search. */
 function buildFts5SearchQuery(raw) {
-	const terms = raw.normalize("NFKC").match(/[\p{L}\p{N}_]+/gu)?.map((term) => term.toLocaleLowerCase()).filter((term) => term.length > 1 && !FTS_SEARCH_STOP_WORDS.has(term));
+	const terms = raw.normalize("NFKC").match(/[\p{L}\p{N}_]+/gu)?.map((term) => term.toLowerCase()).filter((term) => term.length > 1 && !FTS_SEARCH_STOP_WORDS.has(term));
 	if (!terms?.length) return escapeFts5Query(raw);
 	return [...new Set(terms)].slice(0, 12).map((term) => escapeFts5Query(term)).join(" OR ");
 }
@@ -55,52 +55,5 @@ function fts5RankToScore(rank, bestRank, worstRank) {
 	const normalized = (worstRank - rank) / (worstRank - bestRank);
 	return .5 + .5 * Math.max(0, Math.min(1, normalized));
 }
-function lexicalFeatures(raw) {
-	const normalized = raw.normalize("NFKC").toLocaleLowerCase();
-	const features = /* @__PURE__ */ new Set();
-	for (const term of normalized.match(/[\p{L}\p{N}_]+/gu) ?? []) if (term.length > 1 && !FTS_SEARCH_STOP_WORDS.has(term)) features.add(`word:${term}`);
-	for (const sequence of normalized.match(/\p{Script=Han}+/gu) ?? []) {
-		const chars = [...sequence];
-		for (let index = 0; index < chars.length - 1; index += 1) features.add(`han:${chars[index]}${chars[index + 1]}`);
-	}
-	return features;
-}
-/** Bounded lexical fallback for reformulations unsupported by unicode61 tokenization. */
-function memoryLexicalSimilarity(query, content) {
-	const queryFeatures = lexicalFeatures(query);
-	const contentFeatures = lexicalFeatures(content);
-	if (queryFeatures.size === 0 || contentFeatures.size === 0) return 0;
-	let shared = 0;
-	for (const feature of queryFeatures) if (contentFeatures.has(feature)) shared += 1;
-	return 2 * shared / (queryFeatures.size + contentFeatures.size);
-}
-const VECTOR_SIZE = 128;
-function featureVector(raw) {
-	const vector = new Float64Array(VECTOR_SIZE);
-	const normalized = raw.normalize("NFKC").toLocaleLowerCase();
-	const features = [...(normalized.match(/[\p{L}\p{N}_]+/gu) ?? []).map((term) => `w:${term}`), ...[...normalized].map((char, index, chars) => chars.slice(index, index + 3).join("")).filter((value) => value.trim().length >= 2).map((value) => `c:${value}`)];
-	for (const feature of features) {
-		let hash = 2166136261;
-		for (const char of feature) hash = Math.imul(hash ^ char.codePointAt(0), 16777619);
-		const index = (hash >>> 0) % VECTOR_SIZE;
-		vector[index] += (hash & 1) === 0 ? 1 : -1;
-	}
-	return vector;
-}
-/** Local deterministic embedding used to complement FTS without network or model coupling. */
-function memoryVectorSimilarity(query, content) {
-	const left = featureVector(query);
-	const right = featureVector(content);
-	let dot = 0;
-	let leftNorm = 0;
-	let rightNorm = 0;
-	for (let index = 0; index < VECTOR_SIZE; index += 1) {
-		dot += left[index] * right[index];
-		leftNorm += left[index] ** 2;
-		rightNorm += right[index] ** 2;
-	}
-	if (leftNorm === 0 || rightNorm === 0) return 0;
-	return Math.max(0, dot / Math.sqrt(leftNorm * rightNorm));
-}
 //#endregion
-export { buildFts5SearchQuery, escapeFts5Query, fts5RankToScore, memoryLexicalSimilarity, memoryVectorSimilarity };
+export { buildFts5SearchQuery, escapeFts5Query, fts5RankToScore };

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

@@ -6,9 +6,10 @@ export { discoverSqlMigrations, listRegisteredMigrationTargets } from './migrati
 export { closeXopcDatabase, getXopcDatabase, isXopcDatabaseOpen, openXopcDatabase, requireXopcDatabase, resetXopcDatabaseSingletonForTest, type OpenXopcDatabaseOptions, type XopcDatabase, } from './connection.js';
 export { getSqliteDatabase, runSqliteWriteTransaction } from './transaction.js';
 export { finishContextConsolidationRun, getContextConsolidationRun, listContextConsolidationDecisions, listContextConsolidationRuns, recordContextConsolidationDecision, startContextConsolidationRun, type ContextConsolidationDecision, type ContextConsolidationRun, } from './context-consolidation-repository.js';
-export { summarizeUserUnderstandingQuality, 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, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile, type CreateUnderstandingInput, } from './user-context-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 { 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';
 export { appendComposerInputHistory, clearComposerInputHistory, listComposerInputHistory, COMPOSER_INPUT_HISTORY_LIMIT, type ComposerInputHistoryItem, } from './composer-input-history-repository.js';

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

@@ -7,17 +7,18 @@ import { ensureXopcDatabaseSchema } from "./schema.js";
 import { closeXopcDatabase, getXopcDatabase, isXopcDatabaseOpen, openXopcDatabase, requireXopcDatabase, resetXopcDatabaseSingletonForTest } from "./connection.js";
 import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
 import { finishContextConsolidationRun, getContextConsolidationRun, listContextConsolidationDecisions, listContextConsolidationRuns, recordContextConsolidationDecision, startContextConsolidationRun } from "./context-consolidation-repository.js";
-import { 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, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile } from "./user-context-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 { 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";
 import { acknowledgeHomeAttention, isHomeAttentionAcknowledged } from "./home-attention-repository.js";
 import { claimNextConnectorLearningJob, enqueueConnectorLearningJob, listConnectorLearningJobs, recoverStaleConnectorLearningJobs, setConnectorLearningPaused, updateConnectorLearningJob } from "./connector-learning-repository.js";
 import { COMPOSER_INPUT_HISTORY_LIMIT, appendComposerInputHistory, clearComposerInputHistory, listComposerInputHistory } from "./composer-input-history-repository.js";
 import { bindEndpointPrincipal, createEndpointPrincipal, getEndpointPrincipal, listEndpointPrincipals, revokeEndpointPrincipal, touchEndpointPrincipal } from "./endpoint-principal-repository.js";
 import { finishEndpointToolInvocationAudit, listEndpointToolInvocationAudits, startEndpointToolInvocationAudit } from "./endpoint-tool-invocation-repository.js";
 import { getInteractionState, setInteractionState, updateInteractionStateFromMessage } from "./interaction-state-repository.js";
-import { buildDefaultSessionMetadata } from "./session-metadata.js";
-import { buildGlobalSessionStats, classifyStoredRow, estimateTokensFromMessages, extractFtsContent, metadataToSessionInsert, sessionConfigRowToConfig, sessionRowToMetadata, transcriptEntryRowToStoredRow } from "./row-mappers.js";
 import { deleteSessionRecord, ensureSessionRecord, findSessionKeyBySessionId, getCurrentSessionId, getGlobalSessionStats, getSessionMetadata, getSessionPersistedLevels, incrementSessionStatsOnAppend, listSessionMetadata, listSessionsByAgent, patchSessionMetadata, resetSessionRecord, resolveSessionAgentId, updateSessionStats } from "./session-repository.js";
 import { getSessionTaskPlan, setSessionTaskPlan } from "./session-task-plan-repository.js";
 import { buildRelationshipPrompt, getRelationshipSettings, isProactiveSupportAllowed, updateRelationshipSettings } from "./relationship-settings-repository.js";
@@ -32,4 +33,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, replaceTranscriptRows, requireXopcDatabase, resetSessionRecord, resetXopcDatabaseSingletonForTest, resolveMigrationsDir, resolveSessionAgentId, resolveXopcDatabasePath, restoreBeforeCompactionBoundary, reviseCollaborationRule, reviseUnderstanding, revokeEndpointPrincipal, runSqliteWriteTransaction, searchMemoryRecords, searchSessionTranscript, sessionConfigRowToConfig, sessionRowToMetadata, setCollaborationRuleStatus, setConnectorLearningPaused, setInteractionState, setKnowledgeConsumerWatermark, setKnowledgeSourceCursor, setKnowledgeSourceItemSynthesisStatus, setMemoryProviderState, setMemoryRecordStatus, setMemoryTurnFeedback, setSessionConfig, setSessionInputStatus, setSessionTaskPlan, setUnderstandingStatus, setUserTrustPolicy, startContextConsolidationRun, startEndpointToolInvocationAudit, startKnowledgeSyncRun, summarizeMemoryRecallFeedback, summarizeUserUnderstandingQuality, touchEndpointPrincipal, transcriptEntryRowToStoredRow, updateConnectorLearningJob, updateInteractionStateFromMessage, updateRelationshipSettings, updateSessionConfig, updateSessionStats, updateUserProfile, upsertConnectorActionMetadata, upsertConnectorCatalogEntry, upsertConnectorConnection, upsertConnectorInstallation, upsertConnectorSyncPolicy, upsertKnowledgeSourceItems, upsertMemoryRecord, upsertNoteAgentContextRecord, upsertNoteRecord };
+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 };

package/dist/src/storage/sqlite/memory-records-repository.js

@@ -1,9 +1,18 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-import { buildFts5SearchQuery, fts5RankToScore, memoryLexicalSimilarity, memoryVectorSimilarity } from "./fts.js";
+import { buildFts5SearchQuery } from "./fts.js";
 import { LOCAL_USER_ID } from "../../user-context/owner.js";
+import { fuseRankedCandidates } from "../../retrieval/candidateFusion.js";
+import { normalizeRetrievalText, retrievalLexicalSimilarity } from "../../retrieval/textFeatures.js";
+import { buildRetrievalQueryProfile } from "../../retrieval/queryProfile.js";
 import { listMemoryEvidence, listMemoryEvidenceForRecords, replaceMemoryEvidenceForRecord } from "./knowledge-repository.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/memory-records-repository.ts
+function memoryFeedbackAdjustment(summary) {
+	if (!summary || summary.total < 3) return 0;
+	const helpfulRate = (summary.helpful + 1) / (summary.total + 2);
+	const relevancePenalty = summary.irrelevant >= 3 ? .05 : 0;
+	return Math.max(-.1, Math.min(.05, (helpfulRate - .5) * .1 - relevancePenalty));
+}
 function parseStringArray(json) {
 	try {
 		const parsed = JSON.parse(json);
@@ -285,7 +294,12 @@ function listMemoryRecords(options = {}) {
        LIMIT ? OFFSET ?`).all(...params, limit, offset));
 }
 function searchMemoryRecords(options) {
-	const query = buildFts5SearchQuery(options.query);
+	const profile = buildRetrievalQueryProfile(options.query, {
+		...options.visibleToSessionKey ? { sessionKey: options.visibleToSessionKey } : {},
+		...options.visibleToWorkspaceId ?? options.workspaceId ? { workspaceId: options.visibleToWorkspaceId ?? options.workspaceId } : {},
+		...options.visibleToProjectId ?? options.projectId ? { projectId: options.visibleToProjectId ?? options.projectId } : {}
+	});
+	const query = buildFts5SearchQuery(profile.normalized);
 	if (!query) return [];
 	const filters = ["memory_records_fts MATCH ?"];
 	const params = [query];
@@ -330,6 +344,7 @@ function searchMemoryRecords(options) {
 	params.push(...statuses);
 	const maxResults = Math.max(1, Math.min(50, options.maxResults ?? 5));
 	const minScore = options.minScore ?? 0;
+	const candidateLimit = Math.max(50, Math.min(200, maxResults * 10));
 	const rows = getSqliteDatabase().prepare(`SELECT
         r.*,
         bm25(memory_records_fts) AS rank
@@ -337,7 +352,7 @@ function searchMemoryRecords(options) {
        JOIN memory_records r ON r.record_id = f.record_id
        WHERE ${filters.join(" AND ")}
        ORDER BY rank
-       LIMIT ?`).all(...params, maxResults * 3);
+       LIMIT ?`).all(...params, candidateLimit);
 	const candidateRecords = listMemoryRecords({
 		providerId: options.providerId,
 		userId: options.userId,
@@ -352,40 +367,44 @@ function searchMemoryRecords(options) {
 		unscopedWorkspaceOnly: options.unscopedWorkspaceOnly,
 		limit: 500
 	}).filter((record) => statuses.includes(record.status ?? "active") && (!options.kinds?.length || options.kinds.includes(record.kind)));
-	const byId = /* @__PURE__ */ new Map();
 	const candidateById = new Map(candidateRecords.map((record) => [record.id, record]));
-	const missingEvidence = listMemoryEvidenceForRecords(rows.filter((row) => !candidateById.has(row.record_id)).map((row) => row.record_id));
-	if (rows.length > 0) {
-		const bestRank = Math.min(...rows.map((row) => row.rank));
-		const worstRank = Math.max(...rows.map((row) => row.rank));
-		for (const row of rows) {
-			const record = candidateById.get(row.record_id) ?? rowToRecord(row, missingEvidence.get(row.record_id) ?? []);
-			byId.set(record.id, {
-				record,
-				score: fts5RankToScore(row.rank, bestRank, worstRank) * .65,
-				snippet: record.content,
-				citation: {
-					providerId: row.provider_id,
-					recordId: row.record_id,
-					path: record.source.path,
-					lineStart: record.source.lineStart,
-					lineEnd: record.source.lineEnd,
-					createdAt: record.createdAt
-				}
-			});
+	const missingRows = rows.filter((row) => !candidateById.has(row.record_id));
+	const missingEvidence = listMemoryEvidenceForRecords(missingRows.map((row) => row.record_id));
+	const recordById = new Map(candidateRecords.map((record) => [record.id, record]));
+	for (const row of missingRows) recordById.set(row.record_id, rowToRecord(row, missingEvidence.get(row.record_id) ?? []));
+	const lexical = candidateRecords.map((record) => ({
+		id: record.id,
+		score: retrievalLexicalSimilarity(profile.normalized, record.content)
+	})).filter((result) => result.score > 0).sort((left, right) => right.score - left.score).slice(0, candidateLimit);
+	const fused = fuseRankedCandidates([
+		{
+			weight: 1.4,
+			ids: (profile.identifiers.length ? candidateRecords.map((record) => {
+				const content = normalizeRetrievalText(record.content);
+				return {
+					id: record.id,
+					matches: profile.identifiers.filter((identifier) => content.includes(identifier)).length
+				};
+			}).filter((result) => result.matches > 0).sort((left, right) => right.matches - left.matches).slice(0, candidateLimit) : []).map((result) => result.id)
+		},
+		{
+			weight: 1,
+			ids: rows.map((row) => row.record_id)
+		},
+		{
+			weight: .8,
+			ids: lexical.map((result) => result.id)
 		}
-	}
-	for (const record of candidateRecords) {
-		const vector = memoryVectorSimilarity(options.query, record.content);
-		const lexical = memoryLexicalSimilarity(options.query, record.content);
-		const existing = byId.get(record.id);
-		const score = existing ? Math.min(1, existing.score + vector * .25 + lexical * .1) : Math.max(vector, lexical);
-		byId.set(record.id, existing ? {
-			...existing,
-			score
-		} : {
+	]);
+	const feedback = new Map(summarizeMemoryRecallFeedback({ limit: 1e3 }).map((summary) => [summary.recordId, summary]));
+	return [...fused.entries()].map(([id, fusionScore]) => {
+		const record = recordById.get(id);
+		if (!record) return null;
+		const kindBonus = profile.intentKinds.includes(record.kind) ? .08 : 0;
+		const authorityBonus = record.explicitness === "explicit" ? .03 : 0;
+		return {
 			record,
-			score,
+			score: Math.max(0, Math.min(1, fusionScore * .85 + kindBonus + authorityBonus + record.importance * .04 + memoryFeedbackAdjustment(feedback.get(record.id)))),
 			snippet: record.content,
 			citation: {
 				providerId: record.providerId,
@@ -395,9 +414,8 @@ function searchMemoryRecords(options) {
 				lineEnd: record.source.lineEnd,
 				createdAt: record.createdAt
 			}
-		});
-	}
-	return [...byId.values()].filter((result) => result.score >= minScore).sort((left, right) => right.score - left.score).slice(0, maxResults);
+		};
+	}).filter((result) => Boolean(result)).filter((result) => result.score >= minScore).sort((left, right) => right.score - left.score).slice(0, maxResults);
 }
 function deleteMemoryRecord(recordId) {
 	return runSqliteWriteTransaction((db) => {
@@ -566,7 +584,11 @@ function setMemoryTurnFeedback(input) {
       ON CONFLICT DO UPDATE SET rating = excluded.rating, score = excluded.score,
         reason_code = excluded.reason_code, note = excluded.note, updated_at = excluded.updated_at`);
 		upsert.run(randomUUID(), trace.trace_id, turnId, null, "response", input.rating, typeof input.score === "number" ? Math.max(-1, Math.min(1, input.score)) : null, input.reasonCode?.trim().slice(0, 200) || null, input.note?.trim().slice(0, 2e3) || null, source, nowMs, nowMs);
-		for (const item of records) upsert.run(randomUUID(), trace.trace_id, turnId, item.recordId, "record", item.rating, null, item.reasonCode?.trim().slice(0, 200) || null, item.note?.trim().slice(0, 2e3) || null, source, nowMs, nowMs);
+		for (const item of records) {
+			upsert.run(randomUUID(), trace.trace_id, turnId, item.recordId, "record", item.rating, null, item.reasonCode?.trim().slice(0, 200) || null, item.note?.trim().slice(0, 2e3) || null, source, nowMs, nowMs);
+			if (item.rating === "incorrect" || item.rating === "sensitive") db.prepare("UPDATE memory_records SET status = 'needs_review', updated_at = ? WHERE record_id = ?").run(nowMs, item.recordId);
+			else if (item.rating === "outdated") db.prepare("UPDATE memory_records SET status = 'stale', updated_at = ? WHERE record_id = ?").run(nowMs, item.recordId);
+		}
 	});
 	return memoryTraceRowToPayload(trace);
 }

package/dist/src/storage/sqlite/row-mappers.js

@@ -1,7 +1,7 @@
-import "../../session/types.js";
-import { buildDefaultSessionMetadata } from "./session-metadata.js";
 import { isTranscriptContextEntry } from "../../session/session-context-for-llm.js";
+import "../../session/types.js";
 import { init_agent_session_key, resolveAgentIdFromSessionKey } from "../../routing/agent-session-key.js";
+import { buildDefaultSessionMetadata } from "./session-metadata.js";
 //#region src/storage/sqlite/row-mappers.ts
 init_agent_session_key();
 function parseJson(raw) {

package/dist/src/storage/sqlite/session-repository.js

@@ -1,8 +1,8 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
-import { validateSessionId } from "../../session/session-id.js";
+import { escapeFts5Query } from "./fts.js";
 import { buildDefaultSessionMetadata } from "./session-metadata.js";
 import { buildGlobalSessionStats, metadataToSessionInsert, sessionRowToMetadata } from "./row-mappers.js";
-import { escapeFts5Query } from "./fts.js";
+import { validateSessionId } from "../../session/session-id.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/session-repository.ts
 const SESSION_COLUMNS = `

package/dist/src/storage/sqlite/session-turn-replace-repository.d.ts

@@ -0,0 +1,34 @@
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
+import type { TurnOrigin } from '@xopcai/endpoint-tools-protocol';
+export type ReplaceLatestSessionTurnInput = {
+    sessionKey: string;
+    targetTurnId: string;
+    clientMessageId: string;
+    content: string;
+    attachments?: unknown[];
+    thinking?: string;
+    origin: TurnOrigin;
+};
+export type ReplaceLatestSessionTurnResult = {
+    ok: true;
+    idempotent: boolean;
+    inputId: string;
+    removedMessages: AgentMessage[];
+    remainingMessages: AgentMessage[];
+} | {
+    ok: false;
+    code: 'TARGET_NOT_FOUND' | 'NOT_LATEST' | 'SESSION_BUSY';
+};
+/** Validate before aborting a run; the transactional mutation validates again. */
+export declare function validateLatestSessionTurnTarget(sessionKey: string, targetTurnId: string): {
+    ok: true;
+} | {
+    ok: false;
+    code: 'TARGET_NOT_FOUND' | 'NOT_LATEST';
+};
+/**
+ * Replace the latest persisted user turn with a durable queued input.
+ * Transcript deletion and input insertion share one SQLite transaction so a
+ * failed enqueue cannot leave the conversation without the original turn.
+ */
+export declare function replaceLatestSessionTurnAndQueueInput(input: ReplaceLatestSessionTurnInput): ReplaceLatestSessionTurnResult;

package/dist/src/storage/sqlite/session-turn-replace-repository.js

@@ -0,0 +1,110 @@
+import { getXopcDatabase } from "./connection.js";
+import { runSqliteWriteTransaction } from "./transaction.js";
+import { buildSessionContextForLlm, buildSessionDisplayMessages } from "../../session/session-context-for-llm.js";
+import { estimateTokensFromMessages, transcriptEntryRowToStoredRow } from "./row-mappers.js";
+import { randomUUID } from "node:crypto";
+//#region src/storage/sqlite/session-turn-replace-repository.ts
+function isUserRow(row) {
+	return row.role === "user";
+}
+function rowTurnId(row) {
+	const value = row.turnId;
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function validateTargetRows(rows, targetTurnId) {
+	const targetIndex = rows.findIndex((row) => row.role === "user" && rowTurnId(row) === targetTurnId);
+	if (targetIndex < 0) return {
+		ok: false,
+		code: "TARGET_NOT_FOUND"
+	};
+	if (rows.slice(targetIndex + 1).some(isUserRow)) return {
+		ok: false,
+		code: "NOT_LATEST"
+	};
+	return {
+		ok: true,
+		targetIndex
+	};
+}
+/** Validate before aborting a run; the transactional mutation validates again. */
+function validateLatestSessionTurnTarget(sessionKey, targetTurnId) {
+	const { db } = getXopcDatabase();
+	const session = db.prepare(`SELECT session_id FROM sessions WHERE session_key = ?`).get(sessionKey);
+	if (!session) return {
+		ok: false,
+		code: "TARGET_NOT_FOUND"
+	};
+	const result = validateTargetRows(db.prepare(`SELECT entry_id, session_id, seq, entry_kind, role, payload_json, created_at
+       FROM transcript_entries WHERE session_id = ? ORDER BY seq ASC`).all(session.session_id).map(transcriptEntryRowToStoredRow), targetTurnId);
+	return result.ok ? { ok: true } : result;
+}
+/**
+* Replace the latest persisted user turn with a durable queued input.
+* Transcript deletion and input insertion share one SQLite transaction so a
+* failed enqueue cannot leave the conversation without the original turn.
+*/
+function replaceLatestSessionTurnAndQueueInput(input) {
+	return runSqliteWriteTransaction((db) => {
+		const existing = db.prepare(`SELECT id FROM session_inputs WHERE session_key = ? AND client_message_id = ?`).get(input.sessionKey, input.clientMessageId);
+		if (existing) return {
+			ok: true,
+			idempotent: true,
+			inputId: existing.id,
+			removedMessages: [],
+			remainingMessages: []
+		};
+		const session = db.prepare(`SELECT session_id FROM sessions WHERE session_key = ?`).get(input.sessionKey);
+		if (!session) return {
+			ok: false,
+			code: "TARGET_NOT_FOUND"
+		};
+		db.prepare(`INSERT INTO session_input_runtime(session_key, revision, updated_at_ms)
+       VALUES (?, 0, ?) ON CONFLICT(session_key) DO NOTHING`).run(input.sessionKey, Date.now());
+		const runtime = db.prepare(`SELECT active_run_id FROM session_input_runtime WHERE session_key = ?`).get(input.sessionKey);
+		const pending = db.prepare(`SELECT 1 AS found FROM session_inputs
+         WHERE session_key = ? AND status IN ('queued', 'running', 'injecting', 'interrupted')
+         LIMIT 1`).get(input.sessionKey);
+		if (runtime?.active_run_id || pending) return {
+			ok: false,
+			code: "SESSION_BUSY"
+		};
+		const entries = db.prepare(`SELECT entry_id, session_id, seq, entry_kind, role, payload_json, created_at
+         FROM transcript_entries WHERE session_id = ? ORDER BY seq ASC`).all(session.session_id);
+		const target = validateTargetRows(entries.map(transcriptEntryRowToStoredRow), input.targetTurnId);
+		if (target.ok === false) return target;
+		const targetSeq = entries[target.targetIndex].seq;
+		const removedEntries = entries.filter((entry) => entry.seq >= targetSeq && entry.entry_kind !== "compaction");
+		const remainingEntries = entries.filter((entry) => entry.seq < targetSeq && entry.entry_kind !== "compaction");
+		const deleteEntries = entries.filter((entry) => entry.seq >= targetSeq || entry.entry_kind === "compaction");
+		const removedRows = removedEntries.map(transcriptEntryRowToStoredRow);
+		const remainingRows = remainingEntries.map(transcriptEntryRowToStoredRow);
+		const deleteFts = db.prepare(`DELETE FROM transcript_fts WHERE entry_id = ?`);
+		const deleteEntry = db.prepare(`DELETE FROM transcript_entries WHERE entry_id = ?`);
+		for (const entry of deleteEntries) {
+			deleteFts.run(entry.entry_id);
+			deleteEntry.run(entry.entry_id);
+		}
+		const llm = buildSessionContextForLlm(remainingRows);
+		const now = Date.now();
+		db.prepare(`UPDATE sessions SET message_count = ?, estimated_tokens = ?, compacted_count = 0,
+       updated_at = ?, last_accessed_at = ?, last_interaction_at = ? WHERE session_key = ?`).run(llm.length, estimateTokensFromMessages(llm), now, now, now, input.sessionKey);
+		const maxPosition = db.prepare(`SELECT COALESCE(MAX(position), 0) AS value FROM session_inputs
+         WHERE session_key = ? AND status IN ('queued', 'running', 'injecting', 'interrupted')`).get(input.sessionKey);
+		const inputId = randomUUID();
+		db.prepare(`INSERT INTO session_inputs(id, session_key, client_message_id,
+       requested_delivery, effective_delivery, status, content, attachments_json,
+       thinking, origin_json, position, target_run_id, version, created_at_ms, updated_at_ms)
+       VALUES (?, ?, ?, 'next', 'next', 'queued', ?, ?, ?, ?, ?, NULL, 1, ?, ?)`).run(inputId, input.sessionKey, input.clientMessageId, input.content, input.attachments ? JSON.stringify(input.attachments) : null, input.thinking ?? null, JSON.stringify(input.origin), maxPosition.value + 1, now, now);
+		db.prepare(`UPDATE session_input_runtime SET revision = revision + 1, updated_at_ms = ?
+       WHERE session_key = ?`).run(now, input.sessionKey);
+		return {
+			ok: true,
+			idempotent: false,
+			inputId,
+			removedMessages: buildSessionDisplayMessages(removedRows),
+			remainingMessages: buildSessionDisplayMessages(remainingRows)
+		};
+	});
+}
+//#endregion
+export { replaceLatestSessionTurnAndQueueInput, validateLatestSessionTurnTarget };

package/dist/src/storage/sqlite/transcript-repository.js

@@ -1,7 +1,7 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { escapeFts5Query } from "./fts.js";
 import { buildSessionContextForLlm, isRuntimeOnlyTranscriptMessage } from "../../session/session-context-for-llm.js";
 import { classifyStoredRow, estimateTokensFromMessages, extractFtsContent, transcriptEntryRowToStoredRow } from "./row-mappers.js";
-import { escapeFts5Query } from "./fts.js";
 import { getCurrentSessionId, readCurrentSessionId } from "./session-repository.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/transcript-repository.ts

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

@@ -27,6 +27,13 @@ export type UserUnderstandingQualityMetrics = {
         helpfulRate: number | null;
     };
 };
+export type UnderstandingFeedbackSummary = {
+    understandingId: string;
+    helpful: number;
+    irrelevant: number;
+    total: number;
+};
+export declare function summarizeUnderstandingFeedback(understandingIds: string[]): UnderstandingFeedbackSummary[];
 export declare function summarizeUserUnderstandingQuality(options?: {
     windowDays?: number;
     agingCandidateDays?: number;

package/dist/src/storage/sqlite/user-context-quality-repository.js

@@ -1,6 +1,30 @@
 import { getSqliteDatabase } from "./transaction.js";
 import { USER_CONTEXT_PRINCIPAL_ID } from "../../user-context/domain.js";
 //#region src/storage/sqlite/user-context-quality-repository.ts
+function summarizeUnderstandingFeedback(understandingIds) {
+	const ids = [...new Set(understandingIds.filter(Boolean))].slice(0, 1e3);
+	if (!ids.length) return [];
+	const rows = getSqliteDatabase().prepare(`
+    SELECT object_id, rating, COUNT(*) AS count
+    FROM context_feedback
+    WHERE object_type = 'understanding' AND object_id IN (${ids.map(() => "?").join(", ")})
+    GROUP BY object_id, rating
+  `).all(...ids);
+	const summaries = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const current = summaries.get(row.object_id) ?? {
+			understandingId: row.object_id,
+			helpful: 0,
+			irrelevant: 0,
+			total: 0
+		};
+		if (row.rating === "helpful") current.helpful += row.count;
+		if (row.rating === "irrelevant") current.irrelevant += row.count;
+		current.total += row.count;
+		summaries.set(row.object_id, current);
+	}
+	return [...summaries.values()];
+}
 function rate(numerator, denominator) {
 	return denominator > 0 ? Math.round(numerator / denominator * 1e4) / 1e4 : null;
 }
@@ -71,4 +95,4 @@ function summarizeUserUnderstandingQuality(options = {}) {
 	};
 }
 //#endregion
-export { summarizeUserUnderstandingQuality };
+export { summarizeUnderstandingFeedback, summarizeUserUnderstandingQuality };

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

@@ -10,6 +10,10 @@ export type CreateUnderstandingInput = Omit<UserUnderstanding, 'id' | 'versionId
 export declare function createUnderstanding(input: CreateUnderstandingInput, principalId?: string): UserUnderstanding;
 export declare function getUnderstanding(id: string): UserUnderstanding | undefined;
 export declare function listUnderstandings(statuses?: UnderstandingStatus[], principalId?: string): UserUnderstanding[];
+export declare function searchActiveUnderstandings(query: string, limit?: number): Array<{
+    understanding: UserUnderstanding;
+    score: number;
+}>;
 export declare function reviseUnderstanding(id: string, statement: string, options: {
     payload?: Record<string, unknown>;
     canonicalKey?: string;

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

@@ -1,5 +1,7 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
 import { USER_CONTEXT_PRINCIPAL_ID } from "../../user-context/domain.js";
+import { retrievalQueryAuditValue } from "../../retrieval/audit.js";
+import { buildFts5SearchQuery, fts5RankToScore } from "./fts.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/user-context-repository.ts
 const UNDERSTANDING_SELECT = `
@@ -132,6 +134,29 @@ function listUnderstandings(statuses, principalId = USER_CONTEXT_PRINCIPAL_ID) {
 	const placeholders = statuses.map(() => "?").join(", ");
 	return db.prepare(`${UNDERSTANDING_SELECT} WHERE u.principal_id = ? AND u.status IN (${placeholders}) ORDER BY u.updated_at DESC`).all(principalId, ...statuses).map(understandingFromRow);
 }
+function searchActiveUnderstandings(query, limit = 50) {
+	const ftsQuery = buildFts5SearchQuery(query);
+	if (!ftsQuery) return [];
+	const boundedLimit = Math.max(1, Math.min(200, Math.floor(limit)));
+	const rows = getSqliteDatabase().prepare(`
+    SELECT u.*, v.statement, v.payload_json, bm25(user_understanding_fts) AS search_rank
+    FROM user_understanding_fts
+    JOIN user_understandings u
+      ON u.understanding_id = user_understanding_fts.understanding_id
+    JOIN user_understanding_versions v
+      ON v.version_id = u.current_version_id
+    WHERE user_understanding_fts MATCH ? AND u.principal_id = ? AND u.status = 'active'
+    ORDER BY search_rank
+    LIMIT ?
+  `).all(ftsQuery, USER_CONTEXT_PRINCIPAL_ID, boundedLimit);
+	if (!rows.length) return [];
+	const bestRank = Math.min(...rows.map((row) => row.search_rank));
+	const worstRank = Math.max(...rows.map((row) => row.search_rank));
+	return rows.map((row) => ({
+		understanding: understandingFromRow(row),
+		score: fts5RankToScore(row.search_rank, bestRank, worstRank)
+	}));
+}
 function reviseUnderstanding(id, statement, options) {
 	const current = getUnderstanding(id);
 	if (!current) throw new Error(`User understanding not found: ${id}`);
@@ -282,16 +307,17 @@ function listUnderstandingEvidence(understandingId, relation) {
 	}));
 }
 function recordContextRun(input) {
+	const auditedQuery = retrievalQueryAuditValue(input.query);
 	const existing = getSqliteDatabase().prepare("SELECT context_run_id FROM context_runs WHERE turn_id = ?").get(input.turnId);
 	const runId = existing?.context_run_id ?? randomUUID();
 	runSqliteWriteTransaction((db) => {
 		if (existing) {
 			db.prepare(`UPDATE context_runs SET principal_id = ?, session_key = ?, query = ?, budget = ?, duration_ms = ?
-        WHERE context_run_id = ?`).run(input.principalId ?? "local-owner", input.sessionKey, input.query, input.budget, input.durationMs, runId);
+        WHERE context_run_id = ?`).run(input.principalId ?? "local-owner", input.sessionKey, auditedQuery, input.budget, input.durationMs, runId);
 			db.prepare("DELETE FROM context_run_items WHERE context_run_id = ?").run(runId);
 		} else db.prepare(`INSERT INTO context_runs (
         context_run_id, principal_id, turn_id, session_key, query, budget, duration_ms, created_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(runId, input.principalId ?? "local-owner", input.turnId, input.sessionKey, input.query, input.budget, input.durationMs, Date.now());
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(runId, input.principalId ?? "local-owner", input.turnId, input.sessionKey, auditedQuery, input.budget, input.durationMs, Date.now());
 		const insert = db.prepare(`INSERT INTO context_run_items (
       context_run_id, object_type, object_id, version_id, decision, reason, content_snapshot,
       source_label, rank, score, injected_chars
@@ -380,4 +406,4 @@ function decideContextConsent(id, decision) {
 	return Number(result.changes) > 0;
 }
 //#endregion
-export { consumeContextConsent, createCollaborationRule, createContextEvidence, createUnderstanding, decideContextConsent, deleteCollaborationRule, deleteUnderstanding, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, linkUnderstandingEvidence, listCollaborationRules, listUnderstandingEvidence, listUnderstandings, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile };
+export { 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 };