metame-cli 1.2.2 → 1.3.0

package/README.md

@@ -18,14 +18,11 @@ It is not a memory system; it is a  **Cognitive Mirror** .
 
 ## ✨ Key Features
 
-* **🧠 Global Brain (`~/.claude_profile.yaml`):** A single source of truth for your identity, storing your nickname, stress status, and cognitive traits.
-* **🧬 Evolution Mechanism:** You are in control. Use `!metame evolve` to manually teach Claude about your new preferences or constraints, ensuring it gets smarter with every interaction.
-* **🤝 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.
+* **🧠 Global Brain (`~/.claude_profile.yaml`):** A single, portable source of truth — your identity, cognitive traits, and preferences travel with you across every project.
+* **🧬 Cognitive Evolution Engine:** MetaMe learns how you think through three channels: (1) **Passive** — silently captures your messages and distills cognitive traits via Haiku on next launch; (2) **Manual** — `!metame evolve` for explicit teaching; (3) **Confidence gates** — strong directives ("always"/"以后一律") write immediately, normal observations need 3+ consistent sightings before promotion. Schema-enforced (41 fields, 5 tiers, 800 token budget) to prevent bloat.
+* **🤝 Dynamic Handshake:** The "Canary Test." Claude must address you by your **Codename** in the first sentence. If it doesn't, the link is broken.
+* **🛡️ Auto-Lock:** Mark any value with `# [LOCKED]` — treated as a constitution, never auto-modified.
+* **📱 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.
 
 ## 🛠 Prerequisites
 
@@ -91,41 +88,119 @@ 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)
+### Cognitive Evolution
 
-If you need to update a specific trait without editing the file manually:
+MetaMe learns who you are through two paths:
 
-**Bash**
+**Automatic (zero effort):** A global hook captures your messages. On next launch, Haiku distills cognitive traits in the background. Strong directives ("always"/"以后一律") write immediately; normal observations need 3+ consistent sightings. All writes are schema-validated (41 fields, 800 token budget). You'll see:
 
 ```
+🧠 MetaMe: Distilling 7 moments in background...
+```
+
+**Manual:** Update a specific trait directly:
+
+```bash
 metame set-trait status.focus "Learning Rust"
+metame evolve "I prefer functional programming patterns"
 ```
 
-### Passive Distillation (Automatic)
+**Anti-bias safeguards:** single observations ≠ traits, contradictions are tracked not overwritten, pending traits expire after 30 days, context fields auto-clear on staleness.
 
-MetaMe automatically learns your cognitive patterns from conversations — no action needed.
+### Remote Claude Code — Telegram & Feishu (v1.3)
 
-**How it works:**
+Full Claude Code from your phone — stateful sessions with conversation history, tool use, and file editing. Supports both Telegram and Feishu (Lark).
 
-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.
+**Setup:**
+
+```bash
+metame daemon init                    # Create config + setup guide
+```
 
-**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
+Edit `~/.metame/daemon.yaml`:
 
-You'll see this in the startup log:
+```yaml
+telegram:
+  enabled: true
+  bot_token: "YOUR_BOT_TOKEN"         # From @BotFather
+  allowed_chat_ids:
+    - 123456789                        # Your Telegram chat ID
 
+feishu:
+  enabled: true
+  app_id: "YOUR_APP_ID"              # From Feishu Developer Console
+  app_secret: "YOUR_APP_SECRET"
+  allowed_chat_ids: []                # Empty = allow all
 ```
-🧠 MetaMe: Distilling 7 moments in background...
+
+**Start the daemon:**
+
+```bash
+metame daemon start                   # Background process
+metame daemon status                  # Check if running
+metame daemon logs                    # Tail the log
+metame daemon stop                    # Shutdown
+metame daemon install-launchd         # macOS auto-start (RunAtLoad + KeepAlive)
+```
+
+**Session commands (interactive buttons on Telegram & Feishu):**
+
+| Command | Description |
+|---------|-------------|
+| `/new` | Start new session — pick project directory from button list |
+| `/resume` | Resume a session — clickable list scoped to current workdir |
+| `/continue` | Continue the most recent terminal session |
+| `/cd` | Change working directory — with directory browser |
+| `/session` | Current session info |
+
+Just type naturally for conversation — every message stays in the same Claude Code session with full context.
+
+**How it works:**
+
+Each chat gets a persistent session via `claude -p --resume <session-id>`. This is the same Claude Code engine as your terminal — same tools (file editing, bash, code search), same conversation history. You can start work on your computer and `/resume` from your phone, or vice versa.
+
+**Other commands:**
+
+| Command | Description |
+|---------|-------------|
+| `/status` | Daemon status + profile summary |
+| `/tasks` | List scheduled heartbeat tasks |
+| `/run <name>` | Run a task immediately |
+| `/budget` | Today's token usage |
+| `/quiet` | Silence mirror/reflections for 48h |
+
+**Heartbeat Tasks:**
+
+Define scheduled tasks in `daemon.yaml`:
+
+```yaml
+heartbeat:
+  tasks:
+    - name: "morning-news"
+      prompt: "Summarize today's top 3 AI news stories."
+      interval: "24h"
+      model: "haiku"
+      notify: true
+      precondition: "curl -s -o /dev/null -w '%{http_code}' https://news.ycombinator.com | grep 200"
 ```
 
-The hook is installed automatically on first run to `~/.claude/settings.json` (global scope — works across all projects).
+* `precondition`: Shell command — empty output → task skipped, zero tokens.
+* `type: "script"`: Run a local script directly instead of `claude -p`.
+* `notify: true`: Push results to Telegram/Feishu.
+
+**Token efficiency:**
+
+* Polling, slash commands, directory browsing: **zero tokens**
+* Stateful sessions: same cost as using Claude Code in terminal (conversation history managed by Claude CLI)
+* Budget tracking with daily limit (default 50k tokens)
+* 10-second cooldown between Claude calls
+
+**Security:**
+
+* `allowed_chat_ids` whitelist — unauthorized users silently ignored
+* No `--dangerously-skip-permissions` — standard `-p` mode permissions
+* `~/.metame/` directory set to mode 700
+* Bot tokens stored locally, never transmitted
 
 ### Hot Reload (Refresh)
 
@@ -226,7 +301,15 @@ If you want to delete your stored profile data:
 rm ~/.claude_profile.yaml
 ```
 
-### 3. Remove Passive Distillation Data (Optional)
+### 3. Stop the Daemon (if running)
+
+```bash
+metame daemon stop
+launchctl unload ~/Library/LaunchAgents/com.metame.daemon.plist 2>/dev/null
+rm -f ~/Library/LaunchAgents/com.metame.daemon.plist
+```
+
+### 4. Remove Passive Distillation Data (Optional)
 
 Remove the signal capture scripts:
 
@@ -236,7 +319,7 @@ Remove the signal capture scripts:
 rm -rf ~/.metame
 ```
 
-### 4. Remove the Signal Capture Hook (Optional)
+### 5. 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:
 
@@ -253,7 +336,7 @@ console.log('Hook removed.');
 "
 ```
 
-### 5. Cleanup Project Files (Optional)
+### 6. 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`.
 

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'];
+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 scriptsDir = path.join(__dirname, 'scripts');
 
 for (const script of BUNDLED_SCRIPTS) {
@@ -563,6 +563,255 @@ if (isMirror) {
   process.exit(0);
 }
 
+// ---------------------------------------------------------
+// 5.6 DAEMON SUBCOMMANDS
+// ---------------------------------------------------------
+const isDaemon = process.argv.includes('daemon');
+if (isDaemon) {
+  const daemonIndex = process.argv.indexOf('daemon');
+  const subCmd = process.argv[daemonIndex + 1];
+  const DAEMON_CONFIG = path.join(METAME_DIR, 'daemon.yaml');
+  const DAEMON_STATE = path.join(METAME_DIR, 'daemon_state.json');
+  const DAEMON_PID = path.join(METAME_DIR, 'daemon.pid');
+  const DAEMON_LOG = path.join(METAME_DIR, 'daemon.log');
+  const DAEMON_DEFAULT = path.join(__dirname, 'scripts', 'daemon-default.yaml');
+  const DAEMON_SCRIPT = path.join(METAME_DIR, 'daemon.js');
+
+  if (subCmd === 'init') {
+    // Create config from template
+    if (fs.existsSync(DAEMON_CONFIG)) {
+      console.log("⚠️  daemon.yaml already exists at ~/.metame/daemon.yaml");
+      console.log("   Delete it first if you want to re-initialize.");
+    } else {
+      const templateSrc = fs.existsSync(DAEMON_DEFAULT)
+        ? DAEMON_DEFAULT
+        : path.join(METAME_DIR, 'daemon-default.yaml');
+      if (fs.existsSync(templateSrc)) {
+        fs.copyFileSync(templateSrc, DAEMON_CONFIG);
+      } else {
+        console.error("❌ Template not found. Reinstall MetaMe.");
+        process.exit(1);
+      }
+      // Ensure directory permissions (700)
+      try { fs.chmodSync(METAME_DIR, 0o700); } catch { /* ignore on Windows */ }
+      console.log("✅ MetaMe daemon initialized.");
+      console.log(`   Config: ${DAEMON_CONFIG}`);
+    }
+
+    console.log("\n📱 Telegram Setup (optional):");
+    console.log("   1. Message @BotFather on Telegram → /newbot");
+    console.log("   2. Copy the bot token");
+    console.log("   3. Edit ~/.metame/daemon.yaml:");
+    console.log("      telegram:");
+    console.log("        enabled: true");
+    console.log("        bot_token: \"YOUR_TOKEN\"");
+    console.log("        allowed_chat_ids: [YOUR_CHAT_ID]");
+    console.log("   4. To find your chat_id: message your bot, then run:");
+    console.log("      curl https://api.telegram.org/botYOUR_TOKEN/getUpdates");
+    console.log("\n📘 Feishu Setup (optional):");
+    console.log("   1. Go to open.feishu.cn → Create App → get app_id & app_secret");
+    console.log("   2. Enable Bot capability + im:message events");
+    console.log("   3. Enable 'Long Connection' (长连接) mode in Event Subscription");
+    console.log("   4. Edit ~/.metame/daemon.yaml:");
+    console.log("      feishu:");
+    console.log("        enabled: true");
+    console.log("        app_id: \"YOUR_APP_ID\"");
+    console.log("        app_secret: \"YOUR_APP_SECRET\"");
+    console.log("        allowed_chat_ids: [CHAT_ID]");
+
+    console.log("\n   Then: metame daemon start");
+
+    // Optional launchd setup (macOS only)
+    if (process.platform === 'darwin') {
+      const plistDir = path.join(HOME_DIR, 'Library', 'LaunchAgents');
+      const plistPath = path.join(plistDir, 'com.metame.daemon.plist');
+      console.log("\n🍎 Auto-start on macOS (optional):");
+      console.log("   To start daemon automatically on login:");
+      console.log(`   metame daemon start  (first time to verify it works)`);
+      console.log(`   Then create: ${plistPath}`);
+      console.log("   Or run: metame daemon install-launchd");
+    }
+    process.exit(0);
+  }
+
+  if (subCmd === 'install-launchd') {
+    if (process.platform !== 'darwin') {
+      console.error("❌ launchd is macOS-only.");
+      process.exit(1);
+    }
+    const plistDir = path.join(HOME_DIR, 'Library', 'LaunchAgents');
+    if (!fs.existsSync(plistDir)) fs.mkdirSync(plistDir, { recursive: true });
+    const plistPath = path.join(plistDir, 'com.metame.daemon.plist');
+    const nodePath = process.execPath;
+    // Capture current PATH so launchd can find `claude` and other tools
+    const currentPath = process.env.PATH || '/usr/local/bin:/usr/bin:/bin';
+    const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.metame.daemon</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${DAEMON_SCRIPT}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${DAEMON_LOG}</string>
+  <key>StandardErrorPath</key>
+  <string>${DAEMON_LOG}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>METAME_ROOT</key>
+    <string>${__dirname}</string>
+    <key>PATH</key>
+    <string>${currentPath}</string>
+    <key>HOME</key>
+    <string>${HOME_DIR}</string>
+  </dict>
+</dict>
+</plist>`;
+    fs.writeFileSync(plistPath, plistContent, 'utf8');
+    console.log(`✅ launchd plist installed: ${plistPath}`);
+    console.log("   Load now: launchctl load " + plistPath);
+    console.log("   Unload:   launchctl unload " + plistPath);
+    process.exit(0);
+  }
+
+  if (subCmd === 'start') {
+    // Check if already running
+    if (fs.existsSync(DAEMON_PID)) {
+      const existingPid = parseInt(fs.readFileSync(DAEMON_PID, 'utf8').trim(), 10);
+      try {
+        process.kill(existingPid, 0); // test if alive
+        console.log(`⚠️  Daemon already running (PID: ${existingPid})`);
+        console.log("   Use 'metame daemon stop' first.");
+        process.exit(1);
+      } catch {
+        // Stale PID file — clean up
+        fs.unlinkSync(DAEMON_PID);
+      }
+    }
+    if (!fs.existsSync(DAEMON_CONFIG)) {
+      console.error("❌ No config found. Run: metame daemon init");
+      process.exit(1);
+    }
+    if (!fs.existsSync(DAEMON_SCRIPT)) {
+      console.error("❌ daemon.js not found. Reinstall MetaMe.");
+      process.exit(1);
+    }
+    const bg = spawn(process.execPath, [DAEMON_SCRIPT], {
+      detached: true,
+      stdio: 'ignore',
+      env: { ...process.env, HOME: HOME_DIR, METAME_ROOT: __dirname },
+    });
+    bg.unref();
+    console.log(`✅ MetaMe daemon started (PID: ${bg.pid})`);
+    console.log("   Logs: metame daemon logs");
+    console.log("   Stop: metame daemon stop");
+    process.exit(0);
+  }
+
+  if (subCmd === 'stop') {
+    if (!fs.existsSync(DAEMON_PID)) {
+      console.log("ℹ️  No daemon running (no PID file).");
+      process.exit(0);
+    }
+    const pid = parseInt(fs.readFileSync(DAEMON_PID, 'utf8').trim(), 10);
+    try {
+      process.kill(pid, 'SIGTERM');
+      console.log(`✅ Daemon stopped (PID: ${pid})`);
+    } catch (e) {
+      console.log(`⚠️  Process ${pid} not found (may have already exited).`);
+      fs.unlinkSync(DAEMON_PID);
+    }
+    process.exit(0);
+  }
+
+  if (subCmd === 'status') {
+    let state = {};
+    try { state = JSON.parse(fs.readFileSync(DAEMON_STATE, 'utf8')); } catch { /* empty */ }
+
+    // Check if running
+    let isRunning = false;
+    if (fs.existsSync(DAEMON_PID)) {
+      const pid = parseInt(fs.readFileSync(DAEMON_PID, 'utf8').trim(), 10);
+      try { process.kill(pid, 0); isRunning = true; } catch { /* dead */ }
+    }
+
+    console.log(`🤖 MetaMe Daemon: ${isRunning ? '🟢 Running' : '🔴 Stopped'}`);
+    if (state.started_at) console.log(`   Started: ${state.started_at}`);
+    if (state.pid) console.log(`   PID: ${state.pid}`);
+
+    // Budget
+    const budget = state.budget || {};
+    const config = {};
+    try { Object.assign(config, yaml.load(fs.readFileSync(DAEMON_CONFIG, 'utf8'))); } catch { /* empty */ }
+    const limit = (config.budget && config.budget.daily_limit) || 50000;
+    console.log(`   Budget: ${budget.tokens_used || 0}/${limit} tokens (${budget.date || 'no data'})`);
+
+    // Tasks
+    const tasks = state.tasks || {};
+    if (Object.keys(tasks).length > 0) {
+      console.log("   Recent tasks:");
+      for (const [name, info] of Object.entries(tasks)) {
+        const icon = info.status === 'success' ? '✅' : '❌';
+        console.log(`     ${icon} ${name}: ${info.last_run || 'unknown'}`);
+        if (info.output_preview) console.log(`        ${info.output_preview.slice(0, 80)}...`);
+      }
+    }
+    process.exit(0);
+  }
+
+  if (subCmd === 'logs') {
+    if (!fs.existsSync(DAEMON_LOG)) {
+      console.log("ℹ️  No log file yet. Start the daemon first.");
+      process.exit(0);
+    }
+    const content = fs.readFileSync(DAEMON_LOG, 'utf8');
+    const lines = content.split('\n');
+    const tail = lines.slice(-50).join('\n');
+    console.log(tail);
+    process.exit(0);
+  }
+
+  if (subCmd === 'run') {
+    const taskName = process.argv[daemonIndex + 2];
+    if (!taskName) {
+      console.error("❌ Usage: metame daemon run <task-name>");
+      process.exit(1);
+    }
+    if (!fs.existsSync(DAEMON_SCRIPT)) {
+      console.error("❌ daemon.js not found. Reinstall MetaMe.");
+      process.exit(1);
+    }
+    // Run in foreground using daemon.js --run
+    const result = require('child_process').spawnSync(
+      process.execPath,
+      [DAEMON_SCRIPT, '--run', taskName],
+      { stdio: 'inherit', env: { ...process.env, HOME: HOME_DIR, METAME_ROOT: __dirname } }
+    );
+    process.exit(result.status || 0);
+  }
+
+  // Unknown subcommand
+  console.log("📖 MetaMe Daemon Commands:");
+  console.log("   metame daemon init           — initialize config");
+  console.log("   metame daemon start           — start background daemon");
+  console.log("   metame daemon stop            — stop daemon");
+  console.log("   metame daemon status          — show status & budget");
+  console.log("   metame daemon logs            — tail log file");
+  console.log("   metame daemon run <name>      — run a task once");
+  if (process.platform === 'darwin') {
+    console.log("   metame daemon install-launchd — auto-start on macOS");
+  }
+  process.exit(0);
+}
+
 // ---------------------------------------------------------
 // ---------------------------------------------------------
 // 6. SAFETY GUARD: RECURSION PREVENTION (v2)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.2.2",
+    "version": "1.3.0",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -23,9 +23,10 @@
     "author": "Yaron",
     "license": "MIT",
     "dependencies": {
+        "@larksuiteoapi/node-sdk": "^1.58.0",
         "js-yaml": "^4.1.1"
     },
     "engines": {
         "node": ">=14"
     }
-}
+}

package/scripts/daemon-default.yaml

@@ -0,0 +1,49 @@
+# MetaMe Daemon Configuration
+# Generated by: metame daemon init
+
+telegram:
+  enabled: false
+  bot_token: null
+  allowed_chat_ids: []
+
+feishu:
+  enabled: false
+  app_id: null
+  app_secret: null
+  allowed_chat_ids: []
+
+heartbeat:
+  tasks: []
+    # Examples — uncomment or add your own:
+    #
+    # Scheduled task (calls claude -p with your profile context):
+    # - name: "morning-news"
+    #   prompt: "抓取今天的AI领域重要新闻，整理成3条摘要，中英双语。"
+    #   interval: "24h"
+    #   model: "haiku"
+    #   notify: true
+    #
+    # - name: "weekly-review"
+    #   prompt: "基于我的profile，生成本周个人成长回顾和下周建议。"
+    #   interval: "7d"
+    #   model: "haiku"
+    #   notify: true
+    #
+    # Script task (runs a local script directly, no claude -p):
+    # - name: "distill"
+    #   type: "script"
+    #   command: "node ~/.metame/distill.js"
+    #   interval: "6h"
+    #   precondition: "test -s ~/.metame/raw_signals.jsonl"
+    #   notify: false
+    #
+    # precondition: shell command, empty output → skip (zero tokens)
+    # type: "script" → runs command directly instead of claude -p
+
+budget:
+  daily_limit: 50000
+  warning_threshold: 0.8
+
+daemon:
+  log_max_size: 1048576
+  heartbeat_check_interval: 60