openzoo 0.48.18 → 0.48.22

package/lib/grokui.mjs

@@ -5,13 +5,13 @@
 // own independent agent (and that agent can spawn further threads too) —
 // reusing the same SPAWN/SEND pattern podagent.mjs built for shell delegation,
 // adapted here for plain chat.
-import { exec } from 'node:child_process';
+import { exec, execFile } from 'node:child_process';
 import http from 'node:http';
 import { randomUUID } from 'node:crypto';
-import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { cpus, homedir } from 'node:os';
 import path from 'node:path';
-import { brain, brainStream, MODEL, PROXY } from './podagent.mjs';
+import { adaptiveTopK, brain, brainRace, brainStream, tierModels, MODEL, PROXY, TIER_NAMES } 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,68 @@ workspace folder, not their real project. Same one-line-no-prose reply format:
                                                        text — web search only gives you short
                                                        snippets; use FETCH when asked to
                                                        "read" or quote something specific
+
+HOW YOUR SITE ACTUALLY GETS A URL — read this before writing web files.
+
+The working directory is served as a STATIC FILE SERVER at a public URL. It does not run
+a bundler, a dev server, or a build step. Nothing watches your files and compiles them.
+MEASURED failure: a crew wrote tetris-metagame/index.html containing
+  <script type="module" src="/src/main.jsx">
+an unbuilt Vite scaffold. Browsers CANNOT execute JSX, so that page returned 200 and
+rendered a blank screen — for hours, while the crew reported the site as built.
+
+1. BUILD BEFORE YOU CLAIM A SITE EXISTS. For a Vite/React app: install, build, and put the
+   OUTPUT where it is served. Then RUN a command that prints the built index.html and check
+   the script tag points at a real .js file, not a .jsx/.ts/.tsx source.
+2. PREFER PLAIN HTML. One self-contained index.html — inline CSS, vanilla JS — needs no
+   build and works the instant you write it. For most things asked of you that is entirely
+   sufficient, and it gets a live URL now instead of after a toolchain fight.
+3. PUT index.html AT THE WORKSPACE ROOT unless you have a reason not to. The SHALLOWEST
+   index.html is the one the preview shows.
+4. RELATIVE ASSET PATHS: src="assets/app.js", never src="/assets/app.js". The site is
+   served under a path prefix, so a leading slash resolves off the site entirely.
+5. CHECK IT YOURSELF before reporting done —  RUN: curl -s localhost:8080/site/ | head -20
+   and READ the output. A .jsx reference, or <div id="root"></div> with no working script,
+   means it is broken and you are not finished.
+
+Never report a site as finished until you have curled it and seen real markup.
+
+
+SHIP IT IN ONE PASS. This is the single most important instruction here.
+
+You are not a planning assistant. The user wants a WORKING THING at a URL, and they want
+it from the first reply — the way v0 or lovable answers: you describe it, it exists.
+
+So on any "build me X" request:
+
+  WRITE THE WHOLE THING NOW. One self-contained index.html at the workspace root, with
+  inline CSS and vanilla JS, complete enough to open and use. Not a skeleton, not a
+  scaffold, not "here is the structure and I will fill it in" — a real, playable,
+  clickable artifact on the FIRST reply. Ugly and working beats elegant and absent.
+
+  NO BUILD STEP unless the user asked for one. Do not npm init, do not scaffold Vite or
+  React or Next, do not create package.json, do not make a src/ tree. The directory is a
+  static file server: a plain index.html works the instant you write it, and a framework
+  scaffold is a blank page until someone runs a build nobody asked for.
+
+  ITERATE ON THE FILE, NOT ON A PLAN. When something needs changing, EDIT the file and
+  say what changed in one line. Never restate the roadmap, never re-list the features,
+  never ask which part to do first.
+
+  DO NOT SPLIT ONE ARTIFACT ACROSS AGENTS. If it is one page, one game, one dashboard —
+  build it yourself. Spawning a subagent per feature produces five halves of a thing and
+  no thing. Spawn only for work that is genuinely separate and parallel, and only when
+  told to.
+
+  DO NOT WRITE DOCUMENTS INSTEAD OF CODE. SPEC.md, ARCHITECTURE.md, a design doc, a
+  checklist — none of these are what was asked for and none of them render at a URL.
+  Write the artifact. If you truly need to think first, think in the reply, not in a file.
+
+  A STACK IS NEVER YOURS TO PICK. If the brief names one — a chain, an engine, an SDK, a
+  token — use exactly that, even where your training pulls somewhere else. "Smart
+  contract" does not mean Solidity. Anything you were told about the stack outranks
+  anything you assume.
+
   MCP: <url>                                          list the tools an MCP server exposes
   MCP: <url> | <tool> | {"arg": "value"}              CALL one of them, for real
                                                        An MCP endpoint speaks JSON-RPC over
@@ -132,7 +194,12 @@ 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
+  LS: [path]                                          list a directory. The argument is
+                                                       OPTIONAL — a bare  LS:  on its own
+                                                       line lists the working directory.
+                                                       Never write a placeholder like
+                                                       <blank> or <path>; either give a
+                                                       real path or give nothing.
   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
@@ -246,13 +313,23 @@ function newThread(name, parent, members) {
   //
   // dir matters just as much — a child that defaults elsewhere cannot see the
   // files the parent was sent to work on.
+  //
+  // tier/race/raceMode for the same reason, and one more: they are the SPEND
+  // dial. Setting a project to the expensive tier and then having every
+  // subagent it spawns silently drop back to medium means the setting applies
+  // to the one bot you happened to be looking at and nothing that does the
+  // actual work. The opposite is worse — dropping to cheap should not be
+  // quietly undone by a fan-out into four frontier models.
   const p = parent ? threads.get(parent) : null;
   const t = { id, name, color: members ? members[0].color : colorFor(name), parent: parent || null,
     messages: members ? null : [{ role: 'system', content: SYSTEM }],
     members: members || null, history: [], status: 'idle', createdAt: Date.now(), lastActivityAt: Date.now(),
     ...(p?.runMode ? { runMode: p.runMode } : {}),
     ...(p?.dir ? { dir: p.dir } : {}),
-    ...(p?.model ? { model: p.model } : {}) };
+    ...(p?.model ? { model: p.model } : {}),
+    ...(p?.tier ? { tier: p.tier } : {}),
+    ...(p?.race ? { race: p.race } : {}),
+    ...(p?.raceNeed ? { raceNeed: p.raceNeed } : {}) };
   threads.set(id, t);
   saveThreads();
   return t;
@@ -296,6 +373,68 @@ the user sets or changes it with "/dir <path>" in chat. Same format:
   RUN: <shell command>                                run a REAL shell command in this
                                                        group's shared directory — pauses the
                                                        WHOLE round for the user's approval
+
+SHIP IT IN ONE PASS. This is the single most important instruction here.
+
+You are not a planning assistant. The user wants a WORKING THING at a URL, and they want
+it from the first reply — the way v0 or lovable answers: you describe it, it exists.
+
+So on any "build me X" request:
+
+  WRITE THE WHOLE THING NOW. One self-contained index.html at the workspace root, with
+  inline CSS and vanilla JS, complete enough to open and use. Not a skeleton, not a
+  scaffold, not "here is the structure and I will fill it in" — a real, playable,
+  clickable artifact on the FIRST reply. Ugly and working beats elegant and absent.
+
+  NO BUILD STEP unless the user asked for one. Do not npm init, do not scaffold Vite or
+  React or Next, do not create package.json, do not make a src/ tree. The directory is a
+  static file server: a plain index.html works the instant you write it, and a framework
+  scaffold is a blank page until someone runs a build nobody asked for.
+
+  ITERATE ON THE FILE, NOT ON A PLAN. When something needs changing, EDIT the file and
+  say what changed in one line. Never restate the roadmap, never re-list the features,
+  never ask which part to do first.
+
+  DO NOT SPLIT ONE ARTIFACT ACROSS AGENTS. If it is one page, one game, one dashboard —
+  build it yourself. Spawning a subagent per feature produces five halves of a thing and
+  no thing. Spawn only for work that is genuinely separate and parallel, and only when
+  told to.
+
+  DO NOT WRITE DOCUMENTS INSTEAD OF CODE. SPEC.md, ARCHITECTURE.md, a design doc, a
+  checklist — none of these are what was asked for and none of them render at a URL.
+  Write the artifact. If you truly need to think first, think in the reply, not in a file.
+
+  A STACK IS NEVER YOURS TO PICK. If the brief names one — a chain, an engine, an SDK, a
+  token — use exactly that, even where your training pulls somewhere else. "Smart
+  contract" does not mean Solidity. Anything you were told about the stack outranks
+  anything you assume.
+
+
+HOW YOUR SITE ACTUALLY GETS A URL — read this before writing web files.
+
+The working directory is served as a STATIC FILE SERVER at a public URL. It does not run
+a bundler, a dev server, or a build step. Nothing watches your files and compiles them.
+MEASURED failure: a crew wrote tetris-metagame/index.html containing
+  <script type="module" src="/src/main.jsx">
+an unbuilt Vite scaffold. Browsers CANNOT execute JSX, so that page returned 200 and
+rendered a blank screen — for hours, while the crew reported the site as built.
+
+1. BUILD BEFORE YOU CLAIM A SITE EXISTS. For a Vite/React app: install, build, and put the
+   OUTPUT where it is served. Then RUN a command that prints the built index.html and check
+   the script tag points at a real .js file, not a .jsx/.ts/.tsx source.
+2. PREFER PLAIN HTML. One self-contained index.html — inline CSS, vanilla JS — needs no
+   build and works the instant you write it. For most things asked of you that is entirely
+   sufficient, and it gets a live URL now instead of after a toolchain fight.
+3. PUT index.html AT THE WORKSPACE ROOT unless you have a reason not to. The SHALLOWEST
+   index.html is the one the preview shows.
+4. RELATIVE ASSET PATHS: src="assets/app.js", never src="/assets/app.js". The site is
+   served under a path prefix, so a leading slash resolves off the site entirely.
+5. CHECK IT YOURSELF before reporting done —  RUN: curl -s localhost:8080/site/ | head -20
+   and READ the output. A .jsx reference, or <div id="root"></div> with no working script,
+   means it is broken and you are not finished.
+
+Never report a site as finished until you have curled it and seen real markup.
+
                                                        before anything executes ("/mode auto"
                                                        in chat skips that wait). Use this
                                                        instead of guessing or saying you
@@ -418,10 +557,21 @@ async function bindThread(t) {
   const from = t.boundHistoryCount || 0;
   const delta = t.history.slice(from);
   if (!delta.length) return;
-  const corpus = delta.map((h) => (h.who === 'user' ? 'you' : (h.name || t.name)) + ': ' + h.text).join('\n');
+  // Stamp every line with WHICH BOT said it. The context is shared across a
+  // project now, so an unlabelled line is worse than useless — recall would
+  // hand one agent another's words with no way to tell them apart.
+  const corpus = delta.map((h) => '[' + t.name + '] ' + (h.who === 'user' ? 'you' : (h.name || t.name)) + ': ' + h.text).join('\n');
   if (!corpus.trim()) { t.boundHistoryCount = t.history.length; return; }
   try {
-    let ctx = t.contextId;
+    // ONE CONTEXT PER PROJECT, not per thread. Every thread used to bind to
+    // its own private context, so sibling agents spawned for the same job were
+    // memory-isolated: arc-tetris-engine could not recall a thing
+    // arc-token-bets had established, and the user paid to re-explain shared
+    // facts to each one. They are a team; the memory should be too.
+    // The context lives on the ROOT and every descendant binds into it, while
+    // each thread keeps its OWN boundHistoryCount so nothing is re-sent.
+    const root = threads.get(rootOf(t).rootId) || t;
+    let ctx = root.contextId || t.contextId;
     for (let i = 0; i < corpus.length; i += BIND_CHUNK_BYTES) {
       const part = corpus.slice(i, i + BIND_CHUNK_BYTES);
       const body = ctx ? { corpus: part, context_id: ctx } : { corpus: part };
@@ -432,9 +582,15 @@ async function bindThread(t) {
       });
       const j = await r.json().catch(() => ({}));
       if (j?.context_id) ctx = j.context_id;
+      // How many chunks the project's holobrain now holds. This is the number
+      // adaptive top_k scales on — without it we would be guessing, which is
+      // exactly how top_k ended up pinned at 8 in the first place.
+      if (Number(j?.bound)) root.boundItems = (root.boundItems || 0) + Number(j.bound);
       else break; // this chunk failed — stop, keep whatever bound so far rather than lose it all
     }
-    if (ctx) { t.contextId = ctx; t.boundHistoryCount = t.history.length; saveThreads(); }
+    // Write to the ROOT so later siblings inherit it, and to this thread so
+    // the per-call header is readable without walking the tree again.
+    if (ctx) { root.contextId = ctx; t.contextId = ctx; t.boundHistoryCount = t.history.length; saveThreads(); }
   } catch { /* leCore sidecar unreachable — thread still works, just not bound this round */ }
 }
 
@@ -499,13 +655,40 @@ function parseRun(reply) {
   const dsml = new RegExp(`<${SEP}DSML[^>]*\\bparameter\\b[^>]*\\bname="${NAME}"[^>]*>([\\s\\S]*?)<\\/${SEP}DSML`, 'i').exec(reply);
   if (dsml) return sanitizeRunCommand(dsml[1]);
 
-  const m = /^[ \t>*-]*RUN:[ \t]*([\s\S]+)/m.exec(reply);
-  if (!m) return null;
-  let cmd = m[1];
-  const fenced = /^```[\w-]*\n([\s\S]*?)```/.exec(cmd.trim());
-  if (fenced) cmd = fenced[1];
-  else cmd = cmd.replace(/\n```[\s\S]*$/, ''); // trailing fence + any posttext
-  return sanitizeRunCommand(cmd);
+  // SEVERAL "RUN:" LINES IN ONE REPLY RUN BACK TO BACK.
+  //
+  // This capture is `[\s\S]+` on purpose — a command can legitimately span
+  // lines (heredocs, trailing backslashes, fenced blocks). But it is GREEDY,
+  // so when a model emitted three RUN: lines the FIRST match swallowed the
+  // other two and handed bash:
+  //     cd .oz-parts && cat ... > ../full.zip
+  //     RUN: cd .oz-parts && ls -lh full.zip
+  //     RUN: cd .oz-parts && unzip -q full.zip
+  // which is exactly the MEASURED failure:
+  //     /bin/bash: line 3: RUN:: command not found   (lines 3, 5, 7 — exit 127)
+  // The first command ran, the rest died as literal text, and the model then
+  // concluded the RUN: prefix itself was the problem and started emitting bare
+  // commands — which do nothing at all. One greedy quantifier, and the agent
+  // reasons its way out of using the only tool it has.
+  //
+  // Split on the RUN: lines and join with newlines: sequential, one shell, in
+  // order. NOT `&&` — that stops the batch at the first non-zero exit, and a
+  // model batching three steps means "do these three", not "abort quietly if
+  // the first one greps nothing".
+  const heads = [...reply.matchAll(/^[ \t>*-]*RUN:[ \t]*/gm)];
+  if (!heads.length) return null;
+  const cmds = [];
+  for (let i = 0; i < heads.length; i++) {
+    const from = heads[i].index + heads[i][0].length;
+    const to = i + 1 < heads.length ? heads[i + 1].index : reply.length;
+    let cmd = reply.slice(from, to);
+    const fenced = /^```[\w-]*\n([\s\S]*?)```/.exec(cmd.trim());
+    if (fenced) cmd = fenced[1];
+    else cmd = cmd.replace(/\n```[\s\S]*$/, ''); // trailing fence + any posttext
+    cmd = sanitizeRunCommand(cmd);
+    if (cmd) cmds.push(cmd);
+  }
+  return cmds.length ? cmds.join('\n') : null;
 }
 
 // RUN through BASH, not /bin/sh. node's exec() defaults to /bin/sh, which on
@@ -556,11 +739,15 @@ const SLASH_COMMANDS = [
   { 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: '/tier', args: 'cheap|medium|expensive', help: 'how much to spend per turn when no model is pinned' },
+  { name: '/race', args: '<n> | <k> <n>', help: 'launch n models; judge the first k back (k=1 = fastest wins)' },
   { 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: '/all', args: '<message>', help: 'send a message to every bot in this project' },
+  { name: '/ping', args: '', help: 'status of every bot in this project' },
   { 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' },
@@ -698,6 +885,70 @@ async function handleSlash(task, t) {
     saveThreads();
     return `This thread now uses ${arg}.\nNote: while images are in play the vision model still wins, or the call would just fail.`;
   }
+  // /tier — the spend dial for "auto". A pinned /model outranks it, because a
+  // tier silently overriding an explicit id would make /model a suggestion.
+  if (cmd === 'tier') {
+    if (!arg) {
+      const picks = await tierModels(t.tier || 'medium', 3);
+      return `This thread: ${t.tier || 'medium'}${t.tier ? '' : '  (default)'}\n`
+        + `Tiers: ${TIER_NAMES.join(' · ')}\n`
+        + `Top of ${t.tier || 'medium'} right now: ${picks.join(', ')}\n`
+        + (t.model ? `NOTE: /model ${t.model} is pinned on this thread, so the tier is ignored until you /model default.\n` : '')
+        + 'Switch with  /tier <name>   ·  /race <n> to ask several at once.';
+    }
+    const want = arg.trim().toLowerCase();
+    if (!TIER_NAMES.includes(want)) return `Unknown tier "${arg}". One of: ${TIER_NAMES.join(', ')}.`;
+    t.tier = want; saveThreads();
+    const picks = await tierModels(want, 3);
+    return `This thread now runs on the ${want} tier — ${picks.join(', ')}…`
+      + (t.model ? `\nBut /model ${t.model} is still pinned and wins. Run /model default to let the tier take over.` : '');
+  }
+
+  // /race — spend more to wait less, and to survive one provider having a bad
+  // minute. Every entrant is PAID FOR; say so plainly, because the cost is not
+  // visible anywhere else until the bill.
+  if (cmd === 'race') {
+    const showNow = () => {
+      const n = Number(t.race) || 0, k = Math.min(Number(t.raceNeed) || 1, n || 1);
+      if (n < 2) return 'not racing';
+      return k > 1 ? `best of the first ${k} back, out of ${n} launched` : `${n} launched, first one back wins`;
+    };
+    if (!arg) {
+      return `This thread: ${showNow()}\n`
+        + 'Set with  /race <n>        launch n (2-4), FIRST real answer wins.\n'
+        + '          /race <k> <n>    launch n, and the moment k of them are back, judge those k\n'
+        + '                           and ship the winner. The stragglers are abandoned mid-flight.\n\n'
+        + '/race 2 3 is the useful one. k=1 optimises latency only — on a hard question it rewards\n'
+        + 'whichever model thought LEAST. k=n buys quality with the slowest entrant\'s latency, so one\n'
+        + 'wedged provider stalls the whole turn. Taking the first k bounds the wait at the k-th\n'
+        + 'fastest and still gives the judge something to compare.\n'
+        + 'Judging is blind (A/B/C/D) and done by a cheap model. Empty replies do not count toward k.\n'
+        + 'You pay for every entrant, including the abandoned ones, so n=4 costs about 4x a turn.';
+    }
+    const nums = arg.trim().split(/[^0-9]+/).filter(Boolean).map(Number);
+    if (!nums.length) return `"${arg}" is not a number. Use /race 0 to turn it off, /race 3, or /race 2 3.`;
+    // One number is n (judge nothing). Two is "k of n" — and accept them in
+    // either order, because "best 2 of 3" and "3, judge 2" are the same wish
+    // and guessing wrong silently changes what the user pays for.
+    let n = nums.length === 1 ? nums[0] : Math.max(nums[0], nums[1]);
+    let k = nums.length === 1 ? 1 : Math.min(nums[0], nums[1]);
+    n = Math.max(0, Math.min(4, Math.round(n)));
+    k = Math.max(1, Math.min(k, n || 1));
+    if (n < 2) { delete t.race; delete t.raceNeed; saveThreads(); return 'Racing off — one model per turn.'; }
+    t.race = n;
+    if (k > 1) t.raceNeed = k; else delete t.raceNeed;
+    saveThreads();
+    const pool = await tierModels(t.tier || 'medium', 99);
+    return (k > 1
+      ? `Launching ${n} models per turn from the ${t.tier || 'medium'} tier (${pool.length} in the pool, drawn at random).\n`
+        + `As soon as ${k} of them are back, a cheap model reads those ${k} blind and picks the best. `
+        + `The other ${n - k} are abandoned.`
+      : `Launching ${n} models per turn from the ${t.tier || 'medium'} tier (${pool.length} in the pool, drawn at random).\n`
+        + 'First real answer wins; the rest are discarded.')
+      + `\nCosts about ${n}x a normal turn — you pay for the abandoned ones too.`
+      + (t.model ? `\nNOTE: /model ${t.model} is pinned, which disables racing. /model default to race.` : '');
+  }
+
   if (cmd === 'models') {
     try {
       const list = await (await fetch(`${PROXY}/models`)).json();
@@ -762,6 +1013,39 @@ async function handleSlash(task, t) {
     saveThreads();
     return `Remembered. This is injected into every turn of this thread.\n  ${t.memory.length}. ${arg}`;
   }
+  // Talk to the WHOLE project at once. PING: * exists for bots, but there was
+  // no way for a person to do it — you had to open each thread and retype the
+  // same message, which is exactly the chore that makes a 12-agent project
+  // unusable.
+  if (cmd === 'all') {
+    if (!arg) {
+      return 'Usage:  /all <message>   — sends it to everyone BELOW you: your subagents, '
+        + 'their subagents, all the way down.\n'
+        + 'It is scoped to your own branch, not the whole project — run it from the top '
+        + 'thread to reach everybody.';
+    }
+    const crew = subtreeOf(t.id);
+    if (!crew.length) return 'You have no subagents to send to.';
+    for (const x of crew) runTurn(x.id, arg).catch(() => {});
+    return `Sent down your branch to ${crew.length} bot(s): ${crew.map((x) => x.name).join(', ')}`;
+  }
+
+  // Read the room without spending anything: who is working, who is blocked on
+  // an approval, what each said last.
+  if (cmd === 'ping') {
+    // Same scoping as /all: your branch, not the whole project.
+    const crew = subtreeOf(t.id, true);
+    if (crew.length < 2) return 'You have no subagents yet.';
+    return crew.map((x) => {
+      const mark = x.id === t.id ? ' (here)' : '';
+      const last = x.history[x.history.length - 1];
+      return x.pendingRun ? `  ${x.name}${mark}: BLOCKED — waiting for your approval`
+        : x.status === 'thinking' ? `  ${x.name}${mark}: working`
+        : last ? `  ${x.name}${mark}: ${String(last.text).replace(/\s+/g, ' ').slice(0, 90)}`
+        : `  ${x.name}${mark}: nothing yet`;
+    }).join('\n');
+  }
+
   if (cmd === 'sessions') {
     const all = [...threads.values()].sort((a, b) => b.lastActivityAt - a.lastActivityAt);
     if (!all.length) return 'No threads.';
@@ -855,7 +1139,302 @@ function globToRe(glob) {
   return new RegExp('^' + re + '$');
 }
 
+/**
+ * Translate a FOREIGN tool-call envelope into our directive lines.
+ *
+ * Models carry other harnesses' call syntax out of training and emit it here
+ * even when the system prompt spells ours out. MEASURED live on a fresh box:
+ *
+ *   [TOOL_CALL]
+ *   {tool => "LS", args => {
+ *     --path ""
+ *   }}
+ *   [/TOOL_CALL]
+ *
+ * Nothing matched, so it rendered as chat text, nothing ran, and the user had
+ * to type "continue?" — three prompts to get one spawn. This is the same class
+ * of bug as the DSML envelope in parseRun and the old /^RUN:/ anchor: a
+ * silently discarded directive reads to the model as a tool that does nothing,
+ * and it narrates work it never did rather than reporting a failure.
+ *
+ * Translating beats correcting: a correction costs another paid turn, this
+ * costs nothing and the model never learns it was wrong — which is fine,
+ * because being right about the envelope was never the job.
+ */
+function translateForeignToolCall(reply) {
+  const src = String(reply);
+  // THREE envelope dialects seen in production, all from models carrying some
+  // other harness's format out of training:
+  //   [TOOL_CALL]{tool => "LS", args => { --path "" }}[/TOOL_CALL]
+  //   <tool_call>RUN<arg_key>command</arg_key><arg_value>ls -la</arg_value></tool_call>
+  //   <DSML|invoke name="RUN">…   (handled separately, inside parseRun)
+  // Each one shipped as chat text and did nothing until it was taught here, so
+  // the shape of the fix is: normalise ANY of them into {tool, args} and share
+  // one mapping. A fourth dialect should be a few lines, not another outage.
+  const out = [];
+  // DELIMITERS DO NOT HAVE TO MATCH. Models MIX the dialects — measured live:
+  //     [TOOL_CALL]
+  //     RUN
+  //     <arg_key>command</arg_key><arg_value>pwd; ls -la</arg_value>
+  //     </tool_call>
+  // opens with the bracket form and closes with the XML one. Matching PAIRS
+  // ([TOOL_CALL]…[/TOOL_CALL] or <tool_call>…</tool_call>) misses that
+  // entirely, so it rendered as chat text and nothing ran. Scan from ANY
+  // opener to the NEXT closer of EITHER kind.
+  const blocks = [...src.matchAll(
+    /(?:\[TOOL_CALL\]|<tool_call>)([\s\S]*?)(?:\[\/TOOL_CALL\]|<\/tool_call>|$)/gi,
+  )].map((m) => ({ body: m[1] }));
+
+  // DEEPSEEK'S NATIVE SPECIAL-TOKEN FORM — a fifth dialect, and the costliest.
+  //     <|tool_call_begin|>functions.WRITE:0<|tool_call_argument_begin|>
+  //     {"path": "/workspace/x/anti-cheat.js", "content": "…"}
+  //     <|tool_call_end|>
+  // MEASURED: a complete anti-cheat implementation, several hundred lines,
+  // rendered as chat text and written nowhere. The name carries a
+  // "functions." prefix and a ":0" call index; the argument is plain JSON, so
+  // this one maps straight onto our directives once the wrapper is peeled.
+  const dsBlocks = [...src.matchAll(
+    /<\|tool_call_begin\|>([\s\S]*?)<\|tool_call_argument_begin\|>([\s\S]*?)(?:<\|tool_call_end\|>|$)/g,
+  )];
+  for (const m of dsBlocks) {
+    const rawName = m[1].trim().replace(/^functions?\./i, '').replace(/[:.]\d+$/, '');
+    let a = {};
+    try { a = JSON.parse(m[2].trim()); } catch { continue; }
+    const t = rawName.toUpperCase();
+    const pick = (...ks) => ks.map((k) => a[k]).find((v) => v !== undefined && v !== '');
+    if (t === 'WRITE' || t === 'WRITE_FILE') out.push('WRITE: ' + (pick('path', 'file') || '') + ' | ' + (pick('content', 'text', 'body') || ''));
+    else if (t === 'RUN' || t === 'BASH' || t === 'SHELL' || t === 'EXEC') out.push('RUN: ' + (pick('command', 'cmd', 'script') || ''));
+    else if (t === 'READ' || t === 'READ_FILE' || t === 'CAT') out.push('READ: ' + (pick('path', 'file') || ''));
+    else if (t === 'LS' || t === 'LIST') out.push('LS: ' + (pick('path', 'dir') || ''));
+    else if (t === 'GLOB' || t === 'FIND') out.push('GLOB: ' + (pick('pattern', 'glob', 'query') || '*'));
+    else if (t === 'FETCH') out.push('FETCH: ' + (pick('url', 'uri') || ''));
+    else if (t === 'SPAWN') out.push('SPAWN: ' + (pick('name', 'agent') || 'helper') + ' | ' + (pick('task', 'prompt', 'goal') || ''));
+    else if (t === 'SEND') out.push('SEND: ' + (pick('name', 'agent', 'to') || '') + ' | ' + (pick('message', 'msg', 'task') || ''));
+    else if (t === 'MCP') {
+      const tool2 = pick('tool', 'name', 'method') || '';
+      const argj = pick('arg', 'args', 'arguments', 'params');
+      out.push('MCP: ' + (pick('url', 'server') || '')
+        + (tool2 ? ' | ' + tool2 + (argj !== undefined ? ' | ' + (typeof argj === 'string' ? argj : JSON.stringify(argj)) : '') : ''));
+    }
+  }
+  for (const b of blocks) {
+    const body = b.body;
+    // The name is either quoted ({tool => "LS"}) or bare on its own first line
+    // (<tool_call>RUN). Which delimiter opened the block tells us nothing once
+    // models mix them, so try both spellings every time.
+    const tool = (/tool\s*(?:=>|:)\s*"([^"]+)"/i.exec(body) || [])[1]
+      || (/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*$/m.exec(body) || [])[1];
+    if (!tool) continue;
+    // Arguments come in three spellings across harnesses: --flag "v",
+    // "key" => "v", and key: "v". Accept all of them rather than betting on one.
+    const args = {};
+    for (const m of body.matchAll(/--([a-z_]+)\s+"([^"]*)"/gi)) args[m[1].toLowerCase()] = m[2];
+    for (const m of body.matchAll(/"?([a-z_]+)"?\s*(?:=>|:)\s*"([^"]*)"/gi)) {
+      if (m[1].toLowerCase() !== 'tool') args[m[1].toLowerCase()] = m[2];
+    }
+    // <arg_key>name</arg_key><arg_value>value</arg_value>, repeated. Values are
+    // NOT quoted in this dialect and may contain anything, so the value regex
+    // has to be lazy to its own closing tag rather than stop at a quote.
+    for (const m of body.matchAll(/<arg_key>\s*([^<]+?)\s*<\/arg_key>\s*<arg_value>([\s\S]*?)<\/arg_value>/gi)) {
+      args[m[1].toLowerCase()] = m[2];
+    }
+    const a = (...names) => names.map((n) => args[n]).find((v) => v !== undefined && v !== '');
+    const t = tool.toUpperCase();
+    if (t === 'LS' || t === 'LIST') out.push('GLOB: ' + ((a('path', 'dir', 'directory') || '.').replace(/\/$/, '') + '/*'));
+    else if (t === 'GLOB' || t === 'FIND' || t === 'SEARCH_FILES') out.push('GLOB: ' + (a('pattern', 'glob', 'query') || '*'));
+    else if (t === 'READ' || t === 'READ_FILE' || t === 'CAT') out.push('READ: ' + (a('path', 'file', 'filename') || ''));
+    else if (t === 'WRITE' || t === 'WRITE_FILE') out.push('WRITE: ' + (a('path', 'file') || '') + ' | ' + (a('content', 'text', 'body') || ''));
+    else if (t === 'FETCH' || t === 'HTTP' || t === 'BROWSE') out.push('FETCH: ' + (a('url', 'uri') || ''));
+    else if (t === 'RUN' || t === 'BASH' || t === 'SHELL' || t === 'EXEC') out.push('RUN: ' + (a('command', 'cmd', 'script') || ''));
+    else if (t === 'SPAWN') out.push('SPAWN: ' + (a('name', 'agent') || 'helper') + ' | ' + (a('task', 'prompt', 'goal') || ''));
+    else if (t === 'MCP') {
+      // MCP takes url [| tool | {json}] — rebuild whichever form was meant.
+      const url = a('url', 'server', 'endpoint') || '';
+      const tool2 = a('tool', 'name', 'method') || '';
+      const argj = a('arg', 'args', 'arguments', 'params') || '';
+      out.push('MCP: ' + url + (tool2 ? ' | ' + tool2 + (argj ? ' | ' + argj : '') : ''));
+    }
+    else if (t === 'SEND') out.push('SEND: ' + (a('name', 'agent', 'to') || '') + ' | ' + (a('message', 'msg', 'task') || ''));
+    else if (t === 'PING') out.push('PING: ' + (a('name', 'agent') || ''));
+    else if (t === 'SERVE') out.push('SERVE: ' + (a('path', 'file') || ''));
+    else if (t === 'GREP') out.push('GREP: ' + (a('pattern', 'query', 'text') || ''));
+  }
+  // Only claim a translation when a directive actually came out of it — an
+  // unrecognised tool must fall through to the no-directive nudge, not vanish
+  // into an empty string that looks like a successful parse.
+  if (!blocks.length && !out.length) return null;
+  const text = out.filter((l) => !/(:|\|)\s*$/.test(l)).join('\n');
+  return text || null;
+}
+
+/**
+ * Cut a directive's argument at the START OF THE NEXT DIRECTIVE.
+ *
+ * Directive bodies are captured with a greedy [\s\S]+ so a task or a command
+ * may span lines. Greedy means the FIRST directive in a reply swallows every
+ * one after it — measured on RUN (three commands became one broken script) and
+ * again on SPAWN, where an orchestrator emitting five SPAWN lines would have
+ * created one agent whose "task" was the other four.
+ */
+function sliceToNextDirective(text) {
+  const m = /\n[ \t>*-]*(?:RUN|SPAWN|SEND|PING|PEEK|READ|WRITE|EDIT|GLOB|LS|LIST|DIR|FIND|GREP|SERVE|FETCH|MCP|DONE|TODO):/.exec(text);
+  let out = m ? text.slice(0, m.index) : text;
+  // Models fence their directive lists, so the LAST one in a block otherwise
+  // ends up owning the closing ``` and every word of prose after it — a
+  // subagent whose task was "Design anti-cheat ``` These subagents will work
+  // independently." Cut at the closing fence, same as parseRun does.
+  out = out.replace(/\n[ \t]*```[\s\S]*$/, '');
+  return out.trim();
+}
+
+/** Every head of one directive in a reply, in order, each with its argument
+ *  already cut at the next head. Tolerates preamble, list markers and quotes —
+ *  models put "1. " and "> " in front of directives constantly. */
+function directiveLines(reply, keyword) {
+  const heads = [...String(reply).matchAll(new RegExp('^[ \\t>*-]*(?:\\d+[.)]\\s*)?' + keyword + ':[ \\t]*', 'gm'))];
+  return heads.map((h, i) => {
+    const from = h.index + h[0].length;
+    const to = i + 1 < heads.length ? heads[i + 1].index : reply.length;
+    return sliceToNextDirective(reply.slice(from, to));
+  }).filter(Boolean);
+}
+
+/**
+ * Undo the two things models do to a directive line that make it unrecognisable.
+ *
+ * MEASURED live, repeatedly:  <LS: <blank>>
+ *
+ * Both halves come from our own prompt. It documented the argument as
+ * "<path, or blank for the root>", so the model copied the angle brackets AND
+ * the word blank, producing a placeholder where a path goes and wrapping the
+ * whole line for good measure. The prompt no longer teaches that, but models
+ * carry <ARG> notation out of training regardless, and a directive we refuse
+ * over its punctuation costs a paid turn every time.
+ *
+ * Only the directive HEAD is touched — never a body. WRITE content legitimately
+ * contains angle brackets (it is usually HTML), and rewriting that would corrupt
+ * files to fix a cosmetic problem.
+ */
+function unwrapDirectiveLine(reply) {
+  const KW = 'RUN|SPAWN|SEND|PING|PEEK|READ|WRITE|EDIT|MULTIEDIT|NOTEBOOK|GLOB|LS|LIST|DIR|FIND|GREP|SERVE|FETCH|MCP|DONE|TODO';
+  return String(reply).split('\n').map((line) => {
+    // <LS: ...>  ->  LS: ...     (a whole directive wrapped in angle brackets)
+    let out = line.replace(new RegExp('^([ \\t>*-]*)<\\s*((?:' + KW + '):[\\s\\S]*?)\\s*>\\s*$'), '$1$2');
+    // LS: <blank>  ->  LS:       (a placeholder standing in for "no argument")
+    out = out.replace(new RegExp('^([ \\t>*-]*(?:' + KW + '):)[ \\t]*<(?:blank|empty|none|nothing|path|dir|directory|optional)>[ \\t]*$', 'i'), '$1');
+    return out;
+  }).join('\n');
+}
+
+/**
+ * The brief a subagent is missing.
+ *
+ * A SPAWN task is the ORCHESTRATOR'S PARAPHRASE, and it is the whole world the
+ * child ever sees. MEASURED: the user told the orchestrator "remember always:
+ * proofnetwork can do it all, from rng to rpc/wallet management", and the
+ * orchestrator emitted
+ *     SPAWN: meta_game_dev | Develop a meta-game where non-player users can wager
+ * with ProofNetwork nowhere in it. The child heard "smart contract for
+ * wagering", and wrote TetrisMetaGame.SOL — Solidity, on a Solana project —
+ * because that is what "smart contract" means in the training distribution
+ * when nothing says otherwise. The stack WAS specified. It just never reached
+ * the agent doing the work.
+ *
+ * So a child now starts with the message that caused its own existence. Not a
+ * summary of it, not the parent's whole transcript — the actual words the user
+ * last wrote to the parent, which is where constraints like "this is
+ * ProofNetwork" and "use token22 <mint>" always live.
+ */
+function spawnBrief(parent) {
+  if (!parent) return '';
+  const lastUser = [...(parent.history || [])].reverse()
+    .find((m) => m.who === 'user' && !/^\((command output|directive result)\)/.test(String(m.text || '')));
+  const text = String(lastUser?.text || '').trim();
+  if (!text) return '';
+  return 'CONTEXT — this is what was asked of the team you were just spawned into. '
+    + 'Constraints in here (the stack, addresses, what NOT to do) apply to you, and outrank '
+    + 'any assumption you would otherwise make from your own training:\n\n'
+    + text.slice(0, 4000)
+    + '\n\n--- your specific job ---\n';
+}
+
+/**
+ * WHERE YOU SIT IN THE TREE — the thing that stops pointless re-fanning.
+ *
+ * There is deliberately NO depth cap on SPAWN. A cap is the wrong tool: real
+ * work is n-tiered and the right depth is whatever the job is. What actually
+ * went wrong is that a child had no idea the split had ALREADY HAPPENED —
+ * MEASURED, tetris-engine-builder was handed "build the Tetris game", could
+ * not see that four siblings already owned the other quarters, and spawned
+ * agent-1..agent-4 to re-split its own slice. Sixteen threads, generic names,
+ * nobody building anything.
+ *
+ * So tell it: who you are, how many of you there are, what each sibling holds,
+ * and how deep you already are. An agent that can see the decomposition does
+ * the work instead of re-performing the decomposition.
+ */
+function spawnPosition(parent, childName) {
+  if (!parent) return '';
+  const siblings = [...threads.values()].filter((x) => x.parent === parent.id).map((x) => x.name);
+  const depth = rootOf(parent).depth + 1;
+  const others = siblings.filter((n) => n !== childName);
+  return '\n\n--- your place in the team ---\n'
+    + `You are "${childName}", spawned by "${parent.name}". You are at tier ${depth} of this project.\n`
+    + (others.length
+      ? `The work was ALREADY SPLIT before you existed. Your siblings under ${parent.name} are: `
+        + others.join(', ') + '.\nThey hold the other slices. Yours is yours to BUILD.\n'
+      : '')
+    + 'Do NOT re-split your own slice into more agents just because it has several parts — '
+    + 'that is how a team becomes sixteen bots and zero artifacts. SPAWN only if your slice '
+    + 'contains genuinely independent work that NO existing sibling covers, and name any agent '
+    + 'you do spawn after what it owns, never "agent-1".\n'
+    + 'Work in your own directory so you cannot collide with a sibling: '
+    + `type  /dir <path>  if you need one. Everything else — build it yourself, now.\n`;
+}
+
+/**
+ * "AGENT-NAME: do the thing"  ->  "SEND: AGENT-NAME | do the thing"
+ *
+ * Gated on the name resolving to a real thread, so prose like "Note:" or
+ * "Warning:" cannot be mistaken for an address. Names are compared with
+ * separators and case stripped, because a model writes INSTALL-ANALYZE-MCP for
+ * a thread called install-analyze-mcp and means the same bot.
+ */
+function nameAddressedToSend(reply, originId) {
+  const norm = (x) => String(x).toLowerCase().replace(/[^a-z0-9]/g, '');
+  const byNorm = new Map();
+  for (const x of threads.values()) if (x.id !== originId) byNorm.set(norm(x.name), x.name);
+  if (!byNorm.size) return reply;
+  return String(reply).split('\n').map((line) => {
+    const m = /^([ \t>*-]*)([A-Za-z][A-Za-z0-9 _-]{1,48}):[ \t]+(\S[\s\S]*)$/.exec(line);
+    if (!m) return line;
+    const real = byNorm.get(norm(m[2]));
+    // A directive keyword that happens to match a thread name stays a directive.
+    if (!real || /^(RUN|SPAWN|SEND|PING|PEEK|READ|WRITE|EDIT|GLOB|LS|LIST|DIR|FIND|GREP|SERVE|FETCH|MCP|DONE|TODO)$/i.test(m[2].trim())) return line;
+    return `${m[1]}SEND: ${real} | ${m[3]}`;
+  }).join('\n');
+}
+
 async function tryDirective(reply, originId) {
+  // 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);
+  if (translated) reply = translated;
+  // Then strip angle-bracket wrapping and placeholder arguments.
+  reply = unwrapDirectiveLine(reply);
+  // ADDRESSING A BOT BY BARE NAME IS A SEND.
+  //
+  // MEASURED: an orchestrator wrote a block of
+  //     INSTALL-ANALYZE-MCP: Please proceed with installing the MCP…
+  //     GAME-ENGINE: Please proceed with designing the prototype…
+  // one line per subagent, and the user had to ask "sorry did you forget
+  // 'SEND: '". It is a perfectly clear instruction in every sense except the
+  // one the parser cares about.
+  //
+  // Only rewritten when the prefix MATCHES AN EXISTING THREAD, case- and
+  // separator-insensitive. That is what makes this safe: "Note:" or "Step 2:"
+  // never matches a live agent, so ordinary prose is untouched.
+  reply = nameAddressedToSend(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)];
@@ -867,7 +1446,57 @@ async function tryDirective(reply, originId) {
     return results.filter(Boolean).join('\n\n');
   }
 
-  const spawn = /^SPAWN:\s*([^|]+)\|\s*([\s\S]+)/.exec(reply);
+  // EVERY SPAWN LINE, NOT JUST THE FIRST — AND NOT ONLY AT THE START.
+  //
+  // This was /^SPAWN:...([\s\S]+)/ with NO `m` flag, which is two bugs at once:
+  //
+  //   `^` without `m` anchors to the start of the WHOLE REPLY. An orchestrator
+  //   that writes "To address your requirements, I will spawn subagents:" and
+  //   then lists its directives never matched AT ALL — measured live, five
+  //   SPAWN lines, five SEND lines and five PING lines across three turns, and
+  //   the sidebar still held exactly one bot. Identical to the /^RUN:/ anchor
+  //   bug this file already documents, never applied to SPAWN.
+  //
+  //   And [\s\S]+ is greedy, so even once it matched, the FIRST spawn would
+  //   swallow the other four into its own task.
+  //
+  // Fan out over every head, cutting each task at the next directive.
+  const spawnAll = directiveLines(reply, 'SPAWN');
+  if (spawnAll.length > 1) {
+    // CREATE THE WHOLE COHORT BEFORE ANY OF THEM STARTS THINKING.
+    //
+    // Re-entering tryDirective per line spawns them one at a time, and
+    // spawnPosition reads the sibling set AT SPAWN TIME — so the first child
+    // was told it had no siblings, the second one, the fifth four. MEASURED:
+    // tetris-game, spawned second of five, was told "Your siblings under
+    // openzoo are: mcp-analyzer" while three more were seconds behind it. The
+    // whole point of telling a child the split already happened is defeated if
+    // it cannot see most of the split.
+    //
+    // The full cohort is knowable up front — it is right there in the reply.
+    // So: parse every line, create every thread, THEN start their turns.
+    const parent = threads.get(originId);
+    const parsed = spawnAll.map((line) => /^([^|]+)\|([\s\S]+)/.exec(line))
+      .filter(Boolean).map((m) => ({ name: m[1].trim(), task: m[2].trim() }));
+    const made = [];
+    const notes = [];
+    for (const { name, task } of parsed) {
+      const existing = findByName(name);
+      if (existing) { notes.push(`${name} already exists — sending it the task.`); made.push({ t: existing, task, fresh: false }); continue; }
+      const siblings = [...threads.values()].filter((x) => x.parent === originId).length;
+      if (siblings >= SPAWN_MAX_CHILDREN) { notes.push(`Not spawning "${name}": already at ${SPAWN_MAX_CHILDREN} subagents.`); continue; }
+      made.push({ t: newThread(name, originId), task, fresh: true });
+    }
+    // Every thread now exists, so spawnPosition sees the COMPLETE cohort.
+    for (const { t: sub, task, fresh } of made) {
+      runTurn(sub.id, (fresh ? spawnBrief(parent) : '') + task
+        + (fresh ? spawnPosition(parent, sub.name) : '')).catch(() => {});
+    }
+    const fresh = made.filter((m) => m.fresh).map((m) => m.t.name);
+    return [fresh.length ? `Spawned ${fresh.length} together (they can each see the full crew): ${fresh.join(', ')}` : '', ...notes]
+      .filter(Boolean).join('\n');
+  }
+  const spawn = spawnAll.length === 1 ? /^([^|]+)\|([\s\S]+)/.exec(spawnAll[0]) : null;
   if (spawn) {
     const name = spawn[1].trim();
     const task = spawn[2].trim();
@@ -892,27 +1521,85 @@ async function tryDirective(reply, originId) {
         + `every live subagent costs paid calls.`;
     }
     const sub = newThread(name, originId);
-    runTurn(sub.id, task).catch(() => {}); // fire and forget — runs independently
+    // The child gets the ORIGINATING brief plus its own job — see spawnBrief.
+    runTurn(sub.id, spawnBrief(threads.get(originId)) + task + spawnPosition(threads.get(originId), name)).catch(() => {}); // fire and forget
     return `Spawned ${name} — working on it.`;
   }
-  const sendM = /^SEND:\s*([^|]+)\|\s*([\s\S]+)/.exec(reply);
+  // SEND TO A NAME THAT DOES NOT EXIST YET *SPAWNS* IT.
+  //
+  // SPAWN already degrades to SEND when the name is taken ("already exists —
+  // sent it the task instead of spawning a duplicate"). This is that rule's
+  // missing half, and without it the pair was asymmetric in the direction that
+  // costs money: an orchestrator planning a crew names all of them up front and
+  // then SENDs, so every not-yet-spawned member returned
+  //   No thread named "Solana-Betting-Metagame" to message.
+  // — MEASURED live, twice in one chain. Each one is a dead turn the model then
+  // has to notice, diagnose and recover from, at auto-mode prices.
+  //
+  // Creating it is what was meant. The message IS the task; that is exactly the
+  // argument SPAWN takes, so there is nothing to invent.
+  // Same two bugs as SPAWN above: no `m`, and a greedy body.
+  const sendAll = directiveLines(reply, 'SEND');
+  if (sendAll.length > 1) {
+    const out = [];
+    for (const line of sendAll) out.push(await tryDirective('SEND: ' + line, originId));
+    return out.filter(Boolean).join('\n');
+  }
+  const sendM = sendAll.length === 1 ? /^([^|]+)\|([\s\S]+)/.exec(sendAll[0]) : null;
   if (sendM) {
     const name = sendM[1].trim();
     const msg = sendM[2].trim();
     const target = findByName(name);
-    if (target) runTurn(target.id, msg).catch(() => {});
-    return target ? `Messaged ${name}.` : `No thread named "${name}" to message.`;
+    if (target) {
+      runTurn(target.id, msg).catch(() => {});
+      return `Messaged ${name}.`;
+    }
+    // The SAME storm guard SPAWN uses — promoting a SEND must not be a way
+    // around the subagent ceiling, or a chatty orchestrator fans out for free
+    // just by spelling its directive differently.
+    const siblings = [...threads.values()].filter((x) => x.parent === originId).length;
+    if (siblings >= SPAWN_MAX_CHILDREN) {
+      return `Cannot create "${name}": this thread already has ${siblings} subagents `
+        + `(limit ${SPAWN_MAX_CHILDREN}). Reuse one with  SEND: <existing name> | <task>.`;
+    }
+    const sub = newThread(name, originId);
+    runTurn(sub.id, spawnBrief(threads.get(originId)) + msg + spawnPosition(threads.get(originId), name)).catch(() => {});
+    return `${name} did not exist — spawned it with that message as its task.`;
   }
-  const ping = /^PING:\s*(.+)/.exec(reply);
+  // PING had the same anchor bug — no `m`, so a PING after any preamble (or
+  // inside a fence, which is where models put lists of them) never matched.
+  const pingAll = directiveLines(reply, 'PING');
+  if (pingAll.length > 1) {
+    const out = [];
+    for (const line of pingAll) out.push(await tryDirective('PING: ' + line, originId));
+    return out.filter(Boolean).join('\n');
+  }
+  const ping = pingAll.length === 1 ? [null, pingAll[0]] : null;
   if (ping) {
     const name = ping[1].trim();
+    // PING: * (or 'all' / 'project') reaches EVERY bot in this project.
+    // Coordinating a spawn tree by naming siblings one at a time is a chore
+    // the parent should not have to do, and it cannot know who else exists.
+    if (/^(\*|all|project|everyone)$/i.test(name)) {
+      const me = threads.get(originId);
+      const root = me ? rootOf(me).rootId : null;
+      const crew = [...threads.values()].filter((x) => x.id !== originId && rootOf(x).rootId === root);
+      if (!crew.length) return 'No other bots in this project yet.';
+      return crew.map((x) => {
+        const last = x.history[x.history.length - 1];
+        return x.pendingRun ? x.name + ': BLOCKED — waiting for approval'
+          : x.status === 'thinking' ? x.name + ': still working'
+          : last ? x.name + ': ' + String(last.text).slice(0, 200)
+          : x.name + ': no reply yet';
+      }).join('\n');
+    }
     const target = findByName(name);
     const last = target?.history[target.history.length - 1];
     return !target ? `No thread named "${name}".`
       : target.status === 'thinking' ? `${name} is still working.`
       : last ? `${name}: ${last.text}` : `${name} hasn't replied yet.`;
   }
-  const peek = /^PEEK:\s*(.+)/.exec(reply);
+  const peek = /^[ \t>*-]*PEEK:\s*(.+)/m.exec(reply);
   if (peek) {
     const name = peek[1].trim();
     const target = findByName(name);
@@ -921,7 +1608,7 @@ async function tryDirective(reply, originId) {
       .map((h) => (h.who === 'user' ? 'you' : (h.name || target.name)) + ': ' + h.text).join('\n');
     return `${name} (${target.status}):\n${recent || '(nothing yet)'}`;
   }
-  const write = /^WRITE:\s*([^|]+)\|([\s\S]+)/.exec(reply);
+  const write = /^[ \t>*-]*WRITE:\s*([^|]+)\|([\s\S]+)/m.exec(reply);
   if (write) {
     const rel = write[1].trim();
     const content = write[2].replace(/^\n/, '');
@@ -932,7 +1619,7 @@ async function tryDirective(reply, originId) {
       return `Wrote ${rel} (${Buffer.byteLength(content)} bytes) to ${dirFor(originId)}.`;
     } catch (e) { return `Couldn't write ${rel}: ${e.message}`; }
   }
-  const readD = /^READ:\s*(.+)/.exec(reply);
+  const readD = /^[ \t>*-]*READ:\s*(.+)/m.exec(reply);
   if (readD) {
     const rel = readD[1].trim();
     try {
@@ -943,7 +1630,7 @@ async function tryDirective(reply, originId) {
   // 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);
+  const edit = /^[ \t>*-]*EDIT:\s*([^|]+)\|([\s\S]*?)\|\|\|([\s\S]*)$/m.exec(reply);
   if (edit) {
     const rel = edit[1].trim();
     const oldStr = edit[2].replace(/^\n/, '').replace(/\n$/, '');
@@ -962,7 +1649,7 @@ async function tryDirective(reply, originId) {
   // 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);
+  const multi = /^[ \t>*-]*MULTIEDIT:\s*([^|]+)\|([\s\S]+)$/m.exec(reply);
   if (multi) {
     const rel = multi[1].trim();
     const pairs = multi[2].split(';;').map((p) => p.split('|||')).filter((p) => p.length === 2);
@@ -986,7 +1673,7 @@ async function tryDirective(reply, originId) {
   }
 
   // Jupyter: replace one cell's source by index, keeping the notebook valid.
-  const nb = /^NOTEBOOK:\s*([^|]+)\|\s*(\d+)\s*\|([\s\S]+)$/.exec(reply);
+  const nb = /^[ \t>*-]*NOTEBOOK:\s*([^|]+)\|\s*(\d+)\s*\|([\s\S]+)$/m.exec(reply);
   if (nb) {
     const rel = nb[1].trim();
     const idx = Number(nb[2]);
@@ -1005,7 +1692,10 @@ async function tryDirective(reply, originId) {
     } catch (e) { return `Couldn't edit ${rel}: ${e.message}`; }
   }
 
-  const ls = /^LS:\s*(.*)$/.exec(reply);
+  // The real directory listing. It has always existed and never once fired:
+  // no `m` flag, so a bare LS: after any preamble was invisible, which is why
+  // it looked like LS had no handler at all.
+  const ls = /^[ \t>*-]*(?:LS|LIST|DIR):[ \t]*(.*)$/m.exec(reply);
   if (ls) {
     const rel = ls[1].trim() || '.';
     try {
@@ -1022,9 +1712,20 @@ async function tryDirective(reply, originId) {
     } catch (e) { return `Couldn't list ${rel}: ${e.message}`; }
   }
 
-  const glob = /^GLOB:\s*(.+)$/.exec(reply);
+  // LS:/LIST:/DIR:/FIND: are ALIASES for GLOB, and the argument is optional.
+  //
+  // Models reach for "LS:" constantly — it is the obvious name for the thing
+  // and it is all over their training. We only ever documented GLOB, so a bot
+  // emitted a bare `LS:` (MEASURED live, right after announcing "let me first
+  // check the current directory"), nothing matched, the line rendered as chat
+  // text, and the user typed "continue…". Refusing a directive over its
+  // spelling is not a rule, it is a bug that costs a paid turn every time.
+  //
+  // A bare LS: means "what is here" — the empty pattern that GLOB would reject
+  // becomes `*`, which is what was meant.
+  const glob = /^(?:GLOB|LS|LIST|DIR|FIND):[ \t]*(.*)$/m.exec(reply);
   if (glob) {
-    const pattern = glob[1].trim();
+    const pattern = glob[1].trim() || '*';
     try {
       const base = dirFor(originId);
       const re = globToRe(pattern.startsWith('./') ? pattern.slice(2) : pattern);
@@ -1035,7 +1736,7 @@ async function tryDirective(reply, originId) {
     } catch (e) { return `GLOB ${pattern}: ${e.message}`; }
   }
 
-  const grep = /^GREP:\s*([^|]+?)(?:\s*\|\s*(.+))?$/.exec(reply);
+  const grep = /^[ \t>*-]*GREP:\s*([^|]+?)(?:\s*\|\s*(.+))?$/m.exec(reply);
   if (grep) {
     const pattern = grep[1].trim();
     const scope = (grep[2] || '').trim();
@@ -1063,7 +1764,7 @@ async function tryDirective(reply, originId) {
 
   // 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);
+  const todo = /^[ \t>*-]*TODO:\s*([\s\S]*)$/m.exec(reply);
   if (todo) {
     const t = threads.get(originId);
     if (!t) return 'TODO: no such thread.';
@@ -1073,13 +1774,37 @@ async function tryDirective(reply, originId) {
       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);
+    // TICKING SOMETHING OFF TELLS THE CREW.
+    //
+    // A goal completed in silence is a goal the rest of the project cannot
+    // build on. Every agent was working blind: five bots writing five halves
+    // of the same thing, nobody able to see what already existed, and the
+    // orchestrator reduced to PINGing for status one bot at a time. The
+    // information was there the whole time — it just never left the thread.
+    //
+    // "done <n> | <summary>" broadcasts a short peek to the project. The
+    // summary is OPTIONAL; without one the item's own text is the peek, which
+    // is usually enough and costs nothing to write.
+    const done = /^done\s+(\d+)\s*(?:\|\s*([\s\S]+))?$/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;
+      const peek = (done[2] || '').trim() || t.todos[idx].text;
       saveThreads();
-      return 'TODO:\n' + t.todos.map((x, i) => `  ${i + 1}. [${x.done ? 'x' : ' '}] ${x.text}`).join('\n');
+      const left = t.todos.filter((x) => !x.done).length;
+      // Everyone in the project EXCEPT the sender, and only when there is a
+      // project — a lone bot broadcasting to nobody is just a wasted turn.
+      const root = rootOf(t).rootId;
+      const crew = [...threads.values()].filter((x) => x.id !== t.id && rootOf(x).rootId === root);
+      for (const x of crew) {
+        runTurn(x.id, `[${t.name} finished] ${peek}\n`
+          + `(${t.todos.length - left}/${t.todos.length} of its goals done. `
+          + `This is a status peek — do NOT redo this work, and do not reply unless it changes yours.)`)
+          .catch(() => {});
+      }
+      return 'TODO:\n' + t.todos.map((x, i) => `  ${i + 1}. [${x.done ? 'x' : ' '}] ${x.text}`).join('\n')
+        + (crew.length ? `\n\nTold ${crew.length} bot(s) in this project: ${peek.slice(0, 90)}` : '');
     }
     if (/^clear$/i.test(body)) { t.todos = []; saveThreads(); return 'TODO: cleared.'; }
     // Otherwise: replace the list with the lines given.
@@ -1089,13 +1814,13 @@ async function tryDirective(reply, originId) {
     return 'TODO:\n' + t.todos.map((x, i) => `  ${i + 1}. [ ] ${x.text}`).join('\n');
   }
 
-  const serve = /^SERVE:\s*(.*)$/.exec(reply);
+  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 fetchD = /^FETCH:\s*(\S+)/.exec(reply);
+  const fetchD = /^[ \t>*-]*FETCH:\s*(\S+)/m.exec(reply);
   if (fetchD) {
     const url = fetchD[1].trim();
     try {
@@ -1286,7 +2011,14 @@ async function runTurn(threadId, userText, onEvent, images) {
     bindThread(t).catch(() => {});
     return;
   }
-  if (!/^\(command output\)/.test(userText)) t.autoSteps = 0;
+  // A real message from the user resets the auto budget AND the one-shot
+  // announcement nudge — otherwise a thread that got nudged once could never be
+  // nudged again for the rest of its life, which is the opposite of a per-turn
+  // guard. The nudge itself is not a reset: it must not re-arm its own budget.
+  if (!/^\(command output\)/.test(userText) && userText !== NUDGE) {
+    t.autoSteps = 0;
+    delete t.autoNudged;
+  }
   t.messages.push({ role: 'user', content: contentFor(userText, images) });
   t.status = 'thinking';
   let reply = '';
@@ -1307,9 +2039,34 @@ async function runTurn(threadId, userText, onEvent, images) {
   }
   if (t.runMode === 'auto') extras.push({ role: 'system', content: AUTO_DIRECTIVE });
   const callMsgs = extras.length ? [...t.messages, ...extras] : t.messages;
-  const ask = async () => (onEvent
-    ? (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());
+  // WHICH MODEL SERVES THIS TURN.
+  //   /model <id>  pins one explicitly and always wins — an explicit choice is
+  //                not something a tier gets to override.
+  //   /race <n>    fires n models from the tier at once, first real answer wins.
+  //   /tier        otherwise picks the tier's best model.
+  // `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 });
+    // 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);
+    const race = Math.min(Number(t.race) || 0, 4);
+    if (!t.model && race >= 2) {
+      const models = await tierModels(t.tier || 'medium', race, true);
+      // need = how many must come BACK before judging. need 1 is a plain
+      // first-past-the-post race; need N waits for all of them. The point of
+      // the middle (2 of 3) is a judged answer without the slowest entrant
+      // setting the latency.
+      const need = Math.min(Math.max(Number(t.raceNeed) || 1, 1), race);
+      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 brain(callMsgs, t.contextId, model, topK)).trim());
+  };
   try {
     reply = await ask();
     // An EMPTY completion is transient far more often than it is meaningful —
@@ -1320,12 +2077,21 @@ async function runTurn(threadId, userText, onEvent, images) {
     // Retry in place rather than parking the thread behind a note the user has
     // to answer. In auto especially: a transient blip must not become a manual
     // step, which is the whole point of auto.
+    // Each retry goes to a DIFFERENT model in the tier. Asking the same model
+    // a fourth time after three empty completions is the definition of doing
+    // the same thing and expecting a different result — and it is what produced
+    // the "(the model returned nothing 4 times)" bubbles: four attempts, one
+    // sick provider. Empties are per-model and uncorrelated, so moving is the
+    // 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++) {
       await new Promise((r) => setTimeout(r, 400 * (i + 1)));
-      reply = await ask();
+      reply = await ask(t.model ? 0 : i + 1);
     }
     if (!reply) {
-      reply = `(the model returned nothing ${AUTO_EMPTY_RETRIES + 1} times — that is a provider problem, not your input. Try /model to switch, or send anything to retry.)`;
+      reply = t.model
+        ? `(${t.model} returned nothing ${AUTO_EMPTY_RETRIES + 1} times. It is pinned on this thread, so nothing else was tried — /model default frees it to fall back, or /model <id> to switch.)`
+        : `(${AUTO_EMPTY_RETRIES + 1} different models in the ${t.tier || 'medium'} tier each returned nothing — that is upstream, not your input. Try /tier expensive, /race 3, or send anything to retry.)`;
     }
   } catch (e) {
     reply = `error: ${e.message}`;
@@ -1410,15 +2176,180 @@ async function runTurn(threadId, userText, onEvent, images) {
     onEvent?.({ type: 'final', name: t.name, color: t.color, text: note });
     saveThreads();
   }
+
+  // ANNOUNCING IS NOT DOING — so do not let it end the turn.
+  //
+  // In auto, a reply with NO directive stopped the chain dead. The common one
+  // is not a finished answer, it is an announcement: "I'll break this down and
+  // spawn subagents immediately. First, let me check the uploaded files." The
+  // harness posted that as the final word and waited, so the user typed
+  // "continue?" — MEASURED live, three prompts to get one SPAWN.
+  //
+  // AUTO_DIRECTIVE already forbids this in the prompt, and models do it anyway.
+  // A prompt rule with no enforcement is a suggestion. Re-ask once, in-band.
+  //
+  // NARROW ON PURPOSE. It fires only on announcement language, never on a plain
+  // answer — auto is also how you hold an ordinary conversation, and nudging a
+  // finished reply would spend a turn arguing with a bot that already
+  // succeeded. Once per turn (autoNudged), so a model that announces twice
+  // still stops instead of looping on the user's wallet.
+  if (t.runMode === 'auto' && (ack === null || ack === undefined) && !t.autoNudged
+      && (t.autoSteps || 0) < AUTO_MAX_STEPS && ANNOUNCEMENT.test(reply)) {
+    t.autoNudged = true;
+    t.autoSteps = (t.autoSteps || 0) + 1;
+    saveThreads();
+    bindThread(t).catch(() => {});
+    runTurn(threadId, NUDGE, onEvent).catch(() => {});
+    return;
+  }
   bindThread(t).catch(() => {});
 }
 
+// Said it would, without a directive line. "Spawned X" and "working on it" are
+// in here because they are FALSE without a SPAWN: in the same reply — the bot
+// reports success for something the harness never saw.
+const ANNOUNCEMENT = /\b(?:I(?:'| a)?ll |I will |let me |I'm going to |I am going to |first,? |next,? |now I'll |starting|kicking off|spawn(?:ing|ed)|about to|going to (?:check|run|create|start|install))\b/i;
+
+const NUDGE = 'That reply announced work instead of doing it — no directive line reached the harness, '
+  + 'so nothing ran. Emit the directive NOW, as the first line of your reply, with no preamble: '
+  + 'RUN:, SPAWN:, READ:, WRITE:, GLOB:, FETCH:, MCP: or SERVE:. '
+  + 'Exactly the syntax from your instructions — not [TOOL_CALL], not JSON, not a function-call envelope. '
+  + 'If several steps are needed, emit the FIRST one; you get its real output back and continue from there.';
+
+/**
+ * The PROJECT a thread belongs to = the root of its spawn tree, and how deep
+ * it sits. Every thread already carried the parent id; nothing ever walked it, so
+ * fifteen agents rendered as one flat list with no hint that twelve of them
+ * were spawned by one root.
+ *
+ * Depth is capped and visited-guarded: SPAWN sets parent from whoever emitted
+ * the directive, and a bot messaging its own ancestor could otherwise close a
+ * cycle and hang the render loop.
+ */
+function rootOf(t) {
+  const seen = new Set();
+  let cur = t;
+  let depth = 0;
+  while (cur?.parent && depth < 32 && !seen.has(cur.id)) {
+    seen.add(cur.id);
+    const next = threads.get(cur.parent);
+    if (!next) break;
+    cur = next;
+    depth += 1;
+  }
+  return { rootId: cur?.id || t.id, depth };
+}
+
+/**
+ * Order threads as a TREE, not by recency.
+ *
+ * The sidebar sorted purely by lastActivityAt, which scrambled the hierarchy —
+ * a child that just spoke jumped ABOVE its own parent, so the indentation drew
+ * a structure the order contradicted. A tree you cannot read is worse than a
+ * flat list, because it looks like it means something.
+ *
+ * Projects are ordered by their most recent activity (an active project stays
+ * near the top, which is what recency was for), but WITHIN a project the order
+ * is depth-first from the root, so a child is always directly under its parent
+ * and indentation matches position. Siblings are ordered by recency.
+ *
+ * Cycle-guarded: SPAWN sets parent from whoever emitted the directive, and a
+ * bot spawning toward its own ancestor could otherwise loop forever here.
+ */
+function orderedThreads() {
+  const all = [...threads.values()];
+  const byParent = new Map();
+  for (const t of all) {
+    const key = t.parent || '';
+    if (!byParent.has(key)) byParent.set(key, []);
+    byParent.get(key).push(t);
+  }
+  for (const list of byParent.values()) list.sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0));
+
+  // Newest-active project first.
+  const roots = all.filter((t) => !t.parent || !threads.has(t.parent));
+  const freshest = (t) => {
+    let best = t.lastActivityAt || 0;
+    const stack = [t.id];
+    const seen = new Set();
+    while (stack.length) {
+      const id = stack.pop();
+      if (seen.has(id)) continue;
+      seen.add(id);
+      for (const c of byParent.get(id) || []) {
+        best = Math.max(best, c.lastActivityAt || 0);
+        stack.push(c.id);
+      }
+    }
+    return best;
+  };
+  roots.sort((a, b) => freshest(b) - freshest(a));
+
+  const out = [];
+  const seen = new Set();
+  const walk = (t) => {
+    if (seen.has(t.id)) return;
+    seen.add(t.id);
+    out.push(t);
+    for (const c of byParent.get(t.id) || []) walk(c);
+  };
+  for (const r of roots) walk(r);
+  // Anything unreachable (orphaned parent id) still has to appear — a thread
+  // you cannot see is a thread you cannot stop, and it bills.
+  for (const t of all) if (!seen.has(t.id)) out.push(t);
+  return out;
+}
+
+/**
+ * Everyone at or below a thread. Ping-all lives HERE, not on the project root.
+ *
+ * "/all" used to mean "every bot sharing my rootId" — the whole project,
+ * regardless of who you were talking to. That is the wrong unit once a tree has
+ * real tiers: a mid-level owner wants to reach ITS OWN crew, not the eleven
+ * cousins under a sibling. Addressing the whole project from a leaf is how one
+ * message costs twenty paid turns.
+ *
+ * Cycle-guarded, because SPAWN sets parent from whoever emitted the directive
+ * and a bot spawning toward its own ancestor would otherwise loop here.
+ */
+function subtreeOf(id, includeSelf = false) {
+  const out = [];
+  const seen = new Set([id]);
+  const stack = [id];
+  while (stack.length) {
+    const cur = stack.pop();
+    for (const x of threads.values()) {
+      if (x.parent === cur && !seen.has(x.id)) {
+        seen.add(x.id);
+        out.push(x);
+        stack.push(x.id);
+      }
+    }
+  }
+  const self = threads.get(id);
+  return includeSelf && self ? [self, ...out] : out;
+}
+
 function threadSummary(t) {
   const last = t.history[t.history.length - 1];
   return { id: t.id, name: t.name, color: t.color, parent: t.parent, status: t.status,
     preview: last ? (last.who === 'user' ? last.text : last.text).slice(0, 60) : '',
     createdAt: t.createdAt, lastActivityAt: t.lastActivityAt || t.createdAt,
-    dir: t.dir || WORKSPACE_DIR, runMode: t.runMode || 'ask' };
+    dir: t.dir || WORKSPACE_DIR, runMode: t.runMode || 'ask',
+    // BLOCKED ON YOU. A thread with a pending RUN is stopped dead until
+    // someone approves or denies it, and nothing in the sidebar said so — it
+    // looked identical to an idle thread, so a subagent could sit waiting for
+    // an approval nobody knew it wanted. The blue dot means "working"; this
+    // means "your move".
+    awaitingUser: Boolean(t.pendingRun),
+    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
+    // thread. `model` pinned means tier/race are inert — the UI says so.
+    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 };
 }
 
 const APP_HTML = `<!doctype html>
@@ -1442,6 +2373,28 @@ const APP_HTML = `<!doctype html>
   #threads { flex: 1; overflow-y: auto; }
   .trow { display: flex; align-items: center; gap: 10px; padding: 8px 12px; cursor: pointer; border-radius: 10px;
           margin: 0 6px 2px; }
+  /* PROJECT HEADER. The tree indentation shows who spawned whom, but there was
+     no handle on a project as a WHOLE — no way to see where one ends and the
+     next begins, and no way to talk to all of it at once without opening each
+     bot and retyping. This row is that handle. It only appears for a root that
+     actually has children; a lone bot is not a project and does not need a
+     label above it. */
+  .prow { display: flex; align-items: center; gap: 8px; padding: 10px 12px 4px; margin: 0 6px;
+          font-size: 11px; letter-spacing: .06em; text-transform: uppercase; color: #6f7080; }
+  .prow .pname { flex: 1; min-width: 0; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .pcount { color: #4c4d5a; letter-spacing: 0; text-transform: none; }
+  .pingall { border: 1px solid #2c2c2e; background: transparent; color: #8e8e93; font: inherit; font-size: 10px;
+             letter-spacing: .04em; text-transform: uppercase; padding: 2px 7px; border-radius: 999px;
+             cursor: pointer; opacity: 0; transition: opacity .12s ease, color .12s ease, border-color .12s ease; }
+  .prow:hover .pingall, .pingall:focus-visible { opacity: 1; }
+  /* On a THREAD row the button sits beside the close X, so it follows the same
+     reveal-on-hover rule — a permanently visible control on every parent row
+     would turn the sidebar into a wall of buttons. */
+  .trow .pingall { flex: 0 0 auto; margin-left: 2px; }
+  .trow:hover .pingall, .trow.active .pingall { opacity: 1; }
+  .pingall:hover { color: #b8f240; border-color: #b8f240; }
+  .pingall:focus-visible { outline: 2px solid #6ab0ff; outline-offset: 2px; }
+  .pingall[disabled] { opacity: 1; color: #4c4d5a; border-color: #1c1c1e; cursor: default; }
   .trow:hover { background: #17171a; }
   .trow.active { background: #1c1c1e; }
   .tclose { flex: 0 0 20px; width: 20px; height: 20px; border-radius: 50%; border: none; background: transparent;
@@ -1455,6 +2408,17 @@ const APP_HTML = `<!doctype html>
   .tname { font-size: 14px; font-weight: 500; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
   .tprev { font-size: 12px; color: #8e8e93; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
   .tdot { width: 8px; height: 8px; border-radius: 50%; background: #0a84ff; flex: 0 0 8px; }
+  /* "Your move" — a CSS triangle, so it reads as a different SHAPE and not
+     just a different colour. Colour alone would be invisible to a red/green
+     colour-blind user, and this is the one state that needs acting on. */
+  .twarn {
+    width: 0; height: 0; flex: 0 0 auto;
+    border-left: 5px solid transparent; border-right: 5px solid transparent;
+    border-bottom: 9px solid #ffcc00;
+    animation: twarnpulse 1.6s ease-in-out infinite;
+  }
+  @keyframes twarnpulse { 0%,100% { opacity: 1; } 50% { opacity: .45; } }
+  @media (prefers-reduced-motion: reduce) { .twarn { animation: none; } }
   #main { flex: 1; min-width: 0; display: flex; flex-direction: column; height: 100vh; }
   #chatHeader { padding: 14px 20px; border-bottom: 1px solid #1c1c1e; display: flex; align-items: center; gap: 10px;
                 font-weight: 600; }
@@ -1476,6 +2440,54 @@ 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; }
+  /* SPEND DIAL. Two selects rather than more pill toggles: ask/auto is a safety
+     switch you flip constantly, these are set once and forgotten, and giving
+     them the same visual weight would say they matter equally. Muted until
+     they are off default, then they colour — an expensive tier or a live race
+     should be visible at a glance, because both are spending your wallet. */
+  .dial { border: 1px solid #2c2c2e; background: #131315; color: #8e8e93; font: inherit; font-size: 11px;
+          border-radius: 999px; padding: 4px 8px; cursor: pointer; -webkit-appearance: none; appearance: none; }
+  .dial:hover { color: #ececec; border-color: #3a3a3c; }
+  .dial:focus-visible { outline: 2px solid #6ab0ff; outline-offset: 2px; }
+  .dial.hot { color: #f28c4d; border-color: #f28c4d; }
+  .dial.pinned { color: #4c4d5a; border-color: #1c1c1e; }
+  /* WALLET. GET /wallet shipped in 1.5.22 with nothing pointing at it, so the
+     box's own deposit addresses were reachable only by curl — on a product
+     whose entire premise is that the box pays for itself. An address you
+     cannot copy is an address you cannot fund, so every one of them is a
+     click-to-copy row, not selectable text. */
+  #walletOverlay, #assetsOverlay { position: fixed; inset: 0; background: rgba(0,0,0,.66); z-index: 1200;
+                   display: none; align-items: center; justify-content: center; padding: 24px; }
+  #walletOverlay.show, #assetsOverlay.show { display: flex; }
+  #walletBox { width: 100%; max-width: 560px; max-height: 82vh; overflow-y: auto; background: #111113;
+               border: 1px solid #2c2c2e; border-radius: 16px; padding: 20px 22px; }
+  #walletBox h3 { margin: 0 0 2px; font-size: 15px; font-weight: 600; }
+  .wsub { color: #8e8e93; font-size: 12px; margin-bottom: 16px; }
+  .wrow { border: 1px solid #1c1c1e; border-radius: 12px; padding: 10px 12px; margin-bottom: 10px;
+          display: flex; align-items: center; gap: 10px; cursor: pointer; }
+  .wrow:hover { border-color: #3a3a3c; background: #151517; }
+  .wrow .wlab { flex: 0 0 74px; color: #6f7080; font-size: 11px; text-transform: uppercase; letter-spacing: .06em; }
+  /* min-width:0 or the address (one unbreakable token) widens the row and
+     pushes the copy affordance out of the box — the same flexbox trap that
+     once pushed the cost button off-screen. */
+  .wrow .waddr { flex: 1; min-width: 0; font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+                 font-size: 12px; word-break: break-all; line-height: 1.45; }
+  .wrow .wcopy { flex: 0 0 auto; color: #6f7080; font-size: 10px; text-transform: uppercase; letter-spacing: .06em; }
+  .wrow:hover .wcopy { color: #b8f240; }
+  .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; }
+  .wempty { color: #f28c4d; }
+  /* The passphrase field. type=password so it never renders in clear, and
+     autocomplete off so a browser is not tempted to remember a key that
+     unlocks a public blob. */
+  .wpass { width: 100%; margin-top: 4px; padding: 9px 12px; background: #0d0d0f; color: #ececec;
+           border: 1px solid #2c2c2e; border-radius: 10px; font: inherit; font-size: 13px;
+           font-family: ui-monospace, SFMono-Regular, Menlo, monospace; letter-spacing: .12em; }
+  .wpass:focus { outline: none; border-color: #6ab0ff; }
+  .wgo { margin-top: 10px; width: 100%; padding: 9px; border: 0; border-radius: 10px;
+         background: #b8f240; color: #000; font: inherit; font-weight: 600; cursor: pointer; }
+  .wgo[disabled] { background: #2c2c2e; color: #6f7080; cursor: default; }
   /* Slash autocomplete. Anchored above the composer because the composer sits
      at the bottom of the viewport — a dropdown BELOW it would render off
      screen. */
@@ -1549,6 +2561,37 @@ const APP_HTML = `<!doctype html>
   .md-table th { background: #1c1c1e; font-weight: 600; }
   .bubble-images { display: flex; gap: 6px; flex-wrap: wrap; margin-bottom: 8px; }
   .bubble-images img { max-width: 160px; max-height: 160px; border-radius: 12px; display: block; }
+
+  /* COPY AFFORDANCES.
+     Hidden until the row is hovered so they never compete with the text, but
+     always in the DOM — a button that only exists on hover is unreachable by
+     keyboard, so :focus-within reveals them too and each one is tabbable. */
+  .row { position: relative; }
+  .copybtn {
+    position: absolute; top: 2px; opacity: 0; pointer-events: none;
+    display: inline-flex; align-items: center; gap: 4px;
+    padding: 3px 8px; border: 1px solid #3a3a3d; border-radius: 8px;
+    background: #1c1c1e; color: #b9b9c0;
+    font: 500 10.5px/1.4 ui-sans-serif, -apple-system, system-ui, sans-serif;
+    letter-spacing: .02em; cursor: pointer;
+    transition: opacity .12s ease, background .12s ease, color .12s ease;
+  }
+  .row.bot .copybtn { right: -2px; }
+  .row.user .copybtn { left: -2px; }
+  .row:hover .copybtn, .row:focus-within .copybtn { opacity: 1; pointer-events: auto; }
+  .copybtn:hover { background: #2a2a2d; color: #f0f0eb; }
+  .copybtn:focus-visible { opacity: 1; pointer-events: auto; outline: 2px solid #b8f240; outline-offset: 2px; }
+  .copybtn.ok { background: #b8f240; border-color: #b8f240; color: #0b0b0d; }
+
+  /* Code blocks and RUN output get their own button, pinned inside the block —
+     copying one command out of a long reply is the common case, and selecting
+     it by hand in a scrolling <pre> is exactly what people fail at. */
+  .md-pre, .runoutput, .runcmd { position: relative; }
+  .md-pre .copybtn, .runoutput .copybtn, .runcmd .copybtn { top: 6px; right: 6px; left: auto; }
+  .md-pre:hover .copybtn, .runoutput:hover .copybtn, .runcmd:hover .copybtn,
+  .md-pre:focus-within .copybtn, .runoutput:focus-within .copybtn, .runcmd:focus-within .copybtn {
+    opacity: 1; pointer-events: auto;
+  }
   .runcard { background: #1c1c1e; border: 1px solid #333; border-radius: 14px; padding: 12px 14px;
              max-width: 100%; min-width: 0; overflow: hidden; }
   .runcmd { font-family: Menlo, monospace; font-size: 12.5px; color: #ececec; white-space: pre-wrap;
@@ -1655,6 +2698,23 @@ const APP_HTML = `<!doctype html>
       <div id="composeFoot"><span><kbd>Tab</kbd> add</span><span><kbd>Enter</kbd> open</span></div>
     </div>
   </div>
+  <div id="assetsOverlay" data-component="assets-modal">
+    <div id="walletBox">
+      <h3>Unlock baked assets</h3>
+      <div class="wsub">ProofFront ships encrypted inside this box's image. Your passphrase decrypts it here; it is never stored.</div>
+      <input class="wpass" id="assetsPass" type="password" autocomplete="off" spellcheck="false" placeholder="passphrase">
+      <button class="wgo" id="assetsGo" data-testid="assets-decrypt">decrypt</button>
+      <div class="wnote" id="assetsMsg"></div>
+      <div class="wnote">Once unlocked the files are served like anything else in the workspace, and this box's :8080 has no authentication — the lock protects the public image, not a running box whose id someone knows.</div>
+    </div>
+  </div>
+  <div id="walletOverlay" data-component="wallet-modal">
+    <div id="walletBox">
+      <h3>This box's wallet</h3>
+      <div class="wsub">Every model call is paid from here, per call. No account, no API key.</div>
+      <div id="walletBody">loading…</div>
+    </div>
+  </div>
   <div id="main">
     <div id="chatHeader">
       <div id="chatHeaderId"></div>
@@ -1664,6 +2724,32 @@ const APP_HTML = `<!doctype html>
         <button class="modebtn auto" id="modeAuto" data-mode="auto"
                 title="Shell commands run immediately, with no approval prompt">auto</button>
       </div>
+      <select class="dial" id="tierSel" data-component="model-tier" aria-label="Model tier"
+              title="How much to spend per turn when no model is pinned">
+        <option value="cheap">cheap</option>
+        <option value="medium" selected>medium</option>
+        <option value="expensive">expensive</option>
+      </select>
+      <select class="dial" id="raceSel" data-component="model-race" aria-label="Race models"
+              title="Ask N models from the tier at once, drawn at random — fastest real answer wins. You pay for every entrant.">
+        <option value="0" selected>1 model</option>
+        <optgroup label="first back wins">
+          <option value="2">race 2</option>
+          <option value="3">race 3</option>
+          <option value="4">race 4</option>
+        </optgroup>
+        <optgroup label="judge the first k back">
+          <option value="2 3">best 2 of 3</option>
+          <option value="2 4">best 2 of 4</option>
+          <option value="3 4">best 3 of 4</option>
+          <option value="4 4">best 4 of 4</option>
+        </optgroup>
+      </select>
+      <button class="dial" id="assetsBtn" data-component="assets-unlock"
+              title="Unlock the encrypted assets baked into this box's image">assets</button>
+      <button class="dial" id="walletBtn" data-component="wallet-open"
+              title="This box's own wallet — deposit addresses and live balances">wallet</button>
+      <button class="icon-btn" id="reloadBtn" title="Restart grokui on this box">&#8635;</button>
       <button class="icon-btn" id="hudBtn">◎</button>
     </div>
     <div id="hud">
@@ -1709,28 +2795,153 @@ const APP_HTML = `<!doctype html>
   const log = document.getElementById('log');
   const inp = document.getElementById('inp');
   const send = document.getElementById('send');
+  // WHERE OUR OWN API LIVES.
+  //
+  // This UI is served from TWO places: the box root (the RunPod proxy,
+  // https://<pod>-8080.proxy.runpod.net/) and behind a path prefix on the site
+  // (openzoo.fun/api/box/go/<pod>/). Every fetch here was root-absolute —
+  // fetch(API + '/threads') — which is correct at the root and wrong behind a prefix,
+  // where it resolves to openzoo.fun/threads and 404s. MEASURED in a clean
+  // browser: the page loads, and the sidebar is empty forever.
+  //
+  // A <base href> does NOT fix this. base only affects RELATIVE urls; a leading
+  // slash is root-absolute and ignores it entirely. So derive the prefix from
+  // the path we were actually served under and put it in front of every call.
+  // NO REGEX HERE. Backslash escapes inside the APP_HTML template literal are
+  // consumed before the browser ever sees them, so /^\/api\// arrives as
+  // /^/api// — "Invalid regular expression flags", and the whole script dies.
+  // That is the same class of bug that shipped a dead UI in v1.5.22. Plain
+  // string ops cannot be mangled that way.
+  const API = location.pathname.startsWith('/api/box/go/')
+    ? location.pathname.split('/').slice(0, 5).join('/')
+    : '';
   let activeId = null;
   let knownThreads = [];
 
   function initials(name) { return name.slice(0, 2).toUpperCase(); }
 
+  // SEARCH. The input existed with no handler at all — typing in it did
+  // nothing, which is worse than not shipping it. Debounced because every
+  // keystroke otherwise walks every message of every thread server-side.
+  let searchHits = null;   // null = not searching; [] = searched, no hits
+  let searchTimer = null;
+  const searchEl = document.getElementById('search');
+  if (searchEl) {
+    searchEl.addEventListener('input', () => {
+      clearTimeout(searchTimer);
+      const q = searchEl.value.trim();
+      if (!q) { searchHits = null; loadThreads(); return; }
+      searchTimer = setTimeout(async () => {
+        try {
+          searchHits = await (await fetch(API + '/search?q=' + encodeURIComponent(q))).json();
+        } catch (e) { searchHits = []; }
+        loadThreads();
+      }, 180);
+    });
+    searchEl.addEventListener('keydown', (e) => {
+      if (e.key === 'Escape') { searchEl.value = ''; searchHits = null; loadThreads(); }
+    });
+  }
+
   async function loadThreads() {
-    const list = await (await fetch('/threads')).json();
+    const list = await (await fetch(API + '/threads')).json();
+    // When a search is active, show ONLY matches, ordered by hit count, and
+    // replace the preview with the matching line — the point of a search is
+    // seeing WHY something matched, not just that it did.
+    const hitById = searchHits ? new Map(searchHits.map((h) => [h.id, h])) : null;
     knownThreads = list;
     if (!activeId && list.length) activeId = list[0].id;
     threadsEl.innerHTML = '';
-    for (const t of list) {
+    const shown = hitById
+      ? list.filter((t) => hitById.has(t.id))
+          .sort((a, b) => (hitById.get(b.id).hits || 0) - (hitById.get(a.id).hits || 0))
+      : list;
+    if (hitById && !shown.length) {
+      const empty = document.createElement('div');
+      empty.className = 'tprev';
+      empty.style.cssText = 'padding:14px 12px;color:#6f7080';
+      empty.textContent = 'no messages match';
+      threadsEl.appendChild(empty);
+    }
+    // How many bots share each root, so a header can be drawn only where there
+    // is actually a project. Counted over the FULL list, not the filtered one —
+    // a search that matches two of a project's nine bots should still say nine.
+    const crewSize = new Map();
+    for (const t of list) crewSize.set(t.rootId, (crewSize.get(t.rootId) || 0) + 1);
+
+    let lastRoot = null;
+    for (const t of shown) {
+      // PROJECT HEADER + PING ALL. /all and /ping existed but only as typed
+      // commands, which meant the feature was invisible: you had to know it was
+      // there. This is the button.
+      if (!hitById && t.depth === 0 && (crewSize.get(t.rootId) || 1) > 1 && t.rootId !== lastRoot) {
+        const n = crewSize.get(t.rootId);
+        const head = document.createElement('div');
+        head.className = 'prow';
+        head.innerHTML = '<span class="pname">' + escapeHtml(t.name) + '</span>' +
+          '<span class="pcount">' + n + '</span>';
+        threadsEl.appendChild(head);
+        lastRoot = t.rootId;
+      }
       const row = document.createElement('div');
       row.className = 'trow' + (t.id === activeId ? ' active' : '');
+      // SPAWN HIERARCHY. the parent id was always on every thread and nothing ever
+      // rendered it, so fifteen agents looked like fifteen unrelated bots when
+      // twelve of them were one project. Indent by depth; a subagent is visibly
+      // a subagent. Capped at 4 so a deep tree cannot squeeze the name column
+      // to nothing.
+      if (t.depth) row.style.paddingLeft = (10 + Math.min(t.depth, 4) * 12) + 'px';
+      if (t.depth) row.title = 'spawned under ' + (t.rootName || 'a parent');
       row.innerHTML = '<div class="tavatar" style="background:' + t.color + '">' + initials(t.name) + '</div>' +
         '<div class="tmeta"><div class="tname">' + t.name + '</div><div class="tprev">' +
-        (t.status === 'thinking' ? 'typing…' : (t.preview || '')) + '</div></div>' +
-        (t.status === 'thinking' ? '<div class="tdot"></div>' : '') +
+        (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>' +
+          // 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.
+          (t.awaitingUser ? '<div class="twarn" title="Waiting for your approval"></div>'
+            : t.status === 'thinking' ? '<div class="tdot"></div>' : '') +
+        // PING ALL BELONGS TO WHOEVER HAS A CREW. It used to sit only on the
+        // project header, so a mid-level owner could not reach its own
+        // subagents without retyping — and pressing it addressed the WHOLE
+        // project, cousins included. Now every thread with descendants gets
+        // one, scoped to its own branch.
+        (t.kids ? '<button class="pingall trow-ping" data-testid="ping-all" title="Message all '
+          + t.kids + ' bot(s) below ' + escapeHtml(t.name) + '">\u21f2 ' + t.kids + '</button>' : '') +
         '<button class="tclose" title="Remove">✕</button>';
-      row.addEventListener('click', () => { activeId = t.id; render(); });
+      row.addEventListener('click', () => {
+        activeId = t.id;
+        render();
+        // Selecting a bot means you intend to talk to it. Landing focus in the
+        // composer saves a second click every single time, and on mobile it is
+        // what raises the keyboard at all.
+        requestAnimationFrame(() => { try { inp.focus(); } catch (e) {} });
+      });
+      const pingBtn = row.querySelector('.trow-ping');
+      if (pingBtn) {
+        pingBtn.addEventListener('click', async (e) => {
+          e.stopPropagation();
+          const msg = prompt('Send to all ' + t.kids + ' bot(s) below ' + t.name + ':');
+          // Empty is a cancel — sending "" would spend a paid turn on every
+          // bot in the branch for nothing.
+          if (msg === null || !msg.trim()) return;
+          pingBtn.disabled = true;
+          const was = pingBtn.textContent;
+          pingBtn.textContent = '…';
+          try {
+            // Routed through THIS thread, so /all scopes to its own subtree.
+            await fetch(API + '/drive', { method: 'POST', headers: { 'content-type': 'application/json' },
+              body: JSON.stringify({ threadId: t.id, task: '/all ' + msg.trim() }) });
+            pingBtn.textContent = 'sent';
+          } catch (err) { pingBtn.textContent = 'failed'; }
+          setTimeout(() => { pingBtn.disabled = false; pingBtn.textContent = was; }, 1500);
+          await loadThreads();
+        });
+      }
       row.querySelector('.tclose').addEventListener('click', async (e) => {
         e.stopPropagation();
-        await fetch('/threads/' + t.id, { method: 'DELETE' });
+        await fetch(API + '/threads/' + t.id, { method: 'DELETE' });
         if (activeId === t.id) activeId = null;
         await loadThreads();
         if (activeId) render();
@@ -1741,7 +2952,7 @@ const APP_HTML = `<!doctype html>
 
   async function loadActiveMessages() {
     if (!activeId) return null;
-    return await (await fetch('/threads/' + activeId)).json();
+    return await (await fetch(API + '/threads/' + activeId)).json();
   }
 
   function renderHeader(t) {
@@ -1750,8 +2961,171 @@ const APP_HTML = `<!doctype html>
       '<div class="hname"><div>' + t.name + '</div><div class="hdir" title="' + escapeHtml(t.dir || '') +
       '">' + escapeHtml(t.dir || '') + ' · type /dir &lt;path&gt; to change</div></div>';
     setModeButtons(t.runMode || 'ask');
+    setDials(t);
   }
 
+  // Same rule as the mode toggle: reflect the SERVER's value, never track it
+  // client-side. Both dials are also settable by typing /tier and /race, so a
+  // local copy would drift the moment anyone used the chat path.
+  function setDials(t) {
+    const tierSel = document.getElementById('tierSel');
+    const raceSel = document.getElementById('raceSel');
+    if (!tierSel || !raceSel) return;
+    tierSel.value = t.tier || 'medium';
+    raceSel.value = (t.race || 0) < 2 ? '0'
+      : ((t.raceNeed || 1) > 1 ? t.raceNeed + ' ' + t.race : String(t.race));
+    // A pinned /model makes BOTH dials inert. Showing them live while they do
+    // nothing is the kind of lie that costs an hour — grey them out and say why
+    // on hover, rather than letting someone set "expensive" and wonder why the
+    // answers never changed.
+    const pinned = Boolean(t.model);
+    for (const el of [tierSel, raceSel]) {
+      el.disabled = pinned;
+      el.className = 'dial' + (pinned ? ' pinned' : '');
+      el.title = pinned
+        ? t.model + ' is pinned on this thread with /model, so the tier and race are ignored. Run /model default to free them.'
+        : el === tierSel
+          ? 'How much to spend per turn when no model is pinned'
+          : 'Ask N models from the tier at once, drawn at random — fastest real answer wins. You pay for every entrant.';
+    }
+    if (!pinned && (t.tier === 'expensive' || (t.race || 0) >= 2)) {
+      if (t.tier === 'expensive') tierSel.className = 'dial hot';
+      if ((t.race || 0) >= 2) raceSel.className = 'dial hot';
+    }
+  }
+
+  async function setDial(cmd, value) {
+    if (!activeId) return;
+    // Reuses the SAME slash-command path, so there is one implementation of the
+    // rule rather than a second that can disagree with it.
+    await fetch(API + '/drive', { method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ threadId: activeId, task: '/' + cmd + ' ' + value }) });
+    await loadThreads();
+    await render();
+  }
+  // WALLET MODAL.
+  //
+  // Public addresses and balances only — /wallet proxies the proxy's own
+  // endpoint, which never exposes a key. Nothing here can move funds, and it
+  // must stay that way: this UI is served on a box reachable from a public
+  // *.proxy.runpod.net URL.
+  const walletOverlay = document.getElementById('walletOverlay');
+  const walletBody = document.getElementById('walletBody');
+  function walletRow(label, addr) {
+    const row = document.createElement('div');
+    row.className = 'wrow';
+    row.title = 'Click to copy';
+    const l = document.createElement('div'); l.className = 'wlab'; l.textContent = label;
+    const a = document.createElement('div'); a.className = 'waddr'; a.textContent = addr;
+    const c = document.createElement('div'); c.className = 'wcopy'; c.textContent = 'copy';
+    row.append(l, a, c);
+    // The whole row, not a 20px target. Copying a deposit address by hand is
+    // how funds go to the wrong chain.
+    row.addEventListener('click', async () => {
+      const ok = await copyText(addr);
+      c.textContent = ok ? 'copied' : 'select it';
+      setTimeout(() => { c.textContent = 'copy'; }, 1400);
+    });
+    return row;
+  }
+  async function openWallet() {
+    walletOverlay.classList.add('show');
+    walletBody.textContent = 'loading…';
+    let w = null;
+    try {
+      const r = await fetch(API + '/wallet');
+      // fetch does NOT reject on 4xx/5xx, and an older proxy returns an error
+      // body that parses fine into undefined fields — check ok AND the fields.
+      w = r.ok ? await r.json() : null;
+    } catch (e) { w = null; }
+    walletBody.innerHTML = '';
+    if (!w || (!w.solana && !w.evm)) {
+      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.';
+      walletBody.appendChild(p);
+      return;
+    }
+    if (w.solana) walletBody.appendChild(walletRow('Solana', w.solana));
+    if (w.evm) walletBody.appendChild(walletRow('Base / RH', w.evm));
+    if (w.balances) {
+      const b = document.createElement('div');
+      b.className = 'wbal';
+      b.textContent = w.balances;
+      walletBody.appendChild(b);
+    }
+    const note = document.createElement('div');
+    note.className = 'wnote';
+    // funded === false is the genuinely-empty case. Undefined means the proxy
+    // did not say, and guessing "empty" there would send someone to top up a
+    // wallet that is fine.
+    note.textContent = w.funded === false
+      ? 'This wallet is EMPTY — calls will fail with HTTP 402 until it is funded. ' + (w.funding || '')
+      : (w.funding || '');
+    if (w.funded === false) note.classList.add('wempty');
+    if (note.textContent.trim()) walletBody.appendChild(note);
+  }
+  // ASSETS UNLOCK. The passphrase lives in the input and in one fetch body and
+  // nowhere else — not in a variable that outlives the call, not in
+  // localStorage, and the field is cleared the moment it succeeds.
+  const assetsOverlay = document.getElementById('assetsOverlay');
+  const assetsPass = document.getElementById('assetsPass');
+  const assetsGo = document.getElementById('assetsGo');
+  const assetsMsg = document.getElementById('assetsMsg');
+  async function unlockAssets() {
+    const pass = assetsPass.value;
+    if (!pass) { assetsMsg.textContent = 'enter the passphrase'; return; }
+    assetsGo.disabled = true;
+    assetsGo.textContent = 'decrypting…';
+    assetsMsg.textContent = 'this takes a minute — 800MB';
+    try {
+      const r = await fetch(API + '/decrypt-assets', {
+        method: 'POST', headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ pass }),
+      });
+      const j = await r.json().catch(() => ({}));
+      if (j.ok) {
+        assetsPass.value = '';   // do not leave it sitting in the DOM
+        assetsMsg.textContent = j.already ? 'already unlocked' : ('unlocked — ' + j.files + ' files in /workspace/prooffront');
+        assetsMsg.className = 'wnote';
+      } else {
+        assetsMsg.textContent = j.error || ('failed (HTTP ' + r.status + ')');
+        assetsMsg.className = 'wnote wempty';
+      }
+    } catch (e) {
+      assetsMsg.textContent = 'could not reach the box';
+      assetsMsg.className = 'wnote wempty';
+    }
+    assetsGo.disabled = false;
+    assetsGo.textContent = 'decrypt';
+  }
+  assetsGo.addEventListener('click', unlockAssets);
+  assetsPass.addEventListener('keydown', (e) => { if (e.key === 'Enter') unlockAssets(); });
+  document.getElementById('assetsBtn').addEventListener('click', () => {
+    assetsOverlay.classList.add('show');
+    assetsMsg.textContent = '';
+    assetsMsg.className = 'wnote';
+    requestAnimationFrame(() => { try { assetsPass.focus(); } catch (e) {} });
+  });
+  assetsOverlay.addEventListener('click', (e) => {
+    // Clear on dismiss so a passphrase never lingers behind a closed modal.
+    if (e.target === assetsOverlay) { assetsPass.value = ''; assetsOverlay.classList.remove('show'); }
+  });
+
+  document.getElementById('walletBtn').addEventListener('click', openWallet);
+  // Click-outside and Escape both close it — a modal you can only dismiss one
+  // way is a modal people get stuck in.
+  walletOverlay.addEventListener('click', (e) => {
+    if (e.target === walletOverlay) walletOverlay.classList.remove('show');
+  });
+  document.addEventListener('keydown', (e) => {
+    if (e.key === 'Escape' && walletOverlay.classList.contains('show')) walletOverlay.classList.remove('show');
+    if (e.key === 'Escape' && assetsOverlay.classList.contains('show')) { assetsPass.value = ''; assetsOverlay.classList.remove('show'); }
+  });
+
+  document.getElementById('tierSel').addEventListener('change', (e) => setDial('tier', e.target.value));
+  document.getElementById('raceSel').addEventListener('change', (e) => setDial('race', e.target.value));
+
   // The toggle reflects the SERVER's value rather than local state — the mode
   // is per-thread and also settable by typing "/mode auto", so anything that
   // tracked it client-side would drift the moment either path was used.
@@ -1765,7 +3139,7 @@ const APP_HTML = `<!doctype html>
     setModeButtons(mode); // optimistic: the click should feel instant
     // Reuses the SAME "/mode" path the chat command takes, so there is one
     // implementation of the rule rather than a second one that can disagree.
-    await fetch('/drive', { method: 'POST', headers: { 'content-type': 'application/json' },
+    await fetch(API + '/drive', { method: 'POST', headers: { 'content-type': 'application/json' },
       body: JSON.stringify({ threadId: activeId, task: '/mode ' + mode }) });
     await loadThreads(); // refresh runMode + the confirmation line /mode appends
     await render();
@@ -1792,6 +3166,63 @@ const APP_HTML = `<!doctype html>
   // Block-level markdown: fenced code, tables, headings, lists. Models answer
   // in markdown by default, and rendering it as literal "## " and "| --- |"
   // made every structured answer unreadable.
+  /* Copy the given text, and say so. Returns true on success.
+
+     navigator.clipboard is NOT always available: it requires a secure context,
+     and grokui binds 0.0.0.0 inside a box, so reaching it by LAN IP (rather
+     than localhost or the RunPod https proxy) is plain http — where the API is
+     simply undefined. Falling back to execCommand keeps copy working there
+     instead of silently doing nothing, which is the worst outcome for a button
+     whose entire job is invisible. */
+  async function copyText(text) {
+    try {
+      if (navigator.clipboard && window.isSecureContext) {
+        await navigator.clipboard.writeText(text);
+        return true;
+      }
+    } catch (e) { /* fall through to the legacy path */ }
+    try {
+      const ta = document.createElement('textarea');
+      ta.value = text;
+      // Off-screen but focusable: display:none or visibility:hidden make
+      // execCommand('copy') a no-op in several browsers.
+      ta.style.cssText = 'position:fixed;top:-1000px;left:-1000px;opacity:0';
+      ta.setAttribute('readonly', '');
+      document.body.appendChild(ta);
+      ta.select();
+      ta.setSelectionRange(0, ta.value.length); // iOS needs the explicit range
+      const ok = document.execCommand('copy');
+      document.body.removeChild(ta);
+      return ok;
+    } catch (e) { return false; }
+  }
+
+  /* A copy button bound to a getter, not a value — RUN output and streaming
+     replies grow after the button is created, and a captured string would copy
+     a stale prefix. */
+  function copyBtn(getText, label) {
+    const b = document.createElement('button');
+    b.className = 'copybtn';
+    b.type = 'button';
+    b.textContent = label || 'copy';
+    b.title = 'Copy to clipboard';
+    b.addEventListener('click', async (e) => {
+      e.stopPropagation();
+      const ok = await copyText(String(getText() ?? ''));
+      b.textContent = ok ? 'copied' : 'press ⌘C';
+      b.classList.toggle('ok', ok);
+      if (!ok) {
+        // Last resort: select it so the keyboard shortcut works.
+        const sel = window.getSelection();
+        const r = document.createRange();
+        r.selectNodeContents(b.closest('.bubble, .runcard, .md-pre') || b);
+        sel.removeAllRanges(); sel.addRange(r);
+      }
+      setTimeout(() => { b.textContent = label || 'copy'; b.classList.remove('ok'); }, 1400);
+    });
+    return b;
+  }
+
   function renderMentions(text) {
     const fences = [];
     const src = String(text).replace(/\`\`\`([\\w-]*)\\n?([\\s\\S]*?)\`\`\`/g, (m, lang, code) => {
@@ -1866,6 +3297,9 @@ const APP_HTML = `<!doctype html>
       const cmdEl = document.createElement('div');
       cmdEl.className = 'runcmd';
       cmdEl.textContent = '$ ' + text;
+      // Copy WITHOUT the '$ ' prompt — pasting that into a shell is a syntax
+      // error, and this is the single most re-run thing in the UI.
+      cmdEl.appendChild(copyBtn(() => text, 'copy'));
       card.appendChild(cmdEl);
       if (run.status === 'pending') {
         const actions = document.createElement('div');
@@ -1878,12 +3312,12 @@ const APP_HTML = `<!doctype html>
         deny.textContent = 'Deny';
         approve.addEventListener('click', async () => {
           approve.disabled = true; deny.disabled = true;
-          await fetch('/threads/' + activeId + '/run/' + run.id + '/approve', { method: 'POST' });
+          await fetch(API + '/threads/' + activeId + '/run/' + run.id + '/approve', { method: 'POST' });
           render();
         });
         deny.addEventListener('click', async () => {
           approve.disabled = true; deny.disabled = true;
-          await fetch('/threads/' + activeId + '/run/' + run.id + '/deny', { method: 'POST' });
+          await fetch(API + '/threads/' + activeId + '/run/' + run.id + '/deny', { method: 'POST' });
           render();
         });
         actions.appendChild(approve);
@@ -1898,6 +3332,7 @@ const APP_HTML = `<!doctype html>
           const out = document.createElement('pre');
           out.className = 'runoutput';
           out.textContent = run.output;
+          out.appendChild(copyBtn(() => run.output, 'copy'));
           card.appendChild(out);
         }
       }
@@ -1919,6 +3354,20 @@ const APP_HTML = `<!doctype html>
       textEl.innerHTML = renderMentions(text);
       bubble.appendChild(textEl);
       row.appendChild(bubble);
+      // Copy the message SOURCE, not rendered HTML — markdown, code fences and
+      // directive lines are what people want back; innerText drops fences and
+      // mangles indentation.
+      row.appendChild(copyBtn(() => text, 'copy'));
+      for (const pre of textEl.querySelectorAll('.md-pre, pre')) {
+        pre.appendChild(copyBtn(() => {
+            // No regex here on purpose: this string lives inside a template
+            // literal, so an escape sequence is eaten before the browser sees
+            // it. A literal newline inside /.../ is a SyntaxError that kills
+            // the entire script — the sidebar renders empty and nothing works.
+            const t = pre.innerText;
+            return t.endsWith('copy') ? t.slice(0, -4).replace(/\\s+$/, '') : t;
+          }, 'copy'));
+      }
     }
     log.appendChild(row);
   }
@@ -2046,7 +3495,7 @@ const APP_HTML = `<!doctype html>
     pendingFiles = [];
     pendingImages = [];
     renderAttachChips();
-    await fetch('/drive', {
+    await fetch(API + '/drive', {
       method: 'POST', headers: { 'content-type': 'application/json' },
       body: JSON.stringify({ threadId: activeId, task: full, images }),
     });
@@ -2062,7 +3511,7 @@ const APP_HTML = `<!doctype html>
   let slashCmds = [];
   let slashHits = [];
   let slashSel = 0;
-  fetch('/slash-commands').then((r) => r.json()).then((c) => { slashCmds = c; }).catch(() => {});
+  fetch(API + '/slash-commands').then((r) => r.json()).then((c) => { slashCmds = c; }).catch(() => {});
 
   function slashOpen() { return slashMenu.classList.contains('show'); }
   function renderSlash() {
@@ -2175,7 +3624,7 @@ const APP_HTML = `<!doctype html>
     createRow.addEventListener('click', async () => {
       const name = composeInp.value.trim() || prompt('Bot name?');
       if (!name) return;
-      const t = await (await fetch('/threads', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ name }) })).json();
+      const t = await (await fetch(API + '/threads', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ name }) })).json();
       activeId = t.id;
       closeCompose();
       await loadThreads(); await render();
@@ -2197,7 +3646,7 @@ const APP_HTML = `<!doctype html>
       if (t) { activeId = t.id; closeCompose(); await loadThreads(); await render(); return; }
     }
     if (composeSel.length > 1) {
-      const t = await (await fetch('/threads/group', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ names: composeSel.map((c) => c.name) }) })).json();
+      const t = await (await fetch(API + '/threads/group', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ names: composeSel.map((c) => c.name) }) })).json();
       activeId = t.id;
       closeCompose();
       await loadThreads(); await render();
@@ -2225,6 +3674,48 @@ const APP_HTML = `<!doctype html>
   setInterval(tick, 1200);
 
   // --- cost HUD (ported from the Hammerspoon menu-bar widget, same source) ---
+  // RESTART GROKUI. box-boot supervises this process, so exiting IS the
+  // restart. Useful when a box is wedged or has a newer grokui on disk: it
+  // re-execs in seconds instead of costing a box respawn and a 349MB pull.
+  // It cannot change the version baked into the IMAGE — only the site's spawn
+  // path can — so it says restart, not update. Promising an upgrade it cannot
+  // deliver is how a UI teaches people to distrust it.
+  // Cmd/Ctrl+K -> search, the shortcut every chat app trains you to expect.
+  // Escape returns focus to the composer instead of leaving you stranded in
+  // a box you just cleared. Bound on keydown at the document so it works no
+  // matter which pane has focus.
+  document.addEventListener('keydown', (e) => {
+    const k = (e.key || '').toLowerCase();
+    if ((e.metaKey || e.ctrlKey) && k === 'k') {
+      e.preventDefault();
+      const el = document.getElementById('search');
+      if (el) { el.focus(); el.select(); }
+      return;
+    }
+    // Cmd/Ctrl+Enter sends from anywhere — useful when focus drifted into a
+    // RUN card or a copy button mid-thought.
+    if ((e.metaKey || e.ctrlKey) && k === 'enter') {
+      e.preventDefault();
+      try { submit(); } catch (err) { /* not ready */ }
+    }
+  });
+
+  const reloadBtn = document.getElementById('reloadBtn');
+  if (reloadBtn) {
+    reloadBtn.addEventListener('click', async () => {
+      reloadBtn.disabled = true;
+      reloadBtn.textContent = '\u2026';
+      try { await fetch(API + '/restart', { method: 'POST' }); } catch (e) { /* exit races the reply */ }
+      // Poll until it answers again — a fixed timeout either reloads into a
+      // dead port or waits long after it is already back.
+      for (let i = 0; i < 40; i++) {
+        await new Promise((r) => setTimeout(r, 500));
+        try { const r = await fetch(API + '/threads', { cache: 'no-store' }); if (r.ok) break; } catch (e) { /* still down */ }
+      }
+      location.reload();
+    });
+  }
+
   const hudBtn = document.getElementById('hudBtn');
   const hud = document.getElementById('hud');
   function usd(n) {
@@ -2238,7 +3729,7 @@ const APP_HTML = `<!doctype html>
       // fetched server-side by US (see /hud-summary below) — a renderer fetch
       // straight to localhost:8402 would work fine, but routing it through
       // our own backend keeps one fetch path if that ever needs to change.
-      const you = await (await fetch('/hud-summary')).json();
+      const you = await (await fetch(API + '/hud-summary')).json();
       const spent = Number(you.spentUsd) || 0;
       const cogs = Number(you.cogsUsd) || 0;
       const direct = Number(you.directUsd) || 0;
@@ -2293,6 +3784,111 @@ const APP_HTML = `<!doctype html>
 </body></html>`;
 
 const server = http.createServer((req, res) => {
+  // Deposit addresses for the wallet THIS box pays from. Server-side fetch for
+  // the same reason /hud-summary is: the browser cannot reach 127.0.0.1:8402
+  // inside the box. The proxy only ever returns PUBLIC addresses — the key
+  // never leaves /root/.openzoo/wallet.json.
+  if (req.method === 'GET' && req.url === '/wallet') {
+    (async () => {
+      let w = { error: 'proxy unreachable' };
+      try { w = await (await fetch(`${PROXY}/wallet`)).json(); }
+      catch { /* proxy not up yet — say so rather than render an empty modal */ }
+      res.writeHead(200, { 'content-type': 'application/json' });
+      res.end(JSON.stringify(w));
+    })();
+    return;
+  }
+
+  // UNLOCK THE BAKED ASSETS. The image ships ProofFront as ciphertext; this is
+  // where the operator supplies the passphrase that opens it.
+  //
+  // The passphrase is used and dropped: passed to openssl via an ENV VAR (never
+  // argv — a command line is world-readable in /proc), never written to disk,
+  // never logged, never stored on the thread. A wrong one is reported as wrong
+  // and nothing else happens.
+  //
+  // SAY WHAT THIS DOES: once decrypted the files are served by /api/files and
+  // /site like anything else in the workspace, and :8080 has no authentication.
+  // The lock protects the IMAGE, which is public. It does not protect a running
+  // box from anyone who knows its pod id.
+  if (req.method === 'POST' && req.url === '/decrypt-assets') {
+    const chunks = [];
+    req.on('data', (d) => chunks.push(d));
+    req.on('end', () => {
+      let pass = '';
+      try { pass = String(JSON.parse(Buffer.concat(chunks).toString('utf8')).pass || ''); } catch { /* ignore */ }
+      const done = (code, obj) => { res.writeHead(code, { 'content-type': 'application/json' }); res.end(JSON.stringify(obj)); };
+      if (!pass) return done(400, { ok: false, error: 'no passphrase' });
+      if (!existsSync('/opt/prooffront.enc')) return done(404, { ok: false, error: 'this image has no encrypted assets baked in' });
+      if (existsSync('/workspace/prooffront')) return done(200, { ok: true, already: true, note: 'already unlocked' });
+      // Same shape as box-boot: decrypt to temp, verify it is really a zip,
+      // then unpack and swap. Never unzip unverified plaintext into /workspace.
+      const script = 'set -e; '
+        + 'openssl enc -d -aes-256-cbc -pbkdf2 -iter 600000 -in /opt/prooffront.enc -out /tmp/pf.zip -pass env:OZ_PF_PASS 2>/dev/null; '
+        + 'head -c 2 /tmp/pf.zip | grep -q PK; '
+        + 'rm -rf /workspace/.pf.tmp; mkdir -p /workspace/.pf.tmp; '
+        + 'unzip -q /tmp/pf.zip -d /workspace/.pf.tmp; '
+        + 'mv /workspace/.pf.tmp /workspace/prooffront; '
+        + 'rm -f /tmp/pf.zip; '
+        + 'find /workspace/prooffront -type f | wc -l';
+      execFile('bash', ['-lc', script], { env: { ...process.env, OZ_PF_PASS: pass }, timeout: 600000, maxBuffer: 1 << 20 },
+        (err, stdout) => {
+          // Wipe the copy we were handed as soon as openssl is done with it.
+          pass = '';
+          if (err) return done(200, { ok: false, error: 'wrong passphrase, or the blob is corrupt' });
+          done(200, { ok: true, files: Number(String(stdout).trim()) || 0 });
+        });
+    });
+    return;
+  }
+
+  // Restart grokui in place — and ACTUALLY PICK UP THE NEW BUILD.
+  //
+  // Exiting is the restart: on a production box, box-server's ensureOz() poll
+  // notices :4173 is closed and relaunches. (box-boot.sh does NOT supervise
+  // grokui when OZ_UI_B64 is set — box-server owns it, and two supervisors is
+  // the EADDRINUSE bug this file was already fighting.)
+  //
+  // But relaunching alone upgrades NOTHING, and that was the real bug. It runs
+  // /workspace/.grokui/grokui.mjs, and box-server's seedFromImage() overwrites
+  // that only when it is MISSING, under 1KB, or a saved 429 page — a perfectly
+  // valid OLD copy is never replaced. /workspace is a persistent network
+  // volume, so the file a box seeded on its very first boot survived every
+  // restart and every fresh image pull, forever. Symptom: a new image lands,
+  // the box restarts fine, and the UI is byte-identical to the day it spawned.
+  //
+  // So copy the baked build over the workspace copy HERE, before exiting.
+  // Doing it in grokui rather than only in box-server is deliberate: box-server
+  // is injected at spawn, so a fix there reaches new boxes only. This reaches
+  // any box whose grokui can still serve one request.
+  if (req.method === 'POST' && req.url === '/restart') {
+    let seeded = null;
+    try {
+      // Only when they actually DIFFER — an unconditional copy would rewrite
+      // the file on every restart and make "did it upgrade?" unanswerable.
+      for (const f of ['grokui.mjs', 'podagent.mjs']) {
+        const baked = `/opt/grokui/${f}`;
+        const live = `/workspace/.grokui/${f}`;
+        if (!existsSync(baked)) continue;
+        const a = statSync(baked);
+        const b = existsSync(live) ? statSync(live) : null;
+        if (!b || a.size !== b.size) {
+          mkdirSync('/workspace/.grokui', { recursive: true });
+          copyFileSync(baked, live);
+          seeded = (seeded || 0) + 1;
+        }
+      }
+    } catch (e) {
+      // A read-only or missing /opt is a plain `docker run`, not a box. Restart
+      // is still worth doing; just do not claim an upgrade that did not happen.
+      seeded = null;
+    }
+    res.writeHead(200, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ ok: true, restarting: true, upgraded: seeded || 0 }));
+    setTimeout(() => process.exit(0), 150);
+    return;
+  }
+
   if (req.method === 'GET' && req.url === '/hud-summary') {
     (async () => {
       let you = { spentUsd: 0, cogsUsd: 0, directUsd: 0, paidCalls: 0 };
@@ -2338,9 +3934,41 @@ const server = http.createServer((req, res) => {
     res.end(JSON.stringify(SLASH_COMMANDS));
     return;
   }
+  // Search ACROSS MESSAGE BODIES, not just names. The sidebar only carries a
+  // 60-char preview, so a client-side filter can only match what is already on
+  // screen — useless for "which bot did the tetris contract". The server has
+  // every message, so it does the work and returns a hit count plus the
+  // matching line, and the client renders that instead of the preview.
+  if (req.method === 'GET' && req.url.startsWith('/search')) {
+    const q = (new URL(req.url, 'http://x').searchParams.get('q') || '').trim().toLowerCase();
+    res.writeHead(200, { 'content-type': 'application/json' });
+    if (!q) { res.end('[]'); return; }
+    const out = [];
+    for (const t of threads.values()) {
+      let hits = 0;
+      let snippet = '';
+      for (const h of t.history) {
+        const text = String(h.text || '');
+        if (!text.toLowerCase().includes(q)) continue;
+        hits += 1;
+        if (!snippet) {
+          // Centre the window on the match so the term is visible, rather than
+          // returning the first 60 chars of a message that matched at char 900.
+          const at = text.toLowerCase().indexOf(q);
+          const from = Math.max(0, at - 24);
+          snippet = (from ? '…' : '') + text.slice(from, from + 90).replace(/\s+/g, ' ');
+        }
+      }
+      const nameHit = t.name.toLowerCase().includes(q);
+      if (hits || nameHit) out.push({ id: t.id, name: t.name, color: t.color, hits, snippet });
+    }
+    out.sort((a, b) => b.hits - a.hits);
+    res.end(JSON.stringify(out));
+    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)));
+    res.end(JSON.stringify(orderedThreads().map(threadSummary)));
     return;
   }
   if (req.method === 'GET' && req.url.startsWith('/threads/')) {