metame-cli 1.3.20 → 1.3.23

package/scripts/daemon.js

@@ -25,6 +25,12 @@ const STATE_FILE = path.join(METAME_DIR, 'daemon_state.json');
 const PID_FILE = path.join(METAME_DIR, 'daemon.pid');
 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');
+
+// Skill evolution module (hot path + cold path)
+let skillEvolution = null;
+try { skillEvolution = require('./skill-evolution'); } catch { /* graceful fallback */ }
 
 // ---------------------------------------------------------
 // SKILL ROUTING (keyword → /skillname prefix, like metame-desktop)
@@ -106,6 +112,11 @@ function log(level, msg) {
     // Last resort
     process.stderr.write(line);
   }
+  // When running as LaunchAgent (stdout redirected to file), mirror structured logs there too.
+  // This unifies daemon.log and daemon-npm-stdout.log into one source of truth.
+  if (!process.stdout.isTTY) {
+    process.stdout.write(line);
+  }
 }
 
 // ---------------------------------------------------------
@@ -121,7 +132,7 @@ function loadConfig() {
 
 function backupConfig() {
   const bak = CONFIG_FILE + '.bak';
-  try { fs.copyFileSync(CONFIG_FILE, bak); } catch {}
+  try { fs.copyFileSync(CONFIG_FILE, bak); } catch { }
 }
 
 function restoreConfig() {
@@ -132,7 +143,7 @@ function restoreConfig() {
     // Preserve security-critical fields from current config (chat IDs, agent map)
     // so a /fix never loses manually-added channels
     let curCfg = {};
-    try { curCfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {}; } catch {}
+    try { curCfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {}; } catch { }
     for (const adapter of ['feishu', 'telegram']) {
       if (curCfg[adapter] && bakCfg[adapter]) {
         const curIds = curCfg[adapter].allowed_chat_ids || [];
@@ -372,56 +383,78 @@ function executeTask(task, config) {
     log('INFO', `Executing task: ${task.name} (model: ${model}${mcpConfig ? ', mcp: ' + path.basename(mcpConfig) : ''})`);
   }
 
-  try {
-    const output = execFileSync('claude', claudeArgs, {
-      input: fullPrompt,
-      encoding: 'utf8',
-      timeout: task.timeout || 120000,
-      maxBuffer: 5 * 1024 * 1024,
-      ...(cwd && { cwd }),
-      env: { ...process.env, ...getDaemonProviderEnv(), CLAUDECODE: undefined },
-    }).trim();
+  // Use spawnClaudeAsync (non-blocking spawn with process-group kill) instead of
+  // execFileSync (sync, blocks event loop, can't kill sub-agents).
+  // executeTask now returns a Promise — callers must handle it with .then() or await.
+  const timeoutMs = task.timeout || 120000;
+  const asyncArgs = [...claudeArgs];
+  const asyncEnv = { ...process.env, ...getDaemonProviderEnv(), CLAUDECODE: undefined };
 
-    // Rough token estimate: ~4 chars per token for input + output
-    const estimatedTokens = Math.ceil((fullPrompt.length + output.length) / 4);
-    recordTokens(state, estimatedTokens);
+  return new Promise((resolve) => {
+    const child = spawn('claude', asyncArgs, {
+      cwd: cwd || undefined,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: true, // own process group — kills sub-agents on timeout too
+      env: asyncEnv,
+    });
 
-    // Record task result (preserve session_id for persistent sessions)
-    const prevSessionId = state.tasks[task.name]?.session_id;
-    state.tasks[task.name] = {
-      last_run: new Date().toISOString(),
-      status: 'success',
-      output_preview: output.slice(0, 200),
-      ...(prevSessionId && { session_id: prevSessionId }),
-    };
-    saveState(state);
+    let stdout = '';
+    let stderr = '';
+    let timedOut = false;
 
-    log('INFO', `Task ${task.name} completed (est. ${estimatedTokens} tokens)`);
-    return { success: true, output, tokens: estimatedTokens };
-  } catch (e) {
-    const errMsg = e.message || '';
-    // If persistent session expired/not found, reset and let next run create fresh
-    if (task.persistent_session && (errMsg.includes('not found') || errMsg.includes('No session'))) {
-      log('WARN', `Persistent session for ${task.name} expired, will create new on next run`);
-      state.tasks[task.name] = {
-        last_run: new Date().toISOString(),
-        status: 'session_reset',
-        error: 'Session expired, will retry with new session',
-      };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      log('WARN', `Task ${task.name} timeout (${timeoutMs / 1000}s) — killing process group`);
+      try { process.kill(-child.pid, 'SIGTERM'); } catch { child.kill('SIGTERM'); }
+      setTimeout(() => {
+        try { process.kill(-child.pid, 'SIGKILL'); } catch { try { child.kill('SIGKILL'); } catch { } }
+      }, 5000);
+    }, timeoutMs);
+
+    child.stdin.write(fullPrompt);
+    child.stdin.end();
+    child.stdout.on('data', (d) => { stdout += d.toString(); });
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      const output = stdout.trim();
+      if (timedOut) {
+        const prevSid = state.tasks[task.name]?.session_id;
+        state.tasks[task.name] = { last_run: new Date().toISOString(), status: 'timeout', error: 'Task exceeded timeout', ...(prevSid && { session_id: prevSid }) };
+        saveState(state);
+        return resolve({ success: false, error: 'timeout', output: '' });
+      }
+      if (code !== 0) {
+        const errMsg = (stderr || `Exit code ${code}`).slice(0, 200);
+        // Persistent session expired: reset so next run creates a new one
+        if (task.persistent_session && (errMsg.includes('not found') || errMsg.includes('No session'))) {
+          log('WARN', `Persistent session for ${task.name} expired, will create new on next run`);
+          state.tasks[task.name] = { last_run: new Date().toISOString(), status: 'session_reset', error: 'Session expired' };
+          saveState(state);
+          return resolve({ success: false, error: 'session_expired', output: '' });
+        }
+        log('ERROR', `Task ${task.name} failed (exit ${code}): ${errMsg}`);
+        const prevSid = state.tasks[task.name]?.session_id;
+        state.tasks[task.name] = { last_run: new Date().toISOString(), status: 'error', error: errMsg, ...(prevSid && { session_id: prevSid }) };
+        saveState(state);
+        return resolve({ success: false, error: errMsg, output: '' });
+      }
+      const estimatedTokens = Math.ceil((fullPrompt.length + output.length) / 4);
+      recordTokens(state, estimatedTokens);
+      const prevSessionId = state.tasks[task.name]?.session_id;
+      state.tasks[task.name] = { last_run: new Date().toISOString(), status: 'success', output_preview: output.slice(0, 200), ...(prevSessionId && { session_id: prevSessionId }) };
       saveState(state);
-      return { success: false, error: 'session_expired', output: '' };
-    }
-    log('ERROR', `Task ${task.name} failed: ${errMsg}`);
-    const prevSid = state.tasks[task.name]?.session_id;
-    state.tasks[task.name] = {
-      last_run: new Date().toISOString(),
-      status: 'error',
-      error: errMsg.slice(0, 200),
-      ...(prevSid && { session_id: prevSid }),
-    };
-    saveState(state);
-    return { success: false, error: e.message, output: '' };
-  }
+      log('INFO', `Task ${task.name} completed (est. ${estimatedTokens} tokens)`);
+      resolve({ success: true, output, tokens: estimatedTokens });
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      log('ERROR', `Task ${task.name} spawn error: ${err.message}`);
+      resolve({ success: false, error: err.message, output: '' });
+    });
+  });
 }
 
 // parseInterval — imported from ./utils
@@ -497,6 +530,235 @@ function executeWorkflow(task, config) {
   return { success: true, output: outputs.map(o => `Step ${o.step} (${o.skill || 'prompt'}): ${o.error ? 'FAILED' : 'OK'}`).join('\n') + '\n\n' + (lastOk ? lastOk.output : ''), tokens: totalTokens };
 }
 
+// ---------------------------------------------------------
+// AGENT DISPATCH — virtual chatId inter-agent communication
+// ---------------------------------------------------------
+
+// Late-bound reference to handleCommand (defined later in file)
+let _handleCommand = null;
+let _dispatchBridgeRef = null; // Store bridge (not bot) so .bot is always the live object after reconnects
+function setDispatchHandler(fn) { _handleCommand = fn; }
+
+/**
+ * Create a null bot that captures Claude's output without sending to Feishu/Telegram.
+ */
+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,
+  };
+}
+
+/**
+ * Dispatch a task/message to another agent via virtual chatId.
+ * @param {string} targetProject - project key (e.g. 'digital_me', 'desktop')
+ * @param {object} message - { from, type, priority, payload, callback, chain }
+ * @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 };
+
+  // Anti-storm: check chain depth
+  const chain = message.chain || [];
+  if (chain.length >= LIMITS.max_depth) {
+    log('WARN', `Dispatch blocked: max depth ${LIMITS.max_depth} reached (chain: ${chain.join('→')})`);
+    return { success: false, error: 'max_depth_exceeded' };
+  }
+
+  // Anti-storm: check for cycles
+  if (chain.includes(targetProject)) {
+    log('WARN', `Dispatch blocked: cycle detected (${chain.join('→')}→${targetProject})`);
+    return { success: false, error: 'cycle_detected' };
+  }
+
+  // Anti-storm: rate limiting via dispatch log
+  try {
+    if (fs.existsSync(DISPATCH_LOG)) {
+      const lines = fs.readFileSync(DISPATCH_LOG, 'utf8').trim().split('\n').filter(Boolean);
+      const oneHourAgo = Date.now() - 3600_000;
+      const recent = lines
+        .map(l => { try { return JSON.parse(l); } catch { return null; } })
+        .filter(e => e && new Date(e.dispatched_at).getTime() > oneHourAgo);
+      const toTarget = recent.filter(e => e.to === targetProject).length;
+      if (toTarget >= LIMITS.max_per_hour_per_target) {
+        log('WARN', `Dispatch blocked: rate limit to ${targetProject} (${toTarget}/${LIMITS.max_per_hour_per_target} per hour)`);
+        return { success: false, error: 'rate_limit_target' };
+      }
+      if (recent.length >= LIMITS.max_total_per_hour) {
+        log('WARN', `Dispatch blocked: total rate limit (${recent.length}/${LIMITS.max_total_per_hour} per hour)`);
+        return { success: false, error: 'rate_limit_total' };
+      }
+    }
+  } catch (e) {
+    log('WARN', `Dispatch rate check failed: ${e.message}`);
+  }
+
+  if (!_handleCommand) {
+    log('WARN', 'Dispatch: handleCommand not yet bound, dropping task');
+    return { success: false, error: 'handler_not_ready' };
+  }
+
+  const fullMsg = {
+    id: `d_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+    from: message.from || 'unknown',
+    to: targetProject,
+    type: message.type || 'task',
+    priority: message.priority || 'normal',
+    payload: message.payload || {},
+    callback: message.callback || false,
+    new_session: !!message.new_session,
+    chain: [...chain, message.from || 'unknown'],
+    created_at: new Date().toISOString(),
+  };
+
+  // Write to dispatch log for audit / rate-limiting
+  if (!fs.existsSync(DISPATCH_DIR)) fs.mkdirSync(DISPATCH_DIR, { recursive: true });
+  fs.appendFileSync(DISPATCH_LOG, JSON.stringify({ ...fullMsg, dispatched_at: new Date().toISOString() }) + '\n', 'utf8');
+
+  const rawPrompt = fullMsg.payload.prompt || fullMsg.payload.title || 'No prompt provided';
+
+  // Inject sender identity when dispatched by another agent (not directly from user)
+  const userSources = new Set(['unknown', 'claude_session', '_claude_session', 'user']);
+  const senderKey = fullMsg.from;
+  let prompt = rawPrompt;
+  if (senderKey && !userSources.has(senderKey) && config && config.projects) {
+    const senderProj = config.projects[senderKey];
+    const senderName = senderProj ? (senderProj.name || senderKey) : senderKey;
+    const senderIcon = senderProj ? (senderProj.icon || '🤖') : '🤖';
+    prompt = `[系统提示：此消息由 ${senderIcon} ${senderName}（${senderKey}）转发，不是王总直接发送的。如需回复，可调用 ~/.metame/bin/dispatch_to ${senderKey} "回复内容"。]\n\n${rawPrompt}`;
+  }
+
+  // Inject ack-first instruction for all dispatched tasks
+  prompt = `[行为要求：收到此任务后，请先用 dispatch_to 回复一条消息说明「收到，计划：xxx」，再开始执行。]\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];
+  const forceNew = !!fullMsg.new_session;
+  const dispatchChatId = (!forceNew && realChatId) ? realChatId : `_agent_${targetProject}`;
+  const sessionMode = forceNew ? 'fresh session (forced)' : realChatId ? 'existing session' : 'fresh session';
+  log('INFO', `Dispatching ${fullMsg.type} to ${targetProject} via ${sessionMode}: ${rawPrompt.slice(0, 80)}`);
+
+  const nullBot = createNullBot((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) {
+      dispatchTask(fullMsg.from, {
+        from: targetProject,
+        type: 'callback',
+        priority: 'normal',
+        payload: {
+          title: `任务完成: ${fullMsg.payload.title || fullMsg.id}`,
+          original_id: fullMsg.id,
+          output: outStr.slice(0, 500),
+        },
+        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 => {
+    log('ERROR', `Dispatch handleCommand failed for ${targetProject}: ${e.message}`);
+  });
+
+  return { success: true, id: fullMsg.id };
+}
+
+/**
+ * Physiological heartbeat: zero-token awareness check.
+ * Runs every tick unconditionally.
+ */
+function physiologicalHeartbeat(config) {
+  // 1. Update last_alive timestamp
+  const state = loadState();
+  state.last_alive = new Date().toISOString();
+  state.memory_mb = Math.round(process.memoryUsage().rss / 1024 / 1024);
+  saveState(state);
+
+  // 2. Drain pending.jsonl — dispatch requests written by Claude sessions via dispatch_to CLI
+  const PENDING = path.join(DISPATCH_DIR, 'pending.jsonl');
+  const PENDING_TMP = PENDING + '.processing';
+  try {
+    if (fs.existsSync(PENDING)) {
+      // Atomic: rename before reading so new writes during processing go to a fresh file
+      fs.renameSync(PENDING, PENDING_TMP);
+      const content = fs.readFileSync(PENDING_TMP, 'utf8').trim();
+      fs.unlinkSync(PENDING_TMP);
+      if (content) {
+        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);
+        }
+      }
+    }
+  } catch (e) {
+    log('WARN', `Pending dispatch drain failed: ${e.message}`);
+  }
+
+  // 2. Rotate dispatch-log if > 512KB (keep 7 days)
+  try {
+    if (fs.existsSync(DISPATCH_LOG)) {
+      const stat = fs.statSync(DISPATCH_LOG);
+      if (stat.size > 512 * 1024) {
+        const lines = fs.readFileSync(DISPATCH_LOG, 'utf8').trim().split('\n');
+        const sevenDaysAgo = Date.now() - 7 * 86400_000;
+        const recent = lines.filter(l => {
+          try { return new Date(JSON.parse(l).dispatched_at).getTime() > sevenDaysAgo; } catch { return false; }
+        });
+        fs.writeFileSync(DISPATCH_LOG, recent.join('\n') + '\n', 'utf8');
+      }
+    }
+  } catch (e) {
+    log('WARN', `Dispatch log rotation failed: ${e.message}`);
+  }
+}
+
 // ---------------------------------------------------------
 // HEARTBEAT SCHEDULER
 // ---------------------------------------------------------
@@ -511,24 +773,19 @@ function startHeartbeat(config, notifyFn) {
     }
   }
   const tasks = [...legacyTasks, ...projectTasks];
-  if (tasks.length === 0) {
-    log('INFO', 'No heartbeat tasks configured');
-    return;
-  }
 
   const enabledTasks = tasks.filter(t => t.enabled !== false);
   const checkIntervalSec = (config.daemon && config.daemon.heartbeat_check_interval) || 60;
   log('INFO', `Heartbeat scheduler started (check every ${checkIntervalSec}s, ${enabledTasks.length}/${tasks.length} tasks enabled)`);
 
-  if (enabledTasks.length === 0) {
-    return;
-  }
+  // Even with zero tasks, the physiological heartbeat still runs
 
   // Track next run times
   const nextRun = {};
   const now = Date.now();
   const state = loadState();
 
+  let newTaskIndex = 0;
   for (const task of enabledTasks) {
     const intervalSec = parseInterval(task.interval);
     const lastRun = state.tasks[task.name] && state.tasks[task.name].last_run;
@@ -536,29 +793,71 @@ function startHeartbeat(config, notifyFn) {
       const elapsed = (now - new Date(lastRun).getTime()) / 1000;
       nextRun[task.name] = now + Math.max(0, (intervalSec - elapsed)) * 1000;
     } else {
-      // First run: execute after one check interval
-      nextRun[task.name] = now + checkIntervalSec * 1000;
+      // First run: stagger new tasks to avoid thundering herd
+      // Each new task waits an additional check interval beyond the first
+      newTaskIndex++;
+      nextRun[task.name] = now + checkIntervalSec * 1000 * newTaskIndex;
     }
   }
 
+  // Tracks tasks currently running (prevents concurrent runs of the same task)
+  const runningTasks = new Set();
+
   const timer = setInterval(() => {
+    // ① Physiological heartbeat (zero token, pure awareness)
+    physiologicalHeartbeat(config);
+
+    // ② Task heartbeat (burns tokens on schedule)
     const currentTime = Date.now();
     for (const task of enabledTasks) {
       if (currentTime >= (nextRun[task.name] || 0)) {
-        const result = executeTask(task, config);
         const intervalSec = parseInterval(task.interval);
         nextRun[task.name] = currentTime + intervalSec * 1000;
 
-        if (task.notify && notifyFn && !result.skipped) {
-          const proj = task._project || null;
-          if (result.success) {
-            notifyFn(`✅ *${task.name}* completed\n\n${result.output}`, proj);
-          } else {
-            notifyFn(`❌ *${task.name}* failed: ${result.error}`, proj);
-          }
+        if (runningTasks.has(task.name)) {
+          log('WARN', `Task ${task.name} still running — skipping this interval`);
+          continue;
         }
+
+        runningTasks.add(task.name);
+        // executeTask now returns a Promise (async, non-blocking, process-group kill)
+        Promise.resolve(executeTask(task, config))
+          .then((result) => {
+            runningTasks.delete(task.name);
+            if (task.notify && notifyFn && !result.skipped) {
+              const proj = task._project || null;
+              if (result.success) {
+                notifyFn(`✅ *${task.name}* completed\n\n${result.output}`, proj);
+              } else {
+                notifyFn(`❌ *${task.name}* failed: ${result.error}`, proj);
+              }
+            }
+          })
+          .catch((err) => {
+            runningTasks.delete(task.name);
+            log('ERROR', `Task ${task.name} threw: ${err.message}`);
+          });
       }
     }
+
+    // Skill evolution: check queue and notify user of actionable items
+    if (skillEvolution) {
+      try {
+        const notifications = skillEvolution.checkEvolutionQueue();
+        for (const item of notifications) {
+          let msg = '';
+          if (item.type === 'skill_gap') {
+            msg = `🧬 *技能缺口检测*\n${item.reason}`;
+            if (item.search_hint) msg += `\n搜索建议: \`${item.search_hint}\``;
+          } else if (item.type === 'skill_fix') {
+            msg = `🔧 *技能需要修复*\n技能 \`${item.skill_name}\` ${item.reason}`;
+          } else if (item.type === 'user_complaint') {
+            msg = `⚠️ *技能反馈*\n技能 \`${item.skill_name}\` 收到用户反馈\n${item.reason}`;
+          }
+          if (msg && notifyFn) notifyFn(msg);
+        }
+      } catch (e) { log('WARN', `Skill evolution queue check failed: ${e.message}`); }
+    }
   }, checkIntervalSec * 1000);
 
   return timer;
@@ -589,11 +888,12 @@ async function startTelegramBridge(config, executeTaskByName) {
 
   let offset = 0;
   let running = true;
+  const abortController = new AbortController();
 
   const pollLoop = async () => {
     while (running) {
       try {
-        const updates = await bot.getUpdates(offset, 30);
+        const updates = await bot.getUpdates(offset, 30, abortController.signal);
         for (const update of updates) {
           offset = update.update_id + 1;
 
@@ -601,7 +901,7 @@ async function startTelegramBridge(config, executeTaskByName) {
           if (update.callback_query) {
             const cb = update.callback_query;
             const chatId = cb.message && cb.message.chat.id;
-            bot.answerCallback(cb.id).catch(() => {});
+            bot.answerCallback(cb.id).catch(() => { });
             if (chatId && cb.data) {
               const allowedIds = (loadConfig().telegram && loadConfig().telegram.allowed_chat_ids) || [];
               if (!allowedIds.includes(chatId)) continue;
@@ -619,9 +919,10 @@ async function startTelegramBridge(config, executeTaskByName) {
           const chatId = msg.chat.id;
 
           // Security: check whitelist (empty = deny all) — read live config to support hot-reload
-          // Exception: /bind is allowed from any chat so users can self-register new groups
+          // Exception: /bind and /agent bind/new are allowed from any chat so users can self-register new groups
           const allowedIds = (loadConfig().telegram && loadConfig().telegram.allowed_chat_ids) || [];
-          const isBindCmd = msg.text && msg.text.trim().startsWith('/bind');
+          const trimmedText = msg.text && msg.text.trim();
+          const isBindCmd = trimmedText && (trimmedText.startsWith('/agent bind') || trimmedText.startsWith('/agent new'));
           if (!allowedIds.includes(chatId) && !isBindCmd) {
             log('WARN', `Rejected message from unauthorized chat: ${chatId}`);
             continue;
@@ -675,6 +976,7 @@ async function startTelegramBridge(config, executeTaskByName) {
           }
         }
       } catch (e) {
+        if (e.message === 'aborted') break; // clean stop requested, exit loop
         log('ERROR', `Telegram poll error: ${e.message}`);
         // Wait before retry
         await sleep(5000);
@@ -684,6 +986,7 @@ async function startTelegramBridge(config, executeTaskByName) {
 
   const startPoll = () => {
     pollLoop().catch(e => {
+      if (e.message === 'aborted') return; // clean stop, no need to restart
       log('ERROR', `pollLoop crashed: ${e.message} — restarting in 5s`);
       if (running) setTimeout(startPoll, 5000);
     });
@@ -691,16 +994,16 @@ async function startTelegramBridge(config, executeTaskByName) {
   startPoll();
 
   return {
-    stop() { running = false; },
+    stop() { running = false; abortController.abort(); }, // cancel in-flight request immediately
     bot,
   };
 }
 
 // ── Timing constants ─────────────────────────────────────────────────────────
-const CLAUDE_COOLDOWN_MS  = 10000; // 10s between Claude calls per chat
-const STATUS_THROTTLE_MS  = 3000;  // Min 3s between streaming status updates
+const CLAUDE_COOLDOWN_MS = 10000; // 10s between Claude calls per chat
+const STATUS_THROTTLE_MS = 3000;  // Min 3s between streaming status updates
 const FALLBACK_THROTTLE_MS = 8000; // 8s between fallback status updates
-const DEDUP_TTL_MS        = 60000; // Feishu message dedup window (60s)
+const DEDUP_TTL_MS = 60000; // Feishu message dedup window (60s)
 // ─────────────────────────────────────────────────────────────────────────────
 
 // Rate limiter for /ask and /run — prevents rapid-fire Claude calls
@@ -769,13 +1072,18 @@ async function sendFileButtons(bot, chatId, files) {
  */
 function attachOrCreateSession(chatId, projCwd, name) {
   const state = loadState();
-  const recent = listRecentSessions(1, projCwd);
-  if (recent.length > 0 && recent[0].sessionId) {
-    state.sessions[chatId] = { id: recent[0].sessionId, cwd: projCwd, started: true };
-  } else {
-    const newSess = createSession(chatId, projCwd, name || '');
-    state.sessions[chatId] = { id: newSess.id, cwd: projCwd, started: false };
+  // Virtual agent chatIds (_agent_*) always get a fresh one-shot session.
+  // They must not resume real sessions, to avoid concurrency conflicts.
+  if (!String(chatId).startsWith('_agent_')) {
+    const recent = listRecentSessions(1, projCwd);
+    if (recent.length > 0 && recent[0].sessionId) {
+      state.sessions[chatId] = { id: recent[0].sessionId, cwd: projCwd, started: true };
+      saveState(state);
+      return;
+    }
   }
+  const newSess = createSession(chatId, projCwd, name || '');
+  state.sessions[chatId] = { id: newSess.id, cwd: projCwd, started: false };
   saveState(state);
 }
 
@@ -795,7 +1103,7 @@ async function sendDirPicker(bot, chatId, mode, title) {
  * - Shows up to 12 subdirs per page with pagination
  */
 async function sendBrowse(bot, chatId, mode, dirPath, title, page = 0) {
-  const cmd = mode === 'new' ? '/new' : mode === 'bind' ? '/bind-dir' : '/cd';
+  const cmd = mode === 'new' ? '/new' : mode === 'bind' ? '/bind-dir' : mode === 'agent-new' ? '/agent-dir' : '/cd';
   const PAGE_SIZE = 10;
   try {
     const entries = fs.readdirSync(dirPath, { withFileTypes: true });
@@ -943,6 +1251,52 @@ async function sendDirListing(bot, chatId, baseDir, arg) {
   }
 }
 
+/**
+ * 智能合并 Agent 角色描述到 CLAUDE.md
+ * 如果目录中没有 CLAUDE.md，直接创建；否则调用 Claude 合并。
+ */
+async function mergeAgentRole(cwd, description) {
+  const claudeMdPath = path.join(cwd, 'CLAUDE.md');
+  if (!fs.existsSync(claudeMdPath)) {
+    // 直接创建，无需调 Claude
+    const content = `## Agent 角色\n\n${description}\n`;
+    fs.writeFileSync(claudeMdPath, content, 'utf8');
+    return { created: true };
+  }
+
+  const existing = fs.readFileSync(claudeMdPath, 'utf8');
+  const prompt = `现有 CLAUDE.md 内容：
+---
+${existing}
+---
+
+用户为这个 Agent 定义的角色和职责：
+"${description}"
+
+请将用户意图合并进 CLAUDE.md：
+1. 找到现有角色/职责相关章节 → 更新替换
+2. 没有专属章节但有相关内容 → 合并进去
+3. 完全没有相关内容 → 在文件最顶部新增 ## Agent 角色 section
+4. 输出完整 CLAUDE.md 内容，保持原有其他内容不变
+5. 保持简洁，禁止重复
+
+直接输出完整 CLAUDE.md 内容，不要加任何解释或代码块标记。`;
+
+  const claudeArgs = ['-p', '--output-format', 'text', '--max-turns', '1'];
+  const { output, error } = await spawnClaudeAsync(claudeArgs, prompt, HOME, 60000);
+  if (error || !output) {
+    return { error: error || '合并失败' };
+  }
+
+  let cleanOutput = output.trim();
+  if (cleanOutput.startsWith('```')) {
+    cleanOutput = cleanOutput.replace(/^```[a-zA-Z]*\n/, '').replace(/\n```$/, '');
+  }
+
+  fs.writeFileSync(claudeMdPath, cleanOutput, 'utf8');
+  return { merged: true };
+}
+
 /**
  * Unified command handler — shared by Telegram & Feishu
  */
@@ -1009,49 +1363,14 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
   }
 
   // --- /bind <name> [cwd]: register this chat as a dedicated agent channel ---
-  // With cwd:    /bind 小美 ~/          → bind immediately
-  // Without cwd: /bind 教授             → show directory picker
-  if (text.startsWith('/bind ') || text === '/bind') {
-    const args = text.slice(5).trim();
-    const parts = args.split(/\s+/);
-    const agentName = parts[0];
-    const agentCwd = parts.slice(1).join(' ');
-
-    if (!agentName) {
-      await bot.sendMessage(chatId, '用法: /bind <名称> [工作目录]\n例: /bind 小美 ~/\n或:  /bind 教授  (弹出目录选择)');
-      return;
-    }
-
-    if (!agentCwd) {
-      // No cwd given — show directory picker
-      pendingBinds.set(String(chatId), agentName);
-      await sendDirPicker(bot, chatId, 'bind', `为「${agentName}」选择工作目录:`);
-      return;
-    }
-
-    await doBindAgent(bot, chatId, agentName, agentCwd);
-    return;
-  }
-
-  // --- /bind-dir <path>: called by directory picker to complete a pending bind ---
-  if (text.startsWith('/bind-dir ')) {
-    const dirPath = expandPath(text.slice(10).trim());
-    const agentName = pendingBinds.get(String(chatId));
-    if (!agentName) {
-      await bot.sendMessage(chatId, '❌ 没有待完成的 /bind，请重新发送 /bind <名称>');
-      return;
-    }
-    pendingBinds.delete(String(chatId));
-    await doBindAgent(bot, chatId, agentName, dirPath);
-    return;
-  }
 
   // --- chat_agent_map: auto-switch agent based on dedicated chatId ---
   // Configure in daemon.yaml: feishu.chat_agent_map or telegram.chat_agent_map
   //   e.g.  chat_agent_map: { "oc_xxx": "personal", "oc_yyy": "metame" }
-  const chatAgentMap = (config.feishu && config.feishu.chat_agent_map) ||
-                       (config.telegram && config.telegram.chat_agent_map) || {};
-  const mappedKey = chatAgentMap[String(chatId)];
+  const chatAgentMap = { ...(config.telegram ? config.telegram.chat_agent_map : {}), ...(config.feishu ? config.feishu.chat_agent_map : {}) };
+  const _chatIdStr = String(chatId);
+  const mappedKey = chatAgentMap[_chatIdStr] ||
+    (_chatIdStr.startsWith('_agent_') ? _chatIdStr.slice(7) : null);
   if (mappedKey && config.projects && config.projects[mappedKey]) {
     const proj = config.projects[mappedKey];
     const projCwd = normalizeCwd(proj.cwd);
@@ -1088,8 +1407,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     if (!arg) {
       // In a dedicated agent group, use the agent's bound cwd directly
       const newCfg = loadConfig();
-      const agentMap = (newCfg.feishu && newCfg.feishu.chat_agent_map) ||
-                       (newCfg.telegram && newCfg.telegram.chat_agent_map) || {};
+      const agentMap = { ...(newCfg.telegram ? newCfg.telegram.chat_agent_map : {}), ...(newCfg.feishu ? newCfg.feishu.chat_agent_map : {}) };
       const boundKey = agentMap[String(chatId)];
       const boundProj = boundKey && newCfg.projects && newCfg.projects[boundKey];
       if (boundProj && boundProj.cwd) {
@@ -1212,26 +1530,11 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       return;
     }
     if (bot.sendButtons) {
-      const buttons = allSessions.map(s => {
-        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 name = s.customTitle || (s.summary || '').slice(0, 18) || '';
-        let label = `${ago} 📁${proj}`;
-        if (name) label += ` ${name}`;
-        label += ` #${shortId}`;
-        return [{ text: label, callback_data: `/sess ${s.sessionId}` }];
-      });
-      await bot.sendButtons(chatId, '📋 Tap a session to view details:', buttons);
+      await bot.sendCard(chatId, '📋 Recent Sessions', buildSessionCardElements(allSessions));
     } else {
       let msg = '📋 Recent sessions:\n\n';
       allSessions.forEach((s, i) => {
-        const proj = s.projectPath ? path.basename(s.projectPath) : '~';
-        const title = s.customTitle || s.summary || (s.firstPrompt || '').slice(0, 40) || '';
-        const shortId = s.sessionId.slice(0, 8);
-        msg += `${i + 1}. 📁${proj} | ${title}\n   /resume ${shortId}\n`;
+        msg += sessionRichLabel(s, i + 1) + '\n';
       });
       await bot.sendMessage(chatId, msg);
     }
@@ -1268,7 +1571,25 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     detail += `🆔 ID: ${s.sessionId.slice(0, 8)}`;
     if (firstMsg && firstMsg !== summary) detail += `\n\n🗨️ First message:\n${firstMsg}`;
 
-    if (bot.sendButtons) {
+    if (bot.sendCard) {
+      // Build rich detail as markdown body + buttons
+      let body = '';
+      if (title) body += `**📝 ${title}**\n`;
+      if (summary) body += `💡 ${summary}\n`;
+      body += `📁 ${projName} · 📂 ${proj}\n`;
+      body += `💬 ${msgs} messages · 🕐 ${ago}\n`;
+      body += `🆔 ${s.sessionId.slice(0, 8)}`;
+      if (firstMsg && firstMsg !== summary) body += `\n\n🗨️ ${firstMsg.slice(0, 100)}`;
+      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' } },
+        ] },
+      ];
+      await bot.sendCard(chatId, '📋 Session Detail', elements);
+    } else if (bot.sendButtons) {
       await bot.sendButtons(chatId, detail, [
         [{ text: '▶️ Switch to this session', callback_data: `/resume ${s.sessionId}` }],
         [{ text: '⬅️ Back to list', callback_data: '/sessions' }],
@@ -1292,16 +1613,18 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
         await bot.sendMessage(chatId, `No sessions found${curCwd ? ' in ' + path.basename(curCwd) : ''}. Try /new first.`);
         return;
       }
-      const title = curCwd ? `Sessions in ${path.basename(curCwd)}:` : 'Recent sessions:';
-      if (bot.sendButtons) {
+      const headerTitle = curCwd ? `📋 Sessions in ${path.basename(curCwd)}` : '📋 Recent Sessions';
+      if (bot.sendCard) {
+        await bot.sendCard(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, title, buttons);
+        await bot.sendButtons(chatId, headerTitle, buttons);
       } else {
-        let msg = `${title}\n`;
+        let msg = `${title}\n\n`;
         recentSessions.forEach((s, i) => {
-          msg += `${i + 1}. ${sessionLabel(s)}\n   /resume ${s.sessionId.slice(0, 8)}\n`;
+          msg += sessionRichLabel(s, i + 1) + '\n';
         });
         await bot.sendMessage(chatId, msg);
       }
@@ -1326,8 +1649,13 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       fullMatch = recentSessions.find(s => s.sessionId.startsWith(arg))
         || allSessions.find(s => s.sessionId.startsWith(arg));
     }
-    const sessionId = fullMatch ? fullMatch.sessionId : arg;
-    const cwd = (fullMatch && fullMatch.projectPath) || (getSession(chatId) && getSession(chatId).cwd) || HOME;
+    if (!fullMatch) {
+      // No match found — treat as normal message, not a /resume command
+      // (e.g. "/resume 看到的session信息太少了" is feedback, not a session ID)
+      return null; // fall through to askClaude
+    }
+    const sessionId = fullMatch.sessionId;
+    const cwd = fullMatch.projectPath || (getSession(chatId) && getSession(chatId).cwd) || HOME;
 
     const state2 = loadState();
     state2.sessions[chatId] = {
@@ -1336,27 +1664,230 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       started: true,
     };
     saveState(state2);
-    const name = fullMatch ? fullMatch.customTitle : null;
-    const label = name || (fullMatch ? (fullMatch.summary || fullMatch.firstPrompt || '').slice(0, 40) : sessionId.slice(0, 8));
+    const name = fullMatch.customTitle;
+    const label = name || (fullMatch.summary || fullMatch.firstPrompt || '').slice(0, 40) || sessionId.slice(0, 8);
     await bot.sendMessage(chatId, `Resumed: ${label}\nWorkdir: ${cwd}`);
     return;
   }
 
-  if (text === '/agent') {
-    const projects = config.projects || {};
-    const entries = Object.entries(projects).filter(([, p]) => p.cwd);
-    if (entries.length === 0) {
-      await bot.sendMessage(chatId, 'No projects configured. Add projects with cwd to daemon.yaml.');
+  // ─── /agent 命令体系 ────────────────────────────────────────────────
+  // /agent bind <名称> [目录] — 把当前群绑定为专属 agent 频道
+  // /agent list              — 查看所有已配置的 agent
+  // /agent new               — 多步向导新建 agent
+  // /agent edit              — 编辑当前 agent 的 CLAUDE.md 角色定义
+  // /agent reset             — 删除当前 agent 的角色 section
+  // /agent                   — 弹出 agent 切换选择器（无参数）
+  // ─────────────────────────────────────────────────────────────────────
+
+  // 处理 /agent new 多步向导状态机中的文本输入（name/desc 步骤）
+  {
+    const flow = pendingAgentFlows.get(String(chatId));
+    if (flow && flow.step === 'name' && text && !text.startsWith('/')) {
+      // 步骤2: 用户回复了 Agent 名称
+      flow.name = text.trim();
+      flow.step = 'desc';
+      pendingAgentFlows.set(String(chatId), flow);
+      await bot.sendMessage(chatId, `好的，Agent 名称是「${flow.name}」\n\n请描述这个 Agent 的角色和职责（用自然语言）：`);
       return;
     }
-    const currentSession = getSession(chatId);
-    const currentCwd = currentSession?.cwd ? path.resolve(expandPath(currentSession.cwd)) : null;
-    const buttons = entries.map(([key, p]) => {
-      const projCwd = normalizeCwd(p.cwd);
-      const active = currentCwd && path.resolve(projCwd) === currentCwd ? ' ◀' : '';
-      return [{ text: `${p.icon || '🤖'} ${p.name || key}${active}`, callback_data: `/cd ${projCwd}` }];
-    });
-    await bot.sendButtons(chatId, '切换对话对象', buttons);
+    if (flow && flow.step === 'desc' && text && !text.startsWith('/')) {
+      // 步骤3: 用户回复了角色描述
+      pendingAgentFlows.delete(String(chatId));
+      const { dir, name } = flow;
+      const description = text.trim();
+      await bot.sendMessage(chatId, `⏳ 正在配置 Agent「${name}」，稍等...`);
+      try {
+        // a. 写入 config（projects 里新增条目）并绑定当前群
+        await doBindAgent(bot, chatId, name, dir);
+        // b. 智能合并 CLAUDE.md
+        const mergeResult = await mergeAgentRole(dir, description);
+        if (mergeResult.error) {
+          await bot.sendMessage(chatId, `⚠️ CLAUDE.md 合并失败: ${mergeResult.error}，其他配置已保存`);
+        } else if (mergeResult.created) {
+          await bot.sendMessage(chatId, `📝 已创建 CLAUDE.md 并写入角色定义`);
+        } else {
+          await bot.sendMessage(chatId, `📝 已将角色定义合并进现有 CLAUDE.md`);
+        }
+      } catch (e) {
+        await bot.sendMessage(chatId, `❌ 创建 Agent 失败: ${e.message}`);
+      }
+      return;
+    }
+  }
+
+  // /agent edit 状态机：等待用户输入修改意图
+  {
+    const editFlow = pendingAgentFlows.get(String(chatId) + ':edit');
+    if (editFlow && text && !text.startsWith('/')) {
+      pendingAgentFlows.delete(String(chatId) + ':edit');
+      const { cwd } = editFlow;
+      await bot.sendMessage(chatId, '⏳ 正在更新 CLAUDE.md...');
+      const mergeResult = await mergeAgentRole(cwd, text.trim());
+      if (mergeResult.error) {
+        await bot.sendMessage(chatId, `❌ 更新失败: ${mergeResult.error}`);
+      } else {
+        await bot.sendMessage(chatId, '✅ CLAUDE.md 已更新');
+      }
+      return;
+    }
+  }
+
+  if (text === '/agent' || text.startsWith('/agent ')) {
+    const agentArg = text === '/agent' ? '' : text.slice(7).trim();
+    const agentParts = agentArg.split(/\s+/);
+    const agentSub = agentParts[0]; // bind / list / new / edit / reset / ''
+
+    // /agent bind <名称> [目录] — 替代旧的 /bind
+    if (agentSub === 'bind') {
+      const bindName = agentParts[1];
+      const bindCwd = agentParts.slice(2).join(' ');
+      if (!bindName) {
+        await bot.sendMessage(chatId, '用法: /agent bind <名称> [工作目录]\n例: /agent bind 小美 ~/\n或:  /agent bind 教授  (弹出目录选择)');
+        return;
+      }
+      if (!bindCwd) {
+        pendingBinds.set(String(chatId), bindName);
+        await sendDirPicker(bot, chatId, 'bind', `为「${bindName}」选择工作目录:`);
+        return;
+      }
+      await doBindAgent(bot, chatId, bindName, expandPath(bindCwd));
+      return;
+    }
+
+    // /agent list — 查看所有已配置的 agent
+    if (agentSub === 'list') {
+      const cfg = loadConfig();
+      const projects = cfg.projects || {};
+      const entries = Object.entries(projects).filter(([, p]) => p.cwd);
+      if (entries.length === 0) {
+        await bot.sendMessage(chatId, '暂无已配置的 Agent。\n使用 /agent new 创建，或 /agent bind <名称> 绑定目录。');
+        return;
+      }
+      // 找出当前群绑定的 agent
+      const agentMap = { ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}), ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}) };
+      const boundKey = agentMap[String(chatId)];
+      const lines = ['📋 已配置的 Agent：', ''];
+      for (const [key, p] of entries) {
+        const icon = p.icon || '🤖';
+        const name = p.name || key;
+        const displayCwd = (p.cwd || '').replace(HOME, '~');
+        const bound = key === boundKey ? ' ◀ 当前' : '';
+        lines.push(`${icon} ${name}${bound}`);
+        lines.push(`   目录: ${displayCwd}`);
+        lines.push(`   Key: ${key}`);
+        lines.push('');
+      }
+      await bot.sendMessage(chatId, lines.join('\n').trimEnd());
+      return;
+    }
+
+    // /agent new — 多步向导新建 agent
+    if (agentSub === 'new') {
+      pendingAgentFlows.set(String(chatId), { step: 'dir' });
+      await sendBrowse(bot, chatId, 'agent-new', HOME, '步骤1/3：选择这个 Agent 的工作目录');
+      return;
+    }
+
+    // /agent edit — 编辑当前 agent 的 CLAUDE.md 角色定义
+    if (agentSub === 'edit') {
+      const cfg = loadConfig();
+      const agentMap = { ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}), ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}) };
+      const boundKey = agentMap[String(chatId)];
+      const boundProj = boundKey && cfg.projects && cfg.projects[boundKey];
+      if (!boundProj || !boundProj.cwd) {
+        await bot.sendMessage(chatId, '❌ 当前群未绑定 Agent，请先使用 /agent bind 或 /agent new');
+        return;
+      }
+      const cwd = normalizeCwd(boundProj.cwd);
+      const claudeMdPath = path.join(cwd, 'CLAUDE.md');
+      let currentContent = '（CLAUDE.md 不存在）';
+      if (fs.existsSync(claudeMdPath)) {
+        currentContent = fs.readFileSync(claudeMdPath, 'utf8');
+        // 只展示前 500 字符
+        if (currentContent.length > 500) {
+          currentContent = currentContent.slice(0, 500) + '\n...(已截断)';
+        }
+      }
+      pendingAgentFlows.set(String(chatId) + ':edit', { cwd });
+      await bot.sendMessage(chatId, `📄 当前 CLAUDE.md 内容:\n\`\`\`\n${currentContent}\n\`\`\`\n\n请描述你想做的修改（用自然语言，例如：「把角色改成后端工程师，专注 Python」）：`);
+      return;
+    }
+
+    // /agent reset — 删除 CLAUDE.md 里的角色 section
+    if (agentSub === 'reset') {
+      const cfg = loadConfig();
+      const agentMap = { ...(cfg.telegram ? cfg.telegram.chat_agent_map : {}), ...(cfg.feishu ? cfg.feishu.chat_agent_map : {}) };
+      const boundKey = agentMap[String(chatId)];
+      const boundProj = boundKey && cfg.projects && cfg.projects[boundKey];
+      if (!boundProj || !boundProj.cwd) {
+        await bot.sendMessage(chatId, '❌ 当前群未绑定 Agent，请先使用 /agent bind 或 /agent new');
+        return;
+      }
+      const cwd = normalizeCwd(boundProj.cwd);
+      const claudeMdPath = path.join(cwd, 'CLAUDE.md');
+      if (!fs.existsSync(claudeMdPath)) {
+        await bot.sendMessage(chatId, '⚠️ CLAUDE.md 不存在，无需重置');
+        return;
+      }
+      let content = fs.readFileSync(claudeMdPath, 'utf8');
+      // 用正则删除 ## Agent 角色 section（到下一个 ## 或文件末尾）
+      content = content.replace(/(?:^|\n)## Agent 角色\n[\s\S]*?(?=\n## |$)/, '').trimStart();
+      // 如果没匹配到，给出提示
+      if (content === fs.readFileSync(claudeMdPath, 'utf8').trimStart()) {
+        await bot.sendMessage(chatId, '⚠️ 未找到「## Agent 角色」section，CLAUDE.md 未修改');
+        return;
+      }
+      fs.writeFileSync(claudeMdPath, content, 'utf8');
+      await bot.sendMessage(chatId, '✅ 已删除角色 section，请重新发送角色描述（/agent edit 或 /agent new）');
+      return;
+    }
+
+    // /agent（无参数）— 弹出 agent 切换选择器
+    {
+      const projects = config.projects || {};
+      const entries = Object.entries(projects).filter(([, p]) => p.cwd);
+      if (entries.length === 0) {
+        await bot.sendMessage(chatId, '暂无已配置的 Agent。\n使用 /agent new 新建，或 /agent bind <名称> 绑定目录。');
+        return;
+      }
+      const currentSession = getSession(chatId);
+      const currentCwd = currentSession?.cwd ? path.resolve(expandPath(currentSession.cwd)) : null;
+      const buttons = entries.map(([key, p]) => {
+        const projCwd = normalizeCwd(p.cwd);
+        const active = currentCwd && path.resolve(projCwd) === currentCwd ? ' ◀' : '';
+        return [{ text: `${p.icon || '🤖'} ${p.name || key}${active}`, callback_data: `/cd ${projCwd}` }];
+      });
+      await bot.sendButtons(chatId, '切换对话对象', buttons);
+      return;
+    }
+  }
+
+  // --- /bind-dir <path>: /agent bind 目录选择器的内部回调 ---
+  if (text.startsWith('/bind-dir ')) {
+    const dirPath = expandPath(text.slice(10).trim());
+    const agentName = pendingBinds.get(String(chatId));
+    if (!agentName) {
+      await bot.sendMessage(chatId, '❌ 没有待完成的 /agent bind，请重新发送');
+      return;
+    }
+    pendingBinds.delete(String(chatId));
+    await doBindAgent(bot, chatId, agentName, dirPath);
+    return;
+  }
+
+  // --- /agent-dir <path>: /agent new 向导的目录选择回调 ---
+  if (text.startsWith('/agent-dir ')) {
+    const dirPath = expandPath(text.slice(11).trim());
+    const flow = pendingAgentFlows.get(String(chatId));
+    if (!flow || flow.step !== 'dir') {
+      await bot.sendMessage(chatId, '❌ 没有待完成的 /agent new，请重新发送 /agent new');
+      return;
+    }
+    flow.dir = dirPath;
+    flow.step = 'name';
+    pendingAgentFlows.set(String(chatId), flow);
+    const displayPath = dirPath.replace(HOME, '~');
+    await bot.sendMessage(chatId, `✓ 已选择目录：${displayPath}\n\n步骤2/3：给这个 Agent 起个名字？`);
     return;
   }
 
@@ -1524,6 +2055,108 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     return;
   }
 
+  // /dispatch — inter-agent task dispatch
+  if (text.startsWith('/dispatch')) {
+    const args = text.slice('/dispatch'.length).trim();
+
+    if (!args || args === 'status') {
+      // Show dispatch status from log
+      let msg = '📬 Agent Dispatch 状态\n─────────────\n';
+      for (const [key, proj] of Object.entries(config.projects || {})) {
+        msg += `${proj.icon || '🤖'} ${proj.name || key} — 就绪\n`;
+      }
+      if (fs.existsSync(DISPATCH_LOG)) {
+        const lines = fs.readFileSync(DISPATCH_LOG, 'utf8').trim().split('\n').filter(Boolean);
+        const recent = lines.slice(-5).reverse();
+        if (recent.length > 0) {
+          msg += `\n📤 最近派发:\n`;
+          for (const l of recent) {
+            try {
+              const e = JSON.parse(l);
+              msg += `${e.from}→${e.to}: ${(e.payload.title || e.payload.prompt || '').slice(0, 40)} (${e.type})\n`;
+            } catch { /* skip */ }
+          }
+        }
+      }
+      await bot.sendMessage(chatId, msg.trim());
+      return;
+    }
+
+    if (args === 'log') {
+      if (!fs.existsSync(DISPATCH_LOG)) { await bot.sendMessage(chatId, '无派发记录。'); return; }
+      const lines = fs.readFileSync(DISPATCH_LOG, 'utf8').trim().split('\n').filter(Boolean);
+      const recent = lines.slice(-10).reverse();
+      let msg = '📤 最近 10 条派发记录:\n';
+      for (const l of recent) {
+        try {
+          const e = JSON.parse(l);
+          const time = new Date(e.dispatched_at).toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai', hour12: false });
+          msg += `[${time}] ${e.from}→${e.to} ${e.type}: ${(e.payload.title || e.payload.prompt || '').slice(0, 40)}\n`;
+        } catch { /* skip */ }
+      }
+      await bot.sendMessage(chatId, msg.trim());
+      return;
+    }
+
+    // /dispatch to <agent> <prompt>
+    const toMatch = args.match(/^to\s+(\S+)\s+(.+)$/s);
+    if (toMatch) {
+      const targetName = toMatch[1];
+      const prompt = toMatch[2].trim();
+
+      // Resolve target by project key or nickname
+      let targetKey = null;
+      for (const [key, proj] of Object.entries(config.projects || {})) {
+        if (key === targetName || (proj.nicknames || []).some(n => n === targetName)) {
+          targetKey = key;
+          break;
+        }
+      }
+      if (!targetKey) {
+        await bot.sendMessage(chatId, `未找到 agent: ${targetName}\n可用: ${Object.keys(config.projects || {}).join(', ')}`);
+        return;
+      }
+
+      // Determine sender from current chat's project mapping
+      const chatAgentMap = (config.feishu && config.feishu.chat_agent_map) || {};
+      const senderKey = chatAgentMap[chatId] || 'user';
+
+      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 text = `${projInfo.icon || '📬'} **${projInfo.name || targetKey}**\n\n${output.slice(0, 2000)}`;
+        bot.sendMarkdown(targetChatId, text)
+          .then(() => log('INFO', `Dispatch reply sent to ${targetChatId}`))
+          .catch(e => {
+            log('WARN', `Dispatch sendMarkdown failed: ${e.message}, trying sendMessage`);
+            bot.sendMessage(targetChatId, text)
+              .catch(e2 => log('ERROR', `Dispatch reply failed: ${e2.message}`));
+          });
+      };
+
+      const result = dispatchTask(targetKey, {
+        from: senderKey,
+        type: 'task',
+        priority: 'normal',
+        payload: { title: prompt.slice(0, 60), prompt },
+        callback: false,
+      }, config, replyFn);
+
+      if (result.success) {
+        await bot.sendMessage(chatId, `✅ 已派发给 ${projInfo.name || targetName}，执行中…`);
+      } else {
+        await bot.sendMessage(chatId, `❌ 派发失败: ${result.error}`);
+      }
+      return;
+    }
+
+    await bot.sendMessage(chatId, '用法:\n/dispatch status — 查看状态\n/dispatch log — 查看记录\n/dispatch to <agent> <任务内容>');
+    return;
+  }
+
   if (text.startsWith('/run ')) {
     const cd = checkCooldown(chatId);
     if (!cd.ok) { await bot.sendMessage(chatId, `Cooldown: ${cd.wait}s`); return; }
@@ -1583,7 +2216,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
   if (text === '/budget') {
     const limit = (config.budget && config.budget.daily_limit) || 50000;
     const used = state.budget.tokens_used;
-    await bot.sendMessage(chatId, `Budget: ${used}/${limit} tokens (${((used/limit)*100).toFixed(1)}%)`);
+    await bot.sendMessage(chatId, `Budget: ${used}/${limit} tokens (${((used / limit) * 100).toFixed(1)}%)`);
     return;
   }
 
@@ -1597,7 +2230,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     const proc = activeProcesses.get(chatId);
     if (proc && proc.child) {
       proc.aborted = true;
-      proc.child.kill('SIGINT');
+      try { process.kill(-proc.child.pid, 'SIGINT'); } catch { proc.child.kill('SIGINT'); }
       await bot.sendMessage(chatId, '⏹ Stopping Claude...');
     } else {
       await bot.sendMessage(chatId, 'No active task to stop.');
@@ -1616,7 +2249,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     const proc = activeProcesses.get(chatId);
     if (proc && proc.child) {
       proc.aborted = true;
-      proc.child.kill('SIGINT');
+      try { process.kill(-proc.child.pid, 'SIGINT'); } catch { proc.child.kill('SIGINT'); }
     }
     const session = getSession(chatId);
     const name = session ? getSessionName(session.id) : null;
@@ -1801,7 +2434,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     const proc = activeProcesses.get(chatId);
     if (proc && proc.child) {
       proc.aborted = true;
-      proc.child.kill('SIGINT');
+      try { process.kill(-proc.child.pid, 'SIGINT'); } catch { proc.child.kill('SIGINT'); }
     }
 
     const session = getSession(chatId);
@@ -1814,9 +2447,16 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     const arg = text.slice(5).trim();
 
     // Git-based undo: list checkpoints or reset to one
-    const checkpoints = listCheckpoints(cwd);
+    // 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, '⚠️ 没有可用的回退点（无 checkpoint commit）');
+      await bot.sendMessage(chatId, `⚠️ 还没有回退点\n📁 ${path.basename(cwd)}\n\nCheckpoint 在 Claude 修改文件前自动创建，先让 Claude 做点改动再试`);
       return;
     }
 
@@ -1824,18 +2464,15 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       // /undo (no arg) — show recent checkpoints to pick from
       const recent = checkpoints.slice(0, 6); // newest first (already sorted)
       if (bot.sendButtons) {
-        const buttons = recent.map((cp, idx) => {
-          // Extract timestamp from message: "[metame-checkpoint] 2026-02-08T12-34-56"
-          const ts = cp.message.replace(CHECKPOINT_PREFIX, '').trim();
-          const label = ts || cp.hash.slice(0, 8);
+        const buttons = recent.map((cp) => {
+          const label = cpDisplayLabel(cp.message);
           return [{ text: `⏪ ${label}`, callback_data: `/undo ${cp.hash.slice(0, 10)}` }];
         });
         await bot.sendButtons(chatId, `📌 ${checkpoints.length} 个回退点 (git checkpoint):`, buttons);
       } else {
         let msg = '回退到哪个点？回复 /undo <hash>\n\n';
         recent.forEach(cp => {
-          const ts = cp.message.replace(CHECKPOINT_PREFIX, '').trim();
-          msg += `${cp.hash.slice(0, 8)} ${ts}\n`;
+          msg += `${cp.hash.slice(0, 8)} ${cpDisplayLabel(cp.message)}\n`;
         });
         await bot.sendMessage(chatId, msg);
       }
@@ -1868,13 +2505,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
           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 = match.message.replace(CHECKPOINT_PREFIX, '').trim().replace(/-/g, (m, offset) => {
-            // Convert "2026-02-08T12-34-56" back to approximate ISO
-            if (offset === 4 || offset === 7) return '-'; // date separators
-            if (offset === 10) return 'T';
-            if (offset === 13 || offset === 16) return ':';
-            return m;
-          });
+          const cpTs = cpExtractTimestamp(match.message);
           const cpTime = new Date(cpTs).getTime();
           if (cpTime) {
             // Find the first user message AFTER checkpoint time → truncate before it
@@ -1890,7 +2521,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
                     break; // Found a message before checkpoint, stop
                   }
                 }
-              } catch {}
+              } catch { }
             }
             if (cutIdx > 0) {
               const kept = lines.slice(0, cutIdx);
@@ -1905,8 +2536,8 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
 
       const fileList = diffFiles ? diffFiles.split('\n').map(f => path.basename(f)).join(', ') : '';
       const fileCount = diffFiles ? diffFiles.split('\n').length : 0;
-      const ts = match.message.replace(CHECKPOINT_PREFIX, '').trim();
-      let msg = `⏪ 已回退到 ${ts}\n🔀 git reset --hard ${match.hash.slice(0, 8)}`;
+      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}`;
       }
@@ -2131,8 +2762,13 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       '/last — 继续电脑上最近的对话',
       '/cd last — 切到电脑最近的项目目录',
       '',
-      '🤖 Agent 切换:',
-      '/agent — 选择对话的项目/Agent',
+      '🤖 Agent 管理:',
+      '/agent — 切换 Agent',
+      '/agent new — 向导新建 Agent',
+      '/agent bind <名称> [目录] — 绑定当前群',
+      '/agent list — 查看所有 Agent',
+      '/agent edit — 编辑当前 Agent 角色',
+      '/agent reset — 重置当前 Agent 角色',
       '',
       '📂 Session 管理:',
       '/new [path] [name] — 新建会话',
@@ -2170,7 +2806,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     const proc = activeProcesses.get(chatId);
     if (proc && proc.child && !proc.aborted) {
       proc.aborted = true;
-      proc.child.kill('SIGINT');
+      try { process.kill(-proc.child.pid, 'SIGINT'); } catch { proc.child.kill('SIGINT'); }
     }
     // Debounce: wait 5s for more messages before processing
     if (q.timer) clearTimeout(q.timer);
@@ -2209,7 +2845,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     await bot.sendMessage(chatId, 'Daily token budget exceeded.');
     return;
   }
-  await askClaude(bot, chatId, text, config);
+  await askClaude(bot, chatId, text, config, readOnly);
 }
 
 // ---------------------------------------------------------
@@ -2306,6 +2942,61 @@ function _scanAllSessions() {
       const bTime = b.fileMtime || new Date(b.modified).getTime();
       return bTime - aTime;
     });
+
+    // Enrich top N sessions that lack firstPrompt/customTitle by reading jsonl heads
+    const ENRICH_LIMIT = 20;
+    for (let i = 0; i < Math.min(all.length, ENRICH_LIMIT); i++) {
+      const s = all[i];
+      if (s.firstPrompt && s.customTitle) continue;
+      try {
+        const sessionFile = findSessionFile(s.sessionId);
+        if (!sessionFile) continue;
+        // Read first 8KB for firstPrompt, and last 4KB for customTitle
+        const fd = fs.openSync(sessionFile, 'r');
+        const headBuf = Buffer.alloc(8192);
+        const headBytes = fs.readSync(fd, headBuf, 0, 8192, 0);
+        const headStr = headBuf.toString('utf8', 0, headBytes);
+        // Extract firstPrompt from first real user message (skip system-generated)
+        if (!s.firstPrompt) {
+          for (const line of headStr.split('\n')) {
+            if (!line) continue;
+            try {
+              const d = JSON.parse(line);
+              if (d.type === 'user' && d.message && d.userType === 'external') {
+                const content = d.message.content;
+                let raw = '';
+                if (typeof content === 'string') raw = content;
+                else if (Array.isArray(content)) {
+                  const txt = content.find(c => c.type === 'text');
+                  if (txt) raw = txt.text;
+                }
+                // Strip [System hints ...] suffix and <system-reminder> blocks
+                raw = raw.replace(/\n?\[System hints[\s\S]*/i, '').replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '').trim();
+                if (raw && raw.length > 2) { s.firstPrompt = raw.slice(0, 120); break; }
+              }
+            } catch { /* skip line */ }
+          }
+        }
+        // Read tail for customTitle (written by /name command)
+        if (!s.customTitle) {
+          const stat = fs.fstatSync(fd);
+          const tailSize = Math.min(4096, stat.size);
+          const tailBuf = Buffer.alloc(tailSize);
+          fs.readSync(fd, tailBuf, 0, tailSize, stat.size - tailSize);
+          const tailStr = tailBuf.toString('utf8');
+          const tailLines = tailStr.split('\n').reverse();
+          for (const line of tailLines) {
+            if (!line) continue;
+            try {
+              const d = JSON.parse(line);
+              if (d.type === 'custom-title' && d.customTitle) { s.customTitle = d.customTitle; break; }
+            } catch { /* skip */ }
+          }
+        }
+        fs.closeSync(fd);
+      } catch { /* non-fatal */ }
+    }
+
     _sessionCache = all;
     _sessionCacheTime = Date.now();
     return all;
@@ -2368,6 +3059,72 @@ function sessionLabel(s) {
   return `${ago} ${proj ? proj + ': ' : ''}${title || ''} #${shortId}`;
 }
 
+/**
+ * Get the display title for a session using fallback chain: name → summary → firstPrompt
+ */
+function sessionDisplayTitle(s, maxLen) {
+  maxLen = maxLen || 50;
+  // Newlines → space; strip null bytes, surrogates, replacement char, other non-printable control chars
+  const sanitize = (t) => t
+    .replace(/\r?\n/g, ' ')
+    .replace(/[\x00-\x09\x0B\x0C\x0E-\x1F\x7F\uFFFD\uD800-\uDFFF]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (s.customTitle) return sanitize(s.customTitle).slice(0, maxLen);
+  if (s.summary) return sanitize(s.summary).slice(0, maxLen);
+  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);
+  }
+  return '';
+}
+
+/**
+ * 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);
+  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);
+
+  let line = `${index}. `;
+  if (title) line += `${title}${title.length >= 50 ? '..' : ''}`;
+  else line += `(unnamed)`;
+  line += `\n   📁${proj} · ${ago}`;
+  line += `\n   /resume ${shortId}`;
+  return line;
+}
+
+/**
+ * Build Feishu card elements for a list of sessions (used by /sessions and /resume)
+ */
+function buildSessionCardElements(sessions) {
+  const elements = [];
+  sessions.forEach((s, i) => {
+    if (i > 0) elements.push({ tag: 'hr' });
+    const title = sessionDisplayTitle(s, 60);
+    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);
+    let desc = `**${i + 1}. ${title || '(unnamed)'}**\n📁${proj} · ${ago}`;
+    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}` } }] });
+  });
+  return elements;
+}
+
 /**
  * Extract unique project directories from session history, sorted by most recent activity.
  * Returns [{path, label}] for button display.
@@ -2519,7 +3276,10 @@ function spawnClaudeAsync(args, input, cwd, timeoutMs = 300000) {
 
     const timer = setTimeout(() => {
       killed = true;
-      child.kill('SIGTERM');
+      try { process.kill(-child.pid, 'SIGTERM'); } catch { child.kill('SIGTERM'); }
+      setTimeout(() => {
+        try { process.kill(-child.pid, 'SIGKILL'); } catch { try { child.kill('SIGKILL'); } catch { } }
+      }, 5000);
     }, timeoutMs);
 
     child.stdout.on('data', (data) => { stdout += data.toString(); });
@@ -2580,9 +3340,50 @@ const CONTENT_EXTENSIONS = new Set([
 // Active Claude processes per chat (for /stop)
 const activeProcesses = new Map(); // chatId -> { child, aborted }
 
+// 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() {
+  try {
+    const pids = {};
+    for (const [chatId, proc] of activeProcesses) {
+      if (proc.child && proc.child.pid) pids[chatId] = proc.child.pid;
+    }
+    fs.writeFileSync(ACTIVE_PIDS_FILE, JSON.stringify(pids), 'utf8');
+  } catch { }
+}
+function getProcessName(pid) {
+  try {
+    return execSync(`ps -p ${pid} -o comm=`, { encoding: 'utf8', timeout: 2000 }).trim();
+  } catch { return null; }
+}
+function killOrphanPids() {
+  try {
+    if (!fs.existsSync(ACTIVE_PIDS_FILE)) return;
+    const pids = JSON.parse(fs.readFileSync(ACTIVE_PIDS_FILE, 'utf8'));
+    for (const [chatId, pid] of Object.entries(pids)) {
+      try {
+        // Safety: only kill if PID still belongs to a claude process (prevent PID reuse accidents)
+        const comm = getProcessName(pid);
+        if (!comm || !comm.includes('claude')) {
+          log('WARN', `Skipping PID ${pid} (chatId: ${chatId}): process is "${comm}", not claude`);
+          continue;
+        }
+        process.kill(pid, 'SIGKILL');
+        log('INFO', `Killed orphan claude PID ${pid} (chatId: ${chatId})`);
+      } catch { }
+    }
+    fs.unlinkSync(ACTIVE_PIDS_FILE);
+  } catch { }
+}
+
+
 // Pending /bind flows: waiting for user to pick a directory
 const pendingBinds = new Map(); // chatId -> agentName
 
+// Pending /agent new 多步向导状态机
+// chatId -> { step: 'dir'|'name'|'desc', dir: string, name: string }
+const pendingAgentFlows = new Map();
+
 // Message queue for messages received while a task is running
 const messageQueue = new Map(); // chatId -> { messages: string[], notified: false }
 
@@ -2593,11 +3394,54 @@ let caffeinateProcess = null;
 const CHECKPOINT_PREFIX = '[metame-checkpoint]';
 const MAX_CHECKPOINTS = 20;
 
+/**
+ * Extract ISO timestamp string from a checkpoint commit message.
+ * Handles both formats:
+ *   old: "[metame-checkpoint] 2026-02-08T10-30-00"
+ *   new: "[metame-checkpoint] Before: xxx (2026-02-08T10-30-00)"
+ */
+function cpExtractTimestamp(message) {
+  // New format: timestamp in parens at end
+  const parenMatch = message.match(/\((\d{4}-\d{2}-\d{2}T[\d-]{8})\)$/);
+  if (parenMatch) {
+    return parenMatch[1].replace(/-/g, (m, offset) => {
+      if (offset === 4 || offset === 7) return '-';
+      if (offset === 10) return 'T';
+      if (offset === 13 || offset === 16) return ':';
+      return m;
+    });
+  }
+  // Old format: timestamp directly after prefix
+  const raw = message.replace(CHECKPOINT_PREFIX, '').trim();
+  return raw.replace(/-/g, (m, offset) => {
+    if (offset === 4 || offset === 7) return '-';
+    if (offset === 10) return 'T';
+    if (offset === 13 || offset === 16) return ':';
+    return m;
+  });
+}
+
+/**
+ * Human-readable display label for a checkpoint (for /undo list buttons).
+ * Shows "Before: <label> (HH:MM)" or just the timestamp.
+ */
+function cpDisplayLabel(message) {
+  // New format: "[metame-checkpoint] Before: xxx (2026-02-08T10-30-00)"
+  const newMatch = message.match(/Before:\s*(.+?)\s*\((\d{4}-\d{2}-\d{2}T([\d-]{8}))\)$/);
+  if (newMatch) {
+    const label = newMatch[1].slice(0, 30);
+    const time = newMatch[3].replace(/-/g, ':').slice(0, 5); // HH:MM
+    return `${label} (${time})`;
+  }
+  // Old format: just the timestamp
+  return message.replace(CHECKPOINT_PREFIX, '').trim();
+}
+
 /**
  * Create a git checkpoint commit before a Claude turn.
  * Returns the commit hash or null if nothing to commit / not a git repo.
  */
-function gitCheckpoint(cwd) {
+function gitCheckpoint(cwd, label) {
   try {
     // Quick check: is this a git repo?
     execSync('git rev-parse --is-inside-work-tree', { cwd, stdio: 'ignore' });
@@ -2607,10 +3451,14 @@ function gitCheckpoint(cwd) {
     const status = execSync('git status --porcelain', { cwd, encoding: 'utf8', timeout: 5000 }).trim();
     if (!status) return null; // Working tree clean, no checkpoint needed
     const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-    const msg = `${CHECKPOINT_PREFIX} ${ts}`;
+    // Include user prompt as label so /undo list is human-readable
+    const safeLabel = label
+      ? ' Before: ' + label.replace(/["\n\r]/g, ' ').slice(0, 60).trim()
+      : '';
+    const msg = `${CHECKPOINT_PREFIX}${safeLabel} (${ts})`;
     execSync(`git commit -m "${msg}" --no-verify`, { cwd, stdio: 'ignore', timeout: 10000 });
     const hash = execSync('git rev-parse HEAD', { cwd, encoding: 'utf8', timeout: 3000 }).trim();
-    log('INFO', `Git checkpoint: ${hash.slice(0, 8)} in ${path.basename(cwd)}`);
+    log('INFO', `Git checkpoint: ${hash.slice(0, 8)} in ${path.basename(cwd)}${safeLabel}`);
     return hash;
   } catch {
     return null; // Not a git repo or git error — silently skip
@@ -2623,7 +3471,7 @@ function gitCheckpoint(cwd) {
 function listCheckpoints(cwd, limit = 20) {
   try {
     const raw = execSync(
-      `git log --oneline --all --grep="${CHECKPOINT_PREFIX}" -n ${limit} --format="%H %s"`,
+      `git log --fixed-strings --oneline --all --grep="${CHECKPOINT_PREFIX}" -n ${limit} --format="%H %s"`,
       { cwd, encoding: 'utf8', timeout: 5000 }
     ).trim();
     if (!raw) return [];
@@ -2688,12 +3536,14 @@ function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, ch
     const child = spawn('claude', streamArgs, {
       cwd,
       stdio: ['pipe', 'pipe', 'pipe'],
+      detached: true, // Create new process group so killing -pid kills all sub-agents too
       env: { ...process.env, ...getActiveProviderEnv(), CLAUDECODE: undefined },
     });
 
     // Track active process for /stop
     if (chatId) {
       activeProcesses.set(chatId, { child, aborted: false });
+      saveActivePids(); // Fix3: persist PID to disk
     }
 
     let buffer = '';
@@ -2703,10 +3553,15 @@ function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, ch
     let lastStatusTime = 0;
     const STATUS_THROTTLE = STATUS_THROTTLE_MS;
     const writtenFiles = []; // Track files created/modified by Write tool
+    const toolUsageLog = []; // Track all tool invocations for skill evolution
 
     const timer = setTimeout(() => {
       killed = true;
-      child.kill('SIGTERM');
+      log('WARN', `Claude timeout (${timeoutMs / 60000}min) for chatId ${chatId} — killing process group`);
+      try { process.kill(-child.pid, 'SIGTERM'); } catch { child.kill('SIGTERM'); }
+      setTimeout(() => {
+        try { process.kill(-child.pid, 'SIGKILL'); } catch { try { child.kill('SIGKILL'); } catch { } }
+      }, 5000);
     }, timeoutMs);
 
     child.stdout.on('data', (data) => {
@@ -2735,6 +3590,13 @@ function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, ch
               if (block.type === 'tool_use') {
                 const toolName = block.name || 'Tool';
 
+                // Track tool usage for skill evolution
+                const toolEntry = { tool: toolName };
+                if (toolName === 'Skill' && block.input?.skill) toolEntry.skill = block.input.skill;
+                else if (block.input?.command) toolEntry.context = block.input.command.slice(0, 50);
+                else if (block.input?.file_path) toolEntry.context = path.basename(block.input.file_path);
+                if (toolUsageLog.length < 50) toolUsageLog.push(toolEntry);
+
                 // Track files written by Write tool
                 if (toolName === 'Write' && block.input?.file_path) {
                   const filePath = block.input.file_path;
@@ -2799,7 +3661,7 @@ function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, ch
                     : `${displayEmoji} ${displayName}...`;
 
                   if (onStatus) {
-                    onStatus(status).catch(() => {});
+                    onStatus(status).catch(() => { });
                   }
                 }
               }
@@ -2834,23 +3696,23 @@ function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, ch
       // Clean up active process tracking
       const proc = chatId ? activeProcesses.get(chatId) : null;
       const wasAborted = proc && proc.aborted;
-      if (chatId) activeProcesses.delete(chatId);
+      if (chatId) { activeProcesses.delete(chatId); saveActivePids(); } // Fix3
 
       if (wasAborted) {
-        resolve({ output: finalResult || null, error: 'Stopped by user', files: writtenFiles });
+        resolve({ output: finalResult || null, error: 'Stopped by user', files: writtenFiles, toolUsageLog });
       } else if (killed) {
-        resolve({ output: finalResult || null, error: 'Timeout: Claude took too long', files: writtenFiles });
+        resolve({ output: finalResult || null, error: 'Timeout: Claude took too long', files: writtenFiles, toolUsageLog });
       } else if (code !== 0) {
-        resolve({ output: finalResult || null, error: stderr || `Exit code ${code}`, files: writtenFiles });
+        resolve({ output: finalResult || null, error: stderr || `Exit code ${code}`, files: writtenFiles, toolUsageLog });
       } else {
-        resolve({ output: finalResult || '', error: null, files: writtenFiles });
+        resolve({ output: finalResult || '', error: null, files: writtenFiles, toolUsageLog });
       }
     });
 
     child.on('error', (err) => {
       clearTimeout(timer);
-      if (chatId) activeProcesses.delete(chatId);
-      resolve({ output: null, error: err.message, files: [] });
+      if (chatId) { activeProcesses.delete(chatId); saveActivePids(); } // Fix3
+      resolve({ output: null, error: err.message, files: [], toolUsageLog: [] });
     });
 
     // Write input and close stdin
@@ -2897,7 +3759,7 @@ function lazyDistill() {
  * Shared ask logic — full Claude Code session (stateful, with tools)
  * Now uses spawn (async) instead of execSync to allow parallel requests.
  */
-async function askClaude(bot, chatId, prompt, config) {
+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 */ }
@@ -2909,9 +3771,9 @@ async function askClaude(bot, chatId, prompt, config) {
   } catch (e) {
     log('ERROR', `Failed to send ack to ${chatId}: ${e.message}`);
   }
-  await bot.sendTyping(chatId).catch(() => {});
+  await bot.sendTyping(chatId).catch(() => { });
   const typingTimer = setInterval(() => {
-    bot.sendTyping(chatId).catch(() => {});
+    bot.sendTyping(chatId).catch(() => { });
   }, 4000);
 
   // Agent nickname routing: "贾维斯" / "小美，帮我..." → switch project session
@@ -2932,7 +3794,8 @@ async function askClaude(bot, chatId, prompt, config) {
   }
 
   // Skill routing: detect skill first, then decide session
-  const skill = routeSkill(prompt);
+  // BUT: if agent was explicitly addressed by nickname, don't let skill routing hijack the session
+  const skill = agentMatch ? null : routeSkill(prompt);
 
   // Skills with dedicated pinned sessions (reused across days, no re-injection needed)
   const PINNED_SKILL_SESSIONS = new Set(['macos-mail-calendar', 'skill-manager']);
@@ -3015,7 +3878,8 @@ async function askClaude(bot, chatId, prompt, config) {
   const fullPrompt = routedPrompt + daemonHint;
 
   // Git checkpoint before Claude modifies files (for /undo)
-  gitCheckpoint(session.cwd);
+  // Pass the user prompt as label so checkpoint list is human-readable
+  gitCheckpoint(session.cwd, prompt);
 
   // Use streaming mode to show progress
   // Telegram: edit status msg in-place; Feishu: edit or fallback to new messages
@@ -3037,15 +3901,41 @@ async function askClaude(bot, chatId, prompt, config) {
     } catch { /* ignore status update failures */ }
   };
 
-  const { output, error, files } = await spawnClaudeStreaming(args, fullPrompt, session.cwd, onStatus, 600000, chatId);
+  const { output, error, files, toolUsageLog } = await spawnClaudeStreaming(args, fullPrompt, session.cwd, onStatus, 600000, chatId);
   clearInterval(typingTimer);
+
+  // Skill evolution: capture signal + hot path heuristic check
+  if (skillEvolution) {
+    try {
+      const signal = skillEvolution.extractSkillSignal(fullPrompt, output, error, files, session.cwd, toolUsageLog);
+      if (signal) {
+        skillEvolution.appendSkillSignal(signal);
+        skillEvolution.checkHotEvolution(signal);
+      }
+    } catch (e) { log('WARN', `Skill evolution signal capture failed: ${e.message}`); }
+  }
+
   // Clean up status message
   if (statusMsgId && bot.deleteMessage) {
-    bot.deleteMessage(chatId, statusMsgId).catch(() => {});
+    bot.deleteMessage(chatId, statusMsgId).catch(() => { });
   }
 
   // When Claude completes with no text output (pure tool work), send a done notice
   if (output === '' && !error) {
+    // Special case: if dispatch_to was called, send a "forwarded" confirmation
+    const dispatchedTargets = (toolUsageLog || [])
+      .filter(t => t.tool === 'Bash' && typeof t.context === 'string' && t.context.includes('dispatch_to'))
+      .map(t => { const m = t.context.match(/dispatch_to\s+(\S+)/); return m ? m[1] : null; })
+      .filter(Boolean);
+    if (dispatchedTargets.length > 0) {
+      const allProjects = (config && config.projects) || {};
+      const names = dispatchedTargets.map(k => (allProjects[k] && allProjects[k].name) || k).join('、');
+      const doneMsg = await bot.sendMessage(chatId, `✉️ 已转达给 ${names}，处理中…`);
+      if (doneMsg && doneMsg.message_id && session) trackMsgSession(doneMsg.message_id, session);
+      const wasNew = !session.started;
+      if (wasNew) markSessionStarted(chatId);
+      return;
+    }
     const filesDesc = files && files.length > 0 ? `\n修改了 ${files.length} 个文件` : '';
     const doneMsg = await bot.sendMessage(chatId, `✅ 完成${filesDesc}`);
     if (doneMsg && doneMsg.message_id && session) trackMsgSession(doneMsg.message_id, session);
@@ -3098,14 +3988,21 @@ async function askClaude(bot, chatId, prompt, config) {
     }
 
     let replyMsg;
-    if (activeProject && bot.sendCard) {
-      replyMsg = await bot.sendCard(chatId, {
-        title: `${activeProject.icon || '🤖'} ${activeProject.name || ''}`,
-        body: cleanOutput,
-        color: activeProject.color || 'blue',
-      });
-    } else {
-      replyMsg = await bot.sendMarkdown(chatId, cleanOutput);
+    try {
+      if (activeProject && bot.sendCard) {
+        replyMsg = await bot.sendCard(chatId, {
+          title: `${activeProject.icon || '🤖'} ${activeProject.name || ''}`,
+          body: cleanOutput,
+          color: activeProject.color || 'blue',
+        });
+      } else {
+        replyMsg = await bot.sendMarkdown(chatId, cleanOutput);
+      }
+    } catch (sendErr) {
+      log('WARN', `sendCard/sendMarkdown failed (${sendErr.message}), falling back to sendMessage`);
+      try { replyMsg = await bot.sendMessage(chatId, cleanOutput); } catch (e2) {
+        log('ERROR', `sendMessage fallback also failed: ${e2.message}`);
+      }
     }
     if (replyMsg && replyMsg.message_id && session) trackMsgSession(replyMsg.message_id, session);
 
@@ -3113,7 +4010,7 @@ async function askClaude(bot, chatId, prompt, config) {
 
     // Auto-name: if this was the first message and session has no name, generate one
     if (wasNew && !getSessionName(session.id)) {
-      autoNameSession(chatId, session.id, prompt, session.cwd).catch(() => {});
+      autoNameSession(chatId, session.id, prompt, session.cwd).catch(() => { });
     }
   } else {
     const errMsg = error || 'Unknown error';
@@ -3169,6 +4066,9 @@ async function askClaude(bot, chatId, prompt, config) {
   }
 }
 
+// Bind handleCommand for agent dispatch (must come after handleCommand definition)
+setDispatchHandler(handleCommand);
+
 // ---------------------------------------------------------
 // FEISHU BOT BRIDGE
 // ---------------------------------------------------------
@@ -3184,10 +4084,11 @@ async function startFeishuBridge(config, executeTaskByName) {
   try {
     const receiver = await bot.startReceiving(async (chatId, text, event, fileInfo, senderId) => {
       // Security: check whitelist (empty = deny all) — read live config to support hot-reload
-      // Exception: /bind is allowed from any chat so users can self-register new groups
+      // Exception: /bind and /agent bind/new are allowed from any chat so users can self-register new groups
       const liveCfg = loadConfig();
       const allowedIds = (liveCfg.feishu && liveCfg.feishu.allowed_chat_ids) || [];
-      const isBindCmd = text && text.trim().startsWith('/bind');
+      const trimmedText = text && text.trim();
+      const isBindCmd = trimmedText && (trimmedText.startsWith('/agent bind') || trimmedText.startsWith('/agent new'));
       if (!allowedIds.includes(chatId) && !isBindCmd) {
         log('WARN', `Feishu: rejected message from ${chatId}`);
         return;
@@ -3284,7 +4185,7 @@ function killExistingDaemon() {
   } catch {
     // Process doesn't exist or already dead
   }
-  try { fs.unlinkSync(PID_FILE); } catch {}
+  try { fs.unlinkSync(PID_FILE); } catch { }
 }
 
 function writePid() {
@@ -3346,6 +4247,11 @@ async function main() {
   saveState(state);
 
   log('INFO', `MetaMe daemon started (PID: ${process.pid})`);
+  killOrphanPids(); // Fix3: kill any claude processes left by previous daemon
+  // 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}`);
+  }, 60 * 60 * 1000);
 
   // Task executor lookup (always reads fresh config)
   function executeTaskByName(name) {
@@ -3365,20 +4271,24 @@ async function main() {
   let telegramBridge = null;
   let feishuBridge = null;
 
-  // Notification function (sends to all enabled channels)
-  // project: optional { key, name, color, icon } — triggers colored card on Feishu
+  // Notification function
+  // project: optional { key, name, color, icon } — sends to that project's specific chat only
+  // If no project, sends to ALL allowed_chat_ids (use adminNotifyFn for system-only messages)
   const notifyFn = async (message, project = null) => {
-    if (telegramBridge && telegramBridge.bot) {
-      const tgIds = (config.telegram && config.telegram.allowed_chat_ids) || [];
-      for (const chatId of tgIds) {
-        try { await telegramBridge.bot.sendMarkdown(chatId, message); } catch (e) {
-          log('ERROR', `Telegram notify failed ${chatId}: ${e.message}`);
-        }
-      }
-    }
     if (feishuBridge && feishuBridge.bot) {
+      // If a project is specified, only notify chats mapped to that project
+      const chatAgentMap = (config.feishu && config.feishu.chat_agent_map) || {};
       const fsIds = (config.feishu && config.feishu.allowed_chat_ids) || [];
-      for (const chatId of fsIds) {
+      let targetIds;
+      if (project) {
+        // Send only to chats belonging to this project
+        targetIds = fsIds.filter(id => chatAgentMap[id] === project.key);
+        // Fallback: if no mapped chat found, send to first chat (admin)
+        if (targetIds.length === 0) targetIds = fsIds.slice(0, 1);
+      } else {
+        targetIds = fsIds;
+      }
+      for (const chatId of targetIds) {
         try {
           if (project && feishuBridge.bot.sendCard) {
             await feishuBridge.bot.sendCard(chatId, {
@@ -3394,6 +4304,27 @@ async function main() {
         }
       }
     }
+    if (telegramBridge && telegramBridge.bot) {
+      const tgIds = (config.telegram && config.telegram.allowed_chat_ids) || [];
+      for (const chatId of tgIds) {
+        try { await telegramBridge.bot.sendMarkdown(chatId, message); } catch (e) {
+          log('ERROR', `Telegram notify failed ${chatId}: ${e.message}`);
+        }
+      }
+    }
+  };
+
+  // Admin-only notify: system messages sent only to the primary (first) chat
+  const adminNotifyFn = async (message) => {
+    if (feishuBridge && feishuBridge.bot) {
+      const fsIds = (config.feishu && config.feishu.allowed_chat_ids) || [];
+      const adminId = fsIds[0];
+      if (adminId) {
+        try { await feishuBridge.bot.sendMessage(adminId, message); } catch (e) {
+          log('ERROR', `Feishu admin notify failed ${adminId}: ${e.message}`);
+        }
+      }
+    }
   };
 
   // Start heartbeat scheduler
@@ -3427,7 +4358,7 @@ async function main() {
       const r = reloadConfig();
       if (r.success) {
         log('INFO', `Auto-reload OK: ${r.tasks} tasks`);
-        notifyFn(`🔄 Config auto-reloaded. ${r.tasks} heartbeat tasks active.`).catch(() => {});
+        adminNotifyFn(`🔄 Config auto-reloaded. ${r.tasks} heartbeat tasks active.`).catch(() => { });
       } else {
         log('ERROR', `Auto-reload failed: ${r.error}`);
       }
@@ -3435,28 +4366,46 @@ async function main() {
   });
 
   // Auto-restart: watch daemon.js for code changes (hot restart)
+  // If Claude tasks are running, defer restart until they complete.
   const DAEMON_SCRIPT = path.join(METAME_DIR, 'daemon.js');
   const _startTime = Date.now();
   let _restartDebounce = null;
+  let _pendingRestart = false;
   fs.watchFile(DAEMON_SCRIPT, { interval: 3000 }, (curr, prev) => {
     if (curr.mtimeMs === prev.mtimeMs) return;
     // Ignore file changes within 10s of startup (avoids restart loop)
     if (Date.now() - _startTime < 10000) return;
     if (_restartDebounce) clearTimeout(_restartDebounce);
     _restartDebounce = setTimeout(() => {
-      log('INFO', 'daemon.js changed on disk — exiting for restart...');
-      // Don't notify here — the NEW process will notify after startup
-      process.exit(0);
+      if (activeProcesses.size > 0) {
+        // Active Claude tasks running — defer restart
+        log('INFO', `daemon.js changed on disk — deferring restart (${activeProcesses.size} active task(s))`);
+        _pendingRestart = true;
+      } else {
+        log('INFO', 'daemon.js changed on disk — exiting for restart...');
+        process.exit(0);
+      }
     }, 2000);
   });
+  // Hook: after every Claude task completes, check if restart is pending
+  const _origDelete = activeProcesses.delete.bind(activeProcesses);
+  activeProcesses.delete = function(key) {
+    const result = _origDelete(key);
+    if (_pendingRestart && activeProcesses.size === 0) {
+      log('INFO', 'All tasks completed — executing deferred restart...');
+      setTimeout(() => process.exit(0), 500);
+    }
+    return result;
+  };
 
   // Start bridges (both can run simultaneously)
   telegramBridge = await startTelegramBridge(config, executeTaskByName);
   feishuBridge = await startFeishuBridge(config, executeTaskByName);
+  if (feishuBridge) _dispatchBridgeRef = feishuBridge; // store bridge, not bot, so .bot stays live after reconnects
 
   // Notify once on startup (single message, no duplicates)
   await sleep(1500); // Let polling settle
-  await notifyFn('✅ Daemon ready.').catch(() => {});
+  await adminNotifyFn('✅ Daemon ready.').catch(() => { });
 
   // Graceful shutdown
   const shutdown = () => {
@@ -3466,6 +4415,13 @@ async function main() {
     if (heartbeatTimer) clearInterval(heartbeatTimer);
     if (telegramBridge) telegramBridge.stop();
     if (feishuBridge) feishuBridge.stop();
+    // 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 { } }
+      log('INFO', `Shutdown: killed claude process group for chatId ${cid}`);
+    }
+    activeProcesses.clear();
+    try { if (fs.existsSync(ACTIVE_PIDS_FILE)) fs.unlinkSync(ACTIVE_PIDS_FILE); } catch { }
     cleanPid();
     const s = loadState();
     s.pid = null;