evolclaw 2.6.3 → 2.7.0

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

@@ -10,6 +10,7 @@ import { getErrorMessage, classifyError, ErrorType, ERROR_PREFIX, isInfraError,
 import { summarizeToolInput } from '../permission.js';
 import { getOwner } from '../../config.js';
 import { getPackageRoot, resolveRoot } from '../../paths.js';
+import { renderPromptSection } from '../../prompts/templates.js';
 /**
  * 统一消息处理器
  * 负责处理来自不同渠道的消息，协调事件流处理
@@ -129,7 +130,8 @@ export class MessageProcessor {
         '/new', '/pwd', '/plist', '/project', '/bind', '/help', '/status', '/restart',
         '/model', '/effort', '/agent', '/slist', '/session', '/rename', '/repair', '/fork',
         '/stop', '/clear', '/compact', '/safe', '/del', '/perm', '/file', '/check',
-        '/p ', '/s ', '/name ',
+        '/p ', '/s ', '/name ', '/rewind', '/rw', '/rw ', '/activity', '/chatmode',
+        '/aid', '/agentmd',
     ];
     /** 判断消息内容是否为已知命令 */
     isKnownCommand(content) {
@@ -192,6 +194,7 @@ export class MessageProcessor {
                                 logger.debug(`[MessageProcessor] Failed to send kill diagnostic message:`, e);
                             });
                         }
+                        logger.info(`[MessageProcessor] agent.interrupt invoked (idle-kill) stream=${streamKey}`);
                         agent.interrupt(streamKey).catch(e => {
                             logger.debug(`[MessageProcessor] Interrupt failed (may already be cleaned up):`, e);
                         });
@@ -313,7 +316,7 @@ export class MessageProcessor {
             const imageInfo = message.images && message.images.length > 0 ? ` [${message.images.length} image(s)]` : '';
             const modeInfo = isBackground ? ' [\u540e\u53f0]' : '';
             logger.info(`[${message.channel}] ${message.channelId}: ${message.content}${imageInfo}${modeInfo}`);
-            logger.info(`[MessageProcessor] session=${session.id} chatType=${session.chatType} sessionMode=${session.sessionMode} agentId=${session.agentId} msgChatType=${message.chatType ?? 'n/a'}`);
+            logger.info(`[MessageProcessor] session=${session.id} task=${taskId} chatType=${session.chatType} sessionMode=${session.sessionMode} agentId=${session.agentId} msgChatType=${message.chatType ?? 'n/a'}`);
             // 记录开始处理
             this.eventBus.publish({ type: 'message:processing', sessionId: session.id });
             adapter.sendProcessingStatus?.(message.channelId, 'start', session.id, taskId, this.getReplyContext(message));
@@ -353,6 +356,9 @@ export class MessageProcessor {
             }, (options?.flushDelay ?? this.config.flushDelay ?? 3) * 1000, options?.fileMarkerPattern, this.config.debug?.flusherDiag, isProactive);
             // 保存当前 flusher，用于 compact 事件
             this.currentFlusher = flusher;
+            if (isProactive) {
+                logger.info(`[MessageProcessor] proactive mode: flusher silent, outputs via thought.put task=${taskId}`);
+            }
             // Proactive 模式可观测：创建 ThoughtEmitter，将静默的流式事件转发为 thought
             // selector: context = { type: 'task', id: taskId }
             if (isProactive && adapter.putThought) {
@@ -379,12 +385,13 @@ export class MessageProcessor {
                     ? (sessionKey) => this.messageQueue.cancelIntercept(sessionKey)
                     : undefined,
             });
-            // 设置 per-session 权限模式（动态默认值：owner → bypass，admin → auto，guest → readonly）
+            // 设置 per-session 权限模式（动态默认值：owner → bypass，admin → auto，guest → auto）
             const role = session.identity?.role;
-            const defaultPermMode = role === 'owner' ? 'bypass' : role === 'admin' ? 'auto' : 'readonly';
+            const defaultPermMode = role === 'owner' ? 'bypass' : 'auto';
             agent.setMode(session.metadata?.permissionMode ?? defaultPermMode);
             // 标记会话为处理中（实时持久化，重启后可恢复）
             this.sessionManager.markProcessing(session.id);
+            logger.info(`[MessageProcessor] session ${session.id} marked as processing task=${taskId}`);
             // 检查是否因新消息自动中断 — 包装 prompt 让 Agent 知道上下文
             const prevInterruptReason = this.interruptedSessions.get(session.id);
             this.interruptedSessions.delete(session.id);
@@ -396,8 +403,7 @@ export class MessageProcessor {
                 // 动态构建运行时上下文提示
                 const contextParts = [];
                 const currentChannelType = options?.channelType || message.channel;
-                // 1. 当前环境信息
-                const peerLabel = session.identity?.role || 'unknown';
+                // 1. 构建模板变量并渲染 runtime 段
                 const peerName = message.peerName || session.metadata?.peerName;
                 const peerType = message.peerType;
                 const peerId = message.peerId;
@@ -411,52 +417,20 @@ export class MessageProcessor {
                 };
                 const selfIdentity = formatIdentity(selfName, selfAid);
                 const peerIdentity = formatIdentity(peerName, peerId);
-                const envParts = [
-                    `会话通道: ${currentChannelType}`,
-                    `当前项目: ${path.basename(absoluteProjectPath)}`,
-                ];
-                if (session.name)
-                    envParts.push(`会话名称: ${session.name}`);
-                if (selfIdentity)
-                    envParts.push(`当前名称: ${selfIdentity}`);
-                envParts.push(`对端身份: ${peerLabel}`);
-                if (peerIdentity)
-                    envParts.push(`对端名称: ${peerIdentity}`);
-                if (peerType && peerType !== 'unknown')
-                    envParts.push(`对端类型: ${peerType}`);
-                if (session.chatType)
-                    envParts.push(`聊天类型: ${session.chatType}`);
-                if (session.agentId && session.agentId !== 'claude')
-                    envParts.push(`当前Agent: ${session.agentId}`);
-                contextParts.push(`[当前环境] ${envParts.join(' | ')}`);
-                // 只读模式提示
-                if (session.metadata?.permissionMode === 'readonly') {
-                    const sendHint = isProactive
-                        ? '使用 evolclaw ctl file 发送'
-                        : '使用 [SEND_FILE:] 发送';
-                    contextParts.push(`[只读模式] 禁止修改项目文件。如需生成文件供用户下载，请写入 .evolclaw/tmp/ 目录后${sendHint}`);
-                }
-                // 2. 文件发送能力（按 channelType 去重，提示词只展示第一级通道名）
-                // proactive 模式：不推送 [SEND_FILE:] 提示，统一通过 evolclaw ctl file 显式发送（与 ctl send 契约一致）
+                // 文件发送能力（按 channelType 去重）
+                let crossChannelTypes = [];
+                let currentCanSend = false;
                 if (!isProactive) {
                     const fileChannelTypes = new Set();
-                    const currentCanSend = !!channelInfo.adapter.sendFile;
+                    currentCanSend = !!channelInfo.adapter.sendFile;
                     for (const [, info] of this.channels) {
                         if (info.adapter.sendFile) {
                             fileChannelTypes.add(info.options?.channelType || info.adapter.channelName);
                         }
                     }
-                    const crossChannelTypes = [...fileChannelTypes].filter(t => t !== currentChannelType);
-                    if (currentCanSend || crossChannelTypes.length > 0) {
-                        const hints = [];
-                        if (currentCanSend)
-                            hints.push(`[SEND_FILE:路径] 发送文件到当前通道`);
-                        if (crossChannelTypes.length > 0)
-                            hints.push(`[SEND_FILE:${crossChannelTypes[0]}:路径] 发送文件到指定通道（可用: ${crossChannelTypes.join('/')}）`);
-                        contextParts.push(hints.join('，'));
-                    }
+                    crossChannelTypes = [...fileChannelTypes].filter(t => t !== currentChannelType);
                 }
-                // 3. 当前通道能力
+                // 通道能力
                 const capParts = [];
                 if (options?.supportsImages)
                     capParts.push('图片输入');
@@ -464,30 +438,32 @@ export class MessageProcessor {
                     capParts.push('图片输出');
                 if (channelInfo.adapter.sendFile)
                     capParts.push('文件发送');
-                if (capParts.length > 0) {
-                    contextParts.push(`[通道能力] ${capParts.join('、')}`);
-                }
-                // 4. 群聊 @ 规则：告知 agent 应该 @ 谁，由 agent 自行在回复中添加
+                contextParts.push(renderPromptSection('runtime', {
+                    channel: currentChannelType,
+                    project: path.basename(absoluteProjectPath),
+                    sessionName: session.name || '',
+                    selfIdentity: selfIdentity || '',
+                    peerRole: session.identity?.role || 'unknown',
+                    peerIdentity: peerIdentity || '',
+                    peerType: peerType && peerType !== 'unknown' ? peerType : '',
+                    chatType: session.chatType || '',
+                    agent: session.agentId && session.agentId !== 'claude' ? session.agentId : '',
+                    readonly: session.metadata?.permissionMode === 'readonly',
+                    readonlySendHint: isProactive ? '使用 evolclaw ctl file 发送' : '使用 [SEND_FILE:] 发送',
+                    fileSendCurrent: !isProactive && currentCanSend,
+                    fileSendCross: !isProactive && crossChannelTypes.length > 0,
+                    crossPrimary: crossChannelTypes[0] || '',
+                    crossTypes: crossChannelTypes.join('/'),
+                    capability: capParts.length > 0,
+                    capabilities: capParts.join('、'),
+                }));
+                // 2. 群聊 @ 规则
                 if (message.chatType === 'group' && message.peerId) {
-                    contextParts.push(`[群聊回复规则] 回复时必须在开头添加 @${message.peerId} 来通知对方`);
+                    contextParts.push(renderPromptSection('group', { peerId: message.peerId }));
                 }
-                // 5. Agent ctl 自管理指令提示 + SKILLS.md 生成
-                // 暂时注释：排查 proactive 模式下 agent 未调用 Bash 工具的问题，
-                // 怀疑此段与 [Proactive 模式] 语义重合稀释了后者的权重
-                // if (!this.skillsEnsured) {
-                //   this.ensureSkillsFile();
-                //   this.skillsEnsured = true;
-                // }
-                // const skillsHint = this.getSkillsHint();
-                // if (skillsHint) {
-                //   contextParts.push(`[EvolClaw 自管理] ${skillsHint}`);
-                // }
-                // 6. Proactive 模式提示词：agent 的输出不会自动发送，必须主动调用 ctl send/file
+                // 3. Proactive 模式提示词
                 if (isProactive) {
-                    contextParts.push('[Proactive 模式] 本次对话中你的流式输出不会自动发送给用户，必须通过以下命令主动发送：\n' +
-                        '- 发送文本：evolclaw ctl send "<消息内容>"\n' +
-                        '- 发送文件：evolclaw ctl file <路径>\n' +
-                        '可多次调用。如不调用，用户将看不到任何回复。');
+                    contextParts.push(renderPromptSection('proactive', {}));
                 }
                 const effectiveSystemPrompt = [options?.systemPromptAppend, ...contextParts].filter(Boolean).join('\n') || undefined;
                 // 可重试错误（403/429/5xx）指数退避重试，最多 3 次
@@ -495,6 +471,7 @@ export class MessageProcessor {
                 for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
                     let streamRegistered = false;
                     try {
+                        logger.info(`[MessageProcessor] agent.runQuery start: agent=${agent.name} session=${session.id} task=${taskId} attempt=${attempt}/${MAX_RETRIES} agentSessionId=${session.agentSessionId ?? 'none'}`);
                         const stream = await agent.runQuery(session.id, effectivePrompt, absoluteProjectPath, session.agentSessionId, message.images, effectiveSystemPrompt, this.sessionManager);
                         agent.registerStream(streamKey, stream);
                         streamRegistered = true;
@@ -621,8 +598,23 @@ export class MessageProcessor {
             // 非 suppressed 且有流式文本：已经逐步推送过了，不重复添加
             //   但如果 flusher 既未发送过内容也没有 pending 内容（如 text 事件全为空），仍需兜底
             const finalReplyText = streamResult.lastReplyText || streamResult.fullText;
+            // 识别 Claude SDK 本地预处理兜底（如 "Unknown skill: xxx"）：
+            // 特征：无流式 text + complete.result 匹配已知模式
+            // 这类输出不是 agent 的回复意图，而是 SDK 本地拦截到的"未知斜杠命令"提示。
+            // Proactive 模式下 flusher silent，需要兜底发出以告知用户，否则用户完全无反馈。
+            const isSdkFallbackMessage = !!finalReplyText
+                && !streamResult.hasReceivedText
+                && /^Unknown skill:\s+\S+/i.test(finalReplyText.trim());
             if (finalReplyText) {
-                if (shouldSuppress()) {
+                if (isProactive && isSdkFallbackMessage) {
+                    // Proactive 模式 + SDK 本地兜底：直接 sendText 绕过 silent flusher
+                    const isCurrentlyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
+                    if (!isCurrentlyBackground) {
+                        await adapter.sendText(message.channelId, finalReplyText, capturedReplyContext);
+                        logger.info(`[MessageProcessor] proactive SDK fallback replied task=${taskId} text="${finalReplyText.slice(0, 60)}"`);
+                    }
+                }
+                else if (shouldSuppress()) {
                     flusher.addText(finalReplyText);
                 }
                 else if (!streamResult.hasReceivedText || (!flusher.hasSentContent() && !flusher.hasContent())) {
@@ -633,8 +625,10 @@ export class MessageProcessor {
             await flusher.flush(true);
             // 清理 activeStreams（正常完成）
             agent.cleanupStream(streamKey);
+            logger.info(`[MessageProcessor] agent.cleanupStream ok: session=${session.id} task=${taskId}`);
             // 清除处理中状态
             this.sessionManager.clearProcessing(session.id);
+            logger.info(`[MessageProcessor] session ${session.id} processing cleared task=${taskId}`);
             // 注意：不在此处清除 interruptedSessions，由下一条消息的 prompt 包装逻辑消费
             const interruptReason = this.interruptedSessions.get(session.id);
             if (streamResult.isError) {
@@ -708,8 +702,10 @@ export class MessageProcessor {
         catch (error) {
             // 清理流和处理中状态（异常时也要清除）
             agent.cleanupStream(streamKey);
+            logger.info(`[MessageProcessor] agent.cleanupStream ok (on error): session=${session.id} task=${taskId}`);
             try {
                 this.sessionManager.clearProcessing(session.id);
+                logger.info(`[MessageProcessor] session ${session.id} processing cleared (on error) task=${taskId}`);
             }
             catch { }
             // 注意：不在此处清除 interruptedSessions，由下一条消息的 prompt 包装逻辑消费
@@ -823,26 +819,52 @@ export class MessageProcessor {
                 // 每收到事件重置空闲超时
                 const toolName = event.type === 'tool_use' ? event.name : undefined;
                 resetTimer(event.type, toolName);
-                // 记录所有事件类型
-                logger.info(`[MessageProcessor] Event: type=${event.type}`);
+                // 记录事件类型：高价值事件（text/tool_use/tool_result/complete/error/compact/task_progress）INFO，
+                // 框架事件（session_id/state_changed/status）DEBUG
+                let eventDetail = '';
+                if (event.type === 'text' && event.text) {
+                    const preview = event.text.replace(/\s+/g, ' ').slice(0, 80);
+                    eventDetail = ` text="${preview}${event.text.length > 80 ? '…' : ''}"`;
+                }
+                else if (event.type === 'tool_use') {
+                    const input = event.input;
+                    const desc = input?.description
+                        || input?.file_path
+                        || input?.pattern
+                        || (typeof input?.command === 'string' ? input.command.slice(0, 80) : '')
+                        || (typeof input?.prompt === 'string' ? input.prompt.slice(0, 80) : '')
+                        || (typeof input?.query === 'string' ? input.query.slice(0, 80) : '')
+                        || '';
+                    eventDetail = ` tool=${event.name}${desc ? ` desc="${desc}"` : ''}`;
+                }
+                else if (event.type === 'tool_result') {
+                    eventDetail = ` tool=${event.name} ok=${!event.isError}`;
+                }
+                const frameworkEvents = new Set(['session_id', 'state_changed', 'status']);
+                if (frameworkEvents.has(event.type)) {
+                    logger.debug(`[MessageProcessor] Event: type=${event.type}${eventDetail}`);
+                }
+                else {
+                    logger.info(`[MessageProcessor] Event: type=${event.type}${eventDetail}`);
+                }
                 // Proactive 可观测：将事件实时透传为 thought（fire-and-forget）
                 if (thoughtEmitter) {
                     thoughtEmitter.emit(event).catch(() => { });
                 }
                 // session_id 已在 AgentRunner.transformStream 中处理，此处仅记录
                 if (event.type === 'session_id') {
-                    logger.info(`[MessageProcessor] Session ID updated: ${event.sessionId} for session: ${session.id}`);
+                    logger.debug(`[MessageProcessor] Session ID updated: ${event.sessionId} for session: ${session.id}`);
                     continue;
                 }
                 // session 状态变更（idle/running/requires_action）
                 if (event.type === 'state_changed') {
-                    logger.info(`[MessageProcessor] Session state: ${event.state} for session: ${session.id}`);
+                    logger.debug(`[MessageProcessor] Session state: ${event.state} for session: ${session.id}`);
                     this.eventBus.publish({ type: 'agent:state-changed', sessionId: session.id, state: event.state });
                     continue;
                 }
                 // agent 状态通知（仅事件，不直出给用户）
                 if (event.type === 'status') {
-                    logger.info(`[MessageProcessor] Agent status: ${event.subtype}: ${event.message}`);
+                    logger.debug(`[MessageProcessor] Agent status: ${event.subtype}: ${event.message}`);
                     this.eventBus.publish({
                         type: 'agent:status',
                         sessionId: session.id,
@@ -901,7 +923,6 @@ export class MessageProcessor {
                     }
                     // 工具结果
                     if (event.type === 'tool_result') {
-                        logger.debug(`[MessageProcessor] tool_result: name=${event.name}, is_error=${event.isError}`);
                         this.eventBus.publish({
                             type: 'tool:result',
                             sessionId: session.id,

package/dist/core/message/thought-emitter.js

@@ -23,6 +23,7 @@ export class ThoughtEmitter {
         this.channelId = channelId;
         this.taskId = taskId;
         this.chatmode = chatmode;
+        logger.info(`[ThoughtEmitter] created channel=${channelId} task=${taskId} chatmode=${chatmode}`);
     }
     async emit(event) {
         // 对齐 interactive 的 dedup：流式 text 已推过时，complete.result 不再重复发 summary

package/dist/core/session/session-manager.js

@@ -315,6 +315,26 @@ export class SessionManager {
                 logger.info(`✓ Migrated ${migrated} session(s): rootId normalized to replyContext`);
             }
         }
+        // Migration: readonly 模式已禁用，历史会话统一转为 auto
+        if (hasMetadata && tableInfo.length > 0) {
+            const rows = this.db.prepare(`SELECT id, metadata FROM sessions WHERE metadata IS NOT NULL AND metadata != ''`).all();
+            let migratedPerm = 0;
+            for (const row of rows) {
+                try {
+                    const meta = JSON.parse(row.metadata);
+                    if (meta.permissionMode === 'readonly' || meta.permissionMode === 'noask') {
+                        meta.permissionMode = 'auto';
+                        this.db.prepare('UPDATE sessions SET metadata = ? WHERE id = ?')
+                            .run(JSON.stringify(meta), row.id);
+                        migratedPerm++;
+                    }
+                }
+                catch { /* skip malformed JSON */ }
+            }
+            if (migratedPerm > 0) {
+                logger.info(`✓ Migrated ${migratedPerm} session(s): permissionMode → auto`);
+            }
+        }
         // 创建新表（首次初始化）
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS sessions (
@@ -451,7 +471,7 @@ export class SessionManager {
             session.identity = this.resolveIdentity(channel, userId);
             // 新话题会话补写默认权限模式
             if (session.metadata && !session.metadata.permissionMode) {
-                session.metadata.permissionMode = session.identity?.role === 'owner' ? 'bypass' : 'readonly';
+                session.metadata.permissionMode = session.identity?.role === 'owner' ? 'bypass' : 'auto';
                 this.db.prepare(`UPDATE sessions SET metadata = ?, updated_at = ? WHERE id = ?`)
                     .run(JSON.stringify(session.metadata), Date.now(), session.id);
             }
@@ -562,7 +582,7 @@ export class SessionManager {
         session.identity = this.resolveIdentity(channel, userId);
         // 写入默认权限模式（基于角色，只在首次创建时设置）
         if (!sessionMetadata.permissionMode) {
-            sessionMetadata.permissionMode = session.identity?.role === 'owner' ? 'bypass' : 'readonly';
+            sessionMetadata.permissionMode = session.identity?.role === 'owner' ? 'bypass' : 'auto';
         }
         this.insertSession(session);
         this.eventBus.publish({
@@ -661,6 +681,7 @@ export class SessionManager {
     }
     async switchProject(channel, channelId, newProjectPath, currentAgentId) {
         const agentId = currentAgentId || 'claude';
+        logger.info(`[SessionManager] switchProject: channel=${channel} channelId=${channelId} newPath=${newProjectPath} agent=${agentId}`);
         // 1. 继承当前 chatType（在 deactivate 之前读取）
         const inheritedChatType = this.getActiveChatType(channel, channelId);
         // 2. 取消当前活跃会话

package/dist/index.js

@@ -1,7 +1,7 @@
 import { ClaudeSessionFileAdapter } from './core/session/adapters/claude-session-file-adapter.js';
 import { CodexSessionFileAdapter } from './core/session/adapters/codex-session-file-adapter.js';
 import { GeminiSessionFileAdapter } from './core/session/adapters/gemini-session-file-adapter.js';
-import { loadConfig, ensureDataDirs, resolvePaths, resolveAnthropicConfig, isOwner, isAdmin, validateConfigIntegrity, validateChannelInstanceNames, getOwner, getChannelSessionMode } from './config.js';
+import { loadConfig, ensureDataDirs, resolvePaths, resolveAnthropicConfig, isOwner, isAdmin, validateConfigIntegrity, validateChannelInstanceNames, getOwner, getDefaultSessionMode } from './config.js';
 import { SessionManager } from './core/session/session-manager.js';
 import { ClaudeAgentPlugin } from './agents/claude-runner.js';
 import { CodexAgentPlugin } from './agents/codex-runner.js';
@@ -24,7 +24,9 @@ import { InteractionRouter } from './core/interaction-router.js';
 import { ChannelLoader } from './core/channel-loader.js';
 import { AgentLoader } from './core/agent-loader.js';
 import { IpcServer } from './ipc.js';
-import { logger } from './utils/logger.js';
+import { logger, setLogLevel } from './utils/logger.js';
+import { detectDuplicates } from './utils/channel-fingerprint.js';
+import { loadPromptTemplates } from './prompts/templates.js';
 import path from 'path';
 import fs from 'fs';
 async function main() {
@@ -48,8 +50,14 @@ async function main() {
     logger.info('EvolClaw starting...');
     // 确保数据目录存在
     ensureDataDirs();
+    // 加载提示词模板
+    loadPromptTemplates();
     // 加载配置
     const config = loadConfig();
+    // 应用配置中的日志级别（优先于环境变量）
+    if (config.debug?.logLevel) {
+        setLogLevel(config.debug.logLevel);
+    }
     const paths = resolvePaths();
     // 配置完整性校验
     const integrity = validateConfigIntegrity(config);
@@ -63,6 +71,14 @@ async function main() {
     logger.info('✓ Config loaded (API keys hidden)');
     // Channel instance name uniqueness check
     validateChannelInstanceNames(config);
+    // Detect duplicate channel credentials
+    const duplicates = detectDuplicates(config);
+    if (duplicates.length > 0) {
+        for (const d of duplicates) {
+            logger.warn(`⚠ Duplicate channel credential: ${d.fingerprint} is used by instances [${d.instances.join(', ')}]. ` +
+                `Only the first instance will be active.`);
+        }
+    }
     if (anthropic.baseUrl) {
         logger.info(`✓ Using custom API base URL: ${anthropic.baseUrl}`);
     }
@@ -73,28 +89,9 @@ async function main() {
     const statsCollector = new StatsCollector(eventBus);
     // 初始化数据库（带 ownerResolver）
     const sessionManager = new SessionManager(undefined, eventBus, (channel, userId) => isOwner(config, channel, userId), (channel, userId) => isAdmin(config, channel, userId));
-    // sessionMode 解析：通道配置锁定 > chatType 默认（AUN 群聊 → proactive，其余 → interactive）
-    sessionManager.setSessionModeResolver((channel, chatType) => {
-        const locked = getChannelSessionMode(config, channel);
-        if (locked)
-            return locked;
-        // chatType 默认值：仅 AUN 群聊默认为 proactive，其余通道默认 interactive
-        // channel 在多实例时为 instanceName，需要识别 AUN 系
-        // 简化：通过 ChannelOptions.channelType 在 MessageProcessor 注册时已知，但 SessionManager 不持有这个映射
-        // 这里回退到按 instanceName 反查 config.channels.aun
-        if (chatType === 'group') {
-            const aun = config.channels?.aun;
-            if (Array.isArray(aun)) {
-                if (aun.some((i) => i.name === channel))
-                    return 'proactive';
-            }
-            else if (aun) {
-                const effectiveName = aun.name ?? 'aun';
-                if (effectiveName === channel)
-                    return 'proactive';
-            }
-        }
-        return undefined;
+    // sessionMode 解析：全局 chatmode 配置 > 默认 'interactive'
+    sessionManager.setSessionModeResolver((_channel, chatType) => {
+        return getDefaultSessionMode(config, chatType);
     });
     logger.info('✓ Database initialized');
     // 注册会话文件适配器（Claude / Codex 各自的会话文件操作）
@@ -240,7 +237,9 @@ async function main() {
                 await handler({
                     channel: channelType, channelId: chatId, content, images, chatType,
                     peerId: peerId || '', peerName, messageId, mentions, threadId,
-                    replyContext: rootId ? { replyToMessageId: rootId, replyInThread: !!threadId } : undefined,
+                    // 只在话题场景（threadId 有值）才设置 replyContext；
+                    // 纯引用回复（rootId 有值但无 threadId）不设置，避免所有回复都带引用头
+                    replyContext: threadId ? { replyToMessageId: rootId, replyInThread: true } : undefined,
                 });
             }), (channelId, text, replyContext) => inst.channel.sendMessage(channelId, text, {
                 replyToMessageId: replyContext?.replyToMessageId,

package/dist/prompts/templates.js

@@ -0,0 +1,122 @@
+import fs from 'fs';
+import path from 'path';
+import { getPackageRoot, resolveRoot } from '../paths.js';
+import { logger } from '../utils/logger.js';
+const KNOWN_SECTIONS = new Set(['runtime', 'group', 'proactive']);
+const SECTION_RE = /^##\s+(\w+)\s*$/;
+let sections = null;
+let builtinSections = null;
+function parseTemplate(content) {
+    const result = new Map();
+    let currentSection = null;
+    let currentLines = [];
+    for (const line of content.split('\n')) {
+        // Stop parsing at horizontal rule separator (documentation follows)
+        if (/^---\s*$/.test(line)) {
+            if (currentSection) {
+                result.set(currentSection, currentLines.join('\n').trim());
+            }
+            break;
+        }
+        const m = line.match(SECTION_RE);
+        if (m) {
+            if (currentSection) {
+                result.set(currentSection, currentLines.join('\n').trim());
+            }
+            const name = m[1];
+            if (KNOWN_SECTIONS.has(name)) {
+                currentSection = name;
+                currentLines = [];
+            }
+            else {
+                currentSection = null;
+                currentLines = [];
+            }
+        }
+        else if (currentSection) {
+            currentLines.push(line);
+        }
+    }
+    if (currentSection) {
+        result.set(currentSection, currentLines.join('\n').trim());
+    }
+    return result;
+}
+function loadBuiltinTemplate() {
+    const builtinPath = path.join(getPackageRoot(), 'dist', 'templates', 'prompts.md');
+    const srcPath = path.join(getPackageRoot(), 'src', 'templates', 'prompts.md');
+    const filePath = fs.existsSync(builtinPath) ? builtinPath : srcPath;
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return parseTemplate(content);
+}
+export function loadPromptTemplates() {
+    builtinSections = loadBuiltinTemplate();
+    const userPath = path.join(resolveRoot(), 'data', 'prompts.md');
+    if (fs.existsSync(userPath)) {
+        try {
+            const content = fs.readFileSync(userPath, 'utf-8');
+            const parsed = parseTemplate(content);
+            sections = new Map(builtinSections);
+            for (const [key, value] of parsed) {
+                sections.set(key, value);
+            }
+            logger.info(`[PromptTemplates] Loaded user override: ${userPath}`);
+        }
+        catch (err) {
+            logger.warn(`[PromptTemplates] Failed to load user override (${userPath}), using builtin:`, err);
+            sections = builtinSections;
+        }
+    }
+    else {
+        sections = builtinSections;
+        logger.info(`[PromptTemplates] Using builtin templates`);
+    }
+    for (const name of KNOWN_SECTIONS) {
+        if (!sections.has(name)) {
+            logger.warn(`[PromptTemplates] Section "${name}" missing, using builtin fallback`);
+            const fallback = builtinSections.get(name);
+            if (fallback)
+                sections.set(name, fallback);
+        }
+    }
+}
+function isTruthy(val) {
+    if (val === undefined || val === null || val === false || val === '' || val === 0)
+        return false;
+    return true;
+}
+function renderTemplate(template, vars) {
+    // Pass 1: conditional sections {{?key}}...{{/}}
+    let result = template.replace(/\{\{\?(\w+)\}\}([\s\S]*?)\{\{\/\}\}/g, (_match, key, body) => {
+        return isTruthy(vars[key]) ? body : '';
+    });
+    // Pass 2: variable substitution {{key}}
+    result = result.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+        const val = vars[key];
+        if (!isTruthy(val))
+            return '';
+        return String(val);
+    });
+    // Pass 3: remove blank lines
+    return result.split('\n').filter(line => line.trim() !== '').join('\n');
+}
+export function renderPromptSection(section, vars) {
+    if (!sections)
+        loadPromptTemplates();
+    const template = sections.get(section);
+    if (!template) {
+        logger.warn(`[PromptTemplates] Section "${section}" not found`);
+        return '';
+    }
+    return renderTemplate(template, vars);
+}
+/** Reset loaded templates (for testing) */
+export function _resetTemplates() {
+    sections = null;
+    builtinSections = null;
+}
+/** Load templates from a raw string (for testing) */
+export function _loadFromString(content) {
+    builtinSections = parseTemplate(content);
+    sections = builtinSections;
+}