@xopcai/xopc 0.0.248 → 0.0.250

package/dist/src/voice/realtime/memory-context.js

@@ -1,31 +1,26 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { onUserContextChange } from "../../user-context/changes.js";
-import { getUnderstanding, getUserProfile } from "../../storage/sqlite/user-context-repository.js";
 import { parseAgentSessionKey } from "../../routing/session-key-utils.js";
 import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
 import { getSessionConfig } from "../../storage/sqlite/config-repository.js";
 import { init_session_key, parseSessionKey } from "../../routing/session-key.js";
-import { getUserFocus } from "../../user-context/sources/repository.js";
-import { allowsAutomaticDisclosure, focusRejectionReason, rejectionReason } from "../../user-context/selection-policy.js";
+import { getKnowledgeItem } from "../../knowledge-memory/repository.js";
+import "../../knowledge-memory/index.js";
+import { getUserAssertion } from "../../user-model/repository.js";
+import "../../user-model/index.js";
+import { buildExecutionContext } from "../../agent/context/execution-context.js";
 import { stripRuntimeContextFromUserMessage } from "../../session/user-message-display.js";
-import { remoteContextEligibleIds } from "../../storage/sqlite/remote-context-repository.js";
-import { selectAutomaticContext } from "../../user-context/automatic-context.js";
 //#region src/voice/realtime/memory-context.ts
 init_session_key();
 init_logger();
 const log = createLogger("Voice:Memory");
-const policyVersion = (config) => JSON.stringify({
-	userContext: config.userContext,
-	agents: config.agents
-});
 function voiceMemoryEnabled(config, sessionKey) {
 	const parsed = parseSessionKey(sessionKey);
 	const rest = parseAgentSessionKey(sessionKey)?.rest;
 	const parts = rest?.split(":") ?? [];
 	const explicitlyPrivate = rest === "main" || parts.every(Boolean) && !["cron", "subagent"].includes(parts[0] ?? "") && (parts[0] === "direct" && parts.length >= 2 || parts[1] === "direct" && parts.length >= 3 || parts[2] === "direct" && parts.length >= 4);
 	const user = config.userContext;
-	if (!parsed || !explicitlyPrivate || parsed.peerKind !== "direct" || !user.enabled || !user.understanding.enabled || user.memory.mode === "off" || !user.memory.sources.includes("understanding")) return false;
+	if (!parsed || !explicitlyPrivate || parsed.peerKind !== "direct" || !user.enabled || !user.userModel.enabled || !user.contextPlanning.enabled) return false;
 	const mode = getSessionConfig(sessionKey)?.userContextMode;
 	return mode === void 0 || mode === "enabled";
 }
@@ -37,56 +32,49 @@ function voiceMemoryQuery(history) {
 function buildVoiceMemoryContext(input) {
 	const started = performance.now();
 	try {
-		if (!voiceMemoryEnabled(input.getConfig(), input.sessionKey) || input.maxChars < 128) return;
-		const policy = policyVersion(input.getConfig());
-		const workspace = getSessionConfig(input.sessionKey)?.workingDirectoryOverride;
-		const sessionId = getSessionMetadata(input.sessionKey)?.sessionId;
-		const selection = selectAutomaticContext({
-			...input,
+		const config = input.getConfig();
+		if (!voiceMemoryEnabled(config, input.sessionKey) || input.maxChars < 128) return;
+		const session = getSessionMetadata(input.sessionKey);
+		const context = buildExecutionContext({
 			query: voiceMemoryQuery(input.history),
-			deadline: started + 150
+			agentId: session?.routing?.agentId ?? "main",
+			workspaceId: input.workspaceId,
+			projectId: input.projectId,
+			sessionId: input.sessionKey,
+			maxAssertions: 6,
+			maxKnowledge: 3
 		});
-		if (!selection.block) return;
-		let invalid = false;
+		const block = JSON.stringify({ backgroundMemory: {
+			userFacts: context.assertions.map((item) => item.assertion.statement),
+			priorities: context.priorities.map((item) => `${item.rank}: ${item.targetType}/${item.targetId}`),
+			knowledge: context.knowledge.map((item) => item.content)
+		} });
+		if (block.length > input.maxChars || block === "{\"backgroundMemory\":{\"userFacts\":[],\"priorities\":[],\"knowledge\":[]}}") return;
+		const references = [...context.assertions.map((item) => ({
+			kind: "assertion",
+			id: item.assertion.id,
+			updatedAt: item.assertion.recordedAt
+		})), ...context.knowledge.map((item) => ({
+			kind: "knowledge",
+			id: item.id,
+			updatedAt: item.updatedAt
+		}))];
+		const configVersion = JSON.stringify(config.userContext);
 		const isCurrent = () => {
-			try {
-				if (invalid || !voiceMemoryEnabled(input.getConfig(), input.sessionKey) || policy !== policyVersion(input.getConfig()) || workspace !== getSessionConfig(input.sessionKey)?.workingDirectoryOverride) return false;
-				const session = getSessionMetadata(input.sessionKey);
-				if (session?.sessionId !== sessionId || session?.projectId !== input.projectId) return false;
-				const understandingIds = selection.references.filter((r) => r.kind === "understanding").map((r) => r.id);
-				const focusIds = selection.references.filter((r) => r.kind === "focus").map((r) => r.id);
-				const allowed = new Set([...remoteContextEligibleIds("understanding", understandingIds), ...remoteContextEligibleIds("focus", focusIds)]);
-				return selection.references.every((ref) => {
-					if (ref.kind === "profile") return ref.version === JSON.stringify(getUserProfile());
-					if (!allowed.has(ref.id)) return false;
-					if (ref.kind === "focus") {
-						const item = getUserFocus(ref.id);
-						return !!item && item.versionId === ref.version && allowsAutomaticDisclosure(item) && !focusRejectionReason(item, input, Date.now());
-					}
-					const item = getUnderstanding(ref.id);
-					return !!item && item.status === "active" && item.versionId === ref.version && allowsAutomaticDisclosure(item) && !rejectionReason(item, input, Date.now(), []);
-				});
-			} catch {
-				return false;
-			}
+			if (!voiceMemoryEnabled(input.getConfig(), input.sessionKey) || JSON.stringify(input.getConfig().userContext) !== configVersion) return false;
+			return references.every((reference) => reference.kind === "assertion" ? getUserAssertion(reference.id)?.recordedAt === reference.updatedAt : getKnowledgeItem(reference.id)?.updatedAt === reference.updatedAt);
 		};
 		log.debug({
 			sessionKey: input.sessionKey,
-			selectedCount: selection.references.length,
-			contextChars: selection.block.length,
+			selectedCount: references.length,
+			contextChars: block.length,
 			durationMs: performance.now() - started
 		}, "Native voice memory selected");
 		return {
-			...selection,
+			block,
+			references,
 			isCurrent,
-			subscribe: (invalidate) => onUserContextChange((change) => {
-				if (change.kind === "policy" || change.kind === "session" && change.id === input.sessionKey && !isCurrent() || selection.references.some((ref) => ref.kind === change.kind && ref.id === change.id)) {
-					if (!isCurrent()) {
-						invalid = true;
-						invalidate();
-					}
-				}
-			})
+			subscribe: () => () => {}
 		};
 	} catch {
 		log.warn({

package/dist/src/work-discovery/service.d.ts

@@ -57,7 +57,7 @@ export declare class WorkDiscoveryService {
     importUnderstandingSources(rawItems: unknown[], processingPolicy: ModelProcessingPolicy, signal?: AbortSignal, runId?: string, rawCheckpoints?: Record<string, unknown>): Promise<{
         profileCandidates: any[];
         workThreads: any[];
-        focuses: any[];
+        knowledgeCandidates: any[];
         sourceStatuses: {
             sourceId: string;
             status: "completed";
@@ -65,7 +65,7 @@ export declare class WorkDiscoveryService {
     } | {
         profileCandidates: {
             status: "pending" | "rejected";
-            understandingId: string;
+            assertionId: string;
             id: string;
             category: "role" | "responsibility" | "preference" | "routine";
             factKey: string;
@@ -75,20 +75,9 @@ export declare class WorkDiscoveryService {
             evidenceRefs?: string[];
         }[];
         workThreads: import("./types.js").WorkUnderstandingThread[];
-        focuses: import("../user-context/sources/types.js").UserFocus[];
+        knowledgeCandidates: import("../knowledge-memory/domain.js").KnowledgeItem[];
         sourceStatuses: import("./analyzer.js").UnderstandingSourceAnalysisStatus[];
     }>;
-    updateUnderstandingSourceProfile(input: {
-        decisions: Array<{
-            understandingId: string;
-            status: 'accepted' | 'edited' | 'rejected';
-            statement?: string;
-        }>;
-    }): {
-        understandingId: string;
-        status: "rejected" | "accepted" | "edited";
-        statement: string;
-    }[];
     rescanDirectorySource(input: {
         id: string;
         idempotencyKey: string;

package/dist/src/work-discovery/service.js

@@ -1,17 +1,20 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { createContextEvidence, createUnderstanding, getUnderstanding, linkUnderstandingEvidence, listUnderstandingEvidence, listUnderstandings, rejectUnderstanding, reviseUnderstanding, setUnderstandingStatus } from "../storage/sqlite/user-context-repository.js";
-import "../storage/sqlite/index.js";
+import { createContextEvidence } from "../storage/sqlite/context-evidence-repository.js";
 import { ActivityService } from "../activity/service.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { buildSessionKey, init_session_key } from "../routing/session-key.js";
 import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 import { init_providers, resolveModel } from "../providers/index.js";
+import { writeKnowledgeItem } from "../knowledge-memory/repository.js";
+import "../knowledge-memory/index.js";
+import { createPriorityWindow, createUserGoal } from "../user-model/goals.js";
+import { getAssertionSlot, getUserAssertion, linkAssertionEvidence, reconcileAssertion, setAssertionStatus } from "../user-model/repository.js";
+import "../user-model/index.js";
 import { isLocalModelBaseUrl } from "../providers/model-call.js";
-import { focusLifecycle } from "../user-context/focus-lifecycle.js";
-import { createUnderstandingSourceRun, getUnderstandingSourceRun, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant, upsertUserFocus } from "../user-context/sources/repository.js";
 import { allowsRemoteSourceProcessing } from "../user-context/sources/processing-policy.js";
 import { analyzeUnderstandingSources, analyzeWorkContext, workDiscoveryResultMarkdown } from "./analyzer.js";
+import { createUnderstandingSourceRun, getUnderstandingSourceRun, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant } from "../user-context/sources/repository.js";
 import { previewWorkDiscoveryRoot, probeWorkDiscoveryRoot, summarizeWorkContextSnapshot } from "./probe.js";
 import { clusterActivityTopics } from "../user-context/sources/activity-clustering.js";
 import { isLocalUnderstandingSourceId } from "../user-context/sources/local-source-contract.js";
@@ -158,21 +161,7 @@ function normalizeUnderstandingSourceItems(rawItems) {
 		};
 	});
 }
-function understandingKind(category) {
-	if (category === "preference") return "preference";
-	if (category === "routine") return "routine";
-	return "project_context";
-}
-function understandingKey(candidate) {
-	return `understanding:${understandingKind(candidate.category)}:${candidate.factKey}`;
-}
-function sameScope(left, right) {
-	return left.type === right.type && left.id === right.id;
-}
 function persistUnderstandingCandidate(candidate, scope, sourceRef) {
-	const canonicalKey = understandingKey(candidate);
-	const existing = listUnderstandings().find((item) => item.canonicalKey === canonicalKey && sameScope(item.scope, scope));
-	if (existing) return existing;
 	const evidence = createContextEvidence({
 		sourceType: "runtime",
 		sourceRef: `${sourceRef}:${candidate.id}`,
@@ -180,40 +169,87 @@ function persistUnderstandingCandidate(candidate, scope, sourceRef) {
 		trustLevel: "trusted",
 		observedAt: Date.now()
 	});
-	const understanding = createUnderstanding({
-		kind: understandingKind(candidate.category),
-		canonicalKey,
-		status: "candidate",
+	return reconcileAssertion({
+		subject: {
+			type: "user",
+			id: "self"
+		},
+		predicate: `${candidate.category}.work_discovery.${candidate.factKey}`,
+		cardinality: "single",
 		scope,
-		explicitness: "inferred",
-		durability: candidate.category === "routine" ? "recurring" : "durable",
+		kind: candidate.category === "role" ? "identity" : candidate.category === "responsibility" ? "derived_insight" : candidate.category,
+		value: candidate.statement,
+		normalizedValue: candidate.statement.toLocaleLowerCase(),
+		statement: candidate.statement,
+		authority: "system_inferred",
+		confidence: candidate.confidence === "high" ? .9 : candidate.confidence === "medium" ? .72 : .58,
+		inferredImportance: .55,
+		consequence: "low",
+		actionability: .5,
+		volatility: candidate.category === "routine" ? "slow" : "stable",
 		sensitivity: "normal",
 		disclosurePolicy: "referenceable",
-		confidence: candidate.confidence === "high" ? .9 : candidate.confidence === "medium" ? .72 : .58,
-		statement: candidate.statement,
+		observedAt: Date.now(),
 		createdBy: "runtime",
-		changeReason: "work discovery inference"
-	});
-	linkUnderstandingEvidence(understanding.versionId, evidence.id, "supports", understanding.confidence);
-	return understanding;
+		evidenceId: evidence.id,
+		evidenceConfidence: candidate.confidence === "high" ? .9 : .7
+	}).assertion;
 }
-function decideUnderstanding(input, expectedSourcePrefix) {
-	const current = getUnderstanding(input.understandingId);
-	const owned = current && listUnderstandingEvidence(current.id).some((evidence) => evidence.sourceRef.startsWith(expectedSourcePrefix));
-	if (!current || !owned || current.status === "archived") return void 0;
-	if (input.status === "rejected") return rejectUnderstanding(current.id, "Rejected from work discovery review", "user");
+function decideAssertion(input, _expectedSourcePrefix) {
+	const current = getUserAssertion(input.assertionId);
+	if (!current || current.status === "archived") return void 0;
+	if (input.status === "rejected") return setAssertionStatus(current.id, "rejected", {
+		actor: "user",
+		reason: "Rejected in work discovery review."
+	});
 	const statement = input.status === "edited" ? input.statement?.trim().slice(0, 500) : void 0;
 	if (input.status === "edited" && !statement) return void 0;
-	return setUnderstandingStatus((statement ? reviseUnderstanding(current.id, statement, {
-		explicitness: "explicit",
-		confidence: 1,
-		changeReason: "Edited during work discovery review"
-	}) : current).id, "active", {
-		explicitness: "explicit",
-		confidence: 1,
-		actorType: "user",
-		source: "work-discovery-review"
+	if (!statement) return setAssertionStatus(current.id, "active", {
+		actor: "user",
+		reason: "Accepted in work discovery review."
 	});
+	const slot = getAssertionSlot(current.slotId);
+	if (!slot) return void 0;
+	return reconcileAssertion({
+		subject: slot.subject,
+		predicate: slot.predicate,
+		cardinality: slot.cardinality,
+		scope: slot.scope,
+		kind: current.kind,
+		value: statement,
+		normalizedValue: statement.toLocaleLowerCase(),
+		statement,
+		authority: "user_explicit",
+		confidence: 1,
+		declaredImportance: current.declaredImportance ?? .7,
+		inferredImportance: current.inferredImportance,
+		consequence: current.consequence,
+		actionability: current.actionability,
+		volatility: current.volatility,
+		sensitivity: current.sensitivity,
+		disclosurePolicy: current.disclosurePolicy,
+		applicability: current.applicability,
+		observedAt: Date.now(),
+		createdBy: "user",
+		correctionOfAssertionId: current.id
+	}).assertion;
+}
+function persistWorkKnowledge(input) {
+	const now = Date.now();
+	return writeKnowledgeItem({
+		kind: input.scope.type === "project" ? "project_fact" : "workspace_fact",
+		scope: input.scope,
+		content: `${input.title}: ${input.summary}`,
+		canonicalKey: input.canonicalKey,
+		confidence: input.confidence,
+		importance: input.horizon === "current" ? .75 : input.horizon === "ongoing" ? .55 : .4,
+		reviewAt: now + (input.horizon === "current" ? 7 : 30) * 864e5,
+		originClass: "system",
+		source: {
+			evidenceRefs: input.evidenceRefs,
+			horizon: input.horizon
+		}
+	}).item;
 }
 function sessionMetadata(agentId, peerId) {
 	return {
@@ -384,6 +420,7 @@ var WorkDiscoveryService = class {
 		const items = normalizeUnderstandingSourceItems(rawItems);
 		if (!items.length) throw new Error("No readable understanding source items were provided");
 		const target = this.getModelProcessingTarget();
+		const agentId = getDefaultAgentId(this.options.getConfig());
 		const effectiveProcessingPolicy = target.remoteModel ? processingPolicy : "local_only";
 		const checkpoints = /* @__PURE__ */ new Map();
 		for (const [sourceId, value] of Object.entries(rawCheckpoints ?? {})) {
@@ -456,7 +493,7 @@ var WorkDiscoveryService = class {
 			return {
 				profileCandidates: [],
 				workThreads: [],
-				focuses: [],
+				knowledgeCandidates: [],
 				sourceStatuses: [...new Set(items.map((item) => item.sourceId))].map((sourceId) => ({
 					sourceId,
 					status: "completed"
@@ -531,7 +568,7 @@ var WorkDiscoveryService = class {
 		const safeProfileCandidates = analysis.profileCandidates.filter((candidate) => !hasLongVerbatimOverlap(candidate.statement, rawContents));
 		const safeWorkThreadCandidates = analysis.workThreadCandidates.filter((candidate) => !hasLongVerbatimOverlap(candidate.title, rawContents) && !hasLongVerbatimOverlap(candidate.summary, rawContents));
 		const profileCandidates = safeProfileCandidates.map((candidate) => {
-			const understanding = persistUnderstandingCandidate(candidate, { type: "global" }, "understanding-source:onboarding");
+			const assertion = persistUnderstandingCandidate(candidate, { type: "global" }, "understanding-source:onboarding");
 			const evidenceSourceIds = new Set((candidate.evidenceRefs ?? []).map((ref) => ref.split("://", 1)[0]).filter(Boolean));
 			for (const sourceId of evidenceSourceIds) {
 				const sourceRunId = sourceRuns.get(sourceId);
@@ -545,12 +582,12 @@ var WorkDiscoveryService = class {
 					trustLevel: "trusted",
 					observedAt: Date.now()
 				});
-				linkUnderstandingEvidence(understanding.versionId, evidence.id, "supports", understanding.confidence);
+				linkAssertionEvidence(assertion.id, evidence.id, "supports", assertion.confidence);
 			}
 			return {
 				...candidate,
-				status: understanding.status === "rejected" ? "rejected" : "pending",
-				understandingId: understanding.id
+				status: assertion.status === "rejected" ? "rejected" : "pending",
+				assertionId: assertion.id
 			};
 		});
 		const investigation = linkedRun ? getWorkUnderstandingInvestigationForRun(linkedRun.id) : null;
@@ -600,53 +637,45 @@ var WorkDiscoveryService = class {
 			evidence: contextEvidence
 		}) : [];
 		const activityEvidence = new Set(activityTopics.flatMap((topic) => topic.evidenceRefs));
-		const activityFocuses = activityTopics.map((topic) => upsertUserFocus({
+		const activityKnowledge = activityTopics.map((topic) => persistWorkKnowledge({
 			canonicalKey: topic.canonicalKey,
 			title: topic.title,
 			summary: topic.summary,
 			horizon: topic.horizon,
-			status: "candidate",
 			confidence: topic.confidence,
-			evidenceRefs: topic.evidenceRefs,
-			sourceRunId: sourceRuns.get(topic.sourceIds[0] ?? ""),
-			...focusLifecycle(topic.horizon)
+			scope: {
+				type: "agent",
+				id: agentId
+			},
+			evidenceRefs: topic.evidenceRefs
 		}));
-		const modelFocuses = safeWorkThreadCandidates.filter((candidate) => !candidate.evidenceRefs.some((ref) => activityEvidence.has(ref))).map((candidate) => upsertUserFocus({
-			canonicalKey: `source-focus:${candidate.topicKey}`,
+		const modelKnowledge = safeWorkThreadCandidates.filter((candidate) => !candidate.evidenceRefs.some((ref) => activityEvidence.has(ref))).map((candidate) => persistWorkKnowledge({
+			canonicalKey: `source-knowledge:${candidate.topicKey}`,
 			title: candidate.title,
 			summary: candidate.summary,
 			horizon: candidate.horizon,
-			status: "candidate",
 			confidence: candidate.confidence === "high" ? .9 : candidate.confidence === "medium" ? .72 : .55,
-			evidenceRefs: candidate.evidenceRefs,
-			sourceRunId: sourceRuns.get(candidate.evidenceRefs[0]?.split("://", 1)[0] ?? ""),
-			...focusLifecycle(candidate.horizon)
+			scope: {
+				type: "agent",
+				id: agentId
+			},
+			evidenceRefs: candidate.evidenceRefs
 		}));
-		const focuses = [...activityFocuses, ...modelFocuses];
+		const knowledgeCandidates = [...activityKnowledge, ...modelKnowledge];
 		log.info({
 			runId,
 			itemCount: items.length,
 			candidateCount: profileCandidates.length,
-			focusCount: focuses.length,
+			knowledgeCount: knowledgeCandidates.length,
 			incompleteSourceCount: analysis.sourceStatuses.filter((item) => item.status !== "completed").length
 		}, "Understanding sources analyzed");
 		return {
 			profileCandidates,
 			workThreads,
-			focuses,
+			knowledgeCandidates,
 			sourceStatuses: analysis.sourceStatuses
 		};
 	}
-	updateUnderstandingSourceProfile(input) {
-		return input.decisions.flatMap((decision) => {
-			const updated = decideUnderstanding(decision, "understanding-source:");
-			return updated ? [{
-				understandingId: updated.id,
-				status: decision.status,
-				statement: updated.statement
-			}] : [];
-		});
-	}
 	async rescanDirectorySource(input) {
 		const source = getWorkDiscoveryDirectorySource(input.id);
 		if (!source || source.status !== "active") throw new Error("Approved work folder not found");
@@ -867,24 +896,22 @@ var WorkDiscoveryService = class {
 				snapshot: investigatedSnapshot,
 				evidence: unifiedEvidence
 			});
-			const focusCandidates = workThreads.map((thread) => upsertUserFocus({
-				canonicalKey: `work-focus:${thread.canonicalKey}`,
+			const knowledgeCandidates = workThreads.map((thread) => persistWorkKnowledge({
+				canonicalKey: `work-knowledge:${thread.canonicalKey}`,
 				title: thread.title,
 				summary: thread.summary,
 				horizon: thread.horizon,
-				status: "candidate",
 				confidence: thread.confidence,
 				scope: {
 					type: "project",
 					id: run.projectId
 				},
-				evidenceRefs: thread.evidenceIds,
-				...focusLifecycle(thread.horizon)
+				evidenceRefs: thread.evidenceIds
 			}));
 			const result = this.persistProfileCandidates(run, {
 				...baseResult,
 				...workThreads.length ? { workThreads } : {},
-				...focusCandidates.length ? { focusCandidates } : {}
+				...knowledgeCandidates.length ? { knowledgeCandidates } : {}
 			});
 			current = updateWorkDiscoveryRun(run.id, {
 				status: "analyzing",
@@ -1024,13 +1051,13 @@ var WorkDiscoveryService = class {
 	persistProfileCandidates(run, result) {
 		if (!result.profileCandidates?.length) return result;
 		const profileCandidates = result.profileCandidates.map((candidate) => {
-			const understanding = persistUnderstandingCandidate(candidate, {
+			const assertion = persistUnderstandingCandidate(candidate, {
 				type: "project",
 				id: run.projectId
 			}, `work-discovery:${run.id}`);
 			return {
 				...candidate,
-				understandingId: understanding.id
+				assertionId: assertion.id
 			};
 		});
 		return {
@@ -1044,14 +1071,15 @@ var WorkDiscoveryService = class {
 		const decisions = new Map(input.decisions.map((decision) => [decision.id, decision]));
 		const profileCandidates = run.result.profileCandidates.map((candidate) => {
 			const decision = decisions.get(candidate.id);
-			if (!decision || !candidate.understandingId) return candidate;
-			const updated = decideUnderstanding({
-				understandingId: candidate.understandingId,
+			if (!decision || !candidate.assertionId) return candidate;
+			const updated = decideAssertion({
+				assertionId: candidate.assertionId,
 				...decision
 			}, `work-discovery:${run.id}:`);
 			if (!updated) return candidate;
 			return {
 				...candidate,
+				assertionId: updated.id,
 				statement: updated.statement,
 				status: decision.status
 			};
@@ -1106,21 +1134,32 @@ var WorkDiscoveryService = class {
 			recognitionDecision: input.decision,
 			...correctedIntent ? { correctedIntent } : {}
 		});
-		if ((input.decision === "corrected" || input.decision === "different_goal") && correctedIntent) upsertUserFocus({
-			canonicalKey: `user-focus:${createHash("sha256").update(correctedIntent.toLocaleLowerCase()).digest("hex").slice(0, 20)}`,
-			title: correctedIntent.slice(0, 120),
-			summary: correctedIntent,
-			horizon: "current",
-			status: "active",
-			confidence: 1,
-			scope: {
-				type: "project",
-				id: run.projectId
-			},
-			explicitness: "explicit",
-			evidenceRefs: [`session://${createHash("sha256").update(run.sessionKey).digest("hex").slice(0, 16)}/recognition`],
-			...focusLifecycle("current")
-		});
+		if ((input.decision === "corrected" || input.decision === "different_goal") && correctedIntent) {
+			const goal = createUserGoal({
+				title: correctedIntent.slice(0, 120),
+				desiredOutcome: correctedIntent,
+				scope: {
+					type: "project",
+					id: run.projectId
+				},
+				declaredImportance: .9
+			});
+			const now = Date.now();
+			createPriorityWindow({
+				targetType: "goal",
+				targetId: goal.id,
+				rank: "primary",
+				urgency: .9,
+				scope: {
+					type: "project",
+					id: run.projectId
+				},
+				validFrom: now,
+				validTo: now + 30 * 864e5,
+				reviewAt: now + 7 * 864e5,
+				declaredImportance: .9
+			});
+		}
 		const investigation = getWorkUnderstandingInvestigationForRun(run.id);
 		if (investigation && input.decision !== "dismissed") {
 			const observation = correctedIntent ? `The user explicitly stated their current intent: ${correctedIntent}` : "The user explicitly confirmed the inferred current work understanding.";

package/dist/src/work-discovery/types.d.ts

@@ -1,4 +1,4 @@
-import type { UserFocus } from '../user-context/sources/types.js';
+import type { KnowledgeItem } from '../knowledge-memory/index.js';
 export type WorkDiscoveryOnboardingStatus = 'not_started' | 'in_progress' | 'completed' | 'dismissed';
 export interface WorkDiscoveryOnboardingState {
     status: WorkDiscoveryOnboardingStatus;
@@ -161,11 +161,11 @@ export interface WorkDiscoveryResult {
     };
     workThreadCandidates?: WorkUnderstandingThreadCandidate[];
     workThreads?: WorkUnderstandingThread[];
-    focusCandidates?: UserFocus[];
+    knowledgeCandidates?: KnowledgeItem[];
 }
 export interface WorkDiscoveryProfileCandidate {
     id: string;
-    understandingId?: string;
+    assertionId?: string;
     category: 'role' | 'responsibility' | 'preference' | 'routine';
     factKey: string;
     statement: string;

package/dist/src/workflows/service/workflow-run-service.js

@@ -1,9 +1,9 @@
+import { TaskRunRepository } from "../../tasks/task-run-repository.js";
 import { getDefaultAgentId, init_resolve_route } from "../../routing/resolve-route.js";
 import { extractProfileAgentId, resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
 import { init_providers, resolveModel } from "../../providers/index.js";
 import { TaskRepository } from "../../tasks/task-repository.js";
 import { TaskConversationRepository } from "../../tasks/task-conversation-repository.js";
-import { TaskRunRepository } from "../../tasks/task-run-repository.js";
 import { getProjectWorkspacePathForSession } from "../../projects/workspace.js";
 import { publishAutomationProductEvent } from "../../automations/product-events.js";
 import { TaskContextRepository } from "../../tasks/task-context-repository.js";

package/dist/src/workflows/service/workflow-session-bridge.js

@@ -1,7 +1,6 @@
 import "../../session/types.js";
-import { upsertMemoryRecord } from "../../storage/sqlite/memory-records-repository.js";
-import "../../storage/sqlite/index.js";
-import { getProjectWorkspacePathForSession } from "../../projects/workspace.js";
+import { writeKnowledgeItem } from "../../knowledge-memory/repository.js";
+import "../../knowledge-memory/index.js";
 import { TaskWorkflowCoordinator } from "../../tasks/task-workflow-coordinator.js";
 import { renderWorkflowText } from "../../agent/workflow/snapshot.js";
 import { isTerminalWorkflowRunStatus } from "../domain/run.js";
@@ -154,33 +153,26 @@ var WorkflowSessionBridge = class {
 		const agentId = view.run.metadata?.agentId?.trim();
 		if (!projectId || !agentId) return;
 		const resultText = view.run.result?.summary.trim() || renderWorkflowText(runViewToSnapshot(view), view.run.status === "succeeded", { showResultPreviews: true });
-		upsertMemoryRecord({
-			id: `workflow-run:${view.run.id}`,
-			providerId: "workflow-run",
+		writeKnowledgeItem({
 			kind: "task_lesson",
+			scope: {
+				type: "project",
+				id: projectId
+			},
 			sourceAgentId: agentId,
-			workspaceId: getProjectWorkspacePathForSession(sessionKey) ?? this.gateway.currentWorkspacePath,
-			sessionKey,
-			projectId,
+			sourceSessionId: sessionKey,
 			content: [
 				`Workflow ${view.run.definitionId} finished with status ${view.run.status}.`,
 				view.run.goal ? `Goal: ${view.run.goal}` : void 0,
 				compactMemoryLine(resultText)
 			].filter((line) => Boolean(line)).join("\n"),
+			canonicalKey: `workflow-run:${view.run.id}`,
 			source: { provider: "workflow-run" },
 			confidence: view.run.status === "succeeded" ? .7 : .82,
-			tags: [
-				"project",
-				"workflow",
-				view.run.definitionId,
-				view.run.status
-			],
+			importance: .65,
 			status: view.run.status === "succeeded" ? "active" : "needs_review",
-			sensitivity: "normal",
-			evidence: [{
-				sessionKey,
-				sourceText: `workflow:${view.run.id}`
-			}]
+			originClass: "agent",
+			replaceExisting: true
 		});
 	}
 };