@xopcai/xopc 0.0.248 → 0.0.250

package/dist/src/user-context/config.js

@@ -10,15 +10,9 @@ function isValidTimeZone(value) {
 		return false;
 	}
 }
-var UserMemoryModeSchema, DEFAULT_CONTEXT_COMPACTION_POLICY, ContextCompactionPolicySchema, UserMemoryConfigSchema, UserUnderstandingConfigSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, DreamingTimeSchema, UserContextDreamingSchema, UserContextConfigSchema;
+var DEFAULT_CONTEXT_COMPACTION_POLICY, ContextCompactionPolicySchema, WritePolicySchema, MaintenanceTimeSchema, UserModelConfigSchema, KnowledgeMemoryConfigSchema, ContextPlanningConfigSchema, UserContextConfigSchema;
 var init_config = __esmMin((() => {
 	init_response_language();
-	UserMemoryModeSchema = z.enum([
-		"off",
-		"readOnly",
-		"confirmWrite",
-		"auto"
-	]);
 	DEFAULT_CONTEXT_COMPACTION_POLICY = {
 		enabled: true,
 		triggerThreshold: .8,
@@ -54,62 +48,84 @@ var init_config = __esmMin((() => {
 		maxActiveTranscriptBytes: z.number().int().min(64e3).default(2e6),
 		postCompactionSections: z.array(z.string().min(1)).max(12).default(["Session Startup", "Red Lines"])
 	}).strict().default(DEFAULT_CONTEXT_COMPACTION_POLICY);
-	UserMemoryConfigSchema = z.object({
-		mode: UserMemoryModeSchema.default("off"),
-		sources: z.array(z.enum([
-			"session",
-			"agentProfile",
-			"understanding",
-			"workspace"
-		])).default(["session"]),
-		writePolicy: z.object({
-			agentProfile: z.enum([
-				"deny",
-				"confirm",
-				"allow"
-			]).optional(),
-			understanding: z.enum([
-				"deny",
-				"confirm",
-				"allow"
-			]).optional(),
-			workspace: z.enum([
-				"deny",
-				"confirm",
-				"allow"
-			]).optional()
-		}).strict().optional(),
-		retention: z.object({
-			compaction: ContextCompactionPolicySchema,
-			maxAgeDays: z.number().int().positive().optional(),
-			maxItems: z.number().int().positive().optional(),
-			maxChars: z.number().int().positive().optional()
-		}).strict().optional()
-	}).strict().default({
-		mode: "off",
-		sources: ["session"]
-	});
-	UserUnderstandingConfigSchema = z.object({
+	WritePolicySchema = z.enum([
+		"deny",
+		"confirm",
+		"allow"
+	]);
+	MaintenanceTimeSchema = z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Expected time in HH:mm format");
+	UserModelConfigSchema = z.object({
 		enabled: z.boolean().default(true),
+		writePolicy: WritePolicySchema.default("confirm"),
+		sensitiveWritePolicy: WritePolicySchema.default("confirm"),
 		processingPolicy: z.enum(["local_only", "remote_allowed"]).default("remote_allowed"),
-		adaptiveCadence: z.boolean().default(true),
-		reviewIntervalTurns: z.number().int().min(1).max(1e3).default(10),
-		maxHistoryMessages: z.number().int().min(1).max(200).default(80),
-		maxDurationMs: z.number().int().min(1e3).max(6e5).default(12e4)
+		extraction: z.object({
+			reviewIntervalTurns: z.number().int().min(1).max(1e3).default(10),
+			maxHistoryMessages: z.number().int().min(1).max(200).default(80),
+			maxDurationMs: z.number().int().min(1e3).max(6e5).default(12e4)
+		}).strict().default({
+			reviewIntervalTurns: 10,
+			maxHistoryMessages: 80,
+			maxDurationMs: 12e4
+		}),
+		maintenance: z.object({
+			enabled: z.boolean().default(true),
+			timezone: z.string().min(1).refine(isValidTimeZone, "Invalid IANA timezone").optional(),
+			temporalSweepMinutes: z.number().int().min(15).max(60).refine((value) => 60 % value === 0, "Must divide one hour evenly").default(60),
+			dailyTime: MaintenanceTimeSchema.default("03:00"),
+			weeklyDay: z.enum([
+				"sun",
+				"mon",
+				"tue",
+				"wed",
+				"thu",
+				"fri",
+				"sat"
+			]).default("sun"),
+			weeklyTime: MaintenanceTimeSchema.default("04:00"),
+			evidenceThreshold: z.number().int().min(2).max(10).default(2),
+			limit: z.number().int().positive().max(1e4).default(1e3),
+			staleRetentionDays: z.number().int().min(1).max(3650).default(30)
+		}).strict().default({
+			enabled: true,
+			temporalSweepMinutes: 60,
+			dailyTime: "03:00",
+			weeklyDay: "sun",
+			weeklyTime: "04:00",
+			evidenceThreshold: 2,
+			limit: 1e3,
+			staleRetentionDays: 30
+		})
 	}).strict().default({
 		enabled: true,
+		writePolicy: "confirm",
+		sensitiveWritePolicy: "confirm",
 		processingPolicy: "remote_allowed",
-		adaptiveCadence: true,
-		reviewIntervalTurns: 10,
-		maxHistoryMessages: 80,
-		maxDurationMs: 12e4
+		extraction: {
+			reviewIntervalTurns: 10,
+			maxHistoryMessages: 80,
+			maxDurationMs: 12e4
+		},
+		maintenance: {
+			enabled: true,
+			temporalSweepMinutes: 60,
+			dailyTime: "03:00",
+			weeklyDay: "sun",
+			weeklyTime: "04:00",
+			evidenceThreshold: 2,
+			limit: 1e3,
+			staleRetentionDays: 30
+		}
 	});
-	UserContextPrivacySchema = z.object({ sensitiveWritePolicy: z.enum([
-		"deny",
-		"confirm",
-		"allow"
-	]).default("confirm") }).strict().default({ sensitiveWritePolicy: "confirm" });
-	UserContextProviderRoutingSchema = z.object({
+	KnowledgeMemoryConfigSchema = z.object({
+		enabled: z.boolean().default(true),
+		writePolicy: WritePolicySchema.default("confirm"),
+		sources: z.array(z.enum([
+			"session",
+			"workspace",
+			"project",
+			"connector"
+		])).default(["session", "workspace"]),
 		searchStrategy: z.enum([
 			"local-first",
 			"external-first",
@@ -128,61 +144,40 @@ var init_config = __esmMin((() => {
 		allowedProviderIds: z.array(z.string().min(1)).optional(),
 		autoWriteKinds: z.array(z.string().min(1)).optional()
 	}).strict().default({
+		enabled: true,
+		writePolicy: "confirm",
+		sources: ["session", "workspace"],
 		searchStrategy: "fanout",
 		writeStrategy: "local-first",
 		allowExternalWrites: false
 	});
-	DreamingTimeSchema = z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Expected time in HH:mm format");
-	UserContextDreamingSchema = z.object({
-		mode: z.enum(["off", "review"]).default("review"),
-		timezone: z.string().min(1).refine(isValidTimeZone, "Invalid IANA timezone").optional(),
-		schedule: z.object({ time: DreamingTimeSchema.default("03:00") }).strict().default({ time: "03:00" }),
-		minEvidenceSources: z.number().int().min(2).max(10).default(2),
-		limit: z.number().int().positive().max(2e3).default(500)
+	ContextPlanningConfigSchema = z.object({
+		enabled: z.boolean().default(true),
+		maxAssertions: z.number().int().min(1).max(100).default(20),
+		maxKnowledge: z.number().int().min(0).max(100).default(12),
+		maxChars: z.number().int().min(500).max(5e4).default(6e3),
+		compaction: ContextCompactionPolicySchema
 	}).strict().default({
-		mode: "review",
-		schedule: { time: "03:00" },
-		minEvidenceSources: 2,
-		limit: 500
+		enabled: true,
+		maxAssertions: 20,
+		maxKnowledge: 12,
+		maxChars: 6e3,
+		compaction: DEFAULT_CONTEXT_COMPACTION_POLICY
 	});
 	UserContextConfigSchema = z.object({
 		enabled: z.boolean().default(true),
 		preferences: z.object({ responseLanguage: ResponseLanguageSchema.default("auto") }).strict().default({ responseLanguage: "auto" }),
-		memory: UserMemoryConfigSchema,
-		understanding: UserUnderstandingConfigSchema,
-		privacy: UserContextPrivacySchema,
-		providerRouting: UserContextProviderRoutingSchema,
-		dreaming: UserContextDreamingSchema
+		userModel: UserModelConfigSchema,
+		knowledgeMemory: KnowledgeMemoryConfigSchema,
+		contextPlanning: ContextPlanningConfigSchema
 	}).strict().default({
 		enabled: true,
 		preferences: { responseLanguage: "auto" },
-		memory: {
-			mode: "confirmWrite",
-			sources: ["session", "understanding"],
-			writePolicy: { understanding: "confirm" }
-		},
-		understanding: {
-			enabled: true,
-			processingPolicy: "remote_allowed",
-			adaptiveCadence: true,
-			reviewIntervalTurns: 10,
-			maxHistoryMessages: 80,
-			maxDurationMs: 12e4
-		},
-		privacy: { sensitiveWritePolicy: "confirm" },
-		providerRouting: {
-			searchStrategy: "fanout",
-			writeStrategy: "local-first",
-			allowExternalWrites: false
-		},
-		dreaming: {
-			mode: "review",
-			schedule: { time: "03:00" },
-			minEvidenceSources: 2,
-			limit: 500
-		}
+		userModel: UserModelConfigSchema.parse({}),
+		knowledgeMemory: KnowledgeMemoryConfigSchema.parse({}),
+		contextPlanning: ContextPlanningConfigSchema.parse({})
 	});
 }));
 //#endregion
 init_config();
-export { ContextCompactionPolicySchema, DEFAULT_CONTEXT_COMPACTION_POLICY, UserContextConfigSchema, UserContextDreamingSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, UserMemoryConfigSchema, UserMemoryModeSchema, UserUnderstandingConfigSchema, init_config };
+export { ContextCompactionPolicySchema, ContextPlanningConfigSchema, DEFAULT_CONTEXT_COMPACTION_POLICY, KnowledgeMemoryConfigSchema, UserContextConfigSchema, UserModelConfigSchema, init_config };

package/dist/src/user-context/relationship-continuity.d.ts

@@ -1,4 +1,4 @@
-import type { UserUnderstanding } from './domain.js';
+import { type UserAssertion } from '../user-model/index.js';
 export interface RelationshipFollowUpRequest {
     subject: string;
     validFrom?: number;
@@ -8,4 +8,4 @@ export declare function recordExplicitRelationshipFollowUp(input: {
     sessionKey: string;
     message: string;
     nowMs?: number;
-}): UserUnderstanding | null;
+}): UserAssertion | null;

package/dist/src/user-context/relationship-continuity.js

@@ -1,5 +1,6 @@
-import { createContextEvidence, createUnderstanding, linkUnderstandingEvidence, listUnderstandings } from "../storage/sqlite/user-context-repository.js";
-import "../storage/sqlite/index.js";
+import { createContextEvidence } from "../storage/sqlite/context-evidence-repository.js";
+import { reconcileAssertion } from "../user-model/repository.js";
+import "../user-model/index.js";
 import { createHash } from "node:crypto";
 //#region src/user-context/relationship-continuity.ts
 const CHINESE_FOLLOW_UP_PATTERN = /^(?:请|记得|麻烦|帮我)?\s*(?:明天|下周|之后|到时候)?\s*(?:提醒我|问问我|跟进一下|跟进)(?:关于)?[：:，,\s]*(.+)$/;
@@ -24,35 +25,44 @@ function extractExplicitRelationshipFollowUp(message, nowMs = Date.now()) {
 	};
 }
 function recordExplicitRelationshipFollowUp(input) {
-	const request = extractExplicitRelationshipFollowUp(input.message, input.nowMs);
+	const now = input.nowMs ?? Date.now();
+	const request = extractExplicitRelationshipFollowUp(input.message, now);
 	if (!request) return null;
-	const canonicalKey = `relationship-follow-up:${hash(request.subject.toLocaleLowerCase())}`;
-	const existing = listUnderstandings().find((item) => item.canonicalKey === canonicalKey && item.scope.type === "global" && item.status !== "rejected" && item.status !== "archived");
-	if (existing) return existing;
-	const understanding = createUnderstanding({
-		kind: "relationship",
-		canonicalKey,
-		status: "active",
-		scope: { type: "global" },
-		explicitness: "explicit",
-		durability: "recurring",
-		sensitivity: "normal",
-		disclosurePolicy: "referenceable",
-		confidence: 1,
-		statement: request.subject,
-		...request.validFrom ? { validFrom: request.validFrom } : {},
-		createdBy: "user",
-		changeReason: "Explicit follow-up request"
-	});
+	const key = hash(request.subject.toLocaleLowerCase());
 	const evidence = createContextEvidence({
 		sourceType: "conversation",
 		sourceRef: `session:${input.sessionKey}:follow-up:${hash(input.message)}`,
 		redactedExcerpt: input.message.slice(0, 600),
 		trustLevel: "owner",
-		observedAt: input.nowMs ?? Date.now()
+		observedAt: now
 	});
-	linkUnderstandingEvidence(understanding.versionId, evidence.id, "supports", 1);
-	return understanding;
+	return reconcileAssertion({
+		subject: {
+			type: "topic",
+			id: key
+		},
+		predicate: `relationship.follow_up.${key}`,
+		cardinality: "single",
+		scope: { type: "global" },
+		kind: "relationship",
+		value: request.subject,
+		normalizedValue: request.subject.toLocaleLowerCase(),
+		statement: request.subject,
+		authority: "user_explicit",
+		confidence: 1,
+		declaredImportance: .8,
+		inferredImportance: .8,
+		consequence: "medium",
+		actionability: 1,
+		volatility: "slow",
+		sensitivity: "normal",
+		disclosurePolicy: "referenceable",
+		...request.validFrom ? { validFrom: request.validFrom } : {},
+		observedAt: now,
+		createdBy: "user",
+		evidenceId: evidence.id,
+		evidenceConfidence: 1
+	}, now).assertion;
 }
 //#endregion
 export { extractExplicitRelationshipFollowUp, recordExplicitRelationshipFollowUp };

package/dist/src/user-context/sources/activity-clustering.d.ts

@@ -1,5 +1,11 @@
-import type { UnderstandingSourceItem, UserFocus } from './types.js';
-export type ActivityTopic = Pick<UserFocus, 'canonicalKey' | 'title' | 'summary' | 'horizon' | 'confidence' | 'evidenceRefs'> & {
+import type { UnderstandingSourceItem } from './types.js';
+export interface ActivityTopic {
+    canonicalKey: string;
+    title: string;
+    summary: string;
+    horizon: 'current' | 'ongoing' | 'long_term';
+    confidence: number;
+    evidenceRefs: string[];
     sourceIds: string[];
-};
+}
 export declare function clusterActivityTopics(items: UnderstandingSourceItem[], now?: number): ActivityTopic[];

package/dist/src/user-context/sources/index.js

@@ -1,4 +1,4 @@
-import { createUnderstandingSourceRun, deleteUserFocus, getUnderstandingSourceGrant, getUnderstandingSourceRun, getUserFocus, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocusEvidence, listUserFocuses, revokeUnderstandingSourceGrant, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, updateUserFocus, upsertUnderstandingSourceGrant, upsertUserFocus } from "./repository.js";
+import { createUnderstandingSourceRun, getUnderstandingSourceGrant, getUnderstandingSourceRun, listUnderstandingSourceGrants, listUnderstandingSourceRuns, revokeUnderstandingSourceGrant, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant } from "./repository.js";
 import { clusterUnderstandingSignals, tokenizeUnderstandingSignal } from "./signal-clustering.js";
 import { listUnderstandingSourceDefinitions } from "./catalog.js";
-export { clusterUnderstandingSignals, createUnderstandingSourceRun, deleteUserFocus, getUnderstandingSourceGrant, getUnderstandingSourceRun, getUserFocus, listUnderstandingSourceDefinitions, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocusEvidence, listUserFocuses, revokeUnderstandingSourceGrant, tokenizeUnderstandingSignal, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, updateUserFocus, upsertUnderstandingSourceGrant, upsertUserFocus };
+export { clusterUnderstandingSignals, createUnderstandingSourceRun, getUnderstandingSourceGrant, getUnderstandingSourceRun, listUnderstandingSourceDefinitions, listUnderstandingSourceGrants, listUnderstandingSourceRuns, revokeUnderstandingSourceGrant, tokenizeUnderstandingSignal, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant };

package/dist/src/user-context/sources/repository.d.ts

@@ -1,18 +1,4 @@
-import { type ContextEvidence, type UserContextScope } from '../domain.js';
-import type { UnderstandingSourceGrant, UnderstandingSourceRun, UserFocus } from './types.js';
-type UserFocusInput = Omit<UserFocus, 'id' | 'versionId' | 'principalId' | 'scope' | 'explicitness' | 'sensitivity' | 'disclosurePolicy' | 'validFrom' | 'validTo' | 'reviewAt' | 'createdAt' | 'updatedAt'> & {
-    principalId?: string;
-    scope?: UserContextScope;
-    explicitness?: UserFocus['explicitness'];
-    sensitivity?: UserFocus['sensitivity'];
-    disclosurePolicy?: UserFocus['disclosurePolicy'];
-    validFrom?: number;
-    validTo?: number;
-    reviewAt?: number;
-    changeReason?: string;
-    nowMs?: number;
-};
-export declare function listUserFocusEvidence(focusId: string): ContextEvidence[];
+import type { UnderstandingSourceGrant, UnderstandingSourceRun } from './types.js';
 export declare function listUnderstandingSourceGrants(options?: {
     includeRevoked?: boolean;
 }): UnderstandingSourceGrant[];
@@ -53,9 +39,3 @@ export declare function updateUnderstandingSourceRun(id: string, patch: {
     completed?: boolean;
     nowMs?: number;
 }): UnderstandingSourceRun | null;
-export declare function upsertUserFocus(input: UserFocusInput): UserFocus;
-export declare function listUserFocuses(statuses?: UserFocus['status'][], limit?: number): UserFocus[];
-export declare function getUserFocus(id: string): UserFocus | undefined;
-export declare function updateUserFocus(id: string, patch: Partial<Pick<UserFocus, 'title' | 'summary' | 'status' | 'validFrom' | 'validTo' | 'reviewAt'>>, nowMs?: number): UserFocus | null;
-export declare function deleteUserFocus(id: string): boolean;
-export {};

package/dist/src/user-context/sources/repository.js

@@ -1,7 +1,5 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
-import { USER_CONTEXT_PRINCIPAL_ID } from "../domain.js";
 import { notifyUserContextChange } from "../changes.js";
-import { focusLifecycle } from "../focus-lifecycle.js";
 import { randomUUID } from "node:crypto";
 //#region src/user-context/sources/repository.ts
 function record(value) {
@@ -11,14 +9,6 @@ function record(value) {
 		return {};
 	}
 }
-function strings(value) {
-	try {
-		const parsed = JSON.parse(value);
-		return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
-	} catch {
-		return [];
-	}
-}
 function grantFromRow(row) {
 	return {
 		id: row.grant_id,
@@ -53,85 +43,6 @@ function runFromRow(row) {
 		...row.completed_at == null ? {} : { completedAt: row.completed_at }
 	};
 }
-function focusFromRow(row) {
-	return {
-		id: row.focus_id,
-		versionId: row.current_version_id,
-		principalId: row.principal_id,
-		canonicalKey: row.canonical_key,
-		title: row.title,
-		summary: row.summary,
-		horizon: row.horizon,
-		status: row.status,
-		confidence: row.confidence,
-		scope: {
-			type: row.scope_type,
-			...row.scope_id ? { id: row.scope_id } : {}
-		},
-		explicitness: row.explicitness,
-		sensitivity: row.sensitivity,
-		disclosurePolicy: row.disclosure_policy,
-		...row.valid_from == null ? {} : { validFrom: row.valid_from },
-		...row.valid_to == null ? {} : { validTo: row.valid_to },
-		...row.review_at == null ? {} : { reviewAt: row.review_at },
-		evidenceRefs: strings(row.evidence_refs_json),
-		...row.source_run_id ? { sourceRunId: row.source_run_id } : {},
-		createdAt: row.created_at,
-		updatedAt: row.updated_at
-	};
-}
-function focusSnapshot(row) {
-	return {
-		horizon: row.horizon,
-		status: row.status,
-		confidence: row.confidence,
-		scopeType: row.scope_type,
-		scopeId: row.scope_id,
-		explicitness: row.explicitness,
-		sensitivity: row.sensitivity,
-		disclosurePolicy: row.disclosure_policy,
-		validFrom: row.valid_from,
-		validTo: row.valid_to,
-		reviewAt: row.review_at,
-		evidenceRefs: strings(row.evidence_refs_json)
-	};
-}
-function sameFocusVersion(left, right) {
-	return Boolean(left && left.title === right.title && left.summary === right.summary && JSON.stringify(focusSnapshot(left)) === JSON.stringify(focusSnapshot(right)));
-}
-function linkFocusEvidence(versionId, evidenceRefs, confidence) {
-	if (!evidenceRefs.length) return;
-	const placeholders = evidenceRefs.map(() => "?").join(", ");
-	getSqliteDatabase().prepare(`INSERT OR IGNORE INTO user_focus_evidence_links (
-    version_id, evidence_id, relation, confidence
-  ) SELECT ?, evidence_id, 'supports', ? FROM context_evidence WHERE source_ref IN (${placeholders})`).run(versionId, confidence, ...evidenceRefs);
-}
-function listUserFocusEvidence(focusId) {
-	return getSqliteDatabase().prepare(`SELECT DISTINCT e.* FROM context_evidence e
-    JOIN user_focus_evidence_links l ON l.evidence_id = e.evidence_id
-    JOIN user_focus_versions v ON v.version_id = l.version_id
-    WHERE v.focus_id = ? ORDER BY e.observed_at DESC`).all(focusId).map((row) => ({
-		id: row.evidence_id,
-		sourceType: row.source_type,
-		...row.source_instance_id ? { sourceInstanceId: row.source_instance_id } : {},
-		sourceRef: row.source_ref,
-		...row.source_run_id ? { sourceRunId: row.source_run_id } : {},
-		...row.source_item_id ? { sourceItemId: row.source_item_id } : {},
-		...row.session_id ? { sessionId: row.session_id } : {},
-		...row.turn_id ? { turnId: row.turn_id } : {},
-		...row.message_id ? { messageId: row.message_id } : {},
-		...row.content_hash ? { contentHash: row.content_hash } : {},
-		...row.retention_policy ? { retentionPolicy: row.retention_policy } : {},
-		...row.processing_policy ? { processingPolicy: row.processing_policy } : {},
-		...row.extractor_id ? { extractorId: row.extractor_id } : {},
-		...row.extractor_version ? { extractorVersion: row.extractor_version } : {},
-		...row.redacted_excerpt ? { redactedExcerpt: row.redacted_excerpt } : {},
-		trustLevel: row.trust_level,
-		observedAt: row.observed_at,
-		ingestedAt: row.ingested_at ?? row.created_at,
-		createdAt: row.created_at
-	}));
-}
 function listUnderstandingSourceGrants(options = {}) {
 	return getSqliteDatabase().prepare(`SELECT * FROM understanding_source_grants ${options.includeRevoked ? "" : "WHERE status = 'active'"} ORDER BY updated_at DESC`).all().map(grantFromRow);
 }
@@ -213,98 +124,5 @@ function updateUnderstandingSourceRun(id, patch) {
   `).run(patch.status ?? current.status, patch.cursorAfter ?? current.cursorAfter ?? null, patch.itemsSeen ?? current.itemsSeen, JSON.stringify(patch.metadata ?? current.metadata), patch.errorMessage ?? current.errorMessage ?? null, completedAt, id));
 	return getUnderstandingSourceRun(id);
 }
-function upsertUserFocus(input) {
-	const id = randomUUID();
-	const now = input.nowMs ?? Date.now();
-	const scope = input.scope ?? { type: "global" };
-	const explicitness = input.explicitness ?? "inferred";
-	const sensitivity = input.sensitivity ?? "normal";
-	const disclosurePolicy = input.disclosurePolicy ?? "referenceable";
-	const existingRow = getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE canonical_key = ?").get(input.canonicalKey);
-	if (existingRow?.explicitness === "explicit" && explicitness !== "explicit") return focusFromRow(existingRow);
-	if (existingRow) notifyUserContextChange({
-		kind: "focus",
-		id: existingRow.focus_id
-	});
-	let currentVersionId = existingRow?.current_version_id;
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`
-    INSERT INTO user_focuses (
-      focus_id, principal_id, canonical_key, title, summary, horizon, status, confidence,
-      scope_type, scope_id, explicitness, sensitivity, disclosure_policy,
-      valid_from, valid_to, review_at, evidence_refs_json, source_run_id, created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(canonical_key) DO UPDATE SET title = excluded.title, summary = excluded.summary,
-      horizon = excluded.horizon,
-      status = CASE
-        WHEN user_focuses.status IN ('active', 'paused', 'completed', 'rejected') AND excluded.status = 'candidate'
-          THEN user_focuses.status
-        ELSE excluded.status
-      END,
-      confidence = excluded.confidence,
-      scope_type = excluded.scope_type, scope_id = excluded.scope_id,
-      explicitness = excluded.explicitness, sensitivity = excluded.sensitivity,
-      disclosure_policy = excluded.disclosure_policy, valid_from = excluded.valid_from,
-      valid_to = excluded.valid_to, review_at = excluded.review_at,
-      evidence_refs_json = excluded.evidence_refs_json,
-      source_run_id = excluded.source_run_id, updated_at = excluded.updated_at
-  `).run(id, input.principalId ?? "local-owner", input.canonicalKey, input.title, input.summary, input.horizon, input.status, input.confidence, scope.type, scope.id ?? null, explicitness, sensitivity, disclosurePolicy, input.validFrom ?? null, input.validTo ?? null, input.reviewAt ?? null, JSON.stringify(input.evidenceRefs), input.sourceRunId ?? null, now, now);
-		const nextRow = db.prepare("SELECT * FROM user_focuses WHERE canonical_key = ?").get(input.canonicalKey);
-		if (!sameFocusVersion(existingRow, nextRow)) {
-			currentVersionId = randomUUID();
-			db.prepare(`INSERT INTO user_focus_versions (
-        version_id, focus_id, title, summary, snapshot_json, created_by, change_reason, created_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(currentVersionId, nextRow.focus_id, nextRow.title, nextRow.summary, JSON.stringify(focusSnapshot(nextRow)), explicitness === "explicit" ? "user" : input.sourceRunId ? "connector" : "runtime", input.changeReason ?? (existingRow ? "Focus updated" : "Focus created"), now);
-			db.prepare("UPDATE user_focuses SET current_version_id = ? WHERE focus_id = ?").run(currentVersionId, nextRow.focus_id);
-		}
-	});
-	if (currentVersionId) linkFocusEvidence(currentVersionId, input.evidenceRefs, input.confidence);
-	return focusFromRow(getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE canonical_key = ?").get(input.canonicalKey));
-}
-function listUserFocuses(statuses, limit) {
-	const maxRows = limit === void 0 ? -1 : Math.max(1, Math.min(200, Math.floor(limit)));
-	if (!statuses?.length) return getSqliteDatabase().prepare("SELECT * FROM user_focuses ORDER BY updated_at DESC LIMIT ?").all(maxRows).map(focusFromRow);
-	const placeholders = statuses.map(() => "?").join(", ");
-	return getSqliteDatabase().prepare(`SELECT * FROM user_focuses WHERE status IN (${placeholders}) ORDER BY updated_at DESC LIMIT ?`).all(...statuses, maxRows).map(focusFromRow);
-}
-function getUserFocus(id) {
-	const row = getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE focus_id = ? AND principal_id = ?").get(id, USER_CONTEXT_PRINCIPAL_ID);
-	return row ? focusFromRow(row) : void 0;
-}
-function updateUserFocus(id, patch, nowMs = Date.now()) {
-	notifyUserContextChange({
-		kind: "focus",
-		id
-	});
-	const currentRow = getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE focus_id = ?").get(id);
-	if (!currentRow) return null;
-	const current = focusFromRow(currentRow);
-	const renewedLifecycle = patch.status === "active" && (current.status !== "active" || current.reviewAt !== void 0 && current.reviewAt <= nowMs || current.validTo !== void 0 && current.validTo <= nowMs) ? focusLifecycle(current.horizon, nowMs) : {};
-	const nextValidFrom = patch.validFrom ?? renewedLifecycle.validFrom ?? current.validFrom;
-	const nextValidTo = patch.validTo ?? renewedLifecycle.validTo ?? current.validTo;
-	const nextReviewAt = patch.reviewAt ?? renewedLifecycle.reviewAt ?? current.reviewAt;
-	if ((patch.title ?? current.title) === current.title && (patch.summary ?? current.summary) === current.summary && (patch.status ?? current.status) === current.status && nextValidFrom === current.validFrom && nextValidTo === current.validTo && nextReviewAt === current.reviewAt) return current;
-	const versionId = randomUUID();
-	runSqliteWriteTransaction((db) => {
-		db.prepare(`UPDATE user_focuses
-      SET title = ?, summary = ?, status = ?, valid_from = ?, valid_to = ?, review_at = ?, updated_at = ?
-      WHERE focus_id = ?`).run(patch.title ?? current.title, patch.summary ?? current.summary, patch.status ?? current.status, nextValidFrom ?? null, nextValidTo ?? null, nextReviewAt ?? null, nowMs, id);
-		const nextRow = db.prepare("SELECT * FROM user_focuses WHERE focus_id = ?").get(id);
-		db.prepare(`INSERT INTO user_focus_versions (
-      version_id, focus_id, title, summary, snapshot_json, created_by, change_reason, created_at
-    ) VALUES (?, ?, ?, ?, ?, ?, 'Focus updated', ?)`).run(versionId, id, nextRow.title, nextRow.summary, JSON.stringify(focusSnapshot(nextRow)), current.explicitness === "explicit" ? "user" : "runtime", nowMs);
-		db.prepare("UPDATE user_focuses SET current_version_id = ? WHERE focus_id = ?").run(versionId, id);
-	});
-	linkFocusEvidence(versionId, current.evidenceRefs, current.confidence);
-	const row = getSqliteDatabase().prepare("SELECT * FROM user_focuses WHERE focus_id = ?").get(id);
-	return row ? focusFromRow(row) : null;
-}
-function deleteUserFocus(id) {
-	notifyUserContextChange({
-		kind: "focus",
-		id
-	});
-	return Number(getSqliteDatabase().prepare("DELETE FROM user_focuses WHERE focus_id = ?").run(id).changes) > 0;
-}
 //#endregion
-export { createUnderstandingSourceRun, deleteUserFocus, getUnderstandingSourceGrant, getUnderstandingSourceRun, getUserFocus, listUnderstandingSourceGrants, listUnderstandingSourceRuns, listUserFocusEvidence, listUserFocuses, revokeUnderstandingSourceGrant, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, updateUserFocus, upsertUnderstandingSourceGrant, upsertUserFocus };
+export { createUnderstandingSourceRun, getUnderstandingSourceGrant, getUnderstandingSourceRun, listUnderstandingSourceGrants, listUnderstandingSourceRuns, revokeUnderstandingSourceGrant, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceGrantPolicies, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant };

package/dist/src/user-context/sources/types.d.ts

@@ -1,4 +1,3 @@
-import type { UserContextScope, UserUnderstanding } from '../domain.js';
 export type UnderstandingSourcePlatform = 'darwin' | 'win32' | 'linux' | 'all';
 export type UnderstandingSourceCategory = 'files' | 'recent_documents' | 'calendar' | 'tasks' | 'notes' | 'mail' | 'messages' | 'code_activity';
 export type UnderstandingSourceAccessMode = 'once' | 'continuous';
@@ -74,25 +73,3 @@ export interface UnderstandingSourceRun {
     startedAt: number;
     completedAt?: number;
 }
-export interface UserFocus {
-    id: string;
-    versionId: string;
-    principalId: string;
-    canonicalKey: string;
-    title: string;
-    summary: string;
-    horizon: 'current' | 'ongoing' | 'long_term';
-    status: 'candidate' | 'active' | 'paused' | 'completed' | 'rejected';
-    confidence: number;
-    scope: UserContextScope;
-    explicitness: UserUnderstanding['explicitness'];
-    sensitivity: UserUnderstanding['sensitivity'];
-    disclosurePolicy: UserUnderstanding['disclosurePolicy'];
-    validFrom?: number;
-    validTo?: number;
-    reviewAt?: number;
-    evidenceRefs: string[];
-    sourceRunId?: string;
-    createdAt: number;
-    updatedAt: number;
-}