Make the shell approval dialog readable

The command now renders exactly once, as the segment list — the separate
raw verbatim dump that duplicated it is gone. Heredoc bodies and
multi-line quoted arguments (commit messages, etc.) collapse to a
"<label, N lines>" placeholder inline, expandable via the existing
Ctrl+O. Persistent Allow options now lead with a single concise grant
subject and its scope ("Allow these 4 git commands — this session")
instead of a duplicated, ellipsized command mash with the scope buried
and dimmed at the end.

Author: TheGreatAxios

src/tui/command-display.test.ts

@@ -1,5 +1,10 @@
 import { test, expect } from "bun:test";
-import { groupChainSegmentsForDisplay, verbatimCommandLines, middleEllipsis } from "./command-display.js";
+import {
+  collapseSegmentPayloads,
+  groupChainSegmentsForDisplay,
+  verbatimCommandLines,
+  middleEllipsis,
+} from "./command-display.js";
 
 test("pipe stages stay inline while chain operators split", () => {
   expect(groupChainSegmentsForDisplay("ls | head -5 && echo done")).toEqual([
@@ -69,6 +74,39 @@ test("bare carriage returns render as a visible marker", () => {
   ]);
 });
 
+test("collapseSegmentPayloads leaves a single-line segment untouched", () => {
+  expect(collapseSegmentPayloads("git status")).toEqual({ display: "git status", payloads: [] });
+});
+
+test("collapseSegmentPayloads collapses a heredoc body to a placeholder with a line count", () => {
+  const segment = "git commit -F - <<'EOF'\nfix: something\n\nlonger body line\nEOF";
+  const { display, payloads } = collapseSegmentPayloads(segment);
+  expect(display).toBe("git commit -F - <<'EOF' <heredoc, 3 lines>");
+  expect(payloads).toEqual([
+    { placeholder: "<heredoc, 3 lines>", lines: ["fix: something", "", "longer body line"] },
+  ]);
+});
+
+test("collapseSegmentPayloads collapses a multi-line -m message to <message, N lines>", () => {
+  const segment = 'git commit -m "line one\nline two\nline three"';
+  const { display, payloads } = collapseSegmentPayloads(segment);
+  expect(display).toBe("git commit -m <message, 3 lines>");
+  expect(payloads).toEqual([
+    { placeholder: "<message, 3 lines>", lines: ["line one", "line two", "line three"] },
+  ]);
+});
+
+test("collapseSegmentPayloads labels a non-message multi-line quoted argument as <text, N lines>", () => {
+  const segment = 'echo "line one\nline two"';
+  const { display } = collapseSegmentPayloads(segment);
+  expect(display).toBe("echo <text, 2 lines>");
+});
+
+test("collapseSegmentPayloads never collapses a single-line quoted argument", () => {
+  const segment = 'git commit -m "a normal one-line message"';
+  expect(collapseSegmentPayloads(segment)).toEqual({ display: segment, payloads: [] });
+});
+
 test("middleEllipsis keeps head and tail", () => {
   expect(middleEllipsis("abcdefghij", 20)).toBe("abcdefghij");
   const cut = middleEllipsis("prefix-common middle distinguishing-tail", 20);

src/tui/command-display.ts

@@ -231,6 +231,98 @@ export function verbatimCommandLines(text: string): VerbatimLine[] {
   return lines.filter((line, i) => line.text.trim().length > 0 || i === 0);
 }
 
+export type CollapsedPayload = { placeholder: string; lines: string[] };
+
+export type CollapsedSegment = {
+  // The segment with each qualifying payload (a heredoc body, or a quoted
+  // string spanning multiple lines) replaced by a short "<label, N lines>"
+  // placeholder. A segment returned by groupChainSegmentsForDisplay is
+  // already boundary-resolved, so any newline still inside it comes from one
+  // of these two sources — never a chain boundary — which is what lets the
+  // collapsed segment always render as a single line.
+  display: string;
+  // The full text of each collapsed payload, in placeholder order, shown when
+  // the operator expands via Ctrl+O.
+  payloads: CollapsedPayload[];
+};
+
+// Picks a short, human label for a collapsed quoted payload by looking at the
+// flag token immediately before it (`-m`/`--message`/`-F` read as a commit
+// message; anything else is generic "text"). Display-only guesswork — never
+// used for classification or matching.
+function payloadLabel(segment: string, quoteStart: number): string {
+  let k = quoteStart - 1;
+  while (k >= 0 && (segment[k] === " " || segment[k] === "=")) k--;
+  const end = k + 1;
+  while (k >= 0 && segment[k] !== " " && segment[k] !== "=") k--;
+  const token = segment.slice(k + 1, end);
+  return token === "-m" || token === "--message" || token === "-F" ? "message" : "text";
+}
+
+function lineCountSuffix(count: number): string {
+  return `${count} line${count === 1 ? "" : "s"}`;
+}
+
+// Collapse a heredoc body or a multi-line quoted-string argument within one
+// display segment into a placeholder. Never influences classification or
+// grant matching — display only, mirroring the header comment for this file.
+export function collapseSegmentPayloads(segment: string): CollapsedSegment {
+  const payloads: CollapsedPayload[] = [];
+  let display = "";
+  let i = 0;
+  while (i < segment.length) {
+    const ch = segment[i] as string;
+
+    if (ch === "<" && segment[i + 1] === "<") {
+      const marker = parseHeredocMarker(segment, i);
+      if (marker !== null) {
+        let j = i;
+        while (j < segment.length && segment[j] !== "\n") j++;
+        display += segment.slice(i, j);
+        i = j + 1;
+        const bodyLines: string[] = [];
+        while (i < segment.length) {
+          let lineEnd = segment.indexOf("\n", i);
+          if (lineEnd === -1) lineEnd = segment.length;
+          const line = segment.slice(i, lineEnd);
+          if (line.trim() === marker) {
+            i = lineEnd + 1;
+            break;
+          }
+          bodyLines.push(line);
+          i = lineEnd + 1;
+        }
+        const placeholder = `<heredoc, ${lineCountSuffix(bodyLines.length)}>`;
+        display += ` ${placeholder}`;
+        payloads.push({ placeholder, lines: bodyLines });
+        continue;
+      }
+    }
+
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const quote = ch;
+      let j = i + 1;
+      while (j < segment.length && segment[j] !== quote) j++;
+      const content = segment.slice(i + 1, j);
+      if (content.includes("\n")) {
+        const lines = content.split("\n");
+        const placeholder = `<${payloadLabel(segment, i)}, ${lineCountSuffix(lines.length)}>`;
+        display += placeholder;
+        payloads.push({ placeholder, lines });
+        i = j < segment.length ? j + 1 : j;
+        continue;
+      }
+      display += segment.slice(i, j < segment.length ? j + 1 : j);
+      i = j < segment.length ? j + 1 : j;
+      continue;
+    }
+
+    display += ch;
+    i++;
+  }
+  return { display, payloads };
+}
+
 // Truncate to `max` characters keeping both the head and tail, so a set of
 // strings that share a long common prefix (e.g. persistent Allow options that
 // differ only in their trailing grant note) stay visually distinguishable