metame-cli 1.5.4 → 1.5.6

package/scripts/daemon-siri-bridge.js

@@ -0,0 +1,234 @@
+'use strict';
+/**
+ * daemon-siri-bridge.js — HTTP bridge for Siri Shortcuts integration
+ *
+ * Exposes GET/POST /ask endpoint and returns plain text.
+ * Processes through the same Claude pipeline as Telegram/Feishu/iMessage.
+ * Designed for iOS Shortcuts: Dictate → HTTP GET/POST → Speak Text.
+ */
+
+const http = require('http');
+const querystring = require('querystring');
+
+function createSiriBridge(deps) {
+  const { log, loadConfig, handleCommand } = deps;
+
+  function writeText(res, statusCode, text, extraHeaders = {}) {
+    const body = String(text || '');
+    res.writeHead(statusCode, {
+      'Content-Type': 'text/plain; charset=utf-8',
+      'Content-Length': Buffer.byteLength(body),
+      'Cache-Control': 'no-store, no-transform',
+      'X-Content-Type-Options': 'nosniff',
+      ...extraHeaders,
+    });
+    res.end(body);
+  }
+
+  function writeJson(res, statusCode, payload, extraHeaders = {}) {
+    const body = JSON.stringify(payload);
+    res.writeHead(statusCode, {
+      'Content-Type': 'application/json; charset=utf-8',
+      'Content-Length': Buffer.byteLength(body),
+      'Cache-Control': 'no-store, no-transform',
+      'X-Content-Type-Options': 'nosniff',
+      ...extraHeaders,
+    });
+    res.end(body);
+  }
+
+  function normalizePlainText(text) {
+    return String(text || '').replace(/\r\n/g, '\n').trim();
+  }
+
+  function getAuthToken(req, urlObj) {
+    const auth = String(req.headers.authorization || '').replace(/^Bearer\s+/i, '').trim();
+    if (auth) return auth;
+    return String(urlObj.searchParams.get('token') || req.headers['x-api-key'] || '').trim();
+  }
+
+  async function readRequestBody(req) {
+    const chunks = [];
+    for await (const chunk of req) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8');
+  }
+
+  function extractAskText(req, urlObj, rawBody) {
+    const queryText = normalizePlainText(urlObj.searchParams.get('q') || urlObj.searchParams.get('text') || '');
+    if (queryText) return queryText;
+
+    const body = String(rawBody || '');
+    if (!body.trim()) return '';
+
+    const contentType = String(req.headers['content-type'] || '').split(';')[0].trim().toLowerCase();
+    if (contentType === 'application/json') {
+      try {
+        const parsed = JSON.parse(body);
+        return normalizePlainText(
+          parsed && typeof parsed === 'object'
+            ? (parsed.text || parsed.q || parsed.prompt || '')
+            : ''
+        );
+      } catch {
+        return '';
+      }
+    }
+
+    if (contentType === 'application/x-www-form-urlencoded') {
+      const parsed = querystring.parse(body);
+      return normalizePlainText(parsed.text || parsed.q || parsed.prompt || '');
+    }
+
+    return normalizePlainText(body);
+  }
+
+  /**
+   * Collector bot — captures Claude's response instead of sending to a chat.
+   * handleCommand calls bot.sendMessage / sendMarkdown / editMessage as it
+   * streams; we collect everything and return the final text.
+   */
+  function createCollectorBot() {
+    const messages = new Map();
+    let nextId = 1;
+
+    const bot = {
+      suppressAck: true,
+      sendMessage: async (_chatId, text) => {
+        const id = nextId++;
+        messages.set(id, String(text || ''));
+        return { message_id: id };
+      },
+      sendMarkdown: async (_chatId, text) => {
+        const id = nextId++;
+        messages.set(id, String(text || '').replace(/[*_`~#>]/g, '').trim());
+        return { message_id: id };
+      },
+      editMessage: async (_chatId, msgId, text) => {
+        const plain = String(text || '').replace(/[*_`~#>]/g, '').trim();
+        messages.set(msgId, plain);
+        return true;
+      },
+      deleteMessage: async () => false,
+      sendTyping: async () => {},
+      getResult: () => {
+        let last = '';
+        for (const [, text] of messages) {
+          if (text && text.trim()) last = text.trim();
+        }
+        return last;
+      },
+    };
+    return bot;
+  }
+
+  function startSiriBridge(config, executeTaskByName) {
+    const cfg = config.siri_bridge || {};
+    if (!cfg.enabled) return null;
+
+    const port = cfg.port || 8200;
+    const token = cfg.token || '';
+    const chatId = cfg.chat_id || '_siri_';
+    const timeoutMs = cfg.timeout_ms || 120000;
+    const maxReplyLen = cfg.max_reply_length || 0; // 0 = unlimited
+
+    if (!token) {
+      log('WARN', '[SIRI] siri_bridge.token not configured — bridge disabled');
+      return null;
+    }
+
+    const server = http.createServer(async (req, res) => {
+      log('DEBUG', `[SIRI] ${req.method} ${req.url} from ${req.socket.remoteAddress}`);
+      const urlObj = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+
+      // CORS preflight
+      if (req.method === 'OPTIONS') {
+        res.writeHead(204, {
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+          'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-API-Key',
+          'Access-Control-Max-Age': '86400',
+        });
+        res.end();
+        return;
+      }
+
+      // Health check
+      if (req.method === 'GET' && urlObj.pathname === '/health') {
+        writeJson(res, 200, { status: 'ok' });
+        return;
+      }
+
+      // Quick echo test — GET /echo?t=xxx returns plain text immediately
+      if (req.method === 'GET' && urlObj.pathname === '/echo') {
+        const t = normalizePlainText(urlObj.searchParams.get('t') || 'hello from jarvis');
+        writeText(res, 200, t);
+        return;
+      }
+
+      // /ask supports GET for iOS Shortcuts and POST for compatibility.
+      if (!['GET', 'POST'].includes(req.method) || urlObj.pathname !== '/ask') {
+        writeText(res, 404, 'Not Found');
+        return;
+      }
+
+      // Auth
+      const auth = getAuthToken(req, urlObj);
+      if (auth !== token) {
+        writeText(res, 401, 'Unauthorized');
+        return;
+      }
+
+      const rawBody = req.method === 'POST' ? await readRequestBody(req) : '';
+      const text = extractAskText(req, urlObj, rawBody);
+      if (!text) {
+        writeText(res, 400, 'Missing q/text');
+        return;
+      }
+
+      log('INFO', `[SIRI] Received: "${text.slice(0, 80)}"`);
+
+      // Timeout guard
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        writeText(res, 504, 'timeout');
+      }, timeoutMs);
+
+      try {
+        const bot = createCollectorBot();
+        const liveCfg = loadConfig();
+        await handleCommand(bot, chatId, text, liveCfg, executeTaskByName, null, true);
+
+        if (timedOut) return;
+        clearTimeout(timer);
+
+        let reply = bot.getResult() || '(no response)';
+        if (maxReplyLen && reply.length > maxReplyLen) {
+          reply = reply.slice(0, maxReplyLen) + '...';
+        }
+
+        log('INFO', `[SIRI] Reply: "${reply.slice(0, 80)}"`);
+        writeText(res, 200, reply);
+      } catch (err) {
+        if (timedOut) return;
+        clearTimeout(timer);
+        log('ERROR', `[SIRI] Error: ${err.message}`);
+        writeText(res, 500, err.message);
+      }
+    });
+
+    server.listen(port, '0.0.0.0', () => {
+      log('INFO', `[SIRI] HTTP bridge listening on 0.0.0.0:${port}`);
+    });
+
+    server.on('error', (err) => {
+      log('ERROR', `[SIRI] Server error: ${err.message}`);
+    });
+
+    return { stop: () => server.close() };
+  }
+
+  return { startSiriBridge };
+}
+
+module.exports = { createSiriBridge };

package/scripts/daemon-siri-imessage.js

@@ -0,0 +1,209 @@
+'use strict';
+/**
+ * daemon-siri-imessage.js — iMessage I/O layer
+ *
+ * 底层函数：轮询 chat.db + AppleScript 发送。
+ * 上层 Bridge 逻辑在 daemon-bridges.js 的 startImessageBridge()。
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFile, execFileSync } = require('child_process');
+
+const CHAT_DB = path.join(os.homedir(), 'Library', 'Messages', 'chat.db');
+
+// macOS Ventura+: text may be stored in attributedBody blob, not text field.
+// Returns TSV rows:
+//   rowid\ttext\tsender\tchat_guid\tchat_identifier\tchat_name
+//
+// Key filters:
+//   1. is_from_me=0 in SQL WHERE clause is the primary echo guard.
+//   2. local_guids filter REMOVED: in self-chat (note-to-self), all incoming messages
+//      share the Mac's account_guid, so the old filter blocked everything.
+//      Echo prevention is now handled by content fingerprint in createImessageBot.
+//   3. Drop reactions/system/service messages so tapbacks never become prompts.
+const PYTHON_QUERY = `
+import sqlite3,os,re,sys
+db=os.path.expanduser('~/Library/Messages/chat.db')
+con=sqlite3.connect(db)
+rows=con.execute("""
+  SELECT
+    m.rowid,
+    m.text,
+    m.attributedBody,
+    h.id,
+    c.guid,
+    c.chat_identifier,
+    coalesce(c.display_name, c.room_name, c.chat_identifier, c.guid, ''),
+    coalesce(m.account_guid, ''),
+    coalesce(m.associated_message_guid, ''),
+    coalesce(m.associated_message_type, 0),
+    coalesce(m.associated_message_emoji, ''),
+    coalesce(m.is_system_message, 0),
+    coalesce(m.is_service_message, 0),
+    coalesce(m.item_type, 0)
+  FROM message m
+  LEFT JOIN handle h ON m.handle_id=h.rowid
+  LEFT JOIN chat_message_join cmj ON cmj.message_id=m.rowid
+  LEFT JOIN chat c ON c.rowid=cmj.chat_id
+  WHERE m.rowid > ? AND m.is_from_me = 0
+  ORDER BY m.rowid ASC LIMIT 20
+""",(int(sys.argv[1]),)).fetchall()
+seen=set()
+for rowid,text,body,sender,chat_guid,chat_identifier,chat_name,account_guid,assoc_guid,assoc_type,assoc_emoji,is_system,is_service,item_type in rows:
+    if assoc_guid or assoc_type or assoc_emoji or is_system or is_service or item_type:
+        continue
+    if not text and body:
+        decoded=body.decode('utf-8','ignore')
+        m=re.search(r'[\\x20-\\x7e\\u4e00-\\u9fff\\u3000-\\u303f\\uff00-\\uffef]{2,}',decoded)
+        if m: text=m.group(0).strip()
+    if text and text.strip():
+        key=(rowid, chat_guid or chat_identifier or sender or '')
+        if key in seen:
+            continue
+        seen.add(key)
+        print(
+            str(rowid)+'\\t'
+            +str(text).replace('\\n',' ')+'\\t'
+            +(sender or '')+'\\t'
+            +(chat_guid or '')+'\\t'
+            +(chat_identifier or '')+'\\t'
+            +str(chat_name or '').replace('\\n',' ')
+        )
+`.trim();
+
+function isAvailable() {
+  return fs.existsSync(CHAT_DB);
+}
+
+function getMaxRowId() {
+  try {
+    return parseInt(
+      execFileSync('sqlite3', [CHAT_DB, 'SELECT MAX(rowid) FROM message;'],
+        { encoding: 'utf8', timeout: 5000 }).trim(), 10
+    ) || 0;
+  } catch { return 0; }
+}
+
+function queryNewMessages(lastRowId) {
+  try {
+    return execFileSync('python3', ['-c', PYTHON_QUERY, String(lastRowId)],
+      { encoding: 'utf8', timeout: 8000 }).trim();
+  } catch { return ''; }
+}
+
+function escapeAppleScriptString(input) {
+  return String(input || '')
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n');
+}
+
+// Send iMessage via AppleScript; targetChatId should be chat.id / chat.guid.
+function sendImessage(targetChatId, text) {
+  return new Promise((resolve) => {
+    const safe = escapeAppleScriptString(text);
+    const safeChatId = escapeAppleScriptString(targetChatId);
+    const script = [
+      'tell application "Messages"',
+      `  send "${safe}" to chat id "${safeChatId}"`,
+      'end tell',
+    ].join('\n');
+    execFile('osascript', ['-e', script], { timeout: 15000 }, (err) => resolve(!err));
+  });
+}
+
+// Create a bot object compatible with handleCommand / daemon-claude-engine.
+//
+// Design goals for iMessage:
+//   1. No intermediate status spam — buffer all sends, flush only the final text.
+//   2. Prevent echo loop — track recently-sent content fingerprints.
+//   3. editMessage returns true (pretend success) so engine doesn't double-send.
+function createImessageBot(targetChatId, log) {
+  let flushTimer = null;
+  let pendingText = '';
+  // onAfterSend: bridge injects this to advance lastRowId after we send
+  let _onAfterSend = null;
+
+  // Echo fingerprint ring — stores { text, ts } of recently sent messages.
+  // Used by bridge to detect and skip echoed incoming messages.
+  const sentFingerprints = [];
+  const FINGERPRINT_TTL = 30000; // 30s window
+
+  const addFingerprint = (text) => {
+    const now = Date.now();
+    sentFingerprints.push({ text: text.trim().toLowerCase().replace(/\s+/g, ' '), ts: now });
+    // Prune expired entries
+    while (sentFingerprints.length && sentFingerprints[0].ts < now - FINGERPRINT_TTL) {
+      sentFingerprints.shift();
+    }
+  };
+
+  const isEcho = (text) => {
+    const now = Date.now();
+    const needle = text.trim().toLowerCase().replace(/\s+/g, ' ');
+    for (let i = sentFingerprints.length - 1; i >= 0; i--) {
+      const fp = sentFingerprints[i];
+      if (fp.ts < now - FINGERPRINT_TTL) break;
+      // Prefix match: echo may have trailing whitespace or truncation differences
+      if (fp.text === needle || needle.startsWith(fp.text.slice(0, 20)) || fp.text.startsWith(needle.slice(0, 20))) return true;
+    }
+    return false;
+  };
+
+  const scheduleFlush = (text) => {
+    if (flushTimer) clearTimeout(flushTimer);
+    pendingText = text;
+    flushTimer = setTimeout(async () => {
+      flushTimer = null;
+      const final = pendingText;
+      pendingText = '';
+      if (!final) return;
+      const tagged = `🤖 ${final}`;
+      addFingerprint(tagged);
+      const ok = await sendImessage(targetChatId, tagged);
+      if (!ok && log) log('WARN', `[IMESSAGE] send failed to ${targetChatId}`);
+      // After sending, advance lastRowId so the echo is skipped
+      if (_onAfterSend) _onAfterSend();
+    }, 3000); // wait 3s for streaming to settle before sending
+  };
+
+  // Record fingerprint IMMEDIATELY on send/edit calls — not in flush timer.
+  // This ensures the echo is recognized even if poll runs before flush fires.
+  const sendAndFingerprint = (text) => {
+    if (text) {
+      addFingerprint(text);
+      scheduleFlush(text);
+    }
+  };
+
+  const bot = {
+    suppressAck: true,
+    isEcho,
+    sendMessage: (_chatId, text) => {
+      const plain = String(text || '').replace(/[*_`~]/g, '').trim();
+      sendAndFingerprint(plain);
+      return Promise.resolve({ message_id: Date.now() });
+    },
+    sendMarkdown: (_chatId, text) => {
+      const plain = String(text || '').replace(/[*_`~#>]/g, '').trim();
+      sendAndFingerprint(plain);
+      return Promise.resolve({ message_id: Date.now() });
+    },
+    // editMessage: update buffered text and extend flush timer — return true so
+    // engine doesn't fall through to a redundant sendMessage call.
+    editMessage: (_chatId, _msgId, text) => {
+      const plain = String(text || '').replace(/[*_`~]/g, '').trim();
+      sendAndFingerprint(plain);
+      return Promise.resolve(true);
+    },
+    deleteMessage: async () => false,
+    sendTyping:    async () => {},
+    // Bridge injects this after bot is created
+    setOnAfterSend: (fn) => { _onAfterSend = fn; },
+  };
+  return bot;
+}
+
+module.exports = { isAvailable, getMaxRowId, queryNewMessages, createImessageBot };

package/scripts/daemon-task-scheduler.js

@@ -2,7 +2,6 @@
 
 const crypto = require('crypto');
 const { classifyTaskUsage } = require('./usage-classifier');
-const { IS_WIN } = require('./platform');
 
 const WEEKDAY_INDEX = Object.freeze({
   sun: 0,
@@ -196,6 +195,7 @@ function createTaskScheduler(deps) {
     isInSleepMode,
     setSleepMode,
     spawnSessionSummaries,
+    getWakeRecoveryHook,
     skillEvolution,
   } = deps;
 
@@ -746,7 +746,15 @@ function createTaskScheduler(deps) {
         st.wake_restart = new Date().toISOString();
         st.wake_sleep_seconds = Math.round(tickElapsed / 1000);
         saveState(st);
-        // Don't exit — Feishu and Telegram have built-in auto-reconnect
+        const onWakeDetected = typeof getWakeRecoveryHook === 'function' ? getWakeRecoveryHook() : null;
+        if (typeof onWakeDetected === 'function') {
+          Promise.resolve(onWakeDetected({
+            sleepSeconds: Math.round(tickElapsed / 1000),
+            resumedAt: new Date(tickNow).toISOString(),
+          })).catch((e) => {
+            log('WARN', `[WAKE-DETECT] bridge recovery failed: ${e.message}`);
+          });
+        }
       }
 
       // ① Physiological heartbeat (zero token, pure awareness)

package/scripts/{team-dispatch.js → daemon-team-dispatch.js}

@@ -6,7 +6,8 @@
  * Single source of truth for:
  *   - Project/team member resolution by name or nickname
  *   - Team roster hint generation (injected into member sessions)
- *   - Prompt enrichment with shared context (inbox / now.md / _latest.md)
+ *   - Prompt enrichment with scoped context (private now / shared now / inbox / _latest.md)
+ *   - Dispatch context file writes for target-only and team-shared tasks
  *
  * Used by: dispatch_to binary, daemon-admin-commands, daemon-bridges, daemon.js
  */
@@ -112,13 +113,132 @@ function buildTeamRosterHint(parentKey, memberKey, projects) {
   ].join('\n');
 }
 
+function resolveDispatchActor(sourceKey, projects) {
+  const rawKey = String(sourceKey || '').trim();
+  const userSources = new Set(['', 'unknown', 'claude_session', '_claude_session', 'user']);
+  if (userSources.has(rawKey)) return { key: 'user', name: '用户', icon: '👤', isUser: true };
+  const proj = projects && projects[rawKey];
+  if (proj) return { key: rawKey, name: proj.name || rawKey, icon: proj.icon || '🤖', isUser: false };
+  return { key: rawKey || 'unknown', name: rawKey || 'unknown', icon: '🤖', isUser: false };
+}
+
+function buildPrivateNowContent({ actor, target, title, prompt, timeStr, dispatchId, taskId, scopeId, chain }) {
+  const lines = [
+    '# 当前任务',
+    `**最后更新**: ${timeStr} **更新者**: ${actor.icon} ${actor.name}`,
+    '',
+    '## 当前派发',
+    `- **目标**: ${target.icon} ${target.name} (${target.key})`,
+    `- **任务**: ${title || prompt.slice(0, 120) || '(empty)'}`,
+    dispatchId ? `- **编号**: ${dispatchId}` : '',
+    taskId ? `- **TeamTask**: ${taskId}` : '',
+    scopeId && scopeId !== taskId ? `- **Scope**: ${scopeId}` : '',
+    '',
+    '## 任务链',
+    chain && chain.length > 0 ? chain.join(' → ') : `${actor.key} → ${target.key}`,
+  ].filter(Boolean);
+  return `${lines.join('\n')}\n`;
+}
+
+function buildSharedNowContent({ actor, target, title, prompt, timeStr, dispatchId, taskId, scopeId, chain }) {
+  const lines = [
+    '# 共享当前状态',
+    `**最后更新**: ${timeStr} **更新者**: ${actor.icon} ${actor.name}`,
+    '',
+    '## 当前任务',
+    `- **派发给**: ${target.icon} ${target.name} (${target.key})`,
+    `- **任务**: ${title || prompt.slice(0, 120) || '(empty)'}`,
+    dispatchId ? `- **编号**: ${dispatchId}` : '',
+    taskId ? `- **TeamTask**: ${taskId}` : '',
+    scopeId && scopeId !== taskId ? `- **Scope**: ${scopeId}` : '',
+    `- **时间**: ${timeStr}`,
+    '',
+    '## 任务链',
+    chain && chain.length > 0 ? chain.join(' → ') : `${actor.key} → ${target.key}`,
+  ].filter(Boolean);
+  return `${lines.join('\n')}\n`;
+}
+
+function updateDispatchContextFiles({ fs: fsMod = fs, path: pathMod = path, baseDir = METAME_DIR, fullMsg, targetProject, config, envelope, logger = null }) {
+  if (!fullMsg || !targetProject) return { targetNowPath: null, sharedNowPath: null, tasksFilePath: null };
+
+  const logWarn = (msg) => {
+    if (typeof logger === 'function') logger(msg);
+  };
+  const nowDir = pathMod.join(baseDir, 'memory', 'now');
+  const sharedDir = pathMod.join(baseDir, 'memory', 'shared');
+  const targetNowPath = pathMod.join(nowDir, `${targetProject}.md`);
+  const sharedNowPath = pathMod.join(nowDir, 'shared.md');
+  const tasksFilePath = pathMod.join(sharedDir, 'tasks.md');
+  fsMod.mkdirSync(nowDir, { recursive: true });
+
+  const projects = (config && config.projects) || {};
+  const actor = resolveDispatchActor((fullMsg && fullMsg.source_sender_key) || (fullMsg && fullMsg.from), projects);
+  const targetProj = projects[targetProject] || {};
+  const target = { key: targetProject, name: targetProj.name || targetProject, icon: targetProj.icon || '🤖' };
+  const prompt = String(fullMsg && fullMsg.payload && fullMsg.payload.prompt || '').trim();
+  const title = String(fullMsg && fullMsg.payload && fullMsg.payload.title || '').trim();
+  const now = new Date();
+  const timeStr = now.toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai', hour12: false });
+  const dateStr = now.toISOString().slice(0, 10);
+  const taskId = String(envelope && envelope.task_id || '').trim();
+  const scopeId = String(envelope && envelope.scope_id || '').trim();
+  const isSharedTeamTask = !!(envelope && envelope.task_kind === 'team');
+
+  fsMod.writeFileSync(targetNowPath, buildPrivateNowContent({
+    actor, target, title, prompt, timeStr,
+    dispatchId: fullMsg.id, taskId, scopeId, chain: fullMsg.chain,
+  }), 'utf8');
+
+  if (!isSharedTeamTask) return { targetNowPath, sharedNowPath: null, tasksFilePath: null };
+
+  fsMod.writeFileSync(sharedNowPath, buildSharedNowContent({
+    actor, target, title, prompt, timeStr,
+    dispatchId: fullMsg.id, taskId, scopeId, chain: fullMsg.chain,
+  }), 'utf8');
+
+  try {
+    if (!fsMod.existsSync(sharedDir)) fsMod.mkdirSync(sharedDir, { recursive: true });
+    const taskLine = `- [${dateStr}] ${actor.icon} ${actor.name} → ${target.icon} ${target.name}: ${title || prompt.slice(0, 40)}`;
+    let tasksContent = fsMod.existsSync(tasksFilePath)
+      ? fsMod.readFileSync(tasksFilePath, 'utf8')
+      : '# 任务看板\n\n## 🔄 进行中\n\n## ✅ 已完成\n\n## 📅 待开始\n';
+    if (!tasksContent.includes(taskLine)) {
+      const lines = tasksContent.split('\n');
+      const nextLines = [];
+      let inserted = false;
+      let inProgress = false;
+      for (const line of lines) {
+        nextLines.push(line);
+        if (line.includes('## 🔄 进行中')) {
+          inProgress = true;
+          continue;
+        }
+        if (inProgress && line.startsWith('## ')) {
+          nextLines.splice(nextLines.length - 1, 0, taskLine);
+          inserted = true;
+          inProgress = false;
+        }
+      }
+      if (!inserted) nextLines.push(taskLine);
+      tasksContent = nextLines.join('\n');
+      fsMod.writeFileSync(tasksFilePath, tasksContent, 'utf8');
+    }
+  } catch (e) {
+    logWarn(`Failed to update shared task board: ${e.message}`);
+  }
+
+  return { targetNowPath, sharedNowPath, tasksFilePath };
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Prompt enrichment (shared context injection)
 // ─────────────────────────────────────────────────────────────────────────────
 
 /**
  * Enrich a dispatch prompt with shared context read at send time:
- *   1. now/shared.md   — global progress whiteboard
+ *   1. now/<target>.md — target private progress handoff
+ *   2. now/shared.md   — global team progress whiteboard (only when includeShared=true)
  *   2. agents/<target>_latest.md — target's last output
  *   3. inbox/<target>/ — unread messages (archived to read/ after reading)
  *
@@ -129,20 +249,32 @@ function buildTeamRosterHint(parentKey, memberKey, projects) {
  * @param {string} [metameDir] - override METAME_DIR (for testing)
  * @returns {string}
  */
-function buildEnrichedPrompt(target, rawPrompt, metameDir) {
+function buildEnrichedPrompt(target, rawPrompt, metameDir, opts = {}) {
   const base = metameDir || METAME_DIR;
+  const includeShared = !!(opts && opts.includeShared);
   let ctx = '';
 
-  // 1. Shared progress whiteboard
+  // 1. Target private now file
   try {
-    const nowFile = path.join(base, 'memory', 'now', 'shared.md');
-    if (fs.existsSync(nowFile)) {
-      const content = fs.readFileSync(nowFile, 'utf8').trim();
-      if (content) ctx += `[共享进度 now.md]\n${content}\n\n`;
+    const targetNowFile = path.join(base, 'memory', 'now', `${target}.md`);
+    if (fs.existsSync(targetNowFile)) {
+      const content = fs.readFileSync(targetNowFile, 'utf8').trim();
+      if (content) ctx += `[当前进度 now/${target}.md]\n${content}\n\n`;
     }
   } catch { /* non-critical */ }
 
-  // 2. Target's last output
+  // 2. Shared progress whiteboard for real team tasks only
+  if (includeShared) {
+    try {
+      const nowFile = path.join(base, 'memory', 'now', 'shared.md');
+      if (fs.existsSync(nowFile)) {
+        const content = fs.readFileSync(nowFile, 'utf8').trim();
+        if (content) ctx += `[共享进度 now/shared.md]\n${content}\n\n`;
+      }
+    } catch { /* non-critical */ }
+  }
+
+  // 3. Target's last output
   try {
     const latestFile = path.join(base, 'memory', 'agents', `${target}_latest.md`);
     if (fs.existsSync(latestFile)) {
@@ -151,7 +283,7 @@ function buildEnrichedPrompt(target, rawPrompt, metameDir) {
     }
   } catch { /* non-critical */ }
 
-  // 3. Inbox unread messages (archive after reading)
+  // 4. Inbox unread messages (archive after reading)
   try {
     const inboxDir = path.join(base, 'memory', 'inbox', target);
     const readDir = path.join(inboxDir, 'read');
@@ -173,4 +305,11 @@ function buildEnrichedPrompt(target, rawPrompt, metameDir) {
   return ctx ? `${ctx}---\n${rawPrompt}` : rawPrompt;
 }
 
-module.exports = { resolveProjectKey, findTeamMember, buildTeamRosterHint, buildEnrichedPrompt };
+module.exports = {
+  resolveProjectKey,
+  findTeamMember,
+  buildTeamRosterHint,
+  buildEnrichedPrompt,
+  resolveDispatchActor,
+  updateDispatchContextFiles,
+};