@node9/proxy 1.9.0 → 1.9.1

package/dist/cli.mjs

@@ -139,8 +139,8 @@ function sanitizeConfig(raw) {
     }
   }
   const lines = result.error.issues.map((issue) => {
-    const path31 = issue.path.length > 0 ? issue.path.join(".") : "root";
-    return `  \u2022 ${path31}: ${issue.message}`;
+    const path32 = issue.path.length > 0 ? issue.path.join(".") : "root";
+    return `  \u2022 ${path32}: ${issue.message}`;
   });
   return {
     sanitized,
@@ -806,7 +806,7 @@ var init_config = __esm({
               {
                 field: "command",
                 op: "matches",
-                value: "^\\s*git\\b.*\\bpush\\b.*(--force|--force-with-lease|-f\\b)",
+                value: "\\bgit\\b.*\\bpush\\b.*(--force|--force-with-lease|-f\\b)",
                 flags: "i"
               }
             ],
@@ -821,7 +821,7 @@ var init_config = __esm({
               {
                 field: "command",
                 op: "matches",
-                value: "^\\s*git\\b.*\\bpush\\b(?!.*(-f\\b|--force|--force-with-lease))",
+                value: "\\bgit\\b.*\\bpush\\b(?!.*(-f\\b|--force|--force-with-lease))",
                 flags: "i"
               }
             ],
@@ -836,7 +836,7 @@ var init_config = __esm({
               {
                 field: "command",
                 op: "matches",
-                value: "^\\s*git\\b.*(reset\\s+--hard|clean\\s+-[fdxX]|\\brebase\\b|tag\\s+-d|branch\\s+-[dD])",
+                value: "\\bgit\\b.*(reset\\s+--hard|clean\\s+-[fdxX]|\\brebase\\b|tag\\s+-d|branch\\s+-[dD])",
                 flags: "i"
               }
             ],
@@ -848,7 +848,7 @@ var init_config = __esm({
           {
             name: "review-sudo",
             tool: "bash",
-            conditions: [{ field: "command", op: "matches", value: "^\\s*sudo\\s", flags: "i" }],
+            conditions: [{ field: "command", op: "matches", value: "\\bsudo\\s", flags: "i" }],
             conditionMode: "all",
             verdict: "review",
             reason: "Command requires elevated privileges"
@@ -1674,9 +1674,9 @@ function matchesPattern(text, patterns) {
   const withoutDotSlash = text.replace(/^\.\//, "");
   return isMatch(withoutDotSlash) || isMatch(`./${withoutDotSlash}`);
 }
-function getNestedValue(obj, path31) {
+function getNestedValue(obj, path32) {
   if (!obj || typeof obj !== "object") return null;
-  return path31.split(".").reduce((prev, curr) => prev?.[curr], obj);
+  return path32.split(".").reduce((prev, curr) => prev?.[curr], obj);
 }
 function shouldSnapshot(toolName, args, config) {
   if (!config.settings.enableUndo) return false;
@@ -6747,10 +6747,10 @@ __export(tail_exports, {
   startTail: () => startTail
 });
 import http2 from "http";
-import chalk17 from "chalk";
-import fs25 from "fs";
-import os21 from "os";
-import path28 from "path";
+import chalk18 from "chalk";
+import fs26 from "fs";
+import os22 from "os";
+import path29 from "path";
 import readline5 from "readline";
 import { spawn as spawn10, execSync as execSync3 } from "child_process";
 function getIcon(tool) {
@@ -6764,22 +6764,22 @@ 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(os21.homedir(), "~");
+  const argsStr = JSON.stringify(activity.args ?? {}).replace(/\s+/g, " ").replaceAll(os22.homedir(), "~");
   const argsPreview = argsStr.length > 70 ? argsStr.slice(0, 70) + "\u2026" : argsStr;
-  return `${chalk17.gray(time)} ${icon} ${chalk17.white.bold(toolName)} ${chalk17.dim(argsPreview)}`;
+  return `${chalk18.gray(time)} ${icon} ${chalk18.white.bold(toolName)} ${chalk18.dim(argsPreview)}`;
 }
 function renderResult(activity, result) {
   const base = formatBase(activity);
   let status;
   if (result.status === "allow") {
-    status = chalk17.green("\u2713 ALLOW");
+    status = chalk18.green("\u2713 ALLOW");
   } else if (result.status === "dlp") {
-    status = chalk17.bgRed.white.bold(" \u{1F6E1}\uFE0F  DLP ");
+    status = chalk18.bgRed.white.bold(" \u{1F6E1}\uFE0F  DLP ");
   } else {
-    status = chalk17.red("\u2717 BLOCK");
+    status = chalk18.red("\u2717 BLOCK");
   }
   const cost = result.costEstimate ?? activity.costEstimate;
-  const costSuffix = cost == null ? "" : chalk17.dim(`  ~$${cost >= 1e-3 ? cost.toFixed(3) : "0.000"}`);
+  const costSuffix = cost == null ? "" : chalk18.dim(`  ~$${cost >= 1e-3 ? cost.toFixed(3) : "0.000"}`);
   if (process.stdout.isTTY) {
     readline5.clearLine(process.stdout, 0);
     readline5.cursorTo(process.stdout, 0);
@@ -6788,16 +6788,16 @@ function renderResult(activity, result) {
 }
 function renderPending(activity) {
   if (!process.stdout.isTTY) return;
-  process.stdout.write(`${formatBase(activity)}  ${chalk17.yellow("\u25CF \u2026")}\r`);
+  process.stdout.write(`${formatBase(activity)}  ${chalk18.yellow("\u25CF \u2026")}\r`);
 }
 async function ensureDaemon() {
   let pidPort = null;
-  if (fs25.existsSync(PID_FILE)) {
+  if (fs26.existsSync(PID_FILE)) {
     try {
-      const { port } = JSON.parse(fs25.readFileSync(PID_FILE, "utf-8"));
+      const { port } = JSON.parse(fs26.readFileSync(PID_FILE, "utf-8"));
       pidPort = port;
     } catch {
-      console.error(chalk17.dim("\u26A0\uFE0F  Could not read PID file; falling back to default port."));
+      console.error(chalk18.dim("\u26A0\uFE0F  Could not read PID file; falling back to default port."));
     }
   }
   const checkPort = pidPort ?? DAEMON_PORT;
@@ -6808,7 +6808,7 @@ async function ensureDaemon() {
     if (res.ok) return checkPort;
   } catch {
   }
-  console.log(chalk17.dim("\u{1F6E1}\uFE0F  Starting Node9 daemon..."));
+  console.log(chalk18.dim("\u{1F6E1}\uFE0F  Starting Node9 daemon..."));
   const child = spawn10(process.execPath, [process.argv[1], "daemon"], {
     detached: true,
     stdio: "ignore",
@@ -6825,7 +6825,7 @@ async function ensureDaemon() {
     } catch {
     }
   }
-  console.error(chalk17.red("\u274C Daemon failed to start. Try: node9 daemon start"));
+  console.error(chalk18.red("\u274C Daemon failed to start. Try: node9 daemon start"));
   process.exit(1);
 }
 function postDecisionHttp(id, decision, csrfToken, port, opts) {
@@ -6914,9 +6914,9 @@ function buildRecoveryCardLines(req) {
   ];
 }
 function readApproversFromDisk() {
-  const configPath = path28.join(os21.homedir(), ".node9", "config.json");
+  const configPath = path29.join(os22.homedir(), ".node9", "config.json");
   try {
-    const raw = JSON.parse(fs25.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs26.readFileSync(configPath, "utf-8"));
     const settings = raw.settings ?? {};
     return settings.approvers ?? {};
   } catch {
@@ -6927,20 +6927,20 @@ function approverStatusLine() {
   const a = readApproversFromDisk();
   const fmt = (label, key) => {
     const on = a[key] !== false;
-    return `[${key[0]}]${label.slice(1)} ${on ? chalk17.green("\u2713") : chalk17.dim("\u2717")}`;
+    return `[${key[0]}]${label.slice(1)} ${on ? chalk18.green("\u2713") : chalk18.dim("\u2717")}`;
   };
   return `${fmt("native", "native")}  ${fmt("browser", "browser")}  ${fmt("cloud", "cloud")}  ${fmt("terminal", "terminal")}`;
 }
 function toggleApprover(channel) {
-  const configPath = path28.join(os21.homedir(), ".node9", "config.json");
+  const configPath = path29.join(os22.homedir(), ".node9", "config.json");
   try {
-    const raw = JSON.parse(fs25.readFileSync(configPath, "utf-8"));
+    const raw = JSON.parse(fs26.readFileSync(configPath, "utf-8"));
     const settings = raw.settings ?? {};
     const approvers = settings.approvers ?? {};
     approvers[channel] = approvers[channel] === false;
     settings.approvers = approvers;
     raw.settings = settings;
-    fs25.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
+    fs26.writeFileSync(configPath, JSON.stringify(raw, null, 2) + "\n");
   } catch (err2) {
     process.stderr.write(`[node9] toggleApprover failed: ${String(err2)}
 `);
@@ -6972,7 +6972,7 @@ async function startTail(options = {}) {
       req2.end();
     });
     if (result.ok) {
-      console.log(chalk17.green("\u2713 Flight Recorder buffer cleared."));
+      console.log(chalk18.green("\u2713 Flight Recorder buffer cleared."));
     } else if (result.code === "ECONNREFUSED") {
       throw new Error("Daemon is not running. Start it with: node9 daemon start");
     } else if (result.code === "ETIMEDOUT") {
@@ -7016,7 +7016,7 @@ async function startTail(options = {}) {
       const channel = name === "n" ? "native" : name === "b" ? "browser" : name === "c" ? "cloud" : name === "t" ? "terminal" : null;
       if (channel) {
         toggleApprover(channel);
-        console.log(chalk17.dim(`  Approvers: ${approverStatusLine()}`));
+        console.log(chalk18.dim(`  Approvers: ${approverStatusLine()}`));
       }
     };
     process.stdin.on("keypress", idleKeypressHandler);
@@ -7082,7 +7082,7 @@ async function startTail(options = {}) {
           localAllowCounts.get(req2.toolName) ?? 0
         )
       );
-      const decisionStamp = action === "always-allow" ? chalk17.yellow("\u2605 ALWAYS ALLOW") : action === "trust" ? chalk17.cyan("\u23F1 TRUST 30m") : action === "allow" ? chalk17.green("\u2713 ALLOWED") : action === "redirect" ? chalk17.yellow("\u21A9 REDIRECT AI") : chalk17.red("\u2717 DENIED");
+      const decisionStamp = action === "always-allow" ? chalk18.yellow("\u2605 ALWAYS ALLOW") : action === "trust" ? chalk18.cyan("\u23F1 TRUST 30m") : action === "allow" ? chalk18.green("\u2713 ALLOWED") : action === "redirect" ? chalk18.yellow("\u21A9 REDIRECT AI") : chalk18.red("\u2717 DENIED");
       stampedLines.push(`  ${BOLD2}\u2192${RESET2} ${decisionStamp} ${GRAY}(terminal)${RESET2}`, ``);
       for (const line of stampedLines) process.stdout.write(line + "\n");
       process.stdout.write(SHOW_CURSOR);
@@ -7110,8 +7110,8 @@ async function startTail(options = {}) {
       }
       postDecisionHttp(req2.id, httpDecision, csrfToken, port, httpOpts).catch((err2) => {
         try {
-          fs25.appendFileSync(
-            path28.join(os21.homedir(), ".node9", "hook-debug.log"),
+          fs26.appendFileSync(
+            path29.join(os22.homedir(), ".node9", "hook-debug.log"),
             `[tail] POST /decision failed: ${String(err2)}
 `
           );
@@ -7133,7 +7133,7 @@ async function startTail(options = {}) {
       );
       const stampedLines = buildCardLines(req2, priorCount);
       if (externalDecision) {
-        const source = externalDecision === "allow" ? chalk17.green("\u2713 ALLOWED") : chalk17.red("\u2717 DENIED");
+        const source = externalDecision === "allow" ? chalk18.green("\u2713 ALLOWED") : chalk18.red("\u2717 DENIED");
         stampedLines.push(`  ${BOLD2}\u2192${RESET2} ${source} ${GRAY}(external)${RESET2}`, ``);
       }
       for (const line of stampedLines) process.stdout.write(line + "\n");
@@ -7192,16 +7192,16 @@ async function startTail(options = {}) {
     }
   } catch {
   }
-  console.log(chalk17.cyan.bold(`
-\u{1F6F0}\uFE0F  Node9 tail  `) + chalk17.dim(`\u2192 ${dashboardUrl}`));
+  console.log(chalk18.cyan.bold(`
+\u{1F6F0}\uFE0F  Node9 tail  `) + chalk18.dim(`\u2192 ${dashboardUrl}`));
   if (canApprove) {
-    console.log(chalk17.dim("Card: [\u21B5/y] Allow  [n] Deny  [a] Always  [t] Trust 30m"));
-    console.log(chalk17.dim(`Approvers (toggle): ${approverStatusLine()}  [q] quit`));
+    console.log(chalk18.dim("Card: [\u21B5/y] Allow  [n] Deny  [a] Always  [t] Trust 30m"));
+    console.log(chalk18.dim(`Approvers (toggle): ${approverStatusLine()}  [q] quit`));
   }
   if (options.history) {
-    console.log(chalk17.dim("Showing history + live events.\n"));
+    console.log(chalk18.dim("Showing history + live events.\n"));
   } else {
-    console.log(chalk17.dim("Showing live events only. Use --history to include past.\n"));
+    console.log(chalk18.dim("Showing live events only. Use --history to include past.\n"));
   }
   process.on("SIGINT", () => {
     exitIdleMode();
@@ -7211,13 +7211,13 @@ async function startTail(options = {}) {
       readline5.clearLine(process.stdout, 0);
       readline5.cursorTo(process.stdout, 0);
     }
-    console.log(chalk17.dim("\n\u{1F6F0}\uFE0F  Disconnected."));
+    console.log(chalk18.dim("\n\u{1F6F0}\uFE0F  Disconnected."));
     process.exit(0);
   });
   const sseUrl = `http://127.0.0.1:${port}/events?capabilities=input`;
   const req = http2.get(sseUrl, (res) => {
     if (res.statusCode !== 200) {
-      console.error(chalk17.red(`Failed to connect: HTTP ${res.statusCode}`));
+      console.error(chalk18.red(`Failed to connect: HTTP ${res.statusCode}`));
       process.exit(1);
     }
     if (canApprove) enterIdleMode();
@@ -7248,7 +7248,7 @@ async function startTail(options = {}) {
         readline5.clearLine(process.stdout, 0);
         readline5.cursorTo(process.stdout, 0);
       }
-      console.log(chalk17.red("\n\u274C Daemon disconnected."));
+      console.log(chalk18.red("\n\u274C Daemon disconnected."));
       process.exit(1);
     });
   });
@@ -7340,9 +7340,9 @@ async function startTail(options = {}) {
       const hash = data.hash ?? "";
       const summary = data.argsSummary ?? data.tool;
       const fileCount = data.fileCount ?? 0;
-      const files = fileCount > 0 ? chalk17.dim(` \xB7 ${fileCount} file${fileCount === 1 ? "" : "s"}`) : "";
+      const files = fileCount > 0 ? chalk18.dim(` \xB7 ${fileCount} file${fileCount === 1 ? "" : "s"}`) : "";
       process.stdout.write(
-        `${chalk17.dim(time)}  ${chalk17.cyan("\u{1F4F8} snapshot")}  ${chalk17.dim(hash)}  ${summary}${files}
+        `${chalk18.dim(time)}  ${chalk18.cyan("\u{1F4F8} snapshot")}  ${chalk18.dim(hash)}  ${summary}${files}
 `
       );
       return;
@@ -7359,7 +7359,7 @@ async function startTail(options = {}) {
   }
   req.on("error", (err2) => {
     const msg = err2.code === "ECONNREFUSED" ? "Daemon is not running. Start it with: node9 daemon start" : err2.message;
-    console.error(chalk17.red(`
+    console.error(chalk18.red(`
 \u274C ${msg}`));
     process.exit(1);
   });
@@ -7371,7 +7371,7 @@ var init_tail = __esm({
     init_daemon2();
     init_daemon();
     init_core();
-    PID_FILE = path28.join(os21.homedir(), ".node9", "daemon.pid");
+    PID_FILE = path29.join(os22.homedir(), ".node9", "daemon.pid");
     ICONS = {
       bash: "\u{1F4BB}",
       shell: "\u{1F4BB}",
@@ -7410,9 +7410,9 @@ __export(hud_exports, {
   main: () => main,
   renderEnvironmentLine: () => renderEnvironmentLine
 });
-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 http3 from "http";
 async function readStdin() {
   const chunks = [];
@@ -7488,9 +7488,9 @@ function formatTimeLeft(resetsAt) {
   return ` (${m}m left)`;
 }
 function safeReadJson(filePath) {
-  if (!fs26.existsSync(filePath)) return null;
+  if (!fs27.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs26.readFileSync(filePath, "utf-8"));
+    return JSON.parse(fs27.readFileSync(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -7511,12 +7511,12 @@ function countHooksInFile(filePath) {
   return Object.keys(cfg.hooks).length;
 }
 function countRulesInDir(rulesDir) {
-  if (!fs26.existsSync(rulesDir)) return 0;
+  if (!fs27.existsSync(rulesDir)) return 0;
   let count = 0;
   try {
-    for (const entry of fs26.readdirSync(rulesDir, { withFileTypes: true })) {
+    for (const entry of fs27.readdirSync(rulesDir, { withFileTypes: true })) {
       if (entry.isDirectory()) {
-        count += countRulesInDir(path29.join(rulesDir, entry.name));
+        count += countRulesInDir(path30.join(rulesDir, entry.name));
       } else if (entry.isFile() && entry.name.endsWith(".md")) {
         count++;
       }
@@ -7527,46 +7527,46 @@ function countRulesInDir(rulesDir) {
 }
 function isSamePath(a, b) {
   try {
-    return path29.resolve(a) === path29.resolve(b);
+    return path30.resolve(a) === path30.resolve(b);
   } catch {
     return false;
   }
 }
 function countConfigs(cwd) {
-  const homeDir2 = os22.homedir();
-  const claudeDir = path29.join(homeDir2, ".claude");
+  const homeDir2 = os23.homedir();
+  const claudeDir = path30.join(homeDir2, ".claude");
   let claudeMdCount = 0;
   let rulesCount = 0;
   let hooksCount = 0;
   const userMcpServers = /* @__PURE__ */ new Set();
   const projectMcpServers = /* @__PURE__ */ new Set();
-  if (fs26.existsSync(path29.join(claudeDir, "CLAUDE.md"))) claudeMdCount++;
-  rulesCount += countRulesInDir(path29.join(claudeDir, "rules"));
-  const userSettings = path29.join(claudeDir, "settings.json");
+  if (fs27.existsSync(path30.join(claudeDir, "CLAUDE.md"))) claudeMdCount++;
+  rulesCount += countRulesInDir(path30.join(claudeDir, "rules"));
+  const userSettings = path30.join(claudeDir, "settings.json");
   for (const name of getMcpServerNames(userSettings)) userMcpServers.add(name);
   hooksCount += countHooksInFile(userSettings);
-  const userClaudeJson = path29.join(homeDir2, ".claude.json");
+  const userClaudeJson = path30.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 (fs26.existsSync(path29.join(cwd, "CLAUDE.md"))) claudeMdCount++;
-    if (fs26.existsSync(path29.join(cwd, "CLAUDE.local.md"))) claudeMdCount++;
-    const projectClaudeDir = path29.join(cwd, ".claude");
+    if (fs27.existsSync(path30.join(cwd, "CLAUDE.md"))) claudeMdCount++;
+    if (fs27.existsSync(path30.join(cwd, "CLAUDE.local.md"))) claudeMdCount++;
+    const projectClaudeDir = path30.join(cwd, ".claude");
     const overlapsUserScope = isSamePath(projectClaudeDir, claudeDir);
     if (!overlapsUserScope) {
-      if (fs26.existsSync(path29.join(projectClaudeDir, "CLAUDE.md"))) claudeMdCount++;
-      rulesCount += countRulesInDir(path29.join(projectClaudeDir, "rules"));
-      const projSettings = path29.join(projectClaudeDir, "settings.json");
+      if (fs27.existsSync(path30.join(projectClaudeDir, "CLAUDE.md"))) claudeMdCount++;
+      rulesCount += countRulesInDir(path30.join(projectClaudeDir, "rules"));
+      const projSettings = path30.join(projectClaudeDir, "settings.json");
       for (const name of getMcpServerNames(projSettings)) projectMcpServers.add(name);
       hooksCount += countHooksInFile(projSettings);
     }
-    if (fs26.existsSync(path29.join(projectClaudeDir, "CLAUDE.local.md"))) claudeMdCount++;
-    const localSettings = path29.join(projectClaudeDir, "settings.local.json");
+    if (fs27.existsSync(path30.join(projectClaudeDir, "CLAUDE.local.md"))) claudeMdCount++;
+    const localSettings = path30.join(projectClaudeDir, "settings.local.json");
     for (const name of getMcpServerNames(localSettings)) projectMcpServers.add(name);
     hooksCount += countHooksInFile(localSettings);
-    const mcpJsonServers = getMcpServerNames(path29.join(cwd, ".mcp.json"));
+    const mcpJsonServers = getMcpServerNames(path30.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);
@@ -7599,12 +7599,12 @@ function readActiveShieldsHud() {
     return shieldsCache.value;
   }
   try {
-    const shieldsPath = path29.join(os22.homedir(), ".node9", "shields.json");
-    if (!fs26.existsSync(shieldsPath)) {
+    const shieldsPath = path30.join(os23.homedir(), ".node9", "shields.json");
+    if (!fs27.existsSync(shieldsPath)) {
       shieldsCache = { value: [], ts: now };
       return [];
     }
-    const parsed = JSON.parse(fs26.readFileSync(shieldsPath, "utf-8"));
+    const parsed = JSON.parse(fs27.readFileSync(shieldsPath, "utf-8"));
     if (!Array.isArray(parsed.active)) {
       shieldsCache = { value: [], ts: now };
       return [];
@@ -7706,17 +7706,17 @@ function renderContextLine(stdin) {
 async function main() {
   try {
     const [stdin, daemonStatus2] = await Promise.all([readStdin(), queryDaemon()]);
-    if (fs26.existsSync(path29.join(os22.homedir(), ".node9", "hud-debug"))) {
+    if (fs27.existsSync(path30.join(os23.homedir(), ".node9", "hud-debug"))) {
       try {
-        const logPath = path29.join(os22.homedir(), ".node9", "hud-debug.log");
+        const logPath = path30.join(os23.homedir(), ".node9", "hud-debug.log");
         const MAX_LOG_SIZE = 10 * 1024 * 1024;
         let size = 0;
         try {
-          size = fs26.statSync(logPath).size;
+          size = fs27.statSync(logPath).size;
         } catch {
         }
         if (size < MAX_LOG_SIZE) {
-          fs26.appendFileSync(
+          fs27.appendFileSync(
             logPath,
             JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), stdin }) + "\n"
           );
@@ -7737,11 +7737,11 @@ async function main() {
       try {
         const cwd = stdin.cwd ?? process.cwd();
         for (const configPath of [
-          path29.join(cwd, "node9.config.json"),
-          path29.join(os22.homedir(), ".node9", "config.json")
+          path30.join(cwd, "node9.config.json"),
+          path30.join(os23.homedir(), ".node9", "config.json")
         ]) {
-          if (!fs26.existsSync(configPath)) continue;
-          const cfg = JSON.parse(fs26.readFileSync(configPath, "utf-8"));
+          if (!fs27.existsSync(configPath)) continue;
+          const cfg = JSON.parse(fs27.readFileSync(configPath, "utf-8"));
           const hud = cfg.settings?.hud;
           if (hud && "showEnvironmentCounts" in hud) return hud.showEnvironmentCounts !== false;
         }
@@ -8370,10 +8370,10 @@ function teardownHud() {
 
 // src/cli.ts
 init_daemon2();
-import chalk18 from "chalk";
-import fs27 from "fs";
-import path30 from "path";
-import os23 from "os";
+import chalk19 from "chalk";
+import fs28 from "fs";
+import path31 from "path";
+import os24 from "os";
 import { confirm as confirm2 } from "@inquirer/prompts";
 
 // src/utils/duration.ts
@@ -10263,11 +10263,17 @@ function registerInitCommand(program2) {
       if (sendTelemetry) fireTelemetryPing(found);
       console.log("");
     }
-    console.log(chalk11.green.bold("\u{1F6E1}\uFE0F  Node9 is ready!"));
+    const agentList = found.join(", ");
+    console.log(chalk11.green.bold(`\u{1F6E1}\uFE0F  Node9 is protecting ${agentList}!`));
+    console.log("");
+    console.log(chalk11.white("  Watch live:  ") + chalk11.cyan("node9 tail"));
+    console.log(chalk11.white("  Local UI:    ") + chalk11.cyan("node9 daemon --openui"));
     console.log("");
-    console.log(chalk11.white("  Start watching:  ") + chalk11.cyan("node9 tail"));
-    console.log(chalk11.white("  Browser view:    ") + chalk11.cyan("node9 daemon --openui"));
-    console.log(chalk11.white("  Cloud dashboard: ") + chalk11.cyan("node9.ai"));
+    console.log(chalk11.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(
+      chalk11.white("  Team dashboard + full audit trail \u2192 ") + chalk11.cyan.bold("https://node9.ai")
+    );
+    console.log(chalk11.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   });
 }
 
@@ -10625,6 +10631,90 @@ import chalk15 from "chalk";
 import { spawn as spawn9 } from "child_process";
 import { execa as execa2 } from "execa";
 init_provenance();
+
+// src/mcp-pin.ts
+import fs24 from "fs";
+import path27 from "path";
+import os20 from "os";
+import crypto3 from "crypto";
+function getPinsFilePath() {
+  return path27.join(os20.homedir(), ".node9", "mcp-pins.json");
+}
+function hashToolDefinitions(tools) {
+  const sorted = [...tools].sort((a, b) => {
+    const nameA = a.name ?? "";
+    const nameB = b.name ?? "";
+    return nameA.localeCompare(nameB);
+  });
+  const canonical = JSON.stringify(sorted);
+  return crypto3.createHash("sha256").update(canonical).digest("hex");
+}
+function getServerKey(upstreamCommand) {
+  return crypto3.createHash("sha256").update(upstreamCommand).digest("hex").slice(0, 16);
+}
+function readMcpPinsSafe() {
+  const filePath = getPinsFilePath();
+  try {
+    const raw = fs24.readFileSync(filePath, "utf-8");
+    if (!raw.trim()) {
+      return { ok: false, reason: "corrupt", detail: "empty file" };
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed.servers || typeof parsed.servers !== "object" || Array.isArray(parsed.servers)) {
+      return { ok: false, reason: "corrupt", detail: "invalid structure: missing servers object" };
+    }
+    return { ok: true, pins: { servers: parsed.servers } };
+  } catch (err2) {
+    if (err2.code === "ENOENT") {
+      return { ok: false, reason: "missing" };
+    }
+    return { ok: false, reason: "corrupt", detail: String(err2) };
+  }
+}
+function readMcpPins() {
+  const result = readMcpPinsSafe();
+  if (result.ok) return result.pins;
+  if (result.reason === "missing") return { servers: {} };
+  throw new Error(`[node9] MCP pin file is corrupt: ${result.detail}`);
+}
+function writeMcpPins(data) {
+  const filePath = getPinsFilePath();
+  fs24.mkdirSync(path27.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.${crypto3.randomBytes(6).toString("hex")}.tmp`;
+  fs24.writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 384 });
+  fs24.renameSync(tmp, filePath);
+}
+function checkPin(serverKey, currentHash) {
+  const result = readMcpPinsSafe();
+  if (!result.ok) {
+    if (result.reason === "missing") return "new";
+    return "corrupt";
+  }
+  const entry = result.pins.servers[serverKey];
+  if (!entry) return "new";
+  return entry.toolsHash === currentHash ? "match" : "mismatch";
+}
+function updatePin(serverKey, label, toolsHash, toolNames) {
+  const pins = readMcpPins();
+  pins.servers[serverKey] = {
+    label,
+    toolsHash,
+    toolNames,
+    toolCount: toolNames.length,
+    pinnedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeMcpPins(pins);
+}
+function removePin(serverKey) {
+  const pins = readMcpPins();
+  delete pins.servers[serverKey];
+  writeMcpPins(pins);
+}
+function clearAllPins() {
+  writeMcpPins({ servers: {} });
+}
+
+// src/mcp-gateway/index.ts
 function sanitize4(value) {
   return value.replace(/[\x00-\x1F\x7F]/g, "");
 }
@@ -10718,6 +10808,10 @@ async function runMcpGateway(upstreamCommand) {
   let authPending = false;
   let deferredExitCode = null;
   let deferredStdinEnd = false;
+  const pendingToolsListIds = /* @__PURE__ */ new Set();
+  const serverKey = getServerKey(upstreamCommand);
+  let pinState = "pending";
+  const pendingToolCalls = [];
   const agentIn = readline3.createInterface({ input: process.stdin, terminal: false });
   agentIn.on("line", async (line) => {
     let message;
@@ -10740,8 +10834,43 @@ async function runMcpGateway(upstreamCommand) {
       child.stdin.write(line + "\n");
       return;
     }
+    if (message.method === "tools/list" && message.id !== void 0 && message.id !== null) {
+      pendingToolsListIds.add(message.id);
+    }
     if (message.method === "tools/call" || message.method === "call_tool" || message.method === "use_tool") {
-      agentIn.pause();
+      if (pinState === "quarantined") {
+        if (message.id === void 0 || message.id === null) return;
+        const errorResponse = {
+          jsonrpc: "2.0",
+          id: message.id,
+          error: {
+            code: RPC_SERVER_ERROR,
+            message: `Node9 Security: This MCP session is quarantined due to a tool definition mismatch or corrupt pin state. The human operator must review and approve changes before tool calls are allowed. Run: node9 mcp pin update ${serverKey}`,
+            data: { reason: "pin-quarantine", serverKey, pinState }
+          }
+        };
+        process.stdout.write(JSON.stringify(errorResponse) + "\n");
+        return;
+      }
+      if (pinState === "pending") {
+        if (pendingToolsListIds.size > 0) {
+          pendingToolCalls.push(line);
+          return;
+        }
+        if (message.id === void 0 || message.id === null) return;
+        const errorResponse = {
+          jsonrpc: "2.0",
+          id: message.id,
+          error: {
+            code: RPC_SERVER_ERROR,
+            message: "Node9 Security: Tool calls are blocked until MCP tool definitions have been verified. The client must issue a tools/list request before calling tools.",
+            data: { reason: "pin-quarantine", serverKey, pinState }
+          }
+        };
+        process.stdout.write(JSON.stringify(errorResponse) + "\n");
+        return;
+      }
+      if (!deferredStdinEnd) agentIn.pause();
       authPending = true;
       try {
         const toolName = sanitize4(
@@ -10803,9 +10932,100 @@ async function runMcpGateway(upstreamCommand) {
     }
     child.stdin.write(line + "\n");
   });
-  child.stdout.pipe(process.stdout);
+  function drainPendingToolCalls() {
+    if (pendingToolCalls.length === 0) {
+      if (deferredStdinEnd && !authPending) child.stdin.end();
+      return;
+    }
+    const lines = pendingToolCalls.splice(0);
+    for (const queuedLine of lines) {
+      agentIn.emit("line", queuedLine);
+    }
+    if (deferredStdinEnd && !authPending) child.stdin.end();
+  }
+  const upstreamOut = readline3.createInterface({ input: child.stdout, terminal: false });
+  upstreamOut.on("line", (line) => {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+    }
+    if (!parsed) {
+      process.stdout.write(line + "\n");
+      return;
+    }
+    if (parsed.id !== void 0 && pendingToolsListIds.has(parsed.id)) {
+      pendingToolsListIds.delete(parsed.id);
+      if (parsed.result && Array.isArray(parsed.result.tools)) {
+        const tools = parsed.result.tools;
+        const currentHash = hashToolDefinitions(tools);
+        const pinStatus = checkPin(serverKey, currentHash);
+        if (pinStatus === "new") {
+          const toolNames = tools.map((t) => t.name ?? "unknown").sort();
+          updatePin(serverKey, upstreamCommand, currentHash, toolNames);
+          pinState = "validated";
+          console.error(
+            chalk15.green(
+              `\u{1F512} Node9: Pinned ${toolNames.length} tool definition(s) for this MCP server`
+            )
+          );
+          process.stdout.write(line + "\n");
+          drainPendingToolCalls();
+        } else if (pinStatus === "match") {
+          pinState = "validated";
+          process.stdout.write(line + "\n");
+          drainPendingToolCalls();
+        } else if (pinStatus === "corrupt") {
+          pinState = "quarantined";
+          console.error(
+            chalk15.red("\n\u{1F6A8} Node9: MCP pin file is corrupt or unreadable \u2014 session quarantined!")
+          );
+          console.error(chalk15.red("   Tool calls are blocked until the pin file is repaired."));
+          console.error(
+            chalk15.yellow(`   Run: node9 mcp pin reset  (to clear and re-pin on next connect)
+`)
+          );
+          const errorResponse = {
+            jsonrpc: "2.0",
+            id: parsed.id,
+            error: {
+              code: RPC_SERVER_ERROR,
+              message: "Node9 Security: MCP pin file is corrupt or unreadable. Tool definitions cannot be verified. Session quarantined. The human operator must repair or reset the pin file. Run: node9 mcp pin reset",
+              data: { reason: "pin-file-corrupt", serverKey }
+            }
+          };
+          process.stdout.write(JSON.stringify(errorResponse) + "\n");
+          drainPendingToolCalls();
+        } else {
+          pinState = "quarantined";
+          console.error(
+            chalk15.red("\n\u{1F6A8} Node9: MCP tool definitions have changed since last verified!")
+          );
+          console.error(
+            chalk15.red("   This could indicate a supply chain attack (tool poisoning / rug pull).")
+          );
+          console.error(chalk15.red("   Session quarantined \u2014 all tool calls blocked."));
+          console.error(chalk15.yellow(`   Run: node9 mcp pin update ${serverKey}
+`));
+          const errorResponse = {
+            jsonrpc: "2.0",
+            id: parsed.id,
+            error: {
+              code: RPC_SERVER_ERROR,
+              message: `Node9 Security: MCP server tool definitions have changed since they were last pinned. This could indicate a supply chain attack (tool poisoning / rug pull). Session quarantined \u2014 all tool calls are blocked. The human operator must review and approve the changes. Run: node9 mcp pin update ${serverKey}`,
+              data: { reason: "tool-pin-mismatch", serverKey }
+            }
+          };
+          process.stdout.write(JSON.stringify(errorResponse) + "\n");
+          drainPendingToolCalls();
+        }
+        return;
+      }
+    }
+    process.stdout.write(line + "\n");
+  });
   process.stdin.on("close", () => {
-    if (authPending) {
+    if (authPending || pendingToolCalls.length > 0) {
       deferredStdinEnd = true;
     } else {
       child.stdin.end();
@@ -10834,9 +11054,9 @@ function registerMcpGatewayCommand(program2) {
 
 // src/mcp-server/index.ts
 import readline4 from "readline";
-import fs24 from "fs";
-import os20 from "os";
-import path27 from "path";
+import fs25 from "fs";
+import os21 from "os";
+import path28 from "path";
 init_core();
 init_daemon();
 init_shields();
@@ -10936,6 +11156,60 @@ var TOOLS = [
       },
       required: ["hash"]
     }
+  },
+  {
+    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), and agent. Use this to review what AI actions have been taken recently.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Number of recent entries to return (default: 20, max: 100)."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "node9_policy_get",
+    description: "Show all active smart rules in detail \u2014 name, tool, verdict, conditions, and reason. Includes default rules, shield rules, and any custom project rules. Use this to understand exactly what is being blocked or reviewed.",
+    inputSchema: { type: "object", properties: {}, required: [] }
+  },
+  {
+    name: "node9_rule_add",
+    description: 'Add a new protective smart rule to the global node9 config (~/.node9/config.json). Rules can block or send dangerous commands for human review based on regex conditions. IMPORTANT: only "block" and "review" verdicts are permitted \u2014 "allow" rules are never accepted because they would weaken node9 security. Rules can only be added, never removed.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: 'Unique rule name (e.g. "block-drop-prod-db").'
+        },
+        tool: {
+          type: "string",
+          description: 'Tool to match \u2014 "bash", "*", or a specific tool name.'
+        },
+        field: {
+          type: "string",
+          description: 'Field to inspect \u2014 "command" for bash, "sql" for database tools.'
+        },
+        pattern: {
+          type: "string",
+          description: "Regex pattern to match against the field."
+        },
+        verdict: {
+          type: "string",
+          enum: ["block", "review"],
+          description: 'Action to take when the rule matches. Only "block" or "review" are allowed.'
+        },
+        reason: {
+          type: "string",
+          description: "Human-readable explanation shown when the rule triggers."
+        }
+      },
+      required: ["name", "tool", "field", "pattern", "verdict", "reason"]
+    }
   }
 ];
 function handleStatus() {
@@ -10957,13 +11231,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 = path27.join(process.cwd(), "node9.config.json");
-  const globalConfig = path27.join(os20.homedir(), ".node9", "config.json");
+  const projectConfig = path28.join(process.cwd(), "node9.config.json");
+  const globalConfig = path28.join(os21.homedir(), ".node9", "config.json");
   lines.push(
-    `Project config (node9.config.json): ${fs24.existsSync(projectConfig) ? "present" : "not found"}`
+    `Project config (node9.config.json): ${fs25.existsSync(projectConfig) ? "present" : "not found"}`
   );
   lines.push(
-    `Global config (~/.node9/config.json): ${fs24.existsSync(globalConfig) ? "present" : "not found"}`
+    `Global config (~/.node9/config.json): ${fs25.existsSync(globalConfig) ? "present" : "not found"}`
   );
   return lines.join("\n");
 }
@@ -11037,21 +11311,21 @@ function handleShieldDisable(args) {
   writeActiveShields(active.filter((s) => s !== name));
   return `Shield "${name}" disabled.`;
 }
-var GLOBAL_CONFIG_PATH2 = path27.join(os20.homedir(), ".node9", "config.json");
+var GLOBAL_CONFIG_PATH2 = path28.join(os21.homedir(), ".node9", "config.json");
 var APPROVER_CHANNELS = ["native", "browser", "cloud", "terminal"];
 function readGlobalConfigRaw() {
   try {
-    if (fs24.existsSync(GLOBAL_CONFIG_PATH2)) {
-      return JSON.parse(fs24.readFileSync(GLOBAL_CONFIG_PATH2, "utf-8"));
+    if (fs25.existsSync(GLOBAL_CONFIG_PATH2)) {
+      return JSON.parse(fs25.readFileSync(GLOBAL_CONFIG_PATH2, "utf-8"));
     }
   } catch {
   }
   return {};
 }
 function writeGlobalConfigRaw(data) {
-  const dir = path27.dirname(GLOBAL_CONFIG_PATH2);
-  if (!fs24.existsSync(dir)) fs24.mkdirSync(dir, { recursive: true });
-  fs24.writeFileSync(GLOBAL_CONFIG_PATH2, JSON.stringify(data, null, 2) + "\n");
+  const dir = path28.dirname(GLOBAL_CONFIG_PATH2);
+  if (!fs25.existsSync(dir)) fs25.mkdirSync(dir, { recursive: true });
+  fs25.writeFileSync(GLOBAL_CONFIG_PATH2, JSON.stringify(data, null, 2) + "\n");
 }
 function handleApproverList() {
   const config = getConfig();
@@ -11092,6 +11366,75 @@ function handleApproverSet(args) {
   const suffix = anyEnabled ? "" : "\nWARNING: all approver channels are now disabled \u2014 node9 cannot prompt for approval.";
   return `Approver channel "${channel}" ${enabled ? "enabled" : "disabled"} in ~/.node9/config.json.${suffix}`;
 }
+function handleAuditGet(args) {
+  const limit = Math.min(typeof args.limit === "number" ? args.limit : 20, 100);
+  const auditPath = path28.join(os21.homedir(), ".node9", "audit.log");
+  if (!fs25.existsSync(auditPath)) return "No audit log found.";
+  const lines = fs25.readFileSync(auditPath, "utf-8").trim().split("\n").filter(Boolean);
+  const recent = lines.slice(-limit);
+  const entries = recent.map((line) => {
+    try {
+      const e = JSON.parse(line);
+      return `${e.ts}  ${String(e.tool).padEnd(20)} ${String(e.decision).padEnd(8)} ${e.agent ?? ""}`;
+    } catch {
+      return line;
+    }
+  });
+  return `Last ${entries.length} audit entries:
+
+${entries.join("\n")}`;
+}
+function handlePolicyGet() {
+  const config = getConfig();
+  const rules = config.policy.smartRules;
+  if (rules.length === 0) return "No smart rules active.";
+  const lines = rules.map((r, i) => {
+    const conditions = r.conditions.map((c) => `${c.field} ${c.op} "${c.value}"`).join(` ${r.conditionMode ?? "all"} `);
+    return `[${i + 1}] ${r.name ?? "(unnamed)"}  tool:${r.tool}  verdict:${r.verdict}
+    conditions: ${conditions}
+    reason: ${r.reason ?? "\u2014"}`;
+  });
+  return `${rules.length} active smart rules:
+
+${lines.join("\n\n")}`;
+}
+function handleRuleAdd(args) {
+  const name = args.name;
+  const tool = args.tool;
+  const field = args.field;
+  const pattern = args.pattern;
+  const verdict = args.verdict;
+  const reason = args.reason;
+  if (!["block", "review"].includes(verdict)) {
+    throw new Error(
+      'verdict must be "block" or "review" \u2014 "allow" rules are not permitted as they would weaken node9 security'
+    );
+  }
+  try {
+    new RegExp(pattern);
+  } catch {
+    throw new Error(`Invalid regex pattern: ${pattern}`);
+  }
+  const raw = readGlobalConfigRaw();
+  const policy = raw.policy ?? {};
+  const smartRules = policy.smartRules ?? [];
+  const existing = smartRules.find(
+    (r) => typeof r === "object" && r !== null && r.name === name
+  );
+  if (existing) throw new Error(`A rule named "${name}" already exists.`);
+  smartRules.push({
+    name,
+    tool,
+    conditions: [{ field, op: "matches", value: pattern }],
+    conditionMode: "all",
+    verdict,
+    reason
+  });
+  policy.smartRules = smartRules;
+  raw.policy = policy;
+  writeGlobalConfigRaw(raw);
+  return `Rule "${name}" added to ~/.node9/config.json \u2014 verdict: ${verdict} when ${field} matches "${pattern}"`;
+}
 function handleUndoList() {
   const history = getSnapshotHistory();
   if (history.length === 0) {
@@ -11175,6 +11518,12 @@ function runMcpServer() {
           text = handleUndoList();
         } else if (toolName === "node9_undo_revert") {
           text = handleUndoRevert(toolArgs);
+        } else if (toolName === "node9_audit_get") {
+          text = handleAuditGet(toolArgs);
+        } else if (toolName === "node9_policy_get") {
+          text = handlePolicyGet();
+        } else if (toolName === "node9_rule_add") {
+          text = handleRuleAdd(toolArgs);
         } else {
           process.stdout.write(err(id, -32601, `Unknown tool: ${toolName}`) + "\n");
           return;
@@ -11262,22 +11611,99 @@ function registerTrustCommand(program2) {
   });
 }
 
+// src/cli/commands/mcp-pin.ts
+import chalk17 from "chalk";
+function registerMcpPinCommand(program2) {
+  const pinCmd = program2.command("mcp").description("Manage MCP server tool definition pinning (rug pull defense)");
+  const pinSubCmd = pinCmd.command("pin").description("Manage pinned MCP server tool definitions");
+  pinSubCmd.command("list").description("Show all pinned MCP servers and their tool definition hashes").action(() => {
+    const result = readMcpPinsSafe();
+    if (!result.ok) {
+      if (result.reason === "missing") {
+        console.log(chalk17.gray("\nNo MCP servers are pinned yet."));
+        console.log(
+          chalk17.gray("Pins are created automatically when the MCP gateway first connects.\n")
+        );
+        return;
+      }
+      console.error(chalk17.red(`
+\u274C Pin file is corrupt: ${result.detail}`));
+      console.error(chalk17.yellow("   Run: node9 mcp pin reset\n"));
+      process.exit(1);
+    }
+    const entries = Object.entries(result.pins.servers);
+    if (entries.length === 0) {
+      console.log(chalk17.gray("\nNo MCP servers are pinned yet."));
+      console.log(
+        chalk17.gray("Pins are created automatically when the MCP gateway first connects.\n")
+      );
+      return;
+    }
+    console.log(chalk17.bold("\n\u{1F512} Pinned MCP Servers\n"));
+    for (const [key, entry] of entries) {
+      console.log(`  ${chalk17.cyan(key)}  ${chalk17.gray(entry.label)}`);
+      console.log(`    Tools (${entry.toolCount}): ${chalk17.white(entry.toolNames.join(", "))}`);
+      console.log(`    Hash:  ${chalk17.gray(entry.toolsHash.slice(0, 16))}...`);
+      console.log(`    Pinned: ${chalk17.gray(entry.pinnedAt)}`);
+      console.log("");
+    }
+  });
+  pinSubCmd.command("update <serverKey>").description(
+    "Remove a pin so the next gateway connection re-pins with current tool definitions"
+  ).action((serverKey) => {
+    let pins;
+    try {
+      pins = readMcpPins();
+    } catch {
+      console.error(chalk17.red("\n\u274C Pin file is corrupt."));
+      console.error(chalk17.yellow("   Run: node9 mcp pin reset\n"));
+      process.exit(1);
+    }
+    if (!pins.servers[serverKey]) {
+      console.error(chalk17.red(`
+\u274C No pin found for server key "${serverKey}"
+`));
+      console.error(`Run ${chalk17.cyan("node9 mcp pin list")} to see pinned servers.
+`);
+      process.exit(1);
+    }
+    const label = pins.servers[serverKey].label;
+    removePin(serverKey);
+    console.log(chalk17.green(`
+\u{1F513} Pin removed for ${chalk17.cyan(serverKey)}`));
+    console.log(chalk17.gray(`   Server: ${label}`));
+    console.log(chalk17.gray("   Next connection will re-pin with current tool definitions.\n"));
+  });
+  pinSubCmd.command("reset").description("Clear all MCP pins (next connection to each server will re-pin)").action(() => {
+    const result = readMcpPinsSafe();
+    if (!result.ok && result.reason === "missing") {
+      console.log(chalk17.gray("\nNo pins to clear.\n"));
+      return;
+    }
+    const count = result.ok ? Object.keys(result.pins.servers).length : "?";
+    clearAllPins();
+    console.log(chalk17.green(`
+\u{1F513} Cleared ${count} MCP pin(s).`));
+    console.log(chalk17.gray("   Next connection to each server will re-pin.\n"));
+  });
+}
+
 // src/cli.ts
 var { version } = JSON.parse(
-  fs27.readFileSync(path30.join(__dirname, "../package.json"), "utf-8")
+  fs28.readFileSync(path31.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 = path30.join(os23.homedir(), ".node9", "credentials.json");
-  if (!fs27.existsSync(path30.dirname(credPath)))
-    fs27.mkdirSync(path30.dirname(credPath), { recursive: true });
+  const credPath = path31.join(os24.homedir(), ".node9", "credentials.json");
+  if (!fs28.existsSync(path31.dirname(credPath)))
+    fs28.mkdirSync(path31.dirname(credPath), { recursive: true });
   const profileName = options.profile || "default";
   let existingCreds = {};
   try {
-    if (fs27.existsSync(credPath)) {
-      const raw = JSON.parse(fs27.readFileSync(credPath, "utf-8"));
+    if (fs28.existsSync(credPath)) {
+      const raw = JSON.parse(fs28.readFileSync(credPath, "utf-8"));
       if (raw.apiKey) {
         existingCreds = {
           default: { apiKey: raw.apiKey, apiUrl: raw.apiUrl || DEFAULT_API_URL }
@@ -11289,13 +11715,13 @@ program.command("login").argument("<apiKey>").option("--local", "Save key for au
   } catch {
   }
   existingCreds[profileName] = { apiKey, apiUrl: DEFAULT_API_URL };
-  fs27.writeFileSync(credPath, JSON.stringify(existingCreds, null, 2), { mode: 384 });
+  fs28.writeFileSync(credPath, JSON.stringify(existingCreds, null, 2), { mode: 384 });
   if (profileName === "default") {
-    const configPath = path30.join(os23.homedir(), ".node9", "config.json");
+    const configPath = path31.join(os24.homedir(), ".node9", "config.json");
     let config = {};
     try {
-      if (fs27.existsSync(configPath))
-        config = JSON.parse(fs27.readFileSync(configPath, "utf-8"));
+      if (fs28.existsSync(configPath))
+        config = JSON.parse(fs28.readFileSync(configPath, "utf-8"));
     } catch {
     }
     if (!config.settings || typeof config.settings !== "object") config.settings = {};
@@ -11310,19 +11736,19 @@ program.command("login").argument("<apiKey>").option("--local", "Save key for au
       approvers.cloud = false;
     }
     s.approvers = approvers;
-    if (!fs27.existsSync(path30.dirname(configPath)))
-      fs27.mkdirSync(path30.dirname(configPath), { recursive: true });
-    fs27.writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 384 });
+    if (!fs28.existsSync(path31.dirname(configPath)))
+      fs28.mkdirSync(path31.dirname(configPath), { recursive: true });
+    fs28.writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 384 });
   }
   if (options.profile && profileName !== "default") {
-    console.log(chalk18.green(`\u2705 Profile "${profileName}" saved`));
-    console.log(chalk18.gray(`   Switch to it per-session:  NODE9_PROFILE=${profileName} claude`));
+    console.log(chalk19.green(`\u2705 Profile "${profileName}" saved`));
+    console.log(chalk19.gray(`   Switch to it per-session:  NODE9_PROFILE=${profileName} claude`));
   } else if (options.local) {
-    console.log(chalk18.green(`\u2705 Privacy mode \u{1F6E1}\uFE0F`));
-    console.log(chalk18.gray(`   All decisions stay on this machine.`));
+    console.log(chalk19.green(`\u2705 Privacy mode \u{1F6E1}\uFE0F`));
+    console.log(chalk19.gray(`   All decisions stay on this machine.`));
   } else {
-    console.log(chalk18.green(`\u2705 Logged in \u2014 agent mode`));
-    console.log(chalk18.gray(`   Team policy enforced for all calls via Node9 cloud.`));
+    console.log(chalk19.green(`\u2705 Logged in \u2014 agent mode`));
+    console.log(chalk19.gray(`   Team policy enforced for all calls via Node9 cloud.`));
   }
 });
 program.command("addto").description("Integrate Node9 with an AI agent").addHelpText("after", "\n  Supported targets:  claude  gemini  cursor  hud").argument("<target>", "The agent to protect: claude | gemini | cursor | hud").action(async (target) => {
@@ -11330,19 +11756,19 @@ program.command("addto").description("Integrate Node9 with an AI agent").addHelp
   if (target === "claude") return await setupClaude();
   if (target === "cursor") return await setupCursor();
   if (target === "hud") return setupHud();
-  console.error(chalk18.red(`Unknown target: "${target}". Supported: claude, gemini, cursor, hud`));
+  console.error(chalk19.red(`Unknown target: "${target}". Supported: claude, gemini, cursor, hud`));
   process.exit(1);
 });
 program.command("setup").description('Alias for "addto" \u2014 integrate Node9 with an AI agent').addHelpText("after", "\n  Supported targets:  claude  gemini  cursor  hud").argument("[target]", "The agent to protect: claude | gemini | cursor | hud").action(async (target) => {
   if (!target) {
-    console.log(chalk18.cyan("\n\u{1F6E1}\uFE0F  Node9 Setup \u2014 integrate with your AI agent\n"));
-    console.log("  Usage:  " + chalk18.white("node9 setup <target>") + "\n");
+    console.log(chalk19.cyan("\n\u{1F6E1}\uFE0F  Node9 Setup \u2014 integrate with your AI agent\n"));
+    console.log("  Usage:  " + chalk19.white("node9 setup <target>") + "\n");
     console.log("  Targets:");
-    console.log("    " + chalk18.green("claude") + "   \u2014 Claude Code (hook mode)");
-    console.log("    " + chalk18.green("gemini") + "   \u2014 Gemini CLI (hook mode)");
-    console.log("    " + chalk18.green("cursor") + "   \u2014 Cursor (hook mode)");
+    console.log("    " + chalk19.green("claude") + "   \u2014 Claude Code (hook mode)");
+    console.log("    " + chalk19.green("gemini") + "   \u2014 Gemini CLI (hook mode)");
+    console.log("    " + chalk19.green("cursor") + "   \u2014 Cursor (hook mode)");
     process.stdout.write(
-      "    " + chalk18.green("hud") + "     \u2014 Claude Code security statusline\n"
+      "    " + chalk19.green("hud") + "     \u2014 Claude Code security statusline\n"
     );
     console.log("");
     return;
@@ -11352,7 +11778,7 @@ program.command("setup").description('Alias for "addto" \u2014 integrate Node9 w
   if (t === "claude") return await setupClaude();
   if (t === "cursor") return await setupCursor();
   if (t === "hud") return setupHud();
-  console.error(chalk18.red(`Unknown target: "${target}". Supported: claude, gemini, cursor, hud`));
+  console.error(chalk19.red(`Unknown target: "${target}". Supported: claude, gemini, cursor, hud`));
   process.exit(1);
 });
 program.command("removefrom").description("Remove Node9 hooks from an AI agent configuration").addHelpText("after", "\n  Supported targets:  claude  gemini  cursor").argument("<target>", "The agent to remove from: claude | gemini | cursor").action((target) => {
@@ -11363,31 +11789,31 @@ program.command("removefrom").description("Remove Node9 hooks from an AI agent c
   else if (target === "hud") fn = teardownHud;
   else {
     console.error(
-      chalk18.red(`Unknown target: "${target}". Supported: claude, gemini, cursor, hud`)
+      chalk19.red(`Unknown target: "${target}". Supported: claude, gemini, cursor, hud`)
     );
     process.exit(1);
   }
-  console.log(chalk18.cyan(`
+  console.log(chalk19.cyan(`
 \u{1F6E1}\uFE0F  Node9: removing hooks from ${target}...
 `));
   try {
     fn();
   } catch (err2) {
-    console.error(chalk18.red(`  \u26A0\uFE0F  Failed: ${err2 instanceof Error ? err2.message : String(err2)}`));
+    console.error(chalk19.red(`  \u26A0\uFE0F  Failed: ${err2 instanceof Error ? err2.message : String(err2)}`));
     process.exit(1);
   }
-  console.log(chalk18.gray("\n  Restart the agent for changes to take effect."));
+  console.log(chalk19.gray("\n  Restart the agent for changes to take effect."));
 });
 program.command("uninstall").description("Remove all Node9 hooks and optionally delete config files").option("--purge", "Also delete ~/.node9/ directory (config, audit log, credentials)").action(async (options) => {
-  console.log(chalk18.cyan("\n\u{1F6E1}\uFE0F  Node9 Uninstall\n"));
-  console.log(chalk18.bold("Stopping daemon..."));
+  console.log(chalk19.cyan("\n\u{1F6E1}\uFE0F  Node9 Uninstall\n"));
+  console.log(chalk19.bold("Stopping daemon..."));
   try {
     stopDaemon();
-    console.log(chalk18.green("  \u2705 Daemon stopped"));
+    console.log(chalk19.green("  \u2705 Daemon stopped"));
   } catch {
-    console.log(chalk18.blue("  \u2139\uFE0F  Daemon was not running"));
+    console.log(chalk19.blue("  \u2139\uFE0F  Daemon was not running"));
   }
-  console.log(chalk18.bold("\nRemoving hooks..."));
+  console.log(chalk19.bold("\nRemoving hooks..."));
   let teardownFailed = false;
   for (const [label, fn] of [
     ["Claude", teardownClaude],
@@ -11399,45 +11825,45 @@ program.command("uninstall").description("Remove all Node9 hooks and optionally
     } catch (err2) {
       teardownFailed = true;
       console.error(
-        chalk18.red(
+        chalk19.red(
           `  \u26A0\uFE0F  Failed to remove ${label} hooks: ${err2 instanceof Error ? err2.message : String(err2)}`
         )
       );
     }
   }
   if (options.purge) {
-    const node9Dir = path30.join(os23.homedir(), ".node9");
-    if (fs27.existsSync(node9Dir)) {
+    const node9Dir = path31.join(os24.homedir(), ".node9");
+    if (fs28.existsSync(node9Dir)) {
       const confirmed = await confirm2({
         message: `Permanently delete ${node9Dir} (config, audit log, credentials)?`,
         default: false
       });
       if (confirmed) {
-        fs27.rmSync(node9Dir, { recursive: true });
-        if (fs27.existsSync(node9Dir)) {
+        fs28.rmSync(node9Dir, { recursive: true });
+        if (fs28.existsSync(node9Dir)) {
           console.error(
-            chalk18.red("\n  \u26A0\uFE0F  ~/.node9/ could not be fully deleted \u2014 remove it manually.")
+            chalk19.red("\n  \u26A0\uFE0F  ~/.node9/ could not be fully deleted \u2014 remove it manually.")
           );
         } else {
-          console.log(chalk18.green("\n  \u2705 Deleted ~/.node9/ (config, audit log, credentials)"));
+          console.log(chalk19.green("\n  \u2705 Deleted ~/.node9/ (config, audit log, credentials)"));
         }
       } else {
-        console.log(chalk18.yellow("\n  Skipped \u2014 ~/.node9/ was not deleted."));
+        console.log(chalk19.yellow("\n  Skipped \u2014 ~/.node9/ was not deleted."));
       }
     } else {
-      console.log(chalk18.blue("\n  \u2139\uFE0F  ~/.node9/ not found \u2014 nothing to delete"));
+      console.log(chalk19.blue("\n  \u2139\uFE0F  ~/.node9/ not found \u2014 nothing to delete"));
     }
   } else {
     console.log(
-      chalk18.gray("\n  ~/.node9/ kept \u2014 run with --purge to delete config and audit log")
+      chalk19.gray("\n  ~/.node9/ kept \u2014 run with --purge to delete config and audit log")
     );
   }
   if (teardownFailed) {
-    console.error(chalk18.red("\n  \u26A0\uFE0F  Some hooks could not be removed \u2014 see errors above."));
+    console.error(chalk19.red("\n  \u26A0\uFE0F  Some hooks could not be removed \u2014 see errors above."));
     process.exit(1);
   }
-  console.log(chalk18.green.bold("\n\u{1F6E1}\uFE0F  Node9 removed. Run: npm uninstall -g @node9/proxy"));
-  console.log(chalk18.gray("   Restart any open AI agent sessions for changes to take effect.\n"));
+  console.log(chalk19.green.bold("\n\u{1F6E1}\uFE0F  Node9 removed. Run: npm uninstall -g @node9/proxy"));
+  console.log(chalk19.gray("   Restart any open AI agent sessions for changes to take effect.\n"));
 });
 registerDoctorCommand(program, version);
 program.command("explain").description(
@@ -11450,7 +11876,7 @@ program.command("explain").description(
       try {
         args = JSON.parse(trimmed);
       } catch {
-        console.error(chalk18.red(`
+        console.error(chalk19.red(`
 \u274C Invalid JSON: ${trimmed}
 `));
         process.exit(1);
@@ -11461,54 +11887,54 @@ program.command("explain").description(
   }
   const result = await explainPolicy(tool, args);
   console.log("");
-  console.log(chalk18.cyan.bold("\u{1F6E1}\uFE0F  Node9 Explain"));
+  console.log(chalk19.cyan.bold("\u{1F6E1}\uFE0F  Node9 Explain"));
   console.log("");
-  console.log(`   ${chalk18.bold("Tool:")}    ${chalk18.white(result.tool)}`);
+  console.log(`   ${chalk19.bold("Tool:")}    ${chalk19.white(result.tool)}`);
   if (argsRaw) {
     const preview = argsRaw.length > 80 ? argsRaw.slice(0, 77) + "\u2026" : argsRaw;
-    console.log(`   ${chalk18.bold("Input:")}   ${chalk18.gray(preview)}`);
+    console.log(`   ${chalk19.bold("Input:")}   ${chalk19.gray(preview)}`);
   }
   console.log("");
-  console.log(chalk18.bold("Config Sources (Waterfall):"));
+  console.log(chalk19.bold("Config Sources (Waterfall):"));
   for (const tier of result.waterfall) {
-    const num = chalk18.gray(`  ${tier.tier}.`);
+    const num = chalk19.gray(`  ${tier.tier}.`);
     const label = tier.label.padEnd(16);
     let statusStr;
     if (tier.tier === 1) {
-      statusStr = chalk18.gray(tier.note ?? "");
+      statusStr = chalk19.gray(tier.note ?? "");
     } else if (tier.status === "active") {
-      const loc = tier.path ? chalk18.gray(tier.path) : "";
-      const note = tier.note ? chalk18.gray(`(${tier.note})`) : "";
-      statusStr = chalk18.green("\u2713 active") + (loc ? "  " + loc : "") + (note ? "  " + note : "");
+      const loc = tier.path ? chalk19.gray(tier.path) : "";
+      const note = tier.note ? chalk19.gray(`(${tier.note})`) : "";
+      statusStr = chalk19.green("\u2713 active") + (loc ? "  " + loc : "") + (note ? "  " + note : "");
     } else {
-      statusStr = chalk18.gray("\u25CB " + (tier.note ?? "not found"));
+      statusStr = chalk19.gray("\u25CB " + (tier.note ?? "not found"));
     }
-    console.log(`${num} ${chalk18.white(label)} ${statusStr}`);
+    console.log(`${num} ${chalk19.white(label)} ${statusStr}`);
   }
   console.log("");
-  console.log(chalk18.bold("Policy Evaluation:"));
+  console.log(chalk19.bold("Policy Evaluation:"));
   for (const step of result.steps) {
     const isFinal = step.isFinal;
     let icon;
-    if (step.outcome === "allow") icon = chalk18.green("  \u2705");
-    else if (step.outcome === "review") icon = chalk18.red("  \u{1F534}");
-    else if (step.outcome === "skip") icon = chalk18.gray("  \u2500 ");
-    else icon = chalk18.gray("  \u25CB ");
+    if (step.outcome === "allow") icon = chalk19.green("  \u2705");
+    else if (step.outcome === "review") icon = chalk19.red("  \u{1F534}");
+    else if (step.outcome === "skip") icon = chalk19.gray("  \u2500 ");
+    else icon = chalk19.gray("  \u25CB ");
     const name = step.name.padEnd(18);
-    const nameStr = isFinal ? chalk18.white.bold(name) : chalk18.white(name);
-    const detail = isFinal ? chalk18.white(step.detail) : chalk18.gray(step.detail);
-    const arrow = isFinal ? chalk18.yellow("  \u2190 STOP") : "";
+    const nameStr = isFinal ? chalk19.white.bold(name) : chalk19.white(name);
+    const detail = isFinal ? chalk19.white(step.detail) : chalk19.gray(step.detail);
+    const arrow = isFinal ? chalk19.yellow("  \u2190 STOP") : "";
     console.log(`${icon} ${nameStr} ${detail}${arrow}`);
   }
   console.log("");
   if (result.decision === "allow") {
-    console.log(chalk18.green.bold("  Decision: \u2705 ALLOW") + chalk18.gray("  \u2014 no approval needed"));
+    console.log(chalk19.green.bold("  Decision: \u2705 ALLOW") + chalk19.gray("  \u2014 no approval needed"));
   } else {
     console.log(
-      chalk18.red.bold("  Decision: \u{1F534} REVIEW") + chalk18.gray("  \u2014 human approval required")
+      chalk19.red.bold("  Decision: \u{1F534} REVIEW") + chalk19.gray("  \u2014 human approval required")
     );
     if (result.blockedByLabel) {
-      console.log(chalk18.gray(`  Reason:   ${result.blockedByLabel}`));
+      console.log(chalk19.gray(`  Reason:   ${result.blockedByLabel}`));
     }
   }
   console.log("");
@@ -11522,13 +11948,14 @@ program.command("tail").description("Stream live agent activity to the terminal"
   try {
     await startTail2(options);
   } catch (err2) {
-    console.error(chalk18.red(`\u274C ${err2 instanceof Error ? err2.message : String(err2)}`));
+    console.error(chalk19.red(`\u274C ${err2 instanceof Error ? err2.message : String(err2)}`));
     process.exit(1);
   }
 });
 registerWatchCommand(program);
 registerMcpGatewayCommand(program);
 registerMcpServerCommand(program);
+registerMcpPinCommand(program);
 registerCheckCommand(program);
 registerLogCommand(program);
 program.command("hud").description("Render node9 security statusline (spawned by Claude Code statusLine)").addHelpText(
@@ -11553,14 +11980,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 = path30.join(os23.homedir(), ".node9", "hud-debug");
+    const flagFile = path31.join(os24.homedir(), ".node9", "hud-debug");
     if (state === "on") {
-      fs27.mkdirSync(path30.dirname(flagFile), { recursive: true });
-      fs27.writeFileSync(flagFile, "");
+      fs28.mkdirSync(path31.dirname(flagFile), { recursive: true });
+      fs28.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 (fs27.existsSync(flagFile)) fs27.unlinkSync(flagFile);
+      if (fs28.existsSync(flagFile)) fs28.unlinkSync(flagFile);
       console.log("HUD debug logging disabled.");
     } else {
       console.error("Usage: node9 hud debug on|off");
@@ -11575,7 +12002,7 @@ program.command("pause").description("Temporarily disable Node9 protection for a
   const ms = parseDuration(options.duration);
   if (ms === null) {
     console.error(
-      chalk18.red(`
+      chalk19.red(`
 \u274C  Invalid duration: "${options.duration}". Use format like 15m, 1h, 30s.
 `)
     );
@@ -11583,20 +12010,20 @@ program.command("pause").description("Temporarily disable Node9 protection for a
   }
   pauseNode9(ms, options.duration);
   const expiresAt = new Date(Date.now() + ms).toLocaleTimeString();
-  console.log(chalk18.yellow(`
+  console.log(chalk19.yellow(`
 \u23F8  Node9 paused until ${expiresAt}`));
-  console.log(chalk18.gray(`   All tool calls will be allowed without review.`));
-  console.log(chalk18.gray(`   Run "node9 resume" to re-enable early.
+  console.log(chalk19.gray(`   All tool calls will be allowed without review.`));
+  console.log(chalk19.gray(`   Run "node9 resume" to re-enable early.
 `));
 });
 program.command("resume").description("Re-enable Node9 protection immediately").action(() => {
   const { paused } = checkPause();
   if (!paused) {
-    console.log(chalk18.gray("\nNode9 is already active \u2014 nothing to resume.\n"));
+    console.log(chalk19.gray("\nNode9 is already active \u2014 nothing to resume.\n"));
     return;
   }
   resumeNode9();
-  console.log(chalk18.green("\n\u25B6  Node9 resumed \u2014 protection is active.\n"));
+  console.log(chalk19.green("\n\u25B6  Node9 resumed \u2014 protection is active.\n"));
 });
 var HOOK_BASED_AGENTS = {
   claude: "claude",
@@ -11609,15 +12036,15 @@ program.argument("[command...]", "The agent command to run (e.g., gemini)").acti
     if (HOOK_BASED_AGENTS[firstArg2] !== void 0) {
       const target = HOOK_BASED_AGENTS[firstArg2];
       console.error(
-        chalk18.yellow(`
+        chalk19.yellow(`
 \u26A0\uFE0F  Node9 proxy mode does not support "${target}" directly.`)
       );
-      console.error(chalk18.white(`
+      console.error(chalk19.white(`
    "${target}" uses its own hook system. Use:`));
       console.error(
-        chalk18.green(`     node9 addto ${target}   `) + chalk18.gray("# one-time setup")
+        chalk19.green(`     node9 addto ${target}   `) + chalk19.gray("# one-time setup")
       );
-      console.error(chalk18.green(`     ${target}              `) + chalk18.gray("# run normally"));
+      console.error(chalk19.green(`     ${target}              `) + chalk19.gray("# run normally"));
       process.exit(1);
     }
     const runArgs = firstArg2 === "shell" ? commandArgs.slice(1) : commandArgs;
@@ -11634,7 +12061,7 @@ program.argument("[command...]", "The agent command to run (e.g., gemini)").acti
       }
     );
     if (result.noApprovalMechanism && !isDaemonRunning() && !process.env.NODE9_NO_AUTO_DAEMON && getConfig().settings.autoStartDaemon) {
-      console.error(chalk18.cyan("\n\u{1F6E1}\uFE0F  Node9: Starting approval daemon automatically..."));
+      console.error(chalk19.cyan("\n\u{1F6E1}\uFE0F  Node9: Starting approval daemon automatically..."));
       const daemonReady = await autoStartDaemonAndWait();
       if (daemonReady) result = await authorizeHeadless("shell", { command: fullCommand });
     }
@@ -11647,12 +12074,12 @@ program.argument("[command...]", "The agent command to run (e.g., gemini)").acti
     }
     if (!result.approved) {
       console.error(
-        chalk18.red(`
+        chalk19.red(`
 \u274C Node9 Blocked: ${result.reason || "Dangerous command detected."}`)
       );
       process.exit(1);
     }
-    console.error(chalk18.green("\n\u2705 Approved \u2014 running command...\n"));
+    console.error(chalk19.green("\n\u2705 Approved \u2014 running command...\n"));
     await runProxy(fullCommand);
   } else {
     program.help();
@@ -11667,9 +12094,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 = path30.join(os23.homedir(), ".node9", "hook-debug.log");
+        const logPath = path31.join(os24.homedir(), ".node9", "hook-debug.log");
         const msg = reason instanceof Error ? reason.message : String(reason);
-        fs27.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] UNHANDLED: ${msg}
+        fs28.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] UNHANDLED: ${msg}
 `);
       }
       process.exit(0);