beehaven 0.8.21 → 0.8.24

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

package/scripts/sync-skills.mjs

@@ -35,6 +35,7 @@ const SOURCES = {
   'agent-doodle-space':'apps/mcp-server/plugin/skills/agent-doodle-space/SKILL.md',
   'design-craft':   'apps/mcp-server/plugin/skills/design-craft/SKILL.md',
   'layout-systems': 'apps/mcp-server/plugin/skills/layout-systems/SKILL.md',
+  'brand-identity': 'apps/mcp-server/plugin/skills/brand-identity/SKILL.md',
   'pair-on-canvas': 'apps/mcp-server/plugin/skills/pair-on-canvas/SKILL.md',
   'codebase-map':   'apps/mcp-server/plugin/skills/codebase-map/SKILL.md',
   'clearly-workspace': 'apps/mcp-server/plugin/skills/clearly-workspace/SKILL.md',

package/skills/README.md

@@ -1,24 +1,26 @@
-# CLI-paired Claude Code skills
+# Skills shipped with the CLI
 
-Claude Code skills that document built-in `beehaven` CLI verbs.
-Distinct from hive-paired skills (which live with each hive in
-`clearly-hives/<hive>/skills/`).
+The `beehaven` tarball carries the agent skills a CLI-only user needs — the same set the Clearly
+Mac app installs — so `curl | sh` teaches an agent Clearly without the app.
 
-A skill belongs here when it documents functionality that ships
-with the CLI itself, not with any specific hive. Currently:
+## Where each skill comes from
 
-- **`claude-shopper/`** — documents `beehaven shop find/at/search/get/checkout`
-  (the shop@0 protocol surface). Not paired with any hive — the shop
-  catalog is part of the CLI's Yellow Pages integration.
+| Skill | Source of truth (edit HERE, never the copy) |
+|---|---|
+| `beehaven-cli` | `clearly-hives/beehaven-cli/skills/SKILL.md` |
+| `clearly-agent`, `clearly-canvas`, `clearly-workspace`, `design-craft`, `layout-systems`, `brand-identity`, `pair-on-canvas`, `codebase-map`, `agent-home`, `agent-doodle-space` | `apps/mcp-server/plugin/skills/<name>/` in the monorepo |
+| `claude-shopper` | this folder — hand-written, documents `beehaven shop` (the shop@0 protocol) |
 
-These aren't installed by `beehaven install` (that's for hive-paired
-skills via the `agentDocs.claudeCode` manifest field). If a user wants
-the claude-shopper skill, they install it manually:
+`scripts/sync-skills.mjs` copies every monorepo source into `skills/<name>/` (`npm run sync:skills`,
+and automatically at `prepack`) and writes `skills/index.json`. Its `SOURCES` table mirrors the
+Mac app's `electron-builder*.yml` extraResources and `SHIPPED_SKILLS`
+(`apps/electron/electron/agent-skills-installer.ts`); `apps/electron/scripts/verify-mcp-parity.mjs`
+fails when the two sets disagree.
 
-```bash
-cp -R packages/cli/skills/claude-shopper ~/.claude/skills/beehaven-shopper
-```
+## Rules
 
-Or eventually via a `beehaven skills install-bundled <name>` verb (not
-yet built). See `beehaven_sdk/docs/LOCAL_HIVES.md` §11.5 for the
-hive-paired skill flow this complements.
+- Edit the source, then run `npm run sync:skills`. A change made to a copy here is overwritten.
+- Copies are generated, so they are listed in `.gitignore` (a second committed copy is a second copy
+  to drift). ⚠ `agent-home`, `agent-doodle-space`, `clearly-agent` and `clearly-workspace` are still
+  tracked from before that rule; treat them as generated all the same.
+- Only `README.md` and `claude-shopper/` are hand-written here.