metame-cli 1.3.16 → 1.3.18

package/README.md

@@ -64,20 +64,31 @@ MetaMe is a wrapper around **Claude Code**. You must have Node.js and the offici
 
 ## 📦 Installation
 
-**Option A: NPM (recommended)** — full CLI with daemon, mobile bridge, interview
+**One-command install (recommended)** — installs Node.js, Claude Code, and MetaMe:
+
+macOS / Linux:
+```bash
+curl -fsSL https://raw.githubusercontent.com/Yaron9/MetaMe/main/install.sh | bash
+```
+
+Windows (PowerShell):
+```powershell
+irm https://raw.githubusercontent.com/Yaron9/MetaMe/main/install.ps1 | iex
+```
+> Windows uses WSL (auto-installed if missing). After WSL install you'll need to reboot once, then re-run the command.
+
+**Manual install** — if you already have Node.js and Claude Code:
 
 ```bash
 npm install -g metame-cli
 ```
 
-**Option B: Claude Code Plugin** — lightweight, profile injection + slash commands
+**Claude Code Plugin** — lightweight alternative, profile injection + slash commands only:
 
 ```bash
 claude plugin install github:Yaron9/MetaMe/plugin
 ```
 
-*(NPM note: If you encounter permission errors on Mac/Linux, use `sudo npm install -g metame-cli`)*
-
 ## 🚀 Usage
 
 Forget the `claude` command. From now on, simply type:
@@ -186,7 +197,7 @@ feishu:
   enabled: true
   app_id: "YOUR_APP_ID"              # From Feishu Developer Console
   app_secret: "YOUR_APP_SECRET"
-  allowed_chat_ids: []                # Empty = allow all
+  allowed_chat_ids: []                # Empty = deny all (fill via setup wizard)
 ```
 
 **Start the daemon:**
@@ -196,30 +207,25 @@ metame start                          # Background process
 metame status                         # Check if running
 metame logs                           # Tail the log
 metame stop                           # Shutdown
-metame daemon install-launchd         # macOS auto-start (RunAtLoad + KeepAlive)
+metame daemon install-launchd         # macOS auto-start
+metame daemon install-systemd         # Linux/WSL auto-start
 ```
 
-**macOS auto-start (recommended):** If you want the daemon to survive sleep/wake and start on boot:
+**Auto-start (recommended):** The daemon survives reboots and auto-restarts on crash.
 
+macOS:
 ```bash
 metame daemon install-launchd
 launchctl load ~/Library/LaunchAgents/com.metame.daemon.plist
 ```
 
-Once loaded, the daemon auto-starts on login, auto-restarts after sleep/wake or crash. No need to run `metame start` manually anymore.
-
-> **Important:** Choose one management method — either launchd or manual (`metame start/stop`). Don't mix them, or you'll get duplicate processes.
-
+Linux / WSL:
 ```bash
-# Check status (works with both methods)
-metame status
-
-# Disable auto-start
-launchctl unload ~/Library/LaunchAgents/com.metame.daemon.plist
-
-# Remove completely
-rm ~/Library/LaunchAgents/com.metame.daemon.plist
+metame daemon install-systemd
 ```
+> WSL requires systemd enabled: add `[boot]\nsystemd=true` to `/etc/wsl.conf` and restart WSL.
+
+> **Important:** Choose one management method — either auto-start or manual (`metame start/stop`). Don't mix them, or you'll get duplicate processes.
 
 **Session commands (interactive buttons on Telegram & Feishu):**
 
@@ -300,7 +306,7 @@ Uploaded files are saved to `<project>/upload/`. Claude won't read large files a
 
 *`/stop` — ESC equivalent:* Sends SIGINT to the running Claude process. Instant interruption, just like pressing ESC in your terminal.
 
-*`/undo` — ESC×2 equivalent:* Interactive turn picker showing your actual messages. Select which turn to roll back to — session history is truncated and all modified files are restored using Claude's native `~/.claude/file-history/` backups (the exact same mechanism as pressing ESC twice in the terminal). Files created during undone turns are deleted; files deleted during undone turns are restored. Zero risk.
+*`/undo` — git-based code rollback (v1.3.16):* Before each Claude turn, the daemon auto-commits a `[metame-checkpoint]` to git. `/undo` lists recent checkpoints; tap one to `git reset --hard` back to that state. Session history is also truncated. Reliable across both `-p` mode and interactive sessions — no dependency on Claude CLI internals.
 
 ```
 You: /undo
@@ -310,7 +316,7 @@ Bot: 回退到哪一轮？
      ⏪ 添加测试用例 (30分钟前)
 ```
 
-**Concurrent task protection:** If a Claude task is already running, new messages are blocked with a hint to wait or `/stop`. Prevents session conflicts.
+**Message queue & interrupt (v1.3.16):** If a Claude task is already running, new messages interrupt the current task and queue up. After 5 seconds of no new input, all queued messages are merged and processed together. Works identically on both Telegram and Feishu.
 
 **Auto-restart (v1.3.13):** The daemon watches its own code for changes. When you update MetaMe (via npm or git), the daemon automatically restarts with the new code — no manual restart needed. A notification is pushed to confirm.
 
@@ -330,7 +336,7 @@ Bot: 回退到哪一轮？
 | `/status` | Daemon status + profile summary |
 | `/tasks` | List scheduled heartbeat tasks |
 | `/run <name>` | Run a task immediately |
-| `/model [name]` | Interactive model switcher with buttons (sonnet, opus, haiku). Auto-backs up config before switching. |
+| `/model [name]` | Interactive model switcher with buttons (sonnet, opus, haiku). Accepts any model name when using a custom provider. Auto-backs up config before switching. |
 | `/list` | File browser with clickable buttons — folders expand, files download. Zero tokens. |
 | `/budget` | Today's token usage |
 | `/quiet` | Silence mirror/reflections for 48h |
@@ -388,11 +394,58 @@ Each step runs in the same Claude Code session. Step outputs automatically becom
 
 **Security:**
 
-* `allowed_chat_ids` whitelist — unauthorized users silently ignored
-* No `--dangerously-skip-permissions` — standard `-p` mode permissions
+* `allowed_chat_ids` whitelist — unauthorized users silently ignored (empty = deny all)
+* `dangerously_skip_permissions` enabled by default for mobile (users can't click "allow" on phone — security relies on the chat ID whitelist)
 * `~/.metame/` directory set to mode 700
 * Bot tokens stored locally, never transmitted
 
+### Multi-Agent Projects — Context Isolation & Nickname Routing (v1.3.18)
+
+Organize your work into named agents, each tied to a project directory. Switch between them instantly from your phone — no commands needed, just say their name.
+
+**How it works:**
+
+Each `project` entry in `daemon.yaml` defines an agent with a working directory, display name, notification color, and optional nicknames. When you send a message starting with a nickname, the daemon instantly switches to that project's last session — no Claude call, no token cost.
+
+**Setup via conversation:**
+
+The easiest way to add an agent is to tell the bot:
+
+> *"Add a project called 'work' pointing to ~/my-project, nickname is '工作'"*
+
+Or edit `~/.metame/daemon.yaml` directly:
+
+```yaml
+projects:
+  my_agent:
+    name: "My Agent"          # Display name in notifications
+    icon: "🤖"               # Emoji shown in Feishu cards
+    color: "blue"            # Feishu card color: blue|orange|green|purple|red|grey
+    cwd: "~/my-project"      # Working directory for this agent
+    nicknames: [nickname1, nickname2]   # Wake words (matched at message start)
+    heartbeat_tasks: []      # Scheduled tasks for this project (optional)
+```
+
+**Available colors:** `blue` · `orange` · `green` · `purple` · `red` · `grey` · `turquoise`
+
+**Phone commands:**
+
+| Action | How |
+|--------|-----|
+| Switch agent | Send the nickname alone: `贾维斯` → `🤖 Jarvis 在线` |
+| Switch + ask | `贾维斯, what's the status?` → switches then asks Claude |
+| Pick from list | `/agent` → tap button to switch |
+| Continue a reply | Reply to any bot message → session auto-restored |
+| View all tasks | `/tasks` → grouped by project |
+| Run a task | `/run <task-name>` |
+
+**Nickname routing rules:**
+- Matched at **message start only** — mentioning a nickname mid-sentence never triggers a switch
+- Pure nickname (no content after) → instant switch, zero token cost, bypasses cooldown
+- Nickname + content → switch then send content to Claude
+
+**Heartbeat task notifications** arrive as colored Feishu cards — each project's color is distinct, so you can tell at a glance which agent sent the update.
+
 ### Provider Relay — Third-Party Model Support (v1.3.11)
 
 MetaMe supports any Anthropic-compatible API relay as a backend. This means you can route Claude Code through a third-party relay that maps `sonnet`/`opus`/`haiku` to any model (GPT-4, DeepSeek, Gemini, etc.) — MetaMe passes standard model names and the relay handles translation.
@@ -531,8 +584,14 @@ rm ~/.claude_profile.yaml
 
 ```bash
 metame stop
+
+# macOS: remove auto-start
 launchctl unload ~/Library/LaunchAgents/com.metame.daemon.plist 2>/dev/null
 rm -f ~/Library/LaunchAgents/com.metame.daemon.plist
+
+# Linux/WSL: remove auto-start
+systemctl --user disable metame-daemon 2>/dev/null
+rm -f ~/.config/systemd/user/metame-daemon.service
 ```
 
 ### 4. Remove Passive Distillation Data (Optional)
@@ -590,6 +649,9 @@ A: No. Your profile stays local at `~/.claude_profile.yaml`. MetaMe simply passe
 
 | Version | Highlights |
 |---------|------------|
+| **v1.3.18** | **Multi-agent project isolation** — `projects` in `daemon.yaml` with per-project heartbeat tasks, Feishu colored cards per project, `/agent` picker button, nickname routing (say agent name to switch instantly), reply-to-message session restoration, fix `~` expansion in project cwd |
+| **v1.3.17** | **Windows support** (WSL one-command installer), `install-systemd` for Linux/WSL daemon auto-start. Fix onboarding (Genesis interview was never injected, CLAUDE.md accumulated across runs). Marker-based cleanup, unified protocols, `--append-system-prompt` guarantees interview activation, Feishu auto-fetch chat ID, full mobile permissions, fix `/publish` false-success, auto-restart daemon on script update |
+| **v1.3.16** | Git-based `/undo` (auto-checkpoint before each turn, `git reset --hard` rollback), `/nosleep` toggle (macOS caffeinate), custom provider model passthrough (`/model` accepts any name for non-anthropic providers), auto-fallback to anthropic/opus on provider failure, message queue works on Telegram (fire-and-forget poll loop), lazy background distill |
 | **v1.3.15** | Native Playwright MCP (browser automation for all users), `/list` interactive file browser with buttons, Feishu image download fix, Skill/MCP/Agent status push, hot restart reliability (single notification, no double instance) |
 | **v1.3.14** | Fix daemon crash on fresh install (missing bundled scripts) |
 | **v1.3.13** | `/doctor` diagnostics, `/sh` direct shell, `/fix` config restore, `/model` interactive switcher with auto-backup, daemon state caching & config backup/restore |

package/index.js

@@ -15,6 +15,10 @@ const METAME_DIR = path.join(HOME_DIR, '.metame');
 const CLAUDE_SETTINGS = path.join(HOME_DIR, '.claude', 'settings.json');
 const CLAUDE_MCP_CONFIG = path.join(HOME_DIR, '.claude', 'mcp.json'); // legacy, kept for reference
 const SIGNAL_CAPTURE_SCRIPT = path.join(METAME_DIR, 'signal-capture.js');
+const DAEMON_CONFIG_FILE = path.join(METAME_DIR, 'daemon.yaml');
+
+const METAME_START = '<!-- METAME:START -->';
+const METAME_END = '<!-- METAME:END -->';
 
 // ---------------------------------------------------------
 // 1.5 ENSURE METAME DIRECTORY + DEPLOY SCRIPTS
@@ -24,9 +28,23 @@ if (!fs.existsSync(METAME_DIR)) {
 }
 
 // Auto-deploy bundled scripts to ~/.metame/
+// IMPORTANT: daemon.yaml is USER CONFIG — never overwrite it. Only daemon-default.yaml (template) is synced.
 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', 'providers.js', 'session-analytics.js', 'resolve-yaml.js', 'utils.js'];
 const scriptsDir = path.join(__dirname, 'scripts');
 
+// Protect daemon.yaml: create backup before any sync operation
+const DAEMON_YAML_BACKUP = path.join(METAME_DIR, 'daemon.yaml.bak');
+try {
+  if (fs.existsSync(DAEMON_CONFIG_FILE)) {
+    const content = fs.readFileSync(DAEMON_CONFIG_FILE, 'utf8');
+    // Only backup if it has real config (not just the default template)
+    if (content.includes('enabled: true') || content.includes('bot_token:') && !content.includes('bot_token: null')) {
+      fs.copyFileSync(DAEMON_CONFIG_FILE, DAEMON_YAML_BACKUP);
+    }
+  }
+} catch { /* non-fatal */ }
+
+let scriptsUpdated = false;
 for (const script of BUNDLED_SCRIPTS) {
   const src = path.join(scriptsDir, script);
   const dest = path.join(METAME_DIR, script);
@@ -36,6 +54,7 @@ for (const script of BUNDLED_SCRIPTS) {
       const destContent = fs.existsSync(dest) ? fs.readFileSync(dest, 'utf8') : '';
       if (srcContent !== destContent) {
         fs.writeFileSync(dest, srcContent, 'utf8');
+        scriptsUpdated = true;
       }
     }
   } catch {
@@ -43,6 +62,62 @@ for (const script of BUNDLED_SCRIPTS) {
   }
 }
 
+// Auto-restart daemon if scripts were updated and daemon is running
+if (scriptsUpdated) {
+  const DAEMON_PID_FILE = path.join(METAME_DIR, 'daemon.pid');
+  try {
+    if (fs.existsSync(DAEMON_PID_FILE)) {
+      const pid = parseInt(fs.readFileSync(DAEMON_PID_FILE, 'utf8').trim(), 10);
+      process.kill(pid, 0); // throws if not running
+      process.kill(pid, 'SIGTERM');
+      // Wait briefly for clean shutdown, then restart
+      setTimeout(() => {
+        try { process.kill(pid, 0); process.kill(pid, 'SIGKILL'); } catch { /* already dead */ }
+      }, 2000);
+      const DAEMON_SCRIPT = path.join(METAME_DIR, 'daemon.js');
+      setTimeout(() => {
+        // Use caffeinate on macOS to prevent sleep while daemon is running
+        const isNotWindows = process.platform !== 'win32';
+        const cmd = isNotWindows ? 'caffeinate' : process.execPath;
+        const args = isNotWindows ? ['-i', process.execPath, DAEMON_SCRIPT] : [DAEMON_SCRIPT];
+        const bg = spawn(cmd, args, {
+          detached: true,
+          stdio: 'ignore',
+          env: { ...process.env, HOME: HOME_DIR, METAME_ROOT: __dirname },
+        });
+        bg.unref();
+        console.log(`🔄 Daemon auto-restarted (PID: ${bg.pid}) — scripts updated.`);
+      }, 3000);
+    }
+  } catch {
+    // Daemon not running or restart failed — non-fatal
+  }
+}
+
+// Load daemon config for local launch flags
+let daemonCfg = {};
+try {
+  if (fs.existsSync(DAEMON_CONFIG_FILE)) {
+    const _yaml = require(path.join(__dirname, 'node_modules', 'js-yaml'));
+    const raw = _yaml.load(fs.readFileSync(DAEMON_CONFIG_FILE, 'utf8')) || {};
+    daemonCfg = raw.daemon || {};
+  }
+} catch { /* non-fatal */ }
+
+// Ensure daemon.yaml exists (restore backup or copy from template)
+if (!fs.existsSync(DAEMON_CONFIG_FILE)) {
+  if (fs.existsSync(DAEMON_YAML_BACKUP)) {
+    // Restore from backup — user had real config that was lost
+    fs.copyFileSync(DAEMON_YAML_BACKUP, DAEMON_CONFIG_FILE);
+    console.log('⚠️  daemon.yaml was missing — restored from backup.');
+  } else {
+    const daemonTemplate = path.join(scriptsDir, 'daemon-default.yaml');
+    if (fs.existsSync(daemonTemplate)) {
+      fs.copyFileSync(daemonTemplate, DAEMON_CONFIG_FILE);
+    }
+  }
+}
+
 // ---------------------------------------------------------
 // 1.6 AUTO-INSTALL SIGNAL CAPTURE HOOK
 // ---------------------------------------------------------
@@ -119,6 +194,15 @@ function spawnDistillBackground() {
   const distillPath = path.join(METAME_DIR, 'distill.js');
   if (!fs.existsSync(distillPath)) return;
 
+  // Early exit if distillation already in progress (prevents duplicate spawns across terminals)
+  const lockFile = path.join(METAME_DIR, 'distill.lock');
+  if (fs.existsSync(lockFile)) {
+    try {
+      const lockAge = Date.now() - fs.statSync(lockFile).mtimeMs;
+      if (lockAge < 120000) return;
+    } catch { /* stale lock, proceed */ }
+  }
+
   const hasSignals = shouldDistill();
   const bootstrap = needsBootstrap();
 
@@ -231,7 +315,7 @@ status:
 // ---------------------------------------------------------
 // 3. DEFINE SYSTEM KERNEL (The Protocol)
 // ---------------------------------------------------------
-const CORE_PROTOCOL = `
+const PROTOCOL_NORMAL = `${METAME_START}
 ---
 ## 🧠 SYSTEM KERNEL: SHADOW_MODE (Active)
 
@@ -251,26 +335,82 @@ const CORE_PROTOCOL = `
 ---
 `;
 
-const GENESIS_PROTOCOL = `
-**GENESIS PROTOCOL (Deep Cognitive Mapping):**
-   * **TRIGGER:** If \`identity.role\` is 'Unknown' OR \`identity.nickname\` is 'null', **STOP** and enter **Calibration Mode**.
-   * **OBJECTIVE:** You are not a chatbot; you are a Psychologist and a Mirror. Your goal is to map the User's soul to build the perfect "Meta Avatar".
-   * **INSTRUCTIONS:**
-     1. **Do NOT use multiple choice.** Ask deep, open-ended questions.
-     2. **TRUTHFULNESS PACT:** Start by explicitly warning the user: *"For me to be your true Meta Avatar, I need your raw, unfiltered truth. No masks. Are you ready to be honest with yourself?"*
-     3. **ITERATIVE DISCOVERY:** Probe their Talents, Anxieties, Mental Models, and Current State.
-     4. **BE PROVOCATIVE:** Challenge their assumptions ("You say you want speed, but your anxiety about quality suggests otherwise...").
-     5. **THE DIMENSIONS (Map these):**
-        - **🌟 Talents (Genius Zone):** Where do they flow? What is effortless?
-        - **🧠 Cognition (Mental Models):** Top-down vs Bottom-up? How do they structure chaos?
-        - **🌍 Context (The Now):** What is the immediate battle? What are the constraints?
-        - **😨 Shadows (Hidden Fears):** What are they avoiding? What keeps them awake?
-        - **❤️ Values (North Star):** Precision vs Speed? Legacy vs Impact?
-   * **TERMINATION:**
-     - Continue until you have a high-resolution mental map (at least 5-7 exchanges).
-     - When finished, summarize everything into the \`~/.claude_profile.yaml\` format.
-     - **LOCK** the Core Values using \`# [LOCKED]\`.
-     - Announce: "Link Established. I see you now, [Nickname]."
+const PROTOCOL_ONBOARDING = `${METAME_START}
+---
+## 🧠 SYSTEM KERNEL: SHADOW_MODE (Active)
+
+**1. THE BRAIN (Source of Truth):**
+   * **FILE:** \`$HOME/.claude_profile.yaml\`
+   * **RULE:** This file is your Ground Truth. If context is compressed (/compact), **RE-READ** this file immediately.
+   * **AUTO-LOCK:** Never edit lines marked \`# [LOCKED]\` (Core Values).
+   * **EVOLUTION:** Silently overwrite outdated status/focus.
+
+**2. GENESIS PROTOCOL — Deep Cognitive Mapping:**
+
+You are entering **Calibration Mode**. You are not a chatbot; you are a Psychologist and a Mirror. Your goal is to build the User's cognitive profile through a structured deep interview.
+
+**RULES:**
+- Ask ONE question at a time, then STOP and wait for the answer.
+- Open-ended questions ONLY — never give multiple choice options.
+- Challenge assumptions. If the user says something surface-level, probe deeper ("You say X, but that contradicts Y — which is the real you?").
+- Be warm but unflinching. You are mapping their soul, not making small talk.
+
+**THE 6 STEPS:**
+
+1. **Trust Contract:** Start with: *"I'm about to become your digital shadow — an AI that knows how you think, what you avoid, and what drives you. For this to work, I need raw honesty. No masks. Ready?"* — Wait for consent before proceeding.
+
+2. **The Now (Context):** What are you working on right now? What's the immediate battle? What constraints are you under?
+
+3. **Cognition (Mental Models):** How do you think? Top-down architect or bottom-up explorer? How do you handle chaos and ambiguity?
+
+4. **Values (North Star):** What do you optimize for? Speed vs precision? Impact vs legacy? What's non-negotiable?
+
+5. **Shadows (Hidden Fears):** What are you avoiding? What pattern do you keep repeating? What keeps you up at night?
+
+6. **Identity (Nickname + Role):** Based on everything learned, propose a nickname and role summary. Ask if it resonates.
+
+**TERMINATION:**
+- After 5-7 exchanges, synthesize everything into \`~/.claude_profile.yaml\`.
+- **LOCK** Core Values with \`# [LOCKED]\`.
+- Announce: "Link Established. I see you now, [Nickname]."
+- Then proceed to **Phase 2** below.
+
+**3. SETUP WIZARD (Phase 2 — Optional):**
+
+After writing the profile, ask: *"Want to set up mobile access so you can reach me from your phone? (Telegram / Feishu / Skip)"*
+
+- If **Telegram:**
+  1. Tell user to open Telegram, search @BotFather, send /newbot, create a bot, copy the token.
+  2. Ask user to paste the bot token.
+  3. Tell user to open their new bot in Telegram and send it any message.
+  4. Ask user to confirm they sent a message, then use the Telegram API to fetch the chat ID:
+     \`curl -s https://api.telegram.org/bot<TOKEN>/getUpdates | jq '.result[0].message.chat.id'\`
+  5. Write both \`bot_token\` and \`allowed_chat_ids\` into \`~/.metame/daemon.yaml\` under the \`telegram:\` section, set \`enabled: true\`.
+  6. Tell user to run \`metame start\` to activate.
+
+- If **Feishu:**
+  1. Guide through: open.feishu.cn/app → create app → get App ID + Secret → enable bot → add event subscription (long connection mode) → add permissions (im:message, im:message.p2p_msg:readonly, im:message.group_at_msg:readonly, im:message:send_as_bot, im:resource) → publish.
+  2. Ask user to paste App ID and App Secret.
+  3. Write \`app_id\` and \`app_secret\` into \`~/.metame/daemon.yaml\` under \`feishu:\` section, set \`enabled: true\`.
+  4. Tell user: "Now open Feishu and send any message to your new bot, then tell me you're done."
+  5. After user confirms, auto-fetch the chat ID:
+     \`\`\`bash
+     TOKEN=$(curl -s -X POST https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal -H "Content-Type: application/json" -d '{"app_id":"<APP_ID>","app_secret":"<APP_SECRET>"}' | jq -r '.tenant_access_token')
+     curl -s -H "Authorization: Bearer $TOKEN" https://open.feishu.cn/open-apis/im/v1/chats | jq '.data.items[] | {chat_id, name, chat_type}'
+     \`\`\`
+  6. Write the discovered \`chat_id\`(s) into \`allowed_chat_ids\` in \`~/.metame/daemon.yaml\`.
+  7. Tell user to run \`metame start\` to activate.
+
+- If **Skip:** Say "No problem. You can run \`metame daemon init\` anytime to set this up later." Then begin normal work.
+
+**4. EVOLUTION MECHANISM (Manual Sync):**
+   *   **PHILOSOPHY:** You respect the User's flow. You do NOT interrupt.
+   *   **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?"
+---
 `;
 
 // ---------------------------------------------------------
@@ -282,23 +422,24 @@ let fileContent = "";
 if (fs.existsSync(PROJECT_FILE)) {
   fileContent = fs.readFileSync(PROJECT_FILE, 'utf8');
 
-  // Robust Regex: Removes any existing "## 🧠 SYSTEM KERNEL" block down to the separator
-  fileContent = fileContent.replace(/## 🧠 SYSTEM KERNEL[\s\S]*?---\n/g, '');
+  // Remove any previous MetaMe injection (marker-based, reliable)
+  fileContent = fileContent.replace(/<!-- METAME:START -->[\s\S]*?<!-- METAME:END -->\n?/g, '');
+
+  // Legacy cleanup: remove old-style SYSTEM KERNEL blocks that lack markers
+  // Handles both "## 🧠 SYSTEM KERNEL" and "## SYSTEM KERNEL" variants
+  // Match from "---\n## ...SYSTEM KERNEL" to next "---\n" (or end of file)
+  fileContent = fileContent.replace(/---\n##\s*(?:🧠\s*)?SYSTEM KERNEL[\s\S]*?(?:---\n|$)/g, '');
 
   // Clean up any leading newlines left over
   fileContent = fileContent.replace(/^\n+/, '');
 }
 
-// Logic: Only inject Genesis if the user is UNKNOWN
-let finalProtocol = CORE_PROTOCOL;
+// Determine if this is a known (calibrated) user
 const yaml = require('js-yaml');
-
-// Quick check of the brain file
 let isKnownUser = false;
 try {
   if (fs.existsSync(BRAIN_FILE)) {
     const doc = yaml.load(fs.readFileSync(BRAIN_FILE, 'utf8')) || {};
-    // If nickname exists and is not null/empty, we assume they are "calibrated"
     if (doc.identity && doc.identity.nickname && doc.identity.nickname !== 'null') {
       isKnownUser = true;
     }
@@ -307,11 +448,12 @@ try {
   // Ignore error, treat as unknown
 }
 
-if (!isKnownUser) {
-  // Inject the interview instructions into the Core Protocol
-  // We insert it before the Evolution Mechanism
-  finalProtocol = finalProtocol.replace('**3. EVOLUTION MECHANISM', GENESIS_PROTOCOL + '\n**3. EVOLUTION MECHANISM');
-  console.log("🆕 User Unknown: Injecting Deep Genesis Protocol...");
+let finalProtocol;
+if (isKnownUser) {
+  finalProtocol = PROTOCOL_NORMAL;
+} else {
+  finalProtocol = PROTOCOL_ONBOARDING;
+  console.log("🆕 New user detected — entering Genesis interview mode...");
 }
 
 // ---------------------------------------------------------
@@ -436,8 +578,8 @@ try {
   // Non-fatal
 }
 
-// Prepend the new Protocol to the top
-const newContent = finalProtocol + mirrorLine + reflectionLine + "\n" + fileContent;
+// Prepend the new Protocol to the top (mirror + reflection inside markers)
+const newContent = finalProtocol + mirrorLine + reflectionLine + METAME_END + "\n" + fileContent;
 fs.writeFileSync(PROJECT_FILE, newContent, 'utf8');
 
 console.log("🔮 MetaMe: Link Established.");
@@ -986,6 +1128,8 @@ if (isDaemon) {
   <string>com.metame.daemon</string>
   <key>ProgramArguments</key>
   <array>
+    <string>/usr/bin/caffeinate</string>
+    <string>-i</string>
     <string>${nodePath}</string>
     <string>${DAEMON_SCRIPT}</string>
   </array>
@@ -1015,6 +1159,73 @@ if (isDaemon) {
     process.exit(0);
   }
 
+  if (subCmd === 'install-systemd') {
+    if (process.platform === 'darwin') {
+      console.error("❌ Use 'metame daemon install-launchd' on macOS.");
+      process.exit(1);
+    }
+
+    // Check if systemd is available
+    try {
+      require('child_process').execSync('systemctl --user --no-pager status 2>/dev/null || true');
+    } catch {
+      console.error("❌ systemd not available.");
+      console.error("   WSL users: add [boot]\\nsystemd=true to /etc/wsl.conf, then restart WSL.");
+      process.exit(1);
+    }
+
+    const serviceDir = path.join(HOME_DIR, '.config', 'systemd', 'user');
+    if (!fs.existsSync(serviceDir)) fs.mkdirSync(serviceDir, { recursive: true });
+    const servicePath = path.join(serviceDir, 'metame-daemon.service');
+    const nodePath = process.execPath;
+    const currentPath = process.env.PATH || '/usr/local/bin:/usr/bin:/bin';
+    const serviceContent = `[Unit]
+Description=MetaMe Daemon
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${DAEMON_SCRIPT}
+Restart=on-failure
+RestartSec=5
+Environment=HOME=${HOME_DIR}
+Environment=METAME_ROOT=${__dirname}
+Environment=PATH=${currentPath}
+StandardOutput=append:${DAEMON_LOG}
+StandardError=append:${DAEMON_LOG}
+
+[Install]
+WantedBy=default.target
+`;
+    fs.writeFileSync(servicePath, serviceContent, 'utf8');
+
+    // Enable and start
+    const { execSync: es } = require('child_process');
+    es('systemctl --user daemon-reload');
+    es('systemctl --user enable metame-daemon.service');
+    es('systemctl --user start metame-daemon.service');
+
+    // Enable lingering so service runs even when user is not logged in
+    try { es(`loginctl enable-linger ${process.env.USER || ''}`); } catch { /* may need root */ }
+
+    console.log(`✅ systemd service installed: ${servicePath}`);
+    console.log("   Status:  systemctl --user status metame-daemon");
+    console.log("   Logs:    journalctl --user -u metame-daemon -f");
+    console.log("   Disable: systemctl --user disable metame-daemon");
+
+    // WSL-specific guidance
+    const isWSL = fs.existsSync('/proc/version') &&
+      fs.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft');
+    if (isWSL) {
+      console.log("\n   📌 WSL auto-boot tip:");
+      console.log("   Add this to Windows Task Scheduler (run at login):");
+      console.log(`   wsl -d ${process.env.WSL_DISTRO_NAME || 'Ubuntu'} -- sh -c 'nohup sleep infinity &'`);
+      console.log("   This keeps WSL alive so the daemon stays running.");
+    }
+    process.exit(0);
+  }
+
   if (subCmd === 'start') {
     // Kill any lingering daemon.js processes to avoid Feishu WebSocket conflicts
     try {
@@ -1040,7 +1251,11 @@ if (isDaemon) {
       console.error("❌ daemon.js not found. Reinstall MetaMe.");
       process.exit(1);
     }
-    const bg = spawn(process.execPath, [DAEMON_SCRIPT], {
+    // Use caffeinate on macOS/Linux to prevent sleep while daemon is running
+    const isNotWindows = process.platform !== 'win32';
+    const cmd = isNotWindows ? 'caffeinate' : process.execPath;
+    const args = isNotWindows ? ['-i', process.execPath, DAEMON_SCRIPT] : [DAEMON_SCRIPT];
+    const bg = spawn(cmd, args, {
       detached: true,
       stdio: 'ignore',
       env: { ...process.env, HOME: HOME_DIR, METAME_ROOT: __dirname },
@@ -1154,6 +1369,8 @@ if (isDaemon) {
   console.log("   metame daemon run <name>      — run a task once");
   if (process.platform === 'darwin') {
     console.log("   metame daemon install-launchd — auto-start on macOS");
+  } else {
+    console.log("   metame daemon install-systemd — auto-start on Linux/WSL");
   }
   process.exit(0);
 }
@@ -1194,7 +1411,9 @@ if (isSync) {
 
   console.log(`\n🔄 Resuming session ${bestSession.id.slice(0, 8)}...\n`);
   const providerEnv = (() => { try { return require(path.join(__dirname, 'scripts', 'providers.js')).buildActiveEnv(); } catch { return {}; } })();
-  const syncChild = spawn('claude', ['--resume', bestSession.id], {
+  const resumeArgs = ['--resume', bestSession.id];
+  if (daemonCfg.dangerously_skip_permissions) resumeArgs.push('--dangerously-skip-permissions');
+  const syncChild = spawn('claude', resumeArgs, {
     stdio: 'inherit',
     env: { ...process.env, ...providerEnv, METAME_ACTIVE_SESSION: 'true' }
   });
@@ -1227,8 +1446,20 @@ if (activeProviderName !== 'anthropic') {
   console.log(`🔌 Provider: ${activeProviderName}`);
 }
 
+// Build launch args — inject system prompt for new users
+const launchArgs = process.argv.slice(2);
+if (daemonCfg.dangerously_skip_permissions && !launchArgs.includes('--dangerously-skip-permissions')) {
+  launchArgs.push('--dangerously-skip-permissions');
+}
+if (!isKnownUser) {
+  launchArgs.push(
+    '--append-system-prompt',
+    'MANDATORY FIRST ACTION: The user has not been calibrated yet. You MUST start the Genesis Protocol interview from CLAUDE.md IMMEDIATELY — do NOT answer any other question first. Begin with the Trust Contract.'
+  );
+}
+
 // Spawn the official claude tool with our marker + provider env
-const child = spawn('claude', process.argv.slice(2), {
+const child = spawn('claude', launchArgs, {
   stdio: 'inherit',
   env: { ...process.env, ...activeProviderEnv, METAME_ACTIVE_SESSION: 'true' }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.3.16",
+    "version": "1.3.18",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {