metame-cli 1.3.23 → 1.4.0

package/scripts/qmd-client.js

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+
+/**
+ * qmd-client.js — QMD (Hybrid Search Engine) integration for MetaMe
+ *
+ * Optional dependency: https://github.com/tobi/qmd
+ * Install: bun install -g github:tobi/qmd
+ *
+ * When QMD is present:
+ *   - Facts are written as markdown files to ~/.metame/facts-docs/
+ *   - searchFacts() uses qmd_deep_search (BM25 + vector + rerank)
+ *   - QMD HTTP daemon stays running for fast model reuse
+ *
+ * When QMD is absent: all calls are no-ops; caller falls back to FTS5.
+ */
+
+'use strict';
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = os.homedir();
+const FACTS_DOCS_DIR = path.join(HOME, '.metame', 'facts-docs');
+const QMD_URL = 'http://localhost:8181';
+const COLLECTION = 'metame-facts';
+
+// ── Availability ───────────────────────────────────────────────────────────
+
+let _available = null;
+function isAvailable() {
+  if (_available !== null) return _available;
+  try {
+    execSync('which qmd', { stdio: 'pipe', timeout: 2000 });
+    _available = true;
+  } catch {
+    _available = false;
+  }
+  return _available;
+}
+
+async function isDaemonRunning() {
+  if (!isAvailable()) return false;
+  try {
+    const res = await fetch(`${QMD_URL}/health`, {
+      signal: AbortSignal.timeout(800),
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+// ── Daemon lifecycle ───────────────────────────────────────────────────────
+
+/**
+ * Start QMD HTTP daemon if not already running.
+ * Returns true if daemon is up after this call.
+ */
+async function startDaemon() {
+  if (!isAvailable()) return false;
+  if (await isDaemonRunning()) return true;
+  try {
+    execSync('qmd mcp --http --daemon', { stdio: 'ignore', timeout: 8000 });
+    // Give it a moment to bind
+    await new Promise(r => setTimeout(r, 1000));
+    return isDaemonRunning();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Stop QMD HTTP daemon. Non-fatal.
+ */
+function stopDaemon() {
+  if (!isAvailable()) return;
+  try {
+    execSync('qmd mcp stop', { stdio: 'ignore', timeout: 3000 });
+  } catch { /* ignore */ }
+}
+
+// ── Collection setup ───────────────────────────────────────────────────────
+
+/**
+ * Ensure facts-docs/ directory and QMD collection exist.
+ * Safe to call multiple times.
+ */
+function ensureCollection() {
+  if (!isAvailable()) return;
+  fs.mkdirSync(FACTS_DOCS_DIR, { recursive: true });
+  try {
+    // --name is idempotent: adding an already-named collection is a no-op
+    execSync(`qmd collection add "${FACTS_DOCS_DIR}" --name "${COLLECTION}"`, {
+      stdio: 'pipe',
+      timeout: 5000,
+    });
+  } catch { /* already exists or QMD error, both ok */ }
+}
+
+// ── Upsert ─────────────────────────────────────────────────────────────────
+
+/**
+ * Convert a fact object to markdown content.
+ * Filename = {id}.md, so the ID is recoverable from search results.
+ */
+function factToMd(fact) {
+  const tags = Array.isArray(fact.tags) ? fact.tags.join(', ') : '';
+  const date = (fact.created_at || '').slice(0, 10) || new Date().toISOString().slice(0, 10);
+  return [
+    `# [${fact.relation}] ${fact.entity}`,
+    '',
+    fact.value,
+    '',
+    `Tags: ${tags}`,
+    `Project: ${fact.project || 'unknown'}`,
+    `Date: ${date}`,
+  ].join('\n');
+}
+
+/**
+ * Write facts as markdown files and trigger async re-embed.
+ * facts must be the array returned by memory.saveFacts (with id field).
+ * Non-fatal: any error is silently ignored.
+ */
+function upsertFacts(facts) {
+  if (!isAvailable() || !Array.isArray(facts) || facts.length === 0) return;
+  try {
+    ensureCollection();
+    for (const f of facts) {
+      if (!f.id) continue;
+      fs.writeFileSync(path.join(FACTS_DOCS_DIR, `${f.id}.md`), factToMd(f), 'utf8');
+    }
+    // Incremental embed: detach so it doesn't block caller
+    const child = spawn('qmd', ['embed'], {
+      detached: true,
+      stdio: 'ignore',
+      cwd: HOME,
+    });
+    child.unref();
+  } catch { /* non-fatal */ }
+}
+
+// ── Search ─────────────────────────────────────────────────────────────────
+
+/**
+ * Search via QMD HTTP daemon (MCP JSON-RPC).
+ * Returns array of fact IDs, or null if unavailable.
+ */
+async function searchViaHttp(query, limit) {
+  try {
+    const res = await fetch(`${QMD_URL}/mcp`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+          name: 'qmd_deep_search',
+          arguments: { query, limit, min_score: 0.3 },
+        },
+      }),
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return parseSearchResult(data?.result?.content);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Search via QMD CLI (slower; models may not be warm).
+ * Returns array of fact IDs, or null on failure.
+ */
+function searchViaCli(query, limit) {
+  if (!isAvailable()) return null;
+  try {
+    // Use `qmd query` for hybrid search (BM25 + vector + rerank, requires models)
+    // Fall back to `qmd search` (BM25 only) if query fails (e.g. models not yet downloaded)
+    let raw;
+    try {
+      raw = execSync(
+        `qmd query ${JSON.stringify(query)} -c "${COLLECTION}" --json -n ${limit}`,
+        { timeout: 30000, encoding: 'utf8', stdio: 'pipe' }
+      );
+    } catch {
+      raw = execSync(
+        `qmd search ${JSON.stringify(query)} -c "${COLLECTION}" --json -n ${limit}`,
+        { timeout: 8000, encoding: 'utf8', stdio: 'pipe' }
+      );
+    }
+    return parseSearchResult(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse QMD JSON output → array of fact IDs extracted from filenames.
+ *
+ * CLI output format: [{"docid": "#abc123", "score": 0.85, "file": "path/to/f-xxx.md"}, ...]
+ * MCP HTTP format: wrapped in data.result.content as stringified JSON
+ */
+function parseSearchResult(raw) {
+  if (!raw) return null;
+  try {
+    // CLI outputs valid JSON directly; MCP may wrap it
+    const text = typeof raw === 'string' ? raw.trim() : JSON.stringify(raw);
+
+    // Try direct parse first
+    let items;
+    try {
+      const parsed = JSON.parse(text);
+      items = Array.isArray(parsed) ? parsed
+        : Array.isArray(parsed?.result) ? parsed.result
+        : null;
+    } catch {
+      // MCP content may embed JSON inside a string — find the last [...] block
+      // Use lastIndexOf to avoid stopping at ] inside titles like "[bug_lesson]"
+      const start = text.lastIndexOf('[');
+      const end = text.lastIndexOf(']');
+      if (start === -1 || end <= start) return null;
+      items = JSON.parse(text.slice(start, end + 1));
+    }
+
+    if (!Array.isArray(items) || items.length === 0) return null;
+
+    const ids = [];
+    for (const item of items) {
+      // QMD returns { file: "qmd://metame-facts/f-abc12345-ts-rand.md", score, docid }
+      const filePath = item.file || item.path || '';
+      // Strip qmd:// virtual path prefix, then get basename
+      const stripped = filePath.replace(/^qmd:\/\/[^/]+\//, '');
+      const basename = path.basename(stripped, '.md');
+      if (basename.startsWith('f-')) {
+        ids.push(basename);
+      }
+    }
+    return ids.length ? ids : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Top-level search: try HTTP daemon → CLI → return null (caller uses FTS5).
+ * @param {string} query
+ * @param {number} limit
+ * @returns {Promise<string[]|null>} Array of fact IDs, or null
+ */
+async function search(query, limit = 5) {
+  if (!isAvailable()) return null;
+
+  // Try HTTP daemon first (models warm, fast)
+  if (await isDaemonRunning()) {
+    const ids = await searchViaHttp(query, limit);
+    if (ids) return ids;
+  }
+
+  // Fall back to CLI
+  return searchViaCli(query, limit);
+}
+
+module.exports = {
+  isAvailable,
+  isDaemonRunning,
+  startDaemon,
+  stopDaemon,
+  ensureCollection,
+  upsertFacts,
+  search,
+};

package/scripts/schema.js

@@ -17,67 +17,64 @@
 
 const SCHEMA = {
   // === T1: Identity (USER's identity, not agent's) ===
-  'identity.role':            { tier: 'T1', type: 'string', locked: false },
-  'identity.locale':          { tier: 'T1', type: 'string', locked: true },
+  'identity.role': { tier: 'T1', type: 'string', locked: false },
+  'identity.locale': { tier: 'T1', type: 'string', locked: true },
 
   // === T2: Core Values / Traits ===
-  'core_values.*':            { tier: 'T2', type: 'string', locked: true },
-  'core_traits.crisis_reflex':   { tier: 'T2', type: 'enum', locked: true, values: ['Action', 'Analysis', 'Delegation', 'Freeze'] },
-  'core_traits.flow_trigger':    { tier: 'T2', type: 'enum', locked: true, values: ['Ideation', 'Execution', 'Teaching', 'Debugging'] },
-  'core_traits.shadow_self':     { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
-  'core_traits.learning_style':  { tier: 'T2', type: 'enum', locked: true, values: ['Hands-on', 'Conceptual', 'Social', 'Reflective'] },
+  'core_values.*': { tier: 'T2', type: 'string', locked: true },
+  'core_traits.crisis_reflex': { tier: 'T2', type: 'enum', locked: true, values: ['Action', 'Analysis', 'Delegation', 'Freeze'] },
+  'core_traits.flow_trigger': { tier: 'T2', type: 'enum', locked: true, values: ['Ideation', 'Execution', 'Teaching', 'Debugging'] },
+  'core_traits.shadow_self': { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
+  'core_traits.learning_style': { tier: 'T2', type: 'enum', locked: true, values: ['Hands-on', 'Conceptual', 'Social', 'Reflective'] },
   'core_traits.north_star.aspiration': { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
-  'core_traits.north_star.realistic':  { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
+  'core_traits.north_star.realistic': { tier: 'T2', type: 'string', locked: true, maxChars: 80 },
 
   // === T3: Preferences ===
-  'preferences.code_style':       { tier: 'T3', type: 'enum', values: ['concise', 'verbose', 'documented'] },
-  'preferences.communication':    { tier: 'T3', type: 'enum', values: ['direct', 'gentle', 'socratic'] },
-  'preferences.language_mix':     { tier: 'T3', type: 'enum', values: ['zh-only', 'en-only', 'zh-main-en-term', 'code-switch'] },
+  'preferences.code_style': { tier: 'T3', type: 'enum', values: ['concise', 'verbose', 'documented'] },
+  'preferences.communication': { tier: 'T3', type: 'enum', values: ['direct', 'gentle', 'socratic'] },
+  'preferences.language_mix': { tier: 'T3', type: 'enum', values: ['zh-only', 'en-only', 'zh-main-en-term', 'code-switch'] },
   'preferences.tech_terms_language': { tier: 'T3', type: 'enum', values: ['zh', 'en'] },
   'preferences.code_comments_language': { tier: 'T3', type: 'enum', values: ['zh', 'en', null] },
   'preferences.explanation_depth': { tier: 'T3', type: 'enum', values: ['result_only', 'brief_rationale', 'deep_dive'] },
   'preferences.interaction_tempo': { tier: 'T3', type: 'enum', values: ['batch', 'incremental'] },
-  'preferences.tools':            { tier: 'T3', type: 'array', maxItems: 10 },
-  'preferences.anti_patterns':    { tier: 'T3', type: 'array', maxItems: 5 },
+  'preferences.tools': { tier: 'T3', type: 'array', maxItems: 10 },
 
   // === T3b: Cognition ===
-  'cognition.decision_style':               { tier: 'T3', type: 'enum', values: ['intuitive', 'analytical', 'adaptive'] },
-  'cognition.info_processing.entry_point':  { tier: 'T3', type: 'enum', values: ['big_picture', 'details', 'examples'] },
+  'cognition.decision_style': { tier: 'T3', type: 'enum', values: ['intuitive', 'analytical', 'adaptive'] },
+  'cognition.info_processing.entry_point': { tier: 'T3', type: 'enum', values: ['big_picture', 'details', 'examples'] },
   'cognition.info_processing.preferred_format': { tier: 'T3', type: 'enum', values: ['structured', 'narrative', 'visual_metaphor'] },
-  'cognition.abstraction.default_level':    { tier: 'T3', type: 'enum', values: ['strategic', 'architectural', 'implementation', 'operational'] },
-  'cognition.abstraction.range':            { tier: 'T3', type: 'enum', values: ['narrow', 'wide'] },
-  'cognition.cognitive_load.chunk_size':    { tier: 'T3', type: 'enum', values: ['small', 'medium', 'large'] },
+  'cognition.abstraction.default_level': { tier: 'T3', type: 'enum', values: ['strategic', 'architectural', 'implementation', 'operational'] },
+  'cognition.abstraction.range': { tier: 'T3', type: 'enum', values: ['narrow', 'wide'] },
+  'cognition.cognitive_load.chunk_size': { tier: 'T3', type: 'enum', values: ['small', 'medium', 'large'] },
   'cognition.cognitive_load.preferred_response_length': { tier: 'T3', type: 'enum', values: ['concise', 'moderate', 'comprehensive'] },
-  'cognition.motivation.primary_driver':    { tier: 'T3', type: 'enum', values: ['autonomy', 'competence', 'meaning', 'social_proof'] },
-  'cognition.motivation.energy_source':     { tier: 'T3', type: 'enum', values: ['creation', 'optimization', 'problem_solving', 'teaching'] },
+  'cognition.motivation.primary_driver': { tier: 'T3', type: 'enum', values: ['autonomy', 'competence', 'meaning', 'social_proof'] },
+  'cognition.motivation.energy_source': { tier: 'T3', type: 'enum', values: ['creation', 'optimization', 'problem_solving', 'teaching'] },
   'cognition.metacognition.self_awareness': { tier: 'T3', type: 'enum', values: ['high', 'medium', 'low'] },
   'cognition.metacognition.receptive_to_challenge': { tier: 'T3', type: 'enum', values: ['yes', 'sometimes', 'no'] },
 
   // === T4: Context ===
-  'context.focus':             { tier: 'T4', type: 'string', maxChars: 80 },
-  'context.focus_since':       { tier: 'T4', type: 'string' },
-  'context.active_projects':   { tier: 'T4', type: 'array', maxItems: 5 },
-  'context.blockers':          { tier: 'T4', type: 'array', maxItems: 3 },
-  'context.energy':            { tier: 'T4', type: 'enum', values: ['high', 'medium', 'low', null] },
-  'context.milestones':        { tier: 'T4', type: 'array', maxItems: 3 },
-  'context.anti_patterns':     { tier: 'T4', type: 'array', maxItems: 5 },
-  'status.focus':              { tier: 'T4', type: 'string', maxChars: 80 },
-  'status.language':           { tier: 'T4', type: 'string' },
+  'context.focus': { tier: 'T4', type: 'string', maxChars: 80 },
+  'context.focus_since': { tier: 'T4', type: 'string' },
+  'context.active_projects': { tier: 'T4', type: 'array', maxItems: 5 },
+  'context.blockers': { tier: 'T4', type: 'array', maxItems: 3 },
+  'context.energy': { tier: 'T4', type: 'enum', values: ['high', 'medium', 'low', null] },
+  'status.focus': { tier: 'T4', type: 'string', maxChars: 80 },
+  'status.language': { tier: 'T4', type: 'string' },
 
   // === T5: Evolution (system-managed) ===
-  'evolution.last_distill':    { tier: 'T5', type: 'string' },
-  'evolution.distill_count':   { tier: 'T5', type: 'number' },
-  'evolution.recent_changes':  { tier: 'T5', type: 'array', maxItems: 5 },
-  'evolution.auto_distill':    { tier: 'T5', type: 'array', maxItems: 10 },
+  'evolution.last_distill': { tier: 'T5', type: 'string' },
+  'evolution.distill_count': { tier: 'T5', type: 'number' },
+  'evolution.recent_changes': { tier: 'T5', type: 'array', maxItems: 5 },
+  'evolution.auto_distill': { tier: 'T5', type: 'array', maxItems: 10 },
 
   // === T5: Growth (metacognition, system-managed) ===
-  'growth.patterns':              { tier: 'T5', type: 'array', maxItems: 3 },
-  'growth.zone_history':          { tier: 'T5', type: 'array', maxItems: 10 },
-  'growth.reflections_answered':  { tier: 'T5', type: 'number' },
-  'growth.reflections_skipped':   { tier: 'T5', type: 'number' },
-  'growth.last_reflection':       { tier: 'T5', type: 'string' },
-  'growth.quiet_until':           { tier: 'T5', type: 'string' },
-  'growth.mirror_enabled':        { tier: 'T5', type: 'boolean' },
+  'growth.patterns': { tier: 'T5', type: 'array', maxItems: 3 },
+  'growth.zone_history': { tier: 'T5', type: 'array', maxItems: 10 },
+  'growth.reflections_answered': { tier: 'T5', type: 'number' },
+  'growth.reflections_skipped': { tier: 'T5', type: 'number' },
+  'growth.last_reflection': { tier: 'T5', type: 'string' },
+  'growth.quiet_until': { tier: 'T5', type: 'string' },
+  'growth.mirror_enabled': { tier: 'T5', type: 'boolean' },
 };
 
 /**

package/scripts/session-analytics.js

@@ -35,12 +35,15 @@ function loadState() {
  * Save analytics state.
  */
 function saveState(state) {
-  // Cap entries
-  const keys = Object.keys(state.analyzed);
-  if (keys.length > MAX_STATE_ENTRIES) {
-    const sorted = keys.sort((a, b) => (state.analyzed[a] || 0) - (state.analyzed[b] || 0));
-    const toRemove = sorted.slice(0, keys.length - MAX_STATE_ENTRIES);
-    for (const k of toRemove) delete state.analyzed[k];
+  // Cap entries for both tracking keys
+  for (const key of ['analyzed', 'facts_analyzed']) {
+    if (!state[key]) continue;
+    const keys = Object.keys(state[key]);
+    if (keys.length > MAX_STATE_ENTRIES) {
+      const sorted = keys.sort((a, b) => (state[key][a] || 0) - (state[key][b] || 0));
+      const toRemove = sorted.slice(0, keys.length - MAX_STATE_ENTRIES);
+      for (const k of toRemove) delete state[key][k];
+    }
   }
   const dir = path.dirname(STATE_FILE);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
@@ -307,7 +310,7 @@ function findAllUnanalyzedSessions(limit = 30) {
 }
 
 /**
- * Mark a session as analyzed.
+ * Mark a session as analyzed (cognitive distill / pattern detection).
  */
 function markAnalyzed(sessionId) {
   const state = loadState();
@@ -315,6 +318,58 @@ function markAnalyzed(sessionId) {
   saveState(state);
 }
 
+/**
+ * Find all sessions not yet processed by memory-extract (facts extraction).
+ * Uses a separate `facts_analyzed` key so distill and memory-extract don't interfere.
+ */
+function findAllUnextractedSessions(limit = 30) {
+  const state = loadState();
+  const factsAnalyzed = state.facts_analyzed || {};
+  const results = [];
+
+  try {
+    const projectDirs = fs.readdirSync(PROJECTS_ROOT);
+    for (const dir of projectDirs) {
+      const fullDir = path.join(PROJECTS_ROOT, dir);
+      let stat;
+      try { stat = fs.statSync(fullDir); } catch { continue; }
+      if (!stat.isDirectory()) continue;
+
+      let files;
+      try { files = fs.readdirSync(fullDir); } catch { continue; }
+
+      for (const file of files) {
+        if (!file.endsWith('.jsonl')) continue;
+        const sessionId = file.replace('.jsonl', '');
+        if (factsAnalyzed[sessionId]) continue;
+
+        const fullPath = path.join(fullDir, file);
+        let fstat;
+        try { fstat = fs.statSync(fullPath); } catch { continue; }
+
+        if (fstat.size > MAX_FILE_SIZE || fstat.size < MIN_FILE_SIZE) continue;
+
+        results.push({ path: fullPath, session_id: sessionId, mtime: fstat.mtimeMs });
+      }
+    }
+  } catch {
+    return [];
+  }
+
+  results.sort((a, b) => b.mtime - a.mtime);
+  return results.slice(0, limit);
+}
+
+/**
+ * Mark a session as facts-extracted (used by memory-extract, independent of markAnalyzed).
+ */
+function markFactsExtracted(sessionId) {
+  const state = loadState();
+  if (!state.facts_analyzed) state.facts_analyzed = {};
+  state.facts_analyzed[sessionId] = Date.now();
+  saveState(state); // saveState() caps both analyzed and facts_analyzed
+}
+
 /**
  * Read declared goals from the user's profile.
  * Returns a compact string like "DECLARED_GOALS: focus1 | focus2" (~11 tokens).
@@ -410,11 +465,13 @@ function summarizeSession(skeleton, jsonlPath) {
 module.exports = {
   findLatestUnanalyzedSession,
   findAllUnanalyzedSessions,
+  findAllUnextractedSessions,
   extractSkeleton,
   formatForPrompt,
   formatGoalContext,
   summarizeSession,
   markAnalyzed,
+  markFactsExtracted,
 };
 
 // Direct execution for testing

package/scripts/session-summarize.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * session-summarize.js <chatId> <sessionId>
+ * Generates a 3-5 sentence summary for an idle session via Haiku,
+ * stores it in daemon_state.json for injection on next resume.
+ *
+ * Uses session-analytics.extractSkeleton() for robust JSONL parsing
+ * (handles tool_use, artifacts, empty chunks without crashing).
+ */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const [,, chatId, sessionId] = process.argv;
+if (!chatId || !sessionId) {
+  console.error('Usage: session-summarize.js <chatId> <sessionId>');
+  process.exit(1);
+}
+
+const HOME = os.homedir();
+const METAME_DIR = path.join(HOME, '.metame');
+const STATE_FILE = path.join(METAME_DIR, 'daemon_state.json');
+const CLAUDE_PROJECTS = path.join(HOME, '.claude', 'projects');
+
+function findSessionFile(sid) {
+  try {
+    for (const dir of fs.readdirSync(CLAUDE_PROJECTS)) {
+      const p = path.join(CLAUDE_PROJECTS, dir, `${sid}.jsonl`);
+      if (fs.existsSync(p)) return p;
+    }
+  } catch { /* ignore */ }
+  return null;
+}
+
+function loadState() {
+  try { return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')); } catch { return {}; }
+}
+
+function saveState(state) {
+  try { fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), 'utf8'); } catch { /* ignore */ }
+}
+
+async function main() {
+  const sessionFile = findSessionFile(sessionId);
+  if (!sessionFile) {
+    console.log(`[session-summarize] Session file not found for ${sessionId.slice(0, 8)}`);
+    return;
+  }
+
+  // Use extractSkeleton for robust parsing — already battle-tested on 100+ sessions.
+  // Handles tool_use blocks, artifacts, empty chunks, malformed lines gracefully.
+  let skeleton;
+  try {
+    const analytics = require('./session-analytics');
+    skeleton = analytics.extractSkeleton(sessionFile);
+  } catch (e) {
+    console.log(`[session-summarize] extractSkeleton failed: ${e.message}`);
+    return;
+  }
+
+  const snippets = skeleton.user_snippets || [];
+  if (snippets.length < 2) {
+    console.log(`[session-summarize] Too few user messages (${snippets.length}), skipping`);
+    return;
+  }
+
+  let callHaiku;
+  try {
+    callHaiku = require('./providers').callHaiku;
+  } catch (e) {
+    console.log(`[session-summarize] providers not available: ${e.message}`);
+    return;
+  }
+
+  // Build compact context from skeleton (safe strings, already sliced to 100 chars each)
+  const snippetText = snippets.join('\n- ');
+  const meta = [
+    skeleton.project ? `项目: ${skeleton.project}` : '',
+    skeleton.intent ? `首要意图: ${skeleton.intent}` : '',
+    skeleton.duration_min ? `时长: ${skeleton.duration_min}分钟` : '',
+    skeleton.total_tool_calls ? `工具调用: ${skeleton.total_tool_calls}次` : '',
+  ].filter(Boolean).join('，');
+
+  const prompt = `请用2-4句话简洁总结以下会话的核心内容和关键结论。只说结果和决策，不列举过程。中文输出。
+
+${meta}
+
+用户主要说了什么：
+- ${snippetText}`;
+
+  let summary;
+  try {
+    summary = await Promise.race([
+      callHaiku(prompt, {}, 30000),
+      new Promise((_, r) => setTimeout(() => r(new Error('timeout')), 35000)),
+    ]);
+    summary = (summary || '').trim().slice(0, 500);
+  } catch (e) {
+    console.log(`[session-summarize] Haiku call failed: ${e.message}`);
+    return;
+  }
+
+  if (!summary) return;
+
+  const state = loadState();
+  if (!state.sessions) state.sessions = {};
+  if (!state.sessions[chatId]) state.sessions[chatId] = {};
+  state.sessions[chatId].last_summary = summary;
+  state.sessions[chatId].last_summary_at = Date.now();
+  state.sessions[chatId].last_summary_session_id = sessionId;
+  saveState(state);
+
+  console.log(`[session-summarize] Saved for ${chatId} (${sessionId.slice(0, 8)}): ${summary.slice(0, 80)}...`);
+}
+
+main().catch(e => console.error(`[session-summarize] Fatal: ${e.message}`));

package/scripts/skill-evolution.js

@@ -299,16 +299,7 @@ function checkHotEvolution(signal) {
  * Every N runs, triggers self-evaluation to optimize the policy.
  * Returns { updates, missing_skills } or null if nothing to process.
  */
-function callClaude(input, distillEnv, timeout) {
-  const { execFile } = require('child_process');
-  return new Promise((resolve, reject) => {
-    const proc = execFile('claude', ['-p', '--model', 'haiku', '--no-session-persistence'],
-      { env: { ...process.env, ...distillEnv }, timeout, maxBuffer: 10 * 1024 * 1024 },
-      (err, stdout) => { if (err) reject(err); else resolve(stdout.trim()); });
-    proc.stdin.write(input);
-    proc.stdin.end();
-  });
-}
+const { callHaiku, buildDistillEnv } = require('./providers');
 
 async function distillSkills() {
   let yaml;
@@ -368,12 +359,9 @@ async function distillSkills() {
 
   try {
     let distillEnv = {};
-    try {
-      const { buildDistillEnv } = require('./providers');
-      distillEnv = buildDistillEnv();
-    } catch {}
+    try { distillEnv = buildDistillEnv(); } catch {}
 
-    const result = await callClaude(prompt, distillEnv, 90000);
+    const result = await callHaiku(prompt, distillEnv, 90000);
 
     if (result.includes('NO_EVOLUTION')) {
       clearSignals();
@@ -528,7 +516,7 @@ RULES:
 - Be conservative: only change what the data clearly supports
 - prompt_template changes should be surgical, not full rewrites`;
 
-    const result = await callClaude(evalPrompt, distillEnv, 30000);
+    const result = await callHaiku(evalPrompt, distillEnv, 30000);
 
     if (result.includes('NO_CHANGE')) {
       console.log('🧬 Policy self-eval: no changes needed.');
@@ -790,3 +778,18 @@ module.exports = {
   smartStitch,
   listInstalledSkills,
 };
+
+if (require.main === module) {
+  distillSkills()
+    .then(r => {
+      if (r && r.updates && r.updates.length) {
+        console.log(`Skill evolution: ${r.updates.length} update(s) applied`);
+      } else {
+        console.log('Skill evolution: no updates');
+      }
+    })
+    .catch(e => {
+      console.error('Skill evolution error:', e.message);
+      process.exit(1);
+    });
+}