metame-cli 1.3.2 → 1.3.4

package/README.md

@@ -161,18 +161,27 @@ metame daemon install-launchd         # macOS auto-start (RunAtLoad + KeepAlive)
 
 | Command | Description |
 |---------|-------------|
+| `/last` | **Quick resume** — 优先当前目录最近 session，否则全局最近 |
 | `/new` | Start new session — pick project directory from button list |
-| `/resume` | Resume a session — clickable list scoped to current workdir |
-| `/continue` | Continue the most recent terminal session |
+| `/new <name>` | Start new session with a name (e.g., `/new API重构`) |
+| `/resume` | Resume a session — clickable list, shows session names + real-time timestamps |
+| `/resume <name>` | Resume by name (supports partial match, cross-project) |
+| `/name <name>` | Name the current session (syncs with computer's `/rename`) |
 | `/cd` | Change working directory — with directory browser |
+| `/cd last` | **Sync to computer** — jump to the most recent session's directory |
 | `/session` | Current session info |
+| `/continue` | Continue the most recent terminal session |
 
 Just type naturally for conversation — every message stays in the same Claude Code session with full context.
 
+**Session naming:** Sessions can be named via `/new <name>`, `/name <name>` (mobile), or Claude Code's `/rename` (desktop). Names are stored in Claude's native session index and sync across all interfaces — name it on your phone, see it on your computer.
+
 **How it works:**
 
 Each chat gets a persistent session via `claude -p --resume <session-id>`. This is the same Claude Code engine as your terminal — same tools (file editing, bash, code search), same conversation history. You can start work on your computer and `/resume` from your phone, or vice versa.
 
+**Parallel request handling:** The daemon uses async spawning, so multiple users or overlapping requests don't block each other. Each Claude call runs in a non-blocking subprocess.
+
 **Other commands:**
 
 | Command | Description |

package/index.js

@@ -571,11 +571,12 @@ if (isDaemon) {
   const DAEMON_SCRIPT = path.join(METAME_DIR, 'daemon.js');
 
   if (subCmd === 'init') {
-    // Create config from template
-    if (fs.existsSync(DAEMON_CONFIG)) {
-      console.log("⚠️  daemon.yaml already exists at ~/.metame/daemon.yaml");
-      console.log("   Delete it first if you want to re-initialize.");
-    } else {
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(r => rl.question(q, r));
+
+    // Create config from template if not exists
+    if (!fs.existsSync(DAEMON_CONFIG)) {
       const templateSrc = fs.existsSync(DAEMON_DEFAULT)
         ? DAEMON_DEFAULT
         : path.join(METAME_DIR, 'daemon-default.yaml');
@@ -585,45 +586,113 @@ if (isDaemon) {
         console.error("❌ Template not found. Reinstall MetaMe.");
         process.exit(1);
       }
-      // Ensure directory permissions (700)
       try { fs.chmodSync(METAME_DIR, 0o700); } catch { /* ignore on Windows */ }
-      console.log("✅ MetaMe daemon initialized.");
-      console.log(`   Config: ${DAEMON_CONFIG}`);
+      console.log("✅ Config created: ~/.metame/daemon.yaml\n");
+    } else {
+      console.log("✅ Config exists: ~/.metame/daemon.yaml\n");
+    }
+
+    const yaml = require(path.join(__dirname, 'node_modules', 'js-yaml'));
+    let cfg = yaml.load(fs.readFileSync(DAEMON_CONFIG, 'utf8')) || {};
+
+    // --- Telegram Setup ---
+    console.log("━━━ 📱 Telegram Setup ━━━");
+    console.log("Steps:");
+    console.log("  1. Open Telegram, search @BotFather");
+    console.log("  2. Send /newbot, follow prompts to create a bot");
+    console.log("  3. Copy the bot token (looks like: 123456:ABC-DEF...)");
+    console.log("");
+
+    const tgToken = (await ask("Paste your Telegram bot token (Enter to skip): ")).trim();
+    if (tgToken) {
+      if (!cfg.telegram) cfg.telegram = {};
+      cfg.telegram.enabled = true;
+      cfg.telegram.bot_token = tgToken;
+
+      console.log("\nFinding your chat ID...");
+      console.log("  → Send any message to your bot in Telegram first, then press Enter.");
+      await ask("Press Enter after you've messaged your bot: ");
+
+      try {
+        const https = require('https');
+        const chatIds = await new Promise((resolve, reject) => {
+          https.get(`https://api.telegram.org/bot${tgToken}/getUpdates`, (res) => {
+            let body = '';
+            res.on('data', d => body += d);
+            res.on('end', () => {
+              try {
+                const data = JSON.parse(body);
+                const ids = new Set();
+                if (data.result) {
+                  for (const u of data.result) {
+                    if (u.message && u.message.chat) ids.add(u.message.chat.id);
+                  }
+                }
+                resolve([...ids]);
+              } catch { resolve([]); }
+            });
+          }).on('error', () => resolve([]));
+        });
+
+        if (chatIds.length > 0) {
+          cfg.telegram.allowed_chat_ids = chatIds;
+          console.log(`  ✅ Found chat ID(s): ${chatIds.join(', ')}`);
+        } else {
+          console.log("  ⚠️  No messages found. Make sure you messaged the bot.");
+          console.log("     You can set allowed_chat_ids manually in daemon.yaml later.");
+        }
+      } catch {
+        console.log("  ⚠️  Could not fetch chat ID. Set it manually in daemon.yaml.");
+      }
+      console.log("  ✅ Telegram configured!\n");
+    } else {
+      console.log("  Skipped.\n");
+    }
+
+    // --- Feishu Setup ---
+    console.log("━━━ 📘 Feishu (Lark) Setup ━━━");
+    console.log("Steps:");
+    console.log("  1. Go to: https://open.feishu.cn/app");
+    console.log("     → Create App (企业自建应用)");
+    console.log("  2. In 'Credentials' (凭证与基础信息), copy App ID & App Secret");
+    console.log("  3. In 'Bot' (机器人), enable bot capability");
+    console.log("  4. In 'Event Subscription' (事件订阅):");
+    console.log("     → Set mode to 'Long Connection' (使用长连接接收事件)");
+    console.log("     → Add event: im.message.receive_v1 (接收消息)");
+    console.log("  5. In 'Permissions' (权限管理), add:");
+    console.log("     → im:message, im:message:send_as_bot, im:chat");
+    console.log("  6. Publish the app version (创建版本 → 申请发布)");
+    console.log("");
+
+    const feishuAppId = (await ask("Paste your Feishu App ID (Enter to skip): ")).trim();
+    if (feishuAppId) {
+      const feishuSecret = (await ask("Paste your Feishu App Secret: ")).trim();
+      if (feishuSecret) {
+        if (!cfg.feishu) cfg.feishu = {};
+        cfg.feishu.enabled = true;
+        cfg.feishu.app_id = feishuAppId;
+        cfg.feishu.app_secret = feishuSecret;
+        if (!cfg.feishu.allowed_chat_ids) cfg.feishu.allowed_chat_ids = [];
+        console.log("  ✅ Feishu configured!");
+        console.log("  Note: allowed_chat_ids is empty = allow all users.");
+        console.log("        To restrict, add chat IDs to daemon.yaml later.\n");
+      }
+    } else {
+      console.log("  Skipped.\n");
     }
 
-    console.log("\n📱 Telegram Setup (optional):");
-    console.log("   1. Message @BotFather on Telegram → /newbot");
-    console.log("   2. Copy the bot token");
-    console.log("   3. Edit ~/.metame/daemon.yaml:");
-    console.log("      telegram:");
-    console.log("        enabled: true");
-    console.log("        bot_token: \"YOUR_TOKEN\"");
-    console.log("        allowed_chat_ids: [YOUR_CHAT_ID]");
-    console.log("   4. To find your chat_id: message your bot, then run:");
-    console.log("      curl https://api.telegram.org/botYOUR_TOKEN/getUpdates");
-    console.log("\n📘 Feishu Setup (optional):");
-    console.log("   1. Go to open.feishu.cn → Create App → get app_id & app_secret");
-    console.log("   2. Enable Bot capability + im:message events");
-    console.log("   3. Enable 'Long Connection' (长连接) mode in Event Subscription");
-    console.log("   4. Edit ~/.metame/daemon.yaml:");
-    console.log("      feishu:");
-    console.log("        enabled: true");
-    console.log("        app_id: \"YOUR_APP_ID\"");
-    console.log("        app_secret: \"YOUR_APP_SECRET\"");
-    console.log("        allowed_chat_ids: [CHAT_ID]");
-
-    console.log("\n   Then: metame daemon start");
-
-    // Optional launchd setup (macOS only)
+    // Write config
+    fs.writeFileSync(DAEMON_CONFIG, yaml.dump(cfg, { lineWidth: -1 }), 'utf8');
+    console.log("━━━ ✅ Setup Complete ━━━");
+    console.log(`Config saved: ${DAEMON_CONFIG}`);
+    console.log("\nNext steps:");
+    console.log("  metame daemon start         — start the daemon");
+    console.log("  metame daemon status        — check status");
     if (process.platform === 'darwin') {
-      const plistDir = path.join(HOME_DIR, 'Library', 'LaunchAgents');
-      const plistPath = path.join(plistDir, 'com.metame.daemon.plist');
-      console.log("\n🍎 Auto-start on macOS (optional):");
-      console.log("   To start daemon automatically on login:");
-      console.log(`   metame daemon start  (first time to verify it works)`);
-      console.log(`   Then create: ${plistPath}`);
-      console.log("   Or run: metame daemon install-launchd");
+      console.log("  metame daemon install-launchd — auto-start on login");
     }
+
+    rl.close();
     process.exit(0);
   }
 
@@ -676,18 +745,21 @@ if (isDaemon) {
   }
 
   if (subCmd === 'start') {
+    // Kill any lingering daemon.js processes to avoid Feishu WebSocket conflicts
+    try {
+      const { execSync: es } = require('child_process');
+      const pids = es("pgrep -f 'node.*daemon\\.js' 2>/dev/null || true", { encoding: 'utf8' }).trim();
+      if (pids) {
+        for (const p of pids.split('\n').filter(Boolean)) {
+          const n = parseInt(p, 10);
+          if (n && n !== process.pid) try { process.kill(n, 'SIGKILL'); } catch { /* */ }
+        }
+        es('sleep 1');
+      }
+    } catch { /* ignore */ }
     // Check if already running
     if (fs.existsSync(DAEMON_PID)) {
-      const existingPid = parseInt(fs.readFileSync(DAEMON_PID, 'utf8').trim(), 10);
-      try {
-        process.kill(existingPid, 0); // test if alive
-        console.log(`⚠️  Daemon already running (PID: ${existingPid})`);
-        console.log("   Use 'metame daemon stop' first.");
-        process.exit(1);
-      } catch {
-        // Stale PID file — clean up
-        fs.unlinkSync(DAEMON_PID);
-      }
+      try { fs.unlinkSync(DAEMON_PID); } catch { /* */ }
     }
     if (!fs.existsSync(DAEMON_CONFIG)) {
       console.error("❌ No config found. Run: metame daemon init");
@@ -717,11 +789,21 @@ if (isDaemon) {
     const pid = parseInt(fs.readFileSync(DAEMON_PID, 'utf8').trim(), 10);
     try {
       process.kill(pid, 'SIGTERM');
+      // Wait for process to die (up to 3s), then force kill
+      let dead = false;
+      for (let i = 0; i < 6; i++) {
+        const { execSync: es } = require('child_process');
+        es('sleep 0.5');
+        try { process.kill(pid, 0); } catch { dead = true; break; }
+      }
+      if (!dead) {
+        try { process.kill(pid, 'SIGKILL'); } catch { /* already gone */ }
+      }
       console.log(`✅ Daemon stopped (PID: ${pid})`);
     } catch (e) {
       console.log(`⚠️  Process ${pid} not found (may have already exited).`);
-      fs.unlinkSync(DAEMON_PID);
     }
+    try { fs.unlinkSync(DAEMON_PID); } catch { /* ignore */ }
     process.exit(0);
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.3.2",
+    "version": "1.3.4",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -11,7 +11,9 @@
         "scripts/"
     ],
     "scripts": {
-        "start": "node index.js"
+        "start": "node index.js",
+        "sync:plugin": "cp scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/daemon.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml plugin/scripts/ && echo '✅ Plugin scripts synced'",
+        "precommit": "npm run sync:plugin"
     },
     "keywords": [
         "claude",

package/scripts/daemon.js

@@ -615,12 +615,27 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
       await sendDirPicker(bot, chatId, 'new', 'Pick a workdir:');
       return;
     }
-    if (!fs.existsSync(arg)) {
-      await bot.sendMessage(chatId, `Path not found: ${arg}`);
-      return;
+    // Parse: /new <path> [name] — if arg contains a space after a valid path, rest is name
+    let dirPath = arg;
+    let sessionName = '';
+    // Try full arg as path first; if not, split on spaces to find path + name
+    if (!fs.existsSync(dirPath)) {
+      const spaceIdx = arg.indexOf(' ');
+      if (spaceIdx > 0) {
+        const maybePath = arg.slice(0, spaceIdx);
+        if (fs.existsSync(maybePath)) {
+          dirPath = maybePath;
+          sessionName = arg.slice(spaceIdx + 1).trim();
+        }
+      }
+      if (!fs.existsSync(dirPath)) {
+        await bot.sendMessage(chatId, `Path not found: ${dirPath}`);
+        return;
+      }
     }
-    const session = createSession(chatId, arg);
-    await bot.sendMessage(chatId, `New session.\nWorkdir: ${session.cwd}`);
+    const session = createSession(chatId, dirPath, sessionName || '');
+    const label = sessionName ? `[${sessionName}]` : '';
+    await bot.sendMessage(chatId, `New session ${label}\nWorkdir: ${session.cwd}`);
     return;
   }
 
@@ -640,6 +655,54 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     return;
   }
 
+  // /last — smart resume: prefer current cwd, then most recent globally
+  if (text === '/last') {
+    const curSession = getSession(chatId);
+    const curCwd = curSession ? curSession.cwd : null;
+
+    // Strategy: try current cwd first, then fall back to global
+    let s = null;
+    if (curCwd) {
+      const cwdSessions = listRecentSessions(1, curCwd);
+      if (cwdSessions.length > 0) s = cwdSessions[0];
+    }
+    if (!s) {
+      const globalSessions = listRecentSessions(1);
+      if (globalSessions.length > 0) s = globalSessions[0];
+    }
+
+    if (!s) {
+      // Last resort: use __continue__ to resume whatever Claude thinks is last
+      const state2 = loadState();
+      state2.sessions[chatId] = {
+        id: '__continue__',
+        cwd: curCwd || HOME,
+        created: new Date().toISOString(),
+        started: true,
+      };
+      saveState(state2);
+      await bot.sendMessage(chatId, `⚡ Resuming last session in ${path.basename(curCwd || HOME)}`);
+      return;
+    }
+
+    const state2 = loadState();
+    state2.sessions[chatId] = {
+      id: s.sessionId,
+      cwd: s.projectPath || HOME,
+      started: true,
+    };
+    saveState(state2);
+    // Display: name/summary + id on separate lines
+    const name = s.customTitle;
+    const shortId = s.sessionId.slice(0, 8);
+    let title = name ? `[${name}]` : (s.summary || s.firstPrompt || '').slice(0, 40) || 'Session';
+    // Get real file mtime for accuracy
+    const realMtime = getSessionFileMtime(s.sessionId, s.projectPath);
+    const ago = formatRelativeTime(new Date(realMtime || s.fileMtime || new Date(s.modified).getTime()).toISOString());
+    await bot.sendMessage(chatId, `⚡ ${title}\n📁 ${path.basename(s.projectPath || '')} #${shortId}\n🕐 ${ago}`);
+    return;
+  }
+
   if (text === '/resume' || text.startsWith('/resume ')) {
     const arg = text.slice(7).trim();
 
@@ -669,11 +732,24 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
       return;
     }
 
-    // Argument given → match by prefix or full ID
-    const match = recentSessions.length > 0
-      ? recentSessions.find(s => s.sessionId.startsWith(arg))
-      : null;
-    const fullMatch = match || listRecentSessions(50).find(s => s.sessionId.startsWith(arg));
+    // Argument given → match by name, then by session ID prefix
+    const allSessions = listRecentSessions(50);
+    const argLower = arg.toLowerCase();
+    // 1. Match by customTitle (Claude's native session name)
+    let fullMatch = allSessions.find(s => {
+      return s.customTitle && s.customTitle.toLowerCase() === argLower;
+    });
+    // 2. Partial name match
+    if (!fullMatch) {
+      fullMatch = allSessions.find(s => {
+        return s.customTitle && s.customTitle.toLowerCase().includes(argLower);
+      });
+    }
+    // 3. Session ID prefix match
+    if (!fullMatch) {
+      fullMatch = recentSessions.find(s => s.sessionId.startsWith(arg))
+        || allSessions.find(s => s.sessionId.startsWith(arg));
+    }
     const sessionId = fullMatch ? fullMatch.sessionId : arg;
     const cwd = (fullMatch && fullMatch.projectPath) || (getSession(chatId) && getSession(chatId).cwd) || HOME;
 
@@ -681,21 +757,31 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     state2.sessions[chatId] = {
       id: sessionId,
       cwd,
-      created: new Date().toISOString(),
       started: true,
     };
     saveState(state2);
-    const label = fullMatch ? (fullMatch.summary || fullMatch.firstPrompt || '').slice(0, 40) : sessionId.slice(0, 8);
+    const name = fullMatch ? fullMatch.customTitle : null;
+    const label = name || (fullMatch ? (fullMatch.summary || fullMatch.firstPrompt || '').slice(0, 40) : sessionId.slice(0, 8));
     await bot.sendMessage(chatId, `Resumed: ${label}\nWorkdir: ${cwd}`);
     return;
   }
 
   if (text === '/cd' || text.startsWith('/cd ')) {
-    const newCwd = text.slice(3).trim();
+    let newCwd = text.slice(3).trim();
     if (!newCwd) {
       await sendDirPicker(bot, chatId, 'cd', 'Switch workdir:');
       return;
     }
+    // /cd last — jump to the most recent session's directory globally
+    if (newCwd === 'last') {
+      const recent = listRecentSessions(1);
+      if (recent.length > 0 && recent[0].projectPath) {
+        newCwd = recent[0].projectPath;
+      } else {
+        await bot.sendMessage(chatId, 'No recent session found.');
+        return;
+      }
+    }
     if (!fs.existsSync(newCwd)) {
       await bot.sendMessage(chatId, `Path not found: ${newCwd}`);
       return;
@@ -711,12 +797,35 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     return;
   }
 
+  if (text.startsWith('/name ')) {
+    const name = text.slice(6).trim();
+    if (!name) {
+      await bot.sendMessage(chatId, 'Usage: /name <session name>');
+      return;
+    }
+    const session = getSession(chatId);
+    if (!session) {
+      await bot.sendMessage(chatId, 'No active session. Start one first.');
+      return;
+    }
+
+    // Write to Claude's session file (unified with /rename on desktop)
+    if (writeSessionName(session.id, session.cwd, name)) {
+      await bot.sendMessage(chatId, `✅ Session: [${name}]`);
+    } else {
+      await bot.sendMessage(chatId, `⚠️ Failed to save name, but session continues.`);
+    }
+    return;
+  }
+
   if (text === '/session') {
     const session = getSession(chatId);
     if (!session) {
       await bot.sendMessage(chatId, 'No active session. Send any message to start one.');
     } else {
-      await bot.sendMessage(chatId, `Session: ${session.id.slice(0, 8)}...\nWorkdir: ${session.cwd}\nStarted: ${session.created}`);
+      const name = getSessionName(session.id);
+      const nameTag = name ? ` [${name}]` : '';
+      await bot.sendMessage(chatId, `Session: ${session.id.slice(0, 8)}...${nameTag}\nWorkdir: ${session.cwd}`);
     }
     return;
   }
@@ -796,12 +905,14 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
   if (text.startsWith('/')) {
     await bot.sendMessage(chatId, [
       'Commands:',
-      '/new [path] — new session',
-      '/continue — resume last computer session',
-      '/resume <id> — resume specific session',
-      '/cd <path> — change workdir',
+      '/last — ⚡ 一键继续最近的 session',
+      '/new [path] [name] — new session',
+      '/resume [name] — 选择/搜索 session',
+      '/continue — resume last in current dir',
+      '/name <name> — name current session',
+      '/cd <path|last> — change workdir (last=最近目录)',
       '/session — current session info',
-      '/status /tasks /run /budget /quiet /reload',
+      '/status /tasks /budget /reload',
       '',
       'Or just type naturally.',
     ].join('\n'));
@@ -845,30 +956,87 @@ function listRecentSessions(limit, cwd) {
         if (data.entries) all = all.concat(data.entries);
       } catch { /* skip */ }
     }
-    // Filter: must have summary and at least 3 messages
-    all = all.filter(s => s.summary && s.messageCount >= 3);
+    // Filter: must have at least 1 message
+    all = all.filter(s => s.messageCount >= 1);
     // Filter by cwd if provided
     if (cwd) {
       const matched = all.filter(s => s.projectPath === cwd);
       if (matched.length > 0) all = matched;
       // else fallback to all projects
     }
-    // Sort by modified desc, take top N
-    all.sort((a, b) => new Date(b.modified) - new Date(a.modified));
+    // Sort by fileMtime (most accurate), fall back to modified
+    all.sort((a, b) => {
+      const aTime = a.fileMtime || new Date(a.modified).getTime();
+      const bTime = b.fileMtime || new Date(b.modified).getTime();
+      return bTime - aTime;
+    });
     return all.slice(0, limit || 10);
   } catch {
     return [];
   }
 }
 
+/**
+ * Get the actual file mtime of a session's .jsonl file (most accurate)
+ */
+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)) {
+      return fs.statSync(sessionFile).mtimeMs;
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+/**
+ * Format relative time (e.g., "5分钟前", "2小时前", "昨天")
+ */
+function formatRelativeTime(dateStr) {
+  const now = Date.now();
+  const then = new Date(dateStr).getTime();
+  const diffMs = now - then;
+  const diffMin = Math.floor(diffMs / 60000);
+  const diffHour = Math.floor(diffMs / 3600000);
+  const diffDay = Math.floor(diffMs / 86400000);
+
+  if (diffMin < 1) return '刚刚';
+  if (diffMin < 60) return `${diffMin}分钟前`;
+  if (diffHour < 24) return `${diffHour}小时前`;
+  if (diffDay === 1) return '昨天';
+  if (diffDay < 7) return `${diffDay}天前`;
+  return new Date(dateStr).toLocaleDateString('zh-CN', { month: 'numeric', day: 'numeric' });
+}
+
 /**
  * Format a session entry into a short, readable label for buttons
+ * Enhanced: shows relative time, project, name/summary, and first message preview
  */
 function sessionLabel(s) {
+  // Use Claude's native customTitle (unified with /rename on desktop)
+  const name = s.customTitle;
+
   const proj = s.projectPath ? path.basename(s.projectPath) : '';
-  const date = new Date(s.modified).toLocaleDateString('zh-CN', { month: 'numeric', day: 'numeric' });
-  const title = (s.summary || '').slice(0, 28);
-  return `${date} ${proj ? proj + ': ' : ''}${title}`;
+  // Use real file mtime for accuracy, fall back to index data
+  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, 4);
+
+  if (name) {
+    return `${ago} [${name}] ${proj} #${shortId}`;
+  }
+
+  // Use summary, or fall back to firstPrompt preview
+  let title = (s.summary || '').slice(0, 20);
+  if (!title && s.firstPrompt) {
+    title = s.firstPrompt.slice(0, 20);
+    if (s.firstPrompt.length > 20) title += '..';
+  }
+
+  return `${ago} ${proj ? proj + ': ' : ''}${title || ''} #${shortId}`;
 }
 
 /**
@@ -901,18 +1069,65 @@ function getSession(chatId) {
   return state.sessions[chatId] || null;
 }
 
-function createSession(chatId, cwd) {
+function createSession(chatId, cwd, name) {
   const state = loadState();
   const sessionId = crypto.randomUUID();
   state.sessions[chatId] = {
     id: sessionId,
     cwd: cwd || HOME,
-    created: new Date().toISOString(),
     started: false, // true after first message sent
   };
   saveState(state);
-  log('INFO', `New session for ${chatId}: ${sessionId} (cwd: ${state.sessions[chatId].cwd})`);
-  return state.sessions[chatId];
+
+  // If name provided, write to Claude's session file (same as /rename on desktop)
+  if (name) {
+    writeSessionName(sessionId, cwd || HOME, name);
+  }
+
+  log('INFO', `New session for ${chatId}: ${sessionId}${name ? ' [' + name + ']' : ''} (cwd: ${state.sessions[chatId].cwd})`);
+  return { ...state.sessions[chatId], id: sessionId };
+}
+
+/**
+ * Get session name from Claude's sessions-index.json (unified with /rename)
+ */
+function getSessionName(sessionId) {
+  try {
+    if (!fs.existsSync(CLAUDE_PROJECTS_DIR)) return '';
+    const projects = fs.readdirSync(CLAUDE_PROJECTS_DIR);
+    for (const proj of projects) {
+      const indexFile = path.join(CLAUDE_PROJECTS_DIR, proj, 'sessions-index.json');
+      if (!fs.existsSync(indexFile)) continue;
+      const data = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
+      if (data.entries) {
+        const entry = data.entries.find(e => e.sessionId === sessionId);
+        if (entry && entry.customTitle) return entry.customTitle;
+      }
+    }
+  } catch { /* ignore */ }
+  return '';
+}
+
+/**
+ * Write session name to Claude's session file (same format as /rename on desktop)
+ */
+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 entry = JSON.stringify({ type: 'custom-title', customTitle: name, sessionId }) + '\n';
+    fs.appendFileSync(sessionFile, entry, 'utf8');
+    log('INFO', `Named session ${sessionId.slice(0, 8)}: ${name}`);
+    return true;
+  } catch (e) {
+    log('WARN', `Failed to write session name: ${e.message}`);
+    return false;
+  }
 }
 
 function markSessionStarted(chatId) {
@@ -923,8 +1138,89 @@ function markSessionStarted(chatId) {
   }
 }
 
+/**
+ * Auto-generate a session name using Haiku (async, non-blocking).
+ * Writes to Claude's session file (unified with /rename).
+ */
+async function autoNameSession(chatId, sessionId, firstPrompt, cwd) {
+  try {
+    const namePrompt = `Generate a very short session name (2-5 Chinese characters, no punctuation, no quotes) that captures the essence of this user request:
+
+"${firstPrompt.slice(0, 200)}"
+
+Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug修复, 代码审查`;
+
+    const { output } = await spawnClaudeAsync(
+      ['-p', '--model', 'haiku'],
+      namePrompt,
+      HOME,
+      15000 // 15s timeout
+    );
+
+    if (output) {
+      // Clean up: remove quotes, punctuation, trim
+      let name = output.replace(/["""''`]/g, '').replace(/[.,!?:;。，！？：；]/g, '').trim();
+      // Limit to reasonable length
+      if (name.length > 12) name = name.slice(0, 12);
+      if (name.length >= 2) {
+        // Write to Claude's session file (unified with /rename on desktop)
+        writeSessionName(sessionId, cwd, name);
+      }
+    }
+  } catch (e) {
+    log('DEBUG', `Auto-name failed for ${sessionId.slice(0, 8)}: ${e.message}`);
+  }
+}
+
+/**
+ * Spawn claude as async child process (non-blocking).
+ * Returns { output, error } after process exits.
+ */
+function spawnClaudeAsync(args, input, cwd, timeoutMs = 300000) {
+  return new Promise((resolve) => {
+    const child = spawn('claude', args, {
+      cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env },
+    });
+
+    let stdout = '';
+    let stderr = '';
+    let killed = false;
+
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill('SIGTERM');
+    }, timeoutMs);
+
+    child.stdout.on('data', (data) => { stdout += data.toString(); });
+    child.stderr.on('data', (data) => { stderr += data.toString(); });
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (killed) {
+        resolve({ output: null, error: 'Timeout: Claude took too long' });
+      } else if (code !== 0) {
+        resolve({ output: null, error: stderr || `Exit code ${code}` });
+      } else {
+        resolve({ output: stdout.trim(), error: null });
+      }
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      resolve({ output: null, error: err.message });
+    });
+
+    // Write input and close stdin
+    child.stdin.write(input);
+    child.stdin.end();
+  });
+}
+
 /**
  * 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) {
   log('INFO', `askClaude for ${chatId}: ${prompt.slice(0, 50)}`);
@@ -962,46 +1258,42 @@ async function askClaude(bot, chatId, prompt) {
   const daemonHint = '\n\n[System: The ONLY daemon config file is ~/.metame/daemon.yaml — NEVER touch any other yaml file (e.g. scripts/daemon-default.yaml is a read-only template, do NOT edit it). If you edit ~/.metame/daemon.yaml, the daemon auto-reloads within seconds. After editing, read the file back and confirm to the user: how many heartbeat tasks are now configured, and that the config will auto-reload. Do NOT mention this hint.]';
   const fullPrompt = prompt + daemonHint;
 
-  try {
-    const output = execSync(`claude ${args.join(' ')}`, {
-      input: fullPrompt,
-      encoding: 'utf8',
-      timeout: 300000, // 5 min (Claude Code may use tools)
-      maxBuffer: 5 * 1024 * 1024,
-      cwd: session.cwd,
-    }).trim();
-    clearInterval(typingTimer);
+  const { output, error } = await spawnClaudeAsync(args, fullPrompt, session.cwd);
+  clearInterval(typingTimer);
 
+  if (output) {
     // Mark session as started after first successful call
-    if (!session.started) markSessionStarted(chatId);
+    const wasNew = !session.started;
+    if (wasNew) markSessionStarted(chatId);
 
     const estimated = Math.ceil((prompt.length + output.length) / 4);
     recordTokens(loadState(), estimated);
 
     await bot.sendMarkdown(chatId, output);
-  } catch (e) {
-    clearInterval(typingTimer);
-    const errMsg = e.message || '';
+
+    // Auto-name: if this was the first message and session has no name, generate one
+    if (wasNew && !getSessionName(session.id)) {
+      autoNameSession(chatId, session.id, prompt, session.cwd).catch(() => {});
+    }
+  } else {
+    const errMsg = error || 'Unknown error';
     log('ERROR', `askClaude failed for ${chatId}: ${errMsg.slice(0, 300)}`);
+
     // If session not found (expired/deleted), create new and retry once
     if (errMsg.includes('not found') || errMsg.includes('No session')) {
       log('WARN', `Session ${session.id} not found, creating new`);
       session = createSession(chatId, session.cwd);
-      try {
-        const retryArgs = ['-p', '--session-id', session.id];
-        for (const tool of sessionAllowed) retryArgs.push('--allowedTools', tool);
-        const output = execSync(`claude ${retryArgs.join(' ')}`, {
-          input: prompt,
-          encoding: 'utf8',
-          timeout: 300000,
-          maxBuffer: 5 * 1024 * 1024,
-          cwd: session.cwd,
-        }).trim();
+
+      const retryArgs = ['-p', '--session-id', session.id];
+      for (const tool of sessionAllowed) retryArgs.push('--allowedTools', tool);
+
+      const retry = await spawnClaudeAsync(retryArgs, prompt, session.cwd);
+      if (retry.output) {
         markSessionStarted(chatId);
-        await bot.sendMarkdown(chatId, output);
-      } catch (e2) {
-        log('ERROR', `askClaude retry failed: ${(e2.message || '').slice(0, 200)}`);
-        try { await bot.sendMessage(chatId, `Error: ${(e2.message || '').slice(0, 200)}`); } catch { /* */ }
+        await bot.sendMarkdown(chatId, retry.output);
+      } else {
+        log('ERROR', `askClaude retry failed: ${(retry.error || '').slice(0, 200)}`);
+        try { await bot.sendMessage(chatId, `Error: ${(retry.error || '').slice(0, 200)}`); } catch { /* */ }
       }
     } else {
       try { await bot.sendMessage(chatId, `Error: ${errMsg.slice(0, 200)}`); } catch { /* */ }
@@ -1046,6 +1338,24 @@ async function startFeishuBridge(config, executeTaskByName) {
 // ---------------------------------------------------------
 // PID MANAGEMENT
 // ---------------------------------------------------------
+
+// Kill any existing daemon before starting (takeover strategy)
+function killExistingDaemon() {
+  if (!fs.existsSync(PID_FILE)) return;
+  try {
+    const oldPid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
+    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' });
+    }
+  } catch {
+    // Process doesn't exist or already dead
+  }
+  try { fs.unlinkSync(PID_FILE); } catch {}
+}
+
 function writePid() {
   fs.writeFileSync(PID_FILE, String(process.pid), 'utf8');
 }
@@ -1073,6 +1383,8 @@ async function main() {
     process.exit(1);
   }
 
+  // Takeover: kill any existing daemon
+  killExistingDaemon();
   writePid();
   const state = loadState();
   state.pid = process.pid;

package/scripts/feishu-adapter.js

@@ -121,12 +121,32 @@ function createBot(config) {
           loggerLevel: Lark.LoggerLevel.info,
         });
 
+        // Dedup: track recent message_ids (Feishu may redeliver on slow ack)
+        const _seenMsgIds = new Map(); // message_id → timestamp
+        const DEDUP_TTL = 60000; // 60s window
+        function isDuplicate(msgId) {
+          if (!msgId) return false;
+          const now = Date.now();
+          // Cleanup old entries
+          if (_seenMsgIds.size > 200) {
+            for (const [k, t] of _seenMsgIds) {
+              if (now - t > DEDUP_TTL) _seenMsgIds.delete(k);
+            }
+          }
+          if (_seenMsgIds.has(msgId)) return true;
+          _seenMsgIds.set(msgId, now);
+          return false;
+        }
+
         const eventDispatcher = new Lark.EventDispatcher({}).register({
           'im.message.receive_v1': async (data) => {
             try {
               const msg = data.message;
               if (!msg) return;
 
+              // Dedup by message_id
+              if (isDuplicate(msg.message_id)) return;
+
               const chatId = msg.chat_id;
               let text = '';
 
@@ -143,7 +163,8 @@ function createBot(config) {
               text = text.replace(/@_user_\d+\s*/g, '').trim();
 
               if (text) {
-                onMessage(chatId, text, data);
+                // Fire-and-forget: don't block the event loop (SDK needs fast ack)
+                Promise.resolve().then(() => onMessage(chatId, text, data)).catch(() => {});
               }
             } catch (e) {
               // Non-fatal
@@ -159,7 +180,7 @@ function createBot(config) {
               if (action && chatId) {
                 const cmd = action.value && action.value.cmd;
                 if (cmd) {
-                  onMessage(chatId, cmd, data);
+                  Promise.resolve().then(() => onMessage(chatId, cmd, data)).catch(() => {});
                 }
               }
             } catch (e) {