metame-cli 1.4.34 → 1.5.1

package/scripts/docs/pointer-map.md

@@ -0,0 +1,110 @@
+# MetaMe 脚本/文档指针地图
+
+> 目的：回答“这段能力在哪个文件”“当前升级做到哪一步”“先看哪个脚本”。
+
+## 快速入口
+
+- 主入口：`index.js`
+- CLI 双入口：`metame`（Claude）/`metame codex [args]`（Codex）
+- Daemon 主循环：`scripts/daemon.js`
+- 多引擎 runtime 适配层：`scripts/daemon-engine-runtime.js`
+- 会话执行引擎（Claude/Codex 共用入口）：`scripts/daemon-claude-engine.js`
+- 管理命令：`scripts/daemon-admin-commands.js`
+- 命令路由：`scripts/daemon-command-router.js`
+- 执行命令（`/stop`、`/compact` 等）：`scripts/daemon-exec-commands.js`
+- 会话存储：`scripts/daemon-session-store.js`
+- 默认配置：`scripts/daemon-default.yaml`
+- Provider/蒸馏模型配置：`scripts/providers.js`（`/provider`、`/distill-model`）
+- 跨平台基础设施：`scripts/platform.js`（`killProcessTree`、`socketPath`、`sleepSync`、`icon`）
+- 热重载安全机制：`scripts/daemon-runtime-lifecycle.js`（语法预检、last-good 备份、crash-loop 自愈）
+- 维护手册：`scripts/docs/maintenance-manual.md`
+
+## 多引擎（Claude/Codex）定位
+
+- Runtime 工厂与事件归一化：
+  - `scripts/daemon-engine-runtime.js`
+  - 关键点：`normalizeEngineName()`、`buildClaudeArgs()`、`buildCodexArgs()`、`parseCodexStreamEvent()`
+
+- 会话与引擎选择：
+  - `scripts/daemon-claude-engine.js`
+  - 关键点：`askClaude()` 按 `project.engine`/session 选择 runtime；`patchSessionSerialized()` 串行回写 session
+  - Codex 规则：`exec`/`resume`、10 分钟窗口内一次自动重试、`thread_id` 迁移回写
+
+- Agent Soul 身份层（新）：
+  - `scripts/agent-layer.js`
+  - 关键点：`ensureAgentLayer()` 创建 `~/.metame/agents/<id>/`（soul.md、memory-snapshot.md、agent.yaml）；
+    `createLinkOrMirror()` Windows 兼容（symlink → hardlink → copy 降级）；
+    `ensureClaudeMdSoulImport()` 在 CLAUDE.md 头部注入 `@SOUL.md`（Claude CLI 自动加载）；
+    Codex 引擎在每次新 session 时将 CLAUDE.md + SOUL.md 合并写入 AGENTS.md（见 daemon-claude-engine.js:957）；
+    `repairAgentLayer()` 懒迁移：老项目补建 soul 层，幂等安全
+
+- Agent 命令处理（新）：
+  - `scripts/daemon-agent-commands.js`
+  - 关键点：`createAgentCommandHandler()` 处理 `/agent`、`/activate`、`/resume`；
+    `/agent soul [repair|edit]`；`pendingActivations` 无 TTL（消费即删）；防止创建群自激活
+
+- 路由与 Agent 创建：
+  - `scripts/daemon-command-router.js`
+  - `scripts/daemon-agent-tools.js`
+  - 关键点：自然语言提取 `codex` 关键词；默认 `claude` 不写 `engine` 字段，仅 `codex` 持久化 `engine: codex`；
+    `bindAgentToChat()` 自动调用 `ensureAgentMetadata()` 建立 soul 层
+
+- 会话命令与兼容边界：
+  - `scripts/daemon-exec-commands.js`
+  - 关键点：`/stop` 引擎中性；`/compact` 在 codex 会话返回“暂不支持”
+
+- 运行时引擎切换与诊断：
+  - `scripts/daemon-admin-commands.js`
+  - 关键点：`/engine` 切换默认引擎；`/doctor` 按默认引擎检查 CLI 可用性（Claude/Codex）并兼容自定义 provider 模型名
+
+## Mentor Mode（Step 1-4）定位
+
+- Step 1 数据基建：
+  - `scripts/session-analytics.js`
+  - 关键点：`extractSkeleton()` 新增数值指标、`detectSignificantSession()`
+  - `scripts/schema.js`：`growth.mentor_mode`、`growth.mentor_friction_level`、`growth.weekly_report_last`
+  - `scripts/memory.js`：`fact_labels` 表结构
+
+- Step 2 决策引擎：
+  - `scripts/mentor-engine.js`
+  - 关键 API：`checkEmotionBreaker` / `buildMentorPrompt` / `computeZone` / `registerDebt` / `collectDebt` / `detectPatterns`
+  - 运行时状态文件：`~/.metame/mentor_runtime.json`
+
+- Step 3 Hook 接入：
+  - `scripts/daemon-claude-engine.js`：Pre-flight / Context / Post-flight 三段 Hook
+  - `scripts/daemon-admin-commands.js`：`/mentor on|off|level|status`
+  - `scripts/daemon-default.yaml`：`daemon.mentor` 配置段
+
+- Step 4 Distiller & Memory 闭环：
+  - `scripts/distill.js`：`competence_signals` 合并、significant session postmortem 产出、`bug_lesson` 回写
+  - `scripts/memory-extract.js`：消费 `saveFacts().savedFacts`，写入 `fact_labels`
+  - `scripts/memory.js`：`saveFactLabels()` 原子写入 API
+  - `scripts/memory-nightly-reflect.js`：`synthesized_insight` 回写、知识胶囊聚合与 `knowledge_capsule` 回写
+
+## 运行时数据位置
+
+- 画像：`~/.claude_profile.yaml`
+- 记忆数据库：`~/.metame/memory.db`
+- 会话标签：`~/.metame/session_tags.json`
+- 进程 PID 记录：`~/.metame/active_agent_pids.json`
+- 夜间反思文档：`~/.metame/memory/decisions/`、`~/.metame/memory/lessons/`
+- 知识胶囊：`~/.metame/memory/capsules/`
+- 复盘文档：`~/.metame/memory/postmortems/`
+- **Agent Soul 层**：`~/.metame/agents/<agent_id>/`
+  - `agent.yaml` — id / name / engine / aliases
+  - `soul.md` — 身份定义（主文件，项目目录的 SOUL.md 是其链接）
+  - `memory-snapshot.md` — 近期记忆快照（注入 session prompt）
+  - 项目视图：`<cwd>/SOUL.md`（symlink/hardlink/copy）、`<cwd>/MEMORY.md`（同）
+  - `<cwd>/AGENTS.md` — Codex 专用，每次新 session 由 daemon 合并 CLAUDE.md + SOUL.md 写入
+
+## 诊断顺序（推荐）
+
+1. 先看配置：`~/.metame/daemon.yaml` 与 `scripts/daemon-default.yaml`
+2. 再看命令入口：`scripts/daemon-admin-commands.js`、`scripts/daemon-command-router.js`、`scripts/daemon-exec-commands.js`
+3. 再看执行链路：`scripts/daemon-engine-runtime.js` → `scripts/daemon-claude-engine.js` → `scripts/mentor-engine.js`
+4. 最后看离线任务：`scripts/distill.js`、`scripts/memory-extract.js`、`scripts/memory-nightly-reflect.js`
+
+## 同步提示
+
+- 每次改 `scripts/` 后执行：`npm run sync:plugin`
+- plugin 镜像路径：`plugin/scripts/*`

package/scripts/feishu-adapter.js

@@ -10,15 +10,40 @@ const fs = require('fs');
 const path = require('path');
 
 let Lark;
-try {
-  Lark = require('@larksuiteoapi/node-sdk');
-} catch {
+function _tryRequireLark() {
+  // 1. local node_modules (dev environment)
+  try { return require('@larksuiteoapi/node-sdk'); } catch {}
+  // 2. METAME_ROOT/node_modules (packaged metame-cli)
   const metameRoot = process.env.METAME_ROOT;
   if (metameRoot) {
-    Lark = require(require('path').join(metameRoot, 'node_modules', '@larksuiteoapi/node-sdk'));
+    try { return require(path.join(metameRoot, 'node_modules', '@larksuiteoapi/node-sdk')); } catch {}
   }
-  if (!Lark) {
-    console.error('Cannot find @larksuiteoapi/node-sdk. Run: npm install @larksuiteoapi/node-sdk');
+  // 3. ~/.metame/node_modules (auto-installed for new users)
+  const home = process.env.HOME || process.env.USERPROFILE;
+  if (home) {
+    try { return require(path.join(home, '.metame', 'node_modules', '@larksuiteoapi', 'node-sdk')); } catch {}
+  }
+  return null;
+}
+Lark = _tryRequireLark();
+if (!Lark) {
+  // Auto-install into ~/.metame so new users never see this error
+  const home = process.env.HOME || process.env.USERPROFILE;
+  const prefix = home ? path.join(home, '.metame') : null;
+  if (prefix) {
+    console.log('[feishu] @larksuiteoapi/node-sdk not found, auto-installing into ~/.metame ...');
+    const { execSync } = require('child_process');
+    try {
+      execSync(`npm install @larksuiteoapi/node-sdk --prefix "${prefix}" --silent`, { stdio: 'inherit' });
+      Lark = require(path.join(prefix, 'node_modules', '@larksuiteoapi', 'node-sdk'));
+      console.log('[feishu] SDK installed successfully.');
+    } catch (e) {
+      console.error('[feishu] Auto-install failed:', e.message);
+      console.error('Manual fix: npm install @larksuiteoapi/node-sdk --prefix ~/.metame');
+      process.exit(1);
+    }
+  } else {
+    console.error('[feishu] Cannot find @larksuiteoapi/node-sdk and HOME is not set.');
     process.exit(1);
   }
 }
@@ -26,12 +51,11 @@ try {
 // Timeout wrapper: prevents SDK calls from hanging indefinitely when
 // Feishu's token refresh HTTP request has no response (e.g. network down)
 function withTimeout(promise, ms = 10000) {
-  return Promise.race([
-    promise,
-    new Promise((_, reject) =>
-      setTimeout(() => reject(new Error(`Feishu API timeout after ${ms}ms`)), ms)
-    ),
-  ]);
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`Feishu API timeout after ${ms}ms`)), ms);
+  });
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
 
 // Max chars per lark_md element (Feishu limit ~4000)
@@ -416,10 +440,15 @@ function createBot(config) {
               const chatId = data.open_chat_id || data.chat_id
                 || (data.context && data.context.open_chat_id)
                 || (data.event && data.event.open_chat_id);
+              const senderId = (data.operator && data.operator.open_id)
+                || (data.open_id)
+                || (data.user && data.user.open_id)
+                || (data.context && data.context.open_id)
+                || null;
               if (action && chatId) {
                 const cmd = action.value && action.value.cmd;
                 if (cmd) {
-                  Promise.resolve().then(() => onMessage(chatId, cmd, data)).catch((err) => {
+                  Promise.resolve().then(() => onMessage(chatId, cmd, data, null, senderId)).catch((err) => {
                   try { console.error(`[feishu-adapter] card action error: ${err && err.message || err}`); } catch { }
                 });
                 }

package/scripts/hooks/stop-session-capture.js

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+
+/**
+ * MetaMe Stop Hook — Session Event Logger + Tool Failure Capture
+ *
+ * Runs as a Claude Code "Stop" hook.
+ * On each turn end:
+ *   1. Appends a lightweight session event to session_events.jsonl
+ *   2. Reads the tail of the transcript file to extract tool failures (is_error: true)
+ *      and appends them to skill_signals.jsonl
+ *
+ * Performance target: < 50ms total. Only reads last TAIL_BYTES of transcript.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const METAME_DIR = path.join(os.homedir(), '.metame');
+const SESSION_EVENTS = path.join(METAME_DIR, 'session_events.jsonl');
+const SKILL_SIGNALS = path.join(METAME_DIR, 'skill_signals.jsonl');
+
+// Only read the last N bytes of the transcript to stay under 50ms.
+// 20KB covers ~10-20 conversation turns — enough to capture recent failures.
+const TAIL_BYTES = 20 * 1024;
+
+// Cap signal file sizes to prevent unbounded growth.
+const MAX_SESSION_EVENTS_LINES = 2000;
+const MAX_SKILL_SIGNALS_LINES = 500;
+
+// Deduplicate: remember tool_use_ids we already captured (within this invocation).
+// Cross-invocation dedup uses the session_events timestamp as a watermark.
+const capturedIds = new Set();
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    const now = new Date().toISOString();
+
+    fs.mkdirSync(METAME_DIR, { recursive: true });
+
+    // ── 1. Session event (lightweight metadata) ──
+    const sessionEntry = {
+      ts: now,
+      session_id: data.session_id || null,
+      cwd: data.cwd || null,
+      hint: (data.last_assistant_message || '').slice(0, 200),
+    };
+    appendWithCap(SESSION_EVENTS, sessionEntry, MAX_SESSION_EVENTS_LINES);
+
+    // ── 2. Tool failure extraction from transcript tail ──
+    const transcriptPath = data.transcript_path;
+    if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+      process.exit(0);
+    }
+
+    const stat = fs.statSync(transcriptPath);
+    if (stat.size === 0) {
+      process.exit(0);
+    }
+
+    const readSize = Math.min(stat.size, TAIL_BYTES);
+    const buf = Buffer.alloc(readSize);
+    const fd = fs.openSync(transcriptPath, 'r');
+    try {
+      fs.readSync(fd, buf, 0, readSize, Math.max(0, stat.size - readSize));
+    } finally {
+      fs.closeSync(fd);
+    }
+
+    const tail = buf.toString('utf8');
+    // The first line may be truncated (we read from mid-file), skip it.
+    const lines = tail.split('\n');
+    if (lines.length > 1) {
+      lines.shift();
+    }
+
+    // Single-pass: build tool_use_id → tool_name map + collect error signals.
+    const toolNameMap = new Map();
+    const newSignals = [];
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        const msg = entry.message;
+        if (!msg || !Array.isArray(msg.content)) continue;
+
+        for (const block of msg.content) {
+          // Index tool_use entries for name lookup.
+          if (block.type === 'tool_use' && block.id) {
+            toolNameMap.set(block.id, block.name || 'unknown');
+          }
+          // Collect tool failures.
+          if (
+            block.type === 'tool_result' &&
+            block.is_error === true &&
+            block.tool_use_id &&
+            !capturedIds.has(block.tool_use_id)
+          ) {
+            capturedIds.add(block.tool_use_id);
+
+            const errorContent = typeof block.content === 'string'
+              ? block.content
+              : Array.isArray(block.content)
+                ? block.content.map(c => (typeof c === 'string' ? c : c.text || '')).join('\n')
+                : JSON.stringify(block.content);
+
+            newSignals.push({
+              ts: now,
+              type: 'tool_failure',
+              tool_use_id: block.tool_use_id,
+              error: errorContent.slice(0, 500),
+              session_id: data.session_id || null,
+              cwd: data.cwd || null,
+            });
+          }
+        }
+      } catch {
+        // Skip malformed lines (expected for the first truncated line).
+      }
+    }
+
+    // Resolve tool names from the map built in the same pass.
+    for (const signal of newSignals) {
+      signal.tool = toolNameMap.get(signal.tool_use_id) || 'unknown';
+    }
+
+    // Only load watermark and write signals if there are failures to process.
+    if (newSignals.length > 0) {
+      const watermark = loadWatermark(data.session_id);
+      const fresh = watermark
+        ? newSignals.filter(s => !watermark.has(s.tool_use_id))
+        : newSignals;
+
+      if (fresh.length > 0) {
+        // Batch append: single write for all signals.
+        const batch = fresh.map(s => JSON.stringify(s)).join('\n') + '\n';
+        fs.appendFileSync(SKILL_SIGNALS, batch);
+        capFileIfNeeded(SKILL_SIGNALS, MAX_SKILL_SIGNALS_LINES);
+        saveWatermark(data.session_id, capturedIds);
+      }
+    }
+
+    // Probabilistic cleanup of stale watermark files (1 in 50 invocations).
+    if (Math.random() < 0.02) {
+      cleanOldWatermarks(7 * 24 * 60 * 60 * 1000);
+    }
+
+  } catch (e) {
+    // Never block the user's workflow. Log to stderr for diagnostics.
+    try { process.stderr.write(`[metame-stop-hook] ${e.message}\n`); } catch {}
+  }
+  process.exit(0);
+});
+
+/**
+ * Append a JSON entry to a file, then check cap.
+ */
+function appendWithCap(filePath, entry, maxLines) {
+  fs.appendFileSync(filePath, JSON.stringify(entry) + '\n');
+  capFileIfNeeded(filePath, maxLines);
+}
+
+/**
+ * Amortized cap check: only trim when file size suggests overflow.
+ */
+function capFileIfNeeded(filePath, maxLines) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (stat.size > maxLines * 250) {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const allLines = content.split('\n').filter(Boolean);
+      if (allLines.length > maxLines) {
+        fs.writeFileSync(filePath, allLines.slice(-maxLines).join('\n') + '\n');
+      }
+    }
+  } catch {
+    // Non-fatal.
+  }
+}
+
+/**
+ * Delete watermark files older than maxAge (ms).
+ */
+function cleanOldWatermarks(maxAge) {
+  const wmDir = path.join(METAME_DIR, '.hook_watermarks');
+  try {
+    const now = Date.now();
+    for (const file of fs.readdirSync(wmDir)) {
+      if (!file.endsWith('.json')) continue;
+      const filePath = path.join(wmDir, file);
+      try {
+        const age = now - fs.statSync(filePath).mtimeMs;
+        if (age > maxAge) fs.unlinkSync(filePath);
+      } catch { /* skip individual file errors */ }
+    }
+  } catch { /* wmDir doesn't exist yet — normal */ }
+}
+
+/**
+ * Load watermark (set of captured tool_use_ids) for a session.
+ * Stored as a simple JSON file per session to avoid cross-turn duplicates.
+ */
+function loadWatermark(sessionId) {
+  if (!sessionId) return null;
+  const wmPath = path.join(METAME_DIR, '.hook_watermarks', `${sessionId}.json`);
+  try {
+    const data = JSON.parse(fs.readFileSync(wmPath, 'utf8'));
+    return new Set(data.ids || []);
+  } catch {
+    return null;
+  }
+}
+
+function saveWatermark(sessionId, ids) {
+  if (!sessionId) return;
+  const wmDir = path.join(METAME_DIR, '.hook_watermarks');
+  fs.mkdirSync(wmDir, { recursive: true });
+  const wmPath = path.join(wmDir, `${sessionId}.json`);
+
+  // Merge with existing watermark.
+  let existing = new Set();
+  try {
+    const data = JSON.parse(fs.readFileSync(wmPath, 'utf8'));
+    existing = new Set(data.ids || []);
+  } catch {
+    // New watermark.
+  }
+
+  for (const id of ids) {
+    existing.add(id);
+  }
+
+  // Cap watermark size (keep last 200 IDs).
+  const allIds = [...existing];
+  const capped = allIds.length > 200 ? allIds.slice(-200) : allIds;
+
+  fs.writeFileSync(wmPath, JSON.stringify({ ids: capped, updated: new Date().toISOString() }));
+}

package/scripts/memory-extract.js

@@ -7,7 +7,7 @@
  * into memory.db. Runs independently of raw_signals.jsonl so that
  * pure technical sessions (no preference signals) are still captured.
  *
- * Designed to run as a standalone heartbeat task every 30 minutes.
+ * Designed to run as a standalone heartbeat task (default interval: 4h).
  */
 
 'use strict';
@@ -43,7 +43,15 @@ const FACT_EXTRACTION_PROMPT = `你是精准的知识提取引擎。从以下会
 {
   "session_name": "用3-5个词极其精简地概括这起会话的主题（例如：优化微信登录架构、排查Redis连接泄漏、配置Nginx反向代理）",
   "facts": [
-    {"entity":"主体(点号层级如MetaMe.daemon.askClaude)","relation":"类型","value":"脱离上下文可独立理解的一句话","confidence":"high或medium","tags":["最多3个标签"]}
+    {
+      "entity":"主体(点号层级如MetaMe.daemon.askClaude)",
+      "relation":"类型",
+      "value":"脱离上下文可独立理解的一句话",
+      "confidence":"high或medium",
+      "tags":["最多3个标签"],
+      "concepts":["最多3个抽象概念标签，如流量控制/背压/解耦"],
+      "domain":"可选领域标签，如backend/frontend/devops"
+    }
   ]
 }
 
@@ -53,6 +61,7 @@ const FACT_EXTRACTION_PROMPT = `你是精准的知识提取引擎。从以下会
 - value长度20-200字
 - entity用英文点号路径，value可用中文
 - medium confidence必须有非空tags
+- concepts 可为空；若存在，最多3个，必须是抽象概念词而非文件名
 - 优先引用证据里的具体锚点（文件名、命令、报错关键词）；没有锚点时不要硬编
 - 没有值得提取的事实时 facts 返回 []
 
@@ -98,6 +107,68 @@ function saveSessionTag(sessionId, sessionName, facts) {
   }
 }
 
+function normalizeConceptList(input) {
+  if (!Array.isArray(input)) return [];
+  const out = [];
+  const seen = new Set();
+  for (const raw of input) {
+    const v = String(raw || '').trim();
+    if (!v || v.length > 40) continue;
+    if (seen.has(v)) continue;
+    seen.add(v);
+    out.push(v);
+    if (out.length >= 3) break;
+  }
+  return out;
+}
+
+function normalizeDomain(input) {
+  const v = String(input || '').trim();
+  if (!v) return null;
+  return v.length > 40 ? v.slice(0, 40) : v;
+}
+
+function factFingerprint(fact) {
+  if (!fact || typeof fact !== 'object') return '';
+  const entity = String(fact.entity || '').trim();
+  const relation = String(fact.relation || '').trim();
+  const value = String(fact.value || '').trim().slice(0, 100);
+  if (!entity || !relation || !value) return '';
+  return `${entity}||${relation}||${value}`;
+}
+
+function buildFactLabelRows(extractedFacts, savedFacts) {
+  const source = Array.isArray(extractedFacts) ? extractedFacts : [];
+  const saved = Array.isArray(savedFacts) ? savedFacts : [];
+  if (source.length === 0 || saved.length === 0) return [];
+
+  const byFp = new Map();
+  for (const fact of source) {
+    const fp = factFingerprint(fact);
+    if (!fp) continue;
+    if (!byFp.has(fp)) byFp.set(fp, fact);
+  }
+
+  const rows = [];
+  const dedup = new Set();
+  for (const sf of saved) {
+    const fp = factFingerprint(sf);
+    if (!fp) continue;
+    const src = byFp.get(fp);
+    if (!src) continue;
+    const concepts = normalizeConceptList(src.concepts);
+    if (concepts.length === 0) continue;
+    const domain = normalizeDomain(src.domain);
+    for (const label of concepts) {
+      const rowKey = `${sf.id}::${label}`;
+      if (dedup.has(rowKey)) continue;
+      dedup.add(rowKey);
+      rows.push({ fact_id: sf.id, label, domain });
+    }
+  }
+  return rows;
+}
+
 const VAGUE_PATTERNS = [
   /^用户(问|提|说|提到)/, /^我们(讨论|分析|查看)/,
   /这个问题/, /上面(提到|说的|的)/, /可能是因为/,
@@ -144,7 +215,13 @@ async function extractFacts(skeleton, evidence, distillEnv) {
     return true;
   });
 
-  return { ok: true, facts: filteredFacts, session_name };
+  const normalizedFacts = filteredFacts.map(f => ({
+    ...f,
+    concepts: normalizeConceptList(f.concepts),
+    domain: normalizeDomain(f.domain),
+  }));
+
+  return { ok: true, facts: normalizedFacts, session_name };
 }
 
 /**
@@ -235,16 +312,25 @@ async function run() {
           const fallbackScope = skeleton.session_id
             ? `sess_${String(skeleton.session_id).replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 24)}`
             : null;
-          const { saved, skipped, superseded } = memory.saveFacts(
+          const { saved, skipped, superseded, savedFacts } = memory.saveFacts(
             skeleton.session_id,
             skeleton.project || 'unknown',
             facts,
             { scope: skeleton.project_id || fallbackScope }
           );
+          let labelsSaved = 0;
+          if (typeof memory.saveFactLabels === 'function' && Array.isArray(savedFacts) && savedFacts.length > 0) {
+            const labelRows = buildFactLabelRows(facts, savedFacts);
+            if (labelRows.length > 0) {
+              const labelResult = memory.saveFactLabels(labelRows);
+              labelsSaved = Number(labelResult && labelResult.saved) || 0;
+            }
+          }
           totalSaved += saved;
           totalSkipped += skipped;
           const superMsg = superseded > 0 ? `, ${superseded} superseded` : '';
-          console.log(`[memory-extract] Session ${skeleton.session_id.slice(0, 8)}: ${saved} facts saved, ${skipped} skipped${superMsg}`);
+          const labelMsg = labelsSaved > 0 ? `, ${labelsSaved} labels` : '';
+          console.log(`[memory-extract] Session ${skeleton.session_id.slice(0, 8)}: ${saved} facts saved, ${skipped} skipped${superMsg}${labelMsg}`);
         } else {
           console.log(`[memory-extract] Session ${skeleton.session_id.slice(0, 8)} (${session_name}): no facts extracted`);
         }
@@ -270,10 +356,23 @@ async function run() {
 if (require.main === module) {
   run().then(({ sessionsProcessed, factsSaved, factsSkipped }) => {
     console.log(`✅ memory-extract: ${sessionsProcessed} session(s), ${factsSaved} facts saved, ${factsSkipped} skipped`);
+    // Report estimated token usage for daemon budget tracking
+    // Each session processed ≈ 1 callHaiku invocation ≈ 3k tokens
+    const estTokens = sessionsProcessed * 3000;
+    if (estTokens > 0) console.log(`__TOKENS__:${estTokens}`);
   }).catch(e => {
     console.error(`[memory-extract] Fatal: ${e.message}`);
     process.exit(1);
   });
 }
 
-module.exports = { run, extractFacts };
+module.exports = {
+  run,
+  extractFacts,
+  _private: {
+    normalizeConceptList,
+    normalizeDomain,
+    buildFactLabelRows,
+    factFingerprint,
+  },
+};