metame-cli 1.2.1 → 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) {
@@ -294,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.");
@@ -412,6 +490,328 @@ 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);
+}
+
+// ---------------------------------------------------------
+// 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.1",
+    "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"
     }
-}
+}