From 60eed0b85edd9cbc8cf05c18aed354325a83a0a7 Mon Sep 17 00:00:00 2001
From: czyt <czytcn@gmail.com>
Date: Fri, 16 Oct 2026 14:49:43 +0800
Subject: [PATCH 1/3] Define Data query pre scripts and saved editor contract

---
 crates/core/src/data.rs                       | 17 +++++
 crates/formats/src/redact.rs                  |  2 +
 crates/formats/tests/interchange.rs           |  2 +-
 docs/specs/data-query-pre-scripts.md          | 24 +++++++
 .../data-query-pre-scripts-plan.md            | 68 +++++++++++++++++++
 web/src/features/data/DataWorkbench.test.tsx  |  9 +++
 web/src/features/data/DataWorkbench.tsx       |  4 +-
 web/src/features/data/model.ts                |  2 +-
 web/src/features/data/types.ts                |  2 +-
 web/src/shared/i18n/en.json                   |  3 +
 web/src/shared/i18n/zh-CN.json                |  3 +
 11 files changed, 132 insertions(+), 4 deletions(-)
 create mode 100644 docs/specs/data-query-pre-scripts.md
 create mode 100644 tasks/implementation/data-query-pre-scripts-plan.md

diff --git a/crates/core/src/data.rs b/crates/core/src/data.rs
index 419f8c8c..10467af3 100644
--- a/crates/core/src/data.rs
+++ b/crates/core/src/data.rs
@@ -29,6 +29,7 @@ pub enum DataFileFormat {
 pub struct DataConfig {
     pub source: DataSource,
     pub sql: String,
+    pub query_pre_script: String,
     pub file_name: String,
     pub file_format: DataFileFormat,
     pub sheet_name: String,
@@ -44,6 +45,7 @@ impl Default for DataConfig {
         Self {
             source: DataSource::Postgresql,
             sql: "SELECT 1 AS value".into(),
+            query_pre_script: String::new(),
             file_name: String::new(),
             file_format: DataFileFormat::Csv,
             sheet_name: String::new(),
@@ -57,6 +59,7 @@ impl Default for DataConfig {
     }
 }
 pub fn validate_data_config(config: &DataConfig) -> Result<()> {
+    crate::validate_script(&config.query_pre_script)?;
     ensure!(
         config.sql.len() <= MAX_SQL_SOURCE && !config.sql.contains('\0'),
         "Data SQL source exceeds limits"
@@ -221,6 +224,20 @@ pub fn data_url(raw: &str, source: DataSource) -> Result<Url> {
 mod tests {
     use super::*;
     #[test]
+    fn query_pre_script_defaults_and_obeys_shared_script_limit() {
+        let legacy: DataConfig =
+            serde_json::from_value(serde_json::json!({"sql":"SELECT 1"})).unwrap();
+        assert!(legacy.query_pre_script.is_empty());
+        let mut configured = legacy;
+        configured.query_pre_script = "x".repeat(crate::MAX_SCRIPT_BYTES);
+        validate_data_config(&configured).unwrap();
+        let copied: DataConfig =
+            serde_json::from_value(serde_json::to_value(&configured).unwrap()).unwrap();
+        assert_eq!(copied.query_pre_script, configured.query_pre_script);
+        configured.query_pre_script.push('x');
+        assert!(validate_data_config(&configured).is_err());
+    }
+    #[test]
     fn retains_selected_file_and_sql_but_rejects_hidden_network_options() {
         let config = DataConfig {
             source: DataSource::LocalFile,
diff --git a/crates/formats/src/redact.rs b/crates/formats/src/redact.rs
index d616c6d3..1026b1e3 100644
--- a/crates/formats/src/redact.rs
+++ b/crates/formats/src/redact.rs
@@ -522,6 +522,8 @@ pub(super) fn workspace(source: &Workspace) -> Workspace {
                     request.url = data_privacy.screen_text(&redact_url(&request.url));
                     config.file_base64.clear();
                     config.sql = data_privacy.screen_generation_text(&config.sql);
+                    config.query_pre_script = data_privacy
+                        .screen_bounded(&config.query_pre_script, moleapi_core::MAX_SCRIPT_BYTES);
                     config.file_name = data_privacy.screen_text(&config.file_name);
                     config.table_name = data_privacy.screen_text(&config.table_name);
                 }
diff --git a/crates/formats/tests/interchange.rs b/crates/formats/tests/interchange.rs
index 069ce2c0..41c4a5ab 100644
--- a/crates/formats/tests/interchange.rs
+++ b/crates/formats/tests/interchange.rs
@@ -761,7 +761,7 @@ fn data_request_exports_screen_credentials_copied_sql_and_keep_explicit_original
         sql: "SELECT 'it''s-private' AS copied".into(),
         ..Default::default()
     };
-    let request:moleapi_core::RequestSpec=serde_json::from_value(json!({"id":"data","name":"Data request","protocol":{"kind":"data","source":"postgresql","sql":config.sql},"method":"GET","url":"postgresql://user:it%27s-private@db.example/main","description":"","query":[],"headers":[],"body_kind":"none","body":"","auth":{"kind":"none","token":"","username":"","password":""},"timeout_ms":1000,"verify_tls":true,"follow_redirects":false,"assertions":[],"examples":[]})).unwrap();
+    let request:moleapi_core::RequestSpec=serde_json::from_value(json!({"id":"data","name":"Data request","protocol":{"kind":"data","source":"postgresql","sql":config.sql,"query_pre_script":"pm.request.body.update(\"SELECT 'it''s-private'\")"},"method":"GET","url":"postgresql://user:it%27s-private@db.example/main","description":"","query":[],"headers":[],"body_kind":"none","body":"","auth":{"kind":"none","token":"","username":"","password":""},"timeout_ms":1000,"verify_tls":true,"follow_redirects":false,"assertions":[],"examples":[]})).unwrap();
     let mut w=workspace(serde_json::from_value(json!({"schema_version":1,"collections":[{"id":"c","name":"Data","description":"","requests":[request]}],"environments":[],"active_environment_id":null})).unwrap());
     let format = "moleapi";
     {
diff --git a/docs/specs/data-query-pre-scripts.md b/docs/specs/data-query-pre-scripts.md
new file mode 100644
index 00000000..cb4e28b3
--- /dev/null
+++ b/docs/specs/data-query-pre-scripts.md
@@ -0,0 +1,24 @@
+# Data per-query preparation
+
+Authority: `data-client.md`, `data-query-completion.md`, remaining-work milestone 3, and the shared `moleapi-pm/1` script and variable contracts.
+
+## Objective
+
+The Data workbench currently runs the inherited pre-request script once when it opens a connection. Subsequent SQL submissions use the editor text directly. Add a separate saved **query pre script** so each explicit Data query can prepare scoped variables, edit its SQL and report its own tests/logs before the SQL operation starts. Connection preparation retains its current behavior; an existing saved Data request with no query script behaves exactly as before.
+
+## User and API contract
+
+- `DataConfig.query_pre_script` is an optional string, defaulting to empty, limited to the same 256 KiB script budget as other request scripts. Existing imports and saved requests without the field continue to load. The Data editor shows it in a dedicated tab while disconnected and connected; edits are saved with the request but a running session uses the connection-time snapshot until reconnect.
+- Each accepted `data_query` carries a query ID, selected SQL, and read-only flag. The server presents the selected SQL to the isolated script worker as `pm.request.body.raw` in text mode. The script can set variables through existing scope APIs and replace SQL with `pm.request.body.update(...)`. It can log and test. `pm.response` is absent. The output SQL is resolved against the updated scoped values and then checked against the existing 64 KiB, single-statement, dialect, read-only/write and execution budgets. The script cannot change connection URL/auth, headers, method, protocol/source, file selection or read-only flag. Reject an attempted unsupported mutation before dispatching SQL.
+- Only one query preparation or execution is active per Data session. The next pre script waits for the previous query's response postprocessing to finish so it sees the prior script/extraction variable updates. An explicit cancel during preparation stops the preparation and emits a query-scoped cancelled/preparation error outcome without dispatching SQL. Failed/oversized/invalid pre script or SQL resolution emits `data_preprocess_error` with query ID and masked details, and must not run or retry SQL. `pm.skipRequest()` means no SQL and an explicit skipped result. No history record is created for a query that never reached the Data worker.
+- Successful preparation emits a `data_prepared` event with the query ID, safe SQL preview or change indicator, tests/logs and non-private variable update metadata. The Data workbench displays preparation status before live rows and keeps it attached to the correct query; it does not silently edit the saved SQL draft. The actual resolved SQL source is passed to the protocol worker and retained by the existing completion/history path.
+
+## Ownership, privacy and limits
+
+- Recheck session, account, workspace/request identity and owner admission generation before running the script and before dispatch. Logout, session deletion, workspace deletion or a changed owner generation prevents SQL dispatch and later variable updates. The script worker has its existing 250 ms deadline, 64 MiB heap, disabled network/filesystem and 8 MiB output cap. The prepared SQL is revalidated by the protocol runtime; neither the script nor the API bypasses its SQL AST policy.
+- Script output and pre error details are masked using the captured private values. New private values from the script are added to the session scope before later postprocessing and history screening. A script failure with incomplete privacy metadata withholds diagnostic text. The bounded Data session event budget remains authoritative.
+- Busy or full Data sessions reject before script side effects. Each accepted query ID produces at most one SQL dispatch and one terminal preparation result. SQL writes are never retried or called rolled back on cancellation.
+
+## Evidence
+
+Use actual local file and hosted PostgreSQL/MySQL workers to prove variable substitution, SQL mutation, one pre run per query, ordering with post updates, skip/failure/cancel with zero SQL dispatches, read-only policy, privacy masking, owner/logout/delete fencing, script budget, and history SQL source. Verify the bilingual editor and preparation status at 390px. Run Rust and frontend suites, strict Clippy, formatting, production/embedded build, then branch CI and platform gates. Saved datasets, extra Data sources and EDAS remain separate capabilities.
diff --git a/tasks/implementation/data-query-pre-scripts-plan.md b/tasks/implementation/data-query-pre-scripts-plan.md
new file mode 100644
index 00000000..ab167718
--- /dev/null
+++ b/tasks/implementation/data-query-pre-scripts-plan.md
@@ -0,0 +1,68 @@
+# Data per-query pre scripts implementation plan
+
+> **For agentic workers:** Execute each numbered task in order with a failing integration test before its implementation. Use `executing-plans` for inline work. Keep the one final independent branch review.
+
+**Goal:** Run a saved isolated script before every accepted Data SQL query, with safe SQL mutation and scoped variables.
+
+**Architecture:** Keep connection-time scripts as they are. Add a bounded query-pre script field to `DataConfig`, and a server-owned per-session preparation context shared by the send handler and Data completion consumer. Split the protocol's Data query admission from queue dispatch, so a script runs only after one query ID has reserved the active slot; cancellation can abort preparation without SQL. The output SQL is resolved and checked again by the existing Data worker.
+
+**Tech Stack:** Rust/Tokio/Axum, `moleapi-pm/1` QuickJS worker, React/TypeScript, Vitest, local DataFusion file worker and hosted PostgreSQL/MySQL.
+
+**Spec:** `docs/specs/data-query-pre-scripts.md`
+
+## Global constraints
+
+- Preserve the old connection-time pre script and empty-field request behavior.
+- Keep SQL at 64 KiB, scripts at 256 KiB and the 250 ms isolated worker deadline.
+- Never dispatch SQL before owner/session/admission checks or after a failed script. Never retry writes.
+- Reuse Data AST/read-only checks and shared variable/privacy helpers.
+
+## Tasks
+
+### Task 1: Saved contract and editor
+
+**Files:** `crates/core/src/data.rs`, `web/src/features/data/types.ts`, `web/src/features/data/DataWorkbench.tsx`, bilingual dictionaries, core and web Data tests.
+
+- [ ] Add a core serialization/validation test: old Data JSON defaults to an empty script, and a script over 256 KiB is rejected before persistence. Run it red.
+- [ ] Add `query_pre_script` to `DataConfig` and the frontend type with the empty default and cap; run the test green.
+- [ ] Add a Data workbench script tab with a labelled editor that stays editable while connected but documents reconnect-to-apply. Add a saved/reloaded editor test and inspect 390px Chinese/English.
+- [ ] Run `cargo test -p moleapi-core data` and the focused Vitest files; commit the contract and editor.
+
+### Task 2: Protocol reservation
+
+**Files:** `crates/protocols/src/data.rs`, `crates/protocols/src/lib.rs`, `crates/protocols/src/models.rs`, `crates/server/tests/data_client.rs`.
+
+- [ ] Add a failing real-worker test where two sends race, one preparation is cancelled, and a rejected query never emits `data_started` or SQL rows.
+- [ ] Expose owner-scoped `reserve_data_query` and `dispatch_reserved_data_query` around the current one-active-query, 512-command and 20 MiB limits. Cancellation and failure release a reservation exactly once.
+- [ ] Keep the worker's SQL validation after dispatch and its existing terminal completion behavior. Run the new test and all Data client tests; commit.
+
+### Task 3: Server preparation and privacy
+
+**Files:** `crates/server/src/protocols.rs`, `crates/server/src/execution.rs`, `crates/server/src/lib.rs`, Data client and database integration tests.
+
+- [ ] Add a failing local CSV test: per-query script changes SQL from the selected text, runs once on each query, and query N+1 reads N's post-script variable update.
+- [ ] Share session scopes with an async lock between the send handler and completion consumer. Capture request/collection/workspace and owner generation at connect, then run the isolated script on a synthetic text-body request.
+- [ ] Reject changes to URL/auth, method, headers, protocol/source, file selection and read-only mode; accept only SQL/body and scoped variable updates. Validate/resolve the output SQL before dispatch. Return query-scoped prepared, skipped or masked error events without history for unexecuted SQL.
+- [ ] Add failing tests for script deadline/privacy failure, invalid SQL/mutation, owner logout/workspace deletion and cancellation during preparation. Make them pass, then run the Data and database suites; commit.
+
+### Task 4: Workbench result flow
+
+**Files:** `web/src/features/data/useDataEvents.ts`, `web/src/features/data/DataWorkbench.tsx`, `web/src/features/data/types.ts`, focused Vitest files and dictionaries.
+
+- [ ] Add a failing hook test for stale preparation events and cancel/error releasing the run button.
+- [ ] Display query preparation status/tests/logs before rows, retain them with the matching result and never rewrite the saved SQL draft.
+- [ ] Run focused Vitest and browser QA at 390px in both languages against a real CSV fixture; commit.
+
+### Task 5: Gates and review
+
+- [ ] Run `cargo fmt -- --check`, `cargo test --locked`, `cargo clippy --locked --all-targets -- -D warnings`, `npm --prefix web test`, and `npm --prefix web run build`.
+- [ ] Verify hosted PostgreSQL/MySQL SQL mutation and read-only enforcement in Application CI, then track the current platform build and perform one independent whole-branch review.
+- [ ] Update `docs/FEATURE-MATRIX.md`, `docs/IMPLEMENTATION-STATUS.md` and the remaining-work plan with exact supported combinations and still-open saved dataset/source/EDAS gates.
+
+## Review focus
+
+- A script changes the Data source, URL/auth, headers or read-only flag: fail before SQL and mask private diagnostics.
+- Two simultaneous sends or a cancel while the worker is starting: at most one SQL dispatch, no stranded active query.
+- Postprocessing of query N overlaps preparation of N+1: N+1 sees N's scoped updates without leaking them into saved drafts.
+- A script worker times out or loses privacy metadata: no SQL dispatch and no unmasked output.
+- Logout, workspace deletion or session removal during preparation: no late dispatch, history or cross-owner event.
diff --git a/web/src/features/data/DataWorkbench.test.tsx b/web/src/features/data/DataWorkbench.test.tsx
index c2ec8a0f..e1671b63 100644
--- a/web/src/features/data/DataWorkbench.test.tsx
+++ b/web/src/features/data/DataWorkbench.test.tsx
@@ -8,7 +8,16 @@ vi.mock("../workbench/context",()=>({useWorkbench:vi.fn()}));
 vi.mock("./DataSourceFields",()=>({DataSourceFields:()=>null}));
 vi.mock("./DataResults",()=>({DataResults:()=>null}));
 vi.mock("./DataSqlEditor",()=>({DataSqlEditor:()=>null}));
+vi.mock("../../shared/ui",()=>({Editor:({label,value,onChange}:{label:string;value:string;onChange:(value:string)=>void})=><textarea aria-label={label} value={value} onChange={event=>onChange(event.target.value)}/> }));
 afterEach(cleanup);
+it("saves a dedicated query pre script while a Data session is connected",()=>{
+  const value=state();
+  vi.mocked(useWorkbench).mockReturnValue(value as unknown as ReturnType<typeof useWorkbench>);
+  render(<DataWorkbench/>);
+  fireEvent.mouseDown(screen.getByRole("tab",{name:/查询前脚本/}),{button:0,ctrlKey:false});
+  fireEvent.change(screen.getByRole("textbox",{name:"查询前 JavaScript 脚本"}),{target:{value:"pm.request.body.update('SELECT 2')"}});
+  expect(value.updateRequest).toHaveBeenCalledWith({protocol:expect.objectContaining({query_pre_script:"pm.request.body.update('SELECT 2')"})});
+});
 function state() {return {authenticated:true,accountId:"first",selectedId:"workspace",draft:{id:"workspace",data:{active_environment_id:"dev"}},request:{id:"request",protocol:dataConfig()},dark:false,updateRequest:vi.fn(),dataRun:{current:null as (()=>void)|null},protocolSession:{session:{id:"session",state:"open"},events:[],send:vi.fn<(_message:unknown)=>Promise<boolean>>().mockResolvedValue(true),connect:vi.fn(),close:vi.fn(),busy:false,sending:false,error:"",dropped:0}};}
 it("a late rejected admission cannot clear the new scope's active query",async()=>{
   const value=state();const pending:((ok:boolean)=>void)[]=[];
diff --git a/web/src/features/data/DataWorkbench.tsx b/web/src/features/data/DataWorkbench.tsx
index f356f3c1..c582ad69 100644
--- a/web/src/features/data/DataWorkbench.tsx
+++ b/web/src/features/data/DataWorkbench.tsx
@@ -3,6 +3,7 @@ import {Badge,Button,Callout,Flex,Heading,Tabs,Text,TextField} from "@radix-ui/t
 import {Play,Square,RefreshCw,WandSparkles} from "lucide-react";
 import {t,useLanguage,translateCopy} from "../../shared/i18n";
 import {errorCopy,type ErrorCopy} from "../../shared/i18n/errors";
+import {Editor} from "../../shared/ui";
 import {useWorkbench} from "../workbench/context";
 import {DataSourceFields} from "./DataSourceFields";
 import {DataSqlEditor} from "./DataSqlEditor";
@@ -34,9 +35,10 @@ export default function DataWorkbench(){
     <DataSourceFields key={`${state.accountId}/${state.selectedId}/${state.request?.id}/${state.draft?.data.active_environment_id}`} config={config} change={change} connected={connected}/>
     {problem&&<Callout.Root color="red" role="alert"><Callout.Text>{problem}</Callout.Text></Callout.Root>}
     {channel.session?.reason&&<Text color="gray" size="1">{channel.session.reason}</Text>}
-    <Tabs.Root value={tab} onValueChange={setTab} className="data-tabs"><Tabs.List><Tabs.Trigger value="query">{t("查询")}</Tabs.Trigger><Tabs.Trigger value="view">{t("数据视图")}</Tabs.Trigger></Tabs.List>
+    <Tabs.Root value={tab} onValueChange={setTab} className="data-tabs"><Tabs.List><Tabs.Trigger value="query">{t("查询")}</Tabs.Trigger><Tabs.Trigger value="pre">{t("查询前脚本")}</Tabs.Trigger><Tabs.Trigger value="view">{t("数据视图")}</Tabs.Trigger></Tabs.List>
       <Tabs.Content value="query"><div className="data-query-layout"><aside className="data-schema" aria-label={t("数据结构浏览器")}><Flex gap="2" align="center" justify="between"><Text size="2" weight="medium">{t("数据结构")}</Text><Button size="1" variant="ghost" disabled={!open||!!model.active||channel.sending} aria-label={t("刷新数据结构")} onClick={()=>void channel.send({kind:"data_schema_refresh"})}><RefreshCw size={14}/></Button></Flex><TextField.Root value={search} onChange={e=>setSearch(e.target.value)} placeholder={t("搜索表和列")} aria-label={t("搜索表和列")}/>{model.schemaTruncated&&<Text size="1" color="gray">{t("仅显示部分结构，查询仍可直接使用完整表名。")}</Text>}{model.tables.filter(table=>!search||`${table.schema}.${table.name} ${table.columns.map(c=>c.name).join(" ")}`.toLowerCase().includes(search.toLowerCase())).map((table,index)=><details key={`${table.schema}/${table.name}/${index}`}><summary>{table.schema?`${table.schema}.`:""}{table.name}</summary><Button size="1" variant="ghost" onClick={()=>change({sql:`${config.sql.trim()}\nSELECT * FROM ${table.reference} LIMIT 100;`})}>{t("添加表查询")}</Button>{table.columns.map((column,index)=><button className="data-schema-column" key={`${column.name}/${index}`} onClick={()=>change({sql:config.sql+`\nSELECT ${column.reference} FROM ${table.reference} LIMIT 100;`})}><span>{column.name}</span><Text size="1" color="gray">{column.data_type}{column.nullable?" · NULL":""}</Text></button>)}</details>)}</aside>
         <div className="data-editor-panel"><Flex gap="3" align="center" wrap="wrap"><Button disabled={!open||!!model.active||channel.sending} onClick={()=>void run()}><Play size={14}/>{t("运行当前查询")}</Button><Button variant="soft" disabled={!model.active||channel.sending} onClick={()=>model.active&&void channel.send({kind:"data_cancel",query_id:model.active})}>{t("取消查询")}</Button><Button variant="ghost" color="gray" onClick={format}><WandSparkles size={14}/>{t("格式化 SQL")}</Button></Flex><Text size="1" color="gray">{t("运行光标所在的语句；有选区时仅运行选区。连接环境修改后重连生效。")}</Text><DataSqlEditor run={()=>dispatch.current()} value={config.sql} change={sql=>change({sql})} source={config.source} tables={model.tables} dark={state.dark} selection={(from,to)=>{selection.current={from,to};}}/></div></div></Tabs.Content>
+      <Tabs.Content value="pre"><Flex direction="column" gap="2"><Text size="2" color="gray">{t("每条查询前运行此脚本；可用 pm.request.body.update() 修改本次 SQL。修改脚本后重连生效。")}</Text><Editor label={t("查询前 JavaScript 脚本")} value={config.query_pre_script} onChange={query_pre_script=>change({query_pre_script})} dark={state.dark} language="javascript" height="220px"/></Flex></Tabs.Content>
       <Tabs.Content value="view"><Flex gap="3" align="center" wrap="wrap"><Button size="1" variant="soft" disabled={!model.active||channel.sending} onClick={()=>model.active&&void channel.send({kind:"data_cancel",query_id:model.active})}>{t("取消查询")}</Button></Flex><DataResults result={model.result}/>
         {model.result?.done&&!model.processing&&!model.processingError&&<Text size="2" color="gray">{t("正在保存查询历史…")}</Text>}
         {model.processingError&&<Callout.Root color="red" role="alert"><Callout.Text>{model.processingError}</Callout.Text></Callout.Root>}
diff --git a/web/src/features/data/model.ts b/web/src/features/data/model.ts
index cee85668..1a9755f4 100644
--- a/web/src/features/data/model.ts
+++ b/web/src/features/data/model.ts
@@ -1,7 +1,7 @@
 import { PostgreSQL, MySQL, StandardSQL } from "@codemirror/lang-sql";
 import { format } from "sql-formatter";
 import type { DataConfig, DataSource, Cell } from "./types";
-export function dataConfig():DataConfig {return {kind:"data",source:"postgresql",sql:"SELECT 1 AS value",file_name:"",file_format:"csv",sheet_name:"",file_base64:"",table_name:"data",csv_header:true,read_only:true,tls:true,ca_pem:""};}
+export function dataConfig():DataConfig {return {kind:"data",source:"postgresql",sql:"SELECT 1 AS value",query_pre_script:"",file_name:"",file_format:"csv",sheet_name:"",file_base64:"",table_name:"data",csv_header:true,read_only:true,tls:true,ca_pem:""};}
 export function dialect(source:DataSource) {return source==="postgresql"?PostgreSQL:source==="mysql"?MySQL:StandardSQL;}
 /** Lezer owns SQL comments, quotes, statement boundaries, and cursor locations. */
 export function selectedStatement(document:string,source:DataSource,from:number,to=from):string {
diff --git a/web/src/features/data/types.ts b/web/src/features/data/types.ts
index 6d5c2a20..9d212061 100644
--- a/web/src/features/data/types.ts
+++ b/web/src/features/data/types.ts
@@ -1,5 +1,5 @@
 export type DataSource = "postgresql" | "mysql" | "local_file" | "remote_file";
-export interface DataConfig { kind:"data"; source:DataSource; sql:string; file_name:string; file_format:"csv"|"json"|"parquet"|"xlsx"; sheet_name:string; file_base64:string; table_name:string; csv_header:boolean; read_only:boolean; tls:boolean; ca_pem:string }
+export interface DataConfig { kind:"data"; source:DataSource; sql:string; query_pre_script:string; file_name:string; file_format:"csv"|"json"|"parquet"|"xlsx"; sheet_name:string; file_base64:string; table_name:string; csv_header:boolean; read_only:boolean; tls:boolean; ca_pem:string }
 export type Cell = {kind:"null"} | {kind:"bool";value:boolean} | {kind:"text"|"integer"|"decimal";value:string} | {kind:"binary";base64:string;bytes:number} | {kind:"truncated";preview:string;bytes:number};
 export interface DataColumn {name:string;data_type:string;nullable:boolean}
 export interface SchemaColumn extends DataColumn { reference:string }
diff --git a/web/src/shared/i18n/en.json b/web/src/shared/i18n/en.json
index 2648d806..e4bc02c3 100644
--- a/web/src/shared/i18n/en.json
+++ b/web/src/shared/i18n/en.json
@@ -1031,6 +1031,9 @@
   "数据查询": "Data queries",
   "TLS 未验证": "TLS unverified",
   "查询": "Query",
+  "查询前脚本": "Before query",
+  "查询前 JavaScript 脚本": "Before-query JavaScript",
+  "每条查询前运行此脚本；可用 pm.request.body.update() 修改本次 SQL。修改脚本后重连生效。": "Runs before each query. Use pm.request.body.update() to change this query's SQL. Reconnect to apply script edits.",
   "数据视图": "Data view",
   "数据结构浏览器": "Schema explorer",
   "数据结构": "Schema",
diff --git a/web/src/shared/i18n/zh-CN.json b/web/src/shared/i18n/zh-CN.json
index dd0f2f15..584fb832 100644
--- a/web/src/shared/i18n/zh-CN.json
+++ b/web/src/shared/i18n/zh-CN.json
@@ -1031,6 +1031,9 @@
   "数据查询": "数据查询",
   "TLS 未验证": "TLS 未验证",
   "查询": "查询",
+  "查询前脚本": "查询前脚本",
+  "查询前 JavaScript 脚本": "查询前 JavaScript 脚本",
+  "每条查询前运行此脚本；可用 pm.request.body.update() 修改本次 SQL。修改脚本后重连生效。": "每条查询前运行此脚本；可用 pm.request.body.update() 修改本次 SQL。修改脚本后重连生效。",
   "数据视图": "数据视图",
   "数据结构浏览器": "数据结构浏览器",
   "数据结构": "数据结构",

From 5bacc1968a0cf828c4b0c437d13872d031692abc Mon Sep 17 00:00:00 2001
From: czyt <czytcn@gmail.com>
Date: Fri, 16 Oct 2026 14:59:39 +0800
Subject: [PATCH 2/3] Reserve Data query slots before asynchronous preparation

---
 crates/protocols/src/data.rs | 201 ++++++++++++++++++++++++++++-------
 crates/protocols/src/lib.rs  |  11 +-
 2 files changed, 173 insertions(+), 39 deletions(-)

diff --git a/crates/protocols/src/data.rs b/crates/protocols/src/data.rs
index e6bb2c2a..8474e9a7 100644
--- a/crates/protocols/src/data.rs
+++ b/crates/protocols/src/data.rs
@@ -29,6 +29,107 @@ pub enum DataOutcome {
     Error(String),
     Cancelled { write_outcome_unknown: bool },
 }
+pub struct DataReservation {
+    session: Arc<Session>,
+    query_id: String,
+    stop: CancellationToken,
+    dispatched: bool,
+}
+impl DataReservation {
+    pub async fn cancelled(&self) {
+        tokio::select! { _ = self.stop.cancelled() => {}, _ = self.session.cancel.cancelled() => {} }
+    }
+    pub fn dispatch(mut self, sql: String, read_only: bool) -> Result<()> {
+        let mut record = self.session.record.lock().unwrap();
+        ensure!(
+            record.summary.state == SessionState::Open
+                && !self.session.cancel.is_cancelled()
+                && !self.stop.is_cancelled(),
+            "Data query was cancelled before dispatch"
+        );
+        ensure!(
+            !sql.trim().is_empty() && sql.len() <= moleapi_core::MAX_SQL_SOURCE,
+            "Data SQL query exceeds limits"
+        );
+        let mut control = self.session.data.lock().unwrap();
+        ensure!(
+            control
+                .active
+                .as_ref()
+                .is_some_and(|(id, _)| id == &self.query_id),
+            "Data query reservation expired"
+        );
+        ensure!(control.commands < 512, "Data command budget exceeded");
+        ensure!(
+            record.input.saturating_add(sql.len()) <= 20 * 1024 * 1024,
+            "Data command input budget exceeded"
+        );
+        let size = sql.len();
+        self.session
+            .commands
+            .try_send(Command::DataQuery {
+                query_id: self.query_id.clone(),
+                sql,
+                read_only,
+                stop: self.stop.clone(),
+            })
+            .context("Data command queue is full")?;
+        record.input += size;
+        control.commands += 1;
+        self.dispatched = true;
+        Ok(())
+    }
+}
+impl Drop for DataReservation {
+    fn drop(&mut self) {
+        if !self.dispatched {
+            let mut control = self.session.data.lock().unwrap();
+            if control
+                .active
+                .as_ref()
+                .is_some_and(|(id, _)| id == &self.query_id)
+            {
+                control.active = None;
+            }
+        }
+    }
+}
+pub(crate) fn reserve(
+    session: &Arc<Session>,
+    query_id: String,
+    sql: &str,
+) -> Result<DataReservation> {
+    let record = session.record.lock().unwrap();
+    ensure!(
+        record.summary.protocol == "data"
+            && record.summary.state == SessionState::Open
+            && !session.cancel.is_cancelled(),
+        "Data connection is not open"
+    );
+    ensure!(
+        !query_id.is_empty() && query_id.len() <= 128 && !query_id.chars().any(char::is_control),
+        "Invalid Data query ID"
+    );
+    ensure!(
+        !sql.trim().is_empty() && sql.len() <= moleapi_core::MAX_SQL_SOURCE,
+        "Data SQL query exceeds limits"
+    );
+    let mut control = session.data.lock().unwrap();
+    ensure!(control.active.is_none(), "A Data query is already running");
+    ensure!(control.commands < 512, "Data command budget exceeded");
+    ensure!(
+        record.input.saturating_add(sql.len()) <= 20 * 1024 * 1024,
+        "Data command input budget exceeded"
+    );
+    let stop = CancellationToken::new();
+    control.active = Some((query_id.clone(), stop.clone()));
+    Ok(DataReservation {
+        session: session.clone(),
+        query_id,
+        stop,
+        dispatched: false,
+    })
+}
 fn complete(
     session: &Session,
     query_id: String,
@@ -61,7 +162,15 @@ fn slots() -> Arc<Semaphore> {
     SLOTS.get_or_init(|| Arc::new(Semaphore::new(4))).clone()
 }
 pub(crate) fn send(session: &Arc<Session>, message: SendMessage) -> Result<()> {
-    let mut record = session.record.lock().unwrap();
+    if let SendMessage::DataQuery {
+        query_id,
+        sql,
+        read_only,
+    } = &message
+    {
+        return reserve(session, query_id.clone(), sql)?.dispatch(sql.clone(), *read_only);
+    }
+    let record = session.record.lock().unwrap();
     ensure!(
         record.summary.protocol == "data"
             && record.summary.state == SessionState::Open
@@ -77,43 +186,6 @@ pub(crate) fn send(session: &Arc<Session>, message: SendMessage) -> Result<()> {
             }
             Ok(())
         }
-        SendMessage::DataQuery {
-            query_id,
-            sql,
-            read_only,
-        } => {
-            ensure!(
-                !query_id.is_empty()
-                    && query_id.len() <= 128
-                    && !query_id.chars().any(char::is_control),
-                "Invalid Data query ID"
-            );
-            ensure!(
-                !sql.trim().is_empty() && sql.len() <= moleapi_core::MAX_SQL_SOURCE,
-                "Data SQL query exceeds limits"
-            );
-            ensure!(control.active.is_none(), "A Data query is already running");
-            ensure!(control.commands < 512, "Data command budget exceeded");
-            ensure!(
-                record.input.saturating_add(sql.len()) <= 20 * 1024 * 1024,
-                "Data command input budget exceeded"
-            );
-            let input_bytes = sql.len();
-            let stop = CancellationToken::new();
-            session
-                .commands
-                .try_send(Command::DataQuery {
-                    query_id: query_id.clone(),
-                    sql,
-                    read_only,
-                    stop: stop.clone(),
-                })
-                .context("Data command queue is full")?;
-            record.input += input_bytes;
-            control.active = Some((query_id, stop));
-            control.commands += 1;
-            Ok(())
-        }
         SendMessage::DataSchemaRefresh => {
             ensure!(control.active.is_none(), "A Data query is already running");
             ensure!(control.commands < 512, "Data command budget exceeded");
@@ -448,3 +520,56 @@ pub(crate) async fn run(
         }
     }
 }
+
+#[cfg(test)]
+mod reservation_tests {
+    use super::*;
+    use crate::{PreparedFeedback, SessionManager};
+    use serde_json::json;
+
+    #[tokio::test]
+    async fn cancelled_reservation_releases_capacity_without_dispatching_sql() {
+        let request:RequestSpec = serde_json::from_value(json!({"id":"data","name":"Data","method":"GET","url":"","description":"","query":[],"headers":[],"body_kind":"none","body":"","auth":{"kind":"none","token":"","username":"","password":""},"timeout_ms":1000,"verify_tls":true,"follow_redirects":false,"assertions":[],"examples":[],"protocol":{"kind":"data","source":"local_file"}})).unwrap();
+        let manager = SessionManager::default();
+        let summary = manager
+            .register(
+                "owner",
+                "workspace",
+                &request,
+                "safe".into(),
+                PreparedFeedback::default(),
+            )
+            .unwrap();
+        let session = manager.owned("owner", &summary.id).unwrap();
+        session.record.lock().unwrap().summary.state = SessionState::Open;
+        let reserved = manager
+            .reserve_data_query("owner", &summary.id, "first".into(), "SELECT 1")
+            .unwrap();
+        assert!(
+            manager
+                .reserve_data_query("owner", &summary.id, "second".into(), "SELECT 2")
+                .is_err()
+        );
+        send(
+            &session,
+            SendMessage::DataCancel {
+                query_id: "first".into(),
+            },
+        )
+        .unwrap();
+        tokio::time::timeout(Duration::from_millis(100), reserved.cancelled())
+            .await
+            .unwrap();
+        assert!(reserved.dispatch("SELECT 1".into(), true).is_err());
+        let next = manager
+            .reserve_data_query("owner", &summary.id, "second".into(), "SELECT 2")
+            .unwrap();
+        next.dispatch("SELECT 3".into(), true).unwrap();
+        let mut receiver = session.receiver.lock().unwrap().take().unwrap();
+        let command = receiver.try_recv().unwrap();
+        assert!(
+            matches!(command, Command::DataQuery { query_id, sql, .. } if query_id == "second" && sql == "SELECT 3")
+        );
+        assert!(receiver.try_recv().is_err());
+    }
+}
diff --git a/crates/protocols/src/lib.rs b/crates/protocols/src/lib.rs
index 27bc9c2f..c73dba4c 100644
--- a/crates/protocols/src/lib.rs
+++ b/crates/protocols/src/lib.rs
@@ -7,7 +7,7 @@ mod mqtt;
 mod tcp;
 pub use grpc::{ReflectionResult, ReflectionStatus, reflect};
 mod data;
-pub use data::{DataCompletion, DataOutcome};
+pub use data::{DataCompletion, DataOutcome, DataReservation};
 mod engine;
 mod graphql;
 mod models;
@@ -524,6 +524,15 @@ impl SessionManager {
         );
         session.event("system", message)
     }
+    pub fn reserve_data_query(
+        &self,
+        owner: &str,
+        id: &str,
+        query_id: String,
+        sql: &str,
+    ) -> Result<DataReservation> {
+        data::reserve(&self.owned(owner, id)?, query_id, sql)
+    }
     pub fn configure_tcp(
         &self,
         owner: &str,

From 9955195bfc2dcc196a900fd76223cd23f2d7e012 Mon Sep 17 00:00:00 2001
From: czyt <czytcn@gmail.com>
Date: Fri, 16 Oct 2026 18:26:12 +0800
Subject: [PATCH 3/3] Run isolated pre scripts before each Data query

---
 crates/core/src/interpolation.rs              |   8 +
 crates/protocols/src/data.rs                  |  22 +-
 crates/protocols/src/lib.rs                   |   4 +
 crates/protocols/src/models.rs                |  17 +
 crates/server/src/auth.rs                     |   1 +
 crates/server/src/execution.rs                |  83 +++
 crates/server/src/lib.rs                      |   6 +
 crates/server/src/protocols.rs                | 234 ++++++-
 crates/server/tests/data_client.rs            | 583 +++++++++++++++++-
 crates/server/tests/database.rs               |  33 +-
 docs/IMPLEMENTATION-STATUS.md                 |   2 +
 docs/specs/data-query-pre-scripts.md          |   4 +-
 .../data-query-pre-scripts-plan.md            |   7 +
 web/src/features/data/DataWorkbench.test.tsx  |  11 +
 web/src/features/data/DataWorkbench.tsx       |   7 +-
 web/src/features/data/types.ts                |   3 +-
 web/src/features/data/useDataEvents.test.tsx  |  33 +
 web/src/features/data/useDataEvents.ts        |  18 +-
 web/src/features/protocols/events.ts          |   2 +-
 web/src/features/protocols/lifecycle.test.tsx |  23 +
 .../features/protocols/useProtocolSession.ts  |  15 +-
 web/src/shared/i18n/en.json                   |   4 +
 web/src/shared/i18n/zh-CN.json                |   4 +
 23 files changed, 1081 insertions(+), 43 deletions(-)

diff --git a/crates/core/src/interpolation.rs b/crates/core/src/interpolation.rs
index 7abf8936..bd41e73a 100644
--- a/crates/core/src/interpolation.rs
+++ b/crates/core/src/interpolation.rs
@@ -118,6 +118,9 @@ pub fn resolve_request(
     // JavaScript is source code, not an interpolated request field.
     value["pre_request_script"] = "".into();
     value["post_response_script"] = "".into();
+    if request.protocol.is_data() {
+        value["protocol"]["query_pre_script"] = "".into();
+    }
     let mqtt_will = if let Protocol::Mqtt { config } = &request.protocol {
         config.will.as_ref().map(|w| w.message.clone())
     } else {
@@ -499,6 +502,11 @@ pub fn resolve_request(
         config.message.payload_source = original.message.payload_source.clone();
         resolved.body = request.body.clone();
     }
+    if let (Protocol::Data { config }, Protocol::Data { config: original }) =
+        (&mut resolved.protocol, &request.protocol)
+    {
+        config.query_pre_script = original.query_pre_script.clone();
+    }
     resolved.pre_request_script = request.pre_request_script.clone();
     resolved.post_response_script = request.post_response_script.clone();
     reconcile_graphql(&mut resolved)?;
diff --git a/crates/protocols/src/data.rs b/crates/protocols/src/data.rs
index 8474e9a7..d9820bb9 100644
--- a/crates/protocols/src/data.rs
+++ b/crates/protocols/src/data.rs
@@ -1,8 +1,9 @@
 use crate::{Command, EventMessage, SendMessage, Session, SessionState};
 use anyhow::{Context, Result, ensure};
-use moleapi_core::{Environment, NetworkPolicy, Protocol, RequestSpec};
+use moleapi_core::{DataSource, Environment, NetworkPolicy, Protocol, RequestSpec};
 use moleapi_data::{Connection, QueryResult};
 use std::{
+    collections::HashSet,
     path::PathBuf,
     sync::{Arc, OnceLock},
     time::{Duration, Instant},
@@ -15,6 +16,7 @@ pub(crate) struct Control {
     pub worker: Option<PathBuf>,
     active: Option<(String, CancellationToken)>,
     commands: usize,
+    used_query_ids: HashSet<String>,
     pub completions: Option<mpsc::Sender<DataCompletion>>,
 }
 pub struct DataCompletion {
@@ -36,6 +38,9 @@ pub struct DataReservation {
     dispatched: bool,
 }
 impl DataReservation {
+    pub fn cancelled_now(&self) -> bool {
+        self.stop.is_cancelled() || self.session.cancel.is_cancelled()
+    }
     pub async fn cancelled(&self) {
         tokio::select! { _ = self.stop.cancelled() => {}, _ = self.session.cancel.cancelled() => {} }
     }
@@ -60,6 +65,10 @@ impl DataReservation {
             "Data query reservation expired"
         );
         ensure!(control.commands < 512, "Data command budget exceeded");
+        ensure!(
+            !control.used_query_ids.contains(&self.query_id),
+            "Data query ID was already dispatched"
+        );
         ensure!(
             record.input.saturating_add(sql.len()) <= 20 * 1024 * 1024,
             "Data command input budget exceeded"
@@ -76,6 +85,7 @@ impl DataReservation {
             .context("Data command queue is full")?;
         record.input += size;
         control.commands += 1;
+        control.used_query_ids.insert(self.query_id.clone());
         self.dispatched = true;
         Ok(())
     }
@@ -116,6 +126,10 @@ pub(crate) fn reserve(
     );
     let mut control = session.data.lock().unwrap();
     ensure!(control.active.is_none(), "A Data query is already running");
+    ensure!(
+        !control.used_query_ids.contains(&query_id),
+        "Data query ID was already dispatched"
+    );
     ensure!(control.commands < 512, "Data command budget exceeded");
     ensure!(
         record.input.saturating_add(sql.len()) <= 20 * 1024 * 1024,
@@ -369,6 +383,12 @@ pub(crate) async fn run(
                 read_only,
                 stop,
             } => {
+                let read_only = read_only
+                    || config.read_only
+                    || matches!(
+                        config.source,
+                        DataSource::LocalFile | DataSource::RemoteFile
+                    );
                 let started = Instant::now();
                 let permit = match slots().try_acquire_owned() {
                     Ok(value) => value,
diff --git a/crates/protocols/src/lib.rs b/crates/protocols/src/lib.rs
index c73dba4c..ca8a5073 100644
--- a/crates/protocols/src/lib.rs
+++ b/crates/protocols/src/lib.rs
@@ -86,6 +86,10 @@ impl Session {
             EventMessage::DataReady { .. }
             | EventMessage::DataSchema { .. }
             | EventMessage::DataStarted { .. }
+            | EventMessage::DataPreparing { .. }
+            | EventMessage::DataPrepared { .. }
+            | EventMessage::DataPreprocessError { .. }
+            | EventMessage::DataSkipped { .. }
             | EventMessage::DataColumns { .. }
             | EventMessage::DataRows { .. }
             | EventMessage::DataFinished { .. }
diff --git a/crates/protocols/src/models.rs b/crates/protocols/src/models.rs
index 5ae359d3..ea957e23 100644
--- a/crates/protocols/src/models.rs
+++ b/crates/protocols/src/models.rs
@@ -56,6 +56,23 @@ pub enum EventMessage {
     DataStarted {
         query_id: String,
     },
+    DataPreparing {
+        query_id: String,
+    },
+    DataPrepared {
+        query_id: String,
+        sql_changed: bool,
+        tests: Vec<TestResult>,
+        logs: Vec<ScriptLog>,
+        variable_updates: Vec<VariableUpdate>,
+    },
+    DataPreprocessError {
+        query_id: String,
+        message: String,
+    },
+    DataSkipped {
+        query_id: String,
+    },
     DataColumns {
         query_id: String,
         columns: Vec<moleapi_data::Column>,
diff --git a/crates/server/src/auth.rs b/crates/server/src/auth.rs
index 56f98b0d..5538fe1f 100644
--- a/crates/server/src/auth.rs
+++ b/crates/server/src/auth.rs
@@ -316,6 +316,7 @@ mod tests {
     #[tokio::test]
     async fn session_storage_contains_only_digest_and_expired_sessions_are_rejected() {
         let state = AppState {
+            data_sessions: std::sync::Arc::default(),
             history_clears: std::sync::Arc::default(),
             credential_revisions: std::sync::Arc::default(),
             db: crate::storage::connect("sqlite::memory:").await.unwrap(),
diff --git a/crates/server/src/execution.rs b/crates/server/src/execution.rs
index f3d2b048..33241428 100644
--- a/crates/server/src/execution.rs
+++ b/crates/server/src/execution.rs
@@ -696,3 +696,86 @@ pub(crate) async fn postprocess_data(
     }
     Ok(false)
 }
+
+pub(crate) struct PreparedDataQuery {
+    pub sql: Option<String>,
+    pub tests: Vec<TestResult>,
+    pub logs: Vec<ScriptLog>,
+    pub updates: Vec<VariableUpdate>,
+}
+
+pub(crate) async fn prepare_data_query(
+    s: &AppState,
+    request: &RequestSpec,
+    selected_sql: &str,
+    read_only: bool,
+    scopes: &mut VariableScopes,
+) -> Result<PreparedDataQuery, ApiError> {
+    let moleapi_core::Protocol::Data { config } = &request.protocol else {
+        return Err(ApiError::bad("Expected Data request"));
+    };
+    let mut synthetic = request.clone();
+    synthetic.protocol = moleapi_core::Protocol::Http;
+    synthetic.url = "http://data.invalid/query".into();
+    synthetic.body_kind = "text".into();
+    synthetic.body = selected_sql.into();
+    let output = script_phase(s, vec![config.query_pre_script.clone()], &synthetic, None, scopes)
+        .await.map_err(|failure| {
+            scopes.private_values.extend(failure.private_values);
+            if !failure.privacy_complete {
+                return ApiError::bad("Data query pre script failed; details withheld because privacy metadata is incomplete");
+            }
+            let mut value = serde_json::json!(failure.error.message);
+            match crate::privacy::Redactor::new(&scopes.private_values) {
+                Ok(redactor) => redactor.scrub(&mut value),
+                Err(_) => value = serde_json::json!("Data query pre script failed; privacy redaction unavailable"),
+            }
+            ApiError::bad(value.as_str().unwrap_or("Data query pre script failed"))
+        })?;
+    scopes.private_values.extend(output.private_values);
+    let mut expected = synthetic.clone();
+    expected.body = output.request.body.clone();
+    if output.request != expected || output.control.next_request.is_some() {
+        return Err(ApiError::bad(
+            "Data query pre script may only edit SQL and scoped variables",
+        ));
+    }
+    let mut next = scopes.clone();
+    next.apply(&output.updates)
+        .map_err(|e| ApiError::bad(e.to_string()))?;
+    let sql = if output.control.skip_request {
+        None
+    } else {
+        let sql =
+            moleapi_core::resolve_value(&output.request.body, &next.effective()).map_err(|_| {
+                ApiError::bad("Data query SQL has unresolved variables or exceeds limits")
+            })?;
+        let read_only = read_only
+            || config.read_only
+            || matches!(
+                config.source,
+                moleapi_core::DataSource::LocalFile | moleapi_core::DataSource::RemoteFile
+            );
+        moleapi_data::statement(&sql, config.source, read_only).map_err(|_| {
+            ApiError::bad("Prepared Data SQL violates statement or read-only limits")
+        })?;
+        Some(sql)
+    };
+    *scopes = next;
+    let redactor = crate::privacy::Redactor::new(&scopes.private_values)?;
+    let mut details =
+        serde_json::json!({"tests":output.tests,"logs":output.logs,"updates":output.updates});
+    redactor.scrub(&mut details);
+    let mut updates: Vec<VariableUpdate> =
+        serde_json::from_value(details["updates"].clone()).map_err(|_| ApiError::internal())?;
+    for update in &mut updates {
+        update.value = None;
+    }
+    Ok(PreparedDataQuery {
+        sql,
+        tests: serde_json::from_value(details["tests"].clone())
+            .map_err(|_| ApiError::internal())?,
+        logs: serde_json::from_value(details["logs"].clone()).map_err(|_| ApiError::internal())?,
+        updates,
+    })
+}
diff --git a/crates/server/src/lib.rs b/crates/server/src/lib.rs
index 730ecfd9..00c52c63 100644
--- a/crates/server/src/lib.rs
+++ b/crates/server/src/lib.rs
@@ -86,6 +86,11 @@ struct AppState {
     script_worker: PathBuf,
     protocol_sessions: Arc<moleapi_protocols::SessionManager>,
     protocol_admission: Arc<protocol_admission::AdmissionGates>,
+    data_sessions: Arc<
+        std::sync::Mutex<
+            std::collections::HashMap<String, std::sync::Weak<protocols::DataCompletionContext>>,
+        >,
+    >,
     history_clears:
         Arc<std::sync::Mutex<std::collections::HashMap<(String, String), std::time::Instant>>>,
     credential_revisions: Arc<tokio::sync::Mutex<std::collections::HashMap<String, i64>>>,
@@ -279,6 +284,7 @@ async fn build(
         script_worker,
         protocol_sessions: moleapi_protocols::SessionManager::new(),
         protocol_admission: Arc::new(protocol_admission::AdmissionGates::default()),
+        data_sessions: Arc::default(),
         a2a_sources: Arc::new(a2a::Sources::default()),
         webhooks: Arc::new(webhooks::Hub::default()),
     };
diff --git a/crates/server/src/protocols.rs b/crates/server/src/protocols.rs
index 60d3a9b7..e81aa726 100644
--- a/crates/server/src/protocols.rs
+++ b/crates/server/src/protocols.rs
@@ -9,6 +9,7 @@ use moleapi_protocols::{
 };
 use serde::Deserialize;
 use std::sync::Arc;
+type SharedMask = Arc<std::sync::RwLock<Arc<Redactor>>>;
 #[derive(Deserialize)]
 pub struct Create {
     workspace_id: String,
@@ -35,7 +36,7 @@ fn error(e: anyhow::Error) -> ApiError {
         ApiError::bad(text)
     }
 }
-struct DataCompletionContext {
+pub(crate) struct DataCompletionContext {
     state: AppState,
     owner: String,
     session_id: String,
@@ -45,6 +46,16 @@ struct DataCompletionContext {
     prepared_request: RequestSpec,
     admission: Arc<tokio::sync::Mutex<u64>>,
     generation: u64,
+    scopes: tokio::sync::Mutex<moleapi_core::VariableScopes>,
+    processing: tokio::sync::watch::Sender<Option<String>>,
+    mask_state: SharedMask,
+}
+impl DataCompletionContext {
+    fn refresh_mask(&self, values: &std::collections::BTreeSet<String>) -> Result<(), ApiError> {
+        let redactor = Arc::new(Redactor::new(values)?);
+        *self.mask_state.write().unwrap() = redactor;
+        Ok(())
+    }
 }
 async fn check(s: &AppState, owner: &str, id: &str) -> Result<SessionSummary, ApiError> {
     let summary = s.protocol_sessions.summary(owner, id).map_err(error)?;
@@ -147,10 +158,13 @@ pub async fn create(
     {
         return Err(ApiError::bad("Pre scripts cannot change the live protocol"));
     }
-    let redactor = Arc::new(Redactor::new(&scopes.private_values)?);
+    let mask_state: SharedMask = Arc::new(std::sync::RwLock::new(Arc::new(Redactor::new(
+        &scopes.private_values,
+    )?)));
+    let redactor = mask_state.clone();
     let mask: Arc<dyn Fn(&str) -> String + Send + Sync> = Arc::new(move |text| {
         let mut value = serde_json::json!(text);
-        redactor.scrub(&mut value);
+        redactor.read().unwrap().scrub(&mut value);
         value.as_str().unwrap_or("[REDACTED]").into()
     });
     let grpc_method = if request.protocol.is_grpc() {
@@ -371,7 +385,7 @@ pub async fn create(
         return Err(error(e));
     }
     if let Some(mut completions) = data_completions {
-        let context = DataCompletionContext {
+        let context = Arc::new(DataCompletionContext {
             state: s.clone(),
             owner: owner.0.clone(),
             session_id: summary.id.clone(),
@@ -381,8 +395,15 @@ pub async fn create(
             prepared_request: prepared_data_request,
             admission: admission.clone(),
             generation,
-        };
-        let mut scopes = scopes;
+            scopes: tokio::sync::Mutex::new(scopes),
+            processing: tokio::sync::watch::channel(None).0,
+            mask_state: mask_state.clone(),
+        });
+        {
+            let mut sessions = s.data_sessions.lock().unwrap();
+            sessions.retain(|_, context| context.strong_count() > 0);
+            sessions.insert(summary.id.clone(), Arc::downgrade(&context));
+        }
         tokio::spawn(async move {
             while let Some(completion) = completions.recv().await {
                 // Workspace deletion uses this gate for its tombstone and history cascade.
@@ -393,7 +414,7 @@ pub async fn create(
                     .lock(&context.owner, &context.workspace_id)
                     .await;
                 let query_id = completion.query_id.clone();
-                let result = save_data_completion(&context, &mut scopes, completion).await;
+                let result = save_data_completion(&context, completion).await;
                 let message = match result {
                     Ok(Some((history_id, response, notice))) => EventMessage::DataProcessed {
                         query_id: query_id.clone(),
@@ -419,13 +440,22 @@ pub async fn create(
                         &context.owner,
                         &context.session_id,
                         EventMessage::DataPostprocessError {
-                            query_id,
+                            query_id: query_id.clone(),
                             message: "Data postprocessing result exceeds session event limits"
                                 .into(),
                         },
                     );
                 }
+                if context.processing.borrow().as_deref() == Some(query_id.as_str()) {
+                    context.processing.send_replace(None);
+                }
             }
+            context
+                .state
+                .data_sessions
+                .lock()
+                .unwrap()
+                .remove(&context.session_id);
         });
     }
     summary.variable_updates = updates;
@@ -434,7 +464,6 @@ pub async fn create(
 }
 async fn save_data_completion(
     context: &DataCompletionContext,
-    scopes: &mut moleapi_core::VariableScopes,
     completion: DataCompletion,
 ) -> Result<Option<(Option<String>, Response, Option<String>)>, ApiError> {
     let guard = context.admission.lock().await;
@@ -446,6 +475,7 @@ async fn save_data_completion(
         return Ok(None);
     }
     let w = owned(&context.state, &context.owner, &context.workspace_id).await?;
+    let mut scopes = context.scopes.lock().await;
     let history_cleared = crate::history::cleared_since(
         &context.state,
         &context.owner,
@@ -531,7 +561,7 @@ async fn save_data_completion(
             collection,
             &context.prepared_request,
             &mut response,
-            scopes,
+            &mut scopes,
         )
         .await?
     };
@@ -574,6 +604,7 @@ async fn save_data_completion(
         )
         .await?
     };
+    context.refresh_mask(&scopes.private_values)?;
     drop(guard);
     if history_id.is_none() && !history_cleared {
         return Ok(None);
@@ -606,12 +637,193 @@ pub async fn send(
     Path(id): Path<String>,
     Json(message): Json<SendMessage>,
 ) -> Result<Json<serde_json::Value>, ApiError> {
-    check(&s, &owner.0, &id).await?;
+    let summary = check(&s, &owner.0, &id).await?;
+    if let SendMessage::DataQuery {
+        query_id,
+        sql,
+        read_only,
+    } = &message
+        && summary.protocol == "data"
+    {
+        let context = s
+            .data_sessions
+            .lock()
+            .unwrap()
+            .get(&id)
+            .and_then(std::sync::Weak::upgrade)
+            .ok_or_else(ApiError::not_found)?;
+        if let Protocol::Data { config } = &context.prepared_request.protocol
+            && !config.query_pre_script.trim().is_empty()
+        {
+            send_scripted_data_query(
+                &s,
+                &owner.0,
+                &id,
+                &context,
+                query_id.clone(),
+                sql.clone(),
+                *read_only,
+            )
+            .await?;
+            return Ok(Json(serde_json::json!({"ok":true})));
+        }
+    }
     s.protocol_sessions
         .send(&owner.0, &id, message)
         .map_err(error)?;
     Ok(Json(serde_json::json!({"ok":true})))
 }
+
+async fn send_scripted_data_query(
+    s: &AppState,
+    owner: &str,
+    id: &str,
+    context: &DataCompletionContext,
+    query_id: String,
+    selected_sql: String,
+    read_only: bool,
+) -> Result<(), ApiError> {
+    let reservation = s
+        .protocol_sessions
+        .reserve_data_query(owner, id, query_id.clone(), &selected_sql)
+        .map_err(error)?;
+    s.protocol_sessions
+        .data_event(
+            owner,
+            id,
+            EventMessage::DataPreparing {
+                query_id: query_id.clone(),
+            },
+        )
+        .map_err(error)?;
+    let mut processing = context.processing.subscribe();
+    while processing.borrow().is_some() {
+        tokio::select! {
+            _ = reservation.cancelled() => {
+                let _ = s.protocol_sessions.data_event(owner, id, EventMessage::DataCancelled { query_id, write_outcome_unknown:false });
+                return Ok(());
+            }
+            changed = tokio::time::timeout(std::time::Duration::from_secs(30), processing.changed()) => {
+                if !matches!(changed, Ok(Ok(()))) {
+                    let _ = s.protocol_sessions.data_event(owner, id, EventMessage::DataPreprocessError {
+                        query_id, message:"Previous Data query postprocessing is unavailable".into(),
+                    });
+                    return Ok(());
+                }
+            }
+        }
+    }
+    let _workspace_gate = s.webhooks.gates.lock(owner, &context.workspace_id).await;
+    let admitted = context.admission.lock().await;
+    if *admitted != context.generation || check(s, owner, id).await.is_err() {
+        return Err(ApiError::unauthorized());
+    }
+    let mut scopes = context.scopes.lock().await;
+    let before = scopes.clone();
+    let prepared = tokio::select! {
+        _ = reservation.cancelled() => {
+            let _ = s.protocol_sessions.data_event(owner, id, EventMessage::DataCancelled { query_id, write_outcome_unknown:false });
+            return Ok(());
+        }
+        outcome = execution::prepare_data_query(s, &context.prepared_request, &selected_sql, read_only, &mut scopes) => outcome,
+    };
+    let prepared = match prepared {
+        Ok(prepared) => prepared,
+        Err(failure) => {
+            let _ = context.refresh_mask(&scopes.private_values);
+            let _ = s.protocol_sessions.data_event(
+                owner,
+                id,
+                EventMessage::DataPreprocessError {
+                    query_id,
+                    message: failure.message,
+                },
+            );
+            return Ok(());
+        }
+    };
+    if context.refresh_mask(&scopes.private_values).is_err() {
+        let _ = s.protocol_sessions.data_event(
+            owner,
+            id,
+            EventMessage::DataPreprocessError {
+                query_id,
+                message: "Data query privacy redaction unavailable".into(),
+            },
+        );
+        return Ok(());
+    }
+    if reservation.cancelled_now() {
+        let private = scopes.private_values.clone();
+        *scopes = before;
+        scopes.private_values.extend(private);
+        let _ = s.protocol_sessions.data_event(
+            owner,
+            id,
+            EventMessage::DataCancelled {
+                query_id,
+                write_outcome_unknown: false,
+            },
+        );
+        return Ok(());
+    }
+    let event = EventMessage::DataPrepared {
+        query_id: query_id.clone(),
+        sql_changed: prepared
+            .sql
+            .as_ref()
+            .is_some_and(|sql| sql != &selected_sql),
+        tests: prepared.tests,
+        logs: prepared.logs,
+        variable_updates: prepared.updates,
+    };
+    if s.protocol_sessions.data_event(owner, id, event).is_err() {
+        let private = scopes.private_values.clone();
+        *scopes = before;
+        scopes.private_values.extend(private);
+        let _ = s.protocol_sessions.data_event(
+            owner,
+            id,
+            EventMessage::DataPreprocessError {
+                query_id,
+                message: "Data query preparation output exceeds session event limits".into(),
+            },
+        );
+        return Ok(());
+    }
+    let Some(sql) = prepared.sql else {
+        let _ = s
+            .protocol_sessions
+            .data_event(owner, id, EventMessage::DataSkipped { query_id });
+        return Ok(());
+    };
+    context.processing.send_replace(Some(query_id.clone()));
+    let source = match &context.prepared_request.protocol {
+        Protocol::Data { config } => config,
+        _ => unreachable!(),
+    };
+    let effective_read_only = read_only
+        || source.read_only
+        || matches!(
+            source.source,
+            moleapi_core::DataSource::LocalFile | moleapi_core::DataSource::RemoteFile
+        );
+    if let Err(failure) = reservation.dispatch(sql, effective_read_only) {
+        context.processing.send_replace(None);
+        let private = scopes.private_values.clone();
+        *scopes = before;
+        scopes.private_values.extend(private);
+        let _ = s.protocol_sessions.data_event(
+            owner,
+            id,
+            EventMessage::DataPreprocessError {
+                query_id,
+                message: failure.to_string(),
+            },
+        );
+    }
+    Ok(())
+}
 pub async fn close(
     State(s): State<AppState>,
     Extension(owner): Extension<Identity>,
diff --git a/crates/server/tests/data_client.rs b/crates/server/tests/data_client.rs
index fce6aeb2..17f0bf70 100644
--- a/crates/server/tests/data_client.rs
+++ b/crates/server/tests/data_client.rs
@@ -76,7 +76,12 @@ async fn query(router: &Router, token: Option<&str>, id: &str, query_id: &str, s
                 event["message"]["query_id"] == query_id
                     && matches!(
                         event["message"]["kind"].as_str(),
-                        Some("data_finished" | "data_error")
+                        Some(
+                            "data_finished"
+                                | "data_error"
+                                | "data_preprocess_error"
+                                | "data_skipped"
+                        )
                     )
             }) {
                 return batch;
@@ -927,8 +932,6 @@ async fn clearing_history_does_not_restore_an_already_finished_data_query() {
             .any(|test| test["name"] == "after-clear" && test["passed"] == true),
         "{processed}"
     );
-    assert!(processed["history_id"].is_null());
-    assert_eq!(processed["notice"], "history_cleared");
     let (_, history) = call(&router, "GET", "/api/workspaces/data/history", None, None).await;
     assert_eq!(history, json!([]));
 }
@@ -1094,3 +1097,577 @@ async fn full_data_completion_queue_reports_postprocessing_loss_without_sql_repl
     )
     .await;
 }
+
+#[tokio::test]
+async fn query_pre_script_mutates_each_sql_and_sees_prior_post_updates() {
+    let _serial = DATA_CLIENT_TESTS.lock().await;
+    let temp = tempfile::tempdir().unwrap();
+    let router = moleapi_server::local_with_worker(&temp.path().join("data-pre.db"), &worker())
+        .await
+        .unwrap();
+    let mut document = data();
+    let request = &mut document["collections"][0]["requests"][0];
+    request["protocol"]["query_pre_script"] = json!(
+        "const n=Number(pm.collectionVariables.get('query_count')||'0')+1;if(n>1)pm.test('post-visible',()=>pm.expect(pm.collectionVariables.get('post')).to.equal('ready'));pm.collectionVariables.set('query_count',String(n));pm.request.body.update('SELECT name FROM data WHERE id='+n);"
+    );
+    request["post_response_script"] = json!("pm.collectionVariables.set('post','ready');");
+    let (status, workspace) = call(
+        &router,
+        "POST",
+        "/api/workspaces",
+        None,
+        Some(json!({"id":"data","name":"Data","data":document})),
+    )
+    .await;
+    assert_eq!(status, StatusCode::OK, "{workspace}");
+    let (status, session) = call(&router, "POST", "/api/sessions", None,
+        Some(json!({"workspace_id":"data","request":workspace["data"]["collections"][0]["requests"][0]}))).await;
+    assert_eq!(status, StatusCode::OK, "{session}");
+    let id = session["id"].as_str().unwrap();
+    ready(&router, None, id).await;
+    let first = query(
+        &router,
+        None,
+        id,
+        "pre-one",
+        "SELECT name FROM data WHERE id=999",
+    )
+    .await;
+    assert!(
+        first["events"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|event| event["message"]["kind"] == "data_rows"
+                && event["message"]["rows"][0][0]["value"] == "first"),
+        "{first}"
+    );
+    let second = query(
+        &router,
+        None,
+        id,
+        "pre-two",
+        "SELECT name FROM data WHERE id=999",
+    )
+    .await;
+    assert!(
+        second["events"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|event| event["message"]["kind"] == "data_rows"
+                && event["message"]["rows"][0][0]["value"] == "second")
+    );
+    assert!(second["events"].as_array().unwrap().iter().any(|event| {
+        event["message"]["kind"] == "data_prepared"
+            && event["message"]["query_id"] == "pre-two"
+            && event["message"]["tests"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .any(|test| test["name"] == "post-visible" && test["passed"] == true)
+    }));
+    let (status, duplicate) = call(&router, "POST", &format!("/api/sessions/{id}/send"), None,
+        Some(json!({"kind":"data_query","query_id":"pre-one","sql":"SELECT name FROM data WHERE id=999","read_only":true}))).await;
+    assert_eq!(status, StatusCode::BAD_REQUEST, "{duplicate}");
+    let (_, events) = call(
+        &router,
+        "GET",
+        &format!("/api/sessions/{id}/events"),
+        None,
+        None,
+    )
+    .await;
+    assert_eq!(
+        events["events"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .filter(|event| event["message"]["kind"] == "data_started"
+                && event["message"]["query_id"] == "pre-one")
+            .count(),
+        1
+    );
+}
+
+#[tokio::test]
+async fn rejected_query_pre_mutation_does_not_dispatch_or_save_sql() {
+    let _serial = DATA_CLIENT_TESTS.lock().await;
+    let temp = tempfile::tempdir().unwrap();
+    let router =
+        moleapi_server::local_with_worker(&temp.path().join("data-pre-reject.db"), &worker())
+            .await
+            .unwrap();
+    let mut document = data();
+    document["collections"][0]["requests"][0]["protocol"]["query_pre_script"] = json!(
+        "pm.request.url='http://changed.invalid/';pm.request.body.update('SELECT name FROM data WHERE id=2');"
+    );
+    let (status, workspace) = call(
+        &router,
+        "POST",
+        "/api/workspaces",
+        None,
+        Some(json!({"id":"data","name":"Data","data":document})),
+    )
+    .await;
+    assert_eq!(status, StatusCode::OK, "{workspace}");
+    let (status, session) = call(&router, "POST", "/api/sessions", None,
+        Some(json!({"workspace_id":"data","request":workspace["data"]["collections"][0]["requests"][0]}))).await;
+    assert_eq!(status, StatusCode::OK, "{session}");
+    let id = session["id"].as_str().unwrap();
+    ready(&router, None, id).await;
+    let events = query(
+        &router,
+        None,
+        id,
+        "pre-rejected",
+        "SELECT name FROM data WHERE id=1",
+    )
+    .await;
+    let events = events["events"].as_array().unwrap();
+    assert!(
+        events
+            .iter()
+            .any(|event| event["message"]["kind"] == "data_preprocess_error"
+                && event["message"]["query_id"] == "pre-rejected")
+    );
+    assert!(
+        !events
+            .iter()
+            .any(|event| event["message"]["kind"] == "data_started"
+                && event["message"]["query_id"] == "pre-rejected")
+    );
+    let (_, history) = call(&router, "GET", "/api/workspaces/data/history", None, None).await;
+    assert_eq!(history, json!([]));
+}
+
+#[tokio::test]
+async fn cancelling_query_preparation_never_dispatches_sql() {
+    let _serial = DATA_CLIENT_TESTS.lock().await;
+    let temp = tempfile::tempdir().unwrap();
+    let router =
+        moleapi_server::local_with_worker(&temp.path().join("data-pre-cancel.db"), &worker())
+            .await
+            .unwrap();
+    let mut document = data();
+    document["collections"][0]["requests"][0]["protocol"]["query_pre_script"] = json!(
+        "const until=Date.now()+100;while(Date.now()<until){};pm.request.body.update('SELECT name FROM data WHERE id=2');"
+    );
+    let (status, workspace) = call(
+        &router,
+        "POST",
+        "/api/workspaces",
+        None,
+        Some(json!({"id":"data","name":"Data","data":document})),
+    )
+    .await;
+    assert_eq!(status, StatusCode::OK, "{workspace}");
+    let (status, session) = call(&router, "POST", "/api/sessions", None,
+        Some(json!({"workspace_id":"data","request":workspace["data"]["collections"][0]["requests"][0]}))).await;
+    assert_eq!(status, StatusCode::OK, "{session}");
+    let id = session["id"].as_str().unwrap().to_owned();
+    ready(&router, None, &id).await;
+    let sender = router.clone();
+    let query_id = id.clone();
+    let task = tokio::spawn(async move {
+        call(&sender, "POST", &format!("/api/sessions/{query_id}/send"), None,
+        Some(json!({"kind":"data_query","query_id":"pre-cancel","sql":"SELECT name FROM data WHERE id=1","read_only":true}))).await
+    });
+    tokio::time::timeout(Duration::from_secs(5), async {
+        loop {
+            let (_, events) = call(
+                &router,
+                "GET",
+                &format!("/api/sessions/{id}/events"),
+                None,
+                None,
+            )
+            .await;
+            if events["events"].as_array().unwrap().iter().any(|event| {
+                event["message"]["kind"] == "data_preparing"
+                    && event["message"]["query_id"] == "pre-cancel"
+            }) {
+                break;
+            }
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        }
+    })
+    .await
+    .unwrap();
+    let (status, cancelled) = call(
+        &router,
+        "POST",
+        &format!("/api/sessions/{id}/send"),
+        None,
+        Some(json!({"kind":"data_cancel","query_id":"pre-cancel"})),
+    )
+    .await;
+    assert_eq!(status, StatusCode::OK, "{cancelled}");
+    assert_eq!(task.await.unwrap().0, StatusCode::OK);
+    let (_, events) = call(
+        &router,
+        "GET",
+        &format!("/api/sessions/{id}/events"),
+        None,
+        None,
+    )
+    .await;
+    let events = events["events"].as_array().unwrap();
+    assert!(
+        events
+            .iter()
+            .any(|event| event["message"]["kind"] == "data_cancelled"
+                && event["message"]["query_id"] == "pre-cancel")
+    );
+    assert!(
+        !events
+            .iter()
+            .any(|event| event["message"]["kind"] == "data_started"
+                && event["message"]["query_id"] == "pre-cancel")
+    );
+    let (_, history) = call(&router, "GET", "/api/workspaces/data/history", None, None).await;
+    assert_eq!(history, json!([]));
+}
+
+#[tokio::test]
+async fn query_pre_script_skip_keeps_the_connection_and_runs_no_sql() {
+    let _serial = DATA_CLIENT_TESTS.lock().await;
+    let temp = tempfile::tempdir().unwrap();
+    let router =
+        moleapi_server::local_with_worker(&temp.path().join("data-pre-skip.db"), &worker())
+            .await
+            .unwrap();
+    let mut document = data();
+    document["collections"][0]["requests"][0]["protocol"]["query_pre_script"] =
+        json!("pm.execution.skipRequest();");
+    let (status, workspace) = call(
+        &router,
+        "POST",
+        "/api/workspaces",
+        None,
+        Some(json!({"id":"data","name":"Data","data":document})),
+    )
+    .await;
+    assert_eq!(status, StatusCode::OK, "{workspace}");
+    let (status, session) = call(&router, "POST", "/api/sessions", None,
+        Some(json!({"workspace_id":"data","request":workspace["data"]["collections"][0]["requests"][0]}))).await;
+    assert_eq!(status, StatusCode::OK, "{session}");
+    let id = session["id"].as_str().unwrap();
+    ready(&router, None, id).await;
+    let events = query(
+        &router,
+        None,
+        id,
+        "skipped",
+        "SELECT name FROM data WHERE id=1",
+    )
+    .await;
+    let events = events["events"].as_array().unwrap();
+    assert!(
+        events
+            .iter()
+            .any(|event| event["message"]["kind"] == "data_skipped"
+                && event["message"]["query_id"] == "skipped"),
+        "{events:?}"
+    );
+    assert!(
+        events
+            .iter()
+            .any(|event| event["message"]["kind"] == "data_prepared"
+                && event["message"]["query_id"] == "skipped")
+    );
+    assert!(
+        !events
+            .iter()
+            .any(|event| event["message"]["kind"] == "data_started"
+                && event["message"]["query_id"] == "skipped")
+    );
+    let (_, summary) = call(&router, "GET", &format!("/api/sessions/{id}"), None, None).await;
+    assert_eq!(summary["state"], "open");
+    let (_, history) = call(&router, "GET", "/api/workspaces/data/history", None, None).await;
+    assert_eq!(history, json!([]));
+}
+
+#[tokio::test]
+async fn query_pre_script_cannot_turn_a_read_only_query_into_a_write() {
+    let _serial = DATA_CLIENT_TESTS.lock().await;
+    let temp = tempfile::tempdir().unwrap();
+    let router =
+        moleapi_server::local_with_worker(&temp.path().join("data-pre-write.db"), &worker())
+            .await
+            .unwrap();
+    let mut document = data();
+    document["collections"][0]["requests"][0]["protocol"]["query_pre_script"] =
+        json!("pm.request.body.update('DELETE FROM data');");
+    let (status, workspace) = call(
+        &router,
+        "POST",
+        "/api/workspaces",
+        None,
+        Some(json!({"id":"data","name":"Data","data":document})),
+    )
+    .await;
+    assert_eq!(status, StatusCode::OK, "{workspace}");
+    let (status, session) = call(&router, "POST", "/api/sessions", None,
+        Some(json!({"workspace_id":"data","request":workspace["data"]["collections"][0]["requests"][0]}))).await;
+    assert_eq!(status, StatusCode::OK, "{session}");
+    let id = session["id"].as_str().unwrap();
+    ready(&router, None, id).await;
+    let events = query(
+        &router,
+        None,
+        id,
+        "no-write",
+        "SELECT name FROM data WHERE id=1",
+    )
+    .await;
+    let events = events["events"].as_array().unwrap();
+    assert!(
+        events
+            .iter()
+            .any(|event| event["message"]["kind"] == "data_preprocess_error"
+                && event["message"]["query_id"] == "no-write")
+    );
+    assert!(
+        !events
+            .iter()
+            .any(|event| event["message"]["kind"] == "data_started"
+                && event["message"]["query_id"] == "no-write")
+    );
+    let (_, history) = call(&router, "GET", "/api/workspaces/data/history", None, None).await;
+    assert_eq!(history, json!([]));
+}
+
+#[tokio::test]
+async fn query_pre_script_masks_private_logs_and_update_values() {
+    let _serial = DATA_CLIENT_TESTS.lock().await;
+    let temp = tempfile::tempdir().unwrap();
+    let router =
+        moleapi_server::local_with_worker(&temp.path().join("data-pre-private.db"), &worker())
+            .await
+            .unwrap();
+    let mut document = data();
+    document["global_variables"] = json!([{"id":"secret","key":"secret","value":"private-pre-value","enabled":true,"secret":true}]);
+    document["collections"][0]["requests"][0]["protocol"]["query_pre_script"] = json!(
+        "console.log(pm.globals.get('secret'));pm.variables.set('copied',pm.globals.get('secret'));pm.variables.set(pm.globals.get('secret'),'x');pm.request.body.update('SELECT name FROM data WHERE id=2');"
+    );
+    let (status, workspace) = call(
+        &router,
+        "POST",
+        "/api/workspaces",
+        None,
+        Some(json!({"id":"data","name":"Data","data":document})),
+    )
+    .await;
+    assert_eq!(status, StatusCode::OK, "{workspace}");
+    let (status, session) = call(&router, "POST", "/api/sessions", None,
+        Some(json!({"workspace_id":"data","request":workspace["data"]["collections"][0]["requests"][0]}))).await;
+    assert_eq!(status, StatusCode::OK, "{session}");
+    let id = session["id"].as_str().unwrap();
+    ready(&router, None, id).await;
+    let events = query(
+        &router,
+        None,
+        id,
+        "private-pre",
+        "SELECT name FROM data WHERE id=1",
+    )
+    .await;
+    assert!(
+        !events.to_string().contains("private-pre-value"),
+        "{events}"
+    );
+    let prepared = events["events"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|event| event["message"]["kind"] == "data_prepared")
+        .unwrap();
+    assert_eq!(prepared["message"]["logs"][0]["message"], "[REDACTED]");
+    assert!(
+        prepared["message"]["variable_updates"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .all(|update| update["value"].is_null())
+    );
+    assert!(
+        prepared["message"]["variable_updates"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|update| update["key"] == "[REDACTED]")
+    );
+}
+
+#[tokio::test]
+async fn query_pre_script_failure_masks_private_error_and_never_dispatches() {
+    let _serial = DATA_CLIENT_TESTS.lock().await;
+    let temp = tempfile::tempdir().unwrap();
+    let router =
+        moleapi_server::local_with_worker(&temp.path().join("data-pre-failure.db"), &worker())
+            .await
+            .unwrap();
+    let mut document = data();
+    document["global_variables"] = json!([{"id":"secret","key":"secret","value":"failure-private-value","enabled":true,"secret":true}]);
+    document["collections"][0]["requests"][0]["protocol"]["query_pre_script"] =
+        json!("throw new Error(pm.globals.get('secret'));");
+    let (status, workspace) = call(
+        &router,
+        "POST",
+        "/api/workspaces",
+        None,
+        Some(json!({"id":"data","name":"Data","data":document})),
+    )
+    .await;
+    assert_eq!(status, StatusCode::OK, "{workspace}");
+    let (status, session) = call(&router, "POST", "/api/sessions", None,
+        Some(json!({"workspace_id":"data","request":workspace["data"]["collections"][0]["requests"][0]}))).await;
+    assert_eq!(status, StatusCode::OK, "{session}");
+    let id = session["id"].as_str().unwrap();
+    ready(&router, None, id).await;
+    let events = query(
+        &router,
+        None,
+        id,
+        "failed-pre",
+        "SELECT name FROM data WHERE id=1",
+    )
+    .await;
+    assert!(
+        !events.to_string().contains("failure-private-value"),
+        "{events}"
+    );
+    assert!(events["events"].as_array().unwrap().iter().any(|event| {
+        event["message"]["kind"] == "data_preprocess_error"
+            && event["message"]["message"]
+                .as_str()
+                .is_some_and(|text| text.contains("REDACTED"))
+    }));
+    assert!(
+        !events["events"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|event| event["message"]["kind"] == "data_started")
+    );
+}
+
+#[tokio::test]
+async fn query_pre_private_value_is_masked_in_database_error_events() {
+    let _serial = DATA_CLIENT_TESTS.lock().await;
+    let temp = tempfile::tempdir().unwrap();
+    let router =
+        moleapi_server::local_with_worker(&temp.path().join("data-pre-mask-worker.db"), &worker())
+            .await
+            .unwrap();
+    let mut document = data();
+    document["collections"][0]["requests"][0]["protocol"]["query_pre_script"] = json!(
+        "pm.variables.set('dynamic_secret','new-private-value');pm.request.body.update(\"SELECT CAST('{{dynamic_secret}}' AS BIGINT) AS value FROM data\");"
+    );
+    let (status, workspace) = call(
+        &router,
+        "POST",
+        "/api/workspaces",
+        None,
+        Some(json!({"id":"data","name":"Data","data":document})),
+    )
+    .await;
+    assert_eq!(status, StatusCode::OK, "{workspace}");
+    let (status, session) = call(&router, "POST", "/api/sessions", None,
+        Some(json!({"workspace_id":"data","request":workspace["data"]["collections"][0]["requests"][0]}))).await;
+    assert_eq!(status, StatusCode::OK, "{session}");
+    let id = session["id"].as_str().unwrap();
+    ready(&router, None, id).await;
+    let events = query(
+        &router,
+        None,
+        id,
+        "masked-worker",
+        "SELECT name FROM data WHERE id=1",
+    )
+    .await;
+    assert!(
+        events["events"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|event| event["message"]["kind"] == "data_error"),
+        "{events}"
+    );
+    assert!(
+        !events.to_string().contains("new-private-value"),
+        "{events}"
+    );
+    let error = events["events"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|event| event["message"]["kind"] == "data_error")
+        .unwrap();
+    assert!(
+        error["message"]["message"]
+            .as_str()
+            .unwrap()
+            .contains("REDACTED"),
+        "{events}"
+    );
+}
+
+#[tokio::test]
+async fn oversized_preparation_event_rolls_back_variable_updates() {
+    let _serial = DATA_CLIENT_TESTS.lock().await;
+    let temp = tempfile::tempdir().unwrap();
+    let router =
+        moleapi_server::local_with_worker(&temp.path().join("data-pre-event-limit.db"), &worker())
+            .await
+            .unwrap();
+    let mut document = data();
+    document["collections"][0]["requests"][0]["protocol"]["query_pre_script"] = json!(
+        "if(!pm.variables.get('attempted')){pm.variables.set('attempted','yes');for(let i=0;i<999;i++)pm.variables.set('k'.repeat(1020)+String(i).padStart(4,'0'),'x');}pm.request.body.update('SELECT name FROM data WHERE id=2');"
+    );
+    let (status, workspace) = call(
+        &router,
+        "POST",
+        "/api/workspaces",
+        None,
+        Some(json!({"id":"data","name":"Data","data":document})),
+    )
+    .await;
+    assert_eq!(status, StatusCode::OK, "{workspace}");
+    let (status, session) = call(&router, "POST", "/api/sessions", None,
+        Some(json!({"workspace_id":"data","request":workspace["data"]["collections"][0]["requests"][0]}))).await;
+    assert_eq!(status, StatusCode::OK, "{session}");
+    let id = session["id"].as_str().unwrap();
+    ready(&router, None, id).await;
+    for query_id in ["first-large", "second-large"] {
+        let events = query(
+            &router,
+            None,
+            id,
+            query_id,
+            "SELECT name FROM data WHERE id=1",
+        )
+        .await;
+        assert!(
+            events["events"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .any(|event| event["message"]["kind"] == "data_preprocess_error"
+                    && event["message"]["query_id"] == query_id
+                    && event["message"]["message"]
+                        .as_str()
+                        .is_some_and(|text| text.contains("event limits"))),
+            "{events}"
+        );
+        assert!(
+            !events["events"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .any(|event| event["message"]["kind"] == "data_started"
+                    && event["message"]["query_id"] == query_id)
+        );
+    }
+}
diff --git a/crates/server/tests/database.rs b/crates/server/tests/database.rs
index 346e3767..93fee17c 100644
--- a/crates/server/tests/database.rs
+++ b/crates/server/tests/database.rs
@@ -450,13 +450,25 @@ pub async fn verify_data_completion_history() {
         .await
         .unwrap();
         let mut data = example_data();
+        let integer_type = if source == "mysql" {
+            "SIGNED"
+        } else {
+            "BIGINT"
+        };
+        let sql = format!(
+            "SELECT CAST(9007199254740993 AS {integer_type}) AS exact, CAST(1.23 AS DECIMAL(10,2)) AS amount"
+        );
+        let pre_script = format!(
+            "pm.request.body.update({});",
+            serde_json::to_string(&sql).unwrap()
+        );
         let request = &mut data["collections"][0]["requests"][0];
         request["method"] = json!("GET");
         request["url"] = json!(url);
         request["body_kind"] = json!("none");
         request["body"] = json!("");
         request["assertions"] = json!([]);
-        request["protocol"] = json!({"kind":"data","source":source,"tls":false,"sql":"SELECT 1"});
+        request["protocol"] = json!({"kind":"data","source":source,"tls":false,"sql":"SELECT 1","query_pre_script":pre_script});
         let (status, workspace) = call(
             &router,
             "POST",
@@ -483,20 +495,12 @@ pub async fn verify_data_completion_history() {
         })
         .await
         .unwrap();
-        let integer_type = if source == "mysql" {
-            "SIGNED"
-        } else {
-            "BIGINT"
-        };
-        let sql = format!(
-            "SELECT CAST(9007199254740993 AS {integer_type}) AS exact, CAST(1.23 AS DECIMAL(10,2)) AS amount"
-        );
         let (status, sent) = call(
             &router,
             "POST",
             &format!("/api/sessions/{id}/send"),
             None,
-            Some(json!({"kind":"data_query","query_id":"typed-db","sql":sql,"read_only":true})),
+            Some(json!({"kind":"data_query","query_id":"typed-db","sql":"SELECT 1 AS placeholder","read_only":true})),
         )
         .await;
         assert_eq!(status, StatusCode::OK, "{sent}");
@@ -524,6 +528,15 @@ pub async fn verify_data_completion_history() {
                             .any(|event| event["message"]["kind"] == "data_finished"),
                         "{source}: {events}"
                     );
+                    assert!(
+                        events["events"]
+                            .as_array()
+                            .unwrap()
+                            .iter()
+                            .any(|event| event["message"]["kind"] == "data_prepared"
+                                && event["message"]["sql_changed"] == true),
+                        "{source}: {events}"
+                    );
                     break;
                 }
                 tokio::time::sleep(Duration::from_millis(20)).await;
diff --git a/docs/IMPLEMENTATION-STATUS.md b/docs/IMPLEMENTATION-STATUS.md
index 945889d0..b49a6115 100644
--- a/docs/IMPLEMENTATION-STATUS.md
+++ b/docs/IMPLEMENTATION-STATUS.md
@@ -101,6 +101,8 @@ Evidence:234 Rust source tests pass with20 external fixtures ignored;9 real webh
 
 ## Data client functional integration
 
+Per-query Data pre scripts are implemented on `feat/data-query-pre-scripts`: an additive saved script field runs in the isolated worker for each accepted query, can update scoped variables and SQL, and cannot alter connection settings or bypass the saved read-only mode. Local real-file cases cover SQL mutation, ordering with post-script updates, cancel/skip/error with zero SQL dispatch, repeated query-ID rejection, private diagnostic/metadata screening and event-limit rollback. The 390px bilingual editor/result flow and saved reload passed real browser checks. Local Data suite (21), frontend suite (320), strict full-workspace Clippy, rustfmt and production frontend build passed. Hosted PostgreSQL/MySQL query-pre and platform packages remain CI gates; this does not close saved datasets or additional Data sources.
+
 Dedicated PostgreSQL/MySQL and local/remote CSV/JSON/JSONL/Parquet request adapters now share the hosted/native protocol session lifecycle. Modular React workbench provides source/TLS/CA/read-only settings, schema browsing, CodeMirror SQL namespaces/diagnostics/format/current-statement execution, exact result sorting/search/pagination and typed JSON/CSV downloads. Application storage remains separate. Default portable workspace exports withhold local file bytes and known secrets; explicit full exports retain original data. Actual schema reads use independently disposable checked SDK transports.
 
 Final local validation:247 Rust workspace tests pass,20 external fixture cases remain ignored by the generic run;144 frontend tests pass. Strict all-target Clippy, package rustfmt, TypeScript/production frontend and embedded server builds pass. Scoped Data backend and frontend independent reviews found and prompted regression fixes; review artifacts retain findings and evidence limits. A nonreplying TCP peer reproduces upstream MySQL detached cleanup (one-second test timeout); both opt-in immediate-drop/abort transport tests pass. Decimal/mixed JSON numbers use scoped RawValue parsing after a global precision option was found incompatible with A2A serialization. Fresh full A2A regressions pass. MySQL text-protocol metadata now correctly classifies numeric/date bytes instead of treating them as binary.
diff --git a/docs/specs/data-query-pre-scripts.md b/docs/specs/data-query-pre-scripts.md
index cb4e28b3..aee82e70 100644
--- a/docs/specs/data-query-pre-scripts.md
+++ b/docs/specs/data-query-pre-scripts.md
@@ -9,8 +9,8 @@ The Data workbench currently runs the inherited pre-request script once when it
 ## User and API contract
 
 - `DataConfig.query_pre_script` is an optional string, defaulting to empty, limited to the same 256 KiB script budget as other request scripts. Existing imports and saved requests without the field continue to load. The Data editor shows it in a dedicated tab while disconnected and connected; edits are saved with the request but a running session uses the connection-time snapshot until reconnect.
-- Each accepted `data_query` carries a query ID, selected SQL, and read-only flag. The server presents the selected SQL to the isolated script worker as `pm.request.body.raw` in text mode. The script can set variables through existing scope APIs and replace SQL with `pm.request.body.update(...)`. It can log and test. `pm.response` is absent. The output SQL is resolved against the updated scoped values and then checked against the existing 64 KiB, single-statement, dialect, read-only/write and execution budgets. The script cannot change connection URL/auth, headers, method, protocol/source, file selection or read-only flag. Reject an attempted unsupported mutation before dispatching SQL.
-- Only one query preparation or execution is active per Data session. The next pre script waits for the previous query's response postprocessing to finish so it sees the prior script/extraction variable updates. An explicit cancel during preparation stops the preparation and emits a query-scoped cancelled/preparation error outcome without dispatching SQL. Failed/oversized/invalid pre script or SQL resolution emits `data_preprocess_error` with query ID and masked details, and must not run or retry SQL. `pm.skipRequest()` means no SQL and an explicit skipped result. No history record is created for a query that never reached the Data worker.
+- Each accepted `data_query` carries a query ID, selected SQL, and read-only flag. The server presents the selected SQL to the isolated script worker as `pm.request.body.raw` in text mode. This synthetic request uses the GET marker and `http://data.invalid/query` as its URL, so database credentials are not exposed as an HTTP URL. The script can set variables through existing scope APIs and replace SQL with `pm.request.body.update(...)`. It can log and test. `pm.response` is absent. The output SQL is resolved against the updated scoped values and then checked against the existing 64 KiB, single-statement, dialect, read-only/write and execution budgets. The script cannot change connection URL/auth, headers, method, protocol/source, file selection or read-only flag. Reject an attempted unsupported mutation before dispatching SQL.
+- Only one query preparation or execution is active per Data session. The next pre script waits for the previous query's response postprocessing to finish so it sees the prior script/extraction variable updates. An explicit cancel during preparation stops the preparation and emits a query-scoped cancelled/preparation error outcome without dispatching SQL. Failed/oversized/invalid pre script or SQL resolution emits `data_preprocess_error` with query ID and masked details, and must not run or retry SQL. `pm.execution.skipRequest()` means no SQL and an explicit skipped result. No history record is created for a query that never reached the Data worker.
 - Successful preparation emits a `data_prepared` event with the query ID, safe SQL preview or change indicator, tests/logs and non-private variable update metadata. The Data workbench displays preparation status before live rows and keeps it attached to the correct query; it does not silently edit the saved SQL draft. The actual resolved SQL source is passed to the protocol worker and retained by the existing completion/history path.
 
 ## Ownership, privacy and limits
diff --git a/tasks/implementation/data-query-pre-scripts-plan.md b/tasks/implementation/data-query-pre-scripts-plan.md
index ab167718..ce696289 100644
--- a/tasks/implementation/data-query-pre-scripts-plan.md
+++ b/tasks/implementation/data-query-pre-scripts-plan.md
@@ -59,6 +59,13 @@
 - [ ] Verify hosted PostgreSQL/MySQL SQL mutation and read-only enforcement in Application CI, then track the current platform build and perform one independent whole-branch review.
 - [ ] Update `docs/FEATURE-MATRIX.md`, `docs/IMPLEMENTATION-STATUS.md` and the remaining-work plan with exact supported combinations and still-open saved dataset/source/EDAS gates.
 
+## Progress, 2026-10-16
+
+- Saved `query_pre_script` has an empty legacy default, 256 KiB cap, bilingual editor and safe export screening. A real 390px remote CSV query changed selected SQL from `id=1` to `id=2`; English/Chinese status, tests, history link and saved/reloaded script were inspected.
+- Protocol reservation prevents concurrent admission and repeated dispatch of a query ID. The server runs the isolated script once per accepted query, uses the previous query's postprocessed variables, validates mutated SQL, and handles skip/error/cancel without running SQL. The worker enforces the saved read-only setting even if a client sends `read_only=false`.
+- Real file-worker regressions cover mutation, sequential variable updates, cancellation, skip, illegal request changes, read-only writes, private logs/update keys/database diagnostics and oversized preparation-event rollback. Data client tests passed (21); the full frontend suite passed (320), strict full-workspace Clippy, formatting and production frontend build passed. Independent review found four privacy/state issues and an event-limit rollback issue; each was fixed and rechecked.
+- Hosted PostgreSQL/MySQL query-pre mutation, full CI and current platform package gates remain pending. The pinned generator JAR is unavailable in this local checkout, so `cargo test --locked` awaits CI's pinned-asset preparation step. Other Data sources, saved datasets and EDAS are separate remaining capabilities.
+
 ## Review focus
 
 - A script changes the Data source, URL/auth, headers or read-only flag: fail before SQL and mask private diagnostics.
diff --git a/web/src/features/data/DataWorkbench.test.tsx b/web/src/features/data/DataWorkbench.test.tsx
index e1671b63..16adfed3 100644
--- a/web/src/features/data/DataWorkbench.test.tsx
+++ b/web/src/features/data/DataWorkbench.test.tsx
@@ -54,3 +54,14 @@ it("repeated dispatch before React renders admits only one query",()=>{
   act(()=>{value.dataRun.current?.();value.dataRun.current?.();});
   expect(value.protocolSession.send).toHaveBeenCalledTimes(1);
 });
+it("keeps query cancellation available while preparation send is pending",()=>{
+  const value=state();value.protocolSession.send.mockReturnValue(new Promise(()=>{}));
+  vi.mocked(useWorkbench).mockReturnValue(value as unknown as ReturnType<typeof useWorkbench>);
+  const view=render(<DataWorkbench/>);
+  fireEvent.click(screen.getByRole("button",{name:"运行当前查询"}));
+  value.protocolSession.sending=true;view.rerender(<DataWorkbench/>);
+  const cancel=screen.getByRole("button",{name:"取消查询"});
+  expect((cancel as HTMLButtonElement).disabled).toBe(false);
+  fireEvent.click(cancel);
+  expect(value.protocolSession.send).toHaveBeenCalledWith(expect.objectContaining({kind:"data_cancel"}));
+});
diff --git a/web/src/features/data/DataWorkbench.tsx b/web/src/features/data/DataWorkbench.tsx
index c582ad69..b5738266 100644
--- a/web/src/features/data/DataWorkbench.tsx
+++ b/web/src/features/data/DataWorkbench.tsx
@@ -34,12 +34,15 @@ export default function DataWorkbench(){
     <Flex className="data-toolbar" gap="3" align="center" justify="between" wrap="wrap"><Flex gap="3" align="center" wrap="wrap"><Heading size="3">{t("数据查询")}</Heading><Badge color={open?"green":"gray"}>{open?t("已连接"):channel.session?.state==="connecting"?t("连接中"):channel.session?.state==="error"?t("连接失败"):t("未连接")}</Badge>{model.info&&<Text size="1" className="mono wrap-anywhere">{model.info.public_url}{model.info.tls?model.info.tls_verified?" · TLS":` · ${t("TLS 未验证")}`:""}</Text>}</Flex><Flex gap="2"><Button variant="soft" color="gray" disabled={!connected} onClick={()=>void channel.close()}><Square size={14}/>{t("断开")}</Button></Flex></Flex>
     <DataSourceFields key={`${state.accountId}/${state.selectedId}/${state.request?.id}/${state.draft?.data.active_environment_id}`} config={config} change={change} connected={connected}/>
     {problem&&<Callout.Root color="red" role="alert"><Callout.Text>{problem}</Callout.Text></Callout.Root>}
+    {model.preparing&&<Text size="2" color="gray">{t("正在运行查询前脚本…")}</Text>}
     {channel.session?.reason&&<Text color="gray" size="1">{channel.session.reason}</Text>}
     <Tabs.Root value={tab} onValueChange={setTab} className="data-tabs"><Tabs.List><Tabs.Trigger value="query">{t("查询")}</Tabs.Trigger><Tabs.Trigger value="pre">{t("查询前脚本")}</Tabs.Trigger><Tabs.Trigger value="view">{t("数据视图")}</Tabs.Trigger></Tabs.List>
       <Tabs.Content value="query"><div className="data-query-layout"><aside className="data-schema" aria-label={t("数据结构浏览器")}><Flex gap="2" align="center" justify="between"><Text size="2" weight="medium">{t("数据结构")}</Text><Button size="1" variant="ghost" disabled={!open||!!model.active||channel.sending} aria-label={t("刷新数据结构")} onClick={()=>void channel.send({kind:"data_schema_refresh"})}><RefreshCw size={14}/></Button></Flex><TextField.Root value={search} onChange={e=>setSearch(e.target.value)} placeholder={t("搜索表和列")} aria-label={t("搜索表和列")}/>{model.schemaTruncated&&<Text size="1" color="gray">{t("仅显示部分结构，查询仍可直接使用完整表名。")}</Text>}{model.tables.filter(table=>!search||`${table.schema}.${table.name} ${table.columns.map(c=>c.name).join(" ")}`.toLowerCase().includes(search.toLowerCase())).map((table,index)=><details key={`${table.schema}/${table.name}/${index}`}><summary>{table.schema?`${table.schema}.`:""}{table.name}</summary><Button size="1" variant="ghost" onClick={()=>change({sql:`${config.sql.trim()}\nSELECT * FROM ${table.reference} LIMIT 100;`})}>{t("添加表查询")}</Button>{table.columns.map((column,index)=><button className="data-schema-column" key={`${column.name}/${index}`} onClick={()=>change({sql:config.sql+`\nSELECT ${column.reference} FROM ${table.reference} LIMIT 100;`})}><span>{column.name}</span><Text size="1" color="gray">{column.data_type}{column.nullable?" · NULL":""}</Text></button>)}</details>)}</aside>
-        <div className="data-editor-panel"><Flex gap="3" align="center" wrap="wrap"><Button disabled={!open||!!model.active||channel.sending} onClick={()=>void run()}><Play size={14}/>{t("运行当前查询")}</Button><Button variant="soft" disabled={!model.active||channel.sending} onClick={()=>model.active&&void channel.send({kind:"data_cancel",query_id:model.active})}>{t("取消查询")}</Button><Button variant="ghost" color="gray" onClick={format}><WandSparkles size={14}/>{t("格式化 SQL")}</Button></Flex><Text size="1" color="gray">{t("运行光标所在的语句；有选区时仅运行选区。连接环境修改后重连生效。")}</Text><DataSqlEditor run={()=>dispatch.current()} value={config.sql} change={sql=>change({sql})} source={config.source} tables={model.tables} dark={state.dark} selection={(from,to)=>{selection.current={from,to};}}/></div></div></Tabs.Content>
+        <div className="data-editor-panel"><Flex gap="3" align="center" wrap="wrap"><Button disabled={!open||!!model.active||channel.sending} onClick={()=>void run()}><Play size={14}/>{t("运行当前查询")}</Button><Button variant="soft" disabled={!model.active} onClick={()=>model.active&&void channel.send({kind:"data_cancel",query_id:model.active})}>{t("取消查询")}</Button><Button variant="ghost" color="gray" onClick={format}><WandSparkles size={14}/>{t("格式化 SQL")}</Button></Flex><Text size="1" color="gray">{t("运行光标所在的语句；有选区时仅运行选区。连接环境修改后重连生效。")}</Text><DataSqlEditor run={()=>dispatch.current()} value={config.sql} change={sql=>change({sql})} source={config.source} tables={model.tables} dark={state.dark} selection={(from,to)=>{selection.current={from,to};}}/></div></div></Tabs.Content>
       <Tabs.Content value="pre"><Flex direction="column" gap="2"><Text size="2" color="gray">{t("每条查询前运行此脚本；可用 pm.request.body.update() 修改本次 SQL。修改脚本后重连生效。")}</Text><Editor label={t("查询前 JavaScript 脚本")} value={config.query_pre_script} onChange={query_pre_script=>change({query_pre_script})} dark={state.dark} language="javascript" height="220px"/></Flex></Tabs.Content>
-      <Tabs.Content value="view"><Flex gap="3" align="center" wrap="wrap"><Button size="1" variant="soft" disabled={!model.active||channel.sending} onClick={()=>model.active&&void channel.send({kind:"data_cancel",query_id:model.active})}>{t("取消查询")}</Button></Flex><DataResults result={model.result}/>
+      <Tabs.Content value="view"><Flex gap="3" align="center" wrap="wrap"><Button size="1" variant="soft" disabled={!model.active} onClick={()=>model.active&&void channel.send({kind:"data_cancel",query_id:model.active})}>{t("取消查询")}</Button></Flex>
+        {model.preparation&&<Flex direction="column" gap="1"><Text size="2">{t("查询前脚本已完成")}{model.preparation.sql_changed?` · ${t("本次 SQL 已由脚本修改")}`:""}</Text>{model.preparation.tests.map(test=><Text key={test.id} size="2" color={test.passed?"green":"red"}>{test.passed?"✓":"✕"} {test.name}: {test.actual}</Text>)}{model.preparation.logs.map((log,index)=><Text key={index} size="2" color={log.level==="error"?"red":"gray"}>{log.level}: {log.message}</Text>)}{model.preparation.variable_updates.length>0&&<Text size="2">{t("变量更新")}: {model.preparation.variable_updates.map(update=>`${update.scope}.${update.key}`).join(", ")}</Text>}</Flex>}
+        <DataResults result={model.result}/>
         {model.result?.done&&!model.processing&&!model.processingError&&<Text size="2" color="gray">{t("正在保存查询历史…")}</Text>}
         {model.processingError&&<Callout.Root color="red" role="alert"><Callout.Text>{model.processingError}</Callout.Text></Callout.Root>}
         {model.processing&&<Flex direction="column" gap="2"><Text size="2">{t("查询后处理已完成")}</Text>{model.processing.notice&&<Text size="2" color="amber">{model.processing.notice==="history_cleared"?t("历史已清空，本次查询未保存；后处理结果仍可查看。") : t("结果超过 5 MiB，已隐藏历史行数据并跳过后处理。")}</Text>}{model.processing.tests.map(test=><Text key={test.id} size="2" color={test.passed?"green":"red"}>{test.passed?"✓":"✕"} {test.name}: {test.actual}</Text>)}{model.processing.logs.map((log,index)=><Text key={index} size="2" color={log.level==="error"?"red":"gray"}>{log.level}: {log.message}</Text>)}{model.processing.variable_updates.length>0&&<Text size="2">{t("变量更新")}: {model.processing.variable_updates.map(update=>`${update.scope}.${update.key}`).join(", ")}</Text>}{model.processing.history_id&&<Button size="1" variant="soft" onClick={()=>void openHistory(model.processing!.history_id!)}>{t("查看查询历史")}</Button>}</Flex>}
diff --git a/web/src/features/data/types.ts b/web/src/features/data/types.ts
index 9d212061..e0d5abc7 100644
--- a/web/src/features/data/types.ts
+++ b/web/src/features/data/types.ts
@@ -7,4 +7,5 @@ export interface SchemaTable {schema:string;name:string;reference:string;columns
 export interface ConnectionInfo {source:DataSource;public_url:string;tls:boolean;tls_verified:boolean;file_bytes:number|null}
 export interface Result {id:string;columns:DataColumn[];rows:Cell[][];elapsed_ms:number;rows_affected:number;truncated:boolean;limit_reason:string|null;done:boolean}
 export interface DataProcessing {query_id:string;history_id:string|null;notice:string|null;tests:import("../../shared/types").TestResult[];logs:import("../../shared/types").ScriptLog[];variable_updates:import("../../shared/types").VariableUpdate[]}
-export type DataEvent = {kind:"data_ready";info:ConnectionInfo} | {kind:"data_schema";tables:SchemaTable[];clear:boolean;done:boolean;truncated:boolean} | {kind:"data_started";query_id:string} | {kind:"data_columns";query_id:string;columns:DataColumn[]} | {kind:"data_rows";query_id:string;rows:Cell[][]} | {kind:"data_finished";query_id:string;rows_affected:number;elapsed_ms:number;truncated:boolean;limit_reason:string|null} | {kind:"data_error";query_id:string;message:string} | {kind:"data_cancelled";query_id:string;write_outcome_unknown:boolean} | ({kind:"data_processed"}&DataProcessing) | {kind:"data_postprocess_error";query_id:string;message:string};
+export interface DataPreparation {query_id:string;sql_changed:boolean;tests:import("../../shared/types").TestResult[];logs:import("../../shared/types").ScriptLog[];variable_updates:import("../../shared/types").VariableUpdate[]}
+export type DataEvent = {kind:"data_ready";info:ConnectionInfo} | {kind:"data_schema";tables:SchemaTable[];clear:boolean;done:boolean;truncated:boolean} | {kind:"data_preparing";query_id:string} | ({kind:"data_prepared"}&DataPreparation) | {kind:"data_preprocess_error";query_id:string;message:string} | {kind:"data_skipped";query_id:string} | {kind:"data_started";query_id:string} | {kind:"data_columns";query_id:string;columns:DataColumn[]} | {kind:"data_rows";query_id:string;rows:Cell[][]} | {kind:"data_finished";query_id:string;rows_affected:number;elapsed_ms:number;truncated:boolean;limit_reason:string|null} | {kind:"data_error";query_id:string;message:string} | {kind:"data_cancelled";query_id:string;write_outcome_unknown:boolean} | ({kind:"data_processed"}&DataProcessing) | {kind:"data_postprocess_error";query_id:string;message:string};
diff --git a/web/src/features/data/useDataEvents.test.tsx b/web/src/features/data/useDataEvents.test.tsx
index b2796811..b5a37631 100644
--- a/web/src/features/data/useDataEvents.test.tsx
+++ b/web/src/features/data/useDataEvents.test.tsx
@@ -53,3 +53,36 @@ it("shows saved history after a terminal query closes its connection",()=>{
   events=[...events,event(4,{kind:"data_processed",query_id:"query",history_id:"saved",notice:null,tests:[],logs:[],variable_updates:[]})];rerender();
   expect(result.current.processing?.history_id).toBe("saved");
 });
+it("releases a query after pre script failure without waiting for SQL events",()=>{
+  let events:ProtocolEvent[]=[];
+  const {result,rerender}=renderHook(()=>useDataEvents("session",events,0));
+  act(()=>{result.current.reserve("prepared-query");});
+  events=[event(1,{kind:"data_preparing",query_id:"prepared-query"}),event(2,{kind:"data_preprocess_error",query_id:"prepared-query",message:"Invalid query script"})];
+  rerender();
+  expect(result.current.active).toBe(null);
+  expect(result.current.error).toContain("Invalid query script");
+});
+it("does not show previous rows when a new query fails or is skipped before SQL",()=>{
+  let events=[event(1,{kind:"data_started",query_id:"old"}),event(2,{kind:"data_rows",query_id:"old",rows:[[{kind:"text",value:"old row"}]]}),event(3,{kind:"data_finished",query_id:"old",rows_affected:0,elapsed_ms:1,truncated:false,limit_reason:null})];
+  const {result,rerender}=renderHook(()=>useDataEvents("session",events,0));
+  expect(result.current.result?.rows).toHaveLength(1);
+  act(()=>{result.current.reserve("new");});
+  expect(result.current.result).toBe(null);
+  events=[...events,event(4,{kind:"data_preprocess_error",query_id:"new",message:"bad script"})];rerender();
+  expect(result.current.result).toBe(null);
+  act(()=>{result.current.reserve("skipped");});
+  events=[...events,event(5,{kind:"data_skipped",query_id:"skipped"})];rerender();
+  expect(result.current.result).toBe(null);
+  expect(result.current.active).toBe(null);
+});
+it("retains prepared tests through the SQL result and ignores a stale query",()=>{
+  let events:ProtocolEvent[]=[];
+  const {result,rerender}=renderHook(()=>useDataEvents("session",events,0));
+  act(()=>{result.current.reserve("current");});
+  const prepared={kind:"data_prepared" as const,query_id:"current",sql_changed:true,tests:[{id:"pre",name:"Prepared",passed:true,actual:"ok",expected:"ok"}],logs:[],variable_updates:[]};
+  events=[event(1,{...prepared,query_id:"stale"}),event(2,prepared),event(3,{kind:"data_started",query_id:"current"}),event(4,{kind:"data_finished",query_id:"current",rows_affected:0,elapsed_ms:3,truncated:false,limit_reason:null})];
+  rerender();
+  expect(result.current.preparation?.tests[0].name).toBe("Prepared");
+  expect(result.current.preparation?.sql_changed).toBe(true);
+  expect(result.current.result?.done).toBe(true);
+});
diff --git a/web/src/features/data/useDataEvents.ts b/web/src/features/data/useDataEvents.ts
index 780e7a3a..3aefa7a0 100644
--- a/web/src/features/data/useDataEvents.ts
+++ b/web/src/features/data/useDataEvents.ts
@@ -1,30 +1,34 @@
 import { useEffect,useRef,useState } from "react";
 import type { ProtocolEvent } from "../protocols/types";
-import type { ConnectionInfo,DataProcessing,Result,SchemaTable } from "./types";
+import type { ConnectionInfo,DataPreparation,DataProcessing,Result,SchemaTable } from "./types";
 import { message,translateCopy,type LocalizedCopy } from "../../shared/i18n";
 export function useDataEvents(sessionId:string|undefined,events:ProtocolEvent[],dropped:number) {
   const [info,setInfo]=useState<ConnectionInfo|null>(null),[tables,setTables]=useState<SchemaTable[]>([]),[schemaTruncated,setSchemaTruncated]=useState(false);
-  const [result,setResult]=useState<Result|null>(null),[active,setActive]=useState<string|null>(null),[error,setError]=useState<string|LocalizedCopy>(""),[processing,setProcessing]=useState<DataProcessing|null>(null),[processingError,setProcessingError]=useState("");
+  const [result,setResult]=useState<Result|null>(null),[active,setActive]=useState<string|null>(null),[error,setError]=useState<string|LocalizedCopy>(""),[processing,setProcessing]=useState<DataProcessing|null>(null),[processingError,setProcessingError]=useState(""),[preparation,setPreparation]=useState<DataPreparation|null>(null),[preparing,setPreparing]=useState(false);
   const cursor=useRef(0),scope=useRef(sessionId),query=useRef<string|null>(null),schemaGap=useRef(false),inFlight=useRef(false);
   useEffect(()=>{
-    if(scope.current!==sessionId){scope.current=sessionId;cursor.current=0;query.current=null;inFlight.current=false;schemaGap.current=false;setInfo(null);setTables([]);setResult(null);setActive(null);setError("");setProcessing(null);setProcessingError("");setSchemaTruncated(false);}
+    if(scope.current!==sessionId){scope.current=sessionId;cursor.current=0;query.current=null;inFlight.current=false;schemaGap.current=false;setInfo(null);setTables([]);setResult(null);setActive(null);setError("");setProcessing(null);setProcessingError("");setPreparation(null);setPreparing(false);setSchemaTruncated(false);}
     const first=events.find(event=>event.cursor>cursor.current);
     if(first&&first.cursor>cursor.current+1){query.current=null;inFlight.current=false;schemaGap.current=true;setTables([]);setResult(null);setActive(null);setSchemaTruncated(true);setError(message("结果事件已被淘汰，请重新运行查询。"));}
     for(const event of events){if(event.cursor<=cursor.current)continue;cursor.current=event.cursor;const m=event.message;
       switch(m.kind){
         case "data_ready":setInfo(m.info);break;
         case "data_schema":if(m.clear)schemaGap.current=false;setTables(old=>m.clear?m.tables:[...old,...m.tables]);setSchemaTruncated(schemaGap.current||m.truncated);break;
-        case "state":if(m.state==="closed"||m.state==="error"){if(inFlight.current){setResult(null);setError(message("连接在查询完成前关闭，请重新连接。"));query.current=null;}inFlight.current=false;setActive(null);}break;
-        case "data_started":if(query.current&&query.current!==m.query_id)break;query.current=m.query_id;inFlight.current=true;setActive(m.query_id);setError("");setProcessing(null);setProcessingError("");setResult({id:m.query_id,columns:[],rows:[],elapsed_ms:0,rows_affected:0,truncated:false,limit_reason:null,done:false});break;
+        case "state":if(m.state==="closed"||m.state==="error"){if(inFlight.current){setResult(null);setError(message("连接在查询完成前关闭，请重新连接。"));query.current=null;}inFlight.current=false;setActive(null);setPreparing(false);}break;
+        case "data_preparing":if(query.current===m.query_id&&inFlight.current)setPreparing(true);break;
+        case "data_prepared":if(query.current===m.query_id&&inFlight.current){setPreparation(m);setPreparing(false);}break;
+        case "data_preprocess_error":if(query.current===m.query_id){inFlight.current=false;setActive(null);setResult(null);setPreparing(false);setError(m.message);}break;
+        case "data_skipped":if(query.current===m.query_id){inFlight.current=false;setActive(null);setResult(null);setPreparing(false);setError(message("查询前脚本跳过了本次 SQL。"));}break;
+        case "data_started":if(query.current&&query.current!==m.query_id)break;query.current=m.query_id;inFlight.current=true;setActive(m.query_id);setPreparing(false);setError("");setProcessing(null);setProcessingError("");setResult({id:m.query_id,columns:[],rows:[],elapsed_ms:0,rows_affected:0,truncated:false,limit_reason:null,done:false});break;
         case "data_columns":setResult(old=>old?.id===m.query_id?{...old,columns:m.columns}:old);break;
         case "data_rows":setResult(old=>old?.id===m.query_id?{...old,rows:[...old.rows,...m.rows]}:old);break;
         case "data_finished":if(query.current===m.query_id)inFlight.current=false;setActive(old=>old===m.query_id?null:old);setResult(old=>old?.id===m.query_id?{...old,elapsed_ms:m.elapsed_ms,rows_affected:m.rows_affected,truncated:m.truncated,limit_reason:m.limit_reason,done:true}:old);break;
         case "data_error":if(m.query_id&&query.current!==m.query_id)break;if(m.query_id)inFlight.current=false;setActive(old=>old===m.query_id?null:old);setError(m.message);setResult(old=>old?.id===m.query_id?{...old,done:true}:old);break;
-        case "data_cancelled":if(query.current!==m.query_id)break;inFlight.current=false;setActive(old=>old===m.query_id?null:old);setError(m.write_outcome_unknown?message("已请求取消并关闭连接，写入结果可能未知。"):message("已请求取消并关闭连接。"));setResult(null);break;
+        case "data_cancelled":if(query.current!==m.query_id)break;inFlight.current=false;setActive(old=>old===m.query_id?null:old);setPreparing(false);setError(m.write_outcome_unknown?message("已请求取消并关闭连接，写入结果可能未知。"):message("已请求取消并关闭连接。"));setResult(null);break;
         case "data_processed":if(query.current===m.query_id)setProcessing(m);break;
         case "data_postprocess_error":if(query.current===m.query_id)setProcessingError(m.message);break;
       }
     }
   },[sessionId,events,dropped]);
-  return {info,tables,schemaTruncated,result,active,error:translateCopy(error),processing,processingError,reserve:(id:string)=>{if(inFlight.current)return false;query.current=id;inFlight.current=true;setActive(id);setError("");setProcessing(null);setProcessingError("");return true;},release:(id:string)=>{if(query.current===id){query.current=null;inFlight.current=false;setActive(null);}}};
+  return {info,tables,schemaTruncated,result,active,error:translateCopy(error),processing,processingError,preparation,preparing,reserve:(id:string)=>{if(inFlight.current)return false;query.current=id;inFlight.current=true;setActive(id);setResult(null);setError("");setProcessing(null);setProcessingError("");setPreparation(null);setPreparing(true);return true;},release:(id:string)=>{if(query.current===id){query.current=null;inFlight.current=false;setActive(null);setPreparing(false);}}};
 }
diff --git a/web/src/features/protocols/events.ts b/web/src/features/protocols/events.ts
index 4beb8915..5f2b7711 100644
--- a/web/src/features/protocols/events.ts
+++ b/web/src/features/protocols/events.ts
@@ -29,7 +29,7 @@ export function appendEvents(
 export function messageContent(event: ProtocolEvent): string {
   const message = event.message;
   switch (message.kind) {
-    case "data_ready":case "data_schema":case "data_started":case "data_columns":case "data_rows":case "data_finished":case "data_error":case "data_cancelled":case "data_processed":case "data_postprocess_error":return JSON.stringify(message,null,2);
+    case "data_ready":case "data_schema":case "data_preparing":case "data_prepared":case "data_preprocess_error":case "data_skipped":case "data_started":case "data_columns":case "data_rows":case "data_finished":case "data_error":case "data_cancelled":case "data_processed":case "data_postprocess_error":return JSON.stringify(message,null,2);
     case "tcp_data": {
       if(message.redacted)return t("私密载荷已隐藏 · {{value0}} 字节", { value0: message.bytes });
       try {return [message.text!==null ? `UTF8:\n${message.text}` : t("UTF8: 非文本数据"),`Hex:\n${hex.encode(base64.decode(message.base64))}`,`Base64:\n${message.base64}`].join("\n\n");}
diff --git a/web/src/features/protocols/lifecycle.test.tsx b/web/src/features/protocols/lifecycle.test.tsx
index 8bde9d60..febd036f 100644
--- a/web/src/features/protocols/lifecycle.test.tsx
+++ b/web/src/features/protocols/lifecycle.test.tsx
@@ -11,6 +11,7 @@ import { useWorkbenchController } from "../workbench/useWorkbenchController";
 import type { useWorkspace } from "../workspaces/useWorkspace";
 import type { useLocalVariables } from "../variables/useLocalVariables";
 import type { ProtocolSession } from "./types";
+import { dataConfig } from "../data/model";
 vi.mock("../../shared/api", async (original) => ({
   ...(await original<typeof import("../../shared/api")>()),
   api: vi.fn(),
@@ -77,6 +78,28 @@ afterEach(() => {
   cleanup();
   client.clear();
 });
+it("sends Data cancellation while a query preparation request is pending", async () => {
+  const dataRequest = {...request, protocol:dataConfig()};
+  const dataSession = {...session, protocol:"data" as const};
+  let finishQuery!: (value:unknown)=>void;
+  vi.mocked(api).mockImplementation((path,method,body) => {
+    if(path==="/api/sessions"&&method==="POST") return Promise.resolve(dataSession);
+    if(path.endsWith("/events?after=0")) return Promise.resolve({events:[],next_cursor:0,earliest_cursor:1,dropped_count:0});
+    if(path==="/api/sessions/session-a/send"&&method==="POST"&&body&&typeof body==="object"&&"kind" in body&&body.kind==="data_query") return new Promise(done=>{finishQuery=done;});
+    if(path==="/api/sessions/session-a/send"&&method==="POST") return Promise.resolve({ok:true});
+    return Promise.resolve(dataSession);
+  });
+  const workspace = {accountId:"account-a",draft,dirty:false,save:vi.fn()} as unknown as ReturnType<typeof useWorkspace>;
+  const locals = {values:()=>[],apply:vi.fn()} as unknown as ReturnType<typeof useLocalVariables>;
+  const hook = renderHook(()=>useProtocolSession(workspace,dataRequest,locals,true),{wrapper:Wrapper});
+  await act(async()=>await hook.result.current.connect());
+  let pending!:Promise<boolean>;
+  act(()=>{pending=hook.result.current.send({kind:"data_query",query_id:"query",sql:"SELECT 1",read_only:true});});
+  await waitFor(()=>expect(hook.result.current.sending).toBe(true));
+  await act(async()=>expect(await hook.result.current.send({kind:"data_cancel",query_id:"query"})).toBe(true));
+  expect(api).toHaveBeenCalledWith("/api/sessions/session-a/send","POST",{kind:"data_cancel",query_id:"query"});
+  await act(async()=>{finishQuery({ok:true});await pending;});
+});
 it("closes late session creation after unmount without applying its private updates", async () => {
   let resolve!: (value: ProtocolSession) => void;
   const pending = new Promise<ProtocolSession>((done) => (resolve = done));
diff --git a/web/src/features/protocols/useProtocolSession.ts b/web/src/features/protocols/useProtocolSession.ts
index 1772055c..8bd81ec4 100644
--- a/web/src/features/protocols/useProtocolSession.ts
+++ b/web/src/features/protocols/useProtocolSession.ts
@@ -243,17 +243,20 @@ export function useProtocolSession(
     }
   }
   async function send(message: SendMessage) {
+    const cancelData = message.kind === "data_cancel";
     if (
       !sessionId ||
       live?.session.state !== "open" ||
-      sends.current.has(scopeKey())
+      (sends.current.has(scopeKey()) && !cancelData)
     )
       return false;
     const origin = identity;
     const epoch = generation.current;
     const ticket = scopeKey();
-    sends.current.add(ticket);
-    setSendingFor([...sends.current]);
+    if (!cancelData) {
+      sends.current.add(ticket);
+      setSendingFor([...sends.current]);
+    }
     try {
       await api(
         `/api/sessions/${encodeURIComponent(sessionId)}/send`,
@@ -270,8 +273,10 @@ export function useProtocolSession(
         toast.error(liveError(caught));
       return false;
     } finally {
-      sends.current.delete(ticket);
-      if (mounted.current) setSendingFor([...sends.current]);
+      if (!cancelData) {
+        sends.current.delete(ticket);
+        if (mounted.current) setSendingFor([...sends.current]);
+      }
     }
   }
   return {
diff --git a/web/src/shared/i18n/en.json b/web/src/shared/i18n/en.json
index e4bc02c3..96dbada6 100644
--- a/web/src/shared/i18n/en.json
+++ b/web/src/shared/i18n/en.json
@@ -1032,6 +1032,10 @@
   "TLS 未验证": "TLS unverified",
   "查询": "Query",
   "查询前脚本": "Before query",
+  "查询前脚本跳过了本次 SQL。": "The before-query script skipped this SQL query.",
+  "正在运行查询前脚本…": "Running before-query script…",
+  "查询前脚本已完成": "Before-query script completed",
+  "本次 SQL 已由脚本修改": "The script changed this query's SQL",
   "查询前 JavaScript 脚本": "Before-query JavaScript",
   "每条查询前运行此脚本；可用 pm.request.body.update() 修改本次 SQL。修改脚本后重连生效。": "Runs before each query. Use pm.request.body.update() to change this query's SQL. Reconnect to apply script edits.",
   "数据视图": "Data view",
diff --git a/web/src/shared/i18n/zh-CN.json b/web/src/shared/i18n/zh-CN.json
index 584fb832..2dc41f24 100644
--- a/web/src/shared/i18n/zh-CN.json
+++ b/web/src/shared/i18n/zh-CN.json
@@ -1032,6 +1032,10 @@
   "TLS 未验证": "TLS 未验证",
   "查询": "查询",
   "查询前脚本": "查询前脚本",
+  "查询前脚本跳过了本次 SQL。": "查询前脚本跳过了本次 SQL。",
+  "正在运行查询前脚本…": "正在运行查询前脚本…",
+  "查询前脚本已完成": "查询前脚本已完成",
+  "本次 SQL 已由脚本修改": "本次 SQL 已由脚本修改",
   "查询前 JavaScript 脚本": "查询前 JavaScript 脚本",
   "每条查询前运行此脚本；可用 pm.request.body.update() 修改本次 SQL。修改脚本后重连生效。": "每条查询前运行此脚本；可用 pm.request.body.update() 修改本次 SQL。修改脚本后重连生效。",
   "数据视图": "数据视图",