metame-cli 1.3.17 → 1.3.20

package/scripts/daemon.js

@@ -26,6 +26,37 @@ 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');
 
+// ---------------------------------------------------------
+// SKILL ROUTING (keyword → /skillname prefix, like metame-desktop)
+// ---------------------------------------------------------
+const SKILL_ROUTES = [
+  { name: 'macos-mail-calendar', pattern: /邮件|邮箱|收件箱|日历|日程|会议|schedule|email|mail|calendar|unread|inbox/i },
+  { name: 'heartbeat-task-manager', pattern: /提醒|remind|闹钟|定时|每[天周月]/i },
+];
+
+function routeSkill(prompt) {
+  for (const r of SKILL_ROUTES) {
+    if (r.pattern.test(prompt)) return r.name;
+  }
+  return null;
+}
+
+// Agent nickname routing: matches "贾维斯" or "贾维斯，帮我..." at message start
+// Returns { key, proj, rest } or null
+function routeAgent(prompt, config) {
+  for (const [key, proj] of Object.entries((config && config.projects) || {})) {
+    if (!proj.cwd || !proj.nicknames) continue;
+    const nicks = Array.isArray(proj.nicknames) ? proj.nicknames : [proj.nicknames];
+    for (const nick of nicks) {
+      const re = new RegExp(`^${nick}[，,、\\s]*`, 'i');
+      if (re.test(prompt.trim())) {
+        return { key, proj, rest: prompt.trim().replace(re, '').trim() };
+      }
+    }
+  }
+  return null;
+}
+
 const yaml = require('./resolve-yaml');
 const { parseInterval, formatRelativeTime, createPathMap } = require('./utils');
 if (!yaml) {
@@ -95,12 +126,34 @@ function backupConfig() {
 
 function restoreConfig() {
   const bak = CONFIG_FILE + '.bak';
-  if (fs.existsSync(bak)) {
+  if (!fs.existsSync(bak)) return false;
+  try {
+    const bakCfg = yaml.load(fs.readFileSync(bak, 'utf8')) || {};
+    // 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 {}
+    for (const adapter of ['feishu', 'telegram']) {
+      if (curCfg[adapter] && bakCfg[adapter]) {
+        const curIds = curCfg[adapter].allowed_chat_ids || [];
+        const bakIds = bakCfg[adapter].allowed_chat_ids || [];
+        // Union of both lists
+        const merged = [...new Set([...bakIds, ...curIds])];
+        bakCfg[adapter].allowed_chat_ids = merged;
+        // Merge chat_agent_map (current takes precedence)
+        bakCfg[adapter].chat_agent_map = Object.assign(
+          {}, bakCfg[adapter].chat_agent_map || {}, curCfg[adapter].chat_agent_map || {}
+        );
+      }
+    }
+    fs.writeFileSync(CONFIG_FILE, yaml.dump(bakCfg, { lineWidth: -1 }), 'utf8');
+    config = loadConfig();
+    return true;
+  } catch {
     fs.copyFileSync(bak, CONFIG_FILE);
     config = loadConfig();
     return true;
   }
-  return false;
 }
 
 let _cachedState = null;
@@ -221,6 +274,11 @@ function checkPrecondition(task) {
 }
 
 function executeTask(task, config) {
+  if (task.enabled === false) {
+    log('INFO', `Skipping disabled task: ${task.name}`);
+    return { success: true, output: '(disabled)', skipped: true };
+  }
+
   const state = loadState();
 
   if (!checkBudget(config, state)) {
@@ -285,39 +343,81 @@ function executeTask(task, config) {
   }
   const fullPrompt = preamble + taskPrompt;
 
-  const claudeArgs = ['-p', '--model', model];
+  const claudeArgs = ['-p', '--model', model, '--dangerously-skip-permissions'];
   for (const t of (task.allowedTools || [])) claudeArgs.push('--allowedTools', t);
-  log('INFO', `Executing task: ${task.name} (model: ${model})`);
+  // Auto-detect MCP config in task cwd or project directory
+  const cwd = task.cwd ? task.cwd.replace(/^~/, HOME) : undefined;
+  const mcpConfig = task.mcp_config
+    ? path.resolve(task.mcp_config.replace(/^~/, HOME))
+    : cwd && fs.existsSync(path.join(cwd, '.mcp.json'))
+      ? path.join(cwd, '.mcp.json')
+      : null;
+  if (mcpConfig) claudeArgs.push('--mcp-config', mcpConfig);
+
+  // Persistent session: reuse same session across runs (for tasks like weekly-review)
+  if (task.persistent_session) {
+    const savedSessionId = state.tasks[task.name]?.session_id;
+    if (savedSessionId) {
+      claudeArgs.push('--resume', savedSessionId);
+      log('INFO', `Executing task: ${task.name} (model: ${model}, resuming session ${savedSessionId.slice(0, 8)}${mcpConfig ? ', mcp: ' + path.basename(mcpConfig) : ''})`);
+    } else {
+      const newSessionId = crypto.randomUUID();
+      claudeArgs.push('--session-id', newSessionId);
+      if (!state.tasks[task.name]) state.tasks[task.name] = {};
+      state.tasks[task.name].session_id = newSessionId;
+      saveState(state);
+      log('INFO', `Executing task: ${task.name} (model: ${model}, new session ${newSessionId.slice(0, 8)}${mcpConfig ? ', mcp: ' + path.basename(mcpConfig) : ''})`);
+    }
+  } else {
+    log('INFO', `Executing task: ${task.name} (model: ${model}${mcpConfig ? ', mcp: ' + path.basename(mcpConfig) : ''})`);
+  }
 
   try {
     const output = execFileSync('claude', claudeArgs, {
       input: fullPrompt,
       encoding: 'utf8',
-      timeout: 120000, // 2 min timeout
-      maxBuffer: 1024 * 1024,
-      env: { ...process.env, ...getDaemonProviderEnv() },
+      timeout: task.timeout || 120000,
+      maxBuffer: 5 * 1024 * 1024,
+      ...(cwd && { cwd }),
+      env: { ...process.env, ...getDaemonProviderEnv(), CLAUDECODE: undefined },
     }).trim();
 
     // Rough token estimate: ~4 chars per token for input + output
     const estimatedTokens = Math.ceil((fullPrompt.length + output.length) / 4);
     recordTokens(state, estimatedTokens);
 
-    // Record task result
+    // 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);
 
     log('INFO', `Task ${task.name} completed (est. ${estimatedTokens} tokens)`);
     return { success: true, output, tokens: estimatedTokens };
   } catch (e) {
-    log('ERROR', `Task ${task.name} failed: ${e.message}`);
+    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',
+      };
+      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: e.message.slice(0, 200),
+      error: errMsg.slice(0, 200),
+      ...(prevSid && { session_id: prevSid }),
     };
     saveState(state);
     return { success: false, error: e.message, output: '' };
@@ -350,21 +450,28 @@ function executeWorkflow(task, config) {
   const outputs = [];
   let totalTokens = 0;
   const allowed = task.allowedTools || [];
+  // Auto-detect MCP config in task cwd
+  const mcpConfig = task.mcp_config
+    ? path.resolve(task.mcp_config.replace(/^~/, HOME))
+    : fs.existsSync(path.join(cwd, '.mcp.json'))
+      ? path.join(cwd, '.mcp.json')
+      : null;
 
-  log('INFO', `Workflow ${task.name}: ${steps.length} steps, session ${sessionId.slice(0, 8)}`);
+  log('INFO', `Workflow ${task.name}: ${steps.length} steps, session ${sessionId.slice(0, 8)}${mcpConfig ? ', mcp: ' + path.basename(mcpConfig) : ''}`);
 
   for (let i = 0; i < steps.length; i++) {
     const step = steps[i];
     let prompt = (step.skill ? `/${step.skill} ` : '') + (step.prompt || '');
     if (i === 0 && precheck.context) prompt += `\n\n相关数据:\n\`\`\`\n${precheck.context}\n\`\`\``;
-    const args = ['-p', '--model', model];
+    const args = ['-p', '--model', model, '--dangerously-skip-permissions'];
     for (const tool of allowed) args.push('--allowedTools', tool);
+    if (mcpConfig) args.push('--mcp-config', mcpConfig);
     args.push(i === 0 ? '--session-id' : '--resume', sessionId);
 
     log('INFO', `Workflow ${task.name} step ${i + 1}/${steps.length}: ${step.skill || 'prompt'}`);
     try {
-      const output = execSync(`claude ${args.join(' ')}`, {
-        input: prompt, encoding: 'utf8', timeout: step.timeout || 300000, maxBuffer: 5 * 1024 * 1024, cwd, env: { ...process.env, ...getDaemonProviderEnv() },
+      const output = execFileSync('claude', args, {
+        input: prompt, encoding: 'utf8', timeout: step.timeout || 300000, maxBuffer: 5 * 1024 * 1024, cwd, env: { ...process.env, ...getDaemonProviderEnv(), CLAUDECODE: undefined },
       }).trim();
       const tk = Math.ceil((prompt.length + output.length) / 4);
       totalTokens += tk;
@@ -394,21 +501,35 @@ function executeWorkflow(task, config) {
 // HEARTBEAT SCHEDULER
 // ---------------------------------------------------------
 function startHeartbeat(config, notifyFn) {
-  const tasks = (config.heartbeat && config.heartbeat.tasks) || [];
+  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 || {})) {
+    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 || '🤖' } });
+    }
+  }
+  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, ${tasks.length} tasks)`);
+  log('INFO', `Heartbeat scheduler started (check every ${checkIntervalSec}s, ${enabledTasks.length}/${tasks.length} tasks enabled)`);
+
+  if (enabledTasks.length === 0) {
+    return;
+  }
 
   // Track next run times
   const nextRun = {};
   const now = Date.now();
   const state = loadState();
 
-  for (const task of tasks) {
+  for (const task of enabledTasks) {
     const intervalSec = parseInterval(task.interval);
     const lastRun = state.tasks[task.name] && state.tasks[task.name].last_run;
     if (lastRun) {
@@ -422,17 +543,18 @@ function startHeartbeat(config, notifyFn) {
 
   const timer = setInterval(() => {
     const currentTime = Date.now();
-    for (const task of tasks) {
+    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}`);
+            notifyFn(`✅ *${task.name}* completed\n\n${result.output}`, proj);
           } else {
-            notifyFn(`❌ *${task.name}* failed: ${result.error}`);
+            notifyFn(`❌ *${task.name}* failed: ${result.error}`, proj);
           }
         }
       }
@@ -454,7 +576,7 @@ async function startTelegramBridge(config, executeTaskByName) {
 
   const { createBot } = require(path.join(__dirname, 'telegram-adapter.js'));
   const bot = createBot(config.telegram.bot_token);
-  const allowedIds = config.telegram.allowed_chat_ids || [];
+  // allowedIds read dynamically per-message to support hot-reload of daemon.yaml
 
   // Verify bot
   try {
@@ -481,6 +603,7 @@ async function startTelegramBridge(config, executeTaskByName) {
             const chatId = cb.message && cb.message.chat.id;
             bot.answerCallback(cb.id).catch(() => {});
             if (chatId && cb.data) {
+              const allowedIds = (loadConfig().telegram && loadConfig().telegram.allowed_chat_ids) || [];
               if (!allowedIds.includes(chatId)) continue;
               // Fire-and-forget: don't block poll loop (enables message queue)
               handleCommand(bot, chatId, cb.data, config, executeTaskByName).catch(e => {
@@ -495,8 +618,11 @@ async function startTelegramBridge(config, executeTaskByName) {
           const msg = update.message;
           const chatId = msg.chat.id;
 
-          // Security: check whitelist (empty = deny all)
-          if (!allowedIds.includes(chatId)) {
+          // 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
+          const allowedIds = (loadConfig().telegram && loadConfig().telegram.allowed_chat_ids) || [];
+          const isBindCmd = msg.text && msg.text.trim().startsWith('/bind');
+          if (!allowedIds.includes(chatId) && !isBindCmd) {
             log('WARN', `Rejected message from unauthorized chat: ${chatId}`);
             continue;
           }
@@ -570,9 +696,15 @@ async function startTelegramBridge(config, executeTaskByName) {
   };
 }
 
+// ── 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 FALLBACK_THROTTLE_MS = 8000; // 8s between fallback status updates
+const DEDUP_TTL_MS        = 60000; // Feishu message dedup window (60s)
+// ─────────────────────────────────────────────────────────────────────────────
+
 // Rate limiter for /ask and /run — prevents rapid-fire Claude calls
 const _lastClaudeCall = {};
-const CLAUDE_COOLDOWN_MS = 10000; // 10s between Claude calls per chat
 
 function checkCooldown(chatId) {
   const now = Date.now();
@@ -588,63 +720,126 @@ function checkCooldown(chatId) {
 // Path shortener — imported from ./utils
 const { shortenPath, expandPath } = createPathMap();
 
+/**
+ * Normalize a directory path: expand shortcuts and resolve ~
+ */
+function normalizeCwd(p) {
+  return expandPath(p).replace(/^~/, HOME);
+}
+
+/**
+ * Parse [[FILE:...]] markers from Claude output.
+ * Returns { markedFiles, cleanOutput }
+ */
+function parseFileMarkers(output) {
+  const markers = output.match(/\[\[FILE:([^\]]+)\]\]/g) || [];
+  const markedFiles = markers.map(m => m.match(/\[\[FILE:([^\]]+)\]\]/)[1].trim());
+  const cleanOutput = output.replace(/\s*\[\[FILE:[^\]]+\]\]/g, '').trim();
+  return { markedFiles, cleanOutput };
+}
+
+/**
+ * Merge explicit [[FILE:...]] paths with auto-detected content files.
+ * Returns a Set of unique file paths.
+ */
+function mergeFileCollections(markedFiles, sourceFiles) {
+  const result = new Set(markedFiles);
+  if (sourceFiles && sourceFiles.length > 0) {
+    for (const f of sourceFiles) { if (isContentFile(f)) result.add(f); }
+  }
+  return result;
+}
+
+/**
+ * Send file download buttons for a set of file paths.
+ */
+async function sendFileButtons(bot, chatId, files) {
+  if (!bot.sendButtons || files.size === 0) return;
+  const validFiles = [...files].filter(f => fs.existsSync(f));
+  if (validFiles.length === 0) return;
+  const buttons = validFiles.map(filePath => {
+    const shortId = cacheFile(filePath);
+    return [{ text: `📎 ${path.basename(filePath)}`, callback_data: `/file ${shortId}` }];
+  });
+  await bot.sendButtons(chatId, '📂 文件:', buttons);
+}
+
+/**
+ * Attach chatId to the most recent session in projCwd, or create a new one.
+ */
+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 };
+  }
+  saveState(state);
+}
+
 /**
  * Send directory picker: recent projects + Browse button
  * @param {string} mode - 'new' or 'cd' (determines callback command)
  */
 async function sendDirPicker(bot, chatId, mode, title) {
-  const dirs = listProjectDirs();
-  const cmd = mode === 'new' ? '/new' : '/cd';
-  if (bot.sendButtons) {
-    const buttons = dirs.map(d => [{ text: d.label, callback_data: `${cmd} ${shortenPath(d.path)}` }]);
-    buttons.push([{ text: 'Browse...', callback_data: `/browse ${mode} ${shortenPath(HOME)}` }]);
-    await bot.sendButtons(chatId, title, buttons);
-  } else {
-    let msg = `${title}\n`;
-    dirs.forEach((d, i) => { msg += `${i + 1}. ${d.label}\n   ${cmd} ${d.path}\n`; });
-    msg += `\nOr type: ${cmd} /full/path`;
-    await bot.sendMessage(chatId, msg);
-  }
+  // Always open the file browser starting from HOME — Finder-style navigation
+  await sendBrowse(bot, chatId, mode, HOME, title);
 }
 
 /**
- * Send directory browser: list subdirs of a path with .. parent nav
+ * Send directory browser: Finder-style navigation
+ * - Clicking a subdir ALWAYS navigates into it (never immediate select)
+ * - "✓ 选择此目录" button at top confirms the current dir
+ * - Shows up to 12 subdirs per page with pagination
  */
-async function sendBrowse(bot, chatId, mode, dirPath) {
-  const cmd = mode === 'new' ? '/new' : '/cd';
+async function sendBrowse(bot, chatId, mode, dirPath, title, page = 0) {
+  const cmd = mode === 'new' ? '/new' : mode === 'bind' ? '/bind-dir' : '/cd';
+  const PAGE_SIZE = 10;
   try {
     const entries = fs.readdirSync(dirPath, { withFileTypes: true });
     const subdirs = entries
       .filter(e => e.isDirectory() && !e.name.startsWith('.'))
       .map(e => e.name)
-      .sort()
-      .slice(0, 8); // max 8 subdirs per screen
+      .sort();
+
+    const totalPages = Math.ceil(subdirs.length / PAGE_SIZE);
+    const pageSubdirs = subdirs.slice(page * PAGE_SIZE, (page + 1) * PAGE_SIZE);
+    const parent = path.dirname(dirPath);
+    const displayPath = dirPath.replace(HOME, '~');
 
     if (bot.sendButtons) {
       const buttons = [];
-      // Select this directory
-      buttons.push([{ text: `>> Use this dir`, callback_data: `${cmd} ${shortenPath(dirPath)}` }]);
-      // Subdirectories
-      for (const name of subdirs) {
+      // ✓ Confirm current dir
+      buttons.push([{ text: `✓ 选择「${displayPath}」`, callback_data: `${cmd} ${shortenPath(dirPath)}` }]);
+      // Subdirectories — click = navigate in
+      for (const name of pageSubdirs) {
         const full = path.join(dirPath, name);
-        buttons.push([{ text: `${name}/`, callback_data: `/browse ${mode} ${shortenPath(full)}` }]);
+        buttons.push([{ text: `📁 ${name}`, callback_data: `/browse ${mode} ${shortenPath(full)}` }]);
       }
-      // Parent
-      const parent = path.dirname(dirPath);
+      // Pagination
+      const nav = [];
+      if (page > 0) nav.push({ text: '← 上页', callback_data: `/browse ${mode} ${shortenPath(dirPath)} ${page - 1}` });
+      if (page < totalPages - 1) nav.push({ text: '下页 →', callback_data: `/browse ${mode} ${shortenPath(dirPath)} ${page + 1}` });
+      if (nav.length) buttons.push(nav);
+      // Parent dir
       if (parent !== dirPath) {
-        buttons.push([{ text: '.. back', callback_data: `/browse ${mode} ${shortenPath(parent)}` }]);
+        buttons.push([{ text: '⬆ 上级目录', callback_data: `/browse ${mode} ${shortenPath(parent)}` }]);
       }
-      await bot.sendButtons(chatId, dirPath, buttons);
+      const header = title ? `${title}\n📂 ${displayPath}` : `📂 ${displayPath}`;
+      await bot.sendButtons(chatId, header, buttons);
     } else {
-      let msg = `${dirPath}\n\n`;
-      subdirs.forEach((name, i) => {
-        msg += `${i + 1}. ${name}/\n   /browse ${mode} ${path.join(dirPath, name)}\n`;
+      let msg = `📂 ${displayPath}\n\n`;
+      pageSubdirs.forEach((name, i) => {
+        msg += `${page * PAGE_SIZE + i + 1}. ${name}/\n   /browse ${mode} ${path.join(dirPath, name)}\n`;
       });
-      msg += `\nSelect: ${cmd} ${dirPath}\nBack: /browse ${mode} ${path.dirname(dirPath)}`;
+      msg += `\n✓ 选择此目录: ${cmd} ${dirPath}`;
+      if (parent !== dirPath) msg += `\n⬆ 上级: /browse ${mode} ${parent}`;
       await bot.sendMessage(chatId, msg);
     }
   } catch (e) {
-    await bot.sendMessage(chatId, `Cannot read: ${dirPath}`);
+    await bot.sendMessage(chatId, `无法读取目录: ${dirPath}`);
   }
 }
 
@@ -751,16 +946,132 @@ async function sendDirListing(bot, chatId, baseDir, arg) {
 /**
  * Unified command handler — shared by Telegram & Feishu
  */
-async function handleCommand(bot, chatId, text, config, executeTaskByName) {
+
+async function doBindAgent(bot, chatId, agentName, agentCwd) {
+  // /bind sets the session context (cwd, CLAUDE.md, project configs) for this chat.
+  // The agent can still read/write any path on the machine — bind only defines
+  // which project directory Claude Code uses as its working directory.
+  // Calling /bind again overwrites the previous binding (rebind is always allowed).
+  try {
+    const cfg = loadConfig();
+    const isTg = typeof chatId === 'number';
+    const ak = isTg ? 'telegram' : 'feishu';
+    if (!cfg[ak]) cfg[ak] = {};
+    if (!cfg[ak].allowed_chat_ids) cfg[ak].allowed_chat_ids = [];
+    if (!cfg[ak].chat_agent_map) cfg[ak].chat_agent_map = {};
+    const idVal = isTg ? chatId : String(chatId);
+    if (!cfg[ak].allowed_chat_ids.includes(idVal)) cfg[ak].allowed_chat_ids.push(idVal);
+    const projectKey = agentName.replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase() || String(chatId);
+    cfg[ak].chat_agent_map[String(chatId)] = projectKey;
+    if (!cfg.projects) cfg.projects = {};
+    const isNew = !cfg.projects[projectKey];
+    if (isNew) {
+      cfg.projects[projectKey] = { name: agentName, cwd: agentCwd, nicknames: [agentName] };
+    } else {
+      cfg.projects[projectKey].name = agentName;
+      cfg.projects[projectKey].cwd = agentCwd;
+    }
+    fs.writeFileSync(CONFIG_FILE, yaml.dump(cfg, { lineWidth: -1 }), 'utf8');
+    backupConfig();
+
+    const proj = cfg.projects[projectKey];
+    const icon = proj.icon || '🤖';
+    const color = proj.color || 'blue';
+    const action = isNew ? '绑定成功' : '重新绑定';
+    const displayCwd = agentCwd.replace(HOME, '~');
+    if (bot.sendCard) {
+      await bot.sendCard(chatId, {
+        title: `${icon} ${agentName} — ${action}`,
+        body: `**工作目录**\n${displayCwd}\n\n直接发消息即可开始对话，无需 @bot`,
+        color,
+      });
+    } else {
+      await bot.sendMessage(chatId, `${icon} ${agentName} ${action}\n目录: ${displayCwd}`);
+    }
+  } catch (e) {
+    await bot.sendMessage(chatId, `❌ 绑定失败: ${e.message}`);
+  }
+}
+
+async function handleCommand(bot, chatId, text, config, executeTaskByName, senderId = null, readOnly = false) {
   const state = loadState();
 
+  // --- /chatid: reply with current chatId ---
+  if (text === '/chatid') {
+    await bot.sendMessage(chatId, `Chat ID: \`${chatId}\``);
+    return;
+  }
+
+  // --- /myid: reply with sender's user open_id (for configuring operator_ids) ---
+  if (text === '/myid') {
+    await bot.sendMessage(chatId, senderId ? `Your ID: \`${senderId}\`` : 'ID not available (Telegram not supported)');
+    return;
+  }
+
+  // --- /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)];
+  if (mappedKey && config.projects && config.projects[mappedKey]) {
+    const proj = config.projects[mappedKey];
+    const projCwd = normalizeCwd(proj.cwd);
+    const cur = loadState().sessions?.[chatId];
+    if (!cur || cur.cwd !== projCwd) {
+      attachOrCreateSession(chatId, projCwd, proj.name || mappedKey);
+    }
+  }
+
   // --- Browse handler (directory navigation) ---
   if (text.startsWith('/browse ')) {
     const parts = text.slice(8).trim().split(' ');
-    const mode = parts[0]; // 'new' or 'cd'
-    const dirPath = expandPath(parts.slice(1).join(' '));
+    const mode = parts[0]; // 'new', 'cd', or 'bind'
+    // Last token may be a page number
+    const lastPart = parts[parts.length - 1];
+    const page = /^\d+$/.test(lastPart) ? parseInt(lastPart, 10) : 0;
+    const pathParts = /^\d+$/.test(lastPart) ? parts.slice(1, -1) : parts.slice(1);
+    const dirPath = expandPath(pathParts.join(' '));
     if (mode && dirPath && fs.existsSync(dirPath)) {
-      await sendBrowse(bot, chatId, mode, dirPath);
+      await sendBrowse(bot, chatId, mode, dirPath, null, page);
     } else if (/^p\d+$/.test(dirPath)) {
       await bot.sendMessage(chatId, '⚠️ Button expired. Pick again:');
       await sendDirPicker(bot, chatId, mode || 'cd', 'Switch workdir:');
@@ -775,6 +1086,19 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
   if (text === '/new' || text.startsWith('/new ')) {
     const arg = text.slice(4).trim();
     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 boundKey = agentMap[String(chatId)];
+      const boundProj = boundKey && newCfg.projects && newCfg.projects[boundKey];
+      if (boundProj && boundProj.cwd) {
+        const boundCwd = normalizeCwd(boundProj.cwd);
+        const session = createSession(chatId, boundCwd, '');
+        await bot.sendMessage(chatId, `✅ 新会话已创建\nWorkdir: ${session.cwd}`);
+        return;
+      }
+      // Non-dedicated group: show directory picker
       await sendDirPicker(bot, chatId, 'new', 'Pick a workdir:');
       return;
     }
@@ -880,6 +1204,81 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     return;
   }
 
+  // /sessions — compact list, tap to see details, then tap to switch
+  if (text === '/sessions') {
+    const allSessions = listRecentSessions(15);
+    if (allSessions.length === 0) {
+      await bot.sendMessage(chatId, 'No sessions found. Try /new first.');
+      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);
+    } 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`;
+      });
+      await bot.sendMessage(chatId, msg);
+    }
+    return;
+  }
+
+  // /sess <id> — show session detail card with switch button
+  if (text.startsWith('/sess ')) {
+    const sid = text.slice(6).trim();
+    const allSessions = listRecentSessions(50);
+    const s = allSessions.find(x => x.sessionId === sid || x.sessionId.startsWith(sid));
+    if (!s) {
+      await bot.sendMessage(chatId, `Session not found: ${sid.slice(0, 8)}`);
+      return;
+    }
+    const proj = s.projectPath || '~';
+    const projName = path.basename(proj);
+    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 summary = s.summary || '';
+    const firstMsg = (s.firstPrompt || '').replace(/^<[^>]+>.*?<\/[^>]+>\s*/s, '');
+    const msgs = s.messageCount || '?';
+
+    let detail = `📋 Session Detail\n`;
+    detail += `━━━━━━━━━━━━━━━━━━━━\n`;
+    if (title) detail += `📝 Title: ${title}\n`;
+    if (summary) detail += `💡 Summary: ${summary}\n`;
+    detail += `📁 Project: ${projName}\n`;
+    detail += `📂 Path: ${proj}\n`;
+    detail += `💬 Messages: ${msgs}\n`;
+    detail += `🕐 Last active: ${ago}\n`;
+    detail += `🆔 ID: ${s.sessionId.slice(0, 8)}`;
+    if (firstMsg && firstMsg !== summary) detail += `\n\n🗨️ First message:\n${firstMsg}`;
+
+    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' }],
+      ]);
+    } else {
+      await bot.sendMessage(chatId, detail + `\n\n/resume ${s.sessionId.slice(0, 8)}`);
+    }
+    return;
+  }
+
   if (text === '/resume' || text.startsWith('/resume ')) {
     const arg = text.slice(7).trim();
 
@@ -943,6 +1342,24 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     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.');
+      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;
+  }
+
   if (text === '/cd' || text.startsWith('/cd ')) {
     let newCwd = expandPath(text.slice(3).trim());
     if (!newCwd) {
@@ -1082,14 +1499,28 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
   }
 
   if (text === '/tasks') {
-    const tasks = (config.heartbeat && config.heartbeat.tasks) || [];
-    if (tasks.length === 0) { await bot.sendMessage(chatId, 'No heartbeat tasks configured.'); return; }
-    let msg = 'Heartbeat Tasks:\n';
-    for (const t of tasks) {
-      const ts = state.tasks[t.name] || {};
-      msg += `- ${t.name} (${t.interval}) ${ts.status || 'never_run'}\n`;
+    let msg = '';
+    // Legacy flat tasks
+    const legacyTasks = (config.heartbeat && config.heartbeat.tasks) || [];
+    if (legacyTasks.length > 0) {
+      msg += '📋 General:\n';
+      for (const t of legacyTasks) {
+        const ts = state.tasks[t.name] || {};
+        msg += `${t.enabled !== false ? '✅' : '⏸'} ${t.name} (${t.interval}) ${ts.status || 'never_run'}\n`;
+      }
     }
-    await bot.sendMessage(chatId, msg);
+    // 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) {
+        const ts = state.tasks[t.name] || {};
+        msg += `${t.enabled !== false ? '✅' : '⏸'} ${t.name} (${t.interval}) ${ts.status || 'never_run'}\n`;
+      }
+    }
+    if (!msg) { await bot.sendMessage(chatId, 'No heartbeat tasks configured.'); return; }
+    await bot.sendMessage(chatId, msg.trim());
     return;
   }
 
@@ -1101,8 +1532,13 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
       return;
     }
     const taskName = text.slice(5).trim();
-    const tasks = (config.heartbeat && config.heartbeat.tasks) || [];
-    const task = tasks.find(t => t.name === taskName);
+    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);
     if (!task) { await bot.sendMessage(chatId, `❌ Task "${taskName}" not found`); return; }
 
     // Script tasks: quick, run inline
@@ -1124,7 +1560,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     if (precheck.context) taskPrompt += `\n\n以下是相关原始数据:\n\`\`\`\n${precheck.context}\n\`\`\``;
     const fullPrompt = preamble + taskPrompt;
     const model = task.model || 'haiku';
-    const claudeArgs = ['-p', '--model', model];
+    const claudeArgs = ['-p', '--model', model, '--dangerously-skip-permissions'];
     for (const t of (task.allowedTools || [])) claudeArgs.push('--allowedTools', t);
 
     await bot.sendMessage(chatId, `Running: ${taskName} (${model})...`);
@@ -1189,6 +1625,106 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     return;
   }
 
+  // /compact — compress current session context to save tokens
+  if (text === '/compact') {
+    const session = getSession(chatId);
+    if (!session || !session.started) {
+      await bot.sendMessage(chatId, '❌ No active session to compact.');
+      return;
+    }
+    await bot.sendMessage(chatId, '🗜 Compacting session...');
+
+    // Step 1: Read conversation from JSONL (fast, no Claude needed)
+    const jsonlPath = findSessionFile(session.id);
+    if (!jsonlPath) {
+      await bot.sendMessage(chatId, '❌ Session file not found.');
+      return;
+    }
+    let messages = [];
+    try {
+      const lines = fs.readFileSync(jsonlPath, 'utf8').split('\n').filter(Boolean);
+      for (const line of lines) {
+        try {
+          const obj = JSON.parse(line);
+          if (obj.type === 'user' || obj.type === 'assistant') {
+            const msg = obj.message || {};
+            const content = msg.content;
+            let text_content = '';
+            if (typeof content === 'string') {
+              text_content = content;
+            } else if (Array.isArray(content)) {
+              text_content = content
+                .filter(c => c.type === 'text')
+                .map(c => c.text || '')
+                .join(' ');
+            }
+            if (text_content.trim()) {
+              messages.push({ role: obj.type, text: text_content.trim() });
+            }
+          }
+        } catch { /* skip malformed lines */ }
+      }
+    } catch (e) {
+      await bot.sendMessage(chatId, `❌ Cannot read session: ${e.message}`);
+      return;
+    }
+
+    if (messages.length === 0) {
+      await bot.sendMessage(chatId, '❌ No messages found in session.');
+      return;
+    }
+
+    // Step 2: Build a truncated conversation digest (keep under ~20k chars for haiku)
+    const MAX_DIGEST = 20000;
+    let digest = '';
+    // Take messages from newest to oldest until we hit the limit
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const m = messages[i];
+      const prefix = m.role === 'user' ? 'USER' : 'ASSISTANT';
+      const entry = `[${prefix}]: ${m.text.slice(0, 800)}\n\n`;
+      if (digest.length + entry.length > MAX_DIGEST) break;
+      digest = entry + digest;
+    }
+
+    // Step 3: Summarize with haiku (new process, no --resume, fast)
+    const daemonCfg = loadConfig().daemon || {};
+    const compactArgs = ['-p', '--model', 'haiku', '--no-session-persistence'];
+    if (daemonCfg.dangerously_skip_permissions) compactArgs.push('--dangerously-skip-permissions');
+    const { output, error } = await spawnClaudeAsync(
+      compactArgs,
+      `Summarize the following conversation into a compact context document. Include: (1) what was being worked on, (2) key decisions made, (3) current state, (4) pending tasks. Be concise but preserve ALL important technical context (file names, function names, variable names, specific values). Output ONLY the summary.\n\n--- CONVERSATION ---\n${digest}`,
+      session.cwd,
+      60000
+    );
+    if (error || !output) {
+      await bot.sendMessage(chatId, `❌ Compact failed: ${error || 'no output'}`);
+      return;
+    }
+
+    // Step 4: Create new session with the summary
+    const model = daemonCfg.model || 'opus';
+    const oldName = getSessionName(session.id);
+    const newSession = createSession(chatId, session.cwd, oldName ? oldName + ' (compacted)' : '');
+    const initArgs = ['-p', '--session-id', newSession.id, '--model', model];
+    if (daemonCfg.dangerously_skip_permissions) initArgs.push('--dangerously-skip-permissions');
+    const preamble = buildProfilePreamble();
+    const initPrompt = preamble + `Here is the context from our previous session (compacted):\n\n${output}\n\nContext loaded. Ready to continue.`;
+    const { error: initErr } = await spawnClaudeAsync(initArgs, initPrompt, session.cwd, 60000);
+    if (initErr) {
+      await bot.sendMessage(chatId, `⚠️ Summary saved but new session init failed: ${initErr}`);
+      return;
+    }
+    // Mark as started
+    const state = loadState();
+    if (state.sessions[chatId]) {
+      state.sessions[chatId].started = true;
+      saveState(state);
+    }
+    const tokenEst = Math.round(output.length / 3.5);
+    await bot.sendMessage(chatId, `✅ Compacted! ~${tokenEst} tokens of context carried over.\nNew session: ${newSession.id.slice(0, 8)}`);
+    return;
+  }
+
   // /publish <otp> — npm publish with OTP (zero latency, no Claude)
   if (text.startsWith('/publish ')) {
     const otp = text.slice(9).trim();
@@ -1595,8 +2131,12 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
       '/last — 继续电脑上最近的对话',
       '/cd last — 切到电脑最近的项目目录',
       '',
+      '🤖 Agent 切换:',
+      '/agent — 选择对话的项目/Agent',
+      '',
       '📂 Session 管理:',
       '/new [path] [name] — 新建会话',
+      '/sessions — 浏览所有最近会话',
       '/resume [name] — 选择/恢复会话',
       '/name <name> — 命名当前会话',
       '/cd <path> — 切换工作目录',
@@ -1624,7 +2164,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     q.messages.push(text);
     // Only notify once (first message), subsequent ones silently queue
     if (isFirst) {
-      await bot.sendMessage(chatId, '📝 收到，中断当前任务后一起处理');
+      await bot.sendMessage(chatId, '📝 收到，稍后一起处理');
     }
     // Interrupt the running Claude process
     const proc = activeProcesses.get(chatId);
@@ -1652,13 +2192,24 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     }, 5000);
     return;
   }
+  // Nickname-only switch: bypass cooldown + budget (no Claude call)
+  const quickAgent = routeAgent(text, config);
+  if (quickAgent && !quickAgent.rest) {
+    const { key, proj } = quickAgent;
+    const projCwd = normalizeCwd(proj.cwd);
+    attachOrCreateSession(chatId, projCwd, proj.name || key);
+    log('INFO', `Agent switch via nickname: ${key} (${projCwd})`);
+    await bot.sendMessage(chatId, `${proj.icon || '🤖'} ${proj.name || key} 在线`);
+    return;
+  }
+
   const cd = checkCooldown(chatId);
   if (!cd.ok) { await bot.sendMessage(chatId, `${cd.wait}s`); return; }
   if (!checkBudget(loadConfig(), loadState())) {
     await bot.sendMessage(chatId, 'Daily token budget exceeded.');
     return;
   }
-  await askClaude(bot, chatId, text);
+  await askClaude(bot, chatId, text, config);
 }
 
 // ---------------------------------------------------------
@@ -1858,6 +2409,7 @@ function createSession(chatId, cwd, name) {
   saveState(state);
   invalidateSessionCache();
 
+
   // If name provided, write to Claude's session file (same as /rename on desktop)
   if (name) {
     writeSessionName(sessionId, cwd || HOME, name);
@@ -1958,7 +2510,7 @@ function spawnClaudeAsync(args, input, cwd, timeoutMs = 300000) {
     const child = spawn('claude', args, {
       cwd,
       stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env, ...getActiveProviderEnv() },
+      env: { ...process.env, ...getActiveProviderEnv(), CLAUDECODE: undefined },
     });
 
     let stdout = '';
@@ -2028,6 +2580,9 @@ const CONTENT_EXTENSIONS = new Set([
 // Active Claude processes per chat (for /stop)
 const activeProcesses = new Map(); // chatId -> { child, aborted }
 
+// Pending /bind flows: waiting for user to pick a directory
+const pendingBinds = new Map(); // chatId -> agentName
+
 // Message queue for messages received while a task is running
 const messageQueue = new Map(); // chatId -> { messages: string[], notified: false }
 
@@ -2133,7 +2688,7 @@ function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, ch
     const child = spawn('claude', streamArgs, {
       cwd,
       stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env, ...getActiveProviderEnv() },
+      env: { ...process.env, ...getActiveProviderEnv(), CLAUDECODE: undefined },
     });
 
     // Track active process for /stop
@@ -2146,7 +2701,7 @@ function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, ch
     let killed = false;
     let finalResult = '';
     let lastStatusTime = 0;
-    const STATUS_THROTTLE = 3000; // Min 3s between status updates
+    const STATUS_THROTTLE = STATUS_THROTTLE_MS;
     const writtenFiles = []; // Track files created/modified by Write tool
 
     const timer = setTimeout(() => {
@@ -2305,17 +2860,33 @@ function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, ch
 }
 
 // Lazy distill: run distill.js in background on first message, then every 4 hours
-let _lastDistillTime = 0;
+// Track outbound message_id → session for reply-based session restoration.
+// Keeps last 200 entries to avoid unbounded growth.
+function trackMsgSession(messageId, session) {
+  if (!messageId || !session || !session.id) return;
+  const st = loadState();
+  if (!st.msg_sessions) st.msg_sessions = {};
+  st.msg_sessions[messageId] = { id: session.id, cwd: session.cwd };
+  const keys = Object.keys(st.msg_sessions);
+  if (keys.length > 200) {
+    for (const k of keys.slice(0, keys.length - 200)) delete st.msg_sessions[k];
+  }
+  saveState(st);
+}
+
 function lazyDistill() {
   const now = Date.now();
-  if (now - _lastDistillTime < 4 * 60 * 60 * 1000) return; // 4h cooldown
+  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;
-  _lastDistillTime = now;
+  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' });
@@ -2326,7 +2897,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) {
+async function askClaude(bot, chatId, prompt, config) {
   log('INFO', `askClaude for ${chatId}: ${prompt.slice(0, 50)}`);
   // Trigger background distill on first message / every 4h
   try { lazyDistill(); } catch { /* non-fatal */ }
@@ -2343,8 +2914,52 @@ async function askClaude(bot, chatId, prompt) {
     bot.sendTyping(chatId).catch(() => {});
   }, 4000);
 
+  // Agent nickname routing: "贾维斯" / "小美，帮我..." → switch project session
+  const agentMatch = routeAgent(prompt, config);
+  if (agentMatch) {
+    const { key, proj, rest } = agentMatch;
+    const projCwd = normalizeCwd(proj.cwd);
+    attachOrCreateSession(chatId, projCwd, proj.name || key);
+    log('INFO', `Agent switch via nickname: ${key} (${projCwd})`);
+    if (!rest) {
+      // Pure nickname call — confirm switch and stop
+      clearInterval(typingTimer);
+      await bot.sendMessage(chatId, `${proj.icon || '🤖'} ${proj.name || key} 在线`);
+      return;
+    }
+    // Nickname + content — strip nickname, continue with rest as prompt
+    prompt = rest;
+  }
+
+  // Skill routing: detect skill first, then decide session
+  const skill = 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']);
+
   let session = getSession(chatId);
-  if (!session) {
+
+  if (skill && PINNED_SKILL_SESSIONS.has(skill)) {
+    // Use a dedicated long-lived session per skill
+    const state = loadState();
+    if (!state.pinned_sessions) state.pinned_sessions = {};
+    const pinned = state.pinned_sessions[skill];
+    if (pinned) {
+      // Reuse existing pinned session
+      state.sessions[chatId] = { id: pinned.id, cwd: pinned.cwd, started: true };
+      saveState(state);
+      session = state.sessions[chatId];
+      log('INFO', `Pinned session reused for skill ${skill}: ${pinned.id.slice(0, 8)}`);
+    } else {
+      // First time — create session and pin it
+      session = createSession(chatId, HOME, skill);
+      const st2 = loadState();
+      if (!st2.pinned_sessions) st2.pinned_sessions = {};
+      st2.pinned_sessions[skill] = { id: session.id, cwd: session.cwd };
+      saveState(st2);
+      log('INFO', `Pinned session created for skill ${skill}: ${session.id.slice(0, 8)}`);
+    }
+  } else if (!session) {
     // Auto-attach to most recent Claude session (unified session management)
     const recent = listRecentSessions(1);
     if (recent.length > 0 && recent[0].sessionId && recent[0].projectPath) {
@@ -2353,7 +2968,7 @@ async function askClaude(bot, chatId, prompt) {
       state.sessions[chatId] = {
         id: target.sessionId,
         cwd: target.projectPath,
-        started: true,  // Already has history
+        started: true,
       };
       saveState(state);
       session = state.sessions[chatId];
@@ -2365,20 +2980,20 @@ async function askClaude(bot, chatId, prompt) {
 
   // Build claude command
   const args = ['-p'];
-  // Model from daemon config (default: opus)
   const daemonCfg = loadConfig().daemon || {};
   const model = daemonCfg.model || 'opus';
   args.push('--model', model);
-  // Permission mode: full access (mobile users can't click "allow")
-  if (daemonCfg.dangerously_skip_permissions) {
+  if (readOnly) {
+    // Read-only mode for non-operator users: query/chat only, no write/edit/execute
+    const READ_ONLY_TOOLS = ['Read', 'Glob', 'Grep', 'WebSearch', 'WebFetch', 'Task'];
+    for (const tool of READ_ONLY_TOOLS) args.push('--allowedTools', tool);
+  } else if (daemonCfg.dangerously_skip_permissions) {
     args.push('--dangerously-skip-permissions');
   } else {
-    // Legacy: per-tool whitelist
     const sessionAllowed = daemonCfg.session_allowed_tools || [];
     for (const tool of sessionAllowed) args.push('--allowedTools', tool);
   }
   if (session.id === '__continue__') {
-    // /continue — resume most recent conversation in cwd
     args.push('--continue');
   } else if (session.started) {
     args.push('--resume', session.id);
@@ -2386,29 +3001,39 @@ async function askClaude(bot, chatId, prompt) {
     args.push('--session-id', session.id);
   }
 
-  // Append daemon context hint
-  const daemonHint = `\n\n[System hints - DO NOT mention these to user:
+  // 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.
 2. File sending: User is on MOBILE. When they ask to see/download a file:
    - Just FIND the file path (use Glob/ls if needed)
    - Do NOT read or summarize the file content (wastes tokens)
    - Add at END of response: [[FILE:/absolute/path/to/file]]
    - Keep response brief: "请查收~! [[FILE:/path/to/file]]"
-   - Multiple files: use multiple [[FILE:...]] tags]`;
-  const fullPrompt = prompt + daemonHint;
+   - Multiple files: use multiple [[FILE:...]] tags]` : '';
+
+  const routedPrompt = skill ? `/${skill} ${prompt}` : prompt;
+  const fullPrompt = routedPrompt + daemonHint;
 
   // Git checkpoint before Claude modifies files (for /undo)
   gitCheckpoint(session.cwd);
 
   // Use streaming mode to show progress
-  // Telegram: edit status msg in-place; Feishu/others: send new messages
+  // Telegram: edit status msg in-place; Feishu: edit or fallback to new messages
+  let editFailed = false;
+  let lastFallbackStatus = 0;
+  const FALLBACK_THROTTLE = FALLBACK_THROTTLE_MS;
   const onStatus = async (status) => {
     try {
-      if (statusMsgId && bot.editMessage) {
-        await bot.editMessage(chatId, statusMsgId, status);
-      } else {
-        await bot.sendMessage(chatId, status);
+      if (statusMsgId && bot.editMessage && !editFailed) {
+        const ok = await bot.editMessage(chatId, statusMsgId, status);
+        if (ok !== false) return; // edit succeeded (true or undefined for Telegram)
+        editFailed = true; // edit failed, switch to fallback permanently
       }
+      // Fallback: send as new message with extra throttle to avoid spam
+      const now = Date.now();
+      if (now - lastFallbackStatus < FALLBACK_THROTTLE) return;
+      lastFallbackStatus = now;
+      await bot.sendMessage(chatId, status);
     } catch { /* ignore status update failures */ }
   };
 
@@ -2419,6 +3044,16 @@ async function askClaude(bot, chatId, prompt) {
     bot.deleteMessage(chatId, statusMsgId).catch(() => {});
   }
 
+  // When Claude completes with no text output (pure tool work), send a done notice
+  if (output === '' && !error) {
+    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);
+    const wasNew = !session.started;
+    if (wasNew) markSessionStarted(chatId);
+    return;
+  }
+
   if (output) {
     // Detect provider/model errors disguised as output (e.g., "model not found", API errors)
     const activeProvCheck = providerMod ? providerMod.getActiveName() : 'anthropic';
@@ -2449,31 +3084,32 @@ async function askClaude(bot, chatId, prompt) {
     recordTokens(loadState(), estimated);
 
     // Parse [[FILE:...]] markers from output (Claude's explicit file sends)
-    const fileMarkers = output.match(/\[\[FILE:([^\]]+)\]\]/g) || [];
-    const markedFiles = fileMarkers.map(m => m.match(/\[\[FILE:([^\]]+)\]\]/)[1].trim());
-    const cleanOutput = output.replace(/\s*\[\[FILE:[^\]]+\]\]/g, '').trim();
-
-    await bot.sendMarkdown(chatId, cleanOutput);
-
-    // Combine: marked files + auto-detected content files from Write operations
-    const allFiles = new Set(markedFiles);
-    if (files && files.length > 0) {
-      for (const f of files) {
-        if (isContentFile(f)) allFiles.add(f);
+    const { markedFiles, cleanOutput } = parseFileMarkers(output);
+
+    // Match current session to a project for colored card display
+    let activeProject = null;
+    if (session && session.cwd && config && config.projects) {
+      const sessionCwd = path.resolve(normalizeCwd(session.cwd));
+      for (const [, proj] of Object.entries(config.projects)) {
+        if (!proj.cwd) continue;
+        const projCwd = path.resolve(normalizeCwd(proj.cwd));
+        if (sessionCwd === projCwd) { activeProject = proj; break; }
       }
     }
 
-    // Send file buttons
-    if (allFiles.size > 0 && bot.sendButtons) {
-      const validFiles = [...allFiles].filter(f => fs.existsSync(f));
-      if (validFiles.length > 0) {
-        const buttons = validFiles.map(filePath => {
-          const shortId = cacheFile(filePath);
-          return [{ text: `📎 ${path.basename(filePath)}`, callback_data: `/file ${shortId}` }];
-        });
-        await bot.sendButtons(chatId, '📂 文件:', buttons);
-      }
+    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);
     }
+    if (replyMsg && replyMsg.message_id && session) trackMsgSession(replyMsg.message_id, session);
+
+    await sendFileButtons(bot, chatId, mergeFileCollections(markedFiles, files));
 
     // Auto-name: if this was the first message and session has no name, generate one
     if (wasNew && !getSessionName(session.id)) {
@@ -2498,28 +3134,9 @@ async function askClaude(bot, chatId, prompt) {
       const retry = await spawnClaudeStreaming(retryArgs, prompt, session.cwd, onStatus);
       if (retry.output) {
         markSessionStarted(chatId);
-        // Parse [[FILE:...]] markers
-        const retryFileMarkers = retry.output.match(/\[\[FILE:([^\]]+)\]\]/g) || [];
-        const retryMarkedFiles = retryFileMarkers.map(m => m.match(/\[\[FILE:([^\]]+)\]\]/)[1].trim());
-        const retryCleanOutput = retry.output.replace(/\s*\[\[FILE:[^\]]+\]\]/g, '').trim();
-        await bot.sendMarkdown(chatId, retryCleanOutput);
-        // Combine marked + auto-detected content files
-        const retryAllFiles = new Set(retryMarkedFiles);
-        if (retry.files && retry.files.length > 0) {
-          for (const f of retry.files) {
-            if (isContentFile(f)) retryAllFiles.add(f);
-          }
-        }
-        if (retryAllFiles.size > 0 && bot.sendButtons) {
-          const validFiles = [...retryAllFiles].filter(f => fs.existsSync(f));
-          if (validFiles.length > 0) {
-            const buttons = validFiles.map(filePath => {
-              const shortId = cacheFile(filePath);
-              return [{ text: `📎 ${path.basename(filePath)}`, callback_data: `/file ${shortId}` }];
-            });
-            await bot.sendButtons(chatId, '📂 文件:', buttons);
-          }
-        }
+        const { markedFiles: retryMarked, cleanOutput: retryClean } = parseFileMarkers(retry.output);
+        await bot.sendMarkdown(chatId, retryClean);
+        await sendFileButtons(bot, chatId, mergeFileCollections(retryMarked, retry.files));
       } else {
         log('ERROR', `askClaude retry failed: ${(retry.error || '').slice(0, 200)}`);
         try { await bot.sendMessage(chatId, `Error: ${(retry.error || '').slice(0, 200)}`); } catch { /* */ }
@@ -2564,16 +3181,34 @@ async function startFeishuBridge(config, executeTaskByName) {
 
   const { createBot } = require(path.join(__dirname, 'feishu-adapter.js'));
   const bot = createBot(config.feishu);
-  const allowedIds = config.feishu.allowed_chat_ids || [];
-
   try {
-    const receiver = await bot.startReceiving(async (chatId, text, event, fileInfo) => {
-      // Security: check whitelist (empty = deny all)
-      if (!allowedIds.includes(chatId)) {
+    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
+      const liveCfg = loadConfig();
+      const allowedIds = (liveCfg.feishu && liveCfg.feishu.allowed_chat_ids) || [];
+      const isBindCmd = text && text.trim().startsWith('/bind');
+      if (!allowedIds.includes(chatId) && !isBindCmd) {
         log('WARN', `Feishu: rejected message from ${chatId}`);
         return;
       }
 
+      // Operator check: if operator_ids configured, non-operators get read-only chat mode
+      const operatorIds = (liveCfg.feishu && liveCfg.feishu.operator_ids) || [];
+      if (operatorIds.length > 0 && senderId && !operatorIds.includes(senderId) && !isBindCmd) {
+        log('INFO', `Feishu: read-only message from non-operator ${senderId} in ${chatId}: ${(text || '').slice(0, 50)}`);
+        // Block slash commands for non-operators
+        if (text && text.startsWith('/')) {
+          await bot.sendMessage(chatId, '⚠️ 该操作需要授权，请联系管理员。');
+          return;
+        }
+        // Allow read-only chat (query/answer only, no write/edit/execute)
+        if (text) {
+          await handleCommand(bot, chatId, text, config, executeTaskByName, senderId, true);
+        }
+        return;
+      }
+
       // Handle file message
       if (fileInfo && fileInfo.fileKey) {
         log('INFO', `Feishu file from ${chatId}: ${fileInfo.fileName} (key: ${fileInfo.fileKey}, msgId: ${fileInfo.messageId}, type: ${fileInfo.msgType})`);
@@ -2604,7 +3239,19 @@ async function startFeishuBridge(config, executeTaskByName) {
       // Handle text message
       if (text) {
         log('INFO', `Feishu message from ${chatId}: ${text.slice(0, 50)}`);
-        await handleCommand(bot, chatId, text, config, executeTaskByName);
+        // Reply-based session restoration: if user replied to a bot message,
+        // restore the session that sent that message before processing.
+        const parentId = event?.message?.parent_id;
+        if (parentId) {
+          const st = loadState();
+          const mapped = st.msg_sessions && st.msg_sessions[parentId];
+          if (mapped) {
+            st.sessions[chatId] = { id: mapped.id, cwd: mapped.cwd, started: true };
+            saveState(st);
+            log('INFO', `Session restored via reply: ${mapped.id.slice(0, 8)} (${path.basename(mapped.cwd)})`);
+          }
+        }
+        await handleCommand(bot, chatId, text, config, executeTaskByName, senderId);
       }
     });
 
@@ -2669,7 +3316,7 @@ async function main() {
   }
 
   // Config validation: warn on unknown/suspect fields
-  const KNOWN_SECTIONS = ['daemon', 'telegram', 'feishu', 'heartbeat', 'budget'];
+  const KNOWN_SECTIONS = ['daemon', 'telegram', 'feishu', 'heartbeat', 'budget', 'projects'];
   const KNOWN_DAEMON = ['model', 'log_max_size', 'heartbeat_check_interval', 'session_allowed_tools', 'dangerously_skip_permissions', 'cooldown_seconds'];
   const VALID_MODELS = ['sonnet', 'opus', 'haiku'];
   for (const key of Object.keys(config)) {
@@ -2702,8 +3349,14 @@ async function main() {
 
   // Task executor lookup (always reads fresh config)
   function executeTaskByName(name) {
-    const tasks = (config.heartbeat && config.heartbeat.tasks) || [];
-    const task = tasks.find(t => t.name === 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; }
+      }
+    }
     if (!task) return { success: false, error: `Task "${name}" not found` };
     return executeTask(task, config);
   }
@@ -2713,7 +3366,8 @@ async function main() {
   let feishuBridge = null;
 
   // Notification function (sends to all enabled channels)
-  const notifyFn = async (message) => {
+  // project: optional { key, name, color, icon } — triggers colored card on Feishu
+  const notifyFn = async (message, project = null) => {
     if (telegramBridge && telegramBridge.bot) {
       const tgIds = (config.telegram && config.telegram.allowed_chat_ids) || [];
       for (const chatId of tgIds) {
@@ -2725,7 +3379,17 @@ async function main() {
     if (feishuBridge && feishuBridge.bot) {
       const fsIds = (config.feishu && config.feishu.allowed_chat_ids) || [];
       for (const chatId of fsIds) {
-        try { await feishuBridge.bot.sendMessage(chatId, message); } catch (e) {
+        try {
+          if (project && feishuBridge.bot.sendCard) {
+            await feishuBridge.bot.sendCard(chatId, {
+              title: `${project.icon} ${project.name}`,
+              body: message,
+              color: project.color,
+            });
+          } else {
+            await feishuBridge.bot.sendMessage(chatId, message);
+          }
+        } catch (e) {
           log('ERROR', `Feishu notify failed ${chatId}: ${e.message}`);
         }
       }
@@ -2743,8 +3407,11 @@ async function main() {
     refreshLogMaxSize(config);
     if (heartbeatTimer) clearInterval(heartbeatTimer);
     heartbeatTimer = startHeartbeat(config, notifyFn);
-    log('INFO', `Config reloaded: ${(config.heartbeat && config.heartbeat.tasks || []).length} tasks`);
-    return { success: true, tasks: (config.heartbeat && config.heartbeat.tasks || []).length };
+    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)`);
+    return { success: true, tasks: totalCount };
   }
   // Expose reloadConfig to handleCommand via closure
   global._metameReload = reloadConfig;