@node9/proxy 1.0.13 → 1.0.14

package/dist/cli.js

@@ -29,9 +29,9 @@ var import_commander = require("commander");
 // src/core.ts
 var import_chalk2 = __toESM(require("chalk"));
 var import_prompts = require("@inquirer/prompts");
-var import_fs = __toESM(require("fs"));
-var import_path3 = __toESM(require("path"));
-var import_os = __toESM(require("os"));
+var import_fs2 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+var import_os2 = __toESM(require("os"));
 var import_picomatch = __toESM(require("picomatch"));
 var import_sh_syntax = require("sh-syntax");
 
@@ -361,25 +361,26 @@ var import_zod = require("zod");
 var noNewlines = import_zod.z.string().refine((s) => !s.includes("\n") && !s.includes("\r"), {
   message: "Value must not contain literal newline characters (use \\n instead)"
 });
-var validRegex = noNewlines.refine(
-  (s) => {
-    try {
-      new RegExp(s);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  { message: "Value must be a valid regular expression" }
-);
 var SmartConditionSchema = import_zod.z.object({
   field: import_zod.z.string().min(1, "Condition field must not be empty"),
-  op: import_zod.z.enum(["matches", "notMatches", "contains", "notContains", "exists", "notExists"], {
-    errorMap: () => ({
-      message: "op must be one of: matches, notMatches, contains, notContains, exists, notExists"
-    })
-  }),
-  value: validRegex.optional(),
+  op: import_zod.z.enum(
+    [
+      "matches",
+      "notMatches",
+      "contains",
+      "notContains",
+      "exists",
+      "notExists",
+      "matchesGlob",
+      "notMatchesGlob"
+    ],
+    {
+      errorMap: () => ({
+        message: "op must be one of: matches, notMatches, contains, notContains, exists, notExists, matchesGlob, notMatchesGlob"
+      })
+    }
+  ),
+  value: import_zod.z.string().optional(),
   flags: import_zod.z.string().optional()
 });
 var SmartRuleSchema = import_zod.z.object({
@@ -392,11 +393,6 @@ var SmartRuleSchema = import_zod.z.object({
   }),
   reason: import_zod.z.string().optional()
 });
-var PolicyRuleSchema = import_zod.z.object({
-  action: import_zod.z.string().min(1),
-  allowPaths: import_zod.z.array(import_zod.z.string()).optional(),
-  blockPaths: import_zod.z.array(import_zod.z.string()).optional()
-});
 var ConfigFileSchema = import_zod.z.object({
   version: import_zod.z.string().optional(),
   settings: import_zod.z.object({
@@ -421,12 +417,15 @@ var ConfigFileSchema = import_zod.z.object({
     dangerousWords: import_zod.z.array(noNewlines).optional(),
     ignoredTools: import_zod.z.array(import_zod.z.string()).optional(),
     toolInspection: import_zod.z.record(import_zod.z.string()).optional(),
-    rules: import_zod.z.array(PolicyRuleSchema).optional(),
     smartRules: import_zod.z.array(SmartRuleSchema).optional(),
     snapshot: import_zod.z.object({
       tools: import_zod.z.array(import_zod.z.string()).optional(),
       onlyPaths: import_zod.z.array(import_zod.z.string()).optional(),
       ignorePaths: import_zod.z.array(import_zod.z.string()).optional()
+    }).optional(),
+    dlp: import_zod.z.object({
+      enabled: import_zod.z.boolean().optional(),
+      scanIgnoredTools: import_zod.z.boolean().optional()
     }).optional()
   }).optional(),
   environments: import_zod.z.record(import_zod.z.object({ requireApproval: import_zod.z.boolean().optional() })).optional()
@@ -448,8 +447,8 @@ function sanitizeConfig(raw) {
     }
   }
   const lines = result.error.issues.map((issue) => {
-    const path8 = issue.path.length > 0 ? issue.path.join(".") : "root";
-    return `  \u2022 ${path8}: ${issue.message}`;
+    const path9 = issue.path.length > 0 ? issue.path.join(".") : "root";
+    return `  \u2022 ${path9}: ${issue.message}`;
   });
   return {
     sanitized,
@@ -458,18 +457,301 @@ ${lines.join("\n")}`
   };
 }
 
+// src/shields.ts
+var import_fs = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var import_crypto = __toESM(require("crypto"));
+var SHIELDS = {
+  postgres: {
+    name: "postgres",
+    description: "Protects PostgreSQL databases from destructive AI operations",
+    aliases: ["pg", "postgresql"],
+    smartRules: [
+      {
+        name: "shield:postgres:block-drop-table",
+        tool: "*",
+        conditions: [{ field: "sql", op: "matches", value: "DROP\\s+TABLE", flags: "i" }],
+        verdict: "block",
+        reason: "DROP TABLE is irreversible \u2014 blocked by Postgres shield"
+      },
+      {
+        name: "shield:postgres:block-truncate",
+        tool: "*",
+        conditions: [{ field: "sql", op: "matches", value: "TRUNCATE\\s+TABLE", flags: "i" }],
+        verdict: "block",
+        reason: "TRUNCATE is irreversible \u2014 blocked by Postgres shield"
+      },
+      {
+        name: "shield:postgres:block-drop-column",
+        tool: "*",
+        conditions: [
+          { field: "sql", op: "matches", value: "ALTER\\s+TABLE.*DROP\\s+COLUMN", flags: "i" }
+        ],
+        verdict: "block",
+        reason: "DROP COLUMN is irreversible \u2014 blocked by Postgres shield"
+      },
+      {
+        name: "shield:postgres:review-grant-revoke",
+        tool: "*",
+        conditions: [{ field: "sql", op: "matches", value: "\\b(GRANT|REVOKE)\\b", flags: "i" }],
+        verdict: "review",
+        reason: "Permission changes require human approval (Postgres shield)"
+      }
+    ],
+    dangerousWords: ["dropdb", "pg_dropcluster"]
+  },
+  github: {
+    name: "github",
+    description: "Protects GitHub repositories from destructive AI operations",
+    aliases: ["git"],
+    smartRules: [
+      {
+        // Note: git branch -d/-D is already caught by the built-in review-git-destructive rule.
+        // This rule adds coverage for `git push --delete` which the built-in does not match.
+        name: "shield:github:review-delete-branch-remote",
+        tool: "bash",
+        conditions: [
+          {
+            field: "command",
+            op: "matches",
+            value: "git\\s+push\\s+.*--delete",
+            flags: "i"
+          }
+        ],
+        verdict: "review",
+        reason: "Remote branch deletion requires human approval (GitHub shield)"
+      },
+      {
+        name: "shield:github:block-delete-repo",
+        tool: "*",
+        conditions: [
+          { field: "command", op: "matches", value: "gh\\s+repo\\s+delete", flags: "i" }
+        ],
+        verdict: "block",
+        reason: "Repository deletion is irreversible \u2014 blocked by GitHub shield"
+      }
+    ],
+    dangerousWords: []
+  },
+  aws: {
+    name: "aws",
+    description: "Protects AWS infrastructure from destructive AI operations",
+    aliases: ["amazon"],
+    smartRules: [
+      {
+        name: "shield:aws:block-delete-s3-bucket",
+        tool: "*",
+        conditions: [
+          {
+            field: "command",
+            op: "matches",
+            value: "aws\\s+s3.*rb\\s|aws\\s+s3api\\s+delete-bucket",
+            flags: "i"
+          }
+        ],
+        verdict: "block",
+        reason: "S3 bucket deletion is irreversible \u2014 blocked by AWS shield"
+      },
+      {
+        name: "shield:aws:review-iam-changes",
+        tool: "*",
+        conditions: [
+          {
+            field: "command",
+            op: "matches",
+            value: "aws\\s+iam\\s+(create|delete|attach|detach|put|remove)",
+            flags: "i"
+          }
+        ],
+        verdict: "review",
+        reason: "IAM changes require human approval (AWS shield)"
+      },
+      {
+        name: "shield:aws:block-ec2-terminate",
+        tool: "*",
+        conditions: [
+          {
+            field: "command",
+            op: "matches",
+            value: "aws\\s+ec2\\s+terminate-instances",
+            flags: "i"
+          }
+        ],
+        verdict: "block",
+        reason: "EC2 instance termination is irreversible \u2014 blocked by AWS shield"
+      },
+      {
+        name: "shield:aws:review-rds-delete",
+        tool: "*",
+        conditions: [
+          { field: "command", op: "matches", value: "aws\\s+rds\\s+delete-", flags: "i" }
+        ],
+        verdict: "review",
+        reason: "RDS deletion requires human approval (AWS shield)"
+      }
+    ],
+    dangerousWords: []
+  },
+  filesystem: {
+    name: "filesystem",
+    description: "Protects the local filesystem from dangerous AI operations",
+    aliases: ["fs"],
+    smartRules: [
+      {
+        name: "shield:filesystem:review-chmod-777",
+        tool: "bash",
+        conditions: [
+          { field: "command", op: "matches", value: "chmod\\s+(777|a\\+rwx)", flags: "i" }
+        ],
+        verdict: "review",
+        reason: "chmod 777 requires human approval (filesystem shield)"
+      },
+      {
+        name: "shield:filesystem:review-write-etc",
+        tool: "bash",
+        conditions: [
+          {
+            field: "command",
+            // Narrow to write-indicative operations to avoid approval fatigue on reads.
+            // Matches: tee /etc/*, cp .../etc/*, mv .../etc/*, > /etc/*, install .../etc/*
+            op: "matches",
+            value: "(tee|\\bcp\\b|\\bmv\\b|install|>+)\\s+.*\\/etc\\/"
+          }
+        ],
+        verdict: "review",
+        reason: "Writing to /etc requires human approval (filesystem shield)"
+      }
+    ],
+    // dd removed: too common as a legitimate tool (disk imaging, file ops).
+    // mkfs removed: already in the built-in DANGEROUS_WORDS baseline.
+    // wipefs retained: rarely legitimate in an agent context and not in built-ins.
+    dangerousWords: ["wipefs"]
+  }
+};
+function resolveShieldName(input) {
+  const lower = input.toLowerCase();
+  if (SHIELDS[lower]) return lower;
+  for (const [name, def] of Object.entries(SHIELDS)) {
+    if (def.aliases.includes(lower)) return name;
+  }
+  return null;
+}
+function getShield(name) {
+  const resolved = resolveShieldName(name);
+  return resolved ? SHIELDS[resolved] : null;
+}
+function listShields() {
+  return Object.values(SHIELDS);
+}
+var SHIELDS_STATE_FILE = import_path3.default.join(import_os.default.homedir(), ".node9", "shields.json");
+function readActiveShields() {
+  try {
+    const raw = import_fs.default.readFileSync(SHIELDS_STATE_FILE, "utf-8");
+    if (!raw.trim()) return [];
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed.active)) {
+      return parsed.active.filter(
+        (e) => typeof e === "string" && e.length > 0 && e in SHIELDS
+      );
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      process.stderr.write(`[node9] Warning: could not read shields state: ${String(err)}
+`);
+    }
+  }
+  return [];
+}
+function writeActiveShields(active) {
+  import_fs.default.mkdirSync(import_path3.default.dirname(SHIELDS_STATE_FILE), { recursive: true });
+  const tmp = `${SHIELDS_STATE_FILE}.${import_crypto.default.randomBytes(6).toString("hex")}.tmp`;
+  import_fs.default.writeFileSync(tmp, JSON.stringify({ active }, null, 2), { mode: 384 });
+  import_fs.default.renameSync(tmp, SHIELDS_STATE_FILE);
+}
+
+// src/dlp.ts
+var DLP_PATTERNS = [
+  { name: "AWS Access Key ID", regex: /\bAKIA[0-9A-Z]{16}\b/, severity: "block" },
+  { name: "GitHub Token", regex: /\bgh[pous]_[A-Za-z0-9]{36}\b/, severity: "block" },
+  { name: "Slack Bot Token", regex: /\bxoxb-[0-9A-Za-z-]+\b/, severity: "block" },
+  { name: "OpenAI API Key", regex: /\bsk-[a-zA-Z0-9_-]{20,}\b/, severity: "block" },
+  { name: "Stripe Secret Key", regex: /\bsk_(?:live|test)_[0-9a-zA-Z]{24}\b/, severity: "block" },
+  {
+    name: "Private Key (PEM)",
+    regex: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/,
+    severity: "block"
+  },
+  { name: "Bearer Token", regex: /Bearer\s+[a-zA-Z0-9\-._~+/]+=*/i, severity: "review" }
+];
+function maskSecret(raw, pattern) {
+  const match = raw.match(pattern);
+  if (!match) return "****";
+  const secret = match[0];
+  if (secret.length < 8) return "****";
+  const prefix = secret.slice(0, 4);
+  const suffix = secret.slice(-4);
+  const stars = "*".repeat(Math.min(secret.length - 8, 12));
+  return `${prefix}${stars}${suffix}`;
+}
+var MAX_DEPTH = 5;
+var MAX_STRING_BYTES = 1e5;
+var MAX_JSON_PARSE_BYTES = 1e4;
+function scanArgs(args, depth = 0, fieldPath = "args") {
+  if (depth > MAX_DEPTH || args === null || args === void 0) return null;
+  if (Array.isArray(args)) {
+    for (let i = 0; i < args.length; i++) {
+      const match = scanArgs(args[i], depth + 1, `${fieldPath}[${i}]`);
+      if (match) return match;
+    }
+    return null;
+  }
+  if (typeof args === "object") {
+    for (const [key, value] of Object.entries(args)) {
+      const match = scanArgs(value, depth + 1, `${fieldPath}.${key}`);
+      if (match) return match;
+    }
+    return null;
+  }
+  if (typeof args === "string") {
+    const text = args.length > MAX_STRING_BYTES ? args.slice(0, MAX_STRING_BYTES) : args;
+    for (const pattern of DLP_PATTERNS) {
+      if (pattern.regex.test(text)) {
+        return {
+          patternName: pattern.name,
+          fieldPath,
+          redactedSample: maskSecret(text, pattern.regex),
+          severity: pattern.severity
+        };
+      }
+    }
+    if (text.length < MAX_JSON_PARSE_BYTES) {
+      const trimmed = text.trim();
+      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+          const parsed = JSON.parse(text);
+          const inner = scanArgs(parsed, depth + 1, fieldPath);
+          if (inner) return inner;
+        } catch {
+        }
+      }
+    }
+  }
+  return null;
+}
+
 // src/core.ts
-var PAUSED_FILE = import_path3.default.join(import_os.default.homedir(), ".node9", "PAUSED");
-var TRUST_FILE = import_path3.default.join(import_os.default.homedir(), ".node9", "trust.json");
-var LOCAL_AUDIT_LOG = import_path3.default.join(import_os.default.homedir(), ".node9", "audit.log");
-var HOOK_DEBUG_LOG = import_path3.default.join(import_os.default.homedir(), ".node9", "hook-debug.log");
+var PAUSED_FILE = import_path4.default.join(import_os2.default.homedir(), ".node9", "PAUSED");
+var TRUST_FILE = import_path4.default.join(import_os2.default.homedir(), ".node9", "trust.json");
+var LOCAL_AUDIT_LOG = import_path4.default.join(import_os2.default.homedir(), ".node9", "audit.log");
+var HOOK_DEBUG_LOG = import_path4.default.join(import_os2.default.homedir(), ".node9", "hook-debug.log");
 function checkPause() {
   try {
-    if (!import_fs.default.existsSync(PAUSED_FILE)) return { paused: false };
-    const state = JSON.parse(import_fs.default.readFileSync(PAUSED_FILE, "utf-8"));
+    if (!import_fs2.default.existsSync(PAUSED_FILE)) return { paused: false };
+    const state = JSON.parse(import_fs2.default.readFileSync(PAUSED_FILE, "utf-8"));
     if (state.expiry > 0 && Date.now() >= state.expiry) {
       try {
-        import_fs.default.unlinkSync(PAUSED_FILE);
+        import_fs2.default.unlinkSync(PAUSED_FILE);
       } catch {
       }
       return { paused: false };
@@ -480,11 +762,11 @@ function checkPause() {
   }
 }
 function atomicWriteSync(filePath, data, options) {
-  const dir = import_path3.default.dirname(filePath);
-  if (!import_fs.default.existsSync(dir)) import_fs.default.mkdirSync(dir, { recursive: true });
-  const tmpPath = `${filePath}.${import_os.default.hostname()}.${process.pid}.tmp`;
-  import_fs.default.writeFileSync(tmpPath, data, options);
-  import_fs.default.renameSync(tmpPath, filePath);
+  const dir = import_path4.default.dirname(filePath);
+  if (!import_fs2.default.existsSync(dir)) import_fs2.default.mkdirSync(dir, { recursive: true });
+  const tmpPath = `${filePath}.${import_os2.default.hostname()}.${process.pid}.tmp`;
+  import_fs2.default.writeFileSync(tmpPath, data, options);
+  import_fs2.default.renameSync(tmpPath, filePath);
 }
 function pauseNode9(durationMs, durationStr) {
   const state = { expiry: Date.now() + durationMs, duration: durationStr };
@@ -492,18 +774,18 @@ function pauseNode9(durationMs, durationStr) {
 }
 function resumeNode9() {
   try {
-    if (import_fs.default.existsSync(PAUSED_FILE)) import_fs.default.unlinkSync(PAUSED_FILE);
+    if (import_fs2.default.existsSync(PAUSED_FILE)) import_fs2.default.unlinkSync(PAUSED_FILE);
   } catch {
   }
 }
 function getActiveTrustSession(toolName) {
   try {
-    if (!import_fs.default.existsSync(TRUST_FILE)) return false;
-    const trust = JSON.parse(import_fs.default.readFileSync(TRUST_FILE, "utf-8"));
+    if (!import_fs2.default.existsSync(TRUST_FILE)) return false;
+    const trust = JSON.parse(import_fs2.default.readFileSync(TRUST_FILE, "utf-8"));
     const now = Date.now();
     const active = trust.entries.filter((e) => e.expiry > now);
     if (active.length !== trust.entries.length) {
-      import_fs.default.writeFileSync(TRUST_FILE, JSON.stringify({ entries: active }, null, 2));
+      import_fs2.default.writeFileSync(TRUST_FILE, JSON.stringify({ entries: active }, null, 2));
     }
     return active.some((e) => e.tool === toolName || matchesPattern(toolName, e.tool));
   } catch {
@@ -514,8 +796,8 @@ function writeTrustSession(toolName, durationMs) {
   try {
     let trust = { entries: [] };
     try {
-      if (import_fs.default.existsSync(TRUST_FILE)) {
-        trust = JSON.parse(import_fs.default.readFileSync(TRUST_FILE, "utf-8"));
+      if (import_fs2.default.existsSync(TRUST_FILE)) {
+        trust = JSON.parse(import_fs2.default.readFileSync(TRUST_FILE, "utf-8"));
       }
     } catch {
     }
@@ -531,9 +813,9 @@ function writeTrustSession(toolName, durationMs) {
 }
 function appendToLog(logPath, entry) {
   try {
-    const dir = import_path3.default.dirname(logPath);
-    if (!import_fs.default.existsSync(dir)) import_fs.default.mkdirSync(dir, { recursive: true });
-    import_fs.default.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+    const dir = import_path4.default.dirname(logPath);
+    if (!import_fs2.default.existsSync(dir)) import_fs2.default.mkdirSync(dir, { recursive: true });
+    import_fs2.default.appendFileSync(logPath, JSON.stringify(entry) + "\n");
   } catch {
   }
 }
@@ -545,7 +827,7 @@ function appendHookDebug(toolName, args, meta) {
     args: safeArgs,
     agent: meta?.agent,
     mcpServer: meta?.mcpServer,
-    hostname: import_os.default.hostname(),
+    hostname: import_os2.default.hostname(),
     cwd: process.cwd()
   });
 }
@@ -559,7 +841,7 @@ function appendLocalAudit(toolName, args, decision, checkedBy, meta) {
     checkedBy,
     agent: meta?.agent,
     mcpServer: meta?.mcpServer,
-    hostname: import_os.default.hostname()
+    hostname: import_os2.default.hostname()
   });
 }
 function tokenize(toolName) {
@@ -575,9 +857,9 @@ function matchesPattern(text, patterns) {
   const withoutDotSlash = text.replace(/^\.\//, "");
   return isMatch(withoutDotSlash) || isMatch(`./${withoutDotSlash}`);
 }
-function getNestedValue(obj, path8) {
+function getNestedValue(obj, path9) {
   if (!obj || typeof obj !== "object") return null;
-  return path8.split(".").reduce((prev, curr) => prev?.[curr], obj);
+  return path9.split(".").reduce((prev, curr) => prev?.[curr], obj);
 }
 function shouldSnapshot(toolName, args, config) {
   if (!config.settings.enableUndo) return false;
@@ -622,6 +904,10 @@ function evaluateSmartConditions(args, rule) {
           return true;
         }
       }
+      case "matchesGlob":
+        return val !== null && cond.value ? import_picomatch.default.isMatch(val, cond.value) : false;
+      case "notMatchesGlob":
+        return val !== null && cond.value ? !import_picomatch.default.isMatch(val, cond.value) : true;
       default:
         return false;
     }
@@ -785,25 +1071,27 @@ var DEFAULT_CONFIG = {
       onlyPaths: [],
       ignorePaths: ["**/node_modules/**", "dist/**", "build/**", ".next/**", "**/*.log"]
     },
-    rules: [
-      // Only use the legacy rules format for simple path-based rm control.
-      // All other command-level enforcement lives in smartRules below.
-      {
-        action: "rm",
-        allowPaths: [
-          "**/node_modules/**",
-          "dist/**",
-          "build/**",
-          ".next/**",
-          "coverage/**",
-          ".cache/**",
-          "tmp/**",
-          "temp/**",
-          ".DS_Store"
-        ]
-      }
-    ],
     smartRules: [
+      // ── rm safety (critical — always evaluated first) ──────────────────────
+      {
+        name: "block-rm-rf-home",
+        tool: "bash",
+        conditionMode: "all",
+        conditions: [
+          {
+            field: "command",
+            op: "matches",
+            value: "rm\\b.*(-[rRfF]*[rR][rRfF]*|--recursive)"
+          },
+          {
+            field: "command",
+            op: "matches",
+            value: "(~|\\/root(\\/|$)|\\$HOME|\\/home\\/)"
+          }
+        ],
+        verdict: "block",
+        reason: "Recursive delete of home directory is irreversible"
+      },
       // ── SQL safety ────────────────────────────────────────────────────────
       {
         name: "no-delete-without-where",
@@ -894,19 +1182,45 @@ var DEFAULT_CONFIG = {
         verdict: "block",
         reason: "Piping remote script into a shell is a supply-chain attack vector"
       }
-    ]
+    ],
+    dlp: { enabled: true, scanIgnoredTools: true }
   },
   environments: {}
 };
+var ADVISORY_SMART_RULES = [
+  {
+    name: "allow-rm-safe-paths",
+    tool: "*",
+    conditionMode: "all",
+    conditions: [
+      { field: "command", op: "matches", value: "(^|&&|\\|\\||;)\\s*rm\\b" },
+      {
+        field: "command",
+        op: "matches",
+        // Matches known-safe build artifact paths in the command.
+        value: "(node_modules|\\bdist\\b|\\.next|\\bcoverage\\b|\\.cache|\\btmp\\b|\\btemp\\b|\\.DS_Store)(\\/|\\s|$)"
+      }
+    ],
+    verdict: "allow",
+    reason: "Deleting a known-safe build artifact path"
+  },
+  {
+    name: "review-rm",
+    tool: "*",
+    conditions: [{ field: "command", op: "matches", value: "(^|&&|\\|\\||;)\\s*rm\\b" }],
+    verdict: "review",
+    reason: "rm can permanently delete files \u2014 confirm the target path"
+  }
+];
 var cachedConfig = null;
 function _resetConfigCache() {
   cachedConfig = null;
 }
 function getGlobalSettings() {
   try {
-    const globalConfigPath = import_path3.default.join(import_os.default.homedir(), ".node9", "config.json");
-    if (import_fs.default.existsSync(globalConfigPath)) {
-      const parsed = JSON.parse(import_fs.default.readFileSync(globalConfigPath, "utf-8"));
+    const globalConfigPath = import_path4.default.join(import_os2.default.homedir(), ".node9", "config.json");
+    if (import_fs2.default.existsSync(globalConfigPath)) {
+      const parsed = JSON.parse(import_fs2.default.readFileSync(globalConfigPath, "utf-8"));
       const settings = parsed.settings || {};
       return {
         mode: settings.mode || "standard",
@@ -928,9 +1242,9 @@ function getGlobalSettings() {
 }
 function getInternalToken() {
   try {
-    const pidFile = import_path3.default.join(import_os.default.homedir(), ".node9", "daemon.pid");
-    if (!import_fs.default.existsSync(pidFile)) return null;
-    const data = JSON.parse(import_fs.default.readFileSync(pidFile, "utf-8"));
+    const pidFile = import_path4.default.join(import_os2.default.homedir(), ".node9", "daemon.pid");
+    if (!import_fs2.default.existsSync(pidFile)) return null;
+    const data = JSON.parse(import_fs2.default.readFileSync(pidFile, "utf-8"));
     process.kill(data.pid, 0);
     return data.internalToken ?? null;
   } catch {
@@ -945,7 +1259,8 @@ async function evaluatePolicy(toolName, args, agent) {
       (rule) => matchesPattern(toolName, rule.tool) && evaluateSmartConditions(args, rule)
     );
     if (matchedRule) {
-      if (matchedRule.verdict === "allow") return { decision: "allow" };
+      if (matchedRule.verdict === "allow")
+        return { decision: "allow", ruleName: matchedRule.name ?? matchedRule.tool };
       return {
         decision: matchedRule.verdict,
         blockedByLabel: `Smart Rule: ${matchedRule.name ?? matchedRule.tool}`,
@@ -956,13 +1271,11 @@ async function evaluatePolicy(toolName, args, agent) {
     }
   }
   let allTokens = [];
-  let actionTokens = [];
   let pathTokens = [];
   const shellCommand = extractShellCommand(toolName, args, config.policy.toolInspection);
   if (shellCommand) {
     const analyzed = await analyzeShellCommand(shellCommand);
     allTokens = analyzed.allTokens;
-    actionTokens = analyzed.actions;
     pathTokens = analyzed.paths;
     const INLINE_EXEC_PATTERN = /^(python3?|bash|sh|zsh|perl|ruby|node|php|lua)\s+(-c|-e|-eval)\s/i;
     if (INLINE_EXEC_PATTERN.test(shellCommand.trim())) {
@@ -970,11 +1283,9 @@ async function evaluatePolicy(toolName, args, agent) {
     }
     if (isSqlTool(toolName, config.policy.toolInspection)) {
       allTokens = allTokens.filter((t) => !SQL_DML_KEYWORDS.has(t.toLowerCase()));
-      actionTokens = actionTokens.filter((t) => !SQL_DML_KEYWORDS.has(t.toLowerCase()));
     }
   } else {
     allTokens = tokenize(toolName);
-    actionTokens = [toolName];
     if (args && typeof args === "object") {
       const flattenedArgs = JSON.stringify(args).toLowerCase();
       const extraTokens = flattenedArgs.split(/[^a-zA-Z0-9]+/).filter((t) => t.length > 1);
@@ -997,29 +1308,6 @@ async function evaluatePolicy(toolName, args, agent) {
     const allInSandbox = pathTokens.every((p) => matchesPattern(p, config.policy.sandboxPaths));
     if (allInSandbox) return { decision: "allow" };
   }
-  for (const action of actionTokens) {
-    const rule = config.policy.rules.find(
-      (r) => r.action === action || matchesPattern(action, r.action)
-    );
-    if (rule) {
-      if (pathTokens.length > 0) {
-        const anyBlocked = pathTokens.some((p) => matchesPattern(p, rule.blockPaths || []));
-        if (anyBlocked)
-          return {
-            decision: "review",
-            blockedByLabel: `Project/Global Config \u2014 rule "${rule.action}" (path blocked)`,
-            tier: 5
-          };
-        const allAllowed = pathTokens.every((p) => matchesPattern(p, rule.allowPaths || []));
-        if (allAllowed) return { decision: "allow" };
-      }
-      return {
-        decision: "review",
-        blockedByLabel: `Project/Global Config \u2014 rule "${rule.action}" (default block)`,
-        tier: 5
-      };
-    }
-  }
   let matchedDangerousWord;
   const isDangerous = allTokens.some(
     (token) => config.policy.dangerousWords.some((word) => {
@@ -1071,9 +1359,9 @@ async function evaluatePolicy(toolName, args, agent) {
 }
 async function explainPolicy(toolName, args) {
   const steps = [];
-  const globalPath = import_path3.default.join(import_os.default.homedir(), ".node9", "config.json");
-  const projectPath = import_path3.default.join(process.cwd(), "node9.config.json");
-  const credsPath = import_path3.default.join(import_os.default.homedir(), ".node9", "credentials.json");
+  const globalPath = import_path4.default.join(import_os2.default.homedir(), ".node9", "config.json");
+  const projectPath = import_path4.default.join(process.cwd(), "node9.config.json");
+  const credsPath = import_path4.default.join(import_os2.default.homedir(), ".node9", "credentials.json");
   const waterfall = [
     {
       tier: 1,
@@ -1084,19 +1372,19 @@ async function explainPolicy(toolName, args) {
     {
       tier: 2,
       label: "Cloud policy",
-      status: import_fs.default.existsSync(credsPath) ? "active" : "missing",
-      note: import_fs.default.existsSync(credsPath) ? "credentials found (not evaluated in explain mode)" : "not connected \u2014 run: node9 login"
+      status: import_fs2.default.existsSync(credsPath) ? "active" : "missing",
+      note: import_fs2.default.existsSync(credsPath) ? "credentials found (not evaluated in explain mode)" : "not connected \u2014 run: node9 login"
     },
     {
       tier: 3,
       label: "Project config",
-      status: import_fs.default.existsSync(projectPath) ? "active" : "missing",
+      status: import_fs2.default.existsSync(projectPath) ? "active" : "missing",
       path: projectPath
     },
     {
       tier: 4,
       label: "Global config",
-      status: import_fs.default.existsSync(globalPath) ? "active" : "missing",
+      status: import_fs2.default.existsSync(globalPath) ? "active" : "missing",
       path: globalPath
     },
     {
@@ -1107,7 +1395,28 @@ async function explainPolicy(toolName, args) {
     }
   ];
   const config = getConfig();
-  if (matchesPattern(toolName, config.policy.ignoredTools)) {
+  const wouldBeIgnored = matchesPattern(toolName, config.policy.ignoredTools);
+  if (config.policy.dlp.enabled && (!wouldBeIgnored || config.policy.dlp.scanIgnoredTools)) {
+    const dlpMatch = args !== void 0 ? scanArgs(args) : null;
+    if (dlpMatch) {
+      steps.push({
+        name: "DLP Content Scanner",
+        outcome: dlpMatch.severity === "block" ? "block" : "review",
+        detail: `\u{1F6A8} ${dlpMatch.patternName} detected in ${dlpMatch.fieldPath} \u2014 sample: ${dlpMatch.redactedSample}`,
+        isFinal: dlpMatch.severity === "block"
+      });
+      if (dlpMatch.severity === "block") {
+        return { tool: toolName, args, waterfall, steps, decision: "block" };
+      }
+    } else {
+      steps.push({
+        name: "DLP Content Scanner",
+        outcome: "checked",
+        detail: "No sensitive credentials detected in args"
+      });
+    }
+  }
+  if (wouldBeIgnored) {
     steps.push({
       name: "Ignored tools",
       outcome: "allow",
@@ -1160,13 +1469,11 @@ async function explainPolicy(toolName, args) {
     steps.push({ name: "Smart rules", outcome: "skip", detail: "No smart rules configured" });
   }
   let allTokens = [];
-  let actionTokens = [];
   let pathTokens = [];
   const shellCommand = extractShellCommand(toolName, args, config.policy.toolInspection);
   if (shellCommand) {
     const analyzed = await analyzeShellCommand(shellCommand);
     allTokens = analyzed.allTokens;
-    actionTokens = analyzed.actions;
     pathTokens = analyzed.paths;
     const patterns = Object.keys(config.policy.toolInspection);
     const matchingPattern = patterns.find((p) => matchesPattern(toolName, p));
@@ -1200,7 +1507,6 @@ async function explainPolicy(toolName, args) {
     });
     if (isSqlTool(toolName, config.policy.toolInspection)) {
       allTokens = allTokens.filter((t) => !SQL_DML_KEYWORDS.has(t.toLowerCase()));
-      actionTokens = actionTokens.filter((t) => !SQL_DML_KEYWORDS.has(t.toLowerCase()));
       steps.push({
         name: "SQL token stripping",
         outcome: "checked",
@@ -1209,7 +1515,6 @@ async function explainPolicy(toolName, args) {
     }
   } else {
     allTokens = tokenize(toolName);
-    actionTokens = [toolName];
     let detail = `No toolInspection match for "${toolName}" \u2014 tokens: [${allTokens.join(", ")}]`;
     if (args && typeof args === "object") {
       const flattenedArgs = JSON.stringify(args).toLowerCase();
@@ -1250,65 +1555,6 @@ async function explainPolicy(toolName, args) {
       detail: pathTokens.length === 0 ? "No path tokens found in input" : "No sandbox paths configured"
     });
   }
-  let ruleMatched = false;
-  for (const action of actionTokens) {
-    const rule = config.policy.rules.find(
-      (r) => r.action === action || matchesPattern(action, r.action)
-    );
-    if (rule) {
-      ruleMatched = true;
-      if (pathTokens.length > 0) {
-        const anyBlocked = pathTokens.some((p) => matchesPattern(p, rule.blockPaths || []));
-        if (anyBlocked) {
-          steps.push({
-            name: "Policy rules",
-            outcome: "review",
-            detail: `Rule "${rule.action}" matched + path is in blockPaths`,
-            isFinal: true
-          });
-          return {
-            tool: toolName,
-            args,
-            waterfall,
-            steps,
-            decision: "review",
-            blockedByLabel: `Project/Global Config \u2014 rule "${rule.action}" (path blocked)`
-          };
-        }
-        const allAllowed = pathTokens.every((p) => matchesPattern(p, rule.allowPaths || []));
-        if (allAllowed) {
-          steps.push({
-            name: "Policy rules",
-            outcome: "allow",
-            detail: `Rule "${rule.action}" matched + all paths are in allowPaths`,
-            isFinal: true
-          });
-          return { tool: toolName, args, waterfall, steps, decision: "allow" };
-        }
-      }
-      steps.push({
-        name: "Policy rules",
-        outcome: "review",
-        detail: `Rule "${rule.action}" matched \u2014 default block (no path exception)`,
-        isFinal: true
-      });
-      return {
-        tool: toolName,
-        args,
-        waterfall,
-        steps,
-        decision: "review",
-        blockedByLabel: `Project/Global Config \u2014 rule "${rule.action}" (default block)`
-      };
-    }
-  }
-  if (!ruleMatched) {
-    steps.push({
-      name: "Policy rules",
-      outcome: "skip",
-      detail: config.policy.rules.length === 0 ? "No rules configured" : `No rule matched [${actionTokens.join(", ")}]`
-    });
-  }
   let matchedDangerousWord;
   const isDangerous = uniqueTokens.some(
     (token) => config.policy.dangerousWords.some((word) => {
@@ -1377,9 +1623,9 @@ var DAEMON_PORT = 7391;
 var DAEMON_HOST = "127.0.0.1";
 function isDaemonRunning() {
   try {
-    const pidFile = import_path3.default.join(import_os.default.homedir(), ".node9", "daemon.pid");
-    if (!import_fs.default.existsSync(pidFile)) return false;
-    const { pid, port } = JSON.parse(import_fs.default.readFileSync(pidFile, "utf-8"));
+    const pidFile = import_path4.default.join(import_os2.default.homedir(), ".node9", "daemon.pid");
+    if (!import_fs2.default.existsSync(pidFile)) return false;
+    const { pid, port } = JSON.parse(import_fs2.default.readFileSync(pidFile, "utf-8"));
     if (port !== DAEMON_PORT) return false;
     process.kill(pid, 0);
     return true;
@@ -1389,9 +1635,9 @@ function isDaemonRunning() {
 }
 function getPersistentDecision(toolName) {
   try {
-    const file = import_path3.default.join(import_os.default.homedir(), ".node9", "decisions.json");
-    if (!import_fs.default.existsSync(file)) return null;
-    const decisions = JSON.parse(import_fs.default.readFileSync(file, "utf-8"));
+    const file = import_path4.default.join(import_os2.default.homedir(), ".node9", "decisions.json");
+    if (!import_fs2.default.existsSync(file)) return null;
+    const decisions = JSON.parse(import_fs2.default.readFileSync(file, "utf-8"));
     const d = decisions[toolName];
     if (d === "allow" || d === "deny") return d;
   } catch {
@@ -1490,6 +1736,22 @@ async function authorizeHeadless(toolName, args, allowTerminalFallback = false,
   let policyMatchedField;
   let policyMatchedWord;
   let riskMetadata;
+  if (config.policy.dlp.enabled && (!isIgnoredTool(toolName) || config.policy.dlp.scanIgnoredTools)) {
+    const dlpMatch = scanArgs(args);
+    if (dlpMatch) {
+      const dlpReason = `\u{1F6A8} DATA LOSS PREVENTION: ${dlpMatch.patternName} detected in field "${dlpMatch.fieldPath}" (${dlpMatch.redactedSample})`;
+      if (dlpMatch.severity === "block") {
+        if (!isManual) appendLocalAudit(toolName, args, "deny", "dlp-block", meta);
+        return {
+          approved: false,
+          reason: dlpReason,
+          blockedBy: "local-config",
+          blockedByLabel: "\u{1F6A8} Node9 DLP (Secret Detected)"
+        };
+      }
+      explainableLabel = "\u{1F6A8} Node9 DLP (Credential Review)";
+    }
+  }
   if (config.settings.mode === "audit") {
     if (!isIgnoredTool(toolName)) {
       const policyResult = await evaluatePolicy(toolName, args, meta?.agent);
@@ -1729,7 +1991,14 @@ async function authorizeHeadless(toolName, args, allowTerminalFallback = false,
     racePromises.push(
       (async () => {
         try {
-          console.log(import_chalk2.default.bgRed.white.bold(` \u{1F6D1} NODE9 INTERCEPTOR `));
+          if (explainableLabel.includes("DLP")) {
+            console.log(import_chalk2.default.bgRed.white.bold(` \u{1F6A8} NODE9 DLP ALERT \u2014 CREDENTIAL DETECTED `));
+            console.log(
+              import_chalk2.default.red.bold(`   A sensitive secret was detected in the tool arguments!`)
+            );
+          } else {
+            console.log(import_chalk2.default.bgRed.white.bold(` \u{1F6D1} NODE9 INTERCEPTOR `));
+          }
           console.log(`${import_chalk2.default.bold("Action:")} ${import_chalk2.default.red(toolName)}`);
           console.log(`${import_chalk2.default.bold("Flagged By:")} ${import_chalk2.default.yellow(explainableLabel)}`);
           if (isRemoteLocked) {
@@ -1834,8 +2103,8 @@ REASON: Action blocked because no approval channels are available. (Native/Brows
 }
 function getConfig() {
   if (cachedConfig) return cachedConfig;
-  const globalPath = import_path3.default.join(import_os.default.homedir(), ".node9", "config.json");
-  const projectPath = import_path3.default.join(process.cwd(), "node9.config.json");
+  const globalPath = import_path4.default.join(import_os2.default.homedir(), ".node9", "config.json");
+  const projectPath = import_path4.default.join(process.cwd(), "node9.config.json");
   const globalConfig = tryLoadConfig(globalPath);
   const projectConfig = tryLoadConfig(projectPath);
   const mergedSettings = {
@@ -1847,13 +2116,13 @@ function getConfig() {
     dangerousWords: [...DEFAULT_CONFIG.policy.dangerousWords],
     ignoredTools: [...DEFAULT_CONFIG.policy.ignoredTools],
     toolInspection: { ...DEFAULT_CONFIG.policy.toolInspection },
-    rules: [...DEFAULT_CONFIG.policy.rules],
     smartRules: [...DEFAULT_CONFIG.policy.smartRules],
     snapshot: {
       tools: [...DEFAULT_CONFIG.policy.snapshot.tools],
       onlyPaths: [...DEFAULT_CONFIG.policy.snapshot.onlyPaths],
       ignorePaths: [...DEFAULT_CONFIG.policy.snapshot.ignorePaths]
-    }
+    },
+    dlp: { ...DEFAULT_CONFIG.policy.dlp }
   };
   const mergedEnvironments = { ...DEFAULT_CONFIG.environments };
   const applyLayer = (source) => {
@@ -1873,7 +2142,6 @@ function getConfig() {
     if (p.dangerousWords) mergedPolicy.dangerousWords = [...p.dangerousWords];
     if (p.toolInspection)
       mergedPolicy.toolInspection = { ...mergedPolicy.toolInspection, ...p.toolInspection };
-    if (p.rules) mergedPolicy.rules.push(...p.rules);
     if (p.smartRules) mergedPolicy.smartRules.push(...p.smartRules);
     if (p.snapshot) {
       const s2 = p.snapshot;
@@ -1881,6 +2149,11 @@ function getConfig() {
       if (s2.onlyPaths) mergedPolicy.snapshot.onlyPaths.push(...s2.onlyPaths);
       if (s2.ignorePaths) mergedPolicy.snapshot.ignorePaths.push(...s2.ignorePaths);
     }
+    if (p.dlp) {
+      const d = p.dlp;
+      if (d.enabled !== void 0) mergedPolicy.dlp.enabled = d.enabled;
+      if (d.scanIgnoredTools !== void 0) mergedPolicy.dlp.scanIgnoredTools = d.scanIgnoredTools;
+    }
     const envs = source.environments || {};
     for (const [envName, envConfig] of Object.entries(envs)) {
       if (envConfig && typeof envConfig === "object") {
@@ -1895,6 +2168,19 @@ function getConfig() {
   };
   applyLayer(globalConfig);
   applyLayer(projectConfig);
+  for (const shieldName of readActiveShields()) {
+    const shield = getShield(shieldName);
+    if (!shield) continue;
+    const existingRuleNames = new Set(mergedPolicy.smartRules.map((r) => r.name));
+    for (const rule of shield.smartRules) {
+      if (!existingRuleNames.has(rule.name)) mergedPolicy.smartRules.push(rule);
+    }
+    for (const word of shield.dangerousWords) mergedPolicy.dangerousWords.push(word);
+  }
+  const existingAdvisoryNames = new Set(mergedPolicy.smartRules.map((r) => r.name));
+  for (const rule of ADVISORY_SMART_RULES) {
+    if (!existingAdvisoryNames.has(rule.name)) mergedPolicy.smartRules.push(rule);
+  }
   if (process.env.NODE9_MODE) mergedSettings.mode = process.env.NODE9_MODE;
   mergedPolicy.sandboxPaths = [...new Set(mergedPolicy.sandboxPaths)];
   mergedPolicy.dangerousWords = [...new Set(mergedPolicy.dangerousWords)];
@@ -1910,10 +2196,10 @@ function getConfig() {
   return cachedConfig;
 }
 function tryLoadConfig(filePath) {
-  if (!import_fs.default.existsSync(filePath)) return null;
+  if (!import_fs2.default.existsSync(filePath)) return null;
   let raw;
   try {
-    raw = JSON.parse(import_fs.default.readFileSync(filePath, "utf-8"));
+    raw = JSON.parse(import_fs2.default.readFileSync(filePath, "utf-8"));
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     process.stderr.write(
@@ -1975,9 +2261,9 @@ function getCredentials() {
     };
   }
   try {
-    const credPath = import_path3.default.join(import_os.default.homedir(), ".node9", "credentials.json");
-    if (import_fs.default.existsSync(credPath)) {
-      const creds = JSON.parse(import_fs.default.readFileSync(credPath, "utf-8"));
+    const credPath = import_path4.default.join(import_os2.default.homedir(), ".node9", "credentials.json");
+    if (import_fs2.default.existsSync(credPath)) {
+      const creds = JSON.parse(import_fs2.default.readFileSync(credPath, "utf-8"));
       const profileName = process.env.NODE9_PROFILE || "default";
       const profile = creds[profileName];
       if (profile?.apiKey) {
@@ -2008,9 +2294,9 @@ function auditLocalAllow(toolName, args, checkedBy, creds, meta) {
       context: {
         agent: meta?.agent,
         mcpServer: meta?.mcpServer,
-        hostname: import_os.default.hostname(),
+        hostname: import_os2.default.hostname(),
         cwd: process.cwd(),
-        platform: import_os.default.platform()
+        platform: import_os2.default.platform()
       }
     }),
     signal: AbortSignal.timeout(5e3)
@@ -2031,9 +2317,9 @@ async function initNode9SaaS(toolName, args, creds, meta, riskMetadata) {
         context: {
           agent: meta?.agent,
           mcpServer: meta?.mcpServer,
-          hostname: import_os.default.hostname(),
+          hostname: import_os2.default.hostname(),
           cwd: process.cwd(),
-          platform: import_os.default.platform()
+          platform: import_os2.default.platform()
         },
         ...riskMetadata && { riskMetadata }
       }),
@@ -2092,9 +2378,9 @@ async function resolveNode9SaaS(requestId, creds, approved) {
 }
 
 // src/setup.ts
-var import_fs2 = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
-var import_os2 = __toESM(require("os"));
+var import_fs3 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+var import_os3 = __toESM(require("os"));
 var import_chalk3 = __toESM(require("chalk"));
 var import_prompts2 = require("@inquirer/prompts");
 function printDaemonTip() {
@@ -2110,22 +2396,22 @@ function fullPathCommand(subcommand) {
 }
 function readJson(filePath) {
   try {
-    if (import_fs2.default.existsSync(filePath)) {
-      return JSON.parse(import_fs2.default.readFileSync(filePath, "utf-8"));
+    if (import_fs3.default.existsSync(filePath)) {
+      return JSON.parse(import_fs3.default.readFileSync(filePath, "utf-8"));
     }
   } catch {
   }
   return null;
 }
 function writeJson(filePath, data) {
-  const dir = import_path4.default.dirname(filePath);
-  if (!import_fs2.default.existsSync(dir)) import_fs2.default.mkdirSync(dir, { recursive: true });
-  import_fs2.default.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  const dir = import_path5.default.dirname(filePath);
+  if (!import_fs3.default.existsSync(dir)) import_fs3.default.mkdirSync(dir, { recursive: true });
+  import_fs3.default.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 }
 async function setupClaude() {
-  const homeDir2 = import_os2.default.homedir();
-  const mcpPath = import_path4.default.join(homeDir2, ".claude.json");
-  const hooksPath = import_path4.default.join(homeDir2, ".claude", "settings.json");
+  const homeDir2 = import_os3.default.homedir();
+  const mcpPath = import_path5.default.join(homeDir2, ".claude.json");
+  const hooksPath = import_path5.default.join(homeDir2, ".claude", "settings.json");
   const claudeConfig = readJson(mcpPath) ?? {};
   const settings = readJson(hooksPath) ?? {};
   const servers = claudeConfig.mcpServers ?? {};
@@ -2199,8 +2485,8 @@ async function setupClaude() {
   }
 }
 async function setupGemini() {
-  const homeDir2 = import_os2.default.homedir();
-  const settingsPath = import_path4.default.join(homeDir2, ".gemini", "settings.json");
+  const homeDir2 = import_os3.default.homedir();
+  const settingsPath = import_path5.default.join(homeDir2, ".gemini", "settings.json");
   const settings = readJson(settingsPath) ?? {};
   const servers = settings.mcpServers ?? {};
   let anythingChanged = false;
@@ -2282,36 +2568,11 @@ async function setupGemini() {
   }
 }
 async function setupCursor() {
-  const homeDir2 = import_os2.default.homedir();
-  const mcpPath = import_path4.default.join(homeDir2, ".cursor", "mcp.json");
-  const hooksPath = import_path4.default.join(homeDir2, ".cursor", "hooks.json");
+  const homeDir2 = import_os3.default.homedir();
+  const mcpPath = import_path5.default.join(homeDir2, ".cursor", "mcp.json");
   const mcpConfig = readJson(mcpPath) ?? {};
-  const hooksFile = readJson(hooksPath) ?? { version: 1 };
   const servers = mcpConfig.mcpServers ?? {};
   let anythingChanged = false;
-  if (!hooksFile.hooks) hooksFile.hooks = {};
-  const hasPreHook = hooksFile.hooks.preToolUse?.some(
-    (h) => h.command === "node9" && h.args?.includes("check") || h.command?.includes("cli.js")
-  );
-  if (!hasPreHook) {
-    if (!hooksFile.hooks.preToolUse) hooksFile.hooks.preToolUse = [];
-    hooksFile.hooks.preToolUse.push({ command: fullPathCommand("check") });
-    console.log(import_chalk3.default.green("  \u2705 preToolUse hook added \u2192 node9 check"));
-    anythingChanged = true;
-  }
-  const hasPostHook = hooksFile.hooks.postToolUse?.some(
-    (h) => h.command === "node9" && h.args?.includes("log") || h.command?.includes("cli.js")
-  );
-  if (!hasPostHook) {
-    if (!hooksFile.hooks.postToolUse) hooksFile.hooks.postToolUse = [];
-    hooksFile.hooks.postToolUse.push({ command: fullPathCommand("log") });
-    console.log(import_chalk3.default.green("  \u2705 postToolUse hook added \u2192 node9 log"));
-    anythingChanged = true;
-  }
-  if (anythingChanged) {
-    writeJson(hooksPath, hooksFile);
-    console.log("");
-  }
   const serversToWrap = [];
   for (const [name, server] of Object.entries(servers)) {
     if (!server.command || server.command === "node9") continue;
@@ -2340,13 +2601,23 @@ async function setupCursor() {
     }
     console.log("");
   }
+  console.log(
+    import_chalk3.default.yellow(
+      "  \u26A0\uFE0F  Note: Cursor does not yet support native pre-execution hooks.\n     MCP proxy wrapping is the only supported protection mode for Cursor."
+    )
+  );
+  console.log("");
   if (!anythingChanged && serversToWrap.length === 0) {
-    console.log(import_chalk3.default.blue("\u2139\uFE0F  Node9 is already fully configured for Cursor."));
+    console.log(
+      import_chalk3.default.blue(
+        "\u2139\uFE0F  No MCP servers found to wrap. Add MCP servers to ~/.cursor/mcp.json and re-run."
+      )
+    );
     printDaemonTip();
     return;
   }
   if (anythingChanged) {
-    console.log(import_chalk3.default.green.bold("\u{1F6E1}\uFE0F  Node9 is now protecting Cursor!"));
+    console.log(import_chalk3.default.green.bold("\u{1F6E1}\uFE0F  Node9 is now protecting Cursor via MCP proxy!"));
     console.log(import_chalk3.default.gray("    Restart Cursor for changes to take effect."));
     printDaemonTip();
   }
@@ -3396,34 +3667,34 @@ var UI_HTML_TEMPLATE = ui_default;
 
 // src/daemon/index.ts
 var import_http = __toESM(require("http"));
-var import_fs3 = __toESM(require("fs"));
-var import_path5 = __toESM(require("path"));
-var import_os3 = __toESM(require("os"));
+var import_fs4 = __toESM(require("fs"));
+var import_path6 = __toESM(require("path"));
+var import_os4 = __toESM(require("os"));
 var import_child_process2 = require("child_process");
-var import_crypto = require("crypto");
+var import_crypto2 = require("crypto");
 var import_chalk4 = __toESM(require("chalk"));
 var DAEMON_PORT2 = 7391;
 var DAEMON_HOST2 = "127.0.0.1";
-var homeDir = import_os3.default.homedir();
-var DAEMON_PID_FILE = import_path5.default.join(homeDir, ".node9", "daemon.pid");
-var DECISIONS_FILE = import_path5.default.join(homeDir, ".node9", "decisions.json");
-var GLOBAL_CONFIG_FILE = import_path5.default.join(homeDir, ".node9", "config.json");
-var CREDENTIALS_FILE = import_path5.default.join(homeDir, ".node9", "credentials.json");
-var AUDIT_LOG_FILE = import_path5.default.join(homeDir, ".node9", "audit.log");
-var TRUST_FILE2 = import_path5.default.join(homeDir, ".node9", "trust.json");
+var homeDir = import_os4.default.homedir();
+var DAEMON_PID_FILE = import_path6.default.join(homeDir, ".node9", "daemon.pid");
+var DECISIONS_FILE = import_path6.default.join(homeDir, ".node9", "decisions.json");
+var GLOBAL_CONFIG_FILE = import_path6.default.join(homeDir, ".node9", "config.json");
+var CREDENTIALS_FILE = import_path6.default.join(homeDir, ".node9", "credentials.json");
+var AUDIT_LOG_FILE = import_path6.default.join(homeDir, ".node9", "audit.log");
+var TRUST_FILE2 = import_path6.default.join(homeDir, ".node9", "trust.json");
 function atomicWriteSync2(filePath, data, options) {
-  const dir = import_path5.default.dirname(filePath);
-  if (!import_fs3.default.existsSync(dir)) import_fs3.default.mkdirSync(dir, { recursive: true });
-  const tmpPath = `${filePath}.${(0, import_crypto.randomUUID)()}.tmp`;
-  import_fs3.default.writeFileSync(tmpPath, data, options);
-  import_fs3.default.renameSync(tmpPath, filePath);
+  const dir = import_path6.default.dirname(filePath);
+  if (!import_fs4.default.existsSync(dir)) import_fs4.default.mkdirSync(dir, { recursive: true });
+  const tmpPath = `${filePath}.${(0, import_crypto2.randomUUID)()}.tmp`;
+  import_fs4.default.writeFileSync(tmpPath, data, options);
+  import_fs4.default.renameSync(tmpPath, filePath);
 }
 function writeTrustEntry(toolName, durationMs) {
   try {
     let trust = { entries: [] };
     try {
-      if (import_fs3.default.existsSync(TRUST_FILE2))
-        trust = JSON.parse(import_fs3.default.readFileSync(TRUST_FILE2, "utf-8"));
+      if (import_fs4.default.existsSync(TRUST_FILE2))
+        trust = JSON.parse(import_fs4.default.readFileSync(TRUST_FILE2, "utf-8"));
     } catch {
     }
     trust.entries = trust.entries.filter((e) => e.tool !== toolName && e.expiry > Date.now());
@@ -3456,16 +3727,16 @@ function appendAuditLog(data) {
       decision: data.decision,
       source: "daemon"
     };
-    const dir = import_path5.default.dirname(AUDIT_LOG_FILE);
-    if (!import_fs3.default.existsSync(dir)) import_fs3.default.mkdirSync(dir, { recursive: true });
-    import_fs3.default.appendFileSync(AUDIT_LOG_FILE, JSON.stringify(entry) + "\n");
+    const dir = import_path6.default.dirname(AUDIT_LOG_FILE);
+    if (!import_fs4.default.existsSync(dir)) import_fs4.default.mkdirSync(dir, { recursive: true });
+    import_fs4.default.appendFileSync(AUDIT_LOG_FILE, JSON.stringify(entry) + "\n");
   } catch {
   }
 }
 function getAuditHistory(limit = 20) {
   try {
-    if (!import_fs3.default.existsSync(AUDIT_LOG_FILE)) return [];
-    const lines = import_fs3.default.readFileSync(AUDIT_LOG_FILE, "utf-8").trim().split("\n");
+    if (!import_fs4.default.existsSync(AUDIT_LOG_FILE)) return [];
+    const lines = import_fs4.default.readFileSync(AUDIT_LOG_FILE, "utf-8").trim().split("\n");
     if (lines.length === 1 && lines[0] === "") return [];
     return lines.slice(-limit).map((l) => JSON.parse(l)).reverse();
   } catch {
@@ -3475,7 +3746,7 @@ function getAuditHistory(limit = 20) {
 var AUTO_DENY_MS = 12e4;
 function getOrgName() {
   try {
-    if (import_fs3.default.existsSync(CREDENTIALS_FILE)) {
+    if (import_fs4.default.existsSync(CREDENTIALS_FILE)) {
       return "Node9 Cloud";
     }
   } catch {
@@ -3484,13 +3755,13 @@ function getOrgName() {
 }
 var autoStarted = process.env.NODE9_AUTO_STARTED === "1";
 function hasStoredSlackKey() {
-  return import_fs3.default.existsSync(CREDENTIALS_FILE);
+  return import_fs4.default.existsSync(CREDENTIALS_FILE);
 }
 function writeGlobalSetting(key, value) {
   let config = {};
   try {
-    if (import_fs3.default.existsSync(GLOBAL_CONFIG_FILE)) {
-      config = JSON.parse(import_fs3.default.readFileSync(GLOBAL_CONFIG_FILE, "utf-8"));
+    if (import_fs4.default.existsSync(GLOBAL_CONFIG_FILE)) {
+      config = JSON.parse(import_fs4.default.readFileSync(GLOBAL_CONFIG_FILE, "utf-8"));
     }
   } catch {
   }
@@ -3514,7 +3785,7 @@ function abandonPending() {
   });
   if (autoStarted) {
     try {
-      import_fs3.default.unlinkSync(DAEMON_PID_FILE);
+      import_fs4.default.unlinkSync(DAEMON_PID_FILE);
     } catch {
     }
     setTimeout(() => {
@@ -3552,8 +3823,8 @@ function readBody(req) {
 }
 function readPersistentDecisions() {
   try {
-    if (import_fs3.default.existsSync(DECISIONS_FILE)) {
-      return JSON.parse(import_fs3.default.readFileSync(DECISIONS_FILE, "utf-8"));
+    if (import_fs4.default.existsSync(DECISIONS_FILE)) {
+      return JSON.parse(import_fs4.default.readFileSync(DECISIONS_FILE, "utf-8"));
     }
   } catch {
   }
@@ -3569,8 +3840,8 @@ function writePersistentDecision(toolName, decision) {
   }
 }
 function startDaemon() {
-  const csrfToken = (0, import_crypto.randomUUID)();
-  const internalToken = (0, import_crypto.randomUUID)();
+  const csrfToken = (0, import_crypto2.randomUUID)();
+  const internalToken = (0, import_crypto2.randomUUID)();
   const UI_HTML = UI_HTML_TEMPLATE.replace("{{CSRF_TOKEN}}", csrfToken);
   const validToken = (req) => req.headers["x-node9-token"] === csrfToken;
   const IDLE_TIMEOUT_MS = 12 * 60 * 60 * 1e3;
@@ -3580,7 +3851,7 @@ function startDaemon() {
     idleTimer = setTimeout(() => {
       if (autoStarted) {
         try {
-          import_fs3.default.unlinkSync(DAEMON_PID_FILE);
+          import_fs4.default.unlinkSync(DAEMON_PID_FILE);
         } catch {
         }
       }
@@ -3651,7 +3922,7 @@ data: ${JSON.stringify(readPersistentDecisions())}
           mcpServer,
           riskMetadata
         } = JSON.parse(body);
-        const id = (0, import_crypto.randomUUID)();
+        const id = (0, import_crypto2.randomUUID)();
         const entry = {
           id,
           toolName,
@@ -3898,14 +4169,14 @@ data: ${JSON.stringify(readPersistentDecisions())}
   server.on("error", (e) => {
     if (e.code === "EADDRINUSE") {
       try {
-        if (import_fs3.default.existsSync(DAEMON_PID_FILE)) {
-          const { pid } = JSON.parse(import_fs3.default.readFileSync(DAEMON_PID_FILE, "utf-8"));
+        if (import_fs4.default.existsSync(DAEMON_PID_FILE)) {
+          const { pid } = JSON.parse(import_fs4.default.readFileSync(DAEMON_PID_FILE, "utf-8"));
           process.kill(pid, 0);
           return process.exit(0);
         }
       } catch {
         try {
-          import_fs3.default.unlinkSync(DAEMON_PID_FILE);
+          import_fs4.default.unlinkSync(DAEMON_PID_FILE);
         } catch {
         }
         server.listen(DAEMON_PORT2, DAEMON_HOST2);
@@ -3925,25 +4196,25 @@ data: ${JSON.stringify(readPersistentDecisions())}
   });
 }
 function stopDaemon() {
-  if (!import_fs3.default.existsSync(DAEMON_PID_FILE)) return console.log(import_chalk4.default.yellow("Not running."));
+  if (!import_fs4.default.existsSync(DAEMON_PID_FILE)) return console.log(import_chalk4.default.yellow("Not running."));
   try {
-    const { pid } = JSON.parse(import_fs3.default.readFileSync(DAEMON_PID_FILE, "utf-8"));
+    const { pid } = JSON.parse(import_fs4.default.readFileSync(DAEMON_PID_FILE, "utf-8"));
     process.kill(pid, "SIGTERM");
     console.log(import_chalk4.default.green("\u2705 Stopped."));
   } catch {
     console.log(import_chalk4.default.gray("Cleaned up stale PID file."));
   } finally {
     try {
-      import_fs3.default.unlinkSync(DAEMON_PID_FILE);
+      import_fs4.default.unlinkSync(DAEMON_PID_FILE);
     } catch {
     }
   }
 }
 function daemonStatus() {
-  if (!import_fs3.default.existsSync(DAEMON_PID_FILE))
+  if (!import_fs4.default.existsSync(DAEMON_PID_FILE))
     return console.log(import_chalk4.default.yellow("Node9 daemon: not running"));
   try {
-    const { pid } = JSON.parse(import_fs3.default.readFileSync(DAEMON_PID_FILE, "utf-8"));
+    const { pid } = JSON.parse(import_fs4.default.readFileSync(DAEMON_PID_FILE, "utf-8"));
     process.kill(pid, 0);
     console.log(import_chalk4.default.green("Node9 daemon: running"));
   } catch {
@@ -3957,30 +4228,30 @@ var import_execa = require("execa");
 var import_execa2 = require("execa");
 var import_chalk5 = __toESM(require("chalk"));
 var import_readline = __toESM(require("readline"));
-var import_fs5 = __toESM(require("fs"));
-var import_path7 = __toESM(require("path"));
-var import_os5 = __toESM(require("os"));
+var import_fs6 = __toESM(require("fs"));
+var import_path8 = __toESM(require("path"));
+var import_os6 = __toESM(require("os"));
 
 // src/undo.ts
 var import_child_process3 = require("child_process");
-var import_fs4 = __toESM(require("fs"));
-var import_path6 = __toESM(require("path"));
-var import_os4 = __toESM(require("os"));
-var SNAPSHOT_STACK_PATH = import_path6.default.join(import_os4.default.homedir(), ".node9", "snapshots.json");
-var UNDO_LATEST_PATH = import_path6.default.join(import_os4.default.homedir(), ".node9", "undo_latest.txt");
+var import_fs5 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
+var import_os5 = __toESM(require("os"));
+var SNAPSHOT_STACK_PATH = import_path7.default.join(import_os5.default.homedir(), ".node9", "snapshots.json");
+var UNDO_LATEST_PATH = import_path7.default.join(import_os5.default.homedir(), ".node9", "undo_latest.txt");
 var MAX_SNAPSHOTS = 10;
 function readStack() {
   try {
-    if (import_fs4.default.existsSync(SNAPSHOT_STACK_PATH))
-      return JSON.parse(import_fs4.default.readFileSync(SNAPSHOT_STACK_PATH, "utf-8"));
+    if (import_fs5.default.existsSync(SNAPSHOT_STACK_PATH))
+      return JSON.parse(import_fs5.default.readFileSync(SNAPSHOT_STACK_PATH, "utf-8"));
   } catch {
   }
   return [];
 }
 function writeStack(stack) {
-  const dir = import_path6.default.dirname(SNAPSHOT_STACK_PATH);
-  if (!import_fs4.default.existsSync(dir)) import_fs4.default.mkdirSync(dir, { recursive: true });
-  import_fs4.default.writeFileSync(SNAPSHOT_STACK_PATH, JSON.stringify(stack, null, 2));
+  const dir = import_path7.default.dirname(SNAPSHOT_STACK_PATH);
+  if (!import_fs5.default.existsSync(dir)) import_fs5.default.mkdirSync(dir, { recursive: true });
+  import_fs5.default.writeFileSync(SNAPSHOT_STACK_PATH, JSON.stringify(stack, null, 2));
 }
 function buildArgsSummary(tool, args) {
   if (!args || typeof args !== "object") return "";
@@ -3996,13 +4267,13 @@ function buildArgsSummary(tool, args) {
 async function createShadowSnapshot(tool = "unknown", args = {}) {
   try {
     const cwd = process.cwd();
-    if (!import_fs4.default.existsSync(import_path6.default.join(cwd, ".git"))) return null;
-    const tempIndex = import_path6.default.join(cwd, ".git", `node9_index_${Date.now()}`);
+    if (!import_fs5.default.existsSync(import_path7.default.join(cwd, ".git"))) return null;
+    const tempIndex = import_path7.default.join(cwd, ".git", `node9_index_${Date.now()}`);
     const env = { ...process.env, GIT_INDEX_FILE: tempIndex };
     (0, import_child_process3.spawnSync)("git", ["add", "-A"], { env });
     const treeRes = (0, import_child_process3.spawnSync)("git", ["write-tree"], { env });
     const treeHash = treeRes.stdout.toString().trim();
-    if (import_fs4.default.existsSync(tempIndex)) import_fs4.default.unlinkSync(tempIndex);
+    if (import_fs5.default.existsSync(tempIndex)) import_fs5.default.unlinkSync(tempIndex);
     if (!treeHash || treeRes.status !== 0) return null;
     const commitRes = (0, import_child_process3.spawnSync)("git", [
       "commit-tree",
@@ -4023,7 +4294,7 @@ async function createShadowSnapshot(tool = "unknown", args = {}) {
     stack.push(entry);
     if (stack.length > MAX_SNAPSHOTS) stack.splice(0, stack.length - MAX_SNAPSHOTS);
     writeStack(stack);
-    import_fs4.default.writeFileSync(UNDO_LATEST_PATH, commitHash);
+    import_fs5.default.writeFileSync(UNDO_LATEST_PATH, commitHash);
     return commitHash;
   } catch (err) {
     if (process.env.NODE9_DEBUG === "1") console.error("[Node9 Undo Engine Error]:", err);
@@ -4061,9 +4332,9 @@ function applyUndo(hash, cwd) {
     const tracked = (0, import_child_process3.spawnSync)("git", ["ls-files"], { cwd: dir }).stdout.toString().trim().split("\n").filter(Boolean);
     const untracked = (0, import_child_process3.spawnSync)("git", ["ls-files", "--others", "--exclude-standard"], { cwd: dir }).stdout.toString().trim().split("\n").filter(Boolean);
     for (const file of [...tracked, ...untracked]) {
-      const fullPath = import_path6.default.join(dir, file);
-      if (!snapshotFiles.has(file) && import_fs4.default.existsSync(fullPath)) {
-        import_fs4.default.unlinkSync(fullPath);
+      const fullPath = import_path7.default.join(dir, file);
+      if (!snapshotFiles.has(file) && import_fs5.default.existsSync(fullPath)) {
+        import_fs5.default.unlinkSync(fullPath);
       }
     }
     return true;
@@ -4075,7 +4346,7 @@ function applyUndo(hash, cwd) {
 // src/cli.ts
 var import_prompts3 = require("@inquirer/prompts");
 var { version } = JSON.parse(
-  import_fs5.default.readFileSync(import_path7.default.join(__dirname, "../package.json"), "utf-8")
+  import_fs6.default.readFileSync(import_path8.default.join(__dirname, "../package.json"), "utf-8")
 );
 function parseDuration(str) {
   const m = str.trim().match(/^(\d+(?:\.\d+)?)\s*(s|m|h|d)?$/i);
@@ -4107,6 +4378,15 @@ INSTRUCTIONS:
 - If you believe this action is critical, explain your reasoning and ask them to run "node9 pause 15m" to proceed.`;
   }
   const label = blockedByLabel.toLowerCase();
+  if (label.includes("dlp") || label.includes("secret detected") || label.includes("credential review")) {
+    return `NODE9 SECURITY ALERT: A sensitive credential (API key, token, or private key) was found in your tool call arguments.
+CRITICAL INSTRUCTION: Do NOT retry this action.
+REQUIRED ACTIONS:
+1. Remove the hardcoded credential from your command or code.
+2. Use an environment variable or a dedicated secrets manager instead.
+3. Treat the leaked credential as compromised and rotate it immediately.
+Do NOT attempt to bypass this check or pass the credential through another tool.`;
+  }
   if (label.includes("sql safety") && label.includes("delete without where")) {
     return `NODE9: Blocked \u2014 DELETE without WHERE clause would wipe the entire table.
 INSTRUCTION: Add a WHERE clause to scope the deletion (e.g. WHERE id = <value>).
@@ -4268,14 +4548,14 @@ async function runProxy(targetCommand) {
 }
 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 = import_path7.default.join(import_os5.default.homedir(), ".node9", "credentials.json");
-  if (!import_fs5.default.existsSync(import_path7.default.dirname(credPath)))
-    import_fs5.default.mkdirSync(import_path7.default.dirname(credPath), { recursive: true });
+  const credPath = import_path8.default.join(import_os6.default.homedir(), ".node9", "credentials.json");
+  if (!import_fs6.default.existsSync(import_path8.default.dirname(credPath)))
+    import_fs6.default.mkdirSync(import_path8.default.dirname(credPath), { recursive: true });
   const profileName = options.profile || "default";
   let existingCreds = {};
   try {
-    if (import_fs5.default.existsSync(credPath)) {
-      const raw = JSON.parse(import_fs5.default.readFileSync(credPath, "utf-8"));
+    if (import_fs6.default.existsSync(credPath)) {
+      const raw = JSON.parse(import_fs6.default.readFileSync(credPath, "utf-8"));
       if (raw.apiKey) {
         existingCreds = {
           default: { apiKey: raw.apiKey, apiUrl: raw.apiUrl || DEFAULT_API_URL }
@@ -4287,13 +4567,13 @@ program.command("login").argument("<apiKey>").option("--local", "Save key for au
   } catch {
   }
   existingCreds[profileName] = { apiKey, apiUrl: DEFAULT_API_URL };
-  import_fs5.default.writeFileSync(credPath, JSON.stringify(existingCreds, null, 2), { mode: 384 });
+  import_fs6.default.writeFileSync(credPath, JSON.stringify(existingCreds, null, 2), { mode: 384 });
   if (profileName === "default") {
-    const configPath = import_path7.default.join(import_os5.default.homedir(), ".node9", "config.json");
+    const configPath = import_path8.default.join(import_os6.default.homedir(), ".node9", "config.json");
     let config = {};
     try {
-      if (import_fs5.default.existsSync(configPath))
-        config = JSON.parse(import_fs5.default.readFileSync(configPath, "utf-8"));
+      if (import_fs6.default.existsSync(configPath))
+        config = JSON.parse(import_fs6.default.readFileSync(configPath, "utf-8"));
     } catch {
     }
     if (!config.settings || typeof config.settings !== "object") config.settings = {};
@@ -4308,9 +4588,9 @@ program.command("login").argument("<apiKey>").option("--local", "Save key for au
       approvers.cloud = false;
     }
     s.approvers = approvers;
-    if (!import_fs5.default.existsSync(import_path7.default.dirname(configPath)))
-      import_fs5.default.mkdirSync(import_path7.default.dirname(configPath), { recursive: true });
-    import_fs5.default.writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 384 });
+    if (!import_fs6.default.existsSync(import_path8.default.dirname(configPath)))
+      import_fs6.default.mkdirSync(import_path8.default.dirname(configPath), { recursive: true });
+    import_fs6.default.writeFileSync(configPath, JSON.stringify(config, null, 2), { mode: 384 });
   }
   if (options.profile && profileName !== "default") {
     console.log(import_chalk5.default.green(`\u2705 Profile "${profileName}" saved`));
@@ -4349,7 +4629,7 @@ program.command("setup").description('Alias for "addto" \u2014 integrate Node9 w
   process.exit(1);
 });
 program.command("doctor").description("Check that Node9 is installed and configured correctly").action(() => {
-  const homeDir2 = import_os5.default.homedir();
+  const homeDir2 = import_os6.default.homedir();
   let failures = 0;
   function pass(msg) {
     console.log(import_chalk5.default.green("  \u2705 ") + msg);
@@ -4395,10 +4675,10 @@ program.command("doctor").description("Check that Node9 is installed and configu
     );
   }
   section("Configuration");
-  const globalConfigPath = import_path7.default.join(homeDir2, ".node9", "config.json");
-  if (import_fs5.default.existsSync(globalConfigPath)) {
+  const globalConfigPath = import_path8.default.join(homeDir2, ".node9", "config.json");
+  if (import_fs6.default.existsSync(globalConfigPath)) {
     try {
-      JSON.parse(import_fs5.default.readFileSync(globalConfigPath, "utf-8"));
+      JSON.parse(import_fs6.default.readFileSync(globalConfigPath, "utf-8"));
       pass("~/.node9/config.json found and valid");
     } catch {
       fail("~/.node9/config.json is invalid JSON", "Run: node9 init --force");
@@ -4406,17 +4686,17 @@ program.command("doctor").description("Check that Node9 is installed and configu
   } else {
     warn("~/.node9/config.json not found (using defaults)", "Run: node9 init");
   }
-  const projectConfigPath = import_path7.default.join(process.cwd(), "node9.config.json");
-  if (import_fs5.default.existsSync(projectConfigPath)) {
+  const projectConfigPath = import_path8.default.join(process.cwd(), "node9.config.json");
+  if (import_fs6.default.existsSync(projectConfigPath)) {
     try {
-      JSON.parse(import_fs5.default.readFileSync(projectConfigPath, "utf-8"));
+      JSON.parse(import_fs6.default.readFileSync(projectConfigPath, "utf-8"));
       pass("node9.config.json found and valid (project)");
     } catch {
       fail("node9.config.json is invalid JSON", "Fix the JSON or delete it and run: node9 init");
     }
   }
-  const credsPath = import_path7.default.join(homeDir2, ".node9", "credentials.json");
-  if (import_fs5.default.existsSync(credsPath)) {
+  const credsPath = import_path8.default.join(homeDir2, ".node9", "credentials.json");
+  if (import_fs6.default.existsSync(credsPath)) {
     pass("Cloud credentials found (~/.node9/credentials.json)");
   } else {
     warn(
@@ -4425,10 +4705,10 @@ program.command("doctor").description("Check that Node9 is installed and configu
     );
   }
   section("Agent Hooks");
-  const claudeSettingsPath = import_path7.default.join(homeDir2, ".claude", "settings.json");
-  if (import_fs5.default.existsSync(claudeSettingsPath)) {
+  const claudeSettingsPath = import_path8.default.join(homeDir2, ".claude", "settings.json");
+  if (import_fs6.default.existsSync(claudeSettingsPath)) {
     try {
-      const cs = JSON.parse(import_fs5.default.readFileSync(claudeSettingsPath, "utf-8"));
+      const cs = JSON.parse(import_fs6.default.readFileSync(claudeSettingsPath, "utf-8"));
       const hasHook = cs.hooks?.PreToolUse?.some(
         (m) => m.hooks.some((h) => h.command?.includes("node9") || h.command?.includes("cli.js"))
       );
@@ -4441,10 +4721,10 @@ program.command("doctor").description("Check that Node9 is installed and configu
   } else {
     warn("Claude Code \u2014 not configured", "Run: node9 setup claude");
   }
-  const geminiSettingsPath = import_path7.default.join(homeDir2, ".gemini", "settings.json");
-  if (import_fs5.default.existsSync(geminiSettingsPath)) {
+  const geminiSettingsPath = import_path8.default.join(homeDir2, ".gemini", "settings.json");
+  if (import_fs6.default.existsSync(geminiSettingsPath)) {
     try {
-      const gs = JSON.parse(import_fs5.default.readFileSync(geminiSettingsPath, "utf-8"));
+      const gs = JSON.parse(import_fs6.default.readFileSync(geminiSettingsPath, "utf-8"));
       const hasHook = gs.hooks?.BeforeTool?.some(
         (m) => m.hooks.some((h) => h.command?.includes("node9") || h.command?.includes("cli.js"))
       );
@@ -4457,10 +4737,10 @@ program.command("doctor").description("Check that Node9 is installed and configu
   } else {
     warn("Gemini CLI  \u2014 not configured", "Run: node9 setup gemini  (skip if not using Gemini)");
   }
-  const cursorHooksPath = import_path7.default.join(homeDir2, ".cursor", "hooks.json");
-  if (import_fs5.default.existsSync(cursorHooksPath)) {
+  const cursorHooksPath = import_path8.default.join(homeDir2, ".cursor", "hooks.json");
+  if (import_fs6.default.existsSync(cursorHooksPath)) {
     try {
-      const cur = JSON.parse(import_fs5.default.readFileSync(cursorHooksPath, "utf-8"));
+      const cur = JSON.parse(import_fs6.default.readFileSync(cursorHooksPath, "utf-8"));
       const hasHook = cur.hooks?.preToolUse?.some(
         (h) => h.command?.includes("node9") || h.command?.includes("cli.js")
       );
@@ -4562,8 +4842,8 @@ program.command("explain").description(
   console.log("");
 });
 program.command("init").description("Create ~/.node9/config.json with default policy (safe to run multiple times)").option("--force", "Overwrite existing config").option("-m, --mode <mode>", "Set initial security mode (standard, strict, audit)", "standard").action((options) => {
-  const configPath = import_path7.default.join(import_os5.default.homedir(), ".node9", "config.json");
-  if (import_fs5.default.existsSync(configPath) && !options.force) {
+  const configPath = import_path8.default.join(import_os6.default.homedir(), ".node9", "config.json");
+  if (import_fs6.default.existsSync(configPath) && !options.force) {
     console.log(import_chalk5.default.yellow(`\u2139\uFE0F  Global config already exists: ${configPath}`));
     console.log(import_chalk5.default.gray(`   Run with --force to overwrite.`));
     return;
@@ -4577,9 +4857,9 @@ program.command("init").description("Create ~/.node9/config.json with default po
       mode: safeMode
     }
   };
-  const dir = import_path7.default.dirname(configPath);
-  if (!import_fs5.default.existsSync(dir)) import_fs5.default.mkdirSync(dir, { recursive: true });
-  import_fs5.default.writeFileSync(configPath, JSON.stringify(configToSave, null, 2));
+  const dir = import_path8.default.dirname(configPath);
+  if (!import_fs6.default.existsSync(dir)) import_fs6.default.mkdirSync(dir, { recursive: true });
+  import_fs6.default.writeFileSync(configPath, JSON.stringify(configToSave, null, 2));
   console.log(import_chalk5.default.green(`\u2705 Global config created: ${configPath}`));
   console.log(import_chalk5.default.cyan(`   Mode set to: ${safeMode}`));
   console.log(
@@ -4597,14 +4877,14 @@ function formatRelativeTime(timestamp) {
   return new Date(timestamp).toLocaleDateString();
 }
 program.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 = import_path7.default.join(import_os5.default.homedir(), ".node9", "audit.log");
-  if (!import_fs5.default.existsSync(logPath)) {
+  const logPath = import_path8.default.join(import_os6.default.homedir(), ".node9", "audit.log");
+  if (!import_fs6.default.existsSync(logPath)) {
     console.log(
       import_chalk5.default.yellow("No audit logs found. Run node9 with an agent to generate entries.")
     );
     return;
   }
-  const raw = import_fs5.default.readFileSync(logPath, "utf-8");
+  const raw = import_fs6.default.readFileSync(logPath, "utf-8");
   const lines = raw.split("\n").filter((l) => l.trim() !== "");
   let entries = lines.flatMap((line) => {
     try {
@@ -4687,13 +4967,13 @@ program.command("status").description("Show current Node9 mode, policy source, a
   console.log("");
   const modeLabel = settings.mode === "audit" ? import_chalk5.default.blue("audit") : settings.mode === "strict" ? import_chalk5.default.red("strict") : import_chalk5.default.white("standard");
   console.log(`  Mode:    ${modeLabel}`);
-  const projectConfig = import_path7.default.join(process.cwd(), "node9.config.json");
-  const globalConfig = import_path7.default.join(import_os5.default.homedir(), ".node9", "config.json");
+  const projectConfig = import_path8.default.join(process.cwd(), "node9.config.json");
+  const globalConfig = import_path8.default.join(import_os6.default.homedir(), ".node9", "config.json");
   console.log(
-    `  Local:   ${import_fs5.default.existsSync(projectConfig) ? import_chalk5.default.green("Active (node9.config.json)") : import_chalk5.default.gray("Not present")}`
+    `  Local:   ${import_fs6.default.existsSync(projectConfig) ? import_chalk5.default.green("Active (node9.config.json)") : import_chalk5.default.gray("Not present")}`
   );
   console.log(
-    `  Global:  ${import_fs5.default.existsSync(globalConfig) ? import_chalk5.default.green("Active (~/.node9/config.json)") : import_chalk5.default.gray("Not present")}`
+    `  Global:  ${import_fs6.default.existsSync(globalConfig) ? import_chalk5.default.green("Active (~/.node9/config.json)") : import_chalk5.default.gray("Not present")}`
   );
   if (mergedConfig.policy.sandboxPaths.length > 0) {
     console.log(
@@ -4756,9 +5036,9 @@ program.command("check").description("Hook handler \u2014 evaluates a tool call
       } catch (err) {
         const tempConfig = getConfig();
         if (process.env.NODE9_DEBUG === "1" || tempConfig.settings.enableHookLogDebug) {
-          const logPath = import_path7.default.join(import_os5.default.homedir(), ".node9", "hook-debug.log");
+          const logPath = import_path8.default.join(import_os6.default.homedir(), ".node9", "hook-debug.log");
           const errMsg = err instanceof Error ? err.message : String(err);
-          import_fs5.default.appendFileSync(
+          import_fs6.default.appendFileSync(
             logPath,
             `[${(/* @__PURE__ */ new Date()).toISOString()}] JSON_PARSE_ERROR: ${errMsg}
 RAW: ${raw}
@@ -4776,10 +5056,10 @@ RAW: ${raw}
       }
       const config = getConfig();
       if (process.env.NODE9_DEBUG === "1" || config.settings.enableHookLogDebug) {
-        const logPath = import_path7.default.join(import_os5.default.homedir(), ".node9", "hook-debug.log");
-        if (!import_fs5.default.existsSync(import_path7.default.dirname(logPath)))
-          import_fs5.default.mkdirSync(import_path7.default.dirname(logPath), { recursive: true });
-        import_fs5.default.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] STDIN: ${raw}
+        const logPath = import_path8.default.join(import_os6.default.homedir(), ".node9", "hook-debug.log");
+        if (!import_fs6.default.existsSync(import_path8.default.dirname(logPath)))
+          import_fs6.default.mkdirSync(import_path8.default.dirname(logPath), { recursive: true });
+        import_fs6.default.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] STDIN: ${raw}
 `);
       }
       const toolName = sanitize(payload.tool_name ?? payload.name ?? "");
@@ -4790,8 +5070,14 @@ RAW: ${raw}
       const sendBlock = (msg, result2) => {
         const blockedByContext = result2?.blockedByLabel || result2?.blockedBy || "Local Security Policy";
         const isHumanDecision = blockedByContext.toLowerCase().includes("user") || blockedByContext.toLowerCase().includes("daemon") || blockedByContext.toLowerCase().includes("decision");
-        console.error(import_chalk5.default.red(`
+        if (blockedByContext.includes("DLP") || blockedByContext.includes("Secret Detected") || blockedByContext.includes("Credential Review")) {
+          console.error(import_chalk5.default.bgRed.white.bold(`
+ \u{1F6A8} NODE9 DLP ALERT \u2014 CREDENTIAL DETECTED `));
+          console.error(import_chalk5.default.red.bold(`   A sensitive secret was found in the tool arguments!`));
+        } else {
+          console.error(import_chalk5.default.red(`
 \u{1F6D1} Node9 blocked "${toolName}"`));
+        }
         console.error(import_chalk5.default.gray(`   Triggered by: ${blockedByContext}`));
         if (result2?.changeHint) console.error(import_chalk5.default.cyan(`   To change:  ${result2.changeHint}`));
         console.error("");
@@ -4850,9 +5136,9 @@ RAW: ${raw}
       });
     } catch (err) {
       if (process.env.NODE9_DEBUG === "1") {
-        const logPath = import_path7.default.join(import_os5.default.homedir(), ".node9", "hook-debug.log");
+        const logPath = import_path8.default.join(import_os6.default.homedir(), ".node9", "hook-debug.log");
         const errMsg = err instanceof Error ? err.message : String(err);
-        import_fs5.default.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR: ${errMsg}
+        import_fs6.default.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR: ${errMsg}
 `);
       }
       process.exit(0);
@@ -4897,10 +5183,10 @@ program.command("log").description("PostToolUse hook \u2014 records executed too
         decision: "allowed",
         source: "post-hook"
       };
-      const logPath = import_path7.default.join(import_os5.default.homedir(), ".node9", "audit.log");
-      if (!import_fs5.default.existsSync(import_path7.default.dirname(logPath)))
-        import_fs5.default.mkdirSync(import_path7.default.dirname(logPath), { recursive: true });
-      import_fs5.default.appendFileSync(logPath, JSON.stringify(entry) + "\n");
+      const logPath = import_path8.default.join(import_os6.default.homedir(), ".node9", "audit.log");
+      if (!import_fs6.default.existsSync(import_path8.default.dirname(logPath)))
+        import_fs6.default.mkdirSync(import_path8.default.dirname(logPath), { recursive: true });
+      import_fs6.default.appendFileSync(logPath, JSON.stringify(entry) + "\n");
       const config = getConfig();
       if (shouldSnapshot(tool, {}, config)) {
         await createShadowSnapshot();
@@ -5082,13 +5368,103 @@ program.command("undo").description(
     console.log(import_chalk5.default.gray("\nCancelled.\n"));
   }
 });
+var shieldCmd = program.command("shield").description("Manage pre-packaged security shield templates");
+shieldCmd.command("enable <service>").description("Enable a security shield for a specific service").action((service) => {
+  const name = resolveShieldName(service);
+  if (!name) {
+    console.error(import_chalk5.default.red(`
+\u274C Unknown shield: "${service}"
+`));
+    console.log(`Run ${import_chalk5.default.cyan("node9 shield list")} to see available shields.
+`);
+    process.exit(1);
+  }
+  const shield = getShield(name);
+  const active = readActiveShields();
+  if (active.includes(name)) {
+    console.log(import_chalk5.default.yellow(`
+\u2139\uFE0F  Shield "${name}" is already active.
+`));
+    return;
+  }
+  writeActiveShields([...active, name]);
+  console.log(import_chalk5.default.green(`
+\u{1F6E1}\uFE0F  Shield "${name}" enabled.`));
+  console.log(import_chalk5.default.gray(`   ${shield.smartRules.length} smart rules now active.`));
+  if (shield.dangerousWords.length > 0)
+    console.log(import_chalk5.default.gray(`   ${shield.dangerousWords.length} dangerous words now active.`));
+  if (name === "filesystem") {
+    console.log(
+      import_chalk5.default.yellow(
+        `
+   \u26A0\uFE0F  Note: filesystem rules cover common rm -rf patterns but not all variants.
+      Tools like unlink, find -delete, or language-level file ops are not intercepted.`
+      )
+    );
+  }
+  console.log("");
+});
+shieldCmd.command("disable <service>").description("Disable a security shield").action((service) => {
+  const name = resolveShieldName(service);
+  if (!name) {
+    console.error(import_chalk5.default.red(`
+\u274C Unknown shield: "${service}"
+`));
+    console.log(`Run ${import_chalk5.default.cyan("node9 shield list")} to see available shields.
+`);
+    process.exit(1);
+  }
+  const active = readActiveShields();
+  if (!active.includes(name)) {
+    console.log(import_chalk5.default.yellow(`
+\u2139\uFE0F  Shield "${name}" is not active.
+`));
+    return;
+  }
+  writeActiveShields(active.filter((s) => s !== name));
+  console.log(import_chalk5.default.green(`
+\u{1F6E1}\uFE0F  Shield "${name}" disabled.
+`));
+});
+shieldCmd.command("list").description("Show all available shields").action(() => {
+  const active = new Set(readActiveShields());
+  console.log(import_chalk5.default.bold("\n\u{1F6E1}\uFE0F  Available Shields\n"));
+  for (const shield of listShields()) {
+    const status = active.has(shield.name) ? import_chalk5.default.green("\u25CF enabled") : import_chalk5.default.gray("\u25CB disabled");
+    console.log(`  ${status}  ${import_chalk5.default.cyan(shield.name.padEnd(12))} ${shield.description}`);
+    if (shield.aliases.length > 0)
+      console.log(import_chalk5.default.gray(`              aliases: ${shield.aliases.join(", ")}`));
+  }
+  console.log("");
+});
+shieldCmd.command("status").description("Show which shields are currently active").action(() => {
+  const active = readActiveShields();
+  if (active.length === 0) {
+    console.log(import_chalk5.default.yellow("\n\u2139\uFE0F  No shields are active.\n"));
+    console.log(`Run ${import_chalk5.default.cyan("node9 shield list")} to see available shields.
+`);
+    return;
+  }
+  console.log(import_chalk5.default.bold("\n\u{1F6E1}\uFE0F  Active Shields\n"));
+  for (const name of active) {
+    const shield = getShield(name);
+    if (!shield) continue;
+    console.log(`  ${import_chalk5.default.green("\u25CF")} ${import_chalk5.default.cyan(name)}`);
+    console.log(
+      import_chalk5.default.gray(
+        `    ${shield.smartRules.length} smart rules \xB7 ${shield.dangerousWords.length} dangerous words`
+      )
+    );
+  }
+  console.log("");
+});
 process.on("unhandledRejection", (reason) => {
   const isCheckHook = process.argv[2] === "check";
   if (isCheckHook) {
     if (process.env.NODE9_DEBUG === "1" || getConfig().settings.enableHookLogDebug) {
-      const logPath = import_path7.default.join(import_os5.default.homedir(), ".node9", "hook-debug.log");
+      const logPath = import_path8.default.join(import_os6.default.homedir(), ".node9", "hook-debug.log");
       const msg = reason instanceof Error ? reason.message : String(reason);
-      import_fs5.default.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] UNHANDLED: ${msg}
+      import_fs6.default.appendFileSync(logPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] UNHANDLED: ${msg}
 `);
     }
     process.exit(0);