diff --git a/e2e/questdb b/e2e/questdb
index b4afea3ea..090a22720 160000
--- a/e2e/questdb
+++ b/e2e/questdb
@@ -1 +1 @@
-Subproject commit b4afea3eaf80630654a5f6ff178a71692e18c41c
+Subproject commit 090a2272082337f5f986b80e348f9e9d659ab08f
diff --git a/src/consts/shared-definitions.json b/src/consts/shared-definitions.json
index 9432c14f1..a946010ab 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,
@@ -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` is the cell's pane view for SQL/draw cells: editor, result, or editor_result. A cell without an available 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. 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` is the cell's pane view for SQL/draw cells: editor, result, or editor_result. A cell without an available 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. 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 and the cell's `view`; markdown reports `view` as 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. A cell without an available result shows only the editor until one exists; that never rewrites `view`. The response reports the cell's `view`. Markdown has no pane-view state: it reports `view` 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: editor, result, or editor_result. Null preserves. A cell without an available result shows only the editor until one exists; that never rewrites view."
         }
       },
-      "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,7 +864,7 @@
               "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"],
@@ -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: editor, result, or editor_result. Null preserves an existing setting. New draw cells default to result; other new SQL cells default to editor_result but display editor until a result exists. An unavailable result shows only the editor until one exists; that never rewrites view. 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, result, or editor_result; a cell without a result shows only the editor until one exists. Markdown reports `view` 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..fc8dc9960 100644
--- a/src/scenes/Editor/Monaco/importTabs.test.ts
+++ b/src/scenes/Editor/Monaco/importTabs.test.ts
@@ -775,6 +775,36 @@ 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: "editor" },
+            { id: "legacy-on", value: "SELECT 2", isViewMaximized: true },
+            { id: "legacy-off", value: "SELECT 3", isViewMaximized: false },
+            {
+              id: "markdown",
+              value: "# Title",
+              type: "markdown",
+              paneView: "result",
+            },
+          ],
+        },
+      }
+
+      const cells = sanitizeBuffer(input).notebookViewState?.cells
+      expect(cells?.map((cell) => cell.paneView)).toEqual([
+        "editor",
+        "result",
+        "editor_result",
+        undefined,
+      ])
+      expect(cells?.every((cell) => !("isViewMaximized" in cell))).toBe(true)
+    })
+
     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..85de352e6 100644
--- a/src/scenes/Editor/Monaco/importTabs.ts
+++ b/src/scenes/Editor/Monaco/importTabs.ts
@@ -18,9 +18,10 @@ import type {
   NotebookViewState,
 } from "../../../store/notebook"
 import type { ChartConfig, QueryChart } from "../Notebook/CellChart/chartTypes"
-import { isAutoRefresh } from "../Notebook/notebookUtils"
+import { isAutoRefresh, MAX_PANE_HEIGHT_PX } from "../Notebook/notebookUtils"
 import { LINE_NUMBER_HARD_LIMIT } from "./index"
 import {
+  isAgentCellView,
   MAX_NOTEBOOK_CELLS,
   MAX_CELL_LINES,
   MAX_CELL_NAME_LENGTH,
@@ -271,11 +272,22 @@ const sanitizeNotebookCell = (
   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
+  if (item.type !== "markdown") {
+    if (isAgentCellView(item.paneView)) {
+      cell.paneView = item.paneView
+    } else if (item.isViewMaximized === true) {
+      cell.paneView = "result"
+    } else {
+      cell.paneView = "editor_result"
+    }
+  }
+  if (typeof item.topHeight === "number" && Number.isFinite(item.topHeight))
+    cell.topHeight = Math.min(MAX_PANE_HEIGHT_PX, item.topHeight)
+  if (
+    typeof item.bottomHeight === "number" &&
+    Number.isFinite(item.bottomHeight)
+  )
+    cell.bottomHeight = Math.min(MAX_PANE_HEIGHT_PX, 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..4547bbfed 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 { withZoomSlider } from "./buildEchartsOption"
+import { snapChartWidth } from "./chartDensity"
 import { createQuestdbTheme } from "./questdbTheme"
 import { useNotebookBufferId } from "../NotebookProvider"
 import {
@@ -93,6 +97,7 @@ export const ChartRenderer = React.forwardRef<ChartRendererHandle, Props>(
     const reactEchartsRef = useRef<ReactECharts | null>(null)
     const wrapperRef = useRef<HTMLDivElement | null>(null)
     const zoomWindowRef = useRef(zoomWindow)
+    const [measuredWidth, setMeasuredWidth] = useState(0)
     // Decided once per mount: a chart mounting into an already-settled
     // notebook (scroll remount) skips the entry animation.
     const animateEntryRef = useRef(
@@ -128,7 +133,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)
+        if (box.width > 0) setMeasuredWidth(snapChartWidth(box.width))
       })
       observer.observe(wrapper)
 
@@ -186,14 +193,27 @@ 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) setMeasuredWidth(snapChartWidth(width))
+    }, [])
+
+    const optionToDraw = useMemo(
+      () => withZoomSlider(option, measuredWidth),
+      [option, measuredWidth],
+    )
+    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 +240,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" }}
-        />
+        {measuredWidth > 0 && (
+          <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..789da194e 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 { needsZoomSlider } 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,29 @@ export const buildEchartsOption = (
     grid,
     xAxis,
     yAxis,
-    dataZoom: hasZoom ? [{ type: "inside" }, sliderZoom] : undefined,
     series: series as EChartsOption["series"],
   }
 }
+
+// Zoom exists only for a chart too dense for its measured width: the slider
+// costs plot height, and zooming a sparse chart is meaningless. The renderer
+// applies this from its own size.
+export const withZoomSlider = (
+  option: EChartsOption,
+  containerWidthPx: number,
+): EChartsOption => {
+  if (!needsZoomSlider(option, containerWidthPx)) return option
+  return {
+    ...option,
+    grid: { ...(option.grid as object), bottom: GRID_BOTTOM_WITH_ZOOM },
+    dataZoom: [
+      { type: "inside" },
+      {
+        type: "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..14fe9e74a
--- /dev/null
+++ b/src/scenes/Editor/Notebook/CellChart/chartDensity.test.ts
@@ -0,0 +1,157 @@
+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,
+  needsZoomSlider,
+  snapChartWidth,
+} 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)
+  })
+})
+
+describe("withZoomSlider", () => {
+  it("leaves a sparse chart without any zoom", () => {
+    // Given a sparse chart
+    const option = withZoomSlider(bars(15, 1), CONTAINER_PX)
+    // Then neither the slider nor the wheel zoom exists and the grid keeps its margin
+    expect(option.dataZoom).toBeUndefined()
+    expect((option.grid as { bottom: number }).bottom).toBe(56)
+  })
+
+  it("adds the wheel zoom and the slider together on a dense chart", () => {
+    // Given a dense chart
+    const option = withZoomSlider(line(PLOT_PX * 2), CONTAINER_PX)
+    // Then both zooms appear and the grid grows at the bottom
+    const zooms = option.dataZoom as { type: string }[]
+    expect(zooms.map((z) => z.type)).toEqual(["inside", "slider"])
+    expect((option.grid as { bottom: number }).bottom).toBe(86)
+  })
+})
+
+describe("snapChartWidth", () => {
+  it("rounds to 100px steps and never returns zero for a measured width", () => {
+    expect(snapChartWidth(40)).toBe(100)
+    expect(snapChartWidth(849)).toBe(800)
+    expect(snapChartWidth(850)).toBe(900)
+  })
+})
diff --git a/src/scenes/Editor/Notebook/CellChart/chartDensity.ts b/src/scenes/Editor/Notebook/CellChart/chartDensity.ts
new file mode 100644
index 000000000..53316f1c4
--- /dev/null
+++ b/src/scenes/Editor/Notebook/CellChart/chartDensity.ts
@@ -0,0 +1,86 @@
+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 CHART_WIDTH_STEP_PX = 100
+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
+  )
+}
+
+export const snapChartWidth = (px: number): number =>
+  Math.max(
+    CHART_WIDTH_STEP_PX,
+    Math.round(px / CHART_WIDTH_STEP_PX) * CHART_WIDTH_STEP_PX,
+  )
+
+export const needsZoomSlider = (
+  option: EChartsOption,
+  containerWidthPx: number,
+): boolean => {
+  const plotWidth = plotWidthOf(option, containerWidthPx)
+  if (plotWidth <= 0) return 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 tooDense = (slots: number, fillRatio: number, minPx: number) =>
+    slots > 0 && (plotWidth / slots) * fillRatio < minPx
+
+  return (
+    (bars.length > 0 &&
+      tooDense(bandSlots(bars), barFillRatio(barColumns(bars)), MIN_MARK_PX)) ||
+    (candles.length > 0 &&
+      tooDense(bandSlots(candles), CANDLE_FILL_RATIO, MIN_MARK_PX)) ||
+    tooDense(maxDataLength(points), 1, MIN_POINT_PX)
+  )
+}
diff --git a/src/scenes/Editor/Notebook/NotebookProvider.tsx b/src/scenes/Editor/Notebook/NotebookProvider.tsx
index 7ef84f11c..f16a8029f 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 {
+  AgentCellView,
   CellResult,
   NotebookCell,
   NotebookVariable,
@@ -35,7 +36,7 @@ import {
   registerController,
   setCellMaximizedTransition,
   setCellModeTransition,
-  setCellViewMaximizedTransition,
+  setCellPaneViewTransition,
   unregisterController,
   type NotebookControllerActions,
   type NotebookTransitionResult,
@@ -128,7 +129,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: AgentCellView) => void
   setFocusedCell: (cellId: string | null) => void
   setMaximizedCellId: (cellId: string | null) => void
   getCellsSnapshot: () => NotebookCell[]
@@ -158,7 +159,7 @@ const NOOP_ACTIONS: NotebookActions = {
   setCellRefresh: () => undefined,
   resetAutoRefreshOverrides: () => undefined,
   refreshAllCells: () => ({ refreshed: 0, skippedWrites: 0 }),
-  setCellViewMaximized: () => undefined,
+  setCellPaneView: () => undefined,
   setFocusedCell: () => undefined,
   setMaximizedCellId: () => undefined,
   getCellsSnapshot: () => [],
@@ -767,11 +768,11 @@ export const NotebookProvider: React.FC<{
     [applyTransition, bufferId],
   )
 
-  const setCellViewMaximized = useCallback(
-    (cellId: string, value: boolean) =>
+  const setCellPaneView = useCallback(
+    (cellId: string, view: AgentCellView) =>
       silently(() =>
         applyTransition((parts) =>
-          setCellViewMaximizedTransition(parts, bufferId, cellId, value),
+          setCellPaneViewTransition(parts, bufferId, cellId, view),
         ),
       ),
     [applyTransition, bufferId],
@@ -828,7 +829,7 @@ export const NotebookProvider: React.FC<{
     setCellRefresh: store.setCellRefresh,
     resetAutoRefreshOverrides,
     refreshAllCells: () => cellRefreshEngine.refreshAll(),
-    setCellViewMaximized,
+    setCellPaneView,
     setFocusedCell,
     setMaximizedCellId,
     getCellsSnapshot: () => store.cellsRef.current.slice(),
diff --git a/src/scenes/Editor/Notebook/cellHydrationStore.ts b/src/scenes/Editor/Notebook/cellHydrationStore.ts
new file mode 100644
index 000000000..39370f03e
--- /dev/null
+++ b/src/scenes/Editor/Notebook/cellHydrationStore.ts
@@ -0,0 +1,42 @@
+export type CellHydration = {
+  // Mirrors the renderer's hydration-aware result reservation. Persisted cell
+  // state alone cannot distinguish a result that is still loading/released
+  // from one whose snapshot is known to be missing.
+  expectingResult: boolean
+}
+
+const hydrations = new Map<
+  number,
+  Map<string, { token: symbol; value: CellHydration }>
+>()
+
+// Runtime-only: hydration state never reaches the notebook document, but the
+// layout tools derive grid heights from it, so mounted cells publish it here.
+export const publishCellHydration = (
+  bufferId: number,
+  cellId: string,
+  value: CellHydration,
+): (() => void) => {
+  const token = Symbol(cellId)
+  const cells =
+    hydrations.get(bufferId) ??
+    new Map<string, { token: symbol; value: CellHydration }>()
+  cells.set(cellId, { token, value })
+  hydrations.set(bufferId, cells)
+
+  return () => {
+    const current = hydrations.get(bufferId)?.get(cellId)
+    if (current?.token !== token) return
+    cells.delete(cellId)
+    if (cells.size === 0) hydrations.delete(bufferId)
+  }
+}
+
+export const readCellHydration = (
+  bufferId: number,
+  cellId: string,
+): CellHydration | undefined => hydrations.get(bufferId)?.get(cellId)?.value
+
+export const __resetCellHydrationStoreForTests = (): void => {
+  hydrations.clear()
+}
diff --git a/src/scenes/Editor/Notebook/cells/Cell.tsx b/src/scenes/Editor/Notebook/cells/Cell.tsx
index b5ae87894..5f2388a61 100644
--- a/src/scenes/Editor/Notebook/cells/Cell.tsx
+++ b/src/scenes/Editor/Notebook/cells/Cell.tsx
@@ -30,10 +30,12 @@ import { toast } from "../../../../components/Toast"
 import {
   CELL_EDITOR_LINE_HEIGHT,
   CELL_EDITOR_PADDING,
+  clampPaneHeight,
   isDoubleView,
   isExpectingResult,
-  MIN_BOTTOM_HEIGHT_PX,
+  minBottomHeightFor,
   resolveAutoRefresh,
+  resolveCellPaneLayout,
   resolveCellView,
 } from "../notebookUtils"
 import {
@@ -51,6 +53,7 @@ import {
   useCellResizeOrchestration,
 } from "./useCellResizeOrchestration"
 import { CellBottomContent } from "./CellBottomContent"
+import { publishCellHydration } from "../cellHydrationStore"
 import { getMonacoThemeName } from "../../../../utils/monacoInit"
 
 const EditorContainer = styled.div<{ $spotlight: boolean }>`
@@ -174,14 +177,19 @@ 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)
+
+  useEffect(
+    () =>
+      publishCellHydration(bufferIdForEvents, cell.id, {
+        expectingResult,
+      }),
+    [bufferIdForEvents, cell.id, expectingResult],
+  )
+
+  const resultOnly = paneLayout === "result"
+  const showBottomSlot = paneLayout !== "editor"
+  const isSplit = paneLayout === "split"
   const runActive = !isDrawMode && doubleView
   const view = resolveCellView(cell)
   const canRun = !!stripSQLComments(cell.value).trim()
@@ -200,8 +208,6 @@ const CellInner: React.FC<Props> = ({
     middleResizeEnd,
     resetToDefaults,
     resetBottomArea,
-    maximizedChartResizeLive,
-    maximizedChartResizeEnd,
   } = useCellResizeOrchestration({
     cell,
     layoutMode,
@@ -225,7 +231,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 +240,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,7 +296,6 @@ const CellInner: React.FC<Props> = ({
   } = useCellRunActions({
     cell,
     isRunning,
-    isCompactTier,
     showBottomSlot,
     editorRef,
     applyHighlight,
@@ -436,6 +441,7 @@ const CellInner: React.FC<Props> = ({
         isRunning={isRunning}
         headerRef={headerRef}
         toolbarTier={toolbarTier}
+        paneLayout={paneLayout}
         chartZoomed={chartZoomed}
         left={
           <CellNameLabel
@@ -479,7 +485,7 @@ const CellInner: React.FC<Props> = ({
               view={view}
               cellAutoRefresh={cell.autoRefresh}
               autoRefreshDefault={autoRefreshDefault}
-              isViewMaximized={isViewMaximized}
+              paneLayout={paneLayout}
               isRunning={isRunning}
               isGridLoading={isGridLoading}
               isChartLoading={chartLoading}
@@ -491,7 +497,7 @@ const CellInner: React.FC<Props> = ({
             <CellViewToggle
               cellId={cell.id}
               view={view}
-              isViewMaximized={isViewMaximized}
+              paneLayout={paneLayout}
               isGridLoading={isGridLoading}
               isChartLoading={chartLoading}
               isRunning={isRunning}
@@ -501,7 +507,7 @@ const CellInner: React.FC<Props> = ({
           )
         }
       />
-      {!isViewMaximized && (
+      {!resultOnly && (
         <EditorContainer
           ref={editorContainerRef}
           $spotlight={isMaximized}
@@ -572,20 +578,16 @@ const CellInner: React.FC<Props> = ({
           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 +610,20 @@ 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
-        }
+        minHeight={showBottomSlot ? minBottomHeightFor(cell) : undefined}
       />
     ) : null
 
diff --git a/src/scenes/Editor/Notebook/cells/CellDragHeader.tsx b/src/scenes/Editor/Notebook/cells/CellDragHeader.tsx
index ef8ab8f24..84fb948d1 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"
 
@@ -62,6 +62,7 @@ type Props = {
   // cells omit it (no width-driven tiering).
   headerRef?: RefObject<HTMLDivElement>
   toolbarTier?: CellToolbarTier
+  paneLayout?: CellPaneLayout
   chartZoomed?: boolean
 }
 
@@ -78,6 +79,7 @@ export const CellDragHeader: React.FC<Props> = ({
   right,
   headerRef,
   toolbarTier,
+  paneLayout,
   chartZoomed,
 }) => (
   <HeaderBar
@@ -111,6 +113,7 @@ export const CellDragHeader: React.FC<Props> = ({
         isRunning={isRunning}
         inline
         toolbarTier={toolbarTier}
+        paneLayout={paneLayout}
         chartZoomed={chartZoomed}
       />
     </RightSide>
diff --git a/src/scenes/Editor/Notebook/cells/CellToolbar.tsx b/src/scenes/Editor/Notebook/cells/CellToolbar.tsx
index 73041b2bf..f67dd3e7b 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"
@@ -76,6 +74,7 @@ type Props = {
   isRunning?: boolean
   inline?: boolean
   toolbarTier?: CellToolbarTier
+  paneLayout?: CellPaneLayout
   chartZoomed?: boolean
 }
 
@@ -90,6 +89,7 @@ export const CellToolbar: React.FC<Props> = ({
   isRunning = false,
   inline,
   toolbarTier,
+  paneLayout,
   chartZoomed = false,
 }) => {
   const {
@@ -100,7 +100,7 @@ export const CellToolbar: React.FC<Props> = ({
     setFocusedCell,
     setMaximizedCellId,
     setCellRefresh,
-    setCellViewMaximized,
+    setCellPaneView,
     setCellMode,
   } = useNotebookActions()
   const bufferId = useNotebookBufferId()
@@ -114,7 +114,8 @@ 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 sqlShown = paneLayout === "editor"
   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.
@@ -127,7 +128,7 @@ export const CellToolbar: React.FC<Props> = ({
     showViewSql,
     showViewTable,
     showViewChart,
-    showSplitItem,
+    showEditorToggleItem,
     showResetZoom,
     showAutoRefreshItem,
     showRefreshItem,
@@ -142,22 +143,21 @@ 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,
+    sqlShown,
     chartZoomed,
     isGridMode,
     cellIndex,
     totalCells,
   })
 
-  // Minimize the chart/table to the editor, keeping the data on the cell.
+  // Show the editor, keeping the result data on the cell.
   const handleViewSql = () => {
     void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_CHANGE, {
       to: "sql",
       method: "menu",
     })
     signalUserEdit(bufferId)
-    setCellViewMaximized(cellId, false)
+    setCellPaneView(cellId, "editor")
   }
   const handleViewTable = () => {
     if (isRunning) return
@@ -170,10 +170,10 @@ export const CellToolbar: React.FC<Props> = ({
       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.
+    // A chart transfers its data to the grid (no re-query). A hidden result
+    // comes back as a split, like the inline editor toggle of the wider tiers.
     if (isChartView) setCellMode(cellId, "run")
-    setCellViewMaximized(cellId, true)
+    if (sqlShown) setCellPaneView(cellId, "editor_result")
   }
   const handleViewChart = () => {
     if (isRunning) return
@@ -183,20 +183,20 @@ export const CellToolbar: React.FC<Props> = ({
     })
     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 })
+      // Entering draw can be refused (non-DQL SQL); the draw handler reveals a
+      // hidden result only once the draw actually takes.
+      eventBus.publish(EventType.NOTEBOOK_CELL_DRAW, { cellId })
       return
     }
-    setCellViewMaximized(cellId, true)
+    setCellPaneView(cellId, "editor_result")
   }
-  const handleToggleMaximizeView = () => {
-    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_MAXIMIZE, {
-      isViewMaximized: !cell.isViewMaximized,
+  const handleToggleEditor = () => {
+    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_EDITOR_TOGGLE, {
+      editorShown: resultOnly,
       view,
     })
     signalUserEdit(bufferId)
-    setCellViewMaximized(cellId, !cell.isViewMaximized)
+    setCellPaneView(cellId, resultOnly ? "editor_result" : "result")
   }
   const handleMaximizeCell = () => {
     void trackEvent(ConsoleEvent.NOTEBOOK_CELL_MAXIMIZE, {
@@ -310,7 +310,7 @@ export const CellToolbar: React.FC<Props> = ({
                   onSelect={handleViewSql}
                   icon={<FileSqlIcon size={16} />}
                 >
-                  View SQL
+                  View editor
                 </DropdownMenu.Item>
               )}
               {showViewTable && (
@@ -337,18 +337,12 @@ export const CellToolbar: React.FC<Props> = ({
                   {isNoneView ? "Draw" : "View chart"}
                 </DropdownMenu.Item>
               )}
-              {showSplitItem && (
+              {showEditorToggleItem && (
                 <DropdownMenu.Item
-                  onSelect={handleToggleMaximizeView}
-                  icon={
-                    isViewMaximized ? (
-                      <ArrowsInLineVerticalIcon size={16} />
-                    ) : (
-                      <ArrowsOutLineVerticalIcon size={16} />
-                    )
-                  }
+                  onSelect={handleToggleEditor}
+                  icon={<FileSqlIcon size={16} />}
                 >
-                  {isViewMaximized ? "Split view" : "Maximized view"}
+                  {resultOnly ? "Show editor" : "Hide editor"}
                 </DropdownMenu.Item>
               )}
 
diff --git a/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx b/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
index f1ca2eabe..200a3075d 100644
--- a/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
@@ -1,14 +1,14 @@
 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,
@@ -18,7 +18,7 @@ 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 type { CellPaneLayout, CellView } from "../notebookUtils"
 import { trackEvent } from "../../../../modules/ConsoleEventTracker"
 import { ConsoleEvent } from "../../../../modules/ConsoleEventTracker/events"
 
@@ -26,9 +26,12 @@ 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,14 +47,32 @@ 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,
+// but keep editor visibility neutral rather than giving it an accent state.
+const EditorVisibilityToggle = styled(PrimaryToggleButton)`
+  &&:not(:disabled) {
+    width: auto;
+    padding: 0 1rem;
+    height: 3rem;
+    min-height: 3rem;
+    color: ${({ theme }) => theme.color.contentSecondary};
+  }
+
+  &&[data-selected="true"],
+  &&[data-selected="true"]:hover:not(:disabled) {
+    background: ${({ theme }) => theme.color.interactionNeutral};
+    color: ${({ theme }) => theme.color.contentPrimary};
+  }
+`
+
 type Props = {
   cellId: string
   view: CellView
-  isViewMaximized: boolean
+  paneLayout: CellPaneLayout
   isGridLoading: boolean
   isChartLoading: boolean
   isRunning: boolean
@@ -62,16 +83,17 @@ type Props = {
 export const CellViewToggle: React.FC<Props> = ({
   cellId,
   view,
-  isViewMaximized,
+  paneLayout,
   isGridLoading,
   isChartLoading,
   isRunning,
   chartZoomed,
   showLabels,
 }) => {
-  const { setCellViewMaximized, setCellMode, clearCellResult } =
-    useNotebookActions()
+  const { setCellPaneView, setCellMode, clearCellResult } = useNotebookActions()
   const bufferId = useNotebookBufferId()
+  const resultOnly = paneLayout === "result"
+  const resultHidden = paneLayout === "editor"
 
   // 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
@@ -101,15 +123,16 @@ export const CellViewToggle: React.FC<Props> = ({
       return
     }
     setCellMode(cellId, "run")
+    if (resultHidden) setCellPaneView(cellId, "editor_result")
   }
-  const handleSplit = (e: React.MouseEvent) => {
+  const handleEditorVisibility = (e: React.MouseEvent) => {
     e.stopPropagation()
-    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_MAXIMIZE, {
-      isViewMaximized: !isViewMaximized,
+    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_EDITOR_TOGGLE, {
+      editorShown: resultOnly,
       view,
     })
     signalUserEdit(bufferId)
-    setCellViewMaximized(cellId, !isViewMaximized)
+    setCellPaneView(cellId, resultOnly ? "editor_result" : "result")
   }
   const handleResetZoom = (e: React.MouseEvent) => {
     e.stopPropagation()
@@ -118,59 +141,58 @@ export const CellViewToggle: React.FC<Props> = ({
   }
 
   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={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>
+      </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={resultOnly ? "Show editor" : "Hide editor"}
+          onClick={handleEditorVisibility}
+          selected={!resultOnly}
         >
-          {isViewMaximized ? (
-            <ArrowsInLineVerticalIcon />
-          ) : (
-            <ArrowsOutLineVerticalIcon />
-          )}
-        </ViewIconButton>
+          <FileSqlIcon size={18} />
+        </EditorVisibilityToggle>
       </Tooltip>
       {view === "chart" && chartZoomed && (
         <Tooltip content="Reset zoom">
@@ -179,6 +201,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..78fba089b 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,7 +11,7 @@ type Props = {
   view: "grid" | "chart"
   cellAutoRefresh: AutoRefresh | undefined
   autoRefreshDefault: AutoRefresh | undefined
-  isViewMaximized: boolean
+  paneLayout: CellPaneLayout
   isRunning: boolean
   isGridLoading: boolean
   isChartLoading: boolean
@@ -23,7 +24,7 @@ export const CellWideActions: React.FC<Props> = ({
   view,
   cellAutoRefresh,
   autoRefreshDefault,
-  isViewMaximized,
+  paneLayout,
   isRunning,
   isGridLoading,
   isChartLoading,
@@ -49,7 +50,7 @@ export const CellWideActions: React.FC<Props> = ({
     <CellViewToggle
       cellId={cellId}
       view={view}
-      isViewMaximized={isViewMaximized}
+      paneLayout={paneLayout}
       isGridLoading={isGridLoading}
       isChartLoading={isChartLoading}
       isRunning={isRunning}
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..352a71cfe 100644
--- a/src/scenes/Editor/Notebook/cells/useCellResizeOrchestration.ts
+++ b/src/scenes/Editor/Notebook/cells/useCellResizeOrchestration.ts
@@ -8,18 +8,17 @@ import { EventType } from "../../../../modules/EventBus/types"
 import { trackEvent } from "../../../../modules/ConsoleEventTracker"
 import { ConsoleEvent } from "../../../../modules/ConsoleEventTracker/events"
 import {
+  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 +33,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 +56,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 +89,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 }),
@@ -127,7 +126,7 @@ export const useCellResizeOrchestration = ({
       middleSum(),
       height,
       MIN_EDITOR_HEIGHT,
-      MIN_BOTTOM_HEIGHT_PX,
+      minBottomHeightFor(cell),
     )
     if (isMaximized) {
       setSpotlightLiveRatio(top / (top + bottom))
@@ -143,7 +142,7 @@ export const useCellResizeOrchestration = ({
       middleSum(),
       height,
       MIN_EDITOR_HEIGHT,
-      MIN_BOTTOM_HEIGHT_PX,
+      minBottomHeightFor(cell),
     )
     if (isMaximized) {
       setSpotlightLiveRatio(null)
@@ -206,33 +205,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
@@ -253,7 +225,5 @@ export const useCellResizeOrchestration = ({
     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..db9d66c79 100644
--- a/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
+++ b/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
@@ -27,7 +27,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
@@ -45,7 +44,6 @@ type RunRequest = { kind: "all" } | { kind: "single"; source: SingleRunSource }
 export const useCellRunActions = ({
   cell,
   isRunning,
-  isCompactTier,
   showBottomSlot,
   editorRef,
   applyHighlight,
@@ -55,7 +53,7 @@ export const useCellRunActions = ({
     runCell,
     setCellMode,
     clearCellResult,
-    setCellViewMaximized,
+    setCellPaneView,
     getCellsSnapshot,
   } = useNotebookActions()
   const bufferIdForEvents = useNotebookBufferId()
@@ -218,8 +216,12 @@ 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,
+          result: cell.result,
+          paneView: cell.paneView,
+        },
+        { intent: request.kind },
       )
       if (plan.kind === "noop") return
       if (plan.kind === "chart") {
@@ -239,23 +241,26 @@ export const useCellRunActions = ({
       if (request.kind === "all") {
         exitDrawMode()
         void handleRunAll()
-        if (plan.reveal) setCellViewMaximized(cell.id, true)
+        if (plan.reveal) setCellPaneView(cell.id, "editor_result")
         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)
+      if (plan.reveal) {
+        // Running from an editor-only pane view reveals the result as a
+        // split, so the run is not invisible.
+        setCellPaneView(cell.id, "editor_result")
+      }
     },
     [
       cell.id,
       cell.mode,
       cell.result,
+      cell.paneView,
       bufferIdForEvents,
-      isCompactTier,
-      showBottomSlot,
-      setCellViewMaximized,
+      setCellPaneView,
       setCellMode,
       handleRunAll,
       handleRunSingle,
@@ -310,10 +315,11 @@ 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)
+        if (entered && !showBottomSlot)
+          setCellPaneView(cell.id, "editor_result")
       })
     }
     eventBus.subscribe(EventType.NOTEBOOK_CELL_RUN, runHandler)
@@ -322,7 +328,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, setCellPaneView, showBottomSlot])
 
   const isGridLoading = isRunning && firstRunRef.current
 
diff --git a/src/scenes/Editor/Notebook/index.tsx b/src/scenes/Editor/Notebook/index.tsx
index e68221c2c..5476c702f 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,14 @@ import { NotebookToolbar } from "./NotebookToolbar"
 import { NotebookMcpPromo } from "./NotebookMcpPromo"
 import { renderEdgeHandle } from "./resize"
 import {
-  cellChromePx,
-  cellHeightPatchForRows,
+  paneHeightsFromGridRows,
   computeCellGridH,
+  computeCellMaxGridH,
+  computeCellMinGridH,
   generateDefaultLayout as generateDefaultLayoutPure,
-  isDoubleView,
   isExpectingResult,
   mergeCellLayout,
-  MIN_BOTTOM_HEIGHT_PX,
-  minTopHeightFor,
+  resolveCellPaneLayout,
   NOTEBOOK_GRID_COLS,
   NOTEBOOK_GRID_MARGIN_Y,
   NOTEBOOK_GRID_ROW_HEIGHT,
@@ -135,7 +141,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 +161,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 +218,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 +426,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 +453,31 @@ 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),
+      const paneLayout = resolveCellPaneLayout(cell, expectingResult)
+      const minH = computeCellMinGridH(
+        cell,
+        ROW_HEIGHT,
+        GRID_MARGIN_Y,
+        expectingResult,
+        paneLayout,
       )
       return {
         ...item,
-        h: computeCellGridH(cell, ROW_HEIGHT, GRID_MARGIN_Y, expectingResult),
+        h: computeCellGridH(
+          cell,
+          ROW_HEIGHT,
+          GRID_MARGIN_Y,
+          expectingResult,
+          paneLayout,
+        ),
         minH,
+        maxH: computeCellMaxGridH(
+          cell,
+          ROW_HEIGHT,
+          GRID_MARGIN_Y,
+          expectingResult,
+          paneLayout,
+        ),
       }
     })
     return {
@@ -460,7 +485,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 +552,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 +631,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..3fea97c46 100644
--- a/src/scenes/Editor/Notebook/notebookUtils.test.ts
+++ b/src/scenes/Editor/Notebook/notebookUtils.test.ts
@@ -1,6 +1,7 @@
 import { describe, it, expect } from "vitest"
 import {
   ApplyNotebookStateError,
+  agentCellPaneDimensions,
   buildAppliedNotebookState,
   attachScriptSummary,
   autoRefreshIntervalMs,
@@ -8,13 +9,15 @@ import {
   AUTO_REFRESH_OPTIONS,
   isAutoRefresh,
   resolveCellView,
+  agentCellPresentation,
+  resolveCellPaneLayout,
   resolveRunAction,
   buildAppliedCells,
   buildAppliedLayout,
   buildInitialScriptResults,
   buildPersistPayload,
   capResultBytes,
-  cellHeightPatchForRows,
+  paneHeightsFromGridRows,
   cellModeChangePatch,
   cellToolbarMenuFlags,
   cellToolbarTier,
@@ -27,6 +30,8 @@ import {
   computeAgentCellGridH,
   computeCellGridH,
   computeCellHeights,
+  computeCellMaxGridH,
+  computeCellMinGridH,
   computeResultBottomHeight,
   DEFAULT_CHART_BOTTOM_HEIGHT,
   duplicateCellAt,
@@ -54,7 +59,6 @@ import {
   statementKeysFor,
   removeCell,
   resolveRunCompletion,
-  scaleCellHeights,
   setResultAt,
   singleResultFromExec,
   snapMarkdownTopHeight,
@@ -383,7 +387,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 +869,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", () => {
@@ -1033,16 +1099,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 +1249,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 +1264,72 @@ 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("apply is a PUT: mode='draw' with no chart_config throws even when the existing cell had one (no merge)", () => {
@@ -1227,7 +1354,7 @@ 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[] = [
       {
@@ -1236,7 +1363,7 @@ describe("buildAppliedCells", () => {
         value: "SELECT 1",
         mode: "run",
         autoRefresh: "5s",
-        isViewMaximized: true,
+        paneView: "result",
         chartConfig: {
           xColumn: "ts",
           queries: [{ type: "line", yColumns: ["v"] }],
@@ -1253,7 +1380,7 @@ describe("buildAppliedCells", () => {
     expect(nextCells[0].mode).toBe("run")
     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 +1470,7 @@ describe("isDoubleView", () => {
         position: 0,
         value: "",
         mode: "draw",
-        isViewMaximized: true,
+        paneView: "result",
       }),
     ).toBe(true)
   })
@@ -1646,36 +1773,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 })
   })
 })
 
@@ -1834,9 +1960,9 @@ describe("computeCellGridH", () => {
       ),
     ).toBe(9)
   })
-  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("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(
         {
@@ -1845,13 +1971,145 @@ describe("computeCellGridH", () => {
           value: "",
           topHeight: 72,
           bottomHeight: 104,
-          isViewMaximized: true,
+          paneView: "result",
           result: { results: [], activeResultIndex: 0, timestamp: 0 },
         },
         10,
         20,
       ),
-    ).toBe(8)
+    ).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")
+    expect(
+      resolveCellPaneLayout(withResult({ paneView: "editor" }), false),
+    ).toBe("editor")
+  })
+})
+
+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", () => {
+    expect(agentCellPresentation(chart())).toEqual({ view: "editor_result" })
+    expect(agentCellPresentation(chart({ paneView: "editor" }))).toEqual({
+      view: "editor",
+    })
+    expect(agentCellPresentation(chart({ paneView: undefined }))).toEqual({
+      view: "editor_result",
+    })
+  })
+
+  it("reports a null view for a markdown cell", () => {
+    expect(
+      agentCellPresentation(chart({ mode: undefined, type: "markdown" })),
+    ).toEqual({ view: null })
+  })
+})
+
+describe("computeCellMinGridH", () => {
+  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(computeCellMinGridH(cell, 10, 20)).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(computeCellMinGridH(cell, 10, 20)).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(computeCellMinGridH(cell, 10, 20)).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(computeCellMinGridH(cell, 10, 20, false, "editor")).toBe(5)
+    expect(computeCellMinGridH(cell, 10, 20, false, "result")).toBe(6)
   })
 })
 
@@ -1866,7 +2124,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 +2153,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 +2249,7 @@ describe("hasAgentVisibleCellHeightChanged", () => {
   })
 })
 
-describe("cellHeightPatchForRows", () => {
+describe("paneHeightsFromGridRows", () => {
   const withResult = (over: Partial<NotebookCell> = {}): NotebookCell => ({
     id: "x",
     position: 0,
@@ -2004,7 +2262,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 +2272,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 +2341,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,20 +2585,6 @@ 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", () => {
@@ -2330,7 +2596,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 +2604,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 +2619,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)", () => {
@@ -2409,7 +2676,7 @@ describe("cloneNotebookViewState", () => {
         value: "SELECT 2",
         mode: "draw",
         autoRefresh: true,
-        isViewMaximized: true,
+        paneView: "result",
         chartConfig: {
           xColumn: "ts",
           queries: [{ type: "line", yColumns: ["v"] }],
@@ -2483,7 +2750,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"] }],
@@ -2826,83 +3093,102 @@ describe("resolveRunAction", () => {
   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 }
     // When the user presses Run All / Run
     // Then it runs all / one, without revealing anything
-    expect(resolveRunAction(cell, { ...opts, intent: "all" })).toEqual({
+    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("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)
+  it("runs an empty run cell the same way, with nothing to reveal", () => {
+    // Given a run cell with no result (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, and never reveals
+    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 }
+  it("reveals a run cell whose result is hidden by an editor preference", () => {
+    // Given a run cell whose stored preference hides the result
+    const cell = {
+      mode: "run" as const,
+      result,
+      paneView: "editor" as const,
+    }
     // When the user runs
     // Then it reveals the grid first, then runs
-    expect(resolveRunAction(cell, { ...opts, intent: "all" })).toEqual({
+    expect(resolveRunAction(cell, { intent: "all" })).toEqual({
       kind: "run-all",
       reveal: true,
       exitDraw: false,
     })
-    expect(resolveRunAction(cell, { ...opts, intent: "single" })).toEqual({
+    expect(resolveRunAction(cell, { intent: "single" })).toEqual({
       kind: "run-single",
       reveal: true,
       exitDraw: false,
     })
   })
 
+  it("keeps drawing a draw cell that has no result yet", () => {
+    // Given a draw cell whose chart has not landed (bottom slot hidden)
+    const cell = {
+      mode: "draw" as const,
+      paneView: "editor_result" as const,
+    }
+    // When the user presses Run All / Run
+    // Then Run All draws the chart and Run is a no-op — never a reveal
+    expect(resolveRunAction(cell, { intent: "all" })).toEqual({
+      kind: "chart",
+    })
+    expect(resolveRunAction(cell, { intent: "single" })).toEqual({
+      kind: "noop",
+    })
+  })
+
   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 }
     // 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 }
+  it("treats a chart collapsed behind the editor as a grid, exiting draw", () => {
+    // Given a draw cell with the chart collapsed behind an editor preference
+    const cell = {
+      mode: "draw" as const,
+      result,
+      paneView: "editor" as const,
+    }
     // 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({
+    expect(resolveRunAction(cell, { intent: "all" })).toEqual({
       kind: "run-all",
       reveal: true,
       exitDraw: true,
     })
-    expect(resolveRunAction(cell, { ...opts, intent: "single" })).toEqual({
+    expect(resolveRunAction(cell, { intent: "single" })).toEqual({
       kind: "run-single",
       reveal: true,
       exitDraw: true,
@@ -2982,7 +3268,7 @@ describe("cellToolbarMenuFlags", () => {
     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)
@@ -2997,6 +3283,26 @@ describe("cellToolbarMenuFlags", () => {
     expect(f.showViewTable).toBe(false)
     expect(f.showRefreshItem).toBe(true)
     expect(f.showChartSettings).toBe(false)
+    // And the editor toggle the wide header shows inline
+    expect(f.showEditorToggleItem).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/Hide editor is in the menu, as the wide header's inline toggle
+    expect(flags({ tier: "compact", view: "chart" }).showEditorToggleItem).toBe(
+      true,
+    )
+    // Given the result hidden behind the editor
+    // Then View table / View chart are the way back, so the toggle is absent
+    expect(
+      flags({ tier: "compact", view: "chart", sqlShown: true })
+        .showEditorToggleItem,
+    ).toBe(false)
+    // And wider tiers show the toggle inline instead
+    expect(
+      flags({ tier: "standard", view: "chart" }).showEditorToggleItem,
+    ).toBe(false)
   })
 
   it("hides chart commands that reach the unmounted chart when compact View SQL is active", () => {
@@ -3073,7 +3379,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 +3389,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)
   })
 
@@ -3134,7 +3440,7 @@ 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
@@ -3142,7 +3448,7 @@ describe("cellToolbarMenuFlags", () => {
           f.showViewSql ||
             f.showViewTable ||
             f.showViewChart ||
-            f.showSplitItem,
+            f.showEditorToggleItem,
         )
         expect(f.groupBHasItems).toBe(
           f.showResetZoom ||
@@ -3383,83 +3689,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")])
@@ -3923,3 +4152,53 @@ 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", () => {
+    // result-only: 2400 + 44 chrome = 2444px → 82 rows
+    expect(computeCellMaxGridH(withResult, 10, 20, false, "result")).toBe(82)
+    // split keeps the 100px editor: 100 + 2400 + 50 = 2550px → 85 rows
+    expect(computeCellMaxGridH(withResult, 10, 20, false, "split")).toBe(85)
+  })
+
+  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/)
+  })
+})
diff --git a/src/scenes/Editor/Notebook/notebookUtils.ts b/src/scenes/Editor/Notebook/notebookUtils.ts
index 2ab42a702..48556689e 100644
--- a/src/scenes/Editor/Notebook/notebookUtils.ts
+++ b/src/scenes/Editor/Notebook/notebookUtils.ts
@@ -1,5 +1,6 @@
 import type { QueryExecResult } from "../../../hooks/useQueryExecution"
 import type {
+  AgentCellView,
   AutoRefresh,
   AutoRefreshInterval,
   CellLayoutItem,
@@ -96,21 +97,15 @@ type RunActionPlan =
   | { kind: "run-all" | "run-single"; reveal: boolean; exitDraw: boolean }
 
 export const resolveRunAction = (
-  cell: Pick<NotebookCell, "mode" | "result">,
-  opts: {
-    isCompactTier: boolean
-    showBottomSlot: boolean
-    intent: "all" | "single"
-  },
+  cell: Pick<NotebookCell, "mode" | "result" | "paneView">,
+  opts: { 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
+  const reveal = cell.paneView === "editor"
   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
+  // Run mode, or a draw cell collapsed behind an editor-only pane view: 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 {
@@ -139,7 +134,7 @@ export type CellToolbarMenuFlags = {
   showViewSql: boolean
   showViewTable: boolean
   showViewChart: boolean
-  showSplitItem: boolean
+  showEditorToggleItem: boolean
   showResetZoom: boolean
   showAutoRefreshItem: boolean
   showRefreshItem: boolean
@@ -155,9 +150,10 @@ 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 table/chart switch and the editor toggle the wider tiers
+// show in the header. `sqlShown` is the editor-only state.
+// Markdown cells (no run/draw views) keep just the move/duplicate/delete items.
 export const cellToolbarMenuFlags = (params: {
   tier: CellToolbarTier
   view: CellView
@@ -182,7 +178,6 @@ export const cellToolbarMenuFlags = (params: {
   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.
@@ -194,7 +189,8 @@ export const cellToolbarMenuFlags = (params: {
     isCompact && !isMarkdown && (isNoneView || sqlShown || isChartView)
   const showViewChart =
     isCompact && !isMarkdown && (isNoneView || sqlShown || isGridView)
-  const showSplitItem = !hasToolbarSplit && !isNoneView && !isCompact
+  const showEditorToggleItem =
+    isCompact && !isNoneView && !isMarkdown && !sqlShown
   const showResetZoom =
     isCompact && isChartView && chartZoomed && !chartCollapsed
   // Auto-refresh applies to any cell showing a view, not just charts. Unlike
@@ -212,7 +208,7 @@ export const cellToolbarMenuFlags = (params: {
     showViewSql,
     showViewTable,
     showViewChart,
-    showSplitItem,
+    showEditorToggleItem,
     showResetZoom,
     showAutoRefreshItem,
     showRefreshItem,
@@ -222,7 +218,7 @@ export const cellToolbarMenuFlags = (params: {
     showDuplicate,
     showDelete,
     groupAHasItems:
-      showViewSql || showViewTable || showViewChart || showSplitItem,
+      showViewSql || showViewTable || showViewChart || showEditorToggleItem,
     groupBHasItems:
       showResetZoom ||
       showAutoRefreshItem ||
@@ -490,12 +486,19 @@ 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>
+    delete canonical.isViewMaximized
+    return persisted
+  })
 
 export const buildPersistPayload = (
   cells: NotebookCell[],
@@ -601,6 +604,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 +702,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 = {
@@ -1082,16 +1088,20 @@ 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
+    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)
 
     // 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)
     ) {
@@ -1152,13 +1162,72 @@ export const buildAppliedCells = (
     }
 
     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,
+      ...(resolvedMode !== undefined ? { mode: resolvedMode } : {}),
+    }
+    const dimensions = applicableCellDimensions(dimensionCell, {
+      editorHeight: req.editorHeight,
+      resultHeight: req.resultHeight,
+      view: req.view,
+    })
+    if (
+      typeof dimensions.editorHeight === "number" &&
+      (!Number.isFinite(dimensions.editorHeight) ||
+        dimensions.editorHeight < minTopHeightFor(dimensionCell))
+    ) {
+      throw new ApplyNotebookStateError(
+        `Cell at index ${index} has an editor_height below its minimum.`,
+        "cells",
+      )
+    }
+    if (
+      typeof dimensions.resultHeight === "number" &&
+      (!Number.isFinite(dimensions.resultHeight) ||
+        dimensions.resultHeight < minBottomHeightFor(dimensionCell))
+    ) {
+      throw new ApplyNotebookStateError(
+        `Cell at index ${index} has result_height ${dimensions.resultHeight}px; minimum is ${minBottomHeightFor(dimensionCell)}px.`,
+        "cells",
+      )
+    }
+    if (
+      typeof dimensions.editorHeight === "number" &&
+      dimensions.editorHeight > MAX_PANE_HEIGHT_PX
+    ) {
+      throw new ApplyNotebookStateError(
+        `Cell at index ${index} has editor_height ${dimensions.editorHeight}px; maximum is ${MAX_PANE_HEIGHT_PX}px.`,
+        "cells",
+      )
+    }
+    if (
+      typeof dimensions.resultHeight === "number" &&
+      dimensions.resultHeight > MAX_PANE_HEIGHT_PX
+    ) {
+      throw new ApplyNotebookStateError(
+        `Cell at index ${index} has result_height ${dimensions.resultHeight}px; maximum is ${MAX_PANE_HEIGHT_PX}px.`,
+        "cells",
+      )
+    }
+    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)
@@ -1186,11 +1255,6 @@ 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
@@ -1199,21 +1263,9 @@ export const buildAppliedCells = (
       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
+      Object.assign(next, dimensionsPatch)
+      if (resolvedType !== "markdown") {
+        next.paneView ??= "editor_result"
         if (valueChanged && !existing.topResized) {
           const estimated = topHeightForSql(value)
           if (
@@ -1238,19 +1290,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)
+    created.paneView = "editor_result"
     if (resolvedMode !== undefined) created.mode = resolvedMode
     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 +1330,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 +1359,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 +1367,76 @@ 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
+
+export type AgentCellDimensions = {
+  editorHeight?: AgentHeightValue
+  resultHeight?: AgentHeightValue
+  view?: AgentCellView | null
+  expectingResult?: boolean
+}
+
+export const applicableCellDimensions = (
+  cell: Pick<NotebookCell, "type">,
+  dimensions: AgentCellDimensions,
+): AgentCellDimensions =>
+  cell.type === "markdown"
+    ? { ...dimensions, resultHeight: null, view: null }
+    : dimensions
+
+// 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.
+export const agentCellDimensionsPatch = (
+  cell: NotebookCell,
+  dimensions: AgentCellDimensions,
+): Partial<NotebookCell> => {
+  const patch: Partial<NotebookCell> = {}
+  if (dimensions.editorHeight === "auto") {
+    patch.topHeight =
+      cell.type === "markdown" ? undefined : 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 (dimensions.view != null && 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 +1568,41 @@ 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 storedAgentCellView = (cell: NotebookCell): AgentCellView => {
+  if (cell.type === "markdown") return "editor"
+  return cell.paneView ?? "editor_result"
+}
+
+export type AgentCellPresentation = { view: AgentCellView | null }
+
+export const agentCellPresentation = (
+  cell: NotebookCell,
+): AgentCellPresentation => ({
+  view: cell.type === "markdown" ? null : storedAgentCellView(cell),
+})
+
+// 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 => {
+  const hasResult = isDoubleView(cell) || expectingResult
+  if (!hasResult) return "editor"
+  const paneView = storedAgentCellView(cell)
+  if (paneView === "editor") return "editor"
+  return paneView === "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 +1623,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 +1652,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 +1715,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 +1724,10 @@ export const computeCellHeights = (
         cell.bottomHeight ??
         RESERVED_RESULT_BOTTOM_HEIGHT)
       : 0
+  const bottomHeight =
+    cell.mode === "draw"
+      ? Math.max(MIN_CHART_HEIGHT_PX, resolvedBottomHeight)
+      : resolvedBottomHeight
   return { topHeight, bottomHeight }
 }
 
@@ -1564,9 +1737,16 @@ 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
+
+// Derives react-grid-layout `h` from the visible pane heights plus chrome.
+// 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`,
@@ -1581,30 +1761,88 @@ export const computeCellGridH = (
   rowHeight: number,
   marginY: number = 0,
   expectingResult: boolean = false,
+  paneLayout: CellPaneLayout = resolveCellPaneLayout(cell, expectingResult),
 ): number => {
   const { topHeight, bottomHeight } = computeCellHeights(cell, {
     expectingResult,
   })
-  const totalPx = cellChromePx(cell, expectingResult) + topHeight + bottomHeight
+  const visibleTopHeight = paneLayout === "result" ? 0 : topHeight
+  const visibleBottomHeight = paneLayout === "editor" ? 0 : bottomHeight
+  const totalPx =
+    cellChromePx(cell, expectingResult, paneLayout) +
+    visibleTopHeight +
+    visibleBottomHeight
   return Math.max(1, Math.ceil((totalPx + marginY) / (rowHeight + marginY)))
 }
 
+// Minimum grid height for edge/corner resizing. In a split cell the south
+// edge owns only the result pane, so reserve the editor's current allocation
+// rather than merely its minimum. The middle handle is the only control that
+// repartitions editor and result heights.
+export const computeCellMinGridH = (
+  cell: NotebookCell,
+  rowHeight: number,
+  marginY: number,
+  expectingResult: boolean = false,
+  paneLayout: CellPaneLayout = resolveCellPaneLayout(cell, expectingResult),
+): number => {
+  const { topHeight } = computeCellHeights(cell, { expectingResult })
+  const minTopPx =
+    paneLayout === "result"
+      ? 0
+      : paneLayout === "editor"
+        ? minTopHeightFor(cell)
+        : Math.max(minTopHeightFor(cell), topHeight)
+  const minBottomPx = paneLayout === "editor" ? 0 : minBottomHeightFor(cell)
+  const minTotalPx =
+    minTopPx + minBottomPx + cellChromePx(cell, expectingResult, paneLayout)
+  return Math.max(1, Math.ceil((minTotalPx + marginY) / (rowHeight + marginY)))
+}
+
+// Largest grid height a south-edge drag may reach: the pane the edge owns at
+// the ceiling, plus whatever else is on screen.
+export const computeCellMaxGridH = (
+  cell: NotebookCell,
+  rowHeight: number,
+  marginY: number,
+  expectingResult: boolean = false,
+  paneLayout: CellPaneLayout = resolveCellPaneLayout(cell, expectingResult),
+): number => {
+  const { topHeight } = computeCellHeights(cell, { expectingResult })
+  const maxTopPx =
+    paneLayout === "result"
+      ? 0
+      : paneLayout === "split"
+        ? topHeight
+        : MAX_PANE_HEIGHT_PX
+  const maxBottomPx = paneLayout === "editor" ? 0 : MAX_PANE_HEIGHT_PX
+  const maxTotalPx =
+    maxTopPx + maxBottomPx + cellChromePx(cell, expectingResult, paneLayout)
+  return Math.max(1, Math.floor((maxTotalPx + marginY) / (rowHeight + marginY)))
+}
+
 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 +1868,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 } : {}),
   }
 }
 
@@ -1718,14 +1924,32 @@ export const buildAppliedLayout = (
   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, "unrequested"),
+      )
+      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, "unrequested"),
+      )
+      nextY = Math.max(nextY, existing.y + h)
+      return existing.h === h ? existing : { ...existing, h }
     }
     const cellH = computeCellGridH(
       cell,
@@ -1764,38 +1988,12 @@ 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, {
+      layout: buildAppliedLayout(request, nextCells, current.settings.layout, {
         gridCols: NOTEBOOK_GRID_COLS,
         rowHeight: NOTEBOOK_GRID_ROW_HEIGHT,
         marginY: NOTEBOOK_GRID_MARGIN_Y,
@@ -1820,16 +2018,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/store/notebook.ts b/src/store/notebook.ts
index ab7addcc9..fe5474fcb 100644
--- a/src/store/notebook.ts
+++ b/src/store/notebook.ts
@@ -37,6 +37,11 @@ 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"
+
 export type NotebookCell = {
   id: string
   position: number
@@ -53,7 +58,9 @@ export type NotebookCell = {
   mode?: CellMode
   chartConfig?: ChartConfig
   autoRefresh?: AutoRefresh
-  isViewMaximized?: boolean
+  // Stored pane view: editor, result, or editor_result. A cell without a
+  // result shows only the editor until one exists; that never rewrites it.
+  paneView?: AgentCellView
   lastRunStatus?: RunStatus
   lastRunError?: string
 }
@@ -147,6 +154,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/notebookSnapshot.test.ts b/src/utils/ai/notebookSnapshot.test.ts
index c269d3684..7f2a34a02 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"
@@ -154,6 +155,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 +215,79 @@ 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 })
+      expect(gridSnap.cells[0]).toMatchObject({
+        editor_height: "auto",
+        result_height: "auto",
+        view: "editor_result",
+      })
     } 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,
+      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,
+      result_height: null,
+    })
+  })
+
+  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",
+    })
+  })
+
+  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 +347,7 @@ describe("buildSnapshot", () => {
     const cell = sql("a", "SELECT 1", {
       mode: "draw",
       autoRefresh: "5s",
-      isViewMaximized: false,
+      paneView: "editor_result",
       name: "Trades",
       chartConfig: {
         xColumn: "ts",
@@ -317,6 +394,17 @@ describe("summarizeCells", () => {
 })
 
 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 +437,10 @@ 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("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..904e4adc5 100644
--- a/src/utils/ai/notebookSnapshot.ts
+++ b/src/utils/ai/notebookSnapshot.ts
@@ -7,6 +7,7 @@ import { readNotebookBufferMeta } from "../notebooks/notebookDexieView"
 import { NotebookToolError } from "../notebooks/notebookToolError"
 import { sanitizeForPromptContext } from "./sanitizeForPromptContext"
 import type {
+  AgentCellView,
   AutoRefresh,
   CellLayoutItem,
   NotebookCell,
@@ -15,7 +16,10 @@ 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 { getCellRunStatus, type RunStatus } from "./runStatus"
 import type { ChartConfig } from "../../scenes/Editor/Notebook/CellChart/chartTypes"
 
@@ -49,7 +53,9 @@ export type NotebookContextCell = {
   type?: "sql" | "markdown"
   mode?: "run" | "draw"
   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 +64,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 =
@@ -87,8 +93,10 @@ const truncate = (s: string, max: number): string =>
 
 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,
@@ -153,13 +161,18 @@ const refreshFields = (
 
 const buildCell = (
   cell: NotebookCell,
+  bufferId: number,
   gridByCellId: Map<string, CellLayoutItem>,
   layoutMode: "list" | "grid",
   refreshState: ReadonlyMap<string, CellRefreshView> | undefined,
 ): NotebookContextCell => {
+  const dimensions = agentCellPaneDimensions(cell)
   const out: NotebookContextCell = {
     id: cell.id,
     preview: preview(cell.value),
+    editor_height: dimensions.editorHeight,
+    result_height: dimensions.resultHeight,
+    view: agentCellPresentation(cell).view,
     ...lastRunSummary(cell),
     ...refreshFields(refreshState?.get(cell.id)),
   }
@@ -171,9 +184,6 @@ const buildCell = (
   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 +195,6 @@ const buildCell = (
         x: g.x,
         y: g.y,
         w: g.w,
-        h: computeAgentCellGridH(cell),
       }
     }
   }
@@ -224,7 +233,7 @@ export const buildSnapshot = async (
     layout_mode: layoutMode,
     maximized_cell_id: maximizedCellId,
     cells: cells.map((c) =>
-      buildCell(c, gridByCellId, layoutMode, refreshState),
+      buildCell(c, bufferId, gridByCellId, layoutMode, refreshState),
     ),
   }
   // Absence stays observable: with no configured default, nothing polls.
@@ -280,7 +289,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}`)
@@ -293,8 +304,9 @@ export const formatSnapshot = (snap: NotebookContextSnapshot): string => {
     if (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 +331,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} }`,
       )
     }
   }
@@ -434,7 +446,9 @@ export type NotebookCellDetails = {
   type?: "sql" | "markdown"
   mode?: "run" | "draw"
   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
@@ -488,12 +502,16 @@ 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 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,
+    view: agentCellPresentation(cell).view,
     ...refreshFields(refreshState?.get(cell.id)),
   }
   if (truncated) {
@@ -504,8 +522,6 @@ export const serializeCell = (
   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 00e600a5a..57edaacc5 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,11 @@ 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.
 - 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..75276d753 100644
--- a/src/utils/ai/shared.notebookTools.test.ts
+++ b/src/utils/ai/shared.notebookTools.test.ts
@@ -205,6 +205,25 @@ 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,
+    )
+
+    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(
@@ -662,6 +681,90 @@ 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,
+    )
+
+    expect(res.is_error).toBeUndefined()
+    expect(JSON.parse(res.content)).toEqual({ view: "result" })
+    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,
+    )
+
+    expect(JSON.parse(res.content)).toEqual({ view: "editor_result" })
+    expect(cellById(state, "c")?.paneView).toBe("editor_result")
+  })
+
+  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,
+    )
+
+    expect(JSON.parse(res.content)).toEqual({
+      grid: { x: 0, y: 0, w: 4 },
+      view: "editor_result",
+    })
+    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")])
@@ -1044,7 +1147,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,7 +1159,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
                 },
               ],
             },
-            grid: { x: 0, y: 0, w: 6, h: 6 },
+            grid: { x: 0, y: 0, w: 6 },
           },
         ],
       },
@@ -1071,7 +1174,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       value: "SELECT 1",
       mode: "draw",
       autoRefresh: "5s",
-      isViewMaximized: true,
+      paneView: "result",
       chartConfig: {
         xColumn: "ts",
         queries: [
@@ -1730,7 +1833,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,
@@ -1768,7 +1871,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,
           },
@@ -1886,7 +1989,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,
           },
diff --git a/src/utils/mcp/dispatchMCPTool.test.ts b/src/utils/mcp/dispatchMCPTool.test.ts
index 0523071c5..5ef14549c 100644
--- a/src/utils/mcp/dispatchMCPTool.test.ts
+++ b/src/utils/mcp/dispatchMCPTool.test.ts
@@ -173,11 +173,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/notebooks/notebookAIBridge.test.ts b/src/utils/notebooks/notebookAIBridge.test.ts
index e68b457f1..50807b92e 100644
--- a/src/utils/notebooks/notebookAIBridge.test.ts
+++ b/src/utils/notebooks/notebookAIBridge.test.ts
@@ -469,7 +469,7 @@ describe("createNotebookController — applyNotebookState maximized cell id", ()
       updateSettings: () => undefined,
       setCellMode: () => undefined,
       setCellChartConfig: () => undefined,
-      setCellViewMaximized: () => undefined,
+      setCellPaneView: () => undefined,
       setMaximizedCellId: vi.fn(),
       updateCells: () => undefined,
       applyTransition: <T>(
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..7704e76df 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,6 +8,7 @@ import type {
   NotebookViewState,
 } from "../../../store/notebook"
 import type { ChartConfig } from "../../../scenes/Editor/Notebook/CellChart/chartTypes"
+import type { AgentHeightValue } from "../../../scenes/Editor/Notebook/notebookUtils"
 import {
   type CellRunOutcome,
   CELL_CHANGED_BEFORE_RUN_NOTE,
@@ -120,9 +122,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 = {
diff --git a/src/utils/notebooks/notebookController/notebookTransitions.test.ts b/src/utils/notebooks/notebookController/notebookTransitions.test.ts
index 1262b0482..cba9206a3 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,192 @@ 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",
+      expectingResult: false,
+    })
+
+    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" })
+  })
+
+  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" })
+  })
+
+  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",
+        expectingResult: false,
+      },
+    )
+    // 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 })
+  })
+
+  it("supports an editor-only view", () => {
+    const chart = cell("a", "SELECT 1", { mode: "draw" })
+    const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
+      view: "editor",
+      expectingResult: false,
+    })
+
+    expect(out.parts.cells[0]).toMatchObject({
+      paneView: "editor",
+    })
+    expect(out.result).toEqual({ view: "editor" })
+  })
+
+  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",
+      { expectingResult: false },
+    )
+
+    expect(out.result).toEqual({ view: "editor_result" })
+    expect(out.parts.settings.layout?.[0].h).toBe(5)
+  })
+
+  it("persists a result view while the result is still missing", () => {
+    const pending = cell("a", "SELECT 1", {
+      lastRunStatus: "success",
+      paneView: "editor_result",
+    })
+    const out = setCellDimensionsTransition(
+      partsOf([pending]),
+      BUFFER_ID,
+      "a",
+      { view: "result", expectingResult: false },
+    )
+
+    expect(out.parts.cells[0].paneView).toBe("result")
+    expect(out.result).toEqual({ view: "result" })
+  })
+})
+
+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, expectingResult: false },
+    )
+
+    expect(out.result).toEqual({
+      grid: { x: 0, y: 0, w: 4 },
+      view: "editor_result",
+    })
+  })
+
+  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
diff --git a/src/utils/notebooks/notebookController/notebookTransitions.ts b/src/utils/notebooks/notebookController/notebookTransitions.ts
index 710f684ca..7c9bdac60 100644
--- a/src/utils/notebooks/notebookController/notebookTransitions.ts
+++ b/src/utils/notebooks/notebookController/notebookTransitions.ts
@@ -1,5 +1,6 @@
 import {
   MAX_NOTEBOOK_CELLS,
+  type AgentCellView,
   type AutoRefresh,
   type CellMode,
   type CellType,
@@ -11,26 +12,32 @@ import { requireCellIn, requireCellWithinLineLimit } from "../notebookDexieView"
 import type { ApplyNotebookStateRequest } from "./notebookController"
 import type { ChartConfig } from "../../../scenes/Editor/Notebook/CellChart/chartTypes"
 import {
+  agentCellDimensionsPatch,
+  applicableCellDimensions,
   buildAppliedNotebookState,
   carriedRunError,
   carriedRunStatus,
-  cellHeightPatchForRows,
+  cellGridBoundsError,
   cellModeChangePatch,
   clearCellAutoRefresh,
+  computeAgentCellGridH,
   duplicateCellAt,
   insertCell,
-  isExpectingResult,
   mergeCellChartConfig,
+  MAX_PANE_HEIGHT_PX,
+  minBottomHeightFor,
+  minTopHeightFor,
   nextGridSeedPosition,
   reconcileCellResultForValue,
-  NOTEBOOK_GRID_MARGIN_Y,
-  NOTEBOOK_GRID_ROW_HEIGHT,
+  agentCellPresentation,
+  type AgentCellPresentation,
   removeCell,
   swapCellDown,
   swapCellUp,
   topHeightForSql,
   upsertCellLayout,
   type CellGridPosition,
+  type AgentCellDimensions,
 } from "../../../scenes/Editor/Notebook/notebookUtils"
 
 // The single home for every notebook mutation's behavior. Each transition is a
@@ -279,30 +286,98 @@ export const setCellLayoutTransition = (
   parts: ViewParts,
   bufferId: number,
   cellId: string,
-  pos: CellGridPosition,
-): NotebookTransitionResult => {
+  pos: Omit<CellGridPosition, "h"> & { expectingResult?: boolean },
+): 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, pos.expectingResult),
+  }
   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),
+    },
+    touchedCellId: cellId,
+  }
+}
+
+export const setCellDimensionsTransition = (
+  parts: ViewParts,
+  bufferId: number,
+  cellId: string,
+  requested: AgentCellDimensions,
+): NotebookTransitionResult<AgentCellPresentation> => {
+  const cell = requireCellIn(parts.cells, cellId, bufferId)
+  const dimensions = applicableCellDimensions(cell, requested)
+  if (
+    typeof dimensions.editorHeight === "number" &&
+    (!Number.isFinite(dimensions.editorHeight) ||
+      dimensions.editorHeight < minTopHeightFor(cell))
+  ) {
+    throw new NotebookToolError(
+      "validation",
+      `editor_height must be at least ${minTopHeightFor(cell)}px.`,
+    )
+  }
+  if (
+    typeof dimensions.resultHeight === "number" &&
+    (!Number.isFinite(dimensions.resultHeight) ||
+      dimensions.resultHeight < minBottomHeightFor(cell))
+  ) {
+    throw new NotebookToolError(
+      "validation",
+      `result_height must be at least ${minBottomHeightFor(cell)}px for this cell.`,
+    )
+  }
+  if (
+    (typeof dimensions.editorHeight === "number" &&
+      dimensions.editorHeight > MAX_PANE_HEIGHT_PX) ||
+    (typeof dimensions.resultHeight === "number" &&
+      dimensions.resultHeight > MAX_PANE_HEIGHT_PX)
+  ) {
+    throw new NotebookToolError(
+      "validation",
+      `Pane heights must be at most ${MAX_PANE_HEIGHT_PX}px.`,
+    )
+  }
+
+  const patch = agentCellDimensionsPatch(cell, dimensions)
+  const nextCell = { ...cell, ...patch }
+  const layout = parts.settings.layout?.map((item) =>
+    item.i === cellId
+      ? {
+          ...item,
+          h: computeAgentCellGridH(nextCell, dimensions.expectingResult),
+        }
+      : item,
+  )
+  return {
+    parts: {
+      ...parts,
+      cells:
+        Object.keys(patch).length > 0
+          ? patchCellIn(parts.cells, cellId, patch)
+          : parts.cells,
+      settings:
+        layout === parts.settings.layout
+          ? parts.settings
+          : { ...parts.settings, layout },
+    },
+    result: agentCellPresentation(nextCell),
     touchedCellId: cellId,
   }
 }
@@ -348,17 +423,25 @@ export const setCellChartConfigTransition = (
   }
 }
 
-export const setCellViewMaximizedTransition = (
+export const setCellPaneViewTransition = (
   parts: ViewParts,
   bufferId: number,
   cellId: string,
-  value: boolean,
+  paneView: AgentCellView,
 ): 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,
diff --git a/src/utils/notebooks/notebookDexieController.test.ts b/src/utils/notebooks/notebookDexieController.test.ts
index 9f879628f..fb8bd8663 100644
--- a/src/utils/notebooks/notebookDexieController.test.ts
+++ b/src/utils/notebooks/notebookDexieController.test.ts
@@ -357,11 +357,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 +368,7 @@ describe("createDexieNotebookController — settings & layout", () => {
     expect(view.cells[0]).toMatchObject({
       mode: "draw",
       bottomHeight: 350,
-      isViewMaximized: false,
+      paneView: "result",
     })
   })
 
@@ -1255,14 +1254,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 +1289,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
diff --git a/src/utils/notebooks/notebookDexieView.test.ts b/src/utils/notebooks/notebookDexieView.test.ts
new file mode 100644
index 000000000..c971f22c1
--- /dev/null
+++ b/src/utils/notebooks/notebookDexieView.test.ts
@@ -0,0 +1,45 @@
+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")
+  })
+})
diff --git a/src/utils/notebooks/notebookDexieView.ts b/src/utils/notebooks/notebookDexieView.ts
index c6894e21c..f064c49ae 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 { isAgentCellView } from "../../store/notebook"
 import { NotebookToolError } from "./notebookToolError"
 import { buildPersistPayload } from "../../scenes/Editor/Notebook/notebookUtils"
 
@@ -26,8 +27,30 @@ 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.
+const migrateCellPaneView = (cell: NotebookCell): NotebookCell => {
+  const raw = cell as NotebookCell & Record<string, unknown>
+  if (cell.type === "markdown") {
+    const next = { ...raw }
+    delete next.paneView
+    delete next.isViewMaximized
+    return next as NotebookCell
+  }
+  const paneView = isAgentCellView(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/notebookToolError.ts b/src/utils/notebooks/notebookToolError.ts
index c231ab0df..90f5b10d0 100644
--- a/src/utils/notebooks/notebookToolError.ts
+++ b/src/utils/notebooks/notebookToolError.ts
@@ -11,6 +11,7 @@ export type NotebookToolErrorCode =
   | "last_cell"
   | "cell_limit"
   | "cell_too_large"
+  | "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..ccbd76742 100644
--- a/src/utils/notebooks/notebookToolMessages.ts
+++ b/src/utils/notebooks/notebookToolMessages.ts
@@ -30,6 +30,8 @@ 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 "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..eeef6dba5 100644
--- a/src/utils/tools/applyNotebookState.ts
+++ b/src/utils/tools/applyNotebookState.ts
@@ -9,7 +9,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,
@@ -216,13 +221,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)
@@ -389,8 +396,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 = {
diff --git a/src/utils/tools/dispatch.ts b/src/utils/tools/dispatch.ts
index d6be52076..179d5bda2 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,
@@ -68,10 +72,10 @@ import {
   moveCellDownTransition,
   moveCellUpTransition,
   setCellChartConfigTransition,
+  setCellDimensionsTransition,
   setCellLayoutTransition,
   setCellMaximizedTransition,
   setCellModeTransition,
-  setCellViewMaximizedTransition,
   setLayoutModeTransition,
   setNotebookAutoRefreshTransition,
   updateCellTransition,
@@ -83,6 +87,7 @@ import {
   serializeCell,
   summarizeCells,
 } from "../ai/notebookSnapshot"
+import { readCellHydration } from "../../scenes/Editor/Notebook/cellHydrationStore"
 import { generateId } from "../../scenes/Editor/Notebook/notebookUtils"
 import {
   copyNotebookSnapshots,
@@ -162,7 +167,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),
         }),
       }
@@ -498,7 +506,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.",
           }
         })
       }
@@ -813,26 +821,53 @@ 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(
             buffer_id,
-            (parts) =>
-              setCellLayoutTransition(parts, buffer_id, cell_id, {
+            (parts) => {
+              const hydration = readCellHydration(buffer_id, cell_id)
+              return setCellLayoutTransition(parts, buffer_id, cell_id, {
                 x,
                 y,
                 w,
-                h,
-              }),
+                expectingResult: hydration?.expectingResult,
+              })
+            },
+            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(() =>
+          runTransition(
+            buffer_id,
+            (parts) => {
+              const hydration = readCellHydration(buffer_id, cell_id)
+              return setCellDimensionsTransition(parts, buffer_id, cell_id, {
+                editorHeight: editor_height,
+                resultHeight: result_height,
+                view,
+                expectingResult: hydration?.expectingResult,
+              })
+            },
             signal,
           ),
         )
@@ -1039,23 +1074,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,