metame-cli 1.4.34 → 1.5.1

package/scripts/daemon.js

@@ -35,13 +35,14 @@ process.on('uncaughtException', (err) => {
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { execSync, execFileSync, spawn } = require('child_process');
+const { execSync, execFileSync, execFile, spawn } = require('child_process');
 
 const HOME = os.homedir();
 const METAME_DIR = path.join(HOME, '.metame');
 const CONFIG_FILE = path.join(METAME_DIR, 'daemon.yaml');
 const STATE_FILE = path.join(METAME_DIR, 'daemon_state.json');
 const PID_FILE = path.join(METAME_DIR, 'daemon.pid');
+const LOCK_FILE = path.join(METAME_DIR, 'daemon.lock');
 const LOG_FILE = path.join(METAME_DIR, 'daemon.log');
 const BRAIN_FILE = path.join(HOME, '.claude_profile.yaml');
 const DISPATCH_DIR = path.join(METAME_DIR, 'dispatch');
@@ -59,7 +60,7 @@ const CLAUDE_BIN = (() => {
   ];
   try {
     const cmd = process.platform === 'win32' ? 'where claude' : 'which claude 2>/dev/null';
-    return execSync(cmd, { encoding: 'utf8' }).trim().split('\n')[0];
+    return execSync(cmd, { encoding: 'utf8', ...(process.platform === 'win32' ? { windowsHide: true } : {}) }).trim().split('\n')[0];
   } catch {}
   for (const p of candidates) { if (fs.existsSync(p)) return p; }
   return 'claude'; // fallback: hope it's in PATH
@@ -144,6 +145,7 @@ const { createFileBrowser } = require('./daemon-file-browser');
 const { createPidManager, setupRuntimeWatchers } = require('./daemon-runtime-lifecycle');
 const { createNotifier } = require('./daemon-notify');
 const { createClaudeEngine } = require('./daemon-claude-engine');
+const { createEngineRuntimeFactory, detectDefaultEngine, ENGINE_MODEL_CONFIG, ENGINE_DISTILL_MAP, ENGINE_DEFAULT_MODEL } = require('./daemon-engine-runtime');
 const { createCommandRouter } = require('./daemon-command-router');
 const { createTaskScheduler } = require('./daemon-task-scheduler');
 const { createAgentTools } = require('./daemon-agent-tools');
@@ -163,6 +165,11 @@ function getDaemonProviderEnv() {
   try { return providerMod.buildDaemonEnv(); } catch { return {}; }
 }
 
+function getDistillModel() {
+  if (!providerMod || typeof providerMod.getDistillModel !== 'function') return 'haiku';
+  try { return providerMod.getDistillModel(); } catch { return 'haiku'; }
+}
+
 function getActiveProviderEnv() {
   if (!providerMod) return {};
   try { return providerMod.buildActiveEnv(); } catch { return {}; }
@@ -205,9 +212,10 @@ const {
   cpExtractTimestamp,
   cpDisplayLabel,
   gitCheckpoint,
+  gitCheckpointAsync,
   listCheckpoints,
   cleanupCheckpoints,
-} = createCheckpointUtils({ execSync, path, log });
+} = createCheckpointUtils({ execSync, execFile, path, log });
 
 // ---------------------------------------------------------
 // CONFIG & STATE
@@ -893,6 +901,8 @@ function dispatchTask(targetProject, message, config, replyFn, streamOptions = n
  * Spawn session-summarize.js for sessions that have been idle 2-24 hours.
  * Called on sleep mode entry. Skips sessions that already have a fresh summary.
  */
+const MAX_CONCURRENT_SUMMARIES = 3;
+
 function spawnSessionSummaries() {
   const scriptPath = path.join(__dirname, 'session-summarize.js');
   if (!fs.existsSync(scriptPath)) return;
@@ -900,18 +910,43 @@ function spawnSessionSummaries() {
   const now = Date.now();
   const TWO_HOURS = 2 * 60 * 60 * 1000;
   const SEVEN_DAYS = 7 * 24 * 60 * 60 * 1000;
+  // Collect eligible sessions, sort by most recently active first
+  const eligible = [];
   for (const [cid, sess] of Object.entries(state.sessions || {})) {
-    if (!sess.id || !sess.started) continue;
+    // Support both old flat format and new per-engine format
+    let sessionId, started;
+    if (sess.engines) {
+      const active = Object.values(sess.engines).find(s => s.id && s.started);
+      if (!active) continue;
+      sessionId = active.id;
+      started = true;
+    } else {
+      sessionId = sess.id;
+      started = sess.started;
+    }
+    if (!sessionId || !started) continue;
     const lastActive = sess.last_active || 0;
     const idleMs = now - lastActive;
     if (idleMs < TWO_HOURS || idleMs > SEVEN_DAYS) continue;
-    // Skip if summary is already newer than last activity
     if ((sess.last_summary_at || 0) > lastActive) continue;
+    eligible.push({ cid, sess: { ...sess, id: sessionId, started }, lastActive });
+  }
+  eligible.sort((a, b) => b.lastActive - a.lastActive);
+
+  let spawned = 0;
+  for (const { cid, sess } of eligible) {
+    if (spawned >= MAX_CONCURRENT_SUMMARIES) {
+      log('INFO', `[DAEMON] Session summary concurrency limit (${MAX_CONCURRENT_SUMMARIES}) reached, deferring remaining`);
+      break;
+    }
+    const idleMs = now - (sess.last_active || 0);
     try {
       const child = spawn(process.execPath, [scriptPath, cid, sess.id], {
         detached: true, stdio: 'ignore',
+        ...(process.platform === 'win32' ? { windowsHide: true } : {}),
       });
       child.unref();
+      spawned++;
       log('INFO', `[DAEMON] Session summary spawned for ${cid} (idle ${Math.round(idleMs / 3600000)}h)`);
     } catch (e) {
       log('WARN', `[DAEMON] Failed to spawn session summary: ${e.message}`);
@@ -932,6 +967,15 @@ function handleDispatchItem(item, config) {
     log('WARN', `dispatch: unknown target "${item.target}"`);
     return;
   }
+  // 安全护栏：禁止 agent 主动 dispatch 到 personal（防止 LLM 幻觉乱发消息给小美）
+  // personal 只允许用户本人触发，或来源为 user/unknown 的系统任务
+  const _agentSources = new Set(Object.keys((config.projects) || {}));
+  const isFromAgent = _agentSources.has(item.from) || item.from === '_claude_session';
+  const targetProject = config.projects?.[item.target] || {};
+  if (isFromAgent && targetProject.guard === 'user-only') {
+    log('WARN', `dispatch: blocked agent "${item.from}" → "${item.target}" (user-only guard)`);
+    return;
+  }
   log('INFO', `Dispatch: ${item.from || '?'} → ${item.target}: ${item.prompt.slice(0, 60)}`);
   let pendingReplyFn = null;
   let streamOptions = null;
@@ -1109,13 +1153,11 @@ const {
 /**
  * Attach chatId to the most recent session in projCwd, or create a new one.
  */
-function attachOrCreateSession(chatId, projCwd, name) {
-  const state = loadState();
+function attachOrCreateSession(chatId, projCwd, name, engine) {
+  engine = engine || getDefaultEngine();
   // Virtual chatIds (_agent_* / _scope_*) are isolated from real user chats.
   // This avoids cross-context session collisions between user chat and dispatch flows.
-  const newSess = createSession(chatId, projCwd, name || '');
-  state.sessions[chatId] = { id: newSess.id, cwd: projCwd, started: false };
-  saveState(state);
+  createSession(chatId, projCwd, name || '', engine);
 }
 
 /**
@@ -1245,11 +1287,13 @@ const {
   buildSessionCardElements,
   listProjectDirs,
   getSession,
+  getSessionForEngine,
   createSession,
   getSessionName,
   writeSessionName,
   markSessionStarted,
   watchSessionFiles,
+  isEngineSessionValid,
 } = createSessionStore({
   fs,
   path,
@@ -1264,7 +1308,7 @@ const {
 watchSessionFiles(); // 热加载：手机端新建 session 后桌面无需重启
 
 // Active Claude processes per chat (for /stop)
-const activeProcesses = new Map(); // chatId -> { child, aborted }
+const activeProcesses = new Map(); // chatId -> { child, aborted, engine, killSignal }
 
 // Activity tracking for idle/sleep detection
 let lastInteractionTime = Date.now(); // updated on every incoming message
@@ -1301,13 +1345,19 @@ function isUserIdle() {
   return activeProcesses.size === 0;
 }
 
-// Fix3: persist child PIDs so next daemon startup can kill orphans
-const ACTIVE_PIDS_FILE = path.join(HOME, '.metame', 'active_claude_pids.json');
+// Persist child PIDs so next daemon startup can kill orphans
+const ACTIVE_PIDS_FILE = path.join(HOME, '.metame', 'active_agent_pids.json');
 function saveActivePids() {
   try {
     const pids = {};
     for (const [chatId, proc] of activeProcesses) {
-      if (proc.child && proc.child.pid) pids[chatId] = proc.child.pid;
+      if (proc.child && proc.child.pid) {
+        pids[chatId] = {
+          pid: proc.child.pid,
+          engine: proc.engine || getDefaultEngine(),
+          killSignal: proc.killSignal || 'SIGTERM',
+        };
+      }
     }
     fs.writeFileSync(ACTIVE_PIDS_FILE, JSON.stringify(pids), 'utf8');
   } catch { }
@@ -1321,22 +1371,81 @@ function killOrphanPids() {
   try {
     if (!fs.existsSync(ACTIVE_PIDS_FILE)) return;
     const pids = JSON.parse(fs.readFileSync(ACTIVE_PIDS_FILE, 'utf8'));
-    for (const [chatId, pid] of Object.entries(pids)) {
+    for (const [chatId, rec] of Object.entries(pids)) {
       try {
-        // Safety: only kill if PID still belongs to a claude process (prevent PID reuse accidents)
+        const pid = typeof rec === 'number' ? rec : Number(rec && rec.pid);
+        if (!Number.isFinite(pid) || pid <= 0) continue;
+        // Safety: only kill if PID still belongs to a known agent process (prevent PID reuse accidents)
         const comm = getProcessName(pid);
-        if (!comm || !comm.includes('claude')) {
-          log('WARN', `Skipping PID ${pid} (chatId: ${chatId}): process is "${comm}", not claude`);
+        const isKnownAgent = !!comm && (comm.includes('claude') || comm.includes('codex'));
+        if (!isKnownAgent) {
+          log('WARN', `Skipping PID ${pid} (chatId: ${chatId}): process is "${comm}", not claude/codex`);
           continue;
         }
         process.kill(pid, 'SIGKILL');
-        log('INFO', `Killed orphan claude PID ${pid} (chatId: ${chatId})`);
+        log('INFO', `Killed orphan agent PID ${pid} (chatId: ${chatId})`);
       } catch { }
     }
     fs.unlinkSync(ACTIVE_PIDS_FILE);
   } catch { }
 }
 
+const detectedEngine = detectDefaultEngine({ fs, execSync });
+let _defaultEngine = loadState().default_engine || detectedEngine;
+if (providerMod && typeof providerMod.setEngine === 'function') {
+  providerMod.setEngine(_defaultEngine);
+}
+log('INFO', `Default engine: ${_defaultEngine} (detected: ${detectedEngine})`);
+
+// One-time migration: daemon.model (legacy) → daemon.models.<engine>
+try {
+  const _migCfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {};
+  if (_migCfg.daemon && _migCfg.daemon.model && !_migCfg.daemon.models) {
+    _migCfg.daemon.models = { [_defaultEngine]: _migCfg.daemon.model };
+    writeConfigSafe(_migCfg);
+    log('INFO', `Migrated daemon.model="${_migCfg.daemon.model}" → daemon.models.${_defaultEngine}`);
+  }
+} catch { /* ignore */ }
+
+function getDefaultEngine() {
+  return _defaultEngine;
+}
+
+function setDefaultEngine(engine) {
+  _defaultEngine = engine;
+  const st = loadState();
+  st.default_engine = engine;
+  saveState(st);
+  if (providerMod) {
+    // Sync distill model to this engine's default
+    if (typeof providerMod.setDistillModel === 'function') {
+      const distill = (ENGINE_MODEL_CONFIG[engine] || ENGINE_MODEL_CONFIG.claude).distill;
+      try { providerMod.setDistillModel(distill); } catch { /* ignore */ }
+    }
+    if (typeof providerMod.setEngine === 'function') {
+      try { providerMod.setEngine(engine); } catch { /* ignore */ }
+    }
+  }
+  // Migrate old daemon.model → daemon.models[engine] on first switch
+  try {
+    const cfg = yaml.load(fs.readFileSync(CONFIG_FILE, 'utf8')) || {};
+    if (!cfg.daemon) cfg.daemon = {};
+    if (cfg.daemon.model && !cfg.daemon.models) {
+      cfg.daemon.models = { [engine]: cfg.daemon.model };
+      writeConfigSafe(cfg);
+    }
+  } catch { /* ignore */ }
+}
+
+const getEngineRuntime = createEngineRuntimeFactory({
+  fs,
+  path,
+  HOME,
+  execSync,
+  CLAUDE_BIN,
+  getActiveProviderEnv,
+});
+
 const {
   checkPrecondition,
   executeTask,
@@ -1358,6 +1467,7 @@ const {
   recordTokens,
   buildProfilePreamble,
   getDaemonProviderEnv,
+  getDistillModel,
   log,
   physiologicalHeartbeat,
   isUserIdle,
@@ -1403,6 +1513,9 @@ const { handleAdminCommand } = createAdminCommandHandler({
   getMessageQueue: () => messageQueue,
   loadState,
   saveState,
+  getDefaultEngine,
+  setDefaultEngine,
+  getDistillModel,
 });
 
 const { handleSessionCommand } = createSessionCommandHandler({
@@ -1430,6 +1543,7 @@ const { handleSessionCommand } = createSessionCommandHandler({
   sessionRichLabel,
   buildSessionCardElements,
   sessionLabel,
+  getDefaultEngine,
 });
 
 // Message queue for messages received while a task is running
@@ -1461,17 +1575,22 @@ const { spawnClaudeAsync, askClaude } = createClaudeEngine({
   sendFileButtons,
   findSessionFile,
   listRecentSessions,
+  isEngineSessionValid,
   getSession,
+  getSessionForEngine,
   createSession,
   getSessionName,
   writeSessionName,
   markSessionStarted,
   gitCheckpoint,
+  gitCheckpointAsync,
   recordTokens,
   skillEvolution,
   touchInteraction,
   statusThrottleMs: STATUS_THROTTLE_MS,
   fallbackThrottleMs: FALLBACK_THROTTLE_MS,
+  getEngineRuntime,
+  getDefaultEngine,
 });
 
 const agentTools = createAgentTools({
@@ -1531,6 +1650,7 @@ const { handleAgentCommand } = createAgentCommandHandler({
   attachOrCreateSession,
   agentFlowTtlMs: getAgentFlowTtlMs,
   agentBindTtlMs: getAgentBindTtlMs,
+  getDefaultEngine,
 });
 
 // Caffeinate process for /nosleep toggle (macOS only)
@@ -1556,6 +1676,7 @@ const { handleExecCommand } = createExecCommandHandler({
   createSession,
   findSessionFile,
   loadConfig,
+  getDistillModel,
 });
 
 const { handleOpsCommand } = createOpsCommandHandler({
@@ -1604,6 +1725,7 @@ const { handleCommand } = createCommandRouter({
   pendingAgentFlows,
   pendingActivations,
   agentFlowTtlMs: getAgentFlowTtlMs,
+  getDefaultEngine,
 });
 
 // Bind handleCommand for agent dispatch (must come after handleCommand definition)
@@ -1643,6 +1765,72 @@ function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+let daemonLockFd = null;
+function isPidAlive(pid) {
+  if (!pid || Number.isNaN(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function acquireDaemonLock() {
+  const restartFromPid = parseInt(process.env.METAME_RESTART_FROM_PID || '', 10);
+  const maxAttempts = restartFromPid ? 6 : 2;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      daemonLockFd = fs.openSync(LOCK_FILE, 'wx');
+      fs.writeFileSync(daemonLockFd, JSON.stringify({
+        pid: process.pid,
+        started_at: new Date().toISOString(),
+      }), 'utf8');
+      return true;
+    } catch (e) {
+      if (e.code !== 'EEXIST') {
+        log('ERROR', `Failed to acquire daemon lock: ${e.message}`);
+        return false;
+      }
+      try {
+        const raw = fs.readFileSync(LOCK_FILE, 'utf8');
+        const meta = JSON.parse(raw || '{}');
+        const ownerPid = parseInt(meta.pid, 10);
+        if (isPidAlive(ownerPid)) {
+          // Restart handoff: allow child to wait for parent to exit and take over.
+          if (restartFromPid && ownerPid === restartFromPid) {
+            for (let i = 0; i < 30; i++) {
+              sleepSync(500);
+              if (!isPidAlive(ownerPid)) break;
+            }
+            if (isPidAlive(ownerPid)) {
+              log('WARN', `Restart handoff timed out, previous daemon still alive (PID: ${ownerPid})`);
+              if (attempt < maxAttempts - 1) continue;
+              return false;
+            }
+            try { fs.unlinkSync(LOCK_FILE); } catch { /* ignore */ }
+            continue;
+          }
+          log('WARN', `Another daemon instance owns lock (PID: ${meta.pid})`);
+          return false;
+        }
+      } catch {
+        // Ignore malformed lock metadata and treat as stale.
+      }
+      try { fs.unlinkSync(LOCK_FILE); } catch { /* ignore */ }
+    }
+  }
+  return false;
+}
+
+function releaseDaemonLock() {
+  try {
+    if (daemonLockFd !== null) fs.closeSync(daemonLockFd);
+  } catch { /* ignore */ }
+  daemonLockFd = null;
+  try { if (fs.existsSync(LOCK_FILE)) fs.unlinkSync(LOCK_FILE); } catch { /* ignore */ }
+}
+
 // ---------------------------------------------------------
 // MAIN
 // ---------------------------------------------------------
@@ -1662,7 +1850,9 @@ async function main() {
   // Config validation: warn on unknown/suspect fields
   const KNOWN_SECTIONS = ['daemon', 'telegram', 'feishu', 'heartbeat', 'budget', 'projects'];
   const KNOWN_DAEMON = [
-    'model',
+    'model',          // legacy (still valid as fallback)
+    'models',         // per-engine model map: { claude, codex }
+    'distill_models', // per-engine distill model map
     'log_max_size',
     'heartbeat_check_interval',
     'session_allowed_tools',
@@ -1674,7 +1864,8 @@ async function main() {
     'enable_nl_mac_control',
     'enable_nl_mac_fallback',
   ];
-  const VALID_MODELS = ['sonnet', 'opus', 'haiku'];
+  // All known models across all engines (for legacy daemon.model validation only)
+  const BUILTIN_CLAUDE_MODELS = ENGINE_MODEL_CONFIG.claude.options;
   for (const key of Object.keys(config)) {
     if (!KNOWN_SECTIONS.includes(key)) log('WARN', `Config: unknown section "${key}" (typo?)`);
   }
@@ -1682,17 +1873,22 @@ async function main() {
     for (const key of Object.keys(config.daemon)) {
       if (!KNOWN_DAEMON.includes(key)) log('WARN', `Config: unknown daemon.${key} (typo?)`);
     }
-    if (config.daemon.model && !VALID_MODELS.includes(config.daemon.model)) {
-      // Custom model names are valid when using non-anthropic providers
+    // Validate legacy daemon.model (only warn if anthropic provider + unknown Claude model)
+    if (config.daemon.model && !BUILTIN_CLAUDE_MODELS.includes(config.daemon.model)) {
       const activeProv = providerMod ? providerMod.getActiveName() : 'anthropic';
-      if (activeProv === 'anthropic') {
-        log('WARN', `Config: daemon.model="${config.daemon.model}" is not a known model`);
+      if (activeProv === 'anthropic' && _defaultEngine === 'claude') {
+        log('WARN', `Config: daemon.model="${config.daemon.model}" is not a known Claude model`);
       } else {
-        log('INFO', `Config: custom model "${config.daemon.model}" for provider "${activeProv}"`);
+        log('INFO', `Config: model "${config.daemon.model}" for engine "${_defaultEngine}" / provider "${activeProv}"`);
       }
     }
   }
 
+  if (!acquireDaemonLock()) {
+    process.exit(0);
+  }
+  process.on('exit', releaseDaemonLock);
+
   // Takeover: kill any existing daemon
   killExistingDaemon();
   writePid();
@@ -1749,12 +1945,39 @@ async function main() {
   });
   const notifyFn = notifier.notify;
   const adminNotifyFn = notifier.notifyAdmin;
+  const notifyPersonalFn = notifier.notifyPersonal;
 
   // Start dispatch socket server (low-latency IPC, fallback: file polling still works)
   const dispatchSocket = startDispatchSocket(() => config);
 
   // Start heartbeat scheduler
-  let heartbeatTimer = startHeartbeat(config, notifyFn);
+  let heartbeatTimer = startHeartbeat(config, notifyFn, notifyPersonalFn);
+
+  let shuttingDown = false;
+  function spawnReplacementDaemon(reason) {
+    try {
+      const replacementScript = path.join(METAME_DIR, 'daemon.js');
+      const bg = spawn(process.execPath, [replacementScript], {
+        detached: process.platform !== 'win32',
+        stdio: 'ignore',
+        windowsHide: true,
+        cwd: METAME_DIR,
+        env: {
+          ...process.env,
+          HOME,
+          USERPROFILE: HOME,
+          METAME_ROOT: process.env.METAME_ROOT || path.dirname(__filename),
+          METAME_RESTART_FROM_PID: String(process.pid),
+        },
+      });
+      bg.unref();
+      log('INFO', `[RESTART] Spawned replacement daemon (PID: ${bg.pid}) reason=${reason}`);
+      return true;
+    } catch (e) {
+      log('ERROR', `[RESTART] Failed to spawn replacement daemon: ${e.message}`);
+      return false;
+    }
+  }
 
   const runtimeWatchers = setupRuntimeWatchers({
     fs,
@@ -1769,14 +1992,15 @@ async function main() {
     log,
     notifyFn,
     adminNotifyFn,
+    notifyPersonalFn,
     activeProcesses,
     getConfig: () => config,
     setConfig: (next) => { config = next; },
     getHeartbeatTimer: () => heartbeatTimer,
     setHeartbeatTimer: (next) => { heartbeatTimer = next; },
     onRestartRequested: () => {
-      // Reuse full shutdown logic (kill child processes, clean PID, stop bridges)
-      shutdown().catch(() => process.exit(0));
+      // Reuse full shutdown logic, then self-spawn replacement.
+      shutdown({ restartReason: 'daemon-script-changed' }).catch(() => process.exit(1));
     },
   });
   // Expose reloadConfig to handleCommand via closure
@@ -1808,7 +2032,17 @@ async function main() {
   }
 
   // Graceful shutdown
-  const shutdown = async () => {
+  const shutdown = async (opts = {}) => {
+    if (shuttingDown) return;
+    shuttingDown = true;  // set immediately to prevent double-spawn race condition
+    if (opts.restartReason) {
+      const spawned = spawnReplacementDaemon(opts.restartReason);
+      if (!spawned) {
+        log('ERROR', `[RESTART] Abort shutdown: failed to spawn replacement (${opts.restartReason})`);
+        shuttingDown = false;
+        return;
+      }
+    }
     log('INFO', 'Daemon shutting down...');
     await notifyActiveUsers('关闭').catch(() => {});
     runtimeWatchers.stop();
@@ -1819,14 +2053,15 @@ async function main() {
     if (feishuBridge) feishuBridge.stop();
     // Stop QMD semantic search daemon if it was started
     try { require('./qmd-client').stopDaemon(); } catch { /* ignore */ }
-    // Kill all tracked claude process groups before exiting (covers sub-agents too)
+    // Kill all tracked engine process groups before exiting (covers sub-agents too)
     for (const [cid, proc] of activeProcesses) {
       try { process.kill(-proc.child.pid, 'SIGKILL'); } catch { try { proc.child.kill('SIGKILL'); } catch { } }
-      log('INFO', `Shutdown: killed claude process group for chatId ${cid}`);
+      log('INFO', `Shutdown: killed engine process group for chatId ${cid}`);
     }
     activeProcesses.clear();
     try { if (fs.existsSync(ACTIVE_PIDS_FILE)) fs.unlinkSync(ACTIVE_PIDS_FILE); } catch { }
     cleanPid();
+    releaseDaemonLock();
     const s = loadState();
     s.pid = null;
     saveState(s);
@@ -1850,7 +2085,7 @@ async function main() {
         st.watchdog_restart = new Date().toISOString();
         st.watchdog_stall_seconds = Math.round(elapsed / 1000);
         saveState(st);
-        process.exit(1); // caffeinate or launchd will restart us
+        shutdown({ restartReason: 'watchdog-stall' }).catch(() => process.exit(1));
       }
     } catch (e) {
       log('WARN', `[WATCHDOG] Check failed: ${e.message}`);