@carllee1983/dbcli 1.58.0 → 2.0.0

package/dist/cli-runtime.mjs

@@ -51,7 +51,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@carllee1983/dbcli",
-    version: "1.58.0",
+    version: "2.0.0",
     description: "Database CLI for AI agents",
     type: "module",
     publishConfig: {
@@ -9473,6 +9473,23 @@ var init_ceremony = __esm(() => {
     confirm_destructive_warning_ddl: "\u26A0\uFE0F  Warning: this schema change is destructive and cannot be undone!",
     confirm_ddl_prompt: "Are you sure you want to run this {operation}? This cannot be undone.",
     confirm_prompt: "Proceed with this operation?",
+    gate_summary: "This will {operation} rows in {table}.",
+    gate_summary_untargeted: "This will run a {operation} statement.",
+    gate_statement: "Statement:",
+    gate_cancelled: "Cancelled. Nothing was run.",
+    gate_full_table_warning: "\u26A0\uFE0F  This affects EVERY row in {table} and cannot be undone.",
+    gate_ddl_warning: "\u26A0\uFE0F  This destroys {table} and cannot be undone.",
+    gate_ddl_warning_untargeted: "\u26A0\uFE0F  This is a destructive schema change and cannot be undone.",
+    gate_unparseable_warning: "\u26A0\uFE0F  dbcli could not parse this statement, so it is treated as affecting everything.",
+    gate_multiple_statements_warning: "\u26A0\uFE0F  This is more than one statement, and dbcli will not judge them one at a time.",
+    gate_typed_prompt: "Type {phrase} to run it",
+    gate_typed_mismatch: "That did not match {phrase}. Nothing was run.",
+    gate_refused: "Refused: this statement is not limited to specific rows and nobody is here to confirm it (reason={reason}).",
+    gate_remedy_no_where: "Add a WHERE clause \u2014 WHERE 1=1 if you really do mean every row \u2014 or a LIMIT, then run it again.",
+    gate_remedy_ddl_destruction: "No flag skips this. Run it from an interactive terminal, or apply the schema change through a reviewed migration.",
+    gate_remedy_unparseable: "dbcli could not parse this statement and will not guess. Simplify it, or run it from an interactive terminal.",
+    gate_remedy_multiple_statements: "Run one statement per command.",
+    gate_remedy_non_unique_where: "Match on a primary key or a uniquely indexed column, or run it from an interactive terminal.",
     recovery_none: "This cannot be undone automatically \u2014 restore from a backup to get the previous values back.",
     recovery_retry: "Re-run with --recovery to write a recovery plan, then read it with: dbcli recover",
     blacklist_hint: "Run `dbcli blacklist list` to see what is protected"
@@ -9500,6 +9517,23 @@ var init_ceremony2 = __esm(() => {
     confirm_destructive_warning_ddl: "\u26A0\uFE0F  \u8B66\u544A\uFF1A\u9019\u500B schema \u8B8A\u66F4\u5177\u7834\u58DE\u6027\uFF0C\u57F7\u884C\u5F8C\u7121\u6CD5\u5FA9\u539F\uFF01",
     confirm_ddl_prompt: "\u78BA\u5B9A\u8981\u57F7\u884C\u9019\u500B {operation} \u55CE\uFF1F\u6B64\u64CD\u4F5C\u7121\u6CD5\u5FA9\u539F\u3002",
     confirm_prompt: "\u8981\u7E7C\u7E8C\u57F7\u884C\u9019\u500B\u64CD\u4F5C\u55CE\uFF1F",
+    gate_summary: "\u9019\u53E5\u6703\u5C0D {table} \u57F7\u884C {operation}\u3002",
+    gate_summary_untargeted: "\u9019\u53E5\u6703\u57F7\u884C {operation}\u3002",
+    gate_statement: "\u8A9E\u53E5\uFF1A",
+    gate_cancelled: "\u5DF2\u53D6\u6D88\uFF0C\u6C92\u6709\u57F7\u884C\u4EFB\u4F55\u8A9E\u53E5\u3002",
+    gate_full_table_warning: "\u26A0\uFE0F  \u9019\u53E5\u6703\u5F71\u97FF {table} \u7684\u6BCF\u4E00\u5217\uFF0C\u57F7\u884C\u5F8C\u7121\u6CD5\u5FA9\u539F\u3002",
+    gate_ddl_warning: "\u26A0\uFE0F  \u9019\u53E5\u6703\u6467\u6BC0 {table}\uFF0C\u57F7\u884C\u5F8C\u7121\u6CD5\u5FA9\u539F\u3002",
+    gate_ddl_warning_untargeted: "\u26A0\uFE0F  \u9019\u662F\u7834\u58DE\u6027\u7684 schema \u8B8A\u66F4\uFF0C\u57F7\u884C\u5F8C\u7121\u6CD5\u5FA9\u539F\u3002",
+    gate_unparseable_warning: "\u26A0\uFE0F  dbcli \u7121\u6CD5\u89E3\u6790\u9019\u53E5\uFF0C\u56E0\u6B64\u4E00\u5F8B\u8996\u70BA\u6703\u5F71\u97FF\u5168\u90E8\u8CC7\u6599\u3002",
+    gate_multiple_statements_warning: "\u26A0\uFE0F  \u9019\u88E1\u4E0D\u53EA\u4E00\u53E5\u8A9E\u53E5\uFF0Cdbcli \u4E0D\u6703\u9010\u53E5\u5224\u65B7\u3002",
+    gate_typed_prompt: "\u8F38\u5165 {phrase} \u624D\u6703\u57F7\u884C",
+    gate_typed_mismatch: "\u8F38\u5165\u7684\u5167\u5BB9\u8207 {phrase} \u4E0D\u7B26\uFF0C\u6C92\u6709\u57F7\u884C\u4EFB\u4F55\u8A9E\u53E5\u3002",
+    gate_refused: "\u5DF2\u62D2\u7D55\uFF1A\u9019\u53E5\u6C92\u6709\u9650\u5B9A\u8981\u52D5\u54EA\u4E9B\u5217\uFF0C\u800C\u73FE\u5728\u6C92\u6709\u4EBA\u80FD\u78BA\u8A8D\uFF08reason={reason}\uFF09\u3002",
+    gate_remedy_no_where: "\u88DC\u4E0A WHERE\uFF08\u771F\u7684\u8981\u5168\u8868\u5C31\u5BEB WHERE 1=1\uFF09\u6216 LIMIT\uFF0C\u7136\u5F8C\u91CD\u8DD1\u3002",
+    gate_remedy_ddl_destruction: "\u6C92\u6709\u4EFB\u4F55\u65D7\u6A19\u53EF\u4EE5\u8DF3\u904E\u9019\u4E00\u95DC\u3002\u8ACB\u5728\u4E92\u52D5\u7D42\u7AEF\u4E0B\u57F7\u884C\uFF0C\u6216\u6539\u8D70\u7D93\u904E\u5BE9\u67E5\u7684 migration\u3002",
+    gate_remedy_unparseable: "dbcli \u7121\u6CD5\u89E3\u6790\u9019\u53E5\uFF0C\u4E5F\u4E0D\u6703\u7528\u731C\u7684\u3002\u8ACB\u7C21\u5316\u8A9E\u53E5\uFF0C\u6216\u5728\u4E92\u52D5\u7D42\u7AEF\u4E0B\u57F7\u884C\u3002",
+    gate_remedy_multiple_statements: "\u4E00\u6B21\u53EA\u57F7\u884C\u4E00\u53E5\u8A9E\u53E5\u3002",
+    gate_remedy_non_unique_where: "\u6539\u7528\u4E3B\u9375\u6216\u552F\u4E00\u7D22\u5F15\u6B04\u4F4D\u7576\u689D\u4EF6\uFF0C\u6216\u5728\u4E92\u52D5\u7D42\u7AEF\u4E0B\u57F7\u884C\u3002",
     recovery_none: "\u6B64\u64CD\u4F5C\u7121\u6CD5\u81EA\u52D5\u9084\u539F\uFF0C\u8981\u53D6\u56DE\u5148\u524D\u7684\u8CC7\u6599\u8ACB\u5F9E\u5099\u4EFD\u56DE\u5FA9\u3002",
     recovery_retry: "\u52A0\u4E0A --recovery \u91CD\u8DD1\u53EF\u7522\u751F\u56DE\u5FA9\u8A08\u756B\uFF0C\u518D\u7528 dbcli recover \u8B80\u53D6",
     blacklist_hint: "\u57F7\u884C `dbcli blacklist list` \u67E5\u770B\u53D7\u4FDD\u8B77\u7684\u9805\u76EE"
@@ -9730,7 +9764,8 @@ async function readLineFromStdin(prompt = "") {
 }
 async function textFallback(message, defaultValue) {
   const displayMessage = defaultValue ? `${message} [${defaultValue}]: ` : `${message}: `;
-  const answer = await readLineFromStdin(displayMessage);
+  process.stderr.write(displayMessage);
+  const answer = await readLineFromStdin();
   return answer.trim() || defaultValue || "";
 }
 async function selectFallback(message, choices) {
@@ -9756,7 +9791,7 @@ async function text(message, defaultValue) {
   const inquirer = await loadInquirer();
   if (!inquirer)
     return textFallback(message, defaultValue);
-  return await inquirer.input({ message, default: defaultValue });
+  return await inquirer.input({ message, default: defaultValue }, { output: process.stderr });
 }
 async function select(message, choices) {
   if (!process.stdin.isTTY)
@@ -22202,6 +22237,360 @@ var init_elasticsearch = __esm(() => {
   ES_DOCUMENT_PATH = /\/(?:_doc|_source)\/[^/?]+/;
 });
 
+// src/commands/mutation-outcome.ts
+var exports_mutation_outcome = {};
+__export(exports_mutation_outcome, {
+  shouldRenderForHuman: () => shouldRenderForHuman,
+  renderMutationOutcome: () => renderMutationOutcome,
+  printMutationOutcome: () => printMutationOutcome,
+  printMutationFailure: () => printMutationFailure,
+  humanOutputContext: () => humanOutputContext,
+  cancelledOutcome: () => cancelledOutcome
+});
+function shouldRenderForHuman(context) {
+  if (context.format === "json")
+    return false;
+  return context.isTTY;
+}
+function humanOutputContext(options) {
+  return { isTTY: process.stdout.isTTY === true, ...options.format && { format: options.format } };
+}
+function renderMutationOutcome(result, table, elapsedMs) {
+  if (result.status === "error") {
+    return [
+      t_vars("ceremony.failed", { reason: result.error ?? t("ceremony.unknown_error") }),
+      t("ceremony.recovery_retry")
+    ];
+  }
+  if (result.status === "cancelled") {
+    return [t_vars("ceremony.cancelled", { table })];
+  }
+  if (result.status === "dry_run") {
+    return [t_vars("ceremony.dry_run", { table })];
+  }
+  const elapsed = t_vars("ceremony.elapsed", { seconds: (elapsedMs / 1000).toFixed(2) });
+  if (result.rows_affected === 0) {
+    return [t_vars("ceremony.matched_nothing", { table }), elapsed];
+  }
+  return [
+    t_vars(VERB_KEY[result.operation], { count: result.rows_affected, table }),
+    elapsed,
+    t("ceremony.recovery_none")
+  ];
+}
+function printMutationOutcome(result, table, elapsedMs, context, envelopeExtras = {}) {
+  if (shouldRenderForHuman(context)) {
+    const writeLine = result.status === "error" ? console.error : console.log;
+    for (const line of renderMutationOutcome(result, table, elapsedMs))
+      writeLine(line);
+    return;
+  }
+  console.log(JSON.stringify({ ...mutationEnvelope(result), ...envelopeExtras }, null, 2));
+}
+function printMutationFailure(error, operation, context) {
+  if (shouldRenderForHuman(context)) {
+    console.error(t_vars("ceremony.failed", { reason: error.message }));
+    if (error instanceof BlacklistError) {
+      console.error(t("ceremony.blacklist_hint"));
+    }
+    return;
+  }
+  console.log(JSON.stringify({ status: "error", operation, rows_affected: 0, error: error.message }, null, 2));
+}
+function cancelledOutcome(operation, preview) {
+  return {
+    status: "cancelled",
+    operation,
+    rows_affected: 0,
+    sql: preview,
+    timestamp: new Date().toISOString()
+  };
+}
+function mutationEnvelope(result) {
+  return {
+    status: result.status,
+    operation: result.operation,
+    rows_affected: result.rows_affected,
+    ...result.timestamp && { timestamp: result.timestamp },
+    ...result.sql && { sql: result.sql },
+    ...result.error && { error: result.error }
+  };
+}
+var VERB_KEY;
+var init_mutation_outcome = __esm(() => {
+  init_message_loader();
+  init_blacklist();
+  VERB_KEY = {
+    insert: "ceremony.inserted",
+    update: "ceremony.updated",
+    delete: "ceremony.deleted"
+  };
+});
+
+// src/commands/write-gate-prompt.ts
+var exports_write_gate_prompt = {};
+__export(exports_write_gate_prompt, {
+  enforceWriteGate: () => enforceWriteGate,
+  WriteGateRefusal: () => WriteGateRefusal
+});
+async function enforceWriteGate(request) {
+  const { verdict, human } = request;
+  if (verdict.tier === "none")
+    return true;
+  const attended = isAttended(human);
+  if (verdict.tier === "two")
+    return await enforceTierTwo(request, attended);
+  if (request.yes === true)
+    return true;
+  if (!attended)
+    return true;
+  writeSummary(request);
+  const proceed = await promptUser.confirm(t("ceremony.confirm_prompt"));
+  if (!proceed)
+    process.stderr.write(`${t("ceremony.gate_cancelled")}
+`);
+  return proceed;
+}
+function isAttended(human) {
+  return shouldRenderForHuman(human) && process.stdin.isTTY === true;
+}
+async function enforceTierTwo(request, attended) {
+  const { verdict } = request;
+  const reason = verdict.reason ?? "no_where";
+  if (!attended) {
+    throw new WriteGateRefusal(`${t_vars("ceremony.gate_refused", { reason })} ${t(REMEDY_KEY[reason])}`, reason, verdict.table);
+  }
+  writeSummary(request);
+  const warning = verdict.table === undefined && reason === "ddl_destruction" ? t("ceremony.gate_ddl_warning_untargeted") : t_vars(WARNING_KEY[reason], { table: verdict.table ?? "" });
+  process.stderr.write(`
+${warning}
+${t(REMEDY_KEY[reason])}
+`);
+  const typed = await promptUser.text(t_vars("ceremony.gate_typed_prompt", { phrase: verdict.confirmationPhrase }));
+  const matched = typed.trim().toLowerCase() === verdict.confirmationPhrase.toLowerCase();
+  if (!matched) {
+    process.stderr.write(`${t_vars("ceremony.gate_typed_mismatch", { phrase: verdict.confirmationPhrase })}
+`);
+  }
+  return matched;
+}
+function writeSummary(request) {
+  const { verdict, operation, statement } = request;
+  const summary = verdict.table ? t_vars("ceremony.gate_summary", { operation, table: verdict.table }) : t_vars("ceremony.gate_summary_untargeted", { operation });
+  process.stderr.write(`
+${summary}
+${t("ceremony.gate_statement")}
+  ${statement}
+`);
+}
+var WriteGateRefusal, REMEDY_KEY, WARNING_KEY;
+var init_write_gate_prompt = __esm(() => {
+  init_message_loader();
+  init_prompts();
+  init_mutation_outcome();
+  WriteGateRefusal = class WriteGateRefusal extends Error {
+    code = "WRITE_GATE_REFUSED";
+    reason;
+    table;
+    constructor(message, reason, table) {
+      super(message);
+      this.name = "WriteGateRefusal";
+      this.reason = reason;
+      this.table = table;
+    }
+  };
+  REMEDY_KEY = {
+    no_where: "ceremony.gate_remedy_no_where",
+    ddl_destruction: "ceremony.gate_remedy_ddl_destruction",
+    unparseable: "ceremony.gate_remedy_unparseable",
+    non_unique_where: "ceremony.gate_remedy_non_unique_where",
+    multiple_statements: "ceremony.gate_remedy_multiple_statements"
+  };
+  WARNING_KEY = {
+    no_where: "ceremony.gate_full_table_warning",
+    ddl_destruction: "ceremony.gate_ddl_warning",
+    unparseable: "ceremony.gate_unparseable_warning",
+    non_unique_where: "ceremony.gate_full_table_warning",
+    multiple_statements: "ceremony.gate_multiple_statements_warning"
+  };
+});
+
+// src/core/sql-parser.ts
+var exports_sql_parser = {};
+__export(exports_sql_parser, {
+  sqlParser: () => sqlParser
+});
+function sqlParser() {
+  if (!cached2) {
+    const { Parser } = __require("node-sql-parser");
+    cached2 = new Parser;
+  }
+  return cached2;
+}
+var cached2 = null;
+
+// src/commands/write-gate.ts
+var exports_write_gate = {};
+__export(exports_write_gate, {
+  classifyStructuredWriteGate: () => classifyStructuredWriteGate,
+  classifySqlWriteGate: () => classifySqlWriteGate,
+  WRITE_GATE_FALLBACK_PHRASE: () => WRITE_GATE_FALLBACK_PHRASE
+});
+async function classifySqlWriteGate(sql, options = {}) {
+  const { dialect } = options;
+  const classification = classifyStatement(sql);
+  const hiddenWrite = findWriteKeyword(sql, dialect ? [dialect] : undefined);
+  const type = WRITE_TYPES.has(classification.type) ? classification.type : hiddenWrite ? keywordToType(hiddenWrite) : undefined;
+  if (type === undefined)
+    return { tier: "none", confirmationPhrase: WRITE_GATE_FALLBACK_PHRASE };
+  if (containsMultipleStatements(sql, dialect)) {
+    return verdict("two", "multiple_statements", undefined, type);
+  }
+  if (type === "DROP" || type === "TRUNCATE") {
+    const matched = DDL_TARGET.exec(sql)?.[1];
+    const table = matched ? matched.replace(/[`"[\]]/g, "") : undefined;
+    return verdict("two", "ddl_destruction", table, type);
+  }
+  if (type !== "UPDATE" && type !== "DELETE")
+    return verdict("one", undefined, undefined, type);
+  return await classifyQualification(sql, dialect, type);
+}
+async function classifyQualification(sql, dialect, type) {
+  const { sqlParser: sqlParser2 } = await Promise.resolve().then(() => exports_sql_parser);
+  let ast;
+  try {
+    ast = sqlParser2().astify(sql, { database: PARSER_DIALECTS[dialect ?? "mysql"] });
+  } catch {
+    return unparseable(sql, dialect, type);
+  }
+  const statement = Array.isArray(ast) ? ast[0] : ast;
+  if (!statement)
+    return unparseable(sql, dialect, type);
+  const table = tableName(statement.from?.[0] ?? statement.table?.[0]);
+  if (statement.where != null || statement.limit != null) {
+    return verdict("one", undefined, table, type);
+  }
+  return verdict("two", "no_where", table, type);
+}
+function unparseable(sql, dialect, type) {
+  const executable = stripCommentsAndStrings(sql, dialect ? { dialect } : {});
+  if (/\bWHERE\b|\bLIMIT\b/i.test(executable))
+    return verdict("one", undefined, undefined, type);
+  return verdict("two", "unparseable", undefined, type);
+}
+function classifyStructuredWriteGate(request) {
+  const conditions = new Set(Object.keys(request.where).map((key) => key.toLowerCase()));
+  const identifies = uniqueSelectors(request.schema).some((selector) => selector.length > 0 && selector.every((column) => conditions.has(column.toLowerCase())));
+  if (identifies)
+    return verdict("one", undefined, request.table);
+  return verdict("two", "non_unique_where", request.table);
+}
+function uniqueSelectors(schema) {
+  const declared = schema.primaryKey;
+  const primaryKey = Array.isArray(declared) ? declared : typeof declared === "string" ? [declared] : (schema.columns ?? []).filter((column) => column.primaryKey).map((column) => column.name);
+  const unique = (schema.indexes ?? []).filter((index) => index.unique).map((index) => index.columns);
+  return [primaryKey, ...unique];
+}
+function tableName(ref) {
+  if (!ref?.table)
+    return;
+  return ref.db ? `${ref.db}.${ref.table}` : ref.table;
+}
+function keywordToType(keyword) {
+  const upper = keyword.toUpperCase();
+  if (WRITE_TYPES.has(upper))
+    return upper;
+  return "INSERT";
+}
+function verdict(tier, reason, table, operation) {
+  return {
+    tier,
+    ...reason && { reason },
+    ...table && { table },
+    ...operation && { operation },
+    confirmationPhrase: table ?? WRITE_GATE_FALLBACK_PHRASE
+  };
+}
+var WRITE_GATE_FALLBACK_PHRASE = "CONFIRM", PARSER_DIALECTS, WRITE_TYPES, DDL_TARGET;
+var init_write_gate = __esm(() => {
+  init_permission_guard();
+  init_sql_analysis();
+  PARSER_DIALECTS = {
+    mysql: "MySQL",
+    mariadb: "MariaDB",
+    postgresql: "Postgresql"
+  };
+  WRITE_TYPES = new Set([
+    "INSERT",
+    "UPDATE",
+    "DELETE",
+    "TRUNCATE",
+    "DROP",
+    "ALTER",
+    "CREATE"
+  ]);
+  DDL_TARGET = /\b(?:DROP\s+TABLE|TRUNCATE(?:\s+TABLE)?)\s+(?:IF\s+EXISTS\s+)?([`"[\]\w$.]+)\s*;?\s*$/i;
+});
+
+// src/commands/write-gate-guard.ts
+var exports_write_gate_guard = {};
+__export(exports_write_gate_guard, {
+  recordGateDecision: () => recordGateDecision,
+  guardStructuredWrite: () => guardStructuredWrite
+});
+async function recordGateDecision(request) {
+  await writeAuditEntry(request.config, request.command, request.options, {
+    success: request.outcome === "allowed",
+    ...request.sql && { sql: request.sql },
+    ...request.verdict.table && { target: request.verdict.table },
+    metadata: {
+      write_gate_tier: request.tier,
+      write_gate_outcome: request.outcome,
+      write_gate_reason: request.verdict.reason ?? "no_where"
+    }
+  });
+}
+async function guardStructuredWrite(request) {
+  const verdict2 = classifyStructuredWriteGate({
+    table: request.table,
+    where: request.where,
+    schema: request.schema
+  });
+  if (verdict2.tier !== "two")
+    return true;
+  const operation = request.operation.toUpperCase();
+  const preview = `${operation} ${request.table} WHERE ${Object.keys(request.where).join(", ")}`;
+  const record = (outcome) => recordGateDecision({
+    config: request.config,
+    command: request.operation,
+    options: request.options,
+    verdict: verdict2,
+    outcome,
+    tier: "two",
+    sql: preview
+  });
+  try {
+    const proceed = await enforceWriteGate({
+      verdict: verdict2,
+      statement: preview,
+      operation,
+      human: humanOutputContext(request.options)
+    });
+    await record(proceed ? "allowed" : "declined");
+    return proceed;
+  } catch (error) {
+    if (error instanceof WriteGateRefusal)
+      await record("refused");
+    throw error;
+  }
+}
+var init_write_gate_guard = __esm(() => {
+  init_integration_helper();
+  init_mutation_outcome();
+  init_write_gate();
+  init_write_gate_prompt();
+});
+
 // src/core/permission/redis.ts
 var exports_redis = {};
 __export(exports_redis, {
@@ -22528,10 +22917,24 @@ async function executeQueryCommand(sql, options, command, runtimeOverrides = {})
     connectionName = connectionNames[0];
     config = await runtime.loadConfig(configPath, connectionName);
     const context = { config, configPath, connectionName };
+    if (!await runtime.enforceGate(resolvedSql, options, context))
+      return;
     await runtime.preflight(resolvedSql, options, context, fieldSelection, false);
     const execution = await runtime.executeConnection(resolvedSql, options, context, fieldSelection);
     await runtime.presentResult(resolvedSql, options, execution, tableCellLimit);
   } catch (error) {
+    const { WriteGateRefusal: WriteGateRefusal2 } = await Promise.resolve().then(() => (init_write_gate_prompt(), exports_write_gate_prompt));
+    if (error instanceof WriteGateRefusal2) {
+      if (options.format === "json") {
+        console.log(JSON.stringify({
+          status: "refused",
+          code: error.code,
+          reason: error.reason,
+          ...error.table && { table: error.table }
+        }, null, 2));
+      }
+      throw error;
+    }
     let auditId = null;
     let envelopeId;
     if (options.recovery === true && !multiConnectionRequest) {
@@ -22618,6 +23021,48 @@ function scopeMultiConnectionNotices(execution) {
     notices: []
   };
 }
+async function enforceQueryWriteGate(query, options, context) {
+  const { config } = context;
+  const { toSqlDialect: toSqlDialect2, enforcePermission: enforcePermission2 } = await Promise.resolve().then(() => (init_permission_guard(), exports_permission_guard));
+  const dialect = toSqlDialect2(config.connection?.system);
+  if (!dialect)
+    return true;
+  const { classifySqlWriteGate: classifySqlWriteGate2 } = await Promise.resolve().then(() => (init_write_gate(), exports_write_gate));
+  const verdict2 = await classifySqlWriteGate2(query, { dialect });
+  if (verdict2.tier === "none")
+    return true;
+  enforcePermission2(query, config.permission, dialect);
+  const { enforceWriteGate: enforceWriteGate2, WriteGateRefusal: WriteGateRefusal2 } = await Promise.resolve().then(() => (init_write_gate_prompt(), exports_write_gate_prompt));
+  const { humanOutputContext: humanOutputContext2 } = await Promise.resolve().then(() => (init_mutation_outcome(), exports_mutation_outcome));
+  const { recordGateDecision: recordGateDecision2 } = await Promise.resolve().then(() => (init_write_gate_guard(), exports_write_gate_guard));
+  const record = (outcome) => recordGateDecision2({
+    config,
+    command: "query",
+    options: { ...options, config: context.configPath, connectionName: context.connectionName },
+    verdict: verdict2,
+    outcome,
+    tier: verdict2.tier === "two" ? "two" : "one",
+    sql: query
+  });
+  try {
+    const proceed = await enforceWriteGate2({
+      verdict: verdict2,
+      statement: query,
+      operation: verdict2.operation ?? "WRITE",
+      human: humanOutputContext2(options),
+      ...options.yes !== undefined && { yes: options.yes }
+    });
+    if (verdict2.tier === "two")
+      await record(proceed ? "allowed" : "declined");
+    else if (!proceed)
+      await record("declined");
+    return proceed;
+  } catch (error) {
+    if (error instanceof WriteGateRefusal2)
+      await record("refused");
+    throw error;
+  }
+}
 async function preflightQuery(query, options, context, fieldSelection, multiConnection) {
   const { config } = context;
   if (!config.connection)
@@ -23061,6 +23506,7 @@ var init_query = __esm(() => {
     executeConnection: executeConnectionQuery,
     presentResult: presentSingleResult,
     writeAudit: writeAuditEntry,
+    enforceGate: enforceQueryWriteGate,
     randomUUID: () => crypto3.randomUUID(),
     emitRecovery: async (error, context, options) => {
       const { emitRecoveryEnvelope: emitRecoveryEnvelope2 } = await Promise.resolve().then(() => (init_recovery(), exports_recovery));
@@ -23085,7 +23531,7 @@ __export(exports_inline_registrars, {
   registerDeleteCommand: () => registerDeleteCommand
 });
 function registerQueryCommand(program2, run) {
-  program2.command("query [sql]").description(t("query.description")).option("-f, --query-file <path>", "Read query text from a UTF-8 file, or - for stdin").option("--format <type>", "Output format: table, json, csv, html", "table").option("--ui", "Show interactive dashboard in browser", false).option("--limit <number>", "Limit result rows (overrides auto-limit)", parsePositiveInteger).option("--no-limit", "Disable auto-limit in query-only mode").option("--collection <name>", "MongoDB collection name; Elasticsearch index name").option("--index <name>", "Elasticsearch index name (alias for --collection)").option("--fields <list>", "Include fields, or exclude them with --fields=-field_a,-field_b").option("--truncate <number>", "Limit serialized table cells to N Unicode characters", parsePositiveInteger).option("--no-truncate", "Disable the default table-cell truncation").option("--slow-ms <number>", "Emit a passive performance hint at or above this execution time; 0 disables it", parseSlowMs, 1000).addOption(createConnectionSelectorOption()).option("--recovery", "On failure, emit a structured recovery envelope to stdout (suppresses human stderr message)", false).action(async (sql, options, command) => {
+  program2.command("query [sql]").description(t("query.description")).option("-f, --query-file <path>", "Read query text from a UTF-8 file, or - for stdin").option("--format <type>", "Output format: table, json, csv, html", "table").option("--ui", "Show interactive dashboard in browser", false).option("--limit <number>", "Limit result rows (overrides auto-limit)", parsePositiveInteger).option("--no-limit", "Disable auto-limit in query-only mode").option("--collection <name>", "MongoDB collection name; Elasticsearch index name").option("--index <name>", "Elasticsearch index name (alias for --collection)").option("--fields <list>", "Include fields, or exclude them with --fields=-field_a,-field_b").option("--truncate <number>", "Limit serialized table cells to N Unicode characters", parsePositiveInteger).option("--no-truncate", "Disable the default table-cell truncation").option("--slow-ms <number>", "Emit a passive performance hint at or above this execution time; 0 disables it", parseSlowMs, 1000).addOption(createConnectionSelectorOption()).option("--yes", "Skip the confirmation shown before an ordinary write; statements that are not limited to specific rows ignore it", false).option("--recovery", "On failure, emit a structured recovery envelope to stdout (suppresses human stderr message)", false).action(async (sql, options, command) => {
     const rawArgs = command.parent?.rawArgs ?? [];
     const rawTruncate = findLongOptionValue(rawArgs, "--truncate");
     const rootUse = command.parent?.opts().use;
@@ -23401,8 +23847,8 @@ function applyBlacklistRules(facts, blacklist, factors) {
 }
 function findBlacklistedColumnsForTable(blacklist, table) {
   const columns = blacklist.columns ?? {};
-  for (const [tableName, columnNames] of Object.entries(columns)) {
-    if (tableName.toLowerCase() === table.toLowerCase()) {
+  for (const [tableName2, columnNames] of Object.entries(columns)) {
+    if (tableName2.toLowerCase() === table.toLowerCase()) {
       return new Set(columnNames);
     }
   }
@@ -25366,12 +25812,12 @@ class DataExecutor {
     this.dbSystem = dbSystem;
     this.blacklistValidator = blacklistValidator;
   }
-  buildInsertSql(tableName, data, schema) {
+  buildInsertSql(tableName2, data, schema) {
     const columnNames = schema.columns.map((col) => col.name);
     const dataKeys = Object.keys(data);
     for (const key of dataKeys) {
       if (!columnNames.includes(key)) {
-        throw new Error(`Column "${key}" not found in table "${tableName}". Valid columns: ${columnNames.join(", ")}`);
+        throw new Error(`Column "${key}" not found in table "${tableName2}". Valid columns: ${columnNames.join(", ")}`);
       }
     }
     const columns = dataKeys;
@@ -25379,38 +25825,38 @@ class DataExecutor {
     const systemType = this.getSystemType();
     const placeholders = systemType === "postgresql" ? dataKeys.map((_, index) => `$${index + 1}`).join(", ") : dataKeys.map(() => "?").join(", ");
     const quote = this.getQuoteChar();
-    const sql = `INSERT INTO ${quote}${tableName}${quote} (${columns.map((col) => `${quote}${col}${quote}`).join(", ")}) VALUES (${placeholders})`;
+    const sql = `INSERT INTO ${quote}${tableName2}${quote} (${columns.map((col) => `${quote}${col}${quote}`).join(", ")}) VALUES (${placeholders})`;
     return {
       sql,
       params: values
     };
   }
-  async executeInsert(tableName, data, schema, options) {
+  async executeInsert(tableName2, data, schema, options) {
     const timestamp = new Date().toISOString();
     try {
-      this.checkBlacklist("INSERT", tableName);
+      this.checkBlacklist("INSERT", tableName2);
       enforcePermissionForType("INSERT", this.permission);
-      return await this.executeMutation("insert", this.buildInsertSql(tableName, data, schema), timestamp, options, { destructive: false });
+      return await this.executeMutation("insert", this.buildInsertSql(tableName2, data, schema), timestamp, options, { destructive: false });
     } catch (error) {
       return this.handleMutationError("insert", timestamp, error);
     }
   }
-  async executeUpdate(tableName, data, where, schema, options) {
+  async executeUpdate(tableName2, data, where, schema, options) {
     const timestamp = new Date().toISOString();
     try {
-      this.checkBlacklist("UPDATE", tableName);
+      this.checkBlacklist("UPDATE", tableName2);
       enforcePermissionForType("UPDATE", this.permission);
-      return await this.executeMutation("update", this.buildUpdateSql(tableName, data, where, schema), timestamp, options, { destructive: false });
+      return await this.executeMutation("update", this.buildUpdateSql(tableName2, data, where, schema), timestamp, options, { destructive: false });
     } catch (error) {
       return this.handleMutationError("update", timestamp, error);
     }
   }
-  async executeDelete(tableName, where, schema, options) {
+  async executeDelete(tableName2, where, schema, options) {
     const timestamp = new Date().toISOString();
     try {
-      this.checkBlacklist("DELETE", tableName);
+      this.checkBlacklist("DELETE", tableName2);
       enforcePermissionForType("DELETE", this.permission);
-      return await this.executeMutation("delete", this.buildDeleteSql(tableName, where, schema), timestamp, options, { destructive: true });
+      return await this.executeMutation("delete", this.buildDeleteSql(tableName2, where, schema), timestamp, options, { destructive: true });
     } catch (error) {
       return this.handleMutationError("delete", timestamp, error);
     }
@@ -25421,8 +25867,8 @@ class DataExecutor {
   getQuoteChar() {
     return this.dbSystem === "mysql" ? "`" : '"';
   }
-  checkBlacklist(operation, tableName) {
-    this.blacklistValidator?.checkTableBlacklist(operation, tableName, []);
+  checkBlacklist(operation, tableName2) {
+    this.blacklistValidator?.checkTableBlacklist(operation, tableName2, []);
   }
   async executeMutation(operation, statement, timestamp, options, { destructive }) {
     if (options?.dryRun) {
@@ -25477,13 +25923,13 @@ class DataExecutor {
       error: `${operation.toUpperCase()} failed: ${errorMessage2}`
     };
   }
-  buildUpdateSql(tableName, data, where, schema) {
+  buildUpdateSql(tableName2, data, where, schema) {
     const dataKeys = Object.keys(data);
     const whereKeys = Object.keys(where);
     const columnNames = schema.columns.map((col) => col.name);
     for (const key of [...dataKeys, ...whereKeys]) {
       if (!columnNames.includes(key)) {
-        throw new Error(`Column "${key}" not found in table "${tableName}"`);
+        throw new Error(`Column "${key}" not found in table "${tableName2}"`);
       }
     }
     const systemType = this.getSystemType();
@@ -25497,16 +25943,16 @@ class DataExecutor {
       const placeholder = systemType === "postgresql" ? `$${paramIndex++}` : "?";
       return `${quote}${key}${quote} = ${placeholder}`;
     }).join(" AND ");
-    const sql = `UPDATE ${quote}${tableName}${quote} SET ${setClause} WHERE ${whereClause}`;
+    const sql = `UPDATE ${quote}${tableName2}${quote} SET ${setClause} WHERE ${whereClause}`;
     const params = [...dataKeys.map((key) => data[key]), ...whereKeys.map((key) => where[key])];
     return { sql, params };
   }
-  buildDeleteSql(tableName, where, schema) {
+  buildDeleteSql(tableName2, where, schema) {
     const whereKeys = Object.keys(where);
     const columnNames = schema.columns.map((col) => col.name);
     for (const key of whereKeys) {
       if (!columnNames.includes(key)) {
-        throw new Error(`Column "${key}" not found in table "${tableName}"`);
+        throw new Error(`Column "${key}" not found in table "${tableName2}"`);
       }
     }
     const systemType = this.getSystemType();
@@ -25516,7 +25962,7 @@ class DataExecutor {
       const placeholder = systemType === "postgresql" ? `$${paramIndex++}` : "?";
       return `${quote}${key}${quote} = ${placeholder}`;
     }).join(" AND ");
-    const sql = `DELETE FROM ${quote}${tableName}${quote} WHERE ${whereClause}`;
+    const sql = `DELETE FROM ${quote}${tableName2}${quote} WHERE ${whereClause}`;
     const params = whereKeys.map((key) => where[key]);
     return { sql, params };
   }
@@ -25590,87 +26036,6 @@ function auditOutcomeForMutation(result, table, recoveryRef) {
   };
 }
 
-// src/commands/mutation-outcome.ts
-function shouldRenderForHuman(context) {
-  if (context.format === "json")
-    return false;
-  return context.isTTY;
-}
-function humanOutputContext(options) {
-  return { isTTY: process.stdout.isTTY === true, ...options.format && { format: options.format } };
-}
-function renderMutationOutcome(result, table, elapsedMs) {
-  if (result.status === "error") {
-    return [
-      t_vars("ceremony.failed", { reason: result.error ?? t("ceremony.unknown_error") }),
-      t("ceremony.recovery_retry")
-    ];
-  }
-  if (result.status === "cancelled") {
-    return [t_vars("ceremony.cancelled", { table })];
-  }
-  if (result.status === "dry_run") {
-    return [t_vars("ceremony.dry_run", { table })];
-  }
-  const elapsed = t_vars("ceremony.elapsed", { seconds: (elapsedMs / 1000).toFixed(2) });
-  if (result.rows_affected === 0) {
-    return [t_vars("ceremony.matched_nothing", { table }), elapsed];
-  }
-  return [
-    t_vars(VERB_KEY[result.operation], { count: result.rows_affected, table }),
-    elapsed,
-    t("ceremony.recovery_none")
-  ];
-}
-function printMutationOutcome(result, table, elapsedMs, context, envelopeExtras = {}) {
-  if (shouldRenderForHuman(context)) {
-    const writeLine = result.status === "error" ? console.error : console.log;
-    for (const line of renderMutationOutcome(result, table, elapsedMs))
-      writeLine(line);
-    return;
-  }
-  console.log(JSON.stringify({ ...mutationEnvelope(result), ...envelopeExtras }, null, 2));
-}
-function printMutationFailure(error, operation, context) {
-  if (shouldRenderForHuman(context)) {
-    console.error(t_vars("ceremony.failed", { reason: error.message }));
-    if (error instanceof BlacklistError) {
-      console.error(t("ceremony.blacklist_hint"));
-    }
-    return;
-  }
-  console.log(JSON.stringify({ status: "error", operation, rows_affected: 0, error: error.message }, null, 2));
-}
-function cancelledOutcome(operation, preview) {
-  return {
-    status: "cancelled",
-    operation,
-    rows_affected: 0,
-    sql: preview,
-    timestamp: new Date().toISOString()
-  };
-}
-function mutationEnvelope(result) {
-  return {
-    status: result.status,
-    operation: result.operation,
-    rows_affected: result.rows_affected,
-    ...result.timestamp && { timestamp: result.timestamp },
-    ...result.sql && { sql: result.sql },
-    ...result.error && { error: result.error }
-  };
-}
-var VERB_KEY;
-var init_mutation_outcome = __esm(() => {
-  init_message_loader();
-  init_blacklist();
-  VERB_KEY = {
-    insert: "ceremony.inserted",
-    update: "ceremony.updated",
-    delete: "ceremony.deleted"
-  };
-});
-
 // src/core/mongo/dry-run-formatter.ts
 function pretty(value) {
   return JSON.stringify(value, null, INDENT);
@@ -26974,6 +27339,20 @@ async function updateCommand(table, options, command) {
     await adapter.connect();
     try {
       const schema = await adapter.getTableSchema(table);
+      const { guardStructuredWrite: guardStructuredWrite2 } = await Promise.resolve().then(() => (init_write_gate_guard(), exports_write_gate_guard));
+      if (options.dryRun !== true && !await guardStructuredWrite2({
+        operation: "update",
+        table,
+        where: whereConditions,
+        schema,
+        config,
+        options
+      })) {
+        const cancelled = cancelledOutcome("update", `UPDATE ${table}`);
+        printMutationOutcome(cancelled, table, 0, humanOutputContext(options));
+        await writeAuditEntry(config, "update", options, auditOutcomeForMutation(cancelled, table));
+        return;
+      }
       const dbSystem = config.connection.system === "postgresql" ? "postgresql" : "mysql";
       const blacklistManager = new BlacklistManager(config);
       const blacklistValidator = new BlacklistValidator(blacklistManager);
@@ -26999,6 +27378,11 @@ async function updateCommand(table, options, command) {
       await adapter.disconnect();
     }
   } catch (error) {
+    const { WriteGateRefusal: WriteGateRefusal2 } = await Promise.resolve().then(() => (init_write_gate_prompt(), exports_write_gate_prompt));
+    if (error instanceof WriteGateRefusal2) {
+      printMutationFailure(error, "update", humanOutputContext(options));
+      process.exit(1);
+    }
     let auditId = null;
     let envelopeId;
     if (options.recovery === true) {
@@ -27254,6 +27638,20 @@ async function deleteCommand(table, options, command) {
     await adapter.connect();
     try {
       const schema = await adapter.getTableSchema(table);
+      const { guardStructuredWrite: guardStructuredWrite2 } = await Promise.resolve().then(() => (init_write_gate_guard(), exports_write_gate_guard));
+      if (options.dryRun !== true && !await guardStructuredWrite2({
+        operation: "delete",
+        table,
+        where: whereConditions,
+        schema,
+        config,
+        options
+      })) {
+        const cancelled = cancelledOutcome("delete", `DELETE FROM ${table}`);
+        printMutationOutcome(cancelled, table, 0, humanOutputContext(options));
+        await writeAuditEntry(config, "delete", options, auditOutcomeForMutation(cancelled, table));
+        return;
+      }
       const dbSystem = config.connection.system === "postgresql" ? "postgresql" : "mysql";
       const blacklistManager = new BlacklistManager(config);
       const blacklistValidator = new BlacklistValidator(blacklistManager);
@@ -27279,6 +27677,11 @@ async function deleteCommand(table, options, command) {
       await adapter.disconnect();
     }
   } catch (error) {
+    const { WriteGateRefusal: WriteGateRefusal2 } = await Promise.resolve().then(() => (init_write_gate_prompt(), exports_write_gate_prompt));
+    if (error instanceof WriteGateRefusal2) {
+      printMutationFailure(error, "delete", humanOutputContext(options));
+      process.exit(1);
+    }
     let auditId = null;
     let envelopeId;
     if (options.recovery === true) {
@@ -27777,16 +28180,6 @@ var init_export = __esm(() => {
   SQL_PATTERN = /^\s*(SELECT|INSERT|UPDATE|DELETE|CREATE|DROP|ALTER|SHOW|DESCRIBE)\b/i;
 });
 
-// src/core/sql-parser.ts
-function sqlParser() {
-  if (!cached2) {
-    const { Parser } = __require("node-sql-parser");
-    cached2 = new Parser;
-  }
-  return cached2;
-}
-var cached2 = null;
-
 // src/core/explain/read-only.ts
 function containsAnalyzeUnsafeNode(node) {
   if (!node || typeof node !== "object")
@@ -28891,12 +29284,12 @@ function compactVisibleSchema(config) {
   const blacklistManager = new BlacklistManager(config);
   const compactSchema = {};
   const rawSchema = config.schema ?? {};
-  for (const [tableName, tableSchema] of Object.entries(rawSchema)) {
-    if (blacklistManager.isTableBlacklisted(tableName))
+  for (const [tableName2, tableSchema] of Object.entries(rawSchema)) {
+    if (blacklistManager.isTableBlacklisted(tableName2))
       continue;
     const columns = [];
     for (const col of tableSchema.columns || []) {
-      if (blacklistManager.isColumnBlacklisted(tableName, col.name))
+      if (blacklistManager.isColumnBlacklisted(tableName2, col.name))
         continue;
       const compactCol = {
         name: col.name,
@@ -28916,7 +29309,7 @@ function compactVisibleSchema(config) {
       columns.push(compactCol);
     }
     const compactTable = {
-      name: tableSchema.name || tableName,
+      name: tableSchema.name || tableName2,
       columns
     };
     const rowCount = tableSchema.estimatedRowCount ?? tableSchema.rowCount;
@@ -28932,7 +29325,7 @@ function compactVisibleSchema(config) {
         refColumns: fk.refColumns
       }));
     }
-    compactSchema[tableName] = compactTable;
+    compactSchema[tableName2] = compactTable;
   }
   return compactSchema;
 }
@@ -29040,10 +29433,10 @@ function serializeXml(payload) {
   }
   if (Object.keys(payload.schema).length > 0) {
     parts.push("  <tables>");
-    for (const [tableName, table] of Object.entries(payload.schema)) {
+    for (const [tableName2, table] of Object.entries(payload.schema)) {
       const rowsAttr = table.rowCount !== undefined ? ` rows="${table.rowCount}"` : "";
       const pkAttr = table.primaryKey ? ` primary_key="${table.primaryKey.join(",")}"` : "";
-      parts.push(`    <table name="${escapeXml(tableName)}"${rowsAttr}${pkAttr}>`);
+      parts.push(`    <table name="${escapeXml(tableName2)}"${rowsAttr}${pkAttr}>`);
       for (const col of table.columns) {
         const pk = col.primaryKey ? ' primary_key="true"' : "";
         const nulls = col.nullable ? ' nullable="true"' : ' nullable="false"';
@@ -29154,9 +29547,9 @@ function serializeMarkdown(payload) {
     parts.push(`*No table schemas cached or active.*`);
     parts.push(``);
   } else {
-    for (const [tableName, table] of Object.entries(payload.schema)) {
+    for (const [tableName2, table] of Object.entries(payload.schema)) {
       const rows = table.rowCount !== undefined ? ` (~${table.rowCount.toLocaleString()} rows)` : "";
-      parts.push(`### \`${tableName}\`${rows}`);
+      parts.push(`### \`${tableName2}\`${rows}`);
       parts.push(``);
       parts.push(`| Column | Type | Nullable | Primary Key | Default | References |`);
       parts.push(`| :--- | :--- | :---: | :---: | :--- | :--- |`);
@@ -30289,37 +30682,37 @@ async function blacklistList(configPath, format = "text") {
     console.error(`\u26A0  blacklist.columns["${w2.collection}"]: '${w2.raw}' is ignored on mongo connections (${w2.reason}).`);
   }
 }
-async function blacklistTableAdd(tableName, configPath) {
-  if (!isValidTableName(tableName)) {
-    throw new Error(t_vars("errors.invalid_table_name", { table: tableName }));
+async function blacklistTableAdd(tableName2, configPath) {
+  if (!isValidTableName(tableName2)) {
+    throw new Error(t_vars("errors.invalid_table_name", { table: tableName2 }));
   }
   const config = await configModule.read(configPath);
   const blacklist = getOrInitBlacklist(config);
-  if (blacklist.tables.includes(tableName)) {
-    throw new Error(t_vars("errors.table_already_blacklisted", { table: tableName }));
+  if (blacklist.tables.includes(tableName2)) {
+    throw new Error(t_vars("errors.table_already_blacklisted", { table: tableName2 }));
   }
   const newBlacklist = {
     ...blacklist,
-    tables: [...blacklist.tables, tableName]
+    tables: [...blacklist.tables, tableName2]
   };
   await configModule.write(configPath, { ...config, blacklist: newBlacklist });
-  console.log(t_vars("blacklist.table_added", { table: tableName }));
+  console.log(t_vars("blacklist.table_added", { table: tableName2 }));
 }
-async function blacklistTableRemove(tableName, configPath) {
-  if (!isValidTableName(tableName)) {
-    throw new Error(t_vars("errors.invalid_table_name", { table: tableName }));
+async function blacklistTableRemove(tableName2, configPath) {
+  if (!isValidTableName(tableName2)) {
+    throw new Error(t_vars("errors.invalid_table_name", { table: tableName2 }));
   }
   const config = await configModule.read(configPath);
   const blacklist = getOrInitBlacklist(config);
-  if (!blacklist.tables.includes(tableName)) {
-    throw new Error(t_vars("errors.table_not_in_blacklist", { table: tableName }));
+  if (!blacklist.tables.includes(tableName2)) {
+    throw new Error(t_vars("errors.table_not_in_blacklist", { table: tableName2 }));
   }
   const newBlacklist = {
     ...blacklist,
-    tables: blacklist.tables.filter((t2) => t2 !== tableName)
+    tables: blacklist.tables.filter((t2) => t2 !== tableName2)
   };
   await configModule.write(configPath, { ...config, blacklist: newBlacklist });
-  console.log(t_vars("blacklist.table_removed", { table: tableName }));
+  console.log(t_vars("blacklist.table_removed", { table: tableName2 }));
 }
 async function blacklistColumnAdd(identifier, configPath) {
   const parsed = parseColumnIdentifier(identifier);
@@ -30389,17 +30782,17 @@ var init_blacklist2 = __esm(() => {
     }
   });
   tableCmd = blacklistCommand.command("table").description(t("blacklist.tables_label"));
-  tableCmd.command("add <table>").description("Add table to blacklist").option("--config <path>", "Path to .dbcli config file", DEFAULT_CONFIG_PATH).action(async (tableName, options) => {
+  tableCmd.command("add <table>").description("Add table to blacklist").option("--config <path>", "Path to .dbcli config file", DEFAULT_CONFIG_PATH).action(async (tableName2, options) => {
     try {
-      await blacklistTableAdd(tableName, options.config || DEFAULT_CONFIG_PATH);
+      await blacklistTableAdd(tableName2, options.config || DEFAULT_CONFIG_PATH);
     } catch (error) {
       console.error(error.message);
       process.exit(1);
     }
   });
-  tableCmd.command("remove <table>").description("Remove table from blacklist").option("--config <path>", "Path to .dbcli config file", DEFAULT_CONFIG_PATH).action(async (tableName, options) => {
+  tableCmd.command("remove <table>").description("Remove table from blacklist").option("--config <path>", "Path to .dbcli config file", DEFAULT_CONFIG_PATH).action(async (tableName2, options) => {
     try {
-      await blacklistTableRemove(tableName, options.config || DEFAULT_CONFIG_PATH);
+      await blacklistTableRemove(tableName2, options.config || DEFAULT_CONFIG_PATH);
     } catch (error) {
       console.error(error.message);
       process.exit(1);
@@ -31033,7 +31426,7 @@ function consumeCreateTable(node, statement, context) {
     return;
   }
   const identity = resolveTableIdentifier(parsedIdentifier);
-  const tableName = qualifiedTableName(identity);
+  const tableName2 = qualifiedTableName(identity);
   const unsupportedTableField = firstMeaningfulUnsupportedField(node, [
     "type",
     "keyword",
@@ -31043,14 +31436,14 @@ function consumeCreateTable(node, statement, context) {
   ]);
   if (unsupportedTableField) {
     context.unparsed.push({
-      location: tableName,
+      location: tableName2,
       reason: `blocked: unsupported CREATE TABLE ${unsupportedTableField}`
     });
     return;
   }
   if (!Array.isArray(node.create_definitions)) {
     context.unparsed.push({
-      location: tableName,
+      location: tableName2,
       reason: "blocked: unsupported CREATE TABLE without column definitions"
     });
     return;
@@ -31065,7 +31458,7 @@ function consumeCreateTable(node, statement, context) {
   const definitions = [];
   for (const value of node.create_definitions) {
     if (!isAst(value)) {
-      pushUnsupportedDefinition(tableName, "malformed", context.unparsed);
+      pushUnsupportedDefinition(tableName2, "malformed", context.unparsed);
       continue;
     }
     definitions.push(value);
@@ -31091,14 +31484,14 @@ function consumeCreateTable(node, statement, context) {
       consumeTablePrimaryKey(definition, table, context.unparsed);
       continue;
     }
-    pushUnsupportedDefinition(tableName, stringValue2(definition.constraint_type) ?? stringValue2(definition.resource) ?? "malformed", context.unparsed);
+    pushUnsupportedDefinition(tableName2, stringValue2(definition.constraint_type) ?? stringValue2(definition.resource) ?? "malformed", context.unparsed);
   }
   const key = tableIdentityKey(identity);
   if (context.tablesByIdentity.has(key)) {
-    context.duplicateTableIdentity ??= tableName;
+    context.duplicateTableIdentity ??= tableName2;
     context.unparsed.push({
-      location: tableName,
-      reason: `blocked: duplicate table identity '${tableName}'`
+      location: tableName2,
+      reason: `blocked: duplicate table identity '${tableName2}'`
     });
     return;
   }
@@ -31241,12 +31634,12 @@ function consumeCreateIndex(node, statement, context) {
     return;
   }
   const identity = resolveTableIdentifier(parsedIdentifier);
-  const tableName = qualifiedTableName(identity);
+  const tableName2 = qualifiedTableName(identity);
   const target = context.tablesByIdentity.get(tableIdentityKey(identity));
   if (!target) {
     context.unparsed.push({
       location: indexName ?? "index",
-      reason: `blocked: CREATE INDEX targets unknown table '${tableName}'`
+      reason: `blocked: CREATE INDEX targets unknown table '${tableName2}'`
     });
     return;
   }
@@ -31279,7 +31672,7 @@ function consumeCreateIndex(node, statement, context) {
   }
   if (columns.value.length === 0) {
     context.unparsed.push({
-      location: indexName ?? `${tableName} index`,
+      location: indexName ?? `${tableName2} index`,
       reason: "blocked: malformed CREATE INDEX without columns"
     });
     return;
@@ -31727,9 +32120,9 @@ function firstMeaningfulUnsupportedField(value, allowed) {
   }
   return null;
 }
-function pushUnsupportedDefinition(tableName, definition, unparsed) {
+function pushUnsupportedDefinition(tableName2, definition, unparsed) {
   unparsed.push({
-    location: `${tableName} (${definition})`,
+    location: `${tableName2} (${definition})`,
     reason: `blocked: unsupported table definition '${definition}'`
   });
 }
@@ -31855,7 +32248,7 @@ function collectBlocks(text3, unparsed) {
 function parseModel2(block, unparsed) {
   const fields = [];
   const pendingIndexes = [];
-  let tableName = block.name;
+  let tableName2 = block.name;
   let hasTableMap = false;
   for (const sourceLine of block.lines) {
     const line = stripLineComment(sourceLine.text).trim();
@@ -31874,7 +32267,7 @@ function parseModel2(block, unparsed) {
           addBlocked2(unparsed, block.name, `malformed or duplicate '@@map' attribute`);
           continue;
         }
-        tableName = mapped;
+        tableName2 = mapped;
         hasTableMap = true;
         continue;
       }
@@ -31900,12 +32293,12 @@ function parseModel2(block, unparsed) {
   }
   return {
     name: block.name,
-    tableName,
+    tableName: tableName2,
     fields,
     pendingIndexes,
     pendingRelations: [],
     columnNames: new Map,
-    table: { identity: { table: tableName }, columns: [], indexes: [], foreignKeys: [] }
+    table: { identity: { table: tableName2 }, columns: [], indexes: [], foreignKeys: [] }
   };
 }
 function parseField2(line, modelName, lineNumber, unparsed) {
@@ -32964,31 +33357,31 @@ function compareSnapshots(before, after) {
   const removedColumns = [];
   const modifiedColumns = [];
   const indexChanges = [];
-  for (const tableName of addedTables) {
-    const added = after.tables[tableName];
+  for (const tableName2 of addedTables) {
+    const added = after.tables[tableName2];
     if (!added)
       continue;
     for (const col of added.columns) {
       addedColumns.push({
-        table: tableName,
+        table: tableName2,
         column: col.name,
         type: col.type,
         nullable: col.nullable
       });
     }
   }
-  for (const tableName of removedTables) {
-    const removed = before.tables[tableName];
+  for (const tableName2 of removedTables) {
+    const removed = before.tables[tableName2];
     if (!removed)
       continue;
     for (const col of removed.columns) {
-      removedColumns.push({ table: tableName, column: col.name, type: col.type });
+      removedColumns.push({ table: tableName2, column: col.name, type: col.type });
     }
   }
   const commonTables = Array.from(afterTables).filter((t2) => beforeTables.has(t2));
-  for (const tableName of commonTables) {
-    const beforeTable = before.tables[tableName];
-    const afterTable = after.tables[tableName];
+  for (const tableName2 of commonTables) {
+    const beforeTable = before.tables[tableName2];
+    const afterTable = after.tables[tableName2];
     if (!beforeTable || !afterTable)
       continue;
     const beforeColMap = new Map(beforeTable.columns.map((c) => [c.name, c]));
@@ -32996,7 +33389,7 @@ function compareSnapshots(before, after) {
     for (const [name, col] of afterColMap) {
       if (!beforeColMap.has(name)) {
         addedColumns.push({
-          table: tableName,
+          table: tableName2,
           column: name,
           type: col.type,
           nullable: col.nullable
@@ -33005,7 +33398,7 @@ function compareSnapshots(before, after) {
     }
     for (const [name, col] of beforeColMap) {
       if (!afterColMap.has(name)) {
-        removedColumns.push({ table: tableName, column: name, type: col.type });
+        removedColumns.push({ table: tableName2, column: name, type: col.type });
       }
     }
     for (const [name, afterCol] of afterColMap) {
@@ -33014,7 +33407,7 @@ function compareSnapshots(before, after) {
         continue;
       if (beforeCol.type.toLowerCase() !== afterCol.type.toLowerCase() || beforeCol.nullable !== afterCol.nullable) {
         modifiedColumns.push({
-          table: tableName,
+          table: tableName2,
           column: name,
           before: { type: beforeCol.type, nullable: beforeCol.nullable },
           after: { type: afterCol.type, nullable: afterCol.nullable }
@@ -33025,12 +33418,12 @@ function compareSnapshots(before, after) {
     const afterIndexes = new Map((afterTable.indexes || []).map((i) => [i.name, i]));
     for (const name of afterIndexes.keys()) {
       if (!beforeIndexes.has(name)) {
-        indexChanges.push({ table: tableName, name, change: "added" });
+        indexChanges.push({ table: tableName2, name, change: "added" });
       }
     }
     for (const name of beforeIndexes.keys()) {
       if (!afterIndexes.has(name)) {
-        indexChanges.push({ table: tableName, name, change: "removed" });
+        indexChanges.push({ table: tableName2, name, change: "removed" });
       }
     }
   }
@@ -38623,10 +39016,10 @@ async function loadSchemaContext(dbcliPath, connectionName) {
   const loader3 = new SchemaLayeredLoader(dbcliPath, { connectionName });
   const { cache, index } = await loader3.initialize();
   const schema = {};
-  for (const tableName of Object.keys(index?.tables ?? {})) {
-    const table = await cache.getTableSchema(tableName);
+  for (const tableName2 of Object.keys(index?.tables ?? {})) {
+    const table = await cache.getTableSchema(tableName2);
     if (table) {
-      schema[tableName] = table;
+      schema[tableName2] = table;
     }
   }
   return buildSchemaContext(schema);
@@ -40062,9 +40455,9 @@ var init_select_star = __esm(() => {
         span: findingSpan(ctx.sql, "select *"),
         schemaVerified: false
       };
-      const tableName = singlePhysicalTable(ctx.ast);
-      if (ctx.schema.available && tableName && isSoleUnqualifiedStar(ctx.ast)) {
-        const table = ctx.schema.getTable(tableName);
+      const tableName2 = singlePhysicalTable(ctx.ast);
+      if (ctx.schema.available && tableName2 && isSoleUnqualifiedStar(ctx.ast)) {
+        const table = ctx.schema.getTable(tableName2);
         if (table && table.columns.length > 0) {
           if (wildcardIndexes.length === 1) {
             const wildcardIndex = wildcardIndexes[0];
@@ -40973,17 +41366,17 @@ function canonicalizeEvidenceReceiptCommand(command, operation = "assert") {
 function sha2563(value) {
   return `sha256:${createHash5("sha256").update(value).digest("hex")}`;
 }
-function verdictFingerprint(verdict) {
-  if (!record3(verdict) || typeof verdict.pass !== "boolean" || !Array.isArray(verdict.checks) || verdict.checks.length > 1000) {
+function verdictFingerprint(verdict2) {
+  if (!record3(verdict2) || typeof verdict2.pass !== "boolean" || !Array.isArray(verdict2.checks) || verdict2.checks.length > 1000) {
     throw new EvidenceReceiptValidationError("verdict must contain bounded pass bits");
   }
-  const bits = verdict.checks.map((check) => {
+  const bits = verdict2.checks.map((check) => {
     if (!record3(check) || Object.keys(check).some((key) => key !== "pass") || typeof check.pass !== "boolean") {
       throw new EvidenceReceiptValidationError("verdict checks must contain only pass bits");
     }
     return check.pass;
   });
-  return sha2563(JSON.stringify({ pass: verdict.pass, checks: bits }));
+  return sha2563(JSON.stringify({ pass: verdict2.pass, checks: bits }));
 }
 function verificationOutcomeFingerprint(status2, artifactPersisted) {
   if (!isVerificationStatus(status2)) {
@@ -41281,7 +41674,7 @@ var init_assert = __esm(() => {
       const adapter = AdapterFactory.createSqlAdapter(requireSqlConnection11(config.connection));
       await adapter.connect();
       let auditRef = null;
-      let verdict;
+      let verdict2;
       try {
         const blacklistManager = new BlacklistManager(config);
         const blacklistValidator = new BlacklistValidator(blacklistManager);
@@ -41308,9 +41701,9 @@ var init_assert = __esm(() => {
           });
           checks.push(...compareAgainst(current, baseline, options.tolerance));
         }
-        verdict = { pass: checks.every((c) => c.pass), checks };
+        verdict2 = { pass: checks.every((c) => c.pass), checks };
         auditRef = await writeAuditEntry(config, "assert", options, {
-          success: verdict.pass,
+          success: verdict2.pass,
           sql: query
         });
       } finally {
@@ -41320,7 +41713,7 @@ var init_assert = __esm(() => {
       if (options.writeVerificationArtifact === true && verificationSubject) {
         try {
           const artifact2 = buildAssertVerificationArtifact({
-            verdict,
+            verdict: verdict2,
             subject: verificationSubject,
             summary: options.verificationSummary,
             argv: process.argv,
@@ -41339,7 +41732,7 @@ var init_assert = __esm(() => {
             context: await buildEvidenceReceiptContext(config, process.cwd()),
             auditRef,
             verificationArtifactRef: verificationArtifactPath ? basename7(verificationArtifactPath) : null,
-            verdict
+            verdict: verdict2
           });
           evidenceReceiptPath = await writeEvidenceReceipt(process.cwd(), options.evidenceReceipt, receipt);
         } catch {
@@ -41349,23 +41742,23 @@ var init_assert = __esm(() => {
       }
       if (options.format === "json") {
         console.log(JSON.stringify({
-          ...verdict,
+          ...verdict2,
           ...verificationArtifactPath ? { verificationArtifactPath } : {},
           ...evidenceReceiptPath ? { evidenceReceiptPath } : {}
         }, null, 2));
       } else {
-        for (const c of verdict.checks) {
+        for (const c of verdict2.checks) {
           console.log(`${c.pass ? "PASS" : "FAIL"}  ${c.name}  expected=${c.expected} actual=${c.actual}`);
         }
         console.log(`
-Verdict: ${verdict.pass ? "PASS" : "FAIL"}`);
+Verdict: ${verdict2.pass ? "PASS" : "FAIL"}`);
         if (verificationArtifactPath) {
           console.log(`Verification artifact: ${verificationArtifactPath}`);
         }
         if (evidenceReceiptPath)
           console.log(`Evidence receipt: ${evidenceReceiptPath}`);
       }
-      process.exit(verdict.pass || options.fail === false ? 0 : 1);
+      process.exit(verdict2.pass || options.fail === false ? 0 : 1);
     } catch (error) {
       if (error instanceof Error) {
         console.error(error.message);
@@ -44399,9 +44792,9 @@ function createCompleter(ctx) {
       const sqlHits = matchWithSuffix([...SQL_KEYWORDS_FOR_COMPLETION], lastWord);
       const tableHits = matchWithSuffix(allTableNames, lastWord);
       const colHits = isColumnPosition(upperLine) ? (() => {
-        const tableName = extractTableFromLine(trimmed, allTableNames);
-        if (tableName && ctx.columnsByTable[tableName]) {
-          return matchWithSuffix([...ctx.columnsByTable[tableName]], lastWord);
+        const tableName2 = extractTableFromLine(trimmed, allTableNames);
+        if (tableName2 && ctx.columnsByTable[tableName2]) {
+          return matchWithSuffix([...ctx.columnsByTable[tableName2]], lastWord);
         }
         return matchWithSuffix(uniqueColumns, lastWord);
       })() : [[], lastWord];