@node9/proxy 1.10.0 → 1.10.1

package/dist/cli.mjs

@@ -147,8 +147,8 @@ function sanitizeConfig(raw) {
     }
   }
   const lines = result.error.issues.map((issue) => {
-    const path34 = issue.path.length > 0 ? issue.path.join(".") : "root";
-    return `  \u2022 ${path34}: ${issue.message}`;
+    const path35 = issue.path.length > 0 ? issue.path.join(".") : "root";
+    return `  \u2022 ${path35}: ${issue.message}`;
   });
   return {
     sanitized,
@@ -231,7 +231,8 @@ var init_config_schema = __esm({
         slackEnabled: z.boolean().optional(),
         enableTrustSessions: z.boolean().optional(),
         allowGlobalPause: z.boolean().optional(),
-        auditHashArgs: z.boolean().optional()
+        auditHashArgs: z.boolean().optional(),
+        agentPolicy: z.enum(["require_approval", "block_on_rules"]).optional()
       }).optional(),
       policy: z.object({
         sandboxPaths: z.array(z.string()).optional(),
@@ -1709,9 +1710,9 @@ function matchesPattern(text, patterns) {
   const withoutDotSlash = text.replace(/^\.\//, "");
   return isMatch(withoutDotSlash) || isMatch(`./${withoutDotSlash}`);
 }
-function getNestedValue(obj, path34) {
+function getNestedValue(obj, path35) {
   if (!obj || typeof obj !== "object") return null;
-  return path34.split(".").reduce((prev, curr) => prev?.[curr], obj);
+  return path35.split(".").reduce((prev, curr) => prev?.[curr], obj);
 }
 function shouldSnapshot(toolName, args, config) {
   if (!config.settings.enableUndo) return false;
@@ -2791,11 +2792,12 @@ ${smartTruncate(str, 500)}`
 function escapePango(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function buildPlainMessage(toolName, formattedArgs, agent, explainableLabel, locked, allowCount = 1) {
+function buildPlainMessage(toolName, formattedArgs, agent, explainableLabel, locked, allowCount = 1, ruleDescription) {
   const lines = [];
   if (locked) lines.push("\u26A0\uFE0F  LOCKED BY ADMIN POLICY\n");
   lines.push(`\u{1F916} ${agent || "AI Agent"}  |  \u{1F527} ${toolName}`);
   lines.push(`\u{1F6E1}\uFE0F  ${explainableLabel || "Security Policy"}`);
+  if (ruleDescription) lines.push(`\u2139  ${ruleDescription}`);
   lines.push("");
   lines.push(formattedArgs);
   if (allowCount >= 3) {
@@ -2808,7 +2810,7 @@ function buildPlainMessage(toolName, formattedArgs, agent, explainableLabel, loc
   }
   return lines.join("\n");
 }
-function buildPangoMessage(toolName, formattedArgs, agent, explainableLabel, locked, allowCount = 1) {
+function buildPangoMessage(toolName, formattedArgs, agent, explainableLabel, locked, allowCount = 1, ruleDescription) {
   const lines = [];
   if (locked) {
     lines.push('<span foreground="red" weight="bold">\u26A0\uFE0F  LOCKED BY ADMIN POLICY</span>');
@@ -2818,6 +2820,7 @@ function buildPangoMessage(toolName, formattedArgs, agent, explainableLabel, loc
     `<b>\u{1F916} ${escapePango(agent || "AI Agent")}</b>  |  <b>\u{1F527} <tt>${escapePango(toolName)}</tt></b>`
   );
   lines.push(`<i>\u{1F6E1}\uFE0F  ${escapePango(explainableLabel || "Security Policy")}</i>`);
+  if (ruleDescription) lines.push(`<i>\u2139  ${escapePango(ruleDescription)}</i>`);
   lines.push("");
   lines.push(`<tt>${escapePango(formattedArgs)}</tt>`);
   if (allowCount >= 3) {
@@ -2834,7 +2837,7 @@ function buildPangoMessage(toolName, formattedArgs, agent, explainableLabel, loc
   }
   return lines.join("\n");
 }
-async function askNativePopup(toolName, args, agent, explainableLabel, locked = false, signal, matchedField, matchedWord, allowCount = 1) {
+async function askNativePopup(toolName, args, agent, explainableLabel, locked = false, signal, matchedField, matchedWord, allowCount = 1, ruleDescription) {
   if (isTestEnv()) return "deny";
   const { message: formattedArgs, intent } = formatArgs(args, matchedField, matchedWord);
   const intentLabel = intent === "EDIT" ? "Code Edit" : "Action Approval";
@@ -2845,7 +2848,8 @@ async function askNativePopup(toolName, args, agent, explainableLabel, locked =
     agent,
     explainableLabel,
     locked,
-    allowCount
+    allowCount,
+    ruleDescription
   );
   return new Promise((resolve) => {
     let childProcess = null;
@@ -2879,7 +2883,8 @@ end run`;
           agent,
           explainableLabel,
           locked,
-          allowCount
+          allowCount,
+          ruleDescription
         );
         const argsList = [
           locked ? "--info" : "--question",
@@ -2953,7 +2958,7 @@ function auditLocalAllow(toolName, args, checkedBy, creds, meta) {
   }).catch(() => {
   });
 }
-async function initNode9SaaS(toolName, args, creds, meta, riskMetadata) {
+async function initNode9SaaS(toolName, args, creds, meta, riskMetadata, agentPolicy, forceReview) {
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), 1e4);
   if (!creds.apiKey) throw new Error("Node9 API Key is missing");
@@ -2998,7 +3003,9 @@ async function initNode9SaaS(toolName, args, creds, meta, riskMetadata) {
           platform: os9.platform()
         },
         ...riskMetadata && { riskMetadata },
-        ...ciContext && { ciContext }
+        ...ciContext && { ciContext },
+        ...agentPolicy && { policy: agentPolicy },
+        ...forceReview && { forceReview: true }
       }),
       signal: controller.signal
     });
@@ -3392,6 +3399,7 @@ async function _authorizeHeadlessCore(toolName, args, meta, options) {
       policyMatchedWord,
       policyResult.ruleName
     );
+    if (policyRuleDescription) riskMetadata.ruleDescription = policyRuleDescription.slice(0, 200);
     const persistent = policyResult.ruleName ? null : getPersistentDecision(toolName);
     if (persistent === "allow") {
       if (approvers.cloud && creds?.apiKey)
@@ -3426,9 +3434,18 @@ async function _authorizeHeadlessCore(toolName, args, meta, options) {
   }
   let cloudRequestId = null;
   const cloudEnforced = approvers.cloud && !!creds?.apiKey;
-  if (cloudEnforced && !localSmartRuleMatched && !options?.localSmartRuleMatched) {
+  const forceReview = localSmartRuleMatched === true || options?.localSmartRuleMatched === true || void 0;
+  if (cloudEnforced) {
     try {
-      const initResult = await initNode9SaaS(toolName, args, creds, meta, riskMetadata);
+      const initResult = await initNode9SaaS(
+        toolName,
+        args,
+        creds,
+        meta,
+        riskMetadata,
+        config.settings.agentPolicy,
+        forceReview
+      );
       if (!initResult.pending) {
         if (initResult.shadowMode) {
           return { approved: true, checkedBy: "cloud" };
@@ -3443,9 +3460,7 @@ async function _authorizeHeadlessCore(toolName, args, meta, options) {
           };
         }
       }
-      if (!localSmartRuleMatched && !options?.localSmartRuleMatched) {
-        cloudRequestId = initResult.requestId || null;
-      }
+      if (initResult.pending) cloudRequestId = initResult.requestId || null;
       if (!taintWarning) explainableLabel = "Organization Policy (SaaS)";
     } catch {
     }
@@ -3502,7 +3517,7 @@ async function _authorizeHeadlessCore(toolName, args, meta, options) {
       }
     }
   }
-  if (cloudEnforced && cloudRequestId && !localSmartRuleMatched && !options?.localSmartRuleMatched) {
+  if (cloudEnforced && cloudRequestId) {
     racePromises.push(
       (async () => {
         try {
@@ -3534,7 +3549,8 @@ async function _authorizeHeadlessCore(toolName, args, meta, options) {
           signal,
           policyMatchedField,
           policyMatchedWord,
-          daemonAllowCount
+          daemonAllowCount,
+          riskMetadata?.ruleDescription
         );
         if (decision === "always_allow") {
           writeTrustSession(toolName, 36e5);
@@ -6036,14 +6052,181 @@ var init_patch = __esm({
   }
 });
 
-// src/daemon/server.ts
-import http from "http";
+// src/costSync.ts
 import fs16 from "fs";
 import path19 from "path";
+import os14 from "os";
+function normalizeModel(raw) {
+  return raw.replace(/-\d{8}$/, "");
+}
+function pricingFor(model) {
+  const norm = normalizeModel(model);
+  if (PRICING[norm]) return PRICING[norm];
+  let best = null;
+  for (const key of Object.keys(PRICING)) {
+    if (norm.startsWith(key) && (best === null || key.length > best.length)) best = key;
+  }
+  return best ? PRICING[best] : null;
+}
+function parseJSONLFile(filePath) {
+  let content;
+  try {
+    content = fs16.readFileSync(filePath, "utf8");
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+  const daily = /* @__PURE__ */ new Map();
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    let row;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (row["type"] !== "assistant") continue;
+    const msg = row["message"];
+    if (!msg?.["usage"] || typeof msg["model"] !== "string") continue;
+    const usage = msg["usage"];
+    const model = msg["model"];
+    const timestamp = row["timestamp"];
+    if (typeof timestamp !== "string" || timestamp.length < 10) continue;
+    const date = timestamp.slice(0, 10);
+    const p = pricingFor(model);
+    if (!p) continue;
+    const inp = Number(usage["input_tokens"] ?? 0);
+    const out = Number(usage["output_tokens"] ?? 0);
+    const cw = Number(usage["cache_creation_input_tokens"] ?? 0);
+    const cr = Number(usage["cache_read_input_tokens"] ?? 0);
+    const cost = inp * p[0] + out * p[1] + cw * p[2] + cr * p[3];
+    const norm = normalizeModel(model);
+    const key = `${date}::${norm}`;
+    const prev = daily.get(key);
+    if (prev) {
+      prev.costUSD += cost;
+      prev.inputTokens += inp;
+      prev.outputTokens += out;
+      prev.cacheWriteTokens += cw;
+      prev.cacheReadTokens += cr;
+    } else {
+      daily.set(key, {
+        date,
+        model: norm,
+        costUSD: cost,
+        inputTokens: inp,
+        outputTokens: out,
+        cacheWriteTokens: cw,
+        cacheReadTokens: cr
+      });
+    }
+  }
+  return daily;
+}
+function collectEntries() {
+  const projectsDir = path19.join(os14.homedir(), ".claude", "projects");
+  if (!fs16.existsSync(projectsDir)) return [];
+  const combined = /* @__PURE__ */ new Map();
+  let dirs;
+  try {
+    dirs = fs16.readdirSync(projectsDir);
+  } catch {
+    return [];
+  }
+  for (const dir of dirs) {
+    const dirPath = path19.join(projectsDir, dir);
+    try {
+      if (!fs16.statSync(dirPath).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    let files;
+    try {
+      files = fs16.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const entries = parseJSONLFile(path19.join(dirPath, file));
+      for (const [key, e] of entries) {
+        const prev = combined.get(key);
+        if (prev) {
+          prev.costUSD += e.costUSD;
+          prev.inputTokens += e.inputTokens;
+          prev.outputTokens += e.outputTokens;
+          prev.cacheWriteTokens += e.cacheWriteTokens;
+          prev.cacheReadTokens += e.cacheReadTokens;
+        } else {
+          combined.set(key, { ...e });
+        }
+      }
+    }
+  }
+  return [...combined.values()];
+}
+async function syncCost() {
+  const creds = getCredentials();
+  if (!creds?.apiKey || !creds?.apiUrl) return;
+  const entries = collectEntries();
+  if (entries.length === 0) return;
+  let username = "unknown";
+  try {
+    username = os14.userInfo().username;
+  } catch {
+  }
+  const machineId = `${os14.hostname()}:${username}`;
+  try {
+    const res = await fetch(`${creds.apiUrl}/cost-sync`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${creds.apiKey}` },
+      body: JSON.stringify({ machineId, entries }),
+      signal: AbortSignal.timeout(15e3)
+    });
+    if (!res.ok) {
+      fs16.appendFileSync(HOOK_DEBUG_LOG, `[cost-sync] HTTP ${res.status}
+`);
+    }
+  } catch (err2) {
+    fs16.appendFileSync(HOOK_DEBUG_LOG, `[cost-sync] ${err2.message}
+`);
+  }
+}
+function startCostSync() {
+  syncCost().catch(() => {
+  });
+  const timer = setInterval(() => {
+    syncCost().catch(() => {
+    });
+  }, SYNC_INTERVAL_MS);
+  timer.unref();
+}
+var SYNC_INTERVAL_MS, PRICING;
+var init_costSync = __esm({
+  "src/costSync.ts"() {
+    "use strict";
+    init_config();
+    init_audit();
+    SYNC_INTERVAL_MS = 10 * 60 * 1e3;
+    PRICING = {
+      "claude-opus-4": [5e-6, 25e-6, 625e-8, 5e-7],
+      "claude-sonnet-4": [3e-6, 15e-6, 375e-8, 3e-7],
+      "claude-haiku-4": [8e-7, 4e-6, 1e-6, 8e-8],
+      "claude-3-7-sonnet": [3e-6, 15e-6, 375e-8, 3e-7],
+      "claude-3-5-sonnet": [3e-6, 15e-6, 375e-8, 3e-7],
+      "claude-3-5-haiku": [8e-7, 4e-6, 1e-6, 8e-8],
+      "claude-3-haiku": [25e-8, 125e-8, 3e-7, 3e-8]
+    };
+  }
+});
+
+// src/daemon/server.ts
+import http from "http";
+import fs17 from "fs";
+import path20 from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 import { spawnSync as spawnSync2 } from "child_process";
 import chalk2 from "chalk";
 function startDaemon() {
+  startCostSync();
   loadInsightCounts();
   const csrfToken = randomUUID4();
   const internalToken = randomUUID4();
@@ -6059,7 +6242,7 @@ function startDaemon() {
     idleTimer = setTimeout(() => {
       if (autoStarted) {
         try {
-          fs16.unlinkSync(DAEMON_PID_FILE);
+          fs17.unlinkSync(DAEMON_PID_FILE);
         } catch {
         }
       }
@@ -6222,7 +6405,7 @@ data: ${JSON.stringify(item.data)}
             status: "pending"
           });
         }
-        const projectCwd = typeof cwd === "string" && path19.isAbsolute(cwd) ? cwd : void 0;
+        const projectCwd = typeof cwd === "string" && path20.isAbsolute(cwd) ? cwd : void 0;
         const projectConfig = getConfig(projectCwd);
         const browserEnabled = projectConfig.settings.approvers?.browser !== false;
         const terminalEnabled = projectConfig.settings.approvers?.terminal !== false;
@@ -6612,8 +6795,8 @@ data: ${JSON.stringify(item.data)}
         const body = await readBody(req);
         const data = body ? JSON.parse(body) : {};
         const configPath = data.configPath ?? GLOBAL_CONFIG_PATH;
-        const node9Dir = path19.dirname(GLOBAL_CONFIG_PATH);
-        if (!path19.resolve(configPath).startsWith(node9Dir + path19.sep)) {
+        const node9Dir = path20.dirname(GLOBAL_CONFIG_PATH);
+        if (!path20.resolve(configPath).startsWith(node9Dir + path20.sep)) {
           res.writeHead(400, { "Content-Type": "application/json" });
           return res.end(
             JSON.stringify({ error: "configPath must be within the node9 config directory" })
@@ -6724,14 +6907,14 @@ data: ${JSON.stringify(item.data)}
   server.on("error", (e) => {
     if (e.code === "EADDRINUSE") {
       try {
-        if (fs16.existsSync(DAEMON_PID_FILE)) {
-          const { pid } = JSON.parse(fs16.readFileSync(DAEMON_PID_FILE, "utf-8"));
+        if (fs17.existsSync(DAEMON_PID_FILE)) {
+          const { pid } = JSON.parse(fs17.readFileSync(DAEMON_PID_FILE, "utf-8"));
           process.kill(pid, 0);
           return process.exit(0);
         }
       } catch {
         try {
-          fs16.unlinkSync(DAEMON_PID_FILE);
+          fs17.unlinkSync(DAEMON_PID_FILE);
         } catch {
         }
         server.listen(DAEMON_PORT, DAEMON_HOST);
@@ -6799,32 +6982,33 @@ var init_server = __esm({
     init_state2();
     init_patch();
     init_config_schema();
+    init_costSync();
   }
 });
 
 // src/daemon/index.ts
-import fs17 from "fs";
+import fs18 from "fs";
 import chalk3 from "chalk";
 import { spawnSync as spawnSync3 } from "child_process";
 function stopDaemon() {
-  if (!fs17.existsSync(DAEMON_PID_FILE)) return console.log(chalk3.yellow("Not running."));
+  if (!fs18.existsSync(DAEMON_PID_FILE)) return console.log(chalk3.yellow("Not running."));
   try {
-    const { pid } = JSON.parse(fs17.readFileSync(DAEMON_PID_FILE, "utf-8"));
+    const { pid } = JSON.parse(fs18.readFileSync(DAEMON_PID_FILE, "utf-8"));
     process.kill(pid, "SIGTERM");
     console.log(chalk3.green("\u2705 Stopped."));
   } catch {
     console.log(chalk3.gray("Cleaned up stale PID file."));
   } finally {
     try {
-      fs17.unlinkSync(DAEMON_PID_FILE);
+      fs18.unlinkSync(DAEMON_PID_FILE);
     } catch {
     }
   }
 }
 function daemonStatus() {
-  if (fs17.existsSync(DAEMON_PID_FILE)) {
+  if (fs18.existsSync(DAEMON_PID_FILE)) {
     try {
-      const { pid } = JSON.parse(fs17.readFileSync(DAEMON_PID_FILE, "utf-8"));
+      const { pid } = JSON.parse(fs18.readFileSync(DAEMON_PID_FILE, "utf-8"));
       process.kill(pid, 0);
       console.log(chalk3.green("Node9 daemon: running"));
       return;
@@ -6859,9 +7043,9 @@ __export(tail_exports, {
 });
 import http2 from "http";
 import chalk19 from "chalk";
-import fs28 from "fs";
-import os24 from "os";
-import path31 from "path";
+import fs29 from "fs";
+import os25 from "os";
+import path32 from "path";
 import readline5 from "readline";
 import { spawn as spawn10, execSync as execSync3 } from "child_process";
 function getIcon(tool) {
@@ -6884,7 +7068,7 @@ function formatBase(activity) {
   const time = new Date(activity.ts).toLocaleTimeString([], { hour12: false });
   const icon = getIcon(activity.tool);
   const toolName = activity.tool.slice(0, 16).padEnd(16);
-  const argsStr = JSON.stringify(activity.args ?? {}).replace(/\s+/g, " ").replaceAll(os24.homedir(), "~");
+  const argsStr = JSON.stringify(activity.args ?? {}).replace(/\s+/g, " ").replaceAll(os25.homedir(), "~");
   const argsPreview = argsStr.length > 70 ? argsStr.slice(0, 70) + "\u2026" : argsStr;
   return `${chalk19.gray(time)} ${icon} ${chalk19.white.bold(toolName)} ${chalk19.dim(argsPreview)}`;
 }
@@ -6923,9 +7107,9 @@ function renderPending(activity) {
 }
 async function ensureDaemon() {
   let pidPort = null;
-  if (fs28.existsSync(PID_FILE)) {
+  if (fs29.existsSync(PID_FILE)) {
     try {
-      const { port } = JSON.parse(fs28.readFileSync(PID_FILE, "utf-8"));
+      const { port } = JSON.parse(fs29.readFileSync(PID_FILE, "utf-8"));
       pidPort = port;
     } catch {
       console.error(chalk19.dim("\u26A0\uFE0F  Could not read PID file; falling back to default port."));
@@ -7002,6 +7186,9 @@ function buildCardLines(req, localCount = 0) {
     `${CYAN}\u2551${RESET2} Tool:    ${BOLD2}${req.toolName}${RESET2}`,
     `${CYAN}\u2551${RESET2} Reason:  ${tierLabel} \u2014 ${blockedBy}${RESET2}`
   ];
+  if (req.riskMetadata?.ruleDescription) {
+    lines.push(`${CYAN}\u2551${RESET2} ${YELLOW}\u2139  ${req.riskMetadata.ruleDescription}${RESET2}`);
+  }
   if (req.riskMetadata?.ruleName && blockedBy.includes("Taint")) {
     lines.push(`${CYAN}\u2551${RESET2} ${YELLOW}\u26A0  ${req.riskMetadata.ruleName}${RESET2}`);
   }
@@ -7045,9 +7232,9 @@ function buildRecoveryCardLines(req) {
   ];
 }
 function readApproversFromDisk() {
-  const configPath = path31.join(os24.homedir(), ".node9", "config.json");
+  const configPath = path32.join(os25.homedir(), ".node9", "config.json");
   try {
-    const raw = JSON.parse(fs28.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs29.readFileSync(configPath, "utf-8"));
     const settings = raw.settings ?? {};
     return settings.approvers ?? {};
   } catch {
@@ -7063,15 +7250,15 @@ function approverStatusLine() {
   return `${fmt("native", "native")}  ${fmt("browser", "browser")}  ${fmt("cloud", "cloud")}  ${fmt("terminal", "terminal")}`;
 }
 function toggleApprover(channel) {
-  const configPath = path31.join(os24.homedir(), ".node9", "config.json");
+  const configPath = path32.join(os25.homedir(), ".node9", "config.json");
   try {
-    const raw = JSON.parse(fs28.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs29.readFileSync(configPath, "utf-8"));
     const settings = raw.settings ?? {};
     const approvers = settings.approvers ?? {};
     approvers[channel] = approvers[channel] === false;
     settings.approvers = approvers;
     raw.settings = settings;
-    fs28.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+    fs29.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
   } catch (err2) {
     process.stderr.write(`[node9] toggleApprover failed: ${String(err2)}
 `);
@@ -7241,8 +7428,8 @@ async function startTail(options = {}) {
       }
       postDecisionHttp(req2.id, httpDecision, csrfToken, port, httpOpts).catch((err2) => {
         try {
-          fs28.appendFileSync(
-            path31.join(os24.homedir(), ".node9", "hook-debug.log"),
+          fs29.appendFileSync(
+            path32.join(os25.homedir(), ".node9", "hook-debug.log"),
             `[tail] POST /decision failed: ${String(err2)}
 `
           );
@@ -7502,7 +7689,7 @@ var init_tail = __esm({
     init_daemon2();
     init_daemon();
     init_core();
-    PID_FILE = path31.join(os24.homedir(), ".node9", "daemon.pid");
+    PID_FILE = path32.join(os25.homedir(), ".node9", "daemon.pid");
     ICONS = {
       bash: "\u{1F4BB}",
       shell: "\u{1F4BB}",
@@ -7543,9 +7730,9 @@ __export(hud_exports, {
   main: () => main,
   renderEnvironmentLine: () => renderEnvironmentLine
 });
-import fs29 from "fs";
-import path32 from "path";
-import os25 from "os";
+import fs30 from "fs";
+import path33 from "path";
+import os26 from "os";
 import http3 from "http";
 async function readStdin() {
   const chunks = [];
@@ -7621,9 +7808,9 @@ function formatTimeLeft(resetsAt) {
   return ` (${m}m left)`;
 }
 function safeReadJson(filePath) {
-  if (!fs29.existsSync(filePath)) return null;
+  if (!fs30.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs29.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs30.readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -7644,12 +7831,12 @@ function countHooksInFile(filePath) {
   return Object.keys(cfg.hooks).length;
 }
 function countRulesInDir(rulesDir) {
-  if (!fs29.existsSync(rulesDir)) return 0;
+  if (!fs30.existsSync(rulesDir)) return 0;
   let count = 0;
   try {
-    for (const entry of fs29.readdirSync(rulesDir, { withFileTypes: true })) {
+    for (const entry of fs30.readdirSync(rulesDir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
-        count += countRulesInDir(path32.join(rulesDir, entry.name));
+        count += countRulesInDir(path33.join(rulesDir, entry.name));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
         count++;
       }
@@ -7660,46 +7847,46 @@ function countRulesInDir(rulesDir) {
 }
 function isSamePath(a, b) {
   try {
-    return path32.resolve(a) === path32.resolve(b);
+    return path33.resolve(a) === path33.resolve(b);
   } catch {
     return false;
   }
 }
 function countConfigs(cwd) {
-  const homeDir2 = os25.homedir();
-  const claudeDir = path32.join(homeDir2, ".claude");
+  const homeDir2 = os26.homedir();
+  const claudeDir = path33.join(homeDir2, ".claude");
   let claudeMdCount = 0;
   let rulesCount = 0;
   let hooksCount = 0;
   const userMcpServers = /* @__PURE__ */ new Set();
   const projectMcpServers = /* @__PURE__ */ new Set();
-  if (fs29.existsSync(path32.join(claudeDir, "CLAUDE.md"))) claudeMdCount++;
-  rulesCount += countRulesInDir(path32.join(claudeDir, "rules"));
-  const userSettings = path32.join(claudeDir, "settings.json");
+  if (fs30.existsSync(path33.join(claudeDir, "CLAUDE.md"))) claudeMdCount++;
+  rulesCount += countRulesInDir(path33.join(claudeDir, "rules"));
+  const userSettings = path33.join(claudeDir, "settings.json");
   for (const name of getMcpServerNames(userSettings)) userMcpServers.add(name);
   hooksCount += countHooksInFile(userSettings);
-  const userClaudeJson = path32.join(homeDir2, ".claude.json");
+  const userClaudeJson = path33.join(homeDir2, ".claude.json");
   for (const name of getMcpServerNames(userClaudeJson)) userMcpServers.add(name);
   for (const name of getDisabledMcpServers(userClaudeJson, "disabledMcpServers")) {
     userMcpServers.delete(name);
   }
   if (cwd) {
-    if (fs29.existsSync(path32.join(cwd, "CLAUDE.md"))) claudeMdCount++;
-    if (fs29.existsSync(path32.join(cwd, "CLAUDE.local.md"))) claudeMdCount++;
-    const projectClaudeDir = path32.join(cwd, ".claude");
+    if (fs30.existsSync(path33.join(cwd, "CLAUDE.md"))) claudeMdCount++;
+    if (fs30.existsSync(path33.join(cwd, "CLAUDE.local.md"))) claudeMdCount++;
+    const projectClaudeDir = path33.join(cwd, ".claude");
     const overlapsUserScope = isSamePath(projectClaudeDir, claudeDir);
     if (!overlapsUserScope) {
-      if (fs29.existsSync(path32.join(projectClaudeDir, "CLAUDE.md"))) claudeMdCount++;
-      rulesCount += countRulesInDir(path32.join(projectClaudeDir, "rules"));
-      const projSettings = path32.join(projectClaudeDir, "settings.json");
+      if (fs30.existsSync(path33.join(projectClaudeDir, "CLAUDE.md"))) claudeMdCount++;
+      rulesCount += countRulesInDir(path33.join(projectClaudeDir, "rules"));
+      const projSettings = path33.join(projectClaudeDir, "settings.json");
       for (const name of getMcpServerNames(projSettings)) projectMcpServers.add(name);
       hooksCount += countHooksInFile(projSettings);
     }
-    if (fs29.existsSync(path32.join(projectClaudeDir, "CLAUDE.local.md"))) claudeMdCount++;
-    const localSettings = path32.join(projectClaudeDir, "settings.local.json");
+    if (fs30.existsSync(path33.join(projectClaudeDir, "CLAUDE.local.md"))) claudeMdCount++;
+    const localSettings = path33.join(projectClaudeDir, "settings.local.json");
     for (const name of getMcpServerNames(localSettings)) projectMcpServers.add(name);
     hooksCount += countHooksInFile(localSettings);
-    const mcpJsonServers = getMcpServerNames(path32.join(cwd, ".mcp.json"));
+    const mcpJsonServers = getMcpServerNames(path33.join(cwd, ".mcp.json"));
     const disabledMcpJson = getDisabledMcpServers(localSettings, "disabledMcpjsonServers");
     for (const name of disabledMcpJson) mcpJsonServers.delete(name);
     for (const name of mcpJsonServers) projectMcpServers.add(name);
@@ -7732,12 +7919,12 @@ function readActiveShieldsHud() {
     return shieldsCache.value;
   }
   try {
-    const shieldsPath = path32.join(os25.homedir(), ".node9", "shields.json");
-    if (!fs29.existsSync(shieldsPath)) {
+    const shieldsPath = path33.join(os26.homedir(), ".node9", "shields.json");
+    if (!fs30.existsSync(shieldsPath)) {
       shieldsCache = { value: [], ts: now };
       return [];
     }
-    const parsed = JSON.parse(fs29.readFileSync(shieldsPath, "utf-8"));
+    const parsed = JSON.parse(fs30.readFileSync(shieldsPath, "utf-8"));
     if (!Array.isArray(parsed.active)) {
       shieldsCache = { value: [], ts: now };
       return [];
@@ -7839,17 +8026,17 @@ function renderContextLine(stdin) {
 async function main() {
   try {
     const [stdin, daemonStatus2] = await Promise.all([readStdin(), queryDaemon()]);
-    if (fs29.existsSync(path32.join(os25.homedir(), ".node9", "hud-debug"))) {
+    if (fs30.existsSync(path33.join(os26.homedir(), ".node9", "hud-debug"))) {
       try {
-        const logPath = path32.join(os25.homedir(), ".node9", "hud-debug.log");
+        const logPath = path33.join(os26.homedir(), ".node9", "hud-debug.log");
         const MAX_LOG_SIZE = 10 * 1024 * 1024;
         let size = 0;
         try {
-          size = fs29.statSync(logPath).size;
+          size = fs30.statSync(logPath).size;
         } catch {
         }
         if (size < MAX_LOG_SIZE) {
-          fs29.appendFileSync(
+          fs30.appendFileSync(
             logPath,
             JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), stdin }) + "\n"
           );
@@ -7870,11 +8057,11 @@ async function main() {
       try {
         const cwd = stdin.cwd ?? process.cwd();
         for (const configPath of [
-          path32.join(cwd, "node9.config.json"),
-          path32.join(os25.homedir(), ".node9", "config.json")
+          path33.join(cwd, "node9.config.json"),
+          path33.join(os26.homedir(), ".node9", "config.json")
         ]) {
-          if (!fs29.existsSync(configPath)) continue;
-          const cfg = JSON.parse(fs29.readFileSync(configPath, "utf-8"));
+          if (!fs30.existsSync(configPath)) continue;
+          const cfg = JSON.parse(fs30.readFileSync(configPath, "utf-8"));
           const hud = cfg.settings?.hud;
           if (hud && "showEnvironmentCounts" in hud) return hud.showEnvironmentCounts !== false;
         }
@@ -8504,9 +8691,9 @@ function teardownHud() {
 // src/cli.ts
 init_daemon2();
 import chalk20 from "chalk";
-import fs30 from "fs";
-import path33 from "path";
-import os26 from "os";
+import fs31 from "fs";
+import path34 from "path";
+import os27 from "os";
 import { confirm as confirm2 } from "@inquirer/prompts";
 
 // src/utils/duration.ts
@@ -8735,19 +8922,19 @@ init_daemon();
 init_config();
 init_policy();
 import chalk5 from "chalk";
-import fs19 from "fs";
+import fs20 from "fs";
 import { spawn as spawn6 } from "child_process";
-import path21 from "path";
-import os15 from "os";
+import path22 from "path";
+import os16 from "os";
 
 // src/undo.ts
 import { spawnSync as spawnSync4, spawn as spawn5 } from "child_process";
 import crypto3 from "crypto";
-import fs18 from "fs";
+import fs19 from "fs";
 import net3 from "net";
-import path20 from "path";
-import os14 from "os";
-var ACTIVITY_SOCKET_PATH3 = process.platform === "win32" ? "\\\\.\\pipe\\node9-activity" : path20.join(os14.tmpdir(), "node9-activity.sock");
+import path21 from "path";
+import os15 from "os";
+var ACTIVITY_SOCKET_PATH3 = process.platform === "win32" ? "\\\\.\\pipe\\node9-activity" : path21.join(os15.tmpdir(), "node9-activity.sock");
 function notifySnapshotTaken(hash, tool, argsSummary, fileCount) {
   try {
     const payload = JSON.stringify({
@@ -8767,22 +8954,22 @@ function notifySnapshotTaken(hash, tool, argsSummary, fileCount) {
   } catch {
   }
 }
-var SNAPSHOT_STACK_PATH = path20.join(os14.homedir(), ".node9", "snapshots.json");
-var UNDO_LATEST_PATH = path20.join(os14.homedir(), ".node9", "undo_latest.txt");
+var SNAPSHOT_STACK_PATH = path21.join(os15.homedir(), ".node9", "snapshots.json");
+var UNDO_LATEST_PATH = path21.join(os15.homedir(), ".node9", "undo_latest.txt");
 var MAX_SNAPSHOTS = 10;
 var GIT_TIMEOUT = 15e3;
 function readStack() {
   try {
-    if (fs18.existsSync(SNAPSHOT_STACK_PATH))
-      return JSON.parse(fs18.readFileSync(SNAPSHOT_STACK_PATH, "utf-8"));
+    if (fs19.existsSync(SNAPSHOT_STACK_PATH))
+      return JSON.parse(fs19.readFileSync(SNAPSHOT_STACK_PATH, "utf-8"));
   } catch {
   }
   return [];
 }
 function writeStack(stack) {
-  const dir = path20.dirname(SNAPSHOT_STACK_PATH);
-  if (!fs18.existsSync(dir)) fs18.mkdirSync(dir, { recursive: true });
-  fs18.writeFileSync(SNAPSHOT_STACK_PATH, JSON.stringify(stack, null, 2));
+  const dir = path21.dirname(SNAPSHOT_STACK_PATH);
+  if (!fs19.existsSync(dir)) fs19.mkdirSync(dir, { recursive: true });
+  fs19.writeFileSync(SNAPSHOT_STACK_PATH, JSON.stringify(stack, null, 2));
 }
 function extractFilePath(args) {
   if (!args || typeof args !== "object") return null;
@@ -8802,12 +8989,12 @@ function buildArgsSummary(tool, args) {
   return "";
 }
 function findProjectRoot(filePath) {
-  let dir = path20.dirname(filePath);
+  let dir = path21.dirname(filePath);
   while (true) {
-    if (fs18.existsSync(path20.join(dir, ".git")) || fs18.existsSync(path20.join(dir, "package.json"))) {
+    if (fs19.existsSync(path21.join(dir, ".git")) || fs19.existsSync(path21.join(dir, "package.json"))) {
       return dir;
     }
-    const parent = path20.dirname(dir);
+    const parent = path21.dirname(dir);
     if (parent === dir) return process.cwd();
     dir = parent;
   }
@@ -8815,7 +9002,7 @@ function findProjectRoot(filePath) {
 function normalizeCwdForHash(cwd) {
   let normalized;
   try {
-    normalized = fs18.realpathSync(cwd);
+    normalized = fs19.realpathSync(cwd);
   } catch {
     normalized = cwd;
   }
@@ -8825,16 +9012,16 @@ function normalizeCwdForHash(cwd) {
 }
 function getShadowRepoDir(cwd) {
   const hash = crypto3.createHash("sha256").update(normalizeCwdForHash(cwd)).digest("hex").slice(0, 16);
-  return path20.join(os14.homedir(), ".node9", "snapshots", hash);
+  return path21.join(os15.homedir(), ".node9", "snapshots", hash);
 }
 function cleanOrphanedIndexFiles(shadowDir) {
   try {
     const cutoff = Date.now() - 6e4;
-    for (const f of fs18.readdirSync(shadowDir)) {
+    for (const f of fs19.readdirSync(shadowDir)) {
       if (f.startsWith("index_")) {
-        const fp = path20.join(shadowDir, f);
+        const fp = path21.join(shadowDir, f);
         try {
-          if (fs18.statSync(fp).mtimeMs < cutoff) fs18.unlinkSync(fp);
+          if (fs19.statSync(fp).mtimeMs < cutoff) fs19.unlinkSync(fp);
         } catch {
         }
       }
@@ -8846,7 +9033,7 @@ function writeShadowExcludes(shadowDir, ignorePaths) {
   const hardcoded = [".git", ".node9"];
   const lines = [...hardcoded, ...ignorePaths].join("\n");
   try {
-    fs18.writeFileSync(path20.join(shadowDir, "info", "exclude"), lines + "\n", "utf8");
+    fs19.writeFileSync(path21.join(shadowDir, "info", "exclude"), lines + "\n", "utf8");
   } catch {
   }
 }
@@ -8859,25 +9046,25 @@ function ensureShadowRepo(shadowDir, cwd) {
     timeout: 3e3
   });
   if (check.status === 0) {
-    const ptPath = path20.join(shadowDir, "project-path.txt");
+    const ptPath = path21.join(shadowDir, "project-path.txt");
     try {
-      const stored = fs18.readFileSync(ptPath, "utf8").trim();
+      const stored = fs19.readFileSync(ptPath, "utf8").trim();
       if (stored === normalizedCwd) return true;
       if (process.env.NODE9_DEBUG === "1")
         console.error(
           `[Node9] Shadow repo path mismatch: stored="${stored}" expected="${normalizedCwd}" \u2014 reinitializing`
         );
-      fs18.rmSync(shadowDir, { recursive: true, force: true });
+      fs19.rmSync(shadowDir, { recursive: true, force: true });
     } catch {
       try {
-        fs18.writeFileSync(ptPath, normalizedCwd, "utf8");
+        fs19.writeFileSync(ptPath, normalizedCwd, "utf8");
       } catch {
       }
       return true;
     }
   }
   try {
-    fs18.mkdirSync(shadowDir, { recursive: true });
+    fs19.mkdirSync(shadowDir, { recursive: true });
   } catch {
   }
   const init = spawnSync4("git", ["init", "--bare", shadowDir], { timeout: 5e3 });
@@ -8886,7 +9073,7 @@ function ensureShadowRepo(shadowDir, cwd) {
     if (process.env.NODE9_DEBUG === "1") console.error("[Node9] git init --bare failed:", reason);
     return false;
   }
-  const configFile = path20.join(shadowDir, "config");
+  const configFile = path21.join(shadowDir, "config");
   spawnSync4("git", ["config", "--file", configFile, "core.untrackedCache", "true"], {
     timeout: 3e3
   });
@@ -8894,7 +9081,7 @@ function ensureShadowRepo(shadowDir, cwd) {
     timeout: 3e3
   });
   try {
-    fs18.writeFileSync(path20.join(shadowDir, "project-path.txt"), normalizedCwd, "utf8");
+    fs19.writeFileSync(path21.join(shadowDir, "project-path.txt"), normalizedCwd, "utf8");
   } catch {
   }
   return true;
@@ -8914,12 +9101,12 @@ async function createShadowSnapshot(tool = "unknown", args = {}, ignorePaths = [
   let indexFile = null;
   try {
     const rawFilePath = extractFilePath(args);
-    const absFilePath = rawFilePath && path20.isAbsolute(rawFilePath) ? rawFilePath : null;
+    const absFilePath = rawFilePath && path21.isAbsolute(rawFilePath) ? rawFilePath : null;
     const cwd = absFilePath ? findProjectRoot(absFilePath) : process.cwd();
     const shadowDir = getShadowRepoDir(cwd);
     if (!ensureShadowRepo(shadowDir, cwd)) return null;
     writeShadowExcludes(shadowDir, ignorePaths);
-    indexFile = path20.join(shadowDir, `index_${process.pid}_${Date.now()}`);
+    indexFile = path21.join(shadowDir, `index_${process.pid}_${Date.now()}`);
     const shadowEnv = {
       ...process.env,
       GIT_DIR: shadowDir,
@@ -8991,7 +9178,7 @@ async function createShadowSnapshot(tool = "unknown", args = {}, ignorePaths = [
     writeStack(stack);
     const entry = stack[stack.length - 1];
     notifySnapshotTaken(commitHash.slice(0, 7), tool, entry.argsSummary, capturedFiles.length);
-    fs18.writeFileSync(UNDO_LATEST_PATH, commitHash);
+    fs19.writeFileSync(UNDO_LATEST_PATH, commitHash);
     if (shouldGc) {
       spawn5("git", ["gc", "--auto"], { env: shadowEnv, detached: true, stdio: "ignore" }).unref();
     }
@@ -9002,7 +9189,7 @@ async function createShadowSnapshot(tool = "unknown", args = {}, ignorePaths = [
   } finally {
     if (indexFile) {
       try {
-        fs18.unlinkSync(indexFile);
+        fs19.unlinkSync(indexFile);
       } catch {
       }
     }
@@ -9078,9 +9265,9 @@ function applyUndo(hash, cwd) {
       timeout: GIT_TIMEOUT
     }).stdout?.toString().trim().split("\n").filter(Boolean) ?? [];
     for (const file of [...tracked, ...untracked]) {
-      const fullPath = path20.join(dir, file);
-      if (!snapshotFiles.has(file) && fs18.existsSync(fullPath)) {
-        fs18.unlinkSync(fullPath);
+      const fullPath = path21.join(dir, file);
+      if (!snapshotFiles.has(file) && fs19.existsSync(fullPath)) {
+        fs19.unlinkSync(fullPath);
       }
     }
     return true;
@@ -9104,9 +9291,9 @@ function registerCheckCommand(program2) {
         } catch (err2) {
           const tempConfig = getConfig();
           if (process.env.NODE9_DEBUG === "1" || tempConfig.settings.enableHookLogDebug) {
-            const logPath = path21.join(os15.homedir(), ".node9", "hook-debug.log");
+            const logPath = path22.join(os16.homedir(), ".node9", "hook-debug.log");
             const errMsg = err2 instanceof Error ? err2.message : String(err2);
-            fs19.appendFileSync(
+            fs20.appendFileSync(
               logPath,
               `[${(/* @__PURE__ */ new Date()).toISOString()}] JSON_PARSE_ERROR: ${errMsg}
 RAW: ${raw}
@@ -9119,10 +9306,10 @@ RAW: ${raw}
         if (config.settings.autoStartDaemon && !isDaemonRunning() && !process.env.NODE9_NO_AUTO_DAEMON) {
           try {
             const scriptPath = process.argv[1];
-            if (typeof scriptPath !== "string" || !path21.isAbsolute(scriptPath))
+            if (typeof scriptPath !== "string" || !path22.isAbsolute(scriptPath))
               throw new Error("node9: argv[1] is not an absolute path");
-            const resolvedScript = fs19.realpathSync(scriptPath);
-            const expectedCli = fs19.realpathSync(path21.resolve(__dirname, "../../cli.js"));
+            const resolvedScript = fs20.realpathSync(scriptPath);
+            const expectedCli = fs20.realpathSync(path22.resolve(__dirname, "../../cli.js"));
             if (resolvedScript !== expectedCli)
               throw new Error(
                 "node9: daemon spawn aborted \u2014 argv[1] does not resolve to the node9 CLI"
@@ -9148,10 +9335,10 @@ RAW: ${raw}
           }
         }
         if (process.env.NODE9_DEBUG === "1" || config.settings.enableHookLogDebug) {
-          const logPath = path21.join(os15.homedir(), ".node9", "hook-debug.log");
-          if (!fs19.existsSync(path21.dirname(logPath)))
-            fs19.mkdirSync(path21.dirname(logPath), { recursive: true });
-          fs19.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] STDIN: ${raw}
+          const logPath = path22.join(os16.homedir(), ".node9", "hook-debug.log");
+          if (!fs20.existsSync(path22.dirname(logPath)))
+            fs20.mkdirSync(path22.dirname(logPath), { recursive: true });
+          fs20.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] STDIN: ${raw}
 `);
         }
         const toolName = sanitize2(payload.tool_name ?? payload.name ?? "");
@@ -9164,8 +9351,8 @@ RAW: ${raw}
           const isHumanDecision = blockedByContext.toLowerCase().includes("user") || blockedByContext.toLowerCase().includes("daemon") || blockedByContext.toLowerCase().includes("decision");
           let ttyFd = null;
           try {
-            ttyFd = fs19.openSync("/dev/tty", "w");
-            const writeTty = (line) => fs19.writeSync(ttyFd, line + "\n");
+            ttyFd = fs20.openSync("/dev/tty", "w");
+            const writeTty = (line) => fs20.writeSync(ttyFd, line + "\n");
             if (blockedByContext.includes("DLP") || blockedByContext.includes("Secret Detected") || blockedByContext.includes("Credential Review")) {
               writeTty(chalk5.bgRed.white.bold(`
  \u{1F6A8} NODE9 DLP ALERT \u2014 CREDENTIAL DETECTED `));
@@ -9184,7 +9371,7 @@ RAW: ${raw}
           } finally {
             if (ttyFd !== null)
               try {
-                fs19.closeSync(ttyFd);
+                fs20.closeSync(ttyFd);
               } catch {
               }
           }
@@ -9216,7 +9403,7 @@ RAW: ${raw}
         if (shouldSnapshot(toolName, toolInput, config)) {
           await createShadowSnapshot(toolName, toolInput, config.policy.snapshot.ignorePaths);
         }
-        const safeCwdForAuth = typeof payload.cwd === "string" && path21.isAbsolute(payload.cwd) ? payload.cwd : void 0;
+        const safeCwdForAuth = typeof payload.cwd === "string" && path22.isAbsolute(payload.cwd) ? payload.cwd : void 0;
         const result = await authorizeHeadless(toolName, toolInput, meta, {
           cwd: safeCwdForAuth
         });
@@ -9228,12 +9415,12 @@ RAW: ${raw}
         }
         if (result.noApprovalMechanism && !isDaemonRunning() && !process.env.NODE9_NO_AUTO_DAEMON && !process.stdout.isTTY && config.settings.autoStartDaemon) {
           try {
-            const tty = fs19.openSync("/dev/tty", "w");
-            fs19.writeSync(
+            const tty = fs20.openSync("/dev/tty", "w");
+            fs20.writeSync(
               tty,
               chalk5.cyan("\n\u{1F6E1}\uFE0F  Node9: Starting approval daemon automatically...\n")
             );
-            fs19.closeSync(tty);
+            fs20.closeSync(tty);
           } catch {
           }
           const daemonReady = await autoStartDaemonAndWait();
@@ -9260,9 +9447,9 @@ RAW: ${raw}
         });
       } catch (err2) {
         if (process.env.NODE9_DEBUG === "1") {
-          const logPath = path21.join(os15.homedir(), ".node9", "hook-debug.log");
+          const logPath = path22.join(os16.homedir(), ".node9", "hook-debug.log");
           const errMsg = err2 instanceof Error ? err2.message : String(err2);
-          fs19.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR: ${errMsg}
+          fs20.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR: ${errMsg}
 `);
         }
         process.exit(0);
@@ -9299,9 +9486,9 @@ RAW: ${raw}
 init_audit();
 init_config();
 init_policy();
-import fs20 from "fs";
-import path22 from "path";
-import os16 from "os";
+import fs21 from "fs";
+import path23 from "path";
+import os17 from "os";
 init_daemon();
 
 // src/utils/cp-mv-parser.ts
@@ -9374,10 +9561,10 @@ function registerLogCommand(program2) {
           decision: "allowed",
           source: "post-hook"
         };
-        const logPath = path22.join(os16.homedir(), ".node9", "audit.log");
-        if (!fs20.existsSync(path22.dirname(logPath)))
-          fs20.mkdirSync(path22.dirname(logPath), { recursive: true });
-        fs20.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+        const logPath = path23.join(os17.homedir(), ".node9", "audit.log");
+        if (!fs21.existsSync(path23.dirname(logPath)))
+          fs21.mkdirSync(path23.dirname(logPath), { recursive: true });
+        fs21.appendFileSync(logPath, JSON.stringify(entry) + "\n");
         if ((tool === "Bash" || tool === "bash") && isDaemonRunning()) {
           const command = typeof rawInput === "object" && rawInput !== null && "command" in rawInput && typeof rawInput.command === "string" ? rawInput.command : null;
           if (command) {
@@ -9410,7 +9597,7 @@ function registerLogCommand(program2) {
             }
           }
         }
-        const safeCwd = typeof payload.cwd === "string" && path22.isAbsolute(payload.cwd) ? payload.cwd : void 0;
+        const safeCwd = typeof payload.cwd === "string" && path23.isAbsolute(payload.cwd) ? payload.cwd : void 0;
         const config = getConfig(safeCwd);
         if (shouldSnapshot(tool, {}, config)) {
           await createShadowSnapshot("unknown", {}, config.policy.snapshot.ignorePaths);
@@ -9419,9 +9606,9 @@ function registerLogCommand(program2) {
         const msg = err2 instanceof Error ? err2.message : String(err2);
         process.stderr.write(`[Node9] audit log error: ${msg}
 `);
-        const debugPath = path22.join(os16.homedir(), ".node9", "hook-debug.log");
+        const debugPath = path23.join(os17.homedir(), ".node9", "hook-debug.log");
         try {
-          fs20.appendFileSync(debugPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] LOG_ERROR: ${msg}
+          fs21.appendFileSync(debugPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] LOG_ERROR: ${msg}
 `);
         } catch {
         }
@@ -9822,13 +10009,13 @@ function registerConfigShowCommand(program2) {
 // src/cli/commands/doctor.ts
 init_daemon();
 import chalk7 from "chalk";
-import fs21 from "fs";
-import path23 from "path";
-import os17 from "os";
+import fs22 from "fs";
+import path24 from "path";
+import os18 from "os";
 import { execSync as execSync2 } from "child_process";
 function registerDoctorCommand(program2, version2) {
   program2.command("doctor").description("Check that Node9 is installed and configured correctly").action(() => {
-    const homeDir2 = os17.homedir();
+    const homeDir2 = os18.homedir();
     let failures = 0;
     function pass(msg) {
       console.log(chalk7.green("  \u2705 ") + msg);
@@ -9877,10 +10064,10 @@ function registerDoctorCommand(program2, version2) {
       );
     }
     section("Configuration");
-    const globalConfigPath = path23.join(homeDir2, ".node9", "config.json");
-    if (fs21.existsSync(globalConfigPath)) {
+    const globalConfigPath = path24.join(homeDir2, ".node9", "config.json");
+    if (fs22.existsSync(globalConfigPath)) {
       try {
-        JSON.parse(fs21.readFileSync(globalConfigPath, "utf-8"));
+        JSON.parse(fs22.readFileSync(globalConfigPath, "utf-8"));
         pass("~/.node9/config.json found and valid");
       } catch {
         fail("~/.node9/config.json is invalid JSON", "Run: node9 init --force");
@@ -9888,10 +10075,10 @@ function registerDoctorCommand(program2, version2) {
     } else {
       warn("~/.node9/config.json not found (using defaults)", "Run: node9 init");
     }
-    const projectConfigPath = path23.join(process.cwd(), "node9.config.json");
-    if (fs21.existsSync(projectConfigPath)) {
+    const projectConfigPath = path24.join(process.cwd(), "node9.config.json");
+    if (fs22.existsSync(projectConfigPath)) {
       try {
-        JSON.parse(fs21.readFileSync(projectConfigPath, "utf-8"));
+        JSON.parse(fs22.readFileSync(projectConfigPath, "utf-8"));
         pass("node9.config.json found and valid (project)");
       } catch {
         fail(
@@ -9900,8 +10087,8 @@ function registerDoctorCommand(program2, version2) {
         );
       }
     }
-    const credsPath = path23.join(homeDir2, ".node9", "credentials.json");
-    if (fs21.existsSync(credsPath)) {
+    const credsPath = path24.join(homeDir2, ".node9", "credentials.json");
+    if (fs22.existsSync(credsPath)) {
       pass("Cloud credentials found (~/.node9/credentials.json)");
     } else {
       warn(
@@ -9910,10 +10097,10 @@ function registerDoctorCommand(program2, version2) {
       );
     }
     section("Agent Hooks");
-    const claudeSettingsPath = path23.join(homeDir2, ".claude", "settings.json");
-    if (fs21.existsSync(claudeSettingsPath)) {
+    const claudeSettingsPath = path24.join(homeDir2, ".claude", "settings.json");
+    if (fs22.existsSync(claudeSettingsPath)) {
       try {
-        const cs = JSON.parse(fs21.readFileSync(claudeSettingsPath, "utf-8"));
+        const cs = JSON.parse(fs22.readFileSync(claudeSettingsPath, "utf-8"));
         const hasHook = cs.hooks?.PreToolUse?.some(
           (m) => m.hooks.some((h) => h.command?.includes("node9") || h.command?.includes("cli.js"))
         );
@@ -9929,10 +10116,10 @@ function registerDoctorCommand(program2, version2) {
     } else {
       warn("Claude Code \u2014 not configured", "Run: node9 setup claude");
     }
-    const geminiSettingsPath = path23.join(homeDir2, ".gemini", "settings.json");
-    if (fs21.existsSync(geminiSettingsPath)) {
+    const geminiSettingsPath = path24.join(homeDir2, ".gemini", "settings.json");
+    if (fs22.existsSync(geminiSettingsPath)) {
       try {
-        const gs = JSON.parse(fs21.readFileSync(geminiSettingsPath, "utf-8"));
+        const gs = JSON.parse(fs22.readFileSync(geminiSettingsPath, "utf-8"));
         const hasHook = gs.hooks?.BeforeTool?.some(
           (m) => m.hooks.some((h) => h.command?.includes("node9") || h.command?.includes("cli.js"))
         );
@@ -9948,10 +10135,10 @@ function registerDoctorCommand(program2, version2) {
     } else {
       warn("Gemini CLI  \u2014 not configured", "Run: node9 setup gemini  (skip if not using Gemini)");
     }
-    const cursorHooksPath = path23.join(homeDir2, ".cursor", "hooks.json");
-    if (fs21.existsSync(cursorHooksPath)) {
+    const cursorHooksPath = path24.join(homeDir2, ".cursor", "hooks.json");
+    if (fs22.existsSync(cursorHooksPath)) {
       try {
-        const cur = JSON.parse(fs21.readFileSync(cursorHooksPath, "utf-8"));
+        const cur = JSON.parse(fs22.readFileSync(cursorHooksPath, "utf-8"));
         const hasHook = cur.hooks?.preToolUse?.some(
           (h) => h.command?.includes("node9") || h.command?.includes("cli.js")
         );
@@ -9989,9 +10176,9 @@ function registerDoctorCommand(program2, version2) {
 
 // src/cli/commands/audit.ts
 import chalk8 from "chalk";
-import fs22 from "fs";
-import path24 from "path";
-import os18 from "os";
+import fs23 from "fs";
+import path25 from "path";
+import os19 from "os";
 function formatRelativeTime(timestamp) {
   const diff = Date.now() - new Date(timestamp).getTime();
   const sec = Math.floor(diff / 1e3);
@@ -10004,14 +10191,14 @@ function formatRelativeTime(timestamp) {
 }
 function registerAuditCommand(program2) {
   program2.command("audit").description("View local execution audit log").option("--tail <n>", "Number of entries to show", "20").option("--tool <pattern>", "Filter by tool name (substring match)").option("--deny", "Show only denied actions").option("--json", "Output raw JSON").action((options) => {
-    const logPath = path24.join(os18.homedir(), ".node9", "audit.log");
-    if (!fs22.existsSync(logPath)) {
+    const logPath = path25.join(os19.homedir(), ".node9", "audit.log");
+    if (!fs23.existsSync(logPath)) {
       console.log(
         chalk8.yellow("No audit logs found. Run node9 with an agent to generate entries.")
       );
       return;
     }
-    const raw = fs22.readFileSync(logPath, "utf-8");
+    const raw = fs23.readFileSync(logPath, "utf-8");
     const lines = raw.split("\n").filter((l) => l.trim() !== "");
     let entries = lines.flatMap((line) => {
       try {
@@ -10065,9 +10252,9 @@ function registerAuditCommand(program2) {
 
 // src/cli/commands/report.ts
 import chalk9 from "chalk";
-import fs23 from "fs";
-import path25 from "path";
-import os19 from "os";
+import fs24 from "fs";
+import path26 from "path";
+import os20 from "os";
 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();
@@ -10114,8 +10301,8 @@ function getDateRange(period) {
   }
 }
 function parseAuditLog(logPath) {
-  if (!fs23.existsSync(logPath)) return [];
-  const raw = fs23.readFileSync(logPath, "utf-8");
+  if (!fs24.existsSync(logPath)) return [];
+  const raw = fs24.readFileSync(logPath, "utf-8");
   return raw.split("\n").flatMap((line) => {
     if (!line.trim()) return [];
     try {
@@ -10177,29 +10364,39 @@ function claudeModelPrice(model) {
   return null;
 }
 function loadClaudeCost(start, end) {
-  const projectsDir = path25.join(os19.homedir(), ".claude", "projects");
-  if (!fs23.existsSync(projectsDir)) return { total: 0, byDay: /* @__PURE__ */ new Map() };
+  const empty = {
+    total: 0,
+    byDay: /* @__PURE__ */ new Map(),
+    byModel: /* @__PURE__ */ new Map(),
+    inputTokens: 0,
+    cacheReadTokens: 0
+  };
+  const projectsDir = path26.join(os20.homedir(), ".claude", "projects");
+  if (!fs24.existsSync(projectsDir)) return empty;
   let dirs;
   try {
-    dirs = fs23.readdirSync(projectsDir);
+    dirs = fs24.readdirSync(projectsDir);
   } catch {
-    return { total: 0, byDay: /* @__PURE__ */ new Map() };
+    return empty;
   }
   let total = 0;
+  let inputTokens = 0;
+  let cacheReadTokens = 0;
   const byDay = /* @__PURE__ */ new Map();
+  const byModel = /* @__PURE__ */ new Map();
   for (const proj of dirs) {
-    const projPath = path25.join(projectsDir, proj);
+    const projPath = path26.join(projectsDir, proj);
     let files;
     try {
-      const stat = fs23.statSync(projPath);
+      const stat = fs24.statSync(projPath);
       if (!stat.isDirectory()) continue;
-      files = fs23.readdirSync(projPath).filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
+      files = fs24.readdirSync(projPath).filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
     } catch {
       continue;
     }
     for (const file of files) {
       try {
-        const raw = fs23.readFileSync(path25.join(projPath, file), "utf-8");
+        const raw = fs24.readFileSync(path26.join(projPath, file), "utf-8");
         for (const line of raw.split("\n")) {
           if (!line.trim()) continue;
           let entry;
@@ -10217,24 +10414,32 @@ function loadClaudeCost(start, end) {
           if (!usage || !model) continue;
           const p = claudeModelPrice(model);
           if (!p) continue;
-          const cost = (usage.input_tokens ?? 0) * p.i + (usage.output_tokens ?? 0) * p.o + (usage.cache_creation_input_tokens ?? 0) * p.cw + (usage.cache_read_input_tokens ?? 0) * p.cr;
+          const inp = usage.input_tokens ?? 0;
+          const out = usage.output_tokens ?? 0;
+          const cw = usage.cache_creation_input_tokens ?? 0;
+          const cr = usage.cache_read_input_tokens ?? 0;
+          const cost = inp * p.i + out * p.o + cw * p.cw + cr * p.cr;
           total += cost;
+          inputTokens += inp;
+          cacheReadTokens += cr;
           const dateKey = entry.timestamp.slice(0, 10);
           byDay.set(dateKey, (byDay.get(dateKey) ?? 0) + cost);
+          const normModel = model.replace(/@.*$/, "").replace(/-\d{8}$/, "");
+          byModel.set(normModel, (byModel.get(normModel) ?? 0) + cost);
         }
       } catch {
         continue;
       }
     }
   }
-  return { total, byDay };
+  return { total, byDay, byModel, inputTokens, cacheReadTokens };
 }
 function registerReportCommand(program2) {
   program2.command("report").description("Activity and security report \u2014 what Claude did, what was blocked").option("--period <period>", "today | 7d | 30d | month", "7d").option("--no-tests", "exclude test runner calls (npm test, vitest, pytest\u2026) from stats").action((options) => {
     const period = ["today", "7d", "30d", "month"].includes(
       options.period
     ) ? options.period : "7d";
-    const logPath = path25.join(os19.homedir(), ".node9", "audit.log");
+    const logPath = path26.join(os20.homedir(), ".node9", "audit.log");
     const allEntries = parseAuditLog(logPath);
     if (allEntries.length === 0) {
       console.log(
@@ -10243,7 +10448,13 @@ function registerReportCommand(program2) {
       return;
     }
     const { start, end } = getDateRange(period);
-    const { total: costUSD, byDay: costByDay } = loadClaudeCost(start, end);
+    const {
+      total: costUSD,
+      byDay: costByDay,
+      byModel: costByModel,
+      inputTokens: costInputTokens,
+      cacheReadTokens: costCacheRead
+    } = loadClaudeCost(start, end);
     const periodMs = end.getTime() - start.getTime();
     const priorEnd = new Date(start.getTime() - 1);
     const priorStart = new Date(start.getTime() - periodMs);
@@ -10345,7 +10556,6 @@ function registerReportCommand(program2) {
     const blockLabel = blocked > 0 ? chalk9.red(`\u{1F6D1} ${num(blocked)} blocked`) : chalk9.dim("\u{1F6D1} 0 blocked");
     const dlpLabel = dlpHits > 0 ? chalk9.yellow(`\u{1F6A8} ${dlpHits} DLP hits`) : chalk9.dim("\u{1F6A8} 0 DLP hits");
     const loopLabel = loopHits > 0 ? chalk9.yellow(`\u{1F504} ${loopHits} loops`) : chalk9.dim("\u{1F504} 0 loops");
-    const costLabel = costUSD > 0 ? chalk9.magenta(`\u{1F4B0} ${fmtCost(costUSD)}`) : chalk9.dim("\u{1F4B0} \u2013");
     const currentRate = total > 0 ? blocked / total : 0;
     const trendLabel = (() => {
       if (priorBlockRate === null) return chalk9.dim(`${pct(blocked, total)} block rate`);
@@ -10358,7 +10568,7 @@ function registerReportCommand(program2) {
     const ratioLabel = reads > 0 ? chalk9.dim(`edit/read ${(edits / reads).toFixed(1)}`) : chalk9.dim("edit/read \u2013");
     const testLabel = testPasses + testFails > 0 ? chalk9.dim("tests ") + chalk9.green(`${testPasses}\u2713`) + (testFails > 0 ? " " + chalk9.red(`${testFails}\u2717`) : "") : chalk9.dim("tests \u2013");
     console.log(
-      "  " + chalk9.green(`\u2705 ${num(allowed)} allowed`) + "   " + blockLabel + "   " + dlpLabel + "   " + loopLabel + "   " + trendLabel + "   " + costLabel
+      "  " + chalk9.green(`\u2705 ${num(allowed)} allowed`) + "   " + blockLabel + "   " + dlpLabel + "   " + loopLabel + "   " + trendLabel
     );
     console.log("  " + ratioLabel + "   " + testLabel);
     console.log("");
@@ -10443,6 +10653,30 @@ function registerReportCommand(program2) {
         );
       }
     }
+    if (costUSD > 0) {
+      const periodDays = Math.max(1, Math.ceil((end.getTime() - start.getTime()) / 864e5));
+      const avgPerDay = costUSD / periodDays;
+      const cacheHitPct = costInputTokens + costCacheRead > 0 ? Math.round(costCacheRead / (costInputTokens + costCacheRead) * 100) : 0;
+      const costHeaderRight = [
+        chalk9.yellow(fmtCost(costUSD)),
+        chalk9.dim(`avg ${fmtCost(avgPerDay)}/day`),
+        cacheHitPct > 0 ? chalk9.dim(`${cacheHitPct}% cache hit`) : null
+      ].filter(Boolean).join(chalk9.dim("  \xB7  "));
+      console.log("");
+      console.log("  " + chalk9.bold("Cost") + "  " + costHeaderRight);
+      console.log("  " + chalk9.dim("\u2500".repeat(Math.min(50, W - 4))));
+      const modelList = [...costByModel.entries()].sort((a, b) => b[1] - a[1]);
+      const maxModelCost = Math.max(...modelList.map(([, v]) => v), 1e-9);
+      const MODEL_LABEL = 22;
+      const MODEL_BAR = Math.max(6, Math.min(20, W - MODEL_LABEL - 12));
+      for (const [model, cost] of modelList) {
+        const label = model.length > MODEL_LABEL - 1 ? model.slice(0, MODEL_LABEL - 2) + "\u2026" : model;
+        const b = colorBar(cost, maxModelCost, MODEL_BAR);
+        console.log(
+          "  " + chalk9.white(label.padEnd(MODEL_LABEL)) + b + "  " + chalk9.yellow(fmtCost(cost))
+        );
+      }
+    }
     console.log("");
     console.log(
       "  " + chalk9.dim("node9 audit --deny") + chalk9.dim("  \xB7  ") + chalk9.dim("node9 report --period today|7d|30d|month  --no-tests")
@@ -10519,12 +10753,12 @@ function registerDaemonCommand(program2) {
 init_core();
 init_daemon();
 import chalk11 from "chalk";
-import fs24 from "fs";
-import path26 from "path";
-import os20 from "os";
+import fs25 from "fs";
+import path27 from "path";
+import os21 from "os";
 function readJson2(filePath) {
   try {
-    if (fs24.existsSync(filePath)) return JSON.parse(fs24.readFileSync(filePath, "utf-8"));
+    if (fs25.existsSync(filePath)) return JSON.parse(fs25.readFileSync(filePath, "utf-8"));
   } catch {
   }
   return null;
@@ -10589,28 +10823,28 @@ function registerStatusCommand(program2) {
     console.log("");
     const modeLabel = settings.mode === "audit" ? chalk11.blue("audit") : settings.mode === "strict" ? chalk11.red("strict") : chalk11.white("standard");
     console.log(`  Mode:    ${modeLabel}`);
-    const projectConfig = path26.join(process.cwd(), "node9.config.json");
-    const globalConfig = path26.join(os20.homedir(), ".node9", "config.json");
+    const projectConfig = path27.join(process.cwd(), "node9.config.json");
+    const globalConfig = path27.join(os21.homedir(), ".node9", "config.json");
     console.log(
-      `  Local:   ${fs24.existsSync(projectConfig) ? chalk11.green("Active (node9.config.json)") : chalk11.gray("Not present")}`
+      `  Local:   ${fs25.existsSync(projectConfig) ? chalk11.green("Active (node9.config.json)") : chalk11.gray("Not present")}`
     );
     console.log(
-      `  Global:  ${fs24.existsSync(globalConfig) ? chalk11.green("Active (~/.node9/config.json)") : chalk11.gray("Not present")}`
+      `  Global:  ${fs25.existsSync(globalConfig) ? chalk11.green("Active (~/.node9/config.json)") : chalk11.gray("Not present")}`
     );
     if (mergedConfig.policy.sandboxPaths.length > 0) {
       console.log(
         `  Sandbox: ${chalk11.green(`${mergedConfig.policy.sandboxPaths.length} safe zones active`)}`
       );
     }
-    const homeDir2 = os20.homedir();
+    const homeDir2 = os21.homedir();
     const claudeSettings = readJson2(
-      path26.join(homeDir2, ".claude", "settings.json")
+      path27.join(homeDir2, ".claude", "settings.json")
     );
-    const claudeConfig = readJson2(path26.join(homeDir2, ".claude.json"));
+    const claudeConfig = readJson2(path27.join(homeDir2, ".claude.json"));
     const geminiSettings = readJson2(
-      path26.join(homeDir2, ".gemini", "settings.json")
+      path27.join(homeDir2, ".gemini", "settings.json")
     );
-    const cursorConfig = readJson2(path26.join(homeDir2, ".cursor", "mcp.json"));
+    const cursorConfig = readJson2(path27.join(homeDir2, ".cursor", "mcp.json"));
     const agentFound = claudeSettings || claudeConfig || geminiSettings || cursorConfig;
     if (agentFound) {
       console.log("");
@@ -10670,9 +10904,9 @@ function registerStatusCommand(program2) {
 // src/cli/commands/init.ts
 init_core();
 import chalk12 from "chalk";
-import fs25 from "fs";
-import path27 from "path";
-import os21 from "os";
+import fs26 from "fs";
+import path28 from "path";
+import os22 from "os";
 import https2 from "https";
 init_shields();
 var DEFAULT_SHIELDS = ["bash-safe", "filesystem", "postgres"];
@@ -10731,15 +10965,15 @@ function registerInitCommand(program2) {
       }
       console.log("");
     }
-    const configPath = path27.join(os21.homedir(), ".node9", "config.json");
-    if (fs25.existsSync(configPath) && !options.force) {
+    const configPath = path28.join(os22.homedir(), ".node9", "config.json");
+    if (fs26.existsSync(configPath) && !options.force) {
       try {
-        const existing = JSON.parse(fs25.readFileSync(configPath, "utf-8"));
+        const existing = JSON.parse(fs26.readFileSync(configPath, "utf-8"));
         const settings = existing.settings ?? {};
         if (settings.mode !== chosenMode) {
           settings.mode = chosenMode;
           existing.settings = settings;
-          fs25.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
+          fs26.writeFileSync(configPath, JSON.stringify(existing, null, 2) + "\n");
           console.log(chalk12.green(`\u2705 Mode updated: ${chosenMode}`));
         } else {
           console.log(chalk12.blue(`\u2139\uFE0F  Config already exists: ${configPath}`));
@@ -10752,9 +10986,9 @@ function registerInitCommand(program2) {
         ...DEFAULT_CONFIG,
         settings: { ...DEFAULT_CONFIG.settings, mode: chosenMode }
       };
-      const dir = path27.dirname(configPath);
-      if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
-      fs25.writeFileSync(configPath, JSON.stringify(configToSave, null, 2) + "\n");
+      const dir = path28.dirname(configPath);
+      if (!fs26.existsSync(dir)) fs26.mkdirSync(dir, { recursive: true });
+      fs26.writeFileSync(configPath, JSON.stringify(configToSave, null, 2) + "\n");
       console.log(chalk12.green(`\u2705 Config created: ${configPath}`));
       console.log(chalk12.gray(`   Mode: ${chosenMode}`));
     }
@@ -10808,7 +11042,7 @@ function registerInitCommand(program2) {
 }
 
 // src/cli/commands/undo.ts
-import path28 from "path";
+import path29 from "path";
 import chalk14 from "chalk";
 
 // src/tui/undo-navigator.ts
@@ -10967,7 +11201,7 @@ function findMatchingCwd(startDir, history) {
   let dir = startDir;
   while (true) {
     if (cwds.has(dir)) return dir;
-    const parent = path28.dirname(dir);
+    const parent = path29.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -11163,12 +11397,12 @@ import { execa as execa2 } from "execa";
 init_provenance();
 
 // src/mcp-pin.ts
-import fs26 from "fs";
-import path29 from "path";
-import os22 from "os";
+import fs27 from "fs";
+import path30 from "path";
+import os23 from "os";
 import crypto4 from "crypto";
 function getPinsFilePath() {
-  return path29.join(os22.homedir(), ".node9", "mcp-pins.json");
+  return path30.join(os23.homedir(), ".node9", "mcp-pins.json");
 }
 function hashToolDefinitions(tools) {
   const sorted = [...tools].sort((a, b) => {
@@ -11185,7 +11419,7 @@ function getServerKey(upstreamCommand) {
 function readMcpPinsSafe() {
   const filePath = getPinsFilePath();
   try {
-    const raw = fs26.readFileSync(filePath, "utf-8");
+    const raw = fs27.readFileSync(filePath, "utf-8");
     if (!raw.trim()) {
       return { ok: false, reason: "corrupt", detail: "empty file" };
     }
@@ -11209,10 +11443,10 @@ function readMcpPins() {
 }
 function writeMcpPins(data) {
   const filePath = getPinsFilePath();
-  fs26.mkdirSync(path29.dirname(filePath), { recursive: true });
+  fs27.mkdirSync(path30.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${crypto4.randomBytes(6).toString("hex")}.tmp`;
-  fs26.writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 384 });
-  fs26.renameSync(tmp, filePath);
+  fs27.writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 384 });
+  fs27.renameSync(tmp, filePath);
 }
 function checkPin(serverKey, currentHash) {
   const result = readMcpPinsSafe();
@@ -11584,9 +11818,9 @@ function registerMcpGatewayCommand(program2) {
 
 // src/mcp-server/index.ts
 import readline4 from "readline";
-import fs27 from "fs";
-import os23 from "os";
-import path30 from "path";
+import fs28 from "fs";
+import os24 from "os";
+import path31 from "path";
 init_core();
 init_daemon();
 init_shields();
@@ -11761,13 +11995,13 @@ function handleStatus() {
   lines.push(`Active shields: ${activeShields.length > 0 ? activeShields.join(", ") : "none"}`);
   lines.push(`Smart rules: ${config.policy.smartRules.length} loaded`);
   lines.push(`DLP: ${config.policy.dlp?.enabled !== false ? "enabled" : "disabled"}`);
-  const projectConfig = path30.join(process.cwd(), "node9.config.json");
-  const globalConfig = path30.join(os23.homedir(), ".node9", "config.json");
+  const projectConfig = path31.join(process.cwd(), "node9.config.json");
+  const globalConfig = path31.join(os24.homedir(), ".node9", "config.json");
   lines.push(
-    `Project config (node9.config.json): ${fs27.existsSync(projectConfig) ? "present" : "not found"}`
+    `Project config (node9.config.json): ${fs28.existsSync(projectConfig) ? "present" : "not found"}`
   );
   lines.push(
-    `Global config (~/.node9/config.json): ${fs27.existsSync(globalConfig) ? "present" : "not found"}`
+    `Global config (~/.node9/config.json): ${fs28.existsSync(globalConfig) ? "present" : "not found"}`
   );
   return lines.join("\n");
 }
@@ -11841,21 +12075,21 @@ function handleShieldDisable(args) {
   writeActiveShields(active.filter((s) => s !== name));
   return `Shield "${name}" disabled.`;
 }
-var GLOBAL_CONFIG_PATH2 = path30.join(os23.homedir(), ".node9", "config.json");
+var GLOBAL_CONFIG_PATH2 = path31.join(os24.homedir(), ".node9", "config.json");
 var APPROVER_CHANNELS = ["native", "browser", "cloud", "terminal"];
 function readGlobalConfigRaw() {
   try {
-    if (fs27.existsSync(GLOBAL_CONFIG_PATH2)) {
-      return JSON.parse(fs27.readFileSync(GLOBAL_CONFIG_PATH2, "utf-8"));
+    if (fs28.existsSync(GLOBAL_CONFIG_PATH2)) {
+      return JSON.parse(fs28.readFileSync(GLOBAL_CONFIG_PATH2, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function writeGlobalConfigRaw(data) {
-  const dir = path30.dirname(GLOBAL_CONFIG_PATH2);
-  if (!fs27.existsSync(dir)) fs27.mkdirSync(dir, { recursive: true });
-  fs27.writeFileSync(GLOBAL_CONFIG_PATH2, JSON.stringify(data, null, 2) + "\n");
+  const dir = path31.dirname(GLOBAL_CONFIG_PATH2);
+  if (!fs28.existsSync(dir)) fs28.mkdirSync(dir, { recursive: true });
+  fs28.writeFileSync(GLOBAL_CONFIG_PATH2, JSON.stringify(data, null, 2) + "\n");
 }
 function handleApproverList() {
   const config = getConfig();
@@ -11898,9 +12132,9 @@ function handleApproverSet(args) {
 }
 function handleAuditGet(args) {
   const limit = Math.min(typeof args.limit === "number" ? args.limit : 20, 100);
-  const auditPath = path30.join(os23.homedir(), ".node9", "audit.log");
-  if (!fs27.existsSync(auditPath)) return "No audit log found.";
-  const lines = fs27.readFileSync(auditPath, "utf-8").trim().split("\n").filter(Boolean);
+  const auditPath = path31.join(os24.homedir(), ".node9", "audit.log");
+  if (!fs28.existsSync(auditPath)) return "No audit log found.";
+  const lines = fs28.readFileSync(auditPath, "utf-8").trim().split("\n").filter(Boolean);
   const recent = lines.slice(-limit);
   const entries = recent.map((line) => {
     try {
@@ -12220,20 +12454,20 @@ function registerMcpPinCommand(program2) {
 
 // src/cli.ts
 var { version } = JSON.parse(
-  fs30.readFileSync(path33.join(__dirname, "../package.json"), "utf-8")
+  fs31.readFileSync(path34.join(__dirname, "../package.json"), "utf-8")
 );
 var program = new Command();
 program.name("node9").description("The Sudo Command for AI Agents").version(version);
 program.command("login").argument("<apiKey>").option("--local", "Save key for audit/logging only \u2014 local config still controls all decisions").option("--profile <name>", 'Save as a named profile (default: "default")').action((apiKey, options) => {
   const DEFAULT_API_URL = "https://api.node9.ai/api/v1/intercept";
-  const credPath = path33.join(os26.homedir(), ".node9", "credentials.json");
-  if (!fs30.existsSync(path33.dirname(credPath)))
-    fs30.mkdirSync(path33.dirname(credPath), { recursive: true });
+  const credPath = path34.join(os27.homedir(), ".node9", "credentials.json");
+  if (!fs31.existsSync(path34.dirname(credPath)))
+    fs31.mkdirSync(path34.dirname(credPath), { recursive: true });
   const profileName = options.profile || "default";
   let existingCreds = {};
   try {
-    if (fs30.existsSync(credPath)) {
-      const raw = JSON.parse(fs30.readFileSync(credPath, "utf-8"));
+    if (fs31.existsSync(credPath)) {
+      const raw = JSON.parse(fs31.readFileSync(credPath, "utf-8"));
       if (raw.apiKey) {
         existingCreds = {
           default: { apiKey: raw.apiKey, apiUrl: raw.apiUrl || DEFAULT_API_URL }
@@ -12245,13 +12479,13 @@ program.command("login").argument("<apiKey>").option("--local", "Save key for au
   } catch {
   }
   existingCreds[profileName] = { apiKey, apiUrl: DEFAULT_API_URL };
-  fs30.writeFileSync(credPath, JSON.stringify(existingCreds, null, 2), { mode: 384 });
+  fs31.writeFileSync(credPath, JSON.stringify(existingCreds, null, 2), { mode: 384 });
   if (profileName === "default") {
-    const configPath = path33.join(os26.homedir(), ".node9", "config.json");
+    const configPath = path34.join(os27.homedir(), ".node9", "config.json");
     let config = {};
     try {
-      if (fs30.existsSync(configPath))
-        config = JSON.parse(fs30.readFileSync(configPath, "utf-8"));
+      if (fs31.existsSync(configPath))
+        config = JSON.parse(fs31.readFileSync(configPath, "utf-8"));
     } catch {
     }
     if (!config.settings || typeof config.settings !== "object") config.settings = {};
@@ -12266,9 +12500,9 @@ program.command("login").argument("<apiKey>").option("--local", "Save key for au
       approvers.cloud = false;
     }
     s.approvers = approvers;
-    if (!fs30.existsSync(path33.dirname(configPath)))
-      fs30.mkdirSync(path33.dirname(configPath), { recursive: true });
-    fs30.writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 384 });
+    if (!fs31.existsSync(path34.dirname(configPath)))
+      fs31.mkdirSync(path34.dirname(configPath), { recursive: true });
+    fs31.writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 384 });
   }
   if (options.profile && profileName !== "default") {
     console.log(chalk20.green(`\u2705 Profile "${profileName}" saved`));
@@ -12362,15 +12596,15 @@ program.command("uninstall").description("Remove all Node9 hooks and optionally
     }
   }
   if (options.purge) {
-    const node9Dir = path33.join(os26.homedir(), ".node9");
-    if (fs30.existsSync(node9Dir)) {
+    const node9Dir = path34.join(os27.homedir(), ".node9");
+    if (fs31.existsSync(node9Dir)) {
       const confirmed = await confirm2({
         message: `Permanently delete ${node9Dir} (config, audit log, credentials)?`,
         default: false
       });
       if (confirmed) {
-        fs30.rmSync(node9Dir, { recursive: true });
-        if (fs30.existsSync(node9Dir)) {
+        fs31.rmSync(node9Dir, { recursive: true });
+        if (fs31.existsSync(node9Dir)) {
           console.error(
             chalk20.red("\n  \u26A0\uFE0F  ~/.node9/ could not be fully deleted \u2014 remove it manually.")
           );
@@ -12511,14 +12745,14 @@ Claude Code spawns this command every ~300ms and writes a JSON payload to stdin.
 Run "node9 addto claude" to register it as the statusLine.`
 ).argument("[subcommand]", 'Optional: "debug on" / "debug off" to toggle stdin logging').argument("[state]", 'on|off \u2014 used with "debug" subcommand').action(async (subcommand, state) => {
   if (subcommand === "debug") {
-    const flagFile = path33.join(os26.homedir(), ".node9", "hud-debug");
+    const flagFile = path34.join(os27.homedir(), ".node9", "hud-debug");
     if (state === "on") {
-      fs30.mkdirSync(path33.dirname(flagFile), { recursive: true });
-      fs30.writeFileSync(flagFile, "");
+      fs31.mkdirSync(path34.dirname(flagFile), { recursive: true });
+      fs31.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 (fs30.existsSync(flagFile)) fs30.unlinkSync(flagFile);
+      if (fs31.existsSync(flagFile)) fs31.unlinkSync(flagFile);
       console.log("HUD debug logging disabled.");
     } else {
       console.error("Usage: node9 hud debug on|off");
@@ -12625,9 +12859,9 @@ if (process.argv[2] !== "daemon") {
     const isCheckHook = process.argv[2] === "check";
     if (isCheckHook) {
       if (process.env.NODE9_DEBUG === "1" || getConfig().settings.enableHookLogDebug) {
-        const logPath = path33.join(os26.homedir(), ".node9", "hook-debug.log");
+        const logPath = path34.join(os27.homedir(), ".node9", "hook-debug.log");
         const msg = reason instanceof Error ? reason.message : String(reason);
-        fs30.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] UNHANDLED: ${msg}
+        fs31.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] UNHANDLED: ${msg}
 `);
       }
       process.exit(0);