diff --git a/e2e/questdb b/e2e/questdb
index 048a595b7..641a661c6 160000
--- a/e2e/questdb
+++ b/e2e/questdb
@@ -1 +1 @@
-Subproject commit 048a595b70ed66a2a4eb649b36b6bf3ec1e3df8a
+Subproject commit 641a661c6e203ddd7a2fe160407c1be3bb4e3249
diff --git a/e2e/tests/console/result_charts.spec.js b/e2e/tests/console/result_charts.spec.js
index b2cf38bc0..78206934b 100644
--- a/e2e/tests/console/result_charts.spec.js
+++ b/e2e/tests/console/result_charts.spec.js
@@ -52,4 +52,31 @@ describe("questdb charts", () => {
       .invoke("height")
       .should("be.gt", 0)
   })
+
+  it("keeps reset zoom available when the responsive slider disappears", () => {
+    cy.viewport(760, 900)
+    cy.typeQueryDirectly(
+      "SELECT rnd_timestamp(to_timestamp('2024-07-19:00:00:00.000000', 'yyyy-MM-dd:HH:mm:ss.SSSUUU'), to_timestamp('2024-07-20:00:00:00.000000', 'yyyy-MM-dd:HH:mm:ss.SSSUUU'), 0), x FROM long_sequence(500);",
+    )
+    cy.clickRunIconInLine(1)
+    cy.getByDataHook("chart-panel-button").should("be.visible").click()
+
+    cy.getByDataHook("result-chart")
+      .find("canvas")
+      .should("be.visible")
+      .then(($canvas) => {
+        const canvas = $canvas[0]
+        const sliderY = canvas.getBoundingClientRect().height - 44
+
+        cy.wrap(canvas).realMouseDown({ x: 54, y: sliderY })
+        cy.wrap(canvas).realMouseMove(130, sliderY)
+        cy.wrap(canvas).realMouseUp({ x: 130, y: sliderY })
+      })
+
+    cy.getByDataHook("result-chart-reset-zoom").should("be.visible")
+
+    cy.viewport(1280, 900)
+    cy.getByDataHook("result-chart-reset-zoom").should("be.visible").click()
+    cy.getByDataHook("result-chart-reset-zoom").should("not.exist")
+  })
 })
diff --git a/src/components/DropdownMenu/index.tsx b/src/components/DropdownMenu/index.tsx
index c37089522..7e8134074 100644
--- a/src/components/DropdownMenu/index.tsx
+++ b/src/components/DropdownMenu/index.tsx
@@ -1,6 +1,6 @@
 import React from "react"
 import * as RadixDropdownMenu from "@radix-ui/react-dropdown-menu"
-import { CaretRightIcon } from "@phosphor-icons/react"
+import { CaretRightIcon, CheckIcon } from "@phosphor-icons/react"
 import styled, { css } from "styled-components"
 import {
   menuContainerStyles,
@@ -76,6 +76,42 @@ const Item = React.forwardRef<
 
 Item.displayName = "DropdownMenuItem"
 
+const StyledCheckboxItem = styled(RadixDropdownMenu.CheckboxItem)`
+  ${menuItemStyles}
+`
+
+const CheckSlot = styled.span`
+  display: inline-flex;
+  width: 1.6rem;
+  margin-left: auto;
+  align-items: center;
+  justify-content: center;
+  color: ${({ theme }) => theme.color.contentAccent};
+`
+
+type CheckboxItemProps = React.ComponentPropsWithoutRef<
+  typeof RadixDropdownMenu.CheckboxItem
+> & {
+  icon?: React.ReactNode
+}
+
+const CheckboxItem = React.forwardRef<
+  React.ElementRef<typeof RadixDropdownMenu.CheckboxItem>,
+  CheckboxItemProps
+>(({ icon, children, ...props }, ref) => (
+  <StyledCheckboxItem ref={ref} {...props}>
+    {icon != null && <MenuItemIcon>{icon}</MenuItemIcon>}
+    {children}
+    <CheckSlot>
+      <RadixDropdownMenu.ItemIndicator asChild>
+        <CheckIcon size={16} weight="bold" />
+      </RadixDropdownMenu.ItemIndicator>
+    </CheckSlot>
+  </StyledCheckboxItem>
+))
+
+CheckboxItem.displayName = "DropdownMenuCheckboxItem"
+
 const StyledSubTrigger = styled(RadixDropdownMenu.SubTrigger)`
   ${menuItemStyles}
   justify-content: space-between;
@@ -120,6 +156,8 @@ export const DropdownMenu = {
 
   Item,
 
+  CheckboxItem,
+
   Sub: RadixDropdownMenu.Sub,
 
   SubTrigger,
diff --git a/src/consts/shared-definitions.json b/src/consts/shared-definitions.json
index 16c95af3c..e97f51ff5 100644
--- a/src/consts/shared-definitions.json
+++ b/src/consts/shared-definitions.json
@@ -184,7 +184,7 @@
     "surfaces": ["ai", "mcp"],
     "mutatesNotebook": true,
     "createsNotebook": true,
-    "description": "Duplicate a notebook tab. Copies every cell (SQL, mode, chart config) and the layout into a NEW notebook labelled \"<label> (copy)\" placed right after the original; cell ids are regenerated and last-run results are cleared. The copy is ALWAYS made in the background — you never switch the user's active tab. The user sees a notification and opens it themselves; only call activate_notebook if they explicitly ask to be taken there.",
+    "description": "Duplicate a notebook tab. Copies every cell (SQL, mode, chart config), layout, and run history into a NEW notebook labelled \"<label> (copy)\" placed right after the original; cell ids are regenerated. Matching saved result snapshots are copied best-effort in the background and hydrate when the copy is opened. `last_run_status` is preserved as history and does not guarantee that a saved result snapshot exists. The copy is ALWAYS made in the background — you never switch the user's active tab. The user sees a notification and opens it themselves; only call activate_notebook if they explicitly ask to be taken there.",
     "inputSchema": {
       "type": "object",
       "additionalProperties": false,
@@ -222,7 +222,7 @@
     "surfaces": ["ai", "mcp"],
     "mutatesNotebook": false,
     "createsNotebook": false,
-    "description": "List the cells in a notebook. Returns id, type, short preview (≤120 chars), position, mode, and last-run status. Three fields are LIVE-ONLY — present only while the notebook is open in the console, so absence never means \"not refreshing\" or \"not blocked\": `refreshing: true` while a refresh is in flight (the visible rows are still the previous round's), `last_refresh_error` when the last round left a failure, and `auto_refresh_blocked: \"contains_write\"` on cells auto-refresh will not run. `last_run_status` is unrelated to these: it stays the outcome of the last completed RUN, and a refresh never changes it. No cell data values.",
+    "description": "List the cells in a notebook. Returns id, type, short preview (≤120 chars), position, mode, and last-run status. Mode is the presented result kind: `run` for a table result, `draw` for a chart, and null for editor-only/markdown cells. Three fields are LIVE-ONLY — present only while the notebook is open in the console, so absence never means \"not refreshing\" or \"not blocked\": `refreshing: true` while a refresh is in flight (the visible rows are still the previous round's), `last_refresh_error` when the last round left a failure, and `auto_refresh_blocked: \"contains_write\"` on cells auto-refresh will not run. `last_run_status` is unrelated to these: it stays the outcome of the last completed RUN, and a refresh never changes it. No cell data values.",
     "inputSchema": {
       "type": "object",
       "additionalProperties": false,
@@ -241,7 +241,7 @@
     "surfaces": ["ai", "mcp"],
     "mutatesNotebook": false,
     "createsNotebook": false,
-    "description": "Get full details of a cell (value, kind via `type`, UI flags, chart config, last-run status + trimmed error). Three fields are LIVE-ONLY — present only while the notebook is open in the console, so absence never means \"not refreshing\" or \"not blocked\": `refreshing: true` while a refresh is in flight (the visible rows are still the previous round's), `last_refresh_error` when the last round left a failure, and `auto_refresh_blocked: \"contains_write\"` on cells auto-refresh will not run. `last_run_status` is unrelated to these: it stays the outcome of the last completed RUN, and a refresh never changes it. `type:\"markdown\"` marks a prose cell whose `value` is markdown source; SQL cells omit `type`. Never includes query result data. By default the value is capped at 4 KB; a capped response carries `truncated: true` and `full_length`. A truncated value is NOT the cell's real content — NEVER write it back (update_cell / apply_notebook_state value); re-read with get_full_content: true first, or keep the cell with preserve_value: true.",
+    "description": "Get full details of a cell (value, kind via `type`, editor_height/result_height, view, chart config, last-run status + trimmed error). Height values are fixed CSS pixels or \"auto\". `view` reports what a SQL/draw cell presents: \"editor\" while there is nothing to show, else the stored result or editor_result arrangement. Markdown has no pane-view state: it reports `view` and `result_height` as null. Other LIVE-ONLY fields are `refreshing: true`, `last_refresh_error`, and `auto_refresh_blocked: \"contains_write\"`; absence never means \"not refreshing\" or \"not blocked\". `last_run_status` is unrelated to refresh state: it stays the outcome of the last completed RUN. `type:\"markdown\"` marks a prose cell whose `value` is markdown source; SQL cells omit `type`. Never includes query result data. By default the value is capped at 4 KB; a capped response carries `truncated: true` and `full_length`. A truncated value is NOT the cell's real content — NEVER write it back (update_cell / apply_notebook_state value); re-read with get_full_content: true first, or keep the cell with preserve_value: true.",
     "inputSchema": {
       "type": "object",
       "additionalProperties": false,
@@ -266,7 +266,7 @@
     "surfaces": ["ai", "mcp"],
     "mutatesNotebook": false,
     "createsNotebook": false,
-    "description": "Full structural snapshot of a notebook (layout, cells with previews, kind via `type`, last-run statuses). Three fields are LIVE-ONLY — present only while the notebook is open in the console, so absence never means \"not refreshing\" or \"not blocked\": `refreshing: true` while a refresh is in flight (the visible rows are still the previous round's), `last_refresh_error` when the last round left a failure, and `auto_refresh_blocked: \"contains_write\"` on cells auto-refresh will not run. `last_run_status` is unrelated to these: it stays the outcome of the last completed RUN, and a refresh never changes it. `auto_refresh_default` is omitted when the notebook has no configured default. `type:\"markdown\"` marks a prose cell; SQL cells omit `type`. No cell data values; no columns/rows/count. Previews are capped at 120 chars — cells cut carry `preview_truncated: true` + `full_length`; a preview is never a cell's real content to write back.",
+    "description": "Full structural snapshot of a notebook (layout, cells with previews, semantic pane dimensions, kind via `type`, last-run statuses). Cell `grid` contains x/y/w only; height is derived from editor_height, result_height, and view. `view` reports what a SQL/draw cell presents: \"editor\" while there is nothing to show, else the stored result or editor_result arrangement. Markdown has no pane-view state: it reports `view` and `result_height` as null. Other LIVE-ONLY fields are `refreshing: true`, `last_refresh_error`, and `auto_refresh_blocked: \"contains_write\"`; absence never means \"not refreshing\" or \"not blocked\". `last_run_status` is unrelated to refresh state: it stays the outcome of the last completed RUN. `auto_refresh_default` is omitted when the notebook has no configured default. `type:\"markdown\"` marks a prose cell; SQL cells omit `type`. No cell data values; no columns/rows/count. Previews are capped at 120 chars — cells cut carry `preview_truncated: true` + `full_length`; a preview is never a cell's real content to write back.",
     "inputSchema": {
       "type": "object",
       "additionalProperties": false,
@@ -470,7 +470,7 @@
     "surfaces": ["ai", "mcp"],
     "mutatesNotebook": true,
     "createsNotebook": false,
-    "description": "Position a single cell in grid mode. x/y/w/h are integers in the react-grid-layout grid. The 12-column limit applies to WIDTH only (w ≤ 12); h is NOT in column units — the rendered cell box is h*10 + (h-1)*20 px (10px rows with 20px gaps BETWEEN rows; do NOT estimate with h*30), and a fixed 44px cell header inside it leaves (h*30 - 64)px of content. Chart cells pad the plot a further ~40px top and ~56px bottom (~86px when the zoom slider shows) inside that content area. EXAMPLES: markdown h:3 -> 3*10 + 2*20 = 70px box, 70 - 44 = 26px of text (the minimum strip); markdown h:5 -> 130px box, 86px of text (a comfortable title); chart h:10 -> 280px box, 236px content, ~140px of plot after padding (~110px with the zoom slider).",
+    "description": "Position a single cell in grid mode. x/y/w are integers in the react-grid-layout grid; width is limited to 12 columns. Cell height is derived from its semantic pane dimensions. The response includes the applied grid position plus the cell's presented `view` and `mode`; editor-only and markdown cells report mode null, and markdown also reports view null. Use set_cell_dimensions to resize a cell or change its `view`.",
     "inputSchema": {
       "type": "object",
       "additionalProperties": false,
@@ -482,19 +482,71 @@
           "type": "string"
         },
         "x": {
-          "type": "number"
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 11
         },
         "y": {
-          "type": "number"
+          "type": "integer",
+          "minimum": 0
         },
         "w": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 12
+        }
+      },
+      "required": ["buffer_id", "cell_id", "x", "y", "w"]
+    }
+  },
+  {
+    "name": "set_cell_dimensions",
+    "category": "free",
+    "surfaces": ["ai", "mcp"],
+    "mutatesNotebook": true,
+    "createsNotebook": false,
+    "description": "Resize a cell using semantic pane dimensions in CSS pixels and choose its pane view. Every input field is required by strict tool calling: pass null to preserve the current setting. Pass \"auto\" for a height to restore automatic sizing, or a number to pin it. For SQL/draw cells, view accepts editor, result, or editor_result. view \"editor\" is DESTRUCTIVE: it discards the cell's result and snapshot and clears its presented mode — the same gesture as toggling off the table or chart in the UI; the response then carries mode:null and result_discarded:true. The stored result/editor_result arrangement is kept for the next result. A cell with nothing to show reports view \"editor\" and mode null. Markdown has no pane-view state: it reports `view`, `mode`, and `result_height` as null; editor_height sizes its rendered content, while result_height and view are ignored — keep them null. Use 86px for a polished markdown title. Chart result_height must be at least 296px; table results at least 100px. No pane may exceed 2400px.",
+    "inputSchema": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "buffer_id": {
           "type": "number"
         },
-        "h": {
-          "type": "number"
+        "cell_id": {
+          "type": "string"
+        },
+        "editor_height": {
+          "anyOf": [
+            { "type": "number", "minimum": 56, "maximum": 2400 },
+            { "type": "string", "enum": ["auto"] },
+            { "type": "null" }
+          ],
+          "description": "Editor pane height in CSS pixels; for markdown, rendered content height. Null preserves, \"auto\" restores content-driven sizing. SQL editors are at least 72px, markdown at least 56px, and every pane at most 2400px. Use 86px for a polished markdown title."
+        },
+        "result_height": {
+          "anyOf": [
+            { "type": "number", "minimum": 100, "maximum": 2400 },
+            { "type": "string", "enum": ["auto"] },
+            { "type": "null" }
+          ],
+          "description": "Result/chart pane height in CSS pixels. Null preserves, \"auto\" restores result-driven sizing. Maximum 2400px."
+        },
+        "view": {
+          "anyOf": [
+            { "type": "string", "enum": ["editor", "result", "editor_result"] },
+            { "type": "null" }
+          ],
+          "description": "The cell's pane view. Null preserves. result and editor_result store the arrangement. editor DISCARDS the cell's result and snapshot, clears its presented mode, and hides the result pane (the toggle-off gesture); on a cell with nothing to show it is a no-op."
         }
       },
-      "required": ["buffer_id", "cell_id", "x", "y", "w", "h"]
+      "required": [
+        "buffer_id",
+        "cell_id",
+        "editor_height",
+        "result_height",
+        "view"
+      ]
     }
   },
   {
@@ -733,30 +785,6 @@
       "required": ["buffer_id", "cell_id", "name"]
     }
   },
-  {
-    "name": "set_cell_view_maximized",
-    "category": "free",
-    "surfaces": ["ai", "mcp"],
-    "mutatesNotebook": true,
-    "createsNotebook": false,
-    "description": "Toggle whether the cell's result view (chart OR table) fills the cell, hiding the editor. Applies to any cell that has a result — not just charts. For narrow cells, there is no split-view.  When this is false, the cell only shows the editor for narrow cells. For wide cells, it shows the editor and the result view if result exists.",
-    "inputSchema": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "buffer_id": {
-          "type": "number"
-        },
-        "cell_id": {
-          "type": "string"
-        },
-        "value": {
-          "type": "boolean"
-        }
-      },
-      "required": ["buffer_id", "cell_id", "value"]
-    }
-  },
   {
     "name": "apply_notebook_state",
     "category": "free",
@@ -836,12 +864,12 @@
               "type": {
                 "type": ["string", "null"],
                 "enum": ["sql", "markdown", null],
-                "description": "Cell kind. \"markdown\" makes this a rendered prose cell — `value` is markdown source, and `mode`/`chart_config` MUST be null (rejected otherwise). It is never executed or auto-run. Cell kind is STICKY: null/omitted preserves an existing cell's kind (it does NOT reset markdown cells to SQL); new cells default to \"sql\"."
+                "description": "Cell kind. \"markdown\" makes this a rendered prose cell — `value` is markdown source, and `mode`/`chart_config` MUST be null (rejected otherwise). It is never executed or auto-run. Cell kind is FIXED for the life of a cell: null/omitted preserves an existing cell's kind, and sending the other kind for an existing id is rejected — delete the cell and add a new one instead. New cells default to \"sql\"."
               },
               "mode": {
                 "type": ["string", "null"],
                 "enum": ["run", "draw", null],
-                "description": "Cell mode. Null defaults to 'run' for new cells, preserves current for existing."
+                "description": "Requested result mode. Null defaults to 'run' for new cells and preserves the current mode for existing cells, except that view='editor' is authoritative and clears the presented mode. An explicit 'run' or 'draw' cannot be combined with view='editor'."
               },
               "auto_refresh": {
                 "anyOf": [
@@ -853,11 +881,33 @@
                     "enum": ["1s", "5s", "10s", "30s", "1m"]
                   }
                 ],
-                "description": "Per-cell auto-refresh value: true = adaptive poll, false = off, or a fixed interval string (\"1s\"/\"5s\"/\"10s\"/\"30s\"/\"1m\"). Omitted or null stores NO override — the cell inherits the notebook's auto_refresh_default."
+                "description": "Per-cell auto-refresh value: true = adaptive poll, false = off, or a fixed interval string (\"1s\"/\"5s\"/\"10s\"/\"30s\"/\"1m\"). Omitted or null stores NO override — the cell inherits the notebook's auto_refresh_default. Ignored for markdown; keep it null."
               },
-              "is_view_maximized": {
-                "type": ["boolean", "null"],
-                "description": "Whether the cell's result view (chart OR table) fills the cell, hiding the editor. Null defaults to true when mode='draw'."
+              "editor_height": {
+                "anyOf": [
+                  { "type": "number", "minimum": 56, "maximum": 2400 },
+                  { "type": "string", "enum": ["auto"] },
+                  { "type": "null" }
+                ],
+                "description": "Editor pane height in CSS pixels; for markdown, rendered content height. Null preserves an existing setting (default auto for a new cell); \"auto\" restores content-driven sizing. SQL editors are at least 72px, markdown at least 56px, and every pane at most 2400px. Use 86px for a polished markdown title."
+              },
+              "result_height": {
+                "anyOf": [
+                  { "type": "number", "minimum": 100, "maximum": 2400 },
+                  { "type": "string", "enum": ["auto"] },
+                  { "type": "null" }
+                ],
+                "description": "Result/chart pane height in CSS pixels. Null preserves an existing setting (default auto for a new cell); \"auto\" restores result-driven sizing. Charts require at least 296px; tables 100px; maximum 2400px. Ignored for markdown; keep it null."
+              },
+              "view": {
+                "anyOf": [
+                  {
+                    "type": "string",
+                    "enum": ["editor", "result", "editor_result"]
+                  },
+                  { "type": "null" }
+                ],
+                "description": "The cell's pane view. Null preserves an existing setting. result and editor_result store the arrangement. editor is authoritative: it DISCARDS an existing cell's result and snapshot, clears its presented mode, and hides the result pane (the toggle-off gesture; the cell is then listed in results_cleared). Send mode:null with view:'editor'; an explicit mode 'run' or 'draw' is rejected as contradictory. New draw cells default to result; other new SQL cells default to editor_result but report editor with mode null until a result exists. Ignored for markdown; keep it null."
               },
               "chart_config": {
                 "type": ["object", "null"],
@@ -960,22 +1010,24 @@
               "grid": {
                 "type": ["object", "null"],
                 "additionalProperties": false,
-                "description": "Grid position when layout_mode='grid'. The 12 columns apply to width only (w ≤ 12). Rendered cell box is h*10 + (h-1)*20 px (do NOT estimate with h*30); a fixed 44px header leaves (h*30 - 64)px of content; chart plots pad a further ~40px top and ~56-86px bottom. EXAMPLES: markdown h:3 -> 70px box / 26px text (the minimum); markdown h:5 -> 130px / 86px text (a title); chart h:10 -> 280px / ~140px of plot.",
+                "description": "Grid position when layout_mode='grid'. The 12 columns apply to width only (w ≤ 12); height is derived from editor_height, result_height, and view.",
                 "properties": {
                   "x": {
-                    "type": "integer"
+                    "type": "integer",
+                    "minimum": 0,
+                    "maximum": 11
                   },
                   "y": {
-                    "type": "integer"
+                    "type": "integer",
+                    "minimum": 0
                   },
                   "w": {
-                    "type": "integer"
-                  },
-                  "h": {
-                    "type": "integer"
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 12
                   }
                 },
-                "required": ["x", "y", "w", "h"]
+                "required": ["x", "y", "w"]
               }
             },
             "required": [
@@ -986,7 +1038,9 @@
               "type",
               "mode",
               "auto_refresh",
-              "is_view_maximized",
+              "editor_height",
+              "result_height",
+              "view",
               "chart_config",
               "grid"
             ]
@@ -1056,7 +1110,7 @@
     "surfaces": ["mcp"],
     "mutatesNotebook": false,
     "createsNotebook": false,
-    "description": "If notebook tools fail with BRIDGE_NOT_PAIRED, call get_pairing_credentials to begin pairing (the response includes a one-click URL to show the user; authentication runs in the browser, the bridge never sees credentials). Once paired, call get_workspace_state at the start of each notebook turn; the digest of edits since your last fetch is in get_recent_user_actions.\n\nReturn the current workspace + notebook context as text. Use this at the start of every notebook turn so you know which notebook is active, what cells exist, layout mode, chart configs, and last-run statuses. Pass include_user_events=true to also receive the digest of edits the user made since your last fetch.",
+    "description": "If notebook tools fail with BRIDGE_NOT_PAIRED, call get_pairing_credentials to begin pairing (the response includes a one-click URL to show the user; authentication runs in the browser, the bridge never sees credentials). Once paired, call get_workspace_state at the start of every notebook turn; the digest of edits since your last fetch is in get_recent_user_actions.\n\nReturn the current workspace + notebook context as text. Use this at the start of every notebook turn so you know which notebook is active, what cells exist, layout mode, chart configs, and last-run statuses. SQL/draw cells report their pane `view`: \"editor\" while there is nothing to show, else the stored result or editor_result arrangement. Their `mode` matches that presentation: null for editor-only, `run` for a table result, and `draw` for a chart. Markdown reports `view`, `mode`, and `result_height` as null. Pass include_user_events=true to also receive the digest of edits the user made since your last fetch.",
     "inputSchema": {
       "type": "object",
       "properties": {
@@ -1073,7 +1127,7 @@
     "surfaces": ["mcp"],
     "mutatesNotebook": false,
     "createsNotebook": false,
-    "description": "If notebook tools fail with BRIDGE_NOT_PAIRED, call get_pairing_credentials to begin pairing (the response includes a one-click URL to show the user; authentication runs in the browser, the bridge never sees credentials). Once paired, call get_workspace_state at the start of each notebook turn; the digest of edits since your last fetch is in get_recent_user_actions.\n\nReturn the digest of user edits to the notebook since your last fetch (or session start). Use this to detect that the user changed something the agent might want to react to. Coalesced — multiple typing events on the same cell collapse to a single 'edited' entry.",
+    "description": "If notebook tools fail with BRIDGE_NOT_PAIRED, call get_pairing_credentials to begin pairing (the response includes a one-click URL to show the user; authentication runs in the browser, the bridge never sees credentials). Once paired, call get_workspace_state at the start of every notebook turn; the digest of edits since your last fetch is in get_recent_user_actions.\n\nReturn the digest of user edits to the notebook since your last fetch (or session start). Use this to detect that the user changed something the agent might want to react to. Coalesced — multiple typing events on the same cell collapse to a single 'edited' entry.",
     "inputSchema": {
       "type": "object",
       "properties": {},
diff --git a/src/modules/ConsoleEventTracker/events.ts b/src/modules/ConsoleEventTracker/events.ts
index 90f6425bd..219b3e435 100644
--- a/src/modules/ConsoleEventTracker/events.ts
+++ b/src/modules/ConsoleEventTracker/events.ts
@@ -126,7 +126,7 @@ export enum ConsoleEvent {
   NOTEBOOK_CELL_EXPAND_WIDTH = "notebook.cell_expand_width",
   NOTEBOOK_CELL_SIZE_RESET = "notebook.cell_size_reset",
   NOTEBOOK_CELL_VIEW_CHANGE = "notebook.cell_view_change",
-  NOTEBOOK_CELL_VIEW_MAXIMIZE = "notebook.cell_view_maximize",
+  NOTEBOOK_CELL_EDITOR_TOGGLE = "notebook.cell_editor_toggle",
   NOTEBOOK_CELL_MAXIMIZE = "notebook.cell_maximize",
   NOTEBOOK_DRAW_TOGGLE = "notebook.draw_toggle",
   NOTEBOOK_DRAW_REFUSED = "notebook.draw_refused",
@@ -163,12 +163,12 @@ export enum ConsoleEvent {
   MCP_DUPLICATE_CELL = "mcp.duplicate_cell",
   MCP_SET_LAYOUT_MODE = "mcp.set_layout_mode",
   MCP_SET_CELL_LAYOUT = "mcp.set_cell_layout",
+  MCP_SET_CELL_DIMENSIONS = "mcp.set_cell_dimensions",
   MCP_SET_CELL_MODE = "mcp.set_cell_mode",
   MCP_SET_CELL_CHART_CONFIG = "mcp.set_cell_chart_config",
   MCP_SET_CELL_AUTOREFRESH = "mcp.set_cell_autorefresh",
   MCP_SET_NOTEBOOK_AUTOREFRESH = "mcp.set_notebook_autorefresh",
   MCP_SET_CELL_NAME = "mcp.set_cell_name",
-  MCP_SET_CELL_VIEW_MAXIMIZED = "mcp.set_cell_view_maximized",
   MCP_SET_CELL_MAXIMIZED = "mcp.set_cell_maximized",
   MCP_APPLY_NOTEBOOK_STATE = "mcp.apply_notebook_state",
   MCP_GET_TABLES = "mcp.get_tables",
diff --git a/src/scenes/Editor/Monaco/importTabs.test.ts b/src/scenes/Editor/Monaco/importTabs.test.ts
index 5e3cdd0d4..83a87e9b4 100644
--- a/src/scenes/Editor/Monaco/importTabs.test.ts
+++ b/src/scenes/Editor/Monaco/importTabs.test.ts
@@ -775,6 +775,119 @@ describe("sanitizeBuffer", () => {
   })
 
   describe("notebookViewState sanitization", () => {
+    it("imports one preferred view and maps main's legacy boolean", () => {
+      const input = {
+        label: "Notebook",
+        value: "",
+        position: 0,
+        notebookViewState: {
+          cells: [
+            { id: "preferred", value: "SELECT 1", paneView: "result" },
+            { id: "legacy-editor", value: "SELECT 2", paneView: "editor" },
+            { id: "legacy-on", value: "SELECT 3", isViewMaximized: true },
+            { id: "legacy-off", value: "SELECT 4", isViewMaximized: false },
+            {
+              id: "markdown",
+              value: "# Title",
+              type: "markdown",
+              paneView: "result",
+            },
+          ],
+        },
+      }
+
+      const cells = sanitizeBuffer(input).notebookViewState?.cells
+      expect(cells?.map((cell) => cell.paneView)).toEqual([
+        "result",
+        "editor_result",
+        "result",
+        "editor_result",
+        undefined,
+      ])
+      expect(cells?.every((cell) => !("isViewMaximized" in cell))).toBe(true)
+    })
+
+    it("strips run/draw sub-state from markdown cells", () => {
+      // Given a hand-crafted import smuggling SQL sub-state onto markdown
+      const input = {
+        label: "Notebook",
+        value: "",
+        position: 0,
+        notebookViewState: {
+          cells: [
+            {
+              id: "md",
+              value: "# Title",
+              type: "markdown",
+              mode: "draw",
+              autoRefresh: true,
+              chartConfig: { name: "Legacy title", xColumn: "ts", queries: [] },
+            },
+          ],
+        },
+      }
+      // When the buffer is sanitized
+      const cell = sanitizeBuffer(input).notebookViewState?.cells[0]
+      // Then the legacy chart name still becomes the cell name, but the
+      // run/draw sub-state apply_notebook_state would reject is gone
+      expect(cell).toMatchObject({ type: "markdown", name: "Legacy title" })
+      expect(cell && "mode" in cell).toBe(false)
+      expect(cell && "chartConfig" in cell).toBe(false)
+      expect(cell && "autoRefresh" in cell).toBe(false)
+    })
+
+    it("normalizes legacy SQL run mode to the implicit default", () => {
+      const input = {
+        label: "Notebook",
+        value: "",
+        position: 0,
+        notebookViewState: {
+          cells: [
+            { id: "run", value: "SELECT 1", mode: "run" },
+            { id: "draw", value: "SELECT 2", mode: "draw" },
+          ],
+        },
+      }
+
+      const cells = sanitizeBuffer(input).notebookViewState?.cells
+      expect(cells?.[0].mode).toBeUndefined()
+      expect(cells?.[1].mode).toBe("draw")
+    })
+
+    it("clamps imported pane heights to the floors and ceiling the UI enforces", () => {
+      // Given a hand-authored file pinning out-of-range heights
+      const input = {
+        label: "Notebook",
+        value: "",
+        position: 0,
+        notebookViewState: {
+          cells: [
+            {
+              id: "sql",
+              value: "SELECT 1",
+              topHeight: 0,
+              topResized: true,
+              bottomHeight: -500,
+              bottomResized: true,
+            },
+            { id: "chart", value: "SELECT 1", mode: "draw", bottomHeight: 100 },
+            { id: "md", value: "# t", type: "markdown", topHeight: 10 },
+            { id: "huge", value: "SELECT 1", topHeight: 99999 },
+            { id: "ok", value: "SELECT 1", topHeight: 300, bottomHeight: 250 },
+          ],
+        },
+      }
+      // When the buffer is sanitized
+      const cells = sanitizeBuffer(input).notebookViewState?.cells
+      // Then every height lands inside its pane's floor and ceiling, and
+      // in-range values pass through untouched
+      expect(cells?.[0]).toMatchObject({ topHeight: 72, bottomHeight: 100 })
+      expect(cells?.[1].bottomHeight).toBe(296)
+      expect(cells?.[2].topHeight).toBe(56)
+      expect(cells?.[3].topHeight).toBe(2400)
+      expect(cells?.[4]).toMatchObject({ topHeight: 300, bottomHeight: 250 })
+    })
+
     it("whitelists cell fields, reindexes positions, drops session state", () => {
       const input = {
         label: "Notebook",
diff --git a/src/scenes/Editor/Monaco/importTabs.ts b/src/scenes/Editor/Monaco/importTabs.ts
index 6bff47206..b349bb645 100644
--- a/src/scenes/Editor/Monaco/importTabs.ts
+++ b/src/scenes/Editor/Monaco/importTabs.ts
@@ -18,9 +18,15 @@ import type {
   NotebookViewState,
 } from "../../../store/notebook"
 import type { ChartConfig, QueryChart } from "../Notebook/CellChart/chartTypes"
-import { isAutoRefresh } from "../Notebook/notebookUtils"
+import {
+  clampPaneHeight,
+  isAutoRefresh,
+  minBottomHeightFor,
+  minTopHeightFor,
+} from "../Notebook/notebookUtils"
 import { LINE_NUMBER_HARD_LIMIT } from "./index"
 import {
+  isCellPaneView,
   MAX_NOTEBOOK_CELLS,
   MAX_CELL_LINES,
   MAX_CELL_NAME_LENGTH,
@@ -267,15 +273,33 @@ const sanitizeNotebookCell = (
   // Whitelist the kind so a hand-crafted import can't smuggle a bogus type
   // (anything other than "markdown" collapses to the SQL default).
   if (item.type === "markdown") cell.type = "markdown"
-  if (item.mode === "run" || item.mode === "draw") cell.mode = item.mode
-  const chartConfig = sanitizeChartConfig(item.chartConfig)
-  if (chartConfig) cell.chartConfig = chartConfig
-  if (isAutoRefresh(item.autoRefresh)) cell.autoRefresh = item.autoRefresh
-  if (typeof item.isViewMaximized === "boolean")
-    cell.isViewMaximized = item.isViewMaximized
-  if (typeof item.topHeight === "number") cell.topHeight = item.topHeight
-  if (typeof item.bottomHeight === "number")
-    cell.bottomHeight = item.bottomHeight
+  // Markdown cells carry no run/draw sub-state — gating it here keeps a
+  // hand-crafted import from producing a cell apply_notebook_state rejects.
+  if (item.type !== "markdown") {
+    if (item.mode === "draw") cell.mode = "draw"
+    const chartConfig = sanitizeChartConfig(item.chartConfig)
+    if (chartConfig) cell.chartConfig = chartConfig
+    if (isAutoRefresh(item.autoRefresh)) cell.autoRefresh = item.autoRefresh
+    if (isCellPaneView(item.paneView)) {
+      cell.paneView = item.paneView
+    } else if (item.isViewMaximized === true) {
+      cell.paneView = "result"
+    } else {
+      cell.paneView = "editor_result"
+    }
+  }
+  // Clamp to the same pane floors and ceiling every UI writer enforces, so a
+  // hand-authored file can't pin an invisible editor or an overlapping pane.
+  if (typeof item.topHeight === "number" && Number.isFinite(item.topHeight))
+    cell.topHeight = clampPaneHeight(minTopHeightFor(cell), item.topHeight)
+  if (
+    typeof item.bottomHeight === "number" &&
+    Number.isFinite(item.bottomHeight)
+  )
+    cell.bottomHeight = clampPaneHeight(
+      minBottomHeightFor(cell),
+      item.bottomHeight,
+    )
   if (typeof item.topResized === "boolean") cell.topResized = item.topResized
   if (typeof item.bottomResized === "boolean")
     cell.bottomResized = item.bottomResized
diff --git a/src/scenes/Editor/Notebook/CellChart/ChartRenderer.tsx b/src/scenes/Editor/Notebook/CellChart/ChartRenderer.tsx
index 8b600cc9c..818ff9492 100644
--- a/src/scenes/Editor/Notebook/CellChart/ChartRenderer.tsx
+++ b/src/scenes/Editor/Notebook/CellChart/ChartRenderer.tsx
@@ -2,13 +2,17 @@ import React, {
   useCallback,
   useEffect,
   useImperativeHandle,
+  useLayoutEffect,
   useMemo,
   useRef,
+  useState,
 } from "react"
 import ReactECharts from "echarts-for-react/lib/core"
 import type { EChartsOption } from "echarts"
 import { useTheme } from "styled-components"
 import { echarts } from "./echartsSetup"
+import { withZoomDensity } from "./buildEchartsOption"
+import { chartZoomDensity, type ChartZoomDensity } from "./chartDensity"
 import { createQuestdbTheme } from "./questdbTheme"
 import { useNotebookBufferId } from "../NotebookProvider"
 import {
@@ -93,17 +97,39 @@ export const ChartRenderer = React.forwardRef<ChartRendererHandle, Props>(
     const reactEchartsRef = useRef<ReactECharts | null>(null)
     const wrapperRef = useRef<HTMLDivElement | null>(null)
     const zoomWindowRef = useRef(zoomWindow)
+    const [zoomDensity, setZoomDensity] = useState<ChartZoomDensity | null>(
+      null,
+    )
+    const measuredWidthRef = useRef(0)
+    const optionRef = useRef(option)
+    optionRef.current = option
     // Decided once per mount: a chart mounting into an already-settled
     // notebook (scroll remount) skips the entry animation.
     const animateEntryRef = useRef(
       animateEntry && shouldAnimateChartEntry(bufferId),
     )
     const firstInstanceDoneRef = useRef(false)
+    const onZoomChangeRef = useRef(onZoomChange)
 
     useEffect(() => {
       zoomWindowRef.current = zoomWindow
     }, [zoomWindow])
 
+    useEffect(() => {
+      onZoomChangeRef.current = onZoomChange
+    }, [onZoomChange])
+
+    const measureDensity = useCallback((width: number) => {
+      if (width <= 0) return
+      measuredWidthRef.current = width
+      const next = chartZoomDensity(optionRef.current, width)
+      setZoomDensity((previous) =>
+        previous?.slider === next.slider && previous.wheel === next.wheel
+          ? previous
+          : next,
+      )
+    }, [])
+
     // Capture-phase wheel listener must intercept BEFORE ECharts' inner
     // listeners so the page scrolls instead of ECharts preventDefaulting.
     useEffect(() => {
@@ -128,7 +154,9 @@ export const ChartRenderer = React.forwardRef<ChartRendererHandle, Props>(
 
       const observer = new ResizeObserver((entries) => {
         const box = entries[0]?.contentRect
-        if (box) resizeTo(box.width, box.height)
+        if (!box) return
+        resizeTo(box.width, box.height)
+        measureDensity(box.width)
       })
       observer.observe(wrapper)
 
@@ -145,7 +173,7 @@ export const ChartRenderer = React.forwardRef<ChartRendererHandle, Props>(
         observer.disconnect()
         document.removeEventListener("visibilitychange", handleVisibility)
       }
-    }, [])
+    }, [measureDensity])
 
     useImperativeHandle(
       ref,
@@ -169,11 +197,19 @@ export const ChartRenderer = React.forwardRef<ChartRendererHandle, Props>(
         firstInstanceDoneRef.current = true
         const zoom = zoomWindowRef.current
         if (zoom.start > 0 || zoom.end < 100) {
-          instance.dispatchAction({
-            type: "dataZoom",
-            start: zoom.start,
-            end: zoom.end,
-          })
+          const mounted = instance.getOption() as { dataZoom?: unknown[] }
+          if (Array.isArray(mounted.dataZoom) && mounted.dataZoom.length > 0) {
+            instance.dispatchAction({
+              type: "dataZoom",
+              start: zoom.start,
+              end: zoom.end,
+            })
+          } else {
+            // The remounted option dropped its dataZoom, so the saved window
+            // cannot be restored: report the zoom as gone, or the owner's
+            // Reset button keeps pointing at a zoom that no longer exists.
+            onZoomChangeRef.current?.(0, 100)
+          }
         }
         if (animateEntryRef.current) {
           const onFinished = () => {
@@ -186,14 +222,38 @@ export const ChartRenderer = React.forwardRef<ChartRendererHandle, Props>(
       [bufferId],
     )
 
-    const key = useMemo(() => structuralKey(option), [option])
+    // The chart mounts once the wrapper is measured, so the first instance
+    // already carries the right slider decision instead of remounting for it.
+    useLayoutEffect(() => {
+      const width = wrapperRef.current?.getBoundingClientRect().width
+      if (width) measureDensity(width)
+    }, [measureDensity, option])
+
+    const effectiveDensity = useMemo(
+      () =>
+        zoomDensity === null
+          ? null
+          : chartZoomDensity(option, measuredWidthRef.current),
+      [option, zoomDensity],
+    )
+
+    const optionToDraw = useMemo(
+      () =>
+        effectiveDensity === null
+          ? option
+          : withZoomDensity(option, effectiveDensity),
+      [effectiveDensity, option],
+    )
+    const key = useMemo(() => structuralKey(optionToDraw), [optionToDraw])
 
     const suppressEntryAnimation =
       !animateEntryRef.current && !firstInstanceDoneRef.current
     const renderOption = useMemo(
       () =>
-        suppressEntryAnimation ? { ...option, animationDuration: 0 } : option,
-      [option, suppressEntryAnimation],
+        suppressEntryAnimation
+          ? { ...optionToDraw, animationDuration: 0 }
+          : optionToDraw,
+      [optionToDraw, suppressEntryAnimation],
     )
 
     const events = useMemo(() => {
@@ -220,20 +280,22 @@ export const ChartRenderer = React.forwardRef<ChartRendererHandle, Props>(
           height: typeof height === "number" ? `${height}px` : height,
         }}
       >
-        <ReactECharts
-          key={`${theme.mode}:${key}`}
-          ref={reactEchartsRef}
-          echarts={echarts}
-          option={renderOption}
-          theme={chartTheme}
-          notMerge={false}
-          lazyUpdate
-          autoResize={false}
-          onEvents={events}
-          onChartReady={handleChartReady}
-          style={{ height: "100%", width: "100%" }}
-          opts={{ renderer: "canvas" }}
-        />
+        {effectiveDensity !== null && (
+          <ReactECharts
+            key={`${theme.mode}:${key}`}
+            ref={reactEchartsRef}
+            echarts={echarts}
+            option={renderOption}
+            theme={chartTheme}
+            notMerge={false}
+            lazyUpdate
+            autoResize={false}
+            onEvents={events}
+            onChartReady={handleChartReady}
+            style={{ height: "100%", width: "100%" }}
+            opts={{ renderer: "canvas" }}
+          />
+        )}
       </div>
     )
   },
diff --git a/src/scenes/Editor/Notebook/CellChart/buildEchartsOption.test.ts b/src/scenes/Editor/Notebook/CellChart/buildEchartsOption.test.ts
index 6f617e453..dcd82a630 100644
--- a/src/scenes/Editor/Notebook/CellChart/buildEchartsOption.test.ts
+++ b/src/scenes/Editor/Notebook/CellChart/buildEchartsOption.test.ts
@@ -370,3 +370,23 @@ describe("buildEchartsOption — timestamps render in UTC, like the result grid"
     expect(opt.useUTC).toBe(true)
   })
 })
+
+describe("buildEchartsOption — axis labels", () => {
+  it("hides overlapping x-axis labels so a narrow chart thins them instead of colliding", () => {
+    // Given a temporal x column with more ticks than a narrow chart can fit
+    const columns = [col("ts", "TIMESTAMP"), col("v", "DOUBLE")]
+    const dataset = Array.from({ length: 15 }, (_, i) => [i * 120_000, i])
+    // When the option builds
+    const opt = buildEchartsOption({ xColumn: "ts" }, [
+      resolved({
+        columns,
+        dataset,
+        xColumn: "ts",
+        type: "bar",
+        yColumns: ["v"],
+      }),
+    ])
+    // Then the x-axis label config asks ECharts to hide overlaps
+    expect(firstAxis(opt.xAxis).axisLabel).toMatchObject({ hideOverlap: true })
+  })
+})
diff --git a/src/scenes/Editor/Notebook/CellChart/buildEchartsOption.ts b/src/scenes/Editor/Notebook/CellChart/buildEchartsOption.ts
index 294324c05..b4398d263 100644
--- a/src/scenes/Editor/Notebook/CellChart/buildEchartsOption.ts
+++ b/src/scenes/Editor/Notebook/CellChart/buildEchartsOption.ts
@@ -1,4 +1,5 @@
 import type { EChartsOption } from "echarts"
+import { chartZoomDensity, type ChartZoomDensity } from "./chartDensity"
 import type { ColumnDefinition } from "../../../../utils/questdb/types"
 import type { ChartConfig, ChartType, SeriesAxis } from "./chartTypes"
 import { MAX_PARTITION_SERIES, classifyColumn } from "./inferChartConfig"
@@ -32,8 +33,6 @@ type SeriesContext = {
   categoryUnion: string[] | null // set only when overlaying series onto a shared category axis; null for a single positional query
 }
 
-const DATAZOOM_THRESHOLD = 200
-
 const LEGEND_BOTTOM = 3
 const SLIDER_HEIGHT = 18
 const SLIDER_BOTTOM = 40
@@ -357,7 +356,7 @@ export const buildEchartsOption = (
   queries: ResolvedQuery[],
 ): EChartsOption => {
   const chartText = { fontSize: CHART_FONT_SIZE }
-  const axisLabel = { fontSize: CHART_FONT_SIZE }
+  const axisLabel = { fontSize: CHART_FONT_SIZE, hideOverlap: true }
   const axisName = { fontSize: CHART_FONT_SIZE }
   const baseLegend = {
     type: "scroll" as const,
@@ -459,22 +458,13 @@ export const buildEchartsOption = (
       ? (rightQueries[0].name ?? rightQueries[0].yColumns[0] ?? "")
       : "")
 
-  const maxRows = queries.reduce((m, q) => Math.max(m, q.dataset.length), 0)
-  const hasZoom = maxRows > DATAZOOM_THRESHOLD
-  const sliderZoom = {
-    type: "slider" as const,
-    height: SLIDER_HEIGHT,
-    bottom: SLIDER_BOTTOM,
-    textStyle: chartText,
-  }
-
   const rightPadding = 36
 
   const grid: EChartsOption["grid"] = {
     left: 24,
     right: rightPadding,
     top: 40,
-    bottom: hasZoom ? GRID_BOTTOM_WITH_ZOOM : GRID_BOTTOM_NO_ZOOM,
+    bottom: GRID_BOTTOM_NO_ZOOM,
     containLabel: true,
   }
 
@@ -548,7 +538,42 @@ export const buildEchartsOption = (
     grid,
     xAxis,
     yAxis,
-    dataZoom: hasZoom ? [{ type: "inside" }, sliderZoom] : undefined,
     series: series as EChartsOption["series"],
   }
 }
+
+// Every cartesian chart embeds both zoom components, and density only toggles
+// their visibility — never the option's structure, which would remount the
+// chart through its structural key. Wheel zoom arms while marks are merely
+// tight (it costs no plot space); the slider costs plot height, so it waits
+// until marks fall under the readable floor. The renderer applies this from
+// its own measured size.
+export const withZoomSlider = (
+  option: EChartsOption,
+  containerWidthPx: number,
+): EChartsOption =>
+  withZoomDensity(option, chartZoomDensity(option, containerWidthPx))
+
+export const withZoomDensity = (
+  option: EChartsOption,
+  density: ChartZoomDensity,
+): EChartsOption => {
+  if (option.xAxis == null) return option
+  return {
+    ...option,
+    grid: {
+      ...(option.grid as object),
+      bottom: density.slider ? GRID_BOTTOM_WITH_ZOOM : GRID_BOTTOM_NO_ZOOM,
+    },
+    dataZoom: [
+      { type: "inside", disabled: !density.wheel },
+      {
+        type: "slider",
+        show: density.slider,
+        height: SLIDER_HEIGHT,
+        bottom: SLIDER_BOTTOM,
+        textStyle: { fontSize: CHART_FONT_SIZE },
+      },
+    ],
+  }
+}
diff --git a/src/scenes/Editor/Notebook/CellChart/chartDensity.test.ts b/src/scenes/Editor/Notebook/CellChart/chartDensity.test.ts
new file mode 100644
index 000000000..f1c4e61a4
--- /dev/null
+++ b/src/scenes/Editor/Notebook/CellChart/chartDensity.test.ts
@@ -0,0 +1,201 @@
+import { describe, it, expect } from "vitest"
+import type { ColumnDefinition } from "../../../../utils/questdb/types"
+import {
+  buildEchartsOption,
+  withZoomSlider,
+  type ResolvedQuery,
+} from "./buildEchartsOption"
+import {
+  MIN_MARK_PX,
+  MIN_POINT_PX,
+  needsWheelZoom,
+  needsZoomSlider,
+  WHEEL_ZOOM_HEADROOM,
+} from "./chartDensity"
+
+const col = (name: string, type: string): ColumnDefinition => ({ name, type })
+
+const resolved = (over: Partial<ResolvedQuery>): ResolvedQuery => ({
+  index: 0,
+  columns: [],
+  dataset: [],
+  xColumn: null,
+  type: "line",
+  yColumns: [],
+  axis: "left",
+  ...over,
+})
+
+// 800px container, 24 + 36 grid padding, 48px of y-axis labels: 692px plot.
+const CONTAINER_PX = 800
+const PLOT_PX = 692
+const WIDE_CONTAINER_PX = 1600
+
+// The most marks the plot can show at the readable floor, per mark type.
+const readableSlots = (fillRatio: number, minPx: number) =>
+  Math.floor((PLOT_PX * fillRatio) / minPx)
+const singleBarFill = 0.8
+const threeBarFill = 0.8 / (1.2 * 3 - 0.2)
+const candleFill = 0.5
+
+const rows = (count: number, valuesPerRow: number): number[][] =>
+  Array.from({ length: count }, (_, i) => [
+    i * 60_000,
+    ...Array.from({ length: valuesPerRow }, (_, j) => i + j),
+  ])
+
+const bars = (count: number, seriesCount: number) => {
+  const yColumns = Array.from({ length: seriesCount }, (_, j) => `y${j}`)
+  return buildEchartsOption({ xColumn: "ts" }, [
+    resolved({
+      columns: [
+        col("ts", "TIMESTAMP"),
+        ...yColumns.map((y) => col(y, "DOUBLE")),
+      ],
+      dataset: rows(count, seriesCount),
+      xColumn: "ts",
+      type: "bar",
+      yColumns,
+    }),
+  ])
+}
+
+const candles = (count: number) =>
+  buildEchartsOption({ xColumn: "ts" }, [
+    resolved({
+      columns: [
+        col("ts", "TIMESTAMP"),
+        col("open", "DOUBLE"),
+        col("high", "DOUBLE"),
+        col("low", "DOUBLE"),
+        col("close", "DOUBLE"),
+      ],
+      dataset: rows(count, 4),
+      xColumn: "ts",
+      type: "candlestick",
+      yColumns: [],
+      ohlc: { open: "open", high: "high", low: "low", close: "close" },
+    }),
+  ])
+
+const line = (count: number) =>
+  buildEchartsOption({ xColumn: "ts" }, [
+    resolved({
+      columns: [col("ts", "TIMESTAMP"), col("v", "DOUBLE")],
+      dataset: rows(count, 1),
+      xColumn: "ts",
+      type: "line",
+      yColumns: ["v"],
+    }),
+  ])
+
+describe("needsZoomSlider", () => {
+  it("asks for a slider only once single-series bars fall under the readable width", () => {
+    // Given the most single bars the plot can show at the floor
+    const limit = readableSlots(singleBarFill, MIN_MARK_PX)
+    // Then that many need no slider and one more does
+    expect(needsZoomSlider(bars(limit, 1), CONTAINER_PX)).toBe(false)
+    expect(needsZoomSlider(bars(limit + 1, 1), CONTAINER_PX)).toBe(true)
+    // And the same bars in a container twice as wide are readable again
+    expect(needsZoomSlider(bars(limit + 1, 1), WIDE_CONTAINER_PX)).toBe(false)
+  })
+
+  it("counts grouped bar series against the same band", () => {
+    // Given three series sharing every band
+    const limit = readableSlots(threeBarFill, MIN_MARK_PX)
+    // Then the band count that keeps a column readable is a third of the single-series one
+    expect(limit).toBeLessThan(readableSlots(singleBarFill, MIN_MARK_PX) / 3)
+    expect(needsZoomSlider(bars(limit, 3), CONTAINER_PX)).toBe(false)
+    expect(needsZoomSlider(bars(limit + 1, 3), CONTAINER_PX)).toBe(true)
+  })
+
+  it("uses the half-band candle body as the readable mark", () => {
+    // Given the most candles whose bodies stay at the floor
+    const limit = readableSlots(candleFill, MIN_MARK_PX)
+    // Then that many need no slider and one more does
+    expect(needsZoomSlider(candles(limit), CONTAINER_PX)).toBe(false)
+    expect(needsZoomSlider(candles(limit + 1), CONTAINER_PX)).toBe(true)
+  })
+
+  it("asks for a slider on a line only once points outnumber pixels", () => {
+    // Given a point per readable pixel
+    const limit = readableSlots(1, MIN_POINT_PX)
+    // Then that many need no slider and one more does
+    expect(needsZoomSlider(line(limit), CONTAINER_PX)).toBe(false)
+    expect(needsZoomSlider(line(limit + 1), CONTAINER_PX)).toBe(true)
+  })
+
+  it("never asks for a slider before the container is measured", () => {
+    expect(needsZoomSlider(line(5000), 0)).toBe(false)
+  })
+
+  it("uses the exact width instead of rounding a narrow chart up", () => {
+    expect(needsZoomSlider(bars(35, 1), 351)).toBe(true)
+    expect(needsZoomSlider(bars(35, 1), 400)).toBe(false)
+  })
+})
+
+describe("needsWheelZoom", () => {
+  it("arms the wheel at the headroom multiple of the readable floor", () => {
+    // Given the most single bars that stay at the wheel threshold (3× the floor)
+    const limit = readableSlots(
+      singleBarFill,
+      MIN_MARK_PX * WHEEL_ZOOM_HEADROOM,
+    )
+    // Then that many need no wheel and one more does
+    expect(needsWheelZoom(bars(limit, 1), CONTAINER_PX)).toBe(false)
+    expect(needsWheelZoom(bars(limit + 1, 1), CONTAINER_PX)).toBe(true)
+  })
+
+  it("offers the wheel without the slider while marks are tight but readable", () => {
+    // Given a line denser than the wheel threshold but sparser than the floor
+    const points = Math.floor(PLOT_PX / 2)
+    // Then the invisible wheel zoom arms while the space-costing slider waits
+    expect(needsWheelZoom(line(points), CONTAINER_PX)).toBe(true)
+    expect(needsZoomSlider(line(points), CONTAINER_PX)).toBe(false)
+  })
+})
+
+type ZoomComponents = [
+  { type: string; disabled: boolean },
+  { type: string; show: boolean },
+]
+
+describe("withZoomSlider", () => {
+  it("embeds both zoom components inert on a sparse chart", () => {
+    // Given a sparse chart
+    const option = withZoomSlider(bars(15, 1), CONTAINER_PX)
+    // Then the components exist but neither is active, so density changes can
+    // never alter the option's structure, and the grid keeps its margin
+    const [inside, slider] = option.dataZoom as ZoomComponents
+    expect(inside).toMatchObject({ type: "inside", disabled: true })
+    expect(slider).toMatchObject({ type: "slider", show: false })
+    expect((option.grid as { bottom: number }).bottom).toBe(56)
+  })
+
+  it("activates the wheel alone on a tight chart", () => {
+    const option = withZoomSlider(line(Math.floor(PLOT_PX / 2)), CONTAINER_PX)
+
+    const [inside, slider] = option.dataZoom as ZoomComponents
+    expect(inside).toMatchObject({ disabled: false })
+    expect(slider).toMatchObject({ show: false })
+    expect((option.grid as { bottom: number }).bottom).toBe(56)
+  })
+
+  it("activates the wheel and the slider together on a dense chart", () => {
+    // Given a dense chart
+    const option = withZoomSlider(line(PLOT_PX * 2), CONTAINER_PX)
+    // Then both zooms are active and the grid grows at the bottom
+    const [inside, slider] = option.dataZoom as ZoomComponents
+    expect(inside).toMatchObject({ type: "inside", disabled: false })
+    expect(slider).toMatchObject({ type: "slider", show: true })
+    expect((option.grid as { bottom: number }).bottom).toBe(86)
+  })
+
+  it("leaves an axis-less chart without zoom components", () => {
+    // Given a pie option (no xAxis to zoom)
+    const option = withZoomSlider({ series: [{ type: "pie" }] }, CONTAINER_PX)
+
+    expect(option.dataZoom).toBeUndefined()
+  })
+})
diff --git a/src/scenes/Editor/Notebook/CellChart/chartDensity.ts b/src/scenes/Editor/Notebook/CellChart/chartDensity.ts
new file mode 100644
index 000000000..aa2ca4519
--- /dev/null
+++ b/src/scenes/Editor/Notebook/CellChart/chartDensity.ts
@@ -0,0 +1,103 @@
+import type { EChartsOption } from "echarts"
+
+// A bar or candle body narrower than this reads as a line, not a shape.
+export const MIN_MARK_PX = 6
+// Lines and scatter downsample to the pixel grid, so detail is lost only once
+// points outnumber pixels.
+export const MIN_POINT_PX = 1
+const Y_AXIS_LABEL_WIDTH_PX = 48
+// ECharts keeps 20% of a band as the category gap and 20% of a bar between
+// grouped columns, so one column is 0.8 / (1.2k - 0.2) of its band. A candle
+// body is half its band.
+const CANDLE_FILL_RATIO = 0.5
+
+type SeriesSpec = { type?: string; stack?: string; data?: unknown[] }
+
+const seriesOf = (option: EChartsOption): SeriesSpec[] => {
+  const raw = option.series
+  return (Array.isArray(raw) ? raw : raw ? [raw] : []) as SeriesSpec[]
+}
+
+const firstOf = <T>(value: T | T[] | undefined): T | undefined =>
+  Array.isArray(value) ? value[0] : value
+
+const dataLength = (series: SeriesSpec): number =>
+  Array.isArray(series.data) ? series.data.length : 0
+
+const maxDataLength = (list: SeriesSpec[]): number =>
+  list.reduce((max, series) => Math.max(max, dataLength(series)), 0)
+
+const barFillRatio = (columns: number): number => 0.8 / (1.2 * columns - 0.2)
+
+const barColumns = (bars: SeriesSpec[]): number => {
+  const stacks = new Set(bars.map((s) => s.stack).filter(Boolean))
+  return bars.filter((s) => !s.stack).length + stacks.size
+}
+
+const plotWidthOf = (
+  option: EChartsOption,
+  containerWidthPx: number,
+): number => {
+  const grid = firstOf(option.grid) as
+    | { left?: number; right?: number }
+    | undefined
+  const yAxisCount = Array.isArray(option.yAxis) ? option.yAxis.length : 1
+  return (
+    containerWidthPx -
+    (grid?.left ?? 0) -
+    (grid?.right ?? 0) -
+    Y_AXIS_LABEL_WIDTH_PX * yAxisCount
+  )
+}
+
+// Wheel zoom arms while marks are merely tight — this many times the readable
+// floor — since it costs no plot space; the slider waits for the floor itself.
+export const WHEEL_ZOOM_HEADROOM = 3
+
+export type ChartZoomDensity = {
+  slider: boolean
+  wheel: boolean
+}
+
+export const chartZoomDensity = (
+  option: EChartsOption,
+  containerWidthPx: number,
+): ChartZoomDensity => {
+  const plotWidth = plotWidthOf(option, containerWidthPx)
+  if (plotWidth <= 0) return { slider: false, wheel: false }
+
+  const series = seriesOf(option)
+  const bars = series.filter((s) => s.type === "bar")
+  const candles = series.filter((s) => s.type === "candlestick")
+  const points = series.filter((s) => s.type === "line" || s.type === "scatter")
+  const xAxis = firstOf(option.xAxis) as { data?: unknown[] } | undefined
+  const categorySlots = Array.isArray(xAxis?.data) ? xAxis.data.length : 0
+  const bandSlots = (list: SeriesSpec[]) =>
+    Math.max(categorySlots, maxDataLength(list))
+
+  const density = { slider: false, wheel: false }
+  const include = (slots: number, fillRatio: number, minPx: number) => {
+    if (slots <= 0) return
+    const markPx = (plotWidth / slots) * fillRatio
+    density.slider ||= markPx < minPx
+    density.wheel ||= markPx < minPx * WHEEL_ZOOM_HEADROOM
+  }
+  if (bars.length > 0) {
+    include(bandSlots(bars), barFillRatio(barColumns(bars)), MIN_MARK_PX)
+  }
+  if (candles.length > 0) {
+    include(bandSlots(candles), CANDLE_FILL_RATIO, MIN_MARK_PX)
+  }
+  include(maxDataLength(points), 1, MIN_POINT_PX)
+  return density
+}
+
+export const needsZoomSlider = (
+  option: EChartsOption,
+  containerWidthPx: number,
+): boolean => chartZoomDensity(option, containerWidthPx).slider
+
+export const needsWheelZoom = (
+  option: EChartsOption,
+  containerWidthPx: number,
+): boolean => chartZoomDensity(option, containerWidthPx).wheel
diff --git a/src/scenes/Editor/Notebook/DrawCanvas/drawCanvasUtils.test.ts b/src/scenes/Editor/Notebook/DrawCanvas/drawCanvasUtils.test.ts
index fc05af3c3..163929c3d 100644
--- a/src/scenes/Editor/Notebook/DrawCanvas/drawCanvasUtils.test.ts
+++ b/src/scenes/Editor/Notebook/DrawCanvas/drawCanvasUtils.test.ts
@@ -95,6 +95,12 @@ describe("resultsEquivalent", () => {
     expect(resultsEquivalent(a, b)).toBe(true)
   })
 
+  it("ignores internal whitespace and keyword casing", () => {
+    const a = [dql([{ name: "x", type: "INT" }], [[1]], "select  1\nas x")]
+    const b = [dql([{ name: "x", type: "INT" }], [[1]], "SELECT 1 AS x")]
+    expect(resultsEquivalent(a, b)).toBe(true)
+  })
+
   it("returns false when result counts differ", () => {
     const a = dql([{ name: "x", type: "INT" }], [[1]])
     const b = { ...a, count: 2 }
@@ -246,6 +252,15 @@ describe("resultMatchesQueries", () => {
     ).toBe(true)
   })
 
+  it("matches across internal whitespace and keyword casing", () => {
+    // Given a result produced by the statement in one presentation
+    // When the cell now carries the same statement reformatted
+    // Then it still matches — a presentation-only edit never re-fetches
+    expect(
+      resultMatchesQueries(cellResult(["select  1\nas x"]), ["SELECT 1 AS x"]),
+    ).toBe(true)
+  })
+
   it("rejects on statement-count mismatch", () => {
     // Given a single-statement result
     const result = cellResult(["select a"])
diff --git a/src/scenes/Editor/Notebook/DrawCanvas/drawCanvasUtils.ts b/src/scenes/Editor/Notebook/DrawCanvas/drawCanvasUtils.ts
index d8eb35ec9..6bf3ac497 100644
--- a/src/scenes/Editor/Notebook/DrawCanvas/drawCanvasUtils.ts
+++ b/src/scenes/Editor/Notebook/DrawCanvas/drawCanvasUtils.ts
@@ -1,8 +1,7 @@
 import type { QueryExecResult } from "../../../../hooks/useQueryExecution"
 import type { CellResult, SingleQueryResult } from "../../../../store/notebook"
 import type { ColumnDefinition } from "../../../../utils/questdb/types"
-import { hasPendingResult } from "../notebookUtils"
-import { normalizeQueryText } from "../../Monaco/utils"
+import { hasPendingResult, normalizeStatementIdentity } from "../notebookUtils"
 import type { ChartConfig, QueryChart } from "../CellChart/chartTypes"
 import type {
   ChartGlobals,
@@ -73,7 +72,8 @@ export const resultMatchesQueries = (
   result.results.every(
     (r, i) =>
       !(r.type === "dql" && r.truncated) &&
-      normalizeQueryText(r.query) === normalizeQueryText(queries[i]),
+      normalizeStatementIdentity(r.query) ===
+        normalizeStatementIdentity(queries[i]),
   )
 
 export type ChartResult =
@@ -110,11 +110,15 @@ export const resultsEquivalent = (
   for (let i = 0; i < a.length; i++) {
     const x = a[i]
     const y = b[i]
-    // Query identity is the primary discriminator. Formatting differences
-    // introduced by parsing (surrounding whitespace / trailing semicolon) do
-    // not make a new result, but different SQL must always replace the prior
-    // frame even when it happens to return identical rows.
-    if (normalizeQueryText(x.query) !== normalizeQueryText(y.query)) {
+    // Query identity is the primary discriminator. Presentation-only edits
+    // (whitespace, newlines, keyword casing) do not make a new result, but
+    // different SQL must always replace the prior frame even when it happens
+    // to return identical rows.
+    if (
+      x.query !== y.query &&
+      normalizeStatementIdentity(x.query) !==
+        normalizeStatementIdentity(y.query)
+    ) {
       return false
     }
     if (x.type !== y.type) return false
diff --git a/src/scenes/Editor/Notebook/DrawCanvas/index.tsx b/src/scenes/Editor/Notebook/DrawCanvas/index.tsx
index d4a6dc761..ed2b4d77e 100644
--- a/src/scenes/Editor/Notebook/DrawCanvas/index.tsx
+++ b/src/scenes/Editor/Notebook/DrawCanvas/index.tsx
@@ -10,6 +10,7 @@ import {
 } from "../CellChart/ChartRenderer"
 import { ChartSettingsDrawer } from "../CellChart/ChartSettingsDrawer"
 import { resolveDraw, toChartResult } from "./drawCanvasUtils"
+import { Button } from "../../../../components/Button"
 import { toast } from "../../../../components/Toast"
 import { CircleNotchSpinner } from "../../Monaco/icons"
 import { eventBus } from "../../../../modules/EventBus"
@@ -74,6 +75,11 @@ const EmptyState = styled.div`
   font-size: ${({ theme }) => theme.fontSize.sm};
 `
 
+const CancelledState = styled(EmptyState)`
+  flex-direction: column;
+  gap: 1rem;
+`
+
 // Announces loading/empty transitions. Stays mounted with only its text
 // changing — inserting an already-populated live region announces
 // inconsistently across screen readers.
@@ -149,6 +155,11 @@ export const DrawCanvas: React.FC<Props> = ({
     setSettingsOpen(true)
   }, [cell.chartConfig])
 
+  const handleRetry = () => {
+    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_DRAW)
+    eventBus.publish(EventType.NOTEBOOK_CELL_REFRESH_CHART, { cellId: cell.id })
+  }
+
   const option = useMemo(
     () => buildEchartsOption(resolution.chart, resolution.renderQueries),
     [resolution],
@@ -164,6 +175,7 @@ export const DrawCanvas: React.FC<Props> = ({
     chartResult,
     resultStatus === "loading",
   )
+  const cancelled = state.fetchCancelled && results.length === 0 && !loading
   let emptyMessage: string
   if (classifyBlock?.kind === "write") {
     emptyMessage = `Cannot draw a write query ('${classifyBlock.queryType}'). Switch to Run mode to execute this SQL.`
@@ -207,16 +219,34 @@ export const DrawCanvas: React.FC<Props> = ({
   return (
     <Wrapper>
       <VisuallyHiddenStatus role="status">
-        {loading ? "Loading chart data" : empty ? emptyMessage : ""}
+        {loading
+          ? "Loading chart data"
+          : cancelled
+            ? "Chart loading was cancelled"
+            : empty
+              ? emptyMessage
+              : ""}
       </VisuallyHiddenStatus>
       {loading ? (
         <EmptyState aria-hidden="true">
           <CircleNotchSpinner size={24} />
         </EmptyState>
+      ) : cancelled ? (
+        <CancelledState data-hook="draw-canvas-cancelled">
+          <span aria-hidden="true">Chart loading was cancelled.</span>
+          <Button
+            variant="secondary"
+            size="sm"
+            onClick={handleRetry}
+            dataHook="draw-canvas-retry"
+          >
+            Retry
+          </Button>
+        </CancelledState>
       ) : empty ? (
         <EmptyState aria-hidden="true">{emptyMessage}</EmptyState>
       ) : (
-        <Canvas>
+        <Canvas data-hook="draw-canvas">
           <ChartRenderer
             ref={chartRendererRef}
             option={option}
diff --git a/src/scenes/Editor/Notebook/NotebookProvider.tsx b/src/scenes/Editor/Notebook/NotebookProvider.tsx
index 7ef84f11c..951137131 100644
--- a/src/scenes/Editor/Notebook/NotebookProvider.tsx
+++ b/src/scenes/Editor/Notebook/NotebookProvider.tsx
@@ -12,6 +12,7 @@ import { unstable_batchedUpdates } from "react-dom"
 import { useEditor } from "../../../providers/EditorProvider"
 import { QuestContext } from "../../../providers/QuestProvider"
 import type {
+  CellPaneView,
   CellResult,
   NotebookCell,
   NotebookVariable,
@@ -24,6 +25,7 @@ import type { ChartConfig } from "./CellChart/chartTypes"
 import { useQueryExecution } from "../../../hooks/useQueryExecution"
 import { useCellsStore } from "./useCellsStore"
 import { useCellExecution } from "./useCellExecution"
+import type { DrawGateOutcome } from "./useCellExecution"
 import { useNotebookPersistence } from "./useNotebookPersistence"
 import {
   addCellTransition,
@@ -35,7 +37,7 @@ import {
   registerController,
   setCellMaximizedTransition,
   setCellModeTransition,
-  setCellViewMaximizedTransition,
+  setCellPaneViewTransition,
   unregisterController,
   type NotebookControllerActions,
   type NotebookTransitionResult,
@@ -46,10 +48,12 @@ import {
   clearCellAutoRefresh,
   computeResultBottomHeight,
   countAutoRefreshOverrides,
+  discardCellResult,
   generateId,
   releaseCellResultPatch,
   snapshotResultsMatchQueries,
   statementKeysFor,
+  type RunCancelReason,
 } from "./notebookUtils"
 import type { RunCellGate } from "../../../utils/tools/permissions"
 import { signalUserEdit } from "../../../utils/notebooks/notebookAIBridge"
@@ -57,6 +61,11 @@ import { trackEvent } from "../../../modules/ConsoleEventTracker"
 import { ConsoleEvent } from "../../../modules/ConsoleEventTracker/events"
 import { getQueriesFromText } from "../Monaco/utils"
 import { silently } from "../../../utils/notebooks/notebookToolError"
+import {
+  dropSnapshotsAfterPersist,
+  droppedSnapshotCellIds,
+  persistFailure,
+} from "../../../utils/notebooks/notebookSnapshotCleanup"
 import type { AutoRefresh } from "../../../store/notebook"
 import {
   copyNotebookSnapshots,
@@ -118,6 +127,7 @@ export type NotebookActions = {
     expectFullValue?: boolean,
     gate?: RunCellGate,
   ) => Promise<CellRunOutcome>
+  validateForDraw: (cellId: string) => Promise<DrawGateOutcome>
   reRunResultAt: (cellId: string, index: number) => Promise<boolean>
   cancelCell: (cellId: string) => void
   cancelQuery: (cellId: string, index: number) => void
@@ -128,7 +138,7 @@ export type NotebookActions = {
   setCellRefresh: (cellId: string, value: AutoRefresh | undefined) => void
   resetAutoRefreshOverrides: () => void
   refreshAllCells: () => { refreshed: number; skippedWrites: number }
-  setCellViewMaximized: (cellId: string, value: boolean) => void
+  setCellPaneView: (cellId: string, view: CellPaneView) => void
   setFocusedCell: (cellId: string | null) => void
   setMaximizedCellId: (cellId: string | null) => void
   getCellsSnapshot: () => NotebookCell[]
@@ -148,6 +158,7 @@ const NOOP_ACTIONS: NotebookActions = {
   moveCellDown: () => undefined,
   duplicateCell: () => Promise.resolve(""),
   runCell: () => Promise.resolve({ ok: false, superseded: false }),
+  validateForDraw: () => Promise.resolve({ granted: false }),
   reRunResultAt: () => Promise.resolve(false),
   cancelCell: () => undefined,
   cancelQuery: () => undefined,
@@ -158,7 +169,7 @@ const NOOP_ACTIONS: NotebookActions = {
   setCellRefresh: () => undefined,
   resetAutoRefreshOverrides: () => undefined,
   refreshAllCells: () => ({ refreshed: 0, skippedWrites: 0 }),
-  setCellViewMaximized: () => undefined,
+  setCellPaneView: () => undefined,
   setFocusedCell: () => undefined,
   setMaximizedCellId: () => undefined,
   getCellsSnapshot: () => [],
@@ -169,14 +180,17 @@ const NOOP_LIVE_ACTIONS: LiveNotebookActions = {
   getSettings: () => ({}),
   getMaximizedCellId: () => null,
   readRefreshState: () => new Map(),
+  readResultStatus: () => "unrequested",
   flushChartSnapshots: () => Promise.resolve(),
   applyTransition: (run) =>
-    run({
-      cells: [],
-      settings: {},
-      maximizedCellId: null,
-      focusedCellId: null,
-    }).result,
+    Promise.resolve(
+      run({
+        cells: [],
+        settings: {},
+        maximizedCellId: null,
+        focusedCellId: null,
+      }).result,
+    ),
 }
 
 const NOTEBOOK_ACTION_KEYS = Object.keys(NOOP_ACTIONS) as Array<
@@ -387,7 +401,7 @@ export const NotebookProvider: React.FC<{
       const next = { ...settingsRef.current, ...updates }
       settingsRef.current = next
       setSettingsState(next)
-      persistImmediately(store.cellsRef.current)
+      void persistImmediately(store.cellsRef.current)
     },
     [persistImmediately, store.cellsRef],
   )
@@ -407,23 +421,25 @@ export const NotebookProvider: React.FC<{
   )
 
   const cancelCell = useCallback(
-    (cellId: string) => {
-      execution.cancelCell(cellId)
+    (cellId: string, reason?: RunCancelReason) => {
+      execution.cancelCell(cellId, reason)
       releaseCellExecution(cellId)
     },
     [execution, releaseCellExecution],
   )
 
   const abortCellRun = useCallback(
-    (cellId: string) => {
-      execution.abortCellRun(cellId)
+    (cellId: string, reason: RunCancelReason) => {
+      execution.abortCellRun(cellId, reason)
       releaseCellExecution(cellId)
     },
     [execution, releaseCellExecution],
   )
 
-  const applyTransition = useCallback(
-    <T,>(run: (parts: ViewParts) => NotebookTransitionResult<T>): T => {
+  const commitTransition = useCallback(
+    <T,>(
+      run: (parts: ViewParts) => NotebookTransitionResult<T>,
+    ): { result: T; persisted: Promise<void> } => {
       const out = run({
         cells: store.cellsRef.current,
         settings: settingsRef.current,
@@ -442,39 +458,69 @@ export const NotebookProvider: React.FC<{
         setMaximizedCellIdState(parts.maximizedCellId)
         setFocusedCellState(parts.focusedCellId)
       })
-      persistImmediately(parts.cells, true)
-      // A deleted cell's in-flight run must be cancelled; the transition reports
-      // deleted cells via cleanup, so every delete route (UI or agent) cancels
-      // here rather than at each call site.
+      const persisted = persistImmediately(parts.cells, true)
+      // A deleted cell's in-flight run is discarded, not cancelled: superseding
+      // it makes a late completion report the deletion instead of a cleared
+      // result. The transition reports deleted cells via cleanup, so every
+      // delete route (UI or agent) lands here rather than at each call site.
       if (out.cleanup) {
         for (const cellId of out.cleanup.cellIds) {
-          cancelCell(cellId)
-          void deleteCellSnapshot(bufferId, cellId)
+          abortCellRun(cellId, "cell_deleted")
           removeNotebookCellLayouts(bufferId, cellId)
           clearChartZoom(cellId)
         }
       }
-      // For run->draw transitions, abort the in-flight run
       if (out.cancelRuns) {
-        for (const cellId of out.cancelRuns.cellIds) abortCellRun(cellId)
+        for (const cellId of out.cancelRuns.cellIds) {
+          abortCellRun(cellId, out.cancelRuns.reason)
+        }
       }
       // noteMissing collapses the cell's reserved result area immediately
       if (out.deleteSnapshots) {
         for (const cellId of out.deleteSnapshots.cellIds) {
-          void deleteCellSnapshot(bufferId, cellId)
           resultHydration.noteMissing(cellId)
         }
       }
-      return out.result
+      // Snapshot rows outlive a failed document write: the stored document
+      // still references them, so they go only once the new one is durable.
+      void dropSnapshotsAfterPersist(
+        persisted,
+        droppedSnapshotCellIds(out),
+        (cellId) => deleteCellSnapshot(bufferId, cellId),
+      )
+      return { result: out.result, persisted }
     },
-    [
-      store,
-      persistImmediately,
-      bufferId,
-      cancelCell,
-      abortCellRun,
-      resultHydration,
-    ],
+    [store, persistImmediately, bufferId, abortCellRun, resultHydration],
+  )
+
+  // A gesture sees its transition land at once; a failed document write only
+  // reaches the console, as with every other gesture-driven persist.
+  const applyTransition = useCallback(
+    <T,>(run: (parts: ViewParts) => NotebookTransitionResult<T>): T => {
+      const { result, persisted } = commitTransition(run)
+      persisted.catch((error) =>
+        console.warn(`notebook ${bufferId}: document write failed`, error),
+      )
+      return result
+    },
+    [commitTransition, bufferId],
+  )
+
+  // The agent route reports success only once the document is durable, and a
+  // failed write as a typed error the agent can act on.
+  const applyTransitionPersisted = useCallback(
+    <T,>(
+      run: (parts: ViewParts) => NotebookTransitionResult<T>,
+    ): Promise<T> => {
+      const { result, persisted } = commitTransition(run)
+      return persisted.then(
+        () => result,
+        (error) => {
+          throw persistFailure(error)
+        },
+      )
+    },
+    [commitTransition],
   )
 
   const setMaximizedCellId = useCallback(
@@ -517,12 +563,11 @@ export const NotebookProvider: React.FC<{
   // doesn't rehydrate on the next load.
   const clearCellResult = useCallback(
     (cellId: string) => {
-      const cell = store.cellsRef.current.find((c) => c.id === cellId)
-      store.updateCell(cellId, {
-        result: undefined,
-        lastRunStatus: undefined,
-        ...(cell?.bottomResized ? {} : { bottomHeight: undefined }),
-      })
+      store.updateCells((cells) =>
+        cells.map((cell) =>
+          cell.id === cellId ? discardCellResult(cell) : cell,
+        ),
+      )
       resultHydration.forget(cellId)
       void deleteCellSnapshot(bufferId, cellId)
     },
@@ -767,11 +812,11 @@ export const NotebookProvider: React.FC<{
     [applyTransition, bufferId],
   )
 
-  const setCellViewMaximized = useCallback(
-    (cellId: string, value: boolean) =>
+  const setCellPaneView = useCallback(
+    (cellId: string, view: CellPaneView) =>
       silently(() =>
         applyTransition((parts) =>
-          setCellViewMaximizedTransition(parts, bufferId, cellId, value),
+          setCellPaneViewTransition(parts, bufferId, cellId, view),
         ),
       ),
     [applyTransition, bufferId],
@@ -797,6 +842,7 @@ export const NotebookProvider: React.FC<{
     moveCellDown,
     duplicateCell,
     runCell,
+    validateForDraw: execution.validateForDraw,
     reRunResultAt: (cellId, index) => {
       // A per-tab rerun is a manual run: it cancels the refresh round, and
       // any COMMIT clears that statement's refresh error — a committed error
@@ -828,15 +874,16 @@ export const NotebookProvider: React.FC<{
     setCellRefresh: store.setCellRefresh,
     resetAutoRefreshOverrides,
     refreshAllCells: () => cellRefreshEngine.refreshAll(),
-    setCellViewMaximized,
+    setCellPaneView,
     setFocusedCell,
     setMaximizedCellId,
     getCellsSnapshot: () => store.cellsRef.current.slice(),
     getSettings: () => ({ ...settingsRef.current }),
     getMaximizedCellId: () => maximizedCellIdRef.current,
     readRefreshState: () => cellRefreshEngine.readRefreshState(),
+    readResultStatus: (cellId) => resultHydration.statusOf(cellId),
     flushChartSnapshots: () => cellRefreshEngine.flushPendingSnapshots(),
-    applyTransition,
+    applyTransition: applyTransitionPersisted,
   }
 
   const stateValue = useMemo<NotebookState>(
diff --git a/src/scenes/Editor/Notebook/cellRefresh/cellRefreshEngine.test.ts b/src/scenes/Editor/Notebook/cellRefresh/cellRefreshEngine.test.ts
index 92b2575c5..d4b20e21c 100644
--- a/src/scenes/Editor/Notebook/cellRefresh/cellRefreshEngine.test.ts
+++ b/src/scenes/Editor/Notebook/cellRefresh/cellRefreshEngine.test.ts
@@ -14,6 +14,7 @@ import type { CellResultStatus } from "../resultHydration/cellResultHydration"
 import {
   CellRefreshEngine,
   deriveChartLoading,
+  pendingCellFetchState,
   type CellRefreshDeps,
 } from "./cellRefreshEngine"
 import { createRequestLimiter } from "../../../../utils/questdb/requestLimiter"
@@ -82,7 +83,9 @@ const makeDeps = () => {
   const loadStatuses = new Map<string, CellResultStatus>()
   const loadListeners = new Map<string, Set<() => void>>()
   const deps = {
-    executeSingle: vi.fn((sql: string) => Promise.resolve(dqlResult(sql))),
+    executeSingle: vi.fn((sql: string, _signal?: AbortSignal) =>
+      Promise.resolve(dqlResult(sql)),
+    ),
     validateWithGlobals: vi.fn().mockResolvedValue(dqlValidation),
     setCellResult: vi.fn((cellId: string, result: CellResult | undefined) => {
       cellResults.set(cellId, result)
@@ -519,7 +522,7 @@ describe("CellRefreshEngine", () => {
       expect(persistCellSnapshot).toHaveBeenCalledTimes(1)
 
       // When the user switches the cell back to run mode
-      engine.sync([{ ...drawCell("c1", "select 1", "1s"), mode: "run" }])
+      engine.sync([{ ...drawCell("c1", "select 1", "1s"), mode: undefined }])
       await vi.advanceTimersByTimeAsync(15_000)
 
       // Then the blocked frame never persists — saving it would resurrect the
@@ -584,6 +587,121 @@ describe("CellRefreshEngine", () => {
     })
   })
 
+  describe("stopping the first chart fetch", () => {
+    // Like the real client, the fake rejects once its signal aborts.
+    const deferFetch = () => {
+      let resolveFetch: () => void = () => {}
+      deps.executeSingle = vi.fn(
+        (sql: string, signal?: AbortSignal) =>
+          new Promise<QueryExecResult>((resolve, reject) => {
+            resolveFetch = () => resolve(dqlResult(sql))
+            signal?.addEventListener(
+              "abort",
+              () => reject(new Error("aborted")),
+              { once: true },
+            )
+          }),
+      )
+      return () => resolveFetch()
+    }
+
+    it("aborts the round, settles the canvas as cancelled, and discards the late response", async () => {
+      // Given a draw cell whose first fetch is still in flight
+      const resolveFetch = deferFetch()
+      syncOnScreen([drawCell("c1", "select 1", false)])
+      await flushAsync()
+      expect(engine.getState("c1")?.fetching).toBe(true)
+
+      // When the user stops the fetch
+      engine.cancelChartFetch("c1")
+
+      // Then the round is over and the chart no longer reads as loading
+      const state = engine.getState("c1")!
+      expect(state.fetching).toBe(false)
+      expect(state.fetchCancelled).toBe(true)
+      expect(deriveChartLoading(state, { kind: "missing" }, false)).toEqual({
+        loading: false,
+        refreshing: false,
+      })
+
+      // And the aborted response never lands
+      resolveFetch()
+      await flushAsync()
+      expect(deps.setCellResult).not.toHaveBeenCalled()
+    })
+
+    it("a retry clears the cancelled marker and fetches again", async () => {
+      // Given a stopped first fetch
+      const resolveFetch = deferFetch()
+      syncOnScreen([drawCell("c1", "select 1", false)])
+      await flushAsync()
+      engine.cancelChartFetch("c1")
+
+      // When the user retries
+      void engine.refresh("c1")
+      await flushAsync()
+
+      // Then a fresh round is in flight without the marker
+      expect(deps.executeSingle).toHaveBeenCalledTimes(2)
+      expect(engine.getState("c1")?.fetchCancelled).toBe(false)
+      expect(engine.getState("c1")?.fetching).toBe(true)
+
+      // And its response settles the chart
+      resolveFetch()
+      await flushAsync()
+      expect(deps.setCellResult).toHaveBeenCalledTimes(1)
+      const state = engine.getState("c1")!
+      expect(state.settledKey).toBe(state.queriesKey)
+    })
+
+    it("the next auto-refresh tick fetches again after a stop", async () => {
+      // Given a polling draw cell whose first fetch was stopped
+      deferFetch()
+      syncOnScreen([drawCell("c1", "select 1", "1s")])
+      await flushAsync()
+      engine.cancelChartFetch("c1")
+
+      // When the poll interval elapses
+      await vi.advanceTimersByTimeAsync(1000)
+
+      // Then the marker is gone and a new round is in flight
+      expect(deps.executeSingle).toHaveBeenCalledTimes(2)
+      expect(engine.getState("c1")?.fetchCancelled).toBe(false)
+      expect(engine.getState("c1")?.fetching).toBe(true)
+    })
+
+    it("is a no-op once the round has settled", async () => {
+      // Given a draw cell whose first fetch already landed
+      syncOnScreen([drawCell("c1", "select 1", false)])
+      await flushAsync()
+      expect(deps.setCellResult).toHaveBeenCalledTimes(1)
+
+      // When a stale stop arrives
+      engine.cancelChartFetch("c1")
+
+      // Then the settled frame is untouched
+      const state = engine.getState("c1")!
+      expect(state.fetchCancelled).toBe(false)
+      expect(state.settledKey).toBe(state.queriesKey)
+    })
+
+    it("a snapshot load still shows loading over a cancelled marker", () => {
+      // Given a cancelled state whose result snapshot is hydrating
+      const state = {
+        ...pendingCellFetchState("select 1"),
+        fetchCancelled: true,
+      }
+
+      // Then hydration wins until the snapshot settles
+      expect(deriveChartLoading(state, { kind: "missing" }, true).loading).toBe(
+        true,
+      )
+      expect(
+        deriveChartLoading(state, { kind: "missing" }, false).loading,
+      ).toBe(false)
+    })
+  })
+
   describe("settling from existing data", () => {
     it("settles on a matching cell result with rows instead of fetching", async () => {
       // Given a cell result produced by the exact same query (grid → chart)
@@ -841,7 +959,7 @@ describe("CellRefreshEngine", () => {
 
     // When the user switches to the grid and back — the cell never leaves the
     // viewport, so the visibility observer reports nothing new
-    engine.sync([{ ...drawCell("c1", "select 1", "1s"), mode: "run" }])
+    engine.sync([{ ...drawCell("c1", "select 1", "1s"), mode: undefined }])
     engine.sync([drawCell("c1", "select 1", "1s")])
     await flushAsync()
 
@@ -874,7 +992,7 @@ describe("CellRefreshEngine", () => {
     expect(deps.executeSingle).toHaveBeenCalledTimes(1)
 
     // When the cell is no longer in draw mode
-    engine.sync([{ ...drawCell("c1", "select 1", "1s"), mode: "run" }])
+    engine.sync([{ ...drawCell("c1", "select 1", "1s"), mode: undefined }])
 
     // Then no further fetches happen and the entry's state is gone
     await vi.advanceTimersByTimeAsync(10_000)
@@ -963,6 +1081,48 @@ describe("CellRefreshEngine", () => {
     expect(state?.settledKey).toBe(state?.queriesKey)
   })
 
+  it("keeps the frame and skips refetching when a statement only changes whitespace or casing", async () => {
+    // Given a settled draw cell showing results
+    syncOnScreen([drawCell("c1", "select 1 as x", false)])
+    await flushAsync()
+    expect(deps.executeSingle).toHaveBeenCalledTimes(1)
+    const frame = cellResults.get("c1")
+
+    // When the statement is reformatted without changing its SQL
+    engine.sync([drawCell("c1", "SELECT  1\nAS x", false)])
+    await vi.advanceTimersByTimeAsync(301)
+    await flushAsync()
+
+    // Then the displayed frame survives without a refetch
+    expect(deps.executeSingle).toHaveBeenCalledTimes(1)
+    expect(cellResults.get("c1")).toBe(frame)
+    const state = engine.getState("c1")
+    expect(state?.settledKey).toBe(state?.queriesKey)
+  })
+
+  it("executes only the edited statement when auto-refresh is off", async () => {
+    // Given a settled two-statement draw cell with auto-refresh off
+    syncOnScreen([drawCell("c1", "select 1;\nselect 2", false)])
+    await flushAsync()
+    expect(deps.executeSingle).toHaveBeenCalledTimes(2)
+
+    // When one statement changes
+    engine.sync([drawCell("c1", "select 1;\nselect 3", false)])
+    await vi.advanceTimersByTimeAsync(301)
+    await flushAsync()
+
+    // Then only the changed statement executes and the other keeps its result
+    expect(
+      deps.executeSingle.mock.calls.slice(2).map((call) => call[0]),
+    ).toEqual(["select 3"])
+    expect(cellResults.get("c1")?.results.map((r) => r.query)).toEqual([
+      "select 1",
+      "select 3",
+    ])
+    const state = engine.getState("c1")
+    expect(state?.settledKey).toBe(state?.queriesKey)
+  })
+
   it("never executes a query that fails validation, and blocks it once it resolves to a write", async () => {
     // Given a polling draw cell whose INSERT fails validation because its
     // target table does not exist yet (reachable via edit-in-draw or the
@@ -1274,6 +1434,7 @@ describe("CellRefreshEngine", () => {
       slotErrors: new Map<string, string>(),
       cancelledSlots: new Set<string>(),
       slotFetchedAt: new Map<string, number>(),
+      fetchCancelled: false,
     }
 
     // Then the recovery fetch after a failed restore shows the spinner
@@ -1847,7 +2008,7 @@ describe("CellRefreshEngine", () => {
       engine.refreshAll()
 
       // When the cell exits draw mode and returns while still hidden
-      engine.sync([{ ...drawCell("c1", "select 1", false), mode: "run" }])
+      engine.sync([{ ...drawCell("c1", "select 1", false), mode: undefined }])
       engine.sync([drawCell("c1", "select 1", false)])
       await flushAsync()
 
@@ -2099,7 +2260,7 @@ describe("CellRefreshEngine", () => {
     ): NotebookCell => {
       const result = gridFrame(queries)
       cellResults.set(id, result)
-      return { id, position: 0, value, mode: "run", autoRefresh, result }
+      return { id, position: 0, value, mode: undefined, autoRefresh, result }
     }
 
     const errorValidation = (sql: string, error: string) => ({
@@ -2286,7 +2447,7 @@ describe("CellRefreshEngine", () => {
         id: "g1",
         position: 0,
         value: "select 1",
-        mode: "run",
+        mode: undefined,
         autoRefresh: "1s",
       }
 
@@ -2305,7 +2466,7 @@ describe("CellRefreshEngine", () => {
         id: "g1",
         position: 0,
         value: "select 1",
-        mode: "run",
+        mode: undefined,
         autoRefresh: "1s",
         lastRunStatus: "success",
       }
@@ -2844,7 +3005,7 @@ describe("CellRefreshEngine", () => {
           id: "g1",
           position: 0,
           value: "select 1",
-          mode: "run",
+          mode: undefined,
           autoRefresh: false,
           lastRunStatus: "success",
         },
@@ -2900,7 +3061,7 @@ describe("CellRefreshEngine", () => {
           id: "g1",
           position: 0,
           value: "select 1",
-          mode: "run",
+          mode: undefined,
           autoRefresh: false,
           lastRunStatus: "success",
         },
diff --git a/src/scenes/Editor/Notebook/cellRefresh/cellRefreshEngine.ts b/src/scenes/Editor/Notebook/cellRefresh/cellRefreshEngine.ts
index 10ec91e5b..f5abd4b87 100644
--- a/src/scenes/Editor/Notebook/cellRefresh/cellRefreshEngine.ts
+++ b/src/scenes/Editor/Notebook/cellRefresh/cellRefreshEngine.ts
@@ -18,15 +18,18 @@ import {
 } from "../../../../utils/questdb/requestLimiter"
 import { eventBus } from "../../../../modules/EventBus"
 import { EventType } from "../../../../modules/EventBus/types"
-import { getQueriesFromText, normalizeQueryText } from "../../Monaco/utils"
+import { getQueriesFromText } from "../../Monaco/utils"
 import {
   autoRefreshIntervalMs,
   NOTEBOOK_ROW_CAP,
-  reconcileCellResultForValue,
+  normalizeStatementIdentity,
+  reconcileCellResultForStatements,
   resolveAutoRefresh,
   singleResultFromExec,
   sqlHash,
+  statementIdentityOfKey,
   statementKeysFor,
+  statementKeysForIdentities,
   type StatementKey,
 } from "../notebookUtils"
 import {
@@ -82,6 +85,9 @@ export type CellFetchState = {
   // after a partial round the succeeded slots are newer than their siblings.
   // Memory-only — a reload falls back to the frame's saved time.
   slotFetchedAt: ReadonlyMap<StatementKey, number>
+  // The user stopped the in-flight round. Until the next round starts, a
+  // chart with no data settles on a cancelled state instead of loading.
+  fetchCancelled: boolean
 }
 
 export type CellRefreshDeps = {
@@ -114,7 +120,7 @@ const joinQueriesKey = (queries: string[]): string =>
 const normalizedQueriesKey = (queriesKey: string): string =>
   queriesKey
     .split(QUERIES_KEY_SEPARATOR)
-    .map(normalizeQueryText)
+    .map(normalizeStatementIdentity)
     .join(QUERIES_KEY_SEPARATOR)
 
 export const pendingCellFetchState = (sql: string): CellFetchState => {
@@ -130,6 +136,7 @@ export const pendingCellFetchState = (sql: string): CellFetchState => {
     slotErrors: new Map(),
     cancelledSlots: new Set(),
     slotFetchedAt: new Map(),
+    fetchCancelled: false,
   }
 }
 
@@ -140,16 +147,51 @@ export const deriveChartLoading = (
 ): { loading: boolean; refreshing: boolean } => {
   const hasData =
     chartResult.kind === "settled" && chartResult.results.length > 0
+  const cancelled = state.fetchCancelled && !resultLoading
   const loading =
     state.queries.length > 0 &&
     state.classifyBlock === null &&
     !hasData &&
+    !cancelled &&
     (state.settledKey !== state.queriesKey ||
       resultLoading ||
       (state.fetching && chartResult.kind !== "settled"))
   return { loading, refreshing: state.fetching && !loading }
 }
 
+type FetchReason = "settle" | "poll" | "manual"
+
+const keyedStatements = (queries: string[]) => {
+  const identities = queries.map(normalizeStatementIdentity)
+  return {
+    slotKeys: statementKeysForIdentities(identities),
+    identitiesKey: identities.join(QUERIES_KEY_SEPARATOR),
+  }
+}
+
+const isChartableResult = (result: SingleQueryResult): boolean =>
+  result.type === "dql" && !result.truncated && result.dataset.length > 0
+
+// Keys of the frame a round last wrote, so per-slot lookups never re-key the
+// whole cell. A frame the round did not write (released or replaced under it)
+// is keyed on sight.
+class FrameKeys {
+  private frame: SingleQueryResult[] | null = null
+  private keys: StatementKey[] = []
+
+  of(results: SingleQueryResult[]): StatementKey[] {
+    if (results !== this.frame) {
+      this.remember(results, statementKeysFor(results.map((r) => r.query)))
+    }
+    return this.keys
+  }
+
+  remember(results: SingleQueryResult[], keys: StatementKey[]) {
+    this.frame = results
+    this.keys = keys
+  }
+}
+
 const errorMessage = (cause: unknown): string => {
   if (typeof cause === "string" && cause) return cause
   if (cause instanceof Error && cause.message) return cause.message
@@ -214,6 +256,10 @@ type Entry = {
   kind: CellEntryKind
   cellId: string
   sql: string
+  // Statement keys and identities of `state.queries`, derived once per SQL
+  // change so no round or edit re-keys the statement list.
+  slotKeys: StatementKey[]
+  identitiesKey: string
   autoRefresh: AutoRefresh
   visible: boolean
   pendingManualRefresh: boolean
@@ -384,13 +430,23 @@ export class CellRefreshEngine {
     if (!entry) return Promise.resolve()
     this.promotePendingSql(entry)
     entry.manualRefreshInFlight = true
-    return this.fetchOnce(entry, true).then(() => undefined)
+    return this.fetchOnce(entry, "manual").then(() => undefined)
   }
 
   // Cancel acts per statement. After the barrier it aborts that slot's
   // execution; before the barrier it drops the execution intent only — the
   // validation still completes, so the barrier settles with every class known
   // and one DDL/DML statement still blocks the cell.
+  // Stops a chart's in-flight round. The marker lets a chart with no data
+  // settle on a cancelled state instead of spinning; the next round clears it.
+  cancelChartFetch(cellId: string) {
+    const entry = this.entries.get(cellId)
+    if (!entry || entry.kind !== "chart" || !entry.inFlight) return
+    this.abortRound(entry)
+    entry.manualRefreshInFlight = false
+    this.setState(entry, { fetchCancelled: true })
+  }
+
   cancelSlot(cellId: string, statementKey: StatementKey) {
     const entry = this.entries.get(cellId)
     if (!entry || entry.kind !== "grid") return
@@ -445,7 +501,7 @@ export class CellRefreshEngine {
       entry.pollKey = null
       this.updatePoll(entry)
     } else {
-      void this.fetchOnce(entry, true)
+      void this.fetchOnce(entry, "manual")
     }
   }
 
@@ -622,7 +678,7 @@ export class CellRefreshEngine {
     errors: Array<{ statementKey: string; message: string }>,
   ) {
     if (errors.length === 0) return
-    const slotKeys = new Set(statementKeysFor(entry.state.queries))
+    const slotKeys = new Set(entry.slotKeys)
     const slotErrors = new Map(entry.state.slotErrors)
     let changed = false
     for (const { statementKey, message } of errors) {
@@ -634,15 +690,17 @@ export class CellRefreshEngine {
   }
 
   private createEntry(cell: NotebookCell, kind: CellEntryKind) {
+    const state = pendingCellFetchState(cell.value)
     const entry: Entry = {
       kind,
       cellId: cell.id,
       sql: cell.value,
+      ...keyedStatements(state.queries),
       autoRefresh: resolveAutoRefresh(
         cell.autoRefresh,
         this.autoRefreshDefault,
       ),
-      state: pendingCellFetchState(cell.value),
+      state,
       visible: this.visibilityByCell.get(cell.id) ?? false,
       pendingManualRefresh: false,
       manualRefreshInFlight: false,
@@ -745,18 +803,18 @@ export class CellRefreshEngine {
     this.dropPendingSnapshot(entry)
     const queries = getQueriesFromText(sql)
     const queriesKey = joinQueriesKey(queries)
-    const sameQueries =
-      entry.state.settledKey !== null &&
-      normalizedQueriesKey(entry.state.settledKey) ===
-        normalizedQueriesKey(queriesKey)
+    const { slotKeys, identitiesKey } = keyedStatements(queries)
+    const sameQueries = this.settledIdentitiesKey(entry) === identitiesKey
+    entry.slotKeys = slotKeys
+    entry.identitiesKey = identitiesKey
     // Refresh errors follow statement content: an edited statement's error
     // clears, an unchanged sibling's survives the edit.
-    const slotKeys = new Set(statementKeysFor(queries))
+    const slotKeySet = new Set(slotKeys)
     const slotErrors = new Map(
-      [...entry.state.slotErrors].filter(([key]) => slotKeys.has(key)),
+      [...entry.state.slotErrors].filter(([key]) => slotKeySet.has(key)),
     )
     const slotFetchedAt = new Map(
-      [...entry.state.slotFetchedAt].filter(([key]) => slotKeys.has(key)),
+      [...entry.state.slotFetchedAt].filter(([key]) => slotKeySet.has(key)),
     )
     this.setState(entry, {
       queries,
@@ -764,6 +822,7 @@ export class CellRefreshEngine {
       fetching: false,
       slotFetching: new Set(),
       cancelledSlots: new Set(),
+      fetchCancelled: false,
       slotErrors,
       slotFetchedAt,
       ...(sameQueries ? { settledKey: queriesKey } : {}),
@@ -771,6 +830,15 @@ export class CellRefreshEngine {
     if (entry.kind === "grid") this.ensureClassified(entry)
   }
 
+  // A settled entry's settledKey is its queriesKey, whose identities the entry
+  // already holds; only a stale settledKey is normalized on demand.
+  private settledIdentitiesKey(entry: Entry): string | null {
+    const { settledKey, queriesKey } = entry.state
+    if (settledKey === null) return null
+    if (settledKey === queriesKey) return entry.identitiesKey
+    return normalizedQueriesKey(settledKey)
+  }
+
   private applySql(entry: Entry, sql: string) {
     this.applySqlState(entry, sql)
     if (entry.kind === "grid") this.reconcileGridResult(entry)
@@ -794,7 +862,11 @@ export class CellRefreshEngine {
       return
     }
     entry.snapshotRetained = false
-    const reconciled = reconcileCellResultForValue(current, entry.sql)
+    const reconciled = reconcileCellResultForStatements(
+      current,
+      entry.state.queries,
+      entry.slotKeys,
+    )
     if (reconciled === null) {
       // The debounce fires on transient mid-typing text, so a zero-survivor
       // collapse drops the display only — never the disk snapshot. "missing"
@@ -828,7 +900,7 @@ export class CellRefreshEngine {
     const { queries, queriesKey, settledKey, classifyBlock } = entry.state
     if (queries.length === 0) {
       if (entry.kind === "chart" && settledKey !== queriesKey) {
-        void this.fetchOnce(entry)
+        void this.fetchOnce(entry, "settle")
       }
       this.updatePoll(entry)
       return
@@ -867,7 +939,8 @@ export class CellRefreshEngine {
       this.updatePoll(entry)
       return
     }
-    if (entry.visible && !this.documentHidden) void this.fetchOnce(entry)
+    if (entry.visible && !this.documentHidden)
+      void this.fetchOnce(entry, "settle")
     this.updatePoll(entry)
   }
 
@@ -965,7 +1038,7 @@ export class CellRefreshEngine {
     const skipInitialFetch =
       Date.now() - entry.lastFetchedAt < (fixed ?? REFRESH_MIN_MS)
     await runAdaptivePollLoop({
-      fetchFn: () => this.fetchOnce(entry),
+      fetchFn: () => this.fetchOnce(entry, "poll"),
       signal: abort.signal,
       minIntervalMs: fixed ?? REFRESH_MIN_MS,
       maxIntervalMs: fixed ?? REFRESH_MAX_MS,
@@ -975,8 +1048,9 @@ export class CellRefreshEngine {
 
   private async fetchOnce(
     entry: Entry,
-    manual: boolean = false,
+    reason: FetchReason,
   ): Promise<number | void> {
+    const manual = reason === "manual"
     // A poll tick must not abort the round a refresh click started — skip it;
     // the loop resumes on its own schedule once the manual round settles.
     if (!manual && entry.inFlight && entry.manualRefreshInFlight) return
@@ -994,6 +1068,7 @@ export class CellRefreshEngine {
         slotFetching: new Set(),
         slotErrors: new Map(),
         cancelledSlots: new Set(),
+        fetchCancelled: false,
       })
       if (entry.kind === "chart") this.clearCellData(entry)
       return
@@ -1032,13 +1107,17 @@ export class CellRefreshEngine {
     }
     const ac = new AbortController()
     entry.inFlight = ac
-    this.setState(entry, { fetching: true, cancelledSlots: new Set() })
+    this.setState(entry, {
+      fetching: true,
+      cancelledSlots: new Set(),
+      fetchCancelled: false,
+    })
     const start = performance.now()
     // A refresh-all click on a polling cell redeems itself through the poll
     // loop's first tick, so the manual intent rides on the entry, not the call.
     const userAsked = manual || entry.manualRefreshInFlight
     if (entry.kind === "grid") await this.runGridRound(entry, ac, userAsked)
-    else await this.runChartFetch(entry, ac)
+    else await this.runChartFetch(entry, ac, reason)
     return performance.now() - start
   }
 
@@ -1058,7 +1137,11 @@ export class CellRefreshEngine {
     )
   }
 
-  private async runChartFetch(entry: Entry, ac: AbortController) {
+  private async runChartFetch(
+    entry: Entry,
+    ac: AbortController,
+    reason: FetchReason,
+  ) {
     const deps = this.getDeps()
     const { queries, queriesKey } = entry.state
     try {
@@ -1095,6 +1178,11 @@ export class CellRefreshEngine {
         return
       }
       this.setState(entry, { classifyBlock: null, classifiedKey: queriesKey })
+      const carried =
+        reason === "settle"
+          ? this.chartableResultsByKey(entry)
+          : new Map<StatementKey, SingleQueryResult>()
+      const slotKeys = entry.slotKeys
       const fetchStartedAt = Date.now()
       const out = await Promise.all(
         queries.map((q, index) => {
@@ -1103,6 +1191,8 @@ export class CellRefreshEngine {
             return Promise.resolve(
               errorExecResult(q, stmt.error ?? "Invalid statement"),
             )
+          const previous = carried.get(slotKeys[index])
+          if (previous) return Promise.resolve(toExecResult(previous))
           return this.limitRequest(
             () => deps.executeSingle(q, ac.signal, NOTEBOOK_ROW_CAP),
             ac.signal,
@@ -1195,7 +1285,8 @@ export class CellRefreshEngine {
         this.updatePoll(entry)
         return
       }
-      const slotKeys = statementKeysFor(queries)
+      const slotKeys = entry.slotKeys
+      const frameKeys = new FrameKeys()
       const invalidSlots: Array<{ key: StatementKey; message: string }> = []
       const launchSlots: Array<{ key: StatementKey; index: number }> = []
       slotKeys.forEach((key, index) => {
@@ -1248,11 +1339,16 @@ export class CellRefreshEngine {
                 // poll that just verified the rows. The frame is rewritten only
                 // when the rows changed, so an identical poll costs no renders
                 // and no snapshot churn.
-                const previous = this.currentSlotResult(entry.cellId, key)
+                const previous = this.currentSlotResult(
+                  entry.cellId,
+                  key,
+                  frameKeys,
+                )
                 const unchanged =
                   previous !== undefined &&
                   resultsEquivalent([toExecResult(previous)], [exec])
-                if (!unchanged) this.commitSlotResult(entry, key, exec)
+                if (!unchanged)
+                  this.commitSlotResult(entry, slotKeys, key, exec, frameKeys)
                 this.settleSlotSuccess(entry, key)
               }
             })
@@ -1291,14 +1387,30 @@ export class CellRefreshEngine {
     }
   }
 
+  // An edit-triggered settle keeps every unchanged statement's chartable rows
+  // and executes only the statements without any. Poll ticks and manual
+  // refreshes exist for freshness, so they execute every statement.
+  private chartableResultsByKey(
+    entry: Entry,
+  ): Map<StatementKey, SingleQueryResult> {
+    const byKey = new Map<StatementKey, SingleQueryResult>()
+    const current = this.getDeps().getCellResult(entry.cellId)
+    if (!current) return byKey
+    const keys = statementKeysFor(current.results.map((r) => r.query))
+    current.results.forEach((result, index) => {
+      if (isChartableResult(result)) byKey.set(keys[index], result)
+    })
+    return byKey
+  }
+
   private currentSlotResult(
     cellId: string,
     key: StatementKey,
+    frameKeys: FrameKeys,
   ): SingleQueryResult | undefined {
     const current = this.getDeps().getCellResult(cellId)
     if (!current) return undefined
-    const keys = statementKeysFor(current.results.map((r) => r.query))
-    const index = keys.indexOf(key)
+    const index = frameKeys.of(current.results).indexOf(key)
     return index === -1 ? undefined : current.results[index]
   }
 
@@ -1307,16 +1419,17 @@ export class CellRefreshEngine {
   // like any other; the active tab follows its statement's content.
   private commitSlotResult(
     entry: Entry,
+    slotKeys: StatementKey[],
     key: StatementKey,
     exec: QueryExecResult,
+    frameKeys: FrameKeys,
   ) {
     const deps = this.getDeps()
     const current = deps.getCellResult(entry.cellId)
     if (!current) return
-    const slotKeys = statementKeysFor(entry.state.queries)
     const slotIndex = slotKeys.indexOf(key)
     if (slotIndex === -1) return
-    const currentKeys = statementKeysFor(current.results.map((r) => r.query))
+    const currentKeys = frameKeys.of(current.results)
     const byKey = new Map<StatementKey, SingleQueryResult>()
     currentKeys.forEach((currentKey, index) => {
       byKey.set(currentKey, current.results[index])
@@ -1326,6 +1439,10 @@ export class CellRefreshEngine {
     const nextResults = nextKeys.map(
       (slotKey) => byKey.get(slotKey) as SingleQueryResult,
     )
+    frameKeys.remember(
+      nextResults,
+      statementKeysForIdentities(nextKeys.map(statementIdentityOfKey)),
+    )
     const activeKey =
       current.activeStatementKey ??
       currentKeys[
@@ -1410,13 +1527,15 @@ export class CellRefreshEngine {
   // Chart refresh failures live inside the settled frame (error results); the
   // channel re-derives from it so both views feed one last_refresh_error
   // surface — including after a reload.
+  // Every caller has just matched the frame to the current queries, so its
+  // results align with the entry's slot keys by position.
   private deriveChartSlotErrors(entry: Entry) {
     const current = this.getDeps().getCellResult(entry.cellId)
     const slotErrors = new Map<StatementKey, string>()
-    if (current) {
-      const keys = statementKeysFor(current.results.map((r) => r.query))
+    if (current && current.results.length === entry.slotKeys.length) {
       current.results.forEach((result, index) => {
-        if (result.type === "error") slotErrors.set(keys[index], result.error)
+        if (result.type === "error")
+          slotErrors.set(entry.slotKeys[index], result.error)
       })
     }
     const previous = entry.state.slotErrors
diff --git a/src/scenes/Editor/Notebook/cellRefresh/statementIdentityPasses.test.ts b/src/scenes/Editor/Notebook/cellRefresh/statementIdentityPasses.test.ts
new file mode 100644
index 000000000..2b09b664a
--- /dev/null
+++ b/src/scenes/Editor/Notebook/cellRefresh/statementIdentityPasses.test.ts
@@ -0,0 +1,189 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
+import type { QueryExecResult } from "../../../../hooks/useQueryExecution"
+import type {
+  CellResult,
+  NotebookCell,
+  SingleQueryResult,
+} from "../../../../store/notebook"
+import { clearStatementClassCache } from "../../../../utils/tools/permissions"
+
+let formatterCalls = 0
+vi.mock("../../../../utils/formatSql", async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import("../../../../utils/formatSql")>()
+  return {
+    ...actual,
+    formatSql: (...args: Parameters<typeof actual.formatSql>) => {
+      formatterCalls++
+      return actual.formatSql(...args)
+    },
+  }
+})
+
+import { CellRefreshEngine, type CellRefreshDeps } from "./cellRefreshEngine"
+import {
+  deriveStatementFrame,
+  reconcileCellResultForValue,
+} from "../notebookUtils"
+
+// The formatter is the only expensive step of statement identity. Every event
+// below must key each statement list at most once and each result frame at
+// most once, so the ceilings are small multiples of the statement count.
+const N = 5
+const statements = Array.from({ length: N }, (_, i) => `select ${i + 1}`)
+const edited = statements.map((s, i) => (i === 2 ? "select 33" : s))
+const sqlOf = (list: string[]) => list.join(";\n")
+
+const execResult = (query: string): QueryExecResult => ({
+  type: "dql",
+  query,
+  columns: [{ name: "x", type: "INT" }],
+  dataset: [[1]],
+  count: 1,
+})
+
+const frameOf = (list: string[]): CellResult => ({
+  results: list.map(
+    (query) =>
+      ({
+        type: "dql",
+        query,
+        columns: [{ name: "x", type: "INT" }],
+        dataset: [[1]],
+        count: 1,
+        timestamp: 0,
+      }) as unknown as SingleQueryResult,
+  ),
+  activeResultIndex: 0,
+  timestamp: 0,
+})
+
+const fakeDocument = Object.assign(new EventTarget(), { hidden: false })
+
+const flush = async () => {
+  await vi.advanceTimersByTimeAsync(0)
+}
+
+const countFormatterCalls = async (run: () => Promise<void> | void) => {
+  formatterCalls = 0
+  await run()
+  await flush()
+  return formatterCalls
+}
+
+describe("statement identity passes per event", () => {
+  let cellResults: Map<string, CellResult | undefined>
+  let deps: CellRefreshDeps
+  let engine: CellRefreshEngine
+
+  beforeEach(() => {
+    vi.useFakeTimers()
+    clearStatementClassCache()
+    ;(globalThis as { document?: unknown }).document = fakeDocument
+    cellResults = new Map()
+    deps = {
+      executeSingle: vi.fn((sql: string) => Promise.resolve(execResult(sql))),
+      validateWithGlobals: vi
+        .fn()
+        .mockResolvedValue({ query: "q", columns: [], timestamp: 0 }),
+      setCellResult: vi.fn((id: string, result: CellResult | undefined) => {
+        cellResults.set(id, result)
+      }),
+      getCellResult: vi.fn((id: string) => cellResults.get(id)),
+      isDrawCell: vi.fn(() => false),
+      isCellRunning: vi.fn(() => false),
+      resultLoadStatus: vi.fn(() => "loaded"),
+      subscribeResultLoad: vi.fn(() => () => undefined),
+      requestResultLoad: vi.fn(),
+      noteResultMissing: vi.fn(),
+      reviveResultLoad: vi.fn(),
+      onSnapshotPersisted: vi.fn(),
+    } as unknown as CellRefreshDeps
+    engine = new CellRefreshEngine(1, () => deps, { initialFetchJitterMs: 0 })
+    engine.attach()
+  })
+
+  afterEach(() => {
+    engine.destroy()
+    delete (globalThis as { document?: unknown }).document
+    vi.useRealTimers()
+  })
+
+  it("keys a grid cell once per refresh round and twice per edit", async () => {
+    // Given an on-screen grid cell with a settled frame
+    const gridCell = (value: string): NotebookCell =>
+      ({
+        id: "c1",
+        position: 0,
+        value,
+        result: cellResults.get("c1"),
+      }) as NotebookCell
+    cellResults.set("c1", frameOf(statements))
+    engine.setVisible("c1", true)
+    engine.sync([gridCell(sqlOf(statements))])
+    await flush()
+
+    // When the cell is refreshed by hand with unchanged text
+    const refreshCalls = await countFormatterCalls(() => engine.refresh("c1"))
+
+    // Then only the frame is keyed: the statement list came with the entry
+    expect(refreshCalls).toBeLessThanOrEqual(N)
+
+    // When one statement is edited and the debounce fires
+    const editCalls = await countFormatterCalls(async () => {
+      engine.sync([gridCell(sqlOf(edited))])
+      await vi.advanceTimersByTimeAsync(301)
+    })
+
+    // Then the new list and the old frame are keyed once each
+    expect(editCalls).toBeLessThanOrEqual(2 * N)
+  })
+
+  it("keys a chart cell at most four times per edit", async () => {
+    // Given an on-screen draw cell with auto-refresh off
+    ;(deps.isDrawCell as ReturnType<typeof vi.fn>).mockReturnValue(true)
+    const drawCell = (value: string): NotebookCell =>
+      ({
+        id: "c2",
+        position: 0,
+        value,
+        mode: "draw",
+        autoRefresh: false,
+      }) as NotebookCell
+    engine.setVisible("c2", true)
+
+    // When it settles for the first time
+    const settleCalls = await countFormatterCalls(() => {
+      engine.sync([drawCell(sqlOf(statements))])
+    })
+
+    // Then the statement list is keyed once
+    expect(settleCalls).toBeLessThanOrEqual(N)
+
+    // When one statement is edited and the settle round fetches only it
+    const editCalls = await countFormatterCalls(async () => {
+      engine.sync([drawCell(sqlOf(edited))])
+      await vi.advanceTimersByTimeAsync(301)
+    })
+
+    // Then the list, the stale check, and the carry map are each keyed once
+    expect(editCalls).toBeLessThanOrEqual(4 * N + 2)
+  })
+
+  it("keys statements and results once each in the pure helpers", async () => {
+    // Given a frame that matches its statements
+    const frame = frameOf(statements)
+
+    // When the tab frame and the edit reconcile derive from it
+    const frameCalls = await countFormatterCalls(() => {
+      deriveStatementFrame(statements, frame)
+    })
+    const reconcileCalls = await countFormatterCalls(() => {
+      reconcileCellResultForValue(frame, sqlOf(statements))
+    })
+
+    // Then each keys the statement list once and the frame once
+    expect(frameCalls).toBe(2 * N)
+    expect(reconcileCalls).toBe(2 * N)
+  })
+})
diff --git a/src/scenes/Editor/Notebook/cells/Cell.tsx b/src/scenes/Editor/Notebook/cells/Cell.tsx
index b5ae87894..314a4ab36 100644
--- a/src/scenes/Editor/Notebook/cells/Cell.tsx
+++ b/src/scenes/Editor/Notebook/cells/Cell.tsx
@@ -9,6 +9,7 @@ import { CellDragHeader } from "./CellDragHeader"
 import { CellRunDrawToggles } from "./CellRunDrawToggles"
 import { CellWideActions } from "./CellWideActions"
 import { CellViewToggle } from "./CellViewToggle"
+import { CellStopButton } from "./CellStopButton"
 import { CellNameLabel } from "./CellNameLabel"
 import { useChartLoading } from "./useChartLoading"
 import { useChartZoomed } from "./useChartZoomed"
@@ -30,10 +31,13 @@ import { toast } from "../../../../components/Toast"
 import {
   CELL_EDITOR_LINE_HEIGHT,
   CELL_EDITOR_PADDING,
+  MAX_PANE_HEIGHT_PX,
+  clampPaneHeight,
   isDoubleView,
   isExpectingResult,
-  MIN_BOTTOM_HEIGHT_PX,
+  minBottomHeightFor,
   resolveAutoRefresh,
+  resolveCellPaneLayout,
   resolveCellView,
 } from "../notebookUtils"
 import {
@@ -41,6 +45,7 @@ import {
   useCellVirtualizationEngine,
 } from "../cellVirtualization/CellVirtualizationContext"
 import { useCellResultStatus } from "../resultHydration/CellResultHydrationContext"
+import { useCellFetchState } from "../cellRefresh/CellRefreshContext"
 import { EditorShimmer } from "../cellVirtualization/EditorShimmer"
 import { useValidateWithGlobals } from "../globals/useValidateWithGlobals"
 import { useCellRunActions } from "./useCellRunActions"
@@ -146,11 +151,17 @@ const CellInner: React.FC<Props> = ({
   const editorContainerRef = useRef<HTMLDivElement | null>(null)
   const resultRef = useRef<HTMLDivElement | null>(null)
   const headerRef = useRef<HTMLDivElement | null>(null)
+  const focusCellToolbar = useCallback(() => {
+    headerRef.current
+      ?.querySelector<HTMLButtonElement>(".cell-toolbar button")
+      ?.focus()
+  }, [])
 
   const toolbarTier = useCellToolbarTier(headerRef, isMaximized)
   const { loading: chartLoading, refreshing: chartRefreshing } =
     useChartLoading(cell)
   const chartZoomed = useChartZoomed(cell.id)
+  const fetchState = useCellFetchState(cell.id)
   const contentMode = useCellContentMode(cell.id)
   const virtualizationEngine = useCellVirtualizationEngine()
   const resultStatus = useCellResultStatus(cell.id)
@@ -174,14 +185,12 @@ const CellInner: React.FC<Props> = ({
   // in the grid item's height (both go through computeCellHeights).
   const expectingResult = isExpectingResult(cell, resultStatus)
   const doubleView = isDoubleView(cell) || expectingResult
-  // Compact can't split — one full-height pane: the result fills the cell by
-  // default, "View SQL" (isViewMaximized === false) shows the editor instead.
-  const isCompactTier = toolbarTier === "compact"
-  const isViewMaximized = isCompactTier
-    ? doubleView && cell.isViewMaximized !== false
-    : doubleView && !!cell.isViewMaximized
-  const showBottomSlot = isViewMaximized || (doubleView && !isCompactTier)
-  const isSplit = doubleView && !isViewMaximized && !isCompactTier
+  const paneLayout = resolveCellPaneLayout(cell, expectingResult)
+
+  const resultOnly = paneLayout === "result"
+  const showBottomSlot = paneLayout !== "editor"
+  const isSplit = paneLayout === "split"
+  const isCellBusy = isRunning || (isDrawMode && chartLoading)
   const runActive = !isDrawMode && doubleView
   const view = resolveCellView(cell)
   const canRun = !!stripSQLComments(cell.value).trim()
@@ -196,12 +205,11 @@ const CellInner: React.FC<Props> = ({
     spotlightEditorRatio,
     topResize,
     bottomResize,
+    middleMaxHeight,
     middleResizeLive,
     middleResizeEnd,
     resetToDefaults,
     resetBottomArea,
-    maximizedChartResizeLive,
-    maximizedChartResizeEnd,
   } = useCellResizeOrchestration({
     cell,
     layoutMode,
@@ -225,7 +233,7 @@ const CellInner: React.FC<Props> = ({
     (px: number) => {
       if (isMaximized) return
       if (cell.topResized) return
-      const next = Math.max(MIN_EDITOR_HEIGHT, px)
+      const next = clampPaneHeight(MIN_EDITOR_HEIGHT, px)
       if (next === cell.topHeight) return
       updateCell(cell.id, { topHeight: next })
     },
@@ -234,7 +242,7 @@ const CellInner: React.FC<Props> = ({
 
   const { editorRef, monacoRef, handleEditorMount } = useMonacoCellEditor({
     cellId: cell.id,
-    editorMounted: !isViewMaximized && contentMode === "full",
+    editorMounted: !resultOnly && contentMode === "full",
     editorViewState: cell.editorViewState,
     quest,
     onFocus: useCallback(
@@ -290,13 +298,17 @@ const CellInner: React.FC<Props> = ({
   } = useCellRunActions({
     cell,
     isRunning,
-    isCompactTier,
-    showBottomSlot,
     editorRef,
     applyHighlight,
     clearHighlight,
   })
 
+  // Stop exists for the first run or the first chart fetch only: a refresh
+  // keeps its rows or frame on screen and never locks the cell.
+  const showStopButton = isDrawMode
+    ? chartLoading && (fetchState?.fetching ?? false)
+    : isGridLoading
+
   const isExternalSyncRef = useRef(false)
 
   // 500 ms-debounced — one event per cell per typing burst keeps the digest tiny.
@@ -433,9 +445,10 @@ const CellInner: React.FC<Props> = ({
         layoutMode={layoutMode}
         autoRefreshDefault={autoRefreshDefault}
         isMaximized={isMaximized}
-        isRunning={isRunning}
+        isCellBusy={isCellBusy}
         headerRef={headerRef}
         toolbarTier={toolbarTier}
+        paneLayout={paneLayout}
         chartZoomed={chartZoomed}
         left={
           <CellNameLabel
@@ -451,62 +464,76 @@ const CellInner: React.FC<Props> = ({
           />
         }
         right={
-          toolbarTier === "compact" ? null : view === "none" ? (
-            // Neutral: action verbs (Run / Draw) — labelled only when expanded.
-            <CellRunDrawToggles
-              isRunning={isRunning}
-              isChartLoading={chartLoading}
-              runActive={runActive}
-              isDrawMode={isDrawMode}
-              canRun={canRun}
-              autoRefreshOn={effectiveAutoRefresh !== false}
-              showLabels={toolbarTier === "expanded"}
-              onRun={runAll}
-              onHideResult={() => {
-                signalUserEdit(bufferIdForEvents)
-                clearCellResult(cell.id)
-              }}
-              onDraw={() => {
-                void trackEvent(ConsoleEvent.NOTEBOOK_DRAW_TOGGLE, {
-                  mode: isDrawMode ? "run" : "draw",
-                })
-                void handleDrawClick()
-              }}
-            />
-          ) : toolbarTier === "expanded" ? (
-            <CellWideActions
-              cellId={cell.id}
-              view={view}
-              cellAutoRefresh={cell.autoRefresh}
-              autoRefreshDefault={autoRefreshDefault}
-              isViewMaximized={isViewMaximized}
-              isRunning={isRunning}
-              isGridLoading={isGridLoading}
-              isChartLoading={chartLoading}
-              isChartRefreshing={chartRefreshing}
-              chartZoomed={chartZoomed}
-            />
-          ) : (
-            // Standard tier with a result: the compact (label-less) view toggle.
-            <CellViewToggle
-              cellId={cell.id}
-              view={view}
-              isViewMaximized={isViewMaximized}
-              isGridLoading={isGridLoading}
-              isChartLoading={chartLoading}
-              isRunning={isRunning}
-              chartZoomed={chartZoomed}
-              showLabels={false}
-            />
-          )
+          <>
+            {toolbarTier === "compact" ? null : view === "none" ? (
+              // Neutral: action verbs (Run / Draw) — labelled only when expanded.
+              <CellRunDrawToggles
+                isCellBusy={isCellBusy}
+                isChartLoading={chartLoading}
+                runActive={runActive}
+                isDrawMode={isDrawMode}
+                canRun={canRun}
+                autoRefreshOn={effectiveAutoRefresh !== false}
+                showLabels={toolbarTier === "expanded"}
+                onRun={runAll}
+                onHideResult={() => {
+                  signalUserEdit(bufferIdForEvents)
+                  clearCellResult(cell.id)
+                }}
+                onDraw={() => {
+                  void trackEvent(ConsoleEvent.NOTEBOOK_DRAW_TOGGLE, {
+                    mode: isDrawMode ? "run" : "draw",
+                  })
+                  void handleDrawClick()
+                }}
+              />
+            ) : toolbarTier === "expanded" ? (
+              <CellWideActions
+                cellId={cell.id}
+                view={view}
+                cellAutoRefresh={cell.autoRefresh}
+                autoRefreshDefault={autoRefreshDefault}
+                paneLayout={paneLayout}
+                isRunning={isRunning}
+                isGridLoading={isGridLoading}
+                isChartLoading={chartLoading}
+                isChartRefreshing={chartRefreshing}
+                isCellBusy={isCellBusy}
+                chartZoomed={chartZoomed}
+                onResetZoomFocus={focusCellToolbar}
+              />
+            ) : (
+              // Standard tier with a result: the compact (label-less) view toggle.
+              <CellViewToggle
+                cellId={cell.id}
+                view={view}
+                paneLayout={paneLayout}
+                isGridLoading={isGridLoading}
+                isChartLoading={chartLoading}
+                isCellBusy={isCellBusy}
+                chartZoomed={chartZoomed}
+                showLabels={false}
+                onResetZoomFocus={focusCellToolbar}
+              />
+            )}
+            {showStopButton && (
+              <CellStopButton
+                cellId={cell.id}
+                view={isDrawMode ? "chart" : "grid"}
+                onUnmountWhileFocused={focusCellToolbar}
+              />
+            )}
+          </>
         }
       />
-      {!isViewMaximized && (
+      {!resultOnly && (
         <EditorContainer
           ref={editorContainerRef}
           $spotlight={isMaximized}
           style={
-            isMaximized ? { flex: spotlightEditorRatio } : { height: topHeight }
+            isMaximized
+              ? { flex: showBottomSlot ? spotlightEditorRatio : 1 }
+              : { height: topHeight }
           }
         >
           {contentMode === "full" ? (
@@ -569,23 +596,22 @@ const CellInner: React.FC<Props> = ({
             void trackEvent(ConsoleEvent.NOTEBOOK_CELL_SIZE_RESET)
             resetToDefaults()
           }}
+          minHeight={MIN_EDITOR_HEIGHT}
+          maxHeight={middleMaxHeight}
+          ariaLabel="Resize editor pane"
           doubleView={doubleView}
         />
       )}
-      {/* Bottom slot: result grid OR chart, OR chart filling the whole cell
-          when expanded. */}
+      {/* Bottom slot: result grid OR chart. Hiding the editor preserves this
+          pane's own height instead of borrowing the editor allocation. */}
       {showBottomSlot && (
         <BottomSlot
           ref={resultRef}
           $spotlight={isMaximized}
           style={
-            isViewMaximized
-              ? isMaximized
-                ? { flex: 1 }
-                : { height: topHeight + bottomHeight }
-              : isMaximized
-                ? { flex: 1 - spotlightEditorRatio }
-                : { height: bottomHeight }
+            isMaximized
+              ? { flex: resultOnly ? 1 : 1 - spotlightEditorRatio }
+              : { height: bottomHeight }
           }
         >
           <CellBottomContent
@@ -608,34 +634,24 @@ const CellInner: React.FC<Props> = ({
     !isMaximized && layoutMode !== "grid" ? (
       <ResizeHandle
         overlay
-        targetRef={
-          isViewMaximized || showBottomSlot ? resultRef : editorContainerRef
-        }
+        targetRef={showBottomSlot ? resultRef : editorContainerRef}
         onResize={
-          isViewMaximized
-            ? maximizedChartResizeLive
-            : showBottomSlot
-              ? bottomResize.resizeLive
-              : topResize.resizeLive
+          showBottomSlot ? bottomResize.resizeLive : topResize.resizeLive
         }
         onResizeEnd={(height) => {
           void trackEvent(ConsoleEvent.NOTEBOOK_CELL_RESIZE, { region: "s" })
-          if (isViewMaximized) maximizedChartResizeEnd(height)
-          else if (showBottomSlot) bottomResize.resizeEnd(height)
+          if (showBottomSlot) bottomResize.resizeEnd(height)
           else topResize.resizeEnd(height)
         }}
         onDoubleClick={() => {
           void trackEvent(ConsoleEvent.NOTEBOOK_CELL_SIZE_RESET)
-          if (isViewMaximized) resetToDefaults()
-          else resetBottomArea()
+          resetBottomArea()
         }}
         minHeight={
-          isViewMaximized
-            ? MIN_EDITOR_HEIGHT + MIN_BOTTOM_HEIGHT_PX
-            : showBottomSlot
-              ? MIN_BOTTOM_HEIGHT_PX
-              : undefined
+          showBottomSlot ? minBottomHeightFor(cell) : MIN_EDITOR_HEIGHT
         }
+        maxHeight={MAX_PANE_HEIGHT_PX}
+        ariaLabel={showBottomSlot ? "Resize result pane" : "Resize editor pane"}
       />
     ) : null
 
diff --git a/src/scenes/Editor/Notebook/cells/CellBottomContent.tsx b/src/scenes/Editor/Notebook/cells/CellBottomContent.tsx
index eeb7f8e8d..8ebc6d10d 100644
--- a/src/scenes/Editor/Notebook/cells/CellBottomContent.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellBottomContent.tsx
@@ -1,4 +1,5 @@
 import React, { useCallback, useEffect, useMemo } from "react"
+import styled from "styled-components"
 import type { NotebookCell } from "../../../../store/notebook"
 import type { ChartConfig } from "../CellChart/chartTypes"
 import type { CellContentMode } from "../cellVirtualization/cellVirtualizationEngine"
@@ -12,6 +13,7 @@ import { InlineResultTable } from "../result-table"
 import { buildStatementSlotViews } from "../result-table/statementSlotView"
 import { ChartPlaceholder } from "../cellVirtualization/ChartPlaceholder"
 import { GridShimmer } from "../cellVirtualization/GridShimmer"
+import { useCellResultStatus } from "../resultHydration/CellResultHydrationContext"
 import { createResultGridViewportStore } from "../result-table/resultGridViewportStore"
 import { getQueriesFromText } from "../../Monaco/utils"
 import {
@@ -20,6 +22,17 @@ import {
   statementKeysFor,
 } from "../notebookUtils"
 
+// Mirrors DrawCanvas's EmptyState: a failed snapshot read keeps the reserved
+// pane and says so, instead of an endless shimmer or a silent collapse.
+const LoadFailureState = styled.div`
+  height: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  color: ${({ theme }) => theme.color.contentSecondary};
+  font-size: ${({ theme }) => theme.fontSize.sm};
+`
+
 type Props = {
   cell: NotebookCell
   contentMode: CellContentMode
@@ -44,14 +57,20 @@ export const CellBottomContent: React.FC<Props> = ({
   const bufferId = useNotebookBufferId()
   const cellRefresh = useCellRefresh()
   const fetchState = useCellFetchState(cell.id)
+  const resultStatus = useCellResultStatus(cell.id)
   const viewportStore = useMemo(() => createResultGridViewportStore(), [])
 
-  // Tabs follow the editor's statement list; results attach to it by content.
-  // A statement with no result renders the neutral "Not run" slot. A frame no
-  // statement claims (selection run) falls back to the results' own tabs.
+  // Tabs follow the engine's debounced statement list, so a keystroke never
+  // re-keys the cell; results attach to it by content. A statement with no
+  // result renders the neutral "Not run" slot. A frame no statement claims
+  // (selection run) falls back to the results' own tabs.
+  const debouncedQueries = fetchState?.queries
   const statements = useMemo(
-    () => (cell.mode === "draw" ? [] : getQueriesFromText(cell.value)),
-    [cell.mode, cell.value],
+    () =>
+      cell.mode === "draw"
+        ? []
+        : (debouncedQueries ?? getQueriesFromText(cell.value)),
+    [cell.mode, debouncedQueries, cell.value],
   )
   const frame = useMemo(
     () =>
@@ -66,9 +85,11 @@ export const CellBottomContent: React.FC<Props> = ({
 
   const resultIndexOf = useCallback(
     (statementKey: string): number =>
-      statementKeysFor(
-        (cell.result?.results ?? []).map((r) => r.query),
-      ).indexOf(statementKey),
+      cell.result
+        ? statementKeysFor(cell.result.results.map((r) => r.query)).indexOf(
+            statementKey,
+          )
+        : -1,
     [cell.result],
   )
   const reRunStatement = useCallback(
@@ -131,7 +152,13 @@ export const CellBottomContent: React.FC<Props> = ({
       />
     )
   }
-  return expectingResult ? (
-    <GridShimmer statementCount={0} bufferId={bufferId} cellId={cell.id} />
-  ) : null
+  if (!expectingResult) return null
+  if (resultStatus === "failed") {
+    return (
+      <LoadFailureState role="alert" aria-live="assertive" aria-atomic="true">
+        Result failed to load. Run the cell again to restore it.
+      </LoadFailureState>
+    )
+  }
+  return <GridShimmer statementCount={0} bufferId={bufferId} cellId={cell.id} />
 }
diff --git a/src/scenes/Editor/Notebook/cells/CellDragHeader.tsx b/src/scenes/Editor/Notebook/cells/CellDragHeader.tsx
index ef8ab8f24..644dbde89 100644
--- a/src/scenes/Editor/Notebook/cells/CellDragHeader.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellDragHeader.tsx
@@ -3,7 +3,7 @@ import styled from "styled-components"
 import { CellToolbar } from "./CellToolbar"
 import { eventBus } from "../../../../modules/EventBus"
 import { EventType } from "../../../../modules/EventBus/types"
-import type { CellToolbarTier } from "../notebookUtils"
+import type { CellPaneLayout, CellToolbarTier } from "../notebookUtils"
 import type { AutoRefresh, NotebookCell } from "../../../../store/notebook"
 import { editorCardHeaderStyles } from "../../sharedStyles"
 
@@ -55,13 +55,14 @@ type Props = {
   layoutMode: "list" | "grid"
   autoRefreshDefault?: AutoRefresh
   isMaximized: boolean
-  isRunning?: boolean
+  isCellBusy?: boolean
   left?: React.ReactNode
   right?: React.ReactNode
   // SQL cells pass this so the toolbar can adapt to the header's width; markdown
   // cells omit it (no width-driven tiering).
   headerRef?: RefObject<HTMLDivElement>
   toolbarTier?: CellToolbarTier
+  paneLayout?: CellPaneLayout
   chartZoomed?: boolean
 }
 
@@ -73,11 +74,12 @@ export const CellDragHeader: React.FC<Props> = ({
   layoutMode,
   autoRefreshDefault,
   isMaximized,
-  isRunning = false,
+  isCellBusy = false,
   left,
   right,
   headerRef,
   toolbarTier,
+  paneLayout,
   chartZoomed,
 }) => (
   <HeaderBar
@@ -108,9 +110,10 @@ export const CellDragHeader: React.FC<Props> = ({
         layoutMode={layoutMode}
         autoRefreshDefault={autoRefreshDefault}
         isMaximized={isMaximized}
-        isRunning={isRunning}
+        isCellBusy={isCellBusy}
         inline
         toolbarTier={toolbarTier}
+        paneLayout={paneLayout}
         chartZoomed={chartZoomed}
       />
     </RightSide>
diff --git a/src/scenes/Editor/Notebook/cells/CellRunDrawToggles.tsx b/src/scenes/Editor/Notebook/cells/CellRunDrawToggles.tsx
index 1d42dae62..1241fa7c2 100644
--- a/src/scenes/Editor/Notebook/cells/CellRunDrawToggles.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellRunDrawToggles.tsx
@@ -31,7 +31,7 @@ const ToggleButton = styled(NotebookViewToggleSegment)`
 `
 
 type Props = {
-  isRunning: boolean
+  isCellBusy: boolean
   isChartLoading: boolean
   runActive: boolean
   isDrawMode: boolean
@@ -44,7 +44,7 @@ type Props = {
 }
 
 export const CellRunDrawToggles: React.FC<Props> = ({
-  isRunning,
+  isCellBusy,
   isChartLoading,
   runActive,
   isDrawMode,
@@ -54,62 +54,68 @@ export const CellRunDrawToggles: React.FC<Props> = ({
   onRun,
   onHideResult,
   onDraw,
-}) => (
-  <NotebookViewToggle role="group" aria-label="Cell execution mode">
-    <Tooltip
-      content={runActive ? "Hide result" : `Run cell (${ctrlCmd}+Shift+Enter)`}
-    >
-      <ToggleButton
-        type="button"
-        $size="md"
-        $active={runActive}
-        $tone="success"
-        $activeTone="neutral"
-        aria-pressed={runActive}
-        aria-disabled={isRunning || (!runActive && !canRun)}
-        onClick={(e) => {
-          e.stopPropagation()
-          if (isRunning || (!runActive && !canRun)) return
-          if (runActive) {
-            onHideResult()
-            return
-          }
-          onRun()
-        }}
-        aria-label={runActive ? "Hide result" : "Run cell"}
+}) => {
+  const runLocked = isCellBusy || (!runActive && !canRun)
+  const drawLocked = isCellBusy || !canRun
+  return (
+    <NotebookViewToggle role="group" aria-label="Cell execution mode">
+      <Tooltip
+        content={
+          runActive ? "Hide result" : `Run cell (${ctrlCmd}+Shift+Enter)`
+        }
       >
-        <PlayIcon weight="fill" />
-        {showLabels && "Run"}
-      </ToggleButton>
-    </Tooltip>
-    <Tooltip
-      content={
-        isDrawMode
-          ? autoRefreshOn
-            ? "Drawing — auto-refresh on"
-            : "Refresh chart"
-          : "Draw (auto-refresh chart)"
-      }
-    >
-      <ToggleButton
-        type="button"
-        $size="md"
-        $active={isDrawMode}
-        $tone="info"
-        $activeTone="neutral"
-        aria-pressed={isDrawMode}
-        aria-disabled={isRunning || !canRun}
-        aria-busy={isDrawMode && isChartLoading}
-        onClick={(e) => {
-          e.stopPropagation()
-          if (isRunning || !canRun) return
-          onDraw()
-        }}
-        aria-label="Draw"
+        <ToggleButton
+          type="button"
+          $size="md"
+          $active={runActive}
+          $tone="success"
+          $activeTone="neutral"
+          aria-pressed={runActive}
+          aria-disabled={runLocked}
+          onClick={(e) => {
+            e.stopPropagation()
+            if (runLocked) return
+            if (runActive) {
+              onHideResult()
+              return
+            }
+            onRun()
+          }}
+          aria-label={runActive ? "Hide result" : "Run cell"}
+        >
+          <PlayIcon weight="fill" />
+          {showLabels && "Run"}
+        </ToggleButton>
+      </Tooltip>
+      <Tooltip
+        content={
+          isDrawMode
+            ? autoRefreshOn
+              ? "Drawing — auto-refresh on"
+              : "Refresh chart"
+            : "Draw (auto-refresh chart)"
+        }
       >
-        {isDrawMode && isChartLoading ? <Spinner size={18} /> : <ChartIcon />}
-        {showLabels && "Draw"}
-      </ToggleButton>
-    </Tooltip>
-  </NotebookViewToggle>
-)
+        <ToggleButton
+          type="button"
+          $size="md"
+          $active={isDrawMode}
+          $tone="info"
+          $activeTone="neutral"
+          aria-pressed={isDrawMode}
+          aria-disabled={drawLocked}
+          aria-busy={isDrawMode && isChartLoading}
+          onClick={(e) => {
+            e.stopPropagation()
+            if (drawLocked) return
+            onDraw()
+          }}
+          aria-label="Draw"
+        >
+          {isDrawMode && isChartLoading ? <Spinner size={18} /> : <ChartIcon />}
+          {showLabels && "Draw"}
+        </ToggleButton>
+      </Tooltip>
+    </NotebookViewToggle>
+  )
+}
diff --git a/src/scenes/Editor/Notebook/cells/CellStopButton.tsx b/src/scenes/Editor/Notebook/cells/CellStopButton.tsx
new file mode 100644
index 000000000..f6165ee97
--- /dev/null
+++ b/src/scenes/Editor/Notebook/cells/CellStopButton.tsx
@@ -0,0 +1,69 @@
+import React, { useEffect, useRef } from "react"
+import { IconButton } from "../../../../components/IconButton"
+import { Stop } from "../../../../components/icons"
+import { trackEvent } from "../../../../modules/ConsoleEventTracker"
+import { ConsoleEvent } from "../../../../modules/ConsoleEventTracker/events"
+import { useNotebookActions } from "../NotebookProvider"
+import { useCellRefresh } from "../cellRefresh/CellRefreshContext"
+
+type Props = {
+  cellId: string
+  view: "grid" | "chart"
+  onUnmountWhileFocused: () => void
+}
+
+// Ends a cell's first run or first chart fetch. The button unmounts once the
+// phase ends, so a keyboard user's focus is handed on instead of dropping to
+// the document body.
+export const CellStopButton: React.FC<Props> = ({
+  cellId,
+  view,
+  onUnmountWhileFocused,
+}) => {
+  const { cancelCell } = useNotebookActions()
+  const cellRefresh = useCellRefresh()
+  const focusedRef = useRef(false)
+  const onUnmountWhileFocusedRef = useRef(onUnmountWhileFocused)
+
+  const handleClick = (e: React.MouseEvent) => {
+    e.stopPropagation()
+    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_RUN_CANCEL, {
+      scope: "cell",
+      view,
+    })
+    if (view === "chart") {
+      cellRefresh?.cancelChartFetch(cellId)
+      return
+    }
+    cancelCell(cellId)
+  }
+
+  useEffect(() => {
+    onUnmountWhileFocusedRef.current = onUnmountWhileFocused
+  }, [onUnmountWhileFocused])
+
+  useEffect(
+    () => () => {
+      if (focusedRef.current) onUnmountWhileFocusedRef.current()
+    },
+    [],
+  )
+
+  return (
+    <IconButton
+      label={view === "chart" ? "Stop chart loading" : "Stop run"}
+      tooltip="Stop"
+      variant="dangerGhost"
+      onClick={handleClick}
+      onFocus={() => {
+        focusedRef.current = true
+      }}
+      onBlur={() => {
+        focusedRef.current = false
+      }}
+      dataHook="cell-stop-button"
+    >
+      <Stop size="18px" />
+    </IconButton>
+  )
+}
diff --git a/src/scenes/Editor/Notebook/cells/CellToolbar.tsx b/src/scenes/Editor/Notebook/cells/CellToolbar.tsx
index 73041b2bf..67de60a0e 100644
--- a/src/scenes/Editor/Notebook/cells/CellToolbar.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellToolbar.tsx
@@ -12,8 +12,6 @@ import {
   CornersOutIcon,
   CornersInIcon,
   ArrowClockwiseIcon,
-  ArrowsOutLineVerticalIcon,
-  ArrowsInLineVerticalIcon,
   GearIcon,
   TableIcon,
   ChartLineIcon,
@@ -29,7 +27,7 @@ import {
   resolveAutoRefresh,
   resolveCellView,
 } from "../notebookUtils"
-import type { CellToolbarTier } from "../notebookUtils"
+import type { CellPaneLayout, CellToolbarTier } from "../notebookUtils"
 import type { AutoRefresh, NotebookCell } from "../../../../store/notebook"
 import { useNotebookActions, useNotebookBufferId } from "../NotebookProvider"
 import { useCellFetchState } from "../cellRefresh/CellRefreshContext"
@@ -39,9 +37,9 @@ import {
 } from "../../../../utils/notebooks/notebookAIBridge"
 import { eventBus } from "../../../../modules/EventBus"
 import { EventType } from "../../../../modules/EventBus/types"
-import { clearChartZoom } from "../cellVirtualization/chartZoomStore"
 import { trackEvent } from "../../../../modules/ConsoleEventTracker"
 import { ConsoleEvent } from "../../../../modules/ConsoleEventTracker/events"
+import { useCellViewActions } from "./useCellViewActions"
 
 const ToolbarWrapper = styled.div<{
   $inline?: boolean
@@ -73,9 +71,10 @@ type Props = {
   layoutMode: "list" | "grid"
   autoRefreshDefault?: AutoRefresh
   isMaximized: boolean
-  isRunning?: boolean
+  isCellBusy?: boolean
   inline?: boolean
   toolbarTier?: CellToolbarTier
+  paneLayout?: CellPaneLayout
   chartZoomed?: boolean
 }
 
@@ -87,9 +86,10 @@ export const CellToolbar: React.FC<Props> = ({
   layoutMode,
   autoRefreshDefault,
   isMaximized,
-  isRunning = false,
+  isCellBusy = false,
   inline,
   toolbarTier,
+  paneLayout,
   chartZoomed = false,
 }) => {
   const {
@@ -100,8 +100,6 @@ export const CellToolbar: React.FC<Props> = ({
     setFocusedCell,
     setMaximizedCellId,
     setCellRefresh,
-    setCellViewMaximized,
-    setCellMode,
   } = useNotebookActions()
   const bufferId = useNotebookBufferId()
 
@@ -114,7 +112,7 @@ export const CellToolbar: React.FC<Props> = ({
   const isChartView = view === "chart"
   const isGridView = view === "grid"
   const isNoneView = view === "none"
-  const isViewMaximized = !isNoneView && !!cell.isViewMaximized
+  const resultOnly = paneLayout === "result"
   const autoRefresh = resolveAutoRefresh(cell.autoRefresh, autoRefreshDefault)
   // A write cell never ticks, so the menu must not offer an interval the
   // engine would ignore — same gate the inline selector applies.
@@ -122,12 +120,23 @@ export const CellToolbar: React.FC<Props> = ({
     useCellFetchState(cellId)?.classifyBlock?.kind === "write"
   const [menuOpen, setMenuOpen] = useState(false)
   const moreActionsTooltip = useTriggerTooltip()
+  const {
+    viewTable: handleViewTable,
+    viewChart: handleViewChart,
+    toggleEditor: handleToggleEditor,
+    resetZoom: handleResetZoom,
+  } = useCellViewActions({
+    cellId,
+    view,
+    paneLayout: paneLayout ?? "split",
+    isCellBusy,
+    method: "menu",
+  })
 
   const {
-    showViewSql,
     showViewTable,
     showViewChart,
-    showSplitItem,
+    showEditorToggleItem,
     showResetZoom,
     showAutoRefreshItem,
     showRefreshItem,
@@ -142,62 +151,12 @@ export const CellToolbar: React.FC<Props> = ({
     tier: toolbarTier ?? "compact",
     view,
     isMarkdown,
-    // "View SQL" minimizes the chart/table to the editor without dropping data.
-    sqlShown: cell.isViewMaximized === false,
     chartZoomed,
     isGridMode,
     cellIndex,
     totalCells,
   })
 
-  // Minimize the chart/table to the editor, keeping the data on the cell.
-  const handleViewSql = () => {
-    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_CHANGE, {
-      to: "sql",
-      method: "menu",
-    })
-    signalUserEdit(bufferId)
-    setCellViewMaximized(cellId, false)
-  }
-  const handleViewTable = () => {
-    if (isRunning) return
-    signalUserEdit(bufferId)
-    if (isNoneView) {
-      eventBus.publish(EventType.NOTEBOOK_CELL_RUN, { cellId })
-      return
-    }
-    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_CHANGE, {
-      to: "grid",
-      method: "menu",
-    })
-    // A chart transfers its data to the grid (no re-query); restore the data
-    // pane in case the SQL was being shown.
-    if (isChartView) setCellMode(cellId, "run")
-    setCellViewMaximized(cellId, true)
-  }
-  const handleViewChart = () => {
-    if (isRunning) return
-    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_CHANGE, {
-      to: "chart",
-      method: "menu",
-    })
-    signalUserEdit(bufferId)
-    if (isNoneView || isGridView) {
-      // Entering draw can be refused (non-DQL SQL); maximize only once the
-      // draw actually takes, so a refused chart never maximizes the grid.
-      eventBus.publish(EventType.NOTEBOOK_CELL_DRAW, { cellId, maximize: true })
-      return
-    }
-    setCellViewMaximized(cellId, true)
-  }
-  const handleToggleMaximizeView = () => {
-    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_MAXIMIZE, {
-      isViewMaximized: !cell.isViewMaximized,
-      view,
-    })
-    signalUserEdit(bufferId)
-    setCellViewMaximized(cellId, !cell.isViewMaximized)
-  }
   const handleMaximizeCell = () => {
     void trackEvent(ConsoleEvent.NOTEBOOK_CELL_MAXIMIZE, {
       action: isMaximized ? "restore" : "maximize",
@@ -215,10 +174,6 @@ export const CellToolbar: React.FC<Props> = ({
     }
     eventBus.publish(EventType.NOTEBOOK_CELL_RUN, { cellId })
   }
-  const handleResetZoom = () => {
-    clearChartZoom(cellId)
-    eventBus.publish(EventType.NOTEBOOK_CELL_RESET_ZOOM, { cellId })
-  }
   const handleChartSettings = () => {
     void trackEvent(ConsoleEvent.NOTEBOOK_CHART_SETTINGS_OPEN, {
       chartType: cell.chartConfig?.queries.find((q) => q != null)?.type,
@@ -305,51 +260,52 @@ export const CellToolbar: React.FC<Props> = ({
           </Tooltip>
           <DropdownMenu.Portal>
             <DropdownMenu.Content align="end" sideOffset={4}>
-              {showViewSql && (
-                <DropdownMenu.Item
-                  onSelect={handleViewSql}
+              {showViewTable &&
+                (isNoneView ? (
+                  <DropdownMenu.Item
+                    onSelect={handleViewTable}
+                    disabled={isCellBusy}
+                    icon={<PlayIcon size={16} />}
+                  >
+                    Run
+                  </DropdownMenu.Item>
+                ) : (
+                  <DropdownMenu.CheckboxItem
+                    checked={isGridView}
+                    onSelect={handleViewTable}
+                    disabled={isCellBusy}
+                    icon={<TableIcon size={16} />}
+                  >
+                    View table
+                  </DropdownMenu.CheckboxItem>
+                ))}
+              {showViewChart &&
+                (isNoneView ? (
+                  <DropdownMenu.Item
+                    onSelect={handleViewChart}
+                    disabled={isCellBusy}
+                    icon={<ChartLineIcon size={16} />}
+                  >
+                    Draw
+                  </DropdownMenu.Item>
+                ) : (
+                  <DropdownMenu.CheckboxItem
+                    checked={isChartView}
+                    onSelect={handleViewChart}
+                    disabled={isCellBusy}
+                    icon={<ChartLineIcon size={16} />}
+                  >
+                    View chart
+                  </DropdownMenu.CheckboxItem>
+                ))}
+              {showEditorToggleItem && (
+                <DropdownMenu.CheckboxItem
+                  checked={!resultOnly}
+                  onSelect={handleToggleEditor}
                   icon={<FileSqlIcon size={16} />}
                 >
-                  View SQL
-                </DropdownMenu.Item>
-              )}
-              {showViewTable && (
-                <DropdownMenu.Item
-                  onSelect={handleViewTable}
-                  disabled={isRunning}
-                  icon={
-                    isNoneView ? (
-                      <PlayIcon size={16} />
-                    ) : (
-                      <TableIcon size={16} />
-                    )
-                  }
-                >
-                  {isNoneView ? "Run" : "View table"}
-                </DropdownMenu.Item>
-              )}
-              {showViewChart && (
-                <DropdownMenu.Item
-                  onSelect={handleViewChart}
-                  disabled={isRunning}
-                  icon={<ChartLineIcon size={16} />}
-                >
-                  {isNoneView ? "Draw" : "View chart"}
-                </DropdownMenu.Item>
-              )}
-              {showSplitItem && (
-                <DropdownMenu.Item
-                  onSelect={handleToggleMaximizeView}
-                  icon={
-                    isViewMaximized ? (
-                      <ArrowsInLineVerticalIcon size={16} />
-                    ) : (
-                      <ArrowsOutLineVerticalIcon size={16} />
-                    )
-                  }
-                >
-                  {isViewMaximized ? "Split view" : "Maximized view"}
-                </DropdownMenu.Item>
+                  Show editor
+                </DropdownMenu.CheckboxItem>
               )}
 
               {groupAHasItems && <DropdownMenu.Divider />}
diff --git a/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx b/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
index f1ca2eabe..1bfe686cf 100644
--- a/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
@@ -1,34 +1,31 @@
 import React from "react"
 import styled from "styled-components"
-import {
-  TableIcon,
-  ArrowsOutLineVerticalIcon,
-  ArrowsInLineVerticalIcon,
-} from "@phosphor-icons/react"
+import { FileSqlIcon, TableIcon } from "@phosphor-icons/react"
 import { Reset } from "../../../../components/icons"
 import { Spinner } from "./Spinner"
 import { ChartIcon } from "./ChartIcon"
-import { IconButton, Tooltip } from "../../../../components"
+import {
+  IconButton,
+  PrimaryToggleButton,
+  Tooltip,
+} from "../../../../components"
 import {
   NotebookViewToggle,
   NotebookViewToggleSegment,
 } from "../NotebookViewToggle"
-import { useNotebookActions, useNotebookBufferId } from "../NotebookProvider"
-import { signalUserEdit } from "../../../../utils/notebooks/notebookAIBridge"
-import { eventBus } from "../../../../modules/EventBus"
-import { EventType } from "../../../../modules/EventBus/types"
-import { clearChartZoom } from "../cellVirtualization/chartZoomStore"
-import type { CellView } from "../notebookUtils"
-import { trackEvent } from "../../../../modules/ConsoleEventTracker"
-import { ConsoleEvent } from "../../../../modules/ConsoleEventTracker/events"
+import type { CellPaneLayout, CellView } from "../notebookUtils"
+import { useCellViewActions } from "./useCellViewActions"
 
 const DimSpinner = styled(Spinner)`
   opacity: 0.5;
 `
 
-// This control predates the general 3.4rem icon-button size and sits beside
-// the cell toolbar in a tightly constrained header. Preserve its original
-// 3rem height so the two control groups retain their vertical separation.
+const ViewActions = styled.div`
+  display: inline-flex;
+  align-items: center;
+`
+
+// Reset remains a compact auxiliary action beside the view controls.
 const ViewIconButton = styled(IconButton)`
   width: 4rem;
   min-width: 4rem;
@@ -44,34 +41,70 @@ const ViewIconButton = styled(IconButton)`
 const Divider = styled.div`
   width: 1px;
   align-self: stretch;
-  margin: 0.2rem 0;
+  margin: 0.3rem 0.6rem;
   background: ${({ theme }) => theme.color.interactionNeutral};
 `
 
+// Match the schema toolbar's auto-refresh toggle dimensions and interaction.
+// The pressed state wears the same glass lens as the active segments and
+// tabs (SegmentedControl's GlassSelection), so one cue marks every active
+// control in the header. The transparent border reserves the lens's box so
+// toggling never shifts layout.
+const EditorVisibilityToggle = styled(PrimaryToggleButton)`
+  &&:not(:disabled) {
+    width: auto;
+    padding: 0 1rem;
+    height: 3rem;
+    min-height: 3rem;
+    color: ${({ theme }) => theme.color.contentSecondary};
+    border: 1px solid ${({ theme }) => theme.color.transparent};
+    border-bottom-width: 2px;
+    border-radius: 0.4rem;
+  }
+
+  &&[data-selected="true"],
+  &&[data-selected="true"]:hover:not(:disabled) {
+    background: ${({ theme }) => theme.color.glassSurface};
+    color: ${({ theme }) => theme.color.contentPrimary};
+    border-color: ${({ theme }) => theme.color.glassBorder};
+    border-bottom-color: ${({ theme }) => theme.color.glassEdge};
+    box-shadow: 0 3px 9px ${({ theme }) => theme.color.shadowSoft};
+    backdrop-filter: blur(6px) saturate(145%);
+    -webkit-backdrop-filter: blur(5px) saturate(150%);
+  }
+`
+
 type Props = {
   cellId: string
   view: CellView
-  isViewMaximized: boolean
+  paneLayout: CellPaneLayout
   isGridLoading: boolean
   isChartLoading: boolean
-  isRunning: boolean
+  isCellBusy: boolean
   chartZoomed: boolean
   showLabels: boolean
+  onResetZoomFocus?: () => void
 }
 
 export const CellViewToggle: React.FC<Props> = ({
   cellId,
   view,
-  isViewMaximized,
+  paneLayout,
   isGridLoading,
   isChartLoading,
-  isRunning,
+  isCellBusy,
   chartZoomed,
   showLabels,
+  onResetZoomFocus,
 }) => {
-  const { setCellViewMaximized, setCellMode, clearCellResult } =
-    useNotebookActions()
-  const bufferId = useNotebookBufferId()
+  const resultOnly = paneLayout === "result"
+  const { viewTable, viewChart, toggleEditor, resetZoom } = useCellViewActions({
+    cellId,
+    view,
+    paneLayout,
+    isCellBusy,
+    method: "toggle",
+  })
 
   // Clicking the active segment toggles it off, wiping the result back to the
   // empty "none" state. Switching between grid and chart re-renders the same
@@ -80,97 +113,76 @@ export const CellViewToggle: React.FC<Props> = ({
   // mode back, where the grid shows the chart's last frame.
   const handleChart = (e: React.MouseEvent) => {
     e.stopPropagation()
-    if (isRunning) return
-    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_CHANGE, {
-      to: view === "chart" ? "none" : "chart",
-      method: "toggle",
-    })
-    signalUserEdit(bufferId)
-    eventBus.publish(EventType.NOTEBOOK_CELL_DRAW, { cellId })
+    viewChart()
   }
   const handleTable = (e: React.MouseEvent) => {
     e.stopPropagation()
-    if (isRunning) return
-    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_CHANGE, {
-      to: view === "grid" ? "none" : "grid",
-      method: "toggle",
-    })
-    signalUserEdit(bufferId)
-    if (view === "grid") {
-      clearCellResult(cellId)
-      return
-    }
-    setCellMode(cellId, "run")
+    viewTable()
   }
-  const handleSplit = (e: React.MouseEvent) => {
+  const handleEditorVisibility = (e: React.MouseEvent) => {
     e.stopPropagation()
-    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_MAXIMIZE, {
-      isViewMaximized: !isViewMaximized,
-      view,
-    })
-    signalUserEdit(bufferId)
-    setCellViewMaximized(cellId, !isViewMaximized)
+    toggleEditor()
   }
   const handleResetZoom = (e: React.MouseEvent) => {
     e.stopPropagation()
-    clearChartZoom(cellId)
-    eventBus.publish(EventType.NOTEBOOK_CELL_RESET_ZOOM, { cellId })
+    resetZoom()
+    onResetZoomFocus?.()
   }
 
   return (
-    <NotebookViewToggle role="group" aria-label="Cell result view">
-      <Tooltip content="Table">
-        <NotebookViewToggleSegment
-          type="button"
-          $size="md"
-          $active={view === "grid"}
-          $activeTone="neutral"
-          aria-pressed={view === "grid"}
-          aria-busy={view === "grid" && isGridLoading}
-          disabled={isRunning}
-          onClick={handleTable}
-          aria-label="View table"
-        >
-          {view === "grid" && isGridLoading ? (
-            <DimSpinner size={18} />
-          ) : (
-            <TableIcon />
-          )}
-          {showLabels && "Table"}
-        </NotebookViewToggleSegment>
-      </Tooltip>
-      <Tooltip content="Chart">
-        <NotebookViewToggleSegment
-          type="button"
-          $size="md"
-          $active={view === "chart"}
-          $activeTone="neutral"
-          aria-pressed={view === "chart"}
-          aria-busy={view === "chart" && isChartLoading}
-          disabled={isRunning}
-          onClick={handleChart}
-          aria-label="View chart"
-        >
-          {view === "chart" && isChartLoading ? (
-            <DimSpinner size={18} />
-          ) : (
-            <ChartIcon />
-          )}
-          {showLabels && "Chart"}
-        </NotebookViewToggleSegment>
-      </Tooltip>
+    <ViewActions>
+      <NotebookViewToggle role="group" aria-label="Cell result view">
+        <Tooltip content="Table">
+          <NotebookViewToggleSegment
+            type="button"
+            $size="md"
+            $active={view === "grid"}
+            $activeTone="neutral"
+            aria-pressed={view === "grid"}
+            aria-busy={view === "grid" && isGridLoading}
+            disabled={isCellBusy}
+            onClick={handleTable}
+            aria-label="View table"
+          >
+            {view === "grid" && isGridLoading ? (
+              <DimSpinner size={18} />
+            ) : (
+              <TableIcon />
+            )}
+            {showLabels && "Table"}
+          </NotebookViewToggleSegment>
+        </Tooltip>
+        <Tooltip content="Chart">
+          <NotebookViewToggleSegment
+            type="button"
+            $size="md"
+            $active={view === "chart"}
+            $activeTone="neutral"
+            aria-pressed={view === "chart"}
+            aria-busy={view === "chart" && isChartLoading}
+            disabled={isCellBusy}
+            onClick={handleChart}
+            aria-label="View chart"
+          >
+            {view === "chart" && isChartLoading ? (
+              <DimSpinner size={18} />
+            ) : (
+              <ChartIcon />
+            )}
+            {showLabels && "Chart"}
+          </NotebookViewToggleSegment>
+        </Tooltip>
+      </NotebookViewToggle>
       <Divider />
-      <Tooltip content={isViewMaximized ? "Split view" : "Maximize view"}>
-        <ViewIconButton
-          label={isViewMaximized ? "Split view" : "Maximize view"}
-          onClick={handleSplit}
+      <Tooltip content={resultOnly ? "Show editor" : "Hide editor"}>
+        <EditorVisibilityToggle
+          aria-label="Editor"
+          aria-pressed={!resultOnly}
+          onClick={handleEditorVisibility}
+          selected={!resultOnly}
         >
-          {isViewMaximized ? (
-            <ArrowsInLineVerticalIcon />
-          ) : (
-            <ArrowsOutLineVerticalIcon />
-          )}
-        </ViewIconButton>
+          <FileSqlIcon size={18} />
+        </EditorVisibilityToggle>
       </Tooltip>
       {view === "chart" && chartZoomed && (
         <Tooltip content="Reset zoom">
@@ -179,6 +191,6 @@ export const CellViewToggle: React.FC<Props> = ({
           </ViewIconButton>
         </Tooltip>
       )}
-    </NotebookViewToggle>
+    </ViewActions>
   )
 }
diff --git a/src/scenes/Editor/Notebook/cells/CellWideActions.tsx b/src/scenes/Editor/Notebook/cells/CellWideActions.tsx
index c7df6a877..9f2c9f0f4 100644
--- a/src/scenes/Editor/Notebook/cells/CellWideActions.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellWideActions.tsx
@@ -2,6 +2,7 @@ import React from "react"
 import { CellViewToggle } from "./CellViewToggle"
 import { CellRefreshButton } from "./CellRefreshButton"
 import type { AutoRefresh } from "../../../../store/notebook"
+import type { CellPaneLayout } from "../notebookUtils"
 
 type Props = {
   cellId: string
@@ -10,12 +11,14 @@ type Props = {
   view: "grid" | "chart"
   cellAutoRefresh: AutoRefresh | undefined
   autoRefreshDefault: AutoRefresh | undefined
-  isViewMaximized: boolean
+  paneLayout: CellPaneLayout
   isRunning: boolean
   isGridLoading: boolean
   isChartLoading: boolean
   isChartRefreshing: boolean
+  isCellBusy: boolean
   chartZoomed: boolean
+  onResetZoomFocus?: () => void
 }
 
 export const CellWideActions: React.FC<Props> = ({
@@ -23,12 +26,14 @@ export const CellWideActions: React.FC<Props> = ({
   view,
   cellAutoRefresh,
   autoRefreshDefault,
-  isViewMaximized,
+  paneLayout,
   isRunning,
   isGridLoading,
   isChartLoading,
   isChartRefreshing,
+  isCellBusy,
   chartZoomed,
+  onResetZoomFocus,
 }) => (
   <>
     {/* Hide the refresh control until the first result lands — while loading,
@@ -49,12 +54,13 @@ export const CellWideActions: React.FC<Props> = ({
     <CellViewToggle
       cellId={cellId}
       view={view}
-      isViewMaximized={isViewMaximized}
+      paneLayout={paneLayout}
       isGridLoading={isGridLoading}
       isChartLoading={isChartLoading}
-      isRunning={isRunning}
+      isCellBusy={isCellBusy}
       chartZoomed={chartZoomed}
       showLabels
+      onResetZoomFocus={onResetZoomFocus}
     />
   </>
 )
diff --git a/src/scenes/Editor/Notebook/cells/MarkdownCell.tsx b/src/scenes/Editor/Notebook/cells/MarkdownCell.tsx
index ecda9b148..0bb4e99d5 100644
--- a/src/scenes/Editor/Notebook/cells/MarkdownCell.tsx
+++ b/src/scenes/Editor/Notebook/cells/MarkdownCell.tsx
@@ -28,6 +28,7 @@ import { ctrlCmd } from "../../../../utils/platform"
 import {
   hasAgentVisibleCellHeightChanged,
   MIN_MARKDOWN_HEIGHT_PX,
+  MAX_PANE_HEIGHT_PX,
   snapMarkdownTopHeight,
 } from "../notebookUtils"
 
@@ -445,6 +446,8 @@ const MarkdownCellInner: React.FC<Props> = ({
             heightResize.resetHeight()
           }}
           minHeight={MIN_MARKDOWN_HEIGHT_PX}
+          maxHeight={MAX_PANE_HEIGHT_PX}
+          ariaLabel="Resize markdown pane"
         />
       </CellShell>
     )
diff --git a/src/scenes/Editor/Notebook/cells/useCellResize.ts b/src/scenes/Editor/Notebook/cells/useCellResize.ts
index 548175c7a..aa60e5575 100644
--- a/src/scenes/Editor/Notebook/cells/useCellResize.ts
+++ b/src/scenes/Editor/Notebook/cells/useCellResize.ts
@@ -1,4 +1,5 @@
 import { useCallback, useState } from "react"
+import { clampPaneHeight } from "../notebookUtils"
 
 export type ResizeController = {
   /** Live drag value that should override any persisted height. Null when idle. */
@@ -19,14 +20,14 @@ export const useCellResize = (
   const [liveHeight, setLiveHeight] = useState<number | null>(null)
 
   const resizeLive = useCallback(
-    (height: number) => setLiveHeight(Math.max(minHeight, height)),
+    (height: number) => setLiveHeight(clampPaneHeight(minHeight, height)),
     [minHeight],
   )
 
   const resizeEnd = useCallback(
     (height: number) => {
       setLiveHeight(null)
-      commit(Math.max(minHeight, height))
+      commit(clampPaneHeight(minHeight, height))
     },
     [minHeight, commit],
   )
diff --git a/src/scenes/Editor/Notebook/cells/useCellResizeOrchestration.ts b/src/scenes/Editor/Notebook/cells/useCellResizeOrchestration.ts
index 64e2cf6ce..262e10e9b 100644
--- a/src/scenes/Editor/Notebook/cells/useCellResizeOrchestration.ts
+++ b/src/scenes/Editor/Notebook/cells/useCellResizeOrchestration.ts
@@ -8,18 +8,18 @@ import { EventType } from "../../../../modules/EventBus/types"
 import { trackEvent } from "../../../../modules/ConsoleEventTracker"
 import { ConsoleEvent } from "../../../../modules/ConsoleEventTracker/events"
 import {
+  MAX_PANE_HEIGHT_PX,
+  clampPaneHeight,
   computeCellHeights,
   hasAgentVisibleCellHeightChanged,
-  MIN_BOTTOM_HEIGHT_PX,
+  minBottomHeightFor,
   partitionCellHeights,
-  scaleCellHeights,
   topHeightForSql,
 } from "../notebookUtils"
 
-// Minimum content area heights. `MIN_EDITOR_HEIGHT` matches Monaco's reported
-// content height for an empty editor (one line + padding); the previous
-// `MAX_EDITOR_HEIGHT` cap is gone — the editor now auto-grows freely with
-// pasted content (user-confirmed: unbounded).
+// `MIN_EDITOR_HEIGHT` matches Monaco's reported content height for an empty
+// editor (one line + padding). The editor auto-grows with content up to the
+// shared pane ceiling and scrolls inside past it.
 export const MIN_EDITOR_HEIGHT = 72
 
 type Options = {
@@ -34,7 +34,7 @@ type Options = {
 }
 
 // Every way a cell's editor / result split can be resized — the inner split
-// handle, the bottom-edge handle, the maximized-chart handle, the spotlight
+// handle, the bottom-edge handle, the spotlight
 // ratio, and their double-click resets — plus the derived top/bottom heights
 // the layout renders from.
 export const useCellResizeOrchestration = ({
@@ -57,7 +57,7 @@ export const useCellResizeOrchestration = ({
   const readResetTopHeight = useCallback(() => {
     const contentHeight = getEditorContentHeight()
     return contentHeight != null
-      ? Math.max(MIN_EDITOR_HEIGHT, contentHeight)
+      ? clampPaneHeight(MIN_EDITOR_HEIGHT, contentHeight)
       : topHeightForSql(cell.value)
   }, [cell.value, getEditorContentHeight])
 
@@ -90,7 +90,7 @@ export const useCellResizeOrchestration = ({
     }, [cell.id, readResetTopHeight, updateCell]),
   )
   const bottomResize = useCellResize(
-    MIN_BOTTOM_HEIGHT_PX,
+    minBottomHeightFor(cell),
     useCallback(
       (height: number) =>
         updateCell(cell.id, { bottomHeight: height, bottomResized: true }),
@@ -108,6 +108,9 @@ export const useCellResizeOrchestration = ({
     liveBottomHeight: bottomResize.liveHeight,
     expectingResult,
   })
+  const middleMaxHeight = isMaximized
+    ? MAX_PANE_HEIGHT_PX
+    : topHeight + bottomHeight - minBottomHeightFor(cell)
 
   const spotlightEditorRatio =
     spotlightLiveRatio ??
@@ -127,7 +130,7 @@ export const useCellResizeOrchestration = ({
       middleSum(),
       height,
       MIN_EDITOR_HEIGHT,
-      MIN_BOTTOM_HEIGHT_PX,
+      minBottomHeightFor(cell),
     )
     if (isMaximized) {
       setSpotlightLiveRatio(top / (top + bottom))
@@ -143,7 +146,7 @@ export const useCellResizeOrchestration = ({
       middleSum(),
       height,
       MIN_EDITOR_HEIGHT,
-      MIN_BOTTOM_HEIGHT_PX,
+      minBottomHeightFor(cell),
     )
     if (isMaximized) {
       setSpotlightLiveRatio(null)
@@ -206,33 +209,6 @@ export const useCellResizeOrchestration = ({
     updateCell,
   ])
 
-  // When a chart is maximized the BottomSlot fills the whole cell, so its
-  // measured height IS the cell total — scale top/bottom to that new total
-  // (preserving the split so it's intact when the chart is restored).
-  const maximizedChartResizeLive = (newTotalHeight: number) => {
-    const { top, bottom } = scaleCellHeights(
-      topHeight,
-      bottomHeight,
-      newTotalHeight,
-      MIN_EDITOR_HEIGHT,
-      MIN_BOTTOM_HEIGHT_PX,
-    )
-    topResize.resizeLive(top)
-    bottomResize.resizeLive(bottom)
-  }
-
-  const maximizedChartResizeEnd = (newTotalHeight: number) => {
-    const { top, bottom } = scaleCellHeights(
-      topHeight,
-      bottomHeight,
-      newTotalHeight,
-      MIN_EDITOR_HEIGHT,
-      MIN_BOTTOM_HEIGHT_PX,
-    )
-    topResize.resizeEnd(top)
-    bottomResize.resizeEnd(bottom)
-  }
-
   useEffect(() => {
     const handler = (payload?: { cellId?: string }) => {
       if (payload?.cellId !== cell.id) return
@@ -249,11 +225,10 @@ export const useCellResizeOrchestration = ({
     spotlightEditorRatio,
     topResize,
     bottomResize,
+    middleMaxHeight,
     middleResizeLive,
     middleResizeEnd,
     resetToDefaults,
     resetBottomArea,
-    maximizedChartResizeLive,
-    maximizedChartResizeEnd,
   }
 }
diff --git a/src/scenes/Editor/Notebook/cells/useCellRunActions.ts b/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
index 06085116b..3d00bfdd1 100644
--- a/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
+++ b/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
@@ -4,7 +4,6 @@ import type { NotebookCell } from "../../../../store/notebook"
 import { useNotebookActions, useNotebookBufferId } from "../NotebookProvider"
 import { useCellRefresh } from "../cellRefresh/CellRefreshContext"
 import { useLocalStorage } from "../../../../providers/LocalStorageProvider"
-import { useValidateWithGlobals } from "../globals/useValidateWithGlobals"
 import {
   getQueryFromCursor,
   normalizeQueryText,
@@ -12,12 +11,8 @@ import {
   type SelectionRunResolution,
 } from "../../Monaco/utils"
 import { resolveActiveStatementSql, resolveRunAction } from "../notebookUtils"
-import {
-  emitUserAction,
-  signalUserEdit,
-} from "../../../../utils/notebooks/notebookAIBridge"
+import { emitUserAction } from "../../../../utils/notebooks/notebookAIBridge"
 import { createRunStatus, type RanStatus } from "../../../../utils/ai/runStatus"
-import { requireAllDQL } from "../../../../utils/tools/permissions"
 import { toast } from "../../../../components/Toast"
 import { eventBus } from "../../../../modules/EventBus"
 import { EventType } from "../../../../modules/EventBus/types"
@@ -27,8 +22,6 @@ import { ConsoleEvent } from "../../../../modules/ConsoleEventTracker/events"
 type Options = {
   cell: NotebookCell
   isRunning: boolean
-  isCompactTier: boolean
-  showBottomSlot: boolean
   editorRef: React.MutableRefObject<editor.IStandaloneCodeEditor | null>
   applyHighlight: (ok: boolean) => void
   clearHighlight: () => void
@@ -45,28 +38,24 @@ type RunRequest = { kind: "all" } | { kind: "single"; source: SingleRunSource }
 export const useCellRunActions = ({
   cell,
   isRunning,
-  isCompactTier,
-  showBottomSlot,
   editorRef,
   applyHighlight,
   clearHighlight,
 }: Options) => {
   const {
     runCell,
+    validateForDraw,
     setCellMode,
     clearCellResult,
-    setCellViewMaximized,
     getCellsSnapshot,
   } = useNotebookActions()
   const bufferIdForEvents = useNotebookBufferId()
-  const validateWithGlobals = useValidateWithGlobals()
   const { runWithSelectionMode } = useLocalStorage()
   const isDrawMode = cell.mode === "draw"
 
   // A run from the Run toggle spins the Run segment; a run from the refresh
   // button spins the refresh button instead.
   const firstRunRef = useRef(false)
-  const validatingDrawRef = useRef(false)
 
   // Returns true only when the cell actually entered draw mode, so a caller can
   // apply chart-only follow-ups (e.g. maximize) without affecting a cell whose
@@ -84,37 +73,34 @@ export const useCellRunActions = ({
       })
       return false
     }
-    if (validatingDrawRef.current) return false
-    validatingDrawRef.current = true
-    try {
-      const decision = await requireAllDQL(cell.value, (s) =>
-        validateWithGlobals(s),
-      )
-      if (!decision.granted) {
+    // A draw from an empty cell is its first run: the gate's validation is
+    // the phase the Stop button can end.
+    firstRunRef.current = cell.result == null
+    const gate = await validateForDraw(cell.id)
+    if (!gate.granted) {
+      if (gate.reason !== undefined) {
         void trackEvent(ConsoleEvent.NOTEBOOK_DRAW_REFUSED)
-        toast.error(decision.reason)
-        return false
+        toast.error(gate.reason)
       }
-      setCellMode(cell.id, "draw")
-      emitUserAction({
-        kind: "user_changed_cell_mode",
-        bufferId: bufferIdForEvents,
-        cellId: cell.id,
-        mode: "draw",
-      })
-      return true
-    } finally {
-      validatingDrawRef.current = false
+      return false
     }
+    setCellMode(cell.id, "draw")
+    emitUserAction({
+      kind: "user_changed_cell_mode",
+      bufferId: bufferIdForEvents,
+      cellId: cell.id,
+      mode: "draw",
+    })
+    return true
   }, [
     cell.id,
-    cell.value,
+    cell.result,
     isRunning,
     isDrawMode,
     setCellMode,
     clearCellResult,
+    validateForDraw,
     bufferIdForEvents,
-    validateWithGlobals,
   ])
 
   const tryRunSelection = useCallback((): SelectionRunResolution["kind"] => {
@@ -218,8 +204,8 @@ export const useCellRunActions = ({
   const runResolved = useCallback(
     (request: RunRequest) => {
       const plan = resolveRunAction(
-        { mode: cell.mode, result: cell.result },
-        { isCompactTier, showBottomSlot, intent: request.kind },
+        { mode: cell.mode },
+        { intent: request.kind },
       )
       if (plan.kind === "noop") return
       if (plan.kind === "chart") {
@@ -230,36 +216,14 @@ export const useCellRunActions = ({
         })
         return
       }
-      const exitDrawMode = () => {
-        if (!plan.exitDraw) return
-        signalUserEdit(bufferIdForEvents)
-        setCellMode(cell.id, "run")
-      }
       firstRunRef.current = cell.result == null
       if (request.kind === "all") {
-        exitDrawMode()
         void handleRunAll()
-        if (plan.reveal) setCellViewMaximized(cell.id, true)
         return
       }
-      // A single run that finds nothing to run leaves the cell untouched —
-      // a draw cell keeps its chart instead of dropping to the grid.
-      if (!handleRunSingle(request.source)) return
-      exitDrawMode()
-      if (plan.reveal) setCellViewMaximized(cell.id, true)
+      handleRunSingle(request.source)
     },
-    [
-      cell.id,
-      cell.mode,
-      cell.result,
-      bufferIdForEvents,
-      isCompactTier,
-      showBottomSlot,
-      setCellViewMaximized,
-      setCellMode,
-      handleRunAll,
-      handleRunSingle,
-    ],
+    [cell.id, cell.mode, cell.result, handleRunAll, handleRunSingle],
   )
   const runAll = useCallback(() => runResolved({ kind: "all" }), [runResolved])
   const runSingleFromEditor = useCallback(
@@ -310,11 +274,9 @@ export const useCellRunActions = ({
       if (payload?.cellId !== cell.id) return
       refreshRun()
     }
-    const drawHandler = (payload?: { cellId?: string; maximize?: boolean }) => {
+    const drawHandler = (payload?: { cellId?: string }) => {
       if (payload?.cellId !== cell.id) return
-      void handleDrawClick().then((entered) => {
-        if (entered && payload.maximize) setCellViewMaximized(cell.id, true)
-      })
+      void handleDrawClick()
     }
     eventBus.subscribe(EventType.NOTEBOOK_CELL_RUN, runHandler)
     eventBus.subscribe(EventType.NOTEBOOK_CELL_DRAW, drawHandler)
@@ -322,7 +284,7 @@ export const useCellRunActions = ({
       eventBus.unsubscribe(EventType.NOTEBOOK_CELL_RUN, runHandler)
       eventBus.unsubscribe(EventType.NOTEBOOK_CELL_DRAW, drawHandler)
     }
-  }, [cell.id, refreshRun, handleDrawClick, setCellViewMaximized])
+  }, [cell.id, refreshRun, handleDrawClick])
 
   const isGridLoading = isRunning && firstRunRef.current
 
diff --git a/src/scenes/Editor/Notebook/cells/useCellViewActions.ts b/src/scenes/Editor/Notebook/cells/useCellViewActions.ts
new file mode 100644
index 000000000..bedf8b5fa
--- /dev/null
+++ b/src/scenes/Editor/Notebook/cells/useCellViewActions.ts
@@ -0,0 +1,78 @@
+import { useCallback } from "react"
+import { eventBus } from "../../../../modules/EventBus"
+import { EventType } from "../../../../modules/EventBus/types"
+import { ConsoleEvent } from "../../../../modules/ConsoleEventTracker/events"
+import { trackEvent } from "../../../../modules/ConsoleEventTracker"
+import { signalUserEdit } from "../../../../utils/notebooks/notebookAIBridge"
+import { useNotebookActions, useNotebookBufferId } from "../NotebookProvider"
+import { clearChartZoom } from "../cellVirtualization/chartZoomStore"
+import type { CellPaneLayout, CellView } from "../notebookUtils"
+
+type CellViewActionMethod = "menu" | "toggle"
+
+type Params = {
+  cellId: string
+  view: CellView
+  paneLayout: CellPaneLayout
+  isCellBusy: boolean
+  method: CellViewActionMethod
+}
+
+export const useCellViewActions = ({
+  cellId,
+  view,
+  paneLayout,
+  isCellBusy,
+  method,
+}: Params) => {
+  const { setCellPaneView, setCellMode, clearCellResult } = useNotebookActions()
+  const bufferId = useNotebookBufferId()
+  const resultOnly = paneLayout === "result"
+
+  const viewTable = useCallback(() => {
+    if (isCellBusy) return
+    if (view === "none") {
+      signalUserEdit(bufferId)
+      eventBus.publish(EventType.NOTEBOOK_CELL_RUN, { cellId })
+      return
+    }
+
+    // Preserve the existing observable order on both surfaces: the compact
+    // menu signalled first, while the segmented toggle tracked first.
+    if (method === "menu") signalUserEdit(bufferId)
+    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_CHANGE, {
+      to: view === "grid" ? "none" : "grid",
+      method,
+    })
+    if (method === "toggle") signalUserEdit(bufferId)
+
+    if (view === "grid") clearCellResult(cellId)
+    else setCellMode(cellId, "run")
+  }, [bufferId, cellId, clearCellResult, isCellBusy, method, setCellMode, view])
+
+  const viewChart = useCallback(() => {
+    if (isCellBusy) return
+    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_CHANGE, {
+      to: view === "chart" ? "none" : "chart",
+      method,
+    })
+    signalUserEdit(bufferId)
+    eventBus.publish(EventType.NOTEBOOK_CELL_DRAW, { cellId })
+  }, [bufferId, cellId, isCellBusy, method, view])
+
+  const toggleEditor = useCallback(() => {
+    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_EDITOR_TOGGLE, {
+      editorShown: resultOnly,
+      view,
+    })
+    signalUserEdit(bufferId)
+    setCellPaneView(cellId, resultOnly ? "editor_result" : "result")
+  }, [bufferId, cellId, resultOnly, setCellPaneView, view])
+
+  const resetZoom = useCallback(() => {
+    clearChartZoom(cellId)
+    eventBus.publish(EventType.NOTEBOOK_CELL_RESET_ZOOM, { cellId })
+  }, [cellId])
+
+  return { viewTable, viewChart, toggleEditor, resetZoom }
+}
diff --git a/src/scenes/Editor/Notebook/index.tsx b/src/scenes/Editor/Notebook/index.tsx
index e68221c2c..6fc8be773 100644
--- a/src/scenes/Editor/Notebook/index.tsx
+++ b/src/scenes/Editor/Notebook/index.tsx
@@ -1,4 +1,11 @@
-import React, { useCallback, useEffect, useMemo, useRef, useState } from "react"
+import React, {
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react"
 import styled, { css } from "styled-components"
 import {
   ResponsiveGridLayout,
@@ -35,15 +42,11 @@ import { NotebookToolbar } from "./NotebookToolbar"
 import { NotebookMcpPromo } from "./NotebookMcpPromo"
 import { renderEdgeHandle } from "./resize"
 import {
-  cellChromePx,
-  cellHeightPatchForRows,
-  computeCellGridH,
+  paneHeightsFromGridRows,
+  computeCellGridBounds,
   generateDefaultLayout as generateDefaultLayoutPure,
-  isDoubleView,
   isExpectingResult,
   mergeCellLayout,
-  MIN_BOTTOM_HEIGHT_PX,
-  minTopHeightFor,
   NOTEBOOK_GRID_COLS,
   NOTEBOOK_GRID_MARGIN_Y,
   NOTEBOOK_GRID_ROW_HEIGHT,
@@ -135,7 +138,7 @@ const GridCellWrapper = React.forwardRef<HTMLDivElement, GridCellWrapperProps>(
   ),
 )
 
-const GridScrollContainer = styled.div<{ $suppressTransitions?: boolean }>`
+const GridScrollContainer = styled.div<{ $suppressTransitions: boolean }>`
   flex: 1;
   overflow-y: auto;
   padding: 3rem;
@@ -155,13 +158,18 @@ const GridScrollContainer = styled.div<{ $suppressTransitions?: boolean }>`
     opacity: 1;
   }
 
-  /* On first mount, react-grid-layout's items would otherwise animate from
-     their initial state to their computed position/size (the "expanding"
-     glitch). Kill the transition until the layout has settled; it's re-enabled
-     for drag/resize. */
+  /* Height is excluded: a pane switch mounts its content in the same commit
+     the item height changes, so the two must land together. */
+  .react-grid-item {
+    transition-property: left, top, width;
+  }
+
+  /* While the container is being resized the geometry tracks every frame;
+     react-grid-layout's stock transitions would chase each one. */
   ${({ $suppressTransitions }) =>
     $suppressTransitions &&
     css`
+      .react-grid-layout,
       .react-grid-item {
         transition: none !important;
       }
@@ -207,6 +215,23 @@ const LAYOUT_OPTS = {
 const generateDefaultLayout = (cells: { id: string }[]): CellLayoutItem[] =>
   generateDefaultLayoutPure(cells, LAYOUT_OPTS)
 
+const CONTAINER_RESIZE_SETTLE_MS = 200
+
+const useContainerResizeInFlight = (containerWidth: number): boolean => {
+  const [inFlight, setInFlight] = useState(true)
+
+  useLayoutEffect(() => {
+    setInFlight(true)
+    const timer = window.setTimeout(
+      () => setInFlight(false),
+      CONTAINER_RESIZE_SETTLE_MS,
+    )
+    return () => window.clearTimeout(timer)
+  }, [containerWidth])
+
+  return inFlight
+}
+
 const ADDED_CELL_SCROLL_SETTLE_MS = 250
 const ADDED_CELL_SCROLL_BOTTOM_GAP_PX = 20
 
@@ -398,27 +423,12 @@ const GridLayout: React.FC = () => {
     containerRef,
     mounted: gridMeasured,
   } = useContainerWidth({ measureBeforeMount: true })
+  const suppressTransitions = useContainerResizeInFlight(containerWidth)
   const autoScroll = useGridDragAutoScroll(
     containerRef as React.RefObject<HTMLElement>,
   )
   useScrollUserAddedCellIntoView()
 
-  // Suppress react-grid-layout's item transition until the grid has rendered
-  // and the width has settled, so cells don't animate into place on mount.
-  // Two frames cover the initial render + the ResizeObserver's first callback.
-  const [gridReady, setGridReady] = useState(false)
-  useEffect(() => {
-    if (!gridMeasured) return
-    let raf2 = 0
-    const raf1 = requestAnimationFrame(() => {
-      raf2 = requestAnimationFrame(() => setGridReady(true))
-    })
-    return () => {
-      cancelAnimationFrame(raf1)
-      cancelAnimationFrame(raf2)
-    }
-  }, [gridMeasured])
-
   // Derive each cell's grid h from topHeight + bottomHeight + chrome.
   // The h value in settings.layout is ignored on read — it's a stale
   // shadow that only matters when react-grid-layout consumes it. The
@@ -440,19 +450,14 @@ const GridLayout: React.FC = () => {
         cell,
         resultHydration?.statusOf(cell.id) ?? "unrequested",
       )
-      const minBottomPx =
-        isDoubleView(cell) || expectingResult ? MIN_BOTTOM_HEIGHT_PX : 0
-      const minTotalPx =
-        minTopHeightFor(cell) +
-        minBottomPx +
-        cellChromePx(cell, expectingResult)
-      const minH = Math.ceil(
-        (minTotalPx + GRID_MARGIN_Y) / (ROW_HEIGHT + GRID_MARGIN_Y),
-      )
       return {
         ...item,
-        h: computeCellGridH(cell, ROW_HEIGHT, GRID_MARGIN_Y, expectingResult),
-        minH,
+        ...computeCellGridBounds(
+          cell,
+          ROW_HEIGHT,
+          GRID_MARGIN_Y,
+          expectingResult,
+        ),
       }
     })
     return {
@@ -460,7 +465,7 @@ const GridLayout: React.FC = () => {
       layoutKey: computed
         .map(
           (item) =>
-            `${item.i}:${item.x}:${item.y}:${item.w}:${item.h}:${item.minH}`,
+            `${item.i}:${item.x}:${item.y}:${item.w}:${item.h}:${item.minH}:${item.maxH}`,
         )
         .join("|"),
     }
@@ -527,22 +532,22 @@ const GridLayout: React.FC = () => {
         void trackEvent(ConsoleEvent.NOTEBOOK_CELL_RESIZE, { region })
       }
       updateSettings({ layout: mapLayoutXYW(newLayout) })
-      const cellById = new Map(cells.map((c) => [c.id, c]))
-      for (const item of newLayout) {
-        const cell = cellById.get(item.i)
-        if (!cell) continue
-        // rgl reports every cell; the helper no-ops those whose h is unchanged.
-        const patch = cellHeightPatchForRows(
-          cell,
-          item.h,
-          ROW_HEIGHT,
-          GRID_MARGIN_Y,
-          isExpectingResult(
+      if (oldItem && newItem && oldItem.h !== newItem.h) {
+        const cell = cells.find((candidate) => candidate.id === newItem.i)
+        if (cell) {
+          const expectingResult = isExpectingResult(
             cell,
             resultHydration?.statusOf(cell.id) ?? "unrequested",
-          ),
-        )
-        if (Object.keys(patch).length > 0) updateCell(cell.id, patch)
+          )
+          const patch = paneHeightsFromGridRows(
+            cell,
+            newItem.h,
+            ROW_HEIGHT,
+            GRID_MARGIN_Y,
+            expectingResult,
+          )
+          if (Object.keys(patch).length > 0) updateCell(cell.id, patch)
+        }
       }
       if (typeof activeBuffer.id === "number") {
         emitUserAction({
@@ -606,7 +611,7 @@ const GridLayout: React.FC = () => {
     <GridScrollContainer
       ref={containerRef as React.RefObject<HTMLDivElement>}
       id="notebook-scroll-container"
-      $suppressTransitions={!gridReady}
+      $suppressTransitions={suppressTransitions}
       onMouseDown={(e) => {
         const target = e.target as HTMLElement
         const gridItem = target.closest<HTMLElement>("[data-cell-id]")
diff --git a/src/scenes/Editor/Notebook/notebookUtils.test.ts b/src/scenes/Editor/Notebook/notebookUtils.test.ts
index 9ac85852d..5f287bb77 100644
--- a/src/scenes/Editor/Notebook/notebookUtils.test.ts
+++ b/src/scenes/Editor/Notebook/notebookUtils.test.ts
@@ -1,6 +1,8 @@
 import { describe, it, expect } from "vitest"
 import {
   ApplyNotebookStateError,
+  agentCellDimensionsPatch,
+  agentCellPaneDimensions,
   buildAppliedNotebookState,
   attachScriptSummary,
   autoRefreshIntervalMs,
@@ -8,13 +10,15 @@ import {
   AUTO_REFRESH_OPTIONS,
   isAutoRefresh,
   resolveCellView,
+  agentCellPresentation,
+  resolveCellPaneLayout,
   resolveRunAction,
   buildAppliedCells,
   buildAppliedLayout,
   buildInitialScriptResults,
   buildPersistPayload,
   capResultBytes,
-  cellHeightPatchForRows,
+  paneHeightsFromGridRows,
   cellModeChangePatch,
   cellToolbarMenuFlags,
   cellToolbarTier,
@@ -27,6 +31,7 @@ import {
   computeAgentCellGridH,
   computeCellGridH,
   computeCellHeights,
+  computeCellGridBounds,
   computeResultBottomHeight,
   DEFAULT_CHART_BOTTOM_HEIGHT,
   duplicateCellAt,
@@ -51,10 +56,11 @@ import {
   derivePositionalFrame,
   deriveStatementFrame,
   resolveActiveStatementSql,
+  statementIdentityOfKey,
   statementKeysFor,
+  statementKeysForIdentities,
   removeCell,
   resolveRunCompletion,
-  scaleCellHeights,
   setResultAt,
   singleResultFromExec,
   snapMarkdownTopHeight,
@@ -331,6 +337,19 @@ describe("stripCellResults", () => {
     expect(out[1].result).toBeUndefined()
   })
 
+  it("normalizes legacy stored run mode away while preserving draw mode", () => {
+    const legacyRun = {
+      ...cell("run", "SELECT 1"),
+      mode: "run",
+    } as unknown as NotebookCell
+    const draw = { ...cell("draw", "SELECT 2"), mode: "draw" as const }
+
+    const [persistedRun, persistedDraw] = stripCellResults([legacyRun, draw])
+
+    expect("mode" in persistedRun).toBe(false)
+    expect(persistedDraw.mode).toBe("draw")
+  })
+
   // The stripped result is the only run signal an unmounted notebook can report
   // to the agent — record it so a committed write isn't read back as "none".
   it("records lastRunStatus from the result before stripping", () => {
@@ -383,7 +402,15 @@ describe("buildPersistPayload", () => {
       layoutMode: "list",
     })
     expect(payload).toEqual({
-      cells: [{ ...cells[0], result: undefined, lastRunStatus: "cancelled" }],
+      cells: [
+        {
+          ...cells[0],
+          result: undefined,
+          lastRunStatus: "cancelled",
+          lastRunError: undefined,
+          paneView: "editor_result",
+        },
+      ],
       focusedCellId: "a",
       maximizedCellId: undefined,
       settings: { layoutMode: "list" },
@@ -857,17 +884,71 @@ describe("buildAppliedCells", () => {
     expect(nextCells[0].lastRunStatus).toBe("success")
   })
 
-  it("reports resultsCleared when a run cell is converted to markdown", () => {
-    // Given a run cell with a live result
+  it("rejects turning an existing sql cell into markdown", () => {
+    // Given a sql cell
+    const prev: NotebookCell[] = [{ id: "a", position: 0, value: "x" }]
+    // When the apply re-sends its id with type markdown
+    // Then the request is refused
+    expect(() =>
+      buildAppliedCells(prev, {
+        cells: [{ id: "a", value: "x", type: "markdown" }],
+      }),
+    ).toThrow(/Cell "a" is sql; cell kind cannot change/)
+  })
+
+  it("rejects turning an existing markdown cell into sql", () => {
+    // Given a markdown cell
     const prev: NotebookCell[] = [
-      { id: "a", position: 0, value: "x", result: dql("x") },
+      { id: "a", position: 0, value: "# title", type: "markdown" },
     ]
-    // When the apply converts it to markdown without touching the text
-    const { resultsCleared } = buildAppliedCells(prev, {
-      cells: [{ id: "a", value: "x", type: "markdown" }],
+    // When the apply re-sends its id with type sql
+    // Then the request is refused
+    expect(() =>
+      buildAppliedCells(prev, {
+        cells: [{ id: "a", preserveValue: true, type: "sql" }],
+      }),
+    ).toThrow(/Cell "a" is markdown; cell kind cannot change/)
+  })
+
+  it("ignores view and result_height on a markdown cell", () => {
+    // Given an existing markdown cell
+    const prev: NotebookCell[] = [
+      { id: "a", position: 0, value: "# title", type: "markdown" },
+    ]
+    // When the apply sends a view and a result_height with the editor height
+    const { nextCells } = buildAppliedCells(prev, {
+      cells: [
+        {
+          id: "a",
+          preserveValue: true,
+          editorHeight: 86,
+          resultHeight: 300,
+          view: "result",
+        },
+      ],
     })
-    // Then its snapshot is flagged along with the dropped result
-    expect(resultsCleared).toEqual(["a"])
+    // Then only the editor height lands on the cell
+    expect(nextCells[0]).toMatchObject({ topHeight: 86, topResized: true })
+    expect(nextCells[0].bottomHeight).toBeUndefined()
+    expect(nextCells[0].paneView).toBeUndefined()
+  })
+
+  it("accepts an echoed kind on an existing cell", () => {
+    // Given a sql cell and a markdown cell
+    const prev: NotebookCell[] = [
+      { id: "a", position: 0, value: "x" },
+      { id: "b", position: 1, value: "# title", type: "markdown" },
+    ]
+    // When the apply repeats each cell's current kind
+    const { nextCells } = buildAppliedCells(prev, {
+      cells: [
+        { id: "a", preserveValue: true, type: "sql" },
+        { id: "b", preserveValue: true, type: "markdown" },
+      ],
+    })
+    // Then both cells keep their kind
+    expect(nextCells[0].type).toBeUndefined()
+    expect(nextCells[1].type).toBe("markdown")
   })
 
   it("preserves run history as lastRunStatus when a value change drops the result", () => {
@@ -887,7 +968,7 @@ describe("buildAppliedCells", () => {
       },
     ]
     const { nextCells } = buildAppliedCells(prev, {
-      cells: [{ id: "a", value: "INSERT INTO t  VALUES (1)" }],
+      cells: [{ id: "a", value: "INSERT INTO t VALUES (2)" }],
     })
     expect(nextCells[0].result).toBeNull()
     expect(nextCells[0].lastRunStatus).toBe("success")
@@ -920,6 +1001,152 @@ describe("buildAppliedCells", () => {
     expect(nextCells[0].lastRunError).toBe("boom")
   })
 
+  describe("mode change", () => {
+    const drawCell = (overrides: Partial<NotebookCell> = {}): NotebookCell => ({
+      id: "a",
+      position: 0,
+      value: "SELECT 1",
+      mode: "draw",
+      paneView: "editor_result",
+      chartConfig: { xColumn: null, queries: [null] },
+      bottomHeight: DEFAULT_CHART_BOTTOM_HEIGHT,
+      result: {
+        results: [
+          {
+            type: "dql",
+            query: "SELECT 1",
+            columns: [],
+            dataset: [],
+            count: 0,
+          },
+        ],
+        activeResultIndex: 0,
+        timestamp: 0,
+      },
+      ...overrides,
+    })
+    const runCell = (overrides: Partial<NotebookCell> = {}): NotebookCell => ({
+      id: "a",
+      position: 0,
+      value: "SELECT 1",
+      paneView: "editor_result",
+      bottomHeight: 180,
+      ...overrides,
+    })
+
+    it("validates a draw-to-run height against the table floor", () => {
+      // Given a draw cell
+      const prev = [drawCell()]
+      // When the apply switches it to run with a table-legal height
+      const { nextCells } = buildAppliedCells(prev, {
+        cells: [
+          {
+            id: "a",
+            value: "SELECT 1",
+            mode: "run",
+            view: "editor_result",
+            resultHeight: 100,
+          },
+        ],
+      })
+      // Then the apply succeeds and the height is pinned
+      expect(nextCells[0].mode).toBeUndefined()
+      expect(nextCells[0].bottomHeight).toBe(100)
+      expect(nextCells[0].bottomResized).toBe(true)
+    })
+
+    it("validates a run-to-draw height against the chart floor", () => {
+      // Given a run cell
+      const prev = [runCell()]
+      // When the apply switches it to draw with a height below the chart floor
+      const apply = () =>
+        buildAppliedCells(prev, {
+          cells: [
+            {
+              id: "a",
+              value: "SELECT 1",
+              mode: "draw",
+              chartConfig: { xColumn: null, queries: [null] },
+              resultHeight: 100,
+            },
+          ],
+        })
+      // Then the chart minimum applies
+      expect(apply).toThrowError(/minimum is 296px/)
+    })
+
+    it("re-derives an unpinned height when draw becomes run", () => {
+      // Given a draw cell whose height is the draw seed, not a user pin
+      const prev = [drawCell()]
+      // When the apply switches it to run and preserves the height
+      const { nextCells } = buildAppliedCells(prev, {
+        cells: [
+          { id: "a", value: "SELECT 1", mode: "run", resultHeight: null },
+        ],
+      })
+      // Then the table height follows the carried result
+      const next = nextCells[0]
+      expect(next.bottomHeight).toBe(
+        computeResultBottomHeight(next.result, next.value),
+      )
+      expect(next.bottomHeight).not.toBe(DEFAULT_CHART_BOTTOM_HEIGHT)
+      expect(next.bottomResized).toBeFalsy()
+    })
+
+    it("re-seeds an unpinned height when run becomes draw", () => {
+      // Given a run cell with a result-derived height
+      const prev = [runCell()]
+      // When the apply switches it to draw and preserves the height
+      const { nextCells } = buildAppliedCells(prev, {
+        cells: [
+          {
+            id: "a",
+            value: "SELECT 1",
+            mode: "draw",
+            chartConfig: { xColumn: null, queries: [null] },
+            resultHeight: null,
+          },
+        ],
+      })
+      // Then the chart starts at its default height
+      expect(nextCells[0].bottomHeight).toBe(DEFAULT_CHART_BOTTOM_HEIGHT)
+    })
+
+    it("keeps a pinned height across a mode change", () => {
+      // Given a draw cell the user resized
+      const prev = [drawCell({ bottomHeight: 640, bottomResized: true })]
+      // When the apply switches it to run and preserves the height
+      const { nextCells } = buildAppliedCells(prev, {
+        cells: [
+          { id: "a", value: "SELECT 1", mode: "run", resultHeight: null },
+        ],
+      })
+      // Then the pin survives
+      expect(nextCells[0].bottomHeight).toBe(640)
+      expect(nextCells[0].bottomResized).toBe(true)
+    })
+
+    it("keeps the stored height when the mode does not change", () => {
+      // Given a draw cell
+      const prev = [drawCell()]
+      // When the apply keeps it in draw mode
+      const { nextCells } = buildAppliedCells(prev, {
+        cells: [
+          {
+            id: "a",
+            value: "SELECT 1",
+            mode: "draw",
+            chartConfig: { xColumn: null, queries: [null] },
+            resultHeight: null,
+          },
+        ],
+      })
+      // Then nothing re-seeds
+      expect(nextCells[0].bottomHeight).toBe(DEFAULT_CHART_BOTTOM_HEIGHT)
+      expect(nextCells[0].bottomResized).toBeFalsy()
+    })
+  })
+
   it("keeps a released cell's persisted run history when the SQL changes", () => {
     // Given a passive cell whose outcome survives only as persisted run history
     const prev: NotebookCell[] = [
@@ -1033,16 +1260,12 @@ describe("buildAppliedCells", () => {
     expect(nextCells[0].value).toBe(hugeValue)
   })
 
-  it("rejects preserving an over-limit markdown cell flipped to sql", () => {
-    const hugeValue = Array(100_000).fill("x").join("\n")
-    const prev: NotebookCell[] = [
-      { id: "a", position: 0, value: hugeValue, type: "markdown" },
-    ]
+  it("rejects grid placement that extends beyond the notebook columns", () => {
     expect(() =>
-      buildAppliedCells(prev, {
-        cells: [{ id: "a", preserveValue: true, type: "sql" }],
+      buildAppliedCells([], {
+        cells: [{ value: "SELECT 1", grid: { x: 11, y: 0, w: 2 } }],
       }),
-    ).toThrow(/line limit/)
+    ).toThrow(/x \+ w must be at most 12/)
   })
 
   it("deletes cells whose ids are missing from the request", () => {
@@ -1187,7 +1410,7 @@ describe("buildAppliedCells", () => {
     expect(nextCells[0].chartConfig?.queries).toHaveLength(2)
   })
 
-  it("defaults isViewMaximized to true and stores no autoRefresh key on new draw cells", () => {
+  it("defaults a new draw cell to result and stores no autoRefresh key", () => {
     const { nextCells } = buildAppliedCells([], {
       cells: [
         {
@@ -1202,7 +1425,176 @@ describe("buildAppliedCells", () => {
     })
     // No stored key: the cell inherits the notebook default.
     expect("autoRefresh" in nextCells[0]).toBe(false)
-    expect(nextCells[0].isViewMaximized).toBe(true)
+    expect(nextCells[0].paneView).toBe("result")
+  })
+
+  it("applies semantic pane dimensions and view to a new draw cell", () => {
+    const { nextCells } = buildAppliedCells([], {
+      cells: [
+        {
+          value: "SELECT 1",
+          mode: "draw",
+          editorHeight: 120,
+          resultHeight: 300,
+          view: "editor_result",
+          chartConfig: {
+            xColumn: "ts",
+            queries: [{ type: "line", yColumns: ["v"] }],
+          },
+        },
+      ],
+    })
+
+    expect(nextCells[0]).toMatchObject({
+      topHeight: 120,
+      topResized: true,
+      bottomHeight: 300,
+      bottomResized: true,
+      paneView: "editor_result",
+    })
+  })
+
+  it("treats null semantic dimensions as preserve for an existing cell", () => {
+    const existing: NotebookCell = {
+      id: "a",
+      position: 0,
+      value: "SELECT 1",
+      mode: "draw",
+      topHeight: 120,
+      topResized: true,
+      bottomHeight: 280,
+      bottomResized: true,
+      paneView: "editor_result",
+      chartConfig: {
+        xColumn: "ts",
+        queries: [{ type: "line", yColumns: ["v"] }],
+      },
+    }
+    const { nextCells } = buildAppliedCells([existing], {
+      cells: [
+        {
+          id: "a",
+          preserveValue: true,
+          mode: "draw",
+          editorHeight: null,
+          resultHeight: null,
+          view: null,
+          chartConfig: existing.chartConfig,
+        },
+      ],
+    })
+
+    expect(nextCells[0]).toMatchObject({
+      topHeight: 120,
+      topResized: true,
+      bottomHeight: 280,
+      bottomResized: true,
+      paneView: "editor_result",
+    })
+  })
+
+  it("treats editor view as authoritative over a preserved draw mode", () => {
+    const existing: NotebookCell = {
+      id: "a",
+      position: 0,
+      value: "SELECT 1",
+      mode: "draw",
+      result: { results: [], activeResultIndex: 0, timestamp: 1 },
+      paneView: "result",
+      chartConfig: {
+        xColumn: "ts",
+        queries: [{ type: "line", yColumns: ["v"] }],
+      },
+    }
+
+    const { nextCells, resultsCleared } = buildAppliedCells([existing], {
+      cells: [
+        {
+          id: "a",
+          preserveValue: true,
+          mode: null,
+          view: "editor",
+          chartConfig: null,
+        },
+      ],
+    })
+
+    expect("mode" in nextCells[0]).toBe(false)
+    expect(nextCells[0].result).toBeUndefined()
+    expect(nextCells[0].chartConfig).toBeUndefined()
+    expect(resultsCleared).toEqual(["a"])
+  })
+
+  it.each(["run", "draw"] as const)(
+    "rejects explicit mode %s with editor view",
+    (mode) => {
+      expect(() =>
+        buildAppliedCells([], {
+          cells: [{ value: "SELECT 1", mode, view: "editor" }],
+        }),
+      ).toThrow(/explicit mode.*view "editor"/)
+    },
+  )
+
+  it("honors an explicit editor_height sent together with a value change", () => {
+    // Given a never-manually-resized cell
+    const existing: NotebookCell = {
+      id: "a",
+      position: 0,
+      value: "SELECT 1",
+      topHeight: 72,
+    }
+    // When one apply changes the value AND pins the editor height
+    const { nextCells } = buildAppliedCells([existing], {
+      cells: [{ id: "a", value: "SELECT 2", editorHeight: 500 }],
+    })
+    // Then the pinned height wins over the line-count estimate
+    expect(nextCells[0]).toMatchObject({
+      topHeight: 500,
+      topResized: true,
+    })
+  })
+
+  it("re-estimates the editor height for a value change with editor_height auto", () => {
+    const existing: NotebookCell = {
+      id: "a",
+      position: 0,
+      value: "SELECT 1",
+      topHeight: 700,
+      topResized: true,
+    }
+    const { nextCells } = buildAppliedCells([existing], {
+      cells: [{ id: "a", value: "SELECT 2", editorHeight: "auto" }],
+    })
+
+    expect(nextCells[0].topResized).toBe(false)
+    expect(nextCells[0].topHeight).toBe(topHeightForSql("SELECT 2"))
+  })
+
+  it("heals a markdown cell that carries a leaked mode from a legacy import", () => {
+    // Given a markdown cell poisoned with run/draw sub-state by an old import
+    const poisoned: NotebookCell = {
+      id: "a",
+      position: 0,
+      value: "# title",
+      type: "markdown",
+      mode: "draw",
+    }
+    // When an apply preserves the cell
+    const { nextCells } = buildAppliedCells([poisoned], {
+      cells: [{ id: "a", preserveValue: true }],
+    })
+    // Then the apply succeeds and the leaked mode is gone
+    expect(nextCells[0].type).toBe("markdown")
+    expect("mode" in nextCells[0]).toBe(false)
+  })
+
+  it("still rejects an explicit mode on a markdown cell", () => {
+    expect(() =>
+      buildAppliedCells([], {
+        cells: [{ value: "# title", type: "markdown", mode: "run" }],
+      }),
+    ).toThrow(/markdown cell and cannot have a mode/)
   })
 
   it("apply is a PUT: mode='draw' with no chart_config throws even when the existing cell had one (no merge)", () => {
@@ -1227,16 +1619,16 @@ describe("buildAppliedCells", () => {
     ).toThrow(/no chart_config/)
   })
 
-  it("preserves an existing mode while clearing omitted PUT fields", () => {
+  it("preserves existing mode and editor visibility while clearing omitted PUT fields", () => {
     // Given an existing run cell with optional chart presentation fields
     const prev: NotebookCell[] = [
       {
         id: "a",
         position: 0,
         value: "SELECT 1",
-        mode: "run",
+        mode: undefined,
         autoRefresh: "5s",
-        isViewMaximized: true,
+        paneView: "result",
         chartConfig: {
           xColumn: "ts",
           queries: [{ type: "line", yColumns: ["v"] }],
@@ -1249,11 +1641,11 @@ describe("buildAppliedCells", () => {
       cells: [{ id: "a", value: "SELECT 1" }], // bare cell — everything omitted
     })
 
-    // Then mode is sticky while the documented PUT fields are cleared
-    expect(nextCells[0].mode).toBe("run")
+    // Then implicit run stays unstored while the documented PUT fields clear
+    expect(nextCells[0].mode).toBeUndefined()
     expect(nextCells[0].chartConfig).toBeUndefined()
     expect(nextCells[0].autoRefresh).toBeUndefined()
-    expect(nextCells[0].isViewMaximized).toBeUndefined()
+    expect(nextCells[0].paneView).toBe("result")
   })
 
   it("preserves draw mode when apply omits mode and supplies its full chart", () => {
@@ -1343,7 +1735,7 @@ describe("isDoubleView", () => {
         position: 0,
         value: "",
         mode: "draw",
-        isViewMaximized: true,
+        paneView: "result",
       }),
     ).toBe(true)
   })
@@ -1612,12 +2004,14 @@ describe("computeCellHeights", () => {
       bottomHeight: 350,
     })
   })
-  it("double-view (empty result) defaults to the notification-only height", () => {
+  it("double-view (empty result) floors the notification bottom to the pane minimum", () => {
+    // The tight content height is 44 (notification bar only); the visible
+    // pane never renders below MIN_BOTTOM_HEIGHT_PX.
     expect(
       computeCellHeights(
         cell({ result: { results: [], activeResultIndex: 0, timestamp: 0 } }),
       ),
-    ).toEqual({ topHeight: 72, bottomHeight: 44 })
+    ).toEqual({ topHeight: 72, bottomHeight: 100 })
   })
   it("expectingResult reserves the result area when bottomHeight is unset", () => {
     expect(
@@ -1646,36 +2040,35 @@ describe("computeCellHeights", () => {
   })
 })
 
-describe("scaleCellHeights", () => {
-  it("scales both heights proportionally to the new content", () => {
-    expect(scaleCellHeights(200, 200, 200, 72, 88)).toEqual({
-      top: 100,
-      bottom: 100,
-    })
-  })
-  it("clamps the bottom to its minimum and gives the rest to the top", () => {
-    expect(scaleCellHeights(400, 100, 200, 72, 88)).toEqual({
-      top: 112,
-      bottom: 88,
-    })
-  })
-  it("clamps the top to its minimum and gives the rest to the bottom", () => {
-    expect(scaleCellHeights(100, 400, 200, 72, 88)).toEqual({
-      top: 72,
-      bottom: 128,
-    })
-  })
-  it("never shrinks below the combined minimum, even when asked smaller", () => {
-    expect(scaleCellHeights(400, 200, 50, 72, 88)).toEqual({
-      top: 72,
-      bottom: 88,
-    })
+describe("agentCellPaneDimensions", () => {
+  it("reports a stored result pin even when a run result is not loaded", () => {
+    expect(
+      agentCellPaneDimensions({
+        id: "x",
+        position: 0,
+        value: "SELECT 1",
+        bottomHeight: 400,
+        bottomResized: true,
+        lastRunStatus: "success",
+      }),
+    ).toEqual({ editorHeight: "auto", resultHeight: 400 })
   })
-  it("falls back to scale 1 when the old content is zero", () => {
-    expect(scaleCellHeights(0, 0, 300, 72, 88)).toEqual({
-      top: 72,
-      bottom: 228,
-    })
+
+  it("reports auto for unpinned panes and normalizes legacy pins", () => {
+    expect(
+      agentCellPaneDimensions({ id: "x", position: 0, value: "SELECT 1" }),
+    ).toEqual({ editorHeight: "auto", resultHeight: "auto" })
+    expect(
+      agentCellPaneDimensions({
+        id: "x",
+        position: 0,
+        value: "SELECT 1",
+        topHeight: 1,
+        topResized: true,
+        bottomHeight: 1,
+        bottomResized: true,
+      }),
+    ).toEqual({ editorHeight: 72, resultHeight: 100 })
   })
 })
 
@@ -1705,9 +2098,10 @@ describe("computeCellGridH", () => {
     // 72 + 56 = 128 → ceil(128/50) = 3
     expect(computeCellGridH({ id: "x", position: 0, value: "" }, 50)).toBe(3)
   })
-  it("double-view (run with empty result): tight notification-only bottom", () => {
-    // result.results = [] (empty after run) → bottom = NOTIFICATION_PX (44).
-    // 72 + 56 + 44 = 172 → ceil(172/50) = 4
+  it("double-view (run with empty result): notification bottom floored to the pane minimum", () => {
+    // result.results = [] (empty after run) → tight bottom is 44, floored to
+    // MIN_BOTTOM_HEIGHT_PX (100) so render, bounds and save agree.
+    // 72 + 50 + 100 = 222 → ceil(222/50) = 5
     expect(
       computeCellGridH(
         {
@@ -1718,7 +2112,7 @@ describe("computeCellGridH", () => {
         },
         50,
       ),
-    ).toBe(4)
+    ).toBe(5)
   })
   it("respects explicit topHeight and bottomHeight overrides", () => {
     // Split chrome 50: 200 + 50 + 300 = 550 → ceil(550/50) = 11
@@ -1801,7 +2195,7 @@ describe("computeCellGridH", () => {
     ).toBe(9)
   })
   it("expectingResult is ignored once a result is present (double-view wins)", () => {
-    // Same as the "double-view (run with empty result)" case: bottom = 44.
+    // Same as the "double-view (run with empty result)" case: bottom = 100.
     expect(
       computeCellGridH(
         {
@@ -1814,7 +2208,7 @@ describe("computeCellGridH", () => {
         0,
         true,
       ),
-    ).toBe(4)
+    ).toBe(5)
   })
   it("split cells carry the 6px divider on top of the base chrome", () => {
     // Base chrome alone would land exactly on 8 rows (72 + 104 + 44 = 220px
@@ -1832,26 +2226,240 @@ describe("computeCellGridH", () => {
         10,
         20,
       ),
-    ).toBe(9)
+    ).toBe(9)
+  })
+  it("editor-hidden cells reserve only the result pane", () => {
+    // The editor's 72px allocation is remembered but removed from the visible
+    // footprint: 104px result + 44px chrome snaps to 6 rows.
+    expect(
+      computeCellGridH(
+        {
+          id: "x",
+          position: 0,
+          value: "",
+          topHeight: 72,
+          bottomHeight: 104,
+          paneView: "result",
+          result: { results: [], activeResultIndex: 0, timestamp: 0 },
+        },
+        10,
+        20,
+      ),
+    ).toBe(6)
+  })
+
+  it("derives height from exactly the visible pane", () => {
+    const cell: NotebookCell = {
+      id: "x",
+      position: 0,
+      value: "",
+      topHeight: 200,
+      bottomHeight: 300,
+      result: { results: [], activeResultIndex: 0, timestamp: 0 },
+    }
+
+    // Editor: 200 + 44 chrome = 244px → 9 rows (250px rendered).
+    expect(computeCellGridH(cell, 10, 20, false, "editor")).toBe(9)
+    // Result: 300 + 44 chrome = 344px → 13 rows (370px rendered).
+    expect(computeCellGridH(cell, 10, 20, false, "result")).toBe(13)
+    // Wide split retains both panes and the 6px divider: 550px → 19 rows.
+    expect(computeCellGridH(cell, 10, 20, false, "split")).toBe(19)
+  })
+})
+
+describe("resolveCellPaneLayout", () => {
+  const withResult = (over: Partial<NotebookCell> = {}): NotebookCell => ({
+    id: "x",
+    position: 0,
+    value: "",
+    result: { results: [], activeResultIndex: 0, timestamp: 0 },
+    ...over,
+  })
+
+  it("shows only the editor when no result exists", () => {
+    const cell: NotebookCell = { id: "x", position: 0, value: "" }
+    expect(resolveCellPaneLayout(cell, false)).toBe("editor")
+  })
+
+  it("uses the authoritative preference once a result exists", () => {
+    expect(resolveCellPaneLayout(withResult(), false)).toBe("split")
+    expect(
+      resolveCellPaneLayout(withResult({ paneView: "result" }), false),
+    ).toBe("result")
+  })
+})
+
+describe("agentCellPresentation", () => {
+  const chart = (over: Partial<NotebookCell> = {}): NotebookCell => ({
+    id: "x",
+    position: 0,
+    value: "SELECT 1",
+    mode: "draw",
+    paneView: "editor_result",
+    ...over,
+  })
+
+  it("reports the stored pane view once a run outcome exists", () => {
+    expect(agentCellPresentation(chart())).toEqual({
+      view: "editor_result",
+      mode: "draw",
+    })
+    expect(agentCellPresentation(chart({ paneView: "result" }))).toEqual({
+      view: "result",
+      mode: "draw",
+    })
+    expect(agentCellPresentation(chart({ paneView: undefined }))).toEqual({
+      view: "editor_result",
+      mode: "draw",
+    })
+  })
+
+  it("reports editor while the cell has nothing to show", () => {
+    expect(agentCellPresentation(chart({ mode: undefined }))).toEqual({
+      view: "editor",
+      mode: null,
+    })
+    expect(
+      agentCellPresentation(chart({ mode: undefined, lastRunStatus: "none" })),
+    ).toEqual({ view: "editor", mode: null })
+    expect(
+      agentCellPresentation(
+        chart({ mode: undefined, lastRunStatus: "success" }),
+      ),
+    ).toEqual({ view: "editor_result", mode: "run" })
+  })
+
+  it("reports editor when a run-marked result is known missing", () => {
+    const releasedRun = chart({
+      mode: undefined,
+      lastRunStatus: "success",
+      paneView: "result",
+    })
+
+    expect(agentCellPresentation(releasedRun, "unrequested")).toEqual({
+      view: "result",
+      mode: "run",
+    })
+    expect(agentCellPresentation(releasedRun, "missing")).toEqual({
+      view: "editor",
+      mode: null,
+    })
+    expect(agentCellPresentation(chart(), "missing")).toEqual({
+      view: "editor_result",
+      mode: "draw",
+    })
   })
-  it("view-maximized cells drop the divider (bottom slot spans both panes)", () => {
-    // The same heights as the split case, minus the 6px divider: 220px lands
-    // exactly on 8 rows again.
+
+  it("reports a null view for a markdown cell", () => {
     expect(
-      computeCellGridH(
+      agentCellPresentation(chart({ mode: undefined, type: "markdown" })),
+    ).toEqual({ view: null, mode: null })
+  })
+})
+
+describe("computeCellGridBounds", () => {
+  const result = { results: [], activeResultIndex: 0, timestamp: 0 }
+
+  it("reserves the split editor's current height plus the result minimum", () => {
+    const cell: NotebookCell = {
+      id: "x",
+      position: 0,
+      value: "",
+      topHeight: 400,
+      bottomHeight: 300,
+      result,
+    }
+
+    // 400px editor + 100px result minimum + 50px split chrome = 550px,
+    // which is exactly 19 rows at rowHeight=10 and marginY=20.
+    expect(computeCellGridBounds(cell, 10, 20).minH).toBe(19)
+  })
+
+  it("does not reserve the remembered editor height when it is hidden", () => {
+    const cell: NotebookCell = {
+      id: "x",
+      position: 0,
+      value: "",
+      topHeight: 400,
+      bottomHeight: 300,
+      paneView: "result",
+      result,
+    }
+
+    // 100px result minimum + 44px base chrome requires 6 rows.
+    expect(computeCellGridBounds(cell, 10, 20).minH).toBe(6)
+  })
+
+  it("uses the chart-specific result minimum", () => {
+    const cell: NotebookCell = {
+      id: "x",
+      position: 0,
+      value: "",
+      mode: "draw",
+      topHeight: 400,
+      bottomHeight: 350,
+    }
+
+    // 400px editor + 296px chart minimum + 50px split chrome requires 26 rows.
+    expect(computeCellGridBounds(cell, 10, 20).minH).toBe(26)
+  })
+
+  it("uses only the visible pane minimum for editor-only and result-only layouts", () => {
+    const cell: NotebookCell = {
+      id: "x",
+      position: 0,
+      value: "",
+      topHeight: 400,
+      bottomHeight: 300,
+      result,
+    }
+
+    expect(computeCellGridBounds(cell, 10, 20, false, "editor").minH).toBe(5)
+    expect(computeCellGridBounds(cell, 10, 20, false, "result").minH).toBe(6)
+  })
+
+  it("keeps minH ≤ h ≤ maxH for every in-bounds cell state", () => {
+    // Given the full matrix of pane states: notification-only and gridded
+    // results, charts (fresh and errored render alike), hydrating, and
+    // editor-only — at the default and at a tall editor.
+    const dql = {
+      results: [
         {
-          id: "x",
-          position: 0,
-          value: "",
-          topHeight: 72,
-          bottomHeight: 104,
-          isViewMaximized: true,
-          result: { results: [], activeResultIndex: 0, timestamp: 0 },
+          type: "dql" as const,
+          query: "SELECT 1",
+          columns: [{ name: "x", type: "INT" }],
+          dataset: [[1]],
+          count: 1,
         },
+      ],
+      activeResultIndex: 0,
+      timestamp: 0,
+    }
+    const base = { id: "x", position: 0, value: "SELECT 1" }
+    const scenarios: { cell: NotebookCell; expectingResult?: boolean }[] = [
+      { cell: { ...base, result } },
+      { cell: { ...base, result: dql } },
+      { cell: { ...base, result: dql, paneView: "result" } },
+      { cell: { ...base, result, paneView: "result" } },
+      { cell: { ...base, mode: "draw", paneView: "result" } },
+      { cell: { ...base, mode: "draw" } },
+      { cell: { ...base, lastRunStatus: "success" }, expectingResult: true },
+      { cell: { ...base } },
+      { cell: { ...base, topHeight: 900, result } },
+      { cell: { ...base, topHeight: 900, bottomHeight: 2400, result: dql } },
+    ]
+    // When deriving the grid bounds
+    // Then the height always sits inside its own bounds
+    for (const { cell, expectingResult } of scenarios) {
+      const { h, minH, maxH } = computeCellGridBounds(
+        cell,
         10,
         20,
-      ),
-    ).toBe(8)
+        expectingResult ?? false,
+      )
+      expect(minH).toBeLessThanOrEqual(h)
+      expect(h).toBeLessThanOrEqual(maxH)
+    }
   })
 })
 
@@ -1866,7 +2474,7 @@ describe("markdown cell grid lattice", () => {
 
   it("snapMarkdownTopHeight snaps content height up to the next lattice point", () => {
     // Given 10px rows, 20px margins and 44px markdown chrome, on-lattice
-    // content heights are 26, 56, 86, …
+    // content heights are 56, 86, 116, …
     // When the measured content falls between points
     // Then it snaps up to the next one
     expect(snapMarkdownTopHeight(36)).toBe(56)
@@ -1895,20 +2503,20 @@ describe("markdown cell grid lattice", () => {
     expect(computeCellGridH(markdown({ topHeight: 56 }), 10, 20)).toBe(4)
   })
 
-  it("cellHeightPatchForRows back-solves markdown rows with markdown chrome", () => {
+  it("paneHeightsFromGridRows back-solves markdown rows with markdown chrome", () => {
     // Given a markdown cell rendered at 4 rows
     const cell = markdown({ topHeight: 56 })
     // When the user drags the cell to 7 rows (7×10 + 6×20 = 190px box)
-    const patch = cellHeightPatchForRows(cell, 7, 10, 20)
+    const patch = paneHeightsFromGridRows(cell, 7, 10, 20)
     // Then content = 190 − 44 = 146, pinned like a manual drag
     expect(patch).toEqual({ topHeight: 146, topResized: true })
   })
 
-  it("cellHeightPatchForRows floors a tiny markdown drag at the markdown minimum", () => {
+  it("paneHeightsFromGridRows floors a tiny markdown drag at the markdown minimum", () => {
     // Given a markdown cell rendered at 4 rows
     const cell = markdown({ topHeight: 56 })
     // When the user drags the cell down to 2 rows (40px box < 44px chrome)
-    const patch = cellHeightPatchForRows(cell, 2, 10, 20)
+    const patch = paneHeightsFromGridRows(cell, 2, 10, 20)
     // Then the content floors at the markdown minimum, not the SQL 72px
     expect(patch).toEqual({
       topHeight: MIN_MARKDOWN_HEIGHT_PX,
@@ -1991,7 +2599,7 @@ describe("hasAgentVisibleCellHeightChanged", () => {
   })
 })
 
-describe("cellHeightPatchForRows", () => {
+describe("paneHeightsFromGridRows", () => {
   const withResult = (over: Partial<NotebookCell> = {}): NotebookCell => ({
     id: "x",
     position: 0,
@@ -2004,7 +2612,7 @@ describe("cellHeightPatchForRows", () => {
     // Given a single-view run cell whose content-derived height is 5 rows
     const runCell: NotebookCell = { id: "x", position: 0, value: "" }
     // When the requested rows equal that derived height (not a real resize)
-    const patch = cellHeightPatchForRows(runCell, 5, 10, 20)
+    const patch = paneHeightsFromGridRows(runCell, 5, 10, 20)
     // Then nothing is pinned — auto-height is left intact
     expect(patch).toEqual({})
   })
@@ -2014,37 +2622,59 @@ describe("cellHeightPatchForRows", () => {
     const runCell: NotebookCell = { id: "x", position: 0, value: "" }
     // When a taller height is requested (box 10*10+9*20 = 280,
     // targetContentPx = 280 - 44 = 236)
-    const patch = cellHeightPatchForRows(runCell, 10, 10, 20)
+    const patch = paneHeightsFromGridRows(runCell, 10, 10, 20)
     // Then the editor grows to fill it and is pinned
     expect(patch).toEqual({ topHeight: 236, topResized: true })
   })
 
   it("split double-view: resizes the result pane and pins bottomResized", () => {
-    // Given a double-view cell (has result), not maximized — split chrome 50
+    // Given a double-view cell (has result) in split view — split chrome 50
     const c = withResult({ topHeight: 72, bottomHeight: 100 })
     // When a taller height is requested (box 15*10+14*20 = 430,
     // targetContentPx = 430 - 50 = 380)
-    const patch = cellHeightPatchForRows(c, 15, 10, 20)
+    const patch = paneHeightsFromGridRows(c, 15, 10, 20)
     // Then only the bottom slot grows (editor kept), pinned via bottomResized
     expect(patch).toEqual({ bottomHeight: 308, bottomResized: true })
   })
 
-  it("maximized double-view: scales both panes and pins both", () => {
-    // Given a maximized double-view cell — no editor, no divider, so it
-    // carries the base chrome 44
+  it("split double-view: never consumes editor height below the result floor", () => {
+    const c = withResult({ topHeight: 400, bottomHeight: 300 })
+
+    // The split minimum is 400px editor + 100px result + 50px chrome,
+    // or 19 rows. Resizing to that floor changes only the result pane.
+    const patch = paneHeightsFromGridRows(c, 19, 10, 20)
+
+    expect(patch).toEqual({ bottomHeight: 100, bottomResized: true })
+    expect(patch).not.toHaveProperty("topHeight")
+    expect(patch).not.toHaveProperty("topResized")
+  })
+
+  it("editor-hidden double-view: resizes only the visible result pane", () => {
+    // Given an editor-hidden double-view cell carrying base chrome only
     const c = withResult({
       topHeight: 72,
       bottomHeight: 100,
-      isViewMaximized: true,
+      paneView: "result",
     })
     // When a taller height is requested (targetContentPx = 430 - 44 = 386,
-    // scale 386/172 ≈ 2.244)
-    const patch = cellHeightPatchForRows(c, 15, 10, 20)
-    // Then editor and result scale together, both pinned
+    // and no editor allocation in its visible footprint)
+    const patch = paneHeightsFromGridRows(c, 15, 10, 20)
+    // Then only the result changes; the remembered editor height is untouched
     expect(patch).toEqual({
-      topHeight: 162,
-      bottomHeight: 224,
+      bottomHeight: 386,
+      bottomResized: true,
+    })
+  })
+
+  it("editor-only and result-only cells resize only their visible pane", () => {
+    const c = withResult({ topHeight: 200, bottomHeight: 300 })
+
+    expect(paneHeightsFromGridRows(c, 10, 10, 20, false, "editor")).toEqual({
+      topHeight: 236,
       topResized: true,
+    })
+    expect(paneHeightsFromGridRows(c, 15, 10, 20, false, "result")).toEqual({
+      bottomHeight: 386,
       bottomResized: true,
     })
   })
@@ -2061,7 +2691,7 @@ describe("cellHeightPatchForRows", () => {
       lastRunStatus: "success",
     }
     // When a taller height is requested (targetContentPx = 430 - 50 = 380)
-    const patch = cellHeightPatchForRows(expecting, 15, 10, 20, true)
+    const patch = paneHeightsFromGridRows(expecting, 15, 10, 20, true)
     // Then the reserved pane grows, exactly like a hydrated double-view drag
     expect(patch).toEqual({ bottomHeight: 308, bottomResized: true })
   })
@@ -2305,23 +2935,32 @@ describe("lastRunError carry chain", () => {
     expect(nextCells[0].lastRunStatus).toBe("error")
     expect(nextCells[0].lastRunError).toBe("table does not exist")
   })
-
-  it("buildAppliedCells drops run markers when a cell turns markdown", () => {
-    // Given a stripped errored cell converted to prose
-    const [stripped] = stripCellResults([errored("a")])
-
-    // When apply converts it to markdown
-    const { nextCells } = buildAppliedCells([stripped], {
-      cells: [{ id: "a", value: stripped.value, type: "markdown" }],
-    })
-
-    // Then no run markers remain on the markdown cell
-    expect(nextCells[0].lastRunStatus).toBeUndefined()
-    expect(nextCells[0].lastRunError).toBeUndefined()
-  })
 })
 
 describe("buildAppliedLayout", () => {
+  it("derives h from the live snapshot-load status when a reader is provided", () => {
+    // Given a run-marked cell whose result lives only on disk
+    const pending: NotebookCell[] = [
+      { id: "a", position: 0, value: "SELECT 1", lastRunStatus: "success" },
+    ]
+    const request = { cells: [{ id: "a", value: "SELECT 1" }] }
+    const defaults = { gridCols: 12, rowHeight: 10, marginY: 20 }
+    // When the reader reports the snapshot missing vs still loadable
+    const collapsed = buildAppliedLayout(
+      request,
+      pending,
+      [],
+      defaults,
+      () => "missing",
+    )
+    const reserved = buildAppliedLayout(request, pending, [], defaults)
+    // Then the missing cell collapses to its editor while the default
+    // ("unrequested") reserves the result area — statuses drive h
+    expect(collapsed[0].h).toBeLessThan(reserved[0].h)
+    expect(reserved[0].h).toBe(19)
+    expect(collapsed[0].h).toBe(5)
+  })
+
   it("uses request.grid when provided, otherwise derives h from topHeight + bottomHeight", () => {
     const cells: NotebookCell[] = [
       { id: "a", position: 0, value: "" },
@@ -2330,7 +2969,7 @@ describe("buildAppliedLayout", () => {
     const layout = buildAppliedLayout(
       {
         cells: [
-          { id: "a", value: "", grid: { x: 0, y: 0, w: 6, h: 4 } },
+          { id: "a", value: "", grid: { x: 0, y: 0, w: 6 } },
           { id: "b", value: "" },
         ],
       },
@@ -2338,13 +2977,14 @@ describe("buildAppliedLayout", () => {
       [],
       { gridCols: 12, rowHeight: 50 },
     )
-    expect(layout[0]).toEqual({ i: "a", x: 0, y: 0, w: 6, h: 4 })
+    expect(layout[0]).toEqual({ i: "a", x: 0, y: 0, w: 6, h: 3 })
     // Run-mode cell, no result yet → single-view → only topHeight (72) + chrome (40)
-    // = 112 px → ceil(112 / 50) = 3 rows. Stacks below 'a' which had y+h = 4.
-    expect(layout[1]).toEqual({ i: "b", x: 0, y: 4, w: 12, h: 3 })
+    // = 112 px → ceil(112 / 50) = 3 rows. Both cells derive h and the second
+    // stacks below the first at y=3.
+    expect(layout[1]).toEqual({ i: "b", x: 0, y: 3, w: 12, h: 3 })
   })
 
-  it("preserves prevLayout entry when request omits grid", () => {
+  it("keeps prevLayout placement and re-derives h when request omits grid", () => {
     const cells: NotebookCell[] = [{ id: "a", position: 0, value: "" }]
     const layout = buildAppliedLayout(
       { cells: [{ id: "a", value: "" }] },
@@ -2352,7 +2992,7 @@ describe("buildAppliedLayout", () => {
       [{ i: "a", x: 3, y: 4, w: 8, h: 5 }],
       { gridCols: 12, rowHeight: 50 },
     )
-    expect(layout).toEqual([{ i: "a", x: 3, y: 4, w: 8, h: 5 }])
+    expect(layout).toEqual([{ i: "a", x: 3, y: 4, w: 8, h: 3 }])
   })
 
   it("gives draw-mode cells a taller default than run-mode cells (no result yet)", () => {
@@ -2360,7 +3000,7 @@ describe("buildAppliedLayout", () => {
     // draw cells, so they're double-view from creation. Run cells stay
     // single-view (no result) and only count topHeight + chrome.
     const cells: NotebookCell[] = [
-      { id: "run-cell", position: 0, value: "", mode: "run" },
+      { id: "run-cell", position: 0, value: "", mode: undefined },
       {
         id: "draw-cell",
         position: 1,
@@ -2409,7 +3049,7 @@ describe("cloneNotebookViewState", () => {
         value: "SELECT 2",
         mode: "draw",
         autoRefresh: true,
-        isViewMaximized: true,
+        paneView: "result",
         chartConfig: {
           xColumn: "ts",
           queries: [{ type: "line", yColumns: ["v"] }],
@@ -2483,7 +3123,7 @@ describe("cloneNotebookViewState", () => {
     expect(out.cells[0].topHeight).toBe(120)
     expect(out.cells[1].mode).toBe("draw")
     expect(out.cells[1].autoRefresh).toBe(true)
-    expect(out.cells[1].isViewMaximized).toBe(true)
+    expect(out.cells[1].paneView).toBe("result")
     expect(out.cells[1].chartConfig).toEqual({
       xColumn: "ts",
       queries: [{ type: "line", yColumns: ["v"] }],
@@ -2732,7 +3372,7 @@ describe("auto-refresh inheritance helpers", () => {
     const cells: NotebookCell[] = [
       { ...cell("a", "SELECT 1"), mode: "draw", autoRefresh: "5s" },
       { ...cell("b", "SELECT 2"), mode: "draw", autoRefresh: true },
-      { ...cell("c", "SELECT 3"), mode: "run", autoRefresh: false },
+      { ...cell("c", "SELECT 3"), mode: undefined, autoRefresh: false },
       cell("d", "SELECT 4"),
     ]
     // Then every stored key counts — the count matches what a reset would clear
@@ -2756,8 +3396,12 @@ describe("auto-refresh inheritance helpers", () => {
     }
     const cells: NotebookCell[] = [
       { ...cell("a", "SELECT 1"), mode: "draw", autoRefresh: "5s" },
-      { ...cell("b", "SELECT 2", gridResult), mode: "run", autoRefresh: false },
-      { ...cell("c", "SELECT 3"), mode: "run", autoRefresh: "1s" },
+      {
+        ...cell("b", "SELECT 2", gridResult),
+        mode: undefined,
+        autoRefresh: false,
+      },
+      { ...cell("c", "SELECT 3"), mode: undefined, autoRefresh: "1s" },
     ]
     // Then only the cells with a visible view count toward the displayed total
     expect(countActiveAutoRefreshOverrides(cells)).toBe(2)
@@ -2769,7 +3413,7 @@ describe("auto-refresh inheritance helpers", () => {
     // Given a run cell carrying a dormant override
     const dormant: NotebookCell = {
       ...cell("a", "SELECT 1"),
-      mode: "run",
+      mode: undefined,
       autoRefresh: "1s",
     }
     // When the override clears and the cell later switches to draw
@@ -2811,103 +3455,41 @@ describe("resolveCellView", () => {
     expect(resolveCellView({ mode: "draw", result })).toBe("chart")
   })
   it("is grid for a run cell that has a result", () => {
-    expect(resolveCellView({ mode: "run", result })).toBe("grid")
+    expect(resolveCellView({ mode: undefined, result })).toBe("grid")
     expect(resolveCellView({ result })).toBe("grid")
   })
   it("is none for a run cell with no result", () => {
-    expect(resolveCellView({ mode: "run" })).toBe("none")
+    expect(resolveCellView({ mode: undefined })).toBe("none")
     expect(resolveCellView({})).toBe("none")
   })
 })
 
 describe("resolveRunAction", () => {
-  const result = { results: [], activeResultIndex: 0, timestamp: 0 }
-
-  it("runs a single query, or all, for a run cell with a visible grid", () => {
-    // Given a run cell whose grid is on screen
-    const cell = { mode: "run" as const, result }
-    const opts = { isCompactTier: false, showBottomSlot: true }
+  it("runs a single query, or all, for a run cell", () => {
+    // Given a run cell
+    const cell = {}
     // When the user presses Run All / Run
-    // Then it runs all / one, without revealing anything
-    expect(resolveRunAction(cell, { ...opts, intent: "all" })).toEqual({
-      kind: "run-all",
-      reveal: false,
-      exitDraw: false,
-    })
-    expect(resolveRunAction(cell, { ...opts, intent: "single" })).toEqual({
-      kind: "run-single",
-      reveal: false,
-      exitDraw: false,
-    })
-  })
-
-  it("runs an empty run cell the same way, with nothing to reveal in wide tiers", () => {
-    // Given a run cell with no result in a wide tier (none view)
-    const cell = { mode: "run" as const }
-    const opts = { isCompactTier: false, showBottomSlot: false }
-    // When the user runs
-    // Then it runs, and never reveals outside the compact tier
-    expect(resolveRunAction(cell, { ...opts, intent: "all" })).toEqual({
+    // Then it runs all / one
+    expect(resolveRunAction(cell, { intent: "all" })).toEqual({
       kind: "run-all",
-      reveal: false,
-      exitDraw: false,
     })
-    expect(resolveRunAction(cell, { ...opts, intent: "single" })).toEqual({
+    expect(resolveRunAction(cell, { intent: "single" })).toEqual({
       kind: "run-single",
-      reveal: false,
-      exitDraw: false,
     })
   })
 
-  it("reveals a compact run cell whose grid is collapsed by View SQL", () => {
-    // Given a compact run cell with the grid collapsed (View SQL active)
-    const cell = { mode: "run" as const, result }
-    const opts = { isCompactTier: true, showBottomSlot: false }
-    // When the user runs
-    // Then it reveals the grid first, then runs
-    expect(resolveRunAction(cell, { ...opts, intent: "all" })).toEqual({
-      kind: "run-all",
-      reveal: true,
-      exitDraw: false,
-    })
-    expect(resolveRunAction(cell, { ...opts, intent: "single" })).toEqual({
-      kind: "run-single",
-      reveal: true,
-      exitDraw: false,
-    })
-  })
-
-  it("refreshes the whole chart on Run All but ignores Run for a visible chart", () => {
-    // Given a draw cell whose chart is on screen
-    const cell = { mode: "draw" as const, result }
-    const opts = { isCompactTier: false, showBottomSlot: true }
+  it("refreshes the whole chart on Run All but ignores Run for a draw cell", () => {
+    // Given a draw cell
+    const cell = { mode: "draw" as const }
     // When the user presses Run All / Run
     // Then Run All refreshes the chart and Run is a no-op
-    expect(resolveRunAction(cell, { ...opts, intent: "all" })).toEqual({
+    expect(resolveRunAction(cell, { intent: "all" })).toEqual({
       kind: "chart",
     })
-    expect(resolveRunAction(cell, { ...opts, intent: "single" })).toEqual({
+    expect(resolveRunAction(cell, { intent: "single" })).toEqual({
       kind: "noop",
     })
   })
-
-  it("treats a compact chart collapsed behind the editor as a grid, exiting draw", () => {
-    // Given a compact draw cell with the chart collapsed (View SQL active)
-    const cell = { mode: "draw" as const, result }
-    const opts = { isCompactTier: true, showBottomSlot: false }
-    // When the user presses Run All / Run from the editor
-    // Then both reveal a grid and drop the cell out of draw — never the chart
-    expect(resolveRunAction(cell, { ...opts, intent: "all" })).toEqual({
-      kind: "run-all",
-      reveal: true,
-      exitDraw: true,
-    })
-    expect(resolveRunAction(cell, { ...opts, intent: "single" })).toEqual({
-      kind: "run-single",
-      reveal: true,
-      exitDraw: true,
-    })
-  })
 })
 
 describe("cellToolbarTier", () => {
@@ -2966,7 +3548,6 @@ describe("cellToolbarMenuFlags", () => {
       tier: "compact",
       view: "none",
       isMarkdown: false,
-      sqlShown: false,
       chartZoomed: false,
       isGridMode: false,
       cellIndex: 1,
@@ -2981,42 +3562,34 @@ describe("cellToolbarMenuFlags", () => {
     // Then it offers the table (Run) and chart (Draw) entry points only
     expect(f.showViewTable).toBe(true)
     expect(f.showViewChart).toBe(true)
-    expect(f.showViewSql).toBe(false)
-    expect(f.showSplitItem).toBe(false)
+    expect(f.showEditorToggleItem).toBe(false)
     expect(f.showRefreshItem).toBe(false)
     expect(f.groupAHasItems).toBe(true)
     expect(f.groupBHasItems).toBe(false)
   })
 
-  it("compact grid view offers View SQL and View chart, plus Refresh — never View table it already shows", () => {
+  it("compact grid view carries all three checkable view controls plus refresh", () => {
     // Given a narrow cell currently showing the table
     const f = flags({ tier: "compact", view: "grid" })
-    // Then the menu offers the two panes it is NOT showing, plus refresh
-    expect(f.showViewSql).toBe(true)
+    // Then the menu mirrors the wide header: both segments and the editor
+    // toggle, as checkable items
+    expect(f.showViewTable).toBe(true)
     expect(f.showViewChart).toBe(true)
-    expect(f.showViewTable).toBe(false)
+    expect(f.showEditorToggleItem).toBe(true)
     expect(f.showRefreshItem).toBe(true)
     expect(f.showChartSettings).toBe(false)
   })
 
-  it("hides chart commands that reach the unmounted chart when compact View SQL is active", () => {
-    // Given a compact chart cell collapsed to the editor (View SQL active),
-    // which unmounts the DrawCanvas the chart commands publish events to
-    const f = flags({
-      tier: "compact",
-      view: "chart",
-      sqlShown: true,
-      chartZoomed: true,
-    })
-    // Then the commands that would reach the now-unmounted chart are hidden…
-    expect(f.showRefreshItem).toBe(false)
-    expect(f.showChartSettings).toBe(false)
-    expect(f.showResetZoom).toBe(false)
-    // …but the interval submenu stays — it patches cell state, not the chart
-    expect(f.showAutoRefreshItem).toBe(true)
-    // …and View table / View chart still let the user bring a pane back
-    expect(f.showViewTable).toBe(true)
-    expect(f.showViewChart).toBe(true)
+  it("compact cells offer the editor toggle whenever a result is on screen", () => {
+    // Given a compact chart in split or result-only view
+    // Then Show editor is in the menu, as the wide header's inline toggle
+    expect(flags({ tier: "compact", view: "chart" }).showEditorToggleItem).toBe(
+      true,
+    )
+    // And wider tiers show the toggle inline instead
+    expect(
+      flags({ tier: "standard", view: "chart" }).showEditorToggleItem,
+    ).toBe(false)
   })
 
   it("offers the interval submenu to grids, not just charts, wherever the inline control is absent", () => {
@@ -3073,7 +3646,7 @@ describe("cellToolbarMenuFlags", () => {
     expect(f.showAutoRefreshItem).toBe(true)
     expect(f.showRefreshItem).toBe(true)
     expect(f.showChartSettings).toBe(true)
-    expect(f.showSplitItem).toBe(false)
+    expect(f.showEditorToggleItem).toBe(false)
   })
 
   it("expanded tier never duplicates the inline refresh / interval / split controls", () => {
@@ -3083,10 +3656,10 @@ describe("cellToolbarMenuFlags", () => {
     // Then the menu drops all of them, keeping only chart settings (chart only)
     expect(chart.showRefreshItem).toBe(false)
     expect(chart.showAutoRefreshItem).toBe(false)
-    expect(chart.showSplitItem).toBe(false)
+    expect(chart.showEditorToggleItem).toBe(false)
     expect(chart.showChartSettings).toBe(true)
     expect(grid.showRefreshItem).toBe(false)
-    expect(grid.showSplitItem).toBe(false)
+    expect(grid.showEditorToggleItem).toBe(false)
     expect(grid.showChartSettings).toBe(false)
   })
 
@@ -3094,7 +3667,6 @@ describe("cellToolbarMenuFlags", () => {
     // Given a markdown cell (no run/draw views)
     const f = flags({ tier: "compact", view: "none", isMarkdown: true })
     // Then no view/chart items appear
-    expect(f.showViewSql).toBe(false)
     expect(f.showViewTable).toBe(false)
     expect(f.showViewChart).toBe(false)
     expect(f.showChartSettings).toBe(false)
@@ -3134,15 +3706,12 @@ describe("cellToolbarMenuFlags", () => {
         if (tier === "expanded") {
           expect(f.showRefreshItem).toBe(false)
           expect(f.showAutoRefreshItem).toBe(false)
-          expect(f.showSplitItem).toBe(false)
+          expect(f.showEditorToggleItem).toBe(false)
           expect(f.showResetZoom).toBe(false)
         }
         // And a divider flag is set iff at least one of its items shows
         expect(f.groupAHasItems).toBe(
-          f.showViewSql ||
-            f.showViewTable ||
-            f.showViewChart ||
-            f.showSplitItem,
+          f.showViewTable || f.showViewChart || f.showEditorToggleItem,
         )
         expect(f.groupBHasItems).toBe(
           f.showResetZoom ||
@@ -3383,83 +3952,6 @@ describe("buildAppliedNotebookState", () => {
     expect(next.settings.layout?.[0].i).toBe("a")
   })
 
-  it("grid.h differing from the derived height pins it into the cell", () => {
-    // Given a single-view run cell (derived height is 5 rows at 10/20)
-    const current = state([cell("a", "SELECT 1")])
-    // When apply requests a taller grid.h (box 20*10+19*20 = 580,
-    // targetContentPx = 580 - 44 = 536)
-    const next = buildAppliedNotebookState(current, {
-      layoutMode: "grid",
-      cells: [
-        { id: "a", preserveValue: true, grid: { x: 0, y: 0, w: 6, h: 20 } },
-      ],
-    })
-    // Then the height is back-solved into the editor and pinned (topResized)
-    expect(next.cells[0].topHeight).toBe(536)
-    expect(next.cells[0].topResized).toBe(true)
-  })
-
-  it("grid.h equal to the derived height does not pin (auto-height intact)", () => {
-    // Given a single-view run cell whose derived height is 5 rows
-    const current = state([cell("a", "SELECT 1")])
-    // When apply merely echoes that height (the required grid.h round-trip)
-    const next = buildAppliedNotebookState(current, {
-      layoutMode: "grid",
-      cells: [
-        { id: "a", preserveValue: true, grid: { x: 0, y: 0, w: 6, h: 5 } },
-      ],
-    })
-    // Then nothing is pinned — the cell keeps auto-height
-    expect(next.cells[0].topResized).toBeUndefined()
-    expect(next.cells[0].bottomResized).toBeUndefined()
-  })
-
-  it("value edit that echoes the pre-apply grid.h does not pin the editor", () => {
-    // Given a run cell showing a table result (double-view)
-    const withTable = cell("a", "SELECT 1", {
-      results: [],
-      activeResultIndex: 0,
-      timestamp: 0,
-    })
-    const current = state([withTable])
-    // Its grid height is derived from editor + result together
-    const h = computeCellGridH(withTable, 10, 20)
-    // When the agent fixes the SQL (clearing the result) and echoes that same h
-    const next = buildAppliedNotebookState(current, {
-      layoutMode: "grid",
-      cells: [{ id: "a", value: "SELECT 2", grid: { x: 0, y: 0, w: 6, h } }],
-    })
-    // Then the result clears but no phantom resize is pinned — after the re-run
-    // the cell returns to the same split, not a ballooned editor. The height
-    // is restamped from the new SQL (auto-height, not a resize).
-    expect(next.cells[0].result).toBeNull()
-    expect(next.cells[0].topHeight).toBe(topHeightForSql("SELECT 2"))
-    expect(next.cells[0].topResized).toBeUndefined()
-    expect(next.cells[0].bottomResized).toBeUndefined()
-  })
-
-  it("value edit with a taller grid.h resizes the result pane, like a bottom-edge drag", () => {
-    // Given a run cell showing a table result (double-view)
-    const withTable = cell("a", "SELECT 1", {
-      results: [],
-      activeResultIndex: 0,
-      timestamp: 0,
-    })
-    const current = state([withTable])
-    const h = computeCellGridH(withTable, 10, 20)
-    // When the agent fixes the SQL and grows the cell taller (a real resize)
-    const next = buildAppliedNotebookState(current, {
-      layoutMode: "grid",
-      cells: [
-        { id: "a", value: "SELECT 2", grid: { x: 0, y: 0, w: 6, h: h + 5 } },
-      ],
-    })
-    // Then it pins the result pane (bottomResized), never the editor — matching
-    // what the user's grid bottom-edge drag on a table cell writes
-    expect(next.cells[0].bottomResized).toBe(true)
-    expect(next.cells[0].topResized).toBeUndefined()
-  })
-
   it("keeps settings referentially identical when nothing settings-related changed", () => {
     // Given a list-mode notebook
     const current = state([cell("a", "SELECT 1")])
@@ -3619,6 +4111,28 @@ const resultOf = (
 })
 
 describe("reconcileResultsForStatements — content carryover", () => {
+  it("uses one canonical key space before reconciliation", () => {
+    const results = [dqlResult("select 1"), dqlResult("select 2")]
+    const previous = resultOf(results, {
+      activeStatementKey: statementKeysFor(["select 1"])[0],
+    })
+    const edited = ["select 1", "SELECT\n  2"]
+
+    // The render path must attach both results immediately, even before the
+    // refresh engine's debounced reconciliation runs.
+    const frame = deriveStatementFrame(edited, previous)
+    expect(frame?.slots.map((slot) => slot.result?.query)).toEqual([
+      "select 1",
+      "select 2",
+    ])
+
+    // Reconciliation uses exactly the same identities and keeps the active
+    // statement stable without needing a cache-priming render.
+    const reconciled = reconcileResultsForStatements(edited, previous)
+    expect(reconciled?.results).toEqual(results)
+    expect(reconciled?.activeStatementKey).toBe(previous.activeStatementKey)
+  })
+
   it("keeps results for unchanged statements across whitespace and semicolon edits", () => {
     // Given a two-statement frame
     const previous = resultOf([dqlResult("SELECT 1"), dqlResult("SELECT 2")])
@@ -3634,6 +4148,25 @@ describe("reconcileResultsForStatements — content carryover", () => {
     ])
   })
 
+  it("keeps results across internal whitespace, newlines, and keyword casing", () => {
+    const previous = resultOf([
+      dqlResult("select * from trades where sym = 'A'"),
+    ])
+
+    const reconciled = reconcileResultsForStatements(
+      ["SELECT  *\nFROM trades WHERE sym='A';"],
+      previous,
+    )
+
+    expect(reconciled?.results).toEqual(previous.results)
+  })
+
+  it("does not fold case inside SQL string values", () => {
+    const previous = resultOf([dqlResult("select 'A'")])
+
+    expect(reconcileResultsForStatements(["SELECT 'a'"], previous)).toBeNull()
+  })
+
   it("drops an edited statement's result and keeps its siblings", () => {
     // Given results for two statements
     const previous = resultOf([dqlResult("SELECT 1"), dqlResult("SELECT 2")])
@@ -3923,3 +4456,126 @@ describe("resolveActiveStatementSql — the single-run target", () => {
     expect(resolveActiveStatementSql("SELECT 1", null)).toBeUndefined()
   })
 })
+
+describe("pane height ceiling", () => {
+  const withResult: NotebookCell = {
+    id: "x",
+    position: 0,
+    value: "SELECT 1",
+    topHeight: 100,
+    topResized: true,
+    result: { results: [], activeResultIndex: 0, timestamp: 0 },
+  }
+
+  it("caps the editor estimate for a huge pasted query", () => {
+    expect(topHeightForSql(Array(100_000).fill("x").join("\n"))).toBe(2400)
+  })
+
+  it("caps the markdown auto-height snap", () => {
+    expect(snapMarkdownTopHeight(9_999)).toBe(2400)
+  })
+
+  it("caps a south-edge drag that asks for more rows than the ceiling", () => {
+    expect(
+      paneHeightsFromGridRows(
+        { ...withResult, paneView: "result" },
+        500,
+        10,
+        20,
+      ),
+    ).toEqual({ bottomHeight: 2400, bottomResized: true })
+  })
+
+  it("limits grid rows to the pane the south edge owns at the ceiling", () => {
+    // Rounded UP like h, so maxH can never land below the rendered height;
+    // the save path clamps any overshoot back to the 2400px pane ceiling.
+    // result-only: 2400 + 44 chrome = 2444px → 83 rows
+    expect(
+      computeCellGridBounds(withResult, 10, 20, false, "result").maxH,
+    ).toBe(83)
+    // split keeps the 100px editor: 100 + 2400 + 50 = 2550px → 86 rows
+    expect(computeCellGridBounds(withResult, 10, 20, false, "split").maxH).toBe(
+      86,
+    )
+  })
+
+  it("rejects agent heights above the ceiling in apply", () => {
+    expect(() =>
+      buildAppliedCells([], {
+        cells: [{ value: "SELECT 1", editorHeight: 2401 }],
+      }),
+    ).toThrow(/maximum is 2400px/)
+    expect(() =>
+      buildAppliedCells([], {
+        cells: [{ value: "SELECT 1", resultHeight: 2401 }],
+      }),
+    ).toThrow(/maximum is 2400px/)
+  })
+})
+
+describe("statementKeysForIdentities", () => {
+  it("rebuilds a frame's keys from the identities of the keys it was written under", () => {
+    // Given statements with a duplicate and presentation-only differences
+    const statements = ["select 1", "SELECT  1", "select 2"]
+    const keys = statementKeysFor(statements)
+
+    // When the keys are rebuilt from their identities alone
+    const rebuilt = statementKeysForIdentities(keys.map(statementIdentityOfKey))
+
+    // Then they equal the keys built from the text, duplicates included
+    expect(rebuilt).toEqual(keys)
+    expect(keys[0]).not.toBe(keys[1])
+  })
+})
+
+describe("agentCellDimensionsPatch", () => {
+  const markdownCell = (patch: Partial<NotebookCell>): NotebookCell => ({
+    id: "m1",
+    position: 0,
+    value: "# Title\n\nSome prose",
+    type: "markdown",
+    ...patch,
+  })
+
+  it("keeps a markdown cell's measured height when the agent asks for auto", () => {
+    // Given an unpinned markdown cell whose observer measured its content
+    const cell = markdownCell({ topHeight: 236, topResized: false })
+
+    // When the agent sends editor_height "auto" again
+    const patch = agentCellDimensionsPatch(cell, { editorHeight: "auto" })
+
+    // Then only the pin clears and the measurement survives
+    expect(patch).toEqual({ topResized: false })
+  })
+
+  it("clears a pinned markdown cell so it re-measures on the flip", () => {
+    // Given a markdown cell pinned below its content height
+    const cell = markdownCell({ topHeight: 500, topResized: true })
+
+    // When the agent sends editor_height "auto"
+    const patch = agentCellDimensionsPatch(cell, { editorHeight: "auto" })
+
+    // Then the pin clears and the stale number is left for the observer
+    expect(patch).toEqual({ topResized: false })
+  })
+
+  it("restores the SQL editor's content height on auto", () => {
+    // Given a pinned SQL cell
+    const cell: NotebookCell = {
+      id: "s1",
+      position: 0,
+      value: "select 1",
+      topHeight: 400,
+      topResized: true,
+    }
+
+    // When the agent sends editor_height "auto"
+    const patch = agentCellDimensionsPatch(cell, { editorHeight: "auto" })
+
+    // Then the editor returns to its content height, unpinned
+    expect(patch).toEqual({
+      topHeight: topHeightForSql("select 1"),
+      topResized: false,
+    })
+  })
+})
diff --git a/src/scenes/Editor/Notebook/notebookUtils.ts b/src/scenes/Editor/Notebook/notebookUtils.ts
index 2ab42a702..1e3e9d879 100644
--- a/src/scenes/Editor/Notebook/notebookUtils.ts
+++ b/src/scenes/Editor/Notebook/notebookUtils.ts
@@ -1,9 +1,11 @@
 import type { QueryExecResult } from "../../../hooks/useQueryExecution"
 import type {
+  AgentCellView,
   AutoRefresh,
   AutoRefreshInterval,
   CellLayoutItem,
   CellMode,
+  CellPaneView,
   CellResult,
   CellType,
   NotebookCell,
@@ -15,6 +17,8 @@ import type {
 import {
   AUTO_REFRESH_INTERVALS,
   createCell,
+  isAgentCellView,
+  isCellPaneView,
   MAX_NOTEBOOK_CELLS,
   MAX_CELL_LINES,
   exceedsCellLineLimit,
@@ -24,8 +28,10 @@ import {
 import { deriveRunStatusFromResults } from "../../../utils/ai/runStatus"
 import type { RunStatus } from "../../../utils/ai/runStatus"
 import { sanitizeForPromptContext } from "../../../utils/ai/sanitizeForPromptContext"
+import { formatSql } from "../../../utils/formatSql"
 import type { ChartConfig, QueryChart } from "./CellChart/chartTypes"
 import type { CellResultStatus } from "./resultHydration/cellResultHydration"
+export type { CellResultStatus } from "./resultHydration/cellResultHydration"
 import { getQueriesFromText, normalizeQueryText } from "../Monaco/utils"
 import {
   HEADER_HEIGHT,
@@ -90,35 +96,15 @@ export const resolveCellView = (
   return "none"
 }
 
-type RunActionPlan =
-  | { kind: "chart" }
-  | { kind: "noop" }
-  | { kind: "run-all" | "run-single"; reveal: boolean; exitDraw: boolean }
+type RunActionPlan = { kind: "chart" | "noop" | "run-all" | "run-single" }
 
 export const resolveRunAction = (
-  cell: Pick<NotebookCell, "mode" | "result">,
-  opts: {
-    isCompactTier: boolean
-    showBottomSlot: boolean
-    intent: "all" | "single"
-  },
-): RunActionPlan => {
-  // Reveal only the compact "View SQL" collapse — in wider tiers the slot is
-  // never force-hidden, so revealing there would wrongly maximize a split view.
-  const reveal = opts.isCompactTier && !opts.showBottomSlot
-  if (cell.mode === "draw" && !reveal) {
-    return opts.intent === "all" ? { kind: "chart" } : { kind: "noop" }
-  }
-  // Run mode, or a draw cell collapsed behind the compact "View SQL" editor:
-  // act as a grid so a shortcut never surfaces the chart from the editor. A
-  // collapsed draw cell drops to run mode first, so the grid — not the chart —
-  // is what appears.
-  return {
-    kind: opts.intent === "all" ? "run-all" : "run-single",
-    reveal,
-    exitDraw: cell.mode === "draw",
-  }
-}
+  cell: Pick<NotebookCell, "mode">,
+  opts: { intent: "all" | "single" },
+): RunActionPlan =>
+  cell.mode === "draw"
+    ? { kind: opts.intent === "all" ? "chart" : "noop" }
+    : { kind: opts.intent === "all" ? "run-all" : "run-single" }
 
 export type CellToolbarTier = "compact" | "standard" | "expanded"
 
@@ -136,10 +122,9 @@ export const cellToolbarTier = (
       : "compact"
 
 export type CellToolbarMenuFlags = {
-  showViewSql: boolean
   showViewTable: boolean
   showViewChart: boolean
-  showSplitItem: boolean
+  showEditorToggleItem: boolean
   showResetZoom: boolean
   showAutoRefreshItem: boolean
   showRefreshItem: boolean
@@ -155,14 +140,14 @@ export type CellToolbarMenuFlags = {
 // Which items the "more actions" menu shows. An item appears only when it is
 // applicable to the current state AND not already a visible toolbar button for
 // this tier/view, so the menu never duplicates an inline control or offers a
-// disabled/greyed action. `sqlShown` is the compact-tier "View SQL" state
-// (isViewMaximized === false). Markdown cells (no run/draw views) keep just the
-// move/duplicate/delete items.
+// disabled/greyed action. The compact tier has no inline view controls, so the
+// menu carries the same three controls the wider tiers show in the header:
+// the table/chart segments and the editor toggle, as checkable items.
+// Markdown cells (no run/draw views) keep just the move/duplicate/delete items.
 export const cellToolbarMenuFlags = (params: {
   tier: CellToolbarTier
   view: CellView
   isMarkdown: boolean
-  sqlShown: boolean
   chartZoomed: boolean
   isGridMode: boolean
   cellIndex: number
@@ -172,7 +157,6 @@ export const cellToolbarMenuFlags = (params: {
     tier,
     view,
     isMarkdown,
-    sqlShown,
     chartZoomed,
     isGridMode,
     cellIndex,
@@ -180,39 +164,29 @@ export const cellToolbarMenuFlags = (params: {
   } = params
   const isCompact = tier === "compact"
   const isChartView = view === "chart"
-  const isGridView = view === "grid"
   const isNoneView = view === "none"
-  const hasToolbarSplit = tier !== "compact" && !isNoneView
   const hasToolbarRefresh = tier === "expanded" && !isNoneView
   // The inline interval control rides on the refresh split-button, which the
   // expanded tier renders for grids as well as charts.
   const hasToolbarInterval = hasToolbarRefresh
-  const chartCollapsed = isCompact && isChartView && sqlShown
-
-  const showViewSql = isCompact && !isNoneView && !isMarkdown && !sqlShown
-  const showViewTable =
-    isCompact && !isMarkdown && (isNoneView || sqlShown || isChartView)
-  const showViewChart =
-    isCompact && !isMarkdown && (isNoneView || sqlShown || isGridView)
-  const showSplitItem = !hasToolbarSplit && !isNoneView && !isCompact
-  const showResetZoom =
-    isCompact && isChartView && chartZoomed && !chartCollapsed
-  // Auto-refresh applies to any cell showing a view, not just charts. Unlike
-  // Refresh it survives a collapsed chart: it patches cell state rather than
-  // publishing to the unmounted canvas.
+
+  const showViewTable = isCompact && !isMarkdown
+  const showViewChart = isCompact && !isMarkdown
+  const showEditorToggleItem = isCompact && !isNoneView && !isMarkdown
+  const showResetZoom = isCompact && isChartView && chartZoomed
+  // Auto-refresh applies to any cell showing a view, not just charts.
   const showAutoRefreshItem = !hasToolbarInterval && !isNoneView
-  const showRefreshItem = !hasToolbarRefresh && !isNoneView && !chartCollapsed
-  const showChartSettings = isChartView && !chartCollapsed
+  const showRefreshItem = !hasToolbarRefresh && !isNoneView
+  const showChartSettings = isChartView
   const showMoveUp = !isGridMode && cellIndex > 0
   const showMoveDown = !isGridMode && cellIndex < totalCells - 1
   const showDuplicate = totalCells < MAX_NOTEBOOK_CELLS
   const showDelete = totalCells > 1
 
   return {
-    showViewSql,
     showViewTable,
     showViewChart,
-    showSplitItem,
+    showEditorToggleItem,
     showResetZoom,
     showAutoRefreshItem,
     showRefreshItem,
@@ -221,8 +195,7 @@ export const cellToolbarMenuFlags = (params: {
     showMoveDown,
     showDuplicate,
     showDelete,
-    groupAHasItems:
-      showViewSql || showViewTable || showViewChart || showSplitItem,
+    groupAHasItems: showViewTable || showViewChart || showEditorToggleItem,
     groupBHasItems:
       showResetZoom ||
       showAutoRefreshItem ||
@@ -359,6 +332,95 @@ export const NOTEBOOK_ARCHIVED_MID_RUN_NOTE =
   "result was not recorded. Restore it and call get_notebook_state to see the " +
   "current cell state, and verify before re-running anything with side effects."
 
+// Why an in-flight run was cancelled. Transitions name the cause; the shells
+// carry it on the abort signal so both exits can report it.
+export type RunCancelReason =
+  | "result_cleared"
+  | "mode_changed"
+  | "cell_deleted"
+  | "notebook_archived"
+  | "notebook_deleted"
+  | "superseded"
+
+// A signal aborted without a known reason (the tool call itself was aborted).
+export type RunCancellation = RunCancelReason | "cancelled"
+
+const RUN_CANCEL_REASONS: ReadonlySet<string> = new Set<RunCancelReason>([
+  "result_cleared",
+  "mode_changed",
+  "cell_deleted",
+  "notebook_archived",
+  "notebook_deleted",
+  "superseded",
+])
+
+export const runCancellationOf = (signal: AbortSignal): RunCancellation =>
+  typeof signal.reason === "string" && RUN_CANCEL_REASONS.has(signal.reason)
+    ? (signal.reason as RunCancelReason)
+    : "cancelled"
+
+const describeRunCancellation = (reason: RunCancellation): string => {
+  switch (reason) {
+    case "result_cleared":
+      return "the cell's result view was cleared"
+    case "mode_changed":
+      return "the cell was switched to chart mode"
+    case "cell_deleted":
+      return "the cell was deleted"
+    case "notebook_archived":
+      return "the notebook was archived"
+    case "notebook_deleted":
+      return "the notebook was deleted"
+    case "superseded":
+      return "a newer run of this cell started"
+    case "cancelled":
+      return "the request was cancelled"
+  }
+}
+
+export const cancelledBeforeRunNote = (reason: RunCancellation): string =>
+  `Run NOT started: ${describeRunCancellation(reason)} before validation ` +
+  "finished, so nothing was executed. Call get_notebook_state to see the " +
+  "current cell state; it is safe to re-run."
+
+export const MODE_CHANGED_MID_RUN_NOTE =
+  "Run completed, but the cell was switched to chart mode while it was " +
+  "running, so the result was not recorded; the chart now owns the cell. " +
+  "Call get_notebook_state to see the current cell state, and verify before " +
+  "re-running anything with side effects."
+
+export const CANCELLED_MID_RUN_NOTE =
+  "Run completed, but it was cancelled while it was running, so the result " +
+  "was not recorded. Call get_notebook_state to see the current cell state, " +
+  "and verify before re-running anything with side effects."
+
+export const midRunCancellationNote = (reason: RunCancellation): string => {
+  switch (reason) {
+    case "result_cleared":
+      return RESULT_CLEARED_MID_RUN_NOTE
+    case "mode_changed":
+      return MODE_CHANGED_MID_RUN_NOTE
+    case "cell_deleted":
+      return CELL_DELETED_MID_RUN_NOTE
+    case "notebook_archived":
+      return NOTEBOOK_ARCHIVED_MID_RUN_NOTE
+    case "notebook_deleted":
+      return NOTEBOOK_DELETED_MID_RUN_NOTE
+    case "superseded":
+      return SUPERSEDED_RUN_NOTE
+    case "cancelled":
+      return CANCELLED_MID_RUN_NOTE
+  }
+}
+
+export const cancelledBeforeLaunchSummary = (reason: RunCancellation) => ({
+  success: false,
+  queryCount: 0,
+  results: [] as string[],
+  cancelled: reason,
+  note: cancelledBeforeRunNote(reason),
+})
+
 export const STORAGE_FULL_RUN_NOTE =
   "Run completed, but the result could not be saved because the browser's " +
   "local storage limit is exceeded, so it was NOT recorded. Tell the user to " +
@@ -384,6 +446,9 @@ export type CellRunOutcome = {
   cellChanged?: boolean
   notStarted?: boolean
   resultCleared?: boolean
+  // Why a cancelled run stopped. With notStarted it was stopped before any
+  // SQL launched; otherwise the result was discarded at commit.
+  cancelled?: RunCancellation
   // Barrier decisions for gated (agent) runs: a permission denial or an
   // auto-run write skip. Nothing executed when either is set.
   denied?: string
@@ -490,12 +555,20 @@ export const runHistoryPatch = (
 }
 
 export const stripCellResults = (cells: NotebookCell[]): NotebookCell[] =>
-  cells.map((cell) => ({
-    ...cell,
-    result: undefined,
-    lastRunStatus: carriedRunStatus(cell),
-    lastRunError: carriedRunError(cell),
-  }))
+  cells.map((cell) => {
+    const persisted: NotebookCell = {
+      ...cell,
+      result: undefined,
+      lastRunStatus: carriedRunStatus(cell),
+      lastRunError: carriedRunError(cell),
+    }
+    if (cell.type === "markdown") delete persisted.paneView
+    else persisted.paneView = cell.paneView ?? "editor_result"
+    const canonical = persisted as NotebookCell & Record<string, unknown>
+    if (canonical.mode !== "draw") delete canonical.mode
+    delete canonical.isViewMaximized
+    return persisted
+  })
 
 export const buildPersistPayload = (
   cells: NotebookCell[],
@@ -601,6 +674,7 @@ export const insertCell = (
   if (override?.type) patch.type = override.type
   const created: NotebookCell =
     Object.keys(patch).length > 0 ? { ...base, ...patch } : base
+  if (created.type === "markdown") delete created.paneView
   const newCell: NotebookCell =
     created.type === "markdown" || created.topHeight !== undefined
       ? created
@@ -698,9 +772,11 @@ type ApplyCellRequest = {
   type?: CellType | null
   mode?: CellMode | null
   autoRefresh?: AutoRefresh | null
-  isViewMaximized?: boolean | null
+  editorHeight?: number | "auto" | null
+  resultHeight?: number | "auto" | null
+  view?: AgentCellView | null
   chartConfig?: ChartConfig | null
-  grid?: { x: number; y: number; w: number; h: number } | null
+  grid?: { x: number; y: number; w: number } | null
 }
 
 type ApplyRequest = {
@@ -738,6 +814,20 @@ export const nextCopyLabel = (label: string): string => {
   return `${match[1]} (copy ${n + 1})`
 }
 
+// Result identity ignores presentation-only edits while preserving SQL values:
+// the formatter canonicalizes whitespace/newlines and keyword casing, but does
+// not fold string literals or quoted/unquoted identifiers. Invalid, mid-typing
+// SQL falls back to the editor's trim/trailing-semicolon normalization.
+export const normalizeStatementIdentity = (query: string): string => {
+  const normalized = normalizeQueryText(query)
+  if (!normalized) return normalized
+  try {
+    return formatSql(normalized, { uppercase: true })
+  } catch {
+    return normalized
+  }
+}
+
 export const snapshotResultsMatchQueries = (
   results: SingleQueryResult[],
   queries: string[],
@@ -746,7 +836,8 @@ export const snapshotResultsMatchQueries = (
   results.length === queries.length &&
   results.every(
     (result, index) =>
-      normalizeQueryText(result.query) === normalizeQueryText(queries[index]),
+      normalizeStatementIdentity(result.query) ===
+      normalizeStatementIdentity(queries[index]),
   )
 
 // Statement identity across edits: normalized text plus occurrence order for
@@ -755,16 +846,23 @@ export type StatementKey = string
 
 const STATEMENT_KEY_SEPARATOR = "\u0001"
 
-export const statementKeysFor = (texts: string[]): StatementKey[] => {
+export const statementKeysForIdentities = (
+  identities: string[],
+): StatementKey[] => {
   const occurrences = new Map<string, number>()
-  return texts.map((text) => {
-    const normalized = normalizeQueryText(text)
-    const occurrence = occurrences.get(normalized) ?? 0
-    occurrences.set(normalized, occurrence + 1)
-    return `${normalized}${STATEMENT_KEY_SEPARATOR}${occurrence}`
+  return identities.map((identity) => {
+    const occurrence = occurrences.get(identity) ?? 0
+    occurrences.set(identity, occurrence + 1)
+    return `${identity}${STATEMENT_KEY_SEPARATOR}${occurrence}`
   })
 }
 
+export const statementKeysFor = (texts: string[]): StatementKey[] =>
+  statementKeysForIdentities(texts.map(normalizeStatementIdentity))
+
+export const statementIdentityOfKey = (key: StatementKey): string =>
+  key.slice(0, key.lastIndexOf(STATEMENT_KEY_SEPARATOR))
+
 const clampIndex = (index: number, length: number): number =>
   Math.min(Math.max(index, 0), Math.max(length - 1, 0))
 
@@ -788,12 +886,12 @@ export type ReconciledCellResult = {
   activeResultIndex: number
 }
 
-export const reconcileResultsForStatements = (
+export const reconcileResultsForSlotKeys = (
   statements: string[],
+  slotKeys: StatementKey[],
   previous: CellResult,
 ): ReconciledCellResult | null => {
   if (statements.length === 0 || previous.results.length === 0) return null
-  const slotKeys = statementKeysFor(statements)
   const resultKeys = statementKeysFor(previous.results.map((r) => r.query))
   const oldIndexByKey = new Map<StatementKey, number>()
   resultKeys.forEach((key, index) => oldIndexByKey.set(key, index))
@@ -830,13 +928,37 @@ export const reconcileResultsForStatements = (
   }
 }
 
+export const reconcileResultsForStatements = (
+  statements: string[],
+  previous: CellResult,
+): ReconciledCellResult | null =>
+  reconcileResultsForSlotKeys(
+    statements,
+    statementKeysFor(statements),
+    previous,
+  )
+
+// Passive invalidation and mounted hydration must agree about whether a
+// snapshot contains anything displayable. In particular, matching
+// running/queued placeholders are not durable results.
+export const snapshotResultsHaveMatchingStatement = (
+  results: SingleQueryResult[],
+  statements: string[],
+): boolean =>
+  reconcileResultsForStatements(statements, {
+    results,
+    activeResultIndex: 0,
+    timestamp: 0,
+  }) !== null
+
 // Applies the carryover to a cell's in-memory result after an SQL edit:
 // unchanged statements keep their results, everything else drops. A frame
 // that loses slots also loses its script summary — the counts no longer
 // describe what is on screen. Zero survivors collapse the frame to null.
-export const reconcileCellResultForValue = (
+export const reconcileCellResultForStatements = (
   result: CellResult | null | undefined,
-  value: string,
+  statements: string[],
+  slotKeys: StatementKey[],
 ): CellResult | null => {
   if (result == null) return null
   // A pending frame is run-owned: the run writes results into it by position,
@@ -844,10 +966,7 @@ export const reconcileCellResultForValue = (
   // stays pending until the run's last slot settles, and every completion step
   // after that runs synchronously — deferring the reconcile is always safe.
   if (hasPendingResult(result)) return result
-  const reconciled = reconcileResultsForStatements(
-    getQueriesFromText(value),
-    result,
-  )
+  const reconciled = reconcileResultsForSlotKeys(statements, slotKeys, result)
   if (!reconciled) return null
   const frameUnchanged =
     reconciled.results.length === result.results.length &&
@@ -862,6 +981,18 @@ export const reconcileCellResultForValue = (
   return next
 }
 
+export const reconcileCellResultForValue = (
+  result: CellResult | null | undefined,
+  value: string,
+): CellResult | null => {
+  const statements = getQueriesFromText(value)
+  return reconcileCellResultForStatements(
+    result,
+    statements,
+    statementKeysFor(statements),
+  )
+}
+
 export type StatementSlot = {
   key: StatementKey
   sql: string
@@ -1066,8 +1197,29 @@ export const buildAppliedCells = (
         "cells",
       )
     }
+    const existingKind: CellType = existing?.type ?? "sql"
+    if (existing && req.type != null && req.type !== existingKind) {
+      throw new ApplyNotebookStateError(
+        `Cell "${existing.id}" is ${existingKind}; cell kind cannot change. Delete it and add a new cell.`,
+        "cells",
+      )
+    }
+    const resolvedType: CellType | undefined = existing
+      ? existing.type
+      : (req.type ?? undefined)
+
+    // A markdown cell can carry a stored mode only through legacy import
+    // leakage; inheriting it would make every apply that preserves the cell
+    // fail on advice the agent already followed. Dropping it heals the cell
+    // on write — only an explicitly requested mode is the agent's error.
     const resolvedMode: CellMode | undefined =
-      req.mode === undefined || req.mode === null ? existing?.mode : req.mode
+      resolvedType === "markdown"
+        ? undefined
+        : req.view === "editor"
+          ? undefined
+          : req.mode === undefined || req.mode === null
+            ? existing?.mode
+            : req.mode
 
     // PUT semantics: a non-empty string sets the name, null/"" clears it.
     const resolvedName =
@@ -1082,16 +1234,9 @@ export const buildAppliedCells = (
 
     const chartConfig = normalizeChartConfig(req.chartConfig)
 
-    // Cell kind and mode are sticky: omission preserves the existing cell.
-    // Converting a markdown cell to SQL by omission would silently turn prose
-    // into a runnable query, so only an explicit type can do that.
-    const resolvedType: CellType | undefined =
-      req.type === undefined || req.type === null ? existing?.type : req.type
-
     // Markdown cells hold prose, not editor SQL, so they're exempt from the cap.
-    const preservesStoredSql = preserve && existing?.type !== "markdown"
     if (
-      !preservesStoredSql &&
+      !preserve &&
       resolvedType !== "markdown" &&
       exceedsCellLineLimit(value)
     ) {
@@ -1102,7 +1247,7 @@ export const buildAppliedCells = (
     }
 
     if (resolvedType === "markdown") {
-      if (resolvedMode !== undefined) {
+      if (req.mode != null) {
         throw new ApplyNotebookStateError(
           `Cell at index ${index} is a markdown cell and cannot have a mode. Omit mode and chart_config for markdown cells.`,
           "cells",
@@ -1151,14 +1296,70 @@ export const buildAppliedCells = (
       )
     }
 
+    if (hasExplicitModeForEditor(req.mode, req.view)) {
+      throw new ApplyNotebookStateError(
+        `Cell at index ${index} combines an explicit mode with view "editor". Editor view clears the stored result and hides the result pane. Set mode to null to request an editor-only view.`,
+        "cells",
+      )
+    }
+
     const isDraw = resolvedMode === "draw"
-    const isViewMaximized =
-      req.isViewMaximized != null
-        ? req.isViewMaximized
-        : isDraw
-          ? true
-          : undefined
-    const autoRefresh = req.autoRefresh != null ? req.autoRefresh : undefined
+    const dimensionCell: NotebookCell = {
+      ...(existing ?? { id, position: index, value, type: resolvedType }),
+      value,
+    }
+    if (isDraw) dimensionCell.mode = "draw"
+    else delete dimensionCell.mode
+    const validation = validateAgentCellDimensions(dimensionCell, {
+      editorHeight: req.editorHeight,
+      resultHeight: req.resultHeight,
+      view: req.view,
+    })
+    if (!validation.ok) {
+      const { issue } = validation
+      if (issue.reason === "invalid_view") {
+        throw new ApplyNotebookStateError(
+          `Cell at index ${index} has an invalid view; use editor, result, or editor_result.`,
+          "cells",
+        )
+      }
+      if (issue.reason === "invalid_type") {
+        throw new ApplyNotebookStateError(
+          `Cell at index ${index} has an invalid ${issue.field}; use a number, auto, or null.`,
+          "cells",
+        )
+      }
+      if (issue.reason === "below_minimum") {
+        const message =
+          issue.field === "editor_height"
+            ? `Cell at index ${index} has an editor_height below its minimum.`
+            : `Cell at index ${index} has result_height ${issue.value}px; minimum is ${issue.limit}px.`
+        throw new ApplyNotebookStateError(message, "cells")
+      }
+      throw new ApplyNotebookStateError(
+        `Cell at index ${index} has ${issue.field} ${issue.value}px; maximum is ${issue.limit}px.`,
+        "cells",
+      )
+    }
+    const { dimensions } = validation
+    const dimensionsPatch = agentCellDimensionsPatch(dimensionCell, dimensions)
+    if (req.view == null && !existing && isDraw) {
+      dimensionsPatch.paneView = "result"
+    }
+    const autoRefresh =
+      req.autoRefresh != null && resolvedType !== "markdown"
+        ? req.autoRefresh
+        : undefined
+
+    if (req.grid) {
+      const gridError = cellGridBoundsError(req.grid)
+      if (gridError) {
+        throw new ApplyNotebookStateError(
+          `Cell at index ${index} has invalid grid placement: ${gridError}`,
+          "cells",
+        )
+      }
+    }
 
     if (existing) {
       updated.push(existing.id)
@@ -1166,7 +1367,7 @@ export const buildAppliedCells = (
       // Results carry over by statement content: unchanged statements keep
       // theirs, zero survivors collapse the frame. A released cell (result on
       // disk only) keeps its snapshot — hydration reconciles it on load.
-      const next: NotebookCell = {
+      let next: NotebookCell = {
         ...existing,
         id: existing.id,
         position: index,
@@ -1186,35 +1387,27 @@ export const buildAppliedCells = (
         if (carried !== undefined) next.lastRunStatus = carried
         if (carriedError !== undefined) next.lastRunError = carriedError
         else delete next.lastRunError
-      }
-      const hadRunResult =
-        existing.result != null ||
-        (existing.lastRunStatus != null && existing.lastRunStatus !== "none")
-      if ((resolvedType === "markdown" && hadRunResult) || resultDropped) {
         resultsCleared.push(existing.id)
       }
-      if (resolvedMode !== undefined) next.mode = resolvedMode
+      if (isDraw) next.mode = "draw"
       else delete next.mode
+      if ((existing.mode === "draw") !== isDraw) {
+        Object.assign(next, cellModeChangePatch(next, resolvedMode ?? "run"))
+      }
       if (chartConfig !== undefined) next.chartConfig = chartConfig
       else delete next.chartConfig
       if (autoRefresh !== undefined) next.autoRefresh = autoRefresh
       else delete next.autoRefresh
-      if (isViewMaximized !== undefined) next.isViewMaximized = isViewMaximized
-      else delete next.isViewMaximized
-      if (resolvedType === "markdown") {
-        // Markdown cells carry none of the SQL/chart sub-state.
-        next.type = "markdown"
-        next.result = null
-        delete next.mode
-        delete next.chartConfig
-        delete next.autoRefresh
-        delete next.isViewMaximized
-        delete next.bottomHeight
-        delete next.lastRunStatus
-        delete next.lastRunError
-      } else {
-        delete next.type
-        if (valueChanged && !existing.topResized) {
+      if (req.view === "editor" && cellHasRunOutcome(existing)) {
+        next = discardCellResult(next)
+        if (!resultsCleared.includes(existing.id)) {
+          resultsCleared.push(existing.id)
+        }
+      }
+      Object.assign(next, dimensionsPatch)
+      if (resolvedType !== "markdown") {
+        next.paneView ??= "editor_result"
+        if (valueChanged && !next.topResized) {
           const estimated = topHeightForSql(value)
           if (
             existing.topHeight == null ||
@@ -1238,19 +1431,21 @@ export const buildAppliedCells = (
     if (resolvedName !== undefined) created.name = resolvedName
     if (resolvedType === "markdown") {
       created.type = "markdown"
+      Object.assign(created, dimensionsPatch)
       return created
     }
     created.topHeight = topHeightForSql(value)
-    if (resolvedMode !== undefined) created.mode = resolvedMode
+    created.paneView = "editor_result"
+    if (resolvedMode === "draw") created.mode = "draw"
     if (chartConfig !== undefined) created.chartConfig = chartConfig
     if (autoRefresh !== undefined) created.autoRefresh = autoRefresh
-    if (isViewMaximized !== undefined) created.isViewMaximized = isViewMaximized
     // Draw cells are double-view from creation (chart visible immediately),
     // so seed bottomHeight with the chart default. Run cells stay single-
     // view (no bottomHeight) until the user runs them.
     if (resolvedMode === "draw") {
       created.bottomHeight = DEFAULT_CHART_BOTTOM_HEIGHT
     }
+    Object.assign(created, dimensionsPatch)
     return created
   })
 
@@ -1276,14 +1471,13 @@ export const buildAppliedCells = (
 // === Cell sizing model ======================================================
 // Cells are in one of two view states:
 //
-//   - Single-view: only the editor (or only the expanded chart) is visible.
-//     Total cell height = topHeight + chrome.
-//   - Double-view: editor on top + result/chart on bottom.
-//     Total cell height = topHeight + bottomHeight + chrome.
+//   - Editor visible, no result: topHeight + chrome.
+//   - Editor visible with result: topHeight + bottomHeight + split chrome.
+//   - Editor hidden: bottomHeight + chrome. topHeight stays persisted but does
+//     not consume space, so restoring the editor expands around both panes.
 //
-// `topHeight` and `bottomHeight` live on NotebookCell; they replace the four
-// `custom*Height` fields from the old model. In grid mode, the grid h (rows)
-// is *derived* from topHeight + bottomHeight on every render.
+// `topHeight` and `bottomHeight` live on NotebookCell. In grid mode, grid h is
+// derived from the currently visible pane heights on every render.
 // ============================================================================
 
 // Exact fixed chrome every cell carries, in pixels:
@@ -1306,7 +1500,7 @@ export const CELL_EDITOR_LINE_HEIGHT = 24
 export const CELL_EDITOR_PADDING = { top: 4, bottom: 4 }
 
 export const topHeightForSql = (value: string): number =>
-  Math.max(
+  clampPaneHeight(
     DEFAULT_TOP_HEIGHT,
     value.split("\n").length * CELL_EDITOR_LINE_HEIGHT +
       CELL_EDITOR_PADDING.top +
@@ -1314,15 +1508,169 @@ export const topHeightForSql = (value: string): number =>
   )
 
 // Markdown cells carry the base chrome only (they never split) and keep their
-// heights on the grid-row lattice (26, 56, 86, …) so the derived cell box is
+// heights on the grid-row lattice (56, 86, 116, …) so the derived cell box is
 // always exact — see snapMarkdownTopHeight.
-export const MARKDOWN_DEFAULT_TOP_HEIGHT = 56
-export const MIN_MARKDOWN_HEIGHT_PX = 26
+// One line of rendered prose is 34px, so 56 is the first lattice point that
+// shows any content. Stored heights below it render as they are until the next
+// resize writes a new value.
+export const MIN_MARKDOWN_HEIGHT_PX = 56
 
 // Default chart height for draw mode (experimental — per user spec).
 export const DEFAULT_CHART_BOTTOM_HEIGHT = 350
 
 export const MIN_BOTTOM_HEIGHT_PX = 100
+// ECharts reserves roughly 96-126 px for axes, labels, and the zoom control.
+// A 100 px chart pane is structurally valid but leaves no useful plot. Keep
+// table results at the historical minimum while giving charts a visual floor.
+export const MIN_CHART_HEIGHT_PX = 296
+// One ceiling for every pane: it only stops nonsense such as multi-million
+// pixel agent writes or an editor auto-grown to a hundred thousand lines.
+export const MAX_PANE_HEIGHT_PX = 2400
+
+export const clampPaneHeight = (minimum: number, px: number): number =>
+  Math.min(MAX_PANE_HEIGHT_PX, Math.max(minimum, px))
+
+export const minBottomHeightFor = (cell: NotebookCell): number =>
+  cell.mode === "draw" ? MIN_CHART_HEIGHT_PX : MIN_BOTTOM_HEIGHT_PX
+
+export type AgentHeightValue = number | "auto" | null
+
+// Reads a cell's live snapshot-load status; the passive (unmounted) route has
+// no live statuses and falls back to "unrequested", matching what the mounted
+// notebook renders for a run-marked cell before its snapshot loads.
+export type CellResultStatusReader = (cellId: string) => CellResultStatus
+
+export type AgentCellDimensions = {
+  editorHeight?: AgentHeightValue
+  resultHeight?: AgentHeightValue
+  view?: AgentCellView | null
+  resultStatus?: CellResultStatus
+}
+
+export const applicableCellDimensions = (
+  cell: Pick<NotebookCell, "type">,
+  dimensions: AgentCellDimensions,
+): AgentCellDimensions =>
+  cell.type === "markdown"
+    ? { ...dimensions, resultHeight: null, view: null }
+    : dimensions
+
+export type AgentCellDimensionsValidationIssue =
+  | { reason: "invalid_view" }
+  | {
+      field: "editor_height" | "result_height"
+      reason: "invalid_type"
+    }
+  | {
+      field: "editor_height" | "result_height"
+      reason: "below_minimum" | "above_maximum"
+      value: number
+      limit: number
+    }
+
+export type AgentCellDimensionsValidation =
+  | { ok: true; dimensions: AgentCellDimensions }
+  | { ok: false; issue: AgentCellDimensionsValidationIssue }
+
+// One validator for both set_cell_dimensions and apply_notebook_state. The
+// callers keep their tool-specific error types/messages, while contextual
+// minima and the shared ceiling cannot drift between the two entry points.
+export const validateAgentCellDimensions = (
+  cell: NotebookCell,
+  requested: AgentCellDimensions,
+): AgentCellDimensionsValidation => {
+  if (requested.view != null && !isAgentCellView(requested.view)) {
+    return { ok: false, issue: { reason: "invalid_view" } }
+  }
+  const dimensions = applicableCellDimensions(cell, requested)
+  const values = [
+    {
+      field: "editor_height" as const,
+      value: dimensions.editorHeight,
+      minimum: minTopHeightFor(cell),
+    },
+    {
+      field: "result_height" as const,
+      value: dimensions.resultHeight,
+      minimum: minBottomHeightFor(cell),
+    },
+  ]
+  for (const { field, value, minimum } of values) {
+    if (value === undefined || value === null || value === "auto") continue
+    if (typeof value !== "number") {
+      return { ok: false, issue: { field, reason: "invalid_type" } }
+    }
+    if (!Number.isFinite(value) || value < minimum) {
+      return {
+        ok: false,
+        issue: {
+          field,
+          reason: "below_minimum",
+          value,
+          limit: minimum,
+        },
+      }
+    }
+    if (value > MAX_PANE_HEIGHT_PX) {
+      return {
+        ok: false,
+        issue: {
+          field,
+          reason: "above_maximum",
+          value,
+          limit: MAX_PANE_HEIGHT_PX,
+        },
+      }
+    }
+  }
+  return { ok: true, dimensions }
+}
+
+// The agent's view:"editor" is the toggle-off gesture, not a stored value:
+// discard the run outcome, keeping the stored pane arrangement for the next
+// result. Callers also delete the draw marker and persisted snapshot.
+export const discardCellResult = (cell: NotebookCell): NotebookCell => {
+  const next: NotebookCell = {
+    ...cell,
+    result: undefined,
+    lastRunStatus: undefined,
+    ...(cell.bottomResized ? {} : { bottomHeight: undefined }),
+  }
+  delete next.mode
+  return next
+}
+
+// Translate the semantic agent wire model into the persisted pane model.
+// `null`/omission preserves, "auto" clears the corresponding resize pin, and
+// a number fixes the pane at that pixel height. view:"editor" is an action,
+// not a stored value — callers apply discardCellResult for it.
+// A markdown cell's unpinned topHeight is the content measurement its
+// ResizeObserver keeps current, so "auto" only clears the pin: an unpinned
+// cell keeps its measurement, and a pinned one re-measures on the flip.
+export const agentCellDimensionsPatch = (
+  cell: NotebookCell,
+  dimensions: AgentCellDimensions,
+): Partial<NotebookCell> => {
+  const patch: Partial<NotebookCell> = {}
+  if (dimensions.editorHeight === "auto") {
+    if (cell.type !== "markdown") patch.topHeight = topHeightForSql(cell.value)
+    patch.topResized = false
+  } else if (typeof dimensions.editorHeight === "number") {
+    patch.topHeight = dimensions.editorHeight
+    patch.topResized = true
+  }
+  if (dimensions.resultHeight === "auto") {
+    patch.bottomHeight = undefined
+    patch.bottomResized = false
+  } else if (typeof dimensions.resultHeight === "number") {
+    patch.bottomHeight = dimensions.resultHeight
+    patch.bottomResized = true
+  }
+  if (isCellPaneView(dimensions.view) && cell.type !== "markdown") {
+    patch.paneView = dimensions.view
+  }
+  return patch
+}
 
 // Pixel sizes of the result panel's chrome. Kept in sync with the styled-
 // components in result-table/styles.ts; if those constants change, update
@@ -1454,15 +1802,76 @@ export const defaultBottomHeightFor = (cell: NotebookCell): number =>
     ? DEFAULT_CHART_BOTTOM_HEIGHT
     : computeResultBottomHeight(cell.result, cell.value)
 
-// True iff this cell occupies vertical space for a bottom slot — i.e. its
-// total height includes bottomHeight. This includes the chart-expanded case
-// (chart fills both slots; the cell footprint still spans topHeight +
-// bottomHeight).
+// True iff this cell has a result slot. Visibility determines whether the
+// editor allocation is added alongside that slot.
 export const isDoubleView = (cell: NotebookCell): boolean => {
   if (cell.mode === "draw") return true
   return cell.result != null
 }
 
+export type CellPaneLayout = "editor" | "split" | "result"
+
+export const storedCellPaneView = (cell: NotebookCell): CellPaneView =>
+  isCellPaneView(cell.paneView) ? cell.paneView : "editor_result"
+
+// A run outcome is anything view:"editor" would discard: an in-memory result,
+// a carried run status (result on disk only), or draw mode itself.
+export const cellHasRunOutcome = (cell: NotebookCell): boolean =>
+  cell.mode === "draw" ||
+  cell.result != null ||
+  (cell.lastRunStatus != null && cell.lastRunStatus !== "none")
+
+export type AgentCellPresentation = {
+  view: AgentCellView | null
+  mode: CellMode | null
+}
+
+// `view` reports what the cell presents: "editor" while there is nothing to
+// show, the stored arrangement once a run outcome exists. A live, known-missing
+// run snapshot has historical status but no result pane; draw mode remains a
+// result presentation because the chart itself is the mode.
+export const agentCellPresentation = (
+  cell: NotebookCell,
+  resultStatus: CellResultStatus = "unrequested",
+): AgentCellPresentation => {
+  const view: AgentCellView | null =
+    cell.type === "markdown"
+      ? null
+      : cellHasRunOutcome(cell) &&
+          !(
+            cell.mode !== "draw" &&
+            cell.result == null &&
+            resultStatus === "missing"
+          )
+        ? storedCellPaneView(cell)
+        : "editor"
+
+  return {
+    view,
+    mode:
+      view === null || view === "editor"
+        ? null
+        : cell.mode === "draw"
+          ? "draw"
+          : "run",
+  }
+}
+
+export const hasExplicitModeForEditor = (
+  mode: CellMode | null | undefined,
+  view: AgentCellView | null | undefined,
+): boolean => view === "editor" && mode != null
+
+// A cell without a result shows the editor until one exists; that never
+// rewrites its stored view.
+export const resolveCellPaneLayout = (
+  cell: NotebookCell,
+  expectingResult: boolean = false,
+): CellPaneLayout => {
+  if (!isDoubleView(cell) && !expectingResult) return "editor"
+  return storedCellPaneView(cell) === "result" ? "result" : "split"
+}
+
 // bottomHeight seeding when a cell flips between run and draw. A user-resized
 // bottom slot is never overridden.
 export const modeChangeBottomHeightPatch = (
@@ -1483,10 +1892,7 @@ export const modeChangeBottomHeightPatch = (
 export const cellModeChangePatch = (
   cell: NotebookCell | undefined,
   mode: CellMode,
-): Partial<NotebookCell> => ({
-  ...modeChangeBottomHeightPatch(cell, mode),
-  ...(mode === "draw" ? { isViewMaximized: false } : {}),
-})
+): Partial<NotebookCell> => modeChangeBottomHeightPatch(cell, mode)
 
 export const mergeCellChartConfig = (
   cell: NotebookCell,
@@ -1515,24 +1921,56 @@ export const patchCellRunResult = (
   })
 
 // Exact per-state chrome. Split cells (editor above, result/chart or its
-// reserved shimmer below) add the in-flow divider; a view-maximized cell hides
-// both the editor and the divider — its bottom slot spans topHeight +
-// bottomHeight — so it carries the base chrome only, like markdown.
+// reserved shimmer below) add the in-flow divider; an editor-hidden cell
+// carries base chrome only.
 export const cellChromePx = (
   cell: NotebookCell,
   expectingResult: boolean = false,
+  paneLayout: CellPaneLayout = resolveCellPaneLayout(cell, expectingResult),
 ): number => {
   if (cell.type === "markdown") return CELL_BASE_CHROME_PX
-  const split =
-    (isDoubleView(cell) || expectingResult) && cell.isViewMaximized !== true
-  return split ? CELL_BASE_CHROME_PX + SPLIT_HANDLE_PX : CELL_BASE_CHROME_PX
+  return paneLayout === "split"
+    ? CELL_BASE_CHROME_PX + SPLIT_HANDLE_PX
+    : CELL_BASE_CHROME_PX
 }
 
 export const minTopHeightFor = (cell: NotebookCell): number =>
   cell.type === "markdown" ? MIN_MARKDOWN_HEIGHT_PX : DEFAULT_TOP_HEIGHT
 
 const defaultTopHeightFor = (cell: NotebookCell): number =>
-  cell.type === "markdown" ? MARKDOWN_DEFAULT_TOP_HEIGHT : DEFAULT_TOP_HEIGHT
+  cell.type === "markdown" ? MIN_MARKDOWN_HEIGHT_PX : DEFAULT_TOP_HEIGHT
+
+export const agentCellPaneDimensions = (
+  cell: NotebookCell,
+): {
+  editorHeight: number | "auto"
+  resultHeight: number | "auto" | null
+} => {
+  const pinnedHeight = (
+    resized: boolean | undefined,
+    height: number | undefined,
+    minimum: number,
+  ): number | "auto" =>
+    resized && typeof height === "number" && Number.isFinite(height)
+      ? clampPaneHeight(minimum, height)
+      : "auto"
+
+  return {
+    editorHeight: pinnedHeight(
+      cell.topResized,
+      cell.topHeight,
+      minTopHeightFor(cell),
+    ),
+    resultHeight:
+      cell.type === "markdown"
+        ? null
+        : pinnedHeight(
+            cell.bottomResized,
+            cell.bottomHeight,
+            minBottomHeightFor(cell),
+          ),
+  }
+}
 
 // Resolves a cell's editor (top) and bottom-slot heights — shared by the
 // rendered cell (Cell.tsx, with live drag overrides) and computeCellGridH.
@@ -1546,7 +1984,7 @@ export const computeCellHeights = (
 ): { topHeight: number; bottomHeight: number } => {
   const topHeight =
     opts.liveTopHeight ?? cell.topHeight ?? defaultTopHeightFor(cell)
-  const bottomHeight = isDoubleView(cell)
+  const resolvedBottomHeight = isDoubleView(cell)
     ? (opts.liveBottomHeight ??
       cell.bottomHeight ??
       defaultBottomHeightFor(cell))
@@ -1555,6 +1993,14 @@ export const computeCellHeights = (
         cell.bottomHeight ??
         RESERVED_RESULT_BOTTOM_HEIGHT)
       : 0
+  // A visible bottom slot never renders below its pane floor (296 chart /
+  // 100 result): a bare notification sits in a 100px pane rather than a
+  // 44px sliver, so the rendered height, the resize bounds, and the save
+  // path all share one minimum.
+  const bottomHeight =
+    resolvedBottomHeight === 0
+      ? 0
+      : Math.max(minBottomHeightFor(cell), resolvedBottomHeight)
   return { topHeight, bottomHeight }
 }
 
@@ -1564,9 +2010,20 @@ export const NOTEBOOK_GRID_COLS = 12
 export const NOTEBOOK_GRID_ROW_HEIGHT = 10
 export const NOTEBOOK_GRID_MARGIN_Y = 20
 
-// Derives the react-grid-layout `h` (row count) for a cell from its
-// topHeight + bottomHeight + chrome. Recomputed at render time on every
-// state change.
+export const cellGridBoundsError = (pos: {
+  x: number
+  w: number
+}): string | undefined =>
+  pos.x + pos.w > NOTEBOOK_GRID_COLS
+    ? `x + w must be at most ${NOTEBOOK_GRID_COLS}.`
+    : undefined
+
+export type CellGridBounds = { h: number; minH: number; maxH: number }
+
+// Derives react-grid-layout `h` and its resize bounds from the visible pane
+// heights plus chrome — one computation, so the three numbers can never
+// disagree and `minH ≤ h ≤ maxH` holds for every in-bounds cell state.
+// Recomputed at render time on every state change.
 //
 // react-grid-layout inserts `marginY` BETWEEN rows, so the actual
 // rendered px of an h-row cell is `h * rowHeight + (h - 1) * marginY`,
@@ -1576,35 +2033,79 @@ export const NOTEBOOK_GRID_MARGIN_Y = 20
 // marginY=20 (a 500-px content asked for 50 rows that rendered as
 // ~1480 px). Default marginY=0 keeps backwards-compat for tests/callers
 // that ignore margins.
-export const computeCellGridH = (
+//
+// In a split cell the south edge owns only the result pane, so the bounds
+// reserve the editor's current allocation rather than merely its minimum.
+// The middle handle is the only control that repartitions the two panes.
+// Legacy heights stored outside the pane floors/ceiling deliberately render
+// as-is; their first drag snaps them into the new bounds.
+export const computeCellGridBounds = (
   cell: NotebookCell,
   rowHeight: number,
   marginY: number = 0,
   expectingResult: boolean = false,
-): number => {
+  paneLayout: CellPaneLayout = resolveCellPaneLayout(cell, expectingResult),
+): CellGridBounds => {
   const { topHeight, bottomHeight } = computeCellHeights(cell, {
     expectingResult,
   })
-  const totalPx = cellChromePx(cell, expectingResult) + topHeight + bottomHeight
-  return Math.max(1, Math.ceil((totalPx + marginY) / (rowHeight + marginY)))
+  const chrome = cellChromePx(cell, expectingResult, paneLayout)
+  const rows = (px: number): number =>
+    Math.max(1, Math.ceil((px + marginY) / (rowHeight + marginY)))
+  const visibleTopHeight = paneLayout === "result" ? 0 : topHeight
+  const visibleBottomHeight = paneLayout === "editor" ? 0 : bottomHeight
+  const minTopPx =
+    paneLayout === "result"
+      ? 0
+      : paneLayout === "editor"
+        ? minTopHeightFor(cell)
+        : Math.max(minTopHeightFor(cell), topHeight)
+  const maxTopPx =
+    paneLayout === "result"
+      ? 0
+      : paneLayout === "split"
+        ? topHeight
+        : MAX_PANE_HEIGHT_PX
+  const minBottomPx = paneLayout === "editor" ? 0 : minBottomHeightFor(cell)
+  const maxBottomPx = paneLayout === "editor" ? 0 : MAX_PANE_HEIGHT_PX
+  return {
+    h: rows(chrome + visibleTopHeight + visibleBottomHeight),
+    minH: rows(chrome + minTopPx + minBottomPx),
+    maxH: rows(chrome + maxTopPx + maxBottomPx),
+  }
 }
 
+export const computeCellGridH = (
+  cell: NotebookCell,
+  rowHeight: number,
+  marginY: number = 0,
+  expectingResult: boolean = false,
+  paneLayout: CellPaneLayout = resolveCellPaneLayout(cell, expectingResult),
+): number =>
+  computeCellGridBounds(cell, rowHeight, marginY, expectingResult, paneLayout).h
+
 export const snapMarkdownTopHeight = (px: number): number => {
   const step = NOTEBOOK_GRID_ROW_HEIGHT + NOTEBOOK_GRID_MARGIN_Y
   const totalPx = Math.max(px, MIN_MARKDOWN_HEIGHT_PX) + CELL_BASE_CHROME_PX
   const rows = Math.ceil((totalPx + NOTEBOOK_GRID_MARGIN_Y) / step)
-  return rows * step - NOTEBOOK_GRID_MARGIN_Y - CELL_BASE_CHROME_PX
+  return Math.min(
+    MAX_PANE_HEIGHT_PX,
+    rows * step - NOTEBOOK_GRID_MARGIN_Y - CELL_BASE_CHROME_PX,
+  )
 }
 
 // Hydration status isn't knowable headlessly; "unrequested" (reserved space)
 // matches what the notebook renders for a run-marked cell before its snapshot
 // loads, so agent-visible heights agree with the screen.
-export const computeAgentCellGridH = (cell: NotebookCell): number =>
+export const computeAgentCellGridH = (
+  cell: NotebookCell,
+  expectingResult: boolean = isExpectingResult(cell, "unrequested"),
+): number =>
   computeCellGridH(
     cell,
     NOTEBOOK_GRID_ROW_HEIGHT,
     NOTEBOOK_GRID_MARGIN_Y,
-    isExpectingResult(cell, "unrequested"),
+    expectingResult,
   )
 
 export const hasAgentVisibleCellHeightChanged = (
@@ -1630,80 +2131,48 @@ export const partitionCellHeights = (
   return { top, bottom }
 }
 
-export const scaleCellHeights = (
-  oldTop: number,
-  oldBottom: number,
-  newContent: number,
-  minTop: number,
-  minBottom: number,
-): { top: number; bottom: number } => {
-  const oldContent = oldTop + oldBottom
-  const clampedContent = Math.max(minTop + minBottom, newContent)
-  const scale = oldContent > 0 ? clampedContent / oldContent : 1
-  let top = Math.round(oldTop * scale)
-  let bottom = clampedContent - top
-  if (top < minTop) {
-    top = minTop
-    bottom = clampedContent - top
-  }
-  if (bottom < minBottom) {
-    bottom = minBottom
-    top = clampedContent - bottom
-  }
-  return { top, bottom }
-}
-
 // Back-solves a grid `h` into the top/bottom height patch that makes
 // computeCellGridH reproduce it, pinned via *Resized like a manual drag. Empty
 // patch when the rows already match the derived height — an echo of the required
 // grid.h is not a resize, so auto-height stays intact.
-export const cellHeightPatchForRows = (
+export const paneHeightsFromGridRows = (
   cell: NotebookCell,
   rows: number,
   rowHeight: number,
   marginY: number,
   expectingResult: boolean = false,
+  paneLayout: CellPaneLayout = resolveCellPaneLayout(cell, expectingResult),
 ): Partial<NotebookCell> => {
-  if (rows === computeCellGridH(cell, rowHeight, marginY, expectingResult)) {
+  if (
+    rows ===
+    computeCellGridH(cell, rowHeight, marginY, expectingResult, paneLayout)
+  ) {
     return {}
   }
   const targetContentPx =
     rows * rowHeight +
     (rows - 1) * marginY -
-    cellChromePx(cell, expectingResult)
-  if (!isDoubleView(cell) && !expectingResult) {
+    cellChromePx(cell, expectingResult, paneLayout)
+  if (paneLayout === "editor") {
     return {
-      topHeight: Math.max(minTopHeightFor(cell), targetContentPx),
+      topHeight: clampPaneHeight(minTopHeightFor(cell), targetContentPx),
       topResized: true,
     }
   }
-  if (cell.isViewMaximized === true) {
-    // Maximized hides the editor; scale both so the split survives a restore.
-    const { top, bottom } = scaleCellHeights(
-      cell.topHeight ?? DEFAULT_TOP_HEIGHT,
-      cell.bottomHeight ?? defaultBottomHeightFor(cell),
-      targetContentPx,
-      DEFAULT_TOP_HEIGHT,
-      MIN_BOTTOM_HEIGHT_PX,
-    )
+  if (paneLayout === "result") {
     return {
-      topHeight: top,
-      bottomHeight: bottom,
-      topResized: true,
+      bottomHeight: clampPaneHeight(minBottomHeightFor(cell), targetContentPx),
       bottomResized: true,
     }
   }
-  const top = cell.topHeight ?? DEFAULT_TOP_HEIGHT
-  const { top: nextTop, bottom: nextBottom } = partitionCellHeights(
-    targetContentPx,
-    top,
-    DEFAULT_TOP_HEIGHT,
-    MIN_BOTTOM_HEIGHT_PX,
+  const { topHeight } = computeCellHeights(cell, { expectingResult })
+  const nextBottom = clampPaneHeight(
+    minBottomHeightFor(cell),
+    targetContentPx - topHeight,
   )
   return {
     bottomHeight: nextBottom,
     bottomResized: true,
-    ...(nextTop !== top ? { topHeight: nextTop, topResized: true } : {}),
   }
 }
 
@@ -1712,26 +2181,45 @@ export const buildAppliedLayout = (
   nextCells: NotebookCell[],
   prevLayout: CellLayoutItem[] | undefined,
   defaults: { gridCols: number; rowHeight: number; marginY?: number },
+  resultStatusOf: CellResultStatusReader = () => "unrequested",
 ): CellLayoutItem[] => {
   const prevById = new Map((prevLayout ?? []).map((l) => [l.i, l]))
   let nextY = 0
   return nextCells.map((cell, i) => {
     const req = request.cells[i]
     if (req?.grid) {
-      const item = { i: cell.id, ...req.grid }
-      nextY = Math.max(nextY, req.grid.y + req.grid.h)
+      const h = computeCellGridH(
+        cell,
+        defaults.rowHeight,
+        defaults.marginY,
+        isExpectingResult(cell, resultStatusOf(cell.id)),
+      )
+      const item = {
+        i: cell.id,
+        x: req.grid.x,
+        y: req.grid.y,
+        w: req.grid.w,
+        h,
+      }
+      nextY = Math.max(nextY, req.grid.y + h)
       return item
     }
     const existing = prevById.get(cell.id)
     if (existing) {
-      nextY = Math.max(nextY, existing.y + existing.h)
-      return existing
+      const h = computeCellGridH(
+        cell,
+        defaults.rowHeight,
+        defaults.marginY,
+        isExpectingResult(cell, resultStatusOf(cell.id)),
+      )
+      nextY = Math.max(nextY, existing.y + h)
+      return existing.h === h ? existing : { ...existing, h }
     }
     const cellH = computeCellGridH(
       cell,
       defaults.rowHeight,
       defaults.marginY,
-      isExpectingResult(cell, "unrequested"),
+      isExpectingResult(cell, resultStatusOf(cell.id)),
     )
     const item: CellLayoutItem = {
       i: cell.id,
@@ -1754,6 +2242,7 @@ export type NotebookDocumentState = {
 export const buildAppliedNotebookState = (
   current: NotebookDocumentState,
   request: ApplyRequest,
+  resultStatusOf: CellResultStatusReader = () => "unrequested",
 ): NotebookDocumentState & { diff: AppliedDiff; resultsCleared: string[] } => {
   const { nextCells, diff, resultsCleared } = buildAppliedCells(
     current.cells,
@@ -1764,42 +2253,22 @@ export const buildAppliedNotebookState = (
       ? current.settings.layoutMode
       : request.layoutMode
 
-  // Pin an intentionally-resized grid.h into the cell; the stored h alone is a
-  // stale shadow the renderer overwrites (see cellHeightPatchForRows).
-  //
-  // Back-solve against the pre-apply cell, not the mutated one: the agent's h
-  // was derived from the cell it read (with its result), so a value edit that
-  // drops the result must not flip the cell to the single-view branch and pin
-  // the editor. Evaluating on the prior cell makes an agent-sent h behave
-  // exactly like the user's bottom-edge drag.
-  const prevById = new Map(current.cells.map((c) => [c.id, c]))
-  const cells =
-    targetLayoutMode === "grid"
-      ? nextCells.map((cell, i) => {
-          const g = request.cells[i]?.grid
-          if (!g) return cell
-          const prior = prevById.get(cell.id) ?? cell
-          const patch = cellHeightPatchForRows(
-            prior,
-            g.h,
-            NOTEBOOK_GRID_ROW_HEIGHT,
-            NOTEBOOK_GRID_MARGIN_Y,
-            isExpectingResult(prior, "unrequested"),
-          )
-          return Object.keys(patch).length > 0 ? { ...cell, ...patch } : cell
-        })
-      : nextCells
-
   let nextSettings = current.settings
   if (targetLayoutMode === "grid") {
     nextSettings = {
       ...nextSettings,
       layoutMode: "grid",
-      layout: buildAppliedLayout(request, cells, current.settings.layout, {
-        gridCols: NOTEBOOK_GRID_COLS,
-        rowHeight: NOTEBOOK_GRID_ROW_HEIGHT,
-        marginY: NOTEBOOK_GRID_MARGIN_Y,
-      }),
+      layout: buildAppliedLayout(
+        request,
+        nextCells,
+        current.settings.layout,
+        {
+          gridCols: NOTEBOOK_GRID_COLS,
+          rowHeight: NOTEBOOK_GRID_ROW_HEIGHT,
+          marginY: NOTEBOOK_GRID_MARGIN_Y,
+        },
+        resultStatusOf,
+      ),
     }
   } else if (request.layoutMode !== undefined && request.layoutMode !== null) {
     nextSettings = { ...nextSettings, layoutMode: request.layoutMode }
@@ -1820,16 +2289,16 @@ export const buildAppliedNotebookState = (
   let nextMaximizedCellId = current.maximizedCellId
   if (request.maximizedCellId !== undefined) {
     const id = request.maximizedCellId
-    nextMaximizedCellId = id && cells.some((c) => c.id === id) ? id : null
+    nextMaximizedCellId = id && nextCells.some((c) => c.id === id) ? id : null
   } else if (
     nextMaximizedCellId &&
-    !cells.some((c) => c.id === nextMaximizedCellId)
+    !nextCells.some((c) => c.id === nextMaximizedCellId)
   ) {
     nextMaximizedCellId = null
   }
 
   return {
-    cells,
+    cells: nextCells,
     settings: nextSettings,
     maximizedCellId: nextMaximizedCellId,
     diff,
diff --git a/src/scenes/Editor/Notebook/resize/ResizeHandle.test.ts b/src/scenes/Editor/Notebook/resize/ResizeHandle.test.ts
new file mode 100644
index 000000000..8fdafa3b4
--- /dev/null
+++ b/src/scenes/Editor/Notebook/resize/ResizeHandle.test.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest"
+import { resizeHeightForKey } from "./ResizeHandle"
+
+describe("resizeHeightForKey", () => {
+  it("resizes by arrow-key steps and clamps to separator bounds", () => {
+    expect(resizeHeightForKey("ArrowUp", 100, 72, 200)).toBe(90)
+    expect(resizeHeightForKey("ArrowDown", 100, 72, 200)).toBe(110)
+    expect(resizeHeightForKey("ArrowUp", 75, 72, 200)).toBe(72)
+    expect(resizeHeightForKey("ArrowDown", 195, 72, 200)).toBe(200)
+  })
+
+  it("supports larger Shift steps and Home/End bounds", () => {
+    expect(resizeHeightForKey("ArrowDown", 100, 72, 200, true)).toBe(150)
+    expect(resizeHeightForKey("Home", 150, 72, 200)).toBe(72)
+    expect(resizeHeightForKey("End", 100, 72, 200)).toBe(200)
+    expect(resizeHeightForKey("Enter", 100, 72, 200)).toBeNull()
+  })
+})
diff --git a/src/scenes/Editor/Notebook/resize/ResizeHandle.tsx b/src/scenes/Editor/Notebook/resize/ResizeHandle.tsx
index 58f0d47c6..3c067a285 100644
--- a/src/scenes/Editor/Notebook/resize/ResizeHandle.tsx
+++ b/src/scenes/Editor/Notebook/resize/ResizeHandle.tsx
@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useRef } from "react"
+import React, { useCallback, useEffect, useRef, useState } from "react"
 import styled from "styled-components"
 import { color } from "../../../../utils"
 import { SideChip } from "./chips"
@@ -78,7 +78,9 @@ type Props = {
   onResize: (height: number) => void
   onResizeEnd: (height: number) => void
   onDoubleClick: () => void
-  minHeight?: number
+  minHeight: number
+  maxHeight: number
+  ariaLabel: string
   background?: string
   doubleView?: boolean
   // The cell's bottom-edge handle: an absolute strip straddling the cell edge
@@ -90,22 +92,60 @@ type Props = {
 // mouseup is a click and must not commit a resize (which would pin the
 // cell's auto-height).
 const DRAG_THRESHOLD_PX = 3
+const KEYBOARD_STEP_PX = 10
+const KEYBOARD_LARGE_STEP_PX = 50
+
+export const resizeHeightForKey = (
+  key: string,
+  currentHeight: number,
+  minHeight: number,
+  maxHeight: number,
+  largeStep = false,
+): number | null => {
+  const step = largeStep ? KEYBOARD_LARGE_STEP_PX : KEYBOARD_STEP_PX
+  let next: number
+  switch (key) {
+    case "ArrowUp":
+      next = currentHeight - step
+      break
+    case "ArrowDown":
+      next = currentHeight + step
+      break
+    case "Home":
+      next = minHeight
+      break
+    case "End":
+      next = maxHeight
+      break
+    default:
+      return null
+  }
+  return Math.min(maxHeight, Math.max(minHeight, next))
+}
 
 export const ResizeHandle: React.FC<Props> = ({
   targetRef,
   onResize,
   onResizeEnd,
   onDoubleClick,
-  minHeight = 48,
+  minHeight,
+  maxHeight,
+  ariaLabel,
   background,
   doubleView,
   overlay,
 }) => {
+  const [targetHeight, setTargetHeight] = useState<number>()
   const startYRef = useRef(0)
   const startHeightRef = useRef(0)
   const lastHeightRef = useRef(0)
   const endDragRef = useRef<(() => void) | null>(null)
 
+  const clampHeight = useCallback(
+    (height: number) => Math.min(maxHeight, Math.max(minHeight, height)),
+    [maxHeight, minHeight],
+  )
+
   const handleMouseDown = useCallback(
     (e: React.MouseEvent) => {
       e.preventDefault()
@@ -120,7 +160,7 @@ export const ResizeHandle: React.FC<Props> = ({
         const delta = moveEvent.clientY - startYRef.current
         if (!dragged && Math.abs(delta) < DRAG_THRESHOLD_PX) return
         dragged = true
-        const newHeight = Math.max(minHeight, startHeightRef.current + delta)
+        const newHeight = clampHeight(startHeightRef.current + delta)
         lastHeightRef.current = newHeight
         onResize(newHeight)
       }
@@ -144,23 +184,42 @@ export const ResizeHandle: React.FC<Props> = ({
       document.addEventListener("mouseup", handleMouseUp)
       endDragRef.current = endDrag
     },
-    [targetRef, onResize, onResizeEnd, minHeight],
+    [targetRef, onResize, onResizeEnd, clampHeight],
   )
 
-  // Enter/Space on a focused handle resets to default. This is the only
-  // keyboard-accessible interaction we offer — mouse-drag resizing has no
-  // ergonomic keyboard equivalent here, so don't pretend otherwise in
-  // the aria-label.
   const handleKeyDown = useCallback(
     (e: React.KeyboardEvent) => {
       if (e.key === "Enter" || e.key === " ") {
         e.preventDefault()
         onDoubleClick()
+        return
       }
+      if (!targetRef.current) return
+      const next = resizeHeightForKey(
+        e.key,
+        targetRef.current.getBoundingClientRect().height,
+        minHeight,
+        maxHeight,
+        e.shiftKey,
+      )
+      if (next === null) return
+      e.preventDefault()
+      onResize(next)
+      onResizeEnd(next)
     },
-    [onDoubleClick],
+    [maxHeight, minHeight, onDoubleClick, onResize, onResizeEnd, targetRef],
   )
 
+  useEffect(() => {
+    const target = targetRef.current
+    if (!target) return
+    const observer = new ResizeObserver(() =>
+      setTargetHeight(Math.round(target.getBoundingClientRect().height)),
+    )
+    observer.observe(target)
+    return () => observer.disconnect()
+  }, [targetRef])
+
   useEffect(() => () => endDragRef.current?.(), [])
 
   return (
@@ -173,10 +232,11 @@ export const ResizeHandle: React.FC<Props> = ({
       onKeyDown={handleKeyDown}
       role="separator"
       aria-orientation="horizontal"
-      // Sighted mouse users hover for the tooltip; screen-reader users
-      // hear the aria-label. Two audiences, two affordances.
-      aria-label="Resize handle. Press Enter to reset to default size."
-      title="Drag to resize. Double-click to reset."
+      aria-label={ariaLabel}
+      aria-valuemin={Math.round(minHeight)}
+      aria-valuemax={Math.round(maxHeight)}
+      aria-valuenow={targetHeight}
+      title="Drag or use arrow keys to resize. Double-click or press Enter to reset."
       tabIndex={0}
     >
       <span className="resize-line" />
diff --git a/src/scenes/Editor/Notebook/result-table/statementSlotView.test.ts b/src/scenes/Editor/Notebook/result-table/statementSlotView.test.ts
index 027371fc5..12c746329 100644
--- a/src/scenes/Editor/Notebook/result-table/statementSlotView.test.ts
+++ b/src/scenes/Editor/Notebook/result-table/statementSlotView.test.ts
@@ -29,6 +29,7 @@ const fetchState = (over: Partial<CellFetchState> = {}): CellFetchState => ({
   slotErrors: new Map(),
   cancelledSlots: new Set(),
   slotFetchedAt: new Map(),
+  fetchCancelled: false,
   ...over,
 })
 
diff --git a/src/scenes/Editor/Notebook/resultHydration/cellResultHydration.ts b/src/scenes/Editor/Notebook/resultHydration/cellResultHydration.ts
index 3eeccf763..2a1bbc097 100644
--- a/src/scenes/Editor/Notebook/resultHydration/cellResultHydration.ts
+++ b/src/scenes/Editor/Notebook/resultHydration/cellResultHydration.ts
@@ -6,10 +6,7 @@ import type {
 import type { NotebookResultSnapshot } from "../../../../store/notebookResults"
 import { shallowArrayEquals } from "../../../../utils/shallowArrayEquals"
 import { getQueriesFromText, normalizeQueryText } from "../../Monaco/utils"
-import {
-  reconcileResultsForStatements,
-  statementKeysFor,
-} from "../notebookUtils"
+import { reconcileResultsForSlotKeys, statementKeysFor } from "../notebookUtils"
 
 // Legacy records hold the raw cell text — comments included — as the
 // statement's query. Parsing it back to the statement lets those results
@@ -231,7 +228,8 @@ export class CellResultHydrationEngine {
     snapshot: NotebookResultSnapshot,
   ) {
     const statements = getQueriesFromText(cell.value)
-    const reconciled = reconcileResultsForStatements(statements, {
+    const slotKeys = statementKeysFor(statements)
+    const reconciled = reconcileResultsForSlotKeys(statements, slotKeys, {
       results: snapshot.results.map(normalizeSnapshotResultQuery),
       activeResultIndex: snapshot.activeResultIndex ?? 0,
       ...(snapshot.activeStatementKey !== undefined
@@ -252,9 +250,9 @@ export class CellResultHydrationEngine {
       reconciled.results.some((result, index) => {
         return result !== snapshot.results[index]
       })
-    const slotKeys = new Set(statementKeysFor(statements))
+    const slotKeySet = new Set(slotKeys)
     const refreshErrors = snapshot.refreshErrors?.filter((error) =>
-      slotKeys.has(error.statementKey),
+      slotKeySet.has(error.statementKey),
     )
     if (frameChanged) {
       const rewritten: NotebookResultSnapshot = {
diff --git a/src/scenes/Editor/Notebook/useCellExecution.test.ts b/src/scenes/Editor/Notebook/useCellExecution.test.ts
new file mode 100644
index 000000000..5cc8252e5
--- /dev/null
+++ b/src/scenes/Editor/Notebook/useCellExecution.test.ts
@@ -0,0 +1,88 @@
+import { describe, expect, it, vi } from "vitest"
+import type { QueryExecResult } from "../../../hooks/useQueryExecution"
+import {
+  MAX_ACTIVE_STATEMENT_REQUESTS,
+  statementRequestLimiter,
+} from "../../../utils/questdb/requestLimiter"
+import { abortCellRunsOnUnmount, launchStatement } from "./useCellExecution"
+
+describe("abortCellRunsOnUnmount", () => {
+  it("aborts validation and request phases before clearing their registries", () => {
+    const validation = new AbortController()
+    const request = new AbortController()
+    const barriers = new Map([["cell", new Set([validation])]])
+    const requests = new Map([["cell", [request]]])
+    const generations = new Map([["cell", 4]])
+
+    abortCellRunsOnUnmount(barriers, requests, generations)
+
+    expect(validation.signal.aborted).toBe(true)
+    expect(request.signal.aborted).toBe(true)
+    expect(barriers.size).toBe(0)
+    expect(requests.size).toBe(0)
+    expect(generations.get("cell")).toBe(5)
+  })
+
+  it("supersedes a validation-only cell so it cannot launch after teardown", () => {
+    const validation = new AbortController()
+    const barriers = new Map([["validating", new Set([validation])]])
+    const generations = new Map<string, number>()
+
+    abortCellRunsOnUnmount(barriers, new Map(), generations)
+
+    expect(validation.signal.aborted).toBe(true)
+    expect(generations.get("validating")).toBe(1)
+  })
+})
+
+describe("launchStatement", () => {
+  it("reports a statement aborted while queued as not launched", async () => {
+    // Given the limiter is saturated by requests that never settle
+    const holds = Array.from({ length: MAX_ACTIVE_STATEMENT_REQUESTS }, () => {
+      let release: () => void = () => {}
+      const promise = new Promise<void>((resolve) => {
+        release = resolve
+      })
+      return { promise, release }
+    })
+    const occupied = holds.map((hold) =>
+      statementRequestLimiter(() => hold.promise),
+    )
+    const execute = vi.fn<[], Promise<QueryExecResult>>()
+    const ac = new AbortController()
+
+    // When a queued statement's signal aborts before a slot frees up
+    const launch = launchStatement(execute, ac.signal, "select 1")
+    ac.abort()
+
+    // Then it never executed, so it is not launched
+    await expect(launch).resolves.toEqual({ launched: false })
+    expect(execute).not.toHaveBeenCalled()
+    holds.forEach((hold) => hold.release())
+    await Promise.all(occupied)
+  })
+
+  it("keeps the unverifiable cancelled error for a statement aborted after launch", async () => {
+    // Given a statement whose request rejects once its signal aborts
+    const ac = new AbortController()
+    const execute = vi.fn(
+      () =>
+        new Promise<QueryExecResult>((_, reject) => {
+          ac.signal.addEventListener("abort", () =>
+            reject(new Error("aborted")),
+          )
+        }),
+    )
+
+    // When the abort lands mid-flight
+    const launch = launchStatement(execute, ac.signal, "select 1")
+    await vi.waitFor(() => expect(execute).toHaveBeenCalled())
+    ac.abort()
+
+    // Then the outcome is launched, carrying the error that marks it unverified
+    await expect(launch).resolves.toMatchObject({
+      launched: true,
+      exec: { type: "error", error: "Cancelled by user" },
+    })
+  })
+})
diff --git a/src/scenes/Editor/Notebook/useCellExecution.ts b/src/scenes/Editor/Notebook/useCellExecution.ts
index d860d50bb..8b3ecc6ae 100644
--- a/src/scenes/Editor/Notebook/useCellExecution.ts
+++ b/src/scenes/Editor/Notebook/useCellExecution.ts
@@ -12,8 +12,10 @@ import { getQueriesFromText } from "../Monaco/utils"
 import type { ValidateQueryResult } from "../../../utils/questdb/types"
 import {
   hasWriteStatement,
+  requireAllDQL,
   resolveRunBarrier,
   type ClassifiedStatement,
+  type PermissionDecision,
   type RunBarrierOutcome,
   type RunCellGate,
 } from "../../../utils/tools/permissions"
@@ -24,6 +26,9 @@ import {
   hasPendingResult,
   NOTEBOOK_ROW_CAP,
   resolveRunCompletion,
+  runCancellationOf,
+  type RunCancellation,
+  type RunCancelReason,
   runHistoryPatch,
   singleResultFromExec,
   statementKeysFor,
@@ -31,30 +36,56 @@ import {
 import { persistCellSnapshot } from "./persistCellSnapshot"
 import { updateCellSnapshotActiveIndex } from "../../../store/notebookResults"
 
+export type DrawGateOutcome =
+  | { granted: true }
+  | { granted: false; reason?: string }
+
 const publishSchemaIfMutating = (exec: QueryExecResult): void => {
   if (exec.type === "ddl" || exec.type === "dml") {
     eventBus.publish(EventType.MSG_QUERY_SCHEMA)
   }
 }
 
-const beginCellRun = (
-  runGenerationRef: MutableRefObject<Map<string, number>>,
-  cellId: string,
-) => {
-  const generation = (runGenerationRef.current.get(cellId) ?? 0) + 1
-  runGenerationRef.current.set(cellId, generation)
+const beginCellRun = (runGenerations: Map<string, number>, cellId: string) => {
+  const generation = (runGenerations.get(cellId) ?? 0) + 1
+  runGenerations.set(cellId, generation)
+
+  return () => runGenerations.get(cellId) === generation
+}
 
-  return () => runGenerationRef.current.get(cellId) === generation
+// The reason the cell's controllers were aborted with, when any were.
+const cancellationOf = (
+  controllers: readonly AbortController[],
+): RunCancellation | undefined => {
+  const aborted = controllers.find((c) => c.signal.aborted)
+  return aborted ? runCancellationOf(aborted.signal) : undefined
 }
 
 const supersedeCellRun = (
-  runGenerationRef: MutableRefObject<Map<string, number>>,
+  runGenerations: Map<string, number>,
   cellId: string,
 ) => {
-  runGenerationRef.current.set(
-    cellId,
-    (runGenerationRef.current.get(cellId) ?? 0) + 1,
-  )
+  runGenerations.set(cellId, (runGenerations.get(cellId) ?? 0) + 1)
+}
+
+export const abortCellRunsOnUnmount = (
+  barrierControllers: Map<string, Set<AbortController>>,
+  requestControllers: Map<string, AbortController[]>,
+  runGenerations: Map<string, number>,
+): void => {
+  const cellIds = new Set([
+    ...barrierControllers.keys(),
+    ...requestControllers.keys(),
+  ])
+  cellIds.forEach((cellId) => supersedeCellRun(runGenerations, cellId))
+  barrierControllers.forEach((claims) => {
+    claims.forEach((controller) => controller.abort())
+  })
+  requestControllers.forEach((controllers) => {
+    controllers.forEach((controller) => controller.abort())
+  })
+  barrierControllers.clear()
+  requestControllers.clear()
 }
 
 const clearRunningCell = (
@@ -72,6 +103,48 @@ const clearRunningCell = (
   })
 }
 
+const cancelledByUser = (query: string): SingleQueryResult => ({
+  type: "cancelled",
+  query,
+  reason: "user",
+})
+
+const cancelledExecResult = (query: string): QueryExecResult => ({
+  type: "error",
+  query,
+  columns: [],
+  dataset: [],
+  count: 0,
+  error: "Cancelled by user",
+})
+
+type StatementLaunch =
+  | { launched: true; exec: QueryExecResult }
+  | { launched: false }
+
+// The limiter rejects a queued statement when its signal aborts, before any
+// request exists. Only a launched statement can have reached the server, so
+// only that one lands as the unverifiable "Cancelled by user" error; a queued
+// one is plainly cancelled.
+export const launchStatement = async (
+  execute: () => Promise<QueryExecResult>,
+  signal: AbortSignal,
+  query: string,
+): Promise<StatementLaunch> => {
+  let launched = false
+  try {
+    const exec = await statementRequestLimiter(() => {
+      launched = true
+      return execute()
+    }, signal)
+    return { launched: true, exec }
+  } catch {
+    return launched
+      ? { launched: true, exec: cancelledExecResult(query) }
+      : { launched: false }
+  }
+}
+
 type Options = {
   bufferId: number
   cellsRef: MutableRefObject<NotebookCell[]>
@@ -170,9 +243,9 @@ export const useCellExecution = ({
       if (queries.length === 0) return { ok: false, superseded: false }
 
       const prior = abortControllersRef.current.get(cellId)
-      prior?.forEach((c) => c.abort())
+      prior?.forEach((c) => c.abort("superseded" satisfies RunCancelReason))
 
-      const isCurrentRun = beginCellRun(runGenerationRef, cellId)
+      const isCurrentRun = beginCellRun(runGenerationRef.current, cellId)
       const startCell = cellsRef.current.find((c) => c.id === cellId)
       const priorResult = hasPendingResult(startCell?.result)
         ? undefined
@@ -207,28 +280,22 @@ export const useCellExecution = ({
 
       let successCount = 0
       let failedCount = 0
+      let cancelledCount = 0
+      const runSucceeded = () => failedCount === 0 && cancelledCount === 0
+      const cancelFrom = (index: number) => {
+        for (let j = index; j < queries.length; j++) {
+          const cancelled = cancelledByUser(queries[j])
+          finalResults[j] = cancelled
+          updateCellResult(cellId, j, cancelled)
+        }
+        cancelledCount += queries.length - index
+      }
 
       try {
         for (let i = 0; i < queries.length; i++) {
           const perQuery = controllers[i]
           if (perQuery.signal.aborted) {
-            failedCount++
-            const interrupted: SingleQueryResult = {
-              type: "error",
-              query: queries[i],
-              error: "Cancelled by user",
-            }
-            finalResults[i] = interrupted
-            updateCellResult(cellId, i, interrupted)
-            for (let j = i + 1; j < queries.length; j++) {
-              const skipped: SingleQueryResult = {
-                type: "cancelled",
-                query: queries[j],
-                reason: "priorFailure",
-              }
-              finalResults[j] = skipped
-              updateCellResult(cellId, j, skipped)
-            }
+            cancelFrom(i)
             break
           }
 
@@ -241,25 +308,23 @@ export const useCellExecution = ({
             isAuto ? i : undefined,
           )
 
-          let result: QueryExecResult
-          try {
-            result = await statementRequestLimiter(
-              () => executeSingle(sql, perQuery.signal, NOTEBOOK_ROW_CAP),
-              perQuery.signal,
-            )
-          } catch {
-            result = {
-              type: "error",
-              query: sql,
-              columns: [],
-              dataset: [],
-              count: 0,
-              error: "Cancelled by user",
+          const launch = await launchStatement(
+            () => executeSingle(sql, perQuery.signal, NOTEBOOK_ROW_CAP),
+            perQuery.signal,
+            sql,
+          )
+          if (!isCurrentRun()) {
+            return {
+              ok: runSucceeded(),
+              superseded: true,
+              cancelled: cancellationOf(controllers),
             }
           }
-          if (!isCurrentRun()) {
-            return { ok: failedCount === 0, superseded: true }
+          if (!launch.launched) {
+            cancelFrom(i)
+            break
           }
+          const result = launch.exec
           const landed = singleResultFromExec(result, sql)
           finalResults[i] = landed
           updateCellResult(cellId, i, landed)
@@ -267,14 +332,20 @@ export const useCellExecution = ({
 
           if (result.type === "error") {
             failedCount++
-            for (let j = i + 1; j < queries.length; j++) {
-              const cancelled: SingleQueryResult = {
-                type: "cancelled",
-                query: queries[j],
-                reason: "priorFailure",
+            // An aborted statement ends the script by the user's hand, not by
+            // a failure: the rest is cancelled, not skipped.
+            if (perQuery.signal.aborted) {
+              cancelFrom(i + 1)
+            } else {
+              for (let j = i + 1; j < queries.length; j++) {
+                const skipped: SingleQueryResult = {
+                  type: "cancelled",
+                  query: queries[j],
+                  reason: "priorFailure",
+                }
+                finalResults[j] = skipped
+                updateCellResult(cellId, j, skipped)
               }
-              finalResults[j] = cancelled
-              updateCellResult(cellId, j, cancelled)
             }
             break
           }
@@ -284,7 +355,7 @@ export const useCellExecution = ({
         const liveCell = cellsRef.current.find((c) => c.id === cellId)
         if (!liveCell) {
           return {
-            ok: failedCount === 0,
+            ok: runSucceeded(),
             superseded: false,
             resultCleared: true,
           }
@@ -296,7 +367,7 @@ export const useCellExecution = ({
         )
         if (completion === "result_cleared") {
           return {
-            ok: failedCount === 0,
+            ok: runSucceeded(),
             superseded: false,
             resultCleared: true,
           }
@@ -304,7 +375,7 @@ export const useCellExecution = ({
         if (completion === "cell_changed") {
           updateCell(cellId, { result: priorResult })
           return {
-            ok: failedCount === 0,
+            ok: runSucceeded(),
             superseded: false,
             cellChanged: true,
           }
@@ -338,7 +409,7 @@ export const useCellExecution = ({
       }
 
       return {
-        ok: failedCount === 0,
+        ok: runSucceeded(),
         superseded: false,
         result: {
           results: finalResults,
@@ -358,6 +429,43 @@ export const useCellExecution = ({
     ],
   )
 
+  // One running window covers the whole phase: the barrier (validation) and
+  // the request. A claim opens it; the window closes once the cell has
+  // neither a pending claim nor an in-flight request. Cancel, delete and an
+  // agent mode change reach a validating phase through the claim's signal.
+  const claimBarrier = useCallback(
+    (cellId: string, externalSignal?: AbortSignal) => {
+      const ac = new AbortController()
+      const onExternalAbort = () => ac.abort(externalSignal?.reason)
+      externalSignal?.addEventListener("abort", onExternalAbort, { once: true })
+      const claims =
+        barrierAbortsRef.current.get(cellId) ?? new Set<AbortController>()
+      claims.add(ac)
+      barrierAbortsRef.current.set(cellId, claims)
+      setRunningCellIds((prev) => new Set(prev).add(cellId))
+      return {
+        signal: ac.signal,
+        release: () => {
+          externalSignal?.removeEventListener("abort", onExternalAbort)
+          claims.delete(ac)
+          if (claims.size === 0) barrierAbortsRef.current.delete(cellId)
+        },
+      }
+    },
+    [],
+  )
+
+  const releaseIdleCell = useCallback((cellId: string) => {
+    if (barrierAbortsRef.current.has(cellId)) return
+    if (abortControllersRef.current.has(cellId)) return
+    setRunningCellIds((prev) => {
+      if (!prev.has(cellId)) return prev
+      const next = new Set(prev)
+      next.delete(cellId)
+      return next
+    })
+  }, [])
+
   // Parallel run for refreshable (non-write) cells: every DQL statement
   // launches at once through the shared limiter; an invalid statement is
   // skipped with its validation error as the slot result; one failure skips
@@ -372,9 +480,9 @@ export const useCellExecution = ({
       valueAtRunStart: string,
     ): Promise<CellRunOutcome> => {
       const prior = abortControllersRef.current.get(cellId)
-      prior?.forEach((c) => c.abort())
+      prior?.forEach((c) => c.abort("superseded" satisfies RunCancelReason))
 
-      const isCurrentRun = beginCellRun(runGenerationRef, cellId)
+      const isCurrentRun = beginCellRun(runGenerationRef.current, cellId)
       const startCell = cellsRef.current.find((c) => c.id === cellId)
       const priorResult = hasPendingResult(startCell?.result)
         ? undefined
@@ -405,6 +513,14 @@ export const useCellExecution = ({
       setRunningCellIds((prev) => new Set(prev).add(cellId))
 
       let failedCount = 0
+      let cancelledCount = 0
+      const runSucceeded = () => failedCount === 0 && cancelledCount === 0
+      const cancelStatement = (index: number, sql: string) => {
+        cancelledCount++
+        const cancelled = cancelledByUser(sql)
+        finalResults[index] = cancelled
+        if (isCurrentRun()) updateCellResult(cellId, index, cancelled)
+      }
       try {
         await Promise.all(
           queries.map(async (sql, index) => {
@@ -422,34 +538,21 @@ export const useCellExecution = ({
             }
             const perQuery = controllers[index]
             if (perQuery.signal.aborted) {
-              failedCount++
-              const interrupted: SingleQueryResult = {
-                type: "error",
-                query: sql,
-                error: "Cancelled by user",
-              }
-              finalResults[index] = interrupted
-              if (isCurrentRun()) updateCellResult(cellId, index, interrupted)
+              cancelStatement(index, sql)
               return
             }
             updateCellResult(cellId, index, { type: "running", query: sql })
-            let result: QueryExecResult
-            try {
-              result = await statementRequestLimiter(
-                () => executeSingle(sql, perQuery.signal, NOTEBOOK_ROW_CAP),
-                perQuery.signal,
-              )
-            } catch {
-              result = {
-                type: "error",
-                query: sql,
-                columns: [],
-                dataset: [],
-                count: 0,
-                error: "Cancelled by user",
-              }
-            }
+            const launch = await launchStatement(
+              () => executeSingle(sql, perQuery.signal, NOTEBOOK_ROW_CAP),
+              perQuery.signal,
+              sql,
+            )
             if (!isCurrentRun()) return
+            if (!launch.launched) {
+              cancelStatement(index, sql)
+              return
+            }
+            const result = launch.exec
             const landed = singleResultFromExec(result, sql)
             finalResults[index] = landed
             updateCellResult(cellId, index, landed)
@@ -458,12 +561,16 @@ export const useCellExecution = ({
         )
 
         if (!isCurrentRun()) {
-          return { ok: failedCount === 0, superseded: true }
+          return {
+            ok: runSucceeded(),
+            superseded: true,
+            cancelled: cancellationOf(controllers),
+          }
         }
         const liveCell = cellsRef.current.find((c) => c.id === cellId)
         if (!liveCell) {
           return {
-            ok: failedCount === 0,
+            ok: runSucceeded(),
             superseded: false,
             resultCleared: true,
           }
@@ -475,7 +582,7 @@ export const useCellExecution = ({
         )
         if (completion === "result_cleared") {
           return {
-            ok: failedCount === 0,
+            ok: runSucceeded(),
             superseded: false,
             resultCleared: true,
           }
@@ -483,7 +590,7 @@ export const useCellExecution = ({
         if (completion === "cell_changed") {
           updateCell(cellId, { result: priorResult })
           return {
-            ok: failedCount === 0,
+            ok: runSucceeded(),
             superseded: false,
             cellChanged: true,
           }
@@ -499,7 +606,7 @@ export const useCellExecution = ({
         }
         if (queries.length > 1) {
           setScriptSummary(cellId, {
-            successCount: queries.length - failedCount,
+            successCount: queries.length - failedCount - cancelledCount,
             failedCount,
             durationMs: Date.now() - startTime,
           })
@@ -519,7 +626,7 @@ export const useCellExecution = ({
       }
 
       return {
-        ok: failedCount === 0,
+        ok: runSucceeded(),
         superseded: false,
         result: {
           results: finalResults,
@@ -570,16 +677,14 @@ export const useCellExecution = ({
       if (queries.length === 0) return notRun
 
       // The run claims the cell before the barrier: the attribution baseline
-      // is the gesture-time value, and a barrier-phase abort handle lets
-      // cancel and delete reach a run that is still validating.
+      // is the gesture-time value, and the claim keeps the running window open
+      // while the run is still validating.
       const valueAtRunStart = cell.value
-      const barrierAc = new AbortController()
-      const onBarrierAbort = () => barrierAc.abort(externalSignal?.reason)
-      externalSignal?.addEventListener("abort", onBarrierAbort, { once: true })
-      const claims =
-        barrierAbortsRef.current.get(cellId) ?? new Set<AbortController>()
-      claims.add(barrierAc)
-      barrierAbortsRef.current.set(cellId, claims)
+      const claim = claimBarrier(cellId, externalSignal)
+      const bail = (outcome: CellRunOutcome): CellRunOutcome => {
+        releaseIdleCell(cellId)
+        return outcome
+      }
 
       let barrier: RunBarrierOutcome
       try {
@@ -589,30 +694,34 @@ export const useCellExecution = ({
           gate,
           (stmt) =>
             statementRequestLimiter(
-              () => validateWithGlobals(stmt, barrierAc.signal),
-              barrierAc.signal,
+              () => validateWithGlobals(stmt, claim.signal),
+              claim.signal,
             ),
         )
       } finally {
-        externalSignal?.removeEventListener("abort", onBarrierAbort)
-        claims.delete(barrierAc)
-        if (claims.size === 0) barrierAbortsRef.current.delete(cellId)
+        claim.release()
       }
 
       // Re-check the claim after the barrier await: a cancel, delete, or
       // mode change that landed during validation would otherwise launch —
       // and commit — the run.
-      if (barrierAc.signal.aborted || externalSignal?.aborted) return notRun
+      if (claim.signal.aborted || externalSignal?.aborted) {
+        return bail({
+          ...notRun,
+          notStarted: true,
+          cancelled: runCancellationOf(claim.signal),
+        })
+      }
       if (barrier.action === "denied") {
-        return { ok: false, superseded: false, denied: barrier.reason }
+        return bail({ ok: false, superseded: false, denied: barrier.reason })
       }
       if (barrier.action === "skipped") {
-        return { ok: false, superseded: false, skipped: barrier.reason }
+        return bail({ ok: false, superseded: false, skipped: barrier.reason })
       }
       const classified = barrier.classified
       const liveAfterBarrier = cellsRef.current.find((c) => c.id === cellId)
       if (!liveAfterBarrier || liveAfterBarrier.type === "markdown") {
-        return notRun
+        return bail(notRun)
       }
 
       if (classified && !hasWriteStatement(classified)) {
@@ -636,9 +745,9 @@ export const useCellExecution = ({
       }
 
       const prior = abortControllersRef.current.get(cellId)
-      prior?.forEach((c) => c.abort())
+      prior?.forEach((c) => c.abort("superseded" satisfies RunCancelReason))
 
-      const isCurrentRun = beginCellRun(runGenerationRef, cellId)
+      const isCurrentRun = beginCellRun(runGenerationRef.current, cellId)
       const priorRaw = cellsRef.current.find((c) => c.id === cellId)?.result
       const priorResult = hasPendingResult(priorRaw) ? undefined : priorRaw
 
@@ -662,34 +771,24 @@ export const useCellExecution = ({
 
       setRunningCellIds((prev) => new Set(prev).add(cellId))
       try {
-        let execResult: QueryExecResult
-        try {
-          execResult = await statementRequestLimiter(
-            () => executeSingle(queryText, ac.signal, NOTEBOOK_ROW_CAP),
-            ac.signal,
-          )
-        } catch {
-          execResult = {
-            type: "error",
-            query: queryText,
-            columns: [],
-            dataset: [],
-            count: 0,
-            error: "Cancelled by user",
-          }
-        }
+        const launch = await launchStatement(
+          () => executeSingle(queryText, ac.signal, NOTEBOOK_ROW_CAP),
+          ac.signal,
+          queryText,
+        )
+        const ok = launch.launched && launch.exec.type !== "error"
         // A newer run (or a cancel) superseded this one; don't write its result.
         if (!isCurrentRun()) {
-          return { ok: execResult.type !== "error", superseded: true }
+          return {
+            ok,
+            superseded: true,
+            cancelled: cancellationOf([ac]),
+          }
         }
-        publishSchemaIfMutating(execResult)
+        if (launch.launched) publishSchemaIfMutating(launch.exec)
         const liveCell = cellsRef.current.find((c) => c.id === cellId)
         if (!liveCell) {
-          return {
-            ok: execResult.type !== "error",
-            superseded: false,
-            resultCleared: true,
-          }
+          return { ok, superseded: false, resultCleared: true }
         }
         const completion = resolveRunCompletion(
           liveCell,
@@ -697,22 +796,18 @@ export const useCellExecution = ({
           expectFullValue,
         )
         if (completion === "result_cleared") {
-          return {
-            ok: execResult.type !== "error",
-            superseded: false,
-            resultCleared: true,
-          }
+          return { ok, superseded: false, resultCleared: true }
         }
         if (completion === "cell_changed") {
           updateCell(cellId, { result: priorResult })
-          return {
-            ok: execResult.type !== "error",
-            superseded: false,
-            cellChanged: true,
-          }
+          return { ok, superseded: false, cellChanged: true }
         }
         const cellResult: CellResult = {
-          results: [singleResultFromExec(execResult, recordedQuery)],
+          results: [
+            launch.launched
+              ? singleResultFromExec(launch.exec, recordedQuery)
+              : cancelledByUser(recordedQuery),
+          ],
           activeResultIndex: 0,
           timestamp: Date.now(),
         }
@@ -721,11 +816,7 @@ export const useCellExecution = ({
           ...runHistoryPatch(cellResult),
         })
         persistSnapshot(cellId, cellResult)
-        return {
-          ok: execResult.type !== "error",
-          superseded: false,
-          result: cellResult,
-        }
+        return { ok, superseded: false, result: cellResult }
       } finally {
         externalSignal?.removeEventListener("abort", onExternalAbort)
         if (isCurrentRun()) {
@@ -766,7 +857,7 @@ export const useCellExecution = ({
       if (!target || !target.query.trim()) return notCommitted
       const sql = target.query
 
-      const isCurrentRun = beginCellRun(runGenerationRef, cellId)
+      const isCurrentRun = beginCellRun(runGenerationRef.current, cellId)
       const controllers = abortControllersRef.current.get(cellId) ?? []
       controllers[index]?.abort()
       const ac = new AbortController()
@@ -803,11 +894,12 @@ export const useCellExecution = ({
         return { committed: true, ok: execResult.type !== "error" }
       } finally {
         if (isCurrentRun()) {
-          setRunningCellIds((prev) => {
-            const next = new Set(prev)
-            next.delete(cellId)
-            return next
-          })
+          clearRunningCell(
+            abortControllersRef,
+            autoFocusRef,
+            setRunningCellIds,
+            cellId,
+          )
         }
       }
     },
@@ -820,29 +912,72 @@ export const useCellExecution = ({
     ],
   )
 
+  // The Draw gesture's phase: the same claim and running window as a run,
+  // ending at the mode flip instead of a request. The gate commits only
+  // against the SQL and mode it saw — an edit or an agent mode change during
+  // validation wins over the gesture.
+  const validateForDraw = useCallback(
+    async (
+      cellId: string,
+      externalSignal?: AbortSignal,
+    ): Promise<DrawGateOutcome> => {
+      const cell = cellsRef.current.find((c) => c.id === cellId)
+      if (!cell || cell.type === "markdown") return { granted: false }
+      const valueAtStart = cell.value
+      const modeAtStart = cell.mode
+      const claim = claimBarrier(cellId, externalSignal)
+      let decision: PermissionDecision
+      try {
+        decision = await requireAllDQL(valueAtStart, (stmt) =>
+          statementRequestLimiter(
+            () => validateWithGlobals(stmt, claim.signal),
+            claim.signal,
+          ),
+        )
+      } finally {
+        claim.release()
+        releaseIdleCell(cellId)
+      }
+      if (claim.signal.aborted || externalSignal?.aborted) {
+        return { granted: false }
+      }
+      if (!decision.granted) return { granted: false, reason: decision.reason }
+      const live = cellsRef.current.find((c) => c.id === cellId)
+      if (!live || live.value !== valueAtStart || live.mode !== modeAtStart) {
+        return { granted: false }
+      }
+      return { granted: true }
+    },
+    [cellsRef, claimBarrier, releaseIdleCell, validateWithGlobals],
+  )
+
   // Silently discard an in-flight run: no cancelled markers, no snapshot
   // delete. For ownership hand-offs (run→draw) where the chart engine takes
-  // over and the run must simply stop writing.
-  const abortCellRun = useCallback((cellId: string) => {
-    barrierAbortsRef.current.get(cellId)?.forEach((ac) => ac.abort())
-    const controllers = abortControllersRef.current.get(cellId)
-    if (!controllers) return
-    // Supersede the in-flight run so its late resolution can't write back
-    supersedeCellRun(runGenerationRef, cellId)
-    controllers.forEach((ac) => ac.abort())
-    clearRunningCell(
-      abortControllersRef,
-      autoFocusRef,
-      setRunningCellIds,
-      cellId,
-    )
-  }, [])
+  // over, and for a deleted cell; the run stops writing and reports the
+  // reason it was aborted with.
+  const abortCellRun = useCallback(
+    (cellId: string, reason: RunCancelReason) => {
+      barrierAbortsRef.current.get(cellId)?.forEach((ac) => ac.abort(reason))
+      const controllers = abortControllersRef.current.get(cellId)
+      if (!controllers) return
+      // Supersede the in-flight run so its late resolution can't write back
+      supersedeCellRun(runGenerationRef.current, cellId)
+      controllers.forEach((ac) => ac.abort(reason))
+      clearRunningCell(
+        abortControllersRef,
+        autoFocusRef,
+        setRunningCellIds,
+        cellId,
+      )
+    },
+    [],
+  )
 
-  const cancelCell = useCallback((cellId: string) => {
-    barrierAbortsRef.current.get(cellId)?.forEach((ac) => ac.abort())
+  const cancelCell = useCallback((cellId: string, reason?: RunCancelReason) => {
+    barrierAbortsRef.current.get(cellId)?.forEach((ac) => ac.abort(reason))
     const controllers = abortControllersRef.current.get(cellId)
     if (!controllers) return
-    controllers.forEach((ac) => ac.abort())
+    controllers.forEach((ac) => ac.abort(reason))
   }, [])
 
   const cancelQuery = useCallback(
@@ -902,22 +1037,25 @@ export const useCellExecution = ({
   )
 
   useEffect(() => {
+    const barrierControllersMap = barrierAbortsRef.current
     const controllersMap = abortControllersRef.current
+    const runGenerations = runGenerationRef.current
     return () => {
-      // Supersede before aborting so the in-flight continuations bail at their
-      // isCurrentRun() checks instead of overwriting the cell's last good
-      // snapshot with an abort-error (or a frozen "running" state) on unmount.
-      controllersMap.forEach((list, cellId) => {
-        supersedeCellRun(runGenerationRef, cellId)
-        list.forEach((c) => c.abort())
-      })
-      controllersMap.clear()
+      // Supersede before aborting so both validation- and request-phase
+      // continuations bail instead of launching after teardown or overwriting
+      // the cell's last good snapshot with an abort result.
+      abortCellRunsOnUnmount(
+        barrierControllersMap,
+        controllersMap,
+        runGenerations,
+      )
     }
   }, [])
 
   return {
     runningCellIds,
     runCell,
+    validateForDraw,
     reRunResultAt,
     abortCellRun,
     cancelCell,
diff --git a/src/scenes/Editor/Notebook/useNotebookPersistence.ts b/src/scenes/Editor/Notebook/useNotebookPersistence.ts
index 4d7a29f55..6563618a1 100644
--- a/src/scenes/Editor/Notebook/useNotebookPersistence.ts
+++ b/src/scenes/Editor/Notebook/useNotebookPersistence.ts
@@ -82,20 +82,22 @@ export const useNotebookPersistence = ({
     [scheduleFlush],
   )
 
+  // Settles once the document write lands, so a caller can order durable
+  // follow-ups (snapshot cleanup, an agent's success) behind it.
   const persistImmediately = useCallback(
-    (cells: NotebookCell[], exact = false) => {
-      if (preview || disposedRef.current) return
+    (cells: NotebookCell[], exact = false): Promise<void> => {
+      if (preview || disposedRef.current) return Promise.resolve()
       const effective = exact ? cells : (pendingCellsRef.current ?? cells)
       if (persistTimeoutRef.current) {
         window.clearTimeout(persistTimeoutRef.current)
         persistTimeoutRef.current = null
       }
       pendingCellsRef.current = null
-      void enqueueBufferTask(bufferId, () =>
+      return enqueueBufferTask(bufferId, () =>
         updateBuffer(bufferId, {
           notebookViewState: buildPayload(effective),
         }),
-      )
+      ).then(() => undefined)
     },
     [bufferId, updateBuffer, buildPayload, preview],
   )
diff --git a/src/scenes/Result/ResultChart/index.tsx b/src/scenes/Result/ResultChart/index.tsx
index d4278df72..87ca6d625 100644
--- a/src/scenes/Result/ResultChart/index.tsx
+++ b/src/scenes/Result/ResultChart/index.tsx
@@ -3,6 +3,8 @@ import { ChartLineIcon, WarningIcon } from "@phosphor-icons/react"
 import styled from "styled-components"
 import { AIStopButton } from "../../../components/AIStopButton"
 import { Button } from "../../../components/Button"
+import { IconButton } from "../../../components/IconButton"
+import { Reset } from "../../../components/icons"
 import { trackEvent } from "../../../modules/ConsoleEventTracker"
 import { ConsoleEvent } from "../../../modules/ConsoleEventTracker/events"
 import { normalizeQueryText } from "../../Editor/Monaco/utils"
@@ -26,6 +28,7 @@ type ResultChartData = Extract<QueryRawResult, { type: Type.DQL }>
 type Props = {
   result: ResultChartData | null
   visible: boolean
+  onResetZoomFocus?: () => void
 }
 
 type SavedConfig = {
@@ -59,6 +62,13 @@ const ChartArea = styled.div`
   min-height: 0;
 `
 
+const ChartActions = styled.div`
+  position: absolute;
+  z-index: 1;
+  top: 0.8rem;
+  right: 0.8rem;
+`
+
 const TruncationNotice = styled.div`
   display: flex;
   flex-shrink: 0;
@@ -134,7 +144,11 @@ const resultChartTelemetry: ChartSettingsTelemetry = {
   },
 }
 
-export const ResultChart: React.FC<Props> = ({ result, visible }) => {
+export const ResultChart: React.FC<Props> = ({
+  result,
+  visible,
+  onResetZoomFocus,
+}) => {
   const chartQuery = useChartQuery({ seed: result, enabled: visible })
   const [savedConfig, setSavedConfig] = useState<SavedConfig | null>(null)
   const [zoomStart, setZoomStart] = useState(0)
@@ -188,6 +202,13 @@ export const ResultChart: React.FC<Props> = ({ result, visible }) => {
     setZoomEnd(end)
   }, [])
 
+  const handleResetZoom = useCallback(() => {
+    chartRendererRef.current?.resetZoom()
+    onResetZoomFocus?.()
+  }, [onResetZoomFocus])
+
+  const isZoomed = zoomStart > 0 || zoomEnd < 100
+
   let emptyMessage = "Run a query to draw a chart."
   if (chartResult && chartResult.dataset.length === 0) {
     emptyMessage = "This result has no rows to plot."
@@ -272,6 +293,20 @@ export const ResultChart: React.FC<Props> = ({ result, visible }) => {
           </TruncationNotice>
         )}
         <ChartArea>
+          {isZoomed && (
+            <ChartActions>
+              <IconButton
+                label="Reset zoom"
+                tooltip="Reset zoom"
+                variant="secondary"
+                size="sm"
+                dataHook="result-chart-reset-zoom"
+                onClick={handleResetZoom}
+              >
+                <Reset size={16} />
+              </IconButton>
+            </ChartActions>
+          )}
           <ChartRenderer
             ref={chartRendererRef}
             option={option}
diff --git a/src/scenes/Result/index.tsx b/src/scenes/Result/index.tsx
index 603536830..2f5374b0f 100644
--- a/src/scenes/Result/index.tsx
+++ b/src/scenes/Result/index.tsx
@@ -170,6 +170,7 @@ const Result = ({ viewMode }: { viewMode: ResultViewMode }) => {
   const { active: activeQueryExecution } = useQueryExecutionState()
   const activeSidebar = useSelector(selectors.console.getActiveSidebar)
   const gridRef = useRef<IQuestDBGrid | null>(null)
+  const resultToolbarRef = useRef<HTMLDivElement | null>(null)
   const runningRef = useRef(running)
   const [gridFreezeLeftState, setGridFreezeLeftState] = useState<number>(0)
   const [gridHasSelection, setGridHasSelection] = useState<boolean>(false)
@@ -397,7 +398,12 @@ const Result = ({ viewMode }: { viewMode: ResultViewMode }) => {
   return (
     <Root>
       <Wrapper>
-        <Actions>
+        <Actions
+          ref={resultToolbarRef}
+          role="toolbar"
+          aria-label="Result actions"
+          tabIndex={-1}
+        >
           {count !== undefined && (
             <ResultCountBadge
               aria-label={`${count.toLocaleString()} ${count === 1 ? "row" : "rows"}`}
@@ -520,6 +526,7 @@ const Result = ({ viewMode }: { viewMode: ResultViewMode }) => {
             <ResultChart
               result={result?.type === QuestDB.Type.DQL ? result : null}
               visible={viewMode === "chart"}
+              onResetZoomFocus={() => resultToolbarRef.current?.focus()}
             />
           )}
         </Content>
diff --git a/src/store/notebook.ts b/src/store/notebook.ts
index ab7addcc9..337a16d68 100644
--- a/src/store/notebook.ts
+++ b/src/store/notebook.ts
@@ -37,6 +37,19 @@ export type AutoRefresh = boolean | AutoRefreshInterval
 // migration. Markdown cells hold their source in `value` and are never executed.
 export type CellType = "sql" | "markdown"
 
+export type AgentCellView = "editor" | "result" | "editor_result"
+
+export const isAgentCellView = (value: unknown): value is AgentCellView =>
+  value === "editor" || value === "result" || value === "editor_result"
+
+// The storable pane arrangements. "editor" exists only on the agent wire: as a
+// write it discards the result (the toggle-off gesture), as a read it is the
+// derived presentation of a cell with nothing to show.
+export type CellPaneView = "result" | "editor_result"
+
+export const isCellPaneView = (value: unknown): value is CellPaneView =>
+  value === "result" || value === "editor_result"
+
 export type NotebookCell = {
   id: string
   position: number
@@ -50,10 +63,15 @@ export type NotebookCell = {
   topResized?: boolean
   bottomResized?: boolean
   spotlightEditorRatio?: number
-  mode?: CellMode
+  // Draw is persistent cell identity because it is also the marker used to
+  // hydrate and refresh a chart whose result is not currently in memory.
+  // Run is the absence of draw mode and must never be persisted.
+  mode?: "draw"
   chartConfig?: ChartConfig
   autoRefresh?: AutoRefresh
-  isViewMaximized?: boolean
+  // Stored pane arrangement for a cell with a result. A cell without one
+  // shows only the editor; that never rewrites it.
+  paneView?: CellPaneView
   lastRunStatus?: RunStatus
   lastRunError?: string
 }
@@ -147,6 +165,7 @@ export const createCell = (position: number, value = ""): NotebookCell => ({
   id: crypto.randomUUID(),
   position,
   value,
+  paneView: "editor_result",
 })
 
 export const createDefaultNotebookViewState = (): NotebookViewState => ({
diff --git a/src/utils/ai/anthropicProvider.ts b/src/utils/ai/anthropicProvider.ts
index 5a2731f55..ddfbf0dd7 100644
--- a/src/utils/ai/anthropicProvider.ts
+++ b/src/utils/ai/anthropicProvider.ts
@@ -295,11 +295,11 @@ async function handleToolCalls(
   setStatus: StatusCallback,
   tools: AnthropicTool[],
   contextWindow: number,
+  perms: Permissions | (() => Permissions),
+  validateSql: (sql: string) => Promise<ValidateQueryResult>,
   abortSignal?: AbortSignal,
   accumulatedTokens: TokenUsage = { inputTokens: 0, outputTokens: 0 },
   streaming?: StreamingCallback,
-  perms?: Permissions | (() => Permissions),
-  validateSql?: (sql: string) => Promise<ValidateQueryResult>,
   toolContext?: ToolExecutionContext,
   round: number = 1,
 ): Promise<AnthropicToolCallResult | AiAssistantAPIError> {
@@ -430,11 +430,11 @@ async function handleToolCalls(
       setStatus,
       tools,
       contextWindow,
+      perms,
+      validateSql,
       abortSignal,
       newAccumulatedTokens,
       streaming,
-      perms,
-      validateSql,
       toolContext,
       round + 1,
     )
@@ -536,11 +536,11 @@ export function createAnthropicProvider(
           setStatus,
           anthropicTools,
           contextWindow,
+          perms,
+          validateSql,
           abortSignal,
           { inputTokens: 0, outputTokens: 0 },
           streaming,
-          perms,
-          validateSql,
           toolContext,
         )
 
diff --git a/src/utils/ai/notebookSnapshot.test.ts b/src/utils/ai/notebookSnapshot.test.ts
index c269d3684..6100ff533 100644
--- a/src/utils/ai/notebookSnapshot.test.ts
+++ b/src/utils/ai/notebookSnapshot.test.ts
@@ -6,6 +6,7 @@ import {
   formatDigest,
   formatNotebookContextPrefix,
   formatSnapshot,
+  serializeCell,
   summarizeCells,
   type NotebookContextSnapshot,
 } from "./notebookSnapshot"
@@ -18,6 +19,7 @@ import {
 } from "../notebooks/notebookController"
 import { __resetNotebookBufferQueuesForTests } from "../notebooks/notebookBufferQueue"
 import { db } from "../../store/db"
+import { saveCellSnapshot } from "../../store/notebookResults"
 import type {
   NotebookCell,
   NotebookSettings,
@@ -41,6 +43,7 @@ const makeController = (
   cells: NotebookCell[],
   settings: NotebookSettings = {},
   maximizedCellId: string | null = null,
+  readResultStatus?: NonNullable<NotebookController["readResultStatus"]>,
 ): NotebookController => ({
   bufferId,
   kind: "live",
@@ -49,6 +52,13 @@ const makeController = (
       transition({ cells, settings, maximizedCellId, focusedCellId: null })
         .result,
     ),
+  mutateWithResultStatus: (transition) =>
+    Promise.resolve(
+      transition(
+        { cells, settings, maximizedCellId, focusedCellId: null },
+        readResultStatus ?? (() => "unrequested"),
+      ).result,
+    ),
   readView: () =>
     Promise.resolve({
       cells,
@@ -57,6 +67,7 @@ const makeController = (
     }),
   runCell: () =>
     Promise.resolve({ success: true, queryCount: 1, results: ["success"] }),
+  ...(readResultStatus ? { readResultStatus } : {}),
 })
 
 const seedNotebook = async (
@@ -78,9 +89,41 @@ beforeEach(async () => {
   __resetNotebookAIBridgeForTests()
   __resetNotebookBufferQueuesForTests()
   await db.buffers.clear()
+  await db.notebook_results.clear()
 })
 
 describe("buildSnapshot", () => {
+  it("reports a run-marked cell's stored view when the snapshot index is unavailable", async () => {
+    // Given a background notebook whose run-marked cell has no snapshot row,
+    // and an index that rejects every read
+    const id = await db.buffers.add({
+      label: "nb",
+      value: "",
+      position: 0,
+      notebookViewState: {
+        cells: [
+          { id: "a", position: 0, value: "SELECT 1", lastRunStatus: "success" },
+        ],
+      },
+    })
+    const where = vi
+      .spyOn(db.notebook_results, "where")
+      .mockImplementation(() => {
+        throw new Error("index down")
+      })
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined)
+
+    // When the snapshot is built
+    const snap = await buildSnapshot(id)
+
+    // Then the read succeeds and the cell keeps its stored arrangement
+    expect(snap?.status).toBe("ok")
+    expect(snap?.status === "ok" && snap.cells[0].view).toBe("editor_result")
+    expect(warn).toHaveBeenCalledOnce()
+    where.mockRestore()
+    warn.mockRestore()
+  })
+
   it("returns null for a buffer that is not a notebook", async () => {
     const id = await db.buffers.add({
       label: "sql tab",
@@ -114,6 +157,53 @@ describe("buildSnapshot", () => {
     }
   })
 
+  it("reports editor when the mounted cell's saved result is known missing", async () => {
+    const released = sql("a", "SELECT 1", {
+      mode: undefined,
+      lastRunStatus: "success",
+      paneView: "result",
+    })
+    const id = await seedNotebook({ cells: [released] })
+    registerController(
+      makeController(id, [released], {}, null, () => "missing"),
+    )
+
+    const snap = await buildSnapshot(id)
+
+    expect(snap?.status === "ok" ? snap.cells[0] : undefined).toMatchObject({
+      view: "editor",
+      mode: null,
+      last_run_status: "success",
+    })
+  })
+
+  it("uses passive snapshot keys to distinguish restorable and missing results", async () => {
+    const released = sql("a", "SELECT 1", {
+      mode: undefined,
+      lastRunStatus: "success",
+      paneView: "result",
+    })
+    const id = await seedNotebook({ cells: [released] })
+
+    const missing = await buildSnapshot(id)
+    expect(missing?.status === "ok" ? missing.cells[0].view : undefined).toBe(
+      "editor",
+    )
+
+    await saveCellSnapshot({
+      bufferId: id,
+      cellId: "a",
+      results: [],
+      savedAt: 1,
+    })
+    const restorable = await buildSnapshot(id)
+    expect(
+      restorable?.status === "ok"
+        ? [restorable.cells[0].view, restorable.cells[0].mode]
+        : undefined,
+    ).toEqual(["result", "run"])
+  })
+
   it("serves the live snapshot when the controller unregisters mid-read", async () => {
     // Given a mounted notebook whose Dexie copy lags the live cells
     const id = await seedNotebook({ cells: [sql("a", "persisted")] })
@@ -154,6 +244,17 @@ describe("buildSnapshot", () => {
     }
   })
 
+  it("preserves SQL comparison operators in structured snapshot previews", async () => {
+    const value =
+      "SELECT * FROM fx_trades WHERE price < 1 AND quantity > 2 AND symbol <> 'A&B'"
+    const id = await seedNotebook({ cells: [sql("a", value)] })
+    const snap = await buildSnapshot(id)
+    expect(snap?.status).toBe("ok")
+    if (snap?.status === "ok") {
+      expect(snap.cells[0].preview).toBe(value)
+    }
+  })
+
   it("trims last_run_error_summary to 200 chars and never leaks dataset/columns", async () => {
     const longErr = "x".repeat(300)
     const cell = sql("a", "SELECT 1", {
@@ -203,14 +304,107 @@ describe("buildSnapshot", () => {
     const gridSnap = await buildSnapshot(gridId)
     if (listSnap?.status === "ok" && gridSnap?.status === "ok") {
       expect(listSnap.cells[0].grid).toBeUndefined()
-      // h is derived from the cell's content, not the stored layout h (4) —
-      // a fresh run cell resolves to 5 rows regardless of the persisted shadow.
-      expect(gridSnap.cells[0].grid).toEqual({ x: 0, y: 0, w: 6, h: 5 })
+      // Agent layout exposes placement/width only; height is controlled through
+      // semantic pane dimensions and derived internally.
+      expect(gridSnap.cells[0].grid).toEqual({ x: 0, y: 0, w: 6 })
+      // A never-run cell presents only its editor, so the view reads "editor".
+      expect(gridSnap.cells[0]).toMatchObject({
+        editor_height: "auto",
+        result_height: "auto",
+        view: "editor",
+        mode: null,
+      })
     } else {
       throw new Error("expected ok snapshots")
     }
   })
 
+  it("reports a null view and result height for a markdown cell", async () => {
+    // Given a live markdown cell
+    const id = await seedNotebook({
+      cells: [sql("a", "# title", { type: "markdown" })],
+    })
+    // When the snapshot builds
+    const snap = await buildSnapshot(id)
+    const cellSnapshot = snap?.status === "ok" ? snap.cells[0] : undefined
+    // Then the pane fields are null
+    expect(cellSnapshot).toMatchObject({
+      type: "markdown",
+      view: null,
+      mode: null,
+      result_height: null,
+    })
+    // And get_cell reports the same null pane fields
+    const details = serializeCell(
+      [sql("a", "# title", { type: "markdown" })],
+      "a",
+      id,
+      false,
+    )
+    expect(details).toMatchObject({
+      view: null,
+      mode: null,
+      result_height: null,
+    })
+  })
+
+  it("reports editor from get_cell serialization when the result is missing", () => {
+    const released = sql("a", "SELECT 1", {
+      mode: undefined,
+      lastRunStatus: "success",
+      paneView: "editor_result",
+    })
+
+    const details = serializeCell(
+      [released],
+      "a",
+      7,
+      false,
+      undefined,
+      "missing",
+    )
+
+    expect(details).toMatchObject({
+      view: "editor",
+      mode: null,
+      last_run_status: "success",
+    })
+  })
+
+  it("reports the stored view for an inactive notebook", async () => {
+    const id = await seedNotebook({
+      cells: [
+        sql("a", "SELECT 1", {
+          mode: "draw",
+          paneView: "editor_result",
+        }),
+      ],
+    })
+
+    const snap = await buildSnapshot(id)
+    expect(snap?.status === "ok" ? snap.cells[0] : undefined).toMatchObject({
+      view: "editor_result",
+      mode: "draw",
+    })
+  })
+
+  it("round-trips a pinned result height while passive result data is unloaded", async () => {
+    const id = await seedNotebook({
+      cells: [
+        sql("a", "SELECT 1", {
+          bottomHeight: 400,
+          bottomResized: true,
+          lastRunStatus: "success",
+        }),
+      ],
+    })
+
+    const snap = await buildSnapshot(id)
+    expect(
+      snap?.status === "ok" ? snap.cells[0].result_height : undefined,
+    ).toBe(400)
+  })
+
   it("includes settings.variables when non-empty and omits when missing", async () => {
     const cells = [sql("a", "SELECT @x FROM trades")]
     const withVarsId = await seedNotebook({
@@ -270,7 +464,7 @@ describe("buildSnapshot", () => {
     const cell = sql("a", "SELECT 1", {
       mode: "draw",
       autoRefresh: "5s",
-      isViewMaximized: false,
+      paneView: "editor_result",
       name: "Trades",
       chartConfig: {
         xColumn: "ts",
@@ -313,10 +507,37 @@ describe("summarizeCells", () => {
     // Then the name is surfaced for the named cell and omitted otherwise
     expect(named.name).toBe("Recent Trades")
     expect(unnamed.name).toBeUndefined()
+    expect(named.mode).toBeNull()
+    expect(unnamed.mode).toBeNull()
+  })
+
+  it("derives run mode only while a table snapshot still exists", () => {
+    const released = sql("a", "SELECT 1", {
+      lastRunStatus: "success",
+      paneView: "result",
+    })
+
+    expect(summarizeCells([released], undefined, () => "missing")[0].mode).toBe(
+      null,
+    )
+    expect(
+      summarizeCells([released], undefined, () => "unrequested")[0].mode,
+    ).toBe("run")
   })
 })
 
 describe("formatSnapshot", () => {
+  it("guards comparison operators only in the pseudo-XML prompt context", async () => {
+    const value = "SELECT 1 WHERE price < 2 AND quantity > 0"
+    const id = await seedNotebook({ cells: [sql("a", value)] })
+    const snap = (await buildSnapshot(id))!
+
+    expect(snap.status === "ok" && snap.cells[0].preview).toBe(value)
+    const out = formatSnapshot(snap)
+    expect(out).toContain("price ‹ 2 AND quantity › 0")
+    expect(out).not.toContain("price < 2")
+  })
+
   it("emits a warning-variant block for archived status", () => {
     const snap: NotebookContextSnapshot = {
       status: "archived",
@@ -349,7 +570,11 @@ describe("formatSnapshot", () => {
     expect(out).toContain(`buffer_id: ${id}`)
     expect(out).toContain("layout_mode: grid")
     expect(out).toContain("- id: a")
-    expect(out).toContain("grid: { x: 0, y: 0, w: 12, h: 5 }")
+    expect(out).toContain("editor_height: auto")
+    expect(out).toContain("result_height: auto")
+    expect(out).toContain("mode: null")
+    expect(out).toContain("view: editor")
+    expect(out).toContain("grid: { x: 0, y: 0, w: 12 }")
   })
 
   it("renders chart_config as one-line wire JSON the model can copy back", async () => {
diff --git a/src/utils/ai/notebookSnapshot.ts b/src/utils/ai/notebookSnapshot.ts
index 48f2f69ed..769dff938 100644
--- a/src/utils/ai/notebookSnapshot.ts
+++ b/src/utils/ai/notebookSnapshot.ts
@@ -1,12 +1,14 @@
 import {
   getController,
   type CellRefreshView,
+  type NotebookController,
 } from "../notebooks/notebookController"
 import { enqueueBufferTask } from "../notebooks/notebookBufferQueue"
 import { readNotebookBufferMeta } from "../notebooks/notebookDexieView"
 import { NotebookToolError } from "../notebooks/notebookToolError"
 import { sanitizeForPromptContext } from "./sanitizeForPromptContext"
 import type {
+  AgentCellView,
   AutoRefresh,
   CellLayoutItem,
   NotebookCell,
@@ -15,9 +17,14 @@ import type {
 import type { UserActionDigest } from "../../providers/AIConversationProvider/types"
 import type { WorkspaceInfo } from "./executeAIFlow"
 import { normalizeVariables } from "../../scenes/Editor/Notebook/declareUtils"
-import { computeAgentCellGridH } from "../../scenes/Editor/Notebook/notebookUtils"
+import {
+  agentCellPaneDimensions,
+  agentCellPresentation,
+} from "../../scenes/Editor/Notebook/notebookUtils"
+import type { CellResultStatus } from "../../scenes/Editor/Notebook/resultHydration/cellResultHydration"
 import { getCellRunStatus, type RunStatus } from "./runStatus"
 import type { ChartConfig } from "../../scenes/Editor/Notebook/CellChart/chartTypes"
+import { loadPassiveResultStatusReader } from "../notebooks/notebookResultStatus"
 
 type ChartQueryWire = {
   type: string
@@ -47,9 +54,11 @@ export type NotebookContextCell = {
   // Omitted for SQL cells (the default); "markdown" for prose cells (rendered,
   // never executed).
   type?: "sql" | "markdown"
-  mode?: "run" | "draw"
+  mode: "run" | "draw" | null
   auto_refresh?: AutoRefresh
-  is_view_maximized?: boolean
+  editor_height: number | "auto"
+  result_height: number | "auto" | null
+  view: AgentCellView | null
   chart_config?: ChartConfigWire
   last_run_status?: RunStatus
   last_run_error_summary?: string
@@ -58,7 +67,7 @@ export type NotebookContextCell = {
   refreshing?: true
   last_refresh_error?: string
   auto_refresh_blocked?: "contains_write"
-  grid?: { x: number; y: number; w: number; h: number }
+  grid?: { x: number; y: number; w: number }
 }
 
 export type NotebookContextSnapshot =
@@ -82,13 +91,23 @@ export type NotebookContextSnapshot =
 const PREVIEW_MAX = 120
 const ERROR_MAX = 200
 
+export const loadNotebookResultStatusReader = (
+  bufferId: number,
+  controller?: Pick<NotebookController, "readResultStatus">,
+): Promise<(cellId: string) => CellResultStatus> =>
+  controller?.readResultStatus
+    ? Promise.resolve(controller.readResultStatus)
+    : loadPassiveResultStatusReader(bufferId)
+
 const truncate = (s: string, max: number): string =>
   s.length <= max ? s : `${s.slice(0, max - 3)}...`
 
 const escapeNewlines = (s: string): string => s.replace(/\n/g, "\\n")
 
+// Keep structured read payloads faithful to the stored cell value. The
+// pseudo-XML prompt wrapper applies its delimiter guard at formatting time.
 const preview = (value: string): string =>
-  sanitizeForPromptContext(escapeNewlines(truncate(value, PREVIEW_MAX)))
+  escapeNewlines(truncate(value, PREVIEW_MAX))
 
 export const toChartConfigWire = (cfg: ChartConfig): ChartConfigWire => ({
   x_column: cfg.xColumn,
@@ -156,10 +175,16 @@ const buildCell = (
   gridByCellId: Map<string, CellLayoutItem>,
   layoutMode: "list" | "grid",
   refreshState: ReadonlyMap<string, CellRefreshView> | undefined,
+  resultStatus: CellResultStatus,
 ): NotebookContextCell => {
+  const dimensions = agentCellPaneDimensions(cell)
+  const presentation = agentCellPresentation(cell, resultStatus)
   const out: NotebookContextCell = {
     id: cell.id,
     preview: preview(cell.value),
+    editor_height: dimensions.editorHeight,
+    result_height: dimensions.resultHeight,
+    ...presentation,
     ...lastRunSummary(cell),
     ...refreshFields(refreshState?.get(cell.id)),
   }
@@ -169,11 +194,7 @@ const buildCell = (
   }
   if (cell.name != null) out.name = cell.name
   if (cell.type === "markdown") out.type = "markdown"
-  if (cell.mode === "draw" || cell.mode === "run") out.mode = cell.mode
   if (cell.autoRefresh !== undefined) out.auto_refresh = cell.autoRefresh
-  if (typeof cell.isViewMaximized === "boolean") {
-    out.is_view_maximized = cell.isViewMaximized
-  }
   const chartConfig = cell.chartConfig
   if (chartConfig && Array.isArray(chartConfig.queries)) {
     out.chart_config = toChartConfigWire(chartConfig)
@@ -185,7 +206,6 @@ const buildCell = (
         x: g.x,
         y: g.y,
         w: g.w,
-        h: computeAgentCellGridH(cell),
       }
     }
   }
@@ -208,6 +228,10 @@ export const buildSnapshot = async (
   }
   const view = controller ? await controller.readView() : meta.view
   const refreshState = controller?.readRefreshState?.()
+  const resultStatusOf = await loadNotebookResultStatusReader(
+    bufferId,
+    controller,
+  )
   const cells: NotebookCell[] = view.cells
   const settings: NotebookSettings = view.settings ?? {}
   const maximizedCellId = view.maximizedCellId ?? null
@@ -224,7 +248,13 @@ export const buildSnapshot = async (
     layout_mode: layoutMode,
     maximized_cell_id: maximizedCellId,
     cells: cells.map((c) =>
-      buildCell(c, gridByCellId, layoutMode, refreshState),
+      buildCell(
+        c,
+        gridByCellId,
+        layoutMode,
+        refreshState,
+        resultStatusOf(c.id),
+      ),
     ),
   }
   // Absence stays observable: with no configured default, nothing polls.
@@ -280,7 +310,9 @@ export const formatSnapshot = (snap: NotebookContextSnapshot): string => {
   lines.push("  cells:")
   for (const c of snap.cells) {
     lines.push(`    - id: ${c.id}`)
-    lines.push(`      preview: ${JSON.stringify(c.preview)}`)
+    lines.push(
+      `      preview: ${JSON.stringify(sanitizeForPromptContext(c.preview))}`,
+    )
     if (c.preview_truncated) {
       lines.push(`      preview_truncated: true`)
       lines.push(`      full_length: ${c.full_length}`)
@@ -290,11 +322,12 @@ export const formatSnapshot = (snap: NotebookContextSnapshot): string => {
         `      name: ${JSON.stringify(sanitizeForPromptContext(c.name))}`,
       )
     if (c.type) lines.push(`      type: ${c.type}`)
-    if (c.mode) lines.push(`      mode: ${c.mode}`)
+    lines.push(`      mode: ${c.mode}`)
     if (c.auto_refresh !== undefined)
       lines.push(`      auto_refresh: ${c.auto_refresh}`)
-    if (c.is_view_maximized !== undefined)
-      lines.push(`      is_view_maximized: ${c.is_view_maximized}`)
+    lines.push(`      editor_height: ${c.editor_height}`)
+    lines.push(`      result_height: ${c.result_height}`)
+    lines.push(`      view: ${c.view}`)
     if (c.chart_config) {
       lines.push(
         `      chart_config: ${sanitizeForPromptContext(
@@ -319,7 +352,7 @@ export const formatSnapshot = (snap: NotebookContextSnapshot): string => {
       lines.push(`      auto_refresh_blocked: ${c.auto_refresh_blocked}`)
     if (c.grid) {
       lines.push(
-        `      grid: { x: ${c.grid.x}, y: ${c.grid.y}, w: ${c.grid.w}, h: ${c.grid.h} }`,
+        `      grid: { x: ${c.grid.x}, y: ${c.grid.y}, w: ${c.grid.w} }`,
       )
     }
   }
@@ -416,7 +449,7 @@ export type NotebookCellSummary = {
   preview: string
   position: number
   type?: "sql" | "markdown"
-  mode?: "run" | "draw"
+  mode: "run" | "draw" | null
   last_run_status?: RunStatus
   // Live-only (mounted notebook); see NotebookContextCell.
   refreshing?: true
@@ -432,9 +465,11 @@ export type NotebookCellDetails = {
   name?: string
   position: number
   type?: "sql" | "markdown"
-  mode?: "run" | "draw"
+  mode: "run" | "draw" | null
   auto_refresh?: AutoRefresh
-  is_view_maximized?: boolean
+  editor_height: number | "auto"
+  result_height: number | "auto" | null
+  view: AgentCellView | null
   chart_config?: ChartConfigWire
   last_run_status?: RunStatus
   last_run_error?: string
@@ -447,6 +482,7 @@ export type NotebookCellDetails = {
 export const summarizeCells = (
   cells: NotebookCell[],
   refreshState?: ReadonlyMap<string, CellRefreshView>,
+  resultStatusOf?: (cellId: string) => CellResultStatus,
 ): NotebookCellSummary[] =>
   cells.map((cell) => {
     const summary: NotebookCellSummary = {
@@ -456,12 +492,15 @@ export const summarizeCells = (
           ? cell.value
           : `${cell.value.slice(0, 117)}...`,
       position: cell.position,
+      mode: agentCellPresentation(
+        cell,
+        resultStatusOf?.(cell.id) ?? "unrequested",
+      ).mode,
       last_run_status: runStatusOf(cell).status,
       ...refreshFields(refreshState?.get(cell.id)),
     }
     if (cell.name) summary.name = cell.name
     if (cell.type === "markdown") summary.type = "markdown"
-    if (cell.mode) summary.mode = cell.mode
     return summary
   })
 
@@ -471,6 +510,7 @@ export const serializeCell = (
   bufferId: number,
   getFullContent: boolean,
   refreshState?: ReadonlyMap<string, CellRefreshView>,
+  resultStatus: CellResultStatus = "unrequested",
 ): NotebookCellDetails => {
   const cell = cells.find((c) => c.id === cellId)
   if (!cell) {
@@ -488,12 +528,17 @@ export const serializeCell = (
   const truncated = !getFullContent && cell.value.length > CELL_VALUE_MAX
   const value = truncated ? cell.value.slice(0, CELL_VALUE_MAX) : cell.value
   const run = runStatusOf(cell)
+  const dimensions = agentCellPaneDimensions(cell)
+  const presentation = agentCellPresentation(cell, resultStatus)
   const out: NotebookCellDetails = {
     id: cell.id,
     value,
     position: cell.position,
     last_run_status: run.status,
     last_run_error: run.error,
+    editor_height: dimensions.editorHeight,
+    result_height: dimensions.resultHeight,
+    ...presentation,
     ...refreshFields(refreshState?.get(cell.id)),
   }
   if (truncated) {
@@ -502,10 +547,7 @@ export const serializeCell = (
   }
   if (cell.name != null) out.name = cell.name
   if (cell.type === "markdown") out.type = "markdown"
-  if (cell.mode) out.mode = cell.mode
   if (cell.autoRefresh !== undefined) out.auto_refresh = cell.autoRefresh
-  if (typeof cell.isViewMaximized === "boolean")
-    out.is_view_maximized = cell.isViewMaximized
   if (cell.chartConfig && Array.isArray(cell.chartConfig.queries))
     out.chart_config = toChartConfigWire(cell.chartConfig)
   return out
diff --git a/src/utils/ai/prompts.ts b/src/utils/ai/prompts.ts
index 544fa2aee..d3d992efe 100644
--- a/src/utils/ai/prompts.ts
+++ b/src/utils/ai/prompts.ts
@@ -82,7 +82,7 @@ export const NOTEBOOK_INSTRUCTION = `
 
 ## Notebook Authoring
 You can create and edit QuestDB notebooks (tabs of SQL cells with list/grid layouts, draw-mode charts, and markdown prose cells) using these tools:
-create_notebook, list_cells, get_cell, get_notebook_state, add_cell, update_cell, delete_cell, move_cell_up, move_cell_down, duplicate_cell, run_cell, set_layout_mode, set_cell_layout, set_cell_mode, set_cell_name, set_cell_chart_config, set_notebook_autorefresh, set_cell_autorefresh, set_cell_view_maximized, set_cell_maximized.
+create_notebook, list_cells, get_cell, get_notebook_state, add_cell, update_cell, delete_cell, move_cell_up, move_cell_down, duplicate_cell, run_cell, set_layout_mode, set_cell_layout, set_cell_dimensions, set_cell_mode, set_cell_name, set_cell_chart_config, set_notebook_autorefresh, set_cell_autorefresh, set_cell_maximized.
 
 CRITICAL — Do NOT expose buffer_id to the user
 - buffer_id is an internal identifier. NEVER ask the user for it, print it back, or mention it in any response.
@@ -114,10 +114,12 @@ When to use notebook tools
 Editing discipline
 - update_cell overwrites preemptively — cells are auto-saved, there is no unsaved-dirty state to worry about. Be deliberate.
 - Cells containing DDL/DML (INSERT/UPDATE/CREATE/DROP/...) never auto-run via apply_notebook_state or add_cell — they are skipped. Confirm with the user, then call run_cell explicitly; run_cell is the only path that executes a write cell.
-- Markdown cells: add_cell (or apply_notebook_state) with type:"markdown" creates a rendered prose cell — its value is markdown text, it is NEVER executed (run_cell and auto-run are no-ops on it), and it must carry no mode/chart_config. Use them for titles, narrative, and explanations between query cells. In apply_notebook_state the cell kind is STICKY: omitting type preserves a cell's kind (a markdown cell stays markdown).
+- Markdown cells: add_cell (or apply_notebook_state) with type:"markdown" creates a rendered prose cell — its value is markdown text, it is NEVER executed (run_cell and auto-run are no-ops on it), and it must carry no mode/chart_config. Use them for titles, narrative, and explanations between query cells. In apply_notebook_state the cell kind is FIXED: omitting type preserves a cell's kind, and an existing cell can never change kind — delete it and add a new cell instead.
+- Cell dimensions are pane-based CSS pixels, not grid rows. Use editor_height/result_height/view (or set_cell_dimensions); grid height is derived. Null preserves, "auto" restores automatic sizing, and a number pins a pane. For SQL/draw cells, view is the pane view: editor, result, or editor_result. A cell without a result shows only the editor until one exists; that never rewrites view. Markdown has no pane-view state: it reports view and result_height as null; keep view and result_height null when writing a markdown cell (any value is ignored). Keep charts at result_height >= 296 and every pane at most 2400; use editor_height 86 for a polished markdown title.
+- In apply_notebook_state, view:"editor" is authoritative and destructive: it clears the result/snapshot and reports mode:null. Send mode:null with it; explicit mode:"run" or mode:"draw" is contradictory and rejected.
 - To fix a broken cell: update_cell with the fix, then run_cell. If run_cell returns success:false, read the error and try again. Cap repair attempts at two, then summarise and hand back to the user.
 - Draw-mode cells auto-run when their chart config changes. After set_cell_mode=draw + set_cell_chart_config, do NOT call run_cell.
-- apply_notebook_state is a full PUT: every cell you send is REPLACED wholesale and omitted/null fields are cleared, NOT merged from the current cell. To keep a draw cell's chart, re-send its full \`chart_config\` — copy the \`chart_config\` shown on that cell in <notebook_context> (it is already the exact wire shape). For a single targeted edit, prefer update_cell / set_cell_chart_config (a PATCH on chart_config) instead.
+- apply_notebook_state is a full PUT for cell membership, values, and chart configuration. To keep a draw cell's chart, re-send its full \`chart_config\` — copy the \`chart_config\` shown on that cell in <notebook_context> (it is already the exact wire shape). Nullable fields such as the dimensions, view, mode, and type are the exception: null preserves their current setting. For a single targeted edit, prefer update_cell / set_cell_chart_config / set_cell_dimensions instead.
 - For a chart: add_cell with a SELECT that returns (x, y) data, then set_cell_mode=draw, then set_cell_chart_config with \`queries: [{ type, ... }]\` — one entry per \`;\`-split statement, index-aligned. A non-null \`queries\` array REPLACES the whole list, so always send the FULL array (one entry per statement) — never a partial subset, or the omitted statements lose their config and re-infer. A non-empty \`queries\` whose length ≠ the cell's statement count is REJECTED. Use \`queries:null\` to preserve the current config, \`queries:[]\` to reset every statement back to inference. Each query keeps its own type from line/area/stepLine/stepArea/bar/stackedBar/scatter/pie/candlestick.
 - COMBINE multiple types in one chart: put several SELECTs in the cell (\`;\`-separated). They AUTO-COMBINE sharing the first query's x-axis when the x-axis kind matches (all-temporal or all-categorical). Use \`axis:"right"\` (+ \`right_axis:{name,min,max}\`) for a series on a different scale (RSI 0..100, volume); \`enabled:false\` opts a query out. Example: \`SELECT ts,open,high,low,close ...; SELECT ts,vwap ...\` auto-combines OHLC + VWAP with no config; add RSI on a second axis with \`queries:[{type:"candlestick"},{type:"line"},{type:"line",axis:"right"}]\` + \`right_axis:{name:"RSI",min:0,max:100}\`.
 - For a candlestick query: pass \`ohlc:{open,high,low,close}\` (required; an OHLC chart needs an explicit ohlc mapping).
diff --git a/src/utils/ai/shared.notebookTools.test.ts b/src/utils/ai/shared.notebookTools.test.ts
index 001ed28fb..67218a82a 100644
--- a/src/utils/ai/shared.notebookTools.test.ts
+++ b/src/utils/ai/shared.notebookTools.test.ts
@@ -1,4 +1,5 @@
 import "../../test/stubBrowserGlobals"
+import type { Permissions } from "../tools/permissions"
 import { beforeEach, describe, it, expect, vi } from "vitest"
 import { dispatchTool } from "../tools/dispatch"
 import type { ModelToolsClient, StatusCallback } from "./aiAssistant"
@@ -12,6 +13,7 @@ import { NotebookToolError } from "../notebooks/notebookToolError"
 import {
   __resetNotebookControllerForTests,
   registerController,
+  unregisterController,
   type NotebookController,
   type RunCellSummary,
 } from "../notebooks/notebookController"
@@ -40,6 +42,7 @@ import { dispatchMCPTool } from "../mcp/dispatchMCPTool"
 import { EXPECTED_MCP_VERSION } from "../mcp/protocolVersion"
 import type { ToolExecutionContext } from "./shared"
 import { createNotebookFreshness } from "../notebooks/notebookFreshness"
+import { computeAgentCellGridH } from "../../scenes/Editor/Notebook/notebookUtils"
 
 const cell = (
   id: string,
@@ -67,6 +70,8 @@ const mountLive = (
     validate?: (sql: string) => Promise<ValidateQueryResult>
     // Fires on each readView — lets a test simulate a user edit racing a read.
     onRead?: () => void
+    // Fires when duplicate_cell flushes live chart snapshots.
+    onFlush?: () => void
   } = {},
 ) => {
   const state: { parts: ViewParts } = {
@@ -125,6 +130,8 @@ const mountLive = (
         return Promise.reject(error)
       }
     },
+    mutateWithResultStatus: (transition) =>
+      controller.mutate((parts) => transition(parts, () => "unrequested")),
     readView: () => {
       opts.onRead?.()
       return Promise.resolve({
@@ -134,6 +141,10 @@ const mountLive = (
       })
     },
     runCell: vi.fn(runCell),
+    flushChartSnapshots: () => {
+      opts.onFlush?.()
+      return Promise.resolve()
+    },
   }
   registerController(controller)
   return { state, runCell: controller.runCell }
@@ -182,6 +193,16 @@ const makeClient = (
 
 const noopStatus: StatusCallback = () => undefined
 
+// Every agent surface supplies permissions and a validator; tests that do not
+// exercise gating use the widest grant and a validator that classifies as DQL.
+const ALL_GRANTED: Permissions = {
+  grantSchemaAccess: true,
+  read: true,
+  write: true,
+}
+const dqlValidator = () =>
+  Promise.resolve({ query: "", columns: [], timestamp: 0 })
+
 // A default live controller for buffer 1 with an empty notebook, so reads
 // (readBasics / cellValueOf) in gate-rejection and no-op tests have a bound
 // notebook to consult. Tests needing specific cells or a runCell re-mount.
@@ -205,6 +226,27 @@ beforeEach(async () => {
 })
 
 describe("dispatchTool — notebook tools (happy path)", () => {
+  it("get_notebook_state preserves comparison operators in previews", async () => {
+    const value =
+      "SELECT * FROM fx_trades WHERE price < 1 AND quantity > 2 AND symbol <> 'A&B'"
+    live = mountLive(1, [cell("c", value)])
+
+    const res = await dispatchTool(
+      "get_notebook_state",
+      { buffer_id: 1 },
+      makeClient(),
+      noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
+    )
+
+    expect(res.is_error).toBeUndefined()
+    const parsed = JSON.parse(res.content) as {
+      cells: Array<{ preview: string }>
+    }
+    expect(parsed.cells[0].preview).toBe(value)
+  })
+
   it("create_notebook forwards label and returns the new buffer id", async () => {
     const client = makeClient()
     const res = await dispatchTool(
@@ -212,6 +254,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { label: "My notebook" },
       client,
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(client.createNotebook).toHaveBeenCalledWith("My notebook", undefined)
     expect(res.is_error).toBeUndefined()
@@ -233,6 +277,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, sql: "SELECT 1" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     const parsed = JSON.parse(res.content) as { cellId: string }
     expect(typeof parsed.cellId).toBe("string")
@@ -267,6 +313,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "source" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     const { cellId } = JSON.parse(response.content) as { cellId: string }
 
@@ -321,6 +369,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "source" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
 
     // Then neither a cell nor an orphan snapshot is left behind
@@ -329,6 +379,55 @@ describe("dispatchTool — notebook tools (happy path)", () => {
     expect(await loadSnapshotCellIds(1)).toEqual(["source"])
   })
 
+  it("duplicate_cell drops a copied snapshot when refresh changes the live source", async () => {
+    await saveCellSnapshot({
+      bufferId: 1,
+      cellId: "source",
+      results: [
+        {
+          type: "dql",
+          query: "SELECT 1",
+          columns: [],
+          dataset: [[1]],
+          count: 1,
+        },
+      ],
+      savedAt: 100,
+    })
+    const { state } = mountLive(
+      1,
+      [cell("source", "SELECT 1", { lastRunStatus: "success" })],
+      {
+        onFlush: () => {
+          state.parts = {
+            ...state.parts,
+            cells: state.parts.cells.map((current) =>
+              current.id === "source"
+                ? { ...current, lastRunStatus: "error", lastRunError: "new" }
+                : current,
+            ),
+          }
+        },
+      },
+    )
+
+    const response = await dispatchTool(
+      "duplicate_cell",
+      { buffer_id: 1, cell_id: "source" },
+      makeClient(),
+      noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
+    )
+    const { cellId } = JSON.parse(response.content) as { cellId: string }
+
+    expect(cellById(state, cellId)).toMatchObject({
+      lastRunStatus: "error",
+      lastRunError: "new",
+    })
+    expect(await loadCellSnapshot(1, cellId)).toBeUndefined()
+  })
+
   it("add_cell with run:true chains runCell and reports per-query status", async () => {
     const { runCell } = mountLive(1, [], {
       runCell: () =>
@@ -343,12 +442,14 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, sql: "SELECT 1; SELECT bad; SELECT 2", run: true },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(runCell).toHaveBeenCalledWith(
       expect.any(String),
       undefined,
-      undefined,
-      undefined,
+      expect.any(String),
+      { kind: "autoRun" },
     )
     expect(JSON.parse(res.content)).toMatchObject({
       ran: false,
@@ -364,6 +465,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", value: "SELECT 2" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "c")?.value).toBe("SELECT 2")
     expect(cellById(state, "c")?.name).toBe("keep")
@@ -383,6 +486,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     const parsed = JSON.parse(res.content) as Record<string, unknown>
     expect(parsed).toEqual({
@@ -414,6 +519,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     const p1 = JSON.parse(runCellRes.content) as Record<string, unknown>
     expect(p1.unverified).toBe(true)
@@ -424,6 +531,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, sql: "INSERT INTO t VALUES(1)", run: true },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     const p2 = JSON.parse(addRes.content) as Record<string, unknown>
     expect(p2.unverified).toBe(true)
@@ -437,6 +546,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     const p3 = JSON.parse(applyRes.content) as {
       runs: Array<Record<string, unknown>>
@@ -463,6 +574,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "c")?.chartConfig).toMatchObject({
       xColumn: "ts",
@@ -488,6 +601,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
 
     // When the user edits before the transition commits
@@ -507,6 +622,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", value: "5s" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "c")?.autoRefresh).toBe("5s")
   })
@@ -518,6 +635,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", value: true },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "c")?.autoRefresh).toBe(true)
   })
@@ -531,6 +650,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", value: false },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "c")?.autoRefresh).toBe(false)
   })
@@ -542,6 +663,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", value: "2s" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     expect(cellById(state, "c")?.autoRefresh).toBeUndefined()
@@ -558,6 +681,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", value: null },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // Then no key remains — a spread patch would have kept it
     const updated = cellById(state, "c")
@@ -571,6 +696,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, value: "30s" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(state.parts.settings.autoRefreshDefault).toBe("30s")
   })
@@ -582,6 +709,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, value: false },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(state.parts.settings.autoRefreshDefault).toBe(false)
   })
@@ -600,6 +729,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, value: "30s", reset_cell_overrides: true },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // Then the default is stored and no override key survives —
     // every cell now inherits 30s
@@ -621,6 +752,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, value: "30s", reset_cell_overrides: null },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // Then the override stays and still wins over the new default
     expect(state.parts.settings.autoRefreshDefault).toBe("30s")
@@ -634,6 +767,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, value: "2s" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     expect(state.parts.settings.autoRefreshDefault).toBeUndefined()
@@ -662,6 +797,124 @@ describe("dispatchTool — notebook tools (happy path)", () => {
     expect(cellById(state, "c")?.autoRefresh).toBeUndefined()
   })
 
+  it("set_cell_dimensions maps strict null/auto values to semantic pane state", async () => {
+    const { state } = mountLive(1, [
+      cell("c", "SELECT 1", {
+        mode: "draw",
+        topHeight: 200,
+        topResized: true,
+        bottomHeight: 350,
+        paneView: "result",
+      }),
+    ])
+
+    const res = await dispatchTool(
+      "set_cell_dimensions",
+      {
+        buffer_id: 1,
+        cell_id: "c",
+        editor_height: "auto",
+        result_height: 300,
+        view: null,
+      },
+      makeClient(),
+      noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
+    )
+
+    expect(res.is_error).toBeUndefined()
+    expect(JSON.parse(res.content)).toEqual({ view: "result", mode: "draw" })
+    expect(cellById(state, "c")).toMatchObject({
+      topHeight: 72,
+      topResized: false,
+      bottomHeight: 300,
+      bottomResized: true,
+      paneView: "result",
+    })
+  })
+
+  it("set_cell_dimensions reports the cell view", async () => {
+    const { state } = mountLive(1, [cell("c", "SELECT 1", { mode: "draw" })])
+    const res = await dispatchTool(
+      "set_cell_dimensions",
+      {
+        buffer_id: 1,
+        cell_id: "c",
+        editor_height: null,
+        result_height: null,
+        view: "editor_result",
+      },
+      makeClient(),
+      noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
+    )
+
+    expect(JSON.parse(res.content)).toEqual({
+      view: "editor_result",
+      mode: "draw",
+    })
+    expect(cellById(state, "c")?.paneView).toBe("editor_result")
+  })
+
+  it("set_cell_dimensions rejects malformed height strings at runtime", async () => {
+    const { state } = mountLive(1, [cell("c", "SELECT 1")])
+    const res = await dispatchTool(
+      "set_cell_dimensions",
+      {
+        buffer_id: 1,
+        cell_id: "c",
+        editor_height: "bogus",
+        result_height: null,
+        view: null,
+      },
+      makeClient(),
+      noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
+    )
+
+    expect(res.is_error).toBe(true)
+    expect(res.content).toContain(
+      "editor_height must be a number, auto, or null",
+    )
+    expect(cellById(state, "c")?.topHeight).toBeUndefined()
+  })
+
+  it("set_cell_layout returns the stored view with the new position", async () => {
+    const { state } = mountLive(
+      1,
+      [
+        cell("c", "SELECT 1", {
+          mode: "draw",
+          paneView: "editor_result",
+        }),
+      ],
+      {
+        settings: {
+          layoutMode: "grid",
+          layout: [{ i: "c", x: 0, y: 0, w: 6, h: 10 }],
+        },
+      },
+    )
+    const res = await dispatchTool(
+      "set_cell_layout",
+      { buffer_id: 1, cell_id: "c", x: 0, y: 0, w: 4 },
+      makeClient(),
+      noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
+    )
+
+    expect(JSON.parse(res.content)).toEqual({
+      grid: { x: 0, y: 0, w: 4 },
+      view: "editor_result",
+      mode: "draw",
+    })
+    expect(state.parts.settings.layout?.[0].w).toBe(4)
+  })
+
   it("apply_notebook_state never synthesizes auto_refresh for draw cells", async () => {
     // Given a notebook with no auto-refresh default
     const { state } = mountLive(1, [cell("a", "SELECT 1")])
@@ -685,6 +938,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
 
     // Then no cell stores a per-cell value — both inherit
@@ -717,6 +972,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
 
     // Then the default lands and the chart inherits it
@@ -732,6 +989,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", name: "BTC price" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "c")?.name).toBe("BTC price")
   })
@@ -743,6 +1002,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", name: null },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "c")?.name).toBeUndefined()
   })
@@ -754,6 +1015,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", name: "a".repeat(101) },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     expect(cellById(state, "c")?.name).toBe("orig")
@@ -773,6 +1036,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, sql: "INSERT INTO t VALUES(1)" },
       transport,
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect((JSON.parse(t.content) as { unverified?: boolean }).unverified).toBe(
       true,
@@ -791,6 +1056,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, sql: "SELECT * FROM t" },
       serverErr,
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(
       (JSON.parse(s.content) as { unverified?: boolean }).unverified,
@@ -810,6 +1077,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, sql: "INSERT INTO t VALUES(1)" },
       transport,
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // Then the failure envelope is marked unverified
     const transportPayload = JSON.parse(t.content) as {
@@ -832,6 +1101,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, sql: "SELECT * FROM t" },
       serverErr,
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // Then the failure envelope is NOT marked unverified
     const serverPayload = JSON.parse(s.content) as {
@@ -850,6 +1121,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", queries: [{ type: "bar" }] },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "c")?.chartConfig?.queries).toEqual([
       { type: "bar", yColumns: [] },
@@ -873,6 +1146,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "c")?.chartConfig).toMatchObject({
       xColumn: "ts",
@@ -900,6 +1175,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       client,
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     const parsed = JSON.parse(res.content) as { error_code: string }
@@ -933,6 +1210,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "c")?.chartConfig?.queries).toEqual([
       { type: "line", yColumns: [] },
@@ -950,6 +1229,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       client,
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     const parsed = JSON.parse(res.content) as { error_code: string }
@@ -971,6 +1252,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     const parsed = JSON.parse(res.content) as { error_code: string }
@@ -991,6 +1274,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "c")?.chartConfig?.queries).toMatchObject([
       { type: "line", yColumns: ["a"] },
@@ -1005,6 +1290,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", queries: [] },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "c")?.chartConfig?.queries).toEqual([])
   })
@@ -1021,6 +1308,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "c")?.chartConfig?.queries).toMatchObject([
       null,
@@ -1044,7 +1333,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
             value: "SELECT 1",
             mode: "draw",
             auto_refresh: "5s",
-            is_view_maximized: true,
+            view: "result",
             chart_config: {
               x_column: "ts",
               right_axis: null,
@@ -1056,12 +1345,14 @@ describe("dispatchTool — notebook tools (happy path)", () => {
                 },
               ],
             },
-            grid: { x: 0, y: 0, w: 6, h: 6 },
+            grid: { x: 0, y: 0, w: 6 },
           },
         ],
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBeUndefined()
     // The applied cell carries every field in camelCase; c (omitted) is deleted.
@@ -1071,7 +1362,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       value: "SELECT 1",
       mode: "draw",
       autoRefresh: "5s",
-      isViewMaximized: true,
+      paneView: "result",
       chartConfig: {
         xColumn: "ts",
         queries: [
@@ -1099,6 +1390,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(state.parts.settings.autoRefreshDefault).toBe(false)
     // When a later apply passes null
@@ -1111,6 +1404,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // Then the stored default survives
     expect(state.parts.settings.autoRefreshDefault).toBe(false)
@@ -1127,6 +1422,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // Then the tool errors and nothing committed
     expect(res.is_error).toBe(true)
@@ -1150,6 +1447,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // Then the typo errors instead of silently deleting the override
     expect(res.is_error).toBe(true)
@@ -1177,6 +1476,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(a.state.parts.settings.variables).toEqual(variables)
 
@@ -1195,6 +1496,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(b.state.parts.settings.variables).toEqual([
       { name: "keep", value: "1" },
@@ -1215,6 +1518,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(c.state.parts.settings.variables).toEqual([])
   })
@@ -1232,6 +1537,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       client,
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     const parsed = JSON.parse(res.content) as { error_code: string }
@@ -1259,7 +1566,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
         },
         client,
         noopStatus,
-        undefined,
+        ALL_GRANTED,
         validateSql,
       )
       expect(res.is_error).toBe(true)
@@ -1282,7 +1589,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       client,
       noopStatus,
-      undefined,
+      ALL_GRANTED,
       validateSql,
     )
     expect(res.is_error).toBe(true)
@@ -1318,7 +1625,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       client,
       noopStatus,
-      undefined,
+      ALL_GRANTED,
       validateSql,
     )
     expect(validateSql).toHaveBeenNthCalledWith(
@@ -1353,7 +1660,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       client,
       noopStatus,
-      undefined,
+      ALL_GRANTED,
       validateSql,
     )
     expect(res.is_error).toBe(true)
@@ -1373,8 +1680,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cells: [{ value: "SELECT 1" }] },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       toolContext,
     )
@@ -1408,6 +1715,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
           return Promise.reject(error)
         }
       },
+      mutateWithResultStatus: (transition) =>
+        controller.mutate((parts) => transition(parts, () => "unrequested")),
       readView: () =>
         Promise.resolve({
           cells: state.parts.cells,
@@ -1424,8 +1733,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cells: [{ id: "b", value: "SELECT 1" }] },
       makeClient(),
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       abort.signal,
     )
 
@@ -1451,8 +1760,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", value: "SELECT 2" },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       { notebookFreshness: createNotebookFreshness([[1, readSeq]]) },
     )
@@ -1470,8 +1779,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 2, cell_id: "c", value: "SELECT 2" },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       {
         notebookFreshness: createNotebookFreshness([
@@ -1495,8 +1804,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 2, value: "SELECT 1" },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       { notebookFreshness: createNotebookFreshness() },
     )
@@ -1515,8 +1824,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 2, cells: [{ value: "SELECT 1" }] },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       { notebookFreshness: createNotebookFreshness() },
     )
@@ -1538,8 +1847,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", value: "SELECT 2" },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       toolContext,
     )
@@ -1553,8 +1862,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1 },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       toolContext,
     )
@@ -1563,8 +1872,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", value: "SELECT 2" },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       toolContext,
     )
@@ -1584,8 +1893,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { label: "My notebook" },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       toolContext,
     )
@@ -1595,8 +1904,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", value: "SELECT 2" },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       toolContext,
     )
@@ -1615,8 +1924,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1 },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       toolContext,
     )
@@ -1625,8 +1934,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", value: "SELECT 2" },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       toolContext,
     )
@@ -1645,8 +1954,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", value: "SELECT 2" },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       {},
     )
@@ -1665,8 +1974,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { cell_id: "c", value: "SELECT 2" },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       { notebookFreshness: createNotebookFreshness() },
     )
@@ -1687,8 +1996,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cells: [{ value: "SELECT 1" }] },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       { notebookFreshness: createNotebookFreshness([[1, readSeq]]) },
     )
@@ -1708,7 +2017,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: "c", value: "SELECT 2" },
       client,
       noopStatus,
-      undefined,
+      ALL_GRANTED,
       validateSql,
     )
     expect(res.is_error).toBe(true)
@@ -1730,7 +2039,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
             value: "SELECT * FROM trades",
             mode: "draw",
             auto_refresh: null,
-            is_view_maximized: null,
+            view: null,
             chart_config: {
               x_column: "ts",
               name: null,
@@ -1745,6 +2054,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // ohlc is never fabricated from y_columns — the candlestick is rejected
     // outright, and nothing is committed.
@@ -1768,7 +2079,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
             value: "a",
             mode: null,
             auto_refresh: null,
-            is_view_maximized: null,
+            view: null,
             chart_config: null,
             grid: null,
           },
@@ -1776,6 +2087,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     const parsed = JSON.parse(res.content) as Record<string, unknown>
@@ -1790,6 +2103,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       { buffer_id: 1, cell_id: null },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(state.parts.maximizedCellId).toBe(null)
   })
@@ -1808,6 +2123,28 @@ describe("dispatchTool — notebook tools (happy path)", () => {
     expect(res.content).toMatch(/could not resolve SQL/)
   })
 
+  it("set_cell_mode rejects a markdown cell without validating its prose as SQL", async () => {
+    // Given a markdown cell whose source reads like a query
+    const { state } = mountLive(1, [
+      cell("m", "SELECT 1", { type: "markdown" }),
+    ])
+    const validateSql = vi.fn()
+    // When the agent asks for draw mode
+    const res = await dispatchTool(
+      "set_cell_mode",
+      { buffer_id: 1, cell_id: "m", mode: "draw" },
+      makeClient(),
+      noopStatus,
+      { grantSchemaAccess: true, read: true, write: true },
+      validateSql,
+    )
+    // Then the typed validation error comes back and no SQL check ran
+    expect(res.is_error).toBe(true)
+    expect(JSON.parse(res.content)).toMatchObject({ error_code: "validation" })
+    expect(validateSql).not.toHaveBeenCalled()
+    expect(cellById(state, "m")?.mode).toBeUndefined()
+  })
+
   it("denies set_cell_mode draw when cell SQL contains DDL/DML, even with write granted", async () => {
     mountLive(1, [cell("c", "DROP TABLE victim")])
     const res = await dispatchTool(
@@ -1886,7 +2223,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
             value: "DROP TABLE victim",
             mode: "draw",
             auto_refresh: null,
-            is_view_maximized: null,
+            view: null,
             chart_config: { type: "line", x_column: "ts", y_columns: ["x"] },
             grid: null,
           },
@@ -1966,17 +2303,21 @@ describe("dispatchTool — notebook tools (happy path)", () => {
     })
   })
 
-  it("run_cell with no gate leaves execution to re-read the live cell", async () => {
+  it("run_cell pins the SQL it read and gates the launch explicitly", async () => {
     const { runCell } = mountLive(1, [cell("c", "SELECT 1")])
     const res = await dispatchTool(
       "run_cell",
       { buffer_id: 1, cell_id: "c" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBeFalsy()
-    // No gate ran, so no SQL is pinned — the executor re-reads the cell.
-    expect(runCell).toHaveBeenCalledWith("c", undefined, undefined, undefined)
+    expect(runCell).toHaveBeenCalledWith("c", undefined, "SELECT 1", {
+      kind: "explicit",
+      permissions: ALL_GRANTED,
+    })
   })
 
   it("allows add_cell with run=true and SELECT when read and write are both denied", async () => {
@@ -2039,7 +2380,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
   // openaiProvider, openaiChatCompletionsProvider, dispatchMCPTool). This pins
   // both halves so a caller that drops the gate args — or a refactor of that
   // condition — fails loudly here instead of silently auto-running a write.
-  it("auto-run write protection depends entirely on the gate args", async () => {
+  it("add_cell run:true always passes the autoRun gate, so a write is skipped", async () => {
     const validate = vi.fn().mockResolvedValue({ queryType: "INSERT" })
     const gate = mountLive(1, [], { runCell: okRun, validate })
     const gated = await dispatchTool(
@@ -2060,21 +2401,6 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       ran: false,
       skipped: true,
     })
-
-    const ungate = mountLive(1, [], { runCell: okRun })
-    const ungated = await dispatchTool(
-      "add_cell",
-      { buffer_id: 1, sql: "INSERT INTO t VALUES (1)", run: true },
-      makeClient(),
-      noopStatus,
-    )
-    expect(ungate.runCell).toHaveBeenCalledWith(
-      expect.any(String),
-      undefined,
-      undefined,
-      undefined,
-    )
-    expect(JSON.parse(ungated.content)).toMatchObject({ ran: true })
   })
 })
 
@@ -2097,13 +2423,15 @@ describe("dispatchTool — apply_notebook_state auto-run", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBeFalsy()
     expect(runCell).toHaveBeenCalledWith(
       expect.any(String),
       undefined,
-      undefined,
-      undefined,
+      expect.any(String),
+      { kind: "autoRun" },
     )
     const parsed = JSON.parse(res.content) as {
       runs: Array<{ success: boolean; queryCount?: number; results?: string[] }>
@@ -2128,13 +2456,118 @@ describe("dispatchTool — apply_notebook_state auto-run", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(runCell).toHaveBeenCalledWith(
       expect.any(String),
       undefined,
-      undefined,
-      undefined,
+      expect.any(String),
+      { kind: "autoRun" },
+    )
+  })
+
+  it.each(["run", "draw"] as const)(
+    "rejects mode='%s' with authoritative view='editor' before mutating",
+    async (mode) => {
+      const originalResult = {
+        results: [] as SingleQueryResult[],
+        activeResultIndex: 0,
+        timestamp: 1,
+      }
+      const { state, runCell } = mountLive(1, [
+        cell("cell-1", "SELECT 1", {
+          result: originalResult,
+          lastRunStatus: "success",
+          paneView: "result",
+        }),
+      ])
+
+      const res = await dispatchTool(
+        "apply_notebook_state",
+        {
+          buffer_id: 1,
+          layout_mode: null,
+          maximized_cell_id: null,
+          cells: [
+            {
+              id: "cell-1",
+              preserve_value: true,
+              mode,
+              view: "editor",
+            },
+          ],
+        },
+        makeClient(),
+        noopStatus,
+        ALL_GRANTED,
+        dqlValidator,
+      )
+
+      expect(res.is_error).toBe(true)
+      expect(JSON.parse(res.content)).toMatchObject({
+        error_code: "validation",
+      })
+      expect(res.content).toMatch(/view.*editor.*explicit mode/)
+      expect(cellById(state, "cell-1")).toMatchObject({
+        result: originalResult,
+        lastRunStatus: "success",
+        paneView: "result",
+      })
+      expect(runCell).not.toHaveBeenCalled()
+    },
+  )
+
+  it("lets authoritative view='editor' clear a preserved draw mode without chart config", async () => {
+    const { state, runCell } = mountLive(
+      1,
+      [
+        cell("cell-1", "SELECT 1", {
+          mode: "draw",
+          result: {
+            results: [],
+            activeResultIndex: 0,
+            timestamp: 1,
+          },
+          lastRunStatus: "success",
+          paneView: "result",
+          chartConfig: {
+            xColumn: "ts",
+            queries: [{ type: "line", yColumns: ["value"] }],
+          },
+        }),
+      ],
+      { runCell: okRun },
+    )
+
+    const res = await dispatchTool(
+      "apply_notebook_state",
+      {
+        buffer_id: 1,
+        layout_mode: null,
+        maximized_cell_id: null,
+        cells: [
+          {
+            id: "cell-1",
+            preserve_value: true,
+            mode: null,
+            view: "editor",
+          },
+        ],
+      },
+      makeClient(),
+      noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
+
+    expect(res.is_error).toBeFalsy()
+    expect(JSON.parse(res.content)).toMatchObject({ runs: [] })
+    expect(cellById(state, "cell-1")?.mode).toBeUndefined()
+    expect(cellById(state, "cell-1")?.result).toBeUndefined()
+    expect(cellById(state, "cell-1")?.lastRunStatus).toBeUndefined()
+    expect(cellById(state, "cell-1")?.chartConfig).toBeUndefined()
+    expect(runCell).not.toHaveBeenCalled()
   })
 
   it("skips cells whose resolved mode is 'draw'", async () => {
@@ -2156,6 +2589,8 @@ describe("dispatchTool — apply_notebook_state auto-run", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(runCell).not.toHaveBeenCalled()
   })
@@ -2195,7 +2630,7 @@ describe("dispatchTool — apply_notebook_state auto-run", () => {
       },
       makeClient(),
       noopStatus,
-      undefined,
+      ALL_GRANTED,
       dqlValidate,
     )
     // Then the chart remains in draw mode and is never re-run as SQL
@@ -2219,7 +2654,7 @@ describe("dispatchTool — apply_notebook_state auto-run", () => {
       },
       makeClient(),
       noopStatus,
-      undefined,
+      ALL_GRANTED,
       validateSql,
     )
     // Then the draw invariant denies the whole apply before anything commits
@@ -2238,6 +2673,8 @@ describe("dispatchTool — apply_notebook_state auto-run", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(runCell).not.toHaveBeenCalled()
   })
@@ -2282,7 +2719,7 @@ describe("dispatchTool — apply_notebook_state auto-run", () => {
     const validate = vi.fn().mockResolvedValue({ queryType: "INSERT" })
     const { runCell } = mountLive(
       1,
-      [cell("ins-1", "INSERT INTO t VALUES (1)", { mode: "run" })],
+      [cell("ins-1", "INSERT INTO t VALUES (1)")],
       { runCell: okRun, validate },
     )
     const res = await dispatchTool(
@@ -2326,7 +2763,7 @@ describe("dispatchTool — apply_notebook_state auto-run", () => {
     const validate = vi.fn().mockResolvedValue({ queryType: "INSERT" })
     const { runCell } = mountLive(
       1,
-      [cell("ins-1", "INSERT INTO t VALUES (1)", { mode: "run" })],
+      [cell("ins-1", "INSERT INTO t VALUES (1)")],
       { runCell: okRun, validate },
     )
     const res = await dispatchTool(
@@ -2363,11 +2800,9 @@ describe("dispatchTool — apply_notebook_state auto-run", () => {
   })
 
   it("re-runs DQL cells that ran before (only writes are history-gated)", async () => {
-    const { runCell } = mountLive(
-      1,
-      [cell("sel-1", "SELECT 1", { mode: "run" })],
-      { runCell: okRun },
-    )
+    const { runCell } = mountLive(1, [cell("sel-1", "SELECT 1")], {
+      runCell: okRun,
+    })
     await dispatchTool(
       "apply_notebook_state",
       {
@@ -2386,13 +2821,10 @@ describe("dispatchTool — apply_notebook_state auto-run", () => {
     })
   })
 
-  it("preserves existing mode when mode is omitted on an existing cell (draw stays draw, run stays run)", async () => {
+  it("preserves existing mode when omitted (draw stays draw, run stays implicit)", async () => {
     const { state, runCell } = mountLive(
       1,
-      [
-        cell("run-id", "old", { mode: "run" }),
-        cell("draw-id", "old", { mode: "draw" }),
-      ],
+      [cell("run-id", "old"), cell("draw-id", "old", { mode: "draw" })],
       { runCell: okRun },
     )
     const res = await dispatchTool(
@@ -2423,7 +2855,7 @@ describe("dispatchTool — apply_notebook_state auto-run", () => {
     expect(runCell).toHaveBeenCalledWith("run-id", undefined, "SELECT 1", {
       kind: "autoRun",
     })
-    expect(cellById(state, "run-id")?.mode).toBe("run")
+    expect(cellById(state, "run-id")?.mode).toBeUndefined()
     expect(cellById(state, "draw-id")?.mode).toBe("draw")
   })
 
@@ -2452,6 +2884,8 @@ describe("dispatchTool — apply_notebook_state auto-run", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // Flush microtasks so dispatchTool resumes past the apply and fires every
     // runCell concurrently.
@@ -2491,6 +2925,8 @@ describe("dispatchTool — apply_notebook_state auto-run", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     const parsed = JSON.parse(res.content) as {
       runs: Array<{ success: boolean; queryCount?: number; results?: string[] }>
@@ -2517,6 +2953,8 @@ describe("dispatchTool — NotebookToolError envelope", () => {
       { buffer_id: 1, cell_id: "c" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     const parsed = JSON.parse(res.content) as Record<string, unknown>
@@ -2533,6 +2971,8 @@ describe("dispatchTool — NotebookToolError envelope", () => {
       { buffer_id: 1, cell_id: "c" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     expect(
@@ -2548,6 +2988,8 @@ describe("dispatchTool — NotebookToolError envelope", () => {
       { buffer_id: 1, cell_id: "abc123" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     const parsed = JSON.parse(res.content) as Record<string, unknown>
@@ -2566,6 +3008,8 @@ describe("dispatchTool — non-NotebookToolError falls through to default handle
       { buffer_id: 1, cell_id: "c" },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     expect(res.content).toMatch(/network boom/)
@@ -2595,8 +3039,8 @@ describe("dispatchTool — run_query replay guard (sqlWriteExecuted)", () => {
       { sql },
       client,
       noopStatus,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       undefined,
       toolContext,
     )
@@ -2644,6 +3088,8 @@ describe("dispatchMCPTool — data-leak invariant", () => {
       generation: () => 0,
       reset: () => undefined,
     },
+    permissions: { get: () => ALL_GRANTED, consumeDirty: () => false },
+    validateSql: dqlValidator,
     metaToolContext: {
       getActiveBufferId: () => 1,
       getWorkspace: () => null,
@@ -2700,6 +3146,8 @@ describe("dispatchTool — get_cell content cap switch", () => {
       { buffer_id: 1, cell_id: "c", get_full_content: true },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     const parsed = JSON.parse(res.content) as {
       value: string
@@ -2720,6 +3168,8 @@ describe("dispatchTool — get_cell content cap switch", () => {
         input,
         makeClient(),
         noopStatus,
+        ALL_GRANTED,
+        dqlValidator,
       )
       const parsed = JSON.parse(res.content) as {
         value: string
@@ -2731,6 +3181,123 @@ describe("dispatchTool — get_cell content cap switch", () => {
       expect(parsed.full_length).toBe(5000)
     }
   })
+
+  it("reports passive result view only while its snapshot key exists", async () => {
+    unregisterController(1)
+    await db.buffers.update(1, {
+      notebookViewState: {
+        cells: [
+          cell("c", "SELECT 1", {
+            lastRunStatus: "success",
+            paneView: "result",
+          }),
+        ],
+      },
+    })
+
+    const readView = async () => {
+      const response = await dispatchTool(
+        "get_cell",
+        { buffer_id: 1, cell_id: "c" },
+        makeClient(),
+        noopStatus,
+        ALL_GRANTED,
+        dqlValidator,
+      )
+      return (JSON.parse(response.content) as { view: string }).view
+    }
+
+    expect(await readView()).toBe("editor")
+    await saveCellSnapshot({
+      bufferId: 1,
+      cellId: "c",
+      results: [],
+      savedAt: 1,
+    })
+    expect(await readView()).toBe("result")
+  })
+
+  it("uses missing snapshot status for passive layout and dimension mutations", async () => {
+    unregisterController(1)
+    const persistedCell = cell("c", "SELECT 1", {
+      lastRunStatus: "success",
+      paneView: "result",
+    })
+    await db.buffers.update(1, {
+      notebookViewState: {
+        cells: [persistedCell],
+        settings: {
+          layoutMode: "grid",
+          layout: [{ i: "c", x: 0, y: 0, w: 6, h: 99 }],
+        },
+      },
+    })
+
+    const layout = await dispatchTool(
+      "set_cell_layout",
+      { buffer_id: 1, cell_id: "c", x: 0, y: 0, w: 4 },
+      makeClient(),
+      noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
+    )
+    expect(JSON.parse(layout.content)).toEqual({
+      grid: { x: 0, y: 0, w: 4 },
+      view: "editor",
+      mode: null,
+    })
+    expect(
+      (await db.buffers.get(1))?.notebookViewState?.settings?.layout?.[0],
+    ).toEqual({
+      i: "c",
+      x: 0,
+      y: 0,
+      w: 4,
+      h: computeAgentCellGridH(persistedCell, false),
+    })
+
+    const dimensions = await dispatchTool(
+      "set_cell_dimensions",
+      {
+        buffer_id: 1,
+        cell_id: "c",
+        editor_height: null,
+        result_height: null,
+        view: null,
+      },
+      makeClient(),
+      noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
+    )
+    expect(JSON.parse(dimensions.content)).toEqual({
+      view: "editor",
+      mode: null,
+    })
+  })
+})
+
+describe("dispatchTool — apply_notebook_state dimensions", () => {
+  it("rejects a malformed editor_height string at runtime", async () => {
+    const { state } = mountLive(1, [cell("a", "SELECT 1")])
+    const res = await dispatchTool(
+      "apply_notebook_state",
+      {
+        buffer_id: 1,
+        layout_mode: null,
+        maximized_cell_id: null,
+        cells: [{ id: "a", value: "SELECT 1", editor_height: "bogus" }],
+      },
+      makeClient(),
+      noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
+    )
+
+    expect(res.is_error).toBe(true)
+    expect(res.content).toContain("has an invalid editor_height")
+    expect(cellById(state, "a")?.topHeight).toBeUndefined()
+  })
 })
 
 describe("dispatchTool — apply_notebook_state preserve_value", () => {
@@ -2746,6 +3313,8 @@ describe("dispatchTool — apply_notebook_state preserve_value", () => {
       },
       client,
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     expect(res.content).toMatch(/exactly one/)
@@ -2763,6 +3332,8 @@ describe("dispatchTool — apply_notebook_state preserve_value", () => {
       },
       client,
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     expect(res.content).toMatch(/has no value/)
@@ -2780,6 +3351,8 @@ describe("dispatchTool — apply_notebook_state preserve_value", () => {
       },
       client,
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(res.is_error).toBe(true)
     expect(res.content).toMatch(/without an existing cell id/)
@@ -2797,6 +3370,8 @@ describe("dispatchTool — apply_notebook_state preserve_value", () => {
       },
       makeClient(),
       noopStatus,
+      ALL_GRANTED,
+      dqlValidator,
     )
     expect(cellById(state, "a")?.value).toBe("keepme")
   })
@@ -2805,7 +3380,7 @@ describe("dispatchTool — apply_notebook_state preserve_value", () => {
     const validate = vi.fn().mockResolvedValue({ queryType: "INSERT" })
     const { runCell } = mountLive(
       1,
-      [cell("ins-1", "INSERT INTO t VALUES (1)", { mode: "run" })],
+      [cell("ins-1", "INSERT INTO t VALUES (1)")],
       { runCell: okRun, validate },
     )
     const res = await dispatchTool(
@@ -2835,13 +3410,9 @@ describe("dispatchTool — apply_notebook_state preserve_value", () => {
   })
 
   it("auto-run executes a preserved DQL cell with its live SQL", async () => {
-    const { runCell } = mountLive(
-      1,
-      [cell("sel-1", "SELECT 1", { mode: "run" })],
-      {
-        runCell: okRun,
-      },
-    )
+    const { runCell } = mountLive(1, [cell("sel-1", "SELECT 1")], {
+      runCell: okRun,
+    })
     await dispatchTool(
       "apply_notebook_state",
       {
diff --git a/src/utils/ai/types.ts b/src/utils/ai/types.ts
index e0950b921..8659579d8 100644
--- a/src/utils/ai/types.ts
+++ b/src/utils/ai/types.ts
@@ -70,8 +70,8 @@ export type ExecuteFlowParams = {
   setStatus: StatusCallback
   abortSignal?: AbortSignal
   streaming?: StreamingCallback
-  perms?: Permissions | (() => Permissions)
-  validateSql?: (sql: string) => Promise<ValidateQueryResult>
+  perms: Permissions | (() => Permissions)
+  validateSql: (sql: string) => Promise<ValidateQueryResult>
   toolContext?: ToolExecutionContext
 }
 
diff --git a/src/utils/mcp/dispatchMCPTool.test.ts b/src/utils/mcp/dispatchMCPTool.test.ts
index 0523071c5..4a9dae42a 100644
--- a/src/utils/mcp/dispatchMCPTool.test.ts
+++ b/src/utils/mcp/dispatchMCPTool.test.ts
@@ -1,4 +1,5 @@
 import "../../test/stubBrowserGlobals"
+import type { Permissions } from "../tools/permissions"
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"
 
 import { dispatchMCPTool, type DispatchContext } from "./dispatchMCPTool"
@@ -95,6 +96,12 @@ import { dispatchTool as mockedDispatchTool } from "../tools/dispatch"
 
 type Freshness = "unfetched" | "fresh" | "stale"
 
+const ALL_GRANTED: Permissions = {
+  grantSchemaAccess: true,
+  read: true,
+  write: true,
+}
+
 // Sets up the gate for buffer 1: "unfetched" records nothing; "fresh" records a
 // read at the current seq; "stale" records a read and then bumps buffer 1's seq
 // via a user edit so the recorded read no longer matches.
@@ -113,6 +120,9 @@ const ctx = (
     modelToolsClient: {} as unknown as ModelToolsClient,
     freshness: gate,
     metaToolContext: meta,
+    permissions: { get: () => ALL_GRANTED, consumeDirty: () => false },
+    validateSql: () =>
+      Promise.resolve({ query: "", columns: [], timestamp: 0 }),
   }
 }
 
@@ -173,11 +183,11 @@ describe("dispatchMCPTool — state-freshness gate", () => {
     "run_cell",
     "set_layout_mode",
     "set_cell_layout",
+    "set_cell_dimensions",
     "set_cell_mode",
     "set_cell_chart_config",
     "set_notebook_autorefresh",
     "set_cell_autorefresh",
-    "set_cell_view_maximized",
     "set_cell_maximized",
   ]
 
diff --git a/src/utils/mcp/dispatchMCPTool.ts b/src/utils/mcp/dispatchMCPTool.ts
index db9def1f1..988f045fd 100644
--- a/src/utils/mcp/dispatchMCPTool.ts
+++ b/src/utils/mcp/dispatchMCPTool.ts
@@ -13,7 +13,7 @@ import {
   resolveGetWorkspaceState,
   type MetaToolContext,
 } from "./metaResolvers"
-import { DEFAULT_GRANTED, type Permissions } from "../tools/permissions"
+import type { Permissions } from "../tools/permissions"
 import type { ToolCallMessage, ToolContent, ToolResultPayload } from "./types"
 import type { ValidateQueryResult } from "../questdb/types"
 import {
@@ -38,8 +38,8 @@ export type DispatchContext = {
   modelToolsClient: ModelToolsClient
   freshness: NotebookFreshness
   metaToolContext: MetaToolContext
-  permissions?: PermissionsRefs
-  validateSql?: (sql: string) => Promise<ValidateQueryResult>
+  permissions: PermissionsRefs
+  validateSql: (sql: string) => Promise<ValidateQueryResult>
   signal?: AbortSignal
 }
 
@@ -153,9 +153,9 @@ export const dispatchMCPTool = async (
   const result = await dispatchInner(call, ctx)
   // Suppress dirty-notice on a denial — the deny reason already names
   // the missing permission.
-  const dirty = ctx.permissions?.consumeDirty() ?? false
+  const dirty = ctx.permissions.consumeDirty()
   const withPermsNotice =
-    dirty && ctx.permissions && !result.isError
+    dirty && !result.isError
       ? prependPermissionsNotice(
           result,
           buildPermissionsUpdatedBlock(ctx.permissions.get()),
@@ -213,9 +213,7 @@ const dispatchInner = async (
     }
   }
 
-  const perms = ctx.permissions
-    ? (ctx.permissions.get() ?? DEFAULT_GRANTED)
-    : undefined
+  const perms = ctx.permissions.get()
   const fullReadTarget =
     call.name === "get_notebook_state" ? bufferIdOf(call.arguments) : null
   const seqBeforeFullRead =
diff --git a/src/utils/notebooks/notebookAIBridge.test.ts b/src/utils/notebooks/notebookAIBridge.test.ts
index e68b457f1..3f3d0fe08 100644
--- a/src/utils/notebooks/notebookAIBridge.test.ts
+++ b/src/utils/notebooks/notebookAIBridge.test.ts
@@ -29,6 +29,7 @@ import {
 } from "./notebookController"
 import {
   summarizeCellResults,
+  CELL_DELETED_MID_RUN_NOTE,
   SUPERSEDED_RUN_NOTE,
 } from "../../scenes/Editor/Notebook/notebookUtils"
 import { __resetNotebookBufferQueuesForTests } from "./notebookBufferQueue"
@@ -66,6 +67,18 @@ const makeController = (
         focusedCellId: null,
       }).result,
     ),
+  mutateWithResultStatus: (transition) =>
+    Promise.resolve(
+      transition(
+        {
+          cells: [],
+          settings: {},
+          maximizedCellId: null,
+          focusedCellId: null,
+        },
+        () => "unrequested",
+      ).result,
+    ),
   readView: () => Promise.resolve(emptyState),
   runCell: () =>
     Promise.resolve({ success: true, queryCount: 1, results: ["success"] }),
@@ -469,12 +482,12 @@ describe("createNotebookController — applyNotebookState maximized cell id", ()
       updateSettings: () => undefined,
       setCellMode: () => undefined,
       setCellChartConfig: () => undefined,
-      setCellViewMaximized: () => undefined,
+      setCellPaneView: () => undefined,
       setMaximizedCellId: vi.fn(),
       updateCells: () => undefined,
       applyTransition: <T>(
         run: (parts: ViewParts) => NotebookTransitionResult<T>,
-      ): T => {
+      ): Promise<T> => {
         const out = run({
           cells: prevCells,
           settings: {},
@@ -482,17 +495,32 @@ describe("createNotebookController — applyNotebookState maximized cell id", ()
           focusedCellId: null,
         })
         applied.parts = out.parts
-        return out.result
+        return Promise.resolve(out.result)
       },
       getCellsSnapshot: () => prevCells,
       getSettings: () => ({}),
       getMaximizedCellId: () => currentMaximizedId,
       flushChartSnapshots: () => Promise.resolve(),
       readRefreshState: () => new Map(),
+      readResultStatus: () => "unrequested" as const,
     }
     return { live, applied }
   }
 
+  it("reads a cell's snapshot-load status through the live actions", () => {
+    // Given a live controller whose provider reports per-cell statuses
+    const { live } = makeLiveActions([cellA])
+    const controller = createNotebookController(1, {
+      current: {
+        ...live,
+        readResultStatus: (id) => (id === "a" ? "loaded" : "unrequested"),
+      },
+    })
+    // Then the controller delegates mount-independently
+    expect(controller.readResultStatus?.("a")).toBe("loaded")
+    expect(controller.readResultStatus?.("zzz")).toBe("unrequested")
+  })
+
   it("clears a provided maximized id that does not survive the apply", async () => {
     const { live, applied } = makeLiveActions([cellA, cellB])
     const controller = createNotebookController(1, { current: live })
@@ -542,17 +570,20 @@ describe("createNotebookController — live runCell supersession", () => {
   ): NotebookControllerActions => ({
     runCell,
     applyTransition: (run) =>
-      run({
-        cells: snapshot(),
-        settings: {},
-        maximizedCellId: null,
-        focusedCellId: null,
-      }).result,
+      Promise.resolve(
+        run({
+          cells: snapshot(),
+          settings: {},
+          maximizedCellId: null,
+          focusedCellId: null,
+        }).result,
+      ),
     getCellsSnapshot: snapshot,
     getSettings: () => ({}),
     getMaximizedCellId: () => null,
     flushChartSnapshots: () => Promise.resolve(),
     readRefreshState: () => new Map(),
+    readResultStatus: () => "unrequested" as const,
   })
 
   const cellWith = (result: CellResult): NotebookCell => ({
@@ -596,6 +627,31 @@ describe("createNotebookController — live runCell supersession", () => {
     expect(summary.results).toEqual([])
   })
 
+  it("reports a live run whose cell was deleted mid-flight as deleted, not cleared", async () => {
+    // Given the agent's run launched, then the user deleted the cell while it
+    // ran: the mounted runner supersedes the run and carries the reason.
+    let cells = [cellWith(dmlResult(1))]
+    const snapshot = () => cells
+    const runCell = () => {
+      cells = []
+      return Promise.resolve({
+        ok: false,
+        superseded: true,
+        cancelled: "cell_deleted" as const,
+      })
+    }
+    const controller = createNotebookController(1, {
+      current: liveActions(snapshot, runCell),
+    })
+    const summary = await controller.runCell(cellId)
+
+    // Then the agent learns the cell is gone, with nothing to trust as a result
+    expect(summary.cancelled).toBe("cell_deleted")
+    expect(summary.note).toBe(CELL_DELETED_MID_RUN_NOTE)
+    expect(summary.unverified).toBe(true)
+    expect(summary.results).toEqual([])
+  })
+
   it("summarizes the outcome's result even when cell.result has diverged", async () => {
     // Given a run whose recorded result is immediately replaced in the cell by
     // an independent write (as a draw auto-refresh frame would), while the
diff --git a/src/utils/notebooks/notebookBackgroundEdits.test.ts b/src/utils/notebooks/notebookBackgroundEdits.test.ts
index 8bc415a79..05c19a9cf 100644
--- a/src/utils/notebooks/notebookBackgroundEdits.test.ts
+++ b/src/utils/notebooks/notebookBackgroundEdits.test.ts
@@ -1,4 +1,5 @@
 import { describe, it, expect, beforeEach, vi } from "vitest"
+import type { Permissions } from "../tools/permissions"
 import {
   __resetNotebookAIBridgeForTests,
   registerWorkspace,
@@ -10,6 +11,16 @@ import type { Client } from "../questdb/client"
 
 const noop = () => undefined
 
+// Every agent surface supplies permissions and a validator; tests that do not
+// exercise gating use the widest grant and a validator that classifies as DQL.
+const ALL_GRANTED: Permissions = {
+  grantSchemaAccess: true,
+  read: true,
+  write: true,
+}
+const dqlValidator = () =>
+  Promise.resolve({ query: "", columns: [], timestamp: 0 })
+
 const makeWorkspace = (
   overrides: Partial<NotebookWorkspaceController> = {},
 ): NotebookWorkspaceController => ({
@@ -122,6 +133,8 @@ describe("dispatch — create/duplicate/activate", () => {
       { label: "n" },
       client,
       noop,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // The exact wording is pinned once in shared.notebookTools.test.ts.
     const parsed = JSON.parse(res.content) as { hint?: string }
@@ -135,6 +148,8 @@ describe("dispatch — create/duplicate/activate", () => {
       { buffer_id: 1 },
       client,
       noop,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // The exact wording is pinned once in shared.notebookTools.test.ts.
     const parsed = JSON.parse(res.content) as { hint?: string }
@@ -155,8 +170,8 @@ describe("dispatch — create/duplicate/activate", () => {
       { label: "n" },
       client,
       noop,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       signal,
     )
 
@@ -178,8 +193,8 @@ describe("dispatch — create/duplicate/activate", () => {
       { buffer_id: 1 },
       client,
       noop,
-      undefined,
-      undefined,
+      ALL_GRANTED,
+      dqlValidator,
       signal,
     )
 
@@ -197,6 +212,8 @@ describe("dispatch — create/duplicate/activate", () => {
       { buffer_id: 9, cell_to_focus: "c2" },
       client,
       noop,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // Then it activated that buffer, passing the cell to focus through
     expect(activateNotebook).toHaveBeenCalledWith(9, "c2")
@@ -214,6 +231,8 @@ describe("dispatch — create/duplicate/activate", () => {
       { buffer_id: 9, cell_to_focus: null },
       client,
       noop,
+      ALL_GRANTED,
+      dqlValidator,
     )
     // Then it is an error naming the failure
     expect(res.is_error).toBe(true)
diff --git a/src/utils/notebooks/notebookController/index.ts b/src/utils/notebooks/notebookController/index.ts
index c902fa433..989d97491 100644
--- a/src/utils/notebooks/notebookController/index.ts
+++ b/src/utils/notebooks/notebookController/index.ts
@@ -122,10 +122,11 @@ export {
   moveCellDownTransition,
   moveCellUpTransition,
   setCellChartConfigTransition,
+  setCellDimensionsTransition,
   setCellLayoutTransition,
   setCellMaximizedTransition,
   setCellModeTransition,
-  setCellViewMaximizedTransition,
+  setCellPaneViewTransition,
   setLayoutModeTransition,
   setNotebookAutoRefreshTransition,
   updateCellTransition,
diff --git a/src/utils/notebooks/notebookController/notebookController.ts b/src/utils/notebooks/notebookController/notebookController.ts
index 8bcae8f1a..6a9af18e6 100644
--- a/src/utils/notebooks/notebookController/notebookController.ts
+++ b/src/utils/notebooks/notebookController/notebookController.ts
@@ -1,4 +1,5 @@
 import type {
+  AgentCellView,
   AutoRefresh,
   CellType,
   NotebookCell,
@@ -7,17 +8,30 @@ import type {
   NotebookViewState,
 } from "../../../store/notebook"
 import type { ChartConfig } from "../../../scenes/Editor/Notebook/CellChart/chartTypes"
+import type {
+  AgentHeightValue,
+  CellResultStatusReader,
+  CellResultStatus,
+} from "../../../scenes/Editor/Notebook/notebookUtils"
 import {
   type CellRunOutcome,
+  cancelledBeforeLaunchSummary,
+  midRunCancellationNote,
+  type RunCancellation,
   CELL_CHANGED_BEFORE_RUN_NOTE,
   CELL_CHANGED_MID_RUN_NOTE,
   RESULT_CLEARED_MID_RUN_NOTE,
+  snapshotResultsHaveMatchingStatement,
   summarizeCellResults,
-  SUPERSEDED_RUN_NOTE,
 } from "../../../scenes/Editor/Notebook/notebookUtils"
 import { removeNotebookCellLayouts } from "../../../scenes/Editor/Notebook/notebookColumnLayoutStore"
 import { clearChartZoom } from "../../../scenes/Editor/Notebook/cellVirtualization/chartZoomStore"
-import { deleteCellSnapshot } from "../../../store/notebookResults"
+import {
+  deleteCellSnapshot,
+  loadCellSnapshot,
+} from "../../../store/notebookResults"
+import { getQueriesFromText } from "../../../scenes/Editor/Monaco/utils"
+import { loadPassiveResultStatusReader } from "../notebookResultStatus"
 import { NotebookToolError } from "../notebookToolError"
 import { enqueueBufferTask } from "../notebookBufferQueue"
 import { emitAgentEdit } from "../agentActivity"
@@ -31,6 +45,7 @@ import {
 } from "../notebookDexieView"
 import {
   __resetNotebookHeadlessRunsForTests,
+  cancelHeadlessCellRuns,
   runHeadlessCell,
   type DexieControllerDeps,
 } from "../notebookHeadlessRun"
@@ -49,6 +64,8 @@ export type RunCellSummary = {
   results: string[]
   unverified?: boolean
   note?: string
+  // Why a cancelled run stopped; with queryCount 0 nothing was executed.
+  cancelled?: RunCancellation
   // Barrier decisions for gated (agent) runs: a permission denial or an
   // auto-run write skip. Nothing executed when either is set.
   denied?: string
@@ -62,6 +79,16 @@ export type NotebookMutate = <T>(
   transition: (parts: ViewParts) => NotebookTransitionResult<T>,
 ) => Promise<T>
 
+// For the transitions that size a result pane: they also receive the cell
+// result status, which the passive route reads from the snapshot index. Only
+// this entry pays for that read.
+export type NotebookMutateWithResultStatus = <T>(
+  transition: (
+    parts: ViewParts,
+    resultStatusOf: CellResultStatusReader,
+  ) => NotebookTransitionResult<T>,
+) => Promise<T>
+
 // Live-only refresh state, read straight off the refresh engine. Absent for
 // unmounted notebooks — the tool docs say so, so an agent never reads absence
 // as "not refreshing" or "not blocked".
@@ -77,8 +104,14 @@ export type NotebookController = {
   // controller as Dexie across a remount race.
   kind: "live" | "dexie"
   mutate: NotebookMutate
+  mutateWithResultStatus: NotebookMutateWithResultStatus
   readView: () => Promise<NotebookViewState>
   readRefreshState?: () => ReadonlyMap<string, CellRefreshView>
+  // Live-only, like readRefreshState: the snapshot-load status of one cell,
+  // read off the provider's hydration engine (mount-independent). Passive
+  // transitions receive their IndexedDB-backed reader through
+  // `mutateWithResultStatus`.
+  readResultStatus?: (cellId: string) => CellResultStatus
   runCell: (
     cellId: string,
     signal?: AbortSignal,
@@ -90,9 +123,11 @@ export type NotebookController = {
 
 // The subset of the live provider's actions the live controller composes over.
 // `applyTransition` runs a transition against React state (cancelling any run of
-// a deleted cell via its cleanup list); the reads are synchronous ref snapshots.
+// a deleted cell via its cleanup list) and settles once the document is
+// durable; the reads are synchronous ref snapshots.
 export type NotebookControllerActions = {
   readRefreshState: () => ReadonlyMap<string, CellRefreshView>
+  readResultStatus: (cellId: string) => CellResultStatus
   runCell: (
     cellId: string,
     sql?: string,
@@ -102,7 +137,7 @@ export type NotebookControllerActions = {
   ) => Promise<CellRunOutcome>
   applyTransition: <T>(
     run: (parts: ViewParts) => NotebookTransitionResult<T>,
-  ) => T
+  ) => Promise<T>
   getCellsSnapshot: () => NotebookCell[]
   getSettings: () => NotebookSettings
   getMaximizedCellId: () => string | null
@@ -120,9 +155,11 @@ export type ApplyNotebookStateCellRequest = {
   type?: CellType | null
   mode?: "run" | "draw" | null
   autoRefresh?: AutoRefresh | null
-  isViewMaximized?: boolean | null
+  editorHeight?: AgentHeightValue
+  resultHeight?: AgentHeightValue
+  view?: AgentCellView | null
   chartConfig?: ChartConfig | null
-  grid?: { x: number; y: number; w: number; h: number } | null
+  grid?: { x: number; y: number; w: number } | null
 }
 
 export type ApplyNotebookStateRequest = {
@@ -138,20 +175,29 @@ export const createNotebookController = (
   liveActionsRef: { current: NotebookControllerActions },
 ): NotebookController => {
   // The live surface's transition runner: apply the transition to React state
-  // (synchronously, via the provider's applyTransition), then normalize to a
-  // Promise so a transition's typed throw reaches the agent as a rejection.
-  const mutate: NotebookMutate = (transition) => {
+  // via the provider's applyTransition, which settles once the document is
+  // durable; the try normalizes a transition's synchronous typed throw into
+  // the same rejection channel.
+  const applyMutation = <T>(
+    run: (parts: ViewParts) => NotebookTransitionResult<T>,
+  ): Promise<T> => {
     try {
-      return Promise.resolve(liveActionsRef.current.applyTransition(transition))
+      return Promise.resolve(liveActionsRef.current.applyTransition(run))
     } catch (error) {
       return Promise.reject(error)
     }
   }
+  const mutate: NotebookMutate = (transition) => applyMutation(transition)
+  const mutateWithResultStatus: NotebookMutateWithResultStatus = (transition) =>
+    applyMutation((parts) =>
+      transition(parts, liveActionsRef.current.readResultStatus),
+    )
 
   return {
     bufferId,
     kind: "live",
     mutate,
+    mutateWithResultStatus,
     readView: () =>
       Promise.resolve({
         cells: liveActionsRef.current.getCellsSnapshot(),
@@ -160,6 +206,8 @@ export const createNotebookController = (
           liveActionsRef.current.getMaximizedCellId() ?? undefined,
       }),
     readRefreshState: () => liveActionsRef.current.readRefreshState(),
+    readResultStatus: (cellId) =>
+      liveActionsRef.current.readResultStatus(cellId),
     // runCell is not a transition, so it does not inherit requireCellIn — guard
     // it here, matching the passive route's requireCellIn in runHeadlessCell.
     runCell: async (cellId, signal, sql, gate) => {
@@ -193,20 +241,30 @@ export const createNotebookController = (
             : {}),
         }
       }
-      const { superseded, cellChanged, notStarted, resultCleared, result } =
-        outcome
+      const {
+        superseded,
+        cellChanged,
+        notStarted,
+        resultCleared,
+        cancelled,
+        result,
+      } = outcome
 
+      if (cancelled !== undefined && notStarted) {
+        return cancelledBeforeLaunchSummary(cancelled)
+      }
       if (superseded || cellChanged || resultCleared) {
         return {
           ...summarizeCellResults(undefined),
           unverified: true,
+          ...(cancelled !== undefined ? { cancelled } : {}),
           note: notStarted
             ? CELL_CHANGED_BEFORE_RUN_NOTE
             : resultCleared
               ? RESULT_CLEARED_MID_RUN_NOTE
               : cellChanged
                 ? CELL_CHANGED_MID_RUN_NOTE
-                : SUPERSEDED_RUN_NOTE,
+                : midRunCancellationNote(cancelled ?? "superseded"),
         }
       }
 
@@ -268,14 +326,16 @@ export const createDexieNotebookController = (
     }
   }
 
-  const mutate: NotebookMutate = async (transition) => {
+  const runMutation = async <T>(
+    produce: (parts: ViewParts) => Promise<NotebookTransitionResult<T>>,
+  ): Promise<T> => {
     requireActive()
     requireUnclaimed()
     const { result, touchedCellId } = await enqueueBufferTask(
       bufferId,
       async () => {
         const view = await readNotebookView(bufferId)
-        const out = transition(partsOf(view))
+        const out = await produce(partsOf(view))
         requireActive()
         const commit = await commitView(bufferId, out.parts)
         if (commit === "deleted") {
@@ -284,6 +344,31 @@ export const createDexieNotebookController = (
         if (commit === "archived") {
           throw notebookArchivedMidEdit(bufferId)
         }
+        const previousCellsById = new Map(
+          view.cells.map((cell) => [cell.id, cell]),
+        )
+        const changedSqlCells = out.parts.cells.flatMap((nextCell) => {
+          const previousCell = previousCellsById.get(nextCell.id)
+          return previousCell &&
+            nextCell.type !== "markdown" &&
+            previousCell.value !== nextCell.value
+            ? [{ cellId: nextCell.id, value: nextCell.value }]
+            : []
+        })
+        // Invalidate only after the document commit succeeds. Because this is
+        // still inside the per-buffer queue, a completed headless request
+        // cannot interleave its result commit between this mutation and the
+        // invalidation.
+        if (out.cancelRuns) {
+          cancelHeadlessCellRuns(
+            bufferId,
+            out.cancelRuns.cellIds,
+            out.cancelRuns.reason,
+          )
+        }
+        if (out.cleanup && out.cleanup.cellIds.length > 0) {
+          cancelHeadlessCellRuns(bufferId, out.cleanup.cellIds, "cell_deleted")
+        }
         // Runs only after a durable commit and is never awaited: the write is
         // done, and failing the tool over orphaned snapshot/layout cleanup
         // would misreport it.
@@ -294,22 +379,49 @@ export const createDexieNotebookController = (
             clearChartZoom(cellId)
           }
         }
-        if (out.deleteSnapshots) {
-          for (const cellId of out.deleteSnapshots.cellIds) {
-            void deleteCellSnapshot(bufferId, cellId).catch(() => undefined)
+        const snapshotsToDelete = new Set(out.deleteSnapshots?.cellIds ?? [])
+        for (const { cellId, value } of changedSqlCells) {
+          try {
+            const snapshot = await loadCellSnapshot(bufferId, cellId)
+            if (
+              snapshot &&
+              !snapshotResultsHaveMatchingStatement(
+                snapshot.results,
+                getQueriesFromText(value),
+              )
+            ) {
+              snapshotsToDelete.add(cellId)
+            }
+          } catch {
+            // The document edit is already durable. A later hydration retries
+            // reconciliation if IndexedDB could not be inspected here.
           }
         }
+        // Semantic invalidation is awaited so an immediate passive read cannot
+        // observe a stale snapshot key after the mutation resolves.
+        await Promise.all(
+          [...snapshotsToDelete].map((cellId) =>
+            deleteCellSnapshot(bufferId, cellId).catch(() => undefined),
+          ),
+        )
         return out
       },
     )
     emitAgentEdit({ bufferId, cellId: touchedCellId })
     return result
   }
+  const mutate: NotebookMutate = (transition) =>
+    runMutation((parts) => Promise.resolve(transition(parts)))
+  const mutateWithResultStatus: NotebookMutateWithResultStatus = (transition) =>
+    runMutation(async (parts) =>
+      transition(parts, await loadPassiveResultStatusReader(bufferId)),
+    )
 
   return {
     bufferId,
     kind: "dexie",
     mutate,
+    mutateWithResultStatus,
     readView: () =>
       enqueueBufferTask(bufferId, () => readNotebookView(bufferId)),
     runCell: (cellId, signal, sql, gate) =>
diff --git a/src/utils/notebooks/notebookController/notebookControllerUtils.ts b/src/utils/notebooks/notebookController/notebookControllerUtils.ts
index f73515237..bad7ea807 100644
--- a/src/utils/notebooks/notebookController/notebookControllerUtils.ts
+++ b/src/utils/notebooks/notebookController/notebookControllerUtils.ts
@@ -5,7 +5,7 @@ import {
   cancelPendingSearchPublish,
   readNotebookView,
 } from "../notebookDexieView"
-import { forgetHeadlessRuns } from "../notebookHeadlessRun"
+import { cancelHeadlessBufferRuns } from "../notebookHeadlessRun"
 import { forgetBufferSeq } from "../notebookAIBridge"
 import { pinNotebookSnapshots } from "../../../store/notebookResults"
 import type { NotebookController } from "./notebookController"
@@ -109,7 +109,7 @@ export const forgetBuffer = (bufferId: number): void => {
   forgetBufferOwnership(bufferId)
   rejectWaiters(bufferId, new MountClaimReleasedError(bufferId))
   cancelPendingSearchPublish(bufferId)
-  forgetHeadlessRuns(bufferId)
+  cancelHeadlessBufferRuns(bufferId, "notebook_deleted")
 }
 
 export const releaseArchivedBuffer = (bufferId: number): void => {
@@ -117,6 +117,7 @@ export const releaseArchivedBuffer = (bufferId: number): void => {
   releaseBufferEpoch(bufferId)
   rejectWaiters(bufferId, new MountClaimReleasedError(bufferId))
   cancelPendingSearchPublish(bufferId)
+  cancelHeadlessBufferRuns(bufferId, "notebook_archived")
 }
 
 export const registerController = (controller: NotebookController): void => {
diff --git a/src/utils/notebooks/notebookController/notebookTransitions.test.ts b/src/utils/notebooks/notebookController/notebookTransitions.test.ts
index 1262b0482..aefa281cb 100644
--- a/src/utils/notebooks/notebookController/notebookTransitions.test.ts
+++ b/src/utils/notebooks/notebookController/notebookTransitions.test.ts
@@ -6,6 +6,8 @@ import {
   applyNotebookStateTransition,
   deleteCellTransition,
   duplicateCellTransition,
+  setCellDimensionsTransition,
+  setCellLayoutTransition,
   setCellModeTransition,
   updateCellTransition,
 } from "./notebookTransitions"
@@ -37,6 +39,258 @@ const partsOf = (
   ...overrides,
 })
 
+describe("setCellDimensionsTransition", () => {
+  it("shows the editor by expanding the derived footprint and preserving both panes", () => {
+    const chart = cell("a", "SELECT 1", {
+      mode: "draw",
+      topHeight: 72,
+      bottomHeight: 350,
+      paneView: "result",
+    })
+    const parts = partsOf([chart], {
+      settings: {
+        layoutMode: "grid",
+        layout: [{ i: "a", x: 0, y: 0, w: 12, h: 14 }],
+      },
+    })
+
+    const out = setCellDimensionsTransition(parts, BUFFER_ID, "a", {
+      view: "editor_result",
+      resultStatus: "missing",
+    })
+
+    expect(out.parts.cells[0]).toMatchObject({
+      topHeight: 72,
+      bottomHeight: 350,
+      paneView: "editor_result",
+    })
+    expect(out.parts.settings.layout?.[0].h).toBe(17)
+    expect(out.result).toEqual({ view: "editor_result", mode: "draw" })
+  })
+
+  it("supports null preserve, auto reset, and a fixed result height", () => {
+    const chart = cell("a", "SELECT 1", {
+      mode: "draw",
+      topHeight: 200,
+      topResized: true,
+      bottomHeight: 350,
+      bottomResized: false,
+      paneView: "result",
+    })
+
+    const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
+      editorHeight: "auto",
+      resultHeight: 300,
+      view: null,
+    })
+
+    expect(out.parts.cells[0]).toMatchObject({
+      topHeight: 72,
+      topResized: false,
+      bottomHeight: 300,
+      bottomResized: true,
+      paneView: "result",
+    })
+    expect(out.result).toEqual({ view: "result", mode: "draw" })
+  })
+
+  it("ignores view and result_height on a markdown cell and reports a null view", () => {
+    // Given a markdown cell
+    const markdown = cell("a", "# title", { type: "markdown" })
+    // When an agent sends a view and a result_height with the editor height
+    const out = setCellDimensionsTransition(
+      partsOf([markdown]),
+      BUFFER_ID,
+      "a",
+      {
+        editorHeight: 86,
+        resultHeight: 300,
+        view: "result",
+        resultStatus: "missing",
+      },
+    )
+    // Then only the editor height lands, and the view reports null
+    expect(out.parts.cells[0]).toMatchObject({
+      topHeight: 86,
+      topResized: true,
+    })
+    expect(out.parts.cells[0].bottomHeight).toBeUndefined()
+    expect(out.parts.cells[0].paneView).toBeUndefined()
+    expect(out.result).toEqual({ view: null, mode: null })
+  })
+
+  it("view editor discards the run outcome and exits draw", () => {
+    // Given a draw cell with a stored result-only arrangement
+    const chart = cell("a", "SELECT 1", {
+      mode: "draw",
+      paneView: "result",
+      lastRunStatus: "success",
+    })
+    // When an agent sends view "editor" — the toggle-off gesture
+    const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
+      view: "editor",
+      resultStatus: "missing",
+    })
+    // Then the run outcome and persisted draw marker are wiped, the stored
+    // arrangement survives for the next run, and the snapshot is deleted
+    expect(out.parts.cells[0]).toMatchObject({
+      result: undefined,
+      lastRunStatus: undefined,
+      paneView: "result",
+    })
+    expect(out.parts.cells[0].mode).toBeUndefined()
+    expect(out.result).toEqual({
+      view: "editor",
+      mode: null,
+      result_discarded: true,
+    })
+    expect(out.cancelRuns).toEqual({
+      cellIds: ["a"],
+      reason: "result_cleared",
+    })
+    expect(out.deleteSnapshots).toEqual({ cellIds: ["a"] })
+  })
+
+  it("view editor deletes any marker-less snapshot idempotently", () => {
+    const parts = partsOf([cell("a", "SELECT 1")])
+    const out = setCellDimensionsTransition(parts, BUFFER_ID, "a", {
+      view: "editor",
+      resultStatus: "missing",
+    })
+
+    expect(out.parts.cells).toBe(parts.cells)
+    expect(out.result).toEqual({ view: "editor", mode: null })
+    expect(out.cancelRuns).toEqual({
+      cellIds: ["a"],
+      reason: "result_cleared",
+    })
+    expect(out.deleteSnapshots).toEqual({ cellIds: ["a"] })
+  })
+
+  it("rejects a view outside the wire enum", () => {
+    expect(() =>
+      setCellDimensionsTransition(partsOf([cell("a")]), BUFFER_ID, "a", {
+        view: "<forged>" as never,
+      }),
+    ).toThrow(/view must be editor, result, or editor_result/)
+  })
+
+  it("rejects heights above the ceiling", () => {
+    const chart = cell("a", "SELECT 1", { mode: "draw" })
+    expect(() =>
+      setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
+        resultHeight: 2401,
+      }),
+    ).toThrow(/at most 2400px/)
+  })
+
+  it("rejects chart result heights below the visual minimum", () => {
+    const chart = cell("a", "SELECT 1", { mode: "draw" })
+    expect(() =>
+      setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
+        resultHeight: 100,
+      }),
+    ).toThrow(/at least 296px/)
+  })
+
+  it("uses the mounted missing-result state for the grid height", () => {
+    const pending = cell("a", "SELECT 1", {
+      lastRunStatus: "success",
+      paneView: "editor_result",
+    })
+    const out = setCellDimensionsTransition(
+      partsOf([pending], {
+        settings: {
+          layoutMode: "grid",
+          layout: [{ i: "a", x: 0, y: 0, w: 12, h: 19 }],
+        },
+      }),
+      BUFFER_ID,
+      "a",
+      { resultStatus: "missing" },
+    )
+
+    expect(out.result).toEqual({ view: "editor", mode: null })
+    expect(out.parts.settings.layout?.[0].h).toBe(5)
+  })
+
+  it("reserves the result area while the snapshot is still loading", () => {
+    // Given the same pending cell, but with a live status that says the
+    // snapshot has not been proven missing yet
+    const pending = cell("a", "SELECT 1", {
+      lastRunStatus: "success",
+      paneView: "editor_result",
+    })
+    const out = setCellDimensionsTransition(
+      partsOf([pending], {
+        settings: {
+          layoutMode: "grid",
+          layout: [{ i: "a", x: 0, y: 0, w: 12, h: 5 }],
+        },
+      }),
+      BUFFER_ID,
+      "a",
+      { resultStatus: "unrequested" },
+    )
+    // Then the grid box keeps the reserved-result footprint
+    expect(out.parts.settings.layout?.[0].h).toBe(19)
+  })
+
+  it("persists the pane preference but reports editor while result is missing", () => {
+    const pending = cell("a", "SELECT 1", {
+      lastRunStatus: "success",
+      paneView: "editor_result",
+    })
+    const out = setCellDimensionsTransition(
+      partsOf([pending]),
+      BUFFER_ID,
+      "a",
+      { view: "result", resultStatus: "missing" },
+    )
+
+    expect(out.parts.cells[0].paneView).toBe("result")
+    expect(out.result).toEqual({ view: "editor", mode: null })
+  })
+})
+
+describe("setCellLayoutTransition", () => {
+  const chart = cell("a", "SELECT 1", {
+    mode: "draw",
+    paneView: "editor_result",
+  })
+
+  it("returns the stored view after a position change", () => {
+    const out = setCellLayoutTransition(
+      partsOf([chart], {
+        settings: {
+          layoutMode: "grid",
+          layout: [{ i: "a", x: 0, y: 0, w: 6, h: 10 }],
+        },
+      }),
+      BUFFER_ID,
+      "a",
+      { x: 0, y: 0, w: 4, resultStatus: "missing" },
+    )
+
+    expect(out.result).toEqual({
+      grid: { x: 0, y: 0, w: 4 },
+      view: "editor_result",
+      mode: "draw",
+    })
+  })
+
+  it("rejects placement that extends beyond the grid", () => {
+    expect(() =>
+      setCellLayoutTransition(
+        partsOf([chart], { settings: { layoutMode: "grid" } }),
+        BUFFER_ID,
+        "a",
+        { x: 11, y: 0, w: 2 },
+      ),
+    ).toThrow(NotebookToolError)
+  })
+})
+
 describe("applyNotebookStateTransition", () => {
   it("carries every dropped cell in cleanup.cellIds for post-commit removal", () => {
     // Given a three-cell notebook
@@ -96,6 +350,17 @@ describe("applyNotebookStateTransition", () => {
     // Then the frame collapses and the snapshot deletion is requested, so
     // disk agrees with the collapsed cell on every later reload
     expect(out.parts.cells[0].result).toBeNull()
+    expect(out.cancelRuns?.cellIds).toEqual(["a"])
+    expect(out.deleteSnapshots?.cellIds).toEqual(["a"])
+  })
+
+  it("cancels a result-less cell run when apply requests editor-only", () => {
+    // Headless execution does not put a running placeholder in persisted state.
+    const out = applyNotebookStateTransition(partsOf([cell("a", "SELECT 1")]), {
+      cells: [{ id: "a", preserveValue: true, view: "editor" }],
+    })
+
+    expect(out.cancelRuns?.cellIds).toEqual(["a"])
     expect(out.deleteSnapshots?.cellIds).toEqual(["a"])
   })
 
@@ -179,10 +444,12 @@ describe("applyNotebookStateTransition", () => {
     expect(out.parts.focusedCellId).toBe("a")
   })
 
-  it("does no freshness checking: it takes only (parts, request), no read-seq", () => {
+  it("does no freshness checking: it takes (parts, request, resultStatusOf), no read-seq", () => {
     // Freshness is gated once at the dispatch layer, never inside a transition;
-    // a seq parameter here would let staleness leak into the pure layer.
-    expect(applyNotebookStateTransition).toHaveLength(2)
+    // a seq parameter here would let staleness leak into the pure layer. The
+    // third parameter is a per-cell status READER supplied by the controller,
+    // not a freshness token.
+    expect(applyNotebookStateTransition).toHaveLength(3)
   })
 
   it("does no freshness checking: re-applying its own output never staleness-throws", () => {
@@ -229,7 +496,7 @@ describe("deleteCellTransition", () => {
 describe("setCellModeTransition", () => {
   it("asks the shell to cancel the cell's run when it enters draw mode", () => {
     // Given a run-mode cell (a run may be in flight)
-    const parts = partsOf([cell("a", "select 1", { mode: "run" })])
+    const parts = partsOf([cell("a", "select 1")])
     // When the cell switches to draw
     const out = setCellModeTransition(parts, BUFFER_ID, "a", "draw")
     // Then the shell is told to abort its in-flight run — the chart engine
@@ -245,8 +512,24 @@ describe("setCellModeTransition", () => {
     const stillDraw = setCellModeTransition(parts, BUFFER_ID, "a", "draw")
     // Then neither carries a cancel request
     expect(toRun.cancelRuns).toBeUndefined()
+    expect(toRun.parts.cells[0].mode).toBeUndefined()
     expect(stillDraw.cancelRuns).toBeUndefined()
   })
+
+  it.each(["draw", "run"] as const)(
+    "rejects mode %s on a markdown cell with a typed error",
+    (mode) => {
+      // Given a markdown cell whose prose happens to parse as SQL
+      const parts = partsOf([cell("m", "SELECT 1", { type: "markdown" })])
+      // When a mode is requested
+      const apply = () => setCellModeTransition(parts, BUFFER_ID, "m", mode)
+      // Then the transition refuses and the cell keeps no mode
+      expect(apply).toThrowError(NotebookToolError)
+      expect(apply).toThrowError(/Markdown cells have no run or draw mode/)
+      expect(parts.cells[0].mode).toBeUndefined()
+      expect(parts.cells[0].bottomHeight).toBeUndefined()
+    },
+  )
 })
 
 describe("transition validation guards", () => {
diff --git a/src/utils/notebooks/notebookController/notebookTransitions.ts b/src/utils/notebooks/notebookController/notebookTransitions.ts
index 710f684ca..74c69c4b3 100644
--- a/src/utils/notebooks/notebookController/notebookTransitions.ts
+++ b/src/utils/notebooks/notebookController/notebookTransitions.ts
@@ -2,6 +2,7 @@ import {
   MAX_NOTEBOOK_CELLS,
   type AutoRefresh,
   type CellMode,
+  type CellPaneView,
   type CellType,
   type NotebookCell,
 } from "../../../store/notebook"
@@ -11,26 +12,35 @@ import { requireCellIn, requireCellWithinLineLimit } from "../notebookDexieView"
 import type { ApplyNotebookStateRequest } from "./notebookController"
 import type { ChartConfig } from "../../../scenes/Editor/Notebook/CellChart/chartTypes"
 import {
+  agentCellDimensionsPatch,
   buildAppliedNotebookState,
   carriedRunError,
   carriedRunStatus,
-  cellHeightPatchForRows,
+  cellGridBoundsError,
+  cellHasRunOutcome,
   cellModeChangePatch,
+  discardCellResult,
   clearCellAutoRefresh,
+  computeAgentCellGridH,
   duplicateCellAt,
   insertCell,
   isExpectingResult,
   mergeCellChartConfig,
   nextGridSeedPosition,
   reconcileCellResultForValue,
-  NOTEBOOK_GRID_MARGIN_Y,
-  NOTEBOOK_GRID_ROW_HEIGHT,
+  agentCellPresentation,
+  type AgentCellPresentation,
   removeCell,
   swapCellDown,
   swapCellUp,
   topHeightForSql,
   upsertCellLayout,
+  validateAgentCellDimensions,
   type CellGridPosition,
+  type AgentCellDimensions,
+  type CellResultStatus,
+  type CellResultStatusReader,
+  type RunCancelReason,
 } from "../../../scenes/Editor/Notebook/notebookUtils"
 
 // The single home for every notebook mutation's behavior. Each transition is a
@@ -41,9 +51,9 @@ import {
 //
 // Side effects are returned as data, never performed here:
 //   - `cleanup.cellIds`    — snapshots/layouts each shell drops after its commit.
-//   - `cancelRuns.cellIds` — cells whose in-flight run the mounted shell aborts
-//                            (the run would keep writing cell.result after the
-//                            chart engine takes ownership).
+//   - `cancelRuns`          — cells whose in-flight run either shell aborts
+//                            because the transition invalidated its eventual
+//                            result, and the reason the run reports for it.
 //   - `deleteSnapshots.cellIds` — cells that survive the transition but whose
 //                            persisted result no longer matches their SQL;
 //                            each shell deletes the snapshot so hydration
@@ -60,7 +70,7 @@ export type NotebookTransitionResult<T = void> = {
   result: T
   touchedCellId?: string
   cleanup?: { cellIds: string[] }
-  cancelRuns?: { cellIds: string[] }
+  cancelRuns?: { cellIds: string[]; reason: RunCancelReason }
   deleteSnapshots?: { cellIds: string[] }
 }
 
@@ -279,34 +289,134 @@ export const setCellLayoutTransition = (
   parts: ViewParts,
   bufferId: number,
   cellId: string,
-  pos: CellGridPosition,
-): NotebookTransitionResult => {
+  pos: Omit<CellGridPosition, "h"> & { resultStatus?: CellResultStatus },
+): NotebookTransitionResult<
+  AgentCellPresentation & { grid: { x: number; y: number; w: number } }
+> => {
   const cell = requireCellIn(parts.cells, cellId, bufferId)
-  // Pin an intentionally-resized h into the cell (see cellHeightPatchForRows).
-  const heightPatch = cellHeightPatchForRows(
-    cell,
-    pos.h,
-    NOTEBOOK_GRID_ROW_HEIGHT,
-    NOTEBOOK_GRID_MARGIN_Y,
-    isExpectingResult(cell, "unrequested"),
-  )
+  const gridError = cellGridBoundsError(pos)
+  if (gridError) throw new NotebookToolError("validation", gridError)
+  const layoutPos: CellGridPosition = {
+    x: pos.x,
+    y: pos.y,
+    w: pos.w,
+    h: computeAgentCellGridH(
+      cell,
+      isExpectingResult(cell, pos.resultStatus ?? "unrequested"),
+    ),
+  }
   return {
     parts: {
       ...parts,
-      cells:
-        Object.keys(heightPatch).length > 0
-          ? patchCellIn(parts.cells, cellId, heightPatch)
-          : parts.cells,
       settings: {
         ...parts.settings,
-        layout: upsertCellLayout(parts.settings.layout, cellId, pos),
+        layout: upsertCellLayout(parts.settings.layout, cellId, layoutPos),
       },
     },
-    result: undefined,
+    result: {
+      grid: { x: pos.x, y: pos.y, w: pos.w },
+      ...agentCellPresentation(cell, pos.resultStatus),
+    },
     touchedCellId: cellId,
   }
 }
 
+export const setCellDimensionsTransition = (
+  parts: ViewParts,
+  bufferId: number,
+  cellId: string,
+  requested: AgentCellDimensions,
+): NotebookTransitionResult<
+  AgentCellPresentation & { result_discarded?: true }
+> => {
+  const cell = requireCellIn(parts.cells, cellId, bufferId)
+  const validation = validateAgentCellDimensions(cell, requested)
+  if (!validation.ok) {
+    const { issue } = validation
+    if (issue.reason === "invalid_view") {
+      throw new NotebookToolError(
+        "validation",
+        "view must be editor, result, or editor_result.",
+      )
+    }
+    if (issue.reason === "invalid_type") {
+      throw new NotebookToolError(
+        "validation",
+        `${issue.field} must be a number, auto, or null.`,
+      )
+    }
+    if (issue.reason === "below_minimum") {
+      throw new NotebookToolError(
+        "validation",
+        issue.field === "editor_height"
+          ? `editor_height must be at least ${issue.limit}px.`
+          : `result_height must be at least ${issue.limit}px for this cell.`,
+      )
+    }
+    throw new NotebookToolError(
+      "validation",
+      `Pane heights must be at most ${issue.limit}px.`,
+    )
+  }
+  const { dimensions } = validation
+
+  const wantsEditorOnly = dimensions.view === "editor"
+  const discarding = wantsEditorOnly && cellHasRunOutcome(cell)
+  const patch = agentCellDimensionsPatch(cell, dimensions)
+  const nextCell = {
+    ...(wantsEditorOnly ? discardCellResult(cell) : cell),
+    ...patch,
+  }
+  const replacesCell =
+    discarding ||
+    Object.keys(patch).length > 0 ||
+    (wantsEditorOnly && (cell as { mode?: unknown }).mode !== undefined)
+  const layout = parts.settings.layout?.map((item) =>
+    item.i === cellId
+      ? {
+          ...item,
+          h: computeAgentCellGridH(
+            nextCell,
+            discarding
+              ? false
+              : isExpectingResult(
+                  cell,
+                  dimensions.resultStatus ?? "unrequested",
+                ),
+          ),
+        }
+      : item,
+  )
+  return {
+    parts: {
+      ...parts,
+      cells: replacesCell
+        ? parts.cells.map((c) => (c.id === cellId ? nextCell : c))
+        : parts.cells,
+      settings:
+        layout === parts.settings.layout
+          ? parts.settings
+          : { ...parts.settings, layout },
+    },
+    result: {
+      ...agentCellPresentation(nextCell, dimensions.resultStatus),
+      ...(discarding ? { result_discarded: true as const } : {}),
+    },
+    touchedCellId: cellId,
+    // A headless run has no persisted `running` placeholder, and a live run
+    // may still be behind its validation barrier. Emit the cancellation intent
+    // for every SQL-cell editor-only request; shells treat it idempotently when
+    // no run exists.
+    ...(wantsEditorOnly
+      ? { cancelRuns: { cellIds: [cellId], reason: "result_cleared" as const } }
+      : {}),
+    // Snapshot rows live outside the buffer document, so a marker-less cell
+    // cannot prove that none exist. Deletion is idempotent and view:"editor"
+    // is the explicit discard gesture.
+    ...(wantsEditorOnly ? { deleteSnapshots: { cellIds: [cellId] } } : {}),
+  }
+}
+
 export const setCellModeTransition = (
   parts: ViewParts,
   bufferId: number,
@@ -314,18 +424,29 @@ export const setCellModeTransition = (
   mode: CellMode,
 ): NotebookTransitionResult => {
   const cell = requireCellIn(parts.cells, cellId, bufferId)
+  if (cell.type === "markdown") {
+    throw new NotebookToolError(
+      "validation",
+      "Markdown cells have no run or draw mode.",
+    )
+  }
   const entersDraw = mode === "draw" && cell.mode !== "draw"
+  const nextCell: NotebookCell = {
+    ...cell,
+    ...cellModeChangePatch(cell, mode),
+  }
+  if (mode === "draw") nextCell.mode = "draw"
+  else delete nextCell.mode
   return {
     parts: {
       ...parts,
-      cells: patchCellIn(parts.cells, cellId, {
-        mode,
-        ...cellModeChangePatch(cell, mode),
-      }),
+      cells: parts.cells.map((c) => (c.id === cellId ? nextCell : c)),
     },
     result: undefined,
     touchedCellId: cellId,
-    ...(entersDraw ? { cancelRuns: { cellIds: [cellId] } } : {}),
+    ...(entersDraw
+      ? { cancelRuns: { cellIds: [cellId], reason: "mode_changed" as const } }
+      : {}),
   }
 }
 
@@ -348,17 +469,25 @@ export const setCellChartConfigTransition = (
   }
 }
 
-export const setCellViewMaximizedTransition = (
+export const setCellPaneViewTransition = (
   parts: ViewParts,
   bufferId: number,
   cellId: string,
-  value: boolean,
+  paneView: CellPaneView,
 ): NotebookTransitionResult => {
-  requireCellIn(parts.cells, cellId, bufferId)
+  const cell = requireCellIn(parts.cells, cellId, bufferId)
+  if (cell.type === "markdown") {
+    throw new NotebookToolError(
+      "validation",
+      "Markdown cells have no pane view.",
+    )
+  }
   return {
     parts: {
       ...parts,
-      cells: patchCellIn(parts.cells, cellId, { isViewMaximized: value }),
+      cells: patchCellIn(parts.cells, cellId, {
+        paneView,
+      }),
     },
     result: undefined,
     touchedCellId: cellId,
@@ -381,10 +510,29 @@ export const setCellMaximizedTransition = (
 export const applyNotebookStateTransition = (
   parts: ViewParts,
   request: ApplyNotebookStateRequest,
+  resultStatusOf?: CellResultStatusReader,
 ): NotebookTransitionResult<{
   applied: { added: string[]; updated: string[]; deleted: string[] }
 }> => {
-  const next = buildAppliedNotebookState(parts, request)
+  const next = buildAppliedNotebookState(parts, request, resultStatusOf)
+  const existingSqlCellIds = new Set(
+    parts.cells
+      .filter((cell) => cell.type !== "markdown")
+      .map((cell) => cell.id),
+  )
+  const invalidatedResultIds = new Set(next.resultsCleared)
+  for (const cell of request.cells) {
+    if (
+      cell.view === "editor" &&
+      typeof cell.id === "string" &&
+      existingSqlCellIds.has(cell.id)
+    ) {
+      // Passive runs do not install a persisted `running` result, and snapshot
+      // rows live outside this document. An editor-only request must therefore
+      // invalidate both even when there is no visible outcome to clear.
+      invalidatedResultIds.add(cell.id)
+    }
+  }
   return {
     parts: {
       ...parts,
@@ -401,8 +549,16 @@ export const applyNotebookStateTransition = (
     },
     result: { applied: next.diff },
     cleanup: { cellIds: next.diff.deleted },
-    ...(next.resultsCleared.length > 0
-      ? { deleteSnapshots: { cellIds: next.resultsCleared } }
+    ...(invalidatedResultIds.size > 0
+      ? {
+          cancelRuns: {
+            cellIds: [...invalidatedResultIds],
+            reason: "result_cleared" as const,
+          },
+        }
+      : {}),
+    ...(invalidatedResultIds.size > 0
+      ? { deleteSnapshots: { cellIds: [...invalidatedResultIds] } }
       : {}),
   }
 }
diff --git a/src/utils/notebooks/notebookDexieController.test.ts b/src/utils/notebooks/notebookDexieController.test.ts
index 9f879628f..ee7a3697d 100644
--- a/src/utils/notebooks/notebookDexieController.test.ts
+++ b/src/utils/notebooks/notebookDexieController.test.ts
@@ -15,13 +15,14 @@ import {
   moveCellDownTransition,
   moveCellUpTransition,
   setCellMaximizedTransition,
+  setCellDimensionsTransition,
   setCellModeTransition,
   setLayoutModeTransition,
   updateCellTransition,
   type ApplyNotebookStateRequest,
 } from "./notebookController"
 import { generateId } from "../../scenes/Editor/Notebook/notebookUtils"
-import { forgetHeadlessRuns } from "./notebookHeadlessRun"
+import { cancelHeadlessBufferRuns } from "./notebookHeadlessRun"
 import type { DexieControllerDeps } from "./notebookHeadlessRun"
 import {
   claimLive,
@@ -117,7 +118,12 @@ const makeQuest = (opts: { validate?: (sql: string) => unknown } = {}) => {
   return { quest, pending, respondNext }
 }
 
-const dqlResult = { type: "dql", columns: [], dataset: [], count: 1 }
+const dqlResult = {
+  type: "dql" as const,
+  columns: [],
+  dataset: [],
+  count: 1,
+}
 const errorResult = { type: "error", error: "boom" }
 
 // Rebuilds the ergonomic named-method API over the collapsed controller
@@ -274,6 +280,90 @@ describe("createDexieNotebookController — structural edits", () => {
     expect(view.cells[1].value).toBe("keep")
   })
 
+  it("updateCell deletes a snapshot when none of its statements match", async () => {
+    await seedNotebook({
+      cells: [cell("a", "select 1; select 2", { lastRunStatus: "success" })],
+    })
+    await saveCellSnapshot({
+      bufferId: BUFFER_ID,
+      cellId: "a",
+      results: [
+        { ...dqlResult, query: "select 1" },
+        { ...dqlResult, query: "select 2" },
+      ],
+      savedAt: 1,
+    })
+    const controller = makeController()
+
+    await controller.updateCell("a", { value: "select 12; select 3" })
+
+    expect(await loadCellSnapshot(BUFFER_ID, "a")).toBeUndefined()
+  })
+
+  it("updateCell keeps a snapshot with a normalized statement match", async () => {
+    await seedNotebook({
+      cells: [
+        cell("a", "select * from trades where sym = 'A'", {
+          lastRunStatus: "success",
+        }),
+      ],
+    })
+    await saveCellSnapshot({
+      bufferId: BUFFER_ID,
+      cellId: "a",
+      results: [
+        {
+          ...dqlResult,
+          query: "select * from trades where sym = 'A'",
+        },
+      ],
+      savedAt: 1,
+    })
+    const controller = makeController()
+
+    await controller.updateCell("a", {
+      value: "SELECT  *\nFROM trades WHERE sym='A'; select 3",
+    })
+
+    expect(await loadCellSnapshot(BUFFER_ID, "a")).toBeDefined()
+  })
+
+  it("updateCell deletes a matching snapshot that contains only placeholders", async () => {
+    await seedNotebook({
+      cells: [cell("a", "select 1", { lastRunStatus: "success" })],
+    })
+    await saveCellSnapshot({
+      bufferId: BUFFER_ID,
+      cellId: "a",
+      results: [{ type: "running", query: "select 1" }],
+      savedAt: 1,
+    })
+    const controller = makeController()
+
+    await controller.updateCell("a", { value: "SELECT\n  1" })
+
+    expect(await loadCellSnapshot(BUFFER_ID, "a")).toBeUndefined()
+  })
+
+  it("apply deletes a snapshot when none of its statements match", async () => {
+    await seedNotebook({
+      cells: [cell("a", "select 1", { lastRunStatus: "success" })],
+    })
+    await saveCellSnapshot({
+      bufferId: BUFFER_ID,
+      cellId: "a",
+      results: [{ ...dqlResult, query: "select 1" }],
+      savedAt: 1,
+    })
+    const controller = makeController()
+
+    await controller.applyNotebookState({
+      cells: [{ id: "a", value: "select 2" }],
+    })
+
+    expect(await loadCellSnapshot(BUFFER_ID, "a")).toBeUndefined()
+  })
+
   it("updateCell rejects an unknown cell with a typed error", async () => {
     // Given a notebook without cell "ghost"
     await seedNotebook({ cells: [cell("a")] })
@@ -308,6 +398,50 @@ describe("createDexieNotebookController — structural edits", () => {
     expect(await loadCellSnapshot(BUFFER_ID, "a")).toBeUndefined()
   })
 
+  it("view editor deletes a marker-less cell snapshot", async () => {
+    await seedNotebook({
+      cells: [cell("a", "SELECT 1", { paneView: "result" })],
+    })
+    await saveCellSnapshot({
+      bufferId: BUFFER_ID,
+      cellId: "a",
+      results: [],
+      savedAt: 1,
+    })
+    const controller = makeController()
+
+    await controller.mutate((parts) =>
+      setCellDimensionsTransition(parts, BUFFER_ID, "a", {
+        view: "editor",
+      }),
+    )
+
+    await vi.waitFor(async () => {
+      expect(await loadCellSnapshot(BUFFER_ID, "a")).toBeUndefined()
+    })
+  })
+
+  it("apply editor-only deletes a marker-less cell snapshot", async () => {
+    await seedNotebook({
+      cells: [cell("a", "SELECT 1", { paneView: "result" })],
+    })
+    await saveCellSnapshot({
+      bufferId: BUFFER_ID,
+      cellId: "a",
+      results: [],
+      savedAt: 1,
+    })
+    const controller = makeController()
+
+    await controller.applyNotebookState({
+      cells: [{ id: "a", preserveValue: true, view: "editor" }],
+    })
+
+    await vi.waitFor(async () => {
+      expect(await loadCellSnapshot(BUFFER_ID, "a")).toBeUndefined()
+    })
+  })
+
   it("moveCellUp / moveCellDown swap positions durably", async () => {
     // Given two cells
     await seedNotebook({ cells: [cell("a"), cell("b")] })
@@ -357,11 +491,10 @@ describe("createDexieNotebookController — settings & layout", () => {
     expect(view.settings?.layoutMode).toBe("grid")
   })
 
-  it("setCellMode draw seeds the chart bottom height and exits view-maximize", async () => {
-    // Given a view-maximized run cell; when it flips to draw, then the chart
-    // defaults land and the maximize exits
+  it("setCellMode draw seeds the chart bottom height and preserves preference", async () => {
+    // A mode change does not silently rewrite the user's pane preference.
     await seedNotebook({
-      cells: [cell("a", "SELECT 1", { isViewMaximized: true })],
+      cells: [cell("a", "SELECT 1", { paneView: "result" })],
     })
     const controller = makeController()
     await controller.setCellMode("a", "draw")
@@ -369,7 +502,7 @@ describe("createDexieNotebookController — settings & layout", () => {
     expect(view.cells[0]).toMatchObject({
       mode: "draw",
       bottomHeight: 350,
-      isViewMaximized: false,
+      paneView: "result",
     })
   })
 
@@ -669,6 +802,39 @@ describe("createDexieNotebookController — runCell", () => {
     expect(pending).toHaveLength(0)
   })
 
+  it("a skipped newer claim does not supersede an in-flight run", async () => {
+    await seedNotebook({ cells: [cell("a", "INSERT INTO t VALUES (1)")] })
+    const {
+      quest,
+      pending: inFlight,
+      respondNext,
+    } = makeQuest({
+      validate: () => ({ queryType: "INSERT" }),
+    })
+    const controller = makeController({}, quest)
+
+    // An explicit write has passed its barrier and reached the server.
+    const explicit = controller.runCell("a", undefined, undefined, {
+      kind: "explicit",
+      permissions: { grantSchemaAccess: true, read: true, write: true },
+    })
+    await vi.waitFor(() => {
+      if (inFlight.length !== 1) throw new Error("write not in flight")
+    })
+
+    // A newer auto-run claims the same cell, but its barrier skips writes.
+    // Since it never launches, it must not take authority from the write.
+    const autoRun = await controller.runCell("a", undefined, undefined, {
+      kind: "autoRun",
+    })
+    expect(autoRun.skipped).toMatch(/AUTO_RUN_SKIPPED/)
+    expect(inFlight).toHaveLength(1)
+
+    respondNext({ type: "dml" })
+    expect(await explicit).toMatchObject({ success: true, queryCount: 1 })
+    expect((await persistedView()).cells[0].lastRunStatus).toBe("success")
+  })
+
   it("explicit gate denies a write without the write permission at the barrier", async () => {
     await seedNotebook({ cells: [cell("a", "INSERT INTO t VALUES (1)")] })
     const { quest, pending } = makeQuest({
@@ -853,6 +1019,318 @@ describe("createDexieNotebookController — runCell", () => {
     expect((await persistedView()).cells[0].lastRunStatus).toBe("success")
   })
 
+  it("a newer invocation supersedes an older run still awaiting validation", async () => {
+    await seedNotebook({ cells: [cell("a", "SELECT 1")] })
+    const validations: Array<{ resolve: (value: unknown) => void }> = []
+    const {
+      quest,
+      pending: inFlight,
+      respondNext,
+    } = makeQuest({
+      validate: () =>
+        new Promise((resolve) => {
+          validations.push({ resolve })
+        }),
+    })
+    const controller = makeController({}, quest)
+
+    const first = controller.runCell("a", undefined, undefined, {
+      kind: "autoRun",
+    })
+    await vi.waitFor(() => {
+      if (validations.length < 1)
+        throw new Error("first validation not started")
+    })
+
+    const second = controller.runCell("a", undefined, undefined, {
+      kind: "autoRun",
+    })
+    await vi.waitFor(() => {
+      if (validations.length < 2)
+        throw new Error("second validation not started")
+    })
+
+    // The newer invocation validates and launches before the older validation
+    // settles. Resolving the older barrier afterward must not let it launch or
+    // supersede the newer request.
+    validations[1].resolve(dqlValidation)
+    await vi.waitFor(() => {
+      if (inFlight.length !== 1) throw new Error("newer run not launched")
+    })
+    validations[0].resolve(dqlValidation)
+
+    expect(await first).toMatchObject({
+      success: false,
+      queryCount: 0,
+      results: [],
+      cancelled: "superseded",
+    })
+    expect(inFlight).toHaveLength(1)
+
+    respondNext(dqlResult)
+    expect(await second).toMatchObject({ success: true, queryCount: 1 })
+    expect((await persistedView()).cells[0].lastRunStatus).toBe("success")
+  })
+
+  it("view editor invalidates a headless run before it can restore a result", async () => {
+    await seedNotebook({ cells: [cell("a", "SELECT 1")] })
+    const { quest, pending: inFlight, respondNext } = makeQuest()
+    const controller = makeController({}, quest)
+    const run = controller.runCell("a")
+    await vi.waitFor(() => {
+      if (inFlight.length === 0) throw new Error("run not in flight")
+    })
+
+    await controller.mutate((parts) =>
+      setCellDimensionsTransition(parts, BUFFER_ID, "a", {
+        view: "editor",
+      }),
+    )
+    respondNext(dqlResult)
+    const summary = await run
+
+    expect(summary.unverified).toBe(true)
+    expect(summary.note).toMatch(/result was cleared/)
+    expect((await persistedView()).cells[0].lastRunStatus).toBeUndefined()
+    expect(await loadCellSnapshot(BUFFER_ID, "a")).toBeUndefined()
+  })
+
+  it("view editor prevents a headless run from launching after validation", async () => {
+    await seedNotebook({ cells: [cell("a", "SELECT 1")] })
+    let resolveValidation!: (value: unknown) => void
+    const validation = new Promise((resolve) => {
+      resolveValidation = resolve
+    })
+    let validationStarted = false
+    const { quest, pending: inFlight } = makeQuest({
+      validate: () => {
+        validationStarted = true
+        return validation
+      },
+    })
+    const controller = makeController({}, quest)
+    const run = controller.runCell("a", undefined, undefined, {
+      kind: "autoRun",
+    })
+    await vi.waitFor(() => {
+      if (!validationStarted) throw new Error("validation not in flight")
+    })
+
+    await controller.mutate((parts) =>
+      setCellDimensionsTransition(parts, BUFFER_ID, "a", {
+        view: "editor",
+      }),
+    )
+    resolveValidation(dqlValidation)
+    const summary = await run
+
+    expect(summary).toMatchObject({
+      success: false,
+      queryCount: 0,
+      results: [],
+      cancelled: "result_cleared",
+    })
+    expect(summary.note).toMatch(/Run NOT started/)
+    expect(inFlight).toHaveLength(0)
+    expect((await persistedView()).cells[0].lastRunStatus).toBeUndefined()
+    expect(await loadCellSnapshot(BUFFER_ID, "a")).toBeUndefined()
+  })
+
+  it("set_cell_mode draw during a headless run reports the mode change", async () => {
+    // Given a headless run whose query is in flight
+    await seedNotebook({ cells: [cell("a", "SELECT 1")] })
+    const { quest, pending: inFlight, respondNext } = makeQuest()
+    const controller = makeController({}, quest)
+    const run = controller.runCell("a")
+    await vi.waitFor(() => {
+      if (inFlight.length === 0) throw new Error("run not in flight")
+    })
+
+    // When an agent switches the cell to draw mode before the run settles
+    await controller.mutate((parts) =>
+      setCellModeTransition(parts, BUFFER_ID, "a", "draw"),
+    )
+    respondNext(dqlResult)
+    const summary = await run
+
+    // Then the run reports the mode change, not a cleared result
+    expect(summary.unverified).toBe(true)
+    expect(summary.cancelled).toBe("mode_changed")
+    expect(summary.note).toMatch(/switched to chart mode/)
+    expect(summary.note).not.toMatch(/result was cleared/)
+  })
+
+  it("archiving the notebook stops a headless run before it launches", async () => {
+    // Given a headless run that is still validating
+    await seedNotebook({ cells: [cell("a", "SELECT 1")] })
+    let resolveValidation!: (value: unknown) => void
+    const validation = new Promise((resolve) => {
+      resolveValidation = resolve
+    })
+    let validationStarted = false
+    const { quest, pending: inFlight } = makeQuest({
+      validate: () => {
+        validationStarted = true
+        return validation
+      },
+    })
+    const controller = makeController({}, quest)
+    const run = controller.runCell("a", undefined, undefined, {
+      kind: "autoRun",
+    })
+    await vi.waitFor(() => {
+      if (!validationStarted) throw new Error("validation not in flight")
+    })
+
+    // When the notebook is archived while validation is pending
+    releaseArchivedBuffer(BUFFER_ID)
+    resolveValidation(dqlValidation)
+    const summary = await run
+
+    // Then no SQL reaches the server and the run says why it stopped
+    expect(inFlight).toHaveLength(0)
+    expect(summary).toMatchObject({
+      success: false,
+      queryCount: 0,
+      results: [],
+      cancelled: "notebook_archived",
+    })
+    expect(summary.note).toMatch(/Run NOT started/)
+  })
+
+  it("a stale validation barrier cannot unregister its replacement", async () => {
+    await seedNotebook({ cells: [cell("a", "SELECT 1")] })
+    const validations: Array<{ resolve: (value: unknown) => void }> = []
+    const {
+      quest,
+      pending: inFlight,
+      respondNext,
+    } = makeQuest({
+      validate: () =>
+        new Promise((resolve) => {
+          validations.push({ resolve })
+        }),
+    })
+    const controller = makeController({}, quest)
+
+    const firstRun = controller.runCell("a", undefined, undefined, {
+      kind: "autoRun",
+    })
+    await vi.waitFor(() => {
+      if (validations.length < 1)
+        throw new Error("first validation not started")
+    })
+    await controller.mutate((parts) =>
+      setCellDimensionsTransition(parts, BUFFER_ID, "a", {
+        view: "editor",
+      }),
+    )
+
+    const secondRun = controller.runCell("a", undefined, undefined, {
+      kind: "autoRun",
+    })
+    await vi.waitFor(() => {
+      if (validations.length < 2)
+        throw new Error("second validation not started")
+    })
+    validations[0].resolve(dqlValidation)
+    expect(await firstRun).toMatchObject({
+      success: false,
+      queryCount: 0,
+      results: [],
+      cancelled: "result_cleared",
+    })
+
+    await controller.mutate((parts) =>
+      setCellDimensionsTransition(parts, BUFFER_ID, "a", {
+        view: "editor",
+      }),
+    )
+    validations[1].resolve(dqlValidation)
+
+    let secondSettled = false
+    void secondRun.finally(() => {
+      secondSettled = true
+    })
+    await vi.waitFor(() => {
+      if (!secondSettled && inFlight.length === 0) {
+        throw new Error("second run still awaiting validation")
+      }
+    })
+    if (inFlight.length > 0) respondNext(dqlResult)
+
+    expect(await secondRun).toMatchObject({
+      success: false,
+      queryCount: 0,
+      results: [],
+      cancelled: "result_cleared",
+    })
+    expect(inFlight).toHaveLength(0)
+    expect((await persistedView()).cells[0].lastRunStatus).toBeUndefined()
+    expect(await loadCellSnapshot(BUFFER_ID, "a")).toBeUndefined()
+  })
+
+  it("apply editor-only invalidates a headless run before it can restore a result", async () => {
+    await seedNotebook({ cells: [cell("a", "SELECT 1")] })
+    const { quest, pending: inFlight, respondNext } = makeQuest()
+    const controller = makeController({}, quest)
+    const run = controller.runCell("a")
+    await vi.waitFor(() => {
+      if (inFlight.length === 0) throw new Error("run not in flight")
+    })
+
+    await controller.applyNotebookState({
+      cells: [{ id: "a", preserveValue: true, view: "editor" }],
+    })
+    respondNext(dqlResult)
+    const summary = await run
+
+    expect(summary.unverified).toBe(true)
+    expect(summary.note).toMatch(/result was cleared/)
+    expect((await persistedView()).cells[0].lastRunStatus).toBeUndefined()
+    expect(await loadCellSnapshot(BUFFER_ID, "a")).toBeUndefined()
+  })
+
+  it("apply deletion prevents a headless run from launching after validation", async () => {
+    await seedNotebook({
+      cells: [cell("a", "SELECT 1"), cell("b", "SELECT 2")],
+    })
+    let resolveValidation!: (value: unknown) => void
+    const validation = new Promise((resolve) => {
+      resolveValidation = resolve
+    })
+    let validationStarted = false
+    const { quest, pending: inFlight } = makeQuest({
+      validate: () => {
+        validationStarted = true
+        return validation
+      },
+    })
+    const controller = makeController({}, quest)
+    const run = controller.runCell("a", undefined, undefined, {
+      kind: "autoRun",
+    })
+    await vi.waitFor(() => {
+      if (!validationStarted) throw new Error("validation not in flight")
+    })
+
+    await controller.applyNotebookState({
+      cells: [{ id: "b", preserveValue: true }],
+    })
+    resolveValidation(dqlValidation)
+
+    const summary = await run
+    expect(summary).toMatchObject({
+      success: false,
+      queryCount: 0,
+      results: [],
+      cancelled: "cell_deleted",
+    })
+    expect(summary.note).toMatch(/Run NOT started/)
+    expect(inFlight).toHaveLength(0)
+    expect((await persistedView()).cells.map(({ id }) => id)).toEqual(["b"])
+  })
+
   it("a superseded script never starts its remaining statements", async () => {
     // Given a slow write script whose first statement is already in flight
     await seedNotebook({
@@ -896,6 +1374,7 @@ describe("createDexieNotebookController — runCell", () => {
     // The cell disappears while the query is in flight (the queue is not held
     // during execution, so the delete lands before the commit).
     await controller.deleteCell("a")
+    expect(quest.abort).toHaveBeenCalledWith("q-1")
     respondNext(dqlResult)
     const summary = await pending
     expect(summary.unverified).toBe(true)
@@ -1089,7 +1568,7 @@ describe("createDexieNotebookController — runCell", () => {
     })
     // When the notebook is deleted (deleteBuffer clears run bookkeeping too)
     await db.buffers.delete(BUFFER_ID)
-    forgetHeadlessRuns(BUFFER_ID)
+    cancelHeadlessBufferRuns(BUFFER_ID, "notebook_deleted")
     respondNext(dqlResult)
     const summary = await run
     // Then the note names the real reason
@@ -1255,14 +1734,14 @@ describe("createDexieNotebookController — field preservation", () => {
 
   it("a headless run commit keeps the run cell's rich state and never touches siblings or settings", async () => {
     // Given a background notebook whose run cell "a" carries auto-refresh, a
-    // chart config, and view-maximize, a sibling "b" with its own chart, and
+    // chart config, and pane preference, a sibling "b" with its own chart, and
     // notebook-level variables + grid layout
     await seedNotebook({
       cells: [
         cell("a", "SELECT 1", {
           autoRefresh: "5s",
           chartConfig: chartFor("ts"),
-          isViewMaximized: true,
+          paneView: "result",
         }),
         cell("b", "SELECT 2", { position: 1, chartConfig: chartFor("sym") }),
       ],
@@ -1290,7 +1769,7 @@ describe("createDexieNotebookController — field preservation", () => {
     expect(a).toMatchObject({
       autoRefresh: "5s",
       chartConfig: chartFor("ts"),
-      isViewMaximized: true,
+      paneView: "result",
       lastRunStatus: "success",
     })
     // And the untouched sibling and notebook settings survive intact
@@ -1358,3 +1837,69 @@ describe("createDexieNotebookController — persisted snapshot cap", () => {
     })
   })
 })
+
+describe("createDexieNotebookController — result snapshot index", () => {
+  it("a status-free mutation never reads the result snapshot index", async () => {
+    // Given a background notebook and a spy on the index read
+    await seedNotebook({ cells: [cell("a", "SELECT 1")] })
+    const where = vi.spyOn(db.notebook_results, "where")
+    const controller = makeController()
+
+    // When routine mutations run
+    await controller.updateCell("a", { name: "renamed" })
+    await controller.updateCell("a", { value: "SELECT 2" })
+    await controller.mutate((p) => setLayoutModeTransition(p, "grid"))
+
+    // Then the index was never enumerated
+    expect(where).not.toHaveBeenCalled()
+    where.mockRestore()
+  })
+
+  it("a failing result snapshot index does not block a status-free mutation", async () => {
+    // Given the optional index rejects every read
+    await seedNotebook({ cells: [cell("a", "SELECT 1")] })
+    const where = vi
+      .spyOn(db.notebook_results, "where")
+      .mockImplementation(() => {
+        throw new Error("index down")
+      })
+    const controller = makeController()
+
+    // When an unrelated edit runs
+    await controller.updateCell("a", { name: "renamed" })
+
+    // Then the edit is durable
+    expect((await persistedView()).cells[0].name).toBe("renamed")
+    where.mockRestore()
+  })
+
+  it("a failing result snapshot index degrades a dimensions mutation instead of failing it", async () => {
+    // Given a run-marked cell and an index that rejects every read
+    await seedNotebook({
+      cells: [cell("a", "SELECT 1", { lastRunStatus: "success" })],
+    })
+    const where = vi
+      .spyOn(db.notebook_results, "where")
+      .mockImplementation(() => {
+        throw new Error("index down")
+      })
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined)
+    const controller = makeController()
+
+    // When a pane-sizing mutation asks for the cell's result status
+    const out = await controller.mutateWithResultStatus(
+      (parts, resultStatusOf) =>
+        setCellDimensionsTransition(parts, BUFFER_ID, "a", {
+          resultHeight: 200,
+          resultStatus: resultStatusOf("a"),
+        }),
+    )
+
+    // Then it commits with the stored arrangement and logs the degraded read
+    expect(out.view).toBe("editor_result")
+    expect((await persistedView()).cells[0].bottomHeight).toBe(200)
+    expect(warn).toHaveBeenCalledOnce()
+    where.mockRestore()
+    warn.mockRestore()
+  })
+})
diff --git a/src/utils/notebooks/notebookDexieView.test.ts b/src/utils/notebooks/notebookDexieView.test.ts
new file mode 100644
index 000000000..b0fae0044
--- /dev/null
+++ b/src/utils/notebooks/notebookDexieView.test.ts
@@ -0,0 +1,104 @@
+import { describe, expect, it } from "vitest"
+import type { NotebookViewState } from "../../store/notebook"
+import { migratePersistedNotebookView } from "./notebookDexieView"
+
+const legacyView = (isViewMaximized?: boolean): NotebookViewState =>
+  ({
+    cells: [
+      {
+        id: "c",
+        position: 0,
+        value: "SELECT 1",
+        ...(isViewMaximized !== undefined ? { isViewMaximized } : {}),
+      },
+    ],
+  }) as unknown as NotebookViewState
+
+describe("migratePersistedNotebookView preferred view", () => {
+  it.each([
+    [true, "result"],
+    [false, "editor_result"],
+    [undefined, "editor_result"],
+  ] as const)("maps main's isViewMaximized=%s to %s", (legacy, paneView) => {
+    const cell = migratePersistedNotebookView(legacyView(legacy)).cells[0]
+    expect(cell.paneView).toBe(paneView)
+    expect(cell).not.toHaveProperty("isViewMaximized")
+  })
+
+  it("removes pane preference state from markdown", () => {
+    const view = {
+      cells: [
+        {
+          id: "m",
+          position: 0,
+          value: "# Title",
+          type: "markdown",
+          paneView: "result",
+          isViewMaximized: true,
+        },
+      ],
+    } as unknown as NotebookViewState
+    const cell = migratePersistedNotebookView(view).cells[0]
+    expect(cell).not.toHaveProperty("paneView")
+    expect(cell).not.toHaveProperty("isViewMaximized")
+  })
+})
+
+describe("migratePersistedNotebookView markdown sub-state", () => {
+  it("strips SQL-only draw and result state from markdown", () => {
+    // Given a markdown cell an older import left carrying draw state
+    const view = {
+      cells: [
+        {
+          id: "m",
+          position: 0,
+          value: "# Title",
+          type: "markdown",
+          mode: "draw",
+          chartConfig: { xColumn: null, queries: [null] },
+          autoRefresh: 5000,
+          bottomHeight: 350,
+          bottomResized: true,
+          result: { results: [], activeResultIndex: 0, timestamp: 0 },
+          lastRunStatus: "success",
+          lastRunError: "boom",
+          topHeight: 86,
+        },
+      ],
+    } as unknown as NotebookViewState
+    // When the persisted view is migrated
+    const cell = migratePersistedNotebookView(view).cells[0]
+    // Then only markdown's own fields survive
+    expect(cell).toEqual({
+      id: "m",
+      position: 0,
+      value: "# Title",
+      type: "markdown",
+      topHeight: 86,
+    })
+  })
+
+  it("keeps draw state on a SQL cell", () => {
+    // Given a draw cell
+    const view = {
+      cells: [
+        {
+          id: "s",
+          position: 0,
+          value: "SELECT 1",
+          mode: "draw",
+          chartConfig: { xColumn: null, queries: [null] },
+          autoRefresh: 5000,
+          bottomHeight: 350,
+        },
+      ],
+    } as unknown as NotebookViewState
+    // When the persisted view is migrated
+    const cell = migratePersistedNotebookView(view).cells[0]
+    // Then its draw state is untouched
+    expect(cell.mode).toBe("draw")
+    expect(cell.chartConfig).toBeDefined()
+    expect(cell.autoRefresh).toBe(5000)
+    expect(cell.bottomHeight).toBe(350)
+  })
+})
diff --git a/src/utils/notebooks/notebookDexieView.ts b/src/utils/notebooks/notebookDexieView.ts
index c6894e21c..d2387828d 100644
--- a/src/utils/notebooks/notebookDexieView.ts
+++ b/src/utils/notebooks/notebookDexieView.ts
@@ -13,6 +13,7 @@ import type {
   NotebookSettings,
   NotebookViewState,
 } from "../../store/notebook"
+import { isCellPaneView } from "../../store/notebook"
 import { NotebookToolError } from "./notebookToolError"
 import { buildPersistPayload } from "../../scenes/Editor/Notebook/notebookUtils"
 
@@ -26,8 +27,45 @@ type NotebookBufferMeta =
   | { kind: "deleted" }
   | { kind: "not_a_notebook" }
 
-export const migratePersistedNotebookView = (view: NotebookViewState) =>
-  dropLegacyChartConfigs(migrateLegacyCellNames(view))
+// Main persisted `isViewMaximized`. Materialize the stored pane view and drop
+// the legacy key from the runtime view. A stored "editor" predates the
+// discard-on-editor model and normalizes to the split default. Markdown
+// carries no SQL sub-state: imports predating the type gate could persist
+// draw/result fields on prose, which would reserve a phantom result pane.
+const MARKDOWN_FOREIGN_FIELDS = [
+  "paneView",
+  "isViewMaximized",
+  "mode",
+  "chartConfig",
+  "autoRefresh",
+  "bottomHeight",
+  "bottomResized",
+  "result",
+  "lastRunStatus",
+  "lastRunError",
+] as const
+
+const migrateCellPaneView = (cell: NotebookCell): NotebookCell => {
+  const raw = cell as NotebookCell & Record<string, unknown>
+  if (cell.type === "markdown") {
+    const next = { ...raw }
+    for (const field of MARKDOWN_FOREIGN_FIELDS) delete next[field]
+    return next as NotebookCell
+  }
+  const paneView = isCellPaneView(raw.paneView)
+    ? raw.paneView
+    : raw.isViewMaximized === true
+      ? "result"
+      : "editor_result"
+  const next = { ...raw, paneView } as NotebookCell & Record<string, unknown>
+  delete next.isViewMaximized
+  return next as NotebookCell
+}
+
+export const migratePersistedNotebookView = (view: NotebookViewState) => {
+  const migrated = dropLegacyChartConfigs(migrateLegacyCellNames(view))
+  return { ...migrated, cells: migrated.cells.map(migrateCellPaneView) }
+}
 
 export const readNotebookBufferMeta = async (
   bufferId: number,
diff --git a/src/utils/notebooks/notebookHeadlessRun.ts b/src/utils/notebooks/notebookHeadlessRun.ts
index 6850d5dd3..724f112ff 100644
--- a/src/utils/notebooks/notebookHeadlessRun.ts
+++ b/src/utils/notebooks/notebookHeadlessRun.ts
@@ -23,6 +23,11 @@ import {
 import { statementRequestLimiter } from "../questdb/requestLimiter"
 import {
   buildInitialScriptResults,
+  cancelledBeforeLaunchSummary,
+  midRunCancellationNote,
+  runCancellationOf,
+  type RunCancellation,
+  type RunCancelReason,
   CELL_CHANGED_BEFORE_RUN_NOTE,
   CELL_CHANGED_MID_RUN_NOTE,
   CELL_DELETED_MID_RUN_NOTE,
@@ -35,7 +40,6 @@ import {
   singleResultFromExec,
   STORAGE_FULL_RUN_NOTE,
   summarizeCellResults,
-  SUPERSEDED_RUN_NOTE,
   USER_CHANGED_MID_RUN_NOTE,
 } from "../../scenes/Editor/Notebook/notebookUtils"
 import { persistCellSnapshot } from "../../scenes/Editor/Notebook/persistCellSnapshot"
@@ -78,55 +82,128 @@ type RunCommitOutcome =
         | "cell_gone"
         | "cell_changed"
         | "user_changed"
-        | "superseded"
         | "storage_full"
+        | RunCancellation
     }
 
-type ActiveHeadlessRun = {
+type HeadlessClaim = {
   controller: AbortController
+  generation: number
 }
 
-type HeadlessRunHandle = {
+type HeadlessCellClaims = {
+  claims: Set<HeadlessClaim>
+  nextGeneration: number
+  latestLaunchedGeneration: number
+}
+
+type HeadlessRunClaim = {
   signal: AbortSignal
+  launch: () => boolean
   isCurrent: () => boolean
-  finish: () => void
+  release: () => void
 }
 
-// Mirrors the live path's beginCellRun (useCellExecution): a newer headless run
-// of the same cell aborts the older run as well as superseding its result
-const activeHeadlessRuns = new Map<number, Map<string, ActiveHeadlessRun>>()
+// One claim covers a headless run's whole phase, validation through commit.
+// Cancellation reaches it through the signal, whose reason names the cause
+// (a transition, an archive, a supersession). Generations are assigned when
+// validation begins, but a claim becomes authoritative only when it launches:
+// a newer invocation that is denied or skipped must not cancel an in-flight
+// statement. Launching stops honouring the external signal so a statement
+// already in flight records its real outcome.
+const headlessClaims = new Map<number, Map<string, HeadlessCellClaims>>()
 
-const beginHeadlessRun = (
+const claimHeadlessRun = (
   bufferId: number,
   cellId: string,
-): HeadlessRunHandle => {
+  externalSignal?: AbortSignal,
+): HeadlessRunClaim => {
   const perBuffer =
-    activeHeadlessRuns.get(bufferId) ?? new Map<string, ActiveHeadlessRun>()
-  perBuffer.get(cellId)?.controller.abort()
-  const activeRun: ActiveHeadlessRun = {
+    headlessClaims.get(bufferId) ?? new Map<string, HeadlessCellClaims>()
+  const state = perBuffer.get(cellId) ?? {
+    claims: new Set<HeadlessClaim>(),
+    nextGeneration: 0,
+    latestLaunchedGeneration: 0,
+  }
+  const generation = state.nextGeneration + 1
+  const claim: HeadlessClaim = {
     controller: new AbortController(),
+    generation,
   }
-  perBuffer.set(cellId, activeRun)
-  activeHeadlessRuns.set(bufferId, perBuffer)
+  state.nextGeneration = generation
+  state.claims.add(claim)
+  perBuffer.set(cellId, state)
+  headlessClaims.set(bufferId, perBuffer)
+
+  const abortFromExternal = () => claim.controller.abort(externalSignal?.reason)
+  if (externalSignal?.aborted) abortFromExternal()
+  else
+    externalSignal?.addEventListener("abort", abortFromExternal, { once: true })
+  const stopExternal = () =>
+    externalSignal?.removeEventListener("abort", abortFromExternal)
+
   return {
-    signal: activeRun.controller.signal,
+    signal: claim.controller.signal,
+    launch: () => {
+      stopExternal()
+      if (
+        claim.controller.signal.aborted ||
+        claim.generation < state.latestLaunchedGeneration
+      ) {
+        if (!claim.controller.signal.aborted) {
+          claim.controller.abort("superseded" satisfies RunCancelReason)
+        }
+        return false
+      }
+
+      state.latestLaunchedGeneration = claim.generation
+      for (const older of state.claims) {
+        if (older.generation < claim.generation) {
+          older.controller.abort("superseded" satisfies RunCancelReason)
+        }
+      }
+      return true
+    },
     isCurrent: () =>
-      activeHeadlessRuns.get(bufferId)?.get(cellId) === activeRun,
-    finish: () => {
-      const currentPerBuffer = activeHeadlessRuns.get(bufferId)
-      if (currentPerBuffer?.get(cellId) !== activeRun) return
-      currentPerBuffer.delete(cellId)
-      if (currentPerBuffer.size === 0) activeHeadlessRuns.delete(bufferId)
+      !claim.controller.signal.aborted &&
+      claim.generation === state.latestLaunchedGeneration,
+    release: () => {
+      stopExternal()
+      state.claims.delete(claim)
+      if (state.claims.size === 0 && perBuffer.get(cellId) === state) {
+        perBuffer.delete(cellId)
+      }
+      if (perBuffer.size === 0 && headlessClaims.get(bufferId) === perBuffer) {
+        headlessClaims.delete(bufferId)
+      }
     },
   }
 }
 
-export const forgetHeadlessRuns = (bufferId: number): void => {
-  const perBuffer = activeHeadlessRuns.get(bufferId)
-  if (perBuffer) {
-    for (const run of perBuffer.values()) run.controller.abort()
+export const cancelHeadlessBufferRuns = (
+  bufferId: number,
+  reason: Extract<RunCancelReason, "notebook_archived" | "notebook_deleted">,
+): void => {
+  const perBuffer = headlessClaims.get(bufferId)
+  if (!perBuffer) return
+  for (const state of perBuffer.values()) {
+    for (const claim of state.claims) claim.controller.abort(reason)
+  }
+  headlessClaims.delete(bufferId)
+}
+
+export const cancelHeadlessCellRuns = (
+  bufferId: number,
+  cellIds: readonly string[],
+  reason: RunCancelReason,
+): void => {
+  const perBuffer = headlessClaims.get(bufferId)
+  if (!perBuffer) return
+  for (const cellId of cellIds) {
+    const state = perBuffer.get(cellId)
+    if (!state) continue
+    for (const claim of state.claims) claim.controller.abort(reason)
   }
-  activeHeadlessRuns.delete(bufferId)
 }
 
 const emptySummary = (): RunCellSummary => ({
@@ -357,26 +434,35 @@ export const runHeadlessCell = async (
 
   // The runner's barrier classification is the single decision for permission
   // enforcement, auto-run eligibility, and strategy — dispatch never
-  // classifies separately (live-path parity).
-  const validate = createValidateWithGlobals(quest, () => prep.variables)
-  const barrier = await resolveRunBarrier(
-    queryText,
-    queries.length,
-    gate,
-    (stmt) => statementRequestLimiter(() => validate(stmt, signal), signal),
-  )
-  if (signal?.aborted) return emptySummary()
-  if (barrier.action === "denied") {
-    return { ...emptySummary(), denied: barrier.reason }
-  }
-  if (barrier.action === "skipped") {
-    return { ...emptySummary(), skipped: barrier.reason }
-  }
-  const classified = barrier.classified
-
-  const run = beginHeadlessRun(bufferId, cellId)
-
+  // classifies separately (live-path parity). The claim opens the run's
+  // phase here, so a concurrent transition can stop it before it launches.
+  const claim = claimHeadlessRun(bufferId, cellId, signal)
   try {
+    const validate = createValidateWithGlobals(quest, () => prep.variables)
+    const barrier = await resolveRunBarrier(
+      queryText,
+      queries.length,
+      gate,
+      (stmt) =>
+        statementRequestLimiter(
+          () => validate(stmt, claim.signal),
+          claim.signal,
+        ),
+    )
+    if (claim.signal.aborted) {
+      return cancelledBeforeLaunchSummary(runCancellationOf(claim.signal))
+    }
+    if (barrier.action === "denied") {
+      return { ...emptySummary(), denied: barrier.reason }
+    }
+    if (barrier.action === "skipped") {
+      return { ...emptySummary(), skipped: barrier.reason }
+    }
+    const classified = barrier.classified
+
+    if (!claim.launch()) {
+      return cancelledBeforeLaunchSummary(runCancellationOf(claim.signal))
+    }
     // The queue is NOT held during execution, so runs on other cells of the
     // same notebook proceed in parallel; the commit re-reads and patches only
     // this cell.
@@ -388,7 +474,7 @@ export const runHeadlessCell = async (
             variables: prep.variables,
             quest,
             signal,
-            supersedeSignal: run.signal,
+            supersedeSignal: claim.signal,
           })
         : await executeCellQueries({
             queries,
@@ -396,7 +482,7 @@ export const runHeadlessCell = async (
             variables: prep.variables,
             quest,
             signal,
-            supersedeSignal: run.signal,
+            supersedeSignal: claim.signal,
           })
 
     const outcome = await enqueueBufferTask(
@@ -423,8 +509,8 @@ export const runHeadlessCell = async (
         if (getMountEpoch(bufferId) !== prep.mountEpochAtPrep) {
           return { committed: false, reason: "mounted" }
         }
-        if (!run.isCurrent()) {
-          return { committed: false, reason: "superseded" }
+        if (!claim.isCurrent()) {
+          return { committed: false, reason: runCancellationOf(claim.signal) }
         }
         // The user visited the notebook and edited or ran something while
         // this run was executing — their newer state wins over a stale result.
@@ -479,8 +565,6 @@ export const runHeadlessCell = async (
         return { ...summary, unverified: true, note: MOUNTED_MID_RUN_NOTE }
       case "user_changed":
         return { ...summary, unverified: true, note: USER_CHANGED_MID_RUN_NOTE }
-      case "superseded":
-        return { ...summary, unverified: true, note: SUPERSEDED_RUN_NOTE }
       case "cell_changed":
         return { ...summary, unverified: true, note: CELL_CHANGED_MID_RUN_NOTE }
       case "storage_full":
@@ -499,15 +583,22 @@ export const runHeadlessCell = async (
           unverified: true,
           note: NOTEBOOK_ARCHIVED_MID_RUN_NOTE,
         }
+      default:
+        return {
+          ...summary,
+          unverified: true,
+          cancelled: outcome.reason,
+          note: midRunCancellationNote(outcome.reason),
+        }
     }
   } finally {
-    run.finish()
+    claim.release()
   }
 }
 
 export const __resetNotebookHeadlessRunsForTests = (): void => {
-  for (const bufferId of activeHeadlessRuns.keys()) {
-    forgetHeadlessRuns(bufferId)
+  for (const bufferId of [...headlessClaims.keys()]) {
+    cancelHeadlessBufferRuns(bufferId, "notebook_deleted")
   }
   __resetBufferOwnershipForTests()
 }
diff --git a/src/utils/notebooks/notebookResultStatus.ts b/src/utils/notebooks/notebookResultStatus.ts
new file mode 100644
index 000000000..c4655c0b5
--- /dev/null
+++ b/src/utils/notebooks/notebookResultStatus.ts
@@ -0,0 +1,22 @@
+import type { CellResultStatusReader } from "../../scenes/Editor/Notebook/notebookUtils"
+import { loadSnapshotCellIds } from "../../store/notebookResults"
+
+// A passive notebook view persists only the run marker; the result payload
+// lives in notebook_results. Its per-buffer keys tell "exists" from "missing"
+// without loading payloads. The index is optional: when the read fails the
+// status degrades to "failed" and the caller carries on — the primary
+// document stays authoritative.
+export const loadPassiveResultStatusReader = async (
+  bufferId: number,
+): Promise<CellResultStatusReader> => {
+  try {
+    const snapshotCellIds = new Set(await loadSnapshotCellIds(bufferId))
+    return (cellId) => (snapshotCellIds.has(cellId) ? "unrequested" : "missing")
+  } catch (error) {
+    console.warn(
+      `notebook ${bufferId}: result snapshot index unavailable`,
+      error,
+    )
+    return () => "failed"
+  }
+}
diff --git a/src/utils/notebooks/notebookSnapshotCleanup.test.ts b/src/utils/notebooks/notebookSnapshotCleanup.test.ts
new file mode 100644
index 000000000..34b6b83d6
--- /dev/null
+++ b/src/utils/notebooks/notebookSnapshotCleanup.test.ts
@@ -0,0 +1,54 @@
+import { describe, expect, it, vi } from "vitest"
+import {
+  dropSnapshotsAfterPersist,
+  droppedSnapshotCellIds,
+  persistFailure,
+} from "./notebookSnapshotCleanup"
+import { NotebookToolError } from "./notebookToolError"
+
+describe("dropSnapshotsAfterPersist", () => {
+  it("drops the snapshots of deleted and discarded cells once the document write lands", async () => {
+    // Given a transition that deleted one cell and discarded another's result
+    const cellIds = droppedSnapshotCellIds({
+      cleanup: { cellIds: ["deleted"] },
+      deleteSnapshots: { cellIds: ["discarded"] },
+    })
+    const drop = vi.fn((_cellId: string) => Promise.resolve())
+
+    // When the document write succeeds
+    await dropSnapshotsAfterPersist(Promise.resolve(), cellIds, drop)
+
+    // Then both snapshots go
+    expect(drop.mock.calls.map(([cellId]) => cellId)).toEqual([
+      "deleted",
+      "discarded",
+    ])
+  })
+
+  it("keeps every snapshot when the document write fails", async () => {
+    // Given a write that fails, as a full local storage does
+    const drop = vi.fn((_cellId: string) => Promise.resolve())
+
+    // When the cleanup waits on it
+    await dropSnapshotsAfterPersist(
+      Promise.reject(new Error("QuotaExceededError")),
+      ["deleted"],
+      drop,
+    )
+
+    // Then no snapshot is dropped and the failure does not escape
+    expect(drop).not.toHaveBeenCalled()
+  })
+})
+
+describe("persistFailure", () => {
+  it("maps a failed write to the persist_failed tool error with its cause", () => {
+    // When a write failure is mapped for the agent
+    const error = persistFailure(new Error("QuotaExceededError"))
+
+    // Then the agent gets the typed code and the cause
+    expect(error).toBeInstanceOf(NotebookToolError)
+    expect(error.code).toBe("persist_failed")
+    expect(error.message).toContain("QuotaExceededError")
+  })
+})
diff --git a/src/utils/notebooks/notebookSnapshotCleanup.ts b/src/utils/notebooks/notebookSnapshotCleanup.ts
new file mode 100644
index 000000000..75abe6cb6
--- /dev/null
+++ b/src/utils/notebooks/notebookSnapshotCleanup.ts
@@ -0,0 +1,37 @@
+import type { NotebookTransitionResult } from "./notebookController"
+import { NotebookToolError } from "./notebookToolError"
+
+type SnapshotDrops = Pick<
+  NotebookTransitionResult<unknown>,
+  "cleanup" | "deleteSnapshots"
+>
+
+// Cells whose snapshot rows a transition drops: deleted cells, and cells whose
+// result it discarded.
+export const droppedSnapshotCellIds = (out: SnapshotDrops): string[] => [
+  ...(out.cleanup?.cellIds ?? []),
+  ...(out.deleteSnapshots?.cellIds ?? []),
+]
+
+// The document that stops referencing a snapshot must be durable before the
+// snapshot goes. A failed write keeps both, so a reload restores the previous
+// cell together with its result.
+export const dropSnapshotsAfterPersist = (
+  persisted: Promise<void>,
+  cellIds: string[],
+  drop: (cellId: string) => Promise<void>,
+): Promise<void> =>
+  persisted.then(
+    () => {
+      for (const cellId of cellIds) void drop(cellId)
+    },
+    () => undefined,
+  )
+
+export const persistFailure = (error: unknown): NotebookToolError =>
+  new NotebookToolError(
+    "persist_failed",
+    `The change is applied in the open notebook but was not saved: ${
+      error instanceof Error ? error.message : String(error)
+    }`,
+  )
diff --git a/src/utils/notebooks/notebookToolError.ts b/src/utils/notebooks/notebookToolError.ts
index c231ab0df..a4a52bf4c 100644
--- a/src/utils/notebooks/notebookToolError.ts
+++ b/src/utils/notebooks/notebookToolError.ts
@@ -11,6 +11,8 @@ export type NotebookToolErrorCode =
   | "last_cell"
   | "cell_limit"
   | "cell_too_large"
+  | "persist_failed"
+  | "validation"
 
 export class NotebookToolError extends Error {
   readonly code: NotebookToolErrorCode
diff --git a/src/utils/notebooks/notebookToolMessages.ts b/src/utils/notebooks/notebookToolMessages.ts
index 22f52f0a0..bf480788c 100644
--- a/src/utils/notebooks/notebookToolMessages.ts
+++ b/src/utils/notebooks/notebookToolMessages.ts
@@ -30,6 +30,10 @@ export const notebookErrorHint = (code: NotebookToolErrorCode): string => {
       return "The notebook is at its cell limit. Delete a cell first, or restructure with apply_notebook_state."
     case "cell_too_large":
       return "The value exceeds the per-cell line limit. Split it across multiple cells."
+    case "persist_failed":
+      return "The change is applied in the open notebook but was not saved to local storage. Tell the user to free up space (clear old query history or notebooks). Call get_notebook_state to re-sync; do not repeat the change."
+    case "validation":
+      return "Correct the invalid notebook field and retry."
     default:
       return "Notebook tool failed."
   }
diff --git a/src/utils/tools/applyNotebookState.ts b/src/utils/tools/applyNotebookState.ts
index 7a27ba26b..b386f9c9b 100644
--- a/src/utils/tools/applyNotebookState.ts
+++ b/src/utils/tools/applyNotebookState.ts
@@ -1,4 +1,5 @@
 import type { StatusCallback } from "../ai/aiAssistant"
+import type { RunCancellation } from "../../scenes/Editor/Notebook/notebookUtils"
 import { AIOperationStatus } from "../../providers/AIStatusProvider"
 import { getBufferActionSeq } from "../notebooks/notebookAIBridge"
 import { NotebookToolError } from "../notebooks/notebookToolError"
@@ -9,7 +10,12 @@ import {
   type ApplyNotebookStateCellRequest,
   type ApplyNotebookStateRequest,
 } from "../notebooks/notebookController"
-import type { CellMode, CellType, NotebookVariable } from "../../store/notebook"
+import type {
+  AgentCellView,
+  CellMode,
+  CellType,
+  NotebookVariable,
+} from "../../store/notebook"
 import type { ChartConfig } from "../../scenes/Editor/Notebook/CellChart/chartTypes"
 import {
   denyReasonUnresolvedSql,
@@ -17,7 +23,10 @@ import {
   type PermissionDecision,
   type Permissions,
 } from "./permissions"
-import { isAutoRefresh } from "../../scenes/Editor/Notebook/notebookUtils"
+import {
+  hasExplicitModeForEditor,
+  isAutoRefresh,
+} from "../../scenes/Editor/Notebook/notebookUtils"
 import type { ValidateQueryResult } from "../questdb/types"
 import {
   isValidVariableName,
@@ -52,7 +61,7 @@ const validationError = (message: string): ToolResult => ({
 
 const validateApplyVariables = async (
   variables: NotebookVariable[] | null | undefined,
-  validateSql: ((sql: string) => Promise<ValidateQueryResult>) | undefined,
+  validateSql: (sql: string) => Promise<ValidateQueryResult>,
 ): Promise<ToolResult | null> => {
   if (
     variables !== undefined &&
@@ -98,16 +107,14 @@ const validateApplyVariables = async (
       )
     }
   }
-  if (validateSql) {
-    for (let idx = 0; idx < variables.length; idx += 1) {
-      const result = await validateSql(
-        renderDeclareValidationQuery(variables.slice(0, idx + 1)),
+  for (let idx = 0; idx < variables.length; idx += 1) {
+    const result = await validateSql(
+      renderDeclareValidationQuery(variables.slice(0, idx + 1)),
+    )
+    if ("error" in result) {
+      return validationError(
+        `variables[${idx}] (${variables[idx].name}) failed QuestDB validation: ${result.error}`,
       )
-      if ("error" in result) {
-        return validationError(
-          `variables[${idx}] (${variables[idx].name}) failed QuestDB validation: ${result.error}`,
-        )
-      }
     }
   }
   return null
@@ -125,6 +132,7 @@ type RunEntry = {
   queryCount?: number
   results?: string[]
   error?: string
+  cancelled?: RunCancellation
   unverified?: boolean
   note?: string
   skipped?: boolean
@@ -133,8 +141,8 @@ type RunEntry = {
 const runAppliedCells = async (
   resolved: ResolvedRun[],
   bufferId: number,
-  perms: Permissions | undefined,
-  validateSql: ((sql: string) => Promise<ValidateQueryResult>) | undefined,
+  perms: Permissions,
+  validateSql: (sql: string) => Promise<ValidateQueryResult>,
   signal: AbortSignal | undefined,
 ): Promise<RunEntry[]> => {
   const settled = await Promise.all(
@@ -146,12 +154,7 @@ const runAppliedCells = async (
         const result = await withBoundNotebook(
           bufferId,
           (ctrl) =>
-            ctrl.runCell(
-              r.cellId,
-              signal,
-              perms && validateSql ? r.value : undefined,
-              perms && validateSql ? { kind: "autoRun" } : undefined,
-            ),
+            ctrl.runCell(r.cellId, signal, r.value, { kind: "autoRun" }),
           signal,
         )
         if (result.denied !== undefined) {
@@ -170,6 +173,9 @@ const runAppliedCells = async (
           success: result.success,
           queryCount: result.queryCount,
           results: result.results,
+          ...(result.cancelled !== undefined
+            ? { cancelled: result.cancelled }
+            : {}),
           ...(result.unverified ? { unverified: result.unverified } : {}),
           ...(result.note ? { note: result.note } : {}),
         }
@@ -189,8 +195,8 @@ const runAppliedCells = async (
 export const dispatchApplyNotebookState = async (
   input: unknown,
   setStatus: StatusCallback,
-  perms: Permissions | undefined,
-  validateSql: ((sql: string) => Promise<ValidateQueryResult>) | undefined,
+  perms: Permissions,
+  validateSql: (sql: string) => Promise<ValidateQueryResult>,
   signal: AbortSignal | undefined,
   toolContext: ToolExecutionContext | undefined,
 ): Promise<{ content: string; is_error?: boolean }> => {
@@ -216,13 +222,15 @@ export const dispatchApplyNotebookState = async (
         type?: "sql" | "markdown" | null
         mode?: CellMode | null
         auto_refresh?: boolean | string | null
-        is_view_maximized?: boolean | null
+        editor_height?: number | "auto" | null
+        result_height?: number | "auto" | null
+        view?: AgentCellView | null
         chart_config?: {
           x_column?: string | null
           queries?: (ToolQueryChart | null)[] | null
           right_axis?: ToolRightAxis | null
         } | null
-        grid?: { x: number; y: number; w: number; h: number } | null
+        grid?: { x: number; y: number; w: number } | null
       }>
     }) || {}
   setStatus(AIOperationStatus.BuildingNotebook)
@@ -268,6 +276,18 @@ export const dispatchApplyNotebookState = async (
     }
   }
   for (const [idx, c] of cells.entries()) {
+    if (hasExplicitModeForEditor(c.mode, c.view)) {
+      return {
+        content: JSON.stringify({
+          error_code: "validation",
+          message:
+            `VALIDATION_ERROR: cells[${idx}].view "editor" cannot be combined with ` +
+            `an explicit mode. Editor view clears the stored result and hides the result pane. ` +
+            `Set mode to null to request an editor-only view.`,
+        }),
+        is_error: true,
+      }
+    }
     if (
       c.auto_refresh !== undefined &&
       c.auto_refresh !== null &&
@@ -337,40 +357,39 @@ export const dispatchApplyNotebookState = async (
   // Shared by the draw-invariant gate (below) and the post-apply
   // auto-run loop's mode resolution.
   const existingModes = new Map<string, CellMode | undefined>()
-  if (validateSql) {
-    const preApplyBasics = await readBasics()
-    for (const c of cells) {
-      if (typeof c.id !== "string" || c.id.length === 0) continue
-      const existing = preApplyBasics.get(c.id)
-      // Unknown ids fall through so applyNotebookState's all-or-nothing
-      // validation surfaces the precise error.
-      if (existing) existingModes.set(c.id, existing.mode)
-    }
-    const drawCells = cells.filter((c) => {
-      const resolved =
-        c.mode === undefined || c.mode === null
-          ? typeof c.id === "string"
-            ? existingModes.get(c.id)
-            : undefined
-          : c.mode
-      return resolved === "draw"
-    })
-    const decisions = await Promise.all(
-      drawCells.map(async (c): Promise<PermissionDecision> => {
-        const sql = resolveCellSql(c, preApplyBasics)
-        if (sql === null) {
-          return {
-            granted: false,
-            reason: denyReasonUnresolvedSql("apply_notebook_state"),
-          }
+  const preApplyBasics = await readBasics()
+  for (const c of cells) {
+    if (typeof c.id !== "string" || c.id.length === 0) continue
+    const existing = preApplyBasics.get(c.id)
+    // Unknown ids fall through so applyNotebookState's all-or-nothing
+    // validation surfaces the precise error.
+    if (existing) existingModes.set(c.id, existing.mode)
+  }
+  const drawCells = cells.filter((c) => {
+    if (c.view === "editor") return false
+    const resolved =
+      c.mode === undefined || c.mode === null
+        ? typeof c.id === "string"
+          ? existingModes.get(c.id)
+          : undefined
+        : c.mode
+    return resolved === "draw"
+  })
+  const decisions = await Promise.all(
+    drawCells.map(async (c): Promise<PermissionDecision> => {
+      const sql = resolveCellSql(c, preApplyBasics)
+      if (sql === null) {
+        return {
+          granted: false,
+          reason: denyReasonUnresolvedSql("apply_notebook_state"),
         }
-        return requireAllDQL(sql, validateSql)
-      }),
-    )
-    const denied = decisions.find((d) => !d.granted)
-    if (denied && !denied.granted) {
-      return { content: denied.reason, is_error: true }
-    }
+      }
+      return requireAllDQL(sql, validateSql)
+    }),
+  )
+  const denied = decisions.find((d) => !d.granted)
+  if (denied && !denied.granted) {
+    return { content: denied.reason, is_error: true }
   }
   const request: ApplyNotebookStateRequest = {
     layoutMode: layout_mode ?? null,
@@ -389,8 +408,9 @@ export const dispatchApplyNotebookState = async (
       if (c.type === "sql" || c.type === "markdown") cell.type = c.type
       if (c.mode !== undefined && c.mode !== null) cell.mode = c.mode
       if (isAutoRefresh(c.auto_refresh)) cell.autoRefresh = c.auto_refresh
-      if (c.is_view_maximized !== undefined && c.is_view_maximized !== null)
-        cell.isViewMaximized = c.is_view_maximized
+      if (c.editor_height !== undefined) cell.editorHeight = c.editor_height
+      if (c.result_height !== undefined) cell.resultHeight = c.result_height
+      if (c.view !== undefined) cell.view = c.view
       if (c.chart_config) {
         const cfg = c.chart_config
         const chartConfig: ChartConfig = {
@@ -428,7 +448,9 @@ export const dispatchApplyNotebookState = async (
     committed = await withBoundNotebook(
       buffer_id,
       (ctrl) =>
-        ctrl.mutate((parts) => applyNotebookStateTransition(parts, request)),
+        ctrl.mutateWithResultStatus((parts, resultStatusOf) =>
+          applyNotebookStateTransition(parts, request, resultStatusOf),
+        ),
       signal,
     )
     const out = committed
@@ -456,6 +478,7 @@ export const dispatchApplyNotebookState = async (
       // notebook and never auto-run prose as SQL.
       const isMarkdown = postApplyBasics.get(cellId)?.type === "markdown"
       const runnable =
+        c.view !== "editor" &&
         !isMarkdown &&
         resolvedMode === "run" &&
         value !== null &&
diff --git a/src/utils/tools/dispatch.test.ts b/src/utils/tools/dispatch.test.ts
index 31522794f..bd2ede807 100644
--- a/src/utils/tools/dispatch.test.ts
+++ b/src/utils/tools/dispatch.test.ts
@@ -4,9 +4,18 @@ import { dispatchTool } from "./dispatch"
 import { executeTool } from "../ai/shared"
 import type { ModelToolsClient, StatusCallback } from "../ai/aiAssistant"
 import type { Table } from "../questdb/types"
+import type { Permissions } from "./permissions"
 
 const UNSAFE_ROW_COUNT = BigInt("9007199254740993")
 
+const ALL_GRANTED: Permissions = {
+  grantSchemaAccess: true,
+  read: true,
+  write: true,
+}
+const dqlValidator = () =>
+  Promise.resolve({ query: "", columns: [], timestamp: 0 })
+
 const tableWithBigIntCounters = (): Table =>
   ({
     table_name: "trades",
@@ -31,6 +40,8 @@ const toolSurfaces = [
         { table_name: "trades" },
         client,
         ignoreStatus,
+        ALL_GRANTED,
+        dqlValidator,
       ),
   },
   {
diff --git a/src/utils/tools/dispatch.ts b/src/utils/tools/dispatch.ts
index 353da3465..7af5f0c9e 100644
--- a/src/utils/tools/dispatch.ts
+++ b/src/utils/tools/dispatch.ts
@@ -8,7 +8,11 @@ import {
 } from "../questdbDocsRetrieval"
 import { getBufferActionSeq } from "../notebooks/notebookAIBridge"
 import { NotebookToolError } from "../notebooks/notebookToolError"
-import type { CellMode, NotebookCell } from "../../store/notebook"
+import type {
+  AgentCellView,
+  CellMode,
+  NotebookCell,
+} from "../../store/notebook"
 import {
   MAX_CELL_NAME_LENGTH,
   exceedsCellNameLimit,
@@ -69,10 +73,10 @@ import {
   moveCellDownTransition,
   moveCellUpTransition,
   setCellChartConfigTransition,
+  setCellDimensionsTransition,
   setCellLayoutTransition,
   setCellMaximizedTransition,
   setCellModeTransition,
-  setCellViewMaximizedTransition,
   setLayoutModeTransition,
   setNotebookAutoRefreshTransition,
   updateCellTransition,
@@ -80,10 +84,12 @@ import {
   type NotebookTransitionResult,
 } from "../notebooks/notebookController"
 import {
+  loadNotebookResultStatusReader,
   readNotebookState,
   serializeCell,
   summarizeCells,
 } from "../ai/notebookSnapshot"
+import type { CellResultStatusReader } from "../../scenes/Editor/Notebook/notebookUtils"
 import { generateId } from "../../scenes/Editor/Notebook/notebookUtils"
 import {
   copyNotebookSnapshots,
@@ -94,6 +100,19 @@ import {
 // every mutation takes. The transition validates and throws typed errors
 // identically on both routes.
 class NotebookStateChangedError extends Error {}
+class DuplicateSourceChangedError extends Error {}
+
+const requireUnchangedSince = (
+  bufferId: number,
+  expectedActionSeq: number | undefined,
+): void => {
+  if (
+    expectedActionSeq !== undefined &&
+    getBufferActionSeq(bufferId) !== expectedActionSeq
+  ) {
+    throw new NotebookStateChangedError()
+  }
+}
 
 const runTransition = <T>(
   bufferId: number,
@@ -104,17 +123,26 @@ const runTransition = <T>(
   withBoundNotebook(
     bufferId,
     (ctrl) => {
-      if (
-        expectedActionSeq !== undefined &&
-        getBufferActionSeq(bufferId) !== expectedActionSeq
-      ) {
-        throw new NotebookStateChangedError()
-      }
+      requireUnchangedSince(bufferId, expectedActionSeq)
       return ctrl.mutate(transition)
     },
     signal,
   )
 
+const runTransitionWithResultStatus = <T>(
+  bufferId: number,
+  transition: (
+    parts: ViewParts,
+    resultStatusOf: CellResultStatusReader,
+  ) => NotebookTransitionResult<T>,
+  signal?: AbortSignal,
+): Promise<T> =>
+  withBoundNotebook(
+    bufferId,
+    (ctrl) => ctrl.mutateWithResultStatus(transition),
+    signal,
+  )
+
 // Reads the bound notebook's cells without moving the user's tab.
 const readCells = (
   bufferId: number,
@@ -163,7 +191,10 @@ const routeNotebookTool = async <T>(
         is_error: true,
         content: JSON.stringify({
           error_code: e.code,
-          message: e.message,
+          message:
+            e.code === "validation"
+              ? `VALIDATION_ERROR: ${e.message}`
+              : e.message,
           hint: notebookErrorHint(e.code),
         }),
       }
@@ -185,8 +216,8 @@ const dispatchRunQuery = async (
   input: unknown,
   modelToolsClient: ModelToolsClient,
   setStatus: StatusCallback,
-  perms: Permissions | undefined,
-  validateSql: ((sql: string) => Promise<ValidateQueryResult>) | undefined,
+  perms: Permissions,
+  validateSql: (sql: string) => Promise<ValidateQueryResult>,
   signal: AbortSignal | undefined,
   toolContext: ToolExecutionContext | undefined,
 ): Promise<{ content: string; is_error?: boolean }> => {
@@ -200,15 +231,9 @@ const dispatchRunQuery = async (
       is_error: true,
     }
   }
-  if (perms && validateSql) {
-    const decision = await classifyAndCheckSqlForRunQuery(
-      sql,
-      perms,
-      validateSql,
-    )
-    if (!decision.granted) {
-      return { content: decision.reason, is_error: true }
-    }
+  const decision = await classifyAndCheckSqlForRunQuery(sql, perms, validateSql)
+  if (!decision.granted) {
+    return { content: decision.reason, is_error: true }
   }
   let formattedSql = sql
   try {
@@ -261,22 +286,20 @@ export const dispatchTool = async (
   input: unknown,
   modelToolsClient: ModelToolsClient,
   setStatus: StatusCallback,
-  permsOrResolver?: Permissions | (() => Permissions),
-  validateSql?: (sql: string) => Promise<ValidateQueryResult>,
+  permsOrResolver: Permissions | (() => Permissions),
+  validateSql: (sql: string) => Promise<ValidateQueryResult>,
   signal?: AbortSignal,
   toolContext?: ToolExecutionContext,
 ): Promise<{ content: string; is_error?: boolean }> => {
   const perms =
     typeof permsOrResolver === "function" ? permsOrResolver() : permsOrResolver
 
-  if (perms) {
-    const decision = runPermissionGate(toolName, {
-      permissions: perms,
-      categoryFor,
-    })
-    if (!decision.granted) {
-      return { content: decision.reason, is_error: true }
-    }
+  const gate = runPermissionGate(toolName, {
+    permissions: perms,
+    categoryFor,
+  })
+  if (!gate.granted) {
+    return { content: gate.reason, is_error: true }
   }
   if (toolContext && mutatesNotebook(toolName)) {
     toolContext.notebookMutated = true
@@ -498,7 +521,7 @@ export const dispatchTool = async (
           )
           return {
             ...res,
-            hint: "Duplicated in the background — the tab was not switched. The user is notified and can open it. Only call activate_notebook if they explicitly ask to be taken there.",
+            hint: "Duplicated in the background — the tab was not switched. Run history is preserved; matching saved result snapshots copy best-effort in the background and hydrate when opened. The user is notified and can open it. Only call activate_notebook if they explicitly ask to be taken there.",
           }
         })
       }
@@ -515,10 +538,17 @@ export const dispatchTool = async (
         return routeNotebookTool(async () => ({
           cells: await withBoundNotebookReadOnly(
             buffer_id,
-            (view, controller) =>
-              Promise.resolve(
-                summarizeCells(view.cells, controller?.readRefreshState?.()),
-              ),
+            async (view, controller) => {
+              const resultStatusOf = await loadNotebookResultStatusReader(
+                buffer_id,
+                controller,
+              )
+              return summarizeCells(
+                view.cells,
+                controller?.readRefreshState?.(),
+                resultStatusOf,
+              )
+            },
             signal,
           ),
         }))
@@ -534,16 +564,20 @@ export const dispatchTool = async (
         return routeNotebookTool(() =>
           withBoundNotebookReadOnly(
             buffer_id,
-            (view, controller) =>
-              Promise.resolve(
-                serializeCell(
-                  view.cells,
-                  cell_id,
-                  buffer_id,
-                  get_full_content === true,
-                  controller?.readRefreshState?.(),
-                ),
-              ),
+            async (view, controller) => {
+              const resultStatusOf = await loadNotebookResultStatusReader(
+                buffer_id,
+                controller,
+              )
+              return serializeCell(
+                view.cells,
+                cell_id,
+                buffer_id,
+                get_full_content === true,
+                controller?.readRefreshState?.(),
+                resultStatusOf(cell_id),
+              )
+            },
             signal,
           ),
         )
@@ -596,13 +630,9 @@ export const dispatchTool = async (
             setStatus(AIOperationStatus.RunningCell, { cellId })
             // The runner's barrier classification decides auto-run
             // eligibility — writes are skipped at launch, never pre-checked.
-            const r = await runCellBound(
-              buffer_id,
-              cellId,
-              signal,
-              perms && validateSql ? sql : undefined,
-              perms && validateSql ? { kind: "autoRun" } : undefined,
-            )
+            const r = await runCellBound(buffer_id, cellId, signal, sql, {
+              kind: "autoRun",
+            })
             if (r.denied !== undefined) {
               return { cellId, ran: false, error: r.denied }
             }
@@ -614,6 +644,7 @@ export const dispatchTool = async (
               ran: r.success,
               queryCount: r.queryCount,
               results: r.results,
+              ...(r.cancelled !== undefined ? { cancelled: r.cancelled } : {}),
               ...(r.unverified ? { unverified: r.unverified } : {}),
               ...(r.note ? { note: r.note } : {}),
             }
@@ -632,15 +663,13 @@ export const dispatchTool = async (
         const updateBaseline =
           toolContext?.notebookFreshness?.getReadSeq(buffer_id) ??
           getBufferActionSeq(buffer_id)
-        if (validateSql) {
-          const current = (await readCells(buffer_id, signal)).find(
-            (c) => c.id === cell_id,
-          )
-          if (current?.mode === "draw") {
-            const decision = await requireAllDQL(value, validateSql)
-            if (!decision.granted) {
-              return { content: decision.reason, is_error: true }
-            }
+        const current = (await readCells(buffer_id, signal)).find(
+          (c) => c.id === cell_id,
+        )
+        if (current?.mode === "draw") {
+          const decision = await requireAllDQL(value, validateSql)
+          if (!decision.granted) {
+            return { content: decision.reason, is_error: true }
           }
         }
         // The read above awaits a round-trip; re-check the baseline so a user
@@ -730,19 +759,34 @@ export const dispatchTool = async (
             }
           }
 
+          const duplicateCurrentCell = (guardCopiedSnapshot: boolean) =>
+            runTransition(
+              buffer_id,
+              (parts) => {
+                if (
+                  guardCopiedSnapshot &&
+                  controller?.kind === "live" &&
+                  parts.cells.find((cell) => cell.id === cell_id) !== sourceCell
+                ) {
+                  throw new DuplicateSourceChangedError()
+                }
+                return duplicateCellTransition(parts, buffer_id, cell_id, newId)
+              },
+              signal,
+              seqBeforeRead,
+            )
+
           try {
             return {
-              cellId: await runTransition(
-                buffer_id,
-                (parts) =>
-                  duplicateCellTransition(parts, buffer_id, cell_id, newId),
-                signal,
-                seqBeforeRead,
-              ),
+              cellId: await duplicateCurrentCell(snapshotsCopied > 0),
             }
           } catch (error) {
             if (snapshotsCopied > 0) {
               await deleteCellSnapshot(buffer_id, newId).catch(() => undefined)
+              snapshotsCopied = 0
+            }
+            if (error instanceof DuplicateSourceChangedError) {
+              return { cellId: await duplicateCurrentCell(false) }
             }
             throw error
           }
@@ -766,39 +810,36 @@ export const dispatchTool = async (
             }),
           )
         }
-        if (perms && validateSql) {
-          if (value === null) {
-            return {
-              content: denyReasonUnresolvedSql("run_cell"),
-              is_error: true,
-            }
+        if (value === null) {
+          return {
+            content: denyReasonUnresolvedSql("run_cell"),
+            is_error: true,
           }
-          // The runner's barrier classification enforces the permission — one
-          // classification per launch, shared with strategy selection.
-          let deniedReason: string | undefined
-          const routed = await routeNotebookTool(async () => {
-            const summary = await runCellBound(
-              buffer_id,
-              cell_id,
-              signal,
-              value,
-              {
-                kind: "explicit",
-                permissions: perms,
-              },
-            )
-            if (summary.denied !== undefined) {
-              deniedReason = summary.denied
-              return {}
-            }
-            return summary
-          })
-          if (deniedReason !== undefined) {
-            return { content: deniedReason, is_error: true }
+        }
+        // The runner's barrier classification enforces the permission — one
+        // classification per launch, shared with strategy selection.
+        let deniedReason: string | undefined
+        const routed = await routeNotebookTool(async () => {
+          const summary = await runCellBound(
+            buffer_id,
+            cell_id,
+            signal,
+            value,
+            {
+              kind: "explicit",
+              permissions: perms,
+            },
+          )
+          if (summary.denied !== undefined) {
+            deniedReason = summary.denied
+            return {}
           }
-          return routed
+          return summary
+        })
+        if (deniedReason !== undefined) {
+          return { content: deniedReason, is_error: true }
         }
-        return routeNotebookTool(() => runCellBound(buffer_id, cell_id, signal))
+        return routed
       }
       case "set_layout_mode": {
         const { buffer_id, mode } =
@@ -813,25 +854,48 @@ export const dispatchTool = async (
         )
       }
       case "set_cell_layout": {
-        const { buffer_id, cell_id, x, y, w, h } =
+        const { buffer_id, cell_id, x, y, w } =
           (input as {
             buffer_id: number
             cell_id: string
             x: number
             y: number
             w: number
-            h: number
           }) || {}
         setStatus(AIOperationStatus.ConfiguringLayout, { cellId: cell_id })
         return routeNotebookTool(() =>
-          runTransition(
+          runTransitionWithResultStatus(
             buffer_id,
-            (parts) =>
+            (parts, resultStatusOf) =>
               setCellLayoutTransition(parts, buffer_id, cell_id, {
                 x,
                 y,
                 w,
-                h,
+                resultStatus: resultStatusOf(cell_id),
+              }),
+            signal,
+          ),
+        )
+      }
+      case "set_cell_dimensions": {
+        const { buffer_id, cell_id, editor_height, result_height, view } =
+          (input as {
+            buffer_id: number
+            cell_id: string
+            editor_height: number | "auto" | null
+            result_height: number | "auto" | null
+            view: AgentCellView | null
+          }) || {}
+        setStatus(AIOperationStatus.ConfiguringLayout, { cellId: cell_id })
+        return routeNotebookTool(() =>
+          runTransitionWithResultStatus(
+            buffer_id,
+            (parts, resultStatusOf) =>
+              setCellDimensionsTransition(parts, buffer_id, cell_id, {
+                editorHeight: editor_height,
+                resultHeight: result_height,
+                view,
+                resultStatus: resultStatusOf(cell_id),
               }),
             signal,
           ),
@@ -847,16 +911,23 @@ export const dispatchTool = async (
         setStatus(AIOperationStatus.ConfiguringLayout, { cellId: cell_id })
         const modeBaseline = getBufferActionSeq(buffer_id)
         if (mode === "draw" && validateSql) {
-          const cellSql = await cellValueOf(buffer_id, cell_id, signal)
-          if (cellSql === null) {
-            return {
-              content: denyReasonUnresolvedSql("set_cell_mode"),
-              is_error: true,
+          const modeCell = (await readCells(buffer_id, signal)).find(
+            (c) => c.id === cell_id,
+          )
+          // Markdown holds prose, not SQL: the transition rejects it with the
+          // typed error instead of a misleading DQL verdict on the prose.
+          if (modeCell?.type !== "markdown") {
+            const cellSql = modeCell?.value ?? null
+            if (cellSql === null) {
+              return {
+                content: denyReasonUnresolvedSql("set_cell_mode"),
+                is_error: true,
+              }
+            }
+            const decision = await requireAllDQL(cellSql, validateSql)
+            if (!decision.granted) {
+              return { content: decision.reason, is_error: true }
             }
-          }
-          const decision = await requireAllDQL(cellSql, validateSql)
-          if (!decision.granted) {
-            return { content: decision.reason, is_error: true }
           }
         }
         return routeNotebookTool(
@@ -1039,23 +1110,6 @@ export const dispatchTool = async (
           ),
         )
       }
-      case "set_cell_view_maximized": {
-        const { buffer_id, cell_id, value } =
-          (input as {
-            buffer_id: number
-            cell_id: string
-            value: boolean
-          }) || {}
-        setStatus(AIOperationStatus.ConfiguringChart, { cellId: cell_id })
-        return routeNotebookTool(() =>
-          runTransition(
-            buffer_id,
-            (parts) =>
-              setCellViewMaximizedTransition(parts, buffer_id, cell_id, value),
-            signal,
-          ),
-        )
-      }
       case "apply_notebook_state": {
         return dispatchApplyNotebookState(
           input,