@tiens.nguyen/gonext-cli 1.0.350

package/gonext-repl.mjs

@@ -0,0 +1,2648 @@
+#!/usr/bin/env node
+/**
+ * `gonext` — terminal agent REPL (P6).
+ *
+ * Run it inside any project folder:
+ *   $ cd ~/Projects/my-repo
+ *   $ gonext
+ *
+ * It offers to register the CURRENT folder as an agent workspace (with a trust prompt
+ * that maps to --allow-run), authenticates with the worker key from ~/.gonext/worker.env
+ * (the same file `gonext-cli set` / the Wizard write), and loops on a `>> `
+ * prompt. Each question is ENQUEUED as a normal agent_chat job (models/budgets/RAG
+ * resolved from your user settings by POST /api/worker/agent-ask) and executed by the
+ * RUNNING gonext-cli daemon — so its terminal shows the full [gonext-agent]
+ * logs, exactly like a web question. The REPL polls the job and streams the persisted
+ * chunks live into the terminal.
+ *
+ * Conversation history is saved to ~/.gonext/sessions/<hash-of-folder-path>.json after
+ * every turn and reloaded on the next `gonext` in the SAME folder — so closing the
+ * terminal and coming back later still has context (e.g. "continue" after an
+ * interrupted investigation actually resumes it). /reset clears it.
+ *
+ * Requires the worker daemon to be running (it claims the job).
+ * Commands: /exit  /model  /reset  /revert [runId]  /help   Ctrl-C stops following the current run.
+ */
+import { readFile, mkdir, writeFile, unlink } from "node:fs/promises";
+import { existsSync, statSync, readFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+import { dirname, join, resolve, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
+import dotenv from "dotenv";
+
+const DIR = dirname(fileURLToPath(import.meta.url));
+
+// Running version, from the package's own package.json (task #105) — shown in the REPL
+// banner so it's clear which build is running.
+const REPL_VERSION = (() => {
+  try {
+    return createRequire(import.meta.url)("./package.json").version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+})();
+const ENV_FILE = join(homedir(), ".gonext", "worker.env");
+const WS_FILE = join(homedir(), ".gonext", "workspaces.json");
+const SESSIONS_DIR = join(homedir(), ".gonext", "sessions");
+
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const white = (s) => `\x1b[37m${s}\x1b[0m`;
+// ANSI 90 ("bright black") — a reliable neutral grey across terminal themes, unlike
+// code 34 (blue) which many dark-theme palettes render as purple/indigo instead.
+const codeColor = (s) => `\x1b[90m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+// Hover highlight for the clickable thinking line (task #96): just shift the color a little
+// toward white (no bold/underline/anchor) so it subtly signals "hovered" without looking like
+// a link. 97 = bright white.
+const hoverThought = (s) => `\x1b[97m${s}\x1b[0m`;
+
+// The worker's "still thinking" heartbeat lines look like "Caffeinating… (90s)" — we
+// SWALLOW them from the terminal (the local ticker below drives progress instead), and
+// also drop the worker's ~~~ stream fences (they only matter to the web renderer).
+const isHeartbeatLine = (line) => /…\s?\(\d+s\)\s*$/.test(line);
+const isFenceLine = (line) => line.trim() === "~~~";
+// The model's raw Python code blob is delimited by <code>/</code> tags. We don't print
+// the tags themselves, but the code IN BETWEEN prints in a distinct grey (codeColor)
+// instead of dim prose, so it visually separates from the "Thought:" reasoning.
+// Tolerant matching, NOT exact-line: the raw token stream often mangles the tags —
+// glued to content ("<codecreate_folder(...)"), missing the ">", duplicated, or the
+// close tag stuck on the code's last line — and exact matching printed those
+// fragments literally in mixed colors (user-reported).
+const CODE_OPEN_RE = /^<code(?:\s*>)?/; // applied to line.trim()
+const CODE_CLOSE_RE = /<\/code>?\s*$/;
+const isBareCloseTag = (t) => /^<\/code>?$/.test(t);
+// The step summary the worker emits right after a tool call finishes (e.g.
+// "unzip_file(...) | → Unzipped 256 files…") duplicates what's already visible in the
+// gonext-cli daemon's own terminal — swallow it here to keep the REPL terse.
+const isToolStepSummary = (line) => / \| → /.test(line);
+// The router's internal play-by-play ("Routing your request…", "→ Agent mode (needs
+// tools)", "→ Chat reply", "Choosing a tool…", "Composing a reply…") is implementation
+// detail, not something a user needs — also visible in the daemon's own terminal.
+// Swallowed; see routingAnnounced. "Composing a reply…" specifically must be included so
+// it doesn't print (undimmed, since plainReplyFlow is already true by then) right before
+// the real streamed answer, where it would visually blend into the answer text.
+const isRoutingLine = (line) =>
+  /^(Routing your request…|Choosing a tool…|Composing a reply…|→ Agent mode.*|→ Chat reply)$/.test(
+    line.trim()
+  );
+// The edit tools (edit_lines/edit_file/create_file) emit a multi-line "edit card"
+// as one step event — a small stable line protocol rendered here as a colored diff
+// (bold header, red '-' / green '+' lines, dim line numbers). Shapes must stay in
+// sync with _render_edit_card in gonext_agent_chat.py:
+//   ⏺ Update(XeroForwardService.java)
+//     └ Replaced lines 19-19 with 1 line
+//       19 -     ...old...
+//       19 +     ...new...
+//       … (+3 more)
+const isEditCardHeader = (line) => /^⏺ (Update|Create)\(.+\)/.test(line);
+const EDIT_DIFF_RE = /^(\s{4})(\d+) ([-+]) (.*)$/;
+const isEditCardBody = (line) =>
+  /^\s*└ /.test(line) || EDIT_DIFF_RE.test(line) || /^\s{4}… /.test(line);
+
+// Playful words for the local "thinking…" ticker, reused verbatim from the worker's
+// thinking_words.txt sibling (falls back to a tiny built-in list if it's missing).
+const THINKING_WORDS = (() => {
+  try {
+    return readFileSync(join(DIR, "thinking_words.txt"), "utf8")
+      .split("\n")
+      .map((l) => l.trim())
+      .filter((l) => l && !l.startsWith("#"));
+  } catch {
+    return ["Thinking", "Percolating", "Cogitating", "Noodling", "Ruminating"];
+  }
+})();
+const pickWord = () =>
+  THINKING_WORDS[Math.floor(Math.random() * THINKING_WORDS.length)] || "Thinking";
+// In-progress ("blinking") spinner for the step being worked on. 30 styles that rotate
+// ~every 8s so a long CPU-bound wait stays interesting — mirrors the web agent's set
+// (keep in sync with the .spin-N @keyframes in web/src/App.css). Single-width glyphs so
+// they never shift the text after them.
+const SPINNERS = [
+  "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏", "│╱─╲", "▁▃▄▅▆▇▆▅▄▃", "←↖↑↗→↘↓↙", "▏▎▍▌▋▊▉▊▋▌▍▎",
+  "◴◷◶◵", "◐◓◑◒", "⣾⣽⣻⢿⡿⣟⣯⣷", "▖▘▝▗", "✶✸✹✺✹✷",
+  "⠁⠂⠄⡀⢀⠠⠐⠈", "dqpb", "◢◣◤◥", "✦✧", "◜◝◞◟",
+  "▌▀▐▄", "◰◳◲◱", "┤┘┴└├┌┬┐", "▘▝▗▖", "▸▹",
+  "⢄⢂⢁⡁⡈⡐⡠", "▙▛▜▟", "▂▃▄▅▆▇█▇▆▅▄▃", "⣿⣷⣯⣟⡿⢿⣻⣽", "⎺⎻⎼⎽",
+  "•◦", "░▒▓█▓▒", "◇◈◆", "·✢✳✽", "◠◡",
+].map((s) => [...s]);
+// The playful word's color cycles ~every 2.5s (xterm-256 palette matching the web accents:
+// green, cyan, blue, indigo, pink, amber).
+const WAIT_COLORS_256 = [120, 87, 111, 147, 218, 221];
+const color256 = (n, s) => `\x1b[38;5;${n}m${s}\x1b[0m`;
+const orange = (s) => color256(208, s); // peak-token label (task #84)
+// Compact token count: 950 → "950", 12300 → "12.3k", 1500000 → "1.5M" (task #83).
+const fmtTokens = (n) => {
+  if (n < 1000) return String(n);
+  if (n < 1_000_000) return `${(n / 1000).toFixed(n < 100_000 ? 1 : 0)}k`;
+  return `${(n / 1_000_000).toFixed(1)}M`;
+};
+const BULLET = "●"; // a completed action
+
+// ---------- flags ----------
+const argv = process.argv.slice(2);
+if (argv.includes("--help") || argv.includes("-h")) {
+  console.log(
+    "gonext — terminal agent REPL for the current folder\n\n" +
+      "Usage: gonext [-v|--verbose]\n\n" +
+      "  -v, --verbose   show the agent's diagnostic logs ([gonext-agent] …) and python stderr\n" +
+      "  -h, --help      this help\n\n" +
+      "Auth comes from ~/.gonext/worker.env; models/budgets/RAG come from your web Settings.\n" +
+      "Inside the REPL: /exit · /model · /reset · /revert [runId] · /help — Ctrl-C stops following a turn.\n" +
+      "Questions are enqueued like web questions and executed by the RUNNING\n" +
+      "gonext-cli daemon — its terminal shows the full [gonext-agent] logs.\n" +
+      "Conversation history is saved per-folder in ~/.gonext/sessions and resumed next time\n" +
+      "you run `gonext` in the same folder; /reset forgets it and starts fresh."
+  );
+  process.exit(0);
+}
+if (argv.includes("-v") || argv.includes("--verbose")) {
+  process.env.GONEXT_REPL_VERBOSE = "1";
+}
+
+// ---------- auth: worker key + API base from ~/.gonext/worker.env ----------
+dotenv.config({ path: ENV_FILE });
+dotenv.config();
+let workerKey = String(process.env.GONEXT_WORKER_KEY ?? "").trim();
+let apiBase = String(process.env.GONEXT_API_BASE ?? "").trim().replace(/\/+$/, "");
+// Task #127 (BC1a): "configured" = BOTH key AND api-base present. When either is missing,
+// first-run login instead of a dead end — but ONLY interactively; a piped/CI invocation
+// still fails fast with guidance (so scripts don't hang on a browser prompt). An EXISTING
+// user with a full worker.env skips all of this and behaves exactly as before (BC1).
+if (!workerKey || !apiBase) {
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    try {
+      const { deviceLogin, DEFAULT_API_BASE } = await import("./device-login.mjs");
+      console.log(
+        dim("gonext: first-time setup — let's connect this machine to your account.")
+      );
+      const r = await deviceLogin({
+        apiBase: apiBase || DEFAULT_API_BASE,
+        log: (s) => console.log(s),
+      });
+      workerKey = r.workerKey;
+      apiBase = r.apiBase;
+    } catch (e) {
+      console.error(red(`gonext: login failed: ${e instanceof Error ? e.message : e}`));
+      if (e && e.code === "PAIRING_UNSUPPORTED") {
+        console.error(
+          "Configure manually: gonext-cli set <workerKey> --api-base https://chat-api-v2.gomarsic.cc"
+        );
+      }
+      process.exit(1);
+    }
+  } else {
+    console.error(
+      red("gonext: no worker key / API base found.") +
+        `\nRun ${cyan("gonext-cli login")} to sign in, or configure manually:` +
+        "\n  gonext-cli set <workerKey> --api-base https://chat-api-v2.gomarsic.cc"
+    );
+    process.exit(1);
+  }
+}
+
+// Line intake: attach the listener IMMEDIATELY so lines that arrive while startup
+// awaits (workspace prompt fetch, payload probe) are queued instead of lost — vital
+// for piped/scripted input, harmless for interactive TTYs. Both ask() and the main
+// loop consume from this queue (never rl.question, to avoid double-capture).
+//
+// terminal: true (on real TTYs) with readline OWNING the prompt via setPrompt/prompt().
+// History of this setting: plain terminal:true with a MANUALLY-written ">> " once caused
+// a stray "[" artifact — readline redrew the input line using its own (empty, never-set)
+// prompt and cursor tracking that our un-announced writes had made stale. The interim
+// fix (terminal:false) traded that for something worse: the OS's canonical line
+// discipline echoes raw CSI bytes, so arrows/Home/End showed literal "^[[D" and mid-line
+// editing didn't work at all (user-reported). Giving readline the prompt makes its
+// redraw math correct — rl.prompt() resets the cursor state after every burst of our
+// output — and raw mode means backspace/arrows/↑-history all behave like a normal shell.
+// Single source of truth for the REPL's slash commands — drives Tab-completion, the
+// unknown-command guard, and /help, so they can never drift.
+const COMMANDS = [
+  { name: "/model", desc: "switch the coding model for this session" },
+  { name: "/test-auto", desc: "toggle auto-test (verify & fix until it passes) for this folder" },
+  { name: "/rag-local", desc: "toggle storing this folder's RAG knowledge base locally (vs cloud/S3)" },
+  { name: "/server", desc: "pick a deployment server (host/user) for this session" },
+  { name: "/revert", usage: "/revert [runId]", desc: "undo the agent's file edits (latest run)" },
+  { name: "/reset", aliases: ["/new"], desc: "forget this folder's saved conversation and start fresh" },
+  { name: "/output-token", desc: "show the agent code-model OUTPUT-token total for this workspace" },
+  { name: "/reset-output-token-global", desc: "reset the GLOBAL (you + coding server) output-token total to 0" },
+  { name: "/help", desc: "list these commands" },
+  { name: "/exit", aliases: ["/quit"], desc: "quit" },
+];
+const COMMAND_NAMES = COMMANDS.flatMap((c) => [c.name, ...(c.aliases ?? [])]);
+// Tab-completion: when the line starts with "/", complete against the command names.
+function slashCompleter(line) {
+  if (!line.startsWith("/")) return [[], line];
+  const hits = COMMAND_NAMES.filter((n) => n.startsWith(line));
+  return [hits.length ? hits : COMMAND_NAMES, line];
+}
+// Commands whose name/alias matches the typed prefix (all when prefix is "" or "/").
+function filteredCommands(prefix = "") {
+  const p = (prefix ?? "").trim();
+  const m = COMMANDS.filter(
+    (c) =>
+      !p ||
+      p === "/" ||
+      [c.name, ...(c.aliases ?? [])].some((n) => n.startsWith(p))
+  );
+  return m.length ? m : COMMANDS;
+}
+// Display rows for a filtered command set; row `sel` (if >=0) is highlighted (❯ + bold).
+function hintRows(cmds, sel) {
+  const rows = [dim("  commands  (↑/↓ select · Enter run · Tab complete):")];
+  cmds.forEach((c, i) => {
+    const label = c.usage ?? c.name;
+    const alias = c.aliases?.length ? dim(` (${c.aliases.join(", ")})`) : "";
+    const body = `${cyan(label)}${alias}${dim(" — " + c.desc)}`;
+    rows.push(i === sel ? `${green("❯")} ${bold(body)}` : `  ${body}`);
+  });
+  return rows;
+}
+// Permanent print (used by /help and a lone-"/" submit — scrolls with history).
+function printCommands(prefix = "") {
+  for (const r of hintRows(filteredCommands(prefix), -1)) console.log(r);
+  console.log("");
+}
+
+const IS_TTY = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+const rl = createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  terminal: IS_TTY,
+  completer: slashCompleter,
+});
+const PROMPT = cyan(">> ");
+rl.setPrompt(PROMPT);
+// Side effect of terminal:false above: readline no longer intercepts arrow keys for
+// command-history recall, so pressing ↑/↓/→/← (or Home/End/Delete) sends the RAW escape
+// bytes straight through as literal input — the OS's own canonical line discipline
+// doesn't understand them either, so they get echoed and end up IN the submitted line
+// once Enter is pressed (seen live: a task sent to the model started with a literal
+// "\x1b[A" from an accidental up-arrow press). Strip CSI escape sequences (ESC '[' …
+// final-byte) from every submitted line so stray arrow-key presses can't corrupt task
+// text sent to the model.
+const stripAnsiEscapes = (s) => String(s ?? "").replace(/\x1b\[[0-9;]*[A-Za-z~]/g, "");
+// A fetch() failure (DNS, connection reset, timeout) throws rather than returning a
+// response — recognize it so the poll loop can treat it as a transient blip, not a hard
+// stop. Node's fetch throws a TypeError ("fetch failed") wrapping the socket error.
+const isNetworkError = (e) =>
+  e instanceof TypeError ||
+  /fetch failed|network|ECONN|ETIMEDOUT|EAI_AGAIN|socket hang up|und_err|terminated/i.test(
+    String(e?.message ?? e)
+  );
+const _lineQueue = [];
+let _lineWaiter = null;
+let _stdinClosed = false;
+let slashHintRows = 0; // live slash-command hint rows drawn below the prompt (0 = none)
+let slashSel = -1; // highlighted row in the current filtered list (-1 = none)
+let slashNames = []; // command names in the current filtered list (for Enter → run)
+let slashPrefix = ""; // the "/…" text the user typed (restored when ↑/↓ recall history)
+rl.on("line", (l) => {
+  // A list picker owns the keyboard (its Enter resolves via the keypress handler) — never
+  // let that Enter submit a stray empty line into the command loop.
+  if (listPickerActive) {
+    rl.line = "";
+    rl.cursor = 0;
+    return;
+  }
+  // While a turn is running, IGNORE typed input entirely — no type-ahead, no queued
+  // next question. Only Ctrl+C (handled via SIGINT) does anything mid-turn. Clear the
+  // line buffer so nothing the user typed leaks into the next prompt.
+  if (following) {
+    rl.line = "";
+    rl.cursor = 0;
+    return;
+  }
+  // Enter left the cursor on the row where the live slash-hint started — erase it so the
+  // command's own output doesn't print over/under a stale hint block. If a menu item was
+  // highlighted (↑/↓), RUN that command instead of the raw typed line.
+  let submitted = l;
+  if (slashOverlayActive) {
+    // A highlighted menu item (↑/↓) RUNS that command instead of the raw typed line.
+    if (slashSel >= 0 && slashNames[slashSel]) submitted = slashNames[slashSel];
+    closeSlashOverlay(); // wipe the menu, re-enable readline, restore history
+    // readline's own newline echo was suppressed during the overlay — emit it so the
+    // command's output starts on a fresh line, not over the ">> …" input line (#109).
+    process.stdout.write("\r\n");
+  }
+  const clean = stripAnsiEscapes(submitted);
+  if (_lineWaiter) {
+    const w = _lineWaiter;
+    _lineWaiter = null;
+    w(clean);
+  } else {
+    _lineQueue.push(clean);
+  }
+});
+// Neutralize navigation keys (↑/↓ history recall, ←/→ cursor, Home/End, etc.) during a
+// turn: echo is already muted, but readline still recalls history into the invisible
+// buffer on ↑/↓ — reset the line state after every keypress so nothing accumulates or
+// moves. Ctrl+C is unaffected (readline emits its SIGINT before this handler runs).
+// Live command hint = an EPHEMERAL, SELECTABLE overlay drawn BELOW the prompt while the
+// line starts with "/". It redraws as you type (narrowing), ↑/↓ move a highlight, Enter
+// runs the highlighted command, and it DISAPPEARS when you clear the slash — no permanent
+// scrollback copies. Relative cursor moves so it survives terminal scrolling.
+// (slashSel / slashNames / slashPrefix are declared above, near rl.on("line").)
+// While the slash-hint overlay is open, EMPTY readline's history so ↑/↓ don't recall a
+// history entry and trigger readline's OWN line-refresh — that refresh fought our overlay
+// and reprinted the whole ">> /" + hint block on every arrow press (bug #109). With no
+// history to recall, readline's ↑/↓ are inert and our keypress handler owns the highlight.
+// Restored the instant the overlay closes, so normal task-history recall still works.
+let _slashSavedHistory = null;
+function slashNeutralizeHistory() {
+  if (_slashSavedHistory === null && Array.isArray(rl.history)) {
+    _slashSavedHistory = rl.history;
+    rl.history = [];
+    rl.historyIndex = -1;
+  }
+}
+function slashRestoreHistory() {
+  if (_slashSavedHistory !== null) {
+    rl.history = _slashSavedHistory;
+    _slashSavedHistory = null;
+    rl.historyIndex = -1;
+  }
+}
+// While the overlay is active WE own all terminal drawing: readline's own echo +
+// line-refresh are no-op'd (see slashOverlayActive in _writeToOutput/_refreshLine
+// below), exactly like the /server + approval pickers. That's what makes the redraw
+// stable — readline can't clearScreenDown over our menu or fight our cursor (bug #109,
+// which the earlier relative-cursor overlay hit whenever readline refreshed or the
+// menu was near the bottom of the screen and scrolled).
+let slashOverlayActive = false;
+// While true, readline's echo + line-refresh are muted so a typed secret (an API key) never
+// reaches the terminal or scrollback (task #127 — see askSecret + the _writeToOutput guards).
+let secretInput = false;
+
+// Visible width of PROMPT (">> ") — used to put the caret back on the input line by
+// COLUMN, since the string itself carries color escapes that don't occupy cells.
+const PROMPT_COLS = 3;
+
+// Truncate to `max` VISIBLE columns, keeping the ANSI color escapes (which occupy no
+// cells) intact. Essential for the overlay: every row it draws must fit on ONE physical
+// terminal row — see slashOverlaySeq for why a wrapped row corrupts the redraw.
+function clipVisible(s, max) {
+  if (max <= 0) return "";
+  let out = "", seen = 0, sawEscape = false;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "\x1b") {
+      const m = /^\x1b\[[0-9;]*m/.exec(s.slice(i));
+      if (m) { out += m[0]; i += m[0].length - 1; sawEscape = true; continue; }
+    }
+    if (seen >= max) return out + (sawEscape ? "\x1b[0m" : "");
+    out += s[i];
+    seen++;
+  }
+  return out;
+}
+
+// Build the exact bytes that draw the overlay: the input line (">> " + typed text) with
+// the command menu below it, caret left on the input line.
+//
+// Bug #109 v3 — the ↑/↓ stacking. TWO things have to hold for an in-place redraw, and the
+// old version got the first right and the second wrong:
+//
+//  1. NO ABSOLUTE ANCHOR. The old code re-anchored each redraw with DECSC/DECRC
+//     (ESC 7 / ESC 8), an absolute screen position, after pre-scrolling "reserved" rows
+//     into existence. There is one save slot per terminal and its meaning changes as soon
+//     as the screen scrolls, so it is fragile. Every move here is RELATIVE (ESC[nA) or
+//     column-absolute within the current row (ESC[nG), like drawList() (the /server
+//     picker), which has always redrawn correctly.
+//
+//  2. NO WRAPPED ROWS — this is what actually bit the user. `ESC[nA` moves up n PHYSICAL
+//     rows, but `n` here is the number of LOGICAL menu rows. On a narrow terminal a row
+//     like "  /model — switch the coding model for this session" occupies TWO physical
+//     rows, so the walk back up lands short, the next redraw's "\r ESC[2K" clears the
+//     wrong line, and a SECOND ">> /" + menu block is painted below the first — exactly
+//     the reported "it prints the item on every ↑". Verified in a terminal model: at 40
+//     columns the uncorrected version produces three prompt rows. So every row is clipped
+//     to the viewport width, which makes logical rows and physical rows the same thing.
+//     (This is also why the /server picker never showed the bug: its rows are short.)
+function slashOverlaySeq(line, cursor, menu, cols) {
+  const width = Math.max(20, cols || 80);
+  const n = menu.length;
+  let out = "\r\x1b[2K" + clipVisible(PROMPT + line, width - 1);
+  for (const r of menu) out += "\n\x1b[2K" + clipVisible(r, width - 1);
+  // Wipe anything left below (the filtered list can SHRINK as you type), then walk back
+  // up to the input line and park the caret at the typed-text offset.
+  out += "\x1b[J";
+  if (n > 0) out += `\x1b[${n}A`;
+  out += `\r\x1b[${Math.min(width, PROMPT_COLS + cursor + 1)}G`;
+  return out;
+}
+
+// Redraw the input line AND the command menu below it, fully in place.
+function renderSlashOverlay(sel) {
+  const line = rl.line;
+  const cmds = filteredCommands(line);
+  slashNames = cmds.map((c) => c.name);
+  if (sel >= cmds.length) sel = cmds.length - 1;
+  slashSel = sel;
+  slashPrefix = line;
+  const menu = hintRows(cmds, sel);
+  if (!slashOverlayActive) {
+    slashOverlayActive = true;
+    slashNeutralizeHistory();
+  }
+  slashHintRows = menu.length;
+  process.stdout.write(
+    slashOverlaySeq(line, rl.cursor ?? line.length, menu, process.stdout.columns)
+  );
+}
+
+// Close the overlay: erase the menu below, keep the typed input line, hand drawing back
+// to readline. Callers that changed the line to a non-slash value should refresh after.
+// Relative moves only, for the same reason as above.
+function closeSlashOverlay() {
+  if (!slashOverlayActive) {
+    slashRestoreHistory();
+    return;
+  }
+  process.stdout.write(
+    slashCloseSeq(rl.line, rl.cursor ?? rl.line.length, process.stdout.columns)
+  );
+  slashOverlayActive = false;
+  slashHintRows = 0;
+  slashSel = -1;
+  slashNames = [];
+  slashRestoreHistory();
+}
+
+// Bytes that tear the menu down: repaint the input line, erase everything below it, and
+// leave the caret back on the input line at the typed-text offset.
+function slashCloseSeq(line, cursor, cols) {
+  const width = Math.max(20, cols || 80);
+  return (
+    "\r\x1b[2K" + clipVisible(PROMPT + line, width - 1) + // clean, non-wrapping input row
+    "\n\x1b[J" +                      // step below, erase the menu (and anything under it)
+    "\x1b[1A" +                       // back up to the input row (relative)
+    `\r\x1b[${Math.min(width, PROMPT_COLS + cursor + 1)}G`
+  );
+}
+// A window resize reflows every row, so the overlay's row arithmetic (and the width it
+// clipped to) is stale the moment it happens: rows that fit before may now wrap, which is
+// precisely what made the menu stack in the first place (#109 v3). Redraw at the new width
+// — the render ends with ESC[J, so a block that used to be taller leaves no orphans behind.
+if (process.stdout.isTTY) {
+  process.stdout.on("resize", () => {
+    if (!slashOverlayActive) return;
+    try {
+      renderSlashOverlay(slashSel);
+    } catch {
+      closeSlashOverlay(); // never let a resize wedge the prompt
+    }
+  });
+}
+if (process.stdin.isTTY) {
+  process.stdin.on("keypress", (_ch, key) => {
+    // An arrow-key list picker (/server) is up → ↑/↓ move the highlight, Enter chooses.
+    if (listPickerActive) {
+      onListKey(key);
+      rl.line = "";
+      rl.cursor = 0;
+      rl.historyIndex = -1;
+      return;
+    }
+    // A command-approval picker is up → arrow keys move the highlight, Enter chooses.
+    if (approvalActive) {
+      onApprovalKey(key);
+      rl.line = "";
+      rl.cursor = 0;
+      rl.historyIndex = -1;
+      return;
+    }
+    if (following) {
+      rl.line = "";
+      rl.cursor = 0;
+      rl.historyIndex = -1;
+      return;
+    }
+    // Enter is handled by rl.on("line") — don't redraw the hint on the way out.
+    if (key && (key.name === "return" || key.name === "enter")) return;
+    // ↑/↓ while the menu is up = move the highlight IN PLACE. readline drawing is
+    // suppressed (slashOverlayActive) and history neutralized, so its own ↑/↓ do
+    // nothing — we just move the selection and re-render the overlay (bug #109).
+    if (slashOverlayActive && key && (key.name === "up" || key.name === "down")) {
+      rl.historyIndex = -1;
+      const n = slashNames.length;
+      if (n > 0) {
+        slashSel =
+          key.name === "down" ? (slashSel + 1 + n) % n : (slashSel - 1 + n) % n;
+      }
+      renderSlashOverlay(slashSel);
+      return;
+    }
+    if (rl.line.startsWith("/")) {
+      // Typing narrows the list and resets the selection to none.
+      renderSlashOverlay(-1);
+    } else if (slashOverlayActive) {
+      // The line no longer starts with "/" (e.g. backspaced the slash away): tear down
+      // the overlay and let readline redraw the now-normal line.
+      closeSlashOverlay();
+      rl._refreshLine();
+    }
+  });
+}
+rl.on("close", () => {
+  _stdinClosed = true;
+  if (_lineWaiter) {
+    const w = _lineWaiter;
+    _lineWaiter = null;
+    w(null);
+  }
+});
+// Mouse hover+click on the thinking line (task #96): while a turn runs we turn ON xterm
+// ANY-MOTION tracking so we can both HIGHLIGHT the line as the mouse hovers it AND expand it
+// on click (see runAgentTurn). Trade-off the user accepted: with tracking on, the terminal's
+// own drag-to-select/copy is captured by us — the user holds Option/Shift to select text
+// meanwhile. ?1003 = report every button press/release AND all mouse MOTION (needed for hover
+// with no button held); ?1006 = SGR extended coords (no 223-col cap). We disable ?1000/?1002
+// too on teardown in case a terminal had them latched.
+const MOUSE_ON = "\x1b[?1003h\x1b[?1006h";
+const MOUSE_OFF = "\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?1006l";
+let _mouseEnabled = false;
+const enableMouse = () => {
+  if (_mouseEnabled || !process.stdin.isTTY) return;
+  process.stdout.write(MOUSE_ON);
+  _mouseEnabled = true;
+};
+const disableMouse = () => {
+  if (!_mouseEnabled) return;
+  process.stdout.write(MOUSE_OFF);
+  _mouseEnabled = false;
+};
+// Safety net: never leave the user's terminal in mouse-reporting mode (would break their
+// shell's selection) if we exit ungracefully.
+process.on("exit", disableMouse);
+// SGR mouse report: ESC [ < btn ; col ; row (M=press, m=release). btn bit 32 = MOTION
+// (hover/drag), bit 64 = wheel; low 2 bits = which button (0=left). A left CLICK is a press
+// (M) with motion+wheel bits clear and low bits 0; a HOVER is any event with the motion bit.
+const MOUSE_RE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
+// Cursor Position Report reply to our `\x1b[6n` probe: ESC [ row ; col R. We probe right after
+// clearing the status (cursor is then at the status block's TOP row) to learn the thought
+// line's ABSOLUTE viewport row — so hover/click hit-testing is exact even when the block isn't
+// at the bottom of the screen (task #96 fix). No `<`, so it never collides with MOUSE_RE.
+const DSR_RE = /\x1b\[(\d+);(\d+)R/g;
+const nextLine = () =>
+  _lineQueue.length > 0
+    ? Promise.resolve(_lineQueue.shift())
+    : _stdinClosed
+      ? Promise.resolve(null)
+      : new Promise((res) => (_lineWaiter = res));
+const ask = async (q) => {
+  // Route the question through readline's own prompt so its redraw logic stays
+  // consistent (a raw stdout write here would re-create the stale-cursor artifact
+  // that terminal:true mode is designed to avoid). Restored to ">> " afterwards.
+  rl.setPrompt(q);
+  rl.prompt();
+  const a = await nextLine();
+  rl.setPrompt(PROMPT);
+  return (a ?? "").trim();
+};
+// Yes/no prompt with an explicit default. Empty input (just Enter) → the default;
+// otherwise the FIRST non-space character decides (y*→yes, n*→no), and anything else
+// re-uses the default. This replaces a fragile `(await ask()) || "y"` idiom where any
+// leftover character (a stray escape byte, a stray space) silently defeated the
+// default — the reported "[Y/n] + Enter registered as No" bug.
+// Masked prompt for a secret (an API key). Mutes readline's echo/refresh (secretInput)
+// so the typed value never hits the terminal or scrollback (task #127). Returns "" on a
+// bare Enter (skip).
+const askSecret = async (q) => {
+  process.stdout.write(q);
+  secretInput = true;
+  try {
+    const a = await nextLine();
+    return (a ?? "").trim();
+  } finally {
+    secretInput = false;
+    process.stdout.write("\n"); // the muted Enter left the cursor mid-line
+  }
+};
+const askYesNo = async (question, defaultYes) => {
+  const suffix = defaultYes ? " [Y/n] " : " [y/N] ";
+  const raw = (await ask(question + suffix)).trim().toLowerCase();
+  if (!raw) return defaultYes; // just Enter → the default
+  if (raw[0] === "y") return true;
+  if (raw[0] === "n") return false;
+  return defaultYes; // unrecognized → default (never silently flip it)
+};
+
+// ---------- workspace registration for the current folder ----------
+async function readWorkspaces() {
+  try {
+    const raw = JSON.parse(await readFile(WS_FILE, "utf8"));
+    return Array.isArray(raw?.workspaces) ? raw.workspaces : [];
+  } catch {
+    return [];
+  }
+}
+
+async function ensureWorkspace() {
+  const cwd = resolve(process.cwd());
+  const list = await readWorkspaces();
+  const hit = list.find((w) => cwd === w.path || cwd.startsWith(w.path + "/"));
+  if (hit) {
+    // Registered before cloud sync existed → ask once and persist. Otherwise honor the
+    // stored choice. (undefined = old record that never opted in → ask.)
+    if (hit.allowSync === undefined) {
+      hit.allowSync = await askYesNo(
+        "Allow syncing this workspace's chat history to the cloud?", true
+      );
+      await writeFile(WS_FILE, JSON.stringify({ workspaces: list }, null, 2) + "\n");
+    }
+    wsSync = { enabled: hit.allowSync !== false, name: hit.name, path: hit.path };
+    console.log(
+      dim(
+        `workspace: ${hit.name} → ${hit.path} (run ${hit.allowRun ? "enabled" : "disabled"}` +
+          `${hit.allowSync !== false ? ", cloud sync on" : ""})`
+      )
+    );
+    return;
+  }
+  if (!existsSync(cwd) || !statSync(cwd).isDirectory()) return;
+  console.log(`This folder is not a registered workspace:\n  ${cwd}`);
+  const register = await askYesNo(
+    "Register it so the agent can read/edit code here?", true /* default Yes */
+  );
+  if (!register) {
+    console.log(dim("Skipped — the agent will not be able to touch files here."));
+    return;
+  }
+  const allowRun = await askYesNo(
+    "Do you trust this folder — allow the agent to RUN build/test commands\n" +
+      "(npm test, mvn, pytest…)?",
+    true /* default Yes — you opened THIS folder with gonext deliberately, and the
+            action-first workflows (start/test/build the project) need it; commands are
+            still allowlisted (npm/mvn/pytest/…) and run with a scrubbed env. Type n to
+            keep a workspace read/edit-only. */
+  );
+  const allowSync = await askYesNo(
+    "Allow syncing this workspace's chat history to the cloud?\n" +
+      "(your conversation is saved to your account so you can see it on the web app)",
+    true /* default Yes — RAG is NOT synced (it stays on your S3); only chat history. */
+  );
+  const next = list.filter((w) => w.path !== cwd);
+  next.push({
+    name: basename(cwd),
+    path: cwd,
+    allowRun,
+    allowSync,
+    addedAt: new Date().toISOString(),
+  });
+  await mkdir(dirname(WS_FILE), { recursive: true });
+  await writeFile(WS_FILE, JSON.stringify({ workspaces: next }, null, 2) + "\n");
+  wsSync = { enabled: allowSync, name: basename(cwd), path: cwd };
+  console.log(
+    green(`✓ workspace registered: ${basename(cwd)}`) +
+      (allowRun ? green(" (run-commands enabled)") : dim(" (run-commands disabled)")) +
+      (allowSync ? green(" · cloud sync on") : dim(" · cloud sync off"))
+  );
+}
+
+// ---------- conversation persistence, keyed by folder ----------
+// Without this, closing the terminal (or restarting `gonext`) loses ALL context — the
+// next session starts from a blank slate even though the USER remembers the earlier
+// investigation. "continue" (and general follow-ups) only make sense across restarts if
+// there's something real on disk to continue FROM. Same hash-keying scheme the worker's
+// python side already uses for per-URL RAG work dirs (sha256, 32 hex chars), applied
+// here to the workspace path instead so returning to the SAME folder reloads the SAME
+// conversation.
+function sessionFilePath(cwd) {
+  const hash = createHash("sha256").update(cwd).digest("hex").slice(0, 32);
+  return join(SESSIONS_DIR, `${hash}.json`);
+}
+
+// Cap what's kept on disk — the worker already truncates what it actually SENDS to the
+// model by a char budget (see "history: N prior turn(s), M chars (budget 8000)" in its
+// logs), so persisting more than that budget could ever use is just unbounded growth
+// for a long-lived folder with no benefit.
+const MAX_PERSISTED_MESSAGES = 40;
+
+// Cloud sync (task #47), opt-in per workspace. Set by ensureWorkspace() for the current
+// folder; when enabled, saveSession/clearSession also mirror the chat history to Mongo
+// via the worker-authed /api/worker/workspace-sync. RAG is NOT synced (stays on S3).
+let wsSync = { enabled: false, name: "", path: "" };
+const workspaceKeyFor = (cwd) =>
+  createHash("sha256").update(cwd).digest("hex").slice(0, 32);
+
+// Task #104: agent CODE-model OUTPUT-token counters. The API keys the workspace total on
+// workspaceKey and the GLOBAL total on (userId + coding-model URL). Task #125: the REPL
+// now supplies the URL of the backend in EFFECT this session (activeCodingUrl) so the
+// global total follows a /model backend switch; empty → the API falls back to the
+// account-default URL from settings (older behaviour). All best-effort (never block a turn).
+const activeCodingUrl = () => sessionCodingUrl || defaultCodingUrl;
+
+// Task #126: the footer's global "↓" for the CURRENT backend. The saved-full-responses sum
+// (savedResponsesTotal) is authoritative per-URL — and correct even for turns before #125,
+// because each saved row carries its own url — so PREFER it when it has data. Fall back to
+// the #125 incremental counter (globalTotal) when Save-Full-Response is off (no saved rows,
+// so savedResponsesTotal is 0), which keeps a correct non-zero number instead of a
+// surprising 0. Returns null when the response had neither, so callers keep the old value.
+function pickGlobalTotal(t) {
+  if (!t) return null;
+  const saved = Number.isFinite(t.savedResponsesTotal) ? t.savedResponsesTotal : 0;
+  if (saved > 0) return saved;
+  return Number.isFinite(t.globalTotal) ? t.globalTotal : null;
+}
+
+async function fetchOutputTokenTotals(cwd) {
+  try {
+    const qs = new URLSearchParams({ workspaceKey: workspaceKeyFor(cwd) });
+    if (activeCodingUrl()) qs.set("codingUrl", activeCodingUrl());
+    const r = await fetch(`${apiBase}/api/worker/output-tokens?${qs.toString()}`, {
+      headers: { "X-Worker-Key": workerKey },
+    });
+    if (!r.ok) return null;
+    return await r.json();
+  } catch {
+    return null;
+  }
+}
+
+async function addOutputTokens(cwd, delta) {
+  if (!(delta > 0)) return null;
+  try {
+    const r = await fetch(`${apiBase}/api/worker/output-tokens`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
+      body: JSON.stringify({
+        workspaceKey: workspaceKeyFor(cwd),
+        delta,
+        codingUrl: activeCodingUrl(),
+      }),
+    });
+    if (!r.ok) return null;
+    return await r.json();
+  } catch {
+    return null;
+  }
+}
+
+// Save the agent coding-model API key (task #127): the terminal prompts for the Kimi K3 key
+// when the default cloud coder has none, and POSTs it here (worker-key authed). Returns true
+// on success. Best-effort — a failure just leaves the reminder for next startup.
+async function saveCodingKey(apiKey) {
+  try {
+    const r = await fetch(`${apiBase}/api/worker/coding-key`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
+      body: JSON.stringify({ apiKey }),
+    });
+    return r.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function resetGlobalOutputTokens() {
+  try {
+    const r = await fetch(`${apiBase}/api/worker/output-tokens/reset-global`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
+      body: JSON.stringify({ codingUrl: activeCodingUrl() }),
+    });
+    return r.ok;
+  } catch {
+    return false;
+  }
+}
+
+async function pushWorkspaceSync(cwd, history, { del = false } = {}) {
+  if (!wsSync.enabled) return;
+  const body = del
+    ? { workspaceKey: workspaceKeyFor(cwd), delete: true }
+    : {
+        workspaceKey: workspaceKeyFor(cwd),
+        name: wsSync.name || basename(cwd),
+        path: cwd,
+        history: history.slice(-MAX_PERSISTED_MESSAGES),
+      };
+  try {
+    await fetch(`${apiBase}/api/worker/workspace-sync`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
+      body: JSON.stringify(body),
+    });
+  } catch {
+    // Best-effort — a cloud-sync blip must never block the REPL (local save already done).
+  }
+}
+
+async function loadSession(cwd) {
+  try {
+    const raw = JSON.parse(await readFile(sessionFilePath(cwd), "utf8"));
+    return Array.isArray(raw?.history) ? raw.history : [];
+  } catch {
+    return [];
+  }
+}
+
+// The /test-auto choice is remembered per folder (stored alongside history in the same
+// session file). Read it once at startup so the banner and agent-ask reflect it.
+async function loadSessionTestAuto(cwd) {
+  try {
+    const raw = JSON.parse(await readFile(sessionFilePath(cwd), "utf8"));
+    return raw?.testAuto === true;
+  } catch {
+    return false;
+  }
+}
+
+// The /server deploy-target pick is also remembered per folder, so a fresh terminal in
+// the same project still knows where to deploy (task #69 — it was session-only and got
+// lost on restart). Returns {name,host,user} or null.
+async function loadSessionServer(cwd) {
+  try {
+    const raw = JSON.parse(await readFile(sessionFilePath(cwd), "utf8"));
+    const s = raw?.deployServer;
+    return s && typeof s.host === "string" && typeof s.user === "string" ? s : null;
+  } catch {
+    return null;
+  }
+}
+
+// Peak single-request agent-code-model token count remembered per folder (task #84).
+async function loadSessionMaxCodeTokens(cwd) {
+  try {
+    const raw = JSON.parse(await readFile(sessionFilePath(cwd), "utf8"));
+    return Number.isFinite(raw?.maxCodeTokens) ? raw.maxCodeTokens : 0;
+  } catch {
+    return 0;
+  }
+}
+
+// RAG storage backend remembered per folder (task #97): "local" | "cloud" | null (never
+// chosen → we ask once at startup). Local keeps the index on disk under ~/.gonext; cloud
+// uses the user's S3 bucket (the original behavior).
+async function loadSessionRagMode(cwd) {
+  try {
+    const raw = JSON.parse(await readFile(sessionFilePath(cwd), "utf8"));
+    return raw?.ragMode === "local" || raw?.ragMode === "cloud" ? raw.ragMode : null;
+  } catch {
+    return null;
+  }
+}
+
+// Persist just the RAG-mode choice without touching history (used at startup, before the
+// full session is loaded). Read-merge-write so nothing else in the file is lost.
+async function saveSessionRagMode(cwd, mode) {
+  try {
+    let raw = {};
+    try {
+      raw = JSON.parse(await readFile(sessionFilePath(cwd), "utf8")) || {};
+    } catch {
+      raw = {};
+    }
+    raw.ragMode = mode;
+    raw.updatedAt = new Date().toISOString();
+    await mkdir(SESSIONS_DIR, { recursive: true });
+    await writeFile(sessionFilePath(cwd), JSON.stringify(raw, null, 2) + "\n");
+  } catch (err) {
+    console.error(dim(`(rag-mode save failed: ${err.message})`));
+  }
+}
+
+async function saveSession(cwd, history) {
+  try {
+    await mkdir(SESSIONS_DIR, { recursive: true });
+    const trimmed = history.slice(-MAX_PERSISTED_MESSAGES);
+    await writeFile(
+      sessionFilePath(cwd),
+      JSON.stringify(
+        {
+          cwd,
+          updatedAt: new Date().toISOString(),
+          testAuto: sessionTestAuto,
+          deployServer: selectedServer, // remember the /server pick per folder (task #69)
+          maxCodeTokens: sessionMaxCodeTokens, // peak per-request tokens (task #84)
+          ragMode: sessionRagMode, // local vs cloud RAG for this folder (task #97)
+          history: trimmed,
+        },
+        null,
+        2
+      ) + "\n"
+    );
+  } catch (err) {
+    // Non-fatal — losing session persistence should never crash or block the REPL.
+    console.error(dim(`(session save failed: ${err.message})`));
+  }
+  // Mirror to the cloud AFTER the local write (fire-and-forget; opt-in via wsSync).
+  void pushWorkspaceSync(cwd, history);
+}
+
+async function clearSession(cwd) {
+  try {
+    await unlink(sessionFilePath(cwd));
+  } catch {
+    // Nothing on disk to clear — fine.
+  }
+  void pushWorkspaceSync(cwd, [], { del: true }); // /reset removes the cloud copy too
+}
+
+// ---------- fetch the ready-to-run agent payload from user settings ----------
+// /model command: fetch the allowed coding models (default + web-curated whitelist),
+// show a numbered picker, and set sessionCodingModel to the choice for this session.
+async function chooseModel() {
+  let probe;
+  try {
+    probe = await fetchAgentPayload([{ role: "user", content: "ping" }]);
+  } catch (err) {
+    console.log(red(`  couldn't load models: ${err.message}\n`));
+    return;
+  }
+  const allowed = Array.isArray(probe?.codingAllowed) ? probe.codingAllowed : [];
+  const def = (probe?.codingDefault ?? "").trim();
+  // Task #123: a choice is a (backend, model) PAIR — several backends (Ollama, an
+  // OpenAI-compatible endpoint, local MLX) can be enabled at once, and picking one moves
+  // the URL, the kind and the API key with it. `codingChoices` carries the backend of each
+  // entry so the list can say which is which; `codingAllowed` is the same ids, and stays
+  // the fallback for an API that predates this.
+  const choices = Array.isArray(probe?.codingChoices) && probe.codingChoices.length
+    ? probe.codingChoices
+    : allowed.map((id) => ({ id, model: id, kind: "" }));
+  if (choices.length === 0) {
+    console.log(dim("  No coding model configured. Set one in the web app → Settings → Agent.\n"));
+    return;
+  }
+  if (choices.length === 1) {
+    console.log(
+      dim(`  Only one coding model is available: ${choices[0].model}.\n`) +
+        dim("  Add more in the web app → Settings → Agent → Coding backends.\n")
+    );
+    return;
+  }
+  const active = sessionCodingModel || def;
+  // Arrow-key picker (↑/↓ + Enter) — pre-highlight the active model, tag the default, and
+  // name the backend when more than one is in play (the same model name can appear twice).
+  const KIND_LABEL = { ollama: "Ollama", openai: "OpenAI-compatible", local: "local MLX", "": "auto" };
+  const showKind = new Set(choices.map((c) => c.kind ?? "")).size > 1;
+  const labels = choices.map((c) => {
+    const kind = showKind ? `  ${dim(`· ${KIND_LABEL[c.kind ?? ""] ?? c.kind}`)}` : "";
+    return `${c.model}${kind}${c.id === def ? "  (default)" : ""}`;
+  });
+  const activeIdx = choices.findIndex((c) => c.id === active);
+  console.log(dim("  Choose the coding model  (↑/↓ then Enter):"));
+  const idx = await pickFromList(labels, activeIdx >= 0 ? activeIdx : 0);
+  if (idx < 0) {
+    console.log(dim("  (cancelled)\n"));
+    return;
+  }
+  const chosen = choices[idx];
+  // Empty override means "use the account default" — so don't send an override when the
+  // user picks the default (keeps the payload clean and lets a later default change win).
+  sessionCodingModel = chosen.id === def ? "" : chosen.id;
+  // Remember the friendly name for the token footer, which should never show a raw
+  // "<kind>::<model>" wire id.
+  sessionCodingLabel = chosen.id === def ? "" : chosen.model;
+  // Task #125: remember the chosen backend's coding URL so the GLOBAL output-token total is
+  // keyed to it. Default pick → "" so activeCodingUrl() falls back to defaultCodingUrl.
+  sessionCodingUrl = chosen.id === def ? "" : (chosen.url ?? "");
+  const where = showKind ? ` (${KIND_LABEL[chosen.kind ?? ""] ?? chosen.kind})` : "";
+  console.log(
+    green(`  ✓ coding model → ${chosen.model}${where}${chosen.id === def ? " (default)" : ""}\n`)
+  );
+  // Task #125: the GLOBAL lifetime total is per-backend, so re-fetch it for the newly
+  // selected backend NOW — otherwise the footer would keep showing the previous backend's
+  // total until the next turn. (The live per-turn tail, latestOutputTokens, is local to
+  // runAgentTurn and is already 0 here between turns — /model can't run mid-turn — so there
+  // is nothing to zero, and it isn't in scope from here.)
+  const t = await fetchOutputTokenTotals(resolve(process.cwd()));
+  { const g = pickGlobalTotal(t); if (g !== null) globalOutputTokens = g; }
+}
+
+// Probe whether SSH KEY auth already works for a server (so we can tell the user to run
+// ssh-copy-id if not). BatchMode=yes = never prompt for a password → exit!=0 if no key.
+async function checkServerKeyAuth(s) {
+  try {
+    const ok = await new Promise((resolve) => {
+      const p = spawn(
+        "ssh",
+        [
+          "-o", "BatchMode=yes",
+          "-o", "ConnectTimeout=6",
+          "-o", "StrictHostKeyChecking=accept-new",
+          `${s.user}@${s.host}`,
+          "true",
+        ],
+        { stdio: "ignore" }
+      );
+      p.on("exit", (code) => resolve(code === 0));
+      p.on("error", () => resolve(false));
+    });
+    if (ok) console.log(dim("    ✓ key auth works — deploys will connect without a password."));
+    else
+      console.log(
+        yellow("    key auth not set up yet.") +
+          dim(` Run once in your terminal:  `) +
+          `ssh-copy-id ${s.user}@${s.host}`
+      );
+  } catch {
+    /* best-effort check — never block the picker */
+  }
+}
+
+// /server — pick a deployment target (from the web app's Servers registry) for this
+// session. Host/user only, never a secret; the agent deploys here with KEY auth (#69).
+async function chooseServer() {
+  let servers;
+  try {
+    const res = await fetch(`${apiBase}/api/worker/deploy-servers`, {
+      headers: { "X-Worker-Key": workerKey },
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      console.log(red(`  couldn't load servers: ${data?.error || `HTTP ${res.status}`}\n`));
+      return;
+    }
+    servers = Array.isArray(data?.servers) ? data.servers : [];
+  } catch (err) {
+    console.log(red(`  couldn't load servers: ${err.message}\n`));
+    return;
+  }
+  if (servers.length === 0) {
+    console.log(dim("  No deployment servers yet — add them in the web app → Servers.\n"));
+    return;
+  }
+  // Arrow-key picker: ↑/↓ to move, Enter to choose (no number typing). The list ends with
+  // a "none" row to clear the selection. Pre-highlight the current pick if there is one.
+  const labels = servers.map((s) => `${s.name}  (${s.user}@${s.host})`);
+  labels.push("none (clear selection)");
+  const activeIdx = servers.findIndex((s) => s.host === selectedServer?.host);
+  console.log(dim("  Choose a deployment server  (↑/↓ then Enter):"));
+  const idx = await pickFromList(labels, activeIdx >= 0 ? activeIdx : 0);
+  if (idx < 0) {
+    console.log(dim("  (cancelled)\n"));
+    return;
+  }
+  if (idx === servers.length) {
+    // the trailing "none" row
+    selectedServer = null;
+    console.log(dim("  ✓ deployment server cleared.\n"));
+    return;
+  }
+  const s = servers[idx];
+  selectedServer = { name: s.name, host: s.host, user: s.user };
+  console.log(green(`  ✓ deploy target → ${s.name} (${s.user}@${s.host})`));
+  await checkServerKeyAuth(selectedServer);
+  console.log("");
+}
+
+async function fetchAgentPayload(messages) {
+  const res = await fetch(`${apiBase}/api/worker/agent-payload`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
+    body: JSON.stringify({ messages }),
+  });
+  const text = await res.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    data = {};
+  }
+  if (!res.ok) {
+    if (res.status === 404) {
+      throw new Error(
+        "the API does not have POST /api/worker/agent-payload yet — deploy the latest API (sam build && sam deploy)."
+      );
+    }
+    // Task #127 (BC1b): a present-but-INVALID worker key (rotated/revoked while worker.env
+    // kept the stale one) shows up as 401/403. Point the user at re-login rather than a
+    // generic error — we don't proactively re-validate the key, so the first rejection is
+    // where this surfaces.
+    if (res.status === 401 || res.status === 403) {
+      throw new Error(
+        "your worker key was rejected (it may have been rotated or revoked). " +
+          "Run `gonext-cli login` to sign in again, or update it with " +
+          "`gonext-cli set <workerKey> --api-base <url>`."
+      );
+    }
+    throw new Error(data?.error || `agent-payload failed (HTTP ${res.status})`);
+  }
+  return data;
+}
+
+// ---------- run one agent turn via the JOB QUEUE (the daemon executes it) ----------
+// The question is enqueued exactly like a web question, so the RUNNING
+// gonext-cli daemon claims + executes it — its terminal shows the full
+// [gonext-agent] logs. We poll the job here and stream the persisted chunks live.
+let following = false;
+let followAborted = false;
+let currentJobId = null; // the running turn's jobId — so Ctrl+C can cancel it server-side
+let cancelRequested = false; // a cancel POST has been sent for the current turn
+// Interactive command-approval gate: while the agent is paused on a risky command, the
+// terminal shows a Yes/No list picker (↑/↓ + Enter, Yes preselected). approvalActive
+// routes keystrokes to the picker; approvalResolve settles the awaiting promise once.
+let approvalActive = false;
+let approvalSel = 0; // 0 = Yes (default highlighted), 1 = No
+let approvalResolve = null;
+// The active turn's live-status wiper (its local clearStatus), or null between turns. A
+// picker calls this before drawing so the "Almost done…/thought/token" block is gone
+// first — otherwise the 120ms ticker keeps redrawing that block on top of the picker and
+// its relative-cursor math lands on the wrong rows (duplicated/interleaved options).
+let clearActiveStatus = null;
+function drawApprovalOptions(redraw) {
+  // Two option lines, redrawn in place. On redraw the cursor sits one row below "No";
+  // step up 2 rows, clear+rewrite both, landing back where we started.
+  const yes = approvalSel === 0 ? green("▸ Yes") : dim("  Yes");
+  const no = approvalSel === 1 ? green("▸ No") : dim("  No");
+  process.stdout.write((redraw ? "\x1b[2A" : "") + "\x1b[K" + yes + "\n\x1b[K" + no + "\n");
+}
+function finishApproval(allow) {
+  if (!approvalActive) return;
+  approvalActive = false;
+  // Settle the picker: overwrite the two option lines with a single result line.
+  process.stdout.write("\x1b[2A\x1b[J" + (allow ? green("  ▸ Yes — running it") : red("  ▸ No — skipped")) + "\n");
+  const r = approvalResolve;
+  approvalResolve = null;
+  if (r) r(!!allow);
+}
+function onApprovalKey(key) {
+  if (!key) return;
+  if (key.name === "up" || key.name === "down") {
+    approvalSel = key.name === "up" ? 0 : 1; // 2 options: up=Yes, down=No
+    drawApprovalOptions(true);
+  } else if (key.name === "return" || key.name === "enter") {
+    finishApproval(approvalSel === 0);
+  }
+  // Ctrl+C is delivered via readline "SIGINT" (onInterrupt), which also denies — see there.
+}
+// Show the picker and resolve to the user's choice. Non-TTY (piped) can't pick → deny
+// (safe). Auto-denies after ~170s so an absent user never hangs the turn (and stays
+// under the python side's 180s wait); Enter is instant since Yes is preselected.
+// The command carries a "__MAXSTEP__::<message>" sentinel when it's the step-budget
+// continue prompt (task #80) rather than a risky-command approval. That case shows a
+// 3-option picker (Yes / Yes-don't-ask-again / No); a normal command shows Yes/No.
+// Returns { allow, dontAsk } — dontAsk is only ever true for the max-step "don't ask
+// again this session" choice (the caller then stops sending the prompt).
+const MAXSTEP_PREFIX = "__MAXSTEP__::";
+const TIMEOUT_PREFIX = "__TIMEOUT__::";
+const COMPACT_PREFIX = "__COMPACT__::";
+async function approvalPrompt(command) {
+  // Wipe the live "thinking" status block BEFORE any picker draws, and stop the ticker from
+  // redrawing it (the tick early-returns while a picker is active) — otherwise the block
+  // reappears under the options and corrupts the layout.
+  if (clearActiveStatus) clearActiveStatus();
+  // Context-compaction prompt (task #87 rec#3): the running context got large. Ask whether
+  // to aggressively compact older steps. No answer in 30s = No (keep full detail — the safe
+  // default; the always-on auto-trim still bounds things).
+  if (command.startsWith(COMPACT_PREFIX)) {
+    const label = command.slice(COMPACT_PREFIX.length);
+    if (!process.stdin.isTTY) return { allow: false, dontAsk: false };
+    process.stdout.write("\n" + yellow("🗜 " + label) + dim("  (no answer in 30s = keep full)") + "\n");
+    const idx = await pickFromList(
+      ["Yes, compact older steps", "No, keep full detail"],
+      0,
+      { timeoutMs: 30000, timeoutIndex: 1 }
+    );
+    return { allow: idx === 0, dontAsk: false };
+  }
+  // Time-budget prompt (task #81): the agent hit its wall-clock budget. Ask whether to
+  // keep waiting; auto-answer No after 60s of no input so the run can't hang forever.
+  if (command.startsWith(TIMEOUT_PREFIX)) {
+    const label = command.slice(TIMEOUT_PREFIX.length);
+    if (!process.stdin.isTTY) return { allow: false, dontAsk: false };
+    process.stdout.write("\n" + yellow("⏳ " + label) + dim("  (no answer in 60s = stop)") + "\n");
+    const idx = await pickFromList(
+      ["Yes, keep waiting", "No, stop now"],
+      0,
+      { timeoutMs: 60000, timeoutIndex: 1 }
+    );
+    return { allow: idx === 0, dontAsk: false };
+  }
+  const isMax = command.startsWith(MAXSTEP_PREFIX);
+  if (isMax) {
+    const label = command.slice(MAXSTEP_PREFIX.length);
+    if (!process.stdin.isTTY) return { allow: false, dontAsk: false };
+    process.stdout.write("\n" + yellow("⏭ " + label) + "\n");
+    const idx = await pickFromList(
+      ["Yes, keep going", "Yes, and don't ask again this session", "No, stop here"],
+      0
+    );
+    return { allow: idx === 0 || idx === 1, dontAsk: idx === 1 };
+  }
+  const allow = await new Promise((resolve) => {
+    if (!process.stdin.isTTY) {
+      process.stdout.write(dim(`\n(approval needed for: ${command} — no interactive terminal, skipping)\n`));
+      resolve(false);
+      return;
+    }
+    process.stdout.write(
+      "\n" + yellow("⚠ Allow running this command?") + "\n" + dim("  " + command) + "\n"
+    );
+    approvalSel = 0;
+    approvalResolve = resolve;
+    approvalActive = true;
+    drawApprovalOptions(false);
+    const t = setTimeout(() => finishApproval(false), 170000);
+    const orig = resolve;
+    approvalResolve = (v) => {
+      clearTimeout(t);
+      orig(v);
+    };
+  });
+  return { allow, dontAsk: false };
+}
+// Generic arrow-key list picker (↑/↓ + Enter) — used by /server so you navigate instead
+// of typing a number. Same mechanism as the Yes/No approval picker above, generalized to
+// N rows. Returns the chosen index (or -1 on Esc/Ctrl+C). Works OUTSIDE a turn, so it also
+// mutes readline echo/refresh (see the _writeToOutput/_refreshLine guards) via listPickerActive.
+let listPickerActive = false;
+let listSel = 0;
+let listItems = [];
+let listResolve = null;
+function drawList(redraw) {
+  const n = listItems.length;
+  const body = listItems
+    .map((it, i) => "\x1b[K" + (i === listSel ? green("▸ " + it) : dim("  " + it)))
+    .join("\n");
+  process.stdout.write((redraw ? `\x1b[${n}A` : "") + body + "\n");
+}
+function finishList(index) {
+  if (!listPickerActive) return;
+  listPickerActive = false;
+  process.stdout.write(`\x1b[${listItems.length}A\x1b[J`); // wipe the list block
+  const r = listResolve;
+  listResolve = null;
+  listItems = [];
+  if (r) r(index);
+}
+function onListKey(key) {
+  if (!key) return;
+  const n = listItems.length;
+  if (key.name === "up") {
+    listSel = (listSel - 1 + n) % n;
+    drawList(true);
+  } else if (key.name === "down") {
+    listSel = (listSel + 1) % n;
+    drawList(true);
+  } else if (key.name === "return" || key.name === "enter") {
+    finishList(listSel);
+  } else if (key.name === "escape" || (key.ctrl && key.name === "c")) {
+    finishList(-1);
+  }
+}
+function pickFromList(items, initialSel = 0, opts = {}) {
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY || items.length === 0) {
+      resolve(-1);
+      return;
+    }
+    listItems = items;
+    listSel = Math.max(0, Math.min(initialSel, items.length - 1));
+    listResolve = resolve;
+    listPickerActive = true;
+    drawList(false);
+    // Optional auto-resolve after opts.timeoutMs (task #81 time-budget prompt): if the
+    // user doesn't choose in time, finish with opts.timeoutIndex (default -1). Wrap
+    // listResolve so any real selection clears the timer.
+    if (opts && opts.timeoutMs > 0) {
+      const to = setTimeout(
+        () => finishList(opts.timeoutIndex ?? -1),
+        opts.timeoutMs
+      );
+      const orig = listResolve;
+      listResolve = (v) => {
+        clearTimeout(to);
+        orig(v);
+      };
+    }
+  });
+}
+
+// Cancel whichever approval picker is currently showing (Yes/No or the N-row list),
+// resolving it as a DENY. Used when the job ends server-side while we're still waiting
+// for the user, so the picker promise never leaks and no late choice is sent (#110).
+function cancelActivePicker() {
+  if (approvalActive) finishApproval(false);
+  if (listPickerActive) finishList(-1);
+}
+
+// Show an approval picker, but RACE it against the job going terminal. The old code
+// awaited the picker INLINE inside the poll loop, so while the user thought, the REPL
+// stopped polling and couldn't notice that python had already given up (its own approval
+// deadline) and completed the job — the user's late "Yes" then hit a finished job and was
+// silently lost (#110). Here a background watcher polls the job; if it goes
+// completed/failed/cancelled first, we dismiss the picker and report `ended:true` so the
+// caller skips the POST and lets the normal terminal-status handling run.
+async function approvalPromptRacingJob(command) {
+  let watching = true;
+  const watcher = (async () => {
+    while (watching) {
+      await sleep(1000);
+      if (!watching) return null;
+      try {
+        const r = await fetch(`${apiBase}/api/worker/jobs/${jobIdForApprovalRace}`, {
+          headers: { "X-Worker-Key": workerKey },
+        });
+        if (!r.ok) continue;
+        const j = await r.json().catch(() => ({}));
+        if (
+          j?.jobStatus === "completed" ||
+          j?.jobStatus === "failed" ||
+          j?.jobStatus === "cancelled"
+        ) {
+          return "ended";
+        }
+      } catch {
+        /* transient poll error — keep watching */
+      }
+    }
+    return null;
+  })();
+  const picker = approvalPrompt(command).then((r) => ({ kind: "answer", ...r }));
+  const raced = await Promise.race([
+    picker,
+    watcher.then((v) => (v === "ended" ? { kind: "ended" } : new Promise(() => {}))),
+  ]);
+  watching = false;
+  if (raced.kind === "ended") {
+    cancelActivePicker(); // unblock the picker promise so it doesn't leak
+    await picker.catch(() => {}); // let it settle after the cancel
+    return { ended: true, allow: false, dontAsk: false };
+  }
+  // The user answered first — stop the watcher and return their choice.
+  return { ended: false, allow: raced.allow, dontAsk: raced.dontAsk };
+}
+// The jobId the approval race should watch — set by runAgentTurn before it can prompt.
+let jobIdForApprovalRace = "";
+
+// Per-session coding-model override chosen via /model (empty = use the account default).
+// Sent to /agent-ask as codingModelOverride; the API validates it against the whitelist.
+// Task #123: with several backends configured this is a QUALIFIED id ("<kind>::<model>"),
+// which resolves to a whole backend — URL, kind and API key — not just a model name.
+let sessionCodingModel = "";
+// The friendly model name behind sessionCodingModel, for display only: the token footer
+// must never show a raw "<kind>::<model>" wire id. Empty = running the account default.
+let sessionCodingLabel = "";
+// The default coding model id (from the startup agent-payload probe) — shown in the
+// per-turn token footer next to the GLOBAL output total so it's clear which model that
+// lifetime count belongs to. The /model override (sessionCodingModel) wins when set.
+let defaultCodingModel = "";
+// Task #125: the coding-server URL of the backend in effect this session — the /model
+// pick's backend when one is chosen, else the account default. Sent to the output-token
+// endpoints so the GLOBAL lifetime total is keyed to the RIGHT backend (a /model switch to
+// another backend must not keep showing the previous backend's total). Empty = let the API
+// fall back to the account-default URL from settings (older behaviour).
+let sessionCodingUrl = "";
+// The account-default backend's URL (from the startup probe's codingChoices), used when no
+// /model override is active. Set once at startup alongside defaultCodingModel.
+let defaultCodingUrl = "";
+// Auto-test mode (/test-auto): when on, the agent verifies its work (build/run/curl/…)
+// and fixes → re-tests until it passes before finishing. Default off; remembered per
+// folder in the session file; sent to /agent-ask as autoTest so python drives the loop.
+let sessionTestAuto = false;
+// RAG storage backend for THIS folder (task #97): "local" (index on disk under ~/.gonext,
+// per-folder, no S3 needed) | "cloud" (the user's S3 bucket) | null (never chosen → ask once
+// at startup when RAG is enabled). Remembered per folder; sent to /agent-ask as ragMode.
+let sessionRagMode = null;
+// Step-budget opt-out (task #80): set once the user picks "yes, don't ask again" at a
+// max-step prompt. Session-scoped (not persisted per folder); sent to /agent-ask each turn
+// so the agent auto-extends past the step budget without prompting again.
+let alwaysExtendOnMaxStep = false;
+// Deploy target chosen via /server (task #69): {name, host, user} or null. Session-scoped;
+// sent to /agent-ask as deployServer so the agent deploys to this host with KEY auth.
+let selectedServer = null;
+// Task #84: peak single-request agent-code-model token count for THIS workspace, kept
+// as a max across turns and persisted per folder in the session file. Shown in orange
+// next to the live token count.
+let sessionMaxCodeTokens = 0;
+// Task #104: GLOBAL lifetime OUTPUT-token total for (this user + the agent coding-model
+// API URL), fetched from the API. Shown with a ↓ next to the input/max counts. Updated
+// after each turn (the API returns the new total) and refreshed at startup.
+let globalOutputTokens = 0;
+
+// While a turn runs, mute readline's own echo/redraws so keystrokes can't corrupt the
+// live status display and there's no way to type a new question — only Ctrl+C works.
+// Same _writeToOutput override password prompts use; our UI (prompt, status, bullets)
+// writes to stdout directly, so it's unaffected — only readline's echo is swallowed.
+const _origWriteToOutput = rl._writeToOutput ? rl._writeToOutput.bind(rl) : null;
+rl._writeToOutput = (s) => {
+  // slashOverlayActive: the slash-command overlay owns drawing (input line + menu), so
+  // readline's own echo must be swallowed or it fights the overlay (bug #109).
+  if (following || listPickerActive || slashOverlayActive) return;
+  // secretInput (task #127): the user is typing an API key — swallow the echo so it never
+  // appears in the terminal or scrollback.
+  if (secretInput) return;
+  if (_origWriteToOutput) _origWriteToOutput(s);
+  else process.stdout.write(s);
+};
+// _writeToOutput only mutes echoed TEXT; readline's line refresh writes cursor-position
+// + erase escapes (e.g. ESC[1G, ESC[0J) straight to output on every keypress, which
+// would corrupt our live status display. No-op it during a turn so a keypress produces
+// ZERO terminal output.
+const _origRefreshLine = rl._refreshLine ? rl._refreshLine.bind(rl) : null;
+rl._refreshLine = () => {
+  // Suppress readline's line refresh (which does clearScreenDown → would wipe our menu)
+  // while the slash overlay owns the screen. We redraw the input line ourselves (#109).
+  if (following || listPickerActive || slashOverlayActive) return;
+  if (secretInput) return; // don't redraw the typed key (task #127)
+  if (_origRefreshLine) _origRefreshLine();
+};
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** Strip <think> markers for live display, and whole think blocks for the answer. */
+const stripThinkTags = (s) => s.replace(/<\/?think>/gi, "");
+const answerFrom = (s) =>
+  s
+    .replace(/<think>[\s\S]*?<\/think>/gi, "")
+    .replace(/<think>[\s\S]*$/i, "")
+    .trim();
+
+// --- Live-thought normalization (task "agent thought normalizing issue") ---------------
+// The blinking status line names the model's current Thought. But the model often emits
+// <code> with NO "Thought:" prose (or degenerates into a runaway), so the raw stream is
+// a create_file(...) blob / escaped CSS — which used to render verbatim on the line
+// ("◐ , #94a3b8);\n -webkit-background-clip…"). Fix: show a genuine thought ONLY when the
+// model actually wrote prose; otherwise name the TOOL it's calling ("Writing App.js");
+// otherwise show nothing (the line falls back to "Thinking…"). Never raw code/CSS.
+const _baseName = (p) => (String(p || "").split(/[\\/]/).pop() || "").trim();
+const THOUGHT_TOOL_LABELS = {
+  create_file: (a) => `Writing ${_baseName(a) || "a file"}`,
+  create_folder: (a) => `Creating ${_baseName(a) || "a folder"}`,
+  edit_lines: (a) => `Editing ${_baseName(a) || "a file"}`,
+  edit_file: (a) => `Editing ${_baseName(a) || "a file"}`,
+  read_file_lines: (a) => `Reading ${_baseName(a) || "a file"}`,
+  read_text_file: (a) => `Reading ${_baseName(a) || "a file"}`,
+  list_dir: (a) => `Listing ${_baseName(a) || "files"}`,
+  grep_repo: () => "Searching the code",
+  run_command: (a) => `Running ${a || "a command"}`,
+  stop_server: () => "Stopping the server",
+  deploy_web: () => "Deploying",
+  fetch_url: (a) => `Fetching ${_baseName(a) || "a page"}`,
+  web_search: () => "Searching the web",
+  http_request: () => "Calling an API",
+  create_pdf: () => "Building a PDF",
+  rag_search: () => "Searching the knowledge base",
+  rag_index: () => "Indexing the knowledge base",
+  download_file: () => "Downloading a file",
+  unzip_file: () => "Unzipping",
+  send_email: () => "Preparing an email",
+  open_url: (a) => `Opening ${a || "a link"}`,
+  final_answer: () => "Composing the answer",
+};
+// Does this candidate look like CODE / a data blob rather than a human thought? (Escaped
+// newlines, braces, hex colors, -webkit-, a leading function call, or too few spaces.)
+const _thoughtLooksCodey = (s) =>
+  /\\n|[{}]|=>|="|#[0-9a-fA-F]{3,6}\b|-webkit-|;\s*$|^\s*[<([]/.test(s) ||
+  /^\s*[a-z_]\w*\s*\(/i.test(s) ||
+  (s.length > 24 && (s.split(" ").length - 1) / s.length < 0.06);
+// Raw in-fence stream → a short, meaningful status: a real Thought clause if the model
+// wrote one, else a friendly label from the tool it's calling, else "" (→ "Thinking…").
+const normalizeThought = (buf) => {
+  const t = String(buf || "");
+  const ci = t.search(/<code[\s>]/i);
+  const head = ci >= 0 ? t.slice(0, ci) : t;
+  // 1) a genuine Thought prose line (before the code) — only if it isn't itself code AND
+  //    reads like an actual clause. A streaming token boundary can leave the first
+  //    non-empty line as a single bare word (e.g. "string", when the model is rambling
+  //    about "multi-line strings"); shown alone on the blinking line it's meaningless and,
+  //    because liveThought only updates on a truthy value, it can FREEZE there through a
+  //    long silent prompt-eval ("string… (777s)"). Require ≥2 words and a little length so
+  //    a lone fragment falls through to the tool label / "Thinking…" instead.
+  const prose = head
+    .replace(/^\s*Thought:\s*/i, "")
+    .split(/\n/)
+    .map((x) => x.trim())
+    .find(Boolean);
+  const proseIsClause = !!prose && prose.length >= 6 && prose.trim().split(/\s+/).length >= 2;
+  if (proseIsClause && !_thoughtLooksCodey(prose)) return prose.slice(0, 100);
+  // 2) otherwise name the tool being called (from the code part).
+  const codePart = ci >= 0 ? t.slice(ci) : t;
+  const m = /(?:<code>\s*)?\b([a-z_]\w*)\s*\(\s*(?:path\s*=\s*)?["']?([^"'\n,)]*)/i.exec(codePart);
+  if (m && THOUGHT_TOOL_LABELS[m[1]]) return THOUGHT_TOOL_LABELS[m[1]](m[2].trim()).slice(0, 100);
+  // 3) nothing human to show.
+  return "";
+};
+
+// The FULLER thought (task #96): the same Thought prose normalizeThought summarizes, but
+// NOT clipped to one clause/100 chars — collapsed to a single spaced string and capped so
+// the expanded (mouse-click) view has a few lines to show. Returns "" when the live line is
+// only a tool label (nothing extra to expand). Bounded by fenceThought's own 400-char cap.
+const thoughtFull = (buf) => {
+  const t = String(buf || "");
+  const ci = t.search(/<code[\s>]/i);
+  const head = (ci >= 0 ? t.slice(0, ci) : t)
+    .replace(/^\s*Thought:\s*/i, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  // Only worth expanding when there's a genuine prose clause (same gate as normalizeThought
+  // path 1) — a bare fragment or pure code has nothing meaningful to unfold.
+  const first = head.split(/\s+/).length;
+  if (head.length < 6 || first < 2 || _thoughtLooksCodey(head)) return "";
+  return head.slice(0, 400);
+};
+
+// Word-wrap a plain (ANSI-free) string into at most `maxLines` lines of width ≤ `width`,
+// appending an ellipsis to the last line when text was dropped (task #96 expand view).
+const wrapThought = (s, width, maxLines) => {
+  const words = String(s || "").split(/\s+/).filter(Boolean);
+  const lines = [];
+  let cur = "";
+  let truncated = false;
+  for (let i = 0; i < words.length; i++) {
+    const w = words[i];
+    const next = cur ? cur + " " + w : w;
+    if (next.length <= width) {
+      cur = next;
+    } else {
+      if (cur) lines.push(cur);
+      cur = w;
+      if (lines.length >= maxLines) { truncated = true; cur = ""; break; }
+    }
+  }
+  if (cur && lines.length < maxLines) lines.push(cur);
+  else if (cur) truncated = true;
+  if (truncated && lines.length) {
+    const last = lines[maxLines - 1] ?? lines[lines.length - 1];
+    const room = Math.max(1, width - 1);
+    lines[lines.length - 1] = (last.length > room ? last.slice(0, room) : last).replace(/\s+$/, "") + "…";
+  }
+  return lines;
+};
+
+async function runAgentTurn(history) {
+  const res = await fetch(`${apiBase}/api/worker/agent-ask`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
+    // cwd = this terminal's folder → agent puts download/unzip output here (when it's
+    // a registered workspace). codingModelOverride = the /model choice for this session.
+    body: JSON.stringify({
+      messages: history,
+      cwd: resolve(process.cwd()),
+      // The terminal can show a Yes/No picker → the agent PAUSES on a risky command and
+      // asks instead of hard-blocking it (interactive command-approval gate).
+      interactiveApproval: true,
+      // Step-budget opt-out (task #80): once the user chose "don't ask again", auto-extend
+      // past the step budget without prompting.
+      ...(alwaysExtendOnMaxStep ? { alwaysExtendOnMaxStep: true } : {}),
+      // Auto-test mode (/test-auto): the agent verifies its work and fixes until it passes.
+      ...(sessionTestAuto ? { autoTest: true } : {}),
+      // RAG storage backend for this folder (task #97): local disk vs cloud/S3. Only sent
+      // once chosen; absent → the API/python default (cloud), preserving old behavior.
+      ...(sessionRagMode ? { ragMode: sessionRagMode } : {}),
+      // Deploy target chosen via /server — host/user only (no secret), for key-auth deploys.
+      ...(selectedServer ? { deployServer: selectedServer } : {}),
+      ...(sessionCodingModel ? { codingModelOverride: sessionCodingModel } : {}),
+    }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    if (res.status === 404) {
+      throw new Error(
+        "the API does not have POST /api/worker/agent-ask yet — deploy the latest API."
+      );
+    }
+    throw new Error(data?.error || `agent-ask failed (HTTP ${res.status})`);
+  }
+  const jobId = data?.jobId;
+  if (!jobId) throw new Error("agent-ask returned no jobId.");
+
+  following = true;
+  followAborted = false;
+  currentJobId = jobId;
+  jobIdForApprovalRace = jobId; // so an approval picker can watch THIS job for early end (#110)
+  cancelRequested = false;
+  const startedAt = Date.now();
+  let shownChars = 0;
+  let lastApprovalId = null; // the last command-approval request we've already answered
+  let carry = ""; // trailing partial content line held until its newline arrives
+  let statusShown = false; // a transient status line is currently on screen
+  let statusLines = 2; // how many rows the status block currently occupies (grows when expanded)
+  let warnedPending = false;
+  // Transient poll failures (a network blip or a 5xx like the API's momentary "Worker
+  // key lookup failed." — a cold Mongo connection, NOT a bad key) must NOT kill a
+  // long-running turn. Tolerate a run of them; only give up after too many in a row.
+  let pollFailures = 0;
+  const MAX_POLL_FAILURES = 6; // ~6 tries with backoff before conceding the follow
+  let jobRunning = false; // only tick "thinking…" once the worker has claimed the job
+  let answerShownLive = false; // plain-reply content already printed — don't re-print it
+  // True once we've SPECIFICALLY seen "→ Chat reply" (the plain-reply/trivial-chat
+  // branch), as opposed to "→ Agent mode…" (the tool-use branch). Only the plain-reply
+  // path streams its answer via answer_stream with NO heartbeat/tool-summary/code lines
+  // ever interleaved — so only THERE is it safe to partial-flush trailing content live
+  // (see carryFlushedLen below); the agent path's code/tool-call lines must stay buffered
+  // until a full line is known, or we'd risk showing part of something we meant to hide.
+  let plainReplyFlow = false;
+  // Exact answer characters printed live in the plain-reply flow — lets the completed
+  // poll figure out how much of the FINAL answer is still unshown even when resultText
+  // was replaced (not extended) on completion. See the completed-branch recovery below.
+  let liveAnswer = "";
+  // Running total of prompt tokens sent to the agent CODE model this turn (task #83),
+  // read from the job doc each poll. Rendered on the thinking line after the playful word.
+  let latestCodeTokens = 0;
+  // Task #104: this turn's OUTPUT-token total, read from the job doc each poll. Folded into
+  // the lifetime per-workspace + global counters once the turn completes.
+  let latestOutputTokens = 0;
+  let outputTokensPosted = false; // guard: increment the lifetime counters once per turn
+  // First few KB of the raw stream as consumed — a cheap fingerprint to verify the
+  // completed resultText really EXTENDS what we streamed (an old worker replaces it
+  // with the shorter bare answer, which must not be sliced by shownChars).
+  let seenRaw = "";
+
+  // --- Live in-progress ("blinking") bullet -------------------------------------------
+  // The agent's raw Thought/code stream is SUPPRESSED (see the ~~~-fence handling in
+  // consume) — the terminal shows only a clean list of action bullets. While a step is
+  // being thought about / run, we show ONE in-place blinking bullet that counts up —
+  // "◐ working… (7s)" — instead of dumping the model's rambling reasoning and stamping a
+  // "✔ completed thought" on every token-stream micro-pause (the reported clutter).
+  const QUIET_MS = 700; // stream idle this long ⇒ we're waiting on the model
+  const STALE_THOUGHT_MS = 25000; // no new tokens this long ⇒ the current Thought clause is stale (#95 A)
+  let lastContentAt = Date.now();
+  let thinking = false;
+  let thinkingSince = 0;
+  let thinkWord = pickWord(); // playful word shown UNDER the in-progress line (flavor)
+  let lastWordBucket = -1; // 12s window index → rotate the word once per window (task: 30-spinner)
+  let almostDone = false; // set from the worker's "…almost completed thinking…" heartbeat
+  let runningCmd = null; // the command currently executing (from a "Running → …" event)
+  // The model's CURRENT Thought (task #64): while it streams its reasoning inside the
+  // hidden ~~~ fence, show a one-clause summary on the blinking line so a 300s CPU-bound
+  // step reads as "◑ Adding the nav links to app.component.html… (52s)" instead of a
+  // random word. `fenceThought` accumulates the raw in-fence text for the current step.
+  let liveThought = "";
+  let fenceThought = "";
+  // Task #96: the FULLER version of the current thought (for the click-to-expand view) and
+  // whether the user has clicked to expand it. Both reset when the step's Thought changes.
+  let fullLiveThought = "";
+  let thoughtExpanded = false;
+  let hoverRow = -1; // last mouse viewport row (from motion events) → highlight when it's on the thought line
+  let thoughtRow = -1; // absolute viewport row of the thought line (line 1), learned via \x1b[6n
+  let lastDsrAt = 0; // throttle the cursor-position probe
+  const thinkSecs = () => Math.max(1, Math.round((Date.now() - thinkingSince) / 1000));
+
+  // The status is normally TWO in-place lines — the in-progress action, then the playful
+  // word under it — but grows by a few grey lines when the thought is expanded (task #96).
+  // Cursor sits at the end of the LAST line, so clearing = wipe it, then move-up-and-wipe
+  // for each line above, leaving the cursor back at the status's origin for a redraw.
+  const clearStatus = () => {
+    if (!statusShown) return;
+    let seq = "\r\x1b[K";
+    for (let i = 1; i < statusLines; i++) seq += "\x1b[1A\r\x1b[K";
+    process.stdout.write(seq);
+    statusShown = false;
+  };
+  clearActiveStatus = clearStatus; // let pickers wipe this turn's status block before they draw
+
+  const tick = () => {
+    if (!following || followAborted || !jobRunning) return;
+    if (approvalActive || listPickerActive) return; // a picker owns the screen — don't draw over it
+    if (Date.now() - lastContentAt < QUIET_MS) return; // tokens still flowing
+    // A plain-reply answer streams onto a line with NO trailing newline until it's fully
+    // done — overwriting the ticker there corrupts the visible answer mid-word. Stay
+    // silent once any of THIS line has already been shown (see carryFlushedLen).
+    if (plainReplyFlow && carryFlushedLen > 0) return;
+    // Count from when this phase went quiet, so the seconds reflect the current wait/run.
+    if (!thinking) {
+      thinking = true; thinkingSince = lastContentAt; thinkWord = pickWord(); lastWordBucket = 0;
+    }
+    const now = Date.now();
+    // Age out a stale Thought clause: if the model has produced NO new stream content for a
+    // while (e.g. a 150s+ silent prompt-eval on a huge context), the last clause is no longer
+    // "what it's doing now" — drop it so the line falls back to the playful word / "Thinking…"
+    // instead of freezing on an old thought while the timer climbs ("string… (777s)", #95 A).
+    if (liveThought && now - lastContentAt > STALE_THOUGHT_MS) {
+      liveThought = ""; fullLiveThought = ""; thoughtExpanded = false; // #96: nothing to expand once stale
+    }
+    const secs = thinkSecs();
+    // Rotate the playful word once per 12s window (guarded so the fast ticker doesn't
+    // re-roll it many times within the same second).
+    const wordBucket = Math.floor((now - thinkingSince) / 12000);
+    if (wordBucket !== lastWordBucket) { lastWordBucket = wordBucket; thinkWord = pickWord(); }
+    // Spinner: STYLE rotates ~every 8s, FRAME advances ~every 120ms, color cycles ~every
+    // 2.5s — all off the wall clock so they keep moving smoothly across phases.
+    const frames = SPINNERS[Math.floor(now / 8000) % SPINNERS.length];
+    const glyph = frames[Math.floor(now / 120) % frames.length];
+    const wc = WAIT_COLORS_256[Math.floor(now / 2500) % WAIT_COLORS_256.length];
+    // Line 1 = WHAT is happening now: the running command, else the phase (Thinking /
+    // Almost done). Line 2 = the playful word (flavor). Truncate so neither wraps.
+    // Priority: a live command > the model's current Thought clause (task #64, so a
+    // long CPU-bound step reads as what it's actually reasoning about, not "Thinking")
+    // > the "almost done" heartbeat > the bare fallback.
+    const max = Math.max(24, (process.stdout.columns || 80) - 14);
+    const fit = (s) => (s.length > max ? s.slice(0, max - 1) + "…" : s);
+    // Task #104: global (user + coding-URL) OUTPUT-token total, ↓ = generated. Add THIS
+    // turn's in-progress output (latestOutputTokens) to the persisted global so the live
+    // count climbs in real time and matches the web; it's reset to 0 once the turn's total
+    // is POSTed into globalOutputTokens (so it's never double-counted).
+    const liveOutputTotal = globalOutputTokens + latestOutputTokens;
+    const tokLabel =
+      dim(` · ${fmtTokens(latestCodeTokens)} tok`) +
+      orange(` · ${fmtTokens(sessionMaxCodeTokens)} max`) +
+      (liveOutputTotal > 0 ? cyan(` · ↓ ${fmtTokens(liveOutputTotal)}`) : "");
+    // Task #96: the thought line is "clickable" only when the fuller thought has MORE text than
+    // fits on line 1 (a live command / bare "Thinking" / a thought that already fits has nothing
+    // to reveal). Line 1 (what's happening now): a live command > the model's current Thought >
+    // "almost done" > "Thinking". When clickable we drive line 1 from the SAME fuller string, so
+    // the grey expansion CONTINUES where line 1 was cut off instead of repeating the head.
+    const clickable = !!fullLiveThought && !runningCmd && fullLiveThought.length > max;
+    let label, rest;
+    if (clickable) {
+      // Split at a WORD boundary near the line-1 width so nothing is cut mid-word: the last
+      // space at/before max-1 (unless that snaps back too far into the line — then hard-cut).
+      // Line 1 shows the head; the grey expansion CONTINUES from the same point (no dup, no
+      // split word).
+      const sp = fullLiveThought.lastIndexOf(" ", max - 1);
+      const cut = sp >= Math.floor(max * 0.6) ? sp : max - 1;
+      label = `${fullLiveThought.slice(0, cut).replace(/\s+$/, "")}… (${secs}s)`;
+      rest = fullLiveThought.slice(cut).trim();
+    } else {
+      const primary = runningCmd
+        ? `Running ${runningCmd}`
+        : liveThought || (almostDone ? "Almost done" : "Thinking");
+      label = `${fit(primary)}… (${secs}s)`;
+      rest = "";
+    }
+    // When clicked, unfold the remainder as up to 4 wrapped GREY lines BETWEEN the thought and
+    // the playful-word line.
+    const expLines = thoughtExpanded && rest ? wrapThought(rest, max, 4) : [];
+    const drawn = 2 + expLines.length;
+    const rows = process.stdout.rows || 24;
+    // Hover-highlight only the THOUGHT line (line 1) — its exact viewport row comes from the
+    // \x1b[6n probe below (`thoughtRow`); fall back to the viewport-bottom assumption only when
+    // the terminal never answered the probe.
+    const tRow = thoughtRow >= 1 ? thoughtRow : rows - drawn + 1;
+    const hovering = clickable && hoverRow === tRow;
+    clearStatus();
+    // Right after clearing, the cursor sits at the status block's TOP-LEFT = the thought line's
+    // row. Probe for it (throttled) so hover/click hit-testing is exact wherever the block is.
+    if (process.stdin.isTTY && now - lastDsrAt > 400) { lastDsrAt = now; process.stdout.write("\x1b[6n"); }
+    // Line 1: green ● + green phase/seconds (matches the web's green streaming label), or the
+    // underlined bright-green hover style when the mouse is over a clickable thought. Then the
+    // GREY expanded lines (if any), then LAST the SPINNER + playful word + token labels
+    // (task #83/#84), e.g. "  ⠙ Caffeinating… · 12.3k tok · 8.1k max".
+    let out = `${green(BULLET)} ${hovering ? hoverThought(label) : green(label)}`;
+    for (const wl of expLines) out += "\n  " + dim(wl);
+    out += "\n" + `  ${color256(wc, `${glyph} ${thinkWord}…`)}${tokLabel}`;
+    process.stdout.write(out);
+    statusLines = drawn;
+    statusShown = true;
+  };
+  // 120ms so the spinner animates smoothly (the frame math above uses the wall clock, so
+  // seconds still tick once/sec). Only redraws when the model has gone quiet >QUIET_MS.
+  const ticker = setInterval(tick, 120);
+
+  // --- Hover + click on the thinking line (task #96) -------------------------------------
+  // HOVER: motion events keep `hoverRow`; the tick highlights the thought line (underlined
+  // bright-green "link") whenever the mouse is on its row. CLICK: a left-click on the status
+  // block toggles the fuller thought (3-4 grey lines). The block sits at the bottom of the
+  // viewport (new output keeps scrolling it there), so we hit-test rows against the bottom
+  // `statusLines` rows. Mouse reporting is on only for the turn and always turned back off in
+  // the finally + on process exit, so the user's shell is never left in mouse-capture mode.
+  const onStatusClick = (row) => {
+    if (!statusShown) return;
+    const rows = process.stdout.rows || 24;
+    const top = thoughtRow >= 1 ? thoughtRow : rows - statusLines + 1; // thought line row
+    // Toggle only on the thought line + its grey expansion — NOT the last row (the playful
+    // word / token line), so a click there doesn't expand what it isn't part of.
+    if (row < top || row > top + statusLines - 2) return;
+    // Only meaningful when there IS a fuller thought to reveal; otherwise ignore the click
+    // so we don't flicker an empty expand.
+    if (!thoughtExpanded && !(fullLiveThought && !runningCmd)) return;
+    thoughtExpanded = !thoughtExpanded;
+    clearStatus(); // next tick (≤120ms) redraws at the new size; keeps cursor math correct
+  };
+  const onMouseData = (chunk) => {
+    if (!following) return;
+    const s = chunk.toString("latin1");
+    if (s.indexOf("\x1b[") === -1) return; // fast reject: no CSI (mouse report OR cursor reply) here
+    // Cursor-position reply → the thought line's absolute row (see the \x1b[6n probe in tick).
+    DSR_RE.lastIndex = 0;
+    let d;
+    while ((d = DSR_RE.exec(s))) thoughtRow = parseInt(d[1], 10);
+    MOUSE_RE.lastIndex = 0;
+    let m;
+    while ((m = MOUSE_RE.exec(s))) {
+      const btn = parseInt(m[1], 10);
+      const row = parseInt(m[3], 10);
+      const isPress = m[4] === "M";
+      if (btn & 32) { hoverRow = row; continue; } // MOTION (hover/drag) → track for the highlight
+      if (isPress && (btn & 0b11) === 0 && (btn & 64) === 0) onStatusClick(row); // left click → expand
+    }
+  };
+  if (process.stdin.isTTY) process.stdin.on("data", onMouseData);
+  enableMouse();
+
+  // Called right before any real (bullet/edit-card/answer) content prints: drop the
+  // status lines so content lands cleanly, and end the current phase (so the next phase's
+  // seconds count fresh, and any running command is considered finished).
+  const onContent = () => {
+    clearStatus();
+    thinking = false;
+    runningCmd = null;
+    // A concrete action landed → the Thought that led to it is spent; clear it so the
+    // next step's blinking line starts from "Thinking", not last step's stale clause.
+    liveThought = "";
+    fenceThought = "";
+    fullLiveThought = "";       // #96: the fuller thought is spent too…
+    thoughtExpanded = false;    // …and each new thinking phase starts collapsed.
+    lastDsrAt = 0;              // …content just scrolled → re-probe the thought row next tick.
+    lastContentAt = Date.now();
+  };
+
+  // Split newly-arrived text into lines: heartbeats + ~~~ fences + the post-tool-call step
+  // summary ("tool(...) | → result", redundant with the daemon's own terminal) are
+  // swallowed; the model's <code>/</code> TAG lines are hidden but the code body between
+  // them prints in a distinct grey (not dim, so it stands out from "Thought:" prose);
+  // blank lines keep spacing; everything else commits dim to scrollback.
+  let inCode = false;
+  let inEditCard = false; // inside a colored edit-card block (see isEditCardHeader)
+  // The worker wraps the raw model token stream (Thought prose + code) in ~~~ fences;
+  // the concrete ACTION events (tool steps, edit cards) are emitted OUTSIDE them. We
+  // suppress everything IN a fence — the rambling Thought and redundant raw code (the
+  // edit card already shows real changes) — and render the out-of-fence actions as
+  // bullets. This is the whole "action bullets only" declutter (task #41).
+  let inStreamFence = false;
+  let lastWasBlank = true; // suppresses a leading blank line and collapses repeats
+  // Chars of the CURRENT trailing (newline-less) `carry` line already flushed live — lets
+  // a long plain-reply answer stream character-by-character instead of waiting for a "\n"
+  // that might not arrive until the very end (most short replies have none at all).
+  let carryFlushedLen = 0;
+  const consume = (chunk) => {
+    carry += stripThinkTags(chunk);
+    let nl;
+    while ((nl = carry.indexOf("\n")) >= 0) {
+      const line = carry.slice(0, nl);
+      carry = carry.slice(nl + 1);
+      const alreadyFlushed = carryFlushedLen;
+      carryFlushedLen = 0; // reset — `carry` now starts a fresh pending line
+      if (isHeartbeatLine(line)) {
+        // Heartbeats are swallowed (the local ticker drives the display), but they
+        // still carry ONE bit we want: once the worker's word is "…almost completed
+        // thinking…", this model call is past prompt-eval and producing output — flip
+        // the local ticker to the same wording. A plain random-word heartbeat means
+        // we're back to waiting (a fresh step's prompt-eval), so clear the flag.
+        almostDone = /almost/i.test(line);
+        continue;
+      }
+      // A fence opening starts a fresh step's raw stream → reset the harvested Thought
+      // so the blinking line doesn't carry last step's clause into this one.
+      if (isFenceLine(line)) {
+        inStreamFence = !inStreamFence;
+        if (inStreamFence) fenceThought = "";
+        continue;
+      }
+      // Inside a ~~~ fence = raw model Thought/code stream → suppressed from scrollback. Do
+      // NOT bump lastContentAt: while the (now hidden) tokens flow, the blinking bullet keeps
+      // ticking so the user sees the step is still being worked on. But HARVEST the first
+      // Thought clause for the blinking line (task #64) — up to the <code> block, which is
+      // where the prose ends and the tool call begins (we never surface code here).
+      if (inStreamFence) {
+        // Accumulate a bounded head of the stream (enough to see the Thought prose OR the
+        // tool call), capped so a 16k-char runaway can't grow the buffer. normalizeThought
+        // yields a clean label — never raw code/CSS.
+        if (fenceThought.length < 400) {
+          fenceThought += line + "\n";
+          const th = normalizeThought(fenceThought);
+          if (th) liveThought = th;
+          fullLiveThought = thoughtFull(fenceThought); // #96: keep the fuller thought for expand
+        }
+        continue;
+      }
+      if (isToolStepSummary(line)) { lastContentAt = Date.now(); continue; } // swallow
+      if (isRoutingLine(line)) {
+        // Swallow the router's play-by-play entirely — the blinking-bullet ticker (which
+        // already shows the playful word + seconds) is the single in-progress indicator,
+        // so a separate static "Booting the big brain…" line here would just duplicate it.
+        if (line.trim() === "→ Chat reply") plainReplyFlow = true;
+        continue;
+      }
+      // Edit card (a file change made by the agent's edit tools) — rendered as a
+      // colored diff instead of dim prose. Checked before the <code> handling: the
+      // card is a step event, never part of the model's raw code stream, and the ⏺
+      // header is distinctive enough to never collide with generated Python.
+      if (isEditCardHeader(line)) {
+        onContent();
+        inEditCard = true;
+        process.stdout.write(green("⏺") + bold(line.slice(1)) + "\n");
+        lastWasBlank = false;
+        lastContentAt = Date.now();
+        continue;
+      }
+      if (inEditCard) {
+        if (isEditCardBody(line)) {
+          onContent();
+          const m = EDIT_DIFF_RE.exec(line);
+          if (m) {
+            // "    19 -  old text" → dim line number, red/green signed content.
+            const paintDiff = m[3] === "+" ? green : red;
+            process.stdout.write(`${m[1]}${dim(m[2])} ${paintDiff(`${m[3]} ${m[4]}`)}\n`);
+          } else {
+            process.stdout.write(dim(line) + "\n"); // "└ summary" / "… (+N more)"
+          }
+          lastWasBlank = false;
+          lastContentAt = Date.now();
+          continue;
+        }
+        inEditCard = false; // card ended — fall through to normal handling
+      }
+      {
+        const t = line.trim();
+        const openM = !inCode || t.startsWith("<code") ? CODE_OPEN_RE.exec(t) : null;
+        if (openM) {
+          // Enter code mode (or stay in it on a duplicate tag). Anything glued after
+          // the tag on the same line is code — print it, minus a glued close tag.
+          // (Reached only for a stray <code> OUTSIDE a ~~~ fence; in-fence code is
+          // suppressed above. Kept as a safety net.)
+          inCode = true;
+          let rest = t.slice(openM[0].length).trim();
+          if (CODE_CLOSE_RE.test(rest)) {
+            inCode = false;
+            rest = rest.replace(CODE_CLOSE_RE, "").trim();
+          }
+          if (rest) {
+            onContent();
+            process.stdout.write(codeColor(rest) + "\n");
+            lastWasBlank = false;
+          }
+          lastContentAt = Date.now();
+          continue;
+        }
+        if (!inCode && isBareCloseTag(t)) {
+          // Stray close tag with no open in sight — swallow, never show it.
+          lastContentAt = Date.now();
+          continue;
+        }
+      }
+      if (inCode) {
+        const t = line.trim();
+        if (CODE_CLOSE_RE.test(t)) {
+          // Close tag, possibly with the code's last line glued in front of it.
+          const before = t.replace(CODE_CLOSE_RE, "").trim();
+          if (before) {
+            onContent();
+            process.stdout.write(codeColor(before) + "\n");
+            lastWasBlank = false;
+          }
+          inCode = false;
+          lastContentAt = Date.now();
+          continue;
+        }
+        if (t === "") { lastContentAt = Date.now(); continue; } // skip blank lines in code
+        onContent();
+        process.stdout.write(codeColor(line) + "\n");
+        lastWasBlank = false;
+        continue;
+      }
+      if (line.trim() === "") {
+        // Vertical rhythm (task #115). Blank lines arrive from the worker unconditionally —
+        // every {"type":"step"} chunk is `text + "\n\n"`, and closeStreamFence() adds its
+        // own — but whether one was PRINTED used to depend on `!thinking && !statusShown`,
+        // i.e. on whether the status ticker happened to have redrawn its two-line block in
+        // the last ~120ms. Identical output rendered two different ways (reported live: the
+        // first ● bullet flush against the prompt, the next three each with a gap above).
+        // Spacing must not be a race, so neither term is consulted any more:
+        //   • ACTION stream → swallow every stream-borne blank. Bullets and edit cards form
+        //     ONE tight list (task #41); the blank line before the final answer is written
+        //     by the CALLER (`console.log(shown ? "" : "\n\n" + answer)`), not here.
+        //   • PLAIN-REPLY answer → this text IS the answer, so its blanks are real
+        //     paragraph breaks. Keep them (collapsing runs) and clear the status block
+        //     first, which is what the old `!statusShown` guard was really protecting.
+        if (plainReplyFlow && !lastWasBlank) {
+          onContent();
+          process.stdout.write("\n");
+          lastWasBlank = true;
+        }
+        continue;
+      }
+      // Agent flow: a "Running → <cmd>" is the START of a command — show it as the live
+      // in-progress status (the blinking bullet names it) rather than a solid bullet; its
+      // completion ("Command passed/failed → …" / "Server up → …") prints the done bullet.
+      // So the pair collapses to: "◑ Running <cmd>…" while it runs, then "● <result>".
+      if (!plainReplyFlow) {
+        const mRun = /^Running → (.+)$/.exec(line.trim());
+        if (mRun) { runningCmd = mRun[1]; thinking = false; lastContentAt = Date.now(); continue; }
+      }
+      if (alreadyFlushed === 0) onContent();
+      if (plainReplyFlow) {
+        // Plain-reply content IS the answer — print it in the default color and remember
+        // it's visible so the caller doesn't reprint it once the turn completes.
+        process.stdout.write(line.slice(alreadyFlushed) + "\n");
+        liveAnswer += line.slice(alreadyFlushed) + "\n";
+        answerShownLive = true;
+      } else {
+        // The remaining out-of-fence ACTION events ("Command passed → …", "Searching code
+        // → …", "Server up → …", "Composing answer…") each print as ONE solid bullet —
+        // the clean, summarized action list (task #41).
+        process.stdout.write(white(BULLET) + " " + line.trim() + "\n");
+      }
+      lastWasBlank = false;
+    }
+    // Plain-reply answers often have NO internal newline at all (a short one-sentence
+    // reply) and can take many seconds to generate — without this, nothing would print
+    // until the whole thing finally lands, right back to the "wait then dump" problem
+    // this was meant to fix. Only safe in the plain-reply flow (see plainReplyFlow above).
+    if (plainReplyFlow && !inCode && carry.length > carryFlushedLen) {
+      if (carryFlushedLen === 0) onContent();
+      process.stdout.write(carry.slice(carryFlushedLen)); // default color — this IS the answer
+      liveAnswer += carry.slice(carryFlushedLen);
+      carryFlushedLen = carry.length;
+      answerShownLive = true;
+      lastWasBlank = false;
+    }
+    // While in the hidden fence, the model's FIRST Thought line often sits in `carry` with
+    // no newline yet (a long reasoning sentence streams token-by-token) — recompute the
+    // live clause from the partial too, so the blinking line updates mid-sentence instead
+    // of only once the line finally breaks (task #64).
+    if (inStreamFence && fenceThought.length < 400) {
+      const th = normalizeThought(fenceThought + carry);
+      if (th) liveThought = th;
+      fullLiveThought = thoughtFull(fenceThought + carry); // #96: fuller thought for expand
+    }
+    // A non-empty remainder is a partial CONTENT line (heartbeats always arrive whole with
+    // a newline), so tokens are actively flowing — keep the ticker asleep.
+    if (carry.trim() !== "") lastContentAt = Date.now();
+  };
+
+  try {
+    for (;;) {
+      if (followAborted) {
+        clearStatus();
+        process.stdout.write(
+          dim("\n(stopped following — the job keeps running on the worker)\n")
+        );
+        return { text: "", shown: false };
+      }
+      let job;
+      try {
+        const jr = await fetch(`${apiBase}/api/worker/jobs/${jobId}`, {
+          headers: { "X-Worker-Key": workerKey },
+        });
+        const parsed = await jr.json().catch(() => ({}));
+        if (jr.ok) {
+          job = parsed;
+          pollFailures = 0; // a clean poll resets the tolerance window
+        } else if (jr.status >= 400 && jr.status < 500) {
+          // Client error (bad/expired key, job genuinely gone) — NOT transient, fail fast.
+          throw new Error(parsed?.error || `job poll failed (HTTP ${jr.status})`);
+        } else {
+          // 5xx — a momentary server/DB blip (e.g. "Worker key lookup failed."). Transient.
+          throw Object.assign(
+            new Error(parsed?.error || `job poll failed (HTTP ${jr.status})`),
+            { transient: true }
+          );
+        }
+      } catch (err) {
+        // A fetch/network exception has no HTTP status — treat it as transient too.
+        const transient = err?.transient === true || isNetworkError(err);
+        if (!transient) throw err;
+        pollFailures += 1;
+        if (pollFailures >= MAX_POLL_FAILURES) {
+          clearStatus();
+          throw new Error(
+            `lost contact with the API after ${pollFailures} tries (${String(err.message).slice(0, 80)}). ` +
+              "The turn may still be running on the worker — try 'continue'."
+          );
+        }
+        await sleep(Math.min(700 * pollFailures, 3000)); // linear backoff, capped at 3s
+        continue;
+      }
+      jobRunning = job.jobStatus === "running";
+      // Live agent-code-model token total (task #83) — monotonic, shown on the thinking line.
+      if (Number.isFinite(job.agentCodeTokens) && job.agentCodeTokens > latestCodeTokens) {
+        latestCodeTokens = job.agentCodeTokens;
+      }
+      // Peak single-request tokens (task #84): keep the per-workspace max across turns.
+      if (Number.isFinite(job.agentMaxCodeTokens) && job.agentMaxCodeTokens > sessionMaxCodeTokens) {
+        sessionMaxCodeTokens = job.agentMaxCodeTokens;
+      }
+      // This turn's OUTPUT-token total (task #104), monotonic across polls.
+      if (Number.isFinite(job.agentOutputTokens) && job.agentOutputTokens > latestOutputTokens) {
+        latestOutputTokens = job.agentOutputTokens;
+      }
+      const text = typeof job.resultText === "string" ? job.resultText : "";
+      if (job.jobStatus === "completed") {
+        // Task #104: fold this turn's output-token total into the lifetime per-workspace +
+        // global (user + coding-URL) counters, exactly once. Best-effort; the API returns
+        // the new global total, which drives the ↓ header indicator.
+        if (latestOutputTokens > 0 && !outputTokensPosted) {
+          outputTokensPosted = true;
+          void addOutputTokens(resolve(process.cwd()), latestOutputTokens).then((t) => {
+            { const g = pickGlobalTotal(t); if (g !== null) globalOutputTokens = g; }
+            // This turn's total is now folded into globalOutputTokens — zero the live
+            // per-turn tally so the ↓ (global + latest) doesn't double-count it.
+            latestOutputTokens = 0;
+          });
+        }
+        // The job can flip to "completed" between polls with authoritative resultText that
+        // the live stream hasn't caught up to yet (a debounced last chunk, or the final
+        // PATCH landing before its chunk flush was polled). resultText is the source of
+        // truth, so flush any not-yet-shown suffix BEFORE returning — otherwise a plain
+        // reply, whose live stream is its ONLY output, renders truncated mid-word. Gated
+        // to plainReplyFlow: the agent path reprints its answer from resultText via the
+        // caller (shown=false), so a live flush there is unnecessary (and would compound
+        // the separate agent double-print). This runs for the completed poll only; the
+        // running-branch consume below handles every earlier poll.
+        //
+        // The suffix math is only valid when the completed resultText EXTENDS the
+        // streamed accumulation. An older worker REPLACES it with the bare deduped
+        // answer — a shorter, different string — so slicing by shownChars either shows
+        // nothing (the reported "Hello! How" cut) or a garbage tail. Verify with the
+        // seenRaw fingerprint; on a mismatch, recover by answer-prefix instead: print
+        // whatever of the final answer wasn't already shown live.
+        const extendsStream = text.length >= shownChars && text.startsWith(seenRaw);
+        if (plainReplyFlow && extendsStream && text.length > shownChars) {
+          consume(text.slice(shownChars));
+          shownChars = text.length;
+        } else if (plainReplyFlow && !extendsStream && answerShownLive) {
+          const ans = answerFrom(text);
+          let rest = ans.startsWith(liveAnswer) ? ans.slice(liveAnswer.length) : null;
+          if (rest === null) {
+            // The live text may carry a trailing newline the trimmed answer lacks.
+            const printed = liveAnswer.replace(/\s+$/, "");
+            rest = ans.startsWith(printed) ? ans.slice(printed.length) : null;
+          }
+          if (rest) {
+            onContent();
+            process.stdout.write(rest);
+            lastWasBlank = false;
+          }
+        }
+        clearStatus();
+        // Task #104: expose this turn's code-model INPUT + the CUMULATIVE output-token
+        // total (all turns for this user + coding server) so the caller can print a
+        // persistent footer. Output is the running total (globalOutputTokens already holds
+        // every prior turn; latestOutputTokens is THIS turn, not yet folded in because the
+        // addOutputTokens POST above is async) — the same figure the live "↓" showed during
+        // the turn, so it doesn't drop back to just this turn's count at the prompt (#112).
+        // `turnOutputTokens` is kept separately so the caller's footer guard reflects whether
+        // THIS turn used the code model (a plain-reply greeting = 0 → no footer).
+        return {
+          text: answerFrom(text),
+          shown: answerShownLive,
+          inputTokens: latestCodeTokens,
+          outputTokens: globalOutputTokens + latestOutputTokens,
+          turnOutputTokens: latestOutputTokens,
+        };
+      }
+      if (text.length > shownChars) {
+        if (seenRaw.length < 4096) {
+          seenRaw = (seenRaw + text.slice(shownChars)).slice(0, 4096);
+        }
+        consume(text.slice(shownChars));
+        shownChars = text.length;
+      }
+      // Interactive command-approval gate: the agent paused on a risky command. Show the
+      // Yes/No picker once per request id, POST the choice, then let the agent resume.
+      if (
+        job.pendingApproval &&
+        job.pendingApproval.id &&
+        job.pendingApproval.id !== lastApprovalId
+      ) {
+        lastApprovalId = job.pendingApproval.id;
+        clearStatus();
+        // Race the picker against the job ending server-side (#110): if python gives up
+        // (its own approval deadline) and completes the job while we're waiting, dismiss
+        // the picker and DON'T post a now-useless choice — fall through to the normal
+        // completed/failed/cancelled handling below on the next poll.
+        const { ended, allow, dontAsk } = await approvalPromptRacingJob(
+          job.pendingApproval.command || ""
+        );
+        if (ended) {
+          process.stdout.write(
+            dim("\n  (the run already ended before you chose — reply 'continue' to resume)\n")
+          );
+          continue; // re-poll; the terminal-status branches below take it from here
+        }
+        // "Yes, don't ask again this session" (max-step prompt only): remember it so every
+        // later turn sends alwaysExtendOnMaxStep and the agent auto-extends silently (#80).
+        if (dontAsk) {
+          alwaysExtendOnMaxStep = true;
+          process.stdout.write(dim("  (won't ask again about the step budget this session)\n"));
+        }
+        try {
+          await fetch(`${apiBase}/api/worker/jobs/${jobId}/approval`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
+            body: JSON.stringify({ id: lastApprovalId, allow }),
+          });
+        } catch {
+          // Best-effort — if the POST fails, the python side times out and treats as deny.
+        }
+      }
+      if (job.jobStatus === "cancelled") {
+        // User-requested stop (Ctrl+C) — a clean outcome, not an error. The worker has
+        // killed the Python agent. Print a quiet note and return an empty, non-persisted
+        // turn (main() drops it from history).
+        clearStatus();
+        process.stdout.write(dim("\n(cancelled — the agent was stopped)\n"));
+        return { text: "", shown: false, cancelled: true };
+      }
+      if (job.jobStatus === "failed") {
+        clearStatus();
+        throw new Error(job.errorMessage || "job failed");
+      }
+      if (
+        job.jobStatus === "pending" &&
+        !warnedPending &&
+        Date.now() - startedAt > 6000
+      ) {
+        warnedPending = true;
+        clearStatus();
+        process.stdout.write(
+          red("\n⚠ no worker has claimed the job — is `gonext-cli` running?\n")
+        );
+      }
+      await sleep(700);
+    }
+  } finally {
+    clearInterval(ticker);
+    clearStatus();
+    clearActiveStatus = null; // no turn owns the status wiper between turns
+    // Task #96: stop mouse-reporting the moment the turn ends (also on cancel/error — this
+    // finally always runs), and detach the click parser, so the user's shell selection is
+    // never captured between turns.
+    disableMouse();
+    if (process.stdin.isTTY) process.stdin.removeListener("data", onMouseData);
+    following = false;
+    currentJobId = null;
+    // Drop anything typed (but not submitted) during the turn — echo was muted, so it's
+    // invisible; without this it would surface on the next prompt.
+    rl.line = "";
+    rl.cursor = 0;
+  }
+}
+
+// ---------- REPL ----------
+async function main() {
+  console.log(cyan("GoNext agent REPL") + dim(` v${REPL_VERSION} · API ${apiBase} · key ${workerKey.slice(0, 8)}…`));
+  // Task #127, Phase 2: the REPL enqueues jobs that the polling DAEMON executes, so ensure
+  // one is running — no GoTerminal needed. Idempotent + BC4-safe: startDaemon() no-ops when
+  // a daemon (ours, GoTerminal's, or a manual one) is already alive. Best-effort; a failure
+  // here shouldn't block the REPL (the user can `gonext-cli start` manually).
+  try {
+    const ctl = await import("./daemon-control.mjs");
+    const r = await ctl.startDaemon();
+    if (r.started) {
+      console.log(dim(`  started background worker (pid ${r.pid}) · logs ${ctl.LOG_FILE}`));
+    }
+  } catch {
+    /* non-fatal — jobs just won't run until a daemon is started */
+  }
+  await ensureWorkspace();
+  // Restore this folder's remembered auto-test + deploy-target so the banner + agent-ask
+  // reflect them (both survive a fresh terminal in the same project).
+  sessionTestAuto = await loadSessionTestAuto(resolve(process.cwd()));
+  selectedServer = await loadSessionServer(resolve(process.cwd()));
+  sessionMaxCodeTokens = await loadSessionMaxCodeTokens(resolve(process.cwd()));
+  sessionRagMode = await loadSessionRagMode(resolve(process.cwd())); // task #97: local/cloud/null
+  // Task #104: seed the ↓ global OUTPUT-token total (user + coding-URL) from the API.
+  {
+    const t = await fetchOutputTokenTotals(resolve(process.cwd()));
+    { const g = pickGlobalTotal(t); if (g !== null) globalOutputTokens = g; }
+  }
+  // Show which models will answer, straight from user settings (also validates auth).
+  try {
+    const probe = await fetchAgentPayload([{ role: "user", content: "ping" }]);
+    const p = probe?.payload ?? {};
+    // Remember the default coder id for the token footer's global-total label, and the
+    // default backend's coding URL so the GLOBAL output-token total is keyed to it (task
+    // #125) when no /model override is active.
+    if (p.codingModelId) defaultCodingModel = p.codingModelId;
+    if (p.codingBaseURL) defaultCodingUrl = p.codingBaseURL;
+    // RAG storage choice (task #97): ask ONCE per folder, and only when RAG is actually
+    // enabled in Settings. Default Yes = LOCAL (kept on this machine, no S3 needed).
+    if (p.ragEnabled && sessionRagMode === null) {
+      const local = await askYesNo(
+        "Store this folder's RAG knowledge base LOCALLY on this machine?\n" +
+          "(Yes = local, kept in ~/.gonext per folder — no S3 needed; No = cloud, your S3 bucket)",
+        true /* default Yes = local */
+      );
+      sessionRagMode = local ? "local" : "cloud";
+      await saveSessionRagMode(resolve(process.cwd()), sessionRagMode);
+    }
+    console.log(
+      dim(
+        `agent model: ${p.agentModelId || probe?.modelKey || "?"}` +
+          (p.codingModelId ? ` · coder: ${p.codingModelId}` : "") +
+          (p.ragEnabled ? ` · RAG ${sessionRagMode === "cloud" ? "cloud" : "local"}` : "") +
+          ` · auto-test: ${sessionTestAuto ? "on" : "off"}` +
+          (selectedServer ? ` · deploy: ${selectedServer.name} (${selectedServer.user}@${selectedServer.host})` : "")
+      ) + (sessionTestAuto ? "" : dim(" (/test-auto to enable)"))
+    );
+    // Task #127, Phase 3: if the base chat model server isn't answering, offer to set it up
+    // (download + start mlx_lm.server). BC3: only runs when NOTHING answers — an already-up
+    // model is left untouched, and this is skipped entirely. Interactive TTYs only.
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+      try {
+        const md = await import("./model-doctor.mjs");
+        const chatUrl = String(p.agentBaseURL || "").trim() || `http://127.0.0.1:${md.DEFAULT_CHAT_PORT}`;
+        if (!(await md.probeModelServer(chatUrl))) {
+          console.log(
+            dim(`\ngonext: the chat model server (${md.modelRoot(chatUrl)}) isn't responding.`)
+          );
+          const go = await askYesNo("Set up the base model now (download if needed + start)?", true);
+          if (go) {
+            await md.runDoctor({
+              apiBase,
+              workerKey,
+              log: (s) => console.log(s),
+              confirm: (q, defYes) => askYesNo(q, defYes),
+            });
+          } else {
+            console.log(dim("  Skipped. Run `gonext-cli doctor` anytime to set it up.\n"));
+          }
+        }
+      } catch {
+        /* doctor is best-effort — never block the REPL from starting */
+      }
+      // Task #127: the default coding model is a cloud coder (Kimi K3) with no API key yet.
+      // Ask for it (masked). If skipped, the account stays in this "waiting" state
+      // (server-side: coder configured, no key) and we ASK AGAIN on every startup until it's
+      // set. Until then the agent falls back to the chat model for coding (see the payload's
+      // codingKeyMissing handling), so the terminal still works. Logic lives in a module so
+      // it's unit-testable with a mock ask/save.
+      const { promptCodingKeyIfMissing } = await import("./coding-key-prompt.mjs");
+      await promptCodingKeyIfMissing(p, {
+        askSecret,
+        saveCodingKey,
+        log: (s) => console.log(s),
+        colors: { dim, cyan, green, red },
+      });
+    }
+  } catch (err) {
+    // Task #127 (zero-config): a freshly-paired account is seeded with a default local
+    // agent model, so this "no model" path is normally unreachable. An account paired
+    // BEFORE that change has none — point them at re-login, which now seeds it, rather than
+    // only the raw web-Settings instruction.
+    if (/no agent model configured/i.test(err?.message ?? "")) {
+      console.error(
+        red("gonext: no agent model is configured for your account yet.") +
+          dim(
+            "\n  Run `gonext-cli login` to re-connect — new logins set up a local" +
+              "\n  default automatically. Or set the Agent model URL in the web app → Settings → Agent."
+          )
+      );
+    } else {
+      console.error(red(`gonext: ${err.message}`));
+    }
+    process.exit(1);
+  }
+  console.log(dim("Ask about this repo. Type / to see commands (Tab completes). Ctrl-C aborts a running turn.\n"));
+
+  const cwd = resolve(process.cwd());
+  const history = await loadSession(cwd);
+  if (history.length > 0) {
+    const turns = history.filter((m) => m.role === "user").length;
+    console.log(
+      dim(`Resumed session: ${turns} prior turn(s) from last time in this folder — /reset to start fresh.\n`)
+    );
+  }
+  // Ctrl-C arrives on ONE of two paths depending on the readline mode: with
+  // terminal:true (real TTY) readline's raw-mode byte scanning intercepts \x03 and
+  // emits rl "SIGINT" (no OS signal is delivered); with terminal:false (piped input)
+  // the OS delivers a real SIGINT to the process. Attach the same handler to both —
+  // only one can ever fire for a given mode, so there's no double-handling.
+  const onInterrupt = () => {
+    // Ctrl+C while a picker is up = cancel it.
+    if (listPickerActive) finishList(-1);
+    // Ctrl+C while the approval picker is up = decline it (and fall through to also
+    // cancel the turn) — otherwise the poll loop stays blocked awaiting a choice.
+    if (approvalActive) finishApproval(false);
+    if (following) {
+      if (!cancelRequested && currentJobId) {
+        // First Ctrl+C: actually CANCEL the running turn server-side (stop the model),
+        // not just detach. The worker sees the "cancelled" status and kills the Python
+        // agent; the poll loop then returns cleanly with the "(cancelled)" note.
+        cancelRequested = true;
+        const jobId = currentJobId;
+        process.stdout.write(red("\n^C ") + dim("stopping the agent…\n"));
+        fetch(`${apiBase}/api/worker/jobs/cancel`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
+          body: JSON.stringify({ jobId }),
+        }).catch(() => {
+          /* best-effort — the worker also self-detects via the chunk 409 path */
+        });
+      } else {
+        // Second Ctrl+C (or no jobId yet): give up waiting locally. The worker keeps
+        // trying to stop, but we stop following.
+        followAborted = true;
+        process.stdout.write(red("\n^C "));
+      }
+    } else {
+      // Ctrl+C at a prompt with the slash overlay open = dismiss the overlay first (#109).
+      if (slashOverlayActive) closeSlashOverlay();
+      process.stdout.write(dim("\n(/exit to quit)\n"));
+      // Discard anything half-typed (Ctrl-C at a prompt means "never mind") and
+      // redraw through readline so its cursor tracking stays right.
+      rl.line = "";
+      rl.cursor = 0;
+      rl.prompt();
+    }
+  };
+  process.on("SIGINT", onInterrupt);
+  rl.on("SIGINT", onInterrupt);
+
+  // The task from the most recent Ctrl+C-cancelled turn — so a bare "continue" right after
+  // resumes it. A cancelled turn is popped from history (nothing to continue otherwise), so
+  // without this "continue" reaches the agent with no task and it replies as generic chat.
+  let lastCancelledTask = "";
+
+  for (;;) {
+    rl.prompt();
+    // Absorb blank Enter-presses SILENTLY under the same prompt — without this, lines
+    // typed while the agent was busy on a long turn (queued, not yet read) all drain at
+    // once the moment the turn ends, each re-printing ">> " with no newline between them
+    // (e.g. ">> >> >> "). Only re-print the prompt for a genuine stdin close or input.
+    let lineRaw;
+    for (;;) {
+      lineRaw = await nextLine();
+      if (lineRaw === null || lineRaw.trim()) break;
+    }
+    if (lineRaw === null) break; // stdin closed
+    const line = lineRaw.trim();
+    if (line === "/exit" || line === "/quit") break;
+    if (line === "/" || line === "/help") {
+      printCommands();
+      continue;
+    }
+    if (line === "/model") {
+      await chooseModel();
+      continue;
+    }
+    if (line === "/server") {
+      await chooseServer();
+      await saveSession(cwd, history); // remember the pick for this folder
+      continue;
+    }
+    if (line === "/test-auto") {
+      sessionTestAuto = !sessionTestAuto;
+      await saveSession(cwd, history); // persist the choice for this folder
+      console.log(
+        (sessionTestAuto ? green("auto-test: ON") : dim("auto-test: OFF")) +
+          dim(
+            sessionTestAuto
+              ? " — the agent will verify its work and fix until it passes, for this folder.\n"
+              : " for this folder.\n"
+          )
+      );
+      continue;
+    }
+    if (line === "/rag-local") {
+      // Toggle this folder's RAG store between local disk and the cloud (S3). task #97.
+      sessionRagMode = sessionRagMode === "local" ? "cloud" : "local";
+      await saveSession(cwd, history); // persist the choice for this folder
+      console.log(
+        (sessionRagMode === "local" ? green("RAG: LOCAL") : dim("RAG: cloud")) +
+          dim(
+            sessionRagMode === "local"
+              ? " — this folder's knowledge base is stored on this machine (~/.gonext), no S3 needed.\n"
+              : " — this folder's knowledge base is stored in your S3 bucket.\n"
+          )
+      );
+      continue;
+    }
+    if (line === "/reset" || line === "/new") {
+      history.length = 0;
+      await clearSession(cwd);
+      console.log(dim("Session cleared — starting fresh.\n"));
+      continue;
+    }
+    if (line === "/output-token") {
+      // Task #104: print the OUTPUT-token total for THIS workspace (and the global one).
+      const t = await fetchOutputTokenTotals(cwd);
+      { const g = pickGlobalTotal(t); if (g !== null) globalOutputTokens = g; }
+      const ws = t && Number.isFinite(t.workspaceTotal) ? t.workspaceTotal : 0;
+      // Task #126: same saved-else-counter rule as the footer (pickGlobalTotal), not the
+      // raw counter — so /output-token and the live ↓ footer agree.
+      const gl = pickGlobalTotal(t) ?? globalOutputTokens;
+      console.log(
+        cyan(`↓ output tokens`) +
+          dim(` — this workspace: `) +
+          `${fmtTokens(ws)}` +
+          dim(`  ·  global (you + coding server): `) +
+          `${fmtTokens(gl)}\n`
+      );
+      continue;
+    }
+    if (line === "/reset-output-token-global") {
+      // Task #104: zero the GLOBAL (user + coding-URL) output-token counter AND clear all
+      // per-workspace counters, after confirm.
+      const ok = await askYesNo(
+        `Reset the GLOBAL output-token total (currently ${fmtTokens(globalOutputTokens)}) to 0? This also clears every workspace's output-token total.`,
+        false
+      );
+      if (!ok) {
+        console.log(dim("Cancelled — output-token totals unchanged.\n"));
+        continue;
+      }
+      const done = await resetGlobalOutputTokens();
+      if (done) {
+        globalOutputTokens = 0;
+        console.log(green("✓ global + workspace output-token totals reset to 0.\n"));
+      } else {
+        console.log(dim("Could not reset the output-token totals (API error).\n"));
+      }
+      continue;
+    }
+    if (line.startsWith("/revert")) {
+      const runId = line.split(/\s+/)[1] ?? "";
+      await new Promise((res) => {
+        const p = spawn(
+          process.execPath,
+          [join(DIR, "gonext-cli.mjs"), "workspace", "revert", ...(runId ? [runId] : [])],
+          { stdio: "inherit" }
+        );
+        p.on("exit", res);
+        p.on("error", res);
+      });
+      continue;
+    }
+    // Any OTHER "/…" is a typo/unknown command — don't send it to the agent as a
+    // question; point the user at /help (all real commands were handled above).
+    if (line.startsWith("/")) {
+      const cmd = line.split(/\s+/)[0];
+      console.log(dim(`unknown command: ${cmd} — type /help (or / then Tab) to list commands\n`));
+      continue;
+    }
+    // Resume a cancelled task: a BARE "continue" right after a Ctrl+C re-runs the ORIGINAL
+    // request. Only the immediately-next input may resume (consumed here) and only a bare
+    // continue-word — a message with real instructions is a new task. Slash commands above
+    // used `continue` and never reach here, so `/model` then "continue" still resumes.
+    const pendingResume = lastCancelledTask;
+    lastCancelledTask = "";
+    let taskLine = line;
+    if (
+      pendingResume &&
+      /^(continue|resume|go on|keep going|carry on|proceed)\.?$/i.test(line)
+    ) {
+      taskLine = pendingResume;
+      const shown = pendingResume.length > 80 ? pendingResume.slice(0, 80) + "…" : pendingResume;
+      console.log(dim(`↻ resuming the cancelled task: ${shown}\n`));
+    }
+    history.push({ role: "user", content: taskLine });
+    try {
+      const { text: answer, shown, cancelled, inputTokens, outputTokens, turnOutputTokens } =
+        await runAgentTurn(history);
+      if (answer) {
+        history.push({ role: "assistant", content: answer });
+        // Persist after every successful turn (not just on clean exit) — an ungraceful
+        // termination (killed terminal, force-quit) would otherwise lose the whole
+        // session even though most of it completed fine.
+        await saveSession(cwd, history);
+        // A plain-reply answer already streamed live in the loop above — printing it
+        // again here would just duplicate it; a blank line is enough for spacing.
+        console.log(shown ? "" : `\n\n${answer}\n`);
+        // Task #104: persistent token footer at the bottom of the screen — this turn's
+        // code-model INPUT + this turn's OUTPUT (↓ out), then the model's GLOBAL lifetime
+        // output total (all turns for this user + coding server), labelled with the model
+        // name so it's clear which coder that running total belongs to. Guard on THIS turn's
+        // activity so a plain-reply greeting that did no code-model work shows nothing (#112).
+        if ((inputTokens ?? 0) > 0 || (turnOutputTokens ?? 0) > 0) {
+          const coder = sessionCodingLabel || defaultCodingModel;
+          console.log(
+            dim("tokens · ↑ in ") +
+              fmtTokens(inputTokens ?? 0) +
+              dim(" · ") +
+              cyan(`↓ out ${fmtTokens(turnOutputTokens ?? 0)}`) +
+              dim(" · ") +
+              dim(`${coder ? coder + " " : ""}total `) +
+              cyan(`↓ ${fmtTokens(outputTokens ?? 0)}`)
+          );
+        }
+      } else {
+        history.pop(); // aborted/failed/cancelled turn — don't poison the next request
+        // A turn that ended WITHOUT an answer (Ctrl+C cancel, or an abort/failure) must not
+        // silently launch another turn. Any keystrokes the user typed DURING the dead turn
+        // sit in `_lineQueue` — they land there (not ignored) whenever `following` was still
+        // false, e.g. during the agent-ask round-trip at the very start of the turn, or
+        // while the user was mashing "continue"/Enter. If left queued, `nextLine()` drains
+        // them back-to-back on the next loop iterations, each auto-firing a fresh turn that
+        // a straggler Ctrl+C then lands on — the reported "every turn immediately shows
+        // (cancelled)" loop. Drop that buffered input so the NEXT turn only starts when the
+        // user deliberately types something new (bug #92). Resume via "continue" still works:
+        // that's typed AFTER the cancel note, so it arrives through the live waiter, not the
+        // queue.
+        if (_lineQueue.length > 0) _lineQueue.length = 0;
+        // Ctrl+C cancel already printed its own "(cancelled)" note in runAgentTurn — a
+        // second "(no answer)" line here would be redundant/misleading.
+        if (cancelled) {
+          // Remember the ACTUAL task that ran (taskLine, not a bare "continue") so the
+          // next bare "continue" resumes it — even if it was cancelled during step 1,
+          // before any worker-side checkpoint step was written.
+          lastCancelledTask = taskLine;
+        } else {
+          console.log(red("\n(no answer — run aborted or failed)\n"));
+        }
+      }
+    } catch (err) {
+      history.pop();
+      // Same reasoning as the no-answer branch (bug #92): don't let input buffered during a
+      // turn that just threw auto-fire the next one.
+      if (_lineQueue.length > 0) _lineQueue.length = 0;
+      console.error(red(`\ngonext: ${err.message}\n`));
+    }
+  }
+  rl.close();
+  process.exit(0);
+}
+
+main();