metame-cli 1.4.13 → 1.4.17

package/README.md

@@ -105,11 +105,11 @@ Built into the daemon. Runs every 60 seconds regardless of what's in your config
 - Detects when you go idle → generates session continuity summaries
 
 **Layer 1 — System Evolution (built-in defaults)**
-Three tasks shipped out of the box. Only fire when you're idle — they never interrupt active work:
+Three tasks shipped out of the box. They are precondition-gated and run only when useful:
 
 ```yaml
 - cognitive-distill   # 4h · has signals? → distill preferences into profile
-- memory-extract      # 2h · scan sessions → extract long-term facts + topic tags
+- memory-extract      # 4h · scan sessions → extract long-term facts + topic tags
 - skill-evolve        # 6h · has signals? → evolve skills from task outcomes
 ```
 
@@ -150,7 +150,7 @@ Chain skills into multi-step workflows — research → write → publish — fu
           prompt: "Publish it"
 ```
 
-Task options: `require_idle` (defer when you're active), `precondition` (shell guard — skip if false, zero tokens), `notify` (push result to phone), `model`, `cwd`, `allowedTools`, `timeout`.
+Task options: `require_idle` (defer when you're active, retry on next heartbeat tick), `precondition` (shell guard — skip if false, zero tokens), `notify` (push result to phone), `model`, `cwd`, `allowedTools`, `timeout`.
 
 ### 5. Skills That Evolve Themselves
 
@@ -319,14 +319,14 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
                                           │   (memory layer)  ← NEW      │
                                           └──────────────────────────────┘
                                                        ↑
-                                          sleep mode → memory consolidation
-                                                       (background, automatic)
+                                          idle mode → summaries + background memory tasks
+                                                      (automatic, precondition-gated)
 ```
 
 - **Profile** (`~/.claude_profile.yaml`): Your cognitive fingerprint. Injected into every Claude session via `CLAUDE.md`.
-- **Daemon** (`scripts/daemon.js`): Background process handling Telegram/Feishu messages, heartbeat tasks, Unix socket dispatch, and sleep-mode memory triggers.
-- **Distillation** (`scripts/distill.js`): On each launch, silently analyzes your recent messages and updates your profile.
-- **Memory Extract** (`scripts/memory-extract.js`): Triggered on sleep mode. Extracts long-term facts and session topic tags from completed conversations.
+- **Daemon** (`scripts/daemon.js`): Background process handling Telegram/Feishu messages, heartbeat tasks, Unix socket dispatch, and idle/sleep transitions.
+- **Distillation** (`scripts/distill.js`): Heartbeat task (default 4h, signal-gated) that updates your profile.
+- **Memory Extract** (`scripts/memory-extract.js`): Heartbeat task (default 4h, idle-gated) that extracts long-term facts and session topic tags.
 - **Session Summarize** (`scripts/session-summarize.js`): Generates a 2-4 sentence summary for idle sessions. Injected as context when resuming after a 2h+ gap.
 
 ## Security
@@ -349,7 +349,7 @@ All agents share your cognitive profile (`~/.claude_profile.yaml`) — they all
 | Session summary (per session) | ~400–900 tokens input + ≤250 tokens output (Haiku) |
 | Mobile commands (`/stop`, `/list`, `/undo`) | 0 tokens |
 
-> 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.
+> 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 follows heartbeat schedule with idle/precondition guards, and summaries trigger once per idle session on sleep-mode transitions.
 
 ## Plugin
 

package/package.json

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

package/scripts/daemon-admin-commands.js

@@ -17,6 +17,7 @@ function createAdminCommandHandler(deps) {
     getAllTasks,
     dispatchTask,
     log,
+    skillEvolution,
   } = deps;
 
   async function handleAdminCommand(ctx) {
@@ -40,6 +41,96 @@ function createAdminCommandHandler(deps) {
       return { handled: true, config };
     }
 
+    // /skill-evo — inspect and resolve skill evolution queue
+    if (text === '/skill-evo' || text.startsWith('/skill-evo ')) {
+      if (!skillEvolution) {
+        await bot.sendMessage(chatId, '❌ skill-evolution 模块不可用');
+        return { handled: true, config };
+      }
+
+      const arg = text.slice('/skill-evo'.length).trim();
+      const renderItem = (i) => {
+        const id = i.id || '-';
+        const target = i.skill_name ? `skill=${i.skill_name}` : (i.search_hint ? `hint=${i.search_hint}` : 'global');
+        const seen = i.last_seen || i.detected || '-';
+        const ev = i.evidence_count || 1;
+        return `- [${id}] ${i.type}/${i.status} (${target}, ev=${ev})\n  ${i.reason || '(no reason)'}\n  last: ${seen}`;
+      };
+
+      if (!arg || arg === 'list') {
+        const pendingAll = skillEvolution.listQueueItems({ status: 'pending', limit: 200 });
+        const notifiedAll = skillEvolution.listQueueItems({ status: 'notified', limit: 200 });
+        const installedAll = skillEvolution.listQueueItems({ status: 'installed', limit: 200 });
+        const dismissedAll = skillEvolution.listQueueItems({ status: 'dismissed', limit: 200 });
+
+        const pending = pendingAll.slice(0, 10);
+        const notified = notifiedAll.slice(0, 10);
+        const resolved = [...installedAll, ...dismissedAll]
+          .sort((a, b) => new Date(b.last_seen || b.detected || 0).getTime() - new Date(a.last_seen || a.detected || 0).getTime())
+          .slice(0, 5);
+
+        const lines = ['🧬 Skill Evolution Queue'];
+        lines.push(`pending: ${pendingAll.length} | notified: ${notifiedAll.length} | resolved(total): ${installedAll.length + dismissedAll.length}`);
+        if (pending.length > 0) {
+          lines.push('\nPending:');
+          for (const item of pending.slice(0, 5)) lines.push(renderItem(item));
+        }
+        if (notified.length > 0) {
+          lines.push('\nNotified:');
+          for (const item of notified.slice(0, 5)) lines.push(renderItem(item));
+        }
+        if (resolved.length > 0) {
+          lines.push('\nResolved (latest):');
+          for (const item of resolved) lines.push(renderItem(item));
+        }
+        if (pending.length === 0 && notified.length === 0 && resolved.length === 0) {
+          lines.push('\n(queue empty)');
+        }
+        lines.push('\n用法: /skill-evo done <id> | /skill-evo dismiss <id>');
+
+        await bot.sendMessage(chatId, lines.join('\n'));
+
+        if (bot.sendButtons) {
+          const actionable = [...notified, ...pending].slice(0, 3);
+          if (actionable.length > 0) {
+            const buttons = [];
+            for (const item of actionable) {
+              const label = `${item.type}:${(item.skill_name || item.search_hint || 'item').slice(0, 10)}`;
+              buttons.push([
+                { text: `✅ ${label}`, callback_data: `/skill-evo done ${item.id}` },
+                { text: `🙈 ${label}`, callback_data: `/skill-evo dismiss ${item.id}` },
+              ]);
+            }
+            await bot.sendButtons(chatId, '处理建议项：', buttons);
+          }
+        }
+        return { handled: true, config };
+      }
+
+      const doneMatch = arg.match(/^(?:done|install|installed)\s+(\S+)$/i);
+      if (doneMatch) {
+        const id = doneMatch[1];
+        const ok = skillEvolution.resolveQueueItemById
+          ? skillEvolution.resolveQueueItemById(id, 'installed')
+          : false;
+        await bot.sendMessage(chatId, ok ? `✅ 已标记 installed: ${id}` : `❌ 未找到可处理项: ${id}`);
+        return { handled: true, config };
+      }
+
+      const dismissMatch = arg.match(/^(?:dismiss|skip|ignored?)\s+(\S+)$/i);
+      if (dismissMatch) {
+        const id = dismissMatch[1];
+        const ok = skillEvolution.resolveQueueItemById
+          ? skillEvolution.resolveQueueItemById(id, 'dismissed')
+          : false;
+        await bot.sendMessage(chatId, ok ? `✅ 已标记 dismissed: ${id}` : `❌ 未找到可处理项: ${id}`);
+        return { handled: true, config };
+      }
+
+      await bot.sendMessage(chatId, '用法: /skill-evo list | /skill-evo done <id> | /skill-evo dismiss <id>');
+      return { handled: true, config };
+    }
+
     if (text === '/tasks') {
       const { general, project } = getAllTasks(config);
       let msg = '';

package/scripts/daemon-agent-commands.js

@@ -23,6 +23,7 @@ function createAgentCommandHandler(deps) {
     doBindAgent,
     mergeAgentRole,
     agentTools,
+    attachOrCreateSession,
     agentFlowTtlMs,
     agentBindTtlMs,
   } = deps;
@@ -99,13 +100,30 @@ function createAgentCommandHandler(deps) {
       const icon = p.icon || '🤖';
       const action = res.data.isNewProject ? '绑定成功' : '重新绑定';
       const displayCwd = String(res.data.cwd || '').replace(HOME, '~');
+      if (res.data.cwd && typeof attachOrCreateSession === 'function') {
+        attachOrCreateSession(chatId, normalizeCwd(res.data.cwd), p.name || agentName || res.data.projectKey || '');
+      }
       await bot.sendMessage(chatId, `${icon} ${p.name || agentName} ${action}\n目录: ${displayCwd}`);
       return { ok: true, data: res.data };
     }
 
     // Backward-compatible fallback
-    await doBindAgent(bot, chatId, agentName, agentCwd);
-    return { ok: true, data: { cwd: agentCwd } };
+    const fallback = await doBindAgent(bot, chatId, agentName, agentCwd);
+    if (!fallback || fallback.ok === false) {
+      return { ok: false, error: (fallback && fallback.error) || 'bind failed' };
+    }
+    const fallbackCwd = (fallback.data && fallback.data.cwd) || agentCwd;
+    if (fallbackCwd && typeof attachOrCreateSession === 'function') {
+      attachOrCreateSession(chatId, normalizeCwd(fallbackCwd), agentName || '');
+    }
+    return {
+      ok: true,
+      data: {
+        cwd: fallbackCwd,
+        projectKey: fallback && fallback.data ? fallback.data.projectKey : null,
+        project: fallback && fallback.data ? fallback.data.project : null,
+      },
+    };
   }
 
   async function editRoleViaUnifiedApi(workspaceDir, deltaText) {
@@ -121,7 +139,10 @@ function createAgentCommandHandler(deps) {
     if (agentTools && typeof agentTools.createNewWorkspaceAgent === 'function') {
       return agentTools.createNewWorkspaceAgent(name, dir, roleDesc, chatId);
     }
-    await doBindAgent({ sendMessage: async () => {} }, chatId, name, dir);
+    const bound = await doBindAgent({ sendMessage: async () => {} }, chatId, name, dir);
+    if (!bound || bound.ok === false) {
+      return { ok: false, error: (bound && bound.error) || 'bind failed' };
+    }
     const merged = await mergeAgentRole(dir, roleDesc);
     if (merged.error) return { ok: false, error: merged.error };
     return { ok: true, data: { cwd: dir, project: { name }, role: merged } };
@@ -252,6 +273,9 @@ function createAgentCommandHandler(deps) {
           await bot.sendMessage(chatId, `❌ 创建 Agent 失败: ${created.error}`);
           return true;
         }
+        if (created.data && created.data.cwd && typeof attachOrCreateSession === 'function') {
+          attachOrCreateSession(chatId, normalizeCwd(created.data.cwd), name || '');
+        }
         const roleInfo = created.data.role || {};
         if (roleInfo.skipped) {
           await bot.sendMessage(chatId, '✅ Agent 创建成功');

package/scripts/daemon-claude-engine.js

@@ -25,6 +25,7 @@ function createClaudeEngine(deps) {
     normalizeCwd,
     isContentFile,
     sendFileButtons,
+    findSessionFile,
     listRecentSessions,
     getSession,
     createSession,
@@ -38,6 +39,72 @@ function createClaudeEngine(deps) {
     statusThrottleMs = 3000,
     fallbackThrottleMs = 8000,
   } = deps;
+  const SESSION_CWD_VALIDATION_TTL_MS = 30 * 1000;
+  const _sessionCwdValidationCache = new Map(); // key: `${sessionId}@@${cwd}` -> { inCwd, ts }
+
+  function cacheSessionCwdValidation(cacheKey, inCwd) {
+    _sessionCwdValidationCache.set(cacheKey, { inCwd: !!inCwd, ts: Date.now() });
+    if (_sessionCwdValidationCache.size > 512) {
+      const firstKey = _sessionCwdValidationCache.keys().next().value;
+      if (firstKey) _sessionCwdValidationCache.delete(firstKey);
+    }
+    return !!inCwd;
+  }
+
+  function isSessionInCwd(sessionId, cwd) {
+    const safeSessionId = String(sessionId || '').trim();
+    if (!safeSessionId || !cwd) return false;
+
+    const normCwd = normalizeCwd(cwd);
+    const cacheKey = `${safeSessionId}@@${normCwd}`;
+    const cached = _sessionCwdValidationCache.get(cacheKey);
+    if (cached && (Date.now() - cached.ts) < SESSION_CWD_VALIDATION_TTL_MS) {
+      return !!cached.inCwd;
+    }
+
+    try {
+      // Fast path: locate the exact session file, then validate its indexed projectPath.
+      if (typeof findSessionFile === 'function') {
+        const sessionFile = findSessionFile(safeSessionId);
+        if (!sessionFile) return cacheSessionCwdValidation(cacheKey, false);
+
+        const projectDir = path.dirname(sessionFile);
+        const indexFile = path.join(projectDir, 'sessions-index.json');
+        if (fs.existsSync(indexFile)) {
+          const data = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
+          const entries = Array.isArray(data && data.entries) ? data.entries : [];
+          const entry = entries.find(e => e && e.sessionId === safeSessionId);
+          if (entry && entry.projectPath) {
+            return cacheSessionCwdValidation(cacheKey, normalizeCwd(entry.projectPath) === normCwd);
+          }
+          // sessions-index may lag behind new sessions; use project-level path from any entry.
+          const anyProjectPath = (entries.find(e => e && e.projectPath) || {}).projectPath;
+          if (anyProjectPath) {
+            return cacheSessionCwdValidation(cacheKey, normalizeCwd(anyProjectPath) === normCwd);
+          }
+        }
+
+        // Weak fallback: encode normCwd using Claude's folder convention and accept
+        // only positive match. If it doesn't match, keep current session to avoid
+        // false mismatches for paths with non-ASCII/special characters.
+        const expectedDirName = '-' + normCwd.replace(/^\//, '').replace(/[\/_ ]/g, '-');
+        const actualDirName = path.basename(projectDir);
+        if (actualDirName === expectedDirName) {
+          return cacheSessionCwdValidation(cacheKey, true);
+        }
+        // Unable to prove mismatch safely.
+        return cacheSessionCwdValidation(cacheKey, true);
+      }
+
+      // Ultimate fallback (legacy path): scoped scan in target cwd.
+      const recentInCwd = listRecentSessions(1000, normCwd);
+      const existsInCwd = recentInCwd.some(s => s.sessionId === safeSessionId);
+      return cacheSessionCwdValidation(cacheKey, existsInCwd);
+    } catch {
+      // Conservative fallback: if validation infra fails, avoid false positives by preserving current session.
+      return cacheSessionCwdValidation(cacheKey, true);
+    }
+  }
 
   /**
    * Parse [[FILE:...]] markers from Claude output.
@@ -467,13 +534,19 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
     // Skill routing: detect skill first, then decide session
     // BUT: if agent was explicitly addressed by nickname, don't let skill routing hijack the session
     const skill = agentMatch ? null : routeSkill(prompt);
+    const chatIdStr = String(chatId);
+    const chatAgentMap = { ...(config.telegram ? config.telegram.chat_agent_map : {}), ...(config.feishu ? config.feishu.chat_agent_map : {}) };
+    const boundProjectKey = chatAgentMap[chatIdStr] || (chatIdStr.startsWith('_agent_') ? chatIdStr.slice(7) : null);
+    const boundProject = boundProjectKey && config.projects ? config.projects[boundProjectKey] : null;
+    const boundCwd = (boundProject && boundProject.cwd) ? normalizeCwd(boundProject.cwd) : null;
 
     // Skills with dedicated pinned sessions (reused across days, no re-injection needed)
     const PINNED_SKILL_SESSIONS = new Set(['macos-mail-calendar', 'skill-manager']);
+    const usePinnedSkillSession = !!(skill && PINNED_SKILL_SESSIONS.has(skill));
 
     let session = getSession(chatId);
 
-    if (skill && PINNED_SKILL_SESSIONS.has(skill)) {
+    if (usePinnedSkillSession) {
       // Use a dedicated long-lived session per skill
       const state = loadState();
       if (!state.pinned_sessions) state.pinned_sessions = {};
@@ -494,21 +567,51 @@ Reply with ONLY the name, nothing else. Examples: 插件开发, API重构, Bug
         log('INFO', `Pinned session created for skill ${skill}: ${session.id.slice(0, 8)}`);
       }
     } else if (!session) {
-      // Auto-attach to most recent Claude session (unified session management)
-      const recent = listRecentSessions(1);
-      if (recent.length > 0 && recent[0].sessionId && recent[0].projectPath) {
-        const target = recent[0];
-        const state = loadState();
-        state.sessions[chatId] = {
-          id: target.sessionId,
-          cwd: target.projectPath,
-          started: true,
-        };
-        saveState(state);
-        session = state.sessions[chatId];
-        log('INFO', `Auto-attached ${chatId} to recent session: ${target.sessionId.slice(0, 8)} (${path.basename(target.projectPath)})`);
+      if (boundCwd) {
+        // Agent-bound chats must stay in their own workspace: never attach to another project's session.
+        const recentInBound = listRecentSessions(1, boundCwd);
+        if (recentInBound.length > 0 && recentInBound[0].sessionId) {
+          const target = recentInBound[0];
+          const state = loadState();
+          state.sessions[chatId] = {
+            id: target.sessionId,
+            cwd: boundCwd,
+            started: true,
+          };
+          saveState(state);
+          session = state.sessions[chatId];
+          log('INFO', `Auto-attached ${chatId} to bound-session: ${target.sessionId.slice(0, 8)} (${path.basename(boundCwd)})`);
+        } else {
+          session = createSession(chatId, boundCwd, boundProject && boundProject.name ? boundProject.name : '');
+          log('INFO', `Created fresh session for bound workspace: ${path.basename(boundCwd)}`);
+        }
       } else {
-        session = createSession(chatId);
+        // Non-bound chats keep legacy behavior: attach global recent, else create.
+        const recent = listRecentSessions(1);
+        if (recent.length > 0 && recent[0].sessionId && recent[0].projectPath) {
+          const target = recent[0];
+          const state = loadState();
+          state.sessions[chatId] = {
+            id: target.sessionId,
+            cwd: target.projectPath,
+            started: true,
+          };
+          saveState(state);
+          session = state.sessions[chatId];
+          log('INFO', `Auto-attached ${chatId} to recent session: ${target.sessionId.slice(0, 8)} (${path.basename(target.projectPath)})`);
+        } else {
+          session = createSession(chatId);
+        }
+      }
+    }
+
+    // Safety guard: prevent stale state from resuming another workspace's session.
+    if (!usePinnedSkillSession && session && session.started && session.id && session.id !== '__continue__' && session.cwd) {
+      const sessionCwd = normalizeCwd(session.cwd);
+      const existsInCwd = isSessionInCwd(session.id, sessionCwd);
+      if (!existsInCwd) {
+        log('WARN', `Session mismatch detected for ${chatId}: ${session.id.slice(0, 8)} not found in ${sessionCwd}; creating fresh session`);
+        session = createSession(chatId, sessionCwd, boundProject && boundProject.name ? boundProject.name : '');
       }
     }
 

package/scripts/daemon-command-router.js

@@ -6,6 +6,7 @@ function createCommandRouter(deps) {
     loadConfig,
     checkBudget,
     checkCooldown,
+    resetCooldown,
     routeAgent,
     normalizeCwd,
     attachOrCreateSession,
@@ -58,7 +59,7 @@ function createCommandRouter(deps) {
   }
 
   function extractPathFromText(input) {
-    const m = String(input || '').match(/(?:~\/|\/)[^\s，。；;!！?？"“”'‘’`]+/);
+    const m = String(input || '').match(/(?:~\/|\/|\.\/|\.\.\/)[^\s，。；;!！?？"“”'‘’`]+/);
     if (!m) return '';
     return m[0].replace(/[，。；;!！?？]+$/, '');
   }
@@ -100,6 +101,18 @@ function createCommandRouter(deps) {
     return '';
   }
 
+  function isLikelyDirectAgentAction(input) {
+    const text = String(input || '').trim();
+    return /^(?:请|帮我|麻烦|给我|给这个群|给当前群|在这个群|把这个群|把当前群|将这个群|这个群|当前群|本群|群里|我想|我要|我需要|创建|新建|新增|搞一个|加一个|create|bind|绑定|列出|查看|显示|有哪些|解绑|取消绑定|断开绑定|修改|调整)/i.test(text);
+  }
+
+  function looksLikeAgentIssueReport(input) {
+    const text = String(input || '').trim();
+    const hasIssueWords = /(用户反馈|反馈|报错|bug|问题|故障|异常|修复|改一下|修一下|任务|工单|代码)/i.test(text);
+    const hasAgentWords = /(agent|智能体|session|会话|目录|工作区|绑定|切换)/i.test(text);
+    return hasIssueWords && hasAgentWords;
+  }
+
   function projectNameFromResult(data, fallbackName) {
     if (data && data.project && data.project.name) return data.project.name;
     if (data && data.projectKey) return data.projectKey;
@@ -122,6 +135,11 @@ function createCommandRouter(deps) {
     if (hasFreshPendingFlow(key) || hasFreshPendingFlow(key + ':edit')) return false;
     const input = text.trim();
     if (!input) return false;
+    const directAction = isLikelyDirectAgentAction(input);
+    const issueReport = looksLikeAgentIssueReport(input);
+    if (issueReport && !directAction) return false;
+    const workspaceDir = extractPathFromText(input);
+    const hasWorkspacePath = !!workspaceDir;
 
     const hasAgentContext = /(agent|智能体|工作区|人设|绑定|当前群|这个群|chat|workspace)/i.test(input);
     const wantsList = /(列出|查看|显示|有哪些|list|show)/i.test(input) && /(agent|智能体|工作区|绑定)/i.test(input);
@@ -130,10 +148,10 @@ function createCommandRouter(deps) {
       ((/(角色|职责|人设)/i.test(input) && /(改|修改|调整|更新|变成|改成|改为)/i.test(input)) ||
       /(把这个agent|把当前agent|当前群.*角色|当前群.*职责)/i.test(input));
     const wantsCreate =
-      (/(创建|新建|新增|搞一个|加一个|create)/i.test(input) && /(agent|智能体|人设|工作区)/i.test(input));
+      (/(创建|新建|新增|搞一个|加一个|create)/i.test(input) && /(agent|智能体|人设|工作区)/i.test(input) && (directAction || hasWorkspacePath));
     const wantsBind =
       !wantsCreate &&
-      (/(绑定|bind)/i.test(input) && hasAgentContext);
+      (/(绑定|bind)/i.test(input) && hasAgentContext && (directAction || hasWorkspacePath));
 
     if (!wantsList && !wantsUnbind && !wantsEditRole && !wantsCreate && !wantsBind) {
       return false;
@@ -194,9 +212,12 @@ function createCommandRouter(deps) {
     }
 
     if (wantsCreate) {
-      const workspaceDir = extractPathFromText(input);
       if (!workspaceDir) {
-        await bot.sendMessage(chatId, '请补充工作目录，例如：`给这个群创建一个 Agent，目录是 ~/projects/foo`');
+        await bot.sendMessage(chatId, [
+          '我可以帮你创建并绑定 Agent，还差一个工作目录。',
+          '例如：`给这个群创建一个 Agent，目录是 ~/projects/foo`',
+          '也可以直接回我一个路径（`~/`、`/`、`./`、`../` 开头都行）。',
+        ].join('\n'));
         return true;
       }
       const agentName = deriveAgentName(input, workspaceDir);
@@ -214,7 +235,6 @@ function createCommandRouter(deps) {
     }
 
     if (wantsBind) {
-      const workspaceDir = extractPathFromText(input);
       const agentName = deriveAgentName(input, workspaceDir);
       const res = await agentTools.bindAgentToChat(chatId, agentName, workspaceDir || null);
       if (!res.ok) {
@@ -319,6 +339,7 @@ function createCommandRouter(deps) {
         '',
         `⚙️ /model [${currentModel}] /provider [${currentProvider}] /status /tasks /run /budget /reload`,
         '🧠 /memory — 记忆统计 · /memory <关键词> — 搜索事实',
+        '🧬 /skill-evo — 查看/处理技能演化队列',
         `🔧 /doctor /fix /reset /sh <cmd> /nosleep [${getNoSleepProcess() ? 'ON' : 'OFF'}]`,
         '',
         '直接打字即可对话 💬',
@@ -357,6 +378,7 @@ function createCommandRouter(deps) {
         if (msgs.length === 0) return;
         const combined = msgs.join('\n');
         log('INFO', `Processing ${msgs.length} queued message(s) for ${chatId}`);
+        resetCooldown(chatId); // queued msgs already waited, skip cooldown
         try {
           await handleCommand(bot, chatId, combined, config, executeTaskByName);
         } catch (e) {

package/scripts/daemon-task-scheduler.js

@@ -509,6 +509,7 @@ function createTaskScheduler(deps) {
           const notifications = skillEvolution.checkEvolutionQueue();
           for (const item of notifications) {
             let msg = '';
+            const idHint = item.id ? `\nID: \`${item.id}\`` : '';
             if (item.type === 'skill_gap') {
               msg = `🧬 *技能缺口检测*\n${item.reason}`;
               if (item.search_hint) msg += `\n搜索建议: \`${item.search_hint}\``;
@@ -517,6 +518,8 @@ function createTaskScheduler(deps) {
             } else if (item.type === 'user_complaint') {
               msg = `⚠️ *技能反馈*\n技能 \`${item.skill_name}\` 收到用户反馈\n${item.reason}`;
             }
+            if (msg && item.id) msg += `${idHint}\n处理: \`/skill-evo done ${item.id}\` 或 \`/skill-evo dismiss ${item.id}\``;
+            else if (msg) msg += idHint;
             if (msg && notifyFn) notifyFn(msg);
           }
         } catch (e) { log('WARN', `Skill evolution queue check failed: ${e.message}`); }

package/scripts/daemon.js

@@ -52,6 +52,8 @@ try { skillEvolution = require('./skill-evolution'); } catch { /* graceful fallb
 const SKILL_ROUTES = [
   { name: 'macos-mail-calendar', pattern: /邮件|邮箱|收件箱|日历|日程|会议|schedule|email|mail|calendar|unread|inbox/i },
   { name: 'heartbeat-task-manager', pattern: /提醒|remind|闹钟|定时|每[天周月]/i },
+  { name: 'skill-manager', pattern: /找技能|管理技能|更新技能|安装技能|skill manager|skill scout|(?:find|look for)\s+skills?/i },
+  { name: 'skill-evolution-manager', pattern: /\/evolve\b|复盘一下|记录一下(这个)?经验|保存到\s*skill|skill evolution/i },
 ];
 
 function routeSkill(prompt) {
@@ -728,6 +730,10 @@ function checkCooldown(chatId) {
   return { ok: true };
 }
 
+function resetCooldown(chatId) {
+  delete _lastClaudeCall[chatId];
+}
+
 // Path shortener — imported from ./utils
 const { shortenPath, expandPath } = createPathMap();
 const {
@@ -753,14 +759,6 @@ function attachOrCreateSession(chatId, projCwd, name) {
   const state = loadState();
   // Virtual agent chatIds (_agent_*) always get a fresh one-shot session.
   // They must not resume real sessions, to avoid concurrency conflicts.
-  if (!String(chatId).startsWith('_agent_')) {
-    const recent = listRecentSessions(1, projCwd);
-    if (recent.length > 0 && recent[0].sessionId) {
-      state.sessions[chatId] = { id: recent[0].sessionId, cwd: projCwd, started: true };
-      saveState(state);
-      return;
-    }
-  }
   const newSess = createSession(chatId, projCwd, name || '');
   state.sessions[chatId] = { id: newSess.id, cwd: projCwd, started: false };
   saveState(state);
@@ -867,8 +865,13 @@ async function doBindAgent(bot, chatId, agentName, agentCwd) {
     } else {
       await bot.sendMessage(chatId, `${icon} ${agentName} ${action}\n目录: ${displayCwd}`);
     }
+    return {
+      ok: true,
+      data: { projectKey, cwd: agentCwd, isNewProject: isNew, project: cfg.projects[projectKey] },
+    };
   } catch (e) {
     await bot.sendMessage(chatId, `❌ 绑定失败: ${e.message}`);
+    return { ok: false, error: e.message };
   }
 }
 
@@ -1030,6 +1033,7 @@ const { handleAdminCommand } = createAdminCommandHandler({
   getAllTasks,
   dispatchTask,
   log,
+  skillEvolution,
 });
 
 const { handleSessionCommand } = createSessionCommandHandler({
@@ -1086,6 +1090,7 @@ const { spawnClaudeAsync, askClaude } = createClaudeEngine({
   normalizeCwd,
   isContentFile,
   sendFileButtons,
+  findSessionFile,
   listRecentSessions,
   getSession,
   createSession,
@@ -1152,6 +1157,7 @@ const { handleAgentCommand } = createAgentCommandHandler({
   doBindAgent,
   mergeAgentRole,
   agentTools,
+  attachOrCreateSession,
   agentFlowTtlMs: getAgentFlowTtlMs,
   agentBindTtlMs: getAgentBindTtlMs,
 });
@@ -1207,6 +1213,7 @@ const { handleCommand } = createCommandRouter({
   loadConfig,
   checkBudget,
   checkCooldown,
+  resetCooldown,
   routeAgent,
   normalizeCwd,
   attachOrCreateSession,

package/scripts/skill-evolution.js

@@ -11,7 +11,7 @@
  *   - Writes to evolution_queue.yaml for immediate action
  *
  * COLD PATH (batched, Haiku-powered):
- *   - Piggybacks on distill.js (every 4h or on launch)
+ *   - Runs as standalone heartbeat script task (skill-evolve, default 6h)
  *   - Haiku analyzes accumulated skill signals for nuanced insights
  *   - Merges evolution data into skill's evolution.json + SKILL.md
  *
@@ -174,7 +174,8 @@ function extractSkillSignal(prompt, output, error, files, cwd, toolUsageLog) {
 
   const hasSkills = skills.length > 0;
   const hasError = !!error;
-  const hasToolFailure = output && /(?:failed|error|not found|not available|skill.{0,20}(?:missing|absent|not.{0,10}install))/i.test(output);
+  const outputText = typeof output === 'string' ? output : '';
+  const hasToolFailure = /(?:failed|error|not found|not available|skill.{0,20}(?:missing|absent|not.{0,10}install))/i.test(outputText);
 
   // Skip if no skill involvement and no failure
   if (!hasSkills && !hasError && !hasToolFailure) return null;
@@ -185,10 +186,11 @@ function extractSkillSignal(prompt, output, error, files, cwd, toolUsageLog) {
     skills_invoked: skills,
     tools_used: tools.slice(0, 20), // cap for storage
     error: error ? error.substring(0, 500) : null,
+    output_excerpt: outputText.substring(0, 500),
     has_tool_failure: !!hasToolFailure,
     files_modified: (files || []).slice(0, 10),
     cwd: cwd || null,
-    outcome: error ? 'error' : (output ? 'success' : 'empty'),
+    outcome: (hasError || hasToolFailure) ? 'error' : (outputText ? 'success' : 'empty'),
   };
 }
 
@@ -275,7 +277,12 @@ function checkHotEvolution(signal) {
 
   // Rule 3: Missing skill detection
   const missingRe = new RegExp(policy.missing_skill_patterns.join('|'), 'i');
-  if (signal.outcome !== 'success' && signal.prompt && missingRe.test((signal.error || '') + (signal.prompt || ''))) {
+  const missText = [(signal.error || ''), (signal.prompt || ''), (signal.output_excerpt || '')].join('\n');
+  const hasMissingPattern = missingRe.test(missText);
+  const hasExplicitSkillMiss = signal.has_tool_failure &&
+    /skill|技能|能力/i.test(missText) &&
+    /not found|missing|absent|no skill|找不到|没有找到|能力不足/i.test(missText);
+  if (signal.prompt && (hasMissingPattern || hasExplicitSkillMiss)) {
     addToQueue(queue, {
       type: 'skill_gap',
       skill_name: null,
@@ -295,7 +302,7 @@ function checkHotEvolution(signal) {
     if (isSuccess || isFail) {
       for (const sk of signal.skills_invoked) {
         const skillDir = findSkillDir(sk);
-        if (skillDir) trackInsightOutcome(skillDir, isSuccess);
+        if (skillDir) trackInsightOutcome(skillDir, isSuccess, signal);
       }
     }
   }
@@ -305,7 +312,51 @@ function checkHotEvolution(signal) {
  * Update insight outcome stats in evolution.json for a skill.
  * Tracks success_count, fail_count, last_applied_at per insight text.
  */
-function trackInsightOutcome(skillDir, isSuccess) {
+const INSIGHT_STOPWORDS = new Set([
+  'the', 'and', 'for', 'with', 'that', 'this', 'from', 'into', 'when', 'where',
+  'user', 'skill', 'meta', 'metame', 'should', 'always', 'never', 'please',
+  '问题', '用户', '技能', '需要', '应该', '这个', '那个', '以及', '如果', '然后',
+]);
+
+function extractInsightTokens(text) {
+  const raw = String(text || '').toLowerCase();
+  const en = raw.match(/[a-z][a-z0-9_.-]{2,}/g) || [];
+  const zh = raw.match(/[\u4e00-\u9fff]{2,}/g) || [];
+  const tokens = [...en, ...zh]
+    .map(t => t.trim())
+    .filter(t => t.length >= 2 && !INSIGHT_STOPWORDS.has(t));
+  return [...new Set(tokens)];
+}
+
+function pickMatchedInsights(allInsights, signal) {
+  if (!signal || !Array.isArray(allInsights) || allInsights.length === 0) return [];
+
+  const context = [
+    signal.prompt || '',
+    signal.error || '',
+    signal.output_excerpt || '',
+    ...(Array.isArray(signal.tools_used) ? signal.tools_used.map(t => `${t.name || ''} ${t.context || ''}`) : []),
+    ...(Array.isArray(signal.files_modified) ? signal.files_modified : []),
+  ].join('\n').toLowerCase();
+
+  const scored = allInsights
+    .map((insight) => {
+      const tokens = extractInsightTokens(insight).slice(0, 12);
+      if (tokens.length === 0) return { insight, score: 0 };
+      let score = 0;
+      for (const token of tokens) {
+        if (context.includes(token)) score++;
+      }
+      return { insight, score };
+    })
+    .filter(x => x.score > 0)
+    .sort((a, b) => b.score - a.score);
+
+  if (scored.length > 0) return scored.slice(0, 3).map(x => x.insight);
+  return allInsights.length === 1 ? [allInsights[0]] : [];
+}
+
+function trackInsightOutcome(skillDir, isSuccess, signal = null) {
   const evoPath = path.join(skillDir, 'evolution.json');
   let data = {};
   try { data = JSON.parse(fs.readFileSync(evoPath, 'utf8')); } catch { return; }
@@ -317,8 +368,9 @@ function trackInsightOutcome(skillDir, isSuccess) {
     ...(data.fixes || []),
     ...(data.contexts || []),
   ];
+  const targetInsights = signal ? pickMatchedInsights(allInsights, signal) : allInsights;
 
-  for (const insight of allInsights) {
+  for (const insight of targetInsights) {
     if (!data.insights_stats[insight]) {
       data.insights_stats[insight] = { success_count: 0, fail_count: 0, last_applied_at: null };
     }
@@ -333,7 +385,7 @@ function trackInsightOutcome(skillDir, isSuccess) {
 
 // ─────────────────────────────────────────────
 // Cold Path: Haiku-Powered Analysis
-// (called from distill.js)
+// (called by heartbeat script task: skill-evolve)
 // ─────────────────────────────────────────────
 
 /**
@@ -591,7 +643,16 @@ function loadEvolutionQueue(yaml) {
     if (!fs.existsSync(EVOLUTION_QUEUE_FILE)) return { items: [] };
     const content = fs.readFileSync(EVOLUTION_QUEUE_FILE, 'utf8');
     const data = yaml.load(content);
-    return data && Array.isArray(data.items) ? data : { items: [] };
+    const queue = data && Array.isArray(data.items) ? data : { items: [] };
+    let changed = false;
+    for (const item of queue.items) {
+      if (!item.id) {
+        item.id = `q-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+        changed = true;
+      }
+    }
+    if (changed) saveEvolutionQueue(yaml, queue);
+    return queue;
   } catch {
     return { items: [] };
   }
@@ -604,18 +665,24 @@ function saveEvolutionQueue(yaml, queue) {
 }
 
 function addToQueue(queue, entry) {
-  // Dedup by type + skill_name (update existing instead of adding duplicate)
+  // Dedup pending entries by core key. Skill gaps also include search_hint so unrelated gaps don't collapse.
   const existing = queue.items.find(i =>
-    i.type === entry.type && i.skill_name === entry.skill_name && i.status === 'pending'
+    i.type === entry.type &&
+    i.skill_name === entry.skill_name &&
+    i.status === 'pending' &&
+    (entry.type !== 'skill_gap' || (i.search_hint || '') === (entry.search_hint || ''))
   );
 
   if (existing) {
     existing.evidence_count = (existing.evidence_count || 0) + (entry.evidence_count || 1);
     existing.last_seen = new Date().toISOString();
+    if (entry.reason) existing.reason = entry.reason;
+    if (entry.search_hint) existing.search_hint = entry.search_hint;
     return;
   }
 
   queue.items.push({
+    id: `q-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
     ...entry,
     detected: new Date().toISOString(),
     last_seen: new Date().toISOString(),
@@ -639,13 +706,11 @@ function checkEvolutionQueue() {
 
   const queue = loadEvolutionQueue(yaml);
   const pendingItems = queue.items.filter(i => i.status === 'pending');
-  if (pendingItems.length === 0) return [];
-
   const notifications = [];
+  const policy = loadPolicy();
 
   for (const item of pendingItems) {
     // Require minimum evidence before notifying
-    const policy = loadPolicy();
     const minEvidence = item.type === 'skill_gap' ? policy.min_evidence_for_gap : policy.min_evidence_for_update;
     if ((item.evidence_count || 1) < minEvidence) continue;
 
@@ -655,13 +720,14 @@ function checkEvolutionQueue() {
   }
 
   // Prune old resolved items (> 30 days)
+  const beforeLen = queue.items.length;
   const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000;
   queue.items = queue.items.filter(i =>
     i.status === 'pending' || i.status === 'notified' ||
     (new Date(i.last_seen || i.detected).getTime() > cutoff)
   );
 
-  if (notifications.length > 0) {
+  if (notifications.length > 0 || queue.items.length !== beforeLen) {
     saveEvolutionQueue(yaml, queue);
   }
 
@@ -687,6 +753,42 @@ function resolveQueueItem(type, skillName, resolution) {
   }
 }
 
+/**
+ * Mark queue item resolved by queue id.
+ * Returns true when updated.
+ */
+function resolveQueueItemById(id, resolution) {
+  let yaml;
+  try { yaml = require('js-yaml'); } catch { return false; }
+  if (!id) return false;
+
+  const queue = loadEvolutionQueue(yaml);
+  const item = queue.items.find(i =>
+    i.id === id && (i.status === 'pending' || i.status === 'notified')
+  );
+  if (!item) return false;
+
+  item.status = resolution; // 'installed' | 'dismissed'
+  item.resolved_at = new Date().toISOString();
+  saveEvolutionQueue(yaml, queue);
+  return true;
+}
+
+/**
+ * List queue items for manual triage.
+ */
+function listQueueItems({ status = null, limit = 20 } = {}) {
+  let yaml;
+  try { yaml = require('js-yaml'); } catch { return []; }
+  const queue = loadEvolutionQueue(yaml);
+  const items = Array.isArray(queue.items) ? queue.items : [];
+  const filtered = status ? items.filter(i => i.status === status) : items;
+  return filtered
+    .slice()
+    .sort((a, b) => new Date(b.last_seen || b.detected || 0).getTime() - new Date(a.last_seen || a.detected || 0).getTime())
+    .slice(0, Math.max(1, limit));
+}
+
 // ─────────────────────────────────────────────
 // Evolution.json Merge (JS port of merge_evolution.py)
 // ─────────────────────────────────────────────
@@ -726,8 +828,11 @@ function smartStitch(skillDir) {
   try { data = JSON.parse(fs.readFileSync(evoPath, 'utf8')); } catch { return; }
 
   // Build evolution section
+  const AUTO_START = '<!-- METAME-EVOLUTION:START -->';
+  const AUTO_END = '<!-- METAME-EVOLUTION:END -->';
   const sections = [];
-  sections.push('\n\n## User-Learned Best Practices & Constraints');
+  sections.push(`\n\n${AUTO_START}`);
+  sections.push('\n## User-Learned Best Practices & Constraints');
   sections.push('\n> **Auto-Generated Section**: Maintained by skill-evolution-manager. Do not edit manually.');
 
   // Helper: get quality indicator for an insight based on stats
@@ -755,13 +860,17 @@ function smartStitch(skillDir) {
     sections.push(`\n${data.custom_prompts}`);
   }
 
+  sections.push(`\n${AUTO_END}\n`);
   const evolutionBlock = sections.join('\n');
 
   let content = fs.readFileSync(skillMdPath, 'utf8');
-  const pattern = /(\n+## User-Learned Best Practices & Constraints[\s\S]*$)/;
+  const markerPattern = new RegExp(`${AUTO_START}[\\s\\S]*?${AUTO_END}\\n?`);
+  const legacyPattern = /\n+## User-Learned Best Practices & Constraints[\s\S]*?(?=\n##\s+|\n#\s+|$)/;
 
-  if (pattern.test(content)) {
-    content = content.replace(pattern, evolutionBlock);
+  if (markerPattern.test(content)) {
+    content = content.replace(markerPattern, evolutionBlock.trimStart());
+  } else if (legacyPattern.test(content)) {
+    content = content.replace(legacyPattern, evolutionBlock);
   } else {
     content = content + evolutionBlock;
   }
@@ -827,6 +936,8 @@ module.exports = {
   distillSkills,
   checkEvolutionQueue,
   resolveQueueItem,
+  resolveQueueItemById,
+  listQueueItems,
   mergeEvolution,
   smartStitch,
   trackInsightOutcome,

package/scripts/skill-evolution.test.js

@@ -0,0 +1,107 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const yaml = require('js-yaml');
+
+const ROOT = path.resolve(__dirname, '..');
+
+function mkHome() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'metame-skill-evo-'));
+}
+
+function runWithHome(home, code) {
+  return execFileSync(process.execPath, ['-e', code], {
+    cwd: ROOT,
+    env: { ...process.env, HOME: home },
+    encoding: 'utf8',
+  });
+}
+
+test('captures missing-skill failures into skill_gap queue', () => {
+  const home = mkHome();
+  runWithHome(home, `
+    const se = require('./scripts/skill-evolution');
+    const s = se.extractSkillSignal('帮我做封面图', 'Error: skill not found: nano-banana', null, [], process.cwd(), []);
+    se.appendSkillSignal(s);
+    se.checkHotEvolution(s);
+  `);
+
+  const queuePath = path.join(home, '.metame', 'evolution_queue.yaml');
+  const queue = yaml.load(fs.readFileSync(queuePath, 'utf8'));
+  assert.equal(Array.isArray(queue.items), true);
+  assert.equal(queue.items.length, 1);
+  assert.equal(queue.items[0].type, 'skill_gap');
+  assert.equal(queue.items[0].status, 'pending');
+  assert.ok(queue.items[0].id);
+});
+
+test('resolves queue item by id', () => {
+  const home = mkHome();
+  runWithHome(home, `
+    const se = require('./scripts/skill-evolution');
+    const s = se.extractSkillSignal('帮我做封面图', 'Error: skill not found: nano-banana', null, [], process.cwd(), []);
+    se.appendSkillSignal(s);
+    se.checkHotEvolution(s);
+    const items = se.listQueueItems({ status: 'pending', limit: 5 });
+    if (!items[0]) throw new Error('no pending queue item');
+    const ok = se.resolveQueueItemById(items[0].id, 'installed');
+    if (!ok) throw new Error('resolveQueueItemById returned false');
+  `);
+
+  const queuePath = path.join(home, '.metame', 'evolution_queue.yaml');
+  const queue = yaml.load(fs.readFileSync(queuePath, 'utf8'));
+  assert.equal(queue.items.length, 1);
+  assert.equal(queue.items[0].status, 'installed');
+});
+
+test('smartStitch preserves sections after evolution block', () => {
+  const home = mkHome();
+  runWithHome(home, `
+    const fs = require('fs');
+    const path = require('path');
+    const se = require('./scripts/skill-evolution');
+    const dir = path.join(process.env.HOME, 'sample-skill');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'SKILL.md'), '# Demo\\n\\nBody\\n\\n## User-Learned Best Practices & Constraints\\nOld\\n\\n## KeepMe\\nKeep this section\\n');
+    fs.writeFileSync(path.join(dir, 'evolution.json'), JSON.stringify({ preferences: ['prefer concise output'] }, null, 2));
+    se.smartStitch(dir);
+  `);
+
+  const content = fs.readFileSync(path.join(home, 'sample-skill', 'SKILL.md'), 'utf8');
+  assert.match(content, /METAME-EVOLUTION:START/);
+  assert.match(content, /prefer concise output/);
+  assert.match(content, /## KeepMe/);
+  assert.match(content, /Keep this section/);
+});
+
+test('trackInsightOutcome updates only matched insights', () => {
+  const home = mkHome();
+  runWithHome(home, `
+    const fs = require('fs');
+    const path = require('path');
+    const se = require('./scripts/skill-evolution');
+    const dir = path.join(process.env.HOME, '.claude', 'skills', 'demo-skill');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'SKILL.md'), '# Demo');
+    fs.writeFileSync(path.join(dir, 'evolution.json'), JSON.stringify({
+      preferences: ['alpha_mode'],
+      fixes: ['beta_mode']
+    }, null, 2));
+    se.trackInsightOutcome(dir, true, {
+      prompt: 'please use alpha_mode',
+      error: '',
+      output_excerpt: '',
+      tools_used: [],
+      files_modified: []
+    });
+  `);
+
+  const evo = JSON.parse(fs.readFileSync(path.join(home, '.claude', 'skills', 'demo-skill', 'evolution.json'), 'utf8'));
+  assert.equal(typeof evo.insights_stats, 'object');
+  assert.ok(evo.insights_stats.alpha_mode);
+  assert.equal(evo.insights_stats.alpha_mode.success_count, 1);
+  assert.equal(evo.insights_stats.beta_mode, undefined);
+});