metame-cli 1.5.11 → 1.5.12

package/scripts/daemon-team-dispatch.js

@@ -274,15 +274,31 @@ function buildEnrichedPrompt(target, rawPrompt, metameDir, opts = {}) {
     } catch { /* non-critical */ }
   }
 
-  // 3. Target's last output
+  // 3+5. Structured memory (L1+L2) OR legacy _latest.md fallback
+  //       Single stat — structured memory supersedes raw last output
+  let hasStructuredMemory = false;
   try {
-    const latestFile = path.join(base, 'memory', 'agents', `${target}_latest.md`);
-    if (fs.existsSync(latestFile)) {
-      const content = fs.readFileSync(latestFile, 'utf8').trim();
-      if (content) ctx += `[${target} 上次产出]\n${content}\n\n`;
+    const memFile = path.join(base, 'memory', 'now', `${target}_memory.md`);
+    if (fs.existsSync(memFile)) {
+      const content = fs.readFileSync(memFile, 'utf8').trim();
+      if (content) {
+        ctx += `[Memory Context]\n${content}\n\n`;
+        hasStructuredMemory = true;
+      }
     }
   } catch { /* non-critical */ }
 
+  if (!hasStructuredMemory) {
+    // Fallback: raw last output (for non-reactive projects without memory system)
+    try {
+      const latestFile = path.join(base, 'memory', 'agents', `${target}_latest.md`);
+      if (fs.existsSync(latestFile)) {
+        const content = fs.readFileSync(latestFile, 'utf8').trim();
+        if (content) ctx += `[${target} 上次产出]\n${content}\n\n`;
+      }
+    } catch { /* non-critical */ }
+  }
+
   // 4. Inbox unread messages (archive after reading)
   try {
     const inboxDir = path.join(base, 'memory', 'inbox', target);

package/scripts/daemon-utils.js

@@ -9,7 +9,9 @@
 
 function normalizeEngineName(name, defaultEngine = 'claude') {
   const n = String(name || '').trim().toLowerCase();
-  return n === 'codex' ? 'codex' : (typeof defaultEngine === 'function' ? defaultEngine() : defaultEngine);
+  if (n === 'codex') return 'codex';
+  if (n === 'claude') return 'claude';
+  return typeof defaultEngine === 'function' ? defaultEngine() : defaultEngine;
 }
 
 function normalizeCodexSandboxMode(value, fallback = null) {

package/scripts/daemon.js

@@ -2352,6 +2352,7 @@ const { handleAgentCommand } = createAgentCommandHandler({
   writeConfigSafe,
   backupConfig,
   execSync,
+  log,
 });
 
 // Caffeinate process for /nosleep toggle (macOS only)

package/scripts/docs/file-transfer.md

@@ -30,3 +30,4 @@
 - **永远不要读取再复述文件内容**，直接用 `[[FILE:...]]` 标记发送
 - 路径必须是绝对路径
 - daemon 会自动解析标记并通过 bot 发送给用户
+- **⛔ 禁止发到 open_id**：即使系统上下文中存在用户的飞书 `ou_...` ID，也绝不用它发文件。`[[FILE:...]]` 会自动发到**当前对话群**，这才是正确行为。直接发 open_id 会导致文件出现在 bot 和用户的 1-on-1 私聊，而不在当前群里。

package/scripts/hooks/intent-file-transfer.js

@@ -35,9 +35,10 @@ module.exports = function detectFileTransfer(prompt) {
 
   if (isSend) {
     hints.push(
-      '- **发送文件到手机**：在回复末尾加 `[[FILE:/absolute/path]]`，daemon 自动发送',
+      '- **发送文件到手机**：在回复末尾加 `[[FILE:/absolute/path]]`，daemon 自动发到**当前对话群**',
       '- 多个文件用多个 `[[FILE:...]]` 标记',
       '- **不要读取文件内容再复述**，直接用标记发送（省 token）',
+      '- **⛔ 严禁发到 open_id**：即使上下文中有 `ou_...` 用户ID，也绝对不用它发文件——那会发到 bot 私聊而非当前群',
     );
   }
 

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/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 };