evolclaw 3.2.0 → 3.3.0

package/dist/core/message/pending-hints.js

@@ -0,0 +1,232 @@
+// 观察者插话：待用提示（pending-hints）存储。
+//
+// owner 经 observer.inject 给「agent↔对端」会话预埋的提示，落盘为 append-only jsonl，
+// 在下一条对端消息到达、渲染该轮 prompt 时一次性消费、注入渲染层。
+// 详见 docs/observer-insert-design.md 第一部分（§1.3 文件生命周期 / §1.4 thread 作用域）。
+//
+// 文件：sessions/<channelType>/<selfAID>/<对端>/pending-hints.jsonl（与 messages.jsonl 同级）
+// 每行一个事件：
+//   { action:'add',    id, text, threadId, ownerAid, ts }
+//   { action:'remove', targetId?, threadId, ts }   // 无 targetId = 撤该 thread 全部
+//
+// 生命周期 = 一个消费周期（按 (对端,thread) 维度）：
+//   - add/remove 追加行（append-only，处理「加了又撤」的竞态：按时间序回放抵消）
+//   - consume（对端消息到达触发）：回放算「该 thread」有效集 → 返回 → 清掉该 thread 的事件。
+//     · 若文件里其它 thread 仍有未消费提示 → 重写文件只留它们（不误删别的 thread）。
+//     · 否则（无其它 thread 残留）→ 删整个文件。
+//   - 因为 consume 一次性用掉该 thread 的全部有效提示，消费后该 thread 有效集必然归零，
+//     未来状态不依赖消费前历史，故消费即清安全，无需 consume 事件行。
+//   - 任何让「整文件」有效集归零的操作都删文件：consume 后无残留即删；remove 把提示全撤光也删。
+import fs from 'fs';
+import path from 'path';
+import { chatDirPath, appendJsonl, readAllJsonlLines } from '../session/session-fs-store.js';
+import { logger } from '../../utils/logger.js';
+const PENDING_HINTS_FILE = 'pending-hints.jsonl';
+function hintsPath(sessionsDir, channelType, channelId, selfAID) {
+    return path.join(chatDirPath(sessionsDir, channelType, channelId, selfAID), PENDING_HINTS_FILE);
+}
+/** 归一 threadId：undefined/null → ''（主线程）。 */
+function normThread(threadId) {
+    return threadId || '';
+}
+/**
+ * 追加一条 add 事件。返回是否写盘成功（供 ack 判定）。
+ * 写盘成功后才回 ack(accepted)——accepted 真正代表"已持久保存"。
+ */
+export function appendHintAdd(sessionsDir, channelType, channelId, selfAID, hint) {
+    try {
+        const fp = hintsPath(sessionsDir, channelType, channelId, selfAID);
+        fs.mkdirSync(path.dirname(fp), { recursive: true });
+        const ev = {
+            action: 'add', id: hint.id, text: hint.text,
+            threadId: normThread(hint.threadId), ownerAid: hint.ownerAid, ts: hint.ts,
+        };
+        appendJsonl(fp, ev);
+        return true;
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] appendHintAdd failed: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+    }
+}
+/**
+ * 追加一条 remove 事件。若该操作使 (对端,thread) 有效集归零，则删除整个文件。
+ * 返回是否写盘成功（供 ack 判定）。
+ */
+export function appendHintRemove(sessionsDir, channelType, channelId, selfAID, rm) {
+    try {
+        const fp = hintsPath(sessionsDir, channelType, channelId, selfAID);
+        if (!fs.existsSync(fp))
+            return true; // 无文件 = 无可撤，幂等成功
+        fs.mkdirSync(path.dirname(fp), { recursive: true });
+        const ev = {
+            action: 'remove', threadId: normThread(rm.threadId), ts: rm.ts,
+            ...(rm.targetId ? { targetId: rm.targetId } : {}),
+        };
+        appendJsonl(fp, ev);
+        // 撤销后：若全部 thread 的有效集都归零，删文件（不堆死文件）。
+        if (!hasAnyEffective(fp))
+            deleteFile(fp);
+        return true;
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] appendHintRemove failed: ${e instanceof Error ? e.message : String(e)}`);
+        return false;
+    }
+}
+/** 回放整个文件，返回是否还存在任意 thread 的有效提示。 */
+function hasAnyEffective(fp) {
+    const events = readAllJsonlLines(fp);
+    // 按 thread 分组回放
+    const byThread = new Map();
+    for (const ev of events) {
+        const t = normThread(ev.threadId);
+        (byThread.get(t) ?? byThread.set(t, []).get(t)).push(ev);
+    }
+    for (const [, evs] of byThread) {
+        if (replayEffective(evs).length > 0)
+            return true;
+    }
+    return false;
+}
+/** 对单个 thread 的事件序列回放，算出有效提示集（已 add、未被 remove，按 ts 升序）。 */
+function replayEffective(events) {
+    const sorted = events.slice().sort((a, b) => a.ts - b.ts);
+    const active = new Map(); // id → hint，保插入序
+    for (const ev of sorted) {
+        if (ev.action === 'add') {
+            active.set(ev.id, { id: ev.id, text: ev.text, ownerAid: ev.ownerAid, ts: ev.ts });
+        }
+        else {
+            if (ev.targetId)
+                active.delete(ev.targetId);
+            else
+                active.clear(); // 无 targetId = 撤该 thread 全部
+        }
+    }
+    return [...active.values()].sort((a, b) => a.ts - b.ts);
+}
+/**
+ * 消费 (对端, thread) 的有效提示：回放算「该 thread」有效集 → 返回 → 清掉该 thread。
+ *
+ * thread 隔离：只消费传入 threadId（归一后）的提示。若文件里其它 thread 仍有未消费提示，
+ * 重写文件保留它们；只有当整文件再无任何有效提示时才删除文件。
+ * 返回空数组表示该 thread 无有效提示（调用方据此决定是否注入）。
+ */
+export function consumeHints(sessionsDir, channelType, channelId, selfAID, threadId) {
+    const fp = hintsPath(sessionsDir, channelType, channelId, selfAID);
+    if (!fs.existsSync(fp))
+        return [];
+    let all;
+    try {
+        all = readAllJsonlLines(fp);
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] consume read failed: ${e instanceof Error ? e.message : String(e)}`);
+        return [];
+    }
+    const wantThread = normThread(threadId);
+    const sameThread = all.filter(ev => normThread(ev.threadId) === wantThread);
+    const effective = replayEffective(sameThread);
+    // 其它 thread 仍有未消费提示？若有，重写文件只留它们；否则删整个文件。
+    const otherThreadEvents = all.filter(ev => normThread(ev.threadId) !== wantThread);
+    if (otherThreadEvents.length > 0 && hasEffectiveInEvents(otherThreadEvents)) {
+        rewriteFile(fp, otherThreadEvents);
+    }
+    else {
+        deleteFile(fp);
+    }
+    return effective;
+}
+/** events（可能跨多 thread）中是否存在任意有效提示。 */
+function hasEffectiveInEvents(events) {
+    const byThread = new Map();
+    for (const ev of events) {
+        const t = normThread(ev.threadId);
+        (byThread.get(t) ?? byThread.set(t, []).get(t)).push(ev);
+    }
+    for (const [, evs] of byThread) {
+        if (replayEffective(evs).length > 0)
+            return true;
+    }
+    return false;
+}
+function rewriteFile(fp, events) {
+    try {
+        const body = events.map(e => JSON.stringify(e)).join('\n') + '\n';
+        fs.writeFileSync(fp, body);
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] rewriteFile failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+function deleteFile(fp) {
+    try {
+        if (fs.existsSync(fp))
+            fs.unlinkSync(fp);
+    }
+    catch (e) {
+        logger.warn(`[PendingHints] deleteFile failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+/** 仅供 watch / 调试：读出当前 (对端,thread) 有效提示，不消费、不删文件。 */
+export function peekHints(sessionsDir, channelType, channelId, selfAID, threadId) {
+    const fp = hintsPath(sessionsDir, channelType, channelId, selfAID);
+    if (!fs.existsSync(fp))
+        return [];
+    try {
+        const all = readAllJsonlLines(fp);
+        const wantThread = normThread(threadId);
+        return replayEffective(all.filter(ev => normThread(ev.threadId) === wantThread));
+    }
+    catch {
+        return [];
+    }
+}
+// ── 渲染接线纯函数（无 IO，便于单测） ──────────────────────────
+/** 把有效提示转成 owner-hint SubMessage（排在对端真实 item 之前，走 inject 渲染模式）。 */
+export function hintsToSubMessages(hints) {
+    return hints.map(h => ({
+        kind: 'owner-hint',
+        content: h.text,
+        ownerAid: h.ownerAid,
+        injectTime: h.ts,
+        timestamp: h.ts,
+    }));
+}
+/**
+ * 渲染失败兜底：把已消费的 owner-hint（提示已从 pending 删除、不可恢复）以纯文本前缀
+ * 拼到对端原文之前，避免提示被静默丢弃。仅在 renderMessageBody 抛错或产出空时使用。
+ */
+export function composeHintFallback(hintItems, content) {
+    if (!hintItems || hintItems.length === 0)
+        return content;
+    const lines = hintItems.map(h => `‹owner 提示·已验证›（仅你可见，对端无感）\n${h.content}`);
+    return [...lines, content].join('\n\n');
+}
+/**
+ * 解析 observer.inject payload：鉴权（from∈owners）+ 校验（add 需 channel_id+text；remove 需 channel_id）
+ * + 归一字段。纯函数，无副作用——落盘 / ack / watch 由调用方按结果执行。
+ * @param ts 用于 add 缺省 id（`inj-<ts>`）；由调用方传入便于测试确定性。
+ */
+export function parseInjectRequest(payload, fromAid, owners, ts) {
+    const p = (payload && typeof payload === 'object') ? payload : {};
+    const injectId = typeof p.id === 'string' ? p.id : undefined;
+    const action = p.action === 'remove' ? 'remove' : 'add';
+    if (!owners.includes(fromAid)) {
+        return { kind: 'reject', code: 'NOT_OWNER', message: '仅 owner 可插话', action, injectId };
+    }
+    const target = (p.target && typeof p.target === 'object') ? p.target : undefined;
+    const channelId = target && typeof target.channel_id === 'string' ? target.channel_id : undefined;
+    const text = typeof p.text === 'string' ? p.text : '';
+    if (!channelId || (action === 'add' && !text.trim())) {
+        return { kind: 'reject', code: 'INVALID_TARGET', message: 'target.channel_id 必填；add 还需 text', action, injectId };
+    }
+    const chatType = target?.chat_type === 'group' ? 'group' : 'private';
+    const threadId = typeof target?.thread_id === 'string' ? target.thread_id : undefined;
+    const targetId = typeof p.target_id === 'string' ? p.target_id : undefined;
+    if (action === 'remove') {
+        return { kind: 'remove', injectId, channelId, chatType, threadId, targetId };
+    }
+    return { kind: 'add', injectId, id: injectId || `inj-${ts}`, text, channelId, chatType, threadId, ownerAid: fromAid };
+}

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

@@ -0,0 +1,56 @@
+import crypto from 'crypto';
+/**
+ * 计算消息内容的话题指纹（前 20 字符的 md5 前 8 位）。
+ */
+export function computeTopicHash(content) {
+    const slice = content.trim().slice(0, 20);
+    return crypto.createHash('md5').update(slice).digest('hex').slice(0, 8);
+}
+/**
+ * 群聊响应深度决策（纯函数，无 I/O）。
+ *
+ * 根据 dispatch 模式、消息特征（长度/是否问句/是否被@）、话题轮次综合判断。
+ * 返回 depth 枚举 + 更新后的话题追踪状态（调用方负责持久化）。
+ */
+export function resolveResponseDepth(input) {
+    const { chatType, content, selfAid, mentionAids, dispatch, topicRounds: prevRounds, lastTopicHash } = input;
+    // 仅群聊走深度决策；私聊一律 standard
+    if (chatType !== 'group') {
+        return { depth: 'standard', topicRounds: prevRounds, topicHash: lastTopicHash || '' };
+    }
+    const trimmed = content.trim();
+    // ── 话题追踪：更新 topicRounds ──
+    const topicHash = computeTopicHash(trimmed);
+    let topicRounds;
+    if (lastTopicHash && lastTopicHash === topicHash) {
+        topicRounds = prevRounds + 1;
+    }
+    else {
+        topicRounds = 1;
+    }
+    // ── 判断因子 ──
+    const isMentioned = !!(selfAid && mentionAids?.includes(selfAid));
+    const isQuestion = /[？?]\s*$/.test(trimmed) || /^(what|how|why|when|where|who|which|请问|怎么|为什么|什么|如何|能不能|可以)/i.test(trimmed);
+    const isShort = trimmed.length <= 30;
+    // ── 决策逻辑 ──
+    // 被@：至少 standard；话题深入则升 deep
+    if (isMentioned) {
+        const depth = topicRounds >= 3 ? 'deep' : 'standard';
+        return { depth, topicRounds, topicHash };
+    }
+    // broadcast 模式：短消息 + 非问句 → lightweight
+    if (dispatch === 'broadcast') {
+        let depth;
+        if (topicRounds >= 3)
+            depth = 'deep';
+        else if (isShort && !isQuestion)
+            depth = 'lightweight';
+        else
+            depth = 'standard';
+        return { depth, topicRounds, topicHash };
+    }
+    // mention 模式下到达这里说明已通过 dispatch 过滤（被@才入队），
+    // 等同于 isMentioned === true 的分支。兜底 standard。
+    const depth = topicRounds >= 3 ? 'deep' : 'standard';
+    return { depth, topicRounds, topicHash };
+}

package/dist/core/model/model-catalog.js

@@ -10,7 +10,7 @@
  * 详见 docs/model-command-design.md。
  */
 import { loadDefaults, loadAgent } from '../../config-store.js';
-import { resolveAnthropicConfig, resolveOpenaiConfig } from '../../agents/resolve.js';
+import { resolveAnthropicConfig, resolveOpenaiConfig } from '../../agents/baseagent.js';
 import { activeBaseagent } from './model-scope.js';
 /** 取指定 baseagent 的 baseUrl + apiKey（复用现有解析链）。 */
 function resolveCreds(self, ba) {

package/dist/core/model/model-scope.js

@@ -18,8 +18,8 @@ import fs from 'fs';
 import path from 'path';
 import { agentRelationsDir, agentConfig as agentConfigPath, resolvePaths } from '../../paths.js';
 import { loadDefaults, saveDefaultsSafe, loadAgent, saveAgent } from '../../config-store.js';
-import { formatPeerKey, parsePeerKey } from '../relation/peer-key.js';
-import { fileCache } from '../cache/file-cache.js';
+import { formatPeerKey, parsePeerKey } from '../relation/peer-identity.js';
+import { fileCache } from '../daemon-file-cache.js';
 // ── mtime 门控缓存（统一走 FileCache）─────────────────────────────────────
 //
 // resolveEffectiveModel 每条消息按 关系>agent>全局 解析，原本每次都

package/dist/core/permission.js

@@ -217,7 +217,6 @@ function formatEditSummary(input) {
 }
 export class PermissionGateway {
     pending = new Map();
-    timeout = 5 * 60 * 1000;
     eventBus;
     /** 始终允许的工具缓存：toolName → Set<pattern> */
     alwaysAllow = new Map();
@@ -283,6 +282,14 @@ export class PermissionGateway {
         };
         // 尝试富交互（走统一 adapter.send 入口）
         let interactionSent = false;
+        if (context?.flushPending) {
+            try {
+                await context.flushPending();
+            }
+            catch {
+                // flush 失败不应阻断权限请求发送
+            }
+        }
         if (context?.adapter && context.channelId) {
             try {
                 const envelope = buildEnvelope({
@@ -306,15 +313,7 @@ export class PermissionGateway {
             await sendPrompt(renderActionAsText(interaction));
         }
         return new Promise((resolve) => {
-            const timer = setTimeout(() => {
-                const pending = this.pending.get(requestId);
-                if (!pending)
-                    return;
-                this.pending.delete(requestId);
-                this.eventBus?.publish({ type: 'permission:timeout', sessionId, requestId, toolName });
-                pending.resolve('deny');
-            }, this.timeout);
-            this.pending.set(requestId, { sessionId, toolName, resolve, timer });
+            this.pending.set(requestId, { sessionId, toolName, resolve });
             // 注册到 InteractionRouter（卡片和文本降级都注册，统一路由）
             if (context?.interactionRouter) {
                 context.interactionRouter.register(requestId, sessionId, (action) => {
@@ -327,7 +326,6 @@ export class PermissionGateway {
         const pending = this.pending.get(requestId);
         if (!pending || pending.sessionId !== sessionId)
             return false;
-        clearTimeout(pending.timer);
         // 如果是 always，缓存该工具
         if (decision === 'always') {
             this.addAlwaysAllow(pending.toolName);
@@ -341,7 +339,6 @@ export class PermissionGateway {
     cancelAll(sessionId) {
         for (const [requestId, pending] of this.pending.entries()) {
             if (pending.sessionId === sessionId) {
-                clearTimeout(pending.timer);
                 pending.resolve('deny');
                 this.pending.delete(requestId);
             }

package/dist/core/relation/peer-identity.js

@@ -15,7 +15,22 @@ import * as path from 'path';
 import * as crypto from 'crypto';
 import { logger } from '../../utils/logger.js';
 import { agentMdPath } from '../../paths.js';
-import { formatPeerKey } from './peer-key.js';
+/**
+ * peerKey: 关系层路由键，格式 `<channelType>#<urlEncode(channelId)>`。
+ * 群聊场景下 channelId = groupId，所有发言者共用同一个 peerKey。
+ */
+export function formatPeerKey(channelType, channelId) {
+    return `${channelType}#${encodeURIComponent(channelId)}`;
+}
+export function parsePeerKey(key) {
+    const idx = key.indexOf('#');
+    if (idx <= 0)
+        throw new Error(`Invalid peer key: ${key}`);
+    return {
+        channelType: key.slice(0, idx),
+        channelId: decodeURIComponent(key.slice(idx + 1)),
+    };
+}
 /**
  * 对端身份缓存管理器
  */

package/dist/core/session/adapters/codex-session-file-adapter.js

@@ -10,12 +10,14 @@
  * 会返回空数组。
  */
 import { createRequire } from 'module';
+import { sanitizeSessionTitle } from '../session-title.js';
 import { logger } from '../../../utils/logger.js';
 import path from 'path';
 import fs from 'fs';
 import os from 'os';
 const requireFromHere = createRequire(import.meta.url);
 let sqliteModule; // undefined = not tried, null = unavailable
+export const sanitizeCodexThreadTitle = sanitizeSessionTitle;
 function loadSqlite() {
     if (sqliteModule !== undefined)
         return sqliteModule;
@@ -127,7 +129,7 @@ export class CodexSessionFileAdapter {
                 if (row) {
                     return {
                         turns: this.countTurnsFromRollout(row.rollout_path),
-                        title: row.title || undefined,
+                        title: sanitizeCodexThreadTitle(row.title),
                     };
                 }
             }
@@ -210,7 +212,7 @@ export class CodexSessionFileAdapter {
             const rows = db.prepare('SELECT id, title FROM threads WHERE cwd = ? AND archived = 0 ORDER BY updated_at DESC').all(projectPath);
             return rows.map(r => ({
                 sessionId: r.id,
-                title: r.title || undefined,
+                title: sanitizeCodexThreadTitle(r.title),
             }));
         }
         catch (error) {

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

@@ -69,6 +69,9 @@ export class SessionManager {
             return { role: 'admin', mode: 'interactive' };
         return { role: 'guest', mode: 'interactive' };
     }
+    resolvePermissionMode(role) {
+        return (role === 'owner' || role === 'admin') ? 'bypass' : 'readonly';
+    }
     async updateIdentity(sessionId, identity) {
         logger.debug(`[SessionManager] updateIdentity: sessionId=${sessionId}, role=${identity.role}`);
     }
@@ -479,10 +482,10 @@ export class SessionManager {
             throw new Error(`[SessionManager] getOrCreateSession requires channelType. channel="${channel}" channelId="${channelId}"`);
         }
         if (threadId) {
-            const session = this.getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfAID, channelType, peerType);
+            const session = this.getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfAID, channelType, peerType, chatType);
             session.identity = this.resolveIdentity(channel, userId);
             if (session.metadata && !session.metadata.permissionMode) {
-                session.metadata.permissionMode = DEFAULT_PERMISSION_MODE;
+                session.metadata.permissionMode = this.resolvePermissionMode(session.identity.role);
                 this.persistSession(session, 'none');
             }
             return session;
@@ -564,8 +567,9 @@ export class SessionManager {
         }
         // Create new session
         const sessionMetadata = { ...(metadata || {}) };
+        const newIdentity = this.resolveIdentity(channel, userId);
         if (!sessionMetadata.permissionMode)
-            sessionMetadata.permissionMode = DEFAULT_PERMISSION_MODE;
+            sessionMetadata.permissionMode = this.resolvePermissionMode(newIdentity.role);
         const session = {
             id: generateSessionId(),
             channel,
@@ -583,7 +587,7 @@ export class SessionManager {
             createdAt: Date.now(),
             updatedAt: Date.now(),
         };
-        session.identity = this.resolveIdentity(channel, userId);
+        session.identity = newIdentity;
         this.persistSession(session, 'set');
         this.eventBus.publish({
             type: 'session:created',
@@ -614,7 +618,7 @@ export class SessionManager {
             current.agentSessionId = updates.agentSessionId ?? undefined;
         this.persistSession(current, 'sync');
     }
-    getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfAID, channelType, peerType) {
+    getOrCreateThreadSession(channel, channelId, threadId, defaultProjectPath, metadata, name, agentId, selfAID, channelType, peerType, chatType) {
         // 使用精确路径（channelType + selfAID）
         const chatDir = (channelType && selfAID)
             ? (() => { const d = chatDirPath(this.sessionsDir, channelType, channelId, selfAID); fs.mkdirSync(d, { recursive: true }); fs.mkdirSync(path.join(d, '_threads'), { recursive: true }); return d; })()
@@ -627,18 +631,22 @@ export class SessionManager {
             if (existing) {
                 const validSessionId = this.validateSessionFile(existing);
                 if (metadata) {
+                    const creatorPeerId = existing.metadata?.peerId;
                     existing.metadata = { ...(existing.metadata || {}), ...metadata };
+                    if (creatorPeerId && existing.metadata)
+                        existing.metadata.peerId = creatorPeerId;
                     this.persistSession(existing, 'none');
                 }
                 return { ...existing, agentSessionId: validSessionId };
             }
         }
-        // Inherit project path & chatType from active main session
-        const activeMain = this.readActive(channel, channelId, channelType, selfAID);
-        const projectPath = (activeMain && !activeMain.threadId ? activeMain.projectPath : undefined) || defaultProjectPath;
-        const inheritedChatType = (activeMain && !activeMain.threadId ? activeMain.chatType : undefined) || 'private';
+        const projectPath = defaultProjectPath;
+        const effectiveChatType = chatType || 'private';
         const effectiveChannelType = channelType || channel;
         const sessionKey = formatSessionKey(effectiveChannelType, channelId, threadId);
+        // 继承主会话的 agentId（话题会话从属于主会话，应沿用相同 backend）
+        const mainActive = readJsonFile(path.join(chatDir, 'active.json'));
+        const inheritedAgentId = agentId || mainActive?.agentType || 'claude';
         const session = {
             id: generateSessionId(),
             channel,
@@ -647,10 +655,10 @@ export class SessionManager {
             selfAID: selfAID || '',
             projectPath,
             threadId,
-            agentId: agentId || 'claude',
+            agentId: inheritedAgentId,
             sessionKey,
-            chatType: inheritedChatType,
-            sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType, peerType),
+            chatType: effectiveChatType,
+            sessionMode: this.resolveDefaultSessionMode(channel, effectiveChatType, peerType),
             metadata,
             name: name || '话题会话',
             createdAt: Date.now(),
@@ -1024,11 +1032,17 @@ export class SessionManager {
         const existingDir = this.findExistingChatDir(channel, channelId);
         let channelType = channel;
         let selfAID = '';
+        let inheritedRole = 'guest';
         if (existingDir) {
             const active = readJsonFile(path.join(existingDir, 'active.json'));
             if (active) {
                 channelType = active.channelType || channel;
                 selfAID = active.selfAID || '';
+                // 从现有 session 的 permissionMode 反推 role，bypass→owner，其余→guest
+                if (active.permissionMode === 'bypass')
+                    inheritedRole = 'owner';
+                if (!agentId && active.agentType)
+                    agentId = active.agentType;
             }
         }
         const session = {
@@ -1043,7 +1057,7 @@ export class SessionManager {
             sessionKey: formatSessionKey(channelType, channelId, DEFAULT_THREAD_ID),
             chatType: inheritedChatType,
             sessionMode: this.resolveDefaultSessionMode(channel, inheritedChatType),
-            metadata: { permissionMode: DEFAULT_PERMISSION_MODE },
+            metadata: { permissionMode: this.resolvePermissionMode(inheritedRole) },
             name: name || '默认会话',
             createdAt: Date.now(),
             updatedAt: Date.now(),

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

@@ -0,0 +1,26 @@
+const SYSTEM_PROMPT_MARKERS = [
+    '--- [SYSTEM_PROMPT_END] ---',
+    '<system-reminder>',
+    'EvolClaw Context Kit documents are shown below.',
+];
+const MESSAGE_ROUTE_PREFIX_RE = /^‹[^›]*·\s*from:[^›]*→\s*self:[^›]*›\s*/;
+export function sanitizeSessionTitle(title) {
+    if (typeof title !== 'string')
+        return undefined;
+    let cleanTitle = title;
+    for (const marker of SYSTEM_PROMPT_MARKERS) {
+        const markerIndex = cleanTitle.indexOf(marker);
+        if (markerIndex >= 0) {
+            cleanTitle = cleanTitle.slice(0, markerIndex);
+        }
+    }
+    cleanTitle = cleanTitle.trim().replace(MESSAGE_ROUTE_PREFIX_RE, '').replace(/\s+/g, ' ');
+    if (!cleanTitle)
+        return undefined;
+    if (/^\.+$/.test(cleanTitle))
+        return undefined;
+    return cleanTitle.length > 80 ? `${cleanTitle.slice(0, 80)}...` : cleanTitle;
+}
+export function displaySessionTitle(title, fallback = '默认会话') {
+    return sanitizeSessionTitle(title) || sanitizeSessionTitle(fallback) || fallback;
+}