metame-cli 1.5.23 → 1.5.25

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.5.23",
+    "version": "1.5.25",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -9,8 +9,9 @@
     "files": [
         "index.js",
         "scripts/",
-        "!scripts/*.test.js",
+        "!scripts/**/*.test.js",
         "!scripts/test_daemon.js",
+        "!scripts/sync-readme.js",
         "!scripts/hooks/test-*.js",
         "!scripts/daemon.yaml",
         "!scripts/daemon.yaml.bak",

package/scripts/core/team-session-route.js

@@ -0,0 +1,164 @@
+'use strict';
+
+const { rawChatId: _rawChatId } = require('./thread-chat-id');
+
+function buildBoundSessionChatId(projectKey) {
+  const key = String(projectKey || '').trim();
+  return key ? `_bound_${key}` : '';
+}
+
+function isAgentLogicalRouteForMember(logicalChatId, memberKey) {
+  const route = String(logicalChatId || '');
+  const key = String(memberKey || '').trim();
+  if (!route || !key) return false;
+  const base = `_agent_${key}`;
+  return route === base || route.startsWith(`${base}::`);
+}
+
+function resolveBoundTeamContext({ chatId, cfg, state, normalizeCwd }) {
+  const chatKey = String(chatId || '');
+  const rawChatKey = _rawChatId(chatKey);
+  const agentMap = {
+    ...(cfg && cfg.telegram ? cfg.telegram.chat_agent_map : {}),
+    ...(cfg && cfg.feishu ? cfg.feishu.chat_agent_map : {}),
+    ...(cfg && cfg.imessage ? cfg.imessage.chat_agent_map : {}),
+    ...(cfg && cfg.siri_bridge ? cfg.siri_bridge.chat_agent_map : {}),
+  };
+  const boundKey = agentMap[chatKey] || agentMap[rawChatKey] || null;
+  const boundProj = boundKey && cfg && cfg.projects ? cfg.projects[boundKey] : null;
+  const stickyKey = state && state.team_sticky
+    ? (state.team_sticky[chatKey] || state.team_sticky[rawChatKey] || null)
+    : null;
+  const stickyMember = stickyKey && boundProj && Array.isArray(boundProj.team)
+    ? boundProj.team.find((member) => member && member.key === stickyKey) || null
+    : null;
+  const stickyLogicalChatId = state && state.team_session_route
+    ? (state.team_session_route[chatKey] || state.team_session_route[rawChatKey] || null)
+    : null;
+  const normalizedStickyCwd = stickyMember && stickyMember.cwd ? normalizeCwd(stickyMember.cwd) : null;
+  const normalizedBoundCwd = boundProj && boundProj.cwd ? normalizeCwd(boundProj.cwd) : null;
+
+  return {
+    chatKey,
+    rawChatKey,
+    boundKey,
+    boundProj,
+    stickyKey,
+    stickyMember,
+    stickyLogicalChatId,
+    normalizedStickyCwd,
+    normalizedBoundCwd,
+  };
+}
+
+function resolveSessionRoute({
+  chatId,
+  cfg,
+  state,
+  getSession,
+  normalizeCwd,
+  normalizeEngineName,
+  inferStoredEngine,
+}) {
+  const ctx = resolveBoundTeamContext({ chatId, cfg, state, normalizeCwd });
+
+  if (ctx.stickyMember) {
+    return {
+      sessionChatId: isAgentLogicalRouteForMember(ctx.stickyLogicalChatId, ctx.stickyMember.key)
+        ? ctx.stickyLogicalChatId
+        : `_agent_${ctx.stickyMember.key}`,
+      cwd: ctx.normalizedStickyCwd || ctx.normalizedBoundCwd,
+      engine: normalizeEngineName(ctx.stickyMember.engine || (ctx.boundProj && ctx.boundProj.engine)),
+      context: ctx,
+    };
+  }
+
+  if (ctx.boundProj) {
+    return {
+      sessionChatId: buildBoundSessionChatId(ctx.boundKey),
+      cwd: ctx.normalizedBoundCwd,
+      engine: normalizeEngineName(ctx.boundProj.engine),
+      context: ctx,
+    };
+  }
+
+  const rawSession = getSession(chatId);
+  return {
+    sessionChatId: String(chatId || ''),
+    cwd: rawSession && rawSession.cwd ? normalizeCwd(rawSession.cwd) : null,
+    engine: inferStoredEngine(rawSession),
+    context: ctx,
+  };
+}
+
+function resolveResumeRouteForTarget({
+  chatId,
+  targetCwd,
+  cfg,
+  state,
+  normalizeCwd,
+  fallbackSessionChatId,
+}) {
+  const ctx = resolveBoundTeamContext({ chatId, cfg, state, normalizeCwd });
+  const normalizedTargetCwd = targetCwd ? normalizeCwd(targetCwd) : null;
+  if (!ctx.boundProj || !Array.isArray(ctx.boundProj.team) || !normalizedTargetCwd) {
+    return { sessionChatId: fallbackSessionChatId, stickyKey: null, clearSticky: false };
+  }
+
+  const matchedMember = ctx.boundProj.team.find((member) => {
+    if (!member || !member.cwd) return false;
+    return normalizeCwd(member.cwd) === normalizedTargetCwd;
+  });
+  if (matchedMember) {
+    return {
+      sessionChatId: `_agent_${matchedMember.key}`,
+      stickyKey: matchedMember.key,
+      clearSticky: false,
+    };
+  }
+
+  if (ctx.normalizedBoundCwd && ctx.normalizedBoundCwd === normalizedTargetCwd) {
+    return {
+      sessionChatId: buildBoundSessionChatId(ctx.boundKey),
+      stickyKey: ctx.stickyKey || null,
+      clearSticky: !!ctx.stickyKey,
+    };
+  }
+
+  return {
+    sessionChatId: buildBoundSessionChatId(ctx.boundKey),
+    stickyKey: null,
+    clearSticky: true,
+  };
+}
+
+function applyResumeRouteState(state, chatId, resumeRoute) {
+  const chatKey = String(chatId || '');
+  const rawChatKey = _rawChatId(chatKey);
+  if (resumeRoute.clearSticky && state.team_sticky) {
+    delete state.team_sticky[chatKey];
+    delete state.team_sticky[rawChatKey];
+  }
+  if (resumeRoute.clearSticky && state.team_session_route) {
+    delete state.team_session_route[chatKey];
+    delete state.team_session_route[rawChatKey];
+  }
+  if (!resumeRoute.stickyKey) return;
+  if (!state.team_sticky) state.team_sticky = {};
+  state.team_sticky[chatKey] = resumeRoute.stickyKey;
+  state.team_sticky[rawChatKey] = resumeRoute.stickyKey;
+  if (resumeRoute.sessionChatId && resumeRoute.sessionChatId.startsWith('_agent_')) {
+    if (!state.team_session_route) state.team_session_route = {};
+    state.team_session_route[chatKey] = resumeRoute.sessionChatId;
+    state.team_session_route[rawChatKey] = resumeRoute.sessionChatId;
+  }
+}
+
+module.exports = {
+  buildBoundSessionChatId,
+  isAgentLogicalRouteForMember,
+  resolveBoundTeamContext,
+  resolveSessionRoute,
+  resolveResumeRouteForTarget,
+  applyResumeRouteState,
+};

package/scripts/daemon-agent-commands.js

@@ -18,6 +18,11 @@ const {
   handleSoulCommand,
 } = require('./daemon-agent-lifecycle');
 const { parseTeamMembers, createTeamWorkspace } = require('./daemon-team-workflow');
+const {
+  resolveSessionRoute: _resolveSessionRoute,
+  resolveResumeRouteForTarget: _resolveResumeRouteForTarget,
+  applyResumeRouteState: _applyResumeRouteState,
+} = require('./core/team-session-route');
 
 function createAgentCommandHandler(deps) {
   const {
@@ -72,45 +77,16 @@ function createAgentCommandHandler(deps) {
     return available.length === 1 ? normalizeEngineName(available[0]) : getDefaultEngine();
   }
 
-  function buildBoundSessionChatId(projectKey) {
-    const key = String(projectKey || '').trim();
-    return key ? `_bound_${key}` : '';
-  }
-
   function getSessionRoute(chatId) {
-    const cfg = loadConfig();
-    const state = loadState();
-    const chatKey = String(chatId);
-    const agentMap = { ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}), ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}) };
-    const boundKey = agentMap[chatKey] || null;
-    const boundProj = boundKey && cfg.projects ? cfg.projects[boundKey] : null;
-    const stickyKey = state && state.team_sticky ? state.team_sticky[chatKey] : null;
-    const stickyMember = stickyKey && boundProj && Array.isArray(boundProj.team)
-      ? boundProj.team.find((m) => m && m.key === stickyKey)
-      : null;
-
-    if (stickyMember) {
-      return {
-        sessionChatId: `_agent_${stickyMember.key}`,
-        cwd: stickyMember.cwd ? normalizeCwd(stickyMember.cwd) : (boundProj && boundProj.cwd ? normalizeCwd(boundProj.cwd) : null),
-        engine: normalizeEngineName(stickyMember.engine || (boundProj && boundProj.engine)),
-      };
-    }
-
-    if (boundProj) {
-      return {
-        sessionChatId: buildBoundSessionChatId(boundKey),
-        cwd: boundProj.cwd ? normalizeCwd(boundProj.cwd) : null,
-        engine: normalizeEngineName(boundProj.engine),
-      };
-    }
-
-    const rawSession = getSession(chatId);
-    return {
-      sessionChatId: String(chatId),
-      cwd: rawSession && rawSession.cwd ? normalizeCwd(rawSession.cwd) : null,
-      engine: inferStoredEngine(rawSession),
-    };
+    return _resolveSessionRoute({
+      chatId,
+      cfg: loadConfig(),
+      state: loadState(),
+      getSession,
+      normalizeCwd,
+      normalizeEngineName,
+      inferStoredEngine,
+    });
   }
 
   function getCurrentEngine(chatId) {
@@ -170,6 +146,17 @@ function createAgentCommandHandler(deps) {
     return null;
   }
 
+  function resolveResumeRouteForSelection(chatId, route, targetCwd, cfg, state) {
+    return _resolveResumeRouteForTarget({
+      chatId,
+      targetCwd,
+      cfg,
+      state,
+      normalizeCwd,
+      fallbackSessionChatId: route.sessionChatId,
+    });
+  }
+
   async function autoCreateSessionOnEmptyResume(bot, chatId, cwd, engine) {
     const resolvedCwd = cwd ? normalizeCwd(cwd) : null;
     if (!resolvedCwd || !fs.existsSync(resolvedCwd) || typeof attachOrCreateSession !== 'function') {
@@ -389,10 +376,13 @@ function createAgentCommandHandler(deps) {
       }
       const sessionId = fullMatch.sessionId;
       const cwd = fullMatch.projectPath || (curSession && curSession.cwd) || HOME;
+      const targetSessionId = sessionId;
+      const targetCwd = cwd;
 
       const state2 = loadState();
       const cfgForEngine = loadConfig();
-      const sessionKey = route.sessionChatId;
+      const resumeRoute = resolveResumeRouteForSelection(chatId, route, targetCwd, cfgForEngine, state2);
+      const sessionKey = resumeRoute.sessionChatId;
       const existing = state2.sessions[sessionKey] || {};
       const existingEngine = normalizeEngineName(
         existing.engine
@@ -405,8 +395,6 @@ function createAgentCommandHandler(deps) {
         && currentLogical
         && currentLogical.id
         && sessionId === currentLogical.id;
-      const targetSessionId = sessionId;
-      const targetCwd = cwd;
       const existingEngines = existing.engines || {};
       state2.sessions[sessionKey] = {
         ...existing,
@@ -416,6 +404,7 @@ function createAgentCommandHandler(deps) {
         engine: engineByTargetCwd,
         engines: { ...existingEngines, [engineByTargetCwd]: { id: targetSessionId, started: true } },
       };
+      _applyResumeRouteState(state2, chatId, resumeRoute);
       saveState(state2);
       const name = fullMatch.customTitle;
       const label = name || (fullMatch.summary || fullMatch.firstPrompt || '').slice(0, 40) || targetSessionId.slice(0, 8);
@@ -423,7 +412,7 @@ function createAgentCommandHandler(deps) {
       // 读取最近对话片段，帮助确认是否切换到正确的 session
       const recentCtx = getSessionRecentContext ? getSessionRecentContext(targetSessionId) : null;
       const recentDialogue = getSessionRecentDialogue ? getSessionRecentDialogue(targetSessionId, 4) : null;
-      let msg = `✅ 已切换: **${label}**\n📁 ${path.basename(cwd)}`;
+      let msg = `✅ 已切换: **${label}**\n📁 ${path.basename(cwd)}\n🆔 \`${targetSessionId}\``;
       if (selectedLogicalCurrent) {
         msg += '\n\n已恢复当前智能体会话。';
       }

package/scripts/daemon-bridges.js

@@ -5,6 +5,7 @@ try { userAcl = require('./daemon-user-acl'); } catch { /* optional */ }
 const { findTeamMember: _findTeamMember } = require('./daemon-team-dispatch');
 const { isRemoteMember } = require('./daemon-remote-dispatch');
 const { buildThreadChatId, isThreadChatId, rawChatId: _threadRawChatId } = require('./core/thread-chat-id');
+const { isAgentLogicalRouteForMember } = require('./core/team-session-route');
 const imessageIO = (() => { try { return require('./daemon-siri-imessage'); } catch { return null; } })();
 const siriBridgeMod = (() => { try { return require('./daemon-siri-bridge'); } catch { return null; } })();
 const weixinBridgeMod = (() => { try { return require('./daemon-weixin-bridge'); } catch { return null; } })();
@@ -185,6 +186,19 @@ function createBridgeStarter(deps) {
     };
   }
 
+  function resolveReplyStopChatId(targetKey, fallbackChatId, replyMapping) {
+    const resolvedFallback = String(fallbackChatId || '').trim();
+    const mapping = replyMapping && typeof replyMapping === 'object' ? replyMapping : null;
+    const logicalChatId = String(mapping && mapping.logicalChatId || '').trim();
+    if (!logicalChatId) return resolvedFallback;
+    if (!targetKey) return logicalChatId;
+    const expectedPrefix = `_agent_${String(targetKey).trim()}`;
+    if (logicalChatId === expectedPrefix || logicalChatId.startsWith(`${expectedPrefix}::`)) {
+      return logicalChatId;
+    }
+    return resolvedFallback;
+  }
+
   // ── Team group helpers ─────────────────────────────────────────────────
   function _getBoundProject(chatId, cfg) {
     const map = {
@@ -313,9 +327,16 @@ function createBridgeStarter(deps) {
     // When dispatching from a topic thread, include the thread ID in the
     // virtual session key so each topic gets its own independent session.
     const realChatIdStr = String(realChatId || '');
-    const virtualChatId = isThreadChatId(realChatIdStr)
-      ? `_agent_${member.key}::${realChatIdStr}`
-      : `_agent_${member.key}`;
+    const state = loadState() || {};
+    const routeMap = state.team_session_route || {};
+    const rawChatKey = _threadRawChatId(realChatIdStr);
+    const preferredLogicalChatId = routeMap[realChatIdStr] || routeMap[rawChatKey] || '';
+    const expectedBaseChatId = `_agent_${member.key}`;
+    const virtualChatId = isAgentLogicalRouteForMember(preferredLogicalChatId, member.key)
+      ? preferredLogicalChatId
+      : (isThreadChatId(realChatIdStr)
+          ? `${expectedBaseChatId}::${realChatIdStr}`
+          : expectedBaseChatId);
     const parentCwd = member.cwd || boundProj.cwd;
     const resolvedParentCwd = parentCwd.replace(/^~/, require('os').homedir());
     const memberCwd = _getMemberCwd(
@@ -559,9 +580,9 @@ function createBridgeStarter(deps) {
                     );
                     if (m) _targetKey = m.key;
                   }
-                  if (!_targetKey && !_stopArg) _targetKey = _stickyKey;
-                  if (_targetKey) {
-                    const vid = `_agent_${_targetKey}`;
+              if (!_targetKey && !_stopArg) _targetKey = _stickyKey;
+              if (_targetKey) {
+                    const vid = resolveReplyStopChatId(_targetKey, `_agent_${_targetKey}`, parentId ? (_st.msg_sessions && _st.msg_sessions[parentId]) : null);
                     const member = _boundProj.team.find(t => t.key === _targetKey);
                     const label = member ? `${member.icon || '🤖'} ${member.name}` : _targetKey;
                     pipeline.clearQueue(vid);
@@ -783,8 +804,9 @@ function createBridgeStarter(deps) {
             // Respect team_sticky: route to active agent same as text messages
             const _stFile = loadState();
             const _chatKeyFile = String(pipelineChatId);
+            const _rawChatKeyFile = _threadRawChatId(_chatKeyFile);
             const { project: _boundProjFile } = _getBoundProject(chatId, liveCfg);
-            const _stickyKeyFile = (_stFile.team_sticky || {})[_chatKeyFile];
+            const _stickyKeyFile = (_stFile.team_sticky || {})[_chatKeyFile] || (_stFile.team_sticky || {})[_rawChatKeyFile];
             if (_boundProjFile && Array.isArray(_boundProjFile.team) && _boundProjFile.team.length > 0 && _stickyKeyFile) {
               const _stickyMember = _boundProjFile.team.find(m => m.key === _stickyKeyFile);
               if (_stickyMember) {
@@ -814,6 +836,7 @@ function createBridgeStarter(deps) {
           log('INFO', `Feishu message from ${chatId}: ${text.slice(0, 50)}`);
           const parentId = extractFeishuReplyMessageId(event);
           let _replyAgentKey = null;
+          let _replyMapping = null;
           let _replyMappingFound = false; // true = mapping exists (agentKey may be null = main)
           // Load state once for the entire routing block
           const _st = loadState();
@@ -826,6 +849,7 @@ function createBridgeStarter(deps) {
           if (_isQuotedReply) {
             const mapped = _parentMapping;
             if (mapped) {
+              _replyMapping = mapped;
               _replyMappingFound = true;
               if (typeof restoreSessionFromReply === 'function') {
                 restoreSessionFromReply(chatId, mapped);
@@ -852,16 +876,29 @@ function createBridgeStarter(deps) {
           // Helper: set/clear sticky on shared state object and persist
           // Use pipelineChatId so each topic gets independent sticky state
           const _chatKey = String(pipelineChatId);
+          const _rawChatKey = _threadRawChatId(_chatKey);
           const _setSticky = (key) => {
             if (!_st.team_sticky) _st.team_sticky = {};
             _st.team_sticky[_chatKey] = key;
+            if (_rawChatKey && _rawChatKey !== _chatKey) _st.team_sticky[_rawChatKey] = key;
+            if (_st.team_session_route) {
+              if (_st.team_session_route[_chatKey] && !isAgentLogicalRouteForMember(_st.team_session_route[_chatKey], key)) {
+                delete _st.team_session_route[_chatKey];
+              }
+              if (_rawChatKey && _rawChatKey !== _chatKey && _st.team_session_route[_rawChatKey] && !isAgentLogicalRouteForMember(_st.team_session_route[_rawChatKey], key)) {
+                delete _st.team_session_route[_rawChatKey];
+              }
+            }
             saveState(_st);
           };
           const _clearSticky = () => {
             if (_st.team_sticky) delete _st.team_sticky[_chatKey];
+            if (_st.team_sticky && _rawChatKey && _rawChatKey !== _chatKey) delete _st.team_sticky[_rawChatKey];
+            if (_st.team_session_route) delete _st.team_session_route[_chatKey];
+            if (_st.team_session_route && _rawChatKey && _rawChatKey !== _chatKey) delete _st.team_session_route[_rawChatKey];
             saveState(_st);
           };
-          let _stickyKey = (_st.team_sticky || {})[_chatKey] || null;
+          let _stickyKey = (_st.team_sticky || {})[_chatKey] || (_st.team_sticky || {})[_rawChatKey] || 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
@@ -898,9 +935,10 @@ function createBridgeStarter(deps) {
               // Priority 3: bare /stop → sticky
               if (!_targetKey && !_stopArg) _targetKey = _stickyKey;
               if (_targetKey) {
-                const vid = isThreadChatId(String(pipelineChatId))
+                const fallbackVid = isThreadChatId(String(pipelineChatId))
                   ? `_agent_${_targetKey}::${pipelineChatId}`
                   : `_agent_${_targetKey}`;
+                const vid = resolveReplyStopChatId(_targetKey, fallbackVid, _isQuotedReply ? _replyMapping : null);
                 const member = _boundProj.team.find(t => t.key === _targetKey);
                 const label = member ? `${member.icon || '🤖'} ${member.name}` : _targetKey;
                 pipeline.clearQueue(vid);
@@ -1008,6 +1046,9 @@ function createBridgeStarter(deps) {
             if (_stickyKey) {
               const member = _boundProj.team.find(m => m.key === _stickyKey);
               if (member) {
+                if ((_st.team_sticky || {})[_chatKey] !== _stickyKey) {
+                  _setSticky(_stickyKey);
+                }
                 log('INFO', `Sticky route: → ${_stickyKey}`);
                 _dispatchToTeamMember(member, _boundProj, trimmedText, liveCfg, bot, pipelineChatId, executeTaskByName, acl);
                 return;

package/scripts/daemon-claude-engine.js

@@ -1238,7 +1238,19 @@ function createClaudeEngine(deps) {
         ? () => bot.sendCard(chatId, { title: _ackCardHeader.title, body: '🤔', color: _ackCardHeader.color })
         : () => (bot.sendMarkdown ? bot.sendMarkdown(chatId, '🤔') : bot.sendMessage(chatId, '🤔'));
       _ackFn()
-        .then(msg => { if (msg && msg.message_id) statusMsgId = msg.message_id; })
+        .then(msg => {
+          if (!(msg && msg.message_id)) return;
+          statusMsgId = msg.message_id;
+          const trackedAgentKey = projectKeyFromVirtualChatId(chatId);
+          const routeSession = {
+            cwd: (_ackBoundProj && _ackBoundProj.cwd) || HOME,
+            engine: (_ackBoundProj && _ackBoundProj.engine)
+              ? normalizeEngineName(_ackBoundProj.engine)
+              : getDefaultEngine(),
+            logicalChatId: chatId,
+          };
+          trackMsgSession(msg.message_id, routeSession, trackedAgentKey, { routeOnly: true });
+        })
         .catch(e => log('ERROR', `Failed to send ack to ${chatId}: ${e.message}`));
     }
     bot.sendTyping(chatId).catch(() => { });

package/scripts/daemon-command-router.js

@@ -163,6 +163,7 @@ function createCommandRouter(deps) {
 
   function resolveCurrentSessionContext(chatId, config) {
     const chatIdStr = String(chatId || '');
+    const threadScoped = isThreadChatId(chatIdStr);
     const chatAgentMap = {
       ...(config && config.telegram ? config.telegram.chat_agent_map : {}),
       ...(config && config.feishu ? config.feishu.chat_agent_map : {}),
@@ -172,10 +173,19 @@ function createCommandRouter(deps) {
     const _rawChatId = extractOriginalChatId(chatIdStr);
     const mappedKey = chatAgentMap[chatIdStr] || chatAgentMap[_rawChatId] || projectKeyFromVirtualChatId(chatIdStr);
     const mappedProject = mappedKey && config && config.projects ? config.projects[mappedKey] : null;
-    const preferredEngine = String((mappedProject && mappedProject.engine) || getDefaultEngine()).toLowerCase();
     const state = loadState() || {};
     const sessions = state.sessions || {};
+    const stickyKey = state.team_sticky ? (state.team_sticky[chatIdStr] || state.team_sticky[_rawChatId]) : null;
+    const stickyMember = threadScoped && stickyKey && mappedProject && Array.isArray(mappedProject.team)
+      ? mappedProject.team.find((member) => member && member.key === stickyKey)
+      : null;
+    const preferredEngine = String(
+      (stickyMember && stickyMember.engine)
+      || (mappedProject && mappedProject.engine)
+      || getDefaultEngine()
+    ).toLowerCase();
     const candidateIds = [
+      stickyMember ? `_agent_${stickyMember.key}` : null,
       mappedKey ? buildSessionChatId(chatIdStr, mappedKey) : null,
       buildSessionChatId(chatIdStr),
       chatIdStr,
@@ -212,7 +222,8 @@ function createCommandRouter(deps) {
       ...(cfg.imessage ? cfg.imessage.chat_agent_map : {}),
       ...(cfg.siri_bridge ? cfg.siri_bridge.chat_agent_map : {}),
     };
-    const key = map[String(chatId)];
+    const chatIdStr = String(chatId);
+    const key = map[chatIdStr] || map[extractOriginalChatId(chatIdStr)];
     const proj = key && cfg.projects ? cfg.projects[key] : null;
     return { key: key || null, project: proj || null };
   }
@@ -387,17 +398,23 @@ function createCommandRouter(deps) {
     };
     const _chatIdStr = String(chatId);
     const _rawChatId2 = extractOriginalChatId(_chatIdStr);
+    const _threadScoped = isThreadChatId(_chatIdStr);
     const mappedKey = chatAgentMap[_chatIdStr] ||
       chatAgentMap[_rawChatId2] ||
       projectKeyFromVirtualChatId(_chatIdStr);
     if (mappedKey && config.projects && config.projects[mappedKey]) {
       const proj = config.projects[mappedKey];
-      const projCwd = normalizeCwd(proj.cwd);
-      const sessionChatId = buildSessionChatId(chatId, mappedKey);
+      const stickyKey = state && state.team_sticky ? (state.team_sticky[_chatIdStr] || state.team_sticky[_rawChatId2]) : null;
+      const stickyMember = _threadScoped && stickyKey && Array.isArray(proj.team)
+        ? proj.team.find((member) => member && member.key === stickyKey)
+        : null;
+      const targetEngine = (stickyMember && stickyMember.engine) || proj.engine || getDefaultEngine();
+      const projCwd = normalizeCwd((stickyMember && stickyMember.cwd) || proj.cwd);
+      const sessionChatId = stickyMember ? `_agent_${stickyMember.key}` : buildSessionChatId(chatId, mappedKey);
       const sessions = loadState().sessions || {};
       const cur = sessions[sessionChatId];
       const rawSession = sessions[String(chatId)];
-      const projEngine = String((proj && proj.engine) || getDefaultEngine()).toLowerCase();
+      const projEngine = String(targetEngine).toLowerCase();
       // Multi-engine format stores engines in cur.engines object; legacy format uses cur.engine string.
       // Check whether the session already has a slot for the project's configured engine.
       const curHasEngine = cur && (
@@ -408,15 +425,17 @@ function createCommandRouter(deps) {
       );
       const isVirtualSession = _chatIdStr.startsWith('_agent_') || _chatIdStr.startsWith('_scope_');
       const shouldReattachForCwdChange =
+        !stickyMember &&
         !isVirtualSession &&
         !!cur &&
         !!curHasEngine &&
         cur.cwd !== projCwd &&
         !rawHasEngine;
-      if (!cur || !curHasEngine || shouldReattachForCwdChange) {
+      const _isControlCmd = text && /^\/(stop|quit)$/.test(text.trim());
+      if (!_isControlCmd && (!cur || !curHasEngine || shouldReattachForCwdChange)) {
         const initReason = !cur ? 'no-session' : (!curHasEngine ? 'engine-missing' : 'cwd-changed');
         log('INFO', `SESSION-INIT [${String(sessionChatId).slice(-32)}] ${initReason}`);
-        attachOrCreateSession(sessionChatId, projCwd, proj.name || mappedKey, proj.engine || getDefaultEngine());
+        attachOrCreateSession(sessionChatId, projCwd, proj.name || mappedKey, targetEngine);
       }
     }
 

package/scripts/daemon-command-session-route.js

@@ -1,6 +1,10 @@
 'use strict';
 
 const { normalizeEngineName: _normalizeEngine } = require('./daemon-utils');
+const {
+  buildBoundSessionChatId,
+  resolveSessionRoute: _resolveSessionRoute,
+} = require('./core/team-session-route');
 
 function createCommandSessionResolver(deps) {
   const {
@@ -27,11 +31,6 @@ function createCommandSessionResolver(deps) {
     return available.length === 1 ? normalizeEngineName(available[0]) : getDefaultEngine();
   }
 
-  function buildBoundSessionChatId(projectKey) {
-    const key = String(projectKey || '').trim();
-    return key ? `_bound_${key}` : '';
-  }
-
   function normalizeRouteCwd(cwd) {
     if (!cwd) return null;
     try {
@@ -48,39 +47,15 @@ function createCommandSessionResolver(deps) {
   }
 
   function getSessionRoute(chatId) {
-    const cfg = loadConfig();
-    const state = loadState();
-    const chatKey = String(chatId);
-    const agentMap = { ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}), ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}) };
-    const boundKey = agentMap[chatKey] || null;
-    const boundProj = boundKey && cfg.projects ? cfg.projects[boundKey] : null;
-    const stickyKey = state && state.team_sticky ? state.team_sticky[chatKey] : null;
-    const stickyMember = stickyKey && boundProj && Array.isArray(boundProj.team)
-      ? boundProj.team.find((m) => m && m.key === stickyKey)
-      : null;
-
-    if (stickyMember) {
-      return {
-        sessionChatId: `_agent_${stickyMember.key}`,
-        cwd: normalizeRouteCwd(stickyMember.cwd || (boundProj && boundProj.cwd) || null),
-        engine: normalizeEngineName(stickyMember.engine || (boundProj && boundProj.engine)),
-      };
-    }
-
-    if (boundProj) {
-      return {
-        sessionChatId: buildBoundSessionChatId(boundKey),
-        cwd: normalizeRouteCwd(boundProj.cwd || null),
-        engine: normalizeEngineName(boundProj.engine),
-      };
-    }
-
-    const rawSession = getSession(chatId);
-    return {
-      sessionChatId: String(chatId),
-      cwd: rawSession && rawSession.cwd ? normalizeRouteCwd(rawSession.cwd) : null,
-      engine: inferStoredEngine(rawSession),
-    };
+    return _resolveSessionRoute({
+      chatId,
+      cfg: loadConfig(),
+      state: loadState(),
+      getSession,
+      normalizeCwd: normalizeRouteCwd,
+      normalizeEngineName,
+      inferStoredEngine,
+    });
   }
 
   function getActiveSession(chatId) {

package/scripts/daemon-exec-commands.js

@@ -4,6 +4,7 @@ const { classifyTaskUsage } = require('./usage-classifier');
 const { normalizeModel } = require('./daemon-task-scheduler');
 const { resolveEngineModel } = require('./daemon-engine-runtime');
 const { createCommandSessionResolver } = require('./daemon-command-session-route');
+const { isThreadChatId: _isThreadChatId, rawChatId: _rawThreadChatId } = require('./core/thread-chat-id');
 
 function createExecCommandHandler(deps) {
   const {
@@ -218,7 +219,12 @@ function createExecCommandHandler(deps) {
       const _pl = pipeline && pipeline.current;
       if (_pl) {
         _pl.clearQueue(chatId);
-        const stopped = _pl.interruptActive(chatId);
+        let stopped = _pl.interruptActive(chatId);
+        if (!stopped && _isThreadChatId(chatId)) {
+          // Thread-scoped /stop: fall back to raw chatId (task may be keyed at group level).
+          // Do NOT clearQueue(_raw) — that would discard queued tasks from other threads.
+          stopped = _pl.interruptActive(_rawThreadChatId(chatId));
+        }
         if (stopped) {
           await bot.sendMessage(chatId, '⏹ Stopping current engine task...');
         } else {
@@ -226,7 +232,8 @@ function createExecCommandHandler(deps) {
         }
       } else {
         // Fallback: direct activeProcesses manipulation (pipeline not yet initialized)
-        const proc = activeProcesses.get(chatId);
+        const _raw = _isThreadChatId(chatId) ? _rawThreadChatId(chatId) : null;
+        const proc = activeProcesses.get(chatId) || (_raw && activeProcesses.get(_raw));
         if (proc && proc.child) {
           proc.aborted = true;
           const signal = proc.killSignal || 'SIGTERM';
@@ -248,9 +255,12 @@ function createExecCommandHandler(deps) {
       const _pl = pipeline && pipeline.current;
       if (_pl) {
         _pl.clearQueue(chatId);
-        _pl.interruptActive(chatId);
+        if (!_pl.interruptActive(chatId) && _isThreadChatId(chatId)) {
+          _pl.interruptActive(_rawThreadChatId(chatId));
+        }
       } else {
-        const proc = activeProcesses.get(chatId);
+        const _raw = _isThreadChatId(chatId) ? _rawThreadChatId(chatId) : null;
+        const proc = activeProcesses.get(chatId) || (_raw && activeProcesses.get(_raw));
         if (proc && proc.child) {
           proc.aborted = true;
           const signal = proc.killSignal || 'SIGTERM';