metame-cli 1.5.10 → 1.5.12

package/scripts/hooks/intent-perpetual.js

@@ -0,0 +1,109 @@
+'use strict';
+
+/**
+ * Perpetual Task Intent Module
+ *
+ * Detects when the user wants to interact with perpetual/reactive projects
+ * (start research, check progress, manage missions, dispatch to agents).
+ *
+ * HIGH PRECISION: Only fires on explicit perpetual task verbs + target patterns.
+ * Will NOT fire on casual mentions of "研究" in conversational context.
+ *
+ * @param {string} prompt
+ * @param {object} config - daemon.yaml config
+ * @param {string} projectKey - current project key
+ * @returns {string|null}
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// ── Intent patterns ──
+// Each pattern requires BOTH a verb AND a target/context to fire.
+// Single words like "研究" alone will NOT trigger — must be paired with action.
+
+const PERPETUAL_INTENTS = [
+  {
+    // Direct "永续任务" / "perpetual task" / "长期任务" — highest confidence, no verb needed
+    pattern: /永续任务|永续.{0,5}(研究|课题|项目)|perpetual.{0,5}task|长期任务|long.?term.{0,5}(task|mission)/i,
+    hint: (config) => {
+      const bin = path.join(os.homedir(), '.metame', 'bin', 'dispatch_to');
+      const reactive = getReactiveProjects(config);
+      if (reactive.length === 0) return '[永续任务] 暂无 reactive 项目。在 daemon.yaml 中添加 `reactive: true` 配置。';
+      const targets = reactive.map(r => `  ${r.icon} **${r.name}** → \`${bin} ${r.key} "你的任务描述"\``).join('\n');
+      return [
+        '[永续任务系统]',
+        `可用项目:\n${targets}`,
+        '命令: `/status perpetual` 查看进度 | `dispatch_to <key> "任务"` 启动',
+        'Agent 内部用 NEXT_DISPATCH 派发子任务，MISSION_COMPLETE 结束任务。',
+      ].join('\n');
+    },
+  },
+  {
+    // User wants to start/launch a perpetual research mission
+    // Requires action verb + research/mission target
+    pattern: /(开始|启动|开启|launch|start|kick off).{0,15}(研究|课题|实验|mission|research|调研)/i,
+    hint: (config) => {
+      const bin = path.join(os.homedir(), '.metame', 'bin', 'dispatch_to');
+      const reactive = getReactiveProjects(config);
+      if (reactive.length === 0) return null;
+      const targets = reactive.map(r => `  \`${bin} ${r.key} "开始任务"\``).join('\n');
+      return `[永续任务] 启动命令:\n${targets}\n或在 agent 内部用 NEXT_DISPATCH 指令派发子任务。`;
+    },
+  },
+  {
+    // User wants to check perpetual project progress
+    pattern: /(查看|看看|检查|check).{0,10}(进度|进展|状态|progress|status).{0,10}(研究|课题|永续|perpetual|reactive)?/i,
+    hint: () => '[永续任务] `/status perpetual` 查看所有永续项目进度',
+  },
+  {
+    // User wants to see the topic/mission pool
+    pattern: /(课题|任务|mission|topic).{0,8}(池|pool|列表|list|队列|queue)/i,
+    hint: () => '[永续任务] 查看任务队列: `cat workspace/topics.md`\n管理: `node scripts/topic-pool.js list`',
+  },
+  {
+    // User wants to pause/stop a perpetual project
+    pattern: /(暂停|停止|pause|stop).{0,15}(研究|科研|课题|永续|perpetual|reactive)/i,
+    hint: () => '[永续任务] 暂停方式:\n- Budget/depth 超限自动暂停\n- 或手动设置 `daemon_state.json` 中 `reactive.<key>.status = "paused"`',
+  },
+  {
+    // User asks about event log or progress history
+    pattern: /(事件|event).{0,5}(日志|log)|progress\.tsv|进度日志/i,
+    hint: () => '[永续任务] 事件日志: `tail ~/.metame/events/<project>.jsonl`\n进度表: `cat workspace/progress.tsv`',
+  },
+];
+
+function getReactiveProjects(config) {
+  if (!config || !config.projects) return [];
+  return Object.entries(config.projects)
+    .filter(([, proj]) => proj && proj.reactive)
+    .map(([key, proj]) => ({ key, name: proj.name || key, icon: proj.icon || '' }));
+}
+
+// Negative patterns: these look like perpetual intent but are actually
+// one-shot skills (deep-research, casual mention, etc.)
+const NEGATIVE_PATTERNS = [
+  /深度研究|深度调研|deep.?research|调研.{0,5}(一下|下|看看)/i,  // deep-research skill
+  /研究.{0,5}(一下|下|看看|这个|那个|怎么)/i,                     // casual "look into this" (Chinese)
+  /\bresearch\b.{0,5}\b(this|it|that|the|how|what|why)\b/i,    // casual "research this/how" (English)
+  /搜索|搜一下|查一下|google/i,                                  // web search (not English "search" alone)
+];
+
+module.exports = function detectPerpetual(prompt, config) {
+  const text = String(prompt || '').trim();
+  if (!text) return null;
+
+  // Bail early if text matches a negative pattern (one-shot, not perpetual)
+  if (NEGATIVE_PATTERNS.some(re => re.test(text))) return null;
+
+  const hints = [];
+  for (const intent of PERPETUAL_INTENTS) {
+    if (intent.pattern.test(text)) {
+      const h = typeof intent.hint === 'function' ? intent.hint(config) : intent.hint;
+      if (h) hints.push(h);
+    }
+  }
+
+  return hints.length > 0 ? hints.join('\n') : null;
+};

package/scripts/hooks/intent-research.js

@@ -0,0 +1,112 @@
+'use strict';
+
+/**
+ * Research Intent Module — 科研场景按需注入
+ *
+ * 仅在用户/agent 涉及科研操作时注入对应提示：
+ *   - 文献调研 → 注入调研方法论
+ *   - 实验设计 → 注入实验规范
+ *   - 论文写作 → 注入写作标准
+ *   - 任务推进 → 注入永续循环协议
+ *   - 数据分析 → 注入数据溯源规则
+ *
+ * 只对 paper_rev 项目生效。
+ *
+ * @param {string} prompt
+ * @param {object} config
+ * @param {string} projectKey
+ * @returns {string|null}
+ */
+
+const RESEARCH_INTENTS = [
+  {
+    // 文献调研
+    pattern: /文献|调研|literature|survey|paper|论文.{0,5}(搜|找|查)|state.of.the.art|相关工作|related work/i,
+    hint: [
+      '[研究方法：文献调研]',
+      '1. WebSearch 搜索最新论文（限近3年，关注顶刊 CACAIE/ASCE/CMAME）',
+      '2. 每篇记录：标题、方法、数据集、核心发现、与本研究的关联',
+      '3. 产出写入 workspace/literature/<topic>.md',
+      '4. 识别 research gap 后更新 workspace/research-state.md',
+    ].join('\n'),
+  },
+  {
+    // 算法设计/实验设计
+    pattern: /算法|设计|design|实验方案|experiment|PINNs?|Bayesian|贝叶斯|POD|DMD|强化学习|reinforcement|EnKF|降阶/i,
+    hint: [
+      '[研究方法：算法设计]',
+      '1. 先确认相关文献调研已完成（查 workspace/literature/）',
+      '2. 设计写入 workspace/experiments/<name>/design.md',
+      '3. 明确：输入数据、模型架构、损失函数、评价指标、baseline 对比方案',
+      '4. 如需 FEM 数据支持，NEXT_DISPATCH: fem_sim "任务描述"',
+    ].join('\n'),
+  },
+  {
+    // 代码实现
+    pattern: /代码|编写|实现|implement|coding|训练|training|PyTorch|TensorFlow|numpy|脚本/i,
+    hint: [
+      '[研究方法：代码实现]',
+      '1. 代码写入 workspace/experiments/<name>/ 目录',
+      '2. 试验数据引用: fem-workspace/experimental_data.csv, optimization_history.csv',
+      '3. 运行后记录结果到 workspace/experiments/<name>/results.md',
+      '4. 所有数值必须可溯源，不编造结果',
+    ].join('\n'),
+  },
+  {
+    // 论文撰写
+    pattern: /撰写|写作|draft|论文.{0,3}(写|改|稿)|manuscript|章节|section|abstract|introduction|conclusion/i,
+    hint: [
+      '[研究方法：论文撰写]',
+      '目标期刊: Computer-Aided Civil and Infrastructure Engineering (CACAIE)',
+      '写作规范: 被动语态适度、hedging language、术语一致、每段有 topic sentence',
+      '产出写入 workspace/drafts/<section>.md',
+    ].join('\n'),
+  },
+  {
+    // 任务推进/永续循环
+    pattern: /任务|mission|下一步|next|推进|继续|开始|start|进度|progress|REVISION_COMPLETE/i,
+    hint: [
+      '[永续研究循环协议]',
+      '1. 读 workspace/missions.md 取最高优先级 pending 任务',
+      '2. 读 workspace/research-state.md 了解当前进度',
+      '3. 执行任务，产出写入对应 workspace/ 子目录',
+      '4. 更新 research-state.md 记录进展',
+      '5. 发现新问题 → 编辑 missions.md 追加 pending',
+      '6. 完成 → 输出 REVISION_COMPLETE',
+      '7. 派发 FEM 任务 → NEXT_DISPATCH: fem_sim "描述"',
+    ].join('\n'),
+  },
+  {
+    // 数据分析
+    pattern: /数据|分析|analyze|对比|比较|benchmark|baseline|性能|结果|results|R²|RMSE|score/i,
+    hint: [
+      '[研究方法：数据分析]',
+      'Baseline: SGDE 框架 multi-objective score=0.9685, R²=0.9642',
+      '可用数据源: fem-workspace/ 下所有 CSV 和 optimization_results/',
+      '分析结果写入对应实验目录的 results.md',
+    ].join('\n'),
+  },
+];
+
+// 负面模式：排除日常对话
+const NEGATIVE = [
+  /你好|谢谢|OK|好的|收到/i,
+];
+
+module.exports = function detectResearch(prompt, config, projectKey) {
+  // 只对 paper_rev 项目生效
+  if (projectKey && projectKey !== 'paper_rev') return null;
+
+  const text = String(prompt || '').trim();
+  if (!text || text.length < 4) return null;
+  if (NEGATIVE.some(re => re.test(text) && text.length < 10)) return null;
+
+  const hints = [];
+  for (const intent of RESEARCH_INTENTS) {
+    if (intent.pattern.test(text)) {
+      hints.push(intent.hint);
+    }
+  }
+
+  return hints.length > 0 ? hints.join('\n\n') : null;
+};

package/scripts/intent-registry.js

@@ -14,6 +14,8 @@ const DEFAULTS = Object.freeze({
   file_transfer: true,
   memory_recall: true,
   doc_router: true,
+  perpetual: true,
+  research: true,
 });
 
 const INTENT_MODULES = Object.freeze({
@@ -23,6 +25,8 @@ const INTENT_MODULES = Object.freeze({
   file_transfer: require('./hooks/intent-file-transfer'),
   memory_recall: require('./hooks/intent-memory-recall'),
   doc_router: require('./hooks/intent-doc-router'),
+  perpetual: require('./hooks/intent-perpetual'),
+  research: require('./hooks/intent-research'),
 });
 
 function resolveEnabledIntents(config = {}) {

package/scripts/memory-extract.js

@@ -74,6 +74,7 @@ const SESSION_TAGS_FILE = path.join(os.homedir(), '.metame', 'session_tags.json'
 
 /**
  * Persist session name and derived tags to ~/.metame/session_tags.json.
+ * Consumed by /sessions and /resume commands for friendly display titles.
  * Merges into existing file — never overwrites existing entries.
  */
 function saveSessionTag(sessionId, sessionName, facts) {
@@ -337,6 +338,19 @@ async function run() {
 
         sessionAnalytics.markFactsExtracted(skeleton.session_id);
 
+        // Persist session summary to memory.db sessions table (makes sessions searchable)
+        try {
+          const keywords = facts.flatMap(f => Array.isArray(f.tags) ? f.tags : [])
+            .filter((v, i, a) => a.indexOf(v) === i).slice(0, 10).join(',');
+          memory.saveSession({
+            sessionId: skeleton.session_id,
+            project: skeleton.project || 'unknown',
+            scope: skeleton.project_id || null,
+            summary: `[${session_name}] ${facts.map(f => f.value).join(' | ').slice(0, 2000)}`,
+            keywords,
+          });
+        } catch { /* non-fatal — facts already saved, session is bonus */ }
+
         // P2-A: persist session name + tags to session_tags.json
         saveSessionTag(skeleton.session_id, session_name, facts);
 
@@ -391,12 +405,26 @@ async function run() {
             const superMsg = superseded > 0 ? `, ${superseded} superseded` : '';
             const labelMsg = labelsSaved > 0 ? `, ${labelsSaved} labels` : '';
             console.log(`[memory-extract] Codex ${cs.session_id.slice(0, 8)} (${session_name}): ${saved} facts saved${superMsg}${labelMsg}`);
+
+            // Persist Codex session summary to memory.db sessions table
+            try {
+              const keywords = facts.flatMap(f => Array.isArray(f.tags) ? f.tags : [])
+                .filter((v, i, a) => a.indexOf(v) === i).slice(0, 10).join(',');
+              memory.saveSession({
+                sessionId: cs.session_id,
+                project: skeleton.project || 'unknown',
+                scope: skeleton.project_id || null,
+                summary: `[${session_name}] ${facts.map(f => f.value).join(' | ').slice(0, 2000)}`,
+                keywords,
+              });
+            } catch { /* non-fatal */ }
+
+            saveSessionTag(cs.session_id, session_name, facts);
           } else {
             console.log(`[memory-extract] Codex ${cs.session_id.slice(0, 8)} (${session_name}): no facts extracted`);
           }
 
           sessionAnalytics.markCodexFactsExtracted(cs.session_id);
-          saveSessionTag(cs.session_id, session_name, facts);
           processed++;
         } catch (e) {
           console.log(`[memory-extract] Codex session error: ${e.message}`);

package/scripts/memory-nightly-reflect.js

@@ -503,6 +503,109 @@ entity_prefix: ${group.prefix}
       try { if (memory && typeof memory.close === 'function') memory.close(); } catch { /* non-fatal */ }
     }
 
+    // ── Conflict Resolution ──────────────────────────────────────────────
+    // Query CONFLICT facts grouped by entity+relation, ask Haiku to pick winner.
+    // Loser is marked superseded_by winner; winner restored to OK.
+    let conflictsResolved = 0;
+    try {
+      const conflictGroups = db.prepare(`
+        SELECT entity, relation, COUNT(*) as cnt
+        FROM facts
+        WHERE conflict_status = 'CONFLICT' AND superseded_by IS NULL
+        GROUP BY entity, relation
+        HAVING cnt >= 2
+        ORDER BY cnt DESC
+        LIMIT 10
+      `).all();
+
+      if (conflictGroups.length > 0) {
+        console.log(`[NIGHTLY-REFLECT] Found ${conflictGroups.length} conflict group(s) to resolve.`);
+
+        // Collect all conflicting facts for these groups (batch to reduce queries)
+        const allConflicts = [];
+        for (const g of conflictGroups) {
+          const rows = db.prepare(`
+            SELECT id, entity, relation, value, confidence, created_at
+            FROM facts
+            WHERE entity = ? AND relation = ? AND conflict_status = 'CONFLICT' AND superseded_by IS NULL
+            ORDER BY created_at DESC
+          `).all(g.entity, g.relation);
+          if (rows.length >= 2) allConflicts.push({ entity: g.entity, relation: g.relation, facts: rows });
+        }
+
+        if (allConflicts.length > 0) {
+          // Limit to 5 groups to avoid truncating serialized JSON
+          const conflictInput = allConflicts.slice(0, 5).map(g => ({
+            entity: g.entity,
+            relation: g.relation,
+            candidates: g.facts.slice(0, 5).map(f => ({ id: f.id, value: f.value.slice(0, 150), confidence: f.confidence, created_at: f.created_at })),
+          }));
+
+          const resolvePrompt = `你是知识库冲突调解员。以下是同一 entity+relation 下的冲突事实，请选出每组最准确的一条保留。
+
+冲突组(JSON):
+${JSON.stringify(conflictInput, null, 2)}
+
+输出 JSON 数组，每个元素对应一组冲突的裁决：
+[
+  {
+    "entity": "...",
+    "relation": "...",
+    "winner_id": "保留的fact id",
+    "reason": "一句话理由"
+  }
+]
+
+规则：
+- 优先选最新（created_at）且 confidence=high 的
+- 如果旧条目更准确具体，选旧的
+- 只输出 JSON 数组`;
+
+          try {
+            const resolveRaw = await Promise.race([
+              callHaiku(resolvePrompt, distillEnv, 60000),
+              new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 65000)),
+            ]);
+            const verdicts = parseJsonFromLlm(resolveRaw);
+            if (Array.isArray(verdicts)) {
+              for (const v of verdicts) {
+                if (!v || !v.winner_id || !v.entity || !v.relation) continue;
+                // Validate winner exists in our conflict set
+                const group = allConflicts.find(g => g.entity === v.entity && g.relation === v.relation);
+                if (!group) continue;
+                const winnerExists = group.facts.some(f => f.id === v.winner_id);
+                if (!winnerExists) continue;
+
+                const loserIds = group.facts.filter(f => f.id !== v.winner_id).map(f => f.id);
+                if (loserIds.length === 0) continue;
+
+                // Mark losers as superseded
+                const placeholders = loserIds.map(() => '?').join(',');
+                db.prepare(
+                  `UPDATE facts SET superseded_by = ?, conflict_status = 'OK', updated_at = datetime('now')
+                   WHERE id IN (${placeholders})`
+                ).run(v.winner_id, ...loserIds);
+
+                // Restore winner
+                db.prepare(
+                  `UPDATE facts SET conflict_status = 'OK', updated_at = datetime('now') WHERE id = ?`
+                ).run(v.winner_id);
+
+                conflictsResolved += loserIds.length;
+              }
+              if (conflictsResolved > 0) {
+                console.log(`[NIGHTLY-REFLECT] Resolved ${conflictsResolved} conflicting fact(s).`);
+              }
+            }
+          } catch (e) {
+            console.log(`[NIGHTLY-REFLECT] Conflict resolution failed (non-fatal): ${e.message}`);
+          }
+        }
+      }
+    } catch (e) {
+      console.log(`[NIGHTLY-REFLECT] Conflict query failed (non-fatal): ${e.message}`);
+    }
+
     // Write audit log
     writeReflectLog({
       status: 'success',
@@ -510,6 +613,7 @@ entity_prefix: ${group.prefix}
       decisions_written: decisions.length,
       lessons_written: lessons.length,
       synthesized_insights_saved: synthesizedSaved,
+      conflicts_resolved: conflictsResolved,
       capsules_written: capsulesWritten,
       capsule_facts_saved: capsuleFactsSaved,
       decision_file: decisions.length > 0 ? decisionFile : null,

package/scripts/ops-mission-queue.js

@@ -0,0 +1,258 @@
+'use strict';
+
+/**
+ * MetaMe Ops mission queue.
+ * Same CLI interface as AgentScientist's topic-pool.js:
+ *   next | activate <id> | complete <id> | list | scan
+ *
+ * The 'scan' command is unique to ops: it reads daemon logs + event logs
+ * and generates fix missions automatically.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const MISSIONS_FILE = 'workspace/missions.md';
+const SECTIONS = ['pending', 'active', 'completed', 'abandoned'];
+const METAME_DIR = path.join(os.homedir(), '.metame');
+
+// ── Mission file parser (same format as topic-pool) ──────────
+
+function getMissionsPath(cwd) {
+  return path.join(cwd, MISSIONS_FILE);
+}
+
+function parseMission(line) {
+  const m = line.match(/^-\s*\[([^\]]+)\]\s*(.+)$/);
+  if (!m) return null;
+  const id = m[1].trim();
+  let rest = m[2].trim();
+  let priority = 999;
+  const pm = rest.match(/\(priority:\s*(\d+)\)\s*$/);
+  if (pm) {
+    priority = parseInt(pm[1], 10);
+    rest = rest.slice(0, pm.index).trim();
+  }
+  return { id, title: rest, priority };
+}
+
+function parseMissionsFile(content) {
+  const sections = { pending: [], active: [], completed: [], abandoned: [] };
+  let current = null;
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    const secMatch = trimmed.match(/^##\s+(pending|active|completed|abandoned)\s*$/);
+    if (secMatch) { current = secMatch[1]; continue; }
+    if (current && trimmed.startsWith('- [')) {
+      const mission = parseMission(trimmed);
+      if (mission) { mission.status = current; sections[current].push(mission); }
+    }
+  }
+  return sections;
+}
+
+function formatMissions(sections) {
+  const lines = ['# MetaMe Ops Missions', ''];
+  for (const sec of SECTIONS) {
+    lines.push(`## ${sec}`);
+    for (const t of (sections[sec] || [])) {
+      lines.push(t.priority !== 999
+        ? `- [${t.id}] ${t.title} (priority: ${t.priority})`
+        : `- [${t.id}] ${t.title}`);
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+function readSections(cwd) {
+  const fp = getMissionsPath(cwd);
+  if (!fs.existsSync(fp)) return { pending: [], active: [], completed: [], abandoned: [] };
+  return parseMissionsFile(fs.readFileSync(fp, 'utf-8'));
+}
+
+function writeSections(cwd, sections) {
+  const fp = getMissionsPath(cwd);
+  fs.mkdirSync(path.dirname(fp), { recursive: true });
+  fs.writeFileSync(fp, formatMissions(sections), 'utf-8');
+}
+
+function findMission(sections, id) {
+  for (const sec of SECTIONS) {
+    const idx = (sections[sec] || []).findIndex(t => t.id === id);
+    if (idx !== -1) return { section: sec, index: idx, topic: sections[sec][idx] };
+  }
+  return null;
+}
+
+// ── Standard queue commands ──────────────────────────────────
+
+function nextMission(cwd) {
+  const sections = readSections(cwd);
+  if (sections.active.length > 0) {
+    return { success: false, message: `already active: ${sections.active[0].id}` };
+  }
+  if (sections.pending.length === 0) return { success: false, message: 'no pending missions' };
+  const sorted = [...sections.pending].sort((a, b) => a.priority - b.priority);
+  return { success: true, topic: { id: sorted[0].id, title: sorted[0].title, status: 'pending', priority: sorted[0].priority } };
+}
+
+function activateMission(cwd, id) {
+  const sections = readSections(cwd);
+  const found = findMission(sections, id);
+  if (!found) return { success: false, message: `not found: ${id}` };
+  if (found.section !== 'pending') return { success: false, message: `${id} is ${found.section}` };
+  const mission = sections.pending.splice(found.index, 1)[0];
+  mission.status = 'active';
+  sections.active.push(mission);
+  writeSections(cwd, sections);
+  return { success: true, topic: { id: mission.id, title: mission.title, status: 'active' } };
+}
+
+function completeMission(cwd, id) {
+  const sections = readSections(cwd);
+  const found = findMission(sections, id);
+  if (!found) return { success: false, message: `not found: ${id}` };
+  if (found.section !== 'active') return { success: false, message: `${id} is ${found.section}` };
+  const mission = sections.active.splice(found.index, 1)[0];
+  mission.status = 'completed';
+  sections.completed.push(mission);
+  writeSections(cwd, sections);
+  return { success: true, topic: { id: mission.id, title: mission.title, status: 'completed' } };
+}
+
+function listMissions(cwd) {
+  const sections = readSections(cwd);
+  const topics = [];
+  for (const sec of SECTIONS) {
+    for (const t of (sections[sec] || [])) topics.push({ id: t.id, title: t.title, status: sec, priority: t.priority });
+  }
+  return { success: true, topics };
+}
+
+// ── Log scanner: generates missions from error patterns ──────
+
+function scanLogs(cwd) {
+  const sections = readSections(cwd);
+  const existingTitles = new Set(
+    [...sections.pending, ...sections.active, ...sections.completed, ...sections.abandoned].map(t => t.title)
+  );
+
+  const newMissions = [];
+  const now = Date.now();
+  const ONE_DAY = 24 * 60 * 60 * 1000;
+
+  // 1. Scan daemon log for repeated errors
+  const logPath = path.join(METAME_DIR, 'daemon.log');
+  if (fs.existsSync(logPath)) {
+    try {
+      const content = fs.readFileSync(logPath, 'utf8');
+      const lines = content.split('\n');
+      // Only look at recent lines (last 500)
+      const recent = lines.slice(-500);
+      const errorCounts = {};
+      for (const line of recent) {
+        if (!/\bERR\b|\bWARN\b|\bError\b|\bfailed\b/i.test(line)) continue;
+        // Normalize: strip timestamps and variable data
+        const normalized = line
+          .replace(/\d{4}-\d{2}-\d{2}T[\d:.]+Z?/g, '<TS>')
+          .replace(/\d{10,}/g, '<ID>')
+          .replace(/\/tmp\/[^\s]+/g, '<TMP>')
+          .trim();
+        if (normalized.length < 20) continue;
+        const key = normalized.slice(0, 120);
+        errorCounts[key] = (errorCounts[key] || 0) + 1;
+      }
+
+      // Generate missions for errors occurring 3+ times
+      // Dedup key is the pattern alone (not the count, which changes every scan)
+      for (const [pattern, count] of Object.entries(errorCounts)) {
+        if (count < 3) continue;
+        const dedupKey = `Fix recurring error: ${pattern.slice(0, 80)}`;
+        if (existingTitles.has(dedupKey)) continue;
+        // Use stable dedup key as title (count excluded to prevent duplicates)
+        newMissions.push({ title: dedupKey, priority: Math.max(1, 10 - count) });
+      }
+    } catch { /* skip unreadable log */ }
+  }
+
+  // 2. Scan event logs for stuck/stale projects
+  const eventsDir = path.join(METAME_DIR, 'events');
+  if (fs.existsSync(eventsDir)) {
+    try {
+      const evFiles = fs.readdirSync(eventsDir).filter(f => f.endsWith('.jsonl'));
+      for (const f of evFiles) {
+        const fp = path.join(eventsDir, f);
+        const projectKey = path.basename(f, '.jsonl');
+        try {
+          const stat = fs.statSync(fp);
+          const staleHours = (now - stat.mtimeMs) / (60 * 60 * 1000);
+          // If event log wasn't updated in 48h but project is supposed to be active
+          if (staleHours > 48) {
+            // Stable dedup key: project name only (not hours, which changes every scan)
+            const title = `Investigate stale project: ${projectKey}`;
+            if (!existingTitles.has(title)) {
+              newMissions.push({ title, priority: 5 });
+            }
+          }
+        } catch { /* skip */ }
+      }
+    } catch { /* skip */ }
+  }
+
+  // 3. Check test health
+  try {
+    const testFiles = fs.readdirSync(path.join(cwd, 'scripts'))
+      .filter(f => f.endsWith('.test.js'));
+    for (const tf of testFiles) {
+      try {
+        execSyncSafe(`node --test scripts/${tf}`, cwd, 30000);
+      } catch (e) {
+        const title = `Fix failing tests in ${tf}`;
+        if (!existingTitles.has(title)) {
+          newMissions.push({ title, priority: 1 });
+        }
+      }
+    }
+  } catch { /* skip */ }
+
+  // Add new missions to pending
+  if (newMissions.length > 0) {
+    const date = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+    let counter = sections.pending.length + sections.active.length + sections.completed.length + sections.abandoned.length + 1;
+    for (const m of newMissions) {
+      const id = `ops-${date}-${String(counter++).padStart(3, '0')}`;
+      sections.pending.push({ id, title: m.title, priority: m.priority, status: 'pending' });
+    }
+    writeSections(cwd, sections);
+  }
+
+  return { success: true, scanned: true, new_missions: newMissions.length, total_pending: sections.pending.length };
+}
+
+function execSyncSafe(cmd, cwd, timeout) {
+  const { execSync } = require('child_process');
+  return execSync(cmd, { cwd, timeout, encoding: 'utf8', stdio: 'pipe' });
+}
+
+// ── CLI ──────────────────────────────────────────────────────
+
+if (require.main === module) {
+  const cwd = process.env.MISSION_CWD || process.cwd();
+  const [,, command, ...args] = process.argv;
+
+  let result;
+  switch (command) {
+    case 'next':     result = nextMission(cwd); break;
+    case 'activate': result = args[0] ? activateMission(cwd, args[0]) : { success: false, message: 'usage: activate <id>' }; break;
+    case 'complete': result = args[0] ? completeMission(cwd, args[0]) : { success: false, message: 'usage: complete <id>' }; break;
+    case 'list':     result = listMissions(cwd); break;
+    case 'scan':     result = scanLogs(cwd); break;
+    default:         result = { success: false, message: `unknown: ${command}. Available: next, activate, complete, list, scan` };
+  }
+
+  process.stdout.write(JSON.stringify(result) + '\n');
+}
+
+module.exports = { nextMission, activateMission, completeMission, listMissions, scanLogs };