Surface /yolo on landing and permission prompts

Author: TheGreatAxios

docs/TUI.md

@@ -282,6 +282,11 @@ because an earlier version could abandon the awaited promise on Escape and
 leave the session parked with no recovery path short of killing the process;
 Escape must always settle the promise it is dismissing.
 
+The permissions prompt's title line names `/yolo` as the way to skip further
+prompts, longest first as the terminal narrows: `Esc cancel · Enter choose ·
+/yolo skip prompts`, then `Esc · Enter · /yolo`, then `Esc · Enter`. Operator
+questions and the model/provider picker do not advertise `/yolo`.
+
 Once a permission or operator prompt is answered — or cancelled, timed out,
 or auto-settled by a grant / abort / teardown — it leaves the screen and
 does **not** replay the request, the command, or the chosen option into the
@@ -356,6 +361,12 @@ or transcript. The shortcut list it used to open is still reachable, as
 via `openCommandSurface`'s `"help"` case, `command-surfaces.ts`); the `/` row
 in `SHELL_SHORTCUTS` documents that in place of a dedicated `?` row.
 
+The idle landing paints two doors beside the mark, keys aligned so the
+descriptions share a column (`LANDING_HINTS` in `src/tui/landing.ts`): `/`
+for commands, and `/yolo` so Corbits Code does not have to ask for
+permissions. An 80-column terminal still seats the compact mark next to
+them; when the terminal is too narrow, the hints win and the mark drops.
+
 The running build version is chrome, not part of the landing composition:
 `shell.ts`'s `versionRow`/`versionBadge`, a dedicated row pinned to the
 terminal's last line and right-aligned, distinct from `landing.ts`'s hero and

src/tui/landing.test.ts

@@ -105,17 +105,24 @@ describe("landing layout math", () => {
     expect(text.some((line) => line.includes("telemetry"))).toBe(false);
   });
 
+  test("the two doors are commands and /yolo", () => {
+    expect(LANDING_HINTS).toEqual([
+      { key: "/", rest: "for commands" },
+      { key: "/yolo", rest: "so Corbits Code doesn't have to ask for permissions" },
+    ]);
+  });
+
   test("the mark degrades through its tiers and then disappears", () => {
     // Roomy: the hero grid, which is the only size that reads unambiguously.
-    expect(resolveMarkGrid(20, 96)).toBe(MARK_LARGE);
+    expect(resolveMarkGrid(20, 120)).toBe(MARK_LARGE);
     // A row short of the hero, a tier down rather than a clipped hero.
-    expect(resolveMarkGrid(12, 96)).toBe(MARK_MID);
-    expect(resolveMarkGrid(9, 96)).toBe(MARK_SMALL);
+    expect(resolveMarkGrid(12, 120)).toBe(MARK_MID);
+    expect(resolveMarkGrid(9, 120)).toBe(MARK_SMALL);
+    // 80-column terminal: contentWidth is 78 after gutters; the compact mark
+    // still seats beside the two doors.
+    expect(resolveMarkGrid(20, 78)).toBe(MARK_SMALL);
     // Narrow enough that the mark would crowd the hints: the hints win.
-    // (The version moved off this hint block into the shell's own chrome —
-    // CL-5736 — so the block is narrower and a bit more room stays for the
-    // mark at this width than before.)
-    expect(resolveMarkGrid(20, 50)).toBe(MARK_MID);
+    expect(resolveMarkGrid(20, 50)).toBeNull();
     expect(resolveMarkGrid(20, 30)).toBeNull();
     expect(resolveMarkGrid(3, 96)).toBeNull();
   });

src/tui/landing.ts

@@ -9,11 +9,11 @@
  *   ────    the prompt box and its hint row (owned by the shell)
  *   below   the telemetry disclosure, then a few selectable starter prompts
  *
- * The mark is the screen. Beside it sit exactly two lines — the command menu
- * and the shortcut sheet — because those two are the only doors an operator
- * needs on a screen where nothing has happened yet; every other key is behind
- * one of them, and listing keys here would trade the one legible thing on the
- * screen for a reference card nobody reads twice.
+ * The mark is the screen. Beside it sit exactly two lines — `/` for commands
+ * and `/yolo` so permission prompts are not required — because those two are
+ * the only doors an operator needs on a screen where nothing has happened yet;
+ * every other key is behind one of them, and listing keys here would trade the
+ * one legible thing on the screen for a reference card nobody reads twice.
  *
  * The disclosure sits directly under the box rather than at the bottom edge
  * because it has to be read, not discovered.
@@ -70,13 +70,19 @@ export function versionBadgeVisible(columns: number, rows: number): boolean {
 }
 
 /**
- * The one door off the landing screen — `/help` (listed among the commands
- * `/` opens) is the other, so this stays a single row rather than growing.
+ * The two doors off the landing screen. `/help` is among the commands `/`
+ * opens; `/yolo` is the other way in, so permission prompts do not have to be
+ * discovered the hard way.
  */
 export const LANDING_HINTS: readonly {
   readonly key: string;
   readonly rest: string;
-}[] = [{ key: "/", rest: "for commands" }];
+}[] = [
+  { key: "/", rest: "for commands" },
+  // One character shorter than the spoken line ("does not") so an 80-column
+  // terminal still seats the compact mark beside the aligned descriptions.
+  { key: "/yolo", rest: "so Corbits Code doesn't have to ask for permissions" },
+];
 
 /**
  * Columns held for the key, so the descriptions beside them start on one

src/tui/overlays.test.ts

@@ -99,6 +99,8 @@ describe("permissions overlay", () => {
           // First option is in the list model (may clip if body short).
           expect(shell.overlayItems[0]).toBe("Allow once");
           expect(frame).toMatch(/Allow/);
+          expect(frame).toContain("/yolo");
+          expect(frame).toContain("Esc cancel · Enter choose · /yolo skip prompts");
 
           // Navigate deep enough that window must scroll (keep-active-visible).
           const listH = shell.overlayList!.height;
@@ -132,6 +134,27 @@ describe("permissions overlay", () => {
     );
   });
 
+  test("key hints drop to Esc · Enter on a narrow interior", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 32, rows: 24 },
+          wireKeys: false,
+        });
+        try {
+          openPermissionsOverlay(shell, { items: makePermissionItems(4) });
+          await h.renderOnce();
+          const frame = h.captureCharFrame();
+          expect(frame).toContain("Esc · Enter");
+          expect(frame).not.toContain("/yolo");
+        } finally {
+          shell.dispose();
+        }
+      },
+      { width: 32, height: 24 },
+    );
+  });
+
   test("Esc key closes permissions overlay via wireKeys", async () => {
     await withTestRenderer(
       async (h) => {
@@ -208,6 +231,7 @@ describe("operator question overlay", () => {
           expect(frame).toMatch(/Cancel|Allow/);
           // The overlay carries its own keys now that there is no hint strip.
           expect(frame).toContain("Esc cancel");
+          expect(frame).not.toContain("/yolo");
           // Empty title must not leave a leading middle-dot before the hints.
           expect(frame).not.toMatch(/·\s*Esc cancel/);
 
@@ -245,6 +269,7 @@ describe("model / provider picker", () => {
           let frame = h.captureCharFrame();
           expect(frame).toContain("model");
           expect(frame).toMatch(/anthropic|openai|claude/i);
+          expect(frame).not.toContain("/yolo");
 
           moveOverlaySelection(shell, 2);
           acceptOverlaySelection(shell);

src/tui/shell.ts

@@ -1337,6 +1337,13 @@ const MODEL_PICKER_HINTS = [
   "Esc · Enter",
 ] as const;
 
+/** Permissions only: name `/yolo` so skip-prompts is discoverable at the ask. */
+const PERMISSIONS_HINTS = [
+  "Esc cancel · Enter choose · /yolo skip prompts",
+  "Esc · Enter · /yolo",
+  "Esc · Enter",
+] as const;
+
 function overlayHints(shell: AppShell): readonly string[] {
   const answer = overlayAnswerState(shell);
   const hasChoices = shell.overlayItems.length > 0;
@@ -1363,6 +1370,7 @@ function overlayHints(shell: AppShell): readonly string[] {
         ];
       }
     }
+    if (shell.overlayKind === "permissions") return PERMISSIONS_HINTS;
     return DEFAULT_OVERLAY_HINTS;
   }
   if (answer.active) {