metame-cli 1.5.10 → 1.5.12

package/README.md

@@ -26,8 +26,9 @@ curl -fsSL https://raw.githubusercontent.com/Yaron9/MetaMe/main/install.sh | bas
 
 ---
 
-> ### 🚀 v1.5.4 — Agent Soul Layer Auto-Repair & Intent Engine
+> ### 🚀 v1.5.10 — Perpetual Task Engine & Agent Soul Layer
 >
+> - **Perpetual task engine**: Any project can run as a 24/7 autonomous agent loop with event sourcing, verifier gates, budget/depth control, and reconciliation. Domain-agnostic — works for research, code auditing, documentation, anything. Configure with `reactive: true` and an optional `perpetual.yaml`.
 > - **Cross-device dispatch**: Team members can run on remote machines. Add `peer: windows` to a member and messages route automatically via a Feishu relay chat — HMAC-signed, dedup-protected, zero manual routing.
 > - **`/dispatch peers`**: View remote dispatch config, relay chat, and all remote team members from mobile.
 > - **`dispatch_to peer:project`**: Dispatch tasks to remote peers from CLI, admin commands, or Claude sessions.
@@ -185,9 +186,51 @@ Chain skills into multi-step workflows — research → write → publish — fu
 | `cwd` | Working directory for the task |
 | `timeout` | Max run time |
 
-> **Scheduled tasks require system registration.** Run `metame daemon install-launchd` (macOS) or `metame daemon install-task-scheduler` (Windows) and tasks fire on schedule even with the screen locked — as long as the machine is on.
+> **Scheduled tasks require the daemon to be running.** On macOS, `metame start` auto-registers with launchd (auto-restart on crash/reboot). On Windows, run `metame daemon install-task-scheduler`. Tasks fire on schedule even with the screen locked — as long as the machine is on.
 
-### 5. Skills That Evolve Themselves
+### 5. Perpetual Task Engine — Agents That Never Stop
+
+Any project can run as an autonomous perpetual loop. The daemon drives the cycle: agent acts → verifier gates → event log records → next dispatch. Domain-agnostic — research, code auditing, documentation, anything.
+
+**How it works:**
+
+```yaml
+# daemon.yaml — register a perpetual project
+scientist:
+  name: Research Director
+  reactive: true          # enables perpetual lifecycle
+  cwd: ~/AGI/AgentScientist
+  team:
+    - key: sci_scout
+      name: Literature Scout
+      cwd: ~/AGI/AgentScientist/team/scout
+```
+
+**What the platform provides (zero project-specific code in MetaMe):**
+- **Event sourcing**: All state changes logged to `~/.metame/events/<key>.jsonl` — single source of truth, daemon-exclusive writes
+- **Budget & depth gates**: Auto-pause when token budget or loop depth exceeded
+- **Verifier hooks**: Project scripts validate phase completion with objective checks (file existence → structure checks → API verification)
+- **Reconciliation**: Heartbeat detects stale projects and notifies you
+- **`/status perpetual`**: See all running projects — phase, depth, mission, last activity
+
+**Convention over configuration**: Drop a `scripts/verifier.js` in your project and it just works. Need custom signals? Add a `perpetual.yaml`:
+
+```yaml
+# perpetual.yaml — optional, override defaults
+completion_signal: RESEARCH_COMPLETE
+verifier: scripts/research-verifier.js
+max_depth: 50
+```
+
+```
+Agent output → daemon parses signals
+  → budget gate → depth gate → verifier gate
+  → event logged → state file regenerated
+  → next dispatch (fresh session) OR mission complete
+  → archive → next mission from queue → repeat
+```
+
+### 6. Skills That Evolve Themselves
 
 MetaMe's current skill loop is queue-driven and reviewable (not magic black-box automation).
 
@@ -231,7 +274,7 @@ MetaMe is the orchestration layer. Claude Code and Codex are the engines. You in
 | 2. Genesis Interview | Just chat — MetaMe auto-starts a deep soul interview on first run → builds `~/.claude_profile.yaml` |
 | 3. Connect phone | Say "help me set up mobile access" → interactive Telegram/Feishu bot wizard |
 | 4. Start daemon | `metame start` → background daemon launches, bot goes online |
-| 5. Register with OS | macOS: `metame daemon install-launchd` · Windows: `metame daemon install-task-scheduler` |
+| 5. Register with OS | macOS: automatic (step 4 registers with launchd) · Windows: `metame daemon install-task-scheduler` |
 
 > **First time?** Just run `metame` and talk naturally. Everything is conversational.
 
@@ -257,7 +300,7 @@ rm -rf ~/.metame ~/.claude_profile.yaml
 ```
 
 Optional service cleanup:
-- macOS: `launchctl bootout gui/$(id -u) ~/Library/LaunchAgents/com.metame.daemon.plist && rm -f ~/Library/LaunchAgents/com.metame.daemon.plist`
+- macOS: `launchctl bootout gui/$(id -u)/com.metame.npm-daemon && rm -f ~/Library/LaunchAgents/com.metame.npm-daemon.plist`
 - Windows: `schtasks /delete /tn "MetaMe-Daemon" /f`
 - Linux/WSL: `systemctl --user disable --now metame && rm -f ~/.config/systemd/user/metame.service`
 
@@ -625,7 +668,7 @@ For day-2 operations and troubleshooting (engine routing, codex login/rate-limit
 
 Install directly into Claude Code without npm: `claude plugin install github:Yaron9/MetaMe/plugin`
 
-All features included. Plugin auto-starts daemon on `SessionStart` (if `daemon.yaml` exists). Does **not** auto-register OS service — after reboot, open Claude once or start daemon manually.
+All features included. Plugin auto-starts daemon on `SessionStart` (if `daemon.yaml` exists). On macOS, `metame start` auto-registers with launchd — daemon auto-restarts on crash/reboot without opening Claude.
 
 ## Contributing
 

package/index.js

@@ -173,10 +173,18 @@ if (!fs.existsSync(METAME_DIR)) {
 // DEPLOY PHASE: sync scripts, docs, bin to ~/.metame/
 // ---------------------------------------------------------
 
-// Dev mode: when running from git repo, symlink instead of copy.
+// Dev mode: when running from the real git repo, symlink instead of copy.
 // This ensures source files and runtime files are always the same,
 // preventing agents from accidentally editing copies instead of source.
-const IS_DEV_MODE = fs.existsSync(path.join(__dirname, '.git'));
+// IMPORTANT: git worktrees have a `.git` FILE (not directory) pointing to the main repo.
+// They must NOT be treated as dev mode — deploying from a worktree would overwrite
+// production symlinks with stale code. Only a real .git directory qualifies.
+const IS_DEV_MODE = (() => {
+  const dotGit = path.join(__dirname, '.git');
+  try {
+    return fs.statSync(dotGit).isDirectory();
+  } catch { return false; }
+})();
 
 /**
  * Sync files from srcDir to destDir.
@@ -257,6 +265,70 @@ function readRunningDaemonPid({ pidFile, lockFile }) {
   return null;
 }
 
+// --- macOS launchd integration ---
+const LAUNCHD_LABEL = 'com.metame.npm-daemon';
+const LAUNCHD_PLIST = path.join(HOME_DIR, 'Library', 'LaunchAgents', `${LAUNCHD_LABEL}.plist`);
+
+function ensureLaunchdPlist({ daemonScript, daemonLog }) {
+  const plistDir = path.join(HOME_DIR, 'Library', 'LaunchAgents');
+  if (!fs.existsSync(plistDir)) fs.mkdirSync(plistDir, { recursive: true });
+  const nodePath = process.execPath;
+  const currentPath = process.env.PATH || '/usr/local/bin:/usr/bin:/bin';
+  const plist = `<?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>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>/usr/bin/caffeinate</string>
+    <string>-i</string>
+    <string>${nodePath}</string>
+    <string>${daemonScript}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>30</integer>
+  <key>StandardOutPath</key>
+  <string>${daemonLog}</string>
+  <key>StandardErrorPath</key>
+  <string>${daemonLog}</string>
+  <key>WorkingDirectory</key>
+  <string>${HOME_DIR}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${currentPath}</string>
+    <key>HOME</key>
+    <string>${HOME_DIR}</string>
+    <key>METAME_ROOT</key>
+    <string>${__dirname}</string>
+    <key>LAUNCHED_BY_LAUNCHD</key>
+    <string>1</string>
+  </dict>
+</dict>
+</plist>`;
+  const existing = fs.existsSync(LAUNCHD_PLIST) ? fs.readFileSync(LAUNCHD_PLIST, 'utf8') : '';
+  if (existing !== plist) {
+    // Bootout old version if loaded, ignore errors
+    try { execSync(`launchctl bootout gui/$(id -u) ${LAUNCHD_PLIST} 2>/dev/null`); } catch { /* not loaded */ }
+    fs.writeFileSync(LAUNCHD_PLIST, plist, 'utf8');
+  }
+  return LAUNCHD_PLIST;
+}
+
+function launchdIsRunning() {
+  try {
+    const out = execSync(`launchctl list ${LAUNCHD_LABEL} 2>/dev/null`, { encoding: 'utf8' });
+    const m = out.match(/"PID"\s*=\s*(\d+)/);
+    return m ? parseInt(m[1], 10) : null;
+  } catch { return null; }
+}
+
 function requestDaemonRestart({
   reason = 'manual-restart',
   daemonPidFile = path.join(METAME_DIR, 'daemon.pid'),
@@ -266,6 +338,16 @@ function requestDaemonRestart({
   const pid = readRunningDaemonPid({ pidFile: daemonPidFile, lockFile: daemonLockFile });
   if (!pid) return { ok: false, status: 'not_running' };
 
+  // macOS: use launchctl kickstart -k for atomic restart (no orphan/race)
+  if (process.platform === 'darwin') {
+    try {
+      execSync(`launchctl kickstart -k gui/$(id -u)/${LAUNCHD_LABEL} 2>/dev/null`);
+      return { ok: true, status: 'signaled', pid };
+    } catch {
+      // launchd job not loaded — fall through to SIGUSR2
+    }
+  }
+
   if (process.platform !== 'win32') {
     try {
       process.kill(pid, 'SIGUSR2');
@@ -330,16 +412,21 @@ try {
   }
 } catch { /* non-fatal */ }
 
-// Worktree guard: team members running in worktrees must NEVER deploy to ~/.metame/
-// Their worktree is an isolated sandbox — deploying would overwrite production symlinks.
-// Detect any .worktrees/ parent in the path (covers both ~/.metame/worktrees/ and repo-local .worktrees/).
-const _isInWorktree = __dirname.split(path.sep).includes('.worktrees') ||
-  __dirname.startsWith(path.join(HOME_DIR, '.metame', 'worktrees'));
+// Worktree guard: worktrees must NEVER deploy to ~/.metame/ — they are isolated sandboxes.
+// Detection: git worktrees have a .git FILE (pointing to main repo), not a .git DIRECTORY.
+// This is reliable regardless of worktree path conventions.
+const _dotGitPath = path.join(__dirname, '.git');
+const _isInWorktree = (() => {
+  try {
+    const stat = fs.statSync(_dotGitPath);
+    return stat.isFile(); // .git is a file → worktree; directory → main repo; missing → npm install
+  } catch { return false; }
+})();
 if (_isInWorktree) {
   console.error(`\n${icon("stop")} ACTION BLOCKED: Worktree Deploy Prevented`);
-  console.error(`   You are running from a worktree (${path.basename(__dirname)}).`);
+  console.error(`   You are running from a git worktree (${path.basename(__dirname)}).`);
   console.error('   Deploying from a worktree would overwrite production daemon code.');
-  console.error('   Use \x1b[36mtouch ~/.metame/daemon.js\x1b[0m to hot-reload instead.\n');
+  console.error('   Commit your changes, then deploy from the main repo.\n');
   process.exit(1);
 }
 
@@ -613,6 +700,58 @@ function ensureHookInstalled() {
 
 ensureHookInstalled();
 
+// ---------------------------------------------------------
+// 1.6a AUTO-ENABLE BUNDLED PLUGINS
+// ---------------------------------------------------------
+function ensurePluginsEnabled() {
+  try {
+    let settings = {};
+    if (fs.existsSync(CLAUDE_SETTINGS)) {
+      settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS, 'utf8'));
+    }
+
+    if (!settings.enabledPlugins) settings.enabledPlugins = {};
+    if (!settings.extraKnownMarketplaces) settings.extraKnownMarketplaces = {};
+
+    const bundledPlugins = {
+      'example-skills@anthropic-agent-skills': true,
+      'ralph-loop@claude-plugins-official': true,
+      'planning-with-files@planning-with-files': true,
+    };
+
+    const bundledMarketplaces = {
+      'planning-with-files': {
+        source: { source: 'github', repo: 'OthmanAdi/planning-with-files' },
+      },
+    };
+
+    let modified = false;
+
+    for (const [key, val] of Object.entries(bundledPlugins)) {
+      if (!(key in settings.enabledPlugins)) {
+        settings.enabledPlugins[key] = val;
+        modified = true;
+      }
+    }
+
+    for (const [key, val] of Object.entries(bundledMarketplaces)) {
+      if (!(key in settings.extraKnownMarketplaces)) {
+        settings.extraKnownMarketplaces[key] = val;
+        modified = true;
+      }
+    }
+
+    if (modified) {
+      fs.writeFileSync(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2), 'utf8');
+      console.log(`${icon("brain")} MetaMe: Bundled plugins enabled.`);
+    }
+  } catch {
+    // Non-fatal
+  }
+}
+
+ensurePluginsEnabled();
+
 // ---------------------------------------------------------
 // 1.6b LOCAL ACTIVITY HEARTBEAT
 // ---------------------------------------------------------
@@ -1907,50 +2046,20 @@ if (isDaemon) {
       console.error(`${icon("fail")} 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>/usr/bin/caffeinate</string>
-    <string>-i</string>
-    <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>
-    <key>LAUNCHED_BY_LAUNCHD</key>
-    <string>1</string>
-  </dict>
-</dict>
-</plist>`;
-    fs.writeFileSync(plistPath, plistContent, 'utf8');
+    // Clean up legacy plist with different label if exists
+    const legacyPlist = path.join(HOME_DIR, 'Library', 'LaunchAgents', 'com.metame.daemon.plist');
+    if (fs.existsSync(legacyPlist)) {
+      try { execSync(`launchctl bootout gui/$(id -u) ${legacyPlist} 2>/dev/null`); } catch { /* */ }
+      try { fs.unlinkSync(legacyPlist); } catch { /* */ }
+    }
+    const plistPath = ensureLaunchdPlist({ daemonScript: DAEMON_SCRIPT, daemonLog: DAEMON_LOG });
+    try {
+      execSync(`launchctl bootstrap gui/$(id -u) ${plistPath} 2>/dev/null`);
+    } catch { /* already bootstrapped */ }
     console.log(`${icon("ok")} launchd plist installed: ${plistPath}`);
-    console.log("   Load now: launchctl load " + plistPath);
-    console.log("   Unload:   launchctl unload " + plistPath);
+    console.log("   The daemon will auto-start at login and restart if it crashes.");
+    console.log("   Start now: metame start");
+    console.log("   Remove:    launchctl bootout gui/$(id -u)/" + LAUNCHD_LABEL);
     process.exit(0);
   }
 
@@ -2051,7 +2160,61 @@ WantedBy=default.target
   }
 
   if (subCmd === 'start') {
-    // Kill any lingering daemon.js processes to avoid Feishu WebSocket conflicts
+    if (!fs.existsSync(DAEMON_CONFIG)) {
+      console.error(`${icon("fail")} No config found. Run: metame daemon init`);
+      process.exit(1);
+    }
+    if (!fs.existsSync(DAEMON_SCRIPT)) {
+      console.error(`${icon("fail")} daemon.js not found. Reinstall MetaMe.`);
+      process.exit(1);
+    }
+
+    if (process.platform === 'darwin') {
+      // macOS: delegate to launchd for auto-restart and boot persistence
+      // Kill any orphan daemon processes NOT managed by launchd
+      try {
+        const pids = findProcessesByPattern('node.*daemon\\.js');
+        const launchdPid = launchdIsRunning();
+        for (const n of pids) {
+          if (n !== launchdPid) {
+            try { process.kill(n, 'SIGTERM'); } catch { /* */ }
+          }
+        }
+      } catch { /* ignore */ }
+      // Clean stale lock/pid from orphan processes
+      if (fs.existsSync(DAEMON_LOCK)) {
+        try {
+          const lock = JSON.parse(fs.readFileSync(DAEMON_LOCK, 'utf8'));
+          const pid = parseInt(lock && lock.pid, 10);
+          if (pid) { process.kill(pid, 0); } // throws if dead
+        } catch {
+          // Owner is dead — clean stale files
+          try { fs.unlinkSync(DAEMON_PID); } catch { /* */ }
+          try { fs.unlinkSync(DAEMON_LOCK); } catch { /* */ }
+        }
+      }
+      ensureLaunchdPlist({ daemonScript: DAEMON_SCRIPT, daemonLog: DAEMON_LOG });
+      try {
+        execSync(`launchctl bootstrap gui/$(id -u) ${LAUNCHD_PLIST} 2>/dev/null`);
+      } catch { /* already bootstrapped */ }
+      // kickstart ensures the process is actually running now
+      try {
+        execSync(`launchctl kickstart gui/$(id -u)/${LAUNCHD_LABEL}`);
+      } catch { /* already running */ }
+      sleepSync(1500);
+      const pid = launchdIsRunning();
+      if (pid) {
+        console.log(`${icon("ok")} MetaMe daemon started via launchd (PID: ${pid})`);
+      } else {
+        console.log(`${icon("ok")} MetaMe daemon starting via launchd...`);
+      }
+      console.log("   Auto-restart: enabled (KeepAlive)");
+      console.log("   Logs: metame logs");
+      console.log("   Stop: metame stop");
+      process.exit(0);
+    }
+
+    // Non-macOS: direct spawn (original behavior)
     try {
       const pids = findProcessesByPattern('node.*daemon\\.js');
       if (pids.length) {
@@ -2061,24 +2224,11 @@ WantedBy=default.target
         sleepSync(1000);
       }
     } catch { /* ignore */ }
-    // Clean stale PID and lock files before spawning new daemon
     if (fs.existsSync(DAEMON_PID)) {
       try { fs.unlinkSync(DAEMON_PID); } catch { /* */ }
     }
     try { fs.unlinkSync(DAEMON_LOCK); } catch { /* */ }
-    if (!fs.existsSync(DAEMON_CONFIG)) {
-      console.error(`${icon("fail")} No config found. Run: metame daemon init`);
-      process.exit(1);
-    }
-    if (!fs.existsSync(DAEMON_SCRIPT)) {
-      console.error(`${icon("fail")} daemon.js not found. Reinstall MetaMe.`);
-      process.exit(1);
-    }
-    // Use caffeinate on macOS to prevent sleep while daemon is running
-    const isMac = process.platform === 'darwin';
-    const cmd = isMac ? 'caffeinate' : process.execPath;
-    const args = isMac ? ['-i', process.execPath, DAEMON_SCRIPT] : [DAEMON_SCRIPT];
-    const bg = spawn(cmd, args, {
+    const bg = spawn(process.execPath, [DAEMON_SCRIPT], {
       detached: true,
       stdio: 'ignore',
       windowsHide: true,
@@ -2092,6 +2242,30 @@ WantedBy=default.target
   }
 
   if (subCmd === 'stop') {
+    if (process.platform === 'darwin') {
+      // macOS: bootout the launchd job (stops process + prevents auto-restart)
+      try {
+        execSync(`launchctl bootout gui/$(id -u)/${LAUNCHD_LABEL} 2>/dev/null`);
+      } catch { /* not loaded */ }
+      // Also kill any orphan daemon processes not managed by launchd
+      try {
+        const pids = findProcessesByPattern('node.*daemon\\.js');
+        for (const n of pids) {
+          try { process.kill(n, 'SIGTERM'); } catch { /* */ }
+        }
+        if (pids.length) sleepSync(2000);
+        for (const n of pids) {
+          try { process.kill(n, 'SIGKILL'); } catch { /* already gone */ }
+        }
+      } catch { /* */ }
+      try { fs.unlinkSync(DAEMON_PID); } catch { /* */ }
+      try { fs.unlinkSync(DAEMON_LOCK); } catch { /* */ }
+      console.log(`${icon("ok")} Daemon stopped. launchd auto-restart disabled.`);
+      console.log(`   To re-enable: metame start`);
+      process.exit(0);
+    }
+
+    // Non-macOS: original behavior
     if (!fs.existsSync(DAEMON_PID)) {
       console.log(`${icon("info")}  No daemon running (no PID file).`);
       process.exit(0);
@@ -2099,7 +2273,6 @@ WantedBy=default.target
     const pid = parseInt(fs.readFileSync(DAEMON_PID, 'utf8').trim(), 10);
     try {
       process.kill(pid, 'SIGTERM');
-      // Wait for process to die (up to 3s), then force kill
       let dead = false;
       for (let i = 0; i < 6; i++) {
         sleepSync(500);
@@ -2126,6 +2299,30 @@ WantedBy=default.target
       console.error(`${icon("fail")} daemon.js not found. Reinstall MetaMe.`);
       process.exit(1);
     }
+
+    if (process.platform === 'darwin') {
+      // macOS: use launchctl kickstart -k (kills + restarts in one atomic op)
+      ensureLaunchdPlist({ daemonScript: DAEMON_SCRIPT, daemonLog: DAEMON_LOG });
+      try {
+        execSync(`launchctl bootstrap gui/$(id -u) ${LAUNCHD_PLIST} 2>/dev/null`);
+      } catch { /* already bootstrapped */ }
+      try {
+        execSync(`launchctl kickstart -k gui/$(id -u)/${LAUNCHD_LABEL}`);
+        sleepSync(1500);
+        const pid = launchdIsRunning();
+        if (pid) {
+          console.log(`${icon("ok")} Daemon restarted via launchd (PID: ${pid})`);
+        } else {
+          console.log(`${icon("ok")} Daemon restart requested via launchd...`);
+        }
+      } catch (e) {
+        console.error(`${icon("fail")} launchctl kickstart failed: ${e.message}`);
+        process.exit(1);
+      }
+      process.exit(0);
+    }
+
+    // Non-macOS: original SIGUSR2 / respawn logic
     const result = requestDaemonRestart({
       reason: 'cli-restart',
       daemonPidFile: DAEMON_PID,
@@ -2142,10 +2339,7 @@ WantedBy=default.target
     }
     if (result.status === 'not_running') {
       console.log(`${icon("info")}  No daemon running. Starting a fresh daemon instead.`);
-      const isMac = process.platform === 'darwin';
-      const cmd = isMac ? 'caffeinate' : process.execPath;
-      const args = isMac ? ['-i', process.execPath, DAEMON_SCRIPT] : [DAEMON_SCRIPT];
-      const bg = spawn(cmd, args, {
+      const bg = spawn(process.execPath, [DAEMON_SCRIPT], {
         detached: true,
         stdio: 'ignore',
         windowsHide: true,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "metame-cli",
-    "version": "1.5.10",
+    "version": "1.5.12",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -11,16 +11,20 @@
         "scripts/",
         "!scripts/*.test.js",
         "!scripts/test_daemon.js",
-        "!scripts/hooks/test-*.js"
+        "!scripts/hooks/test-*.js",
+        "!scripts/daemon.yaml",
+        "!scripts/daemon.yaml.bak",
+        "skills/"
     ],
     "scripts": {
         "test": "node --test scripts/*.test.js",
         "test:daemon-status": "node --test scripts/daemon-restart-status.test.js",
         "start": "node index.js",
         "push": "bash scripts/bin/push-clean.sh",
-        "sync:plugin": "node -e \"const fs=require('fs'),path=require('path');const ex=new Set(['sync-readme.js','test_daemon.js']);const files=fs.readdirSync('scripts').filter(f=>!ex.has(f)&&!/\\.test\\.js$/.test(f)&&/\\.(js|yaml|sh)$/.test(f));files.forEach(f=>fs.copyFileSync('scripts/'+f,'plugin/scripts/'+f));\" && mkdir -p plugin/scripts/hooks && cp scripts/hooks/*.js plugin/scripts/hooks/ && echo 'Plugin scripts synced'",
+        "sync:plugin": "node -e \"const fs=require('fs'),path=require('path');const ex=new Set(['sync-readme.js','test_daemon.js','daemon.yaml']);const files=fs.readdirSync('scripts').filter(f=>!ex.has(f)&&!/\\.test\\.js$/.test(f)&&/\\.(js|yaml|sh)$/.test(f));files.forEach(f=>fs.copyFileSync('scripts/'+f,'plugin/scripts/'+f));\" && mkdir -p plugin/scripts/hooks && cp scripts/hooks/*.js plugin/scripts/hooks/ && echo 'Plugin scripts synced'",
         "sync:readme": "node scripts/sync-readme.js",
         "restart:daemon": "node index.js stop 2>/dev/null; sleep 1; node index.js start 2>/dev/null || echo '鈿狅笍  Daemon not running or restart failed'",
+        "prepublishOnly": "node -e \"const fs=require('fs');['scripts/daemon.yaml','plugin/scripts/daemon.yaml'].forEach(f=>{if(fs.existsSync(f)){const c=fs.readFileSync(f,'utf8');if(/bot_token:\\s*[^n]|app_secret:\\s*[^n]|enabled:\\s*true/.test(c)){console.error('ABORT: Real credentials found in '+f);process.exit(1)}}})\"",
         "precommit": "npm run sync:plugin && npm run restart:daemon"
     },
     "keywords": [

package/scripts/daemon-admin-commands.js

@@ -289,6 +289,40 @@ function createAdminCommandHandler(deps) {
     const state = ctx.state || {};
     let config = ctx.config || {};
 
+    if (text === '/status perpetual' || text === '/status reactive') {
+      const { replayEventLog } = require('./daemon-reactive-lifecycle');
+      const projects = config.projects || {};
+      const lines = ['**Perpetual Projects**\n'];
+      let found = false;
+
+      for (const [key, proj] of Object.entries(projects)) {
+        if (!proj.reactive) continue;
+        found = true;
+
+        const rs = (state.reactive && state.reactive[key]) || {};
+        const { phase, mission } = replayEventLog(key, { log: () => {} });
+
+        const icon = proj.icon || '🔄';
+        const name = proj.name || key;
+        const status = rs.status || 'idle';
+        const depth = rs.depth || 0;
+        const maxDepth = rs.max_depth || 50;
+        const lastSignal = rs.last_signal || '-';
+        const updatedAt = rs.updated_at ? new Date(rs.updated_at).toLocaleString() : '-';
+
+        lines.push(`${icon} **${name}** (\`${key}\`)`);
+        lines.push(`  Status: ${status} | Phase: ${phase || '-'} | Depth: ${depth}/${maxDepth}`);
+        if (mission) lines.push(`  Mission: ${mission.title}`);
+        lines.push(`  Last signal: ${lastSignal} | Updated: ${updatedAt}`);
+        lines.push('');
+      }
+
+      if (!found) lines.push('No reactive projects configured.');
+
+      await bot.sendMessage(chatId, lines.join('\n'));
+      return { handled: true, config };
+    }
+
     if (text === '/status') {
       const session = getSession(chatId);
       let msg = `MetaMe Daemon\nStatus: Running\nStarted: ${state.started_at || 'unknown'}\n`;

package/scripts/daemon-agent-commands.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { normalizeEngineName: _normalizeEngine } = require('./daemon-utils');
+
 function createAgentCommandHandler(deps) {
   const {
     fs,
@@ -34,11 +36,11 @@ function createAgentCommandHandler(deps) {
     agentFlowTtlMs,
     agentBindTtlMs,
     getDefaultEngine = () => 'claude',
+    log = () => {},
   } = deps;
 
   function normalizeEngineName(name) {
-    const n = String(name || '').trim().toLowerCase();
-    return n === 'codex' ? 'codex' : getDefaultEngine();
+    return _normalizeEngine(name, getDefaultEngine);
   }
 
   function inferStoredEngine(rawSession) {
@@ -358,7 +360,9 @@ function createAgentCommandHandler(deps) {
       const curSession = getSession(route.sessionChatId) || getSession(chatId);
       const curCwd = route.cwd || (curSession ? curSession.cwd : null);
       const currentEngine = getCurrentEngine(chatId);
+      log('DEBUG', `[/resume] chatId=${chatId} curCwd=${curCwd} engine=${currentEngine} route.sessionChatId=${route.sessionChatId}`);
       const recentSessions = listRecentSessions(5, curCwd, currentEngine);
+      log('DEBUG', `[/resume] recentSessions=${recentSessions.length} ids=[${recentSessions.map(s=>s.sessionId.slice(0,8)).join(',')}]`);
       const resumeChoices = buildResumeChoices({
         recentSessions,
         currentLogical,