evolcore 0.0.8 → 0.0.10

package/CHANGELOG.md

@@ -3,6 +3,37 @@
 本文件记录 EvolCore 的重要变更。EvolClaw 版本线的历史记录已归档至
 [`docs/_archive/CHANGELOG-evolclaw.md`](docs/_archive/CHANGELOG-evolclaw.md)。
 
+## 0.0.10 (2026-08-06)
+
+### 数据迁移
+
+- 修复联系人审计在多 Agent 场景下重复迁移的问题，审计记录改为写入各 Agent 自身数据目录。
+- 迁移支持增量合并并复用已完成的迁移证明，同时校验来源内容变化，避免内容已改动时被错误跳过。
+
+## 0.0.9 (2026-08-06)
+
+### 安装与自启
+
+- 支持在安装或初始化时配置登录自启，Windows 与 macOS 开机登录后自动拉起 EvolCore。
+- 已完成初始化的安装可单独开关登录自启，无需重跑初始化流程。
+
+### AUN 通信
+
+- 出站消息默认加密，可通过配置调整；观察者转发与回执一并遵循该设置。
+- 未连接时的图片与消息发送进入待发队列，连接恢复后按序重投，不再直接丢弃。
+- 完善图片上传的类型识别与结构化内容处理。
+
+### BaseAgent 配置
+
+- 支持为 BaseAgent 自定义请求头和查询参数，便于对接需要额外标识的网关。
+- 统一各 BaseAgent 的推理强度配置项，旧字段仍可识别。
+
+### 运行可靠性
+
+- 修复 Agent 在启动阶段被中断时的状态残留。
+- EC Web 版本过低时拒绝启动并提示升级命令，避免新旧组件搭配下的异常行为。
+- 完善菜单协议的权限校验，并修正系统信息查询。
+
 ## 0.0.8 (2026-08-04)
 
 ### AID 与域名管理

package/README.md

@@ -86,16 +86,16 @@ ResponseEngine.processMessage()
 **一行安装（macOS / Linux）**：
 
 ```bash
-curl -fsSL https://download.evolai.cn/install.sh | bash
+curl -fsSL https://download.evolai.cn/releases/evolcore/2026-08-05.2/install.sh | bash
 ```
 
 **Windows PowerShell**：
 
 ```powershell
-irm https://download.evolai.cn/install.ps1 | iex
+& ([scriptblock]::Create((irm https://download.evolai.cn/releases/evolcore/2026-08-05.2/install.ps1))) -AutoStart
 ```
 
-安装器会自动进入 `ec init` 交互向导；只有已有配置同时包含控制 AID 和 Owner 时才跳过。绑定完成后运行 `ec start` 和 `ec status`。安装器不会停止或重启服务，详细流程见 [一键安装脚本说明](docs/evolcore-install-script.md)。
+安装器会自动进入 `ec init` 交互向导；只有已有配置同时包含控制 AID 和 Owner 时才跳过。上面的 Windows 命令会在绑定完成后自动运行 `ec start`；macOS/Linux 需手动运行 `ec start`。安装器不会停止或重启已有服务，详细流程见 [一键安装脚本说明](docs/evolcore-install-script.md)。
 
 **npm 全局安装**：
 
@@ -174,6 +174,40 @@ ec init aun
 - `model`：配置文件 → `~/.claude/settings.json` → 默认 `sonnet`
 - `effort`：配置文件 → `~/.claude/settings.json` → SDK 默认值（`auto`）
 
+Claude/Codex 兼容网关需要额外请求头或查询参数时，可以直接在 EvolCore 的
+`baseagents` 配置中设置，不需要修改 Claude/Codex 的全局配置文件：
+
+```json
+{
+  "baseagents": {
+    "claude": {
+      "baseUrl": "https://example.com/claude",
+      "headers": {
+        "X-Tenant-Id": "${TENANT_ID}"
+      },
+      "queryParams": {
+        "source": "evolcore"
+      }
+    },
+    "codex": {
+      "baseUrl": "https://example.com/codex",
+      "headers": {
+        "X-Tenant-Id": "${TENANT_ID}"
+      },
+      "queryParams": {
+        "source": "evolcore"
+      }
+    }
+  }
+}
+```
+
+`${VAR}` 会按 EvolCore 的环境变量规则展开。Claude 通过 `ANTHROPIC_CUSTOM_HEADERS`
+传递 Header；Codex app-server 启动时由 EvolCore 注入 `env_http_headers` 和
+`query_params`，所以不需要手改 `~/.codex/config.toml`。`queryParams` 不应放置密钥等敏感信息。
+
+完整设计、运行链路和排障说明见：[Claude/Codex 自定义请求元数据技术文档](docs/baseagent-request-metadata.md)。
+
 ### 3. 运行
 
 ```bash

package/dist/agents/baseagent.js

@@ -50,6 +50,35 @@ function directInferenceValue(...values) {
     }
     return undefined;
 }
+const HTTP_HEADER_NAME = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+function normalizeStringMap(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${field} must be an object with string values`);
+    }
+    const entries = [];
+    for (const [key, item] of Object.entries(value)) {
+        if (!key)
+            throw new Error(`${field} names cannot be empty`);
+        if (typeof item !== 'string')
+            throw new Error(`${field}.${key} must be a string`);
+        if (field === 'headers') {
+            if (!HTTP_HEADER_NAME.test(key))
+                throw new Error(`Invalid HTTP header name: ${key}`);
+            if (/[\0\r\n]/.test(item))
+                throw new Error(`HTTP header ${key} cannot contain NUL or line breaks`);
+        }
+        entries.push([key, item]);
+    }
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function normalizeRequestMetadata(value) {
+    return {
+        headers: normalizeStringMap(value?.headers, 'headers'),
+        queryParams: normalizeStringMap(value?.queryParams, 'queryParams'),
+    };
+}
 /** Claude Code accepts both names; AUTH_TOKEN is kept first for compatibility. */
 function resolveAnthropicApiKey(...values) {
     return directInferenceValue(...values);
@@ -71,13 +100,27 @@ function loadClaudeSettings() {
  */
 export function resolveAnthropicDirectConfig(override) {
     const explicit = directInferencePair(override?.apiKey, override?.baseUrl);
-    if (explicit)
-        return explicit;
+    if (explicit) {
+        return {
+            ...explicit,
+            ...normalizeRequestMetadata(override),
+        };
+    }
     const environment = directInferencePair(directInferenceValue(process.env.ANTHROPIC_AUTH_TOKEN, process.env.ANTHROPIC_API_KEY), process.env.ANTHROPIC_BASE_URL);
-    if (environment)
-        return environment;
+    if (environment) {
+        return {
+            ...environment,
+            ...normalizeRequestMetadata(override),
+        };
+    }
     const settings = loadClaudeSettings();
-    return directInferencePair(directInferenceValue(settings.env?.ANTHROPIC_AUTH_TOKEN, settings.env?.ANTHROPIC_API_KEY), settings.env?.ANTHROPIC_BASE_URL);
+    const settingsResolved = directInferencePair(directInferenceValue(settings.env?.ANTHROPIC_AUTH_TOKEN, settings.env?.ANTHROPIC_API_KEY), settings.env?.ANTHROPIC_BASE_URL);
+    return settingsResolved
+        ? {
+            ...settingsResolved,
+            ...normalizeRequestMetadata(override),
+        }
+        : undefined;
 }
 export function resolveAnthropicConfig(config, override) {
     const settings = loadClaudeSettings();
@@ -95,6 +138,8 @@ export function resolveAnthropicConfig(config, override) {
         || globalBaseUrl
         || process.env.ANTHROPIC_BASE_URL
         || settings.env?.ANTHROPIC_BASE_URL;
+    const headers = normalizeStringMap(override?.headers ?? config.agents?.claude?.headers, 'headers');
+    const queryParams = normalizeStringMap(override?.queryParams ?? config.agents?.claude?.queryParams, 'queryParams');
     const model = override?.model
         || config.agents?.claude?.model
         || settings.model
@@ -106,19 +151,22 @@ export function resolveAnthropicConfig(config, override) {
     const pickExec = (v) => (!v || v.includes('your-') || v.includes('placeholder')) ? undefined : v;
     const pathToClaudeCodeExecutable = pickExec(override?.pathToClaudeCodeExecutable)
         || pickExec(config.agents?.claude?.pathToClaudeCodeExecutable);
-    return { apiKey, baseUrl, model, effort, pathToClaudeCodeExecutable };
+    return { apiKey, baseUrl, headers, queryParams, model, effort, pathToClaudeCodeExecutable };
 }
 function loadCodexSettings() {
     try {
-        const authPath = path.join(os.homedir(), '.codex', 'auth.json');
+        const configuredHome = process.env.CODEX_HOME?.trim();
+        const codexHome = configuredHome ? path.resolve(configuredHome) : path.join(os.homedir(), '.codex');
+        const authPath = path.join(codexHome, 'auth.json');
         let apiKey;
         if (fs.existsSync(authPath)) {
             const auth = JSON.parse(fs.readFileSync(authPath, 'utf-8'));
             apiKey = auth.OPENAI_API_KEY;
         }
-        const configPath = path.join(os.homedir(), '.codex', 'config.toml');
+        const configPath = path.join(codexHome, 'config.toml');
         let model;
         let baseUrl;
+        let provider;
         if (fs.existsSync(configPath)) {
             const content = fs.readFileSync(configPath, 'utf-8');
             const modelMatch = content.match(/^model\s*=\s*"([^"]+)"/m);
@@ -126,17 +174,35 @@ function loadCodexSettings() {
                 model = modelMatch[1];
             const providerMatch = content.match(/^model_provider\s*=\s*"([^"]+)"/m);
             if (providerMatch) {
-                const provider = providerMatch[1];
-                const baseUrlMatch = content.match(new RegExp(`\\[model_providers\\.${provider}\\][\\s\\S]*?base_url\\s*=\\s*"([^"]+)"`, 'm'));
-                if (baseUrlMatch)
-                    baseUrl = baseUrlMatch[1];
+                provider = providerMatch[1];
+                baseUrl = readCodexProviderBaseUrl(content, provider);
             }
         }
-        return { apiKey, baseUrl, model };
+        return { apiKey, baseUrl, model, provider };
     }
     catch { }
     return {};
 }
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function readCodexProviderBaseUrl(content, provider) {
+    const segments = /^[A-Za-z0-9_-]+$/.test(provider)
+        ? [provider, JSON.stringify(provider)]
+        : [JSON.stringify(provider)];
+    for (const segment of segments) {
+        const section = new RegExp(`^\\s*\\[\\s*model_providers\\s*\\.\\s*${escapeRegExp(segment)}\\s*\\]\\s*(?:#.*)?$`, 'm').exec(content);
+        if (!section || section.index === undefined)
+            continue;
+        const tail = content.slice(section.index + section[0].length);
+        const nextSection = tail.search(/^\s*\[/m);
+        const block = nextSection >= 0 ? tail.slice(0, nextSection) : tail;
+        const baseUrl = block.match(/^\s*base_url\s*=\s*"([^"]+)"/m)?.[1];
+        if (baseUrl)
+            return baseUrl;
+    }
+    return undefined;
+}
 /**
  * Resolve a complete credential/endpoint pair for direct OpenAI HTTP calls.
  * auth.json and config.toml together form the Codex SDK source; fields are
@@ -144,13 +210,27 @@ function loadCodexSettings() {
  */
 export function resolveOpenaiDirectConfig(override) {
     const explicit = directInferencePair(override?.apiKey, override?.baseUrl);
-    if (explicit)
-        return explicit;
+    if (explicit) {
+        return {
+            ...explicit,
+            ...normalizeRequestMetadata(override),
+        };
+    }
     const environment = directInferencePair(process.env.OPENAI_API_KEY, process.env.OPENAI_BASE_URL);
-    if (environment)
-        return environment;
+    if (environment) {
+        return {
+            ...environment,
+            ...normalizeRequestMetadata(override),
+        };
+    }
     const settings = loadCodexSettings();
-    return directInferencePair(settings.apiKey, settings.baseUrl);
+    const settingsResolved = directInferencePair(settings.apiKey, settings.baseUrl);
+    return settingsResolved
+        ? {
+            ...settingsResolved,
+            ...normalizeRequestMetadata(override),
+        }
+        : undefined;
 }
 export function resolveOpenaiConfig(config, override) {
     const codexSettings = loadCodexSettings();
@@ -172,6 +252,8 @@ export function resolveOpenaiConfig(config, override) {
         || process.env.OPENAI_BASE_URL
         || codexSettings.baseUrl
         || undefined;
+    const headers = normalizeStringMap(override?.headers ?? config.agents?.codex?.headers, 'headers');
+    const queryParams = normalizeStringMap(override?.queryParams ?? config.agents?.codex?.queryParams, 'queryParams');
     const model = override?.model
         || config.agents?.codex?.model
         || codexSettings.model
@@ -187,7 +269,17 @@ export function resolveOpenaiConfig(config, override) {
     const approvalsReviewer = override?.approvalsReviewer
         ?? config.agents?.codex?.approvalsReviewer
         ?? undefined;
-    return { apiKey, baseUrl, model, effort, enableRequestUserInput, approvalsReviewer };
+    return {
+        apiKey,
+        baseUrl,
+        provider: codexSettings.provider,
+        headers,
+        queryParams,
+        model,
+        effort,
+        enableRequestUserInput,
+        approvalsReviewer,
+    };
 }
 export function resolveGoogleConfig(config, override) {
     const googleCfg = config.agents?.gemini;

package/dist/agents/claude-runner.js

@@ -65,6 +65,19 @@ function isClaudeMcpTool(toolName) {
 function isUnknownClaudeTool(toolName) {
     return !isClaudeMcpTool(toolName) && !CLAUDE_BUILTIN_TOOLS.has(toolName);
 }
+function appendQueryParams(baseUrl, queryParams) {
+    if (!baseUrl || !queryParams || Object.keys(queryParams).length === 0)
+        return baseUrl;
+    try {
+        const parsed = new URL(baseUrl);
+        for (const [name, value] of Object.entries(queryParams))
+            parsed.searchParams.set(name, value);
+        return parsed.toString();
+    }
+    catch {
+        return baseUrl;
+    }
+}
 function stableClaudePermissionValue(value, depth = 0) {
     if (depth > 8)
         return '[truncated]';
@@ -529,6 +542,8 @@ export class AgentRunner {
     effort;
     permissionMode = DEFAULT_PERMISSION_MODE;
     baseUrl;
+    customHeaders;
+    customQueryParams;
     config;
     activeSessions = new Map();
     activeStreams = new Map();
@@ -556,16 +571,22 @@ export class AgentRunner {
         if (config) {
             const anthropic = resolveAnthropicConfig(config);
             this.claudeExecutablePath = anthropic.pathToClaudeCodeExecutable;
+            this.customHeaders = anthropic.headers;
+            this.customQueryParams = anthropic.queryParams;
         }
     }
     getAgentEnv(runtimeEnv, evolcoreSessionId) {
+        const anthropicBaseUrl = appendQueryParams(this.baseUrl, this.customQueryParams);
         const env = {
             ...process.env,
             ANTHROPIC_AUTH_TOKEN: this.apiKey,
             ANTHROPIC_API_KEY: this.apiKey,
             PATH: process.env.PATH,
             DISABLE_AUTOUPDATER: '1',
-            ...(this.baseUrl ? { ANTHROPIC_BASE_URL: this.baseUrl } : {}),
+            ...(anthropicBaseUrl ? { ANTHROPIC_BASE_URL: anthropicBaseUrl } : {}),
+            ...(this.customHeaders
+                ? { ANTHROPIC_CUSTOM_HEADERS: Object.entries(this.customHeaders).map(([name, value]) => `${name}: ${value}`).join('\n') }
+                : {}),
             ...(evolcoreSessionId ? { EVOLCORE_SESSION_ID: evolcoreSessionId } : {}),
             ...(runtimeEnv ?? {}),
         };
@@ -2298,6 +2319,7 @@ export class AgentRunner {
         })();
     }
     async interrupt(sessionId) {
+        const streamRegistered = this.activeStreams.has(sessionId);
         const fn = this.interruptFns.get(sessionId);
         const query = this.activeQueries.get(sessionId);
         const cancelledInputIds = [];
@@ -2327,7 +2349,10 @@ export class AgentRunner {
         if (query && typeof query.close === 'function')
             query.close();
         const done = this.streamDone.get(sessionId);
-        if (done) {
+        // A stream interrupted after runQuery resolves but before registerStream has
+        // no consumer that can enter the wrapper generator's finally block. Waiting
+        // for streamDone here would always burn the full timeout.
+        if (done && streamRegistered) {
             await Promise.race([done, new Promise(resolve => setTimeout(resolve, 5_000))]);
         }
         this.interruptFns.delete(sessionId);
@@ -2343,6 +2368,9 @@ export class AgentRunner {
     cleanupStream(sessionId) {
         this.activeMessageStreams.get(sessionId)?.end();
         this.activeMessageStreams.delete(sessionId);
+        this.streamDoneResolvers.get(sessionId)?.();
+        this.streamDoneResolvers.delete(sessionId);
+        this.streamDone.delete(sessionId);
         this.activeStreams.delete(sessionId);
         this.interruptFns.delete(sessionId);
         this.activeQueries.delete(sessionId);

package/dist/agents/codex-app-server-client.js

@@ -3,6 +3,22 @@ import readline from 'readline';
 import { logger } from '../utils/logger.js';
 import { buildHClassGuardCommand } from '../core/permission/sandbox-runtime.js';
 import { resolveCodexLaunchCommand } from '../utils/codex-cli.js';
+import { createHash } from 'crypto';
+function tomlProviderKey(value) {
+    if (!value || /[\0\r\n]/.test(value)) {
+        throw new Error(`Invalid Codex provider name: ${value}`);
+    }
+    return /^[A-Za-z0-9_-]+$/.test(value) ? value : JSON.stringify(value);
+}
+function tomlInlineStringTable(values) {
+    return `{${Object.entries(values)
+        .map(([name, value]) => `${JSON.stringify(name)}=${JSON.stringify(value)}`)
+        .join(',')}}`;
+}
+function codexHeaderEnvName(headerName) {
+    const digest = createHash('sha256').update(headerName).digest('hex').slice(0, 16).toUpperCase();
+    return `EVOLCORE_CODEX_HEADER_${digest}`;
+}
 function hasPermissionProfile(config) {
     if (!config || typeof config.default_permissions !== 'string' || !config.default_permissions)
         return false;
@@ -327,6 +343,9 @@ export class CodexAppServerClient {
     startProcess() {
         const env = { ...process.env, ...this.options.env };
         env.CODEX_API_KEY = this.options.apiKey;
+        for (const [name, value] of Object.entries(this.options.headers ?? {})) {
+            env[codexHeaderEnvName(name)] = value;
+        }
         if (this.options.baseUrl) {
             env.OPENAI_BASE_URL = this.options.baseUrl;
         }
@@ -367,6 +386,18 @@ export class CodexAppServerClient {
         if (this.options.baseUrl) {
             args.push('--config', `openai_base_url=${JSON.stringify(this.options.baseUrl)}`);
         }
+        const headerEnvNames = Object.fromEntries(Object.keys(this.options.headers ?? {}).map(name => [name, codexHeaderEnvName(name)]));
+        const hasHeaders = Object.keys(headerEnvNames).length > 0;
+        const hasQueryParams = Object.keys(this.options.queryParams ?? {}).length > 0;
+        if (hasHeaders || hasQueryParams) {
+            const provider = tomlProviderKey(this.options.provider || 'openai');
+            if (hasHeaders) {
+                args.push('--config', `model_providers.${provider}.env_http_headers=${tomlInlineStringTable(headerEnvNames)}`);
+            }
+            if (hasQueryParams) {
+                args.push('--config', `model_providers.${provider}.query_params=${tomlInlineStringTable(this.options.queryParams ?? {})}`);
+            }
+        }
         if (this.options.effort) {
             args.push('--config', `model_reasoning_effort=${JSON.stringify(this.options.effort)}`);
         }

package/dist/agents/codex-runner.js

@@ -255,6 +255,9 @@ export class CodexRunner {
             const client = new CodexAppServerClient({
                 apiKey: this.resolvedConfig.apiKey,
                 baseUrl: this.resolvedConfig.baseUrl,
+                provider: this.resolvedConfig.provider,
+                headers: this.resolvedConfig.headers,
+                queryParams: this.resolvedConfig.queryParams,
                 model: this.model,
                 effort: this.effort,
                 enableRequestUserInput: this.resolvedConfig.enableRequestUserInput,

package/dist/aun/msg/group.js

@@ -5,7 +5,7 @@ import { TextDecoder } from 'util';
 import { createShortConnection } from '../rpc/index.js';
 import { getAidStore, loadClient, SLOT } from '../aid/store.js';
 import { uploadFileAndBuildPayload } from './upload.js';
-import { daemonTaskSendIpcTimeoutMs } from './p2p.js';
+import { daemonTaskSendIpcTimeoutMs, resolveAunMessageEncrypt } from './p2p.js';
 import { checkGroupIndex, getGroupIndex } from './group-index.js';
 import { appendMessageLog, buildOutboundEntry, classifyAunPayloadForLog } from '../../core/message/message-log.js';
 import { chatDirPath } from '../../core/session/session-fs-store.js';
@@ -50,7 +50,7 @@ function groupSendLogMetadata(args, payload, runtimeContext) {
         source: (runtimeContext ? 'msg' : 'cli'),
     };
 }
-function appendGroupSendOutboundLog(args, messageId, payload, runtimeContext) {
+function appendGroupSendOutboundLog(args, messageId, payload, runtimeContext, encrypt = resolveAunMessageEncrypt(args.encrypt)) {
     const log = groupSendLogMetadata(args, payload, runtimeContext);
     const chatDir = chatDirPath(resolvePaths().sessionsDir, 'aun', args.groupId, args.from);
     fs.mkdirSync(chatDir, { recursive: true });
@@ -63,7 +63,7 @@ function appendGroupSendOutboundLog(args, messageId, payload, runtimeContext) {
         groupId: args.groupId,
         msgId: messageId,
         content: log.content,
-        encrypt: args.encrypt === true,
+        encrypt,
         msgType: log.msgType,
         payloadType: log.payloadType,
         payloadSummary: log.payloadSummary,
@@ -95,7 +95,7 @@ async function tryDaemonGroupSend(args, payload, runtimeContext, file) {
         scope: 'group',
         ...(payload ? { payload } : { file }),
         mentions: args.mentions,
-        encrypt: args.encrypt === true,
+        encrypt: args.encrypt,
         thread,
         returnPolicy: args.returnPolicy,
         originSessionId: runtimeContext.sessionId,
@@ -135,7 +135,7 @@ async function daemonGroupSendResult(args, payload, runtimeContext, result) {
     const messageId = result.message_id
         ?? (typeof result.message.message_id === 'string' ? result.message.message_id : undefined);
     if (messageId && !result.log_written) {
-        appendGroupSendOutboundLog(args, messageId, payload, runtimeContext);
+        appendGroupSendOutboundLog(args, messageId, payload, runtimeContext, result.encrypt ?? resolveAunMessageEncrypt(args.encrypt));
     }
     return {
         ok: true,
@@ -193,12 +193,12 @@ export async function groupSend(args) {
             payload.mentions = args.mentions;
         }
         applyGroupRoutingPayloadFields(payload, args, runtimeContext);
-        const sendParams = { group_id: args.groupId, payload };
-        sendParams.encrypt = args.encrypt === true;
+        const encrypt = resolveAunMessageEncrypt(args.encrypt);
+        const sendParams = { group_id: args.groupId, payload, encrypt };
         const result = await conn.call('group.send', sendParams);
         const messageId = typeof result?.message?.message_id === 'string' ? result.message.message_id : undefined;
         if (messageId)
-            appendGroupSendOutboundLog(args, messageId, payload, runtimeContext);
+            appendGroupSendOutboundLog(args, messageId, payload, runtimeContext, encrypt);
         return {
             ok: true,
             group_id: result?.group_id ?? args.groupId,
@@ -954,7 +954,7 @@ async function sendGroupRulesUpdatedNotice(client, args) {
         const result = await client.group.send({
             group_id: args.groupId,
             payload,
-            encrypt: false,
+            encrypt: resolveAunMessageEncrypt(),
         });
         const message = isRecord(result.message) ? result.message : {};
         const messageId = typeof result.message_id === 'string'

package/dist/aun/msg/p2p.js

@@ -9,6 +9,7 @@ import { chatDirPath } from '../../core/session/session-fs-store.js';
 import { resolvePaths } from '../../paths.js';
 import { ipcQuery } from '../../ipc.js';
 import { AGENT_DELEGATION_TOKEN_ENV } from '../../core/auth/agent-delegation.js';
+import { loadDaemonConfig } from '../../config-store.js';
 const DEFAULT_TASK_EXECUTION_MS = 60 * 60 * 1000;
 const DAEMON_SEND_TIMEOUT_GRACE_MS = 10_000;
 const MAX_TIMER_MS = 2_147_483_647;
@@ -24,6 +25,11 @@ export function daemonTaskSendIpcTimeoutMs(file = false) {
     catch { }
     return Math.min(MAX_TIMER_MS, Math.max(file ? 120_000 : 5_000, executionMs + DAEMON_SEND_TIMEOUT_GRACE_MS));
 }
+export function resolveAunMessageEncrypt(explicit) {
+    if (typeof explicit === 'boolean')
+        return explicit;
+    return loadDaemonConfig().aun?.defaultEncrypt ?? true;
+}
 function buildSimplePayload(body) {
     switch (body.mode) {
         case 'text':
@@ -113,7 +119,7 @@ async function tryDaemonMsgSend(args, payload, runtimeContext, file) {
         to: args.to,
         scope: 'msg',
         ...(payload ? { payload } : { file }),
-        encrypt: args.encrypt === true,
+        encrypt: args.encrypt,
         thread,
         returnPolicy: args.returnPolicy,
         originSessionId: runtimeContext.sessionId,
@@ -155,7 +161,7 @@ async function daemonMsgSendResult(args, payload, runtimeContext, daemonResult)
             payload,
             runtimeContext,
             chatmode: daemonResult.chatmode,
-            encrypt: daemonResult.encrypt ?? args.encrypt === true,
+            encrypt: daemonResult.encrypt ?? resolveAunMessageEncrypt(args.encrypt),
         });
     }
     return sent;
@@ -259,9 +265,8 @@ export async function msgSend(args) {
         // 5. 写入 payload.thread_id/ref_message_id（如果指定）
         applyRoutingPayloadFields(payload, args, runtimeContext, false);
         applyRoutingPayloadFields(payload, args, runtimeContext);
-        const sendParams = { to: args.to, payload };
-        // Default: plaintext. Set encrypt: true to enable E2EE.
-        sendParams.encrypt = args.encrypt === true;
+        const encrypt = resolveAunMessageEncrypt(args.encrypt);
+        const sendParams = { to: args.to, payload, encrypt };
         const result = await conn.call('message.send', sendParams);
         // 5. 写出方向 jsonl（与 daemon 一致格式，标记 source）
         // source 标记：
@@ -273,7 +278,7 @@ export async function msgSend(args) {
                     payload,
                     runtimeContext,
                     chatmode,
-                    encrypt: args.encrypt === true,
+                    encrypt,
                 });
             }
             catch { }