openzoo 0.48.87 → 0.48.89

package/lib/grokui.mjs

@@ -12,6 +12,8 @@ import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSyn
 import { cpus, homedir } from 'node:os';
 import path from 'node:path';
 import { adaptiveTopK, brain, brainRace, brainStream, tierModels, MODEL, PROXY, TIER_NAMES } from './podagent.mjs';
+import { peekDirectiveStatus, STALE_THINKING_MS } from './livestatus.js';
+import { creditBalance } from './info.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
@@ -54,6 +56,28 @@ const MIME = { html: 'text/html', htm: 'text/html', css: 'text/css', js: 'applic
   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' };
 let workspacePort = null;
+let workspacePortResolve = () => {};
+let workspaceBinding = false;
+const workspacePortReady = new Promise((resolve) => { workspacePortResolve = resolve; });
+function bindWorkspaceServer() {
+  if (workspaceServer.listening) {
+    workspacePort = workspaceServer.address().port;
+    workspacePortResolve(workspacePort);
+    return;
+  }
+  if (workspaceBinding) return;
+  workspaceBinding = true;
+  try {
+    workspaceServer.listen(0, '127.0.0.1', () => {
+      workspacePort = workspaceServer.address().port;
+      workspacePortResolve(workspacePort);
+    });
+  } catch (err) {
+    workspaceBinding = false;
+    console.error('[grokui] workspace server:', err.message);
+    setTimeout(bindWorkspaceServer, 250);
+  }
+}
 // route: /<threadId>/<relpath...> — each thread is served from ITS OWN dir
 const workspaceServer = http.createServer((req, res) => {
   try {
@@ -65,14 +89,65 @@ const workspaceServer = http.createServer((req, res) => {
     const full = safeResolveIn(dirFor(threadId), rel);
     const data = readFileSync(full);
     const ext = full.split('.').pop();
-    res.writeHead(200, { 'content-type': MIME[ext] || 'application/octet-stream' });
+    res.writeHead(200, {
+      'content-type': MIME[ext] || 'application/octet-stream',
+      // EDIT of the same html must not be served from a cached first write.
+      'cache-control': 'no-store',
+    });
     res.end(data);
   } catch {
     res.writeHead(404, { 'content-type': 'text/plain' });
     res.end('not found');
   }
 });
-workspaceServer.listen(0, '127.0.0.1', () => { workspacePort = workspaceServer.address().port; });
+workspaceServer.on('error', (err) => {
+  workspaceBinding = false;
+  console.error('[grokui] workspace server:', err.message);
+  setTimeout(bindWorkspaceServer, 250);
+});
+bindWorkspaceServer();
+
+function isPreviewableRel(rel) {
+  const base = path.basename(String(rel || '').split('?')[0]).toLowerCase();
+  return base.endsWith('.html') || base.endsWith('.htm');
+}
+
+async function ensureWorkspacePort(ms = 4000) {
+  if (workspacePort) return workspacePort;
+  if (!workspaceServer.listening) bindWorkspaceServer();
+  let timer;
+  const timeout = new Promise((resolve) => { timer = setTimeout(() => resolve(null), ms); });
+  const port = await Promise.race([workspacePortReady, timeout]);
+  clearTimeout(timer);
+  return port || workspacePort;
+}
+
+function workspaceFileUrl(originId, rel) {
+  const clean = String(rel || '').replace(/^\/+/, '');
+  return `http://localhost:${workspacePort}/${originId}/${clean}`;
+}
+
+// WRITE/EDIT of a playable page must ack a real http:// URL (same shape as
+// SERVE), not a dead disk path. Wait for the static server rather than
+// telling the user to try again after they just wrote a game.
+async function previewAck(originId, rel) {
+  if (!isPreviewableRel(rel)) return '';
+  const port = await ensureWorkspacePort();
+  if (!port) {
+    return `\nPreview: the workspace server is binding; the page is ${rel} and will be at `
+      + `http://localhost/<port>/${originId}/${String(rel).replace(/^\/+/, '')}.`;
+  }
+  return `\nPreview: ${workspaceFileUrl(originId, rel)}`;
+}
+
+const HTML_PREVIEW_RULE = `
+PREVIEW IS AUTOMATIC. After you WRITE or EDIT a .html / .htm file (including index.html),
+the harness already served it — the WRITE ack includes a real http://localhost URL and the
+chat bubble shows a live iframe. The harness will preview. Do not tell the user you
+"can't preview", cannot open a browser, or dump a raw disk path (/Users/..., ~/.openzoo/...)
+as the punchline. The page is already on screen. If you mention a location, use that
+http://localhost link, never a filesystem path.
+`;
 
 const PALETTE = ['#e91e8c', '#34c759', '#ff9500', '#5e5ce6', '#ff3b30', '#0a84ff', '#00c7be'];
 function colorFor(name) {
@@ -117,11 +192,15 @@ workspace folder, not their real project. Same one-line-no-prose reply format:
   SERVE: <relative path, or blank for the dir root>   get a real http:// URL for a file —
                                                        use this instead of claiming you
                                                        "can't expose a port": you can serve
-                                                       static files, just not run a process
+                                                       static files, just not run a process.
+                                                       HTML writes are auto-served — you do
+                                                       not need a separate SERVE for a
+                                                       playable page.
   FETCH: <url>                                        actually fetch and read a page's real
                                                        text — web search only gives you short
                                                        snippets; use FETCH when asked to
                                                        "read" or quote something specific
+${HTML_PREVIEW_RULE}
 
 HOW YOUR SITE ACTUALLY GETS A URL — read this before writing web files.
 
@@ -296,7 +375,14 @@ function loadThreads() {
     if (!existsSync(STORE_FILE)) return false;
     const arr = JSON.parse(readFileSync(STORE_FILE, 'utf8'));
     if (!Array.isArray(arr) || !arr.length) return false;
-    for (const t of arr) threads.set(t.id, t);
+    for (const t of arr) {
+      // A crash mid-turn persisted status=thinking. Do not reload into mute "…".
+      if (t.status === 'thinking') {
+        t.status = 'idle';
+        t.liveStatus = '';
+      }
+      threads.set(t.id, t);
+    }
     return true;
   } catch { return false; }
 }
@@ -367,9 +453,12 @@ the user sets or changes it with "/dir <path>" in chat. Same format:
   READ: <relative path>                              read a file back
   SERVE: <relative path, or blank for the dir root>   get a real http:// URL for it — use
                                                        this instead of saying you can't
-                                                       expose a port
+                                                       expose a port. HTML writes are
+                                                       auto-served; you do not need SERVE
+                                                       just to preview a playable page.
   FETCH: <url>                                        actually fetch and read a page's real
                                                        text — web search only gives snippets
+${HTML_PREVIEW_RULE}
   RUN: <shell command>                                run a REAL shell command in this
                                                        group's shared directory — pauses the
                                                        WHOLE round for the user's approval
@@ -1106,6 +1195,24 @@ setInterval(() => {
   }
 }, 15000).unref();
 
+// A turn that is thinking with no deltas/status for too long is dead — the
+// stream reader used to hang forever and block the next user prompt behind
+// mute dots. Bump turnSeq so the in-flight runTurn bails, then idle.
+setInterval(() => {
+  const now = Date.now();
+  let dirty = false;
+  for (const t of threads.values()) {
+    if (t.status !== 'thinking') continue;
+    const last = t.lastDeltaAt || t.thinkingAt || 0;
+    if (!last || now - last < STALE_THINKING_MS) continue;
+    t.turnSeq = (t.turnSeq || 0) + 1;
+    t.status = 'idle';
+    t.liveStatus = '';
+    dirty = true;
+  }
+  if (dirty) saveThreads();
+}, 5000).unref();
+
 // Directives that only READ. These are safe to run at the same time, so a
 // reply carrying several of them costs one round trip instead of N — a model
 // that wants four files currently spends four full turns (and four payments)
@@ -1487,7 +1594,19 @@ function nameAddressedToSend(reply, originId) {
   }).join('\n');
 }
 
-async function tryDirective(reply, originId) {
+function emitLiveStatus(originId, onEvent, detail) {
+  if (!detail) return;
+  const t = threads.get(originId);
+  if (t) {
+    t.liveStatus = detail;
+    t.lastDeltaAt = Date.now();
+  }
+  onEvent?.({ type: 'status', name: t?.name, color: t?.color, detail });
+}
+
+async function tryDirective(reply, originId, onEvent) {
+  const trail = peekDirectiveStatus(reply);
+  if (trail) emitLiveStatus(originId, onEvent, trail);
   // Foreign envelope in, our directives out — before any matching runs, so
   // every branch below sees the shape it was written for.
   const translated = translateForeignToolCall(reply);
@@ -1512,7 +1631,7 @@ async function tryDirective(reply, originId) {
   const batch = [...reply.matchAll(PARALLEL_DIRECTIVE)];
   if (batch.length > 1) {
     const results = await Promise.all(
-      batch.map((m) => tryDirective(m[0].replace(/^[ \t>*-]*/, ''), originId)
+      batch.map((m) => tryDirective(m[0].replace(/^[ \t>*-]*/, ''), originId, onEvent)
         .catch((e) => `${m[1]}: ${e.message}`)),
     );
     return results.filter(Boolean).join('\n\n');
@@ -1613,7 +1732,7 @@ async function tryDirective(reply, originId) {
   const sendAll = directiveLines(reply, 'SEND');
   if (sendAll.length > 1) {
     const out = [];
-    for (const line of sendAll) out.push(await tryDirective('SEND: ' + line, originId));
+    for (const line of sendAll) out.push(await tryDirective('SEND: ' + line, originId, onEvent));
     return out.filter(Boolean).join('\n');
   }
   const sendM = sendAll.length === 1 ? /^([^|]+)\|([\s\S]+)/.exec(sendAll[0]) : null;
@@ -1642,7 +1761,7 @@ async function tryDirective(reply, originId) {
   const pingAll = directiveLines(reply, 'PING');
   if (pingAll.length > 1) {
     const out = [];
-    for (const line of pingAll) out.push(await tryDirective('PING: ' + line, originId));
+    for (const line of pingAll) out.push(await tryDirective('PING: ' + line, originId, onEvent));
     return out.filter(Boolean).join('\n');
   }
   const ping = pingAll.length === 1 ? [null, pingAll[0]] : null;
@@ -1687,7 +1806,7 @@ async function tryDirective(reply, originId) {
       const full = safeResolveIn(dirFor(originId), rel);
       mkdirSync(path.dirname(full), { recursive: true });
       writeFileSync(full, content);
-      return `Wrote ${rel} (${Buffer.byteLength(content)} bytes) to ${dirFor(originId)}.`;
+      return `Wrote ${rel} (${Buffer.byteLength(content)} bytes) to ${dirFor(originId)}.${await previewAck(originId, rel)}`;
     } catch (e) { return `Couldn't write ${rel}: ${e.message}`; }
   }
   const readD = /^[ \t>*-]*READ:\s*(.+)/m.exec(reply);
@@ -1713,7 +1832,7 @@ async function tryDirective(reply, originId) {
       if (hits === 0) return `EDIT ${rel}: that exact text isn't in the file — READ it first, the copy must match byte for byte.`;
       if (hits > 1) return `EDIT ${rel}: that text appears ${hits} times — include more surrounding context so it matches exactly once.`;
       writeFileSync(full, before.replace(oldStr, newStr));
-      return `Edited ${rel} (${before.length} -> ${before.replace(oldStr, newStr).length} bytes).`;
+      return `Edited ${rel} (${before.length} -> ${before.replace(oldStr, newStr).length} bytes).${await previewAck(originId, rel)}`;
     } catch (e) { return `Couldn't edit ${rel}: ${e.message}`; }
   }
 
@@ -1739,7 +1858,7 @@ async function tryDirective(reply, originId) {
         applied.push(o.slice(0, 40));
       }
       writeFileSync(full, next);
-      return `MULTIEDIT ${rel}: ${applied.length} edit(s) applied (${before.length} -> ${next.length} bytes).`;
+      return `MULTIEDIT ${rel}: ${applied.length} edit(s) applied (${before.length} -> ${next.length} bytes).${await previewAck(originId, rel)}`;
     } catch (e) { return `Couldn't multiedit ${rel}: ${e.message}`; }
   }
 
@@ -1888,8 +2007,11 @@ async function tryDirective(reply, originId) {
   const serve = /^[ \t>*-]*SERVE:\s*(.*)$/m.exec(reply);
   if (serve) {
     const rel = serve[1].trim();
-    if (!workspacePort) return 'Workspace server is still starting — try again in a second.';
-    return `Serving at http://localhost:${workspacePort}/${originId}/${rel}`;
+    const port = await ensureWorkspacePort();
+    if (!port) {
+      return `Serving ${rel || 'index.html'} from ${dirFor(originId)} — waiting for the workspace port to bind.`;
+    }
+    return `Serving at http://localhost:${port}/${originId}/${rel}`;
   }
   const fetchD = /^[ \t>*-]*FETCH:\s*(\S+)/m.exec(reply);
   if (fetchD) {
@@ -2026,59 +2148,78 @@ async function mcpDirective(url, tool, args) {
 }
 
 // onEvent (optional) gets live progress for whoever's actually watching this
-// call: {type:'start',name,color} when a bot begins its turn, {type:'delta',
-// name,color,delta} per streamed token, {type:'final',name,color,text} once
-// its full reply (or directive ack) is settled. Background turns — a SPAWNed
+// call: {type:'start',name,color} when a bot begins its turn, {type:'status',
+// detail} while paying / waiting / walking tools, {type:'delta',name,color,
+// delta} per streamed token, {type:'final',name,color,text} once its full
+// reply (or directive ack) is settled. Background turns — a SPAWNed
 // subagent nobody's looking at yet — run with onEvent omitted and just use
 // the plain non-streaming brain(), which is cheaper when nothing renders it.
 async function runTurn(threadId, userText, onEvent, images) {
   const t = threads.get(threadId);
   if (!t) return;
+  // A new user prompt must not sit behind a dead auto-continue. Bump the
+  // generation so the previous runTurn's awaits bail instead of keeping
+  // status=thinking and the UI on "…".
+  if (!isHarnessUserText(userText)) t.turnSeq = (t.turnSeq || 0) + 1;
+  const seq = t.turnSeq || 0;
+  const stillMine = () => threads.get(threadId)?.turnSeq === seq;
+  const paint = (ev) => {
+    if (!stillMine()) return;
+    if (ev.type === 'status' && ev.detail) t.liveStatus = ev.detail;
+    if (ev.type === 'delta' || ev.type === 'status' || ev.type === 'start') t.lastDeltaAt = Date.now();
+    onEvent?.(ev);
+  };
   t.history.push(images && images.length ? { who: 'user', text: userText, images } : { who: 'user', text: userText });
   t.lastActivityAt = Date.now();
+  t.status = 'thinking';
+  t.thinkingAt = Date.now();
+  t.lastDeltaAt = Date.now();
+  t.liveStatus = 'waiting on model…';
+  let chained = false;
+  let parked = false;
+  try {
   if (t.members) {
-    t.status = 'thinking';
     // sequential, not parallel: each member's context is rebuilt from
     // t.history right before its turn, so it sees every reply (including
     // spawns/sends) the earlier members in THIS round already made
     for (const m of t.members) {
+      if (!stillMine()) return;
       const msgs = buildMemberMessages(t, m);
       let r = '';
-      onEvent?.({ type: 'start', name: m.name, color: m.color });
+      paint({ type: 'start', name: m.name, color: m.color, detail: 'waiting on model…' });
+      const emitStatus = (detail) => paint({ type: 'status', name: m.name, color: m.color, detail });
       try {
         r = onEvent
-          ? (await brainStream(msgs, (delta) => onEvent({ type: 'delta', name: m.name, color: m.color, delta }), t.contextId)).trim()
+          ? (await brainStream(msgs, (delta) => 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;
       const runCmd = parseRun(r);
       if (runCmd) {
         const command = runCmd;
         if (t.runMode === 'auto') {
+          emitLiveStatus(t.id, paint, peekDirectiveStatus('', command));
           const output = await execCommand(command, dirFor(t.id));
           const shown = `$ ${command}\n${output}`;
           t.history.push({ who: 'bot', text: shown, name: m.name, color: m.color });
-          onEvent?.({ type: 'final', name: m.name, color: m.color, text: shown });
+          paint({ type: 'final', name: m.name, color: m.color, text: 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 });
-        onEvent?.({ type: 'run-pending', runId, command, name: m.name, color: m.color });
+        paint({ type: 'run-pending', runId, command, name: m.name, color: m.color });
         // pauses the WHOLE round here — the rest of the group gets their turn
         // on the round that runs after the user approves/denies
-        t.status = 'idle';
-        t.lastActivityAt = Date.now();
-        saveThreads();
+        parked = true;
         return;
       }
-      const ack = await tryDirective(r, t.id);
+      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 });
-      onEvent?.({ type: 'final', name: m.name, color: m.color, text: finalText });
+      paint({ type: 'final', name: m.name, color: m.color, text: finalText });
     }
-    t.status = 'idle';
-    saveThreads();
     bindThread(t).catch(() => {});
     return;
   }
@@ -2092,9 +2233,8 @@ async function runTurn(threadId, userText, onEvent, images) {
     delete t.autoNudged;
   }
   t.messages.push({ role: 'user', content: contentFor(userText, images) });
-  t.status = 'thinking';
   let reply = '';
-  onEvent?.({ type: 'start', name: t.name, color: t.color });
+  paint({ type: 'start', name: t.name, color: t.color, detail: 'waiting on model…' });
   // Transient: the nudge is appended for THIS call only and never pushed into
   // t.messages, so it can't accumulate across a chained auto run or get bound
   // into the thread's context.
@@ -2119,7 +2259,8 @@ async function runTurn(threadId, userText, onEvent, images) {
   // `attempt` exists because a retry must be allowed to land somewhere else:
   // see the empty-completion loop below.
   const ask = async (attempt = 0) => {
-    const emit = (delta) => onEvent && onEvent({ type: 'delta', name: t.name, color: t.color, delta });
+    const emit = (delta) => paint({ type: 'delta', name: t.name, color: t.color, delta });
+    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);
@@ -2131,16 +2272,18 @@ async function runTurn(threadId, userText, onEvent, images) {
       // the middle (2 of 3) is a judged answer without the slowest entrant
       // setting the latency.
       const need = Math.min(Math.max(Number(t.raceNeed) || 1, 1), race);
+      emitStatus('waiting on model…');
       return (await brainRace(callMsgs, emit, t.contextId, models, need)).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;
     return (onEvent
-      ? (await brainStream(callMsgs, emit, t.contextId, model)).trim()
+      ? (await brainStream(callMsgs, emit, t.contextId, model, undefined, 0, topK, emitStatus)).trim()
       : (await brain(callMsgs, t.contextId, model, topK)).trim());
   };
   try {
     reply = await ask();
+    if (!stillMine()) return;
     // An EMPTY completion is transient far more often than it is meaningful —
     // it showed up repeatedly as a dead "(no response)" bubble that cost the
     // user a turn and told them nothing. Retry once before giving up, and if
@@ -2157,7 +2300,9 @@ async function runTurn(threadId, userText, onEvent, images) {
     // fix. A thread pinned with /model stays pinned; that was an explicit
     // choice and silently answering as something else would be worse.
     for (let i = 0; !reply && i < AUTO_EMPTY_RETRIES; i++) {
+      paint({ type: 'status', name: t.name, color: t.color, detail: 'retrying…' });
       await new Promise((r) => setTimeout(r, 400 * (i + 1)));
+      if (!stillMine()) return;
       reply = await ask(t.model ? 0 : i + 1);
     }
     if (!reply) {
@@ -2168,15 +2313,18 @@ async function runTurn(threadId, userText, onEvent, images) {
   } catch (e) {
     reply = `error: ${e.message}`;
   }
+  if (!stillMine()) return;
   t.messages.push({ role: 'assistant', content: reply });
   const runCmd = parseRun(reply);
   if (runCmd) {
     const command = runCmd;
     if (t.runMode === 'auto') {
+      emitLiveStatus(t.id, paint, peekDirectiveStatus('', command));
       const output = await execCommand(command, dirFor(t.id));
+      if (!stillMine()) return;
       const shown = `$ ${command}\n${output}`;
       t.history.push({ who: 'bot', text: shown });
-      onEvent?.({ type: 'final', name: t.name, color: t.color, text: shown });
+      paint({ type: 'final', name: t.name, color: t.color, text: shown });
       // 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,
@@ -2186,9 +2334,6 @@ async function runTurn(threadId, userText, onEvent, images) {
       // AUTO_MAX_STEPS chained commands per user message, reset whenever the
       // user speaks again.
       t.autoSteps = (t.autoSteps || 0) + 1;
-      t.status = 'idle';
-      t.lastActivityAt = Date.now();
-      saveThreads();
       if (t.autoSteps < AUTO_MAX_STEPS) {
         // BIND BEFORE CHAINING. bindThread only ran at the end of a normal
         // turn, and both auto paths return before reaching it — so in auto
@@ -2196,12 +2341,14 @@ async function runTurn(threadId, userText, onEvent, images) {
         // most material (command output, GLOB results, MCP tool lists). The
         // holographic context stopped growing precisely when it mattered.
         bindThread(t).catch(() => {});
+        chained = true;
         runTurn(threadId, condense('(command output)', output), onEvent).catch(() => {});
       } else {
         // Do not park. A "say continue" note is the failure mode auto exists
         // to avoid — inject continue and keep going until DONE or ask.
         t.autoSteps = 0;
         bindThread(t).catch(() => {});
+        chained = true;
         runTurn(threadId, AUTO_CONTINUE, onEvent).catch(() => {});
       }
       return;
@@ -2210,20 +2357,16 @@ 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' });
-      onEvent?.({ type: 'run-pending', runId, command, name: t.name, color: t.color });
+      paint({ type: 'run-pending', runId, command, name: t.name, color: t.color });
     }
-    t.status = 'idle';
-    t.lastActivityAt = Date.now();
-    saveThreads();
+    parked = true;
     return;
   }
-  const ack = await tryDirective(reply, t.id);
+  const ack = await tryDirective(reply, t.id, paint);
+  if (!stillMine()) return;
   const finalText = ack ?? (reply || '(no response)');
   t.history.push({ who: 'bot', text: finalText });
-  onEvent?.({ type: 'final', name: t.name, color: t.color, text: finalText });
-  t.status = 'idle';
-  t.lastActivityAt = Date.now();
-  saveThreads();
+  paint({ type: 'final', name: t.name, color: t.color, text: finalText });
 
   // AUTO CONTINUES AFTER *ANY* DIRECTIVE, not just RUN.
   //
@@ -2240,6 +2383,7 @@ async function runTurn(threadId, userText, onEvent, images) {
       && !/^[ \t>*-]*DONE:/m.test(reply)) {
     t.autoSteps = (t.autoSteps || 0) + 1;
     bindThread(t).catch(() => {});   // bind every hop, not just the last one
+    chained = true;
     if (t.autoSteps < AUTO_MAX_STEPS) {
       runTurn(threadId, condense('(directive result)', ack), onEvent).catch(() => {});
     } else {
@@ -2273,8 +2417,8 @@ async function runTurn(threadId, userText, onEvent, images) {
     // another continue rather than stopping.
     t.autoNudged = true;
     t.autoSteps = (t.autoSteps || 0) + 1;
-    saveThreads();
     bindThread(t).catch(() => {});
+    chained = true;
     if (t.autoSteps < AUTO_MAX_STEPS) {
       runTurn(threadId, NUDGE, onEvent).catch(() => {});
     } else {
@@ -2284,6 +2428,17 @@ async function runTurn(threadId, userText, onEvent, images) {
     return;
   }
   bindThread(t).catch(() => {});
+  } finally {
+    // A hung or thrown brainStream used to leave t.status = 'thinking' and the
+    // UI on mute "…" forever. Always idle unless this hop chained or parked
+    // on an approval — the next runTurn sets thinking again itself.
+    if (stillMine() && !chained && !parked && !t.pendingRun) {
+      t.status = 'idle';
+      t.liveStatus = '';
+    }
+    t.lastActivityAt = Date.now();
+    saveThreads();
+  }
 }
 
 // Said it would, without a directive line. "Spawned X" and "working on it" are
@@ -2418,6 +2573,7 @@ function threadSummary(t) {
     // an approval nobody knew it wanted. The blue dot means "working"; this
     // means "your move".
     awaitingUser: Boolean(t.pendingRun),
+    liveStatus: t.status === 'thinking' ? (t.liveStatus || '') : '',
     rootId: rootOf(t).rootId, depth: rootOf(t).depth,
     rootName: (threads.get(rootOf(t).rootId) || t).name,
     // The spend dial, so the header can show it without a round trip per
@@ -2425,7 +2581,8 @@ function threadSummary(t) {
     tier: t.tier || 'medium', race: Number(t.race) || 0, raceNeed: Number(t.raceNeed) || 1, model: t.model || '',
     // How many bots sit BELOW this one. The ping-all affordance belongs on
     // anyone with a crew, not only on a project root.
-    kids: subtreeOf(t.id).length };
+    kids: subtreeOf(t.id).length,
+    workspacePort: workspacePort || 0 };
 }
 
 const APP_HTML = `<!doctype html>
@@ -2557,6 +2714,10 @@ const APP_HTML = `<!doctype html>
   .wrow .wcopy { flex: 0 0 auto; color: #6f7080; font-size: 10px; text-transform: uppercase; letter-spacing: .06em;
                  user-select: none; }
   .wrow:hover .wcopy { color: #b8f240; }
+  .wcredit { border: 1px solid #2a3a18; background: rgba(184,242,64,.08); border-radius: 12px;
+             padding: 12px 14px; margin-bottom: 12px; }
+  .wcredit .wbig { color: #b8f240; font-size: 22px; font-weight: 700; letter-spacing: -0.03em; }
+  .wcredit .wlab2 { color: #8e8e93; font-size: 11px; margin-top: 2px; }
   .wbal { border: 1px solid #1c1c1e; border-radius: 12px; padding: 10px 12px; margin-bottom: 10px;
           font-size: 12px; color: #ececec; line-height: 1.7; word-break: break-word; }
   .wnote { color: #6f7080; font-size: 11px; line-height: 1.6; margin-top: 12px; }
@@ -2579,11 +2740,14 @@ const APP_HTML = `<!doctype html>
      inside the dials (race / wallet / ◎) once they take a second row. top is
      set from the header's live bottom in placeHud(). z-index stays high; the
      bug was geometry, not stacking. */
-  #hud { position: absolute; right: 14px; width: 250px; background: rgba(14,14,17,.94);
+  #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); }
   #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; }
+  #hud .hcredit { color: #b8f240; font-size: 22px; font-weight: 700; letter-spacing: -0.03em; line-height: 1.15; }
+  #hud .hcreditlab { color: #999aa8; font-size: 10px; margin: 2px 0 8px; }
   #hud .hrow { display: flex; justify-content: space-between; margin: 6px 0; color: #f0f0eb; font-size: 12px; }
   #hud .hrow span:first-child { color: #999aa8; font-size: 10.5px; }
   #hud .hlime { color: #b8f240; }
@@ -2621,7 +2785,13 @@ const APP_HTML = `<!doctype html>
   /* rendered markdown. The bubble is pre-wrap for plain text, but block
      elements carry their own spacing — leaving pre-wrap on would add the
      source newlines back on top of it and double every gap. */
-  .bubble:has(> p, > .md-h, > .md-table, > .md-list, > .md-pre) { white-space: normal; }
+  .bubble:has(> p, > .md-h, > .md-table, > .md-list, > .md-pre, > .html-preview-wrap) { white-space: normal; }
+  .row:has(.html-preview) { max-width: 92%; }
+  .html-preview-wrap { margin-top: 10px; }
+  .html-preview-open { display: inline-block; margin-bottom: 6px; font-size: 12px; color: #6ab0ff;
+                       text-decoration: underline; cursor: pointer; }
+  .html-preview { display: block; width: 100%; height: 420px; border: 1px solid #3a3a3c;
+                  border-radius: 12px; background: #111; }
   .bubble > p { margin: 0 0 10px; }
   .bubble > p:last-child { margin-bottom: 0; }
   .md-h { margin: 14px 0 8px; font-size: 15px; font-weight: 600; line-height: 1.3; }
@@ -2690,6 +2860,8 @@ const APP_HTML = `<!doctype html>
                background: #8e8e93; animation: blink 1.2s infinite ease-in-out; }
   .dots span:nth-child(2) { animation-delay: .2s; } .dots span:nth-child(3) { animation-delay: .4s; }
   @keyframes blink { 0%, 80%, 100% { opacity: .25; } 40% { opacity: 1; } }
+  .tstatus { color: #8e8e93; font-size: 13px; margin-left: 6px; }
+  .ttrail { display: block; color: #8e8e93; font-size: 12.5px; margin-top: 8px; }
   #bar { padding: 10px 16px 18px; position: relative; }
   #row-input { display: flex; align-items: center; gap: 8px; }
   #plusMenu { position: absolute; bottom: 62px; left: 16px; background: #1c1c1e; border-radius: 14px;
@@ -2904,6 +3076,7 @@ const APP_HTML = `<!doctype html>
     : '';
   let activeId = null;
   let knownThreads = [];
+  let workspacePort = 0;
 
   function initials(name) { return name.slice(0, 2).toUpperCase(); }
 
@@ -2937,6 +3110,7 @@ const APP_HTML = `<!doctype html>
     // seeing WHY something matched, not just that it did.
     const hitById = searchHits ? new Map(searchHits.map((h) => [h.id, h])) : null;
     knownThreads = list;
+    if (list[0] && list[0].workspacePort) workspacePort = Number(list[0].workspacePort) || workspacePort;
     if (!activeId && list.length) activeId = list[0].id;
     threadsEl.innerHTML = '';
     const shown = hitById
@@ -2983,7 +3157,7 @@ const APP_HTML = `<!doctype html>
         '<div class="tmeta"><div class="tname">' + t.name + '</div><div class="tprev">' +
         (hitById && hitById.get(t.id) && hitById.get(t.id).snippet
             ? hitById.get(t.id).snippet
-            : t.awaitingUser ? 'waiting for you' : t.status === 'thinking' ? 'typing…' : (t.preview || '')) + '</div></div>' +
+            : t.awaitingUser ? 'waiting for you' : t.status === 'thinking' ? escapeHtml(t.liveStatus || 'typing…') : (t.preview || '')) + '</div></div>' +
           // awaitingUser WINS over thinking: a thread blocked on an approval is
           // NOT working, and showing a working indicator there is a lie that
           // quietly costs you a subagent nobody knows is stuck.
@@ -3039,7 +3213,9 @@ const APP_HTML = `<!doctype html>
 
   async function loadActiveMessages() {
     if (!activeId) return null;
-    return await (await fetch(API + '/threads/' + activeId)).json();
+    const data = await (await fetch(API + '/threads/' + activeId)).json();
+    if (data && data.workspacePort) workspacePort = Number(data.workspacePort) || workspacePort;
+    return data;
   }
 
   function renderHeader(t) {
@@ -3126,7 +3302,7 @@ const APP_HTML = `<!doctype html>
       w = r.ok ? await r.json() : null;
     } catch (e) { w = null; }
     walletBody.innerHTML = '';
-    if (!w || (!w.solana && !w.evm)) {
+    if (!w || (!w.solana && !w.evm && w.creditUsd == null)) {
       const p = document.createElement('div');
       p.className = 'wnote wempty';
       p.textContent = 'Could not reach the local openzoo proxy on :8402. It may still be starting — try again in a few seconds.';
@@ -3144,7 +3320,17 @@ const APP_HTML = `<!doctype html>
     }
     if (w.solana) walletBody.appendChild(walletRow('Solana', w.solana));
     if (w.evm) walletBody.appendChild(walletRow('Base / RH', w.evm));
-    if (w.balances) {
+    if (Array.isArray(w.holdings) && w.holdings.length) {
+      const b = document.createElement('div');
+      b.className = 'wbal';
+      b.textContent = w.holdings.filter((h) => h.chain === 'solana' || Number(h.ui) > 0).map((h) => {
+        const qty = (h.ui) + ' ' + h.symbol + (h.chain && h.chain !== 'solana' ? ' (' + h.chain + ')' : '');
+        if (h.usd == null || !isFinite(Number(h.usd))) return qty;
+        const n = Number(h.usd);
+        return qty + '  ($' + (n >= 0.01 || n === 0 ? n.toFixed(2) : n.toFixed(4)) + ')';
+      }).join('\\n');
+      walletBody.appendChild(b);
+    } else if (w.balances) {
       const b = document.createElement('div');
       b.className = 'wbal';
       b.textContent = w.balances;
@@ -3217,6 +3403,114 @@ const APP_HTML = `<!doctype html>
   document.getElementById('modeAuto').addEventListener('click', () => setMode('auto'));
 
   function escapeHtml(s) { return s.replace(/[&<>]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;' }[c])); }
+  function clientWorkspaceUrl(rel) {
+    if (!workspacePort || !activeId) return '';
+    rel = String(rel || '').replace(/^\\/+/, '');
+    return 'http://localhost:' + workspacePort + '/' + activeId + '/' + rel;
+  }
+  function relFromDiskPath(p) {
+    p = String(p || '');
+    if (p.indexOf('file://') === 0) p = decodeURIComponent(p.slice(7));
+    const t = knownThreads.find(function (x) { return x.id === activeId; });
+    const dir = (t && t.dir) || '';
+    if (dir && (p === dir || p.indexOf(dir + '/') === 0)) {
+      return p.slice(dir.length).replace(/^\\/+/, '');
+    }
+    const marker = '/grokui-workspace/';
+    const i = p.indexOf(marker);
+    if (i >= 0) return p.slice(i + marker.length);
+    const base = p.split('/').pop() || '';
+    return /\\.(html?|HTML?)$/.test(base) ? base : '';
+  }
+  function servedHrefForPath(p) {
+    p = String(p || '');
+    const t = knownThreads.find(function (x) { return x.id === activeId; });
+    const dir = (t && t.dir) || '';
+    if (dir && p === dir) return clientWorkspaceUrl('');
+    if (/\\.(html?|HTML?)$/.test(p) || p.indexOf('grokui-workspace') >= 0 || (dir && p.indexOf(dir) === 0)) {
+      return clientWorkspaceUrl(relFromDiskPath(p));
+    }
+    return '';
+  }
+  // Turn "Wrote foo.html" and /Users/.../foo.html into the live localhost URL
+  // the workspace server already exposes — never a file:// Electron blocks.
+  function linkWorkspacePaths(o) {
+    o = o.replace(/\\b(Wrote|Edited)\\s+([^\\n<]+?)\\s+\\(/g, function (m, verb, file) {
+      const f = file.trim();
+      if (!/\\.(html?|HTML?)$/.test(f)) return m;
+      const url = clientWorkspaceUrl(f);
+      if (!url) return m;
+      return verb + ' <a href="' + url + '" target="_blank" rel="noopener">' + f + '</a> (';
+    });
+    o = o.replace(/\\b(MULTIEDIT)\\s+([^\\s:<]+\\.(?:html?|HTML?))/g, function (m, verb, file) {
+      const url = clientWorkspaceUrl(file);
+      if (!url) return m;
+      return verb + ' <a href="' + url + '" target="_blank" rel="noopener">' + file + '</a>';
+    });
+    o = o.replace(/file:\\/\\/([^\\s<)]+)/g, function (m, raw) {
+      return servedHrefForPath(decodeURIComponent(raw)) || m;
+    });
+    o = o.replace(/(^|[\\s(])((?:\\/Users\\/|\\/home\\/|\\/opt\\/|\\/workspace\\/|\\/tmp\\/|\\/var\\/|~\\/)[^\\s<)]+)/g, function (m, pre, raw) {
+      const punct = /[.,;:]+$/.exec(raw);
+      const p = punct ? raw.slice(0, -punct[0].length) : raw;
+      const href = servedHrefForPath(p);
+      if (!href) return m;
+      return pre + '<a href="' + href + '" target="_blank" rel="noopener">' + p + '</a>' + (punct ? punct[0] : '');
+    });
+    return o;
+  }
+  function htmlPreviewUrl(text) {
+    const s = String(text || '');
+    let m = /https?:\\/\\/localhost:\\d+\\/\\S+\\.(?:html?|HTML?)/.exec(s);
+    if (m) return m[0].replace(/[.,;)]+$/, '');
+    m = /(?:Preview:|Serving at)\\s+(https?:\\/\\/localhost:\\d+\\/\\S+)/.exec(s);
+    if (m) {
+      const u = m[1].replace(/[.,;)]+$/, '');
+      if (/\\.(html?|HTML?)/.test(u) || /\\/[0-9a-fA-F-]{36}\\/?$/.test(u)) return u;
+    }
+    m = /\\b(?:Wrote|Edited|MULTIEDIT)\\s+([^\\n]+?)\\s*(?:\\(|:)/.exec(s);
+    if (m && /\\.(html?|HTML?)$/.test(m[1].trim())) return clientWorkspaceUrl(m[1].trim());
+    m = /(?:\\/Users\\/|\\/home\\/|\\/workspace\\/)\\S+\\.(?:html?|HTML?)/.exec(s);
+    if (m) return servedHrefForPath(m[0].replace(/[.,;)]+$/, '')) || '';
+    return '';
+  }
+  function htmlPreviewKey(text, url) {
+    const bytes = /\\((\\d+)\\s+bytes/.exec(text) || /->\\s+(\\d+)\\s+bytes/.exec(text);
+    return url + '#' + (bytes ? bytes[1] : '0');
+  }
+  let parkedPreviews = {};
+  function parkPreviews() {
+    const parked = {};
+    const nodes = log.querySelectorAll('.html-preview-wrap');
+    for (let i = 0; i < nodes.length; i++) {
+      const el = nodes[i];
+      const k = el.getAttribute('data-preview');
+      if (k) parked[k] = el;
+      el.remove();
+    }
+    return parked;
+  }
+  function previewFrame(url, key) {
+    const existing = parkedPreviews[key];
+    if (existing) { delete parkedPreviews[key]; return existing; }
+    const wrap = document.createElement('div');
+    wrap.className = 'html-preview-wrap';
+    wrap.setAttribute('data-preview', key);
+    const open = document.createElement('a');
+    open.className = 'html-preview-open';
+    open.href = url;
+    open.target = '_blank';
+    open.rel = 'noopener';
+    open.textContent = 'open';
+    const frame = document.createElement('iframe');
+    frame.className = 'html-preview';
+    frame.src = url;
+    frame.setAttribute('sandbox', 'allow-scripts allow-same-origin allow-pointer-lock allow-forms');
+    frame.title = 'preview';
+    wrap.appendChild(open);
+    wrap.appendChild(frame);
+    return wrap;
+  }
   // Inline span-level markdown. Runs AFTER escapeHtml, so every tag below is
   // one we created — model output can never inject its own.
   function mdInline(s) {
@@ -3225,6 +3519,7 @@ const APP_HTML = `<!doctype html>
     o = o.replace(/\\*\\*([^*]+)\\*\\*/g, '<strong>$1</strong>');
     o = o.replace(/(^|[^*])\\*([^*\\n]+)\\*/g, '$1<em>$2</em>');
     o = o.replace(/\\[([^\\]]+)\\]\\((https?:[^)\\s]+)\\)/g, '<a href="$2" target="_blank" rel="noopener">$1</a>');
+    o = linkWorkspacePaths(o);
     // bare URLs, but only at a boundary — inside href="..." the preceding
     // char is a quote, so links we just built are left alone
     o = o.replace(/(^|[\\s(])(https?:\\/\\/[^\\s<)]+)/g, '$1<a href="$2" target="_blank" rel="noopener">$2</a>');
@@ -3562,6 +3857,10 @@ const APP_HTML = `<!doctype html>
       }
       const textEl = document.createElement('div');
       textEl.innerHTML = renderMentions(text);
+      if (who === 'bot') {
+        const preview = htmlPreviewUrl(text);
+        if (preview) textEl.appendChild(previewFrame(preview, htmlPreviewKey(text, preview)));
+      }
       bubble.appendChild(textEl);
       row.appendChild(bubble);
       // Copy the message SOURCE, not rendered HTML — markdown, code fences and
@@ -3582,6 +3881,7 @@ const APP_HTML = `<!doctype html>
     log.appendChild(row);
   }
 
+  let lastRenderKey = '';
   async function render() {
     const t = knownThreads.find((x) => x.id === activeId);
     if (!t) return;
@@ -3589,9 +3889,18 @@ const APP_HTML = `<!doctype html>
     inp.placeholder = 'Message ' + t.name;
     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('||');
+    if (renderKey === lastRenderKey) {
+      if (streamBuf) paintStream();
+      return;
+    }
+    lastRenderKey = renderKey;
     // only re-pin to bottom if the reader was already there — otherwise a
     // background poll (tick() runs every 1.2s) yanks them back mid-scroll
     const wasNearBottom = log.scrollHeight - log.scrollTop - log.clientHeight < 80;
+    parkedPreviews = parkPreviews();
     log.innerHTML = '';
     lastSpeaker = null;
     for (const h of full.history) {
@@ -3599,11 +3908,12 @@ const APP_HTML = `<!doctype html>
         h.runId ? { id: h.runId, status: h.runStatus, output: h.runOutput } : undefined, h.images);
     }
     if (full.status === 'thinking') {
+      if (full.liveStatus) streamStatus = full.liveStatus;
       addRow('bot', streamBuf || '…', t.color, t.name);
       // 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';
+      if (b) { b.id = 'streamBubble'; paintStream(); }
     }
     if (wasNearBottom) log.scrollTop = log.scrollHeight;
   }
@@ -3612,13 +3922,28 @@ const APP_HTML = `<!doctype html>
   // 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 streamStatus = '';
   let es = null, esId = null;
+  function liveBubbleHtml() {
+    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(streamBuf) + trail;
+    }
+    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 : '');
+  }
   function paintStream() {
     const b = document.getElementById('streamBubble');
     if (!b) { render(); return; }
-    // textContent, not markdown: the partial text is frequently mid-fence or
-    // mid-link, and half-parsed markdown flickers. The final render formats it.
-    b.textContent = streamBuf || '…';
+    // 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;
+    } else {
+      b.innerHTML = liveBubbleHtml();
+    }
     if (log.scrollHeight - log.scrollTop - log.clientHeight < 140) log.scrollTop = log.scrollHeight;
   }
   function connectStream(id) {
@@ -3626,13 +3951,15 @@ const APP_HTML = `<!doctype html>
     if (es) es.close();
     esId = id;
     streamBuf = '';
+    streamStatus = '';
     es = new EventSource('/stream/' + id);   // EventSource reconnects on its own
     es.onmessage = (e) => {
       let ev;
       try { ev = JSON.parse(e.data); } catch { return; }
-      if (ev.type === 'start') { streamBuf = ''; paintStream(); }
+      if (ev.type === 'start') { streamBuf = ''; streamStatus = ev.detail || 'waiting on model…'; paintStream(); }
+      else if (ev.type === 'status') { streamStatus = ev.detail || streamStatus; paintStream(); }
       else if (ev.type === 'delta') { streamBuf += ev.delta || ''; paintStream(); }
-      else if (ev.type === 'final' || ev.type === 'run-pending') { streamBuf = ''; render(); }
+      else if (ev.type === 'final' || ev.type === 'run-pending') { streamBuf = ''; streamStatus = ''; render(); }
     };
     es.onerror = () => { /* EventSource retries; the 1.2s poll is the backstop */ };
   }
@@ -4020,7 +4347,6 @@ const server = http.createServer((req, res) => {
       try { w = await (await fetch(`${PROXY}/wallet`)).json(); }
       catch { /* proxy not up yet — say so rather than render an empty modal */ }
       try {
-        const { creditBalance } = await import('./info.js');
         w.creditUsd = await creditBalance();
       } catch { /* leave credit off if the gateway is down */ }
       res.writeHead(200, { 'content-type': 'application/json' });
@@ -4078,11 +4404,10 @@ 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 };
+      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')).json()) }; }
       catch { /* local proxy not running — HUD shows zeros rather than guessing */ }
       try {
-        const { creditBalance } = await import('./info.js');
         you.creditUsd = await creditBalance();
       } catch { /* credit is advisory */ }
       res.writeHead(200, { 'content-type': 'application/json' });
@@ -4165,7 +4490,11 @@ const server = http.createServer((req, res) => {
   if (req.method === 'GET' && req.url.startsWith('/threads/')) {
     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 }) : '{}');
+    res.end(t ? JSON.stringify({
+      id: t.id, history: t.history, status: t.status,
+      liveStatus: t.liveStatus || '',
+      workspacePort: workspacePort || 0, dir: t.dir || WORKSPACE_DIR,
+    }) : '{}');
     return;
   }
   if (req.method === 'DELETE' && req.url.startsWith('/threads/')) {
@@ -4298,3 +4627,5 @@ const server = http.createServer((req, res) => {
 });
 
 server.listen(PORT, BIND, () => console.log(`[grokui] http://${BIND === '0.0.0.0' ? 'localhost' : BIND}:${PORT}`));
+
+export { tryDirective, ensureWorkspacePort, isPreviewableRel, previewAck, workspaceFileUrl };