@cueloop/client 0.1.0-alpha.20 → 0.1.0-alpha.21

package/src/config.ts

@@ -1,8 +1,9 @@
 /**
  * Layered TOML config: built-in defaults → user config → trusted repo
  * config → env. Sections: [keys] action = "combo" (every action rebindable),
- * [theme] per-token overrides, [ui] auto_close + editor, [integrations.obsidian]
- * notes-vault export.
+ * [theme] per-token overrides, [ui] auto_close + editor + the review-panel
+ * layout (review_width + review_state), [integrations.obsidian] notes-vault
+ * export.
  */
 
 import { existsSync, readFileSync } from "node:fs";
@@ -12,6 +13,7 @@ import { OBSIDIAN_DEFAULTS, type ObsidianConfig } from "@cueloop/integration-obs
 import { writeFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import { DARK, type Theme } from "./theme";
+import { REVIEW_DEFAULT_WIDTH, clampWidth, type ReviewPanelMode } from "./review-panel";
 
 export interface KeymapConfig {
   [action: string]: string | string[];
@@ -27,7 +29,11 @@ export type AutoClose = "off" | number;
 export interface CueloopConfig {
   keys: Record<string, string[]>;
   theme: Theme;
-  ui: { autoClose: AutoClose; editor?: string };
+  /**
+   * ui.reviewState / ui.reviewWidth are CLIENT VIEW STATE: the review panel's
+   * collapse mode and expanded-rail width, persisted so they survive restarts.
+   */
+  ui: { autoClose: AutoClose; editor?: string; reviewState: ReviewPanelMode; reviewWidth: number };
   integrations: IntegrationsConfig;
 }
 
@@ -48,6 +54,9 @@ export const DEFAULT_KEYS: Record<string, string[]> = {
   submit: ["return", "enter"],
   quit: ["q"],
   walk: ["w"],
+  review_cycle: ["b"],
+  review_wider: ["]"],
+  review_narrower: ["["],
 };
 
 function parseToml(text: string): Record<string, unknown> {
@@ -68,12 +77,20 @@ function layer(base: CueloopConfig, raw: Record<string, unknown>): CueloopConfig
       out.keys[action] = Array.isArray(combo) ? combo : [combo];
     }
   }
-  const ui = raw["ui"] as { auto_close?: unknown; editor?: unknown } | undefined;
+  const ui = raw["ui"] as
+    | { auto_close?: unknown; editor?: unknown; review_width?: unknown; review_state?: unknown }
+    | undefined;
   if (ui && ui.auto_close !== undefined) {
     if (ui.auto_close === "off") out.ui.autoClose = "off";
     else if (typeof ui.auto_close === "number" && ui.auto_close >= 0) out.ui.autoClose = ui.auto_close;
   }
   if (ui && typeof ui.editor === "string" && ui.editor.trim()) out.ui.editor = ui.editor.trim();
+  if (ui && typeof ui.review_width === "number" && Number.isFinite(ui.review_width)) {
+    out.ui.reviewWidth = clampWidth(ui.review_width);
+  }
+  if (ui && (ui.review_state === "expanded" || ui.review_state === "compact" || ui.review_state === "hidden")) {
+    out.ui.reviewState = ui.review_state;
+  }
   const theme = raw["theme"] as Partial<Record<keyof Theme, string>> | undefined;
   if (theme) {
     for (const [token, value] of Object.entries(theme)) {
@@ -101,13 +118,10 @@ export function loadConfig(options: { repoRoot?: string; userConfigPath?: string
   let config: CueloopConfig = {
     keys: { ...DEFAULT_KEYS },
     theme: { ...DARK },
-    ui: { autoClose: "off" },
+    ui: { autoClose: "off", reviewState: "expanded", reviewWidth: REVIEW_DEFAULT_WIDTH },
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
   };
-  const userPath =
-    options.userConfigPath ??
-    process.env.CUELOOP_CONFIG ??
-    join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cueloop", "config.toml");
+  const userPath = userConfigPathFrom(options.userConfigPath);
   for (const path of [userPath, options.repoRoot ? join(options.repoRoot, ".cueloop", "config.toml") : undefined]) {
     if (!path || !existsSync(path)) continue;
     try {
@@ -128,26 +142,47 @@ export function actionFor(keys: Record<string, string[]>, name: string, shift: b
   return undefined;
 }
 
-/**
- * Persist the auto-close choice into the user config file. Line-level TOML
- * surgery on the one key we own: replace an existing `auto_close`, or append
- * an `[ui]` section - a full TOML writer is not worth its weight here.
- */
-export function persistAutoClose(value: AutoClose, userConfigPath?: string): void {
-  const path =
+function userConfigPathFrom(userConfigPath?: string): string {
+  return (
     userConfigPath ??
     process.env.CUELOOP_CONFIG ??
-    join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cueloop", "config.toml");
-  const rendered = value === "off" ? '"off"' : String(value);
+    join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cueloop", "config.toml")
+  );
+}
+
+/**
+ * Persist one `[ui]` key into the user config file. Line-level TOML surgery on
+ * the keys we own: replace the existing assignment, or drop it under an `[ui]`
+ * section (appending the section when absent) - a full TOML writer is not worth
+ * its weight here.
+ */
+function persistUiSetting(key: string, rendered: string, userConfigPath?: string): void {
+  const path = userConfigPathFrom(userConfigPath);
   let text = "";
   if (existsSync(path)) text = readFileSync(path, "utf8");
-  if (/^\s*auto_close\s*=/m.test(text)) {
-    text = text.replace(/^(\s*)auto_close\s*=.*$/m, `$1auto_close = ${rendered}`);
+  const assignment = new RegExp(`^(\\s*)${key}\\s*=.*$`, "m");
+  if (assignment.test(text)) {
+    text = text.replace(assignment, `$1${key} = ${rendered}`);
   } else if (/^\[ui\]/m.test(text)) {
-    text = text.replace(/^\[ui\]\s*$/m, `[ui]\nauto_close = ${rendered}`);
+    text = text.replace(/^\[ui\]\s*$/m, `[ui]\n${key} = ${rendered}`);
   } else {
-    text = text.trimEnd() + (text.trim() ? "\n\n" : "") + `[ui]\nauto_close = ${rendered}\n`;
+    text = text.trimEnd() + (text.trim() ? "\n\n" : "") + `[ui]\n${key} = ${rendered}\n`;
   }
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, text);
 }
+
+/** Persist the auto-close choice (`[ui] auto_close`) into the user config. */
+export function persistAutoClose(value: AutoClose, userConfigPath?: string): void {
+  persistUiSetting("auto_close", value === "off" ? '"off"' : String(value), userConfigPath);
+}
+
+/** Persist the expanded-rail width (`[ui] review_width`) into the user config. */
+export function persistReviewWidth(width: number, userConfigPath?: string): void {
+  persistUiSetting("review_width", String(clampWidth(width)), userConfigPath);
+}
+
+/** Persist the review-panel collapse mode (`[ui] review_state`) into the config. */
+export function persistReviewState(state: ReviewPanelMode, userConfigPath?: string): void {
+  persistUiSetting("review_state", `"${state}"`, userConfigPath);
+}

package/src/keymap.test.ts

@@ -25,8 +25,8 @@ function state(patch: Partial<KeyState> = {}): KeyState {
   };
 }
 
-function key(name: string, shift = false): { name: string; shift: boolean } {
-  return { name, shift };
+function key(name: string, shift = false, meta = false): { name: string; shift: boolean; meta: boolean } {
+  return { name, shift, meta };
 }
 
 describe("compose overlay", () => {
@@ -45,6 +45,15 @@ describe("compose overlay", () => {
       expect(reduceKey(keyState, key(name))).toEqual(expected);
     });
   }
+
+  // ⌥/Alt+⏎ (meta) and shift+⏎ insert a newline in the composer, so the
+  // grammar must not save on them; only a bare ⏎ saves.
+  test("option/alt+return (meta) does not save - the textarea inserts a newline", () => {
+    expect(reduceKey(keyState, key("return", false, true))).toEqual([]);
+  });
+  test("shift+return does not save - the textarea inserts a newline", () => {
+    expect(reduceKey(keyState, key("return", true, false))).toEqual([]);
+  });
 });
 
 describe("submit overlay", () => {
@@ -53,8 +62,8 @@ describe("submit overlay", () => {
     ["escape", [{ type: "closeOverlay" }]],
     ["return", [{ type: "submitVerdict" }]],
     ["enter", [{ type: "submitVerdict" }]],
-    ["left", [{ type: "cycleVerdict", dir: -1 }]],
-    ["right", [{ type: "cycleVerdict", dir: 1 }]],
+    ["left", [{ type: "cycleVerdict", direction: -1 }]],
+    ["right", [{ type: "cycleVerdict", direction: 1 }]],
     ["j", []],
     ["q", []],
   ];
@@ -265,6 +274,37 @@ describe("guided walk", () => {
   });
 });
 
+describe("review panel controls", () => {
+  const table: [string, Intent[]][] = [
+    ["b", [{ type: "cycleReviewPanel" }]],
+    ["]", [{ type: "resizeReviewPanel", direction: 1 }]],
+    ["[", [{ type: "resizeReviewPanel", direction: -1 }]],
+  ];
+  for (const view of ["plan", "diff"] as const) {
+    for (const [name, expected] of table) {
+      test(`${view} ${name} -> ${JSON.stringify(expected)}`, () => {
+        expect(reduceKey(state({ view }), key(name))).toEqual(expected);
+      });
+    }
+  }
+
+  test("observers may still collapse and resize the panel (it is view state, not a mutation)", () => {
+    const observer = state({ readOnly: true });
+    expect(reduceKey(observer, key("b"))).toEqual([{ type: "cycleReviewPanel" }]);
+    expect(reduceKey(observer, key("]"))).toEqual([{ type: "resizeReviewPanel", direction: 1 }]);
+  });
+
+  test("span mode still owns b as a span verb, not a panel cycle", () => {
+    expect(reduceKey(state({ spanMode: true }), key("b"))).toEqual([{ type: "spanKey", name: "b" }]);
+  });
+
+  test("the walk overlay keeps the brackets for stepping", () => {
+    const walking = state({ view: "diff", overlay: "walk" });
+    expect(reduceKey(walking, key("]"))).toEqual([{ type: "walkForward" }]);
+    expect(reduceKey(walking, key("["))).toEqual([{ type: "walkBack" }]);
+  });
+});
+
 describe("duplicated-branch collapse", () => {
   test("plan and diff produce the same intents for annotation nav, delete, and submit", () => {
     for (const patch of [

package/src/keymap.ts

@@ -32,14 +32,18 @@ export type Intent =
   | { type: "closeOverlay" }
   | { type: "saveCompose" }
   | { type: "submitVerdict" }
-  | { type: "cycleVerdict"; dir: -1 | 1 }
+  | { type: "cycleVerdict"; direction: -1 | 1 }
   | { type: "finishReview" }
   | { type: "optInAutoClose" }
-  | { type: "dismissCompletion" };
+  | { type: "dismissCompletion" }
+  | { type: "cycleReviewPanel" }
+  | { type: "resizeReviewPanel"; direction: -1 | 1 };
 
 export interface KeyInput {
   name: string;
   shift: boolean;
+  /** Option/Alt arrives as `meta` in this terminal stack (never as a raw alt). */
+  meta?: boolean;
 }
 
 export interface KeyState {
@@ -83,10 +87,17 @@ export function reduceKey(state: KeyState, key: KeyInput, resolvedAction?: strin
   if (state.overlay === "compose" || state.overlay === "submit") {
     if (name === "escape") return [{ type: "closeOverlay" }];
     if (name === "return" || name === "enter") {
-      return [state.overlay === "compose" ? { type: "saveCompose" } : { type: "submitVerdict" }];
+      // In the composer, ⌥/Alt+⏎ (meta) and shift+⏎ insert a newline - the
+      // focused textarea owns that; only a bare ⏎ saves. The submit overlay
+      // keeps its plain ⏎ submit.
+      if (state.overlay === "compose") {
+        if (key.shift || key.meta) return [];
+        return [{ type: "saveCompose" }];
+      }
+      return [{ type: "submitVerdict" }];
     }
     if (state.overlay === "submit" && (name === "left" || name === "right")) {
-      return [{ type: "cycleVerdict", dir: name === "left" ? -1 : 1 }];
+      return [{ type: "cycleVerdict", direction: name === "left" ? -1 : 1 }];
     }
     return [];
   }
@@ -117,11 +128,25 @@ export function reduceKey(state: KeyState, key: KeyInput, resolvedAction?: strin
   if (state.readOnly && mutating) return status("observer - read-only");
 
   if (state.view === "inbox") return inboxGrammar(state, name);
-  if (state.view === "diff") return diffGrammar(state, action);
+  // span mode owns its single-letter keys (b slides the span back) before the
+  // review-panel controls claim them
   if (state.spanMode) return spanGrammar(name);
+  // the review panel rides both plan and diff reviews; collapsing and resizing
+  // are view state, so the read-only gate above lets them through
+  const reviewPanel = reviewPanelGrammar(action);
+  if (reviewPanel) return reviewPanel;
+  if (state.view === "diff") return diffGrammar(state, action);
   return planGrammar(state, action, name);
 }
 
+/** The review-panel controls: cycle the mode, widen and narrow the rail. */
+function reviewPanelGrammar(action: string | undefined): Intent[] | null {
+  if (action === "review_cycle") return [{ type: "cycleReviewPanel" }];
+  if (action === "review_wider") return [{ type: "resizeReviewPanel", direction: 1 }];
+  if (action === "review_narrower") return [{ type: "resizeReviewPanel", direction: -1 }];
+  return null;
+}
+
 function inboxGrammar(state: KeyState, name: string): Intent[] {
   if (!state.hasInboxItems) return [];
   if (name === "j" || name === "down") return [{ type: "inboxMove", to: "down" }];

package/src/review-panel.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, test } from "bun:test";
+import {
+  REVIEW_DEFAULT_WIDTH,
+  REVIEW_MAX_WIDTH,
+  REVIEW_MIN_WIDTH,
+  REVIEW_PLAN_MIN_WIDTH,
+  REVIEW_RESIZE_STEP,
+  clampWidth,
+  cycleReviewPanelMode,
+  maxWidthForTerminal,
+  resolveReviewWidth,
+  reviewRowsToDivider,
+  toggleReviewPanelMode,
+  widthFromMouseColumn,
+} from "./review-panel";
+
+describe("clampWidth", () => {
+  test("keeps a width inside the bounds untouched", () => {
+    expect(clampWidth(REVIEW_DEFAULT_WIDTH)).toBe(REVIEW_DEFAULT_WIDTH);
+  });
+
+  test("clamps below the minimum and above the maximum", () => {
+    expect(clampWidth(REVIEW_MIN_WIDTH - 10)).toBe(REVIEW_MIN_WIDTH);
+    expect(clampWidth(REVIEW_MAX_WIDTH + 10)).toBe(REVIEW_MAX_WIDTH);
+  });
+
+  test("rounds a fractional column to a whole one", () => {
+    expect(clampWidth(30.7)).toBe(31);
+  });
+
+  test("honors explicit bounds", () => {
+    expect(clampWidth(100, 10, 20)).toBe(20);
+    expect(clampWidth(5, 10, 20)).toBe(10);
+  });
+});
+
+describe("cycleReviewPanelMode", () => {
+  test("cycles expanded -> compact -> hidden -> expanded", () => {
+    expect(cycleReviewPanelMode("expanded")).toBe("compact");
+    expect(cycleReviewPanelMode("compact")).toBe("hidden");
+    expect(cycleReviewPanelMode("hidden")).toBe("expanded");
+  });
+});
+
+describe("toggleReviewPanelMode", () => {
+  test("the chevron toggles only between expanded and compact, never hidden", () => {
+    expect(toggleReviewPanelMode("expanded")).toBe("compact");
+    expect(toggleReviewPanelMode("compact")).toBe("expanded");
+    // a hidden panel has no chevron; a stray toggle still opens it
+    expect(toggleReviewPanelMode("hidden")).toBe("expanded");
+  });
+});
+
+describe("widthFromMouseColumn", () => {
+  test("measures the rail from the mouse column to the right edge", () => {
+    // divider dragged to column 80 of a 120-wide terminal -> a 40-col rail
+    expect(widthFromMouseColumn(80, 120)).toBe(40);
+  });
+
+  test("clamps the dragged width to the bounds", () => {
+    expect(widthFromMouseColumn(0, 120)).toBe(REVIEW_MAX_WIDTH);
+    expect(widthFromMouseColumn(119, 120)).toBe(REVIEW_MIN_WIDTH);
+  });
+
+  test("cannot drag the rail wide enough to starve the plan on a narrow terminal", () => {
+    // dragging to the far left edge of a 60-col terminal still leaves the plan its minimum
+    expect(widthFromMouseColumn(0, 60)).toBe(60 - REVIEW_PLAN_MIN_WIDTH - 1);
+  });
+
+  test("the resize step widens and narrows within the clamp", () => {
+    expect(clampWidth(REVIEW_DEFAULT_WIDTH + REVIEW_RESIZE_STEP)).toBe(REVIEW_DEFAULT_WIDTH + REVIEW_RESIZE_STEP);
+    expect(clampWidth(REVIEW_MIN_WIDTH - REVIEW_RESIZE_STEP)).toBe(REVIEW_MIN_WIDTH);
+  });
+});
+
+describe("maxWidthForTerminal", () => {
+  test("allows the full rail on a wide terminal", () => {
+    expect(maxWidthForTerminal(120)).toBe(REVIEW_MAX_WIDTH);
+  });
+
+  test("reserves the plan its minimum on a narrow terminal", () => {
+    // 60-col terminal: 30 for the plan and 1 for the divider leaves 29 for the rail
+    expect(maxWidthForTerminal(60)).toBe(60 - REVIEW_PLAN_MIN_WIDTH - 1);
+  });
+
+  test("never drops below the rail minimum, however narrow the terminal", () => {
+    expect(maxWidthForTerminal(40)).toBe(REVIEW_MIN_WIDTH);
+  });
+});
+
+describe("resolveReviewWidth", () => {
+  test("leaves a width that already fits untouched", () => {
+    expect(resolveReviewWidth(REVIEW_DEFAULT_WIDTH, 120)).toBe(REVIEW_DEFAULT_WIDTH);
+  });
+
+  test("shrinks a wide persisted width so the plan keeps its room", () => {
+    // a saved 50-col rail on a 60-col terminal would leave the plan 9 cols; clamp it back
+    expect(resolveReviewWidth(REVIEW_MAX_WIDTH, 60)).toBe(60 - REVIEW_PLAN_MIN_WIDTH - 1);
+  });
+});
+
+describe("reviewRowsToDivider", () => {
+  test("builds one vertical glyph per row", () => {
+    expect(reviewRowsToDivider(3)).toBe("│\n│\n│");
+  });
+
+  test("never collapses to an empty column", () => {
+    expect(reviewRowsToDivider(0)).toBe("│");
+    expect(reviewRowsToDivider(-4)).toBe("│");
+  });
+});

package/src/review-panel.ts

@@ -0,0 +1,76 @@
+/**
+ * Pure geometry and state for the resizable review panel. The panel shows the
+ * review rail in one of three modes and the expanded rail resizes within a
+ * clamp; App owns the React state and the mouse wiring, this module owns the
+ * arithmetic so the layout math stays unit-tested and out of the JSX. Bounds
+ * and the compact width carry over verbatim from the approved prototype.
+ */
+
+/** Expanded (full rail), compact (count + dots strip), or hidden (nothing). */
+export type ReviewPanelMode = "expanded" | "compact" | "hidden";
+
+/** Expanded-rail width bounds, in terminal columns. */
+export const REVIEW_MIN_WIDTH = 24;
+export const REVIEW_MAX_WIDTH = 50;
+export const REVIEW_DEFAULT_WIDTH = 34;
+/**
+ * Columns the plan/diff column keeps for itself: the expanded rail yields past
+ * this so a narrow terminal (or a wide persisted width) can never crowd the
+ * plan out to nothing - the whole reason the panel is resizable. On terminals
+ * wide enough for the full 50-col rail this bound never binds.
+ */
+export const REVIEW_PLAN_MIN_WIDTH = 30;
+/** The compact strip is a fixed narrow column: count on top, one dot per card. */
+export const REVIEW_COMPACT_WIDTH = 6;
+/** Keyboard resize step, in columns, for the widen/narrow keys. */
+export const REVIEW_RESIZE_STEP = 2;
+
+/** Round a desired width to a whole column and clamp it to the bounds. */
+export function clampWidth(desiredWidth: number, min = REVIEW_MIN_WIDTH, max = REVIEW_MAX_WIDTH): number {
+  return Math.max(min, Math.min(max, Math.round(desiredWidth)));
+}
+
+/**
+ * The widest the expanded rail may be on a given terminal, reserving the plan
+ * its minimum and one column for the divider. Never drops below REVIEW_MIN_WIDTH
+ * (an extremely narrow terminal is the auto-collapse case, handled elsewhere).
+ */
+export function maxWidthForTerminal(terminalWidth: number): number {
+  return Math.max(REVIEW_MIN_WIDTH, Math.min(REVIEW_MAX_WIDTH, terminalWidth - REVIEW_PLAN_MIN_WIDTH - 1));
+}
+
+/** Clamp a desired rail width to the bounds AND the terminal, so the plan keeps its room. */
+export function resolveReviewWidth(desiredWidth: number, terminalWidth: number): number {
+  return clampWidth(desiredWidth, REVIEW_MIN_WIDTH, maxWidthForTerminal(terminalWidth));
+}
+
+/** The keybinding cycle: expanded -> compact -> hidden -> expanded. */
+export function cycleReviewPanelMode(mode: ReviewPanelMode): ReviewPanelMode {
+  return mode === "expanded" ? "compact" : mode === "compact" ? "hidden" : "expanded";
+}
+
+/**
+ * The clickable chevron toggles only between expanded and compact - hidden is
+ * reachable by keybinding alone, so it never leaves a leftover tab behind. A
+ * toggle from hidden still opens the panel rather than doing nothing.
+ */
+export function toggleReviewPanelMode(mode: ReviewPanelMode): ReviewPanelMode {
+  return mode === "expanded" ? "compact" : "expanded";
+}
+
+/**
+ * Rail width from an absolute mouse column while dragging the divider: the rail
+ * spans from the mouse column to the terminal's right edge, then clamps.
+ */
+export function widthFromMouseColumn(mouseColumn: number, terminalWidth: number): number {
+  return resolveReviewWidth(terminalWidth - mouseColumn, terminalWidth);
+}
+
+/**
+ * The divider is a single-column stack of vertical glyphs (a text block, not a
+ * bordered box - a one-column box with a border renders a full box). One glyph
+ * per row, at least one so the column never collapses.
+ */
+export function reviewRowsToDivider(rows: number): string {
+  return Array.from({ length: Math.max(1, rows) }, () => "│").join("\n");
+}

package/src/session-controller.ts

@@ -28,7 +28,8 @@ import { diffRowAnchor, diffRows, type DiffRow } from "./view-diff";
 import { firstUnviewedIndex, walkFiles, type WalkFile } from "./walk";
 import { editInEditor } from "./editor";
 import { focusHerdrPane } from "./herdr";
-import { persistAutoClose, type AutoClose, type CueloopConfig } from "./config";
+import { persistAutoClose, persistReviewState, persistReviewWidth, type AutoClose, type CueloopConfig } from "./config";
+import type { ReviewPanelMode } from "./review-panel";
 
 /**
  * Post-submit lifecycle (a review pane should hand you back to the agent,
@@ -119,6 +120,12 @@ export interface ReviewController {
   dismissCompletion(): void;
   /** From the completion prompt: persist auto-close and start the countdown. */
   optInAutoClose(): void;
+  /**
+   * Persist the review-panel layout (client view state) to the user config so
+   * the collapse mode and rail width survive a restart. A read-only config dir
+   * never blocks the review.
+   */
+  saveReviewPanel(layout: { mode?: ReviewPanelMode; width?: number }): void;
 }
 
 export function createReviewController(options: ReviewControllerOptions): ReviewController {
@@ -493,4 +500,13 @@ class Controller implements ReviewController {
     }
     this.autoClose = DEFAULT_AUTO_CLOSE;
   }
+
+  saveReviewPanel(layout: { mode?: ReviewPanelMode; width?: number }): void {
+    try {
+      if (layout.mode !== undefined) persistReviewState(layout.mode);
+      if (layout.width !== undefined) persistReviewWidth(layout.width);
+    } catch {
+      // a read-only config dir must never block collapsing or resizing the rail
+    }
+  }
 }