metame-cli 1.5.9 → 1.5.11

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');
@@ -305,7 +387,7 @@ function requestDaemonRestart({
 const scriptsDir = path.join(__dirname, 'scripts');
 // Auto-detect ALL runtime scripts: daemon-*.js + all other non-test, non-utility .js/.yaml/.sh files.
 // This prevents "missing module" crashes when new files are added without updating a manual list.
-const EXCLUDED_SCRIPTS = new Set(['sync-readme.js', 'test_daemon.js']);
+const EXCLUDED_SCRIPTS = new Set(['sync-readme.js', 'test_daemon.js', 'daemon.yaml']);
 const BUNDLED_SCRIPTS = (() => {
   try {
     return fs.readdirSync(scriptsDir).filter((f) => {
@@ -330,6 +412,19 @@ 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'));
+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('   Deploying from a worktree would overwrite production daemon code.');
+  console.error('   Use \x1b[36mtouch ~/.metame/daemon.js\x1b[0m to hot-reload instead.\n');
+  process.exit(1);
+}
+
 // Pre-deploy syntax validation: check all .js files before syncing to ~/.metame/
 // Catches bad merges and careless agent edits BEFORE they can crash the daemon.
 const { execSync: _execSync } = require('child_process');
@@ -1894,48 +1989,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>
-  </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);
   }
 
@@ -2036,7 +2103,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) {
@@ -2046,23 +2167,11 @@ WantedBy=default.target
         sleepSync(1000);
       }
     } catch { /* ignore */ }
-    // Check if already running
     if (fs.existsSync(DAEMON_PID)) {
       try { fs.unlinkSync(DAEMON_PID); } 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, {
+    try { fs.unlinkSync(DAEMON_LOCK); } catch { /* */ }
+    const bg = spawn(process.execPath, [DAEMON_SCRIPT], {
       detached: true,
       stdio: 'ignore',
       windowsHide: true,
@@ -2076,6 +2185,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);
@@ -2083,7 +2216,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);
@@ -2097,6 +2229,7 @@ WantedBy=default.target
       console.log(`${icon("warn")}  Process ${pid} not found (may have already exited).`);
     }
     try { fs.unlinkSync(DAEMON_PID); } catch { /* ignore */ }
+    try { fs.unlinkSync(DAEMON_LOCK); } catch { /* ignore */ }
     process.exit(0);
   }
 
@@ -2109,6 +2242,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,
@@ -2125,10 +2282,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.9",
+    "version": "1.5.11",
     "description": "The Cognitive Profile Layer for Claude Code. Knows how you think, not just what you said.",
     "main": "index.js",
     "bin": {
@@ -11,16 +11,19 @@
         "scripts/",
         "!scripts/*.test.js",
         "!scripts/test_daemon.js",
-        "!scripts/hooks/test-*.js"
+        "!scripts/hooks/test-*.js",
+        "!scripts/daemon.yaml",
+        "!scripts/daemon.yaml.bak"
     ],
     "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-bridges.js

@@ -652,13 +652,30 @@ function createBridgeStarter(deps) {
   async function startFeishuBridge(config, executeTaskByName) {
     if (!config.feishu || !config.feishu.enabled) return null;
     if (!config.feishu.app_id || !config.feishu.app_secret) {
-      log('WARN', 'Feishu enabled but app_id/app_secret missing');
+      log('ERROR', 'Feishu enabled but app_id/app_secret missing — bridge will NOT start. Check ~/.metame/daemon.yaml');
       return null;
     }
 
     const { createBot } = require('./feishu-adapter.js');
     const bot = createBot(config.feishu);
 
+    // Validate credentials before starting WebSocket — fail loud, not silent
+    try {
+      const validation = await bot.validateCredentials();
+      if (!validation.ok) {
+        log('ERROR', `Feishu credential check FAILED: ${validation.error}`);
+        if (validation.isAuthError) {
+          log('ERROR', 'Feishu bridge will NOT start — fix app_id/app_secret in ~/.metame/daemon.yaml and restart daemon');
+          return null;
+        }
+        log('WARN', 'Feishu credential check failed (possibly network issue) — attempting to start anyway');
+      } else {
+        log('INFO', 'Feishu credentials validated OK');
+      }
+    } catch (e) {
+      log('WARN', `Feishu credential pre-check error: ${e.message} — attempting to start anyway`);
+    }
+
     try {
       const receiver = await bot.startReceiving(async (chatId, text, event, fileInfo, senderId) => {
         const liveCfg = loadConfig();

package/scripts/daemon-claude-engine.js

@@ -1605,6 +1605,33 @@ function createClaudeEngine(deps) {
           }
         }
 
+        // Inject latest nightly insight (decisions/lessons) — one-liner per file, ~100 tokens
+        if (!session.started) {
+          try {
+            const reflectDirs = [
+              path.join(HOME, '.metame', 'memory', 'decisions'),
+              path.join(HOME, '.metame', 'memory', 'lessons'),
+            ];
+            const reflectItems = [];
+            for (const dir of reflectDirs) {
+              if (!fs.existsSync(dir)) continue;
+              const files = fs.readdirSync(dir).filter(f => f.endsWith('.md')).sort();
+              const latest = files[files.length - 1];
+              if (!latest) continue;
+              const content = fs.readFileSync(path.join(dir, latest), 'utf8');
+              // Extract ## headings as one-line summaries (skip frontmatter)
+              const headings = content.match(/^## .+$/gm);
+              if (headings && headings.length > 0) {
+                const type = dir.endsWith('decisions') ? 'decision' : 'lesson';
+                reflectItems.push(...headings.slice(0, 2).map(h => `- [${type}] ${h.replace(/^## /, '')}`));
+              }
+            }
+            if (reflectItems.length > 0) {
+              memoryHint += `\n\n[Recent insights:\n${reflectItems.join('\n')}]`;
+            }
+          } catch { /* non-critical */ }
+        }
+
         memory.close();
       } catch (e) {
         if (e.code !== 'MODULE_NOT_FOUND') log('WARN', `Memory injection failed: ${e.message}`);
@@ -1636,6 +1663,19 @@ function createClaudeEngine(deps) {
         } catch { /* ignore */ }
       }
 
+      // Self-reflection patterns: behavioral guardrails distilled from past mistakes
+      let reflectHint = '';
+      if (!session.started && brainDoc) {
+        try {
+          const patterns = (brainDoc.growth && Array.isArray(brainDoc.growth.self_reflection_patterns))
+            ? brainDoc.growth.self_reflection_patterns.filter(p => p && p.summary).slice(0, 3)
+            : [];
+          if (patterns.length > 0) {
+            reflectHint = `\n- Self-correction patterns (avoid repeating these mistakes):\n${patterns.map(p => `  - ${String(p.summary).slice(0, 150)}`).join('\n')}`;
+          }
+        } catch { /* non-critical */ }
+      }
+
       // Inject daemon hints only on first message of a session
       // Task-specific rules (3-4) are injected only when isTaskIntent() returns true (~250 token saving for casual chat)
       let daemonHint = '';
@@ -1654,7 +1694,7 @@ ${mentorRadarHint}
    Keep it under 200 words. Clear it when the task is fully complete by running: \`> ~/.metame/memory/now/${projectKey || 'default'}.md\`` : '';
         daemonHint = `\n\n[System hints - DO NOT mention these to user:
 1. Daemon config: The ONLY config is ~/.metame/daemon.yaml (never edit daemon-default.yaml). Auto-reloads on change.
-2. Explanation depth (ZPD):${zdpHint ? zdpHint : '\n- User competence map unavailable. Default to concise expert-first explanations unless the user asks for teaching mode.'}${taskRules}]`;
+2. Explanation depth (ZPD):${zdpHint ? zdpHint : '\n- User competence map unavailable. Default to concise expert-first explanations unless the user asks for teaching mode.'}${reflectHint}${taskRules}]`;
       }
 
       daemonHint = adaptDaemonHintForEngine(daemonHint, runtime.name);

package/scripts/daemon-default.yaml

@@ -45,6 +45,7 @@ heartbeat:
       type: script
       command: node ~/.metame/distill.js
       interval: 4h
+      timeout: 5m
       precondition: "test -s ~/.metame/raw_signals.jsonl"
       require_idle: true
       notify: false
@@ -74,6 +75,7 @@ heartbeat:
       type: script
       command: node ~/.metame/skill-evolution.js
       interval: 12h
+      timeout: 5m
       precondition: "test -s ~/.metame/skill_signals.jsonl"
       require_idle: true
       notify: false
@@ -104,7 +106,7 @@ heartbeat:
       at: "01:30"
       require_idle: true
       notify: false
-      enabled: true
+      enabled: false
 
     # Legacy flat tasks (no project isolation). New tasks should go under projects: above.
     # Examples — uncomment or add your own: