@pellux/goodvibes-tui 1.7.0 → 1.9.0

package/src/panels/modals/planning-modal.ts

@@ -20,16 +20,19 @@ import { buildAnswerActions, isGenericRecommendation, type PlanningAnswerAction
 // ---------------------------------------------------------------------------
 // Project Planning → 'planning' config-modal surface (W6.1 group-B port). Shows
 // readiness/questions/decisions/task-graph/handoff — read-only except choosing
-// and submitting an answer to the current open question, approving execution,
-// or refreshing. Submit/approve route to the `/plan` command.
+// an answer to the current open question, approving execution, dismissing the
+// plan, or refreshing.
 //
-// KNOWN GAP (flagged in the report): `/plan` has no subcommand that answers the
-// CURRENT open question. The live app calls a submitPlanningAnswer callback that
-// feeds the answer through the normal chat prompt — the action context has no
-// such seam. Lacking a slash-command equivalent, submit routes the chosen answer
-// text through `/plan <answer text>` (the free-form branch, which RESEEDS the
-// goal rather than resolving the specific question) — a known-imprecise
-// stand-in, surfaced honestly in an in-modal note.
+// DEBT-3 — the seams are now real:
+//   - A CANNED answer to a real open question dispatches `/plan answer <id> <text>`
+//     (records it; the open-question gap clears on the next refine).
+//   - The CUSTOM free-form typed answer (and any answer to a synthetic readiness
+//     question with no open-question record) is submitted to chat via the generic
+//     `submitInput` seam — a real model turn. ORDERING GUARD: the modal closes
+//     BEFORE the turn starts (a turn under a live modal is the modal-liveness
+//     hazard). No more `/plan <text>` reseed approximation.
+//   - Dismiss is a first-class CONFIRMED action (`d`) dispatching `/plan dismiss`,
+//     plus the plain Esc close (planning unchanged).
 // ---------------------------------------------------------------------------
 
 export type PlanningModalService = Pick<ProjectPlanningService, 'status' | 'getState' | 'listDecisions' | 'getLanguage' | 'evaluate'>;
@@ -134,6 +137,7 @@ class PlanningModalSurface implements ConfigModalSurface {
   readonly actions = [
     { key: 'enter', id: 'submit', label: 'submit', enabledFor: () => this.currentAnswerActions().actions.length > 0 },
     { key: 'a', id: 'approve', label: 'approve execution' },
+    { key: 'd', id: 'dismiss', label: 'dismiss planning', confirm: true },
     { key: 'r', id: 'refresh', label: 'refresh' },
   ];
 
@@ -199,7 +203,7 @@ class PlanningModalSurface implements ConfigModalSurface {
       for (const action of actions) {
         rows.push({ id: action.id, label: `${action.label} - ${action.detail}`, ...(action.disabled ? { selectable: false } : {}) });
       }
-      line({ content: 'Note: submit reseeds the plan goal via /plan <text> (no per-question answer command exists yet).', fg: undefined });
+      line({ content: 'Enter records a canned answer against this question; the custom row submits your typed text to chat.', fg: undefined });
     }
 
     for (const l of buildGapsLines(evaluation)) line(l);
@@ -209,31 +213,49 @@ class PlanningModalSurface implements ConfigModalSurface {
 
     return {
       title: 'Planning',
-      tabs: [{ id: 'planning', label: 'Planning', header, rows, hints: [...(question ? ['enter submit'] : []), 'a approve execution'] }],
+      tabs: [{ id: 'planning', label: 'Planning', header, rows }],
     };
   }
 
   onAction(id: string, ctx: ConfigModalActionContext): void {
     if (id === 'refresh') { this.refresh(); ctx.setStatus('Reloading project planning state…'); return; }
     if (id === 'approve') { void ctx.executeCommand?.('plan', ['approve']); ctx.setStatus('Dispatched /plan approve.'); return; }
+    if (id === 'dismiss') {
+      // First-class, confirmed (host two-press) mutating dismiss.
+      void ctx.executeCommand?.('plan', ['dismiss']);
+      ctx.setStatus('Dispatched /plan dismiss.');
+      ctx.close();
+      return;
+    }
     if (id !== 'submit') return;
     const { question, actions } = this.currentAnswerActions();
     if (!question || actions.length === 0) return;
     const action = ctx.row ? actions.find((a) => a.id === ctx.row!.id) : undefined;
-    if (!action || action.disabled || !action.answer.trim()) { ctx.print('Choose a non-empty answer option.'); return; }
+    if (!action || action.disabled) { ctx.print('Choose an answer option.'); return; }
     if (action.kind === 'approve') { void ctx.executeCommand?.('plan', ['approve']); ctx.setStatus('Dispatched /plan approve.'); return; }
-    if (action.kind === 'dismiss') {
-      // There is NO `/plan dismiss` subcommand. Dispatching it fell through to
-      // planning-runtime's free-form goal-seed branch and OVERWROTE the project
-      // goal with the literal string "dismiss". Do not dispatch and do not
-      // mutate any state — print an honest note and close the panel. Planning
-      // is untouched (matching the relabeled "Close (planning unchanged)" row).
-      ctx.print('Pausing project planning isn\'t available as a command yet; planning state left unchanged. Closing the panel.');
+
+    const answerText = action.answer.trim();
+    if (!answerText) { ctx.print('Choose a non-empty answer, or type an answer for the custom row.'); return; }
+
+    // A canned answer to a REAL open question records structurally via /plan answer.
+    const isOpenQuestion = this.snapshot?.state?.openQuestions.some(
+      (q) => q.id === question.id && (q.status ?? 'open') === 'open',
+    ) ?? false;
+    if (action.id !== 'custom' && isOpenQuestion) {
+      void ctx.executeCommand?.('plan', ['answer', question.id, ...answerText.split(/\s+/)]);
+      ctx.setStatus('Dispatched /plan answer for the current question.');
+      return;
+    }
+
+    // Free-form (custom typed) answer, or an answer to a synthetic readiness
+    // question with no open-question record → submit to chat as a real turn.
+    // ORDERING GUARD: close the modal BEFORE the turn starts (modal-liveness).
+    if (ctx.submitInput) {
       ctx.close();
+      ctx.submitInput(answerText);
       return;
     }
-    void ctx.executeCommand?.('plan', action.answer.trim().split(/\s+/));
-    ctx.setStatus(`Dispatched /plan ${action.answer.trim()} (reseeds the goal — see the in-modal note).`);
+    ctx.print('Submitting to chat is unavailable in this runtime; answer left unsent.');
   }
 }
 

package/src/panels/modals/work-plan-modal.ts

@@ -64,6 +64,16 @@ class WorkPlanModalSurface implements ConfigModalSurface {
 
   private readonly hasRow = (row: ConfigModalRow | null): boolean => row !== null;
 
+  /** 'i'/'w' jump to the selected item's linked agent/WRFC chain in Fleet
+   *  (DEBT-5 item 4 — restores the retired WorkPlanPanel's per-item deep-link,
+   *  lost when W6.1 migrated this surface to a modal without it). Gated on
+   *  the link actually being present, same as the retired panel gated the key
+   *  on `item?.linked?.agentId`/`wrfcId` before ever reaching the jump. */
+  private readonly hasAgentLink = (row: ConfigModalRow | null): boolean =>
+    !!(row && this.itemFrom(row.id)?.linked?.agentId);
+  private readonly hasWrfcLink = (row: ConfigModalRow | null): boolean =>
+    !!(row && this.itemFrom(row.id)?.linked?.wrfcId);
+
   readonly actions = [
     { key: 'enter', id: 'cycleStatus', label: 'cycle status', enabledFor: this.hasRow },
     { key: '1', id: 'setPending', label: 'pending', enabledFor: this.hasRow },
@@ -75,6 +85,8 @@ class WorkPlanModalSurface implements ConfigModalSurface {
     { key: 'd', id: 'remove', label: 'delete', enabledFor: this.hasRow },
     { key: 'c', id: 'clearCompleted', label: 'clear done' },
     { key: 'a', id: 'add', label: 'add' },
+    { key: 'i', id: 'jumpAgent', label: 'jump agent', enabledFor: this.hasAgentLink },
+    { key: 'w', id: 'jumpWrfc', label: 'jump wrfc', enabledFor: this.hasWrfcLink },
     { key: 'r', id: 'refresh', label: 'refresh' },
   ];
 
@@ -122,6 +134,22 @@ class WorkPlanModalSurface implements ConfigModalSurface {
     if (!item) return;
     if (id === 'cycleStatus') { void ctx.executeCommand?.('work-plan', ['cycle', item.id]); ctx.setStatus(`Dispatched /work-plan cycle ${item.id}.`); return; }
     if (id === 'remove') { void ctx.executeCommand?.('work-plan', ['remove', item.id]); ctx.setStatus(`Dispatched /work-plan remove ${item.id}.`); return; }
+    if (id === 'jumpAgent') {
+      const agentId = item.linked?.agentId;
+      if (!agentId) return;
+      // 'agent' matches the SDK's ProcessKind for a live agent node — see
+      // FleetPanel.receiveDeepLink's id+kind match.
+      void ctx.executeCommand?.('panel', ['open', 'fleet', '--target', `${agentId}:agent`]);
+      ctx.setStatus(`Opened Fleet on agent ${agentId}.`);
+      return;
+    }
+    if (id === 'jumpWrfc') {
+      const wrfcId = item.linked?.wrfcId;
+      if (!wrfcId) return;
+      void ctx.executeCommand?.('panel', ['open', 'fleet', '--target', `${wrfcId}:wrfc-chain`]);
+      ctx.setStatus(`Opened Fleet on WRFC chain ${wrfcId}.`);
+      return;
+    }
     const status: WorkPlanItemStatus | null =
       id === 'setPending' ? 'pending' : id === 'setInProgress' ? 'in_progress' : id === 'setBlocked' ? 'blocked'
       : id === 'setDone' ? 'done' : id === 'setFailed' ? 'failed' : id === 'setCancelled' ? 'cancelled' : null;

package/src/panels/panel-manager.ts

@@ -2,7 +2,8 @@
 // PanelManager — central manager for panel lifecycle, navigation, and split
 // ---------------------------------------------------------------------------
 
-import type { Panel, PanelRegistration, PanelCategory } from './types.ts';
+import type { Panel, PanelRegistration, PanelCategory, PanelDeepLinkTarget } from './types.ts';
+export type { PanelDeepLinkTarget } from './types.ts';
 // Type-only, erased at runtime, routed through the `@/` alias (not a relative
 // path) so it stays out of the relative-import graph the architecture
 // cycle-checker walks — same discipline as the PanelManager import in types.ts.
@@ -228,7 +229,7 @@ export class PanelManager {
     this._cachedWorkspaceTabs = null;
   }
 
-  open(panelIdOrAlias: string, pane?: 'top' | 'bottom'): Panel {
+  open(panelIdOrAlias: string, pane?: 'top' | 'bottom', target?: PanelDeepLinkTarget): Panel {
     const modalName = this.modalRedirects.get(panelIdOrAlias);
     if (modalName !== undefined) {
       this.openModalCallback?.(modalName);
@@ -244,12 +245,12 @@ export class PanelManager {
       // pane (fixes `/panel open <id> top` and the panel-list T/B move keys).
       if (pane && pane !== existingPane) {
         this._moveBetweenPanes(existingPane, pane, panelId);
-        return this.getPanel(panelId)!;
+        return this._deliverDeepLink(this.getPanel(panelId)!, target);
       }
       this._activateByIdInPane(panelId, existingPane);
       this._focusedPane = existingPane;
       if (existingPane === 'bottom') this._bottomPaneVisible = true;
-      return this._getPane(existingPane).panels[this._getPane(existingPane).activeIndex]!;
+      return this._deliverDeepLink(this._getPane(existingPane).panels[this._getPane(existingPane).activeIndex]!, target);
     }
 
     const targetPane = pane ?? this._focusedPane;
@@ -271,6 +272,16 @@ export class PanelManager {
     }
     panel.onActivate();
     this._invalidateWorkspaceTabs();
+    return this._deliverDeepLink(panel, target);
+  }
+
+  /**
+   * Hand an optional deep-link target (DEBT-5 item 4) to a panel that just
+   * resolved from open(). Panels without a "node" concept simply don't
+   * implement `receiveDeepLink` — the call is a no-op via optional chaining.
+   */
+  private _deliverDeepLink(panel: Panel, target: PanelDeepLinkTarget | undefined): Panel {
+    if (target) panel.receiveDeepLink?.(target);
     return panel;
   }
 

package/src/panels/polish-core.ts

@@ -1,12 +1,7 @@
 import type { Line } from '../types/grid.ts';
 import { createEmptyLine, createStyledCell } from '../types/grid.ts';
 import { getDisplayWidth } from '../utils/terminal-width.ts';
-import { resolveUiTones } from '../renderer/theme.ts';
-
-// DEFAULT_PANEL_PALETTE is built from the mode-resolved chrome tones
-// (resolveUiTones) rather than the static UI_TONES constant — WO-001 single
-// read path. Mode is fixed to 'dark' until the terminal-bg-probe lands.
-const UI_TONES = resolveUiTones('dark');
+import { activeUiTones, registerThemeRefresh } from '../renderer/theme.ts';
 
 // ---------------------------------------------------------------------------
 // Panel palette + core line primitives.
@@ -36,24 +31,36 @@ export interface PanelPalette {
   readonly selectBg?: string;
 }
 
-export const DEFAULT_PANEL_PALETTE: Readonly<Required<PanelPalette>> = {
-  header: UI_TONES.fg.primary,
-  headerBg: UI_TONES.bg.title,
-  label: UI_TONES.fg.muted,
-  value: UI_TONES.fg.primary,
-  dim: UI_TONES.fg.dim,
-  info: UI_TONES.state.info,
-  good: UI_TONES.state.good,
-  warn: UI_TONES.state.warn,
-  bad: UI_TONES.state.bad,
-  empty: UI_TONES.fg.empty,
-  surfaceBg: UI_TONES.bg.surface,
-  sectionBg: UI_TONES.bg.section,
-  summaryBg: UI_TONES.bg.summary,
-  inputBg: UI_TONES.bg.input,
-  accent: UI_TONES.fg.secondary,
-  selectBg: UI_TONES.bg.selected,
-} as const;
+// Built from the mode-resolved chrome tones (activeUiTones). Because 100+ call
+// sites read this object by reference, mode changes rebuild it IN PLACE via the
+// registered refresher below rather than re-resolving per call — see theme.ts's
+// active-mode runtime note. This refresher is registered before any panel's
+// extendPalette() runs (panels import polish → polish-core first), so on a mode
+// flip the base is rebuilt before the extended palettes re-merge from it.
+function buildPanelPalette(): Required<PanelPalette> {
+  const t = activeUiTones();
+  return {
+    header: t.fg.primary,
+    headerBg: t.bg.title,
+    label: t.fg.muted,
+    value: t.fg.primary,
+    dim: t.fg.dim,
+    info: t.state.info,
+    good: t.state.good,
+    warn: t.state.warn,
+    bad: t.state.bad,
+    empty: t.fg.empty,
+    surfaceBg: t.bg.surface,
+    sectionBg: t.bg.section,
+    summaryBg: t.bg.summary,
+    inputBg: t.bg.input,
+    accent: t.fg.secondary,
+    selectBg: t.bg.selected,
+  };
+}
+
+export const DEFAULT_PANEL_PALETTE: Readonly<Required<PanelPalette>> = buildPanelPalette();
+registerThemeRefresh(() => Object.assign(DEFAULT_PANEL_PALETTE as Required<PanelPalette>, buildPanelPalette()));
 
 /**
  * Extend the base panel palette with domain-specific colors.
@@ -73,7 +80,13 @@ export function extendPalette<T extends Record<string, string>>(
   base: typeof DEFAULT_PANEL_PALETTE,
   extras: T,
 ): typeof DEFAULT_PANEL_PALETTE & T {
-  return { ...base, ...extras };
+  const merged = { ...base, ...extras } as typeof DEFAULT_PANEL_PALETTE & T;
+  // Self-register an in-place rebuild so every extendPalette-derived panel
+  // palette (cost/token/git/skills/diff/wrfc) tracks the active mode with zero
+  // per-panel churn. Runs AFTER the base refresher (registered at module eval,
+  // before any panel calls this), so `base` already carries the new-mode values.
+  registerThemeRefresh(() => Object.assign(merged as Record<string, string>, base, extras));
+  return merged;
 }
 
 export function buildPanelLine(

package/src/panels/project-planning-answer-actions.ts

@@ -13,7 +13,7 @@ export interface PlanningAnswerAction {
   readonly label: string;
   readonly detail: string;
   readonly answer: string;
-  readonly kind?: 'answer' | 'approve' | 'dismiss';
+  readonly kind?: 'answer' | 'approve';
   readonly disabled?: boolean;
 }
 
@@ -35,8 +35,12 @@ function compactAnswerDetail(text: string): string {
  * canned suggestions first (de-duplicated by normalized answer text — a
  * question that matches more than one keyword category, e.g. scope +
  * recommendedAnswer echoing one of the scope answers verbatim, must not show
- * the same suggested answer twice), then the fixed ask-narrower/custom/
- * dismiss actions.
+ * the same suggested answer twice), then the fixed ask-narrower/custom actions.
+ *
+ * DEBT-3: dismissing planning is no longer a pseudo answer-row — it is a
+ * first-class confirmed modal action (the `d` key), so no dismiss row is
+ * produced here. A canned answer records against the current open question via
+ * /plan answer; the custom row's free-form text is submitted to chat.
  */
 export function buildAnswerActions(question: ProjectPlanningQuestion, draftAnswer: string): PlanningAnswerAction[] {
   const canned: PlanningAnswerAction[] = [];
@@ -119,18 +123,9 @@ export function buildAnswerActions(question: ProjectPlanningQuestion, draftAnswe
   actions.push({
     id: 'custom',
     label: 'Submit typed answer',
-    detail: draftAnswer ? compactAnswerDetail(draftAnswer) : 'Type an answer first; this row becomes the custom answer.',
+    detail: draftAnswer ? compactAnswerDetail(draftAnswer) : 'Type an answer first; this row submits it to chat.',
     answer: draftAnswer.trim(),
     disabled: !draftAnswer.trim(),
   });
-  actions.push({
-    id: 'dismiss-planning',
-    // Honest label: there is no /plan subcommand that pauses planning, so this
-    // row only closes the panel — it does NOT change any planning state.
-    label: 'Close (planning unchanged)',
-    detail: 'Close this panel. Pausing project planning is not available as a command yet, so planning state is left unchanged; /plan reopens it later.',
-    answer: 'Pause project planning for this workspace and continue without the planning panel.',
-    kind: 'dismiss',
-  });
   return actions;
 }

package/src/panels/types.ts

@@ -16,6 +16,18 @@ export interface PanelIntegrationContext {
   readonly executeCommand?: (name: string, args: string[]) => Promise<unknown>;
 }
 
+/**
+ * A cross-panel deep-link target (DEBT-5 item 4): a specific node a panel
+ * should select + reveal when opened via `PanelManager.open(id, pane, target)`,
+ * e.g. a Fleet tree node keyed by its process id and (optionally) its
+ * ProcessKind for disambiguation. Panel-agnostic on purpose — only panels that
+ * have a "node" concept implement `Panel.receiveDeepLink`.
+ */
+export interface PanelDeepLinkTarget {
+  readonly id: string;
+  readonly kind?: string;
+}
+
 /**
  * Named logical key identifiers emitted by the input tokenizer.
  * These are the ONLY key names that will appear in `handleInput` calls;
@@ -139,6 +151,18 @@ export interface Panel {
    * to intervene before the global shortcut acts.
    */
   interceptPanelClose?(): boolean;
+
+  /**
+   * Optional: consume a deep-link target handed in by `PanelManager.open(id,
+   * pane, target)` (DEBT-5 item 4) — select + reveal the matching node on the
+   * panel's next snapshot. A panel without a "node" concept simply doesn't
+   * implement this (the call is a no-op via optional chaining in
+   * PanelManager). A panel that DOES implement it owns its own honest
+   * "not found" surface (e.g. FleetPanel.setError) when the target no longer
+   * resolves — PanelManager has no transcript/print seam to report on its
+   * behalf.
+   */
+  receiveDeepLink?(target: PanelDeepLinkTarget): void;
 }
 
 export interface PanelRegistration extends Pick<Panel, 'id' | 'name' | 'icon' | 'category'> {

package/src/permissions/prompt.ts

@@ -12,6 +12,72 @@ 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). */
+const MAX_PATH_ROWS = 3;
+
+/** Trailing filename for compact display of a long/absolute path. */
+function baseName(p: string): string {
+  const cleaned = p.replace(/[/\\]+$/, '');
+  const idx = Math.max(cleaned.lastIndexOf('/'), cleaned.lastIndexOf('\\'));
+  return idx >= 0 ? cleaned.slice(idx + 1) : cleaned;
+}
+
+/** Make an absolute path relative to the working directory when it sits under it. */
+function relativize(p: string, cwd?: string): string {
+  if (!cwd || !p.startsWith('/')) return p;
+  if (p === cwd) return '.';
+  const prefix = cwd.endsWith('/') ? cwd : `${cwd}/`;
+  return p.startsWith(prefix) ? p.slice(prefix.length) : p;
+}
+
+/** Collect string elements or `el[field]` strings from an array arg. */
+function collectField(arr: unknown, field: string): string[] {
+  if (!Array.isArray(arr)) return [];
+  const out: string[] = [];
+  for (const el of arr) {
+    if (typeof el === 'string') out.push(el);
+    else if (el && typeof el === 'object' && typeof (el as Record<string, unknown>)[field] === 'string') {
+      out.push((el as Record<string, unknown>)[field] as string);
+    }
+  }
+  return out;
+}
+
+/**
+ * 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.)
+ * Returns [] when nothing recognisable is present (caller falls back).
+ */
+function cardTargets(args: Record<string, unknown>): string[] {
+  const files = collectField(args.files, 'path');
+  if (files.length) return files;
+  if (typeof args.path === 'string') return [args.path];
+  if (typeof args.file === 'string') return [args.file];
+  const commands = collectField(args.commands, 'cmd');
+  if (commands.length) return commands;
+  if (typeof args.command === 'string') return [args.command];
+  if (typeof args.cmd === 'string') return [args.cmd];
+  if (typeof args.pattern === 'string') return [args.pattern];
+  const urls = collectField(args.urls, 'url');
+  if (urls.length) return urls;
+  const queries = collectField(args.queries, 'query');
+  if (queries.length) return queries;
+  if (typeof args.query === 'string') return [args.query];
+  if (typeof args.task === 'string') return [args.task];
+  return [];
+}
+
+/** Short human verb for a permission category, for the condensed summary line. */
+function categoryVerb(category: PermissionCategory): string {
+  switch (category) {
+    case 'write':    return 'write';
+    case 'execute':  return 'run';
+    case 'delegate': return 'delegate';
+    default:         return 'read';
+  }
+}
+
 /**
  * Single source of truth for how many Line rows the hunk-list section
  * occupies: 1 header row + up to MAX_VISIBLE_HUNKS checkbox rows + 1 trailer
@@ -49,12 +115,62 @@ export class PermissionPromptUI {
     };
   }
 
-  static getPromptHeight(request: PermissionPromptRequest, hunkState?: HunkSelectionState): number {
+  /** The relativised display target(s) for the Path field, with a raw fallback. */
+  private static resolvedTargets(request: PermissionPromptRequest): string[] {
+    const cwd = request.workingDirectory;
+    const targets = cardTargets(request.args).map((t) => relativize(t, cwd));
+    return targets.length > 0 ? targets : [getDisplayArg(request.tool, request.args)];
+  }
+
+  /** Path-field row texts — one per target when few, a "N files:" summary when many. */
+  private static pathRowTexts(targets: string[], maxLen: number): string[] {
+    const clamp = (s: string): string => (s.length > maxLen ? `...${s.slice(-(maxLen - 3))}` : s);
+    if (targets.length <= 1) return [clamp(targets[0] ?? '(unknown)')];
+    if (targets.length <= MAX_PATH_ROWS) return targets.map(clamp);
+    const shown = targets.slice(0, 2).map(baseName).join(', ');
+    return [clamp(`${targets.length} files: ${shown}, +${targets.length - 2} more`)];
+  }
+
+  /**
+   * 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.)
+   */
+  private static isCondensed(
+    request: PermissionPromptRequest,
+    hunkState: HunkSelectionState | undefined,
+    detailsExpanded: boolean,
+  ): boolean {
+    if (hunkState || detailsExpanded) return false;
+    // 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.)
+    if (request.category === 'execute' || request.category === 'delegate') return false;
+    const analysis = this.fallbackAnalysis(request);
+    if (analysis.riskLevel !== 'low') return false;
+    const scope = analysis.blastRadius;
+    return scope === undefined || scope === 'local' || scope === 'project';
+  }
+
+  static getPromptHeight(
+    request: PermissionPromptRequest,
+    hunkState?: HunkSelectionState,
+    detailsExpanded = false,
+  ): number {
+    // Condensed low-risk card: top separator, title, summary, choices, bottom
+    // separator — see createPromptLines' condensed branch (must stay in sync).
+    if (this.isCondensed(request, hunkState, detailsExpanded)) return 5;
     const analysis = this.fallbackAnalysis(request);
     const reasonLines = Math.min(2, Math.max(1, analysis.reasons.length));
     const extraLines = (analysis.host ? 1 : 0) + (analysis.surface ? 1 : 0) + (analysis.sideEffects && analysis.sideEffects.length > 0 ? 1 : 0);
     const hunkLines = hunkState ? hunkListRowCount(hunkState) : 0;
-    return 12 + reasonLines + extraLines + hunkLines;
+    // 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;
   }
 
   /** Returns the key argument to display for a given tool invocation. */
@@ -84,12 +200,16 @@ export class PermissionPromptUI {
    * createPromptLines - Renders the permission prompt as an array of Lines.
    * Injected into the viewport by the render function when a request is pending.
    */
-  static createPromptLines(width: number, request: PermissionRequest, hunkState?: HunkSelectionState): Line[] {
+  static createPromptLines(
+    width: number,
+    request: PermissionRequest,
+    hunkState?: HunkSelectionState,
+    detailsExpanded = false,
+  ): Line[] {
     const lines: Line[] = [];
     const { tool, args, category } = request;
     const analysis = this.fallbackAnalysis(request);
     const brief = buildPermissionApprovalBrief(request);
-    const displayArg = this.getDisplayArg(tool, args);
     const { label, color } = this.getCategoryLabel(category);
 
     const ACCENT = '135'; // purple
@@ -97,6 +217,24 @@ export class PermissionPromptUI {
     const TEXT   = '252';
     const DIM    = '244';
 
+    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.)
+    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 }));
+      const scopeText = analysis.blastRadius ? ` (${analysis.blastRadius})` : '';
+      const summaryLine = `   ${categoryVerb(category)} → ${pathRows[0]}${scopeText}`;
+      lines.push(UIFactory.stringToLine(summaryLine.padEnd(width), width, { fg: TEXT }));
+      lines.push(UIFactory.stringToLine(
+        `   [Y] Allow once    [A] Allow always (session)    [N] Deny    [d] details`.padEnd(width),
+        width, { fg: ACCENT, bold: true }));
+      lines.push(UIFactory.stringToLine('─'.repeat(width), width, { fg: ACCENT, dim: true }));
+      return lines;
+    }
+
     // Top separator
     lines.push(UIFactory.stringToLine('─'.repeat(width), width, { fg: ACCENT, dim: true }));
 
@@ -109,13 +247,13 @@ export class PermissionPromptUI {
     const toolLine = `   Tool      : ${tool}`;
     lines.push(UIFactory.stringToLine(toolLine.padEnd(width), width, { fg: TEXT }));
 
-    // Key argument row - truncate if too long
-    const maxArgLen = Math.max(10, width - 16);
-    const truncatedArg = displayArg.length > maxArgLen
-      ? '...' + displayArg.slice(-(maxArgLen - 3))
-      : displayArg;
-    const argLine = `   ${brief.subjectLabel.padEnd(9)}: ${truncatedArg}`;
-    lines.push(UIFactory.stringToLine(argLine.padEnd(width), width, { fg: TEXT }));
+    // 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.)
+    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 }));
+    });
 
     // Working directory row
     const cwd = request.workingDirectory ?? '(unknown)';
@@ -170,6 +308,13 @@ export class PermissionPromptUI {
     const checklistLine = `   Checklist : ${truncatedChecklist}`;
     lines.push(UIFactory.stringToLine(checklistLine.padEnd(width), width, { fg: DIM }));
 
+    // Raw args row — the full tool arguments live here in the details view so
+    // the Path field above can render clean path(s), never a JSON blob. (2a.)
+    const rawArgs = JSON.stringify(args);
+    const maxRawLen = Math.max(10, width - 16);
+    const truncatedRaw = rawArgs.length > maxRawLen ? `${rawArgs.slice(0, maxRawLen - 3)}...` : rawArgs;
+    lines.push(UIFactory.stringToLine(`   Args      : ${truncatedRaw}`.padEnd(width), width, { fg: DIM }));
+
     // Blank spacer
     lines.push(UIFactory.stringToLine(' '.repeat(width), width));
 
@@ -207,10 +352,12 @@ export class PermissionPromptUI {
       lines.push(UIFactory.stringToLine(trailerLine.padEnd(width), width, { fg: DIM }));
     }
 
-    // Choices row
+    // 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`;
+      : `   [Y] Allow once    [A] Allow always (session)    [N] Deny${collapseHint}`;
     lines.push(UIFactory.stringToLine(choicesLine.padEnd(width), width, { fg: ACCENT, bold: true }));
 
     // Bottom separator