@node9/proxy 2.43.0 → 2.44.0

package/dist/cli.mjs

@@ -5504,7 +5504,10 @@ function classify(inv) {
     out.push({ ...f, shown: inv.shown, reason: `${f.reason}: ${inv.shown}` });
   };
   if (hooksBypass(inv)) found(HOOKS_BYPASS);
-  if (stagesEverything(inv)) found(STAGE_ALL);
+  const staged = stagesEverything(inv);
+  if (staged) {
+    found(staged.ifWorkTreeTop === void 0 ? STAGE_ALL : { ...STAGE_ALL, ...staged });
+  }
   if (inv.sub === null) {
     found(UNREADABLE);
     return out;
@@ -5565,12 +5568,35 @@ function appliedValue(env, name) {
   const word = f?.Stmts?.[0]?.Cmd?.Args?.[1];
   return word ? resolveWordLiteral(word) : null;
 }
+function lexicalPath(p) {
+  if (/^[\\/~$]/.test(p) || /^[A-Za-z]:/.test(p)) return null;
+  const parts = [];
+  let climbed = false;
+  for (const part of p.split(/[\\/]+/)) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") {
+      if (parts.length === 0) climbed = true;
+      else parts.pop();
+    } else parts.push(part);
+  }
+  return { parts, climbed };
+}
+function hooksPathBypasses(value) {
+  if (value === null || value === void 0) return true;
+  const v = value.trim();
+  if (v === "" || v === "true") return true;
+  const lp = lexicalPath(v);
+  if (lp === null || lp.climbed || lp.parts.length === 0) return true;
+  return lp.parts[0] === ".git" && lp.parts[1] !== "hooks";
+}
 function hooksBypass(inv) {
-  if (inv.config.has("core.hookspath")) return true;
+  if (inv.config.has("core.hookspath") && hooksPathBypasses(inv.config.get("core.hookspath")))
+    return true;
   for (const [name, value] of inv.env) {
     if (name === "GIT_CONFIG_PARAMETERS" && value !== null && /core\.hookspath/i.test(value))
       return true;
-    if (/^GIT_CONFIG_KEY_\d+$/.test(name) && value !== null && value.toLowerCase() === "core.hookspath")
+    const key = /^GIT_CONFIG_KEY_(\d+)$/.exec(name);
+    if (key && value !== null && value.toLowerCase() === "core.hookspath" && hooksPathBypasses(inv.env.get(`GIT_CONFIG_VALUE_${key[1]}`)))
       return true;
   }
   for (const name of HOOK_KILL_SWITCHES) {
@@ -5612,7 +5638,10 @@ function configWritesHooksPath(args) {
   }
   const key = args[i];
   if (key === null || key === void 0 || key.toLowerCase() !== "core.hookspath") return false;
-  return write2 || i + 1 < args.length;
+  const unset = args.slice(0, i).some((w) => w === "--unset" || w === "--unset-all") || args[0] === "unset";
+  if (unset) return true;
+  if (i + 1 < args.length) return hooksPathBypasses(args[i + 1]);
+  return write2;
 }
 function isHookPath(word) {
   return /(^|[\\/])(\.git[\\/]hooks|\.husky)([\\/]|$)/.test(word);
@@ -5647,31 +5676,49 @@ function chmodDisarmsHook(args, shown) {
 function wholeTree(operand) {
   if (/^:\(top\)\.?$/.test(operand) || operand === ":/" || operand === "*") return true;
   if (operand.startsWith(":")) return false;
+  const lp = lexicalPath(operand);
+  return lp !== null && lp.parts.length === 0;
+}
+function chdirPrefix(inv) {
+  const dirs = inv.chdir ?? [];
+  if (dirs.length === 0) return null;
   const parts = [];
-  for (const part of operand.split("/")) {
-    if (!part || part === ".") continue;
-    if (part === "..") parts.pop();
-    else parts.push(part);
+  for (const d of dirs) {
+    if (d === null || d === "") return null;
+    const lp = lexicalPath(d);
+    if (lp === null || lp.climbed) return null;
+    parts.push(...lp.parts);
   }
-  return parts.length === 0 && !operand.startsWith("/");
+  return parts.length === 0 ? null : parts.join("/");
 }
 function stagesEverything(inv) {
   const sub = inv.sub?.toLowerCase();
+  const prefix = chdirPrefix(inv);
+  const judge = (operands2) => {
+    let conditional = false;
+    for (const operand of operands2) {
+      if (!wholeTree(operand)) continue;
+      if (prefix === null || operand.startsWith(":") || operand.startsWith("/")) return {};
+      if (wholeTree(`${prefix}/${operand === "*" ? "." : operand}`)) return {};
+      conditional = true;
+    }
+    return conditional && prefix !== null ? { ifWorkTreeTop: prefix } : null;
+  };
   if (sub === "add") {
     const o = parseOptions(inv.args, "", ADD_LONG_VALUE);
     if (o.flags.has("-n") || o.flags.has("--dry-run") || o.flags.has("-i") || o.flags.has("--interactive") || o.flags.has("-p") || o.flags.has("--patch") || o.flags.has("-e") || o.flags.has("--edit"))
-      return false;
+      return null;
     const all = o.flags.has("-A") || o.flags.has("--all") || o.flags.has("--no-ignore-removal") || o.flags.has("-u") || o.flags.has("--update");
-    if (all && o.operands.length === 0) return true;
-    return o.operands.some(wholeTree);
+    if (all && o.operands.length === 0) return {};
+    return judge(o.operands);
   }
   if (sub === "commit") {
     const o = parseOptions(inv.args, "mFCcut", COMMIT_LONG_VALUE);
-    if (o.flags.has("--dry-run")) return false;
-    if (o.flags.has("-a") || o.flags.has("--all")) return true;
-    return o.operands.some(wholeTree);
+    if (o.flags.has("--dry-run")) return null;
+    if (o.flags.has("-a") || o.flags.has("--all")) return {};
+    return judge(o.operands);
   }
-  return false;
+  return null;
 }
 function hookTextRunsNothing(text) {
   return text.split(/\r?\n/).every((line) => INERT_LINE_RE.test(line.trim()));
@@ -7724,7 +7771,7 @@ async function evaluatePolicy(config, toolName, args, context = {}, hostHooks =
 }
 async function evaluatePolicyCore(config, toolName, args, context = {}, hooks = {}) {
   const { agent, cwd, activeEnvironment } = context;
-  const { checkProvenance: checkProvenance2, isTrustedHost: isTrustedHost2, isConfiguredRegistry } = hooks;
+  const { checkProvenance: checkProvenance2, isTrustedHost: isTrustedHost2, isConfiguredRegistry, isGitWorkTreeTop: isGitWorkTreeTop2 } = hooks;
   const settingsView = catalogSettings(config);
   const layers = inspectionLayers(config.policy);
   const cv = (id) => checkValue(settingsView, id);
@@ -7878,6 +7925,8 @@ async function evaluatePolicyCore(config, toolName, args, context = {}, hooks =
         const action = cv(id);
         const finding = action === "off" ? void 0 : git.findings.find((f) => f.checkId === id);
         if (!finding) continue;
+        if (finding.ifWorkTreeTop !== void 0 && isGitWorkTreeTop2 && cwd && !isGitWorkTreeTop2(finding.ifWorkTreeTop, cwd))
+          continue;
         const v = applyCheckValue(action, {
           decision: "review",
           blockedByLabel: `Node9 (AST): ${finding.ruleName}`,
@@ -17200,6 +17249,7 @@ zoo`.split("\n");
       /** The words after `git`: global options, then the subcommand. */
       visitGit(rest, env, depth, viaXargs, fromAlias, shown) {
         const config = /* @__PURE__ */ new Map();
+        const chdir = [];
         let i = 0;
         while (i < rest.length) {
           const w = rest[i];
@@ -17214,6 +17264,7 @@ zoo`.split("\n");
               i++;
               value = i < rest.length ? rest[i] : null;
             }
+            if (name === "-C") chdir.push(viaXargs || (value ?? "").includes("{}") ? null : value);
             if (name === "-c" && value !== null) {
               const ceq = value.indexOf("=");
               const key = (ceq > 0 ? value.slice(0, ceq) : value).toLowerCase();
@@ -17230,7 +17281,7 @@ zoo`.split("\n");
         }
         const subWord = i < rest.length ? rest[i] : void 0;
         const args = rest.slice(i + 1);
-        const inv = { sub: null, args, config, env, shown };
+        const inv = { sub: null, args, config, env, shown, chdir };
         if (subWord === void 0) {
           if (!viaXargs) return;
           this.emit(inv);
@@ -17244,16 +17295,23 @@ zoo`.split("\n");
         const fromConfig = config.get(`alias.${subWord.toLowerCase()}`);
         const alias = fromConfig !== void 0 ? fromConfig : this.aliases.get(subWord);
         if (alias !== void 0 && !fromAlias) {
-          this.expandAlias(subWord, alias, args, env, depth, 0, shown);
+          this.expandAlias(subWord, alias, args, env, depth, 0, shown, chdir);
           return;
         }
         inv.sub = subWord;
         this.emit(inv);
         this.recordAliasDefinition(inv, env, depth);
       }
-      expandAlias(name, value, args, env, depth, level, shown) {
+      expandAlias(name, value, args, env, depth, level, shown, chdir) {
         if (value === null) {
-          this.emit({ sub: null, args, config: /* @__PURE__ */ new Map(), env, shown: `${shown} (alias ${name})` });
+          this.emit({
+            sub: null,
+            args,
+            config: /* @__PURE__ */ new Map(),
+            env,
+            shown: `${shown} (alias ${name})`,
+            chdir
+          });
           return;
         }
         if (value.startsWith("!")) {
@@ -17267,7 +17325,16 @@ zoo`.split("\n");
         const nested = this.aliases.get(sub);
         const expandedShown = `${shown} (alias ${name} = ${value})`;
         if (nested !== void 0 && level < MAX_ALIAS_DEPTH) {
-          this.expandAlias(sub, nested, [...words.slice(1), ...args], env, depth, level + 1, shown);
+          this.expandAlias(
+            sub,
+            nested,
+            [...words.slice(1), ...args],
+            env,
+            depth,
+            level + 1,
+            shown,
+            chdir
+          );
           return;
         }
         this.emit({
@@ -17275,7 +17342,8 @@ zoo`.split("\n");
           args: [...words.slice(1), ...args],
           config: /* @__PURE__ */ new Map(),
           env,
-          shown: expandedShown
+          shown: expandedShown,
+          chdir
         });
       }
       /**
@@ -17309,7 +17377,7 @@ zoo`.split("\n");
         if (i + 1 >= args.length) return;
         const value = args[i + 1];
         this.aliases.set(m[1], value);
-        this.expandAlias(m[1], value, [], env, depth, 0, `${inv.shown}`);
+        this.expandAlias(m[1], value, [], env, depth, 0, `${inv.shown}`, []);
       }
     };
     POSITIONAL2 = "\0positional";
@@ -18855,7 +18923,7 @@ zoo`.split("\n");
       { view: "separators-stripped", decoder: "separators", stripped: true }
     ];
     LONG_OUTPUT_THRESHOLD_BYTES = 100 * 1024;
-    CANONICAL_EXTRACTOR_VERSION = "canonical-v34";
+    CANONICAL_EXTRACTOR_VERSION = "canonical-v35";
     DEDUPE_PREVIEW_LEN = 120;
     ENGINE_VERSION = "1.4.0";
   }
@@ -22932,10 +23000,19 @@ async function evaluatePolicy2(toolName, args, agent, cwd, opts) {
       // reaches a long-lived in-process authorizer (the gateway) within seconds.
       isTrustedHost: config.policy.trustedHostsManaged ? (host2) => matchesTrustedHost(host2, config.policy.trustedHosts) : isTrustedHost,
       readAgentSettings,
-      isConfiguredRegistry: (host2, at) => configuredRegistryHosts(at).has(host2)
+      isConfiguredRegistry: (host2, at) => configuredRegistryHosts(at).has(host2),
+      isGitWorkTreeTop
     }
   );
 }
+function isGitWorkTreeTop(dir2, cwd) {
+  if (!path13.isAbsolute(cwd)) return true;
+  try {
+    return fs13.existsSync(path13.join(path13.resolve(cwd, dir2), ".git"));
+  } catch {
+    return true;
+  }
+}
 function readAgentSettings(absPath) {
   const r = readCappedText(
     absPath,
@@ -31952,16 +32029,124 @@ var init_credentials = __esm({
   }
 });
 
-// src/daemon/service.ts
+// src/daemon/startup-log.ts
 import fs38 from "fs";
 import path39 from "path";
 import os32 from "os";
+function capStartupLog(file2) {
+  try {
+    if (fs38.statSync(file2).size > MAX_STARTUP_LOG_BYTES) fs38.truncateSync(file2);
+  } catch {
+  }
+}
+function openStartupLogFd() {
+  try {
+    const file2 = DAEMON_STARTUP_LOG();
+    const dir2 = path39.dirname(file2);
+    if (!fs38.existsSync(dir2)) fs38.mkdirSync(dir2, { recursive: true });
+    capStartupLog(file2);
+    return fs38.openSync(file2, "a");
+  } catch {
+    return void 0;
+  }
+}
+function recordStartupState(outcome, kind, detail) {
+  try {
+    if (outcome === "starting") {
+      const prev = readStartupState();
+      if (prev?.outcome === "starting") {
+        const prevAt = new Date(prev.at).getTime();
+        const age = Math.abs(Date.now() - prevAt);
+        if (!isNaN(prevAt) && age < 24 * 60 * 60 * 1e3) return;
+      }
+    }
+    const file2 = DAEMON_STARTUP_STATE();
+    const dir2 = path39.dirname(file2);
+    if (!fs38.existsSync(dir2)) fs38.mkdirSync(dir2, { recursive: true });
+    const state = { outcome, at: (/* @__PURE__ */ new Date()).toISOString() };
+    if (kind) state.kind = kind;
+    if (detail) state.detail = detail.slice(0, MAX_DETAIL);
+    const tmp = `${file2}.${process.pid}.tmp`;
+    try {
+      fs38.writeFileSync(tmp, JSON.stringify(state), "utf-8");
+      fs38.renameSync(tmp, file2);
+    } catch (err2) {
+      try {
+        fs38.unlinkSync(tmp);
+      } catch {
+      }
+      throw err2;
+    }
+  } catch {
+  }
+}
+function readStartupState() {
+  try {
+    const raw = fs38.readFileSync(DAEMON_STARTUP_STATE(), "utf-8");
+    const s = JSON.parse(raw);
+    if (!s || typeof s.outcome !== "string" || typeof s.at !== "string") return null;
+    return s;
+  } catch {
+    return null;
+  }
+}
+function readStartupCause(maxAgeMs = 24 * 60 * 60 * 1e3) {
+  const s = readStartupState();
+  if (!s) return null;
+  const at = new Date(s.at);
+  if (isNaN(at.getTime()) || Date.now() - at.getTime() > maxAgeMs) return null;
+  switch (s.outcome) {
+    case "ok":
+    case "ok-elsewhere":
+      return null;
+    case "starting":
+      if (Date.now() - at.getTime() < STARTING_GRACE_MS) return null;
+      return {
+        kind: "did-not-start",
+        detail: "the daemon did not come up \u2014 see ~/.node9/daemon-startup.log and hook-debug.log",
+        at,
+        // `at` is the FIRST attempt of the streak, not the most recent one.
+        label: "start attempts failing since"
+      };
+    case "failed":
+      return { kind: s.kind || "failed", detail: s.detail || "", at, label: "last start attempt" };
+    default:
+      return null;
+  }
+}
+function logDaemonStartup(kind, detail) {
+  try {
+    const file2 = DAEMON_STARTUP_LOG();
+    const dir2 = path39.dirname(file2);
+    if (!fs38.existsSync(dir2)) fs38.mkdirSync(dir2, { recursive: true });
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon-startup:${kind}${detail ? ` ${detail}` : ""}
+`;
+    fs38.appendFileSync(file2, line, "utf-8");
+  } catch {
+  }
+}
+var DAEMON_STARTUP_LOG, MAX_STARTUP_LOG_BYTES, DAEMON_STARTUP_STATE, MAX_DETAIL, STARTING_GRACE_MS;
+var init_startup_log = __esm({
+  "src/daemon/startup-log.ts"() {
+    "use strict";
+    DAEMON_STARTUP_LOG = () => path39.join(os32.homedir(), ".node9", "daemon-startup.log");
+    MAX_STARTUP_LOG_BYTES = 256 * 1024;
+    DAEMON_STARTUP_STATE = () => path39.join(os32.homedir(), ".node9", "daemon-startup-state.json");
+    MAX_DETAIL = 200;
+    STARTING_GRACE_MS = 90 * 1e3;
+  }
+});
+
+// src/daemon/service.ts
+import fs39 from "fs";
+import path40 from "path";
+import os33 from "os";
 import { spawnSync as spawnSync2, execFileSync } from "child_process";
 function resolveNode9Binary() {
   try {
     const script = process.argv[1];
-    if (typeof script === "string" && path39.isAbsolute(script) && fs38.existsSync(script)) {
-      return fs38.realpathSync(script);
+    if (typeof script === "string" && path40.isAbsolute(script) && fs39.existsSync(script)) {
+      return fs39.realpathSync(script);
     }
   } catch {
   }
@@ -31985,11 +32170,11 @@ function daemonServiceEnv() {
   return env;
 }
 function launchdPlist(binaryPath) {
-  const logDir = path39.join(os32.homedir(), ".node9");
+  const logDir = path40.join(os33.homedir(), ".node9");
   const nodePath = xmlEscape(process.execPath);
   const scriptPath = xmlEscape(binaryPath);
-  const outLog = xmlEscape(path39.join(logDir, "daemon.log"));
-  const errLog = xmlEscape(path39.join(logDir, "daemon-error.log"));
+  const outLog = xmlEscape(path40.join(logDir, "daemon.log"));
+  const errLog = xmlEscape(path40.join(logDir, "daemon-error.log"));
   const envEntries = Object.entries(daemonServiceEnv()).map(([k, v]) => `        <key>${xmlEscape(k)}</key>
         <string>${xmlEscape(v)}</string>`).join("\n");
   return `<?xml version="1.0" encoding="UTF-8"?>
@@ -32023,9 +32208,9 @@ ${envEntries}
 `;
 }
 function installLaunchd(binaryPath) {
-  const dir2 = path39.dirname(LAUNCHD_PLIST);
-  if (!fs38.existsSync(dir2)) fs38.mkdirSync(dir2, { recursive: true });
-  fs38.writeFileSync(LAUNCHD_PLIST, launchdPlist(binaryPath), "utf-8");
+  const dir2 = path40.dirname(LAUNCHD_PLIST);
+  if (!fs39.existsSync(dir2)) fs39.mkdirSync(dir2, { recursive: true });
+  fs39.writeFileSync(LAUNCHD_PLIST, launchdPlist(binaryPath), "utf-8");
   spawnSync2("launchctl", ["unload", LAUNCHD_PLIST], { encoding: "utf8" });
   const r = spawnSync2("launchctl", ["load", "-w", LAUNCHD_PLIST], {
     encoding: "utf8",
@@ -32036,13 +32221,13 @@ function installLaunchd(binaryPath) {
   }
 }
 function uninstallLaunchd() {
-  if (fs38.existsSync(LAUNCHD_PLIST)) {
+  if (fs39.existsSync(LAUNCHD_PLIST)) {
     spawnSync2("launchctl", ["unload", "-w", LAUNCHD_PLIST], { encoding: "utf8", timeout: 5e3 });
-    fs38.unlinkSync(LAUNCHD_PLIST);
+    fs39.unlinkSync(LAUNCHD_PLIST);
   }
 }
 function isLaunchdInstalled() {
-  return fs38.existsSync(LAUNCHD_PLIST);
+  return fs39.existsSync(LAUNCHD_PLIST);
 }
 function systemdUnit(binaryPath) {
   const envLines = Object.entries(daemonServiceEnv()).map(([k, v]) => `Environment="${k}=${v}"`).join("\n");
@@ -32062,12 +32247,12 @@ WantedBy=default.target
 `;
 }
 function installSystemd(binaryPath) {
-  if (!fs38.existsSync(SYSTEMD_UNIT_DIR)) {
-    fs38.mkdirSync(SYSTEMD_UNIT_DIR, { recursive: true });
+  if (!fs39.existsSync(SYSTEMD_UNIT_DIR)) {
+    fs39.mkdirSync(SYSTEMD_UNIT_DIR, { recursive: true });
   }
-  fs38.writeFileSync(SYSTEMD_UNIT, systemdUnit(binaryPath), "utf-8");
+  fs39.writeFileSync(SYSTEMD_UNIT, systemdUnit(binaryPath), "utf-8");
   try {
-    execFileSync("loginctl", ["enable-linger", os32.userInfo().username], { timeout: 3e3 });
+    execFileSync("loginctl", ["enable-linger", os33.userInfo().username], { timeout: 3e3 });
   } catch {
   }
   const reload = spawnSync2("systemctl", ["--user", "daemon-reload"], {
@@ -32087,21 +32272,21 @@ function installSystemd(binaryPath) {
   }
 }
 function uninstallSystemd() {
-  if (fs38.existsSync(SYSTEMD_UNIT)) {
+  if (fs39.existsSync(SYSTEMD_UNIT)) {
     spawnSync2("systemctl", ["--user", "disable", "--now", "node9-daemon"], {
       encoding: "utf8",
       timeout: 5e3
     });
     spawnSync2("systemctl", ["--user", "daemon-reload"], { encoding: "utf8", timeout: 5e3 });
-    fs38.unlinkSync(SYSTEMD_UNIT);
+    fs39.unlinkSync(SYSTEMD_UNIT);
   }
 }
 function isSystemdInstalled() {
-  return fs38.existsSync(SYSTEMD_UNIT);
+  return fs39.existsSync(SYSTEMD_UNIT);
 }
-function windowsStartupDir(homeDir2 = os32.homedir()) {
-  const appData = process.env.APPDATA || path39.join(homeDir2, "AppData", "Roaming");
-  return path39.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+function windowsStartupDir(homeDir2 = os33.homedir()) {
+  const appData = process.env.APPDATA || path40.join(homeDir2, "AppData", "Roaming");
+  return path40.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
 }
 function windowsLauncherVbs(nodePath, scriptPath) {
   for (const p of [nodePath, scriptPath]) {
@@ -32121,23 +32306,23 @@ function windowsLauncherVbs(nodePath, scriptPath) {
 }
 function installWindowsStartup(binaryPath) {
   const target = WIN_LAUNCHER();
-  const dir2 = path39.dirname(target);
-  if (!fs38.existsSync(dir2)) fs38.mkdirSync(dir2, { recursive: true });
-  fs38.writeFileSync(target, windowsLauncherVbs(process.execPath, binaryPath), "utf-8");
+  const dir2 = path40.dirname(target);
+  if (!fs39.existsSync(dir2)) fs39.mkdirSync(dir2, { recursive: true });
+  fs39.writeFileSync(target, windowsLauncherVbs(process.execPath, binaryPath), "utf-8");
   spawnSync2("wscript.exe", ["//B", target], { encoding: "utf8", timeout: 1e4 });
 }
 function uninstallWindowsStartup() {
   const target = WIN_LAUNCHER();
-  if (fs38.existsSync(target)) fs38.unlinkSync(target);
+  if (fs39.existsSync(target)) fs39.unlinkSync(target);
 }
 function isWindowsStartupInstalled() {
-  return fs38.existsSync(WIN_LAUNCHER());
+  return fs39.existsSync(WIN_LAUNCHER());
 }
 function stopRunningDaemon() {
-  const pidFile = path39.join(os32.homedir(), ".node9", "daemon.pid");
-  if (!fs38.existsSync(pidFile)) return;
+  const pidFile = path40.join(os33.homedir(), ".node9", "daemon.pid");
+  if (!fs39.existsSync(pidFile)) return;
   try {
-    const data = JSON.parse(fs38.readFileSync(pidFile, "utf-8"));
+    const data = JSON.parse(fs39.readFileSync(pidFile, "utf-8"));
     const pid = data.pid;
     const MAX_PID2 = 4194304;
     if (typeof pid === "number" && Number.isInteger(pid) && pid > 0 && pid <= MAX_PID2) {
@@ -32157,7 +32342,7 @@ function stopRunningDaemon() {
       }
     }
     try {
-      fs38.unlinkSync(pidFile);
+      fs39.unlinkSync(pidFile);
     } catch {
     }
   } catch {
@@ -32250,7 +32435,7 @@ function enableDaemonServiceQuiet() {
     if (process.platform === "linux") {
       const r = spawnSync2("systemctl", ["--user", "enable", "node9-daemon"], {
         encoding: "utf8",
-        timeout: 3e3
+        timeout: 1e4
       });
       return r.status === 0;
     }
@@ -32268,19 +32453,35 @@ function ensureAutostartHealthy(autoStartDaemon) {
     enabled: isDaemonServiceEnabled(),
     autoStartDaemon
   });
-  if (decision === "repair") return enableDaemonServiceQuiet() ? "repaired" : "skipped";
+  if (decision === "repair") return enableDaemonServiceQuiet() ? "repaired" : "failed";
   return decision === "ok" ? "ok" : decision === "unsupported" ? "unsupported" : "skipped";
 }
-function scheduleAutostartSelfHeal(autoStartDaemon) {
+function logAutostartHeal(result) {
+  if (result !== "repaired" && result !== "failed") return;
+  try {
+    const file2 = DAEMON_STARTUP_LOG();
+    fs39.mkdirSync(path40.dirname(file2), { recursive: true });
+    capStartupLog(file2);
+    fs39.appendFileSync(file2, `[${(/* @__PURE__ */ new Date()).toISOString()}] [autostart-heal] ${result}
+`);
+  } catch {
+  }
+}
+function scheduleAutostartSelfHeal(autoStartDaemon, heal = ensureAutostartHealthy) {
   if (process.env.NODE9_TESTING === "1") return;
+  let failures = 0;
   const run = () => {
+    let result = "skipped";
     try {
-      ensureAutostartHealthy(autoStartDaemon());
+      result = heal(autoStartDaemon());
     } catch {
     }
+    logAutostartHeal(result);
+    failures = result === "failed" ? failures + 1 : 0;
+    const next = failures > 0 && failures <= AUTOSTART_HEAL_RETRY_MS.length ? AUTOSTART_HEAL_RETRY_MS[failures - 1] : AUTOSTART_HEAL_INTERVAL_MS;
+    setTimeout(run, next).unref();
   };
   setTimeout(run, 6e4).unref();
-  setInterval(run, AUTOSTART_HEAL_INTERVAL_MS).unref();
 }
 function restartDaemonService() {
   try {
@@ -32355,39 +32556,41 @@ function autostartState() {
   if (!isDaemonServiceInstalled()) return "absent";
   return isDaemonServiceEnabled() ? "enabled" : "disabled";
 }
-var LAUNCHD_LABEL, LAUNCHD_PLIST, SYSTEMD_UNIT_DIR, SYSTEMD_UNIT, STARTUP_FILE, WIN_LAUNCHER, AUTOSTART_HEAL_INTERVAL_MS;
+var LAUNCHD_LABEL, LAUNCHD_PLIST, SYSTEMD_UNIT_DIR, SYSTEMD_UNIT, STARTUP_FILE, WIN_LAUNCHER, AUTOSTART_HEAL_INTERVAL_MS, AUTOSTART_HEAL_RETRY_MS;
 var init_service = __esm({
   "src/daemon/service.ts"() {
     "use strict";
+    init_startup_log();
     init_api_url();
     LAUNCHD_LABEL = "ai.node9.daemon";
-    LAUNCHD_PLIST = path39.join(os32.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
-    SYSTEMD_UNIT_DIR = path39.join(os32.homedir(), ".config", "systemd", "user");
-    SYSTEMD_UNIT = path39.join(SYSTEMD_UNIT_DIR, "node9-daemon.service");
+    LAUNCHD_PLIST = path40.join(os33.homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+    SYSTEMD_UNIT_DIR = path40.join(os33.homedir(), ".config", "systemd", "user");
+    SYSTEMD_UNIT = path40.join(SYSTEMD_UNIT_DIR, "node9-daemon.service");
     STARTUP_FILE = "node9-daemon.vbs";
-    WIN_LAUNCHER = () => path39.join(windowsStartupDir(), STARTUP_FILE);
+    WIN_LAUNCHER = () => path40.join(windowsStartupDir(), STARTUP_FILE);
     AUTOSTART_HEAL_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+    AUTOSTART_HEAL_RETRY_MS = [10 * 60 * 1e3, 60 * 60 * 1e3];
   }
 });
 
 // src/apps/detect.ts
-import fs39 from "fs";
-import os33 from "os";
-import path40 from "path";
+import fs40 from "fs";
+import os34 from "os";
+import path41 from "path";
 function readTail(file2, bytes) {
   let fd;
   try {
-    fd = fs39.openSync(file2, "r");
-    const size = fs39.fstatSync(fd).size;
+    fd = fs40.openSync(file2, "r");
+    const size = fs40.fstatSync(fd).size;
     const start = Math.max(0, size - bytes);
     const buf = Buffer.alloc(size - start);
-    fs39.readSync(fd, buf, 0, buf.length, start);
+    fs40.readSync(fd, buf, 0, buf.length, start);
     const text = buf.toString("utf8");
     return start > 0 ? text.slice(text.indexOf("\n") + 1) : text;
   } catch {
     return "";
   } finally {
-    if (fd !== void 0) fs39.closeSync(fd);
+    if (fd !== void 0) fs40.closeSync(fd);
   }
 }
 function programsOf(command) {
@@ -32401,7 +32604,7 @@ function programsOf(command) {
         i++;
         continue;
       }
-      const base2 = path40.basename(w.replace(/^["']|["']$/g, ""));
+      const base2 = path41.basename(w.replace(/^["']|["']$/g, ""));
       if (WRAPPERS.has(base2)) {
         i++;
         continue;
@@ -32436,7 +32639,7 @@ function observeAudit(auditFile) {
       for (const p of programsOf(row.argsPreview)) commands.add(p);
     }
     const dir2 = typeof row.workingDir === "string" ? row.workingDir : "";
-    if (dir2 && path40.isAbsolute(dir2) && !seenDirs.has(dir2) && dirs.length < MAX_PROJECTS) {
+    if (dir2 && path41.isAbsolute(dir2) && !seenDirs.has(dir2) && dirs.length < MAX_PROJECTS) {
       seenDirs.add(dir2);
       dirs.push(dir2);
     }
@@ -32446,21 +32649,21 @@ function observeAudit(auditFile) {
 function readSmall(file2) {
   let fd;
   try {
-    fd = fs39.openSync(file2, READ_FLAGS);
-    const st = fs39.fstatSync(fd);
+    fd = fs40.openSync(file2, READ_FLAGS);
+    const st = fs40.fstatSync(fd);
     if (!st.isFile() || st.size > MAX_FILE_BYTES) return null;
     const buf = Buffer.alloc(st.size);
-    const n = fs39.readSync(fd, buf, 0, st.size, 0);
+    const n = fs40.readSync(fd, buf, 0, st.size, 0);
     return buf.toString("utf8", 0, n);
   } catch {
     return null;
   } finally {
-    if (fd !== void 0) fs39.closeSync(fd);
+    if (fd !== void 0) fs40.closeSync(fd);
   }
 }
 function projectPackages(dir2) {
   const out = /* @__PURE__ */ new Set();
-  const pkg = readSmall(path40.join(dir2, "package.json"));
+  const pkg = readSmall(path41.join(dir2, "package.json"));
   if (pkg) {
     try {
       const j = JSON.parse(pkg);
@@ -32477,7 +32680,7 @@ function projectPackages(dir2) {
     } catch {
     }
   }
-  const req = readSmall(path40.join(dir2, "requirements.txt"));
+  const req = readSmall(path41.join(dir2, "requirements.txt"));
   if (req) {
     for (const line of req.split("\n")) {
       const m = /^\s*([A-Za-z0-9][A-Za-z0-9._-]*)/.exec(line);
@@ -32485,7 +32688,7 @@ function projectPackages(dir2) {
         out.add(m[1].toLowerCase());
     }
   }
-  const py = readSmall(path40.join(dir2, "pyproject.toml"));
+  const py = readSmall(path41.join(dir2, "pyproject.toml"));
   if (py) {
     for (const m of py.matchAll(/["']([A-Za-z0-9][A-Za-z0-9._-]*)\s*(?:[<>=!~;[\]]|["'])/g))
       out.add(m[1].toLowerCase());
@@ -32505,7 +32708,7 @@ function projectPackages(dir2) {
 function projectEnvNames(dir2) {
   const out = /* @__PURE__ */ new Set();
   for (const f of [".env", ".env.local", ".env.development"]) {
-    const text = readSmall(path40.join(dir2, f));
+    const text = readSmall(path41.join(dir2, f));
     if (!text) continue;
     for (const line of text.split("\n")) {
       const m = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line);
@@ -32541,14 +32744,14 @@ function matchApps(obs, projectFacts, catalog = APP_CATALOG) {
   }
   return found;
 }
-function detectApps(home = os33.homedir()) {
-  const obs = observeAudit(path40.join(home, ".node9", "audit.log"));
+function detectApps(home = os34.homedir()) {
+  const obs = observeAudit(path41.join(home, ".node9", "audit.log"));
   for (const cfg of Object.values(readMcpToolsConfig())) {
     if (cfg?.name) obs.servers.add(cfg.name.toLowerCase());
   }
   const facts = obs.projects.filter((dir2) => {
     try {
-      return fs39.statSync(dir2).isDirectory();
+      return fs40.statSync(dir2).isDirectory();
     } catch {
       return false;
     }
@@ -32583,7 +32786,7 @@ var init_detect = __esm({
       "pnpx",
       "bunx"
     ]);
-    READ_FLAGS = typeof fs39.constants.O_NONBLOCK === "number" ? fs39.constants.O_RDONLY | fs39.constants.O_NONBLOCK : fs39.constants.O_RDONLY;
+    READ_FLAGS = typeof fs40.constants.O_NONBLOCK === "number" ? fs40.constants.O_RDONLY | fs40.constants.O_NONBLOCK : fs40.constants.O_RDONLY;
   }
 });
 
@@ -32643,9 +32846,9 @@ var init_daemon2 = __esm({
 });
 
 // src/config/migrate.ts
-import fs40 from "fs";
-import path41 from "path";
-import os34 from "os";
+import fs41 from "fs";
+import path42 from "path";
+import os35 from "os";
 function backupPath(filePath) {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   return `${filePath}.bak-${stamp}`;
@@ -32655,7 +32858,7 @@ function migrateConfigFile(options = {}) {
   if (options.dryRun) {
     let raw;
     try {
-      raw = JSON.parse(fs40.readFileSync(filePath, "utf8"));
+      raw = JSON.parse(fs41.readFileSync(filePath, "utf8"));
     } catch (err2) {
       if (err2.code === "ENOENT") return { status: "no-file" };
       return { status: "failed", error: `cannot read ${filePath}: ${err2.message}` };
@@ -32678,14 +32881,14 @@ function migrateConfigFile(options = {}) {
   }
 }
 function undoMigration(filePath = globalConfigPath()) {
-  const dir2 = path41.dirname(filePath);
-  const base2 = path41.basename(filePath);
-  const backups = fs40.readdirSync(dir2).filter((f) => f.startsWith(`${base2}.bak-`)).sort();
+  const dir2 = path42.dirname(filePath);
+  const base2 = path42.basename(filePath);
+  const backups = fs41.readdirSync(dir2).filter((f) => f.startsWith(`${base2}.bak-`)).sort();
   const newest = backups.at(-1);
   if (!newest) return null;
-  const from = path41.join(dir2, newest);
-  atomicWriteSync(filePath, fs40.readFileSync(from, "utf8"), { mode: 384 });
-  fs40.unlinkSync(from);
+  const from = path42.join(dir2, newest);
+  atomicWriteSync(filePath, fs41.readFileSync(from, "utf8"), { mode: 384 });
+  fs41.unlinkSync(from);
   return { restored: from };
 }
 function autoMigrateLocalConfig() {
@@ -32703,8 +32906,8 @@ function autoMigrateLocalConfig() {
       );
     } else if (outcome.status === "failed") {
       try {
-        fs40.appendFileSync(
-          path41.join(os34.homedir(), ".node9", "hook-debug.log"),
+        fs41.appendFileSync(
+          path42.join(os35.homedir(), ".node9", "hook-debug.log"),
           `[${(/* @__PURE__ */ new Date()).toISOString()}] config migrate failed: ${outcome.error}
 `
         );
@@ -32945,18 +33148,18 @@ var init_forecast = __esm({
 });
 
 // src/version.ts
-import fs41 from "fs";
-import path42 from "path";
+import fs42 from "fs";
+import path43 from "path";
 function readVersion() {
   let dir2 = __dirname;
   for (let i = 0; i < 5; i++) {
-    const p = path42.join(dir2, "package.json");
+    const p = path43.join(dir2, "package.json");
     try {
-      const pkg = JSON.parse(fs41.readFileSync(p, "utf-8"));
+      const pkg = JSON.parse(fs42.readFileSync(p, "utf-8"));
       if (pkg.name === "@node9/proxy" && typeof pkg.version === "string") return pkg.version;
     } catch {
     }
-    const parent = path42.dirname(dir2);
+    const parent = path43.dirname(dir2);
     if (parent === dir2) break;
     dir2 = parent;
   }
@@ -32971,15 +33174,15 @@ var init_version = __esm({
 });
 
 // src/cli/commands/scan-cache.ts
-import fs42 from "fs";
-import os35 from "os";
-import path43 from "path";
+import fs43 from "fs";
+import os36 from "os";
+import path44 from "path";
 import { createHash as createHash6 } from "crypto";
 function flushScanCaches() {
   for (const c of activeCaches) c.flush();
 }
 function scanCacheRoot() {
-  return path43.join(os35.homedir(), ".node9", "scan-cache");
+  return path44.join(os36.homedir(), ".node9", "scan-cache");
 }
 function configHashOf(config) {
   const h = createHash6("sha256");
@@ -32987,14 +33190,14 @@ function configHashOf(config) {
   h.update(JSON.stringify(config.policySource));
   h.update(JSON.stringify(config.policy));
   for (const name of SIDECAR_FILES) {
-    const st = fileStamp(path43.join(os35.homedir(), ".node9", name));
+    const st = fileStamp(path44.join(os36.homedir(), ".node9", name));
     h.update(`|${name}:${st ? `${st.size}:${st.mtimeMs}` : "absent"}`);
   }
   return h.digest("hex").slice(0, 16);
 }
 function fileStamp(filePath) {
   try {
-    const st = fs42.statSync(filePath);
+    const st = fs43.statSync(filePath);
     return { size: st.size, mtimeMs: st.mtimeMs };
   } catch {
     return null;
@@ -33018,8 +33221,8 @@ var init_scan_cache = __esm({
       "trusted-hosts.json",
       "trusted-recipients.json",
       "rules-cache.json",
-      path43.join("osv", "npm", "meta.json"),
-      path43.join("osv", "PyPI", "meta.json")
+      path44.join("osv", "npm", "meta.json"),
+      path44.join("osv", "PyPI", "meta.json")
     ];
     ScanCache = class {
       root;
@@ -33048,7 +33251,7 @@ var init_scan_cache = __esm({
         if (!this.enabled) return fresh;
         try {
           const raw = JSON.parse(
-            fs42.readFileSync(path43.join(this.root, "index.json"), "utf8")
+            fs43.readFileSync(path44.join(this.root, "index.json"), "utf8")
           );
           if (raw.cacheVersion !== SCAN_CACHE_VERSION || raw.engineVersion !== CANONICAL_EXTRACTOR_VERSION || raw.proxyVersion !== PROXY_VERSION || raw.configHash !== configHash || typeof raw.files !== "object") {
             this.dropAll();
@@ -33061,7 +33264,7 @@ var init_scan_cache = __esm({
       }
       dropAll() {
         try {
-          fs42.rmSync(this.root, { recursive: true, force: true });
+          fs43.rmSync(this.root, { recursive: true, force: true });
         } catch {
         }
       }
@@ -33085,7 +33288,7 @@ var init_scan_cache = __esm({
           }
         }
         try {
-          const stored = JSON.parse(fs42.readFileSync(path43.join(this.root, e.result), "utf8"));
+          const stored = JSON.parse(fs43.readFileSync(path44.join(this.root, e.result), "utf8"));
           if ((stored.judgedFrom ?? null) !== (e.judgedFrom ?? null) || !stored.result) {
             this.misses++;
             return null;
@@ -33100,14 +33303,14 @@ var init_scan_cache = __esm({
       put(filePath, stamp, agent, result, hasher, judgeFrom = null) {
         if (!this.enabled) return;
         const name = createHash6("sha256").update(`${agent}|${filePath}`).digest("hex").slice(0, 40);
-        const rel = path43.join("files", name.slice(0, 2), `${name}.json`);
+        const rel = path44.join("files", name.slice(0, 2), `${name}.json`);
         const configHashes = {};
         if (hasher)
           for (const cwd of result.configCwds ?? []) configHashes[cwd] = hasher.configHashFor(cwd);
         try {
-          const abs = path43.join(this.root, rel);
-          fs42.mkdirSync(path43.dirname(abs), { recursive: true, mode: 448 });
-          fs42.writeFileSync(
+          const abs = path44.join(this.root, rel);
+          fs43.mkdirSync(path44.dirname(abs), { recursive: true, mode: 448 });
+          fs43.writeFileSync(
             abs,
             JSON.stringify({ judgedFrom: judgeFrom ? judgeFrom.toISOString() : null, result }),
             { mode: 384 }
@@ -33130,9 +33333,9 @@ var init_scan_cache = __esm({
       /** Drop the entries of transcripts that no longer exist, and their files. */
       prune() {
         for (const [key, e] of Object.entries(this.index.files)) {
-          if (fs42.existsSync(key)) continue;
+          if (fs43.existsSync(key)) continue;
           try {
-            fs42.rmSync(path43.join(this.root, e.result), { force: true });
+            fs43.rmSync(path44.join(this.root, e.result), { force: true });
           } catch {
           }
           delete this.index.files[key];
@@ -33153,10 +33356,10 @@ var init_scan_cache = __esm({
         this.lastFlush = Date.now();
         if (!this.dirty) return;
         try {
-          fs42.mkdirSync(this.root, { recursive: true, mode: 448 });
-          const tmp = path43.join(this.root, `index.${process.pid}.tmp`);
-          fs42.writeFileSync(tmp, JSON.stringify(this.index), { mode: 384 });
-          fs42.renameSync(tmp, path43.join(this.root, "index.json"));
+          fs43.mkdirSync(this.root, { recursive: true, mode: 448 });
+          const tmp = path44.join(this.root, `index.${process.pid}.tmp`);
+          fs43.writeFileSync(tmp, JSON.stringify(this.index), { mode: 384 });
+          fs43.renameSync(tmp, path44.join(this.root, "index.json"));
           this.dirty = false;
         } catch {
         }
@@ -33166,9 +33369,9 @@ var init_scan_cache = __esm({
 });
 
 // src/cli/commands/scan-judge.ts
-import fs43 from "fs";
-import os36 from "os";
-import path44 from "path";
+import fs44 from "fs";
+import os37 from "os";
+import path45 from "path";
 function findingDedupKey(f) {
   return `${f.source.rule.name ?? "<unnamed>"}|${preview(f.input)}|${f.project}|${f.repo ?? ""}`;
 }
@@ -33267,24 +33470,24 @@ var init_scan_judge = __esm({
        *  file, so worktrees count), home-relative; undefined when none. Cached per
        *  directory: history repeats the same few cwds thousands of times. */
       repoOf(cwd) {
-        if (!cwd || !path44.isAbsolute(cwd)) return void 0;
+        if (!cwd || !path45.isAbsolute(cwd)) return void 0;
         if (this.repos.has(cwd)) return this.repos.get(cwd);
         let dir2 = cwd;
         let found;
         for (; ; ) {
           try {
-            if (fs43.existsSync(path44.join(dir2, ".git"))) {
+            if (fs44.existsSync(path45.join(dir2, ".git"))) {
               found = dir2;
               break;
             }
           } catch {
             break;
           }
-          const parent = path44.dirname(dir2);
+          const parent = path45.dirname(dir2);
           if (parent === dir2) break;
           dir2 = parent;
         }
-        const home = os36.homedir();
+        const home = os37.homedir();
         const label3 = found && found.startsWith(home) ? "~" + found.slice(home.length) : found;
         this.repos.set(cwd, label3);
         return label3;
@@ -33429,15 +33632,15 @@ var init_scan_judge = __esm({
 });
 
 // src/pricing/litellm.ts
-import fs44 from "fs";
-import path45 from "path";
-import os37 from "os";
+import fs45 from "fs";
+import path46 from "path";
+import os38 from "os";
 function normalizeModel(raw) {
   return raw.replace(/-\d{8}$/, "").toLowerCase();
 }
 function readCache(opts) {
   try {
-    const raw = JSON.parse(fs44.readFileSync(CACHE_FILE(), "utf-8"));
+    const raw = JSON.parse(fs45.readFileSync(CACHE_FILE(), "utf-8"));
     if (typeof raw.fetchedAt !== "string" || typeof raw.prices !== "object" || raw.prices === null) {
       return null;
     }
@@ -33452,18 +33655,18 @@ function readCache(opts) {
 function writeCache(prices) {
   try {
     const target = CACHE_FILE();
-    const dir2 = path45.dirname(target);
-    if (!fs44.existsSync(dir2)) fs44.mkdirSync(dir2, { recursive: true });
+    const dir2 = path46.dirname(target);
+    if (!fs45.existsSync(dir2)) fs45.mkdirSync(dir2, { recursive: true });
     const tmp = target + ".tmp";
     const body = {
       fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
       prices
     };
-    fs44.writeFileSync(tmp, JSON.stringify(body) + "\n", "utf-8");
-    fs44.renameSync(tmp, target);
+    fs45.writeFileSync(tmp, JSON.stringify(body) + "\n", "utf-8");
+    fs45.renameSync(tmp, target);
   } catch (err2) {
     try {
-      fs44.appendFileSync(
+      fs45.appendFileSync(
         HOOK_DEBUG_LOG,
         `[pricing] cache write failed: ${err2.message}
 `
@@ -33621,7 +33824,7 @@ var init_litellm = __esm({
       "gemini-2.0-flash": [75e-9, 3e-7, 0, 0],
       "gemini-1.5-pro": [125e-8, 5e-6, 0, 0]
     };
-    CACHE_FILE = () => path45.join(os37.homedir(), ".node9", "model-pricing.json");
+    CACHE_FILE = () => path46.join(os38.homedir(), ".node9", "model-pricing.json");
     TTL_MS2 = 24 * 60 * 60 * 1e3;
     memCache = null;
     memCacheAt = 0;
@@ -33631,11 +33834,11 @@ var init_litellm = __esm({
 });
 
 // src/cost-codex.ts
-import fs45 from "fs";
-import os38 from "os";
-import path46 from "path";
+import fs46 from "fs";
+import os39 from "os";
+import path47 from "path";
 function codexSessionsDir() {
-  return path46.join(process.env.CODEX_HOME?.trim() || path46.join(os38.homedir(), ".codex"), "sessions");
+  return path47.join(process.env.CODEX_HOME?.trim() || path47.join(os39.homedir(), ".codex"), "sessions");
 }
 function codexPriceFor(model) {
   return pricingFor(codexModel(model), { exact: true }) ?? CODEX_FALLBACK;
@@ -33667,14 +33870,14 @@ function codexSessionCost(model, tokens, request2) {
 function statAndFirstLine(file2) {
   const CAP = 4 * 1024 * 1024;
   const CHUNK = 64 * 1024;
-  const fd = fs45.openSync(file2, "r");
+  const fd = fs46.openSync(file2, "r");
   try {
-    const stat = fs45.fstatSync(fd);
+    const stat = fs46.fstatSync(fd);
     const limit = Math.min(stat.size, CAP);
     const parts = [];
     for (let pos = 0; pos < limit; pos += CHUNK) {
       const buf = Buffer.alloc(Math.min(CHUNK, limit - pos));
-      const read3 = fs45.readSync(fd, buf, 0, buf.length, pos);
+      const read3 = fs46.readSync(fd, buf, 0, buf.length, pos);
       if (read3 <= 0) break;
       const slice = buf.subarray(0, read3);
       const nl = slice.indexOf(10);
@@ -33683,15 +33886,15 @@ function statAndFirstLine(file2) {
     }
     return { stat, first: Buffer.concat(parts).toString("utf8") };
   } finally {
-    fs45.closeSync(fd);
+    fs46.closeSync(fd);
   }
 }
 function listCodexSessionFiles(base2 = codexSessionsDir()) {
   const files = [];
   const walk2 = (dir2) => {
     try {
-      for (const entry of fs45.readdirSync(dir2, { withFileTypes: true })) {
-        const file2 = path46.join(dir2, entry.name);
+      for (const entry of fs46.readdirSync(dir2, { withFileTypes: true })) {
+        const file2 = path47.join(dir2, entry.name);
         if (entry.isDirectory()) walk2(file2);
         else if (entry.isFile() && entry.name.endsWith(".jsonl")) files.push(file2);
       }
@@ -33699,7 +33902,7 @@ function listCodexSessionFiles(base2 = codexSessionsDir()) {
     }
   };
   walk2(base2);
-  if (path46.basename(base2) === "sessions") walk2(path46.join(path46.dirname(base2), "archived_sessions"));
+  if (path47.basename(base2) === "sessions") walk2(path47.join(path47.dirname(base2), "archived_sessions"));
   const sessions = /* @__PURE__ */ new Map();
   for (const file2 of files.sort()) {
     try {
@@ -33897,13 +34100,13 @@ var init_cost_codex = __esm({
     CODEX_FALLBACK = [5e-6, 15e-6, 0, 25e-7];
     codexSource = {
       id: "codex",
-      available: () => fs45.existsSync(codexSessionsDir()) || fs45.existsSync(path46.join(path46.dirname(codexSessionsDir()), "archived_sessions")),
+      available: () => fs46.existsSync(codexSessionsDir()) || fs46.existsSync(path47.join(path47.dirname(codexSessionsDir()), "archived_sessions")),
       collect(sinceMs) {
         const entries = [];
         for (const file2 of listCodexSessionFiles()) {
           try {
-            if (sinceMs !== void 0 && fs45.statSync(file2).mtimeMs < sinceMs) continue;
-            entries.push(...parseCodexSession(fs45.readFileSync(file2, "utf8").split("\n")));
+            if (sinceMs !== void 0 && fs46.statSync(file2).mtimeMs < sinceMs) continue;
+            entries.push(...parseCodexSession(fs46.readFileSync(file2, "utf8").split("\n")));
           } catch {
           }
         }
@@ -33914,11 +34117,11 @@ var init_cost_codex = __esm({
 });
 
 // src/cost-gemini.ts
-import fs46 from "fs";
-import os39 from "os";
-import path47 from "path";
+import fs47 from "fs";
+import os40 from "os";
+import path48 from "path";
 function geminiTmpDir() {
-  return path47.join(os39.homedir(), ".gemini", "tmp");
+  return path48.join(os40.homedir(), ".gemini", "tmp");
 }
 function geminiPriceFor(model) {
   let tuple = pricingFor(model);
@@ -33933,14 +34136,14 @@ function geminiPriceFor(model) {
 }
 function safeReaddir(dir2) {
   try {
-    return fs46.readdirSync(dir2);
+    return fs47.readdirSync(dir2);
   } catch {
     return [];
   }
 }
 function isDir(p) {
   try {
-    return fs46.statSync(p).isDirectory();
+    return fs47.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -33948,11 +34151,11 @@ function isDir(p) {
 function listGeminiSessionFiles(base2) {
   const out = [];
   for (const project of safeReaddir(base2)) {
-    const chats = path47.join(base2, project, "chats");
+    const chats = path48.join(base2, project, "chats");
     if (!isDir(chats)) continue;
     for (const f of safeReaddir(chats)) {
       if (f.startsWith("session-") && f.endsWith(".jsonl")) {
-        out.push({ file: path47.join(chats, f), project });
+        out.push({ file: path48.join(chats, f), project });
       }
     }
   }
@@ -34019,7 +34222,7 @@ var init_cost_gemini = __esm({
       id: "gemini",
       available() {
         try {
-          return fs46.existsSync(geminiTmpDir());
+          return fs47.existsSync(geminiTmpDir());
         } catch {
           return false;
         }
@@ -34028,13 +34231,13 @@ var init_cost_gemini = __esm({
         const combined2 = /* @__PURE__ */ new Map();
         for (const { file: file2, project } of listGeminiSessionFiles(geminiTmpDir())) {
           try {
-            if (sinceMs !== void 0 && fs46.statSync(file2).mtimeMs < sinceMs) continue;
+            if (sinceMs !== void 0 && fs47.statSync(file2).mtimeMs < sinceMs) continue;
           } catch {
             continue;
           }
           let content;
           try {
-            content = fs46.readFileSync(file2, "utf8");
+            content = fs47.readFileSync(file2, "utf8");
           } catch {
             continue;
           }
@@ -34059,15 +34262,15 @@ var init_cost_gemini = __esm({
 });
 
 // src/cost-copilot.ts
-import fs47 from "fs";
-import os40 from "os";
-import path48 from "path";
+import fs48 from "fs";
+import os41 from "os";
+import path49 from "path";
 function copilotSessionsDir() {
-  return path48.join(os40.homedir(), ".copilot", "session-state");
+  return path49.join(os41.homedir(), ".copilot", "session-state");
 }
 function safeReaddir2(dir2) {
   try {
-    return fs47.readdirSync(dir2);
+    return fs48.readdirSync(dir2);
   } catch {
     return [];
   }
@@ -34143,7 +34346,7 @@ var init_cost_copilot = __esm({
       id: "copilot",
       available() {
         try {
-          return fs47.existsSync(copilotSessionsDir());
+          return fs48.existsSync(copilotSessionsDir());
         } catch {
           return false;
         }
@@ -34152,15 +34355,15 @@ var init_cost_copilot = __esm({
         const base2 = copilotSessionsDir();
         const combined2 = /* @__PURE__ */ new Map();
         for (const sid of safeReaddir2(base2)) {
-          const file2 = path48.join(base2, sid, "events.jsonl");
+          const file2 = path49.join(base2, sid, "events.jsonl");
           try {
-            if (sinceMs !== void 0 && fs47.statSync(file2).mtimeMs < sinceMs) continue;
+            if (sinceMs !== void 0 && fs48.statSync(file2).mtimeMs < sinceMs) continue;
           } catch {
             continue;
           }
           let content;
           try {
-            content = fs47.readFileSync(file2, "utf8");
+            content = fs48.readFileSync(file2, "utf8");
           } catch {
             continue;
           }
@@ -34185,21 +34388,21 @@ var init_cost_copilot = __esm({
 });
 
 // src/session-files.ts
-import * as fs48 from "fs";
-import * as path49 from "path";
+import * as fs49 from "fs";
+import * as path50 from "path";
 function listSessionFiles(dir2, maxDepth = 6) {
   const out = [];
   const walk2 = (d, rel, depth) => {
     if (depth > maxDepth) return;
     let entries;
     try {
-      entries = fs48.readdirSync(d, { withFileTypes: true });
+      entries = fs49.readdirSync(d, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
-      const childRel = rel ? path49.join(rel, e.name) : e.name;
-      if (e.isDirectory()) walk2(path49.join(d, e.name), childRel, depth + 1);
+      const childRel = rel ? path50.join(rel, e.name) : e.name;
+      if (e.isDirectory()) walk2(path50.join(d, e.name), childRel, depth + 1);
       else if (e.name.endsWith(".jsonl")) out.push(childRel);
     }
   };
@@ -34207,7 +34410,7 @@ function listSessionFiles(dir2, maxDepth = 6) {
   return out;
 }
 function sessionIdOf(relPath) {
-  return path49.basename(relPath).replace(/\.jsonl$/, "");
+  return path50.basename(relPath).replace(/\.jsonl$/, "");
 }
 var init_session_files = __esm({
   "src/session-files.ts"() {
@@ -34216,17 +34419,17 @@ var init_session_files = __esm({
 });
 
 // src/costSync.ts
-import fs49 from "fs";
-import path50 from "path";
-import os41 from "os";
+import fs50 from "fs";
+import path51 from "path";
+import os42 from "os";
 function decodeProjectDirName(dirName) {
   return dirName.replace(/-/g, "/");
 }
 function parseJSONLFile(filePath, fallbackWorkingDir) {
-  const runId = path50.basename(filePath, ".jsonl");
+  const runId = path51.basename(filePath, ".jsonl");
   let content;
   try {
-    content = fs49.readFileSync(filePath, "utf8");
+    content = fs50.readFileSync(filePath, "utf8");
   } catch {
     return /* @__PURE__ */ new Map();
   }
@@ -34326,7 +34529,7 @@ async function postCostBatches(apiUrl, apiKey, machineId, entries) {
         signal: AbortSignal.timeout(15e3)
       });
       if (!res.ok) {
-        fs49.appendFileSync(HOOK_DEBUG_LOG, `[cost-sync] HTTP ${res.status}
+        fs50.appendFileSync(HOOK_DEBUG_LOG, `[cost-sync] HTTP ${res.status}
 `);
       } else {
         let stored;
@@ -34348,8 +34551,8 @@ async function postCostBatches(apiUrl, apiKey, machineId, entries) {
 }
 function debugLog(line) {
   try {
-    fs49.mkdirSync(path50.dirname(HOOK_DEBUG_LOG), { recursive: true });
-    fs49.appendFileSync(HOOK_DEBUG_LOG, line);
+    fs50.mkdirSync(path51.dirname(HOOK_DEBUG_LOG), { recursive: true });
+    fs50.appendFileSync(HOOK_DEBUG_LOG, line);
   } catch (err2) {
     console.error(`[cost-sync] could not write ${HOOK_DEBUG_LOG}: ${safeMessage(err2)}`);
   }
@@ -34362,10 +34565,10 @@ async function syncCost() {
   if (entries.length === 0) return;
   let username = "unknown";
   try {
-    username = os41.userInfo().username;
+    username = os42.userInfo().username;
   } catch {
   }
-  const machineId = `${os41.hostname()}:${username}`;
+  const machineId = `${os42.hostname()}:${username}`;
   await postCostBatches(creds.apiUrl, creds.apiKey, machineId, entries);
 }
 function startCostSync() {
@@ -34393,22 +34596,22 @@ var init_costSync = __esm({
     claudeSource = {
       id: "claude",
       available() {
-        return fs49.existsSync(path50.join(os41.homedir(), ".claude", "projects"));
+        return fs50.existsSync(path51.join(os42.homedir(), ".claude", "projects"));
       },
       collect(sinceMs) {
-        const projectsDir = path50.join(os41.homedir(), ".claude", "projects");
-        if (!fs49.existsSync(projectsDir)) return [];
+        const projectsDir = path51.join(os42.homedir(), ".claude", "projects");
+        if (!fs50.existsSync(projectsDir)) return [];
         const combined2 = /* @__PURE__ */ new Map();
         let dirs;
         try {
-          dirs = fs49.readdirSync(projectsDir);
+          dirs = fs50.readdirSync(projectsDir);
         } catch {
           return [];
         }
         for (const dir2 of dirs) {
-          const dirPath = path50.join(projectsDir, dir2);
+          const dirPath = path51.join(projectsDir, dir2);
           try {
-            if (!fs49.statSync(dirPath).isDirectory()) continue;
+            if (!fs50.statSync(dirPath).isDirectory()) continue;
           } catch {
             continue;
           }
@@ -34420,10 +34623,10 @@ var init_costSync = __esm({
           }
           const fallbackWorkingDir = decodeProjectDirName(dir2);
           for (const file2 of files) {
-            const filePath = path50.join(dirPath, file2);
+            const filePath = path51.join(dirPath, file2);
             if (sinceMs !== void 0) {
               try {
-                if (fs49.statSync(filePath).mtimeMs < sinceMs) continue;
+                if (fs50.statSync(filePath).mtimeMs < sinceMs) continue;
               } catch {
                 continue;
               }
@@ -34659,7 +34862,7 @@ function buildScanSummary(agents) {
   };
 }
 function wouldHaveVerb(summary, past = "would have blocked") {
-  return summary.policy?.recordOnly ? `logged only (${summary.policy.mode} mode, nothing enforced)` : past;
+  return summary.policy?.recordOnly ? `logged only (${levelOf(summary.policy.mode)} mode, nothing enforced)` : past;
 }
 function buildSections(findings) {
   const sectionMap = /* @__PURE__ */ new Map();
@@ -34795,10 +34998,10 @@ var init_scan_summary = __esm({
 });
 
 // src/credential-files.ts
-import path51 from "path";
+import path52 from "path";
 function homeCredentialFiles(home) {
   const f = (parts, description, score, kind = "credential") => ({
-    full: path51.join(home, ...parts),
+    full: path52.join(home, ...parts),
     label: "~/" + parts.join("/"),
     description,
     score,
@@ -34819,8 +35022,7 @@ function homeCredentialFiles(home) {
     ),
     f([".docker", "config.json"], "Docker registry auth tokens", 10),
     f([".netrc"], "FTP/HTTP credentials in plain text", 15),
-    f([".npmrc"], "npm auth token: can publish packages as you", 10),
-    f([".node9", "credentials.json"], "Node9 cloud API key", 10)
+    f([".npmrc"], "npm auth token: can publish packages as you", 10)
   ];
 }
 var init_credential_files = __esm({
@@ -34831,9 +35033,9 @@ var init_credential_files = __esm({
 
 // src/cli/commands/blast.ts
 import chalk3 from "chalk";
-import fs50 from "fs";
-import path52 from "path";
-import os42 from "os";
+import fs51 from "fs";
+import path53 from "path";
+import os43 from "os";
 function buildSensitivePaths(home, cwd) {
   const homeFiles = homeCredentialFiles(home).map(({ full, label: label3, description, score }) => ({
     full,
@@ -34844,19 +35046,19 @@ function buildSensitivePaths(home, cwd) {
   return [
     ...homeFiles,
     {
-      full: path52.join(cwd, ".env"),
+      full: path53.join(cwd, ".env"),
       label: ".env  (current folder)",
       description: "App secrets: database passwords, API keys",
       score: 20
     },
     {
-      full: path52.join(cwd, ".env.local"),
+      full: path53.join(cwd, ".env.local"),
       label: ".env.local  (current folder)",
       description: "Local overrides: often contains real credentials",
       score: 15
     },
     {
-      full: path52.join(cwd, ".env.production"),
+      full: path53.join(cwd, ".env.production"),
       label: ".env.production  (current folder)",
       description: "Production secrets",
       score: 20
@@ -34865,7 +35067,7 @@ function buildSensitivePaths(home, cwd) {
 }
 function isReadable(filePath) {
   try {
-    fs50.accessSync(filePath, fs50.constants.R_OK);
+    fs51.accessSync(filePath, fs51.constants.R_OK);
     return true;
   } catch {
     return false;
@@ -34878,13 +35080,13 @@ function scoreLabel(score) {
   return chalk3.red.bold(`${score}/100  Critical`);
 }
 function runBlast() {
-  const home = os42.homedir();
+  const home = os43.homedir();
   const cwd = process.cwd();
   const paths = buildSensitivePaths(home, cwd);
   let scoreDeduction = 0;
   const reachable = [];
   for (const p of paths) {
-    if (fs50.existsSync(p.full) && isReadable(p.full)) {
+    if (fs51.existsSync(p.full) && isReadable(p.full)) {
       reachable.push(p);
       scoreDeduction += p.score;
     }
@@ -34900,11 +35102,18 @@ function runBlast() {
   }
   return { reachable, envFindings, score: Math.max(0, 100 - scoreDeduction) };
 }
+function labelColumnWidth(labels) {
+  return Math.max(38, ...labels.map((l) => l.length + 2));
+}
 function registerBlastCommand(program2) {
   program2.command("blast").description("Map what an AI agent can currently reach on this machine").action(() => {
-    const home = os42.homedir();
+    const home = os43.homedir();
     const cwd = process.cwd();
     const { reachable, envFindings, score } = runBlast();
+    const width = labelColumnWidth([
+      ...reachable.map((p) => p.label),
+      ...envFindings.map((f) => f.key)
+    ]);
     console.log("");
     console.log(
       chalk3.bold("  \u{1F52D}  Node9 Blast Radius") + chalk3.dim("  \xB7  what an AI agent can reach from here")
@@ -34915,7 +35124,7 @@ function registerBlastCommand(program2) {
       console.log("  " + chalk3.red.bold("Sensitive files reachable:"));
       for (const p of reachable) {
         console.log(
-          "    " + chalk3.red("\u2717  ") + chalk3.yellow(p.label.padEnd(38)) + chalk3.dim(p.description)
+          "    " + chalk3.red("\u2717  ") + chalk3.yellow(p.label.padEnd(width)) + chalk3.dim(p.description)
         );
       }
       console.log("");
@@ -34924,7 +35133,7 @@ function registerBlastCommand(program2) {
       console.log("  " + chalk3.red.bold("Secrets in active environment:"));
       for (const f of envFindings) {
         console.log(
-          "    " + chalk3.red("\u2717  ") + chalk3.yellow(f.key.padEnd(38)) + chalk3.dim(f.patternName)
+          "    " + chalk3.red("\u2717  ") + chalk3.yellow(f.key.padEnd(width)) + chalk3.dim(f.patternName)
         );
       }
       console.log("");
@@ -35039,6 +35248,12 @@ function relativeDate(timestamp2, now = /* @__PURE__ */ new Date()) {
   if (days > 90) return "90d+";
   return `${days}d`;
 }
+function relativeAgo(timestamp2, now = /* @__PURE__ */ new Date()) {
+  const rel = relativeDate(timestamp2, now);
+  if (rel === "?" || rel === "today") return rel;
+  if (rel === "1d") return "yesterday";
+  return `${rel} ago`;
+}
 var PANEL_WIDTH;
 var init_scan_derive = __esm({
   "src/cli/render/scan-derive.ts"() {
@@ -35092,17 +35307,17 @@ var init_scan_json = __esm({
 });
 
 // src/cli/render/scan-history.ts
-import fs51 from "fs";
-import path53 from "path";
-import os43 from "os";
+import fs52 from "fs";
+import path54 from "path";
+import os44 from "os";
 function defaultHistoryPath() {
-  return path53.join(os43.homedir(), ".node9", "scan-history.json");
+  return path54.join(os44.homedir(), ".node9", "scan-history.json");
 }
 function readPreviousScan(opts = {}) {
   const filePath = opts.path ?? defaultHistoryPath();
   try {
-    if (!fs51.existsSync(filePath)) return null;
-    const raw = fs51.readFileSync(filePath, "utf8");
+    if (!fs52.existsSync(filePath)) return null;
+    const raw = fs52.readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed) || parsed.length === 0) return null;
     const last = parsed[parsed.length - 1];
@@ -35116,11 +35331,11 @@ function appendScanHistory(record2, opts = {}) {
   const filePath = opts.path ?? defaultHistoryPath();
   const cap = opts.cap ?? SCAN_HISTORY_CAP;
   try {
-    fs51.mkdirSync(path53.dirname(filePath), { recursive: true });
+    fs52.mkdirSync(path54.dirname(filePath), { recursive: true });
     let history = [];
-    if (fs51.existsSync(filePath)) {
+    if (fs52.existsSync(filePath)) {
       try {
-        const parsed = JSON.parse(fs51.readFileSync(filePath, "utf8"));
+        const parsed = JSON.parse(fs52.readFileSync(filePath, "utf8"));
         if (Array.isArray(parsed)) {
           history = parsed.filter(isValidRecord);
         }
@@ -35175,9 +35390,9 @@ __export(scan_watermark_exports, {
   tickForensicBroadcast: () => tickForensicBroadcast,
   tickScanWatcher: () => tickScanWatcher
 });
-import fs52 from "fs";
-import os44 from "os";
-import path54 from "path";
+import fs53 from "fs";
+import os45 from "os";
+import path55 from "path";
 import readline from "readline";
 function freshWatermark() {
   return {
@@ -35190,7 +35405,7 @@ function freshWatermark() {
 function loadWatermark() {
   let raw;
   try {
-    raw = fs52.readFileSync(WATERMARK_FILE(), "utf-8");
+    raw = fs53.readFileSync(WATERMARK_FILE(), "utf-8");
   } catch {
     return { status: "fresh", wm: freshWatermark() };
   }
@@ -35242,28 +35457,28 @@ function loadWatermark() {
 function saveWatermark(wm) {
   if (wm.schemaVersion > WATERMARK_SCHEMA_VERSION) return;
   const target = WATERMARK_FILE();
-  const dir2 = path54.dirname(target);
-  if (!fs52.existsSync(dir2)) fs52.mkdirSync(dir2, { recursive: true });
+  const dir2 = path55.dirname(target);
+  if (!fs53.existsSync(dir2)) fs53.mkdirSync(dir2, { recursive: true });
   const tmp = target + ".tmp";
-  fs52.writeFileSync(tmp, JSON.stringify(wm, null, 2) + "\n", "utf-8");
-  fs52.renameSync(tmp, target);
+  fs53.writeFileSync(tmp, JSON.stringify(wm, null, 2) + "\n", "utf-8");
+  fs53.renameSync(tmp, target);
 }
 function listJsonlFiles() {
   const root = PROJECTS_DIR();
-  if (!fs52.existsSync(root)) return [];
+  if (!fs53.existsSync(root)) return [];
   const out = [];
-  for (const entry of fs52.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs53.readdirSync(root, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const projectDir = path54.join(root, entry.name);
+    const projectDir = path55.join(root, entry.name);
     let inner;
     try {
-      inner = fs52.readdirSync(projectDir, { withFileTypes: true });
+      inner = fs53.readdirSync(projectDir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const file2 of inner) {
       if (file2.isFile() && file2.name.endsWith(".jsonl")) {
-        out.push(path54.join(projectDir, file2.name));
+        out.push(path55.join(projectDir, file2.name));
       }
     }
   }
@@ -35271,7 +35486,7 @@ function listJsonlFiles() {
 }
 function fileSize(p) {
   try {
-    return fs52.statSync(p).size;
+    return fs53.statSync(p).size;
   } catch {
     return 0;
   }
@@ -35281,7 +35496,7 @@ async function scanDelta(filePath, fromByte, onLine) {
   if (size <= fromByte) return fromByte;
   const lastNl = findLastNewline(filePath, fromByte, size);
   const endsWithNewline = lastNl === size - 1;
-  const stream = fs52.createReadStream(filePath, {
+  const stream = fs53.createReadStream(filePath, {
     start: fromByte,
     end: size - 1,
     highWaterMark: 64 * 1024
@@ -35310,7 +35525,7 @@ function findLastNewline(filePath, from, size) {
   const CHUNK = 64 * 1024;
   let fd;
   try {
-    fd = fs52.openSync(filePath, "r");
+    fd = fs53.openSync(filePath, "r");
   } catch {
     return -1;
   }
@@ -35319,7 +35534,7 @@ function findLastNewline(filePath, from, size) {
     let end = size;
     while (end > from) {
       const start = Math.max(from, end - CHUNK);
-      const n = fs52.readSync(fd, buf, 0, end - start, start);
+      const n = fs53.readSync(fd, buf, 0, end - start, start);
       const idx = buf.subarray(0, n).lastIndexOf(10);
       if (idx !== -1) return start + idx;
       end = start;
@@ -35328,7 +35543,7 @@ function findLastNewline(filePath, from, size) {
   } catch {
     return -1;
   } finally {
-    fs52.closeSync(fd);
+    fs53.closeSync(fd);
   }
 }
 function safeCanaryCtxValues() {
@@ -35339,7 +35554,7 @@ function safeCanaryCtxValues() {
   }
 }
 function canonicalContextForLine(obj, sessionId, lineIndex, canaryVals = []) {
-  const cwd = typeof obj.cwd === "string" && path54.isAbsolute(obj.cwd) ? obj.cwd : void 0;
+  const cwd = typeof obj.cwd === "string" && path55.isAbsolute(obj.cwd) ? obj.cwd : void 0;
   return {
     sessionId,
     lineIndex,
@@ -35355,7 +35570,7 @@ function canonicalContextForLine(obj, sessionId, lineIndex, canaryVals = []) {
     // line-level DLP runs above already
     canaryValues: canaryVals,
     ...cwd && { cwd },
-    homeDirs: [os44.homedir()]
+    homeDirs: [os45.homedir()]
   };
 }
 function extractFindingsFromLine(line, sessionId, lineIndex, canaryVals = []) {
@@ -35443,7 +35658,7 @@ async function tickForensicBroadcast(offsets) {
       continue;
     }
     if (size <= offset) continue;
-    const sessionId = path54.basename(file2, ".jsonl");
+    const sessionId = path55.basename(file2, ".jsonl");
     const newOffset = await scanDelta(file2, offset, (obj, lineIndex) => {
       out.push(...extractFindingsFromLine(obj, sessionId, lineIndex, canaryVals));
     });
@@ -35499,7 +35714,7 @@ function emptyTick(uploadAs) {
 function readRawWatermarkPreservingOffsets() {
   let raw;
   try {
-    raw = fs52.readFileSync(WATERMARK_FILE(), "utf-8");
+    raw = fs53.readFileSync(WATERMARK_FILE(), "utf-8");
   } catch {
     return null;
   }
@@ -35534,13 +35749,13 @@ async function runActualTick(wm) {
     if (!known) {
       let mtimeMs = 0;
       try {
-        mtimeMs = fs52.statSync(filePath).mtime.getTime();
+        mtimeMs = fs53.statSync(filePath).mtime.getTime();
       } catch {
         continue;
       }
       if (mtimeMs >= watermarkCreatedAt) {
         filesNew++;
-        const sessionId2 = path54.basename(filePath, ".jsonl");
+        const sessionId2 = path55.basename(filePath, ".jsonl");
         const newScannedTo2 = await scanDelta(filePath, 0, (obj, lineIndex) => {
           totalToolCalls++;
           toolCallsBySession[sessionId2] = (toolCallsBySession[sessionId2] ?? 0) + 1;
@@ -35558,7 +35773,7 @@ async function runActualTick(wm) {
       filesSkipped++;
       continue;
     }
-    const sessionId = path54.basename(filePath, ".jsonl");
+    const sessionId = path55.basename(filePath, ".jsonl");
     const newScannedTo = await scanDelta(filePath, known.scannedTo, (obj, lineIndex) => {
       totalToolCalls++;
       toolCallsBySession[sessionId] = (toolCallsBySession[sessionId] ?? 0) + 1;
@@ -35593,8 +35808,8 @@ var init_scan_watermark = __esm({
     init_registry2();
     init_config();
     init_dist();
-    PROJECTS_DIR = () => path54.join(os44.homedir(), ".claude", "projects");
-    WATERMARK_FILE = () => path54.join(os44.homedir(), ".node9", "scan-watermark.json");
+    PROJECTS_DIR = () => path55.join(os45.homedir(), ".claude", "projects");
+    WATERMARK_FILE = () => path55.join(os45.homedir(), ".node9", "scan-watermark.json");
     MAX_LINE_BYTES = 2 * 1024 * 1024;
     WATERMARK_SCHEMA_VERSION = 2;
     LONG_OUTPUT_THRESHOLD_BYTES2 = LONG_OUTPUT_THRESHOLD_BYTES;
@@ -35610,10 +35825,10 @@ __export(scan_upload_history_exports, {
   parseSinceCutoff: () => parseSinceCutoff,
   runUploadHistory: () => runUploadHistory
 });
-import fs53 from "fs";
+import fs54 from "fs";
 import https from "https";
-import os45 from "os";
-import path55 from "path";
+import os46 from "os";
+import path56 from "path";
 import chalk5 from "chalk";
 function emptySignals2() {
   return {
@@ -35648,40 +35863,40 @@ function parseSinceCutoff(raw, now = /* @__PURE__ */ new Date()) {
   return now.getTime() - 90 * 864e5;
 }
 function* iterateJsonlFiles(cutoffMs) {
-  const projectsDir = path55.join(os45.homedir(), ".claude", "projects");
+  const projectsDir = path56.join(os46.homedir(), ".claude", "projects");
   let dirs;
   try {
-    dirs = fs53.readdirSync(projectsDir);
+    dirs = fs54.readdirSync(projectsDir);
   } catch {
     return;
   }
   for (const dir2 of dirs) {
-    const dirPath = path55.join(projectsDir, dir2);
+    const dirPath = path56.join(projectsDir, dir2);
     let stats;
     try {
-      stats = fs53.statSync(dirPath);
+      stats = fs54.statSync(dirPath);
     } catch {
       continue;
     }
     if (!stats.isDirectory()) continue;
     let files;
     try {
-      files = fs53.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl"));
+      files = fs54.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl"));
     } catch {
       continue;
     }
     for (const file2 of files) {
-      const filePath = path55.join(dirPath, file2);
+      const filePath = path56.join(dirPath, file2);
       let mtime = 0;
       try {
-        mtime = fs53.statSync(filePath).mtimeMs;
+        mtime = fs54.statSync(filePath).mtimeMs;
       } catch {
         continue;
       }
       if (mtime < cutoffMs) continue;
       yield {
         filePath,
-        sessionId: path55.basename(file2, ".jsonl"),
+        sessionId: path56.basename(file2, ".jsonl"),
         projectDir: dir2
       };
     }
@@ -35749,7 +35964,7 @@ async function runUploadHistory(opts) {
     filesScanned++;
     let content;
     try {
-      content = fs53.readFileSync(filePath, "utf8");
+      content = fs54.readFileSync(filePath, "utf8");
     } catch {
       continue;
     }
@@ -35823,10 +36038,10 @@ async function runUploadHistory(opts) {
     const costUrl = creds.apiUrl.endsWith("/policies/sync") ? creds.apiUrl.replace(/\/policies\/sync$/, "/cost-sync") : `${creds.apiUrl.replace(/\/$/, "")}/cost-sync`;
     let username = "unknown";
     try {
-      username = os45.userInfo().username;
+      username = os46.userInfo().username;
     } catch {
     }
-    const machineId = `${os45.hostname()}:${username}`;
+    const machineId = `${os46.hostname()}:${username}`;
     await postJson(costUrl, creds.apiKey, {
       machineId,
       entries: dailyEntries
@@ -35900,9 +36115,9 @@ var init_scan_upload_history = __esm({
 
 // src/cli/commands/scan.ts
 import chalk6 from "chalk";
-import fs54 from "fs";
-import path56 from "path";
-import os46 from "os";
+import fs55 from "fs";
+import path57 from "path";
+import os47 from "os";
 import stringWidth2 from "string-width";
 function dayKey(ts) {
   if (!ts) return "unknown";
@@ -36045,7 +36260,7 @@ function emptyScanDedup() {
   return { findingsKeys: /* @__PURE__ */ new Set(), dlpKeys: /* @__PURE__ */ new Set(), canaryIndex: /* @__PURE__ */ new Map() };
 }
 function displayHome(p) {
-  const home = os46.homedir();
+  const home = os47.homedir();
   return p.startsWith(home) ? "~" + p.slice(home.length) : p;
 }
 function dlpKey(patternName, redactedSample, projLabel, timestamp2) {
@@ -36184,7 +36399,7 @@ function detectLoops(calls, project, sessionId, agent) {
   return findings.sort((a, b) => b.count - a.count);
 }
 function geminiChatFiles(chatsDir) {
-  const files = fs54.readdirSync(chatsDir).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl")).sort((a, b) => Number(b.endsWith(".jsonl")) - Number(a.endsWith(".jsonl")));
+  const files = fs55.readdirSync(chatsDir).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl")).sort((a, b) => Number(b.endsWith(".jsonl")) - Number(a.endsWith(".jsonl")));
   const seen = /* @__PURE__ */ new Set();
   return files.filter((f) => {
     const id = f.replace(/\.jsonl?$/, "");
@@ -36196,14 +36411,14 @@ function geminiChatFiles(chatsDir) {
 function countScanFiles(startDate = null) {
   let total = 0;
   const counts = (p) => fileMayHoldWindow(fileStamp(p), startDate);
-  const claudeDir = path56.join(os46.homedir(), ".claude", "projects");
-  if (fs54.existsSync(claudeDir)) {
+  const claudeDir = path57.join(os47.homedir(), ".claude", "projects");
+  if (fs55.existsSync(claudeDir)) {
     try {
-      for (const proj of fs54.readdirSync(claudeDir)) {
-        const p = path56.join(claudeDir, proj);
+      for (const proj of fs55.readdirSync(claudeDir)) {
+        const p = path57.join(claudeDir, proj);
         try {
-          if (!fs54.statSync(p).isDirectory()) continue;
-          total += listSessionFiles(p).filter((f) => counts(path56.join(p, f))).length;
+          if (!fs55.statSync(p).isDirectory()) continue;
+          total += listSessionFiles(p).filter((f) => counts(path57.join(p, f))).length;
         } catch {
           continue;
         }
@@ -36211,18 +36426,18 @@ function countScanFiles(startDate = null) {
     } catch {
     }
   }
-  const geminiDir = path56.join(os46.homedir(), ".gemini", "tmp");
-  if (fs54.existsSync(geminiDir)) {
+  const geminiDir = path57.join(os47.homedir(), ".gemini", "tmp");
+  if (fs55.existsSync(geminiDir)) {
     try {
-      for (const slug2 of fs54.readdirSync(geminiDir)) {
-        const p = path56.join(geminiDir, slug2);
+      for (const slug2 of fs55.readdirSync(geminiDir)) {
+        const p = path57.join(geminiDir, slug2);
         try {
-          if (!fs54.statSync(p).isDirectory()) continue;
-          const chatsDir = path56.join(p, "chats");
-          if (fs54.existsSync(chatsDir)) {
+          if (!fs55.statSync(p).isDirectory()) continue;
+          const chatsDir = path57.join(p, "chats");
+          if (fs55.existsSync(chatsDir)) {
             try {
               total += geminiChatFiles(chatsDir).filter(
-                (f) => counts(path56.join(chatsDir, f))
+                (f) => counts(path57.join(chatsDir, f))
               ).length;
             } catch {
             }
@@ -36235,13 +36450,13 @@ function countScanFiles(startDate = null) {
     }
   }
   for (const surface of ["antigravity-cli", "antigravity-ide"]) {
-    const brainDir = path56.join(os46.homedir(), ".gemini", surface, "brain");
-    if (!fs54.existsSync(brainDir)) continue;
+    const brainDir = path57.join(os47.homedir(), ".gemini", surface, "brain");
+    if (!fs55.existsSync(brainDir)) continue;
     try {
-      for (const conv of fs54.readdirSync(brainDir)) {
-        const convPath = path56.join(brainDir, conv);
+      for (const conv of fs55.readdirSync(brainDir)) {
+        const convPath = path57.join(brainDir, conv);
         try {
-          if (!fs54.statSync(convPath).isDirectory()) continue;
+          if (!fs55.statSync(convPath).isDirectory()) continue;
           const transcript = antigravityTranscriptPath(convPath);
           if (transcript && counts(transcript)) total += 1;
         } catch {
@@ -36251,12 +36466,12 @@ function countScanFiles(startDate = null) {
     } catch {
     }
   }
-  const copilotDir = path56.join(os46.homedir(), ".copilot", "session-state");
-  if (fs54.existsSync(copilotDir)) {
+  const copilotDir = path57.join(os47.homedir(), ".copilot", "session-state");
+  if (fs55.existsSync(copilotDir)) {
     try {
-      for (const sid of fs54.readdirSync(copilotDir)) {
-        const events = path56.join(copilotDir, sid, "events.jsonl");
-        if (fs54.existsSync(events) && counts(events)) total += 1;
+      for (const sid of fs55.readdirSync(copilotDir)) {
+        const events = path57.join(copilotDir, sid, "events.jsonl");
+        if (fs55.existsSync(events) && counts(events)) total += 1;
       }
     } catch {
     }
@@ -36280,7 +36495,7 @@ async function processClaudeFile(file2, projPath, projLabel, judge, judgeFrom, r
   const session = { sessionId, costUSD: 0, toolCalls: 0 };
   let raw;
   try {
-    raw = fs54.readFileSync(path56.join(projPath, file2), "utf-8");
+    raw = fs55.readFileSync(path57.join(projPath, file2), "utf-8");
   } catch {
     return false;
   }
@@ -36349,7 +36564,7 @@ async function processClaudeFile(file2, projPath, projLabel, judge, judgeFrom, r
           if (block.type !== "tool_result") continue;
           const filePath = block.tool_use_id ? toolUseFilePaths.get(block.tool_use_id) : void 0;
           if (filePath) {
-            const ext = path56.extname(filePath).toLowerCase();
+            const ext = path57.extname(filePath).toLowerCase();
             if (CODE_EXTENSIONS.has(ext)) continue;
           }
           const resultText = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.map((c) => c.text ?? "").join("\n") : null;
@@ -36469,9 +36684,9 @@ async function processClaudeFile(file2, projPath, projLabel, judge, judgeFrom, r
   return true;
 }
 async function processClaudeProject(proj, projectsDir, judge, cache7, startDate, result, dedup, canaryVals, onProgress, onLine) {
-  const projPath = path56.join(projectsDir, proj);
+  const projPath = path57.join(projectsDir, proj);
   try {
-    if (!fs54.statSync(projPath).isDirectory()) return;
+    if (!fs55.statSync(projPath).isDirectory()) return;
   } catch {
     return;
   }
@@ -36483,7 +36698,7 @@ async function processClaudeProject(proj, projectsDir, judge, cache7, startDate,
     return;
   }
   for (const file2 of files) {
-    const filePath = path56.join(projPath, file2);
+    const filePath = path57.join(projPath, file2);
     const stamp = fileStamp(filePath);
     if (!fileMayHoldWindow(stamp, startDate)) continue;
     result.filesScanned++;
@@ -36514,7 +36729,7 @@ async function processClaudeProject(proj, projectsDir, judge, cache7, startDate,
 }
 function claudeProjectLabel(dirName) {
   const name = decodeURIComponent(dirName);
-  const homeDashed = os46.homedir().replace(/\//g, "-");
+  const homeDashed = os47.homedir().replace(/\//g, "-");
   const label3 = name.startsWith(homeDashed) ? "~" + decodeProjectDirName(name.slice(homeDashed.length)) : decodeProjectDirName(name);
   return stripTerminalEscapes(label3).slice(0, 40);
 }
@@ -36625,12 +36840,12 @@ function mergeFileScan(result, file2, dedup, startDate = null) {
   }
 }
 async function scanClaudeHistory(startDate, onProgress, onLine, opts = {}) {
-  const projectsDir = path56.join(os46.homedir(), ".claude", "projects");
+  const projectsDir = path57.join(os47.homedir(), ".claude", "projects");
   const result = emptyClaudeScan();
-  if (!fs54.existsSync(projectsDir)) return result;
+  if (!fs55.existsSync(projectsDir)) return result;
   let projDirs;
   try {
-    projDirs = fs54.readdirSync(projectsDir);
+    projDirs = fs55.readdirSync(projectsDir);
   } catch {
     return result;
   }
@@ -36658,7 +36873,7 @@ async function scanClaudeHistory(startDate, onProgress, onLine, opts = {}) {
 }
 async function scanGeminiHistory(startDate, onProgress, onLine, opts = {}) {
   const canaryVals = safeCanaryScanValues();
-  const tmpDir = path56.join(os46.homedir(), ".gemini", "tmp");
+  const tmpDir = path57.join(os47.homedir(), ".gemini", "tmp");
   const result = {
     filesScanned: 0,
     sessions: 0,
@@ -36675,31 +36890,31 @@ async function scanGeminiHistory(startDate, onProgress, onLine, opts = {}) {
     perSession: []
   };
   const dedup = emptyScanDedup();
-  if (!fs54.existsSync(tmpDir)) return result;
+  if (!fs55.existsSync(tmpDir)) return result;
   let slugDirs;
   try {
-    slugDirs = fs54.readdirSync(tmpDir);
+    slugDirs = fs55.readdirSync(tmpDir);
   } catch {
     return result;
   }
   const judge = new HistoryJudge();
   const cache7 = openScanCache(judge, opts);
   for (const slug2 of slugDirs) {
-    const slugPath = path56.join(tmpDir, slug2);
+    const slugPath = path57.join(tmpDir, slug2);
     try {
-      if (!fs54.statSync(slugPath).isDirectory()) continue;
+      if (!fs55.statSync(slugPath).isDirectory()) continue;
     } catch {
       continue;
     }
     let projLabel = stripTerminalEscapes(slug2).slice(0, 40);
     try {
       projLabel = stripTerminalEscapes(
-        fs54.readFileSync(path56.join(slugPath, ".project_root"), "utf-8").trim()
-      ).replace(os46.homedir(), "~").slice(0, 40);
+        fs55.readFileSync(path57.join(slugPath, ".project_root"), "utf-8").trim()
+      ).replace(os47.homedir(), "~").slice(0, 40);
     } catch {
     }
-    const chatsDir = path56.join(slugPath, "chats");
-    if (!fs54.existsSync(chatsDir)) continue;
+    const chatsDir = path57.join(slugPath, "chats");
+    if (!fs55.existsSync(chatsDir)) continue;
     let chatFiles;
     try {
       chatFiles = geminiChatFiles(chatsDir);
@@ -36708,7 +36923,7 @@ async function scanGeminiHistory(startDate, onProgress, onLine, opts = {}) {
     }
     for (const chatFile of chatFiles) {
       const sessionId = chatFile.replace(/\.jsonl?$/, "");
-      const filePath = path56.join(chatsDir, chatFile);
+      const filePath = path57.join(chatsDir, chatFile);
       const stamp = fileStamp(filePath);
       if (!fileMayHoldWindow(stamp, startDate)) continue;
       result.filesScanned++;
@@ -36722,7 +36937,7 @@ async function scanGeminiHistory(startDate, onProgress, onLine, opts = {}) {
       const fileDedup = emptyScanDedup();
       let raw;
       try {
-        raw = fs54.readFileSync(path56.join(chatsDir, chatFile), "utf-8");
+        raw = fs55.readFileSync(path57.join(chatsDir, chatFile), "utf-8");
       } catch {
         continue;
       }
@@ -36859,13 +37074,13 @@ async function scanGeminiHistory(startDate, onProgress, onLine, opts = {}) {
   return result;
 }
 function antigravityBrainDirs() {
-  return ["antigravity-cli", "antigravity-ide"].map((surface) => path56.join(os46.homedir(), ".gemini", surface, "brain")).filter((p) => fs54.existsSync(p));
+  return ["antigravity-cli", "antigravity-ide"].map((surface) => path57.join(os47.homedir(), ".gemini", surface, "brain")).filter((p) => fs55.existsSync(p));
 }
 function antigravityTranscriptPath(convPath) {
-  const logsDir = path56.join(convPath, ".system_generated", "logs");
+  const logsDir = path57.join(convPath, ".system_generated", "logs");
   for (const name of ["transcript_full.jsonl", "transcript.jsonl"]) {
-    const p = path56.join(logsDir, name);
-    if (fs54.existsSync(p)) return p;
+    const p = path57.join(logsDir, name);
+    if (fs55.existsSync(p)) return p;
   }
   return null;
 }
@@ -36895,14 +37110,14 @@ async function scanAntigravityHistory(startDate, onProgress, onLine, opts = {})
   for (const brainDir of brainDirs) {
     let convDirs;
     try {
-      convDirs = fs54.readdirSync(brainDir);
+      convDirs = fs55.readdirSync(brainDir);
     } catch {
       continue;
     }
     for (const conv of convDirs) {
-      const convPath = path56.join(brainDir, conv);
+      const convPath = path57.join(brainDir, conv);
       try {
-        if (!fs54.statSync(convPath).isDirectory()) continue;
+        if (!fs55.statSync(convPath).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -36921,7 +37136,7 @@ async function scanAntigravityHistory(startDate, onProgress, onLine, opts = {})
       const fileDedup = emptyScanDedup();
       let raw;
       try {
-        raw = fs54.readFileSync(transcriptFile, "utf-8");
+        raw = fs55.readFileSync(transcriptFile, "utf-8");
       } catch {
         continue;
       }
@@ -36996,7 +37211,7 @@ async function scanAntigravityHistory(startDate, onProgress, onLine, opts = {})
             day.bashCalls++;
             const cwd = String(input.cwd ?? "");
             if (cwd && projLabel === conv.slice(0, 8)) {
-              projLabel = stripTerminalEscapes(cwd).replace(os46.homedir(), "~").slice(0, 40);
+              projLabel = stripTerminalEscapes(cwd).replace(os47.homedir(), "~").slice(0, 40);
             }
           }
           const rawCmd = String(input.command ?? "").trimStart();
@@ -37022,7 +37237,7 @@ async function scanAntigravityHistory(startDate, onProgress, onLine, opts = {})
               timestamp: timestamp2,
               sessionId,
               project: projLabel,
-              cwd: typeof input.cwd === "string" && path56.isAbsolute(input.cwd) ? input.cwd : void 0
+              cwd: typeof input.cwd === "string" && path57.isAbsolute(input.cwd) ? input.cwd : void 0
             },
             fileResult,
             fileDedup
@@ -37045,7 +37260,7 @@ async function scanAntigravityHistory(startDate, onProgress, onLine, opts = {})
 }
 async function scanCopilotHistory(startDate, onProgress, onLine, opts = {}) {
   const canaryVals = safeCanaryScanValues();
-  const sessionDir = path56.join(os46.homedir(), ".copilot", "session-state");
+  const sessionDir = path57.join(os47.homedir(), ".copilot", "session-state");
   const result = {
     filesScanned: 0,
     sessions: 0,
@@ -37063,18 +37278,18 @@ async function scanCopilotHistory(startDate, onProgress, onLine, opts = {}) {
     perSession: []
   };
   const dedup = emptyScanDedup();
-  if (!fs54.existsSync(sessionDir)) return result;
+  if (!fs55.existsSync(sessionDir)) return result;
   let sessionIds;
   try {
-    sessionIds = fs54.readdirSync(sessionDir);
+    sessionIds = fs55.readdirSync(sessionDir);
   } catch {
     return result;
   }
   const judge = new HistoryJudge();
   const cache7 = openScanCache(judge, opts);
   for (const sessionId of sessionIds) {
-    const eventsPath = path56.join(sessionDir, sessionId, "events.jsonl");
-    if (!fs54.existsSync(eventsPath)) continue;
+    const eventsPath = path57.join(sessionDir, sessionId, "events.jsonl");
+    if (!fs55.existsSync(eventsPath)) continue;
     const stamp = fileStamp(eventsPath);
     if (!fileMayHoldWindow(stamp, startDate)) continue;
     result.filesScanned++;
@@ -37088,7 +37303,7 @@ async function scanCopilotHistory(startDate, onProgress, onLine, opts = {}) {
     const fileDedup = emptyScanDedup();
     let raw;
     try {
-      raw = fs54.readFileSync(eventsPath, "utf-8");
+      raw = fs55.readFileSync(eventsPath, "utf-8");
     } catch {
       continue;
     }
@@ -37113,8 +37328,8 @@ async function scanCopilotHistory(startDate, onProgress, onLine, opts = {}) {
       if (ev.type === "session.start") {
         const cwd = ev.data?.context?.cwd;
         if (typeof cwd === "string" && cwd) {
-          projLabel = stripTerminalEscapes(cwd).replace(os46.homedir(), "~").slice(0, 40);
-          if (path56.isAbsolute(cwd)) sessionCwd = cwd;
+          projLabel = stripTerminalEscapes(cwd).replace(os47.homedir(), "~").slice(0, 40);
+          if (path57.isAbsolute(cwd)) sessionCwd = cwd;
         }
         continue;
       }
@@ -37247,7 +37462,7 @@ async function scanCodexHistory(startDate, onProgress, onLine, opts = {}) {
     const fileDedup = emptyScanDedup();
     let lines;
     try {
-      lines = fs54.readFileSync(filePath, "utf-8").split("\n");
+      lines = fs55.readFileSync(filePath, "utf-8").split("\n");
     } catch {
       continue;
     }
@@ -37270,8 +37485,8 @@ async function scanCodexHistory(startDate, onProgress, onLine, opts = {}) {
         sessionId = String(payload["id"] ?? filePath);
         startTime = String(payload["timestamp"] ?? "");
         const cwd = String(payload["cwd"] ?? "");
-        projLabel = stripTerminalEscapes(cwd.replace(os46.homedir(), "~")).slice(0, 40);
-        if (path56.isAbsolute(cwd)) sessionCwd = cwd;
+        projLabel = stripTerminalEscapes(cwd.replace(os47.homedir(), "~")).slice(0, 40);
+        if (path57.isAbsolute(cwd)) sessionCwd = cwd;
         continue;
       }
       if (entry.type === "event_msg" && payload["type"] === "user_message") {
@@ -37388,17 +37603,17 @@ async function scanCodexHistory(startDate, onProgress, onLine, opts = {}) {
   return result;
 }
 function scanShellConfig() {
-  const home = os46.homedir();
+  const home = os47.homedir();
   const configFiles = [".zshrc", ".bashrc", ".bash_profile", ".profile"].map(
-    (f) => path56.join(home, f)
+    (f) => path57.join(home, f)
   );
   const findings = [];
   const seen = /* @__PURE__ */ new Set();
   for (const filePath of configFiles) {
-    if (!fs54.existsSync(filePath)) continue;
+    if (!fs55.existsSync(filePath)) continue;
     let lines;
     try {
-      lines = fs54.readFileSync(filePath, "utf-8").split("\n");
+      lines = fs55.readFileSync(filePath, "utf-8").split("\n");
     } catch {
       continue;
     }
@@ -37728,25 +37943,25 @@ function renderPanelScorecard(input, now = /* @__PURE__ */ new Date()) {
   const topLines = [];
   if (scan.canaryFindings.length > 0) {
     const latest = scan.canaryFindings[0];
-    const rel = relativeDate(latest.timestamp, now);
+    const rel = relativeAgo(latest.timestamp, now);
     const n = scan.canaryFindings.length;
     topLines.push(
       mkLine(
         ["\u{1FAA4} ", chalk6.red],
         [`${n} decoy credential${n !== 1 ? "s" : ""} tripped  `, chalk6.bold],
-        [`(latest: ${rel} ago, ${latest.kind} at ${displayHome(latest.path)})`, chalk6.dim]
+        [`(latest: ${rel}, ${latest.kind} at ${displayHome(latest.path)})`, chalk6.dim]
       )
     );
   }
   if (scan.dlpFindings.length > 0) {
     const latest = scan.dlpFindings[0];
-    const rel = relativeDate(latest.timestamp, now);
+    const rel = relativeAgo(latest.timestamp, now);
     const noun = `credential leak${scan.dlpFindings.length !== 1 ? "s" : ""}`;
     topLines.push(
       mkLine(
         ["\u{1F6A8} ", chalk6.red],
         [`${scan.dlpFindings.length} ${noun} in tool input  `, chalk6.bold],
-        [`(latest: ${rel} ago, ${latest.patternName})`, chalk6.dim]
+        [`(latest: ${rel}, ${latest.patternName})`, chalk6.dim]
       )
     );
   }
@@ -38315,7 +38530,7 @@ function registerScanCommand(program2) {
         if (!drillDown) {
           const useInk2 = !options.classic;
           if (useInk2) {
-            const scanInkPath = path56.join(__dirname, "scan-ink.mjs");
+            const scanInkPath = path57.join(__dirname, "scan-ink.mjs");
             const dynamicImport = new Function("id", "return import(id)");
             const mod = await dynamicImport(`file://${scanInkPath}`);
             const rangeLabel2 = options.all ? "all time" : `last ${options.days ?? 90} days`;
@@ -38672,12 +38887,12 @@ var init_scan = __esm({
 });
 
 // src/daemon/build-id.ts
-import fs55 from "fs";
-import path57 from "path";
+import fs56 from "fs";
+import path58 from "path";
 function readOwnVersion() {
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const raw = fs55.readFileSync(path57.join(__dirname, rel), "utf-8");
+      const raw = fs56.readFileSync(path58.join(__dirname, rel), "utf-8");
       const v = JSON.parse(raw).version;
       if (typeof v === "string" && v.length > 0) return v;
     } catch {
@@ -38688,7 +38903,7 @@ function readOwnVersion() {
 function computeBuildId(entry = process.argv[1] ?? "") {
   let mtimeMs = 0;
   try {
-    if (entry) mtimeMs = fs55.statSync(entry).mtimeMs;
+    if (entry) mtimeMs = fs56.statSync(entry).mtimeMs;
   } catch {
   }
   return { version: readOwnVersion(), mtimeMs };
@@ -38829,8 +39044,8 @@ var init_suggestion_tracker = __esm({
 });
 
 // src/daemon/taint-store.ts
-import fs56 from "fs";
-import path58 from "path";
+import fs57 from "fs";
+import path59 from "path";
 var DEFAULT_TTL_MS, TaintStore, SESSION_TAINT_TTL_MS2, SessionTaintStore;
 var init_taint_store = __esm({
   "src/daemon/taint-store.ts"() {
@@ -38900,9 +39115,9 @@ var init_taint_store = __esm({
       /** Resolve to absolute path, falling back to path.resolve if file doesn't exist yet. */
       _resolve(filePath) {
         try {
-          return fs56.realpathSync.native(path58.resolve(filePath));
+          return fs57.realpathSync.native(path59.resolve(filePath));
         } catch {
-          return path58.resolve(filePath);
+          return path59.resolve(filePath);
         }
       }
     };
@@ -38958,7 +39173,7 @@ var init_taint_store = __esm({
 });
 
 // src/daemon/written-store.ts
-import path59 from "path";
+import path60 from "path";
 var SESSION_WRITE_TTL_MS, MAX_WRITTEN, MAX_PATH, SessionWriteStore;
 var init_written_store = __esm({
   "src/daemon/written-store.ts"() {
@@ -38970,7 +39185,7 @@ var init_written_store = __esm({
       records = /* @__PURE__ */ new Map();
       key(p) {
         if (typeof p !== "string" || !p || p.length > MAX_PATH) return null;
-        return path59.resolve(p);
+        return path60.resolve(p);
       }
       /** Record that these absolute paths were (or are about to be) written. */
       record(paths, ttlMs = SESSION_WRITE_TTL_MS) {
@@ -39301,9 +39516,9 @@ var init_cards = __esm({
 
 // src/daemon/state.ts
 import net2 from "net";
-import fs57 from "fs";
-import path60 from "path";
-import os47 from "os";
+import fs58 from "fs";
+import path61 from "path";
+import os48 from "os";
 import { randomUUID as randomUUID6 } from "crypto";
 function onCardDecided(card) {
   const r = card.record;
@@ -39329,8 +39544,8 @@ function onCardDecided(card) {
 }
 function loadInsightCounts() {
   try {
-    if (!fs57.existsSync(INSIGHT_COUNTS_FILE)) return;
-    const data = JSON.parse(fs57.readFileSync(INSIGHT_COUNTS_FILE, "utf-8"));
+    if (!fs58.existsSync(INSIGHT_COUNTS_FILE)) return;
+    const data = JSON.parse(fs58.readFileSync(INSIGHT_COUNTS_FILE, "utf-8"));
     for (const [tool, count] of Object.entries(data)) {
       if (typeof count === "number" && count > 0) insightCounts.set(tool, count);
     }
@@ -39398,16 +39613,16 @@ function appendAuditLog(data) {
       ...data.channel && { channel: data.channel },
       ...data.cardId && { cardId: data.cardId }
     };
-    const dir2 = path60.dirname(AUDIT_LOG_FILE);
-    if (!fs57.existsSync(dir2)) fs57.mkdirSync(dir2, { recursive: true });
-    fs57.appendFileSync(AUDIT_LOG_FILE, JSON.stringify(entry) + "\n");
+    const dir2 = path61.dirname(AUDIT_LOG_FILE);
+    if (!fs58.existsSync(dir2)) fs58.mkdirSync(dir2, { recursive: true });
+    fs58.appendFileSync(AUDIT_LOG_FILE, JSON.stringify(entry) + "\n");
   } catch {
   }
 }
 function getAuditHistory(limit = 20) {
   try {
-    if (!fs57.existsSync(AUDIT_LOG_FILE)) return [];
-    const lines = fs57.readFileSync(AUDIT_LOG_FILE, "utf-8").trim().split("\n");
+    if (!fs58.existsSync(AUDIT_LOG_FILE)) return [];
+    const lines = fs58.readFileSync(AUDIT_LOG_FILE, "utf-8").trim().split("\n");
     if (lines.length === 1 && lines[0] === "") return [];
     return lines.slice(-limit).map((l) => JSON.parse(l)).reverse();
   } catch {
@@ -39416,7 +39631,7 @@ function getAuditHistory(limit = 20) {
 }
 function getOrgName() {
   try {
-    if (fs57.existsSync(CREDENTIALS_FILE)) return "Node9 Cloud";
+    if (fs58.existsSync(CREDENTIALS_FILE)) return "Node9 Cloud";
   } catch {
   }
   return null;
@@ -39428,8 +39643,8 @@ function writeTrustEntry(toolName, durationMs, commandPattern) {
   try {
     let trust = { entries: [] };
     try {
-      if (fs57.existsSync(TRUST_FILE2))
-        trust = JSON.parse(fs57.readFileSync(TRUST_FILE2, "utf-8"));
+      if (fs58.existsSync(TRUST_FILE2))
+        trust = JSON.parse(fs58.readFileSync(TRUST_FILE2, "utf-8"));
     } catch {
     }
     trust.entries = trust.entries.filter(
@@ -39446,8 +39661,8 @@ function writeTrustEntry(toolName, durationMs, commandPattern) {
 }
 function readPersistentDecisions() {
   try {
-    if (fs57.existsSync(DECISIONS_FILE)) {
-      return JSON.parse(fs57.readFileSync(DECISIONS_FILE, "utf-8"));
+    if (fs58.existsSync(DECISIONS_FILE)) {
+      return JSON.parse(fs58.readFileSync(DECISIONS_FILE, "utf-8"));
     }
   } catch {
   }
@@ -39475,7 +39690,7 @@ function estimateToolCost(tool, args) {
     const filePath = a.file_path ?? a.path;
     if (filePath) {
       try {
-        const bytes = fs57.statSync(filePath).size;
+        const bytes = fs58.statSync(filePath).size;
         return bytes / BYTES_PER_TOKEN / 1e6 * INPUT_PRICE_PER_1M;
       } catch {
       }
@@ -39543,7 +39758,7 @@ function abandonPending() {
   cards.abandonLocalOnly();
   if (autoStarted && cards.open().length === 0) {
     try {
-      fs57.unlinkSync(DAEMON_PID_FILE);
+      fs58.unlinkSync(DAEMON_PID_FILE);
     } catch {
     }
     setTimeout(() => {
@@ -39554,8 +39769,8 @@ function abandonPending() {
 }
 function logActivitySocket(msg) {
   try {
-    fs57.appendFileSync(
-      path60.join(homeDir, ".node9", "hook-debug.log"),
+    fs58.appendFileSync(
+      path61.join(homeDir, ".node9", "hook-debug.log"),
       `[${(/* @__PURE__ */ new Date()).toISOString()}] [activity-socket] ${msg}
 `
     );
@@ -39577,13 +39792,13 @@ function shouldRebind(now = Date.now()) {
 function startActivitySocket() {
   bindActivitySocket();
   activityHealthInterval = setInterval(() => {
-    if (!fs57.existsSync(ACTIVITY_SOCKET_PATH2)) attemptRebind("health-probe");
+    if (!fs58.existsSync(ACTIVITY_SOCKET_PATH2)) attemptRebind("health-probe");
   }, ACTIVITY_HEALTH_PROBE_MS);
   activityHealthInterval.unref();
   process.on("exit", () => {
     if (activityHealthInterval) clearInterval(activityHealthInterval);
     try {
-      fs57.unlinkSync(ACTIVITY_SOCKET_PATH2);
+      fs58.unlinkSync(ACTIVITY_SOCKET_PATH2);
     } catch {
     }
   });
@@ -39611,7 +39826,7 @@ function attemptRebind(reason) {
 }
 function bindActivitySocket() {
   try {
-    fs57.unlinkSync(ACTIVITY_SOCKET_PATH2);
+    fs58.unlinkSync(ACTIVITY_SOCKET_PATH2);
   } catch {
   }
   const ACTIVITY_MAX_BYTES = 1024 * 1024;
@@ -39720,14 +39935,14 @@ var init_state3 = __esm({
     init_session_history();
     init_atomic_write();
     init_cards();
-    homeDir = os47.homedir();
-    DAEMON_PID_FILE = path60.join(homeDir, ".node9", "daemon.pid");
-    DECISIONS_FILE = path60.join(homeDir, ".node9", "decisions.json");
-    AUDIT_LOG_FILE = path60.join(homeDir, ".node9", "audit.log");
-    TRUST_FILE2 = path60.join(homeDir, ".node9", "trust.json");
-    GLOBAL_CONFIG_FILE = path60.join(homeDir, ".node9", "config.json");
-    CREDENTIALS_FILE = path60.join(homeDir, ".node9", "credentials.json");
-    INSIGHT_COUNTS_FILE = path60.join(homeDir, ".node9", "insight-counts.json");
+    homeDir = os48.homedir();
+    DAEMON_PID_FILE = path61.join(homeDir, ".node9", "daemon.pid");
+    DECISIONS_FILE = path61.join(homeDir, ".node9", "decisions.json");
+    AUDIT_LOG_FILE = path61.join(homeDir, ".node9", "audit.log");
+    TRUST_FILE2 = path61.join(homeDir, ".node9", "trust.json");
+    GLOBAL_CONFIG_FILE = path61.join(homeDir, ".node9", "config.json");
+    CREDENTIALS_FILE = path61.join(homeDir, ".node9", "credentials.json");
+    INSIGHT_COUNTS_FILE = path61.join(homeDir, ".node9", "insight-counts.json");
     sseClients = /* @__PURE__ */ new Set();
     cards = new CardStore({
       onDecided: onCardDecided,
@@ -39750,7 +39965,7 @@ var init_state3 = __esm({
       "2h": 2 * 60 * 6e4
     };
     autoStarted = process.env.NODE9_AUTO_STARTED === "1";
-    ACTIVITY_SOCKET_PATH2 = process.platform === "win32" ? "\\\\.\\pipe\\node9-activity" : path60.join(os47.tmpdir(), "node9-activity.sock");
+    ACTIVITY_SOCKET_PATH2 = process.platform === "win32" ? "\\\\.\\pipe\\node9-activity" : path61.join(os48.tmpdir(), "node9-activity.sock");
     ACTIVITY_RING_SIZE = 100;
     activityRing = [];
     LARGE_RESPONSE_RING_SIZE = 20;
@@ -39789,13 +40004,13 @@ var init_state3 = __esm({
 });
 
 // src/posture/secrets.ts
-import fs58 from "fs";
-import path61 from "path";
-import os48 from "os";
+import fs59 from "fs";
+import path62 from "path";
+import os49 from "os";
 function displayPath(p, home) {
   if (p === home) return "~";
-  const prefix = home.endsWith(path61.sep) ? home : home + path61.sep;
-  if (p.startsWith(prefix)) return "~" + path61.sep + p.slice(prefix.length);
+  const prefix = home.endsWith(path62.sep) ? home : home + path62.sep;
+  if (p.startsWith(prefix)) return "~" + path62.sep + p.slice(prefix.length);
   return p;
 }
 function safeRead(file2) {
@@ -39806,8 +40021,8 @@ function safeRead(file2) {
 function candidateFiles(home, cwd) {
   const files = /* @__PURE__ */ new Set();
   try {
-    for (const name of fs58.readdirSync(cwd)) {
-      if (name === ".env" || name.startsWith(".env.")) files.add(path61.join(cwd, name));
+    for (const name of fs59.readdirSync(cwd)) {
+      if (name === ".env" || name.startsWith(".env.")) files.add(path62.join(cwd, name));
     }
   } catch {
   }
@@ -39815,7 +40030,7 @@ function candidateFiles(home, cwd) {
     if (spec.hookFile) files.add(spec.hookFile(home));
     if (spec.mcpFile) files.add(spec.mcpFile(home));
   }
-  files.add(path61.join(home, ".env"));
+  files.add(path62.join(home, ".env"));
   return [...files];
 }
 function credentialMaterial(home) {
@@ -39829,7 +40044,7 @@ function plantedDecoyPaths() {
   }
 }
 function checkSecrets(ctx) {
-  const home = ctx.home || os48.homedir();
+  const home = ctx.home || os49.homedir();
   const findings = [];
   const planted = plantedDecoyPaths();
   const plaintext = [];
@@ -39865,7 +40080,7 @@ function checkSecrets(ctx) {
   for (const file2 of credentialMaterial(home)) {
     if (planted.has(file2)) continue;
     try {
-      if (fs58.statSync(file2).isFile()) {
+      if (fs59.statSync(file2).isFile()) {
         creds.push(displayPath(file2, home));
         credPaths.push(file2);
       }
@@ -40035,10 +40250,10 @@ var init_templates = __esm({
 });
 
 // src/posture/egress.ts
-import fs59 from "fs";
+import fs60 from "fs";
 function sandboxEgressWallActive() {
   try {
-    return fs59.existsSync(ALLOWED_DOMAINS_PATH);
+    return fs60.existsSync(ALLOWED_DOMAINS_PATH);
   } catch {
     return false;
   }
@@ -40050,7 +40265,7 @@ function evaluateEgressConfig(egress) {
       severity: "high",
       title: "Egress is locked, but node9 is not enforcing it",
       what: "Egress is set to block, but node9 is not applying the policy.",
-      why: "node9 isn't wired in (or is in observe mode), so the lock has no effect.",
+      why: "node9 isn't wired in (or is in audit mode), so the lock has no effect.",
       who: "The lock protects nothing until node9 is enforcing in-path.",
       owner: "node9",
       detail: [],
@@ -40067,7 +40282,7 @@ function evaluateEgressConfig(egress) {
       severity: "medium",
       title: "Egress is in review, but node9 is not enforcing it",
       what: "Egress is set to review (approval-gate), but node9 is not applying the policy.",
-      why: "node9 isn't wired in (or is in observe mode), so the gate has no effect.",
+      why: "node9 isn't wired in (or is in audit mode), so the gate has no effect.",
       who: "Nothing gates outbound until node9 is enforcing in-path.",
       owner: "node9",
       detail: [],
@@ -40208,14 +40423,14 @@ var init_gate = __esm({
 });
 
 // src/posture/supply-chain.ts
-import os49 from "os";
-import path62 from "path";
+import os50 from "os";
+import path63 from "path";
 import { parse as parseToml6 } from "smol-toml";
 function isNode9Managed(command, args = []) {
   if (!command) return false;
-  if (path62.basename(command).toLowerCase() === "node9") return true;
-  if (PACKAGE_RUNNERS.has(path62.basename(command).toLowerCase())) {
-    return args.some((a) => a === "node9" || path62.basename(a).toLowerCase() === "node9");
+  if (path63.basename(command).toLowerCase() === "node9") return true;
+  if (PACKAGE_RUNNERS.has(path63.basename(command).toLowerCase())) {
+    return args.some((a) => a === "node9" || path63.basename(a).toLowerCase() === "node9");
   }
   return false;
 }
@@ -40237,7 +40452,7 @@ function readServers(file2, format, agent) {
   }
 }
 function checkSupplyChain(ctx) {
-  const home = ctx.home || os49.homedir();
+  const home = ctx.home || os50.homedir();
   const servers = [];
   for (const spec of AGENT_SPECS) {
     if (!spec.mcpFile) continue;
@@ -40336,11 +40551,11 @@ var init_privilege = __esm({
 });
 
 // src/posture/containment.ts
-import fs60 from "fs";
+import fs61 from "fs";
 function inContainer() {
-  if (fs60.existsSync("/.dockerenv") || fs60.existsSync("/run/.containerenv")) return true;
+  if (fs61.existsSync("/.dockerenv") || fs61.existsSync("/run/.containerenv")) return true;
   try {
-    const cgroup = fs60.readFileSync("/proc/1/cgroup", "utf8");
+    const cgroup = fs61.readFileSync("/proc/1/cgroup", "utf8");
     if (/docker|kubepods|containerd|lxc|libpod/.test(cgroup)) return true;
   } catch {
   }
@@ -40386,7 +40601,7 @@ var init_containment = __esm({
 });
 
 // src/posture/inbound.ts
-import fs61 from "fs";
+import fs62 from "fs";
 function buildNetworkFix(labels) {
   const shielded = [
     ...new Map(
@@ -40444,7 +40659,7 @@ function collectListeners() {
   const byPort = /* @__PURE__ */ new Map();
   for (const file2 of ["/proc/net/tcp", "/proc/net/tcp6"]) {
     try {
-      for (const l of parseListeners(fs61.readFileSync(file2, "utf8"))) {
+      for (const l of parseListeners(fs62.readFileSync(file2, "utf8"))) {
         if (!byPort.has(l.port)) byPort.set(l.port, l);
       }
     } catch {
@@ -40456,11 +40671,11 @@ function readProc(pid) {
   let comm = "unknown";
   let cmdline = "";
   try {
-    comm = fs61.readFileSync(`/proc/${pid}/comm`, "utf8").trim().replace(/-MainThread$/, "") || "unknown";
+    comm = fs62.readFileSync(`/proc/${pid}/comm`, "utf8").trim().replace(/-MainThread$/, "") || "unknown";
   } catch {
   }
   try {
-    cmdline = fs61.readFileSync(`/proc/${pid}/cmdline`).toString().replace(/\0/g, " ").trim();
+    cmdline = fs62.readFileSync(`/proc/${pid}/cmdline`).toString().replace(/\0/g, " ").trim();
   } catch {
   }
   return { comm, cmdline };
@@ -40470,21 +40685,21 @@ function resolveProcesses(inodes) {
   if (inodes.size === 0) return map;
   let pids;
   try {
-    pids = fs61.readdirSync("/proc").filter((d) => /^\d+$/.test(d));
+    pids = fs62.readdirSync("/proc").filter((d) => /^\d+$/.test(d));
   } catch {
     return map;
   }
   for (const pid of pids) {
     let fds;
     try {
-      fds = fs61.readdirSync(`/proc/${pid}/fd`);
+      fds = fs62.readdirSync(`/proc/${pid}/fd`);
     } catch {
       continue;
     }
     for (const fd of fds) {
       let link;
       try {
-        link = fs61.readlinkSync(`/proc/${pid}/fd/${fd}`);
+        link = fs62.readlinkSync(`/proc/${pid}/fd/${fd}`);
       } catch {
         continue;
       }
@@ -40589,9 +40804,9 @@ var init_inbound = __esm({
 });
 
 // src/posture/coverage.ts
-import os50 from "os";
+import os51 from "os";
 function checkCoverage(ctx) {
-  const home = ctx.home || os50.homedir();
+  const home = ctx.home || os51.homedir();
   const findings = [];
   const protectedAgents = getAgentWiring(home).filter((r) => r.isProtected);
   if (protectedAgents.length === 0) {
@@ -40609,13 +40824,14 @@ function checkCoverage(ctx) {
     return findings;
   }
   const mode = getConfig(ctx.cwd).settings.mode;
-  if (mode === "observe" || mode === "audit") {
+  if (isRecordOnly(mode)) {
+    const level = levelOf(mode);
     findings.push({
       category: "Coverage",
       severity: "high",
-      title: `node9 is in ${mode} mode \u2014 watching, not blocking`,
+      title: `node9 is in ${level} mode \u2014 watching, not blocking`,
       what: "node9 is watching but not actually blocking anything.",
-      why: `It's in ${mode} mode, which logs risky actions but lets them through.`,
+      why: `It's in ${level} mode, which logs risky actions but lets them through.`,
       who: "The guardrails above are observed, not enforced.",
       detail: [],
       owner: "node9",
@@ -40628,12 +40844,13 @@ var init_coverage = __esm({
   "src/posture/coverage.ts"() {
     "use strict";
     init_config();
+    init_dist();
     init_agent_wiring();
   }
 });
 
 // src/posture/governance.ts
-import path63 from "path";
+import path64 from "path";
 function checkData(ctx) {
   const dlp = getConfig(ctx.cwd).policy.dlp;
   if (!dlp?.enabled) {
@@ -40777,7 +40994,7 @@ var init_governance = __esm({
   "src/posture/governance.ts"() {
     "use strict";
     init_config();
-    jailProbePath = (home) => path63.join(home, ".aws", "credentials");
+    jailProbePath = (home) => path64.join(home, ".aws", "credentials");
   }
 });
 
@@ -40931,7 +41148,7 @@ async function annotateCoverage(findings, ctx) {
         const worst = verdicts.some((v) => v === "review") ? "review" : "block";
         f.coverage = coverageFromVerdict(worst, env, "node9 DLP");
         if (isRecordOnly(mode) && f.fix?.includes("shield enable project-jail")) {
-          f.fix = `node9 already recognises reads of these files, but it is in ${mode ?? "audit"} mode, which logs them and lets them through. Fix it now: set mode to \`standard\` (or \`strict\`) to stop them.`;
+          f.fix = `node9 already recognises reads of these files, but it is in ${levelOf(mode)} mode, which logs them and lets them through. Fix it now: set mode to \`standard\` (or \`strict\`) to stop them.`;
         }
       }
       continue;
@@ -40956,7 +41173,7 @@ var init_enforcement = __esm({
 });
 
 // src/posture/index.ts
-import os51 from "os";
+import os52 from "os";
 function dropEnforcementRedundant(findings) {
   const coveragePresent = findings.some((f) => f.category === "Coverage");
   if (!coveragePresent) return findings;
@@ -40982,7 +41199,7 @@ async function runChecks(checks, ctx) {
 }
 async function runPosture(opts = {}) {
   const ctx = {
-    home: opts.home ?? os51.homedir(),
+    home: opts.home ?? os52.homedir(),
     cwd: opts.cwd ?? process.cwd(),
     agent: opts.agent
   };
@@ -41359,20 +41576,20 @@ var init_ship2 = __esm({
 
 // src/machine-id.ts
 import * as crypto7 from "crypto";
-import * as fs62 from "fs";
-import * as os52 from "os";
-import * as path64 from "path";
-function getMachineId(homeDir2 = os52.homedir()) {
-  const file2 = path64.join(homeDir2, ".node9", "machine-id");
+import * as fs63 from "fs";
+import * as os53 from "os";
+import * as path65 from "path";
+function getMachineId(homeDir2 = os53.homedir()) {
+  const file2 = path65.join(homeDir2, ".node9", "machine-id");
   try {
-    const existing = fs62.readFileSync(file2, "utf-8").trim();
+    const existing = fs63.readFileSync(file2, "utf-8").trim();
     if (UUID_RE.test(existing)) return existing;
   } catch {
   }
   const id = crypto7.randomUUID();
   try {
-    fs62.mkdirSync(path64.dirname(file2), { recursive: true });
-    fs62.writeFileSync(file2, id + "\n", { mode: 384 });
+    fs63.mkdirSync(path65.dirname(file2), { recursive: true });
+    fs63.writeFileSync(file2, id + "\n", { mode: 384 });
   } catch {
   }
   return id;
@@ -41412,10 +41629,10 @@ var init_sync_trigger = __esm({
 });
 
 // src/daemon/sync.ts
-import fs63 from "fs";
+import fs64 from "fs";
 import https4 from "https";
-import os53 from "os";
-import path65 from "path";
+import os54 from "os";
+import path66 from "path";
 function emptySignals3() {
   return {
     dlpFindings: 0,
@@ -41463,7 +41680,7 @@ function readCredentials() {
 }
 function readCachedEtag() {
   try {
-    const raw = JSON.parse(fs63.readFileSync(rulesCacheFile(), "utf-8"));
+    const raw = JSON.parse(fs64.readFileSync(rulesCacheFile(), "utf-8"));
     return typeof raw.etag === "string" ? raw.etag : void 0;
   } catch {
     return void 0;
@@ -41471,7 +41688,7 @@ function readCachedEtag() {
 }
 function readCachedSyncIntervalHours() {
   try {
-    const raw = JSON.parse(fs63.readFileSync(rulesCacheFile(), "utf-8"));
+    const raw = JSON.parse(fs64.readFileSync(rulesCacheFile(), "utf-8"));
     return typeof raw.syncIntervalHours === "number" ? raw.syncIntervalHours : void 0;
   } catch {
     return void 0;
@@ -41488,7 +41705,7 @@ function effectiveSyncIntervalMs() {
 }
 function readSyncHealth() {
   try {
-    const raw = JSON.parse(fs63.readFileSync(syncHealthFile(), "utf-8"));
+    const raw = JSON.parse(fs64.readFileSync(syncHealthFile(), "utf-8"));
     return {
       lastCheckedAt: typeof raw.lastCheckedAt === "string" ? raw.lastCheckedAt : void 0,
       lastChangedAt: typeof raw.lastChangedAt === "string" ? raw.lastChangedAt : void 0,
@@ -41503,17 +41720,17 @@ function readSyncHealth() {
 function writeSyncHealth(h) {
   try {
     const file2 = syncHealthFile();
-    const dir2 = path65.dirname(file2);
-    if (!fs63.existsSync(dir2)) fs63.mkdirSync(dir2, { recursive: true });
+    const dir2 = path66.dirname(file2);
+    if (!fs64.existsSync(dir2)) fs64.mkdirSync(dir2, { recursive: true });
     const tmp = `${file2}.${process.pid}.tmp`;
-    fs63.writeFileSync(tmp, JSON.stringify(h, null, 2) + "\n", "utf-8");
-    fs63.renameSync(tmp, file2);
+    fs64.writeFileSync(tmp, JSON.stringify(h, null, 2) + "\n", "utf-8");
+    fs64.renameSync(tmp, file2);
   } catch {
   }
 }
 function readCacheFetchedAt() {
   try {
-    const raw = JSON.parse(fs63.readFileSync(rulesCacheFile(), "utf-8"));
+    const raw = JSON.parse(fs64.readFileSync(rulesCacheFile(), "utf-8"));
     return typeof raw.fetchedAt === "string" ? raw.fetchedAt : void 0;
   } catch {
     return void 0;
@@ -41550,13 +41767,13 @@ function safeNode9Version() {
   let dir2 = __dirname;
   for (let up = 0; up < 5; up++) {
     try {
-      const pkg = JSON.parse(fs63.readFileSync(path65.join(dir2, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs64.readFileSync(path66.join(dir2, "package.json"), "utf-8"));
       if (pkg.name === "@node9/proxy" || pkg.name === "node9-ai") {
         return pkg.version;
       }
     } catch {
     }
-    const parent = path65.dirname(dir2);
+    const parent = path66.dirname(dir2);
     if (parent === dir2) break;
     dir2 = parent;
   }
@@ -41809,13 +42026,13 @@ function extractManagedConfig(body) {
 }
 function sweepStaleTmp(target) {
   try {
-    const dir2 = path65.dirname(target);
-    const prefix = `${path65.basename(target)}.`;
-    for (const name of fs63.readdirSync(dir2)) {
+    const dir2 = path66.dirname(target);
+    const prefix = `${path66.basename(target)}.`;
+    for (const name of fs64.readdirSync(dir2)) {
       if (!name.startsWith(prefix) || !name.endsWith(".tmp")) continue;
-      const full = path65.join(dir2, name);
+      const full = path66.join(dir2, name);
       try {
-        if (Date.now() - fs63.statSync(full).mtimeMs > 5 * 60 * 1e3) fs63.unlinkSync(full);
+        if (Date.now() - fs64.statSync(full).mtimeMs > 5 * 60 * 1e3) fs64.unlinkSync(full);
       } catch {
       }
     }
@@ -41918,7 +42135,7 @@ async function pushBlastSnapshot(creds) {
 }
 async function pushPostureSnapshot(creds) {
   try {
-    const home = os53.homedir();
+    const home = os54.homedir();
     const result = await runPosture({ home, cwd: home });
     await shipPosture(result, creds);
   } catch {
@@ -42092,7 +42309,7 @@ async function runCloudSync() {
 }
 function getCloudSyncStatus() {
   try {
-    const raw = JSON.parse(fs63.readFileSync(rulesCacheFile(), "utf-8"));
+    const raw = JSON.parse(fs64.readFileSync(rulesCacheFile(), "utf-8"));
     if (!Array.isArray(raw.rules) || typeof raw.fetchedAt !== "string") return { cached: false };
     return {
       cached: true,
@@ -42109,7 +42326,7 @@ function getCloudSyncStatus() {
 }
 function getCloudRules() {
   try {
-    const raw = JSON.parse(fs63.readFileSync(rulesCacheFile(), "utf-8"));
+    const raw = JSON.parse(fs64.readFileSync(rulesCacheFile(), "utf-8"));
     return Array.isArray(raw.rules) ? raw.rules : null;
   } catch {
     return null;
@@ -42179,12 +42396,12 @@ var init_sync = __esm({
       loop: "loops",
       "long-output-redacted": "longOutputRedactions"
     };
-    rulesCacheFile = () => path65.join(os53.homedir(), ".node9", "rules-cache.json");
-    rulesCacheBackupFile = () => path65.join(os53.homedir(), ".node9", "rules-cache.last-good.json");
+    rulesCacheFile = () => path66.join(os54.homedir(), ".node9", "rules-cache.json");
+    rulesCacheBackupFile = () => path66.join(os54.homedir(), ".node9", "rules-cache.last-good.json");
     DEFAULT_INTERVAL_HOURS = 5;
     MIN_INTERVAL_SECONDS = 15;
     MAX_INTERVAL_SECONDS = 24 * 60 * 60;
-    syncHealthFile = () => path65.join(os53.homedir(), ".node9", "sync-health.json");
+    syncHealthFile = () => path66.join(os54.homedir(), ".node9", "sync-health.json");
     STALE_MIN_MS = 3 * 60 * 60 * 1e3;
     STALE_MAX_MS = 24 * 60 * 60 * 1e3;
     STALE_FACTOR = 3;
@@ -42209,9 +42426,9 @@ __export(audit_shipper_exports, {
   startAuditShipper: () => startAuditShipper,
   writeWatermark: () => writeWatermark
 });
-import fs64 from "fs";
-import path66 from "path";
-import os54 from "os";
+import fs65 from "fs";
+import path67 from "path";
+import os55 from "os";
 import crypto8 from "crypto";
 function exposureOf(v) {
   if (!v || typeof v !== "object") return null;
@@ -42221,21 +42438,21 @@ function exposureOf(v) {
   return { kind: o.kind, destinations: Math.max(0, Math.min(1e3, Math.floor(n))) };
 }
 function fileSignature(filePath) {
-  const fd = fs64.openSync(filePath, "r");
+  const fd = fs65.openSync(filePath, "r");
   try {
     const buf = Buffer.alloc(512);
-    const read3 = fs64.readSync(fd, buf, 0, 512, 0);
+    const read3 = fs65.readSync(fd, buf, 0, 512, 0);
     const slice = buf.subarray(0, read3);
     const nl = slice.indexOf(10);
     const firstLine = nl === -1 ? slice : slice.subarray(0, nl);
     return crypto8.createHash("sha256").update(firstLine).digest("hex").slice(0, 16);
   } finally {
-    fs64.closeSync(fd);
+    fs65.closeSync(fd);
   }
 }
 function readWatermark(watermarkPath) {
   try {
-    const raw = JSON.parse(fs64.readFileSync(watermarkPath, "utf-8"));
+    const raw = JSON.parse(fs65.readFileSync(watermarkPath, "utf-8"));
     if (typeof raw.fileSig === "string" && typeof raw.offset === "number" && raw.offset >= 0)
       return raw;
   } catch {
@@ -42244,8 +42461,8 @@ function readWatermark(watermarkPath) {
 }
 function writeWatermark(watermarkPath, wm) {
   const tmp = `${watermarkPath}.tmp`;
-  fs64.writeFileSync(tmp, JSON.stringify(wm));
-  fs64.renameSync(tmp, watermarkPath);
+  fs65.writeFileSync(tmp, JSON.stringify(wm));
+  fs65.renameSync(tmp, watermarkPath);
 }
 function buildWireRows(chunk2) {
   const lastNl = chunk2.lastIndexOf(10);
@@ -42332,11 +42549,11 @@ async function shipOnce(deps = {}) {
   if (!creds?.apiKey) return { status: "no-creds", shipped: 0 };
   const endpoint = buildBatchEndpoint(creds.apiUrl);
   if (!endpoint) return { status: "no-creds", shipped: 0 };
-  if (!fs64.existsSync(auditLogPath)) return { status: "idle", shipped: 0 };
+  if (!fs65.existsSync(auditLogPath)) return { status: "idle", shipped: 0 };
   let shipped = 0;
   try {
     for (let chunkN = 0; chunkN < MAX_CHUNKS_PER_TICK; chunkN++) {
-      const size = fs64.statSync(auditLogPath).size;
+      const size = fs65.statSync(auditLogPath).size;
       if (size === 0) break;
       const sig = fileSignature(auditLogPath);
       const wm = readWatermark(watermarkPath);
@@ -42344,12 +42561,12 @@ async function shipOnce(deps = {}) {
       if (offset >= size) break;
       const toRead = Math.min(size - offset, MAX_CHUNK_BYTES);
       const buf = Buffer.alloc(toRead);
-      const fd = fs64.openSync(auditLogPath, "r");
+      const fd = fs65.openSync(auditLogPath, "r");
       let read3;
       try {
-        read3 = fs64.readSync(fd, buf, 0, toRead, offset);
+        read3 = fs65.readSync(fd, buf, 0, toRead, offset);
       } finally {
-        fs64.closeSync(fd);
+        fs65.closeSync(fd);
       }
       const { rows, consumed } = buildWireRows(buf.subarray(0, read3));
       if (consumed === 0) break;
@@ -42396,8 +42613,8 @@ async function shipOnce(deps = {}) {
 }
 function shipLagBytes(auditLogPath = LOCAL_AUDIT_LOG, watermarkPath = AUDIT_SHIP_WATERMARK) {
   try {
-    if (!fs64.existsSync(auditLogPath)) return 0;
-    const size = fs64.statSync(auditLogPath).size;
+    if (!fs65.existsSync(auditLogPath)) return 0;
+    const size = fs65.statSync(auditLogPath).size;
     const wm = readWatermark(watermarkPath);
     if (!wm) return size;
     if (wm.fileSig !== fileSignature(auditLogPath)) return size;
@@ -42422,20 +42639,20 @@ function startAuditShipper() {
 }
 function outboxBacklog(auditLogPath = LOCAL_AUDIT_LOG, watermarkPath = AUDIT_SHIP_WATERMARK, maxBytes = MAX_CHUNK_BYTES) {
   try {
-    const fd = fs64.openSync(auditLogPath, "r");
+    const fd = fs65.openSync(auditLogPath, "r");
     let chunk2;
     let truncated;
     try {
-      const size = fs64.fstatSync(fd).size;
+      const size = fs65.fstatSync(fd).size;
       const wm = readWatermark(watermarkPath);
       const offset = wm && wm.fileSig === fileSignature(auditLogPath) && wm.offset <= size ? wm.offset : 0;
       const length = Math.min(size - offset, maxBytes);
       const buffer = Buffer.alloc(length);
-      const read3 = fs64.readSync(fd, buffer, 0, length, offset);
+      const read3 = fs65.readSync(fd, buffer, 0, length, offset);
       chunk2 = buffer.subarray(0, read3);
       truncated = size - offset > length;
     } finally {
-      fs64.closeSync(fd);
+      fs65.closeSync(fd);
     }
     const { rows } = buildWireRows(chunk2);
     const oldest = rows.reduce((old, row) => {
@@ -42472,7 +42689,7 @@ var init_audit_shipper = __esm({
       "policy",
       "abandoned"
     ]);
-    AUDIT_SHIP_WATERMARK = path66.join(os54.homedir(), ".node9", "audit-ship.json");
+    AUDIT_SHIP_WATERMARK = path67.join(os55.homedir(), ".node9", "audit-ship.json");
     DEFAULT_INTERVAL_MS = 2e4;
     MAX_BATCH = 500;
     MAX_CHUNK_BYTES = 4 * 1024 * 1024;
@@ -42554,12 +42771,12 @@ var init_decision = __esm({
 });
 
 // src/daemon/dlp-scanner.ts
-import fs65 from "fs";
-import path67 from "path";
-import os55 from "os";
+import fs66 from "fs";
+import path68 from "path";
+import os56 from "os";
 function loadIndex() {
   try {
-    const raw = JSON.parse(fs65.readFileSync(INDEX_FILE, "utf-8"));
+    const raw = JSON.parse(fs66.readFileSync(INDEX_FILE, "utf-8"));
     if (raw && typeof raw === "object" && !Array.isArray(raw)) {
       const r = raw;
       if (r.offsets && typeof r.offsets === "object") return r.offsets;
@@ -42571,13 +42788,13 @@ function loadIndex() {
 }
 function saveIndex(index) {
   try {
-    fs65.writeFileSync(INDEX_FILE, JSON.stringify(index), { encoding: "utf-8", mode: 384 });
+    fs66.writeFileSync(INDEX_FILE, JSON.stringify(index), { encoding: "utf-8", mode: 384 });
   } catch {
   }
 }
 function appendAuditEntry(entry) {
   try {
-    fs65.appendFileSync(AUDIT_LOG_FILE, JSON.stringify(entry) + "\n");
+    fs66.appendFileSync(AUDIT_LOG_FILE, JSON.stringify(entry) + "\n");
   } catch {
   }
 }
@@ -42591,52 +42808,52 @@ function runDlpScan() {
     canaryVals = [];
   }
   const canaryFindings = [];
-  if (!fs65.existsSync(PROJECTS_DIR2)) return;
+  if (!fs66.existsSync(PROJECTS_DIR2)) return;
   const index = loadIndex();
   const seenThisPass = /* @__PURE__ */ new Set();
   const newFindings = [];
   let updated = false;
   let projDirs;
   try {
-    projDirs = fs65.readdirSync(PROJECTS_DIR2);
+    projDirs = fs66.readdirSync(PROJECTS_DIR2);
   } catch {
     return;
   }
   for (const proj of projDirs) {
-    const projPath = path67.join(PROJECTS_DIR2, proj);
+    const projPath = path68.join(PROJECTS_DIR2, proj);
     try {
-      if (!fs65.lstatSync(projPath).isDirectory()) continue;
-      const real = fs65.realpathSync(projPath);
-      if (!real.startsWith(PROJECTS_DIR2 + path67.sep) && real !== PROJECTS_DIR2) continue;
+      if (!fs66.lstatSync(projPath).isDirectory()) continue;
+      const real = fs66.realpathSync(projPath);
+      if (!real.startsWith(PROJECTS_DIR2 + path68.sep) && real !== PROJECTS_DIR2) continue;
     } catch {
       continue;
     }
     let files;
     try {
-      files = fs65.readdirSync(projPath).filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
+      files = fs66.readdirSync(projPath).filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
     } catch {
       continue;
     }
     for (const file2 of files) {
-      const filePath = path67.join(projPath, file2);
+      const filePath = path68.join(projPath, file2);
       const lastOffset = index[filePath] ?? 0;
       let size;
       try {
-        size = fs65.statSync(filePath).size;
+        size = fs66.statSync(filePath).size;
       } catch {
         continue;
       }
       if (size <= lastOffset) continue;
       let fd;
       try {
-        fd = fs65.openSync(filePath, "r");
+        fd = fs66.openSync(filePath, "r");
       } catch {
         continue;
       }
       try {
         const chunkSize = size - lastOffset;
         const buf = Buffer.alloc(chunkSize);
-        fs65.readSync(fd, buf, 0, chunkSize, lastOffset);
+        fs66.readSync(fd, buf, 0, chunkSize, lastOffset);
         const chunk2 = buf.toString("utf-8");
         for (const line of chunk2.split("\n")) {
           if (!line.trim()) continue;
@@ -42657,7 +42874,7 @@ function runDlpScan() {
             const match = scanText(text);
             const canary = canaryVals.length > 0 ? matchCanary(text, canaryVals) : null;
             if (!match && !canary) continue;
-            const projLabel = decodeURIComponent(proj).replace(os55.homedir(), "~").slice(0, 40);
+            const projLabel = decodeURIComponent(proj).replace(os56.homedir(), "~").slice(0, 40);
             const ts = entry.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
             if (canary) {
               const rec = canaryById.get(canary.id);
@@ -42707,7 +42924,7 @@ function runDlpScan() {
         updated = true;
       } finally {
         try {
-          fs65.closeSync(fd);
+          fs66.closeSync(fd);
         } catch {
         }
       }
@@ -42766,15 +42983,15 @@ var init_dlp_scanner = __esm({
     init_registry2();
     init_native();
     init_state3();
-    INDEX_FILE = path67.join(os55.homedir(), ".node9", "dlp-index.json");
-    PROJECTS_DIR2 = path67.join(os55.homedir(), ".claude", "projects");
+    INDEX_FILE = path68.join(os56.homedir(), ".node9", "dlp-index.json");
+    PROJECTS_DIR2 = path68.join(os56.homedir(), ".claude", "projects");
   }
 });
 
 // src/daemon/mcp-reconciler.ts
-import fs66 from "fs";
-import path68 from "path";
-import os56 from "os";
+import fs67 from "fs";
+import path69 from "path";
+import os57 from "os";
 import crypto9 from "crypto";
 function idKey(e) {
   const cmdHash = crypto9.createHash("sha256").update(`${e.command} ${e.args.join(" ")}`).digest("hex").slice(0, 16);
@@ -42782,7 +42999,7 @@ function idKey(e) {
 }
 function loadBaseline() {
   try {
-    const raw = JSON.parse(fs66.readFileSync(BASELINE_FILE2, "utf-8"));
+    const raw = JSON.parse(fs67.readFileSync(BASELINE_FILE2, "utf-8"));
     return new Set(Array.isArray(raw) ? raw : []);
   } catch {
     return /* @__PURE__ */ new Set();
@@ -42790,7 +43007,7 @@ function loadBaseline() {
 }
 function saveBaseline(keys) {
   try {
-    fs66.writeFileSync(BASELINE_FILE2, JSON.stringify([...keys].slice(-BASELINE_CAP)), {
+    fs67.writeFileSync(BASELINE_FILE2, JSON.stringify([...keys].slice(-BASELINE_CAP)), {
       mode: 384
     });
   } catch {
@@ -42978,7 +43195,7 @@ var init_mcp_reconciler = __esm({
     init_cloud();
     init_audit();
     init_mcp_pin();
-    BASELINE_FILE2 = path68.join(os56.homedir(), ".node9", "mcp-baseline.json");
+    BASELINE_FILE2 = path69.join(os57.homedir(), ".node9", "mcp-baseline.json");
     BASELINE_CAP = 500;
     DEFAULT_INTERVAL_MIN = 60;
     DEFAULT_STALE_DAYS = 7;
@@ -43052,114 +43269,6 @@ var init_hook_heal = __esm({
   }
 });
 
-// src/daemon/startup-log.ts
-import fs67 from "fs";
-import path69 from "path";
-import os57 from "os";
-function capStartupLog(file2) {
-  try {
-    if (fs67.statSync(file2).size > MAX_STARTUP_LOG_BYTES) fs67.truncateSync(file2);
-  } catch {
-  }
-}
-function openStartupLogFd() {
-  try {
-    const file2 = DAEMON_STARTUP_LOG();
-    const dir2 = path69.dirname(file2);
-    if (!fs67.existsSync(dir2)) fs67.mkdirSync(dir2, { recursive: true });
-    capStartupLog(file2);
-    return fs67.openSync(file2, "a");
-  } catch {
-    return void 0;
-  }
-}
-function recordStartupState(outcome, kind, detail) {
-  try {
-    if (outcome === "starting") {
-      const prev = readStartupState();
-      if (prev?.outcome === "starting") {
-        const prevAt = new Date(prev.at).getTime();
-        const age = Math.abs(Date.now() - prevAt);
-        if (!isNaN(prevAt) && age < 24 * 60 * 60 * 1e3) return;
-      }
-    }
-    const file2 = DAEMON_STARTUP_STATE();
-    const dir2 = path69.dirname(file2);
-    if (!fs67.existsSync(dir2)) fs67.mkdirSync(dir2, { recursive: true });
-    const state = { outcome, at: (/* @__PURE__ */ new Date()).toISOString() };
-    if (kind) state.kind = kind;
-    if (detail) state.detail = detail.slice(0, MAX_DETAIL);
-    const tmp = `${file2}.${process.pid}.tmp`;
-    try {
-      fs67.writeFileSync(tmp, JSON.stringify(state), "utf-8");
-      fs67.renameSync(tmp, file2);
-    } catch (err2) {
-      try {
-        fs67.unlinkSync(tmp);
-      } catch {
-      }
-      throw err2;
-    }
-  } catch {
-  }
-}
-function readStartupState() {
-  try {
-    const raw = fs67.readFileSync(DAEMON_STARTUP_STATE(), "utf-8");
-    const s = JSON.parse(raw);
-    if (!s || typeof s.outcome !== "string" || typeof s.at !== "string") return null;
-    return s;
-  } catch {
-    return null;
-  }
-}
-function readStartupCause(maxAgeMs = 24 * 60 * 60 * 1e3) {
-  const s = readStartupState();
-  if (!s) return null;
-  const at = new Date(s.at);
-  if (isNaN(at.getTime()) || Date.now() - at.getTime() > maxAgeMs) return null;
-  switch (s.outcome) {
-    case "ok":
-    case "ok-elsewhere":
-      return null;
-    case "starting":
-      if (Date.now() - at.getTime() < STARTING_GRACE_MS) return null;
-      return {
-        kind: "did-not-start",
-        detail: "the daemon did not come up \u2014 see ~/.node9/daemon-startup.log and hook-debug.log",
-        at,
-        // `at` is the FIRST attempt of the streak, not the most recent one.
-        label: "start attempts failing since"
-      };
-    case "failed":
-      return { kind: s.kind || "failed", detail: s.detail || "", at, label: "last start attempt" };
-    default:
-      return null;
-  }
-}
-function logDaemonStartup(kind, detail) {
-  try {
-    const file2 = DAEMON_STARTUP_LOG();
-    const dir2 = path69.dirname(file2);
-    if (!fs67.existsSync(dir2)) fs67.mkdirSync(dir2, { recursive: true });
-    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon-startup:${kind}${detail ? ` ${detail}` : ""}
-`;
-    fs67.appendFileSync(file2, line, "utf-8");
-  } catch {
-  }
-}
-var DAEMON_STARTUP_LOG, MAX_STARTUP_LOG_BYTES, DAEMON_STARTUP_STATE, MAX_DETAIL, STARTING_GRACE_MS;
-var init_startup_log = __esm({
-  "src/daemon/startup-log.ts"() {
-    "use strict";
-    DAEMON_STARTUP_LOG = () => path69.join(os57.homedir(), ".node9", "daemon-startup.log");
-    MAX_STARTUP_LOG_BYTES = 256 * 1024;
-    DAEMON_STARTUP_STATE = () => path69.join(os57.homedir(), ".node9", "daemon-startup-state.json");
-    MAX_DETAIL = 200;
-    STARTING_GRACE_MS = 90 * 1e3;
-  }
-});
-
 // src/supply-chain/zip.ts
 import fs68 from "fs";
 import zlib from "zlib";
@@ -77491,7 +77600,7 @@ function buildReportJson(input) {
 var BLOCK_REASON_LABELS = {
   timeout: "Approval timeout",
   "smart-rule-block": "Smart rule",
-  "observe-mode-dlp-would-block": "DLP (observe)",
+  "observe-mode-dlp-would-block": "DLP (audit)",
   "persistent-deny": "Persistent deny",
   "local-decision": "User denied",
   "dlp-block": "DLP block",
@@ -77531,10 +77640,10 @@ function fmtCost2(usd) {
   return "$" + usd.toFixed(2);
 }
 function registerReportCommand(program2) {
-  program2.command("report").description("Activity and security report \u2014 what Claude did, what was blocked").option("--period <period>", "today | 7d | 30d | month", "7d").option("--no-tests", "exclude test runner calls (npm test, vitest, pytest\u2026) from stats").option("--json", "Emit machine-readable JSON to stdout (suppresses renderer)").action((options) => {
+  program2.command("report").description("Activity and security report \u2014 what Claude did, what was blocked").option("--period <period>", "today | 7d | 30d | 90d | month", "30d").option("--no-tests", "exclude test runner calls (npm test, vitest, pytest\u2026) from stats").option("--json", "Emit machine-readable JSON to stdout (suppresses renderer)").action((options) => {
     const period = ["today", "7d", "30d", "90d", "month"].includes(
       options.period
-    ) ? options.period : "7d";
+    ) ? options.period : "30d";
     const excludeTests = options.tests === false;
     const { data, hasAuditFile, responseDlpEntries } = aggregateReportFromAudit(period, {
       excludeTests
@@ -77732,7 +77841,7 @@ function renderTerminalReport(data, responseDlpEntries, excludeTests) {
   );
   summaryRow(
     observeDlp > 0 ? chalk20.blue("\u{1F441}") : chalk20.dim("\u{1F441}"),
-    "DLP (observe)",
+    "DLP (audit)",
     observeDlp,
     observeDlp > 0 ? "would-block in strict mode" : void 0,
     observeDlp > 0 ? (s) => chalk20.blue(s) : (s) => chalk20.dim(s)
@@ -79240,6 +79349,235 @@ import fs92 from "fs";
 import os78 from "os";
 import path91 from "path";
 import { spawnSync as spawnSync5 } from "child_process";
+
+// src/cli/commands/egress.ts
+init_config();
+init_keyed_guard();
+init_dist();
+init_egress_config();
+init_egress_config();
+import chalk27 from "chalk";
+function guard(fn) {
+  try {
+    fn();
+    return true;
+  } catch (err2) {
+    console.error(chalk27.red(`
+  \u2717 ${err2.message}
+`));
+    process.exitCode = 1;
+    return false;
+  }
+}
+function mutate(action, change) {
+  if (!cliGuardPolicyWrite(action)) return false;
+  return guard(() => setEgress(change));
+}
+function addHost(list2, host2) {
+  if (!cliGuardPolicyWrite(`egress ${list2} ${host2}`)) return false;
+  return guard(() => addEgressHost(list2, host2));
+}
+function exempt2(address) {
+  if (!cliGuardPolicyWrite(`egress exempt ${address}`)) return false;
+  return guard(() => addSsrfExemption(address));
+}
+var INTERNAL_FIELDS = {
+  allowed: { ssrfStrict: false, allowPrivate: true },
+  listed: { ssrfStrict: false, allowPrivate: false },
+  blocked: { ssrfStrict: true, allowPrivate: false }
+};
+var INTERNAL_SAID = {
+  allowed: "reachable without listing them",
+  listed: "reachable only if they are on your allowlist",
+  blocked: "blocked"
+};
+function describeInternalState(state) {
+  return INTERNAL_SAID[state];
+}
+function readInternalState(e) {
+  if (e.ssrfStrict === true) return "blocked";
+  return e.allowPrivate === false ? "listed" : "allowed";
+}
+function setInternal(value) {
+  const state = value.trim().toLowerCase();
+  if (!(state in INTERNAL_FIELDS)) {
+    console.error(
+      chalk27.red(`
+  \u2717 Expected "allowed", "listed" or "blocked", got "${value}".`) + chalk27.gray(
+        "\n    allowed  loopback, 10/172.16/192.168 and CGNAT are reachable (default)\n    listed   they are reachable only if you allowlist them\n    blocked  they are blocked at the floor\n"
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (!mutate(`egress internal ${state}`, INTERNAL_FIELDS[state])) return;
+  _resetConfigCache();
+  const effective = readInternalState(getConfig().policy.egress);
+  if (effective !== state) {
+    console.log(
+      chalk27.yellow(
+        `
+  \u26A0 Saved, but not in effect: your workspace sets internal addresses to ${effective.toUpperCase()} and that governs this machine.
+    Change it in the dashboard, Enforcement \u2192 Network.
+`
+      )
+    );
+    return;
+  }
+  const line = `
+  \u2713 Internal addresses: ${state} \u2014 loopback, the private ranges and CGNAT are ${INTERNAL_SAID[state]}.
+`;
+  console.log(state === "allowed" ? chalk27.yellow(line) : chalk27.green(line));
+}
+function showFloor(e, ssrfStrictSource) {
+  console.log(
+    chalk27.gray("\n  Protected addresses") + chalk27.gray(" \u2014 in shell commands and declared URLs")
+  );
+  console.log(
+    chalk27.gray(
+      "    always blocked: cloud metadata, link-local, multicast\n    no setting releases these, though `node9 pause` suspends all enforcement"
+    )
+  );
+  const state = readInternalState(e);
+  const by = ssrfStrictSource === "workspace" ? "workspace (app.node9.ai)" : ssrfStrictSource === "local" ? "this machine (config.json)" : "the shipped default";
+  const STATE_LABEL = {
+    allowed: "allowed",
+    listed: "allowlist only",
+    blocked: "blocked"
+  };
+  console.log(
+    `    Internal addresses:  ${state === "blocked" ? chalk27.green(STATE_LABEL[state]) : chalk27.yellow(STATE_LABEL[state])}` + chalk27.gray(`  loopback, 10/172.16/192.168 and CGNAT are ${INTERNAL_SAID[state]}`)
+  );
+  console.log(chalk27.gray(`    set by: ${by}`));
+  const exemptions = e.ssrfAllow ?? [];
+  console.log(chalk27.gray(`    Exemptions: ${exemptions.length ? exemptions.join(", ") : "none"}`));
+  console.log(
+    chalk27.gray(
+      "    Covered: shell commands, and tools that declare a URL (WebFetch, an MCP\n    fetch tool, browser navigate).\n    Not covered: an interpreter one-liner (node -e, python3 -c) hides its\n    destination inside a program and does not reach this gate.\n    CGNAT (100.64/10) is NOT in the always-blocked set: it is reachable\n    until Internal addresses is on, and an exemption can release it."
+    )
+  );
+}
+function showStatus() {
+  const cfg = getConfig();
+  const e = cfg.policy.egress;
+  const state = !e.enabled ? chalk27.red("OFF \u2014 your agent can reach any host, except the protected ones below") : e.mode === "block" ? chalk27.green("LOCKED (block) \u2014 unknown hosts are denied") : chalk27.yellow("WATCHING (review) \u2014 unknown hosts prompt you");
+  console.log(chalk27.cyan.bold("\n\u{1F310} Egress control"));
+  console.log("  State: " + state);
+  if (cfg.policySource === "workspace") {
+    console.log(
+      chalk27.gray("  Source: workspace config (app.node9.ai) \u2014 local egress settings are ignored")
+    );
+  }
+  console.log(
+    chalk27.gray(
+      `  ${DEFAULT_EGRESS_ALLOWLIST.length} common dev/LLM hosts are always allowed (github, npm, pypi, anthropic, \u2026).`
+    )
+  );
+  showFloor(e, cfg.ssrfStrictSource);
+  if (e.allow.length) console.log("\n  Your allow: " + e.allow.join(", "));
+  if (e.deny.length) console.log("  Your deny:  " + e.deny.join(", "));
+  if (!e.enabled) {
+    console.log(chalk27.gray("\n  Turn it on:  node9 egress watch   (prompt on unknown hosts)"));
+    console.log(chalk27.gray("               node9 egress lock    (hard-block unknown hosts)"));
+  }
+  console.log("");
+}
+function registerEgressCommand(program2) {
+  const egress = program2.command("egress").description("Control where your agent can send data (egress allowlist)");
+  egress.command("watch").description("Prompt before the agent reaches an unknown host (review mode)").action(() => {
+    if (!mutate("egress watch", { enabled: true, mode: "review" })) return;
+    console.log(chalk27.green("\n\u2713 Egress is now watched (review mode)."));
+    console.log(
+      chalk27.gray("  Routine hosts (LLM APIs, package registries, localhost) are allowed.")
+    );
+    console.log(
+      chalk27.gray("  An unknown host will prompt you \u2014 run `node9 egress lock` to hard-block.\n")
+    );
+  });
+  egress.command("lock").description("Block the agent from reaching unknown hosts (block mode)").action(() => {
+    if (!mutate("egress lock", { enabled: true, mode: "block" })) return;
+    console.log(chalk27.green("\n\u2713 Egress is now locked (block mode)."));
+    console.log(chalk27.gray("  Routine hosts are still allowed; unknown hosts are denied."));
+    console.log(chalk27.gray("  Allow a specific host with `node9 egress allow <host>`.\n"));
+  });
+  egress.command("allow <host>").description("Allow an extra host (glob, e.g. *.mycorp.com)").action((host2) => {
+    if (!addHost("allow", host2)) return;
+    console.log(chalk27.green(`
+\u2713 Allowed egress to ${host2}.
+`));
+  });
+  egress.command("deny <host>").description("Block an extra host (deny always wins)").action((host2) => {
+    if (!addHost("deny", host2)) return;
+    console.log(chalk27.green(`
+\u2713 Denied egress to ${host2}.
+`));
+  });
+  egress.command("off").description("Turn egress control off").action(() => {
+    if (!mutate("egress off", { enabled: false })) return;
+    console.log(
+      chalk27.yellow("\n\u2713 Egress control is off \u2014 the agent can reach any host again.\n")
+    );
+  });
+  egress.command("internal <allowed|listed|blocked>").description(
+    "How loopback, private ranges and CGNAT are treated: allowed (default), listed (must be on the allowlist), or blocked"
+  ).action((value) => setInternal(value));
+  egress.command("strict <on|off>").description("Deprecated alias for `egress internal blocked|allowed`").action((value) => {
+    const v = value.trim().toLowerCase();
+    if (v !== "on" && v !== "off") {
+      console.error(chalk27.red(`
+  \u2717 Expected "on" or "off", got "${value}".
+`));
+      process.exitCode = 1;
+      return;
+    }
+    const state = v === "on" ? "blocked" : getConfig().policy.egress.allowPrivate === false ? "listed" : "allowed";
+    console.log(chalk27.gray(`
+  (\`egress strict ${v}\` is now \`egress internal ${state}\`)`));
+    setInternal(state);
+  });
+  egress.command("exempt <address>").description("Let an address or a CIDR range through the floor (e.g. 100.64.0.0/10)").action((address) => {
+    const a = normalizeEgressHost(address);
+    const slash = a.indexOf("/");
+    const base2 = slash === -1 ? a : a.slice(0, slash);
+    const prefixText = slash === -1 ? null : a.slice(slash + 1);
+    if (!normalizeIpLiteral(base2) || prefixText !== null && !/^\d{1,3}$/.test(prefixText)) {
+      console.error(
+        chalk27.red(`
+  \u2717 "${address}" is not an address or a range.`) + chalk27.gray(
+          "\n    Exemptions are matched as an address (10.0.0.5) or a CIDR\n    range (100.64.0.0/10), never a name.\n"
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const m = classifySsrf(base2);
+    if (m && !m.overridable) {
+      console.error(
+        chalk27.red(`
+  \u2717 ${a} cannot be exempted.`) + chalk27.gray(
+          `
+    ${slash === -1 ? "That address is" : "That range covers only"} protected addresses (${m.tier}), which no setting releases.
+`
+        )
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (!exempt2(a)) return;
+    console.log(chalk27.green(`
+  \u2713 ${a} is exempt from the floor.`));
+    if (!m)
+      console.log(
+        chalk27.gray("    Note: this address is not on the floor anyway \u2014 nothing changes.\n")
+      );
+    else console.log("");
+  });
+  egress.command("status").description("Show the current egress state").action(showStatus);
+  egress.action(showStatus);
+}
+
+// src/mcp-server/index.ts
+init_agent_wiring();
 function ok(id, result) {
   return JSON.stringify({ jsonrpc: "2.0", id: id ?? null, result });
 }
@@ -79373,7 +79711,7 @@ var TOOLS = [
   },
   {
     name: "node9_scan",
-    description: "Scan all AI agent history (Claude + Gemini) and report what node9 would have blocked or flagged. Shows blocked operations, reviewed commands, credential leaks, and agent spend. Use this to audit past activity and find security gaps before they become incidents.",
+    description: "Scan the history of all supported coding agents (Claude Code, Gemini, Codex, Copilot, Antigravity) and report what node9 would have blocked or flagged. Shows blocked operations, reviewed commands, credential leaks, and agent spend. Use this to audit past activity and find security gaps before they become incidents.",
     inputSchema: {
       type: "object",
       properties: {
@@ -79393,8 +79731,8 @@ var TOOLS = [
       properties: {
         period: {
           type: "string",
-          enum: ["today", "7d", "30d", "month"],
-          description: "Time period for the report (default: 7d)."
+          enum: ["today", "7d", "30d", "90d", "month"],
+          description: "Time period for the report (default: 30d)."
         },
         no_tests: {
           type: "boolean",
@@ -79528,7 +79866,7 @@ function handleStatus() {
   const wsGoverned = config.policySource === "workspace";
   const activeShields = wsGoverned ? config.policy.appliedShields ?? [] : readActiveShields();
   const lines = [];
-  lines.push(`Mode: ${settings.mode}`);
+  lines.push(`Mode: ${levelOf(settings.mode)}`);
   if (wsGoverned) {
     lines.push(
       "Policy source: workspace config (app.node9.ai) \u2014 local config files are ignored for policy"
@@ -79544,6 +79882,12 @@ 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"}`);
+  lines.push("Agent hooks:");
+  for (const a of getAgentWiring()) {
+    const hooked = a.hooks.some((h) => h.wired);
+    const state = !a.installed ? "not installed" : hooked ? "wired" : a.isProtected ? "protected through MCP" : "not wired";
+    lines.push(`  ${a.label}: ${state}`);
+  }
   const projectConfig = path91.join(process.cwd(), "node9.config.json");
   const globalConfig = path91.join(os78.homedir(), ".node9", "config.json");
   const presentLabel = wsGoverned ? "present \u2014 ignored (workspace config governs)" : "present";
@@ -79636,6 +79980,11 @@ function handleShieldDisable(args) {
   if (disabledApp) recordUserDecision(disabledApp.slug, "off");
   return `Shield "${name}" disabled.`;
 }
+function internalAddressLine(e) {
+  const configured = readInternalState(e);
+  const state = !e.enabled && configured === "listed" ? "allowed" : configured;
+  return `Internal addresses: ${state} \u2014 loopback and the private ranges are ${describeInternalState(state)}.`;
+}
 function handleEgressStatus() {
   const cfgEgress = getConfig();
   const e = cfgEgress.policy.egress;
@@ -79657,7 +80006,7 @@ function handleEgressStatus() {
     // actually covers is measured in egress.integration.test.ts.
     "Protected addresses: cloud metadata, link-local and multicast are blocked before any of the above is consulted, in shell commands AND in tools that declare a URL (WebFetch, an MCP fetch tool, browser navigate). No setting releases them, though `node9 pause` suspends all enforcement.",
     "NOT covered by that: an interpreter one-liner (node -e, python3 -c) carries its destination inside a program and does not reach this gate. CGNAT (100.64/10) is NOT in the always-blocked set \u2014 it is reachable until the strict tier is on, and an exemption can release it.",
-    `Internal addresses: ${e.ssrfStrict ? "on" : "off"} \u2014 loopback and the private ranges are ${e.ssrfStrict ? "blocked too" : "reachable"}.`,
+    internalAddressLine(e),
     `Floor exemptions: ${e.ssrfAllow?.length ? e.ssrfAllow.join(", ") : "(none)"}`
   ];
   return lines.join("\n");
@@ -79980,7 +80329,7 @@ function registerMcpServerCommand(program2) {
 init_trusted_hosts();
 init_keyed_guard();
 init_trusted_recipients();
-import chalk27 from "chalk";
+import chalk28 from "chalk";
 function isValidHost(host2) {
   return /^(\*\.)?[a-z0-9][a-z0-9.-]*\.[a-z]{2,}$/.test(host2);
 }
@@ -79991,17 +80340,17 @@ function registerTrustCommand(program2) {
     const normalized = normalizeHost2(host2.trim());
     if (!isValidHost(normalized)) {
       console.error(
-        chalk27.red(`
+        chalk28.red(`
 \u274C Invalid host: "${host2}"
-`) + chalk27.gray("   Use an FQDN like api.mycompany.com or *.mycompany.com\n")
+`) + chalk28.gray("   Use an FQDN like api.mycompany.com or *.mycompany.com\n")
       );
       process.exit(1);
     }
     addTrustedHost(normalized);
-    console.log(chalk27.green(`
+    console.log(chalk28.green(`
 \u2705 ${normalized} added to trusted hosts.`));
     console.log(
-      chalk27.gray("   Pipe-chain blocks to this host: critical \u2192 review, high \u2192 allow\n")
+      chalk28.gray("   Pipe-chain blocks to this host: critical \u2192 review, high \u2192 allow\n")
     );
   });
   trustCmd.command("remove <host>").description("Remove a trusted host").action((host2) => {
@@ -80009,27 +80358,27 @@ function registerTrustCommand(program2) {
     const normalized = normalizeHost2(host2.trim());
     const removed = removeTrustedHost(normalized);
     if (!removed) {
-      console.error(chalk27.yellow(`
+      console.error(chalk28.yellow(`
 \u26A0\uFE0F  "${normalized}" is not in the trusted hosts list.
 `));
       process.exit(1);
     }
-    console.log(chalk27.green(`
+    console.log(chalk28.green(`
 \u2705 ${normalized} removed from trusted hosts.
 `));
   });
   trustCmd.command("list").description("Show all trusted hosts").action(() => {
     const hosts = readTrustedHosts();
     if (hosts.length === 0) {
-      console.log(chalk27.gray("\n  No trusted hosts configured.\n"));
-      console.log(`  Add one: ${chalk27.cyan("node9 trust add api.mycompany.com")}
+      console.log(chalk28.gray("\n  No trusted hosts configured.\n"));
+      console.log(`  Add one: ${chalk28.cyan("node9 trust add api.mycompany.com")}
 `);
       return;
     }
-    console.log(chalk27.bold("\n\u{1F513} Trusted Hosts\n"));
+    console.log(chalk28.bold("\n\u{1F513} Trusted Hosts\n"));
     for (const entry of hosts) {
       const date = new Date(entry.addedAt).toLocaleDateString();
-      console.log(`  ${chalk27.cyan(entry.host.padEnd(40))} ${chalk27.gray(`added ${date}`)}`);
+      console.log(`  ${chalk28.cyan(entry.host.padEnd(40))} ${chalk28.gray(`added ${date}`)}`);
     }
     console.log("");
   });
@@ -80041,41 +80390,41 @@ function registerTrustCommand(program2) {
     const stored = addTrustedRecipient(value, "user");
     if (!stored) {
       console.error(
-        chalk27.red(`
+        chalk28.red(`
 \u274C Not a destination: "${value}"
-`) + chalk27.gray("   Use an email address, a hostname or URL, or an IBAN.\n")
+`) + chalk28.gray("   Use an email address, a hostname or URL, or an IBAN.\n")
       );
       process.exit(1);
     }
-    console.log(chalk27.green(`
+    console.log(chalk28.green(`
 \u2705 ${stored} added to trusted recipients.
 `));
   });
   rec.command("remove <value>").description("Remove a trusted recipient").action((value) => {
     if (!cliGuardPolicyWrite(`trust recipient remove ${value}`)) return;
     if (!removeTrustedRecipient(value)) {
-      console.error(chalk27.yellow(`
+      console.error(chalk28.yellow(`
 \u26A0\uFE0F  "${value}" is not in the trusted recipients list.
 `));
       process.exit(1);
     }
-    console.log(chalk27.green(`
+    console.log(chalk28.green(`
 \u2705 ${value} removed from trusted recipients.
 `));
   });
   rec.command("list").description("Show all trusted recipients").action(() => {
     const entries = readTrustedRecipients();
     if (entries.length === 0) {
-      console.log(chalk27.gray("\n  No trusted recipients.\n"));
-      console.log(`  Add one: ${chalk27.cyan("node9 trust recipient add partner@example.com")}
+      console.log(chalk28.gray("\n  No trusted recipients.\n"));
+      console.log(`  Add one: ${chalk28.cyan("node9 trust recipient add partner@example.com")}
 `);
       return;
     }
-    console.log(chalk27.bold("\n\u{1F513} Trusted Recipients\n"));
+    console.log(chalk28.bold("\n\u{1F513} Trusted Recipients\n"));
     for (const e of entries) {
       const date = new Date(e.addedAt).toLocaleDateString();
       console.log(
-        `  ${chalk27.cyan(e.value.padEnd(44))} ${chalk27.gray(`added ${date} (${e.addedBy})`)}`
+        `  ${chalk28.cyan(e.value.padEnd(44))} ${chalk28.gray(`added ${date} (${e.addedBy})`)}`
       );
     }
     console.log("");
@@ -80084,13 +80433,13 @@ function registerTrustCommand(program2) {
 
 // src/cli/commands/mcp-pin.ts
 init_mcp_pin();
-import chalk29 from "chalk";
+import chalk30 from "chalk";
 import fs93 from "fs";
 
 // src/cli/commands/mcp-gateway-cmd.ts
 init_mcp_wrap();
 init_mcp_status();
-import chalk28 from "chalk";
+import chalk29 from "chalk";
 var STATE_WORD = {
   gatewayed: "governed",
   "node9-self": "node9",
@@ -80099,10 +80448,10 @@ var STATE_WORD = {
 };
 function stateChip(state) {
   const w = STATE_WORD[state].padEnd(12);
-  if (state === "gatewayed") return chalk28.green(w);
-  if (state === "node9-self") return chalk28.gray(w);
-  if (state === "remote") return chalk28.gray(w);
-  return chalk28.yellow(w);
+  if (state === "gatewayed") return chalk29.green(w);
+  if (state === "node9-self") return chalk29.gray(w);
+  if (state === "remote") return chalk29.gray(w);
+  return chalk29.yellow(w);
 }
 function relativeAge(ms, now) {
   const s = Math.max(0, Math.round((now - ms) / 1e3));
@@ -80116,15 +80465,15 @@ function relativeAge(ms, now) {
 function connectionChip(e, now) {
   switch (e.connection) {
     case "connected":
-      return chalk28.green(
+      return chalk29.green(
         `\u2713 connected${e.lastSeenAt ? ` (${relativeAge(e.lastSeenAt, now)})` : ""}`
       );
     case "stale":
-      return chalk28.yellow(`\u26A0 stale${e.lastSeenAt ? ` (${relativeAge(e.lastSeenAt, now)})` : ""}`);
+      return chalk29.yellow(`\u26A0 stale${e.lastSeenAt ? ` (${relativeAge(e.lastSeenAt, now)})` : ""}`);
     case "pending-launch":
-      return chalk28.cyan(`\u2026 pending \u2014 restart ${e.agentLabel} to connect`);
+      return chalk29.cyan(`\u2026 pending \u2014 restart ${e.agentLabel} to connect`);
     case "unlaunchable":
-      return chalk28.red(
+      return chalk29.red(
         `\u2717 can't launch \u2014 ${(e.missingEnv ?? []).map((v) => `$${v}`).join(", ")} not set`
       );
     default:
@@ -80149,7 +80498,7 @@ function registerMcpGatewayCommand2(mcp) {
     const now = Date.now();
     const rows = resolveMcpStatus(void 0, process.env, now);
     if (rows.length === 0) {
-      console.error(chalk28.gray("No MCP servers found in any agent config."));
+      console.error(chalk29.gray("No MCP servers found in any agent config."));
       return;
     }
     for (const e of rows) {
@@ -80163,20 +80512,20 @@ function registerMcpGatewayCommand2(mcp) {
     const pending = rows.filter((e) => e.connection === "pending-launch").length;
     if (ungoverned > 0) {
       console.error(
-        chalk28.yellow(
+        chalk29.yellow(
           `
-${ungoverned} ungoverned \u2014 run ` + chalk28.bold("node9 mcp gateway --all") + " to govern."
+${ungoverned} ungoverned \u2014 run ` + chalk29.bold("node9 mcp gateway --all") + " to govern."
         )
       );
     }
     if (pending > 0) {
       console.error(
-        chalk28.cyan(`${pending} governed but not yet connected \u2014 restart the agent to activate.`)
+        chalk29.cyan(`${pending} governed but not yet connected \u2014 restart the agent to activate.`)
       );
     }
     if (unlaunchable > 0) {
       console.error(
-        chalk28.red(
+        chalk29.red(
           `${unlaunchable} can't launch \u2014 set the missing env var(s) where the agent starts (a restart alone won't fix it).`
         )
       );
@@ -80195,27 +80544,27 @@ ${ungoverned} ungoverned \u2014 run ` + chalk28.bold("node9 mcp gateway --all")
       } else if (name) {
         const matches2 = resolve(name, opts.agent);
         if (matches2.length === 0) {
-          console.error(chalk28.red(`No MCP server named "${name}" found.`));
+          console.error(chalk29.red(`No MCP server named "${name}" found.`));
           process.exitCode = 1;
           return;
         }
         if (matches2.length > 1) {
           console.error(
-            chalk28.red(`"${name}" exists in ${matches2.length} agents \u2014 pass --agent <id> (`) + matches2.map((m) => m.agent).join(", ") + ")."
+            chalk29.red(`"${name}" exists in ${matches2.length} agents \u2014 pass --agent <id> (`) + matches2.map((m) => m.agent).join(", ") + ")."
           );
           process.exitCode = 1;
           return;
         }
         targets = matches2;
       } else {
-        console.error(chalk28.red("Pass a server name or --all. See `node9 mcp status`."));
+        console.error(chalk29.red("Pass a server name or --all. See `node9 mcp status`."));
         process.exitCode = 1;
         return;
       }
       const doable = targets.filter((e) => e.state === targetState);
       if (doable.length === 0) {
         console.error(
-          chalk28.gray(
+          chalk29.gray(
             opts.rewrap ? "Nothing to do \u2014 no governed servers to refresh." : "Nothing to do \u2014 already governed (or node9-self)."
           )
         );
@@ -80229,20 +80578,20 @@ ${ungoverned} ungoverned \u2014 run ` + chalk28.bold("node9 mcp gateway --all")
           else wrapEntry(e);
           agents.add(e.agentLabel);
           const verb = opts.rewrap ? "refreshed" : "governed";
-          console.error(chalk28.green(`\u2713 ${verb} ${e.name}`) + chalk28.gray(` (${e.agentLabel})`));
+          console.error(chalk29.green(`\u2713 ${verb} ${e.name}`) + chalk29.gray(` (${e.agentLabel})`));
         } catch (err2) {
           failed++;
           const msg = err2 instanceof Error ? err2.message : String(err2);
           console.error(
-            chalk28.red(`\u2717 failed ${e.name}`) + chalk28.gray(` (${e.agentLabel}): ${msg}`)
+            chalk29.red(`\u2717 failed ${e.name}`) + chalk29.gray(` (${e.agentLabel}): ${msg}`)
           );
         }
       }
       if (failed > 0) process.exitCode = 1;
       if (agents.size > 0) {
         console.error(
-          chalk28.bold(`
-Restart ${[...agents].join(", ")}`) + chalk28.gray(" to activate. Undo any server with ") + chalk28.cyan("node9 mcp ungateway <name>") + chalk28.gray(".")
+          chalk29.bold(`
+Restart ${[...agents].join(", ")}`) + chalk29.gray(" to activate. Undo any server with ") + chalk29.cyan("node9 mcp ungateway <name>") + chalk29.gray(".")
         );
       }
     }
@@ -80250,19 +80599,19 @@ Restart ${[...agents].join(", ")}`) + chalk28.gray(" to activate. Undo any serve
   mcp.command("ungateway <name>").description("Restore an MCP server to its original (un-route it from node9)").option("--agent <id>", "disambiguate a name in more than one agent").action((name, opts) => {
     const matches2 = resolve(name, opts.agent).filter((e2) => e2.state === "gatewayed");
     if (matches2.length === 0) {
-      console.error(chalk28.red(`No governed MCP server named "${name}" found.`));
+      console.error(chalk29.red(`No governed MCP server named "${name}" found.`));
       process.exitCode = 1;
       return;
     }
     if (matches2.length > 1) {
-      console.error(chalk28.red(`"${name}" is governed in multiple agents \u2014 pass --agent <id>.`));
+      console.error(chalk29.red(`"${name}" is governed in multiple agents \u2014 pass --agent <id>.`));
       process.exitCode = 1;
       return;
     }
     const e = matches2[0];
     const orig = fromGateway(e.raw);
     if (!orig) {
-      console.error(chalk28.red(`Couldn't parse the original command for "${name}".`));
+      console.error(chalk29.red(`Couldn't parse the original command for "${name}".`));
       process.exitCode = 1;
       return;
     }
@@ -80270,12 +80619,12 @@ Restart ${[...agents].join(", ")}`) + chalk28.gray(" to activate. Undo any serve
       writeMcpEntry(e.mcpFile, e.format, e.name, orig);
     } catch (err2) {
       const msg = err2 instanceof Error ? err2.message : String(err2);
-      console.error(chalk28.red(`Failed to restore "${name}": ${msg}`));
+      console.error(chalk29.red(`Failed to restore "${name}": ${msg}`));
       process.exitCode = 1;
       return;
     }
     console.error(
-      chalk28.green(`\u2713 restored ${e.name}`) + chalk28.gray(` (${e.agentLabel}) \u2014 restart ${e.agentLabel} to apply.`)
+      chalk29.green(`\u2713 restored ${e.name}`) + chalk29.gray(` (${e.agentLabel}) \u2014 restart ${e.agentLabel} to apply.`)
     );
   });
 }
@@ -80301,14 +80650,14 @@ function registerMcpPinCommand(program2) {
       }
     }
     if (repoCorrupt) {
-      console.error(chalk29.red(`
+      console.error(chalk30.red(`
 \u274C Repo pin file at ${found.path} is corrupt or unreadable.`));
       process.exit(1);
     }
     if (!homeResult.ok && homeResult.reason === "corrupt") {
-      console.error(chalk29.red(`
+      console.error(chalk30.red(`
 \u274C Home pin file is corrupt: ${homeResult.detail}`));
-      console.error(chalk29.yellow("   Run: node9 mcp pin reset\n"));
+      console.error(chalk30.yellow("   Run: node9 mcp pin reset\n"));
       process.exit(1);
     }
     const homeEntries = homeResult.ok ? homeResult.pins.servers : {};
@@ -80320,25 +80669,25 @@ function registerMcpPinCommand(program2) {
       merged.set(key, { entry, source: "repo" });
     }
     if (merged.size === 0) {
-      console.log(chalk29.gray("\nNo MCP servers are pinned yet."));
+      console.log(chalk30.gray("\nNo MCP servers are pinned yet."));
       console.log(
-        chalk29.gray("Pins are created automatically when the MCP gateway first connects.\n")
+        chalk30.gray("Pins are created automatically when the MCP gateway first connects.\n")
       );
       return;
     }
-    console.log(chalk29.bold("\n\u{1F512} Pinned MCP Servers\n"));
+    console.log(chalk30.bold("\n\u{1F512} Pinned MCP Servers\n"));
     const showSource = found.source === "repo";
     for (const [key, { entry, source }] of merged) {
-      const tag = showSource ? ` ${chalk29.yellow(`[${source}]`)}` : "";
-      console.log(`  ${chalk29.cyan(key)}${tag}  ${chalk29.gray(entry.label)}`);
-      console.log(`    Tools (${entry.toolCount}): ${chalk29.white(entry.toolNames.join(", "))}`);
-      console.log(`    Hash:  ${chalk29.gray(entry.toolsHash.slice(0, 16))}...`);
-      console.log(`    Pinned: ${chalk29.gray(entry.pinnedAt)}`);
+      const tag = showSource ? ` ${chalk30.yellow(`[${source}]`)}` : "";
+      console.log(`  ${chalk30.cyan(key)}${tag}  ${chalk30.gray(entry.label)}`);
+      console.log(`    Tools (${entry.toolCount}): ${chalk30.white(entry.toolNames.join(", "))}`);
+      console.log(`    Hash:  ${chalk30.gray(entry.toolsHash.slice(0, 16))}...`);
+      console.log(`    Pinned: ${chalk30.gray(entry.pinnedAt)}`);
       console.log("");
     }
     if (showSource) {
-      console.log(chalk29.gray(`   [repo] entries come from ${found.path}`));
-      console.log(chalk29.gray("   [home] entries come from ~/.node9/mcp-pins.json\n"));
+      console.log(chalk30.gray(`   [repo] entries come from ${found.path}`));
+      console.log(chalk30.gray("   [home] entries come from ~/.node9/mcp-pins.json\n"));
     }
   });
   pinSubCmd.command("promote <serverKey>").description(
@@ -80348,22 +80697,22 @@ function registerMcpPinCommand(program2) {
       const { repoPath, created } = promotePin(serverKey, process.cwd());
       if (created) {
         console.log(
-          chalk29.green(
+          chalk30.green(
             `
-\u2705 Created ${repoPath} with the promoted pin for ${chalk29.cyan(serverKey)}.`
+\u2705 Created ${repoPath} with the promoted pin for ${chalk30.cyan(serverKey)}.`
           )
         );
       } else {
-        console.log(chalk29.green(`
-\u2705 Promoted ${chalk29.cyan(serverKey)} into ${repoPath}.`));
+        console.log(chalk30.green(`
+\u2705 Promoted ${chalk30.cyan(serverKey)} into ${repoPath}.`));
       }
-      console.log(chalk29.gray("   Review the change and commit it:"));
-      console.log(chalk29.cyan(`     git add ${repoPath}`));
-      console.log(chalk29.cyan(`     git commit -m "pin ${serverKey} (node9)"`));
+      console.log(chalk30.gray("   Review the change and commit it:"));
+      console.log(chalk30.cyan(`     git add ${repoPath}`));
+      console.log(chalk30.cyan(`     git commit -m "pin ${serverKey} (node9)"`));
       console.log("");
     } catch (err2) {
       const msg = err2 instanceof Error ? err2.message : String(err2);
-      console.error(chalk29.red(`
+      console.error(chalk30.red(`
 \u274C ${msg}
 `));
       process.exit(1);
@@ -80376,36 +80725,36 @@ function registerMcpPinCommand(program2) {
     try {
       pins = readMcpPins();
     } catch {
-      console.error(chalk29.red("\n\u274C Pin file is corrupt."));
-      console.error(chalk29.yellow("   Run: node9 mcp pin reset\n"));
+      console.error(chalk30.red("\n\u274C Pin file is corrupt."));
+      console.error(chalk30.yellow("   Run: node9 mcp pin reset\n"));
       process.exit(1);
     }
     if (!pins.servers[serverKey]) {
-      console.error(chalk29.red(`
+      console.error(chalk30.red(`
 \u274C No pin found for server key "${serverKey}"
 `));
-      console.error(`Run ${chalk29.cyan("node9 mcp pin list")} to see pinned servers.
+      console.error(`Run ${chalk30.cyan("node9 mcp pin list")} to see pinned servers.
 `);
       process.exit(1);
     }
     const label3 = pins.servers[serverKey].label;
     removePin(serverKey);
-    console.log(chalk29.green(`
-\u{1F513} Pin removed for ${chalk29.cyan(serverKey)}`));
-    console.log(chalk29.gray(`   Server: ${label3}`));
-    console.log(chalk29.gray("   Next connection will re-pin with current tool definitions.\n"));
+    console.log(chalk30.green(`
+\u{1F513} Pin removed for ${chalk30.cyan(serverKey)}`));
+    console.log(chalk30.gray(`   Server: ${label3}`));
+    console.log(chalk30.gray("   Next connection will re-pin with current tool definitions.\n"));
   });
   pinSubCmd.command("reset").description("Clear all MCP pins (next connection to each server will re-pin)").action(() => {
     const result = readMcpPinsSafe();
     if (!result.ok && result.reason === "missing") {
-      console.log(chalk29.gray("\nNo pins to clear.\n"));
+      console.log(chalk30.gray("\nNo pins to clear.\n"));
       return;
     }
     const count = result.ok ? Object.keys(result.pins.servers).length : "?";
     clearAllPins();
-    console.log(chalk29.green(`
+    console.log(chalk30.green(`
 \u{1F513} Cleared ${count} MCP pin(s).`));
-    console.log(chalk29.gray("   Next connection to each server will re-pin.\n"));
+    console.log(chalk30.gray("   Next connection to each server will re-pin.\n"));
   });
   pinCmd.command("forget [serverKey]").option("--stale", "Remove all stale (orphaned) servers at once").description("Remove a server pin that is no longer configured in any agent").action((serverKey, opts) => {
     if (opts.stale) {
@@ -80414,7 +80763,7 @@ function registerMcpPinCommand(program2) {
     }
     if (!serverKey) {
       console.error(
-        chalk29.red("\n\u274C Please provide a server key, or use --stale to remove all orphans.\n")
+        chalk30.red("\n\u274C Please provide a server key, or use --stale to remove all orphans.\n")
       );
       process.exit(1);
     }
@@ -80422,15 +80771,15 @@ function registerMcpPinCommand(program2) {
     try {
       pins = readMcpPins();
     } catch {
-      console.error(chalk29.red("\n\u274C Pin file is corrupt."));
-      console.error(chalk29.yellow("   Run: node9 mcp pin reset\n"));
+      console.error(chalk30.red("\n\u274C Pin file is corrupt."));
+      console.error(chalk30.yellow("   Run: node9 mcp pin reset\n"));
       process.exit(1);
     }
     if (!pins.servers[serverKey]) {
-      console.error(chalk29.red(`
+      console.error(chalk30.red(`
 \u274C No pin found for server key "${serverKey}"
 `));
-      console.error(`Run ${chalk29.cyan("node9 mcp pin list")} to see pinned servers.
+      console.error(`Run ${chalk30.cyan("node9 mcp pin list")} to see pinned servers.
 `);
       process.exit(1);
     }
@@ -80438,10 +80787,10 @@ function registerMcpPinCommand(program2) {
     const liveKeys = inventoryServerKeys(inv);
     if (liveKeys.has(serverKey)) {
       const agent = "an agent config";
-      console.error(chalk29.red(`
+      console.error(chalk30.red(`
 \u274C Server "${serverKey}" is still configured in ${agent}.`));
       console.error(
-        chalk29.yellow(
+        chalk30.yellow(
           `   Remove it from the agent config first, then run: node9 mcp forget ${serverKey}
 `
         )
@@ -80450,10 +80799,10 @@ function registerMcpPinCommand(program2) {
     }
     const label3 = pins.servers[serverKey].label;
     removePin(serverKey);
-    console.log(chalk29.green(`
-\u2713 Forgot server ${chalk29.cyan(serverKey)}`));
-    console.log(chalk29.gray(`   Was: ${label3}`));
-    console.log(chalk29.gray("   Pin removed \u2014 server will no longer appear in the dashboard.\n"));
+    console.log(chalk30.green(`
+\u2713 Forgot server ${chalk30.cyan(serverKey)}`));
+    console.log(chalk30.gray(`   Was: ${label3}`));
+    console.log(chalk30.gray("   Pin removed \u2014 server will no longer appear in the dashboard.\n"));
   });
 }
 function forgetAllStale() {
@@ -80461,16 +80810,16 @@ function forgetAllStale() {
   try {
     pins = readMcpPins();
   } catch {
-    console.error(chalk29.red("\n\u274C Pin file is corrupt."));
-    console.error(chalk29.yellow("   Run: node9 mcp pin reset\n"));
+    console.error(chalk30.red("\n\u274C Pin file is corrupt."));
+    console.error(chalk30.yellow("   Run: node9 mcp pin reset\n"));
     process.exit(1);
   }
   const inv = inventoryMcp();
   const liveKeys = inventoryServerKeys(inv);
   if (liveKeys.size === 0) {
-    console.error(chalk29.red("\n\u274C No live MCP servers detected \u2014 refusing to remove every pin."));
+    console.error(chalk30.red("\n\u274C No live MCP servers detected \u2014 refusing to remove every pin."));
     console.error(
-      chalk29.yellow(
+      chalk30.yellow(
         "   This usually means an agent config is missing or unreadable, not that\n   every server is gone. Check your agent configs, or remove one at a\n   time: node9 mcp forget <key>\n"
       )
     );
@@ -80478,118 +80827,118 @@ function forgetAllStale() {
   }
   const stale = Object.entries(pins.servers).filter(([sk]) => !liveKeys.has(sk));
   if (stale.length === 0) {
-    console.log(chalk29.gray("\nNo stale servers to remove.\n"));
+    console.log(chalk30.gray("\nNo stale servers to remove.\n"));
     return;
   }
   for (const [sk, pin] of stale) {
     delete pins.servers[sk];
-    console.log(chalk29.green(`  \u2713 ${chalk29.cyan(sk)}  ${chalk29.gray(pin.label)}`));
+    console.log(chalk30.green(`  \u2713 ${chalk30.cyan(sk)}  ${chalk30.gray(pin.label)}`));
   }
   writeMcpPins(pins);
-  console.log(chalk29.green(`
+  console.log(chalk30.green(`
 Removed ${stale.length} stale server(s).
 `));
 }
 
 // src/cli/commands/sync.ts
 init_sync();
-import chalk30 from "chalk";
+import chalk31 from "chalk";
 function registerSyncCommand(program2) {
   const policy = program2.command("policy").description("Manage cloud policy rules");
   policy.command("push").description("Push this machine's effective policy to the node9 dashboard").action(async () => {
-    process.stdout.write(chalk30.cyan("Pushing policy to the dashboard\u2026"));
+    process.stdout.write(chalk31.cyan("Pushing policy to the dashboard\u2026"));
     const result = await runPolicyPush();
     process.stdout.write("\n");
     if (!result.ok) {
-      console.error(chalk30.red(`\u2717 ${result.reason}`));
+      console.error(chalk31.red(`\u2717 ${result.reason}`));
       process.exit(1);
     }
-    console.log(chalk30.green("\u2713 Policy mirrored to the dashboard"));
-    console.log(chalk30.gray("  See it under Security Policy \u2192 Machines"));
+    console.log(chalk31.green("\u2713 Policy mirrored to the dashboard"));
+    console.log(chalk31.gray("  See it under Security Policy \u2192 Machines"));
   });
   policy.command("sync").description("Sync cloud policy rules to local cache (~/.node9/rules-cache.json)").action(async () => {
-    process.stdout.write(chalk30.cyan("Syncing cloud policy rules\u2026"));
+    process.stdout.write(chalk31.cyan("Syncing cloud policy rules\u2026"));
     const result = await runCloudSync();
     process.stdout.write("\n");
     if (!result.ok) {
-      console.error(chalk30.red(`\u2717 ${result.reason}`));
+      console.error(chalk31.red(`\u2717 ${result.reason}`));
       process.exit(1);
     }
     if (result.unchanged) {
       console.log(
-        chalk30.green(
+        chalk31.green(
           `\u2713 Already up to date \u2014 ${result.rules} rule${result.rules === 1 ? "" : "s"} cached`
         )
       );
-      console.log(chalk30.gray(`  Cached at: ${result.fetchedAt}`));
-      console.log(chalk30.gray(`  Server returned 304 (no changes since last sync)`));
+      console.log(chalk31.gray(`  Cached at: ${result.fetchedAt}`));
+      console.log(chalk31.gray(`  Server returned 304 (no changes since last sync)`));
     } else {
       console.log(
-        chalk30.green(`\u2713 Synced ${result.rules} rule${result.rules === 1 ? "" : "s"} from cloud`)
+        chalk31.green(`\u2713 Synced ${result.rules} rule${result.rules === 1 ? "" : "s"} from cloud`)
       );
-      console.log(chalk30.gray(`  Cached at: ${result.fetchedAt}`));
-      console.log(chalk30.gray(`  File: ~/.node9/rules-cache.json`));
+      console.log(chalk31.gray(`  Cached at: ${result.fetchedAt}`));
+      console.log(chalk31.gray(`  File: ~/.node9/rules-cache.json`));
     }
   });
   policy.command("show").description("List all cloud policy rules in the local cache").action(() => {
     const status = getCloudSyncStatus();
     if (!status.cached) {
-      console.log(chalk30.yellow("\n  No cloud rules cached \u2014 run: node9 policy sync\n"));
+      console.log(chalk31.yellow("\n  No cloud rules cached \u2014 run: node9 policy sync\n"));
       return;
     }
     const rules = getCloudRules() ?? [];
     const age = Math.round((Date.now() - new Date(status.fetchedAt).getTime()) / 6e4);
     console.log(
-      chalk30.bold(`
-  Cloud policy rules`) + chalk30.gray(
+      chalk31.bold(`
+  Cloud policy rules`) + chalk31.gray(
         ` (${rules.length} rule${rules.length === 1 ? "" : "s"}, synced ${age}m ago)
 `
       )
     );
     if (rules.length === 0) {
-      console.log(chalk30.gray("  No rules defined in cloud policy.\n"));
+      console.log(chalk31.gray("  No rules defined in cloud policy.\n"));
       return;
     }
     for (const rule of rules) {
       const r = rule;
-      const verdictColor = r.verdict === "block" ? chalk30.red : r.verdict === "allow" ? chalk30.green : chalk30.yellow;
+      const verdictColor = r.verdict === "block" ? chalk31.red : r.verdict === "allow" ? chalk31.green : chalk31.yellow;
       console.log(
         `  ${verdictColor(
           String(r.verdict ?? "unknown").toUpperCase().padEnd(6)
-        )}  ${chalk30.white(String(r.name ?? "(unnamed)"))}`
+        )}  ${chalk31.white(String(r.name ?? "(unnamed)"))}`
       );
-      if (r.reason) console.log(chalk30.gray(`           ${String(r.reason)}`));
+      if (r.reason) console.log(chalk31.gray(`           ${String(r.reason)}`));
     }
     console.log("");
   });
   policy.command("status").description("Show current cloud policy cache status").action(() => {
     const s = getCloudSyncStatus();
     if (!s.cached) {
-      console.log(chalk30.yellow("\n  No cache yet \u2014 run: node9 policy sync\n"));
+      console.log(chalk31.yellow("\n  No cache yet \u2014 run: node9 policy sync\n"));
       return;
     }
     const age = Math.round((Date.now() - new Date(s.fetchedAt).getTime()) / 6e4);
     console.log(`
-  Rules   : ${chalk30.green(String(s.rules))} cloud rules loaded`);
+  Rules   : ${chalk31.green(String(s.rules))} cloud rules loaded`);
     console.log(
-      `  Synced  : ${chalk30.gray(`${age} minute${age === 1 ? "" : "s"} ago`)} (${s.fetchedAt})`
+      `  Synced  : ${chalk31.gray(`${age} minute${age === 1 ? "" : "s"} ago`)} (${s.fetchedAt})`
     );
     if (s.workspaceId) {
-      console.log(`  Workspace: ${chalk30.gray(s.workspaceId)}`);
+      console.log(`  Workspace: ${chalk31.gray(s.workspaceId)}`);
     }
     if (s.panicMode) {
       console.log(
-        `  ${chalk30.red.bold("\u{1F6A8} Panic mode  : ON")}  ` + chalk30.dim("(every review-verdict becomes block)")
+        `  ${chalk31.red.bold("\u{1F6A8} Panic mode  : ON")}  ` + chalk31.dim("(every review-verdict becomes block)")
       );
     }
     if (s.shadowMode) {
       console.log(
-        `  ${chalk30.yellow.bold("\u{1F441}  Shadow mode : ON")}  ` + chalk30.dim("(blocks become would-block log entries)")
+        `  ${chalk31.yellow.bold("\u{1F441}  Shadow mode : ON")}  ` + chalk31.dim("(blocks become would-block log entries)")
       );
     }
     if (s.syncIntervalHours) {
       console.log(
-        chalk30.gray(
+        chalk31.gray(
           `  Polling : every ${s.syncIntervalHours} hour${s.syncIntervalHours === 1 ? "" : "s"}`
         )
       );
@@ -80600,7 +80949,7 @@ function registerSyncCommand(program2) {
 
 // src/cli/commands/agents.ts
 init_setup();
-import chalk31 from "chalk";
+import chalk32 from "chalk";
 var SETUP_FN = {
   claude: setupClaude,
   gemini: setupGemini,
@@ -80643,30 +80992,30 @@ function registerAgentsCommand(program2) {
     console.log(`  ${"Agent".padEnd(14)}${"Installed".padEnd(11)}${"Wired".padEnd(8)}Mode`);
     console.log("  " + "\u2500".repeat(44));
     for (const s of statuses) {
-      const installed = s.installed ? chalk31.green("\u2713") : chalk31.gray("\u2717");
-      const wired = !s.installed ? chalk31.gray("\u2014") : s.wired ? chalk31.green("\u2713") : chalk31.yellow("\u2717");
-      const mode = s.mode ? chalk31.gray(s.mode) : chalk31.gray("\u2014");
-      const hint = s.installed && !s.wired ? chalk31.gray(`  \u2190 node9 agents add ${s.name}`) : "";
+      const installed = s.installed ? chalk32.green("\u2713") : chalk32.gray("\u2717");
+      const wired = !s.installed ? chalk32.gray("\u2014") : s.wired ? chalk32.green("\u2713") : chalk32.yellow("\u2717");
+      const mode = s.mode ? chalk32.gray(s.mode) : chalk32.gray("\u2014");
+      const hint = s.installed && !s.wired ? chalk32.gray(`  \u2190 node9 agents add ${s.name}`) : "";
       console.log(`  ${s.label.padEnd(14)}${installed}          ${wired}       ${mode}${hint}`);
     }
     console.log("");
     if (!anyInstalled) {
       console.log(
-        chalk31.gray("  No AI agents detected. Install Claude Code, Gemini CLI, Cursor,\n") + chalk31.gray("  Windsurf, VSCode, or Codex then run: node9 agents list\n")
+        chalk32.gray("  No AI agents detected. Install Claude Code, Gemini CLI, Cursor,\n") + chalk32.gray("  Windsurf, VSCode, or Codex then run: node9 agents list\n")
       );
       return;
     }
     const unwired = statuses.filter((s) => s.installed && !s.wired);
     if (unwired.length > 0) {
       console.log(
-        chalk31.yellow(`  ${unwired.length} agent(s) not yet wired. Run: `) + chalk31.white(`node9 agents add ${unwired[0].name}`) + "\n"
+        chalk32.yellow(`  ${unwired.length} agent(s) not yet wired. Run: `) + chalk32.white(`node9 agents add ${unwired[0].name}`) + "\n"
       );
     }
     if (statuses.some((s) => s.name === "gemini" && s.installed)) {
       console.log(
-        chalk31.yellow(
+        chalk32.yellow(
           "  \u26A0\uFE0F  Gemini CLI stops serving AI Pro/Ultra and free tiers on 2026-06-18.\n"
-        ) + chalk31.gray("     Migrate to Antigravity: ") + chalk31.white("node9 agents add antigravity") + "\n"
+        ) + chalk32.gray("     Migrate to Antigravity: ") + chalk32.white("node9 agents add antigravity") + "\n"
       );
     }
   });
@@ -80674,7 +81023,7 @@ function registerAgentsCommand(program2) {
     const name = resolveAgentName(agent);
     const fn = SETUP_FN[name];
     if (!fn) {
-      console.error(chalk31.red(`Unknown agent: "${agent}". Supported: ${AGENT_NAMES.join(", ")}`));
+      console.error(chalk32.red(`Unknown agent: "${agent}". Supported: ${AGENT_NAMES.join(", ")}`));
       process.exit(1);
     }
     await fn();
@@ -80683,14 +81032,14 @@ function registerAgentsCommand(program2) {
     const name = resolveAgentName(agent);
     const fn = TEARDOWN_FN[name];
     if (!fn) {
-      console.error(chalk31.red(`Unknown agent: "${agent}". Supported: ${AGENT_NAMES.join(", ")}`));
+      console.error(chalk32.red(`Unknown agent: "${agent}". Supported: ${AGENT_NAMES.join(", ")}`));
       process.exit(1);
     }
-    console.log(chalk31.cyan(`
+    console.log(chalk32.cyan(`
 \u{1F6E1}\uFE0F  Node9: removing from ${name}...
 `));
     fn();
-    console.log(chalk31.gray("\n  Restart the agent for changes to take effect."));
+    console.log(chalk32.gray("\n  Restart the agent for changes to take effect."));
   });
 }
 
@@ -80699,21 +81048,21 @@ init_scan();
 
 // src/cli/commands/posture.ts
 init_posture();
-import chalk33 from "chalk";
+import chalk34 from "chalk";
 
 // src/posture/render.ts
 init_score();
-import chalk32 from "chalk";
+import chalk33 from "chalk";
 var ICON = {
-  critical: chalk32.red("\u274C"),
-  high: chalk32.red("\u274C"),
-  medium: chalk32.yellow("\u26A0\uFE0F "),
-  advisory: chalk32.gray("\u26A0\uFE0F ")
+  critical: chalk33.red("\u274C"),
+  high: chalk33.red("\u274C"),
+  medium: chalk33.yellow("\u26A0\uFE0F "),
+  advisory: chalk33.gray("\u26A0\uFE0F ")
 };
 var TIER_LABEL = {
-  good: chalk32.green("Good"),
-  "at-risk": chalk32.yellow("At risk"),
-  critical: chalk32.red("Critical")
+  good: chalk33.green("Good"),
+  "at-risk": chalk33.yellow("At risk"),
+  critical: chalk33.red("Critical")
 };
 function wrap(text, width) {
   const out = [];
@@ -80731,7 +81080,7 @@ function wrap(text, width) {
 }
 var LABEL_WIDTH = 14;
 function label2(category) {
-  return chalk32.bold(category.padEnd(Math.max(LABEL_WIDTH, category.length + 1)));
+  return chalk33.bold(category.padEnd(Math.max(LABEL_WIDTH, category.length + 1)));
 }
 function guardedWhat(f) {
   if (f.detail.length === 0) return "this";
@@ -80741,31 +81090,31 @@ function guardedWhat(f) {
 }
 function renderFinding(f, showWeight = false, displayLabel = f.category) {
   const lines = [];
-  const wt = showWeight && f.scoreWeight ? chalk32.cyan.bold(`+${f.scoreWeight} `) : "";
+  const wt = showWeight && f.scoreWeight ? chalk33.cyan.bold(`+${f.scoreWeight} `) : "";
   lines.push(`  ${ICON[f.severity]} ${label2(displayLabel)}${wt}${f.title}`);
   const indent = " ".repeat(2 + 3 + LABEL_WIDTH);
   const width = 80 - indent.length;
   for (const s of [f.what, f.why, f.who]) {
-    if (s) for (const l of wrap(s, width)) lines.push(indent + chalk32.gray(l));
+    if (s) for (const l of wrap(s, width)) lines.push(indent + chalk33.gray(l));
   }
-  for (const d of f.detail) lines.push(indent + chalk32.gray(d));
+  for (const d of f.detail) lines.push(indent + chalk33.gray(d));
   if (f.fix) {
     let first = true;
     for (const seg of f.fix.split("\n")) {
       for (const l of wrap(seg, width - 2)) {
-        lines.push(indent + chalk32.cyan(first ? "\u2192 " + l : "  " + l));
+        lines.push(indent + chalk33.cyan(first ? "\u2192 " + l : "  " + l));
         first = false;
       }
     }
   }
   const tradeoff = [
-    [f.gain, "gain: ", chalk32.green],
-    [f.cost, "cost: ", chalk32.yellow]
+    [f.gain, "gain: ", chalk33.green],
+    [f.cost, "cost: ", chalk33.yellow]
   ];
   for (const [text, lbl, color2] of tradeoff) {
     if (!text) continue;
     wrap(text, width - 6).forEach((l, i) => {
-      lines.push(indent + (i === 0 ? color2(lbl) : "      ") + chalk32.gray(l));
+      lines.push(indent + (i === 0 ? color2(lbl) : "      ") + chalk33.gray(l));
     });
   }
   return lines;
@@ -80775,7 +81124,7 @@ function renderPosture(result) {
   const tier = TIER_LABEL[result.tier];
   lines.push("");
   lines.push(
-    chalk32.cyan.bold(`\u{1F6E1}\uFE0F  Node9 Posture`) + chalk32.gray(` \u2014 ${result.agent}`) + `        ${chalk32.bold(`Score: ${result.score}/100`)}  (${tier})`
+    chalk33.cyan.bold(`\u{1F6E1}\uFE0F  Node9 Posture`) + chalk33.gray(` \u2014 ${result.agent}`) + `        ${chalk33.bold(`Score: ${result.score}/100`)}  (${tier})`
   );
   const headroom = openHeadroom(result.findings);
   if (headroom > 0) {
@@ -80783,15 +81132,15 @@ function renderPosture(result) {
       (f) => f.coverage?.state !== "covered" && f.coverage?.state !== "cant-fix" && !f.scoreWeight && f.severity !== "advisory"
     ).length;
     const note = openExposures > 0 ? `Of the gap to 100: ${headroom} pts is optional hardening you can choose to turn on (the \u{1F512} tier below, each at some cost to flexibility); the rest is the open findings \u2014 the flagged rows below. Fix those first.` : `${headroom} pts of headroom \u2014 optional hardening you can choose to turn on (the \u{1F512} tier below), each at some cost to flexibility.`;
-    for (const l of wrap(note, 76)) lines.push("  " + chalk32.gray(l));
+    for (const l of wrap(note, 76)) lines.push("  " + chalk33.gray(l));
   }
   lines.push("");
   if (result.headline) {
     const indent = "     ";
-    lines.push(`  ${chalk32.red.bold("\u{1F525} Biggest risk")}`);
-    for (const l of wrap(result.headline.risk, 74)) lines.push(indent + chalk32.white(l));
+    lines.push(`  ${chalk33.red.bold("\u{1F525} Biggest risk")}`);
+    for (const l of wrap(result.headline.risk, 74)) lines.push(indent + chalk33.white(l));
     const action = wrap(`Do this first: ${result.headline.action}`, 72);
-    action.forEach((l, i) => lines.push(indent + chalk32.cyan(i === 0 ? "\u2192 " + l : "  " + l)));
+    action.forEach((l, i) => lines.push(indent + chalk33.cyan(i === 0 ? "\u2192 " + l : "  " + l)));
     lines.push("");
   }
   const covered = result.findings.filter((f) => f.coverage?.state === "covered");
@@ -80801,13 +81150,13 @@ function renderPosture(result) {
   );
   const openLabel = (f) => collision.has(f.category) ? `${f.category} (exposed)` : f.category;
   if (covered.length > 0) {
-    lines.push("  " + chalk32.green("\u{1F7E2} ON NOW \u2014 node9 is enforcing these (your floor)"));
+    lines.push("  " + chalk33.green("\u{1F7E2} ON NOW \u2014 node9 is enforcing these (your floor)"));
     for (const f of covered) {
       const gated = f.coverage?.level === "review" ? "approval-gating" : "blocking";
       const via = f.coverage?.via ?? "node9";
       const lbl = collision.has(f.category) ? `${f.category} (guarded)` : f.category;
       lines.push(
-        `  ${chalk32.green("\u2705")} ${label2(lbl)}${chalk32.gray(`${via} is ${gated} ${guardedWhat(f)}`)}`
+        `  ${chalk33.green("\u2705")} ${label2(lbl)}${chalk33.gray(`${via} is ${gated} ${guardedWhat(f)}`)}`
       );
     }
     lines.push("");
@@ -80816,24 +81165,24 @@ function renderPosture(result) {
   const reduceOpen = open.filter((f) => f.owner !== "node9" && f.node9Reduces);
   const osOpen = open.filter((f) => f.owner !== "node9" && !f.node9Reduces);
   if (node9Open.length > 0) {
-    lines.push("  " + chalk32.cyan.bold("\u{1F527} node9 can fix these \u2014 run the command"));
+    lines.push("  " + chalk33.cyan.bold("\u{1F527} node9 can fix these \u2014 run the command"));
     for (const f of node9Open) lines.push(...renderFinding(f, true, openLabel(f)));
   }
   if (reduceOpen.length > 0) {
     if (node9Open.length > 0) lines.push("");
-    lines.push("  " + chalk32.yellow.bold("\u{1F512} AVAILABLE \u2014 turn on to harden (each has a tradeoff)"));
+    lines.push("  " + chalk33.yellow.bold("\u{1F512} AVAILABLE \u2014 turn on to harden (each has a tradeoff)"));
     for (const f of reduceOpen) lines.push(...renderFinding(f, true, openLabel(f)));
   }
   if (osOpen.length > 0) {
     if (node9Open.length > 0 || reduceOpen.length > 0) lines.push("");
-    lines.push("  " + chalk32.bold("\u{1F9F1} YOUR PART \u2014 node9 can't fix these (OS-level)"));
+    lines.push("  " + chalk33.bold("\u{1F9F1} YOUR PART \u2014 node9 can't fix these (OS-level)"));
     for (const f of osOpen) lines.push(...renderFinding(f, false, openLabel(f)));
   }
   for (const cat of result.passedCategories) {
-    lines.push(`  ${chalk32.green("\u2705")} ${label2(cat)}${chalk32.gray("no issues found")}`);
+    lines.push(`  ${chalk33.green("\u2705")} ${label2(cat)}${chalk33.gray("no issues found")}`);
   }
   for (const cat of result.erroredCategories) {
-    lines.push(`  ${chalk32.gray("\u2022")}  ${label2(cat)}${chalk32.gray("could not be checked")}`);
+    lines.push(`  ${chalk33.gray("\u2022")}  ${label2(cat)}${chalk33.gray("could not be checked")}`);
   }
   lines.push("");
   const crit = open.filter((f) => f.severity === "critical").length;
@@ -80841,16 +81190,16 @@ function renderPosture(result) {
   const med = open.filter((f) => f.severity === "medium").length;
   const adv = open.filter((f) => f.severity === "advisory").length;
   const parts = [];
-  if (crit) parts.push(chalk32.red(`${crit} critical`));
-  if (high) parts.push(chalk32.red(`${high} high`));
-  if (med) parts.push(chalk32.yellow(`${med} medium`));
-  if (adv) parts.push(chalk32.gray(`${adv} advisory`));
-  const summary = parts.length ? parts.join(" \xB7 ") : chalk32.green("no findings");
+  if (crit) parts.push(chalk33.red(`${crit} critical`));
+  if (high) parts.push(chalk33.red(`${high} high`));
+  if (med) parts.push(chalk33.yellow(`${med} medium`));
+  if (adv) parts.push(chalk33.gray(`${adv} advisory`));
+  const summary = parts.length ? parts.join(" \xB7 ") : chalk33.green("no findings");
   lines.push(`  ${summary}`);
   lines.push("");
-  lines.push("  " + chalk32.bold("Track this across your fleet & keep it green:"));
+  lines.push("  " + chalk33.bold("Track this across your fleet & keep it green:"));
   lines.push(
-    "  " + chalk32.dim("\u2192 ") + chalk32.cyan.underline("https://node9.ai/auth/signup?ref=cli_posture")
+    "  " + chalk33.dim("\u2192 ") + chalk33.cyan.underline("https://node9.ai/auth/signup?ref=cli_posture")
   );
   lines.push("");
   return lines.join("\n");
@@ -80870,11 +81219,11 @@ function registerPostureCommand(program2) {
     if (opts.ship) {
       const creds = readCredentials();
       if (!creds) {
-        console.error(chalk33.gray("  Run `node9 login` to ship this to your dashboard."));
+        console.error(chalk34.gray("  Run `node9 login` to ship this to your dashboard."));
       } else {
         const ok2 = await shipPosture(result, creds);
         console.error(
-          ok2 ? chalk33.gray("  \u2713 Shipped to your node9 dashboard.") : chalk33.gray("  Could not reach the dashboard \u2014 saved locally only.")
+          ok2 ? chalk34.gray("  \u2713 Shipped to your node9 dashboard.") : chalk34.gray("  Could not reach the dashboard \u2014 saved locally only.")
         );
       }
     }
@@ -80883,7 +81232,7 @@ function registerPostureCommand(program2) {
 }
 
 // src/cli/commands/scan-repo.ts
-import chalk35 from "chalk";
+import chalk36 from "chalk";
 
 // src/ci-check/fetch.ts
 var import_undici = __toESM(require_undici());
@@ -86395,7 +86744,7 @@ async function scanRepo(input, onProgress) {
 }
 
 // src/ci-check/render.ts
-import chalk34 from "chalk";
+import chalk35 from "chalk";
 var listed = (fs109) => fs109.filter((f) => f.tier !== "review");
 function excerpt(f) {
   const m = /`([^`]+)`/.exec(f.signals[0] ?? "");
@@ -86440,23 +86789,23 @@ function reviewTerminal(findings) {
   const L = [];
   if (items) {
     L.push(
-      chalk34.bold(`\u{1F50D} ${items} ${items === 1 ? "item" : "items"} worth a look (not counted)`) + chalk34.gray(": risky-looking text in a context that is usually harmless. Please confirm.")
+      chalk35.bold(`\u{1F50D} ${items} ${items === 1 ? "item" : "items"} worth a look (not counted)`) + chalk35.gray(": risky-looking text in a context that is usually harmless. Please confirm.")
     );
     const files = [...byFile.keys()];
     for (const file2 of files.slice(0, REVIEW_FILES)) {
       const fs109 = byFile.get(file2);
-      L.push(chalk34.gray(`   ${file2}`));
+      L.push(chalk35.gray(`   ${file2}`));
       for (const f of fs109.slice(0, REVIEW_LINES_PER_FILE))
         L.push(`     \u2022 ${f.line ? `line ${f.line}: ` : ""}${excerpt(f)}`);
       if (fs109.length > REVIEW_LINES_PER_FILE)
-        L.push(chalk34.gray(`     and ${fs109.length - REVIEW_LINES_PER_FILE} similar lines`));
+        L.push(chalk35.gray(`     and ${fs109.length - REVIEW_LINES_PER_FILE} similar lines`));
     }
     const more = files.length - REVIEW_FILES;
-    if (more > 0) L.push(chalk34.gray(`   and ${more} more file${more === 1 ? "" : "s"}`));
+    if (more > 0) L.push(chalk35.gray(`   and ${more} more file${more === 1 ? "" : "s"}`));
   }
   if (grants)
     L.push(
-      chalk34.gray(
+      chalk35.gray(
         `   ${grants} skill${grants === 1 ? " is" : "s are"} granted broad tools (Bash, Write or Edit); usually what the skill needs.`
       )
     );
@@ -86470,45 +86819,45 @@ var ICON2 = {
   advisory: "\u{1F7E2}"
 };
 var COLOR = {
-  critical: chalk34.red.bold,
-  high: chalk34.red,
-  medium: chalk34.yellow,
-  advisory: chalk34.gray
+  critical: chalk35.red.bold,
+  high: chalk35.red,
+  medium: chalk35.yellow,
+  advisory: chalk35.gray
 };
 var ACTION_URL = "https://github.com/marketplace/actions/node9-agent-security?ref=cli_scan_repo";
 function renderCta(res) {
   const L = [];
-  L.push(chalk34.dim("   " + "\u2500".repeat(63)));
+  L.push(chalk35.dim("   " + "\u2500".repeat(63)));
   if (res.worst === "critical" || res.worst === "high") {
     const n = res.findings.filter(
       (f) => isAlert(f) && !f.suppressed && (f.severity === "critical" || f.severity === "high")
     ).length;
     L.push(
-      "   " + chalk34.red.bold(
+      "   " + chalk35.red.bold(
         `\u{1F534} ${n} ${n === 1 ? "issue" : "issues"} to fix, then stop the next at the PR.`
       )
     );
     L.push("");
-    L.push("   " + chalk34.bold("Catch this class of issue on every PR, automatically:"));
+    L.push("   " + chalk35.bold("Catch this class of issue on every PR, automatically:"));
   } else if (res.worst) {
-    L.push("   " + chalk34.yellow("\u{1F7E1} Review the findings above, then keep it covered:"));
+    L.push("   " + chalk35.yellow("\u{1F7E1} Review the findings above, then keep it covered:"));
     L.push("");
-    L.push("   " + chalk34.bold("Check every PR for agent-CI risk:"));
+    L.push("   " + chalk35.bold("Check every PR for agent-CI risk:"));
   } else if (res.incomplete) {
-    L.push("   " + chalk34.yellow.bold("\u26A0\uFE0F  Incomplete: not a clean bill of health."));
+    L.push("   " + chalk35.yellow.bold("\u26A0\uFE0F  Incomplete: not a clean bill of health."));
     L.push("");
-    L.push("   " + chalk34.bold("Get a complete check on every PR (CI reads the tree directly):"));
+    L.push("   " + chalk35.bold("Get a complete check on every PR (CI reads the tree directly):"));
   } else {
     L.push(
-      "   " + chalk34.green(
+      "   " + chalk35.green(
         groupReview(res.findings).byFile.size ? "\u2705 No alerts. Check the items worth a look above." : "\u2705 Agent CI is well-configured: 0 unmitigated issues."
       )
     );
     L.push("");
-    L.push("   " + chalk34.bold("Keep it green as you add agent workflows. Check every PR:"));
+    L.push("   " + chalk35.bold("Keep it green as you add agent workflows. Check every PR:"));
   }
-  L.push("   " + chalk34.dim("\u2192 ") + chalk34.cyan.underline(ACTION_URL));
-  L.push("   " + chalk34.gray("  zero setup \xB7 no token \xB7 runs in your CI"));
+  L.push("   " + chalk35.dim("\u2192 ") + chalk35.cyan.underline(ACTION_URL));
+  L.push("   " + chalk35.gray("  zero setup \xB7 no token \xB7 runs in your CI"));
   return L;
 }
 function ownedHint(source) {
@@ -86548,21 +86897,21 @@ function renderScan(res, diff) {
   const L = [];
   const shown = listed(res.findings);
   const n = shown.length;
-  const head = res.worst === "critical" || res.worst === "high" ? chalk34.red.bold("\u26A0\uFE0F  agent-security risk found") : res.worst ? chalk34.yellow("agent-security notes") : res.incomplete ? chalk34.yellow.bold("\u26A0\uFE0F  INCOMPLETE: could not read all files") : groupReview(res.findings).byFile.size ? chalk34.green("\u2705 agent-security: no alerts (items worth a look below)") : chalk34.green("\u2705 agent-security: clean");
-  L.push(`\u{1F6E1}\uFE0F  ${chalk34.bold("node9 scan-repo")}  \xB7  ${res.source}  \xB7  ${head}`);
+  const head = res.worst === "critical" || res.worst === "high" ? chalk35.red.bold("\u26A0\uFE0F  agent-security risk found") : res.worst ? chalk35.yellow("agent-security notes") : res.incomplete ? chalk35.yellow.bold("\u26A0\uFE0F  INCOMPLETE: could not read all files") : groupReview(res.findings).byFile.size ? chalk35.green("\u2705 agent-security: no alerts (items worth a look below)") : chalk35.green("\u2705 agent-security: clean");
+  L.push(`\u{1F6E1}\uFE0F  ${chalk35.bold("node9 scan-repo")}  \xB7  ${res.source}  \xB7  ${head}`);
   L.push(
-    chalk34.gray(
+    chalk35.gray(
       `   inspected ${res.inspected.length} config file(s), ${n} finding(s)` + (res.suppressedCount ? ` \xB7 ${res.suppressedCount} suppressed by .node9-ignore.json` : "")
     )
   );
   if (diff) {
     const introduced = listed(diff.added).length + diff.escalated.length;
     L.push(
-      diff.base !== "ok" ? chalk34.yellow.bold(
+      diff.base !== "ok" ? chalk35.yellow.bold(
         `   \u26A0\uFE0F  base ${diff.base === "did-not-run" ? "could not be read" : "scan was incomplete"}, so it cannot say what is new; showing everything`
-      ) : introduced > 0 ? chalk34.red.bold(
+      ) : introduced > 0 ? chalk35.red.bold(
         `   \u26A0\uFE0F  this change introduced ${introduced} finding(s)` + (diff.escalated.length ? ` (${diff.escalated.length} by widening an existing one)` : "")
-      ) : chalk34.green(
+      ) : chalk35.green(
         `   \u2705 this change introduced nothing` + (diff.unchanged.length ? ` (${diff.unchanged.length} pre-existing)` : "") + (diff.removed.length ? `, and fixed ${diff.removed.length}` : "")
       )
     );
@@ -86570,7 +86919,7 @@ function renderScan(res, diff) {
   if (res.incomplete) {
     const rateLimited = res.notes.some((nt) => /rate limit/i.test(nt));
     L.push(
-      chalk34.yellow.bold(
+      chalk35.yellow.bold(
         rateLimited ? "   \u26A0\uFE0F  Rate-limited: some files were unread. NOT a clean bill of health; set GITHUB_TOKEN (or run `gh auth login`) and re-run." : "   \u26A0\uFE0F  A network error left some files unread. NOT a clean bill of health; re-run."
       )
     );
@@ -86579,36 +86928,36 @@ function renderScan(res, diff) {
   for (const f of shown) {
     const ex = f.explain;
     L.push(
-      `${ICON2[f.severity]} ${COLOR[f.severity](f.severity.toUpperCase())}  ${chalk34.bold(ex ? ex.headline : f.title)}`
+      `${ICON2[f.severity]} ${COLOR[f.severity](f.severity.toUpperCase())}  ${chalk35.bold(ex ? ex.headline : f.title)}`
     );
-    L.push(chalk34.gray(`   ${f.file}${f.line ? ":" + f.line : ""}  \xB7  ${f.check}`));
+    L.push(chalk35.gray(`   ${f.file}${f.line ? ":" + f.line : ""}  \xB7  ${f.check}`));
     if (ex) {
       L.push(`     ${ex.happens}`);
       for (const s of ex.saw) L.push(`     \u2022 ${s}`);
-      ex.fix.forEach((x, i) => L.push(chalk34.cyan(`     ${i + 1}. ${x}`)));
+      ex.fix.forEach((x, i) => L.push(chalk35.cyan(`     ${i + 1}. ${x}`)));
     } else {
       for (const s of f.signals) L.push(`     \u2022 ${s}`);
       if (f.mitigations?.length)
-        L.push(chalk34.gray(`     \u2713 mitigated: ${f.mitigations.join("; ")}`));
-      L.push(chalk34.cyan(`     \u2192 ${f.fix}`));
+        L.push(chalk35.gray(`     \u2713 mitigated: ${f.mitigations.join("; ")}`));
+      L.push(chalk35.cyan(`     \u2192 ${f.fix}`));
     }
     L.push("");
   }
   if (n === 0 && !res.incomplete) {
     L.push(
-      chalk34.gray("   No committed agent hooks, injectable workflows, or unpinned MCP servers.")
+      chalk35.gray("   No committed agent hooks, injectable workflows, or unpinned MCP servers.")
     );
     L.push("");
   }
   L.push(...reviewTerminal(res.findings));
-  for (const note of res.notes) L.push(chalk34.gray(`   note: ${note}`));
+  for (const note of res.notes) L.push(chalk35.gray(`   note: ${note}`));
   const hasHigh = shown.some(
     (f) => isAlert(f) && !f.suppressed && (f.severity === "critical" || f.severity === "high")
   );
   if (hasHigh && !ownedHint(res.source)) {
     L.push("");
     L.push(
-      chalk34.yellow(
+      chalk35.yellow(
         "   \u26A0\uFE0F  This looks like a live issue on a repo you may not own. Disclose it privately\n       to the maintainers; do not publish it. (node9 never weaponizes findings.)"
       )
     );
@@ -86802,7 +87151,7 @@ function makeProgress(target, quiet) {
   let frame = 0;
   let last = `scanning ${target}\u2026`;
   const timer = setInterval(() => {
-    process.stderr.write(`\r${chalk35.cyan(SPIN[frame++ % SPIN.length])} ${last}   `);
+    process.stderr.write(`\r${chalk36.cyan(SPIN[frame++ % SPIN.length])} ${last}   `);
   }, 80);
   return {
     onProgress: (p) => {
@@ -86865,236 +87214,13 @@ function registerScanRepoCommand(program2) {
       if (!telemetryDisabled()) {
         await sendScanRepoPing(buildScanRepoPing(res, target));
         if (!opts.json && !opts.markdown && process.stderr.isTTY) {
-          process.stderr.write(chalk35.dim(SCAN_REPO_TELEMETRY_NOTICE) + "\n");
+          process.stderr.write(chalk36.dim(SCAN_REPO_TELEMETRY_NOTICE) + "\n");
         }
       }
     }
   );
 }
 
-// src/cli/commands/egress.ts
-init_config();
-init_keyed_guard();
-init_dist();
-init_egress_config();
-init_egress_config();
-import chalk36 from "chalk";
-function guard(fn) {
-  try {
-    fn();
-    return true;
-  } catch (err2) {
-    console.error(chalk36.red(`
-  \u2717 ${err2.message}
-`));
-    process.exitCode = 1;
-    return false;
-  }
-}
-function mutate(action, change) {
-  if (!cliGuardPolicyWrite(action)) return false;
-  return guard(() => setEgress(change));
-}
-function addHost(list2, host2) {
-  if (!cliGuardPolicyWrite(`egress ${list2} ${host2}`)) return false;
-  return guard(() => addEgressHost(list2, host2));
-}
-function exempt2(address) {
-  if (!cliGuardPolicyWrite(`egress exempt ${address}`)) return false;
-  return guard(() => addSsrfExemption(address));
-}
-var INTERNAL_FIELDS = {
-  allowed: { ssrfStrict: false, allowPrivate: true },
-  listed: { ssrfStrict: false, allowPrivate: false },
-  blocked: { ssrfStrict: true, allowPrivate: false }
-};
-var INTERNAL_SAID = {
-  allowed: "reachable without listing them",
-  listed: "reachable only if they are on your allowlist",
-  blocked: "blocked"
-};
-function readInternalState(e) {
-  if (e.ssrfStrict === true) return "blocked";
-  return e.allowPrivate === false ? "listed" : "allowed";
-}
-function setInternal(value) {
-  const state = value.trim().toLowerCase();
-  if (!(state in INTERNAL_FIELDS)) {
-    console.error(
-      chalk36.red(`
-  \u2717 Expected "allowed", "listed" or "blocked", got "${value}".`) + chalk36.gray(
-        "\n    allowed  loopback, 10/172.16/192.168 and CGNAT are reachable (default)\n    listed   they are reachable only if you allowlist them\n    blocked  they are blocked at the floor\n"
-      )
-    );
-    process.exitCode = 1;
-    return;
-  }
-  if (!mutate(`egress internal ${state}`, INTERNAL_FIELDS[state])) return;
-  _resetConfigCache();
-  const effective = readInternalState(getConfig().policy.egress);
-  if (effective !== state) {
-    console.log(
-      chalk36.yellow(
-        `
-  \u26A0 Saved, but not in effect: your workspace sets internal addresses to ${effective.toUpperCase()} and that governs this machine.
-    Change it in the dashboard, Enforcement \u2192 Network.
-`
-      )
-    );
-    return;
-  }
-  const line = `
-  \u2713 Internal addresses: ${state} \u2014 loopback, the private ranges and CGNAT are ${INTERNAL_SAID[state]}.
-`;
-  console.log(state === "allowed" ? chalk36.yellow(line) : chalk36.green(line));
-}
-function showFloor(e, ssrfStrictSource) {
-  console.log(
-    chalk36.gray("\n  Protected addresses") + chalk36.gray(" \u2014 in shell commands and declared URLs")
-  );
-  console.log(
-    chalk36.gray(
-      "    always blocked: cloud metadata, link-local, multicast\n    no setting releases these, though `node9 pause` suspends all enforcement"
-    )
-  );
-  const state = readInternalState(e);
-  const by = ssrfStrictSource === "workspace" ? "workspace (app.node9.ai)" : ssrfStrictSource === "local" ? "this machine (config.json)" : "the shipped default";
-  const STATE_LABEL = {
-    allowed: "allowed",
-    listed: "allowlist only",
-    blocked: "blocked"
-  };
-  console.log(
-    `    Internal addresses:  ${state === "blocked" ? chalk36.green(STATE_LABEL[state]) : chalk36.yellow(STATE_LABEL[state])}` + chalk36.gray(`  loopback, 10/172.16/192.168 and CGNAT are ${INTERNAL_SAID[state]}`)
-  );
-  console.log(chalk36.gray(`    set by: ${by}`));
-  const exemptions = e.ssrfAllow ?? [];
-  console.log(chalk36.gray(`    Exemptions: ${exemptions.length ? exemptions.join(", ") : "none"}`));
-  console.log(
-    chalk36.gray(
-      "    Covered: shell commands, and tools that declare a URL (WebFetch, an MCP\n    fetch tool, browser navigate).\n    Not covered: an interpreter one-liner (node -e, python3 -c) hides its\n    destination inside a program and does not reach this gate.\n    CGNAT (100.64/10) is NOT in the always-blocked set: it is reachable\n    until Internal addresses is on, and an exemption can release it."
-    )
-  );
-}
-function showStatus() {
-  const cfg = getConfig();
-  const e = cfg.policy.egress;
-  const state = !e.enabled ? chalk36.red("OFF \u2014 your agent can reach any host, except the protected ones below") : e.mode === "block" ? chalk36.green("LOCKED (block) \u2014 unknown hosts are denied") : chalk36.yellow("WATCHING (review) \u2014 unknown hosts prompt you");
-  console.log(chalk36.cyan.bold("\n\u{1F310} Egress control"));
-  console.log("  State: " + state);
-  if (cfg.policySource === "workspace") {
-    console.log(
-      chalk36.gray("  Source: workspace config (app.node9.ai) \u2014 local egress settings are ignored")
-    );
-  }
-  console.log(
-    chalk36.gray(
-      `  ${DEFAULT_EGRESS_ALLOWLIST.length} common dev/LLM hosts are always allowed (github, npm, pypi, anthropic, \u2026).`
-    )
-  );
-  showFloor(e, cfg.ssrfStrictSource);
-  if (e.allow.length) console.log("\n  Your allow: " + e.allow.join(", "));
-  if (e.deny.length) console.log("  Your deny:  " + e.deny.join(", "));
-  if (!e.enabled) {
-    console.log(chalk36.gray("\n  Turn it on:  node9 egress watch   (prompt on unknown hosts)"));
-    console.log(chalk36.gray("               node9 egress lock    (hard-block unknown hosts)"));
-  }
-  console.log("");
-}
-function registerEgressCommand(program2) {
-  const egress = program2.command("egress").description("Control where your agent can send data (egress allowlist)");
-  egress.command("watch").description("Prompt before the agent reaches an unknown host (review mode)").action(() => {
-    if (!mutate("egress watch", { enabled: true, mode: "review" })) return;
-    console.log(chalk36.green("\n\u2713 Egress is now watched (review mode)."));
-    console.log(
-      chalk36.gray("  Routine hosts (LLM APIs, package registries, localhost) are allowed.")
-    );
-    console.log(
-      chalk36.gray("  An unknown host will prompt you \u2014 run `node9 egress lock` to hard-block.\n")
-    );
-  });
-  egress.command("lock").description("Block the agent from reaching unknown hosts (block mode)").action(() => {
-    if (!mutate("egress lock", { enabled: true, mode: "block" })) return;
-    console.log(chalk36.green("\n\u2713 Egress is now locked (block mode)."));
-    console.log(chalk36.gray("  Routine hosts are still allowed; unknown hosts are denied."));
-    console.log(chalk36.gray("  Allow a specific host with `node9 egress allow <host>`.\n"));
-  });
-  egress.command("allow <host>").description("Allow an extra host (glob, e.g. *.mycorp.com)").action((host2) => {
-    if (!addHost("allow", host2)) return;
-    console.log(chalk36.green(`
-\u2713 Allowed egress to ${host2}.
-`));
-  });
-  egress.command("deny <host>").description("Block an extra host (deny always wins)").action((host2) => {
-    if (!addHost("deny", host2)) return;
-    console.log(chalk36.green(`
-\u2713 Denied egress to ${host2}.
-`));
-  });
-  egress.command("off").description("Turn egress control off").action(() => {
-    if (!mutate("egress off", { enabled: false })) return;
-    console.log(
-      chalk36.yellow("\n\u2713 Egress control is off \u2014 the agent can reach any host again.\n")
-    );
-  });
-  egress.command("internal <allowed|listed|blocked>").description(
-    "How loopback, private ranges and CGNAT are treated: allowed (default), listed (must be on the allowlist), or blocked"
-  ).action((value) => setInternal(value));
-  egress.command("strict <on|off>").description("Deprecated alias for `egress internal blocked|allowed`").action((value) => {
-    const v = value.trim().toLowerCase();
-    if (v !== "on" && v !== "off") {
-      console.error(chalk36.red(`
-  \u2717 Expected "on" or "off", got "${value}".
-`));
-      process.exitCode = 1;
-      return;
-    }
-    const state = v === "on" ? "blocked" : getConfig().policy.egress.allowPrivate === false ? "listed" : "allowed";
-    console.log(chalk36.gray(`
-  (\`egress strict ${v}\` is now \`egress internal ${state}\`)`));
-    setInternal(state);
-  });
-  egress.command("exempt <address>").description("Let an address or a CIDR range through the floor (e.g. 100.64.0.0/10)").action((address) => {
-    const a = normalizeEgressHost(address);
-    const slash = a.indexOf("/");
-    const base2 = slash === -1 ? a : a.slice(0, slash);
-    const prefixText = slash === -1 ? null : a.slice(slash + 1);
-    if (!normalizeIpLiteral(base2) || prefixText !== null && !/^\d{1,3}$/.test(prefixText)) {
-      console.error(
-        chalk36.red(`
-  \u2717 "${address}" is not an address or a range.`) + chalk36.gray(
-          "\n    Exemptions are matched as an address (10.0.0.5) or a CIDR\n    range (100.64.0.0/10), never a name.\n"
-        )
-      );
-      process.exitCode = 1;
-      return;
-    }
-    const m = classifySsrf(base2);
-    if (m && !m.overridable) {
-      console.error(
-        chalk36.red(`
-  \u2717 ${a} cannot be exempted.`) + chalk36.gray(
-          `
-    ${slash === -1 ? "That address is" : "That range covers only"} protected addresses (${m.tier}), which no setting releases.
-`
-        )
-      );
-      process.exitCode = 1;
-      return;
-    }
-    if (!exempt2(a)) return;
-    console.log(chalk36.green(`
-  \u2713 ${a} is exempt from the floor.`));
-    if (!m)
-      console.log(
-        chalk36.gray("    Note: this address is not on the floor anyway \u2014 nothing changes.\n")
-      );
-    else console.log("");
-  });
-  egress.command("status").description("Show the current egress state").action(showStatus);
-  egress.action(showStatus);
-}
-
 // src/cli/commands/checks.ts
 init_dist();
 init_config();
@@ -87135,7 +87261,9 @@ function renderChecks(report) {
   const lines = [];
   const where = report.policySource === "workspace" ? "workspace (app.node9.ai)" : "local (~/.node9/config.json)";
   lines.push("");
-  lines.push(`${chalk37.cyan.bold("node9 checks")}   policy: ${where}   mode: ${report.mode}`);
+  lines.push(
+    `${chalk37.cyan.bold("node9 checks")}   policy: ${where}   mode: ${levelOf(report.mode)}`
+  );
   lines.push("");
   const row = (c) => {
     const value = (VALUE_COLOR[c.value] ?? chalk37.white)(c.value.padEnd(7));