metame-cli 1.4.15 → 1.4.17

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.4.15",
+    "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-claude-engine.js

@@ -42,13 +42,6 @@ function createClaudeEngine(deps) {
   const SESSION_CWD_VALIDATION_TTL_MS = 30 * 1000;
   const _sessionCwdValidationCache = new Map(); // key: `${sessionId}@@${cwd}` -> { inCwd, ts }
 
-  function decodeProjectDirName(dirName) {
-    const raw = String(dirName || '');
-    if (!raw) return '';
-    if (raw.startsWith('-')) return '/' + raw.slice(1).replace(/-/g, '/');
-    return raw.replace(/-/g, '/');
-  }
-
   function cacheSessionCwdValidation(cacheKey, inCwd) {
     _sessionCwdValidationCache.set(cacheKey, { inCwd: !!inCwd, ts: Date.now() });
     if (_sessionCwdValidationCache.size > 512) {
@@ -84,14 +77,23 @@ function createClaudeEngine(deps) {
           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);
+          }
         }
 
-        // Fallback: infer from encoded Claude project folder name.
-        const inferredPath = decodeProjectDirName(path.basename(projectDir));
-        if (inferredPath) {
-          return cacheSessionCwdValidation(cacheKey, normalizeCwd(inferredPath) === 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);
         }
-        return cacheSessionCwdValidation(cacheKey, false);
+        // Unable to prove mismatch safely.
+        return cacheSessionCwdValidation(cacheKey, true);
       }
 
       // Ultimate fallback (legacy path): scoped scan in target cwd.

package/scripts/daemon-command-router.js

@@ -339,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'}]`,
         '',
         '直接打字即可对话 💬',

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) {
@@ -1031,6 +1033,7 @@ const { handleAdminCommand } = createAdminCommandHandler({
   getAllTasks,
   dispatchTask,
   log,
+  skillEvolution,
 });
 
 const { handleSessionCommand } = createSessionCommandHandler({

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);
+});