openzoo 0.50.96 → 0.50.98

package/lib/cursorbackend.js

@@ -33,20 +33,24 @@ import os from 'node:os';
 import path from 'node:path';
 import zlib from 'node:zlib';
 import { execFileSync, execFile } from 'node:child_process';
+import { createRequire } from 'node:module';
 import { promisify } from 'node:util';
 import tls from 'node:tls';
-import { randomUUID } from 'node:crypto';
-import { encodeAvailableModels, encodeForMethod, encodeEnsureSandBox, encodeGetGrokBotSendStatus, decodeProtoFields, unwrapConnect } from './cursorapi.js';
+import { randomUUID, generateKeyPairSync, createPrivateKey, sign as cryptoSign } from 'node:crypto';
+import { encodeAvailableModels, encodeForMethod, encodeEnsureSandBox, encodeGetGrokBotSendStatus, decodeProtoFields, unwrapConnect, fakeCursorAuthReply } from './cursorapi.js';
 import {
   accountPodPath, accountAgentsPath, rosterForAccount, rosterForEvent,
   readHouseRoster, houseAgentsPath, shapeAgent, agentBrief, briefFromName,
   preferNamedAgent, looksLikeAgentId,
+  grokroomAgentId, grokroomMemberId, grokroomShareUrl, grokroomFromHandle, grokroomAddrFromShare,
+  agentShareUrl, groupShareState, attachOnchainRoom, bindOnchainRoom,
+  isGrokRoomAgent, isGrokRoomMember,
   readWakeups, writeWakeups, shapeWakeup, parseWakeupEvery, wantsWakeupCron,
   DEFAULT_WAKEUP_PROMPT, addDeletedIds, filterDeleted,
 } from './grokbotAccount.js';
 import { spendChipLabel, formatSpendFooter, mergeTurnProof } from './spendProof.js';
 import { spendLinesOnly, writeSpendHud } from './ozSpendChip.js';
-import { zooModelIds, zooModelRow, mediaKindOf } from './models.js';
+import { zooModelIds, zooModelRow, mediaKindOf, resolveModel } from './models.js';
 import { prefixVisitorRichText } from './grokbotweb.js';
 import {
   ingestUpload, lookupUpload, readUploadChunk, readUploadImage, readUploadText,
@@ -66,11 +70,36 @@ const CURSOR_HOSTS = ['api2.cursor.sh', 'api3.cursor.sh', 'api4.cursor.sh', 'rep
 // handshake before ALPN — logged as `HANDSHAKE FAILED ECONNRESET alpn=?`, with
 // no request ever reaching us. Same cert, one more pair of names.
 const ANTHROPIC_TLS_HOSTS = ['api.anthropic.com', 'api-staging.anthropic.com'];
-const TLS_HOSTS = [...CURSOR_HOSTS, ...ANTHROPIC_TLS_HOSTS];
+const TLS_DNS = [...CURSOR_HOSTS, ...ANTHROPIC_TLS_HOSTS, 'localhost'];
+const TLS_IPS = ['127.0.0.1'];
+const TLS_HOSTS = [...TLS_DNS, ...TLS_IPS];
 
-/** Generate (once) a self-signed cert covering every host we impersonate. openssl
- *  is on every mac/linux; this is the only external tool and it is not a trust op. */
-export function ensureCert(log = () => {}) {
+/** Node-only self-signed PEM. Windows has no openssl in PATH (measured 2026-09-03).
+ *  selfsigned@5 `generate` is async. */
+export async function mintTlsPems() {
+  const selfsigned = createRequire(import.meta.url)('selfsigned');
+  const pems = await selfsigned.generate(
+    [{ name: 'commonName', value: 'api2.cursor.sh' }],
+    {
+      keySize: 2048,
+      days: 3650,
+      algorithm: 'sha256',
+      extensions: [{
+        name: 'subjectAltName',
+        altNames: [
+          ...TLS_DNS.map((value) => ({ type: 2, value })),
+          ...TLS_IPS.map((ip) => ({ type: 7, ip })),
+        ],
+      }],
+    },
+  );
+  if (!pems?.cert || !pems?.private) throw new Error('selfsigned returned empty pem');
+  return { cert: pems.cert, key: pems.private };
+}
+
+/** Generate (once) a self-signed cert covering every host we impersonate.
+ *  Mint with the `selfsigned` package (no openssl). openssl is a fallback only. */
+export async function ensureCert(log = () => {}) {
   const cert = path.join(TLS_DIR, 'cert.pem');
   const key = path.join(TLS_DIR, 'key.pem');
   // STALE-CERT INVALIDATION. A plain existence check meant anyone who had ever
@@ -85,12 +114,19 @@ export function ensureCert(log = () => {}) {
     log('cursor-tls: cert predates the current host list — re-minting');
   } catch { /* make it */ }
   fs.mkdirSync(TLS_DIR, { recursive: true });
-  const san = `subjectAltName=${TLS_HOSTS.map((h) => `DNS:${h}`).join(',')}`;
-  execFileSync('openssl', [
-    'req', '-x509', '-newkey', 'rsa:2048', '-nodes',
-    '-keyout', key, '-out', cert, '-days', '3650',
-    '-subj', '/CN=api2.cursor.sh', '-addext', san,
-  ], { stdio: 'ignore' });
+  try {
+    const pems = await mintTlsPems();
+    fs.writeFileSync(key, pems.key);
+    fs.writeFileSync(cert, pems.cert);
+  } catch (e) {
+    const san = `subjectAltName=${TLS_DNS.map((h) => `DNS:${h}`).join(',')},${TLS_IPS.map((h) => `IP:${h}`).join(',')}`;
+    execFileSync('openssl', [
+      'req', '-x509', '-newkey', 'rsa:2048', '-nodes',
+      '-keyout', key, '-out', cert, '-days', '3650',
+      '-subj', '/CN=api2.cursor.sh', '-addext', san,
+    ], { stdio: 'ignore' });
+    log(`cursor-tls: openssl fallback (${e.message})`);
+  }
   fs.writeFileSync(stamp, want);
   log(`cursor-tls: self-signed cert minted at ${TLS_DIR} covering ${TLS_HOSTS.length} hosts (no CA, no trust prompt)`);
   return { cert, key };
@@ -652,10 +688,10 @@ async function fetchEnsureSandBox(req, body, log) {
   try {
     const remote = await podJson('/api/listAgents', {}, log);
     if (Array.isArray(remote) && remote.length) {
-      const merged = rosterForEvent(mergeAgentLists(remote), agentActivity);
+      const merged = rosterForEvent(mergeAgentLists(remote), agentActivity, { includeHidden: true }); // GROKROOM-HIDDEN-BOTS
       saveAgents(merged);
       const active = focusedAgentId || merged[0]?.id;
-      ssePush('agents', { agents: merged, activeAgentId: active });
+      ssePush('agents', { agents: merged.filter((a) => !a.hidden), activeAgentId: active }); // GROKROOM-HIDDEN-BOTS
       log(`cursor-backend:      discovered roster n=${merged.length} account=${realPod.accountId}`);
     }
   } catch (e) {
@@ -837,9 +873,9 @@ async function proxyPodHttp(req, res, full, body, log) {
       try {
         const parsed = JSON.parse(String(inflateBody(cap.buf, cap.respHeaders)));
         if (Array.isArray(parsed)) {
-          const merged = rosterForEvent(mergeAgentLists(parsed), agentActivity);
+          const merged = rosterForEvent(mergeAgentLists(parsed), agentActivity, { includeHidden: true }); // GROKROOM-HIDDEN-BOTS
           saveAgents(merged);
-          jsonSend(res, merged);
+          jsonSend(res, merged.filter((a) => !a.hidden)); // GROKROOM-HIDDEN-BOTS
           log(`cursor-backend:      listAgents 200 merged n=${merged.length} account=${activeAccountId || '?'}`);
           return true;
         }
@@ -942,7 +978,7 @@ function sortAgentsByActivity(list) {
     return ay - ax;
   });
 }
-function bumpAgent(id, { preview = '', notify = true } = {}) {
+function bumpAgent(id, { preview = '', notify = true, select = true } = {}) {
   const now = Date.now();
   const a = agentActivity.get(id) || { unreadCount: 0 };
   a.updatedAt = now;
@@ -960,7 +996,7 @@ function bumpAgent(id, { preview = '', notify = true } = {}) {
   if (idx >= 0) list[idx] = agent;
   else list.unshift(agent);
   saveAgents(sortAgentsByActivity(list.map(shapeAgent)));
-  pushCreatedAgent(agent);
+  pushCreatedAgent(agent, { select });
 }
 
 /** asar ingestAgentsEvent does Ae.agents.map — `{action:"created"}` has no
@@ -972,7 +1008,7 @@ function pushCreatedAgent(agent, { select = true } = {}) {
   const active = focusedAgentId || agent.id;
   const list = rosterForEvent(cachedAgentList() || [], agentActivity);
   ssePush('agent-upserted', { agent, activeAgentId: active });
-  ssePush('agents', { agents: list, activeAgentId: active });
+  ssePush('agents', { agents: list.filter((a) => !a.hidden), activeAgentId: active }); // GROKROOM-HIDDEN-BOTS
 }
 
 /** Grok Bot Helper daemon: GET /local-exec/requests is SSE, POST /local-exec/responses
@@ -987,6 +1023,54 @@ function localExecPush(frame) {
     try { c.write(chunk); } catch { localExecSse.delete(c); }
   }
 }
+/** Helper builds disagree about where the shell output lives: top-level
+ *  `stdout` on some, `message: {stdout, exitCode}` or `clientMessage` on
+ *  others. Dig it out as TEXT — an object that reaches the canvas paints as
+ *  [object Object] (measured: `→ exec "ls" [object Object]` on Linux). */
+export function normalizeExecFrame(frame) {
+  const out = { stdout: '', stderr: '', exitCode: undefined, message: '', error: '' };
+  const seen = new Set();
+  const pick = (node, keys) => {
+    for (const k of keys) if (typeof node[k] === 'string' && node[k]) return node[k];
+    return '';
+  };
+  const visit = (node, depth) => {
+    if (!node || typeof node !== 'object' || depth > 4 || seen.has(node)) return;
+    seen.add(node);
+    if (!out.stdout) out.stdout = pick(node, ['stdout', 'stdOut', 'output']);
+    if (!out.stderr) out.stderr = pick(node, ['stderr', 'stdErr']);
+    if (!out.message) out.message = pick(node, ['message', 'text', 'content']);
+    if (!out.error) out.error = pick(node, ['error', 'errorMessage']);
+    if (out.exitCode == null) {
+      for (const k of ['exitCode', 'exit_code', 'code']) {
+        if (typeof node[k] === 'number') { out.exitCode = node[k]; break; }
+      }
+    }
+    for (const k of ['message', 'clientMessage', 'serverMessage', 'result', 'data', 'payload', 'body', 'throw']) {
+      visit(node[k], depth + 1);
+    }
+  };
+  visit(frame, 0);
+  if (out.error) out.error = `local-exec: ${out.error}`;
+  if (!out.stdout && !out.stderr && !out.message && !out.error) out.message = toolResultText(frame);
+  return out;
+}
+
+/** The daemon streams `output`/`stdout` chunks and only then closes with
+ *  `result`/`exit`, and those streaming frames do not always echo requestId.
+ *  Keying purely on requestId dropped the body on the floor and waited out the
+ *  45s timeout, so fall back to the sole in-flight request. */
+function localExecWaiterFor(f) {
+  if (f.requestId && localExecWaiters.has(f.requestId)) {
+    return { id: f.requestId, w: localExecWaiters.get(f.requestId) };
+  }
+  if (!f.requestId && localExecWaiters.size === 1) {
+    const [id, w] = localExecWaiters.entries().next().value;
+    return { id, w };
+  }
+  return null;
+}
+
 function handleLocalExecFrames(frames, log) {
   for (const f of frames || []) {
     if (!f || typeof f !== 'object') continue;
@@ -994,24 +1078,59 @@ function handleLocalExecFrames(frames, log) {
       localExecHello = f;
       log(`cursor-backend:      local-exec hello computer=${f.computerId || f.label || '?'} root=${f.localRoot || '?'}`);
     }
-    const w = f.requestId && localExecWaiters.get(f.requestId);
-    if (!w) continue;
+    const hit = localExecWaiterFor(f);
+    if (!hit) continue;
+    const { id, w } = hit;
     if (f.kind === 'file') {
       const buf = Buffer.from(f.bytesBase64 || '', 'base64');
       w.resolve({ kind: 'file', bytes: buf, text: buf.toString('utf8') });
-      localExecWaiters.delete(f.requestId);
+      localExecWaiters.delete(id);
     } else if (f.kind === 'file-error' || f.kind === 'messages-error') {
       w.reject(new Error(f.error || 'local-exec error'));
-      localExecWaiters.delete(f.requestId);
-    } else if (f.kind === 'client' || f.kind === 'control' || f.kind === 'result' || f.kind === 'exec-result') {
+      localExecWaiters.delete(id);
+    } else if (f.kind === 'output' || f.kind === 'stdout' || f.kind === 'stderr') {
+      const norm = normalizeExecFrame(f);
+      const chunk = norm.stdout || norm.message
+        || (typeof f.data === 'string' ? f.data : '')
+        || (typeof f.chunk === 'string' ? f.chunk : '');
+      if (f.kind === 'stderr') w.stderr += toolResultText(chunk);
+      else w.chunks += toolResultText(chunk);
+    } else if (shellStreamOf(f)) {
+      // The real Grok Bot lane: stdout/stderr arrive as many `kind:"client"`
+      // frames and the turn is only over on `exit`. Resolving on the first one
+      // (what the old client/control branch did) truncated every command to its
+      // first chunk.
+      const ss = shellStreamOf(f);
+      if (typeof ss.stdout?.data === 'string') w.chunks += ss.stdout.data;
+      if (typeof ss.stderr?.data === 'string') w.stderr += ss.stderr.data;
+      if (ss.exit) {
+        w.resolve({
+          kind: 'exit',
+          message: w.chunks || w.stderr,
+          stdout: w.chunks,
+          stderr: w.stderr,
+          exitCode: Number(ss.exit.code || 0),
+        });
+        localExecWaiters.delete(id);
+      }
+    } else if (f.kind === 'control' && f.message && f.message.heartbeat) {
+      // 3s keepalive while a long command runs. It is a `control` frame like
+      // any other, so the generic branch below used to resolve the call with an
+      // empty body the moment the daemon first breathed.
+      continue;
+    } else if (f.kind === 'client' || f.kind === 'control' || f.kind === 'result'
+      || f.kind === 'exec-result' || f.kind === 'exit') {
+      const norm = normalizeExecFrame(f);
+      const stdout = w.chunks + (norm.stdout || '');
+      const stderr = w.stderr + (norm.stderr || '');
       w.resolve({
         kind: f.kind,
-        message: f.message || f.text || f.stdout || JSON.stringify(f),
-        stdout: f.stdout,
-        stderr: f.stderr,
-        exitCode: f.exitCode,
+        message: norm.error || norm.message || stdout || toolResultText(f),
+        stdout,
+        stderr: norm.error && !stderr ? norm.error : stderr,
+        exitCode: norm.exitCode,
       });
-      localExecWaiters.delete(f.requestId);
+      localExecWaiters.delete(id);
     }
   }
 }
@@ -1024,6 +1143,8 @@ function localExecAsk(frame, timeoutMs = 45000) {
       reject(new Error('local-exec timeout — is Grok Bot Helper connected?'));
     }, timeoutMs);
     localExecWaiters.set(requestId, {
+      chunks: '',
+      stderr: '',
       resolve: (v) => { clearTimeout(t); resolve(v); },
       reject: (e) => { clearTimeout(t); reject(e); },
     });
@@ -1156,6 +1277,7 @@ function appendLine(agentId, role, text, extra = {}) {
       requestId,
       ...(extra.author && typeof extra.author === 'object' ? { author: extra.author } : {}),
       ...(extra.ephemeral ? { ephemeral: true } : {}),
+      ...(extra.sig ? { sig: String(extra.sig) } : {}),
     };
   }
   t.entries.push(e);
@@ -1332,6 +1454,14 @@ export function formatZooProgress({ step, maxSteps, names, command } = {}) {
 
 /** One canvas line per tool. Asar ingest is append-only — mutating a working
  *  bubble is still silence. Keep it short; the model history skips ephemeral. */
+export function toolResultText(result) {
+  if (result == null) return '';
+  if (typeof result === 'string') return result;
+  if (typeof result === 'number' || typeof result === 'boolean') return String(result);
+  if (Buffer.isBuffer(result)) return result.toString('utf8');
+  try { return JSON.stringify(result); } catch { return String(result); }
+}
+
 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.every
@@ -1340,7 +1470,7 @@ export function formatZooToolLine({ name, args = {}, result } = {}) {
   const head = detail
     ? `${name} ${JSON.stringify(String(detail).slice(0, 90))}`
     : String(name || 'tool');
-  let tail = String(result || '').replace(/\s+/g, ' ').trim();
+  let tail = toolResultText(result).replace(/\s+/g, ' ').trim();
   if (tail.startsWith('{')) {
     try {
       const o = JSON.parse(String(result));
@@ -1452,6 +1582,7 @@ function kickBriefedAgent(agent, log = () => {}) {
 
 function seedBriefOnCanvas(agent, log) {
   if (!agent?.id || !String(agent.brief || '').trim()) return false;
+  if (isGrokRoomAgent(agent) || isGrokRoomMember(agent)) return false;
   const t = agentTranscript(agent.id);
   if (!(t.entries || []).length) {
     const nonce = `oz-brief-${agent.id}`;
@@ -1472,6 +1603,7 @@ let payNudged = false;
 /** The terminal banner, on the canvas too: a new user reads the chat, not the shell. */
 async function seedPayNudge(list, activeId, log = () => {}) {
   if (payNudged || !activeId) return false;
+  if (isGrokRoomAgent({ id: activeId }) || /^roombot-/.test(String(activeId))) return false;
   payNudged = true;
   try {
     const t = agentTranscript(activeId);
@@ -1494,6 +1626,7 @@ async function seedPayNudge(list, activeId, log = () => {}) {
 let shipNudged = false;
 function seedShipNudge(list, activeId) {
   if (shipNudged || !activeId) return false;
+  if (isGrokRoomAgent({ id: activeId }) || /^roombot-/.test(String(activeId))) return false;
   const roster = Array.isArray(list) ? list : [];
   if (roster.some((a) => /^firstmate$/i.test(String(a?.name || '')))) { shipNudged = true; return false; }
   const t = agentTranscript(activeId);
@@ -1514,6 +1647,25 @@ function groupMemberRecords(agentId) {
   return groupMemberIds(agentId).map((mid) => {
     const m = roster.find((x) => x.id === mid);
     return { id: mid, name: String(m?.name || mid) };
+  }).filter((m) => !/^roombot-/.test(m.id) && !isGrokRoomMember({ id: m.id }));
+}
+
+export function groupNormText(text) {
+  return stripSpendFooter(String(text || ''))
+    .replace(/^\s*[A-Za-z0-9 _.-]{1,40}:\s*/, '')
+    .toLowerCase()
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+export function groupReplyIsRepeat(text, recent = []) {
+  const n = groupNormText(text);
+  if (n.length < 40) return false;
+  const head = n.slice(0, 90);
+  return (Array.isArray(recent) ? recent : []).some((prev) => {
+    const p = groupNormText(prev);
+    if (p.length < 40) return false;
+    return p.slice(0, 90) === head || p.startsWith(head) || n.startsWith(p.slice(0, 90));
   });
 }
 
@@ -1522,24 +1674,29 @@ export function groupReplyIsPass(text) {
   if (!s) return true;
   if (/^PASS\b/i.test(s)) return true;
   if (s.length < 20) return true;
+  if (/\binfinite\b.{0,48}\b(recursion|loop|chatter)\b/i.test(s)) return true;
+  if (/\bbots? keep triggering\b/i.test(s)) return true;
+  if (/\beach other'?s responses\b/i.test(s)) return true;
+  if (/\bfeedback loop\b/i.test(s)) return true;
   return /\b(nothing (more|else) to add|i('m| am) done|that('s| is) (all|my last word)|we (are|'re) (agreed|aligned|done)|i'?ll (stop|leave it)|no further|conversation is over|natural conclusion|i pass)\b/i.test(s);
 }
 
-const GROUP_MAX_ROUNDS = Math.min(12, Math.max(2, Number(process.env.OZ_GROUP_MAX_ROUNDS || 8)));
-const GROUP_MAX_CALLS = Math.min(24, Math.max(4, Number(process.env.OZ_GROUP_MAX_CALLS || 16)));
+const GROUP_MAX_ROUNDS = Math.min(12, Math.max(1, Number(process.env.OZ_GROUP_MAX_ROUNDS || 2)));
+const GROUP_MAX_CALLS = Math.min(24, Math.max(2, Number(process.env.OZ_GROUP_MAX_CALLS || 6)));
 
-/** Members speak, then keep peek/ponging until they PASS or hit the cap. */
+/** Members speak once, then at most a short peek. Repeats and loop-talk are PASS. */
 async function runGroupQueue({ agentId, humanPrompt, parsed, nonce, log }) {
   const named = groupMemberRecords(agentId);
   if (!named.length) return false;
   const names = named.map((m) => m.name);
   let calls = 0;
+  const painted = [];
 
   const oneTurn = async (m, phase) => {
     const others = names.filter((n) => n !== m.name).join(', ') || 'the group';
     const persona = phase === 'peek'
-      ? `You are ${m.name} in a group with ${others}. Continue ping/pong with the other members using the prior turns. Do not speak as the human. Do not prefix with visitor shortnames. If the exchange has reached a natural conclusion or you have nothing to add, reply with exactly PASS and nothing else. Otherwise one short in-character turn.`
-      : `You are ${m.name} in a group with ${others}. Answer the human as yourself and leave a hook the others can ping. Do not speak as the human. Do not prefix with visitor shortnames. A few sentences.\n\nThe human said: ${humanPrompt}`;
+      ? `You are ${m.name} in a group with ${others}. If you have nothing new, or would repeat another member, reply with exactly PASS. Do not discuss loops, recursion, or that bots are talking to each other. One short in-character line or PASS.`
+      : `You are ${m.name} in a group with ${others}. Answer the human as yourself in a few sentences. Do not speak as the human. Do not prefix with visitor shortnames. Do not discuss infinite loops or recursion unless the human asked about that.\n\nThe human said: ${humanPrompt}`;
     let bit = '';
     try {
       bit = (await zooComplete(persona, log, agentId, parsed)).text;
@@ -1548,7 +1705,7 @@ async function runGroupQueue({ agentId, humanPrompt, parsed, nonce, log }) {
       log(`cursor-backend:      group ${phase} ${m.id} failed: ${e.message}`);
     }
     calls += 1;
-    const pass = groupReplyIsPass(bit);
+    const pass = groupReplyIsPass(bit) || groupReplyIsRepeat(bit, painted);
     if (!pass) {
       const line = fanoutLine(agentId, 'assistant', bit, {
         clientNonce: nonce,
@@ -1557,6 +1714,11 @@ async function runGroupQueue({ agentId, humanPrompt, parsed, nonce, log }) {
       });
       ssePush('transcript', { ...gatewayEntry(line), agentId });
       bumpAgent(agentId, { preview: bit, notify: true });
+      painted.push(bit);
+      {
+        const live = (cachedAgentList() || []).find((a) => a.id === agentId);
+        if (live?.room?.addr) grokroomSend(live, bit, log, { from: m.name });
+      }
       log(`cursor-backend:      group ${phase} ${m.name} seq=${line.seq}`);
     } else {
       log(`cursor-backend:      group ${phase} ${m.name} PASS`);
@@ -1569,19 +1731,28 @@ async function runGroupQueue({ agentId, humanPrompt, parsed, nonce, log }) {
     await oneTurn(m, 'speak');
   }
   if (named.length < 2) return true;
+  if (painted.length >= 2 && groupReplyIsRepeat(painted[painted.length - 1], painted.slice(0, -1))) {
+    log(`cursor-backend:      group stopped after speak (repeat) calls=${calls}`);
+    return true;
+  }
 
   let round = 0;
   while (round < GROUP_MAX_ROUNDS && calls < GROUP_MAX_CALLS) {
     round += 1;
     let passes = 0;
+    const before = painted.length;
     for (const m of named) {
       if (calls >= GROUP_MAX_CALLS) break;
       if (await oneTurn(m, 'peek')) passes += 1;
     }
-    if (passes >= named.length) {
+    if (passes >= named.length || painted.length === before) {
       log(`cursor-backend:      group concluded round=${round} calls=${calls}`);
       break;
     }
+    if (painted.length >= 2 && groupReplyIsRepeat(painted[painted.length - 1], painted.slice(0, -1))) {
+      log(`cursor-backend:      group stopped peek (repeat) round=${round}`);
+      break;
+    }
   }
   log(`cursor-backend:      group queue done rounds=${round} calls=${calls}`);
   return true;
@@ -1603,7 +1774,7 @@ function mergeAgentLists(remote) {
   return sortAgentsByActivity(filterDeleted(out, HOME));
 }
 function gatewayEntry(e) {
-  const { seq, pulledRemote, promptRaw, ephemeral, ...rest } = e;
+  const { seq, pulledRemote, promptRaw, ephemeral, sig, ...rest } = e;
   return rest;
 }
 
@@ -1935,6 +2106,9 @@ const MODEL_ALIASES = {
   'x-ai/grok-4.6': 'grok-4.6',
   glm: 'zai-org/glm-5.3-flash',
   'glm-5': 'zai-org/glm-5.3-flash',
+  'glm-5.2': 'zai-org/GLM-5.2',
+  'z-ai/glm-5.2': 'zai-org/GLM-5.2',
+  'zai-org/glm-5.2': 'zai-org/GLM-5.2',
   'glm-5.3': 'zai-org/glm-5.3-flash',
   'glm-5.3-flash': 'zai-org/glm-5.3-flash',
   flash: 'zai-org/glm-5.3-flash',
@@ -1968,6 +2142,11 @@ async function resolveModelId(raw) {
   if (!s) return null;
   const lower = s.toLowerCase().replace(/^\/+/, '');
   if (MODEL_ALIASES[lower]) return MODEL_ALIASES[lower];
+  try {
+    const ids = await zooModelIds();
+    const mapped = resolveModel(s, ids);
+    if (mapped) return mapped;
+  } catch { /* catalog miss: keep explicit slash ids */ }
   if (s.includes('/')) return s;
   // No vendor prefix and no alias: the LIVE catalog decides, not this file.
   // The zoo serves ids with no slash at all (abliterated-model*), and a
@@ -2062,33 +2241,100 @@ async function writeLocalBytes(abs, bytes, log) {
   fs.writeFileSync(abs, buf);
   return `wrote ${abs} (${buf.length} bytes)`;
 }
+/** `serverMessage` is `agent.v1.ExecServerMessage` as protobuf-es JSON — a oneof,
+ *  so the key IS the case name. Two wrong shapes before this one:
+ *    `{command, cwd}` flat  -> "No handler found for server message of type undefined"
+ *    `{shellArgs: {...}}`   -> "No handler found for server message of type shellArgs"
+ *  `shellArgs` is a real case on the wire (field 2), but `buildLocalExecManager`
+ *  in Grok Bot 0.36.0's dist/local-exec-daemon/main.cjs registers exactly FOUR
+ *  handlers: shellStreamArgs, backgroundShellSpawnArgs, readArgs, lsArgs. The
+ *  one-shot shell case is simply not wired into the local-exec lane — the
+ *  streaming one is, and both carry the same `agent.v1.ShellArgs` payload.
+ *  `authorizedBy*` are read as `=== true` by the daemon's approval gate; without
+ *  them an unattended exec has nothing to approve it.
+ *
+ *  `timeout` is MILLISECONDS. The daemon reads it through a function named
+ *  `resolveShellTimeoutMs` and uses the value verbatim, so the plausible-looking
+ *  `timeout: 120` (seconds, as lib/podagent.mjs had it) aborts the shell after
+ *  120 ms: `echo hi; pwd` came back exit 0 with empty stdout and `ls -lha ~`
+ *  died mid-stream with "Cannot read properties of undefined (reading '3')".
+ *  0 means "use the daemon's default", not "no timeout". */
+export function localExecFrame(command, cwd, timeoutMs = 120_000) {
+  return {
+    kind: 'exec',
+    requestId: randomUUID(),
+    approvalId: randomUUID(),
+    authorizedByStanding: true,
+    authorizedByApproval: true,
+    serverMessage: {
+      shellStreamArgs: { command: String(command), workingDirectory: cwd, timeout: timeoutMs },
+    },
+  };
+}
+
+/** `agent.v1.ShellStream` off an ExecClientMessage: `{stdout:{data}}`,
+ *  `{stderr:{data}}`, `{exit:{code, cwd}}`. `data` is a proto string (T=9), not
+ *  bytes — no base64 decode. */
+export function shellStreamOf(frame) {
+  const m = frame && frame.message;
+  if (!m || typeof m !== 'object') return null;
+  const ss = m.shellStream;
+  return ss && typeof ss === 'object' ? ss : null;
+}
+
+/** exec used to hardcode `/bin/zsh -lc`: on Linux that is usually ENOENT and on
+ *  Windows there is no POSIX shell at all, so every exec came back as a spawn
+ *  error instead of output. */
+export function execShell(command, platform = process.platform) {
+  if (platform === 'win32') {
+    return { file: process.env.ComSpec || 'cmd.exe', args: ['/d', '/s', '/c', command] };
+  }
+  if (platform === 'darwin') return { file: '/bin/zsh', args: ['-lc', command] };
+  for (const sh of ['/bin/bash', '/usr/bin/bash', '/bin/zsh']) {
+    try { if (fs.existsSync(sh)) return { file: sh, args: ['-lc', command] }; } catch { /* keep looking */ }
+  }
+  return { file: '/bin/sh', args: ['-c', command] };
+}
+
 async function execLocal(command, cwd, log) {
   let dir = cwd ? expandUserPath(cwd) : os.homedir();
   try {
     if (!fs.statSync(dir).isDirectory()) dir = os.homedir();
   } catch {
-    // Node reports spawn /bin/zsh ENOENT when cwd is missing — not a missing shell.
+    // Node reports spawn <shell> ENOENT when cwd is missing — not a missing shell.
     try { fs.mkdirSync(dir, { recursive: true }); } catch { dir = os.homedir(); }
   }
   if (localExecSse.size > 0) {
     log(`cursor-backend:      local-exec exec ${JSON.stringify(command).slice(0, 80)}`);
-    const got = await localExecAsk({
-      kind: 'exec',
-      serverMessage: { command, cwd: dir, workingDirectory: dir },
-    }, 60000);
-    const out = got.stdout || got.message || '';
-    const err = got.stderr ? `\nstderr:\n${got.stderr}` : '';
+    // Daemon-side budget stays under our own wait so a slow command reports the
+    // shell's error, not our generic "is Grok Bot Helper connected?".
+    const got = await localExecAsk(localExecFrame(command, dir, 55_000), 60000);
+    const out = toolResultText(got.stdout || got.message || '');
+    const errText = toolResultText(got.stderr);
+    const err = errText ? `\nstderr:\n${errText}` : '';
     return `${out}${err}`.trim() || `(exit ${got.exitCode ?? 0})`;
   }
-  log(`cursor-backend:      exec cwd=${dir} ${JSON.stringify(String(command).slice(0, 80))}`);
+  const sh = execShell(command);
+  log(`cursor-backend:      exec cwd=${dir} sh=${sh.file} ${JSON.stringify(String(command).slice(0, 80))}`);
   const execMs = Math.min(180000, Math.max(15000, Number(process.env.OPENZOO_EXEC_TIMEOUT_MS || 90000)));
-  const { stdout, stderr } = await execFileAsync('/bin/zsh', ['-lc', command], {
-    cwd: dir,
-    timeout: execMs,
-    maxBuffer: 2 * 1024 * 1024,
-    env: process.env,
-  });
-  return `${stdout || ''}${stderr ? `\nstderr:\n${stderr}` : ''}`.trim() || '(no output)';
+  let stdout = '';
+  let stderr = '';
+  try {
+    ({ stdout, stderr } = await execFileAsync(sh.file, sh.args, {
+      cwd: dir,
+      timeout: execMs,
+      maxBuffer: 2 * 1024 * 1024,
+      env: process.env,
+      windowsHide: true,
+    }));
+  } catch (e) {
+    // A nonzero exit (grep with no match, a failing build) still has output the
+    // model needs — bubbling the Error loses it and paints only "ERROR".
+    stdout = toolResultText(e.stdout);
+    stderr = toolResultText(e.stderr) || e.message;
+    if (!stdout && !stderr) throw e;
+  }
+  return `${toolResultText(stdout)}${stderr ? `\nstderr:\n${toolResultText(stderr)}` : ''}`.trim() || '(no output)';
 }
 
 const LOCAL_TOOLS = [
@@ -2600,13 +2846,21 @@ async function runLocalTool(name, args, log, ctx = {}) {
     }
     if (name === 'list_dir') {
       const abs = expandUserPath(args.path || os.homedir());
-      if (localExecSse.size > 0) {
-        const got = await localExecAsk({ kind: 'exec', serverMessage: { command: `ls -la ${JSON.stringify(abs)}`, cwd: os.homedir() } });
-        return got.stdout || got.message || '';
+      try {
+        if (localExecSse.size > 0) {
+          const got = await localExecAsk(localExecFrame(`ls -la ${JSON.stringify(abs)}`, os.homedir(), 40_000));
+          // `|| got` used to dump the whole resolved frame onto the canvas as
+          // JSON ({"kind":"exit","stdout":"", …}) whenever the listing came back
+          // empty. Fall back to the local read instead — it is the same answer.
+          const text = toolResultText(got.stdout || got.stderr || got.message).trim();
+          if (text) return text;
+        }
+        const rows = fs.readdirSync(abs, { withFileTypes: true })
+          .map((e) => `${e.isDirectory() ? 'd' : '-'} ${e.name}`);
+        return rows.join('\n') || '(empty)';
+      } catch (e) {
+        return `list_dir failed ${abs}: ${e.message}`;
       }
-      return fs.readdirSync(abs, { withFileTypes: true })
-        .map((e) => `${e.isDirectory() ? 'd' : '-'} ${e.name}`)
-        .join('\n');
     }
     if (name === 'exec') {
       return await execLocal(String(args.command || ''), args.cwd, log);
@@ -3159,7 +3413,7 @@ async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
           name,
           path: args.path,
           command: args.command ? String(args.command).slice(0, 120) : undefined,
-          note: String(result).slice(0, 200),
+          note: toolResultText(result).slice(0, 200),
         });
         if (typeof opts.onProgress === 'function') {
           opts.onProgress(formatZooToolLine({ name, args, result }));
@@ -3167,7 +3421,7 @@ async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
         messages.push({
           role: 'tool',
           tool_call_id: c.id,
-          content: String(result).slice(0, 120000),
+          content: toolResultText(result).slice(0, 120000),
         });
       }
       if (pendingVision.length) {
@@ -3323,12 +3577,20 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     jsonSend(res, { ok: true, ...state });
     return true;
   }
+  if (name === 'ozShare') {
+    const list = cachedAgentList() || [];
+    const id = String(focusedAgentId || '');
+    const agent = list.find((a) => a.id === id) || null;
+    const share = groupShareState({ agent, rooms: grokroomSync._rooms });
+    jsonSend(res, { ok: true, agentId: id, ...share });
+    return true;
+  }
   if (name === 'ozRevive') {
     let parsed = {};
     try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
     const every = String(parsed.every || '5m');
     const wakes = readWakeups(HOME);
-    const list = (cachedAgentList() || []).filter((a) => a?.id && !a.isGroup);
+    const list = (cachedAgentList() || []).filter((a) => a?.id && !a.isGroup && !isGrokRoomAgent(a) && !isGrokRoomMember(a));
     const armed = [];
     const already = [];
     for (const a of list) {
@@ -3345,10 +3607,48 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     return true;
   }
   if (name === 'getHostStatus') {
-    jsonSend(res, { status: 'ready', ready: true, state: 'ready', hostStatus: 'ready' });
+    const host = {
+      hostVersion: '0.36.0',
+      latestHostVersion: '0.36.0',
+      hostUpdateAvailable: false,
+      isBusy: false,
+      capabilities: [],
+    };
+    jsonSend(res, { status: 'ok', value: host, ...host });
     log('cursor-backend:      -> getHostStatus ready');
     return true;
   }
+  if (name === 'resolveAgentCreation') {
+    const route = { kind: 'box' };
+    jsonSend(res, { status: 'ok', value: route, ...route });
+    log('cursor-backend:      -> resolveAgentCreation box');
+    return true;
+  }
+  if (name === 'getForeverBoxStatus' || name === 'ensureForeverBox') {
+    let parsed = {};
+    try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
+    const box = {
+      agentId: String(parsed.id || parsed.agentId || 'openzoo'),
+      state: 'running',
+    };
+    jsonSend(res, { status: 'ok', value: box, ...box });
+    log(`cursor-backend:      -> ${name} agentId=${box.agentId} state=${box.state}`);
+    return true;
+  }
+  if (name === 'getBoxSecretsStatus') {
+    const secrets = { keys: [], isApplied: false, lastAppliedAtMs: null };
+    jsonSend(res, { status: 'ok', value: secrets, ...secrets });
+    return true;
+  }
+  if (name === 'isEgressTunnelAvailable') {
+    jsonSend(res, { status: 'ok', value: false });
+    return true;
+  }
+  if (name === 'getAgentChannels') {
+    const channels = { manifests: [], connections: [] };
+    jsonSend(res, { status: 'ok', value: channels, ...channels });
+    return true;
+  }
   if (name === 'uploadAttachment' || name === 'readAttachmentImage'
       || name === 'readAttachmentText' || name === 'readAttachmentChunk') {
     let parsed = {};
@@ -3412,7 +3712,8 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
       parsed = { ...src, id: undefined, name: `${src.name || 'chat'} copy` };
     }
     const agent = mintLocalAgent(parsed);
-    jsonSend(res, { agent, id: agent.id, ...agent });
+    const created = { agent, id: agent.id, ...agent };
+    jsonSend(res, { status: 'ok', value: created, ...created });
     pushCreatedAgent(agent);
     log(`cursor-backend:      createAgent local id=${agent.id} name=${JSON.stringify(agent.name)}`);
     return true;
@@ -3430,7 +3731,8 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     let parsed = {};
     try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
     const id = String(parsed.id || parsed.agentId || '');
-    jsonSend(res, { id, isIntroductionInFlight: false });
+    const kick = { id, isIntroductionInFlight: false };
+    jsonSend(res, { status: 'ok', value: kick, ...kick });
     log(`cursor-backend:      kickstartAgent id=${id || '?'}`);
     return true;
   }
@@ -3438,15 +3740,18 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     let parsed = {};
     try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
     const memberIds = [].concat(parsed.memberAgentIds || parsed.memberIds || []).map(String).filter(Boolean);
-    const agent = mintLocalAgent({
+    const raw = mintLocalAgent({
       ...parsed,
       isGroup: true,
       memberIds,
       name: parsed.name || parsed.title || 'group',
     });
-    jsonSend(res, { agent, id: agent.id, ...agent });
+    const agent = mintLocalAgent(attachOnchainRoom(raw, HOME));
+    const created = { agent, id: agent.id, ...agent };
+    jsonSend(res, { status: 'ok', value: created, ...created });
     pushCreatedAgent(agent);
-    log(`cursor-backend:      createGroup local id=${agent.id} members=${memberIds.length} name=${JSON.stringify(agent.name)}`);
+    log(`cursor-backend:      createGroup onchain id=${agent.id} share=${agent.room?.web || ''} members=${memberIds.length} name=${JSON.stringify(agent.name)}`);
+    void paintGroupShareHint(agent, log);
     return true;
   }
   if (name === 'setGroupMembers') {
@@ -3521,7 +3826,7 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
     const ids = new Set([].concat(parsed.ids || parsed.id || []).map(String));
     const next = (cachedAgentList() || []).filter((a) => !ids.has(a.id));
-    addDeletedIds(HOME, [...ids]);
+    addDeletedIds(HOME, [...ids].filter((id) => !/^(room-|roombot-)/.test(id)));
     saveAgents(next);
     for (const id of ids) {
       transcripts.delete(id);
@@ -3544,7 +3849,15 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
       return true;
     }
     if (name === 'listAgents' || name === 'countAgents' || name === 'searchAgents') {
-      const list = rosterForEvent(mergeAgentLists([]), agentActivity);
+      let raw = mergeAgentLists([]);
+      let minted = false;
+      raw = raw.map((a) => {
+        if (!a?.isGroup || a.hidden || /^room-/.test(String(a.id || '')) || agentShareUrl(a)) return a;
+        minted = true;
+        return shapeAgent(attachOnchainRoom(a, HOME));
+      });
+      if (minted) saveAgents(raw.map(shapeAgent));
+      const list = rosterForEvent(raw, agentActivity);
       if (name === 'countAgents') {
         jsonSend(res, list.length);
         log(`cursor-backend:      countAgents local n=${list.length} account=${activeAccountId || 'none'}`);
@@ -3594,6 +3907,20 @@ 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 });
+    const roomAgent = grokroomLookup(agentId);
+    if (roomAgent && /^room-/.test(agentId)) {
+      const userLine = fanoutLine(agentId, 'user', uiText, {
+        clientNonce: nonce,
+        requestId: nonce,
+        richText: visitor ? prefixVisitorRichText(parsed.richText, visitor.shortname, uiText) : parsed.richText,
+        promptRaw: prompt,
+      });
+      noteFocus(agentId);
+      bumpAgent(agentId, { preview: prompt, notify: false, select: false });
+      ssePush('transcript', { ...gatewayEntry(userLine), agentId });
+      grokroomSend(roomAgent, prompt, log);
+      return true;
+    }
     if (!visitor && wantsWakeupCron(prompt)) {
       const cron = scheduleAgentWakeup(agentId, { every: '5m' });
       log(`cursor-backend:      never-stop cron agent=${agentId} every=${cron.everySec}s`);
@@ -3608,6 +3935,12 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     noteFocus(agentId);
     bumpAgent(agentId, { preview: prompt, notify: false });
     ssePush('transcript', { ...gatewayEntry(userLine), agentId });
+    {
+      const live = (cachedAgentList() || []).find((a) => a.id === agentId);
+      if (live?.room?.addr) grokroomSend(live, prompt, log);
+    }
+    const joinAddr = /^\s*\/join\b/i.test(prompt) ? grokroomAddrFromShare(prompt)
+      : (/^\s*https?:\/\/openzoo\.fun\/r\//i.test(prompt) ? grokroomAddrFromShare(prompt) : '');
     const modelCmd = /^\s*\/model(?:\s+(\S+))?\s*$/i.exec(prompt || '');
     setImmediate(async () => {
       let text = '';
@@ -3629,11 +3962,27 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
               text = `model set to ${id}`;
             }
           }
+        } else if (joinAddr) {
+          grouped = true;
+          const joined = joinSharedGroup(joinAddr);
+          if (!joined) {
+            text = `could not join — not an openzoo.fun/r/<addr> share`;
+          } else {
+            noteFocus(joined.id);
+            ssePush('agent-upserted', { agent: joined, activeAgentId: joined.id });
+            ssePush('agents', { agents: rosterForEvent(cachedAgentList() || [], agentActivity), activeAgentId: joined.id });
+            void paintGroupShareHint(joined, log);
+            text = `joined ${joined.name}\n${joined.room?.web || ''}\nIn your OpenZoo Bot: add your bots to this group. They speak here; remote nicks only show up as people, they are not local bots.\nAnyone else: /join ${joined.room?.web || joinAddr}`;
+          }
         } else {
-          const members = groupMemberIds(agentId);
+          const live = (cachedAgentList() || []).find((a) => a.id === agentId);
+          const members = groupMemberRecords(agentId);
+          const isSharedRoom = !!(live?.room?.addr || isGrokRoomAgent(live || { id: agentId }));
           if (members.length) {
             grouped = true;
             await runGroupQueue({ agentId, humanPrompt: prompt, parsed, nonce, log });
+          } else if (isSharedRoom) {
+            grouped = true;
           } else {
             const z = await zooComplete(prompt, log, agentId, parsed, {
               signal: turn.signal,
@@ -3664,6 +4013,10 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
         const line = fanoutLine(agentId, 'assistant', text, { clientNonce: nonce, requestId: nonce });
         ssePush('transcript', { ...gatewayEntry(line), agentId });
         bumpAgent(agentId, { preview: text, notify: true });
+        {
+          const live = (cachedAgentList() || []).find((a) => a.id === agentId);
+          if (live?.room?.addr && text) grokroomSend(live, text, log);
+        }
         log(`cursor-backend:      sendPrompt done agent=${agentId} seq=${line.seq} text=${JSON.stringify(text.slice(0, 220))}`);
       } else {
         log(`cursor-backend:      sendPrompt group done agent=${agentId}`);
@@ -3679,6 +4032,7 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     noteFocus(id);
     tailedAgents.add(id);
     const t = agentTranscript(id);
+    if (isGrokRoomAgent({ id }) || /^roombot-/.test(id)) t.pulledRemote = true;
     if (!t.pulledRemote && realPod?.agent && !useHouseRoster()) {
       const remote = await podJson('/api/getAgentTranscriptTail', {
         id, agentId: id, limit: 200, beforeSeq: parsed.beforeSeq,
@@ -3718,7 +4072,10 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
   }
 
   const stubs = {
-    getHostStatus: { status: 'ready', ready: true, state: 'ready', hostStatus: 'ready' },
+    getHostStatus: {
+      hostVersion: '0.36.0', latestHostVersion: '0.36.0',
+      hostUpdateAvailable: false, isBusy: false, capabilities: [],
+    },
     getHostSettings: { settings: {} },
     setHostSettings: { ok: true },
     setBoxSecrets: { ok: true },
@@ -3729,12 +4086,16 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     getAgentTranscriptTail: { tail: '', lines: [], dropped: false, ok: true },
     getTeachRecordingStatus: { recording: false },
     getTrays: [],
-    isGlobalSearchEnabled: { enabled: false },
-    isEgressTunnelAvailable: { available: false },
+    isGlobalSearchEnabled: false,
+    isEgressTunnelAvailable: false,
     getSharingState: { sharing: false },
     getBotTemplateExportPolicy: { allowed: true },
     getAgentAutomations: { automations: [] },
-    getForeverBoxStatus: { enabled: false },
+    getForeverBoxStatus: { agentId: 'openzoo', state: 'running' },
+    ensureForeverBox: { agentId: 'openzoo', state: 'running' },
+    getBoxSecretsStatus: { keys: [], isApplied: false, lastAppliedAtMs: null },
+    getAgentChannels: { manifests: [], connections: [] },
+    resolveAgentCreation: { kind: 'box' },
     getSubagents: { subagents: [] },
     getAsyncTasks: { tasks: [] },
     getAgentWorkflows: { workflows: [] },
@@ -3799,14 +4160,377 @@ function respond(req, res, method, models) {
   res.end(bodyProto);
 }
 
+// ===== GROKROOM-BRIDGE v1 (overlay) =====
+// Rooms from 127.0.0.1:4799 as native Grok Bot group threads.
+// One room = one sidebar row (# main / # bots / # random / # lobby).
+// Each remote sender is a hidden bubble-member (no sidebar row). Sends POST a
+// signed ed25519 envelope to /submit — the chain is the log. Additive: any
+// failure here must never break zoo chat. Interval starts from startCursorBackend
+// so importing this module in tests does not poll.
+const GROKROOM_API = process.env.OZ_GROKROOM_URL || 'http://127.0.0.1:4799';
+const GROKROOM_PAYMASTER = (process.env.OZ_GROKROOM_PAYMASTER || 'https://openzoo.fun').replace(/\/$/, '');
+const GROKROOM_ID_FILE = path.join(HOME, '.openzoo', 'grokroom-identity.json');
+const GROKROOM_PKCS8_PREFIX = Buffer.from('302e020100300506032b657004220420', 'hex');
+const GROKROOM_HANDLE = (process.env.OZ_ROOM_HANDLE || process.env.USER || 'anon')
+  .replace(/[^A-Za-z0-9 _.'-]/g, '').trim().slice(0, 24) || 'anon';
+const GROKROOM_B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+function grokroomB58(buf) {
+  const digits = [0];
+  for (const byte of buf) {
+    let carry = byte;
+    for (let i = 0; i < digits.length; i++) { carry += digits[i] << 8; digits[i] = carry % 58; carry = (carry / 58) | 0; }
+    while (carry) { digits.push(carry % 58); carry = (carry / 58) | 0; }
+  }
+  let out = '';
+  for (const b of buf) { if (b === 0) out += '1'; else break; }
+  return out + digits.reverse().map((d) => GROKROOM_B58[d]).join('');
+}
+
+let grokroomIdCache = null;
+function grokroomIdentity() {
+  if (grokroomIdCache) return grokroomIdCache;
+  let id = null;
+  try {
+    const j = JSON.parse(fs.readFileSync(GROKROOM_ID_FILE, 'utf8'));
+    if (j.pub && j.seed) id = j;
+  } catch { /* first run */ }
+  if (!id) {
+    const pair = generateKeyPairSync('ed25519');
+    const rawPub = pair.publicKey.export({ format: 'der', type: 'spki' }).subarray(-32);
+    const rawSeed = pair.privateKey.export({ format: 'der', type: 'pkcs8' }).subarray(-32);
+    id = { pub: grokroomB58(Buffer.from(rawPub)), seed: Buffer.from(rawSeed).toString('base64') };
+    try {
+      fs.mkdirSync(path.dirname(GROKROOM_ID_FILE), { recursive: true });
+      fs.writeFileSync(GROKROOM_ID_FILE, JSON.stringify(id, null, 2));
+    } catch { /* in-memory is fine */ }
+  }
+  grokroomIdCache = id;
+  return id;
+}
+
+async function grokroomPost(roomId, body, { from: fromRaw } = {}) {
+  const id = grokroomIdentity();
+  const ts = Date.now();
+  const from = grokroomFromHandle(fromRaw || GROKROOM_HANDLE, GROKROOM_HANDLE);
+  const pub = id.pub;
+  const room = String(roomId || '');
+  const canonical = JSON.stringify({ body, from, pub, room, ts });
+  const key = createPrivateKey({ key: Buffer.concat([GROKROOM_PKCS8_PREFIX, Buffer.from(id.seed, 'base64')]), format: 'der', type: 'pkcs8' });
+  const sig = grokroomB58(cryptoSign(null, Buffer.from(canonical, 'utf8'), key));
+  const payload = JSON.stringify({ room, from, pub, body, ts, sig });
+  const endpoints = [];
+  if (/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(room)) {
+    endpoints.push(GROKROOM_PAYMASTER + '/api/room/submit');
+  }
+  endpoints.push(GROKROOM_API + '/submit');
+  let last = new Error('no submit endpoint');
+  for (const url of endpoints) {
+    try {
+      const r = await fetch(url, {
+        method: 'POST', headers: { 'content-type': 'application/json' },
+        body: payload,
+        signal: AbortSignal.timeout(30000),
+      });
+      const j = await r.json().catch(() => ({}));
+      if (r.ok && j.ok !== false) return j;
+      last = new Error(j.error || ('submit HTTP ' + r.status));
+    } catch (e) {
+      last = e;
+    }
+  }
+  throw last;
+}
+
+function grokroomLookup(agentId) {
+  const list = cachedAgentList() || [];
+  return list.find((a) => a.id === agentId && isGrokRoomAgent(a)) || null;
+}
+
+function grokroomUpsertAgent(parsed, { select = false } = {}) {
+  const id = String(parsed.id);
+  const prev = (cachedAgentList() || []).find((a) => a.id === id) || {};
+  const agent = shapeAgent({
+    ...prev,
+    ...parsed,
+    id,
+    createdAt: prev.createdAt || parsed.createdAt || Date.now(),
+    updatedAt: Date.now(),
+  });
+  const list = cachedAgentList() || [];
+  const i = list.findIndex((a) => a.id === id);
+  if (i < 0) list.unshift(agent);
+  else list[i] = { ...list[i], ...agent };
+  saveAgents(list.map(shapeAgent));
+  agentTranscript(id);
+  if (agent.hidden) {
+    const visible = rosterForEvent(list, agentActivity);
+    ssePush('agents', { agents: visible, activeAgentId: focusedAgentId || visible[0]?.id || id });
+  } else {
+    pushCreatedAgent(agent, { select });
+  }
+  return agent;
+}
+
+function grokroomMemberEnsure(group, name, { speak = false } = {}) {
+  const mid = grokroomMemberId(name);
+  const list = cachedAgentList() || [];
+  let member = list.find((a) => a.id === mid);
+  if (!member) {
+    member = grokroomUpsertAgent({
+      id: mid,
+      name: String(name || 'anon').slice(0, 80),
+      hidden: true,
+      hiddenFromSidebar: true,
+      brief: '',
+      description: '',
+    });
+  }
+  if (!speak) return group;
+  const have = group.memberIds || [];
+  if (have.includes(mid)) return group;
+  return grokroomUpsertAgent({
+    id: group.id,
+    name: group.name,
+    isGroup: true,
+    memberIds: [...have, mid],
+    brief: '',
+    description: '',
+    room: group.room,
+  });
+}
+
+function joinSharedGroup(addr, { name } = {}) {
+  const web = grokroomShareUrl(addr);
+  if (!web) return null;
+  const list = cachedAgentList() || [];
+  const existing = list.find((a) => a?.room?.addr === addr);
+  if (existing) return existing;
+  const raw = mintLocalAgent({
+    isGroup: true,
+    name: String(name || `group ${addr.slice(0, 6)}`).slice(0, 80),
+    memberIds: [],
+    room: { id: addr, addr, web },
+  });
+  return mintLocalAgent(bindOnchainRoom(raw, addr, HOME));
+}
+
+function paintShareIfMissing(agent, log = () => {}) {
+  const url = agentShareUrl(agent);
+  if (!agent?.id || !url) return false;
+  const t = agentTranscript(agent.id);
+  const has = (t.entries || []).some((e) => /openzoo\.fun\/r\//.test(String(e?.content || '')));
+  if (has) return false;
+  const nonce = `oz-share-${agent.id}`;
+  const line = fanoutLine(agent.id, 'assistant', 'Share this room: ' + url, {
+    clientNonce: nonce,
+    requestId: nonce,
+  });
+  ssePush('transcript', { ...gatewayEntry(line), agentId: agent.id });
+  log(`cursor-backend:      group share painted agent=${agent.id}`);
+  return true;
+}
+
+async function paintGroupShareHint(agent, log = () => {}) {
+  if (!agent?.id) return;
+  let rooms = grokroomSync._rooms;
+  if (!Array.isArray(rooms)) {
+    try {
+      const st = await fetch(GROKROOM_API + '/state', { signal: AbortSignal.timeout(4000) }).then((r) => r.json());
+      rooms = Array.isArray(st.rooms) ? st.rooms : [];
+      grokroomSync._rooms = rooms;
+    } catch { rooms = []; }
+  }
+  const share = groupShareState({ agent, rooms });
+  let text = '';
+  if (share.url) {
+    text = 'Share this room on openzoo.fun: ' + share.url;
+  } else if (share.rooms.length) {
+    text = 'This group is local to this house. Public grokrooms — send this URL:\n'
+      + share.rooms.map((r) => `${r.name}  ${r.url}`).join('\n');
+  } else {
+    text = 'This group is local to this house. To share on openzoo.fun, use a grokroom (# main / # bots / # random / # lobby). Start ~/grokroom on :4799 if those rows are missing.';
+  }
+  const line = fanoutLine(agent.id, 'assistant', text, {});
+  ssePush('transcript', { ...gatewayEntry(line), agentId: agent.id });
+  log(`cursor-backend:      group share hint agent=${agent.id}`);
+}
+
+function grokroomEnsureGroup(roomId, name, addr) {
+  const id = grokroomAgentId(roomId);
+  if (!id) return null;
+  const list = cachedAgentList() || [];
+  const prev = list.find((a) => a.id === id || a.room?.id === roomId);
+  const nextAddr = addr || prev?.room?.addr || '';
+  const web = grokroomShareUrl(nextAddr);
+  if (prev) {
+    const need = (nextAddr && prev.room && prev.room.addr !== nextAddr)
+      || (web && prev.room && prev.room.web !== web);
+    const agent = need
+      ? grokroomUpsertAgent({ ...prev, room: { id: roomId, addr: nextAddr, web } }, { select: false })
+      : prev;
+    paintShareIfMissing(agent);
+    return agent;
+  }
+  const agent = grokroomUpsertAgent({
+    id,
+    name: name || ('# ' + roomId),
+    isGroup: true,
+    memberIds: [],
+    brief: '',
+    description: '',
+    room: { id: roomId, addr: nextAddr, web },
+  }, { select: false });
+  const nonce = `oz-room-${id}`;
+  grokroomMemberEnsure(agent, 'room');
+  const text = 'Linked to ' + agent.name + ' on Solana testnet. Every message here is a signed memo on-chain — the chain is the log.'
+    + (web ? ' Share: ' + web : '')
+    + (nextAddr ? ' Explorer: https://solscan.io/account/' + nextAddr + '?cluster=testnet' : '');
+  const line = fanoutLine(id, 'assistant', text, {
+    clientNonce: nonce,
+    requestId: nonce,
+    author: { kind: 'agent', id: grokroomMemberId('room'), name: 'room' },
+  });
+  ssePush('transcript', { ...gatewayEntry(line), agentId: id });
+  return agent;
+}
+
+function grokroomSend(agent, body, log = () => {}, { from } = {}) {
+  const text = stripSpendFooter(String(body || '')).trim().slice(0, 400);
+  const roomKey = agent?.room?.addr || agent?.room?.id;
+  if (!text || !roomKey) return;
+  if (/^PASS\b/i.test(text)) return;
+  grokroomPost(roomKey, text, { from }).then((j) => {
+    log(`cursor-backend:      grokroom posted room=${String(roomKey).slice(0, 8)}… sig=${String(j?.sig || '').slice(0, 12)} from=${from || GROKROOM_HANDLE}`);
+  }).catch((e) => {
+    grokroomMemberEnsure(agent, 'room');
+    const line = fanoutLine(agent.id, 'assistant', '⚠ could not reach the room: ' + e.message, {
+      author: { kind: 'agent', id: grokroomMemberId('room'), name: 'room' },
+    });
+    ssePush('transcript', { ...gatewayEntry(line), agentId: agent.id });
+    log(`cursor-backend:      grokroom send fail ${roomKey} ${e.message}`);
+  });
+}
+
+function grokroomIngestMsgs(group, msgs, log = () => {}) {
+  if (!group?.id || !Array.isArray(msgs) || !msgs.length) return 0;
+  let agent = group;
+  const names = new Set();
+  for (const m of msgs) {
+    const from = String(m.from || m.node || '').slice(0, 24);
+    if (from) names.add(from);
+  }
+  for (const from of names) agent = grokroomMemberEnsure(agent, from);
+  const t = agentTranscript(agent.id);
+  const seen = new Set((t.entries || []).filter((h) => h.sig).map((h) => h.sig));
+  const recent = (t.entries || []).slice(-80).map((h) => String(h.content || ''));
+  let dirty = 0;
+  for (const m of msgs) {
+    const msig = m.sig || m.txSig || m.envsig || (m.pub && m.ts ? m.pub + ':' + m.ts : null);
+    if (!msig || seen.has(msig)) continue;
+    seen.add(msig);
+    const from = String(m.from || m.node || 'anon').slice(0, 24);
+    const body = String(m.body || m.text || '');
+    if (!body) continue;
+    if (recent.includes(body)) continue;
+    agent = grokroomMemberEnsure(agent, from);
+    const mid = grokroomMemberId(from);
+    const line = fanoutLine(agent.id, 'assistant', body, {
+      author: { kind: 'agent', id: mid, name: from },
+      sig: msig,
+    });
+    ssePush('transcript', { ...gatewayEntry(line), agentId: agent.id });
+    dirty += 1;
+  }
+  if (dirty) {
+    bumpAgent(agent.id, { preview: msgs[msgs.length - 1]?.body || '', notify: true, select: false });
+    log(`cursor-backend:      grokroom ${agent.room?.id || agent.id} +${dirty} bubbles`);
+  }
+  return dirty;
+}
+
+async function grokroomSyncPaymaster(log = () => {}) {
+  const list = cachedAgentList() || [];
+  const seen = new Set();
+  for (const a of list) {
+    const addr = a?.room?.addr;
+    if (!grokroomShareUrl(addr) || seen.has(addr)) continue;
+    seen.add(addr);
+    try {
+      const r = await fetch(`${GROKROOM_PAYMASTER}/api/room/history?addr=${encodeURIComponent(addr)}`, {
+        signal: AbortSignal.timeout(8000),
+      });
+      if (!r.ok) continue;
+      const j = await r.json().catch(() => ({}));
+      const msgs = Array.isArray(j.msgs) ? j.msgs : [];
+      grokroomIngestMsgs(a, msgs, log);
+    } catch (e) {
+      log(`cursor-backend:      grokroom history ${String(addr).slice(0, 8)}… ${e.message}`);
+    }
+  }
+}
+
+let grokroomBusy = false;
+async function grokroomSync(log = () => {}) {
+  if (grokroomBusy) return;
+  grokroomBusy = true;
+  try {
+    try {
+      const stRes = await fetch(GROKROOM_API + '/state', { signal: AbortSignal.timeout(4000) });
+      if (stRes.ok) {
+        const st = await stRes.json();
+        const rooms = Array.isArray(st.rooms) ? st.rooms : [];
+        grokroomSync._rooms = rooms;
+        if (!grokroomSync._logged) {
+          grokroomSync._logged = true;
+          log(`cursor-backend:      grokroom sync tick: rooms=${rooms.map((r) => r.id).join(',')}`);
+        }
+        for (const r of rooms) {
+          const roomId = r.id || r.name;
+          if (!roomId) continue;
+          const group = grokroomEnsureGroup(roomId, r.name, r.addr || r.address);
+          if (!group) continue;
+          const feedRes = await fetch(GROKROOM_API + '/feed?room=' + encodeURIComponent(roomId), { signal: AbortSignal.timeout(4000) });
+          if (!feedRes.ok) continue;
+          const feed = await feedRes.json();
+          grokroomIngestMsgs(group, Array.isArray(feed.messages) ? feed.messages : [], log);
+        }
+      }
+    } catch (e) {
+      if (!grokroomSync._localMiss) {
+        grokroomSync._localMiss = true;
+        log(`cursor-backend:      grokroom local :4799 down (${e.message}); paymaster only`);
+      }
+    }
+    await grokroomSyncPaymaster(log);
+  } catch (e) {
+    log(`cursor-backend:      grokroom sync: ${e.message}`);
+  } finally {
+    grokroomBusy = false;
+  }
+}
+
+function startGrokroomBridge(log = () => {}) {
+  if (startGrokroomBridge._on) return;
+  if (process.env.OZ_GROKROOM === '0') {
+    log('cursor-backend:      grokroom bridge off (OZ_GROKROOM=0)');
+    return;
+  }
+  startGrokroomBridge._on = true;
+  const tick = () => grokroomSync(log);
+  setTimeout(tick, 800);
+  setInterval(tick, 4000);
+}
+
 /**
  * Start the impersonation server. Binds `port` (default 8443 — a privileged
  * 443->port redirect is installed alongside the /etc/hosts entry, so this stays
  * unprivileged). Returns { server, port }.
  */
-export function startCursorBackend({ port = 8443, models, log = () => {} } = {}) {
+export async function startCursorBackend({ port = 8443, models, log = () => {} } = {}) {
   restoreAgentWakeups(log);
-  const { cert, key } = ensureCert(log);
+  startGrokroomBridge(log);
+  const { cert, key } = await ensureCert(log);
   const certPem = fs.readFileSync(cert);
   const keyPem = fs.readFileSync(key);
   const secureContext = tls.createSecureContext({ cert: certPem, key: keyPem });
@@ -3895,6 +4619,21 @@ export function startCursorBackend({ port = 8443, models, log = () => {} } = {})
         return;
       }
       log(`cursor-backend: #${conns} ${req.method} ${full}  ct=${ct}  body=${body.length}b`);
+      // HIJACK LOGIN. Measured Linux 2026-09-03: GET /auth/poll -> empty-ok
+      // (`{}`) so SandBackendLoginManager threw bad_200 and the UI stayed on
+      // "Log in with Cursor". Poll must return accessToken+refreshToken JWT.
+      // /oauth/token refresh is the same session — do NOT passthrough fake
+      // tokens to real api2. Sniff/passthru keeps the real issuer.
+      {
+        const fakeAuth = fakeCursorAuthReply(full, { passthrough: sniffOn() || process.env.OPENZOO_PASSTHRU === '1' });
+        if (fakeAuth) {
+          if (req.method === 'OPTIONS') { res.writeHead(204, CORS); res.end(); return; }
+          res.writeHead(200, { 'content-type': fakeAuth.contentType, ...CORS });
+          res.end(fakeAuth.body);
+          log(`cursor-backend:      -> FAKE ${fakeAuth.kind} logged-in (no Cursor account)`);
+          return;
+        }
+      }
       // OAUTH MUST HIT THE REAL ISSUER. empty-ok on /oauth/token is the
       // "Reconnecting to your computer" / edge/handler-failed loop: the app
       // retries the same 509b body forever and never reaches AvailableModels