diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1de963c..85b3dec 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,7 +15,10 @@ auto-generated per-PR notes; this file is the curated, human-readable history.
   Dashboard gains refresh, View/Edit, and `G` navigation commands while stale
   viewer sessions, loading routes, stacked overlays, and nested text inputs
   fail closed. Contextual help is torn down on route and authentication
-  transitions so it cannot survive onto another surface or Login.
+  transitions so it cannot survive onto another surface or Login. Dashboard
+  Style adds `G G`, `G F`, `G R`, `G 2`, and `G 3` for Grid Tiles, Full view,
+  Report, and two/three columns; View mode previews every style without
+  changing the shared dashboard.
 
 ## [0.6.4] - 2026-07-24
 
diff --git a/src/dashboard/application/dashboard-viewer-session.ts b/src/dashboard/application/dashboard-viewer-session.ts
index 7412ffb..e6d7fe7 100644
--- a/src/dashboard/application/dashboard-viewer-session.ts
+++ b/src/dashboard/application/dashboard-viewer-session.ts
@@ -172,6 +172,11 @@ export type DashboardLayoutView =
   | (FlowLayoutModel & { engine: 'flow' })
   | { engine: 'grafana-grid'; grid: GrafanaGridLayoutModel; renderMode: GridRenderMode };
 
+/** The five presentation styles exposed by the Dashboard header. This is a
+ * runtime choice: View mode can select any style without changing the shared
+ * document, while Edit mode maps the same values to authoring commands. */
+export type DashboardStyle = 'grafana-grid' | 'full' | 'report' | 'columns-2' | 'columns-3';
+
 export interface DashboardViewState {
   /** Search-matched tiles only, in their unchanged saved order. */
   tiles: ViewerTileState[];
@@ -182,6 +187,8 @@ export interface DashboardViewState {
   resettableFilterIds: string[];
   filters: ViewerFilterState[];
   layout: DashboardLayoutView;
+  /** The effective header style, including any session-local View-mode choice. */
+  style: DashboardStyle;
   /** Count of ACTIVE filter DEFINITIONS (not non-empty stored values, #188). */
   activeFilterCount: number;
   running: boolean;
@@ -332,6 +339,9 @@ export interface DashboardViewerSession {
    *  `documentRef` entirely. A fresh session (reload/new viewer) always starts
    *  at 'tiles'. */
   setGridRenderMode(mode: GridRenderMode): void;
+  /** Select a complete session-local Dashboard style. Unlike `syncDocument`,
+   * this never changes the source document or re-runs tile queries. */
+  setDashboardStyle(style: DashboardStyle): void;
   /** Cancel all work and turn every later entry point into a no-op. */
   destroy(): void;
 }
@@ -489,6 +499,9 @@ export function createDashboardViewerSession(deps: DashboardViewerDeps): Dashboa
   // outside `documentRef` — never read/written by any command, never
   // persisted. A fresh session always starts at 'tiles'.
   let gridRenderMode: GridRenderMode = 'tiles';
+  // View mode may preview any header style without authoring a layout. `null`
+  // means render the document's authored style (plus the legacy Full override).
+  let dashboardStyleOverride: DashboardStyle | null = null;
   let tileSearch = '';
   // #335: the single wall-clock snapshot the LATEST execution wave resolved its
   // relative tokens against (published as `state.waveWallNowMs`). `null` until
@@ -905,16 +918,31 @@ export function createDashboardViewerSession(deps: DashboardViewerDeps): Dashboa
     // primary with a valid flow@1 fallback still resolves to the flow plugin
     // here, exactly as before #291 (`computeFlowLayout`'s own fallback
     // handling, untouched) — flow behavior stays bit-identical.
-    const plugin = resolveLayoutPluginSync(documentRef.layout);
+    const selectedStyle: DashboardStyle = dashboardStyleOverride
+      ?? (documentRef.layout.type === 'grafana-grid'
+        ? (gridRenderMode === 'full' ? 'full' : 'grafana-grid')
+        : (documentRef.layout.preset as DashboardStyle));
+    const layoutDocument = dashboardStyleOverride === null
+      ? documentRef.layout
+      : selectedStyle === 'grafana-grid' || selectedStyle === 'full'
+        ? (documentRef.layout.type === 'grafana-grid'
+          ? documentRef.layout
+          : { type: 'grafana-grid', version: 1, items: {} })
+        : {
+          type: 'flow', version: 1, preset: selectedStyle,
+          items: documentRef.layout.type === 'flow' ? documentRef.layout.items : {},
+        };
+    const renderMode: GridRenderMode = selectedStyle === 'full' ? 'full' : 'tiles';
+    const plugin = resolveLayoutPluginSync(layoutDocument);
     const layout: DashboardLayoutView = plugin.type === 'grafana-grid'
       ? {
         engine: 'grafana-grid',
         grid: computeGrafanaGridLayout({
-          tiles: visible, layout: documentRef.layout, containerWidth: deps.containerWidth?.(), renderMode: gridRenderMode,
+          tiles: visible, layout: layoutDocument, containerWidth: deps.containerWidth?.(), renderMode,
         }),
-        renderMode: gridRenderMode,
+        renderMode,
       }
-      : { engine: 'flow', ...computeFlowLayout({ tiles: visible, layout: documentRef.layout, mobile }) };
+      : { engine: 'flow', ...computeFlowLayout({ tiles: visible, layout: layoutDocument, mobile }) };
     return {
       tiles: visibleRuntimes.map((runtime) => ({ ...runtime.state })),
       totalTileCount: tiles.length,
@@ -927,6 +955,7 @@ export function createDashboardViewerSession(deps: DashboardViewerDeps): Dashboa
       }).map((filter) => filter.def.id),
       filters: filters.map((filter) => ({ ...filter.state })),
       layout,
+      style: selectedStyle,
       activeFilterCount: filters.filter((filter) => filter.state.active).length,
       running, updatedAt, diagnostics: presentationDiagnostics,
       // #189: construction-time selection-resolution diagnostics are PERSISTENT
@@ -1759,6 +1788,12 @@ export function createDashboardViewerSession(deps: DashboardViewerDeps): Dashboa
     publish();
   }
 
+  function setDashboardStyle(style: DashboardStyle): void {
+    if (destroyed || dashboardStyleOverride === style) return;
+    dashboardStyleOverride = style;
+    publish();
+  }
+
   function destroy(): void {
     destroyed = true;
     for (const runtime of tiles) {
@@ -1781,6 +1816,6 @@ export function createDashboardViewerSession(deps: DashboardViewerDeps): Dashboa
     state: stateSignal as ReadonlySignal<DashboardViewState>,
     controls, timeRangeGroups, getFilterField,
     start, refresh, refreshTile, setFilter, applyFilter, applyFilters, clearFilter, clearAllFilters, resetFilters,
-    setTileSearch, cancelTile, syncDocument, setGridRenderMode, destroy,
+    setTileSearch, cancelTile, syncDocument, setGridRenderMode, setDashboardStyle, destroy,
   };
 }
diff --git a/src/styles.css b/src/styles.css
index d23f36e..ad6bf96 100644
--- a/src/styles.css
+++ b/src/styles.css
@@ -434,6 +434,8 @@ body {
 }
 .fm-item:hover { background: var(--bg-hover); }
 .fm-icon { display: flex; width: 15px; justify-content: center; color: var(--fg-mute); flex-shrink: 0; }
+.fm-leading { display: inline-flex; flex-shrink: 0; }
+.fm-trailing { display: inline-flex; flex-shrink: 0; margin-left: auto; }
 .fm-label { flex: 1; white-space: nowrap; }
 .fm-meta { font-size: 10px; color: var(--fg-faint); font-family: var(--mono); flex-shrink: 0; }
 .fm-sep { height: 1px; background: var(--border-faint); margin: 5px 0; }
@@ -759,6 +761,12 @@ body {
 }
 .shortcut-keys { display: inline-flex; align-items: center; gap: 4px; }
 .shortcut-then { color: var(--fg-faint); font-size: 11px; }
+.shortcut-plus { color: var(--fg-faint); font-size: 11px; }
+.dash-style-key {
+  font-family: var(--mono); font-size: 11px; padding: 2px 6px;
+  background: var(--bg-input); border: 1px solid var(--border); border-radius: 4px; color: var(--fg);
+  white-space: nowrap;
+}
 .modal-card .close-row {
   margin-top: 12px; display: flex; justify-content: flex-end;
 }
diff --git a/src/ui/dashboard.ts b/src/ui/dashboard.ts
index 3125b66..33ab6ea 100644
--- a/src/ui/dashboard.ts
+++ b/src/ui/dashboard.ts
@@ -63,7 +63,7 @@ import { createDashboardChartInteractionController } from './dashboard-chart-int
 import type { DashboardChartInteractionController } from './dashboard-chart-interaction.js';
 import { createDashboardViewerSession } from '../dashboard/application/dashboard-viewer-session.js';
 import type {
-  DashboardViewerSession, DashboardViewState, ViewerTileState, ViewerFilterState,
+  DashboardViewerSession, DashboardViewState, DashboardStyle, ViewerTileState, ViewerFilterState,
 } from '../dashboard/application/dashboard-viewer-session.js';
 import { defaultLayoutRegistry, resolveLayoutPluginSync } from '../dashboard/layouts/layout-registry.js';
 import type { FlowLayoutModel } from '../dashboard/layouts/flow-layout.js';
@@ -226,10 +226,14 @@ export function disposeDashboardSurface(): void {
 /** Build the Dashboard style picker with the same trigger and dropdown
  * vocabulary as File. The trigger shows only the active style; `sync()`
  * reflects session changes without adding a second header label. */
-type LayoutOption = [value: string, label: string, title?: string];
+type LayoutOption = [value: DashboardStyle, label: string, title: string, shortcut: string];
+function dashboardStyleKeyCaps(shortcut: string): HTMLElement {
+  const key = shortcut.toUpperCase();
+  return h('kbd', { class: 'dash-style-key' }, `G + ${key}`);
+}
 function buildLayoutMenu(
   doc: Document, onKeyboardOwnerChange: (owner: App['keyboardOwner']) => void,
-  options: LayoutOption[], getActive: () => string, onPick: (value: string) => void, ariaLabel: string,
+  options: LayoutOption[], getActive: () => string, onPick: (value: DashboardStyle) => void, ariaLabel: string,
 ): { el: HTMLButtonElement; sync: () => void } {
   const label = h('span');
   const el = h('button', {
@@ -251,10 +255,10 @@ function buildLayoutMenu(
       document: doc,
       trigger: el,
       menuClass: 'dash-file-menu dash-style-menu',
-      rows: options.map(([value, optionLabel]) => ({
+      rows: options.map(([value, optionLabel, _title, shortcut]) => ({
         kind: 'item',
         label: optionLabel,
-        meta: value === active ? 'Current' : null,
+        trailing: dashboardStyleKeyCaps(shortcut),
         extraClass: 'dash-style-item',
         onClick: () => onPick(value),
       })),
@@ -539,11 +543,6 @@ export async function renderDashboard(app: DashboardApp): Promise<void> {
     recordBoundParams: (bp) => app.params.recordBoundParams(bp),
     initialFilters: initialBag,
   });
-  // The global shortcut reaches this route-local port only while its renderer
-  // generation is current. It is cleared by both Dashboard cleanup and every
-  // application surface transition.
-  const commandPort = { surface: 'dashboard' as const, generation: surfaceGeneration, refresh: () => session.refresh() };
-  app.surfaceCommands = commandPort;
   let trackedSessionTileIds = new Set(viewerDoc.tiles.map((tile) => tile.id));
   const syncSessionDocument = (next: DashboardDocumentV1): void => {
     session.syncDocument(next);
@@ -577,29 +576,19 @@ export async function renderDashboard(app: DashboardApp): Promise<void> {
   // but the render-mode toggle is harmless to expose read-only since it never
   // persists anything.
   const EDITABLE_LAYOUT_OPTIONS: LayoutOption[] = [
-    ['grafana-grid', 'Grid Tiles', 'A responsive tile grid using authored spans and heights'],
-    ['full', 'Full view', 'Temporary full-width view — tile widths are not saved'],
-    ['report', 'Report', 'One centered, taller tile per row'],
-    ['columns-2', '2 columns', 'Arrange tiles in two columns'],
-    ['columns-3', '3 columns', 'Arrange tiles in three columns'],
-  ];
-  const READONLY_LAYOUT_OPTIONS: LayoutOption[] = [
-    ['grafana-grid', 'Grid Tiles', 'A responsive tile grid using authored spans and heights'],
-    ['full', 'Full view', 'Temporary full-width view — tile widths are not saved'],
+    ['grafana-grid', 'Grid Tiles', 'A responsive tile grid using authored spans and heights', 'G'],
+    ['full', 'Full view', 'Temporary full-width view — tile widths are not saved', 'F'],
+    ['report', 'Report', 'One centered, taller tile per row', 'R'],
+    ['columns-2', '2 columns', 'Arrange tiles in two columns', '2'],
+    ['columns-3', '3 columns', 'Arrange tiles in three columns', '3'],
   ];
   const getActiveLayoutOption = (): string => (currentDoc.layout.type === 'grafana-grid'
     ? (gridRenderMode === 'full' ? 'full' : 'grafana-grid')
     : typeof currentDoc.layout.preset === 'string' ? currentDoc.layout.preset : 'report');
-  const layoutMenu = buildLayoutMenu(
-    doc, keyboardOwnerChannel(app),
-    readOnly ? READONLY_LAYOUT_OPTIONS : EDITABLE_LAYOUT_OPTIONS,
-    getActiveLayoutOption,
-    (value) => {
-      // #321 read-only: the reduced menu offers ONLY 'grafana-grid'/'full'
-      // — either choice is ONLY ever the transient render-mode override, NEVER
-      // a command / persistence.
+  let layoutMenu: { el: HTMLButtonElement; sync: () => void };
+  const selectLayout = (value: DashboardStyle): void => {
       if (readOnly) {
-        session.setGridRenderMode(value === 'full' ? 'full' : 'tiles');
+        session.setDashboardStyle(value as DashboardStyle);
         layoutMenu.sync();
         return;
       }
@@ -636,18 +625,25 @@ export async function renderDashboard(app: DashboardApp): Promise<void> {
         runCommand({ type: 'change-layout', layout: { ...currentDoc.layout, preset: value as FlowPresetV1 } });
       }
       layoutMenu.sync();
-    },
+  };
+  layoutMenu = buildLayoutMenu(
+    doc, keyboardOwnerChannel(app),
+    EDITABLE_LAYOUT_OPTIONS,
+    () => readOnly ? session.state.value.style : getActiveLayoutOption(),
+    selectLayout,
     'Dashboard style',
   );
+  // The global shortcut reaches this route-local port only while its renderer
+  // generation is current. It is cleared by both Dashboard cleanup and every
+  // application surface transition.
+  const commandPort = {
+    surface: 'dashboard' as const,
+    generation: surfaceGeneration,
+    refresh: () => session.refresh(),
+    setDashboardStyle: selectLayout,
+  };
+  app.surfaceCommands = commandPort;
   const layoutWrap = h('div', { class: 'dash-layout-wrap' }, layoutMenu.el);
-  // #321 BLOCKER fix: the reduced read-only menu (Grid Tiles / Full view)
-  // is a grafana-grid-only render-mode toggle — expose it read-only ONLY when
-  // the persisted doc is grafana-grid. A read-only FLOW doc (report/columns-2/
-  // columns-3 — any pre-#321 shared doc) must hide the menu entirely: no
-  // engine switch is possible read-only, so this is decided once at build
-  // time from the static `currentDoc.layout.type`. Editable mode is unchanged
-  // (always the full menu).
-  const showLayoutSelect = !readOnly || currentDoc.layout.type === 'grafana-grid';
 
   // Dashboard keeps the shared header's File word and placement. View exposes
   // the safe Export row only; edit additionally exposes Import.
@@ -2178,13 +2174,12 @@ export async function renderDashboard(app: DashboardApp): Promise<void> {
     );
     if (sview.layout.engine !== lastEngineRendered) { lastLayoutSig = ''; lastGridSig = ''; lastEngineRendered = sview.layout.engine; }
     activeEngine = sview.layout.engine;
-    // #321: keep the local render-mode mirror current from the published
-    // grafana-grid layout view — the ONLY place this session-owned, transient
-    // state is read back into the UI. A change re-syncs the style menu, flips
-    // the grid host's `is-full` class (the CSS vertical-resize-cursor hook),
-    // and updates every built resize handle's accessible label.
-    if (sview.layout.engine === 'grafana-grid' && sview.layout.renderMode !== gridRenderMode) {
-      gridRenderMode = sview.layout.renderMode;
+    // Keep the local render-mode mirror current from the published session
+    // layout. View mode can now project flow styles too, so leaving a Full
+    // grid must also clear the grid host's vertical-only resize affordance.
+    const nextGridRenderMode = sview.layout.engine === 'grafana-grid' ? sview.layout.renderMode : 'tiles';
+    if (nextGridRenderMode !== gridRenderMode) {
+      gridRenderMode = nextGridRenderMode;
       layoutMenu.sync();
       grid.classList.toggle('is-full', gridRenderMode === 'full');
       for (const tileEl of tileEls.values()) applyResizeHandleMode(tileEl, gridRenderMode === 'full');
@@ -2198,7 +2193,7 @@ export async function renderDashboard(app: DashboardApp): Promise<void> {
   });
 
   const primaryToolbar = h('div', { class: 'dash-toolbar dash-toolbar-primary' },
-    showLayoutSelect ? layoutWrap : null,
+    layoutWrap,
     tileCount,
     tileSearch,
     timeFilterHost,
diff --git a/src/ui/menu.ts b/src/ui/menu.ts
index 3406a21..d6c5c21 100644
--- a/src/ui/menu.ts
+++ b/src/ui/menu.ts
@@ -37,7 +37,7 @@ import type { KeyboardOwner } from './app.types.js';
  *    focus target is the row's own first focusable descendant (an `<input>`/
  *    `<button>`/etc.), or the node itself when it can take focus directly. */
 export type MenuRow =
-  | { kind: 'item'; icon?: Node; label: string; meta?: string | null; onClick: () => void; extraClass?: string }
+  | { kind: 'item'; leading?: Node; icon?: Node; label: string; trailing?: Node; meta?: string | null; onClick: () => void; extraClass?: string }
   | { kind: 'section'; label: string }
   | { kind: 'sep' }
   | { kind: 'custom'; node: HTMLElement; focusable?: boolean };
@@ -108,8 +108,10 @@ export function openMenu(opts: MenuOptions): MenuHandle {
       role: 'menuitem',
       onclick: () => { close(); row.onClick(); },
     },
+      row.leading ? h('span', { class: 'fm-leading' }, row.leading) : null,
       row.icon ? h('span', { class: 'fm-icon' }, row.icon) : null,
       h('span', { class: 'fm-label' }, row.label),
+      row.trailing ? h('span', { class: 'fm-trailing' }, row.trailing) : null,
       row.meta ? h('span', { class: 'fm-meta' }, row.meta) : null);
     focusable.push(btn);
     return btn;
diff --git a/src/ui/shortcuts.ts b/src/ui/shortcuts.ts
index a8ca40c..3b36448 100644
--- a/src/ui/shortcuts.ts
+++ b/src/ui/shortcuts.ts
@@ -8,7 +8,8 @@ import type { SqlRoute } from '../core/sql-route.js';
 type ShortcutSurface = 'workspace' | 'dashboard' | 'all';
 type Section = 'application' | 'workspace' | 'dashboard' | 'general' | 'gestures';
 type ShortcutDispatch = 'application' | 'editor';
-type KeyName = 'mod-enter' | 'mod-shift-enter' | 'mod-s' | 'mod-shift-s' | 'mod-alt-1' | 'mod-alt-2' | 'mod-z' | 'mod-shift-z' | 'f1' | 'g-d' | 'g-w' | 'g-v' | 'g-e' | 'question' | 'escape';
+type KeyName = 'mod-enter' | 'mod-shift-enter' | 'mod-s' | 'mod-shift-s' | 'mod-alt-1' | 'mod-alt-2' | 'mod-z' | 'mod-shift-z' | 'f1' | 'g-d' | 'g-w' | 'g-v' | 'g-e' | 'g-g' | 'g-f' | 'g-r' | 'g-2' | 'g-3' | 'g-style' | 'question' | 'escape';
+type DashboardStyle = 'grafana-grid' | 'full' | 'report' | 'columns-2' | 'columns-3';
 
 export interface ShortcutDefinition {
   id: string;
@@ -19,6 +20,8 @@ export interface ShortcutDefinition {
   dispatch: ShortcutDispatch;
   sequence?: readonly [string, string];
   available?: (app: ShortcutsApp) => boolean;
+  /** Dispatch-only entries can be summarized by a single help row. */
+  help?: boolean;
   matches?: (e: ShortcutKeydownEvent, app: ShortcutsApp) => boolean;
   run?: (e: ShortcutKeydownEvent, app: ShortcutsApp) => string | null;
 }
@@ -40,6 +43,11 @@ export const SHORTCUT_CATALOG: readonly ShortcutDefinition[] = [
   { id: 'dashboard-refresh', label: 'Refresh all tiles', section: 'dashboard', surface: 'dashboard', key: 'mod-enter', dispatch: 'application', available: (a) => validDashboardPort(a), matches: (e) => modKey(e) && e.key === 'Enter' && !e.shiftKey, run: (e, a) => { e.preventDefault(); a.surfaceCommands!.refresh(); return 'dashboardRefresh'; } },
   { id: 'dashboard-view', label: 'View mode', section: 'dashboard', surface: 'dashboard', key: 'g-v', dispatch: 'application', sequence: ['g', 'v'], run: (e, a) => { e.preventDefault(); if (a.sqlRoute.mode === 'view') return null; void a.navigateSqlRoute?.({ surface: 'dashboard', workspaceKey: a.state.workspaceKey, mode: 'view' }, 'replace'); return 'dashboardView'; } },
   { id: 'dashboard-edit', label: 'Edit mode', section: 'dashboard', surface: 'dashboard', key: 'g-e', dispatch: 'application', sequence: ['g', 'e'], run: (e, a) => { e.preventDefault(); if (a.sqlRoute.mode === 'edit') return null; void a.navigateSqlRoute?.({ surface: 'dashboard', workspaceKey: a.state.workspaceKey, mode: 'edit' }, 'replace'); return 'dashboardEdit'; } },
+  { id: 'dashboard-grid-tiles', label: 'Grid Tiles', section: 'dashboard', surface: 'dashboard', key: 'g-g', dispatch: 'application', available: (a) => validDashboardPort(a), help: false, sequence: ['g', 'g'], run: (e, a) => { e.preventDefault(); a.surfaceCommands!.setDashboardStyle('grafana-grid'); return 'dashboardGridTiles'; } },
+  { id: 'dashboard-full-view', label: 'Full view', section: 'dashboard', surface: 'dashboard', key: 'g-f', dispatch: 'application', available: (a) => validDashboardPort(a), help: false, sequence: ['g', 'f'], run: (e, a) => { e.preventDefault(); a.surfaceCommands!.setDashboardStyle('full'); return 'dashboardFullView'; } },
+  { id: 'dashboard-report', label: 'Report', section: 'dashboard', surface: 'dashboard', key: 'g-r', dispatch: 'application', available: (a) => validDashboardPort(a), help: false, sequence: ['g', 'r'], run: (e, a) => { e.preventDefault(); a.surfaceCommands!.setDashboardStyle('report'); return 'dashboardReport'; } },
+  { id: 'dashboard-columns-2', label: '2 columns', section: 'dashboard', surface: 'dashboard', key: 'g-2', dispatch: 'application', available: (a) => validDashboardPort(a), help: false, sequence: ['g', '2'], run: (e, a) => { e.preventDefault(); a.surfaceCommands!.setDashboardStyle('columns-2'); return 'dashboardColumns2'; } },
+  { id: 'dashboard-columns-3', label: '3 columns', section: 'dashboard', surface: 'dashboard', key: 'g-3', dispatch: 'application', available: (a) => validDashboardPort(a), help: false, sequence: ['g', '3'], run: (e, a) => { e.preventDefault(); a.surfaceCommands!.setDashboardStyle('columns-3'); return 'dashboardColumns3'; } },
   { id: 'open-help', label: 'Show this dialog', section: 'general', surface: 'all', key: 'question', dispatch: 'application', matches: (e) => e.key === '?' && !modKey(e) && !isTypingTarget(e.target), run: (e, a) => { e.preventDefault(); a.actions.openShortcuts(); return 'shortcuts'; } },
   { id: 'close-overlay', label: 'Close dialog', section: 'general', surface: 'all', key: 'escape', dispatch: 'application', matches: (e) => e.key === 'Escape', run: (e, a) => { if (a.sqlRoute.surface === 'workspace' && a.closeDocPane?.()) { e.preventDefault(); return 'close-doc-pane'; } if (a.sqlRoute.surface === 'workspace' && a.state.running.value) { e.preventDefault(); a.actions.cancel(); return 'cancel'; } return null; } },
 ];
@@ -52,6 +60,7 @@ export interface SurfaceCommandPort {
   surface: 'dashboard';
   generation: number;
   refresh(): void;
+  setDashboardStyle(style: DashboardStyle): void;
 }
 
 /** Narrow controller contract; it deliberately avoids importing the full App. */
@@ -82,7 +91,9 @@ function keyParts(key: KeyName, mac: boolean): string[] {
     'mod-enter': [mod, 'Enter'], 'mod-shift-enter': [mod, shift, 'Enter'], 'mod-s': [mod, 'S'],
     'mod-shift-s': [mod, shift, 'S'], 'mod-alt-1': [mod, alt, '1'], 'mod-alt-2': [mod, alt, '2'],
     'mod-z': [mod, 'Z'], 'mod-shift-z': [mod, shift, 'Z'], f1: ['F1'], 'g-d': ['G', 'then', 'D'],
-    'g-w': ['G', 'then', 'W'], 'g-v': ['G', 'then', 'V'], 'g-e': ['G', 'then', 'E'], question: ['?'], escape: ['Esc'],
+    'g-w': ['G', 'then', 'W'], 'g-v': ['G', 'then', 'V'], 'g-e': ['G', 'then', 'E'],
+    'g-g': ['G', 'then', 'G'], 'g-f': ['G', 'then', 'F'], 'g-r': ['G', 'then', 'R'],
+    'g-2': ['G', 'then', '2'], 'g-3': ['G', 'then', '3'], 'g-style': ['G', 'plus', 'G/F/R/2/3'], question: ['?'], escape: ['Esc'],
   };
   return keys[key];
 }
@@ -97,7 +108,7 @@ function visibleDefinitions(app: ShortcutsApp): ShortcutDefinition[] {
 function keyCaps(parts: string[]): HTMLElement[] {
   return parts.map((part, index) => part === 'then'
     ? h('span', { class: 'shortcut-then' }, 'then')
-    : h('kbd', { key: String(index) }, part));
+    : part === 'plus' ? h('span', { class: 'shortcut-plus' }, '+') : h('kbd', { key: String(index) }, part));
 }
 
 const sectionNames: Record<Section, string> = {
@@ -138,12 +149,17 @@ export function openShortcuts(app: ShortcutsApp, onClose?: () => void): { backdr
   const mac = platformIsMac(doc);
   const sections: HTMLElement[] = [];
   for (const section of ['application', 'workspace', 'dashboard', 'general'] as const) {
-    const entries = rows.filter((row) => row.section === section);
+    const entries = rows.filter((row) => row.section === section && row.help !== false);
     if (!entries.length) continue;
+    const styleHelp = section === 'dashboard' && rows.some((row) => row.id === 'dashboard-grid-tiles')
+      ? [h('div', { class: 'row' }, h('span', { class: 'label' }, 'Style'),
+        h('span', { class: 'shortcut-keys' }, ...keyCaps(keyParts('g-style', mac))))]
+      : [];
     sections.push(h('section', { class: 'shortcut-section', 'aria-label': sectionNames[section] },
       h('h3', { class: 'section-label' }, sectionNames[section]),
       ...entries.map((row) => h('div', { class: 'row' }, h('span', { class: 'label' }, row.label),
         h('span', { class: 'shortcut-keys' }, ...keyCaps(keyParts(row.key, mac))))),
+      ...styleHelp,
     ));
   }
   if (app.sqlRoute.surface === 'workspace') {
@@ -209,10 +225,11 @@ function consumeChord(e: ShortcutKeydownEvent, app: ShortcutsApp): string | null
     && (chord.generation === null || chord.generation === app.captureSurfaceGeneration?.());
   if (!stillCurrent) return null;
   const key = e.key.toLowerCase();
-  if (key === 'g') { beginChord(app); e.preventDefault(); return 'chord'; }
   const command = visibleDefinitions(app).find((definition) => definition.sequence?.[0] === 'g'
     && definition.sequence[1] === key);
-  return command?.run ? command.run(e, app) : null;
+  if (command?.run) return command.run(e, app);
+  if (key === 'g') { beginChord(app); e.preventDefault(); return 'chord'; }
+  return null;
 }
 
 /** Global dispatcher. Commands are gated by current route, identity and surface. */
diff --git a/tests/unit/dashboard-viewer-session.test.ts b/tests/unit/dashboard-viewer-session.test.ts
index f412de4..9747d27 100644
--- a/tests/unit/dashboard-viewer-session.test.ts
+++ b/tests/unit/dashboard-viewer-session.test.ts
@@ -1339,6 +1339,47 @@ describe('setGridRenderMode / Full view (#321)', () => {
     if (layout.engine !== 'grafana-grid') throw new Error('expected grafana-grid engine');
     expect(layout.renderMode).toBe('tiles');
   });
+
+  it('projects every Dashboard style without mutating or re-running the session document', async () => {
+    const { exec, calls } = makeExec(() => ({ columns: [{ name: 'n' }], rows: [[1]] }));
+    const document = gridDoc();
+    const before = JSON.stringify(document);
+    const session = createDashboardViewerSession(makeDeps({ document, exec, queries: gridQueries() }));
+    await session.start();
+    const executed = calls.length;
+
+    session.setDashboardStyle('full');
+    expect(session.state.value.style).toBe('full');
+    expect(session.state.value.layout.engine).toBe('grafana-grid');
+    session.setDashboardStyle('report');
+    expect(session.state.value.style).toBe('report');
+    expect(session.state.value.layout.engine).toBe('flow');
+    if (session.state.value.layout.engine === 'flow') expect(session.state.value.layout.preset).toBe('report');
+    session.setDashboardStyle('columns-3');
+    if (session.state.value.layout.engine === 'flow') expect(session.state.value.layout.columns).toBe(3);
+    session.setDashboardStyle('grafana-grid');
+    expect(session.state.value.layout.engine).toBe('grafana-grid');
+    expect(calls.length).toBe(executed);
+    expect(JSON.stringify(document)).toBe(before);
+  });
+
+  it('projects grid styles from a flow document, preserves flow placements, and ignores duplicate/destroyed choices', async () => {
+    const { exec } = makeExec(() => ({ columns: [{ name: 'n' }], rows: [[1]] }));
+    const document = doc({
+      tiles: [tile('a', 'qa'), tile('b', 'qb')],
+      layout: { type: 'flow', version: 1, preset: 'columns-2', items: { a: { span: 2 } } },
+    });
+    const session = createDashboardViewerSession(makeDeps({ document, exec, queries: gridQueries() }));
+    await session.start();
+    session.setDashboardStyle('columns-3');
+    if (session.state.value.layout.engine === 'flow') expect(session.state.value.layout.rows[0].tiles[0].span).toBe(2);
+    session.setDashboardStyle('full');
+    expect(session.state.value.layout.engine).toBe('grafana-grid');
+    session.setDashboardStyle('full'); // duplicate selection is a no-op
+    session.destroy();
+    session.setDashboardStyle('report');
+    expect(session.state.value.style).toBe('full');
+  });
 });
 
 describe('flow layout (mobile normalization)', () => {
diff --git a/tests/unit/dashboard.test.ts b/tests/unit/dashboard.test.ts
index 6cb170e..492d2a2 100644
--- a/tests/unit/dashboard.test.ts
+++ b/tests/unit/dashboard.test.ts
@@ -2719,19 +2719,23 @@ describe('renderDashboard — Full view (#321)', () => {
     expect(handle.getAttribute('aria-label')).toBe('Resize');
   });
 
-  it('read-only view: the reduced style menu only calls session.setGridRenderMode — never a command', async () => {
+  it('read-only view switches every style session-locally — never a command', async () => {
     const detached = twoTilesGrid();
     const { app, commit } = modeApp({
       workspace: detached, mode: 'view',
     });
     await render(app);
-    expect(layoutOptions(app.root)).toEqual(['Grid Tiles', 'Full view']);
+    expect(layoutOptions(app.root)).toEqual(['Grid Tiles', 'Full view', 'Report', '2 columns', '3 columns']);
     pickLayout(app.root, 'full');
     expect(layoutSelect(app.root).value).toBe('full');
     for (const card of qsa<HTMLElement>(app.root, '.dash-gg-tile')) {
       expect((card.style as CSSStyleDeclaration).gridColumn).toBe('span 12');
     }
     expect(commit).not.toHaveBeenCalled();
+    pickLayout(app.root, 'columns-3');
+    expect(layoutSelect(app.root).value).toBe('columns-3');
+    expect(qs(app.root, '.dash-gg-grid')).toBeNull();
+    expect(commit).not.toHaveBeenCalled();
     pickLayout(app.root, 'grafana-grid');
     expect(layoutSelect(app.root).value).toBe('grafana-grid');
     expect(commit).not.toHaveBeenCalled();
@@ -3991,7 +3995,7 @@ describe('renderDashboard — unified live modes (#407)', () => {
     expect(qsa(app.root, '.dash-tile').length).toBe(1);
     expect(qs(app.root, '.dash-tile .dash-gg-grip')).toBeNull();
     expect(layoutSelect(app.root)).not.toBeNull();
-    expect(layoutOptions(app.root)).toEqual(['Grid Tiles', 'Full view']);
+    expect(layoutOptions(app.root)).toEqual(['Grid Tiles', 'Full view', 'Report', '2 columns', '3 columns']);
     expect(commit).not.toHaveBeenCalled();
   });
 
@@ -4104,6 +4108,10 @@ describe('renderDashboard — unified live modes (#407)', () => {
     expect(styleMenu.classList.contains('file-menu')).toBe(true);
     expect(qsa(styleMenu, '.fm-item .fm-label').map((item) => item.textContent))
       .toEqual(['Grid Tiles', 'Full view', 'Report', '2 columns', '3 columns']);
+    expect(qsa(styleMenu, '.dash-style-item .fm-trailing').map((item) => item.textContent))
+      .toEqual(['G + G', 'G + F', 'G + R', 'G + 2', 'G + 3']);
+    expect(qsa(styleMenu, '.dash-style-item .fm-leading')).toHaveLength(0);
+    expect(styleMenu.textContent).not.toContain('Current');
     style.click();
     expect(qs(app.root, '.dash-updated')).not.toBeNull();
     const refresh = qs(app.root, '.dash-refresh');
diff --git a/tests/unit/file-menu.test.ts b/tests/unit/file-menu.test.ts
index 187f24f..e588b32 100644
--- a/tests/unit/file-menu.test.ts
+++ b/tests/unit/file-menu.test.ts
@@ -454,7 +454,7 @@ describe('Import queries', () => {
     expect(app.actions.save).not.toHaveBeenCalled();
     expect(app.actions.setEditorMode).not.toHaveBeenCalled();
     app.sqlRoute = { surface: 'dashboard', workspaceKey: app.state.workspaceKey, mode: 'view' };
-    app.surfaceCommands = { surface: 'dashboard', generation: 0, refresh: vi.fn() };
+    app.surfaceCommands = { surface: 'dashboard', generation: 0, refresh: vi.fn(), setDashboardStyle: vi.fn() };
     expect(handleKeydown(shortcut('Enter', { metaKey: true }), app)).toBeNull();
     expect(app.surfaceCommands.refresh).not.toHaveBeenCalled();
     app.sqlRoute = { surface: 'workspace', workspaceKey: app.state.workspaceKey };
diff --git a/tests/unit/menu.test.ts b/tests/unit/menu.test.ts
index f6b2227..e934d81 100644
--- a/tests/unit/menu.test.ts
+++ b/tests/unit/menu.test.ts
@@ -20,16 +20,18 @@ function itemRow(label: string, onClick = vi.fn(), extra: Partial<MenuRow & { ki
 }
 
 describe('openMenu — structure (every row kind)', () => {
-  it('renders item (icon+label+meta), section, sep, and a plain custom row', () => {
+  it('renders item (leading+icon+label+trailing+meta), section, sep, and a plain custom row', () => {
     const btn = trigger();
     const icon = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
+    const leading = document.createElement('kbd'); leading.textContent = 'G';
+    const trailing = document.createElement('kbd'); trailing.textContent = 'G + G';
     const custom = document.createElement('div');
     custom.className = 'my-custom-row';
     const onClick = vi.fn();
     const handle = openMenu({
       document, trigger: btn,
       rows: [
-        { kind: 'item', icon, label: 'Do thing', meta: '.json', onClick },
+        { kind: 'item', leading, icon, label: 'Do thing', trailing, meta: '.json', onClick },
         { kind: 'section', label: 'A section' },
         { kind: 'sep' },
         { kind: 'custom', node: custom },
@@ -38,8 +40,10 @@ describe('openMenu — structure (every row kind)', () => {
     expect(handle.el.classList.contains('file-menu')).toBe(true);
     expect(handle.el.getAttribute('role')).toBe('menu');
     const item = handle.el.querySelector('.fm-item')!;
+    expect(item.querySelector('.fm-leading')!.textContent).toBe('G');
     expect(item.querySelector('.fm-icon svg')).not.toBeNull();
     expect(item.querySelector('.fm-label')!.textContent).toBe('Do thing');
+    expect(item.querySelector('.fm-trailing')!.textContent).toBe('G + G');
     expect(item.querySelector('.fm-meta')!.textContent).toBe('.json');
     expect(item.getAttribute('role')).toBe('menuitem');
     expect(handle.el.querySelector('.fm-section')!.textContent).toBe('A section');
diff --git a/tests/unit/shortcuts.test.ts b/tests/unit/shortcuts.test.ts
index 2b8e0b0..ef64f2f 100644
--- a/tests/unit/shortcuts.test.ts
+++ b/tests/unit/shortcuts.test.ts
@@ -71,9 +71,9 @@ describe('openShortcuts', () => {
     expect(text).toContain('Shift-click');
   });
   it('renders Dashboard-only help from the shared catalog and supplies dialog accessibility', () => {
-    const refresh = vi.fn();
+    const refresh = vi.fn(); const setDashboardStyle = vi.fn();
     const app = makeApp({ document, sqlRoute: { surface: 'dashboard', workspaceKey: 'w', mode: 'view' },
-      surfaceCommands: { surface: 'dashboard', generation: 0, refresh } });
+      surfaceCommands: { surface: 'dashboard', generation: 0, refresh, setDashboardStyle } });
     const invoke = document.createElement('button'); document.body.appendChild(invoke); invoke.focus();
     const opened = openShortcuts(app)!;
     const card = document.querySelector<HTMLElement>('.modal-card')!;
@@ -81,6 +81,11 @@ describe('openShortcuts', () => {
     expect(card.getAttribute('aria-modal')).toBe('true');
     expect(card.textContent).toContain('Refresh all tiles');
     expect(card.textContent).toContain('Open SQL Browser');
+    const dashboardRows = [...card.querySelectorAll<HTMLElement>('.shortcut-section[aria-label="Dashboard"] .row')];
+    expect(dashboardRows.map((row) => row.querySelector('.label')?.textContent))
+      .toEqual(['Refresh all tiles', 'View mode', 'Edit mode', 'Style']);
+    expect(dashboardRows.at(-1)?.textContent).toContain('G/F/R/2/3');
+    expect(card.textContent).not.toContain('Grid Tiles');
     expect(card.textContent).not.toContain('Run query');
     expect(card.textContent).not.toContain('Schema tree');
     expect(card.querySelectorAll('kbd').length).toBeGreaterThan(0);
@@ -122,14 +127,20 @@ describe('handleKeydown', () => {
   });
 
   it('dispatches Dashboard refresh and mode navigation only for the current viewer generation', () => {
-    const refresh = vi.fn();
+    const refresh = vi.fn(); const setDashboardStyle = vi.fn();
     const app = makeApp({ sqlRoute: { surface: 'dashboard', workspaceKey: 'sql_library', mode: 'edit' },
       captureSurfaceGeneration: () => 7,
-      surfaceCommands: { surface: 'dashboard', generation: 7, refresh },
+      surfaceCommands: { surface: 'dashboard', generation: 7, refresh, setDashboardStyle },
       navigateSqlRoute: vi.fn(async () => {}) });
     expect(handleKeydown(ev({ metaKey: true, key: 'Enter' }), app)).toBe('dashboardRefresh');
     expect(refresh).toHaveBeenCalledOnce();
     expect(handleKeydown(ev({ key: 'g' }), app)).toBe('chord');
+    expect(handleKeydown(ev({ key: 'g' }), app)).toBe('dashboardGridTiles');
+    expect(setDashboardStyle).toHaveBeenLastCalledWith('grafana-grid');
+    expect(handleKeydown(ev({ key: 'g' }), app)).toBe('chord');
+    expect(handleKeydown(ev({ key: '2' }), app)).toBe('dashboardColumns2');
+    expect(setDashboardStyle).toHaveBeenLastCalledWith('columns-2');
+    expect(handleKeydown(ev({ key: 'g' }), app)).toBe('chord');
     expect(handleKeydown(ev({ key: 'v' }), app)).toBe('dashboardView');
     expect(app.navigateSqlRoute).toHaveBeenCalledWith({ surface: 'dashboard', workspaceKey: 'sql_library', mode: 'view' }, 'replace');
     (app.sqlRoute as { mode?: 'view' | 'edit' }).mode = 'view';
@@ -142,10 +153,26 @@ describe('handleKeydown', () => {
     const editing = makeApp({ sqlRoute: { surface: 'dashboard', workspaceKey: 'sql_library', mode: 'edit' } });
     expect(handleKeydown(ev({ key: 'g' }), editing)).toBe('chord');
     expect(handleKeydown(ev({ key: 'e' }), editing)).toBeNull();
-    app.surfaceCommands = { surface: 'dashboard', generation: 6, refresh };
+    app.surfaceCommands = { surface: 'dashboard', generation: 6, refresh, setDashboardStyle };
     expect(handleKeydown(ev({ metaKey: true, key: 'Enter' }), app)).toBeNull();
   });
 
+  it('selects every Dashboard style through its G chord', () => {
+    const setDashboardStyle = vi.fn();
+    const app = makeApp({
+      sqlRoute: { surface: 'dashboard', workspaceKey: 'sql_library', mode: 'view' },
+      surfaceCommands: { surface: 'dashboard', generation: 0, refresh: vi.fn(), setDashboardStyle },
+    });
+    for (const [key, style, result] of [
+      ['g', 'grafana-grid', 'dashboardGridTiles'], ['f', 'full', 'dashboardFullView'],
+      ['r', 'report', 'dashboardReport'], ['2', 'columns-2', 'dashboardColumns2'], ['3', 'columns-3', 'dashboardColumns3'],
+    ] as const) {
+      expect(handleKeydown(ev({ key: 'g' }), app)).toBe('chord');
+      expect(handleKeydown(ev({ key }), app)).toBe(result);
+      expect(setDashboardStyle).toHaveBeenLastCalledWith(style);
+    }
+  });
+
   it('routes the G chord by current surface, and resets it on mismatch, timeout, blur and stale generation', () => {
     vi.useFakeTimers();
     const navigateSqlRoute = vi.fn(async () => {});
@@ -176,9 +203,9 @@ describe('handleKeydown', () => {
   });
 
   it('keeps surface actions behind keyboard-owning overlays and ignores plain keys while typing', () => {
-    const refresh = vi.fn();
+    const refresh = vi.fn(); const setDashboardStyle = vi.fn();
     const app = makeApp({ sqlRoute: { surface: 'dashboard', workspaceKey: 'sql_library', mode: 'view' },
-      surfaceCommands: { surface: 'dashboard', generation: 0, refresh } });
+      surfaceCommands: { surface: 'dashboard', generation: 0, refresh, setDashboardStyle } });
     app.keyboardOwner = { kind: 'popover' };
     expect(handleKeydown(ev({ metaKey: true, key: 'Enter' }), app)).toBeNull();
     app.keyboardOwner = null;