@clearlysh/beehaven 0.8.36 → 0.8.38

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/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 = '6f5ce18b17c5';
 /** 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-10-30T07:25Z';
 /**
  * The build identity as one short string, for `--version`.
  *

package/dist/call-brief.js

@@ -0,0 +1,157 @@
+/**
+ * `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(', ');
+    let added = 0, changed = 0, removed = 0, sawDelta = false;
+    for (const s of steps) {
+        const d = s?.value?.canvasChanges;
+        if (d && typeof d === 'object' && !Array.isArray(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' },
@@ -2090,6 +2092,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 +3064,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 +3115,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 +3126,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,7 @@ 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 { 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 +644,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 +671,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 +699,8 @@ 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 (!err?.code || /^(ECONN|ENOENT|ETIMEDOUT)/.test(String(err.code)))
+            console.error('  Is the daemon connected? Check with: beehaven status');
         process.exit(1);
     }
     /**

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

@@ -1132,7 +1132,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 +1263,7 @@ export async function cmdCall(action, rawInput, values) {
             }
             printKnownActionAdvice(action, input, result);
         }
-        if (isFailureResult(result))
+        if (briefFailed || isFailureResult(result))
             process.exit(1);
     }
     catch (err) {

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) {

package/dist/daemon-process.js

@@ -8,8 +8,15 @@
  * daemon. Windows reads command lines from one CIM query instead.
  */
 import { execFileSync } from 'child_process';
+import { fileURLToPath } from 'node:url';
+export const CURRENT_DAEMON_ENTRY = fileURLToPath(new URL('./daemon-entry.js', import.meta.url));
+/** pgrep receives a regex argument, so every metacharacter in a user-chosen path is literal. */
+export function daemonEntryPattern(entry = CURRENT_DAEMON_ENTRY) {
+    const special = '\\.^$*+?()[]{}|';
+    return Array.from(entry, character => special.includes(character) ? '\\' + character : character).join('');
+}
 /**
- * Whether a full command line is a beehaven daemon or CLI process.
+ * Whether a full command line is a beehaven daemon or a legacy CLI-start daemon.
  *
  * Strict two-condition test (unchanged on macOS/Linux):
  *   1. argv[0] is a node/tsx/beehaven binary — not a shell, an editor, a grep, etc.;
@@ -20,14 +27,17 @@ import { execFileSync } from 'child_process';
  * an extension (`"C:\Program Files\nodejs\node.exe" C:\…\daemon-entry.js`). It is reduced to the
  * Unix shape (`C:/Program_Files/nodejs/node …`) so the same two conditions apply, unquoted.
  */
-export function isBeehavenCommandLine(raw, platform = process.platform) {
+export function isBeehavenCommandLine(raw, platform = process.platform, expectedEntry = CURRENT_DAEMON_ENTRY, executable = process.execPath) {
     let cmd = (raw ?? '').trim();
     if (!cmd)
         return false;
+    const ownExecutable = platform !== 'win32' && (cmd.startsWith(executable + ' ') || cmd.startsWith(`"${executable}" `));
+    let tail = ownExecutable ? cmd.slice(cmd.startsWith('"') ? executable.length + 3 : executable.length + 1).trim() : cmd.replace(/^\S+\s*/, '');
     if (platform === 'win32') {
         const m = /^"([^"]*)"\s*(.*)$/s.exec(cmd) ?? /^(\S+)\s*(.*)$/s.exec(cmd);
         if (!m)
             return false;
+        tail = m[2].trim();
         const argv0 = m[1].replace(/\\/g, '/').replace(/\.(exe|cmd)$/i, '').replace(/\s+/g, '_').toLowerCase();
         cmd = `${argv0} ${m[2].replace(/"/g, '')}`.trim();
     }
@@ -35,15 +45,20 @@ export function isBeehavenCommandLine(raw, platform = process.platform) {
     // running a heredoc that contains "node .../cli.js" deeper in its argv doesn't false-positive.
     const argv0Ok = /^(\S*\/)?node(\s|$)/.test(cmd) ||
         /^(\S*\/)?tsx(\s|$)/.test(cmd) ||
-        /^(\S*\/)?beehaven(\s|$)/.test(cmd);
+        /^(\S*\/)?beehaven(\s|$)/.test(cmd) || ownExecutable;
     if (!argv0Ok)
         return false;
-    // ⚠⚠ ON WINDOWS ONLY THE DAEMON ENTRY COUNTS. The `cli.js` patterns below exist for LEGACY daemons
-    // (`node cli.js start`, before daemon-entry.js) — and on macOS `pgrep` never surfaced ordinary CLI
-    // runs anyway (it reads its pattern as a BASIC regex, where `(js|ts)` matches nothing). Windows
-    // lists every node process, so with them a `start --headless` parent waiting for its child was
-    // "another daemon" (the child refused to start — the second Windows CI run), and `stop` would
-    // have killed an agent's in-flight `beehaven call`. There are no legacy Windows daemons to find.
+    const firstArgument = tail.startsWith('"') ? tail.slice(1).split('"')[0] : tail.split(/\s/)[0];
+    if (/^-(?:e|p|ep|pe)$|^--(?:eval|print)(?:=|$)/.test(firstArgument))
+        return false;
+    // A custom installer prefix need not contain the word "beehaven". Trust only this package's
+    // exact entry as the direct script argument; a quoted mention inside `node -e` is not a daemon.
+    const normalize = (s) => platform === 'win32' ? s.replace(/\\/g, '/').toLowerCase() : s;
+    const rest = normalize(tail), entry = normalize(expectedEntry);
+    if ([entry, `"${entry}"`].some(value => rest === value || rest.startsWith(value + ' ')))
+        return true;
+    // Windows has no legacy CLI-start daemons. Unix retains that old start shape, but ordinary
+    // CLI calls and eval/print processes are never daemon candidates on any platform.
     if (platform === 'win32')
         return /[/\\]\.?beehaven([-_]sdk)?[/\\].*daemon-entry\.(js|ts)\b/.test(cmd);
     // Condition 2: a subsequent argument must reference a beehaven script.
@@ -59,8 +74,8 @@ export function isBeehavenCommandLine(raw, platform = process.platform) {
     /[/\\]\.?beehaven([-_]sdk)?[/\\].*daemon-entry\.(js|ts)\b/.test(cmd) ||
         /Clearly[^/\\]*\.app[/\\]Contents[/\\]Resources[/\\]beehaven[/\\]daemon-entry\.js\b/.test(cmd) ||
         // Legacy `cli.js start` — for old bundles pre-dating daemon-entry.js.
-        /[/\\]\.?beehaven([-_]sdk)?[/\\].*cli\.(js|ts)\b/.test(cmd) ||
-        /Clearly[^/\\]*\.app[/\\]Contents[/\\]Resources[/\\]beehaven[/\\]cli\.js\b/.test(cmd) ||
+        /[/\\]\.?beehaven([-_]sdk)?[/\\].*cli\.(js|ts)["']?\s+start(?:\s|$)/.test(cmd) ||
+        /Clearly[^/\\]*\.app[/\\]Contents[/\\]Resources[/\\]beehaven[/\\]cli\.js["']?\s+start(?:\s|$)/.test(cmd) ||
         // Bare `beehaven start` — wrapper already matched argv[0].
         /^(\S*\/)?beehaven\s+start\b/.test(cmd));
 }

package/dist/daemon.js

@@ -14,7 +14,7 @@ import { browsePath } from './file-browser.js';
 import { CloudBeeProxy } from './bee/cloud-proxy.js';
 import { IpcServer, probeIpcSocket } from './ipc-server.js';
 import { ipcSocketPath } from './ipc-path.js';
-import { isBeehavenCommandLine, windowsNodeProcesses, selectWindowsDaemons } from './daemon-process.js';
+import { isBeehavenCommandLine, windowsNodeProcesses, selectWindowsDaemons, daemonEntryPattern } from './daemon-process.js';
 import { mintIpcAuthTokens, clearIpcAuthToken } from './ipc-auth.js';
 /**
  * What THIS daemon minted, so shutdown can avoid scrubbing a successor's token.
@@ -41,7 +41,7 @@ import { AgentSessions } from './agent-sessions.js';
 import { RELAY_PRESETS, relayUrlFromConfig, resolveRelaySelection } from './relay-presets.js';
 import { readFileSync, existsSync, mkdirSync, mkdtempSync, writeFileSync, readdirSync, chmodSync, unlinkSync, rmSync, } from 'fs';
 import { createHash } from 'crypto';
-import { execFile, execSync, spawn } from 'child_process';
+import { execFile, execFileSync, execSync, spawn } from 'child_process';
 import { homedir, tmpdir } from 'os';
 import { join, dirname, relative } from 'path';
 import { fileURLToPath } from 'url';
@@ -1228,13 +1228,14 @@ export function findLiveDaemons() {
     //    re-validated by isBeehavenProcess so a broad pgrep hit still has
     //    to pass the strict regex check before being considered ours.
     const patterns = [
+        daemonEntryPattern(),
         'beehaven.*daemon-entry\\.(js|ts)',
         'beehaven.*cli\\.(js|ts)',
         'Clearly.*Resources/beehaven',
     ];
     for (const pattern of patterns) {
         try {
-            const out = execSync(`pgrep -f "${pattern}"`, {
+            const out = execFileSync('pgrep', ['-f', pattern], {
                 encoding: 'utf8',
                 stdio: ['pipe', 'pipe', 'pipe'],
             }).trim();

package/dist/ipc-client.js

@@ -11,6 +11,7 @@ import { EventEmitter } from 'events';
 import { resolveClientAuthToken } from './ipc-auth.js';
 import { ipcSocketPath, socketMayExist } from './ipc-path.js';
 import { activeAgentWrap } from './agent-attribution.js';
+import { utf8Stream } from './utf8-stream.js';
 /** The default address (Unix socket, or this user's named pipe on Windows) — see `ipc-path.ts`. */
 const IPC_SOCKET_PATH = ipcSocketPath();
 /** Default timeout for RPC calls (ms) */
@@ -77,8 +78,10 @@ export class IpcClient extends EventEmitter {
             socket.on('connect', () => {
                 this._connected = 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/ipc-server.js

@@ -27,6 +27,7 @@ import { createConnection, createServer } from 'net';
 import { EventEmitter } from 'events';
 import { resolveAuthScope } from './ipc-auth.js';
 import { ipcSocketPath, socketMayExist, clearStaleSocket, restrictSocketToOwner } from './ipc-path.js';
+import { utf8Stream } from './utf8-stream.js';
 /** The default address (Unix socket, or this user's named pipe on Windows) — see `ipc-path.ts`. */
 const IPC_SOCKET_PATH = ipcSocketPath();
 /**
@@ -194,8 +195,10 @@ export class IpcServer extends EventEmitter {
                 daemonPid: process.pid,
                 requireAuth: true,
             });
+            // CA-63 — decode the stream, not each chunk: a character split across two reads stays whole.
+            const decode = utf8Stream();
             socket.on('data', (data) => {
-                client.buffer += data.toString();
+                client.buffer += decode(data);
                 const lines = client.buffer.split('\n');
                 client.buffer = lines.pop() || '';
                 for (const line of lines) {