metame-cli 1.1.3 → 1.2.1

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,20 +23,16 @@ 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
 
-MetaMe is a wrapper around  **Claude Code** . You must have Node.js and the official Claude Code tool installed first.
+MetaMe is a wrapper around **Claude Code**. You must have Node.js and the official Claude Code tool installed first.
 
-1. **Node.js** : Version 14 or higher.
-2. **Claude Code** :
-   **Bash**
-
-```
-   npm install -g @anthropic-ai/claude-code
-```
-
-1. **Auth** : Ensure you have logged in via `claude login`.
+1. **Node.js**: Version 14 or higher.
+2. **Claude Code**: Ensure `claude` is available in your PATH and you are logged in.
 
 ## 📦 Installation
 
@@ -84,6 +80,53 @@ When you run MetaMe for the first time, it will detect that your profile is empt
 3. Claude will start and immediately say: *"Ready, [Your Name]..."*
 4. Start coding. MetaMe manages the context in the background.
 
+### Global Initialization (Reset/Interview)
+
+If you want to restart the **Genesis Interview** to update your psychological profile:
+
+**Bash**
+
+```
+metame interview
+```
+(Command to be implemented in v1.3 - currently you can manually edit `~/.claude_profile.yaml` or use `set-trait`)
+
+### Surgical Update (Manual Override)
+
+If you need to update a specific trait without editing the file manually:
+
+**Bash**
+
+```
+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**:
@@ -101,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
 
@@ -145,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`.
 
@@ -158,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)
@@ -48,8 +223,10 @@ const CORE_PROTOCOL = `
 
 **3. EVOLUTION MECHANISM (Manual Sync):**
    *   **PHILOSOPHY:** You respect the User's flow. You do NOT interrupt.
-   *   **TOOL:** You have the capability to save insights using \`!metame evolve "Insight"\`.
-   *   **RULE:** Only use this tool when the User **EXPLICITLY** instructs you to "remember this", "save this preference", or "update my profile".
+   *   **TOOLS:**
+       1. **Log Insight:** \`!metame evolve "Insight"\` (For additive knowledge).
+       2. **Surgical Update:** \`!metame set-trait key value\` (For overwriting specific fields, e.g., \`!metame set-trait status.focus "API Design"\`).
+   *   **RULE:** Only use these tools when the User **EXPLICITLY** instructs you.
    *   **REMINDER:** If the User expresses a strong persistent preference, you may gently ask *at the end of the task*: "Should I save this preference to your MetaMe profile?"
 ---
 `;
@@ -182,6 +359,59 @@ if (isEvolve) {
   process.exit(0);
 }
 
+// Check for "set-trait" command (Surgical Update)
+const isSetTrait = process.argv.includes('set-trait');
+
+if (isSetTrait) {
+  const yaml = require('js-yaml');
+
+  // Syntax: metame set-trait <key> <value>
+  // Example: metame set-trait identity.role "Engineering Manager"
+
+  const setIndex = process.argv.indexOf('set-trait');
+  const key = process.argv[setIndex + 1];
+  // Join the rest as the value (allows spaces)
+  const value = process.argv.slice(setIndex + 2).join(' ').trim();
+
+  if (!key || !value) {
+    console.error("❌ Error: Missing key or value.");
+    console.error("   Usage: metame set-trait identity.role \"New Role\"");
+    process.exit(1);
+  }
+
+  try {
+    if (fs.existsSync(BRAIN_FILE)) {
+      const rawContent = fs.readFileSync(BRAIN_FILE, 'utf8');
+      const doc = yaml.load(rawContent) || {};
+
+      // Helper to set nested property
+      const setNested = (obj, path, val) => {
+        const keys = path.split('.');
+        let current = obj;
+        for (let i = 0; i < keys.length - 1; i++) {
+          if (!current[keys[i]]) current[keys[i]] = {};
+          current = current[keys[i]];
+        }
+        current[keys[keys.length - 1]] = val;
+      };
+
+      // Set the value
+      setNested(doc, key, value);
+
+      fs.writeFileSync(BRAIN_FILE, yaml.dump(doc), 'utf8');
+
+      console.log(`🧠 MetaMe Brain Surgically Updated.`);
+      console.log(`   Set \`${key}\` = "${value}"`);
+      console.log("   (Run 'metame refresh' to apply this to the current session)");
+    } else {
+      console.error("❌ Error: No profile found.");
+    }
+  } catch (e) {
+    console.error("❌ Error updating profile:", e.message);
+  }
+  process.exit(0);
+}
+
 // ---------------------------------------------------------
 // ---------------------------------------------------------
 // 6. SAFETY GUARD: RECURSION PREVENTION (v2)
@@ -208,4 +438,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.1.3",
-    "description": "The Meta-Cognitive Layer for Claude Code. Turns your AI into a psychological partner.",
+    "version": "1.2.1",
+    "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"
     },