@byokit/herdr 0.1.10 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## Unreleased
 
+## 0.3.0 (2026-10-01)
+
+- Dependency update: pins @byokit/reach 0.5.0.
+- Dependency update: pins @byokit/relay 0.5.0.
+- Dependency update: pins @byokit/link 0.7.0.
+
+- `PromptReceipt.agentSession` optionally identifies the conversation from the prompt response without an extra read.
+
+- FIX: Refuse non-empty `StartAgent.env` on existing panes instead of silently using the old subscription.
+- Move a conversation to another subscription account with `moveToAccount`: verify the target shell folder,
+  resume and wait before closing the original pane, and roll back the new pane on failure.
+- Open each CLI’s own sign-in in an account-specific tab with `openSignInTab` and the host’s explicit env.
+
+- `HerdrKit.startAgent` lifecycle events: `installing` (with the progress words) before a start
+  that needs an install, `ready` with the fresh ref, and `launchFailed` with a typed reason
+  (`placement-failed` | `pane-busy` | `install-failed` | `start-rejected`) plus plain words —
+  subscribable per call (`StartAgent.onEvent`) or app-wide (`kit.onStartAgent`), no polling.
+  The shape and rejection are unchanged. Install detection (`agentInstallState`, also on
+  `agentStatus` as `installState`) tells a real runnable binary apart from an auto-install
+  launcher such as a mise shim: shimmed or absent reads `installs-on-first-start`, sharing the
+  one probe path with `installedAgentKinds` (`resolveAgentBinary`, `isAutoInstallShim`).
+
+## 0.2.0 (2026-09-30)
+
+- `HerdrKit.agentStatus(kinds)` (B5): per-kind onboarding readiness — installed plus CLI
+  sign-in (`yes`/`no`/`unknown`) from each CLI's own non-secret status command (`claude auth
+  status`, Codex `app-server` `account/read`; `unknown` where a CLI has none), install and
+  sign-in hint words, and the extra install dirs (mise shims, `~/.local/bin`, Homebrew) moved
+  in from muxr's PATH probe. Pi reads `installed: false` with `installs on first start`. The
+  command runner is injectable for tests; credential files are never read.
+
 ## 0.1.10 (2026-09-30)
 
 - Dependency update: pins @byokit/relay 0.4.2.

package/README.md

@@ -149,7 +149,8 @@ persistent grant store, and the phone page above.
 
 | Export | What it does |
 |---|---|
-| `HerdrKit` (`@byokit/herdr`) | The host-side kit, in `adopt` or `own` mode: `start`/`stop`, `state`, `snapshot`/`onChange`, `startAgent`, `prompt`, `sendKeys`, `wait`, `read`, `blocked`/`onBlocked`/`answer`, `closePane`/`closeTab`/`closeWorkspace`, `agentKinds`, `installedAgentKinds`, `terminal`, `onEvent`, `statusWatchReady`, and the pass-throughs `call`, `subscribe` and `cli` |
+| `HerdrKit` (`@byokit/herdr`) | The host-side kit, in `adopt` or `own` mode: `start`/`stop`, `state`, `snapshot`/`onChange`, `startAgent`, `openSignInTab`, `moveToAccount`, `onStartAgent`, `prompt`, `sendKeys`, `wait`, `read`, `blocked`/`onBlocked`/`answer`, `closePane`/`closeTab`/`closeWorkspace`, `agentKinds`, `installedAgentKinds`, `agentStatus`, `agentInstallState`, `terminal`, `onEvent`, `statusWatchReady`, and the pass-throughs `call`, `subscribe` and `cli` |
+| `agentStatus`, `agentInstallState`, `agentProbePath`, `extraPathDirs`, `runStatusCommand`, `isAutoInstallShim`, `resolveAgentBinary` (`@byokit/herdr`) | Onboarding readiness: per-kind install + CLI sign-in without a Herdr connection (see below) |
 | `HERDR_VERSION`, `HERDR_PROTOCOL` | The pinned Herdr release (`0.9.1`) and the protocol the kit speaks (`22`) |
 | `words`, `agentWords`, `stateWords`, `WORDS` | Plain sentences for agent statuses and kit states |
 | `herdrLink` (`@byokit/herdr/link`) | The host side of the `hd.*` link ops, spread into `Host.open`; scopes each grant to its workspaces and can push sealed approval notices through a relay |
@@ -159,15 +160,118 @@ persistent grant store, and the phone page above.
 | `startFakeHerdr`, `writeBinShim`, `herdrContract` (`@byokit/herdr/testing`) | The kit's stand-in Herdr, a bin shim that runs it, and the contract suite the kit passes |
 | `ensureHerdr`, `fetchHerdr`, `HERDR_ASSETS` (`@byokit/herdr/binary`) | Opt-in pinned fetch: the v0.9.1 asset for the current platform into an app-owned dir, sha256-verified, executable, returned as the absolute `own`-mode `bin`; refused (nothing left) on a hash mismatch or unsupported platform |
 
+`PromptReceipt` contains `paneId`, `terminalId`, `revision`, and `status`. Its optional
+`agentSession` (`{ source, agent, kind, value }`) identifies the conversation that received
+this prompt, taken directly from the `agent.prompt` response without another read.
+`kind` distinguishes a session id from a session path; `value` is that id or path.
+Herdr exposes no separate generation counter. When Herdr omits the session (or returns
+null), `agentSession` is absent; callers can fall back to their existing checks.
+
 Types (`HerdrKitOptions`, `HerdrState`, `StartAgent`, `PromptReceipt`, `BlockedAgent`, `HerdrSnapshot`,
 `HerdrMethod`/`HerdrParams`/`HerdrResult`, `HerdrEventName`/`HerdrEventOf`, ...) come from the main entry.
 
+## Account-specific sign-ins and moves
+
+The host supplies account folders and shares conversation history as needed. The kit never reads or copies
+credentials. To connect an account, open its CLI in a new tab and let the person complete the CLI's own login:
+
+```ts
+import type { HerdrKit } from '@byokit/herdr';
+
+declare const kit: HerdrKit; // the host's started kit
+const signIn = await kit.openSignInTab({
+  workspaceId: 'w1', kind: 'codex', cwd: '/home/me/project', env: { CODEX_HOME: '/app/accounts/work' },
+});
+// Attach terminal(signIn.paneId, …) for the CLI's own sign-in screen.
+const moved = await kit.moveToAccount({ paneId: 'w1:p2' }, {
+  provider: 'codex', folder: '/app/accounts/work',
+});
+if (moved.ok) console.log(moved.session); // new pane to follow
+```
+
+A move accepts Claude/Pi for Claude folders and Codex/Pi for Codex folders. It verifies the new shell's effective
+account folder, resumes the conversation there, waits for a ready session, then closes the old pane. A failed
+start preserves the original; a failed source close rolls back the new pane. Failures return a plain `message`
+and a `live` pane id for recovery, including when cleanup fails. Wait until a conversation is idle or done before
+moving it. `StartAgent.env` applies to newly created placements; existing shells cannot receive a new env.
+Tokens stay on the device and are never logged. Each provider's own terms apply to how you use your plan.
+
 ## Two ways in
 
 - `adopt` talks to the socket path the app passes: the person's own Herdr, nothing spawned, nothing written.
 - `own` runs the Herdr binary the app names, in an app-owned state directory.
 
 Helpers cover the common paths (start an agent, deliver a prompt with a receipt, watch blocked agents, exact closes).
+
+## Agent readiness
+
+`kit.agentStatus(kinds)` reports, per kind, whether the agent's CLI is installed and whether
+it is signed in — the onboarding agents-and-pickers check. It needs no Herdr connection: it
+probes the local machine. Install detection reuses `installedAgentKinds` over the host PATH plus
+the extra install dirs a service PATH omits (`extraPathDirs`: `~/.local/bin`, the mise shims,
+`~/.npm-global/bin`, Homebrew and the system dirs — the set muxr probed before this kit did).
+Sign-in comes only from each CLI's own documented non-secret status command, with a 10 s timeout;
+a kind whose CLI has none, or whose command gives no answer, reads `unknown`. Credential files
+are never opened, read or statted — only the signed-in boolean is kept. Install detection tells a
+real runnable binary apart from an auto-install launcher: a mise-style shim on PATH, or nothing
+on PATH at all, reads `installState: 'installs-on-first-start'` with `installed: false` — Herdr
+fetches the agent on first start — instead of a missing-install error. That covers `pi`, which
+Herdr installs via mise: a missing or shimmed `pi` reads `installed: false` with `installs on
+first start`, while a real `pi` binary reads `installed: true`.
+
+```ts
+import { HerdrKit } from '@byokit/herdr';
+
+const kit = new HerdrKit({ mode: 'adopt', bin: 'herdr', socketPath: '/tmp/herdr.sock' });
+// Local probe only — the kit need not be started.
+console.log(await kit.agentStatus(['pi', 'claude', 'codex']));
+```
+
+```text
+[
+  { kind: 'pi', installed: false, installState: 'installs-on-first-start', signedIn: 'unknown',
+    installHint: 'installs on first start' },
+  { kind: 'claude', installed: true, installState: 'installed', signedIn: 'yes',
+    installHint: 'Install the claude command, then check again.' },
+  { kind: 'codex', installed: true, installState: 'installed', signedIn: 'no',
+    installHint: 'Install the codex command, then check again.',
+    signInHint: 'On this computer run `codex`, sign in, then come back.' },
+]
+```
+
+| Kind | Status command | Why this one |
+|---|---|---|
+| `claude` | `claude auth status` (JSON `loggedIn`) | The CLI's own documented status; a signed-out CLI still prints its JSON, so only an empty answer reads `unknown`. |
+| `codex` | `codex app-server` with a pipelined `initialize` + `account/read` round | Codex exposes sign-in only over its app-server protocol; a record `account` in the second answer means signed in. |
+| `pi` | none (Herdr installs it via mise) | Missing or shimmed: `installed: false`, `installs on first start`. A real binary reads `installed: true`. |
+| any other kind | none | No documented non-secret status command, so `unknown` until the kit covers it. |
+
+Options: `{ path, aliases }` as in `installedAgentKinds`; `{ readFile }` overrides the shim
+sniff's file-head reader (tests use fakes); `{ run }` injects the command runner
+(`(command, args, { stdin, timeoutMs }) => Promise<{ stdout } | undefined>`, so tests use fakes);
+`{ timeoutMs }` bounds each probe. `signInHint` rides kinds the kit knows how to check whenever they
+are not signed in; `installHint` always rides along.
+
+## Agent start lifecycle
+
+`startAgent` keeps its typed shape and rejection, and additionally reports the launch as events
+so an app shows `Installing…` instead of a blank start: `installing` (with the progress words)
+before a start that needs an install, `ready` with the fresh ref, and `launchFailed` with a typed
+`reason` (`placement-failed` | `pane-busy` | `install-failed` | `start-rejected`) plus plain words.
+Subscribe per call with `onEvent`, or app-wide with `kit.onStartAgent` — no polling either way.
+
+```ts
+import { HerdrKit } from '@byokit/herdr';
+
+const kit = new HerdrKit({ mode: 'adopt', bin: 'herdr', socketPath: '/tmp/herdr.sock' });
+const off = kit.onStartAgent((e) => {
+  if (e.phase === 'installing') console.log(e.message);       // Installing pi…
+  if (e.phase === 'launchFailed') console.log(e.reason, e.message);
+});
+await kit.startAgent({ kind: 'pi', cwd: '/home/me/project', place: { workspace: 'new' },
+  onEvent: (e) => { if (e.phase === 'ready') console.log(e.ref.paneId); } });
+off();
+```
 `call` and `subscribe` are typed pass-throughs to the complete socket API, and `cli()` reaches the full CLI.
 
 `start()` is non-fatal: if Herdr is down it rejects (state `failed`, e.g. `failed/socket`) and may be called again

package/dist/accounts.d.ts

@@ -0,0 +1,9 @@
+import type { Call } from './agents.ts';
+import type { AgentRef, MoveResult, MoveToAccount, OpenSignInTab, StartAgent } from './types.ts';
+export declare function createAccountPanes(ctx: {
+    call: Call;
+    startAgent(o: StartAgent): Promise<AgentRef>;
+}): {
+    openSignInTab: (o: OpenSignInTab) => Promise<AgentRef>;
+    moveToAccount: (target: AgentRef, o: MoveToAccount) => Promise<MoveResult>;
+};

package/dist/accounts.js

@@ -0,0 +1,130 @@
+// Account-specific CLI panes (D11/6.6). No credentials are read or copied. Moves follow
+// the decided start-then-close order; only fake transports exercise this in tests.
+import { randomBytes } from 'node:crypto';
+import { words } from "./words.js";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export function createAccountPanes(ctx) {
+    const moving = new Set();
+    const call = ctx.call;
+    async function close(paneId) {
+        try {
+            await call('pane.close', { pane_id: paneId });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // A shell rc can override placement env. Verify what the shell actually resolves, rather
+    // than pane.get's launch env. The variable name is fixed by the provider, never caller text.
+    async function checkEnv(paneId, variable, folder, timeout) {
+        const marker = `BYOKIT_ACCOUNT_${randomBytes(8).toString('hex')}`;
+        const deadline = Date.now() + timeout;
+        try {
+            await call('pane.send_text', { pane_id: paneId, text: `echo ${marker}="$${variable}"\n` }, timeout);
+            for (;;) {
+                const result = await call('pane.read', { pane_id: paneId, source: 'recent_unwrapped', lines: 40,
+                    format: 'text', strip_ansi: true }, Math.max(1, deadline - Date.now()));
+                const readings = String(result?.read?.text ?? '').split('\n').map((line) => line.trim())
+                    .filter((line) => line.startsWith(`${marker}=`)).map((line) => line.slice(marker.length + 1));
+                if (readings.length > 0)
+                    return readings.includes(folder);
+                if (Date.now() >= deadline)
+                    return false;
+                await sleep(Math.min(100, Math.max(1, deadline - Date.now())));
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    async function openSignInTab(o) {
+        const { workspaceId, label, ...start } = o;
+        try {
+            return await ctx.startAgent({ ...start, place: { tab: 'new', workspaceId,
+                    ...(label === undefined ? {} : { label }) } });
+        }
+        catch {
+            // A runtime error can contain account env. Never relay it to the sign-in screen.
+            throw Object.assign(new Error(words('agent.notReady')), { code: 'sign_in_failed' });
+        }
+    }
+    async function moveToAccount(target, o) {
+        const failed = (code, live = target.paneId) => ({ ok: false, code, message: words(`move.${code}`), live });
+        if (moving.has(target.paneId))
+            return failed('busy');
+        moving.add(target.paneId);
+        try {
+            let agent;
+            try {
+                agent = (await call('agent.get', { target: target.paneId }))?.agent;
+            }
+            catch {
+                return failed('too_early');
+            }
+            const session = agent?.agent_session;
+            if (!agent || agent.launch_pending === true || !session || typeof session.value !== 'string'
+                || session.value.length === 0)
+                return failed('too_early');
+            if (!['idle', 'done'].includes(agent.agent_status))
+                return failed('busy');
+            const kind = agent.agent;
+            if (!['claude', 'codex'].includes(o.provider) || ![o.provider, 'pi'].includes(kind)
+                || session.agent !== kind)
+                return failed('unsupported');
+            const args = kind === 'pi' && session.kind === 'path' ? ['--session', session.value]
+                : kind === 'claude' && session.kind === 'id' ? ['--resume', session.value]
+                    : kind === 'codex' && session.kind === 'id' ? ['resume', session.value] : undefined;
+            if (args === undefined)
+                return failed('unsupported');
+            if (!o.folder || /[\r\n\0]/.test(o.folder))
+                return failed('env_mismatch');
+            const timeout = o.timeoutMs ?? 15_000;
+            if (!Number.isFinite(timeout) || timeout <= 0)
+                return failed('start_failed');
+            const variable = o.provider === 'claude' ? 'CLAUDE_CONFIG_DIR' : 'CODEX_HOME';
+            let paneId;
+            try {
+                const split = await call('pane.split', { target_pane_id: target.paneId,
+                    direction: o.direction ?? 'right', focus: false,
+                    ...(typeof (agent.foreground_cwd ?? agent.cwd) === 'string' ? { cwd: agent.foreground_cwd ?? agent.cwd } : {}),
+                    env: { ...o.env, [variable]: o.folder } }, timeout);
+                if (typeof split?.pane?.pane_id !== 'string')
+                    return failed('start_failed');
+                paneId = split.pane.pane_id;
+            }
+            catch {
+                return failed('start_failed');
+            }
+            if (!await checkEnv(paneId, variable, o.folder, timeout)) {
+                await close(paneId);
+                return failed('env_mismatch');
+            }
+            try {
+                // Unique names avoid colliding with the still-live source agent.
+                await ctx.startAgent({ kind, cwd: agent.foreground_cwd ?? agent.cwd ?? '.',
+                    name: `move-${randomBytes(8).toString('hex')}`, place: { pane: paneId }, args, timeoutMs: timeout });
+                await call('agent.wait', { target: paneId, until: ['idle', 'done'], timeout_ms: timeout }, timeout + 5000);
+                const ready = (await call('agent.get', { target: paneId }))?.agent;
+                if (!ready || ready.launch_pending === true || !['idle', 'done'].includes(ready.agent_status)
+                    || ready.agent !== kind || ready.agent_session?.agent !== kind
+                    || ready.agent_session?.kind !== session.kind || typeof ready.agent_session?.value !== 'string'
+                    || ready.agent_session.value.length === 0)
+                    throw new Error('not ready');
+            }
+            catch {
+                const cleaned = await close(paneId);
+                return failed('start_failed', cleaned ? target.paneId : paneId);
+            }
+            if (!await close(target.paneId)) {
+                const cleaned = await close(paneId);
+                return failed('close_failed', cleaned ? target.paneId : paneId);
+            }
+            return { ok: true, session: paneId };
+        }
+        finally {
+            moving.delete(target.paneId);
+        }
+    }
+    return { openSignInTab, moveToAccount };
+}

package/dist/agents.d.ts

@@ -1,8 +1,34 @@
 import type { HerdrKit } from './kit.ts';
-import type { HerdrSnapshot } from './types.ts';
+import type { AgentInstallProbe, AgentInstallState, AgentLaunchFailureReason, AgentStartEvent, HerdrSnapshot } from './types.ts';
 export type Call = (method: string, params: Record<string, unknown>, timeoutMs?: number) => Promise<unknown>;
 export declare function createAgents(ctx: {
     call: Call;
     snapshot(): HerdrSnapshot;
     reread(paneId: string): Promise<void>;
-}): Pick<HerdrKit, 'startAgent' | 'prompt' | 'sendKeys' | 'wait' | 'read' | 'agentKinds' | 'installedAgentKinds'>;
+    emitStart?(e: AgentStartEvent): void;
+}): Pick<HerdrKit, 'startAgent' | 'prompt' | 'sendKeys' | 'wait' | 'read' | 'agentKinds' | 'installedAgentKinds' | 'agentStatus'>;
+export declare function resolveAgentBinary(kind: string, o: {
+    path: string[];
+    aliases?: Record<string, string[]>;
+}): {
+    binary: string;
+    path?: string;
+};
+export declare function isAutoInstallShim(file: string, readFile?: (file: string) => string | undefined): boolean;
+export declare function agentInstallState(kind: string, o?: AgentInstallProbe): {
+    kind: string;
+    state: AgentInstallState;
+    path?: string;
+};
+export declare function classifyStartFailure(error: unknown, o?: {
+    installExpected?: boolean;
+    stage?: 'placement' | 'start';
+}): AgentLaunchFailureReason;
+export declare function extraPathDirs(home?: string): string[];
+export declare function agentProbePath(path?: string[], home?: string): string[];
+export declare function runStatusCommand(command: string, args: string[], o?: {
+    stdin?: string;
+    timeoutMs?: number;
+}): Promise<{
+    stdout: string;
+} | undefined>;

package/dist/agents.js

@@ -2,8 +2,11 @@
 // Exact param spellings come from the generated v0.9.1 table (6.7); where muxr and the schema
 // disagree the schema wins. `pane.split` takes `target_pane_id` (muxr agrees), and `agent.start`
 // has no `env` param — a start's env belongs to the placement create/split call (src/generated/methods.ts).
-import { accessSync, constants as fsConstants } from 'node:fs';
-import { join } from 'node:path';
+import { spawn } from 'node:child_process';
+import { accessSync, constants as fsConstants, openSync, readSync, closeSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { delimiter, join } from 'node:path';
+import { words } from "./words.js";
 const PROMPTABLE = ['idle', 'working', 'blocked', 'done'];
 const DEFAULT_TIMEOUT_MS = 60_000;
 // `agent.start` lands while the fresh pane is still at its shell prompt: the server answers
@@ -41,10 +44,50 @@ function rootPaneOf(result) {
 }
 export function createAgents(ctx) {
     const call = ctx.call;
+    const emitStart = (e) => {
+        try {
+            ctx.emitStart?.(e);
+        }
+        catch { /* a listener never breaks a start */ }
+    };
     // Every placement takes its pane id from the server's answer, never a prediction (6.4).
     // Placements that make a pane (every path but `pane`) roll it back with `pane.close` when the
     // start fails, so a failed start leaves no extra pane behind.
     async function startAgent(o) {
+        const emit = (e) => {
+            try {
+                o.onEvent?.(e);
+            }
+            catch { /* a listener never breaks a start */ }
+            emitStart(e);
+        };
+        // Install pre-check: a shim or nothing on PATH means Herdr installs on first start, so the
+        // app hears `installing` before the long start instead of watching a blank pane.
+        let installExpected = false;
+        try {
+            installExpected = agentInstallState(o.kind, o.installProbe).state === 'installs-on-first-start';
+        }
+        catch {
+            installExpected = false;
+        }
+        if (installExpected)
+            emit({ phase: 'installing', kind: o.kind, message: words('agent.installing', { agent: o.kind }) });
+        let stage = 'placement';
+        try {
+            const ref = await startAgentInner(o, () => { stage = 'start'; });
+            emit({ phase: 'ready', kind: o.kind, ref });
+            return ref;
+        }
+        catch (error) {
+            const reason = classifyStartFailure(error, { installExpected, stage });
+            emit({ phase: 'launchFailed', kind: o.kind, reason, message: launchFailureWords(reason, o.kind) });
+            throw error;
+        }
+    }
+    async function startAgentInner(o, onStartPhase) {
+        if ('pane' in o.place && Object.keys(o.env ?? {}).length > 0) {
+            throw fail('env_mismatch', 'This pane needs to be opened again to use that sign-in.');
+        }
         const timeout = o.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         const env = o.env === undefined ? {} : { env: o.env };
         let paneId;
@@ -84,6 +127,7 @@ export function createAgents(ctx) {
         }
         if (paneId === undefined)
             throw new Error('herdr: the placement answered no pane id');
+        onStartPhase?.();
         const name = agentName(o);
         const params = { pane_id: paneId, kind: o.kind, name,
             ...(o.args === undefined ? {} : { args: o.args }), timeout_ms: timeout };
@@ -150,7 +194,12 @@ export function createAgents(ctx) {
             || a.pane_id !== target.paneId) {
             throw new Error('Herdr did not queue the prompt.');
         }
-        return { paneId: a.pane_id, terminalId: a.terminal_id, revision: a.revision, status: a.agent_status };
+        const session = a.agent_session;
+        const agentSession = isObj(session) && typeof session.source === 'string'
+            && typeof session.agent === 'string' && typeof session.kind === 'string' && typeof session.value === 'string'
+            ? { source: session.source, agent: session.agent, kind: session.kind, value: session.value } : undefined;
+        return { paneId: a.pane_id, terminalId: a.terminal_id, revision: a.revision, status: a.agent_status,
+            ...(agentSession === undefined ? {} : { agentSession }) };
     }
     async function wait(target, o) {
         const made = await call('agent.wait', { target: target.paneId,
@@ -174,21 +223,225 @@ export function createAgents(ctx) {
         return manifests.map((m) => (typeof m?.agent === 'string' ? m.agent : '')).filter((kind) => kind !== '');
     }
     function installedAgentKinds(kinds, o) {
-        const installed = [];
-        for (const kind of kinds) {
-            const names = [kind, ...(o.aliases?.[kind] ?? [])];
-            if (names.some((name) => o.path.some((dir) => {
+        return kinds.filter((kind) => resolveAgentBinary(kind, o).path !== undefined);
+    }
+    async function agentStatus(kinds, o) {
+        const path = o?.path ?? agentProbePath();
+        const run = o?.run ?? runStatusCommand;
+        const timeoutMs = o?.timeoutMs ?? STATUS_TIMEOUT_MS;
+        const probe = { path, ...(o?.aliases === undefined ? {} : { aliases: o.aliases }),
+            ...(o?.readFile === undefined ? {} : { readFile: o.readFile }) };
+        return Promise.all(kinds.map(async (kind) => {
+            const install = agentInstallState(kind, probe);
+            const binary = o?.aliases?.[kind]?.[0] ?? kind;
+            const installHint = kind === 'pi' ? PI_INSTALL_HINT : `Install the ${binary} command, then check again.`;
+            // A shim or nothing on PATH means Herdr installs on first start: not installed, with the
+            // readiness words instead of a missing-install error (pi included — a real pi binary is
+            // the only case that reads installed).
+            if (install.state !== 'installed')
+                return { kind, installed: false, installState: install.state, signedIn: 'unknown', installHint };
+            const statusProbe = STATUS_PROBES[kind];
+            if (statusProbe === undefined)
+                return { kind, installed: true, installState: 'installed', signedIn: 'unknown', installHint };
+            let answer;
+            try {
+                answer = await run(statusProbe.command, statusProbe.args, { ...(statusProbe.stdin === undefined ? {} : { stdin: statusProbe.stdin }), timeoutMs });
+            }
+            catch {
+                answer = undefined;
+            }
+            const signedIn = answer === undefined ? 'unknown' : statusProbe.parse(answer.stdout);
+            return { kind, installed: true, installState: 'installed', signedIn, installHint,
+                ...(signedIn === 'yes' ? {} : { signInHint: SIGNIN_HINTS[kind] ?? `Sign in to ${kind} on this computer, then check again.` }) };
+        }));
+    }
+    return { startAgent, prompt, sendKeys, wait, read, agentKinds, installedAgentKinds, agentStatus };
+}
+// One source of truth for install detection (B5's probe plus the shim layer below): the first
+// executable file named for the kind across the probe path, with its absolute path.
+export function resolveAgentBinary(kind, o) {
+    const names = [kind, ...(o.aliases?.[kind] ?? [])];
+    for (const name of names) {
+        for (const dir of o.path) {
+            if (dir === '')
+                continue;
+            const file = join(dir, name);
+            try {
+                accessSync(file, fsConstants.X_OK);
+                return { binary: name, path: file };
+            }
+            catch { /* keep looking */ }
+        }
+    }
+    return { binary: o.aliases?.[kind]?.[0] ?? kind };
+}
+// Bounded head read for the shim sniff: the first 2 KiB as text, undefined when unreadable.
+function readHead(file) {
+    let fd;
+    try {
+        fd = openSync(file, 'r');
+        const buf = Buffer.alloc(2048);
+        const n = readSync(fd, buf, 0, buf.length, 0);
+        return buf.subarray(0, n).toString('utf8');
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined)
+            try {
+                closeSync(fd);
+            }
+            catch { /* already gone */ }
+    }
+}
+// A mise-style auto-install launcher reads as a shell script that execs through mise — the
+// found "binary" runs, but the first run installs the agent instead. Real binaries (ELF,
+// Mach-O) never match: the shebang gate keeps a stray "mise" substring ("promise", …) out.
+export function isAutoInstallShim(file, readFile = readHead) {
+    let head;
+    try {
+        head = readFile(file);
+    }
+    catch {
+        return false;
+    }
+    return head !== undefined && head.startsWith('#!') && head.includes('mise');
+}
+// Per-kind install readiness sharing the B5 probe path: `installed` for a real runnable binary,
+// `installs-on-first-start` for an auto-install launcher/shim or nothing on PATH (Herdr fetches
+// the agent on first start). `missing` stays for callers that probe kinds Herdr never installs.
+export function agentInstallState(kind, o) {
+    const path = o?.path ?? agentProbePath();
+    const found = resolveAgentBinary(kind, { path, ...(o?.aliases === undefined ? {} : { aliases: o.aliases }) });
+    if (found.path === undefined)
+        return { kind, state: 'installs-on-first-start' };
+    const shim = isAutoInstallShim(found.path, o?.readFile);
+    return shim ? { kind, state: 'installs-on-first-start', path: found.path }
+        : { kind, state: 'installed', path: found.path };
+}
+// Typed launch failure for the `launchFailed` event. The rejection itself is unchanged — this
+// only classifies it: a busy pane that outlasted the retry budget, an install that never
+// finished, a placement that made no pane, or any other rejected start.
+export function classifyStartFailure(error, o) {
+    const code = codeOf(error);
+    if (code !== undefined && START_RETRYABLE.has(code))
+        return 'pane-busy';
+    if (o?.stage === 'placement')
+        return 'placement-failed';
+    if (o?.installExpected === true)
+        return 'install-failed';
+    return 'start-rejected';
+}
+function launchFailureWords(reason, kind) {
+    if (reason === 'pane-busy')
+        return words('agent.notReady');
+    if (reason === 'install-failed')
+        return words('agent.installFailed', { agent: kind });
+    return words('agent.launchFailed');
+}
+// Extra install dirs muxr's `executableOnPath`
+// (`apps/host/src/agent/infrastructure/herdrSessionSource.ts`) probes past PATH: user-install
+// dirs a service or GUI daemon's inherited PATH omits — mise shims (Herdr installs Pi through
+// mise), `~/.local/bin`, npm-global, Homebrew and the system dirs.
+export function extraPathDirs(home = homedir()) {
+    return [join(home, '.local', 'bin'), join(home, '.local', 'share', 'mise', 'shims'),
+        join(home, '.npm-global', 'bin'), '/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/bin'];
+}
+// The full install probe: the host's own PATH plus the extra dirs, de-duplicated.
+export function agentProbePath(path = (process.env.PATH ?? '').split(delimiter), home = homedir()) {
+    return [...new Set([...path, ...extraPathDirs(home)])].filter((dir) => dir !== '');
+}
+const STATUS_TIMEOUT_MS = 10_000;
+const PI_INSTALL_HINT = 'installs on first start';
+const SIGNIN_HINTS = {
+    claude: 'On this computer run `claude`, sign in, then come back.',
+    codex: 'On this computer run `codex`, sign in, then come back.',
+};
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+// Per-kind CLI status commands (see the README table for why each one). Every probe asks the
+// CLI itself and keeps only the signed-in boolean — email, plan and everything secret stays out.
+// A kind with no documented non-secret status command has no entry and reads 'unknown'.
+const STATUS_PROBES = {
+    // `claude auth status` prints JSON with `loggedIn` (muxr's planIdentity reads the same);
+    // a signed-out CLI still prints its JSON, so only an empty answer means 'unknown'.
+    claude: { command: 'claude', args: ['auth', 'status'], parse: (stdout) => {
+            let status;
+            try {
+                status = JSON.parse(stdout);
+            }
+            catch {
+                return 'unknown';
+            }
+            if (!isRecord(status))
+                return 'unknown';
+            return status.loggedIn === true ? 'yes' : 'no';
+        } },
+    // Codex exposes sign-in only over its app-server protocol, so the probe pipes a pipelined
+    // `initialize` + `account/read` round (same method muxr's planIdentity uses) and reads the
+    // second answer: a record `account` means signed in, its absence means signed out.
+    codex: { command: 'codex', args: ['app-server'],
+        stdin: '{"id":1,"method":"initialize","params":{"clientInfo":{"name":"byokit","version":"1"}}}\n{"id":2,"method":"account/read","params":{}}\n',
+        parse: (stdout) => {
+            for (const line of stdout.split('\n')) {
+                let message;
                 try {
-                    accessSync(join(dir, name), fsConstants.X_OK);
-                    return true;
+                    message = JSON.parse(line);
                 }
                 catch {
-                    return false;
+                    continue;
+                }
+                if (isRecord(message) && message.id === 2) {
+                    return isRecord(message.result) && isRecord(message.result.account) ? 'yes' : 'no';
                 }
-            })))
-                installed.push(kind);
+            }
+            return 'unknown';
+        } },
+};
+// Default runner: one bounded spawn per probe, stdin piped when the protocol needs it (codex).
+// Failures (missing binary, timeout, non-empty stderr, empty stdout) read as no answer — never throw.
+export async function runStatusCommand(command, args, o) {
+    return new Promise((resolve) => {
+        let done = false;
+        const finish = (value) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        let child;
+        try {
+            child = spawn(command, args, { stdio: ['pipe', 'pipe', 'ignore'], timeout: o?.timeoutMs ?? STATUS_TIMEOUT_MS });
         }
-        return installed;
-    }
-    return { startAgent, prompt, sendKeys, wait, read, agentKinds, installedAgentKinds };
+        catch {
+            finish(undefined);
+            return;
+        }
+        let out = '';
+        const timer = setTimeout(() => { child.kill('SIGKILL'); finish(undefined); }, (o?.timeoutMs ?? STATUS_TIMEOUT_MS) + 500);
+        child.on('error', () => finish(undefined));
+        const stdout = child.stdout;
+        const stdin = child.stdin;
+        if (stdout === null || stdin === null) {
+            finish(undefined);
+            return;
+        }
+        stdout.setEncoding('utf8');
+        stdout.on('data', (chunk) => {
+            out += chunk;
+            if (out.length > 64 * 1024) {
+                child.kill('SIGKILL');
+                finish(undefined);
+            }
+        });
+        child.on('close', () => finish(out.trim() === '' ? undefined : { stdout: out.slice(0, 64 * 1024) }));
+        stdin.on('error', () => { });
+        try {
+            if (o?.stdin !== undefined)
+                stdin.write(o.stdin);
+            stdin.end();
+        }
+        catch { /* a dead stdin settles through close/error */ }
+    });
 }

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { HERDR_VERSION, HERDR_PROTOCOL } from './constants.ts';
 export { HerdrKit } from './kit.ts';
 export { agentWords, stateWords, words, WORDS, type WordKey } from './words.ts';
-export type { AgentRef, AgentStatus, BlockedAgent, HerdrEvent, HerdrEventName, HerdrEventOf, HerdrKitOptions, HerdrMethod, HerdrMethods, HerdrParams, HerdrProtocolRange, HerdrResult, HerdrSnapshot, HerdrState, HerdrSubscription, HerdrSubscribeStop, HerdrTransport, PromptReceipt, StartAgent, TerminalSession, } from './types.ts';
+export { agentProbePath, extraPathDirs, runStatusCommand, agentInstallState, isAutoInstallShim, resolveAgentBinary, classifyStartFailure } from './agents.ts';
+export type { AgentCliSignIn, AgentInstallProbe, AgentInstallState, AgentLaunchFailureReason, AgentReadiness, AgentStartEvent, AgentStatusOptions, AgentStatusRunner, AgentRef, AgentStatus, BlockedAgent, HerdrEvent, HerdrEventName, HerdrEventOf, HerdrKitOptions, HerdrMethod, HerdrMethods, HerdrParams, HerdrProtocolRange, HerdrResult, HerdrSnapshot, HerdrState, HerdrSubscription, HerdrSubscribeStop, HerdrTransport, MoveToAccount, MoveResult, OpenSignInTab, PromptReceipt, StartAgent, TerminalSession, } from './types.ts';

package/dist/index.js

@@ -3,3 +3,4 @@
 export { HERDR_VERSION, HERDR_PROTOCOL } from "./constants.js";
 export { HerdrKit } from "./kit.js";
 export { agentWords, stateWords, words, WORDS } from "./words.js";
+export { agentProbePath, extraPathDirs, runStatusCommand, agentInstallState, isAutoInstallShim, resolveAgentBinary, classifyStartFailure } from "./agents.js";

package/dist/kit.d.ts

@@ -1,4 +1,4 @@
-import type { AgentRef, AgentStatus, BlockedAgent, HerdrEvent, HerdrEventName, HerdrEventOf, HerdrKitOptions, HerdrMethod, HerdrParams, HerdrResult, HerdrSnapshot, HerdrState, HerdrSubscription, HerdrSubscribeStop, PromptReceipt, StartAgent, TerminalSession } from './types.ts';
+import type { AgentReadiness, AgentStartEvent, AgentStatusOptions, AgentRef, AgentStatus, BlockedAgent, HerdrEvent, HerdrEventName, HerdrEventOf, HerdrKitOptions, HerdrMethod, HerdrParams, HerdrResult, HerdrSnapshot, HerdrState, HerdrSubscription, HerdrSubscribeStop, PromptReceipt, StartAgent, TerminalSession, MoveToAccount, MoveResult, OpenSignInTab } from './types.ts';
 export declare class HerdrKit {
     private readonly supervisor;
     private transport?;
@@ -14,7 +14,9 @@ export declare class HerdrKit {
     private statusEpoch;
     private readonly o;
     private readonly callAny;
+    private readonly accountPanes;
     private readonly agents;
+    private readonly startListeners;
     private readonly blockedList;
     constructor(o: HerdrKitOptions);
     get state(): HerdrState;
@@ -65,7 +67,10 @@ export declare class HerdrKit {
      * status events instead of opening a second watch.
      */
     statusWatchReady(): Promise<void>;
+    openSignInTab(o: OpenSignInTab): Promise<AgentRef>;
+    moveToAccount(target: AgentRef, o: MoveToAccount): Promise<MoveResult>;
     startAgent(o: StartAgent): Promise<AgentRef>;
+    onStartAgent(fn: (e: AgentStartEvent) => void): () => void;
     prompt(target: AgentRef, text: string, o?: {
         wait?: {
             until?: AgentStatus[];
@@ -98,4 +103,5 @@ export declare class HerdrKit {
         path: string[];
         aliases?: Record<string, string[]>;
     }): string[];
+    agentStatus(kinds: readonly string[], o?: AgentStatusOptions): Promise<AgentReadiness[]>;
 }

package/dist/kit.js

@@ -1,3 +1,4 @@
+import { createAccountPanes } from "./accounts.js";
 import { createAgents } from "./agents.js";
 import { Blocked } from "./approvals.js";
 import { runCli } from "./cli.js";
@@ -126,13 +127,21 @@ export class HerdrKit {
     // a snapshot read wins over the read (see bootstrap)
     o;
     callAny = (method, params, timeoutMs) => this.call(method, params, timeoutMs === undefined ? undefined : { timeoutMs });
+    accountPanes;
     agents;
+    startListeners = new Set();
     blockedList;
     constructor(o) {
         this.o = o;
         this.supervisor = new Supervisor(o, (s) => { this.current = s; o.onState?.(s); });
+        this.accountPanes = createAccountPanes({ call: this.callAny, startAgent: (o) => this.startAgent(o) });
         this.agents = createAgents({ call: this.callAny, snapshot: () => this.snapshot(),
-            reread: (paneId) => this.reread(paneId) });
+            reread: (paneId) => this.reread(paneId),
+            emitStart: (e) => { for (const fn of [...this.startListeners])
+                try {
+                    fn(e);
+                }
+                catch { /* a listener never breaks a start */ } } });
         this.blockedList = new Blocked({ call: this.callAny });
     }
     get state() { return this.current; }
@@ -437,7 +446,15 @@ export class HerdrKit {
      * status events instead of opening a second watch.
      */
     statusWatchReady() { return this.statusReadyPromise; }
+    openSignInTab(o) { return this.accountPanes.openSignInTab(o); }
+    moveToAccount(target, o) { return this.accountPanes.moveToAccount(target, o); }
     startAgent(o) { return this.agents.startAgent(o); }
+    // App-wide start lifecycle without polling: every startAgent's installing/ready/launchFailed
+    // lands here as well as on that call's own `onEvent`. Returns the unsubscribe function.
+    onStartAgent(fn) {
+        this.startListeners.add(fn);
+        return () => { this.startListeners.delete(fn); };
+    }
     prompt(target, text, o) { return this.agents.prompt(target, text, o); }
     sendKeys(target, keys) { return this.agents.sendKeys(target, keys); }
     wait(target, o) { return this.agents.wait(target, o); }
@@ -450,4 +467,7 @@ export class HerdrKit {
     closeWorkspace(workspaceId) { return closeWorkspace(this.callAny, workspaceId); }
     agentKinds() { return this.agents.agentKinds(); }
     installedAgentKinds(kinds, o) { return this.agents.installedAgentKinds(kinds, o); }
+    // Onboarding readiness (B5): a local PATH probe plus each installed CLI's own status
+    // command — no Herdr connection needed, credential files never read.
+    agentStatus(kinds, o) { return this.agents.agentStatus(kinds, o); }
 }

package/dist/types.d.ts

@@ -47,6 +47,49 @@ export type HerdrEvent = {
 export type { HerdrMethods, HerdrMethod, HerdrParams, HerdrResult } from './generated/methods.ts';
 export type { HerdrEvents, HerdrEventName, HerdrEventOf, HerdrSubscription } from './generated/events.ts';
 export type AgentStatus = 'idle' | 'working' | 'blocked' | 'done' | 'unknown';
+export type AgentCliSignIn = 'yes' | 'no' | 'unknown';
+export type AgentInstallState = 'installed' | 'installs-on-first-start' | 'missing';
+export type AgentInstallProbe = {
+    path?: string[];
+    aliases?: Record<string, string[]>;
+    readFile?: (file: string) => string | undefined;
+};
+export type AgentReadiness = {
+    kind: string;
+    installed: boolean;
+    installState: AgentInstallState;
+    signedIn: AgentCliSignIn;
+    installHint: string;
+    signInHint?: string;
+};
+export type AgentStatusRunner = (command: string, args: string[], o?: {
+    stdin?: string;
+    timeoutMs?: number;
+}) => Promise<{
+    stdout: string;
+} | undefined>;
+export type AgentStatusOptions = {
+    path?: string[];
+    aliases?: Record<string, string[]>;
+    readFile?: (file: string) => string | undefined;
+    run?: AgentStatusRunner;
+    timeoutMs?: number;
+};
+export type AgentLaunchFailureReason = 'placement-failed' | 'pane-busy' | 'install-failed' | 'start-rejected';
+export type AgentStartEvent = {
+    phase: 'installing';
+    kind: string;
+    message: string;
+} | {
+    phase: 'ready';
+    kind: string;
+    ref: AgentRef;
+} | {
+    phase: 'launchFailed';
+    kind: string;
+    reason: AgentLaunchFailureReason;
+    message: string;
+};
 export type AgentRef = {
     paneId: string;
     name?: string;
@@ -75,12 +118,35 @@ export type StartAgent = {
     args?: string[];
     env?: Record<string, string>;
     timeoutMs?: number;
+    onEvent?: (e: AgentStartEvent) => void;
+    installProbe?: AgentInstallProbe;
+};
+export type OpenSignInTab = Omit<StartAgent, 'place' | 'worktree'> & {
+    workspaceId: string;
+    label?: string;
+};
+export type MoveToAccount = {
+    provider: 'claude' | 'codex';
+    folder: string;
+    env?: Record<string, string>;
+    direction?: 'right' | 'down';
+    timeoutMs?: number;
+};
+export type MoveResult = {
+    ok: true;
+    session: string;
+} | {
+    ok: false;
+    code: 'too_early' | 'busy' | 'unsupported' | 'env_mismatch' | 'close_failed' | 'start_failed';
+    message: string;
+    live?: string;
 };
 export type PromptReceipt = {
     paneId: string;
     terminalId: string;
     revision: number;
     status: AgentStatus;
+    agentSession?: AgentSessionRef;
 };
 export type BlockedAgent = {
     paneId: string;

package/dist/words.json

@@ -13,7 +13,16 @@
     "agent.unknown": "Running.",
     "agent.signIn": "Sign in inside {agent}: follow its own steps on the screen.",
     "agent.notReady": "This helper isn't ready yet. Try again in a moment.",
+    "agent.installing": "Installing {agent}…",
+    "agent.installFailed": "Installing {agent} didn't finish. Try again in a moment.",
+    "agent.launchFailed": "That helper couldn't start. Try again in a moment.",
     "approval.stale": "That question already changed. Look again before answering.",
     "close.wouldWiden": "Closing this would close more than you picked. Close the bigger one instead.",
-    "link.notAllowed": "This device can't do that. Ask the person at the computer."
+    "link.notAllowed": "This device can't do that. Ask the person at the computer.",
+    "move.too_early": "This conversation has not started yet. Try again in a moment.",
+    "move.busy": "Wait for this conversation to finish before moving it.",
+    "move.unsupported": "This conversation cannot move between these accounts.",
+    "move.env_mismatch": "The new pane did not receive that sign-in. Try again.",
+    "move.close_failed": "The old pane could not close. The move was undone where possible.",
+    "move.start_failed": "The new account could not take over. Try again."
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byokit/herdr",
-  "version": "0.1.10",
+  "version": "0.3.0",
   "description": "Drive the Herdr on this computer — workspaces, tabs, panes, agents and blocked-approval answers — from an app, or hand it to a phone over @byokit/link.",
   "license": "Apache-2.0",
   "type": "module",
@@ -52,9 +52,9 @@
     "prepack": "tsc -b && node ../../scripts/fix-words-dts.cjs"
   },
   "dependencies": {
-    "@byokit/link": "0.6.0",
-    "@byokit/relay": "0.4.2",
-    "@byokit/reach": "0.4.0",
+    "@byokit/link": "0.7.0",
+    "@byokit/relay": "0.5.0",
+    "@byokit/reach": "0.5.0",
     "@byokit/seal": "0.2.0",
     "ws": "8.21.3"
   },