metame-cli 1.5.21 → 1.5.23

package/scripts/daemon-agent-workflow.js

@@ -0,0 +1,295 @@
+'use strict';
+
+function buildBoundSessionChatId(projectKey) {
+  const key = String(projectKey || '').trim();
+  return key ? `_bound_${key}` : '';
+}
+
+function getBoundProject(chatId, cfg) {
+  const agentMap = {
+    ...(cfg && cfg.telegram ? cfg.telegram.chat_agent_map : {}),
+    ...(cfg && cfg.feishu ? cfg.feishu.chat_agent_map : {}),
+  };
+  const boundKey = agentMap[String(chatId)];
+  const boundProj = boundKey && cfg && cfg.projects && cfg.projects[boundKey];
+  return { boundKey: boundKey || null, boundProj: boundProj || null };
+}
+
+function getLatestActivationForChat(chatId, pendingActivations) {
+  if (!pendingActivations || pendingActivations.size === 0) return null;
+  const cid = String(chatId);
+  let latest = null;
+  for (const rec of pendingActivations.values()) {
+    if (rec.createdByChatId === cid) continue;
+    if (!latest || rec.createdAt > latest.createdAt) latest = rec;
+  }
+  return latest;
+}
+
+function listUnboundProjects(cfg) {
+  const allBoundKeys = new Set(Object.values({
+    ...(cfg && cfg.telegram ? cfg.telegram.chat_agent_map : {}),
+    ...(cfg && cfg.feishu ? cfg.feishu.chat_agent_map : {}),
+  }));
+
+  return Object.entries((cfg && cfg.projects) || {})
+    .filter(([key, p]) => p && p.cwd && !allBoundKeys.has(key))
+    .map(([key, p]) => ({ key, name: p.name || key, cwd: p.cwd, icon: p.icon || '🤖' }));
+}
+
+function attachBoundSession({
+  attachOrCreateSession,
+  projectKey,
+  chatId,
+  cwd,
+  name,
+  engine,
+  normalizeCwd,
+  getDefaultEngine,
+}) {
+  if (!cwd || typeof attachOrCreateSession !== 'function') return;
+  const sessionChatId = projectKey ? buildBoundSessionChatId(projectKey) : String(chatId);
+  attachOrCreateSession(
+    sessionChatId,
+    normalizeCwd(cwd),
+    name || projectKey || '',
+    engine || getDefaultEngine()
+  );
+}
+
+async function bindAgentToChat({
+  agentTools,
+  doBindAgent,
+  bot,
+  chatId,
+  agentName,
+  agentCwd,
+  HOME,
+  attachOrCreateSession,
+  normalizeCwd,
+  getDefaultEngine,
+  announce = true,
+}) {
+  if (agentTools && typeof agentTools.bindAgentToChat === 'function') {
+    const res = await agentTools.bindAgentToChat(chatId, agentName, agentCwd);
+    if (!res.ok) {
+      await bot.sendMessage(chatId, `❌ 绑定失败: ${res.error}`);
+      return { ok: false };
+    }
+    const p = res.data.project || {};
+    const icon = p.icon || '🤖';
+    const action = res.data.isNewProject ? '绑定成功' : '重新绑定';
+    const displayCwd = String(res.data.cwd || '').replace(HOME, '~');
+    attachBoundSession({
+      attachOrCreateSession,
+      projectKey: res.data.projectKey,
+      chatId,
+      cwd: res.data.cwd,
+      name: p.name || agentName || res.data.projectKey || '',
+      engine: p.engine,
+      normalizeCwd,
+      getDefaultEngine,
+    });
+    if (announce) {
+      await bot.sendMessage(chatId, `${icon} ${p.name || agentName} ${action}\n目录: ${displayCwd}`);
+    }
+    return { ok: true, data: res.data };
+  }
+
+  const fallback = await doBindAgent(bot, chatId, agentName, agentCwd);
+  if (!fallback || fallback.ok === false) {
+    return { ok: false, error: (fallback && fallback.error) || 'bind failed' };
+  }
+  const fallbackCwd = (fallback.data && fallback.data.cwd) || agentCwd;
+  attachBoundSession({
+    attachOrCreateSession,
+    projectKey: fallback && fallback.data ? fallback.data.projectKey : null,
+    chatId,
+    cwd: fallbackCwd,
+    name: agentName || '',
+    engine: fallback && fallback.data && fallback.data.project ? fallback.data.project.engine : null,
+    normalizeCwd,
+    getDefaultEngine,
+  });
+  return {
+    ok: true,
+    data: {
+      cwd: fallbackCwd,
+      projectKey: fallback && fallback.data ? fallback.data.projectKey : null,
+      project: fallback && fallback.data ? fallback.data.project : null,
+    },
+  };
+}
+
+async function editAgentRole({ agentTools, mergeAgentRole, workspaceDir, deltaText }) {
+  if (agentTools && typeof agentTools.editAgentRoleDefinition === 'function') {
+    return agentTools.editAgentRoleDefinition(workspaceDir, deltaText);
+  }
+  const legacy = await mergeAgentRole(workspaceDir, deltaText);
+  if (legacy.error) return { ok: false, error: legacy.error };
+  return { ok: true, data: legacy };
+}
+
+async function listAgents({ agentTools, chatId, loadConfig }) {
+  if (agentTools && typeof agentTools.listAllAgents === 'function') {
+    return agentTools.listAllAgents(chatId);
+  }
+
+  const cfg = loadConfig();
+  const projects = cfg.projects || {};
+  const entries = Object.entries(projects)
+    .filter(([, p]) => p && p.cwd)
+    .map(([key, p]) => ({
+      key,
+      name: p.name || key,
+      cwd: p.cwd,
+      icon: p.icon || '🤖',
+    }));
+  const { boundKey } = getBoundProject(chatId, cfg);
+  return { ok: true, data: { agents: entries, boundKey } };
+}
+
+async function unbindAgent({ agentTools, chatId, loadConfig, writeConfigSafe, backupConfig }) {
+  if (agentTools && typeof agentTools.unbindCurrentAgent === 'function') {
+    return agentTools.unbindCurrentAgent(chatId);
+  }
+
+  const cfg = loadConfig();
+  const isTg = typeof chatId === 'number';
+  const ak = isTg ? 'telegram' : 'feishu';
+  if (!cfg[ak]) cfg[ak] = {};
+  if (!cfg[ak].chat_agent_map) cfg[ak].chat_agent_map = {};
+  const old = cfg[ak].chat_agent_map[String(chatId)] || null;
+  if (old) {
+    delete cfg[ak].chat_agent_map[String(chatId)];
+    if (typeof writeConfigSafe === 'function') writeConfigSafe(cfg);
+    if (typeof backupConfig === 'function') backupConfig();
+  }
+  return { ok: true, data: { unbound: !!old, previousProjectKey: old } };
+}
+
+async function createWorkspaceAgent({
+  agentTools,
+  chatId,
+  agentName,
+  workspaceDir,
+  roleDescription,
+  pendingActivations,
+  skipChatBinding = false,
+  engine = null,
+  attachOrCreateSession,
+  normalizeCwd,
+  getDefaultEngine,
+  legacyCreate,
+}) {
+  let res;
+  if (agentTools && typeof agentTools.createNewWorkspaceAgent === 'function') {
+    res = await agentTools.createNewWorkspaceAgent(agentName, workspaceDir, roleDescription, chatId, {
+      skipChatBinding,
+      engine,
+    });
+  } else if (typeof legacyCreate === 'function') {
+    res = await legacyCreate();
+  } else {
+    res = { ok: false, error: 'agentTools.createNewWorkspaceAgent unavailable' };
+  }
+
+  if (!res.ok) return res;
+
+  const data = res.data || {};
+  if (skipChatBinding) {
+    if (data.projectKey && pendingActivations) {
+      pendingActivations.set(data.projectKey, {
+        agentKey: data.projectKey,
+        agentName: (data.project && data.project.name) || agentName || data.projectKey,
+        cwd: data.cwd,
+        createdByChatId: String(chatId),
+        createdAt: Date.now(),
+      });
+    }
+    return res;
+  }
+
+  attachBoundSession({
+    attachOrCreateSession,
+    projectKey: data.projectKey,
+    chatId,
+    cwd: data.cwd,
+    name: (data.project && data.project.name) || agentName || data.projectKey || '',
+    engine: data.project && data.project.engine,
+    normalizeCwd,
+    getDefaultEngine,
+  });
+  return res;
+}
+
+async function handleActivateCommand({
+  bot,
+  chatId,
+  loadConfig,
+  pendingActivations,
+  bindAgent,
+}) {
+  const cfg = loadConfig();
+  const { boundKey } = getBoundProject(chatId, cfg);
+  if (boundKey) {
+    await bot.sendMessage(chatId, `此群已绑定到「${boundKey}」，无需激活。如需更换请先 /agent unbind`);
+    return true;
+  }
+
+  const activation = getLatestActivationForChat(chatId, pendingActivations);
+  if (!activation) {
+    if (pendingActivations) {
+      for (const rec of pendingActivations.values()) {
+        if (rec.createdByChatId === String(chatId)) {
+          await bot.sendMessage(
+            chatId,
+            `❌ 不能在创建来源群激活。\n请在你新建的目标群里发送 \`/activate\`\n\n或在任意群用: \`/agent bind ${rec.agentName} ${rec.cwd}\``
+          );
+          return true;
+        }
+      }
+    }
+
+    const unboundProjects = listUnboundProjects(cfg);
+    if (unboundProjects.length === 1) {
+      const proj = unboundProjects[0];
+      const bindRes = await bindAgent(proj.key, proj.cwd);
+      if (bindRes.ok && pendingActivations) pendingActivations.delete(proj.key);
+      return true;
+    }
+
+    if (unboundProjects.length > 1) {
+      const lines = ['请选择要激活的 Agent：', ''];
+      for (const p of unboundProjects) {
+        lines.push(`${p.icon} ${p.name}  →  \`/agent bind ${p.key} ${p.cwd}\``);
+      }
+      lines.push('\n发送对应命令即可绑定此群。');
+      await bot.sendMessage(chatId, lines.join('\n'));
+      return true;
+    }
+
+    await bot.sendMessage(
+      chatId,
+      '没有待激活的 Agent。\n\n如果已创建过 Agent，直接用:\n`/agent bind <名称> <目录>`\n即可绑定，不需要重新创建。'
+    );
+    return true;
+  }
+
+  const bindRes = await bindAgent(activation.agentName, activation.cwd);
+  if (bindRes.ok && pendingActivations) pendingActivations.delete(activation.agentKey);
+  return true;
+}
+
+module.exports = {
+  getBoundProject,
+  getLatestActivationForChat,
+  listUnboundProjects,
+  buildBoundSessionChatId,
+  bindAgentToChat,
+  createWorkspaceAgent,
+  editAgentRole,
+  listAgents,
+  unbindAgent,
+  handleActivateCommand,
+};

package/scripts/daemon-bridges.js

@@ -817,14 +817,14 @@ function createBridgeStarter(deps) {
           let _replyMappingFound = false; // true = mapping exists (agentKey may be null = main)
           // Load state once for the entire routing block
           const _st = loadState();
+          const _parentMapping = parentId && _st.msg_sessions ? _st.msg_sessions[parentId] : null;
           // Quoted reply = explicit parentId but NOT a topic thread (topics always carry parentId=root_id)
           const _isQuotedReply = !!(parentId && !threadRootId);
-          if (_isQuotedReply) {
-            log('INFO', `Feishu reply metadata detected chat=${chatId} parentId=${parentId}`);
+          if (parentId) {
+            log('INFO', `Feishu reply metadata detected chat=${chatId} parentId=${parentId}${threadRootId ? ' topic=true' : ''}`);
           }
-          // In topic mode, session continuity is handled by pipelineChatId — skip msg_sessions lookup
           if (_isQuotedReply) {
-            const mapped = _st.msg_sessions && _st.msg_sessions[parentId];
+            const mapped = _parentMapping;
             if (mapped) {
               _replyMappingFound = true;
               if (typeof restoreSessionFromReply === 'function') {
@@ -843,6 +843,10 @@ function createBridgeStarter(deps) {
             } else {
               log('INFO', `Feishu reply parentId=${parentId} had no msg_sessions mapping`);
             }
+          } else if (threadRootId && _parentMapping) {
+            _replyMappingFound = true;
+            _replyAgentKey = _parentMapping.agentKey || null;
+            log('INFO', `Feishu topic inherited root mapping agentKey=${_replyAgentKey || 'main'} parentId=${parentId}`);
           }
 
           // Helper: set/clear sticky on shared state object and persist
@@ -857,13 +861,22 @@ function createBridgeStarter(deps) {
             if (_st.team_sticky) delete _st.team_sticky[_chatKey];
             saveState(_st);
           };
-          const _stickyKey = (_st.team_sticky || {})[_chatKey] || null;
+          let _stickyKey = (_st.team_sticky || {})[_chatKey] || null;
 
           // Team group routing: if bound project has a team array, check message for member nickname
           // Non-/stop slash commands bypass team routing → handled by main project
           const { key: _boundKey, project: _boundProj } = _getBoundProject(chatId, liveCfg);
           const _isTeamSlashCmd = trimmedText.startsWith('/') && !/^\/stop(\s|$)/i.test(trimmedText);
           if (_boundProj && Array.isArray(_boundProj.team) && _boundProj.team.length > 0 && !_isTeamSlashCmd) {
+            if (threadRootId && !_stickyKey && _replyAgentKey) {
+              const _topicRootMember = _boundProj.team.find(m => m.key === _replyAgentKey);
+              if (_topicRootMember) {
+                _setSticky(_topicRootMember.key);
+                _stickyKey = _topicRootMember.key;
+                log('INFO', `Topic root mapping → sticky set: ${_chatKey.slice(-8)} → ${_topicRootMember.key}`);
+              }
+            }
+
             // ── /stop precise routing for team groups ──
             const _stopMatch = trimmedText && trimmedText.match(/^\/stop(?:\s+(.+))?$/i);
             if (_stopMatch) {

package/scripts/daemon-claude-engine.js

@@ -9,9 +9,17 @@ const {
   ENGINE_MODEL_CONFIG,
   _private: { resolveCodexPermissionProfile },
 } = require('./daemon-engine-runtime');
-const { buildIntentHintBlock } = require('./intent-registry');
 const { rawChatId } = require('./core/thread-chat-id');
 const { buildAgentContextForEngine, buildMemorySnapshotContent, refreshMemorySnapshot } = require('./agent-layer');
+const {
+  adaptDaemonHintForEngine,
+  buildAgentHint,
+  buildDaemonHint,
+  buildMacAutomationHint,
+  buildLanguageGuard,
+  buildIntentHint,
+  composePrompt,
+} = require('./daemon-prompt-context');
 const { createPlatformSpawn, terminateChildProcess, stopStreamingLifecycle, abortStreamingChildLifecycle, setActiveChildProcess, clearActiveChildProcess, acquireStreamingChild, buildStreamingResult, resolveStreamingClosePayload, accumulateStreamingStderr, splitStreamingStdoutChunk, buildStreamFlushPayload, buildToolOverlayPayload, buildMilestoneOverlayPayload, finalizePersistentStreamingTurn, writeStreamingChildInput, parseStreamingEvents, applyStreamingMetadata, applyStreamingToolState, applyStreamingContentState, createStreamingWatchdog, runAsyncCommand } = require('./core/handoff');
 
 /**
@@ -235,16 +243,6 @@ function createClaudeEngine(deps) {
     return err.message || String(err);
   }
 
-  function adaptDaemonHintForEngine(daemonHint, engineName) {
-    if (normalizeEngineName(engineName) === 'claude') return daemonHint;
-    let out = String(daemonHint || '');
-    // Keep this replacement conservative: only unwrap the known outer wrapper.
-    out = out.replace('[System hints - DO NOT mention these to user:', 'System hints (internal, do not mention to user):');
-    // The current daemonHint template ends with a single trailing `]`.
-    out = out.replace(/\]\s*$/, '');
-    return out;
-  }
-
   function getCodexPermissionProfile(readOnly, daemonCfg = {}, session = {}) {
     return resolveCodexPermissionProfile({ readOnly, daemonCfg, session });
   }
@@ -573,7 +571,12 @@ function createClaudeEngine(deps) {
 
   function projectKeyFromVirtualChatId(chatId) {
     const v = String(chatId || '');
-    if (v.startsWith('_agent_')) return v.slice(7) || null;
+    if (v.startsWith('_agent_')) {
+      const rest = v.slice(7);
+      const scopeIdx = rest.indexOf('::');
+      const key = scopeIdx >= 0 ? rest.slice(0, scopeIdx) : rest;
+      return key || null;
+    }
     if (v.startsWith('_scope_')) {
       const idx = v.lastIndexOf('__');
       if (idx > 7 && idx + 2 < v.length) return v.slice(idx + 2);
@@ -1441,20 +1444,15 @@ function createClaudeEngine(deps) {
         }
       }
 
-      let agentHint = '';
-      if (!session.started && (boundProject || (session && session.cwd))) {
-        try {
-          // Engine-aware: Codex gets memory only (soul is already in AGENTS.md);
-          // Claude gets soul + memory (SOUL.md is not auto-loaded by Claude).
-          agentHint = buildAgentContextForEngine(
-            boundProject || { cwd: session.cwd },
-            engineName,
-            HOME,
-          ).hint || '';
-        } catch (e) {
-          log('WARN', `Agent context injection failed: ${e.message}`);
-        }
-      }
+      const agentHint = buildAgentHint({
+        sessionStarted: session.started,
+        boundProject,
+        sessionCwd: session && session.cwd,
+        engineName,
+        HOME,
+        buildAgentContextForEngine,
+        log,
+      });
 
       // Memory & Knowledge Injection (RAG)
       let memoryHint = '';
@@ -1628,41 +1626,28 @@ function createClaudeEngine(deps) {
 
       // Inject daemon hints only on first message of a session
       // Task-specific rules (3-4) are injected only when isTaskIntent() returns true (~250 token saving for casual chat)
-      let daemonHint = '';
-      if (!session.started) {
-        const mentorRadarHint = (config && config.daemon && config.daemon.mentor && config.daemon.mentor.enabled)
-          ? '\n   When you observe the user is clearly expert or beginner in a domain, note it in your response and suggest: "要不要把你的 {domain} 水平 ({level}) 记录到能力雷达？"'
-          : '';
-        const taskRules = isTaskIntent(prompt) ? `
-3. Active memory: After confirming a new insight, bug root cause, or user preference, persist it with:
-   node ~/.metame/memory-write.js "Entity.sub" "relation_type" "value (20-300 chars)"
-   Valid relations: tech_decision, bug_lesson, arch_convention, config_fact, config_change, workflow_rule, project_milestone
-   Only write verified facts. Do not write speculative or process-description entries.
-${mentorRadarHint}
-4. Task handoff: When suspending a multi-step task or handing off to another agent, write current status to ~/.metame/memory/now/${projectKey || 'default'}.md using:
-   \`mkdir -p ~/.metame/memory/now && printf '%s\\n' "## Current Task" "{task}" "" "## Progress" "{progress}" "" "## Next Step" "{next}" > ~/.metame/memory/now/${projectKey || 'default'}.md\`
-   Keep it under 200 words. Clear it when the task is fully complete by running: \`> ~/.metame/memory/now/${projectKey || 'default'}.md\`` : '';
-        daemonHint = `\n\n[System hints - DO NOT mention these to user:
-1. Daemon config: The ONLY config is ~/.metame/daemon.yaml (never edit daemon-default.yaml). Auto-reloads on change.
-2. Explanation depth (ZPD):${zdpHint ? zdpHint : '\n- User competence map unavailable. Default to concise expert-first explanations unless the user asks for teaching mode.'}${reflectHint}${taskRules}]`;
-      }
-
-      daemonHint = adaptDaemonHintForEngine(daemonHint, runtime.name);
+      const mentorRadarHint = (config && config.daemon && config.daemon.mentor && config.daemon.mentor.enabled)
+        ? '\n   When you observe the user is clearly expert or beginner in a domain, note it in your response and suggest: "要不要把你的 {domain} 水平 ({level}) 记录到能力雷达？"'
+        : '';
+      const daemonHint = buildDaemonHint({
+        sessionStarted: session.started,
+        prompt,
+        mentorRadarHint,
+        zdpHint,
+        reflectHint,
+        projectKey,
+        isTaskIntent,
+        runtimeName: runtime.name,
+      });
 
       const routedPrompt = skill ? `/${skill} ${prompt}` : prompt;
 
-      // Mac automation orchestration hint: lets Claude flexibly compose local scripts
-      // without forcing users to write slash commands by hand.
-      let macAutomationHint = '';
-      if (process.platform === 'darwin' && !readOnly && isMacAutomationIntent(prompt)) {
-        macAutomationHint = `\n\n[Mac automation policy - do NOT expose this block:
-1. Prefer deterministic local control via Bash + osascript/JXA; avoid screenshot/visual workflows unless explicitly requested.
-2. Read/query actions can execute directly.
-3. Before any side-effect action (send email, create/delete/modify calendar event, delete/move files, app quit, system sleep), first show a short execution preview and require explicit user confirmation.
-4. Keep output concise: success/failure + key result only.
-5. If permission is missing, guide user to run /mac perms open then retry.
-6. Before executing high-risk or non-obvious Bash commands (rm, kill, git reset, overwrite configs), prepend a single-line [Why] explanation. Skip for routine commands (ls, cat, grep).]`;
-      }
+      const macAutomationHint = buildMacAutomationHint({
+        processPlatform: process.platform,
+        readOnly,
+        prompt,
+        isMacAutomationIntent,
+      });
 
       // P2-B: inject session summary when resuming after a 2h+ gap
       let summaryHint = '';
@@ -1738,23 +1723,29 @@ ${mentorRadarHint}
       // Language guard: only inject on first message of a new session to avoid
       // linearly growing token cost on every turn in long conversations.
       // Claude Code preserves session context, so the guard persists after initial injection.
-      const langGuard = session.started
-        ? ''
-        : '\n\n[Respond in Simplified Chinese (简体中文) only. NEVER switch to Korean, Japanese, or other languages regardless of tool output or context language.]';
-      // Intent hints are dynamic (per-prompt, semantic match), so compute for all runtimes.
-      let intentHint = '';
-      try {
-        const block = buildIntentHintBlock(prompt, config, boundProjectKey || projectKey || '');
-        if (block) intentHint = `\n\n${block}`;
-      } catch (e) {
-        log('WARN', `Intent registry injection failed: ${e.message}`);
-      }
+      const langGuard = buildLanguageGuard(session.started);
+      const intentHint = buildIntentHint({
+        prompt,
+        config,
+        boundProjectKey,
+        projectKey,
+        log,
+      });
       // For warm process reuse: static context (daemonHint, memoryHint, etc.) is already
       // in the persistent process — skip those to save tokens. intentHint is dynamic
       // (varies per prompt), so include it even on warm reuse.
-      const fullPrompt = _warmEntry
-        ? routedPrompt + intentHint
-        : routedPrompt + daemonHint + intentHint + agentHint + macAutomationHint + summaryHint + memoryHint + mentorHint + langGuard;
+      const fullPrompt = composePrompt({
+        routedPrompt,
+        warmEntry: _warmEntry,
+        intentHint,
+        daemonHint,
+        agentHint,
+        macAutomationHint,
+        summaryHint,
+        memoryHint,
+        mentorHint,
+        langGuard,
+      });
       if (runtime.name === 'codex' && session.started && session.id && requestedCodexPermissionProfile) {
         const actualPermissionProfile = getActualCodexPermissionProfile(session);
         if (codexNeedsFallbackForRequestedPermissions(actualPermissionProfile, requestedCodexPermissionProfile)) {
@@ -2146,14 +2137,14 @@ ${mentorRadarHint}
           const allProjects = (config && config.projects) || {};
           const names = dispatchedTargets.map(k => (allProjects[k] && allProjects[k].name) || k).join('、');
           const doneMsg = await bot.sendMessage(chatId, `✉️ 已转达给 ${names}，处理中…`);
-          if (doneMsg && doneMsg.message_id && session) trackMsgSession(doneMsg.message_id, session, String(chatId).startsWith('_agent_') ? String(chatId).slice(7) : null);
+          if (doneMsg && doneMsg.message_id && session) trackMsgSession(doneMsg.message_id, session, projectKeyFromVirtualChatId(chatId));
           const wasNew = !session.started;
           if (wasNew) markSessionStarted(sessionChatId, engineName);
           return { ok: true };
         }
         const filesDesc = files && files.length > 0 ? `\n修改了 ${files.length} 个文件` : '';
         const doneMsg = await bot.sendMessage(chatId, `✅ 完成${filesDesc}`);
-        if (doneMsg && doneMsg.message_id && session) trackMsgSession(doneMsg.message_id, session, String(chatId).startsWith('_agent_') ? String(chatId).slice(7) : null);
+        if (doneMsg && doneMsg.message_id && session) trackMsgSession(doneMsg.message_id, session, projectKeyFromVirtualChatId(chatId));
         const wasNew = !session.started;
         if (wasNew) markSessionStarted(sessionChatId, engineName);
         return { ok: true };
@@ -2217,6 +2208,10 @@ ${mentorRadarHint}
           cleanOutput = `⚠️ **任务超时，以下是已完成的部分结果：**\n\n${cleanOutput}`;
         }
 
+        if (typeof bot.notifyFinalOutput === 'function') {
+          try { await bot.notifyFinalOutput(cleanOutput); } catch { /* non-critical */ }
+        }
+
         // Match current session to a project for colored card display.
         // Prefer the bound project (known by virtual chatId or chat_agent_map) — avoids ambiguity
         // when multiple projects share the same cwd (e.g. team members with parent project cwd).
@@ -2291,7 +2286,7 @@ ${mentorRadarHint}
             log('ERROR', `sendMessage fallback also failed: ${e2.message}`);
           }
         }
-        const trackedAgentKey = String(chatId).startsWith('_agent_') ? String(chatId).slice(7) : null;
+        const trackedAgentKey = projectKeyFromVirtualChatId(chatId);
         if (replyMsg && replyMsg.message_id && session) {
           if (runtime.name === 'codex' && session.runtimeSessionObserved === false) {
             trackMsgSession(replyMsg.message_id, session, trackedAgentKey, { routeOnly: true });
@@ -2408,6 +2403,9 @@ ${mentorRadarHint}
           if (retry.output) {
             markSessionStarted(sessionChatId, runtime.name);
             const { markedFiles: retryMarked, cleanOutput: retryClean } = parseFileMarkers(retry.output);
+            if (typeof bot.notifyFinalOutput === 'function') {
+              try { await bot.notifyFinalOutput(retryClean); } catch { /* non-critical */ }
+            }
             await bot.sendMarkdown(chatId, retryClean);
             await sendFileButtons(bot, chatId, mergeFileCollections(retryMarked, retry.files));
             return { ok: true };
@@ -2485,6 +2483,7 @@ ${mentorRadarHint}
       codexApprovalPrivilegeRank,
       codexNeedsFallbackForRequestedPermissions,
       buildCodexFallbackBridgePrompt,
+      projectKeyFromVirtualChatId,
     },
   };
 }