@node9/proxy 1.63.0 → 1.64.0

package/dist/cli.js

@@ -343,6 +343,7 @@ var init_config_schema = __esm({
         // nudge-only (default), and the scan cadence in minutes.
         mcpAutoWrap: import_zod.z.boolean().optional(),
         mcpReconcileIntervalMinutes: import_zod.z.number().positive().optional(),
+        mcpStaleAfterDays: import_zod.z.number().min(0).optional(),
         cloudSyncIntervalHours: import_zod.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)
@@ -3977,6 +3978,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",
@@ -3985,7 +3987,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"
             }
           ],
@@ -3999,7 +4001,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"
             }
           ],
@@ -4013,7 +4015,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"
             }
           ],
@@ -4027,7 +4029,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"
             }
           ],
@@ -4041,7 +4043,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"
             }
           ],
@@ -4608,6 +4610,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 = import_fs4.default.readFileSync(cacheFile, "utf-8");
+      existed = true;
+    } catch (err2) {
+      if (err2.code === "ENOENT") return {};
+      continue;
+    }
+    try {
+      return JSON.parse(content);
+    } catch {
+    }
+  }
+  if (existed) {
+    const backup = import_path4.default.join(import_path4.default.dirname(cacheFile), "rules-cache.last-good.json");
+    if (backup !== cacheFile) {
+      try {
+        const raw = JSON.parse(import_fs4.default.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 {
+    import_fs4.default.appendFileSync(
+      import_path4.default.join(import_os4.default.homedir(), ".node9", "hook-debug.log"),
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] ${kind} ${cacheFile}
+`
+    );
+  } catch {
+  }
+}
 function getConfig(cwd) {
   if (!cwd && cachedConfig) return cachedConfig;
   const globalPath = import_path4.default.join(import_os4.default.homedir(), ".node9", "config.json");
@@ -4675,6 +4719,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);
@@ -4684,12 +4729,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;
@@ -4754,10 +4800,12 @@ function getConfig(cwd) {
   applyLayer(globalConfig);
   applyLayer(projectConfig);
   let cloudManagedShields = [];
+  let modeCloudControlled = false;
+  let modeCloudStaged = false;
   {
     const cacheFile = import_path4.default.join(import_os4.default.homedir(), ".node9", "rules-cache.json");
     try {
-      const raw = JSON.parse(import_fs4.default.readFileSync(cacheFile, "utf-8"));
+      const raw = readRulesCacheResilient(cacheFile);
       if (Array.isArray(raw.rules) && raw.rules.length > 0) {
         applyLayer({ policy: { smartRules: raw.rules } });
       }
@@ -4774,6 +4822,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(
@@ -4872,19 +4923,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
@@ -4900,7 +4960,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)];
@@ -4969,7 +5049,7 @@ ${error.replace("Invalid config:\n", "")}
   }
   return sanitized;
 }
-var import_fs4, import_path4, import_os4, DANGEROUS_WORDS, DEFAULT_CONFIG, ADVISORY_SMART_RULES, cachedConfig;
+var import_fs4, import_path4, import_os4, DANGEROUS_WORDS, DEFAULT_CONFIG, ADVISORY_SMART_RULES, cachedConfig, cacheReadFailureLogged;
 var init_config = __esm({
   "src/config/index.ts"() {
     "use strict";
@@ -4981,6 +5061,7 @@ var init_config = __esm({
     init_managed();
     init_build();
     init_trusted_hosts();
+    init_dist();
     DANGEROUS_WORDS = [
       "mkfs",
       // formats/wipes a filesystem partition
@@ -5258,6 +5339,7 @@ var init_config = __esm({
       }
     ];
     cachedConfig = null;
+    cacheReadFailureLogged = false;
   }
 });
 
@@ -5975,6 +6057,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();
@@ -6859,6 +6953,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 = (0, import_crypto5.randomUUID)();
@@ -7173,6 +7273,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);
@@ -7189,7 +7318,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,
@@ -7211,36 +7340,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(
@@ -7252,7 +7358,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" };
@@ -15919,6 +16025,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 = {
@@ -17156,18 +17265,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;
@@ -17190,13 +17308,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 };
 }
@@ -17734,6 +17855,21 @@ function inventoryMcp(home = import_os31.default.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 = {};
@@ -17761,6 +17897,7 @@ var init_mcp_wrap = __esm({
     import_smol_toml4 = require("smol-toml");
     init_agent_wiring();
     init_mcp_cmd();
+    init_mcp_pin();
     init_mcp_cmd();
   }
 });
@@ -18189,9 +18326,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 = import_path34.default.dirname(rulesCacheFile());
-  if (!import_fs35.default.existsSync(dir)) import_fs35.default.mkdirSync(dir, { recursive: true });
-  import_fs35.default.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();
@@ -18485,7 +18625,7 @@ function startForensicBroadcast() {
   const recurring = setInterval(() => void tick(), FORENSIC_BROADCAST_INTERVAL_MS);
   recurring.unref();
 }
-var import_fs35, import_https4, import_os32, import_path34, 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 import_fs35, import_https4, import_os32, import_path34, 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";
@@ -18499,6 +18639,7 @@ var init_sync = __esm({
     init_ship();
     init_build2();
     init_mcp_tools();
+    init_state2();
     init_mcp_status();
     init_ship2();
     init_shields();
@@ -18519,6 +18660,7 @@ var init_sync = __esm({
       "long-output-redacted": "longOutputRedactions"
     };
     rulesCacheFile = () => import_path34.default.join(import_os32.default.homedir(), ".node9", "rules-cache.json");
+    rulesCacheBackupFile = () => import_path34.default.join(import_os32.default.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;
@@ -18760,6 +18902,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
 function loadIndex() {
   try {
@@ -18995,6 +19184,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();
@@ -19034,6 +19224,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 {
@@ -19055,7 +19316,7 @@ function startMcpReconciler() {
   };
   schedule();
 }
-var import_fs38, import_path37, import_os35, import_crypto10, BASELINE_FILE2, BASELINE_CAP, DEFAULT_INTERVAL_MIN;
+var import_fs38, import_path37, import_os35, import_crypto10, BASELINE_FILE2, BASELINE_CAP, DEFAULT_INTERVAL_MIN, DEFAULT_STALE_DAYS;
 var init_mcp_reconciler = __esm({
   "src/daemon/mcp-reconciler.ts"() {
     "use strict";
@@ -19068,9 +19329,11 @@ var init_mcp_reconciler = __esm({
     init_config();
     init_cloud();
     init_audit();
+    init_mcp_pin();
     BASELINE_FILE2 = import_path37.default.join(import_os35.default.homedir(), ".node9", "mcp-baseline.json");
     BASELINE_CAP = 500;
     DEFAULT_INTERVAL_MIN = 60;
+    DEFAULT_STALE_DAYS = 7;
   }
 });
 
@@ -19142,20 +19405,87 @@ var init_hook_heal = __esm({
 });
 
 // src/daemon/startup-log.ts
+function capStartupLog(file) {
+  try {
+    if (import_fs39.default.statSync(file).size > MAX_STARTUP_LOG_BYTES) import_fs39.default.truncateSync(file);
+  } catch {
+  }
+}
 function openStartupLogFd() {
   try {
     const file = DAEMON_STARTUP_LOG();
     const dir = import_path38.default.dirname(file);
     if (!import_fs39.default.existsSync(dir)) import_fs39.default.mkdirSync(dir, { recursive: true });
-    try {
-      if (import_fs39.default.statSync(file).size > MAX_STARTUP_LOG_BYTES) import_fs39.default.truncateSync(file);
-    } catch {
-    }
+    capStartupLog(file);
     return import_fs39.default.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 = import_path38.default.dirname(file);
+    if (!import_fs39.default.existsSync(dir)) import_fs39.default.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 {
+      import_fs39.default.writeFileSync(tmp, JSON.stringify(state), "utf-8");
+      import_fs39.default.renameSync(tmp, file);
+    } catch (err2) {
+      try {
+        import_fs39.default.unlinkSync(tmp);
+      } catch {
+      }
+      throw err2;
+    }
+  } catch {
+  }
+}
+function readStartupState() {
+  try {
+    const raw = import_fs39.default.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();
@@ -19167,7 +19497,7 @@ function logDaemonStartup(kind, detail) {
   } catch {
   }
 }
-var import_fs39, import_path38, import_os36, DAEMON_STARTUP_LOG, MAX_STARTUP_LOG_BYTES;
+var import_fs39, import_path38, import_os36, 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";
@@ -19176,10 +19506,83 @@ var init_startup_log = __esm({
     import_os36 = __toESM(require("os"));
     DAEMON_STARTUP_LOG = () => import_path38.default.join(import_os36.default.homedir(), ".node9", "daemon-startup.log");
     MAX_STARTUP_LOG_BYTES = 256 * 1024;
+    DAEMON_STARTUP_STATE = () => import_path38.default.join(import_os36.default.homedir(), ".node9", "daemon-startup-state.json");
+    MAX_DETAIL = 200;
+    STARTING_GRACE_MS = 90 * 1e3;
   }
 });
 
 // src/daemon/server.ts
+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();
@@ -19194,6 +19597,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 = (0, import_crypto11.randomUUID)();
@@ -19566,6 +19970,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);
@@ -19667,75 +20075,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" }));
@@ -20038,6 +20379,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 {
@@ -20045,6 +20403,7 @@ data: ${JSON.stringify(item.data)}
           const { pid } = JSON.parse(import_fs40.default.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 {
@@ -20052,13 +20411,14 @@ data: ${JSON.stringify(item.data)}
           import_fs40.default.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 = (0, import_child_process2.spawnSync)("ss", ["-Htnp", `sport = :${DAEMON_PORT}`], {
@@ -20086,19 +20446,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(import_chalk6.default.red("\n\u{1F6D1} Node9 Daemon Error:"), e.message);
     process.exit(1);
   });
@@ -20116,6 +20495,8 @@ data: ${JSON.stringify(item.data)}
       { mode: 384 }
     );
     console.error(import_chalk6.default.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(import_chalk6.default.cyan("\u{1F6F0}\uFE0F  Flight Recorder active \u2014 daemon will not idle-timeout"));
@@ -20141,6 +20522,7 @@ var init_server = __esm({
     init_costSync();
     init_sync();
     init_audit_shipper();
+    init_decision();
     init_dlp_scanner();
     init_mcp_reconciler();
     init_hook_heal();
@@ -45343,19 +45725,19 @@ function getModelContextLimit(model) {
 }
 function readSessionUsage() {
   const projectsDir = import_path67.default.join(import_os60.default.homedir(), ".claude", "projects");
-  if (!import_fs70.default.existsSync(projectsDir)) return null;
+  if (!import_fs71.default.existsSync(projectsDir)) return null;
   let latestFile = null;
   let latestMtime = 0;
   try {
-    for (const dir of import_fs70.default.readdirSync(projectsDir)) {
+    for (const dir of import_fs71.default.readdirSync(projectsDir)) {
       const dirPath = import_path67.default.join(projectsDir, dir);
       try {
-        if (!import_fs70.default.statSync(dirPath).isDirectory()) continue;
-        for (const file of import_fs70.default.readdirSync(dirPath)) {
+        if (!import_fs71.default.statSync(dirPath).isDirectory()) continue;
+        for (const file of import_fs71.default.readdirSync(dirPath)) {
           if (!file.endsWith(".jsonl") || file.startsWith("agent-")) continue;
           const filePath = import_path67.default.join(dirPath, file);
           try {
-            const mtime = import_fs70.default.statSync(filePath).mtimeMs;
+            const mtime = import_fs71.default.statSync(filePath).mtimeMs;
             if (mtime > latestMtime) {
               latestMtime = mtime;
               latestFile = filePath;
@@ -45370,7 +45752,7 @@ function readSessionUsage() {
   }
   if (!latestFile) return null;
   try {
-    const lines = import_fs70.default.readFileSync(latestFile, "utf-8").split("\n");
+    const lines = import_fs71.default.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 (import_fs70.default.existsSync(PID_FILE)) {
+  if (import_fs71.default.existsSync(PID_FILE)) {
     try {
-      const { port } = JSON.parse(import_fs70.default.readFileSync(PID_FILE, "utf-8"));
+      const { port } = JSON.parse(import_fs71.default.readFileSync(PID_FILE, "utf-8"));
       pidPort = port;
     } catch {
       console.error(import_chalk40.default.dim("\u26A0\uFE0F  Could not read PID file; falling back to default port."));
@@ -45487,12 +45869,21 @@ async function ensureDaemon() {
   } catch {
   }
   console.log(import_chalk40.default.dim("\u{1F6E1}\uFE0F  Starting Node9 daemon..."));
+  const startupFd = openStartupLogFd();
+  recordStartupState("starting");
   const child = (0, import_child_process14.spawn)(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 {
+      import_fs71.default.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 = import_path67.default.join(import_os60.default.homedir(), ".node9", "config.json");
   try {
-    const raw = JSON.parse(import_fs70.default.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(import_fs71.default.readFileSync(configPath, "utf-8"));
     const settings = raw.settings ?? {};
     return settings.approvers ?? {};
   } catch {
@@ -45648,13 +46039,13 @@ function approverStatusLine() {
 function toggleApprover(channel) {
   const configPath = import_path67.default.join(import_os60.default.homedir(), ".node9", "config.json");
   try {
-    const raw = JSON.parse(import_fs70.default.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(import_fs71.default.readFileSync(configPath, "utf-8"));
     const settings = raw.settings ?? {};
     const approvers = settings.approvers ?? {};
     approvers[channel] = approvers[channel] === false;
     settings.approvers = approvers;
     raw.settings = settings;
-    import_fs70.default.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+    import_fs71.default.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 {
-          import_fs70.default.appendFileSync(
+          import_fs71.default.appendFileSync(
             import_path67.default.join(import_os60.default.homedir(), ".node9", "hook-debug.log"),
             `[tail] POST /decision failed: ${String(err2)}
 `
@@ -45893,7 +46284,7 @@ async function startTail(options = {}) {
   }
   const auditLog = import_path67.default.join(import_os60.default.homedir(), ".node9", "audit.log");
   try {
-    const unackedDlp = import_fs70.default.readFileSync(auditLog, "utf-8").split("\n").filter((l) => l.includes('"response-dlp"')).length;
+    const unackedDlp = import_fs71.default.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 = import_fs70.default.statSync(auditLog).mtimeMs;
+      const auditMtime = import_fs71.default.statSync(auditLog).mtimeMs;
       if (Date.now() - auditMtime >= STALL_THRESHOLD_MS) return;
       console.log("");
       console.log(
@@ -46118,17 +46509,18 @@ async function startTail(options = {}) {
     process.exit(1);
   });
 }
-var import_http5, import_chalk40, import_fs70, import_os60, import_path67, import_readline6, import_child_process14, PID_FILE, ICONS, MODEL_CONTEXT_LIMITS, RESET2, BOLD2, RED, YELLOW, CYAN, GRAY, GREEN, HIDE_CURSOR, SHOW_CURSOR, ERASE_DOWN, pendingShownForId, pendingWrappedLines, DIVIDER;
+var import_http5, import_chalk40, import_fs71, import_os60, import_path67, import_readline6, import_child_process14, PID_FILE, ICONS, MODEL_CONTEXT_LIMITS, RESET2, BOLD2, RED, YELLOW, CYAN, GRAY, GREEN, HIDE_CURSOR, SHOW_CURSOR, ERASE_DOWN, pendingShownForId, pendingWrappedLines, DIVIDER;
 var init_tail = __esm({
   "src/tui/tail.ts"() {
     "use strict";
     import_http5 = __toESM(require("http"));
     import_chalk40 = __toESM(require("chalk"));
-    import_fs70 = __toESM(require("fs"));
+    import_fs71 = __toESM(require("fs"));
     import_os60 = __toESM(require("os"));
     import_path67 = __toESM(require("path"));
     import_readline6 = __toESM(require("readline"));
     import_child_process14 = require("child_process");
+    init_startup_log();
     init_daemon2();
     init_daemon();
     PID_FILE = import_path67.default.join(import_os60.default.homedir(), ".node9", "daemon.pid");
@@ -46253,9 +46645,9 @@ function formatTimeLeft(resetsAt) {
   return ` (${m}m left)`;
 }
 function safeReadJson(filePath) {
-  if (!import_fs71.default.existsSync(filePath)) return null;
+  if (!import_fs72.default.existsSync(filePath)) return null;
   try {
-    return JSON.parse(import_fs71.default.readFileSync(filePath, "utf-8"));
+    return JSON.parse(import_fs72.default.readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -46276,10 +46668,10 @@ function countHooksInFile(filePath) {
   return Object.keys(cfg.hooks).length;
 }
 function countRulesInDir(rulesDir) {
-  if (!import_fs71.default.existsSync(rulesDir)) return 0;
+  if (!import_fs72.default.existsSync(rulesDir)) return 0;
   let count = 0;
   try {
-    for (const entry of import_fs71.default.readdirSync(rulesDir, { withFileTypes: true })) {
+    for (const entry of import_fs72.default.readdirSync(rulesDir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
         count += countRulesInDir(import_path68.default.join(rulesDir, entry.name));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -46305,7 +46697,7 @@ function countConfigs(cwd) {
   let hooksCount = 0;
   const userMcpServers = /* @__PURE__ */ new Set();
   const projectMcpServers = /* @__PURE__ */ new Set();
-  if (import_fs71.default.existsSync(import_path68.default.join(claudeDir, "CLAUDE.md"))) claudeMdCount++;
+  if (import_fs72.default.existsSync(import_path68.default.join(claudeDir, "CLAUDE.md"))) claudeMdCount++;
   rulesCount += countRulesInDir(import_path68.default.join(claudeDir, "rules"));
   const userSettings = import_path68.default.join(claudeDir, "settings.json");
   for (const name of getMcpServerNames(userSettings)) userMcpServers.add(name);
@@ -46316,18 +46708,18 @@ function countConfigs(cwd) {
     userMcpServers.delete(name);
   }
   if (cwd) {
-    if (import_fs71.default.existsSync(import_path68.default.join(cwd, "CLAUDE.md"))) claudeMdCount++;
-    if (import_fs71.default.existsSync(import_path68.default.join(cwd, "CLAUDE.local.md"))) claudeMdCount++;
+    if (import_fs72.default.existsSync(import_path68.default.join(cwd, "CLAUDE.md"))) claudeMdCount++;
+    if (import_fs72.default.existsSync(import_path68.default.join(cwd, "CLAUDE.local.md"))) claudeMdCount++;
     const projectClaudeDir = import_path68.default.join(cwd, ".claude");
     const overlapsUserScope = isSamePath(projectClaudeDir, claudeDir);
     if (!overlapsUserScope) {
-      if (import_fs71.default.existsSync(import_path68.default.join(projectClaudeDir, "CLAUDE.md"))) claudeMdCount++;
+      if (import_fs72.default.existsSync(import_path68.default.join(projectClaudeDir, "CLAUDE.md"))) claudeMdCount++;
       rulesCount += countRulesInDir(import_path68.default.join(projectClaudeDir, "rules"));
       const projSettings = import_path68.default.join(projectClaudeDir, "settings.json");
       for (const name of getMcpServerNames(projSettings)) projectMcpServers.add(name);
       hooksCount += countHooksInFile(projSettings);
     }
-    if (import_fs71.default.existsSync(import_path68.default.join(projectClaudeDir, "CLAUDE.local.md"))) claudeMdCount++;
+    if (import_fs72.default.existsSync(import_path68.default.join(projectClaudeDir, "CLAUDE.local.md"))) claudeMdCount++;
     const localSettings = import_path68.default.join(projectClaudeDir, "settings.local.json");
     for (const name of getMcpServerNames(localSettings)) projectMcpServers.add(name);
     hooksCount += countHooksInFile(localSettings);
@@ -46365,11 +46757,11 @@ function readActiveShieldsHud() {
   }
   try {
     const shieldsPath = import_path68.default.join(import_os61.default.homedir(), ".node9", "shields.json");
-    if (!import_fs71.default.existsSync(shieldsPath)) {
+    if (!import_fs72.default.existsSync(shieldsPath)) {
       shieldsCache = { value: [], ts: now };
       return [];
     }
-    const parsed = JSON.parse(import_fs71.default.readFileSync(shieldsPath, "utf-8"));
+    const parsed = JSON.parse(import_fs72.default.readFileSync(shieldsPath, "utf-8"));
     if (!Array.isArray(parsed.active)) {
       shieldsCache = { value: [], ts: now };
       return [];
@@ -46471,17 +46863,17 @@ function renderContextLine(stdin) {
 async function main() {
   try {
     const [stdin, daemonStatus2] = await Promise.all([readStdin(), queryDaemon()]);
-    if (import_fs71.default.existsSync(import_path68.default.join(import_os61.default.homedir(), ".node9", "hud-debug"))) {
+    if (import_fs72.default.existsSync(import_path68.default.join(import_os61.default.homedir(), ".node9", "hud-debug"))) {
       try {
         const logPath = import_path68.default.join(import_os61.default.homedir(), ".node9", "hud-debug.log");
         const MAX_LOG_SIZE = 10 * 1024 * 1024;
         let size = 0;
         try {
-          size = import_fs71.default.statSync(logPath).size;
+          size = import_fs72.default.statSync(logPath).size;
         } catch {
         }
         if (size < MAX_LOG_SIZE) {
-          import_fs71.default.appendFileSync(
+          import_fs72.default.appendFileSync(
             logPath,
             JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), stdin }) + "\n"
           );
@@ -46505,8 +46897,8 @@ async function main() {
           import_path68.default.join(cwd, "node9.config.json"),
           import_path68.default.join(import_os61.default.homedir(), ".node9", "config.json")
         ]) {
-          if (!import_fs71.default.existsSync(configPath)) continue;
-          const cfg = JSON.parse(import_fs71.default.readFileSync(configPath, "utf-8"));
+          if (!import_fs72.default.existsSync(configPath)) continue;
+          const cfg = JSON.parse(import_fs72.default.readFileSync(configPath, "utf-8"));
           const hud = cfg.settings?.hud;
           if (hud && "showEnvironmentCounts" in hud) return hud.showEnvironmentCounts !== false;
         }
@@ -46524,11 +46916,11 @@ async function main() {
     renderOffline();
   }
 }
-var import_fs71, import_path68, import_os61, import_http6, RESET3, BOLD3, DIM, RED2, GREEN2, YELLOW2, BLUE, MAGENTA, CYAN2, WHITE, BAR_FILLED, BAR_EMPTY, BAR_WIDTH, shieldsCache, SHIELDS_CACHE_TTL_MS;
+var import_fs72, import_path68, import_os61, import_http6, RESET3, BOLD3, DIM, RED2, GREEN2, YELLOW2, BLUE, MAGENTA, CYAN2, WHITE, BAR_FILLED, BAR_EMPTY, BAR_WIDTH, shieldsCache, SHIELDS_CACHE_TTL_MS;
 var init_hud = __esm({
   "src/cli/hud.ts"() {
     "use strict";
-    import_fs71 = __toESM(require("fs"));
+    import_fs72 = __toESM(require("fs"));
     import_path68 = __toESM(require("path"));
     import_os61 = __toESM(require("os"));
     import_http6 = __toESM(require("http"));
@@ -46652,7 +47044,7 @@ function writeCredentialsAndConfig(apiKey, opts = {}) {
 // src/cli.ts
 init_daemon2();
 var import_chalk41 = __toESM(require("chalk"));
-var import_fs72 = __toESM(require("fs"));
+var import_fs73 = __toESM(require("fs"));
 var import_path69 = __toESM(require("path"));
 var import_os62 = __toESM(require("os"));
 var import_child_process15 = require("child_process");
@@ -46858,9 +47250,11 @@ function logAutostartSkipThrottled(reason) {
       if (Date.now() - import_fs43.default.statSync(stamp).mtimeMs < SKIP_THROTTLE_MS) return;
     } catch {
     }
+    const dir = import_path41.default.join(import_os39.default.homedir(), ".node9");
+    if (!import_fs43.default.existsSync(dir)) import_fs43.default.mkdirSync(dir, { recursive: true });
     import_fs43.default.writeFileSync(stamp, "", "utf-8");
     import_fs43.default.appendFileSync(
-      import_path41.default.join(import_os39.default.homedir(), ".node9", "hook-debug.log"),
+      import_path41.default.join(dir, "hook-debug.log"),
       `[${(/* @__PURE__ */ new Date()).toISOString()}] daemon-autostart-skip: ${reason}
 `,
       "utf-8"
@@ -46879,6 +47273,8 @@ async function autoStartDaemonAndWait() {
   }
   if (!resolvedArgv1.endsWith(".js")) return false;
   const startupFd = openStartupLogFd();
+  recordStartupState("starting");
+  let spawned = false;
   try {
     const child = (0, import_child_process5.spawn)(process.execPath, [resolvedArgv1, "daemon"], {
       detached: true,
@@ -46888,13 +47284,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 {
@@ -47707,12 +48114,16 @@ RAW: ${raw}
               delete safeEnv[key];
             }
             const startupFd = openStartupLogFd();
+            recordStartupState("starting");
             try {
               const d = (0, import_child_process7.spawn)(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) {
@@ -47725,6 +48136,7 @@ RAW: ${raw}
           } catch (spawnErr) {
             const logPath = import_path45.default.join(import_os43.default.homedir(), ".node9", "hook-debug.log");
             const msg = spawnErr instanceof Error ? spawnErr.message : String(spawnErr);
+            recordStartupState("failed", "spawn-aborted", msg);
             try {
               import_fs47.default.appendFileSync(
                 logPath,
@@ -48889,6 +49301,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 = import_os46.default.homedir();
@@ -49000,6 +49413,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(
+          import_chalk11.default.gray(
+            `       ${cause.label} ${agoLabel(cause.at.toISOString())}: ${cause.kind}${suffix}`
+          )
+        );
+      }
     }
     const autostart = autostartAdvice({
       installed: isDaemonServiceInstalled(),
@@ -49077,6 +49499,7 @@ function registerDoctorCommand(program2, version2) {
 var import_chalk12 = __toESM(require("chalk"));
 var import_fs52 = __toESM(require("fs"));
 var import_path50 = __toESM(require("path"));
+init_decision();
 var import_os47 = __toESM(require("os"));
 function formatRelativeTime(timestamp) {
   const diff = Date.now() - new Date(timestamp).getTime();
@@ -49108,10 +49531,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) {
@@ -49134,13 +49563,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" ? import_chalk12.default.green("ALLOW".padEnd(10)) : import_chalk12.default.red("DENY".padEnd(10));
+      const result = e.view.outcome === "allow" ? import_chalk12.default.green(e.view.label.padEnd(14)) : e.view.outcome === "deny" ? import_chalk12.default.red(e.view.label.padEnd(14)) : e.view.outcome === "observe" ? import_chalk12.default.yellow(e.view.label.padEnd(14)) : import_chalk12.default.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(import_chalk12.default.dim("  " + "\u2500".repeat(65)));
     console.log(
       `  ${entries.length} entries  |  ${import_chalk12.default.green(allowed + " allowed")}  |  ${import_chalk12.default.red(denied + " denied")}
@@ -49159,6 +49588,7 @@ var import_path51 = __toESM(require("path"));
 init_costSync();
 init_litellm();
 init_cost_codex();
+init_decision();
 var TEST_COMMAND_RE3 = /(?:^|\s)(npm\s+(?:run\s+)?test|npx\s+(?:vitest|jest|mocha)|yarn\s+(?:run\s+)?test|pnpm\s+(?:run\s+)?test|vitest|jest|mocha|pytest|py\.test|cargo\s+test|go\s+test|bundle\s+exec\s+rspec|rspec|phpunit|dotnet\s+test)\b/i;
 function buildTestTimestamps(allEntries) {
   const testTs = /* @__PURE__ */ new Set();
@@ -49249,8 +49679,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");
@@ -49663,12 +50100,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();
@@ -49711,15 +50148,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++;
@@ -49731,7 +50170,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++;
@@ -49749,15 +50188,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);
@@ -49766,7 +50205,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) {
@@ -50320,6 +50759,8 @@ function renderTerminalReport(data, responseDlpEntries, excludeTests) {
 // src/cli/commands/daemon-cmd.ts
 var import_chalk14 = __toESM(require("chalk"));
 var import_child_process9 = require("child_process");
+var import_fs54 = __toESM(require("fs"));
+init_startup_log();
 init_daemon2();
 var VALID_ACTIONS = "start | stop | restart | status | install | uninstall";
 function registerDaemonCommand(program2) {
@@ -50358,14 +50799,27 @@ function registerDaemonCommand(program2) {
       if (cmd === "restart") {
         stopDaemon();
         await new Promise((r) => setTimeout(r, 500));
+        const restartFd = openStartupLogFd();
+        recordStartupState("starting");
         const child = (0, import_child_process9.spawn)(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 {
+            import_fs54.default.closeSync(restartFd);
+          } catch {
+          }
+        }
         if (child.pid) {
-          console.log(import_chalk14.default.green(`\u2713 Daemon restarted (PID ${child.pid})`));
+          console.log(import_chalk14.default.green(`\u2713 Daemon relaunching (PID ${child.pid})`));
+          console.log(import_chalk14.default.gray("   Confirm with: node9 status"));
         } else {
           console.error(import_chalk14.default.red("\u2717 Failed to restart daemon \u2014 spawn returned no PID"));
           process.exit(1);
@@ -50388,13 +50842,33 @@ function registerDaemonCommand(program2) {
         return;
       }
       if (options.background) {
-        const child = (0, import_child_process9.spawn)(process.execPath, [process.argv[1], "daemon"], {
-          detached: true,
-          stdio: "ignore"
-        });
-        child.unref();
-        console.log(import_chalk14.default.green(`
-\u{1F6E1}\uFE0F  Node9 daemon started in background  (PID ${child.pid})`));
+        const startupFd = openStartupLogFd();
+        try {
+          recordStartupState("starting");
+          const child = (0, import_child_process9.spawn)(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(
+            import_chalk14.default.green(`
+\u{1F6E1}\uFE0F  Node9 daemon launching in background  (PID ${child.pid})`)
+          );
+          console.log(import_chalk14.default.gray("   Confirm with: node9 status"));
+        } finally {
+          if (startupFd !== void 0) {
+            try {
+              import_fs54.default.closeSync(startupFd);
+            } catch {
+            }
+          }
+        }
         process.exit(0);
       }
       startDaemon();
@@ -50404,7 +50878,7 @@ function registerDaemonCommand(program2) {
 
 // src/cli/commands/status.ts
 var import_chalk15 = __toESM(require("chalk"));
-var import_fs54 = __toESM(require("fs"));
+var import_fs55 = __toESM(require("fs"));
 var import_path52 = __toESM(require("path"));
 var import_os49 = __toESM(require("os"));
 init_core();
@@ -50487,10 +50961,10 @@ function registerStatusCommand(program2) {
     const projectConfig = import_path52.default.join(process.cwd(), "node9.config.json");
     const globalConfig = import_path52.default.join(import_os49.default.homedir(), ".node9", "config.json");
     console.log(
-      `  Local:   ${import_fs54.default.existsSync(projectConfig) ? import_chalk15.default.green("Active (node9.config.json)") : import_chalk15.default.gray("Not present")}`
+      `  Local:   ${import_fs55.default.existsSync(projectConfig) ? import_chalk15.default.green("Active (node9.config.json)") : import_chalk15.default.gray("Not present")}`
     );
     console.log(
-      `  Global:  ${import_fs54.default.existsSync(globalConfig) ? import_chalk15.default.green("Active (~/.node9/config.json)") : import_chalk15.default.gray("Not present")}`
+      `  Global:  ${import_fs55.default.existsSync(globalConfig) ? import_chalk15.default.green("Active (~/.node9/config.json)") : import_chalk15.default.gray("Not present")}`
     );
     if (mergedConfig.policy.sandboxPaths.length > 0) {
       console.log(
@@ -50532,7 +51006,7 @@ function registerStatusCommand(program2) {
 
 // src/cli/commands/init.ts
 var import_chalk16 = __toESM(require("chalk"));
-var import_fs55 = __toESM(require("fs"));
+var import_fs56 = __toESM(require("fs"));
 var import_path53 = __toESM(require("path"));
 var import_os50 = __toESM(require("os"));
 var import_https6 = __toESM(require("https"));
@@ -50626,15 +51100,15 @@ function registerInitCommand(program2) {
         console.log("");
       }
       const configPath = import_path53.default.join(import_os50.default.homedir(), ".node9", "config.json");
-      const isFirstInstall = !import_fs55.default.existsSync(configPath);
-      if (import_fs55.default.existsSync(configPath) && !options.force) {
+      const isFirstInstall = !import_fs56.default.existsSync(configPath);
+      if (import_fs56.default.existsSync(configPath) && !options.force) {
         try {
-          const existing = JSON.parse(import_fs55.default.readFileSync(configPath, "utf-8"));
+          const existing = JSON.parse(import_fs56.default.readFileSync(configPath, "utf-8"));
           const settings = existing.settings ?? {};
           if (settings.mode !== chosenMode) {
             settings.mode = chosenMode;
             existing.settings = settings;
-            import_fs55.default.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
+            import_fs56.default.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
             console.log(import_chalk16.default.green(`\u2705 Mode updated: ${chosenMode}`));
           } else {
             console.log(import_chalk16.default.blue(`\u2139\uFE0F  Config already exists: ${configPath}`));
@@ -50648,8 +51122,8 @@ function registerInitCommand(program2) {
           settings: { ...DEFAULT_CONFIG.settings, mode: chosenMode }
         };
         const dir = import_path53.default.dirname(configPath);
-        if (!import_fs55.default.existsSync(dir)) import_fs55.default.mkdirSync(dir, { recursive: true });
-        import_fs55.default.writeFileSync(configPath, JSON.stringify(configToSave, null, 2) + "\n");
+        if (!import_fs56.default.existsSync(dir)) import_fs56.default.mkdirSync(dir, { recursive: true });
+        import_fs56.default.writeFileSync(configPath, JSON.stringify(configToSave, null, 2) + "\n");
         console.log(import_chalk16.default.green(`\u2705 Config created: ${configPath}`));
         console.log(import_chalk16.default.gray(`   Mode: ${chosenMode}`));
       }
@@ -50749,14 +51223,14 @@ function registerInitCommand(program2) {
 
 // src/cli/commands/heal.ts
 var import_chalk17 = __toESM(require("chalk"));
-var import_fs56 = __toESM(require("fs"));
+var import_fs57 = __toESM(require("fs"));
 init_agent_wiring();
 init_setup();
 init_hook_baseline();
 var hasHookSurface = (a) => a.hooks.length > 0;
 function backupForHeal(file) {
   try {
-    if (file && import_fs56.default.existsSync(file)) import_fs56.default.copyFileSync(file, `${file}.node9-heal-bak`);
+    if (file && import_fs57.default.existsSync(file)) import_fs57.default.copyFileSync(file, `${file}.node9-heal-bak`);
   } catch {
   }
 }
@@ -51716,16 +52190,17 @@ function registerMcpGatewayCommand(program2) {
 
 // src/mcp-server/index.ts
 var import_readline5 = __toESM(require("readline"));
-var import_fs58 = __toESM(require("fs"));
+var import_fs59 = __toESM(require("fs"));
 var import_os52 = __toESM(require("os"));
 var import_path56 = __toESM(require("path"));
 var import_child_process11 = require("child_process");
+init_decision();
 init_core();
 init_daemon();
 init_shields();
 
 // src/auth/egress-config.ts
-var import_fs57 = __toESM(require("fs"));
+var import_fs58 = __toESM(require("fs"));
 var import_os51 = __toESM(require("os"));
 var import_path55 = __toESM(require("path"));
 var DEFAULT_EGRESS = {
@@ -51741,7 +52216,7 @@ function egressConfigPath() {
 function readEgressRawConfig() {
   let text;
   try {
-    text = import_fs57.default.readFileSync(egressConfigPath(), "utf8");
+    text = import_fs58.default.readFileSync(egressConfigPath(), "utf8");
   } catch (err2) {
     if (err2.code === "ENOENT") return {};
     throw err2;
@@ -51756,8 +52231,8 @@ function readEgressRawConfig() {
 }
 function writeEgressRawConfig(config) {
   const p = egressConfigPath();
-  import_fs57.default.mkdirSync(import_path55.default.dirname(p), { recursive: true });
-  import_fs57.default.writeFileSync(p, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  import_fs58.default.mkdirSync(import_path55.default.dirname(p), { recursive: true });
+  import_fs58.default.writeFileSync(p, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
 }
 function applyEgress(config, change) {
   const policy = config.policy = config.policy ?? {};
@@ -51952,7 +52427,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: {
@@ -51962,8 +52437,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: []
@@ -52145,10 +52620,10 @@ function handleStatus() {
   const projectConfig = import_path56.default.join(process.cwd(), "node9.config.json");
   const globalConfig = import_path56.default.join(import_os52.default.homedir(), ".node9", "config.json");
   lines.push(
-    `Project config (node9.config.json): ${import_fs58.default.existsSync(projectConfig) ? "present" : "not found"}`
+    `Project config (node9.config.json): ${import_fs59.default.existsSync(projectConfig) ? "present" : "not found"}`
   );
   lines.push(
-    `Global config (~/.node9/config.json): ${import_fs58.default.existsSync(globalConfig) ? "present" : "not found"}`
+    `Global config (~/.node9/config.json): ${import_fs59.default.existsSync(globalConfig) ? "present" : "not found"}`
   );
   return lines.join("\n");
 }
@@ -52258,8 +52733,8 @@ var GLOBAL_CONFIG_PATH = import_path56.default.join(import_os52.default.homedir(
 var APPROVER_CHANNELS = ["native", "browser", "cloud", "terminal"];
 function readGlobalConfigRaw() {
   try {
-    if (import_fs58.default.existsSync(GLOBAL_CONFIG_PATH)) {
-      return JSON.parse(import_fs58.default.readFileSync(GLOBAL_CONFIG_PATH, "utf-8"));
+    if (import_fs59.default.existsSync(GLOBAL_CONFIG_PATH)) {
+      return JSON.parse(import_fs59.default.readFileSync(GLOBAL_CONFIG_PATH, "utf-8"));
     }
   } catch {
   }
@@ -52267,8 +52742,8 @@ function readGlobalConfigRaw() {
 }
 function writeGlobalConfigRaw(data) {
   const dir = import_path56.default.dirname(GLOBAL_CONFIG_PATH);
-  if (!import_fs58.default.existsSync(dir)) import_fs58.default.mkdirSync(dir, { recursive: true });
-  import_fs58.default.writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(data, null, 2) + "\n");
+  if (!import_fs59.default.existsSync(dir)) import_fs59.default.mkdirSync(dir, { recursive: true });
+  import_fs59.default.writeFileSync(GLOBAL_CONFIG_PATH, JSON.stringify(data, null, 2) + "\n");
 }
 function handleApproverList() {
   const config = getConfig();
@@ -52313,35 +52788,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 = import_path56.default.join(import_os52.default.homedir(), ".node9", "audit.log");
-  if (!import_fs58.default.existsSync(auditPath)) return "No audit log found.";
-  const rawLines = import_fs58.default.readFileSync(auditPath, "utf-8").trim().split("\n").filter(Boolean);
+  if (!import_fs59.default.existsSync(auditPath)) return "No audit log found.";
+  const rawLines = import_fs59.default.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")}`;
@@ -52688,7 +53165,7 @@ function registerTrustCommand(program2) {
 // src/cli/commands/mcp-pin.ts
 var import_chalk24 = __toESM(require("chalk"));
 init_mcp_pin();
-var import_fs59 = __toESM(require("fs"));
+var import_fs60 = __toESM(require("fs"));
 
 // src/cli/commands/mcp-gateway-cmd.ts
 var import_chalk23 = __toESM(require("chalk"));
@@ -52884,6 +53361,7 @@ Restart ${[...agents].join(", ")}`) + import_chalk23.default.gray(" to activate.
 }
 
 // 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);
@@ -52895,7 +53373,7 @@ function registerMcpPinCommand(program2) {
     let repoCorrupt = false;
     if (found.source === "repo") {
       try {
-        const raw = import_fs59.default.readFileSync(found.path, "utf-8");
+        const raw = import_fs60.default.readFileSync(found.path, "utf-8");
         const parsed = JSON.parse(raw);
         repoEntries = parsed.servers ?? {};
       } catch {
@@ -53009,6 +53487,88 @@ function registerMcpPinCommand(program2) {
 \u{1F513} Cleared ${count} MCP pin(s).`));
     console.log(import_chalk24.default.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(
+        import_chalk24.default.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(import_chalk24.default.red("\n\u274C Pin file is corrupt."));
+      console.error(import_chalk24.default.yellow("   Run: node9 mcp pin reset\n"));
+      process.exit(1);
+    }
+    if (!pins.servers[serverKey]) {
+      console.error(import_chalk24.default.red(`
+\u274C No pin found for server key "${serverKey}"
+`));
+      console.error(`Run ${import_chalk24.default.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(import_chalk24.default.red(`
+\u274C Server "${serverKey}" is still configured in ${agent}.`));
+      console.error(
+        import_chalk24.default.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(import_chalk24.default.green(`
+\u2713 Forgot server ${import_chalk24.default.cyan(serverKey)}`));
+    console.log(import_chalk24.default.gray(`   Was: ${label2}`));
+    console.log(import_chalk24.default.gray("   Pin removed \u2014 server will no longer appear in the dashboard.\n"));
+  });
+}
+function forgetAllStale() {
+  let pins;
+  try {
+    pins = readMcpPins();
+  } catch {
+    console.error(import_chalk24.default.red("\n\u274C Pin file is corrupt."));
+    console.error(import_chalk24.default.yellow("   Run: node9 mcp pin reset\n"));
+    process.exit(1);
+  }
+  const inv = inventoryMcp();
+  const liveKeys = inventoryServerKeys(inv);
+  if (liveKeys.size === 0) {
+    console.error(import_chalk24.default.red("\n\u274C No live MCP servers detected \u2014 refusing to remove every pin."));
+    console.error(
+      import_chalk24.default.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(import_chalk24.default.gray("\nNo stale servers to remove.\n"));
+    return;
+  }
+  for (const [sk, pin] of stale) {
+    delete pins.servers[sk];
+    console.log(import_chalk24.default.green(`  \u2713 ${import_chalk24.default.cyan(sk)}  ${import_chalk24.default.gray(pin.label)}`));
+  }
+  writeMcpPins(pins);
+  console.log(import_chalk24.default.green(`
+Removed ${stale.length} stale server(s).
+`));
 }
 
 // src/cli/commands/sync.ts
@@ -53253,10 +53813,16 @@ var LABEL_WIDTH = 14;
 function label(category) {
   return import_chalk27.default.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 ? import_chalk27.default.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]) {
@@ -53293,11 +53859,11 @@ function renderPosture(result) {
   );
   const headroom = openHeadroom(result.findings);
   if (headroom > 0) {
-    lines.push(
-      "  " + import_chalk27.default.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("  " + import_chalk27.default.gray(l));
   }
   lines.push("");
   if (result.headline) {
@@ -53310,13 +53876,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("  " + import_chalk27.default.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(
-        `  ${import_chalk27.default.green("\u2705")} ${label(f.category)}${import_chalk27.default.gray(`${via} is ${gated} this`)}`
+        `  ${import_chalk27.default.green("\u2705")} ${label(lbl)}${import_chalk27.default.gray(`${via} is ${gated} ${guardedWhat(f)}`)}`
       );
     }
     lines.push("");
@@ -53326,17 +53897,17 @@ function renderPosture(result) {
   const osOpen = open.filter((f) => f.owner !== "node9" && !f.node9Reduces);
   if (node9Open.length > 0) {
     lines.push("  " + import_chalk27.default.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("  " + import_chalk27.default.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("  " + import_chalk27.default.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(`  ${import_chalk27.default.green("\u2705")} ${label(cat)}${import_chalk27.default.gray("no issues found")}`);
@@ -53395,7 +53966,7 @@ function registerPostureCommand(program2) {
 var import_chalk30 = __toESM(require("chalk"));
 
 // src/ci-check/fetch.ts
-var import_fs60 = __toESM(require("fs"));
+var import_fs61 = __toESM(require("fs"));
 var import_path57 = __toESM(require("path"));
 var import_node_child_process = require("child_process");
 var import_undici = __toESM(require_undici());
@@ -53480,7 +54051,7 @@ function parseRepoUrl(input) {
 function isLocalPath(input) {
   if (input.startsWith(".") || input.startsWith("/") || input.startsWith("~")) return true;
   try {
-    return import_fs60.default.existsSync(input) && import_fs60.default.statSync(input).isDirectory();
+    return import_fs61.default.existsSync(input) && import_fs61.default.statSync(input).isDirectory();
   } catch {
     return false;
   }
@@ -53597,8 +54168,8 @@ function readLocalTree(dir) {
   const add = (rel) => {
     const abs = import_path57.default.join(root, rel);
     try {
-      if (import_fs60.default.existsSync(abs) && import_fs60.default.statSync(abs).isFile()) {
-        files.push({ path: rel, content: import_fs60.default.readFileSync(abs, "utf8") });
+      if (import_fs61.default.existsSync(abs) && import_fs61.default.statSync(abs).isFile()) {
+        files.push({ path: rel, content: import_fs61.default.readFileSync(abs, "utf8") });
       }
     } catch {
     }
@@ -53618,7 +54189,7 @@ function readLocalTree(dir) {
     dirsVisited++;
     let entries;
     try {
-      entries = import_fs60.default.readdirSync(import_path57.default.join(root, relDir), { withFileTypes: true });
+      entries = import_fs61.default.readdirSync(import_path57.default.join(root, relDir), { withFileTypes: true });
     } catch {
       return;
     }
@@ -53641,8 +54212,8 @@ function readLocalTree(dir) {
   for (const rel of matches) collect(rel);
   const wfDir = import_path57.default.join(root, WORKFLOW_DIR);
   try {
-    if (import_fs60.default.existsSync(wfDir)) {
-      for (const name of import_fs60.default.readdirSync(wfDir)) {
+    if (import_fs61.default.existsSync(wfDir)) {
+      for (const name of import_fs61.default.readdirSync(wfDir)) {
         if (/\.ya?ml$/.test(name)) add(import_path57.default.join(WORKFLOW_DIR, name));
       }
     }
@@ -54781,7 +55352,7 @@ function registerEgressCommand(program2) {
 var import_chalk32 = __toESM(require("chalk"));
 
 // src/shields/jail.ts
-var import_fs61 = __toESM(require("fs"));
+var import_fs62 = __toESM(require("fs"));
 var import_os53 = __toESM(require("os"));
 var import_path58 = __toESM(require("path"));
 init_build();
@@ -54793,7 +55364,7 @@ function jailStorePath() {
 function readJailPaths() {
   let text;
   try {
-    text = import_fs61.default.readFileSync(jailStorePath(), "utf8");
+    text = import_fs62.default.readFileSync(jailStorePath(), "utf8");
   } catch (err2) {
     if (err2.code === "ENOENT") return [];
     throw err2;
@@ -54811,8 +55382,8 @@ function readJailPaths() {
 }
 function writeJailPaths(paths) {
   const p = jailStorePath();
-  import_fs61.default.mkdirSync(import_path58.default.dirname(p), { recursive: true });
-  import_fs61.default.writeFileSync(p, JSON.stringify({ paths }, null, 2) + "\n", { mode: 384 });
+  import_fs62.default.mkdirSync(import_path58.default.dirname(p), { recursive: true });
+  import_fs62.default.writeFileSync(p, JSON.stringify({ paths }, null, 2) + "\n", { mode: 384 });
 }
 function addJailPath(rawPath, verdict) {
   const norm = rawPath.trim();
@@ -54841,7 +55412,7 @@ function regenerateUserJail(paths) {
       writeActiveShields(active2.filter((s) => s !== USER_JAIL_SHIELD));
     }
     try {
-      import_fs61.default.rmSync(file, { force: true });
+      import_fs62.default.rmSync(file, { force: true });
     } catch {
     }
     return;
@@ -54955,13 +55526,13 @@ function registerJailCommand(program2) {
 
 // src/cli/commands/sandbox.ts
 var import_chalk33 = __toESM(require("chalk"));
-var import_fs64 = __toESM(require("fs"));
+var import_fs65 = __toESM(require("fs"));
 var import_path61 = __toESM(require("path"));
 var import_child_process13 = require("child_process");
 init_config();
 
 // src/sandbox/config.ts
-var import_fs62 = __toESM(require("fs"));
+var import_fs63 = __toESM(require("fs"));
 var import_path59 = __toESM(require("path"));
 var import_yaml2 = require("yaml");
 var SANDBOX_CONFIG_FILE = "node9.sandbox.yaml";
@@ -55039,12 +55610,12 @@ function sandboxConfigPath(cwd = process.cwd()) {
 }
 function loadSandboxConfig(cwd = process.cwd(), fallbackAgent = "claude") {
   const p = sandboxConfigPath(cwd);
-  if (!import_fs62.default.existsSync(p)) {
+  if (!import_fs63.default.existsSync(p)) {
     throw new Error(`sandbox: ${SANDBOX_CONFIG_FILE} not found \u2014 run \`node9 sandbox new\` first.`);
   }
   let raw;
   try {
-    raw = (0, import_yaml2.parse)(import_fs62.default.readFileSync(p, "utf-8"));
+    raw = (0, import_yaml2.parse)(import_fs63.default.readFileSync(p, "utf-8"));
   } catch (err2) {
     throw new Error(
       `sandbox: ${SANDBOX_CONFIG_FILE} is not valid YAML \u2014 ${err2.message}`
@@ -55102,7 +55673,7 @@ function compileAllowlist(input) {
 init_templates();
 
 // src/sandbox/runtime.ts
-var import_fs63 = __toESM(require("fs"));
+var import_fs64 = __toESM(require("fs"));
 var import_os54 = __toESM(require("os"));
 var import_path60 = __toESM(require("path"));
 var import_crypto14 = __toESM(require("crypto"));
@@ -55130,7 +55701,7 @@ function buildRunArgs(opts) {
   args.push("-v", `${allowlistHostPath}:${ALLOWED_DOMAINS_PATH}:ro`);
   if (config.node9.mountAgentCredentials) {
     const creds = agentCredentialsMount(config.agent);
-    if (import_fs63.default.existsSync(creds.hostPath)) {
+    if (import_fs64.default.existsSync(creds.hostPath)) {
       args.push("-v", `${creds.hostPath}:${creds.target}`);
     }
   }
@@ -55152,16 +55723,16 @@ function sandboxBuildDir(cwd = process.cwd()) {
 }
 function writeBuildContext(cwd, dockerfile, entrypoint) {
   const dir = sandboxBuildDir(cwd);
-  import_fs63.default.mkdirSync(dir, { recursive: true });
-  import_fs63.default.writeFileSync(import_path60.default.join(dir, "Dockerfile"), dockerfile);
-  import_fs63.default.writeFileSync(import_path60.default.join(dir, "entrypoint.sh"), entrypoint);
+  import_fs64.default.mkdirSync(dir, { recursive: true });
+  import_fs64.default.writeFileSync(import_path60.default.join(dir, "Dockerfile"), dockerfile);
+  import_fs64.default.writeFileSync(import_path60.default.join(dir, "entrypoint.sh"), entrypoint);
   return dir;
 }
 function writeAllowlist(cwd, hosts) {
   const dir = import_path60.default.join(cwd, ".node9", "sandbox");
-  import_fs63.default.mkdirSync(dir, { recursive: true });
+  import_fs64.default.mkdirSync(dir, { recursive: true });
   const p = import_path60.default.join(dir, "allowed-domains.txt");
-  import_fs63.default.writeFileSync(p, hosts.join("\n") + "\n");
+  import_fs64.default.writeFileSync(p, hosts.join("\n") + "\n");
   return p;
 }
 function resolveHomePath(p) {
@@ -55170,7 +55741,7 @@ function resolveHomePath(p) {
 
 // src/cli/commands/sandbox.ts
 function seedDataDirConfig(dataDir, sandbox) {
-  import_fs64.default.mkdirSync(dataDir, { recursive: true });
+  import_fs65.default.mkdirSync(dataDir, { recursive: true });
   const configPath = import_path61.default.join(dataDir, "config.json");
   const seed = {
     settings: {
@@ -55182,7 +55753,7 @@ function seedDataDirConfig(dataDir, sandbox) {
       }
     }
   };
-  import_fs64.default.writeFileSync(configPath, JSON.stringify(seed, null, 2), { mode: 384 });
+  import_fs65.default.writeFileSync(configPath, JSON.stringify(seed, null, 2), { mode: 384 });
 }
 function registerSandboxCommand(program2, version2) {
   const node9Version2 = pinnedNode9Version(version2);
@@ -55190,13 +55761,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 (import_fs64.default.existsSync(p)) {
+    if (import_fs65.default.existsSync(p)) {
       console.log(
         import_chalk33.default.yellow(`  ${SANDBOX_CONFIG_FILE} already exists \u2014 leaving it untouched.`)
       );
       return;
     }
-    import_fs64.default.writeFileSync(p, scaffoldSandboxYaml(agent));
+    import_fs65.default.writeFileSync(p, scaffoldSandboxYaml(agent));
     console.log(
       import_chalk33.default.green(`  \u2713 wrote ${SANDBOX_CONFIG_FILE}`) + import_chalk33.default.dim(` (agent: ${agent})`)
     );
@@ -55237,7 +55808,7 @@ function registerSandboxCommand(program2, version2) {
     const hash = imageContentHash(dockerfile, entrypoint);
     const image = sandbox.runtime.image;
     const hashFile = import_path61.default.join(sandboxBuildDir(cwd), ".image-hash");
-    const lastHash = import_fs64.default.existsSync(hashFile) ? import_fs64.default.readFileSync(hashFile, "utf-8").trim() : "";
+    const lastHash = import_fs65.default.existsSync(hashFile) ? import_fs65.default.readFileSync(hashFile, "utf-8").trim() : "";
     const imageExists = (0, import_child_process13.spawnSync)(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) {
@@ -55249,7 +55820,7 @@ function registerSandboxCommand(program2, version2) {
         console.error(import_chalk33.default.red("  build failed."));
         process.exit(b.status ?? 1);
       }
-      import_fs64.default.writeFileSync(hashFile, hash);
+      import_fs65.default.writeFileSync(hashFile, hash);
     }
     const dataDir = sandboxDataDir(cwd);
     seedDataDirConfig(dataDir, sandbox);
@@ -55263,7 +55834,7 @@ function registerSandboxCommand(program2, version2) {
     });
     if (sandbox.node9.mountAgentCredentials) {
       const creds = agentCredentialsMount(sandbox.agent);
-      if (import_fs64.default.existsSync(creds.hostPath)) {
+      if (import_fs65.default.existsSync(creds.hostPath)) {
         console.log(import_chalk33.default.dim(`  mounting ${creds.hostPath} (agent credentials, rw)`));
       } else {
         console.log(
@@ -55280,7 +55851,7 @@ function registerSandboxCommand(program2, version2) {
   });
   cmd.command("tail").description("Stream the sandbox's audit log (host-side)").action(() => {
     const auditPath = import_path61.default.join(sandboxDataDir(), "audit.log");
-    if (!import_fs64.default.existsSync(auditPath)) {
+    if (!import_fs65.default.existsSync(auditPath)) {
       console.log(import_chalk33.default.dim("  no sandbox audit yet."));
       return;
     }
@@ -55288,11 +55859,11 @@ function registerSandboxCommand(program2, version2) {
   });
   cmd.command("logs").description("Dump the sandbox's audit log").action(() => {
     const auditPath = import_path61.default.join(sandboxDataDir(), "audit.log");
-    if (!import_fs64.default.existsSync(auditPath)) {
+    if (!import_fs65.default.existsSync(auditPath)) {
       console.log(import_chalk33.default.dim("  no sandbox audit yet."));
       return;
     }
-    process.stdout.write(import_fs64.default.readFileSync(auditPath, "utf-8"));
+    process.stdout.write(import_fs65.default.readFileSync(auditPath, "utf-8"));
   });
   cmd.command("clean").description("Remove the sandbox image, build context, and data").action(() => {
     const cwd = process.cwd();
@@ -55306,15 +55877,16 @@ function registerSandboxCommand(program2, version2) {
         stdio: "ignore"
       });
     }
-    import_fs64.default.rmSync(import_path61.default.join(cwd, ".node9", "sandbox"), { recursive: true, force: true });
+    import_fs65.default.rmSync(import_path61.default.join(cwd, ".node9", "sandbox"), { recursive: true, force: true });
     console.log(import_chalk33.default.green("  \u2713 sandbox image + build + data removed."));
   });
 }
 
 // src/cli/commands/sessions.ts
 var import_chalk34 = __toESM(require("chalk"));
-var import_fs65 = __toESM(require("fs"));
+var import_fs66 = __toESM(require("fs"));
 var import_path62 = __toESM(require("path"));
+init_decision();
 var import_os55 = __toESM(require("os"));
 init_scan_summary();
 init_litellm();
@@ -55411,7 +55983,7 @@ function loadAuditEntries(auditPath) {
   const aPath = auditPath ?? import_path62.default.join(import_os55.default.homedir(), ".node9", "audit.log");
   let raw;
   try {
-    raw = import_fs65.default.readFileSync(aPath, "utf-8");
+    raw = import_fs66.default.readFileSync(aPath, "utf-8");
   } catch {
     return [];
   }
@@ -55421,7 +55993,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 {
     }
@@ -55448,7 +56020,7 @@ function auditEntriesInWindow(entries, windowStart, windowEnd) {
 }
 function buildGeminiSessions(days, allAuditEntries) {
   const tmpDir = import_path62.default.join(import_os55.default.homedir(), ".gemini", "tmp");
-  if (!import_fs65.default.existsSync(tmpDir)) return [];
+  if (!import_fs66.default.existsSync(tmpDir)) return [];
   const cutoff = days !== null ? (() => {
     const d = /* @__PURE__ */ new Date();
     d.setDate(d.getDate() - days);
@@ -55457,7 +56029,7 @@ function buildGeminiSessions(days, allAuditEntries) {
   })() : null;
   let slugDirs;
   try {
-    slugDirs = import_fs65.default.readdirSync(tmpDir);
+    slugDirs = import_fs66.default.readdirSync(tmpDir);
   } catch {
     return [];
   }
@@ -55465,27 +56037,27 @@ function buildGeminiSessions(days, allAuditEntries) {
   for (const slug2 of slugDirs) {
     const slugPath = import_path62.default.join(tmpDir, slug2);
     try {
-      if (!import_fs65.default.statSync(slugPath).isDirectory()) continue;
+      if (!import_fs66.default.statSync(slugPath).isDirectory()) continue;
     } catch {
       continue;
     }
     let projectRoot = import_path62.default.join(import_os55.default.homedir(), slug2);
     try {
-      projectRoot = import_fs65.default.readFileSync(import_path62.default.join(slugPath, ".project_root"), "utf-8").trim();
+      projectRoot = import_fs66.default.readFileSync(import_path62.default.join(slugPath, ".project_root"), "utf-8").trim();
     } catch {
     }
     const chatsDir = import_path62.default.join(slugPath, "chats");
-    if (!import_fs65.default.existsSync(chatsDir)) continue;
+    if (!import_fs66.default.existsSync(chatsDir)) continue;
     let chatFiles;
     try {
-      chatFiles = import_fs65.default.readdirSync(chatsDir).filter((f) => f.endsWith(".json"));
+      chatFiles = import_fs66.default.readdirSync(chatsDir).filter((f) => f.endsWith(".json"));
     } catch {
       continue;
     }
     for (const chatFile of chatFiles) {
       let raw;
       try {
-        raw = import_fs65.default.readFileSync(import_path62.default.join(chatsDir, chatFile), "utf-8");
+        raw = import_fs66.default.readFileSync(import_path62.default.join(chatsDir, chatFile), "utf-8");
       } catch {
         continue;
       }
@@ -55566,7 +56138,7 @@ function buildGeminiSessions(days, allAuditEntries) {
 }
 function buildCodexSessions(days, allAuditEntries) {
   const sessionsBase = import_path62.default.join(import_os55.default.homedir(), ".codex", "sessions");
-  if (!import_fs65.default.existsSync(sessionsBase)) return [];
+  if (!import_fs66.default.existsSync(sessionsBase)) return [];
   const cutoff = days !== null ? (() => {
     const d = /* @__PURE__ */ new Date();
     d.setDate(d.getDate() - days);
@@ -55575,28 +56147,28 @@ function buildCodexSessions(days, allAuditEntries) {
   })() : null;
   const jsonlFiles = [];
   try {
-    for (const year of import_fs65.default.readdirSync(sessionsBase)) {
+    for (const year of import_fs66.default.readdirSync(sessionsBase)) {
       const yearPath = import_path62.default.join(sessionsBase, year);
       try {
-        if (!import_fs65.default.statSync(yearPath).isDirectory()) continue;
+        if (!import_fs66.default.statSync(yearPath).isDirectory()) continue;
       } catch {
         continue;
       }
-      for (const month of import_fs65.default.readdirSync(yearPath)) {
+      for (const month of import_fs66.default.readdirSync(yearPath)) {
         const monthPath = import_path62.default.join(yearPath, month);
         try {
-          if (!import_fs65.default.statSync(monthPath).isDirectory()) continue;
+          if (!import_fs66.default.statSync(monthPath).isDirectory()) continue;
         } catch {
           continue;
         }
-        for (const day of import_fs65.default.readdirSync(monthPath)) {
+        for (const day of import_fs66.default.readdirSync(monthPath)) {
           const dayPath = import_path62.default.join(monthPath, day);
           try {
-            if (!import_fs65.default.statSync(dayPath).isDirectory()) continue;
+            if (!import_fs66.default.statSync(dayPath).isDirectory()) continue;
           } catch {
             continue;
           }
-          for (const file of import_fs65.default.readdirSync(dayPath)) {
+          for (const file of import_fs66.default.readdirSync(dayPath)) {
             if (file.endsWith(".jsonl")) jsonlFiles.push(import_path62.default.join(dayPath, file));
           }
         }
@@ -55609,7 +56181,7 @@ function buildCodexSessions(days, allAuditEntries) {
   for (const filePath of jsonlFiles) {
     let lines;
     try {
-      lines = import_fs65.default.readFileSync(filePath, "utf-8").split("\n");
+      lines = import_fs66.default.readFileSync(filePath, "utf-8").split("\n");
     } catch {
       continue;
     }
@@ -55698,7 +56270,7 @@ function buildSessions(days, historyPath) {
   const hPath = historyPath ?? import_path62.default.join(import_os55.default.homedir(), ".claude", "history.jsonl");
   let historyRaw = "";
   try {
-    historyRaw = import_fs65.default.readFileSync(hPath, "utf-8");
+    historyRaw = import_fs66.default.readFileSync(hPath, "utf-8");
   } catch {
   }
   const cutoff = days !== null ? (() => {
@@ -55722,7 +56294,7 @@ function buildSessions(days, historyPath) {
     const jsonlFile = sessionJsonlPath(entry.project, entry.sessionId);
     let sessionLines = [];
     try {
-      sessionLines = import_fs65.default.readFileSync(jsonlFile, "utf-8").split("\n");
+      sessionLines = import_fs66.default.readFileSync(jsonlFile, "utf-8").split("\n");
     } catch {
     }
     const { toolCalls, costUSD, hasSnapshot, modifiedFiles } = parseSessionLines(sessionLines);
@@ -56116,12 +56688,12 @@ function registerSessionTaintCommand(program2) {
 
 // src/cli/commands/skill-pin.ts
 var import_chalk36 = __toESM(require("chalk"));
-var import_fs66 = __toESM(require("fs"));
+var import_fs67 = __toESM(require("fs"));
 var import_os56 = __toESM(require("os"));
 var import_path63 = __toESM(require("path"));
 function wipeSkillSessions() {
   try {
-    import_fs66.default.rmSync(import_path63.default.join(import_os56.default.homedir(), ".node9", "skill-sessions"), {
+    import_fs67.default.rmSync(import_path63.default.join(import_os56.default.homedir(), ".node9", "skill-sessions"), {
       recursive: true,
       force: true
     });
@@ -56203,15 +56775,15 @@ function registerSkillPinCommand(program2) {
 }
 
 // src/cli/commands/decisions.ts
-var import_fs67 = __toESM(require("fs"));
+var import_fs68 = __toESM(require("fs"));
 var import_os57 = __toESM(require("os"));
 var import_path64 = __toESM(require("path"));
 var import_chalk37 = __toESM(require("chalk"));
 var DECISIONS_FILE2 = import_path64.default.join(import_os57.default.homedir(), ".node9", "decisions.json");
 function readDecisions() {
   try {
-    if (!import_fs67.default.existsSync(DECISIONS_FILE2)) return {};
-    const raw = import_fs67.default.readFileSync(DECISIONS_FILE2, "utf-8");
+    if (!import_fs68.default.existsSync(DECISIONS_FILE2)) return {};
+    const raw = import_fs68.default.readFileSync(DECISIONS_FILE2, "utf-8");
     const parsed = JSON.parse(raw);
     const out = {};
     for (const [k, v] of Object.entries(parsed)) {
@@ -56224,10 +56796,10 @@ function readDecisions() {
 }
 function writeDecisions(d) {
   const dir = import_path64.default.dirname(DECISIONS_FILE2);
-  if (!import_fs67.default.existsSync(dir)) import_fs67.default.mkdirSync(dir, { recursive: true });
+  if (!import_fs68.default.existsSync(dir)) import_fs68.default.mkdirSync(dir, { recursive: true });
   const tmp = `${DECISIONS_FILE2}.${process.pid}.tmp`;
-  import_fs67.default.writeFileSync(tmp, JSON.stringify(d, null, 2));
-  import_fs67.default.renameSync(tmp, DECISIONS_FILE2);
+  import_fs68.default.writeFileSync(tmp, JSON.stringify(d, null, 2));
+  import_fs68.default.renameSync(tmp, DECISIONS_FILE2);
 }
 function registerDecisionsCommand(program2) {
   const cmd = program2.command("decisions").description('Manage persistent "Always Allow" / "Always Deny" tool decisions');
@@ -56284,7 +56856,7 @@ Persistent decisions  (${entries.length})
 
 // src/cli/commands/dlp.ts
 var import_chalk38 = __toESM(require("chalk"));
-var import_fs68 = __toESM(require("fs"));
+var import_fs69 = __toESM(require("fs"));
 var import_path65 = __toESM(require("path"));
 var import_os58 = __toESM(require("os"));
 var AUDIT_LOG = import_path65.default.join(import_os58.default.homedir(), ".node9", "audit.log");
@@ -56295,7 +56867,7 @@ function stripAnsi(s) {
 }
 function loadResolved() {
   try {
-    const raw = JSON.parse(import_fs68.default.readFileSync(RESOLVED_FILE, "utf-8"));
+    const raw = JSON.parse(import_fs69.default.readFileSync(RESOLVED_FILE, "utf-8"));
     return new Set(raw);
   } catch {
     return /* @__PURE__ */ new Set();
@@ -56303,13 +56875,13 @@ function loadResolved() {
 }
 function saveResolved(resolved) {
   try {
-    import_fs68.default.writeFileSync(RESOLVED_FILE, JSON.stringify([...resolved], null, 2), { mode: 384 });
+    import_fs69.default.writeFileSync(RESOLVED_FILE, JSON.stringify([...resolved], null, 2), { mode: 384 });
   } catch {
   }
 }
 function loadDlpFindings() {
-  if (!import_fs68.default.existsSync(AUDIT_LOG)) return [];
-  return import_fs68.default.readFileSync(AUDIT_LOG, "utf-8").split("\n").flatMap((line) => {
+  if (!import_fs69.default.existsSync(AUDIT_LOG)) return [];
+  return import_fs69.default.readFileSync(AUDIT_LOG, "utf-8").split("\n").flatMap((line) => {
     if (!line.trim()) return [];
     try {
       const e = JSON.parse(line);
@@ -56407,14 +56979,14 @@ function registerDlpCommand(program2) {
 
 // src/cli/commands/mask.ts
 var import_chalk39 = __toESM(require("chalk"));
-var import_fs69 = __toESM(require("fs"));
+var import_fs70 = __toESM(require("fs"));
 var import_path66 = __toESM(require("path"));
 var import_os59 = __toESM(require("os"));
 init_dlp();
 function findJsonlFiles(dir) {
   const results = [];
-  if (!import_fs69.default.existsSync(dir)) return results;
-  for (const entry of import_fs69.default.readdirSync(dir, { withFileTypes: true })) {
+  if (!import_fs70.default.existsSync(dir)) return results;
+  for (const entry of import_fs70.default.readdirSync(dir, { withFileTypes: true })) {
     const full = import_path66.default.join(dir, entry.name);
     if (entry.isDirectory()) results.push(...findJsonlFiles(full));
     else if (entry.isFile() && entry.name.endsWith(".jsonl")) results.push(full);
@@ -56458,7 +57030,7 @@ function redactJson(obj) {
 function processFile(filePath, dryRun) {
   let raw;
   try {
-    raw = import_fs69.default.readFileSync(filePath, "utf-8");
+    raw = import_fs70.default.readFileSync(filePath, "utf-8");
   } catch {
     return { redactedLines: 0, patterns: [] };
   }
@@ -56490,14 +57062,14 @@ function processFile(filePath, dryRun) {
     }
   }
   if (!dryRun && redactedLines > 0) {
-    import_fs69.default.writeFileSync(filePath, newLines.join("\n"), "utf-8");
+    import_fs70.default.writeFileSync(filePath, newLines.join("\n"), "utf-8");
   }
   return { redactedLines, patterns };
 }
 function processJsonFile(filePath, dryRun) {
   let raw;
   try {
-    raw = import_fs69.default.readFileSync(filePath, "utf-8");
+    raw = import_fs70.default.readFileSync(filePath, "utf-8");
   } catch {
     return { redactedLines: 0, patterns: [] };
   }
@@ -56510,14 +57082,14 @@ function processJsonFile(filePath, dryRun) {
   const { value, modified, found } = redactJson(parsed);
   if (!modified) return { redactedLines: 0, patterns: [] };
   if (!dryRun) {
-    import_fs69.default.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
+    import_fs70.default.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf-8");
   }
   return { redactedLines: 1, patterns: found };
 }
 function findJsonFiles(dir) {
   const results = [];
-  if (!import_fs69.default.existsSync(dir)) return results;
-  for (const entry of import_fs69.default.readdirSync(dir, { withFileTypes: true })) {
+  if (!import_fs70.default.existsSync(dir)) return results;
+  for (const entry of import_fs70.default.readdirSync(dir, { withFileTypes: true })) {
     const full = import_path66.default.join(dir, entry.name);
     if (entry.isDirectory()) results.push(...findJsonFiles(full));
     else if (entry.isFile() && entry.name.endsWith(".json")) results.push(full);
@@ -56537,7 +57109,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 import_fs69.default.statSync(f.path).mtime >= cutoff;
+        return import_fs70.default.statSync(f.path).mtime >= cutoff;
       } catch {
         return false;
       }
@@ -56593,7 +57165,7 @@ function registerMaskCommand(program2) {
 // src/cli.ts
 init_blast();
 var { version } = JSON.parse(
-  import_fs72.default.readFileSync(import_path69.default.join(__dirname, "../package.json"), "utf-8")
+  import_fs73.default.readFileSync(import_path69.default.join(__dirname, "../package.json"), "utf-8")
 );
 var program = new import_commander.Command();
 program.name("node9").description("The Sudo Command for AI Agents").version(version);
@@ -56773,14 +57345,14 @@ program.command("uninstall").description("Remove all Node9 hooks and optionally
   }
   if (options.purge) {
     const node9Dir = import_path69.default.join(import_os62.default.homedir(), ".node9");
-    if (import_fs72.default.existsSync(node9Dir)) {
+    if (import_fs73.default.existsSync(node9Dir)) {
       const confirmed = await (0, import_prompts2.confirm)({
         message: `Permanently delete ${node9Dir} (config, audit log, credentials)?`,
         default: false
       });
       if (confirmed) {
-        import_fs72.default.rmSync(node9Dir, { recursive: true });
-        if (import_fs72.default.existsSync(node9Dir)) {
+        import_fs73.default.rmSync(node9Dir, { recursive: true });
+        if (import_fs73.default.existsSync(node9Dir)) {
           console.error(
             import_chalk41.default.red("\n  \u26A0\uFE0F  ~/.node9/ could not be fully deleted \u2014 remove it manually.")
           );
@@ -56945,12 +57517,12 @@ Run "node9 addto claude" to register it as the statusLine.`
   if (subcommand === "debug") {
     const flagFile = import_path69.default.join(import_os62.default.homedir(), ".node9", "hud-debug");
     if (state === "on") {
-      import_fs72.default.mkdirSync(import_path69.default.dirname(flagFile), { recursive: true });
-      import_fs72.default.writeFileSync(flagFile, "");
+      import_fs73.default.mkdirSync(import_path69.default.dirname(flagFile), { recursive: true });
+      import_fs73.default.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 (import_fs72.default.existsSync(flagFile)) import_fs72.default.unlinkSync(flagFile);
+      if (import_fs73.default.existsSync(flagFile)) import_fs73.default.unlinkSync(flagFile);
       console.log("HUD debug logging disabled.");
     } else {
       console.error("Usage: node9 hud debug on|off");
@@ -57075,7 +57647,7 @@ if (process.argv[2] !== "daemon") {
       if (process.env.NODE9_DEBUG === "1" || getConfig().settings.enableHookLogDebug) {
         const logPath = import_path69.default.join(import_os62.default.homedir(), ".node9", "hook-debug.log");
         const msg = reason instanceof Error ? reason.message : String(reason);
-        import_fs72.default.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] UNHANDLED: ${msg}
+        import_fs73.default.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] UNHANDLED: ${msg}
 `);
       }
       process.exit(0);