@bahulam/code 2.6.15 → 2.6.16

package/src/terminal/repl-format.mjs

@@ -9,6 +9,58 @@
 
 import * as path from 'node:path';
 import { c, stripAnsi, formatElapsed, inPlace } from './ansi.mjs';
+import * as rqueue from '../ui/render-queue.mjs';
+
+// Transient one-line status writer that is safe under the render queue.
+// Raw inPlace() writes get REDIRECTED into transcript content when the
+// queue is active (cursor codes stripped) — that leaked one line per
+// spinner frame during resume summarization. queue.status() coalesces
+// and overwrites in place; inPlace stays as the no-queue fallback.
+function transientLine(text) {
+  if (rqueue.isActive()) {
+    if (text) rqueue.status(text);
+    else rqueue.clearStatus();
+    return;
+  }
+  inPlace(text);
+}
+
+/**
+ * Atomic repaint writer for raw-stdin overlays (resume picker, /model form).
+ *
+ * While the render queue is active, plain process.stderr.write is REDIRECTED
+ * into transcript content with cursor codes stripped — an overlay's
+ * "cursor-up N + erase" repaint becomes "append another copy" (the form-
+ * replication bug). Each repaint therefore goes through rqueue.raw() as one
+ * frame. On the first paint the frame's rows are reserved with newlines so
+ * painting near the bottom (input dock) scrolls once up-front and the
+ * cursor-relative repaint math stays stable afterwards.
+ */
+export function writeOverlayFrame(erasePrev, lines) {
+  const body = lines.join('\n') + '\n';
+  if (erasePrev > 0) {
+    rqueue.raw(`\x1b[${erasePrev}F\r\x1b[J` + body);
+  } else {
+    rqueue.raw('\n'.repeat(lines.length) + `\x1b[${lines.length}A` + body);
+  }
+}
+
+/**
+ * Erase the previously drawn overlay frame (rows lines tall) so the next
+ * prompt / transcript output starts on a clean line. Call from every
+ * overlay's cleanup path — without this, picker frames stack on screen
+ * when a follow-up prompt (cwd confirm, next overlay) writes below them.
+ */
+export function eraseOverlayFrame(rows, summaryLine = '') {
+  if (!rows || rows <= 0) {
+    if (summaryLine) rqueue.raw(summaryLine + '\n');
+    return;
+  }
+  // Collapse the frame to a compact one-line summary (or nothing). A pure
+  // erase leaves a blank void mid-screen because the input dock parks the
+  // cursor at the bottom before the next plain write lands.
+  rqueue.raw(`\x1b[${rows}F\r\x1b[J` + (summaryLine ? summaryLine + '\n' : ''));
+}
 
 // ── One-liners ───────────────────────────────────────────────────────
 
@@ -182,23 +234,31 @@ export function startResumeProgress(mode = 'full') {
     if (!active) return;
     const glyph = frames[frame % frames.length];
     frame++;
-    inPlace(`  ${c.brand(glyph)} ${c.dim(label)}  ${resumeProgressBar(percent)}  ${c.dim(formatElapsed(started))}`);
+    transientLine(`  ${c.brand(glyph)} ${c.dim(label)}  ${resumeProgressBar(percent)}  ${c.dim(formatElapsed(started))}`);
   };
 
   render();
-  const timer = setInterval(render, 100);
+  let timer = setInterval(render, 100);
   return {
+    // Self-healing: the resume flow stops the progress line to show the
+    // cwd-confirm overlay, then keeps reporting phases ('rebuilding local
+    // session state', …). A dead update() silently dropped every cue after
+    // that prompt — revive the ticker instead (same pattern as
+    // updateSpinner in repl-render.mjs).
     update(nextLabel, nextPercent) {
-      if (!active) return;
       if (nextLabel) label = nextLabel;
       if (Number.isFinite(nextPercent)) percent = Math.max(percent, Math.min(98, nextPercent));
+      if (!active) {
+        active = true;
+        timer = setInterval(render, 100);
+      }
       render();
     },
     stop() {
       if (!active) return;
       active = false;
       clearInterval(timer);
-      inPlace('');
+      transientLine('');
     },
   };
 }

package/src/terminal/repl-model-form.mjs

@@ -0,0 +1,132 @@
+/**
+ * Interactive per-role model form for /model (PRD-076 W7).
+ *
+ * ↑↓ picks a role row, ←→ cycles through [backend default] + the curated
+ * platform catalog for that role, Enter applies to session overrides,
+ * c resets every row to default, Esc cancels. Same raw-stdin overlay
+ * pattern as the resume picker (repl-resume.mjs): pause readline, raw
+ * mode on, redraw in place with cursor-up + erase-down, restore on exit.
+ */
+
+import { c } from './ansi.mjs';
+import { fitAnsiLine, writeOverlayFrame, eraseOverlayFrame } from './repl-format.mjs';
+
+const DEFAULT_SENTINEL = '__default__';
+
+function creditBadge(row) {
+  const usd = Number(row?.input_cost_usd_per_m);
+  if (!Number.isFinite(usd) || usd <= 0) return '';
+  const credits = usd * 200; // credits = provider cost × 2 × 100/USD
+  return `~${credits < 10 ? credits.toFixed(1) : String(Math.round(credits))} cr/M`;
+}
+
+/**
+ * @param {object} opts
+ * @param {object|null} opts.rl        readline instance to pause/resume
+ * @param {Array}  opts.roles          [{ role, label, current, defaultLabel }]
+ * @param {Array}  opts.catalog        raw /api/models rows (may be empty)
+ * @param {Array}  [opts.fallbackIds]  model ids to cycle when no curated catalog
+ * @param {string} [opts.unavailableNote] why the catalog is missing (shown in header)
+ * @returns {Promise<{overrides: Record<string,string>}|null>} null = cancelled
+ */
+export async function pickModelOverridesForm({ rl, roles, catalog, fallbackIds, unavailableNote }) {
+  if (!process.stdin.isTTY) return null;
+  if (rl) rl.pause();
+
+  const curated = (catalog || []).filter(m => m?.harness_validated && m?.id);
+  const usingFallback = curated.length === 0;
+  const optionIds = usingFallback
+    ? [...new Set((fallbackIds || []).filter(Boolean))]
+    : curated.map(m => m.id);
+  const baseOptions = [DEFAULT_SENTINEL, ...optionIds];
+  const byId = new Map(curated.map(m => [m.id, m]));
+
+  // Per-row option list; a current override that isn't in the curated list
+  // is appended so it stays visible and selectable.
+  const rows = roles.map(r => {
+    let opts = baseOptions;
+    let idx = 0;
+    if (r.current) {
+      const found = baseOptions.indexOf(r.current);
+      if (found >= 0) {
+        idx = found;
+      } else {
+        opts = [...baseOptions, r.current];
+        idx = opts.length - 1;
+      }
+    }
+    return { ...r, opts, idx };
+  });
+
+  return await new Promise((resolve) => {
+    const wasRaw = process.stdin.isRaw;
+    let cursor = 0;
+    let renderedLines = 0;
+
+    const valueLabel = (row) => {
+      const value = row.opts[row.idx];
+      if (value === DEFAULT_SENTINEL) {
+        return c.dim(row.defaultLabel ? `default · ${row.defaultLabel}` : 'backend default');
+      }
+      const meta = byId.get(value);
+      const badge = meta ? creditBadge(meta) : '';
+      // Only flag uncurated picks when a curated catalog actually loaded —
+      // in fallback mode every option is a known backend model, not a stray.
+      const flag = meta || usingFallback ? '' : c.yellow(' (uncurated)');
+      return `${c.brand(value)}${badge ? ` ${c.dim(badge)}` : ''}${flag}`;
+    };
+
+    const render = () => {
+      const cols = Math.max(60, process.stderr.columns || 120);
+      const lines = [];
+      lines.push(`  ${c.bold('Models')} ${c.dim('· session overrides · curated platform catalog')}`);
+      if (usingFallback) {
+        const why = unavailableNote ? ` — ${unavailableNote}` : '';
+        lines.push(`  ${c.yellow('!')} ${c.dim(`catalog unavailable${why}; showing this session's backend models`)}`);
+      }
+      lines.push('');
+      rows.forEach((row, i) => {
+        const marker = i === cursor ? c.brand('▸') : ' ';
+        const rawLabel = String(row.label || row.role).padEnd(14, ' ');
+        const label = i === cursor ? c.brand(rawLabel) : rawLabel;
+        lines.push(fitAnsiLine(`  ${marker} ${label} ${c.dim('‹')} ${valueLabel(row)} ${c.dim('›')}`, cols - 1));
+      });
+      lines.push('');
+      lines.push(fitAnsiLine(`  ${c.dim('↑↓ role · ←→ model · Enter apply · c defaults · Esc cancel')}`, cols - 1));
+      writeOverlayFrame(renderedLines, lines);
+      renderedLines = lines.length;
+    };
+
+    const cleanup = (value) => {
+      process.stdin.removeListener('data', onData);
+      process.stdin.setRawMode(wasRaw || false);
+      eraseOverlayFrame(renderedLines);
+      if (rl) rl.resume();
+      resolve(value);
+    };
+
+    const onData = (data) => {
+      const key = data.toString('utf8');
+      if (key === '\x1b' || key === '\x03' || key === 'q') { cleanup(null); return; }
+      if (key === '\r' || key === '\n') {
+        const overrides = {};
+        for (const row of rows) {
+          const value = row.opts[row.idx];
+          if (value && value !== DEFAULT_SENTINEL) overrides[row.role] = value;
+        }
+        cleanup({ overrides });
+        return;
+      }
+      if (key === 'c' || key === 'C') { rows.forEach(r => { r.idx = 0; }); render(); return; }
+      if (key === '\x1b[A') { cursor = Math.max(0, cursor - 1); render(); return; }
+      if (key === '\x1b[B') { cursor = Math.min(rows.length - 1, cursor + 1); render(); return; }
+      if (key === '\x1b[D') { const r = rows[cursor]; r.idx = (r.idx - 1 + r.opts.length) % r.opts.length; render(); return; }
+      if (key === '\x1b[C') { const r = rows[cursor]; r.idx = (r.idx + 1) % r.opts.length; render(); return; }
+    };
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on('data', onData);
+    render();
+  });
+}

package/src/terminal/repl-render.mjs

@@ -27,6 +27,51 @@ import {
   isInputDockMounted,
   moveToContent,
 } from '../ui/input-dock.mjs';
+import * as queue from '../ui/render-queue.mjs';
+
+// Single seam for the transient spinner/status line. Rich mode (render
+// queue active) → coalesced last-wins status that can never interleave
+// with content. Legacy dock path and bare-TTY inPlace stay as fallbacks
+// until their write-sites migrate onto the queue too.
+// Max inner-tool lines shown under the spinner during a sub-agent run.
+const SUB_AGENT_WINDOW_ROWS = 7;
+
+function presentStatus(rendered) {
+  if (queue.isActive()) {
+    const win = runtime.subAgentWindow;
+    if (win?.active && win.lines.length) {
+      queue.statusBlock([
+        rendered,
+        ...win.lines.slice(-SUB_AGENT_WINDOW_ROWS).map(l => `    ${c.dim(l)}`),
+      ]);
+      return;
+    }
+    queue.status(rendered);
+    return;
+  }
+  if (isInputDockMounted()) { drawPinnedStatus(rendered); return; }
+  inPlace(rendered);
+}
+
+/** Push a line into the live sub-agent tool window (dedup consecutive). */
+export function pushSubAgentWindowLine(line) {
+  const win = runtime.subAgentWindow;
+  if (!win?.active) return;
+  const text = String(line || '').trim();
+  if (!text || win.lines[win.lines.length - 1] === text) return;
+  win.lines.push(text);
+  if (win.lines.length > 24) win.lines.splice(0, win.lines.length - 24);
+}
+
+export function setSubAgentWindowActive(active) {
+  runtime.subAgentWindow = { active: Boolean(active), lines: [] };
+}
+
+function erasePresentedStatus() {
+  if (queue.isActive()) { queue.clearStatus(); return; }
+  if (isInputDockMounted()) { clearPinnedStatus(); moveToContent(); return; }
+  inPlace('');
+}
 import {
   formatCardHead,
   formatCompactFileDiff,
@@ -157,11 +202,11 @@ export function renderExploreRun() {
   // picks up exploreSummary() text instead of any stale label.
   runtime.exploreRun.lineActive = true;
 
-  if (isInputDockMounted()) {
-    // Docked terminals reserve a bottom input area. Keeping explore progress
-    // as an animated bottom overlay creates visible gaps between the sub-agent
-    // transcript and the current tool. Emit bounded snapshots into the
-    // transcript instead; every hidden call remains available through /expand.
+  if (!queue.isActive() && isInputDockMounted()) {
+    // Legacy docked path (queue not engaged): an animated bottom overlay
+    // created visible gaps, so emit bounded snapshots into the transcript
+    // instead. With the render queue active this branch is skipped — the
+    // coalesced status line can animate safely in dock mode.
     if (runtime.spinInterval) {
       clearInterval(runtime.spinInterval);
       runtime.spinInterval = null;
@@ -183,8 +228,7 @@ export function renderExploreRun() {
       const frame = SPIN_FRAMES[runtime.spinFrame % SPIN_FRAMES.length];
       runtime.spinFrame++;
       const rendered = `  ${c.brand(frame)} ${c.dim(label)}`;
-      if (isInputDockMounted()) moveToContent();
-      inPlace(rendered);
+      presentStatus(rendered);
     }, 80);
   }
   runtime.lastRenderedBlock = 'tool';
@@ -200,9 +244,10 @@ export function flushExploreRun() {
     if (wasActive) {
       if (runtime.spinInterval) { clearInterval(runtime.spinInterval); runtime.spinInterval = null; }
       runtime.spinText = '';
-      if (!isInputDockMounted()) inPlace('');
+      if (queue.isActive()) queue.clearStatus();
+      else if (!isInputDockMounted()) inPlace('');
     }
-    if (!isInputDockMounted() || summary !== runtime.exploreRun.lastPrintedSummary) {
+    if (queue.isActive() || !isInputDockMounted() || summary !== runtime.exploreRun.lastPrintedSummary) {
       writeExploreSnapshot(summary);
     }
   }
@@ -238,6 +283,17 @@ export function renderToolCall(data) {
     return;
   }
 
+  // Sub-agent live window (queue mode): inner tool calls stream into the
+  // fixed-height status block instead of appending transcript lines. The
+  // card is still recorded so /expand, /last, and `d` show full detail.
+  if (queue.isActive() && runtime.subAgentWindow?.active && inSubAgentBlock()) {
+    recordCard({ id: callId, tool, args, startedAt: Date.now() });
+    session.toolCounts[tool] = (session.toolCounts[tool] || 0) + 1;
+    const label = readToolLabel(tool, { args });
+    pushSubAgentWindowLine(label ? `→ ${tool} · ${label}` : `→ ${tool}`);
+    return; // the spinner tick paints the window block
+  }
+
   flushExploreRun();
   renderBlockBoundary('tool', { compactSame: tool !== 'shell' });
 
@@ -251,8 +307,12 @@ export function renderToolCall(data) {
   session.toolCounts[tool] = (session.toolCounts[tool] || 0) + 1;
   runtime.pendingHead = { callId, head, indent };
   runtime.lastRenderedBlock = 'tool';
-  // Spinner shows what's running until the result arrives.
-  startSpinner(`${tool}…`);
+  // Spinner shows what's running until the result arrives. Per-call phase
+  // gives each tool its own elapsed clock — long shell runs count up live.
+  const spinLabel = tool === 'shell' && args.command
+    ? `shell: ${String(args.command).split('\n')[0].slice(0, 48)}`
+    : `${tool}…`;
+  startSpinner(spinLabel, { phase: `tool:${callId}` });
 }
 
 /**
@@ -316,6 +376,12 @@ export function renderToolResult(data, eventType = 'tool_result') {
     return;
   }
 
+  // Sub-agent live window: the call line is already streaming in the
+  // status block; the result stays card-only (close card summarizes).
+  if (queue.isActive() && runtime.subAgentWindow?.active && inSubAgentBlock()) {
+    return;
+  }
+
   // ── Single-line combined emit ──
   // If the head for this call is still buffered (no interleaving content
   // landed), and the combined line fits the terminal width, emit ONE line
@@ -329,6 +395,7 @@ export function renderToolResult(data, eventType = 'tool_result') {
         process.stderr.write(`${diffPreview}\n`);
         rememberFileDiffPreview(data);
       }
+      renderPlanBody(tool, data);
       runtime.lastRenderedBlock = 'tool';
       runtime.pendingHead = null;
       return;
@@ -340,6 +407,7 @@ export function renderToolResult(data, eventType = 'tool_result') {
         process.stderr.write(`${diffPreview}\n`);
         rememberFileDiffPreview(data);
       }
+      renderPlanBody(tool, data);
       runtime.lastRenderedBlock = 'tool';
       runtime.pendingHead = null;
       return;
@@ -358,6 +426,7 @@ export function renderToolResult(data, eventType = 'tool_result') {
     process.stderr.write(`${diffPreview}\n`);
     rememberFileDiffPreview(data);
   }
+  renderPlanBody(tool, data);
   runtime.lastRenderedBlock = 'tool';
 
   // Lint warnings stay visible alongside writes.
@@ -366,6 +435,29 @@ export function renderToolResult(data, eventType = 'tool_result') {
   }
 }
 
+// The plan sub-agent's output is the one peer result the USER needs to
+// see, not just the model — it's the execution contract for the turn.
+// Render the body as a bordered block (capped; full text stays on the
+// card via /last). All other peer verbs keep the one-line summary.
+const PLAN_BODY_MAX_LINES = 30;
+
+function renderPlanBody(tool, data) {
+  if (String(tool || '').toLowerCase() !== 'plan') return;
+  const text = String(data?.output ?? data?.result ?? '').trim();
+  if (!text) return;
+  const indent = subAgentIndent();
+  const lines = transcriptRenderableLines(renderMarkdown(text));
+  if (!lines.length) return;
+  const shown = lines.slice(0, PLAN_BODY_MAX_LINES);
+  process.stderr.write(`${indent}${paint.text.dim('┌ plan')}\n`);
+  for (const line of shown) {
+    process.stderr.write(`${indent}${paint.text.dim('│')} ${line}\n`);
+  }
+  process.stderr.write(lines.length > shown.length
+    ? `${indent}${paint.text.dim(`└ … ${lines.length - shown.length} more lines · /last to expand`)}\n`
+    : `${indent}${paint.text.dim('└')}\n`);
+}
+
 function fileDiffKey(data = {}) {
   return fileDiffKeys(data)[0] || '';
 }
@@ -541,10 +633,37 @@ export const SPIN_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '
 // (declaration moved to repl-state.mjs runtime.*)
 // (declaration moved to repl-state.mjs runtime.*)
 
-export function startSpinner(text) {
+// Compose the status label with live phase telemetry: elapsed seconds
+// (shown once a phase runs ≥3s — quick tools stay clean) and the
+// per-phase tool-call counter (sub-agent progress). The 80ms tick calls
+// this every frame, so elapsed counts up without any extra timer.
+function composeStatusLabel(label) {
+  const parts = [label];
+  if (runtime.spinStartedAt) {
+    const elapsedS = Math.floor((Date.now() - runtime.spinStartedAt) / 1000);
+    if (runtime.spinToolCalls > 0) {
+      parts.push(`${runtime.spinToolCalls} call${runtime.spinToolCalls === 1 ? '' : 's'}`);
+    }
+    if (elapsedS >= 3) parts.push(`${elapsedS}s`);
+  }
+  return parts.join(' · ');
+}
+
+/**
+ * Start (or re-label) the spinner. `phase` scopes the elapsed clock:
+ * a phase change resets it, same-phase updates keep it counting. Callers
+ * that don't pass a phase get a generic per-call reset (old behavior).
+ */
+export function startSpinner(text, { phase = null } = {}) {
+  const nextPhase = phase || `generic:${text}`;
+  if (runtime.spinPhase !== nextPhase) {
+    runtime.spinPhase = nextPhase;
+    runtime.spinStartedAt = Date.now();
+    runtime.spinToolCalls = 0;
+  }
   runtime.spinText = text;
   runtime.spinFrame = 0;
-  if (runtime.exploreRun && runtime.exploreRun.lineActive && isInputDockMounted()) return;
+  if (!queue.isActive() && runtime.exploreRun && runtime.exploreRun.lineActive && isInputDockMounted()) return;
   if (runtime.spinInterval) return; // already running
   runtime.spinInterval = setInterval(() => {
     // While an explore run is active, its live counts own the spinner
@@ -555,20 +674,29 @@ export function startSpinner(text) {
     if (!label) return;
     const frame = SPIN_FRAMES[runtime.spinFrame % SPIN_FRAMES.length];
     runtime.spinFrame++;
-    const rendered = `  ${c.brand(frame)} ${c.dim(label)}`;
-    if (isExploreActive && isInputDockMounted()) {
+    const rendered = `  ${c.brand(frame)} ${c.dim(composeStatusLabel(label))}`;
+    if (!queue.isActive() && isExploreActive && isInputDockMounted()) {
       return;
     }
-    if (isInputDockMounted()) {
-      drawPinnedStatus(rendered);
-      return;
-    }
-    inPlace(rendered);
+    presentStatus(rendered);
   }, 80);
 }
 
 export function updateSpinner(text) {
   runtime.spinText = text;
+  // Self-healing: a content flush stops the spinner (clears the
+  // interval), but long-running work — sub-agent runs especially —
+  // keeps sending updates afterwards. Without reviving the interval
+  // those updates write into a dead timer and the user sees a frozen
+  // "▸ running" with no progress at all. Same phase → clock continues.
+  if (!runtime.spinInterval && text) {
+    startSpinner(text, { phase: runtime.spinPhase || undefined });
+  }
+}
+
+/** Bump the per-phase progress counter (sub-agent tool calls). */
+export function bumpSpinnerProgress() {
+  runtime.spinToolCalls++;
 }
 
 export function stopSpinner() {
@@ -578,12 +706,10 @@ export function stopSpinner() {
   if (runtime.exploreRun && runtime.exploreRun.lineActive) return;
   if (runtime.spinInterval) { clearInterval(runtime.spinInterval); runtime.spinInterval = null; }
   runtime.spinText = '';
-  if (isInputDockMounted()) {
-    clearPinnedStatus();
-    moveToContent();
-    return;
-  }
-  inPlace('');
+  runtime.spinPhase = null;
+  runtime.spinStartedAt = 0;
+  runtime.spinToolCalls = 0;
+  erasePresentedStatus();
 }
 
 // ── Content Streaming Display ──

package/src/terminal/repl-resume.mjs

@@ -30,6 +30,8 @@ import {
   resumeModeLabel,
   resumeTailTurnCount,
   startResumeProgress,
+  writeOverlayFrame,
+  eraseOverlayFrame,
 } from './repl-format.mjs';
 import { TarangStreamClient } from '../core/stream-client.mjs';
 import { getRecentSessions, getSessionDetail, buildResumeHistory, combineResumeSummaries } from '../core/local-store.mjs';
@@ -86,9 +88,6 @@ export async function pickResumableSession(resumable, ctx) {
     let renderedLines = 0;
 
     const renderMenu = () => {
-      if (renderedLines > 0) {
-        process.stderr.write(`\x1b[${renderedLines}F\r\x1b[J`);
-      }
       if (selected < offset) offset = selected;
       if (selected >= offset + pageSize) offset = selected - pageSize + 1;
 
@@ -119,13 +118,19 @@ export async function pickResumableSession(resumable, ctx) {
         `  ${c.dim(`↑↓ move  ·  Enter resume  ·  P preview  ·  Esc cancel  ·  ${selected + 1}/${resumable.length}`)}`,
         cols - 1
       ));
-      process.stderr.write(lines.join('\n') + '\n');
+      writeOverlayFrame(renderedLines, lines);
       renderedLines = lines.length;
     };
 
     const cleanup = (value) => {
       process.stdin.removeListener('data', onData);
       process.stdin.setRawMode(wasRaw || false);
+      // Collapse the list to one line: picked → which session; preview →
+      // erase only (preview overlay paints next); cancel → caller reports.
+      const picked = value?.action === 'resume' ? value.session : null;
+      eraseOverlayFrame(renderedLines, picked
+        ? `  ${c.green('↺')} ${c.brand(picked.project || '(unknown)')} ${c.dim(`· ${picked.messageCount} msgs · resuming…`)}`
+        : '');
       if (rl) rl.resume();
       resolve(value);
     };
@@ -183,7 +188,6 @@ export async function chooseThresholdMode(ctx, decision) {
     let renderedLines = 0;
 
     const render = () => {
-      if (renderedLines > 0) process.stderr.write(`\x1b[${renderedLines}F\r\x1b[J`);
       const cols = Math.max(60, process.stderr.columns || 120);
       const pct = Math.round(decision.usageRatio * 100);
       const projected = formatCtxTokens(decision.projected);
@@ -221,13 +225,16 @@ export async function chooseThresholdMode(ctx, decision) {
       }
       lines.push('');
       lines.push(fitAnsiLine(`  ${c.dim('↑↓ move  ·  Enter pick  ·  f/s/1/2 shortcut  ·  Esc cancel')}`, cols - 1));
-      process.stderr.write(lines.join('\n') + '\n');
+      writeOverlayFrame(renderedLines, lines);
       renderedLines = lines.length;
     };
 
     const cleanup = (value) => {
       process.stdin.removeListener('data', onData);
       process.stdin.setRawMode(wasRaw || false);
+      eraseOverlayFrame(renderedLines, value
+        ? `  ${c.dim('mode:')} ${c.brand(resumeModeLabel(value))}`
+        : '');
       if (rl) rl.resume();
       resolve(value);
     };
@@ -281,7 +288,6 @@ export async function previewResumeSession(session, ctx) {
     let scrollOffset = 0;
 
     const render = () => {
-      if (renderedLines > 0) process.stderr.write(`\x1b[${renderedLines}F\r\x1b[J`);
       const cols = Math.max(60, process.stderr.columns || 120);
       const rows = Math.max(10, Math.min((process.stderr.rows || 30) - 6, 20));
       const contentLines = (history.summary || '').split('\n');
@@ -305,13 +311,14 @@ export async function previewResumeSession(session, ctx) {
       }
       lines.push('');
       lines.push(fitAnsiLine(`  ${c.dim(`↑↓/PgUp/PgDn scroll  ·  f/s/1/2 switch mode  ·  Enter resume this  ·  q back  ·  ${scrollOffset + 1}-${Math.min(scrollOffset + rows, totalLines)}/${totalLines}`)}`, cols - 1));
-      process.stderr.write(lines.join('\n') + '\n');
+      writeOverlayFrame(renderedLines, lines);
       renderedLines = lines.length;
     };
 
     const cleanup = (value) => {
       process.stdin.removeListener('data', onData);
       process.stdin.setRawMode(wasRaw || false);
+      eraseOverlayFrame(renderedLines);
       if (rl) rl.resume();
       resolve(value);
     };
@@ -343,9 +350,12 @@ export async function previewResumeSession(session, ctx) {
  */
 export async function confirmCwdSwitch(ctx, savedPath, currentPath) {
   if (!process.stdin.isTTY) return 'switch';
-  process.stderr.write(`\n  ${c.dim('This session lives in another repo:')}\n`);
-  process.stderr.write(`  ${c.dim('→')} ${c.brand(savedPath)}  ${c.dim(`(current cwd: ${currentPath})`)}\n`);
-  process.stderr.write(`  ${c.dim('[Enter]')} switch cwd and resume · ${c.dim('[s]')} stay here and resume anyway · ${c.dim('[n]')} cancel  `);
+  const frame = [
+    `  ${c.dim('This session lives in another repo:')}`,
+    `  ${c.dim('→')} ${c.brand(savedPath)}  ${c.dim(`(current cwd: ${currentPath})`)}`,
+    `  ${c.dim('[Enter]')} switch cwd and resume · ${c.dim('[s]')} stay here and resume anyway · ${c.dim('[n]')} cancel`,
+  ];
+  writeOverlayFrame(0, frame);
   const rl = ctx._rl || null;
   if (rl) rl.pause();
   return await new Promise((resolve) => {
@@ -353,8 +363,13 @@ export async function confirmCwdSwitch(ctx, savedPath, currentPath) {
     const cleanup = (value) => {
       process.stdin.removeListener('data', onData);
       process.stdin.setRawMode(wasRaw || false);
+      const summary = value === 'switch'
+        ? `  ${c.dim('cwd →')} ${c.brand(savedPath)}`
+        : value === 'stay'
+          ? `  ${c.dim(`staying in ${currentPath}`)}`
+          : '';
+      eraseOverlayFrame(frame.length, summary);
       if (rl) rl.resume();
-      process.stderr.write('\n');
       resolve(value);
     };
     const onData = (data) => {

package/src/terminal/repl-state.mjs

@@ -49,6 +49,19 @@ export const runtime = {
   spinInterval: null,
   spinText: '',
   spinFrame: 0,
+  // Activity phase tracking — elapsed time + progress counters on the
+  // status line. spinPhase changes reset spinStartedAt; text updates
+  // within the same phase keep the clock running so "thinking · 14s"
+  // and "explore agent · 32s · 12 calls" count up live.
+  spinPhase: null,        // 'thinking' | 'status' | `tool:<id>` | `sub:<type>` | null
+  spinStartedAt: 0,       // Date.now() when the current phase began
+  spinToolCalls: 0,       // per-phase tool-call counter (sub-agents)
+
+  // Sub-agent live tool window: while a sub-agent runs (queue active),
+  // its inner tool calls stream into a fixed-height status block (last
+  // N lines under the spinner) instead of appending to the transcript.
+  // Full detail stays on the recorded cards (/expand, /last, `d`).
+  subAgentWindow: { active: false, lines: [] },
 };
 
 // Full session state for the current CLI process. Set by the REPL loop
@@ -90,6 +103,8 @@ export const session = {
   totalCost: 0,        // accumulated session cost (USD)
   costAccurate: false, // true if backend provides per-model breakdown
   modelOverrides: {},  // session-local role -> model overrides sent to backend
+  modelMode: null,     // named mode (fast|thinking|extra|max) sent as model_mode
+  routePreference: null, // --route platform|byok; controls catalog validation only
   isByok: false,       // set from session_info; hides cost + credits when true
   // ── Subscription / credit state (server-authoritative; set from
   //    session_info + complete events) ──