@axplusb/kepler 2.0.0 → 2.0.3

package/src/onboarding/preflight.mjs

@@ -37,31 +37,44 @@ const FAIL = (s) => `${paint.state.danger('[✗]')} ${s}`;
 
 // ── Individual checks (each returns { status, label, hint? }) ──────────
 
-function checkAuthToken(auth) {
+async function checkAuthAndBackend(auth, { timeoutMs = 2500 } = {}) {
   const creds = auth.loadCredentials();
-  if (creds.token) return { status: 'ok', label: `Auth token` };
-  return { status: 'warn', label: 'Auth token missing', hint: '/login to sign in' };
-}
+  const hasToken = !!creds.token;
+  const url = creds.backendUrl;
 
-function checkProviderKey(auth) {
-  const creds = auth.loadCredentials();
-  if (creds.openRouterKey) return { status: 'ok', label: 'OpenRouter key' };
-  if (creds.anthropicKey)  return { status: 'ok', label: 'Anthropic key' };
-  if (creds.openaiKey)     return { status: 'ok', label: 'OpenAI key' };
-  if (creds.googleKey)     return { status: 'ok', label: 'Google key' };
-  return { status: 'warn', label: 'No model provider key configured', hint: 'set OPENROUTER_API_KEY or run /config' };
-}
+  // No token: just probe whether the backend is reachable so we can hint
+  // /login when it makes sense.
+  if (!hasToken) {
+    const reachable = url ? await ping(url, timeoutMs).catch(() => false) : false;
+    return reachable
+      ? { status: 'warn', label: 'Not signed in · backend ready', hint: '/login to sign in' }
+      : { status: 'warn', label: 'Not signed in · backend offline', hint: '/login once the network is back' };
+  }
 
-async function checkBackend(auth, { timeoutMs = 1500 } = {}) {
-  const creds = auth.loadCredentials();
-  const url = creds.backendUrl;
-  if (!url) return { status: 'warn', label: 'Backend not configured' };
+  // Token present: real authenticated round-trip against /api/user/me.
+  // Three outcomes: valid (200), expired (401/403), unreachable (network).
   try {
-    const reachable = await ping(url, timeoutMs);
-    if (reachable) return { status: 'ok', label: `Backend  ${shorten(url, 48)}` };
-    return { status: 'warn', label: `Backend  ${shorten(url, 48)}`, hint: 'unreachable — check network or start backend' };
+    const ctrl = new AbortController();
+    const t = setTimeout(() => ctrl.abort(), timeoutMs);
+    let resp;
+    try {
+      resp = await fetch(`${url}/api/user/me`, {
+        headers: { 'Authorization': `Bearer ${creds.token}` },
+        signal: ctrl.signal,
+      });
+    } finally { clearTimeout(t); }
+
+    if (resp.ok) {
+      const user = await resp.json().catch(() => null);
+      const who = user?.github_username || user?.email || 'user';
+      return { status: 'ok', label: `Signed in as ${who} · connected` };
+    }
+    if (resp.status === 401 || resp.status === 403) {
+      return { status: 'warn', label: 'Token expired · connected', hint: '/login again to refresh' };
+    }
+    return { status: 'warn', label: `Backend returned ${resp.status}`, hint: 'try again shortly' };
   } catch {
-    return { status: 'warn', label: `Backend  ${shorten(url, 48)}`, hint: 'unreachable' };
+    return { status: 'warn', label: 'Signed in · backend offline', hint: 'check network or try again shortly' };
   }
 }
 
@@ -83,25 +96,32 @@ function checkGit(cwd) {
 function checkLinters(cwd) {
   const present = [];
   const missing = [];
-  for (const [name, kind] of LINTERS) {
-    if (which(name)) present.push({ name, kind });
-    else if (projectUses(cwd, kind)) missing.push({ name, kind });
+  for (const linter of LINTERS) {
+    if (which(linter.bin)) present.push(linter);
+    else if (projectUses(cwd, linter.kind)) missing.push(linter);
   }
   if (present.length === 0 && missing.length === 0) {
     return { status: 'ok', label: 'Linters  none required' };
   }
   if (missing.length === 0) {
-    return { status: 'ok', label: `Linters  ${present.map(p => p.name).join(', ')}` };
+    return { status: 'ok', label: `Linters  ${present.map(p => p.bin).join(', ')}` };
   }
-  const hint = missing.map(m => `/install ${m.name} to enable lint_check for ${m.kind}`).join(' · ');
-  return { status: 'warn', label: `Linter (${missing.map(m => m.name).join(', ')}) not found`, hint };
+  // Honest install command per linter. Falls back to "install via your
+  // package manager" when there is no clean one-liner (e.g. cargo).
+  const hint = missing.map(m => m.install
+    ? `${m.bin}: ${m.install}`
+    : `install ${m.bin} for ${m.kind} support`
+  ).join(' · ');
+  return { status: 'warn', label: `Linter (${missing.map(m => m.bin).join(', ')}) not found`, hint };
 }
 
 const LINTERS = [
-  ['ruff',    'python'],
-  ['eslint',  'javascript'],
-  ['tsc',     'typescript'],
-  ['cargo',   'rust'],
+  { bin: 'ruff',    kind: 'python',     install: 'pip install ruff' },
+  { bin: 'eslint',  kind: 'javascript', install: 'npm i -g eslint' },
+  { bin: 'tsc',     kind: 'typescript', install: 'npm i -g typescript' },
+  // cargo ships with rustup; no clean one-liner — surface the warning
+  // without a misleading "/install" command.
+  { bin: 'cargo',   kind: 'rust',       install: null },
 ];
 
 function projectUses(cwd, kind) {
@@ -252,9 +272,7 @@ export async function runPreflight({ auth, cwd, version, silent = false } = {})
   write('\n' + header + '\n\n');
 
   const checks = [];
-  checks.push(checkAuthToken(auth));
-  checks.push(checkProviderKey(auth));
-  checks.push(await checkBackend(auth));
+  checks.push(await checkAuthAndBackend(auth));
   checks.push(checkGit(cwd));
   checks.push(checkLinters(cwd));
   checks.push(checkProjectMap(cwd));

package/src/terminal/repl.mjs

@@ -24,6 +24,7 @@ import { JsonlWriter } from '../core/jsonl-writer.mjs';
 import { createToolExecutor } from '../core/tool-executor.mjs';
 import { CheckpointManager } from '../core/checkpoints.mjs';
 import { runPreflight } from '../onboarding/preflight.mjs';
+import { printBanner as printBrandedBanner } from '../ui/banner.mjs';
 import { renderMissionReport, saveReport, toMarkdown as missionMarkdown } from '../ui/mission-report.mjs';
 import {
   getVerbosity,
@@ -121,6 +122,7 @@ const session = {
   costBreakdown: [],   // per-model usage: [{ model, role, input_tokens, output_tokens, cost }]
   totalCost: 0,        // accumulated session cost (USD)
   costAccurate: false, // true if backend provides per-model breakdown
+  isByok: false,       // set from session_info; hides cost + credits when true
 };
 
 // ── Commands ──
@@ -165,26 +167,15 @@ const COMMANDS = {
 // ── Banner ──
 
 function printBanner(auth) {
+  // Delegate the visual block to the branded banner module (PRD-055 §4.3,
+  // gradient KEPLER letters in Deep Space Purple → Stellar Magenta → Neon
+  // Cyan). The trailing status line stays here because it needs `auth`.
+  printBrandedBanner();
+
   const creds = auth.loadCredentials();
   const env = process.env.TARANG_ENV || 'production';
   const authStatus = creds.token ? c.green('authenticated') : c.red('/login to start');
-
-  const CYAN = '\x1b[36m';
-  const DIM = '\x1b[2m';
-  const BOLD = '\x1b[1m';
-  const YELLOW = '\x1b[33m';
-  const RST = '\x1b[0m';
-
-  process.stderr.write('\n');
-  process.stderr.write(`${DIM}         ✦${RST}\n`);
-  process.stderr.write(`${DIM}      ╭──────────────────────────╮${RST}\n`);
-  process.stderr.write(`${DIM}      │${RST}  ${BOLD}${CYAN}K · E · P · L · E · R${RST}  ${DIM}│${RST}\n`);
-  process.stderr.write(`${DIM}      ╰──────── ${YELLOW}◯${RST}${DIM} ───────────────╯${RST}\n`);
-  process.stderr.write(`${DIM}            ╱ ╲${RST}\n`);
-  process.stderr.write(`${DIM}       the agentic os${RST}\n`);
-  process.stderr.write('\n');
-  process.stderr.write(`  ${c.gray('v' + VERSION)}  ${c.dim(env)}  ${authStatus}\n`);
-  process.stderr.write('\n');
+  process.stderr.write(`  ${c.gray('v' + VERSION)}  ${c.dim(env)}  ${authStatus}\n\n`);
 }
 
 // ── Prompt Chrome ──
@@ -212,12 +203,12 @@ function printBanner(auth) {
  */
 function buildContextStrip() {
   const totalTokens = session.inputTokens + session.outputTokens;
-  const credits = formatCredits(costToCredits(session.totalCost));
   const elapsed = formatElapsed(session.startTime);
 
+  // BYOK: user pays the provider directly, suppress credits entirely.
   const right = [
     c.dim(`${formatTokens(totalTokens)} tok`),
-    c.dim(credits),
+    ...(session.isByok ? [] : [c.dim(formatCredits(costToCredits(session.totalCost)))]),
     c.dim(elapsed),
   ].join(c.dim(' · '));
 
@@ -264,7 +255,7 @@ function printTurnSummary(toolCount, durationS, turnCost) {
   const parts = [];
   if (toolCount > 0) parts.push(`${toolCount} tools`);
   if (durationS) parts.push(`${Number(durationS).toFixed(1)}s`);
-  if (turnCost > 0) parts.push(formatCredits(costToCredits(turnCost)));
+  if (turnCost > 0 && !session.isByok) parts.push(formatCredits(costToCredits(turnCost)));
   if (parts.length > 0) {
     process.stderr.write(`\n  ${c.green('✓')} ${c.dim(parts.join(' · '))}\n`);
   }
@@ -281,12 +272,39 @@ function updateStatusBar() {
  * args. The result arrives later via `renderToolResult` and is appended as a
  * gutter line. Sub-agent calls are indented per session.inSubAgent.
  */
+// Deferred-head strategy: we DON'T print the tool head when tool_call fires.
+// Instead we buffer it and let renderToolResult emit one combined line
+// "head  → outcome · duration\n". A spinner shows what's running in the
+// meantime so the user still has feedback during slow tools.
+//
+// If something else needs to print before the result arrives (a streamed
+// content event, a sub-agent open, an error, completion), we flush the
+// buffered head as a regular two-line shape first so the interleaving
+// content lands below it.
+let _pendingHead = null; // { callId, head, indent }
+
+function flushPendingHead() {
+  if (!_pendingHead) return;
+  process.stderr.write(`\n${_pendingHead.head}\n`);
+  _pendingHead = null;
+}
+
+function clearPendingHead() {
+  // Called by interleaving handlers — flush as 2-line shape (because we are
+  // about to print something else) and continue.
+  flushPendingHead();
+}
+
 function renderToolCall(data) {
   const tool = data?.tool || 'unknown';
   const args = data?.args || {};
   const indent = subAgentIndent();
   const callId = data?.call_id || data?._callId || `${tool}:${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 
+  // If a previous head is still pending (no result yet), flush it as a
+  // regular two-line shape before starting the next one.
+  flushPendingHead();
+
   const head = formatCardHead(tool, args, {
     cwd: safeCwd(),
     columns: process.stderr.columns || 120,
@@ -295,7 +313,9 @@ function renderToolCall(data) {
 
   recordCard({ id: callId, tool, args, head, startedAt: Date.now() });
   session.toolCounts[tool] = (session.toolCounts[tool] || 0) + 1;
-  process.stderr.write(`\n${head}\n`);
+  _pendingHead = { callId, head, indent };
+  // Spinner shows what's running until the result arrives.
+  startSpinner(`${tool}…`);
 }
 
 /**
@@ -314,7 +334,9 @@ function renderToolResult(data, eventType = 'tool_result') {
   const indent = subAgentIndent();
   const gutter = `${indent}${paint.text.dim('⎿')}  `;
   const callId = data.call_id || data._callId;
-  if (eventType === 'tool_done' && callId && _renderedToolResults.has(callId)) return;
+  // Either tool_result or tool_done is allowed to render — whichever wins
+  // the race. Subsequent events for the same callId are duplicates.
+  if (callId && _renderedToolResults.has(callId)) return;
   if (callId) _renderedToolResults.add(callId);
 
   const tool = data.tool || data._tool || '';
@@ -326,17 +348,44 @@ function renderToolResult(data, eventType = 'tool_result') {
   if (data._blocked) session.blockedOps++;
 
   const { text, tone: t } = summarizeResult(tool, data);
-  const arrow = paint.text.dim('→');
+  // Em dash reads more like prose than a system arrow.
+  const arrow = paint.text.dim('—');
   const painter = t === 'success' ? paint.state.success
                 : t === 'warn'    ? paint.state.warn
                 : t === 'danger'  ? paint.state.danger
                                   : paint.text.dim;
-  const duration = formatToolDuration(data);
+  // Skip the duration tail when the tool was effectively instant (<200ms) —
+  // "1ms" / "0ms" was noise that hurt the prose feel.
+  const duration = (durationMs != null && durationMs < 200) ? '' : formatToolDuration(data);
   const tail = duration ? paint.text.dim(` · ${duration}`) : '';
-  process.stderr.write(`${gutter}${arrow} ${painter(text || 'done')}${tail}\n`);
+  const outcome = `${arrow} ${painter(text || 'done')}${tail}`;
+  const hasLint = (tool === 'write_file' || tool === 'edit_file') && data.lint;
+
+  // ── 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
+  // and skip the gutter entirely.
+  if (_pendingHead && _pendingHead.callId === callId && !hasLint) {
+    const cols = process.stderr.columns || 120;
+    const combined = `${_pendingHead.head}  ${outcome}`;
+    if (stripAnsi(combined).length <= cols) {
+      process.stderr.write(`\n${combined}\n`);
+      _pendingHead = null;
+      return;
+    }
+    // Combined too wide — flush the head as 2-line and fall through.
+    flushPendingHead();
+  } else if (_pendingHead) {
+    // Stale pending head (different callId) — flush it before printing this
+    // result's gutter line below.
+    flushPendingHead();
+  }
+
+  // Two-line shape: gutter under the (already-printed or just-flushed) head.
+  process.stderr.write(`${gutter}${outcome}\n`);
 
   // Lint warnings stay visible alongside writes.
-  if ((tool === 'write_file' || tool === 'edit_file') && data.lint) {
+  if (hasLint) {
     process.stderr.write(`${gutter}${paint.state.warn('⚠ ' + String(data.lint).split('\n')[0].slice(0, 80))}\n`);
   }
 }
@@ -436,6 +485,9 @@ function startContentStream() {
 
 function appendContent(text) {
   if (!text) return;
+  // Any streamed content between renderToolCall and renderToolResult would
+  // scroll the head off "the line above", breaking the in-place collapse.
+  clearPendingHead();
   _streamBuffer += text;
   _streamedPartialText += text;
 
@@ -449,6 +501,9 @@ function flushContent() {
   if (!_streamBuffer) return;
 
   stopSpinner();
+  // Any buffered tool head needs to land BEFORE this content so the order
+  // is preserved on screen.
+  flushPendingHead();
   const rendered = renderMarkdown(_streamBuffer);
   for (const line of rendered.split('\n')) {
     process.stdout.write(`  ${line}\n`);
@@ -478,6 +533,15 @@ function renderEvent(event) {
     case 'thinking': {
       const text = data?.message || data?.text || '';
       if (text && !text.startsWith('Processing')) {
+        // Surface substantive thinking text as visible prose so the user can
+        // follow the agent's reasoning, not just see a spinner blip. We
+        // print at most one line per distinct thought, dim italic.
+        if (text.length > 12 && text !== session._lastEmittedThinking) {
+          flushPendingHead();
+          stopSpinner();
+          process.stderr.write(`  ${c.italic(c.dim(text.slice(0, 200)))}\n`);
+          session._lastEmittedThinking = text;
+        }
         startSpinner(text.slice(0, 80));
         // Capture reasoning so /why can replay it.
         session.lastReasoning = text;
@@ -621,6 +685,7 @@ function renderEvent(event) {
 
     case 'delegation': {
       stopSpinner();
+      clearPendingHead();
       const from = data?.from || '';
       const to = data?.to || '';
       session.delegations.push({ from, to, time: Date.now() });
@@ -636,6 +701,7 @@ function renderEvent(event) {
 
     case 'sub_agent_start': {
       stopSpinner();
+      clearPendingHead();
       const agentType = data?.type || 'sub-agent';
       const model = data?.model || '';
       const query = data?.query || '';
@@ -657,6 +723,7 @@ function renderEvent(event) {
 
     case 'sub_agent_complete': {
       stopSpinner();
+      clearPendingHead();
       const agentType = data?.type || 'sub-agent';
       const usage = data?.usage || {};
       const tokens = (usage.input_tokens || 0) + (usage.output_tokens || 0);
@@ -697,6 +764,9 @@ function renderEvent(event) {
       }
       if (data?.model) session.model = data.model;
       if (data?.user) session.user = { ...session.user, ...data.user };
+      // BYOK users pay their model provider directly; the platform does not
+      // charge them credits. Hide cost + credits when this flag is set.
+      if (typeof data?.is_byok === 'boolean') session.isByok = data.is_byok;
       break;
     }
 
@@ -773,8 +843,9 @@ function renderEvent(event) {
           success: successOverall,
           filesChanged: session.filesChanged,
           toolCounts: session.toolCounts,
-          subAgents: { ...session.subAgentCounts, savedUsd: session.savedUsd },
-          costUsd: turnCost || session.totalCost,
+          subAgents: { ...session.subAgentCounts, savedUsd: session.isByok ? 0 : session.savedUsd },
+          // BYOK users pay their provider directly; suppress cost in the report.
+          costUsd: session.isByok ? null : (turnCost || session.totalCost),
           durationS: data?.duration_s,
           testsPass: data?.tests_passed != null
             ? { passed: data.tests_passed, total: data.tests_total || data.tests_passed }
@@ -799,6 +870,7 @@ function renderEvent(event) {
 
     case 'paused':
       stopSpinner();
+      flushPendingHead();
       process.stderr.write(`  ${c.yellow('⏸')} Paused${data?.reason ? '  ' + c.dim(data.reason) : ''}\n`);
       break;
 
@@ -873,7 +945,11 @@ async function handleCommand(input, ctx) {
       process.stderr.write(`  ${c.dim('Turns')}        ${session.turns}\n`);
       process.stderr.write(`  ${c.dim('Tools')}        ${session.totalToolCalls} total, ${session.toolCalls} last turn\n`);
       process.stderr.write(`  ${c.dim('Duration')}     ${formatElapsed(session.startTime)}\n`);
-      process.stderr.write(`  ${c.dim('Credits')}      ${formatCredits(costToCredits(session.totalCost))}${session.costAccurate ? '' : c.dim(' (est)')}\n`);
+      if (session.isByok) {
+        process.stderr.write(`  ${c.dim('Billing')}      ${c.green('BYOK')} ${c.dim('(provider-billed)')}\n`);
+      } else {
+        process.stderr.write(`  ${c.dim('Credits')}      ${formatCredits(costToCredits(session.totalCost))}${session.costAccurate ? '' : c.dim(' (est)')}\n`);
+      }
       process.stderr.write(`  ${c.dim('CWD')}          ${safeCwd()}\n`);
 
       // Permissions
@@ -941,12 +1017,20 @@ async function handleCommand(input, ctx) {
       process.stderr.write(`  ${c.gray('Turns:')}     ${session.turns}\n`);
       process.stderr.write(`  ${c.gray('Tools:')}     ${session.toolCalls}\n`);
       process.stderr.write(`  ${c.gray('Blocked:')}   ${session.blockedOps}\n`);
-      process.stderr.write(`  ${c.gray('Credits:')}   ${formatCredits(costToCredits(session.totalCost))}${session.costAccurate ? '' : c.dim(' (est)')}\n`);
+      if (session.isByok) {
+        process.stderr.write(`  ${c.gray('Billing:')}   ${c.green('BYOK')} ${c.dim('(provider-billed)')}\n`);
+      } else {
+        process.stderr.write(`  ${c.gray('Credits:')}   ${formatCredits(costToCredits(session.totalCost))}${session.costAccurate ? '' : c.dim(' (est)')}\n`);
+      }
       process.stderr.write(`  ${c.gray('Elapsed:')}  ${formatElapsed(session.startTime)}\n\n`);
       return;
     }
 
     case '/cost': {
+      if (session.isByok) {
+        process.stderr.write(`\n  ${c.bold('Billing')}  ${c.green('BYOK')} ${c.dim('— you pay your model provider directly. Kepler does not charge credits for BYOK usage.')}\n\n`);
+        return;
+      }
       process.stderr.write(`\n  ${c.bold('Session Credits')}  ${c.brand(formatCredits(costToCredits(session.totalCost)))}`);
       if (!session.costAccurate) {
         process.stderr.write(`  ${c.yellow('(estimated)')}`);
@@ -1065,8 +1149,8 @@ async function handleCommand(input, ctx) {
         success: true,
         filesChanged: session.filesChanged,
         toolCounts: session.toolCounts,
-        subAgents: { ...session.subAgentCounts, savedUsd: session.savedUsd },
-        costUsd: session.totalCost,
+        subAgents: { ...session.subAgentCounts, savedUsd: session.isByok ? 0 : session.savedUsd },
+        costUsd: session.isByok ? null : session.totalCost,
         durationS: (Date.now() - session.startTime) / 1000,
         nextActions: ['/commit', '/pr', '/undo'],
       };
@@ -1378,19 +1462,9 @@ export async function startTerminalRepl() {
 
   const ctx = { auth, toolExecutor, approval, jsonlWriter, sessionMgr, checkpoints };
 
-  // ── Mission Control orbit + status bar ──
-  // Opt-out via KEPLER_STATUS_BAR=0 (debugging) or KEPLER_PLAIN=1 (PRD-055).
-  // status-bar.mjs already no-ops when stdout is not a TTY, but the explicit
-  // env opt-out is useful for debugging escape-sequence noise.
-  const statusBarEnabled = process.env.KEPLER_STATUS_BAR !== '0' && term().isTTY && !term().plain;
-  if (statusBarEnabled) {
-    _orbit = createOrbit();
-    attachOrbit(_orbit);
-    // Always unmount before exit so the terminal scroll region is restored.
-    process.on('beforeExit', unmountStatusBar);
-    process.on('exit',       unmountStatusBar);
-  }
-
+  // ── 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
@@ -1437,12 +1511,41 @@ export async function startTerminalRepl() {
 
   process.stderr.write(`\n  ${c.dim('Press')} ${c.brand('Enter')} ${c.dim('to start, or type a prompt below.')}\n`);
 
-  const PROMPT = `${c.brand('kepler')} ${c.dim('›')} `;
+  // Mission Control status bar is OPT-IN as of v2.0.1.
+  // Set KEPLER_STATUS_BAR=1 (or KEPLER_MISSION=1) to enable the persistent
+  // bottom-anchored ORBIT bar. Default off because the DECSTBM scroll
+  // region was eating the prompt visibility on some terminals (issue
+  // observed during v2.0.0 testing). The orbit state machine and tool
+  // cards still work without the bar — the bar is just the rendering.
+  const statusBarEnabled = (
+    process.env.KEPLER_STATUS_BAR === '1' || process.env.KEPLER_MISSION === '1'
+  ) && term().isTTY && !term().plain;
+  if (statusBarEnabled) {
+    _orbit = createOrbit();
+    attachOrbit(_orbit);
+    process.on('beforeExit', unmountStatusBar);
+    process.on('exit',       unmountStatusBar);
+  }
+
+  // The prompt label is the USER speaking, not the agent. Use the signed-in
+  // GitHub handle if known, otherwise fall back to "You".
+  //
+  // readline counts every byte of the prompt as a visible column when it
+  // computes cursor position for line-wrapping; ANSI color codes throw the
+  // math off and produce duplicated text on wrap. Wrap each escape sequence
+  // in SOH (\x01) ... STX (\x02) so readline skips it when measuring width.
+  function rlSafe(s) {
+    return String(s || '').replace(/\x1b\[[0-9;]*m/g, '\x01$&\x02');
+  }
+  function userPrompt() {
+    const who = session.user?.github_username || session.user?.email?.split('@')[0] || 'You';
+    return rlSafe(`${c.brand(who)} ${c.dim('›')} `);
+  }
 
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stderr,
-    prompt: PROMPT,
+    prompt: userPrompt(),
     completer: (line) => {
       if (line.startsWith('/')) {
         const hits = Object.keys(COMMANDS).filter(cmd => cmd.startsWith(line));
@@ -1461,6 +1564,7 @@ export async function startTerminalRepl() {
   function showPrompt() {
     printPromptBlock();
     process.stderr.write('\n');  // half-inch vertical gap above input line
+    rl.setPrompt(userPrompt());  // refresh label in case session.user resolved
     rl.prompt();
   }
 
@@ -1497,6 +1601,7 @@ export async function startTerminalRepl() {
     session.toolCounts = {};
     session.subAgentCounts = {};
     session.savedUsd = 0;
+    session._lastEmittedThinking = '';
 
     // Tell the orbit a new turn started — switches to DISCOVERY and updates
     // task / turn counters in the status bar.
@@ -1555,7 +1660,10 @@ export async function startTerminalRepl() {
         // Esc key (single byte 0x1b, not part of arrow sequence)
         if (bytes.length === 1 && bytes[0] === 0x1b) {
           stopSpinner();
-          process.stderr.write(`\n  ${c.yellow('⏹')} ${c.dim('Cancelling...')}\n`);
+          process.stderr.write(`\n  ${c.yellow('⏹')} ${c.dim('Cancelled.')}\n`);
+          // cancel() now aborts the in-flight SSE reader; the for-await loop
+          // wakes up immediately and the prompt returns. No more "stuck"
+          // Cancelling… message.
           client.cancel();
           return;
         }

package/src/terminal/tool-display.mjs

@@ -1,30 +1,33 @@
+// Present-progressive verbs — read more conversationally than "Read file":
+// "Reading auth.py  — 47 lines" reads like the agent narrating, not a log.
 const TOOL_LABELS = Object.freeze({
-  shell: 'Run command',
-  read_file: 'Read file',
-  read_files: 'Read files',
-  write_file: 'Create file',
-  write_project: 'Create project files',
-  edit_file: 'Edit file',
-  delete_file: 'Delete file',
-  list_files: 'List files',
-  search_code: 'Search code',
-  search_files: 'Search files',
-  grep: 'Search text',
-  get_file_info: 'Inspect file',
-  validate_file: 'Validate file',
-  validate_build: 'Validate build',
-  validate_structure: 'Check project structure',
-  lint_check: 'Check code quality',
-  run_tests: 'Run tests',
-  git_diff: 'Review changes',
-  git_status: 'Check repository status',
-  analyze_code: 'Analyze code',
-  explore: 'Explore codebase',
-  plan: 'Create implementation plan',
-  verify: 'Verify implementation',
-  debug: 'Debug issue',
-  refactor: 'Refactor code',
-  ask_user: 'Ask for input',
+  shell: 'Running',
+  read_file: 'Reading',
+  read_files: 'Reading',
+  write_file: 'Writing',
+  write_project: 'Writing files',
+  edit_file: 'Editing',
+  delete_file: 'Deleting',
+  list_files: 'Listing',
+  search_code: 'Searching',
+  search_files: 'Searching files',
+  grep: 'Searching for',
+  get_file_info: 'Inspecting',
+  validate_file: 'Validating',
+  validate_build: 'Validating build',
+  validate_structure: 'Checking structure',
+  lint_check: 'Linting',
+  run_tests: 'Running tests',
+  git_diff: 'Reviewing changes',
+  git_status: 'Checking git',
+  analyze_code: 'Analyzing',
+  get_project_overview: 'Indexing project',
+  explore: 'Exploring',
+  plan: 'Planning',
+  verify: 'Verifying',
+  debug: 'Debugging',
+  refactor: 'Refactoring',
+  ask_user: 'Asking',
 });
 
 export function toolDisplayLabel(tool) {