@carllee1983/dbcli 1.47.1 → 1.49.0

package/dist/cli.mjs

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@carllee1983/dbcli",
-    version: "1.47.1",
+    version: "1.49.0",
     description: "Database CLI for AI agents",
     type: "module",
     publishConfig: {
@@ -99,6 +99,7 @@ var init_package = __esm(() => {
     },
     files: [
       "dist/",
+      "!dist/.build-stamp",
       "assets/",
       "plugins/",
       "skills/",
@@ -120,7 +121,7 @@ var init_package = __esm(() => {
       "release:check": "bash scripts/release-check.sh",
       "plugin:sync": "bun run scripts/sync-plugin-assets.ts --write",
       "plugin:check": "bun run scripts/sync-plugin-assets.ts",
-      test: "bun test",
+      test: "bun test --timeout 30000",
       "test:unit": "bun test tests/unit tests/core",
       "test:integration": "bun test tests/integration",
       "test:docker": "docker compose -f docker-compose.test.yml up -d --wait && bun test tests/integration/adapters; docker compose -f docker-compose.test.yml down",
@@ -132,8 +133,9 @@ var init_package = __esm(() => {
       typecheck: "tsc --noEmit --pretty false",
       "test:perf": "bun test ./tests/perf/*.bench.ts",
       lint: "eslint src tests scripts --ext .ts --max-warnings=0",
-      "lint:fix": "eslint src tests scripts --ext .ts --fix --max-warnings=0",
-      format: 'prettier --write "src/**/*.ts" "tests/**/*.ts"'
+      "format:check": "prettier --check .",
+      format: "prettier --write .",
+      "lint:fix": "eslint src tests scripts --ext .ts --fix --max-warnings=0"
     },
     dependencies: {
       "cli-table3": "^0.6.5",
@@ -9316,6 +9318,14 @@ class BlacklistManager {
     }
     return Array.from(columnSet);
   }
+  getAllBlacklistedColumns() {
+    const all = new Set;
+    for (const columnSet of this.state.columns.values()) {
+      for (const column of columnSet)
+        all.add(column);
+    }
+    return Array.from(all);
+  }
   canOverrideBlacklist() {
     return this.overrideEnabled;
   }
@@ -9780,6 +9790,35 @@ var init_redis = __esm(() => {
   };
 });
 
+// src/utils/sql-lexical.ts
+function dollarQuoteDelimiterAt(sql, index) {
+  if (sql[index] !== "$")
+    return;
+  if (continuesIdentifier(sql, index))
+    return;
+  return sql.slice(index).match(DOLLAR_QUOTE_DELIMITER)?.[0];
+}
+function continuesIdentifier(sql, index) {
+  let start = index;
+  while (start > 0 && IDENTIFIER_CONTINUATION.test(sql[start - 1] ?? ""))
+    start--;
+  if (start === index)
+    return false;
+  const run = sql.slice(start, index);
+  const first = run[0];
+  if (IDENTIFIER_START.test(first))
+    return true;
+  if (first === "$")
+    return false;
+  return run.replace(/^[0-9]+(?:[eE][0-9]+)?/, "").length > 0;
+}
+var IDENTIFIER_CONTINUATION, IDENTIFIER_START, DOLLAR_QUOTE_DELIMITER;
+var init_sql_lexical = __esm(() => {
+  IDENTIFIER_CONTINUATION = /[A-Za-z0-9_$]|[\u0080-\uFFFF]/;
+  IDENTIFIER_START = /[A-Za-z_]|[\u0080-\uFFFF]/;
+  DOLLAR_QUOTE_DELIMITER = /^\$(?:(?:[A-Za-z_]|[\u0080-\uFFFF])(?:[A-Za-z0-9_]|[\u0080-\uFFFF])*)?\$/;
+});
+
 // src/core/permission-guard.ts
 var exports_permission_guard = {};
 __export(exports_permission_guard, {
@@ -9873,8 +9912,7 @@ function stripCommentsAndStrings2(sql, options = {}) {
       continue;
     }
     if (options.dialect === "postgresql" && char === "$") {
-      const opensToken = !IDENTIFIER_CONTINUATION.test(sql[i - 1] ?? "");
-      const delimiter = opensToken ? sql.slice(i).match(/^\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$/)?.[0] : undefined;
+      const delimiter = dollarQuoteDelimiterAt(sql, i);
       if (delimiter) {
         i += delimiter.length;
         const closingIndex = sql.indexOf(delimiter, i);
@@ -10348,8 +10386,9 @@ function checkElasticsearchPermission(classification, permission) {
     reason: `Elasticsearch ${classification.type} operation requires higher permission tier`
   };
 }
-var PermissionError, IDENTIFIER_CONTINUATION, SQL_DIALECTS, SQL_WRITE_OR_DDL_KEYWORDS, SQL_LOCK_CLAUSE, ESCALATABLE_READ_TYPES, REDIS_COMMAND_PERMISSION, PERMISSION_RANK;
+var PermissionError, SQL_DIALECTS, SQL_WRITE_OR_DDL_KEYWORDS, SQL_LOCK_CLAUSE, ESCALATABLE_READ_TYPES, REDIS_COMMAND_PERMISSION, PERMISSION_RANK;
 var init_permission_guard = __esm(() => {
+  init_sql_lexical();
   PermissionError = class PermissionError extends Error {
     classification;
     requiredPermission;
@@ -10361,7 +10400,6 @@ var init_permission_guard = __esm(() => {
       Object.setPrototypeOf(this, PermissionError.prototype);
     }
   };
-  IDENTIFIER_CONTINUATION = /[A-Za-z0-9_$]|[\u0080-\uFFFF]/;
   SQL_DIALECTS = ["postgresql", "mysql", "mariadb"];
   SQL_WRITE_OR_DDL_KEYWORDS = /(?<![.\w])(INSERT|UPDATE|DELETE|MERGE|UPSERT|REPLACE|TRUNCATE|DROP|ALTER|CREATE|GRANT|REVOKE|RENAME|INTO)\b(?!\s*\()/i;
   SQL_LOCK_CLAUSE = /\bFOR\s+(?:NO\s+KEY\s+)?UPDATE\b|\bFOR\s+(?:KEY\s+)?SHARE\b/gi;
@@ -26063,22 +26101,27 @@ var init_size_guard2 = __esm(() => {
   init_types4();
 });
 
-// src/adapters/redis/blacklist-enforcer.ts
+// src/utils/glob.ts
 function globToRegex(glob) {
   let out = "^";
   for (let i = 0;i < glob.length; i++) {
     const c2 = glob[i];
+    if (c2 === "\\" && i + 1 < glob.length) {
+      out += glob[++i].replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      continue;
+    }
     if (c2 === "*")
       out += ".*";
     else if (c2 === "?")
       out += ".";
     else if (c2 === "[") {
-      const end = glob.indexOf("]", i);
-      if (end === -1)
-        out += "\\[";
-      else {
-        out += glob.slice(i, end + 1);
+      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(c2)) {
       out += "\\" + c2;
@@ -26089,6 +26132,27 @@ function globToRegex(glob) {
   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);
@@ -30248,16 +30312,36 @@ function projectRows(rows, selection) {
   const columnNames = collectColumnNames(projectedRows);
   return { rows: normalizeRows(projectedRows, columnNames), columnNames };
 }
-function hasFieldPath(row, path5) {
-  return readPath(row, path5.split(".")).found;
+function hasFieldPath(row, segments) {
+  return readPath(row, segments).found;
 }
 function omitFieldPaths(rows, paths) {
-  return rows.map((row) => {
-    let projected = cloneRecord(row);
-    for (const path5 of paths)
-      projected = omitPath(projected, path5.split("."));
+  const topLevel = new Set(paths);
+  const dotted = paths.filter((path5) => path5.includes(".")).map((path5) => ({ head: path5.slice(0, path5.indexOf(".")), segments: path5.split(".") }));
+  const maskRecord = (row) => {
+    let projected = cloneRecord(row, topLevel);
+    for (const { head, segments } of dotted) {
+      const value = row[head];
+      if (value !== null && typeof value === "object")
+        projected = omitPath(projected, segments);
+    }
     return projected;
+  };
+  return rows.map((row) => {
+    if (row === null || typeof row !== "object")
+      return {};
+    if (Array.isArray(row))
+      return maskArrayRow(row, maskRecord);
+    return maskRecord(row);
+  });
+}
+function maskArrayRow(row, maskRecord) {
+  const out = {};
+  row.forEach((item, index) => {
+    const masked = Array.isArray(item) ? maskArrayRow(item, maskRecord) : item !== null && typeof item === "object" ? maskRecord(item) : item;
+    defineData(out, String(index), masked);
   });
+  return out;
 }
 function toMongoProjection(selection) {
   const projection = {};
@@ -30321,10 +30405,10 @@ function omitPath(value, segments) {
   }
   return out;
 }
-function cloneRecord(value, omittedKey) {
+function cloneRecord(value, omittedKeys) {
   const out = {};
   for (const [key, child] of Object.entries(value)) {
-    if (key !== omittedKey)
+    if (!omittedKeys.has(key))
       defineData(out, key, child);
   }
   return out;
@@ -30374,28 +30458,171 @@ var init_field_projection = __esm(() => {
   UNSAFE_SEGMENTS = new Set(["__proto__", "prototype", "constructor"]);
 });
 
+// src/utils/es-index-target.ts
+function normalizeEsPath(path5) {
+  let current = path5;
+  for (let pass = 0;pass < MAX_DECODE_PASSES; pass++) {
+    let decoded = current;
+    try {
+      decoded = decodeURIComponent(current);
+    } catch {}
+    const segments = [];
+    for (const segment of decoded.split("/")) {
+      if (segment === "." || segment === "")
+        continue;
+      if (segment === "..") {
+        segments.pop();
+        continue;
+      }
+      segments.push(segment);
+    }
+    const resolved = `/${segments.join("/")}`;
+    if (resolved === current)
+      return resolved;
+    current = resolved;
+  }
+  return current;
+}
+function unwrap(target) {
+  let current = target;
+  for (let pass = 0;pass < MAX_DECODE_PASSES; pass++) {
+    let next = current;
+    try {
+      next = decodeURIComponent(next);
+    } catch {}
+    if (next.startsWith("<") && next.endsWith(">")) {
+      next = next.slice(1, -1).replace(/\{[^}]*\}/g, "*");
+    }
+    if (next === current)
+      return current;
+    current = next;
+  }
+  return current;
+}
+function expandIndexTargets(target) {
+  const concrete = [];
+  const wildcards = [];
+  const add = (candidate) => {
+    if (candidate.length === 0)
+      return;
+    if (/[*?]/.test(candidate) || candidate.toLowerCase() === "_all")
+      wildcards.push(candidate);
+    else
+      concrete.push(candidate);
+  };
+  for (const rawPart of unwrap(target).split(",")) {
+    const part = unwrap(rawPart.trim()).trim().replace(/^[-+]/, "");
+    if (part.length === 0)
+      continue;
+    add(part);
+    if (part.includes(":"))
+      for (const section of part.split(":"))
+        add(section);
+  }
+  return { concrete, wildcards };
+}
+function matchesIndexGlob(pattern, name2) {
+  const normalized = pattern.toLowerCase() === "_all" ? "*" : pattern.toLowerCase();
+  try {
+    return globToRegex(normalized).test(name2.toLowerCase());
+  } catch {
+    return true;
+  }
+}
+function reachesByConvention(name2, entry) {
+  const lower = name2.toLowerCase();
+  const target = entry.toLowerCase();
+  return new RegExp(`^\\.ds-${escapeRegExp(target)}-`).test(lower) || new RegExp(`^${escapeRegExp(target)}-\\d+$`).test(lower);
+}
+function escapeRegExp(text2) {
+  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function indexExpressionReaches(expression, blacklisted) {
+  if (blacklisted.length === 0)
+    return false;
+  const { concrete, wildcards } = expandIndexTargets(expression);
+  return concrete.some((name2) => blacklisted.some((entry) => entry.toLowerCase() === name2.toLowerCase() || reachesByConvention(name2, entry))) || wildcards.some((pattern) => blacklisted.some((entry) => matchesIndexGlob(pattern, entry)));
+}
+var MAX_DECODE_PASSES = 4;
+var init_es_index_target = () => {};
+
 // src/core/blacklist-validator.ts
+function flattenArrayRow(row) {
+  const records = [];
+  for (const item of row) {
+    if (Array.isArray(item))
+      records.push(...flattenArrayRow(item));
+    else if (item !== null && typeof item === "object")
+      records.push(item);
+  }
+  return records;
+}
+function dedupe2(values) {
+  const seen = new Set;
+  const result = [];
+  for (const value of values) {
+    const key = value.toLowerCase();
+    if (value.length === 0 || seen.has(key))
+      continue;
+    seen.add(key);
+    result.push(value);
+  }
+  return result;
+}
+
 class BlacklistValidator {
   manager;
   constructor(manager) {
     this.manager = manager;
   }
-  checkTableBlacklist(operation, tableName, _tableList = []) {
+  checkTableBlacklist(operation, tableName, tableList = []) {
+    this.checkTablesBlacklist(operation, [tableName, ...tableList]);
+  }
+  checkTablesBlacklist(operation, tableNames) {
+    const tables = dedupe2(tableNames);
+    if (tables.length === 0) {
+      return;
+    }
     if (this.manager.canOverrideBlacklist()) {
-      const message = t_vars("warnings.blacklist_override_used", {
+      const message2 = t_vars("warnings.blacklist_override_used", {
         operation,
-        table: tableName
+        table: tables.join(", ")
       });
-      console.error(message);
+      console.error(message2);
       return;
     }
-    if (this.manager.isTableBlacklisted(tableName)) {
-      const message = t_vars("errors.table_blacklisted", {
-        table: tableName,
-        operation
-      });
-      throw new BlacklistError(message, tableName, operation);
+    const blocked = tables.filter((table) => this.manager.isTableBlacklisted(table));
+    if (blocked.length === 0) {
+      return;
     }
+    const message = t_vars("errors.table_blacklisted", {
+      table: blocked.join(", "),
+      operation
+    });
+    throw new BlacklistError(message, blocked[0], operation);
+  }
+  checkIndexBlacklist(operation, target) {
+    const { concrete, wildcards } = expandIndexTargets(target);
+    this.checkTablesBlacklist(operation, concrete);
+    if (wildcards.length === 0 || this.manager.canOverrideBlacklist())
+      return;
+    const blacklisted = Array.from(this.manager.getState().tables);
+    if (blacklisted.length === 0)
+      return;
+    const reachable = wildcards.filter((pattern) => blacklisted.some((entry) => matchesIndexGlob(pattern, entry)));
+    if (reachable.length === 0)
+      return;
+    const message = t_vars("errors.table_blacklisted", {
+      table: reachable.join(", "),
+      operation
+    });
+    throw new BlacklistError(message, reachable[0], operation);
+  }
+  filterColumnsForIndexExpression(target, rows, columnList) {
+    const { concrete, wildcards } = expandIndexTargets(target);
+    const ruleKeys = Array.from(this.manager.getState().columns.keys());
+    const reachable = ruleKeys.filter((key) => wildcards.some((pattern) => matchesIndexGlob(pattern, key)));
+    return this.filterColumnsForTables([...concrete, ...reachable], rows, columnList);
   }
   checkColumnBlacklistOnWrite(tableName, fields, operation = "WRITE") {
     const blacklisted = this.manager.getBlacklistedColumns(tableName);
@@ -30422,11 +30649,64 @@ class BlacklistValidator {
     throw new BlacklistError(message, tableName, operation);
   }
   filterColumns(tableName, rows, columnList) {
-    const blacklistedColumns = this.manager.getBlacklistedColumns(tableName);
+    return this.filterColumnsForTables([tableName], rows, columnList);
+  }
+  filterColumnsForTables(tableNames, rows, columnList) {
+    const tables = dedupe2(tableNames);
+    const blacklistedColumns = tables.length === 0 ? this.manager.getAllBlacklistedColumns() : Array.from(new Set(tables.flatMap((table) => this.manager.getBlacklistedColumns(table))));
     if (blacklistedColumns.length === 0) {
       return { filteredRows: rows, omittedColumns: [] };
     }
-    const omittedColumns = blacklistedColumns.filter((path5) => columnList.includes(path5) || rows.some((row) => hasFieldPath(row, path5)));
+    const probeNested = blacklistedColumns.some((path5) => path5.includes("."));
+    const presentColumns = new Set(columnList);
+    const nestedHeads = new Set;
+    const collect2 = (record) => {
+      for (const key of Object.getOwnPropertyNames(record)) {
+        presentColumns.add(key);
+        if (!probeNested)
+          continue;
+        const value = record[key];
+        if (value !== null && typeof value === "object")
+          nestedHeads.add(key);
+      }
+    };
+    for (const row of rows) {
+      if (row === null || typeof row !== "object")
+        continue;
+      if (Array.isArray(row)) {
+        for (const item of flattenArrayRow(row))
+          collect2(item);
+        continue;
+      }
+      collect2(row);
+    }
+    const protectedPaths = new Set(blacklistedColumns);
+    const omitted = new Set;
+    for (const path5 of blacklistedColumns) {
+      if (presentColumns.has(path5)) {
+        omitted.add(path5);
+        continue;
+      }
+      const dot = path5.indexOf(".");
+      if (dot < 0)
+        continue;
+      if (!nestedHeads.has(path5.slice(0, dot)))
+        continue;
+      const segments = path5.split(".");
+      if (rows.some((row) => hasFieldPath(row, segments)))
+        omitted.add(path5);
+    }
+    for (const column of presentColumns) {
+      let dot = column.indexOf(".");
+      while (dot >= 0) {
+        if (dot > 0 && protectedPaths.has(column.slice(0, dot))) {
+          omitted.add(column);
+          break;
+        }
+        dot = column.indexOf(".", dot + 1);
+      }
+    }
+    const omittedColumns = Array.from(omitted);
     if (omittedColumns.length === 0) {
       return { filteredRows: rows, omittedColumns: [] };
     }
@@ -30446,6 +30726,7 @@ var init_blacklist_validator = __esm(() => {
   init_blacklist();
   init_message_loader();
   init_field_projection();
+  init_es_index_target();
 });
 
 // src/core/verification/types.ts
@@ -34433,6 +34714,355 @@ 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 = (name2) => {
+    const key = name2.toLowerCase();
+    if (name2.length === 0 || seen.has(key))
+      return;
+    seen.add(key);
+    references.push(name2);
+  };
+  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 name2 = readQualifiedName(tokens, cursor);
+      if (!name2)
+        break;
+      const isFunctionCall = parenMeansFunction && isPunctuation(tokens[name2.next], "(");
+      if (!isFunctionCall)
+        recordName(name2.parts);
+      cursor = name2.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 name2 = readQualifiedName(tokens, index);
+    for (let part = 0;part < name2.parts.length; part++) {
+      const value = name2.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 (name2.parts.length > 1)
+      record(name2.parts.join("."));
+    index = name2.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;
 
@@ -34486,11 +35116,9 @@ class QueryExecutor {
           }
         }
       }
-      if (this.blacklistValidator) {
-        const tableName = extractTableName(sql);
-        if (tableName) {
-          this.blacklistValidator.checkTableBlacklist(classification.type, tableName, []);
-        }
+      const referencedTables = this.blacklistValidator ? extractTableReferences(sql, { dialect: this.resolveDialect() }) : [];
+      if (this.blacklistValidator && referencedTables.length > 0) {
+        this.blacklistValidator.checkTablesBlacklist(classification.type, referencedTables);
       }
       const resultData = await this.adapter.execute(executeSql);
       const executionTimeMs = Math.round(performance.now() - start);
@@ -34503,15 +35131,12 @@ class QueryExecutor {
       let securityNotification;
       let omittedColumns = [];
       if (this.blacklistValidator) {
-        const tableName = extractTableName(sql);
-        if (tableName) {
-          const filterResult = this.blacklistValidator.filterColumns(tableName, rows, columnNames);
-          filteredRows = filterResult.filteredRows;
-          if (filterResult.omittedColumns.length > 0) {
-            omittedColumns = filterResult.omittedColumns;
-            columnNames = columnNames.filter((col) => !filterResult.omittedColumns.includes(col));
-            securityNotification = this.blacklistValidator.buildSecurityNotification(tableName, filterResult.omittedColumns);
-          }
+        const filterResult = this.blacklistValidator.filterColumnsForTables(referencedTables, rows, columnNames);
+        filteredRows = filterResult.filteredRows;
+        if (filterResult.omittedColumns.length > 0) {
+          omittedColumns = filterResult.omittedColumns;
+          columnNames = columnNames.filter((col) => !filterResult.omittedColumns.includes(col));
+          securityNotification = this.blacklistValidator.buildSecurityNotification(referencedTables[0] ?? "", filterResult.omittedColumns);
         }
       }
       if (options?.fieldSelection) {
@@ -34617,13 +35242,30 @@ function inferColumnType(value) {
 var init_query_executor = __esm(() => {
   init_permission_guard();
   init_error_suggester();
-  init_engine_hints();
+  init_sql_tables();
   init_applied_limit();
   init_integration_helper();
   init_field_projection();
 });
 
 // src/core/mongo/field-masker.ts
+function maskMongoRowsForCollections(rows, collections, blacklist) {
+  const columns = blacklist.columns ?? {};
+  return collections.reduce((masked, entry) => {
+    const scope = typeof entry === "string" ? { collection: entry } : entry;
+    const atTopLevel = maskMongoRows(masked, scope.collection, blacklist);
+    if (!scope.prefix)
+      return atTopLevel;
+    const rules = columns[scope.collection] ?? findCaseInsensitive(columns, scope.collection);
+    if (!rules || rules.length === 0)
+      return atTopLevel;
+    const prefixKey = `\x00${scope.collection}@${scope.prefix}`;
+    return maskMongoRows(atTopLevel, prefixKey, {
+      ...blacklist,
+      columns: { ...columns, [prefixKey]: rules.map((rule) => `${scope.prefix}.${rule}`) }
+    });
+  }, rows);
+}
 function maskMongoRows(rows, collection, blacklist) {
   const columns = blacklist.columns ?? {};
   const raw = columns[collection] ?? findCaseInsensitive(columns, collection);
@@ -34676,6 +35318,86 @@ function findCaseInsensitive(columns, name2) {
 var REDACTED2 = "[REDACTED]";
 var init_field_masker = () => {};
 
+// src/core/mongo/collection-references.ts
+function recordTarget(value, found) {
+  if (typeof value === "string") {
+    if (value.length > 0)
+      found.add(value);
+    return;
+  }
+  if (value === null || typeof value !== "object")
+    return;
+  const record = value;
+  for (const field of COLLECTION_FIELDS) {
+    const target = record[field];
+    if (typeof target === "string" && target.length > 0)
+      found.add(target);
+    else if (target !== null && typeof target === "object")
+      recordTarget(target, found);
+  }
+}
+function joinPrefix(parent, child) {
+  if (!parent)
+    return child;
+  if (!child)
+    return parent;
+  return `${parent}.${child}`;
+}
+function collect2(pipeline, found, scopes, parentPrefix) {
+  if (!Array.isArray(pipeline))
+    return;
+  for (const stage of pipeline) {
+    if (stage === null || typeof stage !== "object")
+      continue;
+    const record = stage;
+    for (const name2 of COLLECTION_STAGES) {
+      if (!Object.prototype.hasOwnProperty.call(record, name2))
+        continue;
+      const stageTargets = new Set;
+      recordTarget(record[name2], stageTargets);
+      for (const collection of stageTargets)
+        found.add(collection);
+      const value = record[name2];
+      const as = value !== null && typeof value === "object" ? value["as"] : undefined;
+      const prefix = joinPrefix(parentPrefix, typeof as === "string" && as ? as : undefined);
+      for (const collection of stageTargets) {
+        scopes.push({ collection, ...prefix ? { prefix } : {} });
+      }
+    }
+    for (const holder of SUB_PIPELINE_HOLDERS2) {
+      const value = record[holder];
+      if (value === undefined || value === null)
+        continue;
+      if (Array.isArray(value)) {
+        collect2(value, found, scopes, parentPrefix);
+        continue;
+      }
+      if (typeof value !== "object")
+        continue;
+      for (const [key, nested] of Object.entries(value)) {
+        const holderPrefix = holder === "$facet" ? joinPrefix(parentPrefix, key) : joinPrefix(parentPrefix, typeof value["as"] === "string" ? value["as"] : undefined);
+        collect2(nested, found, scopes, holderPrefix);
+      }
+    }
+  }
+}
+function findMongoCollectionReferences(pipeline) {
+  const found = new Set;
+  collect2(pipeline, found, []);
+  return Array.from(found);
+}
+function findMongoCollectionScopes(pipeline) {
+  const scopes = [];
+  collect2(pipeline, new Set, scopes);
+  return scopes;
+}
+var COLLECTION_FIELDS, SUB_PIPELINE_HOLDERS2, COLLECTION_STAGES;
+var init_collection_references = __esm(() => {
+  COLLECTION_FIELDS = ["from", "coll", "into"];
+  SUB_PIPELINE_HOLDERS2 = ["$facet", "$lookup", "$unionWith", "$graphLookup"];
+  COLLECTION_STAGES = ["$lookup", "$unionWith", "$graphLookup", "$out", "$merge"];
+});
+
 // src/core/query-input.ts
 function trimOuterWhitespace(value) {
   let start = 0;
@@ -34857,6 +35579,13 @@ var init_query_size_guard = __esm(() => {
 import crypto3 from "crypto";
 import { tmpdir } from "os";
 import { join as join23 } from "path";
+function mongoCollectionRefs(query) {
+  try {
+    return findMongoCollectionScopes(JSON.parse(query));
+  } catch {
+    return [];
+  }
+}
 function requireSqlConnection2(connection) {
   if (!["postgresql", "mysql", "mariadb"].includes(connection.system)) {
     throw new Error(`This command requires a SQL connection, got: ${connection.system}`);
@@ -35008,17 +35737,22 @@ async function preflightQuery(query, options, context, fieldSelection, multiConn
   await preflightSqlSizeGuard(query, options, config);
 }
 async function preflightSqlSizeGuard(query, options, config) {
-  const { extractTableName: extractTableName2 } = await Promise.resolve().then(() => (init_engine_hints(), exports_engine_hints));
-  const mainTable = extractTableName2(query);
-  if (!mainTable || !config.schema || options.noLimit)
-    return;
-  const tableSchema = config.schema[mainTable];
-  if (!tableSchema)
+  if (!config.schema || options.noLimit)
     return;
+  const { extractTableReferences: extractTableReferences2 } = await Promise.resolve().then(() => (init_sql_tables(), exports_sql_tables));
+  const { SQL_DIALECTS: SQL_DIALECTS2 } = await Promise.resolve().then(() => (init_permission_guard(), exports_permission_guard));
+  const dialect = SQL_DIALECTS2.find((candidate) => candidate === config.connection?.system);
+  const tables = extractTableReferences2(query, { ...dialect ? { dialect } : {} });
+  const schema = config.schema;
   const { shouldBlockQuery: shouldBlockQuery2 } = await Promise.resolve().then(() => (init_query_size_guard(), exports_query_size_guard));
-  const guard = shouldBlockQuery2(query, tableSchema);
-  if (guard.blocked)
-    throw new Error(`\u26A0 ${guard.reason}`);
+  for (const table of tables) {
+    const tableSchema = schema[table];
+    if (!tableSchema)
+      continue;
+    const guard = shouldBlockQuery2(query, tableSchema);
+    if (guard.blocked)
+      throw new Error(`\u26A0 ${guard.reason}`);
+  }
 }
 async function preflightMongoQuery(query, options, config, multiConnection) {
   const collection = options.collection;
@@ -35044,7 +35778,10 @@ async function preflightMongoQuery(query, options, config, multiConnection) {
     context: "MongoDB multi-connection pipelines"
   });
   const blacklistValidator = new BlacklistValidator(new BlacklistManager(config));
-  blacklistValidator.checkTableBlacklist("SELECT", collection, []);
+  blacklistValidator.checkTablesBlacklist("SELECT", [
+    collection,
+    ...findMongoCollectionReferences(parsedQuery)
+  ]);
   if (!config.schema || options.noLimit)
     return;
   const tableSchema = config.schema[collection];
@@ -35068,7 +35805,7 @@ function preflightElasticsearchQuery(query, options, config, multiConnection) {
     JSON.parse(body);
   enforceElasticsearchPermission({ method: "POST", apiPath: `/${indexName}/_search`, body }, multiConnection ? "query-only" : config.permission);
   const blacklistValidator = new BlacklistValidator(new BlacklistManager(config));
-  blacklistValidator.checkTableBlacklist("SELECT", indexName, []);
+  blacklistValidator.checkIndexBlacklist("SELECT", indexName);
 }
 async function executeConnectionQuery(query, options, context, fieldSelection) {
   const { config, configPath, connectionName } = context;
@@ -35221,7 +35958,7 @@ async function mongoQueryBranch(queryStr, options, context, fieldSelection) {
     const limitedResult = appliedLimit === undefined ? undefined : trimAppliedLimit(result.rows, appliedLimit);
     const visibleRows = limitedResult?.rows ?? result.rows;
     const blacklistCfg = config.blacklist ?? { tables: [], columns: {} };
-    const maskedRows = maskMongoRows(visibleRows, collection, blacklistCfg);
+    const maskedRows = maskMongoRowsForCollections(visibleRows, [collection, ...mongoCollectionRefs(queryStr)], blacklistCfg);
     const projected = fieldSelection ? projectRows(maskedRows, fieldSelection) : undefined;
     const outputRows = projected?.rows ?? maskedRows;
     const columnNames = projected?.columnNames ?? (outputRows[0] ? Object.keys(outputRows[0]) : []);
@@ -35325,7 +36062,7 @@ async function elasticsearchQueryBranch(queryStr, options, context) {
     const limitedResult = appliedLimit === undefined ? undefined : trimAppliedLimit(result.rows, appliedLimit);
     const visibleRows = limitedResult?.rows ?? result.rows;
     const columnNames = visibleRows[0] ? Object.keys(visibleRows[0]) : [];
-    const filterResult = blacklistValidator.filterColumns(indexName, visibleRows, columnNames);
+    const filterResult = blacklistValidator.filterColumnsForIndexExpression(indexName, visibleRows, columnNames);
     const queryResult = {
       rows: filterResult.filteredRows,
       rowCount: filterResult.filteredRows.length,
@@ -35387,6 +36124,7 @@ var init_query = __esm(() => {
   init_applied_limit();
   init_integration_helper();
   init_field_masker();
+  init_collection_references();
   init_types4();
   init_query_input();
   init_field_projection();
@@ -35950,7 +36688,8 @@ async function qMongoBranch(snippet, prepared, options, config) {
   });
   const blacklistManager = new BlacklistManager(config);
   const blacklistValidator = new BlacklistValidator(blacklistManager);
-  blacklistValidator.checkTableBlacklist("SELECT", collection);
+  const collections = [collection, ...findMongoCollectionReferences(parsedBody)];
+  blacklistValidator.checkTablesBlacklist("SELECT", collections);
   if (options.dryRun) {
     console.log(`Dry-run preview (no execution):`);
     console.log(`Collection: ${collection}`);
@@ -35965,7 +36704,7 @@ async function qMongoBranch(snippet, prepared, options, config) {
     const result = await adapter.execute(prepared.driver.sql, [collection]);
     const executionTimeMs = Math.round(performance.now() - start);
     const blacklistCfg = config.blacklist ?? { tables: [], columns: {} };
-    const masked = maskMongoRows(result.rows, collection, blacklistCfg);
+    const masked = maskMongoRowsForCollections(result.rows, [collection, ...findMongoCollectionScopes(parsedBody)], blacklistCfg);
     const securityNotification = (blacklistCfg.columns[collection] ?? []).length > 0 ? "Some fields may have been redacted as [REDACTED] per .dbcli blacklist." : undefined;
     if (options.ui || options.format === "html") {
       const html = await generateHtmlReport({
@@ -36006,6 +36745,7 @@ var init_q_mongo = __esm(() => {
   init_adapters();
   init_blacklist_validator();
   init_field_masker();
+  init_collection_references();
   init_formatters();
   init_html_formatter();
   init_opener();
@@ -36053,7 +36793,8 @@ async function qCommand(name2, options, command) {
     config = await configModule.read(configPath);
     if (!config.connection)
       throw new Error('Run "dbcli init" first');
-    const engine = mapSystemToEngine(config.connection.system);
+    const connectionSystem = config.connection.system;
+    const engine = mapSystemToEngine(connectionSystem);
     const dirs = resolveSnippetDirs(process.cwd());
     const map = await loadSnippets(dirs);
     const snippet = resolveByName(map, name2, engine);
@@ -36088,10 +36829,16 @@ async function qCommand(name2, options, command) {
     const blacklistManager = new BlacklistManager(config);
     const blacklistValidator = new BlacklistValidator(blacklistManager);
     const family = engineFamily(engine);
-    const targetName = family === "sql" ? extractTableName(prepared.rewrittenSql) ?? "" : family === "es" ? prepared.execHints?.index ?? "" : "";
+    const sqlDialect = SQL_DIALECTS.find((dialect) => dialect === connectionSystem);
+    const targets = family === "sql" ? extractTableReferences(prepared.rewrittenSql, {
+      ...sqlDialect ? { dialect: sqlDialect } : {}
+    }) : family === "es" ? [prepared.execHints?.index ?? ""] : [];
+    const targetName = targets[0] ?? "";
     targetNameForAudit = targetName || name2;
-    if (family !== "redis" && targetName) {
-      blacklistValidator.checkTableBlacklist("SELECT", targetName);
+    if (family === "es") {
+      blacklistValidator.checkIndexBlacklist("SELECT", targetName);
+    } else if (family !== "redis" && targets.length > 0) {
+      blacklistValidator.checkTablesBlacklist("SELECT", targets);
     }
     const adapter = AdapterFactory.createAdapter(config.connection);
     await adapter.connect();
@@ -36106,7 +36853,7 @@ async function qCommand(name2, options, command) {
       const limitedResult = prepared.guardLimit === undefined ? undefined : trimAppliedLimit(result.rows, prepared.guardLimit);
       const resultRows = limitedResult?.rows ?? result.rows;
       const columnNames = resultRows[0] ? Object.keys(resultRows[0]) : [];
-      const filtered = family === "redis" ? { filteredRows: resultRows, omittedColumns: [] } : blacklistValidator.filterColumns(targetName, resultRows, columnNames);
+      const filtered = family === "redis" ? { filteredRows: resultRows, omittedColumns: [] } : family === "es" ? blacklistValidator.filterColumnsForIndexExpression(targetName, resultRows, columnNames) : blacklistValidator.filterColumnsForTables(targets, resultRows, columnNames);
       const securityNotification = family === "redis" || filtered.omittedColumns.length === 0 ? undefined : blacklistValidator.buildSecurityNotification(targetName, filtered.omittedColumns);
       if (options.ui || options.format === "html") {
         const html = await generateHtmlReport({
@@ -36166,6 +36913,11 @@ async function qCommand(name2, options, command) {
         } else {
           try {
             console.error(colors.dim(`Executing verification query: ${verifySpec.query}`));
+            if (family === "sql") {
+              blacklistValidator.checkTablesBlacklist("SELECT", extractTableReferences(verifySpec.query, {
+                ...sqlDialect ? { dialect: sqlDialect } : {}
+              }));
+            }
             const verifyResult = await adapter.execute(verifySpec.query);
             const firstRow = verifyResult.rows[0];
             const evalResult = evaluateExpectation(firstRow, verifySpec.expects);
@@ -36348,7 +37100,7 @@ var init_q = __esm(() => {
   init_blacklist_validator();
   init_blacklist();
   init_permission_guard();
-  init_engine_hints();
+  init_sql_tables();
   init_formatters();
   init_html_formatter();
   init_opener();
@@ -39186,7 +39938,8 @@ async function exportCommand(sql, options, command) {
     }
     const adapter = AdapterFactory.createSqlAdapter(requireSqlConnection6(config.connection));
     await adapter.connect();
-    const executor3 = new QueryExecutor(adapter, config.permission, undefined, config, {
+    const blacklistValidator = new BlacklistValidator(new BlacklistManager(config));
+    const executor3 = new QueryExecutor(adapter, config.permission, blacklistValidator, config, {
       recovery: options.recovery,
       deferDiagnostics: true
     });
@@ -39329,15 +40082,19 @@ async function esExportBranch(query, options, config) {
   let rowCount;
   const diagnostics = [];
   try {
+    const declaredTarget = query.trim().startsWith("{") ? options.index ?? options.collection : query.trim();
+    if (declaredTarget)
+      blacklistValidator.checkIndexBlacklist("SELECT", declaredTarget);
     const {
       rows: fetched,
       target,
       cap: cap2
     } = await buildEsExportRows(query, options, adapter);
-    blacklistValidator.checkTableBlacklist("SELECT", target, []);
+    blacklistValidator.checkIndexBlacklist("SELECT", target);
     const limitedResult = cap2 === undefined ? undefined : trimAppliedLimit(fetched, cap2);
     assertExportNotSilentlyTruncated(limitedResult?.metadata, options);
-    const rows = limitedResult?.rows ?? fetched;
+    const visibleRows = limitedResult?.rows ?? fetched;
+    const rows = blacklistValidator.filterColumnsForIndexExpression(target, visibleRows, collectColumnUnion(visibleRows)).filteredRows;
     rowCount = rows.length;
     const columns = collectColumnUnion(rows);
     if (options.format === "html") {
@@ -39393,7 +40150,9 @@ async function mongoExportBranch(query, options, config) {
   });
   const blacklistManager = new BlacklistManager(config);
   const blacklistValidator = new BlacklistValidator(blacklistManager);
-  blacklistValidator.checkTableBlacklist("SELECT", collection, []);
+  const mongoScopes = findMongoCollectionScopes(JSON.parse(query));
+  const mongoCollections = [collection, ...findMongoCollectionReferences(JSON.parse(query))];
+  blacklistValidator.checkTablesBlacklist("SELECT", mongoCollections);
   let effectiveLimit;
   if (options.noLimit) {
     effectiveLimit = undefined;
@@ -39413,7 +40172,7 @@ async function mongoExportBranch(query, options, config) {
     const limitedResult = effectiveLimit === undefined ? undefined : trimAppliedLimit(result.rows, effectiveLimit);
     assertExportNotSilentlyTruncated(limitedResult?.metadata, options);
     const blacklistCfg = config.blacklist ?? { tables: [], columns: {} };
-    const maskedRows = maskMongoRows(limitedResult?.rows ?? result.rows, collection, blacklistCfg);
+    const maskedRows = maskMongoRowsForCollections(limitedResult?.rows ?? result.rows, [collection, ...mongoScopes], blacklistCfg);
     rowCount = maskedRows.length;
     hasBlacklistedColumns = (blacklistCfg.columns[collection] ?? []).length > 0;
     const visibleColumns = collectColumnUnion(maskedRows);
@@ -39542,6 +40301,7 @@ var init_export = __esm(() => {
   init_integration_helper();
   init_engine_hints();
   init_field_masker();
+  init_collection_references();
   SQL_PATTERN = /^\s*(SELECT|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|SHOW|DESCRIBE)\b/i;
 });
 
@@ -93845,6 +94605,25 @@ async function runDiagnostic(input) {
     return { ...base, rowCount: 0, rows: [], status: "skipped", reason, durationMs: 0 };
   }
   const family = engineFamily(input.engine);
+  const referencedTables = family === "sql" ? extractTableReferences(prepared.rewrittenSql, {
+    ...ENGINE_DIALECT2[input.engine] ? { dialect: ENGINE_DIALECT2[input.engine] } : {}
+  }) : family === "es" && prepared.execHints?.index ? [prepared.execHints.index] : [];
+  if (input.blacklistValidator && referencedTables.length > 0) {
+    try {
+      input.blacklistValidator.checkTablesBlacklist("SELECT", referencedTables);
+    } catch (err) {
+      if (!(err instanceof BlacklistError))
+        throw err;
+      return {
+        ...base,
+        rowCount: 0,
+        rows: [],
+        status: "skipped",
+        reason: err.message,
+        durationMs: 0
+      };
+    }
+  }
   const start = performance.now();
   const exec2 = (async () => {
     const indexParams = family === "es" && prepared.execHints?.index ? [prepared.execHints.index] : [];
@@ -93880,7 +94659,8 @@ async function runDiagnostic(input) {
       durationMs
     };
   }
-  const rows = outcome.rows ?? [];
+  const fetched = outcome.rows ?? [];
+  const rows = input.blacklistValidator ? input.blacklistValidator.filterColumnsForTables(referencedTables, fetched, fetched[0] ? Object.keys(fetched[0]) : []).filteredRows : fetched;
   if (rows.length === 0) {
     return { ...base, rowCount: 0, rows: [], status: "no-data", durationMs };
   }
@@ -93892,9 +94672,17 @@ async function runDiagnostic(input) {
     durationMs
   };
 }
+var ENGINE_DIALECT2;
 var init_run_diagnostic = __esm(() => {
   init_saved_queries();
   init_strategies();
+  init_sql_tables();
+  init_blacklist();
+  ENGINE_DIALECT2 = {
+    postgres: "postgresql",
+    mysql: "mysql",
+    mariadb: "mariadb"
+  };
 });
 
 // src/core/report/collector.ts
@@ -93950,6 +94738,7 @@ async function collectReport(opts) {
     return finalize({ context, sections: [], warnings, generatedAt });
   }
   const adapter = AdapterFactory.createAdapter(config.connection);
+  const blacklistValidator = new BlacklistValidator(new BlacklistManager(config));
   const sectionEvidence = new Map;
   for (const id of sections)
     sectionEvidence.set(id, []);
@@ -93963,7 +94752,8 @@ async function collectReport(opts) {
         adapter,
         engine,
         timeoutMs: timeout,
-        maxRows
+        maxRows,
+        blacklistValidator
       });
       const sectionId = sectionForIntent(ev.intent);
       if (sectionId && sectionEvidence.has(sectionId)) {
@@ -94027,6 +94817,7 @@ var init_collector2 = __esm(() => {
   init_saved_queries();
   init_select_snippets();
   init_run_diagnostic();
+  init_blacklist_validator();
   init_section_map();
   init_types7();
 });
@@ -97934,7 +98725,8 @@ var init_snapshot = __esm(() => {
   init_validation();
   init_blacklist_validator();
   init_query_executor();
-  init_engine_hints();
+  init_permission_guard();
+  init_sql_tables();
   init_fingerprint();
   init_serializer();
   init_saved_queries();
@@ -97962,10 +98754,12 @@ var init_snapshot = __esm(() => {
       try {
         const blacklistManager = new BlacklistManager(config);
         const blacklistValidator = new BlacklistValidator(blacklistManager);
+        const sqlDialect = SQL_DIALECTS.find((dialect) => dialect === config.connection?.system);
         const executor3 = new QueryExecutor(adapter, config.permission, blacklistValidator, config, options);
         const result = await executor3.execute(sql, { autoLimit: options.limit !== false });
-        const table = extractTableName(sql);
-        const redactedColumns = table ? blacklistManager.getBlacklistedColumns(table) : [];
+        const redactedColumns = Array.from(new Set(extractTableReferences(sql, {
+          ...sqlDialect ? { dialect: sqlDialect } : {}
+        }).flatMap((table) => blacklistManager.getBlacklistedColumns(table))));
         const snap = buildFingerprint(result, {
           includeRows: options.rows === true,
           redactedColumns,
@@ -99531,8 +100325,20 @@ function buildRealRunners(ctx) {
   const blacklist = config.blacklist ?? { tables: [], columns: {} };
   const schema = config.schema ?? {};
   const schemaLookup = { tables: schema, cacheAvailable: Object.keys(schema).length > 0 };
-  const analyze = (sql) => analyzeQueryRisk({ sql: sql.trim(), permission: config.permission, blacklist, schemaLookup, dialect: toSqlDialect(config.connection?.system) });
-  const analyzePlan = (sql) => analyzeQueryRisk({ sql: sql.trim(), permission: "read-write", blacklist, schemaLookup, dialect: toSqlDialect(config.connection?.system) });
+  const analyze = (sql) => analyzeQueryRisk({
+    sql: sql.trim(),
+    permission: config.permission,
+    blacklist,
+    schemaLookup,
+    dialect: toSqlDialect(config.connection?.system)
+  });
+  const analyzePlan = (sql) => analyzeQueryRisk({
+    sql: sql.trim(),
+    permission: "read-write",
+    blacklist,
+    schemaLookup,
+    dialect: toSqlDialect(config.connection?.system)
+  });
   return {
     blacklistGuard: async (table) => {
       const bm = new BlacklistManager(config);
@@ -99605,7 +100411,13 @@ function buildMigrationRunners(ctx) {
   const blacklist = config.blacklist ?? { tables: [], columns: {} };
   const schema = config.schema ?? {};
   const schemaLookup = { tables: schema, cacheAvailable: Object.keys(schema).length > 0 };
-  const analyze = (sql) => analyzeQueryRisk({ sql: sql.trim(), permission: config.permission, blacklist, schemaLookup, dialect: toSqlDialect(config.connection?.system) });
+  const analyze = (sql) => analyzeQueryRisk({
+    sql: sql.trim(),
+    permission: config.permission,
+    blacklist,
+    schemaLookup,
+    dialect: toSqlDialect(config.connection?.system)
+  });
   return {
     blacklistGuard: async (table) => {
       const bm = new BlacklistManager(config);
@@ -99673,8 +100485,20 @@ function buildRollbackRunners(ctx, input) {
   const blacklist = config.blacklist ?? { tables: [], columns: {} };
   const schema = config.schema ?? {};
   const schemaLookup = { tables: schema, cacheAvailable: Object.keys(schema).length > 0 };
-  const analyze = (sql) => analyzeQueryRisk({ sql: sql.trim(), permission: config.permission, blacklist, schemaLookup, dialect: toSqlDialect(config.connection?.system) });
-  const analyzePlan = (sql) => analyzeQueryRisk({ sql: sql.trim(), permission: "read-write", blacklist, schemaLookup, dialect: toSqlDialect(config.connection?.system) });
+  const analyze = (sql) => analyzeQueryRisk({
+    sql: sql.trim(),
+    permission: config.permission,
+    blacklist,
+    schemaLookup,
+    dialect: toSqlDialect(config.connection?.system)
+  });
+  const analyzePlan = (sql) => analyzeQueryRisk({
+    sql: sql.trim(),
+    permission: "read-write",
+    blacklist,
+    schemaLookup,
+    dialect: toSqlDialect(config.connection?.system)
+  });
   const ddlStatementGuard = async (statement, table) => {
     if (!isSingleStatement(statement)) {
       return {
@@ -99786,7 +100610,13 @@ function buildConstraintRunners(ctx, input) {
   const blacklist = config.blacklist ?? { tables: [], columns: {} };
   const schema = config.schema ?? {};
   const schemaLookup = { tables: schema, cacheAvailable: Object.keys(schema).length > 0 };
-  const analyze = (sql) => analyzeQueryRisk({ sql: sql.trim(), permission: config.permission, blacklist, schemaLookup, dialect: toSqlDialect(config.connection?.system) });
+  const analyze = (sql) => analyzeQueryRisk({
+    sql: sql.trim(),
+    permission: config.permission,
+    blacklist,
+    schemaLookup,
+    dialect: toSqlDialect(config.connection?.system)
+  });
   const engine = constraintEngineOf(config.connection.system);
   const violationSql = buildViolationQuery(input, engine);
   const columnsExist = async (table, cols) => {
@@ -103041,17 +103871,20 @@ class ReplEngine {
         };
       }
     }
-    if (this.config?.blacklist) {
-      const tableName = this.extractTableName(sql);
-      if (tableName) {
-        const blacklistedTables = this.config.blacklist.tables ?? [];
-        const isBlacklisted = blacklistedTables.some((t2) => t2.toLowerCase() === tableName.toLowerCase());
-        if (isBlacklisted) {
-          return {
-            action: "continue",
-            output: import_picocolors3.default.red(t_vars("shell.error_blacklisted", { table: tableName }))
-          };
-        }
+    const referencedTables = extractTableReferences(sql, {
+      dialect: SQL_DIALECTS.find((dialect) => dialect === this.context.system)
+    });
+    const blacklistValidator = this.config?.blacklist ? new BlacklistValidator(new BlacklistManager(this.config)) : undefined;
+    if (blacklistValidator && referencedTables.length > 0) {
+      try {
+        blacklistValidator.checkTablesBlacklist("SELECT", referencedTables);
+      } catch (error) {
+        if (!(error instanceof BlacklistError))
+          throw error;
+        return {
+          action: "continue",
+          output: import_picocolors3.default.red(t_vars("shell.error_blacklisted", { table: error.message }))
+        };
       }
     }
     const startTime = Date.now();
@@ -103060,8 +103893,11 @@ class ReplEngine {
         noLimit: this.state.noLimit
       });
       const elapsed = Date.now() - startTime;
-      const rows = result.rows;
-      const columnNames = rows.length > 0 && rows[0] ? Object.keys(rows[0]) : [];
+      const fetched = result.rows;
+      const fetchedColumns = fetched.length > 0 && fetched[0] ? Object.keys(fetched[0]) : [];
+      const filtered = blacklistValidator ? blacklistValidator.filterColumnsForTables(referencedTables, fetched, fetchedColumns) : { filteredRows: fetched, omittedColumns: [] };
+      const rows = filtered.filteredRows;
+      const columnNames = fetchedColumns.filter((col) => !filtered.omittedColumns.includes(col));
       const queryResult = {
         rows,
         rowCount: rows.length,
@@ -103113,10 +103949,6 @@ class ReplEngine {
     }
     return null;
   }
-  extractTableName(sql) {
-    const match = sql.match(/\b(?:FROM|INTO|UPDATE)\s+["'`]?(\w+)["'`]?/i);
-    return match?.[1];
-  }
   isConnectionError(error) {
     const e = error;
     const msg = (e.message ?? "").toLowerCase();
@@ -103131,6 +103963,9 @@ var init_repl_engine = __esm(() => {
   init_permission_guard();
   init_query_result_formatter();
   init_message_loader();
+  init_sql_tables();
+  init_blacklist_validator();
+  init_blacklist();
   import_picocolors3 = __toESM(require_picocolors(), 1);
 });
 
@@ -103340,22 +104175,115 @@ function extractIndexFromPath(path6) {
     return;
   return seg.split("?")[0];
 }
-async function runEsRequest(req, adapter, blacklistTables) {
-  const index = extractIndexFromPath(req.path);
-  if (index && blacklistTables.some((t2) => t2.toLowerCase() === index.toLowerCase())) {
-    throw new Error(`BlacklistRejection: index '${index}' is blacklist-protected`);
+function isUnscopedMetadataPath(path6) {
+  const first = path6.replace(/^\//, "").split("/")[0]?.split("?")[0] ?? "";
+  return UNSCOPED_METADATA_PREFIXES.includes(first);
+}
+function findIndexNamesInBody(body) {
+  const found = [];
+  const walk = (node) => {
+    if (Array.isArray(node)) {
+      for (const item of node)
+        walk(item);
+      return;
+    }
+    if (node === null || typeof node !== "object")
+      return;
+    for (const [key, value] of Object.entries(node)) {
+      if (key === "_index" || key === "index") {
+        for (const candidate of Array.isArray(value) ? value : [value]) {
+          if (typeof candidate === "string" && candidate.length > 0)
+            found.push(candidate);
+        }
+      }
+      walk(value);
+    }
+  };
+  walk(body);
+  return found;
+}
+async function runEsRequest(req, adapter, blacklistTables, blacklistColumns = {}) {
+  const rawPath = req.path.split("?")[0] ?? req.path;
+  const routedPath = normalizeEsPath(rawPath);
+  const index = extractIndexFromPath(routedPath);
+  if (blacklistTables.length > 0) {
+    const literalSegments = `/${rawPath.split("/").filter(Boolean).join("/")}`;
+    if (routedPath !== literalSegments) {
+      throw new Error(`BlacklistRejection: '${req.path}' routes to '${routedPath}', which is not what it ` + `spells. Write the path the server will receive.`);
+    }
+    const blacklistedSegment = routedPath.split("/").find((segment) => segment.length > 0 && indexExpressionReaches(segment, blacklistTables));
+    if (blacklistedSegment !== undefined) {
+      throw new Error(`BlacklistRejection: index '${blacklistedSegment}' is blacklist-protected`);
+    }
+    if (index === undefined) {
+      if (!isUnscopedMetadataPath(routedPath)) {
+        throw new Error(`BlacklistRejection: '${req.path}' names no index, so it cannot be checked against ` + `the blacklist. Scope the request to an index, e.g. GET /<index>/_search.`);
+      }
+    }
+    const inBody = findIndexNamesInBody(req.body).find((name2) => indexExpressionReaches(name2, blacklistTables));
+    if (inBody !== undefined) {
+      throw new Error(`BlacklistRejection: index '${inBody}' is blacklist-protected`);
+    }
+  }
+  const protectedFields = new Set(Object.values(blacklistColumns).flat());
+  if (protectedFields.size > 0) {
+    const named = findStrings(req.body).find((text2) => protectedFields.has(text2));
+    if (named !== undefined) {
+      throw new Error(`BlacklistRejection: field '${named}' is blacklist-protected and cannot be named in a ` + `request \u2014 sorting, aggregating or scripting on it would return its values.`);
+    }
   }
   let body = req.body;
   if (req.path.includes("_search") && body !== null && typeof body === "object" && !Array.isArray(body) && body.size === undefined) {
     body = { ...body, size: ES_SHELL_SIZE_CAP };
   }
-  return adapter.request(req.method, req.path, body);
+  const response = await adapter.request(req.method, req.path, body);
+  return protectedFields.size === 0 ? response : redactFields(response, protectedFields);
+}
+function findStrings(node) {
+  const found = [];
+  const walk = (value) => {
+    if (typeof value === "string") {
+      found.push(value);
+      for (const piece of value.split(/[^A-Za-z0-9_.]+/)) {
+        if (piece.length > 0 && piece !== value)
+          found.push(piece);
+      }
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value)
+        walk(item);
+      return;
+    }
+    if (value === null || typeof value !== "object")
+      return;
+    for (const [key, nested] of Object.entries(value)) {
+      found.push(key);
+      walk(nested);
+    }
+  };
+  walk(node);
+  return found;
+}
+function redactFields(node, fields) {
+  if (Array.isArray(node))
+    return node.map((item) => redactFields(item, fields));
+  if (node === null || typeof node !== "object")
+    return node;
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (fields.has(key))
+      continue;
+    out[key] = redactFields(value, fields);
+  }
+  return out;
 }
 async function runEsShell(configPath) {
   const config = await configModule.read(configPath);
   const adapter = AdapterFactory.createElasticsearchAdapter(config.connection);
   await adapter.connect();
   const blacklistTables = config.blacklist?.tables ?? [];
+  const blacklistColumns = config.blacklist?.columns ?? {};
   console.error(import_picocolors4.default.bold("Elasticsearch shell \u2014 Kibana Dev Tools syntax"));
   console.error(import_picocolors4.default.dim('Enter "<METHOD> /<path>" then an optional JSON body; submit with a blank line. Try: GET /_cat/indices'));
   console.error(import_picocolors4.default.dim('Ctrl+C cancels the current block; Ctrl+D or "exit" quits.'));
@@ -103380,7 +104308,7 @@ async function runEsShell(configPath) {
     }
     try {
       const req = parseEsRequest(block2);
-      const res = await runEsRequest(req, adapter, blacklistTables);
+      const res = await runEsRequest(req, adapter, blacklistTables, blacklistColumns);
       console.log(JSON.stringify(res, null, 2));
     } catch (error) {
       console.error(import_picocolors4.default.red(error.message));
@@ -103408,11 +104336,13 @@ async function runEsShell(configPath) {
     process.exit(0);
   });
 }
-var import_picocolors4, ES_SHELL_SIZE_CAP = 1000;
+var import_picocolors4, UNSCOPED_METADATA_PREFIXES, ES_SHELL_SIZE_CAP = 1000;
 var init_es_shell = __esm(() => {
   init_config();
   init_adapters();
+  init_es_index_target();
   import_picocolors4 = __toESM(require_picocolors(), 1);
+  UNSCOPED_METADATA_PREFIXES = ["_cat", "_cluster", "_nodes", "_tasks", "_ingest", "_license"];
 });
 
 // src/core/repl/command-registry.ts
@@ -105380,6 +106310,10 @@ function fingerprintSql(sql) {
 function shellEscapeDq(s) {
   return s.replace(/\\/g, "\\\\").replace(/\$/g, "\\$").replace(/`/g, "\\`").replace(/"/g, "\\\"");
 }
+function explainSuggestions(sql) {
+  const esc = shellEscapeDq(sql);
+  return [`dbcli explain "${esc}"`, `dbcli guide missing-index-for "${esc}"`];
+}
 function buildByFingerprint(events, slowMs, top) {
   const errorByFp = new Map;
   for (const e of events.filter(isErrored)) {
@@ -105448,11 +106382,7 @@ function buildByFingerprint(events, slowMs, top) {
   stats.sort((a, b) => b.durationMs.total - a.durationMs.total);
   return stats.map((s, i) => {
     if (i < top && s.statement === "SELECT") {
-      const sql = shellEscapeDq(s.exampleSql);
-      return {
-        ...s,
-        suggestedCommands: [`dbcli explain "${sql}"`, `dbcli guide missing-index-for "${sql}"`]
-      };
+      return { ...s, suggestedCommands: explainSuggestions(s.exampleSql) };
     }
     return s;
   });
@@ -105479,13 +106409,27 @@ function buildErrors(events) {
         message: e.error.message,
         count: 0,
         fingerprint: fingerprintSql(e.sql),
-        exampleSql: e.sql
+        exampleSql: e.sql,
+        tables: e.tables
       };
       groups.set(key, g);
     }
     g.count += 1;
   }
-  return [...groups.values()].sort((a, b) => b.count - a.count);
+  return [...groups.values()].sort((a, b) => b.count - a.count).map((g) => {
+    const schemaCmds = g.tables.slice(0, MAX_ERROR_SCHEMA_TABLES).map((t2) => `dbcli schema ${t2}`);
+    const hint = `failed ${g.count}\xD7: verify the involved table/column names against the live schema ` + `before fixing the SQL \u2014 never guess column names`;
+    return {
+      code: g.code,
+      message: g.message,
+      count: g.count,
+      fingerprint: g.fingerprint,
+      exampleSql: g.exampleSql,
+      tables: g.tables,
+      ...schemaCmds.length ? { suggestedCommands: schemaCmds } : {},
+      hints: [hint]
+    };
+  });
 }
 function buildHotTables(events) {
   const map = new Map;
@@ -105514,10 +106458,13 @@ function buildRepetition(events, threshold) {
         fingerprint: fp,
         sessionId: e.sessionId,
         tables: e.tables,
+        statement: e.statement,
         count: 0,
         totalDurationMs: 0,
         minTs: ts,
-        maxTs: ts
+        maxTs: ts,
+        exampleSql: e.sql,
+        exampleDuration: e.durationMs
       };
       groups.set(key, g);
     }
@@ -105527,15 +106474,27 @@ function buildRepetition(events, threshold) {
       g.minTs = ts;
     if (ts > g.maxTs)
       g.maxTs = ts;
+    if (e.durationMs > g.exampleDuration) {
+      g.exampleDuration = e.durationMs;
+      g.exampleSql = e.sql;
+    }
   }
-  return [...groups.values()].filter((g) => g.count >= threshold).map((g) => ({
-    fingerprint: g.fingerprint,
-    sessionId: g.sessionId,
-    count: g.count,
-    spanMs: g.maxTs - g.minTs,
-    totalDurationMs: g.totalDurationMs,
-    tables: g.tables
-  })).sort((a, b) => b.count - a.count);
+  return [...groups.values()].filter((g) => g.count >= threshold).sort((a, b) => b.count - a.count).map((g) => {
+    const spanMs = g.maxTs - g.minTs;
+    const hint = `N+1 suspect: the same query ran ${g.count}\xD7 within one session over ${spanMs}ms \u2014 ` + `collapse into a single query (JOIN / IN (...)) or cache the result`;
+    return {
+      fingerprint: g.fingerprint,
+      sessionId: g.sessionId,
+      count: g.count,
+      spanMs,
+      totalDurationMs: g.totalDurationMs,
+      tables: g.tables,
+      statement: g.statement,
+      exampleSql: g.exampleSql,
+      ...g.statement === "SELECT" ? { suggestedCommands: explainSuggestions(g.exampleSql) } : {},
+      hints: [hint]
+    };
+  });
 }
 function analyzeEvents(events, opts) {
   const timestamps = events.map((e) => e.timestamp).filter(Boolean).sort();
@@ -105589,7 +106548,7 @@ function buildSummary(events, slowMs) {
     }
   };
 }
-var isCompleted = (e) => e.type === "query_completed", isErrored = (e) => e.type === "query_errored";
+var isCompleted = (e) => e.type === "query_completed", isErrored = (e) => e.type === "query_errored", MAX_ERROR_SCHEMA_TABLES = 3;
 var init_analyze = __esm(() => {
   init_sql_metadata();
 });
@@ -105629,12 +106588,29 @@ function renderAnalysisText(report, top) {
   for (const r of report.repetition.slice(0, top)) {
     L2.push(`  ${r.count}x in session ${r.sessionId} (${r.spanMs}ms)  ${r.fingerprint}`);
   }
-  const cmds = [...new Set(report.byFingerprint.flatMap((f) => f.suggestedCommands ?? []))];
+  const cmds = [
+    ...new Set([
+      ...report.byFingerprint.flatMap((f) => f.suggestedCommands ?? []),
+      ...report.errors.flatMap((e) => e.suggestedCommands ?? []),
+      ...report.repetition.flatMap((r) => r.suggestedCommands ?? [])
+    ])
+  ];
   if (cmds.length) {
     L2.push("", "SUGGESTED COMMANDS");
     for (const c2 of cmds)
       L2.push(`  ${c2}`);
   }
+  const hints = [
+    ...new Set([
+      ...report.errors.flatMap((e) => e.hints ?? []),
+      ...report.repetition.flatMap((r) => r.hints ?? [])
+    ])
+  ];
+  if (hints.length) {
+    L2.push("", "HINTS");
+    for (const h of hints)
+      L2.push(`  ${h}`);
+  }
   return L2.join(`
 `);
 }