@xopcai/xopc 0.0.247 → 0.0.249

package/dist/src/agent/ipc/inbox.js

@@ -1,158 +1,89 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { init_paths, resolveAgentDir } from "../../config/paths.js";
-import { init_write_file_atomic, writeTextAtomic } from "../../infra/write-file-atomic.js";
-import { join } from "path";
-import { existsSync, watch } from "fs";
-import { mkdir, readFile, readdir, rename } from "fs/promises";
+import { DurableQueue } from "../../storage/sqlite/durable-queue.js";
 //#region src/agent/ipc/inbox.ts
-init_write_file_atomic();
 init_logger();
-init_paths();
 const log = createLogger("AgentInbox");
+const LEASE_MS = 3e4;
+/** SQLite queue with acknowledgement after processing and renewable claims. */
 var AgentInbox = class AgentInbox {
-	pendingDir;
-	processedDir;
-	watcher;
-	constructor(agentDir) {
-		this.pendingDir = join(agentDir, "inbox", "pending");
-		this.processedDir = join(agentDir, "inbox", "processed");
+	queue;
+	timer;
+	processing = false;
+	stopped = true;
+	constructor(agentId) {
+		this.queue = new DurableQueue("agent-ipc", agentId);
 	}
-	/**
-	* Static factory using agent ID (paths from config).
-	*/
-	static forAgent(config, agentId) {
-		return new AgentInbox(resolveAgentDir(config, agentId));
+	static forAgent(_config, agentId) {
+		return new AgentInbox(agentId);
 	}
-	/**
-	* Enqueue a message
-	*/
 	async enqueue(message) {
-		await mkdir(this.pendingDir, { recursive: true });
-		await writeTextAtomic(join(this.pendingDir, `${message.id}.json`), JSON.stringify(message, null, 2));
-		log.debug({
-			messageId: message.id,
-			to: message.to
-		}, "Enqueued message");
+		this.queue.enqueue(message.id, message);
 	}
-	/**
-	* Dequeue the oldest pending message
-	*/
-	async dequeue() {
-		await mkdir(this.pendingDir, { recursive: true });
-		await mkdir(this.processedDir, { recursive: true });
-		const files = await readdir(this.pendingDir).catch(() => []);
-		if (files.length === 0) return null;
-		const sorted = files.filter((f) => f.endsWith(".json")).sort();
-		if (sorted.length === 0) return null;
-		const fileName = sorted[0];
-		const filePath = join(this.pendingDir, fileName);
-		try {
-			const content = await readFile(filePath, "utf-8");
-			const message = JSON.parse(content);
-			await rename(filePath, join(this.processedDir, fileName));
-			log.debug({
-				messageId: message.id,
-				from: message.from
-			}, "Dequeued message");
-			return message;
-		} catch (error) {
-			log.warn({
-				fileName,
-				error
-			}, "Failed to dequeue message");
-			return null;
-		}
-	}
-	/**
-	* Peek at pending messages without removing them
-	*/
 	async peek(limit = 10) {
-		await mkdir(this.pendingDir, { recursive: true });
-		const jsonFiles = (await readdir(this.pendingDir).catch(() => [])).filter((f) => f.endsWith(".json")).sort();
-		const messages = [];
-		for (const fileName of jsonFiles.slice(0, limit)) try {
-			const content = await readFile(join(this.pendingDir, fileName), "utf-8");
-			const message = JSON.parse(content);
-			messages.push(message);
-		} catch (error) {
-			log.warn({
-				fileName,
-				error
-			}, "Failed to read message");
-		}
-		return messages;
+		return this.queue.pending(limit);
 	}
-	/**
-	* Count pending messages
-	*/
 	async count() {
-		if (!existsSync(this.pendingDir)) return 0;
-		return (await readdir(this.pendingDir).catch(() => [])).filter((f) => f.endsWith(".json")).length;
+		return this.queue.pending().length;
+	}
+	async clearProcessed(olderThanMs) {
+		return this.queue.clearProcessed(olderThanMs);
 	}
-	/**
-	* Watch for new messages
-	*/
 	async watch(handler) {
-		await mkdir(this.pendingDir, { recursive: true });
-		await this.processPending(handler);
-		this.watcher = watch(this.pendingDir, async (eventType, filename) => {
-			if (eventType === "rename" && filename?.endsWith(".json")) await this.processPending(handler);
+		this.stopWatching();
+		this.stopped = false;
+		const poll = () => this.processPending(handler).catch((err) => {
+			log.error({ err }, "IPC queue processing failed");
 		});
-		return () => {
-			this.watcher?.close();
-			this.watcher = void 0;
-		};
+		await poll();
+		if (!this.stopped) {
+			this.timer = setInterval(() => {
+				poll();
+			}, 250);
+			this.timer.unref();
+		}
+		return () => this.stopWatching();
 	}
-	/**
-	* Stop watching
-	*/
 	stopWatching() {
-		this.watcher?.close();
-		this.watcher = void 0;
+		this.stopped = true;
+		clearInterval(this.timer);
+		this.timer = void 0;
 	}
-	/**
-	* Clear all processed messages
-	*/
-	async clearProcessed(olderThanMs) {
-		if (!existsSync(this.processedDir)) return 0;
-		const files = await readdir(this.processedDir).catch(() => []);
-		const cutoff = olderThanMs ? Date.now() - olderThanMs : 0;
-		let cleared = 0;
-		for (const fileName of files) {
-			if (!fileName.endsWith(".json")) continue;
-			const filePath = join(this.processedDir, fileName);
-			try {
-				if (olderThanMs) {
-					if ((await import("fs/promises").then((fs) => fs.stat(filePath))).mtimeMs < cutoff) {
-						await import("fs/promises").then((fs) => fs.unlink(filePath));
-						cleared++;
+	async processPending(handler) {
+		if (this.processing || this.stopped) return;
+		this.processing = true;
+		try {
+			while (!this.stopped) {
+				const claim = this.queue.claim(LEASE_MS);
+				if (!claim) break;
+				const renewal = setInterval(() => {
+					try {
+						this.queue.renew(claim.id, claim.token, LEASE_MS);
+					} catch (err) {
+						log.error({
+							err,
+							messageId: claim.id
+						}, "IPC lease renewal failed");
 					}
-				} else {
-					await import("fs/promises").then((fs) => fs.unlink(filePath));
-					cleared++;
+				}, LEASE_MS / 3);
+				renewal.unref();
+				let succeeded = false;
+				try {
+					await handler(claim.payload);
+					succeeded = true;
+				} catch (err) {
+					log.error({
+						err,
+						messageId: claim.id
+					}, "IPC handler failed; message remains pending");
+				} finally {
+					clearInterval(renewal);
+					this.queue.finish(claim.id, claim.token, succeeded);
 				}
-			} catch (error) {
-				log.warn({
-					fileName,
-					error
-				}, "Failed to clear processed message");
-			}
-		}
-		return cleared;
-	}
-	async processPending(handler) {
-		while (true) {
-			const msg = await this.dequeue();
-			if (!msg) break;
-			try {
-				await handler(msg);
-			} catch (error) {
-				log.error({
-					messageId: msg.id,
-					error
-				}, "Error processing message");
+				if (!succeeded) break;
 			}
+		} finally {
+			this.processing = false;
 		}
 	}
 };

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;

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

@@ -1,10 +1,6 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { retrievalQueryAuditValue } from "../../retrieval/audit.js";
-import { setKnowledgeSourceItemSynthesisStatus } from "../../storage/sqlite/knowledge-repository.js";
-import { appendMemoryTraceEvent } from "../../storage/sqlite/memory-records-repository.js";
-import "../../storage/sqlite/index.js";
-import { UserUnderstandingService } from "./understanding/service.js";
 //#region src/agent/memory/manager.ts
 init_logger();
 const log = createLogger("MemoryManager");
@@ -15,7 +11,6 @@ var MemoryManager = class {
 	loadProviders;
 	writePolicy;
 	pluginProvidersLoaded = false;
-	understanding;
 	memoryRuntime;
 	sessionContexts = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
@@ -31,7 +26,6 @@ var MemoryManager = class {
 			allowedProviderIds: options.writePolicy?.allowedProviderIds,
 			autoWriteKinds: options.writePolicy?.autoWriteKinds
 		};
-		this.understanding = new UserUnderstandingService();
 	}
 	addProvider(provider) {
 		this.providers.push(provider);
@@ -119,21 +113,6 @@ var MemoryManager = class {
 			}
 		}
 	}
-	async applyUnderstandingCandidates(candidates, context = {}) {
-		const sessionContext = context.sessionKey ? this.sessionContexts.get(context.sessionKey) : void 0;
-		const sourceItemId = context.sourceItemId;
-		const result = await this.understanding.applyCandidates(candidates, {
-			...context,
-			workspaceId: context.workspaceId ?? sessionContext?.workspace ?? sessionContext?.agentWorkspace,
-			sourceItemId
-		});
-		const sourceItemIds = [...new Set([...sourceItemId ? [sourceItemId] : [], ...context.sourceItemIds ?? []])];
-		if (sourceItemIds.length) setKnowledgeSourceItemSynthesisStatus(sourceItemIds, "completed");
-		return {
-			...result,
-			...sourceItemId ? { sourceItemId } : {}
-		};
-	}
 	getExternalToolEntries() {
 		const out = [];
 		const seen = /* @__PURE__ */ new Set();
@@ -438,30 +417,22 @@ var MemoryManager = class {
 		return true;
 	}
 	trace(phase, providerId, request, meta = {}) {
-		try {
-			appendMemoryTraceEvent({
-				phase,
-				providerId,
-				request: sanitizeTraceRequest(request),
-				...meta
-			});
-		} catch (err) {
-			log.debug({
-				err,
-				providerId,
-				phase
-			}, "memory trace append failed");
-		}
+		log.debug({
+			phase,
+			providerId,
+			request: sanitizeTraceRequest(request),
+			...meta
+		}, "External memory provider operation");
 	}
 };
 function memorySourceForRecord(record) {
-	if (record.source.provider === "agent-profile") return "agentProfile";
+	if (record.source.provider !== "builtin") return "connector";
 	if (record.scope.sessionKey) return "session";
-	if (record.scope.workspaceId || record.kind === "workspace_fact" || record.kind === "project_context" || record.kind === "task_lesson") return "workspace";
-	return "understanding";
+	if (record.scope.projectId) return "project";
+	return "workspace";
 }
-function writeTargetForRecord(request) {
-	return request.scope?.workspaceId || request.kind === "workspace_fact" || request.kind === "project_context" || request.kind === "task_lesson" ? "workspace" : "understanding";
+function writeTargetForRecord(_request) {
+	return "knowledge";
 }
 function sanitizeTraceRequest(request) {
 	if (!request || typeof request !== "object") return request;

package/dist/src/agent/memory/memory-config.js

@@ -2,7 +2,7 @@
 /** Whether generic workspace and provider-backed memory is available. */
 function isMemorySubsystemEnabled(config) {
 	if (!config) return true;
-	return config.userContext.enabled && config.userContext.memory.mode !== "off";
+	return config.userContext.enabled && config.userContext.knowledgeMemory.enabled;
 }
 /**
 * Whether to prefix the user message with prefetched external memory this turn.

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

@@ -1,6 +1,6 @@
 import type { UserContextConfig } from '../../user-context/config.js';
-export type MemorySource = 'session' | 'agentProfile' | 'understanding' | 'workspace';
-export type MemoryWriteTarget = 'agentProfile' | 'understanding' | 'workspace';
+export type MemorySource = 'session' | 'workspace' | 'project' | 'connector';
+export type MemoryWriteTarget = 'knowledge';
 export type MemoryWriteDecision = 'allow' | 'confirm' | 'deny';
 export interface MemoryCandidate {
     target: MemoryWriteTarget;

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

@@ -4,20 +4,16 @@ function normalizeConfidence(value) {
 	return Math.max(0, Math.min(1, value));
 }
 function buildMemoryRuntime(userContext) {
-	const memory = userContext.memory;
-	const readableSources = !userContext.enabled || memory.mode === "off" ? [] : [...memory.sources];
+	const memory = userContext.knowledgeMemory;
+	const readableSources = !userContext.enabled || !memory.enabled ? [] : [...memory.sources];
 	const sourceSet = new Set(readableSources);
 	return {
 		readableSources,
 		canRead: (source) => sourceSet.has(source),
 		checkWrite: (candidate) => {
-			if (!userContext.enabled || memory.mode === "off") return {
+			if (!userContext.enabled || !memory.enabled) return {
 				decision: "deny",
-				reason: "memory is disabled"
-			};
-			if (memory.mode === "readOnly") return {
-				decision: "deny",
-				reason: "memory is read-only"
+				reason: "knowledge memory is disabled"
 			};
 			if (!candidate.content.trim()) return {
 				decision: "deny",
@@ -27,19 +23,13 @@ function buildMemoryRuntime(userContext) {
 				decision: "deny",
 				reason: "memory confidence is too low"
 			};
-			const sensitivePolicy = userContext.privacy.sensitiveWritePolicy;
-			if (candidate.sensitive && sensitivePolicy !== "allow") return {
-				decision: sensitivePolicy,
-				reason: "memory candidate is sensitive"
-			};
-			const targetPolicy = memory.writePolicy?.[candidate.target] ?? "deny";
-			if (memory.mode === "confirmWrite" && targetPolicy === "allow") return {
-				decision: "confirm",
-				reason: "agent memory mode requires confirmation"
+			if (candidate.sensitive && memory.writePolicy !== "allow") return {
+				decision: memory.writePolicy,
+				reason: "knowledge candidate is sensitive"
 			};
 			return {
-				decision: targetPolicy,
-				reason: `target policy is ${targetPolicy}`
+				decision: memory.writePolicy,
+				reason: `knowledge write policy is ${memory.writePolicy}`
 			};
 		}
 	};

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

@@ -115,7 +115,7 @@ export interface MemoryWriteRequest {
     /** Agent that produced this record. This is request data, never provider state. */
     sourceAgentId?: string;
     provenance?: Partial<Omit<MemoryProvenance, 'sourceAgentId'>>;
-    writeTarget?: 'agentProfile' | 'understanding' | 'workspace';
+    writeTarget?: 'knowledge';
     confirmed?: boolean;
     tags?: string[];
     source?: MemoryRecord['source'];