@xopcai/xopc 0.0.227 → 0.0.229

package/dist/src/agent/background-review/run-background-review.js

@@ -1,54 +1,60 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { UNDERSTANDING_KINDS } from "../../user-context/domain.js";
 import { finishContextExtractionRun } from "../../storage/sqlite/context-extraction-repository.js";
-import { createContextEvidence } from "../../storage/sqlite/user-context-repository.js";
-import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
+import { getTurnPersonalization } from "../../storage/sqlite/user-context-repository.js";
 import { loadCompactionSourceSnapshot } from "../../storage/sqlite/transcript-repository.js";
 import "../../storage/sqlite/index.js";
+import { extractProfileAgentId } from "../../config/agent-profile.js";
 import { init_sync_provider_auth, resolveProviderApiKeySync } from "../../auth/sync-provider-auth.js";
-import { getApiKeySync, init_providers } from "../../providers/index.js";
+import { getApiKeySync, init_providers, resolveModel } from "../../providers/index.js";
 import { createExtensionAwareStreamFn } from "../../providers/extension-stream-bridge.js";
 import { extractTextContent } from "../context/workspace.js";
 import { readAgentMessageContent } from "../memory/agent-message-access.js";
 import { resolveAgentTurnTimeoutMs, runAgentTurnWithTimeout } from "../orchestration/run-agent-turn-with-timeout.js";
-import { claimRegisteredExtraction, extractionInputHash } from "../../user-context/extraction/registry.js";
-import { isDurableUnderstandingCandidate } from "../../user-context/understandingQuality.js";
+import { resolveTypedModelRef } from "../../config/agent-typed-models.js";
+import { claimRegisteredExtraction } from "../../user-context/extraction/registry.js";
 import { isAssistantTurnAborted, isAssistantTurnFailed } from "../orchestration/llm-turn-retry.js";
-import { MEMORY_REVIEW_USER_PROMPT, UNDERSTANDING_REVIEW_SYSTEM_PROMPT } from "./prompts.js";
+import { emptyUnderstandingReview, executeUnderstandingInterpretation } from "../../user-context/extraction/executor.js";
+import { parseSemanticUnderstanding } from "../../user-context/extraction/semantic.js";
+import { UNDERSTANDING_INTERPRETER_SYSTEM_PROMPT, buildUnderstandingInterpreterPrompt } from "./prompts.js";
 import { Agent } from "@earendil-works/pi-agent-core";
 //#region src/agent/background-review/run-background-review.ts
 init_sync_provider_auth();
 init_providers();
 init_logger();
-const log = createLogger("BackgroundReview");
+const log = createLogger("UnderstandingInterpreter");
 function isReviewMessage(value) {
 	if (!value || typeof value !== "object") return false;
 	const role = value.role;
 	return role === "user" || role === "assistant";
 }
-function tagMessage(message, entryId) {
-	const copy = JSON.parse(JSON.stringify(message));
-	const tag = `[evidence_ref:${entryId}]\n`;
-	const messageContent = readAgentMessageContent(copy);
-	if (typeof messageContent === "string") return {
+function messageText(message) {
+	const content = readAgentMessageContent(message);
+	if (typeof content === "string") return content;
+	return Array.isArray(content) ? extractTextContent(content) : "";
+}
+function tagMessage(entry) {
+	const copy = JSON.parse(JSON.stringify(entry.message));
+	const tag = `[evidence_ref:${entry.ref}] [role:${entry.role}]\n`;
+	const content = readAgentMessageContent(copy);
+	if (typeof content === "string") return {
 		...copy,
-		content: `${tag}${messageContent}`
+		content: `${tag}${content}`
 	};
-	if (Array.isArray(messageContent)) {
-		const content = [...messageContent];
-		const first = content[0];
-		if (first?.type === "text") content[0] = {
+	if (Array.isArray(content)) {
+		const parts = [...content];
+		const first = parts[0];
+		if (first?.type === "text") parts[0] = {
 			...first,
 			text: `${tag}${first.text ?? ""}`
 		};
-		else content.unshift({
+		else parts.unshift({
 			type: "text",
 			text: tag
 		});
 		return {
 			...copy,
-			content
+			content: parts
 		};
 	}
 	return copy;
@@ -56,89 +62,75 @@ function tagMessage(message, entryId) {
 function loadEvidenceMessages(sessionKey, max) {
 	const snapshot = loadCompactionSourceSnapshot(sessionKey);
 	if (!snapshot) return [];
-	return snapshot.entries.filter((entry) => isReviewMessage(entry.row)).slice(-max).map((entry) => ({
-		entryId: entry.entryId,
-		createdAt: entry.createdAt,
-		message: entry.row
-	}));
+	return snapshot.entries.filter((entry) => isReviewMessage(entry.row)).slice(-max).map((entry) => {
+		const message = entry.row;
+		return {
+			ref: entry.entryId,
+			role: message.role,
+			text: messageText(message),
+			createdAt: entry.createdAt,
+			message
+		};
+	});
 }
-const ALLOWED_UNDERSTANDING_KINDS = new Set(UNDERSTANDING_KINDS);
-const ALLOWED_SENSITIVITIES = new Set([
-	"normal",
-	"personal",
-	"secret",
-	"regulated"
-]);
 function lastAssistantText(agent) {
-	for (let i = agent.state.messages.length - 1; i >= 0; i--) {
+	for (let i = agent.state.messages.length - 1; i >= 0; i -= 1) {
 		const message = agent.state.messages[i];
-		if (message.role !== "assistant") continue;
-		return Array.isArray(message.content) ? extractTextContent(message.content) : String(message.content);
+		if (message.role === "assistant") return messageText(message);
 	}
 	return "";
 }
-function parseBackgroundCandidates(raw) {
-	const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(raw)?.[1];
-	const start = raw.indexOf("{");
-	const end = raw.lastIndexOf("}");
-	const candidateJson = fenced ?? (start >= 0 && end > start ? raw.slice(start, end + 1) : raw);
+function isLocalModel(model) {
+	if (["ollama", "lmstudio"].includes(model.provider)) return true;
 	try {
-		const parsed = JSON.parse(candidateJson);
-		if (!Array.isArray(parsed.candidates)) return [];
-		const output = [];
-		for (const value of parsed.candidates.slice(0, 8)) {
-			if (!value || typeof value !== "object") continue;
-			const item = value;
-			if (!ALLOWED_UNDERSTANDING_KINDS.has(item.kind)) continue;
-			if (typeof item.content !== "string" || item.content.trim().length < 4) continue;
-			const kind = item.kind;
-			if (!isDurableUnderstandingCandidate(kind, item.content)) continue;
-			const confidence = typeof item.confidence === "number" ? item.confidence : .65;
-			const importance = typeof item.importance === "number" ? item.importance : .5;
-			const durability = item.durability === "ephemeral" || item.durability === "recurring" ? item.durability : "durable";
-			const sensitivity = ALLOWED_SENSITIVITIES.has(item.sensitivity) ? item.sensitivity : "personal";
-			const disclosurePolicy = item.disclosurePolicy === "silent" || item.disclosurePolicy === "ask_before_reference" ? item.disclosurePolicy : "referenceable";
-			const evidenceRefs = Array.isArray(item.evidenceRefs) ? [...new Set(item.evidenceRefs.filter((value) => typeof value === "string" && value.trim().length > 0))] : [];
-			output.push({
-				kind,
-				content: item.content.trim(),
-				confidence: Math.max(0, Math.min(1, confidence)),
-				importance: Math.max(0, Math.min(1, importance)),
-				explicitness: "inferred",
-				durability,
-				sensitivity,
-				disclosurePolicy,
-				evidenceRefs
-			});
-		}
-		return output;
+		const hostname = new URL(model.baseUrl).hostname;
+		return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
 	} catch {
-		return [];
+		return false;
 	}
 }
-function parseUnderstandingCandidates(raw) {
-	return parseBackgroundCandidates(raw).map(({ evidenceRefs: _evidenceRefs, ...candidate }) => candidate);
-}
-async function runUnderstandingReview(params) {
-	const { sessionKey, mainAgent, settings, memoryManager, getConfig } = params;
-	const evidenceMessages = loadEvidenceMessages(sessionKey, settings.maxHistoryMessages);
-	if (!evidenceMessages.length) {
-		log.debug({ sessionKey }, "User-understanding review skipped because no persisted evidence was available");
-		return;
+function resolveInterpreterRuntime(params) {
+	const config = params.getConfig();
+	const processingPolicy = config?.userContext.understanding.processingPolicy ?? "remote_allowed";
+	let model;
+	if (config) {
+		const agentId = extractProfileAgentId(params.sessionKey, config);
+		for (const role of ["understanding", "small"]) {
+			const ref = resolveTypedModelRef(config, agentId, role);
+			if (!ref) continue;
+			try {
+				model = resolveModel(ref);
+				break;
+			} catch (err) {
+				log.debug({
+					err,
+					agentId,
+					role,
+					modelRef: ref
+				}, "Configured understanding model could not be resolved");
+			}
+		}
 	}
-	const lastEvidence = evidenceMessages[evidenceMessages.length - 1];
-	const extraction = claimRegisteredExtraction({
-		extractorId: "transcript-synthesis",
-		sourceRef: `session:${sessionKey}:window:${evidenceMessages[0].entryId}:${lastEvidence.entryId}`,
-		contentForHash: evidenceMessages.map((entry) => entry.entryId).join("\n"),
-		processingPolicy: "remote_allowed",
-		destination: "remote_model"
-	});
-	if (!extraction.shouldExecute) return;
+	model ??= params.mainAgent.state.model;
+	if (processingPolicy === "local_only" && !isLocalModel(model)) {
+		log.debug({
+			sessionKey: params.sessionKey,
+			provider: model.provider,
+			modelId: model.id
+		}, "Understanding interpretation skipped because no local model is configured");
+		return null;
+	}
+	return {
+		model,
+		processingPolicy,
+		destination: isLocalModel(model) ? "local_model" : "remote_model"
+	};
+}
+async function interpret(params) {
 	const reviewAgent = new Agent({
 		initialState: {
-			systemPrompt: UNDERSTANDING_REVIEW_SYSTEM_PROMPT,
-			model: mainAgent.state.model,
+			systemPrompt: UNDERSTANDING_INTERPRETER_SYSTEM_PROMPT,
+			model: params.model,
 			thinkingLevel: "off",
 			tools: [],
 			messages: []
@@ -146,79 +138,71 @@ async function runUnderstandingReview(params) {
 		streamFn: createExtensionAwareStreamFn(),
 		getApiKey: (provider) => resolveProviderApiKeySync(provider) ?? getApiKeySync(provider) ?? ""
 	});
-	reviewAgent.state.messages = evidenceMessages.map((entry) => tagMessage(entry.message, entry.entryId));
-	const timeoutMs = Math.min(settings.maxDurationMs, resolveAgentTurnTimeoutMs(getConfig()));
+	reviewAgent.state.messages = params.evidence.map(tagMessage);
 	try {
 		await runAgentTurnWithTimeout(reviewAgent, async () => {
 			await reviewAgent.prompt({
 				role: "user",
-				content: MEMORY_REVIEW_USER_PROMPT,
+				content: buildUnderstandingInterpreterPrompt({
+					mode: params.mode,
+					availableTargets: params.availableTargets
+				}),
 				timestamp: Date.now()
 			});
 			await reviewAgent.waitForIdle();
-		}, timeoutMs);
+		}, Math.min(params.timeoutMs, resolveAgentTurnTimeoutMs(params.getConfig())));
 	} catch (err) {
 		log.warn({
 			err,
-			sessionKey
-		}, "User-understanding review failed or timed out");
+			sessionKey: params.sessionKey
+		}, "User-understanding interpretation failed or timed out");
 		reviewAgent.abort();
 		await reviewAgent.waitForIdle().catch(() => {});
-		finishContextExtractionRun({
-			runId: extraction.run.id,
-			status: "failed",
-			errorCode: "model_failed"
-		});
-		return;
+		return null;
 	}
-	if (isAssistantTurnAborted(reviewAgent) || isAssistantTurnFailed(reviewAgent)) {
+	if (isAssistantTurnAborted(reviewAgent) || isAssistantTurnFailed(reviewAgent)) return null;
+	return parseSemanticUnderstanding(lastAssistantText(reviewAgent), params.evidence, params.availableTargets.map((item) => item.id));
+}
+async function executeReview(params) {
+	const runtime = resolveInterpreterRuntime(params);
+	if (!runtime) return emptyUnderstandingReview();
+	const extraction = claimRegisteredExtraction({
+		extractorId: params.extractorId,
+		sourceRef: params.sourceRef,
+		contentForHash: params.contentForHash,
+		processingPolicy: runtime.processingPolicy,
+		destination: runtime.destination
+	});
+	if (!extraction.shouldExecute) return emptyUnderstandingReview();
+	const interpretation = await interpret({
+		...params,
+		model: runtime.model
+	});
+	if (!interpretation) {
 		finishContextExtractionRun({
 			runId: extraction.run.id,
 			status: "failed",
-			errorCode: "model_failed"
+			errorCode: "model_or_schema_failed"
 		});
-		return;
+		return emptyUnderstandingReview();
 	}
-	const candidates = parseBackgroundCandidates(lastAssistantText(reviewAgent));
-	let applied = 0;
 	try {
-		const evidenceByRef = new Map(evidenceMessages.map((entry) => [entry.entryId, entry]));
-		const projectId = getSessionMetadata(sessionKey)?.projectId;
-		const outputs = [];
-		for (const { evidenceRefs, ...candidate } of candidates) {
-			const referenced = evidenceRefs.flatMap((ref) => {
-				const entry = evidenceByRef.get(ref);
-				return entry ? [entry] : [];
-			});
-			if (!referenced.length) {
-				outputs.push({
-					candidateKey: `${candidate.kind}:${candidate.content}`,
-					outcome: "rejected"
-				});
-				continue;
-			}
-			const evidenceIds = referenced.map((entry) => createContextEvidence({
-				sourceType: "conversation",
-				sourceRef: `session:${sessionKey}:entry:${entry.entryId}`,
-				sourceRunId: extraction.run.id,
-				sessionId: sessionKey,
-				messageId: entry.entryId,
-				contentHash: extractionInputHash(JSON.stringify(entry.message)),
-				retentionPolicy: "derived_only",
-				processingPolicy: "remote_allowed",
-				extractorId: "transcript-synthesis",
-				extractorVersion: "1",
-				trustLevel: "owner",
-				observedAt: entry.createdAt
-			}).id);
-			const result = await memoryManager.applyUnderstandingCandidates([candidate], {
-				sessionKey,
-				...projectId ? { projectId } : {},
-				evidenceIds,
-				reviewSource: "background",
-				extractionRunId: extraction.run.id
-			});
-			outputs.push(...(result.writeOutputs ?? []).map((output) => ({
+		const result = await executeUnderstandingInterpretation({
+			interpretation,
+			evidence: params.evidence,
+			extractionRunId: extraction.run.id,
+			extractorId: params.extractorId,
+			sessionKey: params.sessionKey,
+			...params.turnId ? { turnId: params.turnId } : {},
+			memoryManager: params.memoryManager,
+			getConfig: params.getConfig,
+			reviewSource: params.mode === "turn" ? "turn" : "background",
+			processingPolicy: runtime.processingPolicy
+		});
+		finishContextExtractionRun({
+			runId: extraction.run.id,
+			status: "completed",
+			outputs: result.writeOutputs?.map((output) => ({
 				candidateKey: output.candidateKey,
 				...output.objectId ? {
 					objectType: "understanding",
@@ -226,30 +210,61 @@ async function runUnderstandingReview(params) {
 				} : {},
 				...output.versionId ? { versionId: output.versionId } : {},
 				outcome: output.outcome
-			})));
-			applied += 1;
-		}
-		finishContextExtractionRun({
-			runId: extraction.run.id,
-			status: "completed",
-			outputs
+			}))
 		});
-	} catch (error) {
+		return result;
+	} catch (err) {
 		finishContextExtractionRun({
 			runId: extraction.run.id,
 			status: "failed",
 			errorCode: "write_failed"
 		});
-		throw error;
+		throw err;
 	}
-	log.debug({
-		sessionKey,
-		candidateCount: candidates.length,
-		applied
-	}, "User-understanding review completed");
+}
+async function runTurnUnderstandingReview(params) {
+	const evidence = loadEvidenceMessages(params.sessionKey, params.maxHistoryMessages ?? 12);
+	if (!evidence.length) return emptyUnderstandingReview();
+	const availableTargets = getTurnPersonalization(params.turnId)?.items.flatMap((item) => {
+		if (item.objectType !== "understanding" || item.decision !== "selected") return [];
+		return [{
+			id: item.objectId,
+			statement: item.content
+		}];
+	}) ?? [];
+	return executeReview({
+		sessionKey: params.sessionKey,
+		mainAgent: params.mainAgent,
+		memoryManager: params.memoryManager,
+		getConfig: params.getConfig,
+		evidence,
+		mode: "turn",
+		extractorId: "turn-semantics",
+		sourceRef: `session:${params.sessionKey}:turn:${params.turnId}`,
+		contentForHash: params.userText,
+		availableTargets,
+		timeoutMs: 3e4,
+		turnId: params.turnId
+	});
 }
 async function runBackgroundReviewTurn(params) {
-	await runUnderstandingReview(params);
+	const evidence = loadEvidenceMessages(params.sessionKey, params.settings.maxHistoryMessages);
+	if (!evidence.length) return;
+	const first = evidence[0];
+	const last = evidence[evidence.length - 1];
+	await executeReview({
+		sessionKey: params.sessionKey,
+		mainAgent: params.mainAgent,
+		memoryManager: params.memoryManager,
+		getConfig: params.getConfig,
+		evidence,
+		mode: "transcript",
+		extractorId: "transcript-synthesis",
+		sourceRef: `session:${params.sessionKey}:window:${first.ref}:${last.ref}`,
+		contentForHash: evidence.map((entry) => entry.ref).join("\n"),
+		availableTargets: [],
+		timeoutMs: params.settings.maxDurationMs
+	});
 }
 //#endregion
-export { parseUnderstandingCandidates, runBackgroundReviewTurn };
+export { runBackgroundReviewTurn, runTurnUnderstandingReview };

package/dist/src/agent/lifecycle/timeout-wrapper.d.ts

@@ -14,6 +14,7 @@ export interface TimeoutConfig {
     networkTimeoutMs: number;
     gracefulShutdownMs: number;
 }
+export declare const DEFAULT_TOOL_EXECUTION_TIMEOUT_MS: number;
 declare const DEFAULT_CONFIG: TimeoutConfig;
 export interface TimeoutResult<T> {
     success: boolean;

package/dist/src/agent/lifecycle/timeout-wrapper.js

@@ -3,12 +3,13 @@ import { init_logger } from "../../utils/logger.js";
 //#region src/agent/lifecycle/timeout-wrapper.ts
 init_logger();
 const log = createLogger("TimeoutWrapper");
+const DEFAULT_TOOL_EXECUTION_TIMEOUT_MS = 1800 * 1e3;
 const DEFAULT_CONFIG = {
-	defaultTimeoutMs: 300 * 1e3,
-	shellTimeoutMs: 300 * 1e3,
-	readTimeoutMs: 30 * 1e3,
-	writeTimeoutMs: 60 * 1e3,
-	networkTimeoutMs: 60 * 1e3,
+	defaultTimeoutMs: DEFAULT_TOOL_EXECUTION_TIMEOUT_MS,
+	shellTimeoutMs: DEFAULT_TOOL_EXECUTION_TIMEOUT_MS,
+	readTimeoutMs: DEFAULT_TOOL_EXECUTION_TIMEOUT_MS,
+	writeTimeoutMs: DEFAULT_TOOL_EXECUTION_TIMEOUT_MS,
+	networkTimeoutMs: DEFAULT_TOOL_EXECUTION_TIMEOUT_MS,
 	gracefulShutdownMs: 5e3
 };
 /**
@@ -254,4 +255,4 @@ var TimeoutManager = class {
 	}
 };
 //#endregion
-export { DEFAULT_CONFIG as DEFAULT_TIMEOUT_CONFIG, TimeoutError, TimeoutManager, executeWithTimeout, executeWithTimeoutResult, withTimeout };
+export { DEFAULT_CONFIG as DEFAULT_TIMEOUT_CONFIG, DEFAULT_TOOL_EXECUTION_TIMEOUT_MS, TimeoutError, TimeoutManager, executeWithTimeout, executeWithTimeoutResult, withTimeout };

package/dist/src/agent/mcp/mcp-transport-config.d.ts

@@ -23,6 +23,6 @@ export type ResolvedHttpMcpTransportConfig = ResolvedBaseMcpTransportConfig & {
     };
 };
 export type ResolvedMcpTransportConfig = ResolvedStdioMcpTransportConfig | ResolvedHttpMcpTransportConfig;
-export declare const DEFAULT_MCP_REQUEST_TIMEOUT_MS = 60000;
+export declare const DEFAULT_MCP_REQUEST_TIMEOUT_MS: number;
 export declare function resolveMcpTransportConfig(serverName: string, rawServer: unknown): ResolvedMcpTransportConfig | null;
 export {};

package/dist/src/agent/mcp/mcp-transport-config.js

@@ -10,7 +10,7 @@ init_logger();
 init_string_coerce();
 const log = createLogger("Mcp:Bundle");
 const DEFAULT_CONNECTION_TIMEOUT_MS = 3e4;
-const DEFAULT_MCP_REQUEST_TIMEOUT_MS = 6e4;
+const DEFAULT_MCP_REQUEST_TIMEOUT_MS = 1800 * 1e3;
 function getConnectionTimeoutMs(rawServer) {
 	if (rawServer && typeof rawServer === "object" && typeof rawServer.connectionTimeoutMs === "number" && rawServer.connectionTimeoutMs > 0) return rawServer.connectionTimeoutMs;
 	return DEFAULT_CONNECTION_TIMEOUT_MS;

package/dist/src/agent/memory/index.d.ts

@@ -5,7 +5,7 @@ export type { UserContextPlan } from './context/types.js';
 export { createMemoryManagerFromConfig } from './create-memory-manager.js';
 export { isMemorySubsystemEnabled, shouldPlanUserContextThisTurn, } from './memory-config.js';
 export { MemoryManager } from './manager.js';
-export { UserUnderstandingService, extractExplicitUnderstandingCandidates } from './understanding/service.js';
+export { UserUnderstandingService } from './understanding/service.js';
 export type { UnderstandingCandidate, UnderstandingReviewResult } from './understanding/types.js';
 export { discoverMemoryPlugins } from './plugin-discovery.js';
 export type { MemoryPluginMetadata } from './plugin-discovery.js';

package/dist/src/agent/memory/index.js

@@ -3,9 +3,9 @@ import { buildUserContextBlock, sanitizeUserContextFenceEscapes } from "./contex
 import { UserContextPlanner } from "../../user-context/planner.js";
 import { extractAgentUserPlainText } from "./user-message-text.js";
 import { BuiltinMemoryProvider } from "./builtin-provider.js";
-import { UserUnderstandingService, extractExplicitUnderstandingCandidates } from "./understanding/service.js";
+import { UserUnderstandingService } from "./understanding/service.js";
 import { MemoryManager } from "./manager.js";
 import { discoverMemoryPlugins } from "./plugin-discovery.js";
 import { createMemoryManagerFromConfig } from "./create-memory-manager.js";
 import { StubMemoryProvider } from "./stub-memory-provider.js";
-export { BuiltinMemoryProvider, MemoryManager, StubMemoryProvider, UserContextPlanner, UserUnderstandingService, buildUserContextBlock, createMemoryManagerFromConfig, discoverMemoryPlugins, extractAgentUserPlainText, extractExplicitUnderstandingCandidates, isMemorySubsystemEnabled, sanitizeUserContextFenceEscapes, shouldPlanUserContextThisTurn };
+export { BuiltinMemoryProvider, MemoryManager, StubMemoryProvider, UserContextPlanner, UserUnderstandingService, buildUserContextBlock, createMemoryManagerFromConfig, discoverMemoryPlugins, extractAgentUserPlainText, isMemorySubsystemEnabled, sanitizeUserContextFenceEscapes, shouldPlanUserContextThisTurn };

package/dist/src/agent/memory/manager.d.ts

@@ -39,17 +39,6 @@ export declare class MemoryManager {
     queuePrefetchAll(query: string, options?: {
         sessionId?: string;
     }): void;
-    syncAll(userContent: string, assistantContent: string, options?: {
-        sessionId?: string;
-    }): Promise<void>;
-    captureTurnUnderstanding(userContent: string, assistantContent: string, options?: {
-        agentId?: string;
-        sessionId?: string;
-        turnId?: string;
-        workspaceId?: string;
-        projectId?: string;
-        correctionTargetRecordIds?: string[];
-    }): Promise<import('./understanding/types.js').UnderstandingReviewResult>;
     syncProvidersForTurn(userContent: string, assistantContent: string, options?: {
         sessionId?: string;
         turnId?: string;
@@ -67,6 +56,7 @@ export declare class MemoryManager {
         source?: MemoryRecord['source'];
         reviewSource?: 'turn' | 'background';
         extractionRunId?: string;
+        supersedesRecordIds?: string[];
     }): Promise<import('./understanding/types.js').UnderstandingReviewResult>;
     getExternalToolEntries(): Array<{
         providerId: string;

package/dist/src/agent/memory/manager.js

@@ -81,22 +81,6 @@ var MemoryManager = class {
 			}, "queuePrefetch failed (non-fatal)");
 		}
 	}
-	async syncAll(userContent, assistantContent, options) {
-		await this.captureTurnUnderstanding(userContent, assistantContent, options);
-		await this.syncProvidersForTurn(userContent, assistantContent, options);
-	}
-	async captureTurnUnderstanding(userContent, assistantContent, options) {
-		const sessionContext = options?.sessionId ? this.sessionContexts.get(options.sessionId) : void 0;
-		return await this.understanding.reviewTurn({
-			userContent,
-			assistantContent,
-			sessionKey: options?.sessionId,
-			turnId: options?.turnId,
-			workspaceId: options?.workspaceId ?? sessionContext?.workspace ?? sessionContext?.agentWorkspace,
-			projectId: options?.projectId,
-			correctionTargetRecordIds: options?.correctionTargetRecordIds
-		});
-	}
 	async syncProvidersForTurn(userContent, assistantContent, options) {
 		const provenance = options?.provenance;
 		const event = {

package/dist/src/agent/memory/understanding/service.d.ts

@@ -1,16 +1,5 @@
 import type { UnderstandingCandidate, UnderstandingReviewResult } from './types.js';
-export declare function extractExplicitUnderstandingCandidates(userContent: string): UnderstandingCandidate[];
-export declare function extractHighSignalUnderstandingCandidates(userContent: string): UnderstandingCandidate[];
 export declare class UserUnderstandingService {
-    reviewTurn(params: {
-        userContent: string;
-        assistantContent: string;
-        sessionKey?: string;
-        turnId?: string;
-        workspaceId?: string;
-        projectId?: string;
-        correctionTargetRecordIds?: string[];
-    }): Promise<UnderstandingReviewResult>;
     applyCandidates(candidates: UnderstandingCandidate[], context: {
         sessionKey?: string;
         workspaceId?: string;