evolcore 0.0.34 → 0.0.35

package/dist/core/command/command-handler.js

@@ -2542,7 +2542,11 @@ export class CommandHandler {
             }
         }
         else {
-            if (!hasTrustedFullAccessDelegation(grant) && (grant.channelType !== 'aun' || grant.chatType !== 'private')) {
+            // `--thread` 是话题作用域读取：目标对端由话题推断，日志属于本 agent 自己，
+            // 所以既允许在群会话里发起，也允许读当前对端以外的话题历史。
+            const threadScoped = parsed.command.kind === 'history' && !!parsed.command.threadId;
+            if (!hasTrustedFullAccessDelegation(grant) && !threadScoped
+                && (grant.channelType !== 'aun' || grant.chatType !== 'private')) {
                 return { ok: false, code: 'SCOPE_MISMATCH', error: 'Managed msg reads require the current AUN private relation' };
             }
             // A management role may read history for any peer, one peer per query.
@@ -2551,6 +2555,7 @@ export class CommandHandler {
             // stay pinned here, and authorizeOperation below remains the authority
             // for every role (member carries currentRelationOnly; visitor is denied).
             const mayReadCrossPeer = hasTrustedFullAccessDelegation(grant)
+                || threadScoped
                 || (parsed.command.kind === 'history' && isAdminRole(grant.issuedRole ?? 'none'));
             if (!mayReadCrossPeer && parsed.command.target !== conversationId) {
                 return { ok: false, code: 'SCOPE_MISMATCH', error: 'Only the current AUN private relation can be targeted' };
@@ -2601,6 +2606,7 @@ export class CommandHandler {
                     ...(parsed.command.before !== undefined ? { before: parsed.command.before } : {}),
                     ...(parsed.command.after !== undefined ? { after: parsed.command.after } : {}),
                     ...(parsed.command.direction ? { direction: parsed.command.direction } : {}),
+                    ...(parsed.command.threadId ? { threadId: parsed.command.threadId } : {}),
                 },
             },
             auditMetadata: {

package/dist/core/command/menu-handler.js

@@ -1769,6 +1769,8 @@ export async function getSubMenuItems(cmd, channel, channelId, userId, args, ove
                 value: definition.id,
                 label: definition.name,
                 desc: `${view.scheduleType}${view.nextFireAt ? ` | 下次 ${new Date(view.nextFireAt).toLocaleString()}` : ''}`,
+                // 只有 trigger 有说明时才带上 description 字段，前端按需渲染
+                ...(definition.description ? { description: definition.description } : {}),
                 status: definition.enabled ? 'active' : 'disabled',
             };
         });

package/dist/core/command/topic-slash.js

@@ -474,18 +474,15 @@ async function summaryCommand(ctx, service, positional, flags, write) {
         }
         // 覆盖游标由 service 自动记录，无需传参
         const ifRev = typeof flags['if-rev'] === 'string' ? parseInt(flags['if-rev'], 10) : undefined;
-        const r = service.setSummary(ctx.selfAid, sessionId, content, Number.isFinite(ifRev) ? ifRev : undefined);
+        const r = await service.setSummary(ctx.selfAid, sessionId, content, Number.isFinite(ifRev) ? ifRev : undefined);
         const cursorNote = r.coveredThroughTs ? `，覆盖至 ${new Date(r.coveredThroughTs).toLocaleString('zh-CN')}` : '';
-        // --name：顺带改名。主会话没有话题名，跳过改名校验而不是报错。
+        // --name：顺带改名。主会话（threadId 为空）同样可以改，走 renameThread 的主会话分支。
         const rawName = flags.name.trim();
         const newName = rawName && rawName !== '-' ? rawName : undefined;
-        if (newName && !target.threadId) {
-            return result(`✅ summary 已写入（rev ${r.rev}${cursorNote}）\n（主会话没有话题名，--name 已忽略）`);
-        }
-        if (newName && target.threadId) {
+        if (newName) {
             try {
                 const renamed = await service.renameThread({
-                    selfAid: ctx.selfAid, peer: target.peer, threadId: target.threadId, name: newName,
+                    selfAid: ctx.selfAid, peer: target.peer, threadId: target.threadId ?? '', name: newName,
                 });
                 return result(`✅ summary 已写入（rev ${r.rev}${cursorNote}）\n`
                     + `✅ 话题已改名: ${renamed.name}`);

package/dist/core/event-catalog.js

@@ -173,6 +173,20 @@ const CATALOG = [
             { path: 'newName', type: 'string' },
         ],
     },
+    {
+        type: 'thread:renamed',
+        namespace: 'thread',
+        name: 'renamed',
+        description: '对端协议消息改写本端话题名',
+        fields: [
+            { path: 'sessionId', type: 'string', optional: true },
+            { path: 'peer', type: 'string' },
+            { path: 'threadId', type: 'string' },
+            { path: 'name', type: 'string' },
+            { path: 'nameUpdatedAt', type: 'number' },
+            { path: 'by', type: 'string' },
+        ],
+    },
     {
         type: 'session:forked',
         namespace: 'session',

package/dist/core/ipc-registration.js

@@ -125,8 +125,18 @@ export function registerDaemonIpc({ ipcServer, agentRegistry, agentDelegationReg
                     aid: params.from,
                     to: params.to,
                     scope: params.peerKind === 'group' ? 'group' : 'msg',
-                    payload: { type: 'topic-created', topicName: params.topicName, threadId: params.threadId },
+                    payload: {
+                        type: params.kind ?? 'topic-created',
+                        topicName: params.topicName,
+                        threadId: params.threadId,
+                        ...(params.nameUpdatedAt ? { nameUpdatedAt: params.nameUpdatedAt } : {}),
+                    },
                     thread: params.threadId,
+                    // 授权链需要托管上下文；宿主终端调用（localControl）没有 token，
+                    // 此时 originSessionId 为空，sendAunMsg 会拒绝——按尽力而为处理。
+                    ...(params.originSessionId ? { originSessionId: params.originSessionId } : {}),
+                    ...(params.delegationToken ? { delegationToken: params.delegationToken } : {}),
+                    ...(params.delegationCommandHash ? { delegationCommandHash: params.delegationCommandHash } : {}),
                 });
                 if (!sent?.ok)
                     throw new Error(sent?.error || 'Topic notification failed');

package/dist/core/memory/batch-meta.js

@@ -95,6 +95,7 @@ export function updateBatchMeta(batchDir, updates) {
             finishedAt: updates.finishedAt,
             success: updates.success,
             ...(updates.agentSessionId ? { agentSessionId: updates.agentSessionId } : {}),
+            ...(updates.failureReason ? { failureReason: updates.failureReason } : {}),
         };
         // 更新 feedback 正文
         let newBody = body;

package/dist/core/memory/consolidation-context.js

@@ -226,13 +226,50 @@ function fillCandidates(ctx, mode, forgetAfterDays) {
     else if (mode === 'forget') {
         const now = Date.now();
         const thresholds = { forgetAfterDays };
-        ctx.candidates = collectCandidates(source, thresholds, now)
-            .filter(info => isDueForReview(info, thresholds, now))
-            .map(info => ({
-            relPath: `consolidated/${info.name}`,
-            description: readFmValue(info.content, 'description') ?? info.name.replace(/\.md$/, ''),
-            tags: info.tags,
-        }));
+        // forget + scope=agent：扫描所有 relation 的 consolidated 目录，以及 agent 自身的 consolidated
+        if (ctx.scope === 'agent') {
+            ctx.candidates = [];
+            // ctx.consolidatedDir 是 agents/<selfAid>/personal/memory/consolidated，
+            // 往上走三级才是 agents/<selfAid>
+            const agentDir = path.dirname(path.dirname(path.dirname(ctx.consolidatedDir)));
+            const relationsRoot = path.join(agentDir, 'relations');
+            if (fs.existsSync(relationsRoot)) {
+                for (const peerKey of fs.readdirSync(relationsRoot)) {
+                    const consolidatedDir = path.join(relationsRoot, peerKey, 'memory', 'consolidated');
+                    if (fs.existsSync(consolidatedDir)) {
+                        const candidates = collectCandidates(consolidatedDir, thresholds, now)
+                            .filter(info => isDueForReview(info, thresholds, now))
+                            .map(info => ({
+                            relPath: `${peerKey}/consolidated/${info.name}`,
+                            description: readFmValue(info.content, 'description') ?? info.name.replace(/\.md$/, ''),
+                            tags: info.tags,
+                        }));
+                        ctx.candidates.push(...candidates);
+                    }
+                }
+            }
+            // agent 自身的 consolidated（原 ⑤b 拉起 forget/agent 的来源）
+            if (fs.existsSync(ctx.consolidatedDir)) {
+                const own = collectCandidates(ctx.consolidatedDir, thresholds, now)
+                    .filter(info => isDueForReview(info, thresholds, now))
+                    .map(info => ({
+                    relPath: `consolidated/${info.name}`,
+                    description: readFmValue(info.content, 'description') ?? info.name.replace(/\.md$/, ''),
+                    tags: info.tags,
+                }));
+                ctx.candidates.push(...own);
+            }
+        }
+        else {
+            // relation / owner 级 forget：只扫描当前层级的 consolidated
+            ctx.candidates = collectCandidates(source, thresholds, now)
+                .filter(info => isDueForReview(info, thresholds, now))
+                .map(info => ({
+                relPath: `consolidated/${info.name}`,
+                description: readFmValue(info.content, 'description') ?? info.name.replace(/\.md$/, ''),
+                tags: info.tags,
+            }));
+        }
     }
 }
 // ── 渲染 ────────────────────────────────────────────────────────────────────
@@ -262,15 +299,45 @@ function renderScopeSection(ctx, mode, threadFiles) {
         lines.push(`待整理的 note 在 \`${ctx.processingDir}\`（整理开始前已从 pending/ 整体移入，是本次的快照）。`);
     }
     else if (ctx.candidates) {
-        lines.push(`**候选记忆（${ctx.candidates.length} 条）** —— 只列路径与描述，按需读正文：`);
-        lines.push('');
-        if (ctx.candidates.length === 0) {
-            lines.push('（无候选）');
+        // forget + scope=agent：按 relation 分组展示
+        if (mode === 'forget' && ctx.scope === 'agent') {
+            const byRelation = new Map();
+            for (const c of ctx.candidates) {
+                const match = c.relPath.match(/^([^/\\]+)[/\\]consolidated[/\\]/);
+                const relation = match ? match[1] : 'unknown';
+                if (!byRelation.has(relation))
+                    byRelation.set(relation, []);
+                byRelation.get(relation).push(c);
+            }
+            lines.push(`**候选记忆（共 ${ctx.candidates.length} 条，分布在 ${byRelation.size} 个关系）** —— 只列路径与描述，按需读正文：`);
+            lines.push('');
+            if (ctx.candidates.length === 0) {
+                lines.push('（无候选）');
+            }
+            else {
+                for (const [relation, candidates] of byRelation) {
+                    lines.push(`#### relation: ${relation} (${candidates.length} 条)`);
+                    lines.push('');
+                    for (const c of candidates) {
+                        const tags = c.tags.length > 0 ? ` [${c.tags.join(', ')}]` : '';
+                        lines.push(`- \`${c.relPath}\`${tags} — ${c.description}`);
+                    }
+                    lines.push('');
+                }
+            }
         }
         else {
-            for (const c of ctx.candidates) {
-                const tags = c.tags.length > 0 ? ` [${c.tags.join(', ')}]` : '';
-                lines.push(`- \`${c.relPath}\`${tags} — ${c.description}`);
+            // 其他模式：直接列出候选
+            lines.push(`**候选记忆（${ctx.candidates.length} 条）** —— 只列路径与描述，按需读正文：`);
+            lines.push('');
+            if (ctx.candidates.length === 0) {
+                lines.push('（无候选）');
+            }
+            else {
+                for (const c of ctx.candidates) {
+                    const tags = c.tags.length > 0 ? ` [${c.tags.join(', ')}]` : '';
+                    lines.push(`- \`${c.relPath}\`${tags} — ${c.description}`);
+                }
             }
         }
     }
@@ -494,6 +561,22 @@ export function serializeConsolidationContext(input) {
         '',
         ...scopes.flatMap(ctx => [renderScopeSection(ctx, input.mode, threadFiles), '', '---', '']),
     ];
+    // 列出可读根（工具 path/file_path 参数必须落在这些路径内）
+    lines.push('', '**可读根（工具 path/file_path 参数必须落在这些路径内）**：');
+    lines.push('- 批次目录：`' + batchDir + '`');
+    for (const ctx of scopes) {
+        if (ctx.processingDir)
+            lines.push('- processingDir: `' + ctx.processingDir + '`');
+        if (ctx.consolidatedDir)
+            lines.push('- consolidatedDir: `' + ctx.consolidatedDir + '`');
+        if (ctx.indexPath)
+            lines.push('- indexPath: `' + ctx.indexPath + '`');
+    }
+    if (historyJsonlPath)
+        lines.push('- 消息流水: `' + historyJsonlPath + '`');
+    if (threadFiles && threadFiles.length > 0)
+        lines.push('- 话题快照: `' + path.join(batchDir, 'threads') + '`');
+    lines.push('', '---', '');
     if (input.mode === 'notes' && threadFiles && threadFiles.length > 0) {
         const threadsDir = path.join(batchDir, 'threads');
         lines.push('## 话题快照文件', '');

package/dist/core/memory/consolidation-trigger.js

@@ -379,19 +379,27 @@ export function checkConsolidationCandidates(params) {
             out.push({ mode: 'profile', peerKey, reason: '索引有变化且画像超期' });
         }
     }
-    // ⑤ 超期记忆 → forget（关系级）
+    // ⑤ 超期记忆 → forget（agent 级，扫描所有 relation + agent 自身，合并成一个会话）
+    let hasRelationForget = false;
     for (const peerKey of peerKeys) {
         const dir = path.join(relationMemoryDir(root, selfAid, peerKey), 'consolidated');
         const due = checkStale(dir, now, config.forgetAfterDays);
-        if (due > 0) {
-            out.push({ mode: 'forget', peerKey, scope: 'relation', reason: `${due} 条记忆超过审查周期（未续期）` });
-        }
+        if (due > 0)
+            hasRelationForget = true;
     }
-    // ⑤b 超期记忆 → forget（agent 级 / owner 级）
+    // ⑤b agent 自身的 consolidated 超期
     const agentConsolidated = path.join(root, 'agents', selfAid, 'personal', 'memory', 'consolidated');
-    if (config.enableAgent && checkStale(agentConsolidated, now, config.forgetAfterDays) > 0) {
-        out.push({ mode: 'forget', scope: 'agent', reason: 'agent 级记忆超期' });
+    const hasAgentForget = config.enableAgent && checkStale(agentConsolidated, now, config.forgetAfterDays) > 0;
+    // 只要有任意一层超期，起一个 forget scope=agent 会话，由会话内统一扫描
+    if (hasRelationForget || hasAgentForget) {
+        const parts = [];
+        if (hasRelationForget)
+            parts.push('关系级记忆超期');
+        if (hasAgentForget)
+            parts.push('agent 级记忆超期');
+        out.push({ mode: 'forget', scope: 'agent', reason: parts.join('、') });
     }
+    // ⑤c owner 级 forget 保持独立（owner 层与 agent/relation 层是平行的）
     if (config.enableOwner && ownerAid) {
         const ownerConsolidated = path.join(root, 'memory', 'owner', ownerAid, 'consolidated');
         if (checkStale(ownerConsolidated, now, config.forgetAfterDays) > 0) {

package/dist/core/memory/consolidation.js

@@ -13,6 +13,7 @@ import path from 'path';
 import { agentDir, resolveRoot } from '../../paths.js';
 import { serializeConsolidationContext } from './consolidation-context.js';
 import { assertSystemSessionLaunchable } from '../system-session/registry.js';
+import { resolveAgentLifecycle } from '../../config/lifecycle.js';
 import { ensureSessionRuntimeDir } from '../../cli/task-context.js';
 import { formatChannelKey } from '../channel-loader.js';
 import { logger } from '../../utils/logger.js';
@@ -48,6 +49,21 @@ function cleanupPreviousConsolidationBatches(_selfAid) {
         logger.warn(`[Memory] 清理整理批次时出错: ${e?.message}`);
     }
 }
+/**
+ * 首次设定（lifecycle）没完成的 agent 不能整理记忆：整理会话会被注入首次设定规则而拒绝干活，
+ * note 却照样被认领。返回拒绝原因；可以整理时返回 undefined。
+ * 直接读磁盘上的 config.json：首次设定完成时 lifecycle 就落在这里，不依赖内存里的注册表。
+ */
+export function consolidationBlockedReason(selfAid) {
+    const configPath = path.join(resolveRoot(), 'agents', selfAid, 'config.json');
+    const config = fs.existsSync(configPath)
+        ? JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+        : {};
+    const lifecycle = resolveAgentLifecycle(config);
+    if (lifecycle === 'active')
+        return undefined;
+    return `agent ${selfAid} 首次设定尚未完成（lifecycle=${lifecycle ?? String(config.lifecycle)}），完成后才能整理记忆`;
+}
 /**
  * 序列化上下文并直接创建整理会话。
  * 失败抛错，调用方负责决定是否记录诊断或回传错误。
@@ -64,6 +80,9 @@ export async function launchConsolidation(channel, params) {
     // 放在认领 processing 之前，拒绝时不留副作用。
     const systemSession = { type: 'memory', subtype: mode };
     assertSystemSessionLaunchable(systemSession, effectiveCtx.baseagent ?? 'claude');
+    const blockedReason = consolidationBlockedReason(selfAid);
+    if (blockedReason)
+        throw new Error(blockedReason);
     // 清理旧的整理批次（保留最新的一个历史）
     cleanupPreviousConsolidationBatches(selfAid);
     // notes 模式：pending/ → processing/ 快照迁移（在序列化上下文之前执行，声明认领）
@@ -213,6 +232,20 @@ function moveIntoDir(srcPath, destDir, stamp) {
     }
     fs.renameSync(srcPath, dest);
 }
+/** 本次整理认领到 processing/ 的 note 条数（收尾归位之前调用）。 */
+function countClaimedNotes(memoryDir) {
+    if (!memoryDir)
+        return 0;
+    const processingDir = path.join(memoryDir, 'processing');
+    try {
+        return fs.readdirSync(processingDir)
+            .filter(entry => entry.endsWith('.md') && fs.statSync(path.join(processingDir, entry)).isFile())
+            .length;
+    }
+    catch {
+        return 0;
+    }
+}
 function restorePendingNotes(memoryDir) {
     const processingDir = path.join(memoryDir, 'processing');
     if (!fs.existsSync(processingDir))
@@ -363,6 +396,17 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
             finalizedSessions.add(sessionId);
             releaseAid = session.selfAID;
             const { summarizeOpsRecords, collectAffectedScopes } = await import('./consolidation-ops-records.js');
+            // 会话正常结束不等于整理做完了。notes 模式认领了 note，却既没写记忆也没写反馈，
+            // 说明 agent 没处理这批 note（例如拒绝了任务）——按失败收尾，note 回 pending 下次重试。
+            let failureReason;
+            if (success && meta.memoryMode === 'notes' && countClaimedNotes(meta.consolidationMemoryDir) > 0) {
+                const ops = summarizeOpsRecords(batchDir);
+                if (ops.created + ops.updated + ops.archived === 0 && !readFeedbackText(batchDir)) {
+                    success = false;
+                    failureReason = '整理会话结束时没有写入任何记忆，也没有写反馈，note 未被处理';
+                    logger.warn(`[Memory] ${failureReason}（session=${sessionId}），按失败收尾`);
+                }
+            }
             if (!success) {
                 await rollbackConsolidation(batchDir, session.selfAID);
             }
@@ -478,6 +522,7 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
                     finishedAt: new Date().toISOString(),
                     success,
                     ...(session.agentSessionId ? { agentSessionId: session.agentSessionId } : {}),
+                    ...(failureReason ? { failureReason } : {}),
                     feedbackText: customText,
                 });
             }
@@ -497,6 +542,7 @@ export function createConsolidationSessionFinalizer({ sessionManager, getAgent,
                         success,
                         summary: summarizeOpsRecords(batchDir),
                         batchDir,
+                        failureReason,
                     });
                     await sendFeedback(feedbackOrigin, text, session.selfAID);
                 }
@@ -738,6 +784,10 @@ export function registerConsolidationLaunchExecutor({ ipcServer, enqueueConsolid
     ipcServer.setConsolidationLaunchExecutor(async (params) => {
         if (!params.taskCtx.selfAid)
             throw new Error('无法确定当前 agent AID（selfAid 为空）');
+        // 入队前就拦：拉起失败在队列里只会记成一句笼统的「拉起整理会话失败」
+        const blockedReason = consolidationBlockedReason(params.taskCtx.selfAid);
+        if (blockedReason)
+            throw new Error(blockedReason);
         const launched = await enqueueConsolidation(params);
         if (!launched)
             throw new Error('拉起整理会话失败，详见 daemon 日志');
@@ -752,6 +802,8 @@ export function registerConsolidationCheckExecutor({ ipcServer, agentRegistry, e
         const agentConfig = agentRegistry.get(selfAid)?.config;
         if (agentConfig?.memory?.enableRelation === false)
             return { launched: [] };
+        if (consolidationBlockedReason(selfAid))
+            return { launched: [] };
         const ownerAid = agentConfig?.owners?.[0];
         const agentCount = agentRegistry.runnableAgents().length;
         const relationsDir = path.join(agentDir(selfAid), 'relations');
@@ -808,6 +860,8 @@ export function registerRelationConsolidationEvents({ eventBus, agentRegistry, r
                 return;
             if (taskCtx.sessionType === 'memory')
                 return;
+            if (consolidationBlockedReason(taskCtx.selfAid))
+                return;
             const memoryConfig = agentRegistry.get(taskCtx.selfAid)?.config?.memory;
             if (memoryConfig?.enableRelation === false)
                 return;
@@ -872,6 +926,7 @@ export function renderDefaultConsolidationFeedback(input) {
             '',
             `**模式**：${mode}`,
             `**触发**：${cause}`,
+            ...(input.failureReason ? [`**原因**：${input.failureReason}`] : []),
             '',
             '本次整理未完成，已回退未归档的改动。详情见整理批次：',
             `\`${input.batchDir}\``,

package/dist/core/memory/memory-writer.js

@@ -50,8 +50,10 @@ export function resolveScopeDirs(scope, taskCtx, ownerAid, peerKeyOverride) {
 /**
  * 把用户给的路径解析成 consolidated/ 下的绝对路径。
  * 允许 slug / <slug>.md / 相对或绝对路径（须落在本作用域的 consolidated/ 内）。
+ *
+ * forget-agent 模式特殊处理：允许路径落在任意 relation 的 consolidated/ 下。
  */
-export function resolveConsolidatedPath(dirs, input) {
+export function resolveConsolidatedPath(dirs, input, taskCtx) {
     const base = path.resolve(dirs.consolidatedDir);
     const looksLikePath = input.includes('/') || input.includes('\\');
     if (!looksLikePath) {
@@ -66,6 +68,20 @@ export function resolveConsolidatedPath(dirs, input) {
         if (!rel.startsWith('..') && !path.isAbsolute(rel))
             return abs;
     }
+    // forget-agent 模式：允许路径落在任意 relation 的 consolidated/ 下，或 agent 自身的 consolidated/
+    const isForgetAgent = taskCtx?.memoryMode === 'forget' && taskCtx?.memoryScope === 'agent';
+    if (isForgetAgent && taskCtx?.selfAid) {
+        const relationsRoot = path.join(resolveRoot(), 'agents', taskCtx.selfAid, 'relations');
+        const absInput = path.resolve(input);
+        const relToRelations = path.relative(relationsRoot, absInput);
+        // 检查是否在某个 relation 的 consolidated/ 下
+        if (!relToRelations.startsWith('..') && !path.isAbsolute(relToRelations)) {
+            const parts = relToRelations.split(path.sep);
+            if (parts.length >= 3 && parts[1] === 'memory' && parts[2] === 'consolidated') {
+                return absInput;
+            }
+        }
+    }
     throw new Error(`ROLE_ACCESS_DENIED: 只能操作本作用域 consolidated/ 下的记忆（${base}），当前路径越界: ${input}`);
 }
 function assertSlug(slug) {
@@ -104,7 +120,7 @@ export async function createMemory(req) {
     const dirs = resolveScopeDirs(req.scope, req.taskCtx, req.ownerAid, req.targetPeerKey);
     fs.mkdirSync(dirs.consolidatedDir, { recursive: true });
     const targetPath = path.join(dirs.consolidatedDir, `${req.slug}.md`);
-    const replacePaths = (req.replaces ?? []).map(p => resolveConsolidatedPath(dirs, p));
+    const replacePaths = (req.replaces ?? []).map(p => resolveConsolidatedPath(dirs, p, req.taskCtx));
     // 撞名闸门：目标已存在且没被 --replaces 覆盖 → 拒绝
     if (fs.existsSync(targetPath) && !replacePaths.includes(targetPath)) {
         throw new Error(`SLUG_EXISTS: 目标已存在: ${targetPath}\n` +
@@ -264,7 +280,7 @@ export async function demoteMemory(req) {
 }
 export async function updateMemory(req) {
     const dirs = resolveScopeDirs(req.scope, req.taskCtx, req.ownerAid);
-    const filePath = resolveConsolidatedPath(dirs, req.target);
+    const filePath = resolveConsolidatedPath(dirs, req.target, req.taskCtx);
     if (!fs.existsSync(filePath))
         throw new Error(`找不到记忆文件: ${filePath}`);
     const document = readMemory(readVerifiedMemory(filePath));
@@ -286,7 +302,7 @@ export async function archiveMemory(req) {
     const dirs = resolveScopeDirs(req.scope, req.taskCtx, req.ownerAid);
     const archived = [];
     for (const t of req.targets) {
-        const p = resolveConsolidatedPath(dirs, t);
+        const p = resolveConsolidatedPath(dirs, t, req.taskCtx);
         if (!fs.existsSync(p))
             throw new Error(`找不到记忆文件: ${p}`);
         const dest = archivePath(dirs.memoryDir, p);

package/dist/core/message/aun-ipc-sender.js

@@ -28,7 +28,7 @@ export function createAunHandoffSender(sessionManager, channelInstances) {
         const log = {
             content: classified.content,
             sessionId: targetSession.id,
-            threadId: targetSession.threadId || null,
+            threadId: targetSession.threadId || '',
             msgType: classified.msgType,
             payloadType: classified.payloadType,
             payloadSummary: classified.payloadSummary,
@@ -267,6 +267,24 @@ export function registerAunIpcSender({ ipcServer, channelInstances, agentDelegat
         if (!payload) {
             return { ok: false, error: 'message payload is required', code: 'INVALID_PAYLOAD' };
         }
+        // 托管 argv 通道（runManagedSend）先前不带 log 元数据：群聊 sendDaemonGroupMsg
+        // 自身会写日志，私聊 sendDaemonMsg 只在 args.log 存在时才写，于是同一份
+        // `ec msg send` 在私聊下不落 messages.jsonl，话题历史里查不到已发出的消息。
+        // 这里在 payload 定型后按同一套规则补出日志元数据，让两条路径记账一致。
+        if (params.argv !== undefined && params.log === undefined) {
+            const classified = classifyAunPayloadForLog(payload);
+            params = {
+                ...params,
+                log: {
+                    content: classified.content,
+                    threadId: params.thread ?? '',
+                    msgType: classified.msgType,
+                    payloadType: classified.payloadType,
+                    payloadSummary: classified.payloadSummary,
+                    source: 'msg',
+                },
+            };
+        }
         try {
             if (Object.prototype.hasOwnProperty.call(payload, 'mentions')) {
                 payload = { ...payload, mentions: normalizeAunMentionEntries(payload.mentions) };

package/dist/core/message/message-bridge.js

@@ -1264,7 +1264,7 @@ export class MessageBridge {
                         appendMessageLog(chatDir, buildInboundEntry({
                             from: msg.peerId || 'unknown',
                             to: msg.selfAID || 'self',
-                            threadId: msg.threadId ?? null,
+                            threadId: msg.threadId ?? '',
                             chatType: msg.chatType || 'private',
                             groupId: msg.groupId ?? null,
                             msgId: msg.messageId ?? null,
@@ -1549,7 +1549,7 @@ export class MessageBridge {
                             from: msg.peerId || 'unknown',
                             to: msg.selfAID || 'self',
                             sessionId: session.id,
-                            threadId: session.threadId || null,
+                            threadId: session.threadId || '',
                             chatType,
                             groupId: msg.groupId ?? null,
                             msgId: msg.messageId ?? null,
@@ -1608,7 +1608,7 @@ export class MessageBridge {
                         const member = item.value;
                         appendMessageLog(inboundEntry.chatDir, buildInboundEntry({
                             from: item.sender, to: selfAid || '', sessionId: session.id,
-                            threadId: session.threadId || null, chatType: 'group', groupId: msg.groupId,
+                            threadId: session.threadId || '', chatType: 'group', groupId: msg.groupId,
                             msgId: item.messageId, content: member.messageLogContent ?? item.content,
                             permMode: item.role, timestamp: item.receivedAt,
                             receivedAt: member.receivedAt, gatewaySeq: member.gatewaySeq,

package/dist/core/message/message-log.js

@@ -21,6 +21,7 @@ const TRANSIENT_PROTOCOL_TYPES = new Set([
     'handoff_state',
     'handoff_result',
     'topic-created', // 话题创建系统消息，不进大模型上下文
+    'topic-renamed', // 话题改名通知，由 channel 层直接消费，不进大模型上下文
 ]);
 const KNOWN_AUN_PAYLOAD_TYPES = new Set([
     'text',

package/dist/core/message/peer-mode.js

@@ -31,6 +31,23 @@ export function resolveChatMode(params) {
         ? effectiveValue
         : chatmodeFactoryDefaults()[field];
 }
+/**
+ * 出站发送路径（`ec msg send` / daemon 私聊发送）用的最小判定。
+ *
+ * 这两条路径只有对端身份、拿不到角色，因此不能复用 `resolveChatMode` 的
+ * 分层配置。口径与 `resolveChatMode` 的硬约束保持一致：
+ *   - 非人类对端（isMachine）→ proactive
+ *   - 人类但角色未知 → proactive（保守侧）
+ *   - 人类且 owner/admin → interactive
+ *
+ * 角色未知时不能假设高信任：interactive 表示"输出即回复"的同步交互，
+ * 只应给已确认的管理者。
+ */
+export function chatmodeForPeerIdentity(identity, role) {
+    if (identity.isMachine)
+        return 'proactive';
+    return resolveChatMode({ role: role ?? undefined, chatType: 'private', peerType: identity.type ?? 'human' });
+}
 export function resolveChatModeForField(params) {
     return resolveChatMode({
         ...params,

package/dist/core/message/response-engine.js

@@ -933,8 +933,18 @@ function wasRetryInputAlreadySubmitted(error) {
     return !!(error && typeof error === 'object' && error[RETRY_INPUT_ALREADY_SUBMITTED_MARK] === true);
 }
 function formatRetryInputAlreadySubmittedMessage(error) {
-    const reason = getErrorRawText(error) || 'Codex 暂时不可用';
-    return `⚠️ Codex 已接收本次消息，但本轮未能确认完成。为避免在会话中重复写入同一消息，系统未自动重试。请检查会话状态后重新发送。\n原因：${reason}`;
+    const raw = getErrorRawText(error);
+    const record = error && typeof error === 'object' ? error : undefined;
+    const retryCount = typeof record?.codexRetryCount === 'number' && Number.isSafeInteger(record.codexRetryCount)
+        ? record.codexRetryCount : undefined;
+    const statusCode = raw?.match(/\b([45]\d{2})\b/)?.[1];
+    if (retryCount !== undefined && statusCode) {
+        return `⚠️ Codex 已重连 ${retryCount} 次模型服务后仍失败（${statusCode}）。本次执行已停止。`;
+    }
+    if (retryCount !== undefined) {
+        return `⚠️ Codex 已重连 ${retryCount} 次模型服务后仍失败。本次执行已停止。`;
+    }
+    return '⚠️ Codex 已接收本次消息，但模型服务请求失败。本次执行已停止。';
 }
 function isNonErrorInterruptReason(reason) {
     return reason === 'new_message'
@@ -4660,7 +4670,8 @@ export class ResponseEngine {
                         peerId: peerIdRaw || undefined,
                         peerKey,
                         peerName: peerName || undefined,
-                        peerRole,
+                        // 系统会话与角色体系无关：不给 peerRole，消息头就不渲染 `· role:` 段
+                        peerRole: systemSessionMarker ? undefined : peerRole,
                         // Display missing identity explicitly without changing the mode resolver's legacy fallback.
                         peerType: peerType || 'unknown',
                         sameDevice: message.sameDevice ?? false,
@@ -4794,7 +4805,7 @@ export class ResponseEngine {
                                 } : {}),
                                 peerId: message.peerId, peerName: peerName || undefined,
                                 peerType: message.peerType,
-                                peerRole: message.batchRole || session.identity?.role || 'none',
+                                peerRole: systemSessionMarker ? undefined : (message.batchRole || session.identity?.role || 'none'),
                                 sameDevice: message.sameDevice, sameNetwork: message.sameNetwork, sameEgressIp: message.sameEgressIp,
                                 encrypted: message.encrypted,
                                 content: message.content, timestamp: message.timestamp,