@xopcai/xopc 0.0.248 → 0.0.250

package/dist/src/agent/memory/compaction-promotion.d.ts

@@ -9,6 +9,7 @@ export interface PromoteCompactionLedgerInput {
     handover: CompactionHandover;
     audit: CompactionAudit;
     sourceEntries: readonly TranscriptSourceEntry[];
+    writePolicy: 'deny' | 'confirm' | 'allow';
 }
 export interface PromoteCompactionLedgerResult {
     episodicRecordIds: string[];

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) {
@@ -83,6 +84,11 @@ function importanceFor(item) {
 	return .5;
 }
 function promoteCompactionLedger(input) {
+	if (input.writePolicy === "deny") return {
+		episodicRecordIds: [],
+		durableRecordIds: [],
+		rejectedRecordIds: []
+	};
 	const sourceById = new Map(input.sourceEntries.map((entry) => [entry.entryId, entry]));
 	const entriesByTurn = /* @__PURE__ */ new Map();
 	const entriesByRound = /* @__PURE__ */ new Map();
@@ -111,99 +117,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",
+			status: active ? input.writePolicy === "allow" && originClass !== "untrusted" ? "active" : "candidate" : "archived",
 			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",
+			status: input.writePolicy === "allow" ? "active" : "candidate",
 			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 { isMemorySubsystemEnabled } 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 { isMemorySubsystemEnabled } from "./memory-config.js";
 import { extractAgentUserPlainText } from "./user-message-text.js";
-import { BuiltinMemoryProvider } from "./builtin-provider.js";
-import { UserUnderstandingService } from "./understanding/service.js";
+import { buildUserContextBlock, sanitizeUserContextFenceEscapes } from "./context-fence.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, isMemorySubsystemEnabled, sanitizeUserContextFenceEscapes, shouldPlanUserContextThisTurn };
+export { MemoryManager, StubMemoryProvider, buildUserContextBlock, createMemoryManagerFromConfig, discoverMemoryPlugins, extractAgentUserPlainText, isMemorySubsystemEnabled, sanitizeUserContextFenceEscapes };

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.d.ts

@@ -1,8 +1,3 @@
 import type { Config } from '../../config/schema.js';
 /** Whether generic workspace and provider-backed memory is available. */
 export declare function isMemorySubsystemEnabled(config: Config | undefined): boolean;
-/**
- * Whether to prefix the user message with prefetched external memory this turn.
- * `first-turn` only injects on turn 1. `contextCadence` N injects on turns 1, N+1, 2N+1, …
- */
-export declare function shouldPlanUserContextThisTurn(_config: Config | undefined, turnNumber: number): boolean;

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

@@ -2,14 +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";
-}
-/**
-* Whether to prefix the user message with prefetched external memory this turn.
-* `first-turn` only injects on turn 1. `contextCadence` N injects on turns 1, N+1, 2N+1, …
-*/
-function shouldPlanUserContextThisTurn(_config, turnNumber) {
-	return turnNumber >= 1;
+	return config.userContext.enabled && config.userContext.knowledgeMemory.enabled;
 }
 //#endregion
-export { isMemorySubsystemEnabled, shouldPlanUserContextThisTurn };
+export { isMemorySubsystemEnabled };

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'];

package/dist/src/agent/orchestration/agent-orchestrator.js

@@ -1,6 +1,8 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { runContextConsolidation } from "../../user-context/consolidation.js";
+import { parseMaintenanceInstruction } from "../../memory-maintenance/schedule.js";
+import { runMemoryMaintenance } from "../../memory-maintenance/service.js";
+import "../../memory-maintenance/index.js";
 import { abortEmbeddedRun } from "../embedded/runs.js";
 import { persistInboundAttachments } from "../../channels/attachments/inbound-persist.js";
 import { buildTranscriptUserMessage, clearPendingTranscriptUserMessage, hydrateUserTurnForLlm, setPendingTranscriptUserMessage } from "../inbound/attachment-pipeline.js";
@@ -48,15 +50,19 @@ var AgentOrchestrator = class {
 		log.debug({ sessionKey }, "Processing message through agent orchestrator");
 		await this.sessionHydrator.workspace(sessionKey);
 		if (typeof msg.content === "string" && (sessionKey.startsWith("cron:") || sessionKey.includes(":cron:") || sessionKey.includes(":automation:") || context.channel === "cron" || context.channel === "automation")) {
-			if (msg.content.includes("__xopc_user_context_consolidation__")) {
+			const maintenanceJob = parseMaintenanceInstruction(msg.content);
+			if (maintenanceJob) {
 				const cfg = this.getConfig?.();
 				if (!cfg) {
-					log.warn({ sessionKey }, "User context review skipped: config unavailable");
+					log.warn({ sessionKey }, "Memory maintenance skipped: config unavailable");
 					return;
 				}
-				await runContextConsolidation({
-					config: cfg,
-					triggerKind: "schedule"
+				const maintenance = cfg.userContext.userModel.maintenance;
+				runMemoryMaintenance({
+					jobType: maintenanceJob,
+					limit: maintenance.limit,
+					staleRetentionDays: maintenance.staleRetentionDays,
+					evidenceThreshold: maintenance.evidenceThreshold
 				});
 				return;
 			}
@@ -108,21 +114,7 @@ var AgentOrchestrator = class {
 					clearPendingTranscriptUserMessage(sessionKey, userMessage);
 				}
 			})();
-			const understandingReview = await this.agentManager.afterAgentTurn(sessionKey, userPlainForMemory, turnId);
-			if (understandingReview?.createdRecords.length) {
-				const captured = understandingReview.createdRecords.filter((record) => record.status === "active");
-				const candidates = understandingReview.createdRecords.filter((record) => record.status === "candidate");
-				if (captured.length) this.onEmbeddedStreamEvent?.(sessionKey, {
-					type: "memory_captured",
-					runId: turnId,
-					records: captured
-				});
-				if (candidates.length) this.onEmbeddedStreamEvent?.(sessionKey, {
-					type: "memory_candidate",
-					runId: turnId,
-					records: candidates
-				});
-			}
+			await this.agentManager.afterAgentTurn(sessionKey, userPlainForMemory, turnId);
 			this.agentManager.scheduleBackgroundReviewAfterUserTurn(sessionKey);
 			if (turnResult.ok) {
 				this.onEmbeddedTurnComplete?.(sessionKey, turnResult.lastAssistantText);

package/dist/src/agent/orchestration/context-overflow.js

@@ -1,6 +1,7 @@
 //#region src/agent/orchestration/context-overflow.ts
 const CONTEXT_OVERFLOW_PATTERNS = [
 	/context(?:_|\s|-)*(?:length|window).*(?:exceed|limit|maximum|too (?:large|long))/i,
+	/\bexceed(?:s|ed)?\s+(?:the\s+)?context(?:_|\s|-)*(?:length|window)\b/i,
 	/maximum context length/i,
 	/max(?:imum)? tokens?.*(?:exceed|limit)/i,
 	/too many tokens/i,

package/dist/src/agent/prompt/sections/memory-skills.js

@@ -1,43 +1,32 @@
 //#region src/agent/prompt/sections/memory-skills.ts
 function buildMemorySection(params) {
 	if (params.includeMemorySection === false) return "";
-	if (!(params.availableTools.has("memory_search") || params.availableTools.has("memory_get") || params.availableTools.has("session_recall") || params.availableTools.has("session_search")) && !params.hasProfileMemory) return "";
-	const citationsMode = params.citationsMode ?? "on";
-	const citationInstruction = citationsMode === "off" ? "Citations are disabled: do not mention file paths or line numbers in replies." : citationsMode === "source-only" ? "Citations: mention the memory record id when it helps." : "Citations: include the memory record id when it helps the user verify recalled context.";
-	const toolLines = [];
-	if (params.availableTools.has("memory_search")) toolLines.push("1. Run `memory_search` to search workspace and connected-source memory records");
-	if (params.availableTools.has("session_search")) toolLines.push(`${toolLines.length + 1}. For **other chat sessions** / cross-session history, use \`session_search\` with keywords (or omit \`query\` to list recent sessions)`);
-	if (params.availableTools.has("session_recall")) toolLines.push(`${toolLines.length + 1}. When the current session summary lacks an exact fact, path, ID, date, decision, or tool result, use session_recall to search its authoritative raw transcript`);
-	if (params.availableTools.has("memory_get")) toolLines.push(`${toolLines.length + 1}. Use \`memory_get\` only for record ids returned by \`memory_search\``);
-	toolLines.push(`${toolLines.length + 1}. If low confidence after search, say you checked`);
-	return [
-		"## Memory Recall",
-		"",
-		citationInstruction,
-		"",
-		"Relevant user understanding is selected separately and injected above.",
-		"",
-		"Before answering anything about prior work, decisions, dates, people, preferences, or todos:",
-		...toolLines,
-		"",
-		"### Memory Sources",
-		"",
-		"- **Current session:** use `session_recall` for exact raw turns, including history older than compaction.",
-		"- **Other sessions:** use `session_search` for cross-session history.",
-		"- **Workspace memory:** cite only record ids returned by `memory_search` / `memory_get`.",
-		"",
-		"### Writing to Memory",
-		"",
-		"- **Declarative vs procedural:** user preferences belong to structured user understanding; reusable task procedures belong to skills.",
-		"- Explicit \"remember this\" statements are captured as durable structured understanding after the turn.",
-		"- Do not invent, cite, or promise memory record ids that were not returned by a memory tool.",
-		"- **Text > Brain**"
-	].join("\n");
+	const names = params.availableTools;
+	if (![
+		"user_context_search",
+		"user_context_get",
+		"knowledge_search",
+		"knowledge_get",
+		"session_recall",
+		"session_search"
+	].some((name) => names.has(name)) && !params.hasProfileMemory) return "";
+	const lines = [
+		"## Context and memory",
+		"",
+		"Relevant user facts, goals, priorities, collaboration rules, and task knowledge are selected for each turn.",
+		"When exact or additional context is needed:"
+	];
+	if (names.has("user_context_search")) lines.push("- Use `user_context_search` for user identity, preferences, routines, and current state.");
+	if (names.has("knowledge_search")) lines.push("- Use `knowledge_search` for project facts, decisions, lessons, commitments, and open questions.");
+	if (names.has("session_recall")) lines.push("- Use `session_recall` for exact raw content from the current session.");
+	if (names.has("session_search")) lines.push("- Use `session_search` for other conversations.");
+	if (names.has("knowledge_write")) lines.push("- Use `knowledge_write` for reusable task knowledge; it is stored as a reviewable candidate with provenance.");
+	lines.push("", "User facts are declarative. Reusable procedures belong in skills.", "Do not infer importance from confidence: confidence measures truth likelihood; importance measures execution value.");
+	return lines.join("\n");
 }
 function buildExternalMemorySection(text) {
-	const t = text?.trim();
-	if (!t) return "";
-	return `## External memory provider\n\n${t}`;
+	const value = text?.trim();
+	return value ? `## External knowledge provider\n\n${value}` : "";
 }
 function buildSkillsSection(hasSkillTools) {
 	if (!hasSkillTools) return "";
@@ -50,7 +39,7 @@ function buildSkillsSection(hasSkillTools) {
 		"Constraints: never load more than one skill up front; only load after selecting.",
 		"- When a skill drives external API writes, assume rate limits: prefer fewer larger writes, avoid tight one-item loops, serialize bursts when possible, and respect 429/Retry-After.",
 		"",
-		"**Division of labor with memory:** Skills = **procedural** workflows; structured memory = **declarative** facts and preferences."
+		"**Division of labor:** Skills contain procedures; user context and knowledge contain declarative facts."
 	].join("\n");
 }
 //#endregion

package/dist/src/agent/prompt/sections/tooling.js

@@ -15,8 +15,11 @@ const CORE_TOOL_ORDER = [
 	"send_message",
 	"send_media",
 	"publish_artifacts",
-	"memory_search",
-	"memory_get",
+	"user_context_search",
+	"user_context_get",
+	"knowledge_search",
+	"knowledge_get",
+	"knowledge_write",
 	"session_recall",
 	"session_search",
 	"session_status",
@@ -52,8 +55,11 @@ const CORE_TOOL_SUMMARIES = {
 	send_message: "Send messages to the current conversation or an explicit configured channel",
 	send_media: "Send media attachments to the current channel",
 	publish_artifacts: "Publish final generated files as durable chat deliverables",
-	memory_search: "Semantic search over indexed memory sources",
-	memory_get: "Read specific lines from memory sources returned by search",
+	user_context_search: "Search typed user facts, preferences, routines, and current state",
+	user_context_get: "Read one typed user assertion with its scope and authority",
+	knowledge_search: "Search scoped project, workspace, and session knowledge",
+	knowledge_get: "Read one knowledge item returned by search",
+	knowledge_write: "Store a scoped knowledge candidate with provenance",
 	session_recall: "Search exact raw turns in the current session, including compacted history",
 	session_search: "Search other chat sessions or list recent sessions",
 	session_status: "Show session usage/time/model state",