@clearlysh/beehaven 0.8.20 → 0.8.22

package/dist/agent-sessions.js

@@ -210,7 +210,7 @@ export class AgentSessions {
             return;
         }
         const base = this.wsBase().replace(/\/$/, '');
-        const url = `${base}/my/hive/ws?token=${encodeURIComponent(spec.token)}&clientType=agent&client=agent&wsType=workspace&deviceId=agent-${encodeURIComponent(agentId)}`;
+        const url = `${base}/my/workspace/ws?token=${encodeURIComponent(spec.token)}&clientType=agent&client=agent&deviceId=agent-${encodeURIComponent(agentId)}`;
         let ws;
         let opened = false;
         let settled = false;

package/dist/build-channel.js

@@ -53,9 +53,9 @@ export const PUBLIC_BUILD = true;
  * ⚠ REWRITTEN IN `dist/` AT BUILD TIME, like `PUBLIC_BUILD`. `unstamped` is what a source checkout
  * carries and what `tsx`/`vitest` see, and it is honest: nothing has stamped them.
  */
-export const BUILD_SHA = '046981bccb35-dirty';
+export const BUILD_SHA = '49efa8cde4ed-dirty';
 /** ISO-8601 minute precision, UTC. Rewritten in `dist/` by `scripts/stamp-build-channel.mjs`. */
-export const BUILD_TIME = '2026-09-29T05:23Z';
+export const BUILD_TIME = '2026-09-30T19:01Z';
 /**
  * The build identity as one short string, for `--version`.
  *

package/dist/cli.js

@@ -1950,6 +1950,7 @@ async function run() {
          * flag with two meanings is worse than a refusal that names the alternative.
          */
         'ticket',
+        'inbox',
         /**
          * ⚠ `trash` — CBH2-34. It pages `document-list { archived: true }` and honours `--limit` up to
          * 500, announcing the clamp when the ask is higher. Left off this list the flag is REFUSED,
@@ -6647,9 +6648,7 @@ complete -F _beehaven_completions beehaven`);
             break;
         }
         case 'swarm': {
-            // Distributed hive mesh — see the swarm, set THIS machine's role, and
-            // dispatch work to worker beehives. One namespace for the whole mesh
-            // (`hive`/`hives` already name the local-apps concept).
+            // Queen and Omni identity commands remain; node registry/dispatch was retired.
             const { cmdSwarm } = await import('./commands/swarm.js');
             await cmdSwarm(positionals, values);
             break;

package/dist/commands/help.js

@@ -1830,42 +1830,22 @@ const PAGES = {
         related: ['app', 'pipe', 'pwd'],
     },
     swarm: {
-        synopsis: 'beehaven swarm <list|queen|role|dispatch|bees|sample-honey|forge-omni> [args]',
-        description: `The distributed HIVE MESH + its two AI bees. A "beehive" is a
-    node running the daemon + hives (this Mac, a headless server via
-    \`start --headless\`, or a Cloudflare container). A QUEEN hive orchestrates;
-    WORKER hives execute the work the queen dispatches. This machine registers
-    itself when the daemon connects — the Mac defaults to QUEEN, a
-    headless/container node to WORKER.
-
-    Mesh subcommands:
-      list                     Every beehive: role, kind, hives, online state
-      queen                    Which NODE is orchestrating right now
-      role <queen|worker>      Make THIS machine the queen (or a worker)
-      whoami                   This machine's beehive identity
-      dispatch <cap> <action> [json]   Route work to the best worker (--target pins one)
-      forget <deviceId>        Drop a stale OFFLINE node
-
-    The bees (AI):
+        synopsis: 'beehaven swarm <bees|sample-honey|forge-omni> [args]',
+        description: `The two AI bees. The unfinished node registry and dispatch
+    protocol were retired; they do not route work.
+
       bees                     👑 Queen + 🐝 Omni status
       sample-honey             👑 Queen ingests the WHOLE workspace corpus
                                (memories, brain, prompts, brand voice) and gets fat
       forge-omni [--force]     👑 Queen distills a LEAN copy of you → 🐝 Omni,
                                your personal-assistant AI TWIN (--force re-samples)
 
-    The Queen bee runs on the queen hive — same crown, two layers (the NODE vs.
-    the AI). Omni is the owner's twin: log in as it with \`agent login omni-bee\`.
-    Distinct from \`hives\` (local apps) — a beehive is a whole NODE.`,
+    Omni is the owner's twin: log in as it with \`agent login omni-bee\`.`,
         flags: [
-            {
-                name: '--target <deviceId>',
-                desc: 'dispatch: pin to a specific beehive instead of auto-selecting',
-            },
             { name: '--force', desc: 'forge-omni: re-sample the honey before distilling' },
         ],
         examples: [
-            { cmd: 'beehaven swarm list', note: 'see the whole swarm' },
-            { cmd: 'beehaven swarm role queen', note: 'make this machine the queen' },
+            { cmd: 'beehaven swarm bees', note: 'see Queen and Omni' },
             { cmd: 'beehaven swarm sample-honey', note: 'Queen ingests everything' },
             { cmd: 'beehaven swarm forge-omni', note: 'forge your AI twin' },
             { cmd: 'beehaven agent login omni-bee', note: 'log in as your twin' },

package/dist/commands/inbox.js

@@ -82,7 +82,7 @@ async function call(action, input, values) {
 async function printList(box, values) {
     const res = await call('inbox-list', {
         box, ...(values.search ? { q: String(values.search) } : {}), ...(values.as ? { as: String(values.as) } : {}),
-        ...(values.limit ? { limit: Number(values.limit) } : {}),
+        ...(values.limit !== undefined ? { limit: Number(values.limit) } : {}),
     }, values);
     const threads = res.threads ?? [];
     const counts = res.counts ?? {};

package/dist/commands/swarm.js

@@ -1,26 +1,7 @@
 /**
- * swarm / hive — the distributed "hive mesh" from the terminal.
- *
- * A **beehive** is a node running the daemon + hives (this Mac, a headless
- * server, or a Cloudflare container). A **queen hive** orchestrates; **worker
- * hives** execute. This machine registers itself automatically when the daemon
- * connects (see daemon.ts `registerBeehive`) — these verbs let you SEE the
- * swarm, designate roles, and route work.
- *
- *   beehaven swarm list                       # every beehive: role, kind, hives, online
- *   beehaven swarm queen                       # who's orchestrating
- *   beehaven swarm role <queen|worker>         # make THIS machine the queen (or a worker)
- *   beehaven swarm whoami                       # this machine's beehive identity
- *   beehaven swarm dispatch <cap> <action> [json]  # route work to the best worker
- *   beehaven swarm forget <deviceId>           # drop a stale offline node
- *
- * All cloud state lives in the always-on Home DO (rpc/swarm-rpcs.ts); these
- * verbs reach it through the daemon over IPC via `rpcOnce`. (One namespace on
- * purpose — `hive`/`hives` already name the local-apps concept.)
+ * swarm — the Queen and Omni identity commands. The unfinished node registry and
+ * dispatch protocol were retired; these two bees remain independent of it.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { homedir, hostname, platform } from 'node:os';
-import { join } from 'node:path';
 import { rpcOnce } from '../ipc-client.js';
 const dim = (s) => `\x1b[2m${s}\x1b[0m`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
@@ -28,50 +9,28 @@ const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
 const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
 const red = (s) => `\x1b[31m${s}\x1b[0m`;
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
-const CONFIG_DIR = join(homedir(), '.beehaven');
-const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
-/** This machine's stable beehive id — MUST match relay.ts `deviceId`. */
-function thisDeviceId() {
-    return `${hostname()}-${platform()}`;
-}
-function loadConfig() {
-    try {
-        return existsSync(CONFIG_FILE) ? JSON.parse(readFileSync(CONFIG_FILE, 'utf8')) : {};
-    }
-    catch {
-        return {};
-    }
-}
-function saveConfig(update) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(CONFIG_FILE, JSON.stringify({ ...loadConfig(), ...update }, null, 2));
-}
 /** Unwrap the daemon's { result } envelope (rpcOnce sometimes returns it raw). */
 function unwrap(r) {
     return r?.result ?? r ?? {};
 }
 // ══════════════════════════════ swarm ══════════════════════════════
 export async function cmdSwarm(positionals, values) {
-    const sub = positionals[1] ?? 'list';
-    const rest = positionals.slice(2);
+    const sub = positionals[1] ?? 'bees';
     switch (sub) {
         case 'list':
         case 'ls':
-            return swarmList();
         case 'queen':
-            return swarmQueen();
         case 'role':
-            return swarmRole(rest);
         case 'whoami':
         case 'status':
         case 'me':
-            return swarmWhoami();
         case 'dispatch':
         case 'run':
-            return swarmDispatch(rest, values);
         case 'forget':
         case 'rm':
-            return swarmForget(rest);
+            console.log('  The node swarm registry and dispatch protocol were retired.');
+            console.log(dim('  Use beehaven swarm bees | sample-honey | forge-omni for Queen and Omni.'));
+            return;
         // The bees — 👑 Queen (samples all the honey) + 🐝 Omni (the owner's twin).
         case 'bees':
             return swarmBees();
@@ -83,121 +42,8 @@ export async function cmdSwarm(positionals, values) {
             return swarmForgeOmni(values);
         default:
             console.log(`  Unknown swarm subcommand '${sub}'.`);
-            console.log(dim('  Try: beehaven swarm list | queen | role | whoami | dispatch | forget | bees | sample-honey | forge-omni'));
-    }
-}
-async function swarmList() {
-    let res;
-    try {
-        res = unwrap(await rpcOnce('swarm-list', {}, 8_000));
-    }
-    catch {
-        console.log(red('  Cannot reach the swarm.') + dim('  Is the daemon running?  beehaven status'));
-        return;
-    }
-    const beehives = res?.beehives ?? [];
-    if (!beehives.length) {
-        console.log('');
-        console.log('  🐝 No beehives registered yet.');
-        console.log(dim('  This machine registers automatically when the daemon connects.'));
-        console.log(dim('  Bring more online: `beehaven start --headless` on a server, or a cloud container.'));
-        console.log('');
-        return;
-    }
-    const me = thisDeviceId();
-    console.log('');
-    console.log(`  🐝 ${bold('Swarm')} ${dim(`— ${res.online}/${res.count} online`)}`);
-    console.log(dim('  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-    for (const b of beehives) {
-        const dot = b.online ? green('●') : dim('○');
-        const crown = b.role === 'queen' ? '👑' : '🐝';
-        const mine = b.deviceId === me ? cyan('  ← this machine') : '';
-        const caps = (b.capabilities ?? []).slice(0, 8).join(', ') || dim('no hives');
-        console.log(`  ${dot} ${crown} ${cyan(String(b.hostname).padEnd(22))} ${dim(String(b.kind).padEnd(15))} ${(b.role === 'queen' ? yellow('queen') : 'worker').padEnd(7)}${mine}`);
-        console.log(`        ${dim(b.deviceId)}`);
-        console.log(`        ${dim('hives:')} ${caps}${b.load ? dim(`   load:${b.load}`) : ''}`);
-    }
-    console.log('');
-    console.log(dim(`  queen: ${res.queen ? green(res.queen) : 'none — promote one with `beehaven swarm role queen`'}`));
-    console.log('');
-}
-async function swarmQueen() {
-    let res;
-    try {
-        res = unwrap(await rpcOnce('swarm-queen', {}, 8_000));
-    }
-    catch {
-        console.log(red('  Cannot reach the swarm.'));
-        return;
-    }
-    const q = res?.queen;
-    console.log('');
-    if (!q) {
-        console.log('  👑 No queen designated.');
-        console.log(dim('  Make this machine the queen:  beehaven swarm role queen'));
-    }
-    else {
-        console.log(`  👑 ${bold('Queen')} — ${cyan(q.hostname)} ${q.online ? green('(online)') : dim('(offline)')}`);
-        console.log(`     ${dim(q.deviceId)}  ·  ${dim(q.kind)}`);
-        console.log(`     ${dim('hives:')} ${(q.capabilities ?? []).join(', ') || dim('none')}`);
-    }
-    console.log('');
-}
-async function swarmDispatch(rest, values) {
-    const capability = rest[0];
-    const action = rest[1];
-    if (!capability || !action) {
-        console.log('  Usage: beehaven swarm dispatch <capability> <action> [json]');
-        console.log(dim('    capability = the hive to run (e.g. motion-studio, voice)'));
-        console.log(dim('    e.g. beehaven swarm dispatch voice synthesize \'{"text":"hi"}\''));
-        return;
-    }
-    let input = {};
-    if (rest[2]) {
-        try {
-            input = JSON.parse(rest[2]);
-        }
-        catch {
-            console.log(red('  Invalid JSON payload.'));
-            return;
-        }
+            console.log(dim('  Try: beehaven swarm bees | sample-honey | forge-omni'));
     }
-    const targetDeviceId = typeof values?.target === 'string' ? values.target : undefined;
-    console.log(dim(`  → dispatching ${capability}:${action}${targetDeviceId ? ` @${targetDeviceId}` : ' to the best worker'}…`));
-    let res;
-    try {
-        res = unwrap(await rpcOnce('swarm-dispatch', { capability, action, input, targetDeviceId }, 300_000));
-    }
-    catch (e) {
-        console.log(red(`  Dispatch failed: ${e?.message ?? e}`));
-        return;
-    }
-    if (res?.error || res?.ok === false) {
-        console.log(red(`  ✗ ${res.error ?? 'dispatch failed'}`) + (res.code ? dim(`  [${res.code}]`) : ''));
-        return;
-    }
-    console.log(green(`  ✓ ${capability}:${action}`) + dim(`  on ${res.targetDeviceId} · ${res.durationMs}ms`));
-    console.log(JSON.stringify(res.result, null, 2));
-}
-async function swarmForget(rest) {
-    const deviceId = rest[0];
-    if (!deviceId) {
-        console.log('  Usage: beehaven swarm forget <deviceId>');
-        return;
-    }
-    let res;
-    try {
-        res = unwrap(await rpcOnce('swarm-forget', { deviceId }, 8_000));
-    }
-    catch (e) {
-        console.log(red(`  ${e?.message ?? e}`));
-        return;
-    }
-    if (res?.error) {
-        console.log(red(`  ✗ ${res.error}`));
-        return;
-    }
-    console.log(green(`  ✓ forgot beehive ${deviceId}`));
 }
 // ══════════════════════════════ the bees ══════════════════════════════
 // 👑 Queen samples ALL the honey (the full corpus, gets fat); 🐝 Omni is the
@@ -283,59 +129,3 @@ async function swarmForgeOmni(values) {
     console.log(dim(`  Log in as your twin:  ${res.loginCommand || 'beehaven agent login omni-bee'}`));
     console.log('');
 }
-// ─────────────────────── this machine's role/identity ───────────────────────
-async function swarmRole(rest) {
-    const role = (rest[0] ?? '').toLowerCase();
-    if (role !== 'queen' && role !== 'worker') {
-        const current = loadConfig().role ?? (process.env.BEEHAVEN_HEADLESS === '1' ? 'worker' : 'queen');
-        console.log('  Usage: beehaven swarm role <queen|worker>');
-        console.log(dim(`  This machine is currently: ${current === 'queen' ? yellow('👑 queen') : 'worker'}`));
-        return;
-    }
-    // 1) Persist locally so it survives restarts + the daemon re-registers with it.
-    saveConfig({ role });
-    // 2) Update the cloud row immediately so the swarm reflects it now (the daemon
-    //    catches up its own role on its next register, ~2 min, or `beehaven restart`).
-    const deviceId = thisDeviceId();
-    let synced = false;
-    try {
-        const r = unwrap(await rpcOnce('hive-set-role', { deviceId, role }, 8_000));
-        synced = !!r?.ok;
-    }
-    catch {
-        /* daemon offline — local config still saved; applies on next connect */
-    }
-    console.log('');
-    console.log(`  ${green('✓')} This machine is now the ${role === 'queen' ? yellow('👑 queen hive') : 'worker hive'}.`);
-    console.log(dim(synced
-        ? '  Synced to the swarm. It orchestrates from here.'
-        : '  Saved locally — applies when the daemon next connects (beehaven restart to apply now).'));
-    console.log('');
-}
-async function swarmWhoami() {
-    const cfg = loadConfig();
-    const deviceId = thisDeviceId();
-    const role = cfg.role ?? (process.env.BEEHAVEN_HEADLESS === '1' ? 'worker' : 'queen');
-    const kind = process.env.BEEHAVEN_KIND ?? (process.env.BEEHAVEN_HEADLESS === '1' ? 'headless' : 'local-mac');
-    console.log('');
-    console.log(`  🐝 ${bold('This beehive')}`);
-    console.log(`     deviceId:  ${cyan(deviceId)}`);
-    console.log(`     role:      ${role === 'queen' ? yellow('👑 queen') : 'worker'}  ${dim('(beehaven swarm role <queen|worker>)')}`);
-    console.log(`     kind:      ${kind}`);
-    // Best-effort live view from the swarm registry.
-    try {
-        const res = unwrap(await rpcOnce('swarm-list', {}, 5_000));
-        const me = (res?.beehives ?? []).find((b) => b.deviceId === deviceId);
-        if (me) {
-            console.log(`     online:    ${me.online ? green('yes') : dim('no')}`);
-            console.log(`     hives:     ${(me.capabilities ?? []).join(', ') || dim('none')}`);
-        }
-        else {
-            console.log(dim('     not yet registered in the swarm — the daemon registers on connect.'));
-        }
-    }
-    catch {
-        /* daemon offline */
-    }
-    console.log('');
-}

package/dist/daemon.js

@@ -45,7 +45,6 @@ import { join, dirname, relative } from 'path';
 import { fileURLToPath } from 'url';
 import { compareVersions, usableUpdateDigest } from './version-utils.js';
 import { installKind } from './commands/self-update.js';
-import { collectSystemTelemetry, collectGitStatus } from './telemetry.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const CONFIG_DIR = join(homedir(), '.beehaven');
 const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
@@ -2502,9 +2501,27 @@ export async function startDaemon(opts) {
         });
     });
     // Local client raw sends → forward to DO via relay
-    ipc.on('send', (msg) => {
-        if (relay.isConnected()) {
-            relay.wsSend(msg);
+    const ipcLiveQueries = new Map();
+    ipc.on('send', (msg, clientId) => {
+        if (!relay.isConnected() || !relay.wsSend(msg))
+            return;
+        const queryId = typeof msg?.queryId === 'string' ? msg.queryId : '';
+        if (!queryId || !clientId)
+            return;
+        if (msg.type === 'sql:subscribe') {
+            if (!ipcLiveQueries.has(clientId)) {
+                ipcLiveQueries.set(clientId, new Set());
+                ipc.onClientDisconnect(clientId, () => {
+                    for (const ownedId of ipcLiveQueries.get(clientId) ?? []) {
+                        relay.wsSend({ type: 'sql:unsubscribe', queryId: ownedId });
+                    }
+                    ipcLiveQueries.delete(clientId);
+                });
+            }
+            ipcLiveQueries.get(clientId).add(queryId);
+        }
+        else if (msg.type === 'sql:unsubscribe') {
+            ipcLiveQueries.get(clientId)?.delete(queryId);
         }
     });
     // Local client HTTP proxy: make a fetch with the daemon's Firebase ID
@@ -3060,57 +3077,6 @@ export async function startDaemon(opts) {
         if (daemonAppManager) {
             relay.sendLocalAppStatus(daemonAppManager.status());
         }
-        // Capabilities may have changed (install/uninstall) — re-advertise this
-        // node's beehive record so the swarm's dispatch matching stays accurate.
-        registerBeehive();
-    }
-    // ── Distributed hive mesh — advertise this daemon as a beehive ──
-    //
-    // The node declares its ROLE (queen orchestrates / worker executes), its
-    // KIND (this Mac / a headless server / a cloud container), and its
-    // CAPABILITIES (the hives it can run — the dispatch match keys). The user's
-    // Mac defaults to QUEEN (the natural orchestrator — where the human is); a
-    // headless/container daemon defaults to WORKER. `beehaven swarm role` (config
-    // `role`) or BEEHAVEN_ROLE overrides. See rpc/swarm-rpcs.ts for the queen
-    // + dispatch side.
-    function beehiveRole() {
-        const env = (process.env.BEEHAVEN_ROLE || '').toLowerCase();
-        if (env === 'queen' || env === 'worker')
-            return env;
-        const cfgRole = String(loadConfig()?.role || '').toLowerCase();
-        if (cfgRole === 'queen' || cfgRole === 'worker')
-            return cfgRole;
-        return process.env.BEEHAVEN_HEADLESS === '1' ? 'worker' : 'queen';
-    }
-    function beehiveKind() {
-        const env = (process.env.BEEHAVEN_KIND || '').toLowerCase();
-        if (env === 'local-mac' || env === 'headless' || env === 'cloud-container')
-            return env;
-        return process.env.BEEHAVEN_HEADLESS === '1' ? 'headless' : 'local-mac';
-    }
-    function beehiveCapabilities() {
-        try {
-            const s = daemonAppManager?.status();
-            const caps = new Set(Array.isArray(s?.buildingTypes) ? s.buildingTypes : []);
-            // Surface app names too so `swarm list` reads friendly (motion-studio,
-            // voice, recorder …) even before a building instance has spun up.
-            for (const a of s?.apps ?? [])
-                if (a?.name)
-                    caps.add(String(a.name));
-            return [...caps];
-        }
-        catch {
-            return [];
-        }
-    }
-    function registerBeehive() {
-        if (!relay.isConnected())
-            return;
-        relay.sendSwarmRegister({
-            role: beehiveRole(),
-            kind: beehiveKind(),
-            capabilities: beehiveCapabilities(),
-        });
     }
     /** Sync a single uninstall to the Home DO. */
     function syncUninstallToCloud(name) {
@@ -4221,18 +4187,6 @@ export async function startDaemon(opts) {
         setTimeout(() => {
             syncAvatarFromCloud().catch(() => { });
         }, 250);
-        // Register as a beehive the moment the WS opens so the node appears in
-        // the swarm immediately; syncInstalledAppsToCloud + the periodic tick
-        // below re-register with the full capability list once hives finish
-        // loading. Deferred slightly so the capability scan sees loaded hives.
-        setTimeout(() => {
-            try {
-                registerBeehive();
-            }
-            catch {
-                /* best-effort */
-            }
-        }, 500);
         // #111 — if startup rehydrated a Claude credential from keychain,
         // tell the worker now that the WS is open. Worker handler at
         // `case 'canvas-credential-rehydrated':` refreshes daemon_confirmed_at
@@ -4429,42 +4383,9 @@ export async function startDaemon(opts) {
     // Auto-update: check hourly, install when idle
     checkAndAutoUpdate();
     setInterval(() => checkAndAutoUpdate(), UPDATE_CHECK_INTERVAL);
-    // Telemetry: opt-in via config.shareTelemetry (default off, togglable from cloud)
-    // Sends system stats + agent metrics + git status every 2 minutes
-    let lastActiveCwd = null;
-    watcher.on('event', (e) => {
-        if (e.cwd)
-            lastActiveCwd = e.cwd;
-    });
-    const sendTelemetry = () => {
-        if (!daemonConfig?.shareTelemetry || !relay.isConnected())
-            return;
-        try {
-            const system = collectSystemTelemetry();
-            const agentSnapshot = metrics.snapshot();
-            const git = lastActiveCwd ? collectGitStatus(lastActiveCwd) : null;
-            relay.sendTelemetry({ system, git, agent: agentSnapshot });
-        }
-        catch {
-            /* non-critical */
-        }
-    };
-    setTimeout(sendTelemetry, 10_000);
-    setInterval(sendTelemetry, 120_000);
-    // Reset metrics window every 5 minutes
+    // Reset the LOCAL metrics window every 5 minutes (no network).
     setInterval(() => metrics.resetWindow(), 5 * 60_000);
-    // Re-advertise this beehive every 2 min: refreshes last_seen and, crucially,
-    // self-heals the swarm's live routing map after a Home-DO hibernation dropped
-    // it (the WS survives hibernation, so without this the node would read
-    // "offline" until its next reconnect). Cheap — one WS frame.
-    setInterval(() => {
-        try {
-            registerBeehive();
-        }
-        catch {
-            /* best-effort */
-        }
-    }, 120_000);
+    // No timed telemetry or swarm-register frames: an idle daemon must cost nothing.
     // Start REPL
     if (opts?.repl !== false && !process.env.BEEHAVEN_NO_REPL)
         repl.start();

package/dist/ipc-server.js

@@ -471,7 +471,7 @@ export class IpcServer extends EventEmitter {
                 break;
             case 'send':
                 // Forward raw message to relay → DO
-                this.emit('send', msg.msg);
+                this.emit('send', msg.msg, client.id);
                 break;
             case 'app-rpc':
                 // Forward RPC to a local app building (not the cloud relay).

package/dist/relay.js

@@ -522,21 +522,17 @@ export class Relay {
                 this.scheduleReconnect();
             return;
         }
-        // The daemon holds ONE socket — to the user's HIVE (`/my/hive/ws`, the per-user
-        // multiplexer). The hive opens a server-side portal to the caller's CANONICAL workspace
-        // (no `workspaceId` → the hive resolves it from `building_assignments`) and pipes it
-        // transparently, so every workspace RPC (canvas-invoke, actions, table sync) round-trips
-        // exactly as before — plus the daemon shares the same socket the web app uses. (Plain
-        // synchronous URL — no pre-connect HTTP hop — so nothing can stall the dial.)
+        // Workspace traffic terminates on the workspace DO itself. A Hive portal can close after
+        // 60 s while leaving the daemon socket open; then cloud pushes and local-tool requests
+        // disappear until the daemon sends another frame. The direct socket hibernates safely.
         const params = new URLSearchParams({
             token,
             client: process.env.BEEHAVEN_CLIENT || 'daemon',
             clientType: process.env.BEEHAVEN_CLIENT_TYPE || 'daemon',
-            wsType: 'workspace',
         });
         if (this.deviceId)
             params.set('deviceId', String(this.deviceId).slice(0, 64));
-        const url = `${this.wsBase()}/my/hive/ws?${params.toString()}`;
+        const url = `${this.wsBase()}/my/workspace/ws?${params.toString()}`;
         const ws = new WebSocket(url);
         // Wait for open or first error/close before resolving
         await new Promise((resolve) => {
@@ -1228,34 +1224,6 @@ export class Relay {
     sendLocalAppStatus(status) {
         this.wsSend({ type: 'local-app-status', ...status });
     }
-    /**
-     * Advertise this daemon as a BEEHIVE in the distributed hive mesh.
-     *
-     * The Home DO's `case 'swarm-register'` upserts a durable node row (keyed by
-     * this stable deviceId) + maps deviceId → this live session, which is how the
-     * swarm knows the node is online and how the queen targets a dispatch at it.
-     * Re-sent on connect, whenever capabilities change, and on a periodic cadence
-     * (see daemon.ts `registerBeehive`) so it also serves as the beehive's
-     * keepalive and self-heals after a DO hibernation dropped the live map.
-     *
-     *   role         'queen' (orchestrator) | 'worker' (executor)
-     *   kind         'local-mac' | 'headless' | 'cloud-container'
-     *   capabilities the hive/building names this node can run (dispatch match keys)
-     */
-    sendSwarmRegister(opts) {
-        if (!this.connected)
-            return;
-        this.wsSend({
-            type: 'swarm-register',
-            deviceId: this.deviceId,
-            role: opts.role,
-            kind: opts.kind,
-            capabilities: opts.capabilities,
-            hostname: hostname(),
-            os: platform(),
-            root: homedir(),
-        });
-    }
     /** Start periodic token self-refresh (every 50 min, for headless/long-running daemons) */
     tokenRefreshTimer = null;
     startTokenRefresh() {

package/dist/verb-surface.js

@@ -140,6 +140,7 @@ export const VERB_SURFACE = {
     describe: { cls: 'BEYOND', why: 'alias', aliasOf: 'explain' },
     rpc: { cls: 'BEYOND', why: 'the raw gateway envelope, below `call`' },
     ticket: { cls: 'BEYOND', why: 'resolves a board before creating, and refuses a numeric priority the API inverts' },
+    inbox: { cls: 'PROVISIONAL', why: 'reads and manages workspace message threads; keep until door traffic is measured' },
     comment: { cls: 'BEYOND', why: 'addresses ANY surface by key/title and turns per-surface anchor flags into one call; prints who the @s reached' },
     comments: { cls: 'BEYOND', why: 'served by the comment module', aliasOf: 'comment' },
     mention: { cls: 'BEYOND', why: 'resolves an 8-char id prefix before acking, and reads your mention queue as whichever identity you are' },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clearlysh/beehaven",
-  "version": "0.8.20",
+  "version": "0.8.22",
   "description": "Beehaven CLI — command your Clearly workspace, agents, and canvas from the terminal",
   "private": false,
   "type": "module",