diff --git a/CHANGELOG.md b/CHANGELOG.md
index b9c44be..4501546 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,21 @@ auto-generated per-PR notes; this file is the curated, human-readable history.
 ## [Unreleased]
 
 ### Changed
+- **Workbench run lifecycle extracted into a route-scoped `WorkbenchSession`**
+  (#276 Phase 3a). `run`/`runScript`/`runEntry`/`cancel` orchestration now
+  lives in `src/ui/workbench/workbench-session.ts`; the run bookkeeping
+  fields (`runT0`/`runQueryId`/`runTick`) and the in-flight `AbortController`
+  are private session state (the `RunState` cast and `AppState.abortController`
+  are gone — issue rule 5: cancellation belongs to its owner). The session is
+  the sole production writer of the `running` signal; the three run-coupled
+  reactive effects register through `session.attachShell(...)` with captured
+  disposers (idempotent on re-render — also fixes a latent double-registration
+  on the connect → re-render path), and `destroy()` releases effects, the
+  elapsed ticker, and any in-flight operation (unit-proven; no production
+  caller until Phase 5's route shells). The architecture guard now carries a
+  rule list: route sessions (`ui/workbench` ↔ `ui/dashboard`) must not import
+  each other, and the dashboard route must not import the editor. Behavior
+  byte-identical.
 - **Authentication and connection lifecycle extracted into `ConnectionSession`**
   (#276 Phase 2). OAuth PKCE login/refresh, Basic-auth probing, IdP config
   resolution, identity, sign-in/out, and the cross-tab dashboard auth handoff
diff --git a/build/check-boundaries.mjs b/build/check-boundaries.mjs
index 4da81bb..ce14eea 100644
--- a/build/check-boundaries.mjs
+++ b/build/check-boundaries.mjs
@@ -1,10 +1,13 @@
-// Architecture boundary guard (issue #276 Phase 0). Day-1 rule only: modules
-// under src/application/ must not import from src/ui/ or src/editor/ — the
-// route/session layer coordinates state and network, it does not reach into
-// DOM rendering or the CodeMirror editor adapters. `import type` counts too:
-// a type-only import still couples the layers at compile time. Later phases
-// (#276 Phases 3-5) extend the rule set (e.g. route sessions must not import
-// each other) — add checks here rather than growing a second script.
+// Architecture boundary guard (issue #276). Rule list, grown per phase:
+//   Phase 0 — src/application/ must not import src/ui/ or src/editor/: the
+//   service layer coordinates state and network, it does not reach into DOM
+//   rendering or the CodeMirror editor adapters.
+//   Phase 3 — the route sessions must not import each other's implementation
+//   modules (ui/workbench ↔ ui/dashboard), and the dashboard route must not
+//   depend on the editor ports at all.
+// `import type` counts too: a type-only import still couples the layers at
+// compile time. Extend RULES below in later phases rather than growing a
+// second script.
 //
 // Hand-rolled regex scan, no AST parser: the codebase has no exotic import
 // syntax, so scanning for import/export specifiers is enough and keeps this
@@ -15,10 +18,16 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const appDir = path.join(repoRoot, 'src', 'application');
-const FORBIDDEN = ['src/ui', 'src/editor'];
 const SOURCE_EXT = /\.(ts|tsx|js|mjs)$/;
 
+/** Each rule: every source file under `dir` must not import anything that
+ *  resolves under any of `forbidden` (directories, repo-relative). */
+const RULES = [
+  { dir: 'src/application', forbidden: ['src/ui', 'src/editor'], why: 'issue #276 day-1 rule' },
+  { dir: 'src/ui/workbench', forbidden: ['src/ui/dashboard'], why: 'issue #276 Phase 3: route sessions must not import each other' },
+  { dir: 'src/ui/dashboard', forbidden: ['src/ui/workbench', 'src/editor'], why: 'issue #276 Phase 3: route sessions must not import each other; dashboard has no editor' },
+];
+
 function collectFiles(dir) {
   const out = [];
   for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
@@ -29,12 +38,6 @@ function collectFiles(dir) {
   return out;
 }
 
-const files = fs.existsSync(appDir) ? collectFiles(appDir) : [];
-if (files.length === 0) {
-  console.log('check-boundaries: no files under src/application/ yet');
-  process.exit(0);
-}
-
 // Matches, in order: static `import ... from '...'` (incl. `import type`),
 // `export ... from '...'` (incl. `export type`), a bare side-effect
 // `import '...'`, and dynamic `import('...')`. Each pattern requires only
@@ -71,25 +74,38 @@ function resolveRelative(fromFile, spec) {
 }
 
 const violations = [];
-for (const file of files) {
-  const source = fs.readFileSync(file, 'utf8');
-  for (const spec of extractSpecifiers(source)) {
-    if (!spec.startsWith('.')) continue; // bare/package specifiers can't reach src/ui or src/editor
-    const resolved = resolveRelative(file, spec);
-    const relResolved = path.relative(repoRoot, resolved).split(path.sep).join('/');
-    const inForbidden = FORBIDDEN.some((f) => relResolved === f || relResolved.startsWith(`${f}/`));
-    if (inForbidden) {
-      const relFile = path.relative(repoRoot, file).split(path.sep).join('/');
-      violations.push(`${relFile} → ${spec} (resolved: ${relResolved})`);
+let checkedFiles = 0;
+let activeRules = 0;
+for (const rule of RULES) {
+  const ruleDir = path.join(repoRoot, rule.dir);
+  const files = fs.existsSync(ruleDir) ? collectFiles(ruleDir) : [];
+  if (files.length === 0) continue; // directory not born yet — rule activates with it
+  activeRules += 1;
+  checkedFiles += files.length;
+  for (const file of files) {
+    const source = fs.readFileSync(file, 'utf8');
+    for (const spec of extractSpecifiers(source)) {
+      if (!spec.startsWith('.')) continue; // bare/package specifiers can't reach src dirs
+      const resolved = resolveRelative(file, spec);
+      const relResolved = path.relative(repoRoot, resolved).split(path.sep).join('/');
+      const hit = rule.forbidden.find((f) => relResolved === f || relResolved.startsWith(`${f}/`));
+      if (hit) {
+        const relFile = path.relative(repoRoot, file).split(path.sep).join('/');
+        violations.push(`${relFile} → ${spec} (resolved: ${relResolved}; ${rule.dir} must not import ${hit} — ${rule.why})`);
+      }
     }
   }
 }
 
 if (violations.length) {
-  console.error('check-boundaries: src/application/ must not import src/ui/ or src/editor/ (issue #276, day-1 rule):');
+  console.error('check-boundaries: layer-boundary violations (issue #276):');
   for (const line of violations) console.error(`  ${line}`);
   process.exit(1);
 }
 
-console.log(`check-boundaries: OK (${files.length} file${files.length === 1 ? '' : 's'} under src/application/, no ui/editor imports)`);
+if (checkedFiles === 0) {
+  console.log('check-boundaries: no files under any guarded directory yet');
+  process.exit(0);
+}
+console.log(`check-boundaries: OK (${checkedFiles} file${checkedFiles === 1 ? '' : 's'} across ${activeRules} active rule${activeRules === 1 ? '' : 's'}, no violations)`);
 process.exit(0);
diff --git a/src/state.ts b/src/state.ts
index 652630f..af09ddb 100644
--- a/src/state.ts
+++ b/src/state.ts
@@ -210,7 +210,6 @@ export interface AppState {
   bannerDismissedFor: Signal<string | null>;
   serverVersion: string | null;
   running: Signal<boolean>;
-  abortController: AbortController | null;
   schemaGraphAbortController: AbortController | null;
   resultView: Signal<'table' | 'json' | 'panel' | 'filter'>;
   exporting: Signal<boolean>;
@@ -394,11 +393,10 @@ export function createState(read: StateReader = { loadJSON, loadStr }): AppState
     // Run state (signals): `running` flips the Run button + results pane via
     // effects; `resultView` is the active Table/JSON/Chart tab. Via `.value`.
     running: signal(false),
-    abortController: null,
     // In-flight schema-lineage fetch (issue #124's inline drawer graph) — its own
-    // AbortController, separate from `abortController` (run/script) and the
-    // export controllers, since a graph fetch isn't gated by `running` and a
-    // second click/drag must be able to supersede an in-flight one.
+    // AbortController, separate from the workbench session's own run/script
+    // controller and the export controllers, since a graph fetch isn't gated by
+    // `running` and a second click/drag must be able to supersede an in-flight one.
     schemaGraphAbortController: null,
     resultView: signal<'table' | 'json' | 'panel' | 'filter'>('table'),
     // True while a streaming Export (issue #87) is in flight — separate from
@@ -564,9 +562,12 @@ export function patchSpecDraft(
   return { ok: true, invalidTab: null, spec: tab.specParsed! };
 }
 
-/** The saved query a tab is linked to (via tab.savedId), or null. */
+/** The saved query a tab is linked to (via tab.savedId), or null. Narrowed to
+ *  exactly the slice it reads (`savedQueries`) — not the full `AppState` —
+ *  so a caller (e.g. `WorkbenchSession`'s own state slice) can pass a Pick
+ *  without a bridging cast. */
 export function savedForTab(
-  state: AppState, tab: Pick<QueryTab, 'savedId'> | null | undefined,
+  state: Pick<AppState, 'savedQueries'>, tab: Pick<QueryTab, 'savedId'> | null | undefined,
 ): SavedQueryV2 | null {
   return (tab && tab.savedId && state.savedQueries.find((q) => q.id === tab.savedId)) || null;
 }
@@ -851,9 +852,11 @@ export function markLibrarySaved(state: AppState): void {
 }
 
 // Push one history entry (most-recent first, capped at 50). Internal — the
-// exported recorders below supply the sql/rows/ms.
+// exported recorders below supply the sql/rows/ms. Narrowed to `history`
+// (the only field it reads/writes) so `recordScriptHistory` below can pass a
+// narrower-than-`AppState` slice through unchanged.
 function pushHistory(
-  state: AppState, sql: string | null | undefined, rows: number | null, ms: number,
+  state: Pick<AppState, 'history'>, sql: string | null | undefined, rows: number | null, ms: number,
   save: SaveJSON, now: number,
 ): void {
   const s = String(sql || '').trim();
@@ -890,9 +893,12 @@ export function recordHistory(
 }
 
 /** Record a successful multiquery script run as one history entry (the whole
- *  script text); per-statement row counts aren't meaningful, so rows is null. */
+ *  script text); per-statement row counts aren't meaningful, so rows is null.
+ *  Narrowed to `Pick<AppState, 'history'>` — the only field it reads/writes —
+ *  so a caller (e.g. `WorkbenchSession`'s own state slice) can pass a Pick
+ *  without a bridging cast. */
 export function recordScriptHistory(
-  state: AppState, sql: string, ms: number, save: SaveJSON = saveJSON, now: number = Date.now(),
+  state: Pick<AppState, 'history'>, sql: string, ms: number, save: SaveJSON = saveJSON, now: number = Date.now(),
 ): void {
   pushHistory(state, sql, null, Math.round(ms), save, now);
 }
diff --git a/src/ui/app.ts b/src/ui/app.ts
index eac7393..b4ebff2 100644
--- a/src/ui/app.ts
+++ b/src/ui/app.ts
@@ -19,23 +19,19 @@ import {
   fieldControls, fieldControlKind,
 } from '../core/param-pipeline.js';
 import type {
-  ParameterAnalysis, PreparedSource, PreparedBatch, PreparedFieldState, ValidationMode, BoundParamSnapshot, FieldControl,
+  ParameterAnalysis, PreparedSource, PreparedBatch, PreparedFieldState, ValidationMode, FieldControl,
 } from '../core/param-pipeline.js';
 import { hasOptionalBlocks } from '../core/optional-blocks.js';
 import { saveJSON, saveStr } from '../core/storage.js';
-import { sqlString, inferQueryName, shortVersion, supportsExplainPretty, userShortName, withStatementBreak, detectSqlFormat, isSchemaMutatingSql, prepareExportSql, formatBytes, formatRows } from '../core/format.js';
-import { EXPLAIN_VIEWS, parseExplain, detectExplainView, buildExplainQuery } from '../core/explain.js';
+import { sqlString, inferQueryName, shortVersion, userShortName, withStatementBreak, isSchemaMutatingSql, prepareExportSql, formatBytes, formatRows } from '../core/format.js';
 import { buildSchemaGraph, expandLineage } from '../core/schema-graph.js';
 import { buildCardGraph } from '../core/schema-cards.js';
 import type { SchemaCardColumnRow } from '../core/schema-cards.js';
 import { toTSV, formatFileMeta, exportFilename, scriptExportName } from '../core/export.js';
 import { newResult, parseErrorPos, findExceptionFrame } from '../core/stream.js';
-import { buildResultSource } from '../core/query-source.js';
 import { encodeShare } from '../core/share.js';
 import { queryName, queryPanel, withQuerySpec } from '../core/saved-query.js';
 import { effectiveDashboardRole } from '../core/result-choice.js';
-import { filterExecution } from '../core/filter-execution.js';
-import { readFilterOptions } from '../core/filter-options.js';
 import {
   CORE_SPEC_VALIDATORS, createSpecValidatorRegistry, evaluateSpecText, formatSpecText,
   hasBlockingSpecErrors,
@@ -44,7 +40,6 @@ import type { SpecValidatorEntry, QuerySpecValidationService } from '../core/spe
 import type { SpecDiagnostic } from '../editor/spec-editor.types.js';
 import { assembleReferenceData, buildCompletions } from '../core/completions.js';
 import { isQuerylessPanel } from '../core/panel-cfg.js';
-import { isKpiPanel, panelExecution } from '../core/panel-execution.js';
 import * as ch from '../net/ch-client.js';
 import { createNoopPort } from '../editor/editor-port.js';
 import type { EditorPort } from '../editor/editor-port.types.js';
@@ -91,6 +86,7 @@ import type { SchemaGraphFocus, SchemaGraphNode, SchemaGraphEdge } from '../core
 import type { LineageFocus } from '../net/ch-client.js';
 import { createQueryExecutionService } from '../application/query-execution-service.js';
 import { createConnectionSession } from '../application/connection-session.js';
+import { createWorkbenchSession } from './workbench/workbench-session.js';
 
 /** Optional globals a plain browser page (or the CM6/Chart/dagre UMD bundles a
  *  `<script>` tag might attach) can carry that aren't in the standard `Window`
@@ -98,43 +94,6 @@ import { createConnectionSession } from '../application/connection-session.js';
  *  supplies `Chart`/`Dagre` (imported packages) via `env` directly. These are
  *  only the env-absent fallback reads below (`win.Chart`, `win.dagre`, …), kept
  *  narrow and all-optional so a plain `Window` still satisfies this widened type. */
-/** `run()`/`runScript()`'s own bookkeeping on `app.state` — a live query's
- *  wall-clock start (`runT0`), its ClickHouse `query_id` (`runQueryId`, for
- *  Cancel's KILL QUERY), and the live-elapsed-ms ticker's interval handle
- *  (`runTick`). `state.ts`'s own `AppState` doesn't declare these fields (set
- *  and read only by app.ts + tests exercising it directly) — narrowed locally
- *  via `runState(app.state)` rather than widening the shared state.ts contract
- *  for this single consumer. */
-interface RunState {
-  runT0: number | null;
-  runQueryId: string | null;
-  runTick: ReturnType<typeof setInterval> | null;
-}
-const runState = (s: AppState): AppState & RunState => s as AppState & RunState;
-
-/** `run()`'s own options bag — an explicit selection override (`sql`), the
- *  Explain button / EXPLAIN-view-switch flags, and a saved-query's remembered
- *  result view. Every real call site (`runEntry`, `explainQuery`,
- *  `setExplainView`, the saved-query open path) passes a subset of exactly
- *  these fields. */
-interface RunOpts {
-  sql?: string;
-  explain?: boolean;
-  explainView?: string;
-  view?: string;
-}
-
-/** The transport `run()` executes under for a KPI-owned panel — the shared
- *  read of `core/panel-execution.js`'s `PanelExecutionResult` (the non-Filter
- *  branch) and the plain Filter-role stand-in literal (the `isFilter` branch),
- *  narrowed to exactly the fields `run()` itself reads. */
-interface KpiExecutionTransport {
-  format?: string;
-  rowLimit?: number;
-  params: Record<string, string | number>;
-  error: string | null;
-}
-
 /** The var-strip's combobox-based field controller — whichever of
  *  `buildEnumField`/`buildRelativeTimeField`/`buildRecentField` `ctl.kind`
  *  picks. Only `RelativeTimeField` actually declares `previewEl` (the #169
@@ -623,9 +582,6 @@ export function createApp(env: CreateAppEnv = {}): App {
     runQuery: ch.runQuery, killQuery: ch.killQuery, ctx: () => chCtx, now, uid, retryMs, sleep, sqlString,
   });
   app.exec = exec;
-  // Milliseconds since the running query started (0 when idle). Used for the
-  // live counter, computed fresh so each render/tick shows the current value.
-  app.elapsedMs = () => (runState(app.state).runT0 != null ? now() - runState(app.state).runT0! : 0);
   // Exposed so results.js can compute a script-export row's live elapsed time
   // (now() - e.startedAt) with the same injected clock as exportScript itself.
   app.now = now;
@@ -719,328 +675,37 @@ export function createApp(env: CreateAppEnv = {}): App {
     return false;
   }
 
-  async function run(opts?: RunOpts): Promise<void> {
-    if (app.state.running.value) return; // already running — cancel via cancel()/Esc
-    const tab = app.activeTab();
-    // `opts.sql` overrides the source SQL (a single selected statement); otherwise
-    // the whole tab runs, byte-for-byte as before (FORMAT / EXPLAIN detection,
-    // trailing `;`, history).
-    const srcSql = opts && opts.sql != null ? opts.sql : tab.sqlDraft;
-    if (!srcSql.trim()) return;
-    const isFilter = effectiveDashboardRole(tab.specParsed) === 'filter';
-    const filterRun = isFilter ? filterExecution(srcSql) : null;
-    if (filterRun?.error) {
-      const filterErrorResult: QueryResult = newResult('Filter', filterRun.rowLimit);
-      filterErrorResult.error = filterRun.error;
-      Object.assign(tab, { result: filterErrorResult });
-      tab.filterPreview = { status: 'error', error: filterRun.error };
-      app.state.resultView.value = 'filter';
-      renderResults(app);
-      return;
-    }
-    const waveMs = wallNow(); // one wall clock for this run wave: gate + args see the same instant
-    if (!isFilter && varGateBlocked(waveMs)) return; // Filter parameters fail statically above
-    // One prepared source for the whole run wave (#173), captured NOW —
-    // synchronously with the gate check above, BEFORE the auth awaits below
-    // (review F6 invariant, shared with runScript/exportDirect/exportScript):
-    // gate and args see the same varValues snapshot; a value edited while a
-    // token refresh is in flight applies to the NEXT run, and can never reach
-    // the server as a never-gate-checked binding. Reused on success for the
-    // recent-value recording (#171), so it reads exactly the boundParams that
-    // were sent.
-    const src = prepareTabSource(srcSql, waveMs);
-    await ensureConfig();
-    if (!(await getToken())) { chCtx.onSignedOut(); return; }
-    cancelSchemaGraph(); // a Run/Explain takes over the result — don't leave a lineage fetch running
-
-    // EXPLAIN-view bookkeeping: the Explain button (opts.explain) forces any query
-    // into EXPLAIN-view mode; a normal Run clears that; switching an EXPLAIN tab
-    // (opts.explainView) preserves it.
-    if (opts && opts.explain) app.state.forceExplain = true;
-    else if (!(opts && opts.explainView != null)) app.state.forceExplain = false;
-
-    // Every downstream decision + the request itself operate on the statement's
-    // execution view (#165): inactive optional blocks removed, markers
-    // stripped — byte-identical to srcSql for SQL without blocks. History still
-    // records the template (srcSql / tab.sqlDraft).
-    const execSql = isFilter ? srcSql : execStatementSql(srcSql);
-
-    const kpiExecution: KpiExecutionTransport = isFilter
-      ? { format: 'Table', rowLimit: app.state.resultRowLimit, params: {}, error: null }
-      : panelExecution(tabPanel(tab), execSql, {
-        format: 'Table', rowLimit: app.state.resultRowLimit, params: {},
-      });
-    if (kpiExecution.error) {
-      const kpiErrorResult: QueryResult = newResult('KPI', 2);
-      kpiErrorResult.error = kpiExecution.error;
-      Object.assign(tab, { result: kpiErrorResult });
-      app.state.resultView.value = 'panel';
-      renderResults(app);
-      return;
-    }
-
-    // An explicit FORMAT clause runs raw and shows ClickHouse's response verbatim
-    // (single raw tab). Otherwise an EXPLAIN (typed, or forced by the button) gets
-    // the five EXPLAIN views; everything else streams structured (Table).
-    const panelIsKpi = !isFilter && isKpiPanel(tabPanel(tab));
-    const explicitFmt = isFilter || panelIsKpi ? null : detectSqlFormat(execSql);
-    const parsed = isFilter || explicitFmt ? null : parseExplain(execSql);
-    const explainMode = !isFilter && !explicitFmt && (parsed != null || app.state.forceExplain);
-    let runSql = execSql;
-    let fmt: string;
-    let explainView: string | null = null;
-    if (isFilter) {
-      fmt = filterRun!.format;
-    } else if (explainMode) {
-      // View precedence: an explicit tab click wins; otherwise a *typed* EXPLAIN
-      // is honored exactly (canonical match → its rich view, else the verbatim
-      // Explain view); the button-forced path falls through to Explain. We never
-      // inherit a stale view from a previous run/tab — typing a plain EXPLAIN must
-      // show the plan, not whatever view was last open.
-      explainView = (opts && opts.explainView)
-        || (parsed && detectExplainView(parsed))
-        || 'explain';
-      fmt = (EXPLAIN_VIEWS.find((v) => v.id === explainView) || EXPLAIN_VIEWS[0]).chFormat;
-      const inner = parsed ? parsed.inner : execSql;
-      const explainOpts = { pretty: supportsExplainPretty(app.state.serverVersion) };
-      runSql = explainView === 'explain' && parsed
-        ? execSql
-        : buildExplainQuery(inner, explainView, explainOpts);
-    } else {
-      fmt = panelIsKpi ? kpiExecution.format! : explicitFmt || 'Table';
-    }
-
-    // Cap a normal result query (Table or explicit-FORMAT SELECT) at the global
-    // row limit; EXPLAIN/PIPELINE/ESTIMATE are exempt (small output, and a cap
-    // would truncate a plan oddly). The streaming guard reads it off the result;
-    // runQuery adds the server-side max_result_rows for the Table path.
-    const rowLimit = isFilter ? filterRun!.rowLimit : explainMode ? 0 : panelIsKpi ? kpiExecution.rowLimit! : app.state.resultRowLimit;
-    const t0 = now();
-    const result: QueryResult = newResult(fmt, rowLimit);
-    Object.assign(tab, { result });
-    if (isFilter) tab.filterPreview = { status: 'running' };
-    if (explainView) result.explainView = explainView;
-    app.state.resultSort = { col: null, dir: 'asc' };
-    const rs = runState(app.state);
-    rs.runT0 = t0;
-    rs.runQueryId = uid('q');
-    app.state.abortController = new AbortController();
-    rs.runTick = setInterval(tickElapsed, 100);
-    // Keep the current Table/JSON/Panel tab across re-runs (#34); a saved-query
-    // open passes its remembered view in opts.view to restore that instead
-    // (a stray legacy 'chart' value maps to 'panel' — #166).
-    const view = opts && opts.view === 'chart' ? 'panel' : opts && opts.view;
-    // Flip the run signals last, in one batch: the results + Run-button effects
-    // fire on this write and read runT0/elapsed, so the bookkeeping above must
-    // already be set. (The old explicit setRunBtn(true)/renderResults are now
-    // those effects' job.)
-    batch(() => {
-      app.state.resultView.value = view != null && ['table', 'json', 'panel', 'filter'].includes(view)
-        ? (view as 'table' | 'json' | 'panel' | 'filter') : app.state.resultView.value;
-      app.state.running.value = true;
-    });
-
-    try {
-      await exec.executeRead(result, {
-        sql: runSql,
-        format: fmt,
-        rowLimit,
-        queryId: rs.runQueryId,
-        signal: app.state.abortController.signal,
-        // Native ClickHouse query parameters (#134/#173): pass prepared values
-        // as param_<name> so the server substitutes them (only row-returning
-        // statements bind — a CREATE VIEW / DDL source stays verbatim).
-        params: isFilter
-          ? filterRun!.params
-          : { ...sessionParamsFor(tab, [srcSql]), ...mergedSourceArgs(src), ...kpiExecution.params },
-        onChunk: () => renderResults(app),
-      });
-    } finally {
-      clearInterval(rs.runTick as ReturnType<typeof setInterval>);
-      rs.runTick = null;
-      app.state.abortController = null;
-      rs.runQueryId = null;
-      rs.runT0 = null;
-      result.progress.elapsed_ns = (now() - t0) * 1e6;
-      if (isFilter) {
-        tab.filterPreview = result.error || result.cancelled
-          ? { status: 'error', error: result.error || 'Filter query was cancelled.' }
-          : {
-              status: 'success',
-              normalized: readFilterOptions({
-                columns: result.columns,
-                row: result.rows[0],
-                rowCount: result.rows.length,
-              }),
-            };
-      }
-      // #185: capture the source that produced a normal, row-returning
-      // structured result (fmt 'Table', so raw FORMAT / EXPLAIN are excluded;
-      // empty results stay ineligible), so the Data Pane's Expand can open an
-      // interactive, independently re-runnable detached view. The authored
-      // template (srcSql — optional-block markers intact) and the run-time
-      // title/description are snapshotted here, never re-derived from the
-      // editor/Library at expand time (which may have changed). This MUST run
-      // BEFORE the running flip below: that flip fires the results effect that
-      // renders the toolbar + its Expand affordance, which gates on
-      // `result.source` — set it after and the button never appears until the
-      // next paint.
-      if (!result.error && !result.cancelled && (fmt === 'Table' || fmt === 'KPI') && result.rows.length > 0) {
-        result.source = buildResultSource({
-          srcSql,
-          tabId: tab.id,
-          rowLimit,
-          tabName: tab.name,
-          savedEntry: savedForTab(app.state, tab),
-        });
-      }
-      // Flip running off last: the results + Run-button effects fire here and
-      // render the final stats, so elapsed_ns must already be recorded. (Old
-      // explicit setRunBtn(false)/renderResults are now those effects' job.)
-      app.state.running.value = false;
-      if (!result.error && !result.cancelled) {
-        // Spec completion is intentionally stable during a run and survives a
-        // later failed/cancelled run. Snapshot only completed structured
-        // results; never expose partially streamed metadata to the editor.
-        tab.lastSuccessfulResultColumns = (fmt === 'Table' || fmt === 'KPI' || fmt === 'Filter')
-          ? result.columns.map((column) => ({ ...column }))
-          : [];
-        app.recordHistory(tab, opts && opts.sql);
-        // #171: this statement succeeded — record its bound params (exactly
-        // what was actually sent; an omitted-optional-block param never
-        // reached `src.statements[*].boundParams` in the first place).
-        app.recordBoundParams(src.statements.flatMap((s) => s.boundParams) as BoundParamSnapshot[]);
-        if (isSchemaMutatingSql(runSql)) app.loadSchema(); // not awaited — fire and forget
-      }
-    }
-  }
-
-  // Run a `;`-separated script sequentially: one ClickHouse request per statement
-  // (CH's HTTP interface runs exactly one statement per request), stopping on the
-  // first failure. Row-returning statements (SELECT/WITH/SHOW/…) are fetched as
-  // JSONCompact capped at 100 rows; everything else runs for effect and reports
-  // OK. The result is a per-statement summary grid (tab.result.script). The whole
-  // script is recorded as one history entry on a clean run. `originalInput` is the
-  // exact text that was split (the selection or the whole editor).
-  async function runScript(statements: string[], originalInput: string): Promise<void> {
-    if (app.state.running.value) return;
-    const waveMs = wallNow(); // one wall clock for the whole script wave
-    if (varGateBlocked(waveMs)) return; // block a script run with unfilled variables
-    // One prepared batch for the whole script (#173): `statements` came from
-    // splitStatements(originalInput), so the batch's statements align by index.
-    // Captured NOW — synchronously with the gate check above, BEFORE the auth
-    // awaits (review F6 invariant, shared with run/exportDirect/exportScript):
-    // gate and args see the same varValues snapshot; edits during the auth
-    // await apply to the next run.
-    const paramSrc = prepareTabSource(originalInput, waveMs);
-    await ensureConfig();
-    if (!(await getToken())) { chCtx.onSignedOut(); return; }
-    cancelSchemaGraph(); // a script run takes over the result — don't leave a lineage fetch running
-    app.state.forceExplain = false;
-    const tab = app.activeTab();
-    const t0 = now();
-    const entries: ScriptEntry[] = [];
-    const scriptResult: ScriptResult = { script: entries };
-    Object.assign(tab, { result: scriptResult });
-    app.state.resultSort = { col: null, dir: 'asc' };
-    const rs = runState(app.state);
-    rs.runT0 = t0;
-    app.state.abortController = new AbortController();
-    rs.runTick = setInterval(tickElapsed, 100);
-    let aborted = false;
-    // Attach a session only if the script needs one (TEMPORARY / SET) or the tab
-    // already has one — same params for every statement, computed once.
-    const sp = sessionParamsFor(tab, statements);
-    app.state.running.value = true; // the results effect paints the (empty) grid
-    try {
-      // Transport/retry loop (one ClickHouse request per statement, the
-      // SESSION_IS_LOCKED / transient-network retry, stop-on-first-failure)
-      // now lives in application/query-execution-service.ts (#276 Phase 1) —
-      // this loop owns only orchestration: per-statement wire text (#165's
-      // execution view), the live query_id (for Cancel), pushing entries +
-      // repainting, and per-statement boundParams recording.
-      const res = await exec.executeScript({
-        statements: statements.map((stmt, i) => ({
-          sql: stmt,
-          // The wire text is the pipeline's per-statement execution view (#165):
-          // inactive optional blocks removed for row-returning statements,
-          // verbatim (byte-identical) for everything else and for block-free SQL.
-          // The result grid keeps showing the authored `stmt`.
-          execSql: paramSrc.statements[i].sql,
-          // Per-statement prepared args (#134/#173): the pipeline binds only
-          // row-returning statements, so a DDL / CREATE VIEW statement in the
-          // script is sent with its {name:Type} placeholders intact.
-          params: { ...sp, ...paramSrc.statements[i].args },
-        })),
-        signal: app.state.abortController.signal,
-        // Fresh query_id per attempt, published before the request so Cancel
-        // issues KILL QUERY against the statement that's actually running.
-        onStatementStart: (_i, { queryId }) => { rs.runQueryId = queryId; },
-        onStatementResult: (i, entry) => {
-          entries.push(entry);
-          // #171: THIS statement succeeded — record its own boundParams (per
-          // statement, not per script: statement 1 of a later-failing script
-          // still records; an error entry stops the script and never records).
-          if (entry.status !== 'error') app.recordBoundParams([...paramSrc.statements[i].boundParams]);
-          renderResults(app);
-        },
-      });
-      aborted = res.aborted;
-    } finally {
-      clearInterval(rs.runTick as ReturnType<typeof setInterval>);
-      rs.runTick = null;
-      app.state.abortController = null;
-      rs.runQueryId = null;
-      rs.runT0 = null;
-      scriptResult.elapsedMs = now() - t0;
-      if (aborted) scriptResult.cancelled = true;
-      app.state.running.value = false;
-      // A statement that actually ran (status !== 'error') and was schema-mutating
-      // refreshes the tree even if a later statement in the script failed — it
-      // already took effect server-side.
-      if (entries.some((e) => e.status !== 'error' && isSchemaMutatingSql(e.sql))) app.loadSchema();
-      // One history entry for the whole script — but only on a clean run (mirrors
-      // run(): no history for an aborted or failed script).
-      if (!aborted && !entries.some((e) => e.status === 'error')) {
-        recordScriptHistory(app.state, originalInput, scriptResult.elapsedMs!, saveJSON);
-        if (app.state.sidePanel.value === 'history') renderSavedHistory(app);
-      }
-    }
-  }
-
-  // The Run button / ⌘+Enter entry point. A non-empty (non-whitespace) editor
-  // selection runs just that text; otherwise the whole tab. The chosen text is
-  // split: one statement keeps today's rich Table/Chart/EXPLAIN path (run());
-  // more than one runs sequentially as a script (runScript).
-  function runEntry(opts?: RunOpts): void | Promise<void> {
-    if (app.activeTab().editorMode !== 'sql') return;
-    if (app.state.running.value) return;
-    const sel = app.sqlEditor.getSelection().text;
-    const hasSel = sel.trim() !== '';
-    const input = hasSel ? sel : app.activeTab().sqlDraft;
-    const statements = splitStatements(input);
-    if (!statements.length) return; // nothing runnable (empty / comments-only)
-    // The unfilled-variable gate (#134) lives in run()/runScript() — the shared
-    // execution choke points — so Explain, row-limit re-runs, and Export are
-    // gated too, not just this path.
-    // Mobile (#126): a run jumps the bottom-nav to the Results panel so the data
-    // the user just asked for is what they see next.
-    if (app.state.isMobile.value) app.state.mobileView.value = 'results';
-    if (effectiveDashboardRole(app.activeTab().specParsed) === 'filter') {
-      return run(hasSel ? { ...opts, sql: input } : opts);
-    }
-    // >1 statement → script grid (a remembered single-result view doesn't apply).
-    if (statements.length > 1) return runScript(statements, input);
-    // 1 statement → today's rich path. Forward opts (e.g. a saved query's
-    // remembered view / Explain); a selection adds the sql override.
-    return run(hasSel ? { ...opts, sql: input } : opts);
-  }
-  // Stop an in-flight query: abort the stream and KILL QUERY on the server.
-  function cancel(): void {
-    if (!app.state.running.value) return;
-    if (app.state.abortController) app.state.abortController.abort();
-    exec.kill(runState(app.state).runQueryId); // fire-and-forget, same as before
-  }
+  // The run/runScript/runEntry/cancel orchestration (#276 Phase 3a) now lives
+  // in ui/workbench/workbench-session.ts — a route-scoped session that owns
+  // the run bookkeeping (runT0/runQueryId/runTick) and the in-flight
+  // AbortController privately (formerly this file's own `runState` cast +
+  // `app.state.abortController`). This shell supplies the DOM/render hooks
+  // (results/history repaint, schema reload, the selection/toast/tick seams)
+  // and the ClickHouse/param-pipeline dependencies the session's core logic
+  // needs; `renderApp`'s `attachShell` call wires the 3 run-coupled reactive
+  // effects (results repaint / Run button / mobile badge) the session owns.
+  const workbench = createWorkbenchSession({
+    exec, ensureConfig, getToken, now, wallNow, uid,
+    state: app.state, // AppState structurally satisfies WorkbenchStateSlice
+    activeTab: () => app.activeTab(),
+    hooks: {
+      renderResults: () => renderResults(app),
+      renderSavedHistory: () => renderSavedHistory(app),
+      cancelSchemaGraph,
+      loadSchema: () => { void app.loadSchema(); },
+      recordHistory: (tab, sql) => app.recordHistory(tab, sql),
+      recordBoundParams: (bp) => app.recordBoundParams([...bp]),
+      prepareTabSource, varGateBlocked, execStatementSql, sessionParamsFor,
+      getSelectionText: () => app.sqlEditor.getSelection().text,
+      tickElapsed,
+      saveJSON,
+      onAuthFailed: () => chCtx.onSignedOut(),
+    },
+  });
+  app.workbench = workbench;
+  // Milliseconds since the running query started (0 when idle) — delegates to
+  // the session's own private runT0 bookkeeping.
+  app.elapsedMs = () => workbench.elapsedMs();
   // Keep `app.hardenedVars` (#170 review) in sync with a field's just-computed
   // 'execute'-mode verdict: added when it's invalid, cleared otherwise — so a
   // corrected-then-reharded value, or a variable that simply stopped being
@@ -1577,12 +1242,12 @@ export function createApp(env: CreateAppEnv = {}): App {
   // views (the editor SQL is left untouched; run() wraps it as needed).
   function explainQuery(): Promise<void> | undefined {
     if (app.activeTab().editorMode !== 'sql') return undefined;
-    return explainMultiBlocked() ? undefined : run({ explain: true });
+    return explainMultiBlocked() ? undefined : workbench.run({ explain: true });
   }
   // Switch the active EXPLAIN view (re-runs the derived query, keeps the mode).
   function setExplainView(id: string): Promise<void> | undefined {
     if (app.activeTab().editorMode !== 'sql') return undefined;
-    return explainMultiBlocked() ? undefined : run({ explainView: id });
+    return explainMultiBlocked() ? undefined : workbench.run({ explainView: id });
   }
   // Change the global result-row cap: persist the (normalized) preference and
   // re-run the current query so a raise genuinely fetches more (server-side cap),
@@ -1591,7 +1256,7 @@ export function createApp(env: CreateAppEnv = {}): App {
   function setResultRowLimit(n: number): Promise<void> | undefined {
     app.state.resultRowLimit = normalizeRowLimit(n);
     app.savePref('resultRowLimit', app.state.resultRowLimit);
-    return app.activeTab().editorMode === 'sql' ? run() : undefined;
+    return app.activeTab().editorMode === 'sql' ? workbench.run() : undefined;
   }
 
   // Fetch the DDL for `target` (e.g. 'db.table' or 'DATABASE db') with
@@ -1706,13 +1371,14 @@ export function createApp(env: CreateAppEnv = {}): App {
   // --- streaming export (issue #87 single-file / #99 script) --------------
   // Full, uncapped export of a query — never the loaded grid — streamed
   // straight to a user-chosen file. Its own query_id + abort, kept separate
-  // from app.state.runQueryId/abortController so an export and a grid run
-  // never clobber each other's cancel state.
+  // from the workbench session's own private run bookkeeping so an export and
+  // a grid run never clobber each other's cancel state.
   let exportAbort: AbortController | null = null;
   let exportQueryId: string | null = null;
   // Script-export state (issue #99) — its own abort/query-id, reassigned each
   // iteration so Cancel reaches the in-flight statement, and kept distinct
-  // from both app.state.run* and the single-export state above.
+  // from both the workbench session's own run bookkeeping and the single-
+  // export state above.
   let exportScriptAbort: AbortController | null = null;
   let exportScriptQueryId: string | null = null;
   let exportScriptCancelled = false;
@@ -2276,8 +1942,8 @@ export function createApp(env: CreateAppEnv = {}): App {
 
   // --- actions registry --------------------------------------------------
   app.actions = {
-    run: runEntry,
-    cancel,
+    run: (opts) => workbench.runEntry(opts),
+    cancel: () => workbench.cancel(),
     newTab: () => newTab(app),
     selectTab: (id) => selectTab(app, id),
     closeTab: (id) => closeTab(app, id),
@@ -2535,19 +2201,26 @@ export function renderApp(app: App, helpers: RenderAppHelpers): void {
     app.renderVarStrip(); // switching tabs / opening a saved query re-detects variables
     app.updateEditorModeUi!(); // assigned just above, unconditionally, before any effect can run
   });
-  // Reactive repaint of the results pane: re-runs on a tab switch, a Table/JSON/
-  // Chart view change, or a run-state flip. (renderResults' activeTab() also
-  // reads tabs.value, so a tab-list change repaints here too.) Streaming-data
-  // repaints still call renderResults directly from run()'s onChunk.
-  effect(() => {
-    app.state.activeTabId.value;
-    app.state.resultView.value;
-    app.state.running.value;
-    renderResults(app);
+  // The workbench's 3 run-coupled reactive effects (#276 Phase 3a — see
+  // workbench-session.ts's own `attachShell`): the results-pane repaint
+  // (re-runs on a tab switch, a Table/JSON/Chart view change, or a run-state
+  // flip — renderResults' activeTab() also reads tabs.value, so a tab-list
+  // change repaints here too; streaming-data repaints still call renderResults
+  // directly from the session's own onChunk), the Run button (label + disabled,
+  // reflecting the run state and the selection — Run ↔ Run selection), and the
+  // mobile Results-nav badge (● while a query streams, else the row count).
+  // Idempotent: re-registers (disposing the previous set) on every renderApp()
+  // re-run.
+  app.workbench.attachShell({
+    renderResults: () => renderResults(app),
+    setRunBtn: (running) => app.setRunBtn(running),
+    setMobileBadge: () => {
+      const r = app.activeTab().result as QueryResult | null;
+      app.dom.mobileBadge!.textContent = state.running.value
+        ? '●'
+        : (r && r.rawText == null && r.progress ? formatRows(r.progress.rows) : '');
+    },
   });
-  // The Run button reflects the run state (label + disabled) and the selection
-  // (Run ↔ Run selection).
-  effect(() => { app.state.hasSelection.value; app.setRunBtn(app.state.running.value); });
   // The Export button reflects the exporting state — set here (not just at
   // click-time) so a second click while one export is already running is
   // blocked visually too, not just by exportDirect's own re-entrance guard.
@@ -2610,15 +2283,6 @@ export function renderApp(app: App, helpers: RenderAppHelpers): void {
   // breakpoint). Each runs once now for the initial paint.
   effect(() => { mainRow.dataset.mobileView = state.mobileView.value; });
   effect(() => { sidebar.dataset.mobileTab = state.mobileTab.value; });
-  // The Results nav badge: ● while a query streams, else the row count (blank for
-  // no/raw result). Same deps as the results repaint so it tracks run/tab/view.
-  effect(() => {
-    state.running.value; state.activeTabId.value; state.resultView.value;
-    const r = app.activeTab().result as QueryResult | null;
-    app.dom.mobileBadge!.textContent = state.running.value
-      ? '●'
-      : (r && r.rawText == null && r.progress ? formatRows(r.progress.rows) : '');
-  });
   app.loadVersion();
   app.loadSchema();
   app.loadReference();
diff --git a/src/ui/app.types.ts b/src/ui/app.types.ts
index b94f8ef..c9e494a 100644
--- a/src/ui/app.types.ts
+++ b/src/ui/app.types.ts
@@ -19,6 +19,7 @@ import type { ConnectionSession, SessionChCtx } from '../application/connection-
 import type { SpecValidatorFn } from '../core/spec-draft.js';
 import type { SavedQueryV2 } from '../generated/json-schema.types.js';
 import type { DynamicSources } from '../core/spec-completion.js';
+import type { WorkbenchSession } from './workbench/workbench-session.js';
 
 export type { QueryTab as Tab, AppState as State } from '../state.js';
 
@@ -283,6 +284,12 @@ export interface App {
   now(): number;
   elapsedMs(): number;
   tickElapsed(): void;
+  /** The route-scoped run/runScript/runEntry/cancel session (#276 Phase 3a —
+   *  `src/ui/workbench/workbench-session.ts`), constructed without App/DOM.
+   *  Owns the run bookkeeping and in-flight AbortController privately; the
+   *  Run/Cancel actions and the Explain/row-limit re-run paths delegate to it,
+   *  and `renderApp`'s `attachShell` call wires its 3 run-coupled effects. */
+  workbench: WorkbenchSession;
   /** The shared request/stream/normalize + multiquery-script transport
    *  service (#276 Phase 1) — `src/application/query-execution-service.ts`,
    *  constructible without App/AppState/DOM. `src/ui/**` may depend on
diff --git a/src/ui/workbench/workbench-session.ts b/src/ui/workbench/workbench-session.ts
new file mode 100644
index 0000000..050d9f8
--- /dev/null
+++ b/src/ui/workbench/workbench-session.ts
@@ -0,0 +1,597 @@
+// #276 Phase 3a WorkbenchSession — route-scoped owner of the workbench
+// running operation and its cancellation state (issue rule 5). Owns
+// run/runScript/runEntry/cancel orchestration; the run bookkeeping fields
+// (runT0/runQueryId/runTick) and the in-flight AbortController are PRIVATE
+// session state (formerly the RunState cast + AppState.abortController).
+// Coordinates — but does not own — the shared AppState signals (running/
+// resultView/...): the session is the sole production writer of `running`.
+// DOM/render stays in the shell via injected hooks. Lives under ui/workbench
+// (the issue's target layout); must not import ui/dashboard/** (check:arch
+// enforces this) nor app.js/app.types.js.
+//
+// This session IS the live implementation: `createApp` constructs it
+// (`app.workbench`), the actions registry delegates run/cancel/explain/
+// row-limit re-runs to it, and `renderApp` wires the three run-coupled
+// reactive effects through `attachShell` (idempotent — a re-render disposes
+// the previous set first). `destroy()` has no production caller yet (the
+// page is single-route today; Phase 5's route shells will invoke it) — its
+// teardown behavior is proven by the unit tests per the issue's acceptance
+// criteria.
+
+import { effect, batch } from '@preact/signals-core';
+import type { Signal } from '@preact/signals-core';
+import { savedForTab, tabPanel, recordScriptHistory } from '../../state.js';
+import type { QueryTab, HistoryEntry, SaveJSON, AppState } from '../../state.js';
+import type { SavedQueryV2 } from '../../generated/json-schema.types.js';
+import type { ResultSort } from '../../core/sort.js';
+import { splitStatements } from '../../core/sql-split.js';
+import { mergedSourceArgs } from '../../core/param-pipeline.js';
+import type { PreparedSource, BoundParamSnapshot } from '../../core/param-pipeline.js';
+import { supportsExplainPretty, detectSqlFormat, isSchemaMutatingSql } from '../../core/format.js';
+import { EXPLAIN_VIEWS, parseExplain, detectExplainView, buildExplainQuery } from '../../core/explain.js';
+import { effectiveDashboardRole } from '../../core/result-choice.js';
+import { filterExecution } from '../../core/filter-execution.js';
+import { readFilterOptions } from '../../core/filter-options.js';
+import { isKpiPanel, panelExecution } from '../../core/panel-execution.js';
+import { newResult } from '../../core/stream.js';
+import { buildResultSource } from '../../core/query-source.js';
+import type { QueryResult, ScriptResult, ScriptEntry } from '../results.js';
+import type { QueryExecutionService } from '../../application/query-execution-service.js';
+
+// ── The state slice run()/runScript()/runEntry()/cancel() touch ────────────
+// Pick-shaped, structurally satisfied by the real `AppState` (state.ts) — a
+// production caller passes `app.state` directly, no adapter needed. Two
+// members (`savedQueries`/`history`) are also read/written by the pure
+// `savedForTab`/`recordScriptHistory` helpers below, whose own signatures are
+// narrowed (state.ts) to exactly the `Pick<AppState, ...>` this slice already
+// satisfies — no bridge cast needed to call them with `state` directly.
+
+/** Result views a saved query can remember — DERIVED from state.ts's own
+ *  `resultView` signal type (type-only, no runtime import) so the two can
+ *  never drift; same pattern as saved-history.ts's ResultView. */
+export type WorkbenchResultView = AppState['resultView']['value'];
+
+export interface WorkbenchStateSlice {
+  running: Signal<boolean>;
+  resultView: Signal<WorkbenchResultView>;
+  /** Reassigned wholesale (`state.resultSort = {...}`) at the start of every
+   *  run/runScript wave — a plain settable property, not a signal. */
+  resultSort: ResultSort;
+  /** Reassigned by the Explain button / a normal Run — plain, not a signal. */
+  forceExplain: boolean;
+  resultRowLimit: number;
+  serverVersion: string | null;
+  /** Read by runScript's clean-run history branch ('history' ⇒ repaint). */
+  sidePanel: Signal<string>;
+  isMobile: Signal<boolean>;
+  mobileView: Signal<'tables' | 'editor' | 'results'>;
+  /** Read by the Run-button effect (Run ↔ "Run selection" label). */
+  hasSelection: Signal<boolean>;
+  /** Read by the results-repaint + mobile-badge effects (attachShell) — NOT
+   *  read by run()/runScript()/runEntry()/cancel() themselves, which address
+   *  the active tab via `deps.activeTab()` instead. */
+  activeTabId: Signal<string>;
+  /** Read by `savedForTab` (state.ts, narrowed to `Pick<AppState,
+   *  'savedQueries'>`) to resolve a run's `result.source.title`/`.description`. */
+  savedQueries: SavedQueryV2[];
+  /** Read/written by `recordScriptHistory` (state.ts, narrowed to
+   *  `Pick<AppState, 'history'>`) on a clean script run. */
+  history: HistoryEntry[];
+}
+
+// ── Injected DOM/render hooks (used INSIDE run()/runScript()/runEntry()) ───
+
+export interface WorkbenchHooks {
+  /** Per-chunk (run) + per-statement (runScript) results-pane repaint. */
+  renderResults(): void;
+  /** runScript's clean-run history repaint when `sidePanel === 'history'`. */
+  renderSavedHistory(): void;
+  cancelSchemaGraph(): void;
+  /** Fire-and-forget schema reload after schema-mutating SQL succeeds. */
+  loadSchema(): void;
+  /** Records a successful single-statement run in history (and, per the real
+   *  app.ts wrapper this replaces, repaints History when it's the open side
+   *  panel — that repaint is this hook's own responsibility, unlike
+   *  `renderSavedHistory` above which the session calls itself for the
+   *  script-history path). */
+  recordHistory(tab: QueryTab, sql?: string): void;
+  recordBoundParams(bp: readonly BoundParamSnapshot[]): void;
+  /** The #173 pipeline's single-source prepare, always in 'execute' mode (the
+   *  only mode run()/runScript() ever use) — Phase 4 moves this into a
+   *  WorkbenchParameterSession; injected until then. */
+  prepareTabSource(sql: string, waveMs: number): PreparedSource;
+  /** True (and already toasted, shell-owned) when the active tab's
+   *  {name:Type} variables block execution. */
+  varGateBlocked(waveMs: number): boolean;
+  /** One statement's execution-view wire text (#165: inactive optional
+   *  blocks stripped). Only run() (single-statement path) uses this —
+   *  runScript gets its per-statement wire text from its own prepared batch. */
+  execStatementSql(stmt: string): string;
+  sessionParamsFor(tab: QueryTab, sqls: string[]): Record<string, string>;
+  /** The SQL editor's current selection text (runEntry's selection-run
+   *  override). */
+  getSelectionText(): string;
+  /** DOM readout write stays in the shell; the session's own 100ms interval
+   *  calls this while a run is in flight. */
+  tickElapsed(): void;
+  /** `recordScriptHistory`'s persistence arg — core/storage.js's `saveJSON`
+   *  shape (state.ts's own `SaveJSON` alias). */
+  saveJSON: SaveJSON;
+  /** Fired when `deps.getToken()` resolves null (signed out / unrefreshable)
+   *  in run()/runScript() — restores the ported code's original
+   *  `chCtx.onSignedOut(); return;` behavior without the session itself
+   *  knowing about `chCtx`/`ConnectionSession`. The shell wires this to its
+   *  ConnectionSession sign-out flow (e.g. `() => chCtx.onSignedOut()`); the
+   *  session stays ignorant of `chCtx`. */
+  onAuthFailed(): void;
+}
+
+// ── Construction deps ────────────────────────────────────────────────────────
+
+export interface WorkbenchSessionDeps {
+  exec: Pick<QueryExecutionService, 'executeRead' | 'executeScript' | 'kill'>;
+  ensureConfig(): Promise<unknown>;
+  /** Resolves the live bearer/basic credential, or null when signed out /
+   *  unrefreshable — run()/runScript() call `hooks.onAuthFailed()` and return
+   *  in that case (byte-equivalent to the ported app.ts's
+   *  `chCtx.onSignedOut(); return;`), keeping the session itself ignorant of
+   *  `chCtx`/`ConnectionSession`. */
+  getToken(): Promise<string | null>;
+  /** Perf clock — elapsedMs()/the run's own t0, matches app.ts's `now`. */
+  now(): number;
+  /** Wall clock — one snapshot per run/script wave (the #173 F6 invariant),
+   *  matches app.ts's `wallNow`. */
+  wallNow(): number;
+  uid(prefix: string): string;
+  state: WorkbenchStateSlice;
+  activeTab(): QueryTab;
+  hooks: WorkbenchHooks;
+}
+
+// ── attachShell: the 3 run-coupled effects, verbatim from renderApp ─────────
+
+export interface WorkbenchShellEffects {
+  /** The results-repaint effect's body (app.ts renderApp ~2542-2547):
+   *  `renderResults(app)`. */
+  renderResults(): void;
+  /** The Run-button effect's body (app.ts renderApp ~2550): `app.setRunBtn(running)`. */
+  setRunBtn(running: boolean): void;
+  /** The mobile-badge effect's body (app.ts renderApp ~2615-2621) — the shell
+   *  closure reads its own dom/badge element and `running`/the active tab's
+   *  result to compute the text. */
+  setMobileBadge(): void;
+}
+
+// ── run()'s own options bag (app.ts ~120-125, moved here verbatim) ──────────
+
+/** `run()`'s own options bag — an explicit selection override (`sql`), the
+ *  Explain button / EXPLAIN-view-switch flags, and a saved-query's remembered
+ *  result view. Every real call site (`runEntry`, `explainQuery`,
+ *  `setExplainView`, the saved-query open path) passes a subset of exactly
+ *  these fields. */
+export interface RunOpts {
+  sql?: string;
+  explain?: boolean;
+  explainView?: string;
+  view?: string;
+}
+
+/** The transport `run()` executes under for a KPI-owned panel — the shared
+ *  read of `core/panel-execution.js`'s `PanelExecutionResult` (the non-Filter
+ *  branch) and the plain Filter-role stand-in literal (the `isFilter` branch),
+ *  narrowed to exactly the fields `run()` itself reads. */
+interface KpiExecutionTransport {
+  format?: string;
+  rowLimit?: number;
+  params: Record<string, string | number>;
+  error: string | null;
+}
+
+export interface WorkbenchSession {
+  run(opts?: RunOpts): Promise<void>;
+  runScript(statements: string[], originalInput: string): Promise<void>;
+  runEntry(opts?: RunOpts): void | Promise<void>;
+  cancel(): void;
+  elapsedMs(): number;
+  attachShell(effects: WorkbenchShellEffects): void;
+  destroy(): void;
+}
+
+export function createWorkbenchSession(deps: WorkbenchSessionDeps): WorkbenchSession {
+  const { state, hooks } = deps;
+
+  // `run()`/`runScript()`'s own bookkeeping — a live query's wall-clock start
+  // (`runT0`), its ClickHouse `query_id` (`runQueryId`, for Cancel's KILL
+  // QUERY), and the live-elapsed-ms ticker's interval handle (`runTick`); plus
+  // the in-flight `AbortController` (formerly `app.state.abortController`).
+  // All PRIVATE to this session — see the module doc above.
+  let runT0: number | null = null;
+  let runQueryId: string | null = null;
+  let runTick: ReturnType<typeof setInterval> | null = null;
+  let abortController: AbortController | null = null;
+
+  // attachShell's registered effect disposers (preact-signals-core's `effect()`
+  // returns a dispose function) — re-attaching (renderApp can re-run) disposes
+  // the previous set first, so the shell never double-fires.
+  let shellDisposers: Array<() => void> = [];
+
+  function disposeShellEffects(): void {
+    for (const dispose of shellDisposers) dispose();
+    shellDisposers = [];
+  }
+
+  // Milliseconds since the running query started (0 when idle).
+  function elapsedMs(): number {
+    return runT0 != null ? deps.now() - runT0 : 0;
+  }
+
+  async function run(opts?: RunOpts): Promise<void> {
+    if (state.running.value) return; // already running — cancel via cancel()/Esc
+    const tab = deps.activeTab();
+    // `opts.sql` overrides the source SQL (a single selected statement); otherwise
+    // the whole tab runs, byte-for-byte as before (FORMAT / EXPLAIN detection,
+    // trailing `;`, history).
+    const srcSql = opts && opts.sql != null ? opts.sql : tab.sqlDraft;
+    if (!srcSql.trim()) return;
+    const isFilter = effectiveDashboardRole(tab.specParsed) === 'filter';
+    const filterRun = isFilter ? filterExecution(srcSql) : null;
+    if (filterRun?.error) {
+      const filterErrorResult: QueryResult = newResult('Filter', filterRun.rowLimit);
+      filterErrorResult.error = filterRun.error;
+      Object.assign(tab, { result: filterErrorResult });
+      tab.filterPreview = { status: 'error', error: filterRun.error };
+      state.resultView.value = 'filter';
+      hooks.renderResults();
+      return;
+    }
+    const waveMs = deps.wallNow(); // one wall clock for this run wave: gate + args see the same instant
+    if (!isFilter && hooks.varGateBlocked(waveMs)) return; // Filter parameters fail statically above
+    // One prepared source for the whole run wave (#173), captured NOW —
+    // synchronously with the gate check above, BEFORE the auth awaits below
+    // (review F6 invariant, shared with runScript/exportDirect/exportScript):
+    // gate and args see the same varValues snapshot; a value edited while a
+    // token refresh is in flight applies to the NEXT run, and can never reach
+    // the server as a never-gate-checked binding. Reused on success for the
+    // recent-value recording (#171), so it reads exactly the boundParams that
+    // were sent.
+    const src = hooks.prepareTabSource(srcSql, waveMs);
+    await deps.ensureConfig();
+    if (!(await deps.getToken())) { hooks.onAuthFailed(); return; }
+
+    hooks.cancelSchemaGraph(); // a Run/Explain takes over the result — don't leave a lineage fetch running
+
+    // EXPLAIN-view bookkeeping: the Explain button (opts.explain) forces any query
+    // into EXPLAIN-view mode; a normal Run clears that; switching an EXPLAIN tab
+    // (opts.explainView) preserves it.
+    if (opts && opts.explain) state.forceExplain = true;
+    else if (!(opts && opts.explainView != null)) state.forceExplain = false;
+
+    // Every downstream decision + the request itself operate on the statement's
+    // execution view (#165): inactive optional blocks removed, markers
+    // stripped — byte-identical to srcSql for SQL without blocks. History still
+    // records the template (srcSql / tab.sqlDraft).
+    const execSql = isFilter ? srcSql : hooks.execStatementSql(srcSql);
+
+    const kpiExecution: KpiExecutionTransport = isFilter
+      ? { format: 'Table', rowLimit: state.resultRowLimit, params: {}, error: null }
+      : panelExecution(tabPanel(tab), execSql, {
+        format: 'Table', rowLimit: state.resultRowLimit, params: {},
+      });
+    if (kpiExecution.error) {
+      const kpiErrorResult: QueryResult = newResult('KPI', 2);
+      kpiErrorResult.error = kpiExecution.error;
+      Object.assign(tab, { result: kpiErrorResult });
+      state.resultView.value = 'panel';
+      hooks.renderResults();
+      return;
+    }
+
+    // An explicit FORMAT clause runs raw and shows ClickHouse's response verbatim
+    // (single raw tab). Otherwise an EXPLAIN (typed, or forced by the button) gets
+    // the five EXPLAIN views; everything else streams structured (Table).
+    const panelIsKpi = !isFilter && isKpiPanel(tabPanel(tab));
+    const explicitFmt = isFilter || panelIsKpi ? null : detectSqlFormat(execSql);
+    const parsed = isFilter || explicitFmt ? null : parseExplain(execSql);
+    const explainMode = !isFilter && !explicitFmt && (parsed != null || state.forceExplain);
+    let runSql = execSql;
+    let fmt: string;
+    let explainView: string | null = null;
+    if (isFilter) {
+      fmt = filterRun!.format;
+    } else if (explainMode) {
+      // View precedence: an explicit tab click wins; otherwise a *typed* EXPLAIN
+      // is honored exactly (canonical match → its rich view, else the verbatim
+      // Explain view); the button-forced path falls through to Explain. We never
+      // inherit a stale view from a previous run/tab — typing a plain EXPLAIN must
+      // show the plan, not whatever view was last open.
+      explainView = (opts && opts.explainView)
+        || (parsed && detectExplainView(parsed))
+        || 'explain';
+      fmt = (EXPLAIN_VIEWS.find((v) => v.id === explainView) || EXPLAIN_VIEWS[0]).chFormat;
+      const inner = parsed ? parsed.inner : execSql;
+      const explainOpts = { pretty: supportsExplainPretty(state.serverVersion) };
+      runSql = explainView === 'explain' && parsed
+        ? execSql
+        : buildExplainQuery(inner, explainView, explainOpts);
+    } else {
+      fmt = panelIsKpi ? kpiExecution.format! : explicitFmt || 'Table';
+    }
+
+    // Cap a normal result query (Table or explicit-FORMAT SELECT) at the global
+    // row limit; EXPLAIN/PIPELINE/ESTIMATE are exempt (small output, and a cap
+    // would truncate a plan oddly). The streaming guard reads it off the result;
+    // runQuery adds the server-side max_result_rows for the Table path.
+    const rowLimit = isFilter ? filterRun!.rowLimit : explainMode ? 0 : panelIsKpi ? kpiExecution.rowLimit! : state.resultRowLimit;
+    const t0 = deps.now();
+    const result: QueryResult = newResult(fmt, rowLimit);
+    Object.assign(tab, { result });
+    if (isFilter) tab.filterPreview = { status: 'running' };
+    if (explainView) result.explainView = explainView;
+    state.resultSort = { col: null, dir: 'asc' };
+    runT0 = t0;
+    runQueryId = deps.uid('q');
+    abortController = new AbortController();
+    runTick = setInterval(hooks.tickElapsed, 100);
+    // Keep the current Table/JSON/Panel tab across re-runs (#34); a saved-query
+    // open passes its remembered view in opts.view to restore that instead
+    // (a stray legacy 'chart' value maps to 'panel' — #166).
+    const view = opts && opts.view === 'chart' ? 'panel' : opts && opts.view;
+    // Flip the run signals last, in one batch: the results + Run-button effects
+    // fire on this write and read runT0/elapsed, so the bookkeeping above must
+    // already be set. (The old explicit setRunBtn(true)/renderResults are now
+    // those effects' job.)
+    batch(() => {
+      state.resultView.value = view != null && ['table', 'json', 'panel', 'filter'].includes(view)
+        ? (view as WorkbenchResultView) : state.resultView.value;
+      state.running.value = true;
+    });
+
+    try {
+      await deps.exec.executeRead(result, {
+        sql: runSql,
+        format: fmt,
+        rowLimit,
+        queryId: runQueryId,
+        signal: abortController.signal,
+        // Native ClickHouse query parameters (#134/#173): pass prepared values
+        // as param_<name> so the server substitutes them (only row-returning
+        // statements bind — a CREATE VIEW / DDL source stays verbatim).
+        params: isFilter
+          ? filterRun!.params
+          : { ...hooks.sessionParamsFor(tab, [srcSql]), ...mergedSourceArgs(src), ...kpiExecution.params },
+        onChunk: () => hooks.renderResults(),
+      });
+    } finally {
+      clearInterval(runTick as ReturnType<typeof setInterval>);
+      runTick = null;
+      abortController = null;
+      runQueryId = null;
+      runT0 = null;
+      result.progress.elapsed_ns = (deps.now() - t0) * 1e6;
+      if (isFilter) {
+        tab.filterPreview = result.error || result.cancelled
+          ? { status: 'error', error: result.error || 'Filter query was cancelled.' }
+          : {
+              status: 'success',
+              normalized: readFilterOptions({
+                columns: result.columns,
+                row: result.rows[0],
+                rowCount: result.rows.length,
+              }),
+            };
+      }
+      // #185: capture the source that produced a normal, row-returning
+      // structured result (fmt 'Table', so raw FORMAT / EXPLAIN are excluded;
+      // empty results stay ineligible), so the Data Pane's Expand can open an
+      // interactive, independently re-runnable detached view. The authored
+      // template (srcSql — optional-block markers intact) and the run-time
+      // title/description are snapshotted here, never re-derived from the
+      // editor/Library at expand time (which may have changed). This MUST run
+      // BEFORE the running flip below: that flip fires the results effect that
+      // renders the toolbar + its Expand affordance, which gates on
+      // `result.source` — set it after and the button never appears until the
+      // next paint.
+      if (!result.error && !result.cancelled && (fmt === 'Table' || fmt === 'KPI') && result.rows.length > 0) {
+        result.source = buildResultSource({
+          srcSql,
+          tabId: tab.id,
+          rowLimit,
+          tabName: tab.name,
+          savedEntry: savedForTab(state, tab),
+        });
+      }
+      // Flip running off last: the results + Run-button effects fire here and
+      // render the final stats, so elapsed_ns must already be recorded. (Old
+      // explicit setRunBtn(false)/renderResults are now those effects' job.)
+      state.running.value = false;
+      if (!result.error && !result.cancelled) {
+        // Spec completion is intentionally stable during a run and survives a
+        // later failed/cancelled run. Snapshot only completed structured
+        // results; never expose partially streamed metadata to the editor.
+        tab.lastSuccessfulResultColumns = (fmt === 'Table' || fmt === 'KPI' || fmt === 'Filter')
+          ? result.columns.map((column) => ({ ...column }))
+          : [];
+        hooks.recordHistory(tab, opts && opts.sql);
+        // #171: this statement succeeded — record its bound params (exactly
+        // what was actually sent; an omitted-optional-block param never
+        // reached `src.statements[*].boundParams` in the first place).
+        hooks.recordBoundParams(src.statements.flatMap((s) => s.boundParams) as BoundParamSnapshot[]);
+        if (isSchemaMutatingSql(runSql)) hooks.loadSchema(); // not awaited — fire and forget
+      }
+    }
+  }
+
+  // Run a `;`-separated script sequentially: one ClickHouse request per statement
+  // (CH's HTTP interface runs exactly one statement per request), stopping on the
+  // first failure. Row-returning statements (SELECT/WITH/SHOW/…) are fetched as
+  // JSONCompact capped at 100 rows; everything else runs for effect and reports
+  // OK. The result is a per-statement summary grid (tab.result.script). The whole
+  // script is recorded as one history entry on a clean run. `originalInput` is the
+  // exact text that was split (the selection or the whole editor).
+  async function runScript(statements: string[], originalInput: string): Promise<void> {
+    if (state.running.value) return;
+    const waveMs = deps.wallNow(); // one wall clock for the whole script wave
+    if (hooks.varGateBlocked(waveMs)) return; // block a script run with unfilled variables
+    // One prepared batch for the whole script (#173): `statements` came from
+    // splitStatements(originalInput), so the batch's statements align by index.
+    // Captured NOW — synchronously with the gate check above, BEFORE the auth
+    // awaits (review F6 invariant, shared with run/exportDirect/exportScript):
+    // gate and args see the same varValues snapshot; edits during the auth
+    // await apply to the next run.
+    const paramSrc = hooks.prepareTabSource(originalInput, waveMs);
+    await deps.ensureConfig();
+    if (!(await deps.getToken())) { hooks.onAuthFailed(); return; }
+
+    hooks.cancelSchemaGraph(); // a script run takes over the result — don't leave a lineage fetch running
+    state.forceExplain = false;
+    const tab = deps.activeTab();
+    const t0 = deps.now();
+    const entries: ScriptEntry[] = [];
+    const scriptResult: ScriptResult = { script: entries };
+    Object.assign(tab, { result: scriptResult });
+    state.resultSort = { col: null, dir: 'asc' };
+    runT0 = t0;
+    abortController = new AbortController();
+    runTick = setInterval(hooks.tickElapsed, 100);
+    let aborted = false;
+    // Attach a session only if the script needs one (TEMPORARY / SET) or the tab
+    // already has one — same params for every statement, computed once.
+    const sp = hooks.sessionParamsFor(tab, statements);
+    state.running.value = true; // the results effect paints the (empty) grid
+    try {
+      // Transport/retry loop (one ClickHouse request per statement, the
+      // SESSION_IS_LOCKED / transient-network retry, stop-on-first-failure)
+      // lives in application/query-execution-service.ts (#276 Phase 1) —
+      // this loop owns only orchestration: per-statement wire text (#165's
+      // execution view), the live query_id (for Cancel), pushing entries +
+      // repainting, and per-statement boundParams recording.
+      const res = await deps.exec.executeScript({
+        statements: statements.map((stmt, i) => ({
+          sql: stmt,
+          // The wire text is the pipeline's per-statement execution view (#165):
+          // inactive optional blocks removed for row-returning statements,
+          // verbatim (byte-identical) for everything else and for block-free SQL.
+          // The result grid keeps showing the authored `stmt`.
+          execSql: paramSrc.statements[i].sql,
+          // Per-statement prepared args (#134/#173): the pipeline binds only
+          // row-returning statements, so a DDL / CREATE VIEW statement in the
+          // script is sent with its {name:Type} placeholders intact.
+          params: { ...sp, ...paramSrc.statements[i].args },
+        })),
+        signal: abortController.signal,
+        // Fresh query_id per attempt, published before the request so Cancel
+        // issues KILL QUERY against the statement that's actually running.
+        onStatementStart: (_i, { queryId }) => { runQueryId = queryId; },
+        onStatementResult: (i, entry) => {
+          entries.push(entry);
+          // #171: THIS statement succeeded — record its own boundParams (per
+          // statement, not per script: statement 1 of a later-failing script
+          // still records; an error entry stops the script and never records).
+          if (entry.status !== 'error') hooks.recordBoundParams([...paramSrc.statements[i].boundParams]);
+          hooks.renderResults();
+        },
+      });
+      aborted = res.aborted;
+    } finally {
+      clearInterval(runTick as ReturnType<typeof setInterval>);
+      runTick = null;
+      abortController = null;
+      runQueryId = null;
+      runT0 = null;
+      scriptResult.elapsedMs = deps.now() - t0;
+      if (aborted) scriptResult.cancelled = true;
+      state.running.value = false;
+      // A statement that actually ran (status !== 'error') and was schema-mutating
+      // refreshes the tree even if a later statement in the script failed — it
+      // already took effect server-side.
+      if (entries.some((e) => e.status !== 'error' && isSchemaMutatingSql(e.sql))) hooks.loadSchema();
+      // One history entry for the whole script — but only on a clean run (mirrors
+      // run(): no history for an aborted or failed script).
+      if (!aborted && !entries.some((e) => e.status === 'error')) {
+        recordScriptHistory(state, originalInput, scriptResult.elapsedMs!, hooks.saveJSON);
+        if (state.sidePanel.value === 'history') hooks.renderSavedHistory();
+      }
+    }
+  }
+
+  // The Run button / ⌘+Enter entry point. A non-empty (non-whitespace) editor
+  // selection runs just that text; otherwise the whole tab. The chosen text is
+  // split: one statement keeps today's rich Table/Chart/EXPLAIN path (run());
+  // more than one runs sequentially as a script (runScript).
+  function runEntry(opts?: RunOpts): void | Promise<void> {
+    if (deps.activeTab().editorMode !== 'sql') return;
+    if (state.running.value) return;
+    const sel = hooks.getSelectionText();
+    const hasSel = sel.trim() !== '';
+    const input = hasSel ? sel : deps.activeTab().sqlDraft;
+    const statements = splitStatements(input);
+    if (!statements.length) return; // nothing runnable (empty / comments-only)
+    // The unfilled-variable gate (#134) lives in run()/runScript() — the shared
+    // execution choke points — so Explain, row-limit re-runs, and Export are
+    // gated too, not just this path.
+    // Mobile (#126): a run jumps the bottom-nav to the Results panel so the data
+    // the user just asked for is what they see next.
+    if (state.isMobile.value) state.mobileView.value = 'results';
+    if (effectiveDashboardRole(deps.activeTab().specParsed) === 'filter') {
+      return run(hasSel ? { ...opts, sql: input } : opts);
+    }
+    // >1 statement → script grid (a remembered single-result view doesn't apply).
+    if (statements.length > 1) return runScript(statements, input);
+    // 1 statement → today's rich path. Forward opts (e.g. a saved query's
+    // remembered view / Explain); a selection adds the sql override.
+    return run(hasSel ? { ...opts, sql: input } : opts);
+  }
+
+  // Stop an in-flight query: abort the stream and KILL QUERY on the server.
+  function cancel(): void {
+    if (!state.running.value) return;
+    if (abortController) abortController.abort();
+    deps.exec.kill(runQueryId); // fire-and-forget, same as before
+  }
+
+  function attachShell(shellEffects: WorkbenchShellEffects): void {
+    disposeShellEffects(); // idempotent re-attach: renderApp can re-run
+    shellDisposers = [
+      // Reactive repaint of the results pane: re-runs on a tab switch, a Table/
+      // JSON/Chart view change, or a run-state flip.
+      effect(() => {
+        state.activeTabId.value;
+        state.resultView.value;
+        state.running.value;
+        shellEffects.renderResults();
+      }),
+      // The Run button reflects the run state (label + disabled) and the
+      // selection (Run ↔ Run selection).
+      effect(() => {
+        state.hasSelection.value;
+        shellEffects.setRunBtn(state.running.value);
+      }),
+      // The Results nav badge: ● while a query streams, else the row count.
+      effect(() => {
+        state.running.value;
+        state.activeTabId.value;
+        state.resultView.value;
+        shellEffects.setMobileBadge();
+      }),
+    ];
+  }
+
+  function destroy(): void {
+    disposeShellEffects();
+    if (runTick != null) {
+      clearInterval(runTick);
+      runTick = null;
+    }
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+    if (runQueryId != null) {
+      deps.exec.kill(runQueryId);
+      runQueryId = null;
+    }
+    runT0 = null;
+  }
+
+  return { run, runScript, runEntry, cancel, elapsedMs, attachShell, destroy };
+}
diff --git a/tests/helpers/fake-app.ts b/tests/helpers/fake-app.ts
index 75fb6f9..2fc3ca2 100644
--- a/tests/helpers/fake-app.ts
+++ b/tests/helpers/fake-app.ts
@@ -31,6 +31,7 @@ import type { ChartJsConfigResult } from '../../src/core/chart-data.js';
 import type { ChartInstance } from '../../src/ui/chart-render.js';
 import type { QueryExecutionService } from '../../src/application/query-execution-service.js';
 import type { ConnectionSession } from '../../src/application/connection-session.js';
+import type { WorkbenchSession } from '../../src/ui/workbench/workbench-session.js';
 
 // Production invariant (#276 Phase 2): `app.chCtx` and `app.conn.chCtx` are
 // THE SAME live object (app.ts aliases `conn.chCtx`) — the defaults + the
@@ -96,6 +97,23 @@ export class FakeChart implements ChartInstance {
   destroy(): void { this.destroyed = true; }
 }
 
+// A minimal `WorkbenchSession` stub (#276 Phase 3a) — no render-module fixture
+// exercises the session's own run/cancel orchestration directly (that's
+// workbench-session.test.ts's job); this just satisfies the `App.workbench`
+// contract. const-first (not inlined below): a `vi.fn()` written directly
+// inside a nested object literal loses its mock-specific type to the
+// surrounding literal's contextual typing (a known inference footgun) — see
+// this file's own header note on `exec`/`chCtx`.
+const workbenchDefaults: WorkbenchSession = {
+  run: vi.fn(async () => {}),
+  runScript: vi.fn(async () => {}),
+  runEntry: vi.fn(),
+  cancel: vi.fn(),
+  elapsedMs: () => 0,
+  attachShell: vi.fn(),
+  destroy: vi.fn(),
+};
+
 // Every `App` member this file's own concrete stubs (below) don't cover,
 // filled with an inert placeholder never read by a fixture that doesn't
 // override it — same convention as (and previously duplicated by) each of
@@ -171,6 +189,7 @@ const appDefaults: App = {
   now: () => 0,
   elapsedMs: () => 0,
   tickElapsed: () => {},
+  workbench: workbenchDefaults,
   exec: {
     executeRead: async (result) => result,
     executeScript: async () => ({ entries: [], aborted: false }),
@@ -201,7 +220,7 @@ const appDefaults: App = {
  * onSignedOut }` (a caller overriding one ChCtx member, not the whole
  * service) would otherwise fail the constraint even though the nested merge
  * below happily accepts a partial sub-object. */
-type AppOverrides = Partial<Omit<App, 'dom' | 'chCtx' | 'actions' | 'exec' | 'conn'>> & {
+type AppOverrides = Partial<Omit<App, 'dom' | 'chCtx' | 'actions' | 'exec' | 'conn' | 'workbench'>> & {
   dom?: Partial<AppDom>;
   chCtx?: Partial<ChCtx>;
   actions?: Partial<ActionsRegistry>;
@@ -214,6 +233,10 @@ type AppOverrides = Partial<Omit<App, 'dom' | 'chCtx' | 'actions' | 'exec' | 'co
    *  (the production identity invariant); override `chCtx` at the top level
    *  and both aliases see it. */
   conn?: Partial<Omit<ConnectionSession, 'chCtx'>>;
+  /** Partial like the rest (#276 Phase 3a) — most fixtures never touch the
+   *  session directly; a test asserting `workbench.run`/`.cancel` was called
+   *  can override just that method. */
+  workbench?: Partial<WorkbenchSession>;
 };
 
 // `overrides` is generic so its properties keep their OWN precise call-site
@@ -346,6 +369,7 @@ export function makeApp<O extends AppOverrides = Record<string, never>>(override
     actions: { ...appDefaults.actions, ...base.actions, ...(overrides.actions ?? {}) },
     exec: { ...appDefaults.exec, ...base.exec, ...(overrides.exec ?? {}) },
     conn: { ...connDefaults, ...(overrides.conn ?? {}), chCtx },
+    workbench: { ...workbenchDefaults, ...(overrides.workbench ?? {}) },
   };
   // Assignability check only (a variable reference, not a fresh literal, so
   // this never trips an excess-property error) — `merged`'s own inferred type
diff --git a/tests/unit/app.test.ts b/tests/unit/app.test.ts
index cdaa578..0526a3f 100644
--- a/tests/unit/app.test.ts
+++ b/tests/unit/app.test.ts
@@ -306,11 +306,6 @@ const schemaGraphOf = (tab: { result: Record<string, unknown> | null }): Indexed
 interface FilterPreviewNormalized { helpers: { options: { value: string; label: string }[] }[] }
 const filterPreviewNormalizedOf = (tab: { filterPreview: Record<string, unknown> | null }): FilterPreviewNormalized =>
   tab.filterPreview!.normalized as FilterPreviewNormalized;
-// `run()`/`runScript()`'s own bookkeeping on `app.state` (app.ts's own doc
-// comment on its `RunState` local interface + `runState()` helper) — not
-// part of the shared `state.ts` contract, narrowed the same way here.
-const runStateOf = (s: AppState): AppState & { runT0: number | null; runQueryId: string | null } =>
-  s as AppState & { runT0: number | null; runQueryId: string | null };
 // `outputFormat` is a stray, never-declared field the untyped JS original set
 // on `app.state` before a since-removed fallback path — inert today (no code
 // reads it), kept as the same harmless dead write via a local intersection
@@ -877,11 +872,12 @@ describe('query run', () => {
   });
   it('run() while already running is a no-op (cancel is separate)', async () => {
     const { app } = appForRun([]);
+    await new Promise((r) => setTimeout(r)); // let mount-time loadVersion/loadSchema/loadReference settle
     app.state.running.value = true;
-    const ac = { abort: vi.fn(), signal: {} as AbortSignal };
-    app.state.abortController = ac;
+    const before = asMock(app.chCtx.fetch).mock.calls.length;
     await app.actions.run();
-    expect(ac.abort).not.toHaveBeenCalled(); // re-running no longer aborts
+    // Guarded before any request goes out — no additional fetch/exec call.
+    expect(asMock(app.chCtx.fetch).mock.calls.length).toBe(before);
     expect(app.state.running.value).toBe(true);
   });
   it('setRunBtn: "Running…" with no trailing "null"; "Run" + kbd when idle', () => {
@@ -1445,28 +1441,50 @@ describe('query run', () => {
     expect(app2.wallNow()).toBeGreaterThan(1e12);
     expect(app2.now()).toBe(0);
   });
-  it('tickElapsed updates the live ms readout, and no-ops without the element', () => {
-    const { app } = appForRun([]);
-    runStateOf(app.state).runT0 = 0;
+  it('tickElapsed updates the live ms readout mid-run (via the workbench session), and no-ops without the element', async () => {
+    let resolveRunFetch!: (value: FakeResponse | Promise<FakeResponse>) => void;
+    let n = 0;
+    const fetch = asFetch(vi.fn((_url: string, init?: { body?: string }) => (init && /SELECT 1/.test(init.body || '')
+      ? new Promise<FakeResponse>((res) => { resolveRunFetch = res; })
+      : Promise.resolve(resp({ json: { data: [] } })))));
+    const { app } = appForRun([], { fetch, now: () => (n += 10) });
+    app.activeTab().sqlDraft = 'SELECT 1';
+    const pending = app.actions.run();
+    await new Promise((r) => setTimeout(r)); // let run() reach the in-flight request
     app.dom.runElapsedEl = document.createElement('span');
-    app.tickElapsed(); // env.now → 0
-    expect(app.dom.runElapsedEl!.textContent).toBe('0 ms');
+    app.tickElapsed();
+    const text = app.dom.runElapsedEl!.textContent!;
+    expect(text).toMatch(/^\d+ ms$/);
+    expect(parseInt(text, 10)).toBeGreaterThan(0);
     app.dom.runElapsedEl = undefined;
     expect(() => app.tickElapsed()).not.toThrow();
+    resolveRunFetch(resp({ body: streamBody([]) }));
+    await pending;
   });
   it('cancel() aborts + issues KILL QUERY when running; no-op when idle', async () => {
-    const { app, e } = appForRun([]);
+    let resolveRunFetch!: (value: FakeResponse | Promise<FakeResponse>) => void;
+    const fetch = asFetch(vi.fn((_url: string, init?: { body?: string }) => (init && /SELECT 1/.test(init.body || '')
+      ? new Promise<FakeResponse>((res) => { resolveRunFetch = res; })
+      : Promise.resolve(resp({ json: { data: [] } })))));
+    const { app, e } = appForRun([], { fetch });
     app.actions.cancel(); // idle → no-op, no throw
-    const abort = vi.fn();
-    app.state.running.value = true;
-    app.state.abortController = { abort, signal: {} as AbortSignal };
-    runStateOf(app.state).runQueryId = 'qid-1';
+    app.activeTab().sqlDraft = 'SELECT 1';
+    const pending = app.actions.run();
+    await new Promise((r) => setTimeout(r)); // let run() reach the in-flight request, publishing its live query_id
+    expect(app.state.running.value).toBe(true);
+    const runCall = asMock(fetch).mock.calls.find((c) => c[1] && /SELECT 1/.test(c[1].body || ''))!;
+    // The live query_id (#276 Phase 3a: minted + tracked by the workbench
+    // session, no longer a state.ts field) rides on the run request's own URL.
+    const queryId = decodeURIComponent((runCall[0].match(/query_id=([^&]+)/) || [])[1] || '');
+    expect(queryId).toBeTruthy();
     app.actions.cancel();
-    expect(abort).toHaveBeenCalled();
+    expect((runCall[1].signal as AbortSignal).aborted).toBe(true);
     await new Promise((r) => setTimeout(r)); // let the fire-and-forget KILL QUERY run
     const kill = asMock(e.fetch!).mock.calls.find((c) => /KILL QUERY/.test((c[1] && c[1].body) || ''))!;
     expect(kill).toBeTruthy();
-    expect(kill[1].body).toContain("query_id = 'qid-1'");
+    expect(kill[1].body).toContain("query_id = '" + queryId + "'");
+    resolveRunFetch(Promise.reject(Object.assign(new Error('aborted'), { name: 'AbortError' })));
+    await pending;
   });
   it('surfaces a query error', async () => {
     const { app } = appForRun([
@@ -3703,7 +3721,7 @@ describe('streaming export (issue #87)', () => {
     const exportCall = asMock(fetch).mock.calls.find((c) => c[1] && c[1].body === EXPORT_BODY)!;
     expect(exportCall[1].signal.aborted).toBe(false);
 
-    app.actions.cancelExport(); // grid run's runQueryId/abortController is untouched — this is the export's own
+    app.actions.cancelExport(); // the workbench session's own run bookkeeping is untouched — this is the export's own
     expect(exportCall[1].signal.aborted).toBe(true);
     resolveExportFetch(Promise.reject(Object.assign(new Error('aborted'), { name: 'AbortError' })));
     await pending;
diff --git a/tests/unit/workbench-session.test.ts b/tests/unit/workbench-session.test.ts
new file mode 100644
index 0000000..90bf62d
--- /dev/null
+++ b/tests/unit/workbench-session.test.ts
@@ -0,0 +1,765 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { signal } from '@preact/signals-core';
+import {
+  createWorkbenchSession,
+} from '../../src/ui/workbench/workbench-session.js';
+import type {
+  WorkbenchSessionDeps, WorkbenchStateSlice, WorkbenchHooks, WorkbenchShellEffects,
+} from '../../src/ui/workbench/workbench-session.js';
+import { newTabObj } from '../../src/state.js';
+import type { QueryTab } from '../../src/state.js';
+import type {
+  QueryExecutionService, ExecuteReadRequest, ScriptExecutionRequest, ScriptExecutionResult,
+} from '../../src/application/query-execution-service.js';
+import type { StreamResult } from '../../src/core/stream.js';
+import type { PreparedSource, PreparedStatement, BoundParamSnapshot } from '../../src/core/param-pipeline.js';
+
+// ── Small deferred helper (mirrors the pattern query-execution-service.test.ts
+// uses for scripting async runQuery behaviors, adapted to a single promise a
+// test can resolve/reject on its own schedule). ────────────────────────────
+
+function deferred<T>(): { promise: Promise<T>; resolve: (v: T) => void; reject: (e: unknown) => void } {
+  let resolve!: (v: T) => void;
+  let reject!: (e: unknown) => void;
+  const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej; });
+  return { promise, resolve, reject };
+}
+
+/** Flush every pending microtask (the `await ensureConfig()` / `await
+ * getToken()` chain each real call makes before touching `running`) via a
+ * macrotask boundary — simpler and more robust than counting `await
+ * Promise.resolve()` calls by hand. */
+function flush(): Promise<void> {
+  return new Promise((r) => setTimeout(r, 0));
+}
+
+function preparedStatement(over: Partial<PreparedStatement> = {}): PreparedStatement {
+  return { sql: 'SELECT 1', args: {}, boundParams: [], ...over };
+}
+
+function preparedSource(over: Partial<PreparedSource> = {}): PreparedSource {
+  return {
+    id: 'tab', statements: [preparedStatement()], missing: [], invalid: [], errors: [], runnable: true, ...over,
+  };
+}
+
+function boundParam(name: string): BoundParamSnapshot {
+  return {
+    name, declaredType: 'String', rawValue: 'x', resolvedValue: 'x', serializedValue: "'x'",
+  };
+}
+
+// ── Fakes ────────────────────────────────────────────────────────────────────
+
+function makeExec(): {
+  exec: Pick<QueryExecutionService, 'executeRead' | 'executeScript' | 'kill'>;
+  executeRead: ReturnType<typeof vi.fn>;
+  executeScript: ReturnType<typeof vi.fn>;
+  kill: ReturnType<typeof vi.fn>;
+} {
+  const executeRead = vi.fn(async (result: StreamResult, _req: ExecuteReadRequest) => result);
+  const executeScript = vi.fn(async (_req: ScriptExecutionRequest): Promise<ScriptExecutionResult> => ({ entries: [], aborted: false }));
+  const kill = vi.fn(async () => {});
+  return { exec: { executeRead, executeScript, kill }, executeRead, executeScript, kill };
+}
+
+function makeState(over: Partial<WorkbenchStateSlice> = {}): WorkbenchStateSlice {
+  return {
+    running: signal(false),
+    resultView: signal('table'),
+    resultSort: { col: null, dir: 'asc' },
+    forceExplain: false,
+    resultRowLimit: 500,
+    serverVersion: null,
+    sidePanel: signal('saved'),
+    isMobile: signal(false),
+    mobileView: signal('editor'),
+    hasSelection: signal(false),
+    activeTabId: signal('t1'),
+    savedQueries: [],
+    history: [],
+    ...over,
+  };
+}
+
+function makeHooks(over: Partial<WorkbenchHooks> = {}): WorkbenchHooks {
+  return {
+    renderResults: vi.fn(),
+    renderSavedHistory: vi.fn(),
+    cancelSchemaGraph: vi.fn(),
+    loadSchema: vi.fn(),
+    recordHistory: vi.fn(),
+    recordBoundParams: vi.fn(),
+    prepareTabSource: vi.fn(() => preparedSource()),
+    varGateBlocked: vi.fn(() => false),
+    execStatementSql: vi.fn((stmt: string) => stmt),
+    sessionParamsFor: vi.fn(() => ({})),
+    getSelectionText: vi.fn(() => ''),
+    tickElapsed: vi.fn(),
+    saveJSON: vi.fn(),
+    onAuthFailed: vi.fn(),
+    ...over,
+  };
+}
+
+interface Harness {
+  deps: WorkbenchSessionDeps;
+  state: WorkbenchStateSlice;
+  hooks: WorkbenchHooks;
+  tab: QueryTab;
+  execFakes: ReturnType<typeof makeExec>;
+  nowSeq: { value: number };
+}
+
+function makeHarness(opts: {
+  state?: Partial<WorkbenchStateSlice>;
+  hooks?: Partial<WorkbenchHooks>;
+  tab?: Partial<QueryTab>;
+  getToken?: () => Promise<string | null>;
+} = {}): Harness {
+  const state = makeState(opts.state);
+  const hooks = makeHooks(opts.hooks);
+  const tab: QueryTab = { ...newTabObj('t1'), ...opts.tab };
+  const execFakes = makeExec();
+  const nowSeq = { value: 0 };
+  const deps: WorkbenchSessionDeps = {
+    exec: execFakes.exec,
+    ensureConfig: vi.fn(async () => undefined),
+    getToken: opts.getToken || vi.fn(async () => 'tok'),
+    now: () => { nowSeq.value += 10; return nowSeq.value; },
+    wallNow: () => 1_700_000_000_000,
+    uid: (() => { let n = 0; return (prefix: string) => `${prefix}-${++n}`; })(),
+    state,
+    activeTab: () => tab,
+    hooks,
+  };
+  return { deps, state, hooks, tab, execFakes, nowSeq };
+}
+
+// ── run() ────────────────────────────────────────────────────────────────────
+
+describe('createWorkbenchSession: run()', () => {
+  it('guards while already running: no exec call, no side effects', async () => {
+    const h = makeHarness({ state: { running: signal(true) } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    expect(h.execFakes.executeRead).not.toHaveBeenCalled();
+    expect(h.hooks.cancelSchemaGraph).not.toHaveBeenCalled();
+  });
+
+  it('does nothing for blank/whitespace-only SQL', async () => {
+    const h = makeHarness({ tab: { sqlDraft: '   ' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    expect(h.execFakes.executeRead).not.toHaveBeenCalled();
+  });
+
+  it('Filter role: a statically invalid Filter SQL sets an error result and never executes', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'SELECT 1; SELECT 2;', specParsed: { name: 'f', favorite: false, dashboard: { role: 'filter' } } } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    expect(h.execFakes.executeRead).not.toHaveBeenCalled();
+    expect((h.tab.result as { error: string } | null)?.error).toMatch(/exactly one statement/);
+    expect(h.tab.filterPreview).toEqual({ status: 'error', error: expect.stringContaining('exactly one statement') });
+    expect(h.state.resultView.value).toBe('filter');
+    expect(h.hooks.renderResults).toHaveBeenCalled();
+  });
+
+  it('Filter role: a valid Filter SQL runs to a successful preview', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'SELECT 1 AS x', specParsed: { name: 'f', favorite: false, dashboard: { role: 'filter' } } } });
+    h.execFakes.executeRead.mockImplementation(async (result: StreamResult) => {
+      Object.assign(result, { columns: [{ name: 'x', type: 'UInt8' }], rows: [[1]] });
+      return result;
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    expect(h.execFakes.executeRead).toHaveBeenCalledTimes(1);
+    const req = h.execFakes.executeRead.mock.calls[0][1] as ExecuteReadRequest;
+    expect(req.format).toBe('Filter');
+    expect(req.rowLimit).toBe(2);
+    expect(h.tab.filterPreview).toMatchObject({ status: 'success' });
+    expect(h.state.running.value).toBe(false);
+  });
+
+  it('Filter role: a failed Filter execution records the error preview', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'SELECT 1', specParsed: { name: 'f', favorite: false, dashboard: { role: 'filter' } } } });
+    h.execFakes.executeRead.mockImplementation(async (result: StreamResult) => {
+      result.error = 'boom';
+      return result;
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    expect(h.tab.filterPreview).toEqual({ status: 'error', error: 'boom' });
+  });
+
+  it('blocks (no exec call) when the var gate is blocked', async () => {
+    const h = makeHarness({ hooks: { varGateBlocked: vi.fn(() => true) } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    expect(h.execFakes.executeRead).not.toHaveBeenCalled();
+    expect(h.deps.ensureConfig).not.toHaveBeenCalled();
+  });
+
+  it('auth failure (getToken → null): no exec call, no cancelSchemaGraph, fires onAuthFailed', async () => {
+    const h = makeHarness({ getToken: async () => null, tab: { sqlDraft: 'SELECT 1' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    expect(h.execFakes.executeRead).not.toHaveBeenCalled();
+    expect(h.hooks.cancelSchemaGraph).not.toHaveBeenCalled();
+    expect(h.hooks.onAuthFailed).toHaveBeenCalledTimes(1);
+  });
+
+  it('KPI panel: an explicit FORMAT clash sets an owned error result and never executes', async () => {
+    const h = makeHarness({
+      tab: { sqlDraft: 'SELECT 1 FORMAT JSON', specParsed: { name: 'k', favorite: false, panel: { cfg: { type: 'kpi' } } } },
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    expect(h.execFakes.executeRead).not.toHaveBeenCalled();
+    expect((h.tab.result as { error: string } | null)?.error).toMatch(/KPI panel owns the result format/);
+    expect(h.state.resultView.value).toBe('panel');
+  });
+
+  it('KPI panel: a clean run executes as format KPI, rowLimit 2, and captures result.source', async () => {
+    const h = makeHarness({
+      tab: { sqlDraft: 'SELECT 1 AS x', name: 'My KPI', specParsed: { name: 'k', favorite: false, panel: { cfg: { type: 'kpi' } } } },
+    });
+    h.execFakes.executeRead.mockImplementation(async (result: StreamResult) => {
+      Object.assign(result, { columns: [{ name: 'x', type: 'UInt8' }], rows: [[1]] });
+      return result;
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    const req = h.execFakes.executeRead.mock.calls[0][1] as ExecuteReadRequest;
+    expect(req.format).toBe('KPI');
+    expect(req.rowLimit).toBe(2);
+    const result = h.tab.result as { source?: { title: string } } | null;
+    expect(result?.source?.title).toBe('My KPI');
+    expect(h.hooks.recordHistory).toHaveBeenCalledWith(h.tab, undefined);
+  });
+
+  it('an explicit FORMAT clause runs raw, honoring the authored format', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'SELECT 1 FORMAT JSON' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    const req = h.execFakes.executeRead.mock.calls[0][1] as ExecuteReadRequest;
+    expect(req.format).toBe('JSON');
+  });
+
+  it('plain Table run: successful row-returning result captures result.source and records history', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'SELECT 1 AS x' } });
+    h.execFakes.executeRead.mockImplementation(async (result: StreamResult, req: ExecuteReadRequest) => {
+      req.onChunk?.(); // exercise the per-chunk repaint hook (a real streamed run pulses this)
+      Object.assign(result, { columns: [{ name: 'x', type: 'UInt8' }], rows: [[1]] });
+      return result;
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.run({ sql: 'SELECT 1 AS x' });
+    const result = h.tab.result as { source?: unknown; error: string | null; cancelled: boolean } | null;
+    expect(result?.source).toBeTruthy();
+    expect(h.hooks.recordHistory).toHaveBeenCalledWith(h.tab, 'SELECT 1 AS x');
+    expect(h.hooks.recordBoundParams).toHaveBeenCalled();
+    expect(h.hooks.loadSchema).not.toHaveBeenCalled();
+    expect(h.hooks.renderResults).toHaveBeenCalled(); // the onChunk pulse (+ the results/mobile-badge shell effects, if attached)
+  });
+
+  it('a schema-mutating statement refreshes the schema tree on success', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'CREATE TABLE t (x Int32) ENGINE=Memory' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    expect(h.hooks.loadSchema).toHaveBeenCalled();
+    // 0 rows → no eligible result.source snapshot.
+    expect((h.tab.result as { source?: unknown } | null)?.source).toBeUndefined();
+  });
+
+  it('a failed run never records history/boundParams/schema-reload', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'SELECT 1' } });
+    h.execFakes.executeRead.mockImplementation(async (result: StreamResult) => {
+      result.error = 'nope';
+      return result;
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    expect(h.hooks.recordHistory).not.toHaveBeenCalled();
+    expect(h.hooks.recordBoundParams).not.toHaveBeenCalled();
+    expect(h.hooks.loadSchema).not.toHaveBeenCalled();
+  });
+
+  it('typed EXPLAIN with no matching rich view runs verbatim under the Explain tab', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'EXPLAIN SELECT 1' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    const req = h.execFakes.executeRead.mock.calls[0][1] as ExecuteReadRequest;
+    expect(req.sql).toBe('EXPLAIN SELECT 1');
+    expect(req.format).toBe('TabSeparatedRaw');
+    expect((h.tab.result as { explainView?: string } | null)?.explainView).toBe('explain');
+  });
+
+  it('typed EXPLAIN ESTIMATE auto-selects the rich Estimate view', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'EXPLAIN ESTIMATE SELECT 1' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    const req = h.execFakes.executeRead.mock.calls[0][1] as ExecuteReadRequest;
+    expect(req.sql).toBe('EXPLAIN ESTIMATE SELECT 1');
+    expect(req.format).toBe('Table');
+    expect(req.rowLimit).toBe(0);
+    expect((h.tab.result as { explainView?: string } | null)?.explainView).toBe('estimate');
+  });
+
+  it('the Explain button forces a plain query into the verbatim Explain view', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'SELECT 1' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run({ explain: true });
+    expect(h.state.forceExplain).toBe(true);
+    const req = h.execFakes.executeRead.mock.calls[0][1] as ExecuteReadRequest;
+    expect(req.sql).toBe('EXPLAIN SELECT 1');
+    expect(req.format).toBe('TabSeparatedRaw');
+  });
+
+  it('an explicit explainView option wins over auto-detection and preserves forceExplain', async () => {
+    const h = makeHarness({ state: { forceExplain: true }, tab: { sqlDraft: 'SELECT 1' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run({ explainView: 'pipeline' });
+    expect(h.state.forceExplain).toBe(true); // preserved, not reset (opts.explainView was given)
+    const req = h.execFakes.executeRead.mock.calls[0][1] as ExecuteReadRequest;
+    expect(req.sql).toBe('EXPLAIN PIPELINE graph = 1 SELECT 1');
+    expect((h.tab.result as { explainView?: string } | null)?.explainView).toBe('pipeline');
+  });
+
+  it('a normal Run clears a stale forceExplain flag', async () => {
+    const h = makeHarness({ state: { forceExplain: true }, tab: { sqlDraft: 'SELECT 1' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run();
+    expect(h.state.forceExplain).toBe(false);
+  });
+
+  it("opts.view='chart' restores the legacy alias as 'panel'", async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'SELECT 1' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run({ view: 'chart' });
+    expect(h.state.resultView.value).toBe('panel');
+  });
+
+  it("an unrecognized opts.view leaves resultView unchanged", async () => {
+    const h = makeHarness({ state: { resultView: signal('json') }, tab: { sqlDraft: 'SELECT 1' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.run({ view: 'bogus' });
+    expect(h.state.resultView.value).toBe('json');
+  });
+
+  it('sets bookkeeping (elapsedMs) BEFORE flipping `running` true (batch ordering)', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'SELECT 1' } });
+    const session = createWorkbenchSession(h.deps);
+    let elapsedAtFlip: number | null = null;
+    let sawTrue = false;
+    const { effect } = await import('@preact/signals-core');
+    const dispose = effect(() => {
+      if (h.state.running.value && !sawTrue) {
+        sawTrue = true;
+        elapsedAtFlip = session.elapsedMs();
+      }
+    });
+    await session.run();
+    dispose();
+    expect(sawTrue).toBe(true);
+    expect(elapsedAtFlip).not.toBeNull();
+    expect(elapsedAtFlip).toBeGreaterThan(0);
+  });
+
+  it('records elapsed_ns BEFORE flipping `running` false (finally teardown order)', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'SELECT 1' } });
+    const session = createWorkbenchSession(h.deps);
+    let elapsedNsAtFalse: number | null = null;
+    let transitions = 0;
+    const { effect } = await import('@preact/signals-core');
+    const dispose = effect(() => {
+      const running = h.state.running.value;
+      transitions += 1;
+      if (transitions > 1 && !running) {
+        elapsedNsAtFalse = (h.tab.result as { progress: { elapsed_ns: number } } | null)?.progress.elapsed_ns ?? null;
+      }
+    });
+    await session.run();
+    dispose();
+    expect(elapsedNsAtFalse).not.toBeNull();
+    expect(elapsedNsAtFalse).toBeGreaterThan(0);
+  });
+});
+
+// ── runScript() ──────────────────────────────────────────────────────────────
+
+describe('createWorkbenchSession: runScript()', () => {
+  it('guards while already running', async () => {
+    const h = makeHarness({ state: { running: signal(true) } });
+    const session = createWorkbenchSession(h.deps);
+    await session.runScript(['SELECT 1'], 'SELECT 1');
+    expect(h.execFakes.executeScript).not.toHaveBeenCalled();
+  });
+
+  it('blocks (no exec call) when the var gate is blocked', async () => {
+    const h = makeHarness({ hooks: { varGateBlocked: vi.fn(() => true) } });
+    const session = createWorkbenchSession(h.deps);
+    await session.runScript(['SELECT 1'], 'SELECT 1'); // eslint-disable-line
+    expect(h.execFakes.executeScript).not.toHaveBeenCalled();
+  });
+
+  it('auth failure (getToken → null): no exec call, fires onAuthFailed', async () => {
+    const h = makeHarness({ getToken: async () => null });
+    const session = createWorkbenchSession(h.deps);
+    await session.runScript(['SELECT 1'], 'SELECT 1');
+    expect(h.execFakes.executeScript).not.toHaveBeenCalled();
+    expect(h.hooks.onAuthFailed).toHaveBeenCalledTimes(1);
+  });
+
+  it('flips `running` true eagerly, before the transport resolves', async () => {
+    const h = makeHarness();
+    const gate = deferred<ScriptExecutionResult>();
+    h.execFakes.executeScript.mockImplementation(() => gate.promise);
+    const session = createWorkbenchSession(h.deps);
+    const p = session.runScript(['SELECT 1'], 'SELECT 1');
+    await flush();
+    expect(h.state.running.value).toBe(true);
+    gate.resolve({ entries: [], aborted: false });
+    await p;
+    expect(h.state.running.value).toBe(false);
+  });
+
+  it('publishes a live query_id via onStatementStart; cancel() targets it', async () => {
+    const h = makeHarness();
+    const gate = deferred<ScriptExecutionResult>();
+    let capturedSignal: AbortSignal | undefined;
+    h.execFakes.executeScript.mockImplementation((req: ScriptExecutionRequest) => {
+      capturedSignal = req.signal;
+      req.onStatementStart(0, { queryId: 'q-live', attempt: 1 });
+      return gate.promise;
+    });
+    const session = createWorkbenchSession(h.deps);
+    const p = session.runScript(['SELECT 1'], 'SELECT 1');
+    await flush();
+    session.cancel();
+    expect(h.execFakes.kill).toHaveBeenCalledWith('q-live');
+    expect(capturedSignal?.aborted).toBe(true);
+    gate.resolve({ entries: [], aborted: true });
+    await p;
+  });
+
+  it('pushes entries + repaints + records boundParams via onStatementResult', async () => {
+    const h = makeHarness({
+      hooks: { prepareTabSource: vi.fn(() => preparedSource({ statements: [preparedStatement({ boundParams: [boundParam('p')] })] })) },
+    });
+    h.execFakes.executeScript.mockImplementation(async (req: ScriptExecutionRequest) => {
+      req.onStatementStart(0, { queryId: 'q-1', attempt: 1 });
+      req.onStatementResult(0, { sql: 'SELECT 1', status: 'rows', columns: [], rows: [], truncated: false, preview: '', ms: 1 });
+      return { entries: [{ sql: 'SELECT 1', status: 'rows', columns: [], rows: [], truncated: false, preview: '', ms: 1 }], aborted: false };
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.runScript(['SELECT 1'], 'SELECT 1');
+    expect(h.hooks.renderResults).toHaveBeenCalled();
+    expect(h.hooks.recordBoundParams).toHaveBeenCalledWith([boundParam('p')]);
+  });
+
+  it('an error entry never records boundParams for that statement, and blocks history', async () => {
+    const h = makeHarness();
+    h.execFakes.executeScript.mockImplementation(async (req: ScriptExecutionRequest) => {
+      req.onStatementResult(0, { sql: 'SELECT 1', status: 'error', error: 'boom', ms: 1 });
+      return { entries: [{ sql: 'SELECT 1', status: 'error', error: 'boom', ms: 1 }], aborted: false };
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.runScript(['SELECT 1'], 'SELECT 1');
+    expect(h.hooks.recordBoundParams).not.toHaveBeenCalled();
+    expect(h.state.history).toEqual([]);
+    expect(h.hooks.renderSavedHistory).not.toHaveBeenCalled();
+  });
+
+  it('a clean run records one script history entry, and repaints History when open', async () => {
+    const h = makeHarness({ state: { sidePanel: signal('history') } });
+    h.execFakes.executeScript.mockImplementation(async (req: ScriptExecutionRequest) => {
+      const entry = { sql: 'SELECT 1', status: 'rows' as const, columns: [], rows: [], truncated: false, preview: '', ms: 5 };
+      req.onStatementResult(0, entry);
+      return { entries: [entry], aborted: false };
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.runScript(['SELECT 1'], 'SELECT 1; SELECT 1;');
+    expect(h.state.history).toHaveLength(1);
+    expect(h.state.history[0].sql).toBe('SELECT 1; SELECT 1;');
+    expect(h.hooks.renderSavedHistory).toHaveBeenCalled();
+    expect(h.hooks.saveJSON).toHaveBeenCalled();
+  });
+
+  it('a clean run does not repaint History when a different side panel is open', async () => {
+    const h = makeHarness({ state: { sidePanel: signal('saved') } });
+    h.execFakes.executeScript.mockImplementation(async (req: ScriptExecutionRequest) => {
+      const entry = { sql: 'SELECT 1', status: 'ok' as const, ms: 5 };
+      req.onStatementResult(0, entry);
+      return { entries: [entry], aborted: false };
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.runScript(['SELECT 1'], 'SELECT 1;');
+    expect(h.state.history).toHaveLength(1);
+    expect(h.hooks.renderSavedHistory).not.toHaveBeenCalled();
+  });
+
+  it('sets `cancelled` on the script result when aborted', async () => {
+    const h = makeHarness();
+    h.execFakes.executeScript.mockImplementation(async () => ({ entries: [], aborted: true }));
+    const session = createWorkbenchSession(h.deps);
+    await session.runScript(['SELECT 1'], 'SELECT 1');
+    expect((h.tab.result as { cancelled?: boolean } | null)?.cancelled).toBe(true);
+    expect(h.state.history).toEqual([]); // aborted → no history, mirrors run()
+  });
+
+  it('reloads the schema after a schema-mutating statement even if a later one fails', async () => {
+    const h = makeHarness({
+      hooks: {
+        prepareTabSource: vi.fn(() => preparedSource({
+          statements: [
+            preparedStatement({ sql: 'CREATE TABLE t (x Int32) ENGINE=Memory' }),
+            preparedStatement({ sql: 'SELECT bogus' }),
+          ],
+        })),
+      },
+    });
+    h.execFakes.executeScript.mockImplementation(async (req: ScriptExecutionRequest) => {
+      const okEntry = { sql: 'CREATE TABLE t (x Int32) ENGINE=Memory', status: 'ok' as const, ms: 1 };
+      const errEntry = { sql: 'SELECT bogus', status: 'error' as const, error: 'boom', ms: 1 };
+      req.onStatementResult(0, okEntry);
+      req.onStatementResult(1, errEntry);
+      return { entries: [okEntry, errEntry], aborted: false };
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.runScript(['CREATE TABLE t (x Int32) ENGINE=Memory', 'SELECT bogus'], 'CREATE TABLE t (x Int32) ENGINE=Memory; SELECT bogus;');
+    expect(h.hooks.loadSchema).toHaveBeenCalled();
+  });
+
+  it('sends the per-statement wire SQL + merged session/args params to the transport', async () => {
+    const h = makeHarness({
+      hooks: {
+        sessionParamsFor: vi.fn(() => ({ session_id: 'sess-1' })),
+        prepareTabSource: vi.fn(() => preparedSource({
+          statements: [preparedStatement({ sql: 'SELECT 1 /* exec */', args: { param_p: '1' } })],
+        })),
+      },
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.runScript(['SELECT 1'], 'SELECT 1');
+    const req = h.execFakes.executeScript.mock.calls[0][0] as ScriptExecutionRequest;
+    expect(req.statements[0].execSql).toBe('SELECT 1 /* exec */');
+    expect(req.statements[0].params).toEqual({ session_id: 'sess-1', param_p: '1' });
+  });
+});
+
+// ── runEntry() ───────────────────────────────────────────────────────────────
+
+describe('createWorkbenchSession: runEntry()', () => {
+  it('does nothing outside SQL editor mode', async () => {
+    const h = makeHarness({ tab: { editorMode: 'spec' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.runEntry();
+    expect(h.execFakes.executeRead).not.toHaveBeenCalled();
+    expect(h.execFakes.executeScript).not.toHaveBeenCalled();
+  });
+
+  it('does nothing while already running', async () => {
+    const h = makeHarness({ state: { running: signal(true) } });
+    const session = createWorkbenchSession(h.deps);
+    await session.runEntry();
+    expect(h.execFakes.executeRead).not.toHaveBeenCalled();
+  });
+
+  it('does nothing for empty/comments-only input', async () => {
+    const h = makeHarness({ tab: { sqlDraft: '-- just a comment' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.runEntry();
+    expect(h.execFakes.executeRead).not.toHaveBeenCalled();
+  });
+
+  it('runs the selection when one is present, overriding the tab draft', async () => {
+    const h = makeHarness({
+      tab: { sqlDraft: 'SELECT 1' },
+      hooks: { getSelectionText: vi.fn(() => 'SELECT 2') },
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.runEntry();
+    const req = h.execFakes.executeRead.mock.calls[0][1] as ExecuteReadRequest;
+    expect(req.sql).toBe('SELECT 2');
+  });
+
+  it('a multi-statement input runs as a script', async () => {
+    const h = makeHarness({
+      tab: { sqlDraft: 'SELECT 1; SELECT 2;' },
+      hooks: {
+        prepareTabSource: vi.fn(() => preparedSource({
+          statements: [preparedStatement({ sql: 'SELECT 1' }), preparedStatement({ sql: 'SELECT 2' })],
+        })),
+      },
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.runEntry();
+    expect(h.execFakes.executeScript).toHaveBeenCalledTimes(1);
+    expect(h.execFakes.executeRead).not.toHaveBeenCalled();
+  });
+
+  it('a Filter-role tab always runs (never scripts), even with multiple statements', async () => {
+    const h = makeHarness({
+      tab: { sqlDraft: 'SELECT 1; SELECT 2;', specParsed: { name: 'f', favorite: false, dashboard: { role: 'filter' } } },
+    });
+    const session = createWorkbenchSession(h.deps);
+    await session.runEntry();
+    expect(h.execFakes.executeScript).not.toHaveBeenCalled();
+    expect(h.state.resultView.value).toBe('filter'); // the static multi-statement Filter error path
+  });
+
+  it('on mobile, jumps the bottom nav to Results', async () => {
+    const h = makeHarness({ state: { isMobile: signal(true) }, tab: { sqlDraft: 'SELECT 1' } });
+    const session = createWorkbenchSession(h.deps);
+    await session.runEntry();
+    expect(h.state.mobileView.value).toBe('results');
+  });
+});
+
+// ── cancel() ─────────────────────────────────────────────────────────────────
+
+describe('createWorkbenchSession: cancel()', () => {
+  it('is a no-op while idle', () => {
+    const h = makeHarness();
+    const session = createWorkbenchSession(h.deps);
+    session.cancel();
+    expect(h.execFakes.kill).not.toHaveBeenCalled();
+  });
+
+  it('aborts the in-flight signal and kills the live query_id while running', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'SELECT 1' } });
+    const gate = deferred<StreamResult>();
+    h.execFakes.executeRead.mockImplementation((result: StreamResult, req: ExecuteReadRequest) => {
+      void req;
+      return gate.promise;
+    });
+    const session = createWorkbenchSession(h.deps);
+    const p = session.run();
+    await flush();
+    expect(h.state.running.value).toBe(true);
+    const req = h.execFakes.executeRead.mock.calls[0][1] as ExecuteReadRequest;
+    session.cancel();
+    expect(req.signal?.aborted).toBe(true);
+    expect(h.execFakes.kill).toHaveBeenCalledWith('q-1');
+    gate.resolve({ ...req } as unknown as StreamResult);
+    await p;
+  });
+});
+
+// ── elapsedMs() ──────────────────────────────────────────────────────────────
+
+describe('createWorkbenchSession: elapsedMs()', () => {
+  it('is 0 while idle', () => {
+    const h = makeHarness();
+    const session = createWorkbenchSession(h.deps);
+    expect(session.elapsedMs()).toBe(0);
+  });
+
+  it('reflects now() - t0 while running', async () => {
+    const h = makeHarness({ tab: { sqlDraft: 'SELECT 1' } });
+    const gate = deferred<StreamResult>();
+    h.execFakes.executeRead.mockImplementation(() => gate.promise);
+    const session = createWorkbenchSession(h.deps);
+    const p = session.run();
+    await flush();
+    expect(session.elapsedMs()).toBeGreaterThan(0);
+    gate.resolve({} as StreamResult);
+    await p;
+    expect(session.elapsedMs()).toBe(0);
+  });
+});
+
+// ── attachShell() ────────────────────────────────────────────────────────────
+
+describe('createWorkbenchSession: attachShell()', () => {
+  function makeEffects(): WorkbenchShellEffects & { renderResults: ReturnType<typeof vi.fn>; setRunBtn: ReturnType<typeof vi.fn>; setMobileBadge: ReturnType<typeof vi.fn> } {
+    return { renderResults: vi.fn(), setRunBtn: vi.fn(), setMobileBadge: vi.fn() };
+  }
+
+  it('fires all 3 effects once on attach', () => {
+    const h = makeHarness();
+    const session = createWorkbenchSession(h.deps);
+    const fx = makeEffects();
+    session.attachShell(fx);
+    expect(fx.renderResults).toHaveBeenCalledTimes(1);
+    expect(fx.setRunBtn).toHaveBeenCalledTimes(1);
+    expect(fx.setMobileBadge).toHaveBeenCalledTimes(1);
+  });
+
+  it('the results + mobile-badge effects react to activeTabId/resultView/running', () => {
+    const h = makeHarness();
+    const session = createWorkbenchSession(h.deps);
+    const fx = makeEffects();
+    session.attachShell(fx);
+    h.state.activeTabId.value = 't2';
+    expect(fx.renderResults).toHaveBeenCalledTimes(2);
+    expect(fx.setMobileBadge).toHaveBeenCalledTimes(2);
+    expect(fx.setRunBtn).toHaveBeenCalledTimes(1); // unaffected by activeTabId
+  });
+
+  it('the Run-button effect reacts to hasSelection', () => {
+    const h = makeHarness();
+    const session = createWorkbenchSession(h.deps);
+    const fx = makeEffects();
+    session.attachShell(fx);
+    h.state.hasSelection.value = true;
+    expect(fx.setRunBtn).toHaveBeenCalledTimes(2);
+    expect(fx.renderResults).toHaveBeenCalledTimes(1); // unaffected by hasSelection
+  });
+
+  it('re-attaching disposes the previous effect set (no double-fire)', () => {
+    const h = makeHarness();
+    const session = createWorkbenchSession(h.deps);
+    const first = makeEffects();
+    const second = makeEffects();
+    session.attachShell(first);
+    session.attachShell(second);
+    h.state.activeTabId.value = 't2';
+    expect(first.renderResults).toHaveBeenCalledTimes(1); // only the initial attach fire
+    expect(second.renderResults).toHaveBeenCalledTimes(2); // initial + the signal write
+  });
+
+  it('destroy() disposes the attached effects (no fire after)', () => {
+    const h = makeHarness();
+    const session = createWorkbenchSession(h.deps);
+    const fx = makeEffects();
+    session.attachShell(fx);
+    session.destroy();
+    h.state.activeTabId.value = 't2';
+    h.state.hasSelection.value = true;
+    expect(fx.renderResults).toHaveBeenCalledTimes(1);
+    expect(fx.setRunBtn).toHaveBeenCalledTimes(1);
+    expect(fx.setMobileBadge).toHaveBeenCalledTimes(1);
+  });
+});
+
+// ── destroy() ────────────────────────────────────────────────────────────────
+
+describe('createWorkbenchSession: destroy()', () => {
+  it('is a safe no-op while idle', () => {
+    const h = makeHarness();
+    const session = createWorkbenchSession(h.deps);
+    expect(() => session.destroy()).not.toThrow();
+    expect(h.execFakes.kill).not.toHaveBeenCalled();
+  });
+
+  it('mid-flight: clears the ticker, aborts, and kills the live query', async () => {
+    const clearSpy = vi.spyOn(globalThis, 'clearInterval');
+    const h = makeHarness({ tab: { sqlDraft: 'SELECT 1' } });
+    const gate = deferred<StreamResult>();
+    h.execFakes.executeRead.mockImplementation(() => gate.promise);
+    const session = createWorkbenchSession(h.deps);
+    const p = session.run();
+    await flush();
+    const req = h.execFakes.executeRead.mock.calls[0][1] as ExecuteReadRequest;
+    const callsBefore = clearSpy.mock.calls.length;
+    session.destroy();
+    expect(clearSpy.mock.calls.length).toBeGreaterThan(callsBefore);
+    expect(req.signal?.aborted).toBe(true);
+    expect(h.execFakes.kill).toHaveBeenCalledWith('q-1');
+    gate.resolve({} as StreamResult);
+    await p;
+    clearSpy.mockRestore();
+  });
+});