metame-cli 1.3.13 → 1.3.16

package/README.md

@@ -47,10 +47,13 @@
 * **🪞 Metacognition Layer (v1.3):** MetaMe now observes *how* you think, not just *what* you say. Behavioral pattern detection runs inside the existing Haiku distill call (zero extra cost). It tracks decision patterns, cognitive load, comfort zones, and avoidance topics across sessions. When persistent patterns emerge, MetaMe injects a one-line mirror observation — e.g., *"You tend to avoid testing until forced"* — with a 14-day cooldown per pattern. Conditional reflection prompts appear only when triggered (every 7th distill or 3x consecutive comfort zone). All injection logic runs in Node.js; Claude receives only pre-decided directives, never rules to self-evaluate.
 * **📱 Remote Claude Code (v1.3):** Full Claude Code from your phone via Telegram or Feishu (Lark). Stateful sessions with `--resume` — same conversation history, tool use, and file editing as your terminal. Interactive buttons for project/session picking, directory browser, and macOS launchd auto-start.
 * **🔄 Workflow Engine (v1.3):** Define multi-step skill chains as heartbeat tasks. Each workflow runs in a single Claude Code session via `--resume`, so step outputs flow as context to the next step. Example: `deep-research` → `tech-writing` → `wechat-publisher` — fully automated content pipeline.
-* **⏹ Full Terminal Control from Mobile (v1.3.13):** `/stop` (ESC), `/undo` (ESC×2) with native file-history restoration, `/model` interactive model switcher, concurrent task protection, daemon auto-restart, and `metame continue` for seamless mobile-to-desktop sync.
-* **🏥 Emergency Recovery (v1.3.13):** `/doctor` interactive diagnostics with one-tap fix buttons, `/sh` direct shell access from your phone (bypasses Claude entirely — the lifeline when everything else is broken), automatic config backup before any setting change, `/fix` to restore last known good config.
+* **⏹ Full Terminal Control from Mobile (v1.3.10):** `/stop` (ESC), `/undo` (ESC×2) with native file-history restoration, concurrent task protection, daemon auto-restart, and `metame continue` for seamless mobile-to-desktop sync.
 * **🎯 Goal Alignment & Drift Detection (v1.3.11):** MetaMe now tracks whether your sessions align with your declared goals. Each distill assesses `goal_alignment` (aligned/partial/drifted) at zero extra API cost. When you drift for 2+ consecutive sessions, a mirror observation is injected passively; after 3+ sessions, a reflection prompt gently asks: "Was this an intentional pivot, or did you lose track?" Session logs now record project, branch, intent, and file directories for richer retrospective analysis. Pattern detection can spot sustained drift trends across your session history.
+* **🔌 Provider Relay (v1.3.11):** Use any Anthropic-compatible API relay as your backend — no file mutation, no invasion. MetaMe injects `ANTHROPIC_BASE_URL` + `ANTHROPIC_API_KEY` at spawn time. Separate provider roles for `active`, `distill`, and `daemon` tasks. CLI: `metame provider add/use/remove/test`. Config stored in `~/.metame/providers.yaml`.
 * **📊 Session History Bootstrap (v1.3.12):** Solves the cold-start problem — MetaMe previously needed 5-7 sessions before producing any visible feedback. Now, on first launch it auto-bootstraps your session history from existing Claude Code JSONL transcripts (zero API cost). Three complementary data layers: **Skeleton** (structural facts extracted locally — tools, duration, project, branch, intent), **Facets** (interaction quality from `/insights` — outcome, friction, satisfaction, when available), and **Haiku** (metacognitive judgments — cognitive load, zones, goal alignment, from the existing distill call). Patterns and mirror observations can appear from your very first MetaMe session.
+* **🏥 Emergency Recovery (v1.3.13):** `/doctor` interactive diagnostics with one-tap fix buttons, `/sh` direct shell access from your phone (bypasses Claude entirely — the lifeline when everything else is broken), automatic config backup before any setting change, `/fix` to restore last known good config. `/model` interactive model switcher with auto-backup.
+* **🌐 Browser Automation (v1.3.15):** Native Playwright MCP integration — auto-registered on first run. Every MetaMe user gets browser control capability out of the box. Combined with Skills, enables workflows like automated podcast publishing, form filling, and web scraping.
+* **📂 Interactive File Browser (v1.3.15):** `/list` shows clickable button cards — folders expand inline, files download on tap. Folder buttons survive daemon restarts (absolute paths, no expiry). Zero token cost.
 
 ## 🛠 Prerequisites
 
@@ -263,6 +266,9 @@ This resumes the latest session with all mobile messages included. Also works as
 📖 Read: 「config.yaml」
 ✏️ Edit: 「daemon.js」
 💻 Bash: 「git status」
+🔧 Skill: 「wechat-publisher」
+🌐 Browser: 「navigate」
+🔗 MCP:server: 「action」
 ```
 
 **File transfer (v1.3.8):** Seamlessly move files between your phone and computer.
@@ -325,6 +331,7 @@ Bot: 回退到哪一轮？
 | `/tasks` | List scheduled heartbeat tasks |
 | `/run <name>` | Run a task immediately |
 | `/model [name]` | Interactive model switcher with buttons (sonnet, opus, haiku). Auto-backs up config before switching. |
+| `/list` | File browser with clickable buttons — folders expand, files download. Zero tokens. |
 | `/budget` | Today's token usage |
 | `/quiet` | Silence mirror/reflections for 48h |
 | `/reload` | Manually reload daemon.yaml (also auto-reloads on file change) |
@@ -386,6 +393,41 @@ 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
 
+### 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.
+
+**How it works:** At spawn time, MetaMe injects `ANTHROPIC_BASE_URL` + `ANTHROPIC_API_KEY` environment variables. Zero file mutation — `~/.claude/settings.json` is never touched.
+
+**CLI commands:**
+
+```bash
+metame provider                         # List all providers
+metame provider add <name>              # Add a relay (prompts for URL & key)
+metame provider use <name>              # Switch active provider
+metame provider remove <name>           # Remove a provider (can't remove 'anthropic')
+metame provider test [name]             # Test connectivity
+metame provider set-role distill <name> # Use a different provider for background distill
+metame provider set-role daemon <name>  # Use a different provider for daemon tasks
+```
+
+**Configuration** (`~/.metame/providers.yaml`):
+
+```yaml
+active: 'anthropic'
+providers:
+  anthropic:
+    label: 'Anthropic (Official)'
+  my-relay:
+    label: 'My Relay'
+    base_url: 'https://api.relay.example.com/v1'
+    api_key: 'sk-xxx'
+distill_provider: null          # null = use active
+daemon_provider: null           # null = use active
+```
+
+Three independent provider roles let you optimize cost: e.g., use an official Anthropic key for active work, a cheaper relay for background distill, and another for daemon heartbeat tasks.
+
 ### Hot Reload (Refresh)
 
 If you update your profile or need to fix a broken context **without restarting your session**:
@@ -544,6 +586,20 @@ A: No. It *prepends* its meta-cognitive protocol to your existing `CLAUDE.md`. Y
 **Q: Is my data sent to a third party?**
 A: No. Your profile stays local at `~/.claude_profile.yaml`. MetaMe simply passes text to the official Claude Code tool.
 
+## 📋 Changelog
+
+| Version | Highlights |
+|---------|------------|
+| **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) |
+| **v1.3.14** | Fix daemon crash on fresh install (missing bundled scripts) |
+| **v1.3.13** | `/doctor` diagnostics, `/sh` direct shell, `/fix` config restore, `/model` interactive switcher with auto-backup, daemon state caching & config backup/restore |
+| **v1.3.12** | Session history bootstrap (cold-start fix), three-layer data architecture (Skeleton + Facets + Haiku), session summary extraction |
+| **v1.3.11** | Goal alignment & drift detection, provider relay system for third-party models, `/insights` facet integration |
+| **v1.3.10** | `/stop`, `/undo` with file restoration, `/model`, concurrent task protection, `metame continue`, daemon auto-restart on code change |
+| **v1.3.8** | Bidirectional file transfer (phone ↔ computer) |
+| **v1.3.7** | Real-time streaming status on mobile |
+| **v1.3** | Metacognition layer, remote Claude Code (Telegram & Feishu), workflow engine, heartbeat tasks, launchd auto-start |
+
 ## 📄 License
 
 MIT License. Feel free to fork, modify, and evolve your own Meta-Cognition.

package/index.js

@@ -13,6 +13,7 @@ const BRAIN_FILE = path.join(HOME_DIR, '.claude_profile.yaml');
 const PROJECT_FILE = path.join(process.cwd(), 'CLAUDE.md');
 const METAME_DIR = path.join(HOME_DIR, '.metame');
 const CLAUDE_SETTINGS = path.join(HOME_DIR, '.claude', 'settings.json');
+const CLAUDE_MCP_CONFIG = path.join(HOME_DIR, '.claude', 'mcp.json'); // legacy, kept for reference
 const SIGNAL_CAPTURE_SCRIPT = path.join(METAME_DIR, 'signal-capture.js');
 
 // ---------------------------------------------------------
@@ -23,7 +24,7 @@ if (!fs.existsSync(METAME_DIR)) {
 }
 
 // Auto-deploy bundled scripts to ~/.metame/
-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'];
+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');
 
 for (const script of BUNDLED_SCRIPTS) {
@@ -87,6 +88,13 @@ function ensureHookInstalled() {
 
 ensureHookInstalled();
 
+// ---------------------------------------------------------
+// 1.6b ENSURE PROJECT-LEVEL MCP CONFIG
+// ---------------------------------------------------------
+// MCP servers are registered per-project via .mcp.json (not user-scope ~/.claude.json)
+// so they only load when working in projects that need them.
+// The daemon's heartbeat tasks use cwd: ~/AGI/Digital_Me which has its own .mcp.json.
+
 // ---------------------------------------------------------
 // 1.7 PASSIVE DISTILLATION (Background, post-launch)
 // ---------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.3.13",
+    "version": "1.3.16",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -13,7 +13,7 @@
     "scripts": {
         "test": "node --test scripts/*.test.js",
         "start": "node index.js",
-        "sync:plugin": "cp scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/distill.js scripts/daemon.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml scripts/providers.js scripts/utils.js plugin/scripts/ && echo '✅ Plugin scripts synced'",
+        "sync:plugin": "cp scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/distill.js scripts/daemon.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml scripts/providers.js scripts/utils.js scripts/resolve-yaml.js plugin/scripts/ && echo '✅ Plugin scripts synced'",
         "restart:daemon": "node index.js stop 2>/dev/null; sleep 1; node index.js start 2>/dev/null || echo '⚠️  Daemon not running or restart failed'",
         "precommit": "npm run sync:plugin && npm run restart:daemon"
     },

package/scripts/daemon.js

@@ -640,6 +640,106 @@ async function sendBrowse(bot, chatId, mode, dirPath) {
   }
 }
 
+const DIR_LIST_TYPE_EMOJI = {
+  '.md': '📄', '.txt': '📄', '.pdf': '📕',
+  '.js': '⚙️', '.ts': '⚙️', '.py': '🐍', '.json': '📋', '.yaml': '📋', '.yml': '📋',
+  '.png': '🖼️', '.jpg': '🖼️', '.jpeg': '🖼️', '.gif': '🖼️', '.svg': '🖼️', '.webp': '🖼️',
+  '.wav': '🎵', '.mp3': '🎵', '.m4a': '🎵', '.flac': '🎵',
+  '.mp4': '🎬', '.mov': '🎬',
+  '.csv': '📊', '.xlsx': '📊',
+  '.html': '🌐', '.css': '🎨',
+  '.sh': '💻', '.bash': '💻',
+};
+
+/**
+ * List directory contents with file info + download buttons + folder nav buttons.
+ * Zero token cost — pure daemon fs operation.
+ */
+async function sendDirListing(bot, chatId, baseDir, arg) {
+  let targetDir = baseDir;
+  let globFilter = null;
+
+  if (arg) {
+    if (arg.includes('*')) {
+      globFilter = arg;
+    } else {
+      const sub = path.resolve(baseDir, arg);
+      if (fs.existsSync(sub) && fs.statSync(sub).isDirectory()) {
+        targetDir = sub;
+      } else {
+        await bot.sendMessage(chatId, `❌ Not found: ${arg}`);
+        return;
+      }
+    }
+  }
+
+  try {
+    let entries = fs.readdirSync(targetDir, { withFileTypes: true });
+    if (globFilter) {
+      const pattern = globFilter.replace(/\./g, '\\.').replace(/\*/g, '.*');
+      const re = new RegExp('^' + pattern + '$', 'i');
+      entries = entries.filter(e => re.test(e.name));
+    }
+    entries.sort((a, b) => {
+      if (a.isDirectory() && !b.isDirectory()) return -1;
+      if (!a.isDirectory() && b.isDirectory()) return 1;
+      return a.name.localeCompare(b.name);
+    });
+    entries = entries.filter(e => !e.name.startsWith('.'));
+
+    if (entries.length === 0) {
+      await bot.sendMessage(chatId, `📁 ${path.basename(targetDir)}/\n(empty)`);
+      return;
+    }
+
+    const allButtons = [];
+    const MAX_BUTTONS = 20;
+
+    for (const entry of entries.slice(0, MAX_BUTTONS)) {
+      const fullPath = path.join(targetDir, entry.name);
+      if (entry.isDirectory()) {
+        // Use absolute path directly for folders (survives daemon restart)
+        // Fall back to shortenPath only if path is too long for callback_data (64 byte limit)
+        const cbPath = fullPath.length <= 58 ? fullPath : shortenPath(fullPath);
+        allButtons.push([{ text: `📂 ${entry.name}/`, callback_data: `/list ${cbPath}` }]);
+      } else {
+        const ext = path.extname(entry.name).toLowerCase();
+        const emoji = DIR_LIST_TYPE_EMOJI[ext] || '📎';
+        let size = '';
+        try {
+          const stat = fs.statSync(fullPath);
+          const bytes = stat.size;
+          if (bytes < 1024) size = ` ${bytes}B`;
+          else if (bytes < 1048576) size = ` ${(bytes / 1024).toFixed(0)}KB`;
+          else size = ` ${(bytes / 1048576).toFixed(1)}MB`;
+        } catch { /* ignore */ }
+        if (isContentFile(fullPath)) {
+          const shortId = cacheFile(fullPath);
+          allButtons.push([{ text: `${emoji} ${entry.name}${size}`, callback_data: `/file ${shortId}` }]);
+        } else {
+          // Non-downloadable files shown as info-only buttons (no action)
+          allButtons.push([{ text: `${emoji} ${entry.name}${size}`, callback_data: 'noop' }]);
+        }
+      }
+    }
+
+    const header = `📁 ${path.basename(targetDir)}/` + (entries.length > MAX_BUTTONS ? ` (${MAX_BUTTONS}/${entries.length})` : '');
+    if (allButtons.length > 0 && bot.sendButtons) {
+      await bot.sendButtons(chatId, header, allButtons);
+    } else {
+      // Fallback for adapters without button support
+      const lines = [header];
+      for (const entry of entries.slice(0, MAX_BUTTONS)) {
+        const isDir = entry.isDirectory();
+        lines.push(isDir ? `  📂 ${entry.name}/` : `  📎 ${entry.name}`);
+      }
+      await bot.sendMessage(chatId, lines.join('\n'));
+    }
+  } catch (e) {
+    await bot.sendMessage(chatId, `❌ ${e.message}`);
+  }
+}
+
 /**
  * Unified command handler — shared by Telegram & Feishu
  */
@@ -653,6 +753,9 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     const dirPath = expandPath(parts.slice(1).join(' '));
     if (mode && dirPath && fs.existsSync(dirPath)) {
       await sendBrowse(bot, chatId, mode, dirPath);
+    } else if (/^p\d+$/.test(dirPath)) {
+      await bot.sendMessage(chatId, '⚠️ Button expired. Pick again:');
+      await sendDirPicker(bot, chatId, mode || 'cd', 'Switch workdir:');
     } else {
       await bot.sendMessage(chatId, 'Invalid browse path.');
     }
@@ -857,6 +960,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
         const name = target.customTitle || target.summary || '';
         const label = name ? name.slice(0, 40) : target.sessionId.slice(0, 8);
         await bot.sendMessage(chatId, `🔄 Synced to: ${label}\n📁 ${path.basename(target.projectPath)}`);
+        await sendDirListing(bot, chatId, target.projectPath, null);
         return;
       } else {
         await bot.sendMessage(chatId, 'No recent session found.');
@@ -864,7 +968,13 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
       }
     }
     if (!fs.existsSync(newCwd)) {
-      await bot.sendMessage(chatId, `Path not found: ${newCwd}`);
+      // Likely an expired path shortcode (e.g. p16) from a daemon restart
+      if (/^p\d+$/.test(newCwd)) {
+        await bot.sendMessage(chatId, '⚠️ Button expired (daemon restarted). Pick again:');
+        await sendDirPicker(bot, chatId, 'cd', 'Switch workdir:');
+      } else {
+        await bot.sendMessage(chatId, `Path not found: ${newCwd}`);
+      }
       return;
     }
     const state2 = loadState();
@@ -889,6 +999,26 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
       saveState(state2);
       await bot.sendMessage(chatId, `📁 ${path.basename(newCwd)}`);
     }
+    await sendDirListing(bot, chatId, newCwd, null);
+    return;
+  }
+
+  // /list [subdir|glob|fullpath] — list files (zero token, daemon-only)
+  if (text === '/list' || text.startsWith('/list ')) {
+    const session = getSession(chatId);
+    const cwd = session?.cwd || HOME;
+    const arg = text.slice(5).trim();
+    // If arg is an absolute or ~ path, list that directly
+    const expanded = arg ? expandPath(arg) : null;
+    if (expanded && /^p\d+$/.test(expanded)) {
+      // Expired shortcode from daemon restart
+      await bot.sendMessage(chatId, '⚠️ Button expired. Refreshing...');
+      await sendDirListing(bot, chatId, cwd, null);
+    } else if (expanded && path.isAbsolute(expanded) && fs.existsSync(expanded) && fs.statSync(expanded).isDirectory()) {
+      await sendDirListing(bot, chatId, expanded, null);
+    } else {
+      await sendDirListing(bot, chatId, cwd, arg || null);
+    }
     return;
   }
 
@@ -1014,6 +1144,12 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
   }
 
   if (text === '/stop') {
+    // Clear message queue (don't process queued messages after stop)
+    if (messageQueue.has(chatId)) {
+      const q = messageQueue.get(chatId);
+      if (q.timer) clearTimeout(q.timer);
+      messageQueue.delete(chatId);
+    }
     const proc = activeProcesses.get(chatId);
     if (proc && proc.child) {
       proc.aborted = true;
@@ -1025,6 +1161,59 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     return;
   }
 
+  // /quit — restart session process (reloads MCP/config, keeps same session)
+  if (text === '/quit') {
+    // Stop running task if any
+    if (messageQueue.has(chatId)) {
+      const q = messageQueue.get(chatId);
+      if (q.timer) clearTimeout(q.timer);
+      messageQueue.delete(chatId);
+    }
+    const proc = activeProcesses.get(chatId);
+    if (proc && proc.child) {
+      proc.aborted = true;
+      proc.child.kill('SIGINT');
+    }
+    const session = getSession(chatId);
+    const name = session ? getSessionName(session.id) : null;
+    const label = name || (session ? session.id.slice(0, 8) : 'none');
+    await bot.sendMessage(chatId, `🔄 Session restarted. MCP/config reloaded.\n📁 ${session ? path.basename(session.cwd) : '~'} [${label}]`);
+    return;
+  }
+
+  // /publish <otp> — npm publish with OTP (zero latency, no Claude)
+  if (text.startsWith('/publish ')) {
+    const otp = text.slice(9).trim();
+    if (!otp || !/^\d{6}$/.test(otp)) {
+      await bot.sendMessage(chatId, '用法: /publish 123456');
+      return;
+    }
+    const session = getSession(chatId);
+    const cwd = session?.cwd || HOME;
+    await bot.sendMessage(chatId, `📦 npm publish --otp=${otp} ...`);
+    try {
+      const child = spawn('npm', ['publish', `--otp=${otp}`], { cwd, timeout: 60000 });
+      let stdout = '', stderr = '';
+      child.stdout.on('data', d => { stdout += d; });
+      child.stderr.on('data', d => { stderr += d; });
+      await new Promise((resolve) => {
+        child.on('close', resolve);
+        child.on('error', resolve);
+      });
+      const output = (stdout + stderr).trim();
+      if (output.includes('+ metame-cli@') || output.includes('npm notice')) {
+        const ver = output.match(/metame-cli@([\d.]+)/);
+        await bot.sendMessage(chatId, `✅ Published${ver ? ' v' + ver[1] : ''}!`);
+      } else {
+        let msg = output.slice(0, 2000) || '(no output)';
+        await bot.sendMessage(chatId, `❌ ${msg}`);
+      }
+    } catch (e) {
+      await bot.sendMessage(chatId, `❌ ${e.message}`);
+    }
+    return;
+  }
+
   // /sh [command] — direct shell execution (emergency lifeline)
   if (text === '/sh' || text.startsWith('/sh ')) {
     const command = text.slice(3).trim();
@@ -1058,6 +1247,12 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
   }
 
   if (text === '/undo' || text.startsWith('/undo ')) {
+    // Clear message queue
+    if (messageQueue.has(chatId)) {
+      const q = messageQueue.get(chatId);
+      if (q.timer) clearTimeout(q.timer);
+      messageQueue.delete(chatId);
+    }
     // Stop running task first
     const proc = activeProcesses.get(chatId);
     if (proc && proc.child) {
@@ -1071,10 +1266,9 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
       return;
     }
 
-    // Find session .jsonl file
-    const projDirName = session.cwd.replace(/\//g, '-');
-    const sessionFile = path.join(HOME, '.claude', 'projects', projDirName, session.id + '.jsonl');
-    if (!fs.existsSync(sessionFile)) {
+    // Find session .jsonl file (scan Claude's native projects directory)
+    const sessionFile = findSessionFile(session.id);
+    if (!sessionFile) {
       await bot.sendMessage(chatId, 'Session file not found.');
       return;
     }
@@ -1226,10 +1420,13 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
 
       const turnsRemoved = turns.filter(t => t.lineIdx >= targetLineIdx).length;
       const allAffected = [...restored, ...deleted];
-      const fileList = allAffected.length > 0
-        ? allAffected.map(f => path.basename(f)).join(', ')
-        : 'none';
-      await bot.sendMessage(chatId, `⏪ 回退了 ${turnsRemoved} 轮对话\n📁 恢复 ${restored.length} / 删除 ${deleted.length}: ${fileList}`);
+      const turnsMsg = `⏪ 回退了 ${turnsRemoved} 轮对话`;
+      if (allAffected.length > 0) {
+        const fileList = allAffected.map(f => path.basename(f)).join(', ');
+        await bot.sendMessage(chatId, `${turnsMsg}\n📁 恢复 ${restored.length} / 删除 ${deleted.length}: ${fileList}`);
+      } else {
+        await bot.sendMessage(chatId, `${turnsMsg}\n📁 无文件变更需要恢复`);
+      }
     } catch (e) {
       await bot.sendMessage(chatId, `❌ Undo failed: ${e.message}`);
     }
@@ -1421,6 +1618,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
       '/session — 查看当前会话',
       '/stop — 中断当前任务 (ESC)',
       '/undo — 回退上一轮操作 (ESC×2)',
+      '/quit — 结束会话，重新加载 MCP/配置',
       '',
       `⚙️ /model [${currentModel}] /provider [${currentProvider}] /status /tasks /run /budget /reload`,
       '🔧 /doctor /fix /reset /sh <cmd>',
@@ -1431,9 +1629,42 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
   }
 
   // --- Natural language → Claude Code session ---
-  // Block if a task is already running (prevent session conflict)
+  // If a task is running: interrupt + collect + merge
   if (activeProcesses.has(chatId)) {
-    await bot.sendMessage(chatId, '⏳ 任务进行中，请等待完成或发 /stop 中断');
+    const isFirst = !messageQueue.has(chatId);
+    if (isFirst) {
+      messageQueue.set(chatId, { messages: [], timer: null });
+    }
+    const q = messageQueue.get(chatId);
+    q.messages.push(text);
+    // Only notify once (first message), subsequent ones silently queue
+    if (isFirst) {
+      await bot.sendMessage(chatId, '📝 收到，中断当前任务后一起处理');
+    }
+    // Interrupt the running Claude process
+    const proc = activeProcesses.get(chatId);
+    if (proc && proc.child && !proc.aborted) {
+      proc.aborted = true;
+      proc.child.kill('SIGINT');
+    }
+    // Debounce: wait 5s for more messages before processing
+    if (q.timer) clearTimeout(q.timer);
+    q.timer = setTimeout(async () => {
+      // Wait for active process to fully exit (up to 10s)
+      for (let i = 0; i < 20 && activeProcesses.has(chatId); i++) {
+        await sleep(500);
+      }
+      const msgs = q.messages.splice(0);
+      messageQueue.delete(chatId);
+      if (msgs.length === 0) return;
+      const combined = msgs.join('\n');
+      log('INFO', `Processing ${msgs.length} queued message(s) for ${chatId}`);
+      try {
+        await handleCommand(bot, chatId, combined, config, executeTaskByName);
+      } catch (e) {
+        log('ERROR', `Queue dispatch failed: ${e.message}`);
+      }
+    }, 5000);
     return;
   }
   const cd = checkCooldown(chatId);
@@ -1451,6 +1682,30 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
 const crypto = require('crypto');
 const CLAUDE_PROJECTS_DIR = path.join(HOME, '.claude', 'projects');
 
+/**
+ * Find a session's .jsonl file by scanning Claude's native projects directory.
+ * This avoids guessing the directory naming convention — we just search for the file.
+ * Results cached for 30s to avoid repeated directory scans in loops.
+ */
+const _sessionFileCache = new Map(); // sessionId -> { path, ts }
+function findSessionFile(sessionId) {
+  if (!sessionId || !fs.existsSync(CLAUDE_PROJECTS_DIR)) return null;
+  const cached = _sessionFileCache.get(sessionId);
+  if (cached && Date.now() - cached.ts < 30000) return cached.path;
+  const target = sessionId + '.jsonl';
+  try {
+    for (const proj of fs.readdirSync(CLAUDE_PROJECTS_DIR)) {
+      const candidate = path.join(CLAUDE_PROJECTS_DIR, proj, target);
+      if (fs.existsSync(candidate)) {
+        _sessionFileCache.set(sessionId, { path: candidate, ts: Date.now() });
+        return candidate;
+      }
+    }
+  } catch { /* ignore */ }
+  _sessionFileCache.set(sessionId, { path: null, ts: Date.now() });
+  return null;
+}
+
 /**
  * Scan all project session indexes, return most recent N sessions.
  * Results cached for 10 seconds to avoid repeated directory scans.
@@ -1537,10 +1792,9 @@ function listRecentSessions(limit, cwd) {
  */
 function getSessionFileMtime(sessionId, projectPath) {
   try {
-    if (!projectPath) return null;
-    const projDirName = projectPath.replace(/\//g, '-');
-    const sessionFile = path.join(CLAUDE_PROJECTS_DIR, projDirName, sessionId + '.jsonl');
-    if (fs.existsSync(sessionFile)) {
+    if (!sessionId) return null;
+    const sessionFile = findSessionFile(sessionId);
+    if (sessionFile) {
       return fs.statSync(sessionFile).mtimeMs;
     }
   } catch { /* ignore */ }
@@ -1653,12 +1907,10 @@ function getSessionName(sessionId) {
  */
 function writeSessionName(sessionId, cwd, name) {
   try {
-    const projDirName = cwd.replace(/\//g, '-');
-    const sessionFile = path.join(CLAUDE_PROJECTS_DIR, projDirName, sessionId + '.jsonl');
-    // Create directory if needed
-    const dir = path.dirname(sessionFile);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+    const sessionFile = findSessionFile(sessionId);
+    if (!sessionFile) {
+      log('WARN', `writeSessionName: session file not found for ${sessionId.slice(0, 8)}`);
+      return;
     }
     const entry = JSON.stringify({ type: 'custom-title', customTitle: name, sessionId }) + '\n';
     fs.appendFileSync(sessionFile, entry, 'utf8');
@@ -1771,6 +2023,9 @@ const TOOL_EMOJI = {
   WebFetch: '🌐',
   WebSearch: '🔍',
   Task: '🤖',
+  Skill: '🔧',
+  TodoWrite: '📋',
+  NotebookEdit: '📓',
   default: '🔧',
 };
 
@@ -1788,6 +2043,9 @@ const CONTENT_EXTENSIONS = new Set([
 // Active Claude processes per chat (for /stop)
 const activeProcesses = new Map(); // chatId -> { child, aborted }
 
+// Message queue for messages received while a task is running
+const messageQueue = new Map(); // chatId -> { messages: string[], notified: false }
+
 // File cache for button callbacks (shortId -> fullPath)
 const fileCache = new Map();
 const FILE_CACHE_TTL = 1800000; // 30 minutes
@@ -1886,9 +2144,33 @@ function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, ch
                   lastStatusTime = now;
                   const emoji = TOOL_EMOJI[toolName] || TOOL_EMOJI.default;
 
-                  // Extract brief context from tool input
+                  // Resolve display name and context for MCP/Skill/Task tools
+                  let displayName = toolName;
+                  let displayEmoji = emoji;
                   let context = '';
-                  if (block.input) {
+
+                  if (toolName === 'Skill' && block.input?.skill) {
+                    // Skill invocation: show skill name
+                    context = block.input.skill;
+                  } else if (toolName === 'Task' && block.input?.description) {
+                    // Agent task: show description
+                    context = block.input.description.slice(0, 30);
+                  } else if (toolName.startsWith('mcp__')) {
+                    // MCP tool: mcp__server__action → "MCP server: action"
+                    const parts = toolName.split('__');
+                    const server = parts[1] || 'unknown';
+                    const action = parts.slice(2).join('_') || '';
+                    if (server === 'playwright') {
+                      displayEmoji = '🌐';
+                      displayName = 'Browser';
+                      context = action.replace(/_/g, ' ');
+                    } else {
+                      displayEmoji = '🔗';
+                      displayName = `MCP:${server}`;
+                      context = action.replace(/_/g, ' ').slice(0, 25);
+                    }
+                  } else if (block.input) {
+                    // Standard tools: extract brief context
                     if (block.input.file_path) {
                       // Insert zero-width space before extension to prevent link parsing
                       const basename = path.basename(block.input.file_path);
@@ -1909,8 +2191,8 @@ function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, ch
                   }
 
                   const status = context
-                    ? `${emoji} ${toolName}: 「${context}」`
-                    : `${emoji} ${toolName}...`;
+                    ? `${displayEmoji} ${displayName}: 「${context}」`
+                    : `${displayEmoji} ${displayName}...`;
 
                   if (onStatus) {
                     onStatus(status).catch(() => {});
@@ -2041,11 +2323,14 @@ async function askClaude(bot, chatId, prompt) {
    - Multiple files: use multiple [[FILE:...]] tags]`;
   const fullPrompt = prompt + daemonHint;
 
-  // Use streaming mode to show progress (edit status msg in-place)
+  // Use streaming mode to show progress
+  // Telegram: edit status msg in-place; Feishu/others: send new messages
   const onStatus = async (status) => {
     try {
       if (statusMsgId && bot.editMessage) {
         await bot.editMessage(chatId, statusMsgId, status);
+      } else {
+        await bot.sendMessage(chatId, status);
       }
     } catch { /* ignore status update failures */ }
   };
@@ -2137,6 +2422,9 @@ async function askClaude(bot, chatId, prompt) {
         log('ERROR', `askClaude retry failed: ${(retry.error || '').slice(0, 200)}`);
         try { await bot.sendMessage(chatId, `Error: ${(retry.error || '').slice(0, 200)}`); } catch { /* */ }
       }
+    } else if (errMsg === 'Stopped by user' && messageQueue.has(chatId)) {
+      // Interrupted by message queue — suppress error, queue timer will handle it
+      log('INFO', `Task interrupted by new message for ${chatId}`);
     } else {
       try { await bot.sendMessage(chatId, `Error: ${errMsg.slice(0, 200)}`); } catch { /* */ }
     }
@@ -2219,8 +2507,11 @@ function killExistingDaemon() {
     if (oldPid && oldPid !== process.pid) {
       process.kill(oldPid, 'SIGTERM');
       log('INFO', `Killed existing daemon (PID: ${oldPid})`);
-      // Brief pause to let it clean up
-      require('child_process').execSync('sleep 1', { stdio: 'ignore' });
+      // Wait for old process to actually exit (up to 5s)
+      for (let i = 0; i < 10; i++) {
+        try { process.kill(oldPid, 0); } catch { break; } // throws if process gone
+        require('child_process').execSync('sleep 0.5', { stdio: 'ignore' });
+      }
     }
   } catch {
     // Process doesn't exist or already dead
@@ -2351,22 +2642,17 @@ async function main() {
 
   // Auto-restart: watch daemon.js for code changes (hot restart)
   const DAEMON_SCRIPT = path.join(METAME_DIR, 'daemon.js');
+  const _startTime = Date.now();
   let _restartDebounce = null;
   fs.watchFile(DAEMON_SCRIPT, { interval: 3000 }, (curr, prev) => {
     if (curr.mtimeMs === prev.mtimeMs) return;
+    // Ignore file changes within 10s of startup (avoids restart loop)
+    if (Date.now() - _startTime < 10000) return;
     if (_restartDebounce) clearTimeout(_restartDebounce);
-    _restartDebounce = setTimeout(async () => {
-      log('INFO', 'daemon.js changed on disk — auto-restarting...');
-      await notifyFn('🔄 Code updated, daemon restarting...').catch(() => {});
-      // Spawn new daemon process, then exit
-      const { spawn } = require('child_process');
-      const newDaemon = spawn(process.execPath, [DAEMON_SCRIPT], {
-        detached: true,
-        stdio: 'ignore',
-        env: { ...process.env, METAME_ROOT: process.env.METAME_ROOT || path.dirname(__dirname) },
-      });
-      newDaemon.unref();
-      setTimeout(() => process.exit(0), 500);
+    _restartDebounce = setTimeout(() => {
+      log('INFO', 'daemon.js changed on disk — exiting for restart...');
+      // Don't notify here — the NEW process will notify after startup
+      process.exit(0);
     }, 2000);
   });
 
@@ -2374,6 +2660,10 @@ async function main() {
   telegramBridge = await startTelegramBridge(config, executeTaskByName);
   feishuBridge = await startFeishuBridge(config, executeTaskByName);
 
+  // Notify once on startup (single message, no duplicates)
+  await sleep(1500); // Let polling settle
+  await notifyFn('✅ Daemon ready.').catch(() => {});
+
   // Graceful shutdown
   const shutdown = () => {
     log('INFO', 'Daemon shutting down...');

package/scripts/feishu-adapter.js

@@ -121,18 +121,13 @@ function createBot(config) {
     async downloadFile(messageId, fileKey, destPath, msgType = 'file') {
       try {
         let res;
-        if (msgType === 'image') {
-          // Images use im.image.get API
-          res = await client.im.image.get({
-            path: { image_key: fileKey },
-          });
-        } else {
-          // Files and media use im.messageResource.get API
-          res = await client.im.messageResource.get({
-            path: { message_id: messageId, file_key: fileKey },
-            params: { type: 'file' },
-          });
-        }
+        // All message attachments (images, files, media) use messageResource.get
+        // im.image.get only works for images uploaded by the app itself
+        const resourceType = msgType === 'image' ? 'image' : 'file';
+        res = await client.im.messageResource.get({
+          path: { message_id: messageId, file_key: fileKey },
+          params: { type: resourceType },
+        });
 
         // SDK returns writeFile method or getReadableStream
         if (res && res.writeFile) {
@@ -293,7 +288,7 @@ function createBot(config) {
                   fileInfo = {
                     messageId: msg.message_id,
                     fileKey: content.file_key || content.image_key,
-                    fileName: content.file_name || content.image_key || `file_${Date.now()}`,
+                    fileName: content.file_name || (content.image_key ? `image_${Date.now()}.png` : `file_${Date.now()}`),
                     msgType: msg.message_type, // 'file', 'image', or 'media'
                   };
                 } catch {}