openzoo 0.50.97 → 0.50.99

package/lib/grokbotAccount.js

@@ -10,7 +10,9 @@
  * just because no Cursor account has logged in.
  */
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
+import { generateKeyPairSync } from 'node:crypto';
 
 export function accountSlug(accountId) {
   const s = String(accountId || '').replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 64);
@@ -204,11 +206,179 @@ export function displayName(raw = {}) {
 export function briefFromName(name) {
   const n = String(name || '').trim();
   if (!n || /^(new bot|chat|group)$/i.test(n) || looksLikeAgentId(n)) return '';
+  // grokroom threads (# main) and bubble-members are not jobs — a brief would
+  // kick a zoo turn on a gossip canvas.
+  if (/^#\s/.test(n)) return '';
   const role = n.replace(/^\d+\s*[·.•.\-—–]+\s*/, '').trim() || n;
   if (role.length < 2) return '';
   return `You are ${n}. Your job is ${role}. Do that job. Do not ask the human to re-brief you. Coordinate with list_agents and message_agent.`;
 }
 
+/** Overlay sidebar id for a grokroom gossip room. */
+export function grokroomAgentId(roomId) {
+  const id = String(roomId || '').replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 40);
+  return id ? `room-${id}` : '';
+}
+
+/** Paymaster `from` field: 1–24 chars, letters/numbers/space/._'- */
+export function grokroomFromHandle(name, fallback = 'anon') {
+  const fb = String(fallback || 'anon').replace(/[^A-Za-z0-9 _.'-]/g, '').trim().slice(0, 24) || 'anon';
+  const s = String(name || fb).replace(/[^A-Za-z0-9 _.'-]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 24);
+  return s || fb;
+}
+
+/** Public page on openzoo.fun for a grokroom account (paymaster + browser signer). */
+export function grokroomShareUrl(addr, { origin = 'https://openzoo.fun' } = {}) {
+  const a = String(addr || '').trim();
+  if (!/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(a)) return '';
+  return `${String(origin || 'https://openzoo.fun').replace(/\/$/, '')}/r/${a}`;
+}
+
+/** Extract a paymaster room addr from a share URL, `/join …`, or a bare pubkey. */
+export function grokroomAddrFromShare(s) {
+  const t = String(s || '').trim();
+  if (!t) return '';
+  const m = t.match(/openzoo\.fun\/r\/([1-9A-HJ-NP-Za-km-z]{32,44})/i)
+    || t.match(/(?:^|\s)\/join\s+(\S+)/i);
+  const cand = m ? m[1] : t;
+  const addr = String(cand).replace(/^https?:\/\/[^/]+\/r\//i, '').replace(/[/?#].*$/, '').trim();
+  return grokroomShareUrl(addr) ? addr : '';
+}
+
+/** Bind an existing public room onto a local group (join). Does not mint a new key. */
+export function bindOnchainRoom(agent, addr, home = os.homedir()) {
+  if (!agent || typeof agent !== 'object') return agent;
+  const web = grokroomShareUrl(addr);
+  if (!web) return agent;
+  const rec = {
+    agentId: String(agent.id || ''),
+    name: String(agent.name || 'group'),
+    addr,
+    web,
+    createdAt: Date.now(),
+  };
+  const all = readOnchainRooms(home).filter((r) => r && r.agentId !== rec.agentId && r.addr !== addr);
+  all.push(rec);
+  writeOnchainRooms(all, home);
+  return {
+    ...agent,
+    isGroup: true,
+    room: { id: String(agent.room?.id || addr), addr, web },
+  };
+}
+
+/** Share URL already on an overlay group (room.web or derived from addr). */
+export function agentShareUrl(a) {
+  if (!a || typeof a !== 'object') return '';
+  return grokroomShareUrl(a.room?.addr || a.room?.address) || String(a.room?.web || '').trim();
+}
+
+/**
+ * Overlay share payload for a focused tray row + grokroom /state rooms.
+ * Grokroom groups have their own /r/<addr>. Local createGroup has no pubkey;
+ * the HUD then lists the public grokroom URLs.
+ */
+export function groupShareState({ agent, rooms } = {}) {
+  const url = agentShareUrl(agent);
+  const list = (Array.isArray(rooms) ? rooms : []).map((r) => {
+    const u = r && (r.web || grokroomShareUrl(r.addr || r.address));
+    if (!u) return null;
+    return { id: String(r.id || r.name || ''), name: String(r.name || r.id || ''), url: u };
+  }).filter(Boolean);
+  const isGroup = !!(agent && (agent.isGroup || agent.room));
+  return { url: url || '', isGroup, rooms: list };
+}
+
+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('');
+}
+
+export function onchainRoomsPath(home = os.homedir()) {
+  return path.join(home, '.openzoo', 'grokbot-onchain-rooms.json');
+}
+
+export function readOnchainRooms(home = os.homedir()) {
+  try {
+    const j = JSON.parse(fs.readFileSync(onchainRoomsPath(home), 'utf8'));
+    return Array.isArray(j) ? j : [];
+  } catch { return []; }
+}
+
+export function writeOnchainRooms(list, home = os.homedir()) {
+  const p = onchainRoomsPath(home);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify(Array.isArray(list) ? list : [], null, 2));
+}
+
+/**
+ * Mint a Solana ed25519 pubkey for a Grok Bot groupchat. The paymaster
+ * indexes memos by that account; https://openzoo.fun/r/<addr> is the public page.
+ */
+export function mintOnchainRoom({ agentId, name, home = os.homedir() } = {}) {
+  const pair = generateKeyPairSync('ed25519');
+  const rawPub = pair.publicKey.export({ format: 'der', type: 'spki' }).subarray(-32);
+  const addr = grokroomB58(Buffer.from(rawPub));
+  const rec = {
+    agentId: String(agentId || ''),
+    name: String(name || 'group'),
+    addr,
+    web: grokroomShareUrl(addr),
+    createdAt: Date.now(),
+  };
+  const all = readOnchainRooms(home).filter((r) => r && r.agentId !== rec.agentId);
+  all.push(rec);
+  writeOnchainRooms(all, home);
+  return rec;
+}
+
+/** Reuse a stored room for this agent, or mint one. */
+export function ensureOnchainRoom(agent, home = os.homedir()) {
+  const addr = agent?.room?.addr || agent?.room?.address || '';
+  const web = grokroomShareUrl(addr);
+  if (web) return { agentId: String(agent.id || ''), name: String(agent.name || ''), addr, web };
+  const hit = readOnchainRooms(home).find((r) => r && r.agentId === agent?.id && grokroomShareUrl(r.addr));
+  if (hit) return { ...hit, web: grokroomShareUrl(hit.addr) };
+  return mintOnchainRoom({ agentId: agent?.id, name: agent?.name, home });
+}
+
+export function attachOnchainRoom(agent, home = os.homedir()) {
+  if (!agent || typeof agent !== 'object') return agent;
+  if (!agent.isGroup && !(agent.room && agent.room.id)) return agent;
+  if (agent.hidden) return agent;
+  const rec = ensureOnchainRoom(agent, home);
+  const id = String(agent.room?.id || rec.agentId || agent.id || '');
+  return {
+    ...agent,
+    room: { id, addr: rec.addr, web: rec.web },
+  };
+}
+
+/** Hidden bubble-member id for a grokroom sender. One row, many rooms. */
+export function grokroomMemberId(name) {
+  const slug = String(name || 'anon').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 24) || 'anon';
+  return `roombot-${slug}`;
+}
+
+export function isGrokRoomAgent(a) {
+  if (!a || typeof a !== 'object') return false;
+  if (a.room && a.room.id) return true;
+  return /^room-/.test(String(a.id || ''));
+}
+
+export function isGrokRoomMember(a) {
+  if (!a || typeof a !== 'object') return false;
+  return a.hidden === true || a.hiddenFromSidebar === true || /^roombot-/.test(String(a.id || ''));
+}
+
 /** Standing job text. shapeAgent used to drop this, so every restart was amnesia. */
 export function agentBrief(raw = {}) {
   const a = raw && typeof raw === 'object' ? raw : {};
@@ -237,7 +407,17 @@ export function shapeAgent(raw = {}) {
     : (Array.isArray(a.memberAgentIds) ? a.memberAgentIds.map((x) => String(x)).filter(Boolean) : []);
   const isGroup = a.isGroup === true || memberIds.length > 0;
   const name = displayName({ ...a, isGroup, memberIds });
-  const brief = agentBrief({ ...a, name, title: a.title || name });
+  const hidden = a.hidden === true || a.hiddenFromSidebar === true;
+  let room = null;
+  if (a.room && typeof a.room === 'object' && a.room.id) {
+    const addr = String(a.room.addr || a.room.address || '');
+    const web = grokroomShareUrl(addr) || String(a.room.web || '').trim();
+    room = { id: String(a.room.id), addr, ...(web ? { web } : {}) };
+  } else if (/^room-/.test(id)) {
+    room = { id: id.slice(5), addr: '' };
+  }
+  const skipJob = hidden || !!room || /^#\s/.test(name);
+  const brief = skipJob ? String(a.brief || '').slice(0, 8000) : agentBrief({ ...a, name, title: a.title || name });
   return {
     id,
     name,
@@ -250,7 +430,8 @@ export function shapeAgent(raw = {}) {
     updatedAt: Number(a.updatedAt) || Date.now(),
     hasUnread: !!a.hasUnread,
     unreadCount: Number(a.unreadCount) || 0,
-    hidden: a.hidden === true || a.hiddenFromSidebar === true, // GROKROOM-HIDDEN-BOTS
+    hidden, // GROKROOM-HIDDEN-BOTS
+    hiddenFromSidebar: hidden,
     notificationsEnabled: a.notificationsEnabled !== false,
     notifyOnUpdatesEnabled: a.notifyOnUpdatesEnabled !== false,
     isGroup,
@@ -261,6 +442,7 @@ export function shapeAgent(raw = {}) {
       ? a.awaitingUserResponse : null,
     avatarShape: a.avatarShape ?? null,
     avatarColor: a.avatarColor ?? null,
+    ...(room ? { room } : {}),
   };
 }
 
@@ -365,7 +547,14 @@ export function addDeletedIds(home, ids) {
 export function filterDeleted(agents, home) {
   const del = readDeletedIds(home);
   if (!del.size || !Array.isArray(agents)) return agents || [];
-  return agents.filter((a) => a && !del.has(String(a.id)));
+  return agents.filter((a) => {
+    if (!a) return false;
+    const id = String(a.id || '');
+    // grokroom threads + bubble-members are gossip identities, not user bots.
+    // The old sidebar roombots were tombstoned; native rooms must still load.
+    if (/^(room-|roombot-)/.test(id)) return true;
+    return !del.has(id);
+  });
 }
 
 export function writeWakeups(home, map) {

package/lib/grokbotFetch.js

@@ -0,0 +1,258 @@
+// Fetch + install the official Grok Bot binary for this platform/arch.
+//
+// Source order:
+//   1. GitHub release grokbot-v* on staccDOTsol/openzoo (our multiarch re-host)
+//   2. Vendor feed api2.cursor.sh/updates/.../sand (same as scripts/release-grokbot.sh)
+//
+// A Finder-launched OpenZoo Bot.app has no npx and no Node on PATH. This is
+// the grokui sidecar trick applied to the vendor Grok Bot: download the
+// matching Grok_Bot_<ver>_<plat>-<arch> artifact, unpack it, then `openzoo bot`
+// can spawn it. GROKBOT_NO_FETCH=1 skips the network (tests / airgap).
+
+import { execFileSync, spawnSync } from 'node:child_process';
+import {
+  chmodSync,
+  copyFileSync,
+  cpSync,
+  createWriteStream,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  statSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+
+export const GROKBOT_GITHUB_REPO = 'staccDOTsol/openzoo';
+
+export const FEED_TARGETS = {
+  'darwin-arm64': { feed: 'darwin-arm64', plat: 'darwin-arm64', ext: 'zip' },
+  'darwin-x64': { feed: 'darwin-x64', plat: 'darwin-x64', ext: 'zip' },
+  'linux-arm64': { feed: 'linux-arm64', plat: 'linux-arm64', ext: 'AppImage' },
+  'linux-x64': { feed: 'linux-x64', plat: 'linux-x64', ext: 'AppImage' },
+  'win32-arm64': { feed: 'win32-arm64-user', plat: 'win-arm64', ext: 'exe' },
+  'win32-x64': { feed: 'win32-x64-user', plat: 'win-x64', ext: 'exe' },
+};
+
+export function machineArch(arch = process.arch) {
+  // nvm's default node on this Mac is x86_64 under Rosetta. Grok Bot is a
+  // native app — fetching darwin-x64 because process.arch is x64 would ship
+  // the Intel build onto Apple Silicon. hw.optional.arm64 is 1 on M-series
+  // even when the current process is translated.
+  if (process.platform === 'darwin') {
+    try {
+      const out = execFileSync('sysctl', ['-n', 'hw.optional.arm64'], {
+        encoding: 'utf8',
+        timeout: 2000,
+      }).trim();
+      if (out === '1') return 'arm64';
+    } catch { /* Intel Mac, or sysctl blocked */ }
+  }
+  return arch === 'arm64' ? 'arm64' : 'x64';
+}
+
+export function hostKey(platform = process.platform, arch = machineArch()) {
+  const a = arch === 'arm64' ? 'arm64' : 'x64';
+  if (platform === 'linux') return `linux-${a}`;
+  if (platform === 'win32') return `win32-${a}`;
+  return `darwin-${a}`;
+}
+
+export function githubAssetRegex(key) {
+  const t = FEED_TARGETS[key];
+  if (!t) return null;
+  const plat = t.plat.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`^Grok_Bot_.+_${plat}\\.${t.ext}$`, 'i');
+}
+
+export function matchGithubAsset(assets, key) {
+  const re = githubAssetRegex(key);
+  if (!re || !Array.isArray(assets)) return null;
+  return assets.find((a) => a && re.test(String(a.name || ''))) || null;
+}
+
+export function installDest(home = homedir(), platform = process.platform) {
+  if (platform === 'linux') return join(home, '.local', 'bin', 'Grok_Bot.AppImage');
+  if (platform === 'win32') {
+    return join(home, 'AppData', 'Local', 'Programs', 'Grok Bot', 'Grok Bot.exe');
+  }
+  return join(home, 'Applications', 'Grok Bot.app');
+}
+
+export function installedBinary(home = homedir(), platform = process.platform) {
+  const dest = installDest(home, platform);
+  if (platform === 'darwin') return join(dest, 'Contents', 'MacOS', 'Grok Bot');
+  return dest;
+}
+
+export function distDir(home = homedir()) {
+  return join(home, '.openzoo', 'grokbot-dist');
+}
+
+export function findAppBundle(dir, depth = 0) {
+  if (!dir || !existsSync(dir) || depth > 4) return null;
+  let entries;
+  try { entries = readdirSync(dir); } catch { return null; }
+  for (const name of entries) {
+    const p = join(dir, name);
+    if (/\.app$/i.test(name) && existsSync(join(p, 'Contents', 'MacOS'))) return p;
+    try {
+      if (statSync(p).isDirectory() && name !== 'Contents' && name !== 'node_modules') {
+        const hit = findAppBundle(p, depth + 1);
+        if (hit) return hit;
+      }
+    } catch { /* skip */ }
+  }
+  return null;
+}
+
+function uaHeaders() {
+  return { 'User-Agent': 'openzoo-bot', Accept: 'application/vnd.github+json' };
+}
+
+export async function githubGrokbotRelease({ fetchImpl = fetch, repo = GROKBOT_GITHUB_REPO } = {}) {
+  const r = await fetchImpl(`https://api.github.com/repos/${repo}/releases?per_page=40`, {
+    headers: uaHeaders(),
+    signal: AbortSignal.timeout(20000),
+  });
+  if (!r.ok) throw new Error(`github releases ${r.status}`);
+  const list = await r.json();
+  if (!Array.isArray(list)) throw new Error('github releases: not a list');
+  const hit = list.find((x) => x && typeof x.tag_name === 'string' && /^grokbot-v/.test(x.tag_name));
+  if (!hit) throw new Error('no grokbot-v* GitHub release');
+  return hit;
+}
+
+export async function vendorFeedAsset(key, { fetchImpl = fetch } = {}) {
+  const t = FEED_TARGETS[key];
+  if (!t) throw new Error(`unknown host key ${key}`);
+  const machine = process.env.GROKBOT_MACHINE_ID || '11111111-2222-3333-4444-555555555555';
+  const base = process.env.GROKBOT_BASE_VERSION || '0.30.0';
+  const url = `https://api2.cursor.sh/updates/api/update/${t.feed}/sand/${base}/${machine}/stable`;
+  const r = await fetchImpl(url, { signal: AbortSignal.timeout(20000) });
+  if (!r.ok) throw new Error(`vendor feed ${r.status}`);
+  const j = await r.json();
+  const version = j.version || j.name || j.productVersion;
+  let fileUrl = j.url;
+  if (typeof fileUrl === 'string' && /\/linux\//.test(fileUrl) && version) {
+    fileUrl = `${fileUrl.replace(/\/[^/]+$/, '')}/Grok_Bot_${version}.AppImage`;
+  }
+  if (!version || !fileUrl) throw new Error(`vendor feed missing url/version for ${key}`);
+  return { version: String(version), url: fileUrl, name: `Grok_Bot_${version}_${t.plat}.${t.ext}`, source: 'vendor' };
+}
+
+export async function resolveGrokBotAsset(key, { fetchImpl = fetch, repo = GROKBOT_GITHUB_REPO } = {}) {
+  if (!FEED_TARGETS[key]) throw new Error(`unknown host key ${key}`);
+  try {
+    const rel = await githubGrokbotRelease({ fetchImpl, repo });
+    const asset = matchGithubAsset(rel.assets || [], key);
+    if (asset && asset.browser_download_url) {
+      const version = String(rel.tag_name || '').replace(/^grokbot-v/, '') || 'unknown';
+      return {
+        version,
+        url: asset.browser_download_url,
+        name: asset.name,
+        source: 'github',
+        tag: rel.tag_name,
+      };
+    }
+  } catch { /* fall through to vendor */ }
+  return vendorFeedAsset(key, { fetchImpl });
+}
+
+async function downloadTo(url, dest, { fetchImpl = fetch, log = () => {} } = {}) {
+  mkdirSync(dirname(dest), { recursive: true });
+  const r = await fetchImpl(url, {
+    headers: uaHeaders(),
+    redirect: 'follow',
+    signal: AbortSignal.timeout(15 * 60 * 1000),
+  });
+  if (!r.ok) throw new Error(`download ${r.status} ${url}`);
+  const total = Number(r.headers.get('content-length') || 0);
+  log(`openzoo: downloading Grok Bot${total ? ` (${Math.round(total / 1024 / 1024)} MB)` : ''}…`);
+  if (!r.body) throw new Error('download: empty body');
+  await pipeline(Readable.fromWeb(r.body), createWriteStream(dest));
+  const sz = statSync(dest).size;
+  if (sz < 50 * 1024 * 1024) throw new Error(`download too small (${sz} bytes) — ${url}`);
+  log(`openzoo: downloaded ${Math.round(sz / 1024 / 1024)} MB -> ${dest}`);
+  return dest;
+}
+
+function run(cmd, args, opts = {}) {
+  const r = spawnSync(cmd, args, { encoding: 'utf8', timeout: opts.timeout || 120000, stdio: opts.stdio || 'pipe' });
+  if (r.error) throw r.error;
+  if (r.status !== 0) {
+    throw new Error(`${cmd} ${args.join(' ')} failed (${r.status}): ${(r.stderr || r.stdout || '').slice(0, 400)}`);
+  }
+  return r;
+}
+
+export function installGrokBotArtifact({ archivePath, key, home = homedir(), log = () => {} }) {
+  const platform = key.startsWith('linux') ? 'linux' : key.startsWith('win32') ? 'win32' : 'darwin';
+  const dest = installDest(home, platform);
+  mkdirSync(dirname(dest), { recursive: true });
+
+  if (platform === 'darwin') {
+    const tmp = join(distDir(home), 'extract');
+    rmSync(tmp, { recursive: true, force: true });
+    mkdirSync(tmp, { recursive: true });
+    run('unzip', ['-o', archivePath, '-d', tmp]);
+    const app = findAppBundle(tmp);
+    if (!app) throw new Error(`zip has no Grok Bot.app: ${archivePath}`);
+    rmSync(dest, { recursive: true, force: true });
+    mkdirSync(dirname(dest), { recursive: true });
+    cpSync(app, dest, { recursive: true });
+    const bin = join(dest, 'Contents', 'MacOS', 'Grok Bot');
+    if (!existsSync(bin)) throw new Error(`installed app missing binary: ${bin}`);
+    log(`openzoo: installed Grok Bot.app -> ${dest}`);
+    return bin;
+  }
+
+  if (platform === 'linux') {
+    copyFileSync(archivePath, dest);
+    chmodSync(dest, 0o755);
+    log(`openzoo: installed AppImage -> ${dest}`);
+    return dest;
+  }
+
+  // NSIS user installer (vendor + our re-host). /S is silent; the default
+  // dest is %LOCALAPPDATA%\Programs\Grok Bot\Grok Bot.exe.
+  log('openzoo: running Grok Bot installer (silent)');
+  run(archivePath, ['/S'], { timeout: 300000, stdio: 'ignore' });
+  const deadline = Date.now() + 60000;
+  while (Date.now() < deadline) {
+    if (existsSync(dest)) return dest;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 500);
+  }
+  if (!existsSync(dest)) {
+    throw new Error(`installer finished but ${dest} is missing — run ${archivePath} yourself`);
+  }
+  return dest;
+}
+
+export async function ensureGrokBot({
+  existing,
+  platform = process.platform,
+  arch = machineArch(),
+  home = homedir(),
+  fetchImpl = fetch,
+  log = (m) => console.error(m),
+} = {}) {
+  if (existing && existsSync(existing)) return existing;
+  if (process.env.GROKBOT_NO_FETCH === '1') {
+    throw new Error('Grok Bot missing and GROKBOT_NO_FETCH=1');
+  }
+  const key = hostKey(platform, arch);
+  const asset = await resolveGrokBotAsset(key, { fetchImpl });
+  log(`openzoo: Grok Bot ${asset.version} from ${asset.source} (${asset.name})`);
+  const destFile = join(distDir(home), asset.name);
+  if (!existsSync(destFile) || statSync(destFile).size < 50 * 1024 * 1024) {
+    await downloadTo(asset.url, destFile, { fetchImpl, log });
+  } else {
+    log(`openzoo: using cached ${destFile}`);
+  }
+  return installGrokBotArtifact({ archivePath: destFile, key, home, log });
+}

package/lib/grokbotweb.js

@@ -16,7 +16,7 @@ import { fileURLToPath } from 'node:url';
 import { exec } from 'node:child_process';
 
 import { config } from './config.js';
-import { readHouseRoster } from './grokbotAccount.js';
+import { readHouseRoster, groupShareState } from './grokbotAccount.js';
 import { ingestUpload, lookupUpload } from './grokbotUploads.js';
 import { spendChipSource, sessionSpendState } from './ozSpendChip.js';
 
@@ -215,8 +215,8 @@ const MIME = {
 };
 
 export const HOST_STATUS = {
-  hostVersion: '0.30.0',
-  latestHostVersion: '0.30.0',
+  hostVersion: '0.36.0',
+  latestHostVersion: '0.36.0',
   hostUpdateAvailable: false,
   isBusy: false,
   capabilities: [],
@@ -233,9 +233,10 @@ export const COORD_DEFAULTS = {
   promptAcceptanceStatus: { outcome: 'found', record: { status: 'accepted' } },
   getAgentTranscriptTail: { entries: [] },
   openAgentTail: { entries: [] },
-  getForeverBoxStatus: { agentId: 'openzoo', state: 'ready' },
-  ensureForeverBox: { agentId: 'openzoo', state: 'ready' },
+  getForeverBoxStatus: { agentId: 'openzoo', state: 'running' },
+  ensureForeverBox: { agentId: 'openzoo', state: 'running' },
   getBoxSecretsStatus: { keys: [], isApplied: false, lastAppliedAtMs: null },
+  resolveAgentCreation: { kind: 'box' },
   isGlobalSearchEnabled: false,
   isEgressTunnelAvailable: false,
   getSharingState: { isEnabled: false, selfAuthId: null, pendingJoinRequests: [], rooms: [], typingUsers: [] },
@@ -679,7 +680,7 @@ async function ensureHijack(log) {
   const { startCursorBackend } = await import('./cursorbackend.js');
   const models = ['gpt-4o', 'gpt-4o-mini'].map((n) => ({ name: n, label: n }));
   try {
-    startCursorBackend({
+    await startCursorBackend({
       port: 8443,
       models,
       log: (m) => log(`  backend: ${m}`),
@@ -761,7 +762,7 @@ export async function startGrokBotWeb(opts = {}) {
     res.writeHead(status, out);
   }
 
-  const server = http.createServer((req, res) => {
+  const server = http.createServer(async (req, res) => {
     const urlPath = decodeURIComponent((req.url || '/').split('?')[0]);
     if (urlPath === '/oz-spend') {
       writeHead(res, 200, {
@@ -772,6 +773,21 @@ export async function startGrokBotWeb(opts = {}) {
       res.end(JSON.stringify({ ok: true, ...sessionSpendState() }));
       return;
     }
+    if (urlPath === '/oz-share') {
+      writeHead(res, 200, {
+        'content-type': 'application/json',
+        'cache-control': 'no-store',
+        'access-control-allow-origin': '*',
+      }, req);
+      let rooms = [];
+      try {
+        const st = await fetch('http://127.0.0.1:4799/state', { signal: AbortSignal.timeout(1500) }).then((r) => r.json());
+        rooms = Array.isArray(st.rooms) ? st.rooms : [];
+      } catch { /* grokroom down */ }
+      const share = groupShareState({ agent: { isGroup: rooms.length > 0 }, rooms });
+      res.end(JSON.stringify({ ok: true, ...share }));
+      return;
+    }
     if (urlPath === '/oz-health') {
       writeHead(res, 200, { 'content-type': 'application/json' }, req);
       res.end(JSON.stringify({