evolcore 0.0.34 → 0.0.35

package/CHANGELOG.md

@@ -5,6 +5,28 @@
 
 ## Unreleased
 
+## 0.0.35 (2026-10-19)
+
+### 权限与记忆
+
+- 规范 Claude Code 与 ecagent 的 Bash 调用说明，要求明确命令目标并标注低、中、高风险等级；缺失或格式错误时提供具体提示，避免权限模式不同导致调用说明不一致。
+- agent 级记忆整理会扫描所有关系记忆并按关系归类，避免遗漏其他对端的过期记忆。
+- 首次设定尚未完成时阻止记忆整理会话启动，避免记忆被提前认领后无法正常处理。
+- 细化只读 Shell 操作的拒绝原因，提升受限命令的诊断可读性。
+
+### Codex 与运行稳定性
+
+- 保留 Codex 模型服务重连进度，并在最终失败时展示实际重试次数，避免只显示笼统的请求失败。
+- 统一 Codex managed hook 的包根目录与安装器解析，升级监视器暂存运行文件时同步携带 `bin` 目录，提升升级和重启过程的一致性。
+- 补充生命周期启动失败时的 stderr 诊断输出，便于定位启动异常。
+- 修复 `agent.md` 显示名解析，改用 YAML 结构化解析以正确处理引号和特殊字符。
+- 修复话题摘要写入时的游标竞态，确保 `coveredThroughTs` 在追加摘要前读取。
+
+### 消息与依赖兼容
+
+- 规范 AUN 原始错误展示，截断错误响应中附带的 HTML 页面，保留有用的错误信息并减少无关输出。
+- 将 AUN SDK 最低运行版本提升至 `0.5.20`，使用经过当前版本验证的 SDK 依赖。
+
 ## 0.0.34 (2026-10-18)
 
 ### 模型与上下文

package/bin/install-codex-managed-hooks.mjs

@@ -22,7 +22,25 @@ function hasArgument(name) {
   return process.argv.includes(name);
 }
 
-function fail(message) {
+/** Path where the elevated installer writes a structured failure record for the non-elevated parent. */
+function installerFailurePath(requirements) {
+  const configDir = requirements
+    ? path.dirname(path.resolve(requirements))
+    : path.join(process.env.ProgramData || path.join(os.homedir(), 'ProgramData'), 'OpenAI', 'Codex');
+  return path.join(configDir, '.evolcore-install-failure.json');
+}
+
+function writeFailureRecord(requirements, message) {
+  try {
+    const record = { time: new Date().toISOString(), message };
+    fs.writeFileSync(installerFailurePath(requirements), JSON.stringify(record) + '\n', { mode: 0o644 });
+  } catch {
+    // Best-effort; parent falls back to "installer exited with code 1" if missing.
+  }
+}
+
+function fail(message, requirements) {
+  writeFailureRecord(requirements, message);
   process.stderr.write(`[evolcore] ${message}\n`);
   process.exit(1);
 }
@@ -653,7 +671,7 @@ function main() {
   const hookPath = path.join(targetDirectory, 'pre-tool-use.mjs');
   const sourceHook = path.join(packageRoot, 'bin', 'codex-managed-hook.mjs');
   for (const file of [sourceHook, nodePath]) {
-    if (!fs.statSync(file).isFile()) fail(`Required Hook runtime file was not found: ${file}`);
+    if (!fs.statSync(file).isFile()) fail(`Required Hook runtime file was not found: ${file}`, requirements);
   }
   if (hasArgument('--repair')) {
     const result = repairManagedHookInstallation({
@@ -674,7 +692,12 @@ function main() {
 }
 
 if (process.argv[1] && pathToFileURL(fs.realpathSync(process.argv[1])).href === import.meta.url) {
+  // Resolve requirements now so writeFailureRecord has a path even if main()
+  // throws before the local `requirements` variable is assigned.
+  const earlyRequirements = argument('--requirements')
+    ? path.resolve(argument('--requirements'))
+    : path.join(process.env.ProgramData || path.join(os.homedir(), 'ProgramData'), 'OpenAI', 'Codex', 'requirements.toml');
   try { main(); } catch (error) {
-    fail(error instanceof Error ? error.message : String(error));
+    fail(error instanceof Error ? error.message : String(error), earlyRequirements);
   }
 }

package/dist/agents/claude-runner.js

@@ -15,7 +15,7 @@ import crypto from 'crypto';
 import { logger } from '../utils/logger.js';
 import { createClaudeStartupArgumentsTooLongError, isClaudeStartupArgumentsTooLong, createClaudeCodeStartupError, isClaudeCodeStartupProcessError, } from '../utils/error-utils.js';
 import { requestDangerousCommandPermission } from '../core/permission/approval-gateway.js';
-import { checkDangerousCommand, checkReadonly, evaluateToolPreflight } from '../core/permission/tool-policy.js';
+import { checkBashDescription, checkDangerousCommand, checkReadonly, evaluateToolPreflight } from '../core/permission/tool-policy.js';
 import { sanitizeShellExecutionEnvironment } from '../core/permission/shell-environment.js';
 import { summarizeToolInput, summarizeToolInputForAudit } from '../utils/tool-summary.js';
 import { encodePath } from '../utils/cross-platform.js';
@@ -2391,6 +2391,16 @@ export class AgentRunner {
                 delete toolInput.pages;
             }
             let updatedInput = toolInput === originalInput ? undefined : toolInput;
+            // Bash description 格式约定先于一切放行分支（含系统会话与 fullaccess）。
+            // TODO(bash-description): 该约束缺少验证——实测模型被拒后不会补 description 重试，
+            // 话题链等链路会被整条堵死。在补齐测试与重试引导前先短路放行，恢复时删除本开关。
+            if (process.env.EVOLCORE_BASH_DESCRIPTION_ENFORCE === '1') {
+                const descriptionCheck = checkBashDescription(toolName, toolInput);
+                if (descriptionCheck) {
+                    await recordPreflightDenial(toolName, toolInput, descriptionCheck, input.tool_use_id ?? input.toolUseID);
+                    return hookDecision('deny', descriptionCheck.message, updatedInput);
+                }
+            }
             // 系统会话：模块判定即最终结论，不进入下面任何按角色 / permissionMode 的分支
             const systemSessionCheck = this.permissionContexts.get(sessionId)?.systemSessionCheck;
             if (systemSessionCheck) {

package/dist/agents/codex/diagnostics.js

@@ -3,8 +3,10 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
 import { parse as parseToml } from 'smol-toml';
-const managedHookInstaller = await import(new URL('../../../bin/install-codex-managed-hooks.mjs', import.meta.url).href);
+import { TARGET_PACKAGE_ROOT_ENV } from '../../product.js';
 export function checkCodexProjectPath(value, options = {}) {
     const configured = typeof value === 'string' ? value.trim() : '';
     if (!configured) {
@@ -239,9 +241,6 @@ function runtimeFileMayExist(file) {
         return !['ENOENT', 'ENOTDIR'].includes(error?.code || '');
     }
 }
-function managedBinding(source, launcher, hookPath) {
-    return managedHookInstaller.managedBinding(source, launcher, hookPath);
-}
 /** Read-only inspection of the machine-wide Windows Codex managed hook. */
 export function inspectCodexManagedHook(options = {}) {
     const paths = codexManagedHookPaths(options);
@@ -250,6 +249,21 @@ export function inspectCodexManagedHook(options = {}) {
     const requirements = path.resolve(options.requirements || paths.requirements);
     const managedDir = path.resolve(options.managedDir || paths.managedDir);
     const hookPath = path.join(managedDir, 'pre-tool-use.mjs');
+    let managedHookInstaller;
+    try {
+        const installer = fileURLToPath(new URL('../../../bin/install-codex-managed-hooks.mjs', import.meta.url));
+        managedHookInstaller = createRequire(import.meta.url)(installer);
+        if (typeof managedHookInstaller.managedBinding !== 'function') {
+            throw new Error('managedBinding export is unavailable');
+        }
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return {
+            status: 'unsafe', requirements, managedDir, hookPath,
+            reason: `managed-hook installer could not be loaded: ${detail}`,
+        };
+    }
     const configDirState = realDirectoryState(path.dirname(requirements));
     const managedDirState = realDirectoryState(managedDir);
     if ([configDirState, managedDirState].includes('unsafe')) {
@@ -312,9 +326,9 @@ export function inspectCodexManagedHook(options = {}) {
     catch (error) {
         return { status: 'unavailable', requirements, managedDir, hookPath, reason: error instanceof Error ? error.message : String(error) };
     }
-    const expectedPackageRoot = path.resolve(options.packageRoot || process.cwd());
+    const expectedPackageRoot = path.resolve(process.env[TARGET_PACKAGE_ROOT_ENV] || options.packageRoot || process.cwd());
     try {
-        const binding = managedBinding(source, launcher, hookPath);
+        const binding = managedHookInstaller.managedBinding(source, launcher, hookPath);
         if (!binding || config.allow_managed_hooks_only !== true || config.features?.hooks !== true
             || normalizedPath(config.hooks?.windows_managed_dir) !== normalizedPath(managedDir)
             || (config.hooks?.managed_dir !== undefined
@@ -382,9 +396,10 @@ export async function ensureCodexManagedHook(options) {
     });
     if (!paths)
         return { status: 'skipped', reason: 'Windows managed hooks are not applicable on this platform' };
+    const packageRoot = process.env[TARGET_PACKAGE_ROOT_ENV] || options.packageRoot;
     const inspectOptions = {
         platform: platformName,
-        packageRoot: options.packageRoot,
+        packageRoot,
         requirements: options.requirements || paths.requirements,
         managedDir: options.managedDir || paths.managedDir,
         programData: options.programData,
@@ -414,7 +429,9 @@ export async function ensureCodexManagedHook(options) {
         || rechecked.repairAmbiguous !== state.repairAmbiguous) {
         return { ...rechecked, repaired: false, error: 'managed-hook state changed during the startup check; retry to confirm the current binding' };
     }
-    const installer = path.join(path.resolve(options.packageRoot), 'bin', 'install-codex-managed-hooks.mjs');
+    const installer = process.env[TARGET_PACKAGE_ROOT_ENV]
+        ? fileURLToPath(new URL('../../../bin/install-codex-managed-hooks.mjs', import.meta.url))
+        : path.join(path.resolve(packageRoot), 'bin', 'install-codex-managed-hooks.mjs');
     if (!fs.existsSync(installer)) {
         return { ...state, repaired: false, error: `managed-hook installer is missing: ${installer}` };
     }
@@ -438,15 +455,29 @@ export async function ensureCodexManagedHook(options) {
         if (result.error)
             return { ok: false, detail: result.error.message };
         if (result.status !== 0) {
-            const detail = (result.stderr || '').replace(/#<\s*CLIXML[\s\S]*?<\/Objs>\s*/gi, '').trim();
-            return { ok: false, detail: detail || `installer exited with code ${result.status}` };
+            const stderrDetail = (result.stderr || '').replace(/#<\s*CLIXML[\s\S]*?<\/Objs>\s*/gi, '').trim();
+            // The elevated child process runs in a separate window and its stderr is
+            // not captured through the Start-Process pipe. Read the structured failure
+            // record the installer writes to ProgramData before exiting.
+            let fileDetail;
+            try {
+                const failurePath = path.join(path.dirname(path.resolve(inspectOptions.requirements || paths.requirements)), '.evolcore-install-failure.json');
+                const raw = fs.readFileSync(failurePath, 'utf8');
+                const parsed = JSON.parse(raw);
+                if (typeof parsed.message === 'string' && parsed.message)
+                    fileDetail = parsed.message;
+                fs.rmSync(failurePath, { force: true });
+            }
+            catch { /* best-effort */ }
+            const detail = fileDetail || stderrDetail || `installer exited with code ${result.status}`;
+            return { ok: false, detail };
         }
         return { ok: true };
     });
     options.onInstallRequired?.(state);
     let elevated;
     try {
-        elevated = runElevated(installer, path.resolve(options.packageRoot));
+        elevated = runElevated(installer, path.resolve(packageRoot));
     }
     catch (error) {
         elevated = { ok: false, detail: error instanceof Error ? error.message : String(error) };

package/dist/agents/codex-runner.js

@@ -88,6 +88,24 @@ class AsyncEventQueue {
         }
     }
 }
+function parseCodexRetryProgress(message) {
+    const match = message.match(/\bReconnecting\.\.\.\s*(\d+)\s*\/\s*(\d+)\b/i);
+    if (!match)
+        return undefined;
+    const count = Number(match[1]);
+    const limit = Number(match[2]);
+    if (!Number.isSafeInteger(count) || !Number.isSafeInteger(limit) || count < 1 || limit < count)
+        return undefined;
+    return { count, limit };
+}
+function createCodexRetryMetadataError(message, state) {
+    const error = new Error(message);
+    if (state.modelRetryCount !== undefined)
+        error.codexRetryCount = state.modelRetryCount;
+    if (state.modelRetryLimit !== undefined)
+        error.codexRetryLimit = state.modelRetryLimit;
+    return error;
+}
 function fallbackErrorCodeForToolDenial(decisionSource, policyCode) {
     if (decisionSource === 'policy' && policyCode === 'apply_patch_invalid_argument')
         return 'INVALID_ARGUMENT';
@@ -4931,7 +4949,7 @@ export class CodexRunner {
                         lastReportedUsage: state.tokenUsage?.last,
                     })}`);
                     if (isRetryableError(new Error(turn.error.message))) {
-                        throw new Error(turn.error.message);
+                        throw createCodexRetryMetadataError(turn.error.message, state);
                     }
                     yield { type: 'error', error: turn.error.message, errorType: toAgentErrorType(turn.error.message) };
                 }
@@ -4953,6 +4971,11 @@ export class CodexRunner {
                 // Codex owns retries within this turn. Throwing here closes our subscription
                 // before its recovery can finish; runQuery must not submit the input again.
                 if (params.willRetry === true) {
+                    const retryProgress = parseCodexRetryProgress(message);
+                    if (retryProgress) {
+                        state.modelRetryCount = Math.max(state.modelRetryCount ?? 0, retryProgress.count);
+                        state.modelRetryLimit = retryProgress.limit;
+                    }
                     yield {
                         type: 'notice', severity: 'warn', subtype: 'codex-model-retry',
                         message: isOutputTokenLimitError(new Error(message))
@@ -4961,8 +4984,9 @@ export class CodexRunner {
                     };
                     break;
                 }
-                if (isRetryableError(new Error(message)))
-                    throw new Error(message);
+                if (isRetryableError(new Error(message))) {
+                    throw createCodexRetryMetadataError(message, state);
+                }
                 yield { type: 'error', error: message, errorType: toAgentErrorType(message) };
                 break;
             }

package/dist/agents/ecagent-runner.js

@@ -10,7 +10,7 @@ import { DEFAULT_PERMISSION_MODE } from '../types.js';
 import { agentSessionsDir, resolveRoot } from '../paths.js';
 import { requestDangerousCommandPermission } from '../core/permission/approval-gateway.js';
 import { normalizeExecutionPermissionMode, normalizePermissionMode } from '../core/permission/mode.js';
-import { checkDangerousCommand, checkReadonly, evaluateToolPreflight } from '../core/permission/tool-policy.js';
+import { checkBashDescription, checkDangerousCommand, checkReadonly, evaluateToolPreflight } from '../core/permission/tool-policy.js';
 import { logger } from '../utils/logger.js';
 import { ErrorType } from '../utils/error-utils.js';
 import { summarizeToolInputForAudit } from '../utils/tool-summary.js';
@@ -700,7 +700,7 @@ function createTools(env, projectPath, runtimeEnv, bootstrapAgentMdPath, fullacc
         name: 'Bash', label: 'Bash', description: 'Run a shell command in the project.',
         parameters: Type.Object({
             command: Type.String(), timeout: Type.Optional(Type.Number({ minimum: 1, maximum: 600_000 })),
-            description: Type.Optional(Type.String()),
+            description: Type.Optional(Type.String({ description: '<命令目标描述> [<风险等级>]，风险等级为 低/中/高 之一，例如 "查看工作区未提交的改动 [低]"。缺失或格式不符时调用被拒。' })),
         }), executionMode: 'sequential',
         async execute(_id, params, signal) {
             const result = await env.exec(params.command, {
@@ -1214,11 +1214,6 @@ export class EcagentRunner {
     }
     async authorizeTool(sessionId, projectPath, mode, toolName, input, turn) {
         const permissionContext = this.permissionContexts.get(sessionId);
-        if (mode === 'fullaccess') {
-            return hasTrustedFullAccessContext(permissionContext)
-                ? {}
-                : { block: true, reason: 'Untrusted fullaccess execution context' };
-        }
         const recordBlockedOperation = async (policyCode, operationInput = input, matchedPath) => {
             const summary = summarizeToolInputForAudit(toolName, operationInput).slice(0, 512);
             auditToolPreflightDenial({
@@ -1257,6 +1252,21 @@ export class EcagentRunner {
                 logger.warn(`[EcagentRunner] failed to record blocked operation: session=${sessionId} tool=${toolName} code=${policyCode} error=${error instanceof Error ? error.message : String(error)}`);
             }
         };
+        // Bash description 格式约定先于一切放行分支（含 fullaccess 与系统会话）。
+        // TODO(bash-description): 与 claude-runner 同因——该约束缺少验证，先短路放行；
+        // 恢复强制时把两个 runner 的开关一起打开。
+        if (process.env.EVOLCORE_BASH_DESCRIPTION_ENFORCE === '1') {
+            const descriptionCheck = checkBashDescription(toolName, input);
+            if (descriptionCheck) {
+                await recordBlockedOperation(descriptionCheck.policyCode);
+                return { block: true, reason: descriptionCheck.message };
+            }
+        }
+        if (mode === 'fullaccess') {
+            return hasTrustedFullAccessContext(permissionContext)
+                ? {}
+                : { block: true, reason: 'Untrusted fullaccess execution context' };
+        }
         // 系统会话：模块判定即最终结论，不进入 preflight / permissionMode 分支
         if (permissionContext?.systemSessionCheck) {
             const decision = permissionContext.systemSessionCheck(toolName, input);

package/dist/aun/aid/agentmd.js

@@ -179,8 +179,19 @@ export function parseAgentDisplayName(content) {
     const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/)?.[1];
     if (!frontmatter)
         return undefined;
-    const name = frontmatter.match(/^name:\s*["']?(.+?)["']?\s*$/m)?.[1]?.trim();
-    return name || undefined;
+    try {
+        const document = parseDocument(frontmatter);
+        if (document.errors.length > 0)
+            return undefined;
+        const fields = document.toJS();
+        if (!fields || typeof fields !== 'object' || Array.isArray(fields))
+            return undefined;
+        const name = fields.name;
+        return typeof name === 'string' ? name.trim() || undefined : undefined;
+    }
+    catch {
+        return undefined;
+    }
 }
 function displayNameKey(aid, aunPath) {
     const root = path.resolve(aunPath ?? resolveRoot());

package/dist/aun/aid/client.js

@@ -39,7 +39,7 @@ export function suppressSdkLogs() {
     };
 }
 // ==================== SDK package ====================
-export const MIN_AUN_CORE_SDK = [0, 5, 17];
+export const MIN_AUN_CORE_SDK = [0, 5, 20];
 export const AUN_CORE_SDK_PKG = '@agentunion/fastaun';
 function compareVersion(a, min) {
     const parts = a.split('.').map(n => parseInt(n, 10));

package/dist/aun/msg/managed-operation.js

@@ -597,6 +597,9 @@ export class ManagedMsgOperationError extends Error {
 }
 const HISTORY_VALUE_FLAGS = new Set([
     '--session', '--limit', '--before', '--after', '--direction', '--format', '--channel-key', '--peer-id',
+    // 话题过滤是托管协作的常规用法（文档 `thread-chain.md` 明确写了
+    // `ec msg history --thread <id>`）；只会收窄结果集，不扩大可读范围。
+    '--thread',
 ]);
 function failMsg(code, reason) {
     return { ok: false, code, reason };
@@ -720,6 +723,15 @@ export function resolveManagedMsgOperation(argv) {
         return failMsg('INVALID_ARGUMENT', '--after must be earlier than --before');
     }
     const target = channelKey === undefined ? String(positionals[0] || '').replace(/^@/, '') : undefined;
+    const threadId = values.get('--thread');
+    if (threadId !== undefined) {
+        if (kind !== 'history')
+            return failMsg('INVALID_ARGUMENT', '--thread is only supported for history');
+        if (channelKey !== undefined)
+            return failMsg('INVALID_ARGUMENT', '--thread cannot be combined with --channel-key/--peer-id');
+        if (!/^thread-[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(threadId))
+            return failMsg('INVALID_ARGUMENT', 'invalid --thread id');
+    }
     const canonicalArgv = ['msg', kind, from];
     if (target !== undefined)
         canonicalArgv.push(target);
@@ -735,6 +747,8 @@ export function resolveManagedMsgOperation(argv) {
         canonicalArgv.push('--after', values.get('--after'));
     if (values.has('--direction'))
         canonicalArgv.push('--direction', values.get('--direction'));
+    if (threadId !== undefined)
+        canonicalArgv.push('--thread', threadId);
     return {
         ok: true,
         command: {
@@ -749,6 +763,7 @@ export function resolveManagedMsgOperation(argv) {
             before,
             after,
             direction,
+            ...(threadId !== undefined ? { threadId } : {}),
         },
     };
 }
@@ -766,6 +781,7 @@ export async function executeManagedMsgOperation(command) {
             before: command.before,
             after: command.after,
             direction: command.direction,
+            threadId: command.threadId,
         })
         : await msgOnline({
             from: command.from,

package/dist/aun/msg/p2p.js

@@ -279,8 +279,24 @@ export async function msgSend(args) {
             catch { /* ignore */ }
         }
         // 2. 决定 chatmode（遵循来源1-3）
-        // 私聊：非 human 对端 → proactive，human 对端 → interactive
-        const chatmode = peerIdentity.isAgent ? 'proactive' : 'interactive';
+        // 私聊：非 human 对端 → proactive；人类对端只有 owner/admin 才 interactive，
+        // 其余（含角色未知）按 proactive 保守处理。判定逻辑集中在 peer-mode。
+        const { chatmodeForPeerIdentity } = await import('../../core/message/peer-mode.js');
+        const { resolvePeerRoleDetail } = await import('../../config/peer-role-resolver.js');
+        let peerRole = null;
+        try {
+            peerRole = resolvePeerRoleDetail({
+                selfAid: args.from,
+                channelKey: `aun#${args.from}#main`,
+                channelType: 'aun',
+                chatType: 'private',
+                actorId: args.to,
+                conversationId: args.to,
+                peerType: peerIdentity.type,
+            }).effectiveRole;
+        }
+        catch { /* 角色解析失败时按未知处理（proactive） */ }
+        const chatmode = chatmodeForPeerIdentity(peerIdentity, peerRole);
         // 3. 构建 payload
         if (!payload) {
             payload = buildSimplePayload(args.body);

package/dist/channels/aun.js

@@ -557,10 +557,23 @@ function setIfDefined(target, key, value) {
     if (value !== undefined)
         target[key] = value;
 }
+function truncateRawErrorForDisplay(raw) {
+    if (typeof raw !== 'string' || !raw.trim())
+        return undefined;
+    const text = raw.trim();
+    const htmlStart = text.toLowerCase().indexOf('<html');
+    return htmlStart >= 0 ? text.slice(0, htmlStart).trimEnd() : text;
+}
+function projectedRawError(raw, displayRaw) {
+    if (typeof raw !== 'string')
+        return raw;
+    return raw.trim() ? displayRaw : raw;
+}
 function appendRawErrorText(text, raw) {
-    if (typeof raw !== 'string' || !raw.trim() || text.includes(raw))
+    const displayRaw = truncateRawErrorForDisplay(raw);
+    if (!displayRaw || text.includes(displayRaw))
         return text;
-    return `${text}\n原因：${raw}`;
+    return `${text}\n原因：${displayRaw}`;
 }
 /**
  * 把 AUNChannel 投递的 opts 映射成渠道无关的 InboundMessage。
@@ -667,6 +680,8 @@ export class AUNChannel {
     traceWriter = null;
     eventBus = null;
     queuedHandler = null;
+    /** `topic-renamed` 消费器，由 runtime 注入（见 setThreadRenameHandler）。 */
+    threadRenameHandler = null;
     groupInviteHandler;
     groupInviteConnectedHandler;
     groupInviteDeliveryGate;
@@ -1396,6 +1411,44 @@ export class AUNChannel {
             return sanitized;
         return undefined;
     }
+    /**
+     * 处理对端 `topic-renamed` 通知：校验字段后交给注入的改名消费器落索引，
+     * 成功后发 `thread:renamed` 让前端刷新。全程不进入 Agent 消息队列。
+     * 通知是尽力而为的，任何失败只记日志，不影响后续消息处理。
+     */
+    applyInboundTopicRename(params) {
+        const payload = params.payload && typeof params.payload === 'object' ? params.payload : null;
+        const threadId = typeof payload?.threadId === 'string' ? payload.threadId : undefined;
+        const name = this.sanitizeTopicName(payload?.topicName);
+        const nameUpdatedAt = typeof payload?.nameUpdatedAt === 'number' && Number.isFinite(payload.nameUpdatedAt)
+            ? payload.nameUpdatedAt : undefined;
+        const applier = this.threadRenameHandler;
+        if (!applier || !threadId || !name || nameUpdatedAt === undefined || !params.peer) {
+            logger.debug(`${this.logPrefix()} topic-renamed ignored: peer=${params.peer || '<none>'} thread=${threadId || '<none>'} hasName=${!!name}`);
+            return;
+        }
+        void applier({
+            selfAid: params.selfAid, peer: params.peer, peerKind: params.peerKind,
+            threadId, name, nameUpdatedAt,
+        }).then(result => {
+            if (!result.applied) {
+                logger.debug(`${this.logPrefix()} topic-renamed not applied (${result.reason ?? 'unknown'}): thread=${threadId}`);
+                return;
+            }
+            this.eventBus?.publish?.({
+                type: 'thread:renamed',
+                sessionId: result.sessionId,
+                peer: params.peer,
+                threadId,
+                name,
+                nameUpdatedAt,
+                by: params.senderAid ?? '',
+            });
+            logger.info(`${this.logPrefix()} topic-renamed applied: thread=${threadId} name=${JSON.stringify(name)}`);
+        }).catch(error => {
+            logger.warn(`${this.logPrefix()} topic-renamed failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }
     buildGroupReplyContext(threadId, senderAid, encrypted, messageId, chatmode, topicName, groupId, label, topicStatus) {
         if (!groupId)
             throw new Error('buildGroupReplyContext requires groupId');
@@ -2524,6 +2577,14 @@ export class AUNChannel {
         if (p2pPayloadType === 'text') {
             import('../utils/msg-diag.js').then(m => m.diagLog('aun_in', { aid: this.config.aid, from: fromAid, to: this.config.aid, msgId: messageId, text })).catch(() => { });
         }
+        // topic-renamed：对端话题改名通知。只更新本端话题索引，不进 Agent 队列。
+        if (p2pPayloadType === 'topic-renamed') {
+            this.applyInboundTopicRename({
+                payload, selfAid: this.config.aid, peer: fromAid, peerKind: 'private',
+                senderAid: fromAid,
+            });
+            return;
+        }
         // action_card_reply 已在 extractTextPayload 中消费，不分发给 agent
         if (p2pPayloadType === 'action_card_reply') {
             this.appendInboundPayloadJsonl(chatId, fromAid, messageId, msgEncrypted, false, logDescriptor, threadId, receivedAt, seq);
@@ -2655,6 +2716,14 @@ export class AUNChannel {
             logger.debug(`${this.logPrefix()} Group dropped observer control envelope: mid=${messageId}`);
             return;
         }
+        // topic-renamed：群内话题改名通知。只更新本端索引，不进 Agent 队列。
+        if (inboundType === 'topic-renamed') {
+            this.applyInboundTopicRename({
+                payload, selfAid: this.config.aid, peer: groupId || senderAid, peerKind: 'group',
+                senderAid,
+            });
+            return;
+        }
         const payloadMentionEntries = this.parsePayloadMentionsOrReject(payload, 'group.inbound', messageId);
         if (!payloadMentionEntries)
             return;
@@ -3765,6 +3834,13 @@ export class AUNChannel {
         }, delayMs);
     }
     // ── Public API (same interface as before) ───────────────────
+    /**
+     * 对端发来的话题改名通知（`topic-renamed`）。由 runtime 注入，交给
+     * ThreadService.applyRemoteRename 落本地索引；不进入 Agent 消息队列。
+     */
+    setThreadRenameHandler(handler) {
+        this.threadRenameHandler = handler;
+    }
     setEventBus(bus) {
         // 重新订阅前先解掉旧的——避免 reload/重连后 listener 累积
         if (this.eventBus && this.queuedHandler && typeof this.eventBus.unsubscribe === 'function') {
@@ -4611,7 +4687,23 @@ export class AUNChannel {
             return { ok: false, error: 'AUN channel is not connected', code: 'AUN_NOT_CONNECTED' };
         }
         const info = await this.fetchPeerInfo(args.to);
-        const chatmode = info.type === 'human' ? 'interactive' : 'proactive';
+        // 与 p2p 发送路径共用同一判定：非人类 → proactive；人类需 owner/admin 才 interactive。
+        const { chatmodeForPeerIdentity } = await import('../core/message/peer-mode.js');
+        let peerRole = null;
+        try {
+            const { resolvePeerRoleDetail } = await import('../config/peer-role-resolver.js');
+            peerRole = resolvePeerRoleDetail({
+                selfAid: this.config.aid,
+                channelKey: `aun#${this.config.aid}#main`,
+                channelType: 'aun',
+                chatType: 'private',
+                actorId: args.to,
+                conversationId: args.to,
+                peerType: info.type ?? undefined,
+            }).effectiveRole;
+        }
+        catch { /* 角色解析失败按未知处理 */ }
+        const chatmode = chatmodeForPeerIdentity({ isMachine: info.type !== 'human', type: info.type ?? undefined }, peerRole);
         if (!finalPayload.chatmode)
             finalPayload.chatmode = chatmode;
         const parentCausation = normalizeCausation(args.causation);
@@ -6426,14 +6518,16 @@ export class AUNChannelPlugin {
                         return;
                     }
                     case 'system.error': {
+                        const raw = truncateRawErrorForDisplay(payload.raw);
+                        const projectedRaw = projectedRawError(payload.raw, raw);
                         const errorPayload = {
                             type: payload.recoverable === true ? 'notice' : 'error',
                             ...taskBase(),
                             subtype: payload.subtype,
                             text: payload.recoverable === true
                                 ? payload.text
-                                : appendRawErrorText(payload.text, payload.raw),
-                            ...(payload.raw !== undefined ? { raw: payload.raw } : {}),
+                                : appendRawErrorText(payload.text, raw),
+                            ...(projectedRaw !== undefined ? { raw: projectedRaw } : {}),
                             ...(payload.reason !== undefined ? { reason: payload.reason } : {}),
                             ...(payload.recoverable === true
                                 ? { severity: 'warn' }
@@ -6443,14 +6537,16 @@ export class AUNChannelPlugin {
                         return;
                     }
                     case 'result.error': {
+                        const raw = truncateRawErrorForDisplay(payload.raw);
+                        const projectedRaw = projectedRawError(payload.raw, raw);
                         const errorPayload = {
                             type: 'error',
                             ...taskBase(),
-                            text: appendRawErrorText(payload.text, payload.raw),
+                            text: appendRawErrorText(payload.text, raw),
                         };
                         setIfDefined(errorPayload, 'subtype', payload.subtype);
                         setIfDefined(errorPayload, 'reason', payload.reason);
-                        setIfDefined(errorPayload, 'raw', payload.raw);
+                        setIfDefined(errorPayload, 'raw', projectedRaw);
                         await channel.sendReliableStructured(channelId, errorPayload, { ...(replyCtx ?? {}), suppressPeerMention: true }, payload.text);
                         return;
                     }
@@ -6776,6 +6872,16 @@ export class AUNChannelPlugin {
             },
             registerHooks(hookCtx) {
                 channel.setEventBus(hookCtx.eventBus);
+                // 话题改名通知消费器：直接改本端索引，不经过 Agent 队列。
+                channel.setThreadRenameHandler(async (input) => {
+                    const { ThreadService } = await import('../core/thread/thread-service.js');
+                    const service = new ThreadService(hookCtx.sessionManager);
+                    const result = await service.applyRemoteRename(input);
+                    const session = result.applied
+                        ? service.findInIndex(input.selfAid, input.peer, input.threadId)?.sessionId
+                        : undefined;
+                    return { applied: result.applied, reason: result.reason, sessionId: session };
+                });
                 if (channel.setOnChannelDown) {
                     channel.setOnChannelDown(() => {
                         hookCtx.eventBus.publish({