@standardagents/code 0.7.1 → 0.8.0

package/dist/index.js

@@ -2274,6 +2274,13 @@ function buildBoxBottom(boxW, borderColor, reset = "\x1B[0m") {
 function buildBoxTopPlain(boxW, borderColor, reset = "\x1B[0m") {
   return `${borderColor}\u256D${"\u2500".repeat(Math.max(1, boxW - 2))}\u256E${reset}`;
 }
+function buildBoxTopLeftLabel(boxW, label, borderColor, labelColor = "\x1B[90m", reset = "\x1B[0m") {
+  const plain = ` ${label} `;
+  const budget = Math.max(1, boxW - 3);
+  const lab = plain.length > budget ? plain.slice(0, Math.max(1, budget)) : plain;
+  const fill = Math.max(1, boxW - 2 - lab.length);
+  return `${borderColor}\u256D${reset}${labelColor}${lab}${reset}${borderColor}${"\u2500".repeat(fill)}\u256E${reset}`;
+}
 function buildBoxBody(content, contentW, borderColor, reset = "\x1B[0m") {
   const vw = boxVisibleWidth(content);
   const pad = Math.max(0, contentW - vw);
@@ -2302,17 +2309,104 @@ function wrapInputBodyLines(inputBuffer, prefix, prefixWidth, contentW) {
   if (out.length === 0) out.push(prefix);
   return out;
 }
+function borderHighlightGrey(intensity) {
+  const t = Math.max(0, Math.min(1, intensity));
+  const e = t * t;
+  const lo = 88;
+  const hi = 236;
+  const v = Math.round(lo + (hi - lo) * e);
+  const ct = process.env.COLORTERM ?? "";
+  const tc = /truecolor|24bit/i.test(ct) || /iterm|kitty|wezterm|ghostty|alacritty/i.test(process.env.TERM_PROGRAM ?? "");
+  if (tc) return `\x1B[38;2;${v};${v};${v}m`;
+  return `\x1B[38;5;${232 + Math.round(23 * e)}m`;
+}
+function rotatingBorderCellColor(index, perimeter, phase, trailFrac = 0.2) {
+  const P = Math.max(1, perimeter);
+  const pos = index / P;
+  const dBehind = ((phase - pos) % 1 + 1) % 1;
+  if (dBehind <= trailFrac) {
+    return borderHighlightGrey(1 - dBehind / trailFrac);
+  }
+  return inputBoxBorderColor();
+}
+function perimeterIndex(edge, offset, boxW, bodyH) {
+  const W = boxW;
+  const H = Math.max(1, bodyH);
+  if (edge === "top") return Math.max(0, Math.min(W - 1, offset));
+  if (edge === "right") return W + Math.max(0, Math.min(H - 1, offset));
+  if (edge === "bottom") return W + H + Math.max(0, Math.min(W - 1, offset));
+  return 2 * W + H + Math.max(0, Math.min(H - 1, offset));
+}
 function buildInputBoxRows(opts) {
   const { cols: cols2, inputBuffer, prefix, prefixWidth, level, levelColor } = opts;
   const borderColor = opts.borderColor ?? inputBoxBorderColor();
   const geo = inputBoxGeometry(cols2);
   const body = wrapInputBodyLines(inputBuffer, prefix, prefixWidth, geo.contentW);
-  const dots = borderLevelDots(level);
-  const dotsStyled = borderLevelDotsStyled(level, levelColor);
-  const top = buildBoxTop(geo.boxW, dots, borderColor, levelColor, "\x1B[0m", dotsStyled);
-  const bottom = buildBoxBottom(geo.boxW, borderColor);
   const pad = " ".repeat(geo.margin);
-  return [pad + top, ...body.map((b) => pad + buildBoxBody(b, geo.contentW, borderColor)), pad + bottom];
+  const phase = opts.borderPhase;
+  if (phase == null || !Number.isFinite(phase)) {
+    const dots2 = borderLevelDots(level);
+    const dotsStyled2 = borderLevelDotsStyled(level, levelColor);
+    const top2 = buildBoxTop(geo.boxW, dots2, borderColor, levelColor, "\x1B[0m", dotsStyled2);
+    const bottom2 = buildBoxBottom(geo.boxW, borderColor);
+    return [pad + top2, ...body.map((b) => pad + buildBoxBody(b, geo.contentW, borderColor)), pad + bottom2];
+  }
+  const W = geo.boxW;
+  const bodyH = Math.max(1, body.length);
+  const P = 2 * W + 2 * bodyH;
+  const reset = "\x1B[0m";
+  const colorAt = (i) => rotatingBorderCellColor(i, P, phase);
+  const dots = borderLevelDots(level);
+  borderLevelDotsStyled(level, levelColor);
+  const labelPlain = ` ${dots} `;
+  const rightFillN = 1;
+  const budget = Math.max(1, W - 2 - rightFillN);
+  const plain = labelPlain.length > budget ? labelPlain.slice(0, Math.max(1, budget)) : labelPlain;
+  const leftFill = Math.max(1, W - 2 - plain.length - rightFillN);
+  let top = "";
+  let xi = 0;
+  top += colorAt(perimeterIndex("top", xi++, W, bodyH)) + "\u256D" + reset;
+  for (let k = 0; k < leftFill; k++) {
+    top += colorAt(perimeterIndex("top", xi++, W, bodyH)) + "\u2500" + reset;
+  }
+  {
+    const plainChars = [...plain];
+    let di = 0;
+    for (const ch of plainChars) {
+      const c2 = colorAt(perimeterIndex("top", xi++, W, bodyH));
+      if (ch === "\u25CF" || ch === "\u25CB") {
+        const levelN = Math.max(1, Math.min(5, level));
+        const filled = di < levelN;
+        di++;
+        top += (filled ? levelColor || c2 : "\x1B[38;5;240m") + (filled ? "\u25CF" : "\u25CB") + reset;
+      } else {
+        top += c2 + ch + reset;
+      }
+    }
+  }
+  for (let k = 0; k < rightFillN; k++) {
+    top += colorAt(perimeterIndex("top", xi++, W, bodyH)) + "\u2500" + reset;
+  }
+  top += colorAt(perimeterIndex("top", Math.min(xi, W - 1), W, bodyH)) + "\u256E" + reset;
+  const bodyRows = [];
+  for (let y = 0; y < bodyH; y++) {
+    const leftC = colorAt(perimeterIndex("left", bodyH - 1 - y, W, bodyH));
+    const rightC = colorAt(perimeterIndex("right", y, W, bodyH));
+    const vw = boxVisibleWidth(body[y]);
+    const sp = Math.max(0, geo.contentW - vw);
+    bodyRows.push(
+      `${pad}${leftC}\u2502${reset} ${body[y]}${" ".repeat(sp)} ${rightC}\u2502${reset}`
+    );
+  }
+  let bottom = "";
+  for (let x = 0; x < W; x++) {
+    const idx = perimeterIndex("bottom", W - 1 - x, W, bodyH);
+    const c2 = colorAt(idx);
+    if (x === 0) bottom += c2 + "\u2570" + reset;
+    else if (x === W - 1) bottom += c2 + "\u256F" + reset;
+    else bottom += c2 + "\u2500" + reset;
+  }
+  return [pad + top, ...bodyRows, pad + bottom];
 }
 var C = {
   reset: "\x1B[0m",
@@ -2367,7 +2461,7 @@ var Tui = class _Tui {
     process.stdin.resume();
     process.stdout.write("\x1B[?2004h");
     process.on("exit", () => process.stdout.write("\x1B[?2004l\x1B[?25h"));
-    process.stdout.on("resize", () => this.renderBottom());
+    process.stdout.on("resize", () => this.scheduleResizeRedraw());
   }
   level;
   // input + indicators
@@ -2426,13 +2520,22 @@ var Tui = class _Tui {
   connected = true;
   bottomDrawn = false;
   started = false;
-  // Resize bookkeeping: the width the region was last drawn at, and the visible
-  // width of every HUD row written above the input. When the terminal is
-  // resized, previously drawn rows re-wrap (a full-width ruler becomes 2+ rows
-  // when narrowed), so the move-up count recorded at draw time is wrong — these
-  // let moveToRegionTop recompute the region height under the NEW wrap instead
-  // of leaving stale rulers behind.
+  // Resize bookkeeping. When the terminal width changes, previously drawn HUD
+  // rows re-wrap (a full-width ruler becomes 2+ physical rows when narrowed),
+  // so the caret-relative move-up from the last paint is stale. We store the
+  // visible width of EVERY region row (not just above the body) plus the caret
+  // row index so moveToRegionTop can recompute physical height under the new
+  // wrap. Resize events are debounced — drag-resizing fires dozens of events
+  // and redrawing each one desyncs and leaves ghost chrome.
   lastDrawnCols = 0;
+  /** Visible width of every HUD row from the last paint, top → bottom. */
+  drawnRegionWidths = [];
+  /** Index into drawnRegionWidths of the row the caret sat on last paint. */
+  lastCaretRegionIndex = 0;
+  resizeTimer = null;
+  /** True between a resize event and the debounced repaint — spinner ticks no-op. */
+  resizePending = false;
+  /** @deprecated kept as alias during paint — prefer drawnRegionWidths */
   drawnHudWidths = [];
   // takeover (approval / menu) state
   takeoverHandler = null;
@@ -2471,6 +2574,23 @@ var Tui = class _Tui {
   };
   onQuit = () => process.exit(0);
   levelListeners = [];
+  /**
+   * Terminal resize fires continuously while the user drags. Redrawing on every
+   * event desyncs the region-height math (each paint uses a half-rewrapped
+   * intermediate width) and stamps ghost boxes into the scrollback. Wait for
+   * the size to settle (~1–2 frames), then do one clean clear+repaint. While
+   * pending, spinner ticks skip paint so they don't thrash mid-drag.
+   */
+  scheduleResizeRedraw() {
+    this.resizePending = true;
+    if (this.resizeTimer) clearTimeout(this.resizeTimer);
+    this.resizeTimer = setTimeout(() => {
+      this.resizeTimer = null;
+      this.resizePending = false;
+      if (!this.started || this.takeoverHandler) return;
+      this.renderBottom();
+    }, 40);
+  }
   get colors() {
     return C;
   }
@@ -2512,6 +2632,10 @@ var Tui = class _Tui {
       clearTimeout(this.streamRedrawTimer);
       this.streamRedrawTimer = null;
     }
+    if (this.resizeTimer) {
+      clearTimeout(this.resizeTimer);
+      this.resizeTimer = null;
+    }
     if (this.spinnerTimer) {
       clearInterval(this.spinnerTimer);
       this.spinnerTimer = null;
@@ -3109,25 +3233,38 @@ var Tui = class _Tui {
       return line;
     });
   }
+  /**
+   * Physical rows a previously painted line of visible width `w` occupies after
+   * the terminal rewraps it to `cols`. Hard-written HUD lines reflow this way.
+   */
+  rewrapRows(w, cols2) {
+    return Math.max(1, Math.ceil(Math.max(w, 1) / Math.max(1, cols2)));
+  }
   /**
    * Move the cursor to the top-left of the current bottom region.
    *
    * Same width as the last draw → the caret's recorded row offset is exact.
    * Width CHANGED (terminal resized) → previously drawn rows re-wrapped, so
-   * that offset is stale; recompute it under the new wrap instead: each drawn
-   * HUD row of visible width w now occupies ceil(w / cols) physical rows
-   * (reflowing terminals re-wrap hard lines; the cursor follows its logical
-   * position in the input text, which inputLayout locates at the new width).
+   * that offset is stale. Recompute using every stored region row width under
+   * the NEW wrap: rows above the caret row + (caret row's rewrap − 1) so we
+   * prefer a slight over-move (clean wipe) over under-move (ghost chrome).
    */
   moveToRegionTop() {
     process.stdout.write("\r");
     if (!this.bottomDrawn) return;
     const cols2 = process.stdout.columns || 80;
     let up;
-    if (cols2 !== this.lastDrawnCols && this.lastDrawnCols > 0) {
+    if (cols2 !== this.lastDrawnCols && this.lastDrawnCols > 0 && this.drawnRegionWidths.length) {
+      const widths = this.drawnRegionWidths.length > 0 ? this.drawnRegionWidths : this.drawnHudWidths;
+      const caretIdx = Math.max(
+        0,
+        Math.min(this.lastCaretRegionIndex, Math.max(0, widths.length - 1))
+      );
       let above = 0;
-      for (const w of this.drawnHudWidths) above += Math.max(1, Math.ceil(Math.max(w, 1) / cols2));
-      up = above + this.inputLayout().caretRow;
+      for (let i = 0; i < caretIdx; i++) above += this.rewrapRows(widths[i], cols2);
+      const caretPhysical = this.rewrapRows(widths[caretIdx] ?? 1, cols2);
+      up = above + Math.max(0, caretPhysical - 1);
+      up += 1;
     } else {
       up = this.lastCursorRow;
     }
@@ -3145,6 +3282,7 @@ var Tui = class _Tui {
    */
   renderBottom() {
     if (!this.started || this.takeoverHandler) return;
+    if (this.resizePending) return;
     const cols2 = process.stdout.columns || 80;
     this.moveToRegionTop();
     const hudWidths = [];
@@ -3181,6 +3319,8 @@ var Tui = class _Tui {
     for (const line of goalLines) writeHudRow(workPad + line);
     const prefix = this.promptPrefix();
     const pw = this.visibleWidth(prefix);
+    const borderAnimating = this.working;
+    const borderPhase = borderAnimating ? Date.now() % 1400 / 1400 : null;
     const boxRows = buildInputBoxRows({
       cols: cols2,
       inputBuffer: this.inputBuffer,
@@ -3188,14 +3328,14 @@ var Tui = class _Tui {
       prefixWidth: pw,
       level: this.level,
       levelColor: this.levelColor(),
-      borderColor: inputBoxBorderColor()
+      borderColor: inputBoxBorderColor(),
+      borderPhase
     });
     const boxTop = boxRows[0];
     const boxBottom = boxRows[boxRows.length - 1];
     const boxBody = boxRows.slice(1, -1);
     writeHudRow(boxTop);
-    const aboveBodyWidths = hudWidths.slice();
-    const aboveBodyRows = aboveBodyWidths.length;
+    const bodyStartIdx = hudWidths.length;
     for (const row of boxBody) writeHudRow(row);
     writeHudRow(boxBottom);
     const paletteBlock = this.paletteBlockLines(cols2);
@@ -3203,10 +3343,12 @@ var Tui = class _Tui {
     const layout = this.inputLayout();
     const bodyRowCount = Math.max(1, boxBody.length);
     const caretBodyRow = Math.max(0, Math.min(layout.caretRow, bodyRowCount - 1));
-    const caretRegionRow = aboveBodyRows + caretBodyRow;
+    const caretRegionRow = bodyStartIdx + caretBodyRow;
     const caretScreenCol = Math.min(rowCap - 1, geo.leftPad + layout.caretCol);
     this.lastCursorRow = caretRegionRow;
-    this.drawnHudWidths = aboveBodyWidths;
+    this.lastCaretRegionIndex = caretRegionRow;
+    this.drawnRegionWidths = hudWidths.slice();
+    this.drawnHudWidths = hudWidths.slice(0, bodyStartIdx);
     this.lastDrawnCols = cols2;
     this.bottomDrawn = true;
     const totalRows = hudRows.length;
@@ -3563,70 +3705,249 @@ var Tui = class _Tui {
     }
     this.renderBottom();
   }
-  /** Approval prompt: arrow-navigable with y/a/l/n shortcuts. Pauses input.
-   * Tab resolves "deny_with_reason" so the caller can collect a free-text reason. */
+  /**
+   * ## Boxed prompt — reusable HUD free-text component
+   *
+   * Single-line free-text capture using the **same chrome as the main input
+   * box** (side margin, grey rounded rim, level-tinted `❯`, real caret). A
+   * left-aligned label sits in the top border rim instead of the permission
+   * level dots.
+   *
+   * Prefer this over {@link Tui.prompt} whenever the capture should feel like
+   * part of the HUD rather than a legacy bar — denial feedback, handoff notes,
+   * reject-with-reason, rename, or any other short free-text moment.
+   *
+   * ```
+   * ╭ Denial feedback ────────────────────────╮
+   * │ ❯ the user-typed note                    │
+   * ╰──────────────────────────────────────────╯
+   * ```
+   *
+   * **Keys**
+   * - Enter — submit (resolves the trimmed string; may be `""`)
+   * - Esc — clear a non-empty draft; Esc again (empty) cancels → `null`
+   *   (override with `escClearsFirst: false` to always cancel)
+   *
+   * **Nested mode** (`nested: true`) — call from inside another takeover
+   * (e.g. approval → feedback) so this component only steals the key handler
+   * and paints/erases its own three rows; the parent still owns begin/end.
+   *
+   * Do **not** use brand-gradient text for the label — gradient is reserved
+   * for success moments (`✓ Goal complete.`, farewell, etc.).
+   *
+   * @returns trimmed text on Enter, or `null` if the user cancelled with Esc
+   */
+  boxedPrompt(opts) {
+    return new Promise((resolve) => {
+      const nested = !!opts.nested;
+      const escClearsFirst = opts.escClearsFirst !== false;
+      const borderLabel = opts.borderLabel || "Feedback";
+      const labelColor = opts.labelColor ?? "\x1B[90m";
+      let buf = opts.initial ?? "";
+      if (!nested) this.beginTakeover();
+      process.stdout.write("\x1B[?25h");
+      const cols2 = process.stdout.columns || 80;
+      const geo = inputBoxGeometry(cols2);
+      const border = inputBoxBorderColor();
+      const pad = " ".repeat(geo.margin);
+      const rowCap = Math.max(1, cols2 - 1);
+      const reset = C.reset;
+      const prompt = `${this.levelColor()}\u276F${reset} `;
+      const promptW = 2;
+      const writeRow = (line) => {
+        const row = this.clampVisible(sanitizeHudRow(line), rowCap);
+        process.stdout.write(`\r\x1B[K${row}
+`);
+      };
+      const draw = () => {
+        writeRow(pad + buildBoxTopLeftLabel(geo.boxW, borderLabel, border, labelColor));
+        writeRow(pad + buildBoxBody(prompt + buf, geo.contentW, border));
+        writeRow(pad + buildBoxBottom(geo.boxW, border));
+        process.stdout.write("\r\x1B[2A");
+        const col = geo.leftPad + promptW + buf.length;
+        if (col > 0) process.stdout.write(`\x1B[${Math.min(rowCap - 1, col)}C`);
+      };
+      const clearFrame = () => {
+        process.stdout.write("\r\x1B[1A\x1B[J");
+      };
+      const redraw = () => {
+        process.stdout.write("\r\x1B[1A");
+        draw();
+      };
+      const finish = (value) => {
+        clearFrame();
+        if (!nested) this.endTakeover();
+        else this.takeoverHandler = null;
+        resolve(value);
+      };
+      draw();
+      this.takeoverHandler = (str, key) => {
+        if (key?.name === "escape") {
+          if (escClearsFirst && buf.length > 0) {
+            buf = "";
+            redraw();
+            return;
+          }
+          finish(null);
+          return;
+        }
+        if (key?.name === "return" || key?.name === "enter") {
+          finish(buf.trim());
+          return;
+        }
+        if (key?.name === "backspace") {
+          if (!buf.length) return;
+          buf = buf.slice(0, -1);
+          redraw();
+          return;
+        }
+        if (str && !key?.ctrl && !key?.meta && str >= " ") {
+          if (buf.length < Math.max(8, geo.contentW - promptW - 1)) {
+            buf += str;
+            redraw();
+          }
+        }
+      };
+    });
+  }
+  /**
+   * Permission prompt: boxed chrome matching the HUD, arrow-navigable options
+   * with shortcuts. Includes "Deny with feedback" — choosing it (or Tab)
+   * opens {@link Tui.boxedPrompt} so the reason can ride back to the agent.
+   */
   approval(question, risk) {
     return new Promise((resolve) => {
       const options = [
         { value: "allow", label: "Allow once", shortcut: "y", color: C.green },
         { value: "always", label: "Always allow this tool", shortcut: "a", color: C.cyan },
-        { value: "always_risk", label: `Allow level ${risk} and below this session`, shortcut: "l", color: C.cyan },
-        { value: "deny", label: "Deny", shortcut: "n", color: C.red }
+        {
+          value: "always_risk",
+          label: `Allow level ${risk} and below this session`,
+          shortcut: "l",
+          color: C.cyan
+        },
+        { value: "deny", label: "Deny", shortcut: "n", color: C.red },
+        {
+          value: "deny_feedback",
+          label: "Deny with feedback",
+          shortcut: "d",
+          color: C.magenta,
+          hint: "tell the agent why"
+        }
       ];
       let idx = 0;
-      const riskBar = `${C.red}${"\u25CF".repeat(risk)}${C.gray}${"\u25CB".repeat(5 - risk)}${C.reset}`;
+      const riskLevel = Math.max(1, Math.min(5, Math.round(risk)));
+      const riskBar = borderLevelDotsStyled(riskLevel, C.yellow, "\x1B[38;5;240m");
       this.beginTakeover();
-      const cols2 = Math.max(1, process.stdout.columns || 80);
-      const physRows = (line) => Math.max(1, Math.ceil(this.visibleWidth(line) / cols2));
-      const headerText = `${C.yellow}\u2503${C.reset} ${C.bold}Permission needed${C.reset}  risk ${riskBar}`;
-      const questionLines = question.split("\n").map((line) => `${C.yellow}\u2503${C.reset} ${line}`);
-      const hintLine = `${C.yellow}\u2503${C.reset} ${C.gray}\u21E5 tab \u2014 deny with a reason${C.reset}`;
-      const blockLines = [headerText, ...questionLines, hintLine];
-      const headerRows = 1 + blockLines.reduce((n, line) => n + physRows(line), 0);
-      process.stdout.write(`
-` + blockLines.map((line) => `${line}
-`).join(""));
-      const renderLine = (i) => {
+      const cols2 = process.stdout.columns || 80;
+      const geo = inputBoxGeometry(cols2);
+      const border = inputBoxBorderColor();
+      const pad = " ".repeat(geo.margin);
+      const rowCap = Math.max(1, cols2 - 1);
+      const reset = C.reset;
+      const wrapContent = (text) => {
+        const flat2 = text.replace(/\s+/g, " ").trim();
+        if (!flat2) return [""];
+        const out = [];
+        let rest = flat2;
+        while (rest.length > geo.contentW) {
+          out.push(rest.slice(0, geo.contentW - 1) + "\u2026");
+          rest = rest.slice(geo.contentW - 1);
+          if (out.length >= 4) {
+            break;
+          }
+        }
+        if (out.length < 4) out.push(rest);
+        return out.length ? out : [""];
+      };
+      const summaryLines = question.split("\n").flatMap((line) => {
+        const plain = line.replace(/\x1b\[[0-9;]*m/g, "").trim();
+        if (!plain) return [];
+        const isWhy = /^why:/i.test(plain);
+        return wrapContent(plain).map((l) => isWhy ? `${C.dim}${l}${reset}` : l);
+      });
+      if (!summaryLines.length) summaryLines.push(`${C.dim}(no details)${reset}`);
+      const writeRow = (line) => {
+        const row = this.clampVisible(sanitizeHudRow(line), rowCap);
+        process.stdout.write(`\r\x1B[K${row}
+`);
+      };
+      const optionCount = options.length;
+      const summaryCount = summaryLines.length;
+      const boxRows = 1 + summaryCount + 1 + optionCount + 1;
+      const titleRows = 2;
+      const totalRows = titleRows + boxRows;
+      const renderOptionContent = (i) => {
         const o = options[i];
         const sel = i === idx;
-        const pointer = sel ? `${o.color}\u276F${C.reset}` : " ";
-        const label = sel ? `${C.bold}${o.label}${C.reset}` : o.label;
-        return `${C.yellow}\u2503${C.reset} ${pointer} ${label} ${C.gray}(${o.shortcut})${C.reset}`;
+        const pointer = sel ? `${o.color}\u276F${reset} ` : "  ";
+        const label = sel ? `${C.bold}${o.color}${o.label}${reset}` : `${C.dim}${o.label}${reset}`;
+        const shortcut = `${C.gray}(${o.shortcut})${reset}`;
+        const hint = o.hint && sel ? `${C.dim}  ${o.hint}${reset}` : "";
+        const plainLabel = o.label;
+        const used = 2 + plainLabel.length + 1 + 3 + (o.hint && sel ? 2 + o.hint.length : 0);
+        const gap = Math.max(1, geo.contentW - used);
+        return `${pointer}${label}${" ".repeat(gap)}${shortcut}${hint}`;
       };
-      const draw = (moveUp) => {
-        if (moveUp) process.stdout.write(`\x1B[${options.length}A`);
-        for (let i = 0; i < options.length; i++) process.stdout.write(`\r\x1B[K${renderLine(i)}
-`);
+      const drawFrame = (moveUp) => {
+        if (moveUp) process.stdout.write(`\x1B[${totalRows}A`);
+        writeRow("");
+        writeRow(
+          `${pad}${C.bold}Permission needed${reset}  ${C.dim}risk${reset} ${riskBar}`
+        );
+        writeRow(pad + buildBoxTopPlain(geo.boxW, border));
+        for (const line of summaryLines) {
+          writeRow(pad + buildBoxBody(line, geo.contentW, border));
+        }
+        writeRow(pad + buildBoxBody("", geo.contentW, border));
+        for (let i = 0; i < optionCount; i++) {
+          writeRow(pad + buildBoxBody(renderOptionContent(i), geo.contentW, border));
+        }
+        writeRow(pad + buildBoxBottom(geo.boxW, border));
       };
-      draw(false);
+      drawFrame(false);
       const erase = () => {
         process.stdout.write("\r");
-        const up = headerRows + options.length;
-        if (up > 0) process.stdout.write(`\x1B[${up}A`);
+        if (totalRows > 0) process.stdout.write(`\x1B[${totalRows}A`);
         process.stdout.write("\x1B[J");
       };
-      const finish = (choice) => {
+      const done = (choice, reason) => {
         erase();
         this.endTakeover();
-        resolve(choice);
+        resolve({ choice });
+      };
+      const collectFeedback = () => {
+        erase();
+        void this.boxedPrompt({ borderLabel: "Denial feedback", nested: true }).then((why) => {
+          this.endTakeover();
+          if (why) resolve({ choice: "deny", reason: why });
+          else resolve({ choice: "deny" });
+        });
+      };
+      const pick = (value) => {
+        if (value === "deny_feedback") collectFeedback();
+        else done(value);
       };
       this.takeoverHandler = (str, key) => {
         if (key?.name === "up" || str === "k") {
-          idx = (idx - 1 + options.length) % options.length;
-          draw(true);
+          idx = (idx - 1 + optionCount) % optionCount;
+          drawFrame(true);
         } else if (key?.name === "down" || str === "j") {
-          idx = (idx + 1) % options.length;
-          draw(true);
+          idx = (idx + 1) % optionCount;
+          drawFrame(true);
         } else if (key?.name === "tab") {
-          finish("deny_with_reason");
+          pick("deny_feedback");
         } else if (key?.name === "return" || key?.name === "enter") {
-          finish(options[idx].value);
+          pick(options[idx].value);
+        } else if (key?.name === "escape") {
+          done("deny");
         } else {
           const k = (str || "").toLowerCase();
-          if (k === "y") finish("allow");
-          else if (k === "a") finish("always");
-          else if (k === "l") finish("always_risk");
-          else if (k === "n" || key?.name === "escape") finish("deny");
+          if (k === "y") pick("allow");
+          else if (k === "a") pick("always");
+          else if (k === "l") pick("always_risk");
+          else if (k === "n") pick("deny");
+          else if (k === "d" || k === "f") pick("deny_feedback");
         }
       };
     });
@@ -5191,18 +5512,11 @@ async function runInteractive(tui, api, threadId, projectDir, machine, resumed,
       }
     },
     requestApproval: async (req, summary, risk) => {
-      const choice = await tui.approval(
+      return tui.approval(
         `${summary}${req.requestPermission ? `
-${c.bold}why: ${req.requestPermission}${c.reset}` : ""}`,
+why: ${req.requestPermission}` : ""}`,
         risk
       );
-      if (choice === "deny_with_reason") {
-        const reason = await tui.prompt(
-          "Why are you denying this? (sent to the agent \u2014 enter to send, esc to skip)"
-        );
-        return { choice: "deny", reason: reason ?? void 0 };
-      }
-      return { choice };
     }
   });
   const stream = new MessageStream(api, threadId, {
@@ -5445,16 +5759,27 @@ ${c.bold}why: ${req.requestPermission}${c.reset}` : ""}`,
     if (upgradeInFlight) return;
     upgradeInFlight = true;
     try {
+      if (opts.auto) {
+        tui.print(
+          `${c.yellow}You're out of simultaneous sessions \u2014 another Standard Code session is using your slot.${c.reset}`
+        );
+      }
       const quote = await api.sessionsQuote(threadId);
       if (!quote) {
         const link = await api.accountLink(threadId).catch(() => null);
         const target = link?.url ?? "https://standardcode.ai/account";
+        tui.print(
+          `${c.gray}Close the other session (its slot frees within ~90s) \u2014 or add another simultaneous session to your plan, then resend your message.${c.reset}`
+        );
         openUrl(target);
         tui.print(`${c.gray}\u2192 opened ${target} to manage your plan${c.reset}`);
         return;
       }
       if (quote.current >= quote.max) {
-        tui.print(`${c.yellow}You're at the maximum of ${quote.max} parallel sessions.${c.reset}`);
+        tui.print(
+          `${c.yellow}You're at the maximum of ${quote.max} parallel session${quote.max === 1 ? "" : "s"}.${c.reset}
+${c.gray}Close another session (its slot frees within ~90s), then resend your message.${c.reset}`
+        );
         return;
       }
       tui.print(renderUpgradePanel(quote));