@xopcai/xopc 0.0.228 → 0.0.229

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

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

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

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

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

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

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

@@ -1,27 +1,12 @@
-import { finishContextExtractionRun, getContextExtractionRun, listContextExtractionOutputs } from "../../../storage/sqlite/context-extraction-repository.js";
+import { getContextExtractionRun } from "../../../storage/sqlite/context-extraction-repository.js";
 import { closeTemporalAssertions, createTemporalAssertion, linkContextObjects } from "../../../storage/sqlite/context-relation-repository.js";
 import { closeUnderstandingValidity, createContextEvidence, createUnderstanding, getUnderstanding, isUnderstandingSuppressed, linkUnderstandingEvidence, listUnderstandings, setUnderstandingStatus } from "../../../storage/sqlite/user-context-repository.js";
 import "../../../storage/sqlite/index.js";
-import { extractExplicitUnderstandingCorrectionContent } from "./correction.js";
-import { claimRegisteredExtraction, extractionInputHash, getRegisteredExtractorDefinition } from "../../../user-context/extraction/registry.js";
+import { getRegisteredExtractorDefinition } from "../../../user-context/extraction/registry.js";
 import { canonicalUnderstandingKey, findContradictoryUnderstanding, findDuplicateUnderstanding } from "../../../user-context/understanding.js";
 import { inferMemorySensitivity, redactSensitiveMemoryText } from "../sensitivity.js";
 //#region src/agent/memory/understanding/service.ts
 const MAX_CANDIDATE_CHARS = 600;
-const EXPLICIT_PATTERNS = [
-	/\b(?:please\s+)?remember(?:\s+that)?\s+(.+)/i,
-	/\bkeep\s+in\s+mind(?:\s+that)?\s+(.+)/i,
-	/(?:请)?记住[：:\s]*(.+)/
-];
-const HIGH_SIGNAL_PATTERNS = [
-	/(?:从现在起|今后|以后)(?:都)?(?:请)?[：:\s]*(.+)/,
-	/下次(?:请)?[：:\s]*(.+)/,
-	/(?:默认|每次|每回)(?:都)?(?:请)?[：:\s]*(.+)/,
-	/((?:我|本人)(?:一直|通常|一般|更)?(?:喜欢|偏好|习惯|希望|不希望|不喜欢).+)/,
-	/\b(?:from now on|going forward|next time|by default|whenever)\b[,:\s]*(.+)/i,
-	/(\bi\s+(?:always|usually|generally)\s+(?:prefer|like|want|need|avoid)\b.+)/i,
-	/(\bi\s+(?:prefer|like|want|need)\s+.+\s+(?:every time|by default|going forward)\b.*)/i
-];
 const SENSITIVITY_RANK = {
 	normal: 0,
 	personal: 1,
@@ -40,50 +25,6 @@ function candidateTime(value) {
 	const parsed = Date.parse(value);
 	return Number.isFinite(parsed) ? parsed : void 0;
 }
-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(project|repo|codebase|workspace)\b/i.test(content) || /项目|仓库|代码库/.test(content)) return "project_context";
-	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 extractExplicitUnderstandingCandidates(userContent) {
-	const correction = extractExplicitUnderstandingCorrectionContent(userContent);
-	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: canonicalUnderstandingKey(kind, content),
-		confidence: correction ? .98 : .95,
-		importance: kind === "boundary" ? .9 : .8,
-		explicitness: "explicit",
-		durability: "durable",
-		sensitivity: inferMemorySensitivity(content),
-		disclosurePolicy: kind === "boundary" ? "silent" : "referenceable"
-	}];
-}
-function extractHighSignalUnderstandingCandidates(userContent) {
-	if (extractExplicitUnderstandingCorrectionContent(userContent)) return [];
-	const matched = userContent.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap((line) => HIGH_SIGNAL_PATTERNS.map((pattern) => pattern.exec(line)?.[1] ?? "")).map(normalizeContent).find((content) => content.length >= 6);
-	if (!matched) return [];
-	const kind = inferKind(matched);
-	return [{
-		kind,
-		content: matched,
-		canonicalKey: canonicalUnderstandingKey(kind, matched),
-		confidence: .85,
-		importance: kind === "boundary" ? .9 : .75,
-		explicitness: "observed",
-		durability: "durable",
-		sensitivity: inferMemorySensitivity(matched),
-		disclosurePolicy: kind === "boundary" ? "silent" : "referenceable"
-	}];
-}
 function scopeForCandidate(candidate, context) {
 	if (candidate.durability === "ephemeral" && context.sessionKey) return {
 		type: "session",
@@ -100,116 +41,6 @@ function scopeForCandidate(candidate, context) {
 	return { type: "global" };
 }
 var UserUnderstandingService = class {
-	async reviewTurn(params) {
-		params.assistantContent;
-		const explicitCandidates = extractExplicitUnderstandingCandidates(params.userContent);
-		const candidates = explicitCandidates.length > 0 ? explicitCandidates : extractHighSignalUnderstandingCandidates(params.userContent);
-		const turnRef = params.turnId ?? `untracked-${extractionInputHash(params.userContent).slice(0, 16)}`;
-		const extraction = claimRegisteredExtraction({
-			extractorId: explicitCandidates.length > 0 ? "explicit-command" : "deterministic-signal",
-			sourceRef: params.sessionKey ? `session:${params.sessionKey}:turn:${turnRef}` : `turn:${turnRef}`,
-			contentForHash: params.userContent,
-			processingPolicy: "local_only",
-			destination: "deterministic"
-		});
-		if (!extraction.shouldExecute) {
-			const previous = listContextExtractionOutputs(extraction.run.id);
-			return {
-				proposed: candidates.length,
-				created: 0,
-				deduplicated: previous.filter((output) => output.outcome !== "rejected").length,
-				rejected: previous.filter((output) => output.outcome === "rejected").length,
-				createdRecords: []
-			};
-		}
-		if (candidates.length === 0) {
-			finishContextExtractionRun({
-				runId: extraction.run.id,
-				status: "completed",
-				outputs: []
-			});
-			return {
-				proposed: 0,
-				created: 0,
-				deduplicated: 0,
-				rejected: 0,
-				createdRecords: []
-			};
-		}
-		const safeCandidates = candidates.filter((candidate) => {
-			const content = normalizeContent(candidate.content);
-			const sensitivity = effectiveSensitivity(candidate.sensitivity, content);
-			return sensitivity !== "secret" && sensitivity !== "regulated";
-		});
-		if (!safeCandidates.length) {
-			finishContextExtractionRun({
-				runId: extraction.run.id,
-				status: "completed",
-				outputs: candidates.map((candidate) => ({
-					candidateKey: candidate.canonicalKey ?? canonicalUnderstandingKey(candidate.kind, candidate.content),
-					outcome: "rejected"
-				}))
-			});
-			return {
-				proposed: candidates.length,
-				created: 0,
-				deduplicated: 0,
-				rejected: candidates.length,
-				createdRecords: []
-			};
-		}
-		const evidence = createContextEvidence({
-			sourceType: "conversation",
-			sourceRef: params.sessionKey ? `session:${params.sessionKey}:turn:${turnRef}` : `turn:${turnRef}`,
-			sourceRunId: extraction.run.id,
-			...params.sessionKey ? { sessionId: params.sessionKey } : {},
-			turnId: turnRef,
-			contentHash: extractionInputHash(params.userContent),
-			retentionPolicy: "derived_only",
-			processingPolicy: "local_only",
-			extractorId: extraction.run.extractorId,
-			extractorVersion: extraction.run.extractorVersion,
-			redactedExcerpt: redactSensitiveMemoryText(safeCandidates.map((candidate) => candidate.content).join("\n")).slice(0, MAX_CANDIDATE_CHARS),
-			trustLevel: "owner",
-			observedAt: Date.now()
-		});
-		let result;
-		try {
-			result = await this.applyCandidates(safeCandidates, {
-				sessionKey: params.sessionKey,
-				workspaceId: params.workspaceId,
-				projectId: params.projectId,
-				evidenceIds: [evidence.id],
-				reviewSource: "turn",
-				supersedesRecordIds: params.correctionTargetRecordIds,
-				extractionRunId: extraction.run.id
-			});
-		} catch (error) {
-			finishContextExtractionRun({
-				runId: extraction.run.id,
-				status: "failed",
-				errorCode: "write_failed"
-			});
-			throw error;
-		}
-		finishContextExtractionRun({
-			runId: extraction.run.id,
-			status: "completed",
-			outputs: result.writeOutputs?.map((output) => ({
-				candidateKey: output.candidateKey,
-				objectType: output.objectId ? "understanding" : void 0,
-				objectId: output.objectId,
-				versionId: output.versionId,
-				outcome: output.outcome
-			})) ?? []
-		});
-		return {
-			...result,
-			proposed: candidates.length,
-			rejected: result.rejected + candidates.length - safeCandidates.length,
-			sourceItemId: evidence.id
-		};
-	}
 	async applyCandidates(candidates, context) {
 		let created = 0;
 		let deduplicated = 0;
@@ -332,7 +163,10 @@ var UserUnderstandingService = class {
 					objectId: supersededId,
 					validTo: closedAt
 				});
-				setUnderstandingStatus(supersededId, "archived");
+				setUnderstandingStatus(supersededId, "archived", {
+					actorType: "user",
+					source: "semantic-memory-superseded"
+				});
 			}
 			const assertionType = record.kind === "current_state" ? "current_state" : record.kind === "routine" ? "routine" : record.kind === "relationship" ? "relationship" : record.kind === "project_context" ? "project_status" : void 0;
 			if (assertionType) createTemporalAssertion({
@@ -372,4 +206,4 @@ var UserUnderstandingService = class {
 	}
 };
 //#endregion
-export { UserUnderstandingService, extractExplicitUnderstandingCandidates, extractHighSignalUnderstandingCandidates };
+export { UserUnderstandingService };

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

@@ -5,7 +5,6 @@ import type { MemoryManager } from './manager.js';
 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;
@@ -15,11 +14,10 @@ export declare class UserContextCoordinator {
     private readonly options;
     private readonly userTurn;
     private readonly lastTurnId;
-    private readonly correctionTargets;
     private readonly planner;
     constructor(options: UserContextCoordinatorOptions);
     forgetSession(sessionKey: string): void;
     clear(): void;
     prepare(userMessage: AgentMessage, sessionKey: string, turnId: string): Promise<UserContextPlan>;
-    afterTurn(sessionKey: string, userPlainText: string): Promise<import('./understanding/types.js').UnderstandingReviewResult | undefined>;
+    afterTurn(sessionKey: string, userPlainText: string): Promise<void>;
 }

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

@@ -1,19 +1,12 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.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 { UserContextPlanner, prependAgentContext } from "../../user-context/planner.js";
-import { isExplicitUnderstandingCorrection } from "./understanding/correction.js";
 import { extractAgentUserPlainText } from "./user-message-text.js";
 import { consumeTurnMemoryProvenance, markTurnRecalledContext } from "./turn-provenance.js";
 import { planTrustedRecall } from "./trusted-recall.js";
 //#region src/agent/memory/user-context-coordinator.ts
 init_session_key();
-init_logger();
-const log = createLogger("UserContextCoordinator");
 function isPrivateSession(sessionKey) {
 	const parsed = parseSessionKey(sessionKey);
 	return !parsed || parsed.peerKind === "direct";
@@ -21,7 +14,6 @@ function isPrivateSession(sessionKey) {
 var UserContextCoordinator = class {
 	userTurn = /* @__PURE__ */ new Map();
 	lastTurnId = /* @__PURE__ */ new Map();
-	correctionTargets = /* @__PURE__ */ new Map();
 	planner = new UserContextPlanner();
 	constructor(options) {
 		this.options = options;
@@ -29,12 +21,10 @@ var UserContextCoordinator = class {
 	forgetSession(sessionKey) {
 		this.userTurn.delete(sessionKey);
 		this.lastTurnId.delete(sessionKey);
-		this.correctionTargets.delete(sessionKey);
 	}
 	clear() {
 		this.userTurn.clear();
 		this.lastTurnId.clear();
-		this.correctionTargets.clear();
 	}
 	async prepare(userMessage, sessionKey, turnId) {
 		const empty = () => ({
@@ -50,37 +40,9 @@ var UserContextCoordinator = class {
 		if (!this.options.isEnabledForSession(sessionKey)) return empty();
 		const config = this.options.getConfig();
 		if (!isPrivateSession(sessionKey)) return empty();
-		const userQuery = extractAgentUserPlainText(userMessage);
-		const taskContext = assembleTaskContext(sessionKey, userQuery);
+		const taskContext = assembleTaskContext(sessionKey, extractAgentUserPlainText(userMessage));
 		const query = taskContext.retrievalQuery;
-		const previousTurnId = this.lastTurnId.get(sessionKey);
 		this.lastTurnId.set(sessionKey, turnId);
-		this.correctionTargets.delete(sessionKey);
-		let excludedRecordIds;
-		if (previousTurnId && isExplicitUnderstandingCorrection(userQuery)) try {
-			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({
-				err,
-				sessionKey
-			}, "Understanding correction feedback was not persisted");
-		}
 		const turn = (this.userTurn.get(sessionKey) ?? 0) + 1;
 		this.userTurn.set(sessionKey, turn);
 		if (!shouldPlanUserContextThisTurn(config, turn)) return empty();
@@ -92,7 +54,6 @@ var UserContextCoordinator = class {
 			turnId,
 			query,
 			userMessage,
-			excludedRecordIds,
 			allocation: taskContext.allocation
 		});
 		const totalChars = taskContext.allocation.maxChars;
@@ -134,36 +95,12 @@ var UserContextCoordinator = class {
 		};
 	}
 	async afterTurn(sessionKey, userPlainText) {
-		if (!this.options.isEnabledForSession(sessionKey)) return void 0;
+		if (!this.options.isEnabledForSession(sessionKey)) return;
 		const memoryManager = this.options.getMemoryManagerForSession(sessionKey);
 		const assistantContent = this.options.getLastAssistantContent(sessionKey) ?? "";
-		if (!isPrivateSession(sessionKey)) return void 0;
-		const correctionTargetRecordIds = this.correctionTargets.get(sessionKey);
+		if (!isPrivateSession(sessionKey)) return;
 		const turnId = this.lastTurnId.get(sessionKey);
 		const provenance = turnId ? consumeTurnMemoryProvenance(sessionKey, turnId) : void 0;
-		this.correctionTargets.delete(sessionKey);
-		try {
-			const review = await memoryManager.captureTurnUnderstanding(userPlainText, assistantContent, {
-				agentId: this.options.getAgentIdForSession(sessionKey),
-				sessionId: sessionKey,
-				turnId,
-				workspaceId: this.options.getWorkspaceIdForSession?.(sessionKey),
-				projectId: this.options.getProjectIdForSession?.(sessionKey),
-				correctionTargetRecordIds
-			});
-			memoryManager.syncProvidersForTurn(userPlainText, assistantContent, {
-				sessionId: sessionKey,
-				turnId,
-				provenance
-			});
-			memoryManager.queuePrefetchAll(userPlainText, { sessionId: sessionKey });
-			return review;
-		} catch (err) {
-			log.warn({
-				err,
-				sessionKey
-			}, "Turn understanding capture failed");
-		}
 		memoryManager.syncProvidersForTurn(userPlainText, assistantContent, {
 			sessionId: sessionKey,
 			turnId,

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

@@ -110,7 +110,7 @@ var AgentOrchestrator = class {
 					clearPendingTranscriptUserMessage(sessionKey, userMessage);
 				}
 			})();
-			const understandingReview = await this.agentManager.afterAgentTurn(sessionKey, userPlainForMemory);
+			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");

package/dist/src/agent/service/direct-turn-helpers.js

@@ -116,7 +116,7 @@ async function runDirectAgentTurn(deps, input) {
 		beforeTurn: () => deps.agentManager.beginBackgroundReviewUserTurn(input.sessionKey),
 		onEvent: input.onEvent
 	});
-	const understandingReview = await deps.agentManager.afterAgentTurn(input.sessionKey, userPlain);
+	const understandingReview = await deps.agentManager.afterAgentTurn(input.sessionKey, userPlain, turnId);
 	if (understandingReview?.createdRecords.length) {
 		const captured = understandingReview.createdRecords.filter((record) => record.status === "active");
 		const candidates = understandingReview.createdRecords.filter((record) => record.status === "candidate");

package/dist/src/cli/commands/doctor/checks/database-schema.js

@@ -52,7 +52,7 @@ async function checkDatabaseSchema(ctx) {
 		id: "database-schema",
 		label: "Database schema",
 		status: "pass",
-		message: `SQLite schema v${status.dbVersion} (current release v136).`,
+		message: `SQLite schema v${status.dbVersion} (current release v137).`,
 		hints: []
 	};
 }

package/dist/src/config/schema.d.ts

@@ -1572,6 +1572,10 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
         }, z.core.$strict>>;
         understanding: z.ZodDefault<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodBoolean>;
+            processingPolicy: z.ZodDefault<z.ZodEnum<{
+                local_only: "local_only";
+                remote_allowed: "remote_allowed";
+            }>>;
             adaptiveCadence: z.ZodDefault<z.ZodBoolean>;
             reviewIntervalTurns: z.ZodDefault<z.ZodNumber>;
             maxHistoryMessages: z.ZodDefault<z.ZodNumber>;

package/dist/src/config/schema.js

@@ -1059,6 +1059,7 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 			},
 			understanding: {
 				enabled: true,
+				processingPolicy: "remote_allowed",
 				adaptiveCadence: true,
 				reviewIntervalTurns: 10,
 				maxHistoryMessages: 80,

package/dist/src/connectors/connected-source-understanding.js

@@ -6,7 +6,6 @@ import { upsertUserFocus } from "../user-context/sources/repository.js";
 import { claimRegisteredExtraction } from "../user-context/extraction/registry.js";
 import { allowsRemoteSourceProcessing } from "../user-context/sources/processing-policy.js";
 import { analyzeUnderstandingSources } from "../work-discovery/analyzer.js";
-import { createHash } from "node:crypto";
 //#region src/connectors/connected-source-understanding.ts
 const MAX_CONNECTED_ITEMS = 150;
 function normalizedValue(item) {
@@ -60,17 +59,14 @@ function connectedItemsForUnderstanding(items) {
 		}];
 	});
 }
-function understandingKind(category) {
-	if (category === "preference") return "preference";
-	if (category === "routine") return "routine";
-	return "project_context";
+function isConnectedPortraitCandidate(candidate) {
+	return candidate.category === "preference" || candidate.category === "routine";
 }
 function understandingCandidate(candidate) {
-	const normalized = candidate.statement.toLocaleLowerCase().replace(/[^\p{L}\p{N}]+/gu, " ").trim();
 	return {
-		kind: understandingKind(candidate.category),
+		kind: candidate.category,
 		content: candidate.statement,
-		canonicalKey: `connected-semantic:${candidate.category}:${createHash("sha256").update(normalized).digest("hex").slice(0, 20)}`,
+		canonicalKey: `understanding:${candidate.category}:${candidate.factKey}`,
 		confidence: candidate.confidence === "high" ? .9 : candidate.confidence === "medium" ? .72 : .55,
 		importance: .68,
 		explicitness: "inferred",
@@ -84,6 +80,18 @@ function hasLongVerbatimOverlap(value, sourceTexts, minimumLength = 32) {
 	if (normalized.length < minimumLength) return false;
 	return sourceTexts.some((source) => source.replace(/\s+/g, " ").includes(normalized));
 }
+function evidenceDate(item) {
+	const timestamp = item.occurredAt ?? item.modifiedAt;
+	return timestamp == null ? void 0 : new Date(timestamp).toISOString().slice(0, 10);
+}
+function durableConnectedEvidence(candidate, itemsByRef) {
+	if (candidate.confidence !== "high") return [];
+	const items = [...new Set(candidate.evidenceRefs ?? [])].flatMap((ref) => itemsByRef.get(ref) ?? []);
+	if (items.some((item) => item.ownerAttribution !== "user")) return [];
+	const required = candidate.category === "routine" ? 3 : 2;
+	const dates = new Set(items.map(evidenceDate).filter((value) => Boolean(value)));
+	return items.length >= required && dates.size >= required ? items : [];
+}
 async function deriveConnectedSourceUnderstanding(input) {
 	const knowledgeItems = listKnowledgeSourceItems({
 		agentId: input.agentId,
@@ -115,22 +123,28 @@ async function deriveConnectedSourceUnderstanding(input) {
 			items
 		});
 		const rawTexts = items.flatMap((item) => item.text ? [item.text] : []);
-		const profileCandidates = analysis.profileCandidates.filter((candidate) => !hasLongVerbatimOverlap(candidate.statement, rawTexts));
-		const sourceItemIds = [...new Set([...profileCandidates.flatMap((candidate) => candidate.evidenceRefs ?? []), ...analysis.workThreadCandidates.flatMap((candidate) => candidate.evidenceRefs)].map((ref) => ref.startsWith("knowledge-source://") ? ref.slice(19) : ""))].filter(Boolean).slice(0, 20);
-		const reviewed = profileCandidates.length ? await input.memoryManager.applyUnderstandingCandidates(profileCandidates.map(understandingCandidate), {
-			agentId: input.agentId,
-			sourceItemIds,
-			sourceText: "Bounded semantic synthesis from explicitly connected work sources.",
-			source: {
-				provider: "connected-sources",
-				sourceInstanceId: input.sourceInstanceId
-			},
-			reviewSource: "background",
-			extractionRunId: extraction.run.id
-		}) : {
+		const itemsByRef = new Map(items.map((item) => [item.evidenceRef, item]));
+		const profileCandidates = analysis.profileCandidates.filter(isConnectedPortraitCandidate).filter((candidate) => !hasLongVerbatimOverlap(candidate.statement, rawTexts) && durableConnectedEvidence(candidate, itemsByRef).length > 0);
+		const reviewed = {
 			created: 0,
 			writeOutputs: []
 		};
+		for (const candidate of profileCandidates) {
+			const evidenceItems = durableConnectedEvidence(candidate, itemsByRef);
+			const applied = await input.memoryManager.applyUnderstandingCandidates([understandingCandidate(candidate)], {
+				agentId: input.agentId,
+				sourceItemIds: evidenceItems.map((item) => item.id).slice(0, 20),
+				sourceText: "Bounded semantic synthesis from explicitly connected work sources.",
+				source: {
+					provider: "connected-sources",
+					sourceInstanceId: input.sourceInstanceId
+				},
+				reviewSource: "background",
+				extractionRunId: extraction.run.id
+			});
+			reviewed.created += applied.created;
+			reviewed.writeOutputs.push(...applied.writeOutputs ?? []);
+		}
 		const focuses = analysis.workThreadCandidates.filter((candidate) => !hasLongVerbatimOverlap(candidate.title, rawTexts) && !hasLongVerbatimOverlap(candidate.summary, rawTexts)).map((candidate) => upsertUserFocus({
 			canonicalKey: `connected-focus:${candidate.topicKey}`,
 			title: candidate.title,

package/dist/src/connectors/learning-coordinator.js

@@ -1,6 +1,5 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { finishContextExtractionRun } from "../storage/sqlite/context-extraction-repository.js";
 import { claimNextConnectorLearningJob, enqueueConnectorLearningJob, listConnectorLearningJobs, recoverStaleConnectorLearningJobs, setConnectorLearningPaused, updateConnectorLearningJob } from "../storage/sqlite/connector-learning-repository.js";
 import { getConnectorInstallation, listConnectorConnections, upsertConnectorConnection } from "../storage/sqlite/connector-repository.js";
 import { getConnectorAccount, reconcileConnectorAccount } from "../storage/sqlite/connector-account-repository.js";
@@ -11,10 +10,8 @@ import { ComposioSessionsAdapter } from "./composio-sessions.js";
 import { buildConnectorLearningArguments, getConnectorLearningPlan } from "./learning-recipes.js";
 import { getConnectorDefinition } from "./catalog.js";
 import { createUnderstandingSourceRun, getUnderstandingSourceGrant, listUnderstandingSourceRuns, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant } from "../user-context/sources/repository.js";
-import { claimRegisteredExtraction } from "../user-context/extraction/registry.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { ConnectedKnowledgePipeline } from "../knowledge/connected-knowledge-pipeline.js";
-import { ConnectedUnderstandingPipeline } from "../knowledge/connected-understanding-pipeline.js";
 import "../knowledge/index.js";
 import { ingestComposioConnectedSource } from "./connected-source-ingestion.js";
 import { deriveConnectedSourceUnderstanding } from "./connected-source-understanding.js";
@@ -210,44 +207,6 @@ function startConnectorLearningCoordinator(options) {
 			itemsIndexed
 		}));
 		publish(updateConnectorLearningJob(job.id, { phase: "deriving" }));
-		const structuralExtraction = claimRegisteredExtraction({
-			extractorId: "connector-structural",
-			sourceRef: `understanding-source-run:${sourceRun.id}`,
-			contentForHash: `${job.sourceInstanceId}:${itemsSeen}:${itemsIndexed}`,
-			processingPolicy: "local_only",
-			destination: "deterministic"
-		});
-		let understanding = {
-			proposed: 0,
-			created: 0,
-			deduplicated: 0,
-			rejected: 0,
-			createdRecords: [],
-			writeOutputs: []
-		};
-		if (structuralExtraction.shouldExecute) try {
-			understanding = await new ConnectedUnderstandingPipeline(options.getMemoryManager()).process(job.agentId, structuralExtraction.run.id);
-			finishContextExtractionRun({
-				runId: structuralExtraction.run.id,
-				status: "completed",
-				outputs: (understanding.writeOutputs ?? []).map((output) => ({
-					candidateKey: output.candidateKey,
-					...output.objectId ? {
-						objectType: "understanding",
-						objectId: output.objectId
-					} : {},
-					...output.versionId ? { versionId: output.versionId } : {},
-					outcome: output.outcome
-				}))
-			});
-		} catch (error) {
-			finishContextExtractionRun({
-				runId: structuralExtraction.run.id,
-				status: "failed",
-				errorCode: "extractor_failed"
-			});
-			throw error;
-		}
 		let semantic = {
 			created: 0,
 			focusCount: 0,
@@ -276,7 +235,7 @@ function startConnectorLearningCoordinator(options) {
 				connectorId: job.connectorId
 			}, `Connected source semantic analysis failed: ${errorMessage}`);
 		}
-		const candidatesCreated = understanding.created + semantic.created + semantic.focusCount;
+		const candidatesCreated = semantic.created + semantic.focusCount;
 		const incomplete = enrichmentErrors.length > 0 || semantic.status !== "completed";
 		const completed = updateConnectorLearningJob(job.id, {
 			status: "completed",

package/dist/src/gateway/chat-stream/mapper.d.ts

@@ -15,6 +15,7 @@ export declare class ChatStreamMapper {
     private currentAssistantMessageId;
     private lastAssistantMessageId;
     private currentAssistantText;
+    private lastAssistantText;
     private currentAssistantReviewEmitted;
     private toolCallToMessageId;
     private turnDiffs;
@@ -28,6 +29,7 @@ export declare class ChatStreamMapper {
     start(): ChatStreamEvent[];
     end(status: ChatStreamStatus, summary?: string): ChatStreamEvent[];
     error(message: string, code?: string): ChatStreamEvent[];
+    getLastAssistantText(): string;
     private mapMessageStart;
     private mapMessageUpdate;
     private mapAssistantSnapshot;