@@ -291,6 +291,8 @@ See [LAUNCH.md](LAUNCH.md).
 
 Multi-statement queries execute sequentially via `POST /api/db/multi-query`, one request per execution unit (`splitExecutionUnits`): a statement, or on SQL Server the whole batch between `GO` lines.
 
+The run target, the connection type's refusal, the confirmation and the route of a run are decided by the functions `analyzeStatement` in `src/lib/editor/statement-analysis.ts` composes in the web editor's order: the web editor calls them one by one, and the VS Code extension's child calls the run target, the editor language and the gate.
+
 ### 4.4. Storage Abstraction Layer
 
 - **Write-through cache architecture**: localStorage (L1 cache) + optional server storage (L2 persistent)
 
@@ -31,7 +31,7 @@ None of it is a GitHub issue.
 - [Drivers and connections](#drivers-and-connections) — D1-D452, U17 · 333
 - [Value interpolation](#value-interpolation) — V1
 - [Row editing](#row-editing) — R1–R3 · 3
-- [Studio UI and query execution](#studio-ui-and-query-execution) — X2-X26, U2-U199 · 185
+- [Studio UI and query execution](#studio-ui-and-query-execution) — X2-X26, U2-U201 · 187
 - [Dependencies](#dependencies) — P1-P13 · 11
 - [Documentation](#documentation) — DOC3-DOC35 · 29
 - [Release pipeline](#release-pipeline) — REL1-REL9 · 9
@@ -6943,6 +6943,27 @@ Found 2026-11-04 while moving the cross-platform jobs' one-time test setup out o
 
 **Done when:** the test refuses a cyclic plan well inside the default timeout on a busy runner, by a Bun release that detects the cycle on the indented path as fast as on the plain one, or by a fence that refuses a cyclic plan before it serialises it, with the test kept.
 
+### U200. The web editor sends a run target that holds no code, which the extension and the statement analysis answer as nothing to run
+
+With the caret on a statement of comments only (`-- note` after `SELECT 1;`, or `SELECT 1; -- note` with the caret at the line's end), or with only a comment selected, `getEffectiveQuery` in `src/components/QueryEditor.tsx` answers the comment and `executeQuery` in `src/hooks/use-query-execution.ts` sends it to the engine; a text of blanks only is sent the same way.
+A target that is an unclosed block comment (`/* open` after `SELECT 1;`, with the caret at the end) is asked about first, with the notice that part of the statement could not be read, and then sent.
+The VS Code extension's `query/target` and `analyzeStatement` in `src/lib/editor/statement-analysis.ts` answer each of these with nothing to run, through `runnableTarget` in `src/lib/sql/run-target.ts`.
+`tests/unit/sql/run-target.test.ts` pins `runTarget`'s own answer for such text, and the parity test in `tests/unit/editor/statement-analysis.test.ts` holds the divergence case by case.
+The web cannot adopt `runnableTarget` alone: when the effective query is empty, `executeQuery` falls back to the tab's whole text.
+Found 2026-11-03 while designing the statement analysis for #2204.
+
+**Done when:** the web answers a target that holds no code with Nothing to run, through `runnableTarget`, and no empty effective query falls back to the tab text.
+
+### U201. The VS Code extension sends a statement the web editor refuses to `query/run` without a question
+
+The web editor asks `statementRefusal` (`src/lib/db/destructive-commands.ts`) before the confirmation gate, and on the nine connection types whose vocabulary row declares a refusal or a console text bound a refused statement is never sent or written to history (`src/hooks/use-query-execution.ts`).
+The extension's `query/target` in `vscode-extension/src/backend/handlers.ts` answers only the gate's verdict, and the host in `vscode-extension/src/host/editor/run-query.ts` sends a statement the gate does not flag to `query/run` without asking, where `checkEditorQuery` applies the console text bound but not the refusal, so only the provider's own guard stops it.
+Checked on 2026-11-04 with the shared functions: `isDangerousQuery` answers false and `statementRefusal` refuses both a Redis `GET a` with `DEL b` on the line after it and `kubectl delete pod web-1`; the Redis provider then refuses the first with the same sentence in `executeRedisCommand`, and the Kubernetes console refuses the second in `readKubectlRun` before any request.
+`analyzeStatement` in `src/lib/editor/statement-analysis.ts` answers both with `refuse`, but `query/target` has no field for a refusal and the host no way to show one.
+Found 2026-11-03 while designing the statement analysis for #2204.
+
+**Done when:** `query/target` answers the connection type's refusal, the host shows it and sends nothing, and a test drives Redis `GET a\nDEL b` and `kubectl delete pod web-1` through it.
+
 ## Dependencies
 
 ### P1. The desktop shell's `glib` advisory has no reachable fix while Tauri v2 targets GTK 3
 
@@ -88,7 +88,7 @@ The webview build swaps three imports for shims through `shimPlugin` in `scripts
 | Connection profiles and secrets | `src/host/connections/profile.ts` (`readProfiles`, `toEntry`, `toWireConnection`), `connection-store.ts` (`ConnectionStore`), `secret-keys.ts` (`secretKey`, `SECRET_PATHS`) | `src/lib/storage/secret-fields.ts` (`secretFieldValues`, `withoutSecretFields`, `withSecretFieldValues` and its field classification maps), `EXTERNAL_DATABASE_TYPES` in `src/lib/db/compatibility.ts` | The profile sits in the `libredb.connections` setting; every secret sits in SecretStorage |
 | Add Connection | `src/host/connections/add-connection-flow.ts` (`AddConnectionFlow`, a pure state machine), `add-connection-ui.ts` (`addConnection`), `field-prompts.ts` (`FIELD_PROMPTS`), `src/backend/engine-catalog.ts` (`engineCatalog`) | `CONNECTION_FORM`, `CONNECTION_PICKER_ORDER` and the `connectionField*` helpers in `src/lib/db/connection-form.ts`, `CONNECTION_FIELDS` and `PLACEABLE_FIELDS` in `src/lib/db/connection-fields.ts`, `CONNECTION_STRING` in `src/lib/db/connection-string`, `parseConnectionString` in `src/lib/connection-string-parser.ts`, `PASTE_FORMATS_TEXT` in `src/lib/connection-paste-formats.ts` (the catalogue's `pasteFormats`, so the host bundles no provider), `testConnection` in `src/lib/api/test-connection.ts`, `newLocalId` in `src/lib/ids.ts` | The flow names no engine: every per-engine fact comes from the `engines/list` catalogue |
 | Connections tree | `src/host/tree/connections-tree.ts` (`ConnectionsTree`), `nodes.ts`, `tree-items.ts`, `icons.ts` | The kind helpers in `src/lib/db/object-kinds.ts` (`containerDepth`, `enumerableKinds`, `findKind`, `kindGroup`, ...), and in the child the provider methods `listContainers`, `countObjects`, `listObjects`, `describeObject` | Levels, folders and labels come from the provider's capabilities, recorded in `OpenConnections` |
-| Editor binding, Run, Cancel, status bar | `src/host/editor/` (`BindingStore`, `RunRegistry`, `RunService`, `runQuery`, `newQuery`, `selectRows`, `cancelQuery`, `changeConnection`, `ConnectionStatusBar`, `ContextKeys`, `DocumentLifecycle`) | In the child: `runTarget` in `src/lib/sql/run-target.ts`, `isDangerousQuery` in `src/lib/sql/dangerous-query.ts`, `resolveSqlGrammar`, `countCodeStatements`, `generateTableQuery` in `src/lib/query-generators.ts`, `editorLanguageForTabType` in `src/lib/editor/tab-language.ts` | Bindings live in memory only, so a window reload forgets them |
+| Editor binding, Run, Cancel, status bar | `src/host/editor/` (`BindingStore`, `RunRegistry`, `RunService`, `runQuery`, `newQuery`, `selectRows`, `cancelQuery`, `changeConnection`, `ConnectionStatusBar`, `ContextKeys`, `DocumentLifecycle`) | In the child: `runnableTarget` in `src/lib/sql/run-target.ts`, `isDangerousQuery` in `src/lib/sql/dangerous-query.ts`, `resolveSqlGrammar`, `generateTableQuery` in `src/lib/query-generators.ts`, `editorLanguageOf` in `src/lib/editor/tab-language.ts` | Bindings live in memory only, so a window reload forgets them |
 | Backend handlers and registry | `src/backend/handlers.ts` (`createHandlers`, `registerHandlers`, `toResponseError`), `registry.ts` (`ConnectionRegistry`), `start.ts` (`startBackend`), `main.ts` | `getOrCreateProvider`, `removeProvider`, `clearProviderCache`, `enabledProviderTypes` in `src/lib/db/factory.ts`; `checkEditorQuery` and `runEditorQuery` in `src/lib/api/editor-query.ts`; `databaseErrorBody` and `internalErrorBody` in `src/lib/api/error-body.ts`; `supportsQueryCancel`, `scopeToCatalog`, `executionUiFor` | `query/run` re-does the steps of `POST /api/db/query` for one statement through the same functions |
 | Backend lifecycle | `src/host/backend-supervisor.ts` (`BackendSupervisor`), `fork-options.ts`, `channel.ts` (`ENABLED_PROVIDERS`) | None; `RESTART_DELAYS_MS` copies `desktop/src-tauri/src/backoff.rs` | |
 | JSON-RPC protocol | `src/protocol.ts` (`BackendApi`, `METHODS`, `PROTOCOL_VERSION`), `src/host/backend-client.ts` (`BackendClient`, `BackendError`) | Types only (`DatabaseConnection`, `ProviderCapabilities`, `EditorQueryBody`, `ApiErrorCode`, ...) | Every Studio import in `protocol.ts` is type-only, so it adds no provider code to the host |
@@ -195,7 +195,7 @@ Step by step, with the code that does it:
 1. `runQuery` in `src/host/editor/run-query.ts` finds the editor, reads its binding from `BindingStore` (or binds it through `pickConnection`), refuses a second run in the same document with `ALREADY_RUNNING`, and reads `libredb.query.rowLimit` (1 to 10000, default 500) with `readRowLimit`.
 2. `RunRegistry.prepare` registers a preparing run with its own cancellation token, so Cancel works even while the connection opens.
 3. `BackendClient.ensureOpen` returns the connection's `ProviderDescription`, opening it first when needed; where the capabilities declare catalog sessions, the person picks a catalog once per binding.
-4. `query/target` sends the whole text, the selection and the cursor; the child applies the web editor's run target rule (`runTarget`) with the engine's grammar, and an empty target becomes "Nothing to run.".
+4. `query/target` sends the whole text, the selection and the cursor; the child applies the web editor's run target rule through `runnableTarget`, with the engine's grammar and the editor language `editorLanguageOf` reads from its capabilities, and a target that holds no code becomes "Nothing to run.".
    The answer also says whether the web editor would ask before running that statement: the child reads it with `isDangerousQuery` under the connection's type, the gate behind the web editor's Query Safety dialog.
    The range that will run is highlighted for one second, and a statement the gate flags then asks in a modal `showWarningMessage` that shows it and offers Run Anyway; Cancel or Escape runs nothing.
 5. `RunService.execute` mints a fresh `queryId`, turns the preparing run into a running `RunEntry`, tells the presenter, and sends `query/run` inside a progress shown on the Results view.
@@ -370,6 +370,7 @@ Select Rows asks the child for `objects/selectStatement`, which writes the state
 - **No login or roles.** The extension serves one person's VS Code: no host or backend code signs anyone in or checks a role, and the host bundle check refuses `src/lib/config/auth-env.ts`.
 - **No storage layer or sync.** Connections are the setting plus SecretStorage, not `src/lib/storage`; the webview's `@/lib/storage` shim throws on any use; editor bindings are in memory only.
 - **A plainer dangerous-query confirmation.** The statement is read by the web editor's own `isDangerousQuery`, but the question is one modal button: no AI risk analysis, and no typed confirmation where the web editor asks for one (an etcd range delete or lease revoke).
+  Nor does Run apply the connection type's refusal: a statement the web editor refuses before sending it (a Redis `GET a` with `DEL b` on the line after it, or `kubectl delete pod web-1`) reaches `query/run` without a question, and only the provider's own guard stops it (`docs/BACKLOG.md` U201).
   Select Rows and Load More ask nothing: the first runs the read the engine's generator built for the object (a SELECT, a find, a `get`, an `aws s3 ls`), and the second reads more pages of a statement already confirmed.
   That differs from the web editor on purpose, whose table click goes through the gate, so a generated read on an object whose name the gate cannot read safely (a ClickHouse table named `a$$b`) asks there and not here.
 - **No query events or governance.** The child bundle refuses `src/lib/governance/start.ts` and `src/lib/query-events/sink.ts`, and `query/run` runs no admission gate.
 
@@ -644,7 +644,7 @@ So the next user's command does not fail, it silently does not happen, and the s
 **WHICH CALLERS END IT, AND WHY THAT CHANGED.** The surface now has TWO callers in the product,
 `POST /api/db/multi-query` and `POST /api/db/query`, each awaiting it in a `finally` under a call
 scope of its own. **The editor never sends a Redis buffer to the first of those.**
-`use-query-execution.ts` gates the multi-statement route on `dialectIsSql`, read from
+`use-query-execution.ts` gates the multi-statement route on `runsAsScript`, read from
 `queryLanguage`, and this provider declares `json` (§9), so an editor run goes to
 `POST /api/db/query` (§12.2).
 
 
@@ -16,9 +16,8 @@ import { useReturnFocus } from "@/hooks/use-return-focus";
 import { QUERY_SAFETY_ANALYSIS_TIMEOUT_MS } from "@/lib/llm/query-safety";
 import { cn } from "@/lib/utils";
 import { vocabularySendsToModel, vocabularyTypedConfirmation } from "@/lib/db/destructive-commands";
-import type { TypedConfirmationAsk } from "@/lib/db/types";
-import { readsSqlText, resolveSqlGrammar } from "@/lib/sql/grammar";
-import { hasLoneCarriageReturnInLineComment, hasUnterminatedSpan } from "@/lib/sql/spans";
+import { typedConfirmationExpected } from "@/lib/editor/statement-analysis";
+import { hasUnreadableRun } from "@/lib/sql/dangerous-query";
 import type { DatabaseType } from "@/lib/types";
 
 // The gate lives in `@/lib/sql/dangerous-query` so the VS Code extension's child, which bundles no component, asks
@@ -87,16 +86,6 @@ const MISSING_CONNECTION_NAME =
 const LOCAL_CLASSIFICATION =
   "This editor checked the statement itself: statements for this engine are not sent to an AI provider for a risk analysis.";
 
-/**
- * The text a typed ask is compared with: the ask's own text, or the connection's name, or undefined where the ask is
- * the name and there is none to type, which the dialog answers with MISSING_CONNECTION_NAME.
- */
-function typedConfirmationText(ask: TypedConfirmationAsk, connectionName: string | undefined): string | undefined {
-  if (ask.type === "text") return ask.text;
-  // An empty name is no name: an exact comparison would let an empty field confirm it.
-  return connectionName === "" ? undefined : connectionName;
-}
-
 /**
  * Why the dialog stopped waiting for the AI analysis before it answered: the person chose to skip it, or it did not
  * finish within QUERY_SAFETY_ANALYSIS_TIMEOUT_MS. Either way Execute no longer waits on it.
@@ -191,25 +180,23 @@ export function QuerySafetyDialog({
    *
    * Memoised because the analysis stream re-renders this component per chunk while
    * the query text does not change, and the scan is linear in that text.
+   *
+   * The gate's own predicate, so the notice and the gate cannot disagree; it answers
+   * false where the text is not SQL, which this notice must never call unreadable.
    */
-  const unreadableRun = useMemo(() => {
-    const type = databaseType as DatabaseType | undefined;
-    // Asked first: a SQL span reader's verdict about text that is not SQL is not
-    // evidence of anything, and saying "could not be read" about a Mongo document
-    // that reads fine is the false alarm this notice exists to avoid.
-    const grammar = resolveSqlGrammar(type);
-    return (
-      readsSqlText(type) && (hasUnterminatedSpan(query, grammar) || hasLoneCarriageReturnInLineComment(query, grammar))
-    );
-  }, [query, databaseType]);
+  const unreadableRun = useMemo(
+    () => hasUnreadableRun(query, databaseType as DatabaseType | undefined),
+    [query, databaseType],
+  );
 
   // What this engine's vocabulary asks the person to type before the statement runs, read from the table the gate
   // that opened this dialog read, so the two cannot disagree about a statement (#1089, section 5.5).
   const typedAsk = useMemo(
     () => vocabularyTypedConfirmation(databaseType as DatabaseType | undefined, query),
     [query, databaseType],
   );
-  const typedExpected = typedAsk === undefined ? undefined : typedConfirmationText(typedAsk, connectionName);
+  // Undefined where the ask is the connection's name and there is none to type, answered with MISSING_CONNECTION_NAME.
+  const typedExpected = typedAsk === undefined ? undefined : typedConfirmationExpected(typedAsk, connectionName);
   // Proceed waits for the analysis and for an exact match, and a refusal in place of the field is never a match,
   // whatever was typed before it replaced the field. The wait for the analysis is bounded: Skip ends it at once and
   // QUERY_SAFETY_ANALYSIS_TIMEOUT_MS ends it anyway, so a slow or hung model can no longer hold every write back.