openzoo 0.48.6 → 0.48.8

package/lib/grokui.mjs

@@ -11,7 +11,7 @@ import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import path from 'node:path';
-import { brain, brainStream, PROXY } from './podagent.mjs';
+import { brain, brainStream, MODEL, PROXY } from './podagent.mjs';
 
 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
@@ -131,6 +131,13 @@ workspace folder, not their real project. Same one-line-no-prose reply format:
                                                        reproduce from memory is destroyed.
                                                        The old text must match byte for byte
                                                        and appear exactly once; READ first.
+  MULTIEDIT: <path> | a ||| b ;; c ||| d              several edits to ONE file, ALL-OR-
+                                                       NOTHING — if any piece doesn't match,
+                                                       the file is left untouched. Prefer this
+                                                       over a run of EDITs, where the third
+                                                       can fail after the first two landed.
+  NOTEBOOK: <path> | <cell index> | <new source>      replace a Jupyter cell (0-indexed);
+                                                       stale outputs are cleared
   TODO: <one item per line>                           set a visible checklist
   TODO: done <n>                                      tick an item   (TODO: alone = show it)
 
@@ -491,6 +498,227 @@ if (!loadThreads()) newThread('openzoo', null);
 // Parses a SPAWN/SEND/PING directive out of a reply, performs its side effect
 // (creating or messaging another thread), and returns the ack text to show in
 // place of the raw directive line — or null if the reply wasn't a directive.
+// ---------------------------------------------------------------------------
+// Slash commands. Local, free, instant — none of these call a model, so
+// checking your spend or clearing a thread costs nothing.
+//
+// Exposed over /slash-commands so the composer can autocomplete them; keeping
+// one list means the menu can never drift from what actually works.
+const SLASH_COMMANDS = [
+  { name: '/help', args: '', help: 'every command and directive' },
+  { name: '/tools', args: '', help: 'the directives bots can emit' },
+  { name: '/cost', args: '', help: 'what this session has actually cost' },
+  { name: '/tokens', args: '', help: 'tokens and calls this session' },
+  { name: '/model', args: '[id]', help: 'show or switch this thread’s model' },
+  { name: '/models', args: '[filter]', help: 'search the ~435 served models' },
+  { name: '/compact', args: '', help: 'summarise history to shrink context' },
+  { name: '/clear', args: '', help: 'wipe this thread’s history' },
+  { name: '/undo', args: '', help: 'drop the last exchange' },
+  { name: '/memory', args: '[text|clear]', help: 'facts injected into every turn' },
+  { name: '/sessions', args: '', help: 'list all threads' },
+  { 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' },
+];
+
+const usd = (n) => (n >= 0.01 || n === 0 ? '$' + n.toFixed(2) : '$' + n.toFixed(5));
+
+// threadId -> open SSE responses. A Set because the same thread can be open in
+// two tabs, and both should see the same tokens.
+const streamListeners = new Map();
+function emitToThread(threadId, ev) {
+  const set = streamListeners.get(threadId);
+  if (!set?.size) return;                       // nobody watching — free
+  const line = `data: ${JSON.stringify(ev)}\n\n`;
+  for (const res of set) {
+    try { res.write(line); } catch { set.delete(res); }
+  }
+}
+
+async function sessionStats() {
+  try { return await (await fetch(`${PROXY}/session`)).json(); }
+  catch { return null; }
+}
+
+function todoBlock(t) {
+  return (t.todos || []).length
+    ? '\n\nTODO:\n' + t.todos.map((x, i) => `  ${i + 1}. [${x.done ? 'x' : ' '}] ${x.text}`).join('\n')
+    : '';
+}
+
+async function handleSlash(task, t) {
+  const m = /^\/(\w+)\s*([\s\S]*)$/.exec(task);
+  if (!m) return null;
+  const cmd = m[1].toLowerCase();
+  const arg = m[2].trim();
+
+  if (cmd === 'help') {
+    return 'Commands:\n'
+      + SLASH_COMMANDS.map((c) => `  ${(c.name + ' ' + c.args).padEnd(26)} ${c.help}`).join('\n')
+      + '\n\nDirectives bots can emit:\n'
+      + '  RUN / WRITE / EDIT / READ / LS / GLOB / GREP / SERVE / FETCH / MCP / TODO / SPAWN / SEND / PING / PEEK\n'
+      + '  (/tools for the full signatures)';
+  }
+  if (cmd === 'tools') {
+    return 'Directives:\n'
+      + '  RUN: <cmd>                          real shell, in this thread’s dir\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'
+      + '  NOTEBOOK: <path> | <cell> | <src>   replace a Jupyter cell\n'
+      + '  READ: <path>                        read a file\n'
+      + '  LS: <path>                          list a directory\n'
+      + '  GLOB: <pattern>                     find files\n'
+      + '  GREP: <regex> | <path>              search contents\n'
+      + '  SERVE: <path>                       real http:// URL for a file\n'
+      + '  FETCH: <url>                        read a page’s text\n'
+      + '  MCP: <url> [| tool | {json}]        list or call MCP tools\n'
+      + '  TODO: <lines>                       visible checklist\n'
+      + '  SPAWN / SEND / PING / PEEK          other bots\n\n'
+      + '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.';
+  }
+  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.)';
+    const spent = Number(s.spentUsd) || 0, cogs = Number(s.cogsUsd) || 0, direct = Number(s.directUsd) || 0;
+    const lines = [
+      `  paid            ${usd(spent)}`,
+      `  our cost        ${usd(cogs)}`,
+      `  without openzoo ${usd(direct)}   (counterfactual, not a bill anyone got)`,
+      `  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' : ''));
+    }
+    return 'This session:\n' + lines.join('\n');
+  }
+  if (cmd === 'model') {
+    if (!arg) return `This thread: ${t.model || MODEL}${t.model ? '' : '  (default)'}\nSwitch with  /model <id>   ·  /models to search.`;
+    if (/^(default|reset)$/i.test(arg)) { delete t.model; saveThreads(); return `Back to the default, ${MODEL}.`; }
+    t.model = arg;
+    saveThreads();
+    return `This thread now uses ${arg}.\nNote: while images are in play the vision model still wins, or the call would just fail.`;
+  }
+  if (cmd === 'models') {
+    try {
+      const list = await (await fetch(`${PROXY}/models`)).json();
+      let ids = (list.data || []).map((x) => x.id);
+      if (arg) ids = ids.filter((i) => i.toLowerCase().includes(arg.toLowerCase()));
+      if (!ids.length) return `No model ids match "${arg}".`;
+      return `${ids.length} model(s)${arg ? ` matching "${arg}"` : ''}:\n`
+        + ids.slice(0, 60).map((i) => '  ' + i).join('\n')
+        + (ids.length > 60 ? `\n  …${ids.length - 60} more — narrow it with /models <text>` : '');
+    } catch (e) { return `Couldn’t reach the proxy: ${e.message}`; }
+  }
+  if (cmd === 'clear') {
+    const sys = t.messages?.[0]?.role === 'system' ? [t.messages[0]] : [];
+    t.messages = sys;
+    t.history = [];
+    delete t.contextId;
+    delete t.boundHistoryCount;
+    saveThreads();
+    return 'Cleared. (The system prompt stays; the bound context is dropped so the next turn re-binds.)';
+  }
+  if (cmd === 'undo') {
+    if (!t.history.length) return 'Nothing to undo.';
+    // Drop back through the bot turns to the user message that caused them.
+    while (t.history.length && t.history[t.history.length - 1].who !== 'user') t.history.pop();
+    t.history.pop();
+    if (t.messages) {
+      while (t.messages.length > 1 && t.messages[t.messages.length - 1].role !== 'user') t.messages.pop();
+      if (t.messages.length > 1) t.messages.pop();
+    }
+    saveThreads();
+    return 'Undone.';
+  }
+  if (cmd === 'compact') {
+    if (!t.messages || t.messages.length < 4) return 'Not enough history to be worth compacting.';
+    const before = t.messages.length;
+    const transcript = t.messages.slice(1)
+      .map((x) => `${x.role}: ${typeof x.content === 'string' ? x.content : '[parts]'}`).join('\n')
+      .slice(-60000);
+    const sum = await brain([
+      { role: 'system', content: 'Summarise this conversation so it can be CONTINUED from the summary alone. Keep decisions, file paths, commands that worked, open problems and anything the user asked for and has not received. Drop pleasantries. No preamble.' },
+      { role: 'user', content: transcript },
+    ], undefined, t.model).catch((e) => `(compact failed: ${e.message})`);
+    if (/^\(compact failed/.test(sum)) return sum;
+    t.messages = [t.messages[0], { role: 'user', content: `[summary of the conversation so far]\n${sum}` }];
+    delete t.contextId;
+    delete t.boundHistoryCount;
+    saveThreads();
+    return `Compacted ${before} messages into a summary.\n\n${sum.slice(0, 1200)}${sum.length > 1200 ? '\n…' : ''}`;
+  }
+  if (cmd === 'memory') {
+    t.memory = t.memory || [];
+    if (!arg) return t.memory.length ? 'Memory:\n' + t.memory.map((x, i) => `  ${i + 1}. ${x}`).join('\n') : 'Memory is empty. Add with  /memory <fact>';
+    if (/^clear$/i.test(arg)) { t.memory = []; saveThreads(); return 'Memory cleared.'; }
+    const del = /^(?:del|rm)\s+(\d+)$/i.exec(arg);
+    if (del) {
+      const i = Number(del[1]) - 1;
+      if (!t.memory[i]) return `No memory item ${del[1]}.`;
+      t.memory.splice(i, 1); saveThreads();
+      return 'Memory:\n' + (t.memory.map((x, n) => `  ${n + 1}. ${x}`).join('\n') || '  (empty)');
+    }
+    t.memory.push(arg);
+    saveThreads();
+    return `Remembered. This is injected into every turn of this thread.\n  ${t.memory.length}. ${arg}`;
+  }
+  if (cmd === 'sessions') {
+    const all = [...threads.values()].sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+    if (!all.length) return 'No threads.';
+    return `${all.length} thread(s):\n` + all.slice(0, 40).map((x) => {
+      const age = Math.round((Date.now() - x.lastActivityAt) / 60000);
+      return `  ${x.name}${x.id === t.id ? ' ← here' : ''}  · ${x.status} · ${x.history.length} msgs · ${age}m ago`;
+    }).join('\n');
+  }
+  if (cmd === 'cron' || cmd === 'crons') {
+    t.crons = t.crons || [];
+    const show = () => (t.crons.length
+      ? 'Timers:\n' + t.crons.map((c) => `  ${c.id}  every ${c.everyMin}m  →  ${c.text.slice(0, 60)}`).join('\n')
+      : 'No timers. Add one with  /cron <minutes> | <message>');
+    if (cmd === 'crons' || !arg || /^(list|show)$/i.test(arg)) return show();
+    const del = /^(?:del|rm)\s+(\S+)$/i.exec(arg);
+    if (del) {
+      const before = t.crons.length;
+      t.crons = t.crons.filter((c) => c.id !== del[1]);
+      saveThreads();
+      return t.crons.length === before ? `No timer ${del[1]}.` : `Removed ${del[1]}.\n${show()}`;
+    }
+    const mk = /^(\d+)\s*m?\s*\|\s*([\s\S]+)$/.exec(arg);
+    if (!mk) return 'Usage:  /cron <minutes> | <message>   ·   /cron del <id>';
+    const everyMin = Math.max(1, Number(mk[1]));
+    const c = { id: randomUUID().slice(0, 6), everyMin, text: mk[2].trim(), nextAt: Date.now() + everyMin * 60000 };
+    t.crons.push(c);
+    saveThreads();
+    return `Timer ${c.id} set: every ${everyMin}m I'll send this thread “${c.text.slice(0, 60)}”.\nThis is REAL — it fires whether or not anyone is watching, and each firing costs a model call.`;
+  }
+  return null; // not one of ours — /dir and /mode fall through to their handlers
+}
+
+// One ticker for every thread's timers, rather than a timer per cron: it
+// survives a restart with no re-arming step, because due-ness is derived from
+// persisted nextAt rather than from a live setInterval.
+//
+// This exists because a bot once told the user it had scheduled "a recurring
+// nudge every 2 minutes" — a capability that did not exist anywhere in the
+// product. Now it does, and the claim can be true.
+setInterval(() => {
+  const now = Date.now();
+  for (const t of threads.values()) {
+    if (!t.crons?.length) continue;
+    for (const c of t.crons) {
+      if (c.nextAt > now) continue;
+      c.nextAt = now + c.everyMin * 60000;
+      saveThreads();
+      runTurn(t.id, c.text).catch(() => {});
+    }
+  }
+}, 15000).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)
@@ -616,6 +844,52 @@ async function tryDirective(reply, originId) {
     } catch (e) { return `Couldn't edit ${rel}: ${e.message}`; }
   }
 
+  // Several edits to ONE file, applied all-or-nothing. Sequential EDITs are a
+  // trap: the third can fail after the first two already landed, leaving the
+  // file in a state neither the model nor the user expected.
+  const multi = /^MULTIEDIT:\s*([^|]+)\|([\s\S]+)$/.exec(reply);
+  if (multi) {
+    const rel = multi[1].trim();
+    const pairs = multi[2].split(';;').map((p) => p.split('|||')).filter((p) => p.length === 2);
+    if (!pairs.length) return 'MULTIEDIT: expected  <path> | old ||| new ;; old2 ||| new2';
+    try {
+      const full = safeResolveIn(dirFor(originId), rel);
+      const before = readFileSync(full, 'utf8');
+      let next = before;
+      const applied = [];
+      for (const [oldRaw, newRaw] of pairs) {
+        const o = oldRaw.trim(), n = newRaw.trim();
+        const hits = next.split(o).length - 1;
+        if (hits === 0) return `MULTIEDIT ${rel}: edit ${applied.length + 1} — text not found, NOTHING was written:\n  ${o.slice(0, 120)}`;
+        if (hits > 1) return `MULTIEDIT ${rel}: edit ${applied.length + 1} matches ${hits} times, NOTHING was written — add context.`;
+        next = next.replace(o, n);
+        applied.push(o.slice(0, 40));
+      }
+      writeFileSync(full, next);
+      return `MULTIEDIT ${rel}: ${applied.length} edit(s) applied (${before.length} -> ${next.length} bytes).`;
+    } catch (e) { return `Couldn't multiedit ${rel}: ${e.message}`; }
+  }
+
+  // Jupyter: replace one cell's source by index, keeping the notebook valid.
+  const nb = /^NOTEBOOK:\s*([^|]+)\|\s*(\d+)\s*\|([\s\S]+)$/.exec(reply);
+  if (nb) {
+    const rel = nb[1].trim();
+    const idx = Number(nb[2]);
+    const src = nb[3].replace(/^\n/, '');
+    try {
+      const full = safeResolveIn(dirFor(originId), rel);
+      const doc = JSON.parse(readFileSync(full, 'utf8'));
+      if (!Array.isArray(doc.cells)) return `NOTEBOOK ${rel}: no cells array — is this really a .ipynb?`;
+      if (!doc.cells[idx]) return `NOTEBOOK ${rel}: no cell ${idx} (it has ${doc.cells.length}, 0-indexed).`;
+      // nbformat stores source as a LIST OF LINES WITH the newlines kept.
+      doc.cells[idx].source = src.split('\n').map((l, i, a) => (i === a.length - 1 ? l : l + '\n'));
+      // Stale outputs next to new code are worse than none.
+      if (doc.cells[idx].cell_type === 'code') { doc.cells[idx].outputs = []; doc.cells[idx].execution_count = null; }
+      writeFileSync(full, JSON.stringify(doc, null, 1));
+      return `NOTEBOOK ${rel}: replaced cell ${idx} (${doc.cells[idx].cell_type}); outputs cleared.`;
+    } catch (e) { return `Couldn't edit ${rel}: ${e.message}`; }
+  }
+
   const ls = /^LS:\s*(.*)$/.exec(reply);
   if (ls) {
     const rel = ls[1].trim() || '.';
@@ -905,13 +1179,23 @@ async function runTurn(threadId, userText, onEvent, images) {
   // 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.
-  const callMsgs = t.runMode === 'auto'
-    ? [...t.messages, { role: 'system', content: AUTO_DIRECTIVE }]
-    : t.messages;
+  const extras = [];
+  // /memory is worthless unless it reaches the model. Injected per-turn for
+  // the same reason AUTO_DIRECTIVE is: the system prompt is frozen into the
+  // thread at creation, so anything added there would never reach a thread
+  // that already exists.
+  if (t.memory?.length) {
+    extras.push({ role: 'system', content: `Remember, for this thread:\n${t.memory.map((x) => `- ${x}`).join('\n')}` });
+  }
+  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 });
+  const callMsgs = extras.length ? [...t.messages, ...extras] : t.messages;
   try {
     reply = onEvent
-      ? (await brainStream(callMsgs, (delta) => onEvent({ type: 'delta', name: t.name, color: t.color, delta }), t.contextId)).trim()
-      : (await brain(callMsgs, t.contextId)).trim();
+      ? (await brainStream(callMsgs, (delta) => onEvent({ type: 'delta', name: t.name, color: t.color, delta }), t.contextId, t.model)).trim()
+      : (await brain(callMsgs, t.contextId, t.model)).trim();
   } catch (e) {
     reply = `error: ${e.message}`;
   }
@@ -1030,6 +1314,19 @@ const APP_HTML = `<!doctype html>
   .modebtn.ask.on { background: #b8f240; }
   .modebtn.auto.on { background: #f28c4d; }
   .modebtn:focus-visible { outline: 2px solid #6ab0ff; outline-offset: 2px; }
+  /* Slash autocomplete. Anchored above the composer because the composer sits
+     at the bottom of the viewport — a dropdown BELOW it would render off
+     screen. */
+  #slashMenu { display: none; position: absolute; bottom: calc(100% + 8px); left: 0; right: 0;
+    max-height: 280px; overflow-y: auto; background: rgba(18,18,22,.98); border: 1px solid #2a2a33;
+    border-radius: 12px; padding: 6px; z-index: 40; box-shadow: 0 10px 34px rgba(0,0,0,.55); }
+  #slashMenu.show { display: block; }
+  .scmd { display: flex; align-items: baseline; gap: 10px; padding: 7px 10px; border-radius: 8px;
+    cursor: pointer; font-size: 12.5px; }
+  .scmd:hover, .scmd.sel { background: #24242c; }
+  .scmd b { color: #b8f240; font-weight: 600; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
+  .scmd i { color: #6f7080; font-style: normal; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; }
+  .scmd span { color: #999aa8; margin-left: auto; text-align: right; }
   #hudBtn { margin-left: 10px; }
   #chatHeaderId { display: flex; align-items: center; gap: 10px; }
   #hud { position: fixed; top: 40px; right: 14px; width: 250px; background: rgba(14,14,17,.94);
@@ -1120,8 +1417,11 @@ const APP_HTML = `<!doctype html>
   .pop-item:hover { background: #2c2c2e; }
   .pop-item svg { width: 18px; height: 18px; flex: 0 0 18px; }
   .pop-item.record svg { color: #ff3b30; }
+  /* position: relative anchors #slashMenu, which is absolutely positioned
+     ABOVE the composer (the composer is pinned to the bottom, so a dropdown
+     below it would render off screen). */
   #pill { flex: 1; display: flex; align-items: center; gap: 6px; background: #2c2c2e; border-radius: 26px;
-          padding: 8px 10px 8px 14px; }
+          padding: 8px 10px 8px 14px; position: relative; }
   .icon-btn { width: 32px; height: 32px; border-radius: 50%; border: none; background: transparent;
               color: #ececec; display: flex; align-items: center; justify-content: center; cursor: pointer;
               flex: 0 0 32px; }
@@ -1229,7 +1529,8 @@ const APP_HTML = `<!doctype html>
           <button class="icon-btn" id="plusBtn">
             <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
           </button>
-          <input id="inp" placeholder="Message" autofocus>
+          <div id="slashMenu" data-component="slash-autocomplete"></div>
+          <input id="inp" placeholder="Message" autofocus autocomplete="off">
           <button class="icon-btn" tabindex="-1">
             <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 2a3 3 0 0 0-3 3v6a3 3 0 0 0 6 0V5a3 3 0 0 0-3-3z"/><path d="M19 10v1a7 7 0 0 1-14 0v-1"/><line x1="12" y1="18" x2="12" y2="22"/></svg>
           </button>
@@ -1476,10 +1777,45 @@ const APP_HTML = `<!doctype html>
       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 (full.status === 'thinking') addRow('bot', '…', t.color, t.name);
+    if (full.status === 'thinking') {
+      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 (wasNearBottom) log.scrollTop = log.scrollHeight;
   }
 
+  // --- 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 es = null, esId = null;
+  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 || '…';
+    if (log.scrollHeight - log.scrollTop - log.clientHeight < 140) log.scrollTop = log.scrollHeight;
+  }
+  function connectStream(id) {
+    if (!id || esId === id) return;
+    if (es) es.close();
+    esId = id;
+    streamBuf = '';
+    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(); }
+      else if (ev.type === 'delta') { streamBuf += ev.delta || ''; paintStream(); }
+      else if (ev.type === 'final' || ev.type === 'run-pending') { streamBuf = ''; render(); }
+    };
+    es.onerror = () => { /* EventSource retries; the 1.2s poll is the backstop */ };
+  }
+
   let pendingFiles = [];
   let pendingImages = [];
   const attachChips = document.getElementById('attachChips');
@@ -1557,7 +1893,60 @@ const APP_HTML = `<!doctype html>
 
   inp.addEventListener('input', () => { send.classList.toggle('show', inp.value.trim().length > 0 || pendingFiles.length > 0 || pendingImages.length > 0); });
   send.addEventListener('click', submit);
-  inp.addEventListener('keydown', (e) => { if (e.key === 'Enter') submit(); });
+  // --- slash autocomplete --------------------------------------------------
+  // The list comes from the SERVER (/slash-commands), so the menu can never
+  // offer something the server doesn't actually handle.
+  const slashMenu = document.getElementById('slashMenu');
+  let slashCmds = [];
+  let slashHits = [];
+  let slashSel = 0;
+  fetch('/slash-commands').then((r) => r.json()).then((c) => { slashCmds = c; }).catch(() => {});
+
+  function slashOpen() { return slashMenu.classList.contains('show'); }
+  function renderSlash() {
+    const v = inp.value;
+    // Only while typing the command itself: once there's a space, the user is
+    // writing arguments and a menu in the way is just noise.
+    const m = /^\\/(\\w*)$/.exec(v);
+    if (!m || !slashCmds.length) { slashMenu.classList.remove('show'); return; }
+    const q = m[1].toLowerCase();
+    slashHits = slashCmds.filter((c) => c.name.slice(1).toLowerCase().startsWith(q));
+    if (!slashHits.length) { slashMenu.classList.remove('show'); return; }
+    if (slashSel >= slashHits.length) slashSel = 0;
+    slashMenu.innerHTML = slashHits.map((c, i) =>
+      '<div class="scmd' + (i === slashSel ? ' sel' : '') + '" data-i="' + i + '">'
+      + '<b>' + escapeHtml(c.name) + '</b><i>' + escapeHtml(c.args) + '</i>'
+      + '<span>' + escapeHtml(c.help) + '</span></div>').join('');
+    slashMenu.classList.add('show');
+  }
+  function slashAccept(i) {
+    const c = slashHits[i];
+    if (!c) return;
+    // Commands that take arguments keep the caret going; ones that don't are
+    // ready to send, so don't make the user delete a trailing space.
+    inp.value = c.name + (c.args ? ' ' : '');
+    slashMenu.classList.remove('show');
+    inp.focus();
+    send.classList.add('show');
+  }
+  slashMenu.addEventListener('mousedown', (e) => {
+    const el = e.target.closest('.scmd');
+    if (!el) return;
+    e.preventDefault();          // keep focus in the input
+    slashAccept(Number(el.dataset.i));
+  });
+  inp.addEventListener('input', renderSlash);
+  inp.addEventListener('blur', () => setTimeout(() => slashMenu.classList.remove('show'), 120));
+
+  inp.addEventListener('keydown', (e) => {
+    if (slashOpen()) {
+      if (e.key === 'ArrowDown') { e.preventDefault(); slashSel = (slashSel + 1) % slashHits.length; renderSlash(); return; }
+      if (e.key === 'ArrowUp') { e.preventDefault(); slashSel = (slashSel - 1 + slashHits.length) % slashHits.length; renderSlash(); return; }
+      if (e.key === 'Tab' || e.key === 'Enter') { e.preventDefault(); slashAccept(slashSel); return; }
+      if (e.key === 'Escape') { slashMenu.classList.remove('show'); return; }
+    }
+    if (e.key === 'Enter') submit();
+  });
 
   const plusBtn = document.getElementById('plusBtn');
   const plusMenu = document.getElementById('plusMenu');
@@ -1669,7 +2058,7 @@ const APP_HTML = `<!doctype html>
     }
   });
 
-  async function tick() { await loadThreads(); await render(); }
+  async function tick() { connectStream(activeId); await loadThreads(); await render(); }
   tick();
   setInterval(tick, 1200);
 
@@ -1752,6 +2141,41 @@ const server = http.createServer((req, res) => {
     })();
     return;
   }
+  // LIVE TOKENS. runTurn has always been able to stream — it takes an onEvent
+  // and calls brainStream — but /drive never passed one, so every turn used
+  // the non-streaming brain() and the UI just polled /threads every 1.2s.
+  // The user watched a "…" bubble for the whole generation and then got the
+  // answer in one lump. Same work, all of the latency, none of the feedback.
+  const sse = /^\/stream\/([^/?]+)$/.exec(req.url || '');
+  if (req.method === 'GET' && sse) {
+    const id = sse[1];
+    res.writeHead(200, {
+      'content-type': 'text/event-stream',
+      'cache-control': 'no-cache',
+      connection: 'keep-alive',
+      // Proxies in front of a box (RunPod, nginx) will happily buffer an
+      // event stream into nothing until it ends, which looks exactly like
+      // streaming being broken.
+      'x-accel-buffering': 'no',
+    });
+    res.write(': open\n\n');
+    if (!streamListeners.has(id)) streamListeners.set(id, new Set());
+    streamListeners.get(id).add(res);
+    const ka = setInterval(() => { try { res.write(': ka\n\n'); } catch { /* gone */ } }, 20000);
+    req.on('close', () => {
+      clearInterval(ka);
+      streamListeners.get(id)?.delete(res);
+      if (!streamListeners.get(id)?.size) streamListeners.delete(id);
+    });
+    return;
+  }
+  // One source of truth for the composer's autocomplete — a hand-kept menu in
+  // the client would drift from what the server actually handles.
+  if (req.method === 'GET' && req.url === '/slash-commands') {
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify(SLASH_COMMANDS));
+    return;
+  }
   if (req.method === 'GET' && req.url === '/threads') {
     res.writeHead(200, { 'content-type': 'application/json' });
     res.end(JSON.stringify([...threads.values()].sort((a, b) => b.lastActivityAt - a.lastActivityAt).map(threadSummary)));
@@ -1843,11 +2267,23 @@ const server = http.createServer((req, res) => {
       } catch { /* ignore */ }
       res.writeHead(200, { 'content-type': 'application/json' });
       res.end(JSON.stringify({ ok: true }));
+      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())) {
+        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;
+        }
+      }
       // "/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());
-      const t = threads.get(threadId);
       if (dirCmd && t) {
         const full = path.resolve(expandHome(dirCmd[1].trim()));
         let ok = false;
@@ -1870,7 +2306,9 @@ const server = http.createServer((req, res) => {
         saveThreads();
         return;
       }
-      runTurn(threadId, task, undefined, images).catch(() => {});
+      // 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(() => {});
     });
     return;
   }

package/lib/podagent.mjs

@@ -280,13 +280,18 @@ function withModelId(messages, model) {
     : m));
 }
 
-export async function brain(messages, contextId) {
+export async function brain(messages, contextId, modelOverride) {
   // explicit plugins, not relying on the gateway's "inject when caller said
   // nothing" default — an explicit array is always respected as-is, so every
   // bot on every model actually has web search. max_tokens 900 was cutting
   // real (especially web-search-backed) answers off mid-sentence.
+  //
+  // modelOverride is what "/model <id>" sets per thread. VISION still wins
+  // when the conversation actually contains images: a text-only model handed
+  // image parts just errors, so silently honouring the override there would
+  // turn a working thread into a broken one.
   const vision = hasImages(messages);
-  const model = vision ? VISION_MODEL : MODEL;
+  const model = vision ? VISION_MODEL : (modelOverride || MODEL);
   messages = vision ? messages : stripImages(messages);
   const r = await postChat(
     { model, max_tokens: 4096, messages: withModelId(messages, model), plugins: [{ id: 'web' }] },
@@ -300,9 +305,9 @@ export async function brain(messages, contextId) {
 /** Same call, but streamed — invokes onDelta(text) as tokens arrive (for a
  *  live-typing UI) and resolves with the full accumulated text at the end, so
  *  callers that need to parse a directive out of the complete reply still can. */
-export async function brainStream(messages, onDelta, contextId) {
+export async function brainStream(messages, onDelta, contextId, modelOverride) {
   const vision = hasImages(messages);
-  const model = vision ? VISION_MODEL : MODEL;
+  const model = vision ? VISION_MODEL : (modelOverride || MODEL);
   messages = vision ? messages : stripImages(messages);
   const r = await postChat(
     { model, max_tokens: 4096, messages: withModelId(messages, model), plugins: [{ id: 'web' }], stream: true },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.48.6",
+  "version": "0.48.8",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun — point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",