metame-cli 1.5.2 → 1.5.4

package/scripts/hooks/hook-utils.js

@@ -0,0 +1,61 @@
+'use strict';
+
+/**
+ * MetaMe Hook Utilities — Shared helpers for Claude Code hooks
+ *
+ * Provides prompt sanitization and internal prompt detection used by
+ * multiple hooks to avoid triggering on daemon-injected system content.
+ */
+
+// Daemon-injected blocks that should be stripped before intent analysis
+const BLOCK_PATTERNS = [
+  /<!--\s*FACTS:START\s*-->[\s\S]*?<!--\s*FACTS:END\s*-->/gi,
+  /<!--\s*MEMORY:START\s*-->[\s\S]*?<!--\s*MEMORY:END\s*-->/gi,
+  /\[System hints - DO NOT mention these to user:[\s\S]*?\]/gi,
+  /\[Mac automation policy - do NOT expose this block:[\s\S]*?\]/gi,
+  /\[Task notification\][\s\S]*?(?=\n{2,}|$)/gi,
+  /<task-notification\b[\s\S]*?<\/task-notification>/gi,
+  /<task-notification\b[\s\S]*$/gi,
+];
+
+// Patterns that identify internal/system prompts (daemon subprocesses)
+const INTERNAL_PATTERNS = [
+  /You are a MetaMe cognitive profile distiller/i,
+  /You are a metacognition pattern detector/i,
+  /你是精准的知识提取引擎/,
+  /RECALLED LONG-TERM FACTS \(context only/i,
+  /\[System hints - DO NOT mention these to user:/i,
+  /\[Mac automation policy - do NOT expose this block:/i,
+  /MANDATORY FIRST ACTION: The user has not been calibrated yet/i,
+  /<!--\s*FACTS:START\s*-->/i,
+  /<!--\s*MEMORY:START\s*-->/i,
+  /\[Task notification\]/i,
+  /<task-notification\b/i,
+];
+
+/**
+ * Strip daemon-injected blocks from prompt text.
+ * Returns clean user payload or empty string.
+ * @param {string} text
+ * @returns {string}
+ */
+function sanitizePrompt(text) {
+  let s = String(text || '');
+  for (const re of BLOCK_PATTERNS) {
+    s = s.replace(re, ' ');
+  }
+  return s.trim();
+}
+
+/**
+ * Returns true if the text matches a known internal/system prompt template.
+ * These come from daemon subprocesses (distill, memory-extract, skill-evolution).
+ * @param {string} text
+ * @returns {boolean}
+ */
+function isInternalPrompt(text) {
+  const s = String(text || '');
+  return INTERNAL_PATTERNS.some(re => re.test(s));
+}
+
+module.exports = { sanitizePrompt, isInternalPrompt };

package/scripts/hooks/intent-agent-manage.js

@@ -0,0 +1,50 @@
+'use strict';
+
+/**
+ * Agent Management Intent Module
+ *
+ * Detects when the user asks about creating, managing, or binding agents,
+ * or asks about code structure / upgrade progress.
+ *
+ * @param {string} prompt
+ * @returns {string|null}
+ */
+
+const AGENT_MANAGE_PATTERNS = [
+  // Creating / binding / managing agents
+  /(?:创建|新建|添加|注册|绑定|配置|管理).{0,8}(?:agent|机器人|bot|智能体)/i,
+  /(?:agent|bot|智能体).{0,8}(?:创建|新建|添加|注册|绑定|配置|管理)/i,
+  // English
+  /\b(?:create|add|register|bind|manage|setup|configure)\s+(?:an?\s+)?agent\b/i,
+];
+
+const CODE_STRUCTURE_PATTERNS = [
+  // Code structure / upgrade / script entry questions
+  /(?:代码结构|脚本入口|升级进度|模块关系|文件结构)/,
+  /(?:pointer.?map|架构图|入口文件)/i,
+];
+
+module.exports = function detectAgentManage(prompt) {
+  const isManage = AGENT_MANAGE_PATTERNS.some(re => re.test(prompt));
+  const isStructure = CODE_STRUCTURE_PATTERNS.some(re => re.test(prompt));
+
+  if (!isManage && !isStructure) return null;
+
+  const hints = [];
+
+  if (isManage) {
+    hints.push(
+      '[Agent 管理提示]',
+      '- 创建/管理/绑定 Agent → 先 `cat ~/.metame/docs/agent-guide.md` 获取完整流程',
+    );
+  }
+
+  if (isStructure) {
+    hints.push(
+      '[代码结构提示]',
+      '- 代码结构/脚本入口/升级进度 → 先 `cat ~/.metame/docs/pointer-map.md` 获取索引',
+    );
+  }
+
+  return hints.join('\n');
+};

package/scripts/hooks/intent-engine.js

@@ -0,0 +1,103 @@
+#!/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';
+
+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');
+
+// Default: all intents enabled unless explicitly set to false in daemon.yaml
+const DEFAULTS = {
+  team_dispatch:  true,
+  ops_assist:     true,
+  task_create:    true,
+  file_transfer:  true,
+  memory_recall:  true,
+  agent_manage:   true,
+  hook_config:    true,
+};
+
+// Intent registry — loaded lazily so startup is fast even if a module has issues
+const INTENT_MODULES = {
+  team_dispatch:  './intent-team-dispatch',
+  ops_assist:     './intent-ops-assist',
+  task_create:    './intent-task-create',
+  file_transfer:  './intent-file-transfer',
+  memory_recall:  './intent-memory-recall',
+  agent_manage:   './intent-agent-manage',
+  hook_config:    './intent-hook-config',
+};
+
+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 */ }
+
+  // Merge daemon.yaml hooks section with defaults
+  const hooksCfg = (config.hooks && typeof config.hooks === 'object') ? config.hooks : {};
+  const enabled = { ...DEFAULTS, ...hooksCfg };
+
+  // Run each enabled intent module, collect non-null hints
+  const hints = [];
+  for (const [key, modulePath] of Object.entries(INTENT_MODULES)) {
+    if (enabled[key] === false) continue;
+    try {
+      const detect = require(modulePath);
+      const result = detect(prompt, config, projectKey);
+      if (result) hints.push(result);
+    } catch (e) {
+      process.stderr.write(`[intent-engine] ${key}: ${e.message}\n`);
+    }
+  }
+
+  if (hints.length === 0) return exit();
+
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: { additionalSystemPrompt: hints.join('\n\n') },
+  }));
+  exit();
+}

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

@@ -0,0 +1,51 @@
+'use strict';
+
+/**
+ * File Transfer Intent Module
+ *
+ * Detects when the user wants to send/receive files via phone.
+ * Injects the [[FILE:...]] protocol hint on demand.
+ *
+ * @param {string} prompt
+ * @returns {string|null}
+ */
+
+const SEND_PATTERNS = [
+  // "发给我/发过来/发我/传给我" — user wants a file sent to phone
+  /(?:发给我|发过来|发我|传给我|传过来|发到手机|发手机上)/,
+  // "导出给我/导出一下/导出文件" — export intent (require suffix to avoid "导出函数" etc.)
+  /导出(?:给我|一下|文件|到手机)/,
+  // English patterns
+  /\b(?:send|share)\s+(?:me|to\s+(?:my\s+)?phone)\b/i,
+];
+
+const RECEIVE_PATTERNS = [
+  // User mentions uploading or sending files to the system
+  /(?:我发|给你|传给你|上传).{0,8}(?:文件|图片|截图|照片|图)/,
+  /upload\/\S+/i,
+];
+
+module.exports = function detectFileTransfer(prompt) {
+  const isSend = SEND_PATTERNS.some(re => re.test(prompt));
+  const isReceive = RECEIVE_PATTERNS.some(re => re.test(prompt));
+
+  if (!isSend && !isReceive) return null;
+
+  const hints = ['[文件传输提示]'];
+
+  if (isSend) {
+    hints.push(
+      '- **发送文件到手机**：在回复末尾加 `[[FILE:/absolute/path]]`，daemon 自动发送',
+      '- 多个文件用多个 `[[FILE:...]]` 标记',
+      '- **不要读取文件内容再复述**，直接用标记发送（省 token）',
+    );
+  }
+
+  if (isReceive) {
+    hints.push(
+      '- **接收文件**：用户发的图片/文件自动存到当前项目 `upload/` 目录，用 Read 查看',
+    );
+  }
+
+  return hints.join('\n');
+};

package/scripts/hooks/intent-hook-config.js

@@ -0,0 +1,28 @@
+'use strict';
+
+/**
+ * Hook Config Intent Module
+ *
+ * Detects when the user asks about hook/intent engine configuration.
+ *
+ * @param {string} prompt
+ * @returns {string|null}
+ */
+
+const HOOK_PATTERNS = [
+  // Hook / intent configuration
+  /(?:hook|intent|意图).{0,10}(?:配置|设置|开关|新增|添加|修改|怎么配|怎么设置|怎么改)/i,
+  /(?:配置|设置|开关|新增|添加|修改).{0,10}(?:hook|intent|意图)/i,
+  // Specific intent engine topics
+  /intent.?engine/i,
+  /意图引擎|意图模块/,
+];
+
+module.exports = function detectHookConfig(prompt) {
+  if (!HOOK_PATTERNS.some(re => re.test(prompt))) return null;
+
+  return [
+    '[Intent Engine 配置提示]',
+    '- Hook/Intent 配置操作 → 先 `cat ~/.metame/docs/hook-config.md` 获取完整手册',
+  ].join('\n');
+};

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

@@ -0,0 +1,35 @@
+'use strict';
+
+/**
+ * Memory Recall Intent Module
+ *
+ * Detects cross-session memory recall intent (user references past conversations).
+ * Injects memory-search command hint on demand.
+ *
+ * @param {string} prompt
+ * @returns {string|null}
+ */
+
+const RECALL_PATTERNS = [
+  // "上次/之前/前几天" — referencing past conversations (tight window to avoid current-session refs)
+  /(?:上次|前几天|上周|前阵子).{0,6}(?:说|讨论|聊|提到|做|改|写|搞|弄|处理|商量)/,
+  // "之前" needs tighter pairing — "之前写了个函数" is current-session, not recall
+  /之前.{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,
+];
+
+module.exports = function detectMemoryRecall(prompt) {
+  if (!RECALL_PATTERNS.some(re => re.test(prompt))) return null;
+
+  return [
+    '[跨会话记忆提示]',
+    '- 搜索记忆: `node ~/.metame/memory-search.js "关键词1" "keyword2"`',
+    '- 一次传 3-4 个关键词（中文+英文+函数名）',
+    '- `--facts` 只搜事实，`--sessions` 只搜会话',
+  ].join('\n');
+};

package/scripts/hooks/intent-ops-assist.js

@@ -0,0 +1,54 @@
+'use strict';
+
+/**
+ * Ops Assist Intent Module
+ *
+ * Detects operational context and injects relevant command hints.
+ * Uses specific patterns to avoid noise — only fires when the user
+ * is clearly asking about operational topics.
+ *
+ * @param {string} prompt
+ * @returns {string|null}
+ */
+
+const OPS_INTENTS = [
+  {
+    // User explicitly wants to revert/undo code changes.
+    // Removed "上一步" (too generic: "上一步的逻辑是什么" is not undo).
+    // \b only used around ASCII keywords; Chinese patterns need no word boundary.
+    pattern: /(回退|撤销|恢复上一版|回到上一版|回滚)|\b(undo|git reset)\b/i,
+    hint: '`/undo` 撤销最近改动 | `/undo <hash>` 回到指定 checkpoint',
+  },
+  {
+    // Save a progress checkpoint — requires explicit "save/create" intent.
+    // Removed bare \bcheckpoint\b: fires on any technical mention of the word.
+    pattern: /保存.{0,5}(进度|checkpoint|快照|存档)|存个档|打个checkpoint/i,
+    hint: '`/checkpoint` 保存当前进度快照',
+  },
+  {
+    // Daemon restart
+    pattern: /(重启|restart).{0,10}(daemon|服务|后台)|daemon.{0,10}(挂了|不响应|崩了|没反应|失联)/i,
+    hint: '`/restart` 重启 MetaMe daemon',
+  },
+  {
+    // Explicitly asking to view logs
+    pattern: /(查看|看看|看下|打开).{0,10}(日志|logs?)|(日志|logs?).{0,10}(在哪|怎么看|如何查)|\b(show|view|check)\s+logs?\b/i,
+    hint: '`/logs` 查看最近运行日志',
+  },
+  {
+    // Memory/session cleanup
+    pattern: /\bgc\b|垃圾回收|清理.{0,5}(缓存|session|内存)|内存.{0,5}(清理|释放|满了|不够)/i,
+    hint: '`/gc` 清理过期 session / 释放内存',
+  },
+  {
+    // System status check
+    pattern: /(系统|daemon|服务|agent).{0,5}(状态|运行情况|是否正常|健康状况)|\b(status|health)\b.{0,10}(check|查看)/i,
+    hint: '`/status` 查看当前系统状态',
+  },
+];
+
+module.exports = function detectOpsAssist(prompt) {
+  const hits = OPS_INTENTS.filter(({ pattern }) => pattern.test(prompt));
+  if (hits.length === 0) return null;
+  return ['[运维提示]', ...hits.map(h => `- ${h.hint}`)].join('\n');
+};

package/scripts/hooks/intent-task-create.js

@@ -0,0 +1,35 @@
+'use strict';
+
+/**
+ * Task Create Intent Module
+ *
+ * Detects scheduling/reminder intent and injects task creation hints.
+ * Requires explicit scheduling language to avoid false positives.
+ *
+ * @param {string} prompt
+ * @returns {string|null}
+ */
+
+const TASK_PATTERNS = [
+  // Explicit recurring schedule: 每天/每小时/... + action
+  /(每天|每小时|每周|每月|每.{1,4}分钟).{0,20}(提醒|通知|运行|执行|做|检查)/,
+  // "提醒我" must be paired with time/frequency context to avoid false positives
+  // e.g. "提醒我明天九点" ✓ / "提醒我这个要注意" ✗
+  /提醒我.{0,15}(每天|每周|每小时|[0-9０-９]|明天|后天|下周|点钟|分钟|小时)|\bremind me\b.{0,20}(every|daily|at \d|\btomorrow\b)|\bset.{0,5}reminder\b/i,
+  // Scheduling keywords
+  /定时任务|\bheartbeat.{0,5}task\b|\bcron job\b/i,
+  // "每天X点提醒" pattern
+  /每天.{0,10}[0-9０-９点时].{0,10}(提醒|通知|叫我)/,
+  // "下次别忘了 / 帮我记住 + 周期性语境"
+  /下次.{0,8}(别忘|记得|提醒)|帮我.{0,5}记住.{0,10}(每|定期|以后)/,
+];
+
+module.exports = function detectTaskCreate(prompt) {
+  if (!TASK_PATTERNS.some(re => re.test(prompt))) return null;
+  return [
+    '[任务调度提示]',
+    '- 定时任务: `/task-add "描述" --at "09:00" --every day`',
+    '- 一次性提醒: `/task-add "描述" --once --in "30m"`',
+    '- 查看任务列表: `/tasks`',
+  ].join('\n');
+};

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

@@ -0,0 +1,106 @@
+'use strict';
+
+/**
+ * Team Dispatch Intent Module
+ *
+ * Detects communication intent towards team members in the prompt.
+ * Extracted from team-context.js — same logic, pure function interface.
+ *
+ * @param {string} prompt        - sanitized user prompt
+ * @param {object} config        - daemon.yaml config
+ * @param {string} projectKey    - METAME_PROJECT env value
+ * @returns {string|null}        - hint string or null if no intent detected
+ */
+
+const path = require('path');
+const os = require('os');
+
+// ── Communication intent patterns ─────────────────────────────────────────────
+// Three structural patterns:
+//   A) verb → name:  告诉工匠 / 发给builder / 通知乙
+//   B) name → verb:  工匠你来 / builder帮我 / 乙去做
+//   C) prep + name:  和工匠讨论 / 跟builder说 / 与乙沟通
+
+const BEFORE_NAME_ZH = ['告诉', '通知', '让', '叫', '派', '交给', '转给', '发给', '联系', '找', '请', '问', '发消息给'];
+const BEFORE_NAME_EN = ['tell', 'ask', 'notify', 'send to', 'assign to', 'delegate to', 'message', 'ping', 'contact'];
+const AFTER_NAME_ZH  = ['你来', '来做', '去做', '帮我', '帮忙', '负责', '处理', '跟进'];
+const AFTER_NAME_EN  = ['help', 'do this', 'handle', 'take care', 'follow up'];
+const PREP_ZH = ['和', '跟', '与'];
+const DISC_EN = ['discuss with', 'talk to', 'chat with', 'coordinate with', 'sync with', 'work with'];
+
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function hasCommIntent(text, nickname) {
+  const t = text.toLowerCase();
+  const n = escapeRe(nickname.toLowerCase());
+
+  // A) verb → name (within 15 chars)
+  for (const v of BEFORE_NAME_ZH) {
+    if (new RegExp(`${v}.{0,15}${n}`, 'u').test(t)) return true;
+  }
+  for (const v of BEFORE_NAME_EN) {
+    if (new RegExp(`${v}.{0,20}${n}`, 'i').test(t)) return true;
+  }
+
+  // B) name → verb (within 8 chars)
+  for (const v of AFTER_NAME_ZH) {
+    if (new RegExp(`${n}.{0,8}${v}`, 'u').test(t)) return true;
+  }
+  for (const v of AFTER_NAME_EN) {
+    if (new RegExp(`${n}.{0,10}${v}`, 'i').test(t)) return true;
+  }
+
+  // C) prep + name (和工匠/跟builder — prep within 3 chars before name)
+  for (const p of PREP_ZH) {
+    if (new RegExp(`${p}.{0,3}${n}`, 'u').test(t)) return true;
+  }
+  for (const v of DISC_EN) {
+    if (new RegExp(`${v}.{0,20}${n}`, 'i').test(t)) return true;
+  }
+
+  return false;
+}
+
+module.exports = function detectTeamDispatch(prompt, config, projectKey) {
+  if (!config || !config.projects || !projectKey) return null;
+
+  const dispatchBin = path.join(os.homedir(), '.metame', 'bin', 'dispatch_to');
+
+  // Collect all reachable team members (siblings + parent)
+  const allMembers = [];
+  for (const [parentKey, parent] of Object.entries(config.projects)) {
+    if (!Array.isArray(parent.team)) continue;
+    for (const member of parent.team) {
+      if (member.key === projectKey) continue; // skip self
+      allMembers.push({ member, isParent: false });
+    }
+    // Allow dispatching to parent project itself (escalation)
+    if (parent.team.some(m => m.key === projectKey)) {
+      allMembers.push({
+        member: { key: parentKey, name: parent.name, nicknames: parent.nicknames },
+        isParent: true,
+      });
+    }
+  }
+
+  if (allMembers.length === 0) return null;
+
+  // Match only members with communication intent in this prompt
+  const hits = allMembers.filter(({ member }) => {
+    const nicks = [member.key, member.name, ...(Array.isArray(member.nicknames) ? member.nicknames : [])].filter(Boolean);
+    return nicks.some(n => hasCommIntent(prompt, n));
+  });
+
+  if (hits.length === 0) return null;
+
+  const lines = hits.map(({ member, isParent }) => {
+    const label = isParent
+      ? `${member.key}（${member.name || member.key}, 向上汇报）`
+      : `${member.key}（${member.name || member.key}）`;
+    return `- ${label}: \`${dispatchBin} --from ${projectKey} ${member.key} "消息"\``;
+  });
+
+  return ['[团队联络提示]', '以下成员可通过 dispatch_to 联络:', ...lines].join('\n');
+};

package/scripts/hooks/team-context.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+/**
+ * MetaMe Team Context Hook — UserPromptSubmit
+ *
+ * Detects communication intent towards team members in the prompt.
+ * If found, injects targeted dispatch_to hint(s) for only those members.
+ * Zero injection when no communication intent detected → zero wasted tokens.
+ *
+ * Triggers when the prompt contains:
+ *   - A communication verb (告诉/让/发给/和...讨论/...) near a member nickname
+ *   - Or a member nickname in a communication context
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const METAME_DIR = path.join(os.homedir(), '.metame');
+
+// ── Communication intent patterns ────────────────────────────────────────────
+// Three structural patterns:
+//   A) verb → name:   告诉工匠 / 发给builder / 通知乙
+//   B) name → verb:   工匠你来 / builder帮我 / 乙去做
+//   C) prep + name:   和工匠讨论 / 跟builder说 / 与乙沟通 (name between prep and verb)
+
+const BEFORE_NAME_ZH = ['告诉', '通知', '让', '叫', '派', '交给', '转给', '发给', '联系', '找', '请', '问', '发消息给'];
+const BEFORE_NAME_EN = ['tell', 'ask', 'notify', 'send to', 'assign to', 'delegate to', 'message', 'ping', 'contact'];
+const AFTER_NAME_ZH  = ['你来', '来做', '去做', '帮我', '帮忙', '负责', '处理', '跟进'];
+const AFTER_NAME_EN  = ['help', 'do this', 'handle', 'take care', 'follow up'];
+// Prepositions that introduce a discussion partner (name follows immediately)
+const PREP_ZH = ['和', '跟', '与'];
+const DISC_EN = ['discuss with', 'talk to', 'chat with', 'coordinate with', 'sync with', 'work with'];
+
+function hasCommIntent(text, nickname) {
+  const t = text.toLowerCase();
+  const n = nickname.toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+  // A) verb → name (within 15 chars)
+  for (const v of BEFORE_NAME_ZH) {
+    if (new RegExp(`${v}.{0,15}${n}`, 'u').test(t)) return true;
+  }
+  for (const v of BEFORE_NAME_EN) {
+    if (new RegExp(`${v}.{0,20}${n}`, 'i').test(t)) return true;
+  }
+
+  // B) name → verb (within 8 chars)
+  for (const v of AFTER_NAME_ZH) {
+    if (new RegExp(`${n}.{0,8}${v}`, 'u').test(t)) return true;
+  }
+  for (const v of AFTER_NAME_EN) {
+    if (new RegExp(`${n}.{0,10}${v}`, 'i').test(t)) return true;
+  }
+
+  // C) prep + name (和工匠/跟builder — prep within 3 chars before name)
+  for (const p of PREP_ZH) {
+    if (new RegExp(`${p}.{0,3}${n}`, 'u').test(t)) return true;
+  }
+  for (const v of DISC_EN) {
+    if (new RegExp(`${v}.{0,20}${n}`, 'i').test(t)) return true;
+  }
+
+  return false;
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+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) {
+  const projectKey = process.env.METAME_PROJECT;
+  if (!projectKey || process.env.METAME_INTERNAL_PROMPT === '1') return exit();
+
+  const prompt = (data.prompt || data.user_prompt || '').trim();
+  if (!prompt) return exit();
+
+  // Load config
+  let config;
+  try {
+    const yaml = require('../resolve-yaml');
+    config = yaml.load(fs.readFileSync(path.join(METAME_DIR, 'daemon.yaml'), 'utf8'));
+  } catch { return exit(); }
+
+  if (!config || !config.projects) return exit();
+
+  // Collect all team members across all projects (caller may be top-level or member)
+  const allMembers = [];
+  for (const [parentKey, parent] of Object.entries(config.projects)) {
+    if (!Array.isArray(parent.team)) continue;
+    for (const member of parent.team) {
+      if (member.key === projectKey) continue; // skip self
+      allMembers.push({ member, parentKey, parent });
+    }
+    // Also allow dispatching to parent project itself (escalation)
+    if (parent.team.some(m => m.key === projectKey)) {
+      allMembers.push({
+        member: { key: parentKey, name: parent.name, nicknames: parent.nicknames },
+        parentKey,
+        parent,
+        isParent: true,
+      });
+    }
+  }
+
+  if (allMembers.length === 0) return exit();
+
+  const dispatchBin = path.join(METAME_DIR, 'bin', 'dispatch_to');
+
+  // Find members with communication intent in this prompt
+  const hits = [];
+  for (const { member, isParent } of allMembers) {
+    const nicks = [member.key, member.name, ...(Array.isArray(member.nicknames) ? member.nicknames : [])].filter(Boolean);
+    const matched = nicks.some(n => hasCommIntent(prompt, n));
+    if (matched) hits.push({ member, isParent });
+  }
+
+  if (hits.length === 0) return exit();
+
+  // Build targeted hint for matched members only
+  const lines = hits.map(({ member, isParent }) => {
+    const target = member.peer ? `${member.peer}:${member.key}` : member.key;
+    const location = member.peer ? ` [远端:${member.peer}]` : '';
+    const label = isParent ? `${member.key}（${member.name || member.key}, 向上汇报）` : `${member.key}（${member.name || member.key}${location}）`;
+    return `- ${label}: \`${dispatchBin} --from ${projectKey} ${target} "消息"\``;
+  });
+
+  const hint = [
+    `[团队联络提示]`,
+    `以下成员可通过 dispatch_to 联络:`,
+    ...lines,
+  ].join('\n');
+
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: { additionalSystemPrompt: hint },
+  }));
+  exit();
+}

package/scripts/memory-extract.js

@@ -276,7 +276,7 @@ async function run() {
     let distillEnv = {};
     try { distillEnv = buildDistillEnv(); } catch { }
 
-    const sessions = sessionAnalytics.findAllUnextractedSessions(8);
+    const sessions = sessionAnalytics.findAllUnextractedSessions(3);
     if (sessions.length === 0) {
       console.log('[memory-extract] No unanalyzed sessions found.');
       memory.close();