@node9/proxy 1.63.0 → 1.64.0

package/dist/cli.mjs

@@ -347,6 +347,7 @@ var init_config_schema = __esm({
         // nudge-only (default), and the scan cadence in minutes.
         mcpAutoWrap: z.boolean().optional(),
         mcpReconcileIntervalMinutes: z.number().positive().optional(),
+        mcpStaleAfterDays: z.number().min(0).optional(),
         cloudSyncIntervalHours: z.number().positive().optional(),
         // Seconds-granular override for the cloud policy sync cadence. Wins over
         // cloudSyncIntervalHours when set. Lets you opt into fast apply (e.g. 20)
@@ -3981,6 +3982,7 @@ var init_dist = __esm({
       name: "redis",
       description: "Protects Redis instances from destructive AI operations",
       aliases: [],
+      _scopeNote: "Every rule requires Redis to actually be involved: a client in the command (redis-cli / valkey-cli, in either order \u2014 `redis-cli FLUSHALL` and `echo FLUSHALL | redis-cli` are both real), OR the command field holding the bare keyword, which is what the MCP redis_command tool sends ({ command: 'FLUSHALL', args: [] }). Without the client requirement these rules matched the WORD anywhere \u2014 including prose in a heredoc writing a file \u2014 which produced two observed false positives: a test fixture describing the shield, and a commit message naming the rule. Every other builtin shield already scopes this way (aws s3, docker system prune, kubectl delete, gh repo delete). See redis-scope.spec.ts.",
       smartRules: [
         {
           name: "shield:redis:block-flushall",
@@ -3989,7 +3991,7 @@ var init_dist = __esm({
             {
               field: "command",
               op: "matches",
-              value: "\\bFLUSHALL\\b",
+              value: "(redis|valkey)-cli.*\\bFLUSHALL\\b|\\bFLUSHALL\\b.*(redis|valkey)-cli|^ ?FLUSHALL\\b|\\.flushall\\s*\\(",
               flags: "i"
             }
           ],
@@ -4003,7 +4005,7 @@ var init_dist = __esm({
             {
               field: "command",
               op: "matches",
-              value: "\\bFLUSHDB\\b",
+              value: "(redis|valkey)-cli.*\\bFLUSHDB\\b|\\bFLUSHDB\\b.*(redis|valkey)-cli|^ ?FLUSHDB\\b|\\.flushdb\\s*\\(",
               flags: "i"
             }
           ],
@@ -4017,7 +4019,7 @@ var init_dist = __esm({
             {
               field: "command",
               op: "matches",
-              value: "\\bCONFIG\\s+RESETSTAT\\b",
+              value: "(redis|valkey)-cli.*CONFIG\\s+RESETSTAT|^ ?CONFIG\\s+RESETSTAT",
               flags: "i"
             }
           ],
@@ -4031,7 +4033,7 @@ var init_dist = __esm({
             {
               field: "command",
               op: "matches",
-              value: "\\bCONFIG\\s+SET\\b",
+              value: "(redis|valkey)-cli.*\\bCONFIG\\s+SET\\b|\\bCONFIG\\s+SET\\b.*(redis|valkey)-cli|^ ?CONFIG\\s+SET\\b",
               flags: "i"
             }
           ],
@@ -4045,7 +4047,7 @@ var init_dist = __esm({
             {
               field: "command",
               op: "matches",
-              value: "\\bDEL\\b.*[*?\\[]|redis-cli.*--scan.*\\|.*xargs.*del",
+              value: "(redis|valkey)-cli.*\\bDEL\\b.*[*?\\[]|^ ?DEL\\b.*[*?\\[]|-cli.*--scan.*xargs.*del",
               flags: "i"
             }
           ],
@@ -4615,6 +4617,48 @@ function getActiveEnvironment(config) {
   const env = config.settings.environment || process.env.NODE_ENV || "development";
   return config.environments[env] ?? null;
 }
+function readRulesCacheResilient(cacheFile) {
+  let existed = false;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    let content;
+    try {
+      content = fs4.readFileSync(cacheFile, "utf-8");
+      existed = true;
+    } catch (err2) {
+      if (err2.code === "ENOENT") return {};
+      continue;
+    }
+    try {
+      return JSON.parse(content);
+    } catch {
+    }
+  }
+  if (existed) {
+    const backup = path4.join(path4.dirname(cacheFile), "rules-cache.last-good.json");
+    if (backup !== cacheFile) {
+      try {
+        const raw = JSON.parse(fs4.readFileSync(backup, "utf-8"));
+        logCacheReadIssue(cacheFile, "RULES_CACHE_CORRUPT_USED_BACKUP");
+        return raw;
+      } catch {
+      }
+    }
+    logCacheReadIssue(cacheFile, "RULES_CACHE_UNREADABLE");
+  }
+  return {};
+}
+function logCacheReadIssue(cacheFile, kind) {
+  if (cacheReadFailureLogged) return;
+  cacheReadFailureLogged = true;
+  try {
+    fs4.appendFileSync(
+      path4.join(os4.homedir(), ".node9", "hook-debug.log"),
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] ${kind} ${cacheFile}
+`
+    );
+  } catch {
+  }
+}
 function getConfig(cwd) {
   if (!cwd && cachedConfig) return cachedConfig;
   const globalPath = path4.join(os4.homedir(), ".node9", "config.json");
@@ -4682,6 +4726,7 @@ function getConfig(cwd) {
     if (s.mcpAutoWrap !== void 0) mergedSettings.mcpAutoWrap = s.mcpAutoWrap === true;
     if (s.mcpReconcileIntervalMinutes !== void 0)
       mergedSettings.mcpReconcileIntervalMinutes = s.mcpReconcileIntervalMinutes;
+    if (s.mcpStaleAfterDays !== void 0) mergedSettings.mcpStaleAfterDays = s.mcpStaleAfterDays;
     if (s.hud !== void 0) mergedSettings.hud = { ...mergedSettings.hud, ...s.hud };
     if (p.sandboxPaths) mergedPolicy.sandboxPaths.push(...p.sandboxPaths);
     if (p.ignoredTools) mergedPolicy.ignoredTools.push(...p.ignoredTools);
@@ -4691,12 +4736,13 @@ function getConfig(cwd) {
     if (p.smartRules) {
       const defaultBlocks = mergedPolicy.smartRules.filter((r) => r.verdict === "block");
       const defaultNonBlocks = mergedPolicy.smartRules.filter((r) => r.verdict !== "block");
-      const userRuleNames = new Set(p.smartRules.filter((r) => r.name).map((r) => r.name));
+      const localRules = p.smartRules.map(({ pinned: _pinned, ...r }) => r);
+      const userRuleNames = new Set(localRules.filter((r) => r.name).map((r) => r.name));
       const filteredBlocks = defaultBlocks.filter((r) => !r.name || !userRuleNames.has(r.name));
       const filteredNonBlocks = defaultNonBlocks.filter(
         (r) => !r.name || !userRuleNames.has(r.name)
       );
-      mergedPolicy.smartRules = [...filteredBlocks, ...p.smartRules, ...filteredNonBlocks];
+      mergedPolicy.smartRules = [...filteredBlocks, ...localRules, ...filteredNonBlocks];
     }
     if (p.snapshot) {
       const s2 = p.snapshot;
@@ -4761,10 +4807,12 @@ function getConfig(cwd) {
   applyLayer(globalConfig);
   applyLayer(projectConfig);
   let cloudManagedShields = [];
+  let modeCloudControlled = false;
+  let modeCloudStaged = false;
   {
     const cacheFile = path4.join(os4.homedir(), ".node9", "rules-cache.json");
     try {
-      const raw = JSON.parse(fs4.readFileSync(cacheFile, "utf-8"));
+      const raw = readRulesCacheResilient(cacheFile);
       if (Array.isArray(raw.rules) && raw.rules.length > 0) {
         applyLayer({ policy: { smartRules: raw.rules } });
       }
@@ -4781,6 +4829,9 @@ function getConfig(cwd) {
             locked.includes("mode")
           );
         }
+        if (typeof mc.mode === "string" || locked.includes("mode")) {
+          modeCloudControlled = true;
+        }
         if (mc.egress && typeof mc.egress === "object") {
           const hosts = (v) => Array.isArray(v) ? v.filter((h) => typeof h === "string") : void 0;
           mergedPolicy.egress = applyManagedEgress(
@@ -4879,19 +4930,28 @@ function getConfig(cwd) {
       }
       if (raw.shadowMode === true) {
         mergedSettings.mode = "observe";
+        modeCloudStaged = true;
       }
     } catch {
     }
   }
   const shieldOverrides = readShieldOverrides();
   const activeShieldNames = [.../* @__PURE__ */ new Set([...readActiveShields(), ...cloudManagedShields])];
+  const cloudManagedSet = new Set(cloudManagedShields);
   for (const shieldName of activeShieldNames) {
-    const shield = getShield(shieldName);
+    const isCloudMandated = cloudManagedSet.has(shieldName);
+    const shield = isCloudMandated ? BUILTIN_SHIELDS[shieldName] : getShield(shieldName);
     if (!shield) continue;
     const existingRuleNames = new Set(mergedPolicy.smartRules.map((r) => r.name));
-    const ruleOverrides = shieldOverrides[shieldName] ?? {};
+    const ruleOverrides = isCloudMandated ? {} : shieldOverrides[shieldName] ?? {};
     for (const rule of shield.smartRules) {
-      if (!existingRuleNames.has(rule.name)) {
+      const collides = rule.name ? existingRuleNames.has(rule.name) : false;
+      if (isCloudMandated) {
+        if (collides) {
+          mergedPolicy.smartRules = mergedPolicy.smartRules.filter((r) => r.name !== rule.name);
+        }
+        mergedPolicy.smartRules.push({ ...rule, pinned: true });
+      } else if (!collides) {
         const overrideVerdict = rule.name ? ruleOverrides[rule.name] : void 0;
         mergedPolicy.smartRules.push(
           overrideVerdict !== void 0 ? { ...rule, verdict: overrideVerdict } : rule
@@ -4907,7 +4967,27 @@ function getConfig(cwd) {
   for (const rule of ADVISORY_SMART_RULES) {
     if (!existingAdvisoryNames.has(rule.name)) mergedPolicy.smartRules.push(rule);
   }
-  if (process.env.NODE9_MODE) mergedSettings.mode = process.env.NODE9_MODE;
+  const envMode = process.env.NODE9_MODE;
+  if (envMode && !modeCloudControlled && ["observe", "audit", "standard", "strict"].includes(envMode)) {
+    mergedSettings.mode = envMode;
+  }
+  if (cloudManagedShields.length > 0 && !modeCloudControlled && !modeCloudStaged && (mergedSettings.mode === "observe" || mergedSettings.mode === "audit")) {
+    mergedSettings.mode = "standard";
+  }
+  const managedFloorActive = cloudManagedShields.length > 0 || modeCloudControlled && mergedSettings.mode === "strict";
+  if (modeCloudControlled && mergedSettings.mode === "strict") {
+    for (const name of Object.keys(mergedEnvironments)) {
+      if (mergedEnvironments[name]?.requireApproval === false) {
+        const cleaned = { ...mergedEnvironments[name] };
+        delete cleaned.requireApproval;
+        mergedEnvironments[name] = cleaned;
+      }
+    }
+  }
+  if (managedFloorActive) {
+    mergedPolicy.ignoredTools = [...DEFAULT_CONFIG.policy.ignoredTools];
+    mergedPolicy.sandboxPaths = [...DEFAULT_CONFIG.policy.sandboxPaths];
+  }
   mergedPolicy.sandboxPaths = [...new Set(mergedPolicy.sandboxPaths)];
   mergedPolicy.dangerousWords = [...new Set(mergedPolicy.dangerousWords)];
   mergedPolicy.ignoredTools = [...new Set(mergedPolicy.ignoredTools)];
@@ -4976,7 +5056,7 @@ ${error.replace("Invalid config:\n", "")}
   }
   return sanitized;
 }
-var DANGEROUS_WORDS, DEFAULT_CONFIG, ADVISORY_SMART_RULES, cachedConfig;
+var DANGEROUS_WORDS, DEFAULT_CONFIG, ADVISORY_SMART_RULES, cachedConfig, cacheReadFailureLogged;
 var init_config = __esm({
   "src/config/index.ts"() {
     "use strict";
@@ -4985,6 +5065,7 @@ var init_config = __esm({
     init_managed();
     init_build();
     init_trusted_hosts();
+    init_dist();
     DANGEROUS_WORDS = [
       "mkfs",
       // formats/wipes a filesystem partition
@@ -5262,6 +5343,7 @@ var init_config = __esm({
       }
     ];
     cachedConfig = null;
+    cacheReadFailureLogged = false;
   }
 });
 
@@ -5982,6 +6064,18 @@ async function isDaemonReachable(timeoutMs = 500) {
     return false;
   }
 }
+async function daemonHasInteractiveApprover(timeoutMs = 400) {
+  try {
+    const res = await fetch(`http://${DAEMON_HOST}:${DAEMON_PORT}/approver`, {
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!res.ok) return false;
+    const body = await res.json();
+    return body.interactive === true;
+  } catch {
+    return false;
+  }
+}
 async function registerDaemonEntry(toolName, args, meta, riskMetadata, activityId, cwd, recoveryCommand, skipBackgroundAuth, viewOnly, localSmartRuleMatched, socketActivitySent) {
   const base = `http://${DAEMON_HOST}:${DAEMON_PORT}`;
   const ctrl = new AbortController();
@@ -6862,6 +6956,12 @@ function isNetworkTool(toolName, args) {
 function notifyActivity(data) {
   return notifyActivitySocket(data);
 }
+async function hasReachableHumanApprover(opts) {
+  const hasDisplay = !!(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+  const nativeReachable = !opts.calledFromDaemon && opts.approvers.native !== false && hasDisplay;
+  if (nativeReachable) return true;
+  return opts.approvers.terminal !== false && await daemonHasInteractiveApprover();
+}
 async function authorizeHeadless(toolName, args, meta, options) {
   if (!options?.calledFromDaemon) {
     const actId = randomUUID();
@@ -7176,6 +7276,35 @@ async function _authorizeHeadlessCore(toolName, args, metaArg, options) {
       return { approved: true, checkedBy: "local-policy" };
     }
     if (policyResult.decision === "block") {
+      const daemonUp = isDaemonRunning();
+      let humanApproverReachable = false;
+      if (!policyResult.dependsOnStatePredicates?.length && daemonUp && !isTestEnv2) {
+        humanApproverReachable = await hasReachableHumanApprover({
+          approvers,
+          calledFromDaemon: options?.calledFromDaemon
+        });
+      }
+      const mayDowngrade = daemonUp && !isTestEnv2 && humanApproverReachable;
+      const hardBlock = () => {
+        if (!isManual)
+          appendLocalAudit(
+            toolName,
+            args,
+            "deny",
+            "smart-rule-block",
+            { ...meta, ruleName: policyResult.ruleName },
+            hashAuditArgs
+          );
+        return {
+          approved: false,
+          reason: policyResult.reason ?? "Action explicitly blocked by Smart Policy.",
+          blockedBy: "local-config",
+          blockedByLabel: policyResult.blockedByLabel,
+          ruleHit: policyResult.ruleName,
+          ...policyResult.recoveryCommand && { recoveryCommand: policyResult.recoveryCommand },
+          ...policyResult.ruleDescription && { ruleDescription: policyResult.ruleDescription }
+        };
+      };
       if (policyResult.dependsOnStatePredicates?.length) {
         const stateResults = await checkStatePredicates(policyResult.dependsOnStatePredicates);
         const predicatesMet = stateResults !== null && policyResult.dependsOnStatePredicates.every((p) => stateResults[p] === true);
@@ -7192,7 +7321,7 @@ async function _authorizeHeadlessCore(toolName, args, metaArg, options) {
         if (predicatesMet && policyResult.recoveryCommand) {
           statefulRecoveryCommand = policyResult.recoveryCommand;
         }
-      } else if (isDaemonRunning() && !isTestEnv2) {
+      } else if (mayDowngrade) {
         if (!isManual)
           appendLocalAudit(
             toolName,
@@ -7214,36 +7343,13 @@ async function _authorizeHeadlessCore(toolName, args, metaArg, options) {
           };
         }
       } else {
-        if (!isManual)
-          appendLocalAudit(
-            toolName,
-            args,
-            "deny",
-            "smart-rule-block",
-            // Include policyResult.ruleName so the [2] Report SHIELDS
-            // panel can attribute this block to its specific shield
-            // (e.g. `shield:project-jail:block-read-ssh`) via the
-            // rule→shield map. checkedBy stays as the generic
-            // `smart-rule-block` for backward compat with existing
-            // log readers.
-            { ...meta, ruleName: policyResult.ruleName },
-            hashAuditArgs
-          );
-        return {
-          approved: false,
-          reason: policyResult.reason ?? "Action explicitly blocked by Smart Policy.",
-          blockedBy: "local-config",
-          blockedByLabel: policyResult.blockedByLabel,
-          ruleHit: policyResult.ruleName,
-          ...policyResult.recoveryCommand && { recoveryCommand: policyResult.recoveryCommand },
-          ...policyResult.ruleDescription && { ruleDescription: policyResult.ruleDescription }
-        };
+        return hardBlock();
       }
     }
     explainableLabel = policyResult.blockedByLabel || "Local Config";
     policyMatchedField = policyResult.matchedField;
     policyMatchedWord = policyResult.matchedWord;
-    if (policyResult.ruleName) localSmartRuleMatched = true;
+    if (policyResult.ruleName || policyResult.tier === 7) localSmartRuleMatched = true;
     if (policyResult.ruleDescription) policyRuleDescription = policyResult.ruleDescription;
     else if (policyResult.reason) policyRuleDescription = policyResult.reason;
     riskMetadata = computeRiskMetadata(
@@ -7255,7 +7361,7 @@ async function _authorizeHeadlessCore(toolName, args, metaArg, options) {
       policyResult.ruleName
     );
     if (policyRuleDescription) riskMetadata.ruleDescription = policyRuleDescription.slice(0, 200);
-    const persistent = policyResult.ruleName ? null : getPersistentDecision(toolName);
+    const persistent = policyResult.ruleName || policyResult.tier === 7 ? null : getPersistentDecision(toolName);
     if (persistent === "allow" && !appPermReview) {
       if (!isManual) appendLocalAudit(toolName, args, "allow", "persistent", meta, hashAuditArgs);
       return { approved: true, checkedBy: "persistent" };
@@ -15924,6 +16030,9 @@ data: ${JSON.stringify(data)}
     }
   });
 }
+function hasInteractiveClient() {
+  return [...sseClients].some((c) => c.capabilities.includes("input"));
+}
 function broadcastForensic(finding) {
   const severity = CRITICAL_FORENSIC_CATEGORIES.has(finding.type) ? "critical" : "warning";
   const event = {
@@ -17154,18 +17263,27 @@ var init_score = __esm({
 
 // src/posture/headline.ts
 function worstFinding(findings) {
-  return [...findings].sort((a, b) => SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity])[0];
+  const cmp = (x, y) => x < y ? -1 : x > y ? 1 : 0;
+  return [...findings].sort(
+    (a, b) => SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity] || cmp(a.category, b.category) || cmp(a.title, b.title)
+  )[0];
+}
+function actionFromFinding(f) {
+  if (!f?.fix) return null;
+  const fix = f.fix.replace(/^fix it now:\s*/i, "");
+  const where = f.detail.length === 0 ? "" : f.detail.length === 1 ? ` \u2014 found: ${f.detail[0]}` : ` \u2014 found: ${f.detail[0]} and ${f.detail.length - 1} more`;
+  return fix + where;
 }
 function deriveHeadline(allFindings) {
   const findings = allFindings.filter(
     (f) => f.coverage?.state !== "covered" && f.coverage?.state !== "cant-fix"
   );
   if (findings.length === 0 || findings.every((f) => f.severity === "advisory")) return null;
-  const has = (category) => findings.some((f) => f.category === category);
-  const secrets = has("Secrets");
-  const egressOpen = has("Egress");
-  const noIsolation = has("Isolation");
-  const gateWeak = has("Approval gate");
+  const has2 = (category) => findings.some((f) => f.category === category);
+  const secrets = has2("Secrets");
+  const egressOpen = has2("Egress");
+  const noIsolation = has2("Isolation");
+  const gateWeak = has2("Approval gate");
   const notWired = findings.some((f) => f.category === "Coverage" && f.severity === "critical");
   const observeOnly = findings.some((f) => f.category === "Coverage" && f.severity === "high");
   let risk;
@@ -17188,13 +17306,16 @@ function deriveHeadline(allFindings) {
   } else if (observeOnly) {
     action = "Switch node9 to enforcing mode \u2014 right now it is only watching, not blocking.";
   } else if (egressOpen) {
-    action = "lock egress to an allowlist (node9 can enforce it) \u2014 it closes the exit the exfiltration needs.";
+    const egressFix = actionFromFinding(
+      worstFinding(findings.filter((f) => f.category === "Egress"))
+    );
+    action = egressFix ? `${egressFix} Closing the exit breaks the exfiltration chain.` : "lock egress to an allowlist (node9 can enforce it) \u2014 it closes the exit the exfiltration needs.";
   } else if (secrets) {
-    action = "node9 can block reads of sensitive paths (~/.ssh, ~/.aws) in-path.";
+    action = actionFromFinding(worstFinding(findings.filter((f) => f.category === "Secrets"))) ?? "node9 can block reads of sensitive credential files in-path (`node9 shield enable project-jail`).";
   } else if (gateWeak) {
-    action = "node9 can enforce destructive-command blocking in-path.";
+    action = actionFromFinding(worstFinding(findings.filter((f) => f.category === "Approval gate"))) ?? "node9 can enforce destructive-command blocking in-path (`node9 shield enable bash-safe`).";
   } else {
-    action = worstFinding(findings)?.fix ?? "Review the findings below.";
+    action = actionFromFinding(worstFinding(findings)) ?? "Review the findings below.";
   }
   return { risk, action };
 }
@@ -17733,6 +17854,21 @@ function inventoryMcp(home = os32.homedir()) {
   }
   return out;
 }
+function inventoryServerKeys(inv) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const e of inv) {
+    if (e.state === "gatewayed") {
+      const i = e.args.indexOf("--upstream");
+      if (i >= 0 && e.args[i + 1]) {
+        keys.add(getServerKey(e.args[i + 1]));
+      }
+    } else if (e.state === "ungoverned") {
+      const cmd = [e.command, ...e.args].map(quoteArg).join(" ");
+      keys.add(getServerKey(cmd));
+    }
+  }
+  return keys;
+}
 function writeMcpEntry(mcpFile, format, name, entry) {
   const key = format === "toml" ? "mcp_servers" : "mcpServers";
   let root = {};
@@ -17756,6 +17892,7 @@ var init_mcp_wrap = __esm({
     "use strict";
     init_agent_wiring();
     init_mcp_cmd();
+    init_mcp_pin();
     init_mcp_cmd();
   }
 });
@@ -18187,9 +18324,12 @@ function extractManagedConfig(body) {
   return out.mode !== void 0 || out.egress !== void 0 || out.dlp !== void 0 || out.approvers !== void 0 || out.reviewChannel !== void 0 || out.approvalTimeoutMs !== void 0 || out.injectionScan !== void 0 || out.loopDetection !== void 0 || out.skillPinning !== void 0 || out.jailPaths !== void 0 || out.trustedHosts !== void 0 || out.appPermissions !== void 0 ? out : void 0;
 }
 function writeCache2(cache) {
-  const dir = path35.dirname(rulesCacheFile());
-  if (!fs36.existsSync(dir)) fs36.mkdirSync(dir, { recursive: true });
-  fs36.writeFileSync(rulesCacheFile(), JSON.stringify(cache, null, 2) + "\n", "utf-8");
+  const data = JSON.stringify(cache, null, 2) + "\n";
+  atomicWriteSync2(rulesCacheFile(), data, "utf-8");
+  try {
+    atomicWriteSync2(rulesCacheBackupFile(), data, "utf-8");
+  } catch {
+  }
 }
 async function syncOnce() {
   const creds = readCredentials();
@@ -18483,7 +18623,7 @@ function startForensicBroadcast() {
   const recurring = setInterval(() => void tick(), FORENSIC_BROADCAST_INTERVAL_MS);
   recurring.unref();
 }
-var FINDING_TO_SIGNAL3, rulesCacheFile, DEFAULT_API_URL2, DEFAULT_INTERVAL_HOURS, MIN_INTERVAL_SECONDS, MAX_INTERVAL_SECONDS, syncHealthFile, STALE_MIN_MS, STALE_MAX_MS, STALE_FACTOR, FORENSIC_BROADCAST_INTERVAL_MS, FORENSIC_INITIAL_DELAY_MS, forensicBroadcastOffsets;
+var FINDING_TO_SIGNAL3, rulesCacheFile, rulesCacheBackupFile, DEFAULT_API_URL2, DEFAULT_INTERVAL_HOURS, MIN_INTERVAL_SECONDS, MAX_INTERVAL_SECONDS, syncHealthFile, STALE_MIN_MS, STALE_MAX_MS, STALE_FACTOR, FORENSIC_BROADCAST_INTERVAL_MS, FORENSIC_INITIAL_DELAY_MS, forensicBroadcastOffsets;
 var init_sync = __esm({
   "src/daemon/sync.ts"() {
     "use strict";
@@ -18493,6 +18633,7 @@ var init_sync = __esm({
     init_ship();
     init_build2();
     init_mcp_tools();
+    init_state2();
     init_mcp_status();
     init_ship2();
     init_shields();
@@ -18513,6 +18654,7 @@ var init_sync = __esm({
       "long-output-redacted": "longOutputRedactions"
     };
     rulesCacheFile = () => path35.join(os33.homedir(), ".node9", "rules-cache.json");
+    rulesCacheBackupFile = () => path35.join(os33.homedir(), ".node9", "rules-cache.last-good.json");
     DEFAULT_API_URL2 = "https://api.node9.ai/api/v1/intercept/policies/sync";
     DEFAULT_INTERVAL_HOURS = 5;
     MIN_INTERVAL_SECONDS = 15;
@@ -18754,6 +18896,53 @@ var init_audit_shipper = __esm({
   }
 });
 
+// src/audit/decision.ts
+function classifyDecision(a, b) {
+  const isRow = !!a && typeof a === "object";
+  const decision = isRow ? a.decision : a;
+  const attribution = isRow ? a.checkedBy ?? a.source : b;
+  const raw = typeof decision === "string" ? decision : String(decision ?? "");
+  const src = typeof attribution === "string" ? attribution.toLowerCase() : "";
+  const d = raw.toLowerCase();
+  if (src && has(src, "observe-mode")) {
+    return { outcome: "observe", label: "Would block", raw };
+  }
+  if (d === "dlp") return { outcome: "info", label: "Finding", raw };
+  if (d === "mcp-discovered") return { outcome: "info", label: "Info", raw };
+  if (d === "allow" || d === "allowed") {
+    if (src === "post-hook") return { outcome: "allow", label: "Ran", raw };
+    if (HUMAN_SOURCES.has(src)) {
+      return { outcome: "allow", label: "Approved", raw };
+    }
+    return { outcome: "allow", label: "Auto-allowed", raw };
+  }
+  if (d === "deny" || d === "auto-deny" || d === "block") {
+    if (TIMEOUT_SOURCES.has(src)) {
+      return { outcome: "deny", label: "Timed out", raw };
+    }
+    if (HUMAN_SOURCES.has(src)) {
+      return { outcome: "deny", label: "Denied", raw };
+    }
+    return { outcome: "deny", label: "Blocked", raw };
+  }
+  if (d === "review" || d === "pending") {
+    return { outcome: "info", label: "Pending", raw };
+  }
+  return { outcome: "unknown", label: raw ? `? ${raw}` : "? (none)", raw };
+}
+function decisionTag(view) {
+  return `[${view.label}]`.padEnd(14);
+}
+var HUMAN_SOURCES, TIMEOUT_SOURCES, has;
+var init_decision = __esm({
+  "src/audit/decision.ts"() {
+    "use strict";
+    HUMAN_SOURCES = /* @__PURE__ */ new Set(["daemon", "cloud", "local-decision", "inline-review-approved"]);
+    TIMEOUT_SOURCES = /* @__PURE__ */ new Set(["timeout"]);
+    has = (s, needle) => s.includes(needle);
+  }
+});
+
 // src/daemon/dlp-scanner.ts
 import fs38 from "fs";
 import path37 from "path";
@@ -18993,6 +19182,7 @@ function runMcpReconcile() {
   }
   const baseline = loadBaseline();
   const creds = getCredentials();
+  reconcileStale(inv, creds);
   const fresh = inv.filter((e) => e.state === "ungoverned" && !baseline.has(idKey(e)));
   if (fresh.length === 0) return;
   const wrappedAgents = /* @__PURE__ */ new Set();
@@ -19032,6 +19222,77 @@ function runMcpReconcile() {
   }
   saveBaseline(baseline);
 }
+function reconcileStale(inv, creds) {
+  let pins;
+  try {
+    pins = readMcpPins();
+  } catch {
+    return;
+  }
+  const serverKeys = Object.keys(pins.servers);
+  if (serverKeys.length === 0) return;
+  const liveKeys = inventoryServerKeys(inv);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let dirty = false;
+  for (const sk of serverKeys) {
+    const pin = pins.servers[sk];
+    if (liveKeys.has(sk)) {
+      if (pin.lastSeen !== now) {
+        pin.lastSeen = now;
+        dirty = true;
+      }
+    } else if (!pin.lastSeen) {
+      pin.lastSeen = pin.pinnedAt;
+      dirty = true;
+    }
+  }
+  const staleDays = getConfig().settings.mcpStaleAfterDays ?? DEFAULT_STALE_DAYS;
+  if (staleDays > 0 && liveKeys.size > 0) {
+    const staleMs = staleDays * 864e5;
+    for (const sk of serverKeys) {
+      const pin = pins.servers[sk];
+      if (liveKeys.has(sk)) continue;
+      const age = Date.now() - Date.parse(pin.lastSeen ?? pin.pinnedAt);
+      if (age >= staleMs) {
+        appendToLog(HOOK_DEBUG_LOG, {
+          event: "mcp-pin-auto-removed",
+          serverKey: sk,
+          label: pin.label,
+          lastSeen: pin.lastSeen,
+          pinnedAt: pin.pinnedAt
+        });
+        if (creds) {
+          try {
+            void auditLocalAllow(
+              `mcp-server:${sk}`,
+              {
+                serverKey: sk,
+                label: pin.label,
+                lastSeen: pin.lastSeen,
+                reason: "stale",
+                staleDays
+              },
+              "mcp-server-removed",
+              creds,
+              { mcpServer: pin.label },
+              void 0,
+              false
+            );
+          } catch {
+          }
+        }
+        delete pins.servers[sk];
+        dirty = true;
+      }
+    }
+  }
+  if (dirty) {
+    try {
+      writeMcpPins(pins);
+    } catch {
+    }
+  }
+}
 function startMcpReconciler() {
   setImmediate(() => {
     try {
@@ -19053,7 +19314,7 @@ function startMcpReconciler() {
   };
   schedule();
 }
-var BASELINE_FILE2, BASELINE_CAP, DEFAULT_INTERVAL_MIN;
+var BASELINE_FILE2, BASELINE_CAP, DEFAULT_INTERVAL_MIN, DEFAULT_STALE_DAYS;
 var init_mcp_reconciler = __esm({
   "src/daemon/mcp-reconciler.ts"() {
     "use strict";
@@ -19062,9 +19323,11 @@ var init_mcp_reconciler = __esm({
     init_config();
     init_cloud();
     init_audit();
+    init_mcp_pin();
     BASELINE_FILE2 = path38.join(os36.homedir(), ".node9", "mcp-baseline.json");
     BASELINE_CAP = 500;
     DEFAULT_INTERVAL_MIN = 60;
+    DEFAULT_STALE_DAYS = 7;
   }
 });
 
@@ -19139,20 +19402,87 @@ var init_hook_heal = __esm({
 import fs40 from "fs";
 import path39 from "path";
 import os37 from "os";
+function capStartupLog(file) {
+  try {
+    if (fs40.statSync(file).size > MAX_STARTUP_LOG_BYTES) fs40.truncateSync(file);
+  } catch {
+  }
+}
 function openStartupLogFd() {
   try {
     const file = DAEMON_STARTUP_LOG();
     const dir = path39.dirname(file);
     if (!fs40.existsSync(dir)) fs40.mkdirSync(dir, { recursive: true });
-    try {
-      if (fs40.statSync(file).size > MAX_STARTUP_LOG_BYTES) fs40.truncateSync(file);
-    } catch {
-    }
+    capStartupLog(file);
     return fs40.openSync(file, "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 file = DAEMON_STARTUP_STATE();
+    const dir = path39.dirname(file);
+    if (!fs40.existsSync(dir)) fs40.mkdirSync(dir, { 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 = `${file}.${process.pid}.tmp`;
+    try {
+      fs40.writeFileSync(tmp, JSON.stringify(state), "utf-8");
+      fs40.renameSync(tmp, file);
+    } catch (err2) {
+      try {
+        fs40.unlinkSync(tmp);
+      } catch {
+      }
+      throw err2;
+    }
+  } catch {
+  }
+}
+function readStartupState() {
+  try {
+    const raw = fs40.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 file = DAEMON_STARTUP_LOG();
@@ -19164,12 +19494,15 @@ function logDaemonStartup(kind, detail) {
   } catch {
   }
 }
-var DAEMON_STARTUP_LOG, MAX_STARTUP_LOG_BYTES;
+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(os37.homedir(), ".node9", "daemon-startup.log");
     MAX_STARTUP_LOG_BYTES = 256 * 1024;
+    DAEMON_STARTUP_STATE = () => path39.join(os37.homedir(), ".node9", "daemon-startup-state.json");
+    MAX_DETAIL = 200;
+    STARTING_GRACE_MS = 90 * 1e3;
   }
 });
 
@@ -19181,6 +19514,76 @@ import os38 from "os";
 import { randomUUID as randomUUID4 } from "crypto";
 import { spawnSync } from "child_process";
 import chalk6 from "chalk";
+function buildDaemonReport(allEntries, period, now) {
+  const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  let start = new Date(todayStart);
+  if (period === "7d") start.setDate(start.getDate() - 6);
+  else if (period === "30d") start.setDate(start.getDate() - 29);
+  else if (period === "month") start = new Date(now.getFullYear(), now.getMonth(), 1);
+  const entries = allEntries.filter((e) => {
+    if (e.source === "post-hook" || e.source === "response-dlp") return false;
+    return new Date(e.ts) >= start;
+  });
+  const isBlocked = (e) => classifyDecision(e).outcome === "deny";
+  const checkedBy = (e) => typeof e.checkedBy === "string" ? e.checkedBy : void 0;
+  const summary = {
+    total: entries.length,
+    // The inline `startsWith('allow')` this replaces counted every non-allow
+    // row as "blocked" — so DLP findings, MCP-discovery events and, worst, all
+    // the observe-mode "would have blocked" rows inflated the blocked count
+    // with things that were never refusals.
+    allowed: entries.filter((e) => classifyDecision(e).outcome === "allow").length,
+    blocked: entries.filter(isBlocked).length,
+    dlp: entries.filter((e) => checkedBy(e)?.includes("dlp")).length,
+    loops: entries.filter((e) => checkedBy(e) === "loop-detected").length
+  };
+  const dailyMap = /* @__PURE__ */ new Map();
+  if (period === "today") {
+    for (let h = 0; h < 24; h++) {
+      const key = String(h).padStart(2, "0") + ":00";
+      dailyMap.set(key, { date: key, calls: 0, blocked: 0 });
+    }
+    for (const e of entries) {
+      const hour = new Date(e.ts).getHours();
+      const key = String(hour).padStart(2, "0") + ":00";
+      const d = dailyMap.get(key);
+      d.calls++;
+      if (isBlocked(e)) d.blocked++;
+    }
+  } else {
+    for (const e of entries) {
+      const date = e.ts.slice(0, 10);
+      const d = dailyMap.get(date) || { date, calls: 0, blocked: 0 };
+      d.calls++;
+      if (isBlocked(e)) d.blocked++;
+      dailyMap.set(date, d);
+    }
+  }
+  const topToolsMap = /* @__PURE__ */ new Map();
+  const topBlockedMap = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const tool = String(e.tool ?? "");
+    topToolsMap.set(tool, (topToolsMap.get(tool) || 0) + 1);
+    if (isBlocked(e)) topBlockedMap.set(tool, (topBlockedMap.get(tool) || 0) + 1);
+  }
+  const top5 = (m) => [...m.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([name, value]) => ({ name, value }));
+  const agentMap = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const key = e.agent || "unknown";
+    const a = agentMap.get(key) ?? { agent: key, total: 0, blocked: 0, dlp: 0 };
+    a.total++;
+    if (isBlocked(e)) a.blocked++;
+    if (checkedBy(e)?.includes("dlp")) a.dlp++;
+    agentMap.set(key, a);
+  }
+  return {
+    summary,
+    daily: [...dailyMap.values()].sort((a, b) => a.date.localeCompare(b.date)),
+    topTools: top5(topToolsMap),
+    topBlockedTools: top5(topBlockedMap),
+    byAgent: [...agentMap.values()].sort((a, b) => b.total - a.total)
+  };
+}
 function startDaemon() {
   try {
     startCostSync();
@@ -19195,6 +19598,7 @@ function startDaemon() {
     const stack = err2 instanceof Error ? err2.stack ?? err2.message : String(err2);
     console.error("\n\u{1F6D1} Node9 daemon startup failed:\n" + stack);
     logDaemonStartup("startup-throw", err2 instanceof Error ? err2.message : String(err2));
+    recordStartupState("failed", "startup-throw", err2 instanceof Error ? err2.message : String(err2));
     process.exit(1);
   }
   const internalToken = randomUUID4();
@@ -19567,6 +19971,10 @@ data: ${JSON.stringify(item.data)}
         return res.end(JSON.stringify({ error: "internal" }));
       }
     }
+    if (req.method === "GET" && pathname === "/approver") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify({ interactive: hasInteractiveClient() }));
+    }
     if (req.method === "GET" && pathname === "/state/check") {
       const predicatesParam = reqUrl.searchParams.get("predicates") ?? "";
       const predicates = predicatesParam.split(",").filter(Boolean);
@@ -19668,75 +20076,8 @@ data: ${JSON.stringify(item.data)}
             return [];
           }
         });
-        const now = /* @__PURE__ */ new Date();
-        const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
-        let start = new Date(todayStart);
-        if (period === "7d") start.setDate(start.getDate() - 6);
-        else if (period === "30d") start.setDate(start.getDate() - 29);
-        else if (period === "month") start = new Date(now.getFullYear(), now.getMonth(), 1);
-        const entries = allEntries.filter((e) => {
-          if (e.source === "post-hook" || e.source === "response-dlp") return false;
-          return new Date(e.ts) >= start;
-        });
-        const summary = {
-          total: entries.length,
-          allowed: entries.filter((e) => e.decision && e.decision.startsWith("allow")).length,
-          blocked: entries.filter((e) => e.decision && !e.decision.startsWith("allow")).length,
-          dlp: entries.filter((e) => e.checkedBy && e.checkedBy.includes("dlp")).length,
-          loops: entries.filter((e) => e.checkedBy === "loop-detected").length
-        };
-        const dailyMap = /* @__PURE__ */ new Map();
-        if (period === "today") {
-          for (let h = 0; h < 24; h++) {
-            const key = String(h).padStart(2, "0") + ":00";
-            dailyMap.set(key, { date: key, calls: 0, blocked: 0 });
-          }
-          for (const e of entries) {
-            const hour = new Date(e.ts).getHours();
-            const key = String(hour).padStart(2, "0") + ":00";
-            const d = dailyMap.get(key);
-            d.calls++;
-            if (e.decision && !e.decision.startsWith("allow")) d.blocked++;
-          }
-        } else {
-          for (const e of entries) {
-            const date = e.ts.slice(0, 10);
-            const d = dailyMap.get(date) || { date, calls: 0, blocked: 0 };
-            d.calls++;
-            if (e.decision && !e.decision.startsWith("allow")) d.blocked++;
-            dailyMap.set(date, d);
-          }
-        }
-        const topToolsMap = /* @__PURE__ */ new Map();
-        const topBlockedMap = /* @__PURE__ */ new Map();
-        for (const e of entries) {
-          topToolsMap.set(e.tool, (topToolsMap.get(e.tool) || 0) + 1);
-          if (e.decision && !e.decision.startsWith("allow")) {
-            topBlockedMap.set(e.tool, (topBlockedMap.get(e.tool) || 0) + 1);
-          }
-        }
-        const topTools = [...topToolsMap.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([name, value]) => ({ name, value }));
-        const topBlockedTools = [...topBlockedMap.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([name, value]) => ({ name, value }));
-        const agentMap = /* @__PURE__ */ new Map();
-        for (const e of entries) {
-          const key = e.agent || "unknown";
-          const a = agentMap.get(key) ?? { agent: key, total: 0, blocked: 0, dlp: 0 };
-          a.total++;
-          if (e.decision && !e.decision.startsWith("allow")) a.blocked++;
-          if (e.checkedBy?.includes("dlp")) a.dlp++;
-          agentMap.set(key, a);
-        }
-        const byAgent = [...agentMap.values()].sort((a, b) => b.total - a.total);
         res.writeHead(200, { "Content-Type": "application/json" });
-        return res.end(
-          JSON.stringify({
-            summary,
-            daily: [...dailyMap.values()].sort((a, b) => a.date.localeCompare(b.date)),
-            topTools,
-            topBlockedTools,
-            byAgent
-          })
-        );
+        return res.end(JSON.stringify(buildDaemonReport(allEntries, period, /* @__PURE__ */ new Date())));
       } catch {
         res.writeHead(500, { "Content-Type": "application/json" });
         return res.end(JSON.stringify({ error: "Failed to parse report" }));
@@ -20039,6 +20380,23 @@ data: ${JSON.stringify(item.data)}
     res.writeHead(404).end();
   });
   setDaemonServer(server);
+  let bindAttempts = 0;
+  const MAX_BIND_ATTEMPTS = 3;
+  function retryListen() {
+    if (++bindAttempts >= MAX_BIND_ATTEMPTS) {
+      logDaemonStartup(
+        "port-unavailable",
+        `:${DAEMON_PORT} is held by something that is not a node9 daemon`
+      );
+      recordStartupState(
+        "failed",
+        "port-unavailable",
+        `:${DAEMON_PORT} is held by another process that is not a node9 daemon \u2014 free the port, then: node9 daemon --background`
+      );
+      return process.exit(0);
+    }
+    server.listen(DAEMON_PORT, DAEMON_HOST);
+  }
   server.on("error", (e) => {
     if (e.code === "EADDRINUSE") {
       try {
@@ -20046,6 +20404,7 @@ data: ${JSON.stringify(item.data)}
           const { pid } = JSON.parse(fs41.readFileSync(DAEMON_PID_FILE, "utf-8"));
           process.kill(pid, 0);
           logDaemonStartup("port-in-use", `another daemon (pid ${pid}) owns :${DAEMON_PORT}`);
+          recordStartupState("ok-elsewhere");
           return process.exit(0);
         }
       } catch {
@@ -20053,13 +20412,14 @@ data: ${JSON.stringify(item.data)}
           fs41.unlinkSync(DAEMON_PID_FILE);
         } catch {
         }
-        server.listen(DAEMON_PORT, DAEMON_HOST);
+        retryListen();
         return;
       }
       fetch(`http://${DAEMON_HOST}:${DAEMON_PORT}/settings`, {
         signal: AbortSignal.timeout(1e3)
       }).then((res) => {
         if (res.ok) {
+          let adopted = false;
           try {
             let orphanPid = null;
             const ss = spawnSync("ss", ["-Htnp", `sport = :${DAEMON_PORT}`], {
@@ -20087,19 +20447,38 @@ data: ${JSON.stringify(item.data)}
                 JSON.stringify({ pid: orphanPid, port: DAEMON_PORT, internalToken, autoStarted }),
                 { mode: 384 }
               );
+              adopted = true;
             }
           } catch {
           }
+          if (adopted) {
+            logDaemonStartup(
+              "port-in-use-orphan",
+              `adopted the daemon already on :${DAEMON_PORT}`
+            );
+            recordStartupState("ok-elsewhere");
+          } else {
+            logDaemonStartup(
+              "orphan-unidentified",
+              `healthy daemon on :${DAEMON_PORT} could not be identified \u2014 no pid file written`
+            );
+            recordStartupState(
+              "failed",
+              "orphan-unidentified",
+              `a healthy daemon is running on :${DAEMON_PORT} but its process could not be identified, so node9 cannot track it \u2014 install \`ss\` or \`lsof\`, or restart it with: node9 daemon --background`
+            );
+          }
           process.exit(0);
         } else {
-          server.listen(DAEMON_PORT, DAEMON_HOST);
+          retryListen();
         }
       }).catch(() => {
-        server.listen(DAEMON_PORT, DAEMON_HOST);
+        retryListen();
       });
       return;
     }
     logDaemonStartup("bind-failed", e.message);
+    recordStartupState("failed", "bind-failed", e.message);
     console.error(chalk6.red("\n\u{1F6D1} Node9 Daemon Error:"), e.message);
     process.exit(1);
   });
@@ -20117,6 +20496,8 @@ data: ${JSON.stringify(item.data)}
       { mode: 384 }
     );
     console.error(chalk6.green(`\u{1F6E1}\uFE0F  Node9 Guard LIVE on 127.0.0.1:${DAEMON_PORT}`));
+    logDaemonStartup("ok", `listening on ${DAEMON_HOST}:${DAEMON_PORT}`);
+    recordStartupState("ok");
   });
   if (watchMode) {
     console.error(chalk6.cyan("\u{1F6F0}\uFE0F  Flight Recorder active \u2014 daemon will not idle-timeout"));
@@ -20134,6 +20515,7 @@ var init_server = __esm({
     init_costSync();
     init_sync();
     init_audit_shipper();
+    init_decision();
     init_dlp_scanner();
     init_mcp_reconciler();
     init_hook_heal();
@@ -45316,7 +45698,7 @@ __export(tail_exports, {
 });
 import http5 from "http";
 import chalk40 from "chalk";
-import fs71 from "fs";
+import fs72 from "fs";
 import os61 from "os";
 import path68 from "path";
 import readline6 from "readline";
@@ -45343,19 +45725,19 @@ function getModelContextLimit(model) {
 }
 function readSessionUsage() {
   const projectsDir = path68.join(os61.homedir(), ".claude", "projects");
-  if (!fs71.existsSync(projectsDir)) return null;
+  if (!fs72.existsSync(projectsDir)) return null;
   let latestFile = null;
   let latestMtime = 0;
   try {
-    for (const dir of fs71.readdirSync(projectsDir)) {
+    for (const dir of fs72.readdirSync(projectsDir)) {
       const dirPath = path68.join(projectsDir, dir);
       try {
-        if (!fs71.statSync(dirPath).isDirectory()) continue;
-        for (const file of fs71.readdirSync(dirPath)) {
+        if (!fs72.statSync(dirPath).isDirectory()) continue;
+        for (const file of fs72.readdirSync(dirPath)) {
           if (!file.endsWith(".jsonl") || file.startsWith("agent-")) continue;
           const filePath = path68.join(dirPath, file);
           try {
-            const mtime = fs71.statSync(filePath).mtimeMs;
+            const mtime = fs72.statSync(filePath).mtimeMs;
             if (mtime > latestMtime) {
               latestMtime = mtime;
               latestFile = filePath;
@@ -45370,7 +45752,7 @@ function readSessionUsage() {
   }
   if (!latestFile) return null;
   try {
-    const lines = fs71.readFileSync(latestFile, "utf-8").split("\n");
+    const lines = fs72.readFileSync(latestFile, "utf-8").split("\n");
     let lastModel = "";
     let lastInput = 0;
     let lastOutput = 0;
@@ -45470,9 +45852,9 @@ function renderPending(activity) {
 }
 async function ensureDaemon() {
   let pidPort = null;
-  if (fs71.existsSync(PID_FILE)) {
+  if (fs72.existsSync(PID_FILE)) {
     try {
-      const { port } = JSON.parse(fs71.readFileSync(PID_FILE, "utf-8"));
+      const { port } = JSON.parse(fs72.readFileSync(PID_FILE, "utf-8"));
       pidPort = port;
     } catch {
       console.error(chalk40.dim("\u26A0\uFE0F  Could not read PID file; falling back to default port."));
@@ -45487,12 +45869,21 @@ async function ensureDaemon() {
   } catch {
   }
   console.log(chalk40.dim("\u{1F6E1}\uFE0F  Starting Node9 daemon..."));
+  const startupFd = openStartupLogFd();
+  recordStartupState("starting");
   const child = spawn8(process.execPath, [process.argv[1], "daemon"], {
     detached: true,
-    stdio: "ignore",
+    stdio: ["ignore", "ignore", startupFd ?? "ignore"],
     env: { ...process.env, NODE9_AUTO_STARTED: "1" }
   });
+  child.on("error", (err2) => recordStartupState("failed", "spawn-failed", err2.message));
   child.unref();
+  if (startupFd !== void 0) {
+    try {
+      fs72.closeSync(startupFd);
+    } catch {
+    }
+  }
   for (let i = 0; i < 20; i++) {
     await new Promise((r) => setTimeout(r, 250));
     try {
@@ -45630,7 +46021,7 @@ function buildRecoveryCardLines(req) {
 function readApproversFromDisk() {
   const configPath = path68.join(os61.homedir(), ".node9", "config.json");
   try {
-    const raw = JSON.parse(fs71.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs72.readFileSync(configPath, "utf-8"));
     const settings = raw.settings ?? {};
     return settings.approvers ?? {};
   } catch {
@@ -45648,13 +46039,13 @@ function approverStatusLine() {
 function toggleApprover(channel) {
   const configPath = path68.join(os61.homedir(), ".node9", "config.json");
   try {
-    const raw = JSON.parse(fs71.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs72.readFileSync(configPath, "utf-8"));
     const settings = raw.settings ?? {};
     const approvers = settings.approvers ?? {};
     approvers[channel] = approvers[channel] === false;
     settings.approvers = approvers;
     raw.settings = settings;
-    fs71.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+    fs72.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
   } catch (err2) {
     process.stderr.write(`[node9] toggleApprover failed: ${String(err2)}
 `);
@@ -45826,7 +46217,7 @@ async function startTail(options = {}) {
       }
       postDecisionHttp(req2.id, httpDecision, authToken, port, httpOpts).catch((err2) => {
         try {
-          fs71.appendFileSync(
+          fs72.appendFileSync(
             path68.join(os61.homedir(), ".node9", "hook-debug.log"),
             `[tail] POST /decision failed: ${String(err2)}
 `
@@ -45893,7 +46284,7 @@ async function startTail(options = {}) {
   }
   const auditLog = path68.join(os61.homedir(), ".node9", "audit.log");
   try {
-    const unackedDlp = fs71.readFileSync(auditLog, "utf-8").split("\n").filter((l) => l.includes('"response-dlp"')).length;
+    const unackedDlp = fs72.readFileSync(auditLog, "utf-8").split("\n").filter((l) => l.includes('"response-dlp"')).length;
     if (unackedDlp > 0) {
       console.log("");
       console.log(
@@ -45933,7 +46324,7 @@ async function startTail(options = {}) {
     if (stallWarned) return;
     if (Date.now() - lastActivityFromDaemon < STALL_THRESHOLD_MS) return;
     try {
-      const auditMtime = fs71.statSync(auditLog).mtimeMs;
+      const auditMtime = fs72.statSync(auditLog).mtimeMs;
       if (Date.now() - auditMtime >= STALL_THRESHOLD_MS) return;
       console.log("");
       console.log(
@@ -46122,6 +46513,7 @@ var PID_FILE, ICONS, MODEL_CONTEXT_LIMITS, RESET2, BOLD2, RED, YELLOW, CYAN, GRA
 var init_tail = __esm({
   "src/tui/tail.ts"() {
     "use strict";
+    init_startup_log();
     init_daemon2();
     init_daemon();
     PID_FILE = path68.join(os61.homedir(), ".node9", "daemon.pid");
@@ -46172,7 +46564,7 @@ __export(hud_exports, {
   main: () => main,
   renderEnvironmentLine: () => renderEnvironmentLine
 });
-import fs72 from "fs";
+import fs73 from "fs";
 import path69 from "path";
 import os62 from "os";
 import http6 from "http";
@@ -46250,9 +46642,9 @@ function formatTimeLeft(resetsAt) {
   return ` (${m}m left)`;
 }
 function safeReadJson(filePath) {
-  if (!fs72.existsSync(filePath)) return null;
+  if (!fs73.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs72.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs73.readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -46273,10 +46665,10 @@ function countHooksInFile(filePath) {
   return Object.keys(cfg.hooks).length;
 }
 function countRulesInDir(rulesDir) {
-  if (!fs72.existsSync(rulesDir)) return 0;
+  if (!fs73.existsSync(rulesDir)) return 0;
   let count = 0;
   try {
-    for (const entry of fs72.readdirSync(rulesDir, { withFileTypes: true })) {
+    for (const entry of fs73.readdirSync(rulesDir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
         count += countRulesInDir(path69.join(rulesDir, entry.name));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -46302,7 +46694,7 @@ function countConfigs(cwd) {
   let hooksCount = 0;
   const userMcpServers = /* @__PURE__ */ new Set();
   const projectMcpServers = /* @__PURE__ */ new Set();
-  if (fs72.existsSync(path69.join(claudeDir, "CLAUDE.md"))) claudeMdCount++;
+  if (fs73.existsSync(path69.join(claudeDir, "CLAUDE.md"))) claudeMdCount++;
   rulesCount += countRulesInDir(path69.join(claudeDir, "rules"));
   const userSettings = path69.join(claudeDir, "settings.json");
   for (const name of getMcpServerNames(userSettings)) userMcpServers.add(name);
@@ -46313,18 +46705,18 @@ function countConfigs(cwd) {
     userMcpServers.delete(name);
   }
   if (cwd) {
-    if (fs72.existsSync(path69.join(cwd, "CLAUDE.md"))) claudeMdCount++;
-    if (fs72.existsSync(path69.join(cwd, "CLAUDE.local.md"))) claudeMdCount++;
+    if (fs73.existsSync(path69.join(cwd, "CLAUDE.md"))) claudeMdCount++;
+    if (fs73.existsSync(path69.join(cwd, "CLAUDE.local.md"))) claudeMdCount++;
     const projectClaudeDir = path69.join(cwd, ".claude");
     const overlapsUserScope = isSamePath(projectClaudeDir, claudeDir);
     if (!overlapsUserScope) {
-      if (fs72.existsSync(path69.join(projectClaudeDir, "CLAUDE.md"))) claudeMdCount++;
+      if (fs73.existsSync(path69.join(projectClaudeDir, "CLAUDE.md"))) claudeMdCount++;
       rulesCount += countRulesInDir(path69.join(projectClaudeDir, "rules"));
       const projSettings = path69.join(projectClaudeDir, "settings.json");
       for (const name of getMcpServerNames(projSettings)) projectMcpServers.add(name);
       hooksCount += countHooksInFile(projSettings);
     }
-    if (fs72.existsSync(path69.join(projectClaudeDir, "CLAUDE.local.md"))) claudeMdCount++;
+    if (fs73.existsSync(path69.join(projectClaudeDir, "CLAUDE.local.md"))) claudeMdCount++;
     const localSettings = path69.join(projectClaudeDir, "settings.local.json");
     for (const name of getMcpServerNames(localSettings)) projectMcpServers.add(name);
     hooksCount += countHooksInFile(localSettings);
@@ -46362,11 +46754,11 @@ function readActiveShieldsHud() {
   }
   try {
     const shieldsPath = path69.join(os62.homedir(), ".node9", "shields.json");
-    if (!fs72.existsSync(shieldsPath)) {
+    if (!fs73.existsSync(shieldsPath)) {
       shieldsCache = { value: [], ts: now };
       return [];
     }
-    const parsed = JSON.parse(fs72.readFileSync(shieldsPath, "utf-8"));
+    const parsed = JSON.parse(fs73.readFileSync(shieldsPath, "utf-8"));
     if (!Array.isArray(parsed.active)) {
       shieldsCache = { value: [], ts: now };
       return [];
@@ -46468,17 +46860,17 @@ function renderContextLine(stdin) {
 async function main() {
   try {
     const [stdin, daemonStatus2] = await Promise.all([readStdin(), queryDaemon()]);
-    if (fs72.existsSync(path69.join(os62.homedir(), ".node9", "hud-debug"))) {
+    if (fs73.existsSync(path69.join(os62.homedir(), ".node9", "hud-debug"))) {
       try {
         const logPath = path69.join(os62.homedir(), ".node9", "hud-debug.log");
         const MAX_LOG_SIZE = 10 * 1024 * 1024;
         let size = 0;
         try {
-          size = fs72.statSync(logPath).size;
+          size = fs73.statSync(logPath).size;
         } catch {
         }
         if (size < MAX_LOG_SIZE) {
-          fs72.appendFileSync(
+          fs73.appendFileSync(
             logPath,
             JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), stdin }) + "\n"
           );
@@ -46502,8 +46894,8 @@ async function main() {
           path69.join(cwd, "node9.config.json"),
           path69.join(os62.homedir(), ".node9", "config.json")
         ]) {
-          if (!fs72.existsSync(configPath)) continue;
-          const cfg = JSON.parse(fs72.readFileSync(configPath, "utf-8"));
+          if (!fs73.existsSync(configPath)) continue;
+          const cfg = JSON.parse(fs73.readFileSync(configPath, "utf-8"));
           const hud = cfg.settings?.hud;
           if (hud && "showEnvironmentCounts" in hud) return hud.showEnvironmentCounts !== false;
         }
@@ -46645,7 +47037,7 @@ function writeCredentialsAndConfig(apiKey, opts = {}) {
 // src/cli.ts
 init_daemon2();
 import chalk41 from "chalk";
-import fs73 from "fs";
+import fs74 from "fs";
 import path70 from "path";
 import os63 from "os";
 import { spawn as spawn9 } from "child_process";
@@ -46851,9 +47243,11 @@ function logAutostartSkipThrottled(reason) {
       if (Date.now() - fs44.statSync(stamp).mtimeMs < SKIP_THROTTLE_MS) return;
     } catch {
     }
+    const dir = path42.join(os40.homedir(), ".node9");
+    if (!fs44.existsSync(dir)) fs44.mkdirSync(dir, { recursive: true });
     fs44.writeFileSync(stamp, "", "utf-8");
     fs44.appendFileSync(
-      path42.join(os40.homedir(), ".node9", "hook-debug.log"),
+      path42.join(dir, "hook-debug.log"),
       `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon-autostart-skip: ${reason}
 `,
       "utf-8"
@@ -46872,6 +47266,8 @@ async function autoStartDaemonAndWait() {
   }
   if (!resolvedArgv1.endsWith(".js")) return false;
   const startupFd = openStartupLogFd();
+  recordStartupState("starting");
+  let spawned = false;
   try {
     const child = spawn3(process.execPath, [resolvedArgv1, "daemon"], {
       detached: true,
@@ -46881,13 +47277,24 @@ async function autoStartDaemonAndWait() {
         NODE9_AUTO_STARTED: "1"
       }
     });
+    child.on("error", (err2) => {
+      if (readStartupState()?.outcome !== "starting") return;
+      recordStartupState("failed", "spawn-failed", err2.message);
+    });
     child.unref();
+    spawned = true;
     for (let i = 0; i < 20; i++) {
       await new Promise((r) => setTimeout(r, 250));
       if (!isDaemonRunning()) continue;
       if (await isDaemonReachable()) return true;
     }
-  } catch {
+  } catch (err2) {
+    if (!spawned)
+      recordStartupState(
+        "failed",
+        "spawn-failed",
+        err2 instanceof Error ? err2.message : String(err2)
+      );
   } finally {
     if (startupFd !== void 0) {
       try {
@@ -47700,12 +48107,16 @@ RAW: ${raw}
               delete safeEnv[key];
             }
             const startupFd = openStartupLogFd();
+            recordStartupState("starting");
             try {
               const d = spawn5(process.execPath, [scriptPath, "daemon"], {
                 detached: true,
                 stdio: ["ignore", "ignore", startupFd ?? "ignore"],
                 env: { ...safeEnv, NODE9_AUTO_STARTED: "1" }
               });
+              d.on("error", (err2) => {
+                recordStartupState("failed", "spawn-failed", err2.message);
+              });
               d.unref();
             } finally {
               if (startupFd !== void 0) {
@@ -47718,6 +48129,7 @@ RAW: ${raw}
           } catch (spawnErr) {
             const logPath = path46.join(os44.homedir(), ".node9", "hook-debug.log");
             const msg = spawnErr instanceof Error ? spawnErr.message : String(spawnErr);
+            recordStartupState("failed", "spawn-aborted", msg);
             try {
               fs48.appendFileSync(
                 logPath,
@@ -48882,6 +49294,7 @@ function agoLabel(iso, now = Date.now()) {
 }
 
 // src/cli/commands/doctor.ts
+init_startup_log();
 function registerDoctorCommand(program2, version2) {
   program2.command("doctor").description("Check that Node9 is installed and configured correctly").action(async () => {
     const homeDir2 = os47.homedir();
@@ -48993,6 +49406,15 @@ function registerDoctorCommand(program2, version2) {
         "Daemon not running \u2014 terminal & native approvals unavailable",
         "Run: node9 daemon --background"
       );
+      const cause = readStartupCause();
+      if (cause) {
+        const suffix = cause.detail ? ` \u2014 ${cause.detail}` : "";
+        console.log(
+          chalk11.gray(
+            `       ${cause.label} ${agoLabel(cause.at.toISOString())}: ${cause.kind}${suffix}`
+          )
+        );
+      }
     }
     const autostart = autostartAdvice({
       installed: isDaemonServiceInstalled(),
@@ -49067,6 +49489,7 @@ function registerDoctorCommand(program2, version2) {
 }
 
 // src/cli/commands/audit.ts
+init_decision();
 import chalk12 from "chalk";
 import fs53 from "fs";
 import path51 from "path";
@@ -49101,10 +49524,16 @@ function registerAuditCommand(program2) {
     });
     entries = entries.map((e) => ({
       ...e,
-      decision: String(e.decision).startsWith("allow") ? "allow" : "deny"
+      // classifyDecision is the ONE mapper (audit/decision.ts). The inline
+      // `startsWith('allow') ? allow : deny` this replaces bucketed `dlp` and
+      // `mcp-discovered` — findings, not verdicts — as DENY, inventing
+      // refusals that never happened.
+      // Pass the ROW, never a field pair — the attribution key differs by
+      // producer (`checkedBy` from the gate, `source` from the hook/daemon).
+      view: classifyDecision(e)
     }));
     if (options.tool) entries = entries.filter((e) => String(e.tool).includes(options.tool));
-    if (options.deny) entries = entries.filter((e) => e.decision === "deny");
+    if (options.deny) entries = entries.filter((e) => e.view.outcome === "deny");
     const limit = Math.max(1, parseInt(options.tail, 10) || 20);
     entries = entries.slice(-limit);
     if (options.json) {
@@ -49127,13 +49556,13 @@ function registerAuditCommand(program2) {
     for (const e of entries) {
       const time = formatRelativeTime(String(e.ts)).padEnd(12);
       const tool = String(e.tool).slice(0, 17).padEnd(18);
-      const result = e.decision === "allow" ? chalk12.green("ALLOW".padEnd(10)) : chalk12.red("DENY".padEnd(10));
+      const result = e.view.outcome === "allow" ? chalk12.green(e.view.label.padEnd(14)) : e.view.outcome === "deny" ? chalk12.red(e.view.label.padEnd(14)) : e.view.outcome === "observe" ? chalk12.yellow(e.view.label.padEnd(14)) : chalk12.gray(e.view.label.padEnd(14));
       const checker = String(e.checkedBy || "unknown").slice(0, 14).padEnd(15);
       const agent = String(e.agent || "unknown");
       console.log(`  ${time} ${tool} ${result} ${checker} ${agent}`);
     }
-    const allowed = entries.filter((e) => e.decision === "allow").length;
-    const denied = entries.filter((e) => e.decision === "deny").length;
+    const allowed = entries.filter((e) => e.view.outcome === "allow").length;
+    const denied = entries.filter((e) => e.view.outcome === "deny").length;
     console.log(chalk12.dim("  " + "\u2500".repeat(65)));
     console.log(
       `  ${entries.length} entries  |  ${chalk12.green(allowed + " allowed")}  |  ${chalk12.red(denied + " denied")}
@@ -49149,6 +49578,7 @@ import chalk13 from "chalk";
 init_costSync();
 init_litellm();
 init_cost_codex();
+init_decision();
 import fs54 from "fs";
 import os49 from "os";
 import path52 from "path";
@@ -49242,8 +49672,15 @@ function parseAuditLog(logPath) {
     }
   });
 }
-function isAllow(decision) {
-  return decision.startsWith("allow");
+function viewOf(e) {
+  const outcome = classifyDecision(e).outcome;
+  const observed = outcome === "observe";
+  return {
+    observed,
+    ran: outcome === "allow" || observed,
+    blocked: outcome === "deny" || outcome === "unknown",
+    info: outcome === "info"
+  };
 }
 function isDlp(checkedBy) {
   return !!checkedBy?.includes("dlp");
@@ -49656,12 +50093,12 @@ function aggregateReportFromAudit(period, opts = {}) {
   const priorStart = new Date(start.getTime() - periodMs);
   const priorEntries = allEntries.filter((e) => {
     if (e.source === "post-hook") return false;
+    if (e.source === "response-dlp") return false;
+    if (typeof e.decision !== "string") return false;
     const ts = new Date(e.ts);
     return ts >= priorStart && ts <= priorEnd;
   });
-  const priorBlocked = priorEntries.filter(
-    (e) => typeof e.decision === "string" && !isAllow(e.decision)
-  ).length;
+  const priorBlocked = priorEntries.filter((e) => viewOf(e).blocked).length;
   const priorBlockRate = priorEntries.length > 0 ? priorBlocked / priorEntries.length : null;
   const excludeTests = opts.excludeTests === true;
   const testTs = excludeTests ? buildTestTimestamps(allEntries) : /* @__PURE__ */ new Set();
@@ -49704,15 +50141,17 @@ function aggregateReportFromAudit(period, opts = {}) {
   let dimInjectionBlocked = 0;
   for (const e of entries) {
     if (superseded.has(supersedeKey(e))) continue;
-    const allow = isAllow(e.decision);
+    const view = viewOf(e);
     const dateKey = e.ts.slice(0, 10);
     const userInteracted = e.source === "daemon";
-    if (userInteracted) {
-      if (allow) userApproved++;
+    if (view.observed) {
+      if (e.checkedBy === "observe-mode-dlp-would-block") observeDlp++;
+    } else if (view.info) {
+    } else if (userInteracted) {
+      if (view.ran) userApproved++;
       else userDenied++;
-    } else if (!allow) {
+    } else if (view.blocked) {
       if (e.checkedBy === "timeout") timedOut++;
-      else if (e.checkedBy === "observe-mode-dlp-would-block") observeDlp++;
       else if (isDlp(e.checkedBy)) dlpBlocked++;
       else if (e.checkedBy === "local-decision") userDenied++;
       else if (e.checkedBy !== "loop-detected") hardBlocked++;
@@ -49724,7 +50163,7 @@ function aggregateReportFromAudit(period, opts = {}) {
     if (cb.includes("would-block") && (cb.includes("pii") || cb.includes("dlp"))) {
       dimDataObserved++;
     }
-    if (!allow && !userInteracted) {
+    if (view.blocked && !userInteracted) {
       switch (dimensionOfBlock(cb, e.ruleName ?? "")) {
         case "network":
           dimNetworkBlocked++;
@@ -49742,15 +50181,15 @@ function aggregateReportFromAudit(period, opts = {}) {
     }
     const t = toolMap.get(e.tool) ?? { calls: 0, blocked: 0 };
     t.calls++;
-    if (!allow) t.blocked++;
+    if (view.blocked) t.blocked++;
     toolMap.set(e.tool, t);
-    if (!allow) {
+    if (view.blocked) {
       const key = e.checkedBy ?? (e.source === "daemon" ? "local-decision" : null);
       if (key) {
         blockMap.set(key, (blockMap.get(key) ?? 0) + 1);
       }
     }
-    if (!allow && e.ruleName) {
+    if ((view.blocked || view.observed) && e.ruleName) {
       ruleMap.set(e.ruleName, (ruleMap.get(e.ruleName) ?? 0) + 1);
     }
     if (e.agent) agentMap.set(e.agent, (agentMap.get(e.agent) ?? 0) + 1);
@@ -49759,7 +50198,7 @@ function aggregateReportFromAudit(period, opts = {}) {
     hourMap.set(hour, (hourMap.get(hour) ?? 0) + 1);
     const d = dailyMap.get(dateKey) ?? { calls: 0, blocked: 0 };
     d.calls++;
-    if (!allow) d.blocked++;
+    if (view.blocked) d.blocked++;
     dailyMap.set(dateKey, d);
   }
   for (const e of allEntries) {
@@ -50311,9 +50750,11 @@ function renderTerminalReport(data, responseDlpEntries, excludeTests) {
 }
 
 // src/cli/commands/daemon-cmd.ts
+init_startup_log();
 init_daemon2();
 import chalk14 from "chalk";
 import { spawn as spawn6 } from "child_process";
+import fs55 from "fs";
 var VALID_ACTIONS = "start | stop | restart | status | install | uninstall";
 function registerDaemonCommand(program2) {
   program2.command("daemon").description("Manage the local approval daemon").argument("[action]", `${VALID_ACTIONS} (default: start)`).option("-b, --background", "Start the daemon in the background (detached)").option(
@@ -50351,14 +50792,27 @@ function registerDaemonCommand(program2) {
       if (cmd === "restart") {
         stopDaemon();
         await new Promise((r) => setTimeout(r, 500));
+        const restartFd = openStartupLogFd();
+        recordStartupState("starting");
         const child = spawn6(process.execPath, [process.argv[1], "daemon"], {
           detached: true,
-          stdio: "ignore",
+          stdio: ["ignore", "ignore", restartFd ?? "ignore"],
           env: { ...process.env, NODE9_AUTO_STARTED: "1" }
         });
+        child.on(
+          "error",
+          (err2) => recordStartupState("failed", "spawn-failed", err2.message)
+        );
         child.unref();
+        if (restartFd !== void 0) {
+          try {
+            fs55.closeSync(restartFd);
+          } catch {
+          }
+        }
         if (child.pid) {
-          console.log(chalk14.green(`\u2713 Daemon restarted (PID ${child.pid})`));
+          console.log(chalk14.green(`\u2713 Daemon relaunching (PID ${child.pid})`));
+          console.log(chalk14.gray("   Confirm with: node9 status"));
         } else {
           console.error(chalk14.red("\u2717 Failed to restart daemon \u2014 spawn returned no PID"));
           process.exit(1);
@@ -50381,13 +50835,33 @@ function registerDaemonCommand(program2) {
         return;
       }
       if (options.background) {
-        const child = spawn6(process.execPath, [process.argv[1], "daemon"], {
-          detached: true,
-          stdio: "ignore"
-        });
-        child.unref();
-        console.log(chalk14.green(`
-\u{1F6E1}\uFE0F  Node9 daemon started in background  (PID ${child.pid})`));
+        const startupFd = openStartupLogFd();
+        try {
+          recordStartupState("starting");
+          const child = spawn6(process.execPath, [process.argv[1], "daemon"], {
+            detached: true,
+            // Capture the child's stderr: a module-load crash prints its stack there
+            // and dies before it can record anything itself.
+            stdio: ["ignore", "ignore", startupFd ?? "ignore"]
+          });
+          child.on(
+            "error",
+            (err2) => recordStartupState("failed", "spawn-failed", err2.message)
+          );
+          child.unref();
+          console.log(
+            chalk14.green(`
+\u{1F6E1}\uFE0F  Node9 daemon launching in background  (PID ${child.pid})`)
+          );
+          console.log(chalk14.gray("   Confirm with: node9 status"));
+        } finally {
+          if (startupFd !== void 0) {
+            try {
+              fs55.closeSync(startupFd);
+            } catch {
+            }
+          }
+        }
         process.exit(0);
       }
       startDaemon();
@@ -50402,7 +50876,7 @@ init_agent_wiring();
 init_sync();
 init_service();
 import chalk15 from "chalk";
-import fs55 from "fs";
+import fs56 from "fs";
 import path53 from "path";
 import os50 from "os";
 function printAgentSection(label2, hookPairs, wrapped) {
@@ -50480,10 +50954,10 @@ function registerStatusCommand(program2) {
     const projectConfig = path53.join(process.cwd(), "node9.config.json");
     const globalConfig = path53.join(os50.homedir(), ".node9", "config.json");
     console.log(
-      `  Local:   ${fs55.existsSync(projectConfig) ? chalk15.green("Active (node9.config.json)") : chalk15.gray("Not present")}`
+      `  Local:   ${fs56.existsSync(projectConfig) ? chalk15.green("Active (node9.config.json)") : chalk15.gray("Not present")}`
     );
     console.log(
-      `  Global:  ${fs55.existsSync(globalConfig) ? chalk15.green("Active (~/.node9/config.json)") : chalk15.gray("Not present")}`
+      `  Global:  ${fs56.existsSync(globalConfig) ? chalk15.green("Active (~/.node9/config.json)") : chalk15.gray("Not present")}`
     );
     if (mergedConfig.policy.sandboxPaths.length > 0) {
       console.log(
@@ -50530,7 +51004,7 @@ init_shields();
 init_service();
 init_core();
 import chalk16 from "chalk";
-import fs56 from "fs";
+import fs57 from "fs";
 import path54 from "path";
 import os51 from "os";
 import https6 from "https";
@@ -50619,15 +51093,15 @@ function registerInitCommand(program2) {
         console.log("");
       }
       const configPath = path54.join(os51.homedir(), ".node9", "config.json");
-      const isFirstInstall = !fs56.existsSync(configPath);
-      if (fs56.existsSync(configPath) && !options.force) {
+      const isFirstInstall = !fs57.existsSync(configPath);
+      if (fs57.existsSync(configPath) && !options.force) {
         try {
-          const existing = JSON.parse(fs56.readFileSync(configPath, "utf-8"));
+          const existing = JSON.parse(fs57.readFileSync(configPath, "utf-8"));
           const settings = existing.settings ?? {};
           if (settings.mode !== chosenMode) {
             settings.mode = chosenMode;
             existing.settings = settings;
-            fs56.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
+            fs57.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
             console.log(chalk16.green(`\u2705 Mode updated: ${chosenMode}`));
           } else {
             console.log(chalk16.blue(`\u2139\uFE0F  Config already exists: ${configPath}`));
@@ -50641,8 +51115,8 @@ function registerInitCommand(program2) {
           settings: { ...DEFAULT_CONFIG.settings, mode: chosenMode }
         };
         const dir = path54.dirname(configPath);
-        if (!fs56.existsSync(dir)) fs56.mkdirSync(dir, { recursive: true });
-        fs56.writeFileSync(configPath, JSON.stringify(configToSave, null, 2) + "\n");
+        if (!fs57.existsSync(dir)) fs57.mkdirSync(dir, { recursive: true });
+        fs57.writeFileSync(configPath, JSON.stringify(configToSave, null, 2) + "\n");
         console.log(chalk16.green(`\u2705 Config created: ${configPath}`));
         console.log(chalk16.gray(`   Mode: ${chosenMode}`));
       }
@@ -50745,11 +51219,11 @@ init_agent_wiring();
 init_setup();
 init_hook_baseline();
 import chalk17 from "chalk";
-import fs57 from "fs";
+import fs58 from "fs";
 var hasHookSurface = (a) => a.hooks.length > 0;
 function backupForHeal(file) {
   try {
-    if (file && fs57.existsSync(file)) fs57.copyFileSync(file, `${file}.node9-heal-bak`);
+    if (file && fs58.existsSync(file)) fs58.copyFileSync(file, `${file}.node9-heal-bak`);
   } catch {
   }
 }
@@ -51709,16 +52183,17 @@ function registerMcpGatewayCommand(program2) {
 
 // src/mcp-server/index.ts
 import readline5 from "readline";
-import fs59 from "fs";
+import fs60 from "fs";
 import os53 from "os";
 import path57 from "path";
 import { spawnSync as spawnSync4 } from "child_process";
+init_decision();
 init_core();
 init_daemon();
 init_shields();
 
 // src/auth/egress-config.ts
-import fs58 from "fs";
+import fs59 from "fs";
 import os52 from "os";
 import path56 from "path";
 var DEFAULT_EGRESS = {
@@ -51734,7 +52209,7 @@ function egressConfigPath() {
 function readEgressRawConfig() {
   let text;
   try {
-    text = fs58.readFileSync(egressConfigPath(), "utf8");
+    text = fs59.readFileSync(egressConfigPath(), "utf8");
   } catch (err2) {
     if (err2.code === "ENOENT") return {};
     throw err2;
@@ -51749,8 +52224,8 @@ function readEgressRawConfig() {
 }
 function writeEgressRawConfig(config) {
   const p = egressConfigPath();
-  fs58.mkdirSync(path56.dirname(p), { recursive: true });
-  fs58.writeFileSync(p, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  fs59.mkdirSync(path56.dirname(p), { recursive: true });
+  fs59.writeFileSync(p, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function applyEgress(config, change) {
   const policy = config.policy = config.policy ?? {};
@@ -51945,7 +52420,7 @@ var TOOLS = [
   },
   {
     name: "node9_audit_get",
-    description: "Read recent entries from the node9 audit log (~/.node9/audit.log). Each entry shows timestamp, tool name, decision (allow/block/review), command/args, and agent. Use this to review what AI actions have been taken recently, especially blocked or reviewed ops.",
+    description: "Read recent entries from the node9 audit log (~/.node9/audit.log). Each entry shows timestamp, outcome, tool name, the command, and the rule that fired. Outcomes use the same words as the dashboard: Auto-allowed, Approved, Ran, Blocked, Denied (a human refused), Timed out (nobody answered), Would block (shadow mode let it through), Finding, Info. Use this to review what AI actions were taken, especially refused ones.",
     inputSchema: {
       type: "object",
       properties: {
@@ -51955,8 +52430,8 @@ var TOOLS = [
         },
         filter: {
           type: "string",
-          enum: ["all", "block", "review"],
-          description: 'Filter by decision. Omit or use "all" to show every entry.'
+          enum: ["all", "allow", "deny", "observe", "info", "block"],
+          description: 'Filter by outcome. "deny" covers every refusal (rule block, human denial, timeout); "observe" is shadow-mode would-blocks; "block" is an alias for "deny". Omit or use "all" for every entry.'
         }
       },
       required: []
@@ -52138,10 +52613,10 @@ function handleStatus() {
   const projectConfig = path57.join(process.cwd(), "node9.config.json");
   const globalConfig = path57.join(os53.homedir(), ".node9", "config.json");
   lines.push(
-    `Project config (node9.config.json): ${fs59.existsSync(projectConfig) ? "present" : "not found"}`
+    `Project config (node9.config.json): ${fs60.existsSync(projectConfig) ? "present" : "not found"}`
   );
   lines.push(
-    `Global config (~/.node9/config.json): ${fs59.existsSync(globalConfig) ? "present" : "not found"}`
+    `Global config (~/.node9/config.json): ${fs60.existsSync(globalConfig) ? "present" : "not found"}`
   );
   return lines.join("\n");
 }
@@ -52251,8 +52726,8 @@ var GLOBAL_CONFIG_PATH = path57.join(os53.homedir(), ".node9", "config.json");
 var APPROVER_CHANNELS = ["native", "browser", "cloud", "terminal"];
 function readGlobalConfigRaw() {
   try {
-    if (fs59.existsSync(GLOBAL_CONFIG_PATH)) {
-      return JSON.parse(fs59.readFileSync(GLOBAL_CONFIG_PATH, "utf-8"));
+    if (fs60.existsSync(GLOBAL_CONFIG_PATH)) {
+      return JSON.parse(fs60.readFileSync(GLOBAL_CONFIG_PATH, "utf-8"));
     }
   } catch {
   }
@@ -52260,8 +52735,8 @@ function readGlobalConfigRaw() {
 }
 function writeGlobalConfigRaw(data) {
   const dir = path57.dirname(GLOBAL_CONFIG_PATH);
-  if (!fs59.existsSync(dir)) fs59.mkdirSync(dir, { recursive: true });
-  fs59.writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(data, null, 2) + "\n");
+  if (!fs60.existsSync(dir)) fs60.mkdirSync(dir, { recursive: true });
+  fs60.writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(data, null, 2) + "\n");
 }
 function handleApproverList() {
   const config = getConfig();
@@ -52306,35 +52781,37 @@ function handleAuditGet(args) {
   const limit = Math.min(typeof args.limit === "number" ? args.limit : 20, 100);
   const filter = typeof args.filter === "string" && args.filter !== "all" ? args.filter : null;
   const auditPath = path57.join(os53.homedir(), ".node9", "audit.log");
-  if (!fs59.existsSync(auditPath)) return "No audit log found.";
-  const rawLines = fs59.readFileSync(auditPath, "utf-8").trim().split("\n").filter(Boolean);
+  if (!fs60.existsSync(auditPath)) return "No audit log found.";
+  const rawLines = fs60.readFileSync(auditPath, "utf-8").trim().split("\n").filter(Boolean);
+  const wanted = filter === "block" ? "deny" : filter;
   const parsed = [];
   for (const line of rawLines) {
     try {
       const e = JSON.parse(line);
-      const decision = String(e.decision ?? "allow");
-      if (filter && decision !== filter) continue;
+      const view = classifyDecision(e);
+      if (wanted && view.outcome !== wanted) continue;
       const argsObj = e.args;
       let detail = "";
       if (argsObj) {
         const cmd = argsObj.command ?? argsObj.file_path ?? argsObj.path ?? argsObj.sql;
-        if (typeof cmd === "string" && cmd) {
-          detail = cmd.length > 80 ? cmd.slice(0, 80) + "\u2026" : cmd;
-        }
+        if (typeof cmd === "string" && cmd) detail = cmd;
       }
-      const decisionPad = decision === "block" ? "[BLOCK] " : decision === "review" ? "[review]" : "[allow] ";
+      if (!detail && typeof e.argsPreview === "string") detail = e.argsPreview;
+      detail = detail.replace(/\s+/g, " ").trim();
+      if (detail.length > 80) detail = detail.slice(0, 80) + "\u2026";
+      const why = typeof e.ruleName === "string" && e.ruleName ? `  (${e.ruleName})` : "";
       const toolPad = String(e.tool ?? "").padEnd(20);
-      const line2 = `${e.ts}  ${decisionPad}  ${toolPad}  ${detail}`;
-      parsed.push({ raw: line, decision, formatted: line2 });
+      const line2 = `${e.ts}  ${decisionTag(view)}  ${toolPad}  ${detail}${why}`;
+      parsed.push({ raw: line, outcome: view.outcome, formatted: line2 });
     } catch {
-      parsed.push({ raw: line, decision: "allow", formatted: line });
+      parsed.push({ raw: line, outcome: "unknown", formatted: `[? unparseable]  ${line}` });
     }
   }
   const recent = parsed.slice(-limit);
   if (recent.length === 0) {
-    return filter ? `No ${filter} entries found in audit log.` : "Audit log is empty.";
+    return filter ? `No ${wanted} entries found in audit log.` : "Audit log is empty.";
   }
-  const header = filter ? `Last ${recent.length} ${filter.toUpperCase()} entries:` : `Last ${recent.length} audit entries:`;
+  const header = filter ? `Last ${recent.length} ${String(wanted).toUpperCase()} entries:` : `Last ${recent.length} audit entries:`;
   return `${header}
 
 ${recent.map((e) => e.formatted).join("\n")}`;
@@ -52681,7 +53158,7 @@ function registerTrustCommand(program2) {
 // src/cli/commands/mcp-pin.ts
 init_mcp_pin();
 import chalk24 from "chalk";
-import fs60 from "fs";
+import fs61 from "fs";
 
 // src/cli/commands/mcp-gateway-cmd.ts
 init_mcp_wrap();
@@ -52877,6 +53354,7 @@ Restart ${[...agents].join(", ")}`) + chalk23.gray(" to activate. Undo any serve
 }
 
 // src/cli/commands/mcp-pin.ts
+init_mcp_wrap();
 function registerMcpPinCommand(program2) {
   const pinCmd = program2.command("mcp").description("Manage MCP servers \u2014 governance (gateway) + tool-definition pinning");
   registerMcpGatewayCommand2(pinCmd);
@@ -52888,7 +53366,7 @@ function registerMcpPinCommand(program2) {
     let repoCorrupt = false;
     if (found.source === "repo") {
       try {
-        const raw = fs60.readFileSync(found.path, "utf-8");
+        const raw = fs61.readFileSync(found.path, "utf-8");
         const parsed = JSON.parse(raw);
         repoEntries = parsed.servers ?? {};
       } catch {
@@ -53002,6 +53480,88 @@ function registerMcpPinCommand(program2) {
 \u{1F513} Cleared ${count} MCP pin(s).`));
     console.log(chalk24.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) {
+      forgetAllStale();
+      return;
+    }
+    if (!serverKey) {
+      console.error(
+        chalk24.red("\n\u274C Please provide a server key, or use --stale to remove all orphans.\n")
+      );
+      process.exit(1);
+    }
+    let pins;
+    try {
+      pins = readMcpPins();
+    } catch {
+      console.error(chalk24.red("\n\u274C Pin file is corrupt."));
+      console.error(chalk24.yellow("   Run: node9 mcp pin reset\n"));
+      process.exit(1);
+    }
+    if (!pins.servers[serverKey]) {
+      console.error(chalk24.red(`
+\u274C No pin found for server key "${serverKey}"
+`));
+      console.error(`Run ${chalk24.cyan("node9 mcp pin list")} to see pinned servers.
+`);
+      process.exit(1);
+    }
+    const inv = inventoryMcp();
+    const liveKeys = inventoryServerKeys(inv);
+    if (liveKeys.has(serverKey)) {
+      const agent = "an agent config";
+      console.error(chalk24.red(`
+\u274C Server "${serverKey}" is still configured in ${agent}.`));
+      console.error(
+        chalk24.yellow(
+          `   Remove it from the agent config first, then run: node9 mcp forget ${serverKey}
+`
+        )
+      );
+      process.exit(1);
+    }
+    const label2 = pins.servers[serverKey].label;
+    removePin(serverKey);
+    console.log(chalk24.green(`
+\u2713 Forgot server ${chalk24.cyan(serverKey)}`));
+    console.log(chalk24.gray(`   Was: ${label2}`));
+    console.log(chalk24.gray("   Pin removed \u2014 server will no longer appear in the dashboard.\n"));
+  });
+}
+function forgetAllStale() {
+  let pins;
+  try {
+    pins = readMcpPins();
+  } catch {
+    console.error(chalk24.red("\n\u274C Pin file is corrupt."));
+    console.error(chalk24.yellow("   Run: node9 mcp pin reset\n"));
+    process.exit(1);
+  }
+  const inv = inventoryMcp();
+  const liveKeys = inventoryServerKeys(inv);
+  if (liveKeys.size === 0) {
+    console.error(chalk24.red("\n\u274C No live MCP servers detected \u2014 refusing to remove every pin."));
+    console.error(
+      chalk24.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"
+      )
+    );
+    process.exit(1);
+  }
+  const stale = Object.entries(pins.servers).filter(([sk]) => !liveKeys.has(sk));
+  if (stale.length === 0) {
+    console.log(chalk24.gray("\nNo stale servers to remove.\n"));
+    return;
+  }
+  for (const [sk, pin] of stale) {
+    delete pins.servers[sk];
+    console.log(chalk24.green(`  \u2713 ${chalk24.cyan(sk)}  ${chalk24.gray(pin.label)}`));
+  }
+  writeMcpPins(pins);
+  console.log(chalk24.green(`
+Removed ${stale.length} stale server(s).
+`));
 }
 
 // src/cli/commands/sync.ts
@@ -53246,10 +53806,16 @@ var LABEL_WIDTH = 14;
 function label(category) {
   return chalk27.bold(category.padEnd(Math.max(LABEL_WIDTH, category.length + 1)));
 }
-function renderFinding(f, showWeight = false) {
+function guardedWhat(f) {
+  if (f.detail.length === 0) return "this";
+  const reads = f.coverageProbe?.kind === "fileRead" ? "reads of " : "";
+  const more = f.detail.length > 1 ? ` and ${f.detail.length - 1} more` : "";
+  return `${reads}${f.detail[0]}${more}`;
+}
+function renderFinding(f, showWeight = false, displayLabel = f.category) {
   const lines = [];
   const wt = showWeight && f.scoreWeight ? chalk27.cyan.bold(`+${f.scoreWeight} `) : "";
-  lines.push(`  ${ICON[f.severity]} ${label(f.category)}${wt}${f.title}`);
+  lines.push(`  ${ICON[f.severity]} ${label(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]) {
@@ -53286,11 +53852,11 @@ function renderPosture(result) {
   );
   const headroom = openHeadroom(result.findings);
   if (headroom > 0) {
-    lines.push(
-      "  " + chalk27.gray(
-        `${headroom} pts of headroom below \u2014 each layer adds security at some cost to flexibility. You choose which to close.`
-      )
-    );
+    const openExposures = result.findings.filter(
+      (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("  " + chalk27.gray(l));
   }
   lines.push("");
   if (result.headline) {
@@ -53303,13 +53869,18 @@ function renderPosture(result) {
   }
   const covered = result.findings.filter((f) => f.coverage?.state === "covered");
   const open = result.findings.filter((f) => f.coverage?.state !== "covered");
+  const collision = new Set(
+    covered.map((f) => f.category).filter((c) => open.some((o) => o.category === c))
+  );
+  const openLabel = (f) => collision.has(f.category) ? `${f.category} (exposed)` : f.category;
   if (covered.length > 0) {
     lines.push("  " + chalk27.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(
-        `  ${chalk27.green("\u2705")} ${label(f.category)}${chalk27.gray(`${via} is ${gated} this`)}`
+        `  ${chalk27.green("\u2705")} ${label(lbl)}${chalk27.gray(`${via} is ${gated} ${guardedWhat(f)}`)}`
       );
     }
     lines.push("");
@@ -53319,17 +53890,17 @@ function renderPosture(result) {
   const osOpen = open.filter((f) => f.owner !== "node9" && !f.node9Reduces);
   if (node9Open.length > 0) {
     lines.push("  " + chalk27.cyan.bold("\u{1F527} node9 can fix these \u2014 run the command"));
-    for (const f of node9Open) lines.push(...renderFinding(f, true));
+    for (const f of node9Open) lines.push(...renderFinding(f, true, openLabel(f)));
   }
   if (reduceOpen.length > 0) {
     if (node9Open.length > 0) lines.push("");
     lines.push("  " + chalk27.yellow.bold("\u{1F512} AVAILABLE \u2014 turn on to harden (each has a tradeoff)"));
-    for (const f of reduceOpen) lines.push(...renderFinding(f, true));
+    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("  " + chalk27.bold("\u{1F9F1} YOUR PART \u2014 node9 can't fix these (OS-level)"));
-    for (const f of osOpen) lines.push(...renderFinding(f));
+    for (const f of osOpen) lines.push(...renderFinding(f, false, openLabel(f)));
   }
   for (const cat of result.passedCategories) {
     lines.push(`  ${chalk27.green("\u2705")} ${label(cat)}${chalk27.gray("no issues found")}`);
@@ -53389,7 +53960,7 @@ import chalk30 from "chalk";
 
 // src/ci-check/fetch.ts
 var import_undici = __toESM(require_undici());
-import fs61 from "fs";
+import fs62 from "fs";
 import path58 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 var cachedGhToken;
@@ -53473,7 +54044,7 @@ function parseRepoUrl(input) {
 function isLocalPath(input) {
   if (input.startsWith(".") || input.startsWith("/") || input.startsWith("~")) return true;
   try {
-    return fs61.existsSync(input) && fs61.statSync(input).isDirectory();
+    return fs62.existsSync(input) && fs62.statSync(input).isDirectory();
   } catch {
     return false;
   }
@@ -53590,8 +54161,8 @@ function readLocalTree(dir) {
   const add = (rel) => {
     const abs = path58.join(root, rel);
     try {
-      if (fs61.existsSync(abs) && fs61.statSync(abs).isFile()) {
-        files.push({ path: rel, content: fs61.readFileSync(abs, "utf8") });
+      if (fs62.existsSync(abs) && fs62.statSync(abs).isFile()) {
+        files.push({ path: rel, content: fs62.readFileSync(abs, "utf8") });
       }
     } catch {
     }
@@ -53611,7 +54182,7 @@ function readLocalTree(dir) {
     dirsVisited++;
     let entries;
     try {
-      entries = fs61.readdirSync(path58.join(root, relDir), { withFileTypes: true });
+      entries = fs62.readdirSync(path58.join(root, relDir), { withFileTypes: true });
     } catch {
       return;
     }
@@ -53634,8 +54205,8 @@ function readLocalTree(dir) {
   for (const rel of matches) collect(rel);
   const wfDir = path58.join(root, WORKFLOW_DIR);
   try {
-    if (fs61.existsSync(wfDir)) {
-      for (const name of fs61.readdirSync(wfDir)) {
+    if (fs62.existsSync(wfDir)) {
+      for (const name of fs62.readdirSync(wfDir)) {
         if (/\.ya?ml$/.test(name)) add(path58.join(WORKFLOW_DIR, name));
       }
     }
@@ -54776,7 +55347,7 @@ import chalk32 from "chalk";
 // src/shields/jail.ts
 init_build();
 init_shields();
-import fs62 from "fs";
+import fs63 from "fs";
 import os54 from "os";
 import path59 from "path";
 var USER_JAIL_SHIELD = "user-jail";
@@ -54786,7 +55357,7 @@ function jailStorePath() {
 function readJailPaths() {
   let text;
   try {
-    text = fs62.readFileSync(jailStorePath(), "utf8");
+    text = fs63.readFileSync(jailStorePath(), "utf8");
   } catch (err2) {
     if (err2.code === "ENOENT") return [];
     throw err2;
@@ -54804,8 +55375,8 @@ function readJailPaths() {
 }
 function writeJailPaths(paths) {
   const p = jailStorePath();
-  fs62.mkdirSync(path59.dirname(p), { recursive: true });
-  fs62.writeFileSync(p, JSON.stringify({ paths }, null, 2) + "\n", { mode: 384 });
+  fs63.mkdirSync(path59.dirname(p), { recursive: true });
+  fs63.writeFileSync(p, JSON.stringify({ paths }, null, 2) + "\n", { mode: 384 });
 }
 function addJailPath(rawPath, verdict) {
   const norm = rawPath.trim();
@@ -54834,7 +55405,7 @@ function regenerateUserJail(paths) {
       writeActiveShields(active2.filter((s) => s !== USER_JAIL_SHIELD));
     }
     try {
-      fs62.rmSync(file, { force: true });
+      fs63.rmSync(file, { force: true });
     } catch {
     }
     return;
@@ -54949,12 +55520,12 @@ function registerJailCommand(program2) {
 // src/cli/commands/sandbox.ts
 init_config();
 import chalk33 from "chalk";
-import fs65 from "fs";
+import fs66 from "fs";
 import path62 from "path";
 import { spawnSync as spawnSync6 } from "child_process";
 
 // src/sandbox/config.ts
-import fs63 from "fs";
+import fs64 from "fs";
 import path60 from "path";
 import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
 var SANDBOX_CONFIG_FILE = "node9.sandbox.yaml";
@@ -55032,12 +55603,12 @@ function sandboxConfigPath(cwd = process.cwd()) {
 }
 function loadSandboxConfig(cwd = process.cwd(), fallbackAgent = "claude") {
   const p = sandboxConfigPath(cwd);
-  if (!fs63.existsSync(p)) {
+  if (!fs64.existsSync(p)) {
     throw new Error(`sandbox: ${SANDBOX_CONFIG_FILE} not found \u2014 run \`node9 sandbox new\` first.`);
   }
   let raw;
   try {
-    raw = parseYaml2(fs63.readFileSync(p, "utf-8"));
+    raw = parseYaml2(fs64.readFileSync(p, "utf-8"));
   } catch (err2) {
     throw new Error(
       `sandbox: ${SANDBOX_CONFIG_FILE} is not valid YAML \u2014 ${err2.message}`
@@ -55096,7 +55667,7 @@ init_templates();
 
 // src/sandbox/runtime.ts
 init_templates();
-import fs64 from "fs";
+import fs65 from "fs";
 import os55 from "os";
 import path61 from "path";
 import crypto9 from "crypto";
@@ -55123,7 +55694,7 @@ function buildRunArgs(opts) {
   args.push("-v", `${allowlistHostPath}:${ALLOWED_DOMAINS_PATH}:ro`);
   if (config.node9.mountAgentCredentials) {
     const creds = agentCredentialsMount(config.agent);
-    if (fs64.existsSync(creds.hostPath)) {
+    if (fs65.existsSync(creds.hostPath)) {
       args.push("-v", `${creds.hostPath}:${creds.target}`);
     }
   }
@@ -55145,16 +55716,16 @@ function sandboxBuildDir(cwd = process.cwd()) {
 }
 function writeBuildContext(cwd, dockerfile, entrypoint) {
   const dir = sandboxBuildDir(cwd);
-  fs64.mkdirSync(dir, { recursive: true });
-  fs64.writeFileSync(path61.join(dir, "Dockerfile"), dockerfile);
-  fs64.writeFileSync(path61.join(dir, "entrypoint.sh"), entrypoint);
+  fs65.mkdirSync(dir, { recursive: true });
+  fs65.writeFileSync(path61.join(dir, "Dockerfile"), dockerfile);
+  fs65.writeFileSync(path61.join(dir, "entrypoint.sh"), entrypoint);
   return dir;
 }
 function writeAllowlist(cwd, hosts) {
   const dir = path61.join(cwd, ".node9", "sandbox");
-  fs64.mkdirSync(dir, { recursive: true });
+  fs65.mkdirSync(dir, { recursive: true });
   const p = path61.join(dir, "allowed-domains.txt");
-  fs64.writeFileSync(p, hosts.join("\n") + "\n");
+  fs65.writeFileSync(p, hosts.join("\n") + "\n");
   return p;
 }
 function resolveHomePath(p) {
@@ -55163,7 +55734,7 @@ function resolveHomePath(p) {
 
 // src/cli/commands/sandbox.ts
 function seedDataDirConfig(dataDir, sandbox) {
-  fs65.mkdirSync(dataDir, { recursive: true });
+  fs66.mkdirSync(dataDir, { recursive: true });
   const configPath = path62.join(dataDir, "config.json");
   const seed = {
     settings: {
@@ -55175,7 +55746,7 @@ function seedDataDirConfig(dataDir, sandbox) {
       }
     }
   };
-  fs65.writeFileSync(configPath, JSON.stringify(seed, null, 2), { mode: 384 });
+  fs66.writeFileSync(configPath, JSON.stringify(seed, null, 2), { mode: 384 });
 }
 function registerSandboxCommand(program2, version2) {
   const node9Version2 = pinnedNode9Version(version2);
@@ -55183,13 +55754,13 @@ function registerSandboxCommand(program2, version2) {
   cmd.command("new").description(`Scaffold ${SANDBOX_CONFIG_FILE} in this project`).option("--agent <agent>", "claude (default) or codex", "claude").action((opts) => {
     const agent = opts.agent === "codex" ? "codex" : "claude";
     const p = sandboxConfigPath();
-    if (fs65.existsSync(p)) {
+    if (fs66.existsSync(p)) {
       console.log(
         chalk33.yellow(`  ${SANDBOX_CONFIG_FILE} already exists \u2014 leaving it untouched.`)
       );
       return;
     }
-    fs65.writeFileSync(p, scaffoldSandboxYaml(agent));
+    fs66.writeFileSync(p, scaffoldSandboxYaml(agent));
     console.log(
       chalk33.green(`  \u2713 wrote ${SANDBOX_CONFIG_FILE}`) + chalk33.dim(` (agent: ${agent})`)
     );
@@ -55230,7 +55801,7 @@ function registerSandboxCommand(program2, version2) {
     const hash = imageContentHash(dockerfile, entrypoint);
     const image = sandbox.runtime.image;
     const hashFile = path62.join(sandboxBuildDir(cwd), ".image-hash");
-    const lastHash = fs65.existsSync(hashFile) ? fs65.readFileSync(hashFile, "utf-8").trim() : "";
+    const lastHash = fs66.existsSync(hashFile) ? fs66.readFileSync(hashFile, "utf-8").trim() : "";
     const imageExists = spawnSync6(sandbox.runtime.engine, ["image", "inspect", image], { stdio: "ignore" }).status === 0;
     const needBuild = sandbox.runtime.rebuild === "always" || !imageExists || sandbox.runtime.rebuild !== "never" && lastHash !== hash;
     if (needBuild) {
@@ -55242,7 +55813,7 @@ function registerSandboxCommand(program2, version2) {
         console.error(chalk33.red("  build failed."));
         process.exit(b.status ?? 1);
       }
-      fs65.writeFileSync(hashFile, hash);
+      fs66.writeFileSync(hashFile, hash);
     }
     const dataDir = sandboxDataDir(cwd);
     seedDataDirConfig(dataDir, sandbox);
@@ -55256,7 +55827,7 @@ function registerSandboxCommand(program2, version2) {
     });
     if (sandbox.node9.mountAgentCredentials) {
       const creds = agentCredentialsMount(sandbox.agent);
-      if (fs65.existsSync(creds.hostPath)) {
+      if (fs66.existsSync(creds.hostPath)) {
         console.log(chalk33.dim(`  mounting ${creds.hostPath} (agent credentials, rw)`));
       } else {
         console.log(
@@ -55273,7 +55844,7 @@ function registerSandboxCommand(program2, version2) {
   });
   cmd.command("tail").description("Stream the sandbox's audit log (host-side)").action(() => {
     const auditPath = path62.join(sandboxDataDir(), "audit.log");
-    if (!fs65.existsSync(auditPath)) {
+    if (!fs66.existsSync(auditPath)) {
       console.log(chalk33.dim("  no sandbox audit yet."));
       return;
     }
@@ -55281,11 +55852,11 @@ function registerSandboxCommand(program2, version2) {
   });
   cmd.command("logs").description("Dump the sandbox's audit log").action(() => {
     const auditPath = path62.join(sandboxDataDir(), "audit.log");
-    if (!fs65.existsSync(auditPath)) {
+    if (!fs66.existsSync(auditPath)) {
       console.log(chalk33.dim("  no sandbox audit yet."));
       return;
     }
-    process.stdout.write(fs65.readFileSync(auditPath, "utf-8"));
+    process.stdout.write(fs66.readFileSync(auditPath, "utf-8"));
   });
   cmd.command("clean").description("Remove the sandbox image, build context, and data").action(() => {
     const cwd = process.cwd();
@@ -55299,18 +55870,19 @@ function registerSandboxCommand(program2, version2) {
         stdio: "ignore"
       });
     }
-    fs65.rmSync(path62.join(cwd, ".node9", "sandbox"), { recursive: true, force: true });
+    fs66.rmSync(path62.join(cwd, ".node9", "sandbox"), { recursive: true, force: true });
     console.log(chalk33.green("  \u2713 sandbox image + build + data removed."));
   });
 }
 
 // src/cli/commands/sessions.ts
+init_decision();
 init_scan_summary();
 init_litellm();
 init_cost_gemini();
 init_cost_codex();
 import chalk34 from "chalk";
-import fs66 from "fs";
+import fs67 from "fs";
 import path63 from "path";
 import os56 from "os";
 function modelPrice(model) {
@@ -55404,7 +55976,7 @@ function loadAuditEntries(auditPath) {
   const aPath = auditPath ?? path63.join(os56.homedir(), ".node9", "audit.log");
   let raw;
   try {
-    raw = fs66.readFileSync(aPath, "utf-8");
+    raw = fs67.readFileSync(aPath, "utf-8");
   } catch {
     return [];
   }
@@ -55414,7 +55986,7 @@ function loadAuditEntries(auditPath) {
     try {
       const e = JSON.parse(line);
       if (!e.ts || !e.tool || !e.decision) continue;
-      if (e.decision === "allow" || e.decision === "allowed") continue;
+      if (classifyDecision(e).outcome === "allow") continue;
       entries.push(e);
     } catch {
     }
@@ -55441,7 +56013,7 @@ function auditEntriesInWindow(entries, windowStart, windowEnd) {
 }
 function buildGeminiSessions(days, allAuditEntries) {
   const tmpDir = path63.join(os56.homedir(), ".gemini", "tmp");
-  if (!fs66.existsSync(tmpDir)) return [];
+  if (!fs67.existsSync(tmpDir)) return [];
   const cutoff = days !== null ? (() => {
     const d = /* @__PURE__ */ new Date();
     d.setDate(d.getDate() - days);
@@ -55450,7 +56022,7 @@ function buildGeminiSessions(days, allAuditEntries) {
   })() : null;
   let slugDirs;
   try {
-    slugDirs = fs66.readdirSync(tmpDir);
+    slugDirs = fs67.readdirSync(tmpDir);
   } catch {
     return [];
   }
@@ -55458,27 +56030,27 @@ function buildGeminiSessions(days, allAuditEntries) {
   for (const slug2 of slugDirs) {
     const slugPath = path63.join(tmpDir, slug2);
     try {
-      if (!fs66.statSync(slugPath).isDirectory()) continue;
+      if (!fs67.statSync(slugPath).isDirectory()) continue;
     } catch {
       continue;
     }
     let projectRoot = path63.join(os56.homedir(), slug2);
     try {
-      projectRoot = fs66.readFileSync(path63.join(slugPath, ".project_root"), "utf-8").trim();
+      projectRoot = fs67.readFileSync(path63.join(slugPath, ".project_root"), "utf-8").trim();
     } catch {
     }
     const chatsDir = path63.join(slugPath, "chats");
-    if (!fs66.existsSync(chatsDir)) continue;
+    if (!fs67.existsSync(chatsDir)) continue;
     let chatFiles;
     try {
-      chatFiles = fs66.readdirSync(chatsDir).filter((f) => f.endsWith(".json"));
+      chatFiles = fs67.readdirSync(chatsDir).filter((f) => f.endsWith(".json"));
     } catch {
       continue;
     }
     for (const chatFile of chatFiles) {
       let raw;
       try {
-        raw = fs66.readFileSync(path63.join(chatsDir, chatFile), "utf-8");
+        raw = fs67.readFileSync(path63.join(chatsDir, chatFile), "utf-8");
       } catch {
         continue;
       }
@@ -55559,7 +56131,7 @@ function buildGeminiSessions(days, allAuditEntries) {
 }
 function buildCodexSessions(days, allAuditEntries) {
   const sessionsBase = path63.join(os56.homedir(), ".codex", "sessions");
-  if (!fs66.existsSync(sessionsBase)) return [];
+  if (!fs67.existsSync(sessionsBase)) return [];
   const cutoff = days !== null ? (() => {
     const d = /* @__PURE__ */ new Date();
     d.setDate(d.getDate() - days);
@@ -55568,28 +56140,28 @@ function buildCodexSessions(days, allAuditEntries) {
   })() : null;
   const jsonlFiles = [];
   try {
-    for (const year of fs66.readdirSync(sessionsBase)) {
+    for (const year of fs67.readdirSync(sessionsBase)) {
       const yearPath = path63.join(sessionsBase, year);
       try {
-        if (!fs66.statSync(yearPath).isDirectory()) continue;
+        if (!fs67.statSync(yearPath).isDirectory()) continue;
       } catch {
         continue;
       }
-      for (const month of fs66.readdirSync(yearPath)) {
+      for (const month of fs67.readdirSync(yearPath)) {
         const monthPath = path63.join(yearPath, month);
         try {
-          if (!fs66.statSync(monthPath).isDirectory()) continue;
+          if (!fs67.statSync(monthPath).isDirectory()) continue;
         } catch {
           continue;
         }
-        for (const day of fs66.readdirSync(monthPath)) {
+        for (const day of fs67.readdirSync(monthPath)) {
           const dayPath = path63.join(monthPath, day);
           try {
-            if (!fs66.statSync(dayPath).isDirectory()) continue;
+            if (!fs67.statSync(dayPath).isDirectory()) continue;
           } catch {
             continue;
           }
-          for (const file of fs66.readdirSync(dayPath)) {
+          for (const file of fs67.readdirSync(dayPath)) {
             if (file.endsWith(".jsonl")) jsonlFiles.push(path63.join(dayPath, file));
           }
         }
@@ -55602,7 +56174,7 @@ function buildCodexSessions(days, allAuditEntries) {
   for (const filePath of jsonlFiles) {
     let lines;
     try {
-      lines = fs66.readFileSync(filePath, "utf-8").split("\n");
+      lines = fs67.readFileSync(filePath, "utf-8").split("\n");
     } catch {
       continue;
     }
@@ -55691,7 +56263,7 @@ function buildSessions(days, historyPath) {
   const hPath = historyPath ?? path63.join(os56.homedir(), ".claude", "history.jsonl");
   let historyRaw = "";
   try {
-    historyRaw = fs66.readFileSync(hPath, "utf-8");
+    historyRaw = fs67.readFileSync(hPath, "utf-8");
   } catch {
   }
   const cutoff = days !== null ? (() => {
@@ -55715,7 +56287,7 @@ function buildSessions(days, historyPath) {
     const jsonlFile = sessionJsonlPath(entry.project, entry.sessionId);
     let sessionLines = [];
     try {
-      sessionLines = fs66.readFileSync(jsonlFile, "utf-8").split("\n");
+      sessionLines = fs67.readFileSync(jsonlFile, "utf-8").split("\n");
     } catch {
     }
     const { toolCalls, costUSD, hasSnapshot, modifiedFiles } = parseSessionLines(sessionLines);
@@ -56109,12 +56681,12 @@ function registerSessionTaintCommand(program2) {
 
 // src/cli/commands/skill-pin.ts
 import chalk36 from "chalk";
-import fs67 from "fs";
+import fs68 from "fs";
 import os57 from "os";
 import path64 from "path";
 function wipeSkillSessions() {
   try {
-    fs67.rmSync(path64.join(os57.homedir(), ".node9", "skill-sessions"), {
+    fs68.rmSync(path64.join(os57.homedir(), ".node9", "skill-sessions"), {
       recursive: true,
       force: true
     });
@@ -56196,15 +56768,15 @@ function registerSkillPinCommand(program2) {
 }
 
 // src/cli/commands/decisions.ts
-import fs68 from "fs";
+import fs69 from "fs";
 import os58 from "os";
 import path65 from "path";
 import chalk37 from "chalk";
 var DECISIONS_FILE2 = path65.join(os58.homedir(), ".node9", "decisions.json");
 function readDecisions() {
   try {
-    if (!fs68.existsSync(DECISIONS_FILE2)) return {};
-    const raw = fs68.readFileSync(DECISIONS_FILE2, "utf-8");
+    if (!fs69.existsSync(DECISIONS_FILE2)) return {};
+    const raw = fs69.readFileSync(DECISIONS_FILE2, "utf-8");
     const parsed = JSON.parse(raw);
     const out = {};
     for (const [k, v] of Object.entries(parsed)) {
@@ -56217,10 +56789,10 @@ function readDecisions() {
 }
 function writeDecisions(d) {
   const dir = path65.dirname(DECISIONS_FILE2);
-  if (!fs68.existsSync(dir)) fs68.mkdirSync(dir, { recursive: true });
+  if (!fs69.existsSync(dir)) fs69.mkdirSync(dir, { recursive: true });
   const tmp = `${DECISIONS_FILE2}.${process.pid}.tmp`;
-  fs68.writeFileSync(tmp, JSON.stringify(d, null, 2));
-  fs68.renameSync(tmp, DECISIONS_FILE2);
+  fs69.writeFileSync(tmp, JSON.stringify(d, null, 2));
+  fs69.renameSync(tmp, DECISIONS_FILE2);
 }
 function registerDecisionsCommand(program2) {
   const cmd = program2.command("decisions").description('Manage persistent "Always Allow" / "Always Deny" tool decisions');
@@ -56277,7 +56849,7 @@ Persistent decisions  (${entries.length})
 
 // src/cli/commands/dlp.ts
 import chalk38 from "chalk";
-import fs69 from "fs";
+import fs70 from "fs";
 import path66 from "path";
 import os59 from "os";
 var AUDIT_LOG = path66.join(os59.homedir(), ".node9", "audit.log");
@@ -56288,7 +56860,7 @@ function stripAnsi(s) {
 }
 function loadResolved() {
   try {
-    const raw = JSON.parse(fs69.readFileSync(RESOLVED_FILE, "utf-8"));
+    const raw = JSON.parse(fs70.readFileSync(RESOLVED_FILE, "utf-8"));
     return new Set(raw);
   } catch {
     return /* @__PURE__ */ new Set();
@@ -56296,13 +56868,13 @@ function loadResolved() {
 }
 function saveResolved(resolved) {
   try {
-    fs69.writeFileSync(RESOLVED_FILE, JSON.stringify([...resolved], null, 2), { mode: 384 });
+    fs70.writeFileSync(RESOLVED_FILE, JSON.stringify([...resolved], null, 2), { mode: 384 });
   } catch {
   }
 }
 function loadDlpFindings() {
-  if (!fs69.existsSync(AUDIT_LOG)) return [];
-  return fs69.readFileSync(AUDIT_LOG, "utf-8").split("\n").flatMap((line) => {
+  if (!fs70.existsSync(AUDIT_LOG)) return [];
+  return fs70.readFileSync(AUDIT_LOG, "utf-8").split("\n").flatMap((line) => {
     if (!line.trim()) return [];
     try {
       const e = JSON.parse(line);
@@ -56401,13 +56973,13 @@ function registerDlpCommand(program2) {
 // src/cli/commands/mask.ts
 init_dlp();
 import chalk39 from "chalk";
-import fs70 from "fs";
+import fs71 from "fs";
 import path67 from "path";
 import os60 from "os";
 function findJsonlFiles(dir) {
   const results = [];
-  if (!fs70.existsSync(dir)) return results;
-  for (const entry of fs70.readdirSync(dir, { withFileTypes: true })) {
+  if (!fs71.existsSync(dir)) return results;
+  for (const entry of fs71.readdirSync(dir, { withFileTypes: true })) {
     const full = path67.join(dir, entry.name);
     if (entry.isDirectory()) results.push(...findJsonlFiles(full));
     else if (entry.isFile() && entry.name.endsWith(".jsonl")) results.push(full);
@@ -56451,7 +57023,7 @@ function redactJson(obj) {
 function processFile(filePath, dryRun) {
   let raw;
   try {
-    raw = fs70.readFileSync(filePath, "utf-8");
+    raw = fs71.readFileSync(filePath, "utf-8");
   } catch {
     return { redactedLines: 0, patterns: [] };
   }
@@ -56483,14 +57055,14 @@ function processFile(filePath, dryRun) {
     }
   }
   if (!dryRun && redactedLines > 0) {
-    fs70.writeFileSync(filePath, newLines.join("\n"), "utf-8");
+    fs71.writeFileSync(filePath, newLines.join("\n"), "utf-8");
   }
   return { redactedLines, patterns };
 }
 function processJsonFile(filePath, dryRun) {
   let raw;
   try {
-    raw = fs70.readFileSync(filePath, "utf-8");
+    raw = fs71.readFileSync(filePath, "utf-8");
   } catch {
     return { redactedLines: 0, patterns: [] };
   }
@@ -56503,14 +57075,14 @@ function processJsonFile(filePath, dryRun) {
   const { value, modified, found } = redactJson(parsed);
   if (!modified) return { redactedLines: 0, patterns: [] };
   if (!dryRun) {
-    fs70.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
+    fs71.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
   }
   return { redactedLines: 1, patterns: found };
 }
 function findJsonFiles(dir) {
   const results = [];
-  if (!fs70.existsSync(dir)) return results;
-  for (const entry of fs70.readdirSync(dir, { withFileTypes: true })) {
+  if (!fs71.existsSync(dir)) return results;
+  for (const entry of fs71.readdirSync(dir, { withFileTypes: true })) {
     const full = path67.join(dir, entry.name);
     if (entry.isDirectory()) results.push(...findJsonFiles(full));
     else if (entry.isFile() && entry.name.endsWith(".json")) results.push(full);
@@ -56530,7 +57102,7 @@ function registerMaskCommand(program2) {
     const cutoff = options.all ? null : new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3);
     const filtered = cutoff ? allFiles.filter((f) => {
       try {
-        return fs70.statSync(f.path).mtime >= cutoff;
+        return fs71.statSync(f.path).mtime >= cutoff;
       } catch {
         return false;
       }
@@ -56586,7 +57158,7 @@ function registerMaskCommand(program2) {
 // src/cli.ts
 init_blast();
 var { version } = JSON.parse(
-  fs73.readFileSync(path70.join(__dirname, "../package.json"), "utf-8")
+  fs74.readFileSync(path70.join(__dirname, "../package.json"), "utf-8")
 );
 var program = new Command();
 program.name("node9").description("The Sudo Command for AI Agents").version(version);
@@ -56766,14 +57338,14 @@ program.command("uninstall").description("Remove all Node9 hooks and optionally
   }
   if (options.purge) {
     const node9Dir = path70.join(os63.homedir(), ".node9");
-    if (fs73.existsSync(node9Dir)) {
+    if (fs74.existsSync(node9Dir)) {
       const confirmed = await confirm2({
         message: `Permanently delete ${node9Dir} (config, audit log, credentials)?`,
         default: false
       });
       if (confirmed) {
-        fs73.rmSync(node9Dir, { recursive: true });
-        if (fs73.existsSync(node9Dir)) {
+        fs74.rmSync(node9Dir, { recursive: true });
+        if (fs74.existsSync(node9Dir)) {
           console.error(
             chalk41.red("\n  \u26A0\uFE0F  ~/.node9/ could not be fully deleted \u2014 remove it manually.")
           );
@@ -56938,12 +57510,12 @@ Run "node9 addto claude" to register it as the statusLine.`
   if (subcommand === "debug") {
     const flagFile = path70.join(os63.homedir(), ".node9", "hud-debug");
     if (state === "on") {
-      fs73.mkdirSync(path70.dirname(flagFile), { recursive: true });
-      fs73.writeFileSync(flagFile, "");
+      fs74.mkdirSync(path70.dirname(flagFile), { recursive: true });
+      fs74.writeFileSync(flagFile, "");
       console.log("HUD debug logging enabled \u2192 ~/.node9/hud-debug.log");
       console.log("Tail it with: tail -f ~/.node9/hud-debug.log");
     } else if (state === "off") {
-      if (fs73.existsSync(flagFile)) fs73.unlinkSync(flagFile);
+      if (fs74.existsSync(flagFile)) fs74.unlinkSync(flagFile);
       console.log("HUD debug logging disabled.");
     } else {
       console.error("Usage: node9 hud debug on|off");
@@ -57068,7 +57640,7 @@ if (process.argv[2] !== "daemon") {
       if (process.env.NODE9_DEBUG === "1" || getConfig().settings.enableHookLogDebug) {
         const logPath = path70.join(os63.homedir(), ".node9", "hook-debug.log");
         const msg = reason instanceof Error ? reason.message : String(reason);
-        fs73.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] UNHANDLED: ${msg}
+        fs74.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] UNHANDLED: ${msg}
 `);
       }
       process.exit(0);