metame-cli 1.5.2 → 1.5.3

package/scripts/daemon-session-commands.js

@@ -35,11 +35,26 @@ function createSessionCommandHandler(deps) {
     return n === 'codex' ? 'codex' : getDefaultEngine();
   }
 
+  function getBoundCwd(chatId) {
+    try {
+      const cfg = loadConfig();
+      const chatAgentMap = { ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}), ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}) };
+      const mappedKey = chatAgentMap[String(chatId)];
+      const proj = mappedKey && cfg.projects ? cfg.projects[mappedKey] : null;
+      return (proj && proj.cwd) ? normalizeCwd(proj.cwd) : null;
+    } catch { return null; }
+  }
+
   // Write per-engine session slot, preserving cwd and other engine slots.
   function attachEngineSession(state, chatId, engine, sessionId, cwd) {
-    const existing = state.sessions[chatId] || {};
+    // For bound chats, resolve to virtual chatId so askClaude picks up the session
+    const cfg = loadConfig();
+    const agentMap = { ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}), ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}) };
+    const boundKey = agentMap[String(chatId)];
+    const effectiveId = boundKey ? `_agent_${boundKey}` : String(chatId);
+    const existing = state.sessions[effectiveId] || {};
     const existingEngines = existing.engines || {};
-    state.sessions[chatId] = {
+    state.sessions[effectiveId] = {
       ...existing,
       cwd: cwd || existing.cwd || HOME,
       engines: { ...existingEngines, [engine]: { id: sessionId, started: true } },
@@ -254,7 +269,7 @@ function createSessionCommandHandler(deps) {
     if (text === '/sessions') {
       const currentEngine = getDefaultEngine();
       const codexLimitTip = '⚠️ 当前为 Codex 会话：`/sessions` 列表暂仅展示 Claude 本地会话，Codex 会话暂不可见。';
-      const allSessions = listRecentSessions(15);
+      const allSessions = listRecentSessions(15, getBoundCwd(chatId));
       if (allSessions.length === 0) {
         const base = 'No sessions found. Try /new first.';
         await bot.sendMessage(chatId, currentEngine === 'codex' ? `${base}\n\n${codexLimitTip}` : base);
@@ -365,14 +380,7 @@ function createSessionCommandHandler(deps) {
 
         // For bound chats, prefer sessions from the same project to avoid
         // the bound-chat guard (handleCommand) immediately overwriting with a new session.
-        let boundCwd = null;
-        try {
-          const cfg = loadConfig();
-          const chatAgentMap = { ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}), ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}) };
-          const mappedKey = chatAgentMap[String(chatId)];
-          const proj = mappedKey && cfg.projects ? cfg.projects[mappedKey] : null;
-          if (proj && proj.cwd) boundCwd = normalizeCwd(proj.cwd);
-        } catch { /* ignore */ }
+        const boundCwd = getBoundCwd(chatId);
 
         let candidates = filtered;
         if (boundCwd) {

package/scripts/daemon-session-store.js

@@ -182,6 +182,11 @@ function createSessionStore(deps) {
               }
             }
           }
+          // Fallback: decode projectPath from directory name (e.g. -Users-yaron-AGI-AChat → /Users/yaron/AGI/AChat)
+          if (!projPathCache.has(proj) && proj.startsWith('-')) {
+            const decoded = proj.replace(/-/g, '/');
+            if (fs.existsSync(decoded)) projPathCache.set(proj, decoded);
+          }
         } catch { /* skip */ }
 
         try {
@@ -283,8 +288,7 @@ function createSessionStore(deps) {
   function listRecentSessions(limit, cwd) {
     let all = scanAllSessions();
     if (cwd) {
-      const matched = all.filter(s => s.projectPath === cwd);
-      if (matched.length > 0) all = matched;
+      all = all.filter(s => s.projectPath === cwd);
     }
     return all.slice(0, limit || 10);
   }
@@ -578,10 +582,24 @@ function createSessionStore(deps) {
   }
 
   // Claude backend: JSONL files under ~/.claude/projects/<hash>/
+  // Best approach: read cwd directly from session file content (not from dir name)
   function _isClaudeSessionValid(sessionId, normCwd) {
     try {
       const sessionFile = findSessionFile(sessionId);
       if (!sessionFile) return false;
+
+      // Try to read cwd from session JSONL file content (most reliable)
+      const content = fs.readFileSync(sessionFile, 'utf8');
+      const lines = content.split('\n').filter(l => l.trim());
+      for (const line of lines.slice(0, 20)) { // Check first 20 lines
+        try {
+          const entry = JSON.parse(line);
+          const fileCwd = entry.cwd || (entry.message && entry.message.cwd);
+          if (fileCwd && path.resolve(fileCwd) === normCwd) return true;
+        } catch { /* skip non-JSON lines */ }
+      }
+
+      // Fallback: check sessions-index.json if exists
       const projectDir = path.dirname(sessionFile);
       const indexFile = path.join(projectDir, 'sessions-index.json');
       if (fs.existsSync(indexFile)) {
@@ -592,15 +610,15 @@ function createSessionStore(deps) {
         const anyPath = (entries.find(e => e && e.projectPath) || {}).projectPath;
         if (anyPath) return path.resolve(anyPath) === normCwd;
       }
-      // Weak fallback: Claude encodes cwd in dir name; only trust a positive match.
-      // Unix: /home/user/project → -home-user-project
-      // Windows: D:\MetaMe → D--MetaMe (replaces : and \ with -)
+
+      // Last resort fallback: dir name match (less reliable, skip for worktree paths)
+      // Skip this for paths containing .worktree to avoid edge cases
+      if (normCwd.includes('.worktree')) return true; // trust the session exists
       const actualDir = path.basename(projectDir).toLowerCase();
       const expectedDir = process.platform === 'win32'
         ? normCwd.replace(/[:\\\/_ ]/g, '-').toLowerCase()
-        : ('-' + normCwd.replace(/^\//, '').replace(/[\/_ ]/g, '-')).toLowerCase();
-      if (actualDir === expectedDir) return true;
-      return false; // dir name mismatch — session belongs to a different project
+        : ('-' + normCwd.replace(/^\//, '').replace(/[\/_. ]/g, '-')).toLowerCase();
+      return actualDir === expectedDir;
     } catch {
       return true; // conservative: infra failure ≠ invalid session
     }

package/scripts/daemon-task-scheduler.js

@@ -741,12 +741,12 @@ function createTaskScheduler(deps) {
       lastTickTime = tickNow;
 
       if (tickElapsed > WAKE_THRESHOLD) {
-        log('FATAL', `[WAKE-DETECT] System resumed after ${Math.round(tickElapsed / 1000)}s sleep — restarting daemon to rebuild connections`);
+        log('WARN', `[WAKE-DETECT] System resumed after ${Math.round(tickElapsed / 1000)}s sleep — letting connections auto-reconnect`);
         const st = loadState();
         st.wake_restart = new Date().toISOString();
         st.wake_sleep_seconds = Math.round(tickElapsed / 1000);
         saveState(st);
-        process.exit(1); // caffeinate will restart us with fresh connections
+        // Don't exit — Feishu and Telegram have built-in auto-reconnect
       }
 
       // ① Physiological heartbeat (zero token, pure awareness)

package/scripts/daemon.js

@@ -69,6 +69,12 @@ const CLAUDE_BIN = (() => {
 // Skill evolution module (hot path + cold path)
 let skillEvolution = null;
 try { skillEvolution = require('./skill-evolution'); } catch { /* graceful fallback */ }
+const {
+  normalizeRemoteDispatchConfig,
+  encodePacket: encodeRemoteDispatchPacket,
+  decodePacket: decodeRemoteDispatchPacket,
+  verifyPacket: verifyRemoteDispatchPacket,
+} = require('./daemon-remote-dispatch');
 
 // ---------------------------------------------------------
 // SKILL ROUTING (keyword → /skillname prefix, like metame-desktop)
@@ -145,7 +151,7 @@ const { createFileBrowser } = require('./daemon-file-browser');
 const { createPidManager, setupRuntimeWatchers } = require('./daemon-runtime-lifecycle');
 const { createNotifier } = require('./daemon-notify');
 const { createClaudeEngine } = require('./daemon-claude-engine');
-const { createEngineRuntimeFactory, detectDefaultEngine, ENGINE_MODEL_CONFIG, ENGINE_DISTILL_MAP, ENGINE_DEFAULT_MODEL } = require('./daemon-engine-runtime');
+const { createEngineRuntimeFactory, detectDefaultEngine, resolveEngineModel, ENGINE_MODEL_CONFIG, ENGINE_DISTILL_MAP, ENGINE_DEFAULT_MODEL } = require('./daemon-engine-runtime');
 const { createCommandRouter } = require('./daemon-command-router');
 const { createTaskScheduler } = require('./daemon-task-scheduler');
 const { createAgentTools } = require('./daemon-agent-tools');
@@ -515,6 +521,31 @@ let _handleCommand = null;
 let _dispatchBridgeRef = null; // Store bridge (not bot) so .bot is always the live object after reconnects
 function setDispatchHandler(fn) { _handleCommand = fn; }
 
+function getRemoteDispatchConfig(config) {
+  return normalizeRemoteDispatchConfig(config || {});
+}
+
+async function sendRemoteDispatch(packet, config) {
+  const rd = getRemoteDispatchConfig(config);
+  const liveBot = _dispatchBridgeRef && _dispatchBridgeRef.bot;
+  if (!rd) return { success: false, error: 'feishu.remote_dispatch not configured' };
+  if (!liveBot || typeof liveBot.sendMessage !== 'function') return { success: false, error: 'feishu bot not connected' };
+  const ts = new Date().toISOString();
+  const id = `${rd.selfPeer}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    const body = encodeRemoteDispatchPacket({
+      v: 1,
+      id,
+      ts,
+      ...packet,
+    }, rd.secret);
+    await liveBot.sendMessage(rd.chatId, body);
+    return { success: true, id };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
 /**
  * Create a null bot that captures Claude's output without sending to Feishu/Telegram.
  */
@@ -795,6 +826,76 @@ 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
+  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');
+      }
+    }
+  } catch (e) {
+    log('WARN', `Failed to update shared files: ${e.message}`);
+  }
+
   const rawPrompt = envelope
     ? buildPromptFromTaskEnvelope(envelope, fullMsg.payload.prompt || fullMsg.payload.title || '')
     : (fullMsg.payload.prompt || fullMsg.payload.title || 'No prompt provided');
@@ -980,6 +1081,36 @@ function spawnSessionSummaries() {
 /**
  * Handle a single dispatch message (from socket or pending.jsonl fallback).
  */
+/**
+ * Find if both sender and target belong to the same team group.
+ * Returns { parentKey, parentProject, senderMember, targetMember, groupChatId } or null.
+ */
+function _findTeamBroadcastContext(fromKey, targetKey, config) {
+  if (!config || !config.projects) return null;
+  const feishuMap = (config.feishu && config.feishu.chat_agent_map) || {};
+  for (const [projKey, proj] of Object.entries(config.projects)) {
+    if (!proj || !Array.isArray(proj.team) || proj.team.length === 0) continue;
+    if (!proj.broadcast) continue; // broadcast switch must be on
+    const senderMember = proj.team.find(m => m.key === fromKey);
+    const targetMember = proj.team.find(m => m.key === targetKey);
+    // Also check if sender/target is the parent project itself
+    const senderIsParent = fromKey === projKey;
+    const targetIsParent = targetKey === projKey;
+    if ((senderMember || senderIsParent) && (targetMember || targetIsParent)) {
+      // Find group chatId for this project
+      const groupChatId = Object.entries(feishuMap).find(([, v]) => v === projKey)?.[0] || null;
+      return {
+        parentKey: projKey,
+        parentProject: proj,
+        senderMember: senderMember || { key: projKey, name: proj.name, icon: proj.icon || '🤖' },
+        targetMember: targetMember || { key: projKey, name: proj.name, icon: proj.icon || '🤖' },
+        groupChatId,
+      };
+    }
+  }
+  return null;
+}
+
 function handleDispatchItem(item, config) {
   if (!item.target || !item.prompt) return;
   if (!(config && config.projects && config.projects[item.target])) {
@@ -996,9 +1127,39 @@ function handleDispatchItem(item, config) {
     return;
   }
   log('INFO', `Dispatch: ${item.from || '?'} → ${item.target}: ${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;
+  if (teamCtx && teamCtx.groupChatId) {
+    const { senderMember, targetMember, groupChatId, parentProject } = teamCtx;
+    const sIcon = senderMember.icon || '🤖';
+    const sName = senderMember.name || senderMember.key;
+    const tIcon = targetMember.icon || '🤖';
+    const tName = targetMember.name || targetMember.key;
+    // Broadcast the handoff message to group as a card
+    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
+      ? () => 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, {
+      from: item.from || 'claude_session',
+      type: 'task', priority: 'normal',
+      payload: { title: item.prompt.slice(0, 60), prompt: item.prompt },
+      callback: false,
+      new_session: !!item.new_session,
+    }, config, null, streamOptions);
+    return;
+  }
+
+  // ── Normal dispatch (non-team or broadcast off) ──
   let pendingReplyFn = null;
   let streamOptions = null;
-  const liveBot = _dispatchBridgeRef && _dispatchBridgeRef.bot;
   if (liveBot) {
     const feishuMap = (config.feishu && config.feishu.chat_agent_map) || {};
     const allowedFeishuIds = (config.feishu && config.feishu.allowed_chat_ids) || [];
@@ -1016,7 +1177,21 @@ function handleDispatchItem(item, config) {
       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;
@@ -1038,6 +1213,8 @@ function handleDispatchItem(item, config) {
             );
           });
         };
+        // Also set streamOptions so target agent's streaming replies go to the sender's group
+        streamOptions = { bot: liveBot, chatId: senderChatId };
       }
     }
   }
@@ -1050,6 +1227,90 @@ function handleDispatchItem(item, config) {
   }, config, pendingReplyFn, streamOptions);
 }
 
+async function handleRemoteDispatchMessage({ chatId, text, config }) {
+  const rd = getRemoteDispatchConfig(config);
+  if (!rd || String(chatId) !== rd.chatId) return false;
+
+  const packet = decodeRemoteDispatchPacket(text);
+  if (!packet) 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.type === 'task') {
+    const replyFn = async (output) => {
+      const res = await sendRemoteDispatch({
+        type: 'result',
+        from_peer: rd.selfPeer,
+        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',
+        request_id: packet.id,
+        result: String(output || '').slice(0, 4000),
+      }, config);
+      if (!res.success) log('WARN', `Remote dispatch result send failed: ${res.error}`);
+    };
+
+    handleDispatchItem({
+      target: packet.target_project,
+      prompt: packet.prompt,
+      from: packet.source_sender_key || `${packet.from_peer}:remote`,
+      new_session: !!packet.new_session,
+      _replyFn: replyFn,
+      _suppressDefaultReplyRouting: true,
+    }, config);
+    return true;
+  }
+
+  if (packet.type === 'result') {
+    const targetChatId = String(packet.source_chat_id || '').trim();
+    if (!targetChatId) {
+      const inboxTarget = String(packet.source_sender_key || '').trim();
+      if (!inboxTarget || inboxTarget === 'user' || inboxTarget === '_claude_session') {
+        log('WARN', 'Remote dispatch result dropped: no source_chat_id/source_sender_key');
+        return true;
+      }
+      try {
+        const inboxDir = path.join(os.homedir(), '.metame', 'memory', 'inbox', inboxTarget);
+        fs.mkdirSync(inboxDir, { recursive: true });
+        const tsStr = new Date().toISOString().replace(/[-:T]/g, '').slice(0, 15);
+        const inboxFile = path.join(inboxDir, `${tsStr}_${packet.from_peer}_${packet.target_project || 'remote'}_result.md`);
+        const body = [
+          `FROM: ${packet.from_peer}:${packet.target_project || 'unknown'}`,
+          `TO: ${inboxTarget}`,
+          `TS: ${new Date().toISOString()}`,
+          '',
+          String(packet.result || '').trim() || '(empty result)',
+        ].join('\n');
+        fs.writeFileSync(inboxFile, body, 'utf8');
+      } catch (e) {
+        log('WARN', `Remote dispatch inbox write failed: ${e.message}`);
+      }
+      return true;
+    }
+    const liveBot = _dispatchBridgeRef && _dispatchBridgeRef.bot;
+    if (!liveBot) {
+      log('WARN', 'Remote dispatch result dropped: no live bot');
+      return true;
+    }
+    const header = `${packet.from_peer}:${packet.target_project || 'unknown'}`;
+    const body = `${header}\n\n${String(packet.result || '').trim() || '(empty result)'}`;
+    try {
+      if (liveBot.sendMarkdown) await liveBot.sendMarkdown(targetChatId, body);
+      else await liveBot.sendMessage(targetChatId, body);
+    } catch (e) {
+      log('WARN', `Remote dispatch result delivery failed: ${e.message}`);
+    }
+    return true;
+  }
+
+  return true;
+}
+
 /**
  * Start Unix Domain Socket server for low-latency dispatch.
  */
@@ -1528,6 +1789,7 @@ const { handleAdminCommand } = createAdminCommandHandler({
   skillEvolution,
   taskBoard,
   taskEnvelope,
+  sendRemoteDispatch,
   getActiveProcesses: () => activeProcesses,
   getMessageQueue: () => messageQueue,
   loadState,
@@ -1765,6 +2027,8 @@ const { startTelegramBridge, startFeishuBridge } = createBridgeStarter({
   getSession,
   handleCommand,
   pendingActivations,
+  activeProcesses,
+  messageQueue,
 });
 
 const { killExistingDaemon, writePid, cleanPid } = createPidManager({
@@ -1900,7 +2164,9 @@ async function main() {
     'enable_nl_mac_fallback',
   ];
   // All known models across all engines (for legacy daemon.model validation only)
-  const BUILTIN_CLAUDE_MODELS = ENGINE_MODEL_CONFIG.claude.options;
+  const BUILTIN_CLAUDE_MODELS = (ENGINE_MODEL_CONFIG.claude.options || []).map(option =>
+    typeof option === 'string' ? option : option.value
+  ).filter(Boolean);
   for (const key of Object.keys(config)) {
     if (!KNOWN_SECTIONS.includes(key)) log('WARN', `Config: unknown section "${key}" (typo?)`);
   }
@@ -1914,7 +2180,7 @@ async function main() {
       if (activeProv === 'anthropic' && _defaultEngine === 'claude') {
         log('WARN', `Config: daemon.model="${config.daemon.model}" is not a known Claude model`);
       } else {
-        log('INFO', `Config: model "${config.daemon.model}" for engine "${_defaultEngine}" / provider "${activeProv}"`);
+        log('INFO', `Config: legacy daemon.model="${config.daemon.model}" retained; active ${_defaultEngine} model resolves to "${resolveEngineModel(_defaultEngine, config.daemon)}" (${activeProv})`);
       }
     }
   }
@@ -2162,5 +2428,5 @@ if (process.argv.includes('--run')) {
   });
 }
 
-// Export for testing
-module.exports = { executeTask, loadConfig, loadState, buildProfilePreamble, parseInterval };
+// Export for testing & cross-bot dispatch
+module.exports = { executeTask, loadConfig, loadState, buildProfilePreamble, parseInterval, handleRemoteDispatchMessage, sendRemoteDispatch };