@clearlysh/beehaven 0.8.21 → 0.8.23

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 = 'f651981dfa50';
+export const BUILD_SHA = '8585349e92e9-dirty';
 /** ISO-8601 minute precision, UTC. Rewritten in `dist/` by `scripts/stamp-build-channel.mjs`. */
-export const BUILD_TIME = '2026-09-29T18:13Z';
+export const BUILD_TIME = '2026-10-02T00:47Z';
 /**
  * The build identity as one short string, for `--version`.
  *

package/dist/cli.js

@@ -309,7 +309,8 @@ ${DEV_ONLY_HELP ? `  PROJECT — build your own Durable Object backend  (HIVE_DE
     app setup <name>                       Re-run a hive's setup script
     install <pkg>                          Shorthand for "app install <pkg>"
     skills install                         Teach every agent about Clearly —
-                                           writes the shipped SKILL.md files
+                                           writes the shipped SKILL.md files + the
+                                           AGENTS.md / GEMINI.md / CLAUDE.md block
     skills <list|sync|remove>              Manage skills paired with installed hives
 
     Deep dive:  beehaven help hives        Mental model + install/connect/call loop
@@ -437,7 +438,9 @@ ${DEV_ONLY_HELP ? `
   ACCOUNT
   ─────────────────────────────────────────────────────────────────────
 
-    login                                  Sign in (browser) — primary flow
+    login                                  Sign in (browser) — primary flow; also teaches
+                                           your agents (skills + AGENTS.md block;
+                                           --no-agent-setup to skip)
     login --email <e> --password <p>       Self-hosted email/password (set BEEHAVEN_API_URL)
     logout                                 Clear local credentials + keychain
     signup                                 Open sign-up page in browser
@@ -1492,6 +1495,7 @@ async function run() {
             // Paired Claude Code skill install policy (see commands/skills.ts)
             'with-skills': { type: 'boolean', default: false },
             'no-skills': { type: 'boolean', default: false },
+            'no-agent-setup': { type: 'boolean', default: false },
             // ── mobile-install metadata for `beehaven teleport <build>.ipa --composition <id>`
             //    (see commands/workspace.ts — wantMobileInstall branch).
             //    Future: parse Info.plist / AndroidManifest.xml automatically
@@ -1950,6 +1954,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,
@@ -3302,6 +3307,31 @@ async function run() {
              */
             console.log(`  ${color.green('✓')} Connected — your new sign-in is live`);
             console.log(`    Background service ${wasRunning ? 'restarted' : 'started'} (PID ${pid})`);
+            /**
+             * ⚠⚠ TEACH THE AGENTS AS PART OF SIGNING IN (PPO-190). "Install the CLI, log in, and your
+             * agents handle the rest" needs the agents to KNOW about the CLI — the skills plus the
+             * instruction block in ~/.codex/AGENTS.md, ~/.gemini/GEMINI.md and a pointer in
+             * ~/.claude/CLAUDE.md. That used to be a separate `beehaven skills install` the installer's
+             * closing text asked for, and a step people skip is a step that did not happen.
+             *
+             * ⚠ Idempotent and non-fatal: unchanged files are not rewritten, symlinked files are left
+             * alone, and a failure here never fails the sign-in. Opt out with `--no-agent-setup` or
+             * BEEHAVEN_NO_AGENT_SETUP=1; undo with `beehaven skills uninstall`.
+             */
+            if (!values['no-agent-setup'] && process.env.BEEHAVEN_NO_AGENT_SETUP !== '1') {
+                try {
+                    const { installAgentSkills } = await import('./commands/agent-skills.js');
+                    const { installAgentInstructions } = await import('./commands/agent-instructions.js');
+                    const sk = installAgentSkills();
+                    const ins = installAgentInstructions();
+                    const changed = [...sk.steps, ...ins.steps].filter((x) => /=(written|updated)$/.test(x)).length;
+                    console.log(`  ${color.green('✓')} Your agents know about Clearly${changed ? '' : color.dim(' (already set up)')}`);
+                    console.log(color.dim('    Skills + instructions for Claude Code, Codex, Gemini and pi · undo: beehaven skills uninstall'));
+                }
+                catch (err) {
+                    console.log(color.dim(`    Agent setup skipped: ${err?.message ?? err} — run: beehaven skills install`));
+                }
+            }
             console.log('');
             break;
         }
@@ -3896,7 +3926,13 @@ complete -F _beehaven_completions beehaven`);
              */
             if (sub === 'install' || sub === 'uninstall') {
                 const { installAgentSkills, removeAgentSkills, AGENT_SKILL_DIRS } = await import('./commands/agent-skills.js');
+                const { installAgentInstructions, removeAgentInstructions } = await import('./commands/agent-instructions.js');
                 const r = sub === 'install' ? installAgentSkills() : removeAgentSkills();
+                // ⚠ The instruction block travels with the skills (PPO-190) — a skill is only OFFERED;
+                // the block is what makes an agent reach for `beehaven` at all.
+                const ins = sub === 'install' ? installAgentInstructions() : removeAgentInstructions();
+                r.steps.push(...ins.steps);
+                r.warnings.push(...ins.warnings);
                 const wrote = r.steps.filter((x) => /=(written|updated)$/.test(x)).length;
                 const current = r.steps.filter((x) => x.endsWith('=current')).length;
                 const removed = r.steps.filter((x) => x.endsWith('=removed')).length;
@@ -6647,9 +6683,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/agent-instructions.js

@@ -0,0 +1,182 @@
+/**
+ * agent-instructions — the "use the beehaven CLI" block in each agent's GLOBAL instruction file.
+ *
+ * ⚠⚠ THE MISSING HALF OF "install the CLI, log in, and your agents handle the rest" (PPO-190).
+ * `skills install` put SKILL.md files on disk, but a skill is only OFFERED to a model when its
+ * description matches. The instruction block is what makes an agent reach for `beehaven` at all
+ * when the user says "put this on my board". The Mac app has written it on every launch
+ * (`apps/electron/electron/agent-skills-installer.ts`); the CLI never did, so a CLI-only user's
+ * Codex and Gemini had skills they never used.
+ *
+ * ⚠⚠ BYTE-IDENTICAL TO THE MAC APP'S BLOCK, MARKER LINE INCLUDED. Both writers splice between the
+ * same BLOCK_START / BLOCK_END. If their text differed by one character, a machine with both would
+ * rewrite the file on every app launch and every CLI install, each undoing the other. One text
+ * means both converge and either uninstaller removes it. `agentInstructionParity.test.mjs` in the
+ * root repo pins the two copies together.
+ *
+ * ⚠ CLAUDE GETS THE SHORT POINTER — `~/.claude/CLAUDE.md` is prepended to every Claude Code
+ * session in every repository, so it carries a pointer to the skills, not a manual. Same rule as
+ * the Mac app; see its note on `AGENT_INSTRUCTION_FILES`.
+ *
+ * ⚠ ONLY OUR BLOCK IS EVER TOUCHED. Text around it is preserved byte for byte; a file with no
+ * block gets one appended; removal deletes the block and nothing else.
+ */
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+const MANAGED_MARKER = 'managed-by: clearly-mac-app';
+export const BLOCK_START = '<!-- clearly:beehaven-cli:start -->';
+export const BLOCK_END = '<!-- clearly:beehaven-cli:end -->';
+/** Resolved at call time so tests can point HOME at a temp dir. */
+export function agentInstructionFiles(home = os.homedir()) {
+    return [
+        { agent: 'codex', file: path.join(home, '.codex', 'AGENTS.md') },
+        { agent: 'gemini', file: path.join(home, '.gemini', 'GEMINI.md') },
+        { agent: 'claude', file: path.join(home, '.claude', 'CLAUDE.md') },
+    ];
+}
+/** The managed block appended to AGENTS.md / GEMINI.md. Keep identical to the Mac app's. */
+export function instructionBlock() {
+    return [
+        BLOCK_START,
+        `<!-- ${MANAGED_MARKER}. Edits inside this block are overwritten on app launch; edit outside it. -->`,
+        '',
+        '## Clearly — drive it with the `beehaven` CLI',
+        '',
+        'Clearly (clearly.sh) is a workspace — documents, projects, boards, tickets and a design',
+        'canvas. Reach it from the shell with the `beehaven` CLI, NOT an HTTP API you construct.',
+        '',
+        '⚠ SIGN IN FIRST. Every call is attributed to an agent identity, and without one the CLI',
+        'refuses. `login` MINTS the name if it does not exist yet, and binds this terminal:',
+        '',
+        '```sh',
+        'beehaven agent login <your-name>   # required — mints + binds, once per session',
+        'beehaven connect home              # target the personal workspace',
+        'beehaven actions                   # list every action available there',
+        'beehaven call <action> \'{...}\'',
+        '```',
+        '',
+        'Read the full skills before driving it — they carry the exact verbs and node shapes:',
+        '',
+        '- `~/.<agent>/skills/clearly-agent/SKILL.md` — **read this first**: identity, sessions, your brief',
+        '- `~/.<agent>/skills/beehaven-cli/SKILL.md` — connect / call / sql / logs, the daemon',
+        '- `~/.<agent>/skills/clearly-workspace/SKILL.md` — audit what a workspace holds and who made it',
+        '- `~/.<agent>/skills/clearly-canvas/SKILL.md` — build + perceive a canvas, comm blocks, code diffs',
+        '- `~/.<agent>/skills/design-craft/SKILL.md` — **load before any visual work**: grid, type, colour, the studio pass',
+        '- `~/.<agent>/skills/layout-systems/SKILL.md` — grids and systems across many artboards',
+        '- `~/.<agent>/skills/pair-on-canvas/SKILL.md` — drive a coding task from a spec on the canvas',
+        '- `~/.<agent>/skills/codebase-map/SKILL.md` — draw a repo’s architecture on the canvas',
+        '',
+        'If a command reports the daemon is unreachable, `beehaven login` re-auths and',
+        '`beehaven start --headless` starts a daemon when the Mac app is not running.',
+        BLOCK_END,
+    ].join('\n');
+}
+/** The short form, for `~/.claude/CLAUDE.md`. Keep identical to the Mac app's `claudeBlock()`. */
+export function claudeBlock() {
+    return [
+        BLOCK_START,
+        `<!-- ${MANAGED_MARKER}. Edits inside this block are overwritten on app launch; edit outside it. -->`,
+        '',
+        '**Clearly workspace** — drive it from the shell with the `beehaven` CLI (documents, projects,',
+        'boards, tickets, canvas). Sign in once per session first: `beehaven agent login <name>` —',
+        'it mints the identity if new. Full detail is in the skills, `clearly-agent` first.',
+        BLOCK_END,
+    ].join('\n');
+}
+/** Insert or replace our block, leaving everything around it untouched. Pure. */
+export function upsertBlock(existing, block) {
+    const start = existing.indexOf(BLOCK_START);
+    const end = existing.indexOf(BLOCK_END);
+    if (start !== -1 && end !== -1 && end > start) {
+        return existing.slice(0, start) + block + existing.slice(end + BLOCK_END.length);
+    }
+    return existing.trim() ? `${existing.trimEnd()}\n\n${block}\n` : `${block}\n`;
+}
+/** Remove our block (and the blank line it was appended after). Pure. */
+export function stripBlock(existing) {
+    const start = existing.indexOf(BLOCK_START);
+    const end = existing.indexOf(BLOCK_END);
+    if (start === -1 || end === -1 || end < start)
+        return existing;
+    const before = existing.slice(0, start).replace(/\n{1,2}$/, '\n');
+    const after = existing.slice(end + BLOCK_END.length).replace(/^\n/, '');
+    const out = (before + after);
+    return out.trim() ? out : '';
+}
+/**
+ * Write the block into every agent's global instruction file. Idempotent: an unchanged file is
+ * reported `=current` and not rewritten.
+ *
+ * ⚠ A SYMLINKED INSTRUCTION FILE IS LEFT ALONE. People keep dotfiles in a repo and link them in;
+ * writing through the link would silently edit their checkout. Same rule as the skills installer.
+ */
+export function installAgentInstructions(home = os.homedir()) {
+    const steps = [];
+    const warnings = [];
+    for (const { agent, file } of agentInstructionFiles(home)) {
+        try {
+            /**
+             * ⚠ ONLY FOR AGENTS THAT ARE INSTALLED. Creating `~/.gemini/GEMINI.md` for someone without
+             * Gemini invents an agent: the skills installer keys on that same directory existing, so
+             * the NEXT run would install skills for it too. Same rule as `installAgentSkills`.
+             */
+            if (!fs.existsSync(path.dirname(file))) {
+                steps.push(`${agent}/instructions=agent-absent`);
+                continue;
+            }
+            if (isSymlink(file)) {
+                steps.push(`${agent}/instructions=symlink-skipped`);
+                continue;
+            }
+            let existing = '';
+            try {
+                existing = fs.readFileSync(file, 'utf8');
+            }
+            catch { /* first run */ }
+            const next = upsertBlock(existing, agent === 'claude' ? claudeBlock() : instructionBlock());
+            if (next === existing) {
+                steps.push(`${agent}/instructions=current`);
+                continue;
+            }
+            fs.writeFileSync(file, next, { mode: 0o644 });
+            steps.push(`${agent}/instructions=${existing ? 'updated' : 'written'}`);
+        }
+        catch (e) {
+            warnings.push(`${agent}/instructions: ${e?.message ?? String(e)}`);
+        }
+    }
+    return { steps, warnings };
+}
+/** Remove only our block. A file that becomes empty is deleted only if we created all of it. */
+export function removeAgentInstructions(home = os.homedir()) {
+    const steps = [];
+    const warnings = [];
+    for (const { agent, file } of agentInstructionFiles(home)) {
+        try {
+            if (!fs.existsSync(file) || isSymlink(file))
+                continue;
+            const existing = fs.readFileSync(file, 'utf8');
+            const next = stripBlock(existing);
+            if (next === existing)
+                continue;
+            if (next)
+                fs.writeFileSync(file, next);
+            else
+                fs.unlinkSync(file);
+            steps.push(`${agent}/instructions=removed`);
+        }
+        catch (e) {
+            warnings.push(`${agent}/instructions: ${e?.message ?? String(e)}`);
+        }
+    }
+    return { steps, warnings };
+}
+function isSymlink(file) {
+    try {
+        return fs.lstatSync(file).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/agent.js

@@ -845,7 +845,11 @@ async function agentLogin(args, values) {
         console.error(`  ${yellow('⚠')} Signed in, but this workspace refused ${cyan(name)}: ${outcome.reason}`);
         if (/revoked|not active|unknown agent|not admitted/i.test(`${outcome.scope} ${outcome.reason}`)) {
             console.error(dim(`    The agent is archived or not admitted here. Restore it in Settings → Agent access,`));
-            console.error(dim(`    or log in as an active agent (beehaven call agent-list '{}' shows the roster).`));
+            // ⚠ The workspace names the live identity in its refusal (PPO-190). The old advice —
+            // `beehaven call agent-list` — ran AS this refused identity and was refused in turn.
+            if (!/Log in as one:/.test(outcome.reason)) {
+                console.error(dim(`    or log in as an active agent: beehaven agent login <name> (the Settings → Agent access page lists them).`));
+            }
         }
         console.error(dim(`    Calls from this session run as ${name} and will be refused — they will NOT fall back to another agent.`));
         process.exitCode = 1;

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/commands/workspace.js

@@ -860,6 +860,22 @@ export async function cmdCall(action, rawInput, values) {
             input = { ...input, action: canonical, name: canonical };
         }
     }
+    // ⚠ `type` IS THE WIRE'S ACTION NAME (PPO-190): a top-level `type` would be overwritten by the
+    // daemon's `{ ...input, type: action }` and lost with `ok: true`. Move it to the verb's own field
+    // or refuse with the right spelling — never drop it in silence. See reserved-type.ts.
+    {
+        const { reconcileReservedType } = await import('../reserved-type.js');
+        const r = reconcileReservedType(action, input);
+        if (r.kind === 'refused') {
+            console.error(`  ${r.error}`);
+            process.exit(1);
+        }
+        if (r.kind === 'moved') {
+            input = r.input;
+            if (!values.json)
+                console.error(`  · ${r.note}`);
+        }
+    }
     // Confirm spend BEFORE resolving a building or touching the daemon — a cancelled call must
     // cost nothing and behave identically whether the input came from argv, a file, or stdin.
     // It runs after the parse because the gate is input-aware: `engine:'handroll'` and any call

package/dist/daemon.js

@@ -2501,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
@@ -3059,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) {
@@ -4220,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
@@ -4430,16 +4385,7 @@ export async function startDaemon(opts) {
     setInterval(() => checkAndAutoUpdate(), UPDATE_CHECK_INTERVAL);
     // Reset the LOCAL metrics window every 5 minutes (no network).
     setInterval(() => metrics.resetWindow(), 5 * 60_000);
-    /**
-     * ⚠⚠ NO TIMED FRAMES TO THE CLOUD (2026-09-29). Two intervals lived here: a `telemetry` frame
-     * and a `swarm-register` re-advertise, each every 2 minutes. Neither had a consumer — the
-     * workspace has no handler for either type and nothing inserts into `beehives` — but each one
-     * woke the user's Hive, reopened its portal (the portal idle-closes after 60 s), woke the
-     * workspace and re-hydrated all ~111 tables. Measured on staging: that kept one Hive resident
-     * ~50% of every hour per connected daemon (~11K GB-s/day) and made the workspace re-read ~15K
-     * rows per reopen. An idle daemon must cost nothing; it speaks when something happens.
-     * Registration still runs on connect and whenever installed apps change (above).
-     */
+    // 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/reserved-type.js

@@ -0,0 +1,60 @@
+/**
+ * reserved-type — `type` is the WIRE'S action name, so a top-level `type` in a call's input is lost.
+ *
+ * ⚠⚠ SILENT DATA LOSS (PPO-190). The daemon sends `{ ...input, type: action }`. An agent that calls
+ * `ticket-create '{"title":"…","type":"bug"}'` gets `ok: true` and a ticket that is NOT a bug: its
+ * `type` was overwritten by `"ticket-create"` before the workspace ever saw it. AGENTS.md has
+ * carried "use `issueType`, not `type`" as a warning, which is a rule every new agent has to be
+ * told and every one of them breaks once.
+ *
+ * The verbs already accept a non-colliding spelling (`issueType`, `linkType`, `proposalType`,
+ * `kind`). This moves `type` onto that spelling when the verb has one, and refuses with the right
+ * spelling when it does not — either way, nothing is dropped in silence.
+ */
+/** Verb → the field the workspace reads instead of `type`. */
+export const TYPE_ALIASES = {
+    // Each entry is a verb whose handler reads this field (verified against apps/cloudflare/src).
+    'ticket-create': 'issueType',
+    'ticket-update': 'issueType',
+    'ticket-link-create': 'linkType',
+    'proposal-create': 'proposalType',
+    'composition-create': 'kind',
+    'record-thought': 'kind',
+    'thought-record': 'kind',
+};
+/**
+ * Reconcile a top-level `type` with the wire's use of the name. Pure.
+ *
+ * ⚠ A `type` EQUAL TO THE ACTION is left alone — that is a caller spelling the action twice, which
+ * the wire already agrees with. Nested `type`s (canvas nodes, `updates.type`) never collide and are
+ * never inspected.
+ */
+export function reconcileReservedType(action, input) {
+    if (!input || typeof input !== 'object' || !Object.prototype.hasOwnProperty.call(input, 'type'))
+        return { kind: 'none' };
+    const value = input.type;
+    if (value === undefined || value === action)
+        return { kind: 'none' };
+    const field = TYPE_ALIASES[action];
+    if (field) {
+        const { type: _dropped, ...rest } = input;
+        if (rest[field] !== undefined && rest[field] !== value) {
+            return {
+                kind: 'refused',
+                error: `both "type" (${JSON.stringify(value)}) and "${field}" (${JSON.stringify(rest[field])}) were given — `
+                    + `"type" is the action name on the wire and would be dropped; pass only "${field}".`,
+            };
+        }
+        return {
+            kind: 'moved',
+            field,
+            input: { ...rest, [field]: value },
+            note: `"type" is reserved for the action name on the wire — sent as "${field}": ${JSON.stringify(value)}`,
+        };
+    }
+    return {
+        kind: 'refused',
+        error: `"type" is reserved for the action name on the wire, so ${action} would never see ${JSON.stringify(value)}. `
+            + `Use the verb's own field (see: beehaven describe ${action}).`,
+    };
+}

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.21",
+  "version": "0.8.23",
   "description": "Beehaven CLI — command your Clearly workspace, agents, and canvas from the terminal",
   "private": false,
   "type": "module",

package/skills/clearly-agent/SKILL.md

@@ -211,7 +211,8 @@ ask the owner.
   `beehaven call agent-list '{}'` shows the live roster; log in as one of those.
 - ⚠ **`workspace-sql` takes `query`**, not `sql`. The wrong key is silently dropped and you get the
   SCHEMA back — `ok: true`, a confident list of tables, not your answer.
-- ⚠ **`document-create` takes `markdown` or `html`**, not `content`. An unknown key is stripped, the
-  document is created empty, and it is **invisible to `document-search` forever**.
-- ⚠ **`ticket-create` takes `issueType`, not `type`** (the wire uses `type` as the action
-  discriminator) and **`body`, not `description`**. Both fail silently.
+- **`document-create` takes `markdown` or `html`.** `content`, `body` and `text` are accepted as
+  markdown aliases, but prefer `markdown`.
+- **`ticket-create` / `ticket-update` take `issueType` and `body`.** The wire uses `type` as the action
+  name, so the CLI moves a top-level `type` to `issueType` for you and refuses it on verbs with no
+  such field. `description` is accepted as `body`.

package/skills/index.json

@@ -74,6 +74,6 @@
     "files": [
       "SKILL.md"
     ],
-    "sha": "94c30f43b217f3e9"
+    "sha": "ad938cb0070fcab0"
   }
 ]