@xopcai/xopc 0.0.247 → 0.0.249

package/dist/src/channels/outbound/persist-store.js

@@ -1,52 +1,25 @@
-import { init_write_file_atomic, writeTextAtomicSync } from "../../infra/write-file-atomic.js";
-import { join } from "path";
-import { existsSync, mkdirSync, readFileSync } from "fs";
+import { DurableQueue } from "../../storage/sqlite/durable-queue.js";
 import { randomUUID } from "node:crypto";
 //#region src/channels/outbound/persist-store.ts
-/**
-* Durable outbound queue (crash recovery): JSON file under agent internal dir.
-*/
-init_write_file_atomic();
 var OutboundPersistStore = class {
-	filePath;
-	pending = [];
-	constructor(agentDir) {
-		mkdirSync(agentDir, { recursive: true });
-		this.filePath = join(agentDir, "outbound-pending.json");
-		this.load();
-	}
-	load() {
-		if (!existsSync(this.filePath)) return;
-		try {
-			const raw = readFileSync(this.filePath, "utf-8");
-			const data = JSON.parse(raw);
-			if (Array.isArray(data)) this.pending = data;
-		} catch {
-			this.pending = [];
-		}
-	}
-	flush() {
-		writeTextAtomicSync(this.filePath, JSON.stringify(this.pending));
+	queue;
+	constructor(scope) {
+		this.queue = new DurableQueue("outbound", scope);
 	}
 	enqueue(message) {
-		const id = randomUUID();
-		this.pending.push({
-			id,
+		const entry = {
+			id: randomUUID(),
 			enqueuedAt: Date.now(),
 			message
-		});
-		this.flush();
-		return id;
+		};
+		this.queue.enqueue(entry.id, entry, entry.enqueuedAt);
+		return entry.id;
 	}
 	ack(id) {
-		const i = this.pending.findIndex((p) => p.id === id);
-		if (i >= 0) {
-			this.pending.splice(i, 1);
-			this.flush();
-		}
+		this.queue.delete(id);
 	}
 	peek() {
-		return this.pending;
+		return this.queue.pending();
 	}
 };
 //#endregion

package/dist/src/channels/outbound-sender.d.ts

@@ -37,7 +37,7 @@ export declare class ChannelOutboundSender {
     private persistStore?;
     constructor(opts: ChannelOutboundSenderOptions);
     setHooks(hooks: OutboundChannelHooks): void;
-    enablePersistence(agentDir: string): void;
+    enablePersistence(agentId: string): void;
     /**
      * Redeliver every queued outbound item (called after channels are started).
      * Best-effort — may duplicate if the prior send succeeded but ack did not

package/dist/src/channels/outbound-sender.js

@@ -18,8 +18,8 @@ var ChannelOutboundSender = class {
 	setHooks(hooks) {
 		this.hooks = hooks;
 	}
-	enablePersistence(agentDir) {
-		this.persistStore = new OutboundPersistStore(agentDir);
+	enablePersistence(agentId) {
+		this.persistStore = new OutboundPersistStore(agentId);
 	}
 	/**
 	* Redeliver every queued outbound item (called after channels are started).

package/dist/src/chat-commands/builtins/understanding.js

@@ -1,5 +1,7 @@
+import { reconcileAssertion } from "../../user-model/repository.js";
+import "../../user-model/index.js";
 import { commandRegistry } from "../registry.js";
-import { createManualUnderstanding } from "../../user-context/manual-understanding.js";
+import { createHash } from "node:crypto";
 //#region src/chat-commands/builtins/understanding.ts
 function parseRememberArgs(args) {
 	const trimmed = args.trim();
@@ -30,20 +32,36 @@ const rememberCommand = {
 			content: "Usage: /remember [--session] <what xopc should know> (max 5000 characters)",
 			success: false
 		};
-		const result = createManualUnderstanding({
-			content,
+		const result = reconcileAssertion({
+			subject: {
+				type: "user",
+				id: "self"
+			},
+			predicate: `remembered.${createHash("sha256").update(content.toLocaleLowerCase()).digest("hex").slice(0, 20)}`,
+			cardinality: "single",
+			value: content,
+			normalizedValue: content.toLocaleLowerCase(),
+			statement: content,
 			kind: "derived_insight",
 			scope: sessionOnly ? {
 				type: "session",
 				id: ctx.sessionKey
 			} : { type: "global" },
+			authority: "user_explicit",
+			confidence: 1,
+			declaredImportance: .8,
+			inferredImportance: .8,
+			consequence: "medium",
+			actionability: .7,
+			volatility: sessionOnly ? "dynamic" : "stable",
 			sensitivity: "normal",
-			durability: sessionOnly ? "ephemeral" : "durable",
-			disclosurePolicy: "referenceable"
+			disclosurePolicy: "referenceable",
+			observedAt: Date.now(),
+			createdBy: "user"
 		});
 		const scopeLabel = sessionOnly ? "this conversation" : "all conversations";
 		return {
-			content: result.created ? `Remembered for ${scopeLabel}. You can review or remove it in About You.` : `This is already remembered for ${scopeLabel}.`,
+			content: result.action === "created" ? `Remembered for ${scopeLabel}. You can review or remove it in User Model.` : `This is already remembered for ${scopeLabel}.`,
 			success: true
 		};
 	}

package/dist/src/cli/commands/doctor/checks/database-schema.js

@@ -52,7 +52,7 @@ async function checkDatabaseSchema(ctx) {
 		id: "database-schema",
 		label: "Database schema",
 		status: "pass",
-		message: `SQLite schema v${status.dbVersion} (current release v145).`,
+		message: `SQLite schema v${status.dbVersion} (current release v150).`,
 		hints: []
 	};
 }

package/dist/src/config/schema.d.ts

@@ -1322,8 +1322,8 @@ export declare const UpdateAutoConfigSchema: z.ZodOptional<z.ZodObject<{
 export declare const UpdateConfigSchema: z.ZodOptional<z.ZodObject<{
     checkOnStart: z.ZodDefault<z.ZodBoolean>;
     channel: z.ZodDefault<z.ZodEnum<{
-        beta: "beta";
         stable: "stable";
+        beta: "beta";
         dev: "dev";
     }>>;
     auto: z.ZodOptional<z.ZodObject<{
@@ -1428,79 +1428,60 @@ export declare const ConfigSchema: 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";
@@ -1519,17 +1500,29 @@ export declare const ConfigSchema: 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>>;
     agents: z.ZodDefault<z.ZodObject<{
@@ -2275,8 +2268,8 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
     update: z.ZodOptional<z.ZodObject<{
         checkOnStart: z.ZodDefault<z.ZodBoolean>;
         channel: z.ZodDefault<z.ZodEnum<{
-            beta: "beta";
             stable: "stable";
+            beta: "beta";
             dev: "dev";
         }>>;
         auto: z.ZodOptional<z.ZodObject<{

package/dist/src/config/schema.js

@@ -2,7 +2,7 @@ import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { AgentModelsOverrideSchema, AgentsConfigSchema as AgentsConfigSchema$1, DEFAULT_AGENT_MODEL_REF, ImageGenerationRouteSchema, ModelRouteSchema } from "../agent-config/schema.js";
 import { init_agent_config } from "../agent-config/index.js";
 import { checkCacheDir, init_cache_dir_policy } from "../browser/cache-dir-policy.js";
-import { UserContextConfigSchema, init_config } from "../user-context/config.js";
+import { DEFAULT_CONTEXT_COMPACTION_POLICY, UserContextConfigSchema, init_config } from "../user-context/config.js";
 import { init_default_model } from "./default-model.js";
 import { init_public_url, validatePublicUrl } from "./public-url.js";
 import { TelegramAccountConfigSchema, TelegramConfigSchema, TelegramGroupConfigSchema, TelegramTopicConfigSchema, init_config_schema } from "../../extensions/telegram/src/config-schema.js";
@@ -804,7 +804,7 @@ activityDetailDefault: z.enum([
 		realtime: z.object({
 			enabled: z.boolean().default(false),
 			defaultEngine: z.enum(["agent", "omni"]).default("agent"),
-			silenceDurationMs: z.number().int().min(300).max(2e3).default(700),
+			silenceDurationMs: z.number().int().min(300).max(2e3).default(1200),
 			idleTimeoutMs: z.number().int().min(1e4).max(3e5).default(6e4),
 			maxDictationMs: z.number().int().min(1e4).max(36e5).default(6e5),
 			maxConversationMs: z.number().int().min(1e4).max(72e5).default(36e5),
@@ -825,7 +825,7 @@ activityDetailDefault: z.enum([
 		}).strict().default({
 			enabled: false,
 			defaultEngine: "agent",
-			silenceDurationMs: 700,
+			silenceDurationMs: 1200,
 			idleTimeoutMs: 6e4,
 			maxDictationMs: 6e5,
 			maxConversationMs: 36e5,
@@ -1007,30 +1007,41 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 		userContext: {
 			enabled: true,
 			preferences: { responseLanguage: "auto" },
-			memory: {
-				mode: "confirmWrite",
-				sources: ["session", "understanding"],
-				writePolicy: { understanding: "confirm" }
-			},
-			understanding: {
+			userModel: {
 				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
+				}
 			},
-			privacy: { sensitiveWritePolicy: "confirm" },
-			providerRouting: {
+			knowledgeMemory: {
+				enabled: true,
+				writePolicy: "confirm",
+				sources: ["session", "workspace"],
 				searchStrategy: "fanout",
 				writeStrategy: "local-first",
 				allowExternalWrites: false
 			},
-			dreaming: {
-				mode: "review",
-				schedule: { time: "03:00" },
-				minEvidenceSources: 2,
-				limit: 500
+			contextPlanning: {
+				enabled: true,
+				maxAssertions: 20,
+				maxKnowledge: 12,
+				maxChars: 6e3,
+				compaction: DEFAULT_CONTEXT_COMPACTION_POLICY
 			}
 		},
 		agents: {

package/dist/src/config/web-patch.d.ts

@@ -26,7 +26,7 @@ export declare function resolveSessionConfigForWeb(config: Config): {
 };
 export declare function resolveUpdateConfigForWeb(config: Config): {
     checkOnStart: boolean;
-    channel: "beta" | "stable" | "dev";
+    channel: "stable" | "beta" | "dev";
     auto: {
         enabled: boolean;
         stableDelayHours: number;

package/dist/src/connectors/composio-managed-client.js

@@ -73,8 +73,12 @@ var ManagedComposioClient = class {
 					}
 				})).item;
 			},
-			search: async () => {
-				return (await this.request({ path: `/connectors/composio/toolkits/${encodeURIComponent(toolkit())}/tools` })).result;
+			search: async ({ query }) => {
+				const results = await Promise.all([...new Set(toolkits)].map(async (slug) => {
+					return (await this.request({ path: `/connectors/composio/toolkits/${encodeURIComponent(slug)}/tools?query=${encodeURIComponent(query)}` })).result;
+				}));
+				if (results.length === 1) return results[0];
+				return { toolSchemas: Object.assign({}, ...results.map((result) => result.toolSchemas ?? {})) };
 			},
 			execute: async (toolSlug, args = {}, options) => {
 				const selected = options?.account ?? connectedAccounts[toolkit()]?.[0];

package/dist/src/connectors/composio-triggers.d.ts

@@ -23,5 +23,5 @@ export declare function normalizeComposioTriggerPayload(payload: unknown, webhoo
     data: Record<string, unknown>;
 };
 export declare function applyComposioConnectionLifecycleEvent(payload: unknown): string | undefined;
-export declare function appendComposioTriggerEvent(config: Config, payload: unknown): Promise<ComposioTriggerArchiveEntry>;
-export declare function listComposioTriggerEvents(config: Config, limit?: number): Promise<ComposioTriggerArchiveEntry[]>;
+export declare function appendComposioTriggerEvent(_config: Config, payload: unknown): Promise<ComposioTriggerArchiveEntry>;
+export declare function listComposioTriggerEvents(_config: Config, limit?: number): Promise<ComposioTriggerArchiveEntry[]>;

package/dist/src/connectors/composio-triggers.js

@@ -1,12 +1,7 @@
 import { listConnectorConnections, upsertConnectorConnection } from "../storage/sqlite/connector-repository.js";
-import { getWorkspacePath } from "../config/workspace-path-helpers.js";
-import { dirname, join } from "node:path";
+import { DurableState } from "../storage/sqlite/durable-state.js";
 import crypto, { createHmac, timingSafeEqual } from "node:crypto";
-import { appendFile, mkdir, readFile } from "node:fs/promises";
 //#region src/connectors/composio-triggers.ts
-function archivePath(config) {
-	return join(getWorkspacePath(config) || "./workspace", "state", "connectors", "composio-triggers.jsonl");
-}
 function readString(value) {
 	return typeof value === "string" && value.trim() ? value.trim() : void 0;
 }
@@ -50,7 +45,7 @@ function applyComposioConnectionLifecycleEvent(payload) {
 	});
 	return connection.id;
 }
-async function appendComposioTriggerEvent(config, payload) {
+async function appendComposioTriggerEvent(_config, payload) {
 	const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
 	const normalized = normalizeComposioTriggerPayload(payload);
 	const entry = {
@@ -60,15 +55,13 @@ async function appendComposioTriggerEvent(config, payload) {
 		trigger: normalized.trigger ?? normalized.type,
 		payload
 	};
-	const path = archivePath(config);
-	await mkdir(dirname(path), { recursive: true });
-	const existing = (await listComposioTriggerEvents(config, 500)).find((candidate) => candidate.id === entry.id);
-	if (existing) return existing;
-	await appendFile(path, `${JSON.stringify(entry)}\n`, "utf8");
-	return entry;
+	return new DurableState("composio-events").update(entry.id, (existing) => ({
+		value: existing ?? entry,
+		result: existing ?? entry
+	}));
 }
-async function listComposioTriggerEvents(config, limit = 50) {
-	return (await readFile(archivePath(config), "utf8").catch(() => "")).split("\n").filter(Boolean).slice(-Math.max(1, Math.min(limit, 500))).map((line) => JSON.parse(line)).reverse();
+async function listComposioTriggerEvents(_config, limit = 50) {
+	return new DurableState("composio-events").values(Math.max(1, Math.min(Math.floor(limit) || 50, 500)), true);
 }
 //#endregion
 export { appendComposioTriggerEvent, applyComposioConnectionLifecycleEvent, listComposioTriggerEvents, normalizeComposioTriggerPayload, verifyComposioWebhook };

package/dist/src/connectors/connected-source-understanding.d.ts

@@ -1,4 +1,3 @@
-import type { MemoryManager } from '../agent/memory/manager.js';
 import type { Config } from '../config/schema.js';
 import type { KnowledgeSourceItem } from '../knowledge/types.js';
 import type { UnderstandingSourceItem } from '../user-context/sources/types.js';
@@ -10,11 +9,10 @@ export declare function deriveConnectedSourceUnderstanding(input: {
     sourceInstanceId: string;
     sourceRunId: string;
     processingPolicy: 'local_only' | 'remote_allowed';
-    memoryManager: MemoryManager;
     analyze?: typeof analyzeUnderstandingSources;
 }): Promise<{
     created: number;
-    focusCount: number;
+    knowledgeCount: number;
     status: 'completed' | 'partial' | 'failed';
     error?: string;
 }>;