@bahulam/code 2.6.12 → 2.6.14

package/src/ui/input-dock.mjs

@@ -71,8 +71,9 @@ let unsubResize = null;
 // the cursor at the correct input position. Without this, readline echoes
 // land on rows the dock briefly moved through mid-render and characters
 // appear above/below the input row.
-let lastFrame = { context: '', meta: '', tips: '', prefix: '', value: '', cursor: null };
+let lastFrame = { context: '', meta: '', tips: '', prefix: '', value: '', cursor: null, overlayLines: null };
 let resetting = false;
+let lastGeometry = null;
 
 function write(s) { try { OUT.write(s); } catch {} }
 function setScrollRegion(top, bottom) { write(`${ESC}${top};${bottom}r`); }
@@ -90,6 +91,13 @@ function cols() {
   return Math.max(40, term().columns || 80);
 }
 
+function drawableColumns() {
+  // Avoid writing into the final terminal column. Many terminals enter
+  // autowrap state there; during rapid resizes that can push fixed dock
+  // frame lines into scrollback.
+  return Math.max(1, cols() - 1);
+}
+
 function contentBottomRow() {
   return Math.max(1, rows() - reservedRows);
 }
@@ -137,8 +145,8 @@ function computeInputRowsForBuffer(prefix, value) {
 // meta line) which then leaks into the transcript as streamed content
 // scrolls past them. We clear the old dock region BEFORE moving the frame
 // so the freed rows are blank when they enter the scroll region.
-function setInputRowsTo(nextRows) {
-  const clamped = Math.max(MIN_INPUT_ROWS, Math.min(inputRowsMax, Math.floor(nextRows)));
+function setInputRowsTo(nextRows, { maxRows = inputRowsMax } = {}) {
+  const clamped = Math.max(MIN_INPUT_ROWS, Math.min(maxRows, Math.floor(nextRows)));
   if (clamped === inputRows) return false;
   const shrinking = clamped < inputRows;
   if (mounted && shrinking) {
@@ -162,7 +170,7 @@ function setInputRowsTo(nextRows) {
 
 function padLine(text) {
   const value = String(text || '');
-  const pad = Math.max(0, cols() - visibleWidth(value));
+  const pad = Math.max(0, drawableColumns() - visibleWidth(value));
   return value + ' '.repeat(pad);
 }
 
@@ -183,7 +191,7 @@ function ruleChars(count) {
 // - Optional right-aligned context strip (session tokens/elapsed) with rule
 //   fill between label and context
 function topRuleLine(context = '') {
-  const w = Math.max(0, cols() - 1);
+  const w = Math.max(0, drawableColumns());
   const brand = paint.brand.primary;
   const bold = paint.bold;
 
@@ -192,14 +200,19 @@ function topRuleLine(context = '') {
   const label = bold(brand(BRAND_LABEL));
   const leftBlock = `${leadRule} ${accent}${label}`;
   const leftWidth = visibleWidth(leftBlock);
+  const rightPadRule = 2;
 
-  const ctx = fitText(context, Math.max(0, Math.floor(w / 2)));
+  const maxCtxWidth = Math.max(0, Math.min(
+    Math.floor(w / 2),
+    w - leftWidth - 1 /* left gap */ - 1 /* minimum middle */ - 1 /* ctx gap */ - rightPadRule - 1 /* tail gap */,
+  ));
+  const ctx = fitText(context, maxCtxWidth);
   const ctxWidth = ctx ? visibleWidth(ctx) : 0;
 
   // Rule fill in the middle. Reserve 1 space around ctx when present.
-  const gap = 1;
-  const rightPadRule = 2;
-  const middleWidth = Math.max(1, w - leftWidth - gap - ctxWidth - (ctx ? gap + rightPadRule : 0));
+  const middleWidth = ctx
+    ? Math.max(1, w - leftWidth - ctxWidth - rightPadRule - 3)
+    : Math.max(1, w - leftWidth - 1);
   const middleRule = brand(ruleChars(middleWidth));
 
   if (!ctx) {
@@ -210,7 +223,7 @@ function topRuleLine(context = '') {
 }
 
 function bottomRuleLine() {
-  return paint.brand.primary(ruleChars(Math.max(0, cols() - 1)));
+  return paint.brand.primary(ruleChars(Math.max(0, drawableColumns())));
 }
 
 // Always park the cursor at the tracked (prefix, value) input position.
@@ -229,8 +242,11 @@ function parkCursorAtInput() {
   focusDockInput(prefix, value, lastFrame.cursor);
 }
 
-function applyLayout() {
+function applyLayout({ clearPrevious = false } = {}) {
   if (!mounted) return;
+  if (clearPrevious && lastGeometry) {
+    clearDockArea({ restore: true, geometry: lastGeometry });
+  }
   const bottom = contentBottomRow();
   setScrollRegion(1, bottom);
   renderFrame(lastFrame);
@@ -257,6 +273,9 @@ function renderFrame(frame = {}) {
   clearLine();
 
   // (input rows are written by drawInputLines / clearInputRows)
+  if (Array.isArray(lastFrame.overlayLines)) {
+    drawInputLines(lastFrame.overlayLines);
+  }
 
   // Spacer below input.
   moveTo(spacerBelowRow(), 1);
@@ -290,6 +309,20 @@ function renderFrame(frame = {}) {
   // pinned-status writers clobber the outer save and restore to the wrong
   // place. Instead, callers that need the cursor parked at the input row
   // invoke parkCursorAtInput() after renderFrame returns.
+  lastGeometry = {
+    top: topRuleRow(),
+    bottom: rows(),
+  };
+}
+
+function clearDockRows(startRow, endRow) {
+  const maxRow = rows();
+  const start = Math.max(1, Math.min(maxRow, Math.floor(startRow || 1)));
+  const end = Math.max(start, Math.min(maxRow, Math.floor(endRow || maxRow)));
+  for (let row = start; row <= end; row++) {
+    moveTo(row, 1);
+    clearLine();
+  }
 }
 
 function clearInputRows() {
@@ -299,13 +332,10 @@ function clearInputRows() {
   }
 }
 
-export function clearDockArea({ restore = true } = {}) {
+export function clearDockArea({ restore = true, geometry = null } = {}) {
   if (!mounted) return false;
   if (restore) saveCursor();
-  for (let row = topRuleRow(); row <= rows(); row++) {
-    moveTo(row, 1);
-    clearLine();
-  }
+  clearDockRows(geometry?.top || topRuleRow(), geometry?.bottom || rows());
   if (restore) restoreCursor();
   return true;
 }
@@ -329,6 +359,15 @@ function layoutInput(prefix, value) {
   };
 }
 
+function layoutOverlayLines(lines) {
+  const budget = inputTextBudget();
+  const wrapped = [];
+  for (const line of lines) {
+    wrapped.push(...wrapToLines(line, budget));
+  }
+  return wrapped.length ? wrapped : [''];
+}
+
 function drawInputLines(lines) {
   const indent = ' '.repeat(INPUT_INDENT);
   for (let i = 0; i < inputRows; i++) {
@@ -359,7 +398,7 @@ export function mountInputDock({ inputRowsMax: requestedMax } = {}) {
   mounted = true;
   applyLayout();
 
-  unsubResize = onResize(() => applyLayout());
+  unsubResize = onResize(() => applyLayout({ clearPrevious: true }));
   process.once('exit', safeUnmount);
   process.once('SIGTERM', () => { safeUnmount(); process.exit(143); });
   return true;
@@ -377,6 +416,7 @@ export function unmountInputDock() {
   } finally {
     mounted = false;
     resetting = false;
+    lastGeometry = null;
   }
 }
 
@@ -435,7 +475,7 @@ export function prepareInputPrompt({ context = '', tips = '', meta = '' } = {})
   if (!mounted) return false;
   setInputRowsTo(MIN_INPUT_ROWS);
   clearInputRows();
-  renderFrame({ context, tips, meta, prefix: '', value: '' });
+  renderFrame({ context, tips, meta, prefix: '', value: '', overlayLines: null });
   moveTo(inputRowStart(), INPUT_INDENT + 1);
   return true;
 }
@@ -444,6 +484,7 @@ export function clearInputPrompt() {
   if (!mounted) return false;
   clearInputRows();
   lastFrame.value = '';
+  lastFrame.overlayLines = null;
   renderFrame(lastFrame);
   parkCursorAtInput();
   return true;
@@ -452,13 +493,39 @@ export function clearInputPrompt() {
 export function renderDockInput(prefix, value, { context = '', tips = '', meta = '', cursor = null } = {}) {
   if (!mounted) return false;
   setInputRowsTo(computeInputRowsForBuffer(prefix, value));
-  renderFrame({ context, tips, meta, prefix, value, cursor });
+  renderFrame({ context, tips, meta, prefix, value, cursor, overlayLines: null });
   const layout = layoutInput(prefix, value);
   drawInputLines(layout.lines);
   focusDockInput(prefix, value, cursor);
   return true;
 }
 
+export function renderDockOverlay({
+  context = '',
+  lines = [],
+  meta = '',
+  tips = '',
+  maxRows = 8,
+} = {}) {
+  if (!mounted) return false;
+  const sourceLines = Array.isArray(lines) ? lines : String(lines || '').split('\n');
+  const wrapped = layoutOverlayLines(sourceLines);
+  const rowCap = Math.max(MIN_INPUT_ROWS, Math.min(MAX_INPUT_ROWS_CAP, Math.max(inputRowsMax, maxRows)));
+  setInputRowsTo(Math.min(rowCap, Math.max(MIN_INPUT_ROWS, wrapped.length)), { maxRows: rowCap });
+  const tail = tailWithEllipsis(wrapped, inputRows);
+  renderFrame({
+    context,
+    meta,
+    tips,
+    prefix: '',
+    value: '',
+    cursor: null,
+    overlayLines: tail.visible,
+  });
+  moveTo(rows(), 1);
+  return true;
+}
+
 /**
  * Move the terminal cursor to the position that corresponds to
  * `prefix + value[0..cursorInValue]` within the (possibly wrapped and
@@ -499,6 +566,10 @@ export function _internals() {
     reservedRows: () => reservedRows,
     layoutInput,
     inputTextBudget,
+    topRuleLine,
+    bottomRuleLine,
+    padLine,
+    drawableColumns,
     FIXED_ROWS,
     BRAND_LABEL,
   };

package/src/ui/slash-commands.mjs

@@ -45,6 +45,7 @@ export const COMMANDS = {
   '/surgical':    'Verbosity: show everything (reasoning, expanded tools)',
   '/compact':     'Compact conversation context',
   '/agents':      'List available agents',
+  '/run':         'Run a sub-agent or synced workflow',
   '/explore':     'Code explorer agent',
   '/review':      'Code review agent',
   '/architect':   'Feature architect agent',
@@ -137,11 +138,20 @@ export const HELP_GROUPS = [
       ['/agents create <name>', 'Create .bahulam/agents/<name>.yaml'],
       ['/agents edit <name>', 'Open local agent YAML'],
       ['/agents sync [name]', 'Sync all or one local agent to cloud'],
+      ['/run <agent> [instruction]', 'Run a local or built-in agent'],
       ['/explore <instruction>', 'Explore code'],
       ['/review <instruction>', 'Review code'],
       ['/architect <instruction>', 'Design an approach'],
     ],
   },
+  {
+    key: 'workflows',
+    title: 'Workflows',
+    summary: 'saved automations',
+    commands: [
+      ['/run <workflow> [instruction]', 'Run a synced workflow if no agent matches'],
+    ],
+  },
   {
     key: 'session',
     title: 'Session',

package/src/ui/tool-card.mjs

@@ -29,6 +29,7 @@ import {
   toolDisplaySummary,
   formatShellCommand,
   shellCommandDisplay,
+  shellCommandProfile,
 } from '../terminal/tool-display.mjs';
 
 // ── Family → label colorizer ─────────────────────────────────────────────
@@ -50,8 +51,10 @@ function formatArgs(tool, args, cwd) {
   const summary = toolDisplaySummary(tool, args || {}, { cwd });
   if (!summary) return '';
   if (tool === 'shell') {
+    const profile = shellCommandProfile(summary, { cwd });
+    if (profile.compact) return compactShellProfile(profile);
     const display = shellCommandDisplay(summary, { cwd });
-    const command = formatShellCommand(display.command, paintShellAdapter);
+    const command = `${paint.text.dim('$')} ${formatShellCommand(display.command, paintShellAdapter)}`;
     return display.cwdLabel
       ? `${command} ${paint.text.dim('in')} ${paint.brand.data(display.cwdLabel)}`
       : command;
@@ -150,6 +153,10 @@ export function summarizeResult(tool, data) {
       if (exit != null && exit !== 0) {
         return { text: `exit ${exit}`, tone: 'danger' };
       }
+      if (tool === 'shell') {
+        const structured = structuredOutputSummary(data.output_preview || data.output);
+        if (structured) return structured;
+      }
       const head = firstOutputLine(data).slice(0, 100);
       return { text: head || 'ok', tone: 'success' };
     }
@@ -179,6 +186,49 @@ export function summarizeResult(tool, data) {
   }
 }
 
+function structuredOutputSummary(output) {
+  const raw = String(output || '').trim();
+  if (!raw || !/^[\[{]/.test(raw)) return null;
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    const first = raw.split('\n').find(line => /^[\[{]/.test(line.trim()));
+    if (!first) return null;
+    try { value = JSON.parse(first.trim()); } catch { return null; }
+  }
+  return summarizeJsonOutput(value);
+}
+
+function summarizeJsonOutput(value) {
+  if (Array.isArray(value)) {
+    return { text: `json array · ${value.length} item${value.length === 1 ? '' : 's'}`, tone: 'success' };
+  }
+  if (!value || typeof value !== 'object') return null;
+
+  if ('service' in value && 'profile' in value && 'inSync' in value) {
+    const service = String(value.service || 'service');
+    const profile = value.profile ? ` · ${value.profile}` : '';
+    const status = value.inSync === true ? 'in sync'
+      : value.inSync === false ? 'out of sync'
+      : 'sync status unknown';
+    const diffs = Array.isArray(value.diff) ? value.diff
+      : Array.isArray(value.diffs) ? value.diffs
+      : [];
+    const diffText = diffs.length ? ` · ${diffs.length} diff${diffs.length === 1 ? '' : 's'}` : '';
+    return {
+      text: `${service} ${status}${profile}${diffText}`,
+      tone: value.inSync === false ? 'warn' : 'success',
+    };
+  }
+
+  const keys = Object.keys(value).slice(0, 4);
+  return {
+    text: keys.length ? `json · ${keys.join(', ')}` : 'json object',
+    tone: 'success',
+  };
+}
+
 export function formatCompactFileDiff(result, {
   indent = '  ',
   maxLines = 14,
@@ -303,20 +353,30 @@ function tone(text, t) {
 export function formatCardHead(tool, args, opts = {}) {
   const cwd = opts.cwd || safeCwd();
   const cols = opts.columns || term().columns || 120;
-  const indent = opts.indent || '  ';
+  const indent = opts.indent ?? (tool === 'shell' ? '' : '  ');
 
   const label     = toolDisplayLabel(tool);
   const argsText  = formatArgs(tool, args, cwd);
+  const leadText  = formatHeadLead(tool, label);
 
-  const leadVisible = visibleWidth(`${indent}${label}`);
+  const leadVisible = visibleWidth(`${indent}${leadText}`);
   const budget = Math.max(20, cols - leadVisible - 4);
 
+  if (tool === 'shell') {
+    const profile = shellCommandProfile(toolDisplaySummary(tool, args || {}, { cwd }), { cwd });
+    if (profile.compact) {
+      const argsTruncated = truncateMiddle(argsText, budget);
+      const head = `${indent}${leadText}`;
+      return argsTruncated ? `${head} ${argsTruncated}` : head;
+    }
+  }
+
   if (tool === 'shell' && visibleWidth(argsText) > budget) {
     const wrapWidth = Math.max(32, cols - visibleWidth(indent) - 4);
     const display = shellCommandDisplay(toolDisplaySummary(tool, args || {}, { cwd }), { cwd });
     const commandLines = wrapCommand(display.command, wrapWidth)
-      .map(line => `${indent}${paint.text.dim('  ')}${formatShellCommand(line, paintShellAdapter)}`);
-    const head = `${indent}${paintLabel(tool, label)}`;
+      .map((line, index) => `${indent}${paint.text.dim(index === 0 ? '$ ' : '> ')}${formatShellCommand(line, paintShellAdapter)}`);
+    const head = `${indent}${leadText}`;
     const cwdLine = display.cwdLabel
       ? `\n${indent}${paint.text.dim('  in ')}${paint.brand.data(display.cwdLabel)}`
       : '';
@@ -325,10 +385,22 @@ export function formatCardHead(tool, args, opts = {}) {
 
   const argsTruncated = truncateMiddle(argsText, budget);
 
-  const head = `${indent}${paintLabel(tool, label)}`;
+  const head = `${indent}${leadText}`;
   return argsTruncated ? `${head} ${argsTruncated}` : head;
 }
 
+function formatHeadLead(tool, label) {
+  if (tool !== 'shell') return paintLabel(tool, label);
+  return `${paint.text.dim('• shell ·')} ${paintLabel(tool, label)}`;
+}
+
+function compactShellProfile(profile) {
+  const parts = [`${paint.text.dim('$')} ${paint.text.primary(profile.summary)}`];
+  if (profile.cwdLabel) parts.push(`${paint.text.dim('in')} ${paint.brand.data(profile.cwdLabel)}`);
+  parts.push(paint.text.dim(profile.detailHint || 'details: F2 or /last'));
+  return parts.join(' · ');
+}
+
 /**
  * Render a full card with outcome.
  *
@@ -346,7 +418,7 @@ export function formatCard({ tool, args, result, durationMs, indent, columns, cw
 
   if (!summary.text && !duration) return head;
 
-  const arrow = paint.text.dim('—');
+  const arrow = outcomeLead(tool);
   const body  = summary.text ? tone(summary.text, summary.tone) : '';
   // Hide the duration tail when the tool was effectively instant (<200ms).
   // For fast reads, "1ms" / "0ms" was noise that broke the prose feel.
@@ -374,6 +446,19 @@ export function formatCard({ tool, args, result, durationMs, indent, columns, cw
   return `${head}\n${gutterIndent}${arrow} ${body}${tail}`;
 }
 
+function outcomeLead(tool) {
+  return isShellOutcomeTool(tool)
+    ? `${paint.text.dim('result')} ${paint.text.dim('—')}`
+    : paint.text.dim('—');
+}
+
+function isShellOutcomeTool(tool) {
+  return [
+    'shell', 'run_tests', 'validate_build', 'lint_check',
+    'validate_file', 'validate_structure',
+  ].includes(String(tool || '').toLowerCase());
+}
+
 function isInlineOutcomeTool(tool) {
   return [
     'read_file', 'read_files', 'read_batch', 'get_file_info',
@@ -397,22 +482,25 @@ function wrapCommand(command, width) {
   const text = String(command || '');
   if (!text) return ['(empty command)'];
   const lines = [];
-  let line = '';
-  for (const token of text.match(/\S+\s*/g) || [text]) {
-    const next = line + token;
-    if (line && visibleWidth(next.trimEnd()) > width) {
-      lines.push(line.trimEnd());
-      line = token;
-      continue;
-    }
-    if (!line && visibleWidth(token.trimEnd()) > width) {
-      lines.push(...chunkLongToken(token.trimEnd(), width));
-      line = '';
-      continue;
+  for (const physicalLine of text.replace(/\r\n?/g, '\n').split('\n')) {
+    let line = '';
+    for (const token of physicalLine.match(/\S+\s*/g) || [physicalLine]) {
+      const next = line + token;
+      if (line && visibleWidth(next.trimEnd()) > width) {
+        lines.push(line.trimEnd());
+        line = token;
+        continue;
+      }
+      if (!line && visibleWidth(token.trimEnd()) > width) {
+        lines.push(...chunkLongToken(token.trimEnd(), width));
+        line = '';
+        continue;
+      }
+      line = next;
     }
-    line = next;
+    if (line.trimEnd()) lines.push(line.trimEnd());
+    else if (!physicalLine.trim()) lines.push('');
   }
-  if (line.trimEnd()) lines.push(line.trimEnd());
   return lines.length ? lines : ['(empty command)'];
 }
 

package/src/ui/tool-details.mjs

@@ -13,9 +13,10 @@
 
 import { paint } from './palette.mjs';
 import { icon, toolFamily } from './icons.mjs';
-import { toolDisplayLabel } from '../terminal/tool-display.mjs';
+import { shellCommandProfile, toolDisplayLabel, toolDisplaySummary } from '../terminal/tool-display.mjs';
 
 const MAX_DETAIL_LINES = 60;
+const MAX_SHELL_DETAIL_LINES = 220;
 const MAX_LINE_WIDTH = 220;
 
 // ── Dispatch ─────────────────────────────────────────────────────────────
@@ -49,6 +50,10 @@ function renderBody(card) {
     case 'validate_file':
     case 'validate_structure': return detailValidator(card);
     case 'plan':            return detailPlan(card);
+    case 'Agent':
+    case 'agent':
+    case 'task':            return detailAgent(card);
+    case 'sub_agent_tools': return detailSubAgentTools(card);
     case 'explore':
     case 'verify':
     case 'debug':
@@ -96,6 +101,13 @@ function oneLineArgs(tool, args) {
 }
 
 function safeDetailArgs(tool, args) {
+  if (tool === 'shell') {
+    const profile = shellCommandProfile(args?.command || args?.cmd || '');
+    return {
+      command: profile.summary,
+      ...(profile.cwdLabel ? { cwd: profile.cwdLabel } : {}),
+    };
+  }
   if (tool === 'write_file') {
     const { content, ...rest } = args || {};
     return {
@@ -112,6 +124,16 @@ function safeDetailArgs(tool, args) {
       })),
     };
   }
+  if (tool === 'Agent' || tool === 'agent' || tool === 'task') {
+    const prompt = args?.prompt || args?.task || args?.query || args?.description || args?.instruction || '';
+    return {
+      ...(args?.subagent_type ? { subagent_type: args.subagent_type } : {}),
+      ...(args?.agent ? { agent: args.agent } : {}),
+      ...(args?.name ? { name: args.name } : {}),
+      ...(Array.isArray(args?.allowed_tools) ? { allowed_tools: args.allowed_tools } : {}),
+      ...(prompt ? { prompt: `[${String(prompt).split('\n').length} lines] ${String(prompt).split('\n').find(Boolean)?.slice(0, 80) || ''}` } : {}),
+    };
+  }
   if (tool === 'edit_file') {
     const next = { ...args };
     for (const key of ['search', 'replace', 'old_string', 'new_string']) {
@@ -235,17 +257,37 @@ function detailDeleteFile(card) {
 // ── Shell / validators ──────────────────────────────────────────────────
 
 function detailShell(card) {
+  const command = String(card.args?.command || card.args?.cmd || '').trim();
   const stdout = String(card.result?.stdout ?? card.result?.output ?? '');
   const stderr = String(card.result?.stderr ?? '');
   const out = [];
+  if (command) {
+    const profile = shellCommandProfile(command);
+    if (profile.cwdLabel) {
+      out.push(paint.text.dim('    cwd'));
+      out.push(`    ${paint.brand.data(profile.cwdLabel)}`);
+      out.push('');
+    }
+
+    out.push(paint.text.dim('    command'));
+    if (profile.script?.body) {
+      out.push(`    ${paint.text.primary(profile.script.invocation || profile.command.split('\n')[0] || profile.command)}`);
+      out.push('');
+      out.push(paint.text.dim('    script'));
+      out.push(numbered(profile.script.body, 1, { maxLines: MAX_SHELL_DETAIL_LINES }));
+    } else {
+      out.push(clip(profile.command, paint.text.primary, { maxLines: MAX_SHELL_DETAIL_LINES }));
+    }
+  }
   if (stdout) {
+    if (out.length) out.push('');
     out.push(paint.text.dim('    stdout'));
-    out.push(clip(stdout));
+    out.push(clip(stdout, paint.text.primary, { maxLines: MAX_DETAIL_LINES }));
   }
   if (stderr) {
     if (out.length) out.push('');
     out.push(paint.state.warn('    stderr'));
-    out.push(clip(stderr, paint.state.danger));
+    out.push(clip(stderr, paint.state.danger, { maxLines: MAX_DETAIL_LINES }));
   }
   return out.length ? out.join('\n') : paint.text.dim('    (no output)');
 }
@@ -267,6 +309,56 @@ function detailPlan(card) {
   }).join('\n');
 }
 
+function detailAgent(card) {
+  const args = card.args || {};
+  const prompt = args.prompt || args.task || args.query || args.description || args.instruction || '';
+  const out = [];
+  const meta = [
+    args.subagent_type ? `type ${args.subagent_type}` : '',
+    args.agent || args.name || '',
+    Array.isArray(args.allowed_tools) && args.allowed_tools.length
+      ? `${args.allowed_tools.length} allowed tools`
+      : '',
+  ].filter(Boolean).join(' · ');
+  if (meta) out.push(`    ${paint.text.dim(meta)}`);
+  if (prompt) {
+    out.push(paint.text.dim('    prompt'));
+    out.push(clip(prompt, paint.text.primary, { maxLines: MAX_DETAIL_LINES }));
+  }
+  const result = String(card.result?.output ?? card.result?.output_preview ?? '');
+  if (result) {
+    if (out.length) out.push('');
+    out.push(paint.text.dim('    result'));
+    out.push(clip(result));
+  }
+  return out.length ? out.join('\n') : detailGenericOutput(card);
+}
+
+function detailSubAgentTools(card) {
+  const entries = Array.isArray(card.result?.tools) ? card.result.tools : [];
+  if (!entries.length) return paint.text.dim('    (no folded tool calls)');
+
+  const out = [];
+  entries.forEach((entry, index) => {
+    const tool = entry.tool || 'tool';
+    const args = entry.args || {};
+    const summary = entry.summary || toolDisplaySummary(tool, args);
+    const outcome = entry.outcome ? ` ${paint.text.dim('—')} ${paint.text.muted(entry.outcome)}` : '';
+    const duration = entry.durationMs != null ? ` ${paint.text.dim('· ' + formatDuration(entry.durationMs))}` : '';
+    out.push(`    ${paint.text.dim(`${index + 1}.`)} ${icon(tool)} ${toolDisplayLabel(tool)}${summary ? ` ${paint.text.muted(summary)}` : ''}${outcome}${duration}`);
+
+    const child = {
+      tool,
+      args,
+      result: entry.result || null,
+      durationMs: entry.durationMs ?? null,
+    };
+    const detail = renderBody(child);
+    if (detail) out.push(indentBlock(detail, '      '));
+  });
+  return out.join('\n');
+}
+
 function detailGenericOutput(card) {
   const out = String(card.result?.output ?? card.result?.output_preview ?? '');
   return clip(out);
@@ -274,28 +366,35 @@ function detailGenericOutput(card) {
 
 // ── Helpers ─────────────────────────────────────────────────────────────
 
-function numbered(text, start) {
+function numbered(text, start, { maxLines = MAX_DETAIL_LINES } = {}) {
   const lines = String(text).split('\n');
   const total = lines.length;
   const width = String(start + total - 1).length;
-  return lines.slice(0, MAX_DETAIL_LINES).map((line, i) => {
+  return lines.slice(0, maxLines).map((line, i) => {
     const n = String(start + i).padStart(width);
     return `    ${paint.text.dim(n)} ${paint.text.primary(line.slice(0, MAX_LINE_WIDTH))}`;
-  }).join('\n') + (total > MAX_DETAIL_LINES
-    ? `\n    ${paint.text.dim(`… ${total - MAX_DETAIL_LINES} more line(s)`)}`
+  }).join('\n') + (total > maxLines
+    ? `\n    ${paint.text.dim(`… ${total - maxLines} more line(s)`)}`
     : '');
 }
 
-function clip(text, painter = paint.text.primary) {
+function clip(text, painter = paint.text.primary, { maxLines = MAX_DETAIL_LINES } = {}) {
   if (!text) return paint.text.dim('    (empty)');
   const lines = String(text).split('\n');
-  const head = lines.slice(0, MAX_DETAIL_LINES).map(l => `    ${painter(l.slice(0, MAX_LINE_WIDTH))}`);
-  if (lines.length > MAX_DETAIL_LINES) {
-    head.push(`    ${paint.text.dim(`… ${lines.length - MAX_DETAIL_LINES} more line(s)`)}`);
+  const head = lines.slice(0, maxLines).map(l => `    ${painter(l.slice(0, MAX_LINE_WIDTH))}`);
+  if (lines.length > maxLines) {
+    head.push(`    ${paint.text.dim(`… ${lines.length - maxLines} more line(s)`)}`);
   }
   return head.join('\n');
 }
 
+function indentBlock(text, prefix) {
+  return String(text || '')
+    .split('\n')
+    .map(line => `${prefix}${line.trimStart()}`)
+    .join('\n');
+}
+
 function renderDiff(text) {
   return text.split('\n').slice(0, MAX_DETAIL_LINES).map(line => {
     if (line.startsWith('+++') || line.startsWith('---')) return `    ${paint.bold(paint.text.muted(line))}`;