metame-cli 1.3.10 → 1.3.12

package/README.md

@@ -4,6 +4,17 @@
   <img src="./logo.png" alt="MetaMe Logo" width="200"/>
 </p>
 
+<p align="center">
+  <a href="https://www.npmjs.com/package/metame-cli"><img src="https://img.shields.io/npm/v/metame-cli.svg" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/metame-cli"><img src="https://img.shields.io/npm/dm/metame-cli.svg" alt="npm downloads"></a>
+  <a href="https://nodejs.org"><img src="https://img.shields.io/node/v/metame-cli.svg" alt="node version"></a>
+  <a href="https://github.com/Yaron9/MetaMe/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/metame-cli.svg" alt="license"></a>
+</p>
+
+<p align="center">
+  <a href="./README.md">English</a> | <a href="./README中文版.md">中文</a>
+</p>
+
 > **The Cognitive Profile Layer for Claude Code.**
 >
 > *Knows how you think. Works wherever you are.*
@@ -37,6 +48,7 @@
 * **📱 Remote Claude Code (v1.3):** Full Claude Code from your phone via Telegram or Feishu (Lark). Stateful sessions with `--resume` — same conversation history, tool use, and file editing as your terminal. Interactive buttons for project/session picking, directory browser, and macOS launchd auto-start.
 * **🔄 Workflow Engine (v1.3):** Define multi-step skill chains as heartbeat tasks. Each workflow runs in a single Claude Code session via `--resume`, so step outputs flow as context to the next step. Example: `deep-research` → `tech-writing` → `wechat-publisher` — fully automated content pipeline.
 * **⏹ Full Terminal Control from Mobile (v1.3.10):** `/stop` (ESC), `/undo` (ESC×2) with native file-history restoration, `/model` to switch models, concurrent task protection, daemon auto-restart, and `metame continue` for seamless mobile-to-desktop sync.
+* **🎯 Goal Alignment & Drift Detection (v1.3.11):** MetaMe now tracks whether your sessions align with your declared goals. Each distill assesses `goal_alignment` (aligned/partial/drifted) at zero extra API cost. When you drift for 2+ consecutive sessions, a mirror observation is injected passively; after 3+ sessions, a reflection prompt gently asks: "Was this an intentional pivot, or did you lose track?" Session logs now record project, branch, intent, and file directories for richer retrospective analysis. Pattern detection can spot sustained drift trends across your session history.
 
 ## 🛠 Prerequisites
 

package/index.js

@@ -23,7 +23,7 @@ if (!fs.existsSync(METAME_DIR)) {
 }
 
 // Auto-deploy bundled scripts to ~/.metame/
-const BUNDLED_SCRIPTS = ['signal-capture.js', 'distill.js', 'schema.js', 'pending-traits.js', 'migrate-v2.js', 'daemon.js', 'telegram-adapter.js', 'feishu-adapter.js', 'daemon-default.yaml'];
+const BUNDLED_SCRIPTS = ['signal-capture.js', 'distill.js', 'schema.js', 'pending-traits.js', 'migrate-v2.js', 'daemon.js', 'telegram-adapter.js', 'feishu-adapter.js', 'daemon-default.yaml', 'providers.js', 'session-analytics.js'];
 const scriptsDir = path.join(__dirname, 'scripts');
 
 for (const script of BUNDLED_SCRIPTS) {
@@ -319,6 +319,27 @@ try {
         candidate.surfaced = new Date().toISOString().slice(0, 10);
         fs.writeFileSync(BRAIN_FILE, yaml.dump(brainDoc, { lineWidth: -1 }), 'utf8');
       }
+
+      // Drift mirror fallback — when no pattern candidate, check recent session drift
+      if (!candidate) {
+        const sessionLogFile = path.join(METAME_DIR, 'session_log.yaml');
+        if (fs.existsSync(sessionLogFile)) {
+          const log = yaml.load(fs.readFileSync(sessionLogFile, 'utf8'));
+          if (log && Array.isArray(log.sessions)) {
+            const recent = log.sessions.slice(-3);
+            const driftCount = recent.filter(s =>
+              s.goal_alignment === 'drifted' || s.goal_alignment === 'partial'
+            ).length;
+            if (driftCount >= 2 && recent.length >= 2) {
+              const projects = [...new Set(recent.map(s => s.project).filter(Boolean))];
+              const declaredFocus = brainDoc.status?.focus || brainDoc.context?.focus;
+              if (declaredFocus && projects.length > 0) {
+                mirrorLine = `\n[MetaMe observation: 最近${driftCount}个session都在${projects.join(',')}上，和声明的目标"${declaredFocus}"有偏差。不要主动提起，只在用户自然提到相关话题时温和回应。]\n`;
+              }
+            }
+          }
+        }
+      }
     }
   }
 } catch {
@@ -350,9 +371,31 @@ try {
       const lastThree = zoneHistory.slice(-3);
       const triggerComfort = lastThree.length === 3 && lastThree.every(z => z === 'C');
 
-      if (trigger7th || triggerComfort) {
+      // Trigger 3: Persistent goal drift (2+ drifted in last 3 sessions)
+      let triggerDrift = false;
+      let driftDeclaredFocus = null;
+      try {
+        const sessionLogFile = path.join(METAME_DIR, 'session_log.yaml');
+        if (fs.existsSync(sessionLogFile)) {
+          const driftLog = yaml.load(fs.readFileSync(sessionLogFile, 'utf8'));
+          if (driftLog && Array.isArray(driftLog.sessions)) {
+            const recentSessions = driftLog.sessions.slice(-3);
+            const driftCount = recentSessions.filter(s =>
+              s.goal_alignment === 'drifted' || s.goal_alignment === 'partial'
+            ).length;
+            if (driftCount >= 2 && recentSessions.length >= 2) {
+              driftDeclaredFocus = refDoc.status?.focus || refDoc.context?.focus;
+              if (driftDeclaredFocus) triggerDrift = true;
+            }
+          }
+        }
+      } catch { /* non-fatal */ }
+
+      if (triggerDrift || triggerComfort || trigger7th) {
         let hint = '';
-        if (triggerComfort) {
+        if (triggerDrift) {
+          hint = `最近几个session的方向和"${driftDeclaredFocus}"有偏差。如果session自然结束，可以温和地问：🪞 是方向有意调整了，还是不小心偏了？`;
+        } else if (triggerComfort) {
           hint = '连续几次都在熟悉领域。如果用户在session结束时自然停顿，可以温和地问：🪞 准备好探索拉伸区了吗？';
         } else {
           hint = '这是第' + distillCount + '次session。如果session自然结束，可以附加一句：🪞 一个词形容这次session的感受？';
@@ -557,7 +600,173 @@ if (isMirror) {
 }
 
 // ---------------------------------------------------------
-// 5.6 DAEMON SUBCOMMANDS
+// 5.6 PROVIDER SUBCOMMANDS
+// ---------------------------------------------------------
+const isProvider = process.argv.includes('provider');
+if (isProvider) {
+  const providers = require(path.join(__dirname, 'scripts', 'providers.js'));
+  const providerIndex = process.argv.indexOf('provider');
+  const subCmd = process.argv[providerIndex + 1];
+
+  if (!subCmd || subCmd === 'list') {
+    const active = providers.getActiveProvider();
+    console.log(`🔌 MetaMe Providers (active: ${active ? active.name : 'anthropic'})`);
+    console.log(providers.listFormatted());
+    process.exit(0);
+  }
+
+  if (subCmd === 'use') {
+    const name = process.argv[providerIndex + 2];
+    if (!name) {
+      console.error("❌ Usage: metame provider use <name>");
+      process.exit(1);
+    }
+    try {
+      providers.setActive(name);
+      const p = providers.getActiveProvider();
+      console.log(`✅ Provider switched → ${name} (${p.label || name})`);
+      if (name !== 'anthropic') {
+        console.log(`   Base URL: ${p.base_url || 'not set'}`);
+      }
+    } catch (e) {
+      console.error(`❌ ${e.message}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
+  if (subCmd === 'add') {
+    const name = process.argv[providerIndex + 2];
+    if (!name) {
+      console.error("❌ Usage: metame provider add <name>");
+      process.exit(1);
+    }
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(r => rl.question(q, r));
+
+    (async () => {
+      console.log(`\n🔌 Add Provider: ${name}\n`);
+      console.log("The relay must accept Anthropic Messages API format.");
+      console.log("(Most quality relays like OpenRouter, OneAPI, etc. support this.)\n");
+
+      const label = (await ask("Display name (e.g. OpenRouter): ")).trim() || name;
+      const base_url = (await ask("Base URL (e.g. https://openrouter.ai/api/v1): ")).trim();
+      const api_key = (await ask("API Key: ")).trim();
+
+      if (!base_url) {
+        console.error("❌ Base URL is required.");
+        rl.close();
+        process.exit(1);
+      }
+
+      const config = { label };
+      if (base_url) config.base_url = base_url;
+      if (api_key) config.api_key = api_key;
+
+      try {
+        providers.addProvider(name, config);
+        console.log(`\n✅ Provider "${name}" added.`);
+        console.log(`   Switch to it: metame provider use ${name}`);
+      } catch (e) {
+        console.error(`❌ ${e.message}`);
+      }
+      rl.close();
+      process.exit(0);
+    })();
+    return; // Prevent further execution while async runs
+  }
+
+  if (subCmd === 'remove') {
+    const name = process.argv[providerIndex + 2];
+    if (!name) {
+      console.error("❌ Usage: metame provider remove <name>");
+      process.exit(1);
+    }
+    try {
+      providers.removeProvider(name);
+      console.log(`✅ Provider "${name}" removed.`);
+    } catch (e) {
+      console.error(`❌ ${e.message}`);
+    }
+    process.exit(0);
+  }
+
+  if (subCmd === 'set-role') {
+    const role = process.argv[providerIndex + 2]; // distill | daemon
+    const name = process.argv[providerIndex + 3]; // provider name or empty to clear
+    if (!role) {
+      console.error("❌ Usage: metame provider set-role <distill|daemon> [provider-name]");
+      console.error("   Omit provider name to reset to active provider.");
+      process.exit(1);
+    }
+    try {
+      providers.setRole(role, name || null);
+      console.log(`✅ ${role} provider ${name ? `set to "${name}"` : 'reset to active'}.`);
+    } catch (e) {
+      console.error(`❌ ${e.message}`);
+    }
+    process.exit(0);
+  }
+
+  if (subCmd === 'test') {
+    const targetName = process.argv[providerIndex + 2];
+    const prov = providers.loadProviders();
+    const name = targetName || prov.active;
+    const p = prov.providers[name];
+    if (!p) {
+      console.error(`❌ Provider "${name}" not found.`);
+      process.exit(1);
+    }
+
+    console.log(`🔍 Testing provider: ${name} (${p.label || name})`);
+    if (name === 'anthropic') {
+      console.log("   Using official Anthropic endpoint — testing via claude CLI...");
+    } else {
+      console.log(`   Base URL: ${p.base_url || 'not set'}`);
+    }
+
+    try {
+      const env = { ...process.env, ...providers.buildEnv(name) };
+      const { execSync } = require('child_process');
+      const start = Date.now();
+      const result = execSync(
+        'claude -p --model haiku --no-session-persistence',
+        {
+          input: 'Respond with exactly: PROVIDER_OK',
+          encoding: 'utf8',
+          timeout: 30000,
+          env,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        }
+      ).trim();
+      const elapsed = Date.now() - start;
+
+      if (result.includes('PROVIDER_OK')) {
+        console.log(`   ✅ Connected (${elapsed}ms)`);
+      } else {
+        console.log(`   ⚠️  Response received (${elapsed}ms) but unexpected: ${result.slice(0, 80)}`);
+      }
+    } catch (e) {
+      console.error(`   ❌ Failed: ${e.message.split('\n')[0]}`);
+    }
+    process.exit(0);
+  }
+
+  // Unknown subcommand — show help
+  console.log("🔌 MetaMe Provider Commands:");
+  console.log("   metame provider              — list providers");
+  console.log("   metame provider use <name>   — switch active provider");
+  console.log("   metame provider add <name>   — add a new provider");
+  console.log("   metame provider remove <name> — remove provider");
+  console.log("   metame provider test [name]  — test connectivity");
+  console.log("   metame provider set-role <distill|daemon> [name]");
+  console.log("                                — assign provider for background tasks");
+  process.exit(0);
+}
+
+// ---------------------------------------------------------
+// 5.7 DAEMON SUBCOMMANDS
 // ---------------------------------------------------------
 const isDaemon = process.argv.includes('daemon');
 if (isDaemon) {
@@ -951,9 +1160,10 @@ if (isSync) {
   }
 
   console.log(`\n🔄 Resuming session ${bestSession.id.slice(0, 8)}...\n`);
+  const providerEnv = (() => { try { return require(path.join(__dirname, 'scripts', 'providers.js')).buildActiveEnv(); } catch { return {}; } })();
   const syncChild = spawn('claude', ['--resume', bestSession.id], {
     stdio: 'inherit',
-    env: { ...process.env, METAME_ACTIVE_SESSION: 'true' }
+    env: { ...process.env, ...providerEnv, METAME_ACTIVE_SESSION: 'true' }
   });
   syncChild.on('error', () => {
     console.error("Could not launch 'claude'. Is Claude Code installed?");
@@ -977,10 +1187,17 @@ if (process.env.METAME_ACTIVE_SESSION === 'true') {
 // ---------------------------------------------------------
 // 7. LAUNCH CLAUDE
 // ---------------------------------------------------------
-// Spawn the official claude tool with our marker
+// Load provider env (zero-overhead for official Anthropic — returns {})
+const activeProviderEnv = (() => { try { return require(path.join(__dirname, 'scripts', 'providers.js')).buildActiveEnv(); } catch { return {}; } })();
+const activeProviderName = (() => { try { return require(path.join(__dirname, 'scripts', 'providers.js')).getActiveName(); } catch { return 'anthropic'; } })();
+if (activeProviderName !== 'anthropic') {
+  console.log(`🔌 Provider: ${activeProviderName}`);
+}
+
+// Spawn the official claude tool with our marker + provider env
 const child = spawn('claude', process.argv.slice(2), {
   stdio: 'inherit',
-  env: { ...process.env, METAME_ACTIVE_SESSION: 'true' }
+  env: { ...process.env, ...activeProviderEnv, METAME_ACTIVE_SESSION: 'true' }
 });
 
 child.on('error', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.3.10",
+    "version": "1.3.12",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -12,7 +12,7 @@
     ],
     "scripts": {
         "start": "node index.js",
-        "sync:plugin": "cp scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/distill.js scripts/daemon.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml plugin/scripts/ && echo '✅ Plugin scripts synced'",
+        "sync:plugin": "cp scripts/schema.js scripts/pending-traits.js scripts/signal-capture.js scripts/distill.js scripts/daemon.js scripts/telegram-adapter.js scripts/feishu-adapter.js scripts/daemon-default.yaml scripts/providers.js plugin/scripts/ && echo '✅ Plugin scripts synced'",
         "restart:daemon": "node index.js daemon stop 2>/dev/null; sleep 1; node index.js daemon start 2>/dev/null || echo '⚠️  Daemon not running or restart failed'",
         "precommit": "npm run sync:plugin && npm run restart:daemon"
     },

package/scripts/daemon.js

@@ -51,6 +51,22 @@ try {
   }
 }
 
+// Provider env for daemon tasks (relay support)
+let providerMod = null;
+try {
+  providerMod = require('./providers');
+} catch { /* providers.js not available — use defaults */ }
+
+function getDaemonProviderEnv() {
+  if (!providerMod) return {};
+  try { return providerMod.buildDaemonEnv(); } catch { return {}; }
+}
+
+function getActiveProviderEnv() {
+  if (!providerMod) return {};
+  try { return providerMod.buildActiveEnv(); } catch { return {}; }
+}
+
 // ---------------------------------------------------------
 // LOGGING
 // ---------------------------------------------------------
@@ -267,6 +283,7 @@ function executeTask(task, config) {
         encoding: 'utf8',
         timeout: 120000, // 2 min timeout
         maxBuffer: 1024 * 1024,
+        env: { ...process.env, ...getDaemonProviderEnv() },
       }
     ).trim();
 
@@ -351,7 +368,7 @@ function executeWorkflow(task, config) {
     log('INFO', `Workflow ${task.name} step ${i + 1}/${steps.length}: ${step.skill || 'prompt'}`);
     try {
       const output = execSync(`claude ${args.join(' ')}`, {
-        input: prompt, encoding: 'utf8', timeout: step.timeout || 300000, maxBuffer: 5 * 1024 * 1024, cwd,
+        input: prompt, encoding: 'utf8', timeout: step.timeout || 300000, maxBuffer: 5 * 1024 * 1024, cwd, env: { ...process.env, ...getDaemonProviderEnv() },
       }).trim();
       const tk = Math.ceil((prompt.length + output.length) / 4);
       totalTokens += tk;
@@ -1186,8 +1203,31 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
     return;
   }
 
+  // /provider [name] — list or switch provider
+  if (text === '/provider' || text.startsWith('/provider ')) {
+    if (!providerMod) {
+      await bot.sendMessage(chatId, '❌ Provider module not available.');
+      return;
+    }
+    const arg = text.slice(9).trim();
+    if (!arg) {
+      const list = providerMod.listFormatted();
+      await bot.sendMessage(chatId, `🔌 Providers:\n${list}\n\n用法: /provider <name>`);
+      return;
+    }
+    try {
+      providerMod.setActive(arg);
+      const p = providerMod.getActiveProvider();
+      await bot.sendMessage(chatId, `✅ Provider: ${arg} (${p.label || arg})`);
+    } catch (e) {
+      await bot.sendMessage(chatId, `❌ ${e.message}`);
+    }
+    return;
+  }
+
   if (text.startsWith('/')) {
     const currentModel = (config.daemon && config.daemon.model) || 'sonnet';
+    const currentProvider = providerMod ? providerMod.getActiveName() : 'anthropic';
     await bot.sendMessage(chatId, [
       '📱 手机端 Claude Code',
       '',
@@ -1204,7 +1244,7 @@ async function handleCommand(bot, chatId, text, config, executeTaskByName) {
       '/stop — 中断当前任务 (ESC)',
       '/undo — 回退上一轮操作 (ESC×2)',
       '',
-      `⚙️ /model [${currentModel}] /status /tasks /run /budget /reload`,
+      `⚙️ /model [${currentModel}] /provider [${currentProvider}] /status /tasks /run /budget /reload`,
       '',
       '直接打字即可对话 💬',
     ].join('\n'));
@@ -1525,7 +1565,7 @@ function spawnClaudeAsync(args, input, cwd, timeoutMs = 300000) {
     const child = spawn('claude', args, {
       cwd,
       stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env },
+      env: { ...process.env, ...getActiveProviderEnv() },
     });
 
     let stdout = '';
@@ -1630,7 +1670,7 @@ function spawnClaudeStreaming(args, input, cwd, onStatus, timeoutMs = 600000, ch
     const child = spawn('claude', streamArgs, {
       cwd,
       stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env },
+      env: { ...process.env, ...getActiveProviderEnv() },
     });
 
     // Track active process for /stop

package/scripts/distill.js

@@ -19,9 +19,22 @@ const BUFFER_FILE = path.join(HOME, '.metame', 'raw_signals.jsonl');
 const BRAIN_FILE = path.join(HOME, '.claude_profile.yaml');
 const LOCK_FILE = path.join(HOME, '.metame', 'distill.lock');
 
-const { hasKey, isLocked, getTier, getAllowedKeysForPrompt, estimateTokens, TOKEN_BUDGET } = require('./schema');
+const { hasKey, isLocked, getTier, getWritableKeysForPrompt, estimateTokens, TOKEN_BUDGET } = require('./schema');
 const { loadPending, savePending, upsertPending, getPromotable, removePromoted } = require('./pending-traits');
 
+// Session analytics — local skeleton extraction (zero API cost)
+let sessionAnalytics = null;
+try {
+  sessionAnalytics = require('./session-analytics');
+} catch { /* session-analytics.js not available — graceful fallback */ }
+
+// Provider env for distillation (cheap relay for background tasks)
+let distillEnv = {};
+try {
+  const { buildDistillEnv } = require('./providers');
+  distillEnv = buildDistillEnv();
+} catch { /* providers.js not available — use defaults */ }
+
 /**
  * Main distillation process.
  * Returns { updated: boolean, summary: string }
@@ -74,6 +87,19 @@ function distill() {
       return { updated: false, behavior: null, summary: 'No valid signals.' };
     }
 
+    // 3b. Extract session skeleton (local, zero API cost)
+    let sessionContext = '';
+    let skeleton = null;
+    if (sessionAnalytics) {
+      try {
+        const latest = sessionAnalytics.findLatestUnanalyzedSession();
+        if (latest) {
+          skeleton = sessionAnalytics.extractSkeleton(latest.path);
+          sessionContext = sessionAnalytics.formatForPrompt(skeleton);
+        }
+      } catch { /* non-fatal */ }
+    }
+
     // 4. Read current profile
     let currentProfile = '';
     try {
@@ -82,95 +108,68 @@ function distill() {
       currentProfile = '(empty profile)';
     }
 
-    // 5. Build distillation prompt
+    // 5. Build distillation prompt (compact + session-aware)
     const userMessages = signals
       .map((s, i) => `${i + 1}. "${s}"`)
       .join('\n');
 
-    const allowedKeys = getAllowedKeysForPrompt();
+    const writableKeys = getWritableKeysForPrompt();
+
+    // Session context section (only when skeleton exists, ~60 tokens)
+    const sessionSection = sessionContext
+      ? `\nSESSION CONTEXT (what actually happened in the latest coding session):\n${sessionContext}\n`
+      : '';
 
-    const distillPrompt = `You are a MetaMe cognitive profile distiller. Your job is to extract COGNITIVE TRAITS and PREFERENCES — how the user thinks, decides, and communicates. You are NOT a memory system. Do NOT store facts ("user lives in X"). Only store cognitive patterns and preferences.
+    // Goal context section (~11 tokens when present)
+    let goalContext = '';
+    if (sessionAnalytics) {
+      try { goalContext = sessionAnalytics.formatGoalContext(BRAIN_FILE); } catch {}
+    }
+    const goalSection = goalContext ? `\n${goalContext}\n` : '';
+
+    const distillPrompt = `You are a MetaMe cognitive profile distiller. Extract COGNITIVE TRAITS and PREFERENCES — how the user thinks, decides, and communicates. NOT a memory system. Do NOT store facts.
 
 CURRENT PROFILE:
 \`\`\`yaml
 ${currentProfile}
 \`\`\`
 
-ALLOWED FIELDS (you may ONLY output keys from this list):
-${allowedKeys}
+WRITABLE FIELDS (T1/T2 are LOCKED and omitted — you may ONLY output keys from this list):
+${writableKeys}
 
 RECENT USER MESSAGES:
 ${userMessages}
-
-INSTRUCTIONS:
-1. Extract ONLY cognitive traits, preferences, and behavioral patterns — NOT facts or events.
-2. IGNORE task-specific messages (e.g., "fix this bug", "add a button").
-3. Only extract things that should persist across ALL future sessions.
-4. You may ONLY output fields from ALLOWED FIELDS. Any other key will be rejected.
-5. Fields marked [LOCKED] must NEVER be changed (T1 and T2 tiers).
-6. For enum fields, you MUST use one of the listed values.
-
-EPISODIC MEMORY — TWO EXCEPTIONS to the "no facts" rule:
-7. context.anti_patterns (max 5): If the user encountered a REPEATED technical failure or expressed strong frustration about a specific technical approach, record it as an anti-pattern. Format: "topic — what failed and why". Only cross-project generalizable lessons, NOT project-specific bugs.
-   Example: ["async/await deadlock — Promise.all rejects all on single failure, use Promise.allSettled", "CSS Grid in email templates — no support, use tables"]
-8. context.milestones (max 3): If the user completed a significant milestone or made a key decision, record it. Only the 3 most recent. Format: short description string.
-   Example: ["MetaMe v1.3 published", "Switched from REST to GraphQL"]
-
-COGNITIVE BIAS PREVENTION:
-- A single observation is a STATE, not a TRAIT. Do NOT infer T3 cognition fields from one message.
-- Never infer cognitive style from identity/demographics.
-- If a new signal contradicts an existing profile value, do NOT output the field — contradictions need accumulation.
-- Signal weight hierarchy:
-  L1 Surface (word choice, tone) → low weight, needs 5+ observations
-  L2 Behavior (question patterns, decision patterns) → medium weight, needs 3 observations
-  L3 Self-declaration ("I prefer...", "以后一律...") → high weight, can write directly
-
-CONFIDENCE TAGGING:
-- If a message contains strong directives (以后一律/永远/always/never/记住/from now on), mark as HIGH.
-- Add a _confidence block mapping field keys to "high" or "normal".
-- Add a _source block mapping field keys to the quote that triggered the extraction.
-
-OUTPUT FORMAT — respond with ONLY a YAML code block:
-\`\`\`yaml
-preferences:
-  code_style: concise
-context:
-  focus: "API redesign"
-_confidence:
-  preferences.code_style: high
-  context.focus: normal
-_source:
-  preferences.code_style: "以后代码一律简洁风格"
-  context.focus: "我现在在做API重构"
-\`\`\`
-
-BEHAVIORAL PATTERN DETECTION (Phase C):
-In addition to cognitive traits, analyze the messages for behavioral patterns in THIS session.
-Output a _behavior block with these fields (use null if not enough signal):
+${sessionSection}${goalSection}
+RULES:
+1. Extract ONLY cognitive traits, preferences, behavioral patterns — NOT facts or events.
+2. IGNORE task-specific messages. Only extract what persists across ALL sessions.
+3. Only output fields from WRITABLE FIELDS. Any other key will be rejected.
+4. For enum fields, use one of the listed values.
+5. Episodic exceptions: context.anti_patterns (max 5, cross-project lessons only), context.milestones (max 3).
+6. Strong directives (以后一律/always/never/from now on) → _confidence: high. Otherwise: normal.
+7. Add _confidence and _source blocks mapping field keys to confidence level and triggering quote.
+
+BIAS PREVENTION:
+- Single observation = STATE, not TRAIT. T3 cognition needs 3+ observations.
+- L1 Surface → needs 5+, L2 Behavior → needs 3, L3 Self-declaration → direct write.
+- Contradiction with existing value → do NOT output (needs accumulation).
+
+BEHAVIORAL ANALYSIS — _behavior block (always output, use null if insufficient signal):
   decision_pattern: premature_closure | exploratory | iterative | null
   cognitive_load: low | medium | high | null
   zone: comfort | stretch | panic | null
-  avoidance_topics: []           # topics mentioned but not acted on
+  avoidance_topics: []
   emotional_response: analytical | blame_external | blame_self | withdrawal | null
-  topics: []                     # main topics discussed (max 5 keywords)
-
-Example _behavior block:
-\`\`\`yaml
-_behavior:
-  decision_pattern: iterative
-  cognitive_load: medium
-  zone: stretch
-  avoidance_topics: ["testing"]
-  emotional_response: analytical
-  topics: ["rust", "error-handling"]
-\`\`\`
-
-IMPORTANT: _behavior is ALWAYS output, even if no profile updates. If there are no profile updates but behavior was detected, output ONLY the _behavior block (do NOT output NO_UPDATE in that case).
-
-If nothing worth saving AND no behavior detected: respond with exactly NO_UPDATE
-Do NOT repeat existing unchanged values. Only output NEW or CHANGED fields.`;
-
-    // 6. Call Claude in print mode with haiku
+  topics: []
+  session_outcome: completed | abandoned | blocked | pivoted | null
+  friction: []                   # max 3 keywords describing pain points
+  goal_alignment: aligned | partial | drifted | null
+  drift_note: "max 30 char explanation" or null
+${sessionContext ? '\nHint: high tool_calls + routine messages → zone likely higher. If DECLARED_GOALS exist, assess goal_alignment.' : ''}
+OUTPUT — respond with ONLY a YAML code block. If nothing worth saving AND no behavior: respond with exactly NO_UPDATE.
+Do NOT repeat existing unchanged values.`;
+
+    // 6. Call Claude in print mode with haiku (+ provider env for relay support)
     let result;
     try {
       result = execSync(
@@ -179,7 +178,8 @@ Do NOT repeat existing unchanged values. Only output NEW or CHANGED fields.`;
           input: distillPrompt,
           encoding: 'utf8',
           timeout: 60000, // 60s — runs in background, no rush
-          stdio: ['pipe', 'pipe', 'pipe']
+          stdio: ['pipe', 'pipe', 'pipe'],
+          env: { ...process.env, ...distillEnv },
         }
       ).trim();
     } catch (err) {
@@ -234,7 +234,10 @@ Do NOT repeat existing unchanged values. Only output NEW or CHANGED fields.`;
       // If only behavior detected but no profile updates
       if (Object.keys(filtered).length === 0 && behavior) {
         cleanup();
-        return { updated: false, behavior, signalCount: signals.length, summary: `Analyzed ${signals.length} messages — behavior logged, no profile changes.` };
+        if (skeleton && sessionAnalytics) {
+          try { sessionAnalytics.markAnalyzed(skeleton.session_id); } catch {}
+        }
+        return { updated: false, behavior, skeleton, signalCount: signals.length, summary: `Analyzed ${signals.length} messages — behavior logged, no profile changes.` };
       }
 
       const profile = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
@@ -297,10 +300,16 @@ Do NOT repeat existing unchanged values. Only output NEW or CHANGED fields.`;
 
       fs.writeFileSync(BRAIN_FILE, restored, 'utf8');
 
+      // Mark session as analyzed after successful distill
+      if (skeleton && sessionAnalytics) {
+        try { sessionAnalytics.markAnalyzed(skeleton.session_id); } catch {}
+      }
+
       cleanup();
       return {
         updated: true,
         behavior,
+        skeleton,
         signalCount: signals.length,
         summary: `${Object.keys(filtered).length} new trait${Object.keys(filtered).length > 1 ? 's' : ''} absorbed. (${tokens} tokens)`
       };
@@ -577,8 +586,9 @@ const MAX_SESSION_LOG = 30;
  * Write a session entry to session_log.yaml.
  * @param {object} behavior - The _behavior block from Haiku
  * @param {number} signalCount - Number of signals processed
+ * @param {object} [skeleton] - Optional session skeleton from session-analytics
  */
-function writeSessionLog(behavior, signalCount) {
+function writeSessionLog(behavior, signalCount, skeleton) {
   if (!behavior) return;
 
   const yaml = require('js-yaml');
@@ -602,6 +612,19 @@ function writeSessionLog(behavior, signalCount) {
     emotional_response: behavior.emotional_response || null,
     avoidance: behavior.avoidance_topics || [],
     signal_count: signalCount,
+    session_outcome: behavior.session_outcome || null,
+    friction: behavior.friction || [],
+    goal_alignment: behavior.goal_alignment || null,
+    drift_note: behavior.drift_note || null,
+    // From skeleton (if available)
+    ...(skeleton ? {
+      duration_min: skeleton.duration_min,
+      tool_calls: skeleton.total_tool_calls,
+      tools: skeleton.tool_counts,
+      project: skeleton.project || null,
+      branch: skeleton.branch || null,
+      intent: skeleton.intent || null,
+    } : {}),
   };
 
   log.sessions.push(entry);
@@ -641,20 +664,42 @@ function detectPatterns() {
 
   // Take last 20 sessions
   const recent = log.sessions.slice(-20);
-  const sessionSummary = recent.map((s, i) =>
-    `${i + 1}. [${s.ts}] topics=${(s.topics || []).join(',')} zone=${s.zone || '?'} decision=${s.decision_pattern || '?'} load=${s.cognitive_load || '?'} avoidance=[${(s.avoidance || []).join(',')}]`
-  ).join('\n');
+  const sessionSummary = recent.map((s, i) => {
+    const parts = [`${i + 1}. [${s.ts}]`];
+    if (s.project) parts.push(`proj=${s.project}`);
+    parts.push(`topics=${(s.topics || []).join(',')}`);
+    parts.push(`zone=${s.zone || '?'}`);
+    if (s.goal_alignment) parts.push(`goal=${s.goal_alignment}`);
+    if (s.drift_note) parts.push(`drift="${s.drift_note}"`);
+    if (s.session_outcome) parts.push(`outcome=${s.session_outcome}`);
+    if (s.friction && s.friction.length) parts.push(`friction=[${s.friction.join(',')}]`);
+    if (s.tool_calls) parts.push(`tools=${s.tool_calls}`);
+    if (s.duration_min) parts.push(`${s.duration_min}min`);
+    parts.push(`load=${s.cognitive_load || '?'}`);
+    parts.push(`avoidance=[${(s.avoidance || []).join(',')}]`);
+    return parts.join(' ');
+  }).join('\n');
+
+  // Read declared goals for pattern context
+  let declaredGoals = '';
+  if (sessionAnalytics) {
+    try { declaredGoals = sessionAnalytics.formatGoalContext(BRAIN_FILE); } catch {}
+  }
+  const goalLine = declaredGoals ? `\nUSER'S ${declaredGoals}\n` : '';
 
   const patternPrompt = `You are a metacognition pattern detector. Analyze these ${recent.length} session summaries and find repeated behavioral patterns.
 
 SESSION HISTORY:
 ${sessionSummary}
-
+${goalLine}
 Find at most 2 patterns from these categories:
 1. Avoidance: topics mentioned repeatedly but never acted on
 2. Energy: what task types correlate with high/low cognitive load
 3. Zone: consecutive comfort zone? frequent panic?
 4. Growth: areas where user went from asking questions to giving commands (mastery signal)
+5. Friction: recurring pain points across sessions
+6. Efficiency: workflow patterns, underutilized tools
+7. Drift: sessions where goal_alignment is drifted/partial for 3+ consecutive sessions
 
 RULES:
 - Only report patterns with confidence > 0.7 (based on frequency/consistency)
@@ -664,7 +709,7 @@ RULES:
 OUTPUT FORMAT — respond with ONLY a YAML code block:
 \`\`\`yaml
 patterns:
-  - type: avoidance|energy|zone|growth
+  - type: avoidance|energy|zone|growth|friction|efficiency|drift
     summary: "one sentence description"
     confidence: 0.7-1.0
 \`\`\`
@@ -678,7 +723,8 @@ If no clear patterns found: respond with exactly NO_PATTERNS`;
         input: patternPrompt,
         encoding: 'utf8',
         timeout: 30000,
-        stdio: ['pipe', 'pipe', 'pipe']
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env, ...distillEnv },
       }
     ).trim();
 
@@ -735,7 +781,7 @@ if (require.main === module) {
   const result = distill();
   // Write session log if behavior was detected
   if (result.behavior) {
-    writeSessionLog(result.behavior, result.signalCount || 0);
+    writeSessionLog(result.behavior, result.signalCount || 0, result.skeleton || null);
   }
   // Run pattern detection (only triggers every 5th distill)
   detectPatterns();

package/scripts/providers.js

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+
+/**
+ * providers.js — MetaMe Provider Management
+ *
+ * Manages API provider configurations for Claude Code.
+ * Injects credentials via environment variables at spawn time — zero file mutation.
+ *
+ * Mechanism: Claude Code respects ANTHROPIC_BASE_URL and ANTHROPIC_API_KEY
+ * env vars. By setting these before spawn(), we redirect Claude Code to any
+ * Anthropic-compatible API relay without touching ~/.claude/settings.json.
+ *
+ * Compatible relays must accept the Anthropic Messages API format.
+ * Model routing is handled by the relay — Claude Code sends standard model
+ * names (haiku, sonnet, opus) and the relay maps them as configured.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = os.homedir();
+const METAME_DIR = path.join(HOME, '.metame');
+const PROVIDERS_FILE = path.join(METAME_DIR, 'providers.yaml');
+
+// Resolve js-yaml (same pattern as daemon.js)
+let yaml;
+try {
+  yaml = require('js-yaml');
+} catch {
+  const metameRoot = process.env.METAME_ROOT;
+  if (metameRoot) {
+    try { yaml = require(path.join(metameRoot, 'node_modules', 'js-yaml')); } catch {}
+  }
+  if (!yaml) {
+    const candidates = [
+      path.resolve(__dirname, '..', 'node_modules', 'js-yaml'),
+      path.resolve(__dirname, 'node_modules', 'js-yaml'),
+    ];
+    for (const p of candidates) {
+      try { yaml = require(p); break; } catch {}
+    }
+  }
+}
+
+// ---------------------------------------------------------
+// DEFAULT CONFIG
+// ---------------------------------------------------------
+function defaultConfig() {
+  return {
+    active: 'anthropic',
+    providers: {
+      anthropic: { label: 'Anthropic (Official)' },
+    },
+    distill_provider: null,
+    daemon_provider: null,
+  };
+}
+
+// ---------------------------------------------------------
+// LOAD / SAVE
+// ---------------------------------------------------------
+function loadProviders() {
+  try {
+    if (!fs.existsSync(PROVIDERS_FILE)) return defaultConfig();
+    const data = yaml.load(fs.readFileSync(PROVIDERS_FILE, 'utf8'));
+    if (!data || typeof data !== 'object') return defaultConfig();
+    // Ensure anthropic always exists
+    if (!data.providers) data.providers = {};
+    if (!data.providers.anthropic) data.providers.anthropic = { label: 'Anthropic (Official)' };
+    return {
+      active: data.active || 'anthropic',
+      providers: data.providers,
+      distill_provider: data.distill_provider || null,
+      daemon_provider: data.daemon_provider || null,
+    };
+  } catch {
+    return defaultConfig();
+  }
+}
+
+function saveProviders(config) {
+  if (!fs.existsSync(METAME_DIR)) fs.mkdirSync(METAME_DIR, { recursive: true });
+  fs.writeFileSync(PROVIDERS_FILE, yaml.dump(config, { lineWidth: -1 }), 'utf8');
+}
+
+// ---------------------------------------------------------
+// PROVIDER ENV BUILDER (Core mechanism)
+// ---------------------------------------------------------
+
+/**
+ * Build env var overrides for a named provider.
+ * Returns {} for 'anthropic' (official) — use Claude Code defaults.
+ * Returns { ANTHROPIC_BASE_URL, ANTHROPIC_API_KEY } for relays.
+ */
+function buildEnv(providerName) {
+  const config = loadProviders();
+  const name = providerName || config.active;
+
+  if (name === 'anthropic') return {};
+
+  const provider = config.providers[name];
+  if (!provider) return {};
+
+  const env = {};
+  if (provider.base_url) env.ANTHROPIC_BASE_URL = provider.base_url;
+  if (provider.api_key) env.ANTHROPIC_API_KEY = provider.api_key;
+  return env;
+}
+
+/**
+ * Build a complete env object for spawn(), merging process.env + provider env.
+ */
+function buildSpawnEnv(providerName) {
+  return { ...process.env, ...buildEnv(providerName) };
+}
+
+/**
+ * Build env for the active provider.
+ */
+function buildActiveEnv() {
+  return buildEnv(null); // null → uses active
+}
+
+/**
+ * Build env for distill tasks (distill_provider → active fallback).
+ */
+function buildDistillEnv() {
+  const config = loadProviders();
+  return buildEnv(config.distill_provider || config.active);
+}
+
+/**
+ * Build env for daemon tasks (daemon_provider → active fallback).
+ */
+function buildDaemonEnv() {
+  const config = loadProviders();
+  return buildEnv(config.daemon_provider || config.active);
+}
+
+// ---------------------------------------------------------
+// CRUD
+// ---------------------------------------------------------
+function getActiveProvider() {
+  const config = loadProviders();
+  const p = config.providers[config.active];
+  return p ? { name: config.active, ...p } : null;
+}
+
+function getActiveName() {
+  return loadProviders().active;
+}
+
+function setActive(name) {
+  const config = loadProviders();
+  if (!config.providers[name]) {
+    throw new Error(`Provider "${name}" not found. Available: ${Object.keys(config.providers).join(', ')}`);
+  }
+  config.active = name;
+  saveProviders(config);
+}
+
+function addProvider(name, providerConfig) {
+  if (name === 'anthropic') throw new Error('Cannot overwrite the default Anthropic provider.');
+  const config = loadProviders();
+  config.providers[name] = providerConfig;
+  saveProviders(config);
+}
+
+function removeProvider(name) {
+  if (name === 'anthropic') throw new Error('Cannot remove the default Anthropic provider.');
+  const config = loadProviders();
+  if (!config.providers[name]) throw new Error(`Provider "${name}" not found.`);
+  if (config.active === name) config.active = 'anthropic';
+  if (config.distill_provider === name) config.distill_provider = null;
+  if (config.daemon_provider === name) config.daemon_provider = null;
+  delete config.providers[name];
+  saveProviders(config);
+}
+
+function setRole(role, providerName) {
+  const config = loadProviders();
+  if (providerName && !config.providers[providerName]) {
+    throw new Error(`Provider "${providerName}" not found.`);
+  }
+  if (role === 'distill') {
+    config.distill_provider = providerName || null;
+  } else if (role === 'daemon') {
+    config.daemon_provider = providerName || null;
+  } else {
+    throw new Error(`Unknown role "${role}". Use: distill, daemon`);
+  }
+  saveProviders(config);
+}
+
+// ---------------------------------------------------------
+// DISPLAY
+// ---------------------------------------------------------
+function listFormatted() {
+  const config = loadProviders();
+  const lines = [''];
+  for (const [name, p] of Object.entries(config.providers)) {
+    const active = name === config.active;
+    const icon = active ? '→' : ' ';
+    const label = p.label || name;
+    const url = p.base_url || 'official';
+    const badge = active ? ' (active)' : '';
+    lines.push(`  ${icon} ${name}: ${label} [${url}]${badge}`);
+  }
+
+  const d = config.distill_provider;
+  const dm = config.daemon_provider;
+  if (d || dm) {
+    lines.push('');
+    if (d) lines.push(`  Distill provider: ${d}`);
+    if (dm) lines.push(`  Daemon provider:  ${dm}`);
+  }
+
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------
+// EXPORTS
+// ---------------------------------------------------------
+module.exports = {
+  loadProviders,
+  saveProviders,
+  buildEnv,
+  buildSpawnEnv,
+  buildActiveEnv,
+  buildDistillEnv,
+  buildDaemonEnv,
+  getActiveProvider,
+  getActiveName,
+  setActive,
+  addProvider,
+  removeProvider,
+  setRole,
+  listFormatted,
+  PROVIDERS_FILE,
+};

package/scripts/schema.js

@@ -175,6 +175,28 @@ function getAllowedKeysForPrompt() {
   return lines.join('\n');
 }
 
+/**
+ * Get only writable keys (T3-T5) as a formatted list for the distill prompt.
+ * Saves ~150 tokens by omitting T1/T2 LOCKED fields the distiller can't write anyway.
+ */
+function getWritableKeysForPrompt() {
+  const lines = [];
+  let currentTier = '';
+  for (const [key, def] of Object.entries(SCHEMA)) {
+    if (def.tier === 'T1' || def.tier === 'T2') continue;
+    if (def.tier !== currentTier) {
+      currentTier = def.tier;
+      lines.push(`\n# ${currentTier}:`);
+    }
+    let desc = `  ${key}: ${def.type}`;
+    if (def.values) desc += ` [${def.values.join('|')}]`;
+    if (def.maxChars) desc += ` (max ${def.maxChars} chars)`;
+    if (def.maxItems) desc += ` (max ${def.maxItems} items)`;
+    lines.push(desc);
+  }
+  return lines.join('\n');
+}
+
 /**
  * Estimate token count for a YAML string (conservative for mixed zh/en).
  */
@@ -192,6 +214,7 @@ module.exports = {
   isLocked,
   validate,
   getAllowedKeysForPrompt,
+  getWritableKeysForPrompt,
   estimateTokens,
   TOKEN_BUDGET,
 };

package/scripts/session-analytics.js

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+
+/**
+ * MetaMe Session Analytics — Local Skeleton Extraction
+ *
+ * Parses Claude Code session JSONL transcripts to extract
+ * behavioral structure (tool usage, duration, git activity).
+ * Pure local processing — zero API cost.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = os.homedir();
+const PROJECTS_ROOT = path.join(HOME, '.claude', 'projects');
+const STATE_FILE = path.join(HOME, '.metame', 'analytics_state.json');
+const MAX_STATE_ENTRIES = 200;
+const MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB
+const MIN_FILE_SIZE = 1024;               // 1KB
+
+/**
+ * Load analytics state (set of already-analyzed session IDs).
+ */
+function loadState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+    }
+  } catch { /* corrupt state — start fresh */ }
+  return { analyzed: {} };
+}
+
+/**
+ * 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];
+  }
+  const dir = path.dirname(STATE_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), 'utf8');
+}
+
+/**
+ * Find the latest unanalyzed session JSONL across all projects.
+ * Returns { path, session_id, mtime } or null.
+ */
+function findLatestUnanalyzedSession() {
+  const state = loadState();
+  let best = null;
+
+  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 (state.analyzed[sessionId]) continue;
+
+        const fullPath = path.join(fullDir, file);
+        let fstat;
+        try { fstat = fs.statSync(fullPath); } catch { continue; }
+
+        // Skip files that are too large or too small
+        if (fstat.size > MAX_FILE_SIZE || fstat.size < MIN_FILE_SIZE) continue;
+
+        if (!best || fstat.mtimeMs > best.mtime) {
+          best = { path: fullPath, session_id: sessionId, mtime: fstat.mtimeMs };
+        }
+      }
+    }
+  } catch {
+    // Projects root doesn't exist yet
+    return null;
+  }
+
+  return best;
+}
+
+/**
+ * Extract a behavioral skeleton from a session JSONL file.
+ * Only parses structural data — no content analysis of tool results.
+ */
+function extractSkeleton(jsonlPath) {
+  const content = fs.readFileSync(jsonlPath, 'utf8');
+  const lines = content.split('\n');
+
+  const skeleton = {
+    session_id: path.basename(jsonlPath, '.jsonl'),
+    user_snippets: [],
+    tool_counts: {},
+    total_tool_calls: 0,
+    models: new Set(),
+    git_committed: false,
+    first_ts: null,
+    last_ts: null,
+    message_count: 0,
+    duration_min: 0,
+    project: null,
+    branch: null,
+    file_dirs: new Set(),
+    intent: null,
+  };
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+
+    // Fast pre-filter: only parse lines that look like user or assistant messages
+    if (!line.includes('"type":"user"') &&
+        !line.includes('"type":"assistant"') &&
+        !line.includes('"type": "user"') &&
+        !line.includes('"type": "assistant"')) {
+      continue;
+    }
+
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+
+    const type = entry.type;
+    const ts = entry.timestamp;
+
+    // Track timestamps for duration
+    if (ts) {
+      if (!skeleton.first_ts || ts < skeleton.first_ts) skeleton.first_ts = ts;
+      if (!skeleton.last_ts || ts > skeleton.last_ts) skeleton.last_ts = ts;
+    }
+
+    if (type === 'user') {
+      // Extract project and branch from first occurrence
+      if (!skeleton.project && entry.cwd) {
+        skeleton.project = path.basename(entry.cwd);
+      }
+      if (!skeleton.branch && entry.gitBranch) {
+        skeleton.branch = entry.gitBranch;
+      }
+
+      const msg = entry.message;
+      if (!msg || !msg.content) continue;
+
+      const content = msg.content;
+      // Handle both string and array content
+      let userText = '';
+      if (typeof content === 'string') {
+        userText = content;
+        skeleton.user_snippets.push(content.slice(0, 100));
+        skeleton.message_count++;
+      } else if (Array.isArray(content)) {
+        for (const item of content) {
+          if (item.type === 'text' && item.text) {
+            userText = item.text;
+            skeleton.user_snippets.push(item.text.slice(0, 100));
+            skeleton.message_count++;
+            break; // One snippet per user message
+          }
+        }
+      }
+
+      // Extract intent from first substantial user message
+      if (!skeleton.intent && userText.length >= 15 && !userText.startsWith('[Request interrupted')) {
+        skeleton.intent = userText.slice(0, 80);
+      }
+    } else if (type === 'assistant') {
+      const msg = entry.message;
+      if (!msg) continue;
+
+      // Track model
+      if (msg.model) skeleton.models.add(msg.model);
+
+      // Count tool calls
+      const content = msg.content;
+      if (Array.isArray(content)) {
+        for (const item of content) {
+          if (item.type === 'tool_use') {
+            const name = item.name || 'unknown';
+            skeleton.tool_counts[name] = (skeleton.tool_counts[name] || 0) + 1;
+            skeleton.total_tool_calls++;
+
+            // Extract file directories from Read/Edit/Write operations
+            if ((name === 'Read' || name === 'Edit' || name === 'Write') &&
+                item.input && typeof item.input.file_path === 'string') {
+              const dirPath = path.dirname(item.input.file_path);
+              const segments = dirPath.split(path.sep).filter(Boolean);
+              const shortDir = segments.slice(-2).join('/');
+              if (shortDir) skeleton.file_dirs.add(shortDir);
+            }
+
+            // Detect git commits from Bash tool calls
+            if (name === 'Bash' && item.input && typeof item.input.command === 'string') {
+              const cmd = item.input.command;
+              if (cmd.includes('git commit') || cmd.includes('git push')) {
+                skeleton.git_committed = true;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Calculate duration
+  if (skeleton.first_ts && skeleton.last_ts) {
+    const start = new Date(skeleton.first_ts).getTime();
+    const end = new Date(skeleton.last_ts).getTime();
+    skeleton.duration_min = Math.round((end - start) / 60000);
+  }
+
+  // Convert Sets to arrays for serialization
+  skeleton.models = [...skeleton.models];
+  skeleton.file_dirs = [...skeleton.file_dirs].slice(0, 5);
+
+  // Cap user snippets at 10
+  if (skeleton.user_snippets.length > 10) {
+    skeleton.user_snippets = skeleton.user_snippets.slice(0, 10);
+  }
+
+  return skeleton;
+}
+
+/**
+ * Format skeleton as a compact one-liner for injection into the distill prompt.
+ * Target: ~60 tokens.
+ */
+function formatForPrompt(skeleton) {
+  if (!skeleton) return '';
+
+  const toolSummary = Object.entries(skeleton.tool_counts)
+    .sort((a, b) => b[1] - a[1])
+    .map(([name, count]) => `${name}×${count}`)
+    .join(' ');
+
+  const parts = [];
+  if (skeleton.project) {
+    const projLabel = skeleton.branch ? `${skeleton.project}@${skeleton.branch}` : skeleton.project;
+    parts.push(`Proj=${projLabel}`);
+  }
+  if (skeleton.duration_min > 0) parts.push(`Duration: ${skeleton.duration_min}min`);
+  parts.push(`Messages: ${skeleton.message_count}`);
+  if (skeleton.total_tool_calls > 0) parts.push(`Tools: ${skeleton.total_tool_calls} (${toolSummary})`);
+  if (skeleton.git_committed) parts.push('Git: committed');
+  if (skeleton.models.length > 0) {
+    const shortModels = skeleton.models.map(m => {
+      if (m.includes('opus')) return 'opus';
+      if (m.includes('sonnet')) return 'sonnet';
+      if (m.includes('haiku')) return 'haiku';
+      return m.split('-')[0];
+    });
+    parts.push(`Model: ${[...new Set(shortModels)].join(',')}`);
+  }
+
+  return parts.join(' | ');
+}
+
+/**
+ * Mark a session as analyzed.
+ */
+function markAnalyzed(sessionId) {
+  const state = loadState();
+  state.analyzed[sessionId] = Date.now();
+  saveState(state);
+}
+
+/**
+ * Read declared goals from the user's profile.
+ * Returns a compact string like "DECLARED_GOALS: focus1 | focus2" (~11 tokens).
+ */
+function formatGoalContext(profilePath) {
+  try {
+    const yaml = require('js-yaml');
+    const profile = yaml.load(fs.readFileSync(profilePath, 'utf8')) || {};
+    const goals = [];
+    if (profile.status && profile.status.focus) goals.push(profile.status.focus);
+    if (profile.context && profile.context.focus && profile.context.focus !== (profile.status && profile.status.focus)) {
+      goals.push(profile.context.focus);
+    }
+    if (goals.length === 0) return '';
+    return `DECLARED_GOALS: ${goals.join(' | ')}`;
+  } catch { return ''; }
+}
+
+module.exports = {
+  findLatestUnanalyzedSession,
+  extractSkeleton,
+  formatForPrompt,
+  formatGoalContext,
+  markAnalyzed,
+};
+
+// Direct execution for testing
+if (require.main === module) {
+  console.log('🔍 Session Analytics — Testing\n');
+
+  const latest = findLatestUnanalyzedSession();
+  if (!latest) {
+    console.log('No unanalyzed sessions found.');
+    process.exit(0);
+  }
+
+  console.log(`Session: ${latest.session_id}`);
+  console.log(`Path: ${latest.path}`);
+  console.log(`Modified: ${new Date(latest.mtime).toISOString()}\n`);
+
+  const skeleton = extractSkeleton(latest.path);
+  console.log('Skeleton:', JSON.stringify(skeleton, null, 2));
+  console.log('\nPrompt format:', formatForPrompt(skeleton));
+
+  const goalCtx = formatGoalContext(path.join(HOME, '.claude_profile.yaml'));
+  if (goalCtx) console.log('Goal context:', goalCtx);
+}