@node9/proxy 2.5.0 → 2.6.2

package/dist/dashboard.mjs

@@ -228,9 +228,9 @@ function matchesPattern(text, patterns) {
   const withoutDotSlash = text.replace(/^\.\//, "");
   return isMatch(withoutDotSlash) || isMatch(`./${withoutDotSlash}`);
 }
-function getNestedValue(obj, path11) {
+function getNestedValue(obj, path12) {
   if (!obj || typeof obj !== "object") return null;
-  const segments = path11.split(".");
+  const segments = path12.split(".");
   for (const seg of segments) {
     if (FORBIDDEN_PATH_SEGMENTS.has(seg)) return null;
   }
@@ -2316,6 +2316,32 @@ var init_daemon = __esm({
 
 // src/config-schema.ts
 import { z } from "zod";
+function sanitizeConfig(raw) {
+  const result = ConfigFileSchema.safeParse(raw);
+  if (result.success) {
+    return { sanitized: result.data, error: null };
+  }
+  const invalidTopLevelKeys = new Set(
+    result.error.issues.filter((issue) => issue.path.length > 0).map((issue) => String(issue.path[0]))
+  );
+  const sanitized = {};
+  if (typeof raw === "object" && raw !== null) {
+    for (const [key, value] of Object.entries(raw)) {
+      if (!invalidTopLevelKeys.has(key)) {
+        sanitized[key] = value;
+      }
+    }
+  }
+  const lines = result.error.issues.map((issue) => {
+    const path12 = issue.path.length > 0 ? issue.path.join(".") : "root";
+    return `  \u2022 ${path12}: ${issue.message}`;
+  });
+  return {
+    sanitized,
+    error: `Invalid config:
+${lines.join("\n")}`
+  };
+}
 var noNewlines, SmartConditionSchema, SmartRuleSchema, ConfigFileSchema;
 var init_config_schema = __esm({
   "src/config-schema.ts"() {
@@ -2515,6 +2541,18 @@ function loadUserShields() {
 function buildSHIELDS() {
   return { ...BUILTIN_SHIELDS, ...loadUserShields() };
 }
+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 readShieldsFile() {
   try {
     const raw = fs3.readFileSync(SHIELDS_STATE_FILE, "utf-8");
@@ -2540,6 +2578,9 @@ function readShieldsFile() {
 function readActiveShields() {
   return readShieldsFile().active;
 }
+function readShieldOverrides() {
+  return readShieldsFile().overrides ?? {};
+}
 var USER_SHIELDS_DIR, SHIELDS, SHIELDS_STATE_FILE;
 var init_shields = __esm({
   "src/shields.ts"() {
@@ -2553,21 +2594,192 @@ var init_shields = __esm({
 });
 
 // src/config/managed.ts
+function rankIn(order, value) {
+  return value === void 0 ? -1 : order.indexOf(value);
+}
+function floorValue(order, local, cloud, opts = {}) {
+  if (cloud === void 0 || rankIn(order, cloud) === -1) return local;
+  if (opts.locked) return cloud;
+  const localSet = opts.localWasSet ?? local !== void 0;
+  if (!localSet || rankIn(order, local) === -1) return cloud;
+  return rankIn(order, local) > rankIn(order, cloud) ? local : cloud;
+}
+function strictestOf(order, ...values) {
+  let best;
+  for (const v of values) {
+    if (rankIn(order, v) === -1) continue;
+    if (best === void 0 || rankIn(order, v) > rankIn(order, best)) best = v;
+  }
+  return best;
+}
+function resolveByOrder(order, local, cloud, locked) {
+  return floorValue(order, local, cloud, { locked }) ?? local;
+}
+function resolveManagedMode(local, cloud, locked) {
+  return resolveByOrder(MODE_ORDER, local, cloud, locked);
+}
+function applyManagedEgress(local, managed, locked, localModeUserSet = true) {
+  const next = { ...local };
+  if (typeof managed.enabled === "boolean") {
+    next.enabled = locked.includes("egressEnabled") ? managed.enabled : local.enabled || managed.enabled;
+  }
+  if (typeof managed.mode === "string") {
+    next.mode = floorValue(EGRESS_MODE_ORDER, local.mode, managed.mode, {
+      locked: locked.includes("egressMode"),
+      // The default 'review' is seeded into egress before any merge, so absence
+      // is invisible from `local.mode` alone — the caller tracks it for us.
+      localWasSet: localModeUserSet
+    }) ?? local.mode;
+  }
+  if (Array.isArray(managed.allow) && managed.allow.length > 0) {
+    next.allow = [...managed.allow];
+  }
+  if (Array.isArray(managed.deny) && managed.deny.length > 0) {
+    next.deny = [.../* @__PURE__ */ new Set([...local.deny ?? [], ...managed.deny])];
+  }
+  if (typeof managed.allowPrivate === "boolean") {
+    next.allowPrivate = locked.includes("egressAllowPrivate") ? managed.allowPrivate : (local.allowPrivate ?? true) && managed.allowPrivate;
+  }
+  return next;
+}
+function applyManagedDlp(local, managed, locked) {
+  const next = { ...local };
+  if (typeof managed.enabled === "boolean") {
+    next.enabled = locked.includes("dlpEnabled") ? managed.enabled : local.enabled || managed.enabled;
+  }
+  if (managed.enabled === true) {
+    next.scanIgnoredTools = true;
+  }
+  if (typeof managed.pii === "string") {
+    next.pii = resolveByOrder(
+      DLP_PII_ORDER,
+      local.pii ?? "off",
+      managed.pii,
+      locked.includes("dlpPii")
+    );
+  }
+  if (typeof managed.reviewAction === "string") {
+    next.reviewAction = resolveByOrder(
+      DLP_REVIEW_ACTION_ORDER,
+      local.reviewAction ?? "review",
+      managed.reviewAction,
+      locked.includes("dlpReviewAction")
+    );
+  }
+  return next;
+}
+function applyManagedCommandChecks(local, managed, locked) {
+  const next = { ...local };
+  for (const key of COMMAND_CHECK_KEYS) {
+    const m = managed[key];
+    if (typeof m !== "string") continue;
+    const lockKey = `commandChecks${key[0].toUpperCase()}${key.slice(1)}`;
+    const resolved = floorValue(COMMAND_CHECK_ORDER, local[key], m, {
+      locked: locked.includes(lockKey)
+    });
+    if (CLASS_B_COMMAND_CHECKS.has(key) && resolved === "off") continue;
+    next[key] = resolved;
+  }
+  return next;
+}
+function applyManagedApprovers(local, managed) {
+  return {
+    ...local,
+    native: typeof managed.native === "boolean" ? managed.native : local.native,
+    browser: typeof managed.browser === "boolean" ? managed.browser : local.browser,
+    cloud: typeof managed.cloud === "boolean" ? managed.cloud : local.cloud,
+    terminal: typeof managed.terminal === "boolean" ? managed.terminal : local.terminal
+  };
+}
+var MODE_ORDER, EGRESS_MODE_ORDER, DLP_PII_ORDER, DLP_REVIEW_ACTION_ORDER, COMMAND_CHECK_ORDER, COMMAND_CHECK_KEYS, CLASS_B_COMMAND_CHECKS;
 var init_managed = __esm({
   "src/config/managed.ts"() {
     "use strict";
+    MODE_ORDER = ["observe", "audit", "standard", "strict"];
+    EGRESS_MODE_ORDER = ["off", "review", "block"];
+    DLP_PII_ORDER = ["off", "block"];
+    DLP_REVIEW_ACTION_ORDER = ["review", "block"];
+    COMMAND_CHECK_ORDER = ["off", "review", "block"];
+    COMMAND_CHECK_KEYS = [
+      "inlineExec",
+      "rmAdvisory",
+      "chmod",
+      "sqlDdl",
+      "evalDynamic",
+      "pipeChainHigh"
+    ];
+    CLASS_B_COMMAND_CHECKS = /* @__PURE__ */ new Set([
+      "evalDynamic",
+      "pipeChainHigh"
+    ]);
   }
 });
 
 // src/shields/build.ts
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function slug(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "rule";
+}
+function pathToRegexFragment(rawPath) {
+  const tail = rawPath.trim().replace(/^~[\\/]?/, "").replace(/^\$\{?HOME\}?[\\/]?/, "").replace(/^\/(?:home|Users)\/[^\\/]+[\\/]?/, "").replace(/^[A-Za-z]:[\\/]Users[\\/][^\\/]+[\\/]?/, "").replace(/^[\\/]+/, "").replace(/[\\/]+$/, "");
+  const segments = tail.split(/[\\/]+/).filter(Boolean).map(escapeRegex);
+  if (segments.length === 0) return "";
+  return `(^|${B})${segments.join(SEP)}(${B}|$)`;
+}
+function pathRules(rawPath, verdict, reason) {
+  const value = pathToRegexFragment(rawPath);
+  if (!value) return [];
+  const why = reason ?? `Accessing ${rawPath} is restricted by this shield`;
+  const s = slug(rawPath);
+  return [
+    {
+      name: `${verdict}-path-${s}-bash`,
+      tool: "bash",
+      conditions: [{ field: "command", op: "matches", value }],
+      verdict,
+      reason: why
+    },
+    // Keep the historical `-anytool` name for the file_path rule: the
+    // rule→shield attribution maps (Report SHIELDS panel) key on rule names.
+    {
+      name: `${verdict}-path-${s}-anytool`,
+      tool: "*",
+      conditions: [{ field: "file_path", op: "matches", value }],
+      verdict,
+      reason: why
+    },
+    {
+      name: `${verdict}-path-${s}-anytool-path`,
+      tool: "*",
+      conditions: [{ field: "path", op: "matches", value }],
+      verdict,
+      reason: why
+    },
+    {
+      name: `${verdict}-path-${s}-anytool-pattern`,
+      tool: "*",
+      conditions: [{ field: "pattern", op: "matches", value }],
+      verdict,
+      reason: why
+    }
+  ];
+}
+var B, SEP;
 var init_build = __esm({
   "src/shields/build.ts"() {
     "use strict";
     init_dist();
+    B = "[\\s/\\\\]";
+    SEP = "[/\\\\]";
   }
 });
 
 // src/auth/trusted-hosts.ts
+function normalizeHost(raw) {
+  return raw.toLowerCase().replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/^[^@]+@/, "").replace(/:\d+$/, "");
+}
 var init_trusted_hosts = __esm({
   "src/auth/trusted-hosts.ts"() {
     "use strict";
@@ -2575,7 +2787,633 @@ var init_trusted_hosts = __esm({
 });
 
 // src/config/index.ts
-var DANGEROUS_WORDS, DEFAULT_CONFIG, CACHE_LOG_REARM_MS;
+import fs4 from "fs";
+import path4 from "path";
+import os4 from "os";
+function getCredentials() {
+  const DEFAULT_API_URL = "https://api.node9.ai/api/v1/intercept";
+  if (process.env.NODE9_API_KEY) {
+    return {
+      apiKey: process.env.NODE9_API_KEY,
+      apiUrl: process.env.NODE9_API_URL || DEFAULT_API_URL
+    };
+  }
+  try {
+    const credPath = path4.join(os4.homedir(), ".node9", "credentials.json");
+    if (fs4.existsSync(credPath)) {
+      const creds = JSON.parse(fs4.readFileSync(credPath, "utf-8"));
+      const profileName = process.env.NODE9_PROFILE || "default";
+      const profile = creds[profileName];
+      if (profile?.apiKey) {
+        return {
+          apiKey: profile.apiKey,
+          apiUrl: profile.apiUrl || DEFAULT_API_URL,
+          localOnly: profile.localOnly === true || profileName !== "default"
+        };
+      }
+      if (creds.apiKey) {
+        return {
+          apiKey: creds.apiKey,
+          apiUrl: creds.apiUrl || DEFAULT_API_URL,
+          localOnly: creds.localOnly === true
+        };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function readRulesCacheResilient(cacheFile) {
+  let existed = false;
+  let sawReadError = false;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    let content;
+    try {
+      content = fs4.readFileSync(cacheFile, "utf-8");
+      existed = true;
+    } catch (err) {
+      if (err.code === "ENOENT") return {};
+      sawReadError = true;
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(content);
+      lastParsedRulesCache = parsed;
+      return parsed;
+    } catch {
+    }
+  }
+  if (existed || sawReadError) {
+    const backup = path4.join(path4.dirname(cacheFile), "rules-cache.last-good.json");
+    if (backup !== cacheFile) {
+      try {
+        const raw = JSON.parse(fs4.readFileSync(backup, "utf-8"));
+        logCacheReadIssue(cacheFile, "RULES_CACHE_CORRUPT_USED_BACKUP");
+        lastParsedRulesCache = raw;
+        return raw;
+      } catch {
+      }
+    }
+    if (lastParsedRulesCache) {
+      logCacheReadIssue(cacheFile, "RULES_CACHE_USED_MEMORY");
+      return lastParsedRulesCache;
+    }
+    logCacheReadIssue(cacheFile, "RULES_CACHE_UNREADABLE");
+  }
+  return {};
+}
+function logCacheReadIssue(cacheFile, kind) {
+  const now = Date.now();
+  if (now - cacheReadLastLoggedAt < CACHE_LOG_REARM_MS) return;
+  cacheReadLastLoggedAt = now;
+  try {
+    fs4.appendFileSync(
+      path4.join(os4.homedir(), ".node9", "hook-debug.log"),
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] ${kind} ${cacheFile}
+`
+    );
+  } catch {
+  }
+}
+function getConfig(cwd) {
+  if (!cwd && cachedConfig) return cachedConfig;
+  const globalPath = path4.join(os4.homedir(), ".node9", "config.json");
+  const projectPath = path4.join(cwd ?? process.cwd(), "node9.config.json");
+  const globalConfig = tryLoadConfig(globalPath);
+  const projectConfig = tryLoadConfig(projectPath);
+  const mergedSettings = {
+    ...DEFAULT_CONFIG.settings,
+    approvers: { ...DEFAULT_CONFIG.settings.approvers },
+    shipper: { ...DEFAULT_CONFIG.settings.shipper }
+  };
+  const mergedPolicy = {
+    sandboxPaths: [...DEFAULT_CONFIG.policy.sandboxPaths],
+    dangerousWords: [...DEFAULT_CONFIG.policy.dangerousWords],
+    ignoredTools: [...DEFAULT_CONFIG.policy.ignoredTools],
+    toolInspection: { ...DEFAULT_CONFIG.policy.toolInspection },
+    smartRules: [...DEFAULT_CONFIG.policy.smartRules],
+    dlp: { ...DEFAULT_CONFIG.policy.dlp },
+    egress: {
+      ...DEFAULT_CONFIG.policy.egress,
+      allow: [...DEFAULT_CONFIG.policy.egress.allow],
+      deny: [...DEFAULT_CONFIG.policy.egress.deny]
+    },
+    loopDetection: { ...DEFAULT_CONFIG.policy.loopDetection },
+    injectionScan: {
+      ...DEFAULT_CONFIG.policy.injectionScan,
+      allow: [...DEFAULT_CONFIG.policy.injectionScan.allow]
+    },
+    skillPinning: {
+      ...DEFAULT_CONFIG.policy.skillPinning,
+      roots: [...DEFAULT_CONFIG.policy.skillPinning.roots]
+    },
+    // Left empty on purpose: the local file is read fresh at policy-eval time
+    // (getCachedHosts via isTrustedHost), NOT snapshotted into the frozen config
+    // here. A managed list fills this below and flips trustedHostsManaged.
+    trustedHosts: [],
+    trustedHostsManaged: false,
+    appPermissions: {},
+    managedJailPaths: []
+  };
+  const mergedEnvironments = { ...DEFAULT_CONFIG.environments };
+  const rank = (v) => {
+    const i = COMMAND_CHECK_ORDER.indexOf(v ?? "");
+    return i === -1 ? 1 : i;
+  };
+  const pr2Creds = getCredentials();
+  const keyed = !!pr2Creds?.apiKey && pr2Creds.localOnly !== true;
+  const applyLayer = (source, isProject = false, isCloud = false) => {
+    if (!source) return;
+    const s = source.settings || {};
+    const p = source.policy || {};
+    if (s.autoStartDaemon !== void 0) mergedSettings.autoStartDaemon = s.autoStartDaemon;
+    if (s.enableHookLogDebug !== void 0)
+      mergedSettings.enableHookLogDebug = s.enableHookLogDebug;
+    if (s.shipper) mergedSettings.shipper = { ...mergedSettings.shipper, ...s.shipper };
+    if (s.cloudSyncIntervalHours !== void 0)
+      mergedSettings.cloudSyncIntervalHours = s.cloudSyncIntervalHours;
+    if (s.mcpAutoWrap !== void 0) mergedSettings.mcpAutoWrap = s.mcpAutoWrap === true;
+    if (s.mcpReconcileIntervalMinutes !== void 0)
+      mergedSettings.mcpReconcileIntervalMinutes = s.mcpReconcileIntervalMinutes;
+    if (s.mcpStaleAfterDays !== void 0) mergedSettings.mcpStaleAfterDays = s.mcpStaleAfterDays;
+    if (s.hud !== void 0) mergedSettings.hud = { ...mergedSettings.hud, ...s.hud };
+    if (keyed && !isCloud) return;
+    if (s.mode !== void 0) mergedSettings.mode = s.mode;
+    if (s.approvers) mergedSettings.approvers = { ...mergedSettings.approvers, ...s.approvers };
+    if (s.approvalTimeoutMs !== void 0) mergedSettings.approvalTimeoutMs = s.approvalTimeoutMs;
+    if (s.approvalTimeoutSeconds !== void 0 && s.approvalTimeoutMs === void 0)
+      mergedSettings.approvalTimeoutMs = s.approvalTimeoutSeconds * 1e3;
+    if (s.environment !== void 0) mergedSettings.environment = s.environment;
+    if (s.reviewChannel !== void 0) mergedSettings.reviewChannel = s.reviewChannel;
+    if (s.mcpAllowWeakening !== void 0) mergedSettings.mcpAllowWeakening = s.mcpAllowWeakening;
+    if (p.sandboxPaths) mergedPolicy.sandboxPaths.push(...p.sandboxPaths);
+    if (p.ignoredTools) mergedPolicy.ignoredTools.push(...p.ignoredTools);
+    if (p.dangerousWords) mergedPolicy.dangerousWords = [...p.dangerousWords];
+    if (p.toolInspection)
+      mergedPolicy.toolInspection = { ...mergedPolicy.toolInspection, ...p.toolInspection };
+    if (p.smartRules) {
+      const defaultBlocks = mergedPolicy.smartRules.filter((r) => r.verdict === "block");
+      const defaultNonBlocks = mergedPolicy.smartRules.filter((r) => r.verdict !== "block");
+      const localRules = p.smartRules.map(({ pinned: _pinned, ...r }) => r);
+      const userRuleNames = new Set(localRules.filter((r) => r.name).map((r) => r.name));
+      const filteredBlocks = defaultBlocks.filter((r) => !r.name || !userRuleNames.has(r.name));
+      const filteredNonBlocks = defaultNonBlocks.filter(
+        (r) => !r.name || !userRuleNames.has(r.name)
+      );
+      mergedPolicy.smartRules = [...filteredBlocks, ...localRules, ...filteredNonBlocks];
+    }
+    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;
+      if (d.pii !== void 0) mergedPolicy.dlp.pii = d.pii;
+      if (d.reviewAction !== void 0) mergedPolicy.dlp.reviewAction = d.reviewAction;
+    }
+    if (p.commandChecks && typeof p.commandChecks === "object") {
+      const src = p.commandChecks;
+      const cc2 = {
+        ...mergedPolicy.commandChecks
+      };
+      for (const k of ["inlineExec", "rmAdvisory", "chmod", "sqlDdl"]) {
+        const v = src[k];
+        if (v !== "off" && v !== "review" && v !== "block") continue;
+        if (isProject && rank(v) < rank(cc2[k])) continue;
+        cc2[k] = v;
+      }
+      for (const k of ["evalDynamic", "pipeChainHigh"]) {
+        const v = src[k];
+        if (v === "review" || v === "block") cc2[k] = v;
+      }
+      if (Object.keys(cc2).length > 0) mergedPolicy.commandChecks = cc2;
+    }
+    if (p.egress) {
+      const e = p.egress;
+      if (e.enabled !== void 0 && !(isProject && e.enabled === false))
+        mergedPolicy.egress.enabled = e.enabled;
+      if (e.mode !== void 0) {
+        const weaker = isProject && rank(e.mode) < rank(mergedPolicy.egress.mode);
+        if (!weaker) {
+          mergedPolicy.egress.mode = e.mode;
+          egressModeUserSet = true;
+        }
+      }
+      if (Array.isArray(e.allow) && (!isProject || !egressAllowUserSet)) {
+        mergedPolicy.egress.allow.push(...e.allow);
+      }
+      if (Array.isArray(e.allow) && !isProject) egressAllowUserSet = true;
+      if (Array.isArray(e.deny)) mergedPolicy.egress.deny.push(...e.deny);
+      if (e.allowPrivate !== void 0 && !(isProject && e.allowPrivate === true))
+        mergedPolicy.egress.allowPrivate = e.allowPrivate;
+    }
+    if (p.loopDetection) {
+      const ld = p.loopDetection;
+      if (ld.enabled !== void 0) mergedPolicy.loopDetection.enabled = ld.enabled;
+      if (ld.threshold !== void 0) mergedPolicy.loopDetection.threshold = ld.threshold;
+      if (ld.windowSeconds !== void 0)
+        mergedPolicy.loopDetection.windowSeconds = ld.windowSeconds;
+    }
+    if (p.injectionScan && typeof p.injectionScan === "object") {
+      const is = p.injectionScan;
+      if (is.enabled !== void 0) mergedPolicy.injectionScan.enabled = is.enabled;
+      if (is.minConfidence !== void 0)
+        mergedPolicy.injectionScan.minConfidence = is.minConfidence;
+      if (Array.isArray(is.allow)) {
+        for (const t of is.allow) {
+          if (typeof t === "string" && t.length > 0) mergedPolicy.injectionScan.allow.push(t);
+        }
+      }
+    }
+    if (p.skillPinning && typeof p.skillPinning === "object") {
+      const sp = p.skillPinning;
+      if (sp.enabled !== void 0) mergedPolicy.skillPinning.enabled = sp.enabled;
+      if (sp.mode !== void 0) mergedPolicy.skillPinning.mode = sp.mode;
+      if (Array.isArray(sp.roots)) {
+        for (const r of sp.roots) {
+          if (typeof r === "string" && r.length > 0) mergedPolicy.skillPinning.roots.push(r);
+        }
+      }
+    }
+    const envs = source.environments || {};
+    for (const [envName, envConfig] of Object.entries(envs)) {
+      if (envConfig && typeof envConfig === "object") {
+        const ec = envConfig;
+        mergedEnvironments[envName] = {
+          ...mergedEnvironments[envName],
+          // Validate field types before merging — do not blindly spread user input
+          ...typeof ec.requireApproval === "boolean" ? { requireApproval: ec.requireApproval } : {}
+        };
+      }
+    }
+  };
+  let egressModeUserSet = false;
+  let egressAllowUserSet = false;
+  applyLayer(globalConfig);
+  applyLayer(
+    projectConfig,
+    /* isProject */
+    true
+  );
+  if (keyed) {
+    mergedSettings.approvers = { ...mergedSettings.approvers, cloud: true };
+  }
+  let cloudManagedShields = [];
+  const managedCommandCheckKeys = /* @__PURE__ */ new Set();
+  const lockedCommandCheckKeys = /* @__PURE__ */ new Set();
+  let modeCloudControlled = false;
+  let modeCloudStaged = false;
+  let cloudMandatesEnforcement = false;
+  let cloudMandatesAppPerm = false;
+  {
+    const cacheFile = path4.join(os4.homedir(), ".node9", "rules-cache.json");
+    try {
+      const raw = readRulesCacheResilient(cacheFile);
+      if (Array.isArray(raw.rules) && raw.rules.length > 0) {
+        applyLayer(
+          { policy: { smartRules: raw.rules } },
+          false,
+          /* isCloud */
+          true
+        );
+      }
+      if (Array.isArray(raw.shields)) {
+        cloudManagedShields = raw.shields.filter((s) => typeof s === "string");
+      }
+      if (raw.managedConfig && typeof raw.managedConfig === "object") {
+        const mc = raw.managedConfig;
+        const locked = Array.isArray(mc.locked) ? mc.locked.filter((f) => typeof f === "string") : [];
+        if (typeof mc.mode === "string") {
+          if (keyed) {
+            if (["observe", "audit", "standard", "strict"].includes(mc.mode)) {
+              mergedSettings.mode = mc.mode;
+            }
+          } else {
+            mergedSettings.mode = resolveManagedMode(
+              mergedSettings.mode,
+              mc.mode,
+              locked.includes("mode")
+            );
+          }
+        }
+        if (typeof mc.mode === "string" || locked.includes("mode")) {
+          modeCloudControlled = true;
+        }
+        if (mc.egress && typeof mc.egress === "object") {
+          const hosts = (v) => Array.isArray(v) ? v.filter((h) => typeof h === "string") : void 0;
+          if (keyed) {
+            const e = mc.egress;
+            if (typeof e.enabled === "boolean") mergedPolicy.egress.enabled = e.enabled;
+            if (e.mode === "off" || e.mode === "review" || e.mode === "block")
+              mergedPolicy.egress.mode = e.mode;
+            const allow = hosts(e.allow);
+            if (allow) mergedPolicy.egress.allow = allow;
+            const deny = hosts(e.deny);
+            if (deny) mergedPolicy.egress.deny = deny;
+            if (typeof e.allowPrivate === "boolean")
+              mergedPolicy.egress.allowPrivate = e.allowPrivate;
+          } else {
+            mergedPolicy.egress = applyManagedEgress(
+              mergedPolicy.egress,
+              {
+                enabled: typeof mc.egress.enabled === "boolean" ? mc.egress.enabled : void 0,
+                mode: typeof mc.egress.mode === "string" ? mc.egress.mode : void 0,
+                allow: hosts(mc.egress.allow),
+                deny: hosts(mc.egress.deny),
+                allowPrivate: typeof mc.egress.allowPrivate === "boolean" ? mc.egress.allowPrivate : void 0
+              },
+              locked,
+              egressModeUserSet
+            );
+          }
+        }
+        if (mc.dlp && typeof mc.dlp === "object") {
+          if (keyed) {
+            if (typeof mc.dlp.enabled === "boolean") mergedPolicy.dlp.enabled = mc.dlp.enabled;
+            if (mc.dlp.pii === "off" || mc.dlp.pii === "block") mergedPolicy.dlp.pii = mc.dlp.pii;
+            if (mc.dlp.reviewAction === "review" || mc.dlp.reviewAction === "block")
+              mergedPolicy.dlp.reviewAction = mc.dlp.reviewAction;
+          } else {
+            mergedPolicy.dlp = applyManagedDlp(
+              mergedPolicy.dlp,
+              {
+                enabled: typeof mc.dlp.enabled === "boolean" ? mc.dlp.enabled : void 0,
+                pii: typeof mc.dlp.pii === "string" ? mc.dlp.pii : void 0,
+                reviewAction: mc.dlp.reviewAction === "review" || mc.dlp.reviewAction === "block" ? mc.dlp.reviewAction : void 0
+              },
+              locked
+            );
+          }
+        }
+        if (mc.commandChecks && typeof mc.commandChecks === "object") {
+          if (keyed) {
+            const src = mc.commandChecks;
+            const next = { ...mergedPolicy.commandChecks ?? {} };
+            for (const key of COMMAND_CHECK_KEYS) {
+              const val = src[key];
+              if (val !== "off" && val !== "review" && val !== "block") continue;
+              if (val === "off" && CLASS_B_COMMAND_CHECKS.has(key)) continue;
+              next[key] = val;
+            }
+            mergedPolicy.commandChecks = next;
+          } else {
+            mergedPolicy.commandChecks = applyManagedCommandChecks(
+              mergedPolicy.commandChecks ?? {},
+              mc.commandChecks,
+              locked
+            );
+          }
+          for (const [key, val] of Object.entries(mc.commandChecks)) {
+            if (typeof val !== "string") continue;
+            managedCommandCheckKeys.add(key);
+            const lockKey = `commandChecks${key[0].toUpperCase()}${key.slice(1)}`;
+            if (locked.includes(lockKey)) lockedCommandCheckKeys.add(key);
+          }
+        }
+        if (mc.approvers && typeof mc.approvers === "object") {
+          const bool = (v) => typeof v === "boolean" ? v : void 0;
+          mergedSettings.approvers = applyManagedApprovers(mergedSettings.approvers, {
+            native: bool(mc.approvers.native),
+            browser: bool(mc.approvers.browser),
+            cloud: bool(mc.approvers.cloud),
+            terminal: bool(mc.approvers.terminal)
+          });
+        }
+        if (mc.reviewChannel === "ask" || mc.reviewChannel === "approver") {
+          mergedSettings.reviewChannel = mc.reviewChannel;
+          mergedSettings.reviewChannelManaged = true;
+        }
+        if (typeof mc.approvalTimeoutMs === "number" && mc.approvalTimeoutMs > 0) {
+          mergedSettings.approvalTimeoutMs = mc.approvalTimeoutMs;
+        }
+        if (mc.injectionScan && typeof mc.injectionScan === "object") {
+          const i = mc.injectionScan;
+          const cur = mergedPolicy.injectionScan;
+          mergedPolicy.injectionScan = {
+            enabled: typeof i.enabled === "boolean" ? i.enabled : cur.enabled,
+            minConfidence: i.minConfidence === "high" || i.minConfidence === "medium" ? i.minConfidence : cur.minConfidence,
+            allow: Array.isArray(i.allow) ? i.allow.filter((x) => typeof x === "string") : cur.allow
+          };
+        }
+        if (mc.loopDetection && typeof mc.loopDetection === "object") {
+          const l = mc.loopDetection;
+          const cur = mergedPolicy.loopDetection;
+          mergedPolicy.loopDetection = {
+            enabled: typeof l.enabled === "boolean" ? l.enabled : cur.enabled,
+            threshold: typeof l.threshold === "number" && Number.isFinite(l.threshold) ? l.threshold : cur.threshold,
+            windowSeconds: typeof l.windowSeconds === "number" && Number.isFinite(l.windowSeconds) ? l.windowSeconds : cur.windowSeconds
+          };
+        }
+        if (mc.skillPinning && typeof mc.skillPinning === "object") {
+          const sk = mc.skillPinning;
+          const cur = mergedPolicy.skillPinning;
+          mergedPolicy.skillPinning = {
+            enabled: typeof sk.enabled === "boolean" ? sk.enabled : cur.enabled,
+            mode: sk.mode === "block" || sk.mode === "warn" ? sk.mode : cur.mode,
+            roots: Array.isArray(sk.roots) ? sk.roots.filter((x) => typeof x === "string") : cur.roots
+          };
+        }
+        if (Array.isArray(mc.jailPaths)) {
+          for (const jp of mc.jailPaths) {
+            const path12 = typeof jp?.path === "string" ? jp.path.trim() : "";
+            if (!path12) continue;
+            const verdict = jp?.verdict === "review" ? "review" : "block";
+            for (const r of pathRules(path12, verdict, "org-managed jail")) {
+              mergedPolicy.smartRules.push({ ...r, name: `org:${r.name}` });
+            }
+            mergedPolicy.managedJailPaths.push({ path: path12, verdict });
+          }
+        }
+        if (Array.isArray(mc.trustedHosts)) {
+          mergedPolicy.trustedHostsManaged = true;
+          mergedPolicy.trustedHosts = mc.trustedHosts.filter((h) => typeof h === "string").map((h) => normalizeHost(h));
+        }
+        if (mc.appPermissions && typeof mc.appPermissions === "object" && !Array.isArray(mc.appPermissions)) {
+          const coerced = {};
+          for (const [srv, tools] of Object.entries(mc.appPermissions)) {
+            if (!tools || typeof tools !== "object" || Array.isArray(tools)) continue;
+            const m = {};
+            for (const [tool, d] of Object.entries(tools)) {
+              if (d === "allow" || d === "review" || d === "block") m[tool] = d;
+            }
+            if (Object.keys(m).length) coerced[srv] = m;
+          }
+          mergedPolicy.appPermissions = coerced;
+          cloudMandatesAppPerm = Object.values(coerced).some(
+            (tools) => Object.values(tools).some((d) => d === "block" || d === "review")
+          );
+        }
+        const on = (v) => !!v && typeof v === "object" && v.enabled === true;
+        cloudMandatesEnforcement = cloudMandatesAppPerm || Array.isArray(mc.jailPaths) && mc.jailPaths.some((jp) => typeof jp?.path === "string" && jp.path.trim() !== "") || on(mc.egress) || on(mc.dlp) || on(mc.injectionScan) || on(mc.skillPinning) || on(mc.loopDetection) || !!mc.commandChecks && typeof mc.commandChecks === "object" && Object.values(mc.commandChecks).some(
+          (v) => typeof v === "string" && v !== "off"
+        );
+      }
+      if (raw.panicMode === true) {
+        mergedSettings.panicMode = true;
+      }
+      if (raw.shadowMode === true) {
+        mergedSettings.mode = "observe";
+        modeCloudStaged = true;
+      }
+    } catch {
+    }
+  }
+  const shieldOverrides = readShieldOverrides();
+  if (keyed) mergedPolicy.trustedHostsManaged = true;
+  const activeShieldNames = keyed ? [...new Set(cloudManagedShields)] : [.../* @__PURE__ */ new Set([...readActiveShields(), ...cloudManagedShields])];
+  const appliedShields = [];
+  const cloudManagedSet = new Set(cloudManagedShields);
+  for (const shieldName of activeShieldNames) {
+    const isCloudMandated = cloudManagedSet.has(shieldName);
+    const shield = isCloudMandated ? BUILTIN_SHIELDS[shieldName] : getShield(shieldName);
+    if (!shield) continue;
+    appliedShields.push(shieldName);
+    const existingRuleNames = new Set(mergedPolicy.smartRules.map((r) => r.name));
+    const ruleOverrides = isCloudMandated ? {} : shieldOverrides[shieldName] ?? {};
+    for (const rule of shield.smartRules) {
+      const collides = rule.name ? existingRuleNames.has(rule.name) : false;
+      if (isCloudMandated) {
+        if (collides) {
+          mergedPolicy.smartRules = mergedPolicy.smartRules.filter((r) => r.name !== rule.name);
+        }
+        mergedPolicy.smartRules.push({ ...rule, pinned: true });
+      } else if (!collides) {
+        const overrideVerdict = rule.name ? ruleOverrides[rule.name] : void 0;
+        mergedPolicy.smartRules.push(
+          overrideVerdict !== void 0 ? { ...rule, verdict: overrideVerdict } : rule
+        );
+      }
+    }
+    const existingWords = new Set(mergedPolicy.dangerousWords);
+    for (const word of shield.dangerousWords) {
+      if (!existingWords.has(word)) mergedPolicy.dangerousWords.push(word);
+    }
+  }
+  mergedPolicy.appliedShields = appliedShields.sort();
+  const existingAdvisoryNames = new Set(mergedPolicy.smartRules.map((r) => r.name));
+  const cc = mergedPolicy.commandChecks ?? {};
+  const advisoryKnobKey = (name) => {
+    if (name === "review-rm") return "rmAdvisory";
+    if (name?.endsWith("-sql")) return "sqlDdl";
+    return void 0;
+  };
+  for (const rule of ADVISORY_SMART_RULES) {
+    const knobKey = rule.verdict === "review" ? advisoryKnobKey(rule.name) : void 0;
+    const knob = knobKey ? cc[knobKey] : void 0;
+    if (knob === "off") continue;
+    const managed = knobKey ? managedCommandCheckKeys.has(knobKey) : false;
+    const locked = knobKey ? lockedCommandCheckKeys.has(knobKey) : false;
+    const twin = existingAdvisoryNames.has(rule.name) ? mergedPolicy.smartRules.find((r) => r.name === rule.name) : void 0;
+    const knobVerdict = knob === "block" ? "block" : rule.verdict;
+    if (!managed) {
+      if (!twin) mergedPolicy.smartRules.push({ ...rule, verdict: knobVerdict });
+      continue;
+    }
+    const effective = locked ? knobVerdict : strictestOf(VERDICT_ORDER, knobVerdict, twin?.verdict) ?? knobVerdict;
+    if (twin) {
+      mergedPolicy.smartRules = mergedPolicy.smartRules.filter((r) => r.name !== rule.name);
+    }
+    const injected = { ...rule, verdict: effective, pinned: true };
+    if (rule.name === "review-rm" && effective !== "block") {
+      injected.conditions = [
+        ...rule.conditions ?? [],
+        { field: "command", op: "notMatches", value: RM_SAFE_PATH_PATTERN }
+      ];
+      injected.conditionMode = "all";
+    }
+    mergedPolicy.smartRules.push(injected);
+  }
+  const envMode = process.env.NODE9_MODE;
+  if (envMode && !modeCloudControlled && // PR-2: one listening point includes the env var — a keyed machine's
+  // mode comes from the workspace (or the shipped default), never the shell.
+  !keyed && ["observe", "audit", "standard", "strict"].includes(envMode)) {
+    mergedSettings.mode = envMode;
+  }
+  if ((cloudManagedShields.length > 0 || cloudMandatesEnforcement) && !modeCloudControlled && !modeCloudStaged && (mergedSettings.mode === "observe" || mergedSettings.mode === "audit")) {
+    mergedSettings.mode = "standard";
+  }
+  const managedFloorActive = cloudManagedShields.length > 0 || cloudMandatesEnforcement || modeCloudControlled && mergedSettings.mode === "strict";
+  if (modeCloudControlled && mergedSettings.mode === "strict") {
+    for (const name of Object.keys(mergedEnvironments)) {
+      if (mergedEnvironments[name]?.requireApproval === false) {
+        const cleaned = { ...mergedEnvironments[name] };
+        delete cleaned.requireApproval;
+        mergedEnvironments[name] = cleaned;
+      }
+    }
+  }
+  if (managedFloorActive) {
+    mergedPolicy.ignoredTools = [...DEFAULT_CONFIG.policy.ignoredTools];
+    mergedPolicy.sandboxPaths = [...DEFAULT_CONFIG.policy.sandboxPaths];
+  }
+  mergedPolicy.sandboxPaths = [...new Set(mergedPolicy.sandboxPaths)];
+  mergedPolicy.dangerousWords = [...new Set(mergedPolicy.dangerousWords)];
+  mergedPolicy.ignoredTools = [...new Set(mergedPolicy.ignoredTools)];
+  mergedPolicy.skillPinning.roots = [...new Set(mergedPolicy.skillPinning.roots)];
+  const result = {
+    settings: mergedSettings,
+    policy: mergedPolicy,
+    environments: mergedEnvironments,
+    // PR-2 — the one truth introspection reads: which of the two working
+    // modes this machine is in. 'workspace' = keyed, policy from the cloud;
+    // 'local' = the local stack (incl. --local / named-profile keys).
+    policySource: keyed ? "workspace" : "local"
+  };
+  if (!cwd) cachedConfig = result;
+  return result;
+}
+function tryLoadConfig(filePath) {
+  if (!fs4.existsSync(filePath)) return null;
+  let raw;
+  try {
+    raw = JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(
+      `
+\u26A0\uFE0F  Node9: Failed to parse ${filePath}
+   ${msg}
+   \u2192 Using default config
+
+`
+    );
+    return null;
+  }
+  const SUPPORTED_VERSION = "1.0";
+  const SUPPORTED_MAJOR = SUPPORTED_VERSION.split(".")[0];
+  const fileVersion = raw?.version;
+  if (fileVersion !== void 0) {
+    const vStr = String(fileVersion);
+    const fileMajor = vStr.split(".")[0];
+    if (fileMajor !== SUPPORTED_MAJOR) {
+      process.stderr.write(
+        `
+\u274C  Node9: Config at ${filePath} has version "${vStr}" \u2014 major version is incompatible with this release (expected "${SUPPORTED_VERSION}"). Config will not be loaded.
+
+`
+      );
+      return null;
+    } else if (vStr !== SUPPORTED_VERSION) {
+      process.stderr.write(
+        `
+\u26A0\uFE0F  Node9: Config at ${filePath} declares version "${vStr}" \u2014 expected "${SUPPORTED_VERSION}". Continuing with best-effort parsing.
+
+`
+      );
+    }
+  }
+  const { sanitized, error } = sanitizeConfig(raw);
+  if (error) {
+    process.stderr.write(
+      `
+\u26A0\uFE0F  Node9: Invalid config at ${filePath}:
+${error.replace("Invalid config:\n", "")}
+   \u2192 Invalid fields ignored, using defaults for those keys
+
+`
+    );
+  }
+  return sanitized;
+}
+var DANGEROUS_WORDS, DEFAULT_CONFIG, RM_SAFE_PATH_PATTERN, VERDICT_ORDER, ADVISORY_SMART_RULES, cachedConfig, lastParsedRulesCache, CACHE_LOG_REARM_MS, cacheReadLastLoggedAt;
 var init_config = __esm({
   "src/config/index.ts"() {
     "use strict";
@@ -2593,10 +3431,18 @@ var init_config = __esm({
     ];
     DEFAULT_CONFIG = {
       version: "1.0",
+      policySource: "local",
       settings: {
         mode: "standard",
         autoStartDaemon: true,
-        enableHookLogDebug: true,
+        // Off by default: this is a DEBUG facility, not part of the product's job.
+        // When on, every tool call appends a row to ~/.node9/hook-debug.log, which
+        // has no production reader and no size ceiling. Turn it on deliberately
+        // (this setting, or NODE9_DEBUG=1) while investigating something.
+        // Error breadcrumbs written from catch blocks are NOT gated by this and
+        // keep working when it is off — see CLAUDE.md "Always write to
+        // hook-debug.log in catch blocks that guard audit trail".
+        enableHookLogDebug: false,
         approvalTimeoutMs: 12e4,
         // 120-second auto-deny timeout
         flightRecorder: true,
@@ -2780,7 +3626,68 @@ var init_config = __esm({
       },
       environments: {}
     };
+    RM_SAFE_PATH_PATTERN = "(node_modules|\\bdist\\b|\\.next|\\bcoverage\\b|\\.cache|\\btmp\\b|\\btemp\\b|\\.DS_Store)(\\/|\\s|$)";
+    VERDICT_ORDER = ["allow", "review", "block"];
+    ADVISORY_SMART_RULES = [
+      // ── rm safety ─────────────────────────────────────────────────────────────
+      // tool: '*' so they cover bash, shell, run_shell_command, and Gemini's Shell.
+      // Pattern '(^|&&|\|\||;)\s*rm\b' matches rm as a shell command (including in
+      // chained commands like 'cat foo && rm bar') but avoids false-positives on 'docker rm'.
+      {
+        name: "allow-rm-safe-paths",
+        tool: "*",
+        conditionMode: "all",
+        conditions: [
+          { field: "command", op: "matches", value: "(^|&&|\\|\\||;)\\s*rm\\b" },
+          { field: "command", op: "matches", value: RM_SAFE_PATH_PATTERN }
+        ],
+        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",
+        description: "The AI wants to delete files. Unlike moving to trash, rm is permanent \u2014 the files cannot be recovered without a backup."
+      },
+      // ── SQL safety (Safe by Default) ──────────────────────────────────────────
+      // These rules fire when an AI calls a database tool directly (e.g. MCP postgres,
+      // mcp__postgres__query) with a destructive SQL statement in the 'sql' field.
+      // The postgres shield upgrades these from 'review' → 'block' for stricter teams;
+      // without a shield, users still get a human-approval gate on every destructive op.
+      {
+        name: "review-drop-table-sql",
+        tool: "*",
+        conditions: [{ field: "sql", op: "matches", value: "DROP\\s+TABLE", flags: "i" }],
+        verdict: "review",
+        reason: "DROP TABLE is irreversible \u2014 enable the postgres shield to block instead",
+        description: "The AI wants to drop a database table. This permanently deletes the table and all its data \u2014 there is no undo."
+      },
+      {
+        name: "review-truncate-sql",
+        tool: "*",
+        conditions: [{ field: "sql", op: "matches", value: "TRUNCATE\\s+TABLE", flags: "i" }],
+        verdict: "review",
+        reason: "TRUNCATE removes all rows \u2014 enable the postgres shield to block instead",
+        description: "The AI wants to truncate a database table, which instantly deletes every row. The table structure remains but all data is gone."
+      },
+      {
+        name: "review-drop-column-sql",
+        tool: "*",
+        conditions: [
+          { field: "sql", op: "matches", value: "ALTER\\s+TABLE.*DROP\\s+COLUMN", flags: "i" }
+        ],
+        verdict: "review",
+        reason: "DROP COLUMN is irreversible \u2014 enable the postgres shield to block instead",
+        description: "The AI wants to drop a column from a database table. This permanently removes the column and all its data from every row."
+      }
+    ];
+    cachedConfig = null;
+    lastParsedRulesCache = null;
     CACHE_LOG_REARM_MS = 5 * 60 * 1e3;
+    cacheReadLastLoggedAt = 0;
   }
 });
 
@@ -2792,28 +3699,28 @@ var init_hasher = __esm({
 });
 
 // src/audit/index.ts
-import path4 from "path";
-import os4 from "os";
+import path5 from "path";
+import os5 from "os";
 var LOCAL_AUDIT_LOG, HOOK_DEBUG_LOG;
 var init_audit = __esm({
   "src/audit/index.ts"() {
     "use strict";
     init_hasher();
-    LOCAL_AUDIT_LOG = path4.join(os4.homedir(), ".node9", "audit.log");
-    HOOK_DEBUG_LOG = path4.join(os4.homedir(), ".node9", "hook-debug.log");
+    LOCAL_AUDIT_LOG = path5.join(os5.homedir(), ".node9", "audit.log");
+    HOOK_DEBUG_LOG = path5.join(os5.homedir(), ".node9", "hook-debug.log");
   }
 });
 
 // src/pricing/litellm.ts
-import fs4 from "fs";
-import path5 from "path";
-import os5 from "os";
+import fs5 from "fs";
+import path6 from "path";
+import os6 from "os";
 function normalizeModel(raw) {
   return raw.replace(/-\d{8}$/, "").toLowerCase();
 }
 function readCache() {
   try {
-    const raw = JSON.parse(fs4.readFileSync(CACHE_FILE(), "utf-8"));
+    const raw = JSON.parse(fs5.readFileSync(CACHE_FILE(), "utf-8"));
     if (typeof raw.fetchedAt !== "string" || typeof raw.prices !== "object" || raw.prices === null) {
       return null;
     }
@@ -2827,18 +3734,18 @@ function readCache() {
 function writeCache(prices) {
   try {
     const target = CACHE_FILE();
-    const dir = path5.dirname(target);
-    if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
+    const dir = path6.dirname(target);
+    if (!fs5.existsSync(dir)) fs5.mkdirSync(dir, { recursive: true });
     const tmp = target + ".tmp";
     const body = {
       fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
       prices
     };
-    fs4.writeFileSync(tmp, JSON.stringify(body) + "\n", "utf-8");
-    fs4.renameSync(tmp, target);
+    fs5.writeFileSync(tmp, JSON.stringify(body) + "\n", "utf-8");
+    fs5.renameSync(tmp, target);
   } catch (err) {
     try {
-      fs4.appendFileSync(
+      fs5.appendFileSync(
         HOOK_DEBUG_LOG,
         `[pricing] cache write failed: ${err.message}
 `
@@ -2982,7 +3889,7 @@ var init_litellm = __esm({
       "gemini-2.0-flash": [75e-9, 3e-7, 0, 0],
       "gemini-1.5-pro": [125e-8, 5e-6, 0, 0]
     };
-    CACHE_FILE = () => path5.join(os5.homedir(), ".node9", "model-pricing.json");
+    CACHE_FILE = () => path6.join(os6.homedir(), ".node9", "model-pricing.json");
     TTL_MS = 24 * 60 * 60 * 1e3;
     memCache = null;
     memCacheAt = 0;
@@ -3124,9 +4031,9 @@ var init_scan_watermark = __esm({
 });
 
 // src/cli/aggregate/report-audit.ts
-import fs5 from "fs";
-import os6 from "os";
-import path6 from "path";
+import fs6 from "fs";
+import os7 from "os";
+import path7 from "path";
 function buildTestTimestamps(allEntries) {
   const testTs = /* @__PURE__ */ new Set();
   for (const e of allEntries) {
@@ -3207,8 +4114,8 @@ function getDateRange(period, now) {
   }
 }
 function parseAuditLog(logPath) {
-  if (!fs5.existsSync(logPath)) return [];
-  const raw = fs5.readFileSync(logPath, "utf-8");
+  if (!fs6.existsSync(logPath)) return [];
+  const raw = fs6.readFileSync(logPath, "utf-8");
   return raw.split("\n").flatMap((line) => {
     if (!line.trim()) return [];
     try {
@@ -3262,25 +4169,25 @@ function freezeClaudeCost(acc) {
   };
 }
 function processClaudeCostProject(proj, projectsDir, start, end, acc) {
-  const projPath = path6.join(projectsDir, proj);
+  const projPath = path7.join(projectsDir, proj);
   let files;
   try {
-    const stat = fs5.statSync(projPath);
+    const stat = fs6.statSync(projPath);
     if (!stat.isDirectory()) return;
-    files = fs5.readdirSync(projPath).filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
+    files = fs6.readdirSync(projPath).filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
   } catch {
     return;
   }
   const startMs = start.getTime();
   for (const file of files) {
-    const filePath = path6.join(projPath, file);
+    const filePath = path7.join(projPath, file);
     try {
-      if (fs5.statSync(filePath).mtimeMs < startMs) continue;
+      if (fs6.statSync(filePath).mtimeMs < startMs) continue;
     } catch {
       continue;
     }
     try {
-      const raw = fs5.readFileSync(filePath, "utf-8");
+      const raw = fs6.readFileSync(filePath, "utf-8");
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
         let entry;
@@ -3330,10 +4237,10 @@ function processClaudeCostProject(proj, projectsDir, start, end, acc) {
 }
 function loadClaudeCost(start, end, projectsDir) {
   const acc = emptyClaudeCostAccumulator();
-  if (!fs5.existsSync(projectsDir)) return freezeClaudeCost(acc);
+  if (!fs6.existsSync(projectsDir)) return freezeClaudeCost(acc);
   let dirs;
   try {
-    dirs = fs5.readdirSync(projectsDir);
+    dirs = fs6.readdirSync(projectsDir);
   } catch {
     return freezeClaudeCost(acc);
   }
@@ -3344,10 +4251,10 @@ function loadClaudeCost(start, end, projectsDir) {
 }
 async function loadClaudeCostAsync(start, end, projectsDir) {
   const acc = emptyClaudeCostAccumulator();
-  if (!fs5.existsSync(projectsDir)) return freezeClaudeCost(acc);
+  if (!fs6.existsSync(projectsDir)) return freezeClaudeCost(acc);
   let dirs;
   try {
-    dirs = fs5.readdirSync(projectsDir);
+    dirs = fs6.readdirSync(projectsDir);
   } catch {
     return freezeClaudeCost(acc);
   }
@@ -3360,7 +4267,7 @@ async function loadClaudeCostAsync(start, end, projectsDir) {
 function processCodexCostFile(filePath, start, end, acc) {
   let lines;
   try {
-    lines = fs5.readFileSync(filePath, "utf-8").split("\n");
+    lines = fs6.readFileSync(filePath, "utf-8").split("\n");
   } catch {
     return;
   }
@@ -3415,31 +4322,31 @@ function processCodexCostFile(filePath, start, end, acc) {
 }
 function listCodexSessionFiles(sessionsBase) {
   const jsonlFiles = [];
-  if (!fs5.existsSync(sessionsBase)) return jsonlFiles;
+  if (!fs6.existsSync(sessionsBase)) return jsonlFiles;
   try {
-    for (const year of fs5.readdirSync(sessionsBase)) {
-      const yearPath = path6.join(sessionsBase, year);
+    for (const year of fs6.readdirSync(sessionsBase)) {
+      const yearPath = path7.join(sessionsBase, year);
       try {
-        if (!fs5.statSync(yearPath).isDirectory()) continue;
+        if (!fs6.statSync(yearPath).isDirectory()) continue;
       } catch {
         continue;
       }
-      for (const month of fs5.readdirSync(yearPath)) {
-        const monthPath = path6.join(yearPath, month);
+      for (const month of fs6.readdirSync(yearPath)) {
+        const monthPath = path7.join(yearPath, month);
         try {
-          if (!fs5.statSync(monthPath).isDirectory()) continue;
+          if (!fs6.statSync(monthPath).isDirectory()) continue;
         } catch {
           continue;
         }
-        for (const day of fs5.readdirSync(monthPath)) {
-          const dayPath = path6.join(monthPath, day);
+        for (const day of fs6.readdirSync(monthPath)) {
+          const dayPath = path7.join(monthPath, day);
           try {
-            if (!fs5.statSync(dayPath).isDirectory()) continue;
+            if (!fs6.statSync(dayPath).isDirectory()) continue;
           } catch {
             continue;
           }
-          for (const file of fs5.readdirSync(dayPath)) {
-            if (file.endsWith(".jsonl")) jsonlFiles.push(path6.join(dayPath, file));
+          for (const file of fs6.readdirSync(dayPath)) {
+            if (file.endsWith(".jsonl")) jsonlFiles.push(path7.join(dayPath, file));
           }
         }
       }
@@ -3520,13 +4427,13 @@ function freezeGeminiCost(acc) {
 function processGeminiCostFile(filePath, projectKey, start, end, acc) {
   const startMs = start.getTime();
   try {
-    if (fs5.statSync(filePath).mtimeMs < startMs) return;
+    if (fs6.statSync(filePath).mtimeMs < startMs) return;
   } catch {
     return;
   }
   let raw;
   try {
-    raw = fs5.readFileSync(filePath, "utf-8");
+    raw = fs6.readFileSync(filePath, "utf-8");
   } catch {
     return;
   }
@@ -3575,30 +4482,30 @@ function listGeminiSessionFiles(geminiTmpDir) {
   const out = [];
   let dirs;
   try {
-    if (!fs5.statSync(geminiTmpDir).isDirectory()) return out;
-    dirs = fs5.readdirSync(geminiTmpDir);
+    if (!fs6.statSync(geminiTmpDir).isDirectory()) return out;
+    dirs = fs6.readdirSync(geminiTmpDir);
   } catch {
     return out;
   }
   for (const proj of dirs) {
-    const chatsDir = path6.join(geminiTmpDir, proj, "chats");
+    const chatsDir = path7.join(geminiTmpDir, proj, "chats");
     let files;
     try {
-      if (!fs5.statSync(chatsDir).isDirectory()) continue;
-      files = fs5.readdirSync(chatsDir);
+      if (!fs6.statSync(chatsDir).isDirectory()) continue;
+      files = fs6.readdirSync(chatsDir);
     } catch {
       continue;
     }
     for (const f of files) {
       if (!f.endsWith(".jsonl")) continue;
-      out.push({ projectKey: proj, file: path6.join(chatsDir, f) });
+      out.push({ projectKey: proj, file: path7.join(chatsDir, f) });
     }
   }
   return out;
 }
 function loadGeminiCost(start, end, geminiTmpDir) {
   const acc = emptyGeminiAccumulator();
-  if (!fs5.existsSync(geminiTmpDir)) return freezeGeminiCost(acc);
+  if (!fs6.existsSync(geminiTmpDir)) return freezeGeminiCost(acc);
   for (const { projectKey, file } of listGeminiSessionFiles(geminiTmpDir)) {
     processGeminiCostFile(file, projectKey, start, end, acc);
   }
@@ -3606,7 +4513,7 @@ function loadGeminiCost(start, end, geminiTmpDir) {
 }
 async function loadGeminiCostAsync(start, end, geminiTmpDir) {
   const acc = emptyGeminiAccumulator();
-  if (!fs5.existsSync(geminiTmpDir)) return freezeGeminiCost(acc);
+  if (!fs6.existsSync(geminiTmpDir)) return freezeGeminiCost(acc);
   const files = listGeminiSessionFiles(geminiTmpDir);
   const CHUNK_SIZE = 5;
   for (let i = 0; i < files.length; i++) {
@@ -3629,11 +4536,11 @@ function dimensionOfBlock(checkedBy, ruleName) {
 }
 function aggregateReportFromAudit(period, opts = {}) {
   const now = opts.now ?? /* @__PURE__ */ new Date();
-  const auditLogPath2 = opts.auditLogPath ?? path6.join(os6.homedir(), ".node9", "audit.log");
-  const claudeProjectsDir = opts.claudeProjectsDir ?? path6.join(os6.homedir(), ".claude", "projects");
-  const codexSessionsDir = opts.codexSessionsDir ?? path6.join(os6.homedir(), ".codex", "sessions");
-  const geminiTmpDir = opts.geminiTmpDir ?? path6.join(os6.homedir(), ".gemini", "tmp");
-  const hasAuditFile = fs5.existsSync(auditLogPath2);
+  const auditLogPath2 = opts.auditLogPath ?? path7.join(os7.homedir(), ".node9", "audit.log");
+  const claudeProjectsDir = opts.claudeProjectsDir ?? path7.join(os7.homedir(), ".claude", "projects");
+  const codexSessionsDir = opts.codexSessionsDir ?? path7.join(os7.homedir(), ".codex", "sessions");
+  const geminiTmpDir = opts.geminiTmpDir ?? path7.join(os7.homedir(), ".gemini", "tmp");
+  const hasAuditFile = fs6.existsSync(auditLogPath2);
   const allEntries = opts.preloadedAuditEntries ?? parseAuditLog(auditLogPath2);
   const unackedDlp = allEntries.filter((e) => e.source === "response-dlp");
   const { start, end } = getDateRange(period, now);
@@ -3870,18 +4777,18 @@ var init_report_audit = __esm({
 });
 
 // src/utils/provenance.ts
-import path7 from "path";
-import os7 from "os";
+import path8 from "path";
+import os8 from "os";
 var USER_PREFIXES;
 var init_provenance = __esm({
   "src/utils/provenance.ts"() {
     "use strict";
     USER_PREFIXES = [
-      path7.join(os7.homedir(), "bin"),
-      path7.join(os7.homedir(), ".local", "bin"),
-      path7.join(os7.homedir(), ".cargo", "bin"),
-      path7.join(os7.homedir(), ".npm-global", "bin"),
-      path7.join(os7.homedir(), ".volta", "bin")
+      path8.join(os8.homedir(), "bin"),
+      path8.join(os8.homedir(), ".local", "bin"),
+      path8.join(os8.homedir(), ".cargo", "bin"),
+      path8.join(os8.homedir(), ".npm-global", "bin"),
+      path8.join(os8.homedir(), ".volta", "bin")
     ];
   }
 });
@@ -3925,14 +4832,14 @@ var init_mcp_pin = __esm({
 });
 
 // src/daemon/hook-baseline.ts
-import path8 from "path";
-import os8 from "os";
+import path9 from "path";
+import os9 from "os";
 var BASELINE_FILE, NOTIFIED_FILE;
 var init_hook_baseline = __esm({
   "src/daemon/hook-baseline.ts"() {
     "use strict";
-    BASELINE_FILE = path8.join(os8.homedir(), ".node9", "hooks-baseline.json");
-    NOTIFIED_FILE = path8.join(os8.homedir(), ".node9", "hook-heal-notified.json");
+    BASELINE_FILE = path9.join(os9.homedir(), ".node9", "hooks-baseline.json");
+    NOTIFIED_FILE = path9.join(os9.homedir(), ".node9", "hook-heal-notified.json");
   }
 });
 
@@ -3991,9 +4898,9 @@ var init_scan_history = __esm({
 
 // src/cli/commands/scan.ts
 import chalk4 from "chalk";
-import fs6 from "fs";
-import path9 from "path";
-import os9 from "os";
+import fs7 from "fs";
+import path10 from "path";
+import os10 from "os";
 import stringWidth2 from "string-width";
 function claudeModelPrice2(model) {
   const t = pricingFor(model);
@@ -4142,7 +5049,7 @@ function processClaudeFile(file, projPath, projLabel, ruleSources, startDate, re
   const sessionId = file.replace(/\.jsonl$/, "");
   let raw;
   try {
-    raw = fs6.readFileSync(path9.join(projPath, file), "utf-8");
+    raw = fs7.readFileSync(path10.join(projPath, file), "utf-8");
   } catch {
     return;
   }
@@ -4194,7 +5101,7 @@ function processClaudeFile(file, projPath, projLabel, ruleSources, startDate, re
           if (block.type !== "tool_result") continue;
           const filePath = block.tool_use_id ? toolUseFilePaths.get(block.tool_use_id) : void 0;
           if (filePath) {
-            const ext = path9.extname(filePath).toLowerCase();
+            const ext = path10.extname(filePath).toLowerCase();
             if (CODE_EXTENSIONS.has(ext)) continue;
           }
           const resultText = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.map((c) => c.text ?? "").join("\n") : null;
@@ -4251,7 +5158,7 @@ function processClaudeFile(file, projPath, projLabel, ruleSources, startDate, re
       const rawCmd = String(input.command ?? "").trimStart();
       if (/^node9\s+(scan|explain|report|tail|dlp|status|sessions|audit)\b/.test(rawCmd)) continue;
       const inputFilePath = typeof input.file_path === "string" ? input.file_path : "";
-      const inputFileExt = inputFilePath ? path9.extname(inputFilePath).toLowerCase() : "";
+      const inputFileExt = inputFilePath ? path10.extname(inputFilePath).toLowerCase() : "";
       if (CODE_EXTENSIONS.has(inputFileExt)) continue;
       const dlpMatch = scanArgs(input);
       if (dlpMatch) {
@@ -4348,19 +5255,19 @@ function processClaudeFile(file, projPath, projLabel, ruleSources, startDate, re
   }
 }
 async function processClaudeProjectAsync(proj, projectsDir, ruleSources, startDate, result, dedup, onProgress, onLine) {
-  const projPath = path9.join(projectsDir, proj);
+  const projPath = path10.join(projectsDir, proj);
   try {
-    if (!fs6.statSync(projPath).isDirectory()) return;
+    if (!fs7.statSync(projPath).isDirectory()) return;
   } catch {
     return;
   }
-  const projLabel = stripTerminalEscapes(decodeURIComponent(proj).replace(os9.homedir(), "~")).slice(
+  const projLabel = stripTerminalEscapes(decodeURIComponent(proj).replace(os10.homedir(), "~")).slice(
     0,
     40
   );
   let files;
   try {
-    files = fs6.readdirSync(projPath).filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
+    files = fs7.readdirSync(projPath).filter((f) => f.endsWith(".jsonl") && !f.startsWith("agent-"));
   } catch {
     return;
   }
@@ -4398,12 +5305,12 @@ function emptyClaudeScan() {
   };
 }
 async function scanClaudeHistoryAsync(startDate, onProgress, onLine) {
-  const projectsDir = path9.join(os9.homedir(), ".claude", "projects");
+  const projectsDir = path10.join(os10.homedir(), ".claude", "projects");
   const result = emptyClaudeScan();
-  if (!fs6.existsSync(projectsDir)) return result;
+  if (!fs7.existsSync(projectsDir)) return result;
   let projDirs;
   try {
-    projDirs = fs6.readdirSync(projectsDir);
+    projDirs = fs7.readdirSync(projectsDir);
   } catch {
     return result;
   }
@@ -4424,7 +5331,7 @@ async function scanClaudeHistoryAsync(startDate, onProgress, onLine) {
   return result;
 }
 function scanGeminiHistory(startDate, onProgress, onLine) {
-  const tmpDir = path9.join(os9.homedir(), ".gemini", "tmp");
+  const tmpDir = path10.join(os10.homedir(), ".gemini", "tmp");
   const result = {
     filesScanned: 0,
     sessions: 0,
@@ -4439,33 +5346,33 @@ function scanGeminiHistory(startDate, onProgress, onLine) {
     sessionsWithEarlySecrets: 0
   };
   const dedup = emptyScanDedup();
-  if (!fs6.existsSync(tmpDir)) return result;
+  if (!fs7.existsSync(tmpDir)) return result;
   let slugDirs;
   try {
-    slugDirs = fs6.readdirSync(tmpDir);
+    slugDirs = fs7.readdirSync(tmpDir);
   } catch {
     return result;
   }
   const ruleSources = buildRuleSources();
-  for (const slug of slugDirs) {
-    const slugPath = path9.join(tmpDir, slug);
+  for (const slug2 of slugDirs) {
+    const slugPath = path10.join(tmpDir, slug2);
     try {
-      if (!fs6.statSync(slugPath).isDirectory()) continue;
+      if (!fs7.statSync(slugPath).isDirectory()) continue;
     } catch {
       continue;
     }
-    let projLabel = stripTerminalEscapes(slug).slice(0, 40);
+    let projLabel = stripTerminalEscapes(slug2).slice(0, 40);
     try {
       projLabel = stripTerminalEscapes(
-        fs6.readFileSync(path9.join(slugPath, ".project_root"), "utf-8").trim()
-      ).replace(os9.homedir(), "~").slice(0, 40);
+        fs7.readFileSync(path10.join(slugPath, ".project_root"), "utf-8").trim()
+      ).replace(os10.homedir(), "~").slice(0, 40);
     } catch {
     }
-    const chatsDir = path9.join(slugPath, "chats");
-    if (!fs6.existsSync(chatsDir)) continue;
+    const chatsDir = path10.join(slugPath, "chats");
+    if (!fs7.existsSync(chatsDir)) continue;
     let chatFiles;
     try {
-      chatFiles = fs6.readdirSync(chatsDir).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl")).sort((a, b) => Number(b.endsWith(".jsonl")) - Number(a.endsWith(".jsonl")));
+      chatFiles = fs7.readdirSync(chatsDir).filter((f) => f.endsWith(".json") || f.endsWith(".jsonl")).sort((a, b) => Number(b.endsWith(".jsonl")) - Number(a.endsWith(".jsonl")));
     } catch {
       continue;
     }
@@ -4478,7 +5385,7 @@ function scanGeminiHistory(startDate, onProgress, onLine) {
       onProgress?.(result.filesScanned);
       let raw;
       try {
-        raw = fs6.readFileSync(path9.join(chatsDir, chatFile), "utf-8");
+        raw = fs7.readFileSync(path10.join(chatsDir, chatFile), "utf-8");
       } catch {
         continue;
       }
@@ -4651,7 +5558,7 @@ function scanGeminiHistory(startDate, onProgress, onLine) {
   return result;
 }
 function scanCodexHistory(startDate, onProgress, onLine) {
-  const sessionsBase = path9.join(os9.homedir(), ".codex", "sessions");
+  const sessionsBase = path10.join(os10.homedir(), ".codex", "sessions");
   const result = {
     filesScanned: 0,
     sessions: 0,
@@ -4666,32 +5573,32 @@ function scanCodexHistory(startDate, onProgress, onLine) {
     sessionsWithEarlySecrets: 0
   };
   const dedup = emptyScanDedup();
-  if (!fs6.existsSync(sessionsBase)) return result;
+  if (!fs7.existsSync(sessionsBase)) return result;
   const jsonlFiles = [];
   try {
-    for (const year of fs6.readdirSync(sessionsBase)) {
-      const yearPath = path9.join(sessionsBase, year);
+    for (const year of fs7.readdirSync(sessionsBase)) {
+      const yearPath = path10.join(sessionsBase, year);
       try {
-        if (!fs6.statSync(yearPath).isDirectory()) continue;
+        if (!fs7.statSync(yearPath).isDirectory()) continue;
       } catch {
         continue;
       }
-      for (const month of fs6.readdirSync(yearPath)) {
-        const monthPath = path9.join(yearPath, month);
+      for (const month of fs7.readdirSync(yearPath)) {
+        const monthPath = path10.join(yearPath, month);
         try {
-          if (!fs6.statSync(monthPath).isDirectory()) continue;
+          if (!fs7.statSync(monthPath).isDirectory()) continue;
         } catch {
           continue;
         }
-        for (const day of fs6.readdirSync(monthPath)) {
-          const dayPath = path9.join(monthPath, day);
+        for (const day of fs7.readdirSync(monthPath)) {
+          const dayPath = path10.join(monthPath, day);
           try {
-            if (!fs6.statSync(dayPath).isDirectory()) continue;
+            if (!fs7.statSync(dayPath).isDirectory()) continue;
           } catch {
             continue;
           }
-          for (const file of fs6.readdirSync(dayPath)) {
-            if (file.endsWith(".jsonl")) jsonlFiles.push(path9.join(dayPath, file));
+          for (const file of fs7.readdirSync(dayPath)) {
+            if (file.endsWith(".jsonl")) jsonlFiles.push(path10.join(dayPath, file));
           }
         }
       }
@@ -4705,7 +5612,7 @@ function scanCodexHistory(startDate, onProgress, onLine) {
     onProgress?.(result.filesScanned);
     let lines;
     try {
-      lines = fs6.readFileSync(filePath, "utf-8").split("\n");
+      lines = fs7.readFileSync(filePath, "utf-8").split("\n");
     } catch {
       continue;
     }
@@ -4732,7 +5639,7 @@ function scanCodexHistory(startDate, onProgress, onLine) {
         sessionId = String(payload["id"] ?? filePath);
         startTime = String(payload["timestamp"] ?? "");
         const cwd = String(payload["cwd"] ?? "");
-        projLabel = stripTerminalEscapes(cwd.replace(os9.homedir(), "~")).slice(0, 40);
+        projLabel = stripTerminalEscapes(cwd.replace(os10.homedir(), "~")).slice(0, 40);
         continue;
       }
       if (entry.type === "turn_context" && typeof payload["model"] === "string") {
@@ -4974,23 +5881,23 @@ var init_scan = __esm({
 });
 
 // src/tui/dashboard/data.ts
-import fs7 from "fs";
-import os10 from "os";
-import path10 from "path";
+import fs8 from "fs";
+import os11 from "os";
+import path11 from "path";
 import http from "http";
 function auditLogPath() {
-  return path10.join(os10.homedir(), ".node9", "audit.log");
+  return path11.join(os11.homedir(), ".node9", "audit.log");
 }
 function readAuditEntriesAsync(chunkSize = 1e3, customPath) {
   return new Promise((resolve) => {
     const p = customPath ?? auditLogPath();
-    if (!fs7.existsSync(p)) {
+    if (!fs8.existsSync(p)) {
       resolve([]);
       return;
     }
     let raw;
     try {
-      raw = fs7.readFileSync(p, "utf8");
+      raw = fs8.readFileSync(p, "utf8");
     } catch {
       resolve([]);
       return;
@@ -5094,7 +6001,10 @@ function compactPathsInCommand(cmd) {
 function loadShieldStatus() {
   try {
     const all = Object.keys(SHIELDS).sort();
-    const activeSet = new Set(readActiveShields());
+    const cfg = getConfig();
+    const activeSet = new Set(
+      cfg.policySource === "workspace" ? cfg.policy.appliedShields ?? [] : readActiveShields()
+    );
     const active = all.filter((n) => activeSet.has(n));
     const inactive = all.filter((n) => !activeSet.has(n));
     return { active, inactive };
@@ -5119,13 +6029,13 @@ function loadBlast() {
   }
 }
 function shortenPath(p) {
-  const home = os10.homedir();
+  const home = os11.homedir();
   return p.startsWith(home) ? p.replace(home, "~") : p;
 }
 async function loadReportAuditAsync(period) {
-  const claudeProjectsDir = path10.join(os10.homedir(), ".claude", "projects");
-  const codexSessionsDir = path10.join(os10.homedir(), ".codex", "sessions");
-  const geminiTmpDir = path10.join(os10.homedir(), ".gemini", "tmp");
+  const claudeProjectsDir = path11.join(os11.homedir(), ".claude", "projects");
+  const codexSessionsDir = path11.join(os11.homedir(), ".codex", "sessions");
+  const geminiTmpDir = path11.join(os11.homedir(), ".gemini", "tmp");
   const { start, end } = getDateRange(period, /* @__PURE__ */ new Date());
   const entries = await readAuditEntriesAsync();
   void ensurePricingLoaded();
@@ -5456,6 +6366,7 @@ var init_data = __esm({
     init_daemon();
     init_costSync();
     init_shields();
+    init_config();
     init_decision();
     init_scan_watermark();
     init_report_audit();
@@ -6205,8 +7116,8 @@ import { Fragment as Fragment3, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-run
 function TopToolsProjects({ audit }) {
   const data = audit?.data;
   const tools = data ? [...data.toolMap.entries()].sort(([, a], [, b]) => b.calls - a.calls).slice(0, ROW_LIMIT) : [];
-  const projects = data ? [...data.cost.byProject.entries()].map(([path11, r]) => ({
-    name: basenameOf(path11),
+  const projects = data ? [...data.cost.byProject.entries()].map(([path12, r]) => ({
+    name: basenameOf(path12),
     cost: r.cost,
     tokens: r.inputTokens + r.outputTokens
   })).sort((a, b) => b.cost - a.cost).slice(0, ROW_LIMIT) : [];
@@ -6643,8 +7554,8 @@ function pickTopLoopFile(loops) {
     map.set(k, (map.get(k) ?? 0) + (l.count ?? 0));
   }
   if (map.size === 0) return void 0;
-  const [path11, count] = [...map.entries()].sort((a, b) => b[1] - a[1])[0];
-  return { path: path11, count };
+  const [path12, count] = [...map.entries()].sort((a, b) => b[1] - a[1])[0];
+  return { path: path12, count };
 }
 var EMPTY_FILTERED_SCAN;
 var init_derive = __esm({