@xopcai/xopc 0.0.189 → 0.0.190

package/dist/src/config/schema.js

@@ -64,7 +64,7 @@ function parseModelRef(ref) {
 		model: trimmed.slice(idx + 1).trim()
 	};
 }
-var AgentModelRefSchema, AgentImageGenerationModelSchema, AgentTypedModelRoleSchema, AgentTypedModelRolesSchema, AgentModelsSchema, AgentsConfigSchema, BrowserCloudConfigSchema, BrowserExtensionConfigSchema, BrowserCloakConfigSchema, BrowserConfigSchema, BindingMatchSchema, BindingRuleSchema, BindingsConfigSchema, SessionDmScopeSchema, SessionStorageConfigSchema, SessionResetModeSchema, SessionResetConfigSchema, SessionResetByTypeSchema, SessionScopeSchema, SessionConfigSchema, ChannelsConfigSchema, SearchProviderEntrySchema, WebSearchConfigSchema, WebsiteBlocklistSchema, WebToolsConfigSchema, ToolsConfigSchema, GatewayAuthRateLimitSchema, GatewaySecuritySchema, GatewayTrustedProxySchema, GatewayAuthSchema, GatewayTailscaleConsentSchema, GatewayTailscaleSchema, GatewayRemoteSchema, GatewayTlsSchema, GatewayModeSchema, HeartbeatConfigSchema, GatewayChannelConnectDeferModeSchema, TunnelConsentSchema, TunnelConfigSchema, WorkspaceImportConfigSchema, WorkspaceConfigSchema, GatewayBindModeSchema, GatewayWebchatConfigSchema, GatewayConfigSchema, ModelsDevConfigSchema, ModelCatalogConfigSchema, SttProviderConfigCatchallSchema, STTProviderConfigSchema, STTFallbackConfigSchema, MediaUnderstandingCapabilitiesSchema, MediaUnderstandingModelSchema, STTConfigSchema, TtsProviderConfigCatchallSchema, TTSProviderConfigSchema, TTSFallbackConfigSchema, TTSModelOverridesConfigSchema, TTSEdgeConfigSchema, TTSSummarizationConfigSchema, TTSConfigSchema, VoiceRefinementConfigSchema, VoiceConfigSchema, MessagesConfigSchema, ToolsMediaAudioConfigSchema, ToolsMediaConfigSchema, ProviderAzureConfigSchema, ProviderRequestOverridesSchema, ProviderAuthConfigSchema, ProvidersConfigSchema, ExtensionSecurityConfigSchema, ExtensionSlotsConfigSchema, ExtensionsConfigSchema, UpdateAutoConfigSchema, UpdateConfigSchema, CommandsConfigSchema, TuiConfigSchema, McpHttpUrlSchema, ConnectorSecretReferenceSchema, McpConfigScalarSchema, McpServerSchema, McpConfigSchema, CodeIntelligenceConfigSchema, ConnectorsConfigSchema, ExperimentalConfigSchema, ConfigSchema;
+var AgentModelRefSchema, AgentImageGenerationModelSchema, AgentTypedModelRoleSchema, AgentTypedModelRolesSchema, AgentModelsSchema, AgentsConfigSchema, BrowserCloudConfigSchema, BrowserExtensionConfigSchema, BrowserCloakConfigSchema, BrowserConfigSchema, BindingMatchSchema, BindingRuleSchema, BindingsConfigSchema, SessionDmScopeSchema, SessionStorageConfigSchema, SessionResetModeSchema, SessionResetConfigSchema, SessionResetByTypeSchema, SessionScopeSchema, SessionConfigSchema, ChannelsConfigSchema, SearchProviderEntrySchema, WebSearchConfigSchema, WebsiteBlocklistSchema, WebToolsConfigSchema, ToolsConfigSchema, GatewayAuthRateLimitSchema, GatewaySecuritySchema, GatewayTrustedProxySchema, GatewayAuthSchema, GatewayTailscaleConsentSchema, GatewayTailscaleSchema, GatewayRemoteSchema, GatewayTlsSchema, GatewayModeSchema, HeartbeatConfigSchema, GatewayChannelConnectDeferModeSchema, TunnelConsentSchema, TunnelConfigSchema, WorkspaceImportConfigSchema, WorkspaceConfigSchema, GatewayBindModeSchema, GatewayWebchatConfigSchema, GatewayConfigSchema, ModelsDevConfigSchema, ModelCatalogConfigSchema, SttProviderConfigCatchallSchema, STTProviderConfigSchema, STTFallbackConfigSchema, MediaUnderstandingCapabilitiesSchema, MediaUnderstandingModelSchema, STTConfigSchema, TtsProviderConfigCatchallSchema, TTSProviderConfigSchema, TTSFallbackConfigSchema, TTSModelOverridesConfigSchema, TTSEdgeConfigSchema, TTSSummarizationConfigSchema, TTSConfigSchema, VoiceRefinementConfigSchema, VoiceConfigSchema, MessagesConfigSchema, ToolsMediaAudioConfigSchema, ToolsMediaConfigSchema, ProviderAzureConfigSchema, ProviderRequestOverridesSchema, ProviderAuthConfigSchema, ProvidersConfigSchema, ExtensionSecurityConfigSchema, ExtensionSlotsConfigSchema, ExtensionsConfigSchema, UpdateAutoConfigSchema, UpdateConfigSchema, CommandsConfigSchema, TuiConfigSchema, McpHttpUrlSchema, ConnectorSecretReferenceSchema, McpConfigScalarSchema, McpServerSchema, McpConfigSchema, ConnectorsConfigSchema, ExperimentalConfigSchema, ConfigSchema;
 var init_schema = __esmMin((() => {
 	init_schema$1();
 	init_preset_chain();
@@ -902,30 +902,6 @@ defaultAgent: z.string().min(1).optional() }).strict().default({});
 		servers: z.record(z.string(), McpServerSchema).optional(),
 		sessionIdleTtlMs: z.number().finite().min(0).optional()
 	}).strict().optional();
-	CodeIntelligenceConfigSchema = z.object({
-		enabled: z.boolean().default(true),
-		agentIds: z.array(z.string().min(1)).default(["coder"]),
-		indexMode: z.enum([
-			"fast",
-			"moderate",
-			"full"
-		]).default("moderate"),
-		autoIndex: z.boolean().default(true),
-		autoRefresh: z.boolean().default(true),
-		refreshDebounceMs: z.number().int().min(100).max(3e4).default(600),
-		queryTimeoutMs: z.number().int().min(1e3).max(12e4).default(2e4),
-		indexTimeoutMs: z.number().int().min(1e4).max(30 * 6e4).default(5 * 6e4),
-		binaryPath: z.string().min(1).optional()
-	}).strict().default({
-		enabled: true,
-		agentIds: ["coder"],
-		indexMode: "moderate",
-		autoIndex: true,
-		autoRefresh: true,
-		refreshDebounceMs: 600,
-		queryTimeoutMs: 2e4,
-		indexTimeoutMs: 5 * 6e4
-	});
 	ConnectorsConfigSchema = z.object({ instances: z.record(z.string(), z.record(z.string(), z.unknown())).optional() }).strict().optional();
 	ExperimentalConfigSchema = z.object({ 
 	/** First-run activation that analyzes one explicitly selected local folder. */
@@ -942,7 +918,6 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 		workspace: WorkspaceConfigSchema,
 		tools: ToolsConfigSchema,
 		mcp: McpConfigSchema,
-		codeIntelligence: CodeIntelligenceConfigSchema,
 		connectors: ConnectorsConfigSchema,
 		experimental: ExperimentalConfigSchema,
 		extensions: ExtensionsConfigSchema.default({}),
@@ -957,7 +932,7 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 		update: UpdateConfigSchema,
 		commands: CommandsConfigSchema,
 		tui: TuiConfigSchema
-	}).default({
+	}).strict().default({
 		userContext: {
 			enabled: true,
 			preferences: { responseLanguage: "auto" },
@@ -979,7 +954,12 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 				writeStrategy: "local-first",
 				allowExternalWrites: false
 			},
-			dreaming: { mode: "off" }
+			dreaming: {
+				mode: "review",
+				schedule: { time: "03:00" },
+				minEvidenceSources: 2,
+				limit: 500
+			}
 		},
 		agents: {
 			default: "main",
@@ -1052,16 +1032,6 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 			maxResults: 5,
 			providers: []
 		} } },
-		codeIntelligence: {
-			enabled: true,
-			agentIds: ["coder"],
-			indexMode: "moderate",
-			autoIndex: true,
-			autoRefresh: true,
-			refreshDebounceMs: 600,
-			queryTimeoutMs: 2e4,
-			indexTimeoutMs: 5 * 6e4
-		},
 		experimental: { workDiscoveryOnboarding: true },
 		extensions: {
 			allow: [],
@@ -1085,4 +1055,4 @@ workDiscoveryOnboarding: z.boolean().default(true) }).strict().default({ workDis
 }));
 //#endregion
 init_schema();
-export { AgentImageGenerationModelSchema, AgentModelRefSchema, AgentModelsSchema, AgentTypedModelRoleSchema, AgentsConfigSchema, BindingMatchSchema, BindingRuleSchema, BindingsConfigSchema, BrowserConfigSchema, ChannelsConfigSchema, CodeIntelligenceConfigSchema, CommandsConfigSchema, ConfigSchema, ConnectorsConfigSchema, ExperimentalConfigSchema, ExtensionSecurityConfigSchema, ExtensionSlotsConfigSchema, ExtensionsConfigSchema, GatewayAuthRateLimitSchema, GatewayAuthSchema, GatewayBindModeSchema, GatewayChannelConnectDeferModeSchema, GatewayConfigSchema, GatewayModeSchema, GatewayRemoteSchema, GatewaySecuritySchema, GatewayTailscaleConsentSchema, GatewayTailscaleSchema, GatewayTlsSchema, GatewayTrustedProxySchema, GatewayWebchatConfigSchema, HeartbeatConfigSchema, McpConfigSchema, McpServerSchema, MediaUnderstandingCapabilitiesSchema, MediaUnderstandingModelSchema, MessagesConfigSchema, ModelCatalogConfigSchema, ModelsDevConfigSchema, ProviderAuthConfigSchema, ProviderAzureConfigSchema, ProviderRequestOverridesSchema, ProvidersConfigSchema, STTConfigSchema, STTFallbackConfigSchema, STTProviderConfigSchema, SearchProviderEntrySchema, SessionConfigSchema, SessionDmScopeSchema, SessionResetByTypeSchema, SessionResetConfigSchema, SessionResetModeSchema, SessionScopeSchema, SessionStorageConfigSchema, TTSConfigSchema, TTSEdgeConfigSchema, TTSFallbackConfigSchema, TTSModelOverridesConfigSchema, TTSProviderConfigSchema, TTSSummarizationConfigSchema, TelegramAccountConfigSchema, TelegramConfigSchema, TelegramGroupConfigSchema, TelegramTopicConfigSchema, ToolsConfigSchema, ToolsMediaAudioConfigSchema, ToolsMediaConfigSchema, TuiConfigSchema, TunnelConfigSchema, TunnelConsentSchema, UpdateAutoConfigSchema, UpdateConfigSchema, VoiceConfigSchema, VoiceRefinementConfigSchema, WebSearchConfigSchema, WebToolsConfigSchema, WebsiteBlocklistSchema, WeixinAccountConfigSchema, WeixinConfigSchema, WorkspaceConfigSchema, WorkspaceImportConfigSchema, getAgentDefaultImageGenerationModelConfig, getAgentDefaultImageModelConfig, getAgentDefaultModelRef, init_schema, parseModelRef };
+export { AgentImageGenerationModelSchema, AgentModelRefSchema, AgentModelsSchema, AgentTypedModelRoleSchema, AgentsConfigSchema, BindingMatchSchema, BindingRuleSchema, BindingsConfigSchema, BrowserConfigSchema, ChannelsConfigSchema, CommandsConfigSchema, ConfigSchema, ConnectorsConfigSchema, ExperimentalConfigSchema, ExtensionSecurityConfigSchema, ExtensionSlotsConfigSchema, ExtensionsConfigSchema, GatewayAuthRateLimitSchema, GatewayAuthSchema, GatewayBindModeSchema, GatewayChannelConnectDeferModeSchema, GatewayConfigSchema, GatewayModeSchema, GatewayRemoteSchema, GatewaySecuritySchema, GatewayTailscaleConsentSchema, GatewayTailscaleSchema, GatewayTlsSchema, GatewayTrustedProxySchema, GatewayWebchatConfigSchema, HeartbeatConfigSchema, McpConfigSchema, McpServerSchema, MediaUnderstandingCapabilitiesSchema, MediaUnderstandingModelSchema, MessagesConfigSchema, ModelCatalogConfigSchema, ModelsDevConfigSchema, ProviderAuthConfigSchema, ProviderAzureConfigSchema, ProviderRequestOverridesSchema, ProvidersConfigSchema, STTConfigSchema, STTFallbackConfigSchema, STTProviderConfigSchema, SearchProviderEntrySchema, SessionConfigSchema, SessionDmScopeSchema, SessionResetByTypeSchema, SessionResetConfigSchema, SessionResetModeSchema, SessionScopeSchema, SessionStorageConfigSchema, TTSConfigSchema, TTSEdgeConfigSchema, TTSFallbackConfigSchema, TTSModelOverridesConfigSchema, TTSProviderConfigSchema, TTSSummarizationConfigSchema, TelegramAccountConfigSchema, TelegramConfigSchema, TelegramGroupConfigSchema, TelegramTopicConfigSchema, ToolsConfigSchema, ToolsMediaAudioConfigSchema, ToolsMediaConfigSchema, TuiConfigSchema, TunnelConfigSchema, TunnelConsentSchema, UpdateAutoConfigSchema, UpdateConfigSchema, VoiceConfigSchema, VoiceRefinementConfigSchema, WebSearchConfigSchema, WebToolsConfigSchema, WebsiteBlocklistSchema, WeixinAccountConfigSchema, WeixinConfigSchema, WorkspaceConfigSchema, WorkspaceImportConfigSchema, getAgentDefaultImageGenerationModelConfig, getAgentDefaultImageModelConfig, getAgentDefaultModelRef, init_schema, parseModelRef };

package/dist/src/connectors/learning-coordinator.js

@@ -10,6 +10,7 @@ import { connectorIdentityKey, normalizeConnectorIdentity } from "./connector-id
 import { ComposioSessionsAdapter } from "./composio-sessions.js";
 import { buildConnectorLearningArguments, getConnectorLearningPlan } from "./learning-recipes.js";
 import { getConnectorDefinition } from "./catalog.js";
+import { createUnderstandingSourceRun, listUnderstandingSourceRuns, updateUnderstandingSourceGrantCheckpoint, updateUnderstandingSourceRun, upsertUnderstandingSourceGrant, upsertUserFocus } from "../user-context/sources/repository.js";
 import { ConnectedUnderstandingPipeline } from "../knowledge/connected-understanding-pipeline.js";
 import "../knowledge/index.js";
 import { ingestComposioConnectedSource } from "./connected-source-ingestion.js";
@@ -22,8 +23,41 @@ function learningFailureCode(error) {
 	const message = error instanceof Error ? error.message : String(error);
 	return message.includes("ToolRouterV2_InvalidConnectedAccountIds") || message.includes("Could not find connected account(s)") || message.includes("missing its provider identity") ? CONNECTED_ACCOUNT_UNAVAILABLE : CONNECTED_SOURCE_SYNC_FAILED;
 }
+function connectorSourceCategory(toolkit) {
+	if (toolkit === "gmail") return "mail";
+	if (toolkit === "googlecalendar") return "calendar";
+	if (toolkit === "github" || toolkit === "linear") return "code_activity";
+	if (toolkit === "slack") return "messages";
+	return "files";
+}
+function ensureUnderstandingSourceRun(job, toolkit, displayName) {
+	const grant = upsertUnderstandingSourceGrant({
+		sourceKey: `connector-account:${job.accountId}`,
+		adapterId: `connector:${job.connectorId}`,
+		category: connectorSourceCategory(toolkit),
+		platform: "all",
+		displayName,
+		accessMode: "continuous",
+		retentionPolicy: "bounded_raw",
+		processingPolicy: "remote_allowed",
+		config: {
+			connectorId: job.connectorId,
+			accountId: job.accountId,
+			readOnly: true
+		}
+	});
+	return listUnderstandingSourceRuns(grant.id, 100).find((run) => run.metadata.connectorLearningJobId === job.id) ?? createUnderstandingSourceRun({
+		grantId: grant.id,
+		kind: job.mode,
+		status: "queued",
+		metadata: {
+			connectorLearningJobId: job.id,
+			connectorId: job.connectorId
+		}
+	});
+}
 function learningEnabled(config) {
-	return config.userContext.enabled && config.userContext.understanding.enabled && config.userContext.memory.mode !== "off" && config.userContext.memory.sources.includes("connectedSources");
+	return config.userContext.enabled && config.userContext.understanding.enabled;
 }
 function startConnectorLearningCoordinator(options) {
 	const intervalMs = Math.max(2e3, Math.min(options.intervalMs ?? 1e4, 6e4));
@@ -60,6 +94,7 @@ function startConnectorLearningCoordinator(options) {
 			idempotencyKey: request.idempotencyKey ?? (mode === "bootstrap" ? `bootstrap:${connection.accountId}:v1` : `incremental:${connection.accountId}:${request.reason ?? "manual"}:${bucket}`),
 			nextRunAt: request.nextRunAt
 		});
+		ensureUnderstandingSourceRun(job, definition.runtime.toolkit, definition.displayName);
 		publish(job);
 		queueMicrotask(() => void runNow());
 		return job;
@@ -77,6 +112,8 @@ function startConnectorLearningCoordinator(options) {
 		if (definition?.runtime.type !== "composio" || definition.runtime.role !== "toolkit") throw new Error(`Connector learning is unavailable for ${job.connectorId}.`);
 		const plan = getConnectorLearningPlan(definition.runtime.toolkit);
 		if (!plan) throw new Error(`Connector learning has no plan for ${definition.runtime.toolkit}.`);
+		const sourceRun = ensureUnderstandingSourceRun(job, plan.toolkit, definition.displayName);
+		updateUnderstandingSourceRun(sourceRun.id, { status: "running" });
 		let connection = listConnectorConnections().find((candidate) => candidate.id === job.connectionId);
 		if (!connection) throw new Error("Connector account no longer exists.");
 		const installation = getConnectorInstallation(`${job.connectorId}-local-owner`);
@@ -153,13 +190,42 @@ function startConnectorLearningCoordinator(options) {
 		}));
 		publish(updateConnectorLearningJob(job.id, { phase: "deriving" }));
 		const understanding = await new ConnectedUnderstandingPipeline(options.getMemoryManager()).process(job.sourceInstanceId, job.connectorId, job.agentId);
-		publish(updateConnectorLearningJob(job.id, {
+		for (const record of understanding.createdRecords.filter((item) => item.kind === "project_context")) upsertUserFocus({
+			canonicalKey: `connector-focus:${job.accountId}:${record.id}`,
+			title: record.content.slice(0, 120),
+			summary: record.content,
+			horizon: "ongoing",
+			status: "candidate",
+			confidence: .72,
+			evidenceRefs: [`connector-account:${job.accountId}`],
+			sourceRunId: sourceRun.id
+		});
+		const completed = updateConnectorLearningJob(job.id, {
 			status: "completed",
 			phase: "completed",
 			candidatesCreated: understanding.created,
 			nextRunAt: null,
 			finished: true
-		}));
+		});
+		updateUnderstandingSourceRun(sourceRun.id, {
+			status: "completed",
+			itemsSeen,
+			cursorAfter: (/* @__PURE__ */ new Date()).toISOString(),
+			completed: true,
+			metadata: {
+				...sourceRun.metadata,
+				itemsIndexed,
+				candidatesCreated: understanding.created
+			}
+		});
+		updateUnderstandingSourceGrantCheckpoint(sourceRun.grantId, {
+			checkpoint: {
+				cursor: (/* @__PURE__ */ new Date()).toISOString(),
+				connectorLearningJobId: job.id
+			},
+			lastCollectedAt: Date.now()
+		});
+		publish(completed);
 		pruneBoundedKnowledgeSourceItems(job.sourceInstanceId, Date.now() - plan.bootstrapWindowDays * 24 * 60 * 6e4);
 		const syncPolicy = getConnectorSyncPolicyForConnection(job.connectionId);
 		if (syncPolicy?.scanEnabled === false) return;
@@ -190,6 +256,12 @@ function startConnectorLearningCoordinator(options) {
 						nextRunAt: exhausted ? null : Date.now() + Math.min(30 * 6e4, 3e4 * 2 ** Math.min(job.attemptCount, 6)),
 						finished: true
 					}));
+					const definition = getConnectorDefinition(job.connectorId);
+					if (definition?.runtime.type === "composio" && definition.runtime.role === "toolkit") updateUnderstandingSourceRun(ensureUnderstandingSourceRun(job, definition.runtime.toolkit, definition.displayName).id, {
+						status: "failed",
+						errorMessage,
+						completed: true
+					});
 					log.warn({
 						err,
 						jobId: job.id,

package/dist/src/gateway/agent-builtin-tools.d.ts

@@ -2,5 +2,5 @@
  * Built-in agent tool `name` values for gateway admin UI (disable toggles).
  * Extension tools are not listed; users can still add arbitrary strings in config.
  */
-export declare const GATEWAY_BUILTIN_TOOL_IDS: readonly ["code_search", "code_read_symbol", "code_trace", "code_impact", "code_architecture", "read_file", "write_file", "apply_patch", "list_dir", "grep", "find", "exec_command", "update_plan", "session_status", "dreaming", "tool_manual", "clarify", "todo", "skills_list", "skill_view", "skill_manage", "skills_marketplace_search", "skill_install", "web_search", "web_fetch", "web_extract", "send_message", "send_media", "read_media", "create_share", "text_to_speech", "memory_search", "memory_get", "session_search", "automation", "workflow", "delegate_task", "execute_code", "image", "image_generate", "create_desktop_pet", "browser_use", "xopc_tool_search", "xopc_tool_describe", "xopc_tool_execute"];
+export declare const GATEWAY_BUILTIN_TOOL_IDS: readonly ["read_file", "write_file", "apply_patch", "list_dir", "grep", "find", "exec_command", "update_plan", "session_status", "dreaming", "tool_manual", "clarify", "todo", "skills_list", "skill_view", "skill_manage", "skills_marketplace_search", "skill_install", "web_search", "web_fetch", "web_extract", "send_message", "send_media", "read_media", "create_share", "text_to_speech", "memory_search", "memory_get", "session_search", "automation", "workflow", "delegate_task", "execute_code", "image", "image_generate", "create_desktop_pet", "browser_use", "xopc_tool_search", "xopc_tool_describe", "xopc_tool_execute"];
 export type GatewayBuiltinToolId = (typeof GATEWAY_BUILTIN_TOOL_IDS)[number];

package/dist/src/gateway/agent-builtin-tools.js

@@ -6,11 +6,6 @@ import "../agent/external-tools/index.js";
 * Extension tools are not listed; users can still add arbitrary strings in config.
 */
 const GATEWAY_BUILTIN_TOOL_IDS = [
-	"code_search",
-	"code_read_symbol",
-	"code_trace",
-	"code_impact",
-	"code_architecture",
 	"read_file",
 	"write_file",
 	"apply_patch",

package/dist/src/gateway/agents-admin.d.ts

@@ -140,13 +140,6 @@ export declare function writeAgentProfileFile(cfg: Config, agentId: string, name
     agentId: string;
     path: string;
 }>>;
-export declare function readUserProfileFile(): Promise<AgentAdminResult<{
-    content: string;
-    path: string;
-}>>;
-export declare function writeUserProfileFile(content: string): Promise<AgentAdminResult<{
-    path: string;
-}>>;
 export declare function readAgentAvatarFile(cfg: Config, agentId: string): Promise<AgentAdminResult<{
     agentId: string;
     buffer: Buffer;

package/dist/src/gateway/agents-admin.js

@@ -1,14 +1,14 @@
 import { resolveCapabilityPresetLayer, resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveAgentDir, resolveAgentProfileDir, resolveAgentWorkspaceDir, resolveDefaultAgentId, resolveUserPath, validateAgentIdForNewAgent } from "../agent/agent-scope.js";
 import { resolveEffectiveAgentProfile } from "../config/agent-profile.js";
-import { WORKSPACE_FILES, init_paths, resolveUserProfilePath } from "../config/paths.js";
+import { WORKSPACE_FILES, init_paths } from "../config/paths.js";
 import { AGENT_PROFILE_MARKDOWN_SYSTEM_FILES, REQUIRED_AGENT_PROFILE_MARKDOWN_FILE_SET } from "../agent/context/workspace.js";
 import { isPathUnderWorkspace, resolveWorkspaceSafePath } from "./workspace-editor-path.js";
 import { seedAgentProfileMarkdownFiles } from "../agent/context/workspace-seed.js";
 import { applyAgentConfig, findAgentEntryIndex, getAgentDeleteBlocker, pruneAgentConfig, removeAgentDirsFromDisk } from "../commands/agents.config.js";
 import { resolveEffectiveTypedModels } from "../config/agent-typed-models.js";
 import { GATEWAY_BUILTIN_TOOL_IDS } from "./agent-builtin-tools.js";
-import { dirname, join, resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { cp, mkdir, readFile, readdir, realpath, stat, unlink, writeFile } from "node:fs/promises";
 //#region src/gateway/agents-admin.ts
 /**
@@ -525,35 +525,6 @@ async function writeAgentProfileFile(cfg, agentId, name, content) {
 		}
 	};
 }
-async function readUserProfileFile() {
-	const path = resolveUserProfilePath();
-	try {
-		return {
-			ok: true,
-			data: {
-				content: await readFile(path, "utf-8"),
-				path
-			}
-		};
-	} catch {
-		return {
-			ok: true,
-			data: {
-				content: "",
-				path
-			}
-		};
-	}
-}
-async function writeUserProfileFile(content) {
-	const path = resolveUserProfilePath();
-	await mkdir(dirname(path), { recursive: true });
-	await writeFile(path, content, "utf-8");
-	return {
-		ok: true,
-		data: { path }
-	};
-}
 const AGENT_AVATAR_MAX_BYTES = 512 * 1024;
 const AGENT_AVATAR_BASENAME = "agent-avatar";
 const AGENT_AVATAR_EXTENSIONS = [
@@ -701,4 +672,4 @@ async function deleteAgentAvatarFile(cfg, agentId) {
 	};
 }
 //#endregion
-export { deleteAgentAvatarFile, extractAvatarFromIdentityMarkdown, finalizeCreateAgentDirs, getGatewayAgentEffectiveManifest, listAgentProfileFiles, listGatewayAgents, parseIdentityMarkdown, prepareCreateAgent, prepareDeleteAgent, prepareUpdateAgent, readAgentAvatarFile, readAgentProfileFile, readUserProfileFile, runAfterDeletePurge, writeAgentAvatarFromBase64, writeAgentProfileFile, writeUserProfileFile };
+export { deleteAgentAvatarFile, extractAvatarFromIdentityMarkdown, finalizeCreateAgentDirs, getGatewayAgentEffectiveManifest, listAgentProfileFiles, listGatewayAgents, parseIdentityMarkdown, prepareCreateAgent, prepareDeleteAgent, prepareUpdateAgent, readAgentAvatarFile, readAgentProfileFile, runAfterDeletePurge, writeAgentAvatarFromBase64, writeAgentProfileFile };

package/dist/src/gateway/dreaming-automation-reconciler.d.ts

@@ -1,9 +1,9 @@
 import type { Config } from '../config/schema.js';
 import type { AutomationService } from '../automations/index.js';
 export type DreamingAutomationReconcileResult = {
-    created: string[];
-    updated: string[];
-    disabled: string[];
+    created: boolean;
+    updated: boolean;
+    disabled: boolean;
 };
 export declare function reconcileDreamingAutomations(params: {
     config: Config;

package/dist/src/gateway/dreaming-automation-reconciler.js

@@ -1,100 +1,60 @@
-import { DREAMING_AUTOMATION_TAG, DREAMING_DEEP_AUTOMATION_NAME, DREAMING_LIGHT_AUTOMATION_NAME, DREAMING_LIGHT_SWEEP_TOKEN, DREAMING_REM_AUTOMATION_NAME, DREAMING_REM_SWEEP_TOKEN, DREAMING_SWEEP_TOKEN } from "../agent/memory/dreaming/constants.js";
-import { compileDreamingSchedule } from "../agent/memory/dreaming/schedule.js";
-import { resolveDreamingAgentScope } from "../agent/memory/dreaming/scope.js";
+import { init_agent_scope, normalizeAgentId, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
+import { USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID, USER_CONTEXT_CONSOLIDATION_TOKEN, compileContextConsolidationCron, resolveContextConsolidationConfig } from "../user-context/consolidation.js";
 //#region src/gateway/dreaming-automation-reconciler.ts
-const DREAMING_AUTOMATIONS = [
-	{
-		phase: "light",
-		name: DREAMING_LIGHT_AUTOMATION_NAME,
-		token: DREAMING_LIGHT_SWEEP_TOKEN
-	},
-	{
-		phase: "deep",
-		name: DREAMING_DEEP_AUTOMATION_NAME,
-		token: DREAMING_SWEEP_TOKEN
-	},
-	{
-		phase: "rem",
-		name: DREAMING_REM_AUTOMATION_NAME,
-		token: DREAMING_REM_SWEEP_TOKEN
-	}
-];
-function phaseDescription(phase) {
-	return `${phase === "light" ? "Light sweep" : phase === "deep" ? "Deep promotion" : "REM pattern discovery"} for memory dreaming. ${DREAMING_AUTOMATION_TAG}`;
-}
-function buildTrigger(config, phase) {
-	const phaseConfig = config.phases[phase];
-	return {
+init_agent_scope();
+async function reconcileDreamingAutomations(params) {
+	const result = {
+		created: false,
+		updated: false,
+		disabled: false
+	};
+	const resolved = resolveContextConsolidationConfig(params.config);
+	const agentId = normalizeAgentId(resolveDefaultAgentId(params.config));
+	const workingDirectory = resolveAgentWorkspaceDir(params.config, agentId);
+	const trigger = {
 		kind: "schedule",
 		schedule: {
 			kind: "cron",
-			expr: compileDreamingSchedule(phaseConfig.schedule),
-			tz: config.timezone
+			expr: compileContextConsolidationCron(resolved.time),
+			tz: resolved.timezone
 		}
 	};
-}
-function dreamingAutomationId(phase) {
-	return `system-user-context-dreaming:${phase}`;
-}
-function buildAction(scope, token) {
-	return {
+	const action = {
 		kind: "agent",
-		agentId: scope.agentId,
-		instruction: token,
-		workingDirectory: scope.workspaceDir,
-		timeoutSeconds: 3600
+		agentId,
+		instruction: USER_CONTEXT_CONSOLIDATION_TOKEN,
+		workingDirectory,
+		timeoutSeconds: 300
 	};
-}
-function automationNeedsUpdate(current, next) {
-	return current.name !== next.name || current.description !== next.description || current.enabled !== next.enabled || JSON.stringify(current.trigger) !== JSON.stringify(next.trigger) || JSON.stringify(current.action) !== JSON.stringify(next.action) || current.safety?.mode !== "auto_apply" || current.afterRun?.kind !== "none" || current.reliability?.disableAfterConsecutiveFailures !== 3;
-}
-async function reconcileDreamingAutomations(params) {
-	const { config, automationService } = params;
-	const result = {
-		created: [],
-		updated: [],
-		disabled: []
-	};
-	const scope = resolveDreamingAgentScope(config);
-	const resolved = scope.config;
-	for (const spec of DREAMING_AUTOMATIONS) {
-		const id = dreamingAutomationId(spec.phase);
-		const current = await automationService.get(id);
-		const enabled = resolved.enabled && resolved.phases[spec.phase].enabled;
-		if (!resolved.enabled) {
-			if (current?.enabled) {
-				await automationService.update(id, { enabled: false });
-				result.disabled.push(id);
-			}
-			continue;
-		}
-		const next = {
-			name: spec.name,
-			description: phaseDescription(spec.phase),
-			enabled,
-			trigger: buildTrigger(resolved, spec.phase),
-			action: buildAction(scope, spec.token)
-		};
-		if (!current) {
-			await automationService.create({
-				id,
-				...next,
-				safety: { mode: "auto_apply" },
-				afterRun: { kind: "none" },
-				reliability: { disableAfterConsecutiveFailures: 3 }
-			});
-			result.created.push(id);
-			continue;
-		}
-		if (automationNeedsUpdate(current, next)) {
-			await automationService.update(id, {
-				...next,
-				safety: { mode: "auto_apply" },
-				afterRun: { kind: "none" },
-				reliability: { disableAfterConsecutiveFailures: 3 }
-			});
-			result.updated.push(id);
+	const current = await params.automationService.get(USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID);
+	if (!resolved.enabled) {
+		if (current?.enabled) {
+			await params.automationService.update(USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID, { enabled: false });
+			result.disabled = true;
 		}
+		return result;
+	}
+	const next = {
+		name: "User context review",
+		description: "Deterministically review structured user understanding for expiry and sufficient evidence.",
+		enabled: true,
+		trigger,
+		action,
+		safety: { mode: "auto_apply" },
+		afterRun: { kind: "none" },
+		reliability: { disableAfterConsecutiveFailures: 3 }
+	};
+	if (!current) {
+		await params.automationService.create({
+			id: USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID,
+			...next
+		});
+		result.created = true;
+		return result;
+	}
+	if (current.name !== next.name || current.description !== next.description || !current.enabled || JSON.stringify(current.trigger) !== JSON.stringify(trigger) || JSON.stringify(current.action) !== JSON.stringify(action) || current.safety?.mode !== "auto_apply" || current.afterRun?.kind !== "none" || current.reliability?.disableAfterConsecutiveFailures !== 3) {
+		await params.automationService.update(USER_CONTEXT_CONSOLIDATION_AUTOMATION_ID, next);
+		result.updated = true;
 	}
 	return result;
 }

package/dist/src/gateway/hono/lib/config-payload.d.ts

@@ -66,7 +66,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
             };
             tools: {
                 builtin?: Record<string, {
-                    mode: "allow" | "confirm" | "deny";
+                    mode: "allow" | "deny" | "confirm";
                     scope?: "workspace" | "readonly" | "unrestricted";
                     limits?: {
                         maxCallsPerTurn?: number;
@@ -75,7 +75,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
                 }>;
                 mcp?: {
                     servers?: Record<string, {
-                        mode: "allow" | "confirm" | "deny";
+                        mode: "allow" | "deny" | "confirm";
                         scope?: "workspace" | "readonly" | "unrestricted";
                         limits?: {
                             maxCallsPerTurn?: number;
@@ -83,7 +83,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
                         };
                     }>;
                     tools?: Record<string, {
-                        mode: "allow" | "confirm" | "deny";
+                        mode: "allow" | "deny" | "confirm";
                         scope?: "workspace" | "readonly" | "unrestricted";
                         limits?: {
                             maxCallsPerTurn?: number;
@@ -143,7 +143,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
             };
             tools?: {
                 builtin?: Record<string, {
-                    mode: "allow" | "confirm" | "deny";
+                    mode: "allow" | "deny" | "confirm";
                     scope?: "workspace" | "readonly" | "unrestricted";
                     limits?: {
                         maxCallsPerTurn?: number;
@@ -152,7 +152,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
                 }>;
                 mcp?: {
                     servers?: Record<string, {
-                        mode: "allow" | "confirm" | "deny";
+                        mode: "allow" | "deny" | "confirm";
                         scope?: "workspace" | "readonly" | "unrestricted";
                         limits?: {
                             maxCallsPerTurn?: number;
@@ -160,7 +160,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
                         };
                     }>;
                     tools?: Record<string, {
-                        mode: "allow" | "confirm" | "deny";
+                        mode: "allow" | "deny" | "confirm";
                         scope?: "workspace" | "readonly" | "unrestricted";
                         limits?: {
                             maxCallsPerTurn?: number;
@@ -290,6 +290,18 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
         preferences: {
             responseLanguage: "auto" | "zh-CN" | "en";
         };
+        dreaming: {
+            mode: "off" | "review";
+            schedule: {
+                time: string;
+            };
+            minEvidenceSources: number;
+            limit: number;
+            timezone?: string;
+        };
+        privacy: {
+            sensitiveWritePolicy: "allow" | "deny" | "confirm";
+        };
         memory: {
             retention: {
                 compaction: {
@@ -345,7 +357,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
         language?: "en" | "zh";
         input?: {
             refinement?: {
-                mode: "off" | "light" | "custom" | "punctuation";
+                mode: "off" | "custom" | "punctuation" | "light";
                 model?: string;
                 customInstruction?: string;
             };

package/dist/src/gateway/hono/lib/config-payload.js

@@ -1,4 +1,4 @@
-import { ContextCompactionPolicySchema, init_config } from "../../../user-context/config.js";
+import { ContextCompactionPolicySchema, UserContextDreamingSchema, UserContextPrivacySchema, init_config } from "../../../user-context/config.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveDefaultAgentId } from "../../../agent/agent-scope.js";
 import { resolveModelsJsonPath } from "../../../config/paths.js";
 import { buildChannelCatalogForConfig, buildChannelCatalogFromSnapshot, getChannelSetupStatus, init_channel_catalog_service } from "../../../channels/catalog/channel-catalog-service.js";
@@ -178,6 +178,8 @@ async function buildSafeWebConfigPayload(service, options = {}) {
 		session: resolveSessionConfigForWeb(config),
 		userContext: {
 			preferences: config.userContext?.preferences ?? { responseLanguage: "auto" },
+			dreaming: UserContextDreamingSchema.parse(config.userContext?.dreaming),
+			privacy: UserContextPrivacySchema.parse(config.userContext?.privacy),
 			memory: { retention: { compaction: ContextCompactionPolicySchema.parse(config.userContext?.memory.retention?.compaction) } }
 		},
 		tui: { defaultAgent: config.tui?.defaultAgent ?? "coder" },

package/dist/src/gateway/hono/oauth-async.d.ts

@@ -8,6 +8,7 @@
 import { Hono } from 'hono';
 import type { GatewayService } from '../service.js';
 import { type OAuthCredentials } from '../../auth/oauth/types.js';
+export declare function refreshModelCatalogAfterOAuth(provider: string, service: Pick<GatewayService, 'getModelCatalogSync'>): Promise<void>;
 export declare function resolveOAuthLoginMethodPreference(params: {
     requestedMethod?: unknown;
     supportedMethods?: readonly string[];

package/dist/src/gateway/hono/oauth-async.js

@@ -17,6 +17,19 @@ init_registry();
 init_credentials();
 init_logger();
 const log = createLogger("OAuthAsync");
+async function refreshModelCatalogAfterOAuth(provider, service) {
+	if (provider !== "xopc-cloud") return;
+	try {
+		await service.getModelCatalogSync().refreshNow();
+	} catch (err) {
+		const errorMessage = err instanceof Error ? err.message : String(err);
+		log.warn({
+			err,
+			provider,
+			errorMessage
+		}, `OAuth completed, but the model catalog could not be refreshed: ${errorMessage}`);
+	}
+}
 /** User-facing message when undici/fetch fails (often DNS, firewall, or wrong machine for localhost callback). */
 function formatOAuthAsyncError(err) {
 	const base = err instanceof Error ? err.message : "OAuth login failed";
@@ -200,7 +213,7 @@ function createOAuthAsyncHandler(service) {
 /**
 * Run OAuth flow in background
 */
-async function runOAuthFlow(session, oauthProvider, _service) {
+async function runOAuthFlow(session, oauthProvider, service) {
 	const abortController = new AbortController();
 	session.abortController = abortController;
 	let manualCodePromise = null;
@@ -276,6 +289,8 @@ async function runOAuthFlow(session, oauthProvider, _service) {
 		const credentials = await oauthProvider.login(callbacks);
 		setOAuthCredentialsToCache(session.provider, credentials);
 		await new CredentialResolver().saveOAuthCredentials(session.provider, credentials);
+		session.message = session.provider === "xopc-cloud" ? "OAuth login successful. Syncing available models..." : "OAuth login successful";
+		await refreshModelCatalogAfterOAuth(session.provider, service);
 		session.status = "completed";
 		session.credentials = credentials;
 		session.message = "OAuth login successful";
@@ -313,4 +328,4 @@ function deleteOAuthCredentialsFromCache(provider) {
 	oauthCredentialsCache.delete(provider);
 }
 //#endregion
-export { createOAuthAsyncHandler, deleteOAuthCredentialsFromCache, getOAuthCredentialsFromCache, resolveOAuthLoginMethodPreference, setOAuthCredentialsToCache };
+export { createOAuthAsyncHandler, deleteOAuthCredentialsFromCache, getOAuthCredentialsFromCache, refreshModelCatalogAfterOAuth, resolveOAuthLoginMethodPreference, setOAuthCredentialsToCache };