From d44b82222ae080066151035ee47ddcbb526ba90c Mon Sep 17 00:00:00 2001
From: emrberk <emreberk5699@gmail.com>
Date: Tue, 1 Sep 2026 19:02:07 +0300
Subject: [PATCH 1/4] refactor: use semantic notebook pane dimensions

---
 e2e/questdb                                   |   2 +-
 src/consts/shared-definitions.json            | 146 ++++--
 src/modules/ConsoleEventTracker/events.ts     |   1 +
 src/scenes/Editor/Monaco/importTabs.ts        |   8 +
 src/scenes/Editor/Notebook/cells/Cell.tsx     | 115 ++++-
 .../Editor/Notebook/cells/CellDragHeader.tsx  |   5 +-
 .../Editor/Notebook/cells/CellToolbar.tsx     |  45 +-
 .../Editor/Notebook/cells/CellViewToggle.tsx  | 146 +++---
 .../cells/useCellResizeOrchestration.ts       |  34 +-
 .../Notebook/cells/useCellRunActions.ts       |  20 +-
 src/scenes/Editor/Notebook/index.tsx          | 108 +++--
 .../Notebook/notebookPresentationStore.ts     |  47 ++
 .../Editor/Notebook/notebookUtils.test.ts     | 348 ++++++++++++--
 src/scenes/Editor/Notebook/notebookUtils.ts   | 433 ++++++++++++++----
 src/store/notebook.ts                         |   9 +
 src/utils/ai/notebookSnapshot.test.ts         | 106 ++++-
 src/utils/ai/notebookSnapshot.ts              |  72 ++-
 src/utils/ai/prompts.ts                       |   5 +-
 src/utils/ai/shared.notebookTools.test.ts     | 138 +++++-
 src/utils/mcp/dispatchMCPTool.test.ts         |   2 +-
 .../notebooks/notebookController/index.ts     |   1 +
 .../notebookController/notebookController.ts  |   9 +-
 .../notebookTransitions.test.ts               | 177 +++++++
 .../notebookController/notebookTransitions.ts | 161 ++++++-
 src/utils/notebooks/notebookToolError.ts      |   1 +
 src/utils/notebooks/notebookToolMessages.ts   |   2 +
 src/utils/tools/applyNotebookState.ts         |  24 +-
 src/utils/tools/dispatch.ts                   |  39 +-
 28 files changed, 1808 insertions(+), 396 deletions(-)
 create mode 100644 src/scenes/Editor/Notebook/notebookPresentationStore.ts

diff --git a/e2e/questdb b/e2e/questdb
index 9b59a9211..12a33d651 160000
--- a/e2e/questdb
+++ b/e2e/questdb
@@ -1 +1 @@
-Subproject commit 9b59a921165af573cedd22bf8b12613de19cb8bd
+Subproject commit 12a33d651e51e2682e7a448c8db5168fc72dfad3
diff --git a/src/consts/shared-definitions.json b/src/consts/shared-definitions.json
index 9432c14f1..e5dafbe54 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, preferred/effective view, chart config, last-run status + trimmed error). Height values are fixed CSS pixels or \"auto\". `preferred_view` is always the stored intent. A rendered cell additionally returns effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted when the cell is not rendered. Compact cannot display editor_result, so it may report `preferred_view: editor_result` with `view: result`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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 represented by editor_height/result_height. `preferred_view` is always the stored intent. A rendered cell additionally returns effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted when the cell is not rendered. Compact cannot display editor_result, so it may report `preferred_view: editor_result` with `view: result`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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. Changing w may change the responsive tier and effective view. The response includes the applied grid position and `preferred_view`; when the cell is rendered it also includes the resulting effective `view` and `tier`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing can later change tier even if grid.w stays fixed. Use set_cell_dimensions to resize a cell or change its preferred 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 preferred 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. view accepts editor, result, or editor_result. Wide cells support all three. Compact cells support editor/result; editor_result deterministically displays as result and is restored if the cell becomes wide. Cells without a result display editor. The response always reports `preferred_view`; when the cell is rendered it also reports effective `view` and live-only `tier` (`wide` or `compact`) as a pair, and may report a `fallback`. For markdown, editor_height sizes the rendered content, result_height must be null, and view must be null or editor; never use the structural 26px minimum for non-empty prose—use at least 56px, or 86px for a polished title. Chart result_height must be at least 240px; table results at least 100px.",
+    "inputSchema": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "buffer_id": {
           "type": "number"
         },
-        "h": {
-          "type": "number"
+        "cell_id": {
+          "type": "string"
+        },
+        "editor_height": {
+          "anyOf": [
+            { "type": "number", "minimum": 26 },
+            { "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. Non-empty markdown should be at least 56px; use 86px for a polished title."
+        },
+        "result_height": {
+          "anyOf": [
+            { "type": "number", "minimum": 100 },
+            { "type": "string", "enum": ["auto"] },
+            { "type": "null" }
+          ],
+          "description": "Result/chart pane height in CSS pixels. Null preserves, \"auto\" restores result-driven sizing."
+        },
+        "view": {
+          "anyOf": [
+            { "type": "string", "enum": ["editor", "result", "editor_result"] },
+            { "type": "null" }
+          ],
+          "description": "Stored pane preference. Null preserves. Wide supports editor, result, and editor_result. Compact supports editor/result and displays editor_result as result; the preference is restored when wide. A cell without a result displays editor."
         }
       },
-      "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",
@@ -855,9 +883,31 @@
                 ],
                 "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."
               },
-              "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": 26 },
+                  { "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. Non-empty markdown should be at least 56px; use 86px for a polished title."
+              },
+              "result_height": {
+                "anyOf": [
+                  { "type": "number", "minimum": 100 },
+                  { "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 240px; tables 100px. Must be null for markdown."
+              },
+              "view": {
+                "anyOf": [
+                  {
+                    "type": "string",
+                    "enum": ["editor", "result", "editor_result"]
+                  },
+                  { "type": "null" }
+                ],
+                "description": "Stored pane preference. Null preserves an existing setting. New draw cells default to result; other new SQL cells show editor until a result exists. Wide supports editor, result, and editor_result. Compact supports editor/result and displays editor_result as result, restoring the preference when wide. A cell without a result displays editor. Markdown requires null or editor."
               },
               "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 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. Each cell always reports stored `preferred_view`. Rendered cells additionally report effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted for inactive or unmounted cells. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. Pass include_user_events=true to also receive the digest of edits the user made since your last fetch.",
     "inputSchema": {
       "type": "object",
       "properties": {
diff --git a/src/modules/ConsoleEventTracker/events.ts b/src/modules/ConsoleEventTracker/events.ts
index 90f6425bd..c58ea67fc 100644
--- a/src/modules/ConsoleEventTracker/events.ts
+++ b/src/modules/ConsoleEventTracker/events.ts
@@ -163,6 +163,7 @@ 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",
diff --git a/src/scenes/Editor/Monaco/importTabs.ts b/src/scenes/Editor/Monaco/importTabs.ts
index 6bff47206..6164e41d2 100644
--- a/src/scenes/Editor/Monaco/importTabs.ts
+++ b/src/scenes/Editor/Monaco/importTabs.ts
@@ -273,6 +273,14 @@ const sanitizeNotebookCell = (
   if (isAutoRefresh(item.autoRefresh)) cell.autoRefresh = item.autoRefresh
   if (typeof item.isViewMaximized === "boolean")
     cell.isViewMaximized = item.isViewMaximized
+  if (
+    item.wideView === "editor" ||
+    item.wideView === "result" ||
+    item.wideView === "editor_result"
+  )
+    cell.wideView = item.wideView
+  if (item.compactView === "editor" || item.compactView === "result")
+    cell.compactView = item.compactView
   if (typeof item.topHeight === "number") cell.topHeight = item.topHeight
   if (typeof item.bottomHeight === "number")
     cell.bottomHeight = item.bottomHeight
diff --git a/src/scenes/Editor/Notebook/cells/Cell.tsx b/src/scenes/Editor/Notebook/cells/Cell.tsx
index 88fe7d161..1aae11406 100644
--- a/src/scenes/Editor/Notebook/cells/Cell.tsx
+++ b/src/scenes/Editor/Notebook/cells/Cell.tsx
@@ -30,12 +30,15 @@ import { toast } from "../../../../components/Toast"
 import {
   CELL_EDITOR_LINE_HEIGHT,
   CELL_EDITOR_PADDING,
+  computeCellHeights,
   isDoubleView,
   isExpectingResult,
-  MIN_BOTTOM_HEIGHT_PX,
+  minBottomHeightFor,
   resolveAutoRefresh,
+  resolveCellPaneLayout,
   resolveCellView,
 } from "../notebookUtils"
+import type { CellToolbarTier } from "../notebookUtils"
 import {
   useCellContentMode,
   useCellVirtualizationEngine,
@@ -51,6 +54,7 @@ import {
   useCellResizeOrchestration,
 } from "./useCellResizeOrchestration"
 import { CellBottomContent } from "./CellBottomContent"
+import { publishLiveCellPresentation } from "../notebookPresentationStore"
 import { getMonacoThemeName } from "../../../../utils/monacoInit"
 
 const EditorContainer = styled.div<{ $spotlight: boolean }>`
@@ -109,6 +113,8 @@ const HiddenCellStatus = styled.span`
   white-space: nowrap;
 `
 
+const GRID_PANE_EXPANSION_FALLBACK_MS = 250
+
 type Props = {
   cell: NotebookCell
   index: number
@@ -118,6 +124,8 @@ type Props = {
   isFocused: boolean
   isMaximized: boolean
   isRunning: boolean
+  toolbarTierOverride?: CellToolbarTier
+  gridContainerWidth?: number
 }
 
 const CellInner: React.FC<Props> = ({
@@ -129,6 +137,8 @@ const CellInner: React.FC<Props> = ({
   isFocused,
   isMaximized,
   isRunning,
+  toolbarTierOverride,
+  gridContainerWidth,
 }) => {
   const { setCellChartConfig, clearCellResult, updateCell, setFocusedCell } =
     useNotebookActions()
@@ -147,7 +157,8 @@ const CellInner: React.FC<Props> = ({
   const resultRef = useRef<HTMLDivElement | null>(null)
   const headerRef = useRef<HTMLDivElement | null>(null)
 
-  const toolbarTier = useCellToolbarTier(headerRef, isMaximized)
+  const observedToolbarTier = useCellToolbarTier(headerRef, isMaximized)
+  const toolbarTier = toolbarTierOverride ?? observedToolbarTier
   const { loading: chartLoading, refreshing: chartRefreshing } =
     useChartLoading(cell)
   const chartZoomed = useChartZoomed(cell.id)
@@ -174,14 +185,82 @@ 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 targetPaneLayout = resolveCellPaneLayout(
+    cell,
+    expectingResult,
+    isCompactTier,
+  )
+  const [paneLayout, setPaneLayout] = React.useState(targetPaneLayout)
+  const resolvedPaneHeights = computeCellHeights(cell, { expectingResult })
+
+  React.useLayoutEffect(() => {
+    if (paneLayout === targetPaneLayout) return undefined
+
+    // Switch immediately before a shrink. Before an expansion, keep the old
+    // pane mounted until RGL has made room for the incoming pane. This applies
+    // to compact editor/result swaps as well as compact -> split.
+    const paneHeight = (layout: typeof paneLayout) =>
+      layout === "editor"
+        ? resolvedPaneHeights.topHeight
+        : layout === "result"
+          ? resolvedPaneHeights.bottomHeight
+          : resolvedPaneHeights.topHeight + resolvedPaneHeights.bottomHeight
+    const expandingPresentation =
+      layoutMode === "grid" &&
+      !isMaximized &&
+      paneHeight(targetPaneLayout) > paneHeight(paneLayout)
+    if (!expandingPresentation) {
+      setPaneLayout(targetPaneLayout)
+      return undefined
+    }
+
+    const gridItem =
+      wrapperRef.current?.closest<HTMLElement>(".react-grid-item")
+    if (!gridItem) {
+      setPaneLayout(targetPaneLayout)
+      return undefined
+    }
+
+    let settled = false
+    const finish = () => {
+      if (settled) return
+      settled = true
+      setPaneLayout(targetPaneLayout)
+    }
+    const onTransitionEnd = (event: TransitionEvent) => {
+      if (event.target === gridItem && event.propertyName === "height") finish()
+    }
+    gridItem.addEventListener("transitionend", onTransitionEnd)
+    const fallback = window.setTimeout(finish, GRID_PANE_EXPANSION_FALLBACK_MS)
+    return () => {
+      settled = true
+      window.clearTimeout(fallback)
+      gridItem.removeEventListener("transitionend", onTransitionEnd)
+    }
+  }, [
+    isMaximized,
+    layoutMode,
+    paneLayout,
+    resolvedPaneHeights.bottomHeight,
+    resolvedPaneHeights.topHeight,
+    targetPaneLayout,
+    wrapperRef,
+  ])
+
+  useEffect(
+    () =>
+      publishLiveCellPresentation(bufferIdForEvents, cell.id, {
+        compact: isCompactTier,
+        paneLayout,
+        ...(gridContainerWidth !== undefined ? { gridContainerWidth } : {}),
+      }),
+    [bufferIdForEvents, cell.id, gridContainerWidth, isCompactTier, paneLayout],
+  )
+
+  const isViewMaximized = paneLayout === "result"
+  const showBottomSlot = paneLayout !== "editor"
+  const isSplit = paneLayout === "split"
   const runActive = !isDrawMode && doubleView
   const view = resolveCellView(cell)
   const canRun = !!stripSQLComments(cell.value).trim()
@@ -425,6 +504,7 @@ const CellInner: React.FC<Props> = ({
         isRunning={isRunning}
         headerRef={headerRef}
         toolbarTier={toolbarTier}
+        paneLayout={paneLayout}
         chartZoomed={chartZoomed}
         left={
           <CellNameLabel
@@ -561,8 +641,8 @@ 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}
@@ -571,7 +651,7 @@ const CellInner: React.FC<Props> = ({
             isViewMaximized
               ? isMaximized
                 ? { flex: 1 }
-                : { height: topHeight + bottomHeight }
+                : { height: bottomHeight }
               : isMaximized
                 ? { flex: 1 - spotlightEditorRatio }
                 : { height: bottomHeight }
@@ -615,15 +695,12 @@ const CellInner: React.FC<Props> = ({
         }}
         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
+          isViewMaximized || 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..8291bf0fe 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 {
@@ -102,6 +102,7 @@ export const CellToolbar: React.FC<Props> = ({
     setCellRefresh,
     setCellViewMaximized,
     setCellMode,
+    updateCell,
   } = useNotebookActions()
   const bufferId = useNotebookBufferId()
 
@@ -114,7 +115,11 @@ export const CellToolbar: React.FC<Props> = ({
   const isChartView = view === "chart"
   const isGridView = view === "grid"
   const isNoneView = view === "none"
-  const isViewMaximized = !isNoneView && !!cell.isViewMaximized
+  const isViewMaximized =
+    !isNoneView &&
+    (paneLayout !== undefined
+      ? paneLayout === "result"
+      : !!cell.isViewMaximized)
   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.
@@ -142,22 +147,24 @@ 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,
+    // Compact cells cannot split, so showing the editor temporarily hides the
+    // result without dropping its data.
+    sqlShown: paneLayout === "editor",
     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)
+    if (toolbarTier === "compact") updateCell(cellId, { compactView: "editor" })
+    else setCellViewMaximized(cellId, false)
   }
   const handleViewTable = () => {
     if (isRunning) return
@@ -173,7 +180,8 @@ export const CellToolbar: React.FC<Props> = ({
     // A chart transfers its data to the grid (no re-query); restore the data
     // pane in case the SQL was being shown.
     if (isChartView) setCellMode(cellId, "run")
-    setCellViewMaximized(cellId, true)
+    if (toolbarTier === "compact") updateCell(cellId, { compactView: "result" })
+    else setCellViewMaximized(cellId, true)
   }
   const handleViewChart = () => {
     if (isRunning) return
@@ -188,15 +196,16 @@ export const CellToolbar: React.FC<Props> = ({
       eventBus.publish(EventType.NOTEBOOK_CELL_DRAW, { cellId, maximize: true })
       return
     }
-    setCellViewMaximized(cellId, true)
+    if (toolbarTier === "compact") updateCell(cellId, { compactView: "result" })
+    else setCellViewMaximized(cellId, true)
   }
   const handleToggleMaximizeView = () => {
     void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_MAXIMIZE, {
-      isViewMaximized: !cell.isViewMaximized,
+      isViewMaximized: !isViewMaximized,
       view,
     })
     signalUserEdit(bufferId)
-    setCellViewMaximized(cellId, !cell.isViewMaximized)
+    setCellViewMaximized(cellId, !isViewMaximized)
   }
   const handleMaximizeCell = () => {
     void trackEvent(ConsoleEvent.NOTEBOOK_CELL_MAXIMIZE, {
@@ -310,7 +319,7 @@ export const CellToolbar: React.FC<Props> = ({
                   onSelect={handleViewSql}
                   icon={<FileSqlIcon size={16} />}
                 >
-                  View SQL
+                  View editor
                 </DropdownMenu.Item>
               )}
               {showViewTable && (
@@ -340,15 +349,9 @@ export const CellToolbar: React.FC<Props> = ({
               {showSplitItem && (
                 <DropdownMenu.Item
                   onSelect={handleToggleMaximizeView}
-                  icon={
-                    isViewMaximized ? (
-                      <ArrowsInLineVerticalIcon size={16} />
-                    ) : (
-                      <ArrowsOutLineVerticalIcon size={16} />
-                    )
-                  }
+                  icon={<FileSqlIcon size={16} />}
                 >
-                  {isViewMaximized ? "Split view" : "Maximized view"}
+                  {isViewMaximized ? "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..1c90b29e8 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,
@@ -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,10 +47,28 @@ 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
@@ -102,7 +123,7 @@ export const CellViewToggle: React.FC<Props> = ({
     }
     setCellMode(cellId, "run")
   }
-  const handleSplit = (e: React.MouseEvent) => {
+  const handleEditorVisibility = (e: React.MouseEvent) => {
     e.stopPropagation()
     void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_MAXIMIZE, {
       isViewMaximized: !isViewMaximized,
@@ -118,59 +139,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={isViewMaximized ? "Show editor" : "Hide editor"}>
+        <EditorVisibilityToggle
+          aria-label={isViewMaximized ? "Show editor" : "Hide editor"}
+          onClick={handleEditorVisibility}
+          selected={!isViewMaximized}
         >
-          {isViewMaximized ? (
-            <ArrowsInLineVerticalIcon />
-          ) : (
-            <ArrowsOutLineVerticalIcon />
-          )}
-        </ViewIconButton>
+          <FileSqlIcon size={18} />
+        </EditorVisibilityToggle>
       </Tooltip>
       {view === "chart" && chartZoomed && (
         <Tooltip content="Reset zoom">
@@ -179,6 +199,6 @@ export const CellViewToggle: React.FC<Props> = ({
           </ViewIconButton>
         </Tooltip>
       )}
-    </NotebookViewToggle>
+    </ViewActions>
   )
 }
diff --git a/src/scenes/Editor/Notebook/cells/useCellResizeOrchestration.ts b/src/scenes/Editor/Notebook/cells/useCellResizeOrchestration.ts
index 64e2cf6ce..60ca9758c 100644
--- a/src/scenes/Editor/Notebook/cells/useCellResizeOrchestration.ts
+++ b/src/scenes/Editor/Notebook/cells/useCellResizeOrchestration.ts
@@ -10,9 +10,8 @@ import { ConsoleEvent } from "../../../../modules/ConsoleEventTracker/events"
 import {
   computeCellHeights,
   hasAgentVisibleCellHeightChanged,
-  MIN_BOTTOM_HEIGHT_PX,
+  minBottomHeightFor,
   partitionCellHeights,
-  scaleCellHeights,
   topHeightForSql,
 } from "../notebookUtils"
 
@@ -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,31 +205,14 @@ 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).
+  // With the editor hidden, resizing changes only the visible result pane.
+  // The editor allocation stays intact for a later restore.
   const maximizedChartResizeLive = (newTotalHeight: number) => {
-    const { top, bottom } = scaleCellHeights(
-      topHeight,
-      bottomHeight,
-      newTotalHeight,
-      MIN_EDITOR_HEIGHT,
-      MIN_BOTTOM_HEIGHT_PX,
-    )
-    topResize.resizeLive(top)
-    bottomResize.resizeLive(bottom)
+    bottomResize.resizeLive(newTotalHeight)
   }
 
   const maximizedChartResizeEnd = (newTotalHeight: number) => {
-    const { top, bottom } = scaleCellHeights(
-      topHeight,
-      bottomHeight,
-      newTotalHeight,
-      MIN_EDITOR_HEIGHT,
-      MIN_BOTTOM_HEIGHT_PX,
-    )
-    topResize.resizeEnd(top)
-    bottomResize.resizeEnd(bottom)
+    bottomResize.resizeEnd(newTotalHeight)
   }
 
   useEffect(() => {
diff --git a/src/scenes/Editor/Notebook/cells/useCellRunActions.ts b/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
index 53fc2985f..668bdce38 100644
--- a/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
+++ b/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
@@ -47,6 +47,7 @@ export const useCellRunActions = ({
     setCellMode,
     clearCellResult,
     setCellViewMaximized,
+    updateCell,
     getCellsSnapshot,
   } = useNotebookActions()
   const bufferIdForEvents = useNotebookBufferId()
@@ -232,7 +233,10 @@ export const useCellRunActions = ({
       // the run must read the cursor first.
       if (plan.kind === "run-all") void handleRunAll(ignoreSelection)
       else void handleRunSingle()
-      if (plan.reveal) setCellViewMaximized(cell.id, true)
+      if (plan.reveal) {
+        if (isCompactTier) updateCell(cell.id, { compactView: "result" })
+        else setCellViewMaximized(cell.id, true)
+      }
     },
     [
       cell.id,
@@ -242,6 +246,7 @@ export const useCellRunActions = ({
       isCompactTier,
       showBottomSlot,
       setCellViewMaximized,
+      updateCell,
       setCellMode,
       handleRunAll,
       handleRunSingle,
@@ -292,7 +297,9 @@ export const useCellRunActions = ({
     const drawHandler = (payload?: { cellId?: string; maximize?: boolean }) => {
       if (payload?.cellId !== cell.id) return
       void handleDrawClick().then((entered) => {
-        if (entered && payload.maximize) setCellViewMaximized(cell.id, true)
+        if (!entered || !payload.maximize) return
+        if (isCompactTier) updateCell(cell.id, { compactView: "result" })
+        else setCellViewMaximized(cell.id, true)
       })
     }
     eventBus.subscribe(EventType.NOTEBOOK_CELL_RUN, runHandler)
@@ -301,7 +308,14 @@ 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,
+    isCompactTier,
+    setCellViewMaximized,
+    updateCell,
+  ])
 
   const isGridLoading = isRunning && firstRunRef.current
 
diff --git a/src/scenes/Editor/Notebook/index.tsx b/src/scenes/Editor/Notebook/index.tsx
index e68221c2c..850c640a9 100644
--- a/src/scenes/Editor/Notebook/index.tsx
+++ b/src/scenes/Editor/Notebook/index.tsx
@@ -35,19 +35,20 @@ import { NotebookToolbar } from "./NotebookToolbar"
 import { NotebookMcpPromo } from "./NotebookMcpPromo"
 import { renderEdgeHandle } from "./resize"
 import {
-  cellChromePx,
   cellHeightPatchForRows,
+  gridCellToolbarTier,
   computeCellGridH,
+  computeCellMinGridH,
   generateDefaultLayout as generateDefaultLayoutPure,
-  isDoubleView,
   isExpectingResult,
   mergeCellLayout,
-  MIN_BOTTOM_HEIGHT_PX,
-  minTopHeightFor,
+  resolveCellPaneLayout,
   NOTEBOOK_GRID_COLS,
+  NOTEBOOK_GRID_MARGIN_X,
   NOTEBOOK_GRID_MARGIN_Y,
   NOTEBOOK_GRID_ROW_HEIGHT,
 } from "./notebookUtils"
+import type { CellToolbarTier } from "./notebookUtils"
 import {
   emitUserAction,
   on as onUserAction,
@@ -180,7 +181,7 @@ const MIN_CELL_W = 2
 // unwanted hard floor in grid mode.
 const MIN_CELL_H = 5
 
-const GRID_MARGIN_X = 20
+const GRID_MARGIN_X = NOTEBOOK_GRID_MARGIN_X
 const GRID_MARGIN_Y = NOTEBOOK_GRID_MARGIN_Y
 const GRID_MARGIN: [number, number] = [GRID_MARGIN_X, GRID_MARGIN_Y]
 const GRID_CONTAINER_PADDING: [number, number] = [0, 0]
@@ -333,13 +334,23 @@ type CellViewProps = {
   isFocused: boolean
   isMaximized: boolean
   isRunning: boolean
+  toolbarTierOverride?: CellToolbarTier
+  gridContainerWidth?: number
 }
 
-const CellView: React.FC<CellViewProps> = ({ autoRefreshDefault, ...props }) =>
+const CellView: React.FC<CellViewProps> = ({
+  autoRefreshDefault,
+  toolbarTierOverride,
+  ...props
+}) =>
   props.cell.type === "markdown" ? (
     <MarkdownCell {...props} />
   ) : (
-    <Cell {...props} autoRefreshDefault={autoRefreshDefault} />
+    <Cell
+      {...props}
+      autoRefreshDefault={autoRefreshDefault}
+      toolbarTierOverride={toolbarTierOverride}
+    />
   )
 
 const ListLayout: React.FC = () => {
@@ -424,7 +435,7 @@ const GridLayout: React.FC = () => {
   // shadow that only matters when react-grid-layout consumes it. The
   // memo recomputes when the layout, the cells or a statusOf boundary
   // (resultStatusVersion) changes
-  const { computedLayout, layoutKey } = useMemo(() => {
+  const { computedLayout, layoutKey, toolbarTierByCellId } = useMemo(() => {
     const mergedLayout = mergeCellLayout(
       settings.layout && settings.layout.length > 0
         ? settings.layout
@@ -433,6 +444,7 @@ const GridLayout: React.FC = () => {
       LAYOUT_OPTS,
     ) as LayoutItem[]
     const cellById = new Map(cells.map((c) => [c.id, c]))
+    const tiers = new Map<string, CellToolbarTier>()
     const computed = mergedLayout.map((item) => {
       const cell = cellById.get(item.i)
       if (!cell) return item
@@ -440,18 +452,29 @@ 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 toolbarTier = gridCellToolbarTier(containerWidth, item.w)
+      const paneLayout = resolveCellPaneLayout(
+        cell,
+        expectingResult,
+        toolbarTier === "compact",
+      )
+      tiers.set(cell.id, toolbarTier)
+      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,
       }
     })
@@ -463,8 +486,15 @@ const GridLayout: React.FC = () => {
             `${item.i}:${item.x}:${item.y}:${item.w}:${item.h}:${item.minH}`,
         )
         .join("|"),
+      toolbarTierByCellId: tiers,
     }
-  }, [settings.layout, cells, resultHydration, resultStatusVersion])
+  }, [
+    settings.layout,
+    cells,
+    resultHydration,
+    resultStatusVersion,
+    containerWidth,
+  ])
 
   const currentLayout = useMemo(() => computedLayout, [layoutKey])
   const gridLayouts = useMemo(
@@ -527,22 +557,33 @@ 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(
+      // A width-only resize may cross the compact breakpoint and therefore
+      // change the cell's derived h. Do not mistake the old h carried by RGL
+      // for an intentional pane-height resize; only back-solve when the user
+      // actually moved the vertical edge.
+      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 toolbarTier = gridCellToolbarTier(containerWidth, newItem.w)
+          const paneLayout = resolveCellPaneLayout(
+            cell,
+            expectingResult,
+            toolbarTier === "compact",
+          )
+          const patch = cellHeightPatchForRows(
+            cell,
+            newItem.h,
+            ROW_HEIGHT,
+            GRID_MARGIN_Y,
+            expectingResult,
+            paneLayout,
+          )
+          if (Object.keys(patch).length > 0) updateCell(cell.id, patch)
+        }
       }
       if (typeof activeBuffer.id === "number") {
         emitUserAction({
@@ -558,6 +599,7 @@ const GridLayout: React.FC = () => {
       cells,
       activeBuffer.id,
       resultHydration,
+      containerWidth,
     ],
   )
 
@@ -657,6 +699,8 @@ const GridLayout: React.FC = () => {
                 isFocused={focusedCellId === cell.id}
                 isMaximized={maximizedCellId === cell.id}
                 isRunning={runningCellIds.has(cell.id)}
+                toolbarTierOverride={toolbarTierByCellId.get(cell.id)}
+                gridContainerWidth={containerWidth}
               />
             </GridCellWrapper>
           ))}
diff --git a/src/scenes/Editor/Notebook/notebookPresentationStore.ts b/src/scenes/Editor/Notebook/notebookPresentationStore.ts
new file mode 100644
index 000000000..1604a327b
--- /dev/null
+++ b/src/scenes/Editor/Notebook/notebookPresentationStore.ts
@@ -0,0 +1,47 @@
+import type { CellPaneLayout } from "./notebookUtils"
+
+export type LiveCellPresentation = {
+  compact: boolean
+  paneLayout: CellPaneLayout
+  // Present for grid cells. Tool mutations use the same measured container
+  // width as the renderer to resolve the tier produced by a new grid.w.
+  gridContainerWidth?: number
+}
+
+const presentations = new Map<
+  number,
+  Map<string, { token: symbol; value: LiveCellPresentation }>
+>()
+
+// Presentation is deliberately runtime-only: resizing a browser window must
+// not rewrite the notebook document. Live AI/MCP reads still need the exact
+// pane currently on screen, so mounted cells publish it here.
+export const publishLiveCellPresentation = (
+  bufferId: number,
+  cellId: string,
+  value: LiveCellPresentation,
+): (() => void) => {
+  const token = Symbol(cellId)
+  const cells =
+    presentations.get(bufferId) ??
+    new Map<string, { token: symbol; value: LiveCellPresentation }>()
+  cells.set(cellId, { token, value })
+  presentations.set(bufferId, cells)
+
+  return () => {
+    const current = presentations.get(bufferId)?.get(cellId)
+    if (current?.token !== token) return
+    cells.delete(cellId)
+    if (cells.size === 0) presentations.delete(bufferId)
+  }
+}
+
+export const readLiveCellPresentation = (
+  bufferId: number,
+  cellId: string,
+): LiveCellPresentation | undefined =>
+  presentations.get(bufferId)?.get(cellId)?.value
+
+export const __resetNotebookPresentationStoreForTests = (): void => {
+  presentations.clear()
+}
diff --git a/src/scenes/Editor/Notebook/notebookUtils.test.ts b/src/scenes/Editor/Notebook/notebookUtils.test.ts
index deaa6f9b9..ceca0d01d 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,6 +9,8 @@ import {
   AUTO_REFRESH_OPTIONS,
   isAutoRefresh,
   resolveCellView,
+  resolveAgentCellPresentation,
+  resolveCellPaneLayout,
   resolveRunAction,
   buildAppliedCells,
   buildAppliedLayout,
@@ -27,6 +30,7 @@ import {
   computeAgentCellGridH,
   computeCellGridH,
   computeCellHeights,
+  computeCellMinGridH,
   computeResultBottomHeight,
   DEFAULT_CHART_BOTTOM_HEIGHT,
   duplicateCellAt,
@@ -54,7 +58,6 @@ import {
   statementKeysFor,
   removeCell,
   resolveRunCompletion,
-  scaleCellHeights,
   setResultAt,
   singleResultFromExec,
   snapMarkdownTopHeight,
@@ -1203,6 +1206,74 @@ 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].wideView).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: 280,
+          view: "editor_result",
+          chartConfig: {
+            xColumn: "ts",
+            queries: [{ type: "line", yColumns: ["v"] }],
+          },
+        },
+      ],
+    })
+
+    expect(nextCells[0]).toMatchObject({
+      topHeight: 120,
+      topResized: true,
+      bottomHeight: 280,
+      bottomResized: true,
+      isViewMaximized: false,
+      wideView: "editor_result",
+      compactView: "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,
+      isViewMaximized: false,
+      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,
+      isViewMaximized: false,
+    })
   })
 
   it("apply is a PUT: mode='draw' with no chart_config throws even when the existing cell had one (no merge)", () => {
@@ -1227,7 +1298,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[] = [
       {
@@ -1253,7 +1324,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].isViewMaximized).toBe(true)
   })
 
   it("preserves draw mode when apply omits mode and supplies its full chart", () => {
@@ -1581,36 +1652,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 })
   })
 })
 
@@ -1769,9 +1839,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(
         {
@@ -1786,7 +1856,168 @@ describe("computeCellGridH", () => {
         10,
         20,
       ),
-    ).toBe(8)
+    ).toBe(6)
+  })
+
+  it("compact cells derive 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, false)).toBe("editor")
+    expect(resolveCellPaneLayout(cell, false, true)).toBe("editor")
+  })
+
+  it("uses persisted visibility for wide cells", () => {
+    expect(resolveCellPaneLayout(withResult(), false, false)).toBe("split")
+    expect(
+      resolveCellPaneLayout(
+        withResult({ isViewMaximized: true }),
+        false,
+        false,
+      ),
+    ).toBe("result")
+    expect(
+      resolveCellPaneLayout(withResult({ wideView: "editor" }), false, false),
+    ).toBe("editor")
+  })
+
+  it("defaults compact cells to result and keeps compact choice independent", () => {
+    expect(resolveCellPaneLayout(withResult(), false, true)).toBe("result")
+    expect(
+      resolveCellPaneLayout(
+        withResult({ isViewMaximized: true, compactView: "editor" }),
+        false,
+        true,
+      ),
+    ).toBe("editor")
+    expect(
+      resolveCellPaneLayout(
+        withResult({ isViewMaximized: false, compactView: "result" }),
+        false,
+        true,
+      ),
+    ).toBe("result")
+  })
+})
+
+describe("resolveAgentCellPresentation", () => {
+  const chart = (over: Partial<NotebookCell> = {}): NotebookCell => ({
+    id: "x",
+    position: 0,
+    value: "SELECT 1",
+    mode: "draw",
+    wideView: "editor_result",
+    compactView: "result",
+    ...over,
+  })
+
+  it("returns the effective live view with its tier", () => {
+    expect(
+      resolveAgentCellPresentation(chart({ wideView: "editor" }), false),
+    ).toEqual({
+      preferred_view: "editor",
+      view: "editor",
+      tier: "wide",
+    })
+    expect(resolveAgentCellPresentation(chart(), true)).toEqual({
+      preferred_view: "editor_result",
+      view: "result",
+      tier: "compact",
+    })
+  })
+
+  it("omits tier and returns the stored preference when inactive", () => {
+    expect(resolveAgentCellPresentation(chart(), undefined)).toEqual({
+      preferred_view: "editor_result",
+    })
+  })
+})
+
+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,
+      isViewMaximized: true,
+      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 + 240px chart minimum + 50px split chrome requires 24 rows.
+    expect(computeCellMinGridH(cell, 10, 20)).toBe(24)
+  })
+
+  it("uses only the visible pane minimum in compact 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)
   })
 })
 
@@ -1964,22 +2195,44 @@ describe("cellHeightPatchForRows", () => {
     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 = cellHeightPatchForRows(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,
     })
     // When a taller height is requested (targetContentPx = 430 - 44 = 386,
-    // scale 386/172 ≈ 2.244)
+    // and no editor allocation in its visible footprint)
     const patch = cellHeightPatchForRows(c, 15, 10, 20)
-    // Then editor and result scale together, both pinned
+    // Then only the result changes; the remembered editor height is untouched
     expect(patch).toEqual({
-      topHeight: 162,
-      bottomHeight: 224,
+      bottomHeight: 386,
+      bottomResized: true,
+    })
+  })
+
+  it("compact editor/result resize only their visible pane", () => {
+    const c = withResult({ topHeight: 200, bottomHeight: 300 })
+
+    expect(cellHeightPatchForRows(c, 10, 10, 20, false, "editor")).toEqual({
+      topHeight: 236,
       topResized: true,
+    })
+    expect(cellHeightPatchForRows(c, 15, 10, 20, false, "result")).toEqual({
+      bottomHeight: 386,
       bottomResized: true,
     })
   })
@@ -2273,10 +2526,11 @@ 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. The supplied legacy h is ignored;
+    // 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", () => {
@@ -2287,7 +2541,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)", () => {
diff --git a/src/scenes/Editor/Notebook/notebookUtils.ts b/src/scenes/Editor/Notebook/notebookUtils.ts
index fd78e7b03..6b49060ac 100644
--- a/src/scenes/Editor/Notebook/notebookUtils.ts
+++ b/src/scenes/Editor/Notebook/notebookUtils.ts
@@ -1,5 +1,7 @@
 import type { QueryExecResult } from "../../../hooks/useQueryExecution"
 import type {
+  AgentCellView,
+  AgentCellTier,
   AutoRefresh,
   AutoRefreshInterval,
   CellLayoutItem,
@@ -103,13 +105,13 @@ export const resolveRunAction = (
     intent: "all" | "single"
   },
 ): RunActionPlan => {
-  // Reveal only the compact "View SQL" collapse — in wider tiers the slot is
+  // Reveal only the compact "View editor" collapse — in wider tiers the slot is
   // never force-hidden, so revealing there would wrongly maximize a split view.
   const reveal = opts.isCompactTier && !opts.showBottomSlot
   if (cell.mode === "draw" && !reveal) {
     return opts.intent === "all" ? { kind: "chart" } : { kind: "noop" }
   }
-  // Run mode, or a draw cell collapsed behind the compact "View SQL" editor:
+  // Run mode, or a draw cell collapsed behind the compact editor 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.
@@ -124,6 +126,7 @@ export type CellToolbarTier = "compact" | "standard" | "expanded"
 
 export const CELL_TOOLBAR_STANDARD_MIN = 480
 export const CELL_TOOLBAR_EXPANDED_MIN = 720
+export const NOTEBOOK_GRID_MARGIN_X = 20
 
 export const cellToolbarTier = (
   width: number,
@@ -135,6 +138,21 @@ export const cellToolbarTier = (
       ? "standard"
       : "compact"
 
+export const gridCellToolbarTier = (
+  containerWidth: number,
+  widthInColumns: number,
+): CellToolbarTier => {
+  const columnWidth =
+    (containerWidth - NOTEBOOK_GRID_MARGIN_X * (NOTEBOOK_GRID_COLS - 1)) /
+    NOTEBOOK_GRID_COLS
+  const itemWidth =
+    columnWidth * widthInColumns +
+    NOTEBOOK_GRID_MARGIN_X * Math.max(0, widthInColumns - 1)
+  // CellWrapper contributes a one-pixel border on each side; the header's
+  // ResizeObserver measures the inner border box.
+  return cellToolbarTier(Math.max(0, itemWidth - 2), false)
+}
+
 export type CellToolbarMenuFlags = {
   showViewSql: boolean
   showViewTable: boolean
@@ -155,9 +173,8 @@ 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. `sqlShown` is the compact-tier "View editor" state.
+// Markdown cells (no run/draw views) keep just the move/duplicate/delete items.
 export const cellToolbarMenuFlags = (params: {
   tier: CellToolbarTier
   view: CellView
@@ -698,9 +715,14 @@ type ApplyCellRequest = {
   type?: CellType | null
   mode?: CellMode | null
   autoRefresh?: AutoRefresh | null
+  editorHeight?: number | "auto" | null
+  resultHeight?: number | "auto" | null
+  view?: AgentCellView | null
+  editorVisible?: boolean | null
+  // Legacy cached-agent inputs. New tool schemas expose view instead.
   isViewMaximized?: boolean | null
   chartConfig?: ChartConfig | null
-  grid?: { x: number; y: number; w: number; h: number } | null
+  grid?: { x: number; y: number; w: number; h?: number } | null
 }
 
 type ApplyRequest = {
@@ -1152,12 +1174,72 @@ export const buildAppliedCells = (
     }
 
     const isDraw = resolvedMode === "draw"
-    const isViewMaximized =
-      req.isViewMaximized != null
-        ? req.isViewMaximized
-        : isDraw
-          ? true
-          : undefined
+    if (
+      resolvedType === "markdown" &&
+      (req.resultHeight != null ||
+        req.editorVisible != null ||
+        (req.view != null && req.view !== "editor"))
+    ) {
+      throw new ApplyNotebookStateError(
+        `Cell at index ${index} is markdown; result_height must be null and view must be null or "editor". Use editor_height to size its rendered content.`,
+        "cells",
+      )
+    }
+    if (
+      typeof req.editorHeight === "number" &&
+      (!Number.isFinite(req.editorHeight) ||
+        req.editorHeight <
+          minTopHeightFor({
+            ...(existing ?? { id, position: index, value }),
+            ...(resolvedType === "markdown"
+              ? { type: "markdown" as const }
+              : {}),
+          }))
+    ) {
+      throw new ApplyNotebookStateError(
+        `Cell at index ${index} has an editor_height below its minimum.`,
+        "cells",
+      )
+    }
+    const dimensionCell: NotebookCell = {
+      ...(existing ?? { id, position: index, value }),
+      value,
+      ...(resolvedMode !== undefined ? { mode: resolvedMode } : {}),
+      ...(resolvedType === "markdown" ? { type: "markdown" } : {}),
+    }
+    if (
+      typeof req.resultHeight === "number" &&
+      (!Number.isFinite(req.resultHeight) ||
+        req.resultHeight < minBottomHeightFor(dimensionCell))
+    ) {
+      throw new ApplyNotebookStateError(
+        `Cell at index ${index} has result_height ${req.resultHeight}px; minimum is ${minBottomHeightFor(dimensionCell)}px.`,
+        "cells",
+      )
+    }
+    const dimensionsPatch = agentCellDimensionsPatch(dimensionCell, {
+      editorHeight: req.editorHeight,
+      resultHeight: req.resultHeight,
+      view: req.view,
+    })
+    if (
+      req.view == null &&
+      req.editorVisible == null &&
+      req.isViewMaximized == null &&
+      !existing &&
+      isDraw
+    ) {
+      dimensionsPatch.isViewMaximized = true
+      dimensionsPatch.wideView = "result"
+    } else if (req.view == null && req.editorVisible != null) {
+      dimensionsPatch.isViewMaximized = !req.editorVisible
+      dimensionsPatch.wideView = req.editorVisible ? "editor_result" : "result"
+    } else if (req.view == null && req.isViewMaximized != null) {
+      dimensionsPatch.isViewMaximized = req.isViewMaximized
+      dimensionsPatch.wideView = req.isViewMaximized
+        ? "result"
+        : "editor_result"
+    }
     const autoRefresh = req.autoRefresh != null ? req.autoRefresh : undefined
 
     if (existing) {
@@ -1199,8 +1281,7 @@ 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
+      Object.assign(next, dimensionsPatch)
       if (resolvedType === "markdown") {
         // Markdown cells carry none of the SQL/chart sub-state.
         next.type = "markdown"
@@ -1209,6 +1290,8 @@ export const buildAppliedCells = (
         delete next.chartConfig
         delete next.autoRefresh
         delete next.isViewMaximized
+        delete next.wideView
+        delete next.compactView
         delete next.bottomHeight
         delete next.lastRunStatus
         delete next.lastRunError
@@ -1238,19 +1321,20 @@ export const buildAppliedCells = (
     if (resolvedName !== undefined) created.name = resolvedName
     if (resolvedType === "markdown") {
       created.type = "markdown"
+      Object.assign(created, dimensionsPatch)
       return created
     }
     created.topHeight = topHeightForSql(value)
     if (resolvedMode !== undefined) created.mode = resolvedMode
     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 +1360,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:
@@ -1323,6 +1406,62 @@ export const MIN_MARKDOWN_HEIGHT_PX = 26
 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 = 240
+
+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
+  compact?: boolean
+  // Legacy cached-agent input. Current schemas expose `view`.
+  editorVisible?: boolean | null
+}
+
+// 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 (typeof dimensions.editorVisible === "boolean") {
+    patch.isViewMaximized = !dimensions.editorVisible
+    patch.wideView = dimensions.editorVisible ? "editor_result" : "result"
+  }
+  if (dimensions.view != null && cell.type !== "markdown") {
+    // Agent writes describe one width-independent preference. Compact cannot
+    // render a split, so editor_result projects to result there and restores
+    // exactly when the cell becomes wide again.
+    patch.wideView = dimensions.view
+    patch.isViewMaximized = dimensions.view === "result"
+    patch.compactView = dimensions.view === "editor" ? "editor" : "result"
+  }
+  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
@@ -1440,15 +1579,69 @@ export const defaultBottomHeightFor = (cell: NotebookCell): number =>
     ? DEFAULT_CHART_BOTTOM_HEIGHT
     : computeResultBottomHeight(cell.result)
 
-// 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 agentViewForPaneLayout = (
+  paneLayout: CellPaneLayout,
+): AgentCellView => (paneLayout === "split" ? "editor_result" : paneLayout)
+
+export const storedAgentCellView = (cell: NotebookCell): AgentCellView => {
+  if (cell.type === "markdown") return "editor"
+  if (cell.wideView !== undefined) return cell.wideView
+  if (cell.isViewMaximized === true) return "result"
+  if (cell.isViewMaximized === false) return "editor_result"
+  return isDoubleView(cell) ? "editor_result" : "editor"
+}
+
+export type AgentCellPresentation = {
+  preferred_view: AgentCellView
+  view?: AgentCellView
+  tier?: AgentCellTier
+}
+
+export const resolveAgentCellPresentation = (
+  cell: NotebookCell,
+  compact?: boolean,
+  expectingResult: boolean = false,
+): AgentCellPresentation => {
+  const preferredView = storedAgentCellView(cell)
+  if (compact === undefined) return { preferred_view: preferredView }
+  const paneLayout = resolveCellPaneLayout(cell, expectingResult, compact)
+  return {
+    preferred_view: preferredView,
+    view: agentViewForPaneLayout(paneLayout),
+    tier: compact ? "compact" : "wide",
+  }
+}
+
+// Resolve responsive presentation without mutating notebook state. Compact
+// cells can show only one pane; wider cells may split. Keeping this decision in
+// one helper prevents rendering and grid geometry from interpreting the two
+// internal responsive preferences differently.
+export const resolveCellPaneLayout = (
+  cell: NotebookCell,
+  expectingResult: boolean = false,
+  compact: boolean = false,
+): CellPaneLayout => {
+  const hasResult = isDoubleView(cell) || expectingResult
+  if (!hasResult) return "editor"
+  if (compact) {
+    return cell.compactView === "editor" ? "editor" : "result"
+  }
+  const wideView =
+    cell.wideView ??
+    (cell.isViewMaximized === true ? "result" : "editor_result")
+  if (wideView === "editor") return "editor"
+  return wideView === "result" ? "result" : "split"
+}
+
 // bottomHeight seeding when a cell flips between run and draw. A user-resized
 // bottom slot is never overridden.
 export const modeChangeBottomHeightPatch = (
@@ -1471,7 +1664,9 @@ export const cellModeChangePatch = (
   mode: CellMode,
 ): Partial<NotebookCell> => ({
   ...modeChangeBottomHeightPatch(cell, mode),
-  ...(mode === "draw" ? { isViewMaximized: false } : {}),
+  ...(mode === "draw"
+    ? { isViewMaximized: false, wideView: "editor_result" as const }
+    : {}),
 })
 
 export const mergeCellChartConfig = (
@@ -1501,17 +1696,17 @@ 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 =>
@@ -1520,6 +1715,39 @@ export const minTopHeightFor = (cell: NotebookCell): number =>
 const defaultTopHeightFor = (cell: NotebookCell): number =>
   cell.type === "markdown" ? MARKDOWN_DEFAULT_TOP_HEIGHT : DEFAULT_TOP_HEIGHT
 
+export const agentCellPaneDimensions = (
+  cell: NotebookCell,
+): {
+  editorHeight: number | "auto"
+  resultHeight?: number | "auto"
+} => {
+  const pinnedHeight = (
+    resized: boolean | undefined,
+    height: number | undefined,
+    minimum: number,
+  ): number | "auto" =>
+    resized && typeof height === "number" && Number.isFinite(height)
+      ? Math.max(minimum, height)
+      : "auto"
+
+  return {
+    editorHeight: pinnedHeight(
+      cell.topResized,
+      cell.topHeight,
+      minTopHeightFor(cell),
+    ),
+    ...(cell.type !== "markdown"
+      ? {
+          resultHeight: 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.
 export const computeCellHeights = (
@@ -1532,7 +1760,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))
@@ -1541,6 +1769,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 }
 }
 
@@ -1550,9 +1782,8 @@ 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.
+// 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`,
@@ -1567,14 +1798,44 @@ 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 === "split"
+        ? Math.max(minTopHeightFor(cell), topHeight)
+        : minTopHeightFor(cell)
+  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)))
+}
+
 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
@@ -1585,12 +1846,16 @@ export const snapMarkdownTopHeight = (px: number): number => {
 // 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,
+  paneLayout?: CellPaneLayout,
+): number =>
   computeCellGridH(
     cell,
     NOTEBOOK_GRID_ROW_HEIGHT,
     NOTEBOOK_GRID_MARGIN_Y,
     isExpectingResult(cell, "unrequested"),
+    paneLayout,
   )
 
 export const hasAgentVisibleCellHeightChanged = (
@@ -1616,29 +1881,6 @@ 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
@@ -1649,47 +1891,38 @@ export const cellHeightPatchForRows = (
   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),
       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: Math.max(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 = Math.max(
+    minBottomHeightFor(cell),
+    targetContentPx - topHeight,
   )
   return {
     bottomHeight: nextBottom,
     bottomResized: true,
-    ...(nextTop !== top ? { topHeight: nextTop, topResized: true } : {}),
   }
 }
 
@@ -1704,14 +1937,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,
@@ -1750,8 +2001,8 @@ 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).
+  // Cached clients may still send grid.h. New clients size semantic panes and
+  // grid h is derived, but keep the legacy back-solve during the transition.
   //
   // 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
@@ -1763,7 +2014,7 @@ export const buildAppliedNotebookState = (
     targetLayoutMode === "grid"
       ? nextCells.map((cell, i) => {
           const g = request.cells[i]?.grid
-          if (!g) return cell
+          if (!g || g.h === undefined) return cell
           const prior = prevById.get(cell.id) ?? cell
           const patch = cellHeightPatchForRows(
             prior,
diff --git a/src/store/notebook.ts b/src/store/notebook.ts
index ab7addcc9..fa4aff4bf 100644
--- a/src/store/notebook.ts
+++ b/src/store/notebook.ts
@@ -37,6 +37,10 @@ export type AutoRefresh = boolean | AutoRefreshInterval
 // migration. Markdown cells hold their source in `value` and are never executed.
 export type CellType = "sql" | "markdown"
 
+export type CellCompactView = "editor" | "result"
+export type AgentCellView = "editor" | "result" | "editor_result"
+export type AgentCellTier = "compact" | "wide"
+
 export type NotebookCell = {
   id: string
   position: number
@@ -53,7 +57,12 @@ export type NotebookCell = {
   mode?: CellMode
   chartConfig?: ChartConfig
   autoRefresh?: AutoRefresh
+  // Wide and compact layouts keep internal presentation preferences. The
+  // agent sets one `view` preference and reads the currently resolved view;
+  // these storage fields are never exposed directly.
   isViewMaximized?: boolean
+  wideView?: AgentCellView
+  compactView?: CellCompactView
   lastRunStatus?: RunStatus
   lastRunError?: string
 }
diff --git a/src/utils/ai/notebookSnapshot.test.ts b/src/utils/ai/notebookSnapshot.test.ts
index c269d3684..b6632ec06 100644
--- a/src/utils/ai/notebookSnapshot.test.ts
+++ b/src/utils/ai/notebookSnapshot.test.ts
@@ -24,6 +24,10 @@ import type {
   NotebookViewState,
 } from "../../store/notebook"
 import { createEmptyDigest } from "../../providers/AIConversationProvider/userActionDigest"
+import {
+  __resetNotebookPresentationStoreForTests,
+  publishLiveCellPresentation,
+} from "../../scenes/Editor/Notebook/notebookPresentationStore"
 
 const sql = (
   id: string,
@@ -77,6 +81,7 @@ beforeEach(async () => {
   __resetNotebookControllerForTests()
   __resetNotebookAIBridgeForTests()
   __resetNotebookBufferQueuesForTests()
+  __resetNotebookPresentationStoreForTests()
   await db.buffers.clear()
 })
 
@@ -154,6 +159,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 +219,82 @@ 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",
+        preferred_view: "editor",
+      })
     } else {
       throw new Error("expected ok snapshots")
     }
   })
 
+  it("reports the effective view and tier of a live responsive cell", async () => {
+    const chart = sql("a", "SELECT 1", {
+      mode: "draw",
+      isViewMaximized: false,
+      wideView: "editor_result",
+      compactView: "editor",
+    })
+    const id = await seedNotebook({ cells: [chart] })
+    registerController(makeController(id, [chart], {}))
+    const unpublish = publishLiveCellPresentation(id, "a", {
+      compact: true,
+      paneLayout: "editor",
+    })
+
+    const snap = await buildSnapshot(id)
+    expect(snap?.status === "ok" ? snap.cells[0] : undefined).toMatchObject({
+      preferred_view: "editor_result",
+      view: "editor",
+      tier: "compact",
+    })
+    unpublish()
+  })
+
+  it("omits tier and reports the stored preference for an inactive notebook", async () => {
+    const id = await seedNotebook({
+      cells: [
+        sql("a", "SELECT 1", {
+          mode: "draw",
+          wideView: "editor_result",
+          compactView: "result",
+        }),
+      ],
+    })
+
+    const snap = await buildSnapshot(id)
+    expect(snap?.status === "ok" ? snap.cells[0] : undefined).toMatchObject({
+      preferred_view: "editor_result",
+    })
+    expect(
+      snap?.status === "ok" ? snap.cells[0].view : "unexpected",
+    ).toBeUndefined()
+    expect(
+      snap?.status === "ok" ? snap.cells[0].tier : "unexpected",
+    ).toBeUndefined()
+  })
+
+  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({
@@ -317,6 +401,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 +444,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..58db65ec2 100644
--- a/src/utils/ai/notebookSnapshot.ts
+++ b/src/utils/ai/notebookSnapshot.ts
@@ -7,6 +7,8 @@ import { readNotebookBufferMeta } from "../notebooks/notebookDexieView"
 import { NotebookToolError } from "../notebooks/notebookToolError"
 import { sanitizeForPromptContext } from "./sanitizeForPromptContext"
 import type {
+  AgentCellView,
+  AgentCellTier,
   AutoRefresh,
   CellLayoutItem,
   NotebookCell,
@@ -15,7 +17,11 @@ 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,
+  resolveAgentCellPresentation,
+} from "../../scenes/Editor/Notebook/notebookUtils"
+import { readLiveCellPresentation } from "../../scenes/Editor/Notebook/notebookPresentationStore"
 import { getCellRunStatus, type RunStatus } from "./runStatus"
 import type { ChartConfig } from "../../scenes/Editor/Notebook/CellChart/chartTypes"
 
@@ -49,7 +55,11 @@ export type NotebookContextCell = {
   type?: "sql" | "markdown"
   mode?: "run" | "draw"
   auto_refresh?: AutoRefresh
-  is_view_maximized?: boolean
+  editor_height?: number | "auto"
+  result_height?: number | "auto"
+  preferred_view: AgentCellView
+  view?: AgentCellView
+  tier?: AgentCellTier
   chart_config?: ChartConfigWire
   last_run_status?: RunStatus
   last_run_error_summary?: string
@@ -58,7 +68,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 +97,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 +165,19 @@ const refreshFields = (
 
 const buildCell = (
   cell: NotebookCell,
+  bufferId: number,
   gridByCellId: Map<string, CellLayoutItem>,
   layoutMode: "list" | "grid",
   refreshState: ReadonlyMap<string, CellRefreshView> | undefined,
 ): NotebookContextCell => {
+  const presentation = resolveAgentCellPresentation(
+    cell,
+    readLiveCellPresentation(bufferId, cell.id)?.compact,
+  )
   const out: NotebookContextCell = {
     id: cell.id,
     preview: preview(cell.value),
+    preferred_view: presentation.preferred_view,
     ...lastRunSummary(cell),
     ...refreshFields(refreshState?.get(cell.id)),
   }
@@ -171,9 +189,12 @@ 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 dimensions = agentCellPaneDimensions(cell)
+  out.editor_height = dimensions.editorHeight
+  if (dimensions.resultHeight !== undefined)
+    out.result_height = dimensions.resultHeight
+  if (presentation.view !== undefined) out.view = presentation.view
+  if (presentation.tier !== undefined) out.tier = presentation.tier
   const chartConfig = cell.chartConfig
   if (chartConfig && Array.isArray(chartConfig.queries)) {
     out.chart_config = toChartConfigWire(chartConfig)
@@ -185,7 +206,6 @@ const buildCell = (
         x: g.x,
         y: g.y,
         w: g.w,
-        h: computeAgentCellGridH(cell),
       }
     }
   }
@@ -224,7 +244,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 +300,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 +315,13 @@ 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}`)
+    if (c.editor_height !== undefined)
+      lines.push(`      editor_height: ${c.editor_height}`)
+    if (c.result_height !== undefined)
+      lines.push(`      result_height: ${c.result_height}`)
+    lines.push(`      preferred_view: ${c.preferred_view}`)
+    if (c.view !== undefined) lines.push(`      view: ${c.view}`)
+    if (c.tier !== undefined) lines.push(`      tier: ${c.tier}`)
     if (c.chart_config) {
       lines.push(
         `      chart_config: ${sanitizeForPromptContext(
@@ -319,7 +346,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 +461,11 @@ export type NotebookCellDetails = {
   type?: "sql" | "markdown"
   mode?: "run" | "draw"
   auto_refresh?: AutoRefresh
-  is_view_maximized?: boolean
+  editor_height: number | "auto"
+  result_height?: number | "auto"
+  preferred_view: AgentCellView
+  view?: AgentCellView
+  tier?: AgentCellTier
   chart_config?: ChartConfigWire
   last_run_status?: RunStatus
   last_run_error?: string
@@ -488,14 +519,23 @@ export const serializeCell = (
   const truncated = !getFullContent && cell.value.length > CELL_VALUE_MAX
   const value = truncated ? cell.value.slice(0, CELL_VALUE_MAX) : cell.value
   const run = runStatusOf(cell)
+  const dimensions = agentCellPaneDimensions(cell)
+  const presentation = resolveAgentCellPresentation(
+    cell,
+    readLiveCellPresentation(bufferId, cell.id)?.compact,
+  )
   const out: NotebookCellDetails = {
     id: cell.id,
     value,
     position: cell.position,
     last_run_status: run.status,
     last_run_error: run.error,
+    editor_height: dimensions.editorHeight,
+    preferred_view: presentation.preferred_view,
     ...refreshFields(refreshState?.get(cell.id)),
   }
+  if (presentation.view !== undefined) out.view = presentation.view
+  if (presentation.tier !== undefined) out.tier = presentation.tier
   if (truncated) {
     out.truncated = true
     out.full_length = cell.value.length
@@ -504,8 +544,8 @@ 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 (dimensions.resultHeight !== undefined)
+    out.result_height = dimensions.resultHeight
   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..94dcc8dcc 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.
@@ -115,9 +115,10 @@ 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).
+- 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. view is editor, result, or editor_result. Wide cells support all three; compact cells support editor/result and project editor_result to result, restoring editor_result if they become wide again. preferred_view is always the stored intent. Mounted cells additionally report effective view and tier (wide/compact) as a pair; both are omitted when the cell is not rendered. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. Keep charts at result_height >= 240; use editor_height 86 for a polished markdown title (never use the 26px structural minimum for non-empty prose).
 - 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 dimension fields are the documented 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..4e8338779 100644
--- a/src/utils/ai/shared.notebookTools.test.ts
+++ b/src/utils/ai/shared.notebookTools.test.ts
@@ -40,6 +40,10 @@ import { dispatchMCPTool } from "../mcp/dispatchMCPTool"
 import { EXPECTED_MCP_VERSION } from "../mcp/protocolVersion"
 import type { ToolExecutionContext } from "./shared"
 import { createNotebookFreshness } from "../notebooks/notebookFreshness"
+import {
+  __resetNotebookPresentationStoreForTests,
+  publishLiveCellPresentation,
+} from "../../scenes/Editor/Notebook/notebookPresentationStore"
 
 const cell = (
   id: string,
@@ -190,6 +194,7 @@ beforeEach(async () => {
   __resetNotebookControllerForTests()
   __resetNotebookAIBridgeForTests()
   __resetNotebookBufferQueuesForTests()
+  __resetNotebookPresentationStoreForTests()
   clearStatementClassCache()
   await db.buffers.clear()
   await db.notebook_results.clear()
@@ -205,6 +210,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 +686,111 @@ 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,
+        isViewMaximized: true,
+      }),
+    ])
+
+    const res = await dispatchTool(
+      "set_cell_dimensions",
+      {
+        buffer_id: 1,
+        cell_id: "c",
+        editor_height: "auto",
+        result_height: 280,
+        view: null,
+      },
+      makeClient(),
+      noopStatus,
+    )
+
+    expect(res.is_error).toBeUndefined()
+    expect(JSON.parse(res.content)).toEqual({ preferred_view: "result" })
+    expect(cellById(state, "c")).toMatchObject({
+      topHeight: 72,
+      topResized: false,
+      bottomHeight: 280,
+      bottomResized: true,
+      isViewMaximized: true,
+    })
+  })
+
+  it("set_cell_dimensions returns the effective compact fallback and tier", async () => {
+    const { state } = mountLive(1, [cell("c", "SELECT 1", { mode: "draw" })])
+    const unpublish = publishLiveCellPresentation(1, "c", {
+      compact: true,
+      paneLayout: "result",
+    })
+
+    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({
+      preferred_view: "editor_result",
+      view: "result",
+      tier: "compact",
+      fallback: "editor_result_unavailable_in_compact",
+    })
+    expect(cellById(state, "c")?.wideView).toBe("editor_result")
+    unpublish()
+  })
+
+  it("set_cell_layout returns the presentation produced by the new width", async () => {
+    const { state } = mountLive(
+      1,
+      [
+        cell("c", "SELECT 1", {
+          mode: "draw",
+          wideView: "editor_result",
+          compactView: "result",
+        }),
+      ],
+      {
+        settings: {
+          layoutMode: "grid",
+          layout: [{ i: "c", x: 0, y: 0, w: 6, h: 10 }],
+        },
+      },
+    )
+    const unpublish = publishLiveCellPresentation(1, "c", {
+      compact: false,
+      paneLayout: "split",
+      gridContainerWidth: 1200,
+    })
+
+    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 },
+      preferred_view: "editor_result",
+      view: "result",
+      tier: "compact",
+    })
+    expect(state.parts.settings.layout?.[0].w).toBe(4)
+    unpublish()
+  })
+
   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 +1173,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,
@@ -1072,6 +1201,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       mode: "draw",
       autoRefresh: "5s",
       isViewMaximized: true,
+      compactView: "result",
       chartConfig: {
         xColumn: "ts",
         queries: [
@@ -1730,7 +1860,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 +1898,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 +2016,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/notebookController/index.ts b/src/utils/notebooks/notebookController/index.ts
index c902fa433..694092537 100644
--- a/src/utils/notebooks/notebookController/index.ts
+++ b/src/utils/notebooks/notebookController/index.ts
@@ -122,6 +122,7 @@ export {
   moveCellDownTransition,
   moveCellUpTransition,
   setCellChartConfigTransition,
+  setCellDimensionsTransition,
   setCellLayoutTransition,
   setCellMaximizedTransition,
   setCellModeTransition,
diff --git a/src/utils/notebooks/notebookController/notebookController.ts b/src/utils/notebooks/notebookController/notebookController.ts
index 8bcae8f1a..0a28cd194 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,14 @@ export type ApplyNotebookStateCellRequest = {
   type?: CellType | null
   mode?: "run" | "draw" | null
   autoRefresh?: AutoRefresh | null
+  editorHeight?: AgentHeightValue
+  resultHeight?: AgentHeightValue
+  view?: AgentCellView | null
+  // Legacy cached-agent inputs. Not advertised by the current schema.
+  editorVisible?: boolean | null
   isViewMaximized?: boolean | null
   chartConfig?: ChartConfig | null
-  grid?: { x: number; y: number; w: number; h: number } | null
+  grid?: { x: number; y: number; w: number; h?: 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..39d5ae0f7 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,181 @@ 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,
+      isViewMaximized: true,
+    })
+    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",
+      compact: false,
+    })
+
+    expect(out.parts.cells[0]).toMatchObject({
+      topHeight: 72,
+      bottomHeight: 350,
+      isViewMaximized: false,
+      wideView: "editor_result",
+      compactView: "result",
+    })
+    expect(out.parts.settings.layout?.[0].h).toBe(17)
+    expect(out.result).toEqual({
+      preferred_view: "editor_result",
+      view: "editor_result",
+      tier: "wide",
+    })
+  })
+
+  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,
+      isViewMaximized: true,
+    })
+
+    const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
+      editorHeight: "auto",
+      resultHeight: 280,
+      view: null,
+    })
+
+    expect(out.parts.cells[0]).toMatchObject({
+      topHeight: 72,
+      topResized: false,
+      bottomHeight: 280,
+      bottomResized: true,
+      isViewMaximized: true,
+    })
+    expect(out.result).toEqual({ preferred_view: "result" })
+  })
+
+  it("stores one editor preference and reports its compact projection", () => {
+    const chart = cell("a", "SELECT 1", {
+      mode: "draw",
+      isViewMaximized: true,
+      compactView: "result",
+    })
+
+    const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
+      view: "editor",
+      compact: true,
+    })
+
+    expect(out.parts.cells[0]).toMatchObject({
+      isViewMaximized: false,
+      wideView: "editor",
+      compactView: "editor",
+    })
+    expect(out.result).toEqual({
+      preferred_view: "editor",
+      view: "editor",
+      tier: "compact",
+    })
+  })
+
+  it("reports the deterministic compact fallback without losing the wide preference", () => {
+    const chart = cell("a", "SELECT 1", { mode: "draw" })
+    const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
+      view: "editor_result",
+      compact: true,
+    })
+
+    expect(out.parts.cells[0]).toMatchObject({
+      wideView: "editor_result",
+      compactView: "result",
+    })
+    expect(out.result).toEqual({
+      preferred_view: "editor_result",
+      view: "result",
+      tier: "compact",
+      fallback: "editor_result_unavailable_in_compact",
+    })
+  })
+
+  it("supports a genuine editor-only view in the wide tier", () => {
+    const chart = cell("a", "SELECT 1", { mode: "draw" })
+    const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
+      view: "editor",
+      compact: false,
+    })
+
+    expect(out.parts.cells[0]).toMatchObject({
+      wideView: "editor",
+      compactView: "editor",
+    })
+    expect(out.result).toEqual({
+      preferred_view: "editor",
+      view: "editor",
+      tier: "wide",
+    })
+  })
+
+  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 240px/)
+  })
+})
+
+describe("setCellLayoutTransition", () => {
+  const chart = cell("a", "SELECT 1", {
+    mode: "draw",
+    wideView: "editor_result",
+    compactView: "result",
+  })
+
+  it("returns the projected live presentation after a width 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, liveCompact: false, gridContainerWidth: 1200 },
+    )
+
+    expect(out.result).toEqual({
+      grid: { x: 0, y: 0, w: 4 },
+      preferred_view: "editor_result",
+      view: "result",
+      tier: "compact",
+    })
+  })
+
+  it("omits effective presentation when no rendered geometry is available", () => {
+    const out = setCellLayoutTransition(
+      partsOf([chart], { settings: { layoutMode: "grid" } }),
+      BUFFER_ID,
+      "a",
+      { x: 0, y: 0, w: 4 },
+    )
+
+    expect(out.result).toEqual({
+      grid: { x: 0, y: 0, w: 4 },
+      preferred_view: "editor_result",
+    })
+  })
+})
+
 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..508e22f27 100644
--- a/src/utils/notebooks/notebookController/notebookTransitions.ts
+++ b/src/utils/notebooks/notebookController/notebookTransitions.ts
@@ -11,18 +11,24 @@ import { requireCellIn, requireCellWithinLineLimit } from "../notebookDexieView"
 import type { ApplyNotebookStateRequest } from "./notebookController"
 import type { ChartConfig } from "../../../scenes/Editor/Notebook/CellChart/chartTypes"
 import {
+  agentCellDimensionsPatch,
   buildAppliedNotebookState,
   carriedRunError,
   carriedRunStatus,
   cellHeightPatchForRows,
   cellModeChangePatch,
   clearCellAutoRefresh,
+  computeAgentCellGridH,
   duplicateCellAt,
+  gridCellToolbarTier,
   insertCell,
   isExpectingResult,
   mergeCellChartConfig,
+  minBottomHeightFor,
+  minTopHeightFor,
   nextGridSeedPosition,
   reconcileCellResultForValue,
+  resolveAgentCellPresentation,
   NOTEBOOK_GRID_MARGIN_Y,
   NOTEBOOK_GRID_ROW_HEIGHT,
   removeCell,
@@ -30,7 +36,9 @@ import {
   swapCellUp,
   topHeightForSql,
   upsertCellLayout,
+  resolveCellPaneLayout,
   type CellGridPosition,
+  type AgentCellDimensions,
 } from "../../../scenes/Editor/Notebook/notebookUtils"
 
 // The single home for every notebook mutation's behavior. Each transition is a
@@ -279,17 +287,48 @@ export const setCellLayoutTransition = (
   parts: ViewParts,
   bufferId: number,
   cellId: string,
-  pos: CellGridPosition,
-): NotebookTransitionResult => {
+  pos: Omit<CellGridPosition, "h"> & {
+    h?: number
+    liveCompact?: boolean
+    gridContainerWidth?: number
+  },
+): NotebookTransitionResult<
+  ReturnType<typeof resolveAgentCellPresentation> & {
+    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"),
+  // Cached clients may still send h. Current clients control pane dimensions
+  // semantically and h is derived from them.
+  const heightPatch =
+    pos.h === undefined
+      ? {}
+      : cellHeightPatchForRows(
+          cell,
+          pos.h,
+          NOTEBOOK_GRID_ROW_HEIGHT,
+          NOTEBOOK_GRID_MARGIN_Y,
+          isExpectingResult(cell, "unrequested"),
+        )
+  const nextCell = { ...cell, ...heightPatch }
+  const compact =
+    parts.settings.layoutMode === "grid"
+      ? pos.gridContainerWidth !== undefined
+        ? gridCellToolbarTier(pos.gridContainerWidth, pos.w) === "compact"
+        : undefined
+      : pos.liveCompact
+  const expectingResult = isExpectingResult(nextCell, "unrequested")
+  const paneLayout = resolveCellPaneLayout(
+    nextCell,
+    expectingResult,
+    compact === true,
   )
+  const layoutPos: CellGridPosition = {
+    x: pos.x,
+    y: pos.y,
+    w: pos.w,
+    h: computeAgentCellGridH(nextCell, paneLayout),
+  }
   return {
     parts: {
       ...parts,
@@ -299,10 +338,105 @@ export const setCellLayoutTransition = (
           : 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 },
+      ...resolveAgentCellPresentation(nextCell, compact, expectingResult),
+    },
+    touchedCellId: cellId,
+  }
+}
+
+export const setCellDimensionsTransition = (
+  parts: ViewParts,
+  bufferId: number,
+  cellId: string,
+  dimensions: AgentCellDimensions,
+): NotebookTransitionResult<
+  ReturnType<typeof resolveAgentCellPresentation> & {
+    fallback?:
+      | "editor_result_unavailable_in_compact"
+      | "requested_view_unavailable"
+  }
+> => {
+  const cell = requireCellIn(parts.cells, cellId, bufferId)
+  if (
+    cell.type === "markdown" &&
+    (dimensions.resultHeight != null ||
+      dimensions.editorVisible != null ||
+      (dimensions.view != null && dimensions.view !== "editor"))
+  ) {
+    throw new NotebookToolError(
+      "validation",
+      'Markdown cells have no result pane; pass null for result_height and null or "editor" for view.',
+    )
+  }
+  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.`,
+    )
+  }
+
+  const patch = agentCellDimensionsPatch(cell, dimensions)
+  const nextCell = { ...cell, ...patch }
+  const paneLayout = resolveCellPaneLayout(
+    nextCell,
+    isExpectingResult(nextCell, "unrequested"),
+    dimensions.compact === true,
+  )
+  const layout = parts.settings.layout?.map((item) =>
+    item.i === cellId
+      ? { ...item, h: computeAgentCellGridH(nextCell, paneLayout) }
+      : item,
+  )
+  const presentation = resolveAgentCellPresentation(
+    nextCell,
+    dimensions.compact,
+    isExpectingResult(nextCell, "unrequested"),
+  )
+  const fallback =
+    presentation.view !== undefined &&
+    dimensions.view === "editor_result" &&
+    presentation.view === "result"
+      ? "editor_result_unavailable_in_compact"
+      : presentation.view !== undefined &&
+          dimensions.view != null &&
+          dimensions.view !== presentation.view
+        ? "requested_view_unavailable"
+        : undefined
+  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: {
+      ...presentation,
+      ...(fallback !== undefined ? { fallback } : {}),
+    },
     touchedCellId: cellId,
   }
 }
@@ -358,7 +492,10 @@ export const setCellViewMaximizedTransition = (
   return {
     parts: {
       ...parts,
-      cells: patchCellIn(parts.cells, cellId, { isViewMaximized: value }),
+      cells: patchCellIn(parts.cells, cellId, {
+        isViewMaximized: value,
+        wideView: value ? "result" : "editor_result",
+      }),
     },
     result: undefined,
     touchedCellId: cellId,
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..da42f39d3 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,18 @@ export const dispatchApplyNotebookState = async (
         type?: "sql" | "markdown" | null
         mode?: CellMode | null
         auto_refresh?: boolean | string | null
+        editor_height?: number | "auto" | null
+        result_height?: number | "auto" | null
+        view?: AgentCellView | null
+        // Legacy cached-agent inputs.
+        editor_visible?: boolean | null
         is_view_maximized?: boolean | 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; h?: number } | null
       }>
     }) || {}
   setStatus(AIOperationStatus.BuildingNotebook)
@@ -389,7 +399,15 @@ 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)
+      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.editor_visible !== undefined) cell.editorVisible = c.editor_visible
+      if (
+        c.editor_visible == null &&
+        c.is_view_maximized !== undefined &&
+        c.is_view_maximized !== null
+      )
         cell.isViewMaximized = c.is_view_maximized
       if (c.chart_config) {
         const cfg = c.chart_config
diff --git a/src/utils/tools/dispatch.ts b/src/utils/tools/dispatch.ts
index d6be52076..5e5ba014d 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,6 +72,7 @@ import {
   moveCellDownTransition,
   moveCellUpTransition,
   setCellChartConfigTransition,
+  setCellDimensionsTransition,
   setCellLayoutTransition,
   setCellMaximizedTransition,
   setCellModeTransition,
@@ -83,6 +88,7 @@ import {
   serializeCell,
   summarizeCells,
 } from "../ai/notebookSnapshot"
+import { readLiveCellPresentation } from "../../scenes/Editor/Notebook/notebookPresentationStore"
 import { generateId } from "../../scenes/Editor/Notebook/notebookUtils"
 import {
   copyNotebookSnapshots,
@@ -498,7 +504,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.",
           }
         })
       }
@@ -820,9 +826,10 @@ export const dispatchTool = async (
             x: number
             y: number
             w: number
-            h: number
+            h?: number
           }) || {}
         setStatus(AIOperationStatus.ConfiguringLayout, { cellId: cell_id })
+        const livePresentation = readLiveCellPresentation(buffer_id, cell_id)
         return routeNotebookTool(() =>
           runTransition(
             buffer_id,
@@ -832,6 +839,32 @@ export const dispatchTool = async (
                 y,
                 w,
                 h,
+                liveCompact: livePresentation?.compact,
+                gridContainerWidth: livePresentation?.gridContainerWidth,
+              }),
+            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) =>
+              setCellDimensionsTransition(parts, buffer_id, cell_id, {
+                editorHeight: editor_height,
+                resultHeight: result_height,
+                view,
+                compact: readLiveCellPresentation(buffer_id, cell_id)?.compact,
               }),
             signal,
           ),

From 832283bcd4f5e6c019be1bad77a30321faa01f39 Mon Sep 17 00:00:00 2001
From: emrberk <emreberk5699@gmail.com>
Date: Wed, 2 Sep 2026 18:36:05 +0300
Subject: [PATCH 2/4] refactor: single viewport-independent notebook cell pane
 preference

Replace isViewMaximized/wideView/compactView with one stored
preferredView. The rendered pane layout derives from that preference,
result availability, and the responsive tier; resizing never rewrites it.

- Persisted isViewMaximized migrates to preferredView on read and import.
- Agent reads report preferred_view plus live view/tier from the
  renderer's hydration-aware pane state.
- Drop legacy tool inputs: editor_visible, is_view_maximized, grid h
  back-solve, and the set_cell_view_maximized tool.
- Reveal a result hidden by an editor preference when the user runs,
  or switches to Table/Chart, in any tier.
- Reserve grid rows for a multi-statement result when any statement
  renders a grid, not only the first.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013ceLPBG4yUmAWH1zqYD9w8
---
 src/consts/shared-definitions.json            |  14 +-
 src/modules/ConsoleEventTracker/events.ts     |   1 -
 src/scenes/Editor/Monaco/importTabs.test.ts   |  30 ++
 src/scenes/Editor/Monaco/importTabs.ts        |  23 +-
 .../Editor/Notebook/NotebookProvider.tsx      |  15 +-
 src/scenes/Editor/Notebook/cells/Cell.tsx     |  32 +-
 .../Editor/Notebook/cells/CellToolbar.tsx     |  25 +-
 .../Editor/Notebook/cells/CellViewToggle.tsx  |  21 +-
 .../Editor/Notebook/cells/CellWideActions.tsx |   7 +-
 .../Notebook/cells/useCellRunActions.ts       |  29 +-
 .../Notebook/notebookPresentationStore.ts     |   4 +
 .../Editor/Notebook/notebookUtils.test.ts     | 277 +++++++++++-------
 src/scenes/Editor/Notebook/notebookUtils.ts   | 198 +++++--------
 src/store/notebook.ts                         |  11 +-
 src/utils/ai/notebookSnapshot.test.ts         |  38 ++-
 src/utils/ai/notebookSnapshot.ts              |  22 +-
 src/utils/ai/prompts.ts                       |   2 +-
 src/utils/ai/shared.notebookTools.test.ts     |  16 +-
 src/utils/notebooks/notebookAIBridge.test.ts  |   2 +-
 .../notebooks/notebookController/index.ts     |   2 +-
 .../notebookController/notebookController.ts  |   5 +-
 .../notebookTransitions.test.ts               |  83 ++++--
 .../notebookController/notebookTransitions.ts |  57 ++--
 .../notebooks/notebookDexieController.test.ts |  15 +-
 src/utils/notebooks/notebookDexieView.test.ts |  48 +++
 src/utils/notebooks/notebookDexieView.ts      |  37 ++-
 src/utils/tools/applyNotebookState.ts         |  12 +-
 src/utils/tools/dispatch.ts                   |  49 ++--
 28 files changed, 626 insertions(+), 449 deletions(-)
 create mode 100644 src/utils/notebooks/notebookDexieView.test.ts

diff --git a/src/consts/shared-definitions.json b/src/consts/shared-definitions.json
index e5dafbe54..d48a67645 100644
--- a/src/consts/shared-definitions.json
+++ b/src/consts/shared-definitions.json
@@ -241,7 +241,7 @@
     "surfaces": ["ai", "mcp"],
     "mutatesNotebook": false,
     "createsNotebook": false,
-    "description": "Get full details of a cell (value, kind via `type`, editor_height/result_height, preferred/effective view, chart config, last-run status + trimmed error). Height values are fixed CSS pixels or \"auto\". `preferred_view` is always the stored intent. A rendered cell additionally returns effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted when the cell is not rendered. Compact cannot display editor_result, so it may report `preferred_view: editor_result` with `view: result`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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.",
+    "description": "Get full details of a cell (value, kind via `type`, editor_height/result_height, preferred/effective view, chart config, last-run status + trimmed error). Height values are fixed CSS pixels or \"auto\". `preferred_view` is the single stored, viewport-independent intent for SQL/draw cells; resizing or result hydration never rewrites it. Markdown reports the fixed value `editor` and has no mutable pane-view state. A rendered SQL/draw cell additionally returns effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted when that cell is not rendered. `view` is derived from `preferred_view`, current result availability, and tier. Markdown cells do not expose effective `view` or `tier`. Compact cannot display editor_result, so it may report `preferred_view: editor_result` with `view: result`. A cell whose result is unavailable temporarily reports `view: editor` without changing `preferred_view`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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, semantic pane dimensions, kind via `type`, last-run statuses). Cell `grid` contains x/y/w only; height is represented by editor_height/result_height. `preferred_view` is always the stored intent. A rendered cell additionally returns effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted when the cell is not rendered. Compact cannot display editor_result, so it may report `preferred_view: editor_result` with `view: result`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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.",
+    "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 represented by editor_height/result_height. `preferred_view` is the single stored, viewport-independent intent for SQL/draw cells; resizing or result hydration never rewrites it. Markdown reports the fixed value `editor` and has no mutable pane-view state. A rendered SQL/draw cell additionally returns effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted when that cell is not rendered. `view` is derived from `preferred_view`, current result availability, and tier. Markdown cells do not expose effective `view` or `tier`. Compact cannot display editor_result, so it may report `preferred_view: editor_result` with `view: result`. An unavailable result temporarily produces `view: editor` without changing `preferred_view`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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 are integers in the react-grid-layout grid; width is limited to 12 columns. Cell height is derived from its semantic pane dimensions. Changing w may change the responsive tier and effective view. The response includes the applied grid position and `preferred_view`; when the cell is rendered it also includes the resulting effective `view` and `tier`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing can later change tier even if grid.w stays fixed. Use set_cell_dimensions to resize a cell or change its preferred view.",
+    "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. Changing w may change the responsive tier and effective view of a SQL/draw cell. The response includes the applied grid position and `preferred_view`; when a SQL/draw cell is rendered it also includes the resulting effective `view` and `tier`. Markdown reports the fixed `preferred_view: editor` and does not expose effective `view` or `tier`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing can later change tier even if grid.w stays fixed. Use set_cell_dimensions to resize a cell or change its preferred view.",
     "inputSchema": {
       "type": "object",
       "additionalProperties": false,
@@ -505,7 +505,7 @@
     "surfaces": ["ai", "mcp"],
     "mutatesNotebook": true,
     "createsNotebook": false,
-    "description": "Resize a cell using semantic pane dimensions in CSS pixels and choose its preferred 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. view accepts editor, result, or editor_result. Wide cells support all three. Compact cells support editor/result; editor_result deterministically displays as result and is restored if the cell becomes wide. Cells without a result display editor. The response always reports `preferred_view`; when the cell is rendered it also reports effective `view` and live-only `tier` (`wide` or `compact`) as a pair, and may report a `fallback`. For markdown, editor_height sizes the rendered content, result_height must be null, and view must be null or editor; never use the structural 26px minimum for non-empty prose—use at least 56px, or 86px for a polished title. Chart result_height must be at least 240px; table results at least 100px.",
+    "description": "Resize a cell using semantic pane dimensions in CSS pixels and choose its single viewport-independent preferred 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. Wide cells display the preference directly. Compact cells project editor_result to result without rewriting it. Cells without an available result temporarily display editor without rewriting the preference. The response always reports `preferred_view`; when a SQL/draw cell is rendered it also reports effective `view` and live-only `tier` (`wide` or `compact`) as a pair, and may report a `fallback`. Markdown has no mutable pane-view state: it reports the fixed `preferred_view: editor` and does not expose effective `view` or `tier`; editor_height sizes its rendered content, result_height must be null, and view must be null or editor. Never use the structural 26px minimum for non-empty prose—use at least 56px, or 86px for a polished title. Chart result_height must be at least 240px; table results at least 100px.",
     "inputSchema": {
       "type": "object",
       "additionalProperties": false,
@@ -537,7 +537,7 @@
             { "type": "string", "enum": ["editor", "result", "editor_result"] },
             { "type": "null" }
           ],
-          "description": "Stored pane preference. Null preserves. Wide supports editor, result, and editor_result. Compact supports editor/result and displays editor_result as result; the preference is restored when wide. A cell without a result displays editor."
+          "description": "Single stored, viewport-independent pane preference. Null preserves. Wide displays editor, result, or editor_result directly. Compact projects editor_result to result without rewriting the preference. A cell without an available result temporarily displays editor without rewriting the preference."
         }
       },
       "required": [
@@ -907,7 +907,7 @@
                   },
                   { "type": "null" }
                 ],
-                "description": "Stored pane preference. Null preserves an existing setting. New draw cells default to result; other new SQL cells show editor until a result exists. Wide supports editor, result, and editor_result. Compact supports editor/result and displays editor_result as result, restoring the preference when wide. A cell without a result displays editor. Markdown requires null or editor."
+                "description": "Single stored, viewport-independent pane preference. 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. Wide displays the preference directly. Compact projects editor_result to result without rewriting it. An unavailable result temporarily displays editor without rewriting the preference. Markdown requires null or editor."
               },
               "chart_config": {
                 "type": ["object", "null"],
@@ -1110,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. Each cell always reports stored `preferred_view`. Rendered cells additionally report effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted for inactive or unmounted cells. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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 the single stored, viewport-independent `preferred_view`; resizing and result hydration never rewrite it. Markdown reports the fixed value `editor` and has no mutable pane-view state. Rendered SQL/draw cells additionally report effective `view` and live-only `tier` (`wide` or `compact`) as a pair; `view` is derived from preference, result availability, and tier. Both are omitted for inactive or unmounted cells. Markdown cells do not expose effective `view` or `tier`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. Pass include_user_events=true to also receive the digest of edits the user made since your last fetch.",
     "inputSchema": {
       "type": "object",
       "properties": {
diff --git a/src/modules/ConsoleEventTracker/events.ts b/src/modules/ConsoleEventTracker/events.ts
index c58ea67fc..13eed171f 100644
--- a/src/modules/ConsoleEventTracker/events.ts
+++ b/src/modules/ConsoleEventTracker/events.ts
@@ -169,7 +169,6 @@ export enum ConsoleEvent {
   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..3e019deb1 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", preferredView: "editor" },
+            { id: "legacy-on", value: "SELECT 2", isViewMaximized: true },
+            { id: "legacy-off", value: "SELECT 3", isViewMaximized: false },
+            {
+              id: "markdown",
+              value: "# Title",
+              type: "markdown",
+              preferredView: "result",
+            },
+          ],
+        },
+      }
+
+      const cells = sanitizeBuffer(input).notebookViewState?.cells
+      expect(cells?.map((cell) => cell.preferredView)).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 6164e41d2..24a97f2e1 100644
--- a/src/scenes/Editor/Monaco/importTabs.ts
+++ b/src/scenes/Editor/Monaco/importTabs.ts
@@ -271,16 +271,19 @@ 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 (
-    item.wideView === "editor" ||
-    item.wideView === "result" ||
-    item.wideView === "editor_result"
-  )
-    cell.wideView = item.wideView
-  if (item.compactView === "editor" || item.compactView === "result")
-    cell.compactView = item.compactView
+  if (item.type !== "markdown") {
+    if (
+      item.preferredView === "editor" ||
+      item.preferredView === "result" ||
+      item.preferredView === "editor_result"
+    ) {
+      cell.preferredView = item.preferredView
+    } else if (item.isViewMaximized === true) {
+      cell.preferredView = "result"
+    } else {
+      cell.preferredView = "editor_result"
+    }
+  }
   if (typeof item.topHeight === "number") cell.topHeight = item.topHeight
   if (typeof item.bottomHeight === "number")
     cell.bottomHeight = item.bottomHeight
diff --git a/src/scenes/Editor/Notebook/NotebookProvider.tsx b/src/scenes/Editor/Notebook/NotebookProvider.tsx
index 6adc0367c..747e764e9 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,
+  setCellPreferredViewTransition,
   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
+  setCellPreferredView: (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,
+  setCellPreferredView: () => 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 setCellPreferredView = useCallback(
+    (cellId: string, view: AgentCellView) =>
       silently(() =>
         applyTransition((parts) =>
-          setCellViewMaximizedTransition(parts, bufferId, cellId, value),
+          setCellPreferredViewTransition(parts, bufferId, cellId, view),
         ),
       ),
     [applyTransition, bufferId],
@@ -828,7 +829,7 @@ export const NotebookProvider: React.FC<{
     setCellRefresh: store.setCellRefresh,
     resetAutoRefreshOverrides,
     refreshAllCells: () => cellRefreshEngine.refreshAll(),
-    setCellViewMaximized,
+    setCellPreferredView,
     setFocusedCell,
     setMaximizedCellId,
     getCellsSnapshot: () => store.cellsRef.current.slice(),
diff --git a/src/scenes/Editor/Notebook/cells/Cell.tsx b/src/scenes/Editor/Notebook/cells/Cell.tsx
index 1aae11406..3341b941a 100644
--- a/src/scenes/Editor/Notebook/cells/Cell.tsx
+++ b/src/scenes/Editor/Notebook/cells/Cell.tsx
@@ -253,12 +253,20 @@ const CellInner: React.FC<Props> = ({
       publishLiveCellPresentation(bufferIdForEvents, cell.id, {
         compact: isCompactTier,
         paneLayout,
+        expectingResult,
         ...(gridContainerWidth !== undefined ? { gridContainerWidth } : {}),
       }),
-    [bufferIdForEvents, cell.id, gridContainerWidth, isCompactTier, paneLayout],
+    [
+      bufferIdForEvents,
+      cell.id,
+      expectingResult,
+      gridContainerWidth,
+      isCompactTier,
+      paneLayout,
+    ],
   )
 
-  const isViewMaximized = paneLayout === "result"
+  const resultOnly = paneLayout === "result"
   const showBottomSlot = paneLayout !== "editor"
   const isSplit = paneLayout === "split"
   const runActive = !isDrawMode && doubleView
@@ -313,7 +321,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(
@@ -548,7 +556,7 @@ const CellInner: React.FC<Props> = ({
               view={view}
               cellAutoRefresh={cell.autoRefresh}
               autoRefreshDefault={autoRefreshDefault}
-              isViewMaximized={isViewMaximized}
+              paneLayout={paneLayout}
               isRunning={isRunning}
               isGridLoading={isGridLoading}
               isChartLoading={chartLoading}
@@ -560,7 +568,7 @@ const CellInner: React.FC<Props> = ({
             <CellViewToggle
               cellId={cell.id}
               view={view}
-              isViewMaximized={isViewMaximized}
+              paneLayout={paneLayout}
               isGridLoading={isGridLoading}
               isChartLoading={chartLoading}
               isRunning={isRunning}
@@ -570,7 +578,7 @@ const CellInner: React.FC<Props> = ({
           )
         }
       />
-      {!isViewMaximized && (
+      {!resultOnly && (
         <EditorContainer
           ref={editorContainerRef}
           $spotlight={isMaximized}
@@ -648,7 +656,7 @@ const CellInner: React.FC<Props> = ({
           ref={resultRef}
           $spotlight={isMaximized}
           style={
-            isViewMaximized
+            resultOnly
               ? isMaximized
                 ? { flex: 1 }
                 : { height: bottomHeight }
@@ -678,10 +686,10 @@ const CellInner: React.FC<Props> = ({
       <ResizeHandle
         overlay
         targetRef={
-          isViewMaximized || showBottomSlot ? resultRef : editorContainerRef
+          resultOnly || showBottomSlot ? resultRef : editorContainerRef
         }
         onResize={
-          isViewMaximized
+          resultOnly
             ? maximizedChartResizeLive
             : showBottomSlot
               ? bottomResize.resizeLive
@@ -689,7 +697,7 @@ const CellInner: React.FC<Props> = ({
         }
         onResizeEnd={(height) => {
           void trackEvent(ConsoleEvent.NOTEBOOK_CELL_RESIZE, { region: "s" })
-          if (isViewMaximized) maximizedChartResizeEnd(height)
+          if (resultOnly) maximizedChartResizeEnd(height)
           else if (showBottomSlot) bottomResize.resizeEnd(height)
           else topResize.resizeEnd(height)
         }}
@@ -698,9 +706,7 @@ const CellInner: React.FC<Props> = ({
           resetBottomArea()
         }}
         minHeight={
-          isViewMaximized || showBottomSlot
-            ? minBottomHeightFor(cell)
-            : undefined
+          resultOnly || showBottomSlot ? minBottomHeightFor(cell) : undefined
         }
       />
     ) : null
diff --git a/src/scenes/Editor/Notebook/cells/CellToolbar.tsx b/src/scenes/Editor/Notebook/cells/CellToolbar.tsx
index 8291bf0fe..8f4189d92 100644
--- a/src/scenes/Editor/Notebook/cells/CellToolbar.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellToolbar.tsx
@@ -100,9 +100,8 @@ export const CellToolbar: React.FC<Props> = ({
     setFocusedCell,
     setMaximizedCellId,
     setCellRefresh,
-    setCellViewMaximized,
+    setCellPreferredView,
     setCellMode,
-    updateCell,
   } = useNotebookActions()
   const bufferId = useNotebookBufferId()
 
@@ -115,11 +114,8 @@ export const CellToolbar: React.FC<Props> = ({
   const isChartView = view === "chart"
   const isGridView = view === "grid"
   const isNoneView = view === "none"
-  const isViewMaximized =
-    !isNoneView &&
-    (paneLayout !== undefined
-      ? paneLayout === "result"
-      : !!cell.isViewMaximized)
+  const resultOnly =
+    !isNoneView && paneLayout !== undefined && paneLayout === "result"
   const autoRefresh = resolveAutoRefresh(cell.autoRefresh, autoRefreshDefault)
   // A write cell never ticks, so the menu must not offer an interval the
   // engine would ignore — same gate the inline selector applies.
@@ -163,8 +159,7 @@ export const CellToolbar: React.FC<Props> = ({
       method: "menu",
     })
     signalUserEdit(bufferId)
-    if (toolbarTier === "compact") updateCell(cellId, { compactView: "editor" })
-    else setCellViewMaximized(cellId, false)
+    setCellPreferredView(cellId, "editor")
   }
   const handleViewTable = () => {
     if (isRunning) return
@@ -180,8 +175,7 @@ export const CellToolbar: React.FC<Props> = ({
     // A chart transfers its data to the grid (no re-query); restore the data
     // pane in case the SQL was being shown.
     if (isChartView) setCellMode(cellId, "run")
-    if (toolbarTier === "compact") updateCell(cellId, { compactView: "result" })
-    else setCellViewMaximized(cellId, true)
+    setCellPreferredView(cellId, "result")
   }
   const handleViewChart = () => {
     if (isRunning) return
@@ -196,16 +190,15 @@ export const CellToolbar: React.FC<Props> = ({
       eventBus.publish(EventType.NOTEBOOK_CELL_DRAW, { cellId, maximize: true })
       return
     }
-    if (toolbarTier === "compact") updateCell(cellId, { compactView: "result" })
-    else setCellViewMaximized(cellId, true)
+    setCellPreferredView(cellId, "result")
   }
   const handleToggleMaximizeView = () => {
     void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_MAXIMIZE, {
-      isViewMaximized: !isViewMaximized,
+      isViewMaximized: !resultOnly,
       view,
     })
     signalUserEdit(bufferId)
-    setCellViewMaximized(cellId, !isViewMaximized)
+    setCellPreferredView(cellId, resultOnly ? "editor_result" : "result")
   }
   const handleMaximizeCell = () => {
     void trackEvent(ConsoleEvent.NOTEBOOK_CELL_MAXIMIZE, {
@@ -351,7 +344,7 @@ export const CellToolbar: React.FC<Props> = ({
                   onSelect={handleToggleMaximizeView}
                   icon={<FileSqlIcon size={16} />}
                 >
-                  {isViewMaximized ? "Show editor" : "Hide editor"}
+                  {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 1c90b29e8..ce9d140b0 100644
--- a/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
@@ -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"
 
@@ -72,7 +72,7 @@ const EditorVisibilityToggle = styled(PrimaryToggleButton)`
 type Props = {
   cellId: string
   view: CellView
-  isViewMaximized: boolean
+  paneLayout: CellPaneLayout
   isGridLoading: boolean
   isChartLoading: boolean
   isRunning: boolean
@@ -83,16 +83,18 @@ type Props = {
 export const CellViewToggle: React.FC<Props> = ({
   cellId,
   view,
-  isViewMaximized,
+  paneLayout,
   isGridLoading,
   isChartLoading,
   isRunning,
   chartZoomed,
   showLabels,
 }) => {
-  const { setCellViewMaximized, setCellMode, clearCellResult } =
+  const { setCellPreferredView, 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
@@ -122,15 +124,16 @@ export const CellViewToggle: React.FC<Props> = ({
       return
     }
     setCellMode(cellId, "run")
+    if (resultHidden) setCellPreferredView(cellId, "editor_result")
   }
   const handleEditorVisibility = (e: React.MouseEvent) => {
     e.stopPropagation()
     void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_MAXIMIZE, {
-      isViewMaximized: !isViewMaximized,
+      isViewMaximized: !resultOnly,
       view,
     })
     signalUserEdit(bufferId)
-    setCellViewMaximized(cellId, !isViewMaximized)
+    setCellPreferredView(cellId, resultOnly ? "editor_result" : "result")
   }
   const handleResetZoom = (e: React.MouseEvent) => {
     e.stopPropagation()
@@ -183,11 +186,11 @@ export const CellViewToggle: React.FC<Props> = ({
         </Tooltip>
       </NotebookViewToggle>
       <Divider />
-      <Tooltip content={isViewMaximized ? "Show editor" : "Hide editor"}>
+      <Tooltip content={resultOnly ? "Show editor" : "Hide editor"}>
         <EditorVisibilityToggle
-          aria-label={isViewMaximized ? "Show editor" : "Hide editor"}
+          aria-label={resultOnly ? "Show editor" : "Hide editor"}
           onClick={handleEditorVisibility}
-          selected={!isViewMaximized}
+          selected={!resultOnly}
         >
           <FileSqlIcon size={18} />
         </EditorVisibilityToggle>
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/useCellRunActions.ts b/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
index 668bdce38..4ce21c8e9 100644
--- a/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
+++ b/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
@@ -46,8 +46,7 @@ export const useCellRunActions = ({
     runCell,
     setCellMode,
     clearCellResult,
-    setCellViewMaximized,
-    updateCell,
+    setCellPreferredView,
     getCellsSnapshot,
   } = useNotebookActions()
   const bufferIdForEvents = useNotebookBufferId()
@@ -211,7 +210,11 @@ export const useCellRunActions = ({
   const runResolved = useCallback(
     (intent: "all" | "single", ignoreSelection = false) => {
       const plan = resolveRunAction(
-        { mode: cell.mode, result: cell.result },
+        {
+          mode: cell.mode,
+          result: cell.result,
+          preferredView: cell.preferredView,
+        },
         { isCompactTier, showBottomSlot, intent },
       )
       if (plan.kind === "noop") return
@@ -234,19 +237,20 @@ export const useCellRunActions = ({
       if (plan.kind === "run-all") void handleRunAll(ignoreSelection)
       else void handleRunSingle()
       if (plan.reveal) {
-        if (isCompactTier) updateCell(cell.id, { compactView: "result" })
-        else setCellViewMaximized(cell.id, true)
+        // Running from compact editor-only mode reveals the result while
+        // preserving the natural split presentation when the cell widens.
+        setCellPreferredView(cell.id, "editor_result")
       }
     },
     [
       cell.id,
       cell.mode,
       cell.result,
+      cell.preferredView,
       bufferIdForEvents,
       isCompactTier,
       showBottomSlot,
-      setCellViewMaximized,
-      updateCell,
+      setCellPreferredView,
       setCellMode,
       handleRunAll,
       handleRunSingle,
@@ -297,9 +301,9 @@ export const useCellRunActions = ({
     const drawHandler = (payload?: { cellId?: string; maximize?: boolean }) => {
       if (payload?.cellId !== cell.id) return
       void handleDrawClick().then((entered) => {
-        if (!entered || !payload.maximize) return
-        if (isCompactTier) updateCell(cell.id, { compactView: "result" })
-        else setCellViewMaximized(cell.id, true)
+        if (!entered) return
+        if (payload.maximize) setCellPreferredView(cell.id, "result")
+        else if (!showBottomSlot) setCellPreferredView(cell.id, "editor_result")
       })
     }
     eventBus.subscribe(EventType.NOTEBOOK_CELL_RUN, runHandler)
@@ -312,9 +316,8 @@ export const useCellRunActions = ({
     cell.id,
     refreshRun,
     handleDrawClick,
-    isCompactTier,
-    setCellViewMaximized,
-    updateCell,
+    setCellPreferredView,
+    showBottomSlot,
   ])
 
   const isGridLoading = isRunning && firstRunRef.current
diff --git a/src/scenes/Editor/Notebook/notebookPresentationStore.ts b/src/scenes/Editor/Notebook/notebookPresentationStore.ts
index 1604a327b..5d8adfabd 100644
--- a/src/scenes/Editor/Notebook/notebookPresentationStore.ts
+++ b/src/scenes/Editor/Notebook/notebookPresentationStore.ts
@@ -3,6 +3,10 @@ import type { CellPaneLayout } from "./notebookUtils"
 export type LiveCellPresentation = {
   compact: boolean
   paneLayout: CellPaneLayout
+  // 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
   // Present for grid cells. Tool mutations use the same measured container
   // width as the renderer to resolve the tier produced by a new grid.w.
   gridContainerWidth?: number
diff --git a/src/scenes/Editor/Notebook/notebookUtils.test.ts b/src/scenes/Editor/Notebook/notebookUtils.test.ts
index ceca0d01d..e7f9a60ae 100644
--- a/src/scenes/Editor/Notebook/notebookUtils.test.ts
+++ b/src/scenes/Editor/Notebook/notebookUtils.test.ts
@@ -386,7 +386,15 @@ describe("buildPersistPayload", () => {
       layoutMode: "list",
     })
     expect(payload).toEqual({
-      cells: [{ ...cells[0], result: undefined, lastRunStatus: "cancelled" }],
+      cells: [
+        {
+          ...cells[0],
+          result: undefined,
+          lastRunStatus: "cancelled",
+          lastRunError: undefined,
+          preferredView: "editor_result",
+        },
+      ],
       focusedCellId: "a",
       maximizedCellId: undefined,
       settings: { layoutMode: "list" },
@@ -1048,6 +1056,56 @@ describe("buildAppliedCells", () => {
     ).toThrow(/line limit/)
   })
 
+  it("validates dimensions against the target type when markdown becomes sql", () => {
+    const prev: NotebookCell[] = [
+      { id: "a", position: 0, value: "SELECT 1", type: "markdown" },
+    ]
+    expect(() =>
+      buildAppliedCells(prev, {
+        cells: [
+          {
+            id: "a",
+            preserveValue: true,
+            type: "sql",
+            editorHeight: 30,
+            view: "result",
+          },
+        ],
+      }),
+    ).toThrow(/editor_height below its minimum/)
+  })
+
+  it("applies a requested view when markdown becomes sql", () => {
+    const prev: NotebookCell[] = [
+      { id: "a", position: 0, value: "SELECT 1", type: "markdown" },
+    ]
+    const { nextCells } = buildAppliedCells(prev, {
+      cells: [
+        {
+          id: "a",
+          preserveValue: true,
+          type: "sql",
+          editorHeight: 72,
+          view: "result",
+        },
+      ],
+    })
+    expect(nextCells[0]).toMatchObject({
+      topHeight: 72,
+      topResized: true,
+      preferredView: "result",
+    })
+    expect(nextCells[0].type).toBeUndefined()
+  })
+
+  it("rejects grid placement that extends beyond the notebook columns", () => {
+    expect(() =>
+      buildAppliedCells([], {
+        cells: [{ value: "SELECT 1", grid: { x: 11, y: 0, w: 2 } }],
+      }),
+    ).toThrow(/x \+ w must be at most 12/)
+  })
+
   it("deletes cells whose ids are missing from the request", () => {
     const prev: NotebookCell[] = [
       { id: "a", position: 0, value: "" },
@@ -1190,7 +1248,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: [
         {
@@ -1205,8 +1263,7 @@ 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].wideView).toBe("result")
+    expect(nextCells[0].preferredView).toBe("result")
   })
 
   it("applies semantic pane dimensions and view to a new draw cell", () => {
@@ -1231,9 +1288,7 @@ describe("buildAppliedCells", () => {
       topResized: true,
       bottomHeight: 280,
       bottomResized: true,
-      isViewMaximized: false,
-      wideView: "editor_result",
-      compactView: "result",
+      preferredView: "editor_result",
     })
   })
 
@@ -1247,7 +1302,7 @@ describe("buildAppliedCells", () => {
       topResized: true,
       bottomHeight: 280,
       bottomResized: true,
-      isViewMaximized: false,
+      preferredView: "editor_result",
       chartConfig: {
         xColumn: "ts",
         queries: [{ type: "line", yColumns: ["v"] }],
@@ -1272,7 +1327,7 @@ describe("buildAppliedCells", () => {
       topResized: true,
       bottomHeight: 280,
       bottomResized: true,
-      isViewMaximized: false,
+      preferredView: "editor_result",
     })
   })
 
@@ -1307,7 +1362,7 @@ describe("buildAppliedCells", () => {
         value: "SELECT 1",
         mode: "run",
         autoRefresh: "5s",
-        isViewMaximized: true,
+        preferredView: "result",
         chartConfig: {
           xColumn: "ts",
           queries: [{ type: "line", yColumns: ["v"] }],
@@ -1324,7 +1379,7 @@ describe("buildAppliedCells", () => {
     expect(nextCells[0].mode).toBe("run")
     expect(nextCells[0].chartConfig).toBeUndefined()
     expect(nextCells[0].autoRefresh).toBeUndefined()
-    expect(nextCells[0].isViewMaximized).toBe(true)
+    expect(nextCells[0].preferredView).toBe("result")
   })
 
   it("preserves draw mode when apply omits mode and supplies its full chart", () => {
@@ -1414,7 +1469,7 @@ describe("isDoubleView", () => {
         position: 0,
         value: "",
         mode: "draw",
-        isViewMaximized: true,
+        preferredView: "result",
       }),
     ).toBe(true)
   })
@@ -1544,12 +1599,13 @@ describe("computeResultBottomHeight", () => {
     ).toBe(464)
   })
 
-  it("multi-statement, first is error → tab + notification only (no grid to show)", () => {
-    // 40 + 44 = 84
+  it("multi-statement, later DQL → tab + full 10-row grid block", () => {
+    // Any grid-bearing tab must fit without resizing or tab-switch jitter:
+    // 40 + 44 + 36 + 44 + 10*30 = 464.
     expect(
       computeResultBottomHeight({
         results: [
-          { type: "error", query: "Q1", error: "boom" },
+          { type: "ddl", query: "Q1" },
           {
             type: "dql",
             query: "Q2",
@@ -1561,6 +1617,19 @@ describe("computeResultBottomHeight", () => {
         activeResultIndex: 1,
         timestamp: 0,
       }),
+    ).toBe(464)
+  })
+
+  it("multi-statement with no DQL grid → tab + notification only", () => {
+    expect(
+      computeResultBottomHeight({
+        results: [
+          { type: "ddl", query: "Q1" },
+          { type: "dml", query: "Q2" },
+        ],
+        activeResultIndex: 1,
+        timestamp: 0,
+      }),
     ).toBe(84)
   })
 
@@ -1850,7 +1919,7 @@ describe("computeCellGridH", () => {
           value: "",
           topHeight: 72,
           bottomHeight: 104,
-          isViewMaximized: true,
+          preferredView: "result",
           result: { results: [], activeResultIndex: 0, timestamp: 0 },
         },
         10,
@@ -1893,32 +1962,36 @@ describe("resolveCellPaneLayout", () => {
     expect(resolveCellPaneLayout(cell, false, true)).toBe("editor")
   })
 
-  it("uses persisted visibility for wide cells", () => {
+  it("uses the authoritative preference for wide cells", () => {
     expect(resolveCellPaneLayout(withResult(), false, false)).toBe("split")
     expect(
       resolveCellPaneLayout(
-        withResult({ isViewMaximized: true }),
+        withResult({ preferredView: "result" }),
         false,
         false,
       ),
     ).toBe("result")
     expect(
-      resolveCellPaneLayout(withResult({ wideView: "editor" }), false, false),
+      resolveCellPaneLayout(
+        withResult({ preferredView: "editor" }),
+        false,
+        false,
+      ),
     ).toBe("editor")
   })
 
-  it("defaults compact cells to result and keeps compact choice independent", () => {
+  it("projects the authoritative preference for compact cells", () => {
     expect(resolveCellPaneLayout(withResult(), false, true)).toBe("result")
     expect(
       resolveCellPaneLayout(
-        withResult({ isViewMaximized: true, compactView: "editor" }),
+        withResult({ preferredView: "editor" }),
         false,
         true,
       ),
     ).toBe("editor")
     expect(
       resolveCellPaneLayout(
-        withResult({ isViewMaximized: false, compactView: "result" }),
+        withResult({ preferredView: "result" }),
         false,
         true,
       ),
@@ -1932,14 +2005,13 @@ describe("resolveAgentCellPresentation", () => {
     position: 0,
     value: "SELECT 1",
     mode: "draw",
-    wideView: "editor_result",
-    compactView: "result",
+    preferredView: "editor_result",
     ...over,
   })
 
   it("returns the effective live view with its tier", () => {
     expect(
-      resolveAgentCellPresentation(chart({ wideView: "editor" }), false),
+      resolveAgentCellPresentation(chart({ preferredView: "editor" }), false),
     ).toEqual({
       preferred_view: "editor",
       view: "editor",
@@ -1957,6 +2029,31 @@ describe("resolveAgentCellPresentation", () => {
       preferred_view: "editor_result",
     })
   })
+
+  it("keeps preference stable while result availability and width change", () => {
+    const pending: NotebookCell = {
+      id: "x",
+      position: 0,
+      value: "SELECT 1",
+      lastRunStatus: "success",
+      preferredView: "editor_result",
+    }
+    expect(resolveAgentCellPresentation(pending, false, true)).toEqual({
+      preferred_view: "editor_result",
+      view: "editor_result",
+      tier: "wide",
+    })
+    expect(resolveAgentCellPresentation(pending, true, true)).toEqual({
+      preferred_view: "editor_result",
+      view: "result",
+      tier: "compact",
+    })
+    expect(resolveAgentCellPresentation(pending, false, false)).toEqual({
+      preferred_view: "editor_result",
+      view: "editor",
+      tier: "wide",
+    })
+  })
 })
 
 describe("computeCellMinGridH", () => {
@@ -1984,7 +2081,7 @@ describe("computeCellMinGridH", () => {
       value: "",
       topHeight: 400,
       bottomHeight: 300,
-      isViewMaximized: true,
+      preferredView: "result",
       result,
     }
 
@@ -2212,7 +2309,7 @@ describe("cellHeightPatchForRows", () => {
     const c = withResult({
       topHeight: 72,
       bottomHeight: 100,
-      isViewMaximized: true,
+      preferredView: "result",
     })
     // When a taller height is requested (targetContentPx = 430 - 44 = 386,
     // and no editor allocation in its visible footprint)
@@ -2518,7 +2615,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: "" },
         ],
       },
@@ -2528,8 +2625,8 @@ describe("buildAppliedLayout", () => {
     )
     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. The supplied legacy h is ignored;
-    // both cells derive h and the second stacks below the first at y=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 })
   })
 
@@ -2598,7 +2695,7 @@ describe("cloneNotebookViewState", () => {
         value: "SELECT 2",
         mode: "draw",
         autoRefresh: true,
-        isViewMaximized: true,
+        preferredView: "result",
         chartConfig: {
           xColumn: "ts",
           queries: [{ type: "line", yColumns: ["v"] }],
@@ -2672,7 +2769,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].preferredView).toBe("result")
     expect(out.cells[1].chartConfig).toEqual({
       xColumn: "ts",
       queries: [{ type: "line", yColumns: ["v"] }],
@@ -3066,6 +3163,45 @@ describe("resolveRunAction", () => {
     })
   })
 
+  it("reveals a wide run cell whose result is hidden by an editor preference", () => {
+    // Given a wide run cell whose stored preference hides the result
+    const cell = {
+      mode: "run" as const,
+      result,
+      preferredView: "editor" as const,
+    }
+    const opts = { isCompactTier: false, showBottomSlot: false }
+    // When the user runs
+    // Then it reveals the grid first, then runs
+    expect(resolveRunAction(cell, { ...opts, intent: "all" })).toEqual({
+      kind: "run-all",
+      reveal: true,
+      exitDraw: false,
+    })
+    expect(resolveRunAction(cell, { ...opts, intent: "single" })).toEqual({
+      kind: "run-single",
+      reveal: true,
+      exitDraw: false,
+    })
+  })
+
+  it("keeps drawing a wide draw cell that has no result yet", () => {
+    // Given a wide draw cell whose chart has not landed (bottom slot hidden)
+    const cell = {
+      mode: "draw" as const,
+      preferredView: "editor_result" as const,
+    }
+    const opts = { isCompactTier: false, showBottomSlot: false }
+    // 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, { ...opts, intent: "all" })).toEqual({
+      kind: "chart",
+    })
+    expect(resolveRunAction(cell, { ...opts, 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 }
@@ -3572,83 +3708,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")])
diff --git a/src/scenes/Editor/Notebook/notebookUtils.ts b/src/scenes/Editor/Notebook/notebookUtils.ts
index 6b49060ac..eaa68e3ac 100644
--- a/src/scenes/Editor/Notebook/notebookUtils.ts
+++ b/src/scenes/Editor/Notebook/notebookUtils.ts
@@ -98,16 +98,16 @@ type RunActionPlan =
   | { kind: "run-all" | "run-single"; reveal: boolean; exitDraw: boolean }
 
 export const resolveRunAction = (
-  cell: Pick<NotebookCell, "mode" | "result">,
+  cell: Pick<NotebookCell, "mode" | "result" | "preferredView">,
   opts: {
     isCompactTier: boolean
     showBottomSlot: boolean
     intent: "all" | "single"
   },
 ): RunActionPlan => {
-  // Reveal only the compact "View editor" 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 hiddenByPreference = cell.preferredView === "editor"
+  const reveal =
+    !opts.showBottomSlot && (opts.isCompactTier || hiddenByPreference)
   if (cell.mode === "draw" && !reveal) {
     return opts.intent === "all" ? { kind: "chart" } : { kind: "noop" }
   }
@@ -507,12 +507,21 @@ 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.preferredView
+    else persisted.preferredView = cell.preferredView ?? "editor_result"
+    const canonical = persisted as NotebookCell & Record<string, unknown>
+    delete canonical.isViewMaximized
+    delete canonical.wideView
+    delete canonical.compactView
+    return persisted
+  })
 
 export const buildPersistPayload = (
   cells: NotebookCell[],
@@ -618,6 +627,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.preferredView
   const newCell: NotebookCell =
     created.type === "markdown" || created.topHeight !== undefined
       ? created
@@ -718,11 +728,8 @@ type ApplyCellRequest = {
   editorHeight?: number | "auto" | null
   resultHeight?: number | "auto" | null
   view?: AgentCellView | null
-  editorVisible?: boolean | null
-  // Legacy cached-agent inputs. New tool schemas expose view instead.
-  isViewMaximized?: boolean | null
   chartConfig?: ChartConfig | null
-  grid?: { x: number; y: number; w: number; h?: number } | null
+  grid?: { x: number; y: number; w: number } | null
 }
 
 type ApplyRequest = {
@@ -1176,37 +1183,30 @@ export const buildAppliedCells = (
     const isDraw = resolvedMode === "draw"
     if (
       resolvedType === "markdown" &&
-      (req.resultHeight != null ||
-        req.editorVisible != null ||
-        (req.view != null && req.view !== "editor"))
+      (req.resultHeight != null || (req.view != null && req.view !== "editor"))
     ) {
       throw new ApplyNotebookStateError(
         `Cell at index ${index} is markdown; result_height must be null and view must be null or "editor". Use editor_height to size its rendered content.`,
         "cells",
       )
     }
+    const dimensionCell: NotebookCell = {
+      ...(existing ?? { id, position: index, value }),
+      value,
+      ...(resolvedMode !== undefined ? { mode: resolvedMode } : {}),
+    }
+    if (resolvedType === "markdown") dimensionCell.type = "markdown"
+    else delete dimensionCell.type
     if (
       typeof req.editorHeight === "number" &&
       (!Number.isFinite(req.editorHeight) ||
-        req.editorHeight <
-          minTopHeightFor({
-            ...(existing ?? { id, position: index, value }),
-            ...(resolvedType === "markdown"
-              ? { type: "markdown" as const }
-              : {}),
-          }))
+        req.editorHeight < minTopHeightFor(dimensionCell))
     ) {
       throw new ApplyNotebookStateError(
         `Cell at index ${index} has an editor_height below its minimum.`,
         "cells",
       )
     }
-    const dimensionCell: NotebookCell = {
-      ...(existing ?? { id, position: index, value }),
-      value,
-      ...(resolvedMode !== undefined ? { mode: resolvedMode } : {}),
-      ...(resolvedType === "markdown" ? { type: "markdown" } : {}),
-    }
     if (
       typeof req.resultHeight === "number" &&
       (!Number.isFinite(req.resultHeight) ||
@@ -1222,26 +1222,21 @@ export const buildAppliedCells = (
       resultHeight: req.resultHeight,
       view: req.view,
     })
-    if (
-      req.view == null &&
-      req.editorVisible == null &&
-      req.isViewMaximized == null &&
-      !existing &&
-      isDraw
-    ) {
-      dimensionsPatch.isViewMaximized = true
-      dimensionsPatch.wideView = "result"
-    } else if (req.view == null && req.editorVisible != null) {
-      dimensionsPatch.isViewMaximized = !req.editorVisible
-      dimensionsPatch.wideView = req.editorVisible ? "editor_result" : "result"
-    } else if (req.view == null && req.isViewMaximized != null) {
-      dimensionsPatch.isViewMaximized = req.isViewMaximized
-      dimensionsPatch.wideView = req.isViewMaximized
-        ? "result"
-        : "editor_result"
+    if (req.view == null && !existing && isDraw) {
+      dimensionsPatch.preferredView = "result"
     }
     const autoRefresh = req.autoRefresh != null ? 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)
       const valueChanged = existing.value !== value
@@ -1289,14 +1284,13 @@ export const buildAppliedCells = (
         delete next.mode
         delete next.chartConfig
         delete next.autoRefresh
-        delete next.isViewMaximized
-        delete next.wideView
-        delete next.compactView
+        delete next.preferredView
         delete next.bottomHeight
         delete next.lastRunStatus
         delete next.lastRunError
       } else {
         delete next.type
+        next.preferredView ??= "editor_result"
         if (valueChanged && !existing.topResized) {
           const estimated = topHeightForSql(value)
           if (
@@ -1325,6 +1319,7 @@ export const buildAppliedCells = (
       return created
     }
     created.topHeight = topHeightForSql(value)
+    created.preferredView = "editor_result"
     if (resolvedMode !== undefined) created.mode = resolvedMode
     if (chartConfig !== undefined) created.chartConfig = chartConfig
     if (autoRefresh !== undefined) created.autoRefresh = autoRefresh
@@ -1421,8 +1416,7 @@ export type AgentCellDimensions = {
   resultHeight?: AgentHeightValue
   view?: AgentCellView | null
   compact?: boolean
-  // Legacy cached-agent input. Current schemas expose `view`.
-  editorVisible?: boolean | null
+  expectingResult?: boolean
 }
 
 // Translate the semantic agent wire model into the persisted pane model.
@@ -1448,17 +1442,8 @@ export const agentCellDimensionsPatch = (
     patch.bottomHeight = dimensions.resultHeight
     patch.bottomResized = true
   }
-  if (typeof dimensions.editorVisible === "boolean") {
-    patch.isViewMaximized = !dimensions.editorVisible
-    patch.wideView = dimensions.editorVisible ? "editor_result" : "result"
-  }
   if (dimensions.view != null && cell.type !== "markdown") {
-    // Agent writes describe one width-independent preference. Compact cannot
-    // render a split, so editor_result projects to result there and restores
-    // exactly when the cell becomes wide again.
-    patch.wideView = dimensions.view
-    patch.isViewMaximized = dimensions.view === "result"
-    patch.compactView = dimensions.view === "editor" ? "editor" : "result"
+    patch.preferredView = dimensions.view
   }
   return patch
 }
@@ -1530,11 +1515,9 @@ const dqlRowCount = (r: SingleQueryResult): number =>
 //      caps at 10 for large ones.
 //   3. Multi-statement (script) run:
 //      - tab bar always visible.
-//      - If the first result is non-DQL (error / DDL / DML / notice), height
-//        is just tab bar + notification (no grid to show).
-//      - Otherwise reserve a full 10 rows worth of space regardless of how
-//        many rows the active tab actually has (avoids jitter when switching
-//        between tabs that have different row counts).
+//      - If no result can display a grid, height is tab bar + notification.
+//      - If any result can display a grid, reserve a full 10 rows regardless
+//        of which tab is active (avoids clipping and tab-switch jitter).
 export const computeResultBottomHeight = (
   result: CellResult | null | undefined,
 ): number => {
@@ -1543,11 +1526,9 @@ export const computeResultBottomHeight = (
   const tabBar = isMulti ? TAB_BAR_PX : 0
 
   if (isMulti) {
-    const first = result.results[0]
-    if (!first || !isDqlWithColumns(first)) {
-      // First query failed / wasn't DQL — there is no grid to show, no point
-      // reserving 10 rows of space. The tab bar still shows so the user can
-      // click through other tabs.
+    if (!result.results.some(isDqlWithColumns)) {
+      // No tab can render a grid. The tab bar still shows so the user can
+      // inspect each statement's status.
       return tabBar + NOTIFICATION_PX
     }
     return (
@@ -1594,10 +1575,7 @@ export const agentViewForPaneLayout = (
 
 export const storedAgentCellView = (cell: NotebookCell): AgentCellView => {
   if (cell.type === "markdown") return "editor"
-  if (cell.wideView !== undefined) return cell.wideView
-  if (cell.isViewMaximized === true) return "result"
-  if (cell.isViewMaximized === false) return "editor_result"
-  return isDoubleView(cell) ? "editor_result" : "editor"
+  return cell.preferredView ?? "editor_result"
 }
 
 export type AgentCellPresentation = {
@@ -1621,10 +1599,9 @@ export const resolveAgentCellPresentation = (
   }
 }
 
-// Resolve responsive presentation without mutating notebook state. Compact
-// cells can show only one pane; wider cells may split. Keeping this decision in
-// one helper prevents rendering and grid geometry from interpreting the two
-// internal responsive preferences differently.
+// Resolve one authoritative preference against live result availability and
+// width. Compact cells project editor_result to result; widening restores the
+// persisted preference without writing notebook state.
 export const resolveCellPaneLayout = (
   cell: NotebookCell,
   expectingResult: boolean = false,
@@ -1632,14 +1609,10 @@ export const resolveCellPaneLayout = (
 ): CellPaneLayout => {
   const hasResult = isDoubleView(cell) || expectingResult
   if (!hasResult) return "editor"
-  if (compact) {
-    return cell.compactView === "editor" ? "editor" : "result"
-  }
-  const wideView =
-    cell.wideView ??
-    (cell.isViewMaximized === true ? "result" : "editor_result")
-  if (wideView === "editor") return "editor"
-  return wideView === "result" ? "result" : "split"
+  const preferredView = storedAgentCellView(cell)
+  if (compact && preferredView === "editor_result") return "result"
+  if (preferredView === "editor") return "editor"
+  return preferredView === "result" ? "result" : "split"
 }
 
 // bottomHeight seeding when a cell flips between run and draw. A user-resized
@@ -1662,12 +1635,7 @@ export const modeChangeBottomHeightPatch = (
 export const cellModeChangePatch = (
   cell: NotebookCell | undefined,
   mode: CellMode,
-): Partial<NotebookCell> => ({
-  ...modeChangeBottomHeightPatch(cell, mode),
-  ...(mode === "draw"
-    ? { isViewMaximized: false, wideView: "editor_result" as const }
-    : {}),
-})
+): Partial<NotebookCell> => modeChangeBottomHeightPatch(cell, mode)
 
 export const mergeCellChartConfig = (
   cell: NotebookCell,
@@ -1782,6 +1750,14 @@ export const NOTEBOOK_GRID_COLS = 12
 export const NOTEBOOK_GRID_ROW_HEIGHT = 10
 export const NOTEBOOK_GRID_MARGIN_Y = 20
 
+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.
 //
@@ -2001,38 +1977,12 @@ export const buildAppliedNotebookState = (
       ? current.settings.layoutMode
       : request.layoutMode
 
-  // Cached clients may still send grid.h. New clients size semantic panes and
-  // grid h is derived, but keep the legacy back-solve during the transition.
-  //
-  // 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 || g.h === undefined) 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,
@@ -2057,16 +2007,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 fa4aff4bf..500877564 100644
--- a/src/store/notebook.ts
+++ b/src/store/notebook.ts
@@ -37,7 +37,6 @@ export type AutoRefresh = boolean | AutoRefreshInterval
 // migration. Markdown cells hold their source in `value` and are never executed.
 export type CellType = "sql" | "markdown"
 
-export type CellCompactView = "editor" | "result"
 export type AgentCellView = "editor" | "result" | "editor_result"
 export type AgentCellTier = "compact" | "wide"
 
@@ -57,12 +56,9 @@ export type NotebookCell = {
   mode?: CellMode
   chartConfig?: ChartConfig
   autoRefresh?: AutoRefresh
-  // Wide and compact layouts keep internal presentation preferences. The
-  // agent sets one `view` preference and reads the currently resolved view;
-  // these storage fields are never exposed directly.
-  isViewMaximized?: boolean
-  wideView?: AgentCellView
-  compactView?: CellCompactView
+  // Authoritative, viewport-independent pane intent. The rendered view is
+  // derived from this preference, result availability, and current width.
+  preferredView?: AgentCellView
   lastRunStatus?: RunStatus
   lastRunError?: string
 }
@@ -156,6 +152,7 @@ export const createCell = (position: number, value = ""): NotebookCell => ({
   id: crypto.randomUUID(),
   position,
   value,
+  preferredView: "editor_result",
 })
 
 export const createDefaultNotebookViewState = (): NotebookViewState => ({
diff --git a/src/utils/ai/notebookSnapshot.test.ts b/src/utils/ai/notebookSnapshot.test.ts
index b6632ec06..dd9c1ed9e 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"
@@ -225,7 +226,7 @@ describe("buildSnapshot", () => {
       expect(gridSnap.cells[0]).toMatchObject({
         editor_height: "auto",
         result_height: "auto",
-        preferred_view: "editor",
+        preferred_view: "editor_result",
       })
     } else {
       throw new Error("expected ok snapshots")
@@ -235,15 +236,14 @@ describe("buildSnapshot", () => {
   it("reports the effective view and tier of a live responsive cell", async () => {
     const chart = sql("a", "SELECT 1", {
       mode: "draw",
-      isViewMaximized: false,
-      wideView: "editor_result",
-      compactView: "editor",
+      preferredView: "editor_result",
     })
     const id = await seedNotebook({ cells: [chart] })
     registerController(makeController(id, [chart], {}))
     const unpublish = publishLiveCellPresentation(id, "a", {
       compact: true,
       paneLayout: "editor",
+      expectingResult: false,
     })
 
     const snap = await buildSnapshot(id)
@@ -255,13 +255,37 @@ describe("buildSnapshot", () => {
     unpublish()
   })
 
+  it("uses the published pane while a result is awaiting hydration", async () => {
+    const pending = sql("a", "SELECT 1", {
+      lastRunStatus: "success",
+      preferredView: "editor_result",
+    })
+    const id = await seedNotebook({ cells: [pending] })
+    registerController(makeController(id, [pending], {}))
+    const unpublish = publishLiveCellPresentation(id, "a", {
+      compact: true,
+      paneLayout: "result",
+      expectingResult: true,
+    })
+
+    const snap = await buildSnapshot(id)
+    expect(snap?.status === "ok" ? snap.cells[0] : undefined).toMatchObject({
+      view: "result",
+      tier: "compact",
+    })
+    expect(serializeCell([pending], "a", id, false)).toMatchObject({
+      view: "result",
+      tier: "compact",
+    })
+    unpublish()
+  })
+
   it("omits tier and reports the stored preference for an inactive notebook", async () => {
     const id = await seedNotebook({
       cells: [
         sql("a", "SELECT 1", {
           mode: "draw",
-          wideView: "editor_result",
-          compactView: "result",
+          preferredView: "editor_result",
         }),
       ],
     })
@@ -354,7 +378,7 @@ describe("buildSnapshot", () => {
     const cell = sql("a", "SELECT 1", {
       mode: "draw",
       autoRefresh: "5s",
-      isViewMaximized: false,
+      preferredView: "editor_result",
       name: "Trades",
       chartConfig: {
         xColumn: "ts",
diff --git a/src/utils/ai/notebookSnapshot.ts b/src/utils/ai/notebookSnapshot.ts
index 58db65ec2..429516d2f 100644
--- a/src/utils/ai/notebookSnapshot.ts
+++ b/src/utils/ai/notebookSnapshot.ts
@@ -19,7 +19,9 @@ import type { WorkspaceInfo } from "./executeAIFlow"
 import { normalizeVariables } from "../../scenes/Editor/Notebook/declareUtils"
 import {
   agentCellPaneDimensions,
+  agentViewForPaneLayout,
   resolveAgentCellPresentation,
+  storedAgentCellView,
 } from "../../scenes/Editor/Notebook/notebookUtils"
 import { readLiveCellPresentation } from "../../scenes/Editor/Notebook/notebookPresentationStore"
 import { getCellRunStatus, type RunStatus } from "./runStatus"
@@ -163,6 +165,16 @@ const refreshFields = (
   }
 }
 
+const liveAgentCellPresentation = (cell: NotebookCell, bufferId: number) => {
+  const live = readLiveCellPresentation(bufferId, cell.id)
+  if (!live) return resolveAgentCellPresentation(cell)
+  return {
+    preferred_view: storedAgentCellView(cell),
+    view: agentViewForPaneLayout(live.paneLayout),
+    tier: live.compact ? ("compact" as const) : ("wide" as const),
+  }
+}
+
 const buildCell = (
   cell: NotebookCell,
   bufferId: number,
@@ -170,10 +182,7 @@ const buildCell = (
   layoutMode: "list" | "grid",
   refreshState: ReadonlyMap<string, CellRefreshView> | undefined,
 ): NotebookContextCell => {
-  const presentation = resolveAgentCellPresentation(
-    cell,
-    readLiveCellPresentation(bufferId, cell.id)?.compact,
-  )
+  const presentation = liveAgentCellPresentation(cell, bufferId)
   const out: NotebookContextCell = {
     id: cell.id,
     preview: preview(cell.value),
@@ -520,10 +529,7 @@ export const serializeCell = (
   const value = truncated ? cell.value.slice(0, CELL_VALUE_MAX) : cell.value
   const run = runStatusOf(cell)
   const dimensions = agentCellPaneDimensions(cell)
-  const presentation = resolveAgentCellPresentation(
-    cell,
-    readLiveCellPresentation(bufferId, cell.id)?.compact,
-  )
+  const presentation = liveAgentCellPresentation(cell, bufferId)
   const out: NotebookCellDetails = {
     id: cell.id,
     value,
diff --git a/src/utils/ai/prompts.ts b/src/utils/ai/prompts.ts
index 94dcc8dcc..3d721ac76 100644
--- a/src/utils/ai/prompts.ts
+++ b/src/utils/ai/prompts.ts
@@ -115,7 +115,7 @@ 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).
-- 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. view is editor, result, or editor_result. Wide cells support all three; compact cells support editor/result and project editor_result to result, restoring editor_result if they become wide again. preferred_view is always the stored intent. Mounted cells additionally report effective view and tier (wide/compact) as a pair; both are omitted when the cell is not rendered. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. Keep charts at result_height >= 240; use editor_height 86 for a polished markdown title (never use the 26px structural minimum for non-empty prose).
+- 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, preferred_view is the single stored, viewport-independent intent: editor, result, or editor_result. Effective view is derived from that preference, current result availability, and tier. Compact projects editor_result to result without rewriting preferred_view; widening restores editor_result. If a result is genuinely unavailable, effective view temporarily falls back to editor without rewriting preferred_view. Mounted SQL/draw cells report effective view and tier (wide/compact) as a pair; both are omitted when the cell is not rendered. Markdown has no mutable pane-view state: it reports the fixed preferred_view editor and does not expose effective view/tier. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. Keep charts at result_height >= 240; use editor_height 86 for a polished markdown title (never use the 26px structural minimum for non-empty prose).
 - 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 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 dimension fields are the documented exception: null preserves their current setting. For a single targeted edit, prefer update_cell / set_cell_chart_config / set_cell_dimensions instead.
diff --git a/src/utils/ai/shared.notebookTools.test.ts b/src/utils/ai/shared.notebookTools.test.ts
index 4e8338779..bda0b4c61 100644
--- a/src/utils/ai/shared.notebookTools.test.ts
+++ b/src/utils/ai/shared.notebookTools.test.ts
@@ -693,7 +693,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
         topHeight: 200,
         topResized: true,
         bottomHeight: 350,
-        isViewMaximized: true,
+        preferredView: "result",
       }),
     ])
 
@@ -717,7 +717,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       topResized: false,
       bottomHeight: 280,
       bottomResized: true,
-      isViewMaximized: true,
+      preferredView: "result",
     })
   })
 
@@ -726,6 +726,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
     const unpublish = publishLiveCellPresentation(1, "c", {
       compact: true,
       paneLayout: "result",
+      expectingResult: false,
     })
 
     const res = await dispatchTool(
@@ -747,7 +748,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       tier: "compact",
       fallback: "editor_result_unavailable_in_compact",
     })
-    expect(cellById(state, "c")?.wideView).toBe("editor_result")
+    expect(cellById(state, "c")?.preferredView).toBe("editor_result")
     unpublish()
   })
 
@@ -757,8 +758,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       [
         cell("c", "SELECT 1", {
           mode: "draw",
-          wideView: "editor_result",
-          compactView: "result",
+          preferredView: "editor_result",
         }),
       ],
       {
@@ -771,6 +771,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
     const unpublish = publishLiveCellPresentation(1, "c", {
       compact: false,
       paneLayout: "split",
+      expectingResult: false,
       gridContainerWidth: 1200,
     })
 
@@ -1185,7 +1186,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
                 },
               ],
             },
-            grid: { x: 0, y: 0, w: 6, h: 6 },
+            grid: { x: 0, y: 0, w: 6 },
           },
         ],
       },
@@ -1200,8 +1201,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       value: "SELECT 1",
       mode: "draw",
       autoRefresh: "5s",
-      isViewMaximized: true,
-      compactView: "result",
+      preferredView: "result",
       chartConfig: {
         xColumn: "ts",
         queries: [
diff --git a/src/utils/notebooks/notebookAIBridge.test.ts b/src/utils/notebooks/notebookAIBridge.test.ts
index e68b457f1..07979d801 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,
+      setCellPreferredView: () => 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 694092537..631c8be83 100644
--- a/src/utils/notebooks/notebookController/index.ts
+++ b/src/utils/notebooks/notebookController/index.ts
@@ -126,7 +126,7 @@ export {
   setCellLayoutTransition,
   setCellMaximizedTransition,
   setCellModeTransition,
-  setCellViewMaximizedTransition,
+  setCellPreferredViewTransition,
   setLayoutModeTransition,
   setNotebookAutoRefreshTransition,
   updateCellTransition,
diff --git a/src/utils/notebooks/notebookController/notebookController.ts b/src/utils/notebooks/notebookController/notebookController.ts
index 0a28cd194..7704e76df 100644
--- a/src/utils/notebooks/notebookController/notebookController.ts
+++ b/src/utils/notebooks/notebookController/notebookController.ts
@@ -125,11 +125,8 @@ export type ApplyNotebookStateCellRequest = {
   editorHeight?: AgentHeightValue
   resultHeight?: AgentHeightValue
   view?: AgentCellView | null
-  // Legacy cached-agent inputs. Not advertised by the current schema.
-  editorVisible?: boolean | null
-  isViewMaximized?: boolean | 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 39d5ae0f7..48d14be26 100644
--- a/src/utils/notebooks/notebookController/notebookTransitions.test.ts
+++ b/src/utils/notebooks/notebookController/notebookTransitions.test.ts
@@ -45,7 +45,7 @@ describe("setCellDimensionsTransition", () => {
       mode: "draw",
       topHeight: 72,
       bottomHeight: 350,
-      isViewMaximized: true,
+      preferredView: "result",
     })
     const parts = partsOf([chart], {
       settings: {
@@ -62,9 +62,7 @@ describe("setCellDimensionsTransition", () => {
     expect(out.parts.cells[0]).toMatchObject({
       topHeight: 72,
       bottomHeight: 350,
-      isViewMaximized: false,
-      wideView: "editor_result",
-      compactView: "result",
+      preferredView: "editor_result",
     })
     expect(out.parts.settings.layout?.[0].h).toBe(17)
     expect(out.result).toEqual({
@@ -81,7 +79,7 @@ describe("setCellDimensionsTransition", () => {
       topResized: true,
       bottomHeight: 350,
       bottomResized: false,
-      isViewMaximized: true,
+      preferredView: "result",
     })
 
     const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
@@ -95,7 +93,7 @@ describe("setCellDimensionsTransition", () => {
       topResized: false,
       bottomHeight: 280,
       bottomResized: true,
-      isViewMaximized: true,
+      preferredView: "result",
     })
     expect(out.result).toEqual({ preferred_view: "result" })
   })
@@ -103,8 +101,7 @@ describe("setCellDimensionsTransition", () => {
   it("stores one editor preference and reports its compact projection", () => {
     const chart = cell("a", "SELECT 1", {
       mode: "draw",
-      isViewMaximized: true,
-      compactView: "result",
+      preferredView: "result",
     })
 
     const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
@@ -113,9 +110,7 @@ describe("setCellDimensionsTransition", () => {
     })
 
     expect(out.parts.cells[0]).toMatchObject({
-      isViewMaximized: false,
-      wideView: "editor",
-      compactView: "editor",
+      preferredView: "editor",
     })
     expect(out.result).toEqual({
       preferred_view: "editor",
@@ -132,8 +127,7 @@ describe("setCellDimensionsTransition", () => {
     })
 
     expect(out.parts.cells[0]).toMatchObject({
-      wideView: "editor_result",
-      compactView: "result",
+      preferredView: "editor_result",
     })
     expect(out.result).toEqual({
       preferred_view: "editor_result",
@@ -151,8 +145,7 @@ describe("setCellDimensionsTransition", () => {
     })
 
     expect(out.parts.cells[0]).toMatchObject({
-      wideView: "editor",
-      compactView: "editor",
+      preferredView: "editor",
     })
     expect(out.result).toEqual({
       preferred_view: "editor",
@@ -169,13 +162,58 @@ describe("setCellDimensionsTransition", () => {
       }),
     ).toThrow(/at least 240px/)
   })
+
+  it("uses the mounted missing-result state for presentation and height", () => {
+    const pending = cell("a", "SELECT 1", {
+      lastRunStatus: "success",
+      preferredView: "editor_result",
+    })
+    const out = setCellDimensionsTransition(
+      partsOf([pending], {
+        settings: {
+          layoutMode: "grid",
+          layout: [{ i: "a", x: 0, y: 0, w: 12, h: 19 }],
+        },
+      }),
+      BUFFER_ID,
+      "a",
+      { compact: false, expectingResult: false },
+    )
+
+    expect(out.result).toEqual({
+      preferred_view: "editor_result",
+      view: "editor",
+      tier: "wide",
+    })
+    expect(out.parts.settings.layout?.[0].h).toBe(5)
+  })
+
+  it("persists a result preference while a missing result falls back to editor", () => {
+    const pending = cell("a", "SELECT 1", {
+      lastRunStatus: "success",
+      preferredView: "editor_result",
+    })
+    const out = setCellDimensionsTransition(
+      partsOf([pending]),
+      BUFFER_ID,
+      "a",
+      { view: "result", compact: false, expectingResult: false },
+    )
+
+    expect(out.parts.cells[0].preferredView).toBe("result")
+    expect(out.result).toEqual({
+      preferred_view: "result",
+      view: "editor",
+      tier: "wide",
+      fallback: "requested_view_unavailable",
+    })
+  })
 })
 
 describe("setCellLayoutTransition", () => {
   const chart = cell("a", "SELECT 1", {
     mode: "draw",
-    wideView: "editor_result",
-    compactView: "result",
+    preferredView: "editor_result",
   })
 
   it("returns the projected live presentation after a width change", () => {
@@ -212,6 +250,17 @@ describe("setCellLayoutTransition", () => {
       preferred_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", () => {
diff --git a/src/utils/notebooks/notebookController/notebookTransitions.ts b/src/utils/notebooks/notebookController/notebookTransitions.ts
index 508e22f27..06adee580 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,
@@ -15,7 +16,7 @@ import {
   buildAppliedNotebookState,
   carriedRunError,
   carriedRunStatus,
-  cellHeightPatchForRows,
+  cellGridBoundsError,
   cellModeChangePatch,
   clearCellAutoRefresh,
   computeAgentCellGridH,
@@ -29,8 +30,6 @@ import {
   nextGridSeedPosition,
   reconcileCellResultForValue,
   resolveAgentCellPresentation,
-  NOTEBOOK_GRID_MARGIN_Y,
-  NOTEBOOK_GRID_ROW_HEIGHT,
   removeCell,
   swapCellDown,
   swapCellUp,
@@ -288,8 +287,8 @@ export const setCellLayoutTransition = (
   bufferId: number,
   cellId: string,
   pos: Omit<CellGridPosition, "h"> & {
-    h?: number
     liveCompact?: boolean
+    liveExpectingResult?: boolean
     gridContainerWidth?: number
   },
 ): NotebookTransitionResult<
@@ -298,28 +297,18 @@ export const setCellLayoutTransition = (
   }
 > => {
   const cell = requireCellIn(parts.cells, cellId, bufferId)
-  // Cached clients may still send h. Current clients control pane dimensions
-  // semantically and h is derived from them.
-  const heightPatch =
-    pos.h === undefined
-      ? {}
-      : cellHeightPatchForRows(
-          cell,
-          pos.h,
-          NOTEBOOK_GRID_ROW_HEIGHT,
-          NOTEBOOK_GRID_MARGIN_Y,
-          isExpectingResult(cell, "unrequested"),
-        )
-  const nextCell = { ...cell, ...heightPatch }
+  const gridError = cellGridBoundsError(pos)
+  if (gridError) throw new NotebookToolError("validation", gridError)
   const compact =
     parts.settings.layoutMode === "grid"
       ? pos.gridContainerWidth !== undefined
         ? gridCellToolbarTier(pos.gridContainerWidth, pos.w) === "compact"
         : undefined
       : pos.liveCompact
-  const expectingResult = isExpectingResult(nextCell, "unrequested")
+  const expectingResult =
+    pos.liveExpectingResult ?? isExpectingResult(cell, "unrequested")
   const paneLayout = resolveCellPaneLayout(
-    nextCell,
+    cell,
     expectingResult,
     compact === true,
   )
@@ -327,15 +316,11 @@ export const setCellLayoutTransition = (
     x: pos.x,
     y: pos.y,
     w: pos.w,
-    h: computeAgentCellGridH(nextCell, paneLayout),
+    h: computeAgentCellGridH(cell, paneLayout),
   }
   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, layoutPos),
@@ -343,7 +328,7 @@ export const setCellLayoutTransition = (
     },
     result: {
       grid: { x: pos.x, y: pos.y, w: pos.w },
-      ...resolveAgentCellPresentation(nextCell, compact, expectingResult),
+      ...resolveAgentCellPresentation(cell, compact, expectingResult),
     },
     touchedCellId: cellId,
   }
@@ -365,7 +350,6 @@ export const setCellDimensionsTransition = (
   if (
     cell.type === "markdown" &&
     (dimensions.resultHeight != null ||
-      dimensions.editorVisible != null ||
       (dimensions.view != null && dimensions.view !== "editor"))
   ) {
     throw new NotebookToolError(
@@ -396,9 +380,11 @@ export const setCellDimensionsTransition = (
 
   const patch = agentCellDimensionsPatch(cell, dimensions)
   const nextCell = { ...cell, ...patch }
+  const expectingResult =
+    dimensions.expectingResult ?? isExpectingResult(nextCell, "unrequested")
   const paneLayout = resolveCellPaneLayout(
     nextCell,
-    isExpectingResult(nextCell, "unrequested"),
+    expectingResult,
     dimensions.compact === true,
   )
   const layout = parts.settings.layout?.map((item) =>
@@ -409,7 +395,7 @@ export const setCellDimensionsTransition = (
   const presentation = resolveAgentCellPresentation(
     nextCell,
     dimensions.compact,
-    isExpectingResult(nextCell, "unrequested"),
+    expectingResult,
   )
   const fallback =
     presentation.view !== undefined &&
@@ -482,19 +468,24 @@ export const setCellChartConfigTransition = (
   }
 }
 
-export const setCellViewMaximizedTransition = (
+export const setCellPreferredViewTransition = (
   parts: ViewParts,
   bufferId: number,
   cellId: string,
-  value: boolean,
+  preferredView: 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 preference.",
+    )
+  }
   return {
     parts: {
       ...parts,
       cells: patchCellIn(parts.cells, cellId, {
-        isViewMaximized: value,
-        wideView: value ? "result" : "editor_result",
+        preferredView,
       }),
     },
     result: undefined,
diff --git a/src/utils/notebooks/notebookDexieController.test.ts b/src/utils/notebooks/notebookDexieController.test.ts
index 9f879628f..036a82b57 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", { preferredView: "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,
+      preferredView: "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,
+          preferredView: "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,
+      preferredView: "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..e989ab140
--- /dev/null
+++ b/src/utils/notebooks/notebookDexieView.test.ts
@@ -0,0 +1,48 @@
+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, preferredView) => {
+      const cell = migratePersistedNotebookView(legacyView(legacy)).cells[0]
+      expect(cell.preferredView).toBe(preferredView)
+      expect(cell).not.toHaveProperty("isViewMaximized")
+    },
+  )
+
+  it("removes pane preference state from markdown", () => {
+    const view = {
+      cells: [
+        {
+          id: "m",
+          position: 0,
+          value: "# Title",
+          type: "markdown",
+          preferredView: "result",
+          isViewMaximized: true,
+        },
+      ],
+    } as unknown as NotebookViewState
+    const cell = migratePersistedNotebookView(view).cells[0]
+    expect(cell).not.toHaveProperty("preferredView")
+    expect(cell).not.toHaveProperty("isViewMaximized")
+  })
+})
diff --git a/src/utils/notebooks/notebookDexieView.ts b/src/utils/notebooks/notebookDexieView.ts
index c6894e21c..a5b266844 100644
--- a/src/utils/notebooks/notebookDexieView.ts
+++ b/src/utils/notebooks/notebookDexieView.ts
@@ -26,8 +26,41 @@ type NotebookBufferMeta =
   | { kind: "deleted" }
   | { kind: "not_a_notebook" }
 
-export const migratePersistedNotebookView = (view: NotebookViewState) =>
-  dropLegacyChartConfigs(migrateLegacyCellNames(view))
+const isAgentCellView = (
+  value: unknown,
+): value is NotebookCell["preferredView"] =>
+  value === "editor" || value === "result" || value === "editor_result"
+
+// Main persisted `isViewMaximized`; the wide/compact fields never shipped.
+// Materialize one viewport-independent preference and remove every legacy
+// presentation key from the runtime view.
+const migrateCellPreferredView = (cell: NotebookCell): NotebookCell => {
+  const raw = cell as NotebookCell & Record<string, unknown>
+  if (cell.type === "markdown") {
+    const next = { ...raw }
+    delete next.preferredView
+    delete next.isViewMaximized
+    delete next.wideView
+    delete next.compactView
+    return next as NotebookCell
+  }
+  const preferredView = isAgentCellView(raw.preferredView)
+    ? raw.preferredView
+    : raw.isViewMaximized === true
+      ? "result"
+      : "editor_result"
+  const next = { ...raw, preferredView } as NotebookCell &
+    Record<string, unknown>
+  delete next.isViewMaximized
+  delete next.wideView
+  delete next.compactView
+  return next as NotebookCell
+}
+
+export const migratePersistedNotebookView = (view: NotebookViewState) => {
+  const migrated = dropLegacyChartConfigs(migrateLegacyCellNames(view))
+  return { ...migrated, cells: migrated.cells.map(migrateCellPreferredView) }
+}
 
 export const readNotebookBufferMeta = async (
   bufferId: number,
diff --git a/src/utils/tools/applyNotebookState.ts b/src/utils/tools/applyNotebookState.ts
index da42f39d3..eeef6dba5 100644
--- a/src/utils/tools/applyNotebookState.ts
+++ b/src/utils/tools/applyNotebookState.ts
@@ -224,15 +224,12 @@ export const dispatchApplyNotebookState = async (
         editor_height?: number | "auto" | null
         result_height?: number | "auto" | null
         view?: AgentCellView | null
-        // Legacy cached-agent inputs.
-        editor_visible?: boolean | null
-        is_view_maximized?: boolean | 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)
@@ -402,13 +399,6 @@ export const dispatchApplyNotebookState = async (
       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.editor_visible !== undefined) cell.editorVisible = c.editor_visible
-      if (
-        c.editor_visible == null &&
-        c.is_view_maximized !== undefined &&
-        c.is_view_maximized !== null
-      )
-        cell.isViewMaximized = c.is_view_maximized
       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 5e5ba014d..7b65a1a51 100644
--- a/src/utils/tools/dispatch.ts
+++ b/src/utils/tools/dispatch.ts
@@ -76,7 +76,6 @@ import {
   setCellLayoutTransition,
   setCellMaximizedTransition,
   setCellModeTransition,
-  setCellViewMaximizedTransition,
   setLayoutModeTransition,
   setNotebookAutoRefreshTransition,
   updateCellTransition,
@@ -819,29 +818,32 @@ 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 })
-        const livePresentation = readLiveCellPresentation(buffer_id, cell_id)
         return routeNotebookTool(() =>
           runTransition(
             buffer_id,
-            (parts) =>
-              setCellLayoutTransition(parts, buffer_id, cell_id, {
+            (parts) => {
+              const livePresentation = readLiveCellPresentation(
+                buffer_id,
+                cell_id,
+              )
+              return setCellLayoutTransition(parts, buffer_id, cell_id, {
                 x,
                 y,
                 w,
-                h,
                 liveCompact: livePresentation?.compact,
+                liveExpectingResult: livePresentation?.expectingResult,
                 gridContainerWidth: livePresentation?.gridContainerWidth,
-              }),
+              })
+            },
             signal,
           ),
         )
@@ -859,13 +861,19 @@ export const dispatchTool = async (
         return routeNotebookTool(() =>
           runTransition(
             buffer_id,
-            (parts) =>
-              setCellDimensionsTransition(parts, buffer_id, cell_id, {
+            (parts) => {
+              const livePresentation = readLiveCellPresentation(
+                buffer_id,
+                cell_id,
+              )
+              return setCellDimensionsTransition(parts, buffer_id, cell_id, {
                 editorHeight: editor_height,
                 resultHeight: result_height,
                 view,
-                compact: readLiveCellPresentation(buffer_id, cell_id)?.compact,
-              }),
+                compact: livePresentation?.compact,
+                expectingResult: livePresentation?.expectingResult,
+              })
+            },
             signal,
           ),
         )
@@ -1072,23 +1080,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,

From a94adff90db73feccf5775dc49ff6cfa33da53d6 Mon Sep 17 00:00:00 2001
From: emrberk <emreberk5699@gmail.com>
Date: Thu, 3 Sep 2026 00:42:30 +0300
Subject: [PATCH 3/4] refactor: derive cell panes synchronously and fix the
 markdown pane contract

- Cells resolve their pane layout during render. The grid expansion delay
  is gone, so tool responses and the rendered pane always agree.
- Grid transitions run for drag, drop, and width changes. They are
  suppressed only while the notebook container is being resized. Item
  height never animates, so a pane switch and its box land together.
- The measured grid container width is published once per notebook and
  read by set_cell_layout, instead of travelling through every cell.
- apply_notebook_state rejects changing an existing cell's kind.
- Markdown cells report preferred_view, view, and result_height as null.
  view and result_height inputs are ignored for markdown instead of
  rejected. auto_refresh is dropped for markdown.
- Tool descriptions and the notebook prompt describe the new contract.
- e2e/questdb submodule bumped to current master.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015sKRGPKxxoNvBSKEPrEP4K
---
 e2e/questdb                                   |   2 +-
 src/consts/shared-definitions.json            |  16 +-
 src/scenes/Editor/Notebook/cells/Cell.tsx     |  77 +--------
 src/scenes/Editor/Notebook/index.tsx          |  68 +++++---
 .../Notebook/notebookPresentationStore.ts     |  23 ++-
 .../Editor/Notebook/notebookUtils.test.ts     | 157 +++++++++---------
 src/scenes/Editor/Notebook/notebookUtils.ts   |  93 +++++------
 src/utils/ai/notebookSnapshot.test.ts         |  31 ++++
 src/utils/ai/notebookSnapshot.ts              |  25 ++-
 src/utils/ai/prompts.ts                       |   4 +-
 src/utils/ai/shared.notebookTools.test.ts     |   4 +-
 .../notebookTransitions.test.ts               |  25 +++
 .../notebookController/notebookTransitions.ts |  14 +-
 src/utils/tools/dispatch.ts                   |   7 +-
 14 files changed, 281 insertions(+), 265 deletions(-)

diff --git a/e2e/questdb b/e2e/questdb
index 12a33d651..9848be5f3 160000
--- a/e2e/questdb
+++ b/e2e/questdb
@@ -1 +1 @@
-Subproject commit 12a33d651e51e2682e7a448c8db5168fc72dfad3
+Subproject commit 9848be5f3ad91796cabe5f098695919b08e73769
diff --git a/src/consts/shared-definitions.json b/src/consts/shared-definitions.json
index d48a67645..a57a3f3a2 100644
--- a/src/consts/shared-definitions.json
+++ b/src/consts/shared-definitions.json
@@ -241,7 +241,7 @@
     "surfaces": ["ai", "mcp"],
     "mutatesNotebook": false,
     "createsNotebook": false,
-    "description": "Get full details of a cell (value, kind via `type`, editor_height/result_height, preferred/effective view, chart config, last-run status + trimmed error). Height values are fixed CSS pixels or \"auto\". `preferred_view` is the single stored, viewport-independent intent for SQL/draw cells; resizing or result hydration never rewrites it. Markdown reports the fixed value `editor` and has no mutable pane-view state. A rendered SQL/draw cell additionally returns effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted when that cell is not rendered. `view` is derived from `preferred_view`, current result availability, and tier. Markdown cells do not expose effective `view` or `tier`. Compact cannot display editor_result, so it may report `preferred_view: editor_result` with `view: result`. A cell whose result is unavailable temporarily reports `view: editor` without changing `preferred_view`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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.",
+    "description": "Get full details of a cell (value, kind via `type`, editor_height/result_height, preferred/effective view, chart config, last-run status + trimmed error). Height values are fixed CSS pixels or \"auto\". `preferred_view` is the single stored, viewport-independent intent for SQL/draw cells; resizing or result hydration never rewrites it. Markdown has no pane-view state: it reports `preferred_view`, `view`, and `result_height` as null. A rendered SQL/draw cell additionally returns effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted when that cell is not rendered. `view` is derived from `preferred_view`, current result availability, and tier. Markdown cells never report `tier`. Compact cannot display editor_result, so it may report `preferred_view: editor_result` with `view: result`. A cell whose result is unavailable temporarily reports `view: editor` without changing `preferred_view`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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, semantic pane dimensions, kind via `type`, last-run statuses). Cell `grid` contains x/y/w only; height is represented by editor_height/result_height. `preferred_view` is the single stored, viewport-independent intent for SQL/draw cells; resizing or result hydration never rewrites it. Markdown reports the fixed value `editor` and has no mutable pane-view state. A rendered SQL/draw cell additionally returns effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted when that cell is not rendered. `view` is derived from `preferred_view`, current result availability, and tier. Markdown cells do not expose effective `view` or `tier`. Compact cannot display editor_result, so it may report `preferred_view: editor_result` with `view: result`. An unavailable result temporarily produces `view: editor` without changing `preferred_view`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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.",
+    "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 represented by editor_height/result_height. `preferred_view` is the single stored, viewport-independent intent for SQL/draw cells; resizing or result hydration never rewrites it. Markdown has no pane-view state: it reports `preferred_view`, `view`, and `result_height` as null. A rendered SQL/draw cell additionally returns effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted when that cell is not rendered. `view` is derived from `preferred_view`, current result availability, and tier. Markdown cells never report `tier`. Compact cannot display editor_result, so it may report `preferred_view: editor_result` with `view: result`. An unavailable result temporarily produces `view: editor` without changing `preferred_view`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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 are integers in the react-grid-layout grid; width is limited to 12 columns. Cell height is derived from its semantic pane dimensions. Changing w may change the responsive tier and effective view of a SQL/draw cell. The response includes the applied grid position and `preferred_view`; when a SQL/draw cell is rendered it also includes the resulting effective `view` and `tier`. Markdown reports the fixed `preferred_view: editor` and does not expose effective `view` or `tier`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing can later change tier even if grid.w stays fixed. Use set_cell_dimensions to resize a cell or change its preferred view.",
+    "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. Changing w may change the responsive tier and effective view of a SQL/draw cell. The response includes the applied grid position and `preferred_view`; when a SQL/draw cell is rendered it also includes the resulting effective `view` and `tier`. Markdown reports `preferred_view` and `view` as null and never reports `tier`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing can later change tier even if grid.w stays fixed. Use set_cell_dimensions to resize a cell or change its preferred view.",
     "inputSchema": {
       "type": "object",
       "additionalProperties": false,
@@ -505,7 +505,7 @@
     "surfaces": ["ai", "mcp"],
     "mutatesNotebook": true,
     "createsNotebook": false,
-    "description": "Resize a cell using semantic pane dimensions in CSS pixels and choose its single viewport-independent preferred 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. Wide cells display the preference directly. Compact cells project editor_result to result without rewriting it. Cells without an available result temporarily display editor without rewriting the preference. The response always reports `preferred_view`; when a SQL/draw cell is rendered it also reports effective `view` and live-only `tier` (`wide` or `compact`) as a pair, and may report a `fallback`. Markdown has no mutable pane-view state: it reports the fixed `preferred_view: editor` and does not expose effective `view` or `tier`; editor_height sizes its rendered content, result_height must be null, and view must be null or editor. Never use the structural 26px minimum for non-empty prose—use at least 56px, or 86px for a polished title. Chart result_height must be at least 240px; table results at least 100px.",
+    "description": "Resize a cell using semantic pane dimensions in CSS pixels and choose its single viewport-independent preferred 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. Wide cells display the preference directly. Compact cells project editor_result to result without rewriting it. Cells without an available result temporarily display editor without rewriting the preference. The response always reports `preferred_view`; when a SQL/draw cell is rendered it also reports effective `view` and live-only `tier` (`wide` or `compact`) as a pair, and may report a `fallback`. Markdown has no pane-view state: it reports `preferred_view`, `view`, and `result_height` as null and never reports `tier`; editor_height sizes its rendered content, while result_height and view are ignored — keep them null. Never use the structural 26px minimum for non-empty prose—use at least 56px, or 86px for a polished title. Chart result_height must be at least 240px; table results at least 100px.",
     "inputSchema": {
       "type": "object",
       "additionalProperties": false,
@@ -864,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"],
@@ -897,7 +897,7 @@
                   { "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 240px; tables 100px. Must be null for markdown."
+                "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 240px; tables 100px. Ignored for markdown; keep it null."
               },
               "view": {
                 "anyOf": [
@@ -907,7 +907,7 @@
                   },
                   { "type": "null" }
                 ],
-                "description": "Single stored, viewport-independent pane preference. 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. Wide displays the preference directly. Compact projects editor_result to result without rewriting it. An unavailable result temporarily displays editor without rewriting the preference. Markdown requires null or editor."
+                "description": "Single stored, viewport-independent pane preference. 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. Wide displays the preference directly. Compact projects editor_result to result without rewriting it. An unavailable result temporarily displays editor without rewriting the preference. Ignored for markdown; keep it null."
               },
               "chart_config": {
                 "type": ["object", "null"],
@@ -1110,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 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 the single stored, viewport-independent `preferred_view`; resizing and result hydration never rewrite it. Markdown reports the fixed value `editor` and has no mutable pane-view state. Rendered SQL/draw cells additionally report effective `view` and live-only `tier` (`wide` or `compact`) as a pair; `view` is derived from preference, result availability, and tier. Both are omitted for inactive or unmounted cells. Markdown cells do not expose effective `view` or `tier`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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 the single stored, viewport-independent `preferred_view`; resizing and result hydration never rewrite it. Markdown has no pane-view state: it reports `preferred_view`, `view`, and `result_height` as null. Rendered SQL/draw cells additionally report effective `view` and live-only `tier` (`wide` or `compact`) as a pair; `view` is derived from preference, result availability, and tier. Both are omitted for inactive or unmounted cells. Markdown cells never report `tier`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. Pass include_user_events=true to also receive the digest of edits the user made since your last fetch.",
     "inputSchema": {
       "type": "object",
       "properties": {
diff --git a/src/scenes/Editor/Notebook/cells/Cell.tsx b/src/scenes/Editor/Notebook/cells/Cell.tsx
index 3341b941a..d79855fce 100644
--- a/src/scenes/Editor/Notebook/cells/Cell.tsx
+++ b/src/scenes/Editor/Notebook/cells/Cell.tsx
@@ -30,7 +30,6 @@ import { toast } from "../../../../components/Toast"
 import {
   CELL_EDITOR_LINE_HEIGHT,
   CELL_EDITOR_PADDING,
-  computeCellHeights,
   isDoubleView,
   isExpectingResult,
   minBottomHeightFor,
@@ -113,8 +112,6 @@ const HiddenCellStatus = styled.span`
   white-space: nowrap;
 `
 
-const GRID_PANE_EXPANSION_FALLBACK_MS = 250
-
 type Props = {
   cell: NotebookCell
   index: number
@@ -125,7 +122,6 @@ type Props = {
   isMaximized: boolean
   isRunning: boolean
   toolbarTierOverride?: CellToolbarTier
-  gridContainerWidth?: number
 }
 
 const CellInner: React.FC<Props> = ({
@@ -138,7 +134,6 @@ const CellInner: React.FC<Props> = ({
   isMaximized,
   isRunning,
   toolbarTierOverride,
-  gridContainerWidth,
 }) => {
   const { setCellChartConfig, clearCellResult, updateCell, setFocusedCell } =
     useNotebookActions()
@@ -186,67 +181,7 @@ const CellInner: React.FC<Props> = ({
   const expectingResult = isExpectingResult(cell, resultStatus)
   const doubleView = isDoubleView(cell) || expectingResult
   const isCompactTier = toolbarTier === "compact"
-  const targetPaneLayout = resolveCellPaneLayout(
-    cell,
-    expectingResult,
-    isCompactTier,
-  )
-  const [paneLayout, setPaneLayout] = React.useState(targetPaneLayout)
-  const resolvedPaneHeights = computeCellHeights(cell, { expectingResult })
-
-  React.useLayoutEffect(() => {
-    if (paneLayout === targetPaneLayout) return undefined
-
-    // Switch immediately before a shrink. Before an expansion, keep the old
-    // pane mounted until RGL has made room for the incoming pane. This applies
-    // to compact editor/result swaps as well as compact -> split.
-    const paneHeight = (layout: typeof paneLayout) =>
-      layout === "editor"
-        ? resolvedPaneHeights.topHeight
-        : layout === "result"
-          ? resolvedPaneHeights.bottomHeight
-          : resolvedPaneHeights.topHeight + resolvedPaneHeights.bottomHeight
-    const expandingPresentation =
-      layoutMode === "grid" &&
-      !isMaximized &&
-      paneHeight(targetPaneLayout) > paneHeight(paneLayout)
-    if (!expandingPresentation) {
-      setPaneLayout(targetPaneLayout)
-      return undefined
-    }
-
-    const gridItem =
-      wrapperRef.current?.closest<HTMLElement>(".react-grid-item")
-    if (!gridItem) {
-      setPaneLayout(targetPaneLayout)
-      return undefined
-    }
-
-    let settled = false
-    const finish = () => {
-      if (settled) return
-      settled = true
-      setPaneLayout(targetPaneLayout)
-    }
-    const onTransitionEnd = (event: TransitionEvent) => {
-      if (event.target === gridItem && event.propertyName === "height") finish()
-    }
-    gridItem.addEventListener("transitionend", onTransitionEnd)
-    const fallback = window.setTimeout(finish, GRID_PANE_EXPANSION_FALLBACK_MS)
-    return () => {
-      settled = true
-      window.clearTimeout(fallback)
-      gridItem.removeEventListener("transitionend", onTransitionEnd)
-    }
-  }, [
-    isMaximized,
-    layoutMode,
-    paneLayout,
-    resolvedPaneHeights.bottomHeight,
-    resolvedPaneHeights.topHeight,
-    targetPaneLayout,
-    wrapperRef,
-  ])
+  const paneLayout = resolveCellPaneLayout(cell, expectingResult, isCompactTier)
 
   useEffect(
     () =>
@@ -254,16 +189,8 @@ const CellInner: React.FC<Props> = ({
         compact: isCompactTier,
         paneLayout,
         expectingResult,
-        ...(gridContainerWidth !== undefined ? { gridContainerWidth } : {}),
       }),
-    [
-      bufferIdForEvents,
-      cell.id,
-      expectingResult,
-      gridContainerWidth,
-      isCompactTier,
-      paneLayout,
-    ],
+    [bufferIdForEvents, cell.id, expectingResult, isCompactTier, paneLayout],
   )
 
   const resultOnly = paneLayout === "result"
diff --git a/src/scenes/Editor/Notebook/index.tsx b/src/scenes/Editor/Notebook/index.tsx
index 850c640a9..1ce47440f 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,
@@ -26,6 +33,7 @@ import {
   useNotebookBufferId,
   useNotebookState,
 } from "./NotebookProvider"
+import { publishGridContainerWidth } from "./notebookPresentationStore"
 import { Cell } from "./cells/Cell"
 import { MarkdownCell } from "./cells/MarkdownCell"
 import type { AutoRefresh, NotebookCell } from "../../../store/notebook"
@@ -136,7 +144,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;
@@ -156,13 +164,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;
       }
@@ -208,6 +221,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
 
@@ -335,7 +365,6 @@ type CellViewProps = {
   isMaximized: boolean
   isRunning: boolean
   toolbarTierOverride?: CellToolbarTier
-  gridContainerWidth?: number
 }
 
 const CellView: React.FC<CellViewProps> = ({
@@ -401,6 +430,7 @@ const GridLayout: React.FC = () => {
   const resultStatusVersion = useResultStatusVersion()
   const { setFocusedCell, updateSettings, updateCell } = useNotebookActions()
   const { activeBuffer } = useEditor()
+  const bufferId = useNotebookBufferId()
   // measureBeforeMount: don't render the grid until the container width is
   // measured, so cells first paint at their real width instead of animating
   // from the guessed initialWidth (react-grid-layout transitions the change).
@@ -409,27 +439,16 @@ const GridLayout: React.FC = () => {
     containerRef,
     mounted: gridMeasured,
   } = useContainerWidth({ measureBeforeMount: true })
+  const suppressTransitions = useContainerResizeInFlight(containerWidth)
+  useEffect(
+    () => publishGridContainerWidth(bufferId, containerWidth),
+    [bufferId, 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
@@ -648,7 +667,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]")
@@ -700,7 +719,6 @@ const GridLayout: React.FC = () => {
                 isMaximized={maximizedCellId === cell.id}
                 isRunning={runningCellIds.has(cell.id)}
                 toolbarTierOverride={toolbarTierByCellId.get(cell.id)}
-                gridContainerWidth={containerWidth}
               />
             </GridCellWrapper>
           ))}
diff --git a/src/scenes/Editor/Notebook/notebookPresentationStore.ts b/src/scenes/Editor/Notebook/notebookPresentationStore.ts
index 5d8adfabd..580f9cb23 100644
--- a/src/scenes/Editor/Notebook/notebookPresentationStore.ts
+++ b/src/scenes/Editor/Notebook/notebookPresentationStore.ts
@@ -7,9 +7,6 @@ export type LiveCellPresentation = {
   // state alone cannot distinguish a result that is still loading/released
   // from one whose snapshot is known to be missing.
   expectingResult: boolean
-  // Present for grid cells. Tool mutations use the same measured container
-  // width as the renderer to resolve the tier produced by a new grid.w.
-  gridContainerWidth?: number
 }
 
 const presentations = new Map<
@@ -46,6 +43,26 @@ export const readLiveCellPresentation = (
 ): LiveCellPresentation | undefined =>
   presentations.get(bufferId)?.get(cellId)?.value
 
+const gridContainerWidths = new Map<number, number>()
+
+// Tool mutations resolve the tier a new grid.w produces from the same
+// measured container width as the renderer, published once per notebook.
+export const publishGridContainerWidth = (
+  bufferId: number,
+  width: number,
+): (() => void) => {
+  gridContainerWidths.set(bufferId, width)
+  return () => {
+    if (gridContainerWidths.get(bufferId) === width) {
+      gridContainerWidths.delete(bufferId)
+    }
+  }
+}
+
+export const readGridContainerWidth = (bufferId: number): number | undefined =>
+  gridContainerWidths.get(bufferId)
+
 export const __resetNotebookPresentationStoreForTests = (): void => {
   presentations.clear()
+  gridContainerWidths.clear()
 }
diff --git a/src/scenes/Editor/Notebook/notebookUtils.test.ts b/src/scenes/Editor/Notebook/notebookUtils.test.ts
index e7f9a60ae..c0a347c3a 100644
--- a/src/scenes/Editor/Notebook/notebookUtils.test.ts
+++ b/src/scenes/Editor/Notebook/notebookUtils.test.ts
@@ -868,17 +868,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].preferredView).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", () => {
@@ -1044,60 +1098,6 @@ 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" },
-    ]
-    expect(() =>
-      buildAppliedCells(prev, {
-        cells: [{ id: "a", preserveValue: true, type: "sql" }],
-      }),
-    ).toThrow(/line limit/)
-  })
-
-  it("validates dimensions against the target type when markdown becomes sql", () => {
-    const prev: NotebookCell[] = [
-      { id: "a", position: 0, value: "SELECT 1", type: "markdown" },
-    ]
-    expect(() =>
-      buildAppliedCells(prev, {
-        cells: [
-          {
-            id: "a",
-            preserveValue: true,
-            type: "sql",
-            editorHeight: 30,
-            view: "result",
-          },
-        ],
-      }),
-    ).toThrow(/editor_height below its minimum/)
-  })
-
-  it("applies a requested view when markdown becomes sql", () => {
-    const prev: NotebookCell[] = [
-      { id: "a", position: 0, value: "SELECT 1", type: "markdown" },
-    ]
-    const { nextCells } = buildAppliedCells(prev, {
-      cells: [
-        {
-          id: "a",
-          preserveValue: true,
-          type: "sql",
-          editorHeight: 72,
-          view: "result",
-        },
-      ],
-    })
-    expect(nextCells[0]).toMatchObject({
-      topHeight: 72,
-      topResized: true,
-      preferredView: "result",
-    })
-    expect(nextCells[0].type).toBeUndefined()
-  })
-
   it("rejects grid placement that extends beyond the notebook columns", () => {
     expect(() =>
       buildAppliedCells([], {
@@ -2009,6 +2009,25 @@ describe("resolveAgentCellPresentation", () => {
     ...over,
   })
 
+  it("reports null pane views for a markdown cell in every tier", () => {
+    // Given a markdown cell
+    const markdown = chart({ mode: undefined, type: "markdown" })
+    // When its presentation resolves for an unmounted, wide, or compact cell
+    // Then preferred_view and view are null and tier is never reported
+    expect(resolveAgentCellPresentation(markdown)).toEqual({
+      preferred_view: null,
+      view: null,
+    })
+    expect(resolveAgentCellPresentation(markdown, false)).toEqual({
+      preferred_view: null,
+      view: null,
+    })
+    expect(resolveAgentCellPresentation(markdown, true)).toEqual({
+      preferred_view: null,
+      view: null,
+    })
+  })
+
   it("returns the effective live view with its tier", () => {
     expect(
       resolveAgentCellPresentation(chart({ preferredView: "editor" }), false),
@@ -2590,20 +2609,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", () => {
diff --git a/src/scenes/Editor/Notebook/notebookUtils.ts b/src/scenes/Editor/Notebook/notebookUtils.ts
index eaa68e3ac..cfcb76c80 100644
--- a/src/scenes/Editor/Notebook/notebookUtils.ts
+++ b/src/scenes/Editor/Notebook/notebookUtils.ts
@@ -1111,16 +1111,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)
     ) {
@@ -1181,26 +1185,20 @@ export const buildAppliedCells = (
     }
 
     const isDraw = resolvedMode === "draw"
-    if (
-      resolvedType === "markdown" &&
-      (req.resultHeight != null || (req.view != null && req.view !== "editor"))
-    ) {
-      throw new ApplyNotebookStateError(
-        `Cell at index ${index} is markdown; result_height must be null and view must be null or "editor". Use editor_height to size its rendered content.`,
-        "cells",
-      )
-    }
     const dimensionCell: NotebookCell = {
-      ...(existing ?? { id, position: index, value }),
+      ...(existing ?? { id, position: index, value, type: resolvedType }),
       value,
       ...(resolvedMode !== undefined ? { mode: resolvedMode } : {}),
     }
-    if (resolvedType === "markdown") dimensionCell.type = "markdown"
-    else delete dimensionCell.type
+    const dimensions = applicableCellDimensions(dimensionCell, {
+      editorHeight: req.editorHeight,
+      resultHeight: req.resultHeight,
+      view: req.view,
+    })
     if (
-      typeof req.editorHeight === "number" &&
-      (!Number.isFinite(req.editorHeight) ||
-        req.editorHeight < minTopHeightFor(dimensionCell))
+      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.`,
@@ -1208,24 +1206,23 @@ export const buildAppliedCells = (
       )
     }
     if (
-      typeof req.resultHeight === "number" &&
-      (!Number.isFinite(req.resultHeight) ||
-        req.resultHeight < minBottomHeightFor(dimensionCell))
+      typeof dimensions.resultHeight === "number" &&
+      (!Number.isFinite(dimensions.resultHeight) ||
+        dimensions.resultHeight < minBottomHeightFor(dimensionCell))
     ) {
       throw new ApplyNotebookStateError(
-        `Cell at index ${index} has result_height ${req.resultHeight}px; minimum is ${minBottomHeightFor(dimensionCell)}px.`,
+        `Cell at index ${index} has result_height ${dimensions.resultHeight}px; minimum is ${minBottomHeightFor(dimensionCell)}px.`,
         "cells",
       )
     }
-    const dimensionsPatch = agentCellDimensionsPatch(dimensionCell, {
-      editorHeight: req.editorHeight,
-      resultHeight: req.resultHeight,
-      view: req.view,
-    })
+    const dimensionsPatch = agentCellDimensionsPatch(dimensionCell, dimensions)
     if (req.view == null && !existing && isDraw) {
       dimensionsPatch.preferredView = "result"
     }
-    const autoRefresh = req.autoRefresh != null ? req.autoRefresh : undefined
+    const autoRefresh =
+      req.autoRefresh != null && resolvedType !== "markdown"
+        ? req.autoRefresh
+        : undefined
 
     if (req.grid) {
       const gridError = cellGridBoundsError(req.grid)
@@ -1263,11 +1260,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
@@ -1277,19 +1269,7 @@ export const buildAppliedCells = (
       if (autoRefresh !== undefined) next.autoRefresh = autoRefresh
       else delete next.autoRefresh
       Object.assign(next, dimensionsPatch)
-      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.preferredView
-        delete next.bottomHeight
-        delete next.lastRunStatus
-        delete next.lastRunError
-      } else {
-        delete next.type
+      if (resolvedType !== "markdown") {
         next.preferredView ??= "editor_result"
         if (valueChanged && !existing.topResized) {
           const estimated = topHeightForSql(value)
@@ -1419,6 +1399,14 @@ export type AgentCellDimensions = {
   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.
@@ -1579,8 +1567,8 @@ export const storedAgentCellView = (cell: NotebookCell): AgentCellView => {
 }
 
 export type AgentCellPresentation = {
-  preferred_view: AgentCellView
-  view?: AgentCellView
+  preferred_view: AgentCellView | null
+  view?: AgentCellView | null
   tier?: AgentCellTier
 }
 
@@ -1589,6 +1577,7 @@ export const resolveAgentCellPresentation = (
   compact?: boolean,
   expectingResult: boolean = false,
 ): AgentCellPresentation => {
+  if (cell.type === "markdown") return { preferred_view: null, view: null }
   const preferredView = storedAgentCellView(cell)
   if (compact === undefined) return { preferred_view: preferredView }
   const paneLayout = resolveCellPaneLayout(cell, expectingResult, compact)
diff --git a/src/utils/ai/notebookSnapshot.test.ts b/src/utils/ai/notebookSnapshot.test.ts
index dd9c1ed9e..b351869c5 100644
--- a/src/utils/ai/notebookSnapshot.test.ts
+++ b/src/utils/ai/notebookSnapshot.test.ts
@@ -280,6 +280,37 @@ describe("buildSnapshot", () => {
     unpublish()
   })
 
+  it("reports null pane views 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 and tier is absent
+    expect(cellSnapshot).toMatchObject({
+      type: "markdown",
+      preferred_view: null,
+      view: null,
+      result_height: null,
+    })
+    expect(cellSnapshot?.tier).toBeUndefined()
+    // And get_cell reports the same null pane fields
+    const details = serializeCell(
+      [sql("a", "# title", { type: "markdown" })],
+      "a",
+      id,
+      false,
+    )
+    expect(details).toMatchObject({
+      preferred_view: null,
+      view: null,
+      result_height: null,
+    })
+    expect(details.tier).toBeUndefined()
+  })
+
   it("omits tier and reports the stored preference for an inactive notebook", async () => {
     const id = await seedNotebook({
       cells: [
diff --git a/src/utils/ai/notebookSnapshot.ts b/src/utils/ai/notebookSnapshot.ts
index 429516d2f..940f6c164 100644
--- a/src/utils/ai/notebookSnapshot.ts
+++ b/src/utils/ai/notebookSnapshot.ts
@@ -18,6 +18,7 @@ import type { UserActionDigest } from "../../providers/AIConversationProvider/ty
 import type { WorkspaceInfo } from "./executeAIFlow"
 import { normalizeVariables } from "../../scenes/Editor/Notebook/declareUtils"
 import {
+  type AgentCellPresentation,
   agentCellPaneDimensions,
   agentViewForPaneLayout,
   resolveAgentCellPresentation,
@@ -58,9 +59,9 @@ export type NotebookContextCell = {
   mode?: "run" | "draw"
   auto_refresh?: AutoRefresh
   editor_height?: number | "auto"
-  result_height?: number | "auto"
-  preferred_view: AgentCellView
-  view?: AgentCellView
+  result_height?: number | "auto" | null
+  preferred_view: AgentCellView | null
+  view?: AgentCellView | null
   tier?: AgentCellTier
   chart_config?: ChartConfigWire
   last_run_status?: RunStatus
@@ -165,7 +166,11 @@ const refreshFields = (
   }
 }
 
-const liveAgentCellPresentation = (cell: NotebookCell, bufferId: number) => {
+const liveAgentCellPresentation = (
+  cell: NotebookCell,
+  bufferId: number,
+): AgentCellPresentation => {
+  if (cell.type === "markdown") return resolveAgentCellPresentation(cell)
   const live = readLiveCellPresentation(bufferId, cell.id)
   if (!live) return resolveAgentCellPresentation(cell)
   return {
@@ -200,7 +205,8 @@ const buildCell = (
   if (cell.autoRefresh !== undefined) out.auto_refresh = cell.autoRefresh
   const dimensions = agentCellPaneDimensions(cell)
   out.editor_height = dimensions.editorHeight
-  if (dimensions.resultHeight !== undefined)
+  if (cell.type === "markdown") out.result_height = null
+  else if (dimensions.resultHeight !== undefined)
     out.result_height = dimensions.resultHeight
   if (presentation.view !== undefined) out.view = presentation.view
   if (presentation.tier !== undefined) out.tier = presentation.tier
@@ -471,9 +477,9 @@ export type NotebookCellDetails = {
   mode?: "run" | "draw"
   auto_refresh?: AutoRefresh
   editor_height: number | "auto"
-  result_height?: number | "auto"
-  preferred_view: AgentCellView
-  view?: AgentCellView
+  result_height?: number | "auto" | null
+  preferred_view: AgentCellView | null
+  view?: AgentCellView | null
   tier?: AgentCellTier
   chart_config?: ChartConfigWire
   last_run_status?: RunStatus
@@ -550,7 +556,8 @@ 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 (dimensions.resultHeight !== undefined)
+  if (cell.type === "markdown") out.result_height = null
+  else if (dimensions.resultHeight !== undefined)
     out.result_height = dimensions.resultHeight
   if (cell.chartConfig && Array.isArray(cell.chartConfig.queries))
     out.chart_config = toChartConfigWire(cell.chartConfig)
diff --git a/src/utils/ai/prompts.ts b/src/utils/ai/prompts.ts
index 3d721ac76..cd8df2eff 100644
--- a/src/utils/ai/prompts.ts
+++ b/src/utils/ai/prompts.ts
@@ -114,8 +114,8 @@ 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).
-- 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, preferred_view is the single stored, viewport-independent intent: editor, result, or editor_result. Effective view is derived from that preference, current result availability, and tier. Compact projects editor_result to result without rewriting preferred_view; widening restores editor_result. If a result is genuinely unavailable, effective view temporarily falls back to editor without rewriting preferred_view. Mounted SQL/draw cells report effective view and tier (wide/compact) as a pair; both are omitted when the cell is not rendered. Markdown has no mutable pane-view state: it reports the fixed preferred_view editor and does not expose effective view/tier. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. Keep charts at result_height >= 240; use editor_height 86 for a polished markdown title (never use the 26px structural minimum for non-empty prose).
+- 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, preferred_view is the single stored, viewport-independent intent: editor, result, or editor_result. Effective view is derived from that preference, current result availability, and tier. Compact projects editor_result to result without rewriting preferred_view; widening restores editor_result. If a result is genuinely unavailable, effective view temporarily falls back to editor without rewriting preferred_view. Mounted SQL/draw cells report effective view and tier (wide/compact) as a pair; both are omitted when the cell is not rendered. Markdown has no pane-view state: it reports preferred_view, view, and result_height as null and never reports tier; keep view and result_height null when writing a markdown cell (any value is ignored). A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. Keep charts at result_height >= 240; use editor_height 86 for a polished markdown title (never use the 26px structural minimum for non-empty prose).
 - 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 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 dimension fields are the documented exception: null preserves their current setting. For a single targeted edit, prefer update_cell / set_cell_chart_config / set_cell_dimensions instead.
diff --git a/src/utils/ai/shared.notebookTools.test.ts b/src/utils/ai/shared.notebookTools.test.ts
index bda0b4c61..d89e71683 100644
--- a/src/utils/ai/shared.notebookTools.test.ts
+++ b/src/utils/ai/shared.notebookTools.test.ts
@@ -42,6 +42,7 @@ import type { ToolExecutionContext } from "./shared"
 import { createNotebookFreshness } from "../notebooks/notebookFreshness"
 import {
   __resetNotebookPresentationStoreForTests,
+  publishGridContainerWidth,
   publishLiveCellPresentation,
 } from "../../scenes/Editor/Notebook/notebookPresentationStore"
 
@@ -772,8 +773,8 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       compact: false,
       paneLayout: "split",
       expectingResult: false,
-      gridContainerWidth: 1200,
     })
+    const unpublishWidth = publishGridContainerWidth(1, 1200)
 
     const res = await dispatchTool(
       "set_cell_layout",
@@ -789,6 +790,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       tier: "compact",
     })
     expect(state.parts.settings.layout?.[0].w).toBe(4)
+    unpublishWidth()
     unpublish()
   })
 
diff --git a/src/utils/notebooks/notebookController/notebookTransitions.test.ts b/src/utils/notebooks/notebookController/notebookTransitions.test.ts
index 48d14be26..55849e7cf 100644
--- a/src/utils/notebooks/notebookController/notebookTransitions.test.ts
+++ b/src/utils/notebooks/notebookController/notebookTransitions.test.ts
@@ -137,6 +137,31 @@ describe("setCellDimensionsTransition", () => {
     })
   })
 
+  it("ignores view and result_height on a markdown cell and reports null views", () => {
+    // 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",
+        compact: false,
+      },
+    )
+    // Then only the editor height lands, and the views report null
+    expect(out.parts.cells[0]).toMatchObject({
+      topHeight: 86,
+      topResized: true,
+    })
+    expect(out.parts.cells[0].bottomHeight).toBeUndefined()
+    expect(out.parts.cells[0].preferredView).toBeUndefined()
+    expect(out.result).toEqual({ preferred_view: null, view: null })
+  })
+
   it("supports a genuine editor-only view in the wide tier", () => {
     const chart = cell("a", "SELECT 1", { mode: "draw" })
     const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
diff --git a/src/utils/notebooks/notebookController/notebookTransitions.ts b/src/utils/notebooks/notebookController/notebookTransitions.ts
index 06adee580..7ed27f229 100644
--- a/src/utils/notebooks/notebookController/notebookTransitions.ts
+++ b/src/utils/notebooks/notebookController/notebookTransitions.ts
@@ -13,6 +13,7 @@ import type { ApplyNotebookStateRequest } from "./notebookController"
 import type { ChartConfig } from "../../../scenes/Editor/Notebook/CellChart/chartTypes"
 import {
   agentCellDimensionsPatch,
+  applicableCellDimensions,
   buildAppliedNotebookState,
   carriedRunError,
   carriedRunStatus,
@@ -338,7 +339,7 @@ export const setCellDimensionsTransition = (
   parts: ViewParts,
   bufferId: number,
   cellId: string,
-  dimensions: AgentCellDimensions,
+  requested: AgentCellDimensions,
 ): NotebookTransitionResult<
   ReturnType<typeof resolveAgentCellPresentation> & {
     fallback?:
@@ -347,16 +348,7 @@ export const setCellDimensionsTransition = (
   }
 > => {
   const cell = requireCellIn(parts.cells, cellId, bufferId)
-  if (
-    cell.type === "markdown" &&
-    (dimensions.resultHeight != null ||
-      (dimensions.view != null && dimensions.view !== "editor"))
-  ) {
-    throw new NotebookToolError(
-      "validation",
-      'Markdown cells have no result pane; pass null for result_height and null or "editor" for view.',
-    )
-  }
+  const dimensions = applicableCellDimensions(cell, requested)
   if (
     typeof dimensions.editorHeight === "number" &&
     (!Number.isFinite(dimensions.editorHeight) ||
diff --git a/src/utils/tools/dispatch.ts b/src/utils/tools/dispatch.ts
index 7b65a1a51..0d198213b 100644
--- a/src/utils/tools/dispatch.ts
+++ b/src/utils/tools/dispatch.ts
@@ -87,7 +87,10 @@ import {
   serializeCell,
   summarizeCells,
 } from "../ai/notebookSnapshot"
-import { readLiveCellPresentation } from "../../scenes/Editor/Notebook/notebookPresentationStore"
+import {
+  readGridContainerWidth,
+  readLiveCellPresentation,
+} from "../../scenes/Editor/Notebook/notebookPresentationStore"
 import { generateId } from "../../scenes/Editor/Notebook/notebookUtils"
 import {
   copyNotebookSnapshots,
@@ -841,7 +844,7 @@ export const dispatchTool = async (
                 w,
                 liveCompact: livePresentation?.compact,
                 liveExpectingResult: livePresentation?.expectingResult,
-                gridContainerWidth: livePresentation?.gridContainerWidth,
+                gridContainerWidth: readGridContainerWidth(buffer_id),
               })
             },
             signal,

From 057faf01f24e6dc3f2c744eb88bcd82f0fe9991b Mon Sep 17 00:00:00 2001
From: emrberk <emreberk5699@gmail.com>
Date: Thu, 3 Sep 2026 19:38:57 +0300
Subject: [PATCH 4/4] remove compact tier and simplify tools

---
 e2e/questdb                                   |   2 +-
 src/consts/shared-definitions.json            |  34 +-
 src/modules/ConsoleEventTracker/events.ts     |   2 +-
 src/scenes/Editor/Monaco/importTabs.test.ts   |   6 +-
 src/scenes/Editor/Monaco/importTabs.ts        |  25 +-
 .../Notebook/CellChart/ChartRenderer.tsx      |  58 ++-
 .../CellChart/buildEchartsOption.test.ts      |  20 +
 .../Notebook/CellChart/buildEchartsOption.ts  |  40 +-
 .../Notebook/CellChart/chartDensity.test.ts   | 157 ++++++++
 .../Editor/Notebook/CellChart/chartDensity.ts |  86 +++++
 .../Editor/Notebook/NotebookProvider.tsx      |  12 +-
 .../Editor/Notebook/cellHydrationStore.ts     |  42 +++
 src/scenes/Editor/Notebook/cells/Cell.tsx     |  50 +--
 .../Editor/Notebook/cells/CellToolbar.tsx     |  40 +-
 .../Editor/Notebook/cells/CellViewToggle.tsx  |  11 +-
 .../Editor/Notebook/cells/useCellResize.ts    |   5 +-
 .../cells/useCellResizeOrchestration.ts       |  24 +-
 .../Notebook/cells/useCellRunActions.ts       |  35 +-
 src/scenes/Editor/Notebook/index.tsx          |  71 +---
 .../Notebook/notebookPresentationStore.ts     |  68 ----
 .../Editor/Notebook/notebookUtils.test.ts     | 345 ++++++++----------
 src/scenes/Editor/Notebook/notebookUtils.ts   | 204 ++++++-----
 src/store/notebook.ts                         |  12 +-
 src/utils/ai/notebookSnapshot.test.ts         |  76 +---
 src/utils/ai/notebookSnapshot.ts              |  67 +---
 src/utils/ai/prompts.ts                       |   4 +-
 src/utils/ai/shared.notebookTools.test.ts     |  53 +--
 src/utils/notebooks/notebookAIBridge.test.ts  |   2 +-
 .../notebooks/notebookController/index.ts     |   2 +-
 .../notebookTransitions.test.ts               | 145 +++-----
 .../notebookController/notebookTransitions.ts |  93 ++---
 .../notebooks/notebookDexieController.test.ts |   8 +-
 src/utils/notebooks/notebookDexieView.test.ts |  17 +-
 src/utils/notebooks/notebookDexieView.ts      |  28 +-
 src/utils/tools/dispatch.ts                   |  27 +-
 35 files changed, 895 insertions(+), 976 deletions(-)
 create mode 100644 src/scenes/Editor/Notebook/CellChart/chartDensity.test.ts
 create mode 100644 src/scenes/Editor/Notebook/CellChart/chartDensity.ts
 create mode 100644 src/scenes/Editor/Notebook/cellHydrationStore.ts
 delete mode 100644 src/scenes/Editor/Notebook/notebookPresentationStore.ts

diff --git a/e2e/questdb b/e2e/questdb
index 9848be5f3..090a22720 160000
--- a/e2e/questdb
+++ b/e2e/questdb
@@ -1 +1 @@
-Subproject commit 9848be5f3ad91796cabe5f098695919b08e73769
+Subproject commit 090a2272082337f5f986b80e348f9e9d659ab08f
diff --git a/src/consts/shared-definitions.json b/src/consts/shared-definitions.json
index a57a3f3a2..a946010ab 100644
--- a/src/consts/shared-definitions.json
+++ b/src/consts/shared-definitions.json
@@ -241,7 +241,7 @@
     "surfaces": ["ai", "mcp"],
     "mutatesNotebook": false,
     "createsNotebook": false,
-    "description": "Get full details of a cell (value, kind via `type`, editor_height/result_height, preferred/effective view, chart config, last-run status + trimmed error). Height values are fixed CSS pixels or \"auto\". `preferred_view` is the single stored, viewport-independent intent for SQL/draw cells; resizing or result hydration never rewrites it. Markdown has no pane-view state: it reports `preferred_view`, `view`, and `result_height` as null. A rendered SQL/draw cell additionally returns effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted when that cell is not rendered. `view` is derived from `preferred_view`, current result availability, and tier. Markdown cells never report `tier`. Compact cannot display editor_result, so it may report `preferred_view: editor_result` with `view: result`. A cell whose result is unavailable temporarily reports `view: editor` without changing `preferred_view`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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.",
+    "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, semantic pane dimensions, kind via `type`, last-run statuses). Cell `grid` contains x/y/w only; height is represented by editor_height/result_height. `preferred_view` is the single stored, viewport-independent intent for SQL/draw cells; resizing or result hydration never rewrites it. Markdown has no pane-view state: it reports `preferred_view`, `view`, and `result_height` as null. A rendered SQL/draw cell additionally returns effective `view` and live-only `tier` (`wide` or `compact`) as a pair; both are omitted when that cell is not rendered. `view` is derived from `preferred_view`, current result availability, and tier. Markdown cells never report `tier`. Compact cannot display editor_result, so it may report `preferred_view: editor_result` with `view: result`. An unavailable result temporarily produces `view: editor` without changing `preferred_view`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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.",
+    "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 are integers in the react-grid-layout grid; width is limited to 12 columns. Cell height is derived from its semantic pane dimensions. Changing w may change the responsive tier and effective view of a SQL/draw cell. The response includes the applied grid position and `preferred_view`; when a SQL/draw cell is rendered it also includes the resulting effective `view` and `tier`. Markdown reports `preferred_view` and `view` as null and never reports `tier`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing can later change tier even if grid.w stays fixed. Use set_cell_dimensions to resize a cell or change its preferred view.",
+    "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,
@@ -505,7 +505,7 @@
     "surfaces": ["ai", "mcp"],
     "mutatesNotebook": true,
     "createsNotebook": false,
-    "description": "Resize a cell using semantic pane dimensions in CSS pixels and choose its single viewport-independent preferred 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. Wide cells display the preference directly. Compact cells project editor_result to result without rewriting it. Cells without an available result temporarily display editor without rewriting the preference. The response always reports `preferred_view`; when a SQL/draw cell is rendered it also reports effective `view` and live-only `tier` (`wide` or `compact`) as a pair, and may report a `fallback`. Markdown has no pane-view state: it reports `preferred_view`, `view`, and `result_height` as null and never reports `tier`; editor_height sizes its rendered content, while result_height and view are ignored — keep them null. Never use the structural 26px minimum for non-empty prose—use at least 56px, or 86px for a polished title. Chart result_height must be at least 240px; table results at least 100px.",
+    "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,
@@ -518,26 +518,26 @@
         },
         "editor_height": {
           "anyOf": [
-            { "type": "number", "minimum": 26 },
+            { "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. Non-empty markdown should be at least 56px; use 86px for a polished title."
+          "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 },
+            { "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."
+          "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": "Single stored, viewport-independent pane preference. Null preserves. Wide displays editor, result, or editor_result directly. Compact projects editor_result to result without rewriting the preference. A cell without an available result temporarily displays editor without rewriting the preference."
+          "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": [
@@ -881,23 +881,23 @@
                     "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."
               },
               "editor_height": {
                 "anyOf": [
-                  { "type": "number", "minimum": 26 },
+                  { "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. Non-empty markdown should be at least 56px; use 86px for a polished title."
+                "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 },
+                  { "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 240px; tables 100px. Ignored for markdown; keep it 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": [
@@ -907,7 +907,7 @@
                   },
                   { "type": "null" }
                 ],
-                "description": "Single stored, viewport-independent pane preference. 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. Wide displays the preference directly. Compact projects editor_result to result without rewriting it. An unavailable result temporarily displays editor without rewriting the preference. Ignored for markdown; keep it 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"],
@@ -1110,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 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 the single stored, viewport-independent `preferred_view`; resizing and result hydration never rewrite it. Markdown has no pane-view state: it reports `preferred_view`, `view`, and `result_height` as null. Rendered SQL/draw cells additionally report effective `view` and live-only `tier` (`wide` or `compact`) as a pair; `view` is derived from preference, result availability, and tier. Both are omitted for inactive or unmounted cells. Markdown cells never report `tier`. A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. 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": {
@@ -1127,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 13eed171f..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",
diff --git a/src/scenes/Editor/Monaco/importTabs.test.ts b/src/scenes/Editor/Monaco/importTabs.test.ts
index 3e019deb1..fc8dc9960 100644
--- a/src/scenes/Editor/Monaco/importTabs.test.ts
+++ b/src/scenes/Editor/Monaco/importTabs.test.ts
@@ -782,21 +782,21 @@ describe("sanitizeBuffer", () => {
         position: 0,
         notebookViewState: {
           cells: [
-            { id: "preferred", value: "SELECT 1", preferredView: "editor" },
+            { 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",
-              preferredView: "result",
+              paneView: "result",
             },
           ],
         },
       }
 
       const cells = sanitizeBuffer(input).notebookViewState?.cells
-      expect(cells?.map((cell) => cell.preferredView)).toEqual([
+      expect(cells?.map((cell) => cell.paneView)).toEqual([
         "editor",
         "result",
         "editor_result",
diff --git a/src/scenes/Editor/Monaco/importTabs.ts b/src/scenes/Editor/Monaco/importTabs.ts
index 24a97f2e1..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,
@@ -272,21 +273,21 @@ const sanitizeNotebookCell = (
   if (chartConfig) cell.chartConfig = chartConfig
   if (isAutoRefresh(item.autoRefresh)) cell.autoRefresh = item.autoRefresh
   if (item.type !== "markdown") {
-    if (
-      item.preferredView === "editor" ||
-      item.preferredView === "result" ||
-      item.preferredView === "editor_result"
-    ) {
-      cell.preferredView = item.preferredView
+    if (isAgentCellView(item.paneView)) {
+      cell.paneView = item.paneView
     } else if (item.isViewMaximized === true) {
-      cell.preferredView = "result"
+      cell.paneView = "result"
     } else {
-      cell.preferredView = "editor_result"
+      cell.paneView = "editor_result"
     }
   }
-  if (typeof item.topHeight === "number") cell.topHeight = item.topHeight
-  if (typeof item.bottomHeight === "number")
-    cell.bottomHeight = item.bottomHeight
+  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 747e764e9..637917a9c 100644
--- a/src/scenes/Editor/Notebook/NotebookProvider.tsx
+++ b/src/scenes/Editor/Notebook/NotebookProvider.tsx
@@ -36,7 +36,7 @@ import {
   registerController,
   setCellMaximizedTransition,
   setCellModeTransition,
-  setCellPreferredViewTransition,
+  setCellPaneViewTransition,
   unregisterController,
   type NotebookControllerActions,
   type NotebookTransitionResult,
@@ -129,7 +129,7 @@ export type NotebookActions = {
   setCellRefresh: (cellId: string, value: AutoRefresh | undefined) => void
   resetAutoRefreshOverrides: () => void
   refreshAllCells: () => { refreshed: number; skippedWrites: number }
-  setCellPreferredView: (cellId: string, view: AgentCellView) => void
+  setCellPaneView: (cellId: string, view: AgentCellView) => void
   setFocusedCell: (cellId: string | null) => void
   setMaximizedCellId: (cellId: string | null) => void
   getCellsSnapshot: () => NotebookCell[]
@@ -159,7 +159,7 @@ const NOOP_ACTIONS: NotebookActions = {
   setCellRefresh: () => undefined,
   resetAutoRefreshOverrides: () => undefined,
   refreshAllCells: () => ({ refreshed: 0, skippedWrites: 0 }),
-  setCellPreferredView: () => undefined,
+  setCellPaneView: () => undefined,
   setFocusedCell: () => undefined,
   setMaximizedCellId: () => undefined,
   getCellsSnapshot: () => [],
@@ -768,11 +768,11 @@ export const NotebookProvider: React.FC<{
     [applyTransition, bufferId],
   )
 
-  const setCellPreferredView = useCallback(
+  const setCellPaneView = useCallback(
     (cellId: string, view: AgentCellView) =>
       silently(() =>
         applyTransition((parts) =>
-          setCellPreferredViewTransition(parts, bufferId, cellId, view),
+          setCellPaneViewTransition(parts, bufferId, cellId, view),
         ),
       ),
     [applyTransition, bufferId],
@@ -829,7 +829,7 @@ export const NotebookProvider: React.FC<{
     setCellRefresh: store.setCellRefresh,
     resetAutoRefreshOverrides,
     refreshAllCells: () => cellRefreshEngine.refreshAll(),
-    setCellPreferredView,
+    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 d79855fce..e0f560998 100644
--- a/src/scenes/Editor/Notebook/cells/Cell.tsx
+++ b/src/scenes/Editor/Notebook/cells/Cell.tsx
@@ -30,6 +30,7 @@ import { toast } from "../../../../components/Toast"
 import {
   CELL_EDITOR_LINE_HEIGHT,
   CELL_EDITOR_PADDING,
+  clampPaneHeight,
   isDoubleView,
   isExpectingResult,
   minBottomHeightFor,
@@ -37,7 +38,6 @@ import {
   resolveCellPaneLayout,
   resolveCellView,
 } from "../notebookUtils"
-import type { CellToolbarTier } from "../notebookUtils"
 import {
   useCellContentMode,
   useCellVirtualizationEngine,
@@ -53,7 +53,7 @@ import {
   useCellResizeOrchestration,
 } from "./useCellResizeOrchestration"
 import { CellBottomContent } from "./CellBottomContent"
-import { publishLiveCellPresentation } from "../notebookPresentationStore"
+import { publishCellHydration } from "../cellHydrationStore"
 import { getMonacoThemeName } from "../../../../utils/monacoInit"
 
 const EditorContainer = styled.div<{ $spotlight: boolean }>`
@@ -121,7 +121,6 @@ type Props = {
   isFocused: boolean
   isMaximized: boolean
   isRunning: boolean
-  toolbarTierOverride?: CellToolbarTier
 }
 
 const CellInner: React.FC<Props> = ({
@@ -133,7 +132,6 @@ const CellInner: React.FC<Props> = ({
   isFocused,
   isMaximized,
   isRunning,
-  toolbarTierOverride,
 }) => {
   const { setCellChartConfig, clearCellResult, updateCell, setFocusedCell } =
     useNotebookActions()
@@ -152,8 +150,7 @@ const CellInner: React.FC<Props> = ({
   const resultRef = useRef<HTMLDivElement | null>(null)
   const headerRef = useRef<HTMLDivElement | null>(null)
 
-  const observedToolbarTier = useCellToolbarTier(headerRef, isMaximized)
-  const toolbarTier = toolbarTierOverride ?? observedToolbarTier
+  const toolbarTier = useCellToolbarTier(headerRef, isMaximized)
   const { loading: chartLoading, refreshing: chartRefreshing } =
     useChartLoading(cell)
   const chartZoomed = useChartZoomed(cell.id)
@@ -180,17 +177,14 @@ 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
-  const isCompactTier = toolbarTier === "compact"
-  const paneLayout = resolveCellPaneLayout(cell, expectingResult, isCompactTier)
+  const paneLayout = resolveCellPaneLayout(cell, expectingResult)
 
   useEffect(
     () =>
-      publishLiveCellPresentation(bufferIdForEvents, cell.id, {
-        compact: isCompactTier,
-        paneLayout,
+      publishCellHydration(bufferIdForEvents, cell.id, {
         expectingResult,
       }),
-    [bufferIdForEvents, cell.id, expectingResult, isCompactTier, paneLayout],
+    [bufferIdForEvents, cell.id, expectingResult],
   )
 
   const resultOnly = paneLayout === "result"
@@ -214,8 +208,6 @@ const CellInner: React.FC<Props> = ({
     middleResizeEnd,
     resetToDefaults,
     resetBottomArea,
-    maximizedChartResizeLive,
-    maximizedChartResizeEnd,
   } = useCellResizeOrchestration({
     cell,
     layoutMode,
@@ -239,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 })
     },
@@ -299,7 +291,6 @@ const CellInner: React.FC<Props> = ({
     useCellRunActions({
       cell,
       isRunning,
-      isCompactTier,
       showBottomSlot,
       editorRef,
       applyHighlight,
@@ -583,13 +574,9 @@ const CellInner: React.FC<Props> = ({
           ref={resultRef}
           $spotlight={isMaximized}
           style={
-            resultOnly
-              ? isMaximized
-                ? { flex: 1 }
-                : { height: bottomHeight }
-              : isMaximized
-                ? { flex: 1 - spotlightEditorRatio }
-                : { height: bottomHeight }
+            isMaximized
+              ? { flex: resultOnly ? 1 : 1 - spotlightEditorRatio }
+              : { height: bottomHeight }
           }
         >
           <CellBottomContent
@@ -612,29 +599,20 @@ const CellInner: React.FC<Props> = ({
     !isMaximized && layoutMode !== "grid" ? (
       <ResizeHandle
         overlay
-        targetRef={
-          resultOnly || showBottomSlot ? resultRef : editorContainerRef
-        }
+        targetRef={showBottomSlot ? resultRef : editorContainerRef}
         onResize={
-          resultOnly
-            ? maximizedChartResizeLive
-            : showBottomSlot
-              ? bottomResize.resizeLive
-              : topResize.resizeLive
+          showBottomSlot ? bottomResize.resizeLive : topResize.resizeLive
         }
         onResizeEnd={(height) => {
           void trackEvent(ConsoleEvent.NOTEBOOK_CELL_RESIZE, { region: "s" })
-          if (resultOnly) 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)
           resetBottomArea()
         }}
-        minHeight={
-          resultOnly || showBottomSlot ? minBottomHeightFor(cell) : undefined
-        }
+        minHeight={showBottomSlot ? minBottomHeightFor(cell) : undefined}
       />
     ) : null
 
diff --git a/src/scenes/Editor/Notebook/cells/CellToolbar.tsx b/src/scenes/Editor/Notebook/cells/CellToolbar.tsx
index 8f4189d92..f67dd3e7b 100644
--- a/src/scenes/Editor/Notebook/cells/CellToolbar.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellToolbar.tsx
@@ -100,7 +100,7 @@ export const CellToolbar: React.FC<Props> = ({
     setFocusedCell,
     setMaximizedCellId,
     setCellRefresh,
-    setCellPreferredView,
+    setCellPaneView,
     setCellMode,
   } = useNotebookActions()
   const bufferId = useNotebookBufferId()
@@ -114,8 +114,8 @@ export const CellToolbar: React.FC<Props> = ({
   const isChartView = view === "chart"
   const isGridView = view === "grid"
   const isNoneView = view === "none"
-  const resultOnly =
-    !isNoneView && paneLayout !== undefined && paneLayout === "result"
+  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.
@@ -128,7 +128,7 @@ export const CellToolbar: React.FC<Props> = ({
     showViewSql,
     showViewTable,
     showViewChart,
-    showSplitItem,
+    showEditorToggleItem,
     showResetZoom,
     showAutoRefreshItem,
     showRefreshItem,
@@ -143,9 +143,7 @@ export const CellToolbar: React.FC<Props> = ({
     tier: toolbarTier ?? "compact",
     view,
     isMarkdown,
-    // Compact cells cannot split, so showing the editor temporarily hides the
-    // result without dropping its data.
-    sqlShown: paneLayout === "editor",
+    sqlShown,
     chartZoomed,
     isGridMode,
     cellIndex,
@@ -159,7 +157,7 @@ export const CellToolbar: React.FC<Props> = ({
       method: "menu",
     })
     signalUserEdit(bufferId)
-    setCellPreferredView(cellId, "editor")
+    setCellPaneView(cellId, "editor")
   }
   const handleViewTable = () => {
     if (isRunning) return
@@ -172,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")
-    setCellPreferredView(cellId, "result")
+    if (sqlShown) setCellPaneView(cellId, "editor_result")
   }
   const handleViewChart = () => {
     if (isRunning) return
@@ -185,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
     }
-    setCellPreferredView(cellId, "result")
+    setCellPaneView(cellId, "editor_result")
   }
-  const handleToggleMaximizeView = () => {
-    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_MAXIMIZE, {
-      isViewMaximized: !resultOnly,
+  const handleToggleEditor = () => {
+    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_EDITOR_TOGGLE, {
+      editorShown: resultOnly,
       view,
     })
     signalUserEdit(bufferId)
-    setCellPreferredView(cellId, resultOnly ? "editor_result" : "result")
+    setCellPaneView(cellId, resultOnly ? "editor_result" : "result")
   }
   const handleMaximizeCell = () => {
     void trackEvent(ConsoleEvent.NOTEBOOK_CELL_MAXIMIZE, {
@@ -339,9 +337,9 @@ export const CellToolbar: React.FC<Props> = ({
                   {isNoneView ? "Draw" : "View chart"}
                 </DropdownMenu.Item>
               )}
-              {showSplitItem && (
+              {showEditorToggleItem && (
                 <DropdownMenu.Item
-                  onSelect={handleToggleMaximizeView}
+                  onSelect={handleToggleEditor}
                   icon={<FileSqlIcon size={16} />}
                 >
                   {resultOnly ? "Show editor" : "Hide editor"}
diff --git a/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx b/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
index ce9d140b0..200a3075d 100644
--- a/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
@@ -90,8 +90,7 @@ export const CellViewToggle: React.FC<Props> = ({
   chartZoomed,
   showLabels,
 }) => {
-  const { setCellPreferredView, setCellMode, clearCellResult } =
-    useNotebookActions()
+  const { setCellPaneView, setCellMode, clearCellResult } = useNotebookActions()
   const bufferId = useNotebookBufferId()
   const resultOnly = paneLayout === "result"
   const resultHidden = paneLayout === "editor"
@@ -124,16 +123,16 @@ export const CellViewToggle: React.FC<Props> = ({
       return
     }
     setCellMode(cellId, "run")
-    if (resultHidden) setCellPreferredView(cellId, "editor_result")
+    if (resultHidden) setCellPaneView(cellId, "editor_result")
   }
   const handleEditorVisibility = (e: React.MouseEvent) => {
     e.stopPropagation()
-    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_MAXIMIZE, {
-      isViewMaximized: !resultOnly,
+    void trackEvent(ConsoleEvent.NOTEBOOK_CELL_EDITOR_TOGGLE, {
+      editorShown: resultOnly,
       view,
     })
     signalUserEdit(bufferId)
-    setCellPreferredView(cellId, resultOnly ? "editor_result" : "result")
+    setCellPaneView(cellId, resultOnly ? "editor_result" : "result")
   }
   const handleResetZoom = (e: React.MouseEvent) => {
     e.stopPropagation()
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 60ca9758c..352a71cfe 100644
--- a/src/scenes/Editor/Notebook/cells/useCellResizeOrchestration.ts
+++ b/src/scenes/Editor/Notebook/cells/useCellResizeOrchestration.ts
@@ -8,6 +8,7 @@ import { EventType } from "../../../../modules/EventBus/types"
 import { trackEvent } from "../../../../modules/ConsoleEventTracker"
 import { ConsoleEvent } from "../../../../modules/ConsoleEventTracker/events"
 import {
+  clampPaneHeight,
   computeCellHeights,
   hasAgentVisibleCellHeightChanged,
   minBottomHeightFor,
@@ -15,10 +16,9 @@ import {
   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 = {
@@ -33,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 = ({
@@ -56,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])
 
@@ -205,16 +205,6 @@ export const useCellResizeOrchestration = ({
     updateCell,
   ])
 
-  // With the editor hidden, resizing changes only the visible result pane.
-  // The editor allocation stays intact for a later restore.
-  const maximizedChartResizeLive = (newTotalHeight: number) => {
-    bottomResize.resizeLive(newTotalHeight)
-  }
-
-  const maximizedChartResizeEnd = (newTotalHeight: number) => {
-    bottomResize.resizeEnd(newTotalHeight)
-  }
-
   useEffect(() => {
     const handler = (payload?: { cellId?: string }) => {
       if (payload?.cellId !== cell.id) return
@@ -235,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 4ce21c8e9..b07f8d783 100644
--- a/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
+++ b/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
@@ -22,7 +22,6 @@ import { ConsoleEvent } from "../../../../modules/ConsoleEventTracker/events"
 type Options = {
   cell: NotebookCell
   isRunning: boolean
-  isCompactTier: boolean
   showBottomSlot: boolean
   editorRef: React.MutableRefObject<editor.IStandaloneCodeEditor | null>
   applyHighlight: (ok: boolean) => void
@@ -36,7 +35,6 @@ type Options = {
 export const useCellRunActions = ({
   cell,
   isRunning,
-  isCompactTier,
   showBottomSlot,
   editorRef,
   applyHighlight,
@@ -46,7 +44,7 @@ export const useCellRunActions = ({
     runCell,
     setCellMode,
     clearCellResult,
-    setCellPreferredView,
+    setCellPaneView,
     getCellsSnapshot,
   } = useNotebookActions()
   const bufferIdForEvents = useNotebookBufferId()
@@ -213,9 +211,9 @@ export const useCellRunActions = ({
         {
           mode: cell.mode,
           result: cell.result,
-          preferredView: cell.preferredView,
+          paneView: cell.paneView,
         },
-        { isCompactTier, showBottomSlot, intent },
+        { intent },
       )
       if (plan.kind === "noop") return
       if (plan.kind === "chart") {
@@ -237,20 +235,18 @@ export const useCellRunActions = ({
       if (plan.kind === "run-all") void handleRunAll(ignoreSelection)
       else void handleRunSingle()
       if (plan.reveal) {
-        // Running from compact editor-only mode reveals the result while
-        // preserving the natural split presentation when the cell widens.
-        setCellPreferredView(cell.id, "editor_result")
+        // 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.preferredView,
+      cell.paneView,
       bufferIdForEvents,
-      isCompactTier,
-      showBottomSlot,
-      setCellPreferredView,
+      setCellPaneView,
       setCellMode,
       handleRunAll,
       handleRunSingle,
@@ -298,12 +294,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) return
-        if (payload.maximize) setCellPreferredView(cell.id, "result")
-        else if (!showBottomSlot) setCellPreferredView(cell.id, "editor_result")
+        if (entered && !showBottomSlot)
+          setCellPaneView(cell.id, "editor_result")
       })
     }
     eventBus.subscribe(EventType.NOTEBOOK_CELL_RUN, runHandler)
@@ -312,13 +307,7 @@ export const useCellRunActions = ({
       eventBus.unsubscribe(EventType.NOTEBOOK_CELL_RUN, runHandler)
       eventBus.unsubscribe(EventType.NOTEBOOK_CELL_DRAW, drawHandler)
     }
-  }, [
-    cell.id,
-    refreshRun,
-    handleDrawClick,
-    setCellPreferredView,
-    showBottomSlot,
-  ])
+  }, [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 1ce47440f..5476c702f 100644
--- a/src/scenes/Editor/Notebook/index.tsx
+++ b/src/scenes/Editor/Notebook/index.tsx
@@ -33,7 +33,6 @@ import {
   useNotebookBufferId,
   useNotebookState,
 } from "./NotebookProvider"
-import { publishGridContainerWidth } from "./notebookPresentationStore"
 import { Cell } from "./cells/Cell"
 import { MarkdownCell } from "./cells/MarkdownCell"
 import type { AutoRefresh, NotebookCell } from "../../../store/notebook"
@@ -43,20 +42,18 @@ import { NotebookToolbar } from "./NotebookToolbar"
 import { NotebookMcpPromo } from "./NotebookMcpPromo"
 import { renderEdgeHandle } from "./resize"
 import {
-  cellHeightPatchForRows,
-  gridCellToolbarTier,
+  paneHeightsFromGridRows,
   computeCellGridH,
+  computeCellMaxGridH,
   computeCellMinGridH,
   generateDefaultLayout as generateDefaultLayoutPure,
   isExpectingResult,
   mergeCellLayout,
   resolveCellPaneLayout,
   NOTEBOOK_GRID_COLS,
-  NOTEBOOK_GRID_MARGIN_X,
   NOTEBOOK_GRID_MARGIN_Y,
   NOTEBOOK_GRID_ROW_HEIGHT,
 } from "./notebookUtils"
-import type { CellToolbarTier } from "./notebookUtils"
 import {
   emitUserAction,
   on as onUserAction,
@@ -194,7 +191,7 @@ const MIN_CELL_W = 2
 // unwanted hard floor in grid mode.
 const MIN_CELL_H = 5
 
-const GRID_MARGIN_X = NOTEBOOK_GRID_MARGIN_X
+const GRID_MARGIN_X = 20
 const GRID_MARGIN_Y = NOTEBOOK_GRID_MARGIN_Y
 const GRID_MARGIN: [number, number] = [GRID_MARGIN_X, GRID_MARGIN_Y]
 const GRID_CONTAINER_PADDING: [number, number] = [0, 0]
@@ -364,22 +361,13 @@ type CellViewProps = {
   isFocused: boolean
   isMaximized: boolean
   isRunning: boolean
-  toolbarTierOverride?: CellToolbarTier
 }
 
-const CellView: React.FC<CellViewProps> = ({
-  autoRefreshDefault,
-  toolbarTierOverride,
-  ...props
-}) =>
+const CellView: React.FC<CellViewProps> = ({ autoRefreshDefault, ...props }) =>
   props.cell.type === "markdown" ? (
     <MarkdownCell {...props} />
   ) : (
-    <Cell
-      {...props}
-      autoRefreshDefault={autoRefreshDefault}
-      toolbarTierOverride={toolbarTierOverride}
-    />
+    <Cell {...props} autoRefreshDefault={autoRefreshDefault} />
   )
 
 const ListLayout: React.FC = () => {
@@ -430,7 +418,6 @@ const GridLayout: React.FC = () => {
   const resultStatusVersion = useResultStatusVersion()
   const { setFocusedCell, updateSettings, updateCell } = useNotebookActions()
   const { activeBuffer } = useEditor()
-  const bufferId = useNotebookBufferId()
   // measureBeforeMount: don't render the grid until the container width is
   // measured, so cells first paint at their real width instead of animating
   // from the guessed initialWidth (react-grid-layout transitions the change).
@@ -440,10 +427,6 @@ const GridLayout: React.FC = () => {
     mounted: gridMeasured,
   } = useContainerWidth({ measureBeforeMount: true })
   const suppressTransitions = useContainerResizeInFlight(containerWidth)
-  useEffect(
-    () => publishGridContainerWidth(bufferId, containerWidth),
-    [bufferId, containerWidth],
-  )
   const autoScroll = useGridDragAutoScroll(
     containerRef as React.RefObject<HTMLElement>,
   )
@@ -454,7 +437,7 @@ const GridLayout: React.FC = () => {
   // shadow that only matters when react-grid-layout consumes it. The
   // memo recomputes when the layout, the cells or a statusOf boundary
   // (resultStatusVersion) changes
-  const { computedLayout, layoutKey, toolbarTierByCellId } = useMemo(() => {
+  const { computedLayout, layoutKey } = useMemo(() => {
     const mergedLayout = mergeCellLayout(
       settings.layout && settings.layout.length > 0
         ? settings.layout
@@ -463,7 +446,6 @@ const GridLayout: React.FC = () => {
       LAYOUT_OPTS,
     ) as LayoutItem[]
     const cellById = new Map(cells.map((c) => [c.id, c]))
-    const tiers = new Map<string, CellToolbarTier>()
     const computed = mergedLayout.map((item) => {
       const cell = cellById.get(item.i)
       if (!cell) return item
@@ -471,13 +453,7 @@ const GridLayout: React.FC = () => {
         cell,
         resultHydration?.statusOf(cell.id) ?? "unrequested",
       )
-      const toolbarTier = gridCellToolbarTier(containerWidth, item.w)
-      const paneLayout = resolveCellPaneLayout(
-        cell,
-        expectingResult,
-        toolbarTier === "compact",
-      )
-      tiers.set(cell.id, toolbarTier)
+      const paneLayout = resolveCellPaneLayout(cell, expectingResult)
       const minH = computeCellMinGridH(
         cell,
         ROW_HEIGHT,
@@ -495,6 +471,13 @@ const GridLayout: React.FC = () => {
           paneLayout,
         ),
         minH,
+        maxH: computeCellMaxGridH(
+          cell,
+          ROW_HEIGHT,
+          GRID_MARGIN_Y,
+          expectingResult,
+          paneLayout,
+        ),
       }
     })
     return {
@@ -502,18 +485,11 @@ 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("|"),
-      toolbarTierByCellId: tiers,
     }
-  }, [
-    settings.layout,
-    cells,
-    resultHydration,
-    resultStatusVersion,
-    containerWidth,
-  ])
+  }, [settings.layout, cells, resultHydration, resultStatusVersion])
 
   const currentLayout = useMemo(() => computedLayout, [layoutKey])
   const gridLayouts = useMemo(
@@ -576,10 +552,6 @@ const GridLayout: React.FC = () => {
         void trackEvent(ConsoleEvent.NOTEBOOK_CELL_RESIZE, { region })
       }
       updateSettings({ layout: mapLayoutXYW(newLayout) })
-      // A width-only resize may cross the compact breakpoint and therefore
-      // change the cell's derived h. Do not mistake the old h carried by RGL
-      // for an intentional pane-height resize; only back-solve when the user
-      // actually moved the vertical edge.
       if (oldItem && newItem && oldItem.h !== newItem.h) {
         const cell = cells.find((candidate) => candidate.id === newItem.i)
         if (cell) {
@@ -587,19 +559,12 @@ const GridLayout: React.FC = () => {
             cell,
             resultHydration?.statusOf(cell.id) ?? "unrequested",
           )
-          const toolbarTier = gridCellToolbarTier(containerWidth, newItem.w)
-          const paneLayout = resolveCellPaneLayout(
-            cell,
-            expectingResult,
-            toolbarTier === "compact",
-          )
-          const patch = cellHeightPatchForRows(
+          const patch = paneHeightsFromGridRows(
             cell,
             newItem.h,
             ROW_HEIGHT,
             GRID_MARGIN_Y,
             expectingResult,
-            paneLayout,
           )
           if (Object.keys(patch).length > 0) updateCell(cell.id, patch)
         }
@@ -618,7 +583,6 @@ const GridLayout: React.FC = () => {
       cells,
       activeBuffer.id,
       resultHydration,
-      containerWidth,
     ],
   )
 
@@ -718,7 +682,6 @@ const GridLayout: React.FC = () => {
                 isFocused={focusedCellId === cell.id}
                 isMaximized={maximizedCellId === cell.id}
                 isRunning={runningCellIds.has(cell.id)}
-                toolbarTierOverride={toolbarTierByCellId.get(cell.id)}
               />
             </GridCellWrapper>
           ))}
diff --git a/src/scenes/Editor/Notebook/notebookPresentationStore.ts b/src/scenes/Editor/Notebook/notebookPresentationStore.ts
deleted file mode 100644
index 580f9cb23..000000000
--- a/src/scenes/Editor/Notebook/notebookPresentationStore.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import type { CellPaneLayout } from "./notebookUtils"
-
-export type LiveCellPresentation = {
-  compact: boolean
-  paneLayout: CellPaneLayout
-  // 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 presentations = new Map<
-  number,
-  Map<string, { token: symbol; value: LiveCellPresentation }>
->()
-
-// Presentation is deliberately runtime-only: resizing a browser window must
-// not rewrite the notebook document. Live AI/MCP reads still need the exact
-// pane currently on screen, so mounted cells publish it here.
-export const publishLiveCellPresentation = (
-  bufferId: number,
-  cellId: string,
-  value: LiveCellPresentation,
-): (() => void) => {
-  const token = Symbol(cellId)
-  const cells =
-    presentations.get(bufferId) ??
-    new Map<string, { token: symbol; value: LiveCellPresentation }>()
-  cells.set(cellId, { token, value })
-  presentations.set(bufferId, cells)
-
-  return () => {
-    const current = presentations.get(bufferId)?.get(cellId)
-    if (current?.token !== token) return
-    cells.delete(cellId)
-    if (cells.size === 0) presentations.delete(bufferId)
-  }
-}
-
-export const readLiveCellPresentation = (
-  bufferId: number,
-  cellId: string,
-): LiveCellPresentation | undefined =>
-  presentations.get(bufferId)?.get(cellId)?.value
-
-const gridContainerWidths = new Map<number, number>()
-
-// Tool mutations resolve the tier a new grid.w produces from the same
-// measured container width as the renderer, published once per notebook.
-export const publishGridContainerWidth = (
-  bufferId: number,
-  width: number,
-): (() => void) => {
-  gridContainerWidths.set(bufferId, width)
-  return () => {
-    if (gridContainerWidths.get(bufferId) === width) {
-      gridContainerWidths.delete(bufferId)
-    }
-  }
-}
-
-export const readGridContainerWidth = (bufferId: number): number | undefined =>
-  gridContainerWidths.get(bufferId)
-
-export const __resetNotebookPresentationStoreForTests = (): void => {
-  presentations.clear()
-  gridContainerWidths.clear()
-}
diff --git a/src/scenes/Editor/Notebook/notebookUtils.test.ts b/src/scenes/Editor/Notebook/notebookUtils.test.ts
index c0a347c3a..0fa92dabf 100644
--- a/src/scenes/Editor/Notebook/notebookUtils.test.ts
+++ b/src/scenes/Editor/Notebook/notebookUtils.test.ts
@@ -9,7 +9,7 @@ import {
   AUTO_REFRESH_OPTIONS,
   isAutoRefresh,
   resolveCellView,
-  resolveAgentCellPresentation,
+  agentCellPresentation,
   resolveCellPaneLayout,
   resolveRunAction,
   buildAppliedCells,
@@ -17,7 +17,7 @@ import {
   buildInitialScriptResults,
   buildPersistPayload,
   capResultBytes,
-  cellHeightPatchForRows,
+  paneHeightsFromGridRows,
   cellModeChangePatch,
   cellToolbarMenuFlags,
   cellToolbarTier,
@@ -30,6 +30,7 @@ import {
   computeAgentCellGridH,
   computeCellGridH,
   computeCellHeights,
+  computeCellMaxGridH,
   computeCellMinGridH,
   computeResultBottomHeight,
   DEFAULT_CHART_BOTTOM_HEIGHT,
@@ -392,7 +393,7 @@ describe("buildPersistPayload", () => {
           result: undefined,
           lastRunStatus: "cancelled",
           lastRunError: undefined,
-          preferredView: "editor_result",
+          paneView: "editor_result",
         },
       ],
       focusedCellId: "a",
@@ -914,7 +915,7 @@ describe("buildAppliedCells", () => {
     // 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].preferredView).toBeUndefined()
+    expect(nextCells[0].paneView).toBeUndefined()
   })
 
   it("accepts an echoed kind on an existing cell", () => {
@@ -1263,7 +1264,7 @@ describe("buildAppliedCells", () => {
     })
     // No stored key: the cell inherits the notebook default.
     expect("autoRefresh" in nextCells[0]).toBe(false)
-    expect(nextCells[0].preferredView).toBe("result")
+    expect(nextCells[0].paneView).toBe("result")
   })
 
   it("applies semantic pane dimensions and view to a new draw cell", () => {
@@ -1273,7 +1274,7 @@ describe("buildAppliedCells", () => {
           value: "SELECT 1",
           mode: "draw",
           editorHeight: 120,
-          resultHeight: 280,
+          resultHeight: 300,
           view: "editor_result",
           chartConfig: {
             xColumn: "ts",
@@ -1286,9 +1287,9 @@ describe("buildAppliedCells", () => {
     expect(nextCells[0]).toMatchObject({
       topHeight: 120,
       topResized: true,
-      bottomHeight: 280,
+      bottomHeight: 300,
       bottomResized: true,
-      preferredView: "editor_result",
+      paneView: "editor_result",
     })
   })
 
@@ -1302,7 +1303,7 @@ describe("buildAppliedCells", () => {
       topResized: true,
       bottomHeight: 280,
       bottomResized: true,
-      preferredView: "editor_result",
+      paneView: "editor_result",
       chartConfig: {
         xColumn: "ts",
         queries: [{ type: "line", yColumns: ["v"] }],
@@ -1327,7 +1328,7 @@ describe("buildAppliedCells", () => {
       topResized: true,
       bottomHeight: 280,
       bottomResized: true,
-      preferredView: "editor_result",
+      paneView: "editor_result",
     })
   })
 
@@ -1362,7 +1363,7 @@ describe("buildAppliedCells", () => {
         value: "SELECT 1",
         mode: "run",
         autoRefresh: "5s",
-        preferredView: "result",
+        paneView: "result",
         chartConfig: {
           xColumn: "ts",
           queries: [{ type: "line", yColumns: ["v"] }],
@@ -1379,7 +1380,7 @@ describe("buildAppliedCells", () => {
     expect(nextCells[0].mode).toBe("run")
     expect(nextCells[0].chartConfig).toBeUndefined()
     expect(nextCells[0].autoRefresh).toBeUndefined()
-    expect(nextCells[0].preferredView).toBe("result")
+    expect(nextCells[0].paneView).toBe("result")
   })
 
   it("preserves draw mode when apply omits mode and supplies its full chart", () => {
@@ -1469,7 +1470,7 @@ describe("isDoubleView", () => {
         position: 0,
         value: "",
         mode: "draw",
-        preferredView: "result",
+        paneView: "result",
       }),
     ).toBe(true)
   })
@@ -1919,7 +1920,7 @@ describe("computeCellGridH", () => {
           value: "",
           topHeight: 72,
           bottomHeight: 104,
-          preferredView: "result",
+          paneView: "result",
           result: { results: [], activeResultIndex: 0, timestamp: 0 },
         },
         10,
@@ -1928,7 +1929,7 @@ describe("computeCellGridH", () => {
     ).toBe(6)
   })
 
-  it("compact cells derive height from exactly the visible pane", () => {
+  it("derives height from exactly the visible pane", () => {
     const cell: NotebookCell = {
       id: "x",
       position: 0,
@@ -1958,120 +1959,44 @@ describe("resolveCellPaneLayout", () => {
 
   it("shows only the editor when no result exists", () => {
     const cell: NotebookCell = { id: "x", position: 0, value: "" }
-    expect(resolveCellPaneLayout(cell, false, false)).toBe("editor")
-    expect(resolveCellPaneLayout(cell, false, true)).toBe("editor")
+    expect(resolveCellPaneLayout(cell, false)).toBe("editor")
   })
 
-  it("uses the authoritative preference for wide cells", () => {
-    expect(resolveCellPaneLayout(withResult(), false, false)).toBe("split")
+  it("uses the authoritative preference once a result exists", () => {
+    expect(resolveCellPaneLayout(withResult(), false)).toBe("split")
     expect(
-      resolveCellPaneLayout(
-        withResult({ preferredView: "result" }),
-        false,
-        false,
-      ),
+      resolveCellPaneLayout(withResult({ paneView: "result" }), false),
     ).toBe("result")
     expect(
-      resolveCellPaneLayout(
-        withResult({ preferredView: "editor" }),
-        false,
-        false,
-      ),
+      resolveCellPaneLayout(withResult({ paneView: "editor" }), false),
     ).toBe("editor")
   })
-
-  it("projects the authoritative preference for compact cells", () => {
-    expect(resolveCellPaneLayout(withResult(), false, true)).toBe("result")
-    expect(
-      resolveCellPaneLayout(
-        withResult({ preferredView: "editor" }),
-        false,
-        true,
-      ),
-    ).toBe("editor")
-    expect(
-      resolveCellPaneLayout(
-        withResult({ preferredView: "result" }),
-        false,
-        true,
-      ),
-    ).toBe("result")
-  })
 })
 
-describe("resolveAgentCellPresentation", () => {
+describe("agentCellPresentation", () => {
   const chart = (over: Partial<NotebookCell> = {}): NotebookCell => ({
     id: "x",
     position: 0,
     value: "SELECT 1",
     mode: "draw",
-    preferredView: "editor_result",
+    paneView: "editor_result",
     ...over,
   })
 
-  it("reports null pane views for a markdown cell in every tier", () => {
-    // Given a markdown cell
-    const markdown = chart({ mode: undefined, type: "markdown" })
-    // When its presentation resolves for an unmounted, wide, or compact cell
-    // Then preferred_view and view are null and tier is never reported
-    expect(resolveAgentCellPresentation(markdown)).toEqual({
-      preferred_view: null,
-      view: null,
-    })
-    expect(resolveAgentCellPresentation(markdown, false)).toEqual({
-      preferred_view: null,
-      view: null,
-    })
-    expect(resolveAgentCellPresentation(markdown, true)).toEqual({
-      preferred_view: null,
-      view: null,
-    })
-  })
-
-  it("returns the effective live view with its tier", () => {
-    expect(
-      resolveAgentCellPresentation(chart({ preferredView: "editor" }), false),
-    ).toEqual({
-      preferred_view: "editor",
+  it("reports the stored pane view", () => {
+    expect(agentCellPresentation(chart())).toEqual({ view: "editor_result" })
+    expect(agentCellPresentation(chart({ paneView: "editor" }))).toEqual({
       view: "editor",
-      tier: "wide",
-    })
-    expect(resolveAgentCellPresentation(chart(), true)).toEqual({
-      preferred_view: "editor_result",
-      view: "result",
-      tier: "compact",
     })
-  })
-
-  it("omits tier and returns the stored preference when inactive", () => {
-    expect(resolveAgentCellPresentation(chart(), undefined)).toEqual({
-      preferred_view: "editor_result",
+    expect(agentCellPresentation(chart({ paneView: undefined }))).toEqual({
+      view: "editor_result",
     })
   })
 
-  it("keeps preference stable while result availability and width change", () => {
-    const pending: NotebookCell = {
-      id: "x",
-      position: 0,
-      value: "SELECT 1",
-      lastRunStatus: "success",
-      preferredView: "editor_result",
-    }
-    expect(resolveAgentCellPresentation(pending, false, true)).toEqual({
-      preferred_view: "editor_result",
-      view: "editor_result",
-      tier: "wide",
-    })
-    expect(resolveAgentCellPresentation(pending, true, true)).toEqual({
-      preferred_view: "editor_result",
-      view: "result",
-      tier: "compact",
-    })
-    expect(resolveAgentCellPresentation(pending, false, false)).toEqual({
-      preferred_view: "editor_result",
-      view: "editor",
-      tier: "wide",
-    })
+  it("reports a null view for a markdown cell", () => {
+    expect(
+      agentCellPresentation(chart({ mode: undefined, type: "markdown" })),
+    ).toEqual({ view: null })
   })
 })
 
@@ -2100,7 +2025,7 @@ describe("computeCellMinGridH", () => {
       value: "",
       topHeight: 400,
       bottomHeight: 300,
-      preferredView: "result",
+      paneView: "result",
       result,
     }
 
@@ -2118,11 +2043,11 @@ describe("computeCellMinGridH", () => {
       bottomHeight: 350,
     }
 
-    // 400px editor + 240px chart minimum + 50px split chrome requires 24 rows.
-    expect(computeCellMinGridH(cell, 10, 20)).toBe(24)
+    // 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 in compact layouts", () => {
+  it("uses only the visible pane minimum for editor-only and result-only layouts", () => {
     const cell: NotebookCell = {
       id: "x",
       position: 0,
@@ -2148,7 +2073,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)
@@ -2177,20 +2102,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,
@@ -2273,7 +2198,7 @@ describe("hasAgentVisibleCellHeightChanged", () => {
   })
 })
 
-describe("cellHeightPatchForRows", () => {
+describe("paneHeightsFromGridRows", () => {
   const withResult = (over: Partial<NotebookCell> = {}): NotebookCell => ({
     id: "x",
     position: 0,
@@ -2286,7 +2211,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({})
   })
@@ -2296,17 +2221,17 @@ 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 })
   })
@@ -2316,7 +2241,7 @@ describe("cellHeightPatchForRows", () => {
 
     // The split minimum is 400px editor + 100px result + 50px chrome,
     // or 19 rows. Resizing to that floor changes only the result pane.
-    const patch = cellHeightPatchForRows(c, 19, 10, 20)
+    const patch = paneHeightsFromGridRows(c, 19, 10, 20)
 
     expect(patch).toEqual({ bottomHeight: 100, bottomResized: true })
     expect(patch).not.toHaveProperty("topHeight")
@@ -2328,11 +2253,11 @@ describe("cellHeightPatchForRows", () => {
     const c = withResult({
       topHeight: 72,
       bottomHeight: 100,
-      preferredView: "result",
+      paneView: "result",
     })
     // When a taller height is requested (targetContentPx = 430 - 44 = 386,
     // and no editor allocation in its visible footprint)
-    const patch = cellHeightPatchForRows(c, 15, 10, 20)
+    const patch = paneHeightsFromGridRows(c, 15, 10, 20)
     // Then only the result changes; the remembered editor height is untouched
     expect(patch).toEqual({
       bottomHeight: 386,
@@ -2340,14 +2265,14 @@ describe("cellHeightPatchForRows", () => {
     })
   })
 
-  it("compact editor/result resize only their visible pane", () => {
+  it("editor-only and result-only cells resize only their visible pane", () => {
     const c = withResult({ topHeight: 200, bottomHeight: 300 })
 
-    expect(cellHeightPatchForRows(c, 10, 10, 20, false, "editor")).toEqual({
+    expect(paneHeightsFromGridRows(c, 10, 10, 20, false, "editor")).toEqual({
       topHeight: 236,
       topResized: true,
     })
-    expect(cellHeightPatchForRows(c, 15, 10, 20, false, "result")).toEqual({
+    expect(paneHeightsFromGridRows(c, 15, 10, 20, false, "result")).toEqual({
       bottomHeight: 386,
       bottomResized: true,
     })
@@ -2365,7 +2290,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 })
   })
@@ -2635,7 +2560,7 @@ describe("buildAppliedLayout", () => {
     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: "" }] },
@@ -2700,7 +2625,7 @@ describe("cloneNotebookViewState", () => {
         value: "SELECT 2",
         mode: "draw",
         autoRefresh: true,
-        preferredView: "result",
+        paneView: "result",
         chartConfig: {
           xColumn: "ts",
           queries: [{ type: "line", yColumns: ["v"] }],
@@ -2774,7 +2699,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].preferredView).toBe("result")
+    expect(out.cells[1].paneView).toBe("result")
     expect(out.cells[1].chartConfig).toEqual({
       xColumn: "ts",
       queries: [{ type: "line", yColumns: ["v"] }],
@@ -3117,92 +3042,70 @@ 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 }
-    // When the user runs
-    // Then it reveals the grid first, then runs
-    expect(resolveRunAction(cell, { ...opts, intent: "all" })).toEqual({
-      kind: "run-all",
-      reveal: true,
-      exitDraw: false,
-    })
-    expect(resolveRunAction(cell, { ...opts, intent: "single" })).toEqual({
-      kind: "run-single",
-      reveal: true,
-      exitDraw: false,
-    })
-  })
-
-  it("reveals a wide run cell whose result is hidden by an editor preference", () => {
-    // Given a wide run cell whose stored preference hides the result
+  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,
-      preferredView: "editor" as const,
+      paneView: "editor" as const,
     }
-    const opts = { isCompactTier: false, showBottomSlot: false }
     // 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 wide draw cell that has no result yet", () => {
-    // Given a wide draw cell whose chart has not landed (bottom slot hidden)
+  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,
-      preferredView: "editor_result" as const,
+      paneView: "editor_result" as const,
     }
-    const opts = { isCompactTier: false, showBottomSlot: false }
     // 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, { ...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",
     })
   })
@@ -3210,29 +3113,31 @@ describe("resolveRunAction", () => {
   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,
@@ -3312,7 +3217,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)
@@ -3327,6 +3232,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", () => {
@@ -3403,7 +3328,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", () => {
@@ -3413,10 +3338,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)
   })
 
@@ -3464,7 +3389,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
@@ -3472,7 +3397,7 @@ describe("cellToolbarMenuFlags", () => {
           f.showViewSql ||
             f.showViewTable ||
             f.showViewChart ||
-            f.showSplitItem,
+            f.showEditorToggleItem,
         )
         expect(f.groupBHasItems).toBe(
           f.showResetZoom ||
@@ -4176,3 +4101,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 cfcb76c80..6bfc84da0 100644
--- a/src/scenes/Editor/Notebook/notebookUtils.ts
+++ b/src/scenes/Editor/Notebook/notebookUtils.ts
@@ -1,7 +1,6 @@
 import type { QueryExecResult } from "../../../hooks/useQueryExecution"
 import type {
   AgentCellView,
-  AgentCellTier,
   AutoRefresh,
   AutoRefreshInterval,
   CellLayoutItem,
@@ -98,21 +97,15 @@ type RunActionPlan =
   | { kind: "run-all" | "run-single"; reveal: boolean; exitDraw: boolean }
 
 export const resolveRunAction = (
-  cell: Pick<NotebookCell, "mode" | "result" | "preferredView">,
-  opts: {
-    isCompactTier: boolean
-    showBottomSlot: boolean
-    intent: "all" | "single"
-  },
+  cell: Pick<NotebookCell, "mode" | "result" | "paneView">,
+  opts: { intent: "all" | "single" },
 ): RunActionPlan => {
-  const hiddenByPreference = cell.preferredView === "editor"
-  const reveal =
-    !opts.showBottomSlot && (opts.isCompactTier || hiddenByPreference)
+  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 editor view:
-  // 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 {
@@ -126,7 +119,6 @@ export type CellToolbarTier = "compact" | "standard" | "expanded"
 
 export const CELL_TOOLBAR_STANDARD_MIN = 480
 export const CELL_TOOLBAR_EXPANDED_MIN = 720
-export const NOTEBOOK_GRID_MARGIN_X = 20
 
 export const cellToolbarTier = (
   width: number,
@@ -138,26 +130,11 @@ export const cellToolbarTier = (
       ? "standard"
       : "compact"
 
-export const gridCellToolbarTier = (
-  containerWidth: number,
-  widthInColumns: number,
-): CellToolbarTier => {
-  const columnWidth =
-    (containerWidth - NOTEBOOK_GRID_MARGIN_X * (NOTEBOOK_GRID_COLS - 1)) /
-    NOTEBOOK_GRID_COLS
-  const itemWidth =
-    columnWidth * widthInColumns +
-    NOTEBOOK_GRID_MARGIN_X * Math.max(0, widthInColumns - 1)
-  // CellWrapper contributes a one-pixel border on each side; the header's
-  // ResizeObserver measures the inner border box.
-  return cellToolbarTier(Math.max(0, itemWidth - 2), false)
-}
-
 export type CellToolbarMenuFlags = {
   showViewSql: boolean
   showViewTable: boolean
   showViewChart: boolean
-  showSplitItem: boolean
+  showEditorToggleItem: boolean
   showResetZoom: boolean
   showAutoRefreshItem: boolean
   showRefreshItem: boolean
@@ -173,7 +150,9 @@ 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 editor" state.
+// 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
@@ -199,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.
@@ -211,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
@@ -229,7 +208,7 @@ export const cellToolbarMenuFlags = (params: {
     showViewSql,
     showViewTable,
     showViewChart,
-    showSplitItem,
+    showEditorToggleItem,
     showResetZoom,
     showAutoRefreshItem,
     showRefreshItem,
@@ -239,7 +218,7 @@ export const cellToolbarMenuFlags = (params: {
     showDuplicate,
     showDelete,
     groupAHasItems:
-      showViewSql || showViewTable || showViewChart || showSplitItem,
+      showViewSql || showViewTable || showViewChart || showEditorToggleItem,
     groupBHasItems:
       showResetZoom ||
       showAutoRefreshItem ||
@@ -514,12 +493,10 @@ export const stripCellResults = (cells: NotebookCell[]): NotebookCell[] =>
       lastRunStatus: carriedRunStatus(cell),
       lastRunError: carriedRunError(cell),
     }
-    if (cell.type === "markdown") delete persisted.preferredView
-    else persisted.preferredView = cell.preferredView ?? "editor_result"
+    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
-    delete canonical.wideView
-    delete canonical.compactView
     return persisted
   })
 
@@ -627,7 +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.preferredView
+  if (created.type === "markdown") delete created.paneView
   const newCell: NotebookCell =
     created.type === "markdown" || created.topHeight !== undefined
       ? created
@@ -1215,9 +1192,27 @@ export const buildAppliedCells = (
         "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.preferredView = "result"
+      dimensionsPatch.paneView = "result"
     }
     const autoRefresh =
       req.autoRefresh != null && resolvedType !== "markdown"
@@ -1270,7 +1265,7 @@ export const buildAppliedCells = (
       else delete next.autoRefresh
       Object.assign(next, dimensionsPatch)
       if (resolvedType !== "markdown") {
-        next.preferredView ??= "editor_result"
+        next.paneView ??= "editor_result"
         if (valueChanged && !existing.topResized) {
           const estimated = topHeightForSql(value)
           if (
@@ -1299,7 +1294,7 @@ export const buildAppliedCells = (
       return created
     }
     created.topHeight = topHeightForSql(value)
-    created.preferredView = "editor_result"
+    created.paneView = "editor_result"
     if (resolvedMode !== undefined) created.mode = resolvedMode
     if (chartConfig !== undefined) created.chartConfig = chartConfig
     if (autoRefresh !== undefined) created.autoRefresh = autoRefresh
@@ -1364,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 +
@@ -1372,10 +1367,12 @@ 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
@@ -1384,7 +1381,13 @@ 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 = 240
+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
@@ -1395,7 +1398,6 @@ export type AgentCellDimensions = {
   editorHeight?: AgentHeightValue
   resultHeight?: AgentHeightValue
   view?: AgentCellView | null
-  compact?: boolean
   expectingResult?: boolean
 }
 
@@ -1431,7 +1433,7 @@ export const agentCellDimensionsPatch = (
     patch.bottomResized = true
   }
   if (dimensions.view != null && cell.type !== "markdown") {
-    patch.preferredView = dimensions.view
+    patch.paneView = dimensions.view
   }
   return patch
 }
@@ -1557,51 +1559,30 @@ export const isDoubleView = (cell: NotebookCell): boolean => {
 
 export type CellPaneLayout = "editor" | "split" | "result"
 
-export const agentViewForPaneLayout = (
-  paneLayout: CellPaneLayout,
-): AgentCellView => (paneLayout === "split" ? "editor_result" : paneLayout)
-
 export const storedAgentCellView = (cell: NotebookCell): AgentCellView => {
   if (cell.type === "markdown") return "editor"
-  return cell.preferredView ?? "editor_result"
+  return cell.paneView ?? "editor_result"
 }
 
-export type AgentCellPresentation = {
-  preferred_view: AgentCellView | null
-  view?: AgentCellView | null
-  tier?: AgentCellTier
-}
+export type AgentCellPresentation = { view: AgentCellView | null }
 
-export const resolveAgentCellPresentation = (
+export const agentCellPresentation = (
   cell: NotebookCell,
-  compact?: boolean,
-  expectingResult: boolean = false,
-): AgentCellPresentation => {
-  if (cell.type === "markdown") return { preferred_view: null, view: null }
-  const preferredView = storedAgentCellView(cell)
-  if (compact === undefined) return { preferred_view: preferredView }
-  const paneLayout = resolveCellPaneLayout(cell, expectingResult, compact)
-  return {
-    preferred_view: preferredView,
-    view: agentViewForPaneLayout(paneLayout),
-    tier: compact ? "compact" : "wide",
-  }
-}
+): AgentCellPresentation => ({
+  view: cell.type === "markdown" ? null : storedAgentCellView(cell),
+})
 
-// Resolve one authoritative preference against live result availability and
-// width. Compact cells project editor_result to result; widening restores the
-// persisted preference without writing notebook state.
+// 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,
-  compact: boolean = false,
 ): CellPaneLayout => {
   const hasResult = isDoubleView(cell) || expectingResult
   if (!hasResult) return "editor"
-  const preferredView = storedAgentCellView(cell)
-  if (compact && preferredView === "editor_result") return "result"
-  if (preferredView === "editor") return "editor"
-  return preferredView === "result" ? "result" : "split"
+  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
@@ -1670,13 +1651,13 @@ 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"
+  resultHeight: number | "auto" | null
 } => {
   const pinnedHeight = (
     resized: boolean | undefined,
@@ -1684,7 +1665,7 @@ export const agentCellPaneDimensions = (
     minimum: number,
   ): number | "auto" =>
     resized && typeof height === "number" && Number.isFinite(height)
-      ? Math.max(minimum, height)
+      ? clampPaneHeight(minimum, height)
       : "auto"
 
   return {
@@ -1693,15 +1674,14 @@ export const agentCellPaneDimensions = (
       cell.topHeight,
       minTopHeightFor(cell),
     ),
-    ...(cell.type !== "markdown"
-      ? {
-          resultHeight: pinnedHeight(
+    resultHeight:
+      cell.type === "markdown"
+        ? null
+        : pinnedHeight(
             cell.bottomResized,
             cell.bottomHeight,
             minBottomHeightFor(cell),
           ),
-        }
-      : {}),
   }
 }
 
@@ -1792,20 +1772,45 @@ export const computeCellMinGridH = (
   const minTopPx =
     paneLayout === "result"
       ? 0
-      : paneLayout === "split"
-        ? Math.max(minTopHeightFor(cell), topHeight)
-        : minTopHeightFor(cell)
+      : 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)
@@ -1813,14 +1818,13 @@ export const snapMarkdownTopHeight = (px: number): number => {
 // loads, so agent-visible heights agree with the screen.
 export const computeAgentCellGridH = (
   cell: NotebookCell,
-  paneLayout?: CellPaneLayout,
+  expectingResult: boolean = isExpectingResult(cell, "unrequested"),
 ): number =>
   computeCellGridH(
     cell,
     NOTEBOOK_GRID_ROW_HEIGHT,
     NOTEBOOK_GRID_MARGIN_Y,
-    isExpectingResult(cell, "unrequested"),
-    paneLayout,
+    expectingResult,
   )
 
 export const hasAgentVisibleCellHeightChanged = (
@@ -1850,7 +1854,7 @@ export const partitionCellHeights = (
 // 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,
@@ -1870,18 +1874,18 @@ export const cellHeightPatchForRows = (
     cellChromePx(cell, expectingResult, paneLayout)
   if (paneLayout === "editor") {
     return {
-      topHeight: Math.max(minTopHeightFor(cell), targetContentPx),
+      topHeight: clampPaneHeight(minTopHeightFor(cell), targetContentPx),
       topResized: true,
     }
   }
   if (paneLayout === "result") {
     return {
-      bottomHeight: Math.max(minBottomHeightFor(cell), targetContentPx),
+      bottomHeight: clampPaneHeight(minBottomHeightFor(cell), targetContentPx),
       bottomResized: true,
     }
   }
   const { topHeight } = computeCellHeights(cell, { expectingResult })
-  const nextBottom = Math.max(
+  const nextBottom = clampPaneHeight(
     minBottomHeightFor(cell),
     targetContentPx - topHeight,
   )
diff --git a/src/store/notebook.ts b/src/store/notebook.ts
index 500877564..fe5474fcb 100644
--- a/src/store/notebook.ts
+++ b/src/store/notebook.ts
@@ -38,7 +38,9 @@ export type AutoRefresh = boolean | AutoRefreshInterval
 export type CellType = "sql" | "markdown"
 
 export type AgentCellView = "editor" | "result" | "editor_result"
-export type AgentCellTier = "compact" | "wide"
+
+export const isAgentCellView = (value: unknown): value is AgentCellView =>
+  value === "editor" || value === "result" || value === "editor_result"
 
 export type NotebookCell = {
   id: string
@@ -56,9 +58,9 @@ export type NotebookCell = {
   mode?: CellMode
   chartConfig?: ChartConfig
   autoRefresh?: AutoRefresh
-  // Authoritative, viewport-independent pane intent. The rendered view is
-  // derived from this preference, result availability, and current width.
-  preferredView?: AgentCellView
+  // 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
 }
@@ -152,7 +154,7 @@ export const createCell = (position: number, value = ""): NotebookCell => ({
   id: crypto.randomUUID(),
   position,
   value,
-  preferredView: "editor_result",
+  paneView: "editor_result",
 })
 
 export const createDefaultNotebookViewState = (): NotebookViewState => ({
diff --git a/src/utils/ai/notebookSnapshot.test.ts b/src/utils/ai/notebookSnapshot.test.ts
index b351869c5..7f2a34a02 100644
--- a/src/utils/ai/notebookSnapshot.test.ts
+++ b/src/utils/ai/notebookSnapshot.test.ts
@@ -25,10 +25,6 @@ import type {
   NotebookViewState,
 } from "../../store/notebook"
 import { createEmptyDigest } from "../../providers/AIConversationProvider/userActionDigest"
-import {
-  __resetNotebookPresentationStoreForTests,
-  publishLiveCellPresentation,
-} from "../../scenes/Editor/Notebook/notebookPresentationStore"
 
 const sql = (
   id: string,
@@ -82,7 +78,6 @@ beforeEach(async () => {
   __resetNotebookControllerForTests()
   __resetNotebookAIBridgeForTests()
   __resetNotebookBufferQueuesForTests()
-  __resetNotebookPresentationStoreForTests()
   await db.buffers.clear()
 })
 
@@ -226,61 +221,14 @@ describe("buildSnapshot", () => {
       expect(gridSnap.cells[0]).toMatchObject({
         editor_height: "auto",
         result_height: "auto",
-        preferred_view: "editor_result",
+        view: "editor_result",
       })
     } else {
       throw new Error("expected ok snapshots")
     }
   })
 
-  it("reports the effective view and tier of a live responsive cell", async () => {
-    const chart = sql("a", "SELECT 1", {
-      mode: "draw",
-      preferredView: "editor_result",
-    })
-    const id = await seedNotebook({ cells: [chart] })
-    registerController(makeController(id, [chart], {}))
-    const unpublish = publishLiveCellPresentation(id, "a", {
-      compact: true,
-      paneLayout: "editor",
-      expectingResult: false,
-    })
-
-    const snap = await buildSnapshot(id)
-    expect(snap?.status === "ok" ? snap.cells[0] : undefined).toMatchObject({
-      preferred_view: "editor_result",
-      view: "editor",
-      tier: "compact",
-    })
-    unpublish()
-  })
-
-  it("uses the published pane while a result is awaiting hydration", async () => {
-    const pending = sql("a", "SELECT 1", {
-      lastRunStatus: "success",
-      preferredView: "editor_result",
-    })
-    const id = await seedNotebook({ cells: [pending] })
-    registerController(makeController(id, [pending], {}))
-    const unpublish = publishLiveCellPresentation(id, "a", {
-      compact: true,
-      paneLayout: "result",
-      expectingResult: true,
-    })
-
-    const snap = await buildSnapshot(id)
-    expect(snap?.status === "ok" ? snap.cells[0] : undefined).toMatchObject({
-      view: "result",
-      tier: "compact",
-    })
-    expect(serializeCell([pending], "a", id, false)).toMatchObject({
-      view: "result",
-      tier: "compact",
-    })
-    unpublish()
-  })
-
-  it("reports null pane views and result height for a markdown cell", async () => {
+  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" })],
@@ -288,14 +236,12 @@ describe("buildSnapshot", () => {
     // When the snapshot builds
     const snap = await buildSnapshot(id)
     const cellSnapshot = snap?.status === "ok" ? snap.cells[0] : undefined
-    // Then the pane fields are null and tier is absent
+    // Then the pane fields are null
     expect(cellSnapshot).toMatchObject({
       type: "markdown",
-      preferred_view: null,
       view: null,
       result_height: null,
     })
-    expect(cellSnapshot?.tier).toBeUndefined()
     // And get_cell reports the same null pane fields
     const details = serializeCell(
       [sql("a", "# title", { type: "markdown" })],
@@ -304,33 +250,25 @@ describe("buildSnapshot", () => {
       false,
     )
     expect(details).toMatchObject({
-      preferred_view: null,
       view: null,
       result_height: null,
     })
-    expect(details.tier).toBeUndefined()
   })
 
-  it("omits tier and reports the stored preference for an inactive notebook", async () => {
+  it("reports the stored view for an inactive notebook", async () => {
     const id = await seedNotebook({
       cells: [
         sql("a", "SELECT 1", {
           mode: "draw",
-          preferredView: "editor_result",
+          paneView: "editor_result",
         }),
       ],
     })
 
     const snap = await buildSnapshot(id)
     expect(snap?.status === "ok" ? snap.cells[0] : undefined).toMatchObject({
-      preferred_view: "editor_result",
+      view: "editor_result",
     })
-    expect(
-      snap?.status === "ok" ? snap.cells[0].view : "unexpected",
-    ).toBeUndefined()
-    expect(
-      snap?.status === "ok" ? snap.cells[0].tier : "unexpected",
-    ).toBeUndefined()
   })
 
   it("round-trips a pinned result height while passive result data is unloaded", async () => {
@@ -409,7 +347,7 @@ describe("buildSnapshot", () => {
     const cell = sql("a", "SELECT 1", {
       mode: "draw",
       autoRefresh: "5s",
-      preferredView: "editor_result",
+      paneView: "editor_result",
       name: "Trades",
       chartConfig: {
         xColumn: "ts",
diff --git a/src/utils/ai/notebookSnapshot.ts b/src/utils/ai/notebookSnapshot.ts
index 940f6c164..904e4adc5 100644
--- a/src/utils/ai/notebookSnapshot.ts
+++ b/src/utils/ai/notebookSnapshot.ts
@@ -8,7 +8,6 @@ import { NotebookToolError } from "../notebooks/notebookToolError"
 import { sanitizeForPromptContext } from "./sanitizeForPromptContext"
 import type {
   AgentCellView,
-  AgentCellTier,
   AutoRefresh,
   CellLayoutItem,
   NotebookCell,
@@ -18,13 +17,9 @@ import type { UserActionDigest } from "../../providers/AIConversationProvider/ty
 import type { WorkspaceInfo } from "./executeAIFlow"
 import { normalizeVariables } from "../../scenes/Editor/Notebook/declareUtils"
 import {
-  type AgentCellPresentation,
   agentCellPaneDimensions,
-  agentViewForPaneLayout,
-  resolveAgentCellPresentation,
-  storedAgentCellView,
+  agentCellPresentation,
 } from "../../scenes/Editor/Notebook/notebookUtils"
-import { readLiveCellPresentation } from "../../scenes/Editor/Notebook/notebookPresentationStore"
 import { getCellRunStatus, type RunStatus } from "./runStatus"
 import type { ChartConfig } from "../../scenes/Editor/Notebook/CellChart/chartTypes"
 
@@ -58,11 +53,9 @@ export type NotebookContextCell = {
   type?: "sql" | "markdown"
   mode?: "run" | "draw"
   auto_refresh?: AutoRefresh
-  editor_height?: number | "auto"
-  result_height?: number | "auto" | null
-  preferred_view: AgentCellView | null
-  view?: AgentCellView | null
-  tier?: AgentCellTier
+  editor_height: number | "auto"
+  result_height: number | "auto" | null
+  view: AgentCellView | null
   chart_config?: ChartConfigWire
   last_run_status?: RunStatus
   last_run_error_summary?: string
@@ -166,20 +159,6 @@ const refreshFields = (
   }
 }
 
-const liveAgentCellPresentation = (
-  cell: NotebookCell,
-  bufferId: number,
-): AgentCellPresentation => {
-  if (cell.type === "markdown") return resolveAgentCellPresentation(cell)
-  const live = readLiveCellPresentation(bufferId, cell.id)
-  if (!live) return resolveAgentCellPresentation(cell)
-  return {
-    preferred_view: storedAgentCellView(cell),
-    view: agentViewForPaneLayout(live.paneLayout),
-    tier: live.compact ? ("compact" as const) : ("wide" as const),
-  }
-}
-
 const buildCell = (
   cell: NotebookCell,
   bufferId: number,
@@ -187,11 +166,13 @@ const buildCell = (
   layoutMode: "list" | "grid",
   refreshState: ReadonlyMap<string, CellRefreshView> | undefined,
 ): NotebookContextCell => {
-  const presentation = liveAgentCellPresentation(cell, bufferId)
+  const dimensions = agentCellPaneDimensions(cell)
   const out: NotebookContextCell = {
     id: cell.id,
     preview: preview(cell.value),
-    preferred_view: presentation.preferred_view,
+    editor_height: dimensions.editorHeight,
+    result_height: dimensions.resultHeight,
+    view: agentCellPresentation(cell).view,
     ...lastRunSummary(cell),
     ...refreshFields(refreshState?.get(cell.id)),
   }
@@ -203,13 +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
-  const dimensions = agentCellPaneDimensions(cell)
-  out.editor_height = dimensions.editorHeight
-  if (cell.type === "markdown") out.result_height = null
-  else if (dimensions.resultHeight !== undefined)
-    out.result_height = dimensions.resultHeight
-  if (presentation.view !== undefined) out.view = presentation.view
-  if (presentation.tier !== undefined) out.tier = presentation.tier
   const chartConfig = cell.chartConfig
   if (chartConfig && Array.isArray(chartConfig.queries)) {
     out.chart_config = toChartConfigWire(chartConfig)
@@ -330,13 +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.editor_height !== undefined)
-      lines.push(`      editor_height: ${c.editor_height}`)
-    if (c.result_height !== undefined)
-      lines.push(`      result_height: ${c.result_height}`)
-    lines.push(`      preferred_view: ${c.preferred_view}`)
-    if (c.view !== undefined) lines.push(`      view: ${c.view}`)
-    if (c.tier !== undefined) lines.push(`      tier: ${c.tier}`)
+    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(
@@ -477,10 +447,8 @@ export type NotebookCellDetails = {
   mode?: "run" | "draw"
   auto_refresh?: AutoRefresh
   editor_height: number | "auto"
-  result_height?: number | "auto" | null
-  preferred_view: AgentCellView | null
-  view?: AgentCellView | null
-  tier?: AgentCellTier
+  result_height: number | "auto" | null
+  view: AgentCellView | null
   chart_config?: ChartConfigWire
   last_run_status?: RunStatus
   last_run_error?: string
@@ -535,7 +503,6 @@ export const serializeCell = (
   const value = truncated ? cell.value.slice(0, CELL_VALUE_MAX) : cell.value
   const run = runStatusOf(cell)
   const dimensions = agentCellPaneDimensions(cell)
-  const presentation = liveAgentCellPresentation(cell, bufferId)
   const out: NotebookCellDetails = {
     id: cell.id,
     value,
@@ -543,11 +510,10 @@ export const serializeCell = (
     last_run_status: run.status,
     last_run_error: run.error,
     editor_height: dimensions.editorHeight,
-    preferred_view: presentation.preferred_view,
+    result_height: dimensions.resultHeight,
+    view: agentCellPresentation(cell).view,
     ...refreshFields(refreshState?.get(cell.id)),
   }
-  if (presentation.view !== undefined) out.view = presentation.view
-  if (presentation.tier !== undefined) out.tier = presentation.tier
   if (truncated) {
     out.truncated = true
     out.full_length = cell.value.length
@@ -556,9 +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 (cell.type === "markdown") out.result_height = null
-  else if (dimensions.resultHeight !== undefined)
-    out.result_height = dimensions.resultHeight
   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 cd8df2eff..57edaacc5 100644
--- a/src/utils/ai/prompts.ts
+++ b/src/utils/ai/prompts.ts
@@ -115,10 +115,10 @@ 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 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, preferred_view is the single stored, viewport-independent intent: editor, result, or editor_result. Effective view is derived from that preference, current result availability, and tier. Compact projects editor_result to result without rewriting preferred_view; widening restores editor_result. If a result is genuinely unavailable, effective view temporarily falls back to editor without rewriting preferred_view. Mounted SQL/draw cells report effective view and tier (wide/compact) as a pair; both are omitted when the cell is not rendered. Markdown has no pane-view state: it reports preferred_view, view, and result_height as null and never reports tier; keep view and result_height null when writing a markdown cell (any value is ignored). A non-maximized cell is compact below 480 CSS px of rendered inner width and wide at 480px or more, so panels/window resizing may change tier even if grid.w does not. Keep charts at result_height >= 240; use editor_height 86 for a polished markdown title (never use the 26px structural minimum for non-empty prose).
+- 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 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 dimension fields are the documented exception: null preserves their current setting. For a single targeted edit, prefer update_cell / set_cell_chart_config / set_cell_dimensions 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 d89e71683..75276d753 100644
--- a/src/utils/ai/shared.notebookTools.test.ts
+++ b/src/utils/ai/shared.notebookTools.test.ts
@@ -40,11 +40,6 @@ import { dispatchMCPTool } from "../mcp/dispatchMCPTool"
 import { EXPECTED_MCP_VERSION } from "../mcp/protocolVersion"
 import type { ToolExecutionContext } from "./shared"
 import { createNotebookFreshness } from "../notebooks/notebookFreshness"
-import {
-  __resetNotebookPresentationStoreForTests,
-  publishGridContainerWidth,
-  publishLiveCellPresentation,
-} from "../../scenes/Editor/Notebook/notebookPresentationStore"
 
 const cell = (
   id: string,
@@ -195,7 +190,6 @@ beforeEach(async () => {
   __resetNotebookControllerForTests()
   __resetNotebookAIBridgeForTests()
   __resetNotebookBufferQueuesForTests()
-  __resetNotebookPresentationStoreForTests()
   clearStatementClassCache()
   await db.buffers.clear()
   await db.notebook_results.clear()
@@ -694,7 +688,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
         topHeight: 200,
         topResized: true,
         bottomHeight: 350,
-        preferredView: "result",
+        paneView: "result",
       }),
     ])
 
@@ -704,7 +698,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
         buffer_id: 1,
         cell_id: "c",
         editor_height: "auto",
-        result_height: 280,
+        result_height: 300,
         view: null,
       },
       makeClient(),
@@ -712,24 +706,18 @@ describe("dispatchTool — notebook tools (happy path)", () => {
     )
 
     expect(res.is_error).toBeUndefined()
-    expect(JSON.parse(res.content)).toEqual({ preferred_view: "result" })
+    expect(JSON.parse(res.content)).toEqual({ view: "result" })
     expect(cellById(state, "c")).toMatchObject({
       topHeight: 72,
       topResized: false,
-      bottomHeight: 280,
+      bottomHeight: 300,
       bottomResized: true,
-      preferredView: "result",
+      paneView: "result",
     })
   })
 
-  it("set_cell_dimensions returns the effective compact fallback and tier", async () => {
+  it("set_cell_dimensions reports the cell view", async () => {
     const { state } = mountLive(1, [cell("c", "SELECT 1", { mode: "draw" })])
-    const unpublish = publishLiveCellPresentation(1, "c", {
-      compact: true,
-      paneLayout: "result",
-      expectingResult: false,
-    })
-
     const res = await dispatchTool(
       "set_cell_dimensions",
       {
@@ -743,23 +731,17 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       noopStatus,
     )
 
-    expect(JSON.parse(res.content)).toEqual({
-      preferred_view: "editor_result",
-      view: "result",
-      tier: "compact",
-      fallback: "editor_result_unavailable_in_compact",
-    })
-    expect(cellById(state, "c")?.preferredView).toBe("editor_result")
-    unpublish()
+    expect(JSON.parse(res.content)).toEqual({ view: "editor_result" })
+    expect(cellById(state, "c")?.paneView).toBe("editor_result")
   })
 
-  it("set_cell_layout returns the presentation produced by the new width", async () => {
+  it("set_cell_layout returns the stored view with the new position", async () => {
     const { state } = mountLive(
       1,
       [
         cell("c", "SELECT 1", {
           mode: "draw",
-          preferredView: "editor_result",
+          paneView: "editor_result",
         }),
       ],
       {
@@ -769,13 +751,6 @@ describe("dispatchTool — notebook tools (happy path)", () => {
         },
       },
     )
-    const unpublish = publishLiveCellPresentation(1, "c", {
-      compact: false,
-      paneLayout: "split",
-      expectingResult: false,
-    })
-    const unpublishWidth = publishGridContainerWidth(1, 1200)
-
     const res = await dispatchTool(
       "set_cell_layout",
       { buffer_id: 1, cell_id: "c", x: 0, y: 0, w: 4 },
@@ -785,13 +760,9 @@ describe("dispatchTool — notebook tools (happy path)", () => {
 
     expect(JSON.parse(res.content)).toEqual({
       grid: { x: 0, y: 0, w: 4 },
-      preferred_view: "editor_result",
-      view: "result",
-      tier: "compact",
+      view: "editor_result",
     })
     expect(state.parts.settings.layout?.[0].w).toBe(4)
-    unpublishWidth()
-    unpublish()
   })
 
   it("apply_notebook_state never synthesizes auto_refresh for draw cells", async () => {
@@ -1203,7 +1174,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       value: "SELECT 1",
       mode: "draw",
       autoRefresh: "5s",
-      preferredView: "result",
+      paneView: "result",
       chartConfig: {
         xColumn: "ts",
         queries: [
diff --git a/src/utils/notebooks/notebookAIBridge.test.ts b/src/utils/notebooks/notebookAIBridge.test.ts
index 07979d801..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,
-      setCellPreferredView: () => 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 631c8be83..989d97491 100644
--- a/src/utils/notebooks/notebookController/index.ts
+++ b/src/utils/notebooks/notebookController/index.ts
@@ -126,7 +126,7 @@ export {
   setCellLayoutTransition,
   setCellMaximizedTransition,
   setCellModeTransition,
-  setCellPreferredViewTransition,
+  setCellPaneViewTransition,
   setLayoutModeTransition,
   setNotebookAutoRefreshTransition,
   updateCellTransition,
diff --git a/src/utils/notebooks/notebookController/notebookTransitions.test.ts b/src/utils/notebooks/notebookController/notebookTransitions.test.ts
index 55849e7cf..cba9206a3 100644
--- a/src/utils/notebooks/notebookController/notebookTransitions.test.ts
+++ b/src/utils/notebooks/notebookController/notebookTransitions.test.ts
@@ -45,7 +45,7 @@ describe("setCellDimensionsTransition", () => {
       mode: "draw",
       topHeight: 72,
       bottomHeight: 350,
-      preferredView: "result",
+      paneView: "result",
     })
     const parts = partsOf([chart], {
       settings: {
@@ -56,20 +56,16 @@ describe("setCellDimensionsTransition", () => {
 
     const out = setCellDimensionsTransition(parts, BUFFER_ID, "a", {
       view: "editor_result",
-      compact: false,
+      expectingResult: false,
     })
 
     expect(out.parts.cells[0]).toMatchObject({
       topHeight: 72,
       bottomHeight: 350,
-      preferredView: "editor_result",
+      paneView: "editor_result",
     })
     expect(out.parts.settings.layout?.[0].h).toBe(17)
-    expect(out.result).toEqual({
-      preferred_view: "editor_result",
-      view: "editor_result",
-      tier: "wide",
-    })
+    expect(out.result).toEqual({ view: "editor_result" })
   })
 
   it("supports null preserve, auto reset, and a fixed result height", () => {
@@ -79,65 +75,26 @@ describe("setCellDimensionsTransition", () => {
       topResized: true,
       bottomHeight: 350,
       bottomResized: false,
-      preferredView: "result",
+      paneView: "result",
     })
 
     const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
       editorHeight: "auto",
-      resultHeight: 280,
+      resultHeight: 300,
       view: null,
     })
 
     expect(out.parts.cells[0]).toMatchObject({
       topHeight: 72,
       topResized: false,
-      bottomHeight: 280,
+      bottomHeight: 300,
       bottomResized: true,
-      preferredView: "result",
-    })
-    expect(out.result).toEqual({ preferred_view: "result" })
-  })
-
-  it("stores one editor preference and reports its compact projection", () => {
-    const chart = cell("a", "SELECT 1", {
-      mode: "draw",
-      preferredView: "result",
-    })
-
-    const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
-      view: "editor",
-      compact: true,
-    })
-
-    expect(out.parts.cells[0]).toMatchObject({
-      preferredView: "editor",
-    })
-    expect(out.result).toEqual({
-      preferred_view: "editor",
-      view: "editor",
-      tier: "compact",
+      paneView: "result",
     })
+    expect(out.result).toEqual({ view: "result" })
   })
 
-  it("reports the deterministic compact fallback without losing the wide preference", () => {
-    const chart = cell("a", "SELECT 1", { mode: "draw" })
-    const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
-      view: "editor_result",
-      compact: true,
-    })
-
-    expect(out.parts.cells[0]).toMatchObject({
-      preferredView: "editor_result",
-    })
-    expect(out.result).toEqual({
-      preferred_view: "editor_result",
-      view: "result",
-      tier: "compact",
-      fallback: "editor_result_unavailable_in_compact",
-    })
-  })
-
-  it("ignores view and result_height on a markdown cell and reports null views", () => {
+  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
@@ -149,34 +106,39 @@ describe("setCellDimensionsTransition", () => {
         editorHeight: 86,
         resultHeight: 300,
         view: "result",
-        compact: false,
+        expectingResult: false,
       },
     )
-    // Then only the editor height lands, and the views report null
+    // 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].preferredView).toBeUndefined()
-    expect(out.result).toEqual({ preferred_view: null, view: null })
+    expect(out.parts.cells[0].paneView).toBeUndefined()
+    expect(out.result).toEqual({ view: null })
   })
 
-  it("supports a genuine editor-only view in the wide tier", () => {
+  it("supports an editor-only view", () => {
     const chart = cell("a", "SELECT 1", { mode: "draw" })
     const out = setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
       view: "editor",
-      compact: false,
+      expectingResult: false,
     })
 
     expect(out.parts.cells[0]).toMatchObject({
-      preferredView: "editor",
-    })
-    expect(out.result).toEqual({
-      preferred_view: "editor",
-      view: "editor",
-      tier: "wide",
+      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", () => {
@@ -185,13 +147,13 @@ describe("setCellDimensionsTransition", () => {
       setCellDimensionsTransition(partsOf([chart]), BUFFER_ID, "a", {
         resultHeight: 100,
       }),
-    ).toThrow(/at least 240px/)
+    ).toThrow(/at least 296px/)
   })
 
-  it("uses the mounted missing-result state for presentation and height", () => {
+  it("uses the mounted missing-result state for the grid height", () => {
     const pending = cell("a", "SELECT 1", {
       lastRunStatus: "success",
-      preferredView: "editor_result",
+      paneView: "editor_result",
     })
     const out = setCellDimensionsTransition(
       partsOf([pending], {
@@ -202,46 +164,37 @@ describe("setCellDimensionsTransition", () => {
       }),
       BUFFER_ID,
       "a",
-      { compact: false, expectingResult: false },
+      { expectingResult: false },
     )
 
-    expect(out.result).toEqual({
-      preferred_view: "editor_result",
-      view: "editor",
-      tier: "wide",
-    })
+    expect(out.result).toEqual({ view: "editor_result" })
     expect(out.parts.settings.layout?.[0].h).toBe(5)
   })
 
-  it("persists a result preference while a missing result falls back to editor", () => {
+  it("persists a result view while the result is still missing", () => {
     const pending = cell("a", "SELECT 1", {
       lastRunStatus: "success",
-      preferredView: "editor_result",
+      paneView: "editor_result",
     })
     const out = setCellDimensionsTransition(
       partsOf([pending]),
       BUFFER_ID,
       "a",
-      { view: "result", compact: false, expectingResult: false },
+      { view: "result", expectingResult: false },
     )
 
-    expect(out.parts.cells[0].preferredView).toBe("result")
-    expect(out.result).toEqual({
-      preferred_view: "result",
-      view: "editor",
-      tier: "wide",
-      fallback: "requested_view_unavailable",
-    })
+    expect(out.parts.cells[0].paneView).toBe("result")
+    expect(out.result).toEqual({ view: "result" })
   })
 })
 
 describe("setCellLayoutTransition", () => {
   const chart = cell("a", "SELECT 1", {
     mode: "draw",
-    preferredView: "editor_result",
+    paneView: "editor_result",
   })
 
-  it("returns the projected live presentation after a width change", () => {
+  it("returns the stored view after a position change", () => {
     const out = setCellLayoutTransition(
       partsOf([chart], {
         settings: {
@@ -251,28 +204,12 @@ describe("setCellLayoutTransition", () => {
       }),
       BUFFER_ID,
       "a",
-      { x: 0, y: 0, w: 4, liveCompact: false, gridContainerWidth: 1200 },
+      { x: 0, y: 0, w: 4, expectingResult: false },
     )
 
     expect(out.result).toEqual({
       grid: { x: 0, y: 0, w: 4 },
-      preferred_view: "editor_result",
-      view: "result",
-      tier: "compact",
-    })
-  })
-
-  it("omits effective presentation when no rendered geometry is available", () => {
-    const out = setCellLayoutTransition(
-      partsOf([chart], { settings: { layoutMode: "grid" } }),
-      BUFFER_ID,
-      "a",
-      { x: 0, y: 0, w: 4 },
-    )
-
-    expect(out.result).toEqual({
-      grid: { x: 0, y: 0, w: 4 },
-      preferred_view: "editor_result",
+      view: "editor_result",
     })
   })
 
diff --git a/src/utils/notebooks/notebookController/notebookTransitions.ts b/src/utils/notebooks/notebookController/notebookTransitions.ts
index 7ed27f229..7c9bdac60 100644
--- a/src/utils/notebooks/notebookController/notebookTransitions.ts
+++ b/src/utils/notebooks/notebookController/notebookTransitions.ts
@@ -22,21 +22,20 @@ import {
   clearCellAutoRefresh,
   computeAgentCellGridH,
   duplicateCellAt,
-  gridCellToolbarTier,
   insertCell,
-  isExpectingResult,
   mergeCellChartConfig,
+  MAX_PANE_HEIGHT_PX,
   minBottomHeightFor,
   minTopHeightFor,
   nextGridSeedPosition,
   reconcileCellResultForValue,
-  resolveAgentCellPresentation,
+  agentCellPresentation,
+  type AgentCellPresentation,
   removeCell,
   swapCellDown,
   swapCellUp,
   topHeightForSql,
   upsertCellLayout,
-  resolveCellPaneLayout,
   type CellGridPosition,
   type AgentCellDimensions,
 } from "../../../scenes/Editor/Notebook/notebookUtils"
@@ -287,37 +286,18 @@ export const setCellLayoutTransition = (
   parts: ViewParts,
   bufferId: number,
   cellId: string,
-  pos: Omit<CellGridPosition, "h"> & {
-    liveCompact?: boolean
-    liveExpectingResult?: boolean
-    gridContainerWidth?: number
-  },
+  pos: Omit<CellGridPosition, "h"> & { expectingResult?: boolean },
 ): NotebookTransitionResult<
-  ReturnType<typeof resolveAgentCellPresentation> & {
-    grid: { x: number; y: number; w: number }
-  }
+  AgentCellPresentation & { grid: { x: number; y: number; w: number } }
 > => {
   const cell = requireCellIn(parts.cells, cellId, bufferId)
   const gridError = cellGridBoundsError(pos)
   if (gridError) throw new NotebookToolError("validation", gridError)
-  const compact =
-    parts.settings.layoutMode === "grid"
-      ? pos.gridContainerWidth !== undefined
-        ? gridCellToolbarTier(pos.gridContainerWidth, pos.w) === "compact"
-        : undefined
-      : pos.liveCompact
-  const expectingResult =
-    pos.liveExpectingResult ?? isExpectingResult(cell, "unrequested")
-  const paneLayout = resolveCellPaneLayout(
-    cell,
-    expectingResult,
-    compact === true,
-  )
   const layoutPos: CellGridPosition = {
     x: pos.x,
     y: pos.y,
     w: pos.w,
-    h: computeAgentCellGridH(cell, paneLayout),
+    h: computeAgentCellGridH(cell, pos.expectingResult),
   }
   return {
     parts: {
@@ -329,7 +309,7 @@ export const setCellLayoutTransition = (
     },
     result: {
       grid: { x: pos.x, y: pos.y, w: pos.w },
-      ...resolveAgentCellPresentation(cell, compact, expectingResult),
+      ...agentCellPresentation(cell),
     },
     touchedCellId: cellId,
   }
@@ -340,13 +320,7 @@ export const setCellDimensionsTransition = (
   bufferId: number,
   cellId: string,
   requested: AgentCellDimensions,
-): NotebookTransitionResult<
-  ReturnType<typeof resolveAgentCellPresentation> & {
-    fallback?:
-      | "editor_result_unavailable_in_compact"
-      | "requested_view_unavailable"
-  }
-> => {
+): NotebookTransitionResult<AgentCellPresentation> => {
   const cell = requireCellIn(parts.cells, cellId, bufferId)
   const dimensions = applicableCellDimensions(cell, requested)
   if (
@@ -369,36 +343,28 @@ export const setCellDimensionsTransition = (
       `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 expectingResult =
-    dimensions.expectingResult ?? isExpectingResult(nextCell, "unrequested")
-  const paneLayout = resolveCellPaneLayout(
-    nextCell,
-    expectingResult,
-    dimensions.compact === true,
-  )
   const layout = parts.settings.layout?.map((item) =>
     item.i === cellId
-      ? { ...item, h: computeAgentCellGridH(nextCell, paneLayout) }
+      ? {
+          ...item,
+          h: computeAgentCellGridH(nextCell, dimensions.expectingResult),
+        }
       : item,
   )
-  const presentation = resolveAgentCellPresentation(
-    nextCell,
-    dimensions.compact,
-    expectingResult,
-  )
-  const fallback =
-    presentation.view !== undefined &&
-    dimensions.view === "editor_result" &&
-    presentation.view === "result"
-      ? "editor_result_unavailable_in_compact"
-      : presentation.view !== undefined &&
-          dimensions.view != null &&
-          dimensions.view !== presentation.view
-        ? "requested_view_unavailable"
-        : undefined
   return {
     parts: {
       ...parts,
@@ -411,10 +377,7 @@ export const setCellDimensionsTransition = (
           ? parts.settings
           : { ...parts.settings, layout },
     },
-    result: {
-      ...presentation,
-      ...(fallback !== undefined ? { fallback } : {}),
-    },
+    result: agentCellPresentation(nextCell),
     touchedCellId: cellId,
   }
 }
@@ -460,24 +423,24 @@ export const setCellChartConfigTransition = (
   }
 }
 
-export const setCellPreferredViewTransition = (
+export const setCellPaneViewTransition = (
   parts: ViewParts,
   bufferId: number,
   cellId: string,
-  preferredView: AgentCellView,
+  paneView: AgentCellView,
 ): NotebookTransitionResult => {
   const cell = requireCellIn(parts.cells, cellId, bufferId)
   if (cell.type === "markdown") {
     throw new NotebookToolError(
       "validation",
-      "Markdown cells have no pane-view preference.",
+      "Markdown cells have no pane view.",
     )
   }
   return {
     parts: {
       ...parts,
       cells: patchCellIn(parts.cells, cellId, {
-        preferredView,
+        paneView,
       }),
     },
     result: undefined,
diff --git a/src/utils/notebooks/notebookDexieController.test.ts b/src/utils/notebooks/notebookDexieController.test.ts
index 036a82b57..fb8bd8663 100644
--- a/src/utils/notebooks/notebookDexieController.test.ts
+++ b/src/utils/notebooks/notebookDexieController.test.ts
@@ -360,7 +360,7 @@ describe("createDexieNotebookController — settings & layout", () => {
   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", { preferredView: "result" })],
+      cells: [cell("a", "SELECT 1", { paneView: "result" })],
     })
     const controller = makeController()
     await controller.setCellMode("a", "draw")
@@ -368,7 +368,7 @@ describe("createDexieNotebookController — settings & layout", () => {
     expect(view.cells[0]).toMatchObject({
       mode: "draw",
       bottomHeight: 350,
-      preferredView: "result",
+      paneView: "result",
     })
   })
 
@@ -1261,7 +1261,7 @@ describe("createDexieNotebookController — field preservation", () => {
         cell("a", "SELECT 1", {
           autoRefresh: "5s",
           chartConfig: chartFor("ts"),
-          preferredView: "result",
+          paneView: "result",
         }),
         cell("b", "SELECT 2", { position: 1, chartConfig: chartFor("sym") }),
       ],
@@ -1289,7 +1289,7 @@ describe("createDexieNotebookController — field preservation", () => {
     expect(a).toMatchObject({
       autoRefresh: "5s",
       chartConfig: chartFor("ts"),
-      preferredView: "result",
+      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
index e989ab140..c971f22c1 100644
--- a/src/utils/notebooks/notebookDexieView.test.ts
+++ b/src/utils/notebooks/notebookDexieView.test.ts
@@ -19,14 +19,11 @@ describe("migratePersistedNotebookView preferred view", () => {
     [true, "result"],
     [false, "editor_result"],
     [undefined, "editor_result"],
-  ] as const)(
-    "maps main's isViewMaximized=%s to %s",
-    (legacy, preferredView) => {
-      const cell = migratePersistedNotebookView(legacyView(legacy)).cells[0]
-      expect(cell.preferredView).toBe(preferredView)
-      expect(cell).not.toHaveProperty("isViewMaximized")
-    },
-  )
+  ] 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 = {
@@ -36,13 +33,13 @@ describe("migratePersistedNotebookView preferred view", () => {
           position: 0,
           value: "# Title",
           type: "markdown",
-          preferredView: "result",
+          paneView: "result",
           isViewMaximized: true,
         },
       ],
     } as unknown as NotebookViewState
     const cell = migratePersistedNotebookView(view).cells[0]
-    expect(cell).not.toHaveProperty("preferredView")
+    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 a5b266844..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,40 +27,29 @@ type NotebookBufferMeta =
   | { kind: "deleted" }
   | { kind: "not_a_notebook" }
 
-const isAgentCellView = (
-  value: unknown,
-): value is NotebookCell["preferredView"] =>
-  value === "editor" || value === "result" || value === "editor_result"
-
-// Main persisted `isViewMaximized`; the wide/compact fields never shipped.
-// Materialize one viewport-independent preference and remove every legacy
-// presentation key from the runtime view.
-const migrateCellPreferredView = (cell: NotebookCell): NotebookCell => {
+// 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.preferredView
+    delete next.paneView
     delete next.isViewMaximized
-    delete next.wideView
-    delete next.compactView
     return next as NotebookCell
   }
-  const preferredView = isAgentCellView(raw.preferredView)
-    ? raw.preferredView
+  const paneView = isAgentCellView(raw.paneView)
+    ? raw.paneView
     : raw.isViewMaximized === true
       ? "result"
       : "editor_result"
-  const next = { ...raw, preferredView } as NotebookCell &
-    Record<string, unknown>
+  const next = { ...raw, paneView } as NotebookCell & Record<string, unknown>
   delete next.isViewMaximized
-  delete next.wideView
-  delete next.compactView
   return next as NotebookCell
 }
 
 export const migratePersistedNotebookView = (view: NotebookViewState) => {
   const migrated = dropLegacyChartConfigs(migrateLegacyCellNames(view))
-  return { ...migrated, cells: migrated.cells.map(migrateCellPreferredView) }
+  return { ...migrated, cells: migrated.cells.map(migrateCellPaneView) }
 }
 
 export const readNotebookBufferMeta = async (
diff --git a/src/utils/tools/dispatch.ts b/src/utils/tools/dispatch.ts
index 0d198213b..179d5bda2 100644
--- a/src/utils/tools/dispatch.ts
+++ b/src/utils/tools/dispatch.ts
@@ -87,10 +87,7 @@ import {
   serializeCell,
   summarizeCells,
 } from "../ai/notebookSnapshot"
-import {
-  readGridContainerWidth,
-  readLiveCellPresentation,
-} from "../../scenes/Editor/Notebook/notebookPresentationStore"
+import { readCellHydration } from "../../scenes/Editor/Notebook/cellHydrationStore"
 import { generateId } from "../../scenes/Editor/Notebook/notebookUtils"
 import {
   copyNotebookSnapshots,
@@ -170,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),
         }),
       }
@@ -834,17 +834,12 @@ export const dispatchTool = async (
           runTransition(
             buffer_id,
             (parts) => {
-              const livePresentation = readLiveCellPresentation(
-                buffer_id,
-                cell_id,
-              )
+              const hydration = readCellHydration(buffer_id, cell_id)
               return setCellLayoutTransition(parts, buffer_id, cell_id, {
                 x,
                 y,
                 w,
-                liveCompact: livePresentation?.compact,
-                liveExpectingResult: livePresentation?.expectingResult,
-                gridContainerWidth: readGridContainerWidth(buffer_id),
+                expectingResult: hydration?.expectingResult,
               })
             },
             signal,
@@ -865,16 +860,12 @@ export const dispatchTool = async (
           runTransition(
             buffer_id,
             (parts) => {
-              const livePresentation = readLiveCellPresentation(
-                buffer_id,
-                cell_id,
-              )
+              const hydration = readCellHydration(buffer_id, cell_id)
               return setCellDimensionsTransition(parts, buffer_id, cell_id, {
                 editorHeight: editor_height,
                 resultHeight: result_height,
                 view,
-                compact: livePresentation?.compact,
-                expectingResult: livePresentation?.expectingResult,
+                expectingResult: hydration?.expectingResult,
               })
             },
             signal,