@xopcai/xopc 0.0.248 → 0.0.249

package/dist/src/user-model/repository.js

@@ -0,0 +1,268 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { USER_MODEL_PRINCIPAL_ID, validateCandidate, validateScope } from "./domain.js";
+import { defaultReviewAt, requiresBoundedValidity } from "./temporal.js";
+import { randomUUID } from "node:crypto";
+//#region src/user-model/repository.ts
+function slotFromRow(row) {
+	return {
+		id: row.slot_id,
+		principalId: row.principal_id,
+		subject: {
+			type: row.subject_type,
+			id: row.subject_id
+		},
+		predicate: row.predicate,
+		cardinality: row.cardinality,
+		scope: {
+			type: row.scope_type,
+			...row.scope_id ? { id: row.scope_id } : {}
+		},
+		createdAt: row.created_at
+	};
+}
+function assertionFromRow(row) {
+	return {
+		id: row.assertion_id,
+		slotId: row.slot_id,
+		kind: row.kind,
+		value: JSON.parse(row.value_json),
+		normalizedValue: row.normalized_value,
+		statement: row.statement,
+		authority: row.authority,
+		status: row.status,
+		confidence: row.confidence,
+		...row.declared_importance === null ? {} : { declaredImportance: row.declared_importance },
+		inferredImportance: row.inferred_importance,
+		consequence: row.consequence,
+		actionability: row.actionability,
+		volatility: row.volatility,
+		sensitivity: row.sensitivity,
+		disclosurePolicy: row.disclosure_policy,
+		applicability: JSON.parse(row.applicability_json),
+		...row.valid_from === null ? {} : { validFrom: row.valid_from },
+		...row.valid_to === null ? {} : { validTo: row.valid_to },
+		observedAt: row.observed_at,
+		recordedAt: row.recorded_at,
+		...row.review_at === null ? {} : { reviewAt: row.review_at },
+		...row.supersedes_assertion_id === null ? {} : { supersedesAssertionId: row.supersedes_assertion_id },
+		createdBy: row.created_by,
+		createdAt: row.created_at
+	};
+}
+function findOrCreateSlot(db, candidate, now) {
+	const principalId = candidate.principalId ?? "local-owner";
+	const scopeId = candidate.scope.id?.trim() ?? null;
+	const existing = db.prepare(`SELECT * FROM user_assertion_slots
+    WHERE principal_id = ? AND subject_type = ? AND subject_id = ? AND predicate = ?
+      AND scope_type = ? AND COALESCE(scope_id, '') = COALESCE(?, '')`).get(principalId, candidate.subject.type, candidate.subject.id.trim(), candidate.predicate.trim(), candidate.scope.type, scopeId);
+	if (existing) {
+		if (existing.cardinality !== candidate.cardinality) throw new Error(`Assertion slot cardinality mismatch for ${candidate.predicate}.`);
+		return slotFromRow(existing);
+	}
+	const id = randomUUID();
+	db.prepare(`INSERT INTO user_assertion_slots (
+    slot_id, principal_id, subject_type, subject_id, predicate, cardinality,
+    scope_type, scope_id, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, principalId, candidate.subject.type, candidate.subject.id.trim(), candidate.predicate.trim(), candidate.cardinality, candidate.scope.type, scopeId, now);
+	return slotFromRow(db.prepare("SELECT * FROM user_assertion_slots WHERE slot_id = ?").get(id));
+}
+function intervalsOverlap(left, candidate) {
+	const leftStart = left.validFrom ?? Number.NEGATIVE_INFINITY;
+	const leftEnd = left.validTo ?? Number.POSITIVE_INFINITY;
+	const rightStart = candidate.validFrom ?? Number.NEGATIVE_INFINITY;
+	return leftStart <= (candidate.validTo ?? Number.POSITIVE_INFINITY) && rightStart <= leftEnd;
+}
+function listReconcilableAssertions(db, slotId) {
+	return db.prepare(`SELECT * FROM user_assertions WHERE slot_id = ?
+    AND status NOT IN ('rejected', 'archived') ORDER BY recorded_at DESC`).all(slotId).map(assertionFromRow);
+}
+function sortByAuthorityAndRecorded(assertions) {
+	return assertions.sort((left, right) => authorityRank(right.authority) - authorityRank(left.authority) || right.recordedAt - left.recordedAt);
+}
+function initialStatus(candidate) {
+	if (requiresBoundedValidity(candidate.kind, candidate.volatility) && candidate.validTo === void 0) return "needs_review";
+	return candidate.authority === "user_explicit" ? "active" : "candidate";
+}
+function insertAssertion(db, slotId, candidate, status, now, supersedesAssertionId) {
+	const id = randomUUID();
+	const reviewAt = candidate.reviewAt ?? defaultReviewAt(candidate.volatility, candidate.observedAt) ?? null;
+	db.prepare(`INSERT INTO user_assertions (
+    assertion_id, slot_id, kind, value_json, normalized_value, statement, authority, status,
+    confidence, declared_importance, inferred_importance, consequence, actionability,
+    volatility, sensitivity, disclosure_policy, applicability_json, valid_from, valid_to,
+    observed_at, recorded_at, review_at, supersedes_assertion_id, created_by, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, slotId, candidate.kind, JSON.stringify(candidate.value), candidate.normalizedValue.trim(), candidate.statement.trim(), candidate.authority, status, candidate.confidence, candidate.declaredImportance ?? null, candidate.inferredImportance, candidate.consequence, candidate.actionability, candidate.volatility, candidate.sensitivity, candidate.disclosurePolicy, JSON.stringify(candidate.applicability ?? {}), candidate.validFrom ?? null, candidate.validTo ?? null, candidate.observedAt, now, reviewAt, supersedesAssertionId ?? null, candidate.createdBy, now);
+	db.prepare(`INSERT INTO user_assertions_fts(statement, assertion_id, slot_id) VALUES (?, ?, ?)`).run(candidate.statement.trim(), id, slotId);
+	recordStatusEvent(db, id, null, status, candidate.createdBy === "connector" ? "runtime" : candidate.createdBy, "Assertion admitted.", now);
+	if (candidate.evidenceId) db.prepare(`INSERT INTO user_assertion_evidence (
+      assertion_id, evidence_id, relation, confidence, created_at
+    ) VALUES (?, ?, 'supports', ?, ?)
+    ON CONFLICT(assertion_id, evidence_id, relation) DO UPDATE SET confidence = excluded.confidence`).run(id, candidate.evidenceId, candidate.evidenceConfidence ?? candidate.confidence, now);
+	return assertionFromRow(db.prepare("SELECT * FROM user_assertions WHERE assertion_id = ?").get(id));
+}
+function recordStatusEvent(db, assertionId, fromStatus, toStatus, actor, reason, now) {
+	db.prepare(`INSERT INTO user_assertion_status_events (
+    event_id, assertion_id, from_status, to_status, actor_type, reason, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), assertionId, fromStatus, toStatus, actor, reason, now);
+}
+function attachEvidence(db, assertionId, candidate, now) {
+	if (!candidate.evidenceId) return;
+	db.prepare(`INSERT INTO user_assertion_evidence (
+    assertion_id, evidence_id, relation, confidence, created_at
+  ) VALUES (?, ?, 'supports', ?, ?)
+  ON CONFLICT(assertion_id, evidence_id, relation) DO UPDATE SET confidence = excluded.confidence`).run(assertionId, candidate.evidenceId, candidate.evidenceConfidence ?? candidate.confidence, now);
+}
+function closeValidity(db, assertion, boundary, now) {
+	if (assertion.validFrom !== void 0 && boundary <= assertion.validFrom) {
+		updateStatus(db, assertion, "archived", "Superseded before its validity began.", now);
+		return;
+	}
+	const end = boundary - 1;
+	db.prepare(`UPDATE user_assertions SET valid_to = ?
+    WHERE assertion_id = ? AND (valid_to IS NULL OR valid_to >= ?)`).run(end, assertion.id, boundary);
+}
+function updateStatus(db, assertion, status, reason, now) {
+	if (assertion.status === status) return;
+	db.prepare("UPDATE user_assertions SET status = ? WHERE assertion_id = ?").run(status, assertion.id);
+	recordStatusEvent(db, assertion.id, assertion.status, status, "runtime", reason, now);
+}
+function authorityRank(authority) {
+	return {
+		external_untrusted: 0,
+		system_inferred: 1,
+		user_observed: 2,
+		user_explicit: 3
+	}[authority];
+}
+function reconcileAssertion(candidate, now = Date.now()) {
+	validateCandidate(candidate);
+	return runSqliteWriteTransaction((db) => {
+		const slot = findOrCreateSlot(db, candidate, now);
+		const existing = listReconcilableAssertions(db, slot.id);
+		if (candidate.correctionOfAssertionId) {
+			if (candidate.authority !== "user_explicit") throw new Error("Only an explicit user assertion can correct an existing assertion.");
+			const target = existing.find((item) => item.id === candidate.correctionOfAssertionId);
+			if (!target) throw new Error("Correction target does not belong to the resolved assertion slot.");
+			if (target.normalizedValue === candidate.normalizedValue.trim()) {
+				attachEvidence(db, target.id, candidate, now);
+				return {
+					action: "deduplicated",
+					assertion: target
+				};
+			}
+			const assertion = insertAssertion(db, slot.id, candidate, "active", now, target.id);
+			closeValidity(db, target, candidate.validFrom ?? candidate.observedAt, now);
+			return {
+				action: "superseded",
+				assertion,
+				previousAssertion: getUserAssertion(target.id)
+			};
+		}
+		const overlapping = sortByAuthorityAndRecorded(existing.filter((item) => intervalsOverlap(item, candidate)));
+		const duplicate = overlapping.find((item) => item.normalizedValue === candidate.normalizedValue.trim());
+		if (duplicate) {
+			attachEvidence(db, duplicate.id, candidate, now);
+			return {
+				action: "deduplicated",
+				assertion: duplicate
+			};
+		}
+		const status = initialStatus(candidate);
+		if (slot.cardinality === "multiple" || !overlapping.length) return {
+			action: "created",
+			assertion: insertAssertion(db, slot.id, candidate, status, now)
+		};
+		const current = overlapping[0];
+		if (candidate.authority === "user_explicit" && authorityRank(candidate.authority) > authorityRank(current.authority)) {
+			const assertion = insertAssertion(db, slot.id, candidate, status, now, current.id);
+			closeValidity(db, current, candidate.validFrom ?? candidate.observedAt, now);
+			return {
+				action: "superseded",
+				assertion,
+				previousAssertion: getUserAssertion(current.id)
+			};
+		}
+		const assertion = insertAssertion(db, slot.id, candidate, candidate.authority === "user_explicit" ? "needs_review" : "conflicted", now);
+		if (current.authority !== "user_explicit" && candidate.authority !== "user_explicit") updateStatus(db, current, "conflicted", "Overlapping assertion has a different value.", now);
+		return {
+			action: "conflicted",
+			assertion,
+			previousAssertion: getUserAssertion(current.id)
+		};
+	});
+}
+function getUserAssertion(id) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM user_assertions WHERE assertion_id = ?").get(id);
+	return row ? assertionFromRow(row) : void 0;
+}
+function getAssertionSlot(id) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM user_assertion_slots WHERE slot_id = ?").get(id);
+	return row ? slotFromRow(row) : void 0;
+}
+function listSlotAssertions(slotId) {
+	return getSqliteDatabase().prepare(`SELECT * FROM user_assertions
+    WHERE slot_id = ? ORDER BY recorded_at DESC`).all(slotId).map(assertionFromRow);
+}
+function listUserAssertions(input = {}) {
+	const principalId = input.principalId ?? "local-owner";
+	const statuses = input.statuses ?? [
+		"active",
+		"candidate",
+		"needs_review",
+		"conflicted"
+	];
+	if (!statuses.length) return [];
+	const placeholders = statuses.map(() => "?").join(", ");
+	const limit = Math.max(1, Math.min(2e3, input.limit ?? 200));
+	return getSqliteDatabase().prepare(`SELECT a.* FROM user_assertions a
+    JOIN user_assertion_slots s ON s.slot_id = a.slot_id
+    WHERE s.principal_id = ? AND a.status IN (${placeholders})
+    ORDER BY a.recorded_at DESC LIMIT ?`).all(principalId, ...statuses, limit).map(assertionFromRow);
+}
+function getActiveAssertionByPredicate(predicate) {
+	const row = getSqliteDatabase().prepare(`SELECT a.* FROM user_assertions a
+    JOIN user_assertion_slots s ON s.slot_id = a.slot_id
+    WHERE s.principal_id = ? AND s.predicate = ? AND a.status = 'active'
+      AND (a.valid_from IS NULL OR a.valid_from <= ?)
+      AND (a.valid_to IS NULL OR a.valid_to >= ?)
+    ORDER BY CASE a.authority WHEN 'user_explicit' THEN 0 WHEN 'user_observed' THEN 1
+      WHEN 'system_inferred' THEN 2 ELSE 3 END, a.recorded_at DESC LIMIT 1`).get(USER_MODEL_PRINCIPAL_ID, predicate, Date.now(), Date.now());
+	return row ? assertionFromRow(row) : void 0;
+}
+function getActiveAssertionForSlot(input) {
+	validateScope(input.scope);
+	const row = getSqliteDatabase().prepare(`SELECT a.* FROM user_assertions a
+    JOIN user_assertion_slots s ON s.slot_id = a.slot_id
+    WHERE s.principal_id = ? AND s.subject_type = ? AND s.subject_id = ?
+      AND s.predicate = ? AND s.scope_type = ?
+      AND COALESCE(s.scope_id, '') = COALESCE(?, '') AND a.status = 'active'
+      AND (a.valid_from IS NULL OR a.valid_from <= ?)
+      AND (a.valid_to IS NULL OR a.valid_to >= ?)
+    ORDER BY CASE a.authority WHEN 'user_explicit' THEN 0 WHEN 'user_observed' THEN 1
+      WHEN 'system_inferred' THEN 2 ELSE 3 END, a.recorded_at DESC LIMIT 1`).get(USER_MODEL_PRINCIPAL_ID, input.subject.type, input.subject.id.trim(), input.predicate.trim(), input.scope.type, input.scope.id?.trim() ?? null, Date.now(), Date.now());
+	return row ? assertionFromRow(row) : void 0;
+}
+function getUserTimezone() {
+	const value = getActiveAssertionByPredicate("preference.timezone")?.value;
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function linkAssertionEvidence(assertionId, evidenceId, relation, confidence, now = Date.now()) {
+	if (!Number.isFinite(confidence) || confidence < 0 || confidence > 1) throw new Error("Evidence confidence must be between 0 and 1.");
+	getSqliteDatabase().prepare(`INSERT INTO user_assertion_evidence (
+    assertion_id, evidence_id, relation, confidence, created_at
+  ) VALUES (?, ?, ?, ?, ?)
+  ON CONFLICT(assertion_id, evidence_id, relation) DO UPDATE SET confidence = excluded.confidence`).run(assertionId, evidenceId, relation, confidence, now);
+}
+function setAssertionStatus(assertionId, status, input) {
+	const current = getUserAssertion(assertionId);
+	if (!current) throw new Error(`User assertion not found: ${assertionId}`);
+	if (current.status === status) return current;
+	const now = input.now ?? Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare("UPDATE user_assertions SET status = ? WHERE assertion_id = ?").run(status, assertionId);
+		recordStatusEvent(db, assertionId, current.status, status, input.actor, input.reason, now);
+	});
+	return getUserAssertion(assertionId);
+}
+//#endregion
+export { getActiveAssertionByPredicate, getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, getUserTimezone, linkAssertionEvidence, listSlotAssertions, listUserAssertions, reconcileAssertion, setAssertionStatus };

package/dist/src/user-model/temporal.d.ts

@@ -0,0 +1,10 @@
+import type { AssertionKind, AssertionVolatility, UserAssertion } from './domain.js';
+export declare function defaultReviewAt(volatility: AssertionVolatility, observedAt: number): number | undefined;
+export declare function requiresBoundedValidity(kind: AssertionKind, volatility: AssertionVolatility): boolean;
+export declare function isAssertionValidAt(assertion: UserAssertion, asOf: number): boolean;
+export interface CurrentAssertionResolution {
+    assertion?: UserAssertion;
+    conflict: boolean;
+    contenders: UserAssertion[];
+}
+export declare function resolveCurrentAssertion(assertions: UserAssertion[], asOf?: number): CurrentAssertionResolution;

package/dist/src/user-model/temporal.js

@@ -0,0 +1,44 @@
+//#region src/user-model/temporal.ts
+const REVIEW_INTERVAL_MS = {
+	stable: void 0,
+	slow: 4320 * 60 * 60 * 1e3,
+	dynamic: 720 * 60 * 60 * 1e3,
+	event: 10080 * 60 * 1e3
+};
+function defaultReviewAt(volatility, observedAt) {
+	const interval = REVIEW_INTERVAL_MS[volatility];
+	return interval === void 0 ? void 0 : observedAt + interval;
+}
+function requiresBoundedValidity(kind, volatility) {
+	return kind === "current_state" || volatility === "event";
+}
+function isAssertionValidAt(assertion, asOf) {
+	return assertion.status === "active" && (assertion.validFrom === void 0 || assertion.validFrom <= asOf) && (assertion.validTo === void 0 || assertion.validTo >= asOf);
+}
+const AUTHORITY_RANK = {
+	external_untrusted: 0,
+	system_inferred: 1,
+	user_observed: 2,
+	user_explicit: 3
+};
+function resolveCurrentAssertion(assertions, asOf = Date.now()) {
+	const contenders = assertions.filter((item) => isAssertionValidAt(item, asOf));
+	if (!contenders.length) return {
+		conflict: false,
+		contenders: []
+	};
+	contenders.sort((left, right) => AUTHORITY_RANK[right.authority] - AUTHORITY_RANK[left.authority] || right.recordedAt - left.recordedAt);
+	const best = contenders[0];
+	if (contenders.filter((item) => AUTHORITY_RANK[item.authority] === AUTHORITY_RANK[best.authority] && item.normalizedValue !== best.normalizedValue).length) return {
+		assertion: void 0,
+		conflict: true,
+		contenders
+	};
+	return {
+		assertion: best,
+		conflict: false,
+		contenders
+	};
+}
+//#endregion
+export { defaultReviewAt, isAssertionValidAt, requiresBoundedValidity, resolveCurrentAssertion };

package/dist/src/voice/realtime/memory-context.d.ts

@@ -1,7 +1,12 @@
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { Config } from '../../config/schema.js';
-import { type AutomaticContextSelection } from '../../user-context/automatic-context.js';
-export interface VoiceMemorySnapshot extends AutomaticContextSelection {
+export interface VoiceMemorySnapshot {
+    block: string;
+    references: Array<{
+        kind: 'assertion' | 'knowledge';
+        id: string;
+        updatedAt: number;
+    }>;
     isCurrent: () => boolean;
     subscribe: (invalidate: () => void) => () => void;
 }

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;