metame-cli 1.2.0 → 1.2.2

package/README.md

@@ -4,17 +4,17 @@
   <img src="./logo.png" alt="MetaMe Logo" width="200"/>
 </p>
 
-> **The Meta-Cognitive Layer for Claude Code.**
+> **The Cognitive Profile Layer for Claude Code.**
 >
-> *Turn your AI assistant into a psychological mirror that knows you, evolves with you, and protects your core values.*
+> *Not a memory system — a cognitive mirror. It knows how you think, decide, and communicate, and it protects your core values.*
 
 ## 📖 Introduction
 
 **Claude Code** is a powerful tool, but it suffers from "Project Amnesia." Every time you switch folders, it forgets who you are, your communication style, and your specific constraints.
 
-**MetaMe** solves this by wrapping Claude in a  **Meta-Cognitive Layer** . It creates a persistent "Global Brain" that travels with you across every project. It knows your psychological profile, monitors your stress levels, and respects your core principles—without you having to repeat yourself.
+**MetaMe** solves this by wrapping Claude in a  **Cognitive Profile Layer** . It creates a persistent "Global Brain" that travels with you across every project. Unlike ChatGPT/Claude/Gemini's built-in memory (which stores *facts* like "user lives in X"), MetaMe captures *how you think* — your decision style, cognitive load preferences, motivation patterns, and communication traits.
 
-It is not just a launcher; it is a  **Meta Avatar** .
+It is not a memory system; it is a  **Cognitive Mirror** .
 
 ## ✨ Key Features
 
@@ -23,6 +23,9 @@ It is not just a launcher; it is a  **Meta Avatar** .
 * **🤝 Dynamic Handshake Protocol:** The "Canary Test." MetaMe verifies its connection to your profile by addressing you by your chosen **Codename** in the very first sentence. If it doesn't, you know the link is broken.
 * **🛡️ Auto-Lock Mechanism:** Mark any value in your profile with `# [LOCKED]`, and MetaMe will treat it as a constitution that cannot be overwritten.
 * **🔌 Smart Injection:** Automatically injects your profile context into the `CLAUDE.md` of any project you enter, ensuring seamless context switching.
+* **🧠 Passive Distillation:** MetaMe silently captures your messages via Claude Code hooks and, on next launch, uses a lightweight LLM (Haiku) to extract cognitive traits and preferences — automatically merging them into your profile with confidence-based upsert. Zero manual effort required.
+* **📊 Schema-Enforced Profile:** A 41-field whitelist across 5 tiers (T1-T5) prevents profile bloat. Fields have type validation, enum constraints, and token budget limits (800 tokens max).
+* **🎯 Confidence-Based Learning:** Strong directives ("always"/"以后一律") write directly. Normal observations accumulate in a pending queue and only promote to the profile after 3 consistent observations — preventing single-session bias.
 
 ## 🛠 Prerequisites
 
@@ -98,6 +101,32 @@ If you need to update a specific trait without editing the file manually:
 metame set-trait status.focus "Learning Rust"
 ```
 
+### Passive Distillation (Automatic)
+
+MetaMe automatically learns your cognitive patterns from conversations — no action needed.
+
+**How it works:**
+
+1. A global Claude Code hook captures every message, tagging each with a **confidence level** (high for strong directives like "always"/"以后一律", normal otherwise).
+2. On your next `metame` launch, a background Haiku model analyzes the buffer and extracts cognitive traits and preferences.
+3. **High-confidence** traits write directly to your profile. **Normal-confidence** traits enter a pending queue (`~/.metame/pending_traits.yaml`) and only promote after 3+ consistent observations.
+4. All writes are validated against a **41-field schema whitelist** — unknown keys are silently dropped, enum fields are type-checked, and a **token budget** (800 max) prevents bloat.
+5. The buffer is cleared, and Claude starts with a clean context.
+
+**Anti-bias safeguards:**
+- Single observations are treated as states, not traits
+- Contradictions are tracked, not blindly overwritten
+- Pending traits expire after 30 days without re-observation
+- Context fields (focus, energy) auto-expire on staleness
+
+You'll see this in the startup log:
+
+```
+🧠 MetaMe: Distilling 7 moments in background...
+```
+
+The hook is installed automatically on first run to `~/.claude/settings.json` (global scope — works across all projects).
+
 ### Hot Reload (Refresh)
 
 If you update your profile or need to fix a broken context **without restarting your session**:
@@ -115,25 +144,63 @@ Your profile is stored in a hidden YAML file in your home directory.
 
 You can edit this file manually to update your status or lock your values.
 
-**Example Profile:**
+**Example Profile (v2 Schema):**
 
 **YAML**
 
 ```
+# === T1: Identity (LOCKED) ===
 identity:
+  nickname: Neo              # [LOCKED]
   role: Senior Architect
-  nickname: Neo
-status:
-  focus: Refactoring Legacy Code
-  pressure: High
+  locale: en-US              # [LOCKED]
+
+# === T2: Core Traits (LOCKED) ===
+core_traits:
+  crisis_reflex: Analysis    # [LOCKED]
+  flow_trigger: Debugging    # [LOCKED]
+  learning_style: Hands-on   # [LOCKED]
+
+# === T3: Preferences (auto-learnable) ===
+preferences:
+  code_style: concise
+  communication: direct
+  explanation_depth: brief_rationale
+
+# === T3b: Cognition (auto-learnable, slow to change) ===
 cognition:
-  crisis_reflex: Strategic_Analysis
-  blind_spot: Perfectionism # [LOCKED]
-values:
-  core: "User Experience First" # [LOCKED]
+  decision_style: analytical
+  info_processing:
+    entry_point: big_picture
+    preferred_format: structured
+  cognitive_load:
+    chunk_size: medium
+    preferred_response_length: moderate
+
+# === T4: Context (auto-overwrite) ===
+context:
+  focus: "Refactoring Legacy Code"
+  energy: high
+
+# === T5: Evolution (system-managed) ===
+evolution:
+  distill_count: 12
+  last_distill: "2026-01-30T10:00:00Z"
 ```
 
-* **`# [LOCKED]`** : Adding this comment ensures that even as the AI evolves your profile, these specific lines will **never** be changed.
+* **T1-T2 fields** marked `# [LOCKED]` are never auto-modified.
+* **T3 fields** are auto-learned with confidence thresholds.
+* **T4 fields** are freely overwritten as your context changes.
+* **T5 fields** are managed by the distillation system.
+
+### Profile Migration (v1 → v2)
+
+If you have an existing v1 profile, run the migration script:
+
+```
+node ~/.metame/migrate-v2.js --dry-run   # preview changes
+node ~/.metame/migrate-v2.js             # apply migration (auto-backup created)
+```
 
 ## 🗑️ Uninstallation
 
@@ -159,7 +226,34 @@ If you want to delete your stored profile data:
 rm ~/.claude_profile.yaml
 ```
 
-### 3. Cleanup Project Files (Optional)
+### 3. Remove Passive Distillation Data (Optional)
+
+Remove the signal capture scripts:
+
+**Bash**
+
+```
+rm -rf ~/.metame
+```
+
+### 4. Remove the Signal Capture Hook (Optional)
+
+MetaMe installs a global hook in `~/.claude/settings.json`. To remove it, edit the file and delete the `UserPromptSubmit` entry under `hooks`, or run:
+
+**Bash**
+
+```
+node -e "
+const fs = require('fs');
+const p = require('os').homedir() + '/.claude/settings.json';
+const s = JSON.parse(fs.readFileSync(p, 'utf8'));
+if (s.hooks) { delete s.hooks.UserPromptSubmit; }
+fs.writeFileSync(p, JSON.stringify(s, null, 2));
+console.log('Hook removed.');
+"
+```
+
+### 5. Cleanup Project Files (Optional)
 
 MetaMe adds a header to `CLAUDE.md` files in your projects. To restore them to their original state (if you have many), you can use a text editor to remove the block starting with `## 🧠 SYSTEM KERNEL`.
 
@@ -172,6 +266,7 @@ You might worry: *"Does this eat up my context window?"*
 *   **Context Cost**: The entire MetaMe kernel + your profile takes up **~800-1000 tokens**.
 *   **Impact**: On a 200k context window, this is **0.5%** of the memory.
 *   **ROI**: By pre-loading your context, you avoid the "instructional drift" and repetitive correction loops that usually waste thousands of tokens at the start of every session.
+*   **Passive Distillation Cost**: The signal capture hook is a local Node.js script (zero API calls). The Haiku distillation on launch processes only a small buffer of filtered messages — typically a few hundred tokens at Haiku's very low cost.
 
 ## ❓ FAQ
 

package/index.js

@@ -11,6 +11,181 @@ const { spawn } = require('child_process');
 const HOME_DIR = os.homedir();
 const BRAIN_FILE = path.join(HOME_DIR, '.claude_profile.yaml');
 const PROJECT_FILE = path.join(process.cwd(), 'CLAUDE.md');
+const METAME_DIR = path.join(HOME_DIR, '.metame');
+const CLAUDE_SETTINGS = path.join(HOME_DIR, '.claude', 'settings.json');
+const SIGNAL_CAPTURE_SCRIPT = path.join(METAME_DIR, 'signal-capture.js');
+
+// ---------------------------------------------------------
+// 1.5 ENSURE METAME DIRECTORY + DEPLOY SCRIPTS
+// ---------------------------------------------------------
+if (!fs.existsSync(METAME_DIR)) {
+  fs.mkdirSync(METAME_DIR, { recursive: true });
+}
+
+// Auto-deploy bundled scripts to ~/.metame/
+const BUNDLED_SCRIPTS = ['signal-capture.js', 'distill.js', 'schema.js', 'pending-traits.js', 'migrate-v2.js'];
+const scriptsDir = path.join(__dirname, 'scripts');
+
+for (const script of BUNDLED_SCRIPTS) {
+  const src = path.join(scriptsDir, script);
+  const dest = path.join(METAME_DIR, script);
+  try {
+    if (fs.existsSync(src)) {
+      const srcContent = fs.readFileSync(src, 'utf8');
+      const destContent = fs.existsSync(dest) ? fs.readFileSync(dest, 'utf8') : '';
+      if (srcContent !== destContent) {
+        fs.writeFileSync(dest, srcContent, 'utf8');
+      }
+    }
+  } catch {
+    // Non-fatal
+  }
+}
+
+// ---------------------------------------------------------
+// 1.6 AUTO-INSTALL SIGNAL CAPTURE HOOK
+// ---------------------------------------------------------
+function ensureHookInstalled() {
+  try {
+    // Ensure ~/.claude/ exists
+    const claudeDir = path.join(HOME_DIR, '.claude');
+    if (!fs.existsSync(claudeDir)) {
+      fs.mkdirSync(claudeDir, { recursive: true });
+    }
+
+    let settings = {};
+    if (fs.existsSync(CLAUDE_SETTINGS)) {
+      settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS, 'utf8'));
+    }
+
+    // Check if our hook is already configured
+    const hookCommand = `node ${SIGNAL_CAPTURE_SCRIPT}`;
+    const existing = settings.hooks?.UserPromptSubmit || [];
+    const alreadyInstalled = existing.some(entry =>
+      entry.hooks?.some(h => h.command === hookCommand)
+    );
+
+    if (!alreadyInstalled) {
+      if (!settings.hooks) settings.hooks = {};
+      if (!settings.hooks.UserPromptSubmit) settings.hooks.UserPromptSubmit = [];
+
+      settings.hooks.UserPromptSubmit.push({
+        hooks: [{
+          type: 'command',
+          command: hookCommand
+        }]
+      });
+
+      fs.writeFileSync(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2), 'utf8');
+      console.log("🪝 MetaMe: Signal capture hook installed.");
+    }
+  } catch (e) {
+    // Non-fatal: hook install failure shouldn't block launch
+    console.error("⚠️  Hook install skipped:", e.message);
+  }
+}
+
+ensureHookInstalled();
+
+// ---------------------------------------------------------
+// 1.7 PASSIVE DISTILLATION (Background, post-launch)
+// ---------------------------------------------------------
+function shouldDistill() {
+  const bufferFile = path.join(METAME_DIR, 'raw_signals.jsonl');
+  if (!fs.existsSync(bufferFile)) return false;
+  const content = fs.readFileSync(bufferFile, 'utf8').trim();
+  return content.length > 0;
+}
+
+function spawnDistillBackground() {
+  const distillPath = path.join(METAME_DIR, 'distill.js');
+  if (!fs.existsSync(distillPath)) return;
+  if (!shouldDistill()) return;
+
+  const bufferFile = path.join(METAME_DIR, 'raw_signals.jsonl');
+  const lines = fs.readFileSync(bufferFile, 'utf8').trim().split('\n').filter(l => l.trim());
+  console.log(`🧠 MetaMe: Distilling ${lines.length} moment${lines.length > 1 ? 's' : ''} in background...`);
+
+  // Spawn as detached background process — won't block Claude launch
+  const bg = spawn('node', [distillPath], {
+    detached: true,
+    stdio: 'ignore'
+  });
+  bg.unref();
+}
+
+// ---------------------------------------------------------
+// 1.8 TIME-BASED EXPIRY (Startup cleanup)
+// ---------------------------------------------------------
+function runExpiryCleanup() {
+  try {
+    const yaml = require('js-yaml');
+    if (!fs.existsSync(BRAIN_FILE)) return;
+
+    const rawProfile = fs.readFileSync(BRAIN_FILE, 'utf8');
+    const profile = yaml.load(rawProfile);
+    if (!profile || typeof profile !== 'object') return;
+
+    const now = Date.now();
+    let changed = false;
+
+    // context.focus: if focus_since > 30 days, auto-clear
+    if (profile.context && profile.context.focus_since) {
+      const focusSince = new Date(profile.context.focus_since).getTime();
+      if (now - focusSince > 30 * 24 * 60 * 60 * 1000) {
+        profile.context.focus = null;
+        profile.context.focus_since = null;
+        changed = true;
+      }
+    }
+
+    // context.blockers: if > 14 days, auto-clear
+    // (blockers are arrays — clear entire array if stale)
+    if (profile.context && Array.isArray(profile.context.blockers) && profile.context.blockers.length > 0) {
+      // If we don't have a blockers_since timestamp, just leave them
+      // Future: add per-item timestamps
+    }
+
+    // context.energy: reset to null on each session start
+    if (profile.context && profile.context.energy !== undefined) {
+      if (profile.context.energy !== null) {
+        profile.context.energy = null;
+        changed = true;
+      }
+    }
+
+    if (changed) {
+      // Preserve comments
+      const commentMatch = rawProfile.match(/^(\s*[\w_]+\s*:.+?)\s+(#.+)$/gm);
+      const dumped = yaml.dump(profile, { lineWidth: -1 });
+      fs.writeFileSync(BRAIN_FILE, dumped, 'utf8');
+    }
+
+    // Expire stale pending traits
+    const pendingFile = path.join(METAME_DIR, 'pending_traits.yaml');
+    if (fs.existsSync(pendingFile)) {
+      const pending = yaml.load(fs.readFileSync(pendingFile, 'utf8')) || {};
+      const cutoff = 30 * 24 * 60 * 60 * 1000;
+      let expiredCount = 0;
+      for (const [key, meta] of Object.entries(pending)) {
+        if (meta.last_seen) {
+          const lastSeen = new Date(meta.last_seen).getTime();
+          if (now - lastSeen > cutoff) {
+            delete pending[key];
+            expiredCount++;
+          }
+        }
+      }
+      if (expiredCount > 0) {
+        fs.writeFileSync(pendingFile, yaml.dump(pending, { lineWidth: -1 }), 'utf8');
+      }
+    }
+  } catch {
+    // Non-fatal — expiry cleanup failure shouldn't block launch
+  }
+}
+
+runExpiryCleanup();
 
 // ---------------------------------------------------------
 // 2. BRAIN INITIALIZATION (Cold Start)
@@ -119,8 +294,86 @@ if (!isKnownUser) {
   console.log("🆕 User Unknown: Injecting Deep Genesis Protocol...");
 }
 
+// ---------------------------------------------------------
+// 4.5 MIRROR INJECTION (Phase C — metacognition observation)
+// ---------------------------------------------------------
+let mirrorLine = '';
+try {
+  if (isKnownUser && fs.existsSync(BRAIN_FILE)) {
+    const brainDoc = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
+
+    // Check quiet mode
+    const quietUntil = brainDoc.growth && brainDoc.growth.quiet_until;
+    const isQuiet = quietUntil && new Date(quietUntil).getTime() > Date.now();
+
+    // Check mirror enabled (default: true)
+    const mirrorEnabled = !(brainDoc.growth && brainDoc.growth.mirror_enabled === false);
+
+    if (!isQuiet && mirrorEnabled && brainDoc.growth && Array.isArray(brainDoc.growth.patterns)) {
+      const now = Date.now();
+      const COOLDOWN_MS = 14 * 24 * 60 * 60 * 1000; // 14 days
+
+      // Find a pattern that hasn't been surfaced in 14 days
+      const candidate = brainDoc.growth.patterns.find(p => {
+        if (!p.surfaced) return true;
+        return (now - new Date(p.surfaced).getTime()) > COOLDOWN_MS;
+      });
+
+      if (candidate) {
+        mirrorLine = `\n[MetaMe observation: ${candidate.summary} 不要主动提起，只在用户自然提到相关话题时温和回应。]\n`;
+
+        // Mark as surfaced
+        candidate.surfaced = new Date().toISOString().slice(0, 10);
+        fs.writeFileSync(BRAIN_FILE, yaml.dump(brainDoc, { lineWidth: -1 }), 'utf8');
+      }
+    }
+  }
+} catch {
+  // Non-fatal
+}
+
+// ---------------------------------------------------------
+// 4.6 REFLECTION PROMPT (Phase C — conditional, NOT static)
+// ---------------------------------------------------------
+// Only inject when trigger conditions are met at startup.
+// This ensures reflections don't fire every session.
+let reflectionLine = '';
+try {
+  if (isKnownUser && fs.existsSync(BRAIN_FILE)) {
+    const refDoc = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
+
+    // Check quiet mode
+    const quietUntil = refDoc.growth && refDoc.growth.quiet_until;
+    const isQuietForRef = quietUntil && new Date(quietUntil).getTime() > Date.now();
+
+    if (!isQuietForRef) {
+      const distillCount = (refDoc.evolution && refDoc.evolution.distill_count) || 0;
+      const zoneHistory = (refDoc.growth && refDoc.growth.zone_history) || [];
+
+      // Trigger 1: Every 7th session
+      const trigger7th = distillCount > 0 && distillCount % 7 === 0;
+
+      // Trigger 2: Three consecutive comfort-zone sessions
+      const lastThree = zoneHistory.slice(-3);
+      const triggerComfort = lastThree.length === 3 && lastThree.every(z => z === 'C');
+
+      if (trigger7th || triggerComfort) {
+        let hint = '';
+        if (triggerComfort) {
+          hint = '连续几次都在熟悉领域。如果用户在session结束时自然停顿，可以温和地问：🪞 准备好探索拉伸区了吗？';
+        } else {
+          hint = '这是第' + distillCount + '次session。如果session自然结束，可以附加一句：🪞 一个词形容这次session的感受？';
+        }
+        reflectionLine = `\n[MetaMe reflection: ${hint} 只在session即将结束时说一次。如果用户没回应就不要追问。]\n`;
+      }
+    }
+  }
+} catch {
+  // Non-fatal
+}
+
 // Prepend the new Protocol to the top
-const newContent = finalProtocol + "\n" + fileContent;
+const newContent = finalProtocol + mirrorLine + reflectionLine + "\n" + fileContent;
 fs.writeFileSync(PROJECT_FILE, newContent, 'utf8');
 
 console.log("🔮 MetaMe: Link Established.");
@@ -237,6 +490,79 @@ if (isSetTrait) {
   process.exit(0);
 }
 
+// ---------------------------------------------------------
+// 5.5 METACOGNITION CONTROL COMMANDS (Phase C)
+// ---------------------------------------------------------
+
+// metame quiet — silence mirror + reflections for 48 hours
+const isQuiet = process.argv.includes('quiet');
+if (isQuiet) {
+  try {
+    const doc = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
+    if (!doc.growth) doc.growth = {};
+    doc.growth.quiet_until = new Date(Date.now() + 48 * 60 * 60 * 1000).toISOString();
+    fs.writeFileSync(BRAIN_FILE, yaml.dump(doc, { lineWidth: -1 }), 'utf8');
+    console.log("🤫 MetaMe: Mirror & reflections silenced for 48 hours.");
+  } catch (e) {
+    console.error("❌ Error:", e.message);
+  }
+  process.exit(0);
+}
+
+// metame insights — show detected patterns
+const isInsights = process.argv.includes('insights');
+if (isInsights) {
+  try {
+    const doc = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
+    const patterns = (doc.growth && doc.growth.patterns) || [];
+    const zoneHistory = (doc.growth && doc.growth.zone_history) || [];
+
+    if (patterns.length === 0) {
+      console.log("🔍 MetaMe: No patterns detected yet. Keep using MetaMe and patterns will emerge after ~5 sessions.");
+    } else {
+      console.log("🪞 MetaMe Insights:\n");
+      patterns.forEach((p, i) => {
+        const icon = p.type === 'avoidance' ? '⚠️' : p.type === 'growth' ? '🌱' : p.type === 'energy' ? '⚡' : '🔄';
+        console.log(`   ${icon} [${p.type}] ${p.summary} (confidence: ${(p.confidence * 100).toFixed(0)}%)`);
+        console.log(`      Detected: ${p.detected}${p.surfaced ? `, Last shown: ${p.surfaced}` : ''}`);
+      });
+      if (zoneHistory.length > 0) {
+        console.log(`\n   📊 Recent zone history: ${zoneHistory.join(' → ')}`);
+        console.log(`      (C=Comfort, S=Stretch, P=Panic)`);
+      }
+      const answered = (doc.growth && doc.growth.reflections_answered) || 0;
+      const skipped = (doc.growth && doc.growth.reflections_skipped) || 0;
+      if (answered + skipped > 0) {
+        console.log(`\n   💭 Reflections: ${answered} answered, ${skipped} skipped`);
+      }
+    }
+  } catch (e) {
+    console.error("❌ Error:", e.message);
+  }
+  process.exit(0);
+}
+
+// metame mirror on/off — toggle mirror injection
+const isMirror = process.argv.includes('mirror');
+if (isMirror) {
+  const mirrorIndex = process.argv.indexOf('mirror');
+  const toggle = process.argv[mirrorIndex + 1];
+  if (toggle !== 'on' && toggle !== 'off') {
+    console.error("❌ Usage: metame mirror on|off");
+    process.exit(1);
+  }
+  try {
+    const doc = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
+    if (!doc.growth) doc.growth = {};
+    doc.growth.mirror_enabled = (toggle === 'on');
+    fs.writeFileSync(BRAIN_FILE, yaml.dump(doc, { lineWidth: -1 }), 'utf8');
+    console.log(`🪞 MetaMe: Mirror ${toggle === 'on' ? 'enabled' : 'disabled'}.`);
+  } catch (e) {
+    console.error("❌ Error:", e.message);
+  }
+  process.exit(0);
+}
+
 // ---------------------------------------------------------
 // ---------------------------------------------------------
 // 6. SAFETY GUARD: RECURSION PREVENTION (v2)
@@ -263,4 +589,7 @@ child.on('error', (err) => {
   console.error("\n❌ Error: Could not launch 'claude'.");
   console.error("   Please make sure Claude Code is installed globally:");
   console.error("   npm install -g @anthropic-ai/claude-code");
-});
+});
+
+// Launch background distillation AFTER Claude starts — no blocking
+spawnDistillBackground();

package/package.json

@@ -1,11 +1,15 @@
 {
     "name": "metame-cli",
-    "version": "1.2.0",
-    "description": "The Meta-Cognitive Layer for Claude Code. Turns your AI into a psychological partner.",
+    "version": "1.2.2",
+    "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
         "metame": "./index.js"
     },
+    "files": [
+        "index.js",
+        "scripts/"
+    ],
     "scripts": {
         "start": "node index.js"
     },