metame-cli 1.4.0 → 1.4.5

package/README.md

@@ -205,6 +205,8 @@ metame daemon install-launchd   # Auto-start on boot + crash recovery
 
 Done. Open Telegram, message your bot.
 
+> **First message?** New chats aren't whitelisted yet. The bot will reply with a one-step setup command — just send `/bind personal ~/` and you're in.
+
 ---
 
 ## Core Capabilities
@@ -216,7 +218,7 @@ Done. Open Telegram, message your bot.
 | **Mobile Bridge** | Full Claude Code via Telegram/Feishu. Stateful sessions, file transfer both ways, real-time streaming status. |
 | **Skill Evolution** | Self-healing skill system. Auto-discovers missing skills, learns from browser recordings, evolves after every task. Skills get smarter over time. |
 | **Heartbeat System** | Three-layer programmable nervous system. Layer 0 kernel always-on (zero config). Layer 1 system evolution built-in (distill + memory + skills). Layer 2 your custom scheduled tasks with `require_idle`, `precondition`, `notify`, workflows. |
-| **Multi-Agent** | Multiple projects with dedicated chat groups. `/bind` for one-tap setup. True parallel execution. |
+| **Multi-Agent** | Multiple projects with dedicated chat groups. `/agent bind` for one-tap setup. True parallel execution. |
 | **Browser Automation** | Built-in Playwright MCP. Browser control out of the box for every user. |
 | **Provider Relay** | Route through any Anthropic-compatible API. Use GPT-4, DeepSeek, Gemini — zero config file mutation. |
 | **Metacognition** | Detects behavioral patterns (decision style, comfort zones, goal drift) and injects mirror observations. Zero extra API cost. |
@@ -298,10 +300,11 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 | `/new` | Start new session (project picker) |
 | `/resume` | Pick from session list |
 | `/stop` | Interrupt current task (ESC) |
-| `/undo` | Rollback with file restoration |
+| `/undo` | Show recent messages as buttons — tap to roll back context + code to before that message |
+| `/undo <hash>` | Roll back to a specific git checkpoint |
 | `/list` | Browse & download project files |
 | `/model` | Switch model (sonnet/opus/haiku) |
-| `/bind <name>` | Register group as dedicated agent |
+| `/agent bind <name> [dir]` | Register group as dedicated agent |
 | `/sh <cmd>` | Raw shell — bypasses Claude |
 | `/memory` | Memory stats: fact count, session tags, DB size |
 | `/memory <keyword>` | Search long-term facts by keyword |
@@ -340,7 +343,7 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 ## Security
 
 - All data stays on your machine. No cloud, no telemetry.
-- `allowed_chat_ids` whitelist — unauthorized users are silently ignored.
+- `allowed_chat_ids` whitelist — unauthorized users get a one-step `/bind` guide instead of silent rejection.
 - `operator_ids` for shared groups — non-operators get read-only mode.
 - `~/.metame/` directory is mode 700.
 - Bot tokens stored locally, never transmitted.
@@ -359,14 +362,20 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 
 > Both memory consolidation and session summarization run in the background via Haiku (`--model haiku`). Input is capped by code: skeleton text ≤ 3,000 chars, summary output ≤ 500 chars. Neither runs per-message — memory consolidation triggers on sleep mode (30-min idle), summaries trigger once per idle session.
 
-## Plugin (Lightweight)
+## Plugin
 
-Don't need mobile access? Install as a Claude Code plugin — profile injection + slash commands only:
+Install directly into Claude Code without npm:
 
 ```bash
 claude plugin install github:Yaron9/MetaMe/plugin
 ```
 
+Includes: cognitive profile injection, daemon (Telegram/Feishu), heartbeat tasks, layered memory, all mobile commands, slash commands (`/metame:evolve`, `/metame:daemon`, `/metame:refresh`, etc.).
+
+**One key difference from the npm CLI:** the plugin daemon starts when you open Claude Code and stops when you close it. It does not run 24/7 in the background. For always-on mobile access (receiving messages while Claude Code is closed), use the npm CLI with `metame daemon install-launchd`.
+
+Use the plugin if you prefer not to install a global npm package and only need mobile access while Claude Code is open. Use the npm CLI (`metame-cli`) for 24/7 daemon, the `metame` command, and first-run interview.
+
 ## License
 
 MIT

package/index.js

@@ -140,7 +140,21 @@ function ensureHookInstalled() {
 ensureHookInstalled();
 
 // ---------------------------------------------------------
-// 1.6b ENSURE PROJECT-LEVEL MCP CONFIG
+// 1.6b LOCAL ACTIVITY HEARTBEAT
+// ---------------------------------------------------------
+// Touch ~/.metame/local_active so the daemon knows the user is active on desktop.
+// This prevents dream tasks (require_idle: true) from firing during live Claude sessions.
+try {
+  const localActiveFile = path.join(METAME_DIR, 'local_active');
+  // Ensure file exists (open with 'a' is a no-op if it already exists)
+  fs.closeSync(fs.openSync(localActiveFile, 'a'));
+  // Update mtime so daemon idle detection sees fresh activity
+  const now = new Date();
+  fs.utimesSync(localActiveFile, now, now);
+} catch { /* non-fatal */ }
+
+// ---------------------------------------------------------
+// 1.6c 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.

package/package.json

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

package/scripts/daemon.js

@@ -924,19 +924,41 @@ function physiologicalHeartbeat(config) {
 }
 
 // ---------------------------------------------------------
-// HEARTBEAT SCHEDULER
+// HEARTBEAT TASK HELPERS (single source of truth)
 // ---------------------------------------------------------
-function startHeartbeat(config, notifyFn) {
-  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 || {})) {
+
+/**
+ * Collect all heartbeat tasks from config (general + per-project).
+ * Each project task gets _project metadata attached.
+ * Returns { general: [...], project: [...], all: [...] }
+ */
+function getAllTasks(cfg) {
+  const general = (cfg.heartbeat && cfg.heartbeat.tasks) || [];
+  const project = [];
+  const generalNames = new Set(general.map(t => t.name));
+  for (const [key, proj] of Object.entries(cfg.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 || '🤖' } });
+      if (generalNames.has(t.name)) log('WARN', `Duplicate task name "${t.name}" in project "${key}" and general heartbeat`);
+      project.push({ ...t, _project: { key, name: proj.name || key, color: proj.color || 'blue', icon: proj.icon || '🤖' } });
     }
   }
-  const tasks = [...legacyTasks, ...projectTasks];
+  return { general, project, all: [...general, ...project] };
+}
+
+/**
+ * Find a task by name across all groups.
+ */
+function findTask(cfg, name) {
+  const { general, project } = getAllTasks(cfg);
+  const found = general.find(t => t.name === name) || project.find(t => t.name === name);
+  return found || null;
+}
+
+// ---------------------------------------------------------
+// HEARTBEAT SCHEDULER
+// ---------------------------------------------------------
+function startHeartbeat(config, notifyFn) {
+  const { all: tasks } = getAllTasks(config);
 
   const enabledTasks = tasks.filter(t => t.enabled !== false);
   const checkIntervalSec = (config.daemon && config.daemon.heartbeat_check_interval) || 60;
@@ -978,6 +1000,9 @@ function startHeartbeat(config, notifyFn) {
       log('INFO', '[DAEMON] Entering Sleep Mode');
       // Generate summaries for sessions idle 2-24h
       spawnSessionSummaries();
+    } else if (!idle && _inSleepMode) {
+      _inSleepMode = false;
+      log('INFO', '[DAEMON] Exiting Sleep Mode — local activity detected');
     }
 
     // ② Task heartbeat (burns tokens on schedule)
@@ -1101,9 +1126,10 @@ async function startTelegramBridge(config, executeTaskByName) {
           // Exception: /bind and /agent bind/new are allowed from any chat so users can self-register new groups
           const allowedIds = (loadConfig().telegram && loadConfig().telegram.allowed_chat_ids) || [];
           const trimmedText = msg.text && msg.text.trim();
-          const isBindCmd = trimmedText && (trimmedText.startsWith('/agent bind') || trimmedText.startsWith('/agent new'));
+          const isBindCmd = trimmedText && (trimmedText.startsWith('/bind') || trimmedText.startsWith('/agent bind') || trimmedText.startsWith('/agent new'));
           if (!allowedIds.includes(chatId) && !isBindCmd) {
             log('WARN', `Rejected message from unauthorized chat: ${chatId}`);
+            bot.sendMessage(chatId, `⚠️ This chat (ID: ${chatId}) is not authorized.\n\nTo get started, send:\n/bind personal ~/\n\nThis will register this chat and bind it to your home directory.`).catch(() => {});
             continue;
           }
 
@@ -1527,6 +1553,7 @@ async function doBindAgent(bot, chatId, agentName, agentCwd) {
 }
 
 async function handleCommand(bot, chatId, text, config, executeTaskByName, senderId = null, readOnly = false) {
+  if (text && !text.startsWith('/chatid') && !text.startsWith('/myid')) log('INFO', `CMD [${String(chatId).slice(-8)}]: ${text.slice(0, 80)}`);
   const state = loadState();
 
   // --- /chatid: reply with current chatId ---
@@ -1714,7 +1741,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
         const factCount = s.facts ?? '?';
         const tagFile = path.join(HOME, '.metame', 'session_tags.json');
         let tagCount = 0;
-        try { tagCount = Object.keys(JSON.parse(fs.readFileSync(tagFile, 'utf8'))).length; } catch {}
+        try { tagCount = Object.keys(JSON.parse(fs.readFileSync(tagFile, 'utf8'))).length; } catch { }
         const lines = [
           `🧠 *Memory Stats*`,
           `━━━━━━━━━━━━━━━━`,
@@ -1971,6 +1998,11 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     }
   }
 
+  // /bind <name> [cwd] → alias for /agent bind <name> [cwd]
+  if (text === '/bind' || text.startsWith('/bind ')) {
+    text = '/agent bind' + text.slice(5);
+  }
+
   if (text === '/agent' || text.startsWith('/agent ')) {
     const agentArg = text === '/agent' ? '' : text.slice(7).trim();
     const agentParts = agentArg.split(/\s+/);
@@ -2269,22 +2301,25 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
   }
 
   if (text === '/tasks') {
+    const { general, project } = getAllTasks(config);
     let msg = '';
-    // Legacy flat tasks
-    const legacyTasks = (config.heartbeat && config.heartbeat.tasks) || [];
-    if (legacyTasks.length > 0) {
+    if (general.length > 0) {
       msg += '📋 General:\n';
-      for (const t of legacyTasks) {
+      for (const t of general) {
         const ts = state.tasks[t.name] || {};
         msg += `${t.enabled !== false ? '✅' : '⏸'} ${t.name} (${t.interval}) ${ts.status || 'never_run'}\n`;
       }
     }
-    // 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) {
+    // Project tasks grouped by _project
+    const byProject = new Map();
+    for (const t of project) {
+      const pk = t._project.key;
+      if (!byProject.has(pk)) byProject.set(pk, { proj: t._project, tasks: [] });
+      byProject.get(pk).tasks.push(t);
+    }
+    for (const [, { proj, tasks }] of byProject) {
+      msg += `\n${proj.icon} ${proj.name}:\n`;
+      for (const t of tasks) {
         const ts = state.tasks[t.name] || {};
         msg += `${t.enabled !== false ? '✅' : '⏸'} ${t.name} (${t.interval}) ${ts.status || 'never_run'}\n`;
       }
@@ -2403,13 +2438,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       return;
     }
     const taskName = text.slice(5).trim();
-    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);
+    const task = findTask(config, taskName);
     if (!task) { await bot.sendMessage(chatId, `❌ Task "${taskName}" not found`); return; }
 
     // Script tasks: quick, run inline
@@ -2676,7 +2705,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     }
 
     const session = getSession(chatId);
-    if (!session || !session.id || !session.cwd) {
+    if (!session || !session.id) {
       await bot.sendMessage(chatId, 'No active session to undo.');
       return;
     }
@@ -2684,107 +2713,190 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
     const cwd = session.cwd;
     const arg = text.slice(5).trim();
 
-    // Git-based undo: list checkpoints or reset to one
-    // First check if cwd is even a git repo
-    let isGitRepo = false;
-    try { execSync('git rev-parse --is-inside-work-tree', { cwd, stdio: 'ignore', timeout: 3000 }); isGitRepo = true; } catch { }
-    const checkpoints = isGitRepo ? listCheckpoints(cwd) : [];
-    if (!isGitRepo) {
-      await bot.sendMessage(chatId, `⚠️ 当前项目不在 git 仓库中，无法使用 /undo\n📁 ${cwd}\n\n切换到 git 项目后重试（/agent bind 或 /cd 切换目录）`);
-      return;
-    }
-    if (checkpoints.length === 0) {
-      await bot.sendMessage(chatId, `⚠️ 还没有回退点\n📁 ${path.basename(cwd)}\n\nCheckpoint 在 Claude 修改文件前自动创建，先让 Claude 做点改动再试`);
+    // /undo <hash> — git reset to specific checkpoint (advanced usage)
+    if (arg) {
+      if (!cwd) {
+        await bot.sendMessage(chatId, '❌ 当前 session 无工作目录，无法执行 git undo');
+        return;
+      }
+      let isGitRepo = false;
+      try { execSync('git rev-parse --is-inside-work-tree', { cwd, stdio: 'ignore', timeout: 3000 }); isGitRepo = true; } catch { }
+      const checkpoints = isGitRepo ? listCheckpoints(cwd) : [];
+      const match = checkpoints.find(cp => cp.hash.startsWith(arg));
+      if (!match) {
+        await bot.sendMessage(chatId, `❌ 未找到 checkpoint: ${arg}`);
+        return;
+      }
+      try {
+        let diffFiles = '';
+        try { diffFiles = execSync(`git diff --name-only HEAD ${match.hash}`, { cwd, encoding: 'utf8', timeout: 5000 }).trim(); } catch { }
+        execSync(`git reset --hard ${match.hash}`, { cwd, stdio: 'ignore', timeout: 10000 });
+        // Truncate context to checkpoint time (covers multi-turn rollback)
+        truncateSessionToCheckpoint(session.id, match.message);
+        const fileList = diffFiles ? diffFiles.split('\n').map(f => path.basename(f)).join(', ') : '';
+        const fileCount = diffFiles ? diffFiles.split('\n').length : 0;
+        let msg = `⏪ 已回退到 ${cpDisplayLabel(match.message)}`;
+        if (fileCount > 0) msg += `\n📁 ${fileCount} 个文件恢复: ${fileList}`;
+        log('INFO', `/undo <hash> executed for ${chatId}: reset to ${match.hash.slice(0, 8)}, files=${fileCount}`);
+        await bot.sendMessage(chatId, msg);
+        cleanupCheckpoints(cwd);
+      } catch (e) {
+        await bot.sendMessage(chatId, `❌ Undo failed: ${e.message}`);
+      }
       return;
     }
 
-    if (!arg) {
-      // /undo (no arg) — show recent checkpoints to pick from
-      const recent = checkpoints.slice(0, 6); // newest first (already sorted)
+    // /undo (no arg) — show recent user messages as buttons to pick rollback point
+    try {
+      const sessionFile = findSessionFile(session.id);
+      if (!sessionFile) {
+        await bot.sendMessage(chatId, '⚠️ 找不到 session 文件，无法列出历史消息');
+        return;
+      }
+      const lines = fs.readFileSync(sessionFile, 'utf8').split('\n').filter(l => l.trim());
+
+      // Helper: extract real user text (skip tool_result entries and system annotations)
+      const extractUserText = (obj) => {
+        try {
+          const content = obj.message?.content;
+          if (typeof content === 'string') return content.trim();
+          if (Array.isArray(content)) {
+            // Skip entries that are purely tool results
+            if (content.every(c => c.type === 'tool_result')) return '';
+            // Find first text item that isn't a system annotation (exact patterns only)
+            const SYSTEM_ANNOTATION = /^\[(Image source|Pasted|Attachment|File):/;
+            const item = content.find(c => c.type === 'text' && c.text && !SYSTEM_ANNOTATION.test(c.text));
+            return item?.text?.trim() || '';
+          }
+        } catch { }
+        return '';
+      };
+
+      // Collect only real human-written user messages (skip tool results / annotations)
+      const userMsgs = [];
+      for (let i = 0; i < lines.length; i++) {
+        try {
+          const obj = JSON.parse(lines[i]);
+          if (obj.type === 'user' && obj.message?.role === 'user') {
+            const text = extractUserText(obj);
+            if (text) userMsgs.push({ idx: i, obj, text });
+          }
+        } catch { }
+      }
+      if (userMsgs.length === 0) {
+        await bot.sendMessage(chatId, '⚠️ 没有可回退的历史消息');
+        return;
+      }
+
+      // Show last 10 (most recent first)
+      const recent = userMsgs.slice(-10).reverse();
       if (bot.sendButtons) {
-        const buttons = recent.map((cp) => {
-          const label = cpDisplayLabel(cp.message);
-          return [{ text: `⏪ ${label}`, callback_data: `/undo ${cp.hash.slice(0, 10)}` }];
+        const buttons = recent.map(({ idx, text, obj }) => {
+          const msgText = text.replace(/\n/g, ' ').slice(0, 28);
+          let timeLabel = '';
+          if (obj.timestamp) {
+            const d = new Date(obj.timestamp);
+            if (!isNaN(d)) timeLabel = ` (${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')})`;
+          }
+          return [{ text: `⏪ ${msgText}${timeLabel}`, callback_data: `/undo_to ${idx}` }];
         });
-        await bot.sendButtons(chatId, `📌 ${checkpoints.length} 个回退点 (git checkpoint):`, buttons);
+        await bot.sendButtons(chatId, `↩️ 回退到哪条消息之前？(共 ${userMsgs.length} 轮)`, buttons);
       } else {
-        let msg = '回退到哪个点？回复 /undo <hash>\n\n';
-        recent.forEach(cp => {
-          msg += `${cp.hash.slice(0, 8)} ${cpDisplayLabel(cp.message)}\n`;
+        let msg = '回退到哪条消息之前？回复 /undo_to <序号>\n\n';
+        recent.forEach(({ idx, text }) => {
+          msg += `[${idx}] ${text.slice(0, 40)}\n`;
         });
         await bot.sendMessage(chatId, msg);
       }
+    } catch (e) {
+      await bot.sendMessage(chatId, `❌ Undo failed: ${e.message}`);
+    }
+    return;
+  }
+
+  // /undo_to <lineIdx> — restore session to before the message at given JSONL line index
+  if (text.startsWith('/undo_to ')) {
+    const idx = parseInt(text.slice(9).trim(), 10);
+    if (isNaN(idx) || idx < 0) {
+      await bot.sendMessage(chatId, '❌ 无效的回退序号');
+      return;
+    }
+
+    // Kill any running task
+    if (messageQueue.has(chatId)) {
+      const q = messageQueue.get(chatId);
+      if (q.timer) clearTimeout(q.timer);
+      messageQueue.delete(chatId);
+    }
+    const proc2 = activeProcesses.get(chatId);
+    if (proc2 && proc2.child) {
+      proc2.aborted = true;
+      try { process.kill(-proc2.child.pid, 'SIGINT'); } catch { proc2.child.kill('SIGINT'); }
+    }
+
+    const session2 = getSession(chatId);
+    if (!session2 || !session2.id) {
+      await bot.sendMessage(chatId, 'No active session.');
       return;
     }
 
-    // /undo <hash> — execute git reset
     try {
-      // Verify the hash exists and is a checkpoint
-      const match = checkpoints.find(cp => cp.hash.startsWith(arg));
-      if (!match) {
-        await bot.sendMessage(chatId, `❌ 未找到 checkpoint: ${arg}`);
+      const sessionFile2 = findSessionFile(session2.id);
+      if (!sessionFile2) { await bot.sendMessage(chatId, '❌ 找不到 session 文件'); return; }
+
+      const lines2 = fs.readFileSync(sessionFile2, 'utf8').split('\n').filter(l => l.trim());
+      if (idx >= lines2.length) {
+        await bot.sendMessage(chatId, '❌ 序号超出范围，session 已变化，请重新 /undo');
         return;
       }
 
-      // Get list of files that will change
-      let diffFiles = '';
+      // Get target message text + timestamp for display and git matching
+      let targetMsg = '', targetTs = 0;
       try {
-        diffFiles = execSync(`git diff --name-only HEAD ${match.hash}`, { cwd, encoding: 'utf8', timeout: 5000 }).trim();
-      } catch { /* ignore */ }
-
-      // Reset working tree to checkpoint
-      execSync(`git reset --hard ${match.hash}`, { cwd, stdio: 'ignore', timeout: 10000 });
+        const obj = JSON.parse(lines2[idx]);
+        const content = obj.message?.content;
+        if (typeof content === 'string') targetMsg = content;
+        else if (Array.isArray(content)) targetMsg = content.find(c => c.type === 'text')?.text || '';
+        if (obj.timestamp) targetTs = new Date(obj.timestamp).getTime() || 0;
+      } catch { }
 
-      // Also truncate JSONL session history (best-effort, non-fatal)
-      try {
-        const sessionFile = findSessionFile(session.id);
-        if (sessionFile) {
-          const fileContent = fs.readFileSync(sessionFile, 'utf8');
-          const lines = fileContent.split('\n').filter(l => l.trim());
-          // Find the last user message that was sent BEFORE this checkpoint
-          // Use the checkpoint timestamp from the commit message
-          const cpTs = cpExtractTimestamp(match.message);
-          const cpTime = new Date(cpTs).getTime();
-          if (cpTime) {
-            // Find the first user message AFTER checkpoint time → truncate before it
-            let cutIdx = -1;
-            for (let i = lines.length - 1; i >= 0; i--) {
-              try {
-                const obj = JSON.parse(lines[i]);
-                if (obj.type === 'user' && obj.timestamp) {
-                  const msgTime = new Date(obj.timestamp).getTime();
-                  if (msgTime && msgTime >= cpTime) {
-                    cutIdx = i;
-                  } else {
-                    break; // Found a message before checkpoint, stop
-                  }
-                }
-              } catch { }
-            }
-            if (cutIdx > 0) {
-              const kept = lines.slice(0, cutIdx);
-              fs.writeFileSync(sessionFile, kept.join('\n') + '\n', 'utf8');
-              log('INFO', `Truncated session at line ${cutIdx} (${lines.length - cutIdx} lines removed)`);
+      // Git reset first (before JSONL truncation) so failure leaves state consistent
+      let gitMsg2 = '';
+      const cwd2 = session2.cwd;
+      if (cwd2) {
+        let isGitRepo2 = false;
+        try { execSync('git rev-parse --is-inside-work-tree', { cwd: cwd2, stdio: 'ignore', timeout: 3000 }); isGitRepo2 = true; } catch { }
+        if (isGitRepo2) {
+          // Exclude safety checkpoints from matching to avoid confusion
+          const checkpoints2 = listCheckpoints(cwd2).filter(cp => !cp.message.includes('[metame-safety]'));
+          const cpMatch = targetTs
+            ? checkpoints2.find(cp => { const t = new Date(cpExtractTimestamp(cp.message) || 0).getTime(); return t > 0 && t <= targetTs; })
+            : checkpoints2[0];
+          if (cpMatch) {
+            let diffFiles2 = '';
+            try { diffFiles2 = execSync(`git diff --name-only HEAD ${cpMatch.hash}`, { cwd: cwd2, encoding: 'utf8', timeout: 5000 }).trim(); } catch { }
+            if (diffFiles2) {
+              // Save current state with distinct prefix (excluded from normal /undo list)
+              gitCheckpoint(cwd2, `[metame-safety] before rollback to: ${targetMsg.slice(0, 40)}`);
+              execSync(`git reset --hard ${cpMatch.hash}`, { cwd: cwd2, stdio: 'ignore', timeout: 10000 });
+              gitMsg2 = `\n📁 ${diffFiles2.split('\n').length} 个文件已恢复`;
+              cleanupCheckpoints(cwd2);
             }
           }
         }
-      } catch (truncErr) {
-        log('WARN', `Session truncation failed (non-fatal): ${truncErr.message}`);
       }
 
-      const fileList = diffFiles ? diffFiles.split('\n').map(f => path.basename(f)).join(', ') : '';
-      const fileCount = diffFiles ? diffFiles.split('\n').length : 0;
-      const label = cpDisplayLabel(match.message);
-      let msg = `⏪ 已回退\n📝 ${label}\n🔀 git reset --hard ${match.hash.slice(0, 8)}`;
-      if (fileCount > 0) {
-        msg += `\n📁 ${fileCount} 个文件恢复: ${fileList}`;
-      }
-      await bot.sendMessage(chatId, msg);
+      // Truncate JSONL after git reset succeeds
+      const kept2 = lines2.slice(0, idx);
+      fs.writeFileSync(sessionFile2, kept2.length ? kept2.join('\n') + '\n' : '', 'utf8');
+      _sessionFileCache.delete(session2.id);
+      const removed2 = lines2.length - kept2.length;
 
-      // Cleanup old checkpoints in background
-      cleanupCheckpoints(cwd);
+      const preview = targetMsg.replace(/\n/g, ' ').slice(0, 30) || `行 ${idx}`;
+      log('INFO', `/undo_to ${idx} for ${chatId}: removed=${removed2} lines${gitMsg2 ? ', ' + gitMsg2.trim() : ''}`);
+      await bot.sendMessage(chatId, `⏪ 已回退到「${preview}」之前\n🧠 上下文回滚 ${removed2} 行${gitMsg2}`);
     } catch (e) {
-      await bot.sendMessage(chatId, `❌ Undo failed: ${e.message}`);
+      await bot.sendMessage(chatId, `❌ 回退失败: ${e.message}`);
     }
     return;
   }
@@ -3016,7 +3128,8 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName, sende
       '/cd <path> — 切换工作目录',
       '/session — 查看当前会话',
       '/stop — 中断当前任务 (ESC)',
-      '/undo — 回退上一轮操作 (ESC×2)',
+      '/undo — 选择历史消息，点击回退到该条之前',
+      '/undo <hash> — 回退到指定 git checkpoint',
       '/quit — 结束会话，重新加载 MCP/配置',
       '',
       `⚙️ /model [${currentModel}] /provider [${currentProvider}] /status /tasks /run /budget /reload`,
@@ -3117,6 +3230,80 @@ function findSessionFile(sessionId) {
   return null;
 }
 
+/**
+ * Truncate the last conversation turn (user message + assistant response) from a session JSONL.
+ * Finds the last {type:"user"} entry and removes it plus everything after.
+ * Returns the number of lines removed, or 0 if nothing was truncated.
+ */
+function truncateSessionLastTurn(sessionId) {
+  try {
+    const sessionFile = findSessionFile(sessionId);
+    if (!sessionFile) return 0;
+    const fileContent = fs.readFileSync(sessionFile, 'utf8');
+    const lines = fileContent.split('\n').filter(l => l.trim());
+    // Find the last user-type entry (walk backwards)
+    let cutIdx = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const obj = JSON.parse(lines[i]);
+        if (obj.type === 'user') { cutIdx = i; break; }
+      } catch { /* skip malformed lines */ }
+    }
+    if (cutIdx <= 0) return 0; // nothing to cut (keep at least line 0)
+    const kept = lines.slice(0, cutIdx);
+    fs.writeFileSync(sessionFile, kept.join('\n') + '\n', 'utf8');
+    // Invalidate cache so next findSessionFile call re-reads fresh
+    _sessionFileCache.delete(sessionId);
+    const removed = lines.length - kept.length;
+    log('INFO', `truncateSessionLastTurn: removed ${removed} lines from ${path.basename(sessionFile)}`);
+    return removed;
+  } catch (e) {
+    log('WARN', `truncateSessionLastTurn failed: ${e.message}`);
+    return 0;
+  }
+}
+
+/**
+ * Truncate session JSONL to the point before a given checkpoint (timestamp-based).
+ * Used for /undo <hash> to handle multi-turn rollback correctly.
+ * Falls back to truncateSessionLastTurn if timestamp parsing fails.
+ */
+function truncateSessionToCheckpoint(sessionId, checkpointMessage) {
+  try {
+    const cpTs = cpExtractTimestamp(checkpointMessage);
+    const cpTime = cpTs ? new Date(cpTs).getTime() : 0;
+    if (!cpTime) return truncateSessionLastTurn(sessionId);
+
+    const sessionFile = findSessionFile(sessionId);
+    if (!sessionFile) return 0;
+    const fileContent = fs.readFileSync(sessionFile, 'utf8');
+    const lines = fileContent.split('\n').filter(l => l.trim());
+
+    // Find the first user message at or after checkpoint time → cut there
+    let cutIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+      try {
+        const obj = JSON.parse(lines[i]);
+        if (obj.type === 'user' && obj.timestamp) {
+          const msgTime = new Date(obj.timestamp).getTime();
+          if (msgTime && msgTime >= cpTime) { cutIdx = i; break; }
+        }
+      } catch { /* skip malformed lines */ }
+    }
+    if (cutIdx <= 0) return truncateSessionLastTurn(sessionId); // fallback
+
+    const kept = lines.slice(0, cutIdx);
+    fs.writeFileSync(sessionFile, kept.join('\n') + '\n', 'utf8');
+    _sessionFileCache.delete(sessionId);
+    const removed = lines.length - kept.length;
+    log('INFO', `truncateSessionToCheckpoint: removed ${removed} lines from ${path.basename(sessionFile)}`);
+    return removed;
+  } catch (e) {
+    log('WARN', `truncateSessionToCheckpoint failed: ${e.message}`);
+    return truncateSessionLastTurn(sessionId); // fallback
+  }
+}
+
 /**
  * Scan all project session indexes, return most recent N sessions.
  * Results cached for 10 seconds to avoid repeated directory scans.
@@ -3603,13 +3790,26 @@ let lastInteractionTime = Date.now(); // updated on every incoming message
 let _inSleepMode = false;             // tracks current sleep state for log transitions
 
 const IDLE_THRESHOLD_MS = 30 * 60 * 1000; // 30 minutes
+const LOCAL_ACTIVE_FILE = path.join(METAME_DIR, 'local_active');
 
 /**
  * Returns true when user has been inactive for >30min AND no sessions are running.
+ * Checks BOTH mobile adapter activity (Telegram/Feishu) AND the local_active heartbeat
+ * file (updated by Claude Code / index.js on each session start).
  * Dream tasks (require_idle: true) only execute in this state.
  */
 function isUserIdle() {
-  return (Date.now() - lastInteractionTime > IDLE_THRESHOLD_MS) && activeProcesses.size === 0;
+  // Check mobile adapter activity (Telegram/Feishu)
+  if (Date.now() - lastInteractionTime <= IDLE_THRESHOLD_MS) return false;
+  // Check local desktop activity via ~/.metame/local_active mtime
+  try {
+    if (fs.existsSync(LOCAL_ACTIVE_FILE)) {
+      const mtime = fs.statSync(LOCAL_ACTIVE_FILE).mtimeMs;
+      if (Date.now() - mtime < IDLE_THRESHOLD_MS) return false;
+    }
+  } catch { /* ignore — treat as idle if file unreadable */ }
+  // Only idle if no active Claude sub-processes either
+  return activeProcesses.size === 0;
 }
 
 // Fix3: persist child PIDs so next daemon startup can kill orphans
@@ -4410,9 +4610,10 @@ async function startFeishuBridge(config, executeTaskByName) {
       const liveCfg = loadConfig();
       const allowedIds = (liveCfg.feishu && liveCfg.feishu.allowed_chat_ids) || [];
       const trimmedText = text && text.trim();
-      const isBindCmd = trimmedText && (trimmedText.startsWith('/agent bind') || trimmedText.startsWith('/agent new'));
+      const isBindCmd = trimmedText && (trimmedText.startsWith('/bind') || trimmedText.startsWith('/agent bind') || trimmedText.startsWith('/agent new'));
       if (!allowedIds.includes(chatId) && !isBindCmd) {
         log('WARN', `Feishu: rejected message from ${chatId}`);
+        bot.sendMessage(chatId, `⚠️ 此会话 (ID: ${chatId}) 未授权。\n\n发送以下命令注册：\n/bind personal ~/\n\n这会将此会话绑定到你的主目录。`).catch(() => {});
         return;
       }
 
@@ -4590,7 +4791,7 @@ async function main() {
       qmd.startDaemon().then(running => {
         if (running) log('INFO', '[QMD] Semantic search daemon started (localhost:8181)');
         else log('INFO', '[QMD] Available but daemon not started — will use CLI fallback');
-      }).catch(() => {});
+      }).catch(() => { });
     }
   } catch { /* qmd-client not available, skip */ }
   // Hourly heartbeat so daemon.log stays fresh even when idle (visible aliveness check)
@@ -4600,14 +4801,7 @@ async function main() {
 
   // Task executor lookup (always reads fresh config)
   function executeTaskByName(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; }
-      }
-    }
+    const task = findTask(config, name);
     if (!task) return { success: false, error: `Task "${name}" not found` };
     return executeTask(task, config);
   }
@@ -4686,10 +4880,9 @@ async function main() {
     refreshLogMaxSize(config);
     if (heartbeatTimer) clearInterval(heartbeatTimer);
     heartbeatTimer = startHeartbeat(config, notifyFn);
-    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)`);
+    const { general, project } = getAllTasks(config);
+    const totalCount = general.length + project.length;
+    log('INFO', `Config reloaded: ${totalCount} tasks (${project.length} in projects)`);
     return { success: true, tasks: totalCount };
   }
   // Expose reloadConfig to handleCommand via closure
@@ -4797,11 +4990,11 @@ if (process.argv.includes('--run')) {
     process.exit(1);
   }
   const config = loadConfig();
-  const tasks = (config.heartbeat && config.heartbeat.tasks) || [];
-  const task = tasks.find(t => t.name === taskName);
+  const task = findTask(config, taskName);
   if (!task) {
+    const { all } = getAllTasks(config);
     console.error(`Task "${taskName}" not found in daemon.yaml`);
-    console.error(`Available: ${tasks.map(t => t.name).join(', ') || '(none)'}`);
+    console.error(`Available: ${all.map(t => t.name).join(', ') || '(none)'}`);
     process.exit(1);
   }
   const result = executeTask(task, config);

package/scripts/distill.js

@@ -82,14 +82,14 @@ async function distill() {
   }
 
   try {
-    // 3. Parse signals (preserve confidence from signal-capture)
+    // 3. Parse signals (preserve confidence + type from signal-capture)
     const signals = [];
     let highConfidenceCount = 0;
     for (const line of lines) {
       try {
         const entry = JSON.parse(line);
         if (entry.prompt) {
-          signals.push(entry.prompt);
+          signals.push({ text: entry.prompt, type: entry.type || 'implicit' });
           if (entry.confidence === 'high') highConfidenceCount++;
         }
       } catch {
@@ -127,18 +127,24 @@ async function distill() {
     }
 
     // 5. Build distillation prompt (compact + session-aware)
-    const userMessages = signals
-      .map((s, i) => `${i + 1}. "${s}"`)
-      .join('\n');
+    // Input budget: keep total prompt under INPUT_TOKEN_BUDGET to control cost/latency.
+    // Priority: system prompt + profile + writable keys (must keep) > user messages > session context
+    const INPUT_TOKEN_BUDGET = 4000; // ~12K chars mixed zh/en
 
     const writableKeys = getWritableKeysForPrompt();
 
-    // Session context section (only when skeleton exists, ~60 tokens)
+    // Reserve budget for fixed parts (system prompt template ~600 tokens, profile, writable keys)
+    const fixedOverhead = 600; // system prompt template + rules
+    const profileTokens = estimateTokens(currentProfile);
+    const keysTokens = estimateTokens(writableKeys);
+    const reservedTokens = fixedOverhead + profileTokens + keysTokens;
+    const availableForContent = Math.max(INPUT_TOKEN_BUDGET - reservedTokens, 200);
+
+    // Build session context (lower priority — truncate first)
     let sessionSection = sessionContext
       ? `\nSESSION CONTEXT (what actually happened in the latest coding session):\n${sessionContext}\n`
       : '';
 
-    // Add summary for long sessions (~30 tokens when present)
     if (sessionSummary) {
       const pivotText = sessionSummary.pivots.length > 0
         ? `\nPivots: ${sessionSummary.pivots.join('; ')}`
@@ -146,12 +152,41 @@ async function distill() {
       sessionSection += `Summary: ${sessionSummary.intent} → ${sessionSummary.outcome}${pivotText}\n`;
     }
 
-    // Goal context section (~11 tokens when present)
     let goalContext = '';
     if (sessionAnalytics) {
       try { goalContext = sessionAnalytics.formatGoalContext(BRAIN_FILE); } catch { }
     }
-    const goalSection = goalContext ? `\n${goalContext}\n` : '';
+    let goalSection = goalContext ? `\n${goalContext}\n` : '';
+
+    // Allocate remaining budget: user messages get priority over session context
+    const sessionTokens = estimateTokens(sessionSection + goalSection);
+    let budgetForMessages = availableForContent - sessionTokens;
+
+    // If not enough room, drop session context first, then trim messages
+    if (budgetForMessages < 100) {
+      sessionSection = '';
+      goalSection = '';
+      budgetForMessages = availableForContent;
+    }
+
+    // Format signals: tag metacognitive signals so Haiku treats them differently
+    const formatSignal = (s, i) => {
+      const tag = s.type === 'metacognitive' ? ' [META]' : '';
+      return `${i + 1}. "${s.text}"${tag}`;
+    };
+
+    // Truncate user messages to fit budget (keep most recent, they're more relevant)
+    let truncatedSignals = signals;
+    let userMessages = signals.map(formatSignal).join('\n');
+    if (estimateTokens(userMessages) > budgetForMessages) {
+      // Drop oldest messages until we fit
+      while (truncatedSignals.length > 1 && estimateTokens(
+        truncatedSignals.map(formatSignal).join('\n')
+      ) > budgetForMessages) {
+        truncatedSignals = truncatedSignals.slice(1);
+      }
+      userMessages = truncatedSignals.map(formatSignal).join('\n');
+    }
 
     const distillPrompt = `You are a MetaMe cognitive profile distiller. Extract COGNITIVE TRAITS and PREFERENCES — how the user thinks, decides, and communicates. NOT a memory system. Do NOT store facts.
 
@@ -172,6 +207,7 @@ RULES:
 3. Only output fields from WRITABLE FIELDS. Any other key will be rejected.
 4. For enum fields, use one of the listed values.
 5. Strong directives (以后一律/always/never/from now on) → _confidence: high. Otherwise: normal.
+6. Messages tagged [META] are metacognitive signals (self-reflection, strategy shifts, error awareness). These are HIGH VALUE for cognition fields — extract decision_style, error_response, receptive_to_challenge, and behavioral patterns from them.
 7. Add _confidence and _source blocks mapping field keys to confidence level and triggering quote.
 8. NEVER extract agent identity or role definitions. Messages like "你是贾维斯/你的角色是.../you are Jarvis" define the AGENT, not the USER. The profile is about the USER's cognition only.
 

package/scripts/feishu-adapter.js

@@ -118,7 +118,7 @@ function createBot(config) {
      * Send markdown as Feishu interactive card (lark_md renders bold, lists, code, links)
      */
     async sendMarkdown(chatId, markdown) {
-      const elements = toMdChunks(markdown).map(c => ({ tag: 'markdown', content: c }));
+      const elements = toMdChunks(markdown).map(c => ({ tag: 'markdown', content: c, text_size: 'x-large' }));
       return _sendInteractive(chatId, { schema: '2.0', body: { elements } });
     },
 
@@ -132,7 +132,7 @@ function createBot(config) {
      */
     async sendCard(chatId, { title, body, color = 'blue' }) {
       const header = { title: { tag: 'plain_text', content: title }, template: color };
-      const elements = body ? toMdChunks(body).map(c => ({ tag: 'markdown', content: c })) : [];
+      const elements = body ? toMdChunks(body).map(c => ({ tag: 'markdown', content: c, text_size: 'x-large' })) : [];
       return _sendInteractive(chatId, { schema: '2.0', header, body: { elements } });
     },
 

package/scripts/memory-extract.js

@@ -28,8 +28,9 @@ const FACT_EXTRACTION_PROMPT = `你是精准的知识提取引擎。从以下会
 - bug_lesson（Bug根因：什么设计/假设导致了问题）
 - arch_convention（架构约定：系统组件的行为边界）
 - config_fact（配置事实：某个值的真实含义，尤其反直觉的）
+- config_change（配置变更：用户选择/确认了某个具体配置值，如”字体选了x-large”、”间隔改为2h”）
 - user_pref（用户明确表达的偏好/红线）
-- workflow_rule（工作流戒律：如“不要在某情况下做某事”的反常识流）
+- workflow_rule（工作流戒律：如”不要在某情况下做某事”的反常识流）
 - project_milestone（项目里程碑：主要架构重构、版本发布等跨会话级成果）
 
 绝对不提取：

package/scripts/memory-search.js

@@ -3,12 +3,14 @@
  * memory-search.js — Cross-session memory recall CLI
  *
  * Usage:
- *   node memory-search.js "<query>"           # search both sessions and facts
- *   node memory-search.js --facts "<query>"   # search facts only
- *   node memory-search.js --sessions "<query>" # search sessions only
- *   node memory-search.js --recent            # show recent sessions
+ *   node memory-search.js "<query>"                # hybrid search (QMD + FTS5)
+ *   node memory-search.js "<q1>" "<q2>" "<q3>"     # multi-keyword parallel search
+ *   node memory-search.js --facts "<query>"         # search facts only
+ *   node memory-search.js --sessions "<query>"      # search sessions only
+ *   node memory-search.js --recent                  # show recent sessions
  *
- * Called by Claude via Bash tool when it needs to recall past knowledge.
+ * Multi-keyword: results are deduplicated by fact ID, best rank wins.
+ * Async: uses QMD hybrid search (BM25 + vector) when available, falls back to FTS5.
  */
 
 'use strict';
@@ -16,7 +18,6 @@
 const path = require('path');
 const os = require('os');
 
-// Support both local dev and installed (~/.metame/) paths
 const memoryPath = [
   path.join(os.homedir(), '.metame', 'memory.js'),
   path.join(__dirname, 'memory.js'),
@@ -31,69 +32,97 @@ const memory = require(memoryPath);
 
 const args = process.argv.slice(2);
 const mode = args[0] && args[0].startsWith('--') ? args[0] : null;
-const query = mode ? args[1] : args[0];
+const queries = mode ? args.slice(1) : args;
 
-try {
-  if (mode === '--recent') {
-    const rows = memory.recentSessions({ limit: 5 });
-    console.log(JSON.stringify(rows.map(r => ({
-      type: 'session',
-      project: r.project,
-      date: r.created_at,
-      summary: r.summary,
-    })), null, 2));
-
-  } else if (mode === '--facts') {
-    if (!query) { console.log('[]'); process.exit(0); }
-    const facts = memory.searchFacts(query, { limit: 5 });
-    console.log(JSON.stringify(facts.map(f => ({
+async function main() {
+  try {
+    if (mode === '--recent') {
+      const rows = memory.recentSessions({ limit: 5 });
+      console.log(JSON.stringify(rows.map(r => ({
+        type: 'session',
+        project: r.project,
+        date: r.created_at,
+        summary: r.summary,
+      })), null, 2));
+      return;
+    }
+
+    if (!queries.length || !queries[0]) {
+      console.log('[]');
+      return;
+    }
+
+    const useAsync = typeof memory.searchFactsAsync === 'function';
+
+    if (mode === '--facts') {
+      const results = await searchMulti(queries, { searchFn: q => useAsync ? memory.searchFactsAsync(q, { limit: 5 }) : memory.searchFacts(q, { limit: 5 }), type: 'fact' });
+      console.log(JSON.stringify(results, null, 2));
+      return;
+    }
+
+    if (mode === '--sessions') {
+      const results = await searchMulti(queries, { searchFn: q => Promise.resolve(memory.searchSessions(q, { limit: 5 })), type: 'session' });
+      console.log(JSON.stringify(results, null, 2));
+      return;
+    }
+
+    // Default: search both facts and sessions, all queries in parallel
+    const factResults = await searchMulti(queries, {
+      searchFn: q => useAsync ? memory.searchFactsAsync(q, { limit: 5 }) : Promise.resolve(memory.searchFacts(q, { limit: 5 })),
       type: 'fact',
-      entity: f.entity,
-      relation: f.relation,
-      value: f.value,
-      confidence: f.confidence,
-      date: f.created_at,
-    })), null, 2));
-
-  } else if (mode === '--sessions') {
-    if (!query) { console.log('[]'); process.exit(0); }
-    const sessions = memory.searchSessions(query, { limit: 5 });
-    console.log(JSON.stringify(sessions.map(s => ({
+      limit: 5,
+    });
+
+    const sessionResults = await searchMulti(queries, {
+      searchFn: q => Promise.resolve(memory.searchSessions(q, { limit: 3 })),
       type: 'session',
-      project: s.project,
-      date: s.created_at,
-      summary: s.summary,
-    })), null, 2));
-
-  } else {
-    // Default: search both facts and sessions
-    if (!query) { console.log('[]'); process.exit(0); }
-    const facts = (typeof memory.searchFacts === 'function')
-      ? memory.searchFacts(query, { limit: 3 })
-      : [];
-    const sessions = memory.searchSessions(query, { limit: 3 });
-
-    const results = [
-      ...facts.map(f => ({
-        type: 'fact',
-        entity: f.entity,
-        relation: f.relation,
-        value: f.value,
-        confidence: f.confidence,
-        date: f.created_at,
-      })),
-      ...sessions.map(s => ({
-        type: 'session',
-        project: s.project,
-        date: s.created_at,
-        summary: s.summary,
-      })),
-    ];
+      limit: 3,
+    });
+
+    console.log(JSON.stringify([...factResults, ...sessionResults], null, 2));
 
-    console.log(JSON.stringify(results, null, 2));
+  } catch (e) {
+    console.log('[]');
+  } finally {
+    try { memory.close(); } catch {}
   }
-} catch (e) {
-  console.log('[]');
-} finally {
-  try { memory.close(); } catch {}
 }
+
+/**
+ * Run multiple queries in parallel, deduplicate and format results.
+ */
+async function searchMulti(queries, { searchFn, type, limit = 5 }) {
+  const allResults = await Promise.all(queries.map(q => searchFn(q).catch(() => [])));
+
+  // Deduplicate by id (facts) or created_at+project (sessions)
+  const seen = new Set();
+  const merged = [];
+
+  for (const batch of allResults) {
+    for (const item of (batch || [])) {
+      const key = type === 'fact'
+        ? `f:${item.id || item.entity + item.value}`
+        : `s:${item.created_at}:${item.project}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        merged.push(type === 'fact' ? {
+          type: 'fact',
+          entity: item.entity,
+          relation: item.relation,
+          value: item.value,
+          confidence: item.confidence,
+          date: item.created_at,
+        } : {
+          type: 'session',
+          project: item.project,
+          date: item.created_at,
+          summary: item.summary,
+        });
+      }
+    }
+  }
+
+  return merged.slice(0, limit);
+}
+
+main();

package/scripts/schema.js

@@ -44,13 +44,10 @@ const SCHEMA = {
   'cognition.info_processing.entry_point': { tier: 'T3', type: 'enum', values: ['big_picture', 'details', 'examples'] },
   'cognition.info_processing.preferred_format': { tier: 'T3', type: 'enum', values: ['structured', 'narrative', 'visual_metaphor'] },
   'cognition.abstraction.default_level': { tier: 'T3', type: 'enum', values: ['strategic', 'architectural', 'implementation', 'operational'] },
-  'cognition.abstraction.range': { tier: 'T3', type: 'enum', values: ['narrow', 'wide'] },
   'cognition.cognitive_load.chunk_size': { tier: 'T3', type: 'enum', values: ['small', 'medium', 'large'] },
-  'cognition.cognitive_load.preferred_response_length': { tier: 'T3', type: 'enum', values: ['concise', 'moderate', 'comprehensive'] },
-  'cognition.motivation.primary_driver': { tier: 'T3', type: 'enum', values: ['autonomy', 'competence', 'meaning', 'social_proof'] },
-  'cognition.motivation.energy_source': { tier: 'T3', type: 'enum', values: ['creation', 'optimization', 'problem_solving', 'teaching'] },
-  'cognition.metacognition.self_awareness': { tier: 'T3', type: 'enum', values: ['high', 'medium', 'low'] },
+  'cognition.motivation.driver': { tier: 'T3', type: 'enum', values: ['autonomy', 'competence', 'meaning', 'creation', 'optimization'] },
   'cognition.metacognition.receptive_to_challenge': { tier: 'T3', type: 'enum', values: ['yes', 'sometimes', 'no'] },
+  'cognition.metacognition.error_response': { tier: 'T3', type: 'enum', values: ['quick_pivot', 'root_cause_first', 'seek_help', 'retry_same'] },
 
   // === T4: Context ===
   'context.focus': { tier: 'T4', type: 'string', maxChars: 80 },

package/scripts/signal-capture.js

@@ -29,6 +29,10 @@ const IMPLICIT_EN = /I (prefer|like|hate|usually|tend to|always)/i;
 const CORRECTION_ZH = /不是.*我(要|想|说)的|我说的不是|你理解错了|不对.*应该/;
 const CORRECTION_EN = /(no,? I meant|that's not what I|you misunderstood|wrong.+should be)/i;
 
+// Metacognitive signals → normal confidence (self-reflection, strategy shifts)
+const META_ZH = /我(发现|意识到|觉得|反思|总结|复盘)|想错了|换个(思路|方向|方案)|回头(想想|看看)|之前的(方案|思路|方向).*(不行|不对|有问题)|我的(问题|毛病|习惯)是|下次(应该|要|得)/;
+const META_EN = /(I realize|looking back|on reflection|my (mistake|problem|habit) is|let me rethink|wrong approach|next time I should)/i;
+
 // Read JSON from stdin
 let input = '';
 process.stdin.setEncoding('utf8');
@@ -38,7 +42,11 @@ process.stdin.on('end', () => {
     const data = JSON.parse(input);
     const prompt = (data.prompt || '').trim();
 
+    // === LAYER 0: Metacognitive bypass — always capture self-reflection ===
+    const isMeta = META_ZH.test(prompt) || META_EN.test(prompt);
+
     // === LAYER 1: Hard filters (definitely not preferences) ===
+    // Metacognitive signals bypass all hard filters — they reveal how user thinks
 
     // Skip empty or very short messages
     // Chinese chars carry more info per char, so use weighted length
@@ -48,43 +56,43 @@ process.stdin.on('end', () => {
     }
 
     // Skip messages that are purely code or file paths
-    if (/^(```|\/[\w/]+\.\w+$)/.test(prompt)) {
+    if (!isMeta && /^(```|\/[\w/]+\.\w+$)/.test(prompt)) {
       process.exit(0);
     }
 
     // Skip common non-preference commands
-    if (/^(\/\w+|!metame|git |npm |pnpm |yarn |brew |sudo |cd |ls |cat |mkdir )/.test(prompt)) {
+    if (!isMeta && /^(\/\w+|!metame|git |npm |pnpm |yarn |brew |sudo |cd |ls |cat |mkdir )/.test(prompt)) {
       process.exit(0);
     }
 
     // Skip pure task instructions (fix/add/delete/refactor/debug/deploy/test/run/build)
-    if (/^(帮我|请你|麻烦)?\s*(fix|add|delete|remove|refactor|debug|deploy|test|run|build|create|update|implement|write|generate|make)/i.test(prompt)) {
+    if (!isMeta && /^(帮我|请你|麻烦)?\s*(fix|add|delete|remove|refactor|debug|deploy|test|run|build|create|update|implement|write|generate|make)/i.test(prompt)) {
       process.exit(0);
     }
-    if (/^(帮我|请你|麻烦)?\s*(修|加|删|重构|调试|部署|测试|运行|构建|创建|更新|实现|写|生成|做)/.test(prompt)) {
+    if (!isMeta && /^(帮我|请你|麻烦)?\s*(修|加|删|重构|调试|部署|测试|运行|构建|创建|更新|实现|写|生成|做)/.test(prompt)) {
       process.exit(0);
     }
 
     // Skip agent identity definitions (these belong in project CLAUDE.md, not user profile)
-    if (/^(你是|你叫|你的(角色|身份|职责|任务)|你负责|你现在是|from now on you are|you are now|your role is)/i.test(prompt)) {
+    if (!isMeta && /^(你是|你叫|你的(角色|身份|职责|任务)|你负责|你现在是|from now on you are|you are now|your role is)/i.test(prompt)) {
       process.exit(0);
     }
 
     // Skip pasted error logs / stack traces
-    if (/^(Error|TypeError|SyntaxError|ReferenceError|at\s+\w+|Traceback|FATAL|WARN|ERR!)/i.test(prompt)) {
+    if (!isMeta && /^(Error|TypeError|SyntaxError|ReferenceError|at\s+\w+|Traceback|FATAL|WARN|ERR!)/i.test(prompt)) {
       process.exit(0);
     }
-    if (prompt.split('\n').length > 10) {
+    if (!isMeta && prompt.split('\n').length > 10) {
       // Multi-line pastes are usually code or logs, not preferences
       process.exit(0);
     }
 
     // Skip pure questions with no preference signal
-    if (/^(what|how|why|where|when|which|can you|could you|is there|are there|does|do you)\s/i.test(prompt) &&
+    if (!isMeta && /^(what|how|why|where|when|which|can you|could you|is there|are there|does|do you)\s/i.test(prompt) &&
         !/prefer|like|hate|always|never|style|习惯|偏好|喜欢|讨厌/.test(prompt)) {
       process.exit(0);
     }
-    if (/^(什么|怎么|为什么|哪|能不能|可以|是不是)\s/.test(prompt) &&
+    if (!isMeta && /^(什么|怎么|为什么|哪|能不能|可以|是不是)\s/.test(prompt) &&
         !/偏好|喜欢|讨厌|习惯|以后|一律|总是|永远|记住/.test(prompt)) {
       process.exit(0);
     }
@@ -93,12 +101,14 @@ process.stdin.on('end', () => {
     const isStrong = STRONG_SIGNAL_ZH.test(prompt) || STRONG_SIGNAL_EN.test(prompt);
     const isCorrection = CORRECTION_ZH.test(prompt) || CORRECTION_EN.test(prompt);
     const confidence = (isStrong || isCorrection) ? 'high' : 'normal';
+    const signalType = isMeta ? 'metacognitive' : isCorrection ? 'correction' : isStrong ? 'directive' : 'implicit';
 
     // Append to buffer
     const entry = {
       ts: new Date().toISOString(),
       prompt: prompt,
       confidence: confidence,
+      type: signalType,
       session: data.session_id || null,
       cwd: data.cwd || null
     };