metame-cli 1.4.33 → 1.5.0

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

@@ -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`);
         }
@@ -276,4 +362,13 @@ if (require.main === module) {
   });
 }
 
-module.exports = { run, extractFacts };
+module.exports = {
+  run,
+  extractFacts,
+  _private: {
+    normalizeConceptList,
+    normalizeDomain,
+    buildFactLabelRows,
+    factFingerprint,
+  },
+};

package/scripts/memory-nightly-reflect.js

@@ -26,15 +26,17 @@ const REFLECT_LOG_FILE = path.join(METAME_DIR, 'memory_reflect_log.jsonl');
 const MEMORY_DIR = path.join(HOME, '.metame', 'memory');
 const DECISIONS_DIR = path.join(MEMORY_DIR, 'decisions');
 const LESSONS_DIR = path.join(MEMORY_DIR, 'lessons');
+const CAPSULES_DIR = path.join(MEMORY_DIR, 'capsules');
 
 // Hot zone thresholds
 const MIN_SEARCH_COUNT = 3;
 const WINDOW_DAYS = 7;
 const MAX_FACTS = 20;
 const LOCK_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+const EXCLUDED_RELATIONS = ['project_milestone', 'synthesized_insight', 'knowledge_capsule', 'bug_lesson'];
 
 // Ensure output directories exist at startup
-[MEMORY_DIR, DECISIONS_DIR, LESSONS_DIR].forEach(d => fs.mkdirSync(d, { recursive: true }));
+[MEMORY_DIR, DECISIONS_DIR, LESSONS_DIR, CAPSULES_DIR].forEach(d => fs.mkdirSync(d, { recursive: true }));
 
 /**
  * Load callHaiku + buildDistillEnv from deployed path, fallback to scripts dir.
@@ -107,18 +109,19 @@ function writeReflectLog(record) {
  * Returns array of plain objects.
  */
 function queryHotFacts(db) {
+  const relationPlaceholders = EXCLUDED_RELATIONS.map(() => '?').join(', ');
   const stmt = db.prepare(`
-    SELECT entity, relation, value, confidence, search_count, created_at
+    SELECT id, entity, relation, value, confidence, search_count, created_at
     FROM facts
     WHERE search_count >= ${MIN_SEARCH_COUNT}
       AND created_at >= datetime('now', '-${WINDOW_DAYS} days')
       AND superseded_by IS NULL
       AND (conflict_status IS NULL OR conflict_status = 'OK')
-      AND relation != 'project_milestone'
+      AND relation NOT IN (${relationPlaceholders})
     ORDER BY search_count DESC, created_at DESC
     LIMIT ${MAX_FACTS}
   `);
-  return stmt.all();
+  return stmt.all(...EXCLUDED_RELATIONS);
 }
 
 /**
@@ -142,6 +145,101 @@ ${sections}
   fs.writeFileSync(filePath, content, 'utf8');
 }
 
+function sanitizeSlug(input, fallback = 'capsule') {
+  const v = String(input || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9\u4e00-\u9fff_-]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+  if (!v) return fallback;
+  return v.slice(0, 50);
+}
+
+function stripMd(text) {
+  return String(text || '').replace(/[#*_`>\[\]\(\)]/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
+function buildSynthesizedFacts(today, decisions, lessons) {
+  const all = []
+    .concat(Array.isArray(decisions) ? decisions : [])
+    .concat(Array.isArray(lessons) ? lessons : []);
+  const out = [];
+  for (const item of all) {
+    const title = String(item && item.title ? item.title : '').trim();
+    const content = String(item && item.content ? item.content : '').trim();
+    if (!title || !content) continue;
+    const value = stripMd(`${title}: ${content}`).slice(0, 280);
+    if (value.length < 20) continue;
+    out.push({
+      entity: `nightly.reflect.${today}`,
+      relation: 'synthesized_insight',
+      value,
+      confidence: 'high',
+      tags: ['nightly', 'reflection'],
+    });
+  }
+  return out;
+}
+
+function entityPrefix(entity) {
+  const src = String(entity || '').trim();
+  if (!src) return '';
+  const parts = src.split('.').map(s => s.trim()).filter(Boolean);
+  if (parts.length === 0) return '';
+  if (parts.length === 1) return parts[0];
+  return `${parts[0]}.${parts[1]}`;
+}
+
+function collectCapsuleGroups(facts, minGroupSize = 3) {
+  const groups = new Map();
+  for (const fact of Array.isArray(facts) ? facts : []) {
+    const prefix = entityPrefix(fact && fact.entity);
+    if (!prefix) continue;
+    if (!groups.has(prefix)) groups.set(prefix, []);
+    groups.get(prefix).push(fact);
+  }
+  return [...groups.entries()]
+    .map(([prefix, items]) => ({ prefix, items }))
+    .filter(g => g.items.length >= minGroupSize)
+    .sort((a, b) => b.items.length - a.items.length);
+}
+
+function parseJsonFromLlm(raw) {
+  const text = String(raw || '');
+  const cleaned = text.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
+  if (!cleaned) return null;
+  try { return JSON.parse(cleaned); } catch { return null; }
+}
+
+function writeCapsuleFile(filePath, capsule, facts, today, prefix) {
+  const related = Array.isArray(capsule.related_concepts) ? capsule.related_concepts.slice(0, 8) : [];
+  const supporting = Array.isArray(capsule.supporting_facts) ? capsule.supporting_facts.slice(0, 8) : [];
+  const content = `---
+date: ${today}
+source: nightly-reflect
+type: knowledge-capsule
+entity_prefix: ${prefix}
+facts_analyzed: ${Array.isArray(facts) ? facts.length : 0}
+---
+
+# ${capsule.title}
+
+## 核心结论
+${capsule.core_conclusion}
+
+## 适用场景
+${capsule.applicable_scenarios}
+
+## 关联概念
+${related.length > 0 ? related.map(x => `- ${x}`).join('\n') : '- (none)'}
+
+## 支撑事实
+${supporting.length > 0 ? supporting.map(x => `- ${x}`).join('\n') : '- (none)'}
+`;
+  fs.writeFileSync(filePath, content, 'utf8');
+}
+
 /**
  * Main nightly reflect run.
  */
@@ -238,12 +336,9 @@ Rules:
     }
 
     // Parse Haiku response
-    let parsed;
-    try {
-      const cleaned = raw.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
-      parsed = JSON.parse(cleaned);
-    } catch (e) {
-      console.log(`[NIGHTLY-REFLECT] Failed to parse Haiku output: ${e.message}`);
+    const parsed = parseJsonFromLlm(raw);
+    if (!parsed || typeof parsed !== 'object') {
+      console.log('[NIGHTLY-REFLECT] Failed to parse Haiku output.');
       writeReflectLog({ status: 'error', reason: 'parse_failed', facts_found: hotFacts.length });
       return;
     }
@@ -265,12 +360,92 @@ Rules:
       console.log(`[NIGHTLY-REFLECT] Lessons written: ${lessonFile}`);
     }
 
+    let synthesizedSaved = 0;
+    let capsulesWritten = 0;
+    let capsuleFactsSaved = 0;
+    let memory = null;
+    try {
+      try { memory = require('./memory'); } catch { /* optional */ }
+
+      // 3B: write distilled insights back into memory.db for closed-loop retrieval.
+      if (memory && typeof memory.saveFacts === 'function') {
+        const synthesizedFacts = buildSynthesizedFacts(today, decisions, lessons);
+        if (synthesizedFacts.length > 0) {
+          const writeRes = memory.saveFacts(`nightly-reflect-${today}`, '*', synthesizedFacts, { scope: '*' });
+          synthesizedSaved = Number(writeRes && writeRes.saved) || 0;
+        }
+      }
+
+      // 3C: knowledge capsule aggregation by entity prefix.
+      const capsuleGroups = collectCapsuleGroups(hotFacts, 3).slice(0, 3);
+      for (const group of capsuleGroups) {
+        const groupFacts = group.items.map(f => ({
+          entity: f.entity,
+          relation: f.relation,
+          value: f.value,
+          search_count: f.search_count,
+        }));
+        const capsulePrompt = `你是知识胶囊生成器。请将同一主题下的事实聚合成结构化胶囊。
+
+entity_prefix: ${group.prefix}
+facts(json): ${JSON.stringify(groupFacts, null, 2).slice(0, 5000)}
+
+输出 JSON：
+{
+  "title":"标题",
+  "core_conclusion":"一句核心结论",
+  "applicable_scenarios":"适用场景（1-2句）",
+  "related_concepts":["概念1","概念2"],
+  "supporting_facts":["支撑点1","支撑点2"]
+}
+
+规则：
+- 只基于输入事实，不虚构
+- 每个字段简洁具体
+- 仅输出 JSON`;
+
+        let capsule = null;
+        try {
+          const rawCapsule = await Promise.race([
+            callHaiku(capsulePrompt, distillEnv, 60000),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 65000)),
+          ]);
+          capsule = parseJsonFromLlm(rawCapsule);
+        } catch { /* non-fatal */ }
+        if (!capsule || !capsule.title || !capsule.core_conclusion || !capsule.applicable_scenarios) continue;
+
+        const capsuleSlug = sanitizeSlug(group.prefix.replace(/\./g, '-'), 'capsule');
+        const capsuleFile = path.join(CAPSULES_DIR, `${capsuleSlug}-${today}.md`);
+        writeCapsuleFile(capsuleFile, capsule, group.items, today, group.prefix);
+        capsulesWritten++;
+
+        if (memory && typeof memory.saveFacts === 'function') {
+          const capsuleValue = stripMd(`${capsule.title}: ${capsule.core_conclusion}`).slice(0, 280);
+          if (capsuleValue.length >= 20) {
+            const saveCapsule = memory.saveFacts(`capsule-${today}-${capsuleSlug}`, '*', [{
+              entity: `capsule.${group.prefix.replace(/\./g, '_')}`,
+              relation: 'knowledge_capsule',
+              value: capsuleValue,
+              confidence: 'high',
+              tags: ['capsule'],
+            }], { scope: '*' });
+            capsuleFactsSaved += Number(saveCapsule && saveCapsule.saved) || 0;
+          }
+        }
+      }
+    } finally {
+      try { if (memory && typeof memory.close === 'function') memory.close(); } catch { /* non-fatal */ }
+    }
+
     // Write audit log
     writeReflectLog({
       status: 'success',
       facts_analyzed: hotFacts.length,
       decisions_written: decisions.length,
       lessons_written: lessons.length,
+      synthesized_insights_saved: synthesizedSaved,
+      capsules_written: capsulesWritten,
+      capsule_facts_saved: capsuleFactsSaved,
       decision_file: decisions.length > 0 ? decisionFile : null,
       lesson_file: lessons.length > 0 ? lessonFile : null,
     });
@@ -296,4 +471,14 @@ if (require.main === module) {
   });
 }
 
-module.exports = { run };
+module.exports = {
+  run,
+  _private: {
+    queryHotFacts,
+    buildSynthesizedFacts,
+    collectCapsuleGroups,
+    entityPrefix,
+    parseJsonFromLlm,
+    EXCLUDED_RELATIONS,
+  },
+};