@bahulam/code 2.6.13 → 2.6.15

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';
@@ -83,12 +84,14 @@ import {
   isInlineOutcomeTool,
   renderBlockBoundary,
   renderExploreRun,
+  renderFileDiffEvent,
   renderStagnation,
   renderToolCall,
   renderToolResult,
   startContentStream,
   startSpinner,
   stopSpinner,
+  transcriptRenderableLines,
   thinkingPrefix,
   updateSpinner,
 } from './repl-render.mjs';
@@ -134,6 +137,7 @@ import {
 } from '../ui/slash-commands.mjs';
 import { createOrbit } from '../state/orbit.mjs';
 import {
+  clearPinnedStatus,
   clearInputPrompt,
   focusDockInput,
   isInputDockMounted,
@@ -258,7 +262,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 +853,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 +1052,10 @@ function renderEvent(event) {
         renderStagnation(data);
         break;
       }
+      if (isDeniedStatusMessage(msg)) {
+        stopSpinner();
+        break;
+      }
       startSpinner(msg);
       break;
     }
@@ -927,6 +1093,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)) {
@@ -934,17 +1101,20 @@ function renderEvent(event) {
         }
       }
       if (text) {
-        renderBlockBoundary('content');
-        if (!runtime.contentHeaderPrinted) {
-          process.stdout.write(`${transcriptHeader('bahulam', { tone: 'assistant' })}\n`);
-          runtime.contentHeaderPrinted = true;
-        }
         const rendered = renderMarkdown(text);
-        for (const line of rendered.split('\n')) {
-          process.stdout.write(`${transcriptLine(line, { tone: 'assistant' })}\n`);
+        const lines = transcriptRenderableLines(rendered);
+        if (lines.length) {
+          renderBlockBoundary('content', { compactSame: true });
+          if (!runtime.contentHeaderPrinted) {
+            process.stdout.write(`${transcriptHeader('bahulam', { tone: 'assistant' })}\n`);
+            runtime.contentHeaderPrinted = true;
+          }
+          for (const line of lines) {
+            process.stdout.write(`${transcriptLine(line, { tone: 'assistant' })}\n`);
+          }
+          runtime.renderedContentThisTurn = true;
+          runtime.lastRenderedBlock = 'content';
         }
-        runtime.renderedContentThisTurn = true;
-        runtime.lastRenderedBlock = 'content';
       }
       break;
     }
@@ -1009,6 +1179,10 @@ function renderEvent(event) {
       session.totalToolCalls++;
       stopSpinner();
       flushContent();
+      if (shouldFoldSubAgentTool(data)) {
+        foldSubAgentToolCall(data);
+        break;
+      }
       renderToolCall(data);
       break;
     }
@@ -1039,6 +1213,7 @@ function renderEvent(event) {
     }
 
     case 'approval_denied': {
+      stopSpinner();
       const reason = data?.reason || 'User denied';
       const toolName = data?.tool || '';
       const indent = subAgentIndent();
@@ -1051,10 +1226,22 @@ function renderEvent(event) {
     case 'tool_result':
     case 'tool_done': {
       stopSpinner();
+      if (shouldFoldSubAgentTool(data)) {
+        foldSubAgentToolResult(data);
+        break;
+      }
       renderToolResult(data, type);
       break;
     }
 
+    case 'file_diff': {
+      stopSpinner();
+      flushContent();
+      flushPendingHead();
+      renderFileDiffEvent(data);
+      break;
+    }
+
     case 'plan': {
       stopSpinner();
       flushContent();
@@ -1153,6 +1340,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 +1370,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 +1439,7 @@ function renderEvent(event) {
     case 'error':
       stopSpinner();
       flushContent();
+      flushFoldedSubAgentTools();
       {
         const guidance = formatAgentErrorGuidance(data || {});
         renderBlockBoundary('status', { compactSame: true });
@@ -1291,22 +1481,26 @@ function renderEvent(event) {
     case 'complete': {
       stopSpinner();
       flushContent();
+      flushFoldedSubAgentTools();
       resetSubAgents();
       session.inSubAgent = false;
 
       const summary = data?.summary || '';
       if (summary && !runtime.renderedContentThisTurn) {
-        renderBlockBoundary('content');
-        if (!runtime.contentHeaderPrinted) {
-          process.stdout.write(`${transcriptHeader('bahulam', { tone: 'assistant' })}\n`);
-          runtime.contentHeaderPrinted = true;
-        }
         const rendered = renderMarkdown(summary);
-        for (const line of rendered.split('\n')) {
-          process.stdout.write(`${transcriptLine(line, { tone: 'assistant' })}\n`);
+        const lines = transcriptRenderableLines(rendered);
+        if (lines.length) {
+          renderBlockBoundary('content', { compactSame: true });
+          if (!runtime.contentHeaderPrinted) {
+            process.stdout.write(`${transcriptHeader('bahulam', { tone: 'assistant' })}\n`);
+            runtime.contentHeaderPrinted = true;
+          }
+          for (const line of lines) {
+            process.stdout.write(`${transcriptLine(line, { tone: 'assistant' })}\n`);
+          }
+          runtime.renderedContentThisTurn = true;
+          runtime.lastRenderedBlock = 'content';
         }
-        runtime.renderedContentThisTurn = true;
-        runtime.lastRenderedBlock = 'content';
       }
 
       // Update session token counts
@@ -1649,6 +1843,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 +1985,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 +2485,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;
@@ -2496,11 +2800,60 @@ export async function startTerminalRepl() {
 
   const ctx = { auth, toolExecutor, approval, jsonlWriter, sessionMgr, checkpoints, effectivePolicy, latestProjectContext, latestEnvelope, pendingVisionPaths: [] };
 
+  let startupOutputRow = 1;
+  let startupOutputCol = 1;
+
+  function trackStartupOutput(chunk) {
+    if (!process.stderr.isTTY || term().plain) return;
+    const text = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk ?? '');
+    if (!text) return;
+    const clean = text
+      .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
+      .replace(/\x1b[()][A-Za-z0-9]/g, '');
+    const width = Math.max(1, process.stderr.columns || process.stdout.columns || 80);
+    for (const ch of clean) {
+      if (ch === '\r') {
+        startupOutputCol = 1;
+        continue;
+      }
+      if (ch === '\n') {
+        startupOutputRow++;
+        startupOutputCol = 1;
+        continue;
+      }
+      startupOutputCol++;
+      if (startupOutputCol > width) {
+        startupOutputRow++;
+        startupOutputCol = 1;
+      }
+    }
+  }
+
+  function startStartupOutputTracking() {
+    if (!process.stderr.isTTY || term().plain) return () => {};
+    const originalWrite = process.stderr.write;
+    function trackedStartupWrite(chunk, ...args) {
+      trackStartupOutput(chunk);
+      return originalWrite.call(this, chunk, ...args);
+    }
+    process.stderr.write = trackedStartupWrite;
+    return () => {
+      if (process.stderr.write === trackedStartupWrite) {
+        process.stderr.write = originalWrite;
+      }
+    };
+  }
+
+  function startupCursorSeed() {
+    return { row: startupOutputRow, col: startupOutputCol };
+  }
+
   async function startNewSession({ announce = true } = {}) {
     stopSpinner();
     flushContent();
     flushPendingHead();
     flushCompactReadRun();
+    runtime.foldedSubAgentTools = null;
     clearCards();
 
     const preserved = {
@@ -2814,57 +3167,67 @@ export async function startTerminalRepl() {
   // ── Print banner + preflight + init BEFORE mounting the status bar ──
   // The status bar shrinks the scroll region; if it mounts first, the
   // banner scrolls off-screen before the user ever sees it.
-  printBanner(auth);
-
-  // Preflight diagnostic (PRD-055 §9). Non-blocking; opt-out via
-  // KEPLER_NO_PREFLIGHT=1 (used by tests / scripted runs).
-  if (process.env.KEPLER_NO_PREFLIGHT !== '1' && !cliArgs.freeswim) {
-    try { await runPreflight({ auth, cwd: safeCwd(), version: VERSION }); }
-    catch { /* preflight is best-effort */ }
-  }
-
-  // ── Initialization ──
-  process.stderr.write(`  ${c.brand('⠋')} ${c.dim('Initializing...')}\r`);
-  await fetchUser(ctx);
-
-  // Clear the spinner line
-  process.stderr.write(`\r${' '.repeat(60)}\r`);
-  process.stderr.write(`  ${c.green('✓')} ${c.dim('Ready; projects will be indexed on demand')}\n`);
-  if (session.user) {
-    process.stderr.write(`  ${c.green('✓')} ${c.dim(`Logged in as ${session.user.github_username || session.user.email || 'user'}`)}\n`);
-  }
-  // ── Resume previous session ──
-  if (cliArgs.resume) {
-    const lastSession = cliArgs.resumeSessionId
-        ? { sessionId: cliArgs.resumeSessionId }
-        : sessionMgr.getLastSession();
-
-    if (lastSession) {
-      const resumed = await activateResumedSession(lastSession.sessionId, 'startup');
-      if (resumed.ok) {
-        process.stderr.write(`  ${c.green('↺')} ${c.dim(`Resumed session: ${messageCountLabel(resumed.messages)}`)}`);
-        process.stderr.write(` ${c.dim('· project')} ${c.brand(path.basename(safeCwd()))}`);
-        process.stderr.write(` ${c.dim(`· agent ${resumed.historyMode}`)}`);
-        if (resumed.switchedProject) process.stderr.write(` ${c.dim('(cwd restored)')}`);
-        if (resumed.projectMissing) process.stderr.write(` ${c.yellow('(saved project path unavailable; using current cwd)')}`);
-        if (resumed.instruction) process.stderr.write(` ${c.dim('—')} ${c.dim(resumed.instruction.slice(0, 50))}`);
-        process.stderr.write('\n');
-        renderResumePreview(resumed, { renderEvent });
+  const stopStartupOutputTracking = startStartupOutputTracking();
+  let dockCursor = startupCursorSeed();
+  try {
+    printBanner(auth);
+
+    // Preflight diagnostic (PRD-055 §9). Non-blocking; opt-out via
+    // KEPLER_NO_PREFLIGHT=1 (used by tests / scripted runs).
+    if (process.env.KEPLER_NO_PREFLIGHT !== '1' && !cliArgs.freeswim) {
+      try { await runPreflight({ auth, cwd: safeCwd(), version: VERSION }); }
+      catch { /* preflight is best-effort */ }
+    }
+
+    // ── Initialization ──
+    process.stderr.write(`  ${c.brand('⠋')} ${c.dim('Initializing...')}\r`);
+    await fetchUser(ctx);
+
+    // Clear the spinner line
+    process.stderr.write(`\r${' '.repeat(60)}\r`);
+    process.stderr.write(`  ${c.green('✓')} ${c.dim('Ready; projects will be indexed on demand')}\n`);
+    if (session.user) {
+      process.stderr.write(`  ${c.green('✓')} ${c.dim(`Logged in as ${session.user.github_username || session.user.email || 'user'}`)}\n`);
+    }
+    // ── Resume previous session ──
+    if (cliArgs.resume) {
+      const lastSession = cliArgs.resumeSessionId
+          ? { sessionId: cliArgs.resumeSessionId }
+          : sessionMgr.getLastSession();
+
+      if (lastSession) {
+        const resumed = await activateResumedSession(lastSession.sessionId, 'startup');
+        if (resumed.ok) {
+          process.stderr.write(`  ${c.green('↺')} ${c.dim(`Resumed session: ${messageCountLabel(resumed.messages)}`)}`);
+          process.stderr.write(` ${c.dim('· project')} ${c.brand(path.basename(safeCwd()))}`);
+          process.stderr.write(` ${c.dim(`· agent ${resumed.historyMode}`)}`);
+          if (resumed.switchedProject) process.stderr.write(` ${c.dim('(cwd restored)')}`);
+          if (resumed.projectMissing) process.stderr.write(` ${c.yellow('(saved project path unavailable; using current cwd)')}`);
+          if (resumed.instruction) process.stderr.write(` ${c.dim('—')} ${c.dim(resumed.instruction.slice(0, 50))}`);
+          process.stderr.write('\n');
+          renderResumePreview(resumed, { renderEvent });
+        } else {
+          process.stderr.write(`  ${c.yellow('!')} ${c.dim(resumed.reason || 'No conversation found for session ' + lastSession.sessionId)}\n`);
+        }
       } else {
-        process.stderr.write(`  ${c.yellow('!')} ${c.dim(resumed.reason || 'No conversation found for session ' + lastSession.sessionId)}\n`);
+        process.stderr.write(`  ${c.yellow('!')} ${c.dim('No previous session to resume')}\n`);
       }
-    } else {
-      process.stderr.write(`  ${c.yellow('!')} ${c.dim('No previous session to resume')}\n`);
     }
-  }
 
-  process.stderr.write(`\n  ${c.dim('Press')} ${c.brand('Enter')} ${c.dim('to start, or type a prompt below.')}\n`);
+    process.stderr.write(`\n  ${c.dim('Press')} ${c.brand('Enter')} ${c.dim('to start, or type a prompt below.')}\n`);
+  } finally {
+    dockCursor = startupCursorSeed();
+    stopStartupOutputTracking();
+  }
 
   // Keep one bottom-reserved UI surface: the fixed input dock. The older
   // status bar used the same terminal scroll-region primitive, so mounting
   // both would make prompt placement unpredictable.
   orbitRef.current = createOrbit();
-  const inputDockActive = mountInputDock();
+  const inputDockActive = mountInputDock({
+    initialContentRow: dockCursor.row,
+    initialContentCol: dockCursor.col,
+  });
   if (inputDockActive) {
     process.on('beforeExit', unmountInputDock);
     process.on('exit',       unmountInputDock);
@@ -2877,11 +3240,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 +3269,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 +3288,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 +3314,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 +3325,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 +3467,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 +3480,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 +3580,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 +3647,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 +3668,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 +3698,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) {
@@ -3485,6 +3925,21 @@ export async function startTerminalRepl() {
     }
     runtime.afterContentFlush = focusExecutionInput;
 
+    function printExecutionInstruction(instruction) {
+      if (isInputDockMounted()) {
+        clearInputPrompt();
+        moveToContent();
+      } else if (executionInputVisible) {
+        process.stderr.write('\n');
+      }
+      renderBlockBoundary('user', { compactSame: true });
+      process.stderr.write(`${transcriptHeader('you', { tone: 'user' })} ${paint.text.dim('follow-up')}\n`);
+      for (const line of String(instruction || '').split('\n')) {
+        process.stderr.write(`${transcriptLine(line, { tone: 'user' })}\n`);
+      }
+      runtime.lastRenderedBlock = 'user';
+    }
+
     async function submitExecutionInstruction() {
       const instruction = executionInputBuffer.trim();
       executionInputBuffer = '';
@@ -3503,18 +3958,14 @@ export async function startTerminalRepl() {
         executionInputVisible = false;
         return;
       }
+      printExecutionInstruction(instruction);
       if (isInputDockMounted()) {
-        clearInputPrompt();
-        moveToContent();
-        process.stderr.write(`${executionInputPrefix()}${instruction}\n`);
         renderDockInput(executionInputPrefix(), '', {
           context: buildContextStrip(),
           meta: buildDockMeta(),
           tips: executionInputTips(),
         });
         moveToContent();
-      } else if (executionInputVisible) {
-        process.stderr.write('\n');
       }
       executionInputVisible = false;
       // Live steering (PRD-081 §5.2): submit through the dedicated
@@ -3540,18 +3991,26 @@ export async function startTerminalRepl() {
       });
 
       if (status === 'accepted') {
+        renderBlockBoundary('status', { compactSame: true });
         process.stderr.write(`  ${c.green('↳')} ${c.dim('sent to running agent')}\n`);
+        runtime.lastRenderedBlock = 'status';
       } else if (status === 'duplicate') {
+        renderBlockBoundary('status', { compactSame: true });
         process.stderr.write(`  ${c.dim('↳ already sent (idempotent)')}\n`);
+        runtime.lastRenderedBlock = 'status';
       } else if (status === 'queued_next_turn') {
         _queuedLines.push(instruction);
+        renderBlockBoundary('status', { compactSame: true });
         process.stderr.write(`  ${c.yellow('↳')} ${c.dim('task ended — queued for next turn')}\n`);
+        runtime.lastRenderedBlock = 'status';
       } else {
         // no_task, error, or unknown — fall back to next-turn queue so the
         // user's text is never silently lost.
         _queuedLines.push(instruction);
         const errBits = result && result.error ? ` ${c.dim(`(${String(result.error).slice(0, 80)})`)}` : '';
+        renderBlockBoundary('status', { compactSame: true });
         process.stderr.write(`  ${c.yellow('↳')} ${c.dim('queued for next turn')}${errBits}\n`);
+        runtime.lastRenderedBlock = 'status';
       }
     }
 
@@ -3637,6 +4096,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 +4196,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 +4210,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 = () => {
@@ -3773,8 +4240,6 @@ export async function startTerminalRepl() {
         moveToContent();
       }
       startContentStream();
-      process.stderr.write(`\n${transcriptHeader('bahulam', { tone: 'assistant' })}\n`);
-      runtime.contentHeaderPrinted = true;
 
       // Immediate feedback so the screen isn't blank between submit and the
       // first backend event. The first `status`, `thinking`, or `content_*`