feat(chat): answer the CLI's menus from the chat; Stop ends Thinking… (#74)

- A menu the CLI asks with (AskUserQuestion — one question or several,
  multiSelect —, a permission or trust prompt, Codex's approval, a
  first-start login menu) is read off the terminal under the chat
  (`parsePaneMenu`/`readRunMenu`) and shown in the prompt box's place as a
  card of buttons. A pick presses its digit (picks it, or ticks its box),
  Claude's unnumbered Submit row is reached with the arrows and Enter, and
  Cancel presses Esc. "Type something" opens a field in the card: its text
  goes in by the arrows, Ctrl+U over anything already typed there, a
  bracketed paste and Enter. That row presses no key — a second press of
  its digit typed the digit into the CLI's field ("44444…"). Keys verified
  on Claude Code 2.1.296 and Codex 0.161. AskUserQuestion fires no
  Notification, so a menu on screen also counts as waiting (live line, tab
  badge). Client only: no new route.
- #74: Esc before the model wrote anything puts the prompt back in Claude
  Code's input box and writes no "[Request interrupted by user]" line, so
  the transcript ended on the prompt and the chat read "Thinking…" for
  15 min. The chat's Stop now ends the live line until a newer transcript
  line arrives (matched by line, not by clock).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

client/src/lib/panePaste.ts

@@ -14,6 +14,9 @@
  * terminal moves the unsent prompt across (`takeRunInput` reads the TUI's
  * input box off the screen and empties it; the chat's draft is pasted back
  * without Enter), so the half-typed text is never left behind on the other side.
+ * The Chat view also answers a menu the CLI asks with (`parsePaneMenu` reads
+ * it off the screen; `chooseRunOption`/`answerRunMenu` press its digit, the
+ * arrows and Enter, or type into its "Type something" row).
  * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
  */
 
@@ -151,3 +154,141 @@ export function takeRunInput(runId: string): string {
   p!.key!("\x1b[3~".repeat(n) + "\x7f".repeat(n));
   return text;
 }
+
+/** One choice of a menu the CLI shows: `n` its number (null for Claude's
+ *  unnumbered Submit row), `checked` a multiSelect box's state. */
+export type PaneMenuOption = {
+  n: number | null;
+  label: string;
+  hint: string;
+  checked: boolean | null;
+};
+/** A menu the CLI asks with (AskUserQuestion, a permission or trust prompt,
+ *  Codex's approval): `cursor` the row its `❯`/`›` is on, `typeAt` the
+ *  "Type something" row (-1: none). */
+export type PaneMenu = {
+  question: string;
+  options: PaneMenuOption[];
+  cursor: number;
+  multi: boolean;
+  typeAt: number;
+};
+
+const OPTION = /^ {0,4}([❯›][ \u00a0]?)? *(\d{1,2})\. +(.*)$/;
+const SUBMIT = /^ *([❯›])?[ \u00a0]*Submit$/;
+const RULE_ROW = /^ *[─╌]{3,} *$/;
+const CHECK = /^\[([ ✔])\] *(.*)$/;
+const PLACEHOLDER = /^Type something\.?$/;
+
+/** The numbered menu at the bottom of `rows`, or null. A menu has two
+ *  numbered rows or more from 1, the cursor on one of them, and no rule right
+ *  above its first row — a reply's numbered list has no cursor, and a list
+ *  typed into Claude's input box sits under the box's rule. */
+export function parsePaneMenu(rows: string[]): PaneMenu | null {
+  const r = rows.map((l) => l.trimEnd());
+  let end = r.length - 1;
+  while (end >= 0 && !r[end]) end--;
+  const options: PaneMenuOption[] = [];
+  let cursor = -1;
+  let hint: string[] = [];
+  let top = -1;
+  // Bottom up: a row under an option that is no option is its hint.
+  for (let i = end; i >= 0 && end - i < 40; i--) {
+    const row = r[i] ?? "";
+    const m = OPTION.exec(row);
+    const s = m ? null : SUBMIT.exec(row);
+    if (m || s) {
+      const text = m ? (m[3] ?? "") : "Submit";
+      const c = m ? CHECK.exec(text) : null;
+      const label = c ? (c[2] ?? "") : text;
+      const h = hint.join(" ");
+      options.unshift({
+        n: m ? Number(m[2]) : null,
+        label,
+        hint: h === label ? "" : h,
+        checked: c ? c[1] === "✔" : null,
+      });
+      if (m?.[1] || s?.[1]) cursor = options.length;
+      hint = [];
+      if (m?.[2] === "1") {
+        top = i;
+        break;
+      }
+    } else if (row && !RULE_ROW.test(row) && options.length) {
+      hint.unshift(row.trim());
+    } else if (row && !RULE_ROW.test(row)) {
+      hint = []; // the footer and anything under the last option
+    }
+  }
+  const numbered = options.filter((o) => o.n !== null);
+  if (top < 0 || cursor < 0 || numbered.length < 2 || RULE_ROW.test(r[top - 1] ?? "")) return null;
+  if (numbered.some((o, i) => o.n !== i + 1)) return null;
+  // The question: the block of text right above the first option.
+  let q = top - 1;
+  while (q >= 0 && !r[q]) q--;
+  const lines: string[] = [];
+  for (; q >= 0 && r[q] && !RULE_ROW.test(r[q]!) && lines.length < 4; q--)
+    lines.unshift(r[q]!.trim());
+  return {
+    question: lines.join("\n"),
+    options,
+    cursor: options.length - cursor,
+    multi: options.some((o) => o.checked !== null),
+    typeAt: typeRow(options),
+  };
+}
+
+/** The "Type something" row. Text typed into it replaces its label, and it is
+ *  still the last numbered row above "Chat about this". */
+function typeRow(options: PaneMenuOption[]): number {
+  const at = options.findIndex((o) => PLACEHOLDER.test(o.label));
+  if (at >= 0) return at;
+  for (let i = options.findIndex((o) => o.label === "Chat about this") - 1; i >= 0; i--)
+    if (options[i]!.n !== null) return i;
+  return -1;
+}
+
+/** The menu `runId`'s visible pane shows now, or null. */
+export function readRunMenu(runId: string): PaneMenu | null {
+  const p = panes.get(runId);
+  const screen = p?.visible() && p.key ? p.screen?.() : null;
+  return screen ? parsePaneMenu(screen.rows) : null;
+}
+
+// One key per write, a beat apart: a TUI reading two arrows in one chunk may
+// take them as one key.
+function pressKeys(key: (data: string) => void, keys: string[]) {
+  keys.forEach((k, i) => setTimeout(() => key(k), i * 40));
+}
+
+/** The arrow presses from the menu's cursor to row `to`. */
+const walk = (menu: PaneMenu, to: number) =>
+  Array<string>(Math.abs(to - menu.cursor)).fill(to > menu.cursor ? "\x1b[B" : "\x1b[A");
+
+/** Picks `menu`'s option `index` in `runId`'s pane: its digit — which picks
+ *  it, or ticks its box in a multiSelect — else (Submit) the arrows to it
+ *  and Enter. False when the pane is not visible or not attached. */
+export function chooseRunOption(runId: string, menu: PaneMenu, index: number): boolean {
+  const p = panes.get(runId);
+  const opt = menu.options[index];
+  if (!p?.visible() || !p.key || !opt) return false;
+  if (opt.n !== null && opt.n < 10) p.key(String(opt.n));
+  else pressKeys(p.key, [...walk(menu, index), "\r"]);
+  return true;
+}
+
+/** Answers `menu` with typed text: the arrows to its "Type something" row,
+ *  Ctrl+U over what is typed there already (one key clears it, however long
+ *  it is), the text as a bracketed
+ *  paste, and Enter — none in a multiSelect, where the text only ticks its
+ *  row and Submit is still to pick. */
+export function answerRunMenu(runId: string, menu: PaneMenu, text: string): boolean {
+  const p = panes.get(runId);
+  const row = menu.options[menu.typeAt];
+  if (!p?.visible() || !p.key || !row) return false;
+  const keys = walk(menu, menu.typeAt);
+  if (!PLACEHOLDER.test(row.label)) keys.push("\x15");
+  keys.push(`\x1b[200~${text}\x1b[201~`);
+  pressKeys(p.key, menu.multi ? keys : [...keys, "\r"]);
+  return true;
+}