@xopcai/xopc 0.0.189 → 0.0.190

package/dist/src/agent/memory/understanding/service.js

@@ -1,15 +1,9 @@
-import { createLogger } from "../../../utils/logger/index.js";
-import { init_logger } from "../../../utils/logger.js";
-import { appendMemoryTraceEvent, markMemoryRecordsConflicted } from "../../../storage/sqlite/memory-records-repository.js";
-import { attachMemoryEvidence, upsertKnowledgeSourceItems } from "../../../storage/sqlite/knowledge-repository.js";
+import { createContextEvidence, createUnderstanding, isUnderstandingSuppressed, linkUnderstandingEvidence, listUnderstandings, setUnderstandingStatus } from "../../../storage/sqlite/user-context-repository.js";
 import "../../../storage/sqlite/index.js";
-import { nextMemoryReviewAt } from "../lifecycle.js";
 import { extractExplicitUnderstandingCorrectionContent } from "./correction.js";
 import { inferMemorySensitivity, redactSensitiveMemoryText } from "../sensitivity.js";
-import { createHash, randomUUID } from "node:crypto";
+import { createHash } from "node:crypto";
 //#region src/agent/memory/understanding/service.ts
-init_logger();
-const log = createLogger("UserUnderstanding");
 const MAX_CANDIDATE_CHARS = 600;
 const EXPLICIT_PATTERNS = [
 	/\b(?:please\s+)?remember(?:\s+that)?\s+(.+)/i,
@@ -18,27 +12,27 @@ const EXPLICIT_PATTERNS = [
 	/以后(?:都)?(?:请)?[：:\s]*(.+)/,
 	/下次(?:请)?[：:\s]*(.+)/
 ];
+const SENSITIVITY_RANK = {
+	normal: 0,
+	personal: 1,
+	secret: 2,
+	regulated: 3
+};
+function effectiveSensitivity(declared, content) {
+	const inferred = inferMemorySensitivity(content);
+	return SENSITIVITY_RANK[inferred] > SENSITIVITY_RANK[declared] ? inferred : declared;
+}
 function normalizeContent(raw) {
 	return raw.replace(/^["'“”‘’\s]+|["'“”‘’\s]+$/g, "").replace(/\s+/g, " ").trim().slice(0, MAX_CANDIDATE_CHARS);
 }
 function inferKind(content) {
 	if (/\b(don't|do not|never|avoid)\b/i.test(content) || /不要|别再|禁止|底线/.test(content)) return "boundary";
 	if (/\b(prefer|preference|like)\b/i.test(content) || /喜欢|偏好|习惯/.test(content)) return "preference";
-	if (/\b(tool|command|pnpm|npm|git|ripgrep|rg)\b/i.test(content) || /工具|命令/.test(content)) return "tool_preference";
 	if (/\b(project|repo|codebase|workspace)\b/i.test(content) || /项目|仓库|代码库/.test(content)) return "project_context";
-	if (/\b(goal|plan|commit|deadline)\b/i.test(content) || /目标|计划|承诺|截止/.test(content)) return "commitment";
-	if (/\b(next time|lesson|failed|error)\b/i.test(content) || /下次|教训|失败|错误/.test(content)) return "task_lesson";
-	return "user_note";
-}
-const SENSITIVITY_RANK = {
-	normal: 0,
-	personal: 1,
-	regulated: 2,
-	secret: 3
-};
-function stricterSensitivity(content, declared) {
-	const inferred = inferMemorySensitivity(content);
-	return SENSITIVITY_RANK[inferred] > SENSITIVITY_RANK[declared] ? inferred : declared;
+	if (/\b(goal|plan|deadline)\b/i.test(content) || /目标|计划|截止/.test(content)) return "long_term_goal";
+	if (/\b(next time|lesson|failed|error)\b/i.test(content) || /教训|失败|错误/.test(content)) return "task_lesson";
+	if (/习惯|每周|每天|usually|routine/i.test(content)) return "routine";
+	return "current_state";
 }
 function canonicalKey(kind, content) {
 	const normalized = content.toLocaleLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
@@ -46,192 +40,130 @@ function canonicalKey(kind, content) {
 }
 function extractExplicitUnderstandingCandidates(userContent) {
 	const correction = extractExplicitUnderstandingCorrectionContent(userContent);
-	if (correction) {
-		const kind = inferKind(correction);
-		return [{
-			kind,
-			content: correction,
-			canonicalKey: canonicalKey(kind, correction),
-			confidence: .95,
-			importance: kind === "boundary" ? .9 : .8,
-			explicitness: "explicit",
-			durability: "durable",
-			sensitivity: inferMemorySensitivity(correction),
-			disclosurePolicy: kind === "boundary" ? "silent" : "referenceable",
-			tags: ["user-understanding", "explicit-user-correction"]
-		}];
-	}
-	const lines = userContent.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-	for (const line of lines.length > 0 ? lines : [userContent.trim()]) for (const pattern of EXPLICIT_PATTERNS) {
-		const content = normalizeContent(pattern.exec(line)?.[1] ?? "");
-		if (content.length < 8) continue;
-		const kind = inferKind(content);
-		return [{
-			kind,
-			content,
-			canonicalKey: canonicalKey(kind, content),
-			confidence: .92,
-			importance: kind === "boundary" ? .9 : .75,
-			explicitness: "explicit",
-			durability: "durable",
-			sensitivity: inferMemorySensitivity(content),
-			disclosurePolicy: kind === "boundary" ? "silent" : "referenceable",
-			tags: ["user-understanding", "explicit-user-request"]
-		}];
-	}
-	return [];
+	const matched = correction ?? userContent.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap((line) => EXPLICIT_PATTERNS.map((pattern) => pattern.exec(line)?.[1] ?? "")).map(normalizeContent).find((content) => content.length >= 8);
+	if (!matched) return [];
+	const content = normalizeContent(matched);
+	const kind = inferKind(content);
+	return [{
+		kind,
+		content,
+		canonicalKey: canonicalKey(kind, content),
+		confidence: correction ? .98 : .95,
+		importance: kind === "boundary" ? .9 : .8,
+		explicitness: "explicit",
+		durability: "durable",
+		sensitivity: inferMemorySensitivity(content),
+		disclosurePolicy: kind === "boundary" ? "silent" : "referenceable"
+	}];
+}
+function scopeForCandidate(candidate, context) {
+	if (candidate.durability === "ephemeral" && context.sessionKey) return {
+		type: "session",
+		id: context.sessionKey
+	};
+	if (candidate.kind === "project_context" && context.projectId) return {
+		type: "project",
+		id: context.projectId
+	};
+	if ((candidate.kind === "project_context" || candidate.kind === "task_lesson") && context.workspaceId) return {
+		type: "workspace",
+		id: context.workspaceId
+	};
+	return { type: "global" };
+}
+function sameScope(left, right) {
+	return left.type === right.type && left.id === right.id;
 }
 var UserUnderstandingService = class {
-	constructor(options) {
-		this.options = options;
-	}
 	async reviewTurn(params) {
+		params.assistantContent;
 		const candidates = extractExplicitUnderstandingCandidates(params.userContent);
-		const sourceText = `User:\n${params.userContent.trim()}\n\nAssistant:\n${params.assistantContent.trim()}`;
-		const normalizedText = redactSensitiveMemoryText(sourceText);
-		const contentHash = createHash("sha256").update(sourceText).digest("hex");
-		const sourceItemId = upsertKnowledgeSourceItems([{
-			sourceInstanceId: params.sessionKey ? `session:${params.sessionKey}` : "session:unknown",
-			collectionScope: "conversation",
-			externalId: contentHash,
-			itemType: "conversation_turn",
-			authorRole: "user",
-			occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
-			contentHash,
-			normalizedText,
-			metadata: params.sessionKey ? { sessionKey: params.sessionKey } : {},
-			sensitivity: "personal",
-			retentionClass: "bounded",
-			synthesisStatus: "pending"
-		}]).items[0]?.id;
+		if (candidates.length === 0) return {
+			proposed: 0,
+			created: 0,
+			deduplicated: 0,
+			rejected: 0,
+			createdRecords: []
+		};
+		const evidence = createContextEvidence({
+			sourceType: "conversation",
+			sourceRef: params.sessionKey ? `session:${params.sessionKey}:turn:${params.turnId ?? "unknown"}` : `turn:${params.turnId ?? "unknown"}`,
+			redactedExcerpt: redactSensitiveMemoryText(params.userContent).slice(0, MAX_CANDIDATE_CHARS),
+			trustLevel: "owner",
+			observedAt: Date.now()
+		});
 		return {
 			...await this.applyCandidates(candidates, {
-				agentId: params.agentId,
 				sessionKey: params.sessionKey,
-				sourceItemId,
-				sourceText: params.userContent,
+				workspaceId: params.workspaceId,
+				projectId: params.projectId,
+				evidenceIds: [evidence.id],
 				reviewSource: "turn",
 				supersedesRecordIds: params.correctionTargetRecordIds
 			}),
-			sourceItemId
+			sourceItemId: evidence.id
 		};
 	}
 	async applyCandidates(candidates, context) {
-		const startedAt = Date.now();
 		let created = 0;
 		let deduplicated = 0;
 		let rejected = 0;
-		const recordIds = [];
 		const createdRecords = [];
-		const correctionTargets = [...new Set(context.supersedesRecordIds ?? [])];
-		const conflictGroupId = correctionTargets.length > 1 ? randomUUID() : void 0;
-		if (conflictGroupId) markMemoryRecordsConflicted(correctionTargets, conflictGroupId);
+		const correctionTarget = context.supersedesRecordIds?.length === 1 ? context.supersedesRecordIds[0] : void 0;
+		const evidenceIds = [...new Set(context.evidenceIds ?? [])];
+		const sourceItemIds = [context.sourceItemId, ...context.sourceItemIds ?? []].filter((value) => Boolean(value));
+		for (const sourceItemId of [...new Set(sourceItemIds)]) {
+			const evidence = createContextEvidence({
+				sourceType: context.source?.provider ? "connector" : "runtime",
+				...context.source?.sourceInstanceId ? { sourceInstanceId: context.source.sourceInstanceId } : {},
+				sourceRef: sourceItemId,
+				...context.sourceText ? { redactedExcerpt: redactSensitiveMemoryText(context.sourceText).slice(0, MAX_CANDIDATE_CHARS) } : {},
+				trustLevel: context.source?.provider ? "untrusted" : "trusted",
+				observedAt: Date.now()
+			});
+			evidenceIds.push(evidence.id);
+		}
 		for (const candidate of candidates.slice(0, 10)) {
 			const content = normalizeContent(candidate.content);
-			const sensitivity = stricterSensitivity(content, candidate.sensitivity);
-			if (content.length < 4 || candidate.confidence < .55 || sensitivity === "secret" || sensitivity === "regulated") {
+			const sensitivity = effectiveSensitivity(candidate.sensitivity, content);
+			const scope = scopeForCandidate(candidate, context);
+			const key = candidate.canonicalKey ?? canonicalKey(candidate.kind, content);
+			if (content.length < 4 || candidate.confidence < .55 || sensitivity === "secret" || sensitivity === "regulated" || isUnderstandingSuppressed(key, scope)) {
 				rejected += 1;
 				continue;
 			}
-			const evidenceText = context.sourceText ? redactSensitiveMemoryText(context.sourceText).slice(0, MAX_CANDIDATE_CHARS) : void 0;
-			const key = candidate.canonicalKey ?? canonicalKey(candidate.kind, content);
-			const supersedesRecordId = correctionTargets.length === 1 ? correctionTargets[0] : void 0;
-			const existing = await this.options.list(key);
-			const sourceItemIds = [...new Set([...context.sourceItemId ? [context.sourceItemId] : [], ...context.sourceItemIds ?? []])];
-			const evidence = (sourceItemIds.length ? sourceItemIds : [void 0]).map((sourceItemId) => ({
-				...sourceItemId ? { sourceItemId } : {},
-				relation: "supports",
-				...context.sessionKey ? { sessionKey: context.sessionKey } : {},
-				...evidenceText ? { sourceText: evidenceText } : {},
-				observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				confidence: candidate.confidence
-			}));
-			if (existing[0]) {
+			const duplicate = listUnderstandings().find((item) => item.canonicalKey === key && item.status !== "rejected" && item.status !== "archived" && sameScope(item.scope, scope));
+			if (duplicate) {
+				for (const evidenceId of evidenceIds) linkUnderstandingEvidence(duplicate.versionId, evidenceId, "supports", candidate.confidence);
 				deduplicated += 1;
-				recordIds.push(existing[0].id);
-				for (const sourceItemId of sourceItemIds) attachMemoryEvidence({
-					recordId: existing[0].id,
-					sourceItemId,
-					relation: "supports",
-					excerpt: evidenceText,
-					confidence: candidate.confidence
-				});
 				continue;
 			}
-			const write = await this.options.write({
+			const isExplicit = candidate.explicitness === "explicit";
+			const record = createUnderstanding({
 				kind: candidate.kind,
-				content,
 				canonicalKey: key,
-				scope: context.agentId || context.sessionKey ? {
-					userId: "local-owner",
-					sessionKey: context.sessionKey
-				} : void 0,
-				tags: [...new Set(["user-understanding", ...candidate.tags ?? []])],
-				source: context.source ?? { provider: "user-understanding" },
-				confidence: candidate.confidence,
-				status: "candidate",
-				sensitivity,
+				status: isExplicit ? "active" : "candidate",
+				scope,
 				explicitness: candidate.explicitness,
 				durability: candidate.durability,
-				importance: candidate.importance,
+				sensitivity,
 				disclosurePolicy: candidate.disclosurePolicy,
-				evidence,
-				validFrom: candidate.validFrom,
-				validTo: candidate.validTo,
-				reviewAfter: nextMemoryReviewAt({
-					durability: candidate.durability,
-					explicitness: candidate.explicitness
-				}),
-				supersedesRecordId,
-				conflictGroupId
+				confidence: candidate.confidence,
+				statement: content,
+				createdBy: context.reviewSource === "background" ? "consolidation" : "runtime",
+				changeReason: context.reviewSource === "background" ? "background synthesis" : "explicit user statement",
+				...candidate.validFrom ? { validFrom: Date.parse(candidate.validFrom) } : {},
+				...candidate.validTo ? { validTo: Date.parse(candidate.validTo) } : {},
+				...correctionTarget ? { supersedesId: correctionTarget } : {}
 			});
-			if (write.success) {
-				created += 1;
-				if (write.record) {
-					recordIds.push(write.record.id);
-					createdRecords.push({
-						id: write.record.id,
-						content: write.record.content,
-						kind: write.record.kind
-					});
-				}
-				for (const sourceItemId of write.record ? sourceItemIds : []) attachMemoryEvidence({
-					recordId: write.record.id,
-					sourceItemId,
-					relation: "supports",
-					excerpt: evidenceText,
-					confidence: candidate.confidence
-				});
-			} else {
-				rejected += 1;
-				log.debug({
-					errorMessage: write.error,
-					canonicalKey: key
-				}, "Understanding candidate was not stored");
-			}
-		}
-		try {
-			appendMemoryTraceEvent({
-				sessionKey: context.sessionKey,
-				phase: "understanding",
-				providerId: "user-understanding",
-				request: {
-					...context.agentId ? { agentId: context.agentId } : {},
-					source: context.reviewSource ?? "turn",
-					proposed: candidates.length,
-					created,
-					deduplicated,
-					rejected
-				},
-				resultCount: created,
-				selectedRecordIds: recordIds,
-				durationMs: Date.now() - startedAt
+			for (const evidenceId of evidenceIds) linkUnderstandingEvidence(record.versionId, evidenceId, "supports", candidate.confidence);
+			if (correctionTarget && isExplicit) setUnderstandingStatus(correctionTarget, "archived");
+			created += 1;
+			createdRecords.push({
+				id: record.id,
+				content: record.statement,
+				kind: record.kind
 			});
-		} catch (err) {
-			log.debug({
-				err,
-				sessionKey: context.sessionKey
-			}, "Understanding quality trace append failed");
 		}
 		return {
 			proposed: candidates.length,

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

@@ -1,15 +1,14 @@
-import type { MemoryDisclosurePolicy, MemoryDurability, MemoryExplicitness, MemoryKind, MemorySensitivity } from '../types.js';
+import type { UnderstandingKind, UserUnderstanding } from '../../../user-context/domain.js';
 export interface UnderstandingCandidate {
-    kind: MemoryKind;
+    kind: UnderstandingKind;
     content: string;
     canonicalKey?: string;
     confidence: number;
     importance: number;
-    explicitness: MemoryExplicitness;
-    durability: MemoryDurability;
-    sensitivity: MemorySensitivity;
-    disclosurePolicy: MemoryDisclosurePolicy;
-    tags?: string[];
+    explicitness: UserUnderstanding['explicitness'];
+    durability: UserUnderstanding['durability'];
+    sensitivity: UserUnderstanding['sensitivity'];
+    disclosurePolicy: UserUnderstanding['disclosurePolicy'];
     validFrom?: string;
     validTo?: string;
 }
@@ -22,6 +21,6 @@ export interface UnderstandingReviewResult {
     createdRecords: Array<{
         id: string;
         content: string;
-        kind: MemoryKind;
+        kind: UnderstandingKind;
     }>;
 }

package/dist/src/agent/memory/user-context-coordinator.d.ts

@@ -6,6 +6,8 @@ export interface UserContextCoordinatorOptions {
     getConfig: () => Config | undefined;
     isEnabledForSession: (sessionKey: string) => boolean;
     getAgentIdForSession: (sessionKey: string) => string;
+    getWorkspaceIdForSession?: (sessionKey: string) => string;
+    getProjectIdForSession?: (sessionKey: string) => string | undefined;
     getMemoryManagerForSession: (sessionKey: string) => MemoryManager;
     getLastAssistantContent: (sessionKey: string) => string | null;
 }
@@ -15,7 +17,6 @@ export declare class UserContextCoordinator {
     private readonly lastTurnId;
     private readonly correctionTargets;
     private readonly planner;
-    private readonly contextCompiler;
     constructor(options: UserContextCoordinatorOptions);
     forgetSession(sessionKey: string): void;
     clear(): void;

package/dist/src/agent/memory/user-context-coordinator.js

@@ -1,14 +1,15 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { setMemoryTurnFeedback } from "../../storage/sqlite/memory-records-repository.js";
+import { getTurnPersonalization, recordContextFeedback, setUnderstandingStatus } from "../../storage/sqlite/user-context-repository.js";
 import "../../storage/sqlite/index.js";
+import { init_session_key, parseSessionKey } from "../../routing/session-key.js";
 import { assembleTaskContext } from "../../tasks/task-context-assembler.js";
 import { shouldPlanUserContextThisTurn } from "./memory-config.js";
-import { ContextCompiler } from "../../user-context/context-compiler.js";
-import { UserContextPlanner } from "./context/planner.js";
+import { UserContextPlanner } from "../../user-context/planner.js";
 import { isExplicitUnderstandingCorrection } from "./understanding/correction.js";
 import { extractAgentUserPlainText } from "./user-message-text.js";
 //#region src/agent/memory/user-context-coordinator.ts
+init_session_key();
 init_logger();
 const log = createLogger("UserContextCoordinator");
 var UserContextCoordinator = class {
@@ -16,7 +17,6 @@ var UserContextCoordinator = class {
 	lastTurnId = /* @__PURE__ */ new Map();
 	correctionTargets = /* @__PURE__ */ new Map();
 	planner = new UserContextPlanner();
-	contextCompiler = new ContextCompiler();
 	constructor(options) {
 		this.options = options;
 	}
@@ -49,26 +49,22 @@ var UserContextCoordinator = class {
 		this.correctionTargets.delete(sessionKey);
 		let excludedRecordIds;
 		if (previousTurnId && isExplicitUnderstandingCorrection(userQuery)) try {
-			const trace = setMemoryTurnFeedback({
-				turnId: previousTurnId,
-				rating: "incorrect",
-				source: "system",
-				reasonCode: "detected_explicit_user_correction"
-			});
-			if (trace?.selectedRecordIds.length) {
-				this.correctionTargets.set(sessionKey, trace.selectedRecordIds);
-				excludedRecordIds = trace.selectedRecordIds;
-				if (trace.selectedRecordIds.length === 1) setMemoryTurnFeedback({
-					turnId: previousTurnId,
-					rating: "incorrect",
-					source: "system",
-					reasonCode: "detected_explicit_user_correction",
-					records: [{
-						recordId: trace.selectedRecordIds[0],
-						rating: "incorrect",
-						reasonCode: "detected_explicit_user_correction"
-					}]
-				});
+			const personalization = getTurnPersonalization(previousTurnId);
+			const selectedIds = personalization?.items.filter((item) => item.objectType === "understanding" && item.decision === "selected").map((item) => item.objectId) ?? [];
+			if (personalization && selectedIds.length) {
+				for (const recordId of selectedIds) {
+					recordContextFeedback({
+						turnId: previousTurnId,
+						runId: personalization.runId,
+						objectType: "understanding",
+						objectId: recordId,
+						rating: "wrong",
+						reason: "detected_explicit_user_correction"
+					});
+					setUnderstandingStatus(recordId, "needs_review");
+				}
+				this.correctionTargets.set(sessionKey, selectedIds);
+				excludedRecordIds = selectedIds;
 			}
 		} catch (err) {
 			log.debug({
@@ -79,30 +75,17 @@ var UserContextCoordinator = class {
 		const turn = (this.userTurn.get(sessionKey) ?? 0) + 1;
 		this.userTurn.set(sessionKey, turn);
 		if (!shouldPlanUserContextThisTurn(config, turn)) return empty();
-		const plan = await this.planner.plan({
-			memoryManager: this.options.getMemoryManagerForSession(sessionKey),
-			agentId: this.options.getAgentIdForSession(sessionKey),
+		return this.planner.plan({
 			sessionKey,
+			channel: parseSessionKey(sessionKey)?.source,
+			workspaceId: this.options.getWorkspaceIdForSession?.(sessionKey) ?? "",
+			projectId: this.options.getProjectIdForSession?.(sessionKey),
 			turnId,
 			query,
 			userMessage,
 			excludedRecordIds,
 			allocation: taskContext.allocation
 		});
-		if (plan.traceId) try {
-			this.contextCompiler.capture({
-				sessionKey,
-				query,
-				plan
-			});
-		} catch (err) {
-			log.debug({
-				err,
-				sessionKey,
-				traceId: plan.traceId
-			}, "Context snapshot was not persisted");
-		}
-		return plan;
 	}
 	async afterTurn(sessionKey, userPlainText) {
 		if (!this.options.isEnabledForSession(sessionKey)) return void 0;
@@ -114,6 +97,9 @@ var UserContextCoordinator = class {
 			const review = await memoryManager.captureTurnUnderstanding(userPlainText, assistantContent, {
 				agentId: this.options.getAgentIdForSession(sessionKey),
 				sessionId: sessionKey,
+				turnId: this.lastTurnId.get(sessionKey),
+				workspaceId: this.options.getWorkspaceIdForSession?.(sessionKey),
+				projectId: this.options.getProjectIdForSession?.(sessionKey),
 				correctionTargetRecordIds
 			});
 			memoryManager.syncProvidersForTurn(userPlainText, assistantContent, { sessionId: sessionKey });

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

@@ -1,13 +1,12 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import "../memory/dreaming/constants.js";
+import { runContextConsolidation } from "../../user-context/consolidation.js";
 import { persistInboundAttachments } from "../../channels/attachments/inbound-persist.js";
 import { buildTranscriptUserMessage, clearPendingTranscriptUserMessage, hydrateUserTurnForLlm, setPendingTranscriptUserMessage } from "../inbound/attachment-pipeline.js";
 import { extractAgentUserPlainText } from "../memory/user-message-text.js";
 import { resolveEffectiveThinkingLevel } from "../../session/thinking-resolve.js";
 import { abortEmbeddedRun } from "../embedded/runs.js";
 import { runEmbeddedTurnForSession } from "../embedded/run-for-session.js";
-import { runDreamingPhase } from "../memory/dreaming/runner.js";
 import { randomUUID } from "node:crypto";
 //#region src/agent/orchestration/agent-orchestrator.ts
 /**
@@ -51,16 +50,14 @@ 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")) {
-			const content = msg.content;
-			if (content.includes("__xopc_memory_dreaming_sweep__") || content.includes("__xopc_memory_dreaming_light_sweep__") || content.includes("__xopc_memory_dreaming_rem_sweep__")) {
+			if (msg.content.includes("__xopc_user_context_consolidation__")) {
 				const cfg = this.getConfig?.();
 				if (!cfg) {
-					log.warn({ sessionKey }, "Dreaming sweep skipped: config unavailable");
+					log.warn({ sessionKey }, "User context review skipped: config unavailable");
 					return;
 				}
-				await runDreamingPhase({
+				await runContextConsolidation({
 					config: cfg,
-					phase: content.includes("__xopc_memory_dreaming_light_sweep__") ? "light" : content.includes("__xopc_memory_dreaming_rem_sweep__") ? "rem" : "deep",
 					triggerKind: "schedule"
 				});
 				return;

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

@@ -5,7 +5,7 @@ function buildMemorySection(params) {
 	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 structured user-understanding records");
+	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("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`);
@@ -14,7 +14,7 @@ function buildMemorySection(params) {
 		"",
 		citationInstruction,
 		"",
-		"User understanding is compiled from structured records and injected above when relevant.",
+		"Relevant user understanding is selected separately and injected above.",
 		"",
 		"Before answering anything about prior work, decisions, dates, people, preferences, or todos:",
 		...toolLines,
@@ -22,11 +22,11 @@ function buildMemorySection(params) {
 		"### Memory Sources",
 		"",
 		"- **Session history:** use `session_search` when available for other chats and prior turns.",
-		"- **Structured memory:** cite only record ids returned by `memory_search` / `memory_get`.",
+		"- **Workspace memory:** cite only record ids returned by `memory_search` / `memory_get`.",
 		"",
 		"### Writing to Memory",
 		"",
-		"- **Declarative vs procedural:** facts and preferences belong to structured memory; reusable task playbooks belong to skills.",
+		"- **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**"

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

@@ -1,10 +1,5 @@
 //#region src/agent/prompt/sections/tooling.ts
 const CORE_TOOL_ORDER = [
-	"code_search",
-	"code_read_symbol",
-	"code_trace",
-	"code_impact",
-	"code_architecture",
 	"read_file",
 	"write_file",
 	"apply_patch",
@@ -41,11 +36,6 @@ const CORE_TOOL_ORDER = [
 	"execute_code"
 ];
 const CORE_TOOL_SUMMARIES = {
-	code_search: "Find definitions, implementations, routes, types, and structurally important symbols",
-	code_read_symbol: "Read exact source for a graph symbol before editing",
-	code_trace: "Trace callers, callees, data flow, and cross-service paths",
-	code_impact: "Map git changes to affected symbols and blast radius",
-	code_architecture: "Map packages, boundaries, layers, entry points, hotspots, and clusters",
 	read_file: "Read targeted file contents before editing",
 	write_file: "Create new files or intentional complete rewrites; prefer apply_patch for code changes",
 	apply_patch: "Apply source edits with patches that begin exactly with *** Begin Patch and end exactly with *** End Patch",

package/dist/src/agent/prompt/service-prompt-builder.d.ts

@@ -39,7 +39,6 @@ export declare class SystemPromptBuilder {
     constructor(config: SystemPromptBuilderConfig);
     build(contextFiles: EmbeddedContextFile[], options: SystemPromptBuildOptions): string;
     rebuild(contextFiles: EmbeddedContextFile[], options: SystemPromptBuildOptions): string;
-    private extractTimezone;
     getSkillPrompt(): string;
     getBasePrompt(contextFiles: EmbeddedContextFile[], options?: {
         externalMemoryInstructions?: string;