@pellux/goodvibes-tui 1.16.1 → 1.18.0

package/src/permissions/broker-approval-card.ts

@@ -0,0 +1,201 @@
+/**
+ * broker-approval-card — render a broker-originated approval ask as a real
+ * TUI approval card.
+ *
+ * The approval broker publishes every ask (local runtime asks, plus
+ * broker-originated ones like the CI fix-session offer). Local asks carry a
+ * `localPrompt` that opens their own card; broker-originated asks do not, so
+ * before this they were invisible in the TUI — the ask sat pending with no
+ * surface. This helper opens a card straight from broker state for those.
+ *
+ * A local ask's own prompt is opened by the broker immediately AFTER it
+ * publishes (see ApprovalBroker.requestApproval), so the open here is deferred
+ * one microtask and re-checks: if a card (the local one, or another broker
+ * card) is already up, it does nothing — only a genuinely unhandled ask surfaces.
+ * The card's resolve answers the broker directly via resolveApproval, so a TUI
+ * decision on a broker-originated ask reaches every waiter on that record.
+ */
+
+import { buildPendingPermissionExtras } from './hunk-selection.ts';
+import type { ApprovalRequesterLookup } from './hunk-selection.ts';
+import type { PendingPermissionState } from '../shell/blocking-input.ts';
+import type { PermissionPromptRequest, RememberTier } from '@pellux/goodvibes-sdk/platform/permissions';
+
+/** The broker seam this helper answers through — a subset of ApprovalBroker. */
+export interface BrokerApprovalCardBroker extends ApprovalRequesterLookup {
+  getApproval(approvalId: string): { readonly status: string; readonly request: PermissionPromptRequest } | null;
+  resolveApproval(
+    approvalId: string,
+    input: {
+      readonly approved: boolean;
+      readonly remember?: boolean;
+      readonly rememberTier?: RememberTier;
+      readonly reason?: string;
+      readonly modifiedArgs?: Record<string, unknown>;
+      readonly actor: string;
+      readonly actorSurface?: string;
+    },
+  ): Promise<unknown>;
+}
+
+export interface BrokerApprovalChangeParams {
+  readonly approval: {
+    readonly id: string;
+    readonly callId: string;
+    readonly status: string;
+    readonly request: PermissionPromptRequest;
+    /** The REAL attachable session id once an ACCEPTED ask (e.g. a ci:fix-session offer) has spawned its session. */
+    readonly fixSessionId?: string | undefined;
+    /** The honest failure when an accepted ask's spawn did NOT produce an attachable session — mutually exclusive with fixSessionId. */
+    readonly fixSessionError?: string | undefined;
+  };
+  readonly getPending: () => PendingPermissionState | null;
+  readonly setPending: (pending: PendingPermissionState | null) => void;
+  readonly broker: BrokerApprovalCardBroker;
+  readonly render: () => void;
+  /**
+   * Fired when a record carries the id of a session an accepted ask spawned
+   * (the CI fix-session). The surface that accepted — attached now — turns this
+   * into a jump/attach affordance. Called each time the field is seen; the
+   * caller de-duplicates by id.
+   */
+  readonly onFixSessionStarted?: (fixSessionId: string) => void;
+  /**
+   * Fired when a record carries the honest failure from an accepted ask whose
+   * spawn produced no attachable session. The surface renders it as an error
+   * line with NO action to jump to (there is no session). Called each time the
+   * field is seen; the caller de-duplicates.
+   */
+  readonly onFixSessionError?: (fixSessionError: string) => void;
+  /** Defers the open (default queueMicrotask); injectable so tests run it synchronously. */
+  readonly defer?: (callback: () => void) => void;
+}
+
+const isActiveStatus = (status: string): boolean => status === 'pending' || status === 'claimed';
+
+export interface FixSessionAffordanceDeps {
+  /** Announce the ready fix session as one actionable line — never a retype instruction. */
+  readonly notify: (message: string) => void;
+  /** Arm the one-key jump with the spawned session id; the surface consumes it on the jump key. */
+  readonly arm: (fixSessionId: string) => void;
+}
+
+/**
+ * Build the one-key jump/attach affordance for a spawned fix-session: the first
+ * time a given session id is seen it ARMS the jump (the surface attaches on the
+ * jump key — the machine does the resume, the user never retypes an id) and
+ * surfaces a one-line actionable notice. Repeats are no-ops (de-duplicated by
+ * id), so the live record update and the listApprovals refresh path can both
+ * feed it safely.
+ */
+export function buildFixSessionAffordance(deps: FixSessionAffordanceDeps): (fixSessionId: string) => void {
+  const seen = new Set<string>();
+  return (fixSessionId) => {
+    if (seen.has(fixSessionId)) return;
+    seen.add(fixSessionId);
+    deps.arm(fixSessionId);
+    deps.notify('[CI] Fix session ready — press j to jump to it.');
+  };
+}
+
+/**
+ * Build the honest failure notice for an accepted fix-session offer whose spawn
+ * produced no attachable session: one error line, NO jump action (there is no
+ * session to attach to). De-duplicated by the error text so the live record
+ * update and the listApprovals refresh path can both feed it safely.
+ */
+export function buildFixSessionErrorNotice(notify: (message: string) => void): (fixSessionError: string) => void {
+  const seen = new Set<string>();
+  return (fixSessionError) => {
+    if (seen.has(fixSessionError)) return;
+    seen.add(fixSessionError);
+    notify(`[CI] Fix session could not start: ${fixSessionError}`);
+  };
+}
+
+export interface FixSessionAttachKeyDeps {
+  /** The armed fix-session id (the surface clears the arm before calling this). */
+  readonly armedFixSessionId: string;
+  /** Attach/jump to the fix session — runs the resume so the user never retypes an id. */
+  readonly attach: (fixSessionId: string) => void;
+  readonly render: () => void;
+}
+
+/**
+ * Consume the keypress that follows an armed fix-session notice: the jump key
+ * ('j') attaches to the armed session; any other key just falls through (the
+ * caller has already cleared the arm, so the affordance is one-shot). Returns
+ * true only when it performed the jump.
+ */
+export function handleFixSessionAttachKey(data: string, deps: FixSessionAttachKeyDeps): boolean {
+  if (data === 'j') {
+    deps.attach(deps.armedFixSessionId);
+    deps.render();
+    return true;
+  }
+  return false;
+}
+
+/**
+ * The refresh path: sweep current approval records for spawned fix-sessions and
+ * feed each to the (de-duplicating) affordance. Catches a session stamped before
+ * the live subscription attached, or a record update the subscription missed.
+ */
+export function refreshFixSessionsFromApprovals(
+  listApprovals: () => readonly { readonly fixSessionId?: string | undefined; readonly fixSessionError?: string | undefined }[],
+  onFixSessionStarted: (fixSessionId: string) => void,
+  onFixSessionError?: (fixSessionError: string) => void,
+): void {
+  for (const record of listApprovals()) {
+    if (record.fixSessionId) onFixSessionStarted(record.fixSessionId);
+    else if (record.fixSessionError && onFixSessionError) onFixSessionError(record.fixSessionError);
+  }
+}
+
+/**
+ * React to one broker approval change: clear the active card when ITS approval
+ * resolves, or open a card for a newly-pending broker-originated ask that no
+ * local prompt is handling.
+ */
+export function handleBrokerApprovalChange(params: BrokerApprovalChangeParams): void {
+  const { approval, getPending, setPending, broker, render } = params;
+  const defer = params.defer ?? queueMicrotask;
+  const active = isActiveStatus(approval.status);
+
+  // An accepted ask that spawned a session (the CI fix-session) publishes its
+  // REAL session id as a record update — the live in-process handle to jump to
+  // it — or, when the spawn failed, an honest error instead of a dead id
+  // (mutually exclusive). Both arrive after the card has resolved and cleared,
+  // so surface them independently of the card lifecycle below.
+  if (approval.fixSessionId) params.onFixSessionStarted?.(approval.fixSessionId);
+  else if (approval.fixSessionError) params.onFixSessionError?.(approval.fixSessionError);
+
+  const pending = getPending();
+  if (pending && pending.callId === approval.callId) {
+    // This is the card already on screen — clear it once its approval resolves.
+    if (!active) { setPending(null); render(); }
+    return;
+  }
+  if (!active) return;
+
+  defer(() => {
+    if (getPending()) return; // a local card (or another broker card) is already up
+    const current = broker.getApproval(approval.id);
+    if (!current || !isActiveStatus(current.status)) return;
+    setPending({
+      ...current.request,
+      ...buildPendingPermissionExtras(current.request, (decision) => {
+        void broker.resolveApproval(approval.id, {
+          approved: decision.approved,
+          remember: decision.remember ?? false,
+          ...(decision.rememberTier ? { rememberTier: decision.rememberTier } : {}),
+          ...(decision.reason ? { reason: decision.reason } : {}),
+          ...(decision.modifiedArgs ? { modifiedArgs: decision.modifiedArgs } : {}),
+          actor: 'tui',
+          actorSurface: 'tui',
+        }).catch(() => {});
+      }, broker),
+    } as PendingPermissionState);
+    render();
+  });
+}

package/src/permissions/hunk-selection.ts

@@ -1,7 +1,7 @@
-import type { PermissionAttribution, PermissionPromptRequest } from '@pellux/goodvibes-sdk/platform/permissions';
+import type { PermissionAttribution, PermissionPromptRequest, RememberTier } from '@pellux/goodvibes-sdk/platform/permissions';
 
 /**
- * Per-hunk accept/reject at the approval gate (W1.3 v1).
+ * Per-hunk accept/reject at the approval gate (v1).
  *
  * Scoped to the `edit` tool only: EditInput.edits is already an array of
  * independent, atomic find/replace units (each a natural "hunk"), so no
@@ -48,6 +48,16 @@ export interface PermissionPromptDecisionWithModifiedArgs {
   approved: boolean;
   remember?: boolean;
   modifiedArgs?: Record<string, unknown>;
+  /** Generalizing remember tier: 'session' | 'exact' | 'command-class' | 'path' | 'tool'. */
+  rememberTier?: RememberTier;
+  /** Free-text from the user; most useful on deny — rides the structured "user declined" tool result. */
+  reason?: string;
+}
+
+/** Extra decision fields a resolve call can carry beyond approve/remember/modifiedArgs. */
+export interface PermissionResolveExtras {
+  readonly rememberTier?: RememberTier;
+  readonly reason?: string;
 }
 
 export interface HunkKeyResult {
@@ -247,14 +257,28 @@ export function buildPendingPermissionExtras(
   now: number = Date.now(),
 ): {
   hunkState: HunkSelectionState | undefined;
-  resolve: (approved: boolean, remember?: boolean, modifiedArgs?: Record<string, unknown>) => void;
+  resolve: (approved: boolean, remember?: boolean, modifiedArgs?: Record<string, unknown>, extras?: PermissionResolveExtras) => void;
   openedAt: number;
   requestedBy: string | undefined;
+  replyMode: 'exec-answer' | undefined;
+  replyBuffer: string | undefined;
 } {
+  // An exec-prompt ask (a running command waiting on stdin) opens straight in
+  // answer mode: every printable key types the answer — a run whose prompt
+  // needs a literal 'y' must never have it eaten as a card command key.
+  const isExecPrompt = request.attribution?.kind === 'exec-prompt';
   return {
     hunkState: isHunkSelectable(request) ? buildHunkSelectionState(request) : undefined,
-    resolve: (approved, remember = false, modifiedArgs) => resolvePromise({ approved, remember, modifiedArgs }),
+    resolve: (approved, remember = false, modifiedArgs, extras) => resolvePromise({
+      approved,
+      remember,
+      modifiedArgs,
+      ...(extras?.rememberTier ? { rememberTier: extras.rememberTier } : {}),
+      ...(extras?.reason ? { reason: extras.reason } : {}),
+    }),
     openedAt: now,
     requestedBy: resolveApprovalRequester(broker, request.callId, request.attribution) ?? undefined,
+    replyMode: isExecPrompt ? 'exec-answer' : undefined,
+    replyBuffer: isExecPrompt ? '' : undefined,
   };
 }

package/src/permissions/prompt.ts

@@ -3,6 +3,8 @@ import { UIFactory } from '../renderer/ui-factory.ts';
 import type { PermissionCategory, PermissionRequestAnalysis } from '@pellux/goodvibes-sdk/platform/permissions';
 import { buildPermissionApprovalBrief, getDisplayArg } from '@pellux/goodvibes-sdk/platform/permissions';
 import { DIFF_TONES, UI_TONES } from '../renderer/ui-primitives.ts';
+import { renderDiffView } from '../renderer/diff-view.ts';
+import { wrapText } from '../utils/terminal-width.ts';
 import type { HunkSelectionState } from './hunk-selection.ts';
 import { readSandboxAskAnnotation } from './sandbox-exec-gate.ts';
 export { buildPendingPermissionExtras } from './hunk-selection.ts';
@@ -13,9 +15,28 @@ export type { PermissionPromptRequest, PermissionPromptDecision, PermissionReque
 /** Visible hunk rows before a "+N more" trailer kicks in (Risk 3). */
 const MAX_VISIBLE_HUNKS = 8;
 
-/** Path rows shown before collapsing to a "N files: a, b, +K more" line (UX-B 2a). */
+/** Path rows shown before collapsing to a "N files: a, b, +K more" line (2a). */
 const MAX_PATH_ROWS = 3;
 
+/** Diff rows shown for a write/edit ask before the "+N more" trailer. */
+const MAX_DIFF_LINES = 10;
+
+/** Field-label column width shared by every "   Label     : value" row. */
+const FIELD_PREFIX_LEN = 16;
+
+/**
+ * View-only state the card renders beyond the request itself: the typed-reply
+ * mode/draft (deny-with-reason, exec-prompt answer), the honest count of
+ * OTHER broker asks still waiting, and the terminal width getPromptHeight
+ * needs for wrap-dependent rows (createPromptLines takes width positionally).
+ */
+export interface PromptViewState {
+  readonly replyMode?: 'deny-reason' | 'exec-answer' | undefined;
+  readonly replyBuffer?: string | undefined;
+  readonly queueCount?: number | undefined;
+  readonly width?: number | undefined;
+}
+
 /** Trailing filename for compact display of a long/absolute path. */
 function baseName(p: string): string {
   const cleaned = p.replace(/[/\\]+$/, '');
@@ -47,7 +68,7 @@ function collectField(arr: unknown, field: string): string[] {
 /**
  * The real display target(s) of a tool invocation — the paths/commands/urls a
  * user needs to see, extracted from the actual arg shapes so a nested
- * `{files:[{path}]}` no longer falls through to a raw JSON blob. (UX-B 2a.)
+ * `{files:[{path}]}` no longer falls through to a raw JSON blob. (2a.)
  * Returns [] when nothing recognisable is present (caller falls back).
  */
 function cardTargets(args: Record<string, unknown>): string[] {
@@ -153,7 +174,7 @@ export class PermissionPromptUI {
   /**
    * A low-risk, project-local request is shown condensed (one summary line +
    * choices) unless the user expanded it with `d`. High/critical risk, external
-   * scope, and hunk-selectable edits always show the full block. (UX-B 2b.)
+   * scope, and hunk-selectable edits always show the full block. (2b.)
    */
   private static isCondensed(
     request: PermissionPromptRequest,
@@ -164,8 +185,11 @@ export class PermissionPromptUI {
     // Shell execution, delegation and network requests always show the full
     // card — their action semantics (command, side effects, host, checklist)
     // warrant scrutiny even when the risk model rates them low. Only mundane
-    // low-risk filesystem reads/writes condense. (UX-B 2b.)
+    // low-risk filesystem reads/writes condense. (2b.)
     if (request.category === 'execute' || request.category === 'delegate') return false;
+    // Remember tiers are one-key choices that must be visible to be usable —
+    // a request carrying rememberOptions always shows the full card.
+    if (request.rememberOptions && request.rememberOptions.length > 0) return false;
     const analysis = this.fallbackAnalysis(request);
     if (analysis.riskLevel !== 'low') return false;
     const scope = analysis.blastRadius;
@@ -197,32 +221,179 @@ export class PermissionPromptUI {
     return `${prefix}${shown}${suffix}`;
   }
 
+  /**
+   * The remember block's row texts: one row per SDK remember tier (numbered,
+   * most specific first) when the request carries rememberOptions, else the
+   * legacy single [A] session-preview row. Hunk mode has no whole-request
+   * remember choice at all. Shared by getPromptHeight and createPromptLines.
+   */
+  private static rememberRowTexts(
+    request: PermissionPromptRequest,
+    hunkState: HunkSelectionState | undefined,
+    width: number,
+  ): string[] {
+    if (hunkState) return [];
+    const options = request.rememberOptions ?? [];
+    if (options.length === 0) return [this.rememberPreviewText(request, width)];
+    const clamp = (s: string): string => (s.length > width ? `${s.slice(0, Math.max(0, width - 3))}...` : s);
+    return options.map((option, index) => {
+      const labelCol = index === 0 ? 'Remember ' : ' '.repeat(9);
+      return clamp(`   ${labelCol}: [${index + 1}] ${option.label} — ${option.detail}`);
+    });
+  }
+
+  /**
+   * The FULL command of an execute ask, wrapped across as many rows as it
+   * needs — never truncated. Empty for non-execute asks and for asks without
+   * a string command. Shared by getPromptHeight and createPromptLines.
+   */
+  private static commandRowTexts(request: PermissionPromptRequest, width: number): string[] {
+    if (request.category !== 'execute') return [];
+    // Exec-prompt asks render their command via execPromptRowTexts instead.
+    if (request.attribution?.kind === 'exec-prompt') return [];
+    const command = typeof request.args?.command === 'string'
+      ? request.args.command
+      : typeof request.args?.cmd === 'string'
+        ? request.args.cmd
+        : '';
+    if (command.length === 0) return [];
+    const budget = Math.max(10, width - FIELD_PREFIX_LEN);
+    const wrapped = command.split('\n').flatMap((line) => (line.length > 0 ? wrapText(line, budget) : ['']));
+    return wrapped.map((row, index) => (index === 0 ? `   Command   : ${row}` : `${' '.repeat(FIELD_PREFIX_LEN - 1)}${row}`));
+  }
+
+  /**
+   * Unified-diff text lines for a write/edit ask (real colored rendering via
+   * renderDiffView), capped at MAX_DIFF_LINES with a context trailer naming
+   * how much is hidden. Null when the ask carries nothing diffable. Hunk-mode
+   * asks render the interactive hunk list instead. Shared by getPromptHeight
+   * and createPromptLines.
+   */
+  private static writeDiffLines(request: PermissionPromptRequest, hunkState: HunkSelectionState | undefined): string[] | null {
+    if (hunkState || request.category !== 'write') return null;
+    const args = request.args ?? {};
+    const target = typeof args.path === 'string' ? args.path : typeof args.file === 'string' ? args.file : '';
+    const out: string[] = [];
+    if (typeof args.content === 'string') {
+      const contentLines = args.content.split('\n');
+      out.push(`+++ ${target || '(new content)'}`);
+      for (const line of contentLines.slice(0, MAX_DIFF_LINES)) out.push(`+${line}`);
+      if (contentLines.length > MAX_DIFF_LINES) out.push(` … +${contentLines.length - MAX_DIFF_LINES} more lines`);
+      return out;
+    }
+    if (Array.isArray(args.edits)) {
+      let budget = MAX_DIFF_LINES;
+      let hidden = 0;
+      for (const edit of args.edits) {
+        if (!edit || typeof edit !== 'object') continue;
+        const e = edit as { path?: unknown; find?: unknown; replace?: unknown };
+        if (typeof e.find !== 'string' || typeof e.replace !== 'string') continue;
+        const findLines = e.find.split('\n');
+        const replaceLines = e.replace.split('\n');
+        const need = 1 + findLines.length + replaceLines.length;
+        if (budget < need) {
+          hidden += 1;
+          continue;
+        }
+        out.push(`@@ ${typeof e.path === 'string' ? e.path : target} @@`);
+        for (const line of findLines) out.push(`-${line}`);
+        for (const line of replaceLines) out.push(`+${line}`);
+        budget -= need;
+      }
+      if (out.length === 0) return null;
+      if (hidden > 0) out.push(` … +${hidden} more edits`);
+      return out;
+    }
+    return null;
+  }
+
+  /**
+   * Rows for an exec-prompt ask (a running command waiting on stdin): the
+   * command and the terminal prompt text, both wrapped in full. Shared by
+   * getPromptHeight and createPromptLines.
+   */
+  private static execPromptRowTexts(request: PermissionPromptRequest, width: number): string[] {
+    const attribution = request.attribution;
+    if (attribution?.kind !== 'exec-prompt') return [];
+    const budget = Math.max(10, width - FIELD_PREFIX_LEN);
+    const rows: string[] = [];
+    const pushWrapped = (label: string, text: string): void => {
+      const wrapped = text.split('\n').flatMap((line) => (line.length > 0 ? wrapText(line, budget) : ['']));
+      wrapped.forEach((row, index) => {
+        rows.push(index === 0 ? `   ${label.padEnd(9)}: ${row}` : `${' '.repeat(FIELD_PREFIX_LEN - 1)}${row}`);
+      });
+    };
+    if (typeof attribution.command === 'string' && attribution.command.length > 0) pushWrapped('Running', attribution.command);
+    if (typeof attribution.prompt === 'string' && attribution.prompt.length > 0) pushWrapped('Asks', attribution.prompt);
+    return rows;
+  }
+
+  /** The typed-reply input row text (deny reason / exec answer), or null when no reply mode is active. */
+  private static replyRowText(view: PromptViewState | undefined, width: number): string | null {
+    if (!view?.replyMode) return null;
+    const label = view.replyMode === 'exec-answer' ? 'Answer   ' : 'Reason   ';
+    const draft = view.replyBuffer ?? '';
+    const budget = Math.max(6, width - FIELD_PREFIX_LEN - 1);
+    const shown = draft.length > budget ? `...${draft.slice(-(budget - 3))}` : draft;
+    return `   ${label}: ${shown}█`;
+  }
+
+  /**
+   * Assemble the card's view state from the pending-permission slot and the
+   * broker's live queue (the honest count of OTHER pending asks — coalesced
+   * asks share one record, so they are never double-counted). One helper so
+   * main.ts passes identical state to getPromptHeight and createPromptLines.
+   */
+  static promptViewState(
+    pending: { readonly callId: string; readonly replyMode?: 'deny-reason' | 'exec-answer' | undefined; readonly replyBuffer?: string | undefined },
+    width: number,
+    broker?: { listApprovals(limit?: number): ReadonlyArray<{ readonly callId: string; readonly status: string }> } | null,
+  ): PromptViewState {
+    let queueCount = 0;
+    try {
+      queueCount = broker?.listApprovals().filter((record) => record.status === 'pending' && record.callId !== pending.callId).length ?? 0;
+    } catch {
+      queueCount = 0; // an unreadable broker never blocks the card
+    }
+    return { replyMode: pending.replyMode, replyBuffer: pending.replyBuffer, queueCount, width };
+  }
+
   static getPromptHeight(
     request: PermissionPromptRequest,
     hunkState?: HunkSelectionState,
     detailsExpanded = false,
     requestedBy?: string,
+    view?: PromptViewState,
   ): number {
-    // Attribution line (only when known) + the always-present remember-scope
-    // preview line are added to BOTH card shapes; keep in sync with
-    // createPromptLines. A hunk-selection prompt has no single [A] remember key,
-    // so the preview line is suppressed there (see createPromptLines).
+    const width = view?.width ?? 80;
+    // Attribution line (only when known) + the remember block (tier rows when
+    // the request carries rememberOptions, else the legacy one-line preview)
+    // are added to BOTH card shapes; keep in sync with createPromptLines.
     const attributionLines = requestedBy ? 1 : 0;
-    const previewLines = hunkState ? 0 : 1;
+    const rememberLines = this.rememberRowTexts(request, hunkState, width).length;
     // Condensed low-risk card: top separator, title, [attribution], [preview],
     // summary, choices, bottom separator — see createPromptLines' condensed branch.
-    if (this.isCondensed(request, hunkState, detailsExpanded)) return 5 + attributionLines + previewLines;
+    if (this.isCondensed(request, hunkState, detailsExpanded)) return 5 + attributionLines + rememberLines;
     const analysis = this.fallbackAnalysis(request);
     const { annotation: judgmentAnnotation, rest: reasonsMinusJudgment } = extractModelJudgmentAnnotation(analysis.reasons);
     const reasonLines = Math.min(2, Math.max(1, reasonsMinusJudgment.length));
     const extraLines = (analysis.host ? 1 : 0) + (analysis.surface ? 1 : 0) + (analysis.sideEffects && analysis.sideEffects.length > 0 ? 1 : 0) + (readSandboxAskAnnotation(request) ? 1 : 0) + (judgmentAnnotation ? 1 : 0);
     const hunkLines = hunkState ? hunkListRowCount(hunkState) : 0;
+    // Item-adopted blocks, each computed by the SAME helper createPromptLines
+    // renders from, so the two functions cannot drift: the full wrapped
+    // command (execute), the colored diff (write), the exec-prompt rows, and
+    // the typed-reply input row.
+    const commandLines = this.commandRowTexts(request, width).length;
+    const diffLines = this.writeDiffLines(request, hunkState)?.length ?? 0;
+    const execPromptLines = this.execPromptRowTexts(request, width).length;
+    const replyLines = this.replyRowText(view, width) ? 1 : 0;
     // Base 12 counted a single arg line; the Path field now spans `pathRows`
     // lines and the full card adds one raw-args row (2a reachability), so the
     // arg allotment becomes pathRows + 1 → base 12 + pathRows (12 already
     // included one of those). See createPromptLines' full branch.
     const pathRows = this.pathRowTexts(this.resolvedTargets(request), 999).length;
-    return 12 + pathRows + reasonLines + extraLines + hunkLines + attributionLines + previewLines;
+    return 12 + pathRows + reasonLines + extraLines + hunkLines + attributionLines + rememberLines
+      + commandLines + diffLines + execPromptLines + replyLines;
   }
 
   /** Returns the key argument to display for a given tool invocation. */
@@ -258,6 +429,7 @@ export class PermissionPromptUI {
     hunkState?: HunkSelectionState,
     detailsExpanded = false,
     requestedBy?: string,
+    view?: PromptViewState,
   ): Line[] {
     const lines: Line[] = [];
     const { tool, args, category } = request;
@@ -270,32 +442,40 @@ export class PermissionPromptUI {
     const TEXT   = '252';
     const DIM    = '244';
 
-    // Attribution line (which agent/process is asking) and the remember-scope
-    // preview line ([A] writes exactly this key). Both are shared by the
-    // condensed and full cards; the preview is suppressed for a hunk-selection
-    // prompt, which has no single whole-request [A] remember key.
+    // Honest queue: how many OTHER broker asks are waiting behind this one.
+    // They surface in turn as each is answered; the count keeps that visible.
+    const queueSuffix = view?.queueCount && view.queueCount > 0
+      ? ` — ${view.queueCount} more waiting`
+      : '';
+
+    // Attribution line (which agent/process is asking) and the remember block
+    // (numbered tier rows from the SDK's rememberOptions, or the legacy [A]
+    // session-preview row). Both are shared by the condensed and full cards;
+    // the remember block is suppressed for a hunk-selection prompt, which has
+    // no single whole-request remember key.
     const pushAttribution = (): void => {
       if (!requestedBy) return;
       lines.push(UIFactory.stringToLine(`   Requested by: ${requestedBy}`.padEnd(width), width, { fg: DIM }));
     };
-    const pushRememberPreview = (): void => {
-      if (hunkState) return;
-      lines.push(UIFactory.stringToLine(this.rememberPreviewText(request, width).padEnd(width), width, { fg: DIM }));
+    const pushRememberBlock = (): void => {
+      for (const rowText of this.rememberRowTexts(request, hunkState, width)) {
+        lines.push(UIFactory.stringToLine(rowText.padEnd(width), width, { fg: DIM }));
+      }
     };
 
     const maxArgLen = Math.max(10, width - 16);
     const pathRows = this.pathRowTexts(this.resolvedTargets(request), maxArgLen);
 
     // Condensed low-risk / project-local card: one summary line (verb → target
-    // (scope)) plus the choices. Full block is one `d` away. (UX-B 2b.)
+    // (scope)) plus the choices. Full block is one `d` away. (2b.)
     if (this.isCondensed(request, hunkState, detailsExpanded)) {
       lines.push(UIFactory.stringToLine('─'.repeat(width), width, { fg: ACCENT, dim: true }));
-      lines.push(UIFactory.stringToLine(` [${label}] ${brief.title} `.padEnd(width), width, { fg: WARN, bold: true }));
+      lines.push(UIFactory.stringToLine(` [${label}] ${brief.title}${queueSuffix} `.padEnd(width), width, { fg: WARN, bold: true }));
       pushAttribution();
       const scopeText = analysis.blastRadius ? ` (${analysis.blastRadius})` : '';
       const summaryLine = `   ${categoryVerb(category)} → ${pathRows[0]}${scopeText}`;
       lines.push(UIFactory.stringToLine(summaryLine.padEnd(width), width, { fg: TEXT }));
-      pushRememberPreview();
+      pushRememberBlock();
       lines.push(UIFactory.stringToLine(
         `   [Y] Allow once    [A] Allow always (session)    [N] Deny    [d] details`.padEnd(width),
         width, { fg: ACCENT, bold: true }));
@@ -306,9 +486,9 @@ export class PermissionPromptUI {
     // Top separator
     lines.push(UIFactory.stringToLine('─'.repeat(width), width, { fg: ACCENT, dim: true }));
 
-    // Title bar: category badge + title
+    // Title bar: category badge + title (+ honest waiting count)
     const titleText = brief.title;
-    const titleLine = ` [${label}] ${titleText} `;
+    const titleLine = ` [${label}] ${titleText}${queueSuffix} `;
     lines.push(UIFactory.stringToLine(titleLine.padEnd(width), width, { fg: WARN, bold: true }));
 
     // Requester attribution (which agent/process raised this request).
@@ -320,12 +500,24 @@ export class PermissionPromptUI {
 
     // Path/subject row(s): actual target path(s), one per line when few, a
     // "N files: a, b, +K more" summary when many. Raw args move to the Args row
-    // below so this field never shows a truncated JSON blob. (UX-B 2a.)
+    // below so this field never shows a truncated JSON blob. (2a.)
     pathRows.forEach((rowText, i) => {
       const labelCol = i === 0 ? brief.subjectLabel.padEnd(9) : ' '.repeat(9);
       lines.push(UIFactory.stringToLine(`   ${labelCol}: ${rowText}`.padEnd(width), width, { fg: TEXT }));
     });
 
+    // The FULL command of an execute ask, wrapped — never truncated. The Path
+    // row above stays as the one-line subject; this block is the whole truth.
+    for (const rowText of this.commandRowTexts(request, width)) {
+      lines.push(UIFactory.stringToLine(rowText.padEnd(width), width, { fg: TEXT }));
+    }
+
+    // Exec-prompt attribution: the running command and the terminal prompt it
+    // is stuck on, wrapped in full — the typed answer feeds this run's stdin.
+    for (const rowText of this.execPromptRowTexts(request, width)) {
+      lines.push(UIFactory.stringToLine(rowText.padEnd(width), width, { fg: WARN }));
+    }
+
     // Working directory row
     const cwd = request.workingDirectory ?? '(unknown)';
     const maxCwdLen = Math.max(10, width - 16);
@@ -416,6 +608,13 @@ export class PermissionPromptUI {
     // Blank spacer
     lines.push(UIFactory.stringToLine(' '.repeat(width), width));
 
+    // Real colored diff for a write/edit ask (adds green, removals red, hunk
+    // headers blue — the same diff-view machinery the transcript uses).
+    const diffTextLines = this.writeDiffLines(request, hunkState);
+    if (diffTextLines) {
+      lines.push(...renderDiffView(diffTextLines.join('\n'), width));
+    }
+
     if (hunkState) {
       // Hunk list — see hunkListRowCount() for the row-count contract this
       // block must match exactly (Risk 2: getPromptHeight/createPromptLines
@@ -450,15 +649,31 @@ export class PermissionPromptUI {
       lines.push(UIFactory.stringToLine(trailerLine.padEnd(width), width, { fg: DIM }));
     }
 
-    // Remember-scope preview: exactly what [A] will write (omitted for hunk mode).
-    pushRememberPreview();
+    // Remember block: numbered tier rows (rememberOptions) or the legacy [A]
+    // session preview (omitted for hunk mode).
+    pushRememberBlock();
+
+    // Typed-reply input row: the deny reason (Enter denies with it as
+    // feedback) or the exec-prompt answer (Enter feeds the running command).
+    const replyRow = this.replyRowText(view, width);
+    if (replyRow) {
+      lines.push(UIFactory.stringToLine(replyRow.padEnd(width), width, { fg: TEXT, bold: true }));
+    }
 
     // Choices row. A condensable card shown in full is the expanded form, so it
     // offers `[d]` to collapse back; other full cards omit the details toggle.
     const collapseHint = this.isCondensed(request, hunkState, false) ? '    [d] hide details' : '';
-    const choicesLine = hunkState
-      ? `   [j/k] Navigate  [Space] Toggle  [A] All  [Enter] Apply selected  [N] Deny`
-      : `   [Y] Allow once    [A] Allow always (session)    [N] Deny${collapseHint}`;
+    const tierCount = hunkState ? 0 : (request.rememberOptions?.length ?? 0);
+    const rememberHint = tierCount > 0
+      ? `    [1${tierCount > 1 ? `-${tierCount}` : ''}] Allow + remember`
+      : '    [A] Allow always (session)';
+    const choicesLine = view?.replyMode === 'exec-answer'
+      ? `   [Enter] Send answer    [Esc] ${((view.replyBuffer ?? '').length > 0) ? 'Clear' : 'Decline'}    [Ctrl+C] Abort turn`
+      : view?.replyMode === 'deny-reason'
+        ? `   [Enter] Deny with this reason    [Esc] Back    [Ctrl+C] Abort turn`
+        : hunkState
+          ? `   [j/k] Navigate  [Space] Toggle  [A] All  [Enter] Apply selected  [N] Deny`
+          : `   [Y] Allow once${rememberHint}    [N] Deny    type a reason to deny${collapseHint}`;
     lines.push(UIFactory.stringToLine(choicesLine.padEnd(width), width, { fg: ACCENT, bold: true }));
 
     // Bottom separator