openzoo 0.49.8 → 0.49.9

package/lib/grokui.mjs

@@ -8,12 +8,14 @@
 import { exec } from 'node:child_process';
 import http from 'node:http';
 import { randomUUID } from 'node:crypto';
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { closeSync, copyFileSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, statSync, writeFileSync, writeSync } from 'node:fs';
 import { cpus, homedir } from 'node:os';
 import path from 'node:path';
 import { adaptiveTopK, brain, brainRace, brainStream, tierModels, MODEL, PROXY, TIER_NAMES, normalizeTier } from './podagent.mjs';
+import { routeChatBody } from './modelroute.js';
 import { peekDirectiveStatus, formatRaceStatus, STALE_THINKING_MS, summarizeRaceFailures, RACE_EVERY_FAILED } from './livestatus.js';
 import { creditBalance } from './info.js';
+import { guardFindCwd } from './runguard.js';
 import {
   SUBSCRIPTIONS_PAGE,
   saveSubscription, clearSubscription,
@@ -31,6 +33,11 @@ import {
   extractBashPaths,
 } from './spill.js';
 import { BIND_MIN_CHARS } from './hrr.js';
+import { stripThinkTags, takeThink } from './think.js';
+import {
+  runClaudeCode, setClaudeRunnerForTest, toolStatusLine, CLAUDE_MISSING,
+  sanitizeClaudeCanvas, closeClaudeSession, GROKUI_RESERVED_SLASH, claudeModelArg,
+} from './claudecode.js';
 
 const PORT = Number(process.env.OZ_GROKUI_PORT || 4173);
 // BIND HOST. Default 127.0.0.1 so the desktop app never exposes a shell-capable
@@ -95,18 +102,11 @@ function stripBasePrefix(base, spec) {
 }
 
 /**
- * Reasoning models leak `<think>…</think>` / `<thinking>…` into the visible
- * reply. MEASURED live on thread tetris: the user-visible bubble contained
- * the raw tags, and the next turn sent them back to the model. Strip complete
- * blocks, an unclosed opener (live stream), and stray closers.
+ * Reasoning used to leak `<think>…</think>` into the visible bubble and then
+ * get sent back to the model. Visible text is still stripped (see takeThink);
+ * the plaintext is kept on the history row as `thinking` and folded in the
+ * canvas. Encrypted blobs never become a chip — that lives in lib/think.js.
  */
-function stripThinkTags(text) {
-  let s = String(text ?? '');
-  s = s.replace(/<think(?:ing)?\b[^>]*>[\s\S]*?<\/think(?:ing)?>/gi, '');
-  s = s.replace(/<think(?:ing)?\b[^>]*>[\s\S]*$/i, '');
-  s = s.replace(/<\/think(?:ing)?>/gi, '');
-  return s.replace(/^\n+|\n+$/g, '').trim();
-}
 const MIME = { html: 'text/html', htm: 'text/html', css: 'text/css', js: 'application/javascript',
   mjs: 'application/javascript', json: 'application/json', png: 'image/png', jpg: 'image/jpeg',
   jpeg: 'image/jpeg', gif: 'image/gif', svg: 'image/svg+xml', txt: 'text/plain', md: 'text/plain' };
@@ -211,6 +211,23 @@ function colorFor(name) {
   return PALETTE[h % PALETTE.length];
 }
 
+// Frozen SYSTEM is baked into old threads at creation. This string is also
+// injected every turn (extras + AUTO_DIRECTIVE) so live Auto cannot "shell
+// the proxy" just because the thread was born with the old "you CAN curl
+// :8402" paragraph. Site-check curls of localhost:8080 stay allowed.
+const CHAT_NOT_PROXY = `You already ARE the chat. Never RUN curl, wget, or fetch against localhost:8402 or
+/v1/chat/completions — that dumps another model's JSON into the canvas and pays twice.
+Orange Auto = WRITE / READ / RUN / GLOB for real work, not "shell the proxy."
+Never mkdir empty trees and declare DONE — WRITE the files.`;
+const PROXY_SHELL_REFUSE = 'refused: you already ARE the chat. Never curl/wget/fetch localhost:8402 or /v1/chat/completions — Orange Auto is WRITE/READ/RUN for real work, not shelling the proxy.';
+function looksLikeProxyShell(cmd) {
+  const s = String(cmd || '');
+  if (!/\b(curl|wget|fetch)\b/i.test(s)) return false;
+  if (/(?:localhost|127\.0\.0\.1|\[::1\])/i.test(s) && /:8402\b/.test(s)) return true;
+  if (/(?:localhost|127\.0\.0\.1|\[::1\])[^\s'"]*\/v1\/chat\/completions/i.test(s)) return true;
+  return false;
+}
+
 const SYSTEM = `You are a helpful assistant served over openzoo (pay-per-call access to ~435
 models, no API key, no account). Reply normally in plain text, concisely.
 
@@ -361,7 +378,7 @@ call. Ask for everything you know you need at once instead of discovering it one
 time. Mutating directives (RUN, WRITE, EDIT, SPAWN, SEND) stay sequential on purpose — racing
 them against each other corrupts the tree.
   RUN: <shell command>                                run a REAL shell command in this
-                                                       thread's directory — by default this
+                                                       thread's directory. Stay in that directory. Never find / — use GLOB: or find . -maxdepth N. By default this
                                                        pauses and waits for the user to
                                                        approve or deny it before anything
                                                        executes ("/mode auto" in chat skips
@@ -385,17 +402,7 @@ output and exit code back; that, not silence, is what failure looks like.
 Never fabricate command output, file contents, or payment receipts. If you did not run it,
 say so and then actually run it.
 
-Via RUN you can also make YOUR OWN paid openzoo calls — POST to
-http://localhost:8402/v1/chat/completions (or /v1/hrr/bind) with curl/python/etc. Auth is
-"Authorization: Bearer sk-openzoo" — any string works, x402 pays per call, not the key. Do
-NOT tell the user you "can't fire the paid calls" or need "their client's bearer key" —
-that's wrong, you can make these calls yourself via RUN. When you do, set max_tokens
-generously (1000+, not 50) — a reasoning model can burn its ENTIRE budget on internal
-reasoning before writing any visible answer, especially against a large bound corpus, and
-comes back with content:null and finish_reason:"length" (confirmed live) if you starve it.
-/v1/hrr/bind also caps around ~8MB per request after JSON-escaping — chunk large corpora
-(e.g. 512KB raw per request) and pass the PREVIOUS chunk's context_id on each next request
-to append to the same bound context, rather than one giant request that silently fails partway.
+${CHAT_NOT_PROXY}
 
 COST ACCOUNTING — do NOT compute this yourself from token counts. Every response carries an
 "x402" object; read the numbers off it: x402.billedUsd (what the user paid — OpenRouter price, plus 33% of savings vs
@@ -425,8 +432,16 @@ const turnAborts = new WeakMap();
 function saveThreads() {
   try {
     mkdirSync(STORE_DIR, { recursive: true });
-    writeFileSync(STORE_FILE, JSON.stringify([...threads.values()]));
-  } catch { /* best effort */ }
+    const data = JSON.stringify([...threads.values()]);
+    const fd = openSync(STORE_FILE, 'w');
+    try {
+      writeSync(fd, data);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    return true;
+  } catch { return false; }
 }
 
 function loadThreads() {
@@ -443,8 +458,16 @@ function loadThreads() {
       }
       if (Array.isArray(t.history)) {
         for (const h of t.history) {
-          if (h && h.who === 'bot' && typeof h.text === 'string') h.text = stripThinkTags(h.text);
+          if (h && h.who === 'bot' && typeof h.text === 'string') {
+            const parts = takeThink(h.text, h.thinking);
+            h.text = parts.text;
+            if (parts.thinking) h.thinking = parts.thinking;
+            else delete h.thinking;
+          }
         }
+        // AUTO continue / nudge / command-output hops must never come back
+        // as user bubbles after a remount. They are harness-only.
+        t.history = t.history.filter(isVisibleHistoryEntry);
       }
       if (Array.isArray(t.messages)) {
         for (const m of t.messages) {
@@ -507,6 +530,10 @@ function newThread(name, parent, members, spec) {
     ...(p?.race ? { race: p.race } : {}),
     ...(p?.raceNeed ? { raceNeed: p.raceNeed } : {}) };
   if (p) attachChildDir(t, p, spec);
+  // Brand-new chat (no parent) starts empty: own holobrain, no contextId,
+  // no boundItems. Do not copy the previous thread's bind / corpus.
+  // SPAWN kids also start unbound here; bindThread shares the parent root
+  // on first bind. Existing threads on disk keep whatever they already have.
   threads.set(id, t);
   saveThreads();
   return t;
@@ -630,6 +657,7 @@ savedUsd, savesVsDirect). Never derive it by summing usage.cost or usage.prompt_
 provider's list price: on a bound context prompt_tokens counts only the slice leCore
 recalled, not the corpus it stands in for, so that math prices the discount against itself
 and wrongly concludes the zoo cost more.
+${CHAT_NOT_PROXY}
 For normal replies just answer directly — do not use any of these unless the request
 actually calls for delegation or file work.` };
 }
@@ -650,8 +678,12 @@ function contentFor(text, images) {
 }
 
 function buildMemberMessages(t, member) {
-  const msgs = [{ role: 'system', content: member.systemPrompt || SYSTEM }];
+  const msgs = [
+    { role: 'system', content: member.systemPrompt || SYSTEM },
+    { role: 'system', content: CHAT_NOT_PROXY },
+  ];
   for (const h of t.history) {
+    if (h.who === 'user' && isHarnessUserText(h.text)) continue;
     if (h.who === 'user') msgs.push({ role: 'user', content: contentFor(h.text, h.images) });
     else if (h.name === member.name) msgs.push({ role: 'assistant', content: h.text });
     else msgs.push({ role: 'user', content: `[${h.name}]: ${h.text}` });
@@ -693,9 +725,7 @@ const NUDGE = 'That reply announced work instead of doing it — no directive li
   + 'RUN:, SPAWN:, READ:, WRITE:, GLOB:, FETCH:, MCP: or SERVE:. '
   + 'Exactly the syntax from your instructions — not [TOOL_CALL], not JSON, not a function-call envelope. '
   + 'If several steps are needed, emit the FIRST one; you get its real output back and continue from there.';
-const AUTO_CONTINUE = 'AUTO is still on — do not stop and do not ask the user to type continue. '
-  + 'Emit the next directive now (RUN:/SPAWN:/SEND:/READ:/WRITE:/GLOB:/FETCH:/MCP:/SERVE:), '
-  + 'or DONE: if the job is actually finished.';
+const AUTO_CONTINUE = 'Please continue the current job. Do not stop to ask the user.';
 const AUTO_RACE_RETRY = 'AUTO is still on — the last model call failed (race/empty/error). '
   + 'Do not stop and do not ask the user to type continue. '
   + 'Emit the next directive now (RUN:/SPAWN:/SEND:/READ:/WRITE:/GLOB:/FETCH:/MCP:/SERVE:), '
@@ -716,6 +746,34 @@ function isTransientModelFail(text) {
   if (/returned nothing \d+ times|each returned nothing/i.test(s)) return true;
   return false;
 }
+// Quiet Claude TUI / --model miss / chrome-only canvas. 1.5.99 PTY Auto
+// treated that as a finished turn, painted "(no response)" / "upstream HTTP N",
+// and went idle. Fall through to Ask/Auto chat-completions instead.
+function isClaudeFallbackReply(text) {
+  const s = String(text || '').trim();
+  if (!s) return true;
+  if (s === '(no response)') return true;
+  if (/^(?:error:\s*)?upstream HTTP \d+\s*$/i.test(s)) return true;
+  return false;
+}
+function isVisibleBotReply(h) {
+  if (!h || h.who !== 'bot') return false;
+  if (!isVisibleHistoryEntry(h)) return false;
+  const text = String(h.text || '').trim();
+  if (!text) return false;
+  if (isClaudeFallbackReply(text)) return false;
+  return true;
+}
+function threadHasVisibleBotReply(t) {
+  return (t?.history || []).some(isVisibleBotReply);
+}
+function popClaudeFallbackBot(t) {
+  if (!t || !Array.isArray(t.history) || !t.history.length) return false;
+  const last = t.history[t.history.length - 1];
+  if (last.who !== 'bot' || !isClaudeFallbackReply(last.text)) return false;
+  t.history.pop();
+  return true;
+}
 function isEmptyWalletPayment(text) {
   // Empty/underfunded only — not a generic HTTP 402 handshake.
   return /\b(?:wallet is empty|empty wallet|wallet underfunded|underfunded)\b/i.test(String(text || ''));
@@ -852,7 +910,22 @@ without a fact only the user has.
 When the job is actually finished, emit DONE: as the first line. A status
 sentence is not a stop — the harness keeps this thread working until DONE:,
 a real blocking question, or the step cap. Empty output, "(no output)", and
-GLOB/GREP with no matches are not finished — try a different command or path.`;
+GLOB/GREP with no matches are not finished — try a different command or path.
+
+${CHAT_NOT_PROXY}`;
+
+/**
+ * Holobrain owner for a thread.
+ * SPAWN kids share the project root (current SPAWN semantics).
+ * A brand-new chat (no parent) is its own root — never attach another
+ * thread's contextId / boundItems.
+ */
+function holobrainOf(t) {
+  if (!t) return null;
+  if (t.parent) return threads.get(rootOf(t).rootId) || t;
+  return t;
+}
+
 async function bindThread(t) {
   // Only bind what's NEW since the last successful bind, continuing the
   // existing context_id — previously this rebuilt and re-sent the WHOLE
@@ -867,15 +940,13 @@ async function bindThread(t) {
   const corpus = delta.map((h) => '[' + t.name + '] ' + (h.who === 'user' ? 'you' : (h.name || t.name)) + ': ' + h.text).join('\n');
   if (!corpus.trim()) { t.boundHistoryCount = t.history.length; return; }
   try {
-    // ONE CONTEXT PER PROJECT, not per thread. Every thread used to bind to
-    // its own private context, so sibling agents spawned for the same job were
-    // memory-isolated: arc-tetris-engine could not recall a thing
-    // arc-token-bets had established, and the user paid to re-explain shared
-    // facts to each one. They are a team; the memory should be too.
-    // The context lives on the ROOT and every descendant binds into it, while
-    // each thread keeps its OWN boundHistoryCount so nothing is re-sent.
-    const root = threads.get(rootOf(t).rootId) || t;
-    let ctx = root.contextId || t.contextId;
+    // SPAWN kids share the project root holobrain so sibling agents can
+    // recall what the crew already bound. A brand-new chat (no parent) is
+    // its own root — do not attach the previous thread's contextId.
+    // Existing threads that already have a bind keep it (we never delete
+    // contextId here).
+    const brain = holobrainOf(t) || t;
+    let ctx = brain.contextId || t.contextId;
     for (let i = 0; i < corpus.length; i += BIND_CHUNK_BYTES) {
       const part = corpus.slice(i, i + BIND_CHUNK_BYTES);
       const body = ctx ? { corpus: part, context_id: ctx } : { corpus: part };
@@ -889,12 +960,12 @@ async function bindThread(t) {
       // How many chunks the project's holobrain now holds. This is the number
       // adaptive top_k scales on — without it we would be guessing, which is
       // exactly how top_k ended up pinned at 8 in the first place.
-      if (Number(j?.bound)) root.boundItems = (root.boundItems || 0) + Number(j.bound);
+      if (Number(j?.bound)) brain.boundItems = (brain.boundItems || 0) + Number(j.bound);
       else break; // this chunk failed — stop, keep whatever bound so far rather than lose it all
     }
-    // Write to the ROOT so later siblings inherit it, and to this thread so
-    // the per-call header is readable without walking the tree again.
-    if (ctx) { root.contextId = ctx; t.contextId = ctx; t.boundHistoryCount = t.history.length; saveThreads(); }
+    // Write to the holobrain owner (project root for SPAWN kids, this thread
+    // for a new chat) and to this thread so the per-call header is local.
+    if (ctx) { brain.contextId = ctx; t.contextId = ctx; t.boundHistoryCount = t.history.length; saveThreads(); }
   } catch { /* leCore sidecar unreachable — thread still works, just not bound this round */ }
 }
 
@@ -1035,8 +1106,10 @@ const RUN_SHELL = process.platform !== 'win32' && existsSync('/bin/bash') ? '/bi
 const RUN_TIMEOUT_MS = Number(process.env.OZ_RUN_TIMEOUT_MS || 600000);
 
 function execCommand(command, cwd) {
+  if (looksLikeProxyShell(command)) return Promise.resolve(PROXY_SHELL_REFUSE);
+  const guarded = guardFindCwd(command, cwd);
   return new Promise((resolve) => {
-    exec(command, { cwd, shell: RUN_SHELL, timeout: RUN_TIMEOUT_MS, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+    exec(guarded, { cwd, shell: RUN_SHELL, timeout: RUN_TIMEOUT_MS, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
       let out = (stdout || '') + (stderr ? '\n' + stderr : '');
       if (err) out += `\n(exit ${err.code ?? 1})`;
       resolve(keepWhole(out).trim() || '(no output)');
@@ -1083,11 +1156,41 @@ const SLASH_COMMANDS = [
   { name: '/cron', args: '<mins> | <message>', help: 'repeat a message on a timer' },
   { name: '/crons', args: '', help: 'list timers  (/cron del <id> removes one)' },
   { name: '/dir', args: '<path>', help: 'set this thread’s working directory' },
-  { name: '/mode', args: 'auto|ask', help: 'run commands immediately, or ask first' },
+  { name: '/mode', args: 'auto|ask', help: 'Auto = Claude Code via OpenZoo; ask = chat + approve RUN' },
 ];
 
+/** Claude TUI slashes that grokui must not intercept in Auto. /model is
+ *  Claude's picker here — grokui's /model pin stays on ask mode. */
+const CLAUDE_SLASH_IN_AUTO = new Set(['agents', 'tasks', 'context', 'model']);
+
+function isGrokuiOwnedSlash(line, runMode) {
+  const cmd = /^\/(\w+)/.exec(String(line || '').trim())?.[1]?.toLowerCase();
+  if (!cmd) return false;
+  if (GROKUI_RESERVED_SLASH.includes(cmd)) return true;
+  if (runMode === 'auto' && CLAUDE_SLASH_IN_AUTO.has(cmd)) return false;
+  return SLASH_COMMANDS.some((c) => c.name.slice(1).toLowerCase() === cmd)
+    || cmd === 'pay' || cmd === 'hud';
+}
+
 const usd = (n) => (n >= 0.01 || n === 0 ? '$' + n.toFixed(2) : '$' + n.toFixed(5));
 
+/**
+ * HUD / sitrep / /cost: prefer spilled-call x when anything bound.
+ * Never an unlabeled Nx — "2.10x spilled" vs "2.10x session".
+ * Rounding: 100+ integer, 10+ 1dp, else 2dp.
+ */
+function formatSavingLabel(you) {
+  const spent = Number(you && you.spentUsd) || 0;
+  if (spent <= 0) return { text: '—', mult: null, spilled: false };
+  const spillX = Number(you && you.spilled && you.spilled.savingX);
+  const sessionX = (Number(you && you.directUsd) || 0) / spent;
+  const spilled = Number.isFinite(spillX) && spillX > 0;
+  const mult = spilled ? spillX : sessionX;
+  if (!Number.isFinite(mult)) return { text: '—', mult: null, spilled: false };
+  const num = (mult >= 100 ? String(Math.round(mult)) : Number(mult).toFixed(mult >= 10 ? 1 : 2)) + 'x';
+  return { text: num + (spilled ? ' spilled' : ' session'), mult, spilled };
+}
+
 // BIND, DON'T PASTE — the whole point of the thing this runs on.
 //
 // Directive results get fed back to the model as a user message, verbatim. A
@@ -1215,8 +1318,8 @@ function inFlightChars(t) {
  */
 function scheduleFilesForCorpus(t, collected, opts = {}) {
   if (!collected?.pending?.length) return null;
-  const root = t ? (threads.get(rootOf(t).rootId) || t) : null;
-  const ctx = opts.contextId || root?.contextId || t?.contextId || null;
+  const brain = t ? holobrainOf(t) : null;
+  const ctx = opts.contextId || brain?.contextId || t?.contextId || null;
   const chars = opts.sentChars ?? inFlightChars(t);
   const background = chars < BIND_MIN_CHARS;
   const fetchImpl = opts.fetchImpl || fetch;
@@ -1233,7 +1336,7 @@ function scheduleFilesForCorpus(t, collected, opts = {}) {
     }).then(async (r) => {
       const j = await r.json().catch(() => ({}));
       if (j?.context_id && t) {
-        const live = threads.get(rootOf(t).rootId) || t;
+        const live = holobrainOf(t) || t;
         live.contextId = j.context_id;
         t.contextId = j.context_id;
         if (Number(j.bound)) live.boundItems = (live.boundItems || 0) + Number(j.bound);
@@ -1301,9 +1404,20 @@ function emitToThread(threadId, ev) {
   }
 }
 
+async function attachSpilled(you) {
+  if (!you || you.spilled != null) return you;
+  try {
+    const info = await (await fetch(`${PROXY}/info`, { signal: AbortSignal.timeout(2000) })).json();
+    if (info && info.spilled) you.spilled = info.spilled;
+  } catch { /* session label stays honest if info is down */ }
+  return you;
+}
+
 async function sessionStats() {
-  try { return await (await fetch(`${PROXY}/session`, { signal: AbortSignal.timeout(2000) })).json(); }
-  catch { return null; }
+  try {
+    const s = await (await fetch(`${PROXY}/session`, { signal: AbortSignal.timeout(2000) })).json();
+    return attachSpilled(s);
+  } catch { return null; }
 }
 
 function todoBlock(t) {
@@ -1328,7 +1442,7 @@ async function handleSlash(task, t) {
   }
   if (cmd === 'tools') {
     return 'Directives:\n'
-      + '  RUN: <cmd>                          real shell, in this thread’s dir\n'
+      + '  RUN: <cmd>                          real shell, in this thread’s dir (never find /)\n'
       + '  WRITE: <path> | <content>           create/overwrite a file\n'
       + '  EDIT: <path> | <old> ||| <new>      change part of a file\n'
       + '  MULTIEDIT: <path> | a|||b ;; c|||d  several edits, all-or-nothing\n'
@@ -1349,6 +1463,20 @@ async function handleSlash(task, t) {
       + 'READ, LS, GLOB, GREP, FETCH, PEEK and MCP run CONCURRENTLY when several\n'
       + 'appear in one reply — four files cost one round trip, not four.';
   }
+  // Header Pay / ◎ echo through the same /drive → history.push path as
+  // /mode and /tier. Short lines only — never wallet JSON or a sitrep dump.
+  if (cmd === 'pay') {
+    return 'Pay — card checkout or the local wallet/x402 burner. Drawer opened.';
+  }
+  if (cmd === 'hud') {
+    const s = await sessionStats();
+    const mode = t.runMode || 'ask';
+    const tier = t.tier || 'auto';
+    if (!s) return `Sitrep — mode ${mode} · ${tier} · proxy unreachable.`;
+    const spent = Number(s.spentUsd) || 0;
+    const sav = formatSavingLabel(s);
+    return `Sitrep — mode ${mode} · ${tier} · paid ${usd(spent)} · ${sav.text} · ${s.paidCalls || 0} calls`;
+  }
   if (cmd === 'cost' || cmd === 'tokens') {
     const s = await sessionStats();
     if (!s) return 'The local openzoo proxy isn’t reachable, so there are no real numbers to show. (Not zero — unknown.)';
@@ -1360,9 +1488,9 @@ async function handleSlash(task, t) {
       `  paid calls      ${s.paidCalls || 0}`,
     ];
     if (spent > 0) {
-      const mult = direct / spent;
-      lines.push(`  multiple        ${mult >= 100 ? Math.round(mult) : mult.toFixed(2)}x`
-        + (mult < 1 ? '  — under 1x: small inputs cost MORE than sending them directly' : ''));
+      const sav = formatSavingLabel(s);
+      lines.push(`  multiple        ${sav.text}`
+        + (sav.mult != null && sav.mult < 1 ? '  — under 1x: small inputs cost MORE than sending them directly' : ''));
     }
     return 'This session:\n' + lines.join('\n');
   }
@@ -1377,16 +1505,27 @@ async function handleSlash(task, t) {
   // tier silently overriding an explicit id would make /model a suggestion.
   if (cmd === 'tier') {
     if (!arg) {
-      const picks = await tierModels(t.tier || 'medium', 3);
-      return `This thread: ${t.tier || 'medium'}${t.tier ? '' : '  (default)'}\n`
-        + `Tiers: ${TIER_NAMES.join(' · ')}\n`
-        + `Top of ${t.tier || 'medium'} right now: ${picks.join(', ')}\n`
+      const cur = t.tier || 'auto';
+      if (cur === 'auto') {
+        return `This thread: auto  (classifier — openzoo/auto)\n`
+          + `Tiers: auto · ${TIER_NAMES.join(' · ')}\n`
+          + (t.model ? `NOTE: /model ${t.model} is pinned on this thread, so Auto is ignored until you /model default.\n` : '')
+          + 'Switch with  /tier <name>   ·  /race <n> to ask several at once.';
+      }
+      const picks = await tierModels(cur, 3);
+      return `This thread: ${cur}\n`
+        + `Tiers: auto · ${TIER_NAMES.join(' · ')}\n`
+        + `Top of ${cur} right now: ${picks.join(', ')}\n`
         + (t.model ? `NOTE: /model ${t.model} is pinned on this thread, so the tier is ignored until you /model default.\n` : '')
         + 'Switch with  /tier <name>   ·  /race <n> to ask several at once.';
     }
     const want = normalizeTier(arg);
-    if (!want) return `Unknown tier "${arg}". One of: ${TIER_NAMES.join(', ')} (also: grok 4.6).`;
+    if (!want) return `Unknown tier "${arg}". One of: auto, ${TIER_NAMES.join(', ')} (also: grok 4.6).`;
     t.tier = want; saveThreads();
+    if (want === 'auto') {
+      return 'This thread now uses Auto — cheapest model that clears the bar (openzoo/auto).'
+        + (t.model ? `\nBut /model ${t.model} is still pinned and wins. Run /model default to let Auto take over.` : '');
+    }
     const picks = await tierModels(want, 3);
     return `This thread now runs on the ${want} tier — ${picks.join(', ')}…`
       + (t.model ? `\nBut /model ${t.model} is still pinned and wins. Run /model default to let the tier take over.` : '');
@@ -1521,7 +1660,7 @@ async function handleSlash(task, t) {
 
   // Wake the room. Used to be a free last-line dump — idle children stayed
   // idle, and a parent reading "kid: <old reply>" thought they had acted.
-  // Empty extra is a nudge (AUTO_CONTINUE), not a cancel. Thinking stays
+  // Empty extra is a continue wake (Claude Code on Auto), not a cancel. Thinking stays
   // thinking; pendingRun stays on the human. Same branch scope as /all.
   if (cmd === 'ping') {
     const crew = subtreeOf(t.id, true);
@@ -1884,6 +2023,69 @@ function isHarnessUserText(text) {
     || String(text || '').startsWith('AUTO_EMPTY_RETRY:');
 }
 
+function isVisibleHistoryEntry(h) {
+  if (!h) return false;
+  if (h.who === 'user' && (h.harness || isHarnessUserText(h.text))) return false;
+  return true;
+}
+
+function visibleHistory(history) {
+  return (history || []).filter(isVisibleHistoryEntry);
+}
+
+function sameUserTurn(entry, userText, images) {
+  if (!entry || entry.who !== 'user') return false;
+  if (String(entry.text || '') !== String(userText || '')) return false;
+  const a = entry.images || [];
+  const b = images || [];
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+
+// Flush the user's turn to RAM + grokui-threads.json BEFORE any model call
+// or UI refresh. A 500 / sidecar bounce / sitrep redraw used to wipe the
+// bubble because it lived only in the live stream. Do not roll this back
+// if the upstream request later fails. Harness continues (AUTO_CONTINUE,
+// AUTO_RACE_RETRY, NUDGE, command-output hops) are not user bubbles.
+function persistUserTurn(t, userText, images) {
+  if (!t) return { ok: false };
+  if (isHarnessUserText(userText)) return { ok: true, skipped: true };
+  if (!Array.isArray(t.history)) t.history = [];
+  const last = t.history[t.history.length - 1];
+  if (sameUserTurn(last, userText, images) && isVisibleHistoryEntry(last)) {
+    t.lastActivityAt = Date.now();
+    saveThreads();
+    return { ok: true, already: true, entry: last };
+  }
+  const entry = images && images.length
+    ? { who: 'user', text: userText, images: images.slice() }
+    : { who: 'user', text: userText };
+  t.history.push(entry);
+  let pushedMsg = false;
+  if (Array.isArray(t.messages)) {
+    const lastMsg = t.messages[t.messages.length - 1];
+    let alreadyMsg = false;
+    if (lastMsg && lastMsg.role === 'user') {
+      const want = contentFor(userText, images);
+      alreadyMsg = lastMsg.content === want
+        || (typeof lastMsg.content === 'string' && lastMsg.content === String(userText || ''));
+    }
+    if (!alreadyMsg) {
+      t.messages.push({ role: 'user', content: contentFor(userText, images) });
+      pushedMsg = true;
+    }
+  }
+  t.lastActivityAt = Date.now();
+  const saved = saveThreads();
+  if (!saved) {
+    t.history.pop();
+    if (pushedMsg && Array.isArray(t.messages)) t.messages.pop();
+    return { ok: false };
+  }
+  return { ok: true, entry };
+}
+
 function firstUserAsk(t) {
   return (t?.history || []).find((m) => m.who === 'user' && !isHarnessUserText(m.text));
 }
@@ -1911,7 +2113,7 @@ function spawnBrief(parent, { refresh = false, child } = {}) {
   const cwd = child?.dir || WORKSPACE_DIR;
   const branch = child?.worktree?.branch;
   const mode = parent.runMode || 'ask';
-  const tier = parent.tier || 'medium';
+  const tier = parent.tier || 'auto';
   const race = Number(parent.race) || 0;
   const raceNeed = Number(parent.raceNeed) || 1;
   const model = parent.model || '';
@@ -2622,12 +2824,141 @@ async function mcpDirective(url, tool, args) {
   }
 }
 
+function autoClaudePrompt(t, userText, images) {
+  const bits = [];
+  if (t.memory?.length) bits.push(`Remember, for this thread:\n${t.memory.map((x) => `- ${x}`).join('\n')}`);
+  if (t.todos?.length) {
+    bits.push(`Current checklist:\n${t.todos.map((x, i) => `${i + 1}. [${x.done ? 'x' : ' '}] ${x.text}`).join('\n')}`);
+  }
+  if (images?.length) bits.push(`(${images.length} image(s) were attached in the desktop UI; work from the text ask.)`);
+  bits.push(String(userText || ''));
+  return bits.join('\n\n');
+}
+
+/**
+ * Orange Auto = interactive `claude` on a PTY (same env as `openzoo claude`).
+ * Not --print, not the RUN:/WRITE:/DONE: text harness. Chat-box lines go to
+ * PTY stdin; TUI output is stripped / folded onto the canvas.
+ */
+async function runAutoClaudeTurn(t, userText, images, paint, stillMine, turnAbort) {
+  paint({ type: 'start', name: t.name, color: t.color, detail: t.liveStatus || 'Claude Code via OpenZoo…' });
+  // Child is alive: canvas must show a folded thinking… row immediately,
+  // before the first thinking_delta or tool_use.
+  paint({ type: 'think', name: t.name, color: t.color, delta: '' });
+  let visible = '';
+  let thinking = '';
+  const toolLines = [];
+  let streamedText = false;
+  const noteTool = (name, input) => {
+    const line = toolStatusLine(name, input);
+    if (!line || toolLines[toolLines.length - 1] === line) return;
+    toolLines.push(line);
+    paint({ type: 'tool', name: t.name, color: t.color, detail: line });
+  };
+  const keepFold = () => paint({ type: 'think', name: t.name, color: t.color, delta: '' });
+  const result = await runClaudeCode({
+    prompt: autoClaudePrompt(t, userText, images),
+    cwd: dirFor(t.id),
+    sessionId: t.claudeSessionId,
+    sessionKey: t.id,
+    model: claudeModelArg(t.model),
+    env: process.env,
+    signal: turnAbort.signal,
+    onEvent(folded) {
+      if (!stillMine() || !folded) return;
+      if (folded.sessionId) t.claudeSessionId = folded.sessionId;
+      if (folded.kind === 'init' || folded.kind === 'partial' || folded.kind === 'tool_result') {
+        keepFold();
+        return;
+      }
+      if (folded.kind === 'tool') {
+        noteTool(folded.name, folded.input);
+        return;
+      }
+      if (folded.kind === 'think') {
+        if (folded.text) {
+          thinking += folded.text;
+          paint({ type: 'think', name: t.name, color: t.color, delta: folded.text });
+        } else {
+          keepFold();
+        }
+        return;
+      }
+      if (folded.kind === 'text' && folded.text) {
+        const clean = sanitizeClaudeCanvas(folded.text);
+        if (!clean) {
+          keepFold();
+          return;
+        }
+        streamedText = true;
+        if (folded.replace) visible = clean;
+        else visible += clean;
+        paint({ type: 'delta', name: t.name, color: t.color, delta: clean, replace: Boolean(folded.replace) });
+        return;
+      }
+      if (folded.kind === 'tui') {
+        if (folded.thinking && folded.thinking !== thinking) {
+          thinking = folded.thinking;
+          paint({ type: 'think', name: t.name, color: t.color, delta: folded.thinking, replace: true });
+        } else {
+          keepFold();
+        }
+        const tuiText = folded.text ? sanitizeClaudeCanvas(folded.text) : '';
+        if (tuiText && tuiText !== visible) {
+          visible = tuiText;
+          streamedText = true;
+          paint({ type: 'delta', name: t.name, color: t.color, delta: tuiText, replace: true });
+        }
+        for (const tool of folded.tools || []) noteTool(tool.name, tool.input);
+        return;
+      }
+      if (folded.kind !== 'assistant') return;
+      if (folded.thinking && !thinking) {
+        thinking = folded.thinking;
+        paint({ type: 'think', name: t.name, color: t.color, delta: folded.thinking });
+      } else {
+        keepFold();
+      }
+      if (folded.text && !streamedText) {
+        const clean = sanitizeClaudeCanvas(folded.text);
+        if (clean) {
+          visible = clean;
+          paint({ type: 'delta', name: t.name, color: t.color, delta: clean, replace: true });
+        }
+      }
+      for (const tool of folded.tools || []) noteTool(tool.name, tool.input);
+    },
+  });
+  if (!stillMine()) {
+    return sanitizeClaudeCanvas(result.paymentFailed || result.text || visible || '', { error: result.error });
+  }
+  if (result.sessionId) t.claudeSessionId = result.sessionId;
+  const thinkAll = [thinking, ...toolLines].filter(Boolean).join('\n');
+  let finalText = result.paymentFailed
+    || result.text
+    || visible
+    || (result.missing ? CLAUDE_MISSING : '');
+  if (!result.paymentFailed && !result.missing) {
+    finalText = sanitizeClaudeCanvas(finalText, { error: result.error });
+  }
+  if (!finalText) finalText = result.error ? 'upstream HTTP 400' : '(no response)';
+  // Empty / chrome-only / HTTP-N: do not commit a dead bot row. runTurn pops
+  // any that slipped through and falls through to Ask/Auto chat-completions.
+  if (isClaudeFallbackReply(finalText) && !result.paymentFailed && !result.missing) {
+    return finalText;
+  }
+  t.history.push({ who: 'bot', text: finalText, thinking: thinkAll || undefined });
+  paint({ type: 'final', name: t.name, color: t.color, text: finalText, thinking: thinkAll || undefined });
+  return finalText;
+}
+
 // onEvent (optional) gets live progress for whoever's actually watching this
 // call: {type:'start',name,color} when a bot begins its turn, {type:'status',
 // detail} while paying / waiting / racing / walking tools, {type:'race',race}
 // for the spectator grid (one cell per launched model + a judging beat),
 // {type:'delta',name,color,delta} per streamed token (replace:true swaps the
-// bubble once), {type:'final',name,color,text} once its full reply (or
+// bubble once), {type:'think',delta} for folded chain-of-thought (not the
+// Auto run-mode chip), {type:'final',name,color,text} once its full reply (or
 // directive ack) is settled. Background turns go through kickTurn →
 // emitToThread, which is a no-op if nobody has the thread open.
 async function runTurn(threadId, userText, onEvent, images) {
@@ -2647,14 +2978,15 @@ async function runTurn(threadId, userText, onEvent, images) {
     if (!stillMine()) return;
     if (ev.type === 'status' && ev.detail && t.status === 'thinking') t.liveStatus = ev.detail;
     if (ev.type === 'race' && ev.race && t.status === 'thinking') t.liveRace = ev.race;
-    if (ev.type === 'delta' || ev.type === 'status' || ev.type === 'start' || ev.type === 'race') t.lastDeltaAt = Date.now();
+    if (ev.type === 'delta' || ev.type === 'think' || ev.type === 'status' || ev.type === 'start' || ev.type === 'race' || ev.type === 'tool') t.lastDeltaAt = Date.now();
     onEvent?.(ev);
   };
-  t.history.push(images && images.length ? { who: 'user', text: userText, images } : { who: 'user', text: userText });
+  persistUserTurn(t, userText, images);
   t.lastActivityAt = Date.now();
   t.status = 'thinking';
   t.thinkingAt = Date.now();
   t.lastDeltaAt = Date.now();
+  saveThreads();
   try { turnAborts.get(t)?.abort(); } catch { /* none */ }
   const turnAbort = new AbortController();
   turnAborts.set(t, turnAbort);
@@ -2665,6 +2997,8 @@ async function runTurn(threadId, userText, onEvent, images) {
   t.liveStatus = (!t.model && raceN >= 2) ? formatRaceStatus(0, raceNeed) : 'waiting on model…';
   let chained = false;
   let parked = false;
+  let usedClaude = false;
+  let claudeFallback = false;
   let lastReply = '';
   try {
   if (t.members) {
@@ -2680,11 +3014,15 @@ async function runTurn(threadId, userText, onEvent, images) {
       const emitStatus = (detail) => paint({ type: 'status', name: m.name, color: m.color, detail });
       try {
         r = onEvent
-          ? (await brainStream(msgs, (delta) => paint({ type: 'delta', name: m.name, color: m.color, delta }), t.contextId, undefined, undefined, 0, 0, emitStatus)).trim()
+          ? (await brainStream(msgs, (delta, meta) => {
+            if (meta?.think) paint({ type: 'think', name: m.name, color: m.color, delta });
+            else paint({ type: 'delta', name: m.name, color: m.color, delta });
+          }, t.contextId, undefined, undefined, 0, 0, emitStatus)).trim()
           : (await brain(msgs, t.contextId)).trim();
       } catch (e) { r = `error: ${e.message}`; }
       if (!stillMine()) return;
-      r = stripThinkTags(r);
+      const memberThink = takeThink(r);
+      r = memberThink.text;
       memberReply = r;
       const runCmd = parseRun(r);
       if (runCmd) {
@@ -2694,16 +3032,19 @@ async function runTurn(threadId, userText, onEvent, images) {
           const output = await execCommand(command, dirFor(t.id));
           noteRunForCorpus(t.id, command, { cwd: dirFor(t.id) });
           const shown = `$ ${command}\n${output}`;
-          t.history.push({ who: 'bot', text: shown, name: m.name, color: m.color });
-          paint({ type: 'final', name: m.name, color: m.color, text: shown });
+          t.history.push({
+            who: 'bot', text: command, runStatus: 'done', runOutput: output,
+            name: m.name, color: m.color, thinking: memberThink.thinking,
+          });
+          paint({ type: 'final', name: m.name, color: m.color, text: command, thinking: memberThink.thinking });
           memberReply = shown;
           // this member's turn is done; the round continues to the next member
           continue;
         }
         const runId = randomUUID();
         t.pendingRun = { runId, command, cwd: dirFor(t.id) };
-        t.history.push({ who: 'bot', text: command, runId, runStatus: 'pending', name: m.name, color: m.color });
-        paint({ type: 'run-pending', runId, command, name: m.name, color: m.color });
+        t.history.push({ who: 'bot', text: command, runId, runStatus: 'pending', name: m.name, color: m.color, thinking: memberThink.thinking });
+        paint({ type: 'run-pending', runId, command, name: m.name, color: m.color, thinking: memberThink.thinking });
         // pauses the WHOLE round here — the rest of the group gets their turn
         // on the round that runs after the user approves/denies
         parked = true;
@@ -2711,8 +3052,8 @@ async function runTurn(threadId, userText, onEvent, images) {
       }
       const ack = await tryDirective(r, t.id, paint);
       const finalText = ack ?? (r || '(no response)');
-      t.history.push({ who: 'bot', text: finalText, name: m.name, color: m.color });
-      paint({ type: 'final', name: m.name, color: m.color, text: finalText });
+      t.history.push({ who: 'bot', text: finalText, name: m.name, color: m.color, thinking: memberThink.thinking });
+      paint({ type: 'final', name: m.name, color: m.color, text: finalText, thinking: memberThink.thinking });
       memberReply = r;
     }
     bindThread(t).catch(() => {});
@@ -2722,6 +3063,38 @@ async function runTurn(threadId, userText, onEvent, images) {
     }
     return;
   }
+  // Orange Auto is interactive Claude Code on a PTY (`openzoo claude` env),
+  // not --print and not the RUN:/WRITE: text loop. Ask still uses chat/completions.
+  if (t.runMode === 'auto') {
+    usedClaude = true;
+    // Auto/Auto: a PTY spawn, --resume, or proxy 500 used to remount the
+    // canvas before finally-saveThreads. Flush the real user turn (history
+    // + messages + disk) immediately before the PTY turn. Harness continue
+    // text is skipped — it must not replace the just-sent bubble.
+    persistUserTurn(t, userText, images);
+    saveThreads();
+    // 1.5.99 PTY Auto swallowed the first send: persist worked, waitIdle
+    // treated a quiet TUI as done, sanitizeClaudeCanvas wiped chrome, no bot
+    // bubble. Skip PTY until a send has produced a visible reply; serve
+    // Ask/Auto chat-completions. Once a visible bot row exists, try PTY and
+    // still fall through if that turn comes back empty / HTTP-N.
+    if (threadHasVisibleBotReply(t)) {
+      usedClaude = true;
+      lastReply = await runAutoClaudeTurn(t, userText, images, paint, stillMine, turnAbort);
+      if (!stillMine()) return;
+      if (!isClaudeFallbackReply(lastReply)) {
+        bindThread(t).catch(() => {});
+        return;
+      }
+      popClaudeFallbackBot(t);
+      usedClaude = false;
+      claudeFallback = true;
+      paint({ type: 'status', name: t.name, color: t.color, detail: 'retrying…' });
+    } else {
+      usedClaude = false;
+      claudeFallback = true;
+    }
+  }
   // A real message from the user resets the auto budget AND the announcement
   // nudge. Harness-injected hops (command output, directive result, nudge,
   // auto-continue) must not re-arm — that would make AUTO_MAX_STEPS a no-op
@@ -2731,7 +3104,12 @@ async function runTurn(threadId, userText, onEvent, images) {
     t.autoSteps = 0;
     delete t.autoNudged;
   }
-  t.messages.push({ role: 'user', content: contentFor(userText, images) });
+  // Real user text was already flushed in persistUserTurn (history + messages).
+  // Harness hops stay out of the transcript; ask-mode still needs them in
+  // t.messages so the model sees the continue without a user bubble.
+  if (isHarnessUserText(userText) && Array.isArray(t.messages)) {
+    t.messages.push({ role: 'user', content: contentFor(userText, images) });
+  }
   let reply = '';
   paint({ type: 'start', name: t.name, color: t.color, detail: t.liveStatus || 'waiting on model…' });
   // Transient: the nudge is appended for THIS call only and never pushed into
@@ -2748,7 +3126,8 @@ async function runTurn(threadId, userText, onEvent, images) {
   if (t.todos?.length) {
     extras.push({ role: 'system', content: `Current checklist (TODO: done <n> to tick one off):\n${t.todos.map((x, i) => `${i + 1}. [${x.done ? 'x' : ' '}] ${x.text}`).join('\n')}` });
   }
-  if (t.runMode === 'auto') extras.push({ role: 'system', content: AUTO_DIRECTIVE });
+  extras.push({ role: 'system', content: CHAT_NOT_PROXY });
+  if (t.runMode === 'auto' && !claudeFallback) extras.push({ role: 'system', content: AUTO_DIRECTIVE });
   const callMsgs = extras.length ? [...t.messages, ...extras] : t.messages;
   // WHICH MODEL SERVES THIS TURN.
   //   /model <id>  pins one explicitly and always wins — an explicit choice is
@@ -2763,18 +3142,34 @@ async function runTurn(threadId, userText, onEvent, images) {
         thread: t, attempt, userText, messages: callMsgs,
       }) ?? '').trim();
     }
-    const emit = (delta, meta) => paint({
-      type: 'delta', name: t.name, color: t.color, delta,
-      ...(meta?.replace ? { replace: true } : {}),
-      ...(meta?.model ? { model: meta.model } : {}),
-    });
+    const emit = (delta, meta) => {
+      if (meta?.think) {
+        paint({ type: 'think', name: t.name, color: t.color, delta });
+        return;
+      }
+      paint({
+        type: 'delta', name: t.name, color: t.color, delta,
+        ...(meta?.replace ? { replace: true } : {}),
+        ...(meta?.model ? { model: meta.model } : {}),
+      });
+    };
     const emitStatus = (detail) => paint({ type: 'status', name: t.name, color: t.color, detail });
-    // Retrieval breadth scales with the PROJECT's corpus, not this thread's —
-    // the holobrain is shared at the root, so that is the pool being searched.
-    const topK = adaptiveTopK((threads.get(rootOf(t).rootId) || t).boundItems);
+    // SPAWN kids search the project root's corpus. A brand-new chat is its
+    // own holobrain — do not scale top_k off another thread's boundItems.
+    const topK = adaptiveTopK((holobrainOf(t) || t).boundItems);
     const race = Math.min(Number(t.race) || 0, 4);
     if (!t.model && race >= 2) {
-      const models = await tierModels(t.tier || 'medium', race, true);
+      const useAuto = !t.tier || t.tier === 'auto';
+      let models = [];
+      if (useAuto) {
+        try {
+          const routed = routeChatBody({ messages: callMsgs }, { k: race, allow_free: false, bindable: true });
+          models = (routed.shortlist || []).map((s) => s.model).filter(Boolean);
+          if (routed.model && !models.includes(routed.model)) models.unshift(routed.model);
+          models = [...new Set(models)].slice(0, race);
+        } catch { models = []; }
+      }
+      if (!models.length) models = await tierModels(useAuto ? 'medium' : (t.tier || 'medium'), race, true);
       // need = how many must come BACK before judging. need 1 is a plain
       // first-past-the-post race; need N waits for all of them. The point of
       // the middle (2 of 3) is a judged answer without the slowest entrant
@@ -2789,7 +3184,7 @@ async function runTurn(threadId, userText, onEvent, images) {
       })).trim();
     }
     // A retry draws a DIFFERENT model from the tier rather than the same one.
-    const model = t.model || (await tierModels(t.tier || 'medium', attempt + 1, attempt > 0))[attempt] || undefined;
+    const model = t.model || 'openzoo/auto';
     return (onEvent
       ? (await brainStream(callMsgs, emit, t.contextId, model, undefined, 0, topK, emitStatus)).trim()
       : (await brain(callMsgs, t.contextId, model, topK)).trim());
@@ -2827,20 +3222,21 @@ async function runTurn(threadId, userText, onEvent, images) {
     reply = `error: ${e.message}`;
   }
   if (!stillMine()) return;
-  reply = stripThinkTags(reply);
+  const settled = takeThink(reply);
+  reply = settled.text;
   lastReply = reply;
   t.messages.push({ role: 'assistant', content: reply });
   const runCmd = parseRun(reply);
   if (runCmd) {
     const command = runCmd;
-    if (t.runMode === 'auto') {
+    if (t.runMode === 'auto' && !claudeFallback) {
       emitLiveStatus(t.id, paint, peekDirectiveStatus('', command));
       const output = await execCommand(command, dirFor(t.id));
       noteRunForCorpus(t.id, command, { cwd: dirFor(t.id) });
       if (!stillMine()) return;
       const shown = `$ ${command}\n${output}`;
-      t.history.push({ who: 'bot', text: shown });
-      paint({ type: 'final', name: t.name, color: t.color, text: shown });
+      t.history.push({ who: 'bot', text: command, runStatus: 'done', runOutput: output, thinking: settled.thinking });
+      paint({ type: 'final', name: t.name, color: t.color, text: command, thinking: settled.thinking });
       // FEED THE OUTPUT BACK. The 'ask' path already does this on approve, so
       // auto mode was strictly LESS capable than the gated one: the command
       // ran, the result was shown, and the model never saw it — no diagnosis,
@@ -2865,8 +3261,8 @@ async function runTurn(threadId, userText, onEvent, images) {
     {
       const runId = randomUUID();
       t.pendingRun = { runId, command, cwd: dirFor(t.id) };
-      t.history.push({ who: 'bot', text: command, runId, runStatus: 'pending' });
-      paint({ type: 'run-pending', runId, command, name: t.name, color: t.color });
+      t.history.push({ who: 'bot', text: command, runId, runStatus: 'pending', thinking: settled.thinking });
+      paint({ type: 'run-pending', runId, command, name: t.name, color: t.color, thinking: settled.thinking });
     }
     parked = true;
     return;
@@ -2874,8 +3270,8 @@ async function runTurn(threadId, userText, onEvent, images) {
   const ack = await tryDirective(reply, t.id, paint);
   if (!stillMine()) return;
   const finalText = ack ?? (reply || '(no response)');
-  t.history.push({ who: 'bot', text: finalText });
-  paint({ type: 'final', name: t.name, color: t.color, text: finalText });
+  t.history.push({ who: 'bot', text: finalText, thinking: settled.thinking });
+  paint({ type: 'final', name: t.name, color: t.color, text: finalText, thinking: settled.thinking });
 
   // AUTO CONTINUES AFTER *ANY* DIRECTIVE, not just RUN.
   //
@@ -2888,7 +3284,7 @@ async function runTurn(threadId, userText, onEvent, images) {
   //
   // Same budget as RUN (shared t.autoSteps, reset when the user speaks), so
   // this cannot spend more than a chained RUN loop already could.
-  if (t.runMode === 'auto' && ack !== null && ack !== undefined
+  if (t.runMode === 'auto' && !claudeFallback && ack !== null && ack !== undefined
       && (isEmptyDirectiveAck(ack) || !isDoneReply(reply))) {
     chained = enqueueAutoHop(
       t, threadId,
@@ -2912,7 +3308,7 @@ async function runTurn(threadId, userText, onEvent, images) {
   // NUDGE announcements (stronger than a bare continue). Plain replies used
   // to park here; they now fall through to AUTO_CONTINUE unless DONE: or a
   // real blocking question. The step cap is the wallet bound.
-  if (t.runMode === 'auto' && (ack === null || ack === undefined)
+  if (t.runMode === 'auto' && !claudeFallback && (ack === null || ack === undefined)
       && (STALLED_OFFER.test(reply) || ANNOUNCEMENT.test(reply))) {
     // Offers and "Spawned X — working on it" with no directive must not end
     // the run. The old once-only autoNudged gate parked the thread after one
@@ -2924,7 +3320,7 @@ async function runTurn(threadId, userText, onEvent, images) {
 
   // After any auto reply that is not DONE: and not waiting on approval,
   // kick immediately. Race/empty/error uses AUTO_RACE_RETRY.
-  if (shouldKeepAuto(t, reply, userText)) {
+  if (!claudeFallback && shouldKeepAuto(t, reply, userText)) {
     chained = enqueueAutoHop(t, threadId, autoHopText(reply, userText), onEvent);
     return;
   }
@@ -2934,7 +3330,7 @@ async function runTurn(threadId, userText, onEvent, images) {
     // ask mode, 402/empty-wallet, or the hard cap. Empty /(no output) is not
     // DONE — AUTO_EMPTY_RETRY. Otherwise kick again.
     if (stillMine() && !chained && !parked) {
-      if (shouldKeepAuto(t, lastReply, userText)) {
+      if (!usedClaude && !claudeFallback && shouldKeepAuto(t, lastReply, userText)) {
         enqueueAutoHop(t, threadId, autoHopText(lastReply, userText), onEvent);
       } else if (!t.pendingRun) {
         t.status = 'idle';
@@ -3063,7 +3459,8 @@ function subtreeOf(id, includeSelf = false) {
 }
 
 function threadSummary(t) {
-  const last = t.history[t.history.length - 1];
+  const vis = visibleHistory(t.history);
+  const last = vis[vis.length - 1];
   return { id: t.id, name: t.name, color: t.color, parent: t.parent, status: t.status,
     preview: last ? (last.who === 'user' ? last.text : last.text).slice(0, 60) : '',
     createdAt: t.createdAt, lastActivityAt: t.lastActivityAt || t.createdAt,
@@ -3095,19 +3492,19 @@ const APP_HTML = `<!doctype html>
 <style>
   :root { color-scheme: dark; }
   * { box-sizing: border-box; }
-  html, body { margin: 0; height: 100%; background: #000; }
+  html, body { margin: 0; height: 100%; width: 100%; overflow: hidden; background: #000; }
   body { color: #ececec; font: 14px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
          display: flex; }
   #dragbar { -webkit-app-region: drag; position: fixed; top: 0; left: 0; right: 0; height: 28px; z-index: 1000; }
   #sidebar { width: 280px; flex: 0 0 280px; border-right: 1px solid #1c1c1e; display: flex; flex-direction: column;
-             height: 100vh; padding-top: 28px; }
+             height: 100%; padding-top: 28px; min-height: 0; position: relative; }
   #main { padding-top: 28px; }
   #sideTop { display: flex; align-items: center; gap: 4px; padding: 0 8px; }
   #sideTop #search { flex: 1; }
   #search { margin: 12px; padding: 8px 12px; background: #1c1c1e; border-radius: 10px; color: #ececec;
             border: none; font: inherit; }
   #search::placeholder { color: #8e8e93; }
-  #threads { flex: 1; overflow-y: auto; }
+  #threads { flex: 1; min-height: 0; overflow-y: auto; }
   .trow { display: flex; align-items: center; gap: 10px; padding: 8px 12px; cursor: pointer; border-radius: 10px;
           margin: 0 6px 2px; }
   /* PROJECT HEADER. The tree indentation shows who spawned whom, but there was
@@ -3172,7 +3569,7 @@ const APP_HTML = `<!doctype html>
   @media (prefers-reduced-motion: reduce) {
     .twarn, .bot-pfp .bot-bob, .bot-pfp .bot-eyes { animation: none; }
   }
-  #main { position: relative; flex: 1; min-width: 0; display: flex; flex-direction: column; height: 100vh; }
+  #main { position: relative; flex: 1; min-width: 0; min-height: 0; display: flex; flex-direction: column; height: 100%; }
   #chatHeader { padding: 14px 20px; border-bottom: 1px solid #1c1c1e; display: flex; align-items: center;
                 flex-wrap: wrap; gap: 8px 10px; font-weight: 600; }
   #chatHeader .tavatar { width: 26px; height: 26px; border-radius: 50%; font-size: 11px; flex: 0 0 26px; }
@@ -3299,6 +3696,21 @@ const APP_HTML = `<!doctype html>
   #hud { position: absolute; right: 14px; width: 270px; background: rgba(14,14,17,.94);
          border: 1px solid #333340; border-radius: 10px; padding: 12px 14px; font: 11px/1.5 Menlo, monospace;
          display: none; z-index: 300; box-shadow: 0 12px 30px rgba(0,0,0,.5); }
+  /* Always-on strip. Sidebar footer — bottom-left of the window, inside the
+     bot list column. Never a child of #main: position:absolute; left:14px
+     there sat on the transcript and covered the last bubbles. ◎ stays a
+     toggle; this one never hides. pointer-events none so it cannot steal
+     thread-row clicks. */
+  #dockHud { flex: 0 0 auto; position: relative; left: auto; bottom: auto;
+    width: 100%; max-width: 100%; z-index: 1;
+    pointer-events: none; background: rgba(14,14,17,.94);
+    border: 0; border-top: 1px solid #333340; border-radius: 0;
+    padding: 8px 12px 12px; color: #8e8e93;
+    font: 10.5px/1.4 ui-monospace, SFMono-Regular, Menlo, monospace;
+    display: flex; flex-wrap: wrap; gap: 6px 10px; align-items: baseline; }
+  #dockHud .dk { color: #6f7080; }
+  #dockHud .dv { color: #c8c8c2; }
+  #dockHud .dv.hlime { color: #b8f240; }
   #hud.show { display: block; }
   #hud .htitle { color: #b8f240; font-size: 10px; letter-spacing: .04em; margin-bottom: 10px; }
   #hud .htitle.hsession { margin-top: 12px; padding-top: 10px; border-top: 1px solid #333340; color: #6f7080; }
@@ -3316,8 +3728,8 @@ const APP_HTML = `<!doctype html>
                 color: #f0c9a8; font-size: 10.5px; line-height: 1.45; }
   #hud .hhint.show { display: block; }
   #hud .hhint b { color: #f28c4d; font-weight: 600; }
-  #sidebar, #main, #walletOverlay, #sitrepOverlay, #composeOverlay,
-  #inp, #search, #composeInp, .bubble, .md-pre, .runoutput, .runcmd {
+  #sidebar, #main, #walletOverlay, #sitrepOverlay, #composeOverlay, #findBar,
+  #inp, #search, #composeInp, #findInp, .bubble, .md-pre, .runoutput, .runcmd {
     -webkit-app-region: no-drag; }
   #log { flex: 1; min-width: 0; overflow-y: auto; overflow-x: hidden; padding: 20px 24px 12px;
          display: flex; flex-direction: column; gap: 6px;
@@ -3399,6 +3811,18 @@ const APP_HTML = `<!doctype html>
   }
   .runcard { background: #1c1c1e; border: 1px solid #333; border-radius: 14px; padding: 12px 14px;
              max-width: 100%; min-width: 0; overflow: hidden; }
+  /* Done RUNs collapse like thinking… — raw curl JSON must not be the message. */
+  .runcard.folded { background: transparent; border: none; padding: 0; }
+  .runfold { align-self: flex-start; max-width: 100%; min-width: 0; }
+  .runchip {
+    border: 0; background: transparent; color: #8e8e93; padding: 0;
+    font: 12px/1.4 inherit; cursor: pointer; letter-spacing: .01em;
+    -webkit-user-select: none; user-select: none;
+  }
+  .runchip:hover { color: #c8c8d0; }
+  .runchip:focus-visible { outline: 2px solid #ff9500; outline-offset: 2px; border-radius: 4px; }
+  .runbody { display: none; margin: 4px 0 2px; }
+  .runfold.open .runbody { display: block; }
   .runcmd { font-family: Menlo, monospace; font-size: 12.5px; color: #ececec; white-space: pre-wrap;
             word-break: break-word; margin-bottom: 8px; }
   .runactions { display: flex; gap: 8px; }
@@ -3411,6 +3835,34 @@ const APP_HTML = `<!doctype html>
                word-break: break-word; max-height: 240px; overflow-y: auto; margin: 0; }
   .row.user .bubble { background: #57575c; }
   .row.bot .bubble { background: #262626; color: #ececec; }
+  /* Folded chain-of-thought. Not the Auto run-mode chip — that is /mode auto.
+     Default collapsed; click the label to unfurl, click again to furl.
+     Live Auto turns always show thinking… while the Claude child is alive. */
+  .msgcol { display: flex; flex-direction: column; gap: 6px; min-width: 0; max-width: 100%; flex: 1; }
+  .thinkfold { align-self: flex-start; max-width: 100%; min-width: 0; }
+  .thinkchip {
+    border: 0; background: transparent; color: #8e8e93; padding: 0;
+    font: 12px/1.4 inherit; cursor: pointer; letter-spacing: .01em;
+    -webkit-user-select: none; user-select: none;
+  }
+  .thinkchip:hover { color: #c8c8d0; }
+  .thinkchip:focus-visible { outline: 2px solid #b8f240; outline-offset: 2px; border-radius: 4px; }
+  .thinkbody {
+    display: none; margin: 4px 0 2px; padding: 8px 12px;
+    color: #8e8e93; font-size: 12.5px; line-height: 1.45;
+    white-space: pre-wrap; word-break: break-word;
+    border-left: 2px solid #3a3a3c; max-height: 240px; overflow-y: auto;
+  }
+  .thinkfold.open .thinkbody { display: block; }
+  /* Compact Claude TUI surface. Stripped text is the bubble; this is the
+     optional monospace frame (folded by default, same chip pattern). */
+  .claudeterm {
+    display: none; margin: 4px 0 2px; padding: 8px 10px;
+    font: 11.5px/1.4 Menlo, ui-monospace, monospace; color: #c8c8d0;
+    background: #141416; border: 1px solid #2a2a2d; border-radius: 8px;
+    white-space: pre-wrap; word-break: break-word; max-height: 220px; overflow: auto;
+  }
+  .thinkfold.open .claudeterm { display: block; }
   .row.bot.pending .bubble { color: #8e8e93; }
   .dots span { display: inline-block; width: 5px; height: 5px; margin-right: 3px; border-radius: 50%;
                background: #8e8e93; animation: blink 1.2s infinite ease-in-out; }
@@ -3535,6 +3987,23 @@ const APP_HTML = `<!doctype html>
     transition: opacity .14s ease, transform .14s ease;
   }
   #copiedToast.show { opacity: 1; transform: translate(-50%, 0); }
+  /* FIND IN THREAD. Cmd/Ctrl+F — not the sidebar thread search (that's Cmd+K).
+     Sits over #log so matches stay in the conversation, not the thread list. */
+  #findBar { display: none; position: absolute; right: 16px; z-index: 320;
+             align-items: center; gap: 6px; background: rgba(18,18,22,.98);
+             border: 1px solid #3a3a3c; border-radius: 12px; padding: 6px 8px;
+             box-shadow: 0 10px 28px rgba(0,0,0,.45); }
+  #findBar.show { display: flex; }
+  #findInp { width: 180px; background: #0b0b0d; border: 1px solid #2c2c2e; border-radius: 8px;
+             color: #ececec; font: inherit; font-size: 13px; padding: 5px 8px; }
+  #findInp:focus { outline: 2px solid #6ab0ff; outline-offset: 1px; }
+  #findCount { min-width: 48px; color: #8e8e93; font-size: 12px; text-align: right;
+               font-variant-numeric: tabular-nums; }
+  #findBar button { border: 0; background: transparent; color: #ececec; width: 26px; height: 26px;
+                    border-radius: 8px; cursor: pointer; font: inherit; line-height: 1; }
+  #findBar button:hover { background: #3a3a3c; }
+  mark.findhit { background: #f2d64b; color: #111; border-radius: 3px; padding: 0 1px; }
+  mark.findhit.cur { background: #b8f240; }
 </style></head>
 <body>
   <div id="copiedToast" role="status" aria-live="polite">copied</div>
@@ -3547,6 +4016,13 @@ const APP_HTML = `<!doctype html>
       <input id="search" placeholder="Search">
     </div>
     <div id="threads"></div>
+    <div id="dockHud" data-component="dock-hud">
+      <span><span class="dk">spill</span> <span id="dockSpill" class="dv">—</span></span>
+      <span><span class="dk">session</span> <span id="dockSession" class="dv">—</span></span>
+      <span><span class="dk">paid</span> <span id="dockPaid" class="dv">—</span></span>
+      <span><span class="dk">bind</span> <span id="dockBind" class="dv">no</span></span>
+      <span><span class="dk">calls</span> <span id="dockCalls" class="dv">0</span></span>
+    </div>
   </div>
   <div id="composeOverlay">
     <div id="composeBox">
@@ -3607,9 +4083,10 @@ const APP_HTML = `<!doctype html>
                 title="Shell commands run immediately, with no approval prompt">auto</button>
       </div>
       <select class="dial" id="tierSel" data-component="model-tier" aria-label="Model tier"
-              title="How much to spend per turn when no model is pinned">
+              title="Auto = cheapest model that clears the bar. Other tiers only apply to /race.">
+        <option value="auto" selected>auto</option>
         <option value="cheap">cheap</option>
-        <option value="medium" selected>medium</option>
+        <option value="medium">medium</option>
         <option value="expensive">expensive</option>
         <option value="grok4.6">grok 4.6</option>
       </select>
@@ -3647,6 +4124,13 @@ const APP_HTML = `<!doctype html>
       <div class="hfoot" id="hFoot">loading…</div>
     </div>
     <div id="log"></div>
+    <div id="findBar" role="search" data-component="find-in-thread">
+      <input id="findInp" type="search" placeholder="Find in conversation" autocomplete="off" spellcheck="false">
+      <span id="findCount" aria-live="polite"></span>
+      <button type="button" id="findPrev" title="Previous" aria-label="Previous match">↑</button>
+      <button type="button" id="findNext" title="Next" aria-label="Next match">↓</button>
+      <button type="button" id="findClose" title="Close" aria-label="Close find">×</button>
+    </div>
     <div id="bar">
       <div id="plusMenu">
         <div class="pop-item" id="attachBtn">
@@ -3678,6 +4162,17 @@ const APP_HTML = `<!doctype html>
     </div>
   </div>
 <script>
+  function formatSavingLabel(you) {
+    const spent = Number(you && you.spentUsd) || 0;
+    if (spent <= 0) return { text: '—', mult: null, spilled: false };
+    const spillX = Number(you && you.spilled && you.spilled.savingX);
+    const sessionX = (Number(you && you.directUsd) || 0) / spent;
+    const spilled = Number.isFinite(spillX) && spillX > 0;
+    const mult = spilled ? spillX : sessionX;
+    if (!Number.isFinite(mult)) return { text: '—', mult: null, spilled: false };
+    const num = (mult >= 100 ? String(Math.round(mult)) : Number(mult).toFixed(mult >= 10 ? 1 : 2)) + 'x';
+    return { text: num + (spilled ? ' spilled' : ' session'), mult, spilled };
+  }
   const threadsEl = document.getElementById('threads');
   const chatHeader = document.getElementById('chatHeader');
   const log = document.getElementById('log');
@@ -4008,7 +4503,7 @@ const APP_HTML = `<!doctype html>
     const tierSel = document.getElementById('tierSel');
     const raceSel = document.getElementById('raceSel');
     if (!tierSel || !raceSel) return;
-    tierSel.value = t.tier || 'medium';
+    tierSel.value = t.tier || 'auto';
     raceSel.value = (t.race || 0) < 2 ? '0'
       : ((t.raceNeed || 1) > 1 ? t.raceNeed + ' ' + t.race : String(t.race));
     // A pinned /model makes BOTH dials inert. Showing them live while they do
@@ -4031,15 +4526,18 @@ const APP_HTML = `<!doctype html>
     }
   }
 
-  async function setDial(cmd, value) {
+  // Header dials and Pay / ◎ all go through /drive so handleSlash (or the
+  // /mode handler) appends the same short bot line as typing the command.
+  async function echoSlash(task) {
     if (!activeId) return;
-    // Reuses the SAME slash-command path, so there is one implementation of the
-    // rule rather than a second that can disagree with it.
     await fetch(API + '/drive', { method: 'POST', headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ threadId: activeId, task: '/' + cmd + ' ' + value }) });
+      body: JSON.stringify({ threadId: activeId, task: task }) });
     await loadThreads();
     await render();
   }
+  async function setDial(cmd, value) {
+    await echoSlash('/' + cmd + ' ' + value);
+  }
   // WALLET MODAL.
   //
   // Public addresses and balances only — /wallet proxies the proxy's own
@@ -4066,7 +4564,13 @@ const APP_HTML = `<!doctype html>
     return row;
   }
   function isEmptyWalletPayment(text) {
-    return /\b(?:wallet is empty|empty wallet|wallet underfunded|underfunded)\b/i.test(String(text || ''));
+    // String ops. A word-boundary regex inside APP_HTML is eaten: \b
+    // becomes a literal backspace and the client never matches a real 402.
+    const s = String(text || '').toLowerCase();
+    return s.includes('wallet is empty')
+      || s.includes('empty wallet')
+      || s.includes('wallet underfunded')
+      || s.includes('underfunded');
   }
   var openedPayForEmpty = false;
   function maybeOpenPayForEmptyWallet(text) {
@@ -4287,7 +4791,10 @@ const APP_HTML = `<!doctype html>
     setSubNote('Subscription key removed. Wallet/x402 is the pay method again.');
     await openWallet();
   }
-  document.getElementById('walletBtn').addEventListener('click', openWallet);
+  document.getElementById('walletBtn').addEventListener('click', () => {
+    echoSlash('/pay');
+    openWallet();
+  });
   const subKeyBtn = document.getElementById('subKeyBtn');
   if (subKeyBtn) subKeyBtn.addEventListener('click', savePastedSub);
   const subForgetBtn = document.getElementById('subForgetBtn');
@@ -4356,10 +4863,10 @@ const APP_HTML = `<!doctype html>
     const spent = Number(you.spentUsd) || 0;
     const cogs = Number(you.cogsUsd) || 0;
     const direct = Number(you.directUsd) || 0;
-    const mult = spent > 0 ? direct / spent : null;
-    const saved = mult == null ? '—'
-      : ((mult >= 100 ? Math.round(mult) : mult.toFixed(mult >= 10 ? 1 : 2)) + 'x');
-    const savedCls = mult == null ? '' : (mult >= 1 ? 'hlime' : 'hember');
+    const proxyDown = you.proxyReachable === false;
+    const sav = formatSavingLabel(you);
+    const saved = proxyDown ? 'proxy unreachable' : sav.text;
+    const savedCls = proxyDown ? 'hember' : (sav.mult == null ? '' : (sav.mult >= 1 ? 'hlime' : 'hember'));
     const thinking = (full && full.status === 'thinking') || t.status === 'thinking';
     const race = (full && full.liveRace) || null;
     let flight = 'idle';
@@ -4376,11 +4883,12 @@ const APP_HTML = `<!doctype html>
       + sitrepRow('cwd', cwd)
       + sitrepRow('in flight', flight)
       + '<div class="wlanetitle" style="margin-top:16px">this session</div>'
-      + sitrepRow('paid', '$' + (spent >= 0.01 || spent === 0 ? spent.toFixed(2) : spent.toFixed(5)))
-      + sitrepRow('cogs', '$' + (cogs >= 0.01 || cogs === 0 ? cogs.toFixed(2) : cogs.toFixed(5)))
-      + sitrepRow('direct', '$' + (direct >= 0.01 || direct === 0 ? direct.toFixed(2) : direct.toFixed(5)))
+      + sitrepRow('proxy', proxyDown ? 'unreachable' : 'ok', proxyDown ? 'hember' : 'hlime')
+      + sitrepRow('paid', proxyDown ? 'proxy unreachable' : ('$' + (spent >= 0.01 || spent === 0 ? spent.toFixed(2) : spent.toFixed(5))))
+      + sitrepRow('cogs', proxyDown ? '—' : ('$' + (cogs >= 0.01 || cogs === 0 ? cogs.toFixed(2) : cogs.toFixed(5))))
+      + sitrepRow('direct', proxyDown ? '—' : ('$' + (direct >= 0.01 || direct === 0 ? direct.toFixed(2) : direct.toFixed(5))))
       + sitrepRow('saved vs naked', saved, savedCls)
-      + sitrepRow('paid calls', String(you.paidCalls || 0))
+      + sitrepRow('paid calls', proxyDown ? '—' : String(you.paidCalls || 0))
       + sitrepRow('prepaid', (Number(you.creditUsd) > 0) ? 'yes' : 'no');
   }
   function closeSitrep() { sitrepOverlay.classList.remove('show'); }
@@ -4408,22 +4916,44 @@ const APP_HTML = `<!doctype html>
     setModeButtons(mode); // optimistic: the click should feel instant
     // Reuses the SAME "/mode" path the chat command takes, so there is one
     // implementation of the rule rather than a second one that can disagree.
-    await fetch(API + '/drive', { method: 'POST', headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ threadId: activeId, task: '/mode ' + mode }) });
-    await loadThreads(); // refresh runMode + the confirmation line /mode appends
-    await render();
+    await echoSlash('/mode ' + mode);
   }
   document.getElementById('modeAsk').addEventListener('click', () => setMode('ask'));
   document.getElementById('modeAuto').addEventListener('click', () => setMode('auto'));
 
   function escapeHtml(s) { return s.replace(/[&<>]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' }[c])); }
-  function stripThinkTags(s) {
+  function scrubBotText(s) {
+    s = String(s == null ? '' : s);
+    s = s.replace(/<system-reminder\\b[^>]*>[\\s\\S]*?<\\/system-reminder>/gi, '');
+    s = s.replace(/<system-reminder\\b[^>]*>[\\s\\S]*$/i, '');
+    s = s.replace(/^[ \\t]*(?:#\\s*)?currentDir\\b[^\\n]*\\n?/gim, '');
+    if (/\\uFFFD/.test(s) || /^\\s*API Error:\\s*(\\d{3})\\b/im.test(s)) {
+      var m = /API Error:\\s*(\\d{3})/i.exec(s);
+      return 'upstream HTTP ' + (m ? m[1] : '400');
+    }
+    return s;
+  }
+  function splitThinkTags(s) {
     s = String(s == null ? '' : s);
-    s = s.replace(/<think(?:ing)?\\b[^>]*>[\\s\\S]*?<\\/think(?:ing)?>/gi, '');
-    s = s.replace(/<think(?:ing)?\\b[^>]*>[\\s\\S]*$/i, '');
+    var bits = [];
+    s = s.replace(/<think(?:ing)?\\b[^>]*>[\\s\\S]*?<\\/think(?:ing)?>/gi, function (m) {
+      var a = m.indexOf('>');
+      var b = m.toLowerCase().lastIndexOf('</think');
+      if (a >= 0 && b > a) bits.push(m.slice(a + 1, b));
+      return '';
+    });
+    s = s.replace(/<think(?:ing)?\\b[^>]*>[\\s\\S]*$/i, function (m) {
+      var a = m.indexOf('>');
+      bits.push(a >= 0 ? m.slice(a + 1) : '');
+      return '';
+    });
     s = s.replace(/<\\/think(?:ing)?>/gi, '');
-    return s.replace(/^\\n+|\\n+$/g, '').trim();
+    return {
+      visible: s.replace(/^\\n+|\\n+$/g, '').trim(),
+      thinking: bits.join('\\n').replace(/^\\n+|\\n+$/g, '').trim()
+    };
   }
+  function stripThinkTags(s) { return splitThinkTags(s).visible; }
   function clientWorkspaceUrl(rel) {
     if (!workspacePort || !activeId) return '';
     rel = String(rel || '').replace(/^\\/+/, '');
@@ -4806,8 +5336,140 @@ const APP_HTML = `<!doctype html>
   }
 
   let lastSpeaker = null;
-  function addRow(who, text, color, name, run, images) {
-    if (who === 'bot') text = stripThinkTags(text);
+  let liveThinkOpen = false;
+  let streamTools = [];
+  let pendingTurns = [];
+  let sending = false;
+  // Mirror of server isHarnessUserText. No regex — APP_HTML template
+  // literals eat \\b / \\/ and kill the whole script.
+  function isHarnessUserText(text) {
+    const s = String(text || '');
+    if (s.indexOf('(command output)') === 0 || s.indexOf('(directive result)') === 0) return true;
+    if (s === 'Please continue the current job. Do not stop to ask the user.') return true;
+    if (s.indexOf('AUTO is still on ') === 0) return true;
+    if (s.indexOf('AUTO_EMPTY_RETRY:') === 0) return true;
+    if (s.indexOf('That reply announced work instead of doing it') === 0) return true;
+    return false;
+  }
+  function pendingStoreKey(id) { return 'openzoo.userTurn.' + id; }
+  function rememberUserTurn(id, text, images) {
+    if (!id || !text || isHarnessUserText(text)) return;
+    try { localStorage.setItem(pendingStoreKey(id), JSON.stringify({ text: text, images: images || [] })); } catch (e) {}
+  }
+  function recalledUserTurn(id) {
+    try {
+      const raw = localStorage.getItem(pendingStoreKey(id));
+      if (!raw) return null;
+      const j = JSON.parse(raw);
+      if (!j || !j.text || isHarnessUserText(j.text)) return null;
+      return j;
+    } catch (e) { return null; }
+  }
+  function forgetUserTurn(id, text) {
+    try {
+      const j = recalledUserTurn(id);
+      if (!id) return;
+      if (!text || (j && j.text === text)) localStorage.removeItem(pendingStoreKey(id));
+    } catch (e) {}
+  }
+  function thinkLabel(live) { return live ? 'thinking...' : 'thought'; }
+  function foldBodyText(think) {
+    const tools = streamTools.length ? streamTools.join('\\n') : '';
+    const t = String(think || '').trim();
+    if (t && tools) return t + '\\n' + tools;
+    return t || tools;
+  }
+  function makeThinkFold(text, live, open) {
+    const fold = document.createElement('div');
+    fold.className = 'thinkfold' + (open ? ' open' : '');
+    const chip = document.createElement('button');
+    chip.type = 'button';
+    chip.className = 'thinkchip';
+    chip.textContent = thinkLabel(live);
+    chip.setAttribute('aria-expanded', open ? 'true' : 'false');
+    const body = document.createElement('div');
+    body.className = 'thinkbody';
+    if (open) body.textContent = text;
+    chip.addEventListener('click', function (e) {
+      e.preventDefault();
+      const next = !fold.classList.contains('open');
+      fold.classList.toggle('open', next);
+      chip.setAttribute('aria-expanded', next ? 'true' : 'false');
+      if (live) liveThinkOpen = next;
+      if (next) body.textContent = fold.getAttribute('data-think') || text || '';
+      else body.textContent = '';
+      if (live) paintStream();
+    });
+    fold.setAttribute('data-think', text || '');
+    fold.appendChild(chip);
+    fold.appendChild(body);
+    return fold;
+  }
+  function runFoldLabel(status) {
+    if (status === 'pending') return 'run';
+    if (status === 'running') return 'running...';
+    if (status === 'denied') return 'denied';
+    return 'ran';
+  }
+  function parseLegacyRun(text) {
+    const raw = String(text || '');
+    if (!raw.startsWith('$ ')) return null;
+    const nl = raw.indexOf('\\n');
+    if (nl < 0) return { command: raw.slice(2), output: '', status: 'done' };
+    return { command: raw.slice(2, nl), output: raw.slice(nl + 1), status: 'done' };
+  }
+  function makeRunFold(command, output, status) {
+    const pending = status === 'pending' || status === 'running';
+    const fold = document.createElement('div');
+    fold.className = 'runfold' + (pending ? ' open' : '');
+    const chip = document.createElement('button');
+    chip.type = 'button';
+    chip.className = 'runchip';
+    chip.textContent = runFoldLabel(status);
+    chip.setAttribute('aria-expanded', pending ? 'true' : 'false');
+    const body = document.createElement('div');
+    body.className = 'runbody';
+    function fillBody() {
+      body.innerHTML = '';
+      const cmdEl = document.createElement('div');
+      cmdEl.className = 'runcmd';
+      cmdEl.textContent = '$ ' + command;
+      cmdEl.appendChild(copyBtn(() => command, 'copy'));
+      body.appendChild(cmdEl);
+      if (status && status !== 'pending') {
+        const st = document.createElement('div');
+        st.className = 'runstatus';
+        st.textContent = status === 'running' ? 'Running…' : status === 'denied' ? 'Denied' : 'Done';
+        body.appendChild(st);
+      }
+      if (output) {
+        const out = document.createElement('pre');
+        out.className = 'runoutput';
+        out.textContent = output;
+        out.appendChild(copyBtn(() => output, 'copy'));
+        body.appendChild(out);
+      }
+    }
+    if (pending) fillBody();
+    chip.addEventListener('click', function (e) {
+      e.preventDefault();
+      const next = !fold.classList.contains('open');
+      fold.classList.toggle('open', next);
+      chip.setAttribute('aria-expanded', next ? 'true' : 'false');
+      if (next) fillBody();
+      else body.innerHTML = '';
+    });
+    fold.appendChild(chip);
+    fold.appendChild(body);
+    return fold;
+  }
+  function addRow(who, text, color, name, run, images, thinking, live) {
+    if (who === 'bot') {
+      text = scrubBotText(text);
+      const parts = splitThinkTags(text);
+      text = parts.visible;
+      if (!thinking) thinking = parts.thinking;
+    }
     const speakerKey = who + '|' + name;
     if (who === 'bot' && speakerKey !== lastSpeaker) {
       const hdr = document.createElement('div');
@@ -4818,17 +5480,25 @@ const APP_HTML = `<!doctype html>
     lastSpeaker = speakerKey;
     const row = document.createElement('div');
     row.className = 'row ' + who;
+    const col = document.createElement('div');
+    col.className = 'msgcol';
+    const thinkText = (who === 'bot' && thinking) ? String(thinking).trim() : '';
+    if (live) {
+      const fold = makeThinkFold(foldBodyText(thinkText), true, !!liveThinkOpen);
+      fold.id = 'streamThink';
+      fold.hidden = false;
+      col.appendChild(fold);
+    } else if (thinkText) {
+      col.appendChild(makeThinkFold(thinkText, false, false));
+    }
     if (run) {
+      const cmd = run.command || text;
+      const st = run.status || 'pending';
+      const pending = st === 'pending' || st === 'running';
       const card = document.createElement('div');
-      card.className = 'runcard';
-      const cmdEl = document.createElement('div');
-      cmdEl.className = 'runcmd';
-      cmdEl.textContent = '$ ' + text;
-      // Copy WITHOUT the '$ ' prompt — pasting that into a shell is a syntax
-      // error, and this is the single most re-run thing in the UI.
-      cmdEl.appendChild(copyBtn(() => text, 'copy'));
-      card.appendChild(cmdEl);
-      if (run.status === 'pending') {
+      card.className = 'runcard' + (pending ? ' pending' : ' folded');
+      card.appendChild(makeRunFold(cmd, run.output || '', st));
+      if (run.id && st === 'pending') {
         const actions = document.createElement('div');
         actions.className = 'runactions';
         const approve = document.createElement('button');
@@ -4850,20 +5520,8 @@ const APP_HTML = `<!doctype html>
         actions.appendChild(approve);
         actions.appendChild(deny);
         card.appendChild(actions);
-      } else {
-        const status = document.createElement('div');
-        status.className = 'runstatus';
-        status.textContent = run.status === 'running' ? 'Running…' : run.status === 'denied' ? 'Denied' : 'Done';
-        card.appendChild(status);
-        if (run.output) {
-          const out = document.createElement('pre');
-          out.className = 'runoutput';
-          out.textContent = run.output;
-          out.appendChild(copyBtn(() => run.output, 'copy'));
-          card.appendChild(out);
-        }
       }
-      row.appendChild(card);
+      col.appendChild(card);
     } else {
       const bubble = document.createElement('div');
       bubble.className = 'bubble';
@@ -4879,6 +5537,7 @@ const APP_HTML = `<!doctype html>
       }
       const textEl = document.createElement('div');
       textEl.innerHTML = renderMentions(text);
+      if (live && (!text || text === '…')) bubble.hidden = true;
       if (who === 'bot') {
         const preview = htmlPreviewUrl(text);
         if (preview) textEl.appendChild(previewFrame(preview, htmlPreviewKey(text, preview)));
@@ -4893,7 +5552,7 @@ const APP_HTML = `<!doctype html>
         maybeOpenPayForEmptyWallet(text);
       }
       bubble.appendChild(textEl);
-      row.appendChild(bubble);
+      col.appendChild(bubble);
       // Copy the message SOURCE, not rendered HTML — markdown, code fences and
       // directive lines are what people want back; innerText drops fences and
       // mangles indentation.
@@ -4909,6 +5568,7 @@ const APP_HTML = `<!doctype html>
           }, 'copy'));
       }
     }
+    row.appendChild(col);
     log.appendChild(row);
   }
 
@@ -4921,10 +5581,11 @@ const APP_HTML = `<!doctype html>
     const full = await loadActiveMessages();
     if (!full || full.id !== activeId) return;
     const renderKey = String(workspacePort) + '|' + full.id + '|' + full.status + '|' + (full.history || []).map(function (h) {
-      return [h.who, h.text, h.runStatus, h.runOutput, (h.images || []).join(',')].join('|#');
-    }).join('||');
+      return [h.who, h.text, h.thinking, h.runStatus, h.runOutput, (h.images || []).join(',')].join('|#');
+    }).join('||') + '|pending:' + pendingTurns.filter(function (p) { return p.threadId === activeId; }).map(function (p) { return p.text; }).join('\\n')
+      + '|recall:' + ((recalledUserTurn(activeId) || {}).text || '');
     if (renderKey === lastRenderKey) {
-      if (streamBuf) paintStream();
+      if (streamBuf || streamThink) paintStream();
       return;
     }
     lastRenderKey = renderKey;
@@ -4934,9 +5595,33 @@ const APP_HTML = `<!doctype html>
     parkedPreviews = parkPreviews();
     log.innerHTML = '';
     lastSpeaker = null;
+    const seenUser = {};
     for (const h of full.history) {
-      addRow(h.who, h.text, h.color || t.color, h.name || t.name,
-        h.runId ? { id: h.runId, status: h.runStatus, output: h.runOutput } : undefined, h.images);
+      if (h.who === 'user' && isHarnessUserText(h.text)) continue;
+      if (h.who === 'user') seenUser[h.text] = true;
+      let run;
+      if (h.runId || h.runStatus) {
+        run = { id: h.runId, status: h.runStatus, output: h.runOutput, command: h.text };
+      } else if (h.who === 'bot') {
+        const legacy = parseLegacyRun(h.text);
+        if (legacy) run = { status: legacy.status, output: legacy.output, command: legacy.command };
+      }
+      addRow(h.who, h.text, h.color || t.color, h.name || t.name, run, h.images, h.thinking);
+    }
+    const keepPending = [];
+    for (let i = 0; i < pendingTurns.length; i++) {
+      const p = pendingTurns[i];
+      if (p.threadId !== activeId) { keepPending.push(p); continue; }
+      if (seenUser[p.text]) { forgetUserTurn(p.threadId, p.text); continue; }
+      addRow('user', p.text, t.color, t.name, undefined, p.images);
+      seenUser[p.text] = true;
+      keepPending.push(p);
+    }
+    pendingTurns = keepPending;
+    const recalled = recalledUserTurn(activeId);
+    if (recalled && recalled.text) {
+      if (seenUser[recalled.text]) forgetUserTurn(activeId, recalled.text);
+      else addRow('user', recalled.text, t.color, t.name, undefined, recalled.images);
     }
     if (full.status === 'thinking') {
       if (full.liveStatus) streamStatus = full.liveStatus;
@@ -4946,19 +5631,21 @@ const APP_HTML = `<!doctype html>
       } else if (streamRaceId !== full.id) {
         streamRace = null;
       }
-      addRow('bot', streamBuf || '…', t.color, t.name);
+      addRow('bot', streamBuf || '…', t.color, t.name, undefined, undefined, streamThink, true);
       // Tag the live bubble so deltas can repaint just this node instead of
       // re-rendering (and re-fetching) the whole thread on every token.
       const b = log.querySelector('.row:last-child .bubble');
       if (b) { b.id = 'streamBubble'; paintStream(); }
     }
     if (wasNearBottom) log.scrollTop = log.scrollHeight;
+    if (findBarOpen()) applyFind(true);
   }
 
   // --- live token stream ---------------------------------------------------
   // The server has always been able to stream; /drive just never asked for it,
   // so a turn showed "…" for its whole duration and then arrived in one lump.
   let streamBuf = '';
+  let streamThink = '';
   let streamStatus = '';
   let streamRace = null;
   let streamRaceId = '';
@@ -5012,44 +5699,117 @@ const APP_HTML = `<!doctype html>
     return '<div class="racewrap"><div class="racecaption">' + escapeHtml(caption) + '</div>'
       + '<div class="racegrid n' + n + '">' + cells + '</div>' + judge + '</div>';
   }
+  function streamParts() {
+    const parts = splitThinkTags(streamBuf);
+    var think = streamThink;
+    if (parts.thinking) think = think ? (think + '\\n' + parts.thinking) : parts.thinking;
+    return { visible: parts.visible, think: think };
+  }
   function liveBubbleHtml() {
     if (raceIsLive(streamRace)) return raceGridHtml(streamRace);
-    if (streamBuf) {
-      const trail = streamStatus && /^(RUN|READ|WRITE|EDIT|SPAWN|SEND|GLOB|GREP|MCP|FETCH|TODO|SERVE|PING|PEEK|MULTIEDIT|NOTEBOOK):/i.test(streamStatus)
-        ? '<span class="ttrail">' + escapeHtml(streamStatus) + '</span>' : '';
-      return escapeHtml(stripThinkTags(streamBuf)) + trail;
+    const vis = streamParts().visible;
+    return vis ? escapeHtml(vis) : '';
+  }
+  function paintThinkFoldLive(think) {
+    const fold = document.getElementById('streamThink');
+    if (!fold) return;
+    const chip = fold.querySelector('.thinkchip');
+    const body = fold.querySelector('.thinkbody');
+    const text = foldBodyText(think);
+    fold.hidden = false;
+    fold.setAttribute('data-think', text);
+    fold.classList.toggle('open', !!liveThinkOpen);
+    if (chip) {
+      chip.textContent = 'thinking...';
+      chip.setAttribute('aria-expanded', liveThinkOpen ? 'true' : 'false');
     }
-    const dots = '<span class="dots"><span></span><span></span><span></span></span>';
-    const st = streamStatus ? '<span class="tstatus">' + escapeHtml(streamStatus) + '</span>' : '';
-    return dots + (st ? ' ' + st : '');
+    if (body) body.textContent = liveThinkOpen ? text : '';
+  }
+  // Follow the live assistant bubble only while the reader is still on
+  // it. A post-paint pad check is what broke autoscroll: a lump >140px
+  // (long reply, 400 dump, table) put them past the pad, then every
+  // later token also refused to follow. Snapshot first; sticky-follow
+  // the turn they are watching; drop follow if they scroll up.
+  let followLive = false;
+  let pinningLog = false;
+  let pinRaf = 0;
+  function pinLogBottom() {
+    pinningLog = true;
+    log.scrollTop = log.scrollHeight;
+    // Tables / markdown can grow the bubble after this paint's layout.
+    // A second pin on the next frame follows that growth. Do not
+    // re-check the pad here — the snapshot already decided to follow.
+    if (pinRaf) cancelAnimationFrame(pinRaf);
+    pinRaf = requestAnimationFrame(function () {
+      pinRaf = 0;
+      log.scrollTop = log.scrollHeight;
+      pinningLog = false;
+    });
+  }
+  log.addEventListener('scroll', function () {
+    if (pinningLog) return;
+    followLive = log.scrollHeight - log.scrollTop - log.clientHeight < 140;
+  });
+  function ensureLiveBotRow() {
+    if (document.getElementById('streamBubble')) return;
+    const t = knownThreads.find((x) => x.id === activeId);
+    if (!t) return;
+    addRow('bot', streamBuf || '…', t.color, t.name, undefined, undefined, streamThink, true);
+    const row = log.querySelector('.row:last-child');
+    if (!row) return;
+    const b = row.querySelector('.bubble');
+    if (b) b.id = 'streamBubble';
+    const fold = row.querySelector('.thinkfold');
+    if (fold) fold.id = 'streamThink';
   }
   function paintStream() {
-    const b = document.getElementById('streamBubble');
-    if (!b) { render(); return; }
+    let b = document.getElementById('streamBubble');
+    if (!b) {
+      // Claude TUI start/replace used to call render(), which wiped #log
+      // and rebuilt from a fetch that could miss the just-sent user turn.
+      // Keep existing user rows; only attach the live assistant bubble.
+      ensureLiveBotRow();
+      b = document.getElementById('streamBubble');
+      if (!b) return;
+    }
+    // Snapshot BEFORE the bubble grows. Same idea as render()'s wasNearBottom.
+    const wasNearBottom = log.scrollHeight - log.scrollTop - log.clientHeight < 140;
+    if (wasNearBottom) followLive = true;
+    const parts = streamParts();
+    paintThinkFoldLive(parts.think);
     if (raceIsLive(streamRace)) {
+      b.hidden = false;
       b.classList.add('raceboard');
       b.innerHTML = liveBubbleHtml();
-      if (log.scrollHeight - log.scrollTop - log.clientHeight < 140) log.scrollTop = log.scrollHeight;
+      if (wasNearBottom || followLive) pinLogBottom();
+      scheduleFindPaint();
       return;
     }
     b.classList.remove('raceboard');
-    // Deltas stay as text; a silent wait paints dots + one mutating status
-    // line so a 20–40s pay/model wait is obviously alive.
-    if (streamBuf && !(streamStatus && /^(RUN|READ|WRITE|EDIT|SPAWN|SEND|GLOB|GREP|MCP|FETCH|TODO|SERVE|PING|PEEK|MULTIEDIT|NOTEBOOK):/i.test(streamStatus))) {
-      b.textContent = streamBuf;
+    // Model text only. Tool status / CoT live in the thinking… fold.
+    if (parts.visible) {
+      b.hidden = false;
+      b.textContent = scrubBotText(parts.visible);
     } else {
+      b.hidden = true;
       b.innerHTML = liveBubbleHtml();
     }
-    if (log.scrollHeight - log.scrollTop - log.clientHeight < 140) log.scrollTop = log.scrollHeight;
+    if (wasNearBottom || followLive) pinLogBottom();
+    scheduleFindPaint();
   }
   function connectStream(id) {
     if (!id || esId === id) return;
     if (es) es.close();
     esId = id;
     streamBuf = '';
+    streamThink = '';
+    streamTools = [];
     streamStatus = '';
     streamRace = null;
     streamRaceId = id;
+    liveThinkOpen = false;
+    // New thread: do not inherit follow from the previous log position.
+    followLive = log.scrollHeight - log.scrollTop - log.clientHeight < 140;
     raceHandoff += 1;
     es = new EventSource('/stream/' + id);   // EventSource reconnects on its own
     es.onmessage = (e) => {
@@ -5057,9 +5817,17 @@ const APP_HTML = `<!doctype html>
       try { ev = JSON.parse(e.data); } catch { return; }
       if (ev.type === 'start') {
         streamBuf = '';
+        streamThink = '';
+        streamTools = [];
         streamStatus = ev.detail || 'waiting on model…';
         streamRace = null;
         streamRaceId = id;
+        liveThinkOpen = false;
+        paintStream();
+      }
+      else if (ev.type === 'tool') {
+        const line = ev.detail || '';
+        if (line && streamTools[streamTools.length - 1] !== line) streamTools.push(line);
         paintStream();
       }
       else if (ev.type === 'status') { streamStatus = ev.detail || streamStatus; paintStream(); }
@@ -5070,8 +5838,14 @@ const APP_HTML = `<!doctype html>
         }
         paintStream();
       }
+      else if (ev.type === 'think') {
+        streamThink = ev.replace ? (ev.delta || '') : streamThink + (ev.delta || '');
+        paintStream();
+      }
       else if (ev.type === 'delta') {
         streamBuf = ev.replace ? (ev.delta || '') : streamBuf + (ev.delta || '');
+        // TUI frames replace the bubble without eating the folded thinking row.
+        if (ev.replace && /<think/i.test(ev.delta || '')) streamThink = '';
         paintStream();
       }
       else if (ev.type === 'final' || ev.type === 'run-pending') {
@@ -5081,6 +5855,8 @@ const APP_HTML = `<!doctype html>
           setTimeout(function () {
             if (token !== raceHandoff) return;
             streamBuf = '';
+            streamThink = '';
+            streamTools = [];
             streamStatus = '';
             streamRace = null;
             render();
@@ -5088,6 +5864,8 @@ const APP_HTML = `<!doctype html>
           return;
         }
         streamBuf = '';
+        streamThink = '';
+        streamTools = [];
         streamStatus = '';
         streamRace = null;
         render();
@@ -5148,15 +5926,22 @@ const APP_HTML = `<!doctype html>
 
   async function submit() {
     const task = inp.value.trim();
-    if (/^\/sitrep\b/i.test(task)) {
+    // String compare — never a regex. A sitrep word-boundary regex inside
+    // this template literal is eaten by the backtick parser and the whole
+    // client script dies (empty sidebar, send is a no-op).
+    const s = String(task).trim().toLowerCase();
+    if (s === '/sitrep' || s.startsWith('/sitrep ')) {
       inp.value = '';
       send.classList.remove('show');
       openSitrep();
       return;
     }
     if ((!task && !pendingFiles.length && !pendingImages.length) || !activeId) return;
-    inp.value = '';
-    send.classList.remove('show');
+    if (sending) return;
+    sending = true;
+    const draft = inp.value;
+    const hadFiles = pendingFiles.slice();
+    const hadImages = pendingImages.slice();
     let full = task;
     // an image with no caption still needs SOME text — an empty text block
     // alongside image_url content gets rejected (400) by at least one path
@@ -5167,13 +5952,39 @@ const APP_HTML = `<!doctype html>
         : '\\n\\n(attached binary file: ' + f.name + ', ' + f.size + ' bytes — content not readable as text)';
     }
     const images = pendingImages.map((i) => i.dataUrl);
-    pendingFiles = [];
-    pendingImages = [];
-    renderAttachChips();
-    await fetch(API + '/drive', {
-      method: 'POST', headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ threadId: activeId, task: full, images }),
-    });
+    const t = knownThreads.find((x) => x.id === activeId) || { color: '', name: '' };
+    pendingTurns.push({ threadId: activeId, text: full, images: images });
+    rememberUserTurn(activeId, full, images);
+    addRow('user', full, t.color, t.name, undefined, images);
+    try { log.scrollTop = log.scrollHeight; } catch (e) {}
+    followLive = true;
+    let persisted = false;
+    try {
+      const r = await fetch(API + '/drive', {
+        method: 'POST', headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ threadId: activeId, task: full, images }),
+      });
+      let body = {};
+      try { body = await r.json(); } catch (e) { body = {}; }
+      persisted = r.ok && body.persisted !== false;
+    } catch (e) { persisted = false; }
+    if (persisted) {
+      inp.value = '';
+      send.classList.remove('show');
+      pendingFiles = [];
+      pendingImages = [];
+      renderAttachChips();
+    } else {
+      pendingTurns = pendingTurns.filter((p) => !(p.threadId === activeId && p.text === full));
+      forgetUserTurn(activeId, full);
+      inp.value = draft;
+      pendingFiles = hadFiles;
+      pendingImages = hadImages;
+      renderAttachChips();
+      send.classList.toggle('show', inp.value.trim().length > 0 || pendingFiles.length > 0 || pendingImages.length > 0);
+      lastRenderKey = '';
+    }
+    sending = false;
     render();
   }
 
@@ -5366,26 +6177,196 @@ const APP_HTML = `<!doctype html>
   // It cannot change the version baked into the IMAGE — only the site's spawn
   // path can — so it says restart, not update. Promising an upgrade it cannot
   // deliver is how a UI teaches people to distrust it.
-  // Cmd/Ctrl+K -> search, the shortcut every chat app trains you to expect.
-  // Escape returns focus to the composer instead of leaving you stranded in
-  // a box you just cleared. Bound on keydown at the document so it works no
-  // matter which pane has focus.
+  // Cmd/Ctrl+K -> sidebar thread search (GET /search). Cmd/Ctrl+F is find
+  // inside the current #log — a different box, on purpose. Bound on document
+  // keydown so it works no matter which pane has focus; preventDefault so
+  // Chromium cannot swallow F for a page-find that was never wired.
   document.addEventListener('keydown', (e) => {
     const k = (e.key || '').toLowerCase();
-    if ((e.metaKey || e.ctrlKey) && k === 'k') {
+    const withMod = e.metaKey || e.ctrlKey;
+    if (withMod && k === 'k') {
       e.preventDefault();
       const el = document.getElementById('search');
       if (el) { el.focus(); el.select(); }
       return;
     }
+    if (withMod && k === 'f') {
+      e.preventDefault();
+      openFindBar();
+      return;
+    }
+    if (withMod && k === 'g' && findBarOpen()) {
+      e.preventDefault();
+      findStep(e.shiftKey ? -1 : 1);
+      return;
+    }
+    if (k === 'escape' && findBarOpen()) {
+      e.preventDefault();
+      closeFindBar();
+      return;
+    }
     // Cmd/Ctrl+Enter sends from anywhere — useful when focus drifted into a
     // RUN card or a copy button mid-thought.
-    if ((e.metaKey || e.ctrlKey) && k === 'enter') {
+    if (withMod && k === 'enter') {
       e.preventDefault();
       try { submit(); } catch (err) { /* not ready */ }
     }
   });
 
+  // FIND IN THREAD. Highlights visible .bubble text only — not sidebar
+  // threads, not think folds, not RUN cards, not tool JSON dumps.
+  let findMarks = [];
+  let findIndex = 0;
+  let findPaintTimer = null;
+  const findBar = document.getElementById('findBar');
+  const findInp = document.getElementById('findInp');
+  const findCount = document.getElementById('findCount');
+  function scheduleFindPaint() {
+    if (!findBarOpen()) return;
+    clearTimeout(findPaintTimer);
+    findPaintTimer = setTimeout(function () { applyFind(true); }, 160);
+  }
+  function findBarOpen() {
+    const el = document.getElementById('findBar');
+    return !!(el && el.classList.contains('show'));
+  }
+  function placeFindBar() {
+    const bar = document.getElementById('findBar');
+    const main = document.getElementById('main');
+    if (!bar || !chatHeader || !main) return;
+    const top = chatHeader.getBoundingClientRect().bottom - main.getBoundingClientRect().top + 8;
+    bar.style.top = Math.max(8, Math.round(top)) + 'px';
+  }
+  function clearFindMarks() {
+    const logEl = document.getElementById('log');
+    if (!logEl) { findMarks = []; return; }
+    const marks = logEl.querySelectorAll('mark.findhit');
+    for (let i = 0; i < marks.length; i++) {
+      const mark = marks[i];
+      const parent = mark.parentNode;
+      if (!parent) continue;
+      parent.replaceChild(document.createTextNode(mark.textContent), mark);
+      parent.normalize();
+    }
+    findMarks = [];
+  }
+  function paintFindCount() {
+    if (!findCount) return;
+    const n = findMarks.length;
+    findCount.textContent = n ? ((findIndex + 1) + ' / ' + n) : (findInp && findInp.value.trim() ? '0 / 0' : '');
+  }
+  function skipFindNode(node) {
+    const p = node && node.parentNode;
+    if (!p || !p.closest) return true;
+    return !!p.closest('.copybtn, .html-preview-wrap, button, script, style');
+  }
+  function highlightTextNode(node, query) {
+    const text = node.nodeValue || '';
+    const hay = text.toLowerCase();
+    const needle = query.toLowerCase();
+    if (!needle) return;
+    let from = 0;
+    const parts = [];
+    let idx = hay.indexOf(needle, from);
+    while (idx !== -1) {
+      if (idx > from) parts.push({ t: text.slice(from, idx), hit: false });
+      parts.push({ t: text.slice(idx, idx + needle.length), hit: true });
+      from = idx + needle.length;
+      idx = hay.indexOf(needle, from);
+    }
+    if (!parts.length) return;
+    if (from < text.length) parts.push({ t: text.slice(from), hit: false });
+    const frag = document.createDocumentFragment();
+    for (let i = 0; i < parts.length; i++) {
+      if (parts[i].hit) {
+        const mark = document.createElement('mark');
+        mark.className = 'findhit';
+        mark.textContent = parts[i].t;
+        findMarks.push(mark);
+        frag.appendChild(mark);
+      } else {
+        frag.appendChild(document.createTextNode(parts[i].t));
+      }
+    }
+    node.parentNode.replaceChild(frag, node);
+  }
+  function applyFind(preserve) {
+    const q = findInp ? findInp.value.trim() : '';
+    const keep = preserve ? findIndex : 0;
+    clearFindMarks();
+    if (!q) { findIndex = 0; paintFindCount(); return; }
+    const logEl = document.getElementById('log');
+    if (!logEl) { paintFindCount(); return; }
+    const bubbles = logEl.querySelectorAll('.bubble');
+    for (let b = 0; b < bubbles.length; b++) {
+      const nodes = [];
+      const walker = document.createTreeWalker(bubbles[b], NodeFilter.SHOW_TEXT, null);
+      let n = walker.nextNode();
+      while (n) {
+        if (n.nodeValue && !skipFindNode(n)) nodes.push(n);
+        n = walker.nextNode();
+      }
+      for (let i = 0; i < nodes.length; i++) highlightTextNode(nodes[i], q);
+    }
+    if (!findMarks.length) { findIndex = 0; paintFindCount(); return; }
+    findIndex = keep % findMarks.length;
+    if (findIndex < 0) findIndex = 0;
+    focusFindHit(findIndex);
+  }
+  function focusFindHit(i) {
+    for (let m = 0; m < findMarks.length; m++) findMarks[m].classList.remove('cur');
+    const mark = findMarks[i];
+    if (!mark) { paintFindCount(); return; }
+    mark.classList.add('cur');
+    if (mark.scrollIntoView) mark.scrollIntoView({ block: 'center', inline: 'nearest' });
+    paintFindCount();
+  }
+  function findStep(dir) {
+    if (!findMarks.length) return;
+    findIndex = (findIndex + dir + findMarks.length) % findMarks.length;
+    focusFindHit(findIndex);
+  }
+  function openFindBar() {
+    if (!findBar || !findInp) return;
+    findBar.classList.add('show');
+    placeFindBar();
+    findInp.focus();
+    findInp.select();
+    if (findInp.value.trim()) applyFind(true);
+    else paintFindCount();
+  }
+  function closeFindBar() {
+    if (findBar) findBar.classList.remove('show');
+    clearFindMarks();
+    findIndex = 0;
+    if (findCount) findCount.textContent = '';
+    if (inp) inp.focus();
+  }
+  if (findInp) {
+    findInp.addEventListener('input', () => applyFind(false));
+    findInp.addEventListener('keydown', (e) => {
+      if (e.key === 'Enter') {
+        e.preventDefault();
+        findStep(e.shiftKey ? -1 : 1);
+      }
+      if (e.key === 'Escape') {
+        e.preventDefault();
+        closeFindBar();
+      }
+    });
+  }
+  if (findBar) {
+    const prevBtn = document.getElementById('findPrev');
+    const nextBtn = document.getElementById('findNext');
+    const closeBtn = document.getElementById('findClose');
+    if (prevBtn) prevBtn.addEventListener('click', () => findStep(-1));
+    if (nextBtn) nextBtn.addEventListener('click', () => findStep(1));
+    if (closeBtn) closeBtn.addEventListener('click', closeFindBar);
+  }
+  if (window.electronAPI && typeof window.electronAPI.onFindInThread === 'function') {
+    window.electronAPI.onFindInThread(function () { openFindBar(); });
+  }
+
   const reloadBtn = document.getElementById('reloadBtn');
   if (reloadBtn) {
     reloadBtn.addEventListener('click', async () => {
@@ -5413,6 +6394,42 @@ const APP_HTML = `<!doctype html>
     const top = chatHeader.getBoundingClientRect().bottom - mainEl.getBoundingClientRect().top + 8;
     hud.style.top = Math.max(8, Math.round(top)) + 'px';
   }
+  function fmtDockX(n) {
+    if (n == null || !Number.isFinite(n)) return '—';
+    return (n >= 100 ? String(Math.round(n)) : Number(n).toFixed(n >= 10 ? 1 : 2)) + 'x';
+  }
+  function paintDock(you) {
+    const spillEl = document.getElementById('dockSpill');
+    const sessEl = document.getElementById('dockSession');
+    const paidEl = document.getElementById('dockPaid');
+    const bindEl = document.getElementById('dockBind');
+    const callsEl = document.getElementById('dockCalls');
+    if (!spillEl || !sessEl || !paidEl || !bindEl || !callsEl) return;
+    if (you && you.proxyReachable === false) {
+      spillEl.textContent = '—';
+      spillEl.className = 'dv';
+      sessEl.textContent = '—';
+      sessEl.className = 'dv';
+      paidEl.textContent = 'proxy unreachable';
+      bindEl.textContent = '—';
+      callsEl.textContent = '—';
+      return;
+    }
+    const spent = Number(you && you.spentUsd) || 0;
+    const direct = Number(you && you.directUsd) || 0;
+    const spillX = Number(you && you.spilled && you.spilled.savingX);
+    const spillCalls = Number(you && you.spilled && you.spilled.calls) || 0;
+    const spillOn = Number.isFinite(spillX) && spillX > 0;
+    const bound = spillOn || spillCalls > 0;
+    const sessionX = spent > 0 ? direct / spent : null;
+    spillEl.textContent = spillOn ? fmtDockX(spillX) : '—';
+    spillEl.className = spillOn ? 'dv hlime' : 'dv';
+    sessEl.textContent = sessionX == null ? '—' : fmtDockX(sessionX);
+    sessEl.className = 'dv';
+    paidEl.textContent = usd(spent);
+    bindEl.textContent = bound ? 'yes' : 'no';
+    callsEl.textContent = String((you && you.paidCalls) || 0);
+  }
   function usd(n) {
     if (n === null || n === undefined) return '—';
     if (n === 0) return '$0';
@@ -5425,6 +6442,22 @@ const APP_HTML = `<!doctype html>
       // straight to localhost:8402 would work fine, but routing it through
       // our own backend keeps one fetch path if that ever needs to change.
       const you = await (await fetch(API + '/hud-summary')).json();
+      const proxyDown = you.proxyReachable === false;
+      setHudTick(proxyDown ? 2000 : 30000);
+      if (proxyDown) {
+        const creditEl = document.getElementById('hCredit');
+        if (creditEl) creditEl.textContent = '—';
+        document.getElementById('hYouSpent').textContent = 'proxy unreachable';
+        document.getElementById('hYouCogs').textContent = '—';
+        document.getElementById('hYouMargin').textContent = '—';
+        document.getElementById('hYouDirect').textContent = '—';
+        document.getElementById('hYouSaved').textContent = '—';
+        document.getElementById('hFoot').textContent = 'proxy unreachable';
+        const hintEl = document.getElementById('hHint');
+        if (hintEl) hintEl.className = 'hhint';
+        paintDock(you);
+        return;
+      }
       const creditEl = document.getElementById('hCredit');
       if (creditEl) creditEl.textContent = (you.creditUsd == null) ? '—' : usd(Number(you.creditUsd) || 0);
       const subRow = document.getElementById('hSubRow');
@@ -5453,13 +6486,15 @@ const APP_HTML = `<!doctype html>
       const savedEl = document.getElementById('hYouSaved');
       const hintEl = document.getElementById('hHint');
       if (spent > 0) {
-        const mult = direct / spent;
+        const sav = formatSavingLabel(you);
+        const mult = sav.mult;
         // honest either way: >=1x is a real saving vs a naked direct call,
         // <1x means you're currently paying MORE than direct would cost —
         // don't dress that up as green when it isn't one.
         // Asking a bound corpus makes this genuinely large (the counterfactual
         // is shipping the WHOLE corpus), so 2dp would read as noise up there.
-        savedEl.textContent = (mult >= 100 ? Math.round(mult) : mult.toFixed(mult >= 10 ? 1 : 2)) + 'x';
+        // Label the number: "Nx spilled" when bound, else "Nx session".
+        savedEl.textContent = sav.text;
         savedEl.className = mult >= 1 ? 'hlime' : 'hember';
         // Session direct/spent (never first-call). Ember when cogs > spent —
         // house losing. Do not treat race_unused as a user refund.
@@ -5471,7 +6506,7 @@ const APP_HTML = `<!doctype html>
           hintEl.className = mult >= 1 ? 'hhint' : 'hhint show';
           hintEl.innerHTML = '<b>feed it more.</b> you\\'re billed on the slice actually sent, '
             + 'not the corpus — so the more you bind, the further ahead this gets. '
-            + 'small inputs cost more than sending them straight.';
+            + 'small inputs cost more than sending them straight. HUD is spilled-call x when any call bound.';
         }
       } else {
         savedEl.textContent = '—';
@@ -5483,25 +6518,45 @@ const APP_HTML = `<!doctype html>
         }
       }
       document.getElementById('hFoot').textContent = (you.paidCalls || 0) + ' paid calls this session';
+      paintDock(you);
     } catch (e) {
       document.getElementById('hFoot').textContent = 'error: ' + e.message;
     }
   }
   let hudTimer = null;
+  let hudTickMs = 30000;
+  function setHudTick(ms) {
+    if (hudTimer && hudTickMs === ms) return;
+    hudTickMs = ms;
+    if (hudTimer) clearInterval(hudTimer);
+    hudTimer = setInterval(refreshHud, hudTickMs);
+  }
+  function ensureHudTick() {
+    if (hudTimer) return;
+    hudTimer = setInterval(refreshHud, hudTickMs);
+  }
   hudBtn.addEventListener('click', (e) => {
     e.stopPropagation();
     hud.classList.toggle('show');
     if (hud.classList.contains('show')) {
       placeHud();
       refreshHud();
-      hudTimer = setInterval(refreshHud, 30000);
-    } else if (hudTimer) {
-      clearInterval(hudTimer); hudTimer = null;
     }
+    echoSlash('/hud');
+  });
+  refreshHud();
+  ensureHudTick();
+  window.addEventListener('resize', () => {
+    if (hud.classList.contains('show')) placeHud();
+    if (findBarOpen()) placeFindBar();
   });
-  window.addEventListener('resize', () => { if (hud.classList.contains('show')) placeHud(); });
-  if (typeof ResizeObserver !== 'undefined' && chatHeader) {
-    new ResizeObserver(() => { if (hud.classList.contains('show')) placeHud(); }).observe(chatHeader);
+  if (typeof ResizeObserver !== 'undefined') {
+    if (chatHeader) {
+      new ResizeObserver(() => {
+        if (hud.classList.contains('show')) placeHud();
+        if (findBarOpen()) placeFindBar();
+      }).observe(chatHeader);
+    }
   }
   document.addEventListener('click', (e) => { if (!hud.contains(e.target)) hud.classList.remove('show'); });
 </script>
@@ -5679,9 +6734,25 @@ const server = http.createServer((req, res) => {
 
   if (req.method === 'GET' && req.url === '/hud-summary') {
     (async () => {
-      let you = { spentUsd: 0, cogsUsd: 0, directUsd: 0, paidCalls: 0, creditUsd: null, chainUsd: null };
-      try { you = { ...you, ...(await (await fetch('http://127.0.0.1:8402/v1/session', { signal: AbortSignal.timeout(2000) })).json()) }; }
-      catch { /* local proxy not running — HUD shows zeros rather than guessing */ }
+      let you = { spentUsd: 0, cogsUsd: 0, directUsd: 0, paidCalls: 0, creditUsd: null, chainUsd: null, proxyReachable: false };
+      try {
+        const r = await fetch('http://127.0.0.1:8402/v1/session', { signal: AbortSignal.timeout(2000) });
+        // 402 = empty wallet / Pay — the sidecar is up. Do not paint that as dead.
+        if (r.ok || r.status === 402) {
+          you.proxyReachable = true;
+          if (r.ok) {
+            try { you = { ...you, ...(await r.json()), proxyReachable: true }; }
+            catch { /* body optional */ }
+          }
+        }
+      } catch { /* session down — try /v1/models before calling the proxy dead */ }
+      if (!you.proxyReachable) {
+        try {
+          const r = await fetch('http://127.0.0.1:8402/v1/models', { signal: AbortSignal.timeout(2000) });
+          if (r.ok || r.status === 402) you.proxyReachable = true;
+        } catch { /* local proxy not running — HUD must not pretend spend is $0 */ }
+      }
+      await attachSpilled(you);
       try {
         you.creditUsd = await creditBalance();
       } catch { /* credit is advisory */ }
@@ -5767,7 +6838,7 @@ const server = http.createServer((req, res) => {
     const t = threads.get(req.url.split('/')[2]);
     res.writeHead(200, { 'content-type': 'application/json' });
     res.end(t ? JSON.stringify({
-      id: t.id, history: t.history, status: t.status,
+      id: t.id, history: visibleHistory(t.history), status: t.status,
       liveStatus: t.status === 'thinking' ? (t.liveStatus || '') : '',
       liveRace: t.status === 'thinking' ? (t.liveRace || null) : null,
       lastRaceFail: t.lastRaceFail || null,
@@ -5856,28 +6927,39 @@ const server = http.createServer((req, res) => {
         threadId = j.threadId; task = (j.task || '').toString();
         images = Array.isArray(j.images) ? j.images.filter((u) => typeof u === 'string') : [];
       } catch { /* ignore */ }
-      res.writeHead(200, { 'content-type': 'application/json' });
-      res.end(JSON.stringify({ ok: true }));
+      const ack = (ok, extra = {}) => {
+        if (res.writableEnded) return;
+        const status = extra.status || (ok ? 200 : 500);
+        res.writeHead(status, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ ok: Boolean(ok), persisted: extra.persisted !== false, ...extra.body }));
+      };
       const t = threads.get(threadId);
-      // Every OTHER slash command. Local, free, instant — no model call, so
-      // checking your spend or clearing a thread never costs anything.
-      // /dir and /mode keep their own handlers below, untouched.
-      if (t && /^\//.test(task.trim())) {
+      if (!t) {
+        ack(false, { status: 404, persisted: false });
+        return;
+      }
+      // Grokui slashes stay local. In Auto, Claude's /agents /tasks /context
+      // /model (and any slash grokui does not own) go to the PTY — print-mode
+      // used to stub those as "wizard removed".
+      if (/^\//.test(task.trim())) {
         // Drawer-only. Never dump sitrep into the transcript.
-        if (/^\/sitrep\b/i.test(task.trim())) return;
-        const handled = await handleSlash(task.trim(), t).catch((e) => `error: ${e.message}`);
-        if (handled !== null && handled !== undefined) {
-          t.history.push({ who: 'bot', text: handled });
-          t.lastActivityAt = Date.now();
-          saveThreads();
-          return;
+        if (/^\/sitrep\b/i.test(task.trim())) { ack(true, { persisted: true }); return; }
+        if (!(t.runMode === 'auto' && !isGrokuiOwnedSlash(task.trim(), t.runMode))) {
+          const handled = await handleSlash(task.trim(), t).catch((e) => `error: ${e.message}`);
+          if (handled !== null && handled !== undefined) {
+            t.history.push({ who: 'bot', text: handled });
+            t.lastActivityAt = Date.now();
+            saveThreads();
+            ack(true, { persisted: true });
+            return;
+          }
         }
       }
       // "/dir <path>" is a LOCAL control command, not sent to the model at
       // all — free, instant, sets which folder this thread's WRITE/READ/SERVE
       // are scoped to. Respecify any time by sending it again.
       const dirCmd = /^\/dir\s+(.+)/.exec(task.trim());
-      if (dirCmd && t) {
+      if (dirCmd) {
         const full = path.resolve(expandHome(dirCmd[1].trim()));
         let ok = false;
         try { ok = statSync(full).isDirectory(); } catch { /* not a dir / doesn't exist */ }
@@ -5888,17 +6970,29 @@ const server = http.createServer((req, res) => {
           t.history.push({ who: 'bot', text: `"${full}" isn't a directory that exists.` });
         }
         saveThreads();
+        ack(true, { persisted: true });
         return;
       }
-      // "/mode auto|ask" toggles whether RUN: commands execute immediately
-      // or wait for an explicit approve/deny — also free/instant, no model call
+      // "/mode auto|ask" — Auto is the Claude Code harness (openzoo claude
+      // env). Ask stays a chat completion; RUN: waits for approve/deny.
       const modeCmd = /^\/mode\s+(auto|ask)\b/.exec(task.trim());
-      if (modeCmd && t) {
+      if (modeCmd) {
         t.runMode = modeCmd[1];
-        t.history.push({ who: 'bot', text: `Run mode set to ${modeCmd[1]}${modeCmd[1] === 'auto' ? ' — commands execute immediately, no approval.' : ' — commands wait for your approval.'}` });
+        if (modeCmd[1] !== 'auto') closeClaudeSession(t.id);
+        t.history.push({ who: 'bot', text: `Run mode set to ${modeCmd[1]}${modeCmd[1] === 'auto' ? ' — Claude Code via OpenZoo (x402). Interactive TUI on a PTY, not --print.' : ' — chat completion; RUN: waits for your approval.'}` });
         saveThreads();
+        ack(true, { persisted: true });
+        return;
+      }
+      // Persist the user bubble to disk BEFORE the model call and before
+      // the HTTP ACK. A proxy 500 / sidecar bounce / remount must not
+      // forget the turn, and must not rewrite it as an AUTO continue.
+      const flushed = persistUserTurn(t, task, images);
+      if (!flushed.ok) {
+        ack(false, { status: 500, persisted: false });
         return;
       }
+      ack(true, { persisted: true });
       // Stream to whoever is watching this thread. emitToThread is a no-op
       // when nobody is, so a spawned subagent nobody has open costs nothing.
       runTurn(threadId, task, (ev) => emitToThread(threadId, ev), images).catch(() => {});
@@ -5913,12 +7007,16 @@ server.listen(PORT, BIND, () => console.log(`[grokui] http://${BIND === '0.0.0.0
 
 export {
   tryDirective, ensureWorkspacePort, isPreviewableRel, previewAck, workspaceFileUrl,
-  parseRun, looksLikeMcpAsBash, stripThinkTags, safeResolveIn, inDir, listDir,
-  handleSlash, newThread, setRunTurnForTest, setBrainAskForTest, runTurn,
+  parseRun, looksLikeMcpAsBash, stripThinkTags, takeThink, safeResolveIn, inDir, listDir,
+  handleSlash, isGrokuiOwnedSlash, newThread, setRunTurnForTest, setBrainAskForTest, setClaudeRunnerForTest, runTurn,
+  runAutoClaudeTurn, autoClaudePrompt,
   AUTO_CONTINUE, AUTO_RACE_RETRY, AUTO_EMPTY_RETRY, pingWakeText, pingCanWake, shouldKeepAuto,
   isDoneReply, isTransientModelFail, isPaymentFailed, isEmptyWalletPayment, isEmptyToolResult, enqueueAutoHop, childKickoff, findByName,
   attachChildDir, finishChildDir,
   lockWorktree, unlockWorktree, parsePrRef, fetchSpecsForOrigin, agentSlug,
   filesForCorpus, noteFileForCorpus, noteRunForCorpus, resetFilesForCorpus,
   filesForCorpusKeys, scheduleFilesForCorpus, inFlightChars, BIND_MIN_CHARS, KEEP_MAX,
+  formatSavingLabel, holobrainOf, looksLikeProxyShell, CHAT_NOT_PROXY, PROXY_SHELL_REFUSE,
+  persistUserTurn, isHarnessUserText, visibleHistory, isVisibleHistoryEntry, saveThreads,
+  isClaudeFallbackReply, popClaudeFallbackBot, threadHasVisibleBotReply,
 };