openzoo 0.50.48 → 0.50.50

package/lib/cursorbackend.js

@@ -40,6 +40,8 @@ import { encodeAvailableModels, encodeForMethod, encodeEnsureSandBox, encodeGetG
 import {
   accountPodPath, accountAgentsPath, rosterForAccount, rosterForEvent,
   readHouseRoster, houseAgentsPath, shapeAgent, agentBrief, briefFromName,
+  readWakeups, writeWakeups, shapeWakeup, parseWakeupEvery, wantsWakeupCron,
+  DEFAULT_WAKEUP_PROMPT,
 } from './grokbotAccount.js';
 import { formatSpendFooter, mergeTurnProof } from './spendProof.js';
 import { prefixVisitorRichText } from './grokbotweb.js';
@@ -1181,10 +1183,132 @@ export function createZooTurnQueue() {
       inflight.delete(id);
       return 1;
     },
+    busy(agentId) {
+      return inflight.has(String(agentId || ''));
+    },
   };
 }
 const zooTurns = createZooTurnQueue();
 
+const wakeupTimers = new Map();
+let wakeupLog = () => {};
+let wakeupsRestored = false;
+
+function persistWakeups(map) {
+  try { writeWakeups(HOME, map); } catch (e) {
+    wakeupLog(`cursor-backend:      wakeups save failed: ${e.message}`);
+  }
+}
+
+export function listAgentWakeups() {
+  return readWakeups(HOME);
+}
+
+export function cancelAgentWakeup(agentId) {
+  const id = String(agentId || '');
+  const t = wakeupTimers.get(id);
+  if (t) {
+    clearTimeout(t);
+    wakeupTimers.delete(id);
+  }
+  const map = readWakeups(HOME);
+  if (!map[id]) return { ok: true, cancelled: false };
+  delete map[id];
+  persistWakeups(map);
+  return { ok: true, cancelled: true, id };
+}
+
+function armWakeup(rec) {
+  const id = rec.agentId;
+  const prev = wakeupTimers.get(id);
+  if (prev) clearTimeout(prev);
+  const delay = Math.max(1000, Number(rec.nextAt) - Date.now());
+  const t = setTimeout(() => {
+    fireAgentWakeup(id).catch((e) => wakeupLog(`cursor-backend:      wakeup fire ${id}: ${e.message}`));
+  }, delay);
+  wakeupTimers.set(id, t);
+}
+
+export function scheduleAgentWakeup(agentId, opts = {}) {
+  const id = String(agentId || '').trim();
+  if (!id) return { ok: false, error: 'no agent' };
+  const now = Date.now();
+  const every = opts.every ?? opts.everySec;
+  const rec = shapeWakeup(id, {
+    every,
+    prompt: opts.prompt,
+    lastAt: 0,
+    nextAt: now + parseWakeupEvery(every) * 1000,
+  }, now);
+  const map = readWakeups(HOME);
+  map[id] = rec;
+  persistWakeups(map);
+  armWakeup(rec);
+  wakeupLog(`cursor-backend:      wakeup every ${rec.everySec}s agent=${id}`);
+  return { ok: true, ...rec };
+}
+
+async function fireAgentWakeup(agentId) {
+  const id = String(agentId || '');
+  const map = readWakeups(HOME);
+  const rec = map[id];
+  if (!rec) {
+    wakeupTimers.delete(id);
+    return;
+  }
+  rec.lastAt = Date.now();
+  rec.nextAt = rec.lastAt + rec.everySec * 1000;
+  persistWakeups(map);
+  armWakeup(rec);
+  if (zooTurns.busy(id)) {
+    wakeupLog(`cursor-backend:      wakeup skip busy agent=${id}`);
+    return;
+  }
+  const nonce = `oz-wakeup-${id}-${rec.lastAt}`;
+  const prompt = rec.prompt || DEFAULT_WAKEUP_PROMPT;
+  const turn = zooTurns.begin(id, nonce);
+  const userLine = fanoutLine(id, 'user', `[wakeup]\n${prompt}`, { clientNonce: nonce, requestId: nonce });
+  ssePush('transcript', { ...gatewayEntry(userLine), agentId: id });
+  bumpAgent(id, { preview: '[wakeup]', notify: false });
+  wakeupLog(`cursor-backend:      wakeup start agent=${id}`);
+  try {
+    const z = await zooComplete(prompt, wakeupLog, id, {}, {
+      signal: turn.signal,
+      onProgress: (note) => {
+        if (!zooTurns.isCurrent(id, nonce)) return;
+        paintChatUpdate(id, note, { clientNonce: nonce, requestId: nonce });
+      },
+    });
+    if (!zooTurns.isCurrent(id, nonce)) return;
+    const line = fanoutLine(id, 'assistant', z.text, { clientNonce: nonce, requestId: nonce });
+    ssePush('transcript', { ...gatewayEntry(line), agentId: id });
+    bumpAgent(id, { preview: z.text, notify: true });
+    wakeupLog(`cursor-backend:      wakeup done agent=${id} seq=${line.seq}`);
+  } catch (e) {
+    if (!isSupersededError(e)) wakeupLog(`cursor-backend:      wakeup failed agent=${id}: ${e.message}`);
+  } finally {
+    zooTurns.end(id, nonce);
+  }
+}
+
+export function restoreAgentWakeups(log = () => {}) {
+  wakeupLog = log;
+  if (wakeupsRestored) return 0;
+  wakeupsRestored = true;
+  const map = readWakeups(HOME);
+  const ids = Object.keys(map);
+  const now = Date.now();
+  ids.forEach((id, i) => {
+    // Do not fire during Grok Bot boot. 10 parallel zoo turns + CDP on the
+    // spinner page left the window on a white disc. First tick is +90s.
+    map[id].nextAt = now + 90_000 + i * 4000;
+  });
+  if (ids.length) persistWakeups(map);
+  for (const id of ids) armWakeup(map[id]);
+  if (ids.length) log(`cursor-backend:      wakeups restored ${ids.length}`);
+  return ids.length;
+}
+
 export function formatZooProgress({ step, maxSteps, names, command } = {}) {
   const tools = Array.isArray(names) ? names.filter(Boolean).join(', ') : String(names || 'tools');
   const cmd = command ? ` ${JSON.stringify(String(command).slice(0, 80))}` : '';
@@ -1195,7 +1319,7 @@ export function formatZooProgress({ step, maxSteps, names, command } = {}) {
  *  bubble is still silence. Keep it short; the model history skips ephemeral. */
 export function formatZooToolLine({ name, args = {}, result } = {}) {
   const detail = args.command || args.path || args.name || args.window
-    || args.query || args.url || args.key || args.app
+    || args.query || args.url || args.key || args.app || args.every
     || (args.x != null && args.y != null ? `${args.x},${args.y}` : '')
     || (args.text != null ? String(args.text).slice(0, 80) : '');
   const head = detail
@@ -2003,6 +2127,34 @@ const LOCAL_TOOLS = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'schedule_wakeup',
+      description: 'Host timer that keeps this bot working with no human message. "never stop" / cron. Default every 5m. Min 60s. Does not spawn bots.',
+      parameters: {
+        type: 'object',
+        properties: {
+          every: { type: 'string', description: '5m, 1h, 90s. Default 5m. Floor 60s.' },
+          prompt: { type: 'string', description: 'What to do on each tick.' },
+          agent: { type: 'string', description: 'Name or id. Default: this bot.' },
+        },
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'cancel_wakeup',
+      description: 'Stop the host wakeup timer for this bot (or agent).',
+      parameters: {
+        type: 'object',
+        properties: {
+          agent: { type: 'string' },
+        },
+      },
+    },
+  },
 ];
 
 export const LOCAL_TOOL_NAMES = LOCAL_TOOLS.map((t) => t.function.name);
@@ -2151,8 +2303,12 @@ async function runLocalTool(name, args, log, ctx = {}) {
       const agent = mintLocalAgent({ name, brief });
       pushCreatedAgent(agent, { select: args.select !== false });
       seedBriefOnCanvas(agent);
+      const n = (cachedAgentList() || []).length;
       log(`cursor-backend:      create_agent tool id=${agent.id} name=${JSON.stringify(agent.name)} brief=${brief ? brief.length : 0}c`);
-      return JSON.stringify({ ok: true, id: agent.id, name: agent.name, brief: agent.brief || '' });
+      const warning = n >= 8
+        ? `Mac already has ${n} bots. Prefer schedule_wakeup over spawning. Only mint a NEW named role.`
+        : undefined;
+      return JSON.stringify({ ok: true, id: agent.id, name: agent.name, brief: agent.brief || '', warning });
     }
     if (name === 'set_brief') {
       const who = findAgent(args.agent || args.id || args.name) || findAgent(ctx.agentId);
@@ -2162,10 +2318,12 @@ async function runLocalTool(name, args, log, ctx = {}) {
     }
     if (name === 'list_agents') {
       const list = cachedAgentList() || [];
+      const wakes = readWakeups(HOME);
       return JSON.stringify(list.map((a) => ({
         id: a.id,
         name: a.name,
         brief: String(a.brief || '').slice(0, 120),
+        wakeup: wakes[a.id] ? { everySec: wakes[a.id].everySec, nextAt: wakes[a.id].nextAt } : null,
       })));
     }
     if (name === 'message_agent') {
@@ -2177,6 +2335,17 @@ async function runLocalTool(name, args, log, ctx = {}) {
         log,
       });
     }
+    if (name === 'schedule_wakeup') {
+      const who = findAgent(args.agent || args.id || args.name) || findAgent(ctx.agentId);
+      if (!who) return 'ERROR no such agent';
+      const got = scheduleAgentWakeup(who.id, { every: args.every, prompt: args.prompt });
+      return JSON.stringify(got);
+    }
+    if (name === 'cancel_wakeup') {
+      const who = findAgent(args.agent || args.id || args.name) || findAgent(ctx.agentId);
+      if (!who) return 'ERROR no such agent';
+      return JSON.stringify(cancelAgentWakeup(who.id));
+    }
     return `unknown tool ${name}`;
   } catch (e) {
     return `ERROR ${e.message}`;
@@ -2273,8 +2442,9 @@ async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
             return brief ? `${who} Standing brief (persisted): ${brief}` : who;
           })(),
           `You HAVE local tools on the user's computer via ${via}.`,
-          'Tools: read_file, write_file, exec, list_dir, screenshot, click, type_text, key, ui_tree, focus_app, open_url, create_agent, set_brief, list_agents, message_agent.',
+          'Tools: read_file, write_file, exec, list_dir, screenshot, click, type_text, key, ui_tree, focus_app, open_url, create_agent, set_brief, list_agents, message_agent, schedule_wakeup, cancel_wakeup.',
           'create_agent mints a sidebar bot. ALWAYS pass brief so they keep the job across restart. set_brief updates it. list_agents + message_agent talk to other bots (one hop). Do not tell the human to copy-paste between canvases.',
+          'NEVER STOP / cron / keep working between human messages: call schedule_wakeup every="5m". That is a host timer. There is no crontab. Do not spawn more bots for persistence. Do not re-read SITREP-NOW.md or STANDING-ORDERS.md every turn — do the next file or click. exec sysctl/uptime is not the job. If the tray already has named workers, answer "no" to spawning more.',
           'You CAN click the Mac and fill/submit browser forms. That is required when the user asks. Do not write a markdown briefing instead of clicking. Do not tell the user to click.',
           'Form loop: focus_app Brave Browser → screenshot → click the field (query or x,y) → type_text → screenshot to confirm → click Submit / key enter. screenshot.screen is click coordinate space. Prefer click query="Submit".',
           'screenshot captures the display and attaches the image. For any on-screen form, dashboard, or click target, screenshot first this turn. Do not guess at UI you have not seen.',
@@ -2805,6 +2975,10 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     log(`cursor-backend:      >> sendPrompt agent=${agentId} keys=${Object.keys(parsed).join(',')} attachments=${attN}${visitor ? ` visitor=${visitor.shortname}` : ''} prompt=${JSON.stringify((prompt || '').slice(0, 80))}`);
     lastSendEchoId = String(nonce);
     jsonSend(res, { accepted: true });
+    if (!visitor && wantsWakeupCron(prompt)) {
+      const cron = scheduleAgentWakeup(agentId, { every: '5m' });
+      log(`cursor-backend:      never-stop cron agent=${agentId} every=${cron.everySec}s`);
+    }
     const turn = zooTurns.begin(agentId, nonce);
     const userLine = fanoutLine(agentId, 'user', uiText, {
       clientNonce: nonce,
@@ -3013,6 +3187,7 @@ function respond(req, res, method, models) {
  * unprivileged). Returns { server, port }.
  */
 export function startCursorBackend({ port = 8443, models, log = () => {} } = {}) {
+  restoreAgentWakeups(log);
   const { cert, key } = ensureCert(log);
   const certPem = fs.readFileSync(cert);
   const keyPem = fs.readFileSync(key);

package/lib/grokbotAccount.js

@@ -184,6 +184,72 @@ export function rosterForEvent(list, activity) {
   });
 }
 
+export const WAKEUP_MIN_SEC = 60;
+export const WAKEUP_MAX_SEC = 6 * 3600;
+export const WAKEUP_DEFAULT_SEC = 5 * 60;
+export const DEFAULT_WAKEUP_PROMPT = 'Wakeup. Continue your brief. Do the next real action (write a file, click, or message a worker). Do not only re-read sitrep. Do not spawn more bots. Do not exec sysctl/uptime.';
+
+export function wakeupsPath(home) {
+  return path.join(home, '.openzoo', 'grokbot-wakeups.json');
+}
+
+/** "5m" / "1h" / "90" / "30s". Floor 60s so a never-stop cron cannot storm. */
+export function parseWakeupEvery(raw) {
+  const s = String(raw ?? '').trim().toLowerCase();
+  if (!s) return WAKEUP_DEFAULT_SEC;
+  const m = s.match(/^(\d+(?:\.\d+)?)\s*(s|sec|secs|seconds?|m|min|mins|minutes?|h|hr|hrs|hours?)?$/);
+  if (!m) return WAKEUP_DEFAULT_SEC;
+  const n = Number(m[1]);
+  if (!Number.isFinite(n) || n <= 0) return WAKEUP_DEFAULT_SEC;
+  const u = m[2] || 's';
+  let sec = n;
+  if (/^m/.test(u)) sec = n * 60;
+  else if (/^h/.test(u)) sec = n * 3600;
+  return Math.min(WAKEUP_MAX_SEC, Math.max(WAKEUP_MIN_SEC, Math.round(sec)));
+}
+
+export function wantsWakeupCron(prompt) {
+  const s = String(prompt || '');
+  if (/\bcron\b.{0,48}\bwakeups?\b/i.test(s)) return true;
+  if (/\bwakeups?\b.{0,48}\bcron\b/i.test(s)) return true;
+  if (/\bnever stop\b/i.test(s)) return true;
+  if (/\bschedule\b.{0,24}\bwakeups?\b/i.test(s)) return true;
+  return false;
+}
+
+export function shapeWakeup(agentId, rec = {}, now = Date.now()) {
+  const everySec = parseWakeupEvery(rec.everySec ?? rec.every ?? rec.interval);
+  const prompt = String(rec.prompt || DEFAULT_WAKEUP_PROMPT).trim().slice(0, 2000)
+    || DEFAULT_WAKEUP_PROMPT;
+  const lastAt = Number(rec.lastAt) || 0;
+  let nextAt = Number(rec.nextAt) || 0;
+  if (!Number.isFinite(nextAt) || nextAt <= 0) nextAt = now + everySec * 1000;
+  return {
+    agentId: String(agentId || rec.agentId || ''),
+    everySec,
+    prompt,
+    lastAt,
+    nextAt,
+  };
+}
+
+export function readWakeups(home) {
+  const raw = readJsonFile(wakeupsPath(home));
+  const src = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+  const out = {};
+  for (const [id, rec] of Object.entries(src)) {
+    const w = shapeWakeup(id, rec);
+    if (w.agentId) out[w.agentId] = w;
+  }
+  return out;
+}
+
+export function writeWakeups(home, map) {
+  const dir = path.dirname(wakeupsPath(home));
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(wakeupsPath(home), JSON.stringify(map || {}, null, 2));
+}
+
 export function callerKeyFromAuth(authorization) {
   const a = String(authorization || '').trim();
   if (!a) return '';

package/lib/grokcli.js

@@ -110,7 +110,7 @@ const GROK_BOT_BIN = `${APP}/Contents/MacOS/Grok Bot`;
 /** pids whose command is the Grok Bot main binary (not grep itself). */
 export function grokBotPids(run = execSync) {
   try {
-    return run(`pgrep -f ${JSON.stringify(GROK_BOT_BIN)}`, { encoding: 'utf8' })
+    return run(`pgrep -f ${JSON.stringify(GROK_BOT_BIN)}`, { encoding: 'utf8', shell: true })
       .trim().split('\n').map((s) => s.trim()).filter(Boolean);
   } catch {
     return [];
@@ -296,7 +296,7 @@ export async function runBot(argv = []) {
     await new Promise((r) => setTimeout(r, 1500));
   }
 
-  if (plan.spawn) {
+  const launchGrokBot = () => {
     console.error('openzoo: launching Grok Bot');
     console.error(`         CURSOR_API_BASE_URL=${url}`);
     spawn(bin, grokBotChromiumArgs(), {
@@ -315,14 +315,14 @@ export async function runBot(argv = []) {
         SAND_HOST_GATEWAY_NETWORK_TOKEN: 'openzoo',
       },
     }).unref();
-  } else {
-    console.error('openzoo: Grok Bot already hijacked — not spawning another copy');
-  }
+  };
+  if (plan.spawn) launchGrokBot();
+  else console.error('openzoo: Grok Bot already hijacked — not spawning another copy');
 
   injectSpendChipInBackground({
     port: GROKBOT_CDP_PORT,
     log: (m) => console.error(m),
-    delayMs: plan.spawn ? 500 : 200,
+    delayMs: plan.spawn ? 8000 : 2000,
   });
 
   console.error('openzoo: leave this running. ctrl-c stops the backend.');

package/lib/ozSpendChip.js

@@ -7,9 +7,27 @@
  */
 import net from 'node:net';
 import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spendChipLabel } from './spendProof.js';
 
 export const GROKBOT_CDP_PORT = Number(process.env.OZ_GROKBOT_CDP_PORT || 9444);
 
+/** Session totals for a floating pill when the open canvas has no footer. */
+export function sessionSpendLabel(home = os.homedir()) {
+  try {
+    const s = JSON.parse(fs.readFileSync(path.join(home, '.openzoo', 'session.json'), 'utf8'));
+    const spent = Number(s.spentUsd || s.spendUsd || 0);
+    const would = Number(s.directUsd || 0);
+    const saved = Number(s.savedUsd != null ? s.savedUsd : Math.max(0, would - spent));
+    if (!(spent > 0.00005)) return '';
+    return spendChipLabel({ spent, would, saved, pct: would > 0 ? (100 * saved) / would : 0 });
+  } catch {
+    return '';
+  }
+}
+
 export function grokBotChromiumArgs(port = GROKBOT_CDP_PORT) {
   return [
     '--ignore-certificate-errors',
@@ -133,9 +151,12 @@ export function spendOnlyText(t) {
 }
 
 function ozEnsureSpendCss() {
-  if (document.getElementById('oz-spend-css')) return;
-  const s = document.createElement('style');
-  s.id = 'oz-spend-css';
+  let s = document.getElementById('oz-spend-css');
+  if (!s) {
+    s = document.createElement('style');
+    s.id = 'oz-spend-css';
+    (document.head || document.documentElement).appendChild(s);
+  }
   s.textContent = [
     '.oz-spend{margin:.55rem 0 0;font-size:12px;color:inherit;opacity:.82;max-width:36em}',
     '.oz-spend>summary{cursor:help;list-style:none;display:inline-flex;align-items:center;gap:.35rem;',
@@ -144,8 +165,9 @@ function ozEnsureSpendCss() {
     '.oz-spend>summary::-webkit-details-marker{display:none}',
     '.oz-spend-body{white-space:pre-wrap;margin:.55rem 0 0;font-size:11px;line-height:1.45;opacity:.88;overflow-wrap:anywhere}',
     '[data-oz-spend-hide]{display:none!important}',
+    'button[aria-label="Start voice input"],button[aria-label*="voice input" i],',
+    'button[aria-label*="steminvoer" i],button[aria-label^="Microphone"]{display:none!important}',
   ].join('');
-  (document.head || document.documentElement).appendChild(s);
 }
 
 function ozSpendHost(el) {
@@ -292,6 +314,52 @@ function ozCollapseSpend() {
     ozAttachSpendChip(host, split);
   }
   ozHideSpendLeftovers();
+  ozEnsureFloatSpend();
+}
+
+function ozEnsureFloatSpend() {
+  const label = String(window.__OZ_SESSION_SPEND__ || '').trim();
+  const msgPills = document.querySelectorAll('.oz-spend:not(#oz-spend-float)').length;
+  let el = document.getElementById('oz-spend-float');
+  if (!label || msgPills) {
+    if (el) el.remove();
+    return;
+  }
+  ozEnsureSpendCss();
+  if (!el) {
+    el = document.createElement('details');
+    el.id = 'oz-spend-float';
+    el.className = 'oz-spend';
+    const sum = document.createElement('summary');
+    const body = document.createElement('div');
+    body.className = 'oz-spend-body';
+    body.textContent = 'session spend (this openzoo bot)';
+    el.appendChild(sum);
+    el.appendChild(body);
+    document.body.appendChild(el);
+  }
+  ozPlaceFloat(el);
+  const sum = el.querySelector('summary');
+  if (sum) sum.textContent = 'ⓘ ' + label;
+}
+
+function ozPlaceFloat(el) {
+  if (!el) return;
+  const ta = document.querySelector('textarea, [contenteditable="true"]');
+  const box = ta && ta.getBoundingClientRect();
+  el.style.position = 'fixed';
+  el.style.right = 'auto';
+  el.style.zIndex = '2147483646';
+  el.style.opacity = '0.95';
+  if (box && box.width > 80 && box.top > 48) {
+    el.style.left = Math.round(box.left) + 'px';
+    el.style.top = Math.round(Math.max(8, box.top - 56)) + 'px';
+    el.style.bottom = 'auto';
+  } else {
+    el.style.left = '96px';
+    el.style.bottom = '72px';
+    el.style.top = 'auto';
+  }
 }
 
 function ozWatchSpend() {
@@ -305,14 +373,27 @@ function ozWatchSpend() {
     else document.addEventListener('DOMContentLoaded', start);
   } catch { /* */ }
   setInterval(run, 1500);
+  try { window.addEventListener('resize', run); } catch (e) {}
 }
 
 export function spendChipSource() {
   return [
     '(function ozSpendChip(){',
     "'use strict';",
-    'if (window.__OZ_SPEND_CHIP__ === 4) return;',
-    'window.__OZ_SPEND_CHIP__ = 4;',
+    'if (window.__OZ_SPEND_CHIP__ === 10) {',
+    '  const el = document.getElementById("oz-spend-float");',
+    '  const ta = document.querySelector("textarea, [contenteditable=\\"true\\"]");',
+    '  const box = ta && ta.getBoundingClientRect();',
+    '  if (el && box && box.width > 80) {',
+    '    el.style.position = "fixed";',
+    '    el.style.left = Math.round(box.left) + "px";',
+    '    el.style.top = Math.round(Math.max(8, box.top - 56)) + "px";',
+    '    el.style.right = "auto";',
+    '    el.style.bottom = "auto";',
+    '  }',
+    '  return;',
+    '}',
+    'window.__OZ_SPEND_CHIP__ = 10;',
     chipUsd.toString(),
     labelFromSpendBody.toString(),
     spendLinesOnly.toString(),
@@ -327,6 +408,8 @@ export function spendChipSource() {
     ozPreviousMessageCard.toString(),
     ozAttachSpendChip.toString(),
     ozCollapseSpend.toString(),
+    ozEnsureFloatSpend.toString(),
+    ozPlaceFloat.toString(),
     ozWatchSpend.toString(),
     'ozWatchSpend();',
     '})();',
@@ -511,12 +594,24 @@ export async function listCdpPages(port, fetchImpl = fetch) {
   return [];
 }
 
-async function injectTarget(target, source, connect) {
+async function injectTarget(target, source, connect, { waitForUi = false } = {}) {
   const session = await connect(target.webSocketDebuggerUrl);
   try {
     await session.send('Page.enable').catch(() => {});
     await session.send('Runtime.enable').catch(() => {});
     await session.send('Page.addScriptToEvaluateOnNewDocument', { source }).catch(() => {});
+    if (waitForUi) {
+      for (let i = 0; i < 32; i += 1) {
+        try {
+          const r = await session.send('Runtime.evaluate', {
+            expression: '!!document.querySelector(\'[class*="sand-"], textarea, [contenteditable="true"]\')',
+            returnByValue: true,
+          });
+          if (r?.result?.value) break;
+        } catch { /* still booting */ }
+        await new Promise((ok) => setTimeout(ok, 250));
+      }
+    }
     await session.send('Runtime.evaluate', { expression: source, awaitPromise: false });
   } finally {
     session.close();
@@ -531,6 +626,7 @@ export async function injectSpendChip({
   connect = cdpSession,
   tries = 40,
   delayMs = 400,
+  waitForUi = false,
 } = {}) {
   let targets = [];
   for (let i = 0; i < Math.max(1, tries); i += 1) {
@@ -542,10 +638,12 @@ export async function injectSpendChip({
     log(`openzoo: spend chip CDP :${port} has no pages yet`);
     return { ok: false, injected: 0 };
   }
+  const label = sessionSpendLabel();
+  const src = `window.__OZ_SESSION_SPEND__=${JSON.stringify(label)};\n${source}`;
   let injected = 0;
   for (const t of targets) {
     try {
-      await injectTarget(t, source, connect);
+      await injectTarget(t, src, connect, { waitForUi });
       injected += 1;
     } catch (e) {
       log(`openzoo: spend chip inject ${e.message}`);
@@ -555,11 +653,23 @@ export async function injectSpendChip({
   return { ok: injected > 0, injected };
 }
 
-/** Fire-and-forget wrapper used by `openzoo bot`. */
+/** One CDP attach, then drop the debugger. A loop here pauses the renderer
+ *  so the composer accepts a keystroke and then dies. Reloads pick the chip
+ *  up via Page.addScriptToEvaluateOnNewDocument from that single inject. */
 export function injectSpendChipInBackground(opts = {}) {
   const log = opts.log || ((m) => console.error(m));
-  injectSpendChip({ ...opts, log }).catch((e) => {
-    log(`openzoo: spend chip inject failed ${e.message}`);
-  });
+  const wait = Math.max(0, Number(opts.delayMs) || 400);
+  setTimeout(() => {
+    injectSpendChip({
+      tries: 24,
+      delayMs: 400,
+      waitForUi: true,
+      ...opts,
+      log,
+      connect: (ws) => cdpSession(ws, { timeoutMs: 2500 }),
+    }).catch((e) => {
+      log(`openzoo: spend chip inject failed ${e.message}`);
+    });
+  }, wait);
 }
 

package/package.json

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