lazyclaw 6.8.0 → 6.9.0

package/commands/chat.mjs

@@ -220,6 +220,7 @@ export async function cmdChat(flags = {}) {
         setMessages: (next) => { _inkMessages = Array.isArray(next) ? next : []; },
         getProv: () => prov,
         setProv: (next) => { prov = wrapInteractiveProv(next); },
+        lookupProv,
         getActiveProvName: () => activeProvName,
         // Persist provider/model picks so they survive a restart (was
         // in-memory only — a model chosen via /model reverted to cfg.model on

package/commands/setup.mjs

@@ -13,6 +13,8 @@ import {
 import { ensureRegistry, requireRegistry, getRegistry } from '../lib/registry_boot.mjs';
 import { SUBCOMMANDS, parseArgs, AGENT_REG_SUBS } from '../lib/args.mjs';
 import { runPermissionStep } from './setup_permission.mjs';
+import { runWizardSteps } from '../tui/wizard_back.mjs';
+import { promptWithBack } from '../tui/prompt_back.mjs';
 import {
   _attachGhostAutocomplete, _fetchModelsForProvider, _pauseChatForSubMenu,
   _pickModelInteractive, _pickProviderInteractive, _printChatBanner,
@@ -170,13 +172,13 @@ export async function cmdSetup(_sub, _positional, flags = {}) {
   }
   process.stdout.write(`\n  ${ok('✓ provider:')} ${cfgAfterOnboard.provider}  ${dim('model:')} ${cfgAfterOnboard.model || '(default)'}\n\n`);
 
-  // Context window — asked right after the model pick (optional; Enter keeps
-  // defaults). Not a numbered step: it's part of the core model setup.
-  await runContextStep({ prompt: _quickPrompt, colors });
-
-  // Tool-permission mode (cfg.chat.permissionMode) — part of the core chat
-  // setup. Extracted to ./setup_permission.mjs (file-size gate).
-  await runPermissionStep({ prompt: _quickPrompt, colors, cfg: cfgAfterOnboard });
+  // Context window + tool-permission mode — core chat setup, looped so Esc on
+  // permission goes back one step to the context window (and Esc on the custom
+  // entries goes back too). Part of the model setup, not numbered steps.
+  const _backPrompt = (label) => promptWithBack(label);
+  await runWizardSteps(['context', 'permission'], (id) => (id === 'context'
+    ? runContextStep({ prompt: _quickPrompt, backPrompt: _backPrompt, colors })
+    : runPermissionStep({ prompt: _quickPrompt, backPrompt: _backPrompt, colors, cfg: cfgAfterOnboard })));
   }
 
   // ── Step 2/7: Verify one clean chat works ───────────────────

package/commands/setup_channels.mjs

@@ -303,10 +303,12 @@ export async function runWebhookStep({ prompt, colors, write = (s) => process.st
 // Context-window step (asked right after the model pick): how much past
 // conversation to keep each turn — a sliding history budget, NOT the model's
 // hard limit. Enter on both prompts keeps the defaults.
-export async function runContextStep({ prompt, colors, write = (s) => process.stdout.write(s) }) {
+// Returns 'BACK' (Esc) / 'NEXT' for the wizard back-loop. backPrompt
+// (promptWithBack) makes Esc reachable on the custom number entry.
+export async function runContextStep({ prompt, backPrompt, colors, write = (s) => process.stdout.write(s) }) {
   const { dim, ok } = colors;
   const cf = await import('../config_features.mjs');
-  const { _pickChoice } = await import('../tui/pickers.mjs');
+  const { _arrowMenu } = await import('../tui/pickers.mjs');
   const cur = cf.chatWindowGet(readConfig());
   write(`  ${dim(`Context window — how much past conversation to send each turn (sliding budget, not the model's hard limit). Now: ${cur.turns} turns · ${cur.tokens} tokens.`)}\n\n`);
   // Pick a preset (or "custom" → type the two numbers). Presets cover the
@@ -318,12 +320,23 @@ export async function runContextStep({ prompt, colors, write = (s) => process.st
     { id: 'large', label: 'Large — 80 turns · 32k tokens', desc: 'more context, costs more', turns: 80, tokens: 32000 },
     { id: 'custom', label: 'Custom…', desc: 'type your own turns + token budget' },
   ];
-  const choice = await _pickChoice('Context window', PRESETS, { subtitle: 'how much past conversation to send each turn', fallback: 'keep' });
-  if (choice === 'keep') { write(`  ${dim('— kept defaults —')}\n\n`); return { skipped: true }; }
+  // _arrowMenu (not _pickChoice) so Esc is distinguishable as BACK, not folded
+  // into the "keep" fallback.
+  const picked = await _arrowMenu({ title: 'Context window', subtitle: 'Esc to go back · how much past conversation to send each turn', items: PRESETS });
+  if (picked === 'BACK') return 'BACK';
+  const choice = (picked === 'CANCEL' || picked == null) ? 'keep' : (typeof picked === 'object' ? picked.id : picked);
+  if (choice === 'keep') { write(`  ${dim('— kept defaults —')}\n\n`); return 'NEXT'; }
   let turns, tokens;
   if (choice === 'custom') {
-    turns = parseInt((await prompt(`  turns to keep (Enter = ${cur.turns}): `)).trim(), 10);
-    tokens = parseInt((await prompt(`  token budget (Enter = ${cur.tokens}): `)).trim(), 10);
+    if (typeof backPrompt === 'function') {
+      const t = await backPrompt(`  turns to keep (Esc = back · Enter = ${cur.turns}): `); if (t && t.back) return 'BACK';
+      const k = await backPrompt(`  token budget (Esc = back · Enter = ${cur.tokens}): `); if (k && k.back) return 'BACK';
+      turns = parseInt(String((t && t.value) || '').trim(), 10);
+      tokens = parseInt(String((k && k.value) || '').trim(), 10);
+    } else {
+      turns = parseInt((await prompt(`  turns to keep (Enter = ${cur.turns}): `)).trim(), 10);
+      tokens = parseInt((await prompt(`  token budget (Enter = ${cur.tokens}): `)).trim(), 10);
+    }
   } else {
     const p = PRESETS.find((x) => x.id === choice);
     turns = p ? p.turns : NaN;
@@ -338,7 +351,7 @@ export async function runContextStep({ prompt, colors, write = (s) => process.st
   const w = cf.chatWindowGet(cfg);
   write(`  ${ok('✓ context window:')} ${w.turns} turns · ${w.tokens} tokens\n`);
   write(`  ${dim('change later: /context turns <N> | tokens <N>')}\n\n`);
-  return { skipped: false, ...w };
+  return 'NEXT';
 }
 
 // Optional orchestration step: enable the multi-agent planner+workers pipeline.

package/commands/setup_permission.mjs

@@ -5,21 +5,34 @@
 // Asks how the claude-cli agent should handle tool permissions and stores the
 // choice at cfg.chat.permissionMode. lib/permission_mode.resolvePermissionMode
 // reads it for every claude spawn; unset defaults to bypass (no nagging).
+//
+// Returns 'BACK' when the user pressed Esc (the wizard re-runs the previous
+// step), else 'NEXT'. A `backPrompt` (tui/prompt_back.promptWithBack) makes Esc
+// reachable; without it we fall back to the plain string `prompt` (no Esc).
 
 import { readConfig, writeConfig } from '../lib/config.mjs';
 import { parsePermissionChoice } from '../lib/permission_mode.mjs';
 
-export async function runPermissionStep({ prompt, colors, cfg } = {}) {
+export async function runPermissionStep({ prompt, backPrompt, colors, cfg } = {}) {
   const accent = (colors && colors.accent) || ((s) => s);
   const dim = (colors && colors.dim) || ((s) => s);
   const ok = (colors && colors.ok) || ((s) => s);
   const provider = String((cfg || readConfig()).provider || '');
   // Only relevant to the claude-cli agent path (the one that spawns `claude`).
-  if (!/claude/.test(provider)) return;
+  if (!/claude/.test(provider)) return 'NEXT';
 
   process.stdout.write(`  ${dim('Tool permissions — when the agent edits files or runs commands:')}\n`);
   process.stdout.write(`  ${dim('    bypass = never ask (fast) · ask = prompt each time · acceptEdits = auto-accept edits only · plan = read-only')}\n`);
-  const mode = parsePermissionChoice(await prompt(`  ${accent('permission')} [bypass/ask/acceptEdits/plan] ${dim('(Enter = bypass)')}: `));
+  const label = `  ${accent('permission')} [bypass/ask/acceptEdits/plan] ${dim('(Esc = back · Enter = bypass)')}: `;
+  let answer;
+  if (typeof backPrompt === 'function') {
+    const r = await backPrompt(label);
+    if (r && r.back) return 'BACK';
+    answer = r ? r.value : '';
+  } else {
+    answer = await prompt(label);
+  }
+  const mode = parsePermissionChoice(answer);
   if (mode) {
     const c = readConfig();
     c.chat = { ...(c.chat || {}), permissionMode: mode };
@@ -28,4 +41,5 @@ export async function runPermissionStep({ prompt, colors, cfg } = {}) {
   } else {
     process.stdout.write(`  ${dim('(unrecognised — kept the current setting)')}\n\n`);
   }
+  return 'NEXT';
 }

package/lib/nl_config_command.mjs

@@ -101,3 +101,22 @@ export function applyConfigCommand(intent, deps) {
   deps.writeConfig(cfg); syncCtx();
   return `✓ Workers → [\`${spec}\`].`;
 }
+
+// After an orchestrator on/off flips cfg.provider, re-point the REPL's LIVE
+// provider state from cfg — otherwise the status bar AND the next turn keep
+// using the old provider (the bug: "orchestrator off" but it still replies as
+// orchestrator). The HUD reads activeProvName and run_turn reads ctx.getProv(),
+// neither of which follows cfg.provider on its own. Best-effort; safe to call
+// from any host (missing setters are skipped).
+export function refreshLiveProvider(ctx) {
+  if (!ctx || !ctx.cfg) return;
+  const name = ctx.cfg.provider;
+  if (!name) return;
+  try { if (typeof ctx.setActiveProvName === 'function') ctx.setActiveProvName(name); } catch { /* ignore */ }
+  try {
+    const lookup = ctx.lookupProv || (ctx.registryMod && ((n) => ctx.registryMod.PROVIDERS && ctx.registryMod.PROVIDERS[n]));
+    const p = lookup && lookup(name);
+    if (p && typeof ctx.setProv === 'function') ctx.setProv(p);
+  } catch { /* ignore */ }
+  try { if (typeof ctx.setActiveModel === 'function') ctx.setActiveModel(ctx.cfg.model || null); } catch { /* ignore */ }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "6.8.0",
+  "version": "6.9.0",
   "description": "Lazy, elegant terminal CLI for chatting with Claude / OpenAI / Gemini / Ollama, orchestrating multi-step LLM workflows, and running multi-agent Slack teams with cross-task memory. Banner-on-launch, slash-command ghost autocomplete, persistent sessions, local HTTP gateway.",
   "keywords": [
     "claude",

package/tui/pickers.mjs

@@ -499,84 +499,82 @@ export async function _pickProviderInteractive() {
   }
 
   // ── Step 2 — provider in that family ──────────────────────────
-  let provider = null;
-  while (!provider) {
-    const memberNames = families[family.id].members;
-    const provItems = memberNames.map((name) => {
-      const meta = info[name] || {};
-      const isCustom = !!meta.custom;
-      const isBuiltinCompat = !!meta.builtinOpenAICompat;
-      // Step-2 desc used to preview four suggested model ids per provider.
-      // That made the row read like "gemini · models: gemini-2.5-pro ·
-      // gemini-2.5-flash · gemini-2.0-flash · gemini-2.0-flash-thinking-exp",
-      // which is too dense and partly redundant — step 3 already shows the
-      // full curated list. Keep the row to a vendor label + endpoint hint.
-      let desc = '';
-      if (isCustom) desc = `custom · ${meta.baseUrl || ''}`;
-      else if (isBuiltinCompat) desc = meta.label || meta.baseUrl || '';
-      else if (meta.label && meta.label !== name) desc = meta.label;
-      return {
-        id: name,
-        label: name,
-        desc,
-        tag: isCustom
-          ? paint('38;5;213', '[custom]')
-          : (meta.requiresApiKey ? paint('38;5;245', '[api key]') : paint('38;5;208', '[no key]')),
-      };
-    });
-    // Surface a "+ Add a new custom endpoint…" entry inside the API-key
-    // family. NIM, OpenRouter, vLLM, LM Studio, Together, Groq, etc. all
-    // speak the OpenAI Chat-Completions wire format — this single hook
-    // covers every one of them without shipping a per-vendor provider.
-    if (family.id === 'api') {
-      provItems.push({
-        id: '__add_custom__',
-        label: '+ Add a custom OpenAI-compatible endpoint…',
-        desc: 'NVIDIA NIM · OpenRouter · Together · Groq · vLLM · LM Studio · …',
-        tag: paint('38;5;213', '[new]'),
+  for (;;) {  // loop Steps 2+3: Esc in Step 3 returns to Step 2, not Step 1
+    let provider = null;
+    while (!provider) {
+      const memberNames = families[family.id].members;
+      const provItems = memberNames.map((name) => {
+        const meta = info[name] || {};
+        const isCustom = !!meta.custom;
+        const isBuiltinCompat = !!meta.builtinOpenAICompat;
+        // Step-2 row: vendor label + endpoint hint only (Step 3 shows models).
+        let desc = '';
+        if (isCustom) desc = `custom · ${meta.baseUrl || ''}`;
+        else if (isBuiltinCompat) desc = meta.label || meta.baseUrl || '';
+        else if (meta.label && meta.label !== name) desc = meta.label;
+        return {
+          id: name,
+          label: name,
+          desc,
+          tag: isCustom
+            ? paint('38;5;213', '[custom]')
+            : (meta.requiresApiKey ? paint('38;5;245', '[api key]') : paint('38;5;208', '[no key]')),
+        };
       });
+      // Surface a "+ Add a new custom endpoint…" entry inside the API-key
+      // family. NIM, OpenRouter, vLLM, LM Studio, Together, Groq, etc. all
+      // speak the OpenAI Chat-Completions wire format — this single hook
+      // covers every one of them without shipping a per-vendor provider.
+      if (family.id === 'api') {
+        provItems.push({
+          id: '__add_custom__',
+          label: '+ Add a custom OpenAI-compatible endpoint…',
+          desc: 'NVIDIA NIM · OpenRouter · Together · Groq · vLLM · LM Studio · …',
+          tag: paint('38;5;213', '[new]'),
+        });
+      }
+      if (memberNames.length === 1 && family.id !== 'api') {
+        // Auto-advance — no point making the user pick from a single row,
+        // unless we just appended the "+ Add custom" entry above.
+        provider = { id: memberNames[0] };
+        break;
+      }
+      const picked = await _arrowMenu({
+        title: `LazyClaw setup — Step 2 of 3:  pick a ${family.label} provider`,
+        subtitle: `Showing ${provItems.length} ${family.label.toLowerCase()} option(s). Type to filter.`,
+        items: provItems,
+        searchable: true,
+      });
+      if (picked === 'CANCEL') return null;
+      if (picked === 'BACK')   { family = null; return _pickProviderInteractive(); }
+      if (picked && picked.id === '__add_custom__') {
+        const added = await _addCustomProviderInteractive();
+        if (!added) continue; // back to provider list
+        // Force the registry to pick up the new entry and recompute the
+        // family bucket for the next loop iteration.
+        await ensureRegistry();
+        Object.assign(families, _providerFamilies());
+        provider = { id: added.name };
+        break;
+      }
+      provider = picked;
     }
-    if (memberNames.length === 1 && family.id !== 'api') {
-      // Auto-advance — no point making the user pick from a single row,
-      // unless we just appended the "+ Add custom" entry above.
-      provider = { id: memberNames[0] };
-      break;
-    }
-    const picked = await _arrowMenu({
-      title: `LazyClaw setup — Step 2 of 3:  pick a ${family.label} provider`,
-      subtitle: `Showing ${provItems.length} ${family.label.toLowerCase()} option(s). Type to filter.`,
-      items: provItems,
-      searchable: true,
+
+    // ── Step 3 — model picker ────────────────────────────────────────
+    // v5.3.2 — the setup wizard no longer surfaces composite providers
+    // (orchestrator is filtered out of _providerFamilies above), so this
+    // step is just the regular model picker. The orchestrator wizard
+    // (_setupOrchestratorInteractive) stays reachable via the dedicated
+    // `lazyclaw orchestrator …` subcommand and an explicit
+    // `--provider orchestrator` invocation.
+    const picked = await _pickModelInteractive(provider.id, {
+      titlePrefix: 'LazyClaw setup — Step 3 of 3:',
+      onBack: 'restart',
     });
     if (picked === 'CANCEL') return null;
-    if (picked === 'BACK')   { family = null; return _pickProviderInteractive(); }
-    if (picked && picked.id === '__add_custom__') {
-      const added = await _addCustomProviderInteractive();
-      if (!added) continue; // back to provider list
-      // Force the registry to pick up the new entry and recompute the
-      // family bucket for the next loop iteration.
-      await ensureRegistry();
-      Object.assign(families, _providerFamilies());
-      provider = { id: added.name };
-      break;
-    }
-    provider = picked;
+    if (picked === 'BACK')   continue; // Esc in Step 3 -> back to Step 2 (one step)
+    return { provider: provider.id, model: picked };
   }
-
-  // ── Step 3 — model picker ────────────────────────────────────────
-  // v5.3.2 — the setup wizard no longer surfaces composite providers
-  // (orchestrator is filtered out of _providerFamilies above), so this
-  // step is just the regular model picker. The orchestrator wizard
-  // (_setupOrchestratorInteractive) stays reachable via the dedicated
-  // `lazyclaw orchestrator …` subcommand and an explicit
-  // `--provider orchestrator` invocation.
-  const picked = await _pickModelInteractive(provider.id, {
-    titlePrefix: 'LazyClaw setup — Step 3 of 3:',
-    onBack: 'restart',
-  });
-  if (picked === 'CANCEL') return null;
-  if (picked === 'BACK')   return _pickProviderInteractive();
-  return { provider: provider.id, model: picked };
 }
 
 // _setupOrchestratorInteractive moved to tui/orchestrator_setup.mjs (it imports

package/tui/prompt_back.mjs

@@ -0,0 +1,85 @@
+// tui/prompt_back.mjs — a raw-mode line prompt that can return BACK on Esc.
+//
+// The setup wizard's typed questions used cooked-mode readline, which never
+// sees Esc (it only resolves on Enter), so "Esc to go back a step" did nothing.
+// This reads keys in raw mode: Enter submits, Esc goes back, arrow keys (which
+// are Esc-PREFIXED sequences) are ignored, Backspace edits, Ctrl-C cancels.
+//
+// classifyKey is pure (unit-tested); promptWithBack is driven by an injectable
+// input/output so it's testable with a fake TTY (no real keyboard).
+
+// Map a raw input chunk to an action. A LONE Esc is "back"; an Esc that begins
+// an escape sequence (\x1b[ or \x1bO — arrows, function keys) is "escseq" and
+// must be ignored so navigation keys don't fire "back".
+export function classifyKey(chunk) {
+  const s = String(chunk == null ? '' : chunk);
+  if (s === '\x1b') return { type: 'back' };
+  if (/^\x1b[[O]/.test(s)) return { type: 'escseq' };
+  if (s === '\r' || s === '\n' || s === '\r\n') return { type: 'submit' };
+  if (s === '\x03') return { type: 'cancel' };           // Ctrl-C
+  if (s === '\x7f' || s === '\b') return { type: 'backspace' };
+  const text = s.replace(/[\x00-\x1f\x7f]/g, '');         // strip control bytes
+  return text ? { type: 'text', text } : { type: 'ignore' };
+}
+
+// Prompt for a line, resolving { value, back }. `back` is true when the user
+// pressed Esc. Falls back to a plain (no-Esc) readline on a non-TTY input.
+// escDelayMs disambiguates a lone Esc from an Esc-sequence that arrives split
+// across two data events (rare, but some terminals do it).
+export function promptWithBack(label, opts = {}) {
+  const input = opts.input || process.stdin;
+  const output = opts.output || process.stdout;
+  const escDelayMs = opts.escDelayMs == null ? 40 : opts.escDelayMs;
+
+  if (!(input.isTTY && typeof input.setRawMode === 'function')) {
+    return _plainLine(label, input, output);
+  }
+
+  return new Promise((resolve) => {
+    output.write('\n' + label);
+    try { input.setRawMode(true); } catch { /* ignore */ }
+    input.resume();
+    let buf = '';
+    let escTimer = null;
+    const finish = (result) => {
+      if (escTimer) { clearTimeout(escTimer); escTimer = null; }
+      input.off('data', onData);
+      try { input.setRawMode(false); } catch { /* ignore */ }
+      output.write('\n');
+      resolve(result);
+    };
+    const onData = (d) => {
+      const s = d.toString('utf8');
+      // A lone Esc byte: wait briefly — if a [ / O follows it was an arrow/nav
+      // sequence (ignore), otherwise it's a real Esc (back).
+      if (s === '\x1b') {
+        escTimer = setTimeout(() => { escTimer = null; finish({ value: '', back: true }); }, escDelayMs);
+        return;
+      }
+      if (escTimer) {
+        clearTimeout(escTimer); escTimer = null;
+        if (/^[[O]/.test(s)) return;   // the tail of a split Esc-sequence
+      }
+      const k = classifyKey(s);
+      switch (k.type) {
+        case 'escseq': case 'ignore': return;
+        case 'back': return finish({ value: '', back: true });
+        case 'submit': return finish({ value: buf.trim(), back: false });
+        case 'cancel': finish({ value: '', back: false, cancel: true }); try { process.exit(130); } catch { /* tests */ } return;
+        case 'backspace': if (buf) { buf = buf.slice(0, -1); output.write('\b \b'); } return;
+        case 'text': buf += k.text; output.write(k.text); return;
+        default: return;
+      }
+    };
+    input.on('data', onData);
+  });
+}
+
+async function _plainLine(label, input, output) {
+  const readline = await import('node:readline');
+  output.write('\n');
+  const rl = readline.createInterface({ input, output });
+  const value = await new Promise((res) => rl.question(label, res));
+  rl.close();
+  return { value: String(value).trim(), back: false };
+}

package/tui/run_turn.mjs

@@ -29,7 +29,7 @@ import { Chalk } from 'chalk';
 import { chatAgenticGet, chatPlanModeGet, effectiveChatTools } from '../config_features.mjs';
 import { defaultSandboxSpec } from '../sandbox/index.mjs';
 import { resolvePermissionMode } from '../lib/permission_mode.mjs';
-import { detectConfigCommand, applyConfigCommand } from '../lib/nl_config_command.mjs';
+import { detectConfigCommand, applyConfigCommand, refreshLiveProvider } from '../lib/nl_config_command.mjs';
 import { readConfig as _readCfg, writeConfig as _writeCfg } from '../lib/config.mjs';
 
 // Force ANSI on these turn-status markers regardless of stdout TTY detection:
@@ -220,8 +220,12 @@ export function makeRunTurn({ ctx, writeFn }) {
       _msgs.push({ role: 'user', content: text });
       ctx.persistTurn('user', text);
       let reply;
-      try { reply = applyConfigCommand(_cmd, { readConfig: _readCfg, writeConfig: _writeCfg, ctxCfg: ctx.cfg }); }
-      catch (e) { reply = `⚠ couldn't apply that change: ${e?.message || e}`; }
+      try {
+        reply = applyConfigCommand(_cmd, { readConfig: _readCfg, writeConfig: _writeCfg, ctxCfg: ctx.cfg });
+        // orchestrator on/off flips the active provider — re-point the live REPL
+        // provider so it stops replying as orchestrator + the HUD refreshes.
+        if (_cmd.kind === 'orchestrator') refreshLiveProvider(ctx);
+      } catch (e) { reply = `⚠ couldn't apply that change: ${e?.message || e}`; }
       try { writeFn(reply + '\n'); } catch { /* sink best-effort */ }
       _msgs.push({ role: 'assistant', content: reply });
       ctx.persistTurn('assistant', reply);

package/tui/status_bar.mjs

@@ -4,16 +4,36 @@
 // Extracted from repl.mjs so the HUD can grow without pushing repl.mjs over the
 // file-size ratchet.
 
-import React from 'react';
+import React, { useState, useEffect } from 'react';
 import { Box, Text } from 'ink';
 import { theme } from './theme.mjs';
 import { formatHudRow, formatGauge } from './hud.mjs';
 
+// How fast the streaming dot pulses, in ms. Exported so it's not a magic number.
+export const BLINK_MS = 450;
+
+// The leading status glyph. While streaming, the dot pulses (bright ↔ dim) so
+// there's a live "something is happening" signal; idle is a steady hollow dot.
+// Pure (takes the current blink phase) so it's unit-testable without a timer.
+export function streamingIndicator(streaming, blinkOn, t = theme) {
+  if (!streaming) return t.dim('○ idle');
+  return blinkOn ? t.accent('● streaming') : t.dim('● streaming');
+}
+
 export function StatusBar({ provider, model, streaming, ctxUsed, ctxTotal, hud }) {
+  // Pulse the streaming dot. The interval only runs while streaming and is torn
+  // down as soon as the turn ends (or the bar unmounts).
+  const [blinkOn, setBlinkOn] = useState(true);
+  useEffect(() => {
+    if (!streaming) { setBlinkOn(true); return undefined; }
+    const id = setInterval(() => setBlinkOn((b) => !b), BLINK_MS);
+    return () => clearInterval(id);
+  }, [streaming]);
+
   // Numbers are computed upstream (chat-history budget, not provider self-report);
   // formatGauge only changes the RENDERING — adds percent + bar + warn marker.
   const ctx = (ctxUsed != null && ctxTotal != null) ? formatGauge(ctxUsed, ctxTotal) : '--';
-  const indicator = streaming ? theme.accent('● streaming') : theme.dim('○ idle');
+  const indicator = streamingIndicator(streaming, blinkOn);
   const prov = provider || '?';
   const mdl = model || '?';
   const hudRow = hud ? formatHudRow(hud) : '';

package/tui/wizard_back.mjs

@@ -0,0 +1,19 @@
+// tui/wizard_back.mjs — drive a sequence of setup-wizard steps with Esc-back.
+//
+// Each step runs its own I/O and returns one of:
+//   'BACK'   — the user pressed Esc → re-run the previous step
+//   'CANCEL' — abort the whole group
+//   (anything else) — advance to the next step
+// Esc on the FIRST step stays on it (there's nothing before it in the group).
+// Pure control flow (the steps do the prompting) so it's unit-testable.
+
+export async function runWizardSteps(stepIds, runStep) {
+  let i = 0;
+  while (i < stepIds.length) {
+    const r = await runStep(stepIds[i], i);
+    if (r === 'CANCEL') return 'CANCEL';
+    if (r === 'BACK') { i = i > 0 ? i - 1 : 0; continue; }
+    i += 1;
+  }
+  return 'DONE';
+}