metame-cli 1.3.23 → 1.4.3

package/scripts/daemon.js

@@ -27,6 +27,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 SOCK_PATH = path.join(METAME_DIR, 'daemon.sock');
 
 // Skill evolution module (hot path + cold path)
 let skillEvolution = null;
@@ -318,11 +319,13 @@ function executeTask(task, config) {
   if (task.type === 'script') {
     log('INFO', `Executing script task: ${task.name} → ${task.command}`);
     try {
+      const scriptEnv = { ...process.env, METAME_ROOT: process.env.METAME_ROOT || '' };
+      delete scriptEnv.CLAUDECODE;
       const output = execSync(task.command, {
         encoding: 'utf8',
-        timeout: 120000,
+        timeout: (task.timeout || 120) * 1000,
         maxBuffer: 1024 * 1024,
-        env: { ...process.env, METAME_ROOT: process.env.METAME_ROOT || '' },
+        env: scriptEnv,
       }).trim();
 
       state.tasks[task.name] = {
@@ -331,7 +334,8 @@ function executeTask(task, config) {
         output_preview: output.slice(0, 200),
       };
       saveState(state);
-      log('INFO', `Script task ${task.name} completed`);
+      if (output) log('INFO', `Script task ${task.name} completed: ${output.slice(0, 300)}`);
+      else log('INFO', `Script task ${task.name} completed`);
       return { success: true, output, tokens: 0 };
     } catch (e) {
       log('ERROR', `Script task ${task.name} failed: ${e.message}`);
@@ -545,15 +549,62 @@ function setDispatchHandler(fn) { _handleCommand = fn; }
 function createNullBot(onOutput) {
   const noop = async () => ({ message_id: '_virtual' });
   return {
-    sendMessage:   async (chatId, text) => { if (onOutput) onOutput(text); return { message_id: '_virtual' }; },
-    sendMarkdown:  async (chatId, text) => { if (onOutput) onOutput(text); return { message_id: '_virtual' }; },
-    sendCard:      async (chatId, card) => { if (onOutput) onOutput(typeof card === 'object' ? (card.body || card.title || JSON.stringify(card)) : card); return { message_id: '_virtual' }; },
-    sendButtons:   async (chatId, text) => { if (onOutput) onOutput(text); return { message_id: '_virtual' }; },
-    sendTyping:    async () => {},
-    editMessage:   async () => {},
-    deleteMessage: async () => {},
-    sendFile:      noop,
-    downloadFile:  noop,
+    sendMessage: async (chatId, text) => { if (onOutput) onOutput(text); return { message_id: '_virtual' }; },
+    sendMarkdown: async (chatId, text) => { if (onOutput) onOutput(text); return { message_id: '_virtual' }; },
+    sendCard: async (chatId, card) => { if (onOutput) onOutput(typeof card === 'object' ? (card.body || card.title || JSON.stringify(card)) : card); return { message_id: '_virtual' }; },
+    sendRawCard: async (chatId, header) => { if (onOutput) onOutput(header); return { message_id: '_virtual' }; },
+    sendButtons: async (chatId, text) => { if (onOutput) onOutput(text); return { message_id: '_virtual' }; },
+    sendTyping: async () => { },
+    editMessage: async () => { },
+    deleteMessage: async () => { },
+    sendFile: noop,
+    downloadFile: noop,
+  };
+}
+
+/**
+ * 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) {
+  // Track edit-broken state independently so dispatch failures don't poison realBot's flag
+  let _editBroken = false;
+  return {
+    sendMessage: async (_, text) => {
+      log('INFO', `[StreamBot→${chatId.slice(-8)}] msg: ${String(text).slice(0, 80)}`);
+      return realBot.sendMessage(chatId, text);
+    },
+    sendMarkdown: async (_, text) => {
+      log('INFO', `[StreamBot→${chatId.slice(-8)}] md: ${String(text).slice(0, 80)}`);
+      return realBot.sendMarkdown(chatId, text);
+    },
+    sendCard: async (_, card) => {
+      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}`);
+      return realBot.sendCard(chatId, card);
+    },
+    sendRawCard: async (_, header, elements) => {
+      log('INFO', `[StreamBot→${chatId.slice(-8)}] rawcard: ${String(header).slice(0, 60)}`);
+      return realBot.sendRawCard(chatId, header, elements);
+    },
+    sendButtons: async (_, text, buttons) => realBot.sendButtons(chatId, text, buttons),
+    sendTyping: async () => realBot.sendTyping(chatId),
+    editMessage: async (_, msgId, text) => {
+      if (_editBroken) return false;
+      log('INFO', `[StreamBot→${chatId.slice(-8)}] edit ${String(msgId).slice(-8)}: ${String(text).slice(0, 60)}`);
+      try {
+        return await realBot.editMessage(chatId, msgId, text);
+      } catch (e) {
+        const code = e?.code || e?.response?.data?.code;
+        if (code === 230001 || code === 230002 || /permission|forbidden/i.test(String(e))) {
+          _editBroken = true;
+        }
+        return false;
+      }
+    },
+    deleteMessage: async (_, msgId) => realBot.deleteMessage(chatId, msgId),
+    sendFile: async (_, filePath, caption) => realBot.sendFile(chatId, filePath, caption),
+    downloadFile: async (...args) => realBot.downloadFile(...args),
   };
 }
 
@@ -564,8 +615,8 @@ function createNullBot(onOutput) {
  * @param {object} config - current daemon config
  * @returns {{ success: boolean, id?: string, error?: string }}
  */
-function dispatchTask(targetProject, message, config, replyFn) {
-  const LIMITS = { max_per_hour_per_target: 5, max_total_per_hour: 20, max_depth: 2 };
+function dispatchTask(targetProject, message, config, replyFn, streamOptions = null) {
+  const LIMITS = { max_per_hour_per_target: 20, max_total_per_hour: 60, max_depth: 2 };
 
   // Anti-storm: check chain depth
   const chain = message.chain || [];
@@ -638,22 +689,22 @@ function dispatchTask(targetProject, message, config, replyFn) {
   }
 
   // Inject ack-first instruction for all dispatched tasks
-  prompt = `[行为要求：收到此任务后，请先用 dispatch_to 回复一条消息说明「收到，计划：xxx」，再开始执行。]\n\n${prompt}`;
+  // Note: do NOT require dispatch_to (Bash) here — dispatched tasks run readOnly=true, Bash is blocked.
+  // Daemon sends the ack autonomously; Claude should just state its plan in the reply text.
+  prompt = `[行为要求：回复开头用1-2句「计划：xxx」说明执行方案，再开始执行。不要调用 dispatch_to，daemon 会自动转发你的回复。]\n\n${prompt}`;
 
   // Prefer target's real Feishu chatId so dispatch reuses the existing session
   // (--resume, no CLAUDE.md re-read, no token waste). Fall back to _agent_* virtual
-  // chatId only if: target has no Feishu chat configured, OR caller requested new_session.
-  const feishuChatMap = (config.feishu && config.feishu.chat_agent_map) || {};
-  const realChatId = Object.entries(feishuChatMap).find(([, v]) => v === targetProject)?.[0];
+  // All dispatches use _agent_* virtual chatId to ensure a clean session with
+  // the correct project context. Real Feishu chatIds are only for direct user messages.
   const forceNew = !!fullMsg.new_session;
-  const dispatchChatId = (!forceNew && realChatId) ? realChatId : `_agent_${targetProject}`;
-  const sessionMode = forceNew ? 'fresh session (forced)' : realChatId ? 'existing session' : 'fresh session';
+  const dispatchChatId = `_agent_${targetProject}`;
+  const sessionMode = forceNew ? 'fresh session (forced)' : 'existing virtual session';
   log('INFO', `Dispatching ${fullMsg.type} to ${targetProject} via ${sessionMode}: ${rawPrompt.slice(0, 80)}`);
 
-  const nullBot = createNullBot((output) => {
+  const outputHandler = (output) => {
     const outStr = typeof output === 'object' ? (output.body || JSON.stringify(output)) : String(output);
     log('INFO', `Dispatch output from ${targetProject}: ${outStr.slice(0, 200)}`);
-    // Forward meaningful output back to the requester (skip typing indicators)
     if (replyFn && outStr.trim().length > 2) {
       replyFn(outStr);
     } else if (!replyFn && fullMsg.callback && fullMsg.from && config) {
@@ -669,19 +720,163 @@ function dispatchTask(targetProject, message, config, replyFn) {
         chain: [], // reset chain for callbacks
       }, config);
     }
-  });
-  // readOnly=true: dispatched agents must not write/edit files on behalf of other agents
-  _handleCommand(nullBot, dispatchChatId, prompt, config, null, null, true).catch(e => {
+  };
+  // 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)
+    : 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).
+  // When forceNew=true, clear any cached session for this virtual chatId so
+  // attachOrCreateSession in handleCommand actually creates a fresh Claude session.
+  if (forceNew) {
+    const st = loadState();
+    if (st.sessions && st.sessions[dispatchChatId]) {
+      delete st.sessions[dispatchChatId];
+      saveState(st);
+    }
+  }
+  const dispatchReadOnly = !(config.daemon && config.daemon.dangerously_skip_permissions);
+  _handleCommand(nullBot, dispatchChatId, prompt, config, null, null, dispatchReadOnly).catch(e => {
     log('ERROR', `Dispatch handleCommand failed for ${targetProject}: ${e.message}`);
   });
 
   return { success: true, id: fullMsg.id };
 }
 
+/**
+ * Spawn memory-extract.js as a detached background process.
+ * Called on sleep mode entry to consolidate session facts.
+ */
+/**
+ * Spawn session-summarize.js for sessions that have been idle 2-24 hours.
+ * Called on sleep mode entry. Skips sessions that already have a fresh summary.
+ */
+function spawnSessionSummaries() {
+  const scriptPath = path.join(__dirname, 'session-summarize.js');
+  if (!fs.existsSync(scriptPath)) return;
+  const state = loadState();
+  const now = Date.now();
+  const TWO_HOURS = 2 * 60 * 60 * 1000;
+  const SEVEN_DAYS = 7 * 24 * 60 * 60 * 1000;
+  for (const [cid, sess] of Object.entries(state.sessions || {})) {
+    if (!sess.id || !sess.started) continue;
+    const lastActive = sess.last_active || 0;
+    const idleMs = now - lastActive;
+    if (idleMs < TWO_HOURS || idleMs > SEVEN_DAYS) continue;
+    // Skip if summary is already newer than last activity
+    if ((sess.last_summary_at || 0) > lastActive) continue;
+    try {
+      const child = spawn(process.execPath, [scriptPath, cid, sess.id], {
+        detached: true, stdio: 'ignore',
+      });
+      child.unref();
+      log('INFO', `[DAEMON] Session summary spawned for ${cid} (idle ${Math.round(idleMs / 3600000)}h)`);
+    } catch (e) {
+      log('WARN', `[DAEMON] Failed to spawn session summary: ${e.message}`);
+    }
+  }
+}
+
 /**
  * Physiological heartbeat: zero-token awareness check.
  * Runs every tick unconditionally.
  */
+/**
+ * Handle a single dispatch message (from socket or pending.jsonl fallback).
+ */
+function handleDispatchItem(item, config) {
+  if (!item.target || !item.prompt) return;
+  if (!(config && config.projects && config.projects[item.target])) {
+    log('WARN', `dispatch: unknown target "${item.target}"`);
+    return;
+  }
+  log('INFO', `Dispatch: ${item.from || '?'} → ${item.target}: ${item.prompt.slice(0, 60)}`);
+  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) || [];
+    const agentChatIds = new Set(Object.keys(feishuMap));
+    const targetChatId = Object.entries(feishuMap).find(([, v]) => v === item.target)?.[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)) {
+        senderChatId = Object.entries(feishuMap).find(([, v]) => v === item.from)?.[0] || null;
+      }
+      if (!senderChatId) {
+        senderChatId = allowedFeishuIds.map(String).find(id => !agentChatIds.has(id)) || null;
+      }
+      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}`)
+          )
+        );
+        pendingReplyFn = (output) => {
+          const text = `${targetProj.icon || '📬'} **${targetProj.name || item.target}** 回复：\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 =>
+              log('ERROR', `Dispatch reply (text) failed: ${e2.message}`)
+            );
+          });
+        };
+      }
+    }
+  }
+  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, pendingReplyFn, streamOptions);
+}
+
+/**
+ * Start Unix Domain Socket server for low-latency dispatch.
+ */
+function startDispatchSocket(config) {
+  const net = require('net');
+  try { fs.unlinkSync(SOCK_PATH); } catch { /* ok */ }
+  const server = net.createServer((conn) => {
+    let buf = '';
+    conn.on('data', d => { buf += d; });
+    conn.on('end', () => {
+      try {
+        const item = JSON.parse(buf);
+        handleDispatchItem(item, config);
+        conn.write(JSON.stringify({ ok: true }) + '\n');
+      } catch (e) {
+        try { conn.write(JSON.stringify({ ok: false, error: e.message }) + '\n'); } catch { /* ignore */ }
+      }
+    });
+    conn.on('error', () => { /* ignore client disconnect */ });
+  });
+  server.on('error', (e) => {
+    log('WARN', `[DAEMON] Dispatch socket error: ${e.message} — file polling still active`);
+  });
+  server.listen(SOCK_PATH, () => {
+    log('INFO', `[DAEMON] Dispatch socket ready: ${SOCK_PATH}`);
+  });
+  return server;
+}
+
 function physiologicalHeartbeat(config) {
   // 1. Update last_alive timestamp
   const state = loadState();
@@ -702,38 +897,7 @@ function physiologicalHeartbeat(config) {
         const items = content.split('\n').filter(Boolean)
           .map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
         for (const item of items) {
-          if (!item.target || !item.prompt) continue;
-          if (!(config && config.projects && config.projects[item.target])) {
-            log('WARN', `pending dispatch: unknown target "${item.target}"`);
-            continue;
-          }
-          log('INFO', `Pending dispatch: ${item.from || '?'} → ${item.target}: ${item.prompt.slice(0, 60)}`);
-          // Build replyFn: use live bot from bridge ref (always fresh, survives reconnects)
-          let pendingReplyFn = null;
-          const liveBot = _dispatchBridgeRef && _dispatchBridgeRef.bot;
-          if (liveBot) {
-            const feishuMap = (config.feishu && config.feishu.chat_agent_map) || {};
-            const targetChatId = Object.entries(feishuMap).find(([, v]) => v === item.target)?.[0];
-            if (targetChatId) {
-              const proj = (config.projects || {})[item.target] || {};
-              pendingReplyFn = (output) => {
-                const text = `${proj.icon || '📬'} **${proj.name || item.target}**\n\n${output.slice(0, 2000)}`;
-                liveBot.sendMarkdown(targetChatId, text).catch(e => {
-                  log('WARN', `Dispatch reply to ${item.target} (markdown) failed: ${e.message}`);
-                  liveBot.sendMessage(targetChatId, text).catch(e2 => {
-                    log('ERROR', `Dispatch reply to ${item.target} (text) failed: ${e2.message}`);
-                  });
-                });
-              };
-            }
-          }
-          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, pendingReplyFn);
+          handleDispatchItem(item, config);
         }
       }
     }
@@ -760,19 +924,41 @@ function physiologicalHeartbeat(config) {
 }
 
 // ---------------------------------------------------------
-// HEARTBEAT SCHEDULER
+// HEARTBEAT TASK HELPERS (single source of truth)
 // ---------------------------------------------------------
-function startHeartbeat(config, notifyFn) {
-  const legacyTasks = (config.heartbeat && config.heartbeat.tasks) || [];
-  const projectTasks = [];
-  const legacyNames = new Set(legacyTasks.map(t => t.name));
-  for (const [key, proj] of Object.entries(config.projects || {})) {
+
+/**
+ * Collect all heartbeat tasks from config (general + per-project).
+ * Each project task gets _project metadata attached.
+ * Returns { general: [...], project: [...], all: [...] }
+ */
+function getAllTasks(cfg) {
+  const general = (cfg.heartbeat && cfg.heartbeat.tasks) || [];
+  const project = [];
+  const generalNames = new Set(general.map(t => t.name));
+  for (const [key, proj] of Object.entries(cfg.projects || {})) {
     for (const t of (proj.heartbeat_tasks || [])) {
-      if (legacyNames.has(t.name)) log('WARN', `Duplicate task name "${t.name}" in project "${key}" and legacy heartbeat — will run twice`);
-      projectTasks.push({ ...t, _project: { key, name: proj.name || key, color: proj.color || 'blue', icon: proj.icon || '🤖' } });
+      if (generalNames.has(t.name)) log('WARN', `Duplicate task name "${t.name}" in project "${key}" and general heartbeat`);
+      project.push({ ...t, _project: { key, name: proj.name || key, color: proj.color || 'blue', icon: proj.icon || '🤖' } });
     }
   }
-  const tasks = [...legacyTasks, ...projectTasks];
+  return { general, project, all: [...general, ...project] };
+}
+
+/**
+ * Find a task by name across all groups.
+ */
+function findTask(cfg, name) {
+  const { general, project } = getAllTasks(cfg);
+  const found = general.find(t => t.name === name) || project.find(t => t.name === name);
+  return found || null;
+}
+
+// ---------------------------------------------------------
+// HEARTBEAT SCHEDULER
+// ---------------------------------------------------------
+function startHeartbeat(config, notifyFn) {
+  const { all: tasks } = getAllTasks(config);
 
   const enabledTasks = tasks.filter(t => t.enabled !== false);
   const checkIntervalSec = (config.daemon && config.daemon.heartbeat_check_interval) || 60;
@@ -807,6 +993,18 @@ function startHeartbeat(config, notifyFn) {
     // ① Physiological heartbeat (zero token, pure awareness)
     physiologicalHeartbeat(config);
 
+    // Sleep mode detection — log transitions once
+    const idle = isUserIdle();
+    if (idle && !_inSleepMode) {
+      _inSleepMode = true;
+      log('INFO', '[DAEMON] Entering Sleep Mode');
+      // Generate summaries for sessions idle 2-24h
+      spawnSessionSummaries();
+    } else if (!idle && _inSleepMode) {
+      _inSleepMode = false;
+      log('INFO', '[DAEMON] Exiting Sleep Mode — local activity detected');
+    }
+
     // ② Task heartbeat (burns tokens on schedule)
     const currentTime = Date.now();
     for (const task of enabledTasks) {
@@ -814,6 +1012,12 @@ function startHeartbeat(config, notifyFn) {
         const intervalSec = parseInterval(task.interval);
         nextRun[task.name] = currentTime + intervalSec * 1000;
 
+        // Dream tasks: only run when user is idle
+        if (task.require_idle && !isUserIdle()) {
+          log('INFO', `[DAEMON] Deferring dream task "${task.name}" — user active`);
+          continue;
+        }
+
         if (runningTasks.has(task.name)) {
           log('WARN', `Task ${task.name} still running — skipping this interval`);
           continue;
@@ -1348,6 +1552,7 @@ async function doBindAgent(bot, chatId, agentName, agentCwd) {
 }
 
 async function handleCommand(bot, chatId, text, config, executeTaskByName, senderId = null, readOnly = false) {
+  if (text && !text.startsWith('/chatid') && !text.startsWith('/myid')) log('INFO', `CMD [${String(chatId).slice(-8)}]: ${text.slice(0, 80)}`);
   const state = loadState();
 
   // --- /chatid: reply with current chatId ---
@@ -1522,6 +1727,56 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     return;
   }
 
+  // /memory [keyword] — show memory stats or search facts
+  if (text === '/memory' || text.startsWith('/memory ')) {
+    const query = text.startsWith('/memory ') ? text.slice(8).trim() : '';
+    let memMod;
+    try { memMod = require('./memory'); } catch { await bot.sendMessage(chatId, '❌ Memory module not available'); return; }
+
+    if (!query) {
+      // Stats view
+      try {
+        const s = memMod.stats();
+        const factCount = s.facts ?? '?';
+        const tagFile = path.join(HOME, '.metame', 'session_tags.json');
+        let tagCount = 0;
+        try { tagCount = Object.keys(JSON.parse(fs.readFileSync(tagFile, 'utf8'))).length; } catch { }
+        const lines = [
+          `🧠 *Memory Stats*`,
+          `━━━━━━━━━━━━━━━━`,
+          `📌 Facts: ${factCount}`,
+          `🏷 Sessions tagged: ${tagCount}`,
+          `🗃 Sessions in DB: ${s.count}`,
+          `💾 DB size: ${s.dbSizeKB} KB`,
+          s.newestDate ? `🕐 Last updated: ${new Date(s.newestDate).toLocaleDateString()}` : '',
+          ``,
+          `搜索: /memory <关键词>`,
+        ].filter(l => l !== undefined && !(l === '' && false));
+        await bot.sendMessage(chatId, lines.join('\n'));
+      } catch (e) {
+        await bot.sendMessage(chatId, `❌ Memory stats error: ${e.message}`);
+      }
+    } else {
+      // Search facts
+      try {
+        const results = await memMod.searchFactsAsync(query, { limit: 5 });
+        if (!results || results.length === 0) {
+          await bot.sendMessage(chatId, `🔍 No facts found for「${query}」`);
+          return;
+        }
+        let msg = `🔍 *Facts: "${query}"* (${results.length})\n━━━━━━━━━━━━━━━━\n`;
+        for (const r of results) {
+          const tag = r.confidence === 'high' ? '🟢' : '🟡';
+          msg += `${tag} *${r.entity}*\n${r.value}\n\n`;
+        }
+        await bot.sendMessage(chatId, msg.trim());
+      } catch (e) {
+        await bot.sendMessage(chatId, `❌ Search error: ${e.message}`);
+      }
+    }
+    return;
+  }
+
   // /sessions — compact list, tap to see details, then tap to switch
   if (text === '/sessions') {
     const allSessions = listRecentSessions(15);
@@ -1530,11 +1785,12 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       return;
     }
     if (bot.sendButtons) {
-      await bot.sendCard(chatId, '📋 Recent Sessions', buildSessionCardElements(allSessions));
+      await bot.sendRawCard(chatId, '📋 Recent Sessions', buildSessionCardElements(allSessions));
     } else {
+      const _tags1 = loadSessionTags();
       let msg = '📋 Recent sessions:\n\n';
       allSessions.forEach((s, i) => {
-        msg += sessionRichLabel(s, i + 1) + '\n';
+        msg += sessionRichLabel(s, i + 1, _tags1) + '\n';
       });
       await bot.sendMessage(chatId, msg);
     }
@@ -1555,7 +1811,11 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     const realMtime = getSessionFileMtime(s.sessionId, s.projectPath);
     const timeMs = realMtime || s.fileMtime || new Date(s.modified).getTime();
     const ago = formatRelativeTime(new Date(timeMs).toISOString());
-    const title = s.customTitle || '';
+    const sessionTags = loadSessionTags();
+    const tagEntry = sessionTags[s.sessionId] || {};
+    const tagName = tagEntry.name || '';
+    const tags = (tagEntry.tags || []).slice(0, 5);
+    const title = s.customTitle || tagName || '';
     const summary = s.summary || '';
     const firstMsg = (s.firstPrompt || '').replace(/^<[^>]+>.*?<\/[^>]+>\s*/s, '');
     const msgs = s.messageCount || '?';
@@ -1563,6 +1823,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     let detail = `📋 Session Detail\n`;
     detail += `━━━━━━━━━━━━━━━━━━━━\n`;
     if (title) detail += `📝 Title: ${title}\n`;
+    if (tags.length) detail += `🏷 Tags: ${tags.map(t => '#' + t).join(' ')}\n`;
     if (summary) detail += `💡 Summary: ${summary}\n`;
     detail += `📁 Project: ${projName}\n`;
     detail += `📂 Path: ${proj}\n`;
@@ -1575,6 +1836,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       // Build rich detail as markdown body + buttons
       let body = '';
       if (title) body += `**📝 ${title}**\n`;
+      if (tags.length) body += `${tags.map(t => `\`${t}\``).join(' ')}\n`;
       if (summary) body += `💡 ${summary}\n`;
       body += `📁 ${projName} · 📂 ${proj}\n`;
       body += `💬 ${msgs} messages · 🕐 ${ago}\n`;
@@ -1583,12 +1845,14 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       const elements = [
         { tag: 'div', text: { tag: 'lark_md', content: body } },
         { tag: 'hr' },
-        { tag: 'action', actions: [
-          { tag: 'button', text: { tag: 'plain_text', content: '▶️ Switch to this session' }, type: 'primary', value: { cmd: `/resume ${s.sessionId}` } },
-          { tag: 'button', text: { tag: 'plain_text', content: '⬅️ Back to list' }, type: 'default', value: { cmd: '/sessions' } },
-        ] },
+        {
+          tag: 'action', actions: [
+            { tag: 'button', text: { tag: 'plain_text', content: '▶️ Switch to this session' }, type: 'primary', value: { cmd: `/resume ${s.sessionId}` } },
+            { tag: 'button', text: { tag: 'plain_text', content: '⬅️ Back to list' }, type: 'default', value: { cmd: '/sessions' } },
+          ]
+        },
       ];
-      await bot.sendCard(chatId, '📋 Session Detail', elements);
+      await bot.sendRawCard(chatId, '📋 Session Detail', elements);
     } else if (bot.sendButtons) {
       await bot.sendButtons(chatId, detail, [
         [{ text: '▶️ Switch to this session', callback_data: `/resume ${s.sessionId}` }],
@@ -1614,17 +1878,18 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
         return;
       }
       const headerTitle = curCwd ? `📋 Sessions in ${path.basename(curCwd)}` : '📋 Recent Sessions';
-      if (bot.sendCard) {
-        await bot.sendCard(chatId, headerTitle, buildSessionCardElements(recentSessions));
+      if (bot.sendRawCard) {
+        await bot.sendRawCard(chatId, headerTitle, buildSessionCardElements(recentSessions));
       } else if (bot.sendButtons) {
         const buttons = recentSessions.map(s => {
           return [{ text: sessionLabel(s), callback_data: `/resume ${s.sessionId}` }];
         });
         await bot.sendButtons(chatId, headerTitle, buttons);
       } else {
+        const _tags2 = loadSessionTags();
         let msg = `${title}\n\n`;
         recentSessions.forEach((s, i) => {
-          msg += sessionRichLabel(s, i + 1) + '\n';
+          msg += sessionRichLabel(s, i + 1, _tags2) + '\n';
         });
         await bot.sendMessage(chatId, msg);
       }
@@ -2030,22 +2295,25 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
   }
 
   if (text === '/tasks') {
+    const { general, project } = getAllTasks(config);
     let msg = '';
-    // Legacy flat tasks
-    const legacyTasks = (config.heartbeat && config.heartbeat.tasks) || [];
-    if (legacyTasks.length > 0) {
+    if (general.length > 0) {
       msg += '📋 General:\n';
-      for (const t of legacyTasks) {
+      for (const t of general) {
         const ts = state.tasks[t.name] || {};
         msg += `${t.enabled !== false ? '✅' : '⏸'} ${t.name} (${t.interval}) ${ts.status || 'never_run'}\n`;
       }
     }
-    // Project tasks grouped
-    for (const [, proj] of Object.entries(config.projects || {})) {
-      const pTasks = proj.heartbeat_tasks || [];
-      if (pTasks.length === 0) continue;
-      msg += `\n${proj.icon || '🤖'} ${proj.name || proj}:\n`;
-      for (const t of pTasks) {
+    // Project tasks grouped by _project
+    const byProject = new Map();
+    for (const t of project) {
+      const pk = t._project.key;
+      if (!byProject.has(pk)) byProject.set(pk, { proj: t._project, tasks: [] });
+      byProject.get(pk).tasks.push(t);
+    }
+    for (const [, { proj, tasks }] of byProject) {
+      msg += `\n${proj.icon} ${proj.name}:\n`;
+      for (const t of tasks) {
         const ts = state.tasks[t.name] || {};
         msg += `${t.enabled !== false ? '✅' : '⏸'} ${t.name} (${t.interval}) ${ts.status || 'never_run'}\n`;
       }
@@ -2124,16 +2392,15 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       const projInfo = config.projects[targetKey] || {};
       // Find the target project's own Feishu chat (reverse lookup of chat_agent_map)
       const feishuChatAgentMap = (config.feishu && config.feishu.chat_agent_map) || {};
-      const targetChatId = Object.entries(feishuChatAgentMap).find(([, v]) => v === targetKey)?.[0] || chatId;
-      const replyFn = (output) => {
-        // Send target agent's reply into the target project's own Feishu chat
+      const targetChatId = Object.entries(feishuChatAgentMap).find(([, v]) => v === targetKey)?.[0] || null;
+      // Stream work directly to target's channel if available; otherwise fallback replyFn
+      const dispatchStreamOptions = targetChatId ? { bot, chatId: targetChatId } : null;
+      const replyFn = targetChatId ? null : (output) => {
         const text = `${projInfo.icon || '📬'} **${projInfo.name || targetKey}**\n\n${output.slice(0, 2000)}`;
-        bot.sendMarkdown(targetChatId, text)
-          .then(() => log('INFO', `Dispatch reply sent to ${targetChatId}`))
+        bot.sendMarkdown(chatId, text)
           .catch(e => {
             log('WARN', `Dispatch sendMarkdown failed: ${e.message}, trying sendMessage`);
-            bot.sendMessage(targetChatId, text)
-              .catch(e2 => log('ERROR', `Dispatch reply failed: ${e2.message}`));
+            bot.sendMessage(chatId, text).catch(e2 => log('ERROR', `Dispatch reply failed: ${e2.message}`));
           });
       };
 
@@ -2143,7 +2410,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
         priority: 'normal',
         payload: { title: prompt.slice(0, 60), prompt },
         callback: false,
-      }, config, replyFn);
+      }, config, replyFn, dispatchStreamOptions);
 
       if (result.success) {
         await bot.sendMessage(chatId, `✅ 已派发给 ${projInfo.name || targetName}，执行中…`);
@@ -2165,13 +2432,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       return;
     }
     const taskName = text.slice(5).trim();
-    const allRunTasks = [...(config.heartbeat && config.heartbeat.tasks || [])];
-    for (const [key, proj] of Object.entries(config.projects || {})) {
-      for (const t of (proj.heartbeat_tasks || [])) {
-        allRunTasks.push({ ...t, _project: { key, name: proj.name || key, color: proj.color || 'blue', icon: proj.icon || '🤖' } });
-      }
-    }
-    const task = allRunTasks.find(t => t.name === taskName);
+    const task = findTask(config, taskName);
     if (!task) { await bot.sendMessage(chatId, `❌ Task "${taskName}" not found`); return; }
 
     // Script tasks: quick, run inline
@@ -2438,7 +2699,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     }
 
     const session = getSession(chatId);
-    if (!session || !session.id || !session.cwd) {
+    if (!session || !session.id) {
       await bot.sendMessage(chatId, 'No active session to undo.');
       return;
     }
@@ -2446,107 +2707,190 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     const cwd = session.cwd;
     const arg = text.slice(5).trim();
 
-    // Git-based undo: list checkpoints or reset to one
-    // First check if cwd is even a git repo
-    let isGitRepo = false;
-    try { execSync('git rev-parse --is-inside-work-tree', { cwd, stdio: 'ignore', timeout: 3000 }); isGitRepo = true; } catch { }
-    const checkpoints = isGitRepo ? listCheckpoints(cwd) : [];
-    if (!isGitRepo) {
-      await bot.sendMessage(chatId, `⚠️ 当前项目不在 git 仓库中，无法使用 /undo\n📁 ${cwd}\n\n切换到 git 项目后重试（/agent bind 或 /cd 切换目录）`);
-      return;
-    }
-    if (checkpoints.length === 0) {
-      await bot.sendMessage(chatId, `⚠️ 还没有回退点\n📁 ${path.basename(cwd)}\n\nCheckpoint 在 Claude 修改文件前自动创建，先让 Claude 做点改动再试`);
+    // /undo <hash> — git reset to specific checkpoint (advanced usage)
+    if (arg) {
+      if (!cwd) {
+        await bot.sendMessage(chatId, '❌ 当前 session 无工作目录，无法执行 git undo');
+        return;
+      }
+      let isGitRepo = false;
+      try { execSync('git rev-parse --is-inside-work-tree', { cwd, stdio: 'ignore', timeout: 3000 }); isGitRepo = true; } catch { }
+      const checkpoints = isGitRepo ? listCheckpoints(cwd) : [];
+      const match = checkpoints.find(cp => cp.hash.startsWith(arg));
+      if (!match) {
+        await bot.sendMessage(chatId, `❌ 未找到 checkpoint: ${arg}`);
+        return;
+      }
+      try {
+        let diffFiles = '';
+        try { diffFiles = execSync(`git diff --name-only HEAD ${match.hash}`, { cwd, encoding: 'utf8', timeout: 5000 }).trim(); } catch { }
+        execSync(`git reset --hard ${match.hash}`, { cwd, stdio: 'ignore', timeout: 10000 });
+        // Truncate context to checkpoint time (covers multi-turn rollback)
+        truncateSessionToCheckpoint(session.id, match.message);
+        const fileList = diffFiles ? diffFiles.split('\n').map(f => path.basename(f)).join(', ') : '';
+        const fileCount = diffFiles ? diffFiles.split('\n').length : 0;
+        let msg = `⏪ 已回退到 ${cpDisplayLabel(match.message)}`;
+        if (fileCount > 0) msg += `\n📁 ${fileCount} 个文件恢复: ${fileList}`;
+        log('INFO', `/undo <hash> executed for ${chatId}: reset to ${match.hash.slice(0, 8)}, files=${fileCount}`);
+        await bot.sendMessage(chatId, msg);
+        cleanupCheckpoints(cwd);
+      } catch (e) {
+        await bot.sendMessage(chatId, `❌ Undo failed: ${e.message}`);
+      }
       return;
     }
 
-    if (!arg) {
-      // /undo (no arg) — show recent checkpoints to pick from
-      const recent = checkpoints.slice(0, 6); // newest first (already sorted)
+    // /undo (no arg) — show recent user messages as buttons to pick rollback point
+    try {
+      const sessionFile = findSessionFile(session.id);
+      if (!sessionFile) {
+        await bot.sendMessage(chatId, '⚠️ 找不到 session 文件，无法列出历史消息');
+        return;
+      }
+      const lines = fs.readFileSync(sessionFile, 'utf8').split('\n').filter(l => l.trim());
+
+      // Helper: extract real user text (skip tool_result entries and system annotations)
+      const extractUserText = (obj) => {
+        try {
+          const content = obj.message?.content;
+          if (typeof content === 'string') return content.trim();
+          if (Array.isArray(content)) {
+            // Skip entries that are purely tool results
+            if (content.every(c => c.type === 'tool_result')) return '';
+            // Find first text item that isn't a system annotation (exact patterns only)
+            const SYSTEM_ANNOTATION = /^\[(Image source|Pasted|Attachment|File):/;
+            const item = content.find(c => c.type === 'text' && c.text && !SYSTEM_ANNOTATION.test(c.text));
+            return item?.text?.trim() || '';
+          }
+        } catch { }
+        return '';
+      };
+
+      // Collect only real human-written user messages (skip tool results / annotations)
+      const userMsgs = [];
+      for (let i = 0; i < lines.length; i++) {
+        try {
+          const obj = JSON.parse(lines[i]);
+          if (obj.type === 'user' && obj.message?.role === 'user') {
+            const text = extractUserText(obj);
+            if (text) userMsgs.push({ idx: i, obj, text });
+          }
+        } catch { }
+      }
+      if (userMsgs.length === 0) {
+        await bot.sendMessage(chatId, '⚠️ 没有可回退的历史消息');
+        return;
+      }
+
+      // Show last 10 (most recent first)
+      const recent = userMsgs.slice(-10).reverse();
       if (bot.sendButtons) {
-        const buttons = recent.map((cp) => {
-          const label = cpDisplayLabel(cp.message);
-          return [{ text: `⏪ ${label}`, callback_data: `/undo ${cp.hash.slice(0, 10)}` }];
+        const buttons = recent.map(({ idx, text, obj }) => {
+          const msgText = text.replace(/\n/g, ' ').slice(0, 28);
+          let timeLabel = '';
+          if (obj.timestamp) {
+            const d = new Date(obj.timestamp);
+            if (!isNaN(d)) timeLabel = ` (${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')})`;
+          }
+          return [{ text: `⏪ ${msgText}${timeLabel}`, callback_data: `/undo_to ${idx}` }];
         });
-        await bot.sendButtons(chatId, `📌 ${checkpoints.length} 个回退点 (git checkpoint):`, buttons);
+        await bot.sendButtons(chatId, `↩️ 回退到哪条消息之前？(共 ${userMsgs.length} 轮)`, buttons);
       } else {
-        let msg = '回退到哪个点？回复 /undo <hash>\n\n';
-        recent.forEach(cp => {
-          msg += `${cp.hash.slice(0, 8)} ${cpDisplayLabel(cp.message)}\n`;
+        let msg = '回退到哪条消息之前？回复 /undo_to <序号>\n\n';
+        recent.forEach(({ idx, text }) => {
+          msg += `[${idx}] ${text.slice(0, 40)}\n`;
         });
         await bot.sendMessage(chatId, msg);
       }
+    } catch (e) {
+      await bot.sendMessage(chatId, `❌ Undo failed: ${e.message}`);
+    }
+    return;
+  }
+
+  // /undo_to <lineIdx> — restore session to before the message at given JSONL line index
+  if (text.startsWith('/undo_to ')) {
+    const idx = parseInt(text.slice(9).trim(), 10);
+    if (isNaN(idx) || idx < 0) {
+      await bot.sendMessage(chatId, '❌ 无效的回退序号');
+      return;
+    }
+
+    // Kill any running task
+    if (messageQueue.has(chatId)) {
+      const q = messageQueue.get(chatId);
+      if (q.timer) clearTimeout(q.timer);
+      messageQueue.delete(chatId);
+    }
+    const proc2 = activeProcesses.get(chatId);
+    if (proc2 && proc2.child) {
+      proc2.aborted = true;
+      try { process.kill(-proc2.child.pid, 'SIGINT'); } catch { proc2.child.kill('SIGINT'); }
+    }
+
+    const session2 = getSession(chatId);
+    if (!session2 || !session2.id) {
+      await bot.sendMessage(chatId, 'No active session.');
       return;
     }
 
-    // /undo <hash> — execute git reset
     try {
-      // Verify the hash exists and is a checkpoint
-      const match = checkpoints.find(cp => cp.hash.startsWith(arg));
-      if (!match) {
-        await bot.sendMessage(chatId, `❌ 未找到 checkpoint: ${arg}`);
+      const sessionFile2 = findSessionFile(session2.id);
+      if (!sessionFile2) { await bot.sendMessage(chatId, '❌ 找不到 session 文件'); return; }
+
+      const lines2 = fs.readFileSync(sessionFile2, 'utf8').split('\n').filter(l => l.trim());
+      if (idx >= lines2.length) {
+        await bot.sendMessage(chatId, '❌ 序号超出范围，session 已变化，请重新 /undo');
         return;
       }
 
-      // Get list of files that will change
-      let diffFiles = '';
+      // Get target message text + timestamp for display and git matching
+      let targetMsg = '', targetTs = 0;
       try {
-        diffFiles = execSync(`git diff --name-only HEAD ${match.hash}`, { cwd, encoding: 'utf8', timeout: 5000 }).trim();
-      } catch { /* ignore */ }
-
-      // Reset working tree to checkpoint
-      execSync(`git reset --hard ${match.hash}`, { cwd, stdio: 'ignore', timeout: 10000 });
+        const obj = JSON.parse(lines2[idx]);
+        const content = obj.message?.content;
+        if (typeof content === 'string') targetMsg = content;
+        else if (Array.isArray(content)) targetMsg = content.find(c => c.type === 'text')?.text || '';
+        if (obj.timestamp) targetTs = new Date(obj.timestamp).getTime() || 0;
+      } catch { }
 
-      // Also truncate JSONL session history (best-effort, non-fatal)
-      try {
-        const sessionFile = findSessionFile(session.id);
-        if (sessionFile) {
-          const fileContent = fs.readFileSync(sessionFile, 'utf8');
-          const lines = fileContent.split('\n').filter(l => l.trim());
-          // Find the last user message that was sent BEFORE this checkpoint
-          // Use the checkpoint timestamp from the commit message
-          const cpTs = cpExtractTimestamp(match.message);
-          const cpTime = new Date(cpTs).getTime();
-          if (cpTime) {
-            // Find the first user message AFTER checkpoint time → truncate before it
-            let cutIdx = -1;
-            for (let i = lines.length - 1; i >= 0; i--) {
-              try {
-                const obj = JSON.parse(lines[i]);
-                if (obj.type === 'user' && obj.timestamp) {
-                  const msgTime = new Date(obj.timestamp).getTime();
-                  if (msgTime && msgTime >= cpTime) {
-                    cutIdx = i;
-                  } else {
-                    break; // Found a message before checkpoint, stop
-                  }
-                }
-              } catch { }
-            }
-            if (cutIdx > 0) {
-              const kept = lines.slice(0, cutIdx);
-              fs.writeFileSync(sessionFile, kept.join('\n') + '\n', 'utf8');
-              log('INFO', `Truncated session at line ${cutIdx} (${lines.length - cutIdx} lines removed)`);
+      // Git reset first (before JSONL truncation) so failure leaves state consistent
+      let gitMsg2 = '';
+      const cwd2 = session2.cwd;
+      if (cwd2) {
+        let isGitRepo2 = false;
+        try { execSync('git rev-parse --is-inside-work-tree', { cwd: cwd2, stdio: 'ignore', timeout: 3000 }); isGitRepo2 = true; } catch { }
+        if (isGitRepo2) {
+          // Exclude safety checkpoints from matching to avoid confusion
+          const checkpoints2 = listCheckpoints(cwd2).filter(cp => !cp.message.includes('[metame-safety]'));
+          const cpMatch = targetTs
+            ? checkpoints2.find(cp => { const t = new Date(cpExtractTimestamp(cp.message) || 0).getTime(); return t > 0 && t <= targetTs; })
+            : checkpoints2[0];
+          if (cpMatch) {
+            let diffFiles2 = '';
+            try { diffFiles2 = execSync(`git diff --name-only HEAD ${cpMatch.hash}`, { cwd: cwd2, encoding: 'utf8', timeout: 5000 }).trim(); } catch { }
+            if (diffFiles2) {
+              // Save current state with distinct prefix (excluded from normal /undo list)
+              gitCheckpoint(cwd2, `[metame-safety] before rollback to: ${targetMsg.slice(0, 40)}`);
+              execSync(`git reset --hard ${cpMatch.hash}`, { cwd: cwd2, stdio: 'ignore', timeout: 10000 });
+              gitMsg2 = `\n📁 ${diffFiles2.split('\n').length} 个文件已恢复`;
+              cleanupCheckpoints(cwd2);
             }
           }
         }
-      } catch (truncErr) {
-        log('WARN', `Session truncation failed (non-fatal): ${truncErr.message}`);
       }
 
-      const fileList = diffFiles ? diffFiles.split('\n').map(f => path.basename(f)).join(', ') : '';
-      const fileCount = diffFiles ? diffFiles.split('\n').length : 0;
-      const label = cpDisplayLabel(match.message);
-      let msg = `⏪ 已回退\n📝 ${label}\n🔀 git reset --hard ${match.hash.slice(0, 8)}`;
-      if (fileCount > 0) {
-        msg += `\n📁 ${fileCount} 个文件恢复: ${fileList}`;
-      }
-      await bot.sendMessage(chatId, msg);
+      // Truncate JSONL after git reset succeeds
+      const kept2 = lines2.slice(0, idx);
+      fs.writeFileSync(sessionFile2, kept2.length ? kept2.join('\n') + '\n' : '', 'utf8');
+      _sessionFileCache.delete(session2.id);
+      const removed2 = lines2.length - kept2.length;
 
-      // Cleanup old checkpoints in background
-      cleanupCheckpoints(cwd);
+      const preview = targetMsg.replace(/\n/g, ' ').slice(0, 30) || `行 ${idx}`;
+      log('INFO', `/undo_to ${idx} for ${chatId}: removed=${removed2} lines${gitMsg2 ? ', ' + gitMsg2.trim() : ''}`);
+      await bot.sendMessage(chatId, `⏪ 已回退到「${preview}」之前\n🧠 上下文回滚 ${removed2} 行${gitMsg2}`);
     } catch (e) {
-      await bot.sendMessage(chatId, `❌ Undo failed: ${e.message}`);
+      await bot.sendMessage(chatId, `❌ 回退失败: ${e.message}`);
     }
     return;
   }
@@ -2778,10 +3122,12 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       '/cd <path> — 切换工作目录',
       '/session — 查看当前会话',
       '/stop — 中断当前任务 (ESC)',
-      '/undo — 回退上一轮操作 (ESC×2)',
+      '/undo — 选择历史消息，点击回退到该条之前',
+      '/undo <hash> — 回退到指定 git checkpoint',
       '/quit — 结束会话，重新加载 MCP/配置',
       '',
       `⚙️ /model [${currentModel}] /provider [${currentProvider}] /status /tasks /run /budget /reload`,
+      `🧠 /memory — 记忆统计 · /memory <关键词> — 搜索事实`,
       `🔧 /doctor /fix /reset /sh <cmd> /nosleep [${caffeinateProcess ? 'ON' : 'OFF'}]`,
       '',
       '直接打字即可对话 💬',
@@ -2878,6 +3224,80 @@ function findSessionFile(sessionId) {
   return null;
 }
 
+/**
+ * Truncate the last conversation turn (user message + assistant response) from a session JSONL.
+ * Finds the last {type:"user"} entry and removes it plus everything after.
+ * Returns the number of lines removed, or 0 if nothing was truncated.
+ */
+function truncateSessionLastTurn(sessionId) {
+  try {
+    const sessionFile = findSessionFile(sessionId);
+    if (!sessionFile) return 0;
+    const fileContent = fs.readFileSync(sessionFile, 'utf8');
+    const lines = fileContent.split('\n').filter(l => l.trim());
+    // Find the last user-type entry (walk backwards)
+    let cutIdx = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const obj = JSON.parse(lines[i]);
+        if (obj.type === 'user') { cutIdx = i; break; }
+      } catch { /* skip malformed lines */ }
+    }
+    if (cutIdx <= 0) return 0; // nothing to cut (keep at least line 0)
+    const kept = lines.slice(0, cutIdx);
+    fs.writeFileSync(sessionFile, kept.join('\n') + '\n', 'utf8');
+    // Invalidate cache so next findSessionFile call re-reads fresh
+    _sessionFileCache.delete(sessionId);
+    const removed = lines.length - kept.length;
+    log('INFO', `truncateSessionLastTurn: removed ${removed} lines from ${path.basename(sessionFile)}`);
+    return removed;
+  } catch (e) {
+    log('WARN', `truncateSessionLastTurn failed: ${e.message}`);
+    return 0;
+  }
+}
+
+/**
+ * Truncate session JSONL to the point before a given checkpoint (timestamp-based).
+ * Used for /undo <hash> to handle multi-turn rollback correctly.
+ * Falls back to truncateSessionLastTurn if timestamp parsing fails.
+ */
+function truncateSessionToCheckpoint(sessionId, checkpointMessage) {
+  try {
+    const cpTs = cpExtractTimestamp(checkpointMessage);
+    const cpTime = cpTs ? new Date(cpTs).getTime() : 0;
+    if (!cpTime) return truncateSessionLastTurn(sessionId);
+
+    const sessionFile = findSessionFile(sessionId);
+    if (!sessionFile) return 0;
+    const fileContent = fs.readFileSync(sessionFile, 'utf8');
+    const lines = fileContent.split('\n').filter(l => l.trim());
+
+    // Find the first user message at or after checkpoint time → cut there
+    let cutIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+      try {
+        const obj = JSON.parse(lines[i]);
+        if (obj.type === 'user' && obj.timestamp) {
+          const msgTime = new Date(obj.timestamp).getTime();
+          if (msgTime && msgTime >= cpTime) { cutIdx = i; break; }
+        }
+      } catch { /* skip malformed lines */ }
+    }
+    if (cutIdx <= 0) return truncateSessionLastTurn(sessionId); // fallback
+
+    const kept = lines.slice(0, cutIdx);
+    fs.writeFileSync(sessionFile, kept.join('\n') + '\n', 'utf8');
+    _sessionFileCache.delete(sessionId);
+    const removed = lines.length - kept.length;
+    log('INFO', `truncateSessionToCheckpoint: removed ${removed} lines from ${path.basename(sessionFile)}`);
+    return removed;
+  } catch (e) {
+    log('WARN', `truncateSessionToCheckpoint failed: ${e.message}`);
+    return truncateSessionLastTurn(sessionId); // fallback
+  }
+}
+
 /**
  * Scan all project session indexes, return most recent N sessions.
  * Results cached for 10 seconds to avoid repeated directory scans.
@@ -3014,6 +3434,13 @@ function listRecentSessions(limit, cwd) {
   return all.slice(0, limit || 10);
 }
 
+/** Load session_tags.json — returns {} if missing or malformed */
+function loadSessionTags() {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(HOME, '.metame', 'session_tags.json'), 'utf8'));
+  } catch { return {}; }
+}
+
 /**
  * Get the actual file mtime of a session's .jsonl file (most accurate)
  */
@@ -3062,7 +3489,7 @@ function sessionLabel(s) {
 /**
  * Get the display title for a session using fallback chain: name → summary → firstPrompt
  */
-function sessionDisplayTitle(s, maxLen) {
+function sessionDisplayTitle(s, maxLen, sessionTags) {
   maxLen = maxLen || 50;
   // Newlines → space; strip null bytes, surrogates, replacement char, other non-printable control chars
   const sanitize = (t) => t
@@ -3070,18 +3497,24 @@ function sessionDisplayTitle(s, maxLen) {
     .replace(/[\x00-\x09\x0B\x0C\x0E-\x1F\x7F\uFFFD\uD800-\uDFFF]/g, '')
     .replace(/\s+/g, ' ')
     .trim();
+  // Priority: user name > our P2-A name > user's first message > Claude native summary
+  // firstPrompt is authentic user content; s.summary is Claude's auto-generated index field (unreliable)
   if (s.customTitle) return sanitize(s.customTitle).slice(0, maxLen);
-  if (s.summary) return sanitize(s.summary).slice(0, maxLen);
+  // P2-A: use Haiku-generated session name (only if memory-extract has processed this session)
+  const tagEntry = sessionTags && sessionTags[s.sessionId];
+  if (tagEntry && tagEntry.name) return sanitize(tagEntry.name).slice(0, maxLen);
+  // Not yet processed by P2-A: show the user's actual first message
   if (s.firstPrompt) {
     const clean = s.firstPrompt
       .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
       .replace(/^<[^>]+>.*?<\/[^>]+>\s*/s, '')
       .replace(/\[System hints[\s\S]*/i, '');
-    // Take first non-empty line after stripping noise
     const firstLine = clean.split('\n').map(l => l.trim()).find(l => l.length > 2) || '';
     const sanitized = sanitize(firstLine);
     if (sanitized && sanitized.length > 2) return sanitized.slice(0, maxLen);
   }
+  // Last resort: Claude's native auto-summary from sessions-index.json
+  if (s.summary) return sanitize(s.summary).slice(0, maxLen);
   return '';
 }
 
@@ -3089,17 +3522,20 @@ function sessionDisplayTitle(s, maxLen) {
  * Format a session entry into a rich text block for non-button contexts (Feishu text).
  * Shows: name, title/summary, project, time, and /resume shortcut.
  */
-function sessionRichLabel(s, index) {
-  const title = sessionDisplayTitle(s, 50);
+function sessionRichLabel(s, index, sessionTags) {
+  sessionTags = sessionTags || loadSessionTags();
+  const title = sessionDisplayTitle(s, 50, sessionTags);
   const proj = s.projectPath ? path.basename(s.projectPath) : '~';
   const realMtime = getSessionFileMtime(s.sessionId, s.projectPath);
   const timeMs = realMtime || s.fileMtime || new Date(s.modified).getTime();
   const ago = formatRelativeTime(new Date(timeMs).toISOString());
   const shortId = s.sessionId.slice(0, 8);
+  const tags = (sessionTags[s.sessionId] && sessionTags[s.sessionId].tags || []).slice(0, 3);
 
   let line = `${index}. `;
   if (title) line += `${title}${title.length >= 50 ? '..' : ''}`;
   else line += `(unnamed)`;
+  if (tags.length) line += `  ${tags.map(t => `#${t}`).join(' ')}`;
   line += `\n   📁${proj} · ${ago}`;
   line += `\n   /resume ${shortId}`;
   return line;
@@ -3109,16 +3545,19 @@ function sessionRichLabel(s, index) {
  * Build Feishu card elements for a list of sessions (used by /sessions and /resume)
  */
 function buildSessionCardElements(sessions) {
+  const sessionTags = loadSessionTags();
   const elements = [];
   sessions.forEach((s, i) => {
     if (i > 0) elements.push({ tag: 'hr' });
-    const title = sessionDisplayTitle(s, 60);
+    const title = sessionDisplayTitle(s, 60, sessionTags);
     const proj = s.projectPath ? path.basename(s.projectPath) : '~';
     const realMtime = getSessionFileMtime(s.sessionId, s.projectPath);
     const timeMs = realMtime || s.fileMtime || new Date(s.modified).getTime();
     const ago = formatRelativeTime(new Date(timeMs).toISOString());
     const shortId = s.sessionId.slice(0, 6);
+    const tags = (sessionTags[s.sessionId] && sessionTags[s.sessionId].tags || []).slice(0, 4);
     let desc = `**${i + 1}. ${title || '(unnamed)'}**\n📁${proj} · ${ago}`;
+    if (tags.length) desc += `\n${tags.map(t => `\`${t}\``).join(' ')}`;
     elements.push({ tag: 'div', text: { tag: 'lark_md', content: desc } });
     elements.push({ tag: 'action', actions: [{ tag: 'button', text: { tag: 'plain_text', content: `▶️ Switch #${shortId}` }, type: 'primary', value: { cmd: `/resume ${s.sessionId}` } }] });
   });
@@ -3340,6 +3779,33 @@ const CONTENT_EXTENSIONS = new Set([
 // Active Claude processes per chat (for /stop)
 const activeProcesses = new Map(); // chatId -> { child, aborted }
 
+// Activity tracking for idle/sleep detection
+let lastInteractionTime = Date.now(); // updated on every incoming message
+let _inSleepMode = false;             // tracks current sleep state for log transitions
+
+const IDLE_THRESHOLD_MS = 30 * 60 * 1000; // 30 minutes
+const LOCAL_ACTIVE_FILE = path.join(METAME_DIR, 'local_active');
+
+/**
+ * Returns true when user has been inactive for >30min AND no sessions are running.
+ * Checks BOTH mobile adapter activity (Telegram/Feishu) AND the local_active heartbeat
+ * file (updated by Claude Code / index.js on each session start).
+ * Dream tasks (require_idle: true) only execute in this state.
+ */
+function isUserIdle() {
+  // Check mobile adapter activity (Telegram/Feishu)
+  if (Date.now() - lastInteractionTime <= IDLE_THRESHOLD_MS) return false;
+  // Check local desktop activity via ~/.metame/local_active mtime
+  try {
+    if (fs.existsSync(LOCAL_ACTIVE_FILE)) {
+      const mtime = fs.statSync(LOCAL_ACTIVE_FILE).mtimeMs;
+      if (Date.now() - mtime < IDLE_THRESHOLD_MS) return false;
+    }
+  } catch { /* ignore — treat as idle if file unreadable */ }
+  // Only idle if no active Claude sub-processes either
+  return activeProcesses.size === 0;
+}
+
 // Fix3: persist child PIDs so next daemon startup can kill orphans
 const ACTIVE_PIDS_FILE = path.join(HOME, '.metame', 'active_claude_pids.json');
 function saveActivePids() {
@@ -3736,24 +4202,6 @@ function trackMsgSession(messageId, session) {
   saveState(st);
 }
 
-function lazyDistill() {
-  const now = Date.now();
-  const st = loadState();
-  const lastDistillTime = st.last_distill_time || 0;
-  if (now - lastDistillTime < 4 * 60 * 60 * 1000) return; // 4h cooldown
-  const distillPath = path.join(HOME, '.metame', 'distill.js');
-  const signalsPath = path.join(HOME, '.metame', 'raw_signals.jsonl');
-  if (!fs.existsSync(distillPath)) return;
-  if (!fs.existsSync(signalsPath)) return;
-  const content = fs.readFileSync(signalsPath, 'utf8').trim();
-  if (!content) return;
-  st.last_distill_time = now;
-  saveState(st);
-  const lines = content.split('\n').filter(l => l.trim()).length;
-  log('INFO', `Distilling ${lines} signal(s) in background...`);
-  const bg = spawn('node', [distillPath], { detached: true, stdio: 'ignore' });
-  bg.unref();
-}
 
 /**
  * Shared ask logic — full Claude Code session (stateful, with tools)
@@ -3761,8 +4209,20 @@ function lazyDistill() {
  */
 async function askClaude(bot, chatId, prompt, config, readOnly = false) {
   log('INFO', `askClaude for ${chatId}: ${prompt.slice(0, 50)}`);
-  // Trigger background distill on first message / every 4h
-  try { lazyDistill(); } catch { /* non-fatal */ }
+  // Track interaction time for idle/sleep detection
+  lastInteractionTime = Date.now();
+  // Track per-session last_active for summary generation (P2-B)
+  try {
+    const _st = loadState();
+    if (_st.sessions && _st.sessions[chatId]) {
+      _st.sessions[chatId].last_active = Date.now();
+      saveState(_st);
+    }
+  } catch { /* non-critical */ }
+  if (_inSleepMode) {
+    _inSleepMode = false;
+    log('INFO', '[DAEMON] Exiting Sleep Mode — user active');
+  }
   // Send a single status message, updated in-place, deleted on completion
   let statusMsgId = null;
   try {
@@ -3864,6 +4324,42 @@ async function askClaude(bot, chatId, prompt, config, readOnly = false) {
     args.push('--session-id', session.id);
   }
 
+  // Memory & Knowledge Injection (RAG)
+  let memoryHint = '';
+  try {
+    const memory = require('./memory');
+    const _cid = String(chatId);
+    const _cfg = loadConfig();
+    const _agentMap = { ...(_cfg.telegram ? _cfg.telegram.chat_agent_map : {}), ...(_cfg.feishu ? _cfg.feishu.chat_agent_map : {}) };
+    const projectKey = _agentMap[_cid] || (_cid.startsWith('_agent_') ? _cid.slice(7) : null);
+
+    // 1. Inject recent session memories ONLY on first message of a session
+    if (!session.started) {
+      const recent = memory.recentSessions({ limit: 3, project: projectKey || undefined });
+      if (recent.length > 0) {
+        const items = recent.map(r => `- [${r.created_at}] ${r.summary}${r.keywords ? ' (keywords: ' + r.keywords + ')' : ''}`).join('\n');
+        memoryHint += `\n\n<!-- MEMORY:START -->\n[Session memory - recent context from past sessions, use to inform your responses:\n${items}]\n<!-- MEMORY:END -->`;
+      }
+    }
+
+    // 2. Dynamic Fact Injection (RAG) — first message only
+    // Facts stay in Claude's context for the rest of the session; no need to repeat.
+    // Uses QMD hybrid search if available, falls back to FTS5.
+    if (!session.started) {
+      const searchFn = memory.searchFactsAsync || memory.searchFacts;
+      const facts = await Promise.resolve(searchFn(prompt, { limit: 5, project: projectKey || undefined }));
+      if (facts.length > 0) {
+        const factItems = facts.map(f => `- [${f.relation}] ${f.value}`).join('\n');
+        memoryHint += `\n\n<!-- FACTS:START -->\n[Relevant knowledge and user preferences retrieved for this query. Follow these constraints implicitly:\n${factItems}]\n<!-- FACTS:END -->`;
+        log('INFO', `[MEMORY] Injected ${facts.length} facts based on prompt`);
+      }
+    }
+
+    memory.close();
+  } catch (e) {
+    if (e.code !== 'MODULE_NOT_FOUND') log('WARN', `Memory injection failed: ${e.message}`);
+  }
+
   // Inject daemon hints only on first message of a session
   const daemonHint = !session.started ? `\n\n[System hints - DO NOT mention these to user:
 1. Daemon config: The ONLY config is ~/.metame/daemon.yaml (never edit daemon-default.yaml). Auto-reloads on change.
@@ -3875,7 +4371,27 @@ async function askClaude(bot, chatId, prompt, config, readOnly = false) {
    - Multiple files: use multiple [[FILE:...]] tags]` : '';
 
   const routedPrompt = skill ? `/${skill} ${prompt}` : prompt;
-  const fullPrompt = routedPrompt + daemonHint;
+
+  // P2-B: inject session summary when resuming after a 2h+ gap
+  let summaryHint = '';
+  if (session.started) {
+    try {
+      const _stSum = loadState();
+      const _sess = _stSum.sessions && _stSum.sessions[chatId];
+      if (_sess && _sess.last_summary && _sess.last_summary_at) {
+        const _idleMs = Date.now() - (_sess.last_active || 0);
+        const _summaryAgeH = (Date.now() - _sess.last_summary_at) / 3600000;
+        if (_idleMs > 2 * 60 * 60 * 1000 && _summaryAgeH < 168) {
+          summaryHint = `
+
+[上次对话摘要，供参考]: ${_sess.last_summary}`;
+          log('INFO', `[DAEMON] Injected session summary for ${chatId} (idle ${Math.round(_idleMs / 3600000)}h)`);
+        }
+      }
+    } catch { /* non-critical */ }
+  }
+
+  const fullPrompt = routedPrompt + daemonHint + summaryHint + memoryHint;
 
   // Git checkpoint before Claude modifies files (for /undo)
   // Pass the user prompt as label so checkpoint list is human-readable
@@ -4248,6 +4764,29 @@ async function main() {
 
   log('INFO', `MetaMe daemon started (PID: ${process.pid})`);
   killOrphanPids(); // Fix3: kill any claude processes left by previous daemon
+
+  // Pre-initialize memory DB at startup so the file exists before any agent session needs it.
+  // This prevents Claude Code from showing a "new file" permission dialog mid-task on the desktop.
+  try {
+    const memMod = require('./memory');
+    memMod.stats(); // triggers DB + schema creation
+    memMod.close();
+    log('INFO', `Memory DB ready: ${memMod.DB_PATH}`);
+  } catch (e) {
+    log('WARN', `Memory DB pre-init failed (non-fatal, will retry on first use): ${e.message}`);
+  }
+
+  // Start QMD semantic search daemon if available (optional, non-fatal)
+  try {
+    const qmd = require('./qmd-client');
+    if (qmd.isAvailable()) {
+      qmd.ensureCollection();
+      qmd.startDaemon().then(running => {
+        if (running) log('INFO', '[QMD] Semantic search daemon started (localhost:8181)');
+        else log('INFO', '[QMD] Available but daemon not started — will use CLI fallback');
+      }).catch(() => { });
+    }
+  } catch { /* qmd-client not available, skip */ }
   // Hourly heartbeat so daemon.log stays fresh even when idle (visible aliveness check)
   setInterval(() => {
     log('INFO', `Daemon heartbeat — uptime: ${Math.round(process.uptime() / 60)}m, active sessions: ${activeProcesses.size}`);
@@ -4255,14 +4794,7 @@ async function main() {
 
   // Task executor lookup (always reads fresh config)
   function executeTaskByName(name) {
-    const legacy = (config.heartbeat && config.heartbeat.tasks) || [];
-    let task = legacy.find(t => t.name === name);
-    if (!task) {
-      for (const [key, proj] of Object.entries(config.projects || {})) {
-        const found = (proj.heartbeat_tasks || []).find(t => t.name === name);
-        if (found) { task = { ...found, _project: { key, name: proj.name || key, color: proj.color || 'blue', icon: proj.icon || '🤖' } }; break; }
-      }
-    }
+    const task = findTask(config, name);
     if (!task) return { success: false, error: `Task "${name}" not found` };
     return executeTask(task, config);
   }
@@ -4327,6 +4859,9 @@ async function main() {
     }
   };
 
+  // Start dispatch socket server (low-latency IPC, fallback: file polling still works)
+  const dispatchSocket = startDispatchSocket(config);
+
   // Start heartbeat scheduler
   let heartbeatTimer = startHeartbeat(config, notifyFn);
 
@@ -4338,10 +4873,9 @@ async function main() {
     refreshLogMaxSize(config);
     if (heartbeatTimer) clearInterval(heartbeatTimer);
     heartbeatTimer = startHeartbeat(config, notifyFn);
-    const legacyCount = (config.heartbeat && config.heartbeat.tasks || []).length;
-    const projectCount = Object.values(config.projects || {}).reduce((n, p) => n + (p.heartbeat_tasks || []).length, 0);
-    const totalCount = legacyCount + projectCount;
-    log('INFO', `Config reloaded: ${totalCount} tasks (${projectCount} in projects)`);
+    const { general, project } = getAllTasks(config);
+    const totalCount = general.length + project.length;
+    log('INFO', `Config reloaded: ${totalCount} tasks (${project.length} in projects)`);
     return { success: true, tasks: totalCount };
   }
   // Expose reloadConfig to handleCommand via closure
@@ -4389,7 +4923,7 @@ async function main() {
   });
   // Hook: after every Claude task completes, check if restart is pending
   const _origDelete = activeProcesses.delete.bind(activeProcesses);
-  activeProcesses.delete = function(key) {
+  activeProcesses.delete = function (key) {
     const result = _origDelete(key);
     if (_pendingRestart && activeProcesses.size === 0) {
       log('INFO', 'All tasks completed — executing deferred restart...');
@@ -4413,8 +4947,12 @@ async function main() {
     fs.unwatchFile(CONFIG_FILE);
     fs.unwatchFile(DAEMON_SCRIPT);
     if (heartbeatTimer) clearInterval(heartbeatTimer);
+    if (dispatchSocket) try { dispatchSocket.close(); } catch { }
+    try { fs.unlinkSync(SOCK_PATH); } catch { }
     if (telegramBridge) telegramBridge.stop();
     if (feishuBridge) feishuBridge.stop();
+    // Stop QMD semantic search daemon if it was started
+    try { require('./qmd-client').stopDaemon(); } catch { /* ignore */ }
     // Kill all tracked claude process groups before exiting (covers sub-agents too)
     for (const [cid, proc] of activeProcesses) {
       try { process.kill(-proc.child.pid, 'SIGKILL'); } catch { try { proc.child.kill('SIGKILL'); } catch { } }
@@ -4445,11 +4983,11 @@ if (process.argv.includes('--run')) {
     process.exit(1);
   }
   const config = loadConfig();
-  const tasks = (config.heartbeat && config.heartbeat.tasks) || [];
-  const task = tasks.find(t => t.name === taskName);
+  const task = findTask(config, taskName);
   if (!task) {
+    const { all } = getAllTasks(config);
     console.error(`Task "${taskName}" not found in daemon.yaml`);
-    console.error(`Available: ${tasks.map(t => t.name).join(', ') || '(none)'}`);
+    console.error(`Available: ${all.map(t => t.name).join(', ') || '(none)'}`);
     process.exit(1);
   }
   const result = executeTask(task, config);