openzoo 0.48.5 → 0.48.7

package/lib/grokui.mjs

@@ -8,10 +8,10 @@
 import { exec } from 'node:child_process';
 import http from 'node:http';
 import { randomUUID } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+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
@@ -122,6 +122,31 @@ workspace folder, not their real project. Same one-line-no-prose reply format:
                                                        own client. Use this directive; it
                                                        does the initialize handshake, holds
                                                        the session, and calls the tool.
+  LS: <path, or blank for the root>                   list a directory
+  GLOB: <pattern>                                     find files — *.js, **/*.test.ts, src/**
+  GREP: <regex> | <optional path or glob>             search file CONTENTS, with line numbers
+  EDIT: <path> | <exact old text> ||| <new text>      change PART of a file. Prefer this over
+                                                       WRITE for edits — WRITE replaces the
+                                                       whole file, so anything you don't
+                                                       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)
+
+WORK IN PARALLEL. READ, LS, GLOB, GREP, FETCH, PEEK and MCP are read-only, and if you emit
+several of them in ONE reply the harness runs them CONCURRENTLY and returns every result
+together. Four files in one turn costs one round trip; four turns costs four, and you pay per
+call. Ask for everything you know you need at once instead of discovering it one file at a
+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
                                                        pauses and waits for the user to
@@ -473,7 +498,268 @@ 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));
+
+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)
+// fetching them one at a time.
+//
+// Deliberately excludes RUN / WRITE / EDIT / SPAWN / SEND: those mutate, and
+// concurrent mutation of the same tree is a race the model cannot reason
+// about. Reads fan out, writes stay sequential.
+const PARALLEL_DIRECTIVE = /^[ \t>*-]*(READ|LS|GLOB|GREP|FETCH|PEEK|MCP):[ \t]*(.+)$/gm;
+
+// Walk a thread dir once, cheaply, skipping the things nobody means to search.
+const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.next', '__pycache__', '.venv', 'venv']);
+function walkDir(base, rel = '', out = [], depth = 0) {
+  if (depth > 12 || out.length > 5000) return out;
+  let entries = [];
+  try { entries = readdirSync(path.join(base, rel), { withFileTypes: true }); } catch { return out; }
+  for (const e of entries) {
+    const r = rel ? path.join(rel, e.name) : e.name;
+    if (e.isDirectory()) {
+      if (SKIP_DIRS.has(e.name)) continue;
+      walkDir(base, r, out, depth + 1);
+    } else out.push(r);
+  }
+  return out;
+}
+
+// Glob -> RegExp. `**` crosses separators, `*` and `?` do not.
+function globToRe(glob) {
+  let re = '';
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === '*') {
+      if (glob[i + 1] === '*') { re += '.*'; i++; if (glob[i + 1] === '/') i++; }
+      else re += '[^/]*';
+    } else if (c === '?') re += '[^/]';
+    else if ('.+^${}()|[]\\'.includes(c)) re += '\\' + c;
+    else re += c;
+  }
+  return new RegExp('^' + re + '$');
+}
+
 async function tryDirective(reply, originId) {
+  // FAN OUT FIRST. Each line is re-entered on its own, so every branch below
+  // stays single-directive and none of them had to learn about batching.
+  const batch = [...reply.matchAll(PARALLEL_DIRECTIVE)];
+  if (batch.length > 1) {
+    const results = await Promise.all(
+      batch.map((m) => tryDirective(m[0].replace(/^[ \t>*-]*/, ''), originId)
+        .catch((e) => `${m[1]}: ${e.message}`)),
+    );
+    return results.filter(Boolean).join('\n\n');
+  }
+
   const spawn = /^SPAWN:\s*([^|]+)\|\s*([\s\S]+)/.exec(reply);
   if (spawn) {
     const name = spawn[1].trim();
@@ -527,6 +813,155 @@ async function tryDirective(reply, originId) {
       return `${rel}:\n${data.slice(0, 4000)}${data.length > 4000 ? '\n…(truncated)' : ''}`;
     } catch (e) { return `Couldn't read ${rel}: ${e.message}`; }
   }
+  // EDIT beats WRITE for changing part of a file: WRITE overwrites the whole
+  // thing, so a model that wants a one-line change has to reproduce the entire
+  // file from memory and silently drops whatever it forgot.
+  const edit = /^EDIT:\s*([^|]+)\|([\s\S]*?)\|\|\|([\s\S]*)$/.exec(reply);
+  if (edit) {
+    const rel = edit[1].trim();
+    const oldStr = edit[2].replace(/^\n/, '').replace(/\n$/, '');
+    const newStr = edit[3].replace(/^\n/, '').replace(/\n$/, '');
+    try {
+      const full = safeResolveIn(dirFor(originId), rel);
+      const before = readFileSync(full, 'utf8');
+      const hits = before.split(oldStr).length - 1;
+      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).`;
+    } 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() || '.';
+    try {
+      const full = safeResolveIn(dirFor(originId), rel);
+      const entries = readdirSync(full, { withFileTypes: true });
+      if (!entries.length) return `${rel}: (empty)`;
+      const lines = entries.slice(0, 300).map((e) => {
+        if (e.isDirectory()) return `  ${e.name}/`;
+        let size = '';
+        try { size = ` (${statSync(path.join(full, e.name)).size}b)`; } catch { /* raced */ }
+        return `  ${e.name}${size}`;
+      });
+      return `${rel}:\n${lines.join('\n')}${entries.length > 300 ? `\n  …${entries.length - 300} more` : ''}`;
+    } catch (e) { return `Couldn't list ${rel}: ${e.message}`; }
+  }
+
+  const glob = /^GLOB:\s*(.+)$/.exec(reply);
+  if (glob) {
+    const pattern = glob[1].trim();
+    try {
+      const base = dirFor(originId);
+      const re = globToRe(pattern.startsWith('./') ? pattern.slice(2) : pattern);
+      const hits = walkDir(base).filter((f) => re.test(f) || re.test(path.basename(f)));
+      if (!hits.length) return `GLOB ${pattern}: no matches`;
+      return `GLOB ${pattern} — ${hits.length} match(es):\n${hits.slice(0, 200).map((h) => '  ' + h).join('\n')}`
+        + (hits.length > 200 ? `\n  …${hits.length - 200} more` : '');
+    } catch (e) { return `GLOB ${pattern}: ${e.message}`; }
+  }
+
+  const grep = /^GREP:\s*([^|]+?)(?:\s*\|\s*(.+))?$/.exec(reply);
+  if (grep) {
+    const pattern = grep[1].trim();
+    const scope = (grep[2] || '').trim();
+    try {
+      const base = dirFor(originId);
+      let re;
+      try { re = new RegExp(pattern, 'i'); }
+      catch { return `GREP: ${pattern} isn't a valid regex.`; }
+      let files = walkDir(base);
+      if (scope) { const sre = globToRe(scope); files = files.filter((f) => sre.test(f) || f.startsWith(scope)); }
+      const out = [];
+      for (const f of files) {
+        if (out.length > 200) break;
+        let text;
+        try { text = readFileSync(path.join(base, f), 'utf8'); } catch { continue; }
+        if (text.indexOf(String.fromCharCode(0)) !== -1) continue; // binary — NUL, not whitespace
+        text.split('\n').forEach((line, i) => {
+          if (out.length <= 200 && re.test(line)) out.push(`  ${f}:${i + 1}: ${line.trim().slice(0, 200)}`);
+        });
+      }
+      if (!out.length) return `GREP ${pattern}: no matches`;
+      return `GREP ${pattern} — ${out.length} hit(s):\n${out.join('\n')}`;
+    } catch (e) { return `GREP: ${e.message}`; }
+  }
+
+  // A real, persisted checklist. Bots were already narrating plans; this makes
+  // the plan a thing the user can see and the model can be held to.
+  const todo = /^TODO:\s*([\s\S]*)$/.exec(reply);
+  if (todo) {
+    const t = threads.get(originId);
+    if (!t) return 'TODO: no such thread.';
+    t.todos = t.todos || [];
+    const body = todo[1].trim();
+    if (!body || /^(list|show)$/i.test(body)) {
+      if (!t.todos.length) return 'TODO: (empty)';
+      return 'TODO:\n' + t.todos.map((x, i) => `  ${i + 1}. [${x.done ? 'x' : ' '}] ${x.text}`).join('\n');
+    }
+    const done = /^done\s+(\d+)/i.exec(body);
+    if (done) {
+      const idx = Number(done[1]) - 1;
+      if (!t.todos[idx]) return `TODO: no item ${done[1]}.`;
+      t.todos[idx].done = true;
+      saveThreads();
+      return 'TODO:\n' + t.todos.map((x, i) => `  ${i + 1}. [${x.done ? 'x' : ' '}] ${x.text}`).join('\n');
+    }
+    if (/^clear$/i.test(body)) { t.todos = []; saveThreads(); return 'TODO: cleared.'; }
+    // Otherwise: replace the list with the lines given.
+    t.todos = body.split('\n').map((l) => l.replace(/^[-*\d.)\]\s]+/, '').trim())
+      .filter(Boolean).map((text) => ({ text, done: false }));
+    saveThreads();
+    return 'TODO:\n' + t.todos.map((x, i) => `  ${i + 1}. [ ] ${x.text}`).join('\n');
+  }
+
   const serve = /^SERVE:\s*(.*)$/.exec(reply);
   if (serve) {
     const rel = serve[1].trim();
@@ -732,13 +1167,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}`;
   }
@@ -857,6 +1302,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);
@@ -947,8 +1405,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; }
@@ -1056,7 +1517,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>
@@ -1384,7 +1846,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');
@@ -1579,6 +2094,13 @@ const server = http.createServer((req, res) => {
     })();
     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)));
@@ -1670,11 +2192,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;

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.5",
+  "version": "0.48.7",
   "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",