metame-cli 1.2.2 → 1.3.1

package/README.md

@@ -18,14 +18,13 @@ 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.
+* **🪞 Metacognition Layer (v1.3):** MetaMe now observes *how* you think, not just *what* you say. Behavioral pattern detection runs inside the existing Haiku distill call (zero extra cost). It tracks decision patterns, cognitive load, comfort zones, and avoidance topics across sessions. When persistent patterns emerge, MetaMe injects a one-line mirror observation — e.g., *"You tend to avoid testing until forced"* — with a 14-day cooldown per pattern. Conditional reflection prompts appear only when triggered (every 7th distill or 3x consecutive comfort zone). All injection logic runs in Node.js; Claude receives only pre-decided directives, never rules to self-evaluate.
+* **📱 Remote Claude Code (v1.3):** Full Claude Code from your phone via Telegram or Feishu (Lark). Stateful sessions with `--resume` — same conversation history, tool use, and file editing as your terminal. Interactive buttons for project/session picking, directory browser, and macOS launchd auto-start.
+* **🔄 Workflow Engine (v1.3):** Define multi-step skill chains as heartbeat tasks. Each workflow runs in a single Claude Code session via `--resume`, so step outputs flow as context to the next step. Example: `deep-research` → `tech-writing` → `wechat-publisher` — fully automated content pipeline.
 
 ## 🛠 Prerequisites
 
@@ -91,41 +90,152 @@ 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"
+```
+
+**Anti-bias safeguards:** single observations ≠ traits, contradictions are tracked not overwritten, pending traits expire after 30 days, context fields auto-clear on staleness.
+
+**Metacognition controls:**
+
+```bash
+metame quiet            # Silence mirror observations & reflections for 48h
+metame insights         # Show detected behavioral patterns
+metame mirror on|off    # Toggle mirror injection
+```
+
+### Remote Claude Code — Telegram & Feishu (v1.3)
+
+Full Claude Code from your phone — stateful sessions with conversation history, tool use, and file editing. Supports both Telegram and Feishu (Lark).
+
+**Setup:**
+
+```bash
+metame daemon init                    # Create config + setup guide
+```
+
+Edit `~/.metame/daemon.yaml`:
+
+```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
 ```
 
-### Passive Distillation (Automatic)
+**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 |
 
-MetaMe automatically learns your cognitive patterns from conversations — no action needed.
+Just type naturally for conversation — every message stays in the same Claude Code session with full context.
 
 **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.
+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.
 
-**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
+**Other commands:**
 
-You'll see this in the startup log:
+| 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 |
+| `/reload` | Manually reload daemon.yaml (also auto-reloads on file change) |
 
+**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"
 ```
-🧠 MetaMe: Distilling 7 moments in background...
+
+* `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.
+
+**Workflow tasks** (multi-step skill chains):
+
+```yaml
+heartbeat:
+  tasks:
+    - name: "daily-wechat"
+      type: "workflow"
+      interval: "24h"
+      model: "sonnet"
+      notify: true
+      steps:
+        - skill: "deep-research"
+          prompt: "Today's top 3 AI news stories"
+        - skill: "tech-writing"
+          prompt: "Write a WeChat article based on the research above"
+        - skill: "wechat-publisher"
+          prompt: "Publish the article"
+          optional: true
 ```
 
-The hook is installed automatically on first run to `~/.claude/settings.json` (global scope — works across all projects).
+Each step runs in the same Claude Code session. Step outputs automatically become context for the next step. Set `optional: true` on steps that may fail without aborting the workflow.
+
+**Auto-reload:** The daemon watches `daemon.yaml` for changes. When Claude (or you) edits the config file, the daemon automatically reloads — no restart or `/reload` needed. A notification is pushed to confirm.
+
+**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 +336,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 +354,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 +371,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.1",
     "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