Stop a stacked palette from clobbering the approval overlay's cached body text

applyOverlayBodyText cached every opened overlay's raw body text for a
resize to re-shape against, but a palette stacked over an open permission or
operator overlay called it too, with its own (empty) body — overwriting the
approval's cache. Popping the palette restores overlayBodyLines from the
snapshot but not this cache, so a resize right after re-shaped the approval
from the palette's stale empty string, blanking its body entirely (header
included). The cache write is now scoped to decision overlays, since a
palette never reads it back.

Also tightens decisionContextBudget's docblock and a test comment that
overclaimed the guarantee held below 10 rows; the resolver's own collapse
fallback (unrelated to this budget) still has a gap below that floor.

Author: TheGreatAxios

src/tui/approval-prompt-visibility.test.ts

@@ -11,7 +11,7 @@ import { openPermissionsOverlay, makePermissionItems } from "./overlays.js";
 
 const WIDTH = 80;
 // Deliberately spans from far below the documented 24-row baseline down to
-// the shortest terminals the shell claims to support, plus a comfortable one.
+// 10 rows, the shortest terminal this fix guarantees, plus a comfortable one.
 const HEIGHTS = [10, 12, 15, 24, 40] as const;
 
 const APPROVAL_BODY = [

src/tui/overlay-body-cache-staleness.test.ts

@@ -0,0 +1,68 @@
+/**
+ * CL-5750 follow-up: a palette stacked over an open approval must not
+ * clobber the approval's cached raw body text, which a resize re-shapes
+ * against the new height's context budget (see `decisionContextBudget` /
+ * `applyOverlayBodyText` in shell.ts).
+ */
+import { describe, expect, test } from "bun:test";
+import { withTestRenderer } from "./harness.js";
+import {
+  createAppShell,
+  appendStreamRow,
+  closeInsetOverlay,
+  openPalette,
+  type AppShell,
+} from "./shell.js";
+import { openPermissionsOverlay, makePermissionItems } from "./overlays.js";
+
+function primeSession(shell: AppShell): void {
+  appendStreamRow(shell, { role: "assistant", text: "session underway" });
+}
+
+describe("decision overlay body cache survives a stacked palette", () => {
+  test("resize after popping a stacked palette re-shapes the approval's own body, not a blanked one", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          run: "idle",
+        });
+        try {
+          primeSession(shell);
+          openPermissionsOverlay(shell, {
+            items: makePermissionItems(3),
+            body: "run_shell\nRun shell command\nSome context about the risky command.",
+          });
+          await h.renderOnce();
+          expect(shell.overlayBodyLines.length).toBeGreaterThan(0);
+
+          // Stack a palette over the open permissions overlay — its own
+          // (empty) body must not overwrite the approval's cached raw text.
+          openPalette(shell, {
+            catalog: [{ id: "foo", label: "foo" }],
+            title: "commands",
+          });
+          await h.renderOnce();
+          expect(shell.overlayKind).toBe("palette");
+
+          // Pop the palette back to the permissions overlay underneath.
+          closeInsetOverlay(shell);
+          await h.renderOnce();
+          expect(shell.overlayKind).toBe("permissions");
+          expect(shell.overlayBodyLines.length).toBeGreaterThan(0);
+
+          // Resize: the body must still show the permission context, not be
+          // blanked by re-shaping from the palette's stale empty cache.
+          h.resize(80, 20);
+          await h.renderOnce();
+          await h.renderOnce();
+          expect(shell.overlayBodyLines.length).toBeGreaterThan(0);
+          expect(shell.overlayBodyLines.join("\n")).toContain("run_shell");
+        } finally {
+          shell.dispose();
+        }
+      },
+      { width: 80, height: 24 },
+    );
+  });
+});

src/tui/shell.ts

@@ -3372,15 +3372,21 @@ const DECISION_CONTEXT_BLANK_ROWS = 1;
 
 /**
  * Shrink the decision body's context budget so its own chrome never crowds
- * out the one thing that must survive any terminal height: at least one
- * choice row, with the prompt box still seated at its floor below it. A
+ * out the one thing this fix guarantees down to a 10-row terminal: at least
+ * one choice row, with the prompt box still seated at its floor below it. A
  * generous, fixed context budget reads fine on a tall terminal, but on a
  * short one it can consume the entire overlay host, leaving no room to paint
  * a single option — the operator is then asked to decide between choices
  * they cannot see. Shrinking the context first, down to dropping it entirely
  * on the shortest terminals, is the deliberate trade: the header (which tool,
  * which question) and the choices are the two things an approval cannot
  * render without; the surrounding detail can give way first.
+ *
+ * Below 10 rows this budget alone cannot save the frame: the resolver's own
+ * collapse fallback (`resolveGeometry` in geometry/resolve.ts) can still hand
+ * the overlay host fewer rows than its render minimum once every other zone
+ * is already at floor, which is a pre-existing gap in the resolver, not
+ * something this budget controls.
  */
 function decisionContextBudget(
   shell: AppShell,
@@ -3409,7 +3415,15 @@ function applyOverlayBodyText(
 ): void {
   const width = overlayRowWidth(shell);
   const bag = internals.get(shell);
-  if (bag) bag.overlayRawBodyText = text;
+  // Scoped to decision overlays: a palette stacked over an open approval
+  // calls this too, with its own (usually empty) body text. Caching that
+  // would overwrite the approval's cached raw text with the palette's, and
+  // popping the palette restores the approval's `overlayBodyLines` but not
+  // this cache (`PriorOverlaySnapshot` never carried it) — so a resize right
+  // after would re-shape the approval's body from the palette's stale empty
+  // string instead of its own, blanking it. The palette itself never reads
+  // this cache (not a decision overlay), so it never needs to be cached.
+  if (bag && isDecisionOverlay(shell.overlayKind)) bag.overlayRawBodyText = text;
   if (text.length === 0) {
     shell.overlayBodyLines = [];
     shell.overlayBodyFgs = [];