@xopcai/xopc 0.0.180 → 0.0.187

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

@@ -48,7 +48,7 @@ export declare const UserMemoryConfigSchema: z.ZodDefault<z.ZodObject<{
     sources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         session: "session";
         workspace: "workspace";
-        curated: "curated";
+        understanding: "understanding";
         userProfile: "userProfile";
         agentProfile: "agentProfile";
         connectedSources: "connectedSources";
@@ -64,7 +64,7 @@ export declare const UserMemoryConfigSchema: z.ZodDefault<z.ZodObject<{
             confirm: "confirm";
             deny: "deny";
         }>>;
-        curated: z.ZodOptional<z.ZodEnum<{
+        understanding: z.ZodOptional<z.ZodEnum<{
             allow: "allow";
             confirm: "confirm";
             deny: "deny";
@@ -131,21 +131,114 @@ 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<{
-    enabled: z.ZodDefault<z.ZodBoolean>;
-    frequency: z.ZodOptional<z.ZodString>;
+    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>;
-            cron: z.ZodOptional<z.ZodString>;
+            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>;
-            dedupeSimilarity: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>>;
         deep: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
-            cron: z.ZodOptional<z.ZodString>;
+            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>;
@@ -155,7 +248,18 @@ export declare const UserContextDreamingSchema: z.ZodDefault<z.ZodObject<{
         }, z.core.$strict>>;
         rem: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
-            cron: z.ZodOptional<z.ZodString>;
+            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>;
@@ -164,6 +268,13 @@ export declare const UserContextDreamingSchema: z.ZodDefault<z.ZodObject<{
 }, z.core.$strict>>;
 export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
+    preferences: z.ZodDefault<z.ZodObject<{
+        responseLanguage: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            "zh-CN": "zh-CN";
+            en: "en";
+        }>>;
+    }, z.core.$strict>>;
     memory: z.ZodDefault<z.ZodObject<{
         mode: z.ZodDefault<z.ZodEnum<{
             off: "off";
@@ -174,7 +285,7 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
         sources: z.ZodDefault<z.ZodArray<z.ZodEnum<{
             session: "session";
             workspace: "workspace";
-            curated: "curated";
+            understanding: "understanding";
             userProfile: "userProfile";
             agentProfile: "agentProfile";
             connectedSources: "connectedSources";
@@ -190,7 +301,7 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
                 confirm: "confirm";
                 deny: "deny";
             }>>;
-            curated: z.ZodOptional<z.ZodEnum<{
+            understanding: z.ZodOptional<z.ZodEnum<{
                 allow: "allow";
                 confirm: "confirm";
                 deny: "deny";
@@ -258,20 +369,45 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
         autoWriteKinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     dreaming: z.ZodDefault<z.ZodObject<{
-        enabled: z.ZodDefault<z.ZodBoolean>;
-        frequency: z.ZodOptional<z.ZodString>;
+        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>;
-                cron: z.ZodOptional<z.ZodString>;
+                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>;
-                dedupeSimilarity: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strict>>;
             deep: z.ZodOptional<z.ZodObject<{
                 enabled: z.ZodOptional<z.ZodBoolean>;
-                cron: z.ZodOptional<z.ZodString>;
+                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>;
@@ -281,7 +417,18 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
             }, z.core.$strict>>;
             rem: z.ZodOptional<z.ZodObject<{
                 enabled: z.ZodOptional<z.ZodBoolean>;
-                cron: z.ZodOptional<z.ZodString>;
+                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>;
@@ -290,3 +437,5 @@ export declare const UserContextConfigSchema: z.ZodDefault<z.ZodObject<{
     }, 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>;

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

@@ -1,8 +1,18 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { ResponseLanguageSchema, init_response_language } from "../i18n/response-language.js";
 import { z } from "zod";
 //#region src/user-context/config.ts
-var UserMemoryModeSchema, DEFAULT_CONTEXT_COMPACTION_POLICY, ContextCompactionPolicySchema, UserMemoryConfigSchema, UserUnderstandingConfigSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, DreamingPhaseSchema, UserContextDreamingSchema, UserContextConfigSchema;
+function isValidTimeZone(value) {
+	try {
+		new Intl.DateTimeFormat("en", { timeZone: value }).format();
+		return true;
+	} catch {
+		return false;
+	}
+}
+var UserMemoryModeSchema, DEFAULT_CONTEXT_COMPACTION_POLICY, ContextCompactionPolicySchema, UserMemoryConfigSchema, UserUnderstandingConfigSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, DreamingIntervalHoursSchema, DreamingTimeSchema, DreamingScheduleSchema, DreamingEditablePhaseSchema, DreamingSettingsSchema, DreamingPhaseSchema, UserContextDreamingSchema, UserContextConfigSchema;
 var init_config = __esmMin((() => {
+	init_response_language();
 	UserMemoryModeSchema = z.enum([
 		"off",
 		"readOnly",
@@ -48,7 +58,7 @@ var init_config = __esmMin((() => {
 			"session",
 			"userProfile",
 			"agentProfile",
-			"curated",
+			"understanding",
 			"workspace",
 			"connectedSources"
 		])).default(["session"]),
@@ -63,7 +73,7 @@ var init_config = __esmMin((() => {
 				"confirm",
 				"allow"
 			]).optional(),
-			curated: z.enum([
+			understanding: z.enum([
 				"deny",
 				"confirm",
 				"allow"
@@ -125,19 +135,67 @@ 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(),
-		cron: z.string().min(1).optional()
+		schedule: DreamingScheduleSchema.optional()
 	}).strict();
 	UserContextDreamingSchema = z.object({
-		enabled: z.boolean().default(false),
-		frequency: z.string().min(1).optional(),
-		timezone: z.string().optional(),
+		mode: z.enum([
+			"off",
+			"observe",
+			"review",
+			"automatic"
+		]).default("off"),
+		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(),
-				dedupeSimilarity: z.number().min(0).max(1).optional()
+				limit: z.number().int().nonnegative().optional()
 			}).strict().optional(),
 			deep: DreamingPhaseSchema.extend({
 				minScore: z.number().min(0).max(1).optional(),
@@ -153,9 +211,10 @@ var init_config = __esmMin((() => {
 				minPatternStrength: z.number().min(0).max(1).optional()
 			}).strict().optional()
 		}).strict().optional()
-	}).strict().default({ enabled: false });
+	}).strict().default({ mode: "off" });
 	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,
@@ -163,10 +222,11 @@ var init_config = __esmMin((() => {
 		dreaming: UserContextDreamingSchema
 	}).strict().default({
 		enabled: true,
+		preferences: { responseLanguage: "auto" },
 		memory: {
 			mode: "confirmWrite",
-			sources: ["session", "curated"],
-			writePolicy: { curated: "confirm" }
+			sources: ["session", "understanding"],
+			writePolicy: { understanding: "confirm" }
 		},
 		understanding: {
 			enabled: true,
@@ -181,9 +241,9 @@ var init_config = __esmMin((() => {
 			writeStrategy: "local-first",
 			allowExternalWrites: false
 		},
-		dreaming: { enabled: false }
+		dreaming: { mode: "off" }
 	});
 }));
 //#endregion
 init_config();
-export { ContextCompactionPolicySchema, DEFAULT_CONTEXT_COMPACTION_POLICY, UserContextConfigSchema, UserContextDreamingSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, UserMemoryConfigSchema, UserMemoryModeSchema, UserUnderstandingConfigSchema, init_config };
+export { ContextCompactionPolicySchema, DEFAULT_CONTEXT_COMPACTION_POLICY, DreamingScheduleSchema, DreamingSettingsSchema, UserContextConfigSchema, UserContextDreamingSchema, UserContextPrivacySchema, UserContextProviderRoutingSchema, UserMemoryConfigSchema, UserMemoryModeSchema, UserUnderstandingConfigSchema, init_config };

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

@@ -3,15 +3,16 @@ import { type RelationshipSettings } from '../storage/sqlite/index.js';
 export interface ContextSnapshot {
     id: string;
     traceId: string;
-    sessionKey: string;
+    ownerKind: 'session';
+    ownerId: string;
+    sessionKey?: string;
     query: string;
     selectedItems: UserContextPlan['items'];
     rejectedItems: UserContextPlan['rejected'];
     consentRequests: UserContextPlan['consentRequests'];
     relationshipPolicy: RelationshipSettings;
     estimatedTokens: number;
-    outcomeId?: string;
-    runId?: string;
+    allocation?: UserContextPlan['allocation'];
     createdAt: number;
 }
 export declare class ContextCompiler {
@@ -23,9 +24,4 @@ export declare class ContextCompiler {
     }): ContextSnapshot;
     get(id: string): ContextSnapshot | undefined;
     latestForSession(sessionKey: string, since?: number): ContextSnapshot | undefined;
-    linkToRun(input: {
-        snapshotId: string;
-        outcomeId?: string;
-        runId: string;
-    }): ContextSnapshot | undefined;
 }

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

@@ -7,15 +7,16 @@ function fromRow(row) {
 	return {
 		id: row.snapshot_id,
 		traceId: row.trace_id,
-		sessionKey: row.session_key,
+		ownerKind: row.owner_kind,
+		ownerId: row.owner_id,
+		...row.session_key ? { sessionKey: row.session_key } : {},
 		query: row.query,
 		selectedItems: JSON.parse(row.selected_items_json),
 		rejectedItems: JSON.parse(row.rejected_items_json),
 		consentRequests: JSON.parse(row.consent_requests_json),
 		relationshipPolicy: JSON.parse(row.relationship_policy_json),
 		estimatedTokens: row.estimated_tokens,
-		...row.outcome_id ? { outcomeId: row.outcome_id } : {},
-		...row.run_id ? { runId: row.run_id } : {},
+		...row.allocation_json ? { allocation: JSON.parse(row.allocation_json) } : {},
 		createdAt: row.created_at
 	};
 }
@@ -25,10 +26,10 @@ var ContextCompiler = class {
 		const id = randomUUID();
 		runSqliteWriteTransaction((db) => {
 			db.prepare(`INSERT INTO context_snapshots (
-          snapshot_id, trace_id, session_key, query, selected_items_json,
+          snapshot_id, trace_id, owner_kind, owner_id, session_key, query, selected_items_json,
           rejected_items_json, consent_requests_json, relationship_policy_json,
-          estimated_tokens, created_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.plan.traceId, input.sessionKey, input.query.trim(), JSON.stringify(input.plan.items), JSON.stringify(input.plan.rejected), JSON.stringify(input.plan.consentRequests), JSON.stringify(getRelationshipSettings()), input.plan.estimatedTokens, now);
+          estimated_tokens, allocation_json, created_at
+        ) VALUES (?, ?, 'session', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.plan.traceId, input.sessionKey, input.sessionKey, input.query.trim(), JSON.stringify(input.plan.items), JSON.stringify(input.plan.rejected), JSON.stringify(input.plan.consentRequests), JSON.stringify(getRelationshipSettings()), input.plan.estimatedTokens, input.plan.allocation ? JSON.stringify(input.plan.allocation) : null, now);
 		});
 		return this.get(id);
 	}
@@ -42,10 +43,6 @@ var ContextCompiler = class {
        ORDER BY created_at DESC LIMIT 1`).get(sessionKey, since);
 		return row ? fromRow(row) : void 0;
 	}
-	linkToRun(input) {
-		getSqliteDatabase().prepare(`UPDATE context_snapshots SET outcome_id = ?, run_id = ? WHERE snapshot_id = ?`).run(input.outcomeId ?? null, input.runId, input.snapshotId);
-		return this.get(input.snapshotId);
-	}
 };
 //#endregion
 export { ContextCompiler };

package/dist/src/user-context/interaction-state.js

@@ -1,6 +1,7 @@
 //#region src/user-context/interaction-state.ts
 function inferInteractionState(message) {
 	const text = message.trim().toLocaleLowerCase();
+	const emotion = text.match(/(焦虑|难过|委屈|生气|疲惫|累|害怕|孤独|anxious|sad|angry|exhausted|afraid|lonely)/)?.[1];
 	if (/你.{0,6}(没|不).{0,6}(理解|懂)|别.{0,4}(建议|说教)|太(啰嗦|冷淡)|you (do not|don't) understand|stop giving (me )?advice|too verbose|too cold/.test(text)) return {
 		supportNeed: "listen",
 		confidence: .95,
@@ -32,13 +33,13 @@ function inferInteractionState(message) {
 		source: "explicit",
 		repairStatus: "none"
 	};
-	if (/帮我(做|改|创建|实现|处理|发送)|请(完成|执行)|\b(build|fix|create|implement|send|run)\b/.test(text)) return {
+	if (/帮我.{0,8}(做|改|创建|实现|处理|发送|修好)|请(完成|执行)|\b(build|fix|create|implement|send|run)\b/.test(text)) return {
 		supportNeed: "act",
+		...emotion ? { emotionHypothesis: emotion } : {},
 		confidence: .85,
 		source: "explicit",
 		repairStatus: "none"
 	};
-	const emotion = text.match(/(焦虑|难过|委屈|生气|疲惫|累|害怕|孤独|anxious|sad|angry|exhausted|afraid|lonely)/)?.[1];
 	if (emotion) return {
 		supportNeed: "listen",
 		emotionHypothesis: emotion,
@@ -58,10 +59,13 @@ function buildInteractionStatePrompt(signal) {
 		listen: "Prioritize listening and acknowledgment. Do not rush into advice or an action list.",
 		clarify: "Help the user organize the situation with one focused question at a time.",
 		advise: "Offer a clear recommendation with concise reasoning and practical options.",
-		act: "Prioritize execution, state the intended outcome, and verify the result.",
+		act: "Prioritize execution, state the intended task, and verify the result. Care must support progress, not replace it.",
 		unknown: "Do not assume the support needed. If it matters, ask one concise question."
 	}[signal.supportNeed]];
-	if (signal.emotionHypothesis) lines.push(`Possible current emotion: ${signal.emotionHypothesis} (confidence ${signal.confidence.toFixed(2)}). Treat this only as a hypothesis.`);
+	if (signal.emotionHypothesis) {
+		lines.push(`Possible current emotion: ${signal.emotionHypothesis} (confidence ${signal.confidence.toFixed(2)}). Treat this only as a hypothesis.`);
+		if (signal.supportNeed === "act") lines.push("Acknowledge the pressure in one natural sentence, then continue doing the work without making the user manage your feelings.");
+	}
 	if (signal.repairStatus === "needed") lines.push("Relationship repair is needed: briefly acknowledge the specific mismatch, do not defend yourself, adjust immediately, and ask at most one concise question.");
 	return lines.join("\n\n");
 }

package/dist/src/user-context/manual-understanding.d.ts

@@ -0,0 +1,19 @@
+import type { MemoryKind, MemoryRecord } from '../agent/memory/types.js';
+export type ManualUnderstandingScope = {
+    type: 'global';
+} | {
+    type: 'session';
+    sessionKey: string;
+};
+export declare function createManualUnderstanding(input: {
+    agentId: string;
+    content: string;
+    kind: MemoryKind;
+    scope: ManualUnderstandingScope;
+    sensitivity: NonNullable<MemoryRecord['sensitivity']>;
+    durability: MemoryRecord['durability'];
+    disclosurePolicy: MemoryRecord['disclosurePolicy'];
+}): {
+    record: MemoryRecord;
+    created: boolean;
+};

package/dist/src/user-context/manual-understanding.js

@@ -0,0 +1,69 @@
+import { listMemoryRecords, upsertMemoryRecord } from "../storage/sqlite/memory-records-repository.js";
+import "../storage/sqlite/index.js";
+import { nextMemoryReviewAt } from "../agent/memory/lifecycle.js";
+import { isUserContextRecord } from "./projection.js";
+//#region src/user-context/manual-understanding.ts
+const STATUSES = [
+	"candidate",
+	"active",
+	"needs_review",
+	"stale",
+	"archived",
+	"rejected"
+];
+function sameScope(record, scope) {
+	if (scope.type === "session") return record.scope.sessionKey === scope.sessionKey;
+	return !record.scope.sessionKey && !record.scope.projectId && !record.scope.workspaceId;
+}
+function findDuplicate(content, scope) {
+	const normalized = content.toLocaleLowerCase();
+	for (const status of STATUSES) {
+		let offset = 0;
+		while (true) {
+			const page = listMemoryRecords({
+				status,
+				limit: 500,
+				offset
+			});
+			const duplicate = page.find((record) => isUserContextRecord(record) && sameScope(record, scope) && record.content.trim().toLocaleLowerCase() === normalized);
+			if (duplicate) return duplicate;
+			if (page.length < 500) break;
+			offset += page.length;
+		}
+	}
+}
+function createManualUnderstanding(input) {
+	const duplicate = findDuplicate(input.content, input.scope);
+	if (duplicate) return {
+		record: duplicate,
+		created: false
+	};
+	return {
+		record: upsertMemoryRecord({
+			providerId: "local",
+			kind: input.kind,
+			sourceAgentId: input.agentId,
+			...input.scope.type === "session" ? { sessionKey: input.scope.sessionKey } : {},
+			content: input.content,
+			source: {
+				provider: "local",
+				path: "you://manual"
+			},
+			confidence: 1,
+			tags: ["user-understanding", "explicit-user-memory"],
+			status: "active",
+			sensitivity: input.sensitivity,
+			explicitness: "explicit",
+			durability: input.durability,
+			importance: .8,
+			disclosurePolicy: input.disclosurePolicy,
+			reviewAfter: nextMemoryReviewAt({
+				durability: input.durability,
+				explicitness: "explicit"
+			})
+		}),
+		created: true
+	};
+}
+//#endregion
+export { createManualUnderstanding };

package/dist/src/user-context/memory-episode-evaluator.d.ts

@@ -0,0 +1,32 @@
+export interface MemoryEpisode {
+    id: string;
+    expectedRecall: string[];
+    forbiddenRecall: string[];
+    expectedLifecycle: string[];
+    expectedDreaming: string[];
+}
+export interface MemoryEpisodeObservation {
+    recalledRecordIds: string[];
+    lifecycleActions: string[];
+    dreamingActions: string[];
+    scopeViolations: number;
+    sensitivityViolations: number;
+}
+export interface MemoryEpisodeResult {
+    id: string;
+    recall: number;
+    forbiddenRecall: string[];
+    missingLifecycle: string[];
+    missingDreaming: string[];
+    safe: boolean;
+    passed: boolean;
+}
+export declare function evaluateMemoryEpisode(episode: MemoryEpisode, observation: MemoryEpisodeObservation): MemoryEpisodeResult;
+export declare function evaluateMemoryEpisodeSuite(cases: Array<{
+    episode: MemoryEpisode;
+    observation: MemoryEpisodeObservation;
+}>): {
+    releaseReady: boolean;
+    averageRecall: number;
+    results: MemoryEpisodeResult[];
+};