beehaven 0.8.36 → 0.8.39

package/dist/agent-limit-refusal.js

@@ -0,0 +1,43 @@
+/**
+ * MCP2-65 — what `beehaven agent login <new name>` says when the workspace already has all the
+ * agents its plan includes (Free includes one).
+ *
+ * The identity mints at the account; joining the workspace is where the cap refuses
+ * (`agent-session-start` → automatic admission → `agent-create`, code `agent-limit-reached`). The
+ * reason alone left the person at a wall. The three choices, in this order:
+ *   1. log in as an agent they already have — one agent works from several apps;
+ *   2. upgrade for more agents (a pricing link: this is the terminal, not an MCP tool result);
+ *   3. archive one in Agents settings, then log in again.
+ *
+ * Pure: returns plain lines, the command colours them.
+ */
+export const AGENT_LIMIT_CODE = 'agent-limit-reached';
+export function isAgentLimitRefusal(code) {
+    return String(code ?? '') === AGENT_LIMIT_CODE;
+}
+/** An absolute pricing link from the refusal's relative `upgradeUrl` and the web origin for this env. */
+export function upgradeLink(origin, upgradeUrl) {
+    const base = String(origin || 'https://www.clearly.sh').replace(/\/+$/, '');
+    const raw = typeof upgradeUrl === 'string' ? upgradeUrl.trim() : '';
+    // Only a site-relative path is joined; anything else falls back to the pricing page.
+    const path = /^\/(?!\/)[A-Za-z0-9/_?=&.-]*$/.test(raw) ? raw : '/pricing';
+    return `${base}${path}`;
+}
+export function agentLimitLoginLines(opts) {
+    const agents = (Array.isArray(opts.details?.activeAgents) ? opts.details.activeAgents : [])
+        .map((a) => ({ id: String(a?.id ?? '').trim(), name: String(a?.name ?? '').trim() }))
+        .filter((a) => a.id && a.id !== opts.name);
+    const first = agents[0];
+    const listed = agents.map((a) => (a.name && a.name !== a.id ? `${a.id} ("${a.name}")` : a.id)).join(', ');
+    const reason = String(opts.reason || '').trim();
+    return {
+        headline: `Signed in, but ${opts.workspace || 'this workspace'} is at its agent limit${reason ? `: ${reason}` : '.'}`,
+        choices: [
+            first
+                ? `Use the agent you already have (one agent works from several apps): beehaven agent login ${first.id}${agents.length > 1 ? `   · also yours here: ${listed}` : ''}`
+                : 'Use an agent you already have (one agent works from several apps): beehaven agent login <its name>',
+            `Upgrade for more agents: ${upgradeLink(opts.origin, opts.details?.upgradeUrl)}`,
+            `Or archive one in Agents settings, then run: beehaven agent login ${opts.name}`,
+        ],
+    };
+}

package/dist/agent-mint-response.js

@@ -0,0 +1,10 @@
+/** Only an explicit appearance choice may rebind a portable identity on another device. */
+export function accountMintRequest(agentId, requestedAvatarId) {
+    return { agentId, ...(requestedAvatarId ? { avatarId: requestedAvatarId } : {}) };
+}
+export function accountMintResponse(response) {
+    const value = response?.result ?? response;
+    if (!value?.token)
+        throw Object.assign(new Error(`${String(value?.error || 'The server returned no agent token')}${value?.code ? ` (${value.code})` : ''}`), { code: value?.code || 'mint-refused' });
+    return value;
+}

package/dist/agent-state.js

@@ -365,11 +365,18 @@ export function loginSessionOutcome(started, thrown) {
         return { kind: 'started', sessionId: id, brief: payload?.brief };
     const err = payload?.error ?? started?.error;
     if (err) {
+        const code = String(payload?.code ?? started?.code ?? '');
         return {
             kind: 'refused',
             reason: typeof err === 'string' ? err : String(err?.message ?? JSON.stringify(err)),
-            code: String(payload?.code ?? started?.code ?? ''),
+            code,
             scope: String(payload?.scope ?? started?.scope ?? ''),
+            // MCP2-65: the agent-cap refusal names the caller's live agents and a pricing path, so the
+            // login can print the three choices instead of a bare reason.
+            ...(code === 'agent-limit-reached' ? { details: {
+                    activeAgents: Array.isArray(payload?.activeAgents) ? payload.activeAgents : [],
+                    ...(typeof payload?.upgradeUrl === 'string' ? { upgradeUrl: payload.upgradeUrl } : {}),
+                } } : {}),
         };
     }
     return { kind: 'refused', reason: 'the workspace returned no session', code: '', scope: '' };

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 = '31746b91dfbf';
+export const BUILD_SHA = '3026e5a147f9';
 /** ISO-8601 minute precision, UTC. Rewritten in `dist/` by `scripts/stamp-build-channel.mjs`. */
-export const BUILD_TIME = '2026-10-29T05:50Z';
+export const BUILD_TIME = '2026-11-12T22:52Z';
 /**
  * The build identity as one short string, for `--version`.
  *

package/dist/call-brief.js

@@ -0,0 +1,172 @@
+/**
+ * `beehaven call <action> … --brief` — a receipt a person (or an agent's context window) can read.
+ *
+ * ⚠⚠ WHY THIS EXISTS. A `canvas-act` batch answers with every step's full value plus the lint of
+ * every touched artboard — routinely tens of kilobytes. Agents learned to pipe it into a summariser
+ * they wrote on the spot (`… 2>&1 | node summ.mjs`), and in the first recorded canvas take (MCP2-20)
+ * that improvisation cost four failed tool calls: shell pipes and `/tmp` redirects need approval in
+ * a headless agent, and the summariser crashed on the stderr breadcrumb it was fed. The receipt the
+ * agent wanted is printed here instead, from the same result, with the exit code unchanged.
+ *
+ * ⚠ IT DROPS NOTHING THAT DECIDES THE NEXT STEP: failed steps (with their error), rollbacks and
+ * skips, lint findings that need fixing, a review's verdict and blocking count. What it leaves out
+ * is bulk — per-step echoes, previews, font metadata. `--json` still prints the whole payload.
+ */
+const clip = (s, n) => {
+    const t = String(s ?? '').replace(/\s+/g, ' ').trim();
+    return t.length > n ? `${t.slice(0, n - 1)}…` : t;
+};
+const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+/** `canvas.create-node` → `create-node`; `frame.create` stays as written. */
+const verb = (a) => (a.startsWith('canvas.') ? a.slice(7) : a);
+export function briefReceipt(action, result) {
+    const r = (result && typeof result === 'object' ? result : { value: result });
+    const error = typeof r.error === 'string' && r.error ? r.error : null;
+    /**
+     * MCP2-28 (codex review) — A FAILED BATCH IS STILL A BATCH. This returned the one-line refusal for
+     * any `ok:false`, before looking at `results`, so a rolled-back canvas-act (step 2 of 2 refused)
+     * printed a truncated error with no step number and no "rolled back". The batch receipt is read
+     * first; the top-level failure is kept on it, so the exit code still says it failed.
+     */
+    if (Array.isArray(r.results) && r.results.length) {
+        const b = batchReceipt(action, r);
+        if (error || r.ok === false) {
+            b.ok = false;
+            b.lines[0] = b.lines[0].replace(/^✓/, '✗');
+            const why = clip(error ?? r.message ?? r.code ?? '', 200);
+            // Not repeated when a failed step already says it (the step line clips at 140, this at 200).
+            if (why && !b.lines.some((l) => l.includes(why.slice(0, 60))))
+                b.lines.splice(1, 0, `  ${why}`);
+        }
+        return b;
+    }
+    if (error || r.ok === false) {
+        return { ok: false, lines: [`✗ ${action} · ${clip(error ?? r.message ?? r.code ?? 'refused', 160)}`] };
+    }
+    if (Array.isArray(r.results))
+        return batchReceipt(action, r);
+    return { ok: true, lines: [`✓ ${action}${describeValue(r)}`] };
+}
+function batchReceipt(action, r) {
+    const steps = r.results;
+    const failed = steps.map((s, i) => ({ s, i })).filter(({ s }) => s?.ok === false);
+    const lines = [];
+    // What ran: a review or a set of measurements reads better as its result than as a step count.
+    const reviews = steps.filter((s) => /canvas\.review/.test(s?.action) && s?.ok !== false);
+    const measures = steps.filter((s) => s?.action === 'canvas.measure-text' && s?.ok !== false);
+    const counts = new Map();
+    for (const s of steps)
+        counts.set(verb(s?.action ?? '?'), (counts.get(verb(s?.action ?? '?')) ?? 0) + 1);
+    const mix = [...counts].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([a, n]) => (n > 1 ? `${a} ×${n}` : a)).join(', ');
+    /**
+     * CDS-163 — THE BATCH'S OWN DELTA WINS. Only update steps carry a per-step `canvasChanges`, so
+     * summing steps printed "+0 ~69 −0 layers" for a 343-step build that created 211 layers. The worker
+     * returns one batch-level `canvasChanges`, diffed over every node the batch addressed (creates
+     * included); the per-step sum is kept for an older worker that does not send it.
+     */
+    let added = 0, changed = 0, removed = 0, sawDelta = false;
+    const isDelta = (d) => !!d && typeof d === 'object' && !Array.isArray(d);
+    if (isDelta(r.canvasChanges)) {
+        sawDelta = true;
+        added = Number(r.canvasChanges.added || 0);
+        changed = Number(r.canvasChanges.changed || 0);
+        removed = Number(r.canvasChanges.removed || 0);
+    }
+    else {
+        for (const s of steps) {
+            const d = s?.value?.canvasChanges;
+            if (isDelta(d)) {
+                sawDelta = true;
+                added += Number(d.added || 0);
+                changed += Number(d.changed || 0);
+                removed += Number(d.removed || 0);
+            }
+        }
+    }
+    const rev = r.canvasNodesRev ?? [...steps].reverse().find((s) => s?.value?.canvasNodesRev != null)?.value?.canvasNodesRev;
+    const head = [`${failed.length ? '✗' : '✓'} ${action}`, `${plural(steps.length, 'step')}${mix ? ` (${mix})` : ''}`];
+    if (sawDelta && added + changed + removed)
+        head.push(`+${added} ~${changed} −${removed} layers`);
+    if (rev != null)
+        head.push(`rev ${rev}`);
+    if (r.rolledBack)
+        head.push('rolled back');
+    if (r.partial)
+        head.push('partly applied');
+    if (Array.isArray(r.skipped) ? r.skipped.length : r.skipped)
+        head.push(`${Array.isArray(r.skipped) ? r.skipped.length : r.skipped} skipped`);
+    lines.push(head.join(' · '));
+    for (const { s, i } of failed.slice(0, 3)) {
+        lines.push(`  ✗ step ${i + 1} ${verb(s.action ?? '?')}: ${clip(s.error ?? s.value?.error ?? 'failed', 140)}`);
+    }
+    if (failed.length > 3)
+        lines.push(`  … ${failed.length - 3} more failed steps`);
+    for (const m of measures.slice(0, 6)) {
+        const v = m.value ?? {};
+        lines.push(`  ${Math.round(v.width ?? 0)}×${Math.round(v.height ?? 0)} · ${plural(v.lineCount ?? 1, 'line')}${v.exact === false ? ' · estimated' : ''} — ${v.family ?? ''} ${v.size ?? ''}/${v.fontWeight ?? ''}`.trimEnd());
+    }
+    for (const rv of reviews) {
+        const v = rv.value ?? {};
+        const reports = Array.isArray(v.reviews) ? v.reviews : [v];
+        for (const rep of reports) {
+            const blocking = rep.blocking?.craft ?? 0;
+            const where = rep.scope?.name ?? rep.scope?.ids?.[0] ?? '';
+            lines.push(`  review${where ? ` ${clip(where, 40)}` : ''}: ${rep.verdict ?? 'unknown'}${blocking ? ` · ${plural(blocking, 'blocking finding')}` : ''}`);
+            for (const f of (rep.craft?.findings ?? []).filter((x) => x.severity === 'warn').slice(0, 3)) {
+                lines.push(`    ${f.check}: ${clip(f.detail, 120)}`);
+            }
+        }
+    }
+    // Lint of the touched artboards: what must be fixed next, never the whole report.
+    for (const d of (Array.isArray(r.diagnostics) ? r.diagnostics : [])) {
+        const errors = d.errors ?? [];
+        if (!errors.length && d.verdict !== 'fix')
+            continue;
+        lines.push(`  lint ${clip(d.artboard ?? d.id, 40)}: ${d.verdict ?? 'fix'}`);
+        for (const e of errors.slice(0, 3))
+            lines.push(`    ${clip(e, 140)}`);
+        if (errors.length > 3 || d.moreErrors)
+            lines.push(`    … ${(errors.length - 3 > 0 ? errors.length - 3 : 0) + (d.moreErrors ?? 0)} more`);
+    }
+    const clean = (Array.isArray(r.diagnostics) ? r.diagnostics : []).filter((d) => d.verdict && d.verdict !== 'fix');
+    if (clean.length)
+        lines.push(`  lint ${[...new Set(clean.map((d) => d.verdict))].join('/')} on ${plural(clean.length, 'artboard')}`);
+    /**
+     * MCP2-25 — THE CARRIED TICKET'S OUTCOME DECIDES THE NEXT STEP TOO. A batch carrying `ticket` moves
+     * it only when its review passes; the receipt said nothing either way, so an agent could not tell a
+     * done commit from one the review held back.
+     */
+    const t = r.ticket;
+    if (t && typeof t === 'object') {
+        if (t.applied)
+            lines.push(`  ticket ${t.key ?? t.id} → ${t.status ?? 'updated'}${t.frame?.url ? ` · frame ${t.frame.url}` : ''}`);
+        else
+            lines.push(`  ✗ ticket ${t.id ?? ''} not moved: ${clip(t.reason ?? t.error ?? 'refused', 200)}`);
+    }
+    return { ok: failed.length === 0, lines };
+}
+/** A one-line description of an ordinary result: its identity and what it holds. */
+function describeValue(r) {
+    const bits = [];
+    const id = r.key ?? r.id ?? r.compositionId ?? r.documentId;
+    if (id)
+        bits.push(String(id).length > 24 ? String(id).slice(0, 8) : String(id));
+    const title = r.title ?? r.name;
+    if (typeof title === 'string' && title)
+        bits.push(`"${clip(title, 60)}"`);
+    if (typeof r.status === 'string')
+        bits.push(r.status);
+    if (r.verdict)
+        bits.push(`verdict ${r.verdict}`);
+    for (const [k, v] of Object.entries(r)) {
+        if (Array.isArray(v) && v.length && bits.length < 4 && !['results', 'diagnostics'].includes(k))
+            bits.push(`${v.length} ${k}`);
+    }
+    if (typeof r.count === 'number' && !bits.some((b) => b.endsWith(' items')))
+        bits.push(`count ${r.count}`);
+    if (typeof r.url === 'string')
+        bits.push(r.url);
+    if (r.value !== undefined && typeof r.value !== 'object')
+        bits.push(clip(r.value, 120));
+    return bits.length ? ` · ${bits.join(' · ')}` : '';
+}

package/dist/claude-bridge.js

@@ -22,6 +22,7 @@ import { homedir } from 'os';
 import { EventEmitter } from 'events';
 import { activeAgentWrap } from './agent-attribution.js';
 import { ipcSocketPath, watcherSocketPath, socketMayExist } from './ipc-path.js';
+import { utf8Stream } from './utf8-stream.js';
 const CONFIG_DIR = join(homedir(), '.beehaven');
 export class ClaudeBridge extends EventEmitter {
     socket = null;
@@ -56,8 +57,10 @@ export class ClaudeBridge extends EventEmitter {
                 this.send({ type: 'session:announce', label: 'claude-code', app: 'bridge' });
                 resolve(true);
             });
+            // CA-63 — decode the stream, not each chunk: a character split across two reads stays whole.
+            const decode = utf8Stream();
             socket.on('data', (data) => {
-                this.buffer += data.toString();
+                this.buffer += decode(data);
                 const lines = this.buffer.split('\n');
                 this.buffer = lines.pop() || '';
                 for (const line of lines) {

package/dist/cli.js

@@ -408,7 +408,7 @@ ${DEV_ONLY_HELP ? `
     beehaven actions --all         …including ones this caller cannot invoke
     beehaven actions --search <q>  Find one by substring
     beehaven explain <action>      Its exact arguments, from the live schema
-    beehaven call <action> [json]  Invoke it; returns the raw JSON result
+    beehaven call <action> [json]  Invoke it; returns the raw JSON result (--brief: a short receipt; --out <file>: the JSON to a file)
 
     # discover, then run
     beehaven actions --search ticket
@@ -1443,6 +1443,8 @@ async function run() {
             address: { type: 'string' },
             protocol: { type: 'string' },
             json: { type: 'boolean', default: false },
+            // `beehaven call … --brief`: a short receipt instead of the full JSON (call-brief.ts).
+            brief: { type: 'boolean', default: false },
             // `--conversation <id>` threads `beehaven agent "<msg>"` onto an existing
             // Omni thread instead of minting a new one per invocation.
             conversation: { type: 'string' },
@@ -1879,6 +1881,7 @@ async function run() {
      * would be refused while `conversations --json` worked.
      */
     const JSON_CAPABLE = new Set([
+        'doc', 'search',
         'admin', 'apps', 'd1', 'describe', 'explain', 'marketplace', 'secrets',
         'shop', 'user', 'webhook', 'webhooks', 'workspaces', 'ws',
         // Honour what the modules already implement.
@@ -2090,6 +2093,8 @@ async function run() {
         'slides', 'deck',
         // `brand tokens -o tokens.css` · `component render -o button.svg`
         'brand', 'brands', 'component', 'components',
+        // MCP2-25 — `call <action> … --out result.json`: the whole result to a file, the receipt to the console.
+        'call',
     ]);
     /**
      * ⚠ ONE REFUSAL, because there is now one flag. Both spellings are named in the message so a
@@ -3060,13 +3065,13 @@ async function run() {
             }
             console.log('');
             console.log(`  ${color.green('✓')} Signed in as ${color.bold(captured.email ?? captured.userId)}`);
-            console.log(`    Tokens stored in keychain + ~/.beehaven/config.json`);
+            console.log(`    Sign-in saved on this device`);
             // Auto-restart the daemon. New tokens won't take effect until
             // the daemon restarts (it reads creds at startup, keeps them
             // in memory, has no hot-reload IPC verb). Doing the restart
             // here matches gh / firebase-tools UX — login-then-go.
             const { findLiveDaemons, stopDaemonProcess } = await import('./daemon.js');
-            const { spawnStandaloneDaemon } = await import('./commands/daemon-cmd.js');
+            const { spawnStandaloneDaemon, waitForLoginConnection } = await import('./commands/daemon-cmd.js');
             /**
              * ⚠⚠ THE RESTART IS PLUMBING AND WAS NARRATED AS THOUGH IT WERE THE POINT. What a person saw
              * after signing in was:
@@ -3111,6 +3116,7 @@ async function run() {
              * started with developer scope.
              */
             const pid = spawnStandaloneDaemon(values);
+            const connection = await waitForLoginConnection();
             /**
              * ⚠ ONE OUTCOME LINE, IN THE SAME SHAPE AS THE ONE ABOVE IT. `✓ (PID 73532)` was a tick, a
              * bracket and a number — grammatically nothing, and unreadable as a result. This says what
@@ -3121,7 +3127,16 @@ async function run() {
              * `beehaven status` labels the same thing `Relay:`. Naming the outcome rather than the
              * process is what stops a sign-in ending on the word "stopped".
              */
-            console.log(`  ${color.green('✓')} Connected — your new sign-in is live`);
+            if (connection.ready) {
+                console.log(`  ${color.green('✓')} Connected — your new sign-in is live`);
+            }
+            else {
+                console.error(`  ${color.yellow('!')} Signed in, but the workspace connection is not ready.`);
+                console.error(connection.reason === 'environment-mismatch'
+                    ? '    The running service is on a different environment. Run `beehaven status` before retrying.'
+                    : '    Run `beehaven status` to check the connection, then retry your workspace command.');
+                process.exitCode = 2;
+            }
             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

package/dist/commands/agent.js

@@ -25,6 +25,8 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { rpcOnce } from '../ipc-client.js';
+import { accountMintRequest, accountMintResponse } from '../agent-mint-response.js';
+import { agentLimitLoginLines, isAgentLimitRefusal } from '../agent-limit-refusal.js';
 import { saveAgent, loadAgent, listAgents, deleteAgent, findAgentByAvatar, isValidAgentName, resolveActiveAgent, activeAgentName, saveAgentSession, clearAgentSession, clearAgentSessionId, decodeAgentTokenClaims, } from '../agent-state.js';
 const VALID_KINDS = ['claude-code', 'daemon-agent', 'clearly-ai'];
 export const FREE_SKINS = [
@@ -643,7 +645,7 @@ async function agentLogin(args, values) {
     }
     const avatarId = requestedAvatarId || existingRecord?.avatarId || chosenSkin || name;
     // Local-first avatar-collision guard (durable guard is the cloud pool).
-    const collision = findAgentByAvatar(avatarId, name);
+    const collision = requestedAvatarId ? findAgentByAvatar(requestedAvatarId, name) : null;
     if (collision) {
         console.error(`  Avatar "${avatarId}" is already claimed by agent "${collision}".`);
         console.error(`  Pick another: beehaven agent login ${name} --avatar <other-id>`);
@@ -670,7 +672,7 @@ async function agentLogin(args, values) {
      * credential.
      */
     try {
-        const cloud = await rpcOnce('agent-account-mint', { agentId: name, avatarId }, 15_000);
+        const cloud = accountMintResponse(await rpcOnce('agent-account-mint', accountMintRequest(name, requestedAvatarId), 15_000));
         const tok = cloud?.token ?? cloud?.result?.token;
         if (tok) {
             minted = {
@@ -698,7 +700,14 @@ async function agentLogin(args, values) {
     }
     catch (err) {
         console.error(`  Could not mint identity: ${err?.message ?? err}`);
-        console.error('  Is the daemon connected? Check with: beehaven status');
+        if (String(err?.code) === 'identity-limit-reached') {
+            // MCP2-71: the account's safety ceiling — no plan lifts it; signing in as one you have always works.
+            console.error('  Sign in as an agent you already have: beehaven agent list, then beehaven agent login <name>');
+            console.error('  Or delete one you no longer use in Agents, then run this again.');
+            process.exit(1);
+        }
+        if (!err?.code || /^(ECONN|ENOENT|ETIMEDOUT)/.test(String(err.code)))
+            console.error('  Is the daemon connected? Check with: beehaven status');
         process.exit(1);
     }
     /**
@@ -962,6 +971,21 @@ async function agentLogin(args, values) {
         console.log(`  ${green('◷')} Workspace work session ${cyan(outcome.sessionId.slice(0, 8))} started.`);
         printBrief(outcome.brief);
     }
+    else if (outcome.kind === 'refused' && isAgentLimitRefusal(outcome.code)) {
+        // MCP2-65: at the plan's agent limit, say what to do — not just that it was refused.
+        const { resolveAuthOrigin } = await import('../browser-login.js');
+        const lines = agentLimitLoginLines({
+            name, workspace: (await workspaceLabel(chosenWorkspace)).split(/ {2}\(| — /)[0], reason: outcome.reason,
+            details: outcome.details, origin: resolveAuthOrigin().authOrigin,
+        });
+        console.log('');
+        console.error(`  ${yellow('⚠')} ${lines.headline}`);
+        console.error('    Your choices:');
+        for (const line of lines.choices)
+            console.error(`    · ${line}`);
+        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;
+    }
     else if (outcome.kind === 'refused') {
         console.log('');
         console.error(`  ${yellow('⚠')} Signed in, but this workspace refused ${cyan(name)}: ${outcome.reason}`);

package/dist/commands/daemon-cmd.js

@@ -16,6 +16,22 @@ import { fileURLToPath } from 'node:url';
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { findLiveDaemons, resolveRelayUrlForDaemon } from '../daemon.js';
+import { waitForConnection } from '../connection-ready.js';
+/** Each attempt authenticates over IPC; a PID or greeting alone cannot prove a usable sign-in. */
+export async function waitForLoginConnection() {
+    const { IpcClient } = await import('../ipc-client.js');
+    return waitForConnection(async () => {
+        const client = new IpcClient({ timeout: 1000 });
+        try {
+            await client.connect();
+            const state = await client.call('daemon:session-status', {}, 1000);
+            return { connected: state?.relay?.connected === true, endpoint: state?.relay?.endpoint };
+        }
+        finally {
+            client.disconnect();
+        }
+    }, resolveRelayUrlForDaemon());
+}
 /** dist/daemon-entry.js — sibling of dist/cli.js (this file is dist/commands/). */
 function daemonEntryPath() {
     return join(dirname(fileURLToPath(import.meta.url)), '..', 'daemon-entry.js');
@@ -82,7 +98,7 @@ export async function startHeadlessDaemon(values) {
             const { daemonRpc } = await import('../daemon-client.js');
             let activeRelay = null;
             try {
-                const status = await daemonRpc('daemon:status', {});
+                const status = await daemonRpc('daemon:session-status', {});
                 activeRelay = status?.relay?.endpoint ?? null;
             }
             catch { /* status is advisory; the socket probe already succeeded */ }

package/dist/commands/help.js

@@ -715,7 +715,7 @@ const PAGES = {
         related: ['call', 'pwd', 'workspace'],
     },
     call: {
-        synopsis: 'beehaven call <action> [json-input] [--building <type>:<id>] [--json]',
+        synopsis: 'beehaven call <action> [json-input | @file | -] [--building <type>:<id>] [--json | --brief]',
         description: `Invoke an RPC on the current target. Input is a JSON string.
     Schema comes from the action's manifest — use \`beehaven actions\` first
     to see what's available, or \`beehaven explain <action>\` for the exact
@@ -725,10 +725,12 @@ const PAGES = {
         flags: [
             { name: '--building <type>:<id>', desc: 'Explicit target (e.g. shopifyStore:clearly-demo)' },
             { name: '--json', desc: 'Suppress breadcrumb + hint blocks; raw stdout only' },
+            { name: '--brief', desc: 'A short receipt instead of the JSON: steps, layer changes, failures, lint to fix, review verdicts. Same exit code.' },
             { name: '--timeout <ms>', desc: 'Override the 30s default' },
         ],
         examples: [
             { cmd: 'beehaven call note-create \'{"title":"Hello"}\'' },
+            { cmd: 'beehaven call canvas-act @build.json --brief', note: 'a canvas batch, read as a one-line receipt' },
             { cmd: "beehaven call project-list '{}' --building home" },
             {
                 cmd: 'beehaven call admin-agent-chat \'{"conversationId":"c1","message":"top sellers?","scope":"read"}\'',

package/dist/commands/workspace.js

@@ -26,6 +26,8 @@ import { resolveActiveAgent } from '../agent-state.js';
 import { isAgentRuntime } from '../agent-scope.js';
 import { getTarget } from '../cli-state.js';
 import { attachShellCwd, absorbShellCwd, shellTargetKey } from '../shell-session.js';
+import { planLimitAdvice } from '../limit-advice.js';
+import { resolveAuthOrigin } from '../browser-login.js';
 /** Workspace-agent jobs wait for the server's ceiling (900s) plus the report's tail. */
 export const AGENT_TURN_TIMEOUT_MS = 930_000;
 const AGENT_TURN_ACTIONS = new Set(['agent-prompt', 'agent-turn']);
@@ -1132,7 +1134,36 @@ export async function cmdCall(action, rawInput, values) {
             printCallErrorHints(raw.message, action, values);
             process.exit(1);
         }
-        if (result && typeof result === 'object') {
+        /**
+         * MCP2-25 — `call … --out <file>` writes the whole JSON result to a file. The canvas skill tells
+         * agents to save a large response once and read a summary, and the only way was `> file`, which a
+         * headless agent needs permission for: a recorded Claude Code take lost a call to "`--out` is not
+         * supported by `beehaven call`". The receipt (or a one-line note) still prints; the exit code is
+         * the result's, exactly as without the flag.
+         */
+        const outPath = values.out ?? values.output;
+        if (typeof outPath === 'string' && outPath) {
+            const { mkdirSync, writeFileSync } = await import('node:fs');
+            const { dirname, resolve } = await import('node:path');
+            const file = resolve(outPath);
+            mkdirSync(dirname(file), { recursive: true });
+            const text = result && typeof result === 'object' ? JSON.stringify(result, null, 2) : String(result ?? '');
+            writeFileSync(file, text + '\n');
+            if (!values.brief)
+                console.log(`wrote ${text.length.toLocaleString()} bytes to ${outPath}`);
+        }
+        let briefFailed = false;
+        if (values.brief && !values.json) {
+            // ⚠ THE SAME RESULT, READ FOR A PERSON — see call-brief.ts for what is kept and why.
+            const { briefReceipt } = await import('../call-brief.js');
+            const receipt = briefReceipt(action, result);
+            console.log(receipt.lines.join('\n'));
+            briefFailed = !receipt.ok;
+        }
+        else if (typeof outPath === 'string' && outPath) {
+            // Written above; the console keeps only the note, so a large result stays out of the context.
+        }
+        else if (result && typeof result === 'object') {
             console.log(JSON.stringify(result, null, 2));
         }
         else {
@@ -1234,7 +1265,7 @@ export async function cmdCall(action, rawInput, values) {
             }
             printKnownActionAdvice(action, input, result);
         }
-        if (isFailureResult(result))
+        if (briefFailed || isFailureResult(result))
             process.exit(1);
     }
     catch (err) {
@@ -1258,6 +1289,16 @@ function printKnownActionAdvice(action, input, result) {
     if (action === 'ticket-get' && result?.code === 'not-found') {
         console.error('  If this key belongs to a document, read it with document-get; ticket-get reads board cards only.');
     }
+    // MCP2-70 / MCP2-71: a plan or account limit says what is true and what to do, in words.
+    if (/-limit-reached$/.test(String(result?.code ?? ''))) {
+        let origin = 'https://www.clearly.sh';
+        try {
+            origin = resolveAuthOrigin().authOrigin;
+        }
+        catch { /* the default web origin */ }
+        for (const line of planLimitAdvice(result, origin))
+            console.error(line);
+    }
 }
 /**
  * Emit navigation hints for common call failures. Agents parse these to
@@ -2434,8 +2475,8 @@ export async function cmdTask(title, values) {
 }
 // ── beehaven doc add <file> — local file → searchable project document ───
 //
-// One-shot: reads a local file, mints a note (note-create) + seeds its body
-// (note-content-seed). Content lands in the workspace SQLite note-content
+// One-shot: reads a local file and creates it through document-create.
+// Content lands in the workspace SQLite note-content
 // table + FTS5 index, so `search-notes` and the cloud agent can retrieve it.
 // This is the DOCUMENT path; `teleport` is the raw-blob (R2) path. Markdown is
 // stored verbatim; code is wrapped in a fenced block (with the language) so it
@@ -2496,16 +2537,14 @@ export async function cmdDocAdd(filePath, values) {
     const title = values.title ||
         (isMarkdown ? raw.match(/^#\s+(.+)$/m)?.[1]?.trim() || fileName : fileName);
     try {
-        const created = await rpcOnce('note-create', {
-            noteData: { projectId: values.project || undefined, title },
-            fileType: 'document',
+        const created = await rpcOnce('document-create', {
+            projectId: values.project || undefined, title, markdown: data,
         }, getTimeout(values));
-        const noteId = created?.noteId || created?.id;
+        assertNoRpcError(created, 'document-create');
+        const noteId = created?.id;
         if (!noteId) {
-            console.error(`  note-create failed: ${JSON.stringify(created)}`);
-            process.exit(1);
+            throw new Error(`document-create failed: ${JSON.stringify(created)}`);
         }
-        await rpcOnce('note-content-seed', { noteId, data, title }, getTimeout(values));
         if (values.json) {
             console.log(JSON.stringify({
                 noteId,

package/dist/connection-ready.js

@@ -0,0 +1,25 @@
+export async function waitForConnection(probe, expectedEndpoint, options = {}) {
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ?? ((ms) => new Promise(resolve => setTimeout(resolve, ms)));
+    const deadline = now() + (options.timeoutMs ?? 30_000);
+    const normalize = (value) => value.replace(/\/+$/, '');
+    let reason = 'starting';
+    do {
+        try {
+            const state = await probe();
+            if (state.endpoint && normalize(state.endpoint) !== normalize(expectedEndpoint))
+                return { ready: false, reason: 'environment-mismatch' };
+            if (state.connected && state.endpoint && normalize(state.endpoint) === normalize(expectedEndpoint))
+                return { ready: true, reason: 'connected' };
+            reason = 'relay-unavailable';
+        }
+        catch {
+            reason = 'starting';
+        }
+        const remaining = deadline - now();
+        if (remaining <= 0)
+            break;
+        await sleep(Math.min(options.pollMs ?? 250, remaining));
+    } while (now() < deadline);
+    return { ready: false, reason };
+}

package/dist/daemon-client.js

@@ -18,6 +18,7 @@ import net from 'net';
 import { resolveClientAuthToken } from './ipc-auth.js';
 import { activeAgentWrap } from './agent-attribution.js';
 import { ipcSocketPath, socketMayExist } from './ipc-path.js';
+import { utf8Stream } from './utf8-stream.js';
 const TIMEOUT_MS = 60_000;
 const AUTH_TIMEOUT_MS = 3_000;
 /** One attempt. Resolves, never rejects. */
@@ -112,8 +113,10 @@ function handshake(socket) {
             socket.removeListener('data', onData);
             reject(new Error('IPC auth handshake timeout'));
         }, AUTH_TIMEOUT_MS);
+        // CA-63 — decode the stream, not each chunk: a character split across two reads stays whole.
+        const decode = utf8Stream();
         const onData = (chunk) => {
-            buffer += chunk.toString();
+            buffer += decode(chunk);
             const lines = buffer.split('\n');
             buffer = lines.pop() || '';
             for (const line of lines) {
@@ -218,8 +221,10 @@ function sendIpc(socket, msg) {
             socket.removeListener('data', onData);
             reject(new Error(`Daemon RPC timeout after ${TIMEOUT_MS}ms`));
         }, TIMEOUT_MS);
+        // CA-63 — decode the stream, not each chunk: a character split across two reads stays whole.
+        const decode = utf8Stream();
         const onData = (chunk) => {
-            buffer += chunk.toString();
+            buffer += decode(chunk);
             const lines = buffer.split('\n');
             buffer = lines.pop() || '';
             for (const line of lines) {