@bahulam/code 2.6.12 → 2.6.14

package/src/terminal/repl.mjs

@@ -35,6 +35,7 @@ import { renderMissionReport, saveReport, toMarkdown as missionMarkdown } from '
 import {
   getVerbosity,
   setVerbosity,
+  showSubAgentTools,
   label as verbosityLabel,
   MODES as V_MODES,
 } from '../state/verbosity.mjs';
@@ -44,7 +45,7 @@ import { ApprovalManager } from '../core/approval.mjs';
 import { resolveBackendUrl } from '../core/backend-url.mjs';
 import { formatMessageWindow, lowWindowStatus, messagesRemaining } from '../core/rate-limit-display.mjs';
 import { formatAgentErrorGuidance } from '../core/error-guidance.mjs';
-import { BUILTIN_AGENTS, runAgent } from './agents.mjs';
+import { BUILTIN_AGENTS, findBuiltinAgent, localAgentMatches, runAgent, runAgentDefinition } from './agents.mjs';
 import { createAgentFile, isVsCodeTerminal, listLocalAgents, openAgentFile, syncAgentsToBackend } from '../agents/scaffold.mjs';
 import { SessionManager } from '../core/session-manager.mjs';
 import { parseArgs } from '../config/cli-args.mjs';
@@ -134,6 +135,7 @@ import {
 } from '../ui/slash-commands.mjs';
 import { createOrbit } from '../state/orbit.mjs';
 import {
+  clearPinnedStatus,
   clearInputPrompt,
   focusDockInput,
   isInputDockMounted,
@@ -258,7 +260,7 @@ function renderHelp(topic = '') {
 function renderKeyboardHelp() {
   process.stderr.write(`\n  ${c.bold('Keyboard')}\n`);
   process.stderr.write(`  ${c.gray('Ctrl+C')}  exit   ${c.gray('↑↓')}  history   ${c.gray('Tab')}  autocomplete\n`);
-  process.stderr.write(`  ${c.gray('Ctrl+D')}  expand last tool   ${c.gray('Space')}  pause/resume   ${c.gray('Esc')}  interrupt\n\n`);
+  process.stderr.write(`  ${c.gray('F2')}      expand last tool   ${c.gray('Space')}  pause/resume   ${c.gray('Esc')}  interrupt\n\n`);
 }
 
 const MODEL_ROLE_ALIASES = new Map([
@@ -849,6 +851,164 @@ function updateStatusBar() {
 
 // ── Event Renderer ──
 
+function isDeniedStatusMessage(message = '') {
+  return /^(?:Denied\s+\S+|Blocked by safety policy)\b/i.test(String(message || '').trim());
+}
+
+function toolCallId(data = {}, tool = 'tool') {
+  return data.call_id || data._callId || data.request_id || data.id ||
+    `${tool}:${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function isSubAgentToolEvent(data = {}) {
+  return Boolean(data?.internal || data?.sub_agent);
+}
+
+function shouldFoldSubAgentTool(data = {}) {
+  return isSubAgentToolEvent(data) && !showSubAgentTools(getVerbosity());
+}
+
+function foldedSubAgentName(data = {}) {
+  return data?.sub_agent || data?.agent || data?.type || 'sub-agent';
+}
+
+function ensureFoldedSubAgentTools(agentType) {
+  const current = runtime.foldedSubAgentTools;
+  if (current && current.agentType === agentType) return current;
+  if (current?.entries?.length) flushFoldedSubAgentTools();
+  runtime.foldedSubAgentTools = {
+    agentType,
+    entries: [],
+    startedAt: Date.now(),
+  };
+  return runtime.foldedSubAgentTools;
+}
+
+function findFoldedToolEntry(fold, callId, tool) {
+  if (!fold) return null;
+  if (callId) {
+    const exact = fold.entries.find(entry => entry.callId === callId);
+    if (exact) return exact;
+  }
+  for (let i = fold.entries.length - 1; i >= 0; i--) {
+    const entry = fold.entries[i];
+    if (entry.tool === tool && !entry.result) return entry;
+  }
+  return null;
+}
+
+function foldSubAgentToolCall(data = {}) {
+  const tool = data?.tool || 'unknown';
+  const args = data?.args || {};
+  const callId = toolCallId(data, tool);
+  const agentType = foldedSubAgentName(data);
+  const fold = ensureFoldedSubAgentTools(agentType);
+  const existing = findFoldedToolEntry(fold, callId, tool);
+  const entry = existing || {
+    callId,
+    tool,
+    args,
+    summary: toolDisplaySummary(tool, args, { cwd: safeCwd() }),
+    startedAt: Date.now(),
+    result: null,
+    durationMs: null,
+    outcome: '',
+    tone: 'dim',
+  };
+  if (!existing) fold.entries.push(entry);
+  recordCard({ id: callId, tool, args, startedAt: entry.startedAt });
+  session.toolCounts[tool] = (session.toolCounts[tool] || 0) + 1;
+  startSpinner(`${agentType} → ${tool}`);
+}
+
+function foldSubAgentToolResult(data = {}) {
+  const tool = data?.tool || data?._tool || 'unknown';
+  const args = data?.args || {};
+  const callId = toolCallId(data, tool);
+  const agentType = foldedSubAgentName(data);
+  const fold = ensureFoldedSubAgentTools(agentType);
+  let entry = findFoldedToolEntry(fold, callId, tool);
+  if (!entry) {
+    entry = {
+      callId,
+      tool,
+      args,
+      summary: toolDisplaySummary(tool, args, { cwd: safeCwd() }),
+      startedAt: Date.now(),
+      result: null,
+      durationMs: null,
+      outcome: '',
+      tone: 'dim',
+    };
+    fold.entries.push(entry);
+  }
+  const durationMs = data?.duration_ms ?? (data?.duration_s != null ? data.duration_s * 1000 : null);
+  const summary = summarizeResult(tool, data);
+  entry.args = entry.args && Object.keys(entry.args).length ? entry.args : args;
+  entry.result = data;
+  entry.durationMs = durationMs;
+  entry.outcome = summary.text || '';
+  entry.tone = summary.tone || 'dim';
+  if (data._blocked) session.blockedOps++;
+  recordCard({ id: callId, tool, args: entry.args, result: data, durationMs, startedAt: entry.startedAt });
+}
+
+function foldedOutcome(entry) {
+  if (!entry?.outcome) return '';
+  const painter = entry.tone === 'success' ? paint.state.success
+                : entry.tone === 'warn'    ? paint.state.warn
+                : entry.tone === 'danger'  ? paint.state.danger
+                                          : paint.text.muted;
+  return `${paint.text.dim('—')} ${painter(entry.outcome)}`;
+}
+
+function foldedToolLine(entry, indent, columns) {
+  const head = formatCardHead(entry.tool, entry.args || {}, {
+    cwd: safeCwd(),
+    columns: Math.max(40, columns - indent.length - 2),
+    indent: '',
+  }).split('\n')[0];
+  const line = `${indent}${paint.text.dim('•')} ${head}${entry.outcome ? `  ${foldedOutcome(entry)}` : ''}`;
+  return fitAnsiLine(line, Math.max(32, columns));
+}
+
+function flushFoldedSubAgentTools() {
+  const fold = runtime.foldedSubAgentTools;
+  if (!fold) return;
+  const entries = Array.isArray(fold.entries) ? fold.entries : [];
+  runtime.foldedSubAgentTools = null;
+  if (!entries.length) return;
+
+  renderBlockBoundary('tool', { compactSame: true });
+  const indent = subAgentIndent();
+  const cols = process.stderr.columns || 120;
+  const shown = entries.slice(0, 4);
+  const extra = Math.max(0, entries.length - shown.length);
+  const header = `${indent}${paint.text.dim('⎿')} ${paint.text.dim(`${fold.agentType} tools · ${entries.length} tool use${entries.length === 1 ? '' : 's'}`)}`;
+  process.stderr.write(`${fitAnsiLine(header, cols)}\n`);
+  for (const entry of shown) {
+    process.stderr.write(`${foldedToolLine(entry, `${indent}  `, cols)}\n`);
+  }
+  if (extra > 0) {
+    process.stderr.write(`${indent}  ${paint.text.dim(`… +${extra} tool use${extra === 1 ? '' : 's'} · /last expands this batch`)}\n`);
+  } else {
+    process.stderr.write(`${indent}  ${paint.text.dim('/last expands this batch')}\n`);
+  }
+  recordCard({
+    id: `sub-agent-tools:${fold.agentType}:${Date.now()}`,
+    tool: 'sub_agent_tools',
+    args: { agent: fold.agentType, total: entries.length },
+    result: {
+      success: true,
+      output: `${entries.length} folded sub-agent tool use${entries.length === 1 ? '' : 's'}`,
+      tools: entries,
+    },
+    durationMs: Date.now() - (fold.startedAt || Date.now()),
+    startedAt: fold.startedAt || Date.now(),
+  });
+  runtime.lastRenderedBlock = 'tool';
+}
+
 function renderEvent(event) {
   const { type, data } = event;
 
@@ -890,6 +1050,10 @@ function renderEvent(event) {
         renderStagnation(data);
         break;
       }
+      if (isDeniedStatusMessage(msg)) {
+        stopSpinner();
+        break;
+      }
       startSpinner(msg);
       break;
     }
@@ -927,6 +1091,7 @@ function renderEvent(event) {
       if (text) {
         flushContent();
         stopSpinner();
+        flushFoldedSubAgentTools();
         if (runtime.streamedPartialText && text.startsWith(runtime.streamedPartialText)) {
           text = text.slice(runtime.streamedPartialText.length);
         } else if (runtime.streamedPartialText.includes(text)) {
@@ -1009,6 +1174,10 @@ function renderEvent(event) {
       session.totalToolCalls++;
       stopSpinner();
       flushContent();
+      if (shouldFoldSubAgentTool(data)) {
+        foldSubAgentToolCall(data);
+        break;
+      }
       renderToolCall(data);
       break;
     }
@@ -1039,6 +1208,7 @@ function renderEvent(event) {
     }
 
     case 'approval_denied': {
+      stopSpinner();
       const reason = data?.reason || 'User denied';
       const toolName = data?.tool || '';
       const indent = subAgentIndent();
@@ -1051,6 +1221,10 @@ function renderEvent(event) {
     case 'tool_result':
     case 'tool_done': {
       stopSpinner();
+      if (shouldFoldSubAgentTool(data)) {
+        foldSubAgentToolResult(data);
+        break;
+      }
       renderToolResult(data, type);
       break;
     }
@@ -1153,6 +1327,7 @@ function renderEvent(event) {
     case 'sub_agent_start': {
       stopSpinner();
       clearPendingHead();
+      flushFoldedSubAgentTools();
       const agentType = data?.type || 'sub-agent';
       const query = data?.query || '';
       renderBlockBoundary('subagent');
@@ -1182,6 +1357,7 @@ function renderEvent(event) {
     case 'sub_agent_complete': {
       stopSpinner();
       clearPendingHead();
+      flushFoldedSubAgentTools();
       const agentType = data?.type || 'sub-agent';
       const usage = data?.usage || {};
       const tokens = (usage.input_tokens || 0) + (usage.output_tokens || 0);
@@ -1250,6 +1426,7 @@ function renderEvent(event) {
     case 'error':
       stopSpinner();
       flushContent();
+      flushFoldedSubAgentTools();
       {
         const guidance = formatAgentErrorGuidance(data || {});
         renderBlockBoundary('status', { compactSame: true });
@@ -1291,6 +1468,7 @@ function renderEvent(event) {
     case 'complete': {
       stopSpinner();
       flushContent();
+      flushFoldedSubAgentTools();
       resetSubAgents();
       session.inSubAgent = false;
 
@@ -1649,6 +1827,111 @@ function handleTasksCommand(rest, ctx) {
   }
 }
 
+async function prepareDirectAgentRunContext(ctx, instruction = '') {
+  const cwd = safeCwd();
+  const registered = await ctx.toolExecutor.registerProjectRoots([cwd]);
+  const failed = registered.find(result => result?.success === false);
+  if (failed) {
+    throw new Error(`Could not register project root for sub-agent: ${failed.error || failed.root || cwd}`);
+  }
+
+  const effectivePolicy = loadEffectivePolicy({ cwd });
+  if (ctx.approval) {
+    ctx.approval.policy = effectivePolicy.policy;
+    if (ctx.approval.trustStore) ctx.approval.trustStore.policy = effectivePolicy.policy;
+  }
+  const projectContext = loadProjectContext({ cwd, previous: ctx.latestProjectContext || null });
+  const projectResources = ctx.toolExecutor.getProjectResources();
+  const envelope = buildContextEnvelope({
+    cwd,
+    effectivePolicy,
+    projectContext,
+    activeHints: [],
+    projectResources,
+    agentContext: ctx.toolExecutor.getAgentContext(),
+  });
+
+  ctx.effectivePolicy = effectivePolicy;
+  ctx.latestProjectContext = projectContext;
+  ctx.latestEnvelope = envelope;
+
+  const execContext = {
+    ...envelope,
+    cwd,
+    project_root: cwd,
+    project_resources: projectResources,
+    work_scope: buildWorkScope({
+      instruction: instruction || 'Run sub-agent task',
+      cwd,
+      projectResources,
+    }),
+  };
+  const modelOverrides = Object.fromEntries(sessionModelOverrideEntries());
+  if (Object.keys(modelOverrides).length > 0) {
+    execContext.model_overrides = modelOverrides;
+    if (modelOverrides.reasoning) execContext.model_override = modelOverrides.reasoning;
+  }
+  return execContext;
+}
+
+async function handleRunCommand(rest = '', ctx) {
+  const parts = String(rest || '').trim().split(/\s+/).filter(Boolean);
+  const target = parts.shift();
+  const instruction = parts.join(' ');
+
+  if (!target) {
+    process.stderr.write(`  ${c.gray('Usage: /run <agent-or-workflow> [instruction]')}\n`);
+    return;
+  }
+
+  const localAgent = listLocalAgents(safeCwd()).find(agent => localAgentMatches(agent, target));
+  const builtinAgent = findBuiltinAgent(target);
+  const runnableAgent = localAgent || builtinAgent;
+  if (runnableAgent) {
+    try {
+      const execContext = await prepareDirectAgentRunContext(ctx, instruction || target);
+      return await runAgentDefinition(runnableAgent, instruction, ctx, session, renderEvent, {
+        cwd: execContext.cwd,
+        execContext,
+      });
+    } catch (err) {
+      process.stderr.write(`  ${c.red('✗')} ${err.message || String(err)}\n`);
+      return;
+    }
+  }
+
+  try {
+    process.stderr.write(`  ${c.dim(`Running workflow '${target}'...`)}\n`);
+    const result = await ctx.toolExecutor.execute('workflow_run_multi', {
+      name: target,
+      instruction,
+    });
+
+    if (result?.success === false) {
+      process.stderr.write(`  ${c.red('✗')} ${result.output || `Workflow '${target}' failed.`}\n`);
+      return;
+    }
+
+    process.stderr.write(`  ${c.green('✓')} ${c.dim(`Workflow '${target}' complete`)}\n`);
+    const details = [];
+    if (result?.run_id) details.push(`run ${result.run_id}`);
+    if (result?.duration_s) details.push(`${result.duration_s}s`);
+    if (result?.total_tokens) details.push(`${formatTokens(result.total_tokens)} tok`);
+    if (result?.total_cost) details.push(formatCostValue(result.total_cost));
+    if (details.length) process.stderr.write(`  ${c.dim(details.join(' · '))}\n`);
+
+    const output = result?.result || result?.output || '';
+    if (output) {
+      process.stderr.write('\n');
+      process.stderr.write(renderMarkdown(String(output), { width: process.stderr.columns || 96 }));
+      process.stderr.write('\n');
+    }
+  } catch (err) {
+    process.stderr.write(`  ${c.red('✗')} ${err.message || String(err)}\n`);
+    process.stderr.write(`  ${c.gray('Usage: /run <agent-or-workflow> [instruction]')}\n`);
+  }
+}
+
 async function handleCommand(input, ctx) {
   const { cmd, rest, aliasTarget } = normalizeCommandInput(input);
   if (aliasTarget) {
@@ -1686,6 +1969,10 @@ async function handleCommand(input, ctx) {
       handleTasksCommand(rest, ctx);
       return;
 
+    case '/run':
+      await handleRunCommand(rest, ctx);
+      return;
+
     case '/attach':
       handleAttachCommand(rest, ctx);
       return;
@@ -2182,6 +2469,7 @@ async function handleCommand(input, ctx) {
       session.agentHistory.length = 0;
       session.toolCalls = 0;
       session.subAgentToolCalls = 0;
+      runtime.foldedSubAgentTools = null;
       clearCards();
       process.stderr.write(`  ${c.gray('Conversation cleared.')}\n`);
       return;
@@ -2501,6 +2789,7 @@ export async function startTerminalRepl() {
     flushContent();
     flushPendingHead();
     flushCompactReadRun();
+    runtime.foldedSubAgentTools = null;
     clearCards();
 
     const preserved = {
@@ -2877,11 +3166,17 @@ export async function startTerminalRepl() {
   // terminals that ignore the request.
   const PASTE_BEGIN = '\x1b[200~';
   const PASTE_END   = '\x1b[201~';
+  const F2_SEQUENCES = new Set(['\x1bOQ', '\x1b[12~']);
   let _inBracketedPaste = false;
   let _bracketedPasteBuffer = '';
+  let _suppressBracketedPasteLines = false;
+  let _bracketedPasteStartLine = '';
+  let _bracketedPasteStartCursor = 0;
+  let _promptHasInsertedPaste = false;
   const _pasteEndListeners = new Set();
   function onBracketedPasteEnd(cb) { _pasteEndListeners.add(cb); return () => _pasteEndListeners.delete(cb); }
   function isInBracketedPaste() { return _inBracketedPaste; }
+  function isF2Sequence(text) { return F2_SEQUENCES.has(String(text || '')); }
 
   if (process.stdin.isTTY) {
     try { process.stderr.write('\x1b[?2004h'); } catch {}
@@ -2900,6 +3195,11 @@ export async function startTerminalRepl() {
           if (start === -1) return;
           _inBracketedPaste = true;
           _bracketedPasteBuffer = '';
+          _suppressBracketedPasteLines = true;
+          _bracketedPasteStartLine = String(rl?.line || '');
+          _bracketedPasteStartCursor = typeof rl?.cursor === 'number'
+            ? rl.cursor
+            : _bracketedPasteStartLine.length;
           i = start + PASTE_BEGIN.length;
         } else {
           const end = s.indexOf(PASTE_END, i);
@@ -2914,7 +3214,10 @@ export async function startTerminalRepl() {
           // Notify subscribers on next tick so readline finishes emitting its
           // synchronous `line` events for the buffered content first.
           const cbs = [..._pasteEndListeners];
-          setImmediate(() => { for (const cb of cbs) { try { cb(payload); } catch {} } });
+          setImmediate(() => {
+            for (const cb of cbs) { try { cb(payload); } catch {} }
+            _suppressBracketedPasteLines = false;
+          });
           i = end + PASTE_END.length;
         }
       }
@@ -2937,8 +3240,10 @@ export async function startTerminalRepl() {
 
   function printInputBottomRule() {
     if (isInputDockMounted()) {
+      clearPinnedStatus();
       clearInputPrompt();
       moveToContent();
+      if (process.stderr.isTTY && !term().plain) process.stderr.write('\r\x1b[2K');
       return;
     }
     if (term().plain) return;
@@ -2946,11 +3251,11 @@ export async function startTerminalRepl() {
   }
 
   function idleInputTips() {
-    return '[Enter] send  [/] commands  [Tab] complete  [Ctrl+D] details';
+    return '[Enter] send  [/] commands  [Tab] complete  [F2] details';
   }
 
   function executionInputTips() {
-    return 'type any extra context (paths, corrections, follow-ups) · [Enter] send · [Esc] cancel · [Ctrl+P] pause';
+    return 'type extra context · [Enter] send · [Esc] cancel · [Ctrl+P] pause · [F2] details';
   }
 
   // Proxy stream: swallows writes when the dock owns the input row so
@@ -3088,10 +3393,10 @@ export async function startTerminalRepl() {
     slashHintLine = '';
   }
 
-  function replaceReadlineLine(value) {
+  function replaceReadlineLine(value, cursor = null) {
     const next = String(value || '');
     rl.line = next;
-    rl.cursor = next.length;
+    rl.cursor = cursor == null ? next.length : Math.max(0, Math.min(next.length, Number(cursor) || 0));
     if (typeof rl._refreshLine === 'function') {
       rl._refreshLine();
     } else {
@@ -3101,6 +3406,17 @@ export async function startTerminalRepl() {
     }
   }
 
+  function insertPromptText(text, { baseLine = rl.line || '', baseCursor = rl.cursor, fromPaste = false } = {}) {
+    const payload = String(text || '');
+    if (!payload) return;
+    const line = String(baseLine || '');
+    const cursor = typeof baseCursor === 'number' ? Math.max(0, Math.min(line.length, baseCursor)) : line.length;
+    const next = `${line.slice(0, cursor)}${payload}${line.slice(cursor)}`;
+    if (fromPaste) _promptHasInsertedPaste = true;
+    replaceReadlineLine(next, cursor + payload.length);
+    renderIdleDockInput();
+  }
+
   function acceptSlashHint() {
     const item = slashHintItems[slashHintSelected];
     if (!item) return false;
@@ -3190,8 +3506,18 @@ export async function startTerminalRepl() {
     readline.emitKeypressEvents(process.stdin, rl);
     process.stdin.on('keypress', (_str, key = {}) => {
       if (!inputActive) return;
+      if (_inBracketedPaste || _suppressBracketedPasteLines) return;
+      if (key.name === 'return' || key.name === 'enter') return;
+      if (key.name === 'f2') {
+        clearSlashHint();
+        if (isInputDockMounted()) moveToContent();
+        expandLast();
+        renderIdleDockInput();
+        return;
+      }
       setImmediate(() => {
         if (!inputActive) return;
+        if (_inBracketedPaste || _suppressBracketedPasteLines) return;
         if (slashHintVisible && key.name === 'tab' && acceptSlashHint()) return;
         if (slashHintVisible && key.name === 'down' && moveSlashHintSelection(1)) return;
         if (slashHintVisible && key.name === 'up' && moveSlashHintSelection(-1)) return;
@@ -3247,8 +3573,18 @@ export async function startTerminalRepl() {
       _pasteFlushTimer = null;
     }
     if (!_pasteLines.length) return;
-    const line = _pasteLines.join('\n');
+    const trailing = String(rl.line || '');
+    const pastedLines = _pasteLines.slice();
     _pasteLines = [];
+    if (pastedLines.length > 1 || trailing) {
+      const text = [...pastedLines, trailing].join('\n');
+      _promptHasInsertedPaste = true;
+      replaceReadlineLine(text);
+      renderIdleDockInput();
+      return;
+    }
+    const line = pastedLines.join('\n');
+    _promptHasInsertedPaste = false;
     queueOrRunLine(line);
   }
 
@@ -3258,8 +3594,29 @@ export async function startTerminalRepl() {
   // or the user pressed Enter normally), the debounce falls back to old
   // behavior — a single Enter flushes almost instantly.
   rl.on('line', async (line) => {
+    if (_suppressBracketedPasteLines) {
+      _pasteLines = [];
+      if (_pasteFlushTimer) {
+        clearTimeout(_pasteFlushTimer);
+        _pasteFlushTimer = null;
+      }
+      return;
+    }
+    if (!inputActive) {
+      _pasteLines = [];
+      if (_pasteFlushTimer) {
+        clearTimeout(_pasteFlushTimer);
+        _pasteFlushTimer = null;
+      }
+      return;
+    }
+    const submitInsertedPaste = _promptHasInsertedPaste || String(line || '').includes('\n');
     _pasteLines.push(line);
     if (_pasteFlushTimer) clearTimeout(_pasteFlushTimer);
+    if (submitInsertedPaste) {
+      flushPastedLines();
+      return;
+    }
     if (isInBracketedPaste()) {
       _pasteFlushTimer = null;
     } else {
@@ -3267,10 +3624,19 @@ export async function startTerminalRepl() {
     }
   });
 
-  onBracketedPasteEnd(() => {
-    // Readline has finished emitting synchronous line events for the pasted
-    // content by the time this fires (setImmediate in the pre-listener).
-    flushPastedLines();
+  onBracketedPasteEnd((payload) => {
+    _pasteLines = [];
+    if (_pasteFlushTimer) {
+      clearTimeout(_pasteFlushTimer);
+      _pasteFlushTimer = null;
+    }
+    // Readline has finished emitting synchronous `line` events by now.
+    // Treat paste as editing the prompt buffer; Enter remains the submit.
+    insertPromptText(payload || '', {
+      baseLine: _bracketedPasteStartLine,
+      baseCursor: _bracketedPasteStartCursor,
+      fromPaste: true,
+    });
   });
 
   async function _handleLine(line) {
@@ -3637,6 +4003,14 @@ export async function startTerminalRepl() {
         const bytes2 = [...data];
         const text2 = data.toString('utf8');
 
+        if (isF2Sequence(text2)) {
+          stopSpinner();
+          if (isInputDockMounted()) moveToContent();
+          expandLast();
+          if (isInputDockMounted()) redrawExecutionInput();
+          return;
+        }
+
         // Esc key (single byte 0x1b, not part of arrow sequence)
         if (bytes2.length === 1 && bytes2[0] === 0x1b) {
           if (executionInputVisible || executionInputBuffer) {
@@ -3729,15 +4103,6 @@ export async function startTerminalRepl() {
           return;
         }
 
-        // Ctrl+D — expand last tool card (Mission Control §6.2). Only when
-        // there's no in-progress follow-up input.
-        if (!executionInputBuffer && bytes2.length === 1 && bytes2[0] === 0x04) {
-          stopSpinner();
-          if (isInputDockMounted()) moveToContent();
-          expandLast();
-          return;
-        }
-
         // Any safe text (unicode, tabs, spaces, symbols) becomes a live
         // follow-up instruction. Enter sends it via resume(instruction).
         if (isSafeFollowUpText(text2)) {
@@ -3752,6 +4117,15 @@ export async function startTerminalRepl() {
       approval.setExecutionHooks({
         onPause: () => { execListenerActive = false; },
         onResume: () => { execListenerActive = true; },
+        onApprovalPromptEnd: () => {
+          if (!isInputDockMounted()) return;
+          renderDockInput(executionInputPrefix(), executionInputBuffer, {
+            context: buildContextStrip(),
+            meta: buildDockMeta(),
+            tips: executionInputTips(),
+          });
+          moveToContent();
+        },
       });
 
       keypressCleanup = () => {