Wrap operator-question choices instead of ellipsizing them

The overlay was collapsing long option labels with a middle ellipsis, so interview and permission choices became unreadable. Choices now wrap to a shared height.

ask_operator rejects labels over 48 characters and the interview skill puts trade-offs in the transcript, not in the option string.

Author: TheGreatAxios

docs/TUI.md

@@ -317,9 +317,12 @@ framed content in the shell, and they are shaped rather than merely listed
 subject in the action color — the only Breakthrough Orange on the card.
 The overlay host border and title use calm dim chrome (`UI.textDim`);
 consequence impact in the description zone paints `UI.warning` (sand), not
-orange. A blank row separates the subject from context, and each choice gets
-one row with the active choice marked by a solid block (`█`) rather than a
-background fill (cream text, not orange).
+orange. A blank row separates the subject from context. Choices wrap on word
+boundaries — never middle-ellipsized — to a shared row count at the current
+width (minimum two rows so short labels still breathe; a taller wrap raises
+every choice to the same height so list paging stays a simple multiple). The
+active choice is marked by a solid block (`█`) rather than a background fill
+(cream text, not orange).
 
 ## How selectors should work
 

plugins/corbits-skills/skills/interview/SKILL.md

@@ -37,9 +37,9 @@ Each question is one `ask_operator` call: `question` (string) plus `options` (ar
 
 **Quality bar for options:**
 
-- Mutually exclusive and concrete — not "yes / no / maybe"
+- Mutually exclusive **short labels** — not "yes / no / maybe"
 - Each option a real, defensible choice — not a strawman
-- Put trade-offs in the option string itself ("simpler but less flexible", "consistent with existing patterns") — `options` are strings, not `{ label, description }` objects
+- Trade-offs, rationale, and context go in the **preceding transcript reply**, then `ask_operator` with a brief question and brief labels. Do not put essays in the option string — `options` are strings, not `{ label, description }` objects
 - Ground options in the topic and context — do not invent generic options when concrete ones exist
 - Combination options only when the dimension genuinely permits more than one answer
 - If you have a recommendation, put it first and label it
@@ -90,34 +90,34 @@ After emitting the findings, stop. Do not load other skills, invoke other agents
 
 **Invocation:** `use_skill(name="interview")` with the topic in the conversation, or `/interview notification system; backend is Node/Postgres, internal users only, must integrate with existing auth`
 
-**Round 1** (three parallel `ask_operator` calls — independent dimensions, so ask together):
+**Round 1** (three parallel `ask_operator` calls — independent dimensions, so ask together). Trade-offs belong in the transcript before the calls, not in the labels — e.g. "critical vs activity vs re-engagement; never-miss vs real-time vs per-event opt-in; in-app vs email vs webhook."
 
 ```
 ask_operator({
   question: "What is the primary goal of the notification system?",
   options: [
-    "Alert on critical events — Errors, security issues, SLA breaches",
-    "Keep users informed of activity — Mentions, replies, updates",
-    "Drive user re-engagement — Digests, reminders, summaries"
+    "Alert on critical events",
+    "Keep users informed of activity",
+    "Drive user re-engagement"
   ]
 })
 
 ask_operator({
   question: "If you had to pick one, which matters most?",
   options: [
-    "Reliability of delivery (recommended) — Never miss a notification, even if delayed",
-    "Latency — Real-time, even if some are dropped under load",
-    "User control — Fine-grained per-event opt-in/out"
+    "Reliability of delivery (recommended)",
+    "Latency",
+    "User control"
   ]
 })
 
 ask_operator({
   question: "Which delivery channels do you want?",
   options: [
-    "In-app — Notification center in the UI",
-    "Email — Per-event or digest",
+    "In-app",
+    "Email",
     "In-app + Email",
-    "Webhook — Outbound HTTP to a user-configured endpoint",
+    "Webhook",
     "All of the above"
   ]
 })

src/agent/director.ts

@@ -118,6 +118,7 @@ export const askOperatorDefinition: ToolDefinition = {
     "Pause execution and ask the operator a short clarifying question with short option labels. " +
     "Put any long rationale, trade-offs, or context in a normal transcript reply first, then call this " +
     "with only a brief question and brief option labels — the overlay is not a place for essays. " +
+    "Each option label must be at most 48 characters. " +
     "Execution resumes when the operator selects an option.",
   inputSchema: {
     type: "object",
@@ -129,8 +130,9 @@ export const askOperatorDefinition: ToolDefinition = {
       },
       options: {
         type: "array",
-        description: "Short option labels the operator can choose from (keep each label brief)",
-        items: { type: "string" },
+        description:
+          "Short option labels the operator can choose from (at most 48 characters each)",
+        items: { type: "string", maxLength: 48 },
         minItems: 1,
       },
     },

src/agent/tools.ts

@@ -87,6 +87,12 @@ const AskOperatorArgs = type({
   options: "string[]",
 });
 
+/** Cap on each ask_operator option label (UTF-16 code units). */
+export const ASK_OPERATOR_OPTION_MAX_CHARS = 48;
+
+/** Cap on the ask_operator question (UTF-16 code units). */
+export const ASK_OPERATOR_QUESTION_MAX_CHARS = 160;
+
 const SubmitOutputArgs = type({
   "summary?": "string",
   "step?": "string",
@@ -451,6 +457,23 @@ export async function createAgentToolset(args: AgentToolsetArgs): Promise<AgentT
         if (options.length === 0) {
           return "Error: ask_operator requires at least one option.";
         }
+        if (question.length > ASK_OPERATOR_QUESTION_MAX_CHARS) {
+          return (
+            `Error: ask_operator question is ${question.length} characters; ` +
+            `keep it to ${ASK_OPERATOR_QUESTION_MAX_CHARS} or fewer. ` +
+            "Put the essay in a transcript reply first, then retry with a brief question."
+          );
+        }
+        for (let i = 0; i < options.length; i++) {
+          const option = options[i] ?? "";
+          if (option.length > ASK_OPERATOR_OPTION_MAX_CHARS) {
+            return (
+              `Error: ask_operator option ${i + 1} is ${option.length} characters; ` +
+              `keep each label to ${ASK_OPERATOR_OPTION_MAX_CHARS} or fewer. ` +
+              "Put the essay in a transcript reply first, then retry with short option labels."
+            );
+          }
+        }
         const result = await onOperatorGate(question, options);
         if (result.kind === "cancel") {
           return "The operator dismissed the question without answering. Do not ask it again; proceed with your best judgment or continue with other work.";

src/director.test.ts

@@ -77,6 +77,9 @@ describe("ask_operator definition", () => {
     expect(schema.properties).not.toHaveProperty("command");
     expect(askOperatorDefinition.description).not.toMatch(/pre-authoriz/i);
     expect(askOperatorDefinition.description).not.toMatch(/`command`/);
+    expect(askOperatorDefinition.description).toMatch(/at most 48 characters/);
+    const options = schema.properties?.options as { items?: { maxLength?: number } };
+    expect(options.items?.maxLength).toBe(48);
   });
 });
 

src/prompts.test.ts

@@ -266,7 +266,16 @@ test("buildAvailableTools lists exactly the tools it is given", () => {
 });
 
 test("sub-agent prompt carries the report-back contract and harness facts", () => {
-  const prompt = buildSubAgentSystemPrompt();
+  // Context interpolates cwd. A worktree path containing "ask_operator" would
+  // poison this check even when the prompt does not advertise the tool.
+  const prompt = buildSubAgentSystemPrompt(undefined, {
+    cwd: "/repo/root",
+    platform: "Darwin 25.4.0",
+    arch: "arm64",
+    runtime: "Bun 1.2.0",
+    date: new Date(2026, 5, 5),
+    isGitRepo: false,
+  });
   expect(prompt).toContain("short-lived child agent dispatched by Corbits Code");
   expect(prompt).toContain("Reporting back:");
   expect(prompt).toContain("only thing returned to the parent");

src/tui/gate-wire.test.ts

@@ -304,46 +304,49 @@ describe("wireGates", () => {
   });
 
   test("permission.gate paints the collapsed body and expands it on toggle", async () => {
-    await withTestRenderer(async (h) => {
-      const shell = createAppShell(h.renderer, {
-        terminal: { columns: 100, rows: 40 },
-        run: "idle",
-      });
-      const emitter = new EventEmitter();
-      const request: PermissionRequest = {
-        tool: "run_shell",
-        action: "Run shell command",
-        subject: "echo start && cat > notes.txt <<EOF\nalpha\nbeta\nEOF",
-        scopes: [],
-      };
-      try {
-        const dispose = wireGates(emitter, shell);
-        emitter.emit("permission.gate", { request, resolve: () => {} });
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 100, rows: 40 },
+          run: "idle",
+        });
+        const emitter = new EventEmitter();
+        const request: PermissionRequest = {
+          tool: "run_shell",
+          action: "Run shell command",
+          subject: "echo start && cat > notes.txt <<EOF\nalpha\nbeta\nEOF",
+          scopes: [],
+        };
+        try {
+          const dispose = wireGates(emitter, shell);
+          emitter.emit("permission.gate", { request, resolve: () => {} });
 
-        const collapsed = shell.overlayBodyLines.join("\n");
-        expect(collapsed).toContain("1) echo start");
-        expect(collapsed).toContain("<heredoc, 2 lines>");
-        expect(collapsed).not.toContain("alpha");
+          const collapsed = shell.overlayBodyLines.join("\n");
+          expect(collapsed).toContain("1) echo start");
+          expect(collapsed).toContain("<heredoc, 2 lines>");
+          expect(collapsed).not.toContain("alpha");
 
-        expect(toggleOverlayExpand(shell)).toBe(true);
-        const expanded = shell.overlayBodyLines.join("\n");
-        expect(expanded).toContain("<heredoc, 2 lines>");
-        expect(expanded).toContain("alpha");
-        expect(expanded).toContain("beta");
+          expect(toggleOverlayExpand(shell)).toBe(true);
+          const expanded = shell.overlayBodyLines.join("\n");
+          expect(expanded).toContain("<heredoc, 2 lines>");
+          expect(expanded).toContain("alpha");
+          expect(expanded).toContain("beta");
 
-        // Full text also lands in the scrollable transcript, which no
-        // overlay height cap can clip.
-        const streamed = shell.streamLog.map((r) => r.text).join("\n");
-        expect(streamed).toContain("alpha");
+          // Full text also lands in the scrollable transcript, which no
+          // overlay height cap can clip.
+          const streamed = shell.streamLog.map((r) => r.text).join("\n");
+          expect(streamed).toContain("alpha");
 
-        expect(toggleOverlayExpand(shell)).toBe(true);
-        expect(shell.overlayBodyLines.join("\n")).not.toContain("alpha");
+          expect(toggleOverlayExpand(shell)).toBe(true);
+          expect(shell.overlayBodyLines.join("\n")).not.toContain("alpha");
 
-        dispose();
-      } finally {
-        shell.dispose();
-      }
-    });
+          dispose();
+        } finally {
+          shell.dispose();
+        }
+      },
+      { width: 100, height: 40 },
+    );
   });
 
   test("operator.gate opens overlay and resolves selection through onAccept", async () => {
@@ -1294,9 +1297,9 @@ describe("permission overlay height", () => {
     const tall = await hostRowsFor(60, 1);
     expect(short).toBe(tall);
 
-    // Two extra choices cost exactly two extra rows: the choices are
-    // single-spaced, so the list is one row per item.
-    expect(await hostRowsFor(60, 3)).toBe(tall + 2);
+    // Two extra choices cost exactly four extra rows: each choice occupies
+    // two rows (wrap padding), so the list is a simple multiple of item count.
+    expect(await hostRowsFor(60, 3)).toBe(tall + 4);
   });
 
   test("caps rather than growing, and the list scrolls inside the cap", async () => {

src/tui/landing.test.ts

@@ -489,7 +489,7 @@ describe("landing screen", () => {
     await withTestRenderer(
       async (h) => {
         const shell = createAppShell(h.renderer, {
-          terminal: { columns: 100, rows: 36 },
+          terminal: { columns: 100, rows: 48 },
           wireKeys: false,
           run: "idle",
         });
@@ -509,7 +509,7 @@ describe("landing screen", () => {
           shell.dispose();
         }
       },
-      { width: 100, height: 36 },
+      { width: 100, height: 48 },
     );
   });
 

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

@@ -14,6 +14,7 @@ import {
   type AppShell,
 } from "./shell.js";
 import { openPermissionsOverlay, makePermissionItems } from "./overlays.js";
+import { DECISION_CHOICE_ROWS } from "./overlay-body.js";
 
 function primeSession(shell: AppShell): void {
   appendStreamRow(shell, { role: "assistant", text: "session underway" });
@@ -24,17 +25,23 @@ describe("decision overlay body cache survives a stacked palette", () => {
     await withTestRenderer(
       async (h) => {
         const shell = createAppShell(h.renderer, {
-          terminal: { columns: 80, rows: 24 },
+          terminal: { columns: 80, rows: 32 },
           run: "idle",
         });
         try {
           primeSession(shell);
+          const items = makePermissionItems(3);
           openPermissionsOverlay(shell, {
-            items: makePermissionItems(3),
+            items,
             body: "run_shell\nRun shell command\nSome context about the risky command.",
           });
           await h.renderOnce();
           expect(shell.overlayBodyLines.length).toBeGreaterThan(0);
+          const hostBefore = shell.layout.overlayHeight;
+          // Chrome is border (2) + title (1) + body lines; list is N * perItem.
+          expect(hostBefore).toBe(
+            shell.overlayBodyLines.length + 3 + items.length * DECISION_CHOICE_ROWS,
+          );
 
           // Stack a palette over the open permissions overlay — its own
           // (empty) body must not overwrite the approval's cached raw text.
@@ -50,6 +57,8 @@ describe("decision overlay body cache survives a stacked palette", () => {
           await h.renderOnce();
           expect(shell.overlayKind).toBe("permissions");
           expect(shell.overlayBodyLines.length).toBeGreaterThan(0);
+          expect(shell.layout.overlayHeight).toBe(hostBefore);
+          expect(shell.overlayList?.height).toBe(items.length);
 
           // Resize: the body must still show the permission context, not be
           // blanked by re-shaping from the palette's stale empty cache.
@@ -62,7 +71,7 @@ describe("decision overlay body cache survives a stacked palette", () => {
           shell.dispose();
         }
       },
-      { width: 80, height: 24 },
+      { width: 80, height: 32 },
     );
   });
 });