diff --git a/e2e/questdb b/e2e/questdb
index 9b59a9211..9848be5f3 160000
--- a/e2e/questdb
+++ b/e2e/questdb
@@ -1 +1 @@
-Subproject commit 9b59a921165af573cedd22bf8b12613de19cb8bd
+Subproject commit 9848be5f3ad91796cabe5f098695919b08e73769
diff --git a/src/consts/shared-definitions.json b/src/consts/shared-definitions.json
index 9432c14f1..a57a3f3a2 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 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, 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 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/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 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,
@@ -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 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,
+      "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": "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": ["buffer_id", "cell_id", "x", "y", "w", "h"]
+      "required": [
+        "buffer_id",
+        "cell_id",
+        "editor_height",
+        "result_height",
+        "view"
+      ]
     }
   },
   {
@@ -733,30 +785,6 @@
       "required": ["buffer_id", "cell_id", "name"]
     }
   },
-  {
-    "name": "set_cell_view_maximized",
-    "category": "free",
-    "surfaces": ["ai", "mcp"],
-    "mutatesNotebook": true,
-    "createsNotebook": false,
-    "description": "Toggle whether the cell's result view (chart OR table) fills the cell, hiding the editor. Applies to any cell that has a result — not just charts. For narrow cells, there is no split-view.  When this is false, the cell only shows the editor for narrow cells. For wide cells, it shows the editor and the result view if result exists.",
-    "inputSchema": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "buffer_id": {
-          "type": "number"
-        },
-        "cell_id": {
-          "type": "string"
-        },
-        "value": {
-          "type": "boolean"
-        }
-      },
-      "required": ["buffer_id", "cell_id", "value"]
-    }
-  },
   {
     "name": "apply_notebook_state",
     "category": "free",
@@ -836,7 +864,7 @@
               "type": {
                 "type": ["string", "null"],
                 "enum": ["sql", "markdown", null],
-                "description": "Cell kind. \"markdown\" makes this a rendered prose cell — `value` is markdown source, and `mode`/`chart_config` MUST be null (rejected otherwise). It is never executed or auto-run. Cell kind is STICKY: null/omitted preserves an existing cell's kind (it does NOT reset markdown cells to SQL); new cells default to \"sql\"."
+                "description": "Cell kind. \"markdown\" makes this a rendered prose cell — `value` is markdown source, and `mode`/`chart_config` MUST be null (rejected otherwise). It is never executed or auto-run. Cell kind is FIXED for the life of a cell: null/omitted preserves an existing cell's kind, and sending the other kind for an existing id is rejected — delete the cell and add a new one instead. New cells default to \"sql\"."
               },
               "mode": {
                 "type": ["string", "null"],
@@ -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. Ignored for markdown; keep it null."
+              },
+              "view": {
+                "anyOf": [
+                  {
+                    "type": "string",
+                    "enum": ["editor", "result", "editor_result"]
+                  },
+                  { "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."
               },
               "chart_config": {
                 "type": ["object", "null"],
@@ -960,22 +1010,24 @@
               "grid": {
                 "type": ["object", "null"],
                 "additionalProperties": false,
-                "description": "Grid position when layout_mode='grid'. The 12 columns apply to width only (w ≤ 12). Rendered cell box is h*10 + (h-1)*20 px (do NOT estimate with h*30); a fixed 44px header leaves (h*30 - 64)px of content; chart plots pad a further ~40px top and ~56-86px bottom. EXAMPLES: markdown h:3 -> 70px box / 26px text (the minimum); markdown h:5 -> 130px / 86px text (a title); chart h:10 -> 280px / ~140px of plot.",
+                "description": "Grid position when layout_mode='grid'. The 12 columns apply to width only (w ≤ 12); height is derived from editor_height, result_height, and view.",
                 "properties": {
                   "x": {
-                    "type": "integer"
+                    "type": "integer",
+                    "minimum": 0,
+                    "maximum": 11
                   },
                   "y": {
-                    "type": "integer"
+                    "type": "integer",
+                    "minimum": 0
                   },
                   "w": {
-                    "type": "integer"
-                  },
-                  "h": {
-                    "type": "integer"
+                    "type": "integer",
+                    "minimum": 1,
+                    "maximum": 12
                   }
                 },
-                "required": ["x", "y", "w", "h"]
+                "required": ["x", "y", "w"]
               }
             },
             "required": [
@@ -986,7 +1038,9 @@
               "type",
               "mode",
               "auto_refresh",
-              "is_view_maximized",
+              "editor_height",
+              "result_height",
+              "view",
               "chart_config",
               "grid"
             ]
@@ -1056,7 +1110,7 @@
     "surfaces": ["mcp"],
     "mutatesNotebook": false,
     "createsNotebook": false,
-    "description": "If notebook tools fail with BRIDGE_NOT_PAIRED, call get_pairing_credentials to begin pairing (the response includes a one-click URL to show the user; authentication runs in the browser, the bridge never sees credentials). Once paired, call get_workspace_state at the start of each notebook turn; the digest of edits since your last fetch is in get_recent_user_actions.\n\nReturn the current workspace + notebook context as text. Use this at the start of every notebook turn so you know which notebook is active, what cells exist, layout mode, chart configs, and last-run statuses. Pass include_user_events=true to also receive the digest of edits the user made since your last fetch.",
+    "description": "If notebook tools fail with BRIDGE_NOT_PAIRED, call get_pairing_credentials to begin pairing (the response includes a one-click URL to show the user; authentication runs in the browser, the bridge never sees credentials). Once paired, call get_workspace_state at the start of every notebook turn; the digest of edits since your last fetch is in get_recent_user_actions.\n\nReturn the current workspace + notebook context as text. Use this at the start of every notebook turn so you know which notebook is active, what cells exist, layout mode, chart configs, and last-run statuses. SQL/draw cells report 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/modules/ConsoleEventTracker/events.ts b/src/modules/ConsoleEventTracker/events.ts
index 90f6425bd..13eed171f 100644
--- a/src/modules/ConsoleEventTracker/events.ts
+++ b/src/modules/ConsoleEventTracker/events.ts
@@ -163,12 +163,12 @@ export enum ConsoleEvent {
   MCP_DUPLICATE_CELL = "mcp.duplicate_cell",
   MCP_SET_LAYOUT_MODE = "mcp.set_layout_mode",
   MCP_SET_CELL_LAYOUT = "mcp.set_cell_layout",
+  MCP_SET_CELL_DIMENSIONS = "mcp.set_cell_dimensions",
   MCP_SET_CELL_MODE = "mcp.set_cell_mode",
   MCP_SET_CELL_CHART_CONFIG = "mcp.set_cell_chart_config",
   MCP_SET_CELL_AUTOREFRESH = "mcp.set_cell_autorefresh",
   MCP_SET_NOTEBOOK_AUTOREFRESH = "mcp.set_notebook_autorefresh",
   MCP_SET_CELL_NAME = "mcp.set_cell_name",
-  MCP_SET_CELL_VIEW_MAXIMIZED = "mcp.set_cell_view_maximized",
   MCP_SET_CELL_MAXIMIZED = "mcp.set_cell_maximized",
   MCP_APPLY_NOTEBOOK_STATE = "mcp.apply_notebook_state",
   MCP_GET_TABLES = "mcp.get_tables",
diff --git a/src/scenes/Editor/Monaco/importTabs.test.ts b/src/scenes/Editor/Monaco/importTabs.test.ts
index 5e3cdd0d4..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 6bff47206..24a97f2e1 100644
--- a/src/scenes/Editor/Monaco/importTabs.ts
+++ b/src/scenes/Editor/Monaco/importTabs.ts
@@ -271,8 +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.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 88fe7d161..d79855fce 100644
--- a/src/scenes/Editor/Notebook/cells/Cell.tsx
+++ b/src/scenes/Editor/Notebook/cells/Cell.tsx
@@ -32,10 +32,12 @@ import {
   CELL_EDITOR_PADDING,
   isDoubleView,
   isExpectingResult,
-  MIN_BOTTOM_HEIGHT_PX,
+  minBottomHeightFor,
   resolveAutoRefresh,
+  resolveCellPaneLayout,
   resolveCellView,
 } from "../notebookUtils"
+import type { CellToolbarTier } from "../notebookUtils"
 import {
   useCellContentMode,
   useCellVirtualizationEngine,
@@ -51,6 +53,7 @@ import {
   useCellResizeOrchestration,
 } from "./useCellResizeOrchestration"
 import { CellBottomContent } from "./CellBottomContent"
+import { publishLiveCellPresentation } from "../notebookPresentationStore"
 import { getMonacoThemeName } from "../../../../utils/monacoInit"
 
 const EditorContainer = styled.div<{ $spotlight: boolean }>`
@@ -118,6 +121,7 @@ type Props = {
   isFocused: boolean
   isMaximized: boolean
   isRunning: boolean
+  toolbarTierOverride?: CellToolbarTier
 }
 
 const CellInner: React.FC<Props> = ({
@@ -129,6 +133,7 @@ const CellInner: React.FC<Props> = ({
   isFocused,
   isMaximized,
   isRunning,
+  toolbarTierOverride,
 }) => {
   const { setCellChartConfig, clearCellResult, updateCell, setFocusedCell } =
     useNotebookActions()
@@ -147,7 +152,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 +180,22 @@ const CellInner: React.FC<Props> = ({
   // in the grid item's height (both go through computeCellHeights).
   const expectingResult = isExpectingResult(cell, resultStatus)
   const doubleView = isDoubleView(cell) || expectingResult
-  // Compact can't split — one full-height pane: the result fills the cell by
-  // default, "View SQL" (isViewMaximized === false) shows the editor instead.
   const isCompactTier = toolbarTier === "compact"
-  const isViewMaximized = isCompactTier
-    ? doubleView && cell.isViewMaximized !== false
-    : doubleView && !!cell.isViewMaximized
-  const showBottomSlot = isViewMaximized || (doubleView && !isCompactTier)
-  const isSplit = doubleView && !isViewMaximized && !isCompactTier
+  const paneLayout = resolveCellPaneLayout(cell, expectingResult, isCompactTier)
+
+  useEffect(
+    () =>
+      publishLiveCellPresentation(bufferIdForEvents, cell.id, {
+        compact: isCompactTier,
+        paneLayout,
+        expectingResult,
+      }),
+    [bufferIdForEvents, cell.id, expectingResult, isCompactTier, paneLayout],
+  )
+
+  const resultOnly = paneLayout === "result"
+  const showBottomSlot = paneLayout !== "editor"
+  const isSplit = paneLayout === "split"
   const runActive = !isDrawMode && doubleView
   const view = resolveCellView(cell)
   const canRun = !!stripSQLComments(cell.value).trim()
@@ -234,7 +248,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(
@@ -425,6 +439,7 @@ const CellInner: React.FC<Props> = ({
         isRunning={isRunning}
         headerRef={headerRef}
         toolbarTier={toolbarTier}
+        paneLayout={paneLayout}
         chartZoomed={chartZoomed}
         left={
           <CellNameLabel
@@ -468,7 +483,7 @@ const CellInner: React.FC<Props> = ({
               view={view}
               cellAutoRefresh={cell.autoRefresh}
               autoRefreshDefault={autoRefreshDefault}
-              isViewMaximized={isViewMaximized}
+              paneLayout={paneLayout}
               isRunning={isRunning}
               isGridLoading={isGridLoading}
               isChartLoading={chartLoading}
@@ -480,7 +495,7 @@ const CellInner: React.FC<Props> = ({
             <CellViewToggle
               cellId={cell.id}
               view={view}
-              isViewMaximized={isViewMaximized}
+              paneLayout={paneLayout}
               isGridLoading={isGridLoading}
               isChartLoading={chartLoading}
               isRunning={isRunning}
@@ -490,7 +505,7 @@ const CellInner: React.FC<Props> = ({
           )
         }
       />
-      {!isViewMaximized && (
+      {!resultOnly && (
         <EditorContainer
           ref={editorContainerRef}
           $spotlight={isMaximized}
@@ -561,17 +576,17 @@ const CellInner: React.FC<Props> = ({
           doubleView={doubleView}
         />
       )}
-      {/* Bottom slot: result grid OR chart, OR chart filling the whole cell
-          when expanded. */}
+      {/* Bottom slot: result grid OR chart. Hiding the editor preserves this
+          pane's own height instead of borrowing the editor allocation. */}
       {showBottomSlot && (
         <BottomSlot
           ref={resultRef}
           $spotlight={isMaximized}
           style={
-            isViewMaximized
+            resultOnly
               ? isMaximized
                 ? { flex: 1 }
-                : { height: topHeight + bottomHeight }
+                : { height: bottomHeight }
               : isMaximized
                 ? { flex: 1 - spotlightEditorRatio }
                 : { height: bottomHeight }
@@ -598,10 +613,10 @@ const CellInner: React.FC<Props> = ({
       <ResizeHandle
         overlay
         targetRef={
-          isViewMaximized || showBottomSlot ? resultRef : editorContainerRef
+          resultOnly || showBottomSlot ? resultRef : editorContainerRef
         }
         onResize={
-          isViewMaximized
+          resultOnly
             ? maximizedChartResizeLive
             : showBottomSlot
               ? bottomResize.resizeLive
@@ -609,21 +624,16 @@ 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)
         }}
         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
+          resultOnly || 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..8f4189d92 100644
--- a/src/scenes/Editor/Notebook/cells/CellToolbar.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellToolbar.tsx
@@ -12,8 +12,6 @@ import {
   CornersOutIcon,
   CornersInIcon,
   ArrowClockwiseIcon,
-  ArrowsOutLineVerticalIcon,
-  ArrowsInLineVerticalIcon,
   GearIcon,
   TableIcon,
   ChartLineIcon,
@@ -29,7 +27,7 @@ import {
   resolveAutoRefresh,
   resolveCellView,
 } from "../notebookUtils"
-import type { CellToolbarTier } from "../notebookUtils"
+import type { CellPaneLayout, CellToolbarTier } from "../notebookUtils"
 import type { AutoRefresh, NotebookCell } from "../../../../store/notebook"
 import { useNotebookActions, useNotebookBufferId } from "../NotebookProvider"
 import { useCellFetchState } from "../cellRefresh/CellRefreshContext"
@@ -76,6 +74,7 @@ type Props = {
   isRunning?: boolean
   inline?: boolean
   toolbarTier?: CellToolbarTier
+  paneLayout?: CellPaneLayout
   chartZoomed?: boolean
 }
 
@@ -90,6 +89,7 @@ export const CellToolbar: React.FC<Props> = ({
   isRunning = false,
   inline,
   toolbarTier,
+  paneLayout,
   chartZoomed = false,
 }) => {
   const {
@@ -100,7 +100,7 @@ export const CellToolbar: React.FC<Props> = ({
     setFocusedCell,
     setMaximizedCellId,
     setCellRefresh,
-    setCellViewMaximized,
+    setCellPreferredView,
     setCellMode,
   } = useNotebookActions()
   const bufferId = useNotebookBufferId()
@@ -114,7 +114,8 @@ export const CellToolbar: React.FC<Props> = ({
   const isChartView = view === "chart"
   const isGridView = view === "grid"
   const isNoneView = view === "none"
-  const isViewMaximized = !isNoneView && !!cell.isViewMaximized
+  const resultOnly =
+    !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.
@@ -142,22 +143,23 @@ 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)
+    setCellPreferredView(cellId, "editor")
   }
   const handleViewTable = () => {
     if (isRunning) return
@@ -173,7 +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")
-    setCellViewMaximized(cellId, true)
+    setCellPreferredView(cellId, "result")
   }
   const handleViewChart = () => {
     if (isRunning) return
@@ -188,15 +190,15 @@ export const CellToolbar: React.FC<Props> = ({
       eventBus.publish(EventType.NOTEBOOK_CELL_DRAW, { cellId, maximize: true })
       return
     }
-    setCellViewMaximized(cellId, true)
+    setCellPreferredView(cellId, "result")
   }
   const handleToggleMaximizeView = () => {
     void trackEvent(ConsoleEvent.NOTEBOOK_CELL_VIEW_MAXIMIZE, {
-      isViewMaximized: !cell.isViewMaximized,
+      isViewMaximized: !resultOnly,
       view,
     })
     signalUserEdit(bufferId)
-    setCellViewMaximized(cellId, !cell.isViewMaximized)
+    setCellPreferredView(cellId, resultOnly ? "editor_result" : "result")
   }
   const handleMaximizeCell = () => {
     void trackEvent(ConsoleEvent.NOTEBOOK_CELL_MAXIMIZE, {
@@ -310,7 +312,7 @@ export const CellToolbar: React.FC<Props> = ({
                   onSelect={handleViewSql}
                   icon={<FileSqlIcon size={16} />}
                 >
-                  View SQL
+                  View editor
                 </DropdownMenu.Item>
               )}
               {showViewTable && (
@@ -340,15 +342,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"}
+                  {resultOnly ? "Show editor" : "Hide editor"}
                 </DropdownMenu.Item>
               )}
 
diff --git a/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx b/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
index f1ca2eabe..ce9d140b0 100644
--- a/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellViewToggle.tsx
@@ -1,14 +1,14 @@
 import React from "react"
 import styled from "styled-components"
-import {
-  TableIcon,
-  ArrowsOutLineVerticalIcon,
-  ArrowsInLineVerticalIcon,
-} from "@phosphor-icons/react"
+import { FileSqlIcon, TableIcon } from "@phosphor-icons/react"
 import { Reset } from "../../../../components/icons"
 import { Spinner } from "./Spinner"
 import { ChartIcon } from "./ChartIcon"
-import { IconButton, Tooltip } from "../../../../components"
+import {
+  IconButton,
+  PrimaryToggleButton,
+  Tooltip,
+} from "../../../../components"
 import {
   NotebookViewToggle,
   NotebookViewToggleSegment,
@@ -18,7 +18,7 @@ import { signalUserEdit } from "../../../../utils/notebooks/notebookAIBridge"
 import { eventBus } from "../../../../modules/EventBus"
 import { EventType } from "../../../../modules/EventBus/types"
 import { clearChartZoom } from "../cellVirtualization/chartZoomStore"
-import type { CellView } from "../notebookUtils"
+import type { CellPaneLayout, CellView } from "../notebookUtils"
 import { trackEvent } from "../../../../modules/ConsoleEventTracker"
 import { ConsoleEvent } from "../../../../modules/ConsoleEventTracker/events"
 
@@ -26,9 +26,12 @@ const DimSpinner = styled(Spinner)`
   opacity: 0.5;
 `
 
-// This control predates the general 3.4rem icon-button size and sits beside
-// the cell toolbar in a tightly constrained header. Preserve its original
-// 3rem height so the two control groups retain their vertical separation.
+const ViewActions = styled.div`
+  display: inline-flex;
+  align-items: center;
+`
+
+// Reset remains a compact auxiliary action beside the view controls.
 const ViewIconButton = styled(IconButton)`
   width: 4rem;
   min-width: 4rem;
@@ -44,14 +47,32 @@ const ViewIconButton = styled(IconButton)`
 const Divider = styled.div`
   width: 1px;
   align-self: stretch;
-  margin: 0.2rem 0;
+  margin: 0.3rem 0.6rem;
   background: ${({ theme }) => theme.color.interactionNeutral};
 `
 
+// Match the schema toolbar's auto-refresh toggle dimensions and interaction,
+// but keep editor visibility neutral rather than giving it an accent state.
+const EditorVisibilityToggle = styled(PrimaryToggleButton)`
+  &&:not(:disabled) {
+    width: auto;
+    padding: 0 1rem;
+    height: 3rem;
+    min-height: 3rem;
+    color: ${({ theme }) => theme.color.contentSecondary};
+  }
+
+  &&[data-selected="true"],
+  &&[data-selected="true"]:hover:not(:disabled) {
+    background: ${({ theme }) => theme.color.interactionNeutral};
+    color: ${({ theme }) => theme.color.contentPrimary};
+  }
+`
+
 type Props = {
   cellId: string
   view: CellView
-  isViewMaximized: boolean
+  paneLayout: CellPaneLayout
   isGridLoading: boolean
   isChartLoading: boolean
   isRunning: boolean
@@ -62,16 +83,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
@@ -101,15 +124,16 @@ export const CellViewToggle: React.FC<Props> = ({
       return
     }
     setCellMode(cellId, "run")
+    if (resultHidden) setCellPreferredView(cellId, "editor_result")
   }
-  const handleSplit = (e: React.MouseEvent) => {
+  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()
@@ -118,59 +142,58 @@ export const CellViewToggle: React.FC<Props> = ({
   }
 
   return (
-    <NotebookViewToggle role="group" aria-label="Cell result view">
-      <Tooltip content="Table">
-        <NotebookViewToggleSegment
-          type="button"
-          $size="md"
-          $active={view === "grid"}
-          $activeTone="neutral"
-          aria-pressed={view === "grid"}
-          aria-busy={view === "grid" && isGridLoading}
-          disabled={isRunning}
-          onClick={handleTable}
-          aria-label="View table"
-        >
-          {view === "grid" && isGridLoading ? (
-            <DimSpinner size={18} />
-          ) : (
-            <TableIcon />
-          )}
-          {showLabels && "Table"}
-        </NotebookViewToggleSegment>
-      </Tooltip>
-      <Tooltip content="Chart">
-        <NotebookViewToggleSegment
-          type="button"
-          $size="md"
-          $active={view === "chart"}
-          $activeTone="neutral"
-          aria-pressed={view === "chart"}
-          aria-busy={view === "chart" && isChartLoading}
-          disabled={isRunning}
-          onClick={handleChart}
-          aria-label="View chart"
-        >
-          {view === "chart" && isChartLoading ? (
-            <DimSpinner size={18} />
-          ) : (
-            <ChartIcon />
-          )}
-          {showLabels && "Chart"}
-        </NotebookViewToggleSegment>
-      </Tooltip>
+    <ViewActions>
+      <NotebookViewToggle role="group" aria-label="Cell result view">
+        <Tooltip content="Table">
+          <NotebookViewToggleSegment
+            type="button"
+            $size="md"
+            $active={view === "grid"}
+            $activeTone="neutral"
+            aria-pressed={view === "grid"}
+            aria-busy={view === "grid" && isGridLoading}
+            disabled={isRunning}
+            onClick={handleTable}
+            aria-label="View table"
+          >
+            {view === "grid" && isGridLoading ? (
+              <DimSpinner size={18} />
+            ) : (
+              <TableIcon />
+            )}
+            {showLabels && "Table"}
+          </NotebookViewToggleSegment>
+        </Tooltip>
+        <Tooltip content="Chart">
+          <NotebookViewToggleSegment
+            type="button"
+            $size="md"
+            $active={view === "chart"}
+            $activeTone="neutral"
+            aria-pressed={view === "chart"}
+            aria-busy={view === "chart" && isChartLoading}
+            disabled={isRunning}
+            onClick={handleChart}
+            aria-label="View chart"
+          >
+            {view === "chart" && isChartLoading ? (
+              <DimSpinner size={18} />
+            ) : (
+              <ChartIcon />
+            )}
+            {showLabels && "Chart"}
+          </NotebookViewToggleSegment>
+        </Tooltip>
+      </NotebookViewToggle>
       <Divider />
-      <Tooltip content={isViewMaximized ? "Split view" : "Maximize view"}>
-        <ViewIconButton
-          label={isViewMaximized ? "Split view" : "Maximize view"}
-          onClick={handleSplit}
+      <Tooltip content={resultOnly ? "Show editor" : "Hide editor"}>
+        <EditorVisibilityToggle
+          aria-label={resultOnly ? "Show editor" : "Hide editor"}
+          onClick={handleEditorVisibility}
+          selected={!resultOnly}
         >
-          {isViewMaximized ? (
-            <ArrowsInLineVerticalIcon />
-          ) : (
-            <ArrowsOutLineVerticalIcon />
-          )}
-        </ViewIconButton>
+          <FileSqlIcon size={18} />
+        </EditorVisibilityToggle>
       </Tooltip>
       {view === "chart" && chartZoomed && (
         <Tooltip content="Reset zoom">
@@ -179,6 +202,6 @@ export const CellViewToggle: React.FC<Props> = ({
           </ViewIconButton>
         </Tooltip>
       )}
-    </NotebookViewToggle>
+    </ViewActions>
   )
 }
diff --git a/src/scenes/Editor/Notebook/cells/CellWideActions.tsx b/src/scenes/Editor/Notebook/cells/CellWideActions.tsx
index c7df6a877..78fba089b 100644
--- a/src/scenes/Editor/Notebook/cells/CellWideActions.tsx
+++ b/src/scenes/Editor/Notebook/cells/CellWideActions.tsx
@@ -2,6 +2,7 @@ import React from "react"
 import { CellViewToggle } from "./CellViewToggle"
 import { CellRefreshButton } from "./CellRefreshButton"
 import type { AutoRefresh } from "../../../../store/notebook"
+import type { CellPaneLayout } from "../notebookUtils"
 
 type Props = {
   cellId: string
@@ -10,7 +11,7 @@ type Props = {
   view: "grid" | "chart"
   cellAutoRefresh: AutoRefresh | undefined
   autoRefreshDefault: AutoRefresh | undefined
-  isViewMaximized: boolean
+  paneLayout: CellPaneLayout
   isRunning: boolean
   isGridLoading: boolean
   isChartLoading: boolean
@@ -23,7 +24,7 @@ export const CellWideActions: React.FC<Props> = ({
   view,
   cellAutoRefresh,
   autoRefreshDefault,
-  isViewMaximized,
+  paneLayout,
   isRunning,
   isGridLoading,
   isChartLoading,
@@ -49,7 +50,7 @@ export const CellWideActions: React.FC<Props> = ({
     <CellViewToggle
       cellId={cellId}
       view={view}
-      isViewMaximized={isViewMaximized}
+      paneLayout={paneLayout}
       isGridLoading={isGridLoading}
       isChartLoading={isChartLoading}
       isRunning={isRunning}
diff --git a/src/scenes/Editor/Notebook/cells/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..4ce21c8e9 100644
--- a/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
+++ b/src/scenes/Editor/Notebook/cells/useCellRunActions.ts
@@ -46,7 +46,7 @@ export const useCellRunActions = ({
     runCell,
     setCellMode,
     clearCellResult,
-    setCellViewMaximized,
+    setCellPreferredView,
     getCellsSnapshot,
   } = useNotebookActions()
   const bufferIdForEvents = useNotebookBufferId()
@@ -210,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
@@ -232,16 +236,21 @@ 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) {
+        // 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,
+      setCellPreferredView,
       setCellMode,
       handleRunAll,
       handleRunSingle,
@@ -292,7 +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) 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)
@@ -301,7 +312,13 @@ 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,
+    setCellPreferredView,
+    showBottomSlot,
+  ])
 
   const isGridLoading = isRunning && firstRunRef.current
 
diff --git a/src/scenes/Editor/Notebook/index.tsx b/src/scenes/Editor/Notebook/index.tsx
index e68221c2c..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"
@@ -35,19 +43,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,
@@ -135,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;
@@ -155,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;
       }
@@ -180,7 +194,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]
@@ -207,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
 
@@ -333,13 +364,22 @@ type CellViewProps = {
   isFocused: boolean
   isMaximized: boolean
   isRunning: boolean
+  toolbarTierOverride?: CellToolbarTier
 }
 
-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 = () => {
@@ -390,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).
@@ -398,33 +439,22 @@ 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
   // 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 +463,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 +471,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 +505,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 +576,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 +618,7 @@ const GridLayout: React.FC = () => {
       cells,
       activeBuffer.id,
       resultHydration,
+      containerWidth,
     ],
   )
 
@@ -606,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]")
@@ -657,6 +718,7 @@ 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
new file mode 100644
index 000000000..580f9cb23
--- /dev/null
+++ b/src/scenes/Editor/Notebook/notebookPresentationStore.ts
@@ -0,0 +1,68 @@
+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 deaa6f9b9..c0a347c3a 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,
@@ -383,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" },
@@ -857,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", () => {
@@ -1033,16 +1098,12 @@ describe("buildAppliedCells", () => {
     expect(nextCells[0].value).toBe(hugeValue)
   })
 
-  it("rejects preserving an over-limit markdown cell flipped to sql", () => {
-    const hugeValue = Array(100_000).fill("x").join("\n")
-    const prev: NotebookCell[] = [
-      { id: "a", position: 0, value: hugeValue, type: "markdown" },
-    ]
+  it("rejects grid placement that extends beyond the notebook columns", () => {
     expect(() =>
-      buildAppliedCells(prev, {
-        cells: [{ id: "a", preserveValue: true, type: "sql" }],
+      buildAppliedCells([], {
+        cells: [{ value: "SELECT 1", grid: { x: 11, y: 0, w: 2 } }],
       }),
-    ).toThrow(/line limit/)
+    ).toThrow(/x \+ w must be at most 12/)
   })
 
   it("deletes cells whose ids are missing from the request", () => {
@@ -1187,7 +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: [
         {
@@ -1202,7 +1263,72 @@ describe("buildAppliedCells", () => {
     })
     // No stored key: the cell inherits the notebook default.
     expect("autoRefresh" in nextCells[0]).toBe(false)
-    expect(nextCells[0].isViewMaximized).toBe(true)
+    expect(nextCells[0].preferredView).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,
+      preferredView: "editor_result",
+    })
+  })
+
+  it("treats null semantic dimensions as preserve for an existing cell", () => {
+    const existing: NotebookCell = {
+      id: "a",
+      position: 0,
+      value: "SELECT 1",
+      mode: "draw",
+      topHeight: 120,
+      topResized: true,
+      bottomHeight: 280,
+      bottomResized: true,
+      preferredView: "editor_result",
+      chartConfig: {
+        xColumn: "ts",
+        queries: [{ type: "line", yColumns: ["v"] }],
+      },
+    }
+    const { nextCells } = buildAppliedCells([existing], {
+      cells: [
+        {
+          id: "a",
+          preserveValue: true,
+          mode: "draw",
+          editorHeight: null,
+          resultHeight: null,
+          view: null,
+          chartConfig: existing.chartConfig,
+        },
+      ],
+    })
+
+    expect(nextCells[0]).toMatchObject({
+      topHeight: 120,
+      topResized: true,
+      bottomHeight: 280,
+      bottomResized: true,
+      preferredView: "editor_result",
+    })
   })
 
   it("apply is a PUT: mode='draw' with no chart_config throws even when the existing cell had one (no merge)", () => {
@@ -1227,7 +1353,7 @@ describe("buildAppliedCells", () => {
     ).toThrow(/no chart_config/)
   })
 
-  it("preserves an existing mode while clearing omitted PUT fields", () => {
+  it("preserves existing mode and editor visibility while clearing omitted PUT fields", () => {
     // Given an existing run cell with optional chart presentation fields
     const prev: NotebookCell[] = [
       {
@@ -1236,7 +1362,7 @@ describe("buildAppliedCells", () => {
         value: "SELECT 1",
         mode: "run",
         autoRefresh: "5s",
-        isViewMaximized: true,
+        preferredView: "result",
         chartConfig: {
           xColumn: "ts",
           queries: [{ type: "line", yColumns: ["v"] }],
@@ -1253,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).toBeUndefined()
+    expect(nextCells[0].preferredView).toBe("result")
   })
 
   it("preserves draw mode when apply omits mode and supplies its full chart", () => {
@@ -1343,7 +1469,7 @@ describe("isDoubleView", () => {
         position: 0,
         value: "",
         mode: "draw",
-        isViewMaximized: true,
+        preferredView: "result",
       }),
     ).toBe(true)
   })
@@ -1473,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",
@@ -1490,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)
   })
 
@@ -1581,36 +1721,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 +1908,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(
         {
@@ -1780,13 +1919,221 @@ describe("computeCellGridH", () => {
           value: "",
           topHeight: 72,
           bottomHeight: 104,
-          isViewMaximized: true,
+          preferredView: "result",
           result: { results: [], activeResultIndex: 0, timestamp: 0 },
         },
         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 the authoritative preference for wide cells", () => {
+    expect(resolveCellPaneLayout(withResult(), false, false)).toBe("split")
+    expect(
+      resolveCellPaneLayout(
+        withResult({ preferredView: "result" }),
+        false,
+        false,
+      ),
+    ).toBe("result")
+    expect(
+      resolveCellPaneLayout(
+        withResult({ preferredView: "editor" }),
+        false,
+        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", () => {
+  const chart = (over: Partial<NotebookCell> = {}): NotebookCell => ({
+    id: "x",
+    position: 0,
+    value: "SELECT 1",
+    mode: "draw",
+    preferredView: "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",
+      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",
+    })
+  })
+
+  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", () => {
+  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,
+      preferredView: "result",
+      result,
+    }
+
+    // 100px result minimum + 44px base chrome requires 6 rows.
+    expect(computeCellMinGridH(cell, 10, 20)).toBe(6)
+  })
+
+  it("uses the chart-specific result minimum", () => {
+    const cell: NotebookCell = {
+      id: "x",
+      position: 0,
+      value: "",
+      mode: "draw",
+      topHeight: 400,
+      bottomHeight: 350,
+    }
+
+    // 400px editor + 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 +2311,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,
+      preferredView: "result",
     })
     // 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,
     })
   })
@@ -2240,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", () => {
@@ -2265,7 +2620,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: "" },
         ],
       },
@@ -2273,10 +2628,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. 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 +2643,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)", () => {
@@ -2344,7 +2700,7 @@ describe("cloneNotebookViewState", () => {
         value: "SELECT 2",
         mode: "draw",
         autoRefresh: true,
-        isViewMaximized: true,
+        preferredView: "result",
         chartConfig: {
           xColumn: "ts",
           queries: [{ type: "line", yColumns: ["v"] }],
@@ -2418,7 +2774,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"] }],
@@ -2812,6 +3168,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 }
@@ -3318,83 +3713,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 fd78e7b03..cfcb76c80 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,
@@ -96,20 +98,20 @@ 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 SQL" collapse — in wider tiers the slot is
-  // never force-hidden, so revealing there would wrongly maximize a split view.
-  const reveal = opts.isCompactTier && !opts.showBottomSlot
+  const hiddenByPreference = cell.preferredView === "editor"
+  const reveal =
+    !opts.showBottomSlot && (opts.isCompactTier || hiddenByPreference)
   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
@@ -490,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[],
@@ -601,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
@@ -698,9 +725,11 @@ type ApplyCellRequest = {
   type?: CellType | null
   mode?: CellMode | null
   autoRefresh?: AutoRefresh | null
-  isViewMaximized?: boolean | null
+  editorHeight?: number | "auto" | null
+  resultHeight?: number | "auto" | null
+  view?: AgentCellView | null
   chartConfig?: ChartConfig | null
-  grid?: { x: number; y: number; w: number; h: number } | null
+  grid?: { x: number; y: number; w: number } | null
 }
 
 type ApplyRequest = {
@@ -1082,16 +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)
     ) {
@@ -1152,13 +1185,54 @@ export const buildAppliedCells = (
     }
 
     const isDraw = resolvedMode === "draw"
-    const isViewMaximized =
-      req.isViewMaximized != null
-        ? req.isViewMaximized
-        : isDraw
-          ? true
-          : undefined
-    const autoRefresh = req.autoRefresh != null ? req.autoRefresh : undefined
+    const dimensionCell: NotebookCell = {
+      ...(existing ?? { id, position: index, value, type: resolvedType }),
+      value,
+      ...(resolvedMode !== undefined ? { mode: resolvedMode } : {}),
+    }
+    const dimensions = applicableCellDimensions(dimensionCell, {
+      editorHeight: req.editorHeight,
+      resultHeight: req.resultHeight,
+      view: req.view,
+    })
+    if (
+      typeof dimensions.editorHeight === "number" &&
+      (!Number.isFinite(dimensions.editorHeight) ||
+        dimensions.editorHeight < minTopHeightFor(dimensionCell))
+    ) {
+      throw new ApplyNotebookStateError(
+        `Cell at index ${index} has an editor_height below its minimum.`,
+        "cells",
+      )
+    }
+    if (
+      typeof dimensions.resultHeight === "number" &&
+      (!Number.isFinite(dimensions.resultHeight) ||
+        dimensions.resultHeight < minBottomHeightFor(dimensionCell))
+    ) {
+      throw new ApplyNotebookStateError(
+        `Cell at index ${index} has result_height ${dimensions.resultHeight}px; minimum is ${minBottomHeightFor(dimensionCell)}px.`,
+        "cells",
+      )
+    }
+    const dimensionsPatch = agentCellDimensionsPatch(dimensionCell, dimensions)
+    if (req.view == null && !existing && isDraw) {
+      dimensionsPatch.preferredView = "result"
+    }
+    const autoRefresh =
+      req.autoRefresh != null && resolvedType !== "markdown"
+        ? req.autoRefresh
+        : undefined
+
+    if (req.grid) {
+      const gridError = cellGridBoundsError(req.grid)
+      if (gridError) {
+        throw new ApplyNotebookStateError(
+          `Cell at index ${index} has invalid grid placement: ${gridError}`,
+          "cells",
+        )
+      }
+    }
 
     if (existing) {
       updated.push(existing.id)
@@ -1186,11 +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
@@ -1199,21 +1268,9 @@ export const buildAppliedCells = (
       else delete next.chartConfig
       if (autoRefresh !== undefined) next.autoRefresh = autoRefresh
       else delete next.autoRefresh
-      if (isViewMaximized !== undefined) next.isViewMaximized = isViewMaximized
-      else delete next.isViewMaximized
-      if (resolvedType === "markdown") {
-        // Markdown cells carry none of the SQL/chart sub-state.
-        next.type = "markdown"
-        next.result = null
-        delete next.mode
-        delete next.chartConfig
-        delete next.autoRefresh
-        delete next.isViewMaximized
-        delete next.bottomHeight
-        delete next.lastRunStatus
-        delete next.lastRunError
-      } else {
-        delete next.type
+      Object.assign(next, dimensionsPatch)
+      if (resolvedType !== "markdown") {
+        next.preferredView ??= "editor_result"
         if (valueChanged && !existing.topResized) {
           const estimated = topHeightForSql(value)
           if (
@@ -1238,19 +1295,21 @@ export const buildAppliedCells = (
     if (resolvedName !== undefined) created.name = resolvedName
     if (resolvedType === "markdown") {
       created.type = "markdown"
+      Object.assign(created, dimensionsPatch)
       return created
     }
     created.topHeight = topHeightForSql(value)
+    created.preferredView = "editor_result"
     if (resolvedMode !== undefined) created.mode = resolvedMode
     if (chartConfig !== undefined) created.chartConfig = chartConfig
     if (autoRefresh !== undefined) created.autoRefresh = autoRefresh
-    if (isViewMaximized !== undefined) created.isViewMaximized = isViewMaximized
     // Draw cells are double-view from creation (chart visible immediately),
     // so seed bottomHeight with the chart default. Run cells stay single-
     // view (no bottomHeight) until the user runs them.
     if (resolvedMode === "draw") {
       created.bottomHeight = DEFAULT_CHART_BOTTOM_HEIGHT
     }
+    Object.assign(created, dimensionsPatch)
     return created
   })
 
@@ -1276,14 +1335,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 +1381,60 @@ 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
+  expectingResult?: boolean
+}
+
+export const applicableCellDimensions = (
+  cell: Pick<NotebookCell, "type">,
+  dimensions: AgentCellDimensions,
+): AgentCellDimensions =>
+  cell.type === "markdown"
+    ? { ...dimensions, resultHeight: null, view: null }
+    : dimensions
+
+// Translate the semantic agent wire model into the persisted pane model.
+// `null`/omission preserves, "auto" clears the corresponding resize pin, and
+// a number fixes the pane at that pixel height.
+export const agentCellDimensionsPatch = (
+  cell: NotebookCell,
+  dimensions: AgentCellDimensions,
+): Partial<NotebookCell> => {
+  const patch: Partial<NotebookCell> = {}
+  if (dimensions.editorHeight === "auto") {
+    patch.topHeight =
+      cell.type === "markdown" ? undefined : topHeightForSql(cell.value)
+    patch.topResized = false
+  } else if (typeof dimensions.editorHeight === "number") {
+    patch.topHeight = dimensions.editorHeight
+    patch.topResized = true
+  }
+  if (dimensions.resultHeight === "auto") {
+    patch.bottomHeight = undefined
+    patch.bottomResized = false
+  } else if (typeof dimensions.resultHeight === "number") {
+    patch.bottomHeight = dimensions.resultHeight
+    patch.bottomResized = true
+  }
+  if (dimensions.view != null && cell.type !== "markdown") {
+    patch.preferredView = dimensions.view
+  }
+  return patch
+}
 
 // Pixel sizes of the result panel's chrome. Kept in sync with the styled-
 // components in result-table/styles.ts; if those constants change, update
@@ -1391,11 +1503,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 => {
@@ -1404,11 +1514,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 (
@@ -1440,15 +1548,62 @@ 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"
+  return cell.preferredView ?? "editor_result"
+}
+
+export type AgentCellPresentation = {
+  preferred_view: AgentCellView | null
+  view?: AgentCellView | null
+  tier?: AgentCellTier
+}
+
+export const resolveAgentCellPresentation = (
+  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",
+  }
+}
+
+// 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,
+  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"
+}
+
 // bottomHeight seeding when a cell flips between run and draw. A user-resized
 // bottom slot is never overridden.
 export const modeChangeBottomHeightPatch = (
@@ -1469,10 +1624,7 @@ export const modeChangeBottomHeightPatch = (
 export const cellModeChangePatch = (
   cell: NotebookCell | undefined,
   mode: CellMode,
-): Partial<NotebookCell> => ({
-  ...modeChangeBottomHeightPatch(cell, mode),
-  ...(mode === "draw" ? { isViewMaximized: false } : {}),
-})
+): Partial<NotebookCell> => modeChangeBottomHeightPatch(cell, mode)
 
 export const mergeCellChartConfig = (
   cell: NotebookCell,
@@ -1501,17 +1653,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 +1672,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 +1717,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 +1726,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 +1739,16 @@ export const NOTEBOOK_GRID_COLS = 12
 export const NOTEBOOK_GRID_ROW_HEIGHT = 10
 export const NOTEBOOK_GRID_MARGIN_Y = 20
 
-// Derives the react-grid-layout `h` (row count) for a cell from its
-// topHeight + bottomHeight + chrome. Recomputed at render time on every
-// state change.
+export const cellGridBoundsError = (pos: {
+  x: number
+  w: number
+}): string | undefined =>
+  pos.x + pos.w > NOTEBOOK_GRID_COLS
+    ? `x + w must be at most ${NOTEBOOK_GRID_COLS}.`
+    : undefined
+
+// Derives react-grid-layout `h` from the visible pane heights plus chrome.
+// Recomputed at render time on every state change.
 //
 // react-grid-layout inserts `marginY` BETWEEN rows, so the actual
 // rendered px of an h-row cell is `h * rowHeight + (h - 1) * marginY`,
@@ -1567,14 +1763,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 +1811,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 +1846,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 +1856,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 +1902,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,38 +1966,12 @@ export const buildAppliedNotebookState = (
       ? current.settings.layoutMode
       : request.layoutMode
 
-  // Pin an intentionally-resized grid.h into the cell; the stored h alone is a
-  // stale shadow the renderer overwrites (see cellHeightPatchForRows).
-  //
-  // Back-solve against the pre-apply cell, not the mutated one: the agent's h
-  // was derived from the cell it read (with its result), so a value edit that
-  // drops the result must not flip the cell to the single-view branch and pin
-  // the editor. Evaluating on the prior cell makes an agent-sent h behave
-  // exactly like the user's bottom-edge drag.
-  const prevById = new Map(current.cells.map((c) => [c.id, c]))
-  const cells =
-    targetLayoutMode === "grid"
-      ? nextCells.map((cell, i) => {
-          const g = request.cells[i]?.grid
-          if (!g) return cell
-          const prior = prevById.get(cell.id) ?? cell
-          const patch = cellHeightPatchForRows(
-            prior,
-            g.h,
-            NOTEBOOK_GRID_ROW_HEIGHT,
-            NOTEBOOK_GRID_MARGIN_Y,
-            isExpectingResult(prior, "unrequested"),
-          )
-          return Object.keys(patch).length > 0 ? { ...cell, ...patch } : cell
-        })
-      : nextCells
-
   let nextSettings = current.settings
   if (targetLayoutMode === "grid") {
     nextSettings = {
       ...nextSettings,
       layoutMode: "grid",
-      layout: buildAppliedLayout(request, cells, current.settings.layout, {
+      layout: buildAppliedLayout(request, nextCells, current.settings.layout, {
         gridCols: NOTEBOOK_GRID_COLS,
         rowHeight: NOTEBOOK_GRID_ROW_HEIGHT,
         marginY: NOTEBOOK_GRID_MARGIN_Y,
@@ -1806,16 +1996,16 @@ export const buildAppliedNotebookState = (
   let nextMaximizedCellId = current.maximizedCellId
   if (request.maximizedCellId !== undefined) {
     const id = request.maximizedCellId
-    nextMaximizedCellId = id && cells.some((c) => c.id === id) ? id : null
+    nextMaximizedCellId = id && nextCells.some((c) => c.id === id) ? id : null
   } else if (
     nextMaximizedCellId &&
-    !cells.some((c) => c.id === nextMaximizedCellId)
+    !nextCells.some((c) => c.id === nextMaximizedCellId)
   ) {
     nextMaximizedCellId = null
   }
 
   return {
-    cells,
+    cells: nextCells,
     settings: nextSettings,
     maximizedCellId: nextMaximizedCellId,
     diff,
diff --git a/src/store/notebook.ts b/src/store/notebook.ts
index ab7addcc9..500877564 100644
--- a/src/store/notebook.ts
+++ b/src/store/notebook.ts
@@ -37,6 +37,9 @@ export type AutoRefresh = boolean | AutoRefreshInterval
 // migration. Markdown cells hold their source in `value` and are never executed.
 export type CellType = "sql" | "markdown"
 
+export type AgentCellView = "editor" | "result" | "editor_result"
+export type AgentCellTier = "compact" | "wide"
+
 export type NotebookCell = {
   id: string
   position: number
@@ -53,7 +56,9 @@ export type NotebookCell = {
   mode?: CellMode
   chartConfig?: ChartConfig
   autoRefresh?: AutoRefresh
-  isViewMaximized?: boolean
+  // Authoritative, viewport-independent pane intent. The rendered view is
+  // derived from this preference, result availability, and current width.
+  preferredView?: AgentCellView
   lastRunStatus?: RunStatus
   lastRunError?: string
 }
@@ -147,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 c269d3684..b351869c5 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"
@@ -24,6 +25,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 +82,7 @@ beforeEach(async () => {
   __resetNotebookControllerForTests()
   __resetNotebookAIBridgeForTests()
   __resetNotebookBufferQueuesForTests()
+  __resetNotebookPresentationStoreForTests()
   await db.buffers.clear()
 })
 
@@ -154,6 +160,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 +220,136 @@ 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_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 () => {
+    // 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: [
+        sql("a", "SELECT 1", {
+          mode: "draw",
+          preferredView: "editor_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({
@@ -270,7 +409,7 @@ describe("buildSnapshot", () => {
     const cell = sql("a", "SELECT 1", {
       mode: "draw",
       autoRefresh: "5s",
-      isViewMaximized: false,
+      preferredView: "editor_result",
       name: "Trades",
       chartConfig: {
         xColumn: "ts",
@@ -317,6 +456,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 +499,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..940f6c164 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,14 @@ import type {
 import type { UserActionDigest } from "../../providers/AIConversationProvider/types"
 import type { WorkspaceInfo } from "./executeAIFlow"
 import { normalizeVariables } from "../../scenes/Editor/Notebook/declareUtils"
-import { computeAgentCellGridH } from "../../scenes/Editor/Notebook/notebookUtils"
+import {
+  type AgentCellPresentation,
+  agentCellPaneDimensions,
+  agentViewForPaneLayout,
+  resolveAgentCellPresentation,
+  storedAgentCellView,
+} 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 +58,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" | null
+  preferred_view: AgentCellView | null
+  view?: AgentCellView | null
+  tier?: AgentCellTier
   chart_config?: ChartConfigWire
   last_run_status?: RunStatus
   last_run_error_summary?: string
@@ -58,7 +71,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 +100,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,
@@ -151,15 +166,32 @@ 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,
   gridByCellId: Map<string, CellLayoutItem>,
   layoutMode: "list" | "grid",
   refreshState: ReadonlyMap<string, CellRefreshView> | undefined,
 ): NotebookContextCell => {
+  const presentation = liveAgentCellPresentation(cell, bufferId)
   const out: NotebookContextCell = {
     id: cell.id,
     preview: preview(cell.value),
+    preferred_view: presentation.preferred_view,
     ...lastRunSummary(cell),
     ...refreshFields(refreshState?.get(cell.id)),
   }
@@ -171,9 +203,13 @@ 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 (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)
@@ -185,7 +221,6 @@ const buildCell = (
         x: g.x,
         y: g.y,
         w: g.w,
-        h: computeAgentCellGridH(cell),
       }
     }
   }
@@ -224,7 +259,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 +315,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 +330,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 +361,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 +476,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" | null
+  preferred_view: AgentCellView | null
+  view?: AgentCellView | null
+  tier?: AgentCellTier
   chart_config?: ChartConfigWire
   last_run_status?: RunStatus
   last_run_error?: string
@@ -488,14 +534,20 @@ 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 = liveAgentCellPresentation(cell, bufferId)
   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 +556,9 @@ export const serializeCell = (
   if (cell.type === "markdown") out.type = "markdown"
   if (cell.mode) out.mode = cell.mode
   if (cell.autoRefresh !== undefined) out.auto_refresh = cell.autoRefresh
-  if (typeof cell.isViewMaximized === "boolean")
-    out.is_view_maximized = cell.isViewMaximized
+  if (cell.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 00e600a5a..cd8df2eff 100644
--- a/src/utils/ai/prompts.ts
+++ b/src/utils/ai/prompts.ts
@@ -82,7 +82,7 @@ export const NOTEBOOK_INSTRUCTION = `
 
 ## Notebook Authoring
 You can create and edit QuestDB notebooks (tabs of SQL cells with list/grid layouts, draw-mode charts, and markdown prose cells) using these tools:
-create_notebook, list_cells, get_cell, get_notebook_state, add_cell, update_cell, delete_cell, move_cell_up, move_cell_down, duplicate_cell, run_cell, set_layout_mode, set_cell_layout, set_cell_mode, set_cell_name, set_cell_chart_config, set_notebook_autorefresh, set_cell_autorefresh, set_cell_view_maximized, set_cell_maximized.
+create_notebook, list_cells, get_cell, get_notebook_state, add_cell, update_cell, delete_cell, move_cell_up, move_cell_down, duplicate_cell, run_cell, set_layout_mode, set_cell_layout, set_cell_dimensions, set_cell_mode, set_cell_name, set_cell_chart_config, set_notebook_autorefresh, set_cell_autorefresh, set_cell_maximized.
 
 CRITICAL — Do NOT expose buffer_id to the user
 - buffer_id is an internal identifier. NEVER ask the user for it, print it back, or mention it in any response.
@@ -114,10 +114,11 @@ When to use notebook tools
 Editing discipline
 - update_cell overwrites preemptively — cells are auto-saved, there is no unsaved-dirty state to worry about. Be deliberate.
 - Cells containing DDL/DML (INSERT/UPDATE/CREATE/DROP/...) never auto-run via apply_notebook_state or add_cell — they are skipped. Confirm with the user, then call run_cell explicitly; run_cell is the only path that executes a write cell.
-- Markdown cells: add_cell (or apply_notebook_state) with type:"markdown" creates a rendered prose cell — its value is markdown text, it is NEVER executed (run_cell and auto-run are no-ops on it), and it must carry no mode/chart_config. Use them for titles, narrative, and explanations between query cells. In apply_notebook_state the cell kind is STICKY: omitting type preserves a cell's kind (a markdown cell stays markdown).
+- Markdown cells: add_cell (or apply_notebook_state) with type:"markdown" creates a rendered prose cell — its value is markdown text, it is NEVER executed (run_cell and auto-run are no-ops on it), and it must carry no mode/chart_config. Use them for titles, narrative, and explanations between query cells. In apply_notebook_state the cell kind is FIXED: omitting type preserves a cell's kind, and an existing cell can never change kind — delete it and add a new cell instead.
+- Cell dimensions are pane-based CSS pixels, not grid rows. Use editor_height/result_height/view (or set_cell_dimensions); grid height is derived. Null preserves, "auto" restores automatic sizing, and a number pins a pane. For SQL/draw cells, 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: 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..d89e71683 100644
--- a/src/utils/ai/shared.notebookTools.test.ts
+++ b/src/utils/ai/shared.notebookTools.test.ts
@@ -40,6 +40,11 @@ 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,
@@ -190,6 +195,7 @@ beforeEach(async () => {
   __resetNotebookControllerForTests()
   __resetNotebookAIBridgeForTests()
   __resetNotebookBufferQueuesForTests()
+  __resetNotebookPresentationStoreForTests()
   clearStatementClassCache()
   await db.buffers.clear()
   await db.notebook_results.clear()
@@ -205,6 +211,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 +687,113 @@ 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,
+        preferredView: "result",
+      }),
+    ])
+
+    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,
+      preferredView: "result",
+    })
+  })
+
+  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",
+      expectingResult: false,
+    })
+
+    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")?.preferredView).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",
+          preferredView: "editor_result",
+        }),
+      ],
+      {
+        settings: {
+          layoutMode: "grid",
+          layout: [{ i: "c", x: 0, y: 0, w: 6, h: 10 }],
+        },
+      },
+    )
+    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 },
+      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)
+    unpublishWidth()
+    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 +1176,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
             value: "SELECT 1",
             mode: "draw",
             auto_refresh: "5s",
-            is_view_maximized: true,
+            view: "result",
             chart_config: {
               x_column: "ts",
               right_axis: null,
@@ -1056,7 +1188,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
                 },
               ],
             },
-            grid: { x: 0, y: 0, w: 6, h: 6 },
+            grid: { x: 0, y: 0, w: 6 },
           },
         ],
       },
@@ -1071,7 +1203,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
       value: "SELECT 1",
       mode: "draw",
       autoRefresh: "5s",
-      isViewMaximized: true,
+      preferredView: "result",
       chartConfig: {
         xColumn: "ts",
         queries: [
@@ -1730,7 +1862,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 +1900,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 +2018,7 @@ describe("dispatchTool — notebook tools (happy path)", () => {
             value: "DROP TABLE victim",
             mode: "draw",
             auto_refresh: null,
-            is_view_maximized: null,
+            view: null,
             chart_config: { type: "line", x_column: "ts", y_columns: ["x"] },
             grid: null,
           },
diff --git a/src/utils/mcp/dispatchMCPTool.test.ts b/src/utils/mcp/dispatchMCPTool.test.ts
index 0523071c5..5ef14549c 100644
--- a/src/utils/mcp/dispatchMCPTool.test.ts
+++ b/src/utils/mcp/dispatchMCPTool.test.ts
@@ -173,11 +173,11 @@ describe("dispatchMCPTool — state-freshness gate", () => {
     "run_cell",
     "set_layout_mode",
     "set_cell_layout",
+    "set_cell_dimensions",
     "set_cell_mode",
     "set_cell_chart_config",
     "set_notebook_autorefresh",
     "set_cell_autorefresh",
-    "set_cell_view_maximized",
     "set_cell_maximized",
   ]
 
diff --git a/src/utils/notebooks/notebookAIBridge.test.ts b/src/utils/notebooks/notebookAIBridge.test.ts
index e68b457f1..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 c902fa433..631c8be83 100644
--- a/src/utils/notebooks/notebookController/index.ts
+++ b/src/utils/notebooks/notebookController/index.ts
@@ -122,10 +122,11 @@ export {
   moveCellDownTransition,
   moveCellUpTransition,
   setCellChartConfigTransition,
+  setCellDimensionsTransition,
   setCellLayoutTransition,
   setCellMaximizedTransition,
   setCellModeTransition,
-  setCellViewMaximizedTransition,
+  setCellPreferredViewTransition,
   setLayoutModeTransition,
   setNotebookAutoRefreshTransition,
   updateCellTransition,
diff --git a/src/utils/notebooks/notebookController/notebookController.ts b/src/utils/notebooks/notebookController/notebookController.ts
index 8bcae8f1a..7704e76df 100644
--- a/src/utils/notebooks/notebookController/notebookController.ts
+++ b/src/utils/notebooks/notebookController/notebookController.ts
@@ -1,4 +1,5 @@
 import type {
+  AgentCellView,
   AutoRefresh,
   CellType,
   NotebookCell,
@@ -7,6 +8,7 @@ import type {
   NotebookViewState,
 } from "../../../store/notebook"
 import type { ChartConfig } from "../../../scenes/Editor/Notebook/CellChart/chartTypes"
+import type { AgentHeightValue } from "../../../scenes/Editor/Notebook/notebookUtils"
 import {
   type CellRunOutcome,
   CELL_CHANGED_BEFORE_RUN_NOTE,
@@ -120,9 +122,11 @@ export type ApplyNotebookStateCellRequest = {
   type?: CellType | null
   mode?: "run" | "draw" | null
   autoRefresh?: AutoRefresh | null
-  isViewMaximized?: boolean | null
+  editorHeight?: AgentHeightValue
+  resultHeight?: AgentHeightValue
+  view?: AgentCellView | null
   chartConfig?: ChartConfig | null
-  grid?: { x: number; y: number; w: number; h: number } | null
+  grid?: { x: number; y: number; w: number } | null
 }
 
 export type ApplyNotebookStateRequest = {
diff --git a/src/utils/notebooks/notebookController/notebookTransitions.test.ts b/src/utils/notebooks/notebookController/notebookTransitions.test.ts
index 1262b0482..55849e7cf 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,255 @@ 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,
+      preferredView: "result",
+    })
+    const parts = partsOf([chart], {
+      settings: {
+        layoutMode: "grid",
+        layout: [{ i: "a", x: 0, y: 0, w: 12, h: 14 }],
+      },
+    })
+
+    const out = setCellDimensionsTransition(parts, BUFFER_ID, "a", {
+      view: "editor_result",
+      compact: false,
+    })
+
+    expect(out.parts.cells[0]).toMatchObject({
+      topHeight: 72,
+      bottomHeight: 350,
+      preferredView: "editor_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,
+      preferredView: "result",
+    })
+
+    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,
+      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",
+    })
+  })
+
+  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", () => {
+    // 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", {
+      view: "editor",
+      compact: false,
+    })
+
+    expect(out.parts.cells[0]).toMatchObject({
+      preferredView: "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/)
+  })
+
+  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",
+    preferredView: "editor_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",
+    })
+  })
+
+  it("rejects placement that extends beyond the grid", () => {
+    expect(() =>
+      setCellLayoutTransition(
+        partsOf([chart], { settings: { layoutMode: "grid" } }),
+        BUFFER_ID,
+        "a",
+        { x: 11, y: 0, w: 2 },
+      ),
+    ).toThrow(NotebookToolError)
+  })
+})
+
 describe("applyNotebookStateTransition", () => {
   it("carries every dropped cell in cleanup.cellIds for post-commit removal", () => {
     // Given a three-cell notebook
diff --git a/src/utils/notebooks/notebookController/notebookTransitions.ts b/src/utils/notebooks/notebookController/notebookTransitions.ts
index 710f684ca..7ed27f229 100644
--- a/src/utils/notebooks/notebookController/notebookTransitions.ts
+++ b/src/utils/notebooks/notebookController/notebookTransitions.ts
@@ -1,5 +1,6 @@
 import {
   MAX_NOTEBOOK_CELLS,
+  type AgentCellView,
   type AutoRefresh,
   type CellMode,
   type CellType,
@@ -11,26 +12,33 @@ import { requireCellIn, requireCellWithinLineLimit } from "../notebookDexieView"
 import type { ApplyNotebookStateRequest } from "./notebookController"
 import type { ChartConfig } from "../../../scenes/Editor/Notebook/CellChart/chartTypes"
 import {
+  agentCellDimensionsPatch,
+  applicableCellDimensions,
   buildAppliedNotebookState,
   carriedRunError,
   carriedRunStatus,
-  cellHeightPatchForRows,
+  cellGridBoundsError,
   cellModeChangePatch,
   clearCellAutoRefresh,
+  computeAgentCellGridH,
   duplicateCellAt,
+  gridCellToolbarTier,
   insertCell,
   isExpectingResult,
   mergeCellChartConfig,
+  minBottomHeightFor,
+  minTopHeightFor,
   nextGridSeedPosition,
   reconcileCellResultForValue,
-  NOTEBOOK_GRID_MARGIN_Y,
-  NOTEBOOK_GRID_ROW_HEIGHT,
+  resolveAgentCellPresentation,
   removeCell,
   swapCellDown,
   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,30 +287,134 @@ export const setCellLayoutTransition = (
   parts: ViewParts,
   bufferId: number,
   cellId: string,
-  pos: CellGridPosition,
-): NotebookTransitionResult => {
+  pos: Omit<CellGridPosition, "h"> & {
+    liveCompact?: boolean
+    liveExpectingResult?: 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(
+  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,
-    pos.h,
-    NOTEBOOK_GRID_ROW_HEIGHT,
-    NOTEBOOK_GRID_MARGIN_Y,
-    isExpectingResult(cell, "unrequested"),
+    expectingResult,
+    compact === true,
   )
+  const layoutPos: CellGridPosition = {
+    x: pos.x,
+    y: pos.y,
+    w: pos.w,
+    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, pos),
+        layout: upsertCellLayout(parts.settings.layout, cellId, layoutPos),
       },
     },
-    result: undefined,
+    result: {
+      grid: { x: pos.x, y: pos.y, w: pos.w },
+      ...resolveAgentCellPresentation(cell, compact, expectingResult),
+    },
+    touchedCellId: cellId,
+  }
+}
+
+export const setCellDimensionsTransition = (
+  parts: ViewParts,
+  bufferId: number,
+  cellId: string,
+  requested: AgentCellDimensions,
+): NotebookTransitionResult<
+  ReturnType<typeof resolveAgentCellPresentation> & {
+    fallback?:
+      | "editor_result_unavailable_in_compact"
+      | "requested_view_unavailable"
+  }
+> => {
+  const cell = requireCellIn(parts.cells, cellId, bufferId)
+  const dimensions = applicableCellDimensions(cell, requested)
+  if (
+    typeof dimensions.editorHeight === "number" &&
+    (!Number.isFinite(dimensions.editorHeight) ||
+      dimensions.editorHeight < minTopHeightFor(cell))
+  ) {
+    throw new NotebookToolError(
+      "validation",
+      `editor_height must be at least ${minTopHeightFor(cell)}px.`,
+    )
+  }
+  if (
+    typeof dimensions.resultHeight === "number" &&
+    (!Number.isFinite(dimensions.resultHeight) ||
+      dimensions.resultHeight < minBottomHeightFor(cell))
+  ) {
+    throw new NotebookToolError(
+      "validation",
+      `result_height must be at least ${minBottomHeightFor(cell)}px for this cell.`,
+    )
+  }
+
+  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,
+  )
+  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,
+      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,
   }
 }
@@ -348,17 +460,25 @@ 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 }),
+      cells: patchCellIn(parts.cells, cellId, {
+        preferredView,
+      }),
     },
     result: undefined,
     touchedCellId: cellId,
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/notebooks/notebookToolError.ts b/src/utils/notebooks/notebookToolError.ts
index c231ab0df..90f5b10d0 100644
--- a/src/utils/notebooks/notebookToolError.ts
+++ b/src/utils/notebooks/notebookToolError.ts
@@ -11,6 +11,7 @@ export type NotebookToolErrorCode =
   | "last_cell"
   | "cell_limit"
   | "cell_too_large"
+  | "validation"
 
 export class NotebookToolError extends Error {
   readonly code: NotebookToolErrorCode
diff --git a/src/utils/notebooks/notebookToolMessages.ts b/src/utils/notebooks/notebookToolMessages.ts
index 22f52f0a0..ccbd76742 100644
--- a/src/utils/notebooks/notebookToolMessages.ts
+++ b/src/utils/notebooks/notebookToolMessages.ts
@@ -30,6 +30,8 @@ export const notebookErrorHint = (code: NotebookToolErrorCode): string => {
       return "The notebook is at its cell limit. Delete a cell first, or restructure with apply_notebook_state."
     case "cell_too_large":
       return "The value exceeds the per-cell line limit. Split it across multiple cells."
+    case "validation":
+      return "Correct the invalid notebook field and retry."
     default:
       return "Notebook tool failed."
   }
diff --git a/src/utils/tools/applyNotebookState.ts b/src/utils/tools/applyNotebookState.ts
index 7a27ba26b..eeef6dba5 100644
--- a/src/utils/tools/applyNotebookState.ts
+++ b/src/utils/tools/applyNotebookState.ts
@@ -9,7 +9,12 @@ import {
   type ApplyNotebookStateCellRequest,
   type ApplyNotebookStateRequest,
 } from "../notebooks/notebookController"
-import type { CellMode, CellType, NotebookVariable } from "../../store/notebook"
+import type {
+  AgentCellView,
+  CellMode,
+  CellType,
+  NotebookVariable,
+} from "../../store/notebook"
 import type { ChartConfig } from "../../scenes/Editor/Notebook/CellChart/chartTypes"
 import {
   denyReasonUnresolvedSql,
@@ -216,13 +221,15 @@ export const dispatchApplyNotebookState = async (
         type?: "sql" | "markdown" | null
         mode?: CellMode | null
         auto_refresh?: boolean | string | null
-        is_view_maximized?: boolean | null
+        editor_height?: number | "auto" | null
+        result_height?: number | "auto" | null
+        view?: AgentCellView | null
         chart_config?: {
           x_column?: string | null
           queries?: (ToolQueryChart | null)[] | null
           right_axis?: ToolRightAxis | null
         } | null
-        grid?: { x: number; y: number; w: number; h: number } | null
+        grid?: { x: number; y: number; w: number } | null
       }>
     }) || {}
   setStatus(AIOperationStatus.BuildingNotebook)
@@ -389,8 +396,9 @@ export const dispatchApplyNotebookState = async (
       if (c.type === "sql" || c.type === "markdown") cell.type = c.type
       if (c.mode !== undefined && c.mode !== null) cell.mode = c.mode
       if (isAutoRefresh(c.auto_refresh)) cell.autoRefresh = c.auto_refresh
-      if (c.is_view_maximized !== undefined && c.is_view_maximized !== null)
-        cell.isViewMaximized = c.is_view_maximized
+      if (c.editor_height !== undefined) cell.editorHeight = c.editor_height
+      if (c.result_height !== undefined) cell.resultHeight = c.result_height
+      if (c.view !== undefined) cell.view = c.view
       if (c.chart_config) {
         const cfg = c.chart_config
         const chartConfig: ChartConfig = {
diff --git a/src/utils/tools/dispatch.ts b/src/utils/tools/dispatch.ts
index d6be52076..0d198213b 100644
--- a/src/utils/tools/dispatch.ts
+++ b/src/utils/tools/dispatch.ts
@@ -8,7 +8,11 @@ import {
 } from "../questdbDocsRetrieval"
 import { getBufferActionSeq } from "../notebooks/notebookAIBridge"
 import { NotebookToolError } from "../notebooks/notebookToolError"
-import type { CellMode, NotebookCell } from "../../store/notebook"
+import type {
+  AgentCellView,
+  CellMode,
+  NotebookCell,
+} from "../../store/notebook"
 import {
   MAX_CELL_NAME_LENGTH,
   exceedsCellNameLimit,
@@ -68,10 +72,10 @@ import {
   moveCellDownTransition,
   moveCellUpTransition,
   setCellChartConfigTransition,
+  setCellDimensionsTransition,
   setCellLayoutTransition,
   setCellMaximizedTransition,
   setCellModeTransition,
-  setCellViewMaximizedTransition,
   setLayoutModeTransition,
   setNotebookAutoRefreshTransition,
   updateCellTransition,
@@ -83,6 +87,10 @@ import {
   serializeCell,
   summarizeCells,
 } from "../ai/notebookSnapshot"
+import {
+  readGridContainerWidth,
+  readLiveCellPresentation,
+} from "../../scenes/Editor/Notebook/notebookPresentationStore"
 import { generateId } from "../../scenes/Editor/Notebook/notebookUtils"
 import {
   copyNotebookSnapshots,
@@ -498,7 +506,7 @@ export const dispatchTool = async (
           )
           return {
             ...res,
-            hint: "Duplicated in the background — the tab was not switched. The user is notified and can open it. Only call activate_notebook if they explicitly ask to be taken there.",
+            hint: "Duplicated in the background — the tab was not switched. Run history is preserved; matching saved result snapshots copy best-effort in the background and hydrate when opened. The user is notified and can open it. Only call activate_notebook if they explicitly ask to be taken there.",
           }
         })
       }
@@ -813,26 +821,62 @@ export const dispatchTool = async (
         )
       }
       case "set_cell_layout": {
-        const { buffer_id, cell_id, x, y, w, h } =
+        const { buffer_id, cell_id, x, y, w } =
           (input as {
             buffer_id: number
             cell_id: string
             x: number
             y: number
             w: number
-            h: number
           }) || {}
         setStatus(AIOperationStatus.ConfiguringLayout, { cellId: cell_id })
         return routeNotebookTool(() =>
           runTransition(
             buffer_id,
-            (parts) =>
-              setCellLayoutTransition(parts, buffer_id, cell_id, {
+            (parts) => {
+              const livePresentation = readLiveCellPresentation(
+                buffer_id,
+                cell_id,
+              )
+              return setCellLayoutTransition(parts, buffer_id, cell_id, {
                 x,
                 y,
                 w,
-                h,
-              }),
+                liveCompact: livePresentation?.compact,
+                liveExpectingResult: livePresentation?.expectingResult,
+                gridContainerWidth: readGridContainerWidth(buffer_id),
+              })
+            },
+            signal,
+          ),
+        )
+      }
+      case "set_cell_dimensions": {
+        const { buffer_id, cell_id, editor_height, result_height, view } =
+          (input as {
+            buffer_id: number
+            cell_id: string
+            editor_height: number | "auto" | null
+            result_height: number | "auto" | null
+            view: AgentCellView | null
+          }) || {}
+        setStatus(AIOperationStatus.ConfiguringLayout, { cellId: cell_id })
+        return routeNotebookTool(() =>
+          runTransition(
+            buffer_id,
+            (parts) => {
+              const livePresentation = readLiveCellPresentation(
+                buffer_id,
+                cell_id,
+              )
+              return setCellDimensionsTransition(parts, buffer_id, cell_id, {
+                editorHeight: editor_height,
+                resultHeight: result_height,
+                view,
+                compact: livePresentation?.compact,
+                expectingResult: livePresentation?.expectingResult,
+              })
+            },
             signal,
           ),
         )
@@ -1039,23 +1083,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,