npm - @node9/proxy - Versions diffs - 1.61.1 → 1.62.1 - Mend

@node9/proxy 1.61.1 → 1.62.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/cli.mjs CHANGED Viewed

@@ -248,8 +248,8 @@ function sanitizeConfig(raw) {
     }
   }
   const lines = result.error.issues.map((issue) => {
-    const path70 = issue.path.length > 0 ? issue.path.join(".") : "root";
-    return `  \u2022 ${path70}: ${issue.message}`;
+    const path71 = issue.path.length > 0 ? issue.path.join(".") : "root";
+    return `  \u2022 ${path71}: ${issue.message}`;
   });
   return {
     sanitized,
@@ -1464,9 +1464,9 @@ function matchesPattern(text, patterns) {
   const withoutDotSlash = text.replace(/^\.\//, "");
   return isMatch(withoutDotSlash) || isMatch(`./${withoutDotSlash}`);
 }
-function getNestedValue(obj, path70) {
+function getNestedValue(obj, path71) {
   if (!obj || typeof obj !== "object") return null;
-  const segments = path70.split(".");
+  const segments = path71.split(".");
   for (const seg of segments) {
     if (FORBIDDEN_PATH_SEGMENTS.has(seg)) return null;
   }
@@ -4849,10 +4849,10 @@ function getConfig(cwd) {
         }
         if (Array.isArray(mc.jailPaths)) {
           for (const jp of mc.jailPaths) {
-            const path70 = typeof jp?.path === "string" ? jp.path.trim() : "";
-            if (!path70) continue;
+            const path71 = typeof jp?.path === "string" ? jp.path.trim() : "";
+            if (!path71) continue;
             const verdict = jp?.verdict === "review" ? "review" : "block";
-            for (const r of pathRules(path70, verdict, "org-managed jail")) {
+            for (const r of pathRules(path71, verdict, "org-managed jail")) {
               mergedPolicy.smartRules.push({ ...r, name: `org:${r.name}` });
             }
           }
@@ -17963,6 +17963,66 @@ function pickSyncIntervalMs(cloudHours, localSettings) {
 function effectiveSyncIntervalMs() {
   return pickSyncIntervalMs(readCachedSyncIntervalHours(), getConfig().settings);
 }
+function readSyncHealth() {
+  try {
+    const raw = JSON.parse(fs36.readFileSync(syncHealthFile(), "utf-8"));
+    return {
+      lastCheckedAt: typeof raw.lastCheckedAt === "string" ? raw.lastCheckedAt : void 0,
+      lastChangedAt: typeof raw.lastChangedAt === "string" ? raw.lastChangedAt : void 0,
+      lastError: typeof raw.lastError === "string" ? raw.lastError : void 0,
+      lastErrorAt: typeof raw.lastErrorAt === "string" ? raw.lastErrorAt : void 0,
+      consecutiveFailures: typeof raw.consecutiveFailures === "number" && raw.consecutiveFailures >= 0 ? raw.consecutiveFailures : 0
+    };
+  } catch {
+    return { consecutiveFailures: 0 };
+  }
+}
+function writeSyncHealth(h) {
+  try {
+    const file = syncHealthFile();
+    const dir = path35.dirname(file);
+    if (!fs36.existsSync(dir)) fs36.mkdirSync(dir, { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs36.writeFileSync(tmp, JSON.stringify(h, null, 2) + "\n", "utf-8");
+    fs36.renameSync(tmp, file);
+  } catch {
+  }
+}
+function readCacheFetchedAt() {
+  try {
+    const raw = JSON.parse(fs36.readFileSync(rulesCacheFile(), "utf-8"));
+    return typeof raw.fetchedAt === "string" ? raw.fetchedAt : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function recordSyncHealth(result) {
+  const h = readSyncHealth();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (result.ok) {
+    h.lastCheckedAt = now;
+    if (result.changed) h.lastChangedAt = now;
+    h.consecutiveFailures = 0;
+    h.lastError = void 0;
+    h.lastErrorAt = void 0;
+  } else {
+    h.consecutiveFailures += 1;
+    h.lastError = result.error;
+    h.lastErrorAt = now;
+  }
+  writeSyncHealth(h);
+}
+function stalenessThresholdMs(intervalMs) {
+  return Math.min(STALE_MAX_MS, Math.max(STALE_MIN_MS, intervalMs * STALE_FACTOR));
+}
+function isPolicyStale(nowMs = Date.now(), health) {
+  const h = health ?? readSyncHealth();
+  const lastKnownGood = h.lastCheckedAt ?? readCacheFetchedAt();
+  if (!lastKnownGood) return false;
+  const last = Date.parse(lastKnownGood);
+  if (Number.isNaN(last)) return false;
+  return nowMs - last > stalenessThresholdMs(effectiveSyncIntervalMs());
+}
 function fetchCloudPolicy(apiKey, apiUrl, ifNoneMatch) {
   const parsed = new URL(apiUrl);
   const headers = {
@@ -18127,6 +18187,7 @@ async function syncOnce() {
   try {
     const result = await fetchCloudPolicy(creds.apiKey, creds.apiUrl, readCachedEtag());
     if (result.kind === "unchanged") {
+      recordSyncHealth({ ok: true });
     } else {
       const cache = {
         fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -18140,8 +18201,19 @@ async function syncOnce() {
         managedConfig: extractManagedConfig(result.body)
       };
       writeCache2(cache);
+      recordSyncHealth({ ok: true, changed: true });
+    }
+  } catch (err2) {
+    const msg = err2 instanceof Error ? err2.message : String(err2);
+    recordSyncHealth({ ok: false, error: msg });
+    try {
+      appendToLog(HOOK_DEBUG_LOG, {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        kind: "policy-sync-error",
+        error: msg
+      });
+    } catch {
     }
-  } catch {
   }
   if (process.env.NODE9_BLAST_DISABLE !== "1") {
     void pushBlastSnapshot(creds);
@@ -18317,6 +18389,7 @@ async function runCloudSync() {
     const result = await fetchCloudPolicy(creds.apiKey, creds.apiUrl, readCachedEtag());
     if (result.kind === "unchanged") {
       const status = getCloudSyncStatus();
+      recordSyncHealth({ ok: true });
       maybePushBlast();
       return status.cached ? { ok: true, rules: status.rules, fetchedAt: status.fetchedAt, unchanged: true } : { ok: true, rules: 0, fetchedAt: (/* @__PURE__ */ new Date()).toISOString(), unchanged: true };
     }
@@ -18332,11 +18405,14 @@ async function runCloudSync() {
       managedConfig: extractManagedConfig(result.body)
     };
     writeCache2(cache);
+    recordSyncHealth({ ok: true, changed: true });
     maybePushBlast();
     return { ok: true, rules: cache.rules.length, fetchedAt: cache.fetchedAt };
   } catch (err2) {
+    const msg = err2 instanceof Error ? err2.message : String(err2);
+    recordSyncHealth({ ok: false, error: msg });
     maybePushBlast();
-    return { ok: false, reason: err2 instanceof Error ? err2.message : String(err2) };
+    return { ok: false, reason: msg };
   }
 }
 function getCloudSyncStatus() {
@@ -18393,7 +18469,7 @@ function startForensicBroadcast() {
   const recurring = setInterval(() => void tick(), FORENSIC_BROADCAST_INTERVAL_MS);
   recurring.unref();
 }
-var FINDING_TO_SIGNAL3, rulesCacheFile, DEFAULT_API_URL2, DEFAULT_INTERVAL_HOURS, MIN_INTERVAL_SECONDS, MAX_INTERVAL_SECONDS, FORENSIC_BROADCAST_INTERVAL_MS, FORENSIC_INITIAL_DELAY_MS, forensicBroadcastOffsets;
+var FINDING_TO_SIGNAL3, rulesCacheFile, DEFAULT_API_URL2, DEFAULT_INTERVAL_HOURS, MIN_INTERVAL_SECONDS, MAX_INTERVAL_SECONDS, syncHealthFile, STALE_MIN_MS, STALE_MAX_MS, STALE_FACTOR, FORENSIC_BROADCAST_INTERVAL_MS, FORENSIC_INITIAL_DELAY_MS, forensicBroadcastOffsets;
 var init_sync = __esm({
   "src/daemon/sync.ts"() {
     "use strict";
@@ -18427,6 +18503,10 @@ var init_sync = __esm({
     DEFAULT_INTERVAL_HOURS = 5;
     MIN_INTERVAL_SECONDS = 15;
     MAX_INTERVAL_SECONDS = 24 * 60 * 60;
+    syncHealthFile = () => path35.join(os33.homedir(), ".node9", "sync-health.json");
+    STALE_MIN_MS = 3 * 60 * 60 * 1e3;
+    STALE_MAX_MS = 24 * 60 * 60 * 1e3;
+    STALE_FACTOR = 3;
     FORENSIC_BROADCAST_INTERVAL_MS = 3e4;
     FORENSIC_INITIAL_DELAY_MS = 5e3;
     forensicBroadcastOffsets = /* @__PURE__ */ new Map();
@@ -19041,23 +19121,68 @@ var init_hook_heal = __esm({
   }
 });
-// src/daemon/server.ts
-import http3 from "http";
+// src/daemon/startup-log.ts
 import fs40 from "fs";
 import path39 from "path";
 import os37 from "os";
+function openStartupLogFd() {
+  try {
+    const file = DAEMON_STARTUP_LOG();
+    const dir = path39.dirname(file);
+    if (!fs40.existsSync(dir)) fs40.mkdirSync(dir, { recursive: true });
+    try {
+      if (fs40.statSync(file).size > MAX_STARTUP_LOG_BYTES) fs40.truncateSync(file);
+    } catch {
+    }
+    return fs40.openSync(file, "a");
+  } catch {
+    return void 0;
+  }
+}
+function logDaemonStartup(kind, detail) {
+  try {
+    const file = DAEMON_STARTUP_LOG();
+    const dir = path39.dirname(file);
+    if (!fs40.existsSync(dir)) fs40.mkdirSync(dir, { recursive: true });
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon-startup:${kind}${detail ? ` ${detail}` : ""}
+`;
+    fs40.appendFileSync(file, line, "utf-8");
+  } catch {
+  }
+}
+var DAEMON_STARTUP_LOG, MAX_STARTUP_LOG_BYTES;
+var init_startup_log = __esm({
+  "src/daemon/startup-log.ts"() {
+    "use strict";
+    DAEMON_STARTUP_LOG = () => path39.join(os37.homedir(), ".node9", "daemon-startup.log");
+    MAX_STARTUP_LOG_BYTES = 256 * 1024;
+  }
+});
+// src/daemon/server.ts
+import http3 from "http";
+import fs41 from "fs";
+import path40 from "path";
+import os38 from "os";
 import { randomUUID as randomUUID4 } from "crypto";
 import { spawnSync } from "child_process";
 import chalk6 from "chalk";
 function startDaemon() {
-  startCostSync();
-  startCloudSync();
-  startForensicBroadcast();
-  startAuditShipper();
-  startDlpScanner();
-  startMcpReconciler();
-  startHookHeal();
-  loadInsightCounts();
+  try {
+    startCostSync();
+    startCloudSync();
+    startForensicBroadcast();
+    startAuditShipper();
+    startDlpScanner();
+    startMcpReconciler();
+    startHookHeal();
+    loadInsightCounts();
+  } catch (err2) {
+    const stack = err2 instanceof Error ? err2.stack ?? err2.message : String(err2);
+    console.error("\n\u{1F6D1} Node9 daemon startup failed:\n" + stack);
+    logDaemonStartup("startup-throw", err2 instanceof Error ? err2.message : String(err2));
+    process.exit(1);
+  }
   const internalToken = randomUUID4();
   const validToken = (req) => req.headers["x-node9-internal"] === internalToken || req.headers["x-node9-token"] === internalToken;
   const IDLE_TIMEOUT_MS = 12 * 60 * 60 * 1e3;
@@ -19069,7 +19194,7 @@ function startDaemon() {
     idleTimer = setTimeout(() => {
       if (autoStarted) {
         try {
-          fs40.unlinkSync(DAEMON_PID_FILE);
+          fs41.unlinkSync(DAEMON_PID_FILE);
         } catch {
         }
       }
@@ -19214,7 +19339,7 @@ data: ${JSON.stringify(item.data)}
             mcpServer: entry.mcpServer
           });
         }
-        const projectCwd = typeof cwd === "string" && path39.isAbsolute(cwd) ? cwd : void 0;
+        const projectCwd = typeof cwd === "string" && path40.isAbsolute(cwd) ? cwd : void 0;
         const projectConfig = getConfig(projectCwd);
         const browserEnabled = projectConfig.settings.approvers?.browser !== false;
         const terminalEnabled = projectConfig.settings.approvers?.terminal !== false;
@@ -19506,8 +19631,8 @@ data: ${JSON.stringify(item.data)}
       if (!validToken(req)) return res.writeHead(403).end();
       const periodParam = reqUrl.searchParams.get("period") || "7d";
       const period = ["today", "7d", "30d", "month"].includes(periodParam) ? periodParam : "7d";
-      const logPath = path39.join(os37.homedir(), ".node9", "audit.log");
-      if (!fs40.existsSync(logPath)) {
+      const logPath = path40.join(os38.homedir(), ".node9", "audit.log");
+      if (!fs41.existsSync(logPath)) {
         res.writeHead(200, { "Content-Type": "application/json" });
         return res.end(
           JSON.stringify({
@@ -19520,7 +19645,7 @@ data: ${JSON.stringify(item.data)}
         );
       }
       try {
-        const raw = fs40.readFileSync(logPath, "utf-8");
+        const raw = fs41.readFileSync(logPath, "utf-8");
         const allEntries = raw.split("\n").flatMap((line) => {
           if (!line.trim()) return [];
           try {
@@ -19903,14 +20028,15 @@ data: ${JSON.stringify(item.data)}
   server.on("error", (e) => {
     if (e.code === "EADDRINUSE") {
       try {
-        if (fs40.existsSync(DAEMON_PID_FILE)) {
-          const { pid } = JSON.parse(fs40.readFileSync(DAEMON_PID_FILE, "utf-8"));
+        if (fs41.existsSync(DAEMON_PID_FILE)) {
+          const { pid } = JSON.parse(fs41.readFileSync(DAEMON_PID_FILE, "utf-8"));
           process.kill(pid, 0);
+          logDaemonStartup("port-in-use", `another daemon (pid ${pid}) owns :${DAEMON_PORT}`);
           return process.exit(0);
         }
       } catch {
         try {
-          fs40.unlinkSync(DAEMON_PID_FILE);
+          fs41.unlinkSync(DAEMON_PID_FILE);
         } catch {
         }
         server.listen(DAEMON_PORT, DAEMON_HOST);
@@ -19959,6 +20085,7 @@ data: ${JSON.stringify(item.data)}
       });
       return;
     }
+    logDaemonStartup("bind-failed", e.message);
     console.error(chalk6.red("\n\u{1F6D1} Node9 Daemon Error:"), e.message);
     process.exit(1);
   });
@@ -19996,20 +20123,21 @@ var init_server = __esm({
     init_dlp_scanner();
     init_mcp_reconciler();
     init_hook_heal();
+    init_startup_log();
     init_mcp_tools();
   }
 });
 // src/daemon/service.ts
-import fs41 from "fs";
-import path40 from "path";
-import os38 from "os";
+import fs42 from "fs";
+import path41 from "path";
+import os39 from "os";
 import { spawnSync as spawnSync2, execFileSync } from "child_process";
 function resolveNode9Binary() {
   try {
     const script = process.argv[1];
-    if (typeof script === "string" && path40.isAbsolute(script) && fs41.existsSync(script)) {
-      return fs41.realpathSync(script);
+    if (typeof script === "string" && path41.isAbsolute(script) && fs42.existsSync(script)) {
+      return fs42.realpathSync(script);
     }
   } catch {
   }
@@ -20027,11 +20155,11 @@ function xmlEscape(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
 function launchdPlist(binaryPath) {
-  const logDir = path40.join(os38.homedir(), ".node9");
+  const logDir = path41.join(os39.homedir(), ".node9");
   const nodePath = xmlEscape(process.execPath);
   const scriptPath = xmlEscape(binaryPath);
-  const outLog = xmlEscape(path40.join(logDir, "daemon.log"));
-  const errLog = xmlEscape(path40.join(logDir, "daemon-error.log"));
+  const outLog = xmlEscape(path41.join(logDir, "daemon.log"));
+  const errLog = xmlEscape(path41.join(logDir, "daemon-error.log"));
   return `<?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">
@@ -20064,9 +20192,9 @@ function launchdPlist(binaryPath) {
 `;
 }
 function installLaunchd(binaryPath) {
-  const dir = path40.dirname(LAUNCHD_PLIST);
-  if (!fs41.existsSync(dir)) fs41.mkdirSync(dir, { recursive: true });
-  fs41.writeFileSync(LAUNCHD_PLIST, launchdPlist(binaryPath), "utf-8");
+  const dir = path41.dirname(LAUNCHD_PLIST);
+  if (!fs42.existsSync(dir)) fs42.mkdirSync(dir, { recursive: true });
+  fs42.writeFileSync(LAUNCHD_PLIST, launchdPlist(binaryPath), "utf-8");
   spawnSync2("launchctl", ["unload", LAUNCHD_PLIST], { encoding: "utf8" });
   const r = spawnSync2("launchctl", ["load", "-w", LAUNCHD_PLIST], {
     encoding: "utf8",
@@ -20077,13 +20205,13 @@ function installLaunchd(binaryPath) {
   }
 }
 function uninstallLaunchd() {
-  if (fs41.existsSync(LAUNCHD_PLIST)) {
+  if (fs42.existsSync(LAUNCHD_PLIST)) {
     spawnSync2("launchctl", ["unload", "-w", LAUNCHD_PLIST], { encoding: "utf8", timeout: 5e3 });
-    fs41.unlinkSync(LAUNCHD_PLIST);
+    fs42.unlinkSync(LAUNCHD_PLIST);
   }
 }
 function isLaunchdInstalled() {
-  return fs41.existsSync(LAUNCHD_PLIST);
+  return fs42.existsSync(LAUNCHD_PLIST);
 }
 function systemdUnit(binaryPath) {
   return `[Unit]
@@ -20102,12 +20230,12 @@ WantedBy=default.target
 `;
 }
 function installSystemd(binaryPath) {
-  if (!fs41.existsSync(SYSTEMD_UNIT_DIR)) {
-    fs41.mkdirSync(SYSTEMD_UNIT_DIR, { recursive: true });
+  if (!fs42.existsSync(SYSTEMD_UNIT_DIR)) {
+    fs42.mkdirSync(SYSTEMD_UNIT_DIR, { recursive: true });
   }
-  fs41.writeFileSync(SYSTEMD_UNIT, systemdUnit(binaryPath), "utf-8");
+  fs42.writeFileSync(SYSTEMD_UNIT, systemdUnit(binaryPath), "utf-8");
   try {
-    execFileSync("loginctl", ["enable-linger", os38.userInfo().username], { timeout: 3e3 });
+    execFileSync("loginctl", ["enable-linger", os39.userInfo().username], { timeout: 3e3 });
   } catch {
   }
   const reload = spawnSync2("systemctl", ["--user", "daemon-reload"], {
@@ -20127,23 +20255,23 @@ function installSystemd(binaryPath) {
   }
 }
 function uninstallSystemd() {
-  if (fs41.existsSync(SYSTEMD_UNIT)) {
+  if (fs42.existsSync(SYSTEMD_UNIT)) {
     spawnSync2("systemctl", ["--user", "disable", "--now", "node9-daemon"], {
       encoding: "utf8",
       timeout: 5e3
     });
     spawnSync2("systemctl", ["--user", "daemon-reload"], { encoding: "utf8", timeout: 5e3 });
-    fs41.unlinkSync(SYSTEMD_UNIT);
+    fs42.unlinkSync(SYSTEMD_UNIT);
   }
 }
 function isSystemdInstalled() {
-  return fs41.existsSync(SYSTEMD_UNIT);
+  return fs42.existsSync(SYSTEMD_UNIT);
 }
 function stopRunningDaemon() {
-  const pidFile = path40.join(os38.homedir(), ".node9", "daemon.pid");
-  if (!fs41.existsSync(pidFile)) return;
+  const pidFile = path41.join(os39.homedir(), ".node9", "daemon.pid");
+  if (!fs42.existsSync(pidFile)) return;
   try {
-    const data = JSON.parse(fs41.readFileSync(pidFile, "utf-8"));
+    const data = JSON.parse(fs42.readFileSync(pidFile, "utf-8"));
     const pid = data.pid;
     const MAX_PID2 = 4194304;
     if (typeof pid === "number" && Number.isInteger(pid) && pid > 0 && pid <= MAX_PID2) {
@@ -20163,7 +20291,7 @@ function stopRunningDaemon() {
       }
     }
     try {
-      fs41.unlinkSync(pidFile);
+      fs42.unlinkSync(pidFile);
     } catch {
     }
   } catch {
@@ -20233,24 +20361,93 @@ function isDaemonServiceInstalled() {
   if (process.platform === "linux") return isSystemdInstalled();
   return false;
 }
+function autostartRepairDecision(opts) {
+  if (!opts.autoStartDaemon) return "skip";
+  if (process.platform !== "linux" && process.platform !== "darwin") return "unsupported";
+  if (!opts.installed) return "skip";
+  return opts.enabled ? "ok" : "repair";
+}
+function enableDaemonServiceQuiet() {
+  try {
+    if (process.platform === "linux") {
+      const r = spawnSync2("systemctl", ["--user", "enable", "node9-daemon"], {
+        encoding: "utf8",
+        timeout: 3e3
+      });
+      return r.status === 0;
+    }
+    return process.platform === "darwin";
+  } catch {
+    return false;
+  }
+}
+function ensureAutostartHealthy(autoStartDaemon) {
+  const decision = autostartRepairDecision({
+    installed: isDaemonServiceInstalled(),
+    enabled: isDaemonServiceEnabled(),
+    autoStartDaemon
+  });
+  if (decision === "repair") return enableDaemonServiceQuiet() ? "repaired" : "skipped";
+  return decision === "ok" ? "ok" : decision === "unsupported" ? "unsupported" : "skipped";
+}
+function autostartAdvice(opts) {
+  const installable = process.platform === "linux" || process.platform === "darwin";
+  if (!opts.cloudEnabled || !installable) return null;
+  const installHint = process.platform === "linux" ? "Run: systemctl --user enable --now node9-daemon   (or: node9 daemon install)" : "Run: node9 daemon install";
+  if (opts.installed && !opts.enabled) {
+    return {
+      level: "warn",
+      message: "Daemon autostart is INSTALLED but DISABLED \u2014 it will NOT survive a reboot, so cloud policy can silently go stale.",
+      hint: installHint
+    };
+  }
+  if (!opts.installed) {
+    return {
+      level: "warn",
+      message: "No daemon autostart installed \u2014 the daemon only runs when an agent happens to spawn it; cloud policy may lag.",
+      hint: installHint
+    };
+  }
+  return null;
+}
+function isDaemonServiceEnabled() {
+  try {
+    if (process.platform === "linux") {
+      const r = spawnSync2("systemctl", ["--user", "is-enabled", "node9-daemon"], {
+        encoding: "utf8",
+        timeout: 3e3
+      });
+      return r.status === 0 && (r.stdout ?? "").trim() === "enabled";
+    }
+    if (process.platform === "darwin") {
+      const r = spawnSync2("launchctl", ["list", LAUNCHD_LABEL], {
+        encoding: "utf8",
+        timeout: 3e3
+      });
+      return r.status === 0;
+    }
+  } catch {
+  }
+  return false;
+}
 var LAUNCHD_LABEL, LAUNCHD_PLIST, SYSTEMD_UNIT_DIR, SYSTEMD_UNIT;
 var init_service = __esm({
   "src/daemon/service.ts"() {
     "use strict";
     LAUNCHD_LABEL = "ai.node9.daemon";
-    LAUNCHD_PLIST = path40.join(os38.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-    SYSTEMD_UNIT_DIR = path40.join(os38.homedir(), ".config", "systemd", "user");
-    SYSTEMD_UNIT = path40.join(SYSTEMD_UNIT_DIR, "node9-daemon.service");
+    LAUNCHD_PLIST = path41.join(os39.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+    SYSTEMD_UNIT_DIR = path41.join(os39.homedir(), ".config", "systemd", "user");
+    SYSTEMD_UNIT = path41.join(SYSTEMD_UNIT_DIR, "node9-daemon.service");
   }
 });
 // src/daemon/index.ts
-import fs42 from "fs";
+import fs43 from "fs";
 import chalk7 from "chalk";
 function stopDaemon() {
-  if (!fs42.existsSync(DAEMON_PID_FILE)) return console.log(chalk7.yellow("Not running."));
+  if (!fs43.existsSync(DAEMON_PID_FILE)) return console.log(chalk7.yellow("Not running."));
   try {
-    const data = JSON.parse(fs42.readFileSync(DAEMON_PID_FILE, "utf-8"));
+    const data = JSON.parse(fs43.readFileSync(DAEMON_PID_FILE, "utf-8"));
     const pid = data.pid;
     if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0 || pid > MAX_PID) {
       console.log(chalk7.gray("Cleaned up invalid PID file."));
@@ -20262,7 +20459,7 @@ function stopDaemon() {
     console.log(chalk7.gray("Cleaned up stale PID file."));
   } finally {
     try {
-      fs42.unlinkSync(DAEMON_PID_FILE);
+      fs43.unlinkSync(DAEMON_PID_FILE);
     } catch {
     }
   }
@@ -20271,9 +20468,9 @@ function daemonStatus() {
   const serviceInstalled = isDaemonServiceInstalled();
   const serviceLabel = serviceInstalled ? chalk7.green("installed (starts on login)") : chalk7.yellow("not installed \u2014 run: node9 daemon install");
   let processStatus;
-  if (fs42.existsSync(DAEMON_PID_FILE)) {
+  if (fs43.existsSync(DAEMON_PID_FILE)) {
     try {
-      const data = JSON.parse(fs42.readFileSync(DAEMON_PID_FILE, "utf-8"));
+      const data = JSON.parse(fs43.readFileSync(DAEMON_PID_FILE, "utf-8"));
       const pid = data.pid;
       const port = data.port;
       if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0 || pid > MAX_PID) {
@@ -21416,14 +21613,14 @@ var require_util = __commonJS({
         }
         const port = url.port != null ? url.port : url.protocol === "https:" ? 443 : 80;
         let origin = url.origin != null ? url.origin : `${url.protocol || ""}//${url.hostname || ""}:${port}`;
-        let path70 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
+        let path71 = url.path != null ? url.path : `${url.pathname || ""}${url.search || ""}`;
         if (origin[origin.length - 1] === "/") {
           origin = origin.slice(0, origin.length - 1);
         }
-        if (path70 && path70[0] !== "/") {
-          path70 = `/${path70}`;
+        if (path71 && path71[0] !== "/") {
+          path71 = `/${path71}`;
         }
-        return new URL(`${origin}${path70}`);
+        return new URL(`${origin}${path71}`);
       }
       if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
         throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
@@ -22244,9 +22441,9 @@ var require_diagnostics = __commonJS({
         "undici:client:sendHeaders",
         (evt) => {
           const {
-            request: { method, path: path70, origin }
+            request: { method, path: path71, origin }
           } = evt;
-          debugLog("sending request to %s %s%s", method, origin, path70);
+          debugLog("sending request to %s %s%s", method, origin, path71);
         }
       );
     }
@@ -22264,14 +22461,14 @@ var require_diagnostics = __commonJS({
         "undici:request:headers",
         (evt) => {
           const {
-            request: { method, path: path70, origin },
+            request: { method, path: path71, origin },
             response: { statusCode }
           } = evt;
           debugLog(
             "received response to %s %s%s - HTTP %d",
             method,
             origin,
-            path70,
+            path71,
             statusCode
           );
         }
@@ -22280,23 +22477,23 @@ var require_diagnostics = __commonJS({
         "undici:request:trailers",
         (evt) => {
           const {
-            request: { method, path: path70, origin }
+            request: { method, path: path71, origin }
           } = evt;
-          debugLog("trailers received from %s %s%s", method, origin, path70);
+          debugLog("trailers received from %s %s%s", method, origin, path71);
         }
       );
       diagnosticsChannel.subscribe(
         "undici:request:error",
         (evt) => {
           const {
-            request: { method, path: path70, origin },
+            request: { method, path: path71, origin },
             error
           } = evt;
           debugLog(
             "request to %s %s%s errored - %s",
             method,
             origin,
-            path70,
+            path71,
             error.message
           );
         }
@@ -22399,7 +22596,7 @@ var require_request = __commonJS({
     var kHandler = /* @__PURE__ */ Symbol("handler");
     var Request = class {
       constructor(origin, {
-        path: path70,
+        path: path71,
         method,
         body,
         headers,
@@ -22416,11 +22613,11 @@ var require_request = __commonJS({
         maxRedirections,
         typeOfService
       }, handler) {
-        if (typeof path70 !== "string") {
+        if (typeof path71 !== "string") {
           throw new InvalidArgumentError("path must be a string");
-        } else if (path70[0] !== "/" && !(path70.startsWith("http://") || path70.startsWith("https://")) && method !== "CONNECT") {
+        } else if (path71[0] !== "/" && !(path71.startsWith("http://") || path71.startsWith("https://")) && method !== "CONNECT") {
           throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
-        } else if (invalidPathRegex.test(path70)) {
+        } else if (invalidPathRegex.test(path71)) {
           throw new InvalidArgumentError("invalid request path");
         }
         if (typeof method !== "string") {
@@ -22495,7 +22692,7 @@ var require_request = __commonJS({
         this.completed = false;
         this.aborted = false;
         this.upgrade = upgrade || null;
-        this.path = query ? serializePathWithQuery(path70, query) : path70;
+        this.path = query ? serializePathWithQuery(path71, query) : path71;
         this.origin = origin;
         this.protocol = getProtocolFromUrlString(origin);
         this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
@@ -27534,7 +27731,7 @@ var require_client_h1 = __commonJS({
       return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
     }
     function writeH1(client, request2) {
-      const { method, path: path70, host, upgrade, blocking, reset } = request2;
+      const { method, path: path71, host, upgrade, blocking, reset } = request2;
       let { body, headers, contentLength } = request2;
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
       if (util.isFormDataLike(body)) {
@@ -27603,7 +27800,7 @@ var require_client_h1 = __commonJS({
       if (socket.setTypeOfService) {
         socket.setTypeOfService(request2.typeOfService);
       }
-      let header = `${method} ${path70} HTTP/1.1\r
+      let header = `${method} ${path71} HTTP/1.1\r
 `;
       if (typeof host === "string") {
         header += `host: ${host}\r
@@ -28256,7 +28453,7 @@ var require_client_h2 = __commonJS({
     function writeH2(client, request2) {
       const requestTimeout = request2.bodyTimeout ?? client[kBodyTimeout];
       const session = client[kHTTP2Session];
-      const { method, path: path70, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request2;
+      const { method, path: path71, host, upgrade, expectContinue, signal, protocol, headers: reqHeaders } = request2;
       let { body } = request2;
       if (upgrade != null && upgrade !== "websocket") {
         util.errorRequest(client, request2, new InvalidArgumentError(`Custom upgrade "${upgrade}" not supported over HTTP/2`));
@@ -28324,7 +28521,7 @@ var require_client_h2 = __commonJS({
           }
           headers[HTTP2_HEADER_METHOD] = "CONNECT";
           headers[HTTP2_HEADER_PROTOCOL] = "websocket";
-          headers[HTTP2_HEADER_PATH] = path70;
+          headers[HTTP2_HEADER_PATH] = path71;
           if (protocol === "ws:" || protocol === "wss:") {
             headers[HTTP2_HEADER_SCHEME] = protocol === "ws:" ? "http" : "https";
           } else {
@@ -28365,7 +28562,7 @@ var require_client_h2 = __commonJS({
         stream.setTimeout(requestTimeout);
         return true;
       }
-      headers[HTTP2_HEADER_PATH] = path70;
+      headers[HTTP2_HEADER_PATH] = path71;
       headers[HTTP2_HEADER_SCHEME] = protocol === "http:" ? "http" : "https";
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
       if (body && typeof body.read === "function") {
@@ -30667,10 +30864,10 @@ var require_proxy_agent = __commonJS({
         };
         const {
           origin,
-          path: path70 = "/",
+          path: path71 = "/",
           headers = {}
         } = opts;
-        opts.path = origin + path70;
+        opts.path = origin + path71;
         if (!("host" in headers) && !("Host" in headers)) {
           const { host } = new URL(origin);
           headers.host = host;
@@ -32733,20 +32930,20 @@ var require_mock_utils = __commonJS({
       }
       return normalizedQp;
     }
-    function safeUrl(path70) {
-      if (typeof path70 !== "string") {
-        return path70;
+    function safeUrl(path71) {
+      if (typeof path71 !== "string") {
+        return path71;
       }
-      const pathSegments = path70.split("?", 3);
+      const pathSegments = path71.split("?", 3);
       if (pathSegments.length !== 2) {
-        return path70;
+        return path71;
       }
       const qp = new URLSearchParams(pathSegments.pop());
       qp.sort();
       return [...pathSegments, qp.toString()].join("?");
     }
-    function matchKey(mockDispatch2, { path: path70, method, body, headers }) {
-      const pathMatch = matchValue(mockDispatch2.path, path70);
+    function matchKey(mockDispatch2, { path: path71, method, body, headers }) {
+      const pathMatch = matchValue(mockDispatch2.path, path71);
       const methodMatch = matchValue(mockDispatch2.method, method);
       const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
       const headersMatch = matchHeaders(mockDispatch2, headers);
@@ -32771,8 +32968,8 @@ var require_mock_utils = __commonJS({
       const basePath = key.query ? serializePathWithQuery(key.path, key.query) : key.path;
       const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
       const resolvedPathWithoutTrailingSlash = removeTrailingSlash(resolvedPath);
-      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path70, ignoreTrailingSlash }) => {
-        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path70)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path70), resolvedPath);
+      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path71, ignoreTrailingSlash }) => {
+        return ignoreTrailingSlash ? matchValue(removeTrailingSlash(safeUrl(path71)), resolvedPathWithoutTrailingSlash) : matchValue(safeUrl(path71), resolvedPath);
       });
       if (matchedMockDispatches.length === 0) {
         throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
@@ -32811,19 +33008,19 @@ var require_mock_utils = __commonJS({
         mockDispatches.splice(index, 1);
       }
     }
-    function removeTrailingSlash(path70) {
-      while (path70.endsWith("/")) {
-        path70 = path70.slice(0, -1);
+    function removeTrailingSlash(path71) {
+      while (path71.endsWith("/")) {
+        path71 = path71.slice(0, -1);
       }
-      if (path70.length === 0) {
-        path70 = "/";
+      if (path71.length === 0) {
+        path71 = "/";
       }
-      return path70;
+      return path71;
     }
     function buildKey(opts) {
-      const { path: path70, method, body, headers, query } = opts;
+      const { path: path71, method, body, headers, query } = opts;
       return {
-        path: path70,
+        path: path71,
         method,
         body,
         headers,
@@ -33513,10 +33710,10 @@ var require_pending_interceptors_formatter = __commonJS({
       }
       format(pendingInterceptors) {
         const withPrettyHeaders = pendingInterceptors.map(
-          ({ method, path: path70, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
+          ({ method, path: path71, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
             Method: method,
             Origin: origin,
-            Path: path70,
+            Path: path71,
             "Status code": statusCode,
             Persistent: persist ? PERSISTENT : NOT_PERSISTENT,
             Invocations: timesInvoked,
@@ -33598,9 +33795,9 @@ var require_mock_agent = __commonJS({
         const acceptNonStandardSearchParameters = this[kMockAgentAcceptsNonStandardSearchParameters];
         const dispatchOpts = { ...opts };
         if (acceptNonStandardSearchParameters && dispatchOpts.path) {
-          const [path70, searchParams] = dispatchOpts.path.split("?");
+          const [path71, searchParams] = dispatchOpts.path.split("?");
           const normalizedSearchParams = normalizeSearchParams(searchParams, acceptNonStandardSearchParameters);
-          dispatchOpts.path = `${path70}?${normalizedSearchParams}`;
+          dispatchOpts.path = `${path71}?${normalizedSearchParams}`;
         }
         return this[kAgent].dispatch(dispatchOpts, handler);
       }
@@ -34001,12 +34198,12 @@ var require_snapshot_recorder = __commonJS({
        * @return {Promise<void>} - Resolves when snapshots are loaded
        */
       async loadSnapshots(filePath) {
-        const path70 = filePath || this.#snapshotPath;
-        if (!path70) {
+        const path71 = filePath || this.#snapshotPath;
+        if (!path71) {
           throw new InvalidArgumentError("Snapshot path is required");
         }
         try {
-          const data = await readFile(resolve2(path70), "utf8");
+          const data = await readFile(resolve2(path71), "utf8");
           const parsed = JSON.parse(data);
           if (Array.isArray(parsed)) {
             this.#snapshots.clear();
@@ -34020,7 +34217,7 @@ var require_snapshot_recorder = __commonJS({
           if (error.code === "ENOENT") {
             this.#snapshots.clear();
           } else {
-            throw new UndiciError(`Failed to load snapshots from ${path70}`, { cause: error });
+            throw new UndiciError(`Failed to load snapshots from ${path71}`, { cause: error });
           }
         }
       }
@@ -34031,11 +34228,11 @@ var require_snapshot_recorder = __commonJS({
        * @returns {Promise<void>} - Resolves when snapshots are saved
        */
       async saveSnapshots(filePath) {
-        const path70 = filePath || this.#snapshotPath;
-        if (!path70) {
+        const path71 = filePath || this.#snapshotPath;
+        if (!path71) {
           throw new InvalidArgumentError("Snapshot path is required");
         }
-        const resolvedPath = resolve2(path70);
+        const resolvedPath = resolve2(path71);
         await mkdir(dirname2(resolvedPath), { recursive: true });
         const data = Array.from(this.#snapshots.entries()).map(([hash, snapshot]) => ({
           hash,
@@ -34660,15 +34857,15 @@ var require_redirect_handler = __commonJS({
           return;
         }
         const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
-        const path70 = search ? `${pathname}${search}` : pathname;
-        const redirectUrlString = `${origin}${path70}`;
+        const path71 = search ? `${pathname}${search}` : pathname;
+        const redirectUrlString = `${origin}${path71}`;
         for (const historyUrl of this.history) {
           if (historyUrl.toString() === redirectUrlString) {
             throw new InvalidArgumentError(`Redirect loop detected. Cannot redirect to ${origin}. This typically happens when using a Client or Pool with cross-origin redirects. Use an Agent for cross-origin redirects.`);
           }
         }
         this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
-        this.opts.path = path70;
+        this.opts.path = path71;
         this.opts.origin = origin;
         this.opts.query = null;
       }
@@ -40875,11 +41072,11 @@ var require_fetch = __commonJS({
       function dispatch({ body }) {
         const url = requestCurrentURL(request2);
         const agent = fetchParams.controller.dispatcher;
-        const path70 = url.pathname + url.search;
+        const path71 = url.pathname + url.search;
         const hasTrailingQuestionMark = url.search.length === 0 && url.href[url.href.length - url.hash.length - 1] === "?";
         return new Promise((resolve2, reject) => agent.dispatch(
           {
-            path: hasTrailingQuestionMark ? `${path70}?` : path70,
+            path: hasTrailingQuestionMark ? `${path71}?` : path71,
             origin: url.origin,
             method: request2.method,
             body: agent.isMockActive ? request2.body && (request2.body.source || request2.body.stream) : body,
@@ -41810,9 +42007,9 @@ var require_util4 = __commonJS({
         }
       }
     }
-    function validateCookiePath(path70) {
-      for (let i = 0; i < path70.length; ++i) {
-        const code = path70.charCodeAt(i);
+    function validateCookiePath(path71) {
+      for (let i = 0; i < path71.length; ++i) {
+        const code = path71.charCodeAt(i);
         if (code < 32 || // exclude CTLs (0-31)
         code === 127 || // DEL
         code === 59) {
@@ -44982,11 +45179,11 @@ var require_undici = __commonJS({
           if (typeof opts.path !== "string") {
             throw new InvalidArgumentError("invalid opts.path");
           }
-          let path70 = opts.path;
+          let path71 = opts.path;
           if (!opts.path.startsWith("/")) {
-            path70 = `/${path70}`;
+            path71 = `/${path71}`;
           }
-          url = new URL(util.parseOrigin(url).origin + path70);
+          url = new URL(util.parseOrigin(url).origin + path71);
         } else {
           if (!opts) {
             opts = typeof url === "object" ? url : {};
@@ -45105,9 +45302,9 @@ __export(tail_exports, {
 });
 import http5 from "http";
 import chalk40 from "chalk";
-import fs70 from "fs";
-import os59 from "os";
-import path67 from "path";
+import fs71 from "fs";
+import os61 from "os";
+import path68 from "path";
 import readline6 from "readline";
 import { spawn as spawn8 } from "child_process";
 function shortenPathSummary(s) {
@@ -45131,20 +45328,20 @@ function getModelContextLimit(model) {
   return 2e5;
 }
 function readSessionUsage() {
-  const projectsDir = path67.join(os59.homedir(), ".claude", "projects");
-  if (!fs70.existsSync(projectsDir)) return null;
+  const projectsDir = path68.join(os61.homedir(), ".claude", "projects");
+  if (!fs71.existsSync(projectsDir)) return null;
   let latestFile = null;
   let latestMtime = 0;
   try {
-    for (const dir of fs70.readdirSync(projectsDir)) {
-      const dirPath = path67.join(projectsDir, dir);
+    for (const dir of fs71.readdirSync(projectsDir)) {
+      const dirPath = path68.join(projectsDir, dir);
       try {
-        if (!fs70.statSync(dirPath).isDirectory()) continue;
-        for (const file of fs70.readdirSync(dirPath)) {
+        if (!fs71.statSync(dirPath).isDirectory()) continue;
+        for (const file of fs71.readdirSync(dirPath)) {
           if (!file.endsWith(".jsonl") || file.startsWith("agent-")) continue;
-          const filePath = path67.join(dirPath, file);
+          const filePath = path68.join(dirPath, file);
           try {
-            const mtime = fs70.statSync(filePath).mtimeMs;
+            const mtime = fs71.statSync(filePath).mtimeMs;
             if (mtime > latestMtime) {
               latestMtime = mtime;
               latestFile = filePath;
@@ -45159,7 +45356,7 @@ function readSessionUsage() {
   }
   if (!latestFile) return null;
   try {
-    const lines = fs70.readFileSync(latestFile, "utf-8").split("\n");
+    const lines = fs71.readFileSync(latestFile, "utf-8").split("\n");
     let lastModel = "";
     let lastInput = 0;
     let lastOutput = 0;
@@ -45220,7 +45417,7 @@ function formatBase(activity) {
   const time = new Date(activity.ts).toLocaleTimeString([], { hour12: false });
   const icon = getIcon(activity.tool);
   const toolName = activity.tool.slice(0, 16).padEnd(16);
-  const argsStr = JSON.stringify(activity.args ?? {}).replace(/\s+/g, " ").replaceAll(os59.homedir(), "~");
+  const argsStr = JSON.stringify(activity.args ?? {}).replace(/\s+/g, " ").replaceAll(os61.homedir(), "~");
   const argsPreview = argsStr.length > 70 ? argsStr.slice(0, 70) + "\u2026" : argsStr;
   return `${chalk40.gray(time)} ${icon} ${agentLabel(activity.agent, activity.mcpServer, activity.sessionId)}${chalk40.white.bold(toolName)} ${chalk40.dim(argsPreview)}`;
 }
@@ -45259,9 +45456,9 @@ function renderPending(activity) {
 }
 async function ensureDaemon() {
   let pidPort = null;
-  if (fs70.existsSync(PID_FILE)) {
+  if (fs71.existsSync(PID_FILE)) {
     try {
-      const { port } = JSON.parse(fs70.readFileSync(PID_FILE, "utf-8"));
+      const { port } = JSON.parse(fs71.readFileSync(PID_FILE, "utf-8"));
       pidPort = port;
     } catch {
       console.error(chalk40.dim("\u26A0\uFE0F  Could not read PID file; falling back to default port."));
@@ -45417,9 +45614,9 @@ function buildRecoveryCardLines(req) {
   ];
 }
 function readApproversFromDisk() {
-  const configPath = path67.join(os59.homedir(), ".node9", "config.json");
+  const configPath = path68.join(os61.homedir(), ".node9", "config.json");
   try {
-    const raw = JSON.parse(fs70.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs71.readFileSync(configPath, "utf-8"));
     const settings = raw.settings ?? {};
     return settings.approvers ?? {};
   } catch {
@@ -45435,15 +45632,15 @@ function approverStatusLine() {
   return `${fmt("native", "native")}  ${fmt("cloud", "cloud")}  ${fmt("terminal", "terminal")}`;
 }
 function toggleApprover(channel) {
-  const configPath = path67.join(os59.homedir(), ".node9", "config.json");
+  const configPath = path68.join(os61.homedir(), ".node9", "config.json");
   try {
-    const raw = JSON.parse(fs70.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs71.readFileSync(configPath, "utf-8"));
     const settings = raw.settings ?? {};
     const approvers = settings.approvers ?? {};
     approvers[channel] = approvers[channel] === false;
     settings.approvers = approvers;
     raw.settings = settings;
-    fs70.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+    fs71.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
   } catch (err2) {
     process.stderr.write(`[node9] toggleApprover failed: ${String(err2)}
 `);
@@ -45615,8 +45812,8 @@ async function startTail(options = {}) {
       }
       postDecisionHttp(req2.id, httpDecision, authToken, port, httpOpts).catch((err2) => {
         try {
-          fs70.appendFileSync(
-            path67.join(os59.homedir(), ".node9", "hook-debug.log"),
+          fs71.appendFileSync(
+            path68.join(os61.homedir(), ".node9", "hook-debug.log"),
             `[tail] POST /decision failed: ${String(err2)}
 `
           );
@@ -45680,9 +45877,9 @@ async function startTail(options = {}) {
     };
     process.stdin.on("keypress", onKeypress);
   }
-  const auditLog = path67.join(os59.homedir(), ".node9", "audit.log");
+  const auditLog = path68.join(os61.homedir(), ".node9", "audit.log");
   try {
-    const unackedDlp = fs70.readFileSync(auditLog, "utf-8").split("\n").filter((l) => l.includes('"response-dlp"')).length;
+    const unackedDlp = fs71.readFileSync(auditLog, "utf-8").split("\n").filter((l) => l.includes('"response-dlp"')).length;
     if (unackedDlp > 0) {
       console.log("");
       console.log(
@@ -45722,7 +45919,7 @@ async function startTail(options = {}) {
     if (stallWarned) return;
     if (Date.now() - lastActivityFromDaemon < STALL_THRESHOLD_MS) return;
     try {
-      const auditMtime = fs70.statSync(auditLog).mtimeMs;
+      const auditMtime = fs71.statSync(auditLog).mtimeMs;
       if (Date.now() - auditMtime >= STALL_THRESHOLD_MS) return;
       console.log("");
       console.log(
@@ -45913,7 +46110,7 @@ var init_tail = __esm({
     "use strict";
     init_daemon2();
     init_daemon();
-    PID_FILE = path67.join(os59.homedir(), ".node9", "daemon.pid");
+    PID_FILE = path68.join(os61.homedir(), ".node9", "daemon.pid");
     ICONS = {
       bash: "\u{1F4BB}",
       shell: "\u{1F4BB}",
@@ -45961,9 +46158,9 @@ __export(hud_exports, {
   main: () => main,
   renderEnvironmentLine: () => renderEnvironmentLine
 });
-import fs71 from "fs";
-import path68 from "path";
-import os60 from "os";
+import fs72 from "fs";
+import path69 from "path";
+import os62 from "os";
 import http6 from "http";
 async function readStdin() {
   const chunks = [];
@@ -46039,9 +46236,9 @@ function formatTimeLeft(resetsAt) {
   return ` (${m}m left)`;
 }
 function safeReadJson(filePath) {
-  if (!fs71.existsSync(filePath)) return null;
+  if (!fs72.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs71.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs72.readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -46062,12 +46259,12 @@ function countHooksInFile(filePath) {
   return Object.keys(cfg.hooks).length;
 }
 function countRulesInDir(rulesDir) {
-  if (!fs71.existsSync(rulesDir)) return 0;
+  if (!fs72.existsSync(rulesDir)) return 0;
   let count = 0;
   try {
-    for (const entry of fs71.readdirSync(rulesDir, { withFileTypes: true })) {
+    for (const entry of fs72.readdirSync(rulesDir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
-        count += countRulesInDir(path68.join(rulesDir, entry.name));
+        count += countRulesInDir(path69.join(rulesDir, entry.name));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
         count++;
       }
@@ -46078,46 +46275,46 @@ function countRulesInDir(rulesDir) {
 }
 function isSamePath(a, b) {
   try {
-    return path68.resolve(a) === path68.resolve(b);
+    return path69.resolve(a) === path69.resolve(b);
   } catch {
     return false;
   }
 }
 function countConfigs(cwd) {
-  const homeDir2 = os60.homedir();
-  const claudeDir = path68.join(homeDir2, ".claude");
+  const homeDir2 = os62.homedir();
+  const claudeDir = path69.join(homeDir2, ".claude");
   let claudeMdCount = 0;
   let rulesCount = 0;
   let hooksCount = 0;
   const userMcpServers = /* @__PURE__ */ new Set();
   const projectMcpServers = /* @__PURE__ */ new Set();
-  if (fs71.existsSync(path68.join(claudeDir, "CLAUDE.md"))) claudeMdCount++;
-  rulesCount += countRulesInDir(path68.join(claudeDir, "rules"));
-  const userSettings = path68.join(claudeDir, "settings.json");
+  if (fs72.existsSync(path69.join(claudeDir, "CLAUDE.md"))) claudeMdCount++;
+  rulesCount += countRulesInDir(path69.join(claudeDir, "rules"));
+  const userSettings = path69.join(claudeDir, "settings.json");
   for (const name of getMcpServerNames(userSettings)) userMcpServers.add(name);
   hooksCount += countHooksInFile(userSettings);
-  const userClaudeJson = path68.join(homeDir2, ".claude.json");
+  const userClaudeJson = path69.join(homeDir2, ".claude.json");
   for (const name of getMcpServerNames(userClaudeJson)) userMcpServers.add(name);
   for (const name of getDisabledMcpServers(userClaudeJson, "disabledMcpServers")) {
     userMcpServers.delete(name);
   }
   if (cwd) {
-    if (fs71.existsSync(path68.join(cwd, "CLAUDE.md"))) claudeMdCount++;
-    if (fs71.existsSync(path68.join(cwd, "CLAUDE.local.md"))) claudeMdCount++;
-    const projectClaudeDir = path68.join(cwd, ".claude");
+    if (fs72.existsSync(path69.join(cwd, "CLAUDE.md"))) claudeMdCount++;
+    if (fs72.existsSync(path69.join(cwd, "CLAUDE.local.md"))) claudeMdCount++;
+    const projectClaudeDir = path69.join(cwd, ".claude");
     const overlapsUserScope = isSamePath(projectClaudeDir, claudeDir);
     if (!overlapsUserScope) {
-      if (fs71.existsSync(path68.join(projectClaudeDir, "CLAUDE.md"))) claudeMdCount++;
-      rulesCount += countRulesInDir(path68.join(projectClaudeDir, "rules"));
-      const projSettings = path68.join(projectClaudeDir, "settings.json");
+      if (fs72.existsSync(path69.join(projectClaudeDir, "CLAUDE.md"))) claudeMdCount++;
+      rulesCount += countRulesInDir(path69.join(projectClaudeDir, "rules"));
+      const projSettings = path69.join(projectClaudeDir, "settings.json");
       for (const name of getMcpServerNames(projSettings)) projectMcpServers.add(name);
       hooksCount += countHooksInFile(projSettings);
     }
-    if (fs71.existsSync(path68.join(projectClaudeDir, "CLAUDE.local.md"))) claudeMdCount++;
-    const localSettings = path68.join(projectClaudeDir, "settings.local.json");
+    if (fs72.existsSync(path69.join(projectClaudeDir, "CLAUDE.local.md"))) claudeMdCount++;
+    const localSettings = path69.join(projectClaudeDir, "settings.local.json");
     for (const name of getMcpServerNames(localSettings)) projectMcpServers.add(name);
     hooksCount += countHooksInFile(localSettings);
-    const mcpJsonServers = getMcpServerNames(path68.join(cwd, ".mcp.json"));
+    const mcpJsonServers = getMcpServerNames(path69.join(cwd, ".mcp.json"));
     const disabledMcpJson = getDisabledMcpServers(localSettings, "disabledMcpjsonServers");
     for (const name of disabledMcpJson) mcpJsonServers.delete(name);
     for (const name of mcpJsonServers) projectMcpServers.add(name);
@@ -46150,12 +46347,12 @@ function readActiveShieldsHud() {
     return shieldsCache.value;
   }
   try {
-    const shieldsPath = path68.join(os60.homedir(), ".node9", "shields.json");
-    if (!fs71.existsSync(shieldsPath)) {
+    const shieldsPath = path69.join(os62.homedir(), ".node9", "shields.json");
+    if (!fs72.existsSync(shieldsPath)) {
       shieldsCache = { value: [], ts: now };
       return [];
     }
-    const parsed = JSON.parse(fs71.readFileSync(shieldsPath, "utf-8"));
+    const parsed = JSON.parse(fs72.readFileSync(shieldsPath, "utf-8"));
     if (!Array.isArray(parsed.active)) {
       shieldsCache = { value: [], ts: now };
       return [];
@@ -46257,17 +46454,17 @@ function renderContextLine(stdin) {
 async function main() {
   try {
     const [stdin, daemonStatus2] = await Promise.all([readStdin(), queryDaemon()]);
-    if (fs71.existsSync(path68.join(os60.homedir(), ".node9", "hud-debug"))) {
+    if (fs72.existsSync(path69.join(os62.homedir(), ".node9", "hud-debug"))) {
       try {
-        const logPath = path68.join(os60.homedir(), ".node9", "hud-debug.log");
+        const logPath = path69.join(os62.homedir(), ".node9", "hud-debug.log");
         const MAX_LOG_SIZE = 10 * 1024 * 1024;
         let size = 0;
         try {
-          size = fs71.statSync(logPath).size;
+          size = fs72.statSync(logPath).size;
         } catch {
         }
         if (size < MAX_LOG_SIZE) {
-          fs71.appendFileSync(
+          fs72.appendFileSync(
             logPath,
             JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), stdin }) + "\n"
           );
@@ -46288,11 +46485,11 @@ async function main() {
       try {
         const cwd = stdin.cwd ?? process.cwd();
         for (const configPath of [
-          path68.join(cwd, "node9.config.json"),
-          path68.join(os60.homedir(), ".node9", "config.json")
+          path69.join(cwd, "node9.config.json"),
+          path69.join(os62.homedir(), ".node9", "config.json")
         ]) {
-          if (!fs71.existsSync(configPath)) continue;
-          const cfg = JSON.parse(fs71.readFileSync(configPath, "utf-8"));
+          if (!fs72.existsSync(configPath)) continue;
+          const cfg = JSON.parse(fs72.readFileSync(configPath, "utf-8"));
           const hud = cfg.settings?.hud;
           if (hud && "showEnvironmentCounts" in hud) return hud.showEnvironmentCounts !== false;
         }
@@ -46434,9 +46631,9 @@ function writeCredentialsAndConfig(apiKey, opts = {}) {
 // src/cli.ts
 init_daemon2();
 import chalk41 from "chalk";
-import fs72 from "fs";
-import path69 from "path";
-import os61 from "os";
+import fs73 from "fs";
+import path70 from "path";
+import os63 from "os";
 import { spawn as spawn9 } from "child_process";
 import { confirm as confirm2 } from "@inquirer/prompts";
@@ -46623,26 +46820,48 @@ async function runProxy(targetCommand) {
 // src/cli/daemon-starter.ts
 init_daemon();
+init_startup_log();
 import { spawn as spawn3 } from "child_process";
-import path41 from "path";
-import fs43 from "fs";
+import path42 from "path";
+import fs44 from "fs";
+import os40 from "os";
 function isTestingMode() {
   return /^(1|true|yes)$/i.test(process.env.NODE9_TESTING ?? "");
 }
+var SKIP_STAMP = () => path42.join(os40.homedir(), ".node9", ".autostart-skip-stamp");
+var SKIP_THROTTLE_MS = 60 * 60 * 1e3;
+function logAutostartSkipThrottled(reason) {
+  try {
+    const stamp = SKIP_STAMP();
+    try {
+      if (Date.now() - fs44.statSync(stamp).mtimeMs < SKIP_THROTTLE_MS) return;
+    } catch {
+    }
+    fs44.writeFileSync(stamp, "", "utf-8");
+    fs44.appendFileSync(
+      path42.join(os40.homedir(), ".node9", "hook-debug.log"),
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon-autostart-skip: ${reason}
+`,
+      "utf-8"
+    );
+  } catch {
+  }
+}
 async function autoStartDaemonAndWait() {
   if (isTestingMode()) return false;
-  if (!path41.isAbsolute(process.argv[1])) return false;
+  if (!path42.isAbsolute(process.argv[1])) return false;
   let resolvedArgv1;
   try {
-    resolvedArgv1 = fs43.realpathSync(process.argv[1]);
+    resolvedArgv1 = fs44.realpathSync(process.argv[1]);
   } catch {
     return false;
   }
   if (!resolvedArgv1.endsWith(".js")) return false;
+  const startupFd = openStartupLogFd();
   try {
     const child = spawn3(process.execPath, [resolvedArgv1, "daemon"], {
       detached: true,
-      stdio: "ignore",
+      stdio: ["ignore", "ignore", startupFd ?? "ignore"],
       env: {
         ...process.env,
         NODE9_AUTO_STARTED: "1"
@@ -46655,30 +46874,41 @@ async function autoStartDaemonAndWait() {
       if (await isDaemonReachable()) return true;
     }
   } catch {
+  } finally {
+    if (startupFd !== void 0) {
+      try {
+        fs44.closeSync(startupFd);
+      } catch {
+      }
+    }
   }
   return false;
 }
+// src/cli.ts
+init_service();
 // src/cli/commands/check.ts
 init_orchestrator();
 init_state();
 init_daemon();
+init_startup_log();
 init_config();
 init_policy();
 import chalk9 from "chalk";
-import fs47 from "fs";
+import fs48 from "fs";
 import { spawn as spawn5 } from "child_process";
-import path45 from "path";
-import os42 from "os";
+import path46 from "path";
+import os44 from "os";
 // src/undo.ts
 import { spawnSync as spawnSync3, spawn as spawn4 } from "child_process";
 import crypto7 from "crypto";
-import fs44 from "fs";
+import fs45 from "fs";
 import net3 from "net";
-import path42 from "path";
-import os39 from "os";
-var ACTIVITY_SOCKET_PATH3 = process.platform === "win32" ? "\\\\.\\pipe\\node9-activity" : path42.join(os39.tmpdir(), "node9-activity.sock");
+import path43 from "path";
+import os41 from "os";
+var ACTIVITY_SOCKET_PATH3 = process.platform === "win32" ? "\\\\.\\pipe\\node9-activity" : path43.join(os41.tmpdir(), "node9-activity.sock");
 function notifySnapshotTaken(hash, tool, argsSummary, fileCount) {
   try {
     const payload = JSON.stringify({
@@ -46698,22 +46928,22 @@ function notifySnapshotTaken(hash, tool, argsSummary, fileCount) {
   } catch {
   }
 }
-var SNAPSHOT_STACK_PATH = path42.join(os39.homedir(), ".node9", "snapshots.json");
-var UNDO_LATEST_PATH = path42.join(os39.homedir(), ".node9", "undo_latest.txt");
+var SNAPSHOT_STACK_PATH = path43.join(os41.homedir(), ".node9", "snapshots.json");
+var UNDO_LATEST_PATH = path43.join(os41.homedir(), ".node9", "undo_latest.txt");
 var MAX_SNAPSHOTS = 10;
 var GIT_TIMEOUT = 15e3;
 function readStack() {
   try {
-    if (fs44.existsSync(SNAPSHOT_STACK_PATH))
-      return JSON.parse(fs44.readFileSync(SNAPSHOT_STACK_PATH, "utf-8"));
+    if (fs45.existsSync(SNAPSHOT_STACK_PATH))
+      return JSON.parse(fs45.readFileSync(SNAPSHOT_STACK_PATH, "utf-8"));
   } catch {
   }
   return [];
 }
 function writeStack(stack) {
-  const dir = path42.dirname(SNAPSHOT_STACK_PATH);
-  if (!fs44.existsSync(dir)) fs44.mkdirSync(dir, { recursive: true });
-  fs44.writeFileSync(SNAPSHOT_STACK_PATH, JSON.stringify(stack, null, 2));
+  const dir = path43.dirname(SNAPSHOT_STACK_PATH);
+  if (!fs45.existsSync(dir)) fs45.mkdirSync(dir, { recursive: true });
+  fs45.writeFileSync(SNAPSHOT_STACK_PATH, JSON.stringify(stack, null, 2));
 }
 function extractFilePath(args) {
   if (!args || typeof args !== "object") return null;
@@ -46733,12 +46963,12 @@ function buildArgsSummary(tool, args) {
   return "";
 }
 function findProjectRoot(filePath) {
-  let dir = path42.dirname(filePath);
+  let dir = path43.dirname(filePath);
   while (true) {
-    if (fs44.existsSync(path42.join(dir, ".git")) || fs44.existsSync(path42.join(dir, "package.json"))) {
+    if (fs45.existsSync(path43.join(dir, ".git")) || fs45.existsSync(path43.join(dir, "package.json"))) {
       return dir;
     }
-    const parent = path42.dirname(dir);
+    const parent = path43.dirname(dir);
     if (parent === dir) return process.cwd();
     dir = parent;
   }
@@ -46746,7 +46976,7 @@ function findProjectRoot(filePath) {
 function normalizeCwdForHash(cwd) {
   let normalized;
   try {
-    normalized = fs44.realpathSync(cwd);
+    normalized = fs45.realpathSync(cwd);
   } catch {
     normalized = cwd;
   }
@@ -46756,16 +46986,16 @@ function normalizeCwdForHash(cwd) {
 }
 function getShadowRepoDir(cwd) {
   const hash = crypto7.createHash("sha256").update(normalizeCwdForHash(cwd)).digest("hex").slice(0, 16);
-  return path42.join(os39.homedir(), ".node9", "snapshots", hash);
+  return path43.join(os41.homedir(), ".node9", "snapshots", hash);
 }
 function cleanOrphanedIndexFiles(shadowDir) {
   try {
     const cutoff = Date.now() - 6e4;
-    for (const f of fs44.readdirSync(shadowDir)) {
+    for (const f of fs45.readdirSync(shadowDir)) {
       if (f.startsWith("index_")) {
-        const fp = path42.join(shadowDir, f);
+        const fp = path43.join(shadowDir, f);
         try {
-          if (fs44.statSync(fp).mtimeMs < cutoff) fs44.unlinkSync(fp);
+          if (fs45.statSync(fp).mtimeMs < cutoff) fs45.unlinkSync(fp);
         } catch {
         }
       }
@@ -46777,7 +47007,7 @@ function writeShadowExcludes(shadowDir, ignorePaths) {
   const hardcoded = [".git", ".node9"];
   const lines = [...hardcoded, ...ignorePaths].join("\n");
   try {
-    fs44.writeFileSync(path42.join(shadowDir, "info", "exclude"), lines + "\n", "utf8");
+    fs45.writeFileSync(path43.join(shadowDir, "info", "exclude"), lines + "\n", "utf8");
   } catch {
   }
 }
@@ -46790,25 +47020,25 @@ function ensureShadowRepo(shadowDir, cwd) {
     timeout: 3e3
   });
   if (check.status === 0) {
-    const ptPath = path42.join(shadowDir, "project-path.txt");
+    const ptPath = path43.join(shadowDir, "project-path.txt");
     try {
-      const stored = fs44.readFileSync(ptPath, "utf8").trim();
+      const stored = fs45.readFileSync(ptPath, "utf8").trim();
       if (stored === normalizedCwd) return true;
       if (process.env.NODE9_DEBUG === "1")
         console.error(
           `[Node9] Shadow repo path mismatch: stored="${stored}" expected="${normalizedCwd}" \u2014 reinitializing`
         );
-      fs44.rmSync(shadowDir, { recursive: true, force: true });
+      fs45.rmSync(shadowDir, { recursive: true, force: true });
     } catch {
       try {
-        fs44.writeFileSync(ptPath, normalizedCwd, "utf8");
+        fs45.writeFileSync(ptPath, normalizedCwd, "utf8");
       } catch {
       }
       return true;
     }
   }
   try {
-    fs44.mkdirSync(shadowDir, { recursive: true });
+    fs45.mkdirSync(shadowDir, { recursive: true });
   } catch {
   }
   const init = spawnSync3("git", ["init", "--bare", shadowDir], { timeout: 5e3 });
@@ -46817,7 +47047,7 @@ function ensureShadowRepo(shadowDir, cwd) {
     if (process.env.NODE9_DEBUG === "1") console.error("[Node9] git init --bare failed:", reason);
     return false;
   }
-  const configFile = path42.join(shadowDir, "config");
+  const configFile = path43.join(shadowDir, "config");
   spawnSync3("git", ["config", "--file", configFile, "core.untrackedCache", "true"], {
     timeout: 3e3
   });
@@ -46825,7 +47055,7 @@ function ensureShadowRepo(shadowDir, cwd) {
     timeout: 3e3
   });
   try {
-    fs44.writeFileSync(path42.join(shadowDir, "project-path.txt"), normalizedCwd, "utf8");
+    fs45.writeFileSync(path43.join(shadowDir, "project-path.txt"), normalizedCwd, "utf8");
   } catch {
   }
   return true;
@@ -46848,12 +47078,12 @@ async function createShadowSnapshot(tool = "unknown", args = {}, ignorePaths = [
   let indexFile = null;
   try {
     const rawFilePath = extractFilePath(args);
-    const absFilePath = rawFilePath && path42.isAbsolute(rawFilePath) ? rawFilePath : null;
+    const absFilePath = rawFilePath && path43.isAbsolute(rawFilePath) ? rawFilePath : null;
     const cwd = absFilePath ? findProjectRoot(absFilePath) : process.cwd();
     const shadowDir = getShadowRepoDir(cwd);
     if (!ensureShadowRepo(shadowDir, cwd)) return null;
     writeShadowExcludes(shadowDir, ignorePaths);
-    indexFile = path42.join(shadowDir, `index_${process.pid}_${Date.now()}`);
+    indexFile = path43.join(shadowDir, `index_${process.pid}_${Date.now()}`);
     const shadowEnv = {
       ...process.env,
       GIT_DIR: shadowDir,
@@ -46925,7 +47155,7 @@ async function createShadowSnapshot(tool = "unknown", args = {}, ignorePaths = [
     writeStack(stack);
     const entry = stack[stack.length - 1];
     notifySnapshotTaken(commitHash.slice(0, 7), tool, entry.argsSummary, capturedFiles.length);
-    fs44.writeFileSync(UNDO_LATEST_PATH, commitHash);
+    fs45.writeFileSync(UNDO_LATEST_PATH, commitHash);
     if (shouldGc) {
       spawn4("git", ["gc", "--auto"], { env: shadowEnv, detached: true, stdio: "ignore" }).unref();
     }
@@ -46936,7 +47166,7 @@ async function createShadowSnapshot(tool = "unknown", args = {}, ignorePaths = [
   } finally {
     if (indexFile) {
       try {
-        fs44.unlinkSync(indexFile);
+        fs45.unlinkSync(indexFile);
       } catch {
       }
     }
@@ -47012,9 +47242,9 @@ function applyUndo(hash, cwd) {
       timeout: GIT_TIMEOUT
     }).stdout?.toString().trim().split("\n").filter(Boolean) ?? [];
     for (const file of [...tracked, ...untracked]) {
-      const fullPath = path42.join(dir, file);
-      if (!snapshotFiles.has(file) && fs44.existsSync(fullPath)) {
-        fs44.unlinkSync(fullPath);
+      const fullPath = path43.join(dir, file);
+      if (!snapshotFiles.has(file) && fs45.existsSync(fullPath)) {
+        fs45.unlinkSync(fullPath);
       }
     }
     return true;
@@ -47024,12 +47254,12 @@ function applyUndo(hash, cwd) {
 }
 // src/skill-pin.ts
-import fs45 from "fs";
-import path43 from "path";
-import os40 from "os";
+import fs46 from "fs";
+import path44 from "path";
+import os42 from "os";
 import crypto8 from "crypto";
 function getPinsFilePath2() {
-  return path43.join(os40.homedir(), ".node9", "skill-pins.json");
+  return path44.join(os42.homedir(), ".node9", "skill-pins.json");
 }
 var MAX_FILES = 5e3;
 var MAX_TOTAL_BYTES = 50 * 1024 * 1024;
@@ -47043,18 +47273,18 @@ function walkDir(root) {
     if (out.length >= MAX_FILES) return;
     let entries;
     try {
-      entries = fs45.readdirSync(dir, { withFileTypes: true });
+      entries = fs46.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       if (out.length >= MAX_FILES) return;
-      const full = path43.join(dir, entry.name);
-      const rel = relDir ? path43.posix.join(relDir, entry.name) : entry.name;
+      const full = path44.join(dir, entry.name);
+      const rel = relDir ? path44.posix.join(relDir, entry.name) : entry.name;
       let lst;
       try {
-        lst = fs45.lstatSync(full);
+        lst = fs46.lstatSync(full);
       } catch {
         continue;
       }
@@ -47066,7 +47296,7 @@ function walkDir(root) {
       if (!lst.isFile()) continue;
       if (totalBytes + lst.size > MAX_TOTAL_BYTES) continue;
       try {
-        const buf = fs45.readFileSync(full);
+        const buf = fs46.readFileSync(full);
         totalBytes += buf.length;
         out.push({ rel, hash: sha256Bytes(buf) });
       } catch {
@@ -47080,14 +47310,14 @@ function walkDir(root) {
 function hashSkillRoot(absPath) {
   let lst;
   try {
-    lst = fs45.lstatSync(absPath);
+    lst = fs46.lstatSync(absPath);
   } catch {
     return { exists: false, contentHash: "", fileCount: 0 };
   }
   if (lst.isSymbolicLink()) return { exists: false, contentHash: "", fileCount: 0 };
   if (lst.isFile()) {
     try {
-      return { exists: true, contentHash: sha256Bytes(fs45.readFileSync(absPath)), fileCount: 1 };
+      return { exists: true, contentHash: sha256Bytes(fs46.readFileSync(absPath)), fileCount: 1 };
     } catch {
       return { exists: false, contentHash: "", fileCount: 0 };
     }
@@ -47105,7 +47335,7 @@ function getRootKey(absPath) {
 function readSkillPinsSafe() {
   const filePath = getPinsFilePath2();
   try {
-    const raw = fs45.readFileSync(filePath, "utf-8");
+    const raw = fs46.readFileSync(filePath, "utf-8");
     if (!raw.trim()) return { ok: false, reason: "corrupt", detail: "empty file" };
     const parsed = JSON.parse(raw);
     if (!parsed.roots || typeof parsed.roots !== "object" || Array.isArray(parsed.roots)) {
@@ -47125,10 +47355,10 @@ function readSkillPins() {
 }
 function writeSkillPins(data) {
   const filePath = getPinsFilePath2();
-  fs45.mkdirSync(path43.dirname(filePath), { recursive: true });
+  fs46.mkdirSync(path44.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${crypto8.randomBytes(6).toString("hex")}.tmp`;
-  fs45.writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 384 });
-  fs45.renameSync(tmp, filePath);
+  fs46.writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 384 });
+  fs46.renameSync(tmp, filePath);
 }
 function removePin2(rootKey) {
   const pins = readSkillPins();
@@ -47172,36 +47402,36 @@ function verifyAndPinRoots(roots) {
   return { kind: "verified" };
 }
 function defaultSkillRoots(_cwd) {
-  const marketplaces = path43.join(os40.homedir(), ".claude", "plugins", "marketplaces");
+  const marketplaces = path44.join(os42.homedir(), ".claude", "plugins", "marketplaces");
   const roots = [];
   let registries;
   try {
-    registries = fs45.readdirSync(marketplaces, { withFileTypes: true });
+    registries = fs46.readdirSync(marketplaces, { withFileTypes: true });
   } catch {
     return [];
   }
   for (const registry of registries) {
     if (!registry.isDirectory()) continue;
-    const pluginsDir = path43.join(marketplaces, registry.name, "plugins");
+    const pluginsDir = path44.join(marketplaces, registry.name, "plugins");
     let plugins;
     try {
-      plugins = fs45.readdirSync(pluginsDir, { withFileTypes: true });
+      plugins = fs46.readdirSync(pluginsDir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const plugin of plugins) {
       if (!plugin.isDirectory()) continue;
-      roots.push(path43.join(pluginsDir, plugin.name));
+      roots.push(path44.join(pluginsDir, plugin.name));
     }
   }
   return roots;
 }
 function resolveUserSkillRoot(entry, cwd) {
   if (!entry) return null;
-  if (entry.startsWith("~/") || entry === "~") return path43.join(os40.homedir(), entry.slice(1));
-  if (path43.isAbsolute(entry)) return entry;
-  if (!cwd || !path43.isAbsolute(cwd)) return null;
-  return path43.join(cwd, entry);
+  if (entry.startsWith("~/") || entry === "~") return path44.join(os42.homedir(), entry.slice(1));
+  if (path44.isAbsolute(entry)) return entry;
+  if (!cwd || !path44.isAbsolute(cwd)) return null;
+  return path44.join(cwd, entry);
 }
 // src/cli/commands/check.ts
@@ -47210,11 +47440,11 @@ init_audit();
 // src/review-pending.ts
 init_hasher();
-import fs46 from "fs";
-import os41 from "os";
-import path44 from "path";
+import fs47 from "fs";
+import os43 from "os";
+import path45 from "path";
 function storePath() {
-  return process.env.NODE9_PENDING_STORE || path44.join(os41.homedir(), ".node9", "pending-reviews.json");
+  return process.env.NODE9_PENDING_STORE || path45.join(os43.homedir(), ".node9", "pending-reviews.json");
 }
 var TTL_MS2 = 6 * 60 * 60 * 1e3;
 var MAX_ENTRIES = 500;
@@ -47231,7 +47461,7 @@ function reviewCorrelationKey(payload) {
 }
 function read() {
   try {
-    const parsed = JSON.parse(fs46.readFileSync(storePath(), "utf-8"));
+    const parsed = JSON.parse(fs47.readFileSync(storePath(), "utf-8"));
     if (parsed && Array.isArray(parsed.entries)) return parsed;
   } catch {
   }
@@ -47240,11 +47470,11 @@ function read() {
 function write(store) {
   try {
     const p = storePath();
-    const dir = path44.dirname(p);
-    if (!fs46.existsSync(dir)) fs46.mkdirSync(dir, { recursive: true });
+    const dir = path45.dirname(p);
+    if (!fs47.existsSync(dir)) fs47.mkdirSync(dir, { recursive: true });
     const tmp = `${p}.${process.pid}.tmp`;
-    fs46.writeFileSync(tmp, JSON.stringify(store));
-    fs46.renameSync(tmp, p);
+    fs47.writeFileSync(tmp, JSON.stringify(store));
+    fs47.renameSync(tmp, p);
   } catch {
   }
 }
@@ -47357,9 +47587,9 @@ function registerCheckCommand(program2) {
         } catch (err2) {
           const tempConfig = getConfig();
           if (process.env.NODE9_DEBUG === "1" || tempConfig.settings.enableHookLogDebug) {
-            const logPath = path45.join(os42.homedir(), ".node9", "hook-debug.log");
+            const logPath = path46.join(os44.homedir(), ".node9", "hook-debug.log");
             const errMsg = err2 instanceof Error ? err2.message : String(err2);
-            fs47.appendFileSync(
+            fs48.appendFileSync(
               logPath,
               `[${(/* @__PURE__ */ new Date()).toISOString()}] JSON_PARSE_ERROR: ${errMsg}
 RAW: ${raw}
@@ -47372,14 +47602,14 @@ RAW: ${raw}
           const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
           if (process.env.NODE9_DEBUG === "1") {
             try {
-              const logPath = path45.join(os42.homedir(), ".node9", "hook-debug.log");
-              if (!fs47.existsSync(path45.dirname(logPath)))
-                fs47.mkdirSync(path45.dirname(logPath), { recursive: true });
+              const logPath = path46.join(os44.homedir(), ".node9", "hook-debug.log");
+              if (!fs48.existsSync(path46.dirname(logPath)))
+                fs48.mkdirSync(path46.dirname(logPath), { recursive: true });
               const sanitized = JSON.stringify({
                 ...payload,
                 prompt: `<redacted, ${prompt.length} bytes>`
               });
-              fs47.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] STDIN: ${sanitized}
+              fs48.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] STDIN: ${sanitized}
 `);
             } catch {
             }
@@ -47400,8 +47630,8 @@ RAW: ${raw}
           );
           const reason = `\u{1F6A8} Node9 DLP: ${dlpMatch.patternName} detected in prompt (${dlpMatch.redactedSample}). Prompt was not submitted \u2014 remove the credential and try again.`;
           try {
-            const ttyFd = fs47.openSync("/dev/tty", "w");
-            fs47.writeSync(
+            const ttyFd = fs48.openSync("/dev/tty", "w");
+            fs48.writeSync(
               ttyFd,
               chalk9.bgRed.white.bold(`
  \u{1F6A8} NODE9 DLP \u2014 PROMPT BLOCKED
@@ -47411,7 +47641,7 @@ RAW: ${raw}
 `)
             );
-            fs47.closeSync(ttyFd);
+            fs48.closeSync(ttyFd);
           } catch {
           }
           const isCodex = agent2 === "Codex";
@@ -47430,16 +47660,17 @@ RAW: ${raw}
           process.exit(2);
         }
         const payloadCwd = typeof payload.cwd === "string" ? payload.cwd : Array.isArray(payload.workspacePaths) && typeof payload.workspacePaths[0] === "string" ? payload.workspacePaths[0] : void 0;
-        const safeCwdForConfig = typeof payloadCwd === "string" && path45.isAbsolute(payloadCwd) ? payloadCwd : void 0;
+        const safeCwdForConfig = typeof payloadCwd === "string" && path46.isAbsolute(payloadCwd) ? payloadCwd : void 0;
         const config = getConfig(safeCwdForConfig);
-        if (config.settings.autoStartDaemon && !isDaemonRunning() && !process.env.NODE9_NO_AUTO_DAEMON) {
+        const daemonDown = !isDaemonRunning();
+        if (config.settings.autoStartDaemon && daemonDown && !process.env.NODE9_NO_AUTO_DAEMON) {
           try {
             const scriptPath = process.argv[1];
-            if (typeof scriptPath !== "string" || !path45.isAbsolute(scriptPath))
+            if (typeof scriptPath !== "string" || !path46.isAbsolute(scriptPath))
               throw new Error("node9: argv[1] is not an absolute path");
-            const resolvedScript = fs47.realpathSync(scriptPath);
-            const packageDist = fs47.realpathSync(path45.resolve(__dirname, "../.."));
-            if (!resolvedScript.startsWith(packageDist + path45.sep) && resolvedScript !== packageDist)
+            const resolvedScript = fs48.realpathSync(scriptPath);
+            const packageDist = fs48.realpathSync(path46.resolve(__dirname, "../.."));
+            if (!resolvedScript.startsWith(packageDist + path46.sep) && resolvedScript !== packageDist)
               throw new Error(
                 `node9: daemon spawn aborted \u2014 argv[1] (${resolvedScript}) is outside package dist (${packageDist})`
               );
@@ -47454,17 +47685,27 @@ RAW: ${raw}
             ]) {
               delete safeEnv[key];
             }
-            const d = spawn5(process.execPath, [scriptPath, "daemon"], {
-              detached: true,
-              stdio: "ignore",
-              env: { ...safeEnv, NODE9_AUTO_STARTED: "1" }
-            });
-            d.unref();
+            const startupFd = openStartupLogFd();
+            try {
+              const d = spawn5(process.execPath, [scriptPath, "daemon"], {
+                detached: true,
+                stdio: ["ignore", "ignore", startupFd ?? "ignore"],
+                env: { ...safeEnv, NODE9_AUTO_STARTED: "1" }
+              });
+              d.unref();
+            } finally {
+              if (startupFd !== void 0) {
+                try {
+                  fs48.closeSync(startupFd);
+                } catch {
+                }
+              }
+            }
           } catch (spawnErr) {
-            const logPath = path45.join(os42.homedir(), ".node9", "hook-debug.log");
+            const logPath = path46.join(os44.homedir(), ".node9", "hook-debug.log");
             const msg = spawnErr instanceof Error ? spawnErr.message : String(spawnErr);
             try {
-              fs47.appendFileSync(
+              fs48.appendFileSync(
                 logPath,
                 `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon-autostart-failed: ${msg}
 `
@@ -47472,12 +47713,16 @@ RAW: ${raw}
             } catch {
             }
           }
+        } else if (daemonDown && !isTestingMode()) {
+          logAutostartSkipThrottled(
+            !config.settings.autoStartDaemon ? "autoStartDaemon=false" : process.env.NODE9_NO_AUTO_DAEMON ? "NODE9_NO_AUTO_DAEMON" : "unknown"
+          );
         }
         if (process.env.NODE9_DEBUG === "1" || config.settings.enableHookLogDebug) {
-          const logPath = path45.join(os42.homedir(), ".node9", "hook-debug.log");
-          if (!fs47.existsSync(path45.dirname(logPath)))
-            fs47.mkdirSync(path45.dirname(logPath), { recursive: true });
-          fs47.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] STDIN: ${raw}
+          const logPath = path46.join(os44.homedir(), ".node9", "hook-debug.log");
+          if (!fs48.existsSync(path46.dirname(logPath)))
+            fs48.mkdirSync(path46.dirname(logPath), { recursive: true });
+          fs48.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] STDIN: ${raw}
 `);
         }
         const rawToolName = sanitize2(extractToolName(payload));
@@ -47491,8 +47736,8 @@ RAW: ${raw}
           const isHumanDecision = blockedByContext.toLowerCase().includes("user") || blockedByContext.toLowerCase().includes("daemon") || blockedByContext.toLowerCase().includes("decision");
           let ttyFd = null;
           try {
-            ttyFd = fs47.openSync("/dev/tty", "w");
-            const writeTty = (line) => fs47.writeSync(ttyFd, line + "\n");
+            ttyFd = fs48.openSync("/dev/tty", "w");
+            const writeTty = (line) => fs48.writeSync(ttyFd, line + "\n");
             if (blockedByContext.includes("DLP") || blockedByContext.includes("Secret Detected") || blockedByContext.includes("Credential Review")) {
               writeTty(chalk9.bgRed.white.bold(`
  \u{1F6A8} NODE9 DLP ALERT \u2014 CREDENTIAL DETECTED `));
@@ -47511,7 +47756,7 @@ RAW: ${raw}
           } finally {
             if (ttyFd !== null)
               try {
-                fs47.closeSync(ttyFd);
+                fs48.closeSync(ttyFd);
               } catch {
               }
           }
@@ -47568,8 +47813,8 @@ RAW: ${raw}
           } catch {
           }
           try {
-            const ttyFd = fs47.openSync("/dev/tty", "w");
-            fs47.writeSync(
+            const ttyFd = fs48.openSync("/dev/tty", "w");
+            fs48.writeSync(
               ttyFd,
               chalk9.yellow(
                 `
@@ -47577,7 +47822,7 @@ RAW: ${raw}
 `
               )
             );
-            fs47.closeSync(ttyFd);
+            fs48.closeSync(ttyFd);
           } catch {
           }
           if (agent === "GitHub Copilot") {
@@ -47609,17 +47854,17 @@ RAW: ${raw}
         const safeSessionId = /^[A-Za-z0-9_\-]{1,128}$/.test(rawSessionId) ? rawSessionId : "";
         if (skillPinCfg.enabled && safeSessionId) {
           try {
-            const sessionsDir = path45.join(os42.homedir(), ".node9", "skill-sessions");
-            const flagPath = path45.join(sessionsDir, `${safeSessionId}.json`);
+            const sessionsDir = path46.join(os44.homedir(), ".node9", "skill-sessions");
+            const flagPath = path46.join(sessionsDir, `${safeSessionId}.json`);
             let flag = null;
             try {
-              flag = JSON.parse(fs47.readFileSync(flagPath, "utf-8"));
+              flag = JSON.parse(fs48.readFileSync(flagPath, "utf-8"));
             } catch {
             }
             const writeFlag = (data2) => {
               try {
-                fs47.mkdirSync(sessionsDir, { recursive: true });
-                fs47.writeFileSync(
+                fs48.mkdirSync(sessionsDir, { recursive: true });
+                fs48.writeFileSync(
                   flagPath,
                   JSON.stringify({ ...data2, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
                   { mode: 384 }
@@ -47630,8 +47875,8 @@ RAW: ${raw}
             const sendSkillWarn = (detail, recoveryCmd) => {
               let ttyFd = null;
               try {
-                ttyFd = fs47.openSync("/dev/tty", "w");
-                const w = (line) => fs47.writeSync(ttyFd, line + "\n");
+                ttyFd = fs48.openSync("/dev/tty", "w");
+                const w = (line) => fs48.writeSync(ttyFd, line + "\n");
                 w(chalk9.yellow(`
 \u26A0\uFE0F  Node9: installed skill drift detected`));
                 w(chalk9.gray(`   ${detail}`));
@@ -47646,7 +47891,7 @@ RAW: ${raw}
               } finally {
                 if (ttyFd !== null)
                   try {
-                    fs47.closeSync(ttyFd);
+                    fs48.closeSync(ttyFd);
                   } catch {
                   }
               }
@@ -47662,7 +47907,7 @@ RAW: ${raw}
               return;
             }
             if (!flag || flag.state !== "verified" && flag.state !== "warned") {
-              const absoluteCwd = typeof payloadCwd === "string" && path45.isAbsolute(payloadCwd) ? payloadCwd : void 0;
+              const absoluteCwd = typeof payloadCwd === "string" && path46.isAbsolute(payloadCwd) ? payloadCwd : void 0;
               const extraRoots = skillPinCfg.roots;
               const resolvedExtra = extraRoots.map((r) => resolveUserSkillRoot(r, absoluteCwd)).filter((r) => typeof r === "string");
               const roots = [...defaultSkillRoots(absoluteCwd), ...resolvedExtra];
@@ -47703,10 +47948,10 @@ RAW: ${raw}
               }
               try {
                 const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1e3;
-                for (const name of fs47.readdirSync(sessionsDir)) {
-                  const p = path45.join(sessionsDir, name);
+                for (const name of fs48.readdirSync(sessionsDir)) {
+                  const p = path46.join(sessionsDir, name);
                   try {
-                    if (fs47.statSync(p).mtimeMs < cutoff) fs47.unlinkSync(p);
+                    if (fs48.statSync(p).mtimeMs < cutoff) fs48.unlinkSync(p);
                   } catch {
                   }
                 }
@@ -47716,9 +47961,9 @@ RAW: ${raw}
           } catch (err2) {
             if (process.env.NODE9_DEBUG === "1") {
               try {
-                const dbg = path45.join(os42.homedir(), ".node9", "hook-debug.log");
+                const dbg = path46.join(os44.homedir(), ".node9", "hook-debug.log");
                 const msg = err2 instanceof Error ? err2.message : String(err2);
-                fs47.appendFileSync(dbg, `[${(/* @__PURE__ */ new Date()).toISOString()}] SKILL_PIN_ERROR: ${msg}
+                fs48.appendFileSync(dbg, `[${(/* @__PURE__ */ new Date()).toISOString()}] SKILL_PIN_ERROR: ${msg}
 `);
               } catch {
               }
@@ -47728,7 +47973,7 @@ RAW: ${raw}
         if (shouldSnapshot(toolName, toolInput, config)) {
           await createShadowSnapshot(toolName, toolInput, config.policy.snapshot.ignorePaths);
         }
-        const safeCwdForAuth = typeof payloadCwd === "string" && path45.isAbsolute(payloadCwd) ? payloadCwd : void 0;
+        const safeCwdForAuth = typeof payloadCwd === "string" && path46.isAbsolute(payloadCwd) ? payloadCwd : void 0;
         const askMode = resolveAskMode(agent, opts, config);
         const result = await authorizeHeadless(toolName, toolInput, meta, {
           cwd: safeCwdForAuth,
@@ -47746,12 +47991,12 @@ RAW: ${raw}
         }
         if (result.noApprovalMechanism && !isDaemonRunning() && !process.env.NODE9_NO_AUTO_DAEMON && !process.stdout.isTTY && config.settings.autoStartDaemon) {
           try {
-            const tty = fs47.openSync("/dev/tty", "w");
-            fs47.writeSync(
+            const tty = fs48.openSync("/dev/tty", "w");
+            fs48.writeSync(
               tty,
               chalk9.cyan("\n\u{1F6E1}\uFE0F  Node9: Starting approval daemon automatically...\n")
             );
-            fs47.closeSync(tty);
+            fs48.closeSync(tty);
           } catch {
           }
           const daemonReady = await autoStartDaemonAndWait();
@@ -47778,9 +48023,9 @@ RAW: ${raw}
         });
       } catch (err2) {
         if (process.env.NODE9_DEBUG === "1") {
-          const logPath = path45.join(os42.homedir(), ".node9", "hook-debug.log");
+          const logPath = path46.join(os44.homedir(), ".node9", "hook-debug.log");
           const errMsg = err2 instanceof Error ? err2.message : String(err2);
-          fs47.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR: ${errMsg}
+          fs48.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR: ${errMsg}
 `);
         }
         process.exit(0);
@@ -47816,9 +48061,9 @@ RAW: ${raw}
 // src/cli/commands/log.ts
 init_audit();
 init_config();
-import fs48 from "fs";
-import path46 from "path";
-import os43 from "os";
+import fs49 from "fs";
+import path47 from "path";
+import os45 from "os";
 init_daemon();
 init_dlp();
@@ -47926,10 +48171,10 @@ function registerLogCommand(program2) {
         if (rawToolName !== tool) entry.agentToolName = rawToolName;
         const payloadSessionId = payload.session_id ?? payload.conversationId;
         if (payloadSessionId) entry.sessionId = payloadSessionId;
-        const logPath = path46.join(os43.homedir(), ".node9", "audit.log");
-        if (!fs48.existsSync(path46.dirname(logPath)))
-          fs48.mkdirSync(path46.dirname(logPath), { recursive: true });
-        fs48.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+        const logPath = path47.join(os45.homedir(), ".node9", "audit.log");
+        if (!fs49.existsSync(path47.dirname(logPath)))
+          fs49.mkdirSync(path47.dirname(logPath), { recursive: true });
+        fs49.appendFileSync(logPath, JSON.stringify(entry) + "\n");
         if ((tool === "Bash" || tool === "bash") && isDaemonRunning()) {
           const command = typeof rawInput === "object" && rawInput !== null && "command" in rawInput && typeof rawInput.command === "string" ? rawInput.command : null;
           if (command) {
@@ -47963,7 +48208,7 @@ function registerLogCommand(program2) {
           }
         }
         const payloadCwd = typeof payload.cwd === "string" ? payload.cwd : Array.isArray(payload.workspacePaths) && typeof payload.workspacePaths[0] === "string" ? payload.workspacePaths[0] : void 0;
-        const safeCwd = typeof payloadCwd === "string" && path46.isAbsolute(payloadCwd) ? payloadCwd : void 0;
+        const safeCwd = typeof payloadCwd === "string" && path47.isAbsolute(payloadCwd) ? payloadCwd : void 0;
         const config = getConfig(safeCwd);
         {
           const toolOutput = payload.tool_response?.output;
@@ -48040,9 +48285,9 @@ function registerLogCommand(program2) {
         const msg = err2 instanceof Error ? err2.message : String(err2);
         process.stderr.write(`[Node9] audit log error: ${msg}
 `);
-        const debugPath = path46.join(os43.homedir(), ".node9", "hook-debug.log");
+        const debugPath = path47.join(os45.homedir(), ".node9", "hook-debug.log");
         try {
-          fs48.appendFileSync(debugPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] LOG_ERROR: ${msg}
+          fs49.appendFileSync(debugPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] LOG_ERROR: ${msg}
 `);
         } catch {
         }
@@ -48069,16 +48314,16 @@ function registerLogCommand(program2) {
 init_shields();
 init_build();
 import chalk10 from "chalk";
-import fs50 from "fs";
-import path48 from "path";
-import os44 from "os";
+import fs51 from "fs";
+import path49 from "path";
+import os46 from "os";
 // src/shields/create.ts
 init_dist();
 init_shields();
 init_audit();
-import fs49 from "fs";
-import path47 from "path";
+import fs50 from "fs";
+import path48 from "path";
 function builtinNames() {
   const names = /* @__PURE__ */ new Set();
   for (const def of Object.values(BUILTIN_SHIELDS)) {
@@ -48095,8 +48340,8 @@ function createShield(def, opts = {}) {
       error: `"${name}" is a built-in shield \u2014 choose a different name (a user shield with this name would shadow the built-in).`
     };
   }
-  const filePath = path47.join(USER_SHIELDS_DIR_PATH, `${name}.json`);
-  if (!opts.overwrite && fs49.existsSync(filePath)) {
+  const filePath = path48.join(USER_SHIELDS_DIR_PATH, `${name}.json`);
+  if (!opts.overwrite && fs50.existsSync(filePath)) {
     return {
       ok: false,
       error: `Shield "${name}" already exists at ${filePath}. Pass --overwrite to replace it.`
@@ -48161,8 +48406,8 @@ var COMMUNITY_INDEX_URL = "https://raw.githubusercontent.com/node9ai/node9-proxy
 function readCloudShields() {
   const out = /* @__PURE__ */ new Set();
   try {
-    const file = path48.join(os44.homedir(), ".node9", "rules-cache.json");
-    const raw = JSON.parse(fs50.readFileSync(file, "utf-8"));
+    const file = path49.join(os46.homedir(), ".node9", "rules-cache.json");
+    const raw = JSON.parse(fs51.readFileSync(file, "utf-8"));
     for (const r of raw.rules ?? []) {
       const rule = r;
       const fromSource = rule.source?.startsWith("SHIELD:") ? rule.source.slice("SHIELD:".length).toLowerCase() : void 0;
@@ -48479,7 +48724,7 @@ function registerShieldCommand(program2) {
       if (opts.fromFile) {
         let raw;
         try {
-          raw = JSON.parse(fs50.readFileSync(opts.fromFile, "utf-8"));
+          raw = JSON.parse(fs51.readFileSync(opts.fromFile, "utf-8"));
         } catch (err2) {
           console.error(
             chalk10.red(`
@@ -48601,14 +48846,31 @@ function registerConfigShowCommand(program2) {
 init_daemon();
 init_config();
 init_agent_wiring();
+init_sync();
+init_service();
 import chalk11 from "chalk";
-import fs51 from "fs";
-import path49 from "path";
-import os45 from "os";
+import fs52 from "fs";
+import path50 from "path";
+import os47 from "os";
 import { execSync } from "child_process";
+// src/lib/relative-time.ts
+function agoLabel(iso, now = Date.now()) {
+  const ms = now - new Date(iso).getTime();
+  if (!Number.isFinite(ms) || ms < 0) return "just now";
+  const min = Math.floor(ms / 6e4);
+  if (min < 1) return "just now";
+  if (min < 60) return `${min} min ago`;
+  const hr = Math.floor(min / 60);
+  if (hr < 24) return `${hr} hour${hr === 1 ? "" : "s"} ago`;
+  const d = Math.floor(hr / 24);
+  return `${d} day${d === 1 ? "" : "s"} ago`;
+}
+// src/cli/commands/doctor.ts
 function registerDoctorCommand(program2, version2) {
   program2.command("doctor").description("Check that Node9 is installed and configured correctly").action(async () => {
-    const homeDir2 = os45.homedir();
+    const homeDir2 = os47.homedir();
     let failures = 0;
     function pass(msg) {
       console.log(chalk11.green("  \u2705 ") + msg);
@@ -48654,10 +48916,10 @@ function registerDoctorCommand(program2, version2) {
       );
     }
     section("Configuration");
-    const globalConfigPath = path49.join(homeDir2, ".node9", "config.json");
-    if (fs51.existsSync(globalConfigPath)) {
+    const globalConfigPath = path50.join(homeDir2, ".node9", "config.json");
+    if (fs52.existsSync(globalConfigPath)) {
       try {
-        JSON.parse(fs51.readFileSync(globalConfigPath, "utf-8"));
+        JSON.parse(fs52.readFileSync(globalConfigPath, "utf-8"));
         pass("~/.node9/config.json found and valid");
       } catch {
         fail("~/.node9/config.json is invalid JSON", "Run: node9 init --force");
@@ -48665,10 +48927,10 @@ function registerDoctorCommand(program2, version2) {
     } else {
       warn("~/.node9/config.json not found (using defaults)", "Run: node9 init");
     }
-    const projectConfigPath = path49.join(process.cwd(), "node9.config.json");
-    if (fs51.existsSync(projectConfigPath)) {
+    const projectConfigPath = path50.join(process.cwd(), "node9.config.json");
+    if (fs52.existsSync(projectConfigPath)) {
       try {
-        JSON.parse(fs51.readFileSync(projectConfigPath, "utf-8"));
+        JSON.parse(fs52.readFileSync(projectConfigPath, "utf-8"));
         pass("node9.config.json found and valid (project)");
       } catch {
         fail(
@@ -48677,8 +48939,8 @@ function registerDoctorCommand(program2, version2) {
         );
       }
     }
-    const credsPath = path49.join(homeDir2, ".node9", "credentials.json");
-    if (fs51.existsSync(credsPath)) {
+    const credsPath = path50.join(homeDir2, ".node9", "credentials.json");
+    if (fs52.existsSync(credsPath)) {
       pass("Cloud credentials found (~/.node9/credentials.json)");
     } else {
       warn(
@@ -48718,11 +48980,31 @@ function registerDoctorCommand(program2, version2) {
         "Run: node9 daemon --background"
       );
     }
+    const autostart = autostartAdvice({
+      installed: isDaemonServiceInstalled(),
+      enabled: isDaemonServiceEnabled(),
+      cloudEnabled: !!getConfig().settings.approvers?.cloud
+    });
+    if (autostart) warn(autostart.message, autostart.hint);
+    if (fs52.existsSync(path50.join(os47.homedir(), ".node9", "credentials.json")) && getConfig().settings.approvers?.cloud) {
+      section("Policy sync");
+      const health = readSyncHealth();
+      if (isPolicyStale(Date.now(), health)) {
+        const when = health.lastCheckedAt ? `last reached the cloud ${agoLabel(health.lastCheckedAt)}` : "never reached the cloud";
+        const fails = health.consecutiveFailures > 0 ? ` (${health.consecutiveFailures} consecutive failure${health.consecutiveFailures === 1 ? "" : "s"}${health.lastError ? `: ${health.lastError}` : ""})` : "";
+        warn(
+          `Cloud policy is STALE \u2014 ${when}${fails}. The cached policy is still enforced, but changes from the dashboard are not reaching this machine.`,
+          "Run: node9 policy sync   (and ensure the daemon autostarts: systemctl --user enable --now node9-daemon)"
+        );
+      } else if (health.lastCheckedAt) {
+        pass(`Cloud policy fresh \u2014 last synced ${agoLabel(health.lastCheckedAt)}`);
+      }
+    }
     section("Cloud audit shipping");
     try {
       const { shipLagBytes: shipLagBytes2, readWatermark: readWatermark2, AUDIT_SHIP_WATERMARK: AUDIT_SHIP_WATERMARK2 } = await Promise.resolve().then(() => (init_audit_shipper(), audit_shipper_exports));
       const cfg = getConfig();
-      const creds = fs51.existsSync(path49.join(os45.homedir(), ".node9", "credentials.json"));
+      const creds = fs52.existsSync(path50.join(os47.homedir(), ".node9", "credentials.json"));
       if (!creds) {
         warn("Not logged in \u2014 audit rows stay local", "Run: node9 login <api-key>");
       } else if (!cfg.settings.approvers.cloud) {
@@ -48772,9 +49054,9 @@ function registerDoctorCommand(program2, version2) {
 // src/cli/commands/audit.ts
 import chalk12 from "chalk";
-import fs52 from "fs";
-import path50 from "path";
-import os46 from "os";
+import fs53 from "fs";
+import path51 from "path";
+import os48 from "os";
 function formatRelativeTime(timestamp) {
   const diff = Date.now() - new Date(timestamp).getTime();
   const sec = Math.floor(diff / 1e3);
@@ -48787,14 +49069,14 @@ function formatRelativeTime(timestamp) {
 }
 function registerAuditCommand(program2) {
   program2.command("audit").description("View local execution audit log").option("--tail <n>", "Number of entries to show", "20").option("--tool <pattern>", "Filter by tool name (substring match)").option("--deny", "Show only denied actions").option("--json", "Output raw JSON").action((options) => {
-    const logPath = path50.join(os46.homedir(), ".node9", "audit.log");
-    if (!fs52.existsSync(logPath)) {
+    const logPath = path51.join(os48.homedir(), ".node9", "audit.log");
+    if (!fs53.existsSync(logPath)) {
       console.log(
         chalk12.yellow("No audit logs found. Run node9 with an agent to generate entries.")
       );
       return;
     }
-    const raw = fs52.readFileSync(logPath, "utf-8");
+    const raw = fs53.readFileSync(logPath, "utf-8");
     const lines = raw.split("\n").filter((l) => l.trim() !== "");
     let entries = lines.flatMap((line) => {
       try {
@@ -48853,9 +49135,9 @@ import chalk13 from "chalk";
 init_costSync();
 init_litellm();
 init_cost_codex();
-import fs53 from "fs";
-import os47 from "os";
-import path51 from "path";
+import fs54 from "fs";
+import os49 from "os";
+import path52 from "path";
 var TEST_COMMAND_RE3 = /(?:^|\s)(npm\s+(?:run\s+)?test|npx\s+(?:vitest|jest|mocha)|yarn\s+(?:run\s+)?test|pnpm\s+(?:run\s+)?test|vitest|jest|mocha|pytest|py\.test|cargo\s+test|go\s+test|bundle\s+exec\s+rspec|rspec|phpunit|dotnet\s+test)\b/i;
 function buildTestTimestamps(allEntries) {
   const testTs = /* @__PURE__ */ new Set();
@@ -48935,8 +49217,8 @@ function getDateRange(period, now) {
   }
 }
 function parseAuditLog(logPath) {
-  if (!fs53.existsSync(logPath)) return [];
-  const raw = fs53.readFileSync(logPath, "utf-8");
+  if (!fs54.existsSync(logPath)) return [];
+  const raw = fs54.readFileSync(logPath, "utf-8");
   return raw.split("\n").flatMap((line) => {
     if (!line.trim()) return [];
     try {
@@ -48983,25 +49265,25 @@ function freezeClaudeCost(acc) {
   };
 }
 function processClaudeCostProject(proj, projectsDir, start, end, acc) {
-  const projPath = path51.join(projectsDir, proj);
+  const projPath = path52.join(projectsDir, proj);
   let files;
   try {
-    const stat = fs53.statSync(projPath);
+    const stat = fs54.statSync(projPath);
     if (!stat.isDirectory()) return;
-    files = fs53.readdirSync(projPath).filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
+    files = fs54.readdirSync(projPath).filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
   } catch {
     return;
   }
   const startMs = start.getTime();
   for (const file of files) {
-    const filePath = path51.join(projPath, file);
+    const filePath = path52.join(projPath, file);
     try {
-      if (fs53.statSync(filePath).mtimeMs < startMs) continue;
+      if (fs54.statSync(filePath).mtimeMs < startMs) continue;
     } catch {
       continue;
     }
     try {
-      const raw = fs53.readFileSync(filePath, "utf-8");
+      const raw = fs54.readFileSync(filePath, "utf-8");
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
         let entry;
@@ -49051,10 +49333,10 @@ function processClaudeCostProject(proj, projectsDir, start, end, acc) {
 }
 function loadClaudeCost(start, end, projectsDir) {
   const acc = emptyClaudeCostAccumulator();
-  if (!fs53.existsSync(projectsDir)) return freezeClaudeCost(acc);
+  if (!fs54.existsSync(projectsDir)) return freezeClaudeCost(acc);
   let dirs;
   try {
-    dirs = fs53.readdirSync(projectsDir);
+    dirs = fs54.readdirSync(projectsDir);
   } catch {
     return freezeClaudeCost(acc);
   }
@@ -49066,7 +49348,7 @@ function loadClaudeCost(start, end, projectsDir) {
 function processCodexCostFile(filePath, start, end, acc) {
   let lines;
   try {
-    lines = fs53.readFileSync(filePath, "utf-8").split("\n");
+    lines = fs54.readFileSync(filePath, "utf-8").split("\n");
   } catch {
     return;
   }
@@ -49121,31 +49403,31 @@ function processCodexCostFile(filePath, start, end, acc) {
 }
 function listCodexSessionFiles2(sessionsBase) {
   const jsonlFiles = [];
-  if (!fs53.existsSync(sessionsBase)) return jsonlFiles;
+  if (!fs54.existsSync(sessionsBase)) return jsonlFiles;
   try {
-    for (const year of fs53.readdirSync(sessionsBase)) {
-      const yearPath = path51.join(sessionsBase, year);
+    for (const year of fs54.readdirSync(sessionsBase)) {
+      const yearPath = path52.join(sessionsBase, year);
       try {
-        if (!fs53.statSync(yearPath).isDirectory()) continue;
+        if (!fs54.statSync(yearPath).isDirectory()) continue;
       } catch {
         continue;
       }
-      for (const month of fs53.readdirSync(yearPath)) {
-        const monthPath = path51.join(yearPath, month);
+      for (const month of fs54.readdirSync(yearPath)) {
+        const monthPath = path52.join(yearPath, month);
         try {
-          if (!fs53.statSync(monthPath).isDirectory()) continue;
+          if (!fs54.statSync(monthPath).isDirectory()) continue;
         } catch {
           continue;
         }
-        for (const day of fs53.readdirSync(monthPath)) {
-          const dayPath = path51.join(monthPath, day);
+        for (const day of fs54.readdirSync(monthPath)) {
+          const dayPath = path52.join(monthPath, day);
           try {
-            if (!fs53.statSync(dayPath).isDirectory()) continue;
+            if (!fs54.statSync(dayPath).isDirectory()) continue;
           } catch {
             continue;
           }
-          for (const file of fs53.readdirSync(dayPath)) {
-            if (file.endsWith(".jsonl")) jsonlFiles.push(path51.join(dayPath, file));
+          for (const file of fs54.readdirSync(dayPath)) {
+            if (file.endsWith(".jsonl")) jsonlFiles.push(path52.join(dayPath, file));
           }
         }
       }
@@ -49210,13 +49492,13 @@ function freezeGeminiCost(acc) {
 function processGeminiCostFile(filePath, projectKey, start, end, acc) {
   const startMs = start.getTime();
   try {
-    if (fs53.statSync(filePath).mtimeMs < startMs) return;
+    if (fs54.statSync(filePath).mtimeMs < startMs) return;
   } catch {
     return;
   }
   let raw;
   try {
-    raw = fs53.readFileSync(filePath, "utf-8");
+    raw = fs54.readFileSync(filePath, "utf-8");
   } catch {
     return;
   }
@@ -49265,30 +49547,30 @@ function listGeminiSessionFiles2(geminiTmpDir2) {
   const out = [];
   let dirs;
   try {
-    if (!fs53.statSync(geminiTmpDir2).isDirectory()) return out;
-    dirs = fs53.readdirSync(geminiTmpDir2);
+    if (!fs54.statSync(geminiTmpDir2).isDirectory()) return out;
+    dirs = fs54.readdirSync(geminiTmpDir2);
   } catch {
     return out;
   }
   for (const proj of dirs) {
-    const chatsDir = path51.join(geminiTmpDir2, proj, "chats");
+    const chatsDir = path52.join(geminiTmpDir2, proj, "chats");
     let files;
     try {
-      if (!fs53.statSync(chatsDir).isDirectory()) continue;
-      files = fs53.readdirSync(chatsDir);
+      if (!fs54.statSync(chatsDir).isDirectory()) continue;
+      files = fs54.readdirSync(chatsDir);
     } catch {
       continue;
     }
     for (const f of files) {
       if (!f.endsWith(".jsonl")) continue;
-      out.push({ projectKey: proj, file: path51.join(chatsDir, f) });
+      out.push({ projectKey: proj, file: path52.join(chatsDir, f) });
     }
   }
   return out;
 }
 function loadGeminiCost(start, end, geminiTmpDir2) {
   const acc = emptyGeminiAccumulator();
-  if (!fs53.existsSync(geminiTmpDir2)) return freezeGeminiCost(acc);
+  if (!fs54.existsSync(geminiTmpDir2)) return freezeGeminiCost(acc);
   for (const { projectKey, file } of listGeminiSessionFiles2(geminiTmpDir2)) {
     processGeminiCostFile(file, projectKey, start, end, acc);
   }
@@ -49306,11 +49588,11 @@ function dimensionOfBlock(checkedBy, ruleName) {
 }
 function aggregateReportFromAudit(period, opts = {}) {
   const now = opts.now ?? /* @__PURE__ */ new Date();
-  const auditLogPath = opts.auditLogPath ?? path51.join(os47.homedir(), ".node9", "audit.log");
-  const claudeProjectsDir = opts.claudeProjectsDir ?? path51.join(os47.homedir(), ".claude", "projects");
-  const codexSessionsDir2 = opts.codexSessionsDir ?? path51.join(os47.homedir(), ".codex", "sessions");
-  const geminiTmpDir2 = opts.geminiTmpDir ?? path51.join(os47.homedir(), ".gemini", "tmp");
-  const hasAuditFile = fs53.existsSync(auditLogPath);
+  const auditLogPath = opts.auditLogPath ?? path52.join(os49.homedir(), ".node9", "audit.log");
+  const claudeProjectsDir = opts.claudeProjectsDir ?? path52.join(os49.homedir(), ".claude", "projects");
+  const codexSessionsDir2 = opts.codexSessionsDir ?? path52.join(os49.homedir(), ".codex", "sessions");
+  const geminiTmpDir2 = opts.geminiTmpDir ?? path52.join(os49.homedir(), ".gemini", "tmp");
+  const hasAuditFile = fs54.existsSync(auditLogPath);
   const allEntries = opts.preloadedAuditEntries ?? parseAuditLog(auditLogPath);
   const unackedDlp = allEntries.filter((e) => e.source === "response-dlp");
   const { start, end } = getDateRange(period, now);
@@ -50103,10 +50385,12 @@ function registerDaemonCommand(program2) {
 init_core();
 init_daemon();
 init_agent_wiring();
+init_sync();
+init_service();
 import chalk15 from "chalk";
-import fs54 from "fs";
-import path52 from "path";
-import os48 from "os";
+import fs55 from "fs";
+import path53 from "path";
+import os50 from "os";
 function printAgentSection(label2, hookPairs, wrapped) {
   console.log(chalk15.bold(`  ${label2}`));
   for (const { name, present } of hookPairs) {
@@ -50135,6 +50419,15 @@ function registerStatusCommand(program2) {
     console.log("");
     if (creds && settings.approvers.cloud) {
       console.log(chalk15.green("  \u25CF Agent mode") + chalk15.gray(" \u2014 cloud team policy enforced"));
+      const health = readSyncHealth();
+      if (isPolicyStale(Date.now(), health)) {
+        const when = health.lastCheckedAt ? `last synced ${agoLabel(health.lastCheckedAt)}` : "never synced";
+        const fails = health.consecutiveFailures > 0 ? ` \xB7 ${health.consecutiveFailures} failed attempt${health.consecutiveFailures === 1 ? "" : "s"}${health.lastError ? ` (${health.lastError})` : ""}` : "";
+        console.log(chalk15.yellow("    \u26A0 Policy sync STALE") + chalk15.gray(` \u2014 ${when}${fails}`));
+        console.log(chalk15.gray("      the cached policy is still enforced \u2014 run: node9 doctor"));
+      } else if (health.lastCheckedAt) {
+        console.log(chalk15.gray(`    \u21B3 policy synced ${agoLabel(health.lastCheckedAt)}`));
+      }
     } else if (creds && !settings.approvers.cloud) {
       console.log(
         chalk15.blue("  \u25CF Privacy mode \u{1F6E1}\uFE0F") + chalk15.gray(" \u2014 all decisions stay on this machine")
@@ -50152,6 +50445,16 @@ function registerStatusCommand(program2) {
     } else {
       console.log(chalk15.gray("  \u25CB Daemon stopped"));
     }
+    const autostart = autostartAdvice({
+      installed: isDaemonServiceInstalled(),
+      enabled: isDaemonServiceEnabled(),
+      cloudEnabled: !!(creds && settings.approvers.cloud)
+    });
+    if (autostart) {
+      console.log(
+        chalk15.yellow("    \u26A0 daemon autostart not active") + chalk15.gray(" \u2014 won't survive reboot; run: node9 doctor")
+      );
+    }
     if (settings.enableUndo) {
       console.log(
         chalk15.magenta("  \u25CF Undo Engine") + chalk15.gray(`    \u2192 Auto-snapshotting Git repos on AI change`)
@@ -50160,20 +50463,20 @@ function registerStatusCommand(program2) {
     console.log("");
     const modeLabel = settings.mode === "audit" ? chalk15.blue("audit") : settings.mode === "strict" ? chalk15.red("strict") : chalk15.white("standard");
     console.log(`  Mode:    ${modeLabel}`);
-    const projectConfig = path52.join(process.cwd(), "node9.config.json");
-    const globalConfig = path52.join(os48.homedir(), ".node9", "config.json");
+    const projectConfig = path53.join(process.cwd(), "node9.config.json");
+    const globalConfig = path53.join(os50.homedir(), ".node9", "config.json");
     console.log(
-      `  Local:   ${fs54.existsSync(projectConfig) ? chalk15.green("Active (node9.config.json)") : chalk15.gray("Not present")}`
+      `  Local:   ${fs55.existsSync(projectConfig) ? chalk15.green("Active (node9.config.json)") : chalk15.gray("Not present")}`
     );
     console.log(
-      `  Global:  ${fs54.existsSync(globalConfig) ? chalk15.green("Active (~/.node9/config.json)") : chalk15.gray("Not present")}`
+      `  Global:  ${fs55.existsSync(globalConfig) ? chalk15.green("Active (~/.node9/config.json)") : chalk15.gray("Not present")}`
     );
     if (mergedConfig.policy.sandboxPaths.length > 0) {
       console.log(
         `  Sandbox: ${chalk15.green(`${mergedConfig.policy.sandboxPaths.length} safe zones active`)}`
       );
     }
-    const wiring = getAgentWiring(os48.homedir()).filter((a) => a.present);
+    const wiring = getAgentWiring(os50.homedir()).filter((a) => a.present);
     if (wiring.length > 0) {
       console.log("");
       console.log(chalk15.bold("  Agent Wiring:"));
@@ -50211,10 +50514,11 @@ init_core();
 init_setup();
 init_shields();
 init_service();
+init_core();
 import chalk16 from "chalk";
-import fs55 from "fs";
-import path53 from "path";
-import os49 from "os";
+import fs56 from "fs";
+import path54 from "path";
+import os51 from "os";
 import https6 from "https";
 var DEFAULT_SHIELDS = ["bash-safe", "filesystem", "project-jail"];
 function buildTelemetryPayload(agents, firstInstall) {
@@ -50300,16 +50604,16 @@ function registerInitCommand(program2) {
         }
         console.log("");
       }
-      const configPath = path53.join(os49.homedir(), ".node9", "config.json");
-      const isFirstInstall = !fs55.existsSync(configPath);
-      if (fs55.existsSync(configPath) && !options.force) {
+      const configPath = path54.join(os51.homedir(), ".node9", "config.json");
+      const isFirstInstall = !fs56.existsSync(configPath);
+      if (fs56.existsSync(configPath) && !options.force) {
         try {
-          const existing = JSON.parse(fs55.readFileSync(configPath, "utf-8"));
+          const existing = JSON.parse(fs56.readFileSync(configPath, "utf-8"));
           const settings = existing.settings ?? {};
           if (settings.mode !== chosenMode) {
             settings.mode = chosenMode;
             existing.settings = settings;
-            fs55.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
+            fs56.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
             console.log(chalk16.green(`\u2705 Mode updated: ${chosenMode}`));
           } else {
             console.log(chalk16.blue(`\u2139\uFE0F  Config already exists: ${configPath}`));
@@ -50322,9 +50626,9 @@ function registerInitCommand(program2) {
           ...DEFAULT_CONFIG,
           settings: { ...DEFAULT_CONFIG.settings, mode: chosenMode }
         };
-        const dir = path53.dirname(configPath);
-        if (!fs55.existsSync(dir)) fs55.mkdirSync(dir, { recursive: true });
-        fs55.writeFileSync(configPath, JSON.stringify(configToSave, null, 2) + "\n");
+        const dir = path54.dirname(configPath);
+        if (!fs56.existsSync(dir)) fs56.mkdirSync(dir, { recursive: true });
+        fs56.writeFileSync(configPath, JSON.stringify(configToSave, null, 2) + "\n");
         console.log(chalk16.green(`\u2705 Config created: ${configPath}`));
         console.log(chalk16.gray(`   Mode: ${chosenMode}`));
       }
@@ -50376,8 +50680,13 @@ function registerInitCommand(program2) {
               console.log(chalk16.gray("     You can try again later with: node9 daemon install"));
             }
           }
+        } else if (isDaemonServiceEnabled()) {
+          console.log(chalk16.green("  \u2713 Daemon login service already installed & enabled"));
         } else {
-          console.log(chalk16.green("  \u2713 Daemon login service already installed"));
+          const healed = ensureAutostartHealthy(!!getConfig().settings.autoStartDaemon);
+          console.log(
+            healed === "repaired" ? chalk16.green("  \u2713 Re-enabled daemon login service (was installed but disabled)") : chalk16.gray("  \xB7 Daemon login service is disabled (autostart off) \u2014 left as-is")
+          );
         }
         if (!isTestingMode()) {
           process.stdout.write(chalk16.dim("  Starting daemon..."));
@@ -50422,11 +50731,11 @@ init_agent_wiring();
 init_setup();
 init_hook_baseline();
 import chalk17 from "chalk";
-import fs56 from "fs";
+import fs57 from "fs";
 var hasHookSurface = (a) => a.hooks.length > 0;
 function backupForHeal(file) {
   try {
-    if (file && fs56.existsSync(file)) fs56.copyFileSync(file, `${file}.node9-heal-bak`);
+    if (file && fs57.existsSync(file)) fs57.copyFileSync(file, `${file}.node9-heal-bak`);
   } catch {
   }
 }
@@ -50593,7 +50902,7 @@ function registerConnectCommand(program2) {
 }
 // src/cli/commands/undo.ts
-import path54 from "path";
+import path55 from "path";
 import chalk20 from "chalk";
 // src/tui/undo-navigator.ts
@@ -50752,7 +51061,7 @@ function findMatchingCwd(startDir, history) {
   let dir = startDir;
   while (true) {
     if (cwds.has(dir)) return dir;
-    const parent = path54.dirname(dir);
+    const parent = path55.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -51386,18 +51695,18 @@ function registerMcpGatewayCommand(program2) {
 // src/mcp-server/index.ts
 import readline5 from "readline";
-import fs58 from "fs";
-import os51 from "os";
-import path56 from "path";
+import fs59 from "fs";
+import os53 from "os";
+import path57 from "path";
 import { spawnSync as spawnSync4 } from "child_process";
 init_core();
 init_daemon();
 init_shields();
 // src/auth/egress-config.ts
-import fs57 from "fs";
-import os50 from "os";
-import path55 from "path";
+import fs58 from "fs";
+import os52 from "os";
+import path56 from "path";
 var DEFAULT_EGRESS = {
   enabled: false,
   mode: "review",
@@ -51406,12 +51715,12 @@ var DEFAULT_EGRESS = {
   allowPrivate: true
 };
 function egressConfigPath() {
-  return path55.join(os50.homedir(), ".node9", "config.json");
+  return path56.join(os52.homedir(), ".node9", "config.json");
 }
 function readEgressRawConfig() {
   let text;
   try {
-    text = fs57.readFileSync(egressConfigPath(), "utf8");
+    text = fs58.readFileSync(egressConfigPath(), "utf8");
   } catch (err2) {
     if (err2.code === "ENOENT") return {};
     throw err2;
@@ -51426,8 +51735,8 @@ function readEgressRawConfig() {
 }
 function writeEgressRawConfig(config) {
   const p = egressConfigPath();
-  fs57.mkdirSync(path55.dirname(p), { recursive: true });
-  fs57.writeFileSync(p, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs58.mkdirSync(path56.dirname(p), { recursive: true });
+  fs58.writeFileSync(p, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function applyEgress(config, change) {
   const policy = config.policy = config.policy ?? {};
@@ -51812,13 +52121,13 @@ function handleStatus() {
   lines.push(`Active shields: ${activeShields.length > 0 ? activeShields.join(", ") : "none"}`);
   lines.push(`Smart rules: ${config.policy.smartRules.length} loaded`);
   lines.push(`DLP: ${config.policy.dlp?.enabled !== false ? "enabled" : "disabled"}`);
-  const projectConfig = path56.join(process.cwd(), "node9.config.json");
-  const globalConfig = path56.join(os51.homedir(), ".node9", "config.json");
+  const projectConfig = path57.join(process.cwd(), "node9.config.json");
+  const globalConfig = path57.join(os53.homedir(), ".node9", "config.json");
   lines.push(
-    `Project config (node9.config.json): ${fs58.existsSync(projectConfig) ? "present" : "not found"}`
+    `Project config (node9.config.json): ${fs59.existsSync(projectConfig) ? "present" : "not found"}`
   );
   lines.push(
-    `Global config (~/.node9/config.json): ${fs58.existsSync(globalConfig) ? "present" : "not found"}`
+    `Global config (~/.node9/config.json): ${fs59.existsSync(globalConfig) ? "present" : "not found"}`
   );
   return lines.join("\n");
 }
@@ -51924,21 +52233,21 @@ function handleEgressDeny(args) {
   addEgressHost("deny", host);
   return `Denied egress to ${host} (deny always wins over allow).`;
 }
-var GLOBAL_CONFIG_PATH = path56.join(os51.homedir(), ".node9", "config.json");
+var GLOBAL_CONFIG_PATH = path57.join(os53.homedir(), ".node9", "config.json");
 var APPROVER_CHANNELS = ["native", "browser", "cloud", "terminal"];
 function readGlobalConfigRaw() {
   try {
-    if (fs58.existsSync(GLOBAL_CONFIG_PATH)) {
-      return JSON.parse(fs58.readFileSync(GLOBAL_CONFIG_PATH, "utf-8"));
+    if (fs59.existsSync(GLOBAL_CONFIG_PATH)) {
+      return JSON.parse(fs59.readFileSync(GLOBAL_CONFIG_PATH, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function writeGlobalConfigRaw(data) {
-  const dir = path56.dirname(GLOBAL_CONFIG_PATH);
-  if (!fs58.existsSync(dir)) fs58.mkdirSync(dir, { recursive: true });
-  fs58.writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(data, null, 2) + "\n");
+  const dir = path57.dirname(GLOBAL_CONFIG_PATH);
+  if (!fs59.existsSync(dir)) fs59.mkdirSync(dir, { recursive: true });
+  fs59.writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(data, null, 2) + "\n");
 }
 function handleApproverList() {
   const config = getConfig();
@@ -51982,9 +52291,9 @@ function handleApproverSet(args) {
 function handleAuditGet(args) {
   const limit = Math.min(typeof args.limit === "number" ? args.limit : 20, 100);
   const filter = typeof args.filter === "string" && args.filter !== "all" ? args.filter : null;
-  const auditPath = path56.join(os51.homedir(), ".node9", "audit.log");
-  if (!fs58.existsSync(auditPath)) return "No audit log found.";
-  const rawLines = fs58.readFileSync(auditPath, "utf-8").trim().split("\n").filter(Boolean);
+  const auditPath = path57.join(os53.homedir(), ".node9", "audit.log");
+  if (!fs59.existsSync(auditPath)) return "No audit log found.";
+  const rawLines = fs59.readFileSync(auditPath, "utf-8").trim().split("\n").filter(Boolean);
   const parsed = [];
   for (const line of rawLines) {
     try {
@@ -52358,7 +52667,7 @@ function registerTrustCommand(program2) {
 // src/cli/commands/mcp-pin.ts
 init_mcp_pin();
 import chalk24 from "chalk";
-import fs59 from "fs";
+import fs60 from "fs";
 // src/cli/commands/mcp-gateway-cmd.ts
 init_mcp_wrap();
@@ -52565,7 +52874,7 @@ function registerMcpPinCommand(program2) {
     let repoCorrupt = false;
     if (found.source === "repo") {
       try {
-        const raw = fs59.readFileSync(found.path, "utf-8");
+        const raw = fs60.readFileSync(found.path, "utf-8");
         const parsed = JSON.parse(raw);
         repoEntries = parsed.servers ?? {};
       } catch {
@@ -53066,8 +53375,8 @@ import chalk30 from "chalk";
 // src/ci-check/fetch.ts
 var import_undici = __toESM(require_undici());
-import fs60 from "fs";
-import path57 from "path";
+import fs61 from "fs";
+import path58 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 var cachedGhToken;
 function resolveGitHubToken() {
@@ -53150,7 +53459,7 @@ function parseRepoUrl(input) {
 function isLocalPath(input) {
   if (input.startsWith(".") || input.startsWith("/") || input.startsWith("~")) return true;
   try {
-    return fs60.existsSync(input) && fs60.statSync(input).isDirectory();
+    return fs61.existsSync(input) && fs61.statSync(input).isDirectory();
   } catch {
     return false;
   }
@@ -53265,10 +53574,10 @@ function readLocalTree(dir) {
   const files = [];
   const notes = [];
   const add = (rel) => {
-    const abs = path57.join(root, rel);
+    const abs = path58.join(root, rel);
     try {
-      if (fs60.existsSync(abs) && fs60.statSync(abs).isFile()) {
-        files.push({ path: rel, content: fs60.readFileSync(abs, "utf8") });
+      if (fs61.existsSync(abs) && fs61.statSync(abs).isFile()) {
+        files.push({ path: rel, content: fs61.readFileSync(abs, "utf8") });
       }
     } catch {
     }
@@ -53288,7 +53597,7 @@ function readLocalTree(dir) {
     dirsVisited++;
     let entries;
     try {
-      entries = fs60.readdirSync(path57.join(root, relDir), { withFileTypes: true });
+      entries = fs61.readdirSync(path58.join(root, relDir), { withFileTypes: true });
     } catch {
       return;
     }
@@ -53309,11 +53618,11 @@ function readLocalTree(dir) {
       `repo is large \u2014 some agent-surface files may be INCOMPLETE (capped at ${MAX_SURFACE_FILES} files / ${MAX_DIRS} dirs).`
     );
   for (const rel of matches) collect(rel);
-  const wfDir = path57.join(root, WORKFLOW_DIR);
+  const wfDir = path58.join(root, WORKFLOW_DIR);
   try {
-    if (fs60.existsSync(wfDir)) {
-      for (const name of fs60.readdirSync(wfDir)) {
-        if (/\.ya?ml$/.test(name)) add(path57.join(WORKFLOW_DIR, name));
+    if (fs61.existsSync(wfDir)) {
+      for (const name of fs61.readdirSync(wfDir)) {
+        if (/\.ya?ml$/.test(name)) add(path58.join(WORKFLOW_DIR, name));
       }
     }
   } catch {
@@ -53456,6 +53765,38 @@ function collectTools(steps) {
   }
   return s;
 }
+function toolTokens(blob) {
+  const out = [];
+  let buf = "";
+  let inParen = false;
+  const flush = () => {
+    const t = buf.replace(/[[\]"'`\r\n]/g, "").trim();
+    if (t) out.push(t);
+    buf = "";
+  };
+  for (const ch of blob) {
+    if (ch === "(") inParen = true;
+    else if (ch === ")") inParen = false;
+    if (!inParen && (ch === "," || /\s/.test(ch))) {
+      flush();
+      continue;
+    }
+    buf += ch;
+  }
+  flush();
+  return out;
+}
+function matchedBroadTools(blob) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const tok of toolTokens(blob)) {
+    if (!BROAD_TOOL_RE.test(`,${tok},`)) continue;
+    if (seen.has(tok)) continue;
+    seen.add(tok);
+    out.push(tok.length > 40 ? tok.slice(0, 40) + "\u2026" : tok);
+  }
+  return out;
+}
 function untrustedHeadCheckout(steps) {
   for (const step of steps) {
     if (!step.uses || !/actions\/checkout/.test(step.uses)) continue;
@@ -53586,7 +53927,7 @@ function severityFromScore(score) {
   if (score >= 1) return "advisory";
   return null;
 }
-function analyzeWorkflow(path70, content) {
+function analyzeWorkflow(path71, content) {
   let raw;
   try {
     raw = parseYaml(content) ?? {};
@@ -53682,7 +54023,12 @@ function analyzeWorkflow(path70, content) {
   if (head === "root") signals.push("checks out the untrusted PR head into the workspace root");
   if (head === "subdir") signals.push("checks out the untrusted PR head into an isolated subdir");
   if (promptUntrusted) signals.push("feeds untrusted PR/issue text to the agent");
-  if (broadTools) signals.push("agent has broad/write-capable tools (Bash/Write/curl/git push)");
+  if (broadTools) {
+    const names = matchedBroadTools(toolsBlob);
+    signals.push(
+      names.length ? `agent has broad/write-capable tools: ${names.map((n) => `\`${n}\``).join(", ")}` : "agent has broad/write-capable tool grants"
+    );
+  }
   if (bypassActive) signals.push('allowed_non_write_users: "*" \u2014 any user can trigger the agent');
   if (elevated) signals.push("elevated permissions (contents/id-token: write)");
   if (pat) signals.push("a static PAT is exposed to the agent (recoverable via injection)");
@@ -53707,7 +54053,7 @@ function analyzeWorkflow(path70, content) {
     dimension: "workflows",
     severity,
     title,
-    file: path70,
+    file: path71,
     signals,
     mitigations: mitigations.length ? mitigations : void 0,
     fix: head === "root" && privileged ? "Do not check out the untrusted PR head into the workspace root under a privileged trigger (pull_request_target/workflow_run) \u2014 check out the base ref, or isolate the head in a subdir (--add-dir). Add an actor gate and scope the agent tools." : head === "root" ? "This runs under `pull_request` (fork PRs get a read-only token), so the head checkout is low-risk today \u2014 keep it on `pull_request` (not `pull_request_target`) and keep the actor gate + scoped tools." : "Add/verify an actor gate, scope the agent tools to read-only, and env-deny secrets. See Anthropic\u2019s claude-code-action security doc."
@@ -53783,7 +54129,7 @@ function evalAgentJob(job, wf, raw, untrustedTrigger, reusable) {
   if (reusable && !loadedGun && SEVERITY_RANK2[severity] > SEVERITY_RANK2.medium) severity = "medium";
   return { severity, secrets, injectable, canReadEnv };
 }
-function analyzeWorkflowSecrets(path70, content) {
+function analyzeWorkflowSecrets(path71, content) {
   let raw;
   try {
     raw = parseYaml(content) ?? {};
@@ -53803,7 +54149,7 @@ function analyzeWorkflowSecrets(path70, content) {
     dimension: "data",
     severity: worst.severity,
     title: worst.severity === "advisory" ? "Secrets reachable by the agent \u2014 hardening" : "Exfiltratable secrets reachable by an injectable agent",
-    file: path70,
+    file: path71,
     signals: [
       `agent can reach: ${worst.secrets.map((s) => s.name).join(", ")}`,
       worst.injectable ? "the agent is externally triggerable (untrusted trigger, no gate)" : "gated / not externally triggerable \u2014 latent risk only",
@@ -53830,7 +54176,7 @@ function hookCommands(hooks) {
   }
   return out;
 }
-function analyzeAgentConfig(path70, content) {
+function analyzeAgentConfig(path71, content) {
   let cfg;
   try {
     cfg = JSON.parse(content);
@@ -53849,7 +54195,7 @@ function analyzeAgentConfig(path70, content) {
       dimension: "toolRules",
       severity: high ? "high" : "medium",
       title: high ? "Agent hook runs UNPINNED/remote third-party code on every action" : "Agent hook runs third-party code in the agent hot path",
-      file: path70,
+      file: path71,
       signals: [
         `hook command: \`${cmd.slice(0, 120)}\``,
         remoteExec ? "fetch-and-run (curl|wget / pipe-to-shell) \u2014 unpinnable remote code execution on every contributor" : unpinned ? "unpinned \u2014 a compromised/yanked package = code execution on every contributor" : "pinned, but still a standing supply-chain dependency in the agent hot path"
@@ -53869,7 +54215,7 @@ function analyzeAgentConfig(path70, content) {
       dimension: "toolRules",
       severity: hasBackstop ? "medium" : "high",
       title: hasBackstop ? "Committed agent config pre-authorizes broad tools" : "Committed agent config pre-authorizes broad tools with no deny backstop",
-      file: path70,
+      file: path71,
       signals: [
         `broad allow(s): ${broad.slice(0, 5).join(", ")}`,
         hasBackstop ? "a `deny` list backstops the broad allow" : "no `deny` entry covers Bash/Write/Edit \u2014 every contributor is pre-authorized for catastrophic tools"
@@ -53882,16 +54228,16 @@ function analyzeAgentConfig(path70, content) {
 // src/ci-check/mcp.ts
 init_dist();
-function analyzeMcp(path70, content) {
+function analyzeMcp(path71, content) {
   let cfg;
   try {
     cfg = JSON.parse(content);
   } catch {
     return [];
   }
-  return analyzeMcpServers(cfg.mcpServers ?? {}, path70);
+  return analyzeMcpServers(cfg.mcpServers ?? {}, path71);
 }
-function analyzeMcpServers(servers, path70) {
+function analyzeMcpServers(servers, path71) {
   const findings = [];
   for (const [name, srv] of Object.entries(servers ?? {})) {
     if (!srv || srv.disabled) continue;
@@ -53902,7 +54248,7 @@ function analyzeMcpServers(servers, path70) {
         dimension: "mcp",
         severity: "medium",
         title: `MCP server "${name}" runs an unpinned executable`,
-        file: path70,
+        file: path71,
         signals: [`\`${argv.slice(0, 120)}\` \u2014 unversioned/@latest npx`],
         fix: "Pin the MCP server package to an exact version so a PR (or a registry compromise) can\u2019t swap the toolchain."
       });
@@ -53916,7 +54262,7 @@ function analyzeMcpServers(servers, path70) {
           dimension: "mcp",
           severity: "high",
           title: `MCP server "${name}" has an inline credential`,
-          file: path70,
+          file: path71,
           signals: [
             `env.${k} matches ${hit.patternName} \u2014 agent-reachable secret committed to the repo`
           ],
@@ -53930,7 +54276,7 @@ function analyzeMcpServers(servers, path70) {
 // src/ci-check/codex.ts
 import { parse as parseToml5 } from "smol-toml";
-function analyzeCodexConfig(path70, content) {
+function analyzeCodexConfig(path71, content) {
   let cfg;
   try {
     cfg = parseToml5(content);
@@ -53938,7 +54284,7 @@ function analyzeCodexConfig(path70, content) {
     return [];
   }
   const findings = [];
-  findings.push(...analyzeMcpServers(cfg.mcp_servers ?? {}, path70));
+  findings.push(...analyzeMcpServers(cfg.mcp_servers ?? {}, path71));
   const sandbox = typeof cfg.sandbox_mode === "string" ? cfg.sandbox_mode : "";
   const approval = typeof cfg.approval_policy === "string" ? cfg.approval_policy : "";
   const fullAccess = /danger-full-access/i.test(sandbox);
@@ -53953,7 +54299,7 @@ function analyzeCodexConfig(path70, content) {
       dimension: "toolRules",
       severity: fullAccess ? "high" : "medium",
       title: fullAccess ? "Codex config grants a full-access sandbox" : "Codex config never requires approval",
-      file: path70,
+      file: path71,
       signals,
       fix: 'Commit a least-privilege Codex config: prefer `sandbox_mode = "read-only"` (or `"workspace-write"`) and `approval_policy = "on-request"`/`"on-failure"`. A repo-committed config applies to every contributor who runs Codex here.'
     });
@@ -54009,10 +54355,10 @@ function decodeSuspiciousBase64(text) {
   }
   return out;
 }
-function mk(severity, title, signals, fix, path70) {
-  return { check: "CI-6", dimension: "instructions", severity, title, file: path70, signals, fix };
+function mk(severity, title, signals, fix, path71) {
+  return { check: "CI-6", dimension: "instructions", severity, title, file: path71, signals, fix };
 }
-function analyzeInstructionFile(path70, content) {
+function analyzeInstructionFile(path71, content) {
   const findings = [];
   const decoded = decodeSuspiciousBase64(content);
   if (TAG_CHARS.test(content))
@@ -54024,7 +54370,7 @@ function analyzeInstructionFile(path70, content) {
           "contains Unicode tag characters (U+E0000\u2013E007F) \u2014 an invisible instruction-smuggling channel with no legitimate use in text"
         ],
         "Remove the tag characters. Instruction files must be plain, reviewable text.",
-        path70
+        path71
       )
     );
   if (BIDI_OVERRIDE.test(content))
@@ -54036,7 +54382,7 @@ function analyzeInstructionFile(path70, content) {
           "contains a bidi override (U+202D/U+202E) \u2014 a Trojan-Source technique that visually reorders text so a human reads something different from what the agent parses"
         ],
         "Remove the bidi override characters.",
-        path70
+        path71
       )
     );
   else if (BIDI_EMBED_ISOLATE.test(content))
@@ -54048,7 +54394,7 @@ function analyzeInstructionFile(path70, content) {
           "contains bidi embed/isolate characters (U+202A\u2013202C / U+2066\u20132069) \u2014 legitimate in right-to-left text, but confirm they are not being used to hide or reorder instructions"
         ],
         "Confirm the bidi marks are legitimate RTL formatting; remove otherwise.",
-        path70
+        path71
       )
     );
   const zw = suspiciousZeroWidth(content);
@@ -54062,7 +54408,7 @@ function analyzeInstructionFile(path70, content) {
           revealed ? "a zero-width character conceals a prompt-override directive that only appears once the hidden characters are stripped" : "a zero-width character splits a visible Latin word \u2014 a concealment technique (hides text from human review while the agent reads it as contiguous)"
         ],
         "Remove the zero-width characters. Instruction files must be plain, reviewable text.",
-        path70
+        path71
       )
     );
   }
@@ -54078,7 +54424,7 @@ function analyzeInstructionFile(path70, content) {
           `contains a prompt-override / role-impersonation directive (\`${m[0].slice(0, 60).trim()}\`)${ovEnc ? " \u2014 concealed in a base64 blob" : ""}`
         ],
         "Remove the override text. An instruction file should not tell the agent to ignore its own rules.",
-        path70
+        path71
       )
     );
   }
@@ -54090,7 +54436,7 @@ function analyzeInstructionFile(path70, content) {
         "Instruction directs the agent to fetch and run remote code",
         [`\`${fo[0].slice(0, 70).trim()}\` \u2014 fetch-and-obey, outside an install/setup section`],
         "Do not instruct the agent to pipe remote content into a shell; pin and vendor scripts instead.",
-        path70
+        path71
       )
     );
   }
@@ -54102,7 +54448,7 @@ function analyzeInstructionFile(path70, content) {
         "Instruction points the agent at credential material",
         [`references \`${sp[0].slice(0, 50).trim()}\` \u2014 directs the agent toward secrets`],
         "Do not reference credential files or paths in agent instructions.",
-        path70
+        path71
       )
     );
   }
@@ -54114,7 +54460,7 @@ function analyzeInstructionFile(path70, content) {
         "Instruction directs the agent to send data to an external endpoint",
         [`\`${ex[0].slice(0, 70).trim()}\` \u2014 possible exfiltration directive`],
         "Remove external post/upload directives from agent instructions.",
-        path70
+        path71
       )
     );
   }
@@ -54416,17 +54762,17 @@ import chalk32 from "chalk";
 // src/shields/jail.ts
 init_build();
 init_shields();
-import fs61 from "fs";
-import os52 from "os";
-import path58 from "path";
+import fs62 from "fs";
+import os54 from "os";
+import path59 from "path";
 var USER_JAIL_SHIELD = "user-jail";
 function jailStorePath() {
-  return path58.join(os52.homedir(), ".node9", "jail-paths.json");
+  return path59.join(os54.homedir(), ".node9", "jail-paths.json");
 }
 function readJailPaths() {
   let text;
   try {
-    text = fs61.readFileSync(jailStorePath(), "utf8");
+    text = fs62.readFileSync(jailStorePath(), "utf8");
   } catch (err2) {
     if (err2.code === "ENOENT") return [];
     throw err2;
@@ -54444,8 +54790,8 @@ function readJailPaths() {
 }
 function writeJailPaths(paths) {
   const p = jailStorePath();
-  fs61.mkdirSync(path58.dirname(p), { recursive: true });
-  fs61.writeFileSync(p, JSON.stringify({ paths }, null, 2) + "\n", { mode: 384 });
+  fs62.mkdirSync(path59.dirname(p), { recursive: true });
+  fs62.writeFileSync(p, JSON.stringify({ paths }, null, 2) + "\n", { mode: 384 });
 }
 function addJailPath(rawPath, verdict) {
   const norm = rawPath.trim();
@@ -54467,14 +54813,14 @@ function removeJailPath(rawPath) {
   return { removed, paths: after };
 }
 function regenerateUserJail(paths) {
-  const file = path58.join(USER_SHIELDS_DIR_PATH, `${USER_JAIL_SHIELD}.json`);
+  const file = path59.join(USER_SHIELDS_DIR_PATH, `${USER_JAIL_SHIELD}.json`);
   if (paths.length === 0) {
     const active2 = readActiveShields();
     if (active2.includes(USER_JAIL_SHIELD)) {
       writeActiveShields(active2.filter((s) => s !== USER_JAIL_SHIELD));
     }
     try {
-      fs61.rmSync(file, { force: true });
+      fs62.rmSync(file, { force: true });
     } catch {
     }
     return;
@@ -54589,13 +54935,13 @@ function registerJailCommand(program2) {
 // src/cli/commands/sandbox.ts
 init_config();
 import chalk33 from "chalk";
-import fs64 from "fs";
-import path61 from "path";
+import fs65 from "fs";
+import path62 from "path";
 import { spawnSync as spawnSync6 } from "child_process";
 // src/sandbox/config.ts
-import fs62 from "fs";
-import path59 from "path";
+import fs63 from "fs";
+import path60 from "path";
 import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
 var SANDBOX_CONFIG_FILE = "node9.sandbox.yaml";
 var FORBIDDEN_ENV = /* @__PURE__ */ new Set(["NODE9_API_KEY", "NODE9_API_URL"]);
@@ -54668,16 +55014,16 @@ function scaffoldSandboxYaml(agent) {
   return header + stringifyYaml(defaultSandboxConfig(agent));
 }
 function sandboxConfigPath(cwd = process.cwd()) {
-  return path59.join(cwd, SANDBOX_CONFIG_FILE);
+  return path60.join(cwd, SANDBOX_CONFIG_FILE);
 }
 function loadSandboxConfig(cwd = process.cwd(), fallbackAgent = "claude") {
   const p = sandboxConfigPath(cwd);
-  if (!fs62.existsSync(p)) {
+  if (!fs63.existsSync(p)) {
     throw new Error(`sandbox: ${SANDBOX_CONFIG_FILE} not found \u2014 run \`node9 sandbox new\` first.`);
   }
   let raw;
   try {
-    raw = parseYaml2(fs62.readFileSync(p, "utf-8"));
+    raw = parseYaml2(fs63.readFileSync(p, "utf-8"));
   } catch (err2) {
     throw new Error(
       `sandbox: ${SANDBOX_CONFIG_FILE} is not valid YAML \u2014 ${err2.message}`
@@ -54736,13 +55082,13 @@ init_templates();
 // src/sandbox/runtime.ts
 init_templates();
-import fs63 from "fs";
-import os53 from "os";
-import path60 from "path";
+import fs64 from "fs";
+import os55 from "os";
+import path61 from "path";
 import crypto9 from "crypto";
 import { spawnSync as spawnSync5 } from "child_process";
 function sandboxDataDir(cwd = process.cwd()) {
-  return path60.join(cwd, ".node9", "sandbox", "data");
+  return path61.join(cwd, ".node9", "sandbox", "data");
 }
 function detectEngine(engine) {
   const r = spawnSync5(engine, ["--version"], { encoding: "utf-8" });
@@ -54753,7 +55099,7 @@ function detectEngine(engine) {
 }
 function agentCredentialsMount(agent) {
   const rel = agent === "codex" ? ".codex/auth.json" : ".claude/.credentials.json";
-  return { hostPath: path60.join(os53.homedir(), rel), target: `/home/${RUN_AS_USER}/${rel}` };
+  return { hostPath: path61.join(os55.homedir(), rel), target: `/home/${RUN_AS_USER}/${rel}` };
 }
 function buildRunArgs(opts) {
   const { config, workspaceHostPath, dataHostPath, allowlistHostPath, agentArgs } = opts;
@@ -54763,7 +55109,7 @@ function buildRunArgs(opts) {
   args.push("-v", `${allowlistHostPath}:${ALLOWED_DOMAINS_PATH}:ro`);
   if (config.node9.mountAgentCredentials) {
     const creds = agentCredentialsMount(config.agent);
-    if (fs63.existsSync(creds.hostPath)) {
+    if (fs64.existsSync(creds.hostPath)) {
       args.push("-v", `${creds.hostPath}:${creds.target}`);
     }
   }
@@ -54781,30 +55127,30 @@ function imageContentHash(dockerfile, entrypoint) {
   return crypto9.createHash("sha256").update(dockerfile).update("\0").update(entrypoint).digest("hex").slice(0, 16);
 }
 function sandboxBuildDir(cwd = process.cwd()) {
-  return path60.join(cwd, ".node9", "sandbox", "build");
+  return path61.join(cwd, ".node9", "sandbox", "build");
 }
 function writeBuildContext(cwd, dockerfile, entrypoint) {
   const dir = sandboxBuildDir(cwd);
-  fs63.mkdirSync(dir, { recursive: true });
-  fs63.writeFileSync(path60.join(dir, "Dockerfile"), dockerfile);
-  fs63.writeFileSync(path60.join(dir, "entrypoint.sh"), entrypoint);
+  fs64.mkdirSync(dir, { recursive: true });
+  fs64.writeFileSync(path61.join(dir, "Dockerfile"), dockerfile);
+  fs64.writeFileSync(path61.join(dir, "entrypoint.sh"), entrypoint);
   return dir;
 }
 function writeAllowlist(cwd, hosts) {
-  const dir = path60.join(cwd, ".node9", "sandbox");
-  fs63.mkdirSync(dir, { recursive: true });
-  const p = path60.join(dir, "allowed-domains.txt");
-  fs63.writeFileSync(p, hosts.join("\n") + "\n");
+  const dir = path61.join(cwd, ".node9", "sandbox");
+  fs64.mkdirSync(dir, { recursive: true });
+  const p = path61.join(dir, "allowed-domains.txt");
+  fs64.writeFileSync(p, hosts.join("\n") + "\n");
   return p;
 }
 function resolveHomePath(p) {
-  return p.startsWith("~") ? path60.join(os53.homedir(), p.slice(1)) : path60.resolve(p);
+  return p.startsWith("~") ? path61.join(os55.homedir(), p.slice(1)) : path61.resolve(p);
 }
 // src/cli/commands/sandbox.ts
 function seedDataDirConfig(dataDir, sandbox) {
-  fs64.mkdirSync(dataDir, { recursive: true });
-  const configPath = path61.join(dataDir, "config.json");
+  fs65.mkdirSync(dataDir, { recursive: true });
+  const configPath = path62.join(dataDir, "config.json");
   const seed = {
     settings: {
       approvers: {
@@ -54815,7 +55161,7 @@ function seedDataDirConfig(dataDir, sandbox) {
       }
     }
   };
-  fs64.writeFileSync(configPath, JSON.stringify(seed, null, 2), { mode: 384 });
+  fs65.writeFileSync(configPath, JSON.stringify(seed, null, 2), { mode: 384 });
 }
 function registerSandboxCommand(program2, version2) {
   const node9Version2 = pinnedNode9Version(version2);
@@ -54823,13 +55169,13 @@ function registerSandboxCommand(program2, version2) {
   cmd.command("new").description(`Scaffold ${SANDBOX_CONFIG_FILE} in this project`).option("--agent <agent>", "claude (default) or codex", "claude").action((opts) => {
     const agent = opts.agent === "codex" ? "codex" : "claude";
     const p = sandboxConfigPath();
-    if (fs64.existsSync(p)) {
+    if (fs65.existsSync(p)) {
       console.log(
         chalk33.yellow(`  ${SANDBOX_CONFIG_FILE} already exists \u2014 leaving it untouched.`)
       );
       return;
     }
-    fs64.writeFileSync(p, scaffoldSandboxYaml(agent));
+    fs65.writeFileSync(p, scaffoldSandboxYaml(agent));
     console.log(
       chalk33.green(`  \u2713 wrote ${SANDBOX_CONFIG_FILE}`) + chalk33.dim(` (agent: ${agent})`)
     );
@@ -54869,8 +55215,8 @@ function registerSandboxCommand(program2, version2) {
     const buildDir = writeBuildContext(cwd, dockerfile, entrypoint);
     const hash = imageContentHash(dockerfile, entrypoint);
     const image = sandbox.runtime.image;
-    const hashFile = path61.join(sandboxBuildDir(cwd), ".image-hash");
-    const lastHash = fs64.existsSync(hashFile) ? fs64.readFileSync(hashFile, "utf-8").trim() : "";
+    const hashFile = path62.join(sandboxBuildDir(cwd), ".image-hash");
+    const lastHash = fs65.existsSync(hashFile) ? fs65.readFileSync(hashFile, "utf-8").trim() : "";
     const imageExists = spawnSync6(sandbox.runtime.engine, ["image", "inspect", image], { stdio: "ignore" }).status === 0;
     const needBuild = sandbox.runtime.rebuild === "always" || !imageExists || sandbox.runtime.rebuild !== "never" && lastHash !== hash;
     if (needBuild) {
@@ -54882,7 +55228,7 @@ function registerSandboxCommand(program2, version2) {
         console.error(chalk33.red("  build failed."));
         process.exit(b.status ?? 1);
       }
-      fs64.writeFileSync(hashFile, hash);
+      fs65.writeFileSync(hashFile, hash);
     }
     const dataDir = sandboxDataDir(cwd);
     seedDataDirConfig(dataDir, sandbox);
@@ -54896,7 +55242,7 @@ function registerSandboxCommand(program2, version2) {
     });
     if (sandbox.node9.mountAgentCredentials) {
       const creds = agentCredentialsMount(sandbox.agent);
-      if (fs64.existsSync(creds.hostPath)) {
+      if (fs65.existsSync(creds.hostPath)) {
         console.log(chalk33.dim(`  mounting ${creds.hostPath} (agent credentials, rw)`));
       } else {
         console.log(
@@ -54912,20 +55258,20 @@ function registerSandboxCommand(program2, version2) {
     process.exit(r.status ?? 0);
   });
   cmd.command("tail").description("Stream the sandbox's audit log (host-side)").action(() => {
-    const auditPath = path61.join(sandboxDataDir(), "audit.log");
-    if (!fs64.existsSync(auditPath)) {
+    const auditPath = path62.join(sandboxDataDir(), "audit.log");
+    if (!fs65.existsSync(auditPath)) {
       console.log(chalk33.dim("  no sandbox audit yet."));
       return;
     }
     spawnSync6("tail", ["-f", auditPath], { stdio: "inherit" });
   });
   cmd.command("logs").description("Dump the sandbox's audit log").action(() => {
-    const auditPath = path61.join(sandboxDataDir(), "audit.log");
-    if (!fs64.existsSync(auditPath)) {
+    const auditPath = path62.join(sandboxDataDir(), "audit.log");
+    if (!fs65.existsSync(auditPath)) {
       console.log(chalk33.dim("  no sandbox audit yet."));
       return;
     }
-    process.stdout.write(fs64.readFileSync(auditPath, "utf-8"));
+    process.stdout.write(fs65.readFileSync(auditPath, "utf-8"));
   });
   cmd.command("clean").description("Remove the sandbox image, build context, and data").action(() => {
     const cwd = process.cwd();
@@ -54939,7 +55285,7 @@ function registerSandboxCommand(program2, version2) {
         stdio: "ignore"
       });
     }
-    fs64.rmSync(path61.join(cwd, ".node9", "sandbox"), { recursive: true, force: true });
+    fs65.rmSync(path62.join(cwd, ".node9", "sandbox"), { recursive: true, force: true });
     console.log(chalk33.green("  \u2713 sandbox image + build + data removed."));
   });
 }
@@ -54950,9 +55296,9 @@ init_litellm();
 init_cost_gemini();
 init_cost_codex();
 import chalk34 from "chalk";
-import fs65 from "fs";
-import path62 from "path";
-import os54 from "os";
+import fs66 from "fs";
+import path63 from "path";
+import os56 from "os";
 function modelPrice(model) {
   const t = pricingFor(model);
   if (!t) return null;
@@ -54969,10 +55315,10 @@ function encodeProjectPath(projectPath) {
 }
 function sessionJsonlPath(projectPath, sessionId) {
   const encoded = encodeProjectPath(projectPath);
-  return path62.join(os54.homedir(), ".claude", "projects", encoded, `${sessionId}.jsonl`);
+  return path63.join(os56.homedir(), ".claude", "projects", encoded, `${sessionId}.jsonl`);
 }
 function projectLabel(projectPath) {
-  return projectPath.replace(os54.homedir(), "~");
+  return projectPath.replace(os56.homedir(), "~");
 }
 function parseHistoryLines(lines) {
   const entries = [];
@@ -55041,10 +55387,10 @@ function parseSessionLines(lines) {
   return { toolCalls, costUSD, hasSnapshot, modifiedFiles };
 }
 function loadAuditEntries(auditPath) {
-  const aPath = auditPath ?? path62.join(os54.homedir(), ".node9", "audit.log");
+  const aPath = auditPath ?? path63.join(os56.homedir(), ".node9", "audit.log");
   let raw;
   try {
-    raw = fs65.readFileSync(aPath, "utf-8");
+    raw = fs66.readFileSync(aPath, "utf-8");
   } catch {
     return [];
   }
@@ -55080,8 +55426,8 @@ function auditEntriesInWindow(entries, windowStart, windowEnd) {
   return result;
 }
 function buildGeminiSessions(days, allAuditEntries) {
-  const tmpDir = path62.join(os54.homedir(), ".gemini", "tmp");
-  if (!fs65.existsSync(tmpDir)) return [];
+  const tmpDir = path63.join(os56.homedir(), ".gemini", "tmp");
+  if (!fs66.existsSync(tmpDir)) return [];
   const cutoff = days !== null ? (() => {
     const d = /* @__PURE__ */ new Date();
     d.setDate(d.getDate() - days);
@@ -55090,35 +55436,35 @@ function buildGeminiSessions(days, allAuditEntries) {
   })() : null;
   let slugDirs;
   try {
-    slugDirs = fs65.readdirSync(tmpDir);
+    slugDirs = fs66.readdirSync(tmpDir);
   } catch {
     return [];
   }
   const summaries = [];
   for (const slug2 of slugDirs) {
-    const slugPath = path62.join(tmpDir, slug2);
+    const slugPath = path63.join(tmpDir, slug2);
     try {
-      if (!fs65.statSync(slugPath).isDirectory()) continue;
+      if (!fs66.statSync(slugPath).isDirectory()) continue;
     } catch {
       continue;
     }
-    let projectRoot = path62.join(os54.homedir(), slug2);
+    let projectRoot = path63.join(os56.homedir(), slug2);
     try {
-      projectRoot = fs65.readFileSync(path62.join(slugPath, ".project_root"), "utf-8").trim();
+      projectRoot = fs66.readFileSync(path63.join(slugPath, ".project_root"), "utf-8").trim();
     } catch {
     }
-    const chatsDir = path62.join(slugPath, "chats");
-    if (!fs65.existsSync(chatsDir)) continue;
+    const chatsDir = path63.join(slugPath, "chats");
+    if (!fs66.existsSync(chatsDir)) continue;
     let chatFiles;
     try {
-      chatFiles = fs65.readdirSync(chatsDir).filter((f) => f.endsWith(".json"));
+      chatFiles = fs66.readdirSync(chatsDir).filter((f) => f.endsWith(".json"));
     } catch {
       continue;
     }
     for (const chatFile of chatFiles) {
       let raw;
       try {
-        raw = fs65.readFileSync(path62.join(chatsDir, chatFile), "utf-8");
+        raw = fs66.readFileSync(path63.join(chatsDir, chatFile), "utf-8");
       } catch {
         continue;
       }
@@ -55198,8 +55544,8 @@ function buildGeminiSessions(days, allAuditEntries) {
   return summaries;
 }
 function buildCodexSessions(days, allAuditEntries) {
-  const sessionsBase = path62.join(os54.homedir(), ".codex", "sessions");
-  if (!fs65.existsSync(sessionsBase)) return [];
+  const sessionsBase = path63.join(os56.homedir(), ".codex", "sessions");
+  if (!fs66.existsSync(sessionsBase)) return [];
   const cutoff = days !== null ? (() => {
     const d = /* @__PURE__ */ new Date();
     d.setDate(d.getDate() - days);
@@ -55208,29 +55554,29 @@ function buildCodexSessions(days, allAuditEntries) {
   })() : null;
   const jsonlFiles = [];
   try {
-    for (const year of fs65.readdirSync(sessionsBase)) {
-      const yearPath = path62.join(sessionsBase, year);
+    for (const year of fs66.readdirSync(sessionsBase)) {
+      const yearPath = path63.join(sessionsBase, year);
       try {
-        if (!fs65.statSync(yearPath).isDirectory()) continue;
+        if (!fs66.statSync(yearPath).isDirectory()) continue;
       } catch {
         continue;
       }
-      for (const month of fs65.readdirSync(yearPath)) {
-        const monthPath = path62.join(yearPath, month);
+      for (const month of fs66.readdirSync(yearPath)) {
+        const monthPath = path63.join(yearPath, month);
         try {
-          if (!fs65.statSync(monthPath).isDirectory()) continue;
+          if (!fs66.statSync(monthPath).isDirectory()) continue;
         } catch {
           continue;
         }
-        for (const day of fs65.readdirSync(monthPath)) {
-          const dayPath = path62.join(monthPath, day);
+        for (const day of fs66.readdirSync(monthPath)) {
+          const dayPath = path63.join(monthPath, day);
           try {
-            if (!fs65.statSync(dayPath).isDirectory()) continue;
+            if (!fs66.statSync(dayPath).isDirectory()) continue;
           } catch {
             continue;
           }
-          for (const file of fs65.readdirSync(dayPath)) {
-            if (file.endsWith(".jsonl")) jsonlFiles.push(path62.join(dayPath, file));
+          for (const file of fs66.readdirSync(dayPath)) {
+            if (file.endsWith(".jsonl")) jsonlFiles.push(path63.join(dayPath, file));
           }
         }
       }
@@ -55242,7 +55588,7 @@ function buildCodexSessions(days, allAuditEntries) {
   for (const filePath of jsonlFiles) {
     let lines;
     try {
-      lines = fs65.readFileSync(filePath, "utf-8").split("\n");
+      lines = fs66.readFileSync(filePath, "utf-8").split("\n");
     } catch {
       continue;
     }
@@ -55328,10 +55674,10 @@ function buildCodexSessions(days, allAuditEntries) {
   return summaries;
 }
 function buildSessions(days, historyPath) {
-  const hPath = historyPath ?? path62.join(os54.homedir(), ".claude", "history.jsonl");
+  const hPath = historyPath ?? path63.join(os56.homedir(), ".claude", "history.jsonl");
   let historyRaw = "";
   try {
-    historyRaw = fs65.readFileSync(hPath, "utf-8");
+    historyRaw = fs66.readFileSync(hPath, "utf-8");
   } catch {
   }
   const cutoff = days !== null ? (() => {
@@ -55355,7 +55701,7 @@ function buildSessions(days, historyPath) {
     const jsonlFile = sessionJsonlPath(entry.project, entry.sessionId);
     let sessionLines = [];
     try {
-      sessionLines = fs65.readFileSync(jsonlFile, "utf-8").split("\n");
+      sessionLines = fs66.readFileSync(jsonlFile, "utf-8").split("\n");
     } catch {
     }
     const { toolCalls, costUSD, hasSnapshot, modifiedFiles } = parseSessionLines(sessionLines);
@@ -55749,12 +56095,12 @@ function registerSessionTaintCommand(program2) {
 // src/cli/commands/skill-pin.ts
 import chalk36 from "chalk";
-import fs66 from "fs";
-import os55 from "os";
-import path63 from "path";
+import fs67 from "fs";
+import os57 from "os";
+import path64 from "path";
 function wipeSkillSessions() {
   try {
-    fs66.rmSync(path63.join(os55.homedir(), ".node9", "skill-sessions"), {
+    fs67.rmSync(path64.join(os57.homedir(), ".node9", "skill-sessions"), {
       recursive: true,
       force: true
     });
@@ -55836,15 +56182,15 @@ function registerSkillPinCommand(program2) {
 }
 // src/cli/commands/decisions.ts
-import fs67 from "fs";
-import os56 from "os";
-import path64 from "path";
+import fs68 from "fs";
+import os58 from "os";
+import path65 from "path";
 import chalk37 from "chalk";
-var DECISIONS_FILE2 = path64.join(os56.homedir(), ".node9", "decisions.json");
+var DECISIONS_FILE2 = path65.join(os58.homedir(), ".node9", "decisions.json");
 function readDecisions() {
   try {
-    if (!fs67.existsSync(DECISIONS_FILE2)) return {};
-    const raw = fs67.readFileSync(DECISIONS_FILE2, "utf-8");
+    if (!fs68.existsSync(DECISIONS_FILE2)) return {};
+    const raw = fs68.readFileSync(DECISIONS_FILE2, "utf-8");
     const parsed = JSON.parse(raw);
     const out = {};
     for (const [k, v] of Object.entries(parsed)) {
@@ -55856,11 +56202,11 @@ function readDecisions() {
   }
 }
 function writeDecisions(d) {
-  const dir = path64.dirname(DECISIONS_FILE2);
-  if (!fs67.existsSync(dir)) fs67.mkdirSync(dir, { recursive: true });
+  const dir = path65.dirname(DECISIONS_FILE2);
+  if (!fs68.existsSync(dir)) fs68.mkdirSync(dir, { recursive: true });
   const tmp = `${DECISIONS_FILE2}.${process.pid}.tmp`;
-  fs67.writeFileSync(tmp, JSON.stringify(d, null, 2));
-  fs67.renameSync(tmp, DECISIONS_FILE2);
+  fs68.writeFileSync(tmp, JSON.stringify(d, null, 2));
+  fs68.renameSync(tmp, DECISIONS_FILE2);
 }
 function registerDecisionsCommand(program2) {
   const cmd = program2.command("decisions").description('Manage persistent "Always Allow" / "Always Deny" tool decisions');
@@ -55917,18 +56263,18 @@ Persistent decisions  (${entries.length})
 // src/cli/commands/dlp.ts
 import chalk38 from "chalk";
-import fs68 from "fs";
-import path65 from "path";
-import os57 from "os";
-var AUDIT_LOG = path65.join(os57.homedir(), ".node9", "audit.log");
-var RESOLVED_FILE = path65.join(os57.homedir(), ".node9", "dlp-resolved.json");
+import fs69 from "fs";
+import path66 from "path";
+import os59 from "os";
+var AUDIT_LOG = path66.join(os59.homedir(), ".node9", "audit.log");
+var RESOLVED_FILE = path66.join(os59.homedir(), ".node9", "dlp-resolved.json");
 var ANSI_RE = /\x1b(?:\[[0-9;?]*[a-zA-Z]|\][^\x07\x1b]*(?:\x07|\x1b\\)|[@-_])/g;
 function stripAnsi(s) {
   return s.replace(ANSI_RE, "");
 }
 function loadResolved() {
   try {
-    const raw = JSON.parse(fs68.readFileSync(RESOLVED_FILE, "utf-8"));
+    const raw = JSON.parse(fs69.readFileSync(RESOLVED_FILE, "utf-8"));
     return new Set(raw);
   } catch {
     return /* @__PURE__ */ new Set();
@@ -55936,13 +56282,13 @@ function loadResolved() {
 }
 function saveResolved(resolved) {
   try {
-    fs68.writeFileSync(RESOLVED_FILE, JSON.stringify([...resolved], null, 2), { mode: 384 });
+    fs69.writeFileSync(RESOLVED_FILE, JSON.stringify([...resolved], null, 2), { mode: 384 });
   } catch {
   }
 }
 function loadDlpFindings() {
-  if (!fs68.existsSync(AUDIT_LOG)) return [];
-  return fs68.readFileSync(AUDIT_LOG, "utf-8").split("\n").flatMap((line) => {
+  if (!fs69.existsSync(AUDIT_LOG)) return [];
+  return fs69.readFileSync(AUDIT_LOG, "utf-8").split("\n").flatMap((line) => {
     if (!line.trim()) return [];
     try {
       const e = JSON.parse(line);
@@ -56041,14 +56387,14 @@ function registerDlpCommand(program2) {
 // src/cli/commands/mask.ts
 init_dlp();
 import chalk39 from "chalk";
-import fs69 from "fs";
-import path66 from "path";
-import os58 from "os";
+import fs70 from "fs";
+import path67 from "path";
+import os60 from "os";
 function findJsonlFiles(dir) {
   const results = [];
-  if (!fs69.existsSync(dir)) return results;
-  for (const entry of fs69.readdirSync(dir, { withFileTypes: true })) {
-    const full = path66.join(dir, entry.name);
+  if (!fs70.existsSync(dir)) return results;
+  for (const entry of fs70.readdirSync(dir, { withFileTypes: true })) {
+    const full = path67.join(dir, entry.name);
     if (entry.isDirectory()) results.push(...findJsonlFiles(full));
     else if (entry.isFile() && entry.name.endsWith(".jsonl")) results.push(full);
   }
@@ -56091,7 +56437,7 @@ function redactJson(obj) {
 function processFile(filePath, dryRun) {
   let raw;
   try {
-    raw = fs69.readFileSync(filePath, "utf-8");
+    raw = fs70.readFileSync(filePath, "utf-8");
   } catch {
     return { redactedLines: 0, patterns: [] };
   }
@@ -56123,14 +56469,14 @@ function processFile(filePath, dryRun) {
     }
   }
   if (!dryRun && redactedLines > 0) {
-    fs69.writeFileSync(filePath, newLines.join("\n"), "utf-8");
+    fs70.writeFileSync(filePath, newLines.join("\n"), "utf-8");
   }
   return { redactedLines, patterns };
 }
 function processJsonFile(filePath, dryRun) {
   let raw;
   try {
-    raw = fs69.readFileSync(filePath, "utf-8");
+    raw = fs70.readFileSync(filePath, "utf-8");
   } catch {
     return { redactedLines: 0, patterns: [] };
   }
@@ -56143,15 +56489,15 @@ function processJsonFile(filePath, dryRun) {
   const { value, modified, found } = redactJson(parsed);
   if (!modified) return { redactedLines: 0, patterns: [] };
   if (!dryRun) {
-    fs69.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
+    fs70.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
   }
   return { redactedLines: 1, patterns: found };
 }
 function findJsonFiles(dir) {
   const results = [];
-  if (!fs69.existsSync(dir)) return results;
-  for (const entry of fs69.readdirSync(dir, { withFileTypes: true })) {
-    const full = path66.join(dir, entry.name);
+  if (!fs70.existsSync(dir)) return results;
+  for (const entry of fs70.readdirSync(dir, { withFileTypes: true })) {
+    const full = path67.join(dir, entry.name);
     if (entry.isDirectory()) results.push(...findJsonFiles(full));
     else if (entry.isFile() && entry.name.endsWith(".json")) results.push(full);
   }
@@ -56160,9 +56506,9 @@ function findJsonFiles(dir) {
 function registerMaskCommand(program2) {
   program2.command("mask").description("Redact plaintext secrets from local AI session history files").option("--dry-run", "show what would be redacted without making changes").option("--all", "scan all history (default: last 30 days)").action(async (options) => {
     const dryRun = !!options.dryRun;
-    const home = os58.homedir();
-    const claudeDir = path66.join(home, ".claude", "projects");
-    const geminiDir = path66.join(home, ".gemini", "tmp");
+    const home = os60.homedir();
+    const claudeDir = path67.join(home, ".claude", "projects");
+    const geminiDir = path67.join(home, ".gemini", "tmp");
     const allFiles = [
       ...findJsonlFiles(claudeDir).map((p) => ({ path: p, type: "jsonl" })),
       ...findJsonFiles(geminiDir).map((p) => ({ path: p, type: "json" }))
@@ -56170,7 +56516,7 @@ function registerMaskCommand(program2) {
     const cutoff = options.all ? null : new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3);
     const filtered = cutoff ? allFiles.filter((f) => {
       try {
-        return fs69.statSync(f.path).mtime >= cutoff;
+        return fs70.statSync(f.path).mtime >= cutoff;
       } catch {
         return false;
       }
@@ -56226,7 +56572,7 @@ function registerMaskCommand(program2) {
 // src/cli.ts
 init_blast();
 var { version } = JSON.parse(
-  fs72.readFileSync(path69.join(__dirname, "../package.json"), "utf-8")
+  fs73.readFileSync(path70.join(__dirname, "../package.json"), "utf-8")
 );
 var program = new Command();
 program.name("node9").description("The Sudo Command for AI Agents").version(version);
@@ -56252,6 +56598,11 @@ program.command("login").argument("<apiKey>").option("--local", "Save key for au
   } else {
     console.log(chalk41.green(`\u2705 Logged in \u2014 agent mode`));
     console.log(chalk41.gray(`   Team policy enforced for all calls via Node9 cloud.`));
+    if (!isTestingMode()) {
+      const healed = ensureAutostartHealthy(!!getConfig().settings.autoStartDaemon);
+      if (healed === "repaired")
+        console.log(chalk41.green(`   \u2713 Re-enabled daemon autostart (survives reboot)`));
+    }
   }
 });
 program.command("signup").description("Create your node9 account / open the dashboard in your browser").option("--login", "Open the login page instead of signup").action((options) => {
@@ -56400,15 +56751,15 @@ program.command("uninstall").description("Remove all Node9 hooks and optionally
   } catch {
   }
   if (options.purge) {
-    const node9Dir = path69.join(os61.homedir(), ".node9");
-    if (fs72.existsSync(node9Dir)) {
+    const node9Dir = path70.join(os63.homedir(), ".node9");
+    if (fs73.existsSync(node9Dir)) {
       const confirmed = await confirm2({
         message: `Permanently delete ${node9Dir} (config, audit log, credentials)?`,
         default: false
       });
       if (confirmed) {
-        fs72.rmSync(node9Dir, { recursive: true });
-        if (fs72.existsSync(node9Dir)) {
+        fs73.rmSync(node9Dir, { recursive: true });
+        if (fs73.existsSync(node9Dir)) {
           console.error(
             chalk41.red("\n  \u26A0\uFE0F  ~/.node9/ could not be fully deleted \u2014 remove it manually.")
           );
@@ -56533,7 +56884,7 @@ program.command("tail").description("Stream live agent activity to the terminal"
 });
 program.command("monitor").description("Live interactive dashboard \u2014 activity feed, approvals, security signals").action(async () => {
   try {
-    const dashboardPath = path69.join(__dirname, "dashboard.mjs");
+    const dashboardPath = path70.join(__dirname, "dashboard.mjs");
     const dynamicImport = new Function("id", "return import(id)");
     const mod = await dynamicImport(`file://${dashboardPath}`);
     await mod.startMonitor();
@@ -56571,14 +56922,14 @@ Claude Code spawns this command every ~300ms and writes a JSON payload to stdin.
 Run "node9 addto claude" to register it as the statusLine.`
 ).argument("[subcommand]", 'Optional: "debug on" / "debug off" to toggle stdin logging').argument("[state]", 'on|off \u2014 used with "debug" subcommand').action(async (subcommand, state) => {
   if (subcommand === "debug") {
-    const flagFile = path69.join(os61.homedir(), ".node9", "hud-debug");
+    const flagFile = path70.join(os63.homedir(), ".node9", "hud-debug");
     if (state === "on") {
-      fs72.mkdirSync(path69.dirname(flagFile), { recursive: true });
-      fs72.writeFileSync(flagFile, "");
+      fs73.mkdirSync(path70.dirname(flagFile), { recursive: true });
+      fs73.writeFileSync(flagFile, "");
       console.log("HUD debug logging enabled \u2192 ~/.node9/hud-debug.log");
       console.log("Tail it with: tail -f ~/.node9/hud-debug.log");
     } else if (state === "off") {
-      if (fs72.existsSync(flagFile)) fs72.unlinkSync(flagFile);
+      if (fs73.existsSync(flagFile)) fs73.unlinkSync(flagFile);
       console.log("HUD debug logging disabled.");
     } else {
       console.error("Usage: node9 hud debug on|off");
@@ -56701,9 +57052,9 @@ if (process.argv[2] !== "daemon") {
     const isCheckHook = process.argv[2] === "check";
     if (isCheckHook) {
       if (process.env.NODE9_DEBUG === "1" || getConfig().settings.enableHookLogDebug) {
-        const logPath = path69.join(os61.homedir(), ".node9", "hook-debug.log");
+        const logPath = path70.join(os63.homedir(), ".node9", "hook-debug.log");
         const msg = reason instanceof Error ? reason.message : String(reason);
-        fs72.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] UNHANDLED: ${msg}
+        fs73.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] UNHANDLED: ${msg}
 `);
       }
       process.exit(0);