@carllee1983/dbcli 4.0.0 → 6.0.0

package/dist/cli-runtime.mjs

@@ -51,7 +51,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@carllee1983/dbcli",
-    version: "4.0.0",
+    version: "6.0.0",
     description: "Database CLI for AI agents",
     type: "module",
     publishConfig: {
@@ -4372,7 +4372,7 @@ function validateFormat(value, allowedFormats, commandName) {
     throw new Error(`Invalid format "${value}" for ${commandName}. Allowed: ${allowed}`);
   }
 }
-var EnvRefSchema, StringOrEnvRef, NumberOrEnvRef, OptStringOrEnvRef, OptNumberOrEnvRef, MIN_CONNECTION_TIMEOUT_MS = 100, MAX_CONNECTION_TIMEOUT_MS = 600000, MIN_STATEMENT_TIMEOUT_MS = 0, MAX_STATEMENT_TIMEOUT_MS = 3600000, TimeoutField, MongoDBConnectionConfigSchema, SqlConnectionConfigSchema, RedisConnectionConfigSchema, ElasticsearchConnectionConfigSchema, ConnectionConfigSchema, PermissionSchema, EnvironmentLabelSchema, MetadataSchema, BLACKLIST_KEY_ALIASES, BlacklistConfigSchema, RedisMaskRuleSchema, RedisConfigSchema, AuditRotationConfigSchema, AuditConfigSchema, DbcliConfigSchema, SqlNamedConnectionSchema, MongoDBNamedConnectionSchema, RedisNamedConnectionSchema, ElasticsearchNamedConnectionSchema, NamedConnectionUnion, NamedConnectionSchema, DbcliConfigV2Schema;
+var EnvRefSchema, StringOrEnvRef, NumberOrEnvRef, OptStringOrEnvRef, OptNumberOrEnvRef, MIN_CONNECTION_TIMEOUT_MS = 100, MAX_CONNECTION_TIMEOUT_MS = 600000, MIN_STATEMENT_TIMEOUT_MS = 0, MAX_STATEMENT_TIMEOUT_MS = 3600000, TimeoutField, MongoDBConnectionConfigSchema, SqlConnectionConfigSchema, RedisConnectionConfigSchema, ElasticsearchConnectionConfigSchema, ConnectionConfigSchema, PermissionSchema, EnvironmentLabelSchema, MetadataSchema, BLACKLIST_KEY_ALIASES, BlacklistConfigSchema, RedisMaskRuleSchema, RedisConfigSchema, DEFAULT_AUDIT_ROTATION, AuditRotationConfigSchema, AuditConfigSchema, DbcliConfigSchema, SqlNamedConnectionSchema, MongoDBNamedConnectionSchema, RedisNamedConnectionSchema, ElasticsearchNamedConnectionSchema, NamedConnectionUnion, NamedConnectionSchema, DbcliConfigV2Schema;
 var init_validation = __esm(() => {
   init_zod();
   EnvRefSchema = exports_external.object({
@@ -4474,10 +4474,11 @@ var init_validation = __esm(() => {
   RedisConfigSchema = exports_external.object({
     mask: exports_external.array(RedisMaskRuleSchema).default([])
   }).optional();
+  DEFAULT_AUDIT_ROTATION = { max_bytes: 10485760, max_entries: 1e4 };
   AuditRotationConfigSchema = exports_external.object({
-    max_bytes: exports_external.number().int().positive().default(10485760),
-    max_entries: exports_external.number().int().positive().default(1000)
-  }).optional().default({ max_bytes: 10485760, max_entries: 1000 });
+    max_bytes: exports_external.number().int().positive().default(DEFAULT_AUDIT_ROTATION.max_bytes),
+    max_entries: exports_external.number().int().positive().default(DEFAULT_AUDIT_ROTATION.max_entries)
+  }).optional().default({ ...DEFAULT_AUDIT_ROTATION });
   AuditConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
     strict: exports_external.boolean().default(false),
@@ -4488,7 +4489,7 @@ var init_validation = __esm(() => {
   }).optional().default({
     enabled: true,
     strict: false,
-    rotation: { max_bytes: 10485760, max_entries: 1000 }
+    rotation: { ...DEFAULT_AUDIT_ROTATION }
   });
   DbcliConfigSchema = exports_external.object({
     connection: ConnectionConfigSchema,
@@ -6321,7 +6322,7 @@ var init_config = __esm(() => {
     audit: {
       enabled: true,
       strict: false,
-      rotation: { max_bytes: 10485760, max_entries: 1000 }
+      rotation: { ...DEFAULT_AUDIT_ROTATION }
     }
   };
   configModule = {
@@ -11164,6 +11165,233 @@ var init_server_side_script = __esm(() => {
   ES_OPAQUE_BODY_KEYS = ["wrapper"];
 });
 
+// src/utils/glob.ts
+function findClassEnd(glob, open2) {
+  for (let i = open2 + 1;i < glob.length; i++) {
+    if (glob[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (glob[i] === "]")
+      return i;
+  }
+  return -1;
+}
+function isValidCharacterClass(body) {
+  try {
+    new RegExp(body);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseGlob(glob) {
+  const memo = parsedGlobs.get(glob);
+  if (memo !== undefined)
+    return memo;
+  const parsed = parseGlobUncached(glob);
+  parsedGlobs.set(glob, parsed);
+  return parsed;
+}
+function parseGlobUncached(glob) {
+  const runs = [];
+  let current = [];
+  let leadingStar = false;
+  let trailingStar = false;
+  let sawStar = false;
+  const endRun = () => {
+    if (current.length > 0)
+      runs.push(current);
+    current = [];
+  };
+  for (let i = 0;i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "\\" && i + 1 < glob.length) {
+      trailingStar = false;
+      current.push({ kind: "literal", char: glob[++i] });
+      continue;
+    }
+    if (c === "*") {
+      if (!sawStar && current.length === 0)
+        leadingStar = true;
+      sawStar = true;
+      trailingStar = true;
+      endRun();
+      continue;
+    }
+    trailingStar = false;
+    if (c === "?") {
+      current.push({ kind: "any" });
+      continue;
+    }
+    if (c === "[") {
+      const end = findClassEnd(glob, i);
+      const body = end === -1 ? "" : glob.slice(i, end + 1);
+      if (body !== "" && isValidCharacterClass(body)) {
+        current.push({ kind: "class", test: new RegExp(`^${body}$`, "s") });
+        i = end;
+        continue;
+      }
+      current.push({ kind: "literal", char: "[" });
+      continue;
+    }
+    current.push({ kind: "literal", char: c });
+  }
+  endRun();
+  return { runs, leadingStar, trailingStar, anchored: !sawStar };
+}
+function runMatchesAt(run, text2, at) {
+  if (at + run.length > text2.length)
+    return false;
+  for (let i = 0;i < run.length; i++) {
+    const token = run[i];
+    const ch = text2[at + i];
+    if (token.kind === "literal") {
+      if (token.char !== ch)
+        return false;
+    } else if (token.kind === "class") {
+      if (!token.test.test(ch))
+        return false;
+    }
+  }
+  return true;
+}
+function globMatches(glob, text2) {
+  const { runs, leadingStar, trailingStar, anchored } = parseGlob(glob);
+  if (anchored) {
+    const run = runs[0] ?? [];
+    return text2.length === run.length && runMatchesAt(run, text2, 0);
+  }
+  if (runs.length === 0)
+    return true;
+  let cursor = 0;
+  let first = 0;
+  let last = runs.length;
+  if (!leadingStar) {
+    const head = runs[0];
+    if (!runMatchesAt(head, text2, 0))
+      return false;
+    cursor = head.length;
+    first = 1;
+  }
+  if (!trailingStar) {
+    const tail = runs[last - 1];
+    const at = text2.length - tail.length;
+    if (at < cursor || !runMatchesAt(tail, text2, at))
+      return false;
+    last -= 1;
+  }
+  const limit = trailingStar ? text2.length : text2.length - runs[runs.length - 1].length;
+  for (let r = first;r < last; r++) {
+    const run = runs[r];
+    let found = -1;
+    for (let at = cursor;at + run.length <= limit; at++) {
+      if (runMatchesAt(run, text2, at)) {
+        found = at;
+        break;
+      }
+    }
+    if (found === -1)
+      return false;
+    cursor = found + run.length;
+  }
+  return true;
+}
+function escapeGlob(literal) {
+  return literal.replace(/[*?[\]\\]/g, "\\$&");
+}
+function globNeverMatches(glob) {
+  for (let i = 0;i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (c !== "[")
+      continue;
+    const end = findClassEnd(glob, i);
+    if (end === -1) {
+      return "unclosed character class";
+    }
+    const body = glob.slice(i, end + 1);
+    if (body === "[]" || body === "[^]")
+      return "empty character class matches nothing";
+    if (!isValidCharacterClass(body))
+      return "invalid character class";
+    i = end;
+  }
+  return null;
+}
+var parsedGlobs;
+var init_glob = __esm(() => {
+  parsedGlobs = new Map;
+});
+
+// src/core/mongo/path-matcher.ts
+function compilePatterns(raw) {
+  const patterns = [];
+  const rejected = [];
+  for (const entry of raw) {
+    if (typeof entry !== "string" || entry.length === 0) {
+      rejected.push({ raw: String(entry ?? ""), reason: "must be a non-empty string" });
+      continue;
+    }
+    const segments = entry.split(".");
+    if (segments.some((s) => s.length === 0)) {
+      rejected.push({ raw: entry, reason: "empty path segment" });
+      continue;
+    }
+    const globstar = segments.find((seg) => seg.includes("**"));
+    if (globstar !== undefined) {
+      rejected.push({
+        raw: entry,
+        reason: "`**` matches one segment, not a subtree; write `*` or a longer path"
+      });
+      continue;
+    }
+    const dead = segments.map((seg) => globNeverMatches(seg)).find((r) => r !== null);
+    if (dead !== undefined && dead !== null) {
+      rejected.push({ raw: entry, reason: dead });
+      continue;
+    }
+    const wildcardTail = segments.length > 1 && segments[segments.length - 1] === "*";
+    const literal = wildcardTail ? segments.slice(0, -1) : segments;
+    patterns.push({
+      raw: entry,
+      segments: literal,
+      wildcardTail
+    });
+  }
+  return { patterns, rejected };
+}
+function matchAny(path, patterns) {
+  if (patterns.length === 0)
+    return false;
+  const pathSegments = path.split(".");
+  for (const pat of patterns) {
+    if (pat.wildcardTail) {
+      if (pathSegments.length < pat.segments.length)
+        continue;
+    } else {
+      if (pat.segments.length !== pathSegments.length)
+        continue;
+    }
+    let ok = true;
+    for (let i = 0;i < pat.segments.length; i++) {
+      if (!globMatches(pat.segments[i], pathSegments[i])) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok)
+      return true;
+  }
+  return false;
+}
+var init_path_matcher = __esm(() => {
+  init_glob();
+});
+
 // src/core/mongo/request-fields.ts
 function asFieldPath(text2) {
   if (text2.startsWith("$$"))
@@ -11172,15 +11400,31 @@ function asFieldPath(text2) {
     return text2.slice(1);
   return text2;
 }
-function reachesProtectedField(path, protectedFields) {
+function globRulesOf(protectedFields) {
+  const globbed = [...protectedFields].filter((rule) => /[*?[\\]/.test(rule));
+  if (globbed.length === 0)
+    return [];
+  const { patterns, rejected } = compilePatterns(globbed);
+  if (rejected.length > 0) {
+    const detail = rejected.map((r) => `'${r.raw}' (${r.reason})`).join(", ");
+    throw new Error(`BlacklistRejection: blacklist entries this matcher cannot read: ${detail}`);
+  }
+  return patterns;
+}
+function reachesProtectedField(path, protectedFields, globs) {
   if (protectedFields.has(path))
     return true;
+  if (globs.length > 0 && matchAny(path, globs))
+    return true;
   const parts = path.split(".");
   if (parts.length === 1)
     return false;
   for (let start = 0;start < parts.length; start += 1) {
     for (let end = start + 1;end <= parts.length; end += 1) {
-      if (protectedFields.has(parts.slice(start, end).join(".")))
+      const candidate = parts.slice(start, end).join(".");
+      if (protectedFields.has(candidate))
+        return true;
+      if (globs.length > 0 && matchAny(candidate, globs))
         return true;
     }
   }
@@ -11189,6 +11433,7 @@ function reachesProtectedField(path, protectedFields) {
 function findProtectedFieldReference(request, protectedFields) {
   if (protectedFields.size === 0)
     return;
+  const globs = globRulesOf(protectedFields);
   const candidates = [];
   let movesWholeDocument = false;
   const walk = (node) => {
@@ -11222,7 +11467,7 @@ function findProtectedFieldReference(request, protectedFields) {
     }
   };
   walk(request);
-  const named = candidates.find((path) => path.length > 0 && reachesProtectedField(path, protectedFields));
+  const named = candidates.find((path) => path.length > 0 && reachesProtectedField(path, protectedFields, globs));
   if (named !== undefined)
     return named;
   return movesWholeDocument ? [...protectedFields][0] : undefined;
@@ -11261,6 +11506,7 @@ function protectedFieldsForRequest(request, collection, columns) {
 }
 var WHOLE_DOCUMENT_VARIABLES, RESHAPES_DOCUMENT, NAMES_A_FIELD_DYNAMICALLY = "$getField";
 var init_request_fields = __esm(() => {
+  init_path_matcher();
   WHOLE_DOCUMENT_VARIABLES = new Set(["ROOT", "CURRENT"]);
   RESHAPES_DOCUMENT = new Set(["$objectToArray", "$replaceRoot", "$replaceWith"]);
 });
@@ -12215,66 +12461,13 @@ var init_size_guard = __esm(() => {
   init_types3();
 });
 
-// src/utils/glob.ts
-function globToRegex(glob) {
-  let out = "^";
-  for (let i = 0;i < glob.length; i++) {
-    const c = glob[i];
-    if (c === "\\" && i + 1 < glob.length) {
-      out += glob[++i].replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      continue;
-    }
-    if (c === "*")
-      out += ".*";
-    else if (c === "?")
-      out += ".";
-    else if (c === "[") {
-      const end = findClassEnd(glob, i);
-      const body = end === -1 ? "" : glob.slice(i, end + 1);
-      if (body !== "" && isValidCharacterClass(body)) {
-        out += body;
-        i = end;
-      } else {
-        out += "\\[";
-      }
-    } else if (".^$+(){}|\\".includes(c)) {
-      out += "\\" + c;
-    } else {
-      out += c;
-    }
-  }
-  out += "$";
-  return new RegExp(out);
-}
-function findClassEnd(glob, open2) {
-  for (let i = open2 + 1;i < glob.length; i++) {
-    if (glob[i] === "\\") {
-      i++;
-      continue;
-    }
-    if (glob[i] === "]")
-      return i;
-  }
-  return -1;
-}
-function isValidCharacterClass(body) {
-  try {
-    new RegExp(body);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // src/adapters/redis/blacklist-enforcer.ts
 function patternsOverlap(a, b) {
-  const ra = globToRegex(a);
-  const rb = globToRegex(b);
   const probeA = sampleFromGlob(a);
   const probeB = sampleFromGlob(b);
-  if (probeA !== null && rb.test(probeA))
+  if (probeA !== null && globMatches(b, probeA))
     return true;
-  if (probeB !== null && ra.test(probeB))
+  if (probeB !== null && globMatches(a, probeB))
     return true;
   return false;
 }
@@ -12317,7 +12510,7 @@ function checkKeyArgs(command, args, rules) {
     if (key === undefined)
       continue;
     for (const pat of rules) {
-      if (globToRegex(pat).test(key)) {
+      if (globMatches(pat, key)) {
         return { ok: false, matchedKey: key, matchedPattern: pat };
       }
     }
@@ -12374,6 +12567,7 @@ function expandKeyArity(arity, args, argCount) {
 }
 var init_blacklist_enforcer = __esm(() => {
   init_command_metadata();
+  init_glob();
 });
 
 // src/adapters/redis/returned-key-names.ts
@@ -12385,8 +12579,7 @@ function filterReturnedKeyNames(command, reply, rules) {
     return reply;
   if (!returnsKeyNames(command))
     return reply;
-  const regexes = rules.map((pattern) => globToRegex(pattern));
-  const permitted = (key) => typeof key === "string" && regexes.every((regex) => !regex.test(key));
+  const permitted = (key) => typeof key === "string" && rules.every((rule) => !globMatches(rule, key));
   if (Array.isArray(reply) && reply.length === 2 && Array.isArray(reply[1])) {
     return [reply[0], reply[1].filter(permitted)];
   }
@@ -12396,12 +12589,13 @@ function filterReturnedKeyNames(command, reply, rules) {
 }
 var RETURNS_KEY_NAMES;
 var init_returned_key_names = __esm(() => {
+  init_glob();
   RETURNS_KEY_NAMES = new Set(["SCAN", "KEYS"]);
 });
 
 // src/adapters/redis/value-masker.ts
 function planFor(key, rules) {
-  const matched = rules.filter((r) => globToRegex(r.keyPattern).test(key));
+  const matched = rules.filter((r) => globMatches(r.keyPattern, key));
   if (matched.length === 0)
     return null;
   const wholeValue = matched.some((r) => !r.fields || r.fields.length === 0);
@@ -12456,7 +12650,7 @@ function maskRedisRows(command, args, rows, rules) {
 }
 var REDACTED = "[REDACTED]", MASKABLE;
 var init_value_masker = __esm(() => {
-  init_blacklist_enforcer();
+  init_glob();
   MASKABLE = new Set(["GET", "GETRANGE", "HGETALL", "HGET", "HMGET", "HVALS"]);
 });
 
@@ -12547,8 +12741,7 @@ class RedisAdapter {
   async sampleKeyNames(limit) {
     const client = this.requireClient();
     const rules = this.blacklistRules;
-    const regexes = rules.map((p) => globToRegex(p));
-    const { keys, scanned } = await scanAllKeys(client, "*", limit, limit, (key) => regexes.every((r) => !r.test(key)));
+    const { keys, scanned } = await scanAllKeys(client, "*", limit, limit, (key) => rules.every((rule) => !globMatches(rule, key)));
     return { names: keys, truncated: scanned >= limit };
   }
   async getDbSize() {
@@ -12927,6 +13120,7 @@ var init_redis_adapter = __esm(() => {
   init_types2();
   init_size_guard();
   init_blacklist_enforcer();
+  init_glob();
   init_returned_key_names();
   init_types3();
   init_command_metadata();
@@ -13449,7 +13643,7 @@ async function writeV2InitConfig(configPath, connectionName, connection, permiss
     audit: {
       enabled: true,
       strict: false,
-      rotation: { max_bytes: 10485760, max_entries: 1000 }
+      rotation: { ...DEFAULT_AUDIT_ROTATION }
     }
   };
   await writeV2Config(storagePath, v2Config);
@@ -13464,6 +13658,7 @@ var init_init_shared = __esm(() => {
   init_config();
   init_config_v2();
   init_prompts();
+  init_validation();
   init_config_binding();
 });
 
@@ -16457,6 +16652,23 @@ class ColumnIndexBuilder {
   }
 }
 // src/core/blacklist-manager.ts
+function normalizeBlacklistEntry(raw) {
+  const trimmed = raw.trim();
+  const quote = trimmed[0];
+  if ((quote === '"' || quote === "`") && trimmed.length > 1 && trimmed.endsWith(quote)) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+function assertNotTableQualified(tableKey, column) {
+  const dot = column.indexOf(".");
+  if (dot <= 0)
+    return;
+  if (column.slice(0, dot).toLowerCase() !== tableKey.toLowerCase())
+    return;
+  throw new Error(`[BlacklistManager] blacklist.columns["${tableKey}"] entry ${JSON.stringify(column)} is ` + `qualified with its own table and would never match. Write it as ` + `${JSON.stringify(column.slice(dot + 1))}.`);
+}
+
 class BlacklistManager {
   config;
   state;
@@ -16465,6 +16677,7 @@ class BlacklistManager {
     this.config = config;
     this.overrideEnabled = (overrideEnvValue ?? Bun.env.DBCLI_OVERRIDE_BLACKLIST ?? "") === "true";
     this.state = this.loadBlacklist();
+    this.wildcardTables = [...this.state.tables].filter((entry) => /[*?[\\]/.test(entry));
   }
   loadBlacklist() {
     const tables = new Set;
@@ -16476,7 +16689,7 @@ class BlacklistManager {
     if (Array.isArray(blacklistConfig.tables)) {
       for (const tableName of blacklistConfig.tables) {
         if (typeof tableName === "string") {
-          tables.add(tableName.toLowerCase());
+          tables.add(normalizeBlacklistEntry(tableName).toLowerCase());
         } else {
           console.warn(`[BlacklistManager] Invalid table name in blacklist config: ${JSON.stringify(tableName)}`);
         }
@@ -16497,13 +16710,15 @@ class BlacklistManager {
         const columnSet = new Set;
         for (const col of cols) {
           if (typeof col === "string") {
-            columnSet.add(col);
+            const entry = normalizeBlacklistEntry(col);
+            assertNotTableQualified(normalizeBlacklistEntry(tableName), entry);
+            columnSet.add(entry);
           } else {
             console.warn(`[BlacklistManager] Invalid column name in blacklist.columns["${tableName}"]: ${JSON.stringify(col)}`);
           }
         }
         if (columnSet.size > 0) {
-          columns.set(tableName.toLowerCase(), columnSet);
+          columns.set(normalizeBlacklistEntry(tableName).toLowerCase(), columnSet);
         }
       }
     } else if (blacklistConfig.columns !== undefined) {
@@ -16512,17 +16727,47 @@ class BlacklistManager {
     return { tables, columns };
   }
   isTableBlacklisted(tableName) {
-    return this.state.tables.has(tableName.toLowerCase());
+    const name = tableName.toLowerCase();
+    if (this.state.tables.has(name))
+      return true;
+    for (const pattern of this.wildcardTables) {
+      if (globMatches(pattern, name))
+        return true;
+    }
+    return false;
+  }
+  wildcardTables;
+  columnRulesFor(tableName) {
+    const key = normalizeBlacklistEntry(tableName).toLowerCase();
+    const direct = this.state.columns.get(key);
+    if (direct)
+      return direct;
+    const dot = key.lastIndexOf(".");
+    if (dot > 0) {
+      const bare = this.state.columns.get(key.slice(dot + 1));
+      if (bare)
+        return bare;
+    }
+    let merged;
+    for (const [ruleKey, columns] of this.state.columns) {
+      const ruleDot = ruleKey.lastIndexOf(".");
+      if (ruleDot <= 0 || ruleKey.slice(ruleDot + 1) !== key)
+        continue;
+      merged ??= new Set;
+      for (const column of columns)
+        merged.add(column);
+    }
+    return merged;
   }
   isColumnBlacklisted(tableName, columnName) {
-    const columnSet = this.state.columns.get(tableName.toLowerCase());
+    const columnSet = this.columnRulesFor(tableName);
     if (!columnSet) {
       return false;
     }
-    return columnSet.has(columnName);
+    return columnSet.has(normalizeBlacklistEntry(columnName).toLowerCase());
   }
   getBlacklistedColumns(tableName) {
-    const columnSet = this.state.columns.get(tableName.toLowerCase());
+    const columnSet = this.columnRulesFor(tableName);
     if (!columnSet) {
       return [];
     }
@@ -16543,6 +16788,9 @@ class BlacklistManager {
     return this.state;
   }
 }
+var init_blacklist_manager = __esm(() => {
+  init_glob();
+});
 
 // src/types/blacklist.ts
 var BlacklistError;
@@ -16819,7 +17067,7 @@ function expandIndexTargets(target) {
 function matchesIndexGlob(pattern, name) {
   const normalized = pattern.toLowerCase() === "_all" ? "*" : pattern.toLowerCase();
   try {
-    return globToRegex(normalized).test(name.toLowerCase());
+    return globMatches(normalized, name.toLowerCase());
   } catch {
     return true;
   }
@@ -16851,7 +17099,9 @@ function indexExpressionReaches(expression, blacklisted) {
   return concrete.some(reachesName) || wildcards.some((pattern) => entries.names.some((entry) => matchesIndexGlob(pattern, entry)) || entries.patterns.length > 0);
 }
 var MAX_DECODE_PASSES = 4;
-var init_es_index_target = () => {};
+var init_es_index_target = __esm(() => {
+  init_glob();
+});
 
 // src/core/blacklist-validator.ts
 function flattenArrayRow(row) {
@@ -16876,6 +17126,17 @@ function dedupe2(values) {
   }
   return result;
 }
+function compileGlobRules(rules, fold, table, operation) {
+  const globbed = rules.filter((rule) => /[*?[\\]/.test(rule));
+  if (globbed.length === 0)
+    return [];
+  const { patterns, rejected } = compilePatterns(globbed.map(fold));
+  if (rejected.length > 0) {
+    const detail = rejected.map((r) => `'${r.raw}' (${r.reason})`).join(", ");
+    throw new BlacklistError(`blacklist.columns for '${table}' has entries this matcher cannot read: ${detail}`, table, operation);
+  }
+  return patterns;
+}
 
 class BlacklistValidator {
   manager;
@@ -16933,7 +17194,27 @@ class BlacklistValidator {
     if (blacklisted.length === 0 || fields.length === 0) {
       return;
     }
-    const conflicts = fields.filter((f) => blacklisted.includes(f));
+    const protectedPaths = new Set(blacklisted.map((name) => name.toLowerCase()));
+    const globs = compileGlobRules(blacklisted, (value) => value.toLowerCase(), tableName, operation);
+    const conflicts = fields.filter((field) => {
+      const name = field.toLowerCase();
+      if (protectedPaths.has(name))
+        return true;
+      if (matchAny(name, globs))
+        return true;
+      let dot = name.indexOf(".");
+      while (dot >= 0) {
+        if (dot > 0) {
+          const ancestor = name.slice(0, dot);
+          if (protectedPaths.has(ancestor))
+            return true;
+          if (matchAny(ancestor, globs))
+            return true;
+        }
+        dot = name.indexOf(".", dot + 1);
+      }
+      return false;
+    });
     if (conflicts.length === 0) {
       return;
     }
@@ -16984,11 +17265,20 @@ class BlacklistValidator {
       }
       collect(row);
     }
-    const protectedPaths = new Set(blacklistedColumns);
+    const foldHead = (path) => {
+      const dot = path.indexOf(".");
+      return dot < 0 ? path.toLowerCase() : path.slice(0, dot).toLowerCase() + path.slice(dot);
+    };
+    const protectedPaths = new Set(blacklistedColumns.map(foldHead));
+    const globRules = compileGlobRules(blacklistedColumns, foldHead, tables[0] ?? "unknown", "SELECT");
+    const presentByFolded = new Map;
+    for (const column of presentColumns)
+      presentByFolded.set(foldHead(column), column);
     const omitted = new Set;
     for (const path of blacklistedColumns) {
-      if (presentColumns.has(path)) {
-        omitted.add(path);
+      const present = presentByFolded.get(foldHead(path));
+      if (present !== undefined) {
+        omitted.add(present);
         continue;
       }
       const dot = path.indexOf(".");
@@ -17003,13 +17293,30 @@ class BlacklistValidator {
     for (const column of presentColumns) {
       let dot = column.indexOf(".");
       while (dot >= 0) {
-        if (dot > 0 && protectedPaths.has(column.slice(0, dot))) {
+        if (dot > 0 && protectedPaths.has(column.slice(0, dot).toLowerCase())) {
           omitted.add(column);
           break;
         }
         dot = column.indexOf(".", dot + 1);
       }
     }
+    if (globRules.length > 0) {
+      for (const column of presentColumns) {
+        const folded = foldHead(column);
+        if (matchAny(folded, globRules)) {
+          omitted.add(column);
+          continue;
+        }
+        let dot = folded.indexOf(".");
+        while (dot >= 0) {
+          if (dot > 0 && matchAny(folded.slice(0, dot), globRules)) {
+            omitted.add(column);
+            break;
+          }
+          dot = folded.indexOf(".", dot + 1);
+        }
+      }
+    }
     const omittedColumns = Array.from(omitted);
     if (omittedColumns.length === 0) {
       return { filteredRows: rows, omittedColumns: [] };
@@ -17030,6 +17337,7 @@ var init_blacklist_validator = __esm(() => {
   init_blacklist();
   init_message_loader();
   init_field_projection();
+  init_path_matcher();
   init_es_index_target();
 });
 
@@ -18040,6 +18348,7 @@ var init_core = __esm(() => {
   init_schema_updater();
   init_concurrent_lock();
   init_error_recovery();
+  init_blacklist_manager();
   init_blacklist_validator();
   init_size_category();
   init_health_checker();
@@ -18418,6 +18727,355 @@ var init_sql_lexical = __esm(() => {
   DOLLAR_QUOTE_DELIMITER = /^\$(?:(?:[A-Za-z_]|[\u0080-\uFFFF])(?:[A-Za-z0-9_]|[\u0080-\uFFFF])*)?\$/;
 });
 
+// src/utils/sql-tables.ts
+var exports_sql_tables = {};
+__export(exports_sql_tables, {
+  extractTableReferences: () => extractTableReferences
+});
+function tokenize(sql, dialect, backslashEscapes) {
+  const tokens = [];
+  const mysqlDialect = dialect === "mysql" || dialect === "mariadb";
+  let i = 0;
+  while (i < sql.length) {
+    const char = sql[i];
+    const dashFollowerCode = sql.charCodeAt(i + 2);
+    if (char === "-" && sql[i + 1] === "-" && (!mysqlDialect || sql[i + 2] === undefined || dashFollowerCode <= 32 || dashFollowerCode === 127)) {
+      while (i < sql.length && sql[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (mysqlDialect && char === "#") {
+      while (i < sql.length && sql[i] !== `
+`)
+        i++;
+      continue;
+    }
+    if (char === "/" && sql[i + 1] === "*") {
+      if (mysqlDialect && (sql.startsWith("/*!", i) || sql.startsWith("/*M!", i))) {
+        const prefixLength = sql.startsWith("/*M!", i) ? 4 : 3;
+        const closingIndex = sql.indexOf("*/", i + prefixLength);
+        const bodyEnd = closingIndex === -1 ? sql.length : closingIndex;
+        const body = sql.slice(i + prefixLength, bodyEnd).replace(/^\d+/, " ");
+        tokens.push(...tokenize(body, dialect, backslashEscapes));
+        i = closingIndex === -1 ? sql.length : closingIndex + 2;
+        continue;
+      }
+      const nests = dialect === "postgresql";
+      let depth = 1;
+      i += 2;
+      while (i < sql.length && depth > 0) {
+        if (nests && sql[i] === "/" && sql[i + 1] === "*") {
+          depth++;
+          i += 2;
+          continue;
+        }
+        if (sql[i] === "*" && sql[i + 1] === "/") {
+          depth--;
+          i += 2;
+          continue;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (dialect === "postgresql" && char === "$") {
+      const delimiter = dollarQuoteDelimiterAt(sql, i);
+      if (delimiter) {
+        i += delimiter.length;
+        const closingIndex = sql.indexOf(delimiter, i);
+        i = closingIndex === -1 ? sql.length : closingIndex + delimiter.length;
+        continue;
+      }
+    }
+    if (char === "'") {
+      i++;
+      while (i < sql.length) {
+        if (sql[i] === "'") {
+          if (sql[i + 1] === "'") {
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        if (backslashEscapes && sql[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (char === '"' || char === "`") {
+      const quote = char;
+      i++;
+      let value = "";
+      while (i < sql.length) {
+        if (sql[i] === quote) {
+          if (sql[i + 1] === quote) {
+            value += quote;
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        if (backslashEscapes && sql[i] === "\\") {
+          value += sql[i + 1] ?? "";
+          i += 2;
+          continue;
+        }
+        value += sql[i];
+        i++;
+      }
+      tokens.push({ value, kind: "identifier", quoted: true });
+      continue;
+    }
+    if (IDENTIFIER_START2.test(char)) {
+      let value = "";
+      while (i < sql.length && IDENTIFIER_PART.test(sql[i])) {
+        value += sql[i];
+        i++;
+      }
+      tokens.push({ value, kind: "identifier", quoted: false });
+      continue;
+    }
+    if (char === "." || char === "," || char === "(" || char === ")" || char === ";") {
+      tokens.push({ value: char, kind: "punctuation", quoted: false });
+      i++;
+      continue;
+    }
+    i++;
+  }
+  return tokens;
+}
+function isKeyword(token, keywords) {
+  if (!token || token.kind !== "identifier" || token.quoted)
+    return false;
+  return keywords.has(token.value.toUpperCase());
+}
+function isPunctuation(token, value) {
+  return token?.kind === "punctuation" && token.value === value;
+}
+function readQualifiedName(tokens, index) {
+  const first = tokens[index];
+  if (!first || first.kind !== "identifier")
+    return null;
+  const parts = [first.value];
+  let cursor = index + 1;
+  while (isPunctuation(tokens[cursor], ".") && tokens[cursor + 1]?.kind === "identifier") {
+    parts.push(tokens[cursor + 1].value);
+    cursor += 2;
+  }
+  return { parts, next: cursor };
+}
+function decodedVariants(value) {
+  const decoded = value.replace(ANY_ESCAPE_SEQUENCE, (whole, _escape, long, short) => fromCodePointOrRaw(long ?? short, whole));
+  return decoded === value ? [] : [decoded];
+}
+function fromCodePointOrRaw(hex, whole) {
+  const codePoint = parseInt(hex, 16);
+  return codePoint <= 1114111 ? String.fromCodePoint(codePoint) : whole;
+}
+function extractTableReferences(sql, options = {}) {
+  const seen = new Set;
+  const references = [];
+  const record = (name) => {
+    const key = name.toLowerCase();
+    if (name.length === 0 || seen.has(key))
+      return;
+    seen.add(key);
+    references.push(name);
+  };
+  const dialects = options.dialect ? [options.dialect] : ["postgresql", "mysql", undefined];
+  for (const dialect of dialects) {
+    for (const backslashEscapes of [false, true]) {
+      collectReferences(tokenize(sql, dialect, backslashEscapes), record);
+    }
+  }
+  return references;
+}
+function collectReferences(tokens, record) {
+  const recordName = (parts) => {
+    const bare = parts[parts.length - 1];
+    record(bare);
+    for (const variant of decodedVariants(bare))
+      record(variant);
+    if (parts.length > 1)
+      record(parts.join("."));
+  };
+  let i = 0;
+  while (i < tokens.length) {
+    if (!isKeyword(tokens[i], TABLE_INTRODUCERS)) {
+      i++;
+      continue;
+    }
+    const introducer = tokens[i].value.toUpperCase();
+    const parenMeansFunction = introducer === "FROM" || introducer === "JOIN";
+    let cursor = i + 1;
+    while (isKeyword(tokens[cursor], PRE_TABLE_NOISE))
+      cursor++;
+    while (parenMeansFunction && isPunctuation(tokens[cursor], "(") && !isKeyword(tokens[cursor + 1], SUBQUERY_OPENERS) && tokens[cursor + 1]?.kind === "identifier") {
+      cursor++;
+    }
+    let expectTable = true;
+    while (expectTable) {
+      expectTable = false;
+      const name = readQualifiedName(tokens, cursor);
+      if (!name)
+        break;
+      const isFunctionCall = parenMeansFunction && isPunctuation(tokens[name.next], "(");
+      if (!isFunctionCall)
+        recordName(name.parts);
+      cursor = name.next;
+      if (isFunctionCall)
+        break;
+      if (isKeyword(tokens[cursor], AS_KEYWORD))
+        cursor++;
+      if (tokens[cursor]?.kind === "identifier" && !isKeyword(tokens[cursor], POST_TABLE_KEYWORDS)) {
+        cursor++;
+      }
+      while (isPunctuation(tokens[cursor], "(")) {
+        let depth = 0;
+        do {
+          if (isPunctuation(tokens[cursor], "("))
+            depth++;
+          else if (isPunctuation(tokens[cursor], ")"))
+            depth--;
+          cursor++;
+        } while (depth > 0 && cursor < tokens.length);
+        if (tokens[cursor]?.kind === "identifier" && !isKeyword(tokens[cursor], POST_TABLE_KEYWORDS))
+          cursor++;
+      }
+      if (isPunctuation(tokens[cursor], ",")) {
+        cursor++;
+        expectTable = true;
+      }
+    }
+    i = Math.max(cursor, i + 1);
+  }
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    if (!token || token.kind !== "identifier") {
+      index++;
+      continue;
+    }
+    const name = readQualifiedName(tokens, index);
+    for (let part = 0;part < name.parts.length; part++) {
+      const value = name.parts[part];
+      const isQuoted = tokens[index + part * 2]?.quoted === true;
+      if (isQuoted || !RESERVED_KEYWORDS.has(value.toUpperCase())) {
+        record(value);
+        for (const variant of decodedVariants(value))
+          record(variant);
+      }
+    }
+    if (name.parts.length > 1)
+      record(name.parts.join("."));
+    index = name.next;
+  }
+}
+var TABLE_INTRODUCERS, PRE_TABLE_NOISE, SUBQUERY_OPENERS, AS_KEYWORD, POST_TABLE_KEYWORDS, RESERVED_KEYWORDS, IDENTIFIER_START2, IDENTIFIER_PART, ANY_ESCAPE_SEQUENCE;
+var init_sql_tables = __esm(() => {
+  init_sql_lexical();
+  TABLE_INTRODUCERS = new Set([
+    "FROM",
+    "JOIN",
+    "INTO",
+    "UPDATE",
+    "TABLE",
+    "TRUNCATE",
+    "COPY",
+    "USING",
+    "STRAIGHT_JOIN"
+  ]);
+  PRE_TABLE_NOISE = new Set(["ONLY", "LATERAL", "TABLE"]);
+  SUBQUERY_OPENERS = new Set(["SELECT", "WITH", "VALUES", "TABLE"]);
+  AS_KEYWORD = new Set(["AS"]);
+  POST_TABLE_KEYWORDS = new Set([
+    "AS",
+    "ON",
+    "USING",
+    "WHERE",
+    "GROUP",
+    "ORDER",
+    "HAVING",
+    "LIMIT",
+    "OFFSET",
+    "FETCH",
+    "WINDOW",
+    "UNION",
+    "INTERSECT",
+    "EXCEPT",
+    "JOIN",
+    "INNER",
+    "LEFT",
+    "RIGHT",
+    "FULL",
+    "OUTER",
+    "CROSS",
+    "NATURAL",
+    "STRAIGHT_JOIN",
+    "SET",
+    "VALUES",
+    "SELECT",
+    "RETURNING",
+    "FOR",
+    "INTO",
+    "PARTITION",
+    "WITH",
+    "TABLESAMPLE",
+    "FORCE",
+    "IGNORE",
+    "USE"
+  ]);
+  RESERVED_KEYWORDS = new Set([
+    "ALL",
+    "AND",
+    "AS",
+    "ASC",
+    "CASE",
+    "CROSS",
+    "DESC",
+    "DISTINCT",
+    "ELSE",
+    "FALSE",
+    "FOR",
+    "FROM",
+    "GROUP",
+    "HAVING",
+    "IN",
+    "INNER",
+    "INTO",
+    "IS",
+    "JOIN",
+    "LEFT",
+    "LIKE",
+    "LIMIT",
+    "NOT",
+    "NULL",
+    "ON",
+    "OR",
+    "ORDER",
+    "OUTER",
+    "RIGHT",
+    "SELECT",
+    "THEN",
+    "TRUE",
+    "UNION",
+    "USING",
+    "VALUES",
+    "WHEN",
+    "WHERE",
+    "WITH"
+  ]);
+  IDENTIFIER_START2 = /[A-Za-z_\u0080-\uFFFF]/;
+  IDENTIFIER_PART = /[A-Za-z0-9_$\u0080-\uFFFF]/;
+  ANY_ESCAPE_SEQUENCE = /([^0-9a-fA-F+'"\s])(?:\+([0-9a-fA-F]{6})|([0-9a-fA-F]{4}))/g;
+});
+
 // src/core/permission/sql-analysis.ts
 function normalizeSQL(sql) {
   return sql.replace(/--[^\n]*\n/g, `
@@ -19010,6 +19668,9 @@ var init_engine_hints = __esm(() => {
 });
 
 // src/core/audit/integration-helper.ts
+function sqlDialectFor(engine) {
+  return SQL_AUDIT_DIALECTS.includes(engine) ? engine : null;
+}
 async function getAuditLogger(config, configPath, connectionName) {
   const storagePath = await resolveConfigStoragePath(configPath);
   const connName = connectionName || config.effectiveConnectionName || getGlobalConnectionName() || "default";
@@ -19051,6 +19712,8 @@ async function writeAuditEntryResult(config, commandName, options, outcome) {
     const logger = await getAuditLogger(config, options.config || ".dbcli", connectionName);
     const engine = config.connection?.system || "postgresql";
     const target = outcome.target || getOperationTarget(engine, commandName, options, outcome.sql);
+    const auditDialect = sqlDialectFor(engine);
+    const blacklistChecked = auditDialect ? extractTableReferences(outcome.sql ?? "", { dialect: auditDialect }) : [];
     let tier = outcome.sideEffectTier ?? getEngineCapability(engine, commandName).tier;
     if (options.dryRun || options.plan) {
       tier = "dry-run";
@@ -19075,6 +19738,7 @@ async function writeAuditEntryResult(config, commandName, options, outcome) {
       ...outcome.recovery_ref && { recovery_ref: outcome.recovery_ref },
       metadata: {
         ...outcome.metadata ?? {},
+        ...blacklistChecked.length > 0 && { blacklist_checked: blacklistChecked },
         connection_name: connectionName,
         environment: config.effectiveEnvironment ?? null
       }
@@ -19087,15 +19751,17 @@ async function writeAuditEntryResult(config, commandName, options, outcome) {
     };
   }
 }
-var _sessionIdService = null, _loggers, AuditRequiredError;
+var SQL_AUDIT_DIALECTS, _sessionIdService = null, _loggers, AuditRequiredError;
 var init_integration_helper = __esm(() => {
   init_logger2();
   init_session_id();
   init_config_binding();
   init_config();
   init_capabilities();
+  init_sql_tables();
   init_redaction();
   init_engine_hints();
+  SQL_AUDIT_DIALECTS = ["postgresql", "mysql", "mariadb"];
   _loggers = new Map;
   AuditRequiredError = class AuditRequiredError extends Error {
     constructor(detail) {
@@ -19170,73 +19836,6 @@ async function getAllTablesFromAdapter(adapter) {
 }
 var init_error_suggester = () => {};
 
-// src/core/mongo/path-matcher.ts
-function compilePatterns(raw) {
-  const patterns = [];
-  const rejected = [];
-  for (const entry of raw) {
-    if (typeof entry !== "string" || entry.length === 0) {
-      rejected.push({ raw: String(entry ?? ""), reason: "must be a non-empty string" });
-      continue;
-    }
-    const segments = entry.split(".");
-    if (segments.length === 0 || segments.some((s) => s.length === 0)) {
-      rejected.push({ raw: entry, reason: "empty path segment" });
-      continue;
-    }
-    const wildcardIndices = segments.map((s, i) => s.includes("*") ? i : -1).filter((i) => i >= 0);
-    if (wildcardIndices.length === 0) {
-      patterns.push({ raw: entry, segments, wildcardTail: false });
-      continue;
-    }
-    const lastIndex = segments.length - 1;
-    const onlyTail = wildcardIndices.length === 1 && wildcardIndices[0] === lastIndex && segments[lastIndex] === "*";
-    if (!onlyTail) {
-      rejected.push({ raw: entry, reason: "wildcard must be the final segment" });
-      continue;
-    }
-    if (segments.length === 1) {
-      rejected.push({ raw: entry, reason: "wildcard must have a parent path" });
-      continue;
-    }
-    patterns.push({ raw: entry, segments: segments.slice(0, -1), wildcardTail: true });
-  }
-  return { patterns, rejected };
-}
-function matchAny(path, patterns) {
-  if (patterns.length === 0)
-    return false;
-  const pathSegments = path.split(".");
-  for (const pat of patterns) {
-    if (pat.wildcardTail) {
-      if (pathSegments.length < pat.segments.length)
-        continue;
-      let ok = true;
-      for (let i = 0;i < pat.segments.length; i++) {
-        if (pat.segments[i] !== pathSegments[i]) {
-          ok = false;
-          break;
-        }
-      }
-      if (ok)
-        return true;
-    } else {
-      if (pat.segments.length !== pathSegments.length)
-        continue;
-      let ok = true;
-      for (let i = 0;i < pat.segments.length; i++) {
-        if (pat.segments[i] !== pathSegments[i]) {
-          ok = false;
-          break;
-        }
-      }
-      if (ok)
-        return true;
-    }
-  }
-  return false;
-}
-
 // src/utils/bounded-parallel.ts
 async function mapWithConcurrency(items, limit, worker) {
   if (items.length === 0)
@@ -21322,7 +21921,11 @@ function markRedactedColumns(cols, collection, blacklist) {
   const raw = (blacklist.columns ?? {})[collection];
   if (!raw || raw.length === 0)
     return cols;
-  const { patterns } = compilePatterns(raw);
+  const { patterns, rejected } = compilePatterns(raw);
+  if (rejected.length > 0) {
+    const detail = rejected.map((r) => `'${r.raw}' (${r.reason})`).join(", ");
+    throw new Error(`blacklist.columns for '${collection}' has entries this matcher cannot read: ${detail}`);
+  }
   if (patterns.length === 0)
     return cols;
   return cols.map((c) => matchAny(c.name, patterns) ? { ...c, redacted: true } : c);
@@ -21770,6 +22373,7 @@ var init_schema = __esm(() => {
   init_validation();
   init_connection_selector();
   init_error_suggester();
+  init_path_matcher();
   init_config_path();
   ALLOWED_FORMATS2 = ["table", "json"];
   schemaCommand = new Command().name("schema").description("Display table schema, scan database schema, or refresh existing schema with detected changes").argument("[table]", "Optional: table name to inspect (if omitted, scans all tables)").option("--format <format>", "Output format: table (default) or json", "table").option("--config <path>", "Path to .dbcli config file", ".dbcli").addOption(createConnectionSelectorOption()).option("--refresh", "Refresh schema by detecting changes from database", false).option("--reset", "Clear all existing schema data and re-fetch from database", false).option("--force", "Skip confirmation when updating schema data", false).option("--sample-size <n>", "MongoDB only: number of documents to sample for schema inference (default 100, max 1000). Ignored on SQL connections.").option("--sample-method <method>", 'MongoDB only: "random" (default, uses $sample) or "natural" (uses find().limit()). Ignored on SQL connections.', "random").option("--recovery", "On failure, emit a structured recovery envelope to stdout (suppresses human stderr message)", false).action(schemaAction);
@@ -21874,355 +22478,6 @@ async function openInBrowser(target) {
 }
 var init_opener = () => {};
 
-// src/utils/sql-tables.ts
-var exports_sql_tables = {};
-__export(exports_sql_tables, {
-  extractTableReferences: () => extractTableReferences
-});
-function tokenize(sql, dialect, backslashEscapes) {
-  const tokens = [];
-  const mysqlDialect = dialect === "mysql" || dialect === "mariadb";
-  let i = 0;
-  while (i < sql.length) {
-    const char = sql[i];
-    const dashFollowerCode = sql.charCodeAt(i + 2);
-    if (char === "-" && sql[i + 1] === "-" && (!mysqlDialect || sql[i + 2] === undefined || dashFollowerCode <= 32 || dashFollowerCode === 127)) {
-      while (i < sql.length && sql[i] !== `
-`)
-        i++;
-      continue;
-    }
-    if (mysqlDialect && char === "#") {
-      while (i < sql.length && sql[i] !== `
-`)
-        i++;
-      continue;
-    }
-    if (char === "/" && sql[i + 1] === "*") {
-      if (mysqlDialect && (sql.startsWith("/*!", i) || sql.startsWith("/*M!", i))) {
-        const prefixLength = sql.startsWith("/*M!", i) ? 4 : 3;
-        const closingIndex = sql.indexOf("*/", i + prefixLength);
-        const bodyEnd = closingIndex === -1 ? sql.length : closingIndex;
-        const body = sql.slice(i + prefixLength, bodyEnd).replace(/^\d+/, " ");
-        tokens.push(...tokenize(body, dialect, backslashEscapes));
-        i = closingIndex === -1 ? sql.length : closingIndex + 2;
-        continue;
-      }
-      const nests = dialect === "postgresql";
-      let depth = 1;
-      i += 2;
-      while (i < sql.length && depth > 0) {
-        if (nests && sql[i] === "/" && sql[i + 1] === "*") {
-          depth++;
-          i += 2;
-          continue;
-        }
-        if (sql[i] === "*" && sql[i + 1] === "/") {
-          depth--;
-          i += 2;
-          continue;
-        }
-        i++;
-      }
-      continue;
-    }
-    if (dialect === "postgresql" && char === "$") {
-      const delimiter = dollarQuoteDelimiterAt(sql, i);
-      if (delimiter) {
-        i += delimiter.length;
-        const closingIndex = sql.indexOf(delimiter, i);
-        i = closingIndex === -1 ? sql.length : closingIndex + delimiter.length;
-        continue;
-      }
-    }
-    if (char === "'") {
-      i++;
-      while (i < sql.length) {
-        if (sql[i] === "'") {
-          if (sql[i + 1] === "'") {
-            i += 2;
-            continue;
-          }
-          i++;
-          break;
-        }
-        if (backslashEscapes && sql[i] === "\\") {
-          i += 2;
-          continue;
-        }
-        i++;
-      }
-      continue;
-    }
-    if (char === '"' || char === "`") {
-      const quote = char;
-      i++;
-      let value = "";
-      while (i < sql.length) {
-        if (sql[i] === quote) {
-          if (sql[i + 1] === quote) {
-            value += quote;
-            i += 2;
-            continue;
-          }
-          i++;
-          break;
-        }
-        if (backslashEscapes && sql[i] === "\\") {
-          value += sql[i + 1] ?? "";
-          i += 2;
-          continue;
-        }
-        value += sql[i];
-        i++;
-      }
-      tokens.push({ value, kind: "identifier", quoted: true });
-      continue;
-    }
-    if (IDENTIFIER_START2.test(char)) {
-      let value = "";
-      while (i < sql.length && IDENTIFIER_PART.test(sql[i])) {
-        value += sql[i];
-        i++;
-      }
-      tokens.push({ value, kind: "identifier", quoted: false });
-      continue;
-    }
-    if (char === "." || char === "," || char === "(" || char === ")" || char === ";") {
-      tokens.push({ value: char, kind: "punctuation", quoted: false });
-      i++;
-      continue;
-    }
-    i++;
-  }
-  return tokens;
-}
-function isKeyword(token, keywords) {
-  if (!token || token.kind !== "identifier" || token.quoted)
-    return false;
-  return keywords.has(token.value.toUpperCase());
-}
-function isPunctuation(token, value) {
-  return token?.kind === "punctuation" && token.value === value;
-}
-function readQualifiedName(tokens, index) {
-  const first = tokens[index];
-  if (!first || first.kind !== "identifier")
-    return null;
-  const parts = [first.value];
-  let cursor = index + 1;
-  while (isPunctuation(tokens[cursor], ".") && tokens[cursor + 1]?.kind === "identifier") {
-    parts.push(tokens[cursor + 1].value);
-    cursor += 2;
-  }
-  return { parts, next: cursor };
-}
-function decodedVariants(value) {
-  const decoded = value.replace(ANY_ESCAPE_SEQUENCE, (whole, _escape, long, short) => fromCodePointOrRaw(long ?? short, whole));
-  return decoded === value ? [] : [decoded];
-}
-function fromCodePointOrRaw(hex, whole) {
-  const codePoint = parseInt(hex, 16);
-  return codePoint <= 1114111 ? String.fromCodePoint(codePoint) : whole;
-}
-function extractTableReferences(sql, options = {}) {
-  const seen = new Set;
-  const references = [];
-  const record = (name) => {
-    const key = name.toLowerCase();
-    if (name.length === 0 || seen.has(key))
-      return;
-    seen.add(key);
-    references.push(name);
-  };
-  const dialects = options.dialect ? [options.dialect] : ["postgresql", "mysql", undefined];
-  for (const dialect of dialects) {
-    for (const backslashEscapes of [false, true]) {
-      collectReferences(tokenize(sql, dialect, backslashEscapes), record);
-    }
-  }
-  return references;
-}
-function collectReferences(tokens, record) {
-  const recordName = (parts) => {
-    const bare = parts[parts.length - 1];
-    record(bare);
-    for (const variant of decodedVariants(bare))
-      record(variant);
-    if (parts.length > 1)
-      record(parts.join("."));
-  };
-  let i = 0;
-  while (i < tokens.length) {
-    if (!isKeyword(tokens[i], TABLE_INTRODUCERS)) {
-      i++;
-      continue;
-    }
-    const introducer = tokens[i].value.toUpperCase();
-    const parenMeansFunction = introducer === "FROM" || introducer === "JOIN";
-    let cursor = i + 1;
-    while (isKeyword(tokens[cursor], PRE_TABLE_NOISE))
-      cursor++;
-    while (parenMeansFunction && isPunctuation(tokens[cursor], "(") && !isKeyword(tokens[cursor + 1], SUBQUERY_OPENERS) && tokens[cursor + 1]?.kind === "identifier") {
-      cursor++;
-    }
-    let expectTable = true;
-    while (expectTable) {
-      expectTable = false;
-      const name = readQualifiedName(tokens, cursor);
-      if (!name)
-        break;
-      const isFunctionCall = parenMeansFunction && isPunctuation(tokens[name.next], "(");
-      if (!isFunctionCall)
-        recordName(name.parts);
-      cursor = name.next;
-      if (isFunctionCall)
-        break;
-      if (isKeyword(tokens[cursor], AS_KEYWORD))
-        cursor++;
-      if (tokens[cursor]?.kind === "identifier" && !isKeyword(tokens[cursor], POST_TABLE_KEYWORDS)) {
-        cursor++;
-      }
-      while (isPunctuation(tokens[cursor], "(")) {
-        let depth = 0;
-        do {
-          if (isPunctuation(tokens[cursor], "("))
-            depth++;
-          else if (isPunctuation(tokens[cursor], ")"))
-            depth--;
-          cursor++;
-        } while (depth > 0 && cursor < tokens.length);
-        if (tokens[cursor]?.kind === "identifier" && !isKeyword(tokens[cursor], POST_TABLE_KEYWORDS))
-          cursor++;
-      }
-      if (isPunctuation(tokens[cursor], ",")) {
-        cursor++;
-        expectTable = true;
-      }
-    }
-    i = Math.max(cursor, i + 1);
-  }
-  let index = 0;
-  while (index < tokens.length) {
-    const token = tokens[index];
-    if (!token || token.kind !== "identifier") {
-      index++;
-      continue;
-    }
-    const name = readQualifiedName(tokens, index);
-    for (let part = 0;part < name.parts.length; part++) {
-      const value = name.parts[part];
-      const isQuoted = tokens[index + part * 2]?.quoted === true;
-      if (isQuoted || !RESERVED_KEYWORDS.has(value.toUpperCase())) {
-        record(value);
-        for (const variant of decodedVariants(value))
-          record(variant);
-      }
-    }
-    if (name.parts.length > 1)
-      record(name.parts.join("."));
-    index = name.next;
-  }
-}
-var TABLE_INTRODUCERS, PRE_TABLE_NOISE, SUBQUERY_OPENERS, AS_KEYWORD, POST_TABLE_KEYWORDS, RESERVED_KEYWORDS, IDENTIFIER_START2, IDENTIFIER_PART, ANY_ESCAPE_SEQUENCE;
-var init_sql_tables = __esm(() => {
-  init_sql_lexical();
-  TABLE_INTRODUCERS = new Set([
-    "FROM",
-    "JOIN",
-    "INTO",
-    "UPDATE",
-    "TABLE",
-    "TRUNCATE",
-    "COPY",
-    "USING",
-    "STRAIGHT_JOIN"
-  ]);
-  PRE_TABLE_NOISE = new Set(["ONLY", "LATERAL", "TABLE"]);
-  SUBQUERY_OPENERS = new Set(["SELECT", "WITH", "VALUES", "TABLE"]);
-  AS_KEYWORD = new Set(["AS"]);
-  POST_TABLE_KEYWORDS = new Set([
-    "AS",
-    "ON",
-    "USING",
-    "WHERE",
-    "GROUP",
-    "ORDER",
-    "HAVING",
-    "LIMIT",
-    "OFFSET",
-    "FETCH",
-    "WINDOW",
-    "UNION",
-    "INTERSECT",
-    "EXCEPT",
-    "JOIN",
-    "INNER",
-    "LEFT",
-    "RIGHT",
-    "FULL",
-    "OUTER",
-    "CROSS",
-    "NATURAL",
-    "STRAIGHT_JOIN",
-    "SET",
-    "VALUES",
-    "SELECT",
-    "RETURNING",
-    "FOR",
-    "INTO",
-    "PARTITION",
-    "WITH",
-    "TABLESAMPLE",
-    "FORCE",
-    "IGNORE",
-    "USE"
-  ]);
-  RESERVED_KEYWORDS = new Set([
-    "ALL",
-    "AND",
-    "AS",
-    "ASC",
-    "CASE",
-    "CROSS",
-    "DESC",
-    "DISTINCT",
-    "ELSE",
-    "FALSE",
-    "FOR",
-    "FROM",
-    "GROUP",
-    "HAVING",
-    "IN",
-    "INNER",
-    "INTO",
-    "IS",
-    "JOIN",
-    "LEFT",
-    "LIKE",
-    "LIMIT",
-    "NOT",
-    "NULL",
-    "ON",
-    "OR",
-    "ORDER",
-    "OUTER",
-    "RIGHT",
-    "SELECT",
-    "THEN",
-    "TRUE",
-    "UNION",
-    "USING",
-    "VALUES",
-    "WHEN",
-    "WHERE",
-    "WITH"
-  ]);
-  IDENTIFIER_START2 = /[A-Za-z_\u0080-\uFFFF]/;
-  IDENTIFIER_PART = /[A-Za-z0-9_$\u0080-\uFFFF]/;
-  ANY_ESCAPE_SEQUENCE = /([^0-9a-fA-F+'"\s])(?:\+([0-9a-fA-F]{6})|([0-9a-fA-F]{4}))/g;
-});
-
 // src/core/limits.ts
 var DEFAULT_QUERY_ONLY_LIMIT = 1000;
 
@@ -22402,7 +22657,10 @@ function maskMongoRowsForCollections(rows, collections, blacklist) {
     const prefixKey = `\x00${scope.collection}@${scope.prefix}`;
     return maskMongoRows(atTopLevel, prefixKey, {
       ...blacklist,
-      columns: { ...columns, [prefixKey]: rules.map((rule) => `${scope.prefix}.${rule}`) }
+      columns: {
+        ...columns,
+        [prefixKey]: rules.map((rule) => `${escapeGlob(scope.prefix)}.${rule}`)
+      }
     });
   }, rows);
 }
@@ -22411,10 +22669,14 @@ function maskMongoRows(rows, collection, blacklist) {
   const raw = columns[collection] ?? findCaseInsensitive(columns, collection);
   if (!raw || raw.length === 0)
     return rows;
-  const { patterns } = compilePatterns(raw);
+  const { patterns, rejected } = compilePatterns(raw);
+  if (rejected.length > 0) {
+    const detail = rejected.map((r) => `'${r.raw}' (${r.reason})`).join(", ");
+    throw new BlacklistError(`blacklist.columns for '${collection}' has entries this matcher cannot read: ${detail}`, collection, "READ");
+  }
   if (patterns.length === 0)
     return rows;
-  const idAffected = patterns.some((p) => p.segments.length === 1 && p.segments[0] === "_id" && !p.wildcardTail);
+  const idAffected = patterns.some((p) => p.segments.length === 1 && !p.wildcardTail && globMatches(p.segments[0], "_id"));
   if (idAffected) {
     console.error(`[blacklist] collection '${collection}' blacklists '_id'; read paths still expose _id to preserve document references.`);
   }
@@ -22456,7 +22718,12 @@ function findCaseInsensitive(columns, name) {
   return;
 }
 var REDACTED2 = "[REDACTED]";
-var init_field_masker = () => {};
+var init_field_masker = __esm(() => {
+  init_blacklist();
+  init_path_matcher();
+  init_glob();
+  init_glob();
+});
 
 // src/core/mongo/collection-references.ts
 function recordTarget(value, found) {
@@ -24224,6 +24491,7 @@ var init_query = __esm(() => {
   init_opener();
   init_query_executor();
   init_config();
+  init_blacklist_manager();
   init_blacklist_validator();
   init_config_path();
   init_validation();
@@ -26161,6 +26429,7 @@ async function qMongoBranch(snippet, prepared, options, config) {
 }
 var init_q_mongo = __esm(() => {
   init_adapters();
+  init_blacklist_manager();
   init_blacklist_validator();
   init_field_masker();
   init_collection_references();
@@ -26524,6 +26793,7 @@ var init_q = __esm(() => {
   init_adapters();
   init_config();
   init_config_path();
+  init_blacklist_manager();
   init_blacklist_validator();
   init_blacklist();
   init_permission_guard();
@@ -26792,6 +27062,365 @@ function previewDelete(collection, filter) {
 }
 var INDENT = 2;
 
+// src/utils/where-parser.ts
+function parseWhereClause(whereClause) {
+  if (!whereClause || whereClause.trim() === "") {
+    throw new Error("WHERE clause cannot be empty");
+  }
+  const conditions = {};
+  const andParts = whereClause.split(/\s+AND\s+/i);
+  for (const part of andParts) {
+    const match = part.match(/^(\w+)\s*=\s*(.+)$/);
+    if (!match) {
+      throw new Error(`Cannot parse WHERE clause: "${part}". Use format "column=value" or "col1=val1 AND col2=val2"`);
+    }
+    const column = match[1];
+    const valueStr = match[2];
+    if (valueStr === undefined || column === undefined) {
+      throw new Error(`Cannot parse WHERE clause: "${part}". Use format "column=value" or "col1=val1 AND col2=val2"`);
+    }
+    const trimmed = valueStr.trim();
+    const isFullyQuoted = trimmed.length >= 2 && (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith('"') && trimmed.endsWith('"'));
+    if (!isFullyQuoted && /\s+AND\s*$/i.test(trimmed)) {
+      throw new Error(`Cannot parse WHERE clause: "${part}". Use format "column=value" or "col1=val1 AND col2=val2"`);
+    }
+    const stripped = isFullyQuoted ? trimmed.slice(1, -1) : trimmed;
+    let value = stripped;
+    if (stripped !== "" && !isNaN(Number(stripped))) {
+      value = Number(stripped);
+    }
+    if (stripped === "true")
+      value = true;
+    else if (stripped === "false")
+      value = false;
+    else if (stripped === "null")
+      value = null;
+    conditions[column] = value;
+  }
+  return conditions;
+}
+
+// src/core/mongo/dml-plan.ts
+function permissionSql(operation) {
+  if (operation === "insert")
+    return "INSERT INTO dummy";
+  if (operation === "update")
+    return "UPDATE dummy";
+  return "DELETE FROM dummy";
+}
+function broadOperation(operation) {
+  if (operation === "insert")
+    return "INSERT";
+  if (operation === "update")
+    return "UPDATE";
+  return "DELETE";
+}
+function pushFactor2(factors, code, severity, message) {
+  if (factors.some((f) => f.code === code && f.message === message))
+    return;
+  factors.push({ code, severity, message });
+}
+function decide2(factors) {
+  if (factors.some((f) => f.severity === "block"))
+    return "BLOCK";
+  if (factors.some((f) => f.severity === "warn"))
+    return "WARN";
+  return "ALLOW";
+}
+function classifyMongoUpdate(setDoc) {
+  const fields = new Set;
+  const tierFactors = [];
+  let hasBlock = false;
+  const hasAnyOperator = Object.keys(setDoc).some((k) => k.startsWith("$"));
+  if (!hasAnyOperator) {
+    for (const k of Object.keys(setDoc))
+      fields.add(k);
+    return { fields: Array.from(fields), tierFactors, hasBlock };
+  }
+  const seenTiers = new Map;
+  for (const [op, payload] of Object.entries(setDoc)) {
+    if (!op.startsWith("$")) {
+      fields.add(op);
+      continue;
+    }
+    if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+      for (const k of Object.keys(payload))
+        fields.add(k);
+    }
+    const tier = MONGO_OPERATOR_TIER[op];
+    if (tier === undefined) {
+      hasBlock = true;
+      tierFactors.push({
+        code: "mongo_unknown_operator",
+        severity: "block",
+        message: `Update uses unknown operator '${op}'. Reject by default; add to tier table if intentional.`
+      });
+      continue;
+    }
+    if (tier === "BLOCK") {
+      hasBlock = true;
+      tierFactors.push({
+        code: "mongo_unknown_operator",
+        severity: "block",
+        message: `Update uses '${op}' which executes server-side code. Operation rejected.`
+      });
+      continue;
+    }
+    if (tier === "SAFE")
+      continue;
+    const bucket = seenTiers.get(tier) ?? [];
+    bucket.push(op);
+    seenTiers.set(tier, bucket);
+  }
+  for (const [tier, ops] of seenTiers) {
+    if (tier === "RENAME") {
+      tierFactors.push({
+        code: "mongo_rename_operator",
+        severity: "warn",
+        message: `Update uses ${ops.join(", ")}; a renamed field keeps its value under a name the read mask does not know.`
+      });
+    } else if (tier === "ARITHMETIC") {
+      tierFactors.push({
+        code: "mongo_arithmetic_operator",
+        severity: "warn",
+        message: `Update uses ${ops.join(", ")}; numeric mutation may compound silently.`
+      });
+    } else if (tier === "ARRAY") {
+      tierFactors.push({
+        code: "mongo_array_operator",
+        severity: "warn",
+        message: `Update uses ${ops.join(", ")}; array mutation can grow unboundedly without a size guard.`
+      });
+    } else if (tier === "BITWISE") {
+      tierFactors.push({
+        code: "mongo_bitwise_operator",
+        severity: "warn",
+        message: `Update uses ${ops.join(", ")}; bitwise updates skip type promotion checks.`
+      });
+    }
+  }
+  return { fields: Array.from(fields), tierFactors, hasBlock };
+}
+function hasIdEquality(where) {
+  if (!("_id" in where))
+    return false;
+  const value = where._id;
+  if (value === null || value === undefined)
+    return false;
+  if (typeof value === "object")
+    return false;
+  return true;
+}
+function hasNonIdEquality(where) {
+  for (const [key, value] of Object.entries(where)) {
+    if (key === "_id")
+      continue;
+    if (key.startsWith("$"))
+      continue;
+    if (value === null)
+      continue;
+    if (typeof value === "object")
+      continue;
+    return true;
+  }
+  return false;
+}
+function hasBroadFilter(where) {
+  for (const [key, value] of Object.entries(where)) {
+    if (MONGO_BROAD_FILTER_OPERATORS.has(key))
+      return true;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      for (const inner of Object.keys(value)) {
+        if (MONGO_BROAD_FILTER_OPERATORS.has(inner))
+          return true;
+      }
+    }
+  }
+  return false;
+}
+function applyPermission(operation, context, factors) {
+  const permResult = checkPermission(permissionSql(operation), context.permission);
+  if (!permResult.allowed) {
+    pushFactor2(factors, "permission_denied", "block", permResult.reason);
+  }
+}
+function applyTableBlacklist(target, context, factors) {
+  const blacklisted = (context.blacklist.tables ?? []).map((t2) => t2.toLowerCase());
+  if (blacklisted.includes(target.toLowerCase())) {
+    pushFactor2(factors, "table_blacklisted", "block", `Target collection ${target} is blacklisted.`);
+  }
+}
+function applyColumnBlacklist(target, fields, context, factors) {
+  const columns = context.blacklist.columns ?? {};
+  const lower = target.toLowerCase();
+  let raw = [];
+  for (const [t2, cols] of Object.entries(columns)) {
+    if (t2.toLowerCase() === lower) {
+      raw = cols;
+      break;
+    }
+  }
+  if (raw.length === 0)
+    return;
+  const { patterns, rejected } = compilePatterns(raw);
+  if (rejected.length > 0) {
+    const detail = rejected.map((r) => `'${r.raw}' (${r.reason})`).join(", ");
+    pushFactor2(factors, "blacklist_unreadable", "block", `blacklist.columns for '${target}' has entries this matcher cannot read: ${detail}`);
+    return;
+  }
+  if (patterns.length === 0)
+    return;
+  for (const field of fields) {
+    if (matchAny(field, patterns)) {
+      pushFactor2(factors, "blacklisted_column", "block", `MongoDB write would touch blacklisted path ${target}.${field}.`);
+    }
+  }
+}
+function applySchemaCoverage(target, context, factors) {
+  const schemaTables = Object.keys(context.schema);
+  if (schemaTables.length === 0) {
+    pushFactor2(factors, "schema_cache_missing", "warn", "Schema cache is missing for the selected connection.");
+    return;
+  }
+  const known = schemaTables.some((t2) => t2.toLowerCase() === target.toLowerCase());
+  if (!known) {
+    pushFactor2(factors, "schema_table_unknown", "warn", `Target collection ${target} is missing from schema cache.`);
+  }
+}
+function buildRecommendations2(factors) {
+  const out = new Set;
+  const codes = new Set(factors.map((f) => f.code));
+  if (codes.has("nonsql_filter_empty")) {
+    out.add("Add an _id equality filter before executing this MongoDB write.");
+  }
+  if (codes.has("nonsql_missing_id")) {
+    out.add("Prefer an _id equality filter before executing this MongoDB write.");
+  }
+  if (codes.has("nonsql_filter_broad")) {
+    out.add("Narrow the filter to an _id equality or a tightly bounded condition.");
+  }
+  if (codes.has("nonsql_unsupported_operator")) {
+    out.add("Restrict the update document to $set / $unset for planner-safe writes.");
+  }
+  if (codes.has("permission_denied")) {
+    out.add("Switch to a connection with sufficient permission only if the operation is intended.");
+  }
+  if (codes.has("table_blacklisted") || codes.has("blacklisted_column")) {
+    out.add("Review blacklist rules before accessing sensitive data.");
+  }
+  if (codes.has("schema_cache_missing") || codes.has("schema_table_unknown")) {
+    out.add("Refresh schema cache for the target collection before executing.");
+  }
+  out.add("Use --dry-run on the actual write command.");
+  return Array.from(out);
+}
+function buildSuggestedCommands2(target, factors) {
+  const codes = new Set(factors.map((f) => f.code));
+  if (codes.has("schema_cache_missing") || codes.has("schema_table_unknown")) {
+    return [`dbcli schema ${target} --format json`];
+  }
+  return [];
+}
+function flattenInsertPaths(data, prefix = "") {
+  const out = [];
+  for (const [k, v] of Object.entries(data)) {
+    const path2 = prefix === "" ? k : `${prefix}.${k}`;
+    out.push(path2);
+    if (v && typeof v === "object" && !Array.isArray(v) && !(v instanceof Date)) {
+      const ctor = v.constructor?.name;
+      if (ctor === "Object") {
+        out.push(...flattenInsertPaths(v, path2));
+      }
+    }
+  }
+  return out;
+}
+var MONGO_OPERATOR_TIER, MONGO_BROAD_FILTER_OPERATORS, analyzeMongoDmlRisk = (intent, context) => {
+  const factors = [];
+  applyPermission(intent.operation, context, factors);
+  applyTableBlacklist(intent.target, context, factors);
+  if (intent.operation === "insert") {
+    applyColumnBlacklist(intent.target, flattenInsertPaths(intent.data), context, factors);
+  } else if (intent.operation === "update") {
+    const cls = classifyMongoUpdate(intent.set);
+    for (const f of cls.tierFactors)
+      pushFactor2(factors, f.code, f.severity, f.message);
+    applyColumnBlacklist(intent.target, cls.fields, context, factors);
+    const where = intent.where ?? {};
+    if (Object.keys(where).length === 0) {
+      pushFactor2(factors, "nonsql_filter_empty", "block", "MongoDB update filter is empty and would match every document.");
+    } else if (!hasIdEquality(where)) {
+      if (hasBroadFilter(where)) {
+        pushFactor2(factors, "nonsql_filter_broad", "warn", "MongoDB update filter uses a broad operator and may match multiple documents.");
+      } else if (hasNonIdEquality(where)) {
+        pushFactor2(factors, "nonsql_missing_id", "warn", "MongoDB update filter does not use _id and may match multiple documents.");
+      } else {
+        pushFactor2(factors, "nonsql_filter_broad", "warn", "MongoDB update filter is not an _id equality and may match multiple documents.");
+      }
+    }
+  } else {
+    const where = intent.where ?? {};
+    if (Object.keys(where).length === 0) {
+      pushFactor2(factors, "nonsql_filter_empty", "block", "MongoDB delete filter is empty and would match every document.");
+    } else if (!hasIdEquality(where)) {
+      if (hasBroadFilter(where)) {
+        pushFactor2(factors, "nonsql_filter_broad", "warn", "MongoDB delete filter uses a broad operator and may match multiple documents.");
+      } else if (hasNonIdEquality(where)) {
+        pushFactor2(factors, "nonsql_missing_id", "warn", "MongoDB delete filter does not use _id and may match multiple documents.");
+      } else {
+        pushFactor2(factors, "nonsql_filter_broad", "warn", "MongoDB delete filter is not an _id equality and may match multiple documents.");
+      }
+    }
+  }
+  applySchemaCoverage(intent.target, context, factors);
+  return {
+    decision: decide2(factors),
+    operation: broadOperation(intent.operation),
+    targetTables: [intent.target],
+    riskFactors: factors,
+    recommendations: buildRecommendations2(factors),
+    suggestedCommands: buildSuggestedCommands2(intent.target, factors)
+  };
+};
+var init_dml_plan = __esm(() => {
+  init_path_matcher();
+  init_permission_guard();
+  MONGO_OPERATOR_TIER = {
+    $set: "SAFE",
+    $unset: "SAFE",
+    $rename: "RENAME",
+    $inc: "ARITHMETIC",
+    $mul: "ARITHMETIC",
+    $min: "ARITHMETIC",
+    $max: "ARITHMETIC",
+    $currentDate: "ARITHMETIC",
+    $push: "ARRAY",
+    $pull: "ARRAY",
+    $pullAll: "ARRAY",
+    $pop: "ARRAY",
+    $addToSet: "ARRAY",
+    $bit: "BITWISE",
+    $where: "BLOCK"
+  };
+  MONGO_BROAD_FILTER_OPERATORS = new Set([
+    "$regex",
+    "$in",
+    "$nin",
+    "$gt",
+    "$gte",
+    "$lt",
+    "$lte",
+    "$ne",
+    "$exists",
+    "$or",
+    "$and",
+    "$nor",
+    "$not",
+    "$expr",
+    "$text"
+  ]);
+});
+
 // src/core/dml-plan-sql.ts
 function assertIdentifier(value, role) {
   if (!value || !IDENTIFIER_RE.test(value)) {
@@ -26851,359 +27480,6 @@ var init_dml_plan_sql = __esm(() => {
   IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 });
 
-// src/utils/where-parser.ts
-function parseWhereClause(whereClause) {
-  if (!whereClause || whereClause.trim() === "") {
-    throw new Error("WHERE clause cannot be empty");
-  }
-  const conditions = {};
-  const andParts = whereClause.split(/\s+AND\s+/i);
-  for (const part of andParts) {
-    const match = part.match(/^(\w+)\s*=\s*(.+)$/);
-    if (!match) {
-      throw new Error(`Cannot parse WHERE clause: "${part}". Use format "column=value" or "col1=val1 AND col2=val2"`);
-    }
-    const column = match[1];
-    const valueStr = match[2];
-    if (valueStr === undefined || column === undefined) {
-      throw new Error(`Cannot parse WHERE clause: "${part}". Use format "column=value" or "col1=val1 AND col2=val2"`);
-    }
-    const trimmed = valueStr.trim();
-    const isFullyQuoted = trimmed.length >= 2 && (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith('"') && trimmed.endsWith('"'));
-    if (!isFullyQuoted && /\s+AND\s*$/i.test(trimmed)) {
-      throw new Error(`Cannot parse WHERE clause: "${part}". Use format "column=value" or "col1=val1 AND col2=val2"`);
-    }
-    const stripped = isFullyQuoted ? trimmed.slice(1, -1) : trimmed;
-    let value = stripped;
-    if (stripped !== "" && !isNaN(Number(stripped))) {
-      value = Number(stripped);
-    }
-    if (stripped === "true")
-      value = true;
-    else if (stripped === "false")
-      value = false;
-    else if (stripped === "null")
-      value = null;
-    conditions[column] = value;
-  }
-  return conditions;
-}
-
-// src/core/mongo/dml-plan.ts
-function permissionSql(operation) {
-  if (operation === "insert")
-    return "INSERT INTO dummy";
-  if (operation === "update")
-    return "UPDATE dummy";
-  return "DELETE FROM dummy";
-}
-function broadOperation(operation) {
-  if (operation === "insert")
-    return "INSERT";
-  if (operation === "update")
-    return "UPDATE";
-  return "DELETE";
-}
-function pushFactor2(factors, code, severity, message) {
-  if (factors.some((f) => f.code === code && f.message === message))
-    return;
-  factors.push({ code, severity, message });
-}
-function decide2(factors) {
-  if (factors.some((f) => f.severity === "block"))
-    return "BLOCK";
-  if (factors.some((f) => f.severity === "warn"))
-    return "WARN";
-  return "ALLOW";
-}
-function classifyMongoUpdate(setDoc) {
-  const fields = new Set;
-  const tierFactors = [];
-  let hasBlock = false;
-  const hasAnyOperator = Object.keys(setDoc).some((k) => k.startsWith("$"));
-  if (!hasAnyOperator) {
-    for (const k of Object.keys(setDoc))
-      fields.add(k);
-    return { fields: Array.from(fields), tierFactors, hasBlock };
-  }
-  const seenTiers = new Map;
-  for (const [op, payload] of Object.entries(setDoc)) {
-    if (!op.startsWith("$")) {
-      fields.add(op);
-      continue;
-    }
-    if (payload && typeof payload === "object" && !Array.isArray(payload)) {
-      for (const k of Object.keys(payload))
-        fields.add(k);
-    }
-    const tier = MONGO_OPERATOR_TIER[op];
-    if (tier === undefined) {
-      hasBlock = true;
-      tierFactors.push({
-        code: "mongo_unknown_operator",
-        severity: "block",
-        message: `Update uses unknown operator '${op}'. Reject by default; add to tier table if intentional.`
-      });
-      continue;
-    }
-    if (tier === "BLOCK") {
-      hasBlock = true;
-      tierFactors.push({
-        code: "mongo_unknown_operator",
-        severity: "block",
-        message: `Update uses '${op}' which executes server-side code. Operation rejected.`
-      });
-      continue;
-    }
-    if (tier === "SAFE")
-      continue;
-    const bucket = seenTiers.get(tier) ?? [];
-    bucket.push(op);
-    seenTiers.set(tier, bucket);
-  }
-  for (const [tier, ops] of seenTiers) {
-    if (tier === "RENAME") {
-      tierFactors.push({
-        code: "mongo_rename_operator",
-        severity: "warn",
-        message: `Update uses ${ops.join(", ")}; field rename does not exfiltrate data but can break readers.`
-      });
-    } else if (tier === "ARITHMETIC") {
-      tierFactors.push({
-        code: "mongo_arithmetic_operator",
-        severity: "warn",
-        message: `Update uses ${ops.join(", ")}; numeric mutation may compound silently.`
-      });
-    } else if (tier === "ARRAY") {
-      tierFactors.push({
-        code: "mongo_array_operator",
-        severity: "warn",
-        message: `Update uses ${ops.join(", ")}; array mutation can grow unboundedly without a size guard.`
-      });
-    } else if (tier === "BITWISE") {
-      tierFactors.push({
-        code: "mongo_bitwise_operator",
-        severity: "warn",
-        message: `Update uses ${ops.join(", ")}; bitwise updates skip type promotion checks.`
-      });
-    }
-  }
-  return { fields: Array.from(fields), tierFactors, hasBlock };
-}
-function hasIdEquality(where) {
-  if (!("_id" in where))
-    return false;
-  const value = where._id;
-  if (value === null || value === undefined)
-    return false;
-  if (typeof value === "object")
-    return false;
-  return true;
-}
-function hasNonIdEquality(where) {
-  for (const [key, value] of Object.entries(where)) {
-    if (key === "_id")
-      continue;
-    if (key.startsWith("$"))
-      continue;
-    if (value === null)
-      continue;
-    if (typeof value === "object")
-      continue;
-    return true;
-  }
-  return false;
-}
-function hasBroadFilter(where) {
-  for (const [key, value] of Object.entries(where)) {
-    if (MONGO_BROAD_FILTER_OPERATORS.has(key))
-      return true;
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      for (const inner of Object.keys(value)) {
-        if (MONGO_BROAD_FILTER_OPERATORS.has(inner))
-          return true;
-      }
-    }
-  }
-  return false;
-}
-function applyPermission(operation, context, factors) {
-  const permResult = checkPermission(permissionSql(operation), context.permission);
-  if (!permResult.allowed) {
-    pushFactor2(factors, "permission_denied", "block", permResult.reason);
-  }
-}
-function applyTableBlacklist(target, context, factors) {
-  const blacklisted = (context.blacklist.tables ?? []).map((t2) => t2.toLowerCase());
-  if (blacklisted.includes(target.toLowerCase())) {
-    pushFactor2(factors, "table_blacklisted", "block", `Target collection ${target} is blacklisted.`);
-  }
-}
-function applyColumnBlacklist(target, fields, context, factors) {
-  const columns = context.blacklist.columns ?? {};
-  const lower = target.toLowerCase();
-  let raw = [];
-  for (const [t2, cols] of Object.entries(columns)) {
-    if (t2.toLowerCase() === lower) {
-      raw = cols;
-      break;
-    }
-  }
-  if (raw.length === 0)
-    return;
-  const { patterns } = compilePatterns(raw);
-  if (patterns.length === 0)
-    return;
-  for (const field of fields) {
-    if (matchAny(field, patterns)) {
-      pushFactor2(factors, "blacklisted_column", "block", `MongoDB write would touch blacklisted path ${target}.${field}.`);
-    }
-  }
-}
-function applySchemaCoverage(target, context, factors) {
-  const schemaTables = Object.keys(context.schema);
-  if (schemaTables.length === 0) {
-    pushFactor2(factors, "schema_cache_missing", "warn", "Schema cache is missing for the selected connection.");
-    return;
-  }
-  const known = schemaTables.some((t2) => t2.toLowerCase() === target.toLowerCase());
-  if (!known) {
-    pushFactor2(factors, "schema_table_unknown", "warn", `Target collection ${target} is missing from schema cache.`);
-  }
-}
-function buildRecommendations2(factors) {
-  const out = new Set;
-  const codes = new Set(factors.map((f) => f.code));
-  if (codes.has("nonsql_filter_empty")) {
-    out.add("Add an _id equality filter before executing this MongoDB write.");
-  }
-  if (codes.has("nonsql_missing_id")) {
-    out.add("Prefer an _id equality filter before executing this MongoDB write.");
-  }
-  if (codes.has("nonsql_filter_broad")) {
-    out.add("Narrow the filter to an _id equality or a tightly bounded condition.");
-  }
-  if (codes.has("nonsql_unsupported_operator")) {
-    out.add("Restrict the update document to $set / $unset for planner-safe writes.");
-  }
-  if (codes.has("permission_denied")) {
-    out.add("Switch to a connection with sufficient permission only if the operation is intended.");
-  }
-  if (codes.has("table_blacklisted") || codes.has("blacklisted_column")) {
-    out.add("Review blacklist rules before accessing sensitive data.");
-  }
-  if (codes.has("schema_cache_missing") || codes.has("schema_table_unknown")) {
-    out.add("Refresh schema cache for the target collection before executing.");
-  }
-  out.add("Use --dry-run on the actual write command.");
-  return Array.from(out);
-}
-function buildSuggestedCommands2(target, factors) {
-  const codes = new Set(factors.map((f) => f.code));
-  if (codes.has("schema_cache_missing") || codes.has("schema_table_unknown")) {
-    return [`dbcli schema ${target} --format json`];
-  }
-  return [];
-}
-function flattenInsertPaths(data, prefix = "") {
-  const out = [];
-  for (const [k, v] of Object.entries(data)) {
-    const path2 = prefix === "" ? k : `${prefix}.${k}`;
-    out.push(path2);
-    if (v && typeof v === "object" && !Array.isArray(v) && !(v instanceof Date)) {
-      const ctor = v.constructor?.name;
-      if (ctor === "Object") {
-        out.push(...flattenInsertPaths(v, path2));
-      }
-    }
-  }
-  return out;
-}
-var MONGO_OPERATOR_TIER, MONGO_BROAD_FILTER_OPERATORS, analyzeMongoDmlRisk = (intent, context) => {
-  const factors = [];
-  applyPermission(intent.operation, context, factors);
-  applyTableBlacklist(intent.target, context, factors);
-  if (intent.operation === "insert") {
-    applyColumnBlacklist(intent.target, flattenInsertPaths(intent.data), context, factors);
-  } else if (intent.operation === "update") {
-    const cls = classifyMongoUpdate(intent.set);
-    for (const f of cls.tierFactors)
-      pushFactor2(factors, f.code, f.severity, f.message);
-    applyColumnBlacklist(intent.target, cls.fields, context, factors);
-    const where = intent.where ?? {};
-    if (Object.keys(where).length === 0) {
-      pushFactor2(factors, "nonsql_filter_empty", "block", "MongoDB update filter is empty and would match every document.");
-    } else if (!hasIdEquality(where)) {
-      if (hasBroadFilter(where)) {
-        pushFactor2(factors, "nonsql_filter_broad", "warn", "MongoDB update filter uses a broad operator and may match multiple documents.");
-      } else if (hasNonIdEquality(where)) {
-        pushFactor2(factors, "nonsql_missing_id", "warn", "MongoDB update filter does not use _id and may match multiple documents.");
-      } else {
-        pushFactor2(factors, "nonsql_filter_broad", "warn", "MongoDB update filter is not an _id equality and may match multiple documents.");
-      }
-    }
-  } else {
-    const where = intent.where ?? {};
-    if (Object.keys(where).length === 0) {
-      pushFactor2(factors, "nonsql_filter_empty", "block", "MongoDB delete filter is empty and would match every document.");
-    } else if (!hasIdEquality(where)) {
-      if (hasBroadFilter(where)) {
-        pushFactor2(factors, "nonsql_filter_broad", "warn", "MongoDB delete filter uses a broad operator and may match multiple documents.");
-      } else if (hasNonIdEquality(where)) {
-        pushFactor2(factors, "nonsql_missing_id", "warn", "MongoDB delete filter does not use _id and may match multiple documents.");
-      } else {
-        pushFactor2(factors, "nonsql_filter_broad", "warn", "MongoDB delete filter is not an _id equality and may match multiple documents.");
-      }
-    }
-  }
-  applySchemaCoverage(intent.target, context, factors);
-  return {
-    decision: decide2(factors),
-    operation: broadOperation(intent.operation),
-    targetTables: [intent.target],
-    riskFactors: factors,
-    recommendations: buildRecommendations2(factors),
-    suggestedCommands: buildSuggestedCommands2(intent.target, factors)
-  };
-};
-var init_dml_plan = __esm(() => {
-  init_permission_guard();
-  MONGO_OPERATOR_TIER = {
-    $set: "SAFE",
-    $unset: "SAFE",
-    $rename: "RENAME",
-    $inc: "ARITHMETIC",
-    $mul: "ARITHMETIC",
-    $min: "ARITHMETIC",
-    $max: "ARITHMETIC",
-    $currentDate: "ARITHMETIC",
-    $push: "ARRAY",
-    $pull: "ARRAY",
-    $pullAll: "ARRAY",
-    $pop: "ARRAY",
-    $addToSet: "ARRAY",
-    $bit: "BITWISE",
-    $where: "BLOCK"
-  };
-  MONGO_BROAD_FILTER_OPERATORS = new Set([
-    "$regex",
-    "$in",
-    "$nin",
-    "$gt",
-    "$gte",
-    "$lt",
-    "$lte",
-    "$ne",
-    "$exists",
-    "$or",
-    "$and",
-    "$nor",
-    "$not",
-    "$expr",
-    "$text"
-  ]);
-});
-
 // src/core/redis/dml-plan.ts
 function permissionSql2(operation) {
   if (operation === "insert")
@@ -27665,7 +27941,7 @@ async function insertCommand(table, options, command) {
       const blacklistManager = new BlacklistManager(config);
       const blacklistValidator = new BlacklistValidator(blacklistManager);
       blacklistValidator.checkTableBlacklist("INSERT", table, []);
-      blacklistValidator.checkColumnBlacklistOnWrite(table, Object.keys(data), "INSERT");
+      blacklistValidator.checkColumnBlacklistOnWrite(table, flattenInsertPaths(data), "INSERT");
       const preview = `SET ${table} ... (Redis Insert)`;
       if (options.dryRun) {
         const output = {
@@ -27730,7 +28006,7 @@ async function insertCommand(table, options, command) {
       const blacklistManager = new BlacklistManager(config);
       const blacklistValidator = new BlacklistValidator(blacklistManager);
       blacklistValidator.checkTableBlacklist("INSERT", table, []);
-      blacklistValidator.checkColumnBlacklistOnWrite(table, Object.keys(data), "INSERT");
+      blacklistValidator.checkColumnBlacklistOnWrite(table, flattenInsertPaths(data), "INSERT");
       const preview = previewInsert(table, data);
       if (options.dryRun) {
         const output = {
@@ -27848,9 +28124,11 @@ var init_insert = __esm(() => {
   init_mutation_outcome();
   init_config();
   init_permission_guard();
+  init_blacklist_manager();
   init_blacklist_validator();
   init_blacklist();
   init_config_path();
+  init_dml_plan();
   init_dml_plan4();
   init_integration_helper();
 });
@@ -28008,7 +28286,11 @@ async function updateCommand(table, options, command) {
       if (hasOperator) {
         const operators = updateDoc;
         for (const [op, payload] of Object.entries(operators)) {
-          if ((op === "$set" || op === "$unset") && payload && typeof payload === "object" && !Array.isArray(payload)) {
+          if (!op.startsWith("$")) {
+            writtenFields.add(op);
+            continue;
+          }
+          if (payload && typeof payload === "object" && !Array.isArray(payload)) {
             for (const k of Object.keys(payload))
               writtenFields.add(k);
           }
@@ -28169,6 +28451,7 @@ var init_update = __esm(() => {
   init_mutation_outcome();
   init_config();
   init_permission_guard();
+  init_blacklist_manager();
   init_blacklist_validator();
   init_blacklist();
   init_config_path();
@@ -28468,6 +28751,7 @@ var init_delete = __esm(() => {
   init_mutation_outcome();
   init_config();
   init_permission_guard();
+  init_blacklist_manager();
   init_blacklist_validator();
   init_blacklist();
   init_config_path();
@@ -28911,6 +29195,7 @@ var init_export = __esm(() => {
   init_config();
   init_prompts();
   init_config_path();
+  init_blacklist_manager();
   init_blacklist_validator();
   init_applied_limit();
   init_integration_helper();
@@ -30147,6 +30432,7 @@ async function gatherContext(workspaceRoot, configPath, options = {}) {
 }
 var init_context = __esm(() => {
   init_config();
+  init_blacklist_manager();
   init_loader();
   init_snippet_paths();
   init_semantic();
@@ -31363,11 +31649,8 @@ function auditBlacklistPatterns(cfg) {
   }
   return { warnings };
 }
-function isValidTableNameForSystem(name, system) {
-  if (!isValidTableName(name))
-    return false;
-  const literalMatching = system === "postgresql" || system === "mysql" || system === "mariadb" || system === "mongodb";
-  return !(literalMatching && GLOB_CHARS.test(name));
+function isValidTableNameForSystem(name, _system) {
+  return isValidTableName(name);
 }
 function isValidTableName(name) {
   return VALID_TABLE_NAME.test(name);
@@ -31533,16 +31816,16 @@ function resolveBlacklistConfigPath(options, command) {
   }
   return DEFAULT_CONFIG_PATH;
 }
-var DEFAULT_CONFIG_PATH = ".dbcli", VALID_TABLE_NAME, VALID_COLUMN_NAME, GLOB_CHARS, blacklistCommand, tableCmd, columnCmd;
+var DEFAULT_CONFIG_PATH = ".dbcli", VALID_TABLE_NAME, VALID_COLUMN_NAME, blacklistCommand, tableCmd, columnCmd;
 var init_blacklist2 = __esm(() => {
   init_config_v2();
   init_esm();
   init_message_loader();
   init_config();
+  init_path_matcher();
   init_validation();
-  VALID_TABLE_NAME = /^[a-zA-Z0-9_.*?:@[\]-]+$/;
-  VALID_COLUMN_NAME = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-  GLOB_CHARS = /[*?[\]]/;
+  VALID_TABLE_NAME = /^[a-zA-Z0-9_.*?:@[\]\\-]+$/;
+  VALID_COLUMN_NAME = /^[a-zA-Z0-9_*?[\]\\-]+$/;
   blacklistCommand = new Command("blacklist").description(t("blacklist.description"));
   blacklistCommand.command("list").description(t("blacklist.list_title")).option("--config <path>", "Path to .dbcli config file").option("--format <type>", "Output format: text, json", "text").action(async (options, command) => {
     try {
@@ -31718,6 +32001,7 @@ var init_check = __esm(() => {
   init_adapters();
   init_config();
   init_health_checker();
+  init_blacklist_manager();
   init_size_category();
   init_validation();
   init_connection_selector();
@@ -33594,9 +33878,8 @@ var init_proposals = __esm(() => {
 });
 
 // src/core/orm-drift/compare.ts
-function globToRegex2(glob) {
-  const escaped = glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`);
+function starOnlyGlob(glob) {
+  return glob.replace(/[?[\]\\]/g, "\\$&");
 }
 function tableMap(schema, defaultSchema) {
   const tables = new Map;
@@ -33630,7 +33913,7 @@ function compareNormalized(orm, db, opts) {
   const tableKeys = new Set([...ormTables.keys(), ...dbTables.keys()]);
   const extraDefaultIgnore = opts.extraDefaultIgnore ?? [];
   const defaultIgnore = [...DEFAULT_IGNORE, ...extraDefaultIgnore];
-  const ignorePatterns = opts.ignore.map(globToRegex2);
+  const ignorePatterns = opts.ignore;
   const targetLabel = opts.targetLabel ?? "database";
   const entries = [];
   for (const tableKey of tableKeys) {
@@ -33641,7 +33924,7 @@ function compareNormalized(orm, db, opts) {
       continue;
     const table = qualifiedTableName(normalizedTable.identity);
     const isDefaultIgnored = defaultIgnore.includes(normalizedTable.identity.table);
-    if (isDefaultIgnored || ignorePatterns.some((pattern) => pattern.test(table))) {
+    if (isDefaultIgnored || ignorePatterns.some((pattern) => globMatches(starOnlyGlob(pattern), table))) {
       entries.push(entryWithProposals({
         category: "unmanaged",
         severity: "info",
@@ -33823,6 +34106,7 @@ function compareIndexes(ormIndexes, dbIndexes, tableIdentity, table, ormSource,
 var DEFAULT_IGNORE, entryOrder = (left, right) => codePointOrder(left.table, right.table) || codePointOrder(left.object, right.object) || codePointOrder(left.category, right.category) || codePointOrder(left.detail, right.detail);
 var init_compare = __esm(() => {
   init_normalized_schema();
+  init_glob();
   init_proposals();
   DEFAULT_IGNORE = ["_prisma_migrations"];
 });
@@ -34719,7 +35003,7 @@ function shouldEmbedRecent(opts) {
   return opts.forAgent === true || opts.format === "json";
 }
 function briefifyForRecent(entry) {
-  const phase = entry.metadata?.es_shell_phase;
+  const phase = entry.metadata?.shell_phase;
   return {
     id: entry.id,
     ts: entry.ts,
@@ -35426,6 +35710,7 @@ var init_collector2 = __esm(() => {
   init_saved_queries();
   init_select_snippets();
   init_run_diagnostic();
+  init_blacklist_manager();
   init_blacklist_validator();
   init_section_map();
   init_types7();
@@ -37431,7 +37716,7 @@ function parseTailN(raw) {
   return requested;
 }
 function briefify(entry) {
-  const phase = entry.metadata?.es_shell_phase;
+  const phase = entry.metadata?.shell_phase;
   return {
     ts: entry.ts,
     command: entry.command,
@@ -37486,8 +37771,8 @@ function renderTailAllTable(envelopes) {
 }
 function briefifyShow(entry) {
   const { metadata, redacted_query, ...rest } = entry;
-  const phase = metadata?.es_shell_phase;
-  return phase === undefined ? rest : { ...rest, metadata: { es_shell_phase: phase } };
+  const phase = metadata?.shell_phase;
+  return phase === undefined ? rest : { ...rest, metadata: { shell_phase: phase } };
 }
 function renderEntryTable(entry) {
   const lines = [];
@@ -42015,6 +42300,7 @@ var init_snapshot = __esm(() => {
   init_config();
   init_config_path();
   init_validation();
+  init_blacklist_manager();
   init_blacklist_validator();
   init_query_executor();
   init_permission_guard();
@@ -42683,6 +42969,7 @@ var init_assert = __esm(() => {
   init_config();
   init_config_path();
   init_validation();
+  init_blacklist_manager();
   init_blacklist_validator();
   init_query_executor();
   init_saved_queries();
@@ -44861,6 +45148,7 @@ var init_verify2 = __esm(() => {
   init_adapters();
   init_config();
   init_config_path();
+  init_blacklist_manager();
   init_blacklist_validator();
   init_query_executor();
   init_query_risk_analyzer();
@@ -45612,15 +45900,17 @@ class ReplEngine {
   adapter;
   context;
   writeGate;
+  auditSink;
   state;
   buffer;
   history;
   formatter;
   config;
-  constructor(adapter, context, historyPath, config = null, writeGate = null) {
+  constructor(adapter, context, historyPath, config = null, writeGate = null, auditSink = null) {
     this.adapter = adapter;
     this.context = context;
     this.writeGate = writeGate;
+    this.auditSink = auditSink;
     this.state = { format: "table", timing: false, connected: true, noLimit: false };
     this.buffer = new MultilineBuffer;
     this.history = new HistoryManager(historyPath);
@@ -45752,10 +46042,11 @@ class ReplEngine {
     } else {
       const permResult = checkPermission(sql, this.context.permission, SQL_DIALECTS.find((dialect) => dialect === this.context.system));
       if (!permResult.allowed) {
+        await this.auditSink?.({ phase: "outcome", success: false, statement: sql });
         return {
           action: "continue",
           output: import_picocolors3.default.red(t_vars("shell.error_permission", {
-            required: permResult.classification.type === "UNKNOWN" ? "admin" : "read-write",
+            required: permResult.requiredPermission ?? "admin",
             current: this.context.permission
           }))
         };
@@ -45771,18 +46062,22 @@ class ReplEngine {
       } catch (error) {
         if (!(error instanceof BlacklistError))
           throw error;
+        await this.auditSink?.({ phase: "outcome", success: false, statement: sql });
         return {
           action: "continue",
           output: import_picocolors3.default.red(t_vars("shell.error_blacklisted", { table: error.message }))
         };
       }
     }
-    if (this.writeGate && !await this.writeGate(sql))
+    if (this.writeGate && !await this.writeGate(sql)) {
+      await this.auditSink?.({ phase: "outcome", success: false, statement: sql });
       return { action: "continue" };
+    }
     return this.runStatement(sql, blacklistValidator, referencedTables);
   }
   async runStatement(sql, blacklistValidator, referencedTables) {
     const startTime = Date.now();
+    await this.auditSink?.({ phase: "attempt", success: true, statement: sql });
     try {
       const result = await this.adapter.execute(sql, undefined, {
         noLimit: this.state.noLimit
@@ -45808,6 +46103,7 @@ class ReplEngine {
 ` + import_picocolors3.default.dim(t_vars("shell.timing_display", { ms: String(elapsed) }));
       }
       this.state = { ...this.state, connected: true };
+      await this.auditSink?.({ phase: "outcome", success: true, statement: sql });
       return { action: "continue", output };
     } catch (error) {
       if (this.isConnectionError(error) && this.state.connected) {
@@ -45819,12 +46115,14 @@ class ReplEngine {
           console.error(import_picocolors3.default.green(t("shell.error_reconnect_success")));
           return this.runStatement(sql, blacklistValidator, referencedTables);
         } catch (reconnectError) {
+          await this.auditSink?.({ phase: "outcome", success: false, statement: sql });
           return {
             action: "continue",
             output: import_picocolors3.default.red(t_vars("shell.error_reconnect_failed", { message: reconnectError.message }))
           };
         }
       }
+      await this.auditSink?.({ phase: "outcome", success: false, statement: sql });
       return {
         action: "continue",
         output: import_picocolors3.default.red(t_vars("shell.error_sql_failed", { message: error.message }))
@@ -45859,6 +46157,7 @@ var init_repl_engine = __esm(() => {
   init_query_result_formatter();
   init_message_loader();
   init_sql_tables();
+  init_blacklist_manager();
   init_blacklist_validator();
   init_blacklist();
   import_picocolors3 = __toESM(require_picocolors(), 1);
@@ -46400,7 +46699,7 @@ async function executeEsBlock(block2, session) {
         target: record4.target,
         sql: record4.statement,
         sideEffectTier: record4.tierOverride,
-        metadata: { es_shell_phase: record4.phase }
+        metadata: { shell_phase: record4.phase }
       })
     });
     console.log(JSON.stringify(res, null, 2));
@@ -46600,6 +46899,25 @@ var init_shell_write_gate = __esm(() => {
   init_write_gate_guard();
 });
 
+// src/commands/shell-audit-sink.ts
+var exports_shell_audit_sink = {};
+__export(exports_shell_audit_sink, {
+  createShellAuditSink: () => createShellAuditSink
+});
+function createShellAuditSink(options) {
+  const write = options.write ?? writeAuditEntryResult;
+  return async (record4) => {
+    return await write(options.config, "shell", { config: options.configPath }, {
+      success: record4.success,
+      sql: record4.statement,
+      metadata: { shell_phase: record4.phase }
+    });
+  };
+}
+var init_shell_audit_sink = __esm(() => {
+  init_integration_helper();
+});
+
 // src/commands/shell.ts
 var exports_shell = {};
 __export(exports_shell, {
@@ -46717,7 +47035,11 @@ async function runShell(options, configPath) {
     dialect,
     ask: asker.ask
   }) : null;
-  const engine = new ReplEngine(adapter, context, HISTORY_PATH, config, writeGate);
+  const auditSink = (await Promise.resolve().then(() => (init_shell_audit_sink(), exports_shell_audit_sink))).createShellAuditSink({
+    config,
+    configPath
+  });
+  const engine = new ReplEngine(adapter, context, HISTORY_PATH, config, writeGate, auditSink);
   const complete = createCompleter(context);
   console.error(import_picocolors5.default.bold(t_vars("shell.welcome", {
     system: config.connection.system,
@@ -47549,6 +47871,7 @@ var init_migrate = __esm(() => {
   init_ddl2();
   init_ddl_executor();
   init_mutation_confirm();
+  init_blacklist_manager();
   init_config_path();
   migrateCommand = new Command("migrate").description(t("migrate.description"));
   addExecOpts(migrateCommand.command("create <table>").description(t("migrate.create_description")).option("--column <spec...>", 'Column definitions (e.g., "id:serial:pk" "name:varchar(50):not-null")')).action(async (table, opts, command) => {
@@ -47851,7 +48174,9 @@ function envVarNameFor(connName, field) {
   const slug = connName.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
   return `DBCLI_${slug}_${field.toUpperCase()}`;
 }
-var init_config_v2_mutations = () => {};
+var init_config_v2_mutations = __esm(() => {
+  init_validation();
+});
 
 // src/core/env-file-writer.ts
 import { chmod as chmod2, mkdir as mkdir18, readFile as readFile9, writeFile as writeFile9 } from "fs/promises";
@@ -52231,6 +52556,9 @@ var init_data_access = __esm(() => {
 });
 
 // src/core/orm-drift/change-set.ts
+function starOnlyGlob2(glob) {
+  return glob.replace(/[?[\]\\]/g, "\\$&");
+}
 function normalizeProposedChanges(input) {
   validateInput(input);
   const gaps = [
@@ -52288,7 +52616,7 @@ function tableMap2(schema, defaultSchema, side) {
   return tables;
 }
 function ignoredTableKeys(input, declared, baseline, gaps) {
-  const patterns = [...DEFAULT_IGNORE2, ...input.ignore ?? []].map(globToRegex3);
+  const patterns = [...DEFAULT_IGNORE2, ...input.ignore ?? []];
   const ignored = new Set;
   for (const [side, tables] of [
     ["declared", declared],
@@ -52296,7 +52624,7 @@ function ignoredTableKeys(input, declared, baseline, gaps) {
   ]) {
     for (const [key, resolved] of tables) {
       const name = qualifiedTableName(resolved.identity);
-      if (!patterns.some((pattern) => pattern.test(name) || pattern.test(resolved.identity.table)))
+      if (!patterns.some((pattern) => globMatches(starOnlyGlob2(pattern), name) || globMatches(starOnlyGlob2(pattern), resolved.identity.table)))
         continue;
       if (ignored.has(key))
         continue;
@@ -52474,10 +52802,6 @@ function unparsedGaps(schema, side) {
     reason: entry.reason
   }));
 }
-function globToRegex3(glob) {
-  const escaped = glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  return new RegExp(`^${escaped}$`);
-}
 function gapOrder(left, right) {
   return codePointOrder5(left.side, right.side) || codePointOrder5(left.kind, right.kind) || codePointOrder5(left.location, right.location) || codePointOrder5(left.reason, right.reason);
 }
@@ -52493,6 +52817,7 @@ function codePointOrder5(left, right) {
 }
 var DEFAULT_IGNORE2, NormalizedChangeSetError;
 var init_change_set = __esm(() => {
+  init_glob();
   DEFAULT_IGNORE2 = ["_prisma_migrations"];
   NormalizedChangeSetError = class NormalizedChangeSetError extends Error {
     constructor(message) {