@xopcai/xopc 0.0.248 → 0.0.249

package/dist/src/agent/external-tools/gateway-tools.js

@@ -1,3 +1,7 @@
+import { connectionBindings, getActiveConnectionWait, publishConnectionWait, requireSessionConnection, reviseCurrentConnectionObjective } from "../../storage/sqlite/connection-wait-repository.js";
+import { listConnectorConnections } from "../../storage/sqlite/connector-repository.js";
+import { connectorPrincipalForSession } from "../../connectors/principal.js";
+import { connectionCandidates, resolveConnectionCandidate } from "../../connectors/connection-candidates.js";
 import { ExternalToolService } from "./service.js";
 import { EXTERNAL_TOOL_SOURCES } from "./types.js";
 import { Type } from "@sinclair/typebox";
@@ -5,7 +9,9 @@ import { Type } from "@sinclair/typebox";
 const EXTERNAL_TOOL_NAMES = {
 	search: "xopc_tool_search",
 	describe: "xopc_tool_describe",
-	execute: "xopc_tool_execute"
+	execute: "xopc_tool_execute",
+	requireConnection: "xopc_require_connection",
+	updateConnectionObjective: "xopc_update_connection_objective"
 };
 const ToolSearchSchema = Type.Object({
 	query: Type.String({ description: "Describe the capability or task you need." }),
@@ -38,49 +44,155 @@ function textResult(value, details = {}) {
 		details
 	};
 }
-function createExternalToolGatewayTools(providers) {
+function createExternalToolGatewayTools(providers, getContext) {
 	const service = new ExternalToolService(providers);
+	const searchTool = {
+		name: EXTERNAL_TOOL_NAMES.search,
+		label: "🔎 External Tool Search",
+		description: "Search MCP, connected-app, extension, remote-memory, and current-endpoint tools. Use concise English capability keywords. Returns compact references only; call xopc_tool_describe before execution.",
+		parameters: ToolSearchSchema,
+		async execute(_toolCallId, params) {
+			return textResult({
+				...await service.search(params),
+				connectionCandidates: connectionCandidates(params.query),
+				selectedConnections: getContext?.()?.sessionKey ? connectionBindings(getContext().sessionKey) : [],
+				waitingObjective: getContext?.()?.sessionKey ? getActiveConnectionWait(getContext().sessionKey)?.summary : void 0
+			});
+		}
+	};
+	const describeTool = {
+		name: EXTERNAL_TOOL_NAMES.describe,
+		label: "📋 External Tool Contract",
+		description: "Load exact contracts for up to three external tools returned by xopc_tool_search.",
+		parameters: ToolDescribeSchema,
+		async execute(_toolCallId, params) {
+			const result = await service.describe(params.toolRefs);
+			return textResult({
+				...result,
+				...result.notFound.length ? { instruction: "These exact tool contracts are unavailable. Do not execute them, invent revisions, or reconnect the account. Use a different available tool or explain the capability failure." } : {}
+			});
+		}
+	};
+	const executeTool = {
+		name: EXTERNAL_TOOL_NAMES.execute,
+		label: "▶️ External Tool Execute",
+		description: "Execute one external tool using its exact reference, contract revision, and validated arguments.",
+		parameters: ToolExecuteSchema,
+		async execute(toolCallId, params, signal, onUpdate) {
+			const result = await service.execute({
+				...params,
+				context: {
+					toolCallId,
+					signal,
+					onUpdate
+				}
+			});
+			return {
+				...result,
+				details: {
+					...result.details ?? {},
+					delegatedToolRef: params.toolRef,
+					delegatedToolRevision: params.revision
+				}
+			};
+		}
+	};
+	const requireSchema = Type.Object({
+		requirements: Type.Array(Type.Object({
+			candidateRef: Type.String(),
+			accountId: Type.Optional(Type.String()),
+			accountSelector: Type.Optional(Type.String({ maxLength: 100 }))
+		}), {
+			minItems: 1,
+			maxItems: 5
+		}),
+		purpose: Type.String({
+			minLength: 1,
+			maxLength: 1e3
+		}),
+		checkpoint: Type.Object({
+			completedSteps: Type.Array(Type.String({ maxLength: 500 }), { maxItems: 20 }),
+			pendingSteps: Type.Array(Type.String({ maxLength: 500 }), {
+				minItems: 1,
+				maxItems: 20
+			}),
+			timeRange: Type.Optional(Type.Object({
+				from: Type.String(),
+				to: Type.String(),
+				timezone: Type.String(),
+				expression: Type.String()
+			}))
+		}, { description: "Preserve completed work, remaining work, and absolute dates resolved from the original request. Never include credentials." })
+	});
+	const requireTool = {
+		name: EXTERNAL_TOOL_NAMES.requireConnection,
+		label: "Connect app",
+		parameters: requireSchema,
+		description: "Request the connections returned as connectionCandidates by xopc_tool_search. Explain the need once before calling. This pauses the current objective and displays one action area above the input. Never return OAuth URLs or repeat a skipped request. If another objective is waiting, ask the user to continue or cancel it first.",
+		async execute(_id, params) {
+			const context = getContext?.();
+			if (!context) throw new Error("No active conversation.");
+			const range = params.checkpoint.timeRange;
+			if (range && (!Number.isFinite(Date.parse(range.from)) || !Number.isFinite(Date.parse(range.to)) || Date.parse(range.from) >= Date.parse(range.to))) throw new Error("Provide a valid absolute time range.");
+			if (range) new Intl.DateTimeFormat("en", { timeZone: range.timezone }).format();
+			const principal = connectorPrincipalForSession(context.sessionKey);
+			if (!principal.isLocalOwner) throw new Error("Connection recovery is available in the owner chat.");
+			const selected = connectionBindings(context.sessionKey);
+			if (params.requirements.every((item) => selected.some((need) => need.connectorId === item.candidateRef && need.connectionId && (!item.accountId || item.accountId === need.accountId) && (!item.accountSelector || item.accountSelector === need.accountSelector) && listConnectorConnections({
+				principalId: principal.principalId,
+				connectorId: need.connectorId
+			}).some((connection) => connection.id === need.connectionId && connection.status === "active")))) return textResult({
+				status: "already_connected",
+				selectedConnections: selected,
+				instruction: "These accounts were already checked for this objective. Missing tool contracts are a tool availability problem. Do not request authorization again or invent a revision. Explain the unavailable capability and stop retrying the same tools."
+			});
+			const result = requireSessionConnection({
+				sessionKey: context.sessionKey,
+				principalId: principal.principalId,
+				agentId: principal.agentId ?? "main",
+				summary: params.purpose,
+				checkpoint: params.checkpoint,
+				needs: params.requirements.map((item) => {
+					const need = resolveConnectionCandidate(item.candidateRef);
+					if (item.accountId && !listConnectorConnections({
+						principalId: principal.principalId,
+						connectorId: need.connectorId
+					}).some((connection) => connection.accountId === item.accountId)) throw new Error("Unknown account for this app.");
+					return {
+						...need,
+						accountId: item.accountId,
+						accountSelector: item.accountSelector,
+						key: `${need.connectorId}:${item.accountId ?? item.accountSelector ?? "default"}`
+					};
+				})
+			});
+			publishConnectionWait(context.sessionKey);
+			return textResult(result);
+		}
+	};
+	const reviseSchema = Type.Object({
+		action: Type.Union([Type.Literal("update"), Type.Literal("cancel")]),
+		objective: Type.Optional(Type.String({
+			minLength: 1,
+			maxLength: 4e3
+		}))
+	});
 	return [
+		searchTool,
+		describeTool,
+		executeTool,
+		requireTool,
 		{
-			name: EXTERNAL_TOOL_NAMES.search,
-			label: "🔎 External Tool Search",
-			description: "Search MCP, connected-app, extension, remote-memory, and current-endpoint tools. Use concise English capability keywords. Returns compact references only; call xopc_tool_describe before execution.",
-			parameters: ToolSearchSchema,
-			async execute(_toolCallId, params) {
-				return textResult(await service.search(params));
-			}
-		},
-		{
-			name: EXTERNAL_TOOL_NAMES.describe,
-			label: "📋 External Tool Contract",
-			description: "Load exact contracts for up to three external tools returned by xopc_tool_search.",
-			parameters: ToolDescribeSchema,
-			async execute(_toolCallId, params) {
-				return textResult(await service.describe(params.toolRefs));
-			}
-		},
-		{
-			name: EXTERNAL_TOOL_NAMES.execute,
-			label: "▶️ External Tool Execute",
-			description: "Execute one external tool using its exact reference, contract revision, and validated arguments.",
-			parameters: ToolExecuteSchema,
-			async execute(toolCallId, params, signal, onUpdate) {
-				const result = await service.execute({
-					...params,
-					context: {
-						toolCallId,
-						signal,
-						onUpdate
-					}
-				});
-				return {
-					...result,
-					details: {
-						...result.details ?? {},
-						delegatedToolRef: params.toolRef,
-						delegatedToolRevision: params.revision
-					}
-				};
+			name: EXTERNAL_TOOL_NAMES.updateConnectionObjective,
+			label: "Update waiting objective",
+			parameters: reviseSchema,
+			description: "Use when the user supplements or explicitly cancels the objective waiting for a connection. Update with the complete revised objective including the requested time range. For unrelated work leave the waiting objective unchanged. Cancellation does not disconnect the account.",
+			async execute(_id, params) {
+				const context = getContext?.();
+				if (!context) throw new Error("No active conversation.");
+				if (params.action === "update" && !params.objective) throw new Error("The revised objective is required.");
+				reviseCurrentConnectionObjective(context.sessionKey, params.action === "update" ? params.objective : void 0);
+				return textResult({ status: params.action === "update" ? "updated" : "cancelled" });
 			}
 		}
 	];

package/dist/src/agent/external-tools/index.js

@@ -40,7 +40,7 @@ function createDefaultExternalToolGatewayTools(deps) {
 		runtime: deps.endpointTools,
 		getCurrentContext: deps.getCurrentContext
 	}));
-	return createExternalToolGatewayTools(providers);
+	return createExternalToolGatewayTools(providers, deps.getCurrentContext);
 }
 //#endregion
 export { EXTERNAL_TOOL_NAMES, ExternalToolService, createDefaultExternalToolGatewayTools };

package/dist/src/agent/external-tools/search-error.d.ts

@@ -0,0 +1,12 @@
+export declare class ExternalToolSearchError extends Error {
+    readonly phase: 'create_session' | 'search';
+    readonly toolkits: string[];
+    constructor(phase: 'create_session' | 'search', toolkits: string[], cause: unknown);
+}
+/** Expose diagnostic metadata without returning provider payloads or credentials to the model. */
+export declare function searchFailureDetails(error: unknown): {
+    phase: string;
+    toolkits?: string[];
+    code?: string | number;
+    status?: number;
+};

package/dist/src/agent/external-tools/search-error.js

@@ -0,0 +1,29 @@
+//#region src/agent/external-tools/search-error.ts
+var ExternalToolSearchError = class extends Error {
+	constructor(phase, toolkits, cause) {
+		super(`Composio tool discovery failed during ${phase}`, { cause });
+		this.phase = phase;
+		this.toolkits = toolkits;
+		this.name = "ExternalToolSearchError";
+	}
+};
+/** Expose diagnostic metadata without returning provider payloads or credentials to the model. */
+function searchFailureDetails(error) {
+	const details = error instanceof ExternalToolSearchError ? {
+		phase: error.phase,
+		toolkits: error.toolkits
+	} : { phase: "search" };
+	const visited = /* @__PURE__ */ new Set();
+	let current = error;
+	while (current && typeof current === "object" && !visited.has(current)) {
+		visited.add(current);
+		const row = current;
+		if (details.code === void 0 && (typeof row.code === "number" || typeof row.code === "string" && /^[a-zA-Z0-9_.-]{1,100}$/.test(row.code))) details.code = row.code;
+		const status = row.status ?? row.statusCode;
+		if (details.status === void 0 && typeof status === "number") details.status = status;
+		current = row.cause;
+	}
+	return details;
+}
+//#endregion
+export { ExternalToolSearchError, searchFailureDetails };

package/dist/src/agent/external-tools/service.d.ts

@@ -1,3 +1,4 @@
+import { searchFailureDetails } from './search-error.js';
 import type { ExternalToolExecutionContext, ExternalToolProvider, ExternalToolSearchHit, ExternalToolSource, VersionedExternalToolDescriptor } from './types.js';
 export declare class ExternalToolService {
     private readonly providerBySource;
@@ -10,6 +11,9 @@ export declare class ExternalToolService {
     }): Promise<{
         tools: ExternalToolSearchHit[];
         unavailableSources: ExternalToolSource[];
+        sourceErrors?: Array<ReturnType<typeof searchFailureDetails> & {
+            source: ExternalToolSource;
+        }>;
     }>;
     describe(toolRefs: string[]): Promise<{
         tools: VersionedExternalToolDescriptor[];

package/dist/src/agent/external-tools/service.js

@@ -1,6 +1,11 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { searchFailureDetails } from "./search-error.js";
 import crypto from "node:crypto";
 import Ajv2020 from "ajv/dist/2020.js";
 //#region src/agent/external-tools/service.ts
+init_logger();
+const log = createLogger("ExternalToolService");
 const DEFAULT_SEARCH_LIMIT = 8;
 const MAX_SEARCH_LIMIT = 20;
 const MAX_DESCRIBE_COUNT = 3;
@@ -49,11 +54,25 @@ var ExternalToolService = class {
 			hits: await provider.search(params.query)
 		})));
 		const unavailableSources = [];
+		const sourceErrors = [];
 		const hits = [];
 		for (const [index, result] of settled.entries()) if (result.status === "fulfilled") hits.push(...result.value.hits);
 		else {
 			const provider = selected[index];
-			if (provider) unavailableSources.push(provider.source);
+			if (provider) {
+				unavailableSources.push(provider.source);
+				const details = {
+					source: provider.source,
+					...searchFailureDetails(result.reason)
+				};
+				sourceErrors.push(details);
+				const errorMessage = result.reason instanceof Error ? result.reason.message : String(result.reason);
+				log.warn({
+					...details,
+					err: result.reason instanceof Error ? result.reason : void 0,
+					errorMessage
+				}, `External tool search failed for ${provider.source}: ${errorMessage}`);
+			}
 		}
 		const limit = Math.min(MAX_SEARCH_LIMIT, Math.max(1, params.limit ?? DEFAULT_SEARCH_LIMIT));
 		return {
@@ -67,7 +86,8 @@ var ExternalToolService = class {
 				title: hit.title,
 				summary: hit.summary.slice(0, 300)
 			})),
-			unavailableSources
+			unavailableSources,
+			...sourceErrors.length ? { sourceErrors } : {}
 		};
 	}
 	async describe(toolRefs) {

package/dist/src/agent/memory/compaction-policy.js

@@ -8,7 +8,7 @@ const POLICY_DEFAULTS = {
 	postCompactionSections: ["Session Startup", "Red Lines"]
 };
 function resolveCompactionPolicy(config) {
-	const configured = config?.userContext.memory.retention?.compaction;
+	const configured = config?.userContext.contextPlanning.compaction;
 	if (!configured) return {
 		...POLICY_DEFAULTS,
 		postCompactionSections: [...POLICY_DEFAULTS.postCompactionSections]

package/dist/src/agent/memory/compaction-promotion.js

@@ -1,4 +1,5 @@
-import { getMemoryRecord, setMemoryRecordStatus, upsertMemoryRecord } from "../../storage/sqlite/memory-records-repository.js";
+import { listKnowledgeItems, setKnowledgeStatus, writeKnowledgeItem } from "../../knowledge-memory/repository.js";
+import "../../knowledge-memory/index.js";
 import { resolveMemorySessionKind } from "./turn-provenance.js";
 import { createHash } from "node:crypto";
 //#region src/agent/memory/compaction-promotion.ts
@@ -10,17 +11,17 @@ const DURABLE_KINDS = new Set([
 	"constraint",
 	"next_action"
 ]);
-const RECALL_TOOL_RE = /^(?:memory_(?:search|get)|session_(?:search|recall))$/;
-const MEMORY_KIND_BY_HANDOVER_KIND = {
-	objective: "long_term_goal",
-	decision: "derived_insight",
+const RECALL_TOOL_RE = /^(?:(?:user_context|knowledge)_(?:search|get)|session_(?:search|recall))$/;
+const KNOWLEDGE_KIND_BY_HANDOVER_KIND = {
+	objective: "commitment",
+	decision: "decision",
 	pending_user_ask: "open_question",
 	todo: "commitment",
-	constraint: "project_context",
+	constraint: "project_fact",
 	file_change: "workspace_fact",
 	tool_outcome: "task_lesson",
 	failure: "task_lesson",
-	current_state: "current_state",
+	current_state: "episode",
 	next_action: "commitment"
 };
 function stableId(prefix, ...parts) {
@@ -111,99 +112,66 @@ function promoteCompactionLedger(input) {
 	};
 	const sessionKind = resolveMemorySessionKind(input.sessionKey);
 	for (const item of input.handover.items) {
-		const episodeId = stableId("compaction-episode", input.sessionId, item.id);
 		const classified = classifyItemProvenance(item, sourceById, entriesByTurn, entriesByRound);
 		const originClass = sessionKind === "automation" || sessionKind === "workflow" || sessionKind === "background" ? "system" : sessionKind === "group" ? "untrusted" : classified.originClass;
 		const active = item.status === "active";
-		upsertMemoryRecord({
-			id: episodeId,
-			providerId: "compaction-ledger",
-			kind: MEMORY_KIND_BY_HANDOVER_KIND[item.kind],
-			sourceAgentId: input.sourceAgentId,
-			workspaceId: input.workspaceId,
-			sessionKey: input.sessionKey,
-			projectId: input.projectId,
+		const episode = writeKnowledgeItem({
+			kind: KNOWLEDGE_KIND_BY_HANDOVER_KIND[item.kind],
+			scope: {
+				type: "session",
+				id: input.sessionKey
+			},
 			content: item.text,
 			canonicalKey: `compaction:${input.sessionId}:${item.id}`,
-			source: {
-				provider: "compaction-ledger",
-				sessionEntryId: item.sources[0]?.entryId
-			},
 			confidence: input.audit.status === "passed" ? .82 : .65,
-			tags: [
-				"compaction",
-				"episodic",
-				item.kind,
-				item.status
-			],
 			status: active ? "candidate" : "archived",
-			sensitivity: "normal",
-			explicitness: "inferred",
-			durability: "ephemeral",
 			importance: importanceFor(item),
-			disclosurePolicy: "referenceable",
-			evidence: item.sources.map((source) => ({
-				sessionKey: input.sessionKey,
-				turnId: rowTurnId(sourceById.get(source.entryId)),
-				relation: "derived_from",
-				sourceText: `[transcript:${source.seq}] ${item.text}`,
-				observedAt: classified.observedAt
-			})),
 			originClass,
-			sessionKind,
-			observedAt: classified.observedAt,
+			sourceAgentId: input.sourceAgentId,
 			sourceSessionId: input.sessionKey,
-			supersedesKey: item.id,
-			derivedFromRecalledContext: classified.derivedFromRecalledContext
+			sourceTurnId: item.sources[0] ? rowTurnId(sourceById.get(item.sources[0].entryId)) : void 0,
+			derivedFromRecalledContext: classified.derivedFromRecalledContext,
+			source: {
+				provider: "compaction-ledger",
+				sessionEntryIds: item.sources.map((source) => source.entryId),
+				observedAt: classified.observedAt,
+				handoverKind: item.kind
+			}
 		});
-		result.episodicRecordIds.push(episodeId);
-		const durableId = stableId("compaction-durable", input.workspaceId, input.projectId ?? "", item.kind, item.text);
+		result.episodicRecordIds.push(episode.item.id);
 		if (!(active && input.audit.status === "passed" && sessionKind === "interactive" && originClass === "agent" && !classified.derivedFromRecalledContext && DURABLE_KINDS.has(item.kind))) {
-			if ((!active ? getMemoryRecord(durableId) : null)?.provenance.sourceSessionId === input.sessionKey) setMemoryRecordStatus(durableId, "archived");
-			result.rejectedRecordIds.push(episodeId);
+			const existingDurable = !active ? listKnowledgeItems({ limit: 2e3 }).find((entry) => entry.canonicalKey === `durable:${item.kind}:${stableId("fact", item.text)}`) : void 0;
+			if (existingDurable?.sourceSessionId === input.sessionKey) setKnowledgeStatus(existingDurable.id, "archived");
+			result.rejectedRecordIds.push(episode.item.id);
 			continue;
 		}
-		upsertMemoryRecord({
-			id: durableId,
-			providerId: "compaction-ledger",
-			kind: MEMORY_KIND_BY_HANDOVER_KIND[item.kind],
+		const durable = writeKnowledgeItem({
+			kind: KNOWLEDGE_KIND_BY_HANDOVER_KIND[item.kind],
+			scope: input.projectId ? {
+				type: "project",
+				id: input.projectId
+			} : {
+				type: "workspace",
+				id: input.workspaceId
+			},
 			sourceAgentId: input.sourceAgentId,
-			workspaceId: input.workspaceId,
-			projectId: input.projectId,
 			content: item.text,
 			canonicalKey: `durable:${item.kind}:${stableId("fact", item.text)}`,
-			source: {
-				provider: "compaction-ledger",
-				sessionEntryId: item.sources[0]?.entryId
-			},
 			confidence: .82,
-			tags: [
-				"compaction",
-				"durable",
-				item.kind
-			],
 			status: "active",
-			sensitivity: "normal",
-			explicitness: "inferred",
-			durability: "durable",
 			importance: importanceFor(item),
-			disclosurePolicy: "referenceable",
-			evidence: [{
-				sessionKey: input.sessionKey,
-				turnId: item.sources[0] ? rowTurnId(sourceById.get(item.sources[0].entryId)) : void 0,
-				relation: "derived_from",
-				sourceText: item.text,
-				observedAt: classified.observedAt
-			}],
-			supersedesRecordId: episodeId,
 			originClass: "agent",
-			sessionKind,
-			observedAt: classified.observedAt,
 			sourceSessionId: input.sessionKey,
-			supersedesKey: item.id,
-			derivedFromRecalledContext: false
+			sourceTurnId: item.sources[0] ? rowTurnId(sourceById.get(item.sources[0].entryId)) : void 0,
+			derivedFromRecalledContext: false,
+			source: {
+				provider: "compaction-ledger",
+				episodeKnowledgeId: episode.item.id,
+				sessionEntryIds: item.sources.map((source) => source.entryId),
+				observedAt: classified.observedAt
+			}
 		});
-		result.durableRecordIds.push(durableId);
+		result.durableRecordIds.push(durable.item.id);
 	}
 	return result;
 }

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

@@ -1,5 +1,4 @@
 import { isMemorySubsystemEnabled } from "./memory-config.js";
-import { BuiltinMemoryProvider } from "./builtin-provider.js";
 import { MemoryManager } from "./manager.js";
 import { loadMemoryPluginProviders } from "./plugin-discovery.js";
 import { buildMemoryRuntime } from "./runtime.js";
@@ -12,13 +11,12 @@ function createMemoryManagerFromConfig(config) {
 		...config ? { memoryRuntime: buildMemoryRuntime(config.userContext) } : {},
 		...enabled ? { loadProviders: () => loadMemoryPluginProviders({ config }) } : {}
 	});
-	mgr.addProvider(new BuiltinMemoryProvider());
 	if (!enabled) return mgr;
 	return mgr;
 }
 function resolveMemoryManagerOptions(config) {
 	if (!config) return {};
-	const providerRouting = config.userContext.providerRouting;
+	const providerRouting = config.userContext.knowledgeMemory;
 	return {
 		searchStrategy: providerRouting.searchStrategy,
 		writeStrategy: providerRouting.writeStrategy,

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

@@ -1,12 +1,7 @@
-export { BuiltinMemoryProvider } from './builtin-provider.js';
 export { buildUserContextBlock, sanitizeUserContextFenceEscapes, } from './context-fence.js';
-export { UserContextPlanner } from '../../user-context/planner.js';
-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 } 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';
 export type { MemoryProvider, MemoryProviderInitOptions } from './provider.js';

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

@@ -1,11 +1,8 @@
 import { isMemorySubsystemEnabled, shouldPlanUserContextThisTurn } from "./memory-config.js";
-import { buildUserContextBlock, sanitizeUserContextFenceEscapes } from "./context-fence.js";
-import { UserContextPlanner } from "../../user-context/planner.js";
 import { extractAgentUserPlainText } from "./user-message-text.js";
-import { BuiltinMemoryProvider } from "./builtin-provider.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 { buildUserContextBlock, sanitizeUserContextFenceEscapes } from "./context-fence.js";
 import { StubMemoryProvider } from "./stub-memory-provider.js";
-export { BuiltinMemoryProvider, MemoryManager, StubMemoryProvider, UserContextPlanner, UserUnderstandingService, buildUserContextBlock, createMemoryManagerFromConfig, discoverMemoryPlugins, extractAgentUserPlainText, isMemorySubsystemEnabled, sanitizeUserContextFenceEscapes, shouldPlanUserContextThisTurn };
+export { MemoryManager, StubMemoryProvider, buildUserContextBlock, createMemoryManagerFromConfig, discoverMemoryPlugins, extractAgentUserPlainText, isMemorySubsystemEnabled, sanitizeUserContextFenceEscapes, shouldPlanUserContextThisTurn };

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

@@ -1,7 +1,6 @@
 import type { AgentTool } from '@earendil-works/pi-agent-core';
 import type { MemoryRuntime } from './runtime.js';
 import type { MemoryProvider, MemoryProviderInitOptions } from './provider.js';
-import type { UnderstandingCandidate } from './understanding/types.js';
 import type { MemoryDeleteRequest, MemoryListRequest, MemoryReadRequest, MemoryReadResult, MemorySearchRequest, MemorySearchResult, MemoryUpdateRequest, MemoryWriteRequest, MemoryWriteResult, MemoryRecord, MemorySignal, MemoryKind } from './types.js';
 import type { TurnMemoryProvenance } from './turn-provenance.js';
 export type MemorySearchStrategy = 'local-first' | 'external-first' | 'fanout' | 'local-only' | 'external-only';
@@ -28,7 +27,6 @@ export declare class MemoryManager {
     private readonly loadProviders?;
     private readonly writePolicy;
     private pluginProvidersLoaded;
-    private readonly understanding;
     private readonly memoryRuntime?;
     private readonly sessionContexts;
     constructor(options?: MemoryManagerOptions);
@@ -44,20 +42,6 @@ export declare class MemoryManager {
         turnId?: string;
         provenance?: TurnMemoryProvenance;
     }): Promise<void>;
-    applyUnderstandingCandidates(candidates: UnderstandingCandidate[], context?: {
-        agentId?: string;
-        sessionKey?: string;
-        workspaceId?: string;
-        projectId?: string;
-        sourceItemId?: string;
-        sourceItemIds?: string[];
-        evidenceIds?: string[];
-        sourceText?: string;
-        source?: MemoryRecord['source'];
-        reviewSource?: 'turn' | 'background';
-        extractionRunId?: string;
-        supersedesRecordIds?: string[];
-    }): Promise<import('./understanding/types.js').UnderstandingReviewResult>;
     getExternalToolEntries(): Array<{
         providerId: string;
         tool: AgentTool;