@bivy/bivy 0.18.11-staging.8 → 0.18.11-staging.9

package/bin/bivy.mjs

@@ -2467,16 +2467,20 @@ async function cmdSuggest(args = []) {
 // account machine, and get its answer back. Agent-agnostic — any agent with a
 // shell can call it — and meant for when the user asks for another agent/machine.
 const DELEGATE_USAGE = `Usage: bivy delegate "<task>" [--agent <id>] [--machine <name>] [--model <model>] [--repo owner/repo] [--wait [seconds]] [--json]
+       bivy delegate "<task>" --to <agent>[@<machine>],<agent>[@<machine>],… [--wait [seconds]]
+       bivy delegate machines [--json]
        bivy delegate status <run-id> [--json]
        bivy delegate wait <run-id> [--timeout <seconds>] [--json]
 
 Hands a self-contained task to another agent (and/or another machine on your account) as a
 delegated Run tied to this session ($BIVY_SESSION_ID). With --wait (or 'wait'), prints the
-child's final answer and any branch/PR it produced once it finishes. 'bivy nodes' lists machines.`;
+child's final answer and any branch/PR it produced once it finishes. --to sends the same task
+to several agents/machines at once (up to 3) so the results can be compared.
+'machines' lists your machines and the agents installed on each.`;
 
 async function cmdDelegate(args = []) {
   if (!args.length || args.some((a) => a === "-h" || a === "--help")) { console.log(DELEGATE_USAGE); return; }
-  const flagsWithValue = new Set(["--session", "--agent", "--machine", "--model", "--repo", "--timeout"]);
+  const flagsWithValue = new Set(["--session", "--agent", "--machine", "--model", "--repo", "--timeout", "--to"]);
   const flag = (name) => {
     const i = args.indexOf(name);
     return i >= 0 && i + 1 < args.length ? args[i + 1] : undefined;
@@ -2525,11 +2529,46 @@ async function cmdDelegate(args = []) {
   };
   try {
     const [action, runId] = positional;
+    if (action === "machines" && positional.length === 1) {
+      const res = await fetch(`${url(config)}/api/machines`, { headers: token ? { authorization: `Bearer ${token}` } : {} });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok) throw new Error(data?.error || `HTTP ${res.status}`);
+      if (json) { console.log(JSON.stringify(data.machines, null, 2)); return; }
+      for (const m of data.machines || []) {
+        const agents = m.agents ? m.agents.map((a) => a.id).join(", ") || "none" : m.error ? `unknown (${m.error})` : "unknown while offline";
+        console.log(`${m.name}${m.self ? " (this machine)" : ""} — ${m.online ? "online" : "offline"} — agents: ${agents}`);
+      }
+      return;
+    }
     if (action === "status" && runId) return print(await call(`/${encodeURIComponent(runId)}`));
     if (action === "wait" && runId) return print(await waitFor(runId, Number(flag("--timeout") ?? 600)));
     const instructions = positional.join(" ").trim();
     if (!instructions) { console.error(c.red(DELEGATE_USAGE)); process.exit(1); return; }
-    const started = await call("", { instructions, agent: flag("--agent"), machine: flag("--machine"), model: flag("--model"), repo: flag("--repo") });
+    // Fan-out: the same task to several agent@machine targets, one group, so the
+    // parent's transcript shows them side by side to compare.
+    const to = flag("--to");
+    if (to) {
+      const targets = to.split(",").map((t) => t.trim()).filter(Boolean).map((t) => {
+        const [agent, machine] = t.split("@");
+        return { agent: agent ? governedChatAgentId(agent) : undefined, machine: machine || undefined, label: t };
+      });
+      const group = `fanout-${Date.now().toString(36)}`;
+      const runs = [];
+      for (const target of targets) {
+        runs.push({ target, run: await call("", { instructions, agent: target.agent, machine: target.machine, model: flag("--model"), repo: flag("--repo"), group }) });
+      }
+      if (waitIndex < 0) {
+        if (json) console.log(JSON.stringify(runs.map((r) => r.run), null, 2));
+        else for (const { target, run } of runs) console.log(`${target.label}: run ${run.runId} (${run.status})`);
+        return;
+      }
+      const finished = await Promise.all(runs.map(async ({ target, run }) => ({ target, run: await waitFor(run.runId, Number(waitArg ?? 600)) })));
+      if (json) { console.log(JSON.stringify(finished.map((f) => f.run), null, 2)); return; }
+      for (const { target, run } of finished) { console.log(`\n── ${target.label}`); print(run); }
+      return;
+    }
+    const agent = flag("--agent");
+    const started = await call("", { instructions, agent: agent ? governedChatAgentId(agent) : undefined, machine: flag("--machine"), model: flag("--model"), repo: flag("--repo") });
     if (waitIndex < 0) {
       if (!json) console.log(`Delegated as run ${started.runId} (${started.status}). Follow it with 'bivy delegate wait ${started.runId}'.`);
       else print(started);

package/dist/agent-instructions.js

@@ -44,7 +44,8 @@ export const BIVY_AGENT_NOTE = [
         "write it to stand on its own, with paths relative to the project root.",
     "- Only when the user asks for another agent or another of their machines to take part: " +
         '`bivy delegate "<self-contained task>" --agent <id> [--machine <name>] --wait` runs it there and prints ' +
-        "its answer and any branch/PR (`bivy nodes` lists machines). Use your own sub-agents for everything else.",
+        "its answer and any branch/PR; `--to codex,grok@<machine>` asks several to compare, `bivy delegate machines` " +
+        "lists machines and their agents. Use your own sub-agents for everything else.",
 ].join("\n");
 const PREAMBLE = "The user's global Bivy instructions follow. They apply to every workspace; where they conflict with " +
     "instructions from the current repository (AGENTS.md, CLAUDE.md, …), the repository's instructions win.";

package/dist/apps/styles.css

@@ -354,6 +354,9 @@ input, textarea, select { font-family: inherit; font-size: 16px; }
 @keyframes dot-pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.6; } }
 .session-row { position: relative; display: flex; align-items: center; }
 .session-row .session-item { flex: 1; min-width: 0; }
+/* A delegated child under its parent session (sessionNesting.ts). */
+.session-row.nested { padding-inline-start: var(--space-4); }
+.session-row.nested::before { content: ""; position: absolute; inset-block: var(--space-2); inset-inline-start: var(--space-2); border-inline-start: 1px solid var(--line-strong); }
 .pending-launch-actions { display: flex; flex: none; gap: 4px; padding-right: 6px; }
 .pending-launch-actions button { min-height: var(--space-7); min-width: var(--space-7); border: 1px solid var(--line-strong); border-radius: var(--radius-sm); background: var(--surface-2); color: var(--ink); padding: 5px 8px; font-size: 12px; cursor: pointer; }
 .pending-launch-actions button:last-child { color: var(--muted); background: transparent; }
@@ -3107,6 +3110,26 @@ p.setup-note .btn.link { min-height: 44px; margin-block: calc((1lh - 44px) / 2);
 .suggestion-actions, .suggestion-all { display: flex; flex-wrap: wrap; gap: var(--space-2); margin-top: var(--space-2); }
 .suggestion-all { padding-top: var(--space-2); border-top: 1px solid var(--line); }
 .suggestion-status { margin: var(--space-2) 0 0; display: flex; align-items: center; gap: var(--space-2); color: var(--ok); font-size: var(--text-sm); font-weight: var(--weight-medium); }
+/* Delegation (DelegationCard.tsx): a task handed to another agent/machine.
+   Shell from .card, status from .badge; layout only here. A fan-out renders as
+   one group whose members sit side by side where there is room. */
+.delegation-card { max-inline-size: 440px; display: flex; flex-direction: column; gap: var(--space-1); }
+.delegation-eyebrow { margin: 0; color: var(--muted); font-size: var(--text-xs); font-weight: var(--weight-semibold); }
+.delegation-head { display: flex; align-items: center; justify-content: space-between; gap: var(--space-2); }
+.delegation-head { align-items: flex-start; }
+.delegation-target { display: flex; flex-direction: column; font-weight: var(--weight-semibold); overflow-wrap: anywhere; min-inline-size: 0; }
+.delegation-machine { color: var(--muted); font-size: var(--text-xs); font-weight: var(--weight-normal); }
+.delegation-task { margin: 0; color: var(--muted); font-size: var(--text-sm); overflow-wrap: anywhere; display: -webkit-box; -webkit-line-clamp: 3; -webkit-box-orient: vertical; overflow: hidden; }
+.delegation-failure { margin: 0; color: var(--danger); font-size: var(--text-sm); overflow-wrap: anywhere; }
+.delegation-answer summary { cursor: pointer; color: var(--muted); font-size: var(--text-sm); }
+.delegation-answer p { margin: var(--space-1) 0 0; font-size: var(--text-sm); white-space: pre-wrap; overflow-wrap: anywhere; max-block-size: 18em; overflow-y: auto; }
+.delegation-refs { margin: 0; display: flex; flex-wrap: wrap; align-items: center; gap: var(--space-2); font-size: var(--text-sm); }
+.delegation-refs code { overflow-wrap: anywhere; }
+.delegation-actions { display: flex; flex-wrap: wrap; gap: var(--space-2); }
+.delegation-group { display: flex; flex-direction: column; gap: var(--space-1); margin-block: var(--space-2); }
+.delegation-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); gap: var(--space-2); }
+.delegation-member { display: flex; flex-direction: column; gap: var(--space-1); min-inline-size: 0; }
+.delegation-member > .btn { align-self: flex-start; }
 /* Review card (ReviewCard.tsx): the app at a moment worth judging. The
    screenshot is shown whole, phone-shaped, on a quiet stage; Before/Now is the
    canonical .segmented switch; one primary action. */

package/dist/runtime/tool-call-map.js

@@ -111,7 +111,7 @@ const PATH_KEYS = ["path", "file_path", "filePath", "filename", "fileName", "fil
  */
 function bivyDelegation(command) {
     const match = /^\s*bivy\s+delegate\b(.*)$/s.exec(command);
-    if (!match || /^\s+(status|wait|--help|-h)\b/.test(match[1]))
+    if (!match || /^\s+(status|wait|machines|--help|-h)\b/.test(match[1]))
         return undefined;
     const rest = match[1];
     const flag = (name) => new RegExp(`--${name}(?:=|\\s+)("([^"]*)"|'([^']*)'|(\\S+))`).exec(rest);
@@ -120,7 +120,8 @@ function bivyDelegation(command) {
     const machine = value(flag("machine"));
     const quoted = /(?:^|\s)("([^"]+)"|'([^']+)')/.exec(rest.replace(/--[a-z-]+(?:=|\s+)("[^"]*"|'[^']*'|\S+)/g, ""));
     const description = quoted ? (quoted[2] ?? quoted[3]) : undefined;
-    const label = [agent, machine && `@ ${machine}`].filter(Boolean).join(" ") || undefined;
+    const to = value(flag("to"))?.split(",").map((t) => t.trim().replace("@", " @ ")).filter(Boolean).join(", ");
+    const label = to || [agent, machine && `@ ${machine}`].filter(Boolean).join(" ") || undefined;
     return { ...(label ? { label } : {}), ...(description ? { description } : {}) };
 }
 /**

package/dist/server.js

@@ -161,6 +161,8 @@ import { synthesizeOpenAiSpeech } from "./tts.js";
 import { seal, open } from "./e2e.js";
 import { recoverModelAuthKey } from "./model-auth-key-recovery.js";
 import { RunDelegationService, parseDelegationSource } from "./run-tools.js";
+import { delegationCard } from "./session/delegation-cards.js";
+import { TERMINAL_DELEGATION, isDelegatedFrom } from "./session/delegations.js";
 import { ControlPlaneTaskPoller, resolveControlPlaneTaskConfig, } from "./control-plane-tasks.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const repoRoot = path.resolve(__dirname, "..");
@@ -532,6 +534,13 @@ const runDelegation = new RunDelegationService({
         const targetId = typeof target?.id === "string" ? target.id : machine === identity.name ? identity.nodeId : undefined;
         if (!targetId)
             throw new Error(`Machine not found on this account: ${machine}`);
+        // Fail up front, with what IS there, rather than when the machine claims the Run.
+        if (input.agent) {
+            const agents = targetId === identity.nodeId ? localAgents() : await siblingAgents(targetId).catch(() => undefined);
+            if (agents && !agents.some((agent) => agent.id === input.agent)) {
+                throw new Error(`Agent "${input.agent}" is not installed on ${machine} (it has: ${agents.map((agent) => agent.id).join(", ") || "none"})`);
+            }
+        }
         return delegatedRunRequest("/node/automation-runs", {
             method: "POST",
             body: JSON.stringify({
@@ -562,21 +571,113 @@ const runDelegation = new RunDelegationService({
         const machine = typeof routing.nodeLabel === "string" && routing.nodeLabel ? routing.nodeLabel : identity.name;
         if (machine === identity.name)
             return delegationAnswer(sessionId);
-        const nodes = await delegatedRunRequest("/nodes");
-        const target = Array.isArray(nodes) ? nodes.find((node) => node && typeof node === "object" && node.name === machine) : undefined;
-        if (typeof target?.id !== "string" || !sessionAdvertiseTarget)
+        const target = (await accountMachines()).find((m) => m.name === machine);
+        if (!target)
             return undefined;
-        const client = new SiblingClient({ controlPlaneUrl: sessionAdvertiseTarget.controlPlaneUrl, enrollmentToken: sessionAdvertiseTarget.enrollmentToken, siblingNodeId: target.id, label: "Bivy delegation" });
+        const reply = await siblingRequest(target.id, { kind: "delegation.answer", sessionId });
+        return typeof reply.answer === "string" ? reply.answer : undefined;
+    },
+});
+/** The account's machines (id, name, online), briefly cached. */
+let machinesCache;
+async function accountMachines() {
+    if (machinesCache && Date.now() - machinesCache.at < 20_000)
+        return machinesCache.machines;
+    const nodes = await delegatedRunRequest("/nodes");
+    const machines = (Array.isArray(nodes) ? nodes : []).flatMap((node) => {
+        const n = node && typeof node === "object" ? node : {};
+        return typeof n.id === "string" && typeof n.name === "string" ? [{ id: n.id, name: n.name, online: n.online === true }] : [];
+    });
+    machinesCache = { at: Date.now(), machines };
+    return machines;
+}
+/** One sealed request to a co-owned machine over the relay (node as client). */
+async function siblingRequest(nodeId, command, timeoutMs = 20_000) {
+    if (!sessionAdvertiseTarget)
+        throw new Error("This machine is not signed in to an account.");
+    const client = new SiblingClient({ controlPlaneUrl: sessionAdvertiseTarget.controlPlaneUrl, enrollmentToken: sessionAdvertiseTarget.enrollmentToken, siblingNodeId: nodeId, label: "Bivy delegation" });
+    try {
+        await client.connect();
+        return await client.request(command, timeoutMs);
+    }
+    finally {
+        client.close();
+    }
+}
+/** Agents this machine can run a delegated task with (installed ones). */
+function localAgents() {
+    return runtimeList().filter((rt) => rt.status === "available").map((rt) => ({ id: rt.id, name: String(rt.displayName || rt.id) }));
+}
+async function siblingAgents(nodeId) {
+    const reply = await siblingRequest(nodeId, { kind: "agents.available" }, 10_000);
+    return Array.isArray(reply.agents) ? reply.agents.flatMap((a) => {
+        const agent = a && typeof a === "object" ? a : {};
+        return typeof agent.id === "string" ? [{ id: agent.id, name: typeof agent.name === "string" ? agent.name : agent.id }] : [];
+    }) : [];
+}
+async function machinesWithAgents() {
+    const machines = await accountMachines();
+    return Promise.all(machines.map(async (m) => {
+        const self = m.id === identity.nodeId;
+        if (self)
+            return { ...m, online: true, self, agents: localAgents() };
+        if (!m.online)
+            return { ...m, self };
         try {
-            await client.connect();
-            const reply = await client.request({ kind: "delegation.answer", sessionId }, 20_000);
-            return typeof reply.answer === "string" ? reply.answer : undefined;
+            return { ...m, self, agents: await siblingAgents(m.id) };
         }
-        finally {
-            client.close();
+        catch (error) {
+            return { ...m, self, error: error instanceof Error ? error.message : String(error) };
         }
-    },
-});
+    }));
+}
+/** Fold a delegated Run's latest status into its card in the parent session. */
+function recordDelegation(parentSessionId, run, start) {
+    const record = resolveSession(parentSessionId);
+    if (!record)
+        return run;
+    const prev = eventLog.delegations(record.id).find((card) => card.id === run.runId);
+    const card = delegationCard(prev, run, start);
+    if (prev && JSON.stringify(prev) === JSON.stringify(card))
+        return run;
+    eventLog.appendDelegation(record.id, { afterMessageCount: record.session.getMessages().length, delegation: card });
+    broadcast(stampSessionEvent({ type: "session.event", sessionId: record.id, event: { type: "delegation", delegation: card } }));
+    if (card.childSessionId && !prev?.childSessionId)
+        void linkDelegatedChild(record, card).catch(() => { });
+    return run;
+}
+/** Tell the child session where it came from — locally, or on its machine. */
+async function linkDelegatedChild(parent, card) {
+    const from = { sessionId: parent.id, nodeId: identity.nodeId, machine: identity.name, ...(parent.session.getName() ? { title: parent.session.getName().slice(0, 256) } : {}) };
+    if (!card.nodeId || card.nodeId === identity.nodeId) {
+        applyDelegationLink(card.childSessionId, from);
+        return;
+    }
+    await siblingRequest(card.nodeId, { kind: "delegation.link", childSessionId: card.childSessionId, parent: from }, 10_000);
+}
+function applyDelegationLink(childSessionId, from) {
+    const record = resolveSession(childSessionId);
+    if (!record && !metadata.getSession(childSessionId))
+        return false;
+    if (record)
+        record.delegatedFrom = from;
+    metadata.upsertSession({ id: childSessionId, delegatedFrom: from });
+    if (record)
+        broadcast({ type: "session.updated", sessionId: record.id, sessionFile: record.sessionFile, bivySession: bivySessionEnvelope(record) });
+    scheduleAdvertise();
+    return true;
+}
+// Children rarely finish while someone is polling them: keep the parent's open
+// cards current in the background (cheap: cached, and only non-terminal ones).
+setInterval(() => {
+    for (const record of new Set(openSessions.values())) {
+        for (const card of eventLog.delegations(record.id)) {
+            if (TERMINAL_DELEGATION.has(card.status))
+                continue;
+            void runDelegation.getRunStatus(record.id, card.id).then((run) => recordDelegation(record.id, run)).catch(() => { });
+        }
+    }
+}, 15_000).unref();
 // Delegated Runs remain available through the explicit Session API, but are not
 // exposed as agent tools. Coding agents should use their own native sub-agent
 // facilities; advertising Runs here caused routine work to create noisy,
@@ -2434,6 +2535,16 @@ const RELAY_COMMANDS = {
     },
     // A co-owned node asking for a delegated child's answer over the sealed
     // node-to-node channel (see runDelegation.answer). Replies to the requester.
+    // Discovery: which agents this machine can run (docs/agent-delegation.md).
+    "agents.available"(msg, ctx) {
+        ctx.reply({ type: "agents.available", requestId: msg.requestId, machine: identity.name, agents: localAgents() });
+    },
+    // The parent of a delegated child session on this machine introduces itself,
+    // so the child can show and link where it came from.
+    "delegation.link"(msg, ctx) {
+        const linked = typeof msg.childSessionId === "string" && isDelegatedFrom(msg.parent) ? applyDelegationLink(msg.childSessionId, msg.parent) : false;
+        ctx.reply({ type: "delegation.link", requestId: msg.requestId, linked });
+    },
     async "delegation.answer"(msg, ctx) {
         const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
         const answer = sessionId ? await delegationAnswer(sessionId).catch(() => undefined) : undefined;
@@ -6384,6 +6495,7 @@ async function sessionListRows() {
             source: rec?.source ?? meta?.source,
             bivyCreated: Boolean(meta),
             forkedFrom: rec?.forkedFrom ?? meta?.forkedFrom,
+            delegatedFrom: rec?.delegatedFrom ?? meta?.delegatedFrom,
             branch: rec?.worktree?.branch ?? meta?.branch,
             sandbox: rec?.sandbox ?? normalizeSandboxTier(meta?.sandbox),
             approvalMode: rec?.approvalMode,
@@ -6669,6 +6781,7 @@ function persistSessionMetadata(record, status = sessionStatus(record)) {
         workspace: record.workspace,
         source: record.source ?? "manual",
         forkedFrom: record.forkedFrom,
+        delegatedFrom: record.delegatedFrom,
         automationRunId: record.automationRunId,
         delegationDepth: record.delegationDepth,
         runtimeId: record.runtimeId,
@@ -8493,7 +8606,7 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
     // Rehydrating (rather than leaving this undefined for a resumed session)
     // also avoids a persistSessionMetadata call later silently clobbering the
     // stored contract with undefined via its `{...prev, ...input}` merge.
-    const record = { id: sessionId, session, runtimeId: rt.id, credentialLabels, sandbox: sessionSandbox, approvalMode: sessionSafety.approval, automationRunId: storedMeta?.automationRunId, delegationDepth: storedMeta?.delegationDepth, workspace: sessionWorkspace, sessionFile: session.sessionFile, agentServiceAddress: attachedAddress ?? rt.agentServiceAddress, worktree, source, prUrl: storedMeta?.prUrl, prs: storedMeta?.prs, contract: storedMeta?.contract, lastTouchedAt: resumedLastActive ?? Date.now(), warning: modelFallbackMessage, ephemeral: opts.ephemeral, workspaceState: runGit(["status", "--porcelain", "--untracked-files=normal"], sessionWorkspace) ? "dirty" : "clean" };
+    const record = { id: sessionId, session, runtimeId: rt.id, credentialLabels, sandbox: sessionSandbox, approvalMode: sessionSafety.approval, automationRunId: storedMeta?.automationRunId, delegationDepth: storedMeta?.delegationDepth, workspace: sessionWorkspace, sessionFile: session.sessionFile, agentServiceAddress: attachedAddress ?? rt.agentServiceAddress, worktree, source, prUrl: storedMeta?.prUrl, prs: storedMeta?.prs, delegatedFrom: storedMeta?.delegatedFrom, contract: storedMeta?.contract, lastTouchedAt: resumedLastActive ?? Date.now(), warning: modelFallbackMessage, ephemeral: opts.ephemeral, workspaceState: runGit(["status", "--porcelain", "--untracked-files=normal"], sessionWorkspace) ? "dirty" : "clean" };
     // Migration: a session resumed/reopened from before this feature (or from a
     // node that predates it) has no stored contract. Stamp an honest one now
     // from currently-observed facts rather than leaving it blank forever or
@@ -10423,6 +10536,7 @@ app.get("/api/sessions", async (_req, res, next) => {
                 source: rec?.source ?? meta?.source,
                 bivyCreated: Boolean(meta),
                 forkedFrom: rec?.forkedFrom ?? meta?.forkedFrom,
+                delegatedFrom: rec?.delegatedFrom ?? meta?.delegatedFrom,
                 branch: rec?.worktree?.branch ?? meta?.branch,
                 prUrl: rec?.prUrl ?? meta?.prUrl,
                 prs: rec?.prs ?? meta?.prs,
@@ -11339,7 +11453,12 @@ app.post("/api/session/:id/suggest", (req, res) => {
 // authorizes every status lookup against this parent Session's provenance.
 app.post("/api/session/:id/delegated-runs", async (req, res) => {
     try {
-        res.status(201).json(await runDelegation.startRun(String(req.params.id), req.body));
+        const input = req.body;
+        const result = await runDelegation.startRun(String(req.params.id), input);
+        const machine = input.machine?.trim() || identity.name;
+        const nodeId = (await accountMachines().catch(() => [])).find((m) => m.name === machine)?.id ?? (machine === identity.name ? identity.nodeId : undefined);
+        recordDelegation(String(req.params.id), result, { instructions: input.instructions, agent: input.agent, machine, nodeId, group: typeof input.group === "string" ? input.group.slice(0, 64) : undefined });
+        res.status(201).json(result);
     }
     catch (error) {
         res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
@@ -11347,7 +11466,7 @@ app.post("/api/session/:id/delegated-runs", async (req, res) => {
 });
 app.get("/api/session/:id/delegated-runs/:runId", async (req, res) => {
     try {
-        res.json(await runDelegation.getRunStatus(String(req.params.id), String(req.params.runId)));
+        res.json(recordDelegation(String(req.params.id), await runDelegation.getRunStatus(String(req.params.id), String(req.params.runId))));
     }
     catch (error) {
         res.status(404).json({ error: error instanceof Error ? error.message : String(error) });
@@ -11355,7 +11474,18 @@ app.get("/api/session/:id/delegated-runs/:runId", async (req, res) => {
 });
 app.post("/api/session/:id/delegated-runs/:runId/wait", async (req, res) => {
     try {
-        res.json(await runDelegation.waitForRun(String(req.params.id), String(req.params.runId), Number(req.body?.timeoutSeconds), AbortSignal.timeout(305_000)));
+        res.json(recordDelegation(String(req.params.id), await runDelegation.waitForRun(String(req.params.id), String(req.params.runId), Number(req.body?.timeoutSeconds), AbortSignal.timeout(305_000))));
+    }
+    catch (error) {
+        res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
+    }
+});
+// The account's machines and the agents installed on each (asked of every
+// online machine over the sealed node-to-node channel), for `bivy delegate
+// machines` and for picking a valid agent @ machine up front.
+app.get("/api/machines", async (_req, res) => {
+    try {
+        res.json({ machines: await machinesWithAgents() });
     }
     catch (error) {
         res.status(400).json({ error: error instanceof Error ? error.message : String(error) });

package/dist/session/delegation-cards.js

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// Pure: fold a delegated Run's latest status into its card in the parent
+// session (docs/agent-delegation.md). The server logs and broadcasts the result.
+import { MAX_DELEGATION_ANSWER, MAX_DELEGATION_TASK } from "./delegations.js";
+const bound = (value, max) => value && value.length > max ? `${value.slice(0, max - 1)}…` : value;
+export function delegationCard(prev, run, start) {
+    const refs = run.references ?? {};
+    const task = start ? bound(start.instructions.trim().split(/\r?\n/, 1)[0] ?? "", MAX_DELEGATION_TASK) : prev?.task ?? "";
+    const pick = (key, next) => (next ?? prev?.[key]);
+    const card = { id: run.runId, status: run.status, task };
+    const fields = {
+        agent: pick("agent", start?.agent),
+        machine: pick("machine", start?.machine),
+        nodeId: pick("nodeId", start?.nodeId),
+        group: pick("group", start?.group),
+        childSessionId: pick("childSessionId", refs.sessionId),
+        answer: pick("answer", bound(run.answer, MAX_DELEGATION_ANSWER)),
+        branch: pick("branch", refs.branch),
+        prUrl: pick("prUrl", refs.prUrl),
+        failure: pick("failure", refs.failure),
+    };
+    for (const [key, value] of Object.entries(fields))
+        if (value)
+            card[key] = value;
+    return card;
+}

package/dist/session/delegations.js

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+export const DELEGATION_BLOCK = "bivy_delegation";
+export const MAX_DELEGATION_TASK = 200;
+export const MAX_DELEGATION_ANSWER = 8000;
+export const TERMINAL_DELEGATION = new Set(["succeeded", "failed", "cancelled"]);
+const optionalString = (v) => v === undefined || typeof v === "string";
+export function isDelegationCard(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const d = value;
+    return typeof d.id === "string" && d.id.length > 0 && typeof d.status === "string" && typeof d.task === "string"
+        && [d.agent, d.machine, d.nodeId, d.group, d.childSessionId, d.answer, d.branch, d.prUrl, d.failure].every(optionalString);
+}
+export function isDelegatedFrom(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const d = value;
+    return typeof d.sessionId === "string" && d.sessionId.length > 0 && d.sessionId.length <= 256
+        && [d.nodeId, d.machine, d.title].every((v) => v === undefined || (typeof v === "string" && v.length <= 256));
+}

package/dist/session/event-log.js

@@ -29,6 +29,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { normalizedIntermediateText, thinkingTextFromContent, mergeTranscript } from "./transcript-merge.js";
+import { DELEGATION_BLOCK, isDelegationCard } from "./delegations.js";
 import { APP_PUBLICATION_BLOCK, APP_REVIEW_BLOCK, isAppReference, isAppReview } from "../apps/types.js";
 import { SUGGESTION_BLOCK, isTaskSuggestion } from "./suggestions.js";
 /**
@@ -254,6 +255,12 @@ function isSuggestionEntry(value) {
     const entry = value;
     return entry.bivyKind === "suggestion" && typeof entry.id === "string" && typeof entry.createdAt === "number" && typeof entry.afterMessageCount === "number" && isTaskSuggestion(entry.suggestion);
 }
+function isDelegationEntry(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const entry = value;
+    return entry.bivyKind === "delegation" && typeof entry.id === "string" && typeof entry.createdAt === "number" && typeof entry.afterMessageCount === "number" && isDelegationCard(entry.delegation);
+}
 function isAppReviewEntry(value) {
     if (!value || typeof value !== "object")
         return false;
@@ -261,7 +268,7 @@ function isAppReviewEntry(value) {
     return entry.bivyKind === "app-review" && typeof entry.id === "string" && typeof entry.createdAt === "number" && typeof entry.afterMessageCount === "number" && isAppReview(entry.review);
 }
 function isRecord(value) {
-    return isOverlay(value) || isBase(value) || isForkDisplay(value) || isAttachment(value) || isOutboundAttachment(value) || isInlineImage(value) || isAppPublication(value) || isAppReviewEntry(value) || isSuggestionEntry(value);
+    return isDelegationEntry(value) || isOverlay(value) || isBase(value) || isForkDisplay(value) || isAttachment(value) || isOutboundAttachment(value) || isInlineImage(value) || isAppPublication(value) || isAppReviewEntry(value) || isSuggestionEntry(value);
 }
 /**
  * Fold attachment records into a text→refs list: last write wins per text (a
@@ -383,11 +390,23 @@ export function replayExtras(entries) {
         role: "assistant", content: [{ type: APP_REVIEW_BLOCK, review: entry.review }],
         id: entry.id, afterMessageCount: entry.afterMessageCount, createdAt: entry.createdAt,
     }));
+    // A delegation card keeps the place it was created and shows its latest state.
+    const delegations = new Map();
+    for (const entry of entries) {
+        if (entry.bivyKind !== "delegation")
+            continue;
+        const first = delegations.get(entry.id);
+        delegations.set(entry.id, first ? { ...first, delegation: entry.delegation } : entry);
+    }
+    const delegationCards = [...delegations.values()].map((entry) => ({
+        role: "assistant", content: [{ type: DELEGATION_BLOCK, delegation: entry.delegation }],
+        id: `delegation-${entry.id}`, afterMessageCount: entry.afterMessageCount, createdAt: entry.createdAt,
+    }));
     const suggestions = entries.filter((entry) => entry.bivyKind === "suggestion").map((entry) => ({
         role: "assistant", content: [{ type: SUGGESTION_BLOCK, suggestion: entry.suggestion }],
         id: entry.id, afterMessageCount: entry.afterMessageCount, createdAt: entry.createdAt,
     }));
-    return [...foldIntermediate(intermediate), ...foldTool(tool), ...replayOutboundAttachments(entries), ...publications, ...cards, ...suggestions];
+    return [...foldIntermediate(intermediate), ...foldTool(tool), ...replayOutboundAttachments(entries), ...publications, ...cards, ...delegationCards, ...suggestions];
 }
 /**
  * Fold the outbound (agent-sent) attachment records into time-anchored synthetic
@@ -683,6 +702,19 @@ export class EventLog {
         this.enqueue(id, `app:${entry.id}`, { ...entry, app: { ...entry.app }, bivyKind: "app-publication", createdAt: Date.now() });
     }
     /** `createdAt`/`afterMessageCount` place the card; an expired card keeps its original place. */
+    /** Record a delegation card's latest state; replay keeps its first position. */
+    appendDelegation(id, entry) {
+        this.load(id);
+        this.enqueue(id, this.syntheticKey(id), { bivyKind: "delegation", createdAt: Date.now(), afterMessageCount: entry.afterMessageCount, id: entry.delegation.id, delegation: structuredClone(entry.delegation) });
+    }
+    /** The delegation cards this session holds, latest state each. */
+    delegations(id) {
+        const byId = new Map();
+        for (const entry of this.entries(id))
+            if (entry.bivyKind === "delegation")
+                byId.set(entry.id, entry.delegation);
+        return [...byId.values()];
+    }
     appendAppReview(id, entry) {
         this.load(id);
         this.enqueue(id, `review:${entry.review.id}`, { bivyKind: "app-review", createdAt: entry.createdAt ?? Date.now(), afterMessageCount: entry.afterMessageCount, id: entry.review.id, review: structuredClone(entry.review) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.18.11-staging.8",
+  "version": "0.18.11-staging.9",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",