metame-cli 1.5.4 → 1.5.5

package/scripts/daemon.js

@@ -47,7 +47,7 @@ const LOG_FILE = path.join(METAME_DIR, 'daemon.log');
 const BRAIN_FILE = path.join(HOME, '.claude_profile.yaml');
 const DISPATCH_DIR = path.join(METAME_DIR, 'dispatch');
 const DISPATCH_LOG = path.join(DISPATCH_DIR, 'dispatch-log.jsonl');
-const { socketPath, needsSocketCleanup } = require('./platform');
+const { sleepSync, socketPath, needsSocketCleanup } = require('./platform');
 const SOCK_PATH = socketPath(METAME_DIR);
 
 // Resolve claude binary path (daemon may not inherit user's full PATH)
@@ -69,6 +69,8 @@ const CLAUDE_BIN = (() => {
 // Skill evolution module (hot path + cold path)
 let skillEvolution = null;
 try { skillEvolution = require('./skill-evolution'); } catch { /* graceful fallback */ }
+let userAcl = null;
+try { userAcl = require('./daemon-user-acl'); } catch { /* optional */ }
 const {
   normalizeRemoteDispatchConfig,
   encodePacket: encodeRemoteDispatchPacket,
@@ -84,18 +86,15 @@ function isMacLocalOrchestratorIntent(prompt) {
   const text = String(prompt || '').trim();
   if (!text) return false;
 
-  // Explicit macOS automation keywords.
-  if (/\b(?:mac|macos|applescript|osascript|jxa|hammerspoon|aerospace|yabai|skhd|raycast|launchctl|keyboard maestro)\b/i.test(text)) {
-    return true;
-  }
-  if (/(自动化|辅助功能|系统设置|隐私|权限|锁屏|锁定屏幕|睡眠|休眠|静音|取消静音|音量)/.test(text)) {
-    return true;
-  }
+  const hasAutomationVerb = /(?:自动化|脚本|控制|操作|执行|设置|调整|打开|关闭|启动|退出|切到|唤起|锁屏|锁定屏幕|睡眠|休眠|静音|取消静音|调(?:高|低|整)?音量|open|launch|quit|activate|lock\s*screen|sleep|mute|unmute|set\s+volume|run\s+(?:an?\s+)?script)/i.test(text);
+  const hasMacTool = /\b(?:mac|macos|applescript|osascript|jxa|hammerspoon|aerospace|yabai|skhd|raycast|launchctl|keyboard maestro|shortcuts)\b/i.test(text);
+  const hasMacTarget = /(?:微信|WeChat|飞书|Feishu|Finder|Safari|Terminal|iTerm|系统设置|System Settings|辅助功能|隐私|权限|屏幕录制|自动化|电脑|桌面|访达|System Events|LaunchAgent|快捷指令|锁屏|锁定屏幕|睡眠|休眠|静音|音量|mac)/i.test(text);
+
+  // Require an actual automation ask. Mentioning "macOS" or "权限" alone should not route.
+  if (hasMacTool && hasAutomationVerb) return true;
 
-  // General verbs must be paired with explicit macOS targets to avoid over-routing.
-  const hasAction = /(?:打开|关闭|启动|退出|切到|唤起|锁屏|锁定屏幕|睡眠|休眠|静音|取消静音|调(?:高|低|整)?音量|open|launch|quit|activate|lock\s*screen|sleep|mute|unmute)/i.test(text);
-  const hasTarget = /(?:微信|WeChat|飞书|Feishu|Finder|Safari|Terminal|iTerm|系统设置|System Settings|电脑|System Events|mac)/i.test(text);
-  return hasAction && hasTarget;
+  // Natural-language control only triggers when both the action and the macOS target are explicit.
+  return hasAutomationVerb && hasMacTarget;
 }
 
 const SKILL_ROUTES = [
@@ -148,13 +147,13 @@ const { createSessionCommandHandler } = require('./daemon-session-commands');
 const { createSessionStore } = require('./daemon-session-store');
 const { createCheckpointUtils } = require('./daemon-checkpoints');
 const { createBridgeStarter } = require('./daemon-bridges');
-const { buildTeamRosterHint } = require('./team-dispatch');
+const { buildTeamRosterHint, buildEnrichedPrompt, resolveDispatchActor, updateDispatchContextFiles } = require('./team-dispatch');
 const { createFileBrowser } = require('./daemon-file-browser');
 const { createPidManager, setupRuntimeWatchers } = require('./daemon-runtime-lifecycle');
 const { repairAgentLayer } = require('./agent-layer');
 const { createNotifier } = require('./daemon-notify');
 const { createClaudeEngine } = require('./daemon-claude-engine');
-const { createEngineRuntimeFactory, detectDefaultEngine, resolveEngineModel, ENGINE_MODEL_CONFIG, ENGINE_DISTILL_MAP, ENGINE_DEFAULT_MODEL } = require('./daemon-engine-runtime');
+const { createEngineRuntimeFactory, detectDefaultEngine, resolveEngineModel, ENGINE_MODEL_CONFIG } = require('./daemon-engine-runtime');
 const { createCommandRouter } = require('./daemon-command-router');
 const { createTaskScheduler } = require('./daemon-task-scheduler');
 const { createAgentTools } = require('./daemon-agent-tools');
@@ -520,15 +519,6 @@ function recordTokens(state, tokens, meta = null) {
 }
 
 
-function getBudgetWarning(config, state) {
-  const limit = (config.budget && config.budget.daily_limit) || 50000;
-  const threshold = (config.budget && config.budget.warning_threshold) || 0.8;
-  const ratio = state.budget.tokens_used / limit;
-  if (ratio >= 1) return 'exceeded';
-  if (ratio >= threshold) return 'warning';
-  return 'ok';
-}
-
 const taskBoard = createTaskBoard({
   logger: (msg) => log('WARN', msg),
 });
@@ -540,12 +530,58 @@ const taskBoard = createTaskBoard({
 // Late-bound reference to handleCommand (defined later in file)
 let _handleCommand = null;
 let _dispatchBridgeRef = null; // Store bridge (not bot) so .bot is always the live object after reconnects
+const _pendingRemoteDispatches = new Map();
 function setDispatchHandler(fn) { _handleCommand = fn; }
 
 function getRemoteDispatchConfig(config) {
   return normalizeRemoteDispatchConfig(config || {});
 }
 
+function trackRemoteDispatch(packet) {
+  if (!packet || packet.type !== 'task') return;
+  const requestId = String(packet.id || '').trim();
+  const targetChatId = String(packet.source_chat_id || '').trim();
+  if (!requestId || !targetChatId) return;
+  const liveBot = _dispatchBridgeRef && _dispatchBridgeRef.bot;
+  const timeoutMs = 15000;
+  const existing = _pendingRemoteDispatches.get(requestId);
+  if (existing && existing.timer) clearTimeout(existing.timer);
+  const timer = setTimeout(async () => {
+    _pendingRemoteDispatches.delete(requestId);
+    const text = [
+      '⏱️ 远端 Dispatch 超时',
+      '',
+      `目标: ${packet.to_peer}:${packet.target_project || 'unknown'}`,
+      `请求: ${requestId}`,
+      `状态: 15s 内未收到回执`,
+    ].join('\n');
+    log('WARN', `Remote dispatch timeout id=${requestId} target=${packet.to_peer}:${packet.target_project || 'unknown'}`);
+    if (!liveBot) return;
+    try {
+      if (liveBot.sendMarkdown) await liveBot.sendMarkdown(targetChatId, text);
+      else await liveBot.sendMessage(targetChatId, text);
+    } catch (e) {
+      log('WARN', `Remote dispatch timeout delivery failed: ${e.message}`);
+    }
+  }, timeoutMs);
+  _pendingRemoteDispatches.set(requestId, {
+    id: requestId,
+    targetChatId,
+    targetPeer: String(packet.to_peer || '').trim(),
+    targetProject: String(packet.target_project || '').trim(),
+    timer,
+  });
+}
+
+function resolveTrackedRemoteDispatch(requestId) {
+  const key = String(requestId || '').trim();
+  if (!key) return null;
+  const tracked = _pendingRemoteDispatches.get(key) || null;
+  if (tracked && tracked.timer) clearTimeout(tracked.timer);
+  if (tracked) _pendingRemoteDispatches.delete(key);
+  return tracked;
+}
+
 async function sendRemoteDispatch(packet, config) {
   const rd = getRemoteDispatchConfig(config);
   const liveBot = _dispatchBridgeRef && _dispatchBridgeRef.bot;
@@ -562,6 +598,10 @@ async function sendRemoteDispatch(packet, config) {
       from_peer: rd.selfPeer,
     }, rd.secret);
     await liveBot.sendMessage(rd.chatId, body);
+    log('INFO', `Remote dispatch sent type=${packet.type} id=${id} to=${packet.to_peer}:${packet.target_project || 'unknown'} via=${rd.chatId}`);
+    if (packet.type === 'task') {
+      trackRemoteDispatch({ ...packet, id }, config);
+    }
     return { success: true, id };
   } catch (e) {
     return { success: false, error: e.message };
@@ -587,38 +627,91 @@ function createNullBot(onOutput) {
   };
 }
 
+function stripLeadingPlanSection(text) {
+  const src = String(text || '');
+  if (!src.trim()) return '';
+  const normalized = src.replace(/\r\n/g, '\n');
+  const paragraphs = normalized.split(/\n\s*\n/);
+  if (paragraphs.length === 0) return normalized.trim();
+  const first = String(paragraphs[0] || '').trim();
+  if (!/^计划[:：]/.test(first)) return normalized.trim();
+  const rest = paragraphs.slice(1).join('\n\n').trim();
+  if (rest) return rest;
+  const lines = normalized.split('\n');
+  const remaining = lines.slice(1).join('\n').trim();
+  return remaining || first.replace(/^计划[:：]\s*/, '').trim();
+}
+
 /**
  * Forward bot: routes all calls to a real bot with a fixed chatId.
  * Used for dispatch tasks so Claude's streaming output appears in the target's Feishu channel.
  */
-function createStreamForwardBot(realBot, chatId, onOutput = null) {
+function createStreamForwardBot(realBot, chatId, onOutput = null, opts = {}) {
   // Track edit-broken state independently so dispatch failures don't poison realBot's flag
   let _editBroken = false;
+  const ready = opts && opts.ready && typeof opts.ready.then === 'function'
+    ? opts.ready.catch(() => {})
+    : Promise.resolve();
+  async function waitUntilReady() {
+    await ready;
+  }
+  function normalizeOutput(payload) {
+    const text = typeof payload === 'object'
+      ? (payload.body || payload.title || JSON.stringify(payload))
+      : String(payload);
+    return opts.stripPlan !== false ? stripLeadingPlanSection(text) : text;
+  }
+  async function deliver(text, rawText = text) {
+    const displayText = normalizeOutput(text);
+    if (onOutput) onOutput(rawText);
+    if (opts.responseCard && realBot.sendCard) {
+      return realBot.sendCard(chatId, {
+        title: opts.responseCard.title,
+        body: displayText,
+        color: opts.responseCard.color || 'blue',
+      });
+    }
+    return realBot.sendMessage(chatId, displayText);
+  }
   return {
     sendMessage: async (_, text) => {
+      await waitUntilReady();
       log('INFO', `[StreamBot→${chatId.slice(-8)}] msg: ${String(text).slice(0, 80)}`);
-      if (onOutput) onOutput(text);
-      return realBot.sendMessage(chatId, text);
+      return deliver(text, text);
     },
     sendMarkdown: async (_, text) => {
+      await waitUntilReady();
       log('INFO', `[StreamBot→${chatId.slice(-8)}] md: ${String(text).slice(0, 80)}`);
+      if (opts.responseCard && realBot.sendCard) {
+        const displayText = normalizeOutput(text);
+        if (onOutput) onOutput(text);
+        return realBot.sendCard(chatId, {
+          title: opts.responseCard.title,
+          body: displayText,
+          color: opts.responseCard.color || 'blue',
+        });
+      }
+      const displayText = normalizeOutput(text);
       if (onOutput) onOutput(text);
-      return realBot.sendMarkdown(chatId, text);
+      return realBot.sendMarkdown(chatId, displayText);
     },
     sendCard: async (_, card) => {
+      await waitUntilReady();
       const title = typeof card === 'object' ? (card.title || card.body || '').slice(0, 60) : String(card).slice(0, 60);
       log('INFO', `[StreamBot→${chatId.slice(-8)}] card: ${title}`);
       if (onOutput) onOutput(typeof card === 'object' ? (card.body || card.title || JSON.stringify(card)) : card);
       return realBot.sendCard(chatId, card);
     },
     sendRawCard: async (_, header, elements) => {
+      await waitUntilReady();
       log('INFO', `[StreamBot→${chatId.slice(-8)}] rawcard: ${String(header).slice(0, 60)}`);
       if (onOutput) onOutput(header);
       return realBot.sendRawCard(chatId, header, elements);
     },
-    sendButtons: async (_, text, buttons) => realBot.sendButtons(chatId, text, buttons),
-    sendTyping: async () => realBot.sendTyping(chatId),
+    sendButtons: async (_, text, buttons) => { await waitUntilReady(); return realBot.sendButtons(chatId, text, buttons); },
+    sendTyping: async () => { await waitUntilReady(); return realBot.sendTyping(chatId); },
     editMessage: async (_, msgId, text) => {
+      await waitUntilReady();
       if (_editBroken) return false;
       log('INFO', `[StreamBot→${chatId.slice(-8)}] edit ${String(msgId).slice(-8)}: ${String(text).slice(0, 60)}`);
       try {
@@ -631,8 +724,8 @@ function createStreamForwardBot(realBot, chatId, onOutput = null) {
         return false;
       }
     },
-    deleteMessage: async (_, msgId) => realBot.deleteMessage(chatId, msgId),
-    sendFile: async (_, filePath, caption) => realBot.sendFile(chatId, filePath, caption),
+    deleteMessage: async (_, msgId) => { await waitUntilReady(); return realBot.deleteMessage(chatId, msgId); },
+    sendFile: async (_, filePath, caption) => { await waitUntilReady(); return realBot.sendFile(chatId, filePath, caption); },
     downloadFile: async (...args) => realBot.downloadFile(...args),
   };
 }
@@ -802,6 +895,7 @@ function dispatchTask(targetProject, message, config, replyFn, streamOptions = n
   const fullMsg = {
     id: `d_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
     from: message.from || 'unknown',
+    source_sender_id: String(message.source_sender_id || '').trim() || '',
     to: targetProject,
     type: message.type || 'task',
     priority: message.priority || 'normal',
@@ -859,79 +953,23 @@ function dispatchTask(targetProject, message, config, replyFn, streamOptions = n
   if (!fs.existsSync(DISPATCH_DIR)) fs.mkdirSync(DISPATCH_DIR, { recursive: true });
   fs.appendFileSync(DISPATCH_LOG, JSON.stringify({ ...fullMsg, dispatched_at: new Date().toISOString() }) + '\n', 'utf8');
 
-  // Auto-update now/shared.md and team shared files for cross-agent visibility
+  // Auto-update scoped dispatch context files; only TeamTask writes shared state.
   try {
-    const NOW_DIR = path.join(HOME, '.metame', 'memory', 'now');
-    const SHARED_FILE = path.join(NOW_DIR, 'shared.md');
-    const SHARED_DIR = path.join(HOME, '.metame', 'memory', 'shared');
-    if (!fs.existsSync(NOW_DIR)) fs.mkdirSync(NOW_DIR, { recursive: true });
-
-    const now = new Date();
-    const timeStr = now.toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai', hour12: false });
-    const dateStr = now.toISOString().slice(0, 10);
-
-    // Get sender display name
-    const fromProj = config && config.projects ? config.projects[fullMsg.from] : null;
-    const fromName = fromProj ? (fromProj.name || fullMsg.from) : (fullMsg.from || 'unknown');
-    const fromIcon = fromProj ? (fromProj.icon || '🤖') : '🤖';
-
-    // Get target display name
-    const toProj = config && config.projects ? config.projects[targetProject] : null;
-    const toName = toProj ? (toProj.name || targetProject) : targetProject;
-    const toIcon = toProj ? (toProj.icon || '🤖') : '🤖';
-
-    const taskTitle = payload.title || '';
-    const taskPrompt = payload.prompt || '';
-
-    // Update shared.md
-    const content = `# 共享当前状态
-**最后更新**: ${timeStr} **更新者**: ${fromName} (${fullMsg.from})
-
-## 当前任务
-- **派发给**: ${toIcon} ${toName} (${targetProject})
-- **任务**: ${taskTitle || taskPrompt.slice(0, 60)}
-- **时间**: ${timeStr}
-
-## 任务链
-${fullMsg.chain ? fullMsg.chain.join(' → ') : fullMsg.from} → ${targetProject}
-`;
-    fs.writeFileSync(SHARED_FILE, content, 'utf8');
-
-    // Update tasks.md if shared directory exists
-    const tasksFile = path.join(SHARED_DIR, 'tasks.md');
-    if (fs.existsSync(SHARED_DIR)) {
-      const taskLine = `- [${dateStr}] ${fromIcon} ${fromName} → ${toIcon} ${toName}: ${taskTitle || taskPrompt.slice(0, 40)}`;
-      let tasksContent = '';
-      if (fs.existsSync(tasksFile)) {
-        tasksContent = fs.readFileSync(tasksFile, 'utf8');
-      } else {
-        tasksContent = '# 任务看板\n\n## 🔄 进行中\n\n## ✅ 已完成\n\n## 📅 待开始\n';
-      }
-      // Insert task under "进行中" section
-      if (!tasksContent.includes(taskLine)) {
-        const lines = tasksContent.split('\n');
-        const newLines = [];
-        let inProgress = false;
-        for (const line of lines) {
-          newLines.push(line);
-          if (line.includes('## 🔄 进行中')) {
-            inProgress = true;
-          } else if (inProgress && line.startsWith('## ')) {
-            newLines.push(taskLine);
-            inProgress = false;
-          }
-        }
-        if (inProgress) newLines.push(taskLine);
-        fs.writeFileSync(tasksFile, newLines.join('\n'), 'utf8');
-      }
-    }
+    updateDispatchContextFiles({
+      fs,
+      path,
+      baseDir: METAME_DIR,
+      fullMsg,
+      targetProject,
+      config,
+      envelope,
+      logger: (msg) => log('WARN', msg),
+    });
   } catch (e) {
-    log('WARN', `Failed to update shared files: ${e.message}`);
+    log('WARN', `Failed to update dispatch context files: ${e.message}`);
   }
 
-  const rawPrompt = envelope
-    ? buildPromptFromTaskEnvelope(envelope, fullMsg.payload.prompt || fullMsg.payload.title || '')
-    : (fullMsg.payload.prompt || fullMsg.payload.title || 'No prompt provided');
+  const rawPrompt = buildDispatchPrompt(targetProject, fullMsg, envelope);
 
   // Inject sender identity when dispatched by another agent (not directly from user)
   const userSources = new Set(['unknown', 'claude_session', '_claude_session', 'user']);
@@ -957,10 +995,25 @@ ${fullMsg.chain ? fullMsg.chain.join(' → ') : fullMsg.from} → ${targetProjec
   const dispatchChatId = buildDispatchChatId(targetProject, envelope && envelope.scope_id);
   const sessionMode = forceNew ? 'fresh session (forced)' : 'existing virtual session';
   log('INFO', `Dispatching ${fullMsg.type} to ${targetProject} via ${sessionMode}: ${rawPrompt.slice(0, 80)}`);
+  const streamReady = streamOptions?.bot && streamOptions?.chatId
+    ? (() => {
+      if (typeof streamOptions.preDispatch === 'function') {
+        return Promise.resolve()
+          .then(() => streamOptions.preDispatch())
+          .catch(e => log('WARN', `Dispatch prelude failed: ${e.message}`));
+      }
+      if (streamOptions.sendTaskCard === false) return Promise.resolve();
+      const card = buildDispatchTaskCard(fullMsg, targetProject, config);
+      return Promise.resolve()
+        .then(() => sendDispatchTaskCard(streamOptions.bot, streamOptions.chatId, card))
+        .catch(e => log('WARN', `Dispatch task card failed: ${e.message}`));
+    })()
+    : Promise.resolve();
 
   let _taskFinalized = false;
   const outputHandler = (output) => {
     const outStr = typeof output === 'object' ? (output.body || JSON.stringify(output)) : String(output);
+    const displayOut = envelope ? appendTeamTaskResumeHint(outStr, envelope.task_id, envelope.scope_id) : outStr;
     log('INFO', `Dispatch output from ${targetProject}: ${outStr.slice(0, 200)}`);
     if (envelope && taskBoard && !_taskFinalized && outStr.trim().length > 2) {
       const status = inferTaskStatusFromOutput(outStr);
@@ -979,7 +1032,7 @@ ${fullMsg.chain ? fullMsg.chain.join(' → ') : fullMsg.from} → ${targetProjec
       _taskFinalized = true;
     }
     if (replyFn && outStr.trim().length > 2) {
-      replyFn(outStr);
+      replyFn(displayOut);
     } else if (!replyFn && fullMsg.callback && fullMsg.from && config) {
       // Write result to sender's inbox before dispatching callback
       try {
@@ -994,7 +1047,7 @@ ${fullMsg.chain ? fullMsg.chain.join(' → ') : fullMsg.from} → ${targetProjec
           `TS: ${new Date().toISOString()}`,
           `SUBJECT: ${subject}`,
           '',
-          outStr.trim().slice(0, 2000),
+          displayOut.slice(0, 2000),
         ].join('\n');
         fs.writeFileSync(inboxFile, body, 'utf8');
       } catch (e) {
@@ -1002,12 +1055,13 @@ ${fullMsg.chain ? fullMsg.chain.join(' → ') : fullMsg.from} → ${targetProjec
       }
       dispatchTask(fullMsg.from, {
         from: targetProject,
+        source_sender_id: fullMsg.source_sender_id || '',
         type: 'callback',
         priority: 'normal',
         payload: {
           title: `任务完成: ${fullMsg.payload.title || fullMsg.id}`,
           original_id: fullMsg.id,
-          output: outStr.slice(0, 500),
+          output: displayOut.slice(0, 500),
         },
         chain: [], // reset chain for callbacks
       }, config);
@@ -1016,11 +1070,14 @@ ${fullMsg.chain ? fullMsg.chain.join(' → ') : fullMsg.from} → ${targetProjec
   // If streamOptions provided, use real bot so output appears in target's Feishu channel.
   // Otherwise fall back to nullBot which captures output for replyFn.
   const nullBot = streamOptions?.bot && streamOptions?.chatId
-    ? createStreamForwardBot(streamOptions.bot, streamOptions.chatId, outputHandler)
+    ? createStreamForwardBot(streamOptions.bot, streamOptions.chatId, outputHandler, {
+      ready: streamReady,
+      stripPlan: streamOptions.stripPlan !== false,
+      responseCard: streamOptions.responseCard || null,
+    })
     : createNullBot(outputHandler);
-  // Permission inheritance: if daemon runs with dangerously_skip_permissions, dispatched agents
-  // inherit the same level — they need Write access for implementation tasks.
-  // Otherwise fall back to readOnly (safe default for untrusted daemon configs).
+  // Trusted dispatches (user / bound agent / team member) keep write access.
+  // Only unknown senders are downgraded to read-only.
   // When forceNew=true, clear any cached session for this virtual chatId so
   // attachOrCreateSession in handleCommand actually creates a fresh Claude session.
   if (forceNew) {
@@ -1030,7 +1087,7 @@ ${fullMsg.chain ? fullMsg.chain.join(' → ') : fullMsg.from} → ${targetProjec
       saveState(st);
     }
   }
-  const dispatchReadOnly = !(config.daemon && config.daemon.dangerously_skip_permissions);
+  const dispatchReadOnly = resolveDispatchReadOnly(message, config, targetProject);
   if (envelope && taskBoard) {
     taskBoard.markTaskStatus(envelope.task_id, 'running', { summary: `dispatched via ${sessionMode}` });
     taskBoard.appendTaskEvent(envelope.task_id, 'task_started', targetProject, { session_mode: sessionMode });
@@ -1043,7 +1100,12 @@ ${fullMsg.chain ? fullMsg.chain.join(' → ') : fullMsg.from} → ${targetProjec
     }
   });
 
-  return { success: true, id: fullMsg.id, task_id: envelope ? envelope.task_id : null };
+  return {
+    success: true,
+    id: fullMsg.id,
+    task_id: envelope ? envelope.task_id : null,
+    scope_id: envelope ? envelope.scope_id : null,
+  };
 }
 
 /**
@@ -1144,28 +1206,265 @@ function _findTeamBroadcastContext(fromKey, targetKey, config) {
   return null;
 }
 
+function resolveDispatchSenderChatId(item, config) {
+  const requestedChatId = String(item && item.source_chat_id || '').trim();
+  if (requestedChatId) return requestedChatId;
+
+  const feishuMap = (config && config.feishu && config.feishu.chat_agent_map) || {};
+  const allowedFeishuIds = ((config && config.feishu && config.feishu.allowed_chat_ids) || []).map(String);
+  const agentChatIds = new Set(Object.keys(feishuMap).map(String));
+  const senderKey = String(item && (item.source_sender_key || item.from) || '').trim();
+  const userSources = new Set(['', 'unknown', 'claude_session', '_claude_session', 'user']);
+
+  if (!userSources.has(senderKey)) {
+    const directChatId = Object.entries(feishuMap).find(([, v]) => v === senderKey)?.[0] || null;
+    if (directChatId) return String(directChatId);
+
+    const projects = (config && config.projects) || {};
+    for (const [projKey, proj] of Object.entries(projects)) {
+      if (!Array.isArray(proj && proj.team)) continue;
+      const member = proj.team.find(m => m && m.key === senderKey);
+      if (!member) continue;
+      const groupChatId = Object.entries(feishuMap).find(([, v]) => v === projKey)?.[0] || null;
+      if (groupChatId) return String(groupChatId);
+    }
+  }
+
+  return allowedFeishuIds.find(id => !agentChatIds.has(id)) || null;
+}
+
+function writeDispatchReceiptInbox(item, receipt) {
+  const senderKey = String(item && (item.source_sender_key || item.from) || '').trim();
+  if (!senderKey || ['user', 'unknown', 'claude_session', '_claude_session'].includes(senderKey)) return;
+  try {
+    const inboxDir = path.join(os.homedir(), '.metame', 'memory', 'inbox', senderKey);
+    fs.mkdirSync(inboxDir, { recursive: true });
+    const tsStr = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 15);
+    const targetKey = String(receipt && receipt.targetKey || item.target || 'unknown').trim() || 'unknown';
+    const inboxFile = path.join(inboxDir, `${tsStr}_${targetKey}_dispatch_receipt.md`);
+    const body = [
+      `TYPE: dispatch_receipt`,
+      `STATUS: ${receipt && receipt.status ? receipt.status : 'accepted'}`,
+      `TARGET: ${targetKey}`,
+      `DISPATCH_ID: ${receipt && receipt.dispatchId ? receipt.dispatchId : ''}`,
+      `TS: ${new Date().toISOString()}`,
+      '',
+      String(receipt && receipt.text || '').trim() || '(empty receipt)',
+    ].join('\n');
+    fs.writeFileSync(inboxFile, body, 'utf8');
+  } catch (e) {
+    log('WARN', `Dispatch receipt inbox write failed: ${e.message}`);
+  }
+}
+
+function sendDispatchReceipt(item, config, receipt) {
+  const liveBot = _dispatchBridgeRef && _dispatchBridgeRef.bot;
+  const senderChatId = resolveDispatchSenderChatId(item, config);
+  const text = String(receipt && receipt.text || '').trim();
+  if (!text) return;
+
+  if (liveBot && senderChatId) {
+    const send = liveBot.sendMarkdown
+      ? liveBot.sendMarkdown(senderChatId, text)
+      : liveBot.sendMessage(senderChatId, text);
+    send.catch((e) => {
+      log('WARN', `Dispatch receipt delivery failed: ${e.message}`);
+      writeDispatchReceiptInbox(item, receipt);
+    });
+    return;
+  }
+
+  writeDispatchReceiptInbox(item, receipt);
+}
+
+function buildTeamTaskResumeHint(taskId, scopeId) {
+  const safeTaskId = String(taskId || '').trim();
+  if (!safeTaskId) return '';
+  const safeScopeId = String(scopeId || '').trim();
+  const lines = [
+    '',
+    `TeamTask: ${safeTaskId}`,
+  ];
+  if (safeScopeId && safeScopeId !== safeTaskId) lines.push(`Scope: ${safeScopeId}`);
+  lines.push(`如需复工，请使用: /TeamTask resume ${safeTaskId}`);
+  return lines.join('\n');
+}
+
+function appendTeamTaskResumeHint(text, taskId, scopeId) {
+  const base = String(text || '').trim();
+  const hint = buildTeamTaskResumeHint(taskId, scopeId);
+  if (!hint) return base;
+  return `${base}${hint}`;
+}
+
+function buildDispatchPrompt(targetProject, fullMsg, envelope, metameDir = METAME_DIR) {
+  const promptBody = buildEnrichedPrompt(
+    targetProject,
+    fullMsg && fullMsg.payload ? (fullMsg.payload.prompt || fullMsg.payload.title || 'No prompt provided') : 'No prompt provided',
+    metameDir,
+    { includeShared: !!(envelope && envelope.task_kind === 'team') }
+  );
+  return envelope
+    ? buildPromptFromTaskEnvelope(envelope, promptBody)
+    : promptBody;
+}
+
+function resolveDispatchTarget(targetKey, config) {
+  const rawKey = String(targetKey || '').trim();
+  const projects = (config && config.projects) || {};
+  if (!rawKey) return null;
+  if (projects[rawKey]) {
+    const proj = projects[rawKey];
+    return {
+      key: rawKey,
+      name: proj.name || rawKey,
+      icon: proj.icon || '🤖',
+      color: proj.color || 'blue',
+      parentKey: rawKey,
+      parentProject: proj,
+      member: null,
+      isTeamMember: false,
+    };
+  }
+  for (const [parentKey, parent] of Object.entries(projects)) {
+    if (!Array.isArray(parent && parent.team)) continue;
+    const member = parent.team.find(m => m && m.key === rawKey);
+    if (!member) continue;
+    return {
+      key: rawKey,
+      name: member.name || rawKey,
+      icon: member.icon || parent.icon || '🤖',
+      color: member.color || parent.color || 'blue',
+      parentKey,
+      parentProject: parent,
+      member,
+      isTeamMember: true,
+    };
+  }
+  return null;
+}
+
+function buildDispatchResponseCard(targetKey, config) {
+  const target = resolveDispatchTarget(targetKey, config);
+  if (!target) return null;
+  return {
+    title: `${target.icon} ${target.name}`,
+    color: target.color || 'blue',
+  };
+}
+
+function buildDispatchTaskCard(fullMsg, targetProject, config) {
+  const projects = (config && config.projects) || {};
+  const actor = resolveDispatchActor(
+    (fullMsg && fullMsg.source_sender_key) || (fullMsg && fullMsg.from),
+    projects
+  );
+  const target = resolveDispatchTarget(targetProject, config) || {
+    icon: '🤖',
+    name: targetProject,
+    color: 'blue',
+  };
+  const prompt = String(fullMsg && fullMsg.payload && (fullMsg.payload.prompt || fullMsg.payload.title) || '').trim();
+  const preview = prompt ? `${prompt.slice(0, 300)}${prompt.length > 300 ? '…' : ''}` : '(empty)';
+  const lines = [
+    `发起: ${actor.icon} ${actor.name}`,
+    `目标: ${target.icon} ${target.name}`,
+    `编号: ${fullMsg.id}`,
+  ];
+  if (fullMsg.task_id) lines.push(`TeamTask: ${fullMsg.task_id}`);
+  if (fullMsg.scope_id && fullMsg.scope_id !== fullMsg.task_id) lines.push(`Scope: ${fullMsg.scope_id}`);
+  lines.push('', preview);
+  return {
+    title: '📬 新任务',
+    body: lines.join('\n'),
+    color: target.color || 'blue',
+    markdown: `## 📬 新任务\n\n${lines.join('\n')}\n\n---\n${preview}`,
+    text: `📬 新任务\n\n${lines.join('\n')}\n\n${preview}`,
+  };
+}
+
+function resolveDispatchReadOnly(message, config, targetProject) {
+  if (message && typeof message.readOnly === 'boolean') return message.readOnly;
+  const senderId = String((message && message.source_sender_id) || '').trim();
+  if (senderId && userAcl && typeof userAcl.resolveUserCtx === 'function') {
+    try {
+      const userCtx = userAcl.resolveUserCtx(senderId, config || {});
+      return !!userCtx.readOnly;
+    } catch { /* fall through to safe default */ }
+  }
+  void targetProject;
+  return true;
+}
+
+async function sendDispatchTaskCard(bot, chatId, card) {
+  if (!bot || !chatId || !card) return null;
+  if (bot.sendCard) return bot.sendCard(chatId, { title: card.title, body: card.body, color: card.color || 'blue' });
+  if (bot.sendMarkdown) return bot.sendMarkdown(chatId, card.markdown);
+  return bot.sendMessage(chatId, card.text);
+}
+
+function buildDispatchReceipt(item, config, result, opts = {}) {
+  const targetKey = String(opts.targetKey || item.target || '').trim() || 'unknown';
+  const target = resolveDispatchTarget(targetKey, config) || {
+    icon: '🤖',
+    name: targetKey,
+  };
+  const actor = resolveDispatchActor(
+    String(item && (item.source_sender_key || item.from) || 'user').trim() || 'user',
+    (config && config.projects) || {}
+  );
+  const prompt = String(item && item.prompt || '').trim();
+  const preview = prompt ? `${prompt.slice(0, 120)}${prompt.length > 120 ? '...' : ''}` : '(empty)';
+  const isFailed = !result || !result.success;
+  const title = isFailed ? '❌ Dispatch 回执' : '📮 Dispatch 回执';
+  const statusLine = isFailed
+    ? `状态: 入队失败 (${String(result && result.error || 'unknown_error').slice(0, 120)})`
+    : '状态: 目标端已接收并入队';
+  const lines = [
+    title,
+    '',
+    statusLine,
+    `发起: ${actor.icon} ${actor.name}`,
+    `目标: ${target.icon} ${target.name}`,
+  ];
+  if (result && result.id) lines.push(`编号: ${result.id}`);
+  lines.push(`摘要: ${preview}`);
+  if (result && result.task_id) lines.push(buildTeamTaskResumeHint(result.task_id, result.scope_id));
+  return {
+    status: isFailed ? 'failed' : 'accepted',
+    dispatchId: result && result.id ? result.id : '',
+    targetKey,
+    text: lines.join('\n'),
+  };
+}
+
 function handleDispatchItem(item, config) {
   if (!item.target || !item.prompt) return;
-  if (!(config && config.projects && config.projects[item.target])) {
+  const resolvedTarget = resolveDispatchTarget(item.target, config);
+  if (!resolvedTarget) {
     log('WARN', `dispatch: unknown target "${item.target}"`);
-    return;
+    sendDispatchReceipt(item, config, buildDispatchReceipt(item, config, { success: false, error: 'unknown_target' }));
+    return { success: false, error: 'unknown_target' };
   }
+  const targetKey = resolvedTarget.key;
   // 安全护栏：禁止 agent 主动 dispatch 到 personal（防止 LLM 幻觉乱发消息给小美）
   // personal 只允许用户本人触发，或来源为 user/unknown 的系统任务
   const _agentSources = new Set(Object.keys((config.projects) || {}));
   const isFromAgent = _agentSources.has(item.from) || item.from === '_claude_session';
-  const targetProject = config.projects?.[item.target] || {};
+  const targetProject = config.projects?.[targetKey] || {};
   if (isFromAgent && targetProject.guard === 'user-only') {
-    log('WARN', `dispatch: blocked agent "${item.from}" → "${item.target}" (user-only guard)`);
-    return;
+    log('WARN', `dispatch: blocked agent "${item.from}" → "${targetKey}" (user-only guard)`);
+    sendDispatchReceipt(item, config, buildDispatchReceipt(item, config, { success: false, error: 'target_guard_user_only' }));
+    return { success: false, error: 'target_guard_user_only' };
   }
-  log('INFO', `Dispatch: ${item.from || '?'} → ${item.target}: ${item.prompt.slice(0, 60)}`);
+  log('INFO', `Dispatch: ${item.from || '?'} → ${targetKey}: ${item.prompt.slice(0, 60)}`);
 
   // ── Team broadcast: intra-team dispatch → show in group chat ──
   const liveBot = _dispatchBridgeRef && _dispatchBridgeRef.bot;
-  const teamCtx = liveBot ? _findTeamBroadcastContext(item.from, item.target, config) : null;
+  const teamCtx = liveBot ? _findTeamBroadcastContext(item.from, targetKey, config) : null;
+  const responseCard = buildDispatchResponseCard(targetKey, config);
   if (teamCtx && teamCtx.groupChatId) {
-    const { senderMember, targetMember, groupChatId, parentProject } = teamCtx;
+    const { senderMember, targetMember, groupChatId } = teamCtx;
     const sIcon = senderMember.icon || '🤖';
     const sName = senderMember.name || senderMember.key;
     const tIcon = targetMember.icon || '🤖';
@@ -1174,71 +1473,48 @@ function handleDispatchItem(item, config) {
     const cardTitle = `${sIcon} ${sName} → ${tIcon} ${tName}`;
     const cardBody = item.prompt.slice(0, 300) + (item.prompt.length > 300 ? '…' : '');
     const cardColor = senderMember.color || 'blue';
-    const sendFn = liveBot.sendCard
+    const sendTaskNotice = liveBot.sendCard
       ? () => liveBot.sendCard(groupChatId, { title: cardTitle, body: cardBody, color: cardColor })
       : () => liveBot.sendMarkdown(groupChatId, `**${cardTitle}**\n\n> ${cardBody}`);
-    sendFn().catch(e => log('WARN', `Team broadcast failed: ${e.message}`));
-    // Use streamForwardBot so target's reply also shows in group
-    const streamOptions = { bot: liveBot, chatId: groupChatId };
-    dispatchTask(item.target, {
+    // Use streamForwardBot so target's reply also shows in group.
+    // Gate the worker output behind the task notice so the group always sees the task card first.
+    const streamOptions = {
+      bot: liveBot,
+      chatId: groupChatId,
+      preDispatch: () => sendTaskNotice().catch(e => log('WARN', `Team broadcast failed: ${e.message}`)),
+      sendTaskCard: false,
+      stripPlan: true,
+      responseCard,
+    };
+    const result = dispatchTask(targetKey, {
       from: item.from || 'claude_session',
+      source_sender_id: item.source_sender_id || '',
       type: 'task', priority: 'normal',
       payload: { title: item.prompt.slice(0, 60), prompt: item.prompt },
       callback: false,
       new_session: !!item.new_session,
+      source_chat_id: item.source_chat_id || '',
+      source_sender_key: item.source_sender_key || item.from || '',
+      source_sender_id: item.source_sender_id || '',
     }, config, null, streamOptions);
-    return;
+    sendDispatchReceipt(item, config, buildDispatchReceipt(item, config, result));
+    return result;
   }
 
   // ── Normal dispatch (non-team or broadcast off) ──
-  let pendingReplyFn = null;
+  let pendingReplyFn = typeof item._replyFn === 'function' ? item._replyFn : null;
   let streamOptions = null;
   if (liveBot) {
     const feishuMap = (config.feishu && config.feishu.chat_agent_map) || {};
-    const allowedFeishuIds = (config.feishu && config.feishu.allowed_chat_ids) || [];
-    const agentChatIds = new Set(Object.keys(feishuMap));
-    const targetChatId = Object.entries(feishuMap).find(([, v]) => v === item.target)?.[0] || null;
+    const targetChatId = Object.entries(feishuMap).find(([, v]) => v === targetKey)?.[0] || null;
     if (targetChatId) {
-      streamOptions = { bot: liveBot, chatId: targetChatId };
-      const ackText = `📬 **新任务**\n\n> ${item.prompt.slice(0, 120)}${item.prompt.length > 120 ? '...' : ''}`;
-      liveBot.sendMarkdown(targetChatId, ackText).catch(() =>
-        liveBot.sendMessage(targetChatId, ackText.replace(/\*\*/g, '')).catch(e =>
-          log('WARN', `Dispatch ack failed: ${e.message}`)
-        )
-      );
-    } else {
-      const _userSources = new Set(['unknown', 'claude_session', '_claude_session', 'user']);
-      let senderChatId = null;
-      if (!_userSources.has(item.from)) {
-        // Direct match: sender is a bound agent
-        senderChatId = Object.entries(feishuMap).find(([, v]) => v === item.from)?.[0] || null;
-        // Team member fallback: if sender is a team member (e.g., jarvis_c), find parent project's chatId
-        if (!senderChatId) {
-          const projects = config.projects || {};
-          for (const [projKey, proj] of Object.entries(projects)) {
-            if (proj.team && Array.isArray(proj.team)) {
-              const member = proj.team.find(m => m.key === item.from);
-              if (member && feishuMap[projKey]) {
-                senderChatId = feishuMap[projKey];
-                break;
-              }
-            }
-          }
-        }
-      }
-      if (!senderChatId) {
-        senderChatId = allowedFeishuIds.map(String).find(id => !agentChatIds.has(id)) || null;
-      }
+      streamOptions = { bot: liveBot, chatId: targetChatId, stripPlan: true, responseCard };
+    } else if (!item._suppressDefaultReplyRouting) {
+      const senderChatId = resolveDispatchSenderChatId(item, config);
       if (senderChatId) {
-        const targetProj = (config.projects || {})[item.target] || {};
-        const ackText = `📬 已接收，转发给 ${targetProj.icon || '🤖'} **${targetProj.name || item.target}**...\n\n> ${item.prompt.slice(0, 100)}${item.prompt.length > 100 ? '...' : ''}`;
-        liveBot.sendMarkdown(senderChatId, ackText).catch(() =>
-          liveBot.sendMessage(senderChatId, ackText.replace(/\*\*/g, '')).catch(e =>
-            log('WARN', `Dispatch ack to sender failed: ${e.message}`)
-          )
-        );
+        const targetProj = resolveDispatchTarget(targetKey, config) || {};
         pendingReplyFn = (output) => {
-          const text = `${targetProj.icon || '📬'} **${targetProj.name || item.target}** 回复：\n\n${output.slice(0, 2000)}`;
+          const text = `${targetProj.icon || '📬'} **${targetProj.name || targetKey}** 回复：\n\n${output.slice(0, 2000)}`;
           liveBot.sendMarkdown(senderChatId, text).catch(e => {
             log('WARN', `Dispatch reply (markdown) failed: ${e.message}`);
             liveBot.sendMessage(senderChatId, text.replace(/\*\*/g, '')).catch(e2 =>
@@ -1247,35 +1523,52 @@ function handleDispatchItem(item, config) {
           });
         };
         // Also set streamOptions so target agent's streaming replies go to the sender's group
-        streamOptions = { bot: liveBot, chatId: senderChatId };
+        streamOptions = { bot: liveBot, chatId: senderChatId, stripPlan: true, responseCard };
       }
     }
   }
-  dispatchTask(item.target, {
+  const result = dispatchTask(targetKey, {
     from: item.from || 'claude_session',
+    source_sender_id: item.source_sender_id || '',
     type: 'task', priority: 'normal',
     payload: { title: item.prompt.slice(0, 60), prompt: item.prompt },
     callback: false,
     new_session: !!item.new_session,
+    source_chat_id: item.source_chat_id || '',
+    source_sender_key: item.source_sender_key || item.from || '',
+    source_sender_id: item.source_sender_id || '',
   }, config, pendingReplyFn, streamOptions);
+  sendDispatchReceipt(item, config, buildDispatchReceipt(item, config, result));
+  return result;
 }
 
 async function handleRemoteDispatchMessage({ chatId, text, config }) {
   const rd = getRemoteDispatchConfig(config);
   if (!rd || String(chatId) !== rd.chatId) return false;
+  log('INFO', `Remote dispatch intercept chat=${chatId} preview=${String(text || '').slice(0, 48).replace(/\s+/g, ' ')}`);
 
   const packet = decodeRemoteDispatchPacket(text);
-  if (!packet) return true;
+  if (!packet) {
+    log('INFO', 'Remote dispatch decode miss');
+    return true;
+  }
   if (!verifyRemoteDispatchPacket(packet, rd.secret)) {
     log('WARN', 'Remote dispatch ignored: invalid signature');
     return true;
   }
-  if (packet.from_peer === rd.selfPeer) return true;
-  if (packet.to_peer !== rd.selfPeer) return true;
+  if (packet.from_peer === rd.selfPeer) {
+    log('INFO', `Remote dispatch ignored: self echo id=${packet.id || ''}`);
+    return true;
+  }
+  if (packet.to_peer !== rd.selfPeer) {
+    log('INFO', `Remote dispatch ignored: peer mismatch id=${packet.id || ''} to=${packet.to_peer || ''} self=${rd.selfPeer}`);
+    return true;
+  }
   if (isRemoteDispatchDuplicate(packet.id)) {
     log('DEBUG', `Remote dispatch ignored: duplicate id=${packet.id}`);
     return true;
   }
+  log('INFO', `Remote dispatch received type=${packet.type} id=${packet.id || ''} from=${packet.from_peer}:${packet.target_project || 'unknown'}`);
 
   if (packet.type === 'task') {
     const replyFn = async (output) => {
@@ -1286,24 +1579,89 @@ async function handleRemoteDispatchMessage({ chatId, text, config }) {
         target_project: packet.target_project,
         source_chat_id: packet.source_chat_id,
         source_sender_key: packet.source_sender_key || 'user',
+        source_sender_id: packet.source_sender_id || '',
         request_id: packet.id,
         result: String(output || '').slice(0, 4000),
       }, config);
       if (!res.success) log('WARN', `Remote dispatch result send failed: ${res.error}`);
     };
 
-    handleDispatchItem({
+    const dispatchRes = handleDispatchItem({
       target: packet.target_project,
       prompt: packet.prompt,
       from: packet.source_sender_key || `${packet.from_peer}:remote`,
       new_session: !!packet.new_session,
+      source_chat_id: packet.source_chat_id || '',
+      source_sender_key: packet.source_sender_key || '',
+      source_sender_id: packet.source_sender_id || '',
       _replyFn: replyFn,
       _suppressDefaultReplyRouting: true,
     }, config);
+    const ackRes = await sendRemoteDispatch({
+      type: 'ack',
+      to_peer: packet.from_peer,
+      target_project: packet.target_project,
+      source_chat_id: packet.source_chat_id,
+      source_sender_key: packet.source_sender_key || 'user',
+      source_sender_id: packet.source_sender_id || '',
+      request_id: packet.id,
+      dispatch_id: dispatchRes && dispatchRes.id ? dispatchRes.id : '',
+      task_id: dispatchRes && dispatchRes.task_id ? dispatchRes.task_id : '',
+      scope_id: dispatchRes && dispatchRes.scope_id ? dispatchRes.scope_id : '',
+      status: dispatchRes && dispatchRes.success ? 'accepted' : 'failed',
+      error: dispatchRes && dispatchRes.success ? '' : String(dispatchRes && dispatchRes.error || 'dispatch_failed'),
+    }, config);
+    if (!ackRes.success) log('WARN', `Remote dispatch ack send failed: ${ackRes.error}`);
+    return true;
+  }
+
+  if (packet.type === 'ack') {
+    resolveTrackedRemoteDispatch(packet.request_id);
+    log('INFO', `Remote dispatch ack id=${packet.request_id || ''} status=${packet.status} from=${packet.from_peer}:${packet.target_project || 'unknown'}`);
+    const text = String(packet.status) === 'accepted'
+      ? [
+        '📮 远端 Dispatch 回执',
+        '',
+        `状态: ${packet.from_peer}:${packet.target_project || 'unknown'} 已接收并入队`,
+        packet.dispatch_id ? `编号: ${packet.dispatch_id}` : '',
+        packet.task_id ? buildTeamTaskResumeHint(packet.task_id, packet.scope_id) : '',
+      ].filter(Boolean).join('\n')
+      : [
+        '❌ 远端 Dispatch 回执',
+        '',
+        `状态: ${packet.from_peer}:${packet.target_project || 'unknown'} 入队失败`,
+        packet.error ? `错误: ${String(packet.error).slice(0, 200)}` : '',
+      ].filter(Boolean).join('\n');
+
+    const targetChatId = String(packet.source_chat_id || '').trim();
+    if (targetChatId) {
+      const liveBot = _dispatchBridgeRef && _dispatchBridgeRef.bot;
+      if (!liveBot) {
+        writeDispatchReceiptInbox({ from: packet.source_sender_key || 'user' }, { status: packet.status, targetKey: packet.target_project, dispatchId: packet.dispatch_id, text });
+        return true;
+      }
+      try {
+        if (liveBot.sendMarkdown) await liveBot.sendMarkdown(targetChatId, text);
+        else await liveBot.sendMessage(targetChatId, text);
+      } catch (e) {
+        log('WARN', `Remote dispatch ack delivery failed: ${e.message}`);
+        writeDispatchReceiptInbox({ from: packet.source_sender_key || 'user' }, { status: packet.status, targetKey: packet.target_project, dispatchId: packet.dispatch_id, text });
+      }
+      return true;
+    }
+
+    writeDispatchReceiptInbox({ from: packet.source_sender_key || 'user' }, {
+      status: packet.status,
+      targetKey: packet.target_project,
+      dispatchId: packet.dispatch_id,
+      text,
+    });
     return true;
   }
 
   if (packet.type === 'result') {
+    resolveTrackedRemoteDispatch(packet.request_id);
+    log('INFO', `Remote dispatch result id=${packet.request_id || ''} from=${packet.from_peer}:${packet.target_project || 'unknown'}`);
     const targetChatId = String(packet.source_chat_id || '').trim();
     if (!targetChatId) {
       const inboxTarget = String(packet.source_sender_key || '').trim();
@@ -1361,8 +1719,8 @@ function startDispatchSocket(getConfig) {
       try {
         const item = JSON.parse(buf);
         const liveCfg = typeof getConfig === 'function' ? getConfig() : getConfig;
-        handleDispatchItem(item, liveCfg || {});
-        conn.write(JSON.stringify({ ok: true }) + '\n');
+        const result = handleDispatchItem(item, liveCfg || {});
+        conn.write(JSON.stringify({ ok: !!(result && result.success), id: result && result.id ? result.id : null, error: result && result.error ? result.error : null }) + '\n');
       } catch (e) {
         try { conn.write(JSON.stringify({ ok: false, error: e.message }) + '\n'); } catch { /* ignore */ }
       }
@@ -1420,9 +1778,19 @@ function physiologicalHeartbeat(config) {
         const liveBot = _dispatchBridgeRef && _dispatchBridgeRef.bot;
         for (const item of items) {
           if (item.relay_chat_id && item.body && liveBot && typeof liveBot.sendMessage === 'function') {
-            liveBot.sendMessage(item.relay_chat_id, item.body).catch(e2 =>
-              log('WARN', `Remote dispatch relay send failed: ${e2.message}`)
-            );
+            const packet = decodeRemoteDispatchPacket(item.body);
+            liveBot.sendMessage(item.relay_chat_id, item.body)
+              .then(() => {
+                if (packet) {
+                  log('INFO', `Remote dispatch queue sent type=${packet.type} id=${packet.id || ''} to=${packet.to_peer}:${packet.target_project || 'unknown'} via=${item.relay_chat_id}`);
+                  if (packet.type === 'task') trackRemoteDispatch(packet, config);
+                } else {
+                  log('INFO', `Remote dispatch queue sent raw via=${item.relay_chat_id}`);
+                }
+              })
+              .catch(e2 =>
+                log('WARN', `Remote dispatch relay send failed: ${e2.message}`)
+              );
           }
         }
       }
@@ -1453,7 +1821,6 @@ function physiologicalHeartbeat(config) {
 const CLAUDE_COOLDOWN_MS = 10000; // 10s between Claude calls per chat
 const STATUS_THROTTLE_MS = 3000;  // Min 3s between streaming status updates
 const FALLBACK_THROTTLE_MS = 8000; // 8s between fallback status updates
-const DEDUP_TTL_MS = 60000; // Feishu message dedup window (60s)
 // ─────────────────────────────────────────────────────────────────────────────
 
 // Rate limiter for /ask and /run — prevents rapid-fire Claude calls
@@ -1629,6 +1996,7 @@ async function doBindAgent(bot, chatId, agentName, agentCwd) {
 // ---------------------------------------------------------
 const {
   findSessionFile,
+  findCodexSessionFile,
   clearSessionFileCache,
   truncateSessionToCheckpoint,
   listRecentSessions,
@@ -1638,15 +2006,17 @@ const {
   sessionRichLabel,
   getSessionRecentContext,
   buildSessionCardElements,
-  listProjectDirs,
   getSession,
   getSessionForEngine,
   createSession,
+  restoreSessionFromReply,
   getSessionName,
   writeSessionName,
   markSessionStarted,
   watchSessionFiles,
   isEngineSessionValid,
+  getCodexSessionSandboxProfile,
+  getCodexSessionPermissionMode,
 } = createSessionStore({
   fs,
   path,
@@ -1799,6 +2169,8 @@ const getEngineRuntime = createEngineRuntimeFactory({
   getActiveProviderEnv,
 });
 
+let wakeRecoveryHook = null;
+
 const {
   checkPrecondition,
   executeTask,
@@ -1827,6 +2199,7 @@ const {
   isInSleepMode: () => _inSleepMode,
   setSleepMode: (next) => { _inSleepMode = !!next; },
   spawnSessionSummaries,
+  getWakeRecoveryHook: () => wakeRecoveryHook,
   skillEvolution,
 });
 
@@ -1933,7 +2306,10 @@ const { spawnClaudeAsync, askClaude } = createClaudeEngine({
   sendFileButtons,
   findSessionFile,
   listRecentSessions,
+  getSessionRecentContext,
   isEngineSessionValid,
+  getCodexSessionSandboxProfile,
+  getCodexSessionPermissionMode,
   getSession,
   getSessionForEngine,
   createSession,
@@ -1993,6 +2369,7 @@ const { handleAgentCommand } = createAgentCommandHandler({
   sendBrowse,
   sendDirPicker,
   getSession,
+  getSessionForEngine,
   listRecentSessions,
   buildSessionCardElements,
   sessionLabel,
@@ -2038,8 +2415,10 @@ const { handleExecCommand } = createExecCommandHandler({
   getSessionName,
   createSession,
   findSessionFile,
+  findCodexSessionFile,
   loadConfig,
   getDistillModel,
+  getDefaultEngine,
 });
 
 const { handleOpsCommand } = createOpsCommandHandler({
@@ -2048,9 +2427,12 @@ const { handleOpsCommand } = createOpsCommandHandler({
   spawn,
   execSync,
   log,
+  loadConfig,
+  loadState,
   messageQueue,
   activeProcesses,
   getSession,
+  getSessionForEngine,
   listCheckpoints,
   cpDisplayLabel,
   truncateSessionToCheckpoint,
@@ -2061,6 +2443,7 @@ const { handleOpsCommand } = createOpsCommandHandler({
   cleanupCheckpoints,
   getNoSleepProcess: () => caffeinateProcess,
   setNoSleepProcess: (p) => { caffeinateProcess = p || null; },
+  getDefaultEngine,
 });
 
 const { handleCommand } = createCommandRouter({
@@ -2097,7 +2480,7 @@ setDispatchHandler(handleCommand);
 // ---------------------------------------------------------
 // BOT BRIDGES
 // ---------------------------------------------------------
-const { startTelegramBridge, startFeishuBridge } = createBridgeStarter({
+const { startTelegramBridge, startFeishuBridge, startImessageBridge, startSiriBridge } = createBridgeStarter({
   fs,
   path,
   HOME,
@@ -2107,6 +2490,7 @@ const { startTelegramBridge, startFeishuBridge } = createBridgeStarter({
   loadState,
   saveState,
   getSession,
+  restoreSessionFromReply,
   handleCommand,
   pendingActivations,
   activeProcesses,
@@ -2231,7 +2615,7 @@ async function main() {
   }
 
   // Config validation: warn on unknown/suspect fields
-  const KNOWN_SECTIONS = ['daemon', 'telegram', 'feishu', 'heartbeat', 'budget', 'projects'];
+  const KNOWN_SECTIONS = ['daemon', 'telegram', 'feishu', 'heartbeat', 'budget', 'projects', 'imessage', 'siri_bridge'];
   const KNOWN_DAEMON = [
     'model',          // legacy (still valid as fallback)
     'models',         // per-engine model map: { claude, codex }
@@ -2322,6 +2706,7 @@ async function main() {
   // Bridges
   let telegramBridge = null;
   let feishuBridge = null;
+  let lastWakeBridgeRecoveryAt = 0;
 
   const notifier = createNotifier({
     log,
@@ -2335,6 +2720,25 @@ async function main() {
   // Start dispatch socket server (low-latency IPC, fallback: file polling still works)
   const dispatchSocket = startDispatchSocket(() => config);
 
+  wakeRecoveryHook = async ({ sleepSeconds }) => {
+    const now = Date.now();
+    if (now - lastWakeBridgeRecoveryAt < 60 * 1000) {
+      log('INFO', `[WAKE-DETECT] bridge recovery skipped — cooldown active (${Math.round((now - lastWakeBridgeRecoveryAt) / 1000)}s since last)`);
+      return;
+    }
+    lastWakeBridgeRecoveryAt = now;
+    const tasks = [];
+    if (telegramBridge && typeof telegramBridge.reconnect === 'function') {
+      log('INFO', `[WAKE-DETECT] reconnecting Telegram bridge after ${sleepSeconds}s sleep`);
+      tasks.push(Promise.resolve().then(() => telegramBridge.reconnect()));
+    }
+    if (feishuBridge && typeof feishuBridge.reconnect === 'function') {
+      log('INFO', `[WAKE-DETECT] reconnecting Feishu bridge after ${sleepSeconds}s sleep`);
+      tasks.push(Promise.resolve().then(() => feishuBridge.reconnect()));
+    }
+    await Promise.allSettled(tasks);
+  };
+
   // Start heartbeat scheduler
   let heartbeatTimer = startHeartbeat(config, notifyFn, notifyPersonalFn);
 
@@ -2399,6 +2803,8 @@ async function main() {
   // Start bridges (both can run simultaneously)
   telegramBridge = await startTelegramBridge(config, executeTaskByName);
   feishuBridge = await startFeishuBridge(config, executeTaskByName);
+  await startImessageBridge(config, executeTaskByName);
+  await startSiriBridge(config, executeTaskByName);
   if (feishuBridge) _dispatchBridgeRef = feishuBridge; // store bridge, not bot, so .bot stays live after reconnects
 
   // Notify once on startup (single message, no duplicates)
@@ -2445,6 +2851,8 @@ async function main() {
     try { require('./qmd-client').stopDaemon(); } catch { /* ignore */ }
     // Kill all tracked engine process groups before exiting (covers sub-agents too)
     for (const [cid, proc] of activeProcesses) {
+      proc.aborted = true;
+      proc.abortReason = opts.restartReason ? 'daemon-restart' : 'shutdown';
       try { process.kill(-proc.child.pid, 'SIGKILL'); } catch { try { proc.child.kill('SIGKILL'); } catch { } }
       log('INFO', `Shutdown: killed engine process group for chatId ${cid}`);
     }
@@ -2458,6 +2866,10 @@ async function main() {
     process.exit(0);
   };
 
+  process.on('SIGUSR2', () => {
+    shutdown({ restartReason: process.env.METAME_DEPLOY_RESTART_REASON || 'external-restart' })
+      .catch(() => process.exit(1));
+  });
   process.on('SIGTERM', () => { shutdown().catch(() => process.exit(0)); });
   process.on('SIGINT', () => { shutdown().catch(() => process.exit(0)); });
 
@@ -2518,4 +2930,21 @@ if (process.argv.includes('--run')) {
 }
 
 // Export for testing & cross-bot dispatch
-module.exports = { executeTask, loadConfig, loadState, buildProfilePreamble, parseInterval, handleRemoteDispatchMessage, sendRemoteDispatch };
+module.exports = {
+  executeTask,
+  loadConfig,
+  loadState,
+  buildProfilePreamble,
+  parseInterval,
+  handleRemoteDispatchMessage,
+  sendRemoteDispatch,
+  __test: {
+    buildDispatchPrompt,
+    createStreamForwardBot,
+    buildDispatchTaskCard,
+    stripLeadingPlanSection,
+    resolveDispatchTarget,
+    resolveDispatchReadOnly,
+    isMacLocalOrchestratorIntent,
+  },
+};