@carllee1983/dbcli 2.0.0 → 3.0.0

package/dist/cli-runtime.mjs

@@ -51,7 +51,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@carllee1983/dbcli",
-    version: "2.0.0",
+    version: "3.0.0",
     description: "Database CLI for AI agents",
     type: "module",
     publishConfig: {
@@ -133,7 +133,9 @@ var init_package = __esm(() => {
       "platform:check": "bun run scripts/check-platform-parity.ts",
       "agent-core:check": "bun run scripts/check-agent-core-purity.ts",
       "core-stdout:check": "bun run scripts/check-core-no-stdout.ts",
+      "plan:check": "bun run scripts/check-plan-acceptance.ts",
       typecheck: "tsc --noEmit --pretty false",
+      "typecheck:tests": "tsc --noEmit --pretty false -p tsconfig.tests.json",
       "test:perf": "bun test ./tests/perf/*.bench.ts",
       lint: "eslint src tests scripts --ext .ts --max-warnings=0",
       "format:check": "prettier --check .",
@@ -8903,6 +8905,15 @@ var init_messages = __esm(() => {
       health: {
         description: "Show AuditLogger health snapshot (size, entries, lock state, last write)"
       },
+      write_gate: {
+        description: "Summarize tier-two write-gate decisions (ADR 0010's measurement)",
+        header: "Write-gate summary \u2014 connection: {conn}",
+        window: "Audit entries scanned: {scanned}, {from} \u2192 {to}",
+        decisions: "Tier-two evaluations: {count}, {from} \u2192 {to}",
+        tier_one: "Tier one, counted apart: {count} ({outcomes})",
+        no_decisions: "Tier two was never reached in this window. Per ADR 0010 that falsifies the criterion, not the gate: the shapes it looks for are not the shapes people write.",
+        no_entries: "The audit log is empty, so this says nothing about the gate either way. Run some writes, or check `dbcli audit health`."
+      },
       disabled_hint: "Audit is disabled (audit.enabled = false in .dbcli). Use 'dbcli audit health' for details.",
       no_entries: "No audit entries.",
       show_no_match: "No audit entry matches '{prefix}'.",
@@ -9211,6 +9222,15 @@ var init_messages2 = __esm(() => {
       health: {
         description: "\u986F\u793A AuditLogger \u5065\u5EB7\u72C0\u614B\uFF08\u6A94\u6848\u5927\u5C0F\u3001\u7B46\u6578\u3001lock \u72C0\u614B\u3001\u6700\u5F8C\u5BEB\u5165\u7D50\u679C\uFF09"
       },
+      write_gate: {
+        description: "\u7D71\u8A08\u7B2C\u4E8C\u7D1A\u5BEB\u5165\u9598\u9580\u7684\u5224\u5B9A\uFF08ADR 0010 \u62BC\u6CE8\u7684\u90A3\u500B\u91CF\u6E2C\uFF09",
+        header: "\u5BEB\u5165\u9598\u9580\u6458\u8981 \u2014 \u9023\u7DDA\uFF1A{conn}",
+        window: "\u6383\u904E\u7684\u7A3D\u6838\u7D00\u9304\uFF1A{scanned} \u7B46\uFF0C{from} \u2192 {to}",
+        decisions: "\u7B2C\u4E8C\u7D1A\u5224\u5B9A\uFF1A{count} \u6B21\uFF0C{from} \u2192 {to}",
+        tier_one: "\u7B2C\u4E00\u7D1A\uFF0C\u5206\u958B\u8A08\u7B97\uFF1A{count} \u6B21\uFF08{outcomes}\uFF09",
+        no_decisions: "\u9019\u6BB5\u5340\u9593\u5167\u7B2C\u4E8C\u7D1A\u4E00\u6B21\u90FD\u6C92\u88AB\u89F8\u53CA\u3002\u4F9D ADR 0010\uFF0C\u9019\u63A8\u7FFB\u7684\u662F\u5224\u6E96\u800C\u4E0D\u662F\u9598\u9580\uFF1A\u5B83\u5728\u627E\u7684\u5F62\u72C0\u4E0D\u662F\u5927\u5BB6\u5BE6\u969B\u6703\u5BEB\u7684\u5F62\u72C0\u3002",
+        no_entries: "\u7A3D\u6838\u7D00\u9304\u662F\u7A7A\u7684\uFF0C\u6240\u4EE5\u9019\u5C0D\u9598\u9580\u6C92\u6709\u4EFB\u4F55\u7D50\u8AD6\u3002\u5148\u8DD1\u4E00\u4E9B\u5BEB\u5165\uFF0C\u6216\u7528 `dbcli audit health` \u6AA2\u67E5\u3002"
+      },
       disabled_hint: "Audit \u5DF2\u505C\u7528\uFF08.dbcli \u4E2D audit.enabled = false\uFF09\u3002\u57F7\u884C `dbcli audit health` \u67E5\u770B\u8A73\u60C5\u3002",
       no_entries: "\u6C92\u6709 audit \u7D00\u9304\u3002",
       show_no_match: "\u627E\u4E0D\u5230\u7B26\u5408 '{prefix}' \u7684 audit \u7D00\u9304\u3002",
@@ -9422,7 +9442,8 @@ var init_shell = __esm(() => {
     multiline_cancelled: "Multiline input cancelled.",
     timing_display: "Time: {ms}ms",
     rows_display: "{count} row(s)",
-    unknown_command: "Unknown command: '{command}'. Type '.help' for available commands."
+    unknown_command: "Unknown command: '{command}'. Type '.help' for available commands.",
+    subcommand_prefix_hint: "This line is being read as SQL and is waiting for its `;`. If you meant the dbcli subcommand, type {command} instead. Ctrl-C cancels."
   };
 });
 
@@ -9448,7 +9469,8 @@ var init_shell2 = __esm(() => {
     multiline_cancelled: "\u5DF2\u53D6\u6D88\u591A\u884C\u8F38\u5165\u3002",
     timing_display: "\u8017\u6642\uFF1A{ms}ms",
     rows_display: "{count} \u7B46\u8CC7\u6599",
-    unknown_command: "\u672A\u77E5\u6307\u4EE4\uFF1A'{command}'\u3002\u8F38\u5165 '.help' \u67E5\u770B\u53EF\u7528\u6307\u4EE4\u3002"
+    unknown_command: "\u672A\u77E5\u6307\u4EE4\uFF1A'{command}'\u3002\u8F38\u5165 '.help' \u67E5\u770B\u53EF\u7528\u6307\u4EE4\u3002",
+    subcommand_prefix_hint: "\u9019\u4E00\u884C\u88AB\u7576\u6210 SQL\uFF0C\u6B63\u5728\u7B49\u5206\u865F\u3002\u5982\u679C\u4F60\u8981\u7684\u662F dbcli \u5B50\u6307\u4EE4\uFF0C\u8ACB\u6539\u6253 {command}\u3002Ctrl-C \u53EF\u53D6\u6D88\u3002"
   };
 });
 
@@ -9482,14 +9504,20 @@ var init_ceremony = __esm(() => {
     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_multi_table_warning: "This write joins another table. How many rows of the target it touches depends on the data, not on the statement, so it cannot be checked before it runs.",
+    gate_nested_write_warning: "\u26A0\uFE0F  This statement carries a second write inside it, and dbcli will not read the tier of that write off this one.",
     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_refused_in_shell: "Refused: a dbcli subcommand started from the shell has no way to ask you, even though you are right here (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_multi_table: "Rewrite it as a single-table statement \u2014 move the other table into a subquery in the WHERE \u2014 or run it where someone can confirm it.",
+    gate_remedy_nested_write: "Run the nested write as its own statement, or run this one where someone can confirm it.",
     gate_remedy_non_unique_where: "Match on a primary key or a uniquely indexed column, or run it from an interactive terminal.",
+    gate_remedy_in_shell: "Type the statement at the dbcli> prompt instead \u2014 there the shell asks you to type the target table name.",
     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"
@@ -9526,14 +9554,20 @@ var init_ceremony2 = __esm(() => {
     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_multi_table_warning: "\u9019\u500B\u5BEB\u5165\u63A5\u4E86\u53E6\u4E00\u5F35\u8868\u3002\u5B83\u6703\u52D5\u5230\u76EE\u6A19\u8868\u5E7E\u5217\u53D6\u6C7A\u65BC\u8CC7\u6599\u800C\u4E0D\u662F\u8A9E\u53E5\u672C\u8EAB\uFF0C\u57F7\u884C\u524D\u7121\u6CD5\u6AA2\u67E5\u3002",
+    gate_nested_write_warning: "\u26A0\uFE0F  \u9019\u53E5\u88E1\u9762\u9084\u593E\u8457\u53E6\u4E00\u500B\u5BEB\u5165\uFF0Cdbcli \u4E0D\u6703\u62FF\u9019\u53E5\u7684\u5C64\u7D1A\u4EE3\u66FF\u90A3\u500B\u5BEB\u5165\u7684\u5C64\u7D1A\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_refused_in_shell: "\u5DF2\u62D2\u7D55\uFF1A\u5F9E shell \u555F\u52D5\u7684 dbcli \u5B50\u6307\u4EE4\u6C92\u6709\u8FA6\u6CD5\u5411\u4F60\u63D0\u554F\uFF0C\u5373\u4F7F\u4F60\u4EBA\u5C31\u5728\u9019\u88E1\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_multi_table: "\u6539\u5BEB\u6210\u55AE\u8868\u8A9E\u53E5\u2014\u2014\u628A\u53E6\u4E00\u5F35\u8868\u79FB\u9032 WHERE \u7684\u5B50\u67E5\u8A62\u88E1\u2014\u2014\u6216\u6539\u5728\u6709\u4EBA\u53EF\u4EE5\u78BA\u8A8D\u7684\u5730\u65B9\u57F7\u884C\u3002",
+    gate_remedy_nested_write: "\u628A\u88E1\u9762\u90A3\u500B\u5BEB\u5165\u62C6\u6210\u7368\u7ACB\u7684\u4E00\u53E5\u4F86\u57F7\u884C\uFF0C\u6216\u6539\u5728\u6709\u4EBA\u53EF\u4EE5\u78BA\u8A8D\u7684\u5730\u65B9\u57F7\u884C\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",
+    gate_remedy_in_shell: "\u8ACB\u76F4\u63A5\u5728 dbcli> \u63D0\u793A\u7B26\u6253\u9019\u53E5\u8A9E\u53E5\u2014\u2014\u5728\u90A3\u88E1 dbcli \u6703\u8ACB\u4F60\u6253\u51FA\u76EE\u6A19\u8CC7\u6599\u8868\u7684\u540D\u7A31\u4F86\u78BA\u8A8D\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"
@@ -18007,7 +18041,7 @@ async function writeAuditEntry(config, commandName, options, outcome) {
     const logger = await getAuditLogger(config, options.config || ".dbcli", connectionName);
     const engine = config.connection?.system || "postgresql";
     const target = outcome.target || getOperationTarget(engine, commandName, options, outcome.sql);
-    let tier = getEngineCapability(engine, commandName).tier;
+    let tier = outcome.sideEffectTier ?? getEngineCapability(engine, commandName).tier;
     if (options.dryRun || options.plan) {
       tier = "dry-run";
     }
@@ -18940,6 +18974,7 @@ __export(exports_permission_guard, {
   checkPermissionForClassification: () => checkPermissionForClassification,
   checkPermission: () => checkPermission,
   SQL_WRITE_OR_DDL_KEYWORDS: () => SQL_WRITE_OR_DDL_KEYWORDS,
+  SQL_LOCK_CLAUSE: () => SQL_LOCK_CLAUSE,
   SQL_DIALECTS: () => SQL_DIALECTS,
   PermissionError: () => PermissionError
 });
@@ -22358,7 +22393,8 @@ 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);
+    const inShell = process.env.DBCLI_SHELL_SUBCOMMAND === "1";
+    throw new WriteGateRefusal(inShell ? `${t_vars("ceremony.gate_refused_in_shell", { reason })} ${t("ceremony.gate_remedy_in_shell")}` : `${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 ?? "" });
@@ -22366,7 +22402,13 @@ async function enforceTierTwo(request, attended) {
 ${warning}
 ${t(REMEDY_KEY[reason])}
 `);
-  const typed = await promptUser.text(t_vars("ceremony.gate_typed_prompt", { phrase: verdict.confirmationPhrase }));
+  const ask = request.ask ?? promptUser.text;
+  const typed = await ask(t_vars("ceremony.gate_typed_prompt", { phrase: verdict.confirmationPhrase }));
+  if (typed === null) {
+    process.stderr.write(`${t("ceremony.gate_cancelled")}
+`);
+    return false;
+  }
   const matched = typed.trim().toLowerCase() === verdict.confirmationPhrase.toLowerCase();
   if (!matched) {
     process.stderr.write(`${t_vars("ceremony.gate_typed_mismatch", { phrase: verdict.confirmationPhrase })}
@@ -22404,14 +22446,18 @@ var init_write_gate_prompt = __esm(() => {
     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"
+    multiple_statements: "ceremony.gate_remedy_multiple_statements",
+    multi_table: "ceremony.gate_remedy_multi_table",
+    nested_write: "ceremony.gate_remedy_nested_write"
   };
   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"
+    multiple_statements: "ceremony.gate_multiple_statements_warning",
+    multi_table: "ceremony.gate_multi_table_warning",
+    nested_write: "ceremony.gate_nested_write_warning"
   };
 });
 
@@ -22446,6 +22492,12 @@ async function classifySqlWriteGate(sql, options = {}) {
   if (containsMultipleStatements(sql, dialect)) {
     return verdict("two", "multiple_statements", undefined, type);
   }
+  const nested = nestedWrite(sql, dialect);
+  if (nested)
+    return verdict("two", "nested_write", undefined, nested);
+  const merge = classifyMerge(sql, dialect);
+  if (merge)
+    return merge;
   if (type === "DROP" || type === "TRUNCATE") {
     const matched = DDL_TARGET.exec(sql)?.[1];
     const table = matched ? matched.replace(/[`"[\]]/g, "") : undefined;
@@ -22464,20 +22516,139 @@ async function classifyQualification(sql, dialect, type) {
     return unparseable(sql, dialect, type);
   }
   const statement = Array.isArray(ast) ? ast[0] : ast;
-  if (!statement)
+  if (!statement || statement.type !== "update" && statement.type !== "delete") {
     return unparseable(sql, dialect, type);
-  const table = tableName(statement.from?.[0] ?? statement.table?.[0]);
-  if (statement.where != null || statement.limit != null) {
+  }
+  const scope = [...statement.table ?? [], ...statement.from ?? []];
+  const sources = new Set(scope.map((ref, index) => refIdentity(ref) ?? `#unnamed-${index}`));
+  if (sources.size > 1) {
+    return verdict("two", "multi_table", undefined, type);
+  }
+  const target = normaliseRef(statement.table?.[0] ?? scope[0]);
+  const table = tableName(target);
+  if (statement.limit != null)
+    return verdict("one", undefined, table, type);
+  if (statement.where != null && narrowsTarget(statement.where, refNames(target))) {
     return verdict("one", undefined, table, type);
   }
   return verdict("two", "no_where", table, type);
 }
+function normaliseRef(ref) {
+  if (ref?.table?.toUpperCase() !== "ONLY")
+    return ref;
+  if (typeof ref.as !== "string" || ref.as.length === 0)
+    return ref;
+  return {
+    db: ref.db,
+    on: ref.on,
+    as: null,
+    table: typeof ref.as === "string" ? ref.as : undefined
+  };
+}
+function refIdentity(reference) {
+  const ref = normaliseRef(reference);
+  if (typeof ref?.table !== "string")
+    return;
+  return (ref.db ? `${ref.db}.${ref.table}` : ref.table).toLowerCase();
+}
+function refNames(reference) {
+  const ref = normaliseRef(reference);
+  const name = typeof ref?.as === "string" && ref.as.length > 0 ? ref.as : ref?.table;
+  return typeof name === "string" ? [name.toLowerCase()] : [];
+}
+function narrowsTarget(where, targetNames) {
+  const names = new Set(targetNames);
+  const { owners, correlated, skippedSubquery } = scanCondition(where);
+  if (owners.length === 0 && correlated.length === 0)
+    return !skippedSubquery;
+  return owners.some((owner) => owner === null || names.has(owner)) || correlated.some((owner) => names.has(owner));
+}
+function mergeScans(scans) {
+  return {
+    owners: scans.flatMap((scan) => scan.owners),
+    correlated: scans.flatMap((scan) => scan.correlated),
+    skippedSubquery: scans.some((scan) => scan.skippedSubquery)
+  };
+}
+function scanCondition(node, bound) {
+  if (node === null || typeof node !== "object")
+    return EMPTY_SCAN;
+  const record = node;
+  const inner = record.ast ?? (record.type === "select" ? record : undefined);
+  const nested = inner !== undefined;
+  if (record.type === "column_ref") {
+    const owner = record.table;
+    const name = owner == null ? null : String(owner).toLowerCase();
+    if (bound === undefined)
+      return { owners: [name], correlated: [], skippedSubquery: false };
+    if (name === null || bound.has(name))
+      return EMPTY_SCAN;
+    return { owners: [], correlated: [name], skippedSubquery: false };
+  }
+  const scope = nested ? new Set([...bound ?? [], ...boundNames(inner)]) : bound;
+  const scans = Object.values(record).map((value) => Array.isArray(value) ? mergeScans(value.map((item) => scanCondition(item, scope))) : scanCondition(value, scope));
+  const merged = mergeScans(scans);
+  return nested ? { ...merged, skippedSubquery: true } : merged;
+}
+function boundNames(select2) {
+  const from = select2?.from ?? [];
+  return Array.isArray(from) ? from.flatMap((ref) => refNames(ref)) : [];
+}
+function stripParenthesised(text2) {
+  let previous = text2;
+  for (;; ) {
+    const next = previous.replace(/\([^()]*\)/g, " ");
+    if (next === previous)
+      return next;
+    previous = next;
+  }
+}
 function unparseable(sql, dialect, type) {
   const executable = stripCommentsAndStrings(sql, dialect ? { dialect } : {});
+  const statementLevel = stripParenthesised(executable);
+  const singleTable = SINGLE_TARGET.test(executable) && !SECOND_SOURCE_ANYWHERE.test(executable) && !SECOND_SOURCE_AT_STATEMENT_LEVEL.some((pattern) => pattern.test(statementLevel));
+  if (!singleTable)
+    return verdict("two", "unparseable", undefined, type);
   if (/\bWHERE\b|\bLIMIT\b/i.test(executable))
     return verdict("one", undefined, undefined, type);
   return verdict("two", "unparseable", undefined, type);
 }
+function classifyMerge(sql, dialect) {
+  const executable = stripParenthesised(stripCommentsAndStrings(sql, dialect ? { dialect } : {}));
+  if (!MERGE_STATEMENT.test(executable))
+    return;
+  const matched = MERGE_TARGET.exec(executable)?.[1];
+  const table = matched === undefined || matched.endsWith(".") || /^USING$/i.test(matched) ? undefined : matched;
+  const destructive = /\bTHEN\s+DELETE\b/i.test(executable) ? "DELETE" : /\bTHEN\s+UPDATE\b/i.test(executable) ? "UPDATE" : undefined;
+  if (!destructive)
+    return verdict("one", undefined, table, "INSERT");
+  return verdict("two", "multi_table", table, destructive);
+}
+function nestedWrite(sql, dialect) {
+  const executable = stripCommentsAndStrings(sql, dialect ? { dialect } : {}).replace(SQL_LOCK_CLAUSE, " ").replace(REFERENTIAL_ACTION, " ");
+  const match = /\b(INSERT|UPDATE|DELETE)\b|\bMERGE\s+INTO\b/i.exec(insideParentheses(executable));
+  if (match === null)
+    return;
+  return keywordToType(match[1] ?? "MERGE");
+}
+function insideParentheses(text2) {
+  let depth = 0;
+  let result = "";
+  for (const char of text2) {
+    if (char === "(") {
+      depth += 1;
+      result += " ";
+      continue;
+    }
+    if (char === ")") {
+      depth = Math.max(0, depth - 1);
+      result += " ";
+      continue;
+    }
+    result += depth > 0 ? char : " ";
+  }
+  return result;
+}
 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())));
@@ -22511,7 +22682,7 @@ function verdict(tier, reason, table, operation) {
     confirmationPhrase: table ?? WRITE_GATE_FALLBACK_PHRASE
   };
 }
-var WRITE_GATE_FALLBACK_PHRASE = "CONFIRM", PARSER_DIALECTS, WRITE_TYPES, DDL_TARGET;
+var WRITE_GATE_FALLBACK_PHRASE = "CONFIRM", PARSER_DIALECTS, WRITE_TYPES, DDL_TARGET, EMPTY_SCAN, SINGLE_TARGET, SECOND_SOURCE_ANYWHERE, SECOND_SOURCE_AT_STATEMENT_LEVEL, MERGE_STATEMENT, MERGE_TARGET, REFERENTIAL_ACTION;
 var init_write_gate = __esm(() => {
   init_permission_guard();
   init_sql_analysis();
@@ -22530,6 +22701,13 @@ var init_write_gate = __esm(() => {
     "CREATE"
   ]);
   DDL_TARGET = /\b(?:DROP\s+TABLE|TRUNCATE(?:\s+TABLE)?)\s+(?:IF\s+EXISTS\s+)?([`"[\]\w$.]+)\s*;?\s*$/i;
+  EMPTY_SCAN = { owners: [], correlated: [], skippedSubquery: false };
+  SINGLE_TARGET = /^\s*(?:UPDATE\s+(?:ONLY\s+)?[\w`"[\]$.]+\s+SET\b|DELETE\s+FROM\s+(?:ONLY\s+)?[\w`"[\]$.]+(?!\s*,)(?:\s|$))/i;
+  SECOND_SOURCE_ANYWHERE = /\b(?:SELECT|TABLE|VALUES|JOIN|USING)\b/i;
+  SECOND_SOURCE_AT_STATEMENT_LEVEL = [/\bWITH\b/i, /\bUPDATE\b[\s\S]*?\bFROM\b/i];
+  MERGE_STATEMENT = /\bMERGE\s+INTO\b/i;
+  MERGE_TARGET = /\bMERGE\s+INTO\s+(?:ONLY\s+)?([\w$.]+)/i;
+  REFERENTIAL_ACTION = /\bON\s+(?:DELETE|UPDATE)\b/gi;
 });
 
 // src/commands/write-gate-guard.ts
@@ -22541,6 +22719,7 @@ __export(exports_write_gate_guard, {
 async function recordGateDecision(request) {
   await writeAuditEntry(request.config, request.command, request.options, {
     success: request.outcome === "allowed",
+    sideEffectTier: "db-write",
     ...request.sql && { sql: request.sql },
     ...request.verdict.table && { target: request.verdict.table },
     metadata: {
@@ -25491,9 +25670,12 @@ async function qCommand(name, options, command) {
       console.error(`\u26A0 ${w2}`);
     if (prepared.warnings.length > 0)
       console.error("");
+    const family = engineFamily(engine);
+    const sqlDialect = SQL_DIALECTS.find((dialect) => dialect === connectionSystem);
+    const classification = family === "sql" ? enforcePermission(prepared.rewrittenSql, config.permission, sqlDialect) : undefined;
     if (options.dryRun) {
       console.log(formatDryRun({
-        family: engineFamily(engine),
+        family,
         driverSql: prepared.driver.sql,
         values: prepared.driver.values,
         execHints: prepared.execHints,
@@ -25514,8 +25696,6 @@ async function qCommand(name, options, command) {
     }
     const blacklistManager = new BlacklistManager(config);
     const blacklistValidator = new BlacklistValidator(blacklistManager);
-    const family = engineFamily(engine);
-    const sqlDialect = SQL_DIALECTS.find((dialect) => dialect === connectionSystem);
     const targets = family === "sql" ? extractTableReferences(prepared.rewrittenSql, {
       ...sqlDialect ? { dialect: sqlDialect } : {}
     }) : family === "es" ? [prepared.execHints?.index ?? ""] : [];
@@ -25523,8 +25703,8 @@ async function qCommand(name, options, command) {
     targetNameForAudit = targetName || name;
     if (family === "es") {
       blacklistValidator.checkIndexBlacklist("SELECT", targetName);
-    } else if (family !== "redis" && targets.length > 0) {
-      blacklistValidator.checkTablesBlacklist("SELECT", targets);
+    } else if (classification && targets.length > 0) {
+      blacklistValidator.checkTablesBlacklist(classification.type, targets);
     }
     const adapter = AdapterFactory.createAdapter(config.connection);
     await adapter.connect();
@@ -36541,6 +36721,81 @@ Verification artifact: ${verificationArtifactPath}`);
   });
 });
 
+// src/core/audit/write-gate-summary.ts
+function metadataOf(entry) {
+  const metadata = entry.metadata;
+  return metadata && typeof metadata === "object" ? metadata : {};
+}
+function readString(source, key) {
+  const value = source[key];
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+class Span {
+  from;
+  to;
+  add(ts) {
+    if (this.from === undefined || ts < this.from)
+      this.from = ts;
+    if (this.to === undefined || ts > this.to)
+      this.to = ts;
+  }
+  value() {
+    return this.from === undefined || this.to === undefined ? null : { from: this.from, to: this.to };
+  }
+}
+function summarizeWriteGate(entries) {
+  const outcomes = Object.fromEntries(GATE_OUTCOMES.map((o) => [o, 0]));
+  const reasons = Object.fromEntries(GATE_REASONS.map((r) => [r, 0]));
+  const tierOneOutcomes = {};
+  const window = new Span;
+  const range = new Span;
+  let total = 0;
+  let tierOneTotal = 0;
+  const tally = (into, key) => {
+    into[key] = (into[key] ?? 0) + 1;
+  };
+  for (const entry of entries) {
+    window.add(entry.ts);
+    const metadata = metadataOf(entry);
+    const tier = readString(metadata, "write_gate_tier");
+    if (!tier)
+      continue;
+    const outcome = readString(metadata, "write_gate_outcome") ?? "unknown";
+    if (tier !== "two") {
+      tierOneTotal += 1;
+      tally(tierOneOutcomes, outcome);
+      continue;
+    }
+    total += 1;
+    range.add(entry.ts);
+    tally(outcomes, outcome);
+    tally(reasons, readString(metadata, "write_gate_reason") ?? "unknown");
+  }
+  return {
+    scanned: entries.length,
+    window: window.value(),
+    total,
+    outcomes,
+    reasons,
+    tierOne: { total: tierOneTotal, outcomes: tierOneOutcomes },
+    range: range.value()
+  };
+}
+var GATE_OUTCOMES, GATE_REASONS;
+var init_write_gate_summary = __esm(() => {
+  GATE_OUTCOMES = ["allowed", "declined", "refused"];
+  GATE_REASONS = [
+    "no_where",
+    "ddl_destruction",
+    "unparseable",
+    "multiple_statements",
+    "non_unique_where",
+    "multi_table",
+    "nested_write"
+  ];
+});
+
 // src/commands/audit.ts
 var exports_audit = {};
 __export(exports_audit, {
@@ -36726,6 +36981,53 @@ function readLineFromStdinWithStderrPrompt(prompt) {
     process.stdin.resume();
   });
 }
+function formatOutcomeCounts(outcomes) {
+  const seen = Object.entries(outcomes).filter(([, count]) => count > 0);
+  if (seen.length === 0)
+    return MISSING_PLACEHOLDER;
+  return seen.map(([name, count]) => `${name} ${count}`).join(", ");
+}
+function renderWriteGateSummary(summary, connections) {
+  const lines = [];
+  lines.push(t_vars("audit.write_gate.header", {
+    conn: connections.length > 0 ? connections.join(", ") : MISSING_PLACEHOLDER
+  }));
+  if (summary.window) {
+    lines.push(t_vars("audit.write_gate.window", {
+      scanned: String(summary.scanned),
+      from: summary.window.from,
+      to: summary.window.to
+    }));
+  }
+  if (summary.total === 0) {
+    lines.push("");
+    lines.push(summary.scanned === 0 ? t("audit.write_gate.no_entries") : t("audit.write_gate.no_decisions"));
+    if (summary.tierOne.total > 0) {
+      lines.push(t_vars("audit.write_gate.tier_one", {
+        count: String(summary.tierOne.total),
+        outcomes: formatOutcomeCounts(summary.tierOne.outcomes)
+      }));
+    }
+    return lines.join(`
+`);
+  }
+  lines.push(t_vars("audit.write_gate.decisions", {
+    count: String(summary.total),
+    from: summary.range?.from ?? MISSING_PLACEHOLDER,
+    to: summary.range?.to ?? MISSING_PLACEHOLDER
+  }));
+  lines.push("");
+  lines.push(renderTable(Object.entries(summary.outcomes).map(([name, count]) => [name, String(count)]), ["outcome", "count"]));
+  lines.push("");
+  lines.push(renderTable(Object.entries(summary.reasons).map(([name, count]) => [name, String(count)]), ["reason", "count"]));
+  lines.push("");
+  lines.push(t_vars("audit.write_gate.tier_one", {
+    count: String(summary.tierOne.total),
+    outcomes: formatOutcomeCounts(summary.tierOne.outcomes)
+  }));
+  return lines.join(`
+`);
+}
 async function statAuditFile(file) {
   try {
     const s = await stat7(file);
@@ -36745,6 +37047,7 @@ var init_audit = __esm(() => {
   init_config_binding();
   init_reader2();
   init_integration_helper();
+  init_write_gate_summary();
   ALLOWED_FORMATS14 = ["table", "json"];
   auditCommand = new Command("audit").description(t("audit.description"));
   auditCommand.command("tail").description(t("audit.tail.description")).option("--n <number>", `Number of recent entries to show (1..${MAX_TAIL_N})`, String(DEFAULT_TAIL_N)).option("--all", "Merge entries across all connections", false).option("--format <format>", `Output format: ${ALLOWED_FORMATS14.join(" | ")} (default: table)`, "table").option("--brief", "Trim each entry to ts/command/target/success", false).option("--no-brief", "Disable brief mode (override --for-agent default)").option("--for-agent", "Shortcut for --format json --brief", false).action(async (options, command) => {
@@ -36952,6 +37255,33 @@ var init_audit = __esm(() => {
 `);
     process.exit(0);
   });
+  auditCommand.command("write-gate").description(t("audit.write_gate.description")).option("--all", "Summarize across all connections", false).option("--format <format>", `Output format: ${ALLOWED_FORMATS14.join(" | ")} (default: table)`, "table").option("--for-agent", "Shortcut for --format json", false).action(async (options, command) => {
+    const format = options.forAgent === true ? "json" : options.format;
+    validateFormat(format, ALLOWED_FORMATS14, "audit write-gate");
+    const configPath = resolveConfigPath(command, options);
+    const config = await configModule.read(configPath);
+    if (isAuditDisabled(config))
+      emitDisabledAndExit0();
+    const { auditDir, auditFile, connectionName } = await resolveAuditPaths(configPath, config);
+    let entries = [];
+    let connections = [connectionName];
+    if (options.all === true) {
+      const discovered = await discoverConnections(auditDir);
+      connections = discovered.map((c) => c.connection);
+      for (const c of discovered) {
+        for (const file of c.files)
+          entries.push(...await readEntries(file));
+      }
+    } else {
+      entries = await readEntries(auditFile, { include_rotated: true });
+    }
+    const summary = summarizeWriteGate(entries);
+    if (format === "json") {
+      console.log(JSON.stringify({ connections, summary }, null, 2));
+      return;
+    }
+    console.log(renderWriteGateSummary(summary, connections));
+  });
   auditCommand.command("health").description(t("audit.health.description")).option("--format <format>", `Output format: ${ALLOWED_FORMATS14.join(" | ")} (default: table)`, "table").option("--brief", "Trim to enabled / lastWrite / rotationUsage", false).option("--no-brief", "Disable brief mode (override --for-agent default)").option("--for-agent", "Shortcut for --format json --brief", false).action(async (options, command) => {
     const forAgent = options.forAgent === true;
     const format = forAgent ? "json" : options.format;
@@ -41196,20 +41526,39 @@ var init_grammar = __esm(() => {
 });
 
 // src/core/assert/evaluator.ts
+function numeric(value) {
+  if (typeof value === "number")
+    return Number.isNaN(value) ? null : value;
+  const trimmed = value.trim();
+  if (trimmed === "")
+    return null;
+  const parsed = Number(trimmed);
+  return Number.isNaN(parsed) ? null : parsed;
+}
 function compare(a, op, b) {
+  let left = a;
+  let right = b;
+  if (typeof a !== typeof b) {
+    const na = numeric(a);
+    const nb = numeric(b);
+    if (na !== null && nb !== null) {
+      left = na;
+      right = nb;
+    }
+  }
   switch (op) {
     case ">":
-      return a > b;
+      return left > right;
     case ">=":
-      return a >= b;
+      return left >= right;
     case "<":
-      return a < b;
+      return left < right;
     case "<=":
-      return a <= b;
+      return left <= right;
     case "==":
-      return a === b;
+      return left === right;
     case "!=":
-      return a !== b;
+      return left !== right;
   }
 }
 function firstScalar(result) {
@@ -41262,7 +41611,10 @@ function evaluateExpect(node, result) {
     };
   }
   if (pred.type === "between") {
-    const bad2 = nonNull.filter((v) => typeof v !== "number" || v < pred.low || v > pred.high);
+    const bad2 = nonNull.filter((v) => {
+      const n = numeric(v);
+      return n === null || n < pred.low || n > pred.high;
+    });
     return {
       name: `col:${column} between ${pred.low} and ${pred.high}`,
       expected: "0 out of range",
@@ -41293,7 +41645,7 @@ function compareVs(a, b, mode) {
     name: "vs:value",
     expected: String(bv),
     actual: String(av),
-    pass: av !== null && bv !== null && av === bv
+    pass: av !== null && bv !== null && compare(av, "==", bv)
   };
 }
 var AssertShapeError;
@@ -41366,7 +41718,7 @@ function canonicalizeEvidenceReceiptCommand(command, operation = "assert") {
 function sha2563(value) {
   return `sha256:${createHash5("sha256").update(value).digest("hex")}`;
 }
-function verdictFingerprint(verdict2) {
+function verdictObservation(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");
   }
@@ -41376,26 +41728,30 @@ function verdictFingerprint(verdict2) {
     }
     return check.pass;
   });
-  return sha2563(JSON.stringify({ pass: verdict2.pass, checks: bits }));
+  return {
+    kind: "assert-verdict",
+    checksPassed: bits.filter(Boolean).length,
+    checksTotal: bits.length
+  };
 }
-function verificationOutcomeFingerprint(status2, artifactPersisted) {
+function verificationObservation(status2, artifactPersisted) {
   if (!isVerificationStatus(status2)) {
     throw new EvidenceReceiptValidationError("verificationStatus must be a verification status");
   }
   if (typeof artifactPersisted !== "boolean") {
     throw new EvidenceReceiptValidationError("verificationArtifactPersisted must be a boolean");
   }
-  return sha2563(JSON.stringify({ status: status2, artifactPersisted }));
+  return { kind: "verify-outcome", status: status2 };
 }
 function buildEvidenceReceipt(input, options = {}) {
   const operation = input.operation === "verify" ? "verify" : "assert";
   const command = canonicalizeEvidenceReceiptCommand(input.command, operation);
   const context = parseContext2(input.context);
-  const { observationFingerprint, outcome } = input.operation === "verify" ? {
-    observationFingerprint: verificationOutcomeFingerprint(input.verificationStatus, input.verificationArtifactPersisted),
+  const { observation, outcome } = input.operation === "verify" ? {
+    observation: verificationObservation(input.verificationStatus, input.verificationArtifactPersisted),
     outcome: input.verificationStatus === "verified" && input.verificationArtifactPersisted ? "succeeded" : "failed"
   } : {
-    observationFingerprint: verdictFingerprint(input.verdict),
+    observation: verdictObservation(input.verdict),
     outcome: input.verdict.pass ? "succeeded" : "failed"
   };
   const receipt = {
@@ -41412,10 +41768,7 @@ function buildEvidenceReceipt(input, options = {}) {
       verificationArtifactRef: input.verificationArtifactRef === undefined ? null : nullableId(input.verificationArtifactRef, "verificationArtifactRef")
     },
     replay: { status: "context-required" },
-    observation: {
-      kind: operation === "assert" ? "assert-verdict" : "verify-outcome",
-      fingerprint: observationFingerprint
-    }
+    observation
   };
   return receipt;
 }
@@ -41460,9 +41813,7 @@ function parseEvidenceReceipt(raw) {
     throw new EvidenceReceiptValidationError("command provenance hash mismatch");
   if (!record3(raw.replay) || raw.replay.status !== "context-required" || Object.keys(raw.replay).length !== 1)
     throw new EvidenceReceiptValidationError("replay must be context-required");
-  if (!record3(raw.observation) || raw.observation.kind !== (operation === "assert" ? "assert-verdict" : "verify-outcome") || Object.keys(raw.observation).length !== 2)
-    throw new EvidenceReceiptValidationError("observation must match receipt operation");
-  const observationKind = operation === "assert" ? "assert-verdict" : "verify-outcome";
+  const observation = parseObservation(raw.observation, operation);
   return {
     version: EVIDENCE_RECEIPT_VERSION,
     id: safeId(raw.id, "id"),
@@ -41477,10 +41828,26 @@ function parseEvidenceReceipt(raw) {
       verificationArtifactRef: nullableId(raw.provenance.verificationArtifactRef, "provenance.verificationArtifactRef")
     },
     replay: { status: "context-required" },
-    observation: {
-      kind: observationKind,
-      fingerprint: fingerprint(raw.observation.fingerprint, "observation.fingerprint")
-    }
+    observation
+  };
+}
+function parseObservation(raw, operation) {
+  if (!record3(raw))
+    throw new EvidenceReceiptValidationError("observation must be an object");
+  if (operation === "verify") {
+    exact(raw, ["kind", "status"], "observation");
+    if (raw.kind !== "verify-outcome" || !isVerificationStatus(raw.status))
+      throw new EvidenceReceiptValidationError("observation must match receipt operation");
+    return { kind: "verify-outcome", status: raw.status };
+  }
+  exact(raw, ["kind", "checksPassed", "checksTotal"], "observation");
+  const { kind, checksPassed, checksTotal } = raw;
+  if (kind !== "assert-verdict" || !Number.isSafeInteger(checksPassed) || !Number.isSafeInteger(checksTotal) || checksPassed < 0 || checksTotal < checksPassed)
+    throw new EvidenceReceiptValidationError("observation must match receipt operation");
+  return {
+    kind: "assert-verdict",
+    checksPassed,
+    checksTotal
   };
 }
 function inside(root, target) {
@@ -44242,6 +44609,9 @@ function classifyInput(raw) {
       return { type: "meta", raw, normalized: normalized2 };
     }
   }
+  if (normalized2.startsWith(COMMAND_PREFIX)) {
+    return { type: "command", raw, normalized: normalized2 };
+  }
   const firstWord = (normalized2.split(/\s+/)[0] ?? "").toUpperCase();
   if (sqlKeywordSet.has(firstWord)) {
     return { type: "sql", raw, normalized: normalized2 };
@@ -44251,7 +44621,7 @@ function classifyInput(raw) {
   }
   return { type: "command", raw, normalized: normalized2 };
 }
-var META_PREFIX = ".", SQL_TERMINATOR = ";", sqlKeywordSet, metaCommandNames;
+var META_PREFIX = ".", COMMAND_PREFIX = "\\", SQL_TERMINATOR = ";", sqlKeywordSet, metaCommandNames;
 var init_input_classifier = __esm(() => {
   init_types11();
   sqlKeywordSet = new Set(SQL_KEYWORDS_FOR_DETECTION);
@@ -44275,6 +44645,10 @@ class MultilineBuffer {
   isActive() {
     return this.lines.length > 0;
   }
+  isInsideLiteral() {
+    return insideLiteral(this.lines.join(`
+`));
+  }
   getPartial() {
     return this.lines.join(`
 `);
@@ -44284,9 +44658,17 @@ class MultilineBuffer {
   }
 }
 function hasUnquotedSemicolon(sql) {
+  return scan(sql).semicolon;
+}
+function insideLiteral(sql) {
+  const { inSingleQuote, inDoubleQuote } = scan(sql);
+  return inSingleQuote || inDoubleQuote;
+}
+function scan(sql) {
   let inSingleQuote = false;
   let inDoubleQuote = false;
   let escaped = false;
+  let semicolon = false;
   for (let i = 0;i < sql.length; i++) {
     const ch = sql[i];
     if (escaped) {
@@ -44306,10 +44688,10 @@ function hasUnquotedSemicolon(sql) {
       continue;
     }
     if (ch === ";" && !inSingleQuote && !inDoubleQuote) {
-      return true;
+      semicolon = true;
     }
   }
-  return false;
+  return { semicolon, inSingleQuote, inDoubleQuote };
 }
 
 // src/core/repl/meta-commands.ts
@@ -44353,7 +44735,8 @@ function helpText() {
     "",
     import_picocolors2.default.bold("Usage:"),
     `  SQL statements     Execute directly (end with ${import_picocolors2.default.cyan(";")})`,
-    `  dbcli commands     Run without ${import_picocolors2.default.dim("dbcli")} prefix (e.g. ${import_picocolors2.default.cyan("schema users")})`,
+    `  dbcli commands     Run without the ${import_picocolors2.default.dim("dbcli")} prefix (e.g. ${import_picocolors2.default.cyan("schema users")})`,
+    `  ${import_picocolors2.default.cyan("\\<command>")}         Force the dbcli subcommand \u2014 required for ${import_picocolors2.default.dim("delete")}, ${import_picocolors2.default.dim("update")}, ${import_picocolors2.default.dim("insert")} and other SQL keywords (e.g. ${import_picocolors2.default.cyan("\\delete users --where id=1")})`,
     `  Ctrl+D             Exit`
   ];
   return lines.join(`
@@ -44457,24 +44840,26 @@ function splitRespectingQuotes(input) {
   let current = "";
   let inDoubleQuote = false;
   let inSingleQuote = false;
+  let quoted = false;
   for (let i = 0;i < input.length; i++) {
     const ch = input[i];
     if (ch === '"' && !inSingleQuote) {
       inDoubleQuote = !inDoubleQuote;
-      current += ch;
+      quoted = true;
     } else if (ch === "'" && !inDoubleQuote) {
       inSingleQuote = !inSingleQuote;
-      current += ch;
+      quoted = true;
     } else if (ch === " " && !inDoubleQuote && !inSingleQuote) {
-      if (current.length > 0) {
+      if (current.length > 0 || quoted) {
         tokens.push(current);
         current = "";
+        quoted = false;
       }
     } else {
       current += ch;
     }
   }
-  if (current.length > 0) {
+  if (current.length > 0 || quoted) {
     tokens.push(current);
   }
   return tokens;
@@ -44540,14 +44925,16 @@ var init_history_manager = () => {};
 class ReplEngine {
   adapter;
   context;
+  writeGate;
   state;
   buffer;
   history;
   formatter;
   config;
-  constructor(adapter, context, historyPath, config = null) {
+  constructor(adapter, context, historyPath, config = null, writeGate = null) {
     this.adapter = adapter;
     this.context = context;
+    this.writeGate = writeGate;
     this.state = { format: "table", timing: false, connected: true, noLimit: false };
     this.buffer = new MultilineBuffer;
     this.history = new HistoryManager(historyPath);
@@ -44560,6 +44947,9 @@ class ReplEngine {
   isMultiline() {
     return this.buffer.isActive();
   }
+  cancelMultiline() {
+    this.buffer.reset();
+  }
   getHistory() {
     return this.history.getAll();
   }
@@ -44568,6 +44958,13 @@ class ReplEngine {
   }
   async processInput(line) {
     if (this.buffer.isActive()) {
+      const classified2 = classifyInput(line);
+      if (classified2.type === "meta" && !this.buffer.isInsideLiteral()) {
+        const result = this.handleMeta(classified2.normalized);
+        if (result.action === "quit" || result.action === "clear")
+          this.buffer.reset();
+        return result;
+      }
       const bufResult = this.buffer.append(line);
       if (bufResult.complete) {
         this.history.add(bufResult.sql);
@@ -44604,14 +45001,27 @@ class ReplEngine {
       this.history.add(bufResult.sql);
       return this.executeSql(bufResult.sql);
     }
-    return { action: "multiline" };
+    const hint = this.subcommandHint(input);
+    return hint ? { action: "multiline", output: hint } : { action: "multiline" };
+  }
+  subcommandHint(input) {
+    const words = input.trim().split(/\s+/);
+    const firstWord = (words[0] ?? "").toLowerCase();
+    if (!this.context.commandNames.includes(firstWord))
+      return;
+    if (!/\s--[a-z]/.test(input))
+      return;
+    if (STATEMENT_CONTINUATION.has((words[1] ?? "").toUpperCase()))
+      return;
+    return import_picocolors3.default.dim(t_vars("shell.subcommand_prefix_hint", { command: `${COMMAND_PREFIX}${firstWord}` }));
   }
   async handleCommand(input) {
-    const parsed = parseCommandLine(input);
+    const invocation = input.startsWith(COMMAND_PREFIX) ? input.slice(COMMAND_PREFIX.length) : input;
+    const parsed = parseCommandLine(invocation);
     if (!isKnownCommand(parsed.command, this.context.commandNames)) {
       if (this.context.system === "redis") {
         this.history.add(input);
-        return this.executeSql(input);
+        return this.executeSql(invocation);
       }
       return {
         action: "continue",
@@ -44621,11 +45031,11 @@ class ReplEngine {
     this.history.add(input);
     try {
       const cliPath = new URL("../../cli.ts", import.meta.url).pathname;
-      const argv = [parsed.command, "--config", this.context.configPath, ...parsed.args];
+      const argv = ["--config", this.context.configPath, parsed.command, ...parsed.args];
       const proc = Bun.spawn(["bun", "run", cliPath, ...argv], {
         stdout: "pipe",
         stderr: "pipe",
-        env: { ...process.env }
+        env: { ...process.env, DBCLI_SHELL_SUBCOMMAND: "1" }
       });
       const [stdoutBuf, stderrBuf] = await Promise.all([
         new Response(proc.stdout).text(),
@@ -44681,6 +45091,11 @@ class ReplEngine {
         };
       }
     }
+    if (this.writeGate && !await this.writeGate(sql))
+      return { action: "continue" };
+    return this.runStatement(sql, blacklistValidator, referencedTables);
+  }
+  async runStatement(sql, blacklistValidator, referencedTables) {
     const startTime = Date.now();
     try {
       const result = await this.adapter.execute(sql, undefined, {
@@ -44716,7 +45131,7 @@ class ReplEngine {
           await this.adapter.connect();
           this.state = { ...this.state, connected: true };
           console.error(import_picocolors3.default.green(t("shell.error_reconnect_success")));
-          return this.executeSql(sql);
+          return this.runStatement(sql, blacklistValidator, referencedTables);
         } catch (reconnectError) {
           return {
             action: "continue",
@@ -44747,7 +45162,7 @@ class ReplEngine {
     return isTransportFailure(error);
   }
 }
-var import_picocolors3;
+var import_picocolors3, STATEMENT_CONTINUATION;
 var init_repl_engine = __esm(() => {
   init_connection_error_message();
   init_input_classifier();
@@ -44761,6 +45176,15 @@ var init_repl_engine = __esm(() => {
   init_blacklist_validator();
   init_blacklist();
   import_picocolors3 = __toESM(require_picocolors(), 1);
+  STATEMENT_CONTINUATION = new Set([
+    "FROM",
+    "INTO",
+    "SET",
+    "TABLE",
+    "INDEX",
+    "VIEW",
+    "DATABASE"
+  ]);
 });
 
 // src/core/repl/completer.ts
@@ -44803,6 +45227,11 @@ function createCompleter(ctx) {
     }
     const words = trimmed.split(/\s+/);
     if (words.length === 1) {
+      if (lastWord.startsWith(COMMAND_PREFIX)) {
+        const bare = lastWord.slice(COMMAND_PREFIX.length);
+        const [hits] = matchWithSuffix([...ctx.commandNames], bare);
+        return [hits.map((hit) => `${COMMAND_PREFIX}${hit}`), lastWord];
+      }
       const cmdHits = matchWithSuffix([...ctx.commandNames], lastWord);
       const sqlHits = matchWithSuffix([...SQL_KEYWORDS_FOR_COMPLETION], lastWord);
       return [[...cmdHits[0], ...sqlHits[0]], lastWord];
@@ -44856,6 +45285,7 @@ function matchWithSuffix(candidates, prefix) {
 var REDIS_COMMANDS, TABLE_POSITION_KEYWORDS, COMMANDS_TAKING_TABLE_ARG;
 var init_completer = __esm(() => {
   init_types11();
+  init_input_classifier();
   init_command_metadata();
   REDIS_COMMANDS = Object.keys(REDIS_COMMAND_TABLE);
   TABLE_POSITION_KEYWORDS = new Set([
@@ -45153,6 +45583,94 @@ var init_command_registry = __esm(() => {
   REPL_DENYLIST = new Set(["shell"]);
 });
 
+// src/commands/shell-prompt-asker.ts
+var exports_shell_prompt_asker = {};
+__export(exports_shell_prompt_asker, {
+  createPromptAsker: () => createPromptAsker
+});
+function createPromptAsker(getInterface) {
+  let pending = null;
+  return {
+    async ask(question) {
+      const rl = getInterface();
+      if (!rl)
+        throw new Error("Write gate asked for confirmation before the shell started");
+      return new Promise((resolve10) => {
+        const controller = new AbortController;
+        const settle = (answer) => {
+          pending = null;
+          rl.pause();
+          resolve10(answer);
+        };
+        pending = {
+          abort: () => {
+            controller.abort();
+            settle(null);
+          }
+        };
+        try {
+          rl.question(`${question}: `, { signal: controller.signal }, settle);
+        } catch (error) {
+          pending = null;
+          throw error;
+        }
+      });
+    },
+    cancel() {
+      if (!pending)
+        return false;
+      pending.abort();
+      return true;
+    }
+  };
+}
+
+// src/commands/shell-write-gate.ts
+var exports_shell_write_gate = {};
+__export(exports_shell_write_gate, {
+  createShellWriteGate: () => createShellWriteGate
+});
+function createShellWriteGate(options) {
+  const record4 = options.record ?? ((decision) => recordGateDecision({
+    config: options.config,
+    command: "shell",
+    options: { config: options.configPath },
+    verdict: decision.verdict,
+    outcome: decision.outcome,
+    tier: decision.tier,
+    sql: decision.sql
+  }));
+  return async (sql) => {
+    const verdict2 = await classifySqlWriteGate(sql, { dialect: options.dialect });
+    if (verdict2.tier !== "two")
+      return true;
+    const decide5 = (outcome) => record4({ verdict: verdict2, outcome, tier: "two", sql });
+    try {
+      const proceed = await enforceWriteGate({
+        verdict: verdict2,
+        statement: sql,
+        operation: verdict2.operation ?? "WRITE",
+        human: { isTTY: process.stdin.isTTY === true },
+        ...options.ask && { ask: options.ask }
+      });
+      await decide5(proceed ? "allowed" : "declined");
+      return proceed;
+    } catch (error) {
+      if (!(error instanceof WriteGateRefusal))
+        throw error;
+      await decide5("refused");
+      process.stderr.write(`${error.message}
+`);
+      return false;
+    }
+  };
+}
+var init_shell_write_gate = __esm(() => {
+  init_write_gate();
+  init_write_gate_prompt();
+  init_write_gate_guard();
+});
+
 // src/commands/shell.ts
 var exports_shell = {};
 __export(exports_shell, {
@@ -45259,7 +45777,18 @@ async function runShell(options, configPath) {
     columnsByTable,
     commandNames
   };
-  const engine = new ReplEngine(adapter, context, HISTORY_PATH, config);
+  let replInterface = null;
+  const { createPromptAsker: createPromptAsker2 } = await Promise.resolve().then(() => exports_shell_prompt_asker);
+  const asker = createPromptAsker2(() => replInterface);
+  const { toSqlDialect: toSqlDialect2 } = await Promise.resolve().then(() => (init_permission_guard(), exports_permission_guard));
+  const dialect = toSqlDialect2(config.connection.system);
+  const writeGate = dialect ? (await Promise.resolve().then(() => (init_shell_write_gate(), exports_shell_write_gate))).createShellWriteGate({
+    config,
+    configPath,
+    dialect,
+    ask: asker.ask
+  }) : null;
+  const engine = new ReplEngine(adapter, context, HISTORY_PATH, config, writeGate);
   const complete = createCompleter(context);
   console.error(import_picocolors5.default.bold(t_vars("shell.welcome", {
     system: config.connection.system,
@@ -45293,10 +45822,22 @@ async function runShell(options, configPath) {
     completer: (line) => complete(line),
     terminal: process.stdin.isTTY ?? false
   });
+  replInterface = rl;
   const continuationPrompt = import_picocolors5.default.dim(t("shell.continuation_prompt") + "> ");
   rl.prompt();
-  rl.on("line", async (line) => {
-    const result = await engine.processInput(line);
+  const handleLine = async (line) => {
+    rl.pause();
+    let result;
+    try {
+      result = await engine.processInput(line);
+    } catch (error) {
+      console.error(import_picocolors5.default.red(t_vars("shell.error_sql_failed", { message: error.message })));
+      rl.setPrompt(import_picocolors5.default.cyan(t("shell.prompt") + "> "));
+      rl.prompt();
+      return;
+    } finally {
+      rl.resume();
+    }
     switch (result.action) {
       case "quit":
         if (result.output)
@@ -45307,16 +45848,21 @@ async function runShell(options, configPath) {
         console.clear();
         break;
       case "multiline":
-        rl.setPrompt(continuationPrompt);
+        if (result.output)
+          console.error(result.output);
         break;
       case "continue":
         if (result.output) {
           console.log(result.output);
         }
-        rl.setPrompt(import_picocolors5.default.cyan(t("shell.prompt") + "> "));
         break;
     }
+    rl.setPrompt(engine.isMultiline() ? continuationPrompt : import_picocolors5.default.cyan(t("shell.prompt") + "> "));
     rl.prompt();
+  };
+  let pending = Promise.resolve();
+  rl.on("line", (line) => {
+    pending = pending.then(() => handleLine(line));
   });
   rl.on("close", async () => {
     console.error(import_picocolors5.default.dim(t("shell.goodbye")));
@@ -45325,7 +45871,10 @@ async function runShell(options, configPath) {
     process.exit(0);
   });
   rl.on("SIGINT", () => {
+    if (asker.cancel())
+      return;
     if (engine.isMultiline()) {
+      engine.cancelMultiline();
       console.error(import_picocolors5.default.dim(t("shell.multiline_cancelled")));
       rl.setPrompt(import_picocolors5.default.cyan(t("shell.prompt") + "> "));
     }
@@ -45341,7 +45890,10 @@ async function runBatchSession(engine, input) {
       continue;
     const result = await engine.processInput(line);
     if (result.output) {
-      console.log(result.output);
+      if (result.action === "multiline")
+        console.error(result.output);
+      else
+        console.log(result.output);
     }
     if (result.action === "quit") {
       return;
@@ -49354,11 +49906,19 @@ function assertVerificationSubjects(subject, claims) {
     throw new EvidencePackValidationError("verification evidence must match the claims subject kind");
   }
 }
-function canonicalizeWithoutDigest(pack) {
-  return JSON.stringify(pack);
+function canonicalize(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value))
+    return `[${value.map(canonicalize).join(",")}]`;
+  const entries = Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, v]) => `${JSON.stringify(key)}:${canonicalize(v)}`);
+  return `{${entries.join(",")}}`;
+}
+function digest(content) {
+  return createHash8("sha256").update(canonicalize(content)).digest("hex");
 }
-function digest(pack) {
-  return createHash8("sha256").update(canonicalizeWithoutDigest(pack)).digest("hex");
+function packId(contentDigest) {
+  return `evp_${contentDigest.slice(0, 32)}`;
 }
 function parseEvidenceClaimsInput(raw) {
   if (!isRecord4(raw))
@@ -49393,49 +49953,52 @@ function buildEvidencePack(input, references, options = {}) {
   if (evidence2.some((reference) => reference.kind === "verification-artifact" && reference.subjectKind !== normalized2.subject.kind)) {
     throw new EvidencePackValidationError("verification evidence must match the claims subject kind");
   }
-  const base = {
+  const content = {
     version: EVIDENCE_PACK_VERSION,
-    id: id(options.idFactory?.() ?? `evp_${randomUUID6()}`, "pack.id"),
-    createdAt: (options.now?.() ?? new Date).toISOString(),
     subject: normalized2.subject,
-    claims: normalized2.claims.map((claim) => ({ ...claim, evidence: evidence2 })),
-    coverage: { completeForDeclaredEvidence: true, gaps: [] }
+    claims: normalized2.claims.map((claim) => ({ ...claim, evidence: evidence2 }))
+  };
+  const contentDigest = digest(content);
+  return {
+    ...content,
+    id: packId(contentDigest),
+    createdAt: (options.now?.() ?? new Date).toISOString(),
+    integrity: { algorithm: "sha256", digest: contentDigest }
   };
-  return { ...base, integrity: { algorithm: "sha256", digest: digest(base) } };
 }
 function parseEvidencePack(raw) {
   if (!isRecord4(raw))
     throw new EvidencePackValidationError("evidence pack must be an object");
-  requireExactKeys(raw, ["version", "id", "createdAt", "subject", "claims", "coverage", "integrity"], "evidence pack");
+  requireExactKeys(raw, ["version", "id", "createdAt", "subject", "claims", "integrity"], "evidence pack");
   if (raw.version !== EVIDENCE_PACK_VERSION) {
     throw new EvidencePackValidationError(`evidence pack version must be ${EVIDENCE_PACK_VERSION}`);
   }
-  if (!isRecord4(raw.coverage))
-    throw new EvidencePackValidationError("coverage must be an object");
-  requireExactKeys(raw.coverage, ["completeForDeclaredEvidence", "gaps"], "coverage");
-  if (raw.coverage.completeForDeclaredEvidence !== true || !Array.isArray(raw.coverage.gaps) || raw.coverage.gaps.length !== 0) {
-    throw new EvidencePackValidationError("v1 coverage must be complete for declared evidence with no gaps");
-  }
   if (!isRecord4(raw.integrity))
     throw new EvidencePackValidationError("integrity must be an object");
   requireExactKeys(raw.integrity, ["algorithm", "digest"], "integrity");
   if (raw.integrity.algorithm !== "sha256")
     throw new EvidencePackValidationError("integrity.algorithm must be sha256");
-  const base = {
+  const content = {
     version: EVIDENCE_PACK_VERSION,
-    id: id(raw.id, "pack.id"),
-    createdAt: iso(raw.createdAt, "pack.createdAt"),
     subject: parseSubject(raw.subject),
-    claims: parseClaims(raw.claims, true),
-    coverage: { completeForDeclaredEvidence: true, gaps: [] }
+    claims: parseClaims(raw.claims, true)
   };
-  assertVerificationSubjects(base.subject, base.claims);
+  assertVerificationSubjects(content.subject, content.claims);
   const actualDigest = text4(raw.integrity.digest, "integrity.digest", 128);
   if (!/^[a-f0-9]{64}$/.test(actualDigest))
     throw new EvidencePackValidationError("integrity.digest must be sha256 hex");
-  if (actualDigest !== digest(base))
+  const expectedDigest = digest(content);
+  if (actualDigest !== expectedDigest)
     throw new EvidencePackValidationError("evidence pack digest mismatch");
-  return { ...base, integrity: { algorithm: "sha256", digest: actualDigest } };
+  const packIdentity = id(raw.id, "pack.id");
+  if (packIdentity !== packId(expectedDigest))
+    throw new EvidencePackValidationError("evidence pack id does not match its content digest");
+  return {
+    ...content,
+    id: packIdentity,
+    createdAt: iso(raw.createdAt, "pack.createdAt"),
+    integrity: { algorithm: "sha256", digest: actualDigest }
+  };
 }
 function isInside(root, target) {
   const relativePath = relative5(root, target);
@@ -49558,7 +50121,9 @@ var init_evidence_pack = __esm(() => {
 // src/commands/evidence.ts
 var exports_evidence = {};
 __export(exports_evidence, {
-  evidenceCommand: () => evidenceCommand
+  evidenceCommand: () => evidenceCommand,
+  containsBlockedTerm: () => containsBlockedTerm,
+  blockedTerms: () => blockedTerms
 });
 import { join as join42, relative as relative6, resolve as resolve12, sep as sep8 } from "path";
 import { realpath as realpath3 } from "fs/promises";
@@ -49581,24 +50146,34 @@ async function readClaimsInput(filePath) {
 function blockedTerms(config) {
   return [
     ...config.blacklist?.tables ?? [],
+    ...Object.keys(config.blacklist?.columns ?? {}),
     ...Object.values(config.blacklist?.columns ?? {}).flat()
   ].map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0);
 }
-function assertNoBlockedText(value, terms) {
+function containsBlockedTerm(value, terms) {
+  const normalized2 = value.toLowerCase();
+  return terms.some((term) => {
+    const trimmed = term.trim().toLowerCase();
+    if (trimmed.length === 0)
+      return false;
+    const escaped = trimmed.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?<![A-Za-z0-9_])${escaped}(?![A-Za-z0-9_])`).test(normalized2);
+  });
+}
+function assertNoBlockedText(value, terms, field) {
   if (!value)
     return;
-  const normalized2 = value.toLowerCase();
-  if (terms.some((term) => normalized2.includes(term))) {
-    throw new EvidencePackValidationError("evidence content contains a blocked identifier");
+  if (containsBlockedTerm(value, terms)) {
+    throw new EvidencePackValidationError(`${field} contains a blocked identifier`);
   }
 }
 function assertClaimsSafe(raw, terms) {
   const input = parseEvidenceClaimsInput(raw);
-  assertNoBlockedText(input.subject.kind, terms);
-  assertNoBlockedText(input.subject.name, terms);
-  for (const claim of input.claims) {
-    assertNoBlockedText(claim.id, terms);
-    assertNoBlockedText(claim.text, terms);
+  assertNoBlockedText(input.subject.kind, terms, "subject.kind");
+  assertNoBlockedText(input.subject.name, terms, "subject.name");
+  for (const [index, claim] of input.claims.entries()) {
+    assertNoBlockedText(claim.id, terms, `claim ${index + 1} id`);
+    assertNoBlockedText(claim.text, terms, `claim ${index + 1} text`);
   }
 }
 function sameReference(left, right) {
@@ -50788,7 +51363,7 @@ var init_change_set = __esm(() => {
 import { createReadStream } from "fs";
 import { lstat as lstat7 } from "fs/promises";
 import { createInterface as createInterface3 } from "readline";
-async function loadWorkloadEvidence(options) {
+async function loadWorkloadSource(options) {
   const now = options.now ?? new Date;
   let info;
   try {
@@ -51169,7 +51744,7 @@ function semanticSchema(schema, blocked) {
   }
   return result;
 }
-async function loadObservedWorkloadEvidence(path4, workspaceRoot, blocked) {
+async function loadObservedWorkloadSource(path4, workspaceRoot, blocked) {
   if (path4 === undefined) {
     return {
       state: "absent",
@@ -51179,7 +51754,7 @@ async function loadObservedWorkloadEvidence(path4, workspaceRoot, blocked) {
       issues: []
     };
   }
-  return loadWorkloadEvidence({ path: resolve14(workspaceRoot, path4), blockedIdentifiers: blocked });
+  return loadWorkloadSource({ path: resolve14(workspaceRoot, path4), blockedIdentifiers: blocked });
 }
 function shouldFail(report, failOn) {
   if (failOn === "never")
@@ -51317,7 +51892,7 @@ var init_impact2 = __esm(() => {
       const contracts = await loadContractEvidence(workspaceRoot, semantic, baseline, savedQueries, blockedIdentifiers);
       const dataAccess = await loadDataAccessEvidence(workspaceRoot, semantic, baseline, savedQueries, blockedIdentifiers);
       const verifications = await loadVerificationEvidence(workspaceRoot, blockedIdentifiers);
-      const observedWorkload = await loadObservedWorkloadEvidence(options.events, workspaceRoot, blockedIdentifiers);
+      const observedWorkload = await loadObservedWorkloadSource(options.events, workspaceRoot, blockedIdentifiers);
       const report = assessImpact({
         changes,
         semantic,