metame-cli 1.5.21 → 1.5.23

package/scripts/hooks/intent-doc-router.js

@@ -12,16 +12,18 @@
 
 const { createDocRoute } = require('./doc-router');
 
+const AGENT_DOC_PATTERNS = [
+  /(?:agent|智能体|机器人|bot).{0,12}(文档|手册|说明|guide)/i,
+  /(?:怎么|如何|手册|文档|说明).{0,12}(配置|管理|使用).{0,12}(agent|智能体|机器人|bot)/i,
+  /(?:agent|智能体|机器人|bot).{0,12}(怎么|如何).{0,12}(配置|管理|使用)/i,
+];
+
 const routes = [
   createDocRoute({
-    patterns: [
-      /(?:创建|新建|添加|注册|绑定|配置|管理).{0,8}(?:agent|机器人|bot|智能体)/i,
-      /(?:agent|bot|智能体).{0,8}(?:创建|新建|添加|注册|绑定|配置|管理)/i,
-      /\b(?:create|add|register|bind|manage|setup|configure)\s+(?:an?\s+)?agent\b/i,
-    ],
-    title: 'Agent 管理提示',
+    patterns: AGENT_DOC_PATTERNS,
+    title: 'Agent 文档提示',
     docPath: '~/.metame/docs/agent-guide.md',
-    summary: '创建/管理/绑定 Agent',
+    summary: 'Agent 配置/管理/使用说明',
   }),
   createDocRoute({
     patterns: [
@@ -34,8 +36,8 @@ const routes = [
   }),
   createDocRoute({
     patterns: [
-      /(?:hook|intent|意图).{0,10}(?:配置|设置|开关|新增|添加|修改|怎么配|怎么设置|怎么改)/i,
-      /(?:配置|设置|开关|新增|添加|修改).{0,10}(?:hook|intent|意图)/i,
+      /(?:hook|intent|意图).{0,10}(?:配置|设置|开关|新增|添加|修改|怎么配|怎么设置|怎么改|原理)/i,
+      /(?:配置|设置|开关|新增|添加|修改|原理).{0,10}(?:hook|intent|意图)/i,
       /intent.?engine/i,
       /意图引擎|意图模块/,
     ],
@@ -45,10 +47,20 @@ const routes = [
   }),
 ];
 
-module.exports = function detectDocRouter(prompt) {
+function hasExplicitDocIntent(prompt) {
+  const text = String(prompt || '').trim();
+  if (!text) return false;
+  return AGENT_DOC_PATTERNS.some((pattern) => pattern.test(text)) ||
+    /(?:文档|手册|说明|guide|readme)/i.test(text);
+}
+
+function detectDocRouter(prompt) {
   const hints = routes
     .map((detect) => detect(prompt))
     .filter(Boolean);
 
   return hints.length ? hints.join('\n') : null;
-};
+}
+
+module.exports = detectDocRouter;
+module.exports.hasExplicitDocIntent = hasExplicitDocIntent;

package/scripts/hooks/intent-memory-recall.js

@@ -17,8 +17,6 @@ const RECALL_PATTERNS = [
   /之前.{0,4}(?:说过|讨论过|聊过|提到过|商量过|做过的)/,
   // "还记得/记不记得" — asking if AI remembers (exclude "你记得" which is often imperative)
   /(?:还记得|记不记得|记得吗)/,
-  // "之前那个/上次那个" — referencing past artifacts
-  /(?:之前|上次|前几天)那个/,
   // English recall patterns
   /\b(?:last time|previously|remember when|do you remember|earlier we)\b/i,
 ];
@@ -31,6 +29,6 @@ module.exports = function detectMemoryRecall(prompt) {
     '- 搜索记忆: `node ~/.metame/memory-search.js "关键词1" "keyword2"`',
     '- 一次传 3-4 个关键词（中文+英文+函数名）',
     '- `--facts` 只搜事实，`--sessions` 只搜会话',
-    '- 统一召回: `require("./memory").assembleContext({ query, scope: { project, agent } })`',
+    '- 不要假设工作区里存在 `./memory` 模块；优先走 `memory-search.js` CLI 做召回',
   ].join('\n');
 };

package/scripts/hooks/intent-team-dispatch.js

@@ -4,7 +4,7 @@
  * Team Dispatch Intent Module
  *
  * Detects communication intent towards team members in the prompt.
- * Extracted from team-context.js — same logic, pure function interface.
+ * Daemon-side intent module for team dispatch hints.
  *
  * @param {string} prompt        - sanitized user prompt
  * @param {object} config        - daemon.yaml config

package/scripts/intent-registry.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const detectDocRouter = require('./hooks/intent-doc-router');
+
 /**
  * Shared intent registry for all MetaMe runtime adapters.
  *
@@ -8,9 +10,9 @@
  */
 
 const DEFAULTS = Object.freeze({
+  agent_capability: true,
   team_dispatch: true,
   ops_assist: true,
-  task_create: true,
   file_transfer: true,
   weixin_bridge: true,
   memory_recall: true,
@@ -20,17 +22,54 @@ const DEFAULTS = Object.freeze({
 });
 
 const INTENT_MODULES = Object.freeze({
+  agent_capability: {
+    detect: require('./hooks/intent-agent-capability'),
+    priority: 100,
+  },
   team_dispatch: require('./hooks/intent-team-dispatch'),
-  ops_assist: require('./hooks/intent-ops-assist'),
-  task_create: require('./hooks/intent-task-create'),
-  file_transfer: require('./hooks/intent-file-transfer'),
-  weixin_bridge: require('./hooks/intent-weixin-bridge'),
-  memory_recall: require('./hooks/intent-memory-recall'),
-  doc_router: require('./hooks/intent-doc-router'),
-  perpetual: require('./hooks/intent-perpetual'),
-  research: require('./hooks/intent-research'),
+  ops_assist: {
+    detect: require('./hooks/intent-ops-assist'),
+    priority: 80,
+  },
+  file_transfer: {
+    detect: require('./hooks/intent-file-transfer'),
+    priority: 95,
+  },
+  weixin_bridge: {
+    detect: require('./hooks/intent-weixin-bridge'),
+    priority: 90,
+  },
+  memory_recall: {
+    detect: require('./hooks/intent-memory-recall'),
+    priority: 70,
+  },
+  doc_router: {
+    detect: detectDocRouter,
+    priority: 10,
+    fallbackOnly: true,
+  },
+  perpetual: {
+    detect: require('./hooks/intent-perpetual'),
+    priority: 60,
+  },
+  research: {
+    detect: require('./hooks/intent-research'),
+    priority: 55,
+  },
 });
 
+const DEFAULT_MAX_HINTS = 2;
+const DEFAULT_MAX_HINT_CHARS = 1200;
+
+function normalizeIntentModule(entry) {
+  if (typeof entry === 'function') return { detect: entry, priority: 50, fallbackOnly: false };
+  return {
+    detect: entry.detect,
+    priority: Number.isFinite(entry.priority) ? entry.priority : 50,
+    fallbackOnly: !!entry.fallbackOnly,
+  };
+}
+
 function resolveEnabledIntents(config = {}) {
   const hooksCfg = (config.hooks && typeof config.hooks === 'object') ? config.hooks : {};
   return { ...DEFAULTS, ...hooksCfg };
@@ -42,18 +81,43 @@ function collectIntentHints(prompt, config = {}, projectKey = '') {
 
   const enabled = resolveEnabledIntents(config);
   const hints = [];
-  for (const [key, detect] of Object.entries(INTENT_MODULES)) {
+  for (const [key, rawEntry] of Object.entries(INTENT_MODULES)) {
     if (enabled[key] === false) continue;
-    const hint = detect(text, config, projectKey);
+    const entry = normalizeIntentModule(rawEntry);
+    const hint = entry.detect(text, config, projectKey);
     if (hint) hints.push({ key, hint });
   }
   return hints;
 }
 
 function buildIntentHintBlock(prompt, config = {}, projectKey = '') {
-  return collectIntentHints(prompt, config, projectKey)
-    .map(item => item.hint)
-    .join('\n\n');
+  const maxHints = Number.isInteger(config && config.intent_max_hints) && config.intent_max_hints > 0
+    ? config.intent_max_hints
+    : DEFAULT_MAX_HINTS;
+  const maxChars = Number.isInteger(config && config.intent_max_hint_chars) && config.intent_max_hint_chars > 0
+    ? config.intent_max_hint_chars
+    : DEFAULT_MAX_HINT_CHARS;
+
+  let hits = collectIntentHints(prompt, config, projectKey)
+    .map((item) => ({ ...item, ...normalizeIntentModule(INTENT_MODULES[item.key]) }));
+
+  if (hits.some(item => !item.fallbackOnly) && !(typeof detectDocRouter.hasExplicitDocIntent === 'function' && detectDocRouter.hasExplicitDocIntent(prompt))) {
+    hits = hits.filter(item => !item.fallbackOnly);
+  }
+
+  hits.sort((a, b) => b.priority - a.priority);
+
+  const selected = [];
+  let usedChars = 0;
+  for (const item of hits) {
+    if (selected.length >= maxHints) break;
+    const nextChars = usedChars + item.hint.length;
+    if (selected.length > 0 && nextChars > maxChars) continue;
+    selected.push(item);
+    usedChars = nextChars;
+  }
+
+  return selected.map(item => item.hint).join('\n\n');
 }
 
 module.exports = {

package/scripts/ops-mission-queue.js

@@ -15,7 +15,12 @@ const os = require('os');
 
 const MISSIONS_FILE = 'workspace/missions.md';
 const SECTIONS = ['pending', 'active', 'completed', 'abandoned'];
-const METAME_DIR = path.join(os.homedir(), '.metame');
+const RECENT_LOG_LINES = 500;
+const ERROR_THRESHOLD = 3;
+
+function getMetameDir() {
+  return process.env.METAME_DIR || path.join(os.homedir(), '.metame');
+}
 
 // ── Mission file parser (same format as topic-pool) ──────────
 
@@ -86,6 +91,90 @@ function findMission(sections, id) {
   return null;
 }
 
+function normalizeLogLine(line) {
+  return String(line || '')
+    .replace(/\d{4}-\d{2}-\d{2}T[\d:.]+Z?/g, '<TS>')
+    .replace(/\d{10,}/g, '<ID>')
+    .replace(/\/tmp\/[^\s]+/g, '<TMP>')
+    .trim();
+}
+
+function collectRecurringErrors() {
+  const counts = {};
+  const logPath = path.join(getMetameDir(), 'daemon.log');
+  if (!fs.existsSync(logPath)) return counts;
+
+  try {
+    const content = fs.readFileSync(logPath, 'utf8');
+    const recent = content.split('\n').slice(-RECENT_LOG_LINES);
+    for (const line of recent) {
+      if (!/\bERR\b|\bWARN\b|\bError\b|\bfailed\b/i.test(line)) continue;
+      const normalized = normalizeLogLine(line);
+      if (normalized.length < 20) continue;
+      const key = normalized.slice(0, 120);
+      counts[key] = (counts[key] || 0) + 1;
+    }
+  } catch { /* ignore unreadable log */ }
+
+  return counts;
+}
+
+function parseRecurringErrorTitle(title) {
+  const m = String(title || '').match(/^Fix recurring error(?:\s*\(\d+x\))?:\s*(.+)$/i);
+  return m ? m[1].trim() : '';
+}
+
+function shouldKeepMission(title, cwd, recurringErrors, now) {
+  const recurringPattern = parseRecurringErrorTitle(title);
+  if (recurringPattern) {
+    return (recurringErrors[recurringPattern] || 0) >= ERROR_THRESHOLD;
+  }
+
+  const testMatch = String(title || '').match(/^Fix failing tests in (.+)$/i);
+  if (testMatch) {
+    const testName = testMatch[1].trim();
+    const testPath = path.join(cwd, 'scripts', testName);
+    if (!fs.existsSync(testPath)) return false;
+    try {
+      execSyncSafe(`node --test scripts/${testName}`, cwd, 30000);
+      return false;
+    } catch {
+      return true;
+    }
+  }
+
+  const staleMatch = String(title || '').match(/^Investigate stale project:\s*(.+)$/i);
+  if (staleMatch) {
+    const projectKey = staleMatch[1].trim();
+    const fp = path.join(getMetameDir(), 'events', `${projectKey}.jsonl`);
+    if (!fs.existsSync(fp)) return false;
+    try {
+      const staleHours = (now - fs.statSync(fp).mtimeMs) / (60 * 60 * 1000);
+      return staleHours > 48;
+    } catch {
+      return true;
+    }
+  }
+
+  return true;
+}
+
+function pruneObsoleteMissions(cwd) {
+  const sections = readSections(cwd);
+  const recurringErrors = collectRecurringErrors();
+  const now = Date.now();
+  const pruned = [];
+
+  sections.pending = sections.pending.filter((mission) => {
+    const keep = shouldKeepMission(mission.title, cwd, recurringErrors, now);
+    if (!keep) pruned.push(mission);
+    return keep;
+  });
+
+  if (pruned.length > 0) writeSections(cwd, sections);
+  return { success: true, pruned: pruned.length, pruned_ids: pruned.map(m => m.id) };
+}
+
 // ── Standard queue commands ──────────────────────────────────
 
 function nextMission(cwd) {
@@ -134,6 +223,7 @@ function listMissions(cwd) {
 // ── Log scanner: generates missions from error patterns ──────
 
 function scanLogs(cwd) {
+  const pruneResult = pruneObsoleteMissions(cwd);
   const sections = readSections(cwd);
   const existingTitles = new Set(
     [...sections.pending, ...sections.active, ...sections.completed, ...sections.abandoned].map(t => t.title)
@@ -141,44 +231,18 @@ function scanLogs(cwd) {
 
   const newMissions = [];
   const now = Date.now();
-  const ONE_DAY = 24 * 60 * 60 * 1000;
+  const recurringErrors = collectRecurringErrors();
 
   // 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 */ }
+  for (const [pattern, count] of Object.entries(recurringErrors)) {
+    if (count < ERROR_THRESHOLD) continue;
+    const dedupKey = `Fix recurring error: ${pattern.slice(0, 80)}`;
+    if (existingTitles.has(dedupKey)) continue;
+    newMissions.push({ title: dedupKey, priority: Math.max(1, 10 - count) });
   }
 
   // 2. Scan event logs for stuck/stale projects
-  const eventsDir = path.join(METAME_DIR, 'events');
+  const eventsDir = path.join(getMetameDir(), 'events');
   if (fs.existsSync(eventsDir)) {
     try {
       const evFiles = fs.readdirSync(eventsDir).filter(f => f.endsWith('.jsonl'));
@@ -248,11 +312,12 @@ if (require.main === module) {
     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 'prune':    result = pruneObsoleteMissions(cwd); break;
     case 'scan':     result = scanLogs(cwd); break;
-    default:         result = { success: false, message: `unknown: ${command}. Available: next, activate, complete, list, scan` };
+    default:         result = { success: false, message: `unknown: ${command}. Available: next, activate, complete, list, prune, scan` };
   }
 
   process.stdout.write(JSON.stringify(result) + '\n');
 }
 
-module.exports = { nextMission, activateMission, completeMission, listMissions, scanLogs };
+module.exports = { nextMission, activateMission, completeMission, listMissions, pruneObsoleteMissions, scanLogs };

package/scripts/ops-reactive-bootstrap.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const yaml = require('./resolve-yaml');
+const { pruneObsoleteMissions, scanLogs } = require('./ops-mission-queue');
+const { bootstrapReactiveProject } = require('./daemon-reactive-lifecycle');
+
+const HOME = os.homedir();
+const METAME_DIR = path.join(HOME, '.metame');
+const CONFIG_PATH = path.join(METAME_DIR, 'daemon.yaml');
+const STATE_PATH = path.join(METAME_DIR, 'daemon_state.json');
+const PROJECT_KEY = 'metame_ops';
+
+function loadConfig() {
+  return yaml.load(fs.readFileSync(CONFIG_PATH, 'utf8')) || {};
+}
+
+function loadState() {
+  try {
+    return JSON.parse(fs.readFileSync(STATE_PATH, 'utf8'));
+  } catch {
+    return { reactive: {}, budget: { tokens_used: 0 } };
+  }
+}
+
+function saveState(state) {
+  fs.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
+}
+
+function checkBudget(config, state) {
+  const budget = config?.daemon?.daily_token_budget;
+  const used = Number(state?.budget?.tokens_used || 0);
+  if (!Number.isFinite(budget) || budget <= 0) return true;
+  return used < budget;
+}
+
+function dispatchReactiveItem(item) {
+  const dispatchBin = path.join(METAME_DIR, 'bin', 'dispatch_to');
+  const args = [dispatchBin];
+  if (item.new_session) args.push('--new');
+  if (item.from) args.push('--from', item.from);
+  args.push(item.target, item.prompt);
+  execFileSync(args[0], args.slice(1), {
+    encoding: 'utf8',
+    timeout: 30000,
+    env: process.env,
+  });
+  return { success: true };
+}
+
+function main() {
+  const config = loadConfig();
+  const project = config?.projects?.[PROJECT_KEY];
+  if (!project || !project.cwd) {
+    process.stdout.write(JSON.stringify({ success: false, skipped: true, reason: 'project_missing' }) + '\n');
+    return;
+  }
+
+  const cwd = project.cwd.replace(/^~/, HOME);
+  const pruned = pruneObsoleteMissions(cwd);
+  const scanned = scanLogs(cwd);
+
+  const result = bootstrapReactiveProject(PROJECT_KEY, config, {
+    metameDir: METAME_DIR,
+    loadState,
+    saveState,
+    checkBudget,
+    handleDispatchItem: dispatchReactiveItem,
+    log: () => {},
+    notifyUser: () => {},
+  });
+
+  process.stdout.write(JSON.stringify({
+    success: true,
+    pruned: pruned.pruned || 0,
+    new_missions: scanned.new_missions || 0,
+    total_pending: scanned.total_pending || 0,
+    bootstrap: result,
+  }) + '\n');
+}
+
+if (require.main === module) main();

package/scripts/resolve-yaml.js

@@ -1,6 +1,9 @@
 'use strict';
 
 const path = require('path');
+const { bootstrapRuntimeModulePaths } = require('./runtime-bootstrap');
+
+bootstrapRuntimeModulePaths(__dirname);
 
 let yaml;
 try {

package/scripts/runtime-bootstrap.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const Module = require('module');
+
+function readRuntimeEnvFile(baseDir) {
+  const runtimeFile = path.join(baseDir, 'runtime-env.json');
+  try {
+    if (!fs.existsSync(runtimeFile)) return null;
+    return JSON.parse(fs.readFileSync(runtimeFile, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function collectNodeModuleCandidates(baseDir) {
+  const candidates = [];
+  const runtimeEnv = readRuntimeEnvFile(baseDir);
+  const metameRoot = String(process.env.METAME_ROOT || runtimeEnv?.metameRoot || '').trim();
+  const runtimeNodeModules = String(runtimeEnv?.nodeModules || '').trim();
+
+  if (runtimeNodeModules) candidates.push(runtimeNodeModules);
+  if (metameRoot) candidates.push(path.join(metameRoot, 'node_modules'));
+
+  candidates.push(path.join(baseDir, 'node_modules'));
+  candidates.push(path.resolve(baseDir, '..', 'node_modules'));
+
+  const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+  if (home) candidates.push(path.join(home, '.metame', 'node_modules'));
+
+  return [...new Set(candidates.filter(Boolean))];
+}
+
+function bootstrapRuntimeModulePaths(baseDir = __dirname) {
+  const runtimeEnv = readRuntimeEnvFile(baseDir);
+  if (!process.env.METAME_ROOT && runtimeEnv?.metameRoot) {
+    process.env.METAME_ROOT = runtimeEnv.metameRoot;
+  }
+
+  const existingNodePath = String(process.env.NODE_PATH || '')
+    .split(path.delimiter)
+    .map(p => p.trim())
+    .filter(Boolean);
+
+  let updated = false;
+  for (const candidate of collectNodeModuleCandidates(baseDir)) {
+    try {
+      if (!fs.existsSync(candidate) || !fs.statSync(candidate).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    if (!existingNodePath.includes(candidate)) {
+      existingNodePath.unshift(candidate);
+      updated = true;
+    }
+    if (!Module.globalPaths.includes(candidate)) {
+      Module.globalPaths.unshift(candidate);
+      updated = true;
+    }
+  }
+
+  if (updated) {
+    process.env.NODE_PATH = existingNodePath.join(path.delimiter);
+    if (typeof Module._initPaths === 'function') Module._initPaths();
+  }
+
+  return {
+    metameRoot: process.env.METAME_ROOT || '',
+    nodePath: process.env.NODE_PATH || '',
+  };
+}
+
+module.exports = {
+  bootstrapRuntimeModulePaths,
+};

package/scripts/hooks/intent-engine.js

@@ -1,75 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * MetaMe Intent Engine — Unified UserPromptSubmit Hook
- *
- * Config-driven intent dispatcher. Replaces the standalone team-context.js hook.
- * Each intent module detects a specific pattern and returns a hint string or null.
- * Only injects an additionalSystemPrompt when at least one intent fires.
- *
- * Enabled intents are controlled via daemon.yaml `hooks:` section:
- *
- *   hooks:
- *     team_dispatch: true   # team member communication hints (default: on)
- *     ops_assist: true      # /undo /restart /logs etc. hints (default: on)
- *     task_create: true     # task scheduling hints (default: on)
- *
- * Set any key to false to disable that intent module.
- */
-
-'use strict';
-
-// Global safety net: hooks must NEVER crash or exit non-zero
-process.on('uncaughtException', () => process.exit(0));
-process.on('unhandledRejection', () => process.exit(0));
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const METAME_DIR = path.join(os.homedir(), '.metame');
-const { sanitizePrompt, isInternalPrompt } = require('./hook-utils');
-const { buildIntentHintBlock } = require('../intent-registry');
-
-function exit() { process.exit(0); }
-
-let raw = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', c => { raw += c; });
-process.stdin.on('end', () => {
-  try { run(JSON.parse(raw)); } catch { exit(); }
-});
-
-function run(data) {
-  // Internal daemon subprocesses set this env flag — never inject hints into them
-  if (process.env.METAME_INTERNAL_PROMPT === '1') return exit();
-
-  const projectKey = process.env.METAME_PROJECT || '';
-  const rawPrompt = (data.prompt || data.user_prompt || '').trim();
-  if (!rawPrompt) return exit();
-
-  // Strip daemon-injected blocks, then bail if this is a system prompt
-  if (isInternalPrompt(rawPrompt)) return exit();
-  const prompt = sanitizePrompt(rawPrompt);
-  if (!prompt) return exit();
-
-  // Load daemon.yaml config (graceful: intents that don't need config still run)
-  let config = {};
-  try {
-    const yaml = require('../resolve-yaml');
-    config = yaml.load(fs.readFileSync(path.join(METAME_DIR, 'daemon.yaml'), 'utf8')) || {};
-  } catch { /* proceed with defaults */ }
-
-  let intentBlock = '';
-  try {
-    intentBlock = buildIntentHintBlock(prompt, config, projectKey);
-  } catch {
-    return exit();
-  }
-  if (!intentBlock) return exit();
-
-  process.stdout.write(JSON.stringify({
-    hookSpecificOutput: { additionalContext: intentBlock },
-  }));
-  exit();
-}