@xopcai/xopc 0.0.248 → 0.0.249

package/dist/src/user-context/config.d.ts

@@ -1,10 +1,4 @@
 import { z } from 'zod';
-export declare const UserMemoryModeSchema: z.ZodEnum<{
-    off: "off";
-    auto: "auto";
-    readOnly: "readOnly";
-    confirmWrite: "confirmWrite";
-}>;
 export declare const DEFAULT_CONTEXT_COMPACTION_POLICY: {
     enabled: boolean;
     triggerThreshold: number;
@@ -40,79 +34,60 @@ export declare const ContextCompactionPolicySchema: z.ZodDefault<z.ZodObject<{
     maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
     postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>>;
-export declare const UserMemoryConfigSchema: z.ZodDefault<z.ZodObject<{
-    mode: z.ZodDefault<z.ZodEnum<{
-        off: "off";
-        auto: "auto";
-        readOnly: "readOnly";
-        confirmWrite: "confirmWrite";
-    }>>;
-    sources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        session: "session";
-        workspace: "workspace";
-        understanding: "understanding";
-        agentProfile: "agentProfile";
-    }>>>;
-    writePolicy: z.ZodOptional<z.ZodObject<{
-        agentProfile: z.ZodOptional<z.ZodEnum<{
-            allow: "allow";
-            confirm: "confirm";
-            deny: "deny";
-        }>>;
-        understanding: z.ZodOptional<z.ZodEnum<{
-            allow: "allow";
-            confirm: "confirm";
-            deny: "deny";
-        }>>;
-        workspace: z.ZodOptional<z.ZodEnum<{
-            allow: "allow";
-            confirm: "confirm";
-            deny: "deny";
-        }>>;
-    }, z.core.$strict>>;
-    retention: z.ZodOptional<z.ZodObject<{
-        compaction: z.ZodDefault<z.ZodObject<{
-            enabled: z.ZodDefault<z.ZodBoolean>;
-            triggerThreshold: z.ZodDefault<z.ZodNumber>;
-            reserveTokens: z.ZodDefault<z.ZodNumber>;
-            minMessagesBeforeCompact: z.ZodDefault<z.ZodNumber>;
-            keepRecentTokens: z.ZodDefault<z.ZodNumber>;
-            recentTurnsPreserve: z.ZodDefault<z.ZodNumber>;
-            summaryMaxTokens: z.ZodDefault<z.ZodNumber>;
-            summaryChunkTokens: z.ZodDefault<z.ZodNumber>;
-            summaryTimeoutMs: z.ZodDefault<z.ZodNumber>;
-            summaryRetries: z.ZodDefault<z.ZodNumber>;
-            qualityGuard: z.ZodDefault<z.ZodBoolean>;
-            gapAudit: z.ZodDefault<z.ZodBoolean>;
-            model: z.ZodOptional<z.ZodString>;
-            minToolResultKeepChars: z.ZodDefault<z.ZodNumber>;
-            maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
-            postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>;
-        maxAgeDays: z.ZodOptional<z.ZodNumber>;
-        maxItems: z.ZodOptional<z.ZodNumber>;
-        maxChars: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>>;
-}, z.core.$strict>>;
-export declare const UserUnderstandingConfigSchema: z.ZodDefault<z.ZodObject<{
+export declare const UserModelConfigSchema: z.ZodDefault<z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
+    writePolicy: z.ZodDefault<z.ZodEnum<{
+        allow: "allow";
+        confirm: "confirm";
+        deny: "deny";
+    }>>;
+    sensitiveWritePolicy: z.ZodDefault<z.ZodEnum<{
+        allow: "allow";
+        confirm: "confirm";
+        deny: "deny";
+    }>>;
     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>;
-    maxDurationMs: z.ZodDefault<z.ZodNumber>;
+    extraction: z.ZodDefault<z.ZodObject<{
+        reviewIntervalTurns: z.ZodDefault<z.ZodNumber>;
+        maxHistoryMessages: z.ZodDefault<z.ZodNumber>;
+        maxDurationMs: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
+    maintenance: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        timezone: z.ZodOptional<z.ZodString>;
+        temporalSweepMinutes: z.ZodDefault<z.ZodNumber>;
+        dailyTime: z.ZodDefault<z.ZodString>;
+        weeklyDay: z.ZodDefault<z.ZodEnum<{
+            sun: "sun";
+            mon: "mon";
+            tue: "tue";
+            wed: "wed";
+            thu: "thu";
+            fri: "fri";
+            sat: "sat";
+        }>>;
+        weeklyTime: z.ZodDefault<z.ZodString>;
+        evidenceThreshold: z.ZodDefault<z.ZodNumber>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        staleRetentionDays: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
 }, z.core.$strict>>;
-export declare const UserContextPrivacySchema: z.ZodDefault<z.ZodObject<{
-    sensitiveWritePolicy: z.ZodDefault<z.ZodEnum<{
+export declare const KnowledgeMemoryConfigSchema: z.ZodDefault<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    writePolicy: z.ZodDefault<z.ZodEnum<{
         allow: "allow";
         confirm: "confirm";
         deny: "deny";
     }>>;
-}, z.core.$strict>>;
-export declare const UserContextProviderRoutingSchema: z.ZodDefault<z.ZodObject<{
+    sources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        project: "project";
+        session: "session";
+        workspace: "workspace";
+        connector: "connector";
+    }>>>;
     searchStrategy: z.ZodDefault<z.ZodEnum<{
         "local-first": "local-first";
         "external-first": "external-first";
@@ -131,17 +106,29 @@ export declare const UserContextProviderRoutingSchema: z.ZodDefault<z.ZodObject<
     allowedProviderIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     autoWriteKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>>;
-export declare const UserContextDreamingSchema: z.ZodDefault<z.ZodObject<{
-    mode: z.ZodDefault<z.ZodEnum<{
-        off: "off";
-        review: "review";
-    }>>;
-    timezone: z.ZodOptional<z.ZodString>;
-    schedule: z.ZodDefault<z.ZodObject<{
-        time: z.ZodDefault<z.ZodString>;
+export declare const ContextPlanningConfigSchema: z.ZodDefault<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    maxAssertions: z.ZodDefault<z.ZodNumber>;
+    maxKnowledge: z.ZodDefault<z.ZodNumber>;
+    maxChars: z.ZodDefault<z.ZodNumber>;
+    compaction: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        triggerThreshold: z.ZodDefault<z.ZodNumber>;
+        reserveTokens: z.ZodDefault<z.ZodNumber>;
+        minMessagesBeforeCompact: z.ZodDefault<z.ZodNumber>;
+        keepRecentTokens: z.ZodDefault<z.ZodNumber>;
+        recentTurnsPreserve: z.ZodDefault<z.ZodNumber>;
+        summaryMaxTokens: z.ZodDefault<z.ZodNumber>;
+        summaryChunkTokens: z.ZodDefault<z.ZodNumber>;
+        summaryTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        summaryRetries: z.ZodDefault<z.ZodNumber>;
+        qualityGuard: z.ZodDefault<z.ZodBoolean>;
+        gapAudit: z.ZodDefault<z.ZodBoolean>;
+        model: z.ZodOptional<z.ZodString>;
+        minToolResultKeepChars: z.ZodDefault<z.ZodNumber>;
+        maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
+        postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
-    minEvidenceSources: z.ZodDefault<z.ZodNumber>;
-    limit: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>>;
 export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
@@ -152,79 +139,60 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
             "zh-CN": "zh-CN";
         }>>;
     }, z.core.$strict>>;
-    memory: z.ZodDefault<z.ZodObject<{
-        mode: z.ZodDefault<z.ZodEnum<{
-            off: "off";
-            auto: "auto";
-            readOnly: "readOnly";
-            confirmWrite: "confirmWrite";
-        }>>;
-        sources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            session: "session";
-            workspace: "workspace";
-            understanding: "understanding";
-            agentProfile: "agentProfile";
-        }>>>;
-        writePolicy: z.ZodOptional<z.ZodObject<{
-            agentProfile: z.ZodOptional<z.ZodEnum<{
-                allow: "allow";
-                confirm: "confirm";
-                deny: "deny";
-            }>>;
-            understanding: z.ZodOptional<z.ZodEnum<{
-                allow: "allow";
-                confirm: "confirm";
-                deny: "deny";
-            }>>;
-            workspace: z.ZodOptional<z.ZodEnum<{
-                allow: "allow";
-                confirm: "confirm";
-                deny: "deny";
-            }>>;
-        }, z.core.$strict>>;
-        retention: z.ZodOptional<z.ZodObject<{
-            compaction: z.ZodDefault<z.ZodObject<{
-                enabled: z.ZodDefault<z.ZodBoolean>;
-                triggerThreshold: z.ZodDefault<z.ZodNumber>;
-                reserveTokens: z.ZodDefault<z.ZodNumber>;
-                minMessagesBeforeCompact: z.ZodDefault<z.ZodNumber>;
-                keepRecentTokens: z.ZodDefault<z.ZodNumber>;
-                recentTurnsPreserve: z.ZodDefault<z.ZodNumber>;
-                summaryMaxTokens: z.ZodDefault<z.ZodNumber>;
-                summaryChunkTokens: z.ZodDefault<z.ZodNumber>;
-                summaryTimeoutMs: z.ZodDefault<z.ZodNumber>;
-                summaryRetries: z.ZodDefault<z.ZodNumber>;
-                qualityGuard: z.ZodDefault<z.ZodBoolean>;
-                gapAudit: z.ZodDefault<z.ZodBoolean>;
-                model: z.ZodOptional<z.ZodString>;
-                minToolResultKeepChars: z.ZodDefault<z.ZodNumber>;
-                maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
-                postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>>;
-            maxAgeDays: z.ZodOptional<z.ZodNumber>;
-            maxItems: z.ZodOptional<z.ZodNumber>;
-            maxChars: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    understanding: z.ZodDefault<z.ZodObject<{
+    userModel: z.ZodDefault<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
+        writePolicy: z.ZodDefault<z.ZodEnum<{
+            allow: "allow";
+            confirm: "confirm";
+            deny: "deny";
+        }>>;
+        sensitiveWritePolicy: z.ZodDefault<z.ZodEnum<{
+            allow: "allow";
+            confirm: "confirm";
+            deny: "deny";
+        }>>;
         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>;
-        maxDurationMs: z.ZodDefault<z.ZodNumber>;
+        extraction: z.ZodDefault<z.ZodObject<{
+            reviewIntervalTurns: z.ZodDefault<z.ZodNumber>;
+            maxHistoryMessages: z.ZodDefault<z.ZodNumber>;
+            maxDurationMs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        maintenance: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            timezone: z.ZodOptional<z.ZodString>;
+            temporalSweepMinutes: z.ZodDefault<z.ZodNumber>;
+            dailyTime: z.ZodDefault<z.ZodString>;
+            weeklyDay: z.ZodDefault<z.ZodEnum<{
+                sun: "sun";
+                mon: "mon";
+                tue: "tue";
+                wed: "wed";
+                thu: "thu";
+                fri: "fri";
+                sat: "sat";
+            }>>;
+            weeklyTime: z.ZodDefault<z.ZodString>;
+            evidenceThreshold: z.ZodDefault<z.ZodNumber>;
+            limit: z.ZodDefault<z.ZodNumber>;
+            staleRetentionDays: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
-    privacy: z.ZodDefault<z.ZodObject<{
-        sensitiveWritePolicy: z.ZodDefault<z.ZodEnum<{
+    knowledgeMemory: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        writePolicy: z.ZodDefault<z.ZodEnum<{
             allow: "allow";
             confirm: "confirm";
             deny: "deny";
         }>>;
-    }, z.core.$strict>>;
-    providerRouting: z.ZodDefault<z.ZodObject<{
+        sources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            project: "project";
+            session: "session";
+            workspace: "workspace";
+            connector: "connector";
+        }>>>;
         searchStrategy: z.ZodDefault<z.ZodEnum<{
             "local-first": "local-first";
             "external-first": "external-first";
@@ -243,18 +211,32 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
         allowedProviderIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
         autoWriteKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
-    dreaming: z.ZodDefault<z.ZodObject<{
-        mode: z.ZodDefault<z.ZodEnum<{
-            off: "off";
-            review: "review";
-        }>>;
-        timezone: z.ZodOptional<z.ZodString>;
-        schedule: z.ZodDefault<z.ZodObject<{
-            time: z.ZodDefault<z.ZodString>;
+    contextPlanning: z.ZodDefault<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        maxAssertions: z.ZodDefault<z.ZodNumber>;
+        maxKnowledge: z.ZodDefault<z.ZodNumber>;
+        maxChars: z.ZodDefault<z.ZodNumber>;
+        compaction: z.ZodDefault<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            triggerThreshold: z.ZodDefault<z.ZodNumber>;
+            reserveTokens: z.ZodDefault<z.ZodNumber>;
+            minMessagesBeforeCompact: z.ZodDefault<z.ZodNumber>;
+            keepRecentTokens: z.ZodDefault<z.ZodNumber>;
+            recentTurnsPreserve: z.ZodDefault<z.ZodNumber>;
+            summaryMaxTokens: z.ZodDefault<z.ZodNumber>;
+            summaryChunkTokens: z.ZodDefault<z.ZodNumber>;
+            summaryTimeoutMs: z.ZodDefault<z.ZodNumber>;
+            summaryRetries: z.ZodDefault<z.ZodNumber>;
+            qualityGuard: z.ZodDefault<z.ZodBoolean>;
+            gapAudit: z.ZodDefault<z.ZodBoolean>;
+            model: z.ZodOptional<z.ZodString>;
+            minToolResultKeepChars: z.ZodDefault<z.ZodNumber>;
+            maxActiveTranscriptBytes: z.ZodDefault<z.ZodNumber>;
+            postCompactionSections: z.ZodDefault<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>;
-        minEvidenceSources: z.ZodDefault<z.ZodNumber>;
-        limit: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
 }, z.core.$strict>>;
 export type UserContextConfig = z.infer<typeof UserContextConfigSchema>;
-export type UserContextDreaming = z.infer<typeof UserContextDreamingSchema>;
+export type UserModelConfig = z.infer<typeof UserModelConfigSchema>;
+export type KnowledgeMemoryConfig = z.infer<typeof KnowledgeMemoryConfigSchema>;
+export type ContextPlanningConfig = z.infer<typeof ContextPlanningConfigSchema>;

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 };