@xopcai/xopc 0.0.188 → 0.0.190

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

@@ -49,30 +49,23 @@ export declare const UserMemoryConfigSchema: z.ZodDefault<z.ZodObject<{
         session: "session";
         workspace: "workspace";
         understanding: "understanding";
-        userProfile: "userProfile";
         agentProfile: "agentProfile";
-        connectedSources: "connectedSources";
     }>>>;
     writePolicy: z.ZodOptional<z.ZodObject<{
-        userProfile: z.ZodOptional<z.ZodEnum<{
-            allow: "allow";
-            confirm: "confirm";
-            deny: "deny";
-        }>>;
         agentProfile: z.ZodOptional<z.ZodEnum<{
             allow: "allow";
-            confirm: "confirm";
             deny: "deny";
+            confirm: "confirm";
         }>>;
         understanding: z.ZodOptional<z.ZodEnum<{
             allow: "allow";
-            confirm: "confirm";
             deny: "deny";
+            confirm: "confirm";
         }>>;
         workspace: z.ZodOptional<z.ZodEnum<{
             allow: "allow";
-            confirm: "confirm";
             deny: "deny";
+            confirm: "confirm";
         }>>;
     }, z.core.$strict>>;
     retention: z.ZodOptional<z.ZodObject<{
@@ -108,8 +101,8 @@ export declare const UserUnderstandingConfigSchema: z.ZodDefault<z.ZodObject<{
 export declare const UserContextPrivacySchema: z.ZodDefault<z.ZodObject<{
     sensitiveWritePolicy: z.ZodDefault<z.ZodEnum<{
         allow: "allow";
-        confirm: "confirm";
         deny: "deny";
+        confirm: "confirm";
     }>>;
 }, z.core.$strict>>;
 export declare const UserContextProviderRoutingSchema: z.ZodDefault<z.ZodObject<{
@@ -131,140 +124,17 @@ 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 DreamingScheduleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"interval">;
-    everyHours: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<6>, z.ZodLiteral<8>, z.ZodLiteral<12>, z.ZodLiteral<24>]>;
-    minute: z.ZodNumber;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"daily">;
-    time: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"weekly">;
-    weekday: z.ZodNumber;
-    time: z.ZodString;
-}, z.core.$strict>], "kind">;
-export declare const DreamingSettingsSchema: z.ZodObject<{
-    mode: z.ZodEnum<{
-        off: "off";
-        observe: "observe";
-        review: "review";
-        automatic: "automatic";
-    }>;
-    timezone: z.ZodString;
-    phases: z.ZodObject<{
-        light: z.ZodObject<{
-            enabled: z.ZodBoolean;
-            schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"interval">;
-                everyHours: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<6>, z.ZodLiteral<8>, z.ZodLiteral<12>, z.ZodLiteral<24>]>;
-                minute: z.ZodNumber;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"daily">;
-                time: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"weekly">;
-                weekday: z.ZodNumber;
-                time: z.ZodString;
-            }, z.core.$strict>], "kind">;
-        }, z.core.$strict>;
-        deep: z.ZodObject<{
-            enabled: z.ZodBoolean;
-            schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"interval">;
-                everyHours: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<6>, z.ZodLiteral<8>, z.ZodLiteral<12>, z.ZodLiteral<24>]>;
-                minute: z.ZodNumber;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"daily">;
-                time: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"weekly">;
-                weekday: z.ZodNumber;
-                time: z.ZodString;
-            }, z.core.$strict>], "kind">;
-        }, z.core.$strict>;
-        rem: z.ZodObject<{
-            enabled: z.ZodBoolean;
-            schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"interval">;
-                everyHours: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<6>, z.ZodLiteral<8>, z.ZodLiteral<12>, z.ZodLiteral<24>]>;
-                minute: z.ZodNumber;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"daily">;
-                time: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"weekly">;
-                weekday: z.ZodNumber;
-                time: z.ZodString;
-            }, z.core.$strict>], "kind">;
-        }, z.core.$strict>;
-    }, z.core.$strict>;
-}, z.core.$strict>;
 export declare const UserContextDreamingSchema: z.ZodDefault<z.ZodObject<{
     mode: z.ZodDefault<z.ZodEnum<{
         off: "off";
-        observe: "observe";
         review: "review";
-        automatic: "automatic";
     }>>;
     timezone: z.ZodOptional<z.ZodString>;
-    phases: z.ZodOptional<z.ZodObject<{
-        light: z.ZodOptional<z.ZodObject<{
-            enabled: z.ZodOptional<z.ZodBoolean>;
-            schedule: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"interval">;
-                everyHours: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<6>, z.ZodLiteral<8>, z.ZodLiteral<12>, z.ZodLiteral<24>]>;
-                minute: z.ZodNumber;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"daily">;
-                time: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"weekly">;
-                weekday: z.ZodNumber;
-                time: z.ZodString;
-            }, z.core.$strict>], "kind">>;
-            lookbackDays: z.ZodOptional<z.ZodNumber>;
-            limit: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
-        deep: z.ZodOptional<z.ZodObject<{
-            enabled: z.ZodOptional<z.ZodBoolean>;
-            schedule: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"interval">;
-                everyHours: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<6>, z.ZodLiteral<8>, z.ZodLiteral<12>, z.ZodLiteral<24>]>;
-                minute: z.ZodNumber;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"daily">;
-                time: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"weekly">;
-                weekday: z.ZodNumber;
-                time: z.ZodString;
-            }, z.core.$strict>], "kind">>;
-            minScore: z.ZodOptional<z.ZodNumber>;
-            minRecallCount: z.ZodOptional<z.ZodNumber>;
-            minUniqueQueries: z.ZodOptional<z.ZodNumber>;
-            limit: z.ZodOptional<z.ZodNumber>;
-            recencyHalfLifeDays: z.ZodOptional<z.ZodNumber>;
-            maxAgeDays: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
-        rem: z.ZodOptional<z.ZodObject<{
-            enabled: z.ZodOptional<z.ZodBoolean>;
-            schedule: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"interval">;
-                everyHours: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<6>, z.ZodLiteral<8>, z.ZodLiteral<12>, z.ZodLiteral<24>]>;
-                minute: z.ZodNumber;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"daily">;
-                time: z.ZodString;
-            }, z.core.$strict>, z.ZodObject<{
-                kind: z.ZodLiteral<"weekly">;
-                weekday: z.ZodNumber;
-                time: z.ZodString;
-            }, z.core.$strict>], "kind">>;
-            lookbackDays: z.ZodOptional<z.ZodNumber>;
-            limit: z.ZodOptional<z.ZodNumber>;
-            minPatternStrength: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>;
+    schedule: z.ZodDefault<z.ZodObject<{
+        time: z.ZodDefault<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>;
@@ -286,30 +156,23 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
             session: "session";
             workspace: "workspace";
             understanding: "understanding";
-            userProfile: "userProfile";
             agentProfile: "agentProfile";
-            connectedSources: "connectedSources";
         }>>>;
         writePolicy: z.ZodOptional<z.ZodObject<{
-            userProfile: z.ZodOptional<z.ZodEnum<{
-                allow: "allow";
-                confirm: "confirm";
-                deny: "deny";
-            }>>;
             agentProfile: z.ZodOptional<z.ZodEnum<{
                 allow: "allow";
-                confirm: "confirm";
                 deny: "deny";
+                confirm: "confirm";
             }>>;
             understanding: z.ZodOptional<z.ZodEnum<{
                 allow: "allow";
-                confirm: "confirm";
                 deny: "deny";
+                confirm: "confirm";
             }>>;
             workspace: z.ZodOptional<z.ZodEnum<{
                 allow: "allow";
-                confirm: "confirm";
                 deny: "deny";
+                confirm: "confirm";
             }>>;
         }, z.core.$strict>>;
         retention: z.ZodOptional<z.ZodObject<{
@@ -345,8 +208,8 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
     privacy: z.ZodDefault<z.ZodObject<{
         sensitiveWritePolicy: z.ZodDefault<z.ZodEnum<{
             allow: "allow";
-            confirm: "confirm";
             deny: "deny";
+            confirm: "confirm";
         }>>;
     }, z.core.$strict>>;
     providerRouting: z.ZodDefault<z.ZodObject<{
@@ -371,71 +234,15 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
     dreaming: z.ZodDefault<z.ZodObject<{
         mode: z.ZodDefault<z.ZodEnum<{
             off: "off";
-            observe: "observe";
             review: "review";
-            automatic: "automatic";
         }>>;
         timezone: z.ZodOptional<z.ZodString>;
-        phases: z.ZodOptional<z.ZodObject<{
-            light: z.ZodOptional<z.ZodObject<{
-                enabled: z.ZodOptional<z.ZodBoolean>;
-                schedule: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"interval">;
-                    everyHours: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<6>, z.ZodLiteral<8>, z.ZodLiteral<12>, z.ZodLiteral<24>]>;
-                    minute: z.ZodNumber;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"daily">;
-                    time: z.ZodString;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"weekly">;
-                    weekday: z.ZodNumber;
-                    time: z.ZodString;
-                }, z.core.$strict>], "kind">>;
-                lookbackDays: z.ZodOptional<z.ZodNumber>;
-                limit: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
-            deep: z.ZodOptional<z.ZodObject<{
-                enabled: z.ZodOptional<z.ZodBoolean>;
-                schedule: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"interval">;
-                    everyHours: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<6>, z.ZodLiteral<8>, z.ZodLiteral<12>, z.ZodLiteral<24>]>;
-                    minute: z.ZodNumber;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"daily">;
-                    time: z.ZodString;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"weekly">;
-                    weekday: z.ZodNumber;
-                    time: z.ZodString;
-                }, z.core.$strict>], "kind">>;
-                minScore: z.ZodOptional<z.ZodNumber>;
-                minRecallCount: z.ZodOptional<z.ZodNumber>;
-                minUniqueQueries: z.ZodOptional<z.ZodNumber>;
-                limit: z.ZodOptional<z.ZodNumber>;
-                recencyHalfLifeDays: z.ZodOptional<z.ZodNumber>;
-                maxAgeDays: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
-            rem: z.ZodOptional<z.ZodObject<{
-                enabled: z.ZodOptional<z.ZodBoolean>;
-                schedule: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"interval">;
-                    everyHours: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<6>, z.ZodLiteral<8>, z.ZodLiteral<12>, z.ZodLiteral<24>]>;
-                    minute: z.ZodNumber;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"daily">;
-                    time: z.ZodString;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"weekly">;
-                    weekday: z.ZodNumber;
-                    time: z.ZodString;
-                }, z.core.$strict>], "kind">>;
-                lookbackDays: z.ZodOptional<z.ZodNumber>;
-                limit: z.ZodOptional<z.ZodNumber>;
-                minPatternStrength: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strict>>;
+        schedule: z.ZodDefault<z.ZodObject<{
+            time: z.ZodDefault<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 DreamingSchedule = z.infer<typeof DreamingScheduleSchema>;
-export type DreamingSettings = z.infer<typeof DreamingSettingsSchema>;
+export type UserContextDreaming = z.infer<typeof UserContextDreamingSchema>;

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

@@ -10,7 +10,7 @@ function isValidTimeZone(value) {
 		return false;
 	}
 }
-var UserMemoryModeSchema, DEFAULT_CONTEXT_COMPACTION_POLICY, ContextCompactionPolicySchema, UserMemoryConfigSchema, UserUnderstandingConfigSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, DreamingIntervalHoursSchema, DreamingTimeSchema, DreamingScheduleSchema, DreamingEditablePhaseSchema, DreamingSettingsSchema, DreamingPhaseSchema, UserContextDreamingSchema, UserContextConfigSchema;
+var UserMemoryModeSchema, DEFAULT_CONTEXT_COMPACTION_POLICY, ContextCompactionPolicySchema, UserMemoryConfigSchema, UserUnderstandingConfigSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, DreamingTimeSchema, UserContextDreamingSchema, UserContextConfigSchema;
 var init_config = __esmMin((() => {
 	init_response_language();
 	UserMemoryModeSchema = z.enum([
@@ -56,18 +56,11 @@ var init_config = __esmMin((() => {
 		mode: UserMemoryModeSchema.default("off"),
 		sources: z.array(z.enum([
 			"session",
-			"userProfile",
 			"agentProfile",
 			"understanding",
-			"workspace",
-			"connectedSources"
+			"workspace"
 		])).default(["session"]),
 		writePolicy: z.object({
-			userProfile: z.enum([
-				"deny",
-				"confirm",
-				"allow"
-			]).optional(),
 			agentProfile: z.enum([
 				"deny",
 				"confirm",
@@ -135,83 +128,19 @@ var init_config = __esmMin((() => {
 		writeStrategy: "local-first",
 		allowExternalWrites: false
 	});
-	DreamingIntervalHoursSchema = z.union([
-		z.literal(1),
-		z.literal(2),
-		z.literal(3),
-		z.literal(4),
-		z.literal(6),
-		z.literal(8),
-		z.literal(12),
-		z.literal(24)
-	]);
 	DreamingTimeSchema = z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Expected time in HH:mm format");
-	DreamingScheduleSchema = z.discriminatedUnion("kind", [
-		z.object({
-			kind: z.literal("interval"),
-			everyHours: DreamingIntervalHoursSchema,
-			minute: z.number().int().min(0).max(59)
-		}).strict(),
-		z.object({
-			kind: z.literal("daily"),
-			time: DreamingTimeSchema
-		}).strict(),
-		z.object({
-			kind: z.literal("weekly"),
-			weekday: z.number().int().min(0).max(6),
-			time: DreamingTimeSchema
-		}).strict()
-	]);
-	DreamingEditablePhaseSchema = z.object({
-		enabled: z.boolean(),
-		schedule: DreamingScheduleSchema
-	}).strict();
-	DreamingSettingsSchema = z.object({
-		mode: z.enum([
-			"off",
-			"observe",
-			"review",
-			"automatic"
-		]),
-		timezone: z.string().min(1).refine(isValidTimeZone, "Invalid IANA timezone"),
-		phases: z.object({
-			light: DreamingEditablePhaseSchema,
-			deep: DreamingEditablePhaseSchema,
-			rem: DreamingEditablePhaseSchema
-		}).strict()
-	}).strict();
-	DreamingPhaseSchema = z.object({
-		enabled: z.boolean().optional(),
-		schedule: DreamingScheduleSchema.optional()
-	}).strict();
 	UserContextDreamingSchema = z.object({
-		mode: z.enum([
-			"off",
-			"observe",
-			"review",
-			"automatic"
-		]).default("off"),
+		mode: z.enum(["off", "review"]).default("review"),
 		timezone: z.string().min(1).refine(isValidTimeZone, "Invalid IANA timezone").optional(),
-		phases: z.object({
-			light: DreamingPhaseSchema.extend({
-				lookbackDays: z.number().int().positive().optional(),
-				limit: z.number().int().nonnegative().optional()
-			}).strict().optional(),
-			deep: DreamingPhaseSchema.extend({
-				minScore: z.number().min(0).max(1).optional(),
-				minRecallCount: z.number().int().positive().optional(),
-				minUniqueQueries: z.number().int().positive().optional(),
-				limit: z.number().int().nonnegative().optional(),
-				recencyHalfLifeDays: z.number().positive().optional(),
-				maxAgeDays: z.number().positive().optional()
-			}).strict().optional(),
-			rem: DreamingPhaseSchema.extend({
-				lookbackDays: z.number().int().positive().optional(),
-				limit: z.number().int().nonnegative().optional(),
-				minPatternStrength: z.number().min(0).max(1).optional()
-			}).strict().optional()
-		}).strict().optional()
-	}).strict().default({ mode: "off" });
+		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)
+	}).strict().default({
+		mode: "review",
+		schedule: { time: "03:00" },
+		minEvidenceSources: 2,
+		limit: 500
+	});
 	UserContextConfigSchema = z.object({
 		enabled: z.boolean().default(true),
 		preferences: z.object({ responseLanguage: ResponseLanguageSchema.default("auto") }).strict().default({ responseLanguage: "auto" }),
@@ -241,9 +170,14 @@ var init_config = __esmMin((() => {
 			writeStrategy: "local-first",
 			allowExternalWrites: false
 		},
-		dreaming: { mode: "off" }
+		dreaming: {
+			mode: "review",
+			schedule: { time: "03:00" },
+			minEvidenceSources: 2,
+			limit: 500
+		}
 	});
 }));
 //#endregion
 init_config();
-export { ContextCompactionPolicySchema, DEFAULT_CONTEXT_COMPACTION_POLICY, DreamingScheduleSchema, DreamingSettingsSchema, UserContextConfigSchema, UserContextDreamingSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, UserMemoryConfigSchema, UserMemoryModeSchema, UserUnderstandingConfigSchema, init_config };
+export { ContextCompactionPolicySchema, DEFAULT_CONTEXT_COMPACTION_POLICY, UserContextConfigSchema, UserContextDreamingSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, UserMemoryConfigSchema, UserMemoryModeSchema, UserUnderstandingConfigSchema, init_config };

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

@@ -0,0 +1,26 @@
+import type { Config } from '../config/schema.js';
+import { type ContextConsolidationRun } from '../storage/sqlite/index.js';
+export declare const USER_CONTEXT_CONSOLIDATION_TOKEN = "__xopc_user_context_consolidation__";
+export declare const USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID = "system-user-context-consolidation";
+type ConsolidationMetrics = {
+    scanned: number;
+    needsReview: number;
+    stale: number;
+};
+export declare function resolveContextConsolidationConfig(config: Config): {
+    enabled: boolean;
+    timezone: string;
+    time: string;
+    minEvidenceSources: number;
+    limit: number;
+};
+export declare function compileContextConsolidationCron(time: string): string;
+export declare function runContextConsolidation(input: {
+    config: Config;
+    triggerKind: 'schedule' | 'manual';
+    now?: number;
+}): Promise<{
+    run: ContextConsolidationRun;
+    metrics: ConsolidationMetrics;
+}>;
+export {};

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

@@ -0,0 +1,115 @@
+import { finishContextConsolidationRun, recordContextConsolidationDecision, startContextConsolidationRun } from "../storage/sqlite/context-consolidation-repository.js";
+import { listUnderstandingEvidence, listUnderstandings, setUnderstandingStatus } from "../storage/sqlite/user-context-repository.js";
+import "../storage/sqlite/index.js";
+//#region src/user-context/consolidation.ts
+const USER_CONTEXT_CONSOLIDATION_TOKEN = "__xopc_user_context_consolidation__";
+const USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID = "system-user-context-consolidation";
+function distinctEvidenceCount(understandingId, relation) {
+	return new Set(listUnderstandingEvidence(understandingId, relation).map((evidence) => `${evidence.sourceType}:${evidence.sourceInstanceId ?? ""}:${evidence.sourceRef}`)).size;
+}
+function resolveContextConsolidationConfig(config) {
+	const dreaming = config.userContext.dreaming;
+	return {
+		enabled: config.userContext.enabled && dreaming.mode === "review",
+		timezone: dreaming.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC",
+		time: dreaming.schedule.time,
+		minEvidenceSources: dreaming.minEvidenceSources,
+		limit: dreaming.limit
+	};
+}
+function compileContextConsolidationCron(time) {
+	const [hour, minute] = time.split(":").map(Number);
+	return `${minute} ${hour} * * *`;
+}
+async function runContextConsolidation(input) {
+	const resolved = resolveContextConsolidationConfig(input.config);
+	if (input.triggerKind === "schedule" && !resolved.enabled) throw new Error("User context consolidation is off");
+	const now = input.now ?? Date.now();
+	const run = startContextConsolidationRun(input.triggerKind, now);
+	const metrics = {
+		scanned: 0,
+		needsReview: 0,
+		stale: 0
+	};
+	try {
+		const understandings = listUnderstandings(["candidate", "active"]).slice(0, resolved.limit);
+		for (const understanding of understandings) {
+			metrics.scanned += 1;
+			const evidenceCount = distinctEvidenceCount(understanding.id, "supports");
+			const contradictionCount = distinctEvidenceCount(understanding.id, "contradicts");
+			if (understanding.validTo != null && understanding.validTo <= now || understanding.expiresAt != null && understanding.expiresAt <= now) {
+				setUnderstandingStatus(understanding.id, "stale");
+				recordContextConsolidationDecision({
+					runId: run.runId,
+					understandingId: understanding.id,
+					action: "stale",
+					reasonCode: "validity_expired",
+					evidenceCount,
+					now
+				});
+				metrics.stale += 1;
+				continue;
+			}
+			if (contradictionCount > 0) {
+				setUnderstandingStatus(understanding.id, "needs_review");
+				recordContextConsolidationDecision({
+					runId: run.runId,
+					understandingId: understanding.id,
+					action: "needs_review",
+					reasonCode: "contradictory_evidence",
+					evidenceCount: contradictionCount,
+					now
+				});
+				metrics.needsReview += 1;
+				continue;
+			}
+			if (understanding.status === "active" && understanding.reviewAt != null && understanding.reviewAt <= now) {
+				setUnderstandingStatus(understanding.id, "needs_review");
+				recordContextConsolidationDecision({
+					runId: run.runId,
+					understandingId: understanding.id,
+					action: "needs_review",
+					reasonCode: "review_due",
+					evidenceCount,
+					now
+				});
+				metrics.needsReview += 1;
+				continue;
+			}
+			if (understanding.status === "candidate" && evidenceCount >= resolved.minEvidenceSources) {
+				setUnderstandingStatus(understanding.id, "needs_review");
+				recordContextConsolidationDecision({
+					runId: run.runId,
+					understandingId: understanding.id,
+					action: "needs_review",
+					reasonCode: "independent_evidence_threshold",
+					evidenceCount,
+					now
+				});
+				metrics.needsReview += 1;
+			}
+		}
+		return {
+			run: finishContextConsolidationRun({
+				runId: run.runId,
+				ok: true,
+				reason: "completed",
+				metrics,
+				now
+			}) ?? run,
+			metrics
+		};
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		finishContextConsolidationRun({
+			runId: run.runId,
+			ok: false,
+			reason,
+			metrics,
+			now
+		});
+		throw error;
+	}
+}
+//#endregion
+export { USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID, USER_CONTEXT_CONSOLIDATION_TOKEN, compileContextConsolidationCron, resolveContextConsolidationConfig, runContextConsolidation };

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

@@ -0,0 +1,75 @@
+export declare const USER_CONTEXT_PRINCIPAL_ID = "local-owner";
+export type UserProfile = {
+    callName: string;
+    role: string;
+    primaryGoal: string;
+    pronouns: string;
+    timezone: string;
+    locale: string;
+    accessibility: Record<string, unknown>;
+    createdAt: number;
+    updatedAt: number;
+};
+export type UserContextScope = {
+    type: 'global' | 'workspace' | 'project' | 'session';
+    id?: string;
+};
+export type UnderstandingKind = 'preference' | 'boundary' | 'relationship' | 'routine' | 'current_state' | 'long_term_goal' | 'project_context' | 'task_lesson' | 'derived_insight';
+export type UnderstandingStatus = 'candidate' | 'active' | 'needs_review' | 'stale' | 'archived' | 'rejected';
+export type UserUnderstanding = {
+    id: string;
+    kind: UnderstandingKind;
+    canonicalKey: string;
+    status: UnderstandingStatus;
+    scope: UserContextScope;
+    explicitness: 'explicit' | 'observed' | 'inferred';
+    durability: 'ephemeral' | 'durable' | 'recurring';
+    sensitivity: 'normal' | 'personal' | 'secret' | 'regulated';
+    disclosurePolicy: 'silent' | 'referenceable' | 'ask_before_reference';
+    confidence: number;
+    statement: string;
+    payload: Record<string, unknown>;
+    versionId: string;
+    validFrom?: number;
+    validTo?: number;
+    expiresAt?: number;
+    reviewAt?: number;
+    conflictGroupId?: string;
+    supersedesId?: string;
+    createdAt: number;
+    updatedAt: number;
+};
+export type CollaborationRule = {
+    id: string;
+    category: 'communication' | 'execution' | 'boundary' | 'routine' | 'proactive';
+    status: 'active' | 'disabled' | 'archived';
+    priority: number;
+    scope: UserContextScope;
+    conditions: Record<string, unknown>;
+    statement: string;
+    revisionId: string;
+    createdAt: number;
+    updatedAt: number;
+};
+export type PersonalizationItem = {
+    objectType: 'profile' | 'rule' | 'understanding';
+    objectId: string;
+    versionId?: string;
+    decision: 'selected' | 'irrelevant' | 'expired' | 'scope_mismatch' | 'sensitive' | 'needs_consent' | 'budget_exceeded' | 'conflicted' | 'disabled';
+    reason: string;
+    content: string;
+    sourceLabel: string;
+    rank?: number;
+    score?: number;
+    injectedChars: number;
+};
+export type ContextEvidence = {
+    id: string;
+    sourceType: 'conversation' | 'connector' | 'user' | 'runtime';
+    sourceInstanceId?: string;
+    sourceRef: string;
+    redactedExcerpt?: string;
+    trustLevel: 'owner' | 'trusted' | 'untrusted';
+    observedAt: number;
+    createdAt: number;
+};

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

@@ -0,0 +1,4 @@
+//#region src/user-context/domain.ts
+const USER_CONTEXT_PRINCIPAL_ID = "local-owner";
+//#endregion
+export { USER_CONTEXT_PRINCIPAL_ID };