metame-cli 1.5.4 → 1.5.5

package/scripts/daemon-bridges.js

@@ -4,6 +4,8 @@ let userAcl = null;
 try { userAcl = require('./daemon-user-acl'); } catch { /* optional */ }
 const { findTeamMember: _findTeamMember } = require('./team-dispatch');
 const { isRemoteMember } = require('./daemon-remote-dispatch');
+const imessageIO = (() => { try { return require('./daemon-siri-imessage'); } catch { return null; } })();
+const siriBridgeMod = (() => { try { return require('./daemon-siri-bridge'); } catch { return null; } })();
 
 function createBridgeStarter(deps) {
   const {
@@ -16,6 +18,7 @@ function createBridgeStarter(deps) {
     loadState,
     saveState,
     getSession,
+    restoreSessionFromReply,
     handleCommand,
     pendingActivations,  // optional — used to show smart activation hint
     activeProcesses,     // optional — used for auto-dispatch to clones
@@ -82,7 +85,7 @@ function createBridgeStarter(deps) {
     return latest;
   }
 
-  function unauthorizedMsg(chatId, useSend) {
+  function unauthorizedMsg(chatId) {
     const pending = getPendingActivationForChat(chatId);
     if (pending) {
       return `⚠️ 此群未授权\n\n发送以下命令激活 Agent「${pending.agentName}」：\n\`/activate\``;
@@ -90,11 +93,71 @@ function createBridgeStarter(deps) {
     return '⚠️ 此群未授权\n\n如已创建 Agent，发送 `/activate` 完成绑定。\n否则请先在主群创建 Agent。';
   }
 
+  function extractFeishuReplyMessageId(event) {
+    const candidates = [
+      event && event.message && event.message.parent_id,
+      event && event.message && event.message.parent_message_id,
+      event && event.message && event.message.root_id,
+      event && event.message && event.message.reply_in_thread_id,
+      event && event.event && event.event.message && event.event.message.parent_id,
+      event && event.event && event.event.message && event.event.message.parent_message_id,
+      event && event.event && event.event.message && event.event.message.root_id,
+      event && event.event && event.event.message && event.event.message.reply_in_thread_id,
+    ];
+    for (const value of candidates) {
+      const text = String(value || '').trim();
+      if (text) return text;
+    }
+    return null;
+  }
+
+  function trackBridgeReplyMapping(messageId, payload = {}) {
+    const safeMessageId = String(messageId || '').trim();
+    if (!safeMessageId) return;
+    const state = loadState();
+    if (!state.msg_sessions) state.msg_sessions = {};
+    state.msg_sessions[safeMessageId] = {
+      ...(state.msg_sessions[safeMessageId] || {}),
+      ...payload,
+    };
+    saveState(state);
+  }
+
+  function inferSessionMapping(logicalChatId, fallback = {}) {
+    const chatKey = String(logicalChatId || '').trim();
+    if (!chatKey) return { ...fallback };
+    const state = loadState();
+    const raw = state.sessions && state.sessions[chatKey];
+    if (!raw || typeof raw !== 'object') {
+      return {
+        logicalChatId: chatKey,
+        ...fallback,
+      };
+    }
+    const engines = raw.engines && typeof raw.engines === 'object' ? raw.engines : {};
+    const preferredEngine = String(fallback.engine || '').trim().toLowerCase();
+    const slot = (preferredEngine && engines[preferredEngine])
+      || engines.codex
+      || engines.claude
+      || null;
+    return {
+      ...(slot && slot.id ? { id: String(slot.id) } : {}),
+      cwd: raw.cwd || fallback.cwd,
+      engine: preferredEngine || (engines.codex ? 'codex' : 'claude'),
+      logicalChatId: chatKey,
+      ...((slot && slot.sandboxMode) ? { sandboxMode: slot.sandboxMode } : {}),
+      ...((slot && slot.approvalPolicy) ? { approvalPolicy: slot.approvalPolicy } : {}),
+      ...((slot && slot.permissionMode) ? { permissionMode: slot.permissionMode } : {}),
+      ...fallback,
+    };
+  }
+
   // ── Team group helpers ─────────────────────────────────────────────────
   function _getBoundProject(chatId, cfg) {
     const map = {
-      ...(cfg.telegram ? cfg.telegram.chat_agent_map || {} : {}),
-      ...(cfg.feishu ? cfg.feishu.chat_agent_map || {} : {}),
+      ...(cfg.telegram  ? cfg.telegram.chat_agent_map  || {} : {}),
+      ...(cfg.feishu    ? cfg.feishu.chat_agent_map    || {} : {}),
+      ...(cfg.imessage  ? cfg.imessage.chat_agent_map  || {} : {}),
     };
     const key = map[String(chatId)];
     const proj = key && cfg.projects ? cfg.projects[key] : null;
@@ -104,7 +167,7 @@ function createBridgeStarter(deps) {
 
   // Creates a bot proxy that redirects all send methods to replyChatId
   function _createTeamProxyBot(bot, replyChatId) {
-    const SEND = new Set(['sendMessage', 'sendMarkdown', 'sendCard', 'editMessage', 'deleteMessage', 'sendTyping', 'sendFile', 'sendButtonCard']);
+    const SEND = new Set(['sendMessage', 'sendMarkdown', 'sendCard', 'editMessage', 'deleteMessage', 'sendTyping', 'sendFile', 'sendButtons', 'sendButtonCard']);
     return new Proxy(bot, {
       get(target, prop) {
         const orig = target[prop];
@@ -201,6 +264,7 @@ function createBridgeStarter(deps) {
         prompt: text,
         source_chat_id: String(realChatId),
         source_sender_key: acl.senderId || 'user',
+        source_sender_id: acl.senderId || '',
       }, cfg).then(res => {
         if (res.success) {
           bot.sendMessage(realChatId, `📡 已发送给 ${member.icon || '🤖'} ${member.name} (${member.peer})`).catch(() => {});
@@ -260,12 +324,16 @@ function createBridgeStarter(deps) {
 
     let offset = 0;
     let running = true;
-    const abortController = new AbortController();
+    let abortController = new AbortController();
+    let pollLoopActive = false;
+    let reconnectTimer = null;
 
-    const pollLoop = async () => {
-      while (running) {
-        try {
-          const updates = await bot.getUpdates(offset, 30, abortController.signal);
+    const pollLoop = async (signal) => {
+      pollLoopActive = true;
+      try {
+        while (running && signal === abortController.signal) {
+          try {
+            const updates = await bot.getUpdates(offset, 30, signal);
           for (const update of updates) {
             offset = update.update_id + 1;
 
@@ -377,11 +445,29 @@ function createBridgeStarter(deps) {
 
               // Team group routing for Telegram (same logic as Feishu)
               const trimmedText = text.trim();
+              const parentId = msg.reply_to_message && msg.reply_to_message.message_id
+                ? String(msg.reply_to_message.message_id)
+                : null;
+              let _replyAgentKey = null;
               const { key: _boundKey, project: _boundProj } = _getBoundProject(chatId, liveCfg);
               const _isTeamSlashCmd = trimmedText.startsWith('/') && !/^\/stop(\s|$)/i.test(trimmedText);
 
               // Load sticky state
               const _st = loadState();
+              if (parentId) {
+                const mapped = _st.msg_sessions && _st.msg_sessions[parentId];
+                if (mapped) {
+                  if (typeof restoreSessionFromReply === 'function') {
+                    restoreSessionFromReply(chatId, mapped);
+                  } else {
+                    if (!_st.sessions) _st.sessions = {};
+                    _st.sessions[chatId] = { id: mapped.id, cwd: mapped.cwd, started: true };
+                    saveState(_st);
+                  }
+                  log('INFO', `Telegram session restored via reply: ${mapped.id.slice(0, 8)} (${path.basename(mapped.cwd)})`);
+                  _replyAgentKey = mapped.agentKey || null;
+                }
+              }
               const _chatKey = String(chatId);
               const _setSticky = (key) => {
                 if (!_st.team_sticky) _st.team_sticky = {};
@@ -399,24 +485,55 @@ function createBridgeStarter(deps) {
                 const _stopMatch = trimmedText && trimmedText.match(/^\/stop(?:\s+(.+))?$/i);
                 if (_stopMatch) {
                   const _stopArg = (_stopMatch[1] || '').trim();
-                  if (_stopArg) {
+                  let _targetKey = null;
+                  if (_replyAgentKey) {
+                    const m = _boundProj.team.find(t => t.key === _replyAgentKey);
+                    if (m) _targetKey = m.key;
+                  }
+                  if (!_targetKey && _stopArg) {
                     const _sa = _stopArg.toLowerCase();
                     const m = _boundProj.team.find(t =>
                       (t.nicknames || []).some(n => n.toLowerCase() === _sa) || (t.name && t.name.toLowerCase() === _sa) || t.key === _sa
                     );
-                    if (m) {
-                      _clearSticky();
-                      log('INFO', `Team /stop: ${_chatKey.slice(-8)} → cleared sticky`);
-                      await bot.sendMessage(chatId, `⏹ 已切换回主 Agent`).catch(() => {});
+                    if (m) _targetKey = m.key;
+                  }
+                  if (!_targetKey && !_stopArg) _targetKey = _stickyKey;
+                  if (_targetKey) {
+                    const vid = `_agent_${_targetKey}`;
+                    const member = _boundProj.team.find(t => t.key === _targetKey);
+                    const label = member ? `${member.icon || '🤖'} ${member.name}` : _targetKey;
+                    if (messageQueue.has(vid)) {
+                      const vq = messageQueue.get(vid);
+                      if (vq && vq.timer) clearTimeout(vq.timer);
+                      messageQueue.delete(vid);
+                    }
+                    const vproc = activeProcesses && activeProcesses.get(vid);
+                    if (vproc && vproc.child) {
+                      vproc.aborted = true;
+                      const sig = vproc.killSignal || 'SIGTERM';
+                      try { process.kill(-vproc.child.pid, sig); } catch { try { vproc.child.kill(sig); } catch { /* */ } }
+                      await bot.sendMessage(chatId, `⏹ Stopping ${label}...`);
                     } else {
-                      await bot.sendMessage(chatId, `❌ 未找到团队成员: ${_stopArg}`).catch(() => {});
+                      await bot.sendMessage(chatId, `${label} 当前没有活跃任务`);
                     }
                     continue;
                   }
-                  // Bare /stop, clear sticky
-                  _clearSticky();
-                  await bot.sendMessage(chatId, `⏹ 已切换回主 Agent`).catch(() => {});
-                  continue;
+                  if (_stopArg) {
+                    await bot.sendMessage(chatId, `❌ 未找到团队成员: ${_stopArg}`).catch(() => {});
+                    continue;
+                  }
+                }
+
+                // 0. Quoted reply → force route + set sticky
+                if (_replyAgentKey) {
+                  const member = _boundProj.team.find(m => m.key === _replyAgentKey);
+                  if (member) {
+                    _setSticky(member.key);
+                    log('INFO', `Telegram quoted reply → force route to ${_replyAgentKey} (sticky set)`);
+                    _dispatchToTeamMember(member, _boundProj, trimmedText, liveCfg, bot, chatId, executeTaskByName, acl);
+                    continue;
+                  }
+                  log('INFO', `Telegram quoted reply agentKey=${_replyAgentKey} not in team, falling through`);
                 }
 
                 // 1. Explicit nickname → route + set sticky
@@ -472,16 +589,21 @@ function createBridgeStarter(deps) {
               });
             }
           }
-        } catch (e) {
-          if (e.message === 'aborted') break;
-          log('ERROR', `Telegram poll error: ${e.message}`);
-          await sleep(5000);
+          } catch (e) {
+            if (e.message === 'aborted') break;
+            log('ERROR', `Telegram poll error: ${e.message}`);
+            await sleep(5000);
+          }
         }
+      } finally {
+        pollLoopActive = false;
       }
     };
 
     const startPoll = () => {
-      pollLoop().catch(e => {
+      if (!running || pollLoopActive) return;
+      const signal = abortController.signal;
+      pollLoop(signal).catch(e => {
         if (e.message === 'aborted') return;
         log('ERROR', `pollLoop crashed: ${e.message} — restarting in 5s`);
         if (running) setTimeout(startPoll, 5000);
@@ -490,7 +612,24 @@ function createBridgeStarter(deps) {
     startPoll();
 
     return {
-      stop() { running = false; abortController.abort(); },
+      stop() {
+        running = false;
+        if (reconnectTimer) clearTimeout(reconnectTimer);
+        abortController.abort();
+      },
+      reconnect() {
+        if (!running) return;
+        if (reconnectTimer) clearTimeout(reconnectTimer);
+        try { abortController.abort(); } catch { /* ignore */ }
+        abortController = new AbortController();
+        reconnectTimer = setTimeout(() => {
+          reconnectTimer = null;
+          startPoll();
+        }, 150);
+      },
+      isAlive() {
+        return running && (pollLoopActive || !abortController.signal.aborted);
+      },
       bot,
     };
   }
@@ -508,6 +647,12 @@ function createBridgeStarter(deps) {
     try {
       const receiver = await bot.startReceiving(async (chatId, text, event, fileInfo, senderId) => {
         const liveCfg = loadConfig();
+        const relayCfg = liveCfg && liveCfg.feishu && liveCfg.feishu.remote_dispatch;
+        const relayChatId = relayCfg && relayCfg.chat_id ? String(relayCfg.chat_id) : '';
+        if (relayChatId && String(chatId) === relayChatId) {
+          const preview = String(text || '').slice(0, 80).replace(/\s+/g, ' ');
+          log('INFO', `Feishu relay event chat=${chatId} sender=${senderId || 'unknown'} preview=${preview}`);
+        }
 
         // ── Remote dispatch interception (before ACL) ──
         if (handleRemoteDispatchMessage && text) {
@@ -575,18 +720,31 @@ function createBridgeStarter(deps) {
           });
           if (acl.blocked) return;
           log('INFO', `Feishu message from ${chatId}: ${text.slice(0, 50)}`);
-          const parentId = event?.message?.parent_id;
+          const parentId = extractFeishuReplyMessageId(event);
           let _replyAgentKey = null;
           // Load state once for the entire routing block
           const _st = loadState();
+          if (parentId) {
+            log('INFO', `Feishu reply metadata detected chat=${chatId} parentId=${parentId}`);
+          }
           if (parentId) {
             const mapped = _st.msg_sessions && _st.msg_sessions[parentId];
             if (mapped) {
-              if (!_st.sessions) _st.sessions = {};
-              _st.sessions[chatId] = { id: mapped.id, cwd: mapped.cwd, started: true };
-              saveState(_st);
-              log('INFO', `Session restored via reply: ${mapped.id.slice(0, 8)} (${path.basename(mapped.cwd)})`);
+              if (typeof restoreSessionFromReply === 'function') {
+                restoreSessionFromReply(chatId, mapped);
+              } else {
+                if (mapped.id) {
+                  if (!_st.sessions) _st.sessions = {};
+                  _st.sessions[chatId] = { id: mapped.id, cwd: mapped.cwd, started: true };
+                  saveState(_st);
+                }
+              }
+              if (mapped.id) {
+                log('INFO', `Session restored via reply: ${mapped.id.slice(0, 8)} (${path.basename(mapped.cwd)})`);
+              }
               _replyAgentKey = mapped.agentKey || null;
+            } else {
+              log('INFO', `Feishu reply parentId=${parentId} had no msg_sessions mapping`);
             }
           }
 
@@ -670,18 +828,28 @@ function createBridgeStarter(deps) {
             }
             // 1. Explicit nickname → route + set sticky
             const teamMatch = _findTeamMember(trimmedText, _boundProj.team);
-            if (teamMatch) {
-              const { member, rest } = teamMatch;
-              _setSticky(member.key);
-              if (!rest) {
-                // Pure nickname, no task — confirm member is online
-                log('INFO', `Sticky set (pure nickname): ${_chatKey.slice(-8)} → ${member.key}`);
-                bot.sendMarkdown(chatId, `${member.icon || '🤖'} **${member.name}** 在线`).catch(() => {});
-                return;
-              }
-              log('INFO', `Sticky set: ${_chatKey.slice(-8)} → ${member.key}`);
-              _dispatchToTeamMember(member, _boundProj, rest, liveCfg, bot, chatId, executeTaskByName, acl);
-              return;
+              if (teamMatch) {
+                  const { member, rest } = teamMatch;
+                  _setSticky(member.key);
+                  if (!rest) {
+                    // Pure nickname, no task — confirm member is online
+                    log('INFO', `Sticky set (pure nickname): ${_chatKey.slice(-8)} → ${member.key}`);
+                    bot.sendMarkdown(chatId, `${member.icon || '🤖'} **${member.name}** 在线`)
+                      .then((msg) => {
+                        if (msg && msg.message_id) {
+                          trackBridgeReplyMapping(msg.message_id, inferSessionMapping(`_agent_${member.key}`, {
+                            agentKey: member.key,
+                            cwd: member.cwd || _boundProj.cwd,
+                            engine: member.engine || _boundProj.engine || 'claude',
+                          }));
+                        }
+                      })
+                      .catch(() => {});
+                    return;
+                  }
+                  log('INFO', `Sticky set: ${_chatKey.slice(-8)} → ${member.key}`);
+                  _dispatchToTeamMember(member, _boundProj, rest, liveCfg, bot, chatId, executeTaskByName, acl);
+                  return;
             }
 
             // 1.5. Main project nickname → clear sticky, route to main
@@ -691,11 +859,22 @@ function createBridgeStarter(deps) {
             if (_mainMatch) {
               _clearSticky();
               const rest = trimmedText.slice(_mainMatch.length).replace(/^[\s,，:：]+/, '');
-              log('INFO', `Main nickname → cleared sticky, routing to main${rest ? ` (task: ${rest.slice(0, 30)})` : ''}`);
-              if (!rest) {
-                bot.sendMarkdown(chatId, `${_boundProj.icon || '🤖'} **${_boundProj.name}** 在线`).catch(() => {});
-                return;
-              }
+                  log('INFO', `Main nickname → cleared sticky, routing to main${rest ? ` (task: ${rest.slice(0, 30)})` : ''}`);
+                  if (!rest) {
+                    bot.sendMarkdown(chatId, `${_boundProj.icon || '🤖'} **${_boundProj.name}** 在线`)
+                      .then((msg) => {
+                        if (msg && msg.message_id) {
+                          trackBridgeReplyMapping(msg.message_id, inferSessionMapping(String(chatId), {
+                            agentKey: _boundKey || null,
+                            cwd: _boundProj.cwd,
+                            engine: _boundProj.engine || 'claude',
+                            logicalChatId: _boundKey ? `_bound_${_boundKey}` : String(chatId),
+                          }));
+                        }
+                      })
+                      .catch(() => {});
+                    return;
+                  }
               try {
                 await handleCommand(bot, chatId, rest, liveCfg, executeTaskByName, acl.senderId, acl.readOnly);
               } catch (e) {
@@ -729,7 +908,227 @@ function createBridgeStarter(deps) {
     }
   }
 
-  return { startTelegramBridge, startFeishuBridge };
+  // ── iMessage Bridge ─────────────────────────────────────────────────────────
+  async function startImessageBridge(config, executeTaskByName) {
+    const cfg = config.imessage || {};
+    if (!cfg.enabled) return null;
+    if (!imessageIO) { log('WARN', '[IMESSAGE] daemon-siri-imessage module not found'); return null; }
+    if (!imessageIO.isAvailable()) { log('WARN', '[IMESSAGE] chat.db not found — bridge disabled'); return null; }
+
+    const selfId = cfg.self_id || '';
+    const allowedSenders = cfg.allowed_senders || (selfId ? [selfId] : []);
+    const allowedChats = cfg.allowed_chat_ids || [];
+    const pollMs = cfg.poll_ms || 2000;
+
+    if (!selfId) { log('WARN', '[IMESSAGE] self_id not configured — bridge disabled'); return null; }
+
+    let lastRowId  = imessageIO.getMaxRowId();
+    let processing = false;
+    let running    = true;
+
+    // Per-chat persistent bot instances (preserve state across polls)
+    const chatBots = new Map();
+    const getBot = (chatTarget) => {
+      if (!chatBots.has(chatTarget)) {
+        const bot = imessageIO.createImessageBot(chatTarget, log);
+        // After bot sends a reply, advance lastRowId immediately + again after delay
+        if (bot.setOnAfterSend) {
+          bot.setOnAfterSend(() => {
+            // Immediate advance — covers fast echo
+            const freshNow = imessageIO.getMaxRowId();
+            if (freshNow > lastRowId) {
+              log('INFO', `[IMESSAGE] Advanced lastRowId ${lastRowId}→${freshNow} (echo skip immediate)`);
+              lastRowId = freshNow;
+            }
+            // Delayed advance — covers slow iCloud sync echo
+            setTimeout(() => {
+              const freshLater = imessageIO.getMaxRowId();
+              if (freshLater > lastRowId) {
+                log('INFO', `[IMESSAGE] Advanced lastRowId ${lastRowId}→${freshLater} (echo skip delayed)`);
+                lastRowId = freshLater;
+              }
+            }, 3000);
+          });
+        }
+        chatBots.set(chatTarget, bot);
+      }
+      return chatBots.get(chatTarget);
+    };
+
+    log('INFO', `[IMESSAGE] Bridge started (poll=${pollMs}ms, self=${selfId}, lastRowId=${lastRowId})`);
+
+    const timer = setInterval(async () => {
+      if (!running || processing) return;
+      processing = true;
+      try {
+        const rows = imessageIO.queryNewMessages(lastRowId);
+        if (!rows) { processing = false; return; }
+
+        for (const row of rows.split('\n').filter(Boolean)) {
+          const parts = row.split('\t');
+          const rowId = parseInt(parts[0], 10);
+          const text = (parts[1] || '').trim();
+          const sender = (parts[2] || '').trim();
+          const chatGuid = (parts[3] || '').trim();
+          const chatIdentifier = (parts[4] || '').trim();
+          const chatName = (parts[5] || '').trim();
+          const chatTarget = chatGuid || chatIdentifier || sender;
+
+          if (!rowId || rowId <= lastRowId) continue;
+          lastRowId = rowId;
+          if (!text) continue;
+          if (!chatTarget) continue;
+
+          if (allowedSenders.length && !allowedSenders.includes(sender)) {
+            log('INFO', `[IMESSAGE] Ignored message from ${sender} (not in allowed_senders)`);
+            continue;
+          }
+          if (allowedChats.length && !allowedChats.includes(chatTarget) && !allowedChats.includes(chatIdentifier)) {
+            log('INFO', `[IMESSAGE] Ignored chat ${chatTarget} (${chatName || sender || 'unknown'}) not in allowed_chat_ids`);
+            continue;
+          }
+
+          const chatId = chatTarget;
+          const liveCfg = loadConfig();
+          const bot = getBot(chatTarget);
+
+          // Echo fingerprint check — skip if this text matches something we recently sent
+          if (bot.isEcho && bot.isEcho(text)) {
+            log('INFO', `[IMESSAGE] Skipped echo: "${text.slice(0, 40)}"`);
+            continue;
+          }
+
+          const trimmedText = text.trim();
+          let commandText = text;
+
+          log('INFO', `[IMESSAGE] Received chat=${chatTarget} sender=${sender || 'unknown'} name=${chatName || '-'}: "${text.slice(0, 60)}"`);
+
+          const acl = await applyUserAcl({
+            bot,
+            chatId,
+            text,
+            config: liveCfg,
+            senderId: sender,
+            bypassAcl: false,
+          });
+          if (acl.blocked) continue;
+
+          const { project: _boundProj } = _getBoundProject(chatId, liveCfg);
+          const _isTeamSlashCmd = trimmedText.startsWith('/') && !/^\/stop(\s|$)/i.test(trimmedText);
+          const _st = loadState();
+          const _chatKey = String(chatId);
+          const _setSticky = (key) => {
+            if (!_st.team_sticky) _st.team_sticky = {};
+            _st.team_sticky[_chatKey] = key;
+            saveState(_st);
+          };
+          const _clearSticky = () => {
+            if (_st.team_sticky) delete _st.team_sticky[_chatKey];
+            saveState(_st);
+          };
+          const _stickyKey = (_st.team_sticky || {})[_chatKey] || null;
+
+          if (_boundProj && Array.isArray(_boundProj.team) && _boundProj.team.length > 0 && !_isTeamSlashCmd) {
+            const _stopMatch = trimmedText.match(/^\/stop(?:\s+(.+))?$/i);
+            if (_stopMatch) {
+              const _stopArg = (_stopMatch[1] || '').trim();
+              let _targetKey = null;
+              if (_stopArg) {
+                const _sa = _stopArg.toLowerCase();
+                const m = _boundProj.team.find(t =>
+                  (t.nicknames || []).some(n => n.toLowerCase() === _sa) || (t.name && t.name.toLowerCase() === _sa) || t.key === _sa
+                );
+                if (m) _targetKey = m.key;
+              }
+              if (!_targetKey && !_stopArg) _targetKey = _stickyKey;
+              if (_targetKey) {
+                const vid = `_agent_${_targetKey}`;
+                const member = _boundProj.team.find(t => t.key === _targetKey);
+                const label = member ? `${member.icon || '🤖'} ${member.name}` : _targetKey;
+                if (messageQueue.has(vid)) {
+                  const vq = messageQueue.get(vid);
+                  if (vq && vq.timer) clearTimeout(vq.timer);
+                  messageQueue.delete(vid);
+                }
+                const vproc = activeProcesses && activeProcesses.get(vid);
+                if (vproc && vproc.child) {
+                  vproc.aborted = true;
+                  const sig = vproc.killSignal || 'SIGTERM';
+                  try { process.kill(-vproc.child.pid, sig); } catch { try { vproc.child.kill(sig); } catch { /* */ } }
+                  await bot.sendMessage(chatId, `Stopping ${label}...`);
+                } else {
+                  await bot.sendMessage(chatId, `${label} 当前没有活跃任务`);
+                }
+                continue;
+              }
+              if (_stopArg) {
+                await bot.sendMessage(chatId, `未找到团队成员: ${_stopArg}`);
+                continue;
+              }
+            }
+
+            const teamMatch = _findTeamMember(trimmedText, _boundProj.team);
+            if (teamMatch) {
+              const { member, rest } = teamMatch;
+              _setSticky(member.key);
+              if (!rest) {
+                await bot.sendMessage(chatId, `${member.icon || '🤖'} ${member.name} 在线`);
+                continue;
+              }
+              log('INFO', `[IMESSAGE] Team route ${chatId} -> ${member.key}`);
+              _dispatchToTeamMember(member, _boundProj, rest, liveCfg, bot, chatId, executeTaskByName, acl);
+              continue;
+            }
+
+            const _mainNicks = Array.isArray(_boundProj.nicknames) ? _boundProj.nicknames : [];
+            const _trimLower = trimmedText.toLowerCase();
+            const _mainMatch = _mainNicks.find(n =>
+              _trimLower === n.toLowerCase()
+              || _trimLower.startsWith(n.toLowerCase() + ' ')
+              || _trimLower.startsWith(n.toLowerCase() + '，')
+              || _trimLower.startsWith(n.toLowerCase() + ',')
+            );
+            if (_mainMatch) {
+              _clearSticky();
+              const rest = trimmedText.slice(_mainMatch.length).replace(/^[\s,，:：]+/, '');
+              if (!rest) {
+                await bot.sendMessage(chatId, `${_boundProj.icon || '🤖'} ${_boundProj.name || 'Agent'} 在线`);
+                continue;
+              }
+              commandText = rest;
+            } else if (_stickyKey) {
+              const member = _boundProj.team.find(m => m.key === _stickyKey);
+              if (member) {
+                log('INFO', `[IMESSAGE] Sticky route ${chatId} -> ${member.key}`);
+                _dispatchToTeamMember(member, _boundProj, trimmedText, liveCfg, bot, chatId, executeTaskByName, acl);
+                continue;
+              }
+            }
+          }
+
+          handleCommand(bot, chatId, commandText, liveCfg, executeTaskByName, sender, false)
+            .catch(e => log('ERROR', `[IMESSAGE] handleCommand error: ${e.message}`));
+        }
+      } catch (e) {
+        log('WARN', `[IMESSAGE] poll error: ${e.message}`);
+      }
+      processing = false;
+    }, pollMs);
+
+    return {
+      stop: () => { running = false; clearInterval(timer); },
+      bot: imessageIO.createImessageBot(selfId, log),
+    };
+  }
+
+  // ── Siri HTTP Bridge ────────────────────────────────────────────────────────
+  function startSiriBridge(config, executeTaskByName) {
+    if (!siriBridgeMod) { log('WARN', '[SIRI] daemon-siri-bridge module not found'); return null; }
+    const bridge = siriBridgeMod.createSiriBridge({ log, loadConfig, handleCommand });
+    return bridge.startSiriBridge(config, executeTaskByName);
+  }
+
+  return { startTelegramBridge, startFeishuBridge, startImessageBridge, startSiriBridge };
 }
 
 module.exports = { createBridgeStarter };