metame-cli 1.3.17 → 1.3.18

package/README.md

@@ -399,6 +399,53 @@ Each step runs in the same Claude Code session. Step outputs automatically becom
 * `~/.metame/` directory set to mode 700
 * Bot tokens stored locally, never transmitted
 
+### Multi-Agent Projects — Context Isolation & Nickname Routing (v1.3.18)
+
+Organize your work into named agents, each tied to a project directory. Switch between them instantly from your phone — no commands needed, just say their name.
+
+**How it works:**
+
+Each `project` entry in `daemon.yaml` defines an agent with a working directory, display name, notification color, and optional nicknames. When you send a message starting with a nickname, the daemon instantly switches to that project's last session — no Claude call, no token cost.
+
+**Setup via conversation:**
+
+The easiest way to add an agent is to tell the bot:
+
+> *"Add a project called 'work' pointing to ~/my-project, nickname is '工作'"*
+
+Or edit `~/.metame/daemon.yaml` directly:
+
+```yaml
+projects:
+  my_agent:
+    name: "My Agent"          # Display name in notifications
+    icon: "🤖"               # Emoji shown in Feishu cards
+    color: "blue"            # Feishu card color: blue|orange|green|purple|red|grey
+    cwd: "~/my-project"      # Working directory for this agent
+    nicknames: [nickname1, nickname2]   # Wake words (matched at message start)
+    heartbeat_tasks: []      # Scheduled tasks for this project (optional)
+```
+
+**Available colors:** `blue` · `orange` · `green` · `purple` · `red` · `grey` · `turquoise`
+
+**Phone commands:**
+
+| Action | How |
+|--------|-----|
+| Switch agent | Send the nickname alone: `贾维斯` → `🤖 Jarvis 在线` |
+| Switch + ask | `贾维斯, what's the status?` → switches then asks Claude |
+| Pick from list | `/agent` → tap button to switch |
+| Continue a reply | Reply to any bot message → session auto-restored |
+| View all tasks | `/tasks` → grouped by project |
+| Run a task | `/run <task-name>` |
+
+**Nickname routing rules:**
+- Matched at **message start only** — mentioning a nickname mid-sentence never triggers a switch
+- Pure nickname (no content after) → instant switch, zero token cost, bypasses cooldown
+- Nickname + content → switch then send content to Claude
+
+**Heartbeat task notifications** arrive as colored Feishu cards — each project's color is distinct, so you can tell at a glance which agent sent the update.
+
 ### Provider Relay — Third-Party Model Support (v1.3.11)
 
 MetaMe supports any Anthropic-compatible API relay as a backend. This means you can route Claude Code through a third-party relay that maps `sonnet`/`opus`/`haiku` to any model (GPT-4, DeepSeek, Gemini, etc.) — MetaMe passes standard model names and the relay handles translation.
@@ -602,6 +649,7 @@ A: No. Your profile stays local at `~/.claude_profile.yaml`. MetaMe simply passe
 
 | Version | Highlights |
 |---------|------------|
+| **v1.3.18** | **Multi-agent project isolation** — `projects` in `daemon.yaml` with per-project heartbeat tasks, Feishu colored cards per project, `/agent` picker button, nickname routing (say agent name to switch instantly), reply-to-message session restoration, fix `~` expansion in project cwd |
 | **v1.3.17** | **Windows support** (WSL one-command installer), `install-systemd` for Linux/WSL daemon auto-start. Fix onboarding (Genesis interview was never injected, CLAUDE.md accumulated across runs). Marker-based cleanup, unified protocols, `--append-system-prompt` guarantees interview activation, Feishu auto-fetch chat ID, full mobile permissions, fix `/publish` false-success, auto-restart daemon on script update |
 | **v1.3.16** | Git-based `/undo` (auto-checkpoint before each turn, `git reset --hard` rollback), `/nosleep` toggle (macOS caffeinate), custom provider model passthrough (`/model` accepts any name for non-anthropic providers), auto-fallback to anthropic/opus on provider failure, message queue works on Telegram (fire-and-forget poll loop), lazy background distill |
 | **v1.3.15** | Native Playwright MCP (browser automation for all users), `/list` interactive file browser with buttons, Feishu image download fix, Skill/MCP/Agent status push, hot restart reliability (single notification, no double instance) |

package/index.js

@@ -28,9 +28,22 @@ if (!fs.existsSync(METAME_DIR)) {
 }
 
 // Auto-deploy bundled scripts to ~/.metame/
+// IMPORTANT: daemon.yaml is USER CONFIG — never overwrite it. Only daemon-default.yaml (template) is synced.
 const BUNDLED_SCRIPTS = ['signal-capture.js', 'distill.js', 'schema.js', 'pending-traits.js', 'migrate-v2.js', 'daemon.js', 'telegram-adapter.js', 'feishu-adapter.js', 'daemon-default.yaml', 'providers.js', 'session-analytics.js', 'resolve-yaml.js', 'utils.js'];
 const scriptsDir = path.join(__dirname, 'scripts');
 
+// Protect daemon.yaml: create backup before any sync operation
+const DAEMON_YAML_BACKUP = path.join(METAME_DIR, 'daemon.yaml.bak');
+try {
+  if (fs.existsSync(DAEMON_CONFIG_FILE)) {
+    const content = fs.readFileSync(DAEMON_CONFIG_FILE, 'utf8');
+    // Only backup if it has real config (not just the default template)
+    if (content.includes('enabled: true') || content.includes('bot_token:') && !content.includes('bot_token: null')) {
+      fs.copyFileSync(DAEMON_CONFIG_FILE, DAEMON_YAML_BACKUP);
+    }
+  }
+} catch { /* non-fatal */ }
+
 let scriptsUpdated = false;
 for (const script of BUNDLED_SCRIPTS) {
   const src = path.join(scriptsDir, script);
@@ -63,7 +76,11 @@ if (scriptsUpdated) {
       }, 2000);
       const DAEMON_SCRIPT = path.join(METAME_DIR, 'daemon.js');
       setTimeout(() => {
-        const bg = spawn(process.execPath, [DAEMON_SCRIPT], {
+        // Use caffeinate on macOS to prevent sleep while daemon is running
+        const isNotWindows = process.platform !== 'win32';
+        const cmd = isNotWindows ? 'caffeinate' : process.execPath;
+        const args = isNotWindows ? ['-i', process.execPath, DAEMON_SCRIPT] : [DAEMON_SCRIPT];
+        const bg = spawn(cmd, args, {
           detached: true,
           stdio: 'ignore',
           env: { ...process.env, HOME: HOME_DIR, METAME_ROOT: __dirname },
@@ -77,11 +94,27 @@ if (scriptsUpdated) {
   }
 }
 
-// Ensure daemon.yaml exists (copy from template if missing)
+// Load daemon config for local launch flags
+let daemonCfg = {};
+try {
+  if (fs.existsSync(DAEMON_CONFIG_FILE)) {
+    const _yaml = require(path.join(__dirname, 'node_modules', 'js-yaml'));
+    const raw = _yaml.load(fs.readFileSync(DAEMON_CONFIG_FILE, 'utf8')) || {};
+    daemonCfg = raw.daemon || {};
+  }
+} catch { /* non-fatal */ }
+
+// Ensure daemon.yaml exists (restore backup or copy from template)
 if (!fs.existsSync(DAEMON_CONFIG_FILE)) {
-  const daemonTemplate = path.join(scriptsDir, 'daemon-default.yaml');
-  if (fs.existsSync(daemonTemplate)) {
-    fs.copyFileSync(daemonTemplate, DAEMON_CONFIG_FILE);
+  if (fs.existsSync(DAEMON_YAML_BACKUP)) {
+    // Restore from backup — user had real config that was lost
+    fs.copyFileSync(DAEMON_YAML_BACKUP, DAEMON_CONFIG_FILE);
+    console.log('⚠️  daemon.yaml was missing — restored from backup.');
+  } else {
+    const daemonTemplate = path.join(scriptsDir, 'daemon-default.yaml');
+    if (fs.existsSync(daemonTemplate)) {
+      fs.copyFileSync(daemonTemplate, DAEMON_CONFIG_FILE);
+    }
   }
 }
 
@@ -161,6 +194,15 @@ function spawnDistillBackground() {
   const distillPath = path.join(METAME_DIR, 'distill.js');
   if (!fs.existsSync(distillPath)) return;
 
+  // Early exit if distillation already in progress (prevents duplicate spawns across terminals)
+  const lockFile = path.join(METAME_DIR, 'distill.lock');
+  if (fs.existsSync(lockFile)) {
+    try {
+      const lockAge = Date.now() - fs.statSync(lockFile).mtimeMs;
+      if (lockAge < 120000) return;
+    } catch { /* stale lock, proceed */ }
+  }
+
   const hasSignals = shouldDistill();
   const bootstrap = needsBootstrap();
 
@@ -1086,6 +1128,8 @@ if (isDaemon) {
   <string>com.metame.daemon</string>
   <key>ProgramArguments</key>
   <array>
+    <string>/usr/bin/caffeinate</string>
+    <string>-i</string>
     <string>${nodePath}</string>
     <string>${DAEMON_SCRIPT}</string>
   </array>
@@ -1207,7 +1251,11 @@ WantedBy=default.target
       console.error("❌ daemon.js not found. Reinstall MetaMe.");
       process.exit(1);
     }
-    const bg = spawn(process.execPath, [DAEMON_SCRIPT], {
+    // Use caffeinate on macOS/Linux to prevent sleep while daemon is running
+    const isNotWindows = process.platform !== 'win32';
+    const cmd = isNotWindows ? 'caffeinate' : process.execPath;
+    const args = isNotWindows ? ['-i', process.execPath, DAEMON_SCRIPT] : [DAEMON_SCRIPT];
+    const bg = spawn(cmd, args, {
       detached: true,
       stdio: 'ignore',
       env: { ...process.env, HOME: HOME_DIR, METAME_ROOT: __dirname },
@@ -1363,7 +1411,9 @@ if (isSync) {
 
   console.log(`\n🔄 Resuming session ${bestSession.id.slice(0, 8)}...\n`);
   const providerEnv = (() => { try { return require(path.join(__dirname, 'scripts', 'providers.js')).buildActiveEnv(); } catch { return {}; } })();
-  const syncChild = spawn('claude', ['--resume', bestSession.id], {
+  const resumeArgs = ['--resume', bestSession.id];
+  if (daemonCfg.dangerously_skip_permissions) resumeArgs.push('--dangerously-skip-permissions');
+  const syncChild = spawn('claude', resumeArgs, {
     stdio: 'inherit',
     env: { ...process.env, ...providerEnv, METAME_ACTIVE_SESSION: 'true' }
   });
@@ -1398,6 +1448,9 @@ if (activeProviderName !== 'anthropic') {
 
 // Build launch args — inject system prompt for new users
 const launchArgs = process.argv.slice(2);
+if (daemonCfg.dangerously_skip_permissions && !launchArgs.includes('--dangerously-skip-permissions')) {
+  launchArgs.push('--dangerously-skip-permissions');
+}
 if (!isKnownUser) {
   launchArgs.push(
     '--append-system-prompt',

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.3.17",
+    "version": "1.3.18",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {

package/scripts/daemon-default.yaml

@@ -12,8 +12,27 @@ feishu:
   app_secret: null
   allowed_chat_ids: []
 
+projects:
+  # Per-project heartbeat tasks. Each project's tasks are isolated and
+  # notifications arrive as colored Feishu cards (visually distinct).
+  #
+  # example_project:
+  #   name: "My Project"
+  #   icon: "🎬"
+  #   color: "orange"        # blue|orange|green|red|grey|purple|turquoise
+  #   heartbeat_tasks:
+  #     - name: "daily-task"
+  #       cwd: "~/AGI/MyProject"
+  #       model: "sonnet"
+  #       interval: "24h"
+  #       notify: true
+  #       enabled: true
+  #       prompt: "..."
+  #       allowedTools: [Read, Write, WebSearch]
+
 heartbeat:
   tasks: []
+    # Legacy flat tasks (no project isolation). New tasks should go under projects: above.
     # Examples — uncomment or add your own:
     #
     # Scheduled task (calls claude -p with your profile context):

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) {
@@ -221,6 +252,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 +321,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 +428,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 +479,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 +521,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);
           }
         }
       }
@@ -880,6 +980,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 +1118,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 = expandPath(p.cwd).replace(/^~/, HOME);
+      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 +1275,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 +1308,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 +1336,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 +1401,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 +1907,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> — 切换工作目录',
@@ -1652,13 +1968,32 @@ 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 = expandPath(proj.cwd).replace(/^~/, HOME);
+    const st = loadState();
+    const recentInDir = listRecentSessions(1, projCwd);
+    if (recentInDir.length > 0 && recentInDir[0].sessionId) {
+      st.sessions[chatId] = { id: recentInDir[0].sessionId, cwd: projCwd, started: true };
+    } else {
+      const newSess = createSession(chatId, projCwd, proj.name || key);
+      st.sessions[chatId] = { id: newSess.id, cwd: projCwd, started: false };
+    }
+    saveState(st);
+    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 +2193,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 +2294,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 = '';
@@ -2133,7 +2469,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
@@ -2306,6 +2642,20 @@ 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
@@ -2326,7 +2676,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 +2693,60 @@ 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 = expandPath(proj.cwd).replace(/^~/, HOME);
+    const st = loadState();
+    const recentInDir = listRecentSessions(1, projCwd);
+    if (recentInDir.length > 0 && recentInDir[0].sessionId) {
+      st.sessions[chatId] = { id: recentInDir[0].sessionId, cwd: projCwd, started: true };
+    } else {
+      const newSess = createSession(chatId, projCwd, proj.name || key);
+      st.sessions[chatId] = { id: newSess.id, cwd: projCwd, started: false };
+    }
+    saveState(st);
+    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 +2755,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 +2767,16 @@ 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) {
     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,16 +2784,18 @@ 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);
@@ -2419,6 +2819,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';
@@ -2453,7 +2863,8 @@ async function askClaude(bot, chatId, prompt) {
     const markedFiles = fileMarkers.map(m => m.match(/\[\[FILE:([^\]]+)\]\]/)[1].trim());
     const cleanOutput = output.replace(/\s*\[\[FILE:[^\]]+\]\]/g, '').trim();
 
-    await bot.sendMarkdown(chatId, cleanOutput);
+    const replyMsg = await bot.sendMarkdown(chatId, cleanOutput);
+    if (replyMsg && replyMsg.message_id && session) trackMsgSession(replyMsg.message_id, session);
 
     // Combine: marked files + auto-detected content files from Write operations
     const allFiles = new Set(markedFiles);
@@ -2604,6 +3015,18 @@ async function startFeishuBridge(config, executeTaskByName) {
       // Handle text message
       if (text) {
         log('INFO', `Feishu message from ${chatId}: ${text.slice(0, 50)}`);
+        // 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);
       }
     });
@@ -2669,7 +3092,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 +3125,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 +3142,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 +3155,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 +3183,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;

package/scripts/feishu-adapter.js

@@ -38,7 +38,7 @@ function createBot(config) {
      * Send a plain text message
      */
     async sendMessage(chatId, text) {
-      await client.im.message.create({
+      const res = await client.im.message.create({
         params: { receive_id_type: 'chat_id' },
         data: {
           receive_id: chatId,
@@ -46,20 +46,91 @@ function createBot(config) {
           content: JSON.stringify({ text }),
         },
       });
+      // Return Telegram-compatible shape so daemon can edit it later
+      const msgId = res?.data?.message_id;
+      return msgId ? { message_id: msgId } : null;
+    },
+
+    async editMessage(chatId, messageId, text) {
+      try {
+        await client.im.message.patch({
+          path: { message_id: messageId },
+          data: { content: JSON.stringify({ text }) },
+        });
+      } catch { /* non-fatal */ }
     },
 
     /**
-     * Send markdown (Feishu doesn't support raw markdown — sends as text)
+     * Send markdown as Feishu interactive card (lark_md renders bold, lists, code, links)
      */
     async sendMarkdown(chatId, markdown) {
-      await client.im.message.create({
+      // Convert standard markdown → lark_md compatible format
+      let content = markdown
+        .replace(/^(#{1,3})\s+(.+)$/gm, '**$2**')   // headers → bold
+        .replace(/^---+$/gm, '─────────────────────');  // hr → unicode line
+
+      // Split into chunks if too long (lark_md element limit ~4000 chars)
+      const MAX_CHUNK = 3800;
+      const chunks = [];
+      if (content.length <= MAX_CHUNK) {
+        chunks.push(content);
+      } else {
+        // Split on double newlines to avoid breaking mid-paragraph
+        const paragraphs = content.split(/\n\n/);
+        let buf = '';
+        for (const p of paragraphs) {
+          if (buf.length + p.length + 2 > MAX_CHUNK && buf) {
+            chunks.push(buf);
+            buf = p;
+          } else {
+            buf = buf ? buf + '\n\n' + p : p;
+          }
+        }
+        if (buf) chunks.push(buf);
+      }
+
+      const elements = chunks.map(c => ({
+        tag: 'div',
+        text: { tag: 'lark_md', content: c },
+      }));
+
+      const card = {
+        config: { wide_screen_mode: true },
+        elements,
+      };
+
+      const res = await client.im.message.create({
         params: { receive_id_type: 'chat_id' },
         data: {
           receive_id: chatId,
-          msg_type: 'text',
-          content: JSON.stringify({ text: markdown }),
+          msg_type: 'interactive',
+          content: JSON.stringify(card),
         },
       });
+      const msgId = res?.data?.message_id;
+      return msgId ? { message_id: msgId } : null;
+    },
+
+    /**
+     * Send a colored interactive card (for project-tagged notifications)
+     * @param {string} chatId
+     * @param {string} title - card header text
+     * @param {string} body - card body (lark markdown)
+     * @param {string} color - header color: blue|orange|green|red|grey|purple|turquoise
+     */
+    async sendCard(chatId, { title, body, color = 'blue' }) {
+      const elements = body ? [{ tag: 'div', text: { tag: 'lark_md', content: body } }] : [];
+      const card = {
+        config: { wide_screen_mode: true },
+        header: { title: { tag: 'plain_text', content: title }, template: color },
+        elements,
+      };
+      const res = await client.im.message.create({
+        params: { receive_id_type: 'chat_id' },
+        data: { receive_id: chatId, msg_type: 'interactive', content: JSON.stringify(card) },
+      });
+      const msgId = res?.data?.message_id;
+      return msgId ? { message_id: msgId } : null;
     },
 
     /**

package/scripts/signal-capture.js

@@ -13,7 +13,6 @@ const path = require('path');
 const os = require('os');
 
 const BUFFER_FILE = path.join(os.homedir(), '.metame', 'raw_signals.jsonl');
-const MAX_BUFFER_LINES = 50; // Safety cap to avoid unbounded growth
 
 // === CONFIDENCE PATTERNS ===
 
@@ -110,11 +109,6 @@ process.stdin.on('end', () => {
 
     existingLines.push(JSON.stringify(entry));
 
-    // Keep only the most recent entries (drop oldest)
-    if (existingLines.length > MAX_BUFFER_LINES) {
-      existingLines = existingLines.slice(-MAX_BUFFER_LINES);
-    }
-
     fs.writeFileSync(BUFFER_FILE, existingLines.join('\n') + '\n');
 
   } catch {