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

package/bin/acp-shim.mjs

@@ -136,6 +136,11 @@ let initialized = false;
 let modelConfigId = "model";
 // A model chosen before the ACP session existed, applied once it does.
 let pendingModel = null;
+// True while session/load replays history (see session.resume).
+let replayingHistory = false;
+// The config-option id carrying reasoning effort (ACP category "thought_level"),
+// when the agent advertises one.
+let thoughtConfigId = null;
 // toolCallId -> { requestId, options } so a later bivy tool.decision answers the
 // right ACP permission request with a concrete optionId.
 const permissionRequests = new Map();
@@ -369,19 +374,25 @@ function publishModels(result) {
     // ACP model ids are `provider/model`; split the provider so Bivy can group and
     // scope provider-specific settings the same way it does for other runtimes.
     .map((m) => ({ ...m, provider: m.id.includes("/") ? m.id.split("/")[0] : "agent" }));
-  if (!models.length) return;
-  modelConfigId = String(modelOption?.id ?? "model");
+  // Reasoning effort rides the same config-option surface under ACP's
+  // `thought_level` category (Grok: reasoning_effort xhigh/high/medium/low).
+  const thoughtOption = options.find((o) => String(o?.category ?? "") === "thought_level");
+  const levels = (Array.isArray(thoughtOption?.options) ? thoughtOption.options : []).map((o) => String(o?.value ?? "")).filter(Boolean);
+  if (!models.length && !levels.length) return;
+  if (models.length) modelConfigId = String(modelOption?.id ?? "model");
+  if (levels.length) thoughtConfigId = String(thoughtOption.id);
   bivy({
     type: "runtime.models",
     models,
     ...(modelOption?.currentValue ? { currentModel: String(modelOption.currentValue) } : {}),
+    ...(levels.length ? { thinking: { levels, ...(thoughtOption?.currentValue ? { current: String(thoughtOption.currentValue) } : {}) } } : {}),
   });
 }
 
 // --- ACP → bivy: streamed session/update notifications ----------------------
 function onSessionUpdate(params) {
   const u = params?.update;
-  if (!u || typeof u !== "object") return;
+  if (!u || typeof u !== "object" || replayingHistory) return;
   // Any update arriving while the turn is draining means the agent is still
   // emitting the tail of this turn (see the drain note above) — reset the quiet
   // window so session.done waits for it instead of sealing history short.
@@ -600,7 +611,14 @@ async function onBivyCommand(msg) {
           // hanging the reopen with no watchdog to recover it (resume isn't a
           // "working" turn). On timeout/failure we fall back to a fresh session so
           // the chat still opens instead of spinning on "Fetching transcript…".
-          const res = await agentRequest("session/load", { sessionId: ref, cwd, mcpServers }, { timeoutMs: 30_000 });
+          // ACP agents replay the whole conversation as session/update during
+          // session/load. Bivy already has that history; forwarding the replay
+          // re-recorded past thinking (and could fold old text onto the last
+          // reply) as if it were live.
+          replayingHistory = true;
+          let res;
+          try { res = await agentRequest("session/load", { sessionId: ref, cwd, mcpServers }, { timeoutMs: 30_000 }); }
+          finally { replayingHistory = false; }
           sessionId = res?.sessionId ?? ref;
           publishModels(res);
         } catch (error) {
@@ -683,6 +701,15 @@ async function onBivyCommand(msg) {
         bivy({ replyTo: id, ok: true });
         return;
       }
+      case "thinking.set": {
+        const level = String(msg.level ?? "").trim();
+        if (sessionId && thoughtConfigId && level) {
+          try { await agentRequest("session/set_config_option", { sessionId, configId: thoughtConfigId, value: level }, { timeoutMs: 15_000 }); }
+          catch (e) { bivy({ type: "runtime.debug", message: `acp set thought level failed: ${e instanceof Error ? e.message : String(e)}` }); }
+        }
+        if (id !== undefined) bivy({ replyTo: id, ok: true });
+        return;
+      }
       case "session.abort": {
         // A pending drain must not fire session.done after the user cancelled —
         // the turn is being torn down, not finishing on its own.

package/bin/bivy.mjs

@@ -1827,7 +1827,7 @@ function cmdCompletions(args = []) {
   const shell = (args[0] || "").toLowerCase();
   const commands = [
     "run", "runs", "sessions", "ls", "resume", "promote", "rename", "nodes", "agent", "agents", "agents:install", "shim", "takeover", "token", "exec",
-    "send", "attach", "suggest", "kill", "setup", "start", "stop", "restart", "status", "doctor", "diagnostics", "capabilities", "logs", "login", "logout", "signout", "provider", "model",
+    "send", "attach", "suggest", "delegate", "kill", "setup", "start", "stop", "restart", "status", "doctor", "diagnostics", "capabilities", "logs", "login", "logout", "signout", "provider", "model",
     "update", "update:log", "audit", "automation", "config", "plugin", "open", "service", "secrets", "voice", "link", "relay:setup",
     "github:connect", "github:app-create", "github:app-connect", "github:app-sync", "prune", "uninstall", "help", "version",
   ];
@@ -2462,6 +2462,125 @@ async function cmdSuggest(args = []) {
   console.log(c.green("Suggested in the chat. The user can start it in one tap."));
 }
 
+// Cross-agent / cross-machine delegation (docs/agent-delegation.md): hand a
+// self-contained task from this session to another agent, optionally on another
+// 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. --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", "--to"]);
+  const flag = (name) => {
+    const i = args.indexOf(name);
+    return i >= 0 && i + 1 < args.length ? args[i + 1] : undefined;
+  };
+  const json = args.includes("--json");
+  const waitIndex = args.indexOf("--wait");
+  const waitArg = waitIndex >= 0 && /^\d+$/.test(args[waitIndex + 1] ?? "") ? args[waitIndex + 1] : undefined;
+  const positional = args.filter((a, i) => !a.startsWith("--") && !(i > 0 && flagsWithValue.has(args[i - 1])) && !(waitArg && i === waitIndex + 1));
+  const sessionId = resolveAttachSessionId({ sessionFlag: flag("--session"), env: process.env });
+  if (!sessionId) { console.error(c.red("No session id. Run inside an agent session ($BIVY_SESSION_ID) or pass --session <id>.")); process.exit(1); return; }
+  const config = loadConfig();
+  if (!(await ensureNodeRunning(config))) { console.error(c.red(`Could not reach the Bivy node at ${url(config)}.`)); process.exit(1); return; }
+  let token;
+  try { token = await localDeviceToken(config); } catch { token = undefined; }
+  const base = `${url(config)}/api/session/${encodeURIComponent(sessionId)}/delegated-runs`;
+  const call = async (path, body) => {
+    const res = await fetch(`${base}${path}`, {
+      method: body ? "POST" : "GET",
+      headers: { "content-type": "application/json", ...(token ? { authorization: `Bearer ${token}` } : {}) },
+      ...(body ? { body: JSON.stringify(body) } : {}),
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) throw new Error(data?.error || `HTTP ${res.status}`);
+    return data;
+  };
+  const terminal = (run) => ["succeeded", "failed", "cancelled"].includes(run?.status);
+  // The node caps one wait at 300s; loop until the child ends or our budget does.
+  const waitFor = async (runId, seconds) => {
+    const deadline = Date.now() + seconds * 1000;
+    let run = await call(`/${encodeURIComponent(runId)}`);
+    while (!terminal(run) && Date.now() < deadline) {
+      const slice = Math.max(1, Math.min(300, Math.ceil((deadline - Date.now()) / 1000)));
+      run = await call(`/${encodeURIComponent(runId)}/wait`, { timeoutSeconds: slice });
+    }
+    return run;
+  };
+  const print = (run) => {
+    if (json) { console.log(JSON.stringify(run, null, 2)); return; }
+    console.log(`Run ${run.runId}: ${run.status}${terminal(run) ? "" : " (still running — 'bivy delegate wait " + run.runId + "')"}`);
+    const refs = run.references || {};
+    if (refs.failure) console.log(`Failure: ${refs.failure}`);
+    if (refs.branch) console.log(`Branch: ${refs.branch}`);
+    if (refs.prUrl) console.log(`PR: ${refs.prUrl}`);
+    if (refs.sessionId) console.log(`Child session: ${refs.sessionId}`);
+    if (run.answer) console.log(`\nAnswer:\n${run.answer}`);
+  };
+  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; }
+    // 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);
+      return;
+    }
+    print(await waitFor(started.runId, Number(waitArg ?? 600)));
+  } catch (error) {
+    console.error(c.red(`Delegate failed: ${error?.message || String(error)}`));
+    process.exit(1);
+  }
+}
+
 // Universal app publishing: every agent that can write JSON and run a command
 // uses the same contract. Relative static directories are manifest-relative.
 async function cmdApp(args = []) {
@@ -5468,6 +5587,9 @@ An agent's own --help passes through, e.g. 'bivy run claude --help'.`);
     case "suggest":
       await cmdSuggest(args);
       break;
+    case "delegate":
+      await cmdDelegate(args);
+      break;
     case "completions":
     case "completion":
       cmdCompletions(args);

package/dist/agent-instructions.js

@@ -42,6 +42,10 @@ export const BIVY_AGENT_NOTE = [
         '`bivy suggest "<complete instruction>" [--title "short label"]` instead of only listing them. The user can ' +
         "start each in one tap, in this session or in a parallel one that works in its own copy of the project, so " +
         "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; `--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/agents/claude-code/runtime.js

@@ -1294,6 +1294,17 @@ class ClaudeSession {
                 // falls through so its capabilities/commands reach the client.)
                 if (message?.subtype === "task_notification" || message?.subtype === "compact_boundary")
                     break;
+                // Banners Claude Code shows the user: a hook's block reason, slash-command
+                // output, warnings (SDK 0.3.283+). Show them as the chat's system notice
+                // and keep them in the transcript; "info" is transcript-mode-only upstream.
+                if (message?.subtype === "informational") {
+                    const text = typeof message.content === "string" ? message.content.trim() : "";
+                    if (text && message.level !== "info") {
+                        this.messages.push({ role: "system", content: text, timestamp: Date.now() });
+                        this.emit({ type: "session.notice", level: message.level === "warning" ? "warning" : "info", message: text });
+                    }
+                    break;
+                }
                 this.emit({ type: String(message?.type ?? "unknown"), raw: message });
                 break;
             }

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; }
@@ -1193,7 +1196,9 @@ button.sheet-action:last-child { border-bottom: 0; }
   margin: 0;
   max-height: calc(var(--app-h, 100dvh) - (2 * var(--space-5)));
 }
-.sheet-head { display: flex; align-items: center; gap: 10px; padding: 12px 16px; border-bottom: 1px solid var(--line); flex: none; touch-action: none; }
+/* Lifted above the sheet body so a menu opened from the header (the model
+   picker's reasoning menu) layers over the body's sticky search field. */
+.sheet-head { display: flex; align-items: center; gap: 10px; padding: 12px 16px; border-bottom: 1px solid var(--line); flex: none; touch-action: none; position: relative; z-index: calc(var(--z-sticky) + 1); }
 .sheet-title { font-weight: 700; flex: 1; }
 .sheet-close { border: 0; background: transparent; color: var(--muted); font-size: 22px; line-height: 1; min-width: var(--space-7); min-height: var(--space-7); }
 .sheet-close:active { transform: scale(0.9); }
@@ -3105,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/run-tools.js

@@ -8,6 +8,8 @@ export const RUN_TOOL_LIMITS = {
     maxWaitSeconds: 300,
     minPollMs: 1_000,
     maxIdempotencyKey: 128,
+    /** The child's final answer returned to the parent (characters). */
+    maxAnswer: 8_000,
 };
 const TERMINAL = new Set(["succeeded", "failed", "cancelled"]);
 const STATUSES = new Set(["pending", "claimed", "running", "waiting", "needs_attention", "succeeded", "failed", "cancelled"]);
@@ -107,6 +109,12 @@ export class RunDelegationService {
         if (!raw || provenance?.parentSessionId !== sessionId)
             throw new Error("delegated Run not found");
         const value = safeRun(raw, provenance);
+        if (TERMINAL.has(value.status) && this.backend.answer) {
+            // Best-effort: an unreachable machine still leaves status + references.
+            const answer = cached?.value.answer ?? await this.backend.answer(raw).catch(() => undefined);
+            if (answer)
+                value.answer = answer.length > RUN_TOOL_LIMITS.maxAnswer ? `${answer.slice(0, RUN_TOOL_LIMITS.maxAnswer - 1)}…` : answer;
+        }
         this.cache.set(`${sessionId}:${runId}`, { at: this.now(), value });
         return value;
     }

package/dist/runtime/protocol.js

@@ -274,6 +274,32 @@ class ProtocolSession {
      *  applied to the spawned child and reused by the per-turn preflight. */
     prepareEnv = {};
     getModels() { return this.models; }
+    // Reasoning-effort levels published by the shim (see runtime.models); empty
+    // when the agent has none, which keeps the picker hidden.
+    thinkingLevels = [];
+    thinkingLevel;
+    thinkingChosen = false;
+    supportsThinking() { return this.thinkingLevels.length > 0; }
+    getAvailableThinkingLevels() { return this.thinkingLevels; }
+    getThinkingLevel() { return this.thinkingLevel; }
+    setThinkingLevel(level) {
+        const next = level.trim();
+        if (!this.thinkingLevels.includes(next))
+            return;
+        this.thinkingLevel = next;
+        this.thinkingChosen = true;
+        this.sendThinkingLevel(next);
+    }
+    /** Fire-and-forget like the pipe runtimes' flag. With no live agent yet the
+     *  choice is kept and sent once the agent publishes its levels. */
+    sendThinkingLevel(level) {
+        try {
+            void this.command("thinking.set", { sessionId: this.id, level }).catch(() => { });
+        }
+        catch {
+            // Agent not running; runtime.models re-applies the kept choice.
+        }
+    }
     getCurrentModel() {
         if (!this.currentModelId)
             return undefined;
@@ -622,6 +648,23 @@ class ProtocolSession {
                 if (typeof msg.currentModel === "string")
                     this.currentModelId = msg.currentModel;
             }
+            // Reasoning-effort levels the agent advertises (an ACP `thought_level`
+            // config option), driven by the same picker as the pipe runtimes' flags.
+            const thinking = msg.thinking;
+            const levels = Array.isArray(thinking?.levels) ? thinking.levels.filter((l) => typeof l === "string" && Boolean(l)) : [];
+            if (levels.length) {
+                this.thinkingLevels = levels;
+                // A level picked before the agent was up is applied now; otherwise adopt
+                // the agent's own current level.
+                if (this.thinkingChosen && this.thinkingLevel && levels.includes(this.thinkingLevel))
+                    this.sendThinkingLevel(this.thinkingLevel);
+                else if (typeof thinking?.current === "string")
+                    this.thinkingLevel = thinking.current;
+            }
+            // The catalog arrived after the client asked for it (it lands with the
+            // agent's session): let the node push the fresh model/effort picker.
+            if (models.length || levels.length)
+                this.emit({ type: "runtime.models" });
             return;
         }
         if (type === "message.delta") {

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

@@ -103,6 +103,27 @@ const DELEGATE = new Set([
     "subagentactivity",
 ]);
 const PATH_KEYS = ["path", "file_path", "filePath", "filename", "fileName", "file", "target_file", "targetFile"];
+/**
+ * `bivy delegate "<task>" --agent codex --machine mac` run from any agent's
+ * shell hands work to another agent/machine (docs/agent-delegation.md). Show it
+ * as the delegation it is — "Delegated · codex @ mac" — not as a shell command.
+ * `status` / `wait` follow-ups stay ordinary commands.
+ */
+function bivyDelegation(command) {
+    const match = /^\s*bivy\s+delegate\b(.*)$/s.exec(command);
+    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);
+    const value = (m) => m ? (m[2] ?? m[3] ?? m[4]) : undefined;
+    const agent = value(flag("agent"));
+    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 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 } : {}) };
+}
 /**
  * Classify one tool call into a normalized ToolCallDetail, or undefined when it
  * doesn't map to a known kind (the caller then leaves the tool block opaque).
@@ -114,6 +135,9 @@ export function mapToolCall(toolName, input, context = {}) {
     const o = asRecord(input);
     if (inToolSet(SHELL, toolName, key)) {
         const command = str(o, "command", "cmd", "script", "input", "args");
+        const delegated = command ? bivyDelegation(command) : undefined;
+        if (delegated)
+            return decorate({ kind: "delegation", ...delegated }, toolName, input, context);
         return command ? decorate({ kind: "shell", command, ...(str(o, "cwd", "workdir", "workingDir", "directory") ? { cwd: str(o, "cwd", "workdir", "workingDir", "directory") } : {}) }, toolName, input, context) : undefined;
     }
     if (inToolSet(EDIT, toolName, key)) {

package/dist/server.js

@@ -144,6 +144,7 @@ import { attachmentsFrom, materializeAttachments, sanitizeAttachmentFilename } f
 import { AttachmentStore, isValidAttachmentHash } from "./session/attachment-store.js";
 import { planAttachment, isAttachPlanError, MAX_AGENT_ATTACHMENT_BYTES } from "./session/attach-to-chat.js";
 import { ReplicationService } from "./session/replication-service.js";
+import { SiblingClient } from "./session/sibling-client.js";
 import { createSessionNewDedupe } from "./session/session-new-dedupe.js";
 import { computeSessionContract } from "./session/session-contract.js";
 import { SecretVault, resolveSecret } from "./secrets.js";
@@ -160,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, "..");
@@ -531,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({
@@ -550,7 +560,124 @@ const runDelegation = new RunDelegationService({
             }),
         });
     },
+    // The child's reply is read from the machine that ran it — locally, or over
+    // the sealed node-to-node relay channel. It never travels through the Run queue.
+    answer: async (raw) => {
+        const output = raw.output && typeof raw.output === "object" ? raw.output : {};
+        const sessionId = typeof output.sessionId === "string" ? output.sessionId : "";
+        if (!sessionId)
+            return undefined;
+        const routing = raw.routing && typeof raw.routing === "object" ? raw.routing : {};
+        const machine = typeof routing.nodeLabel === "string" && routing.nodeLabel ? routing.nodeLabel : identity.name;
+        if (machine === identity.name)
+            return delegationAnswer(sessionId);
+        const target = (await accountMachines()).find((m) => m.name === machine);
+        if (!target)
+            return undefined;
+        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 {
+            return { ...m, self, agents: await siblingAgents(m.id) };
+        }
+        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,
@@ -2406,6 +2533,23 @@ const RELAY_COMMANDS = {
         if (record)
             replayPendingInteractions(record.id);
     },
+    // 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;
+        ctx.reply({ type: "delegation.answer", requestId: msg.requestId, sessionId, ...(answer ? { answer } : {}) });
+    },
     async "sessions.list"() {
         // Relay clients request the list on every connect/reconnect. Replay even an
         // empty update state so a banner from the previous daemon is cleared.
@@ -5162,6 +5306,30 @@ async function waitForSessionIdle(record, capMs = 2 * 60 * 60 * 1000) {
         await new Promise((resolve) => setTimeout(resolve, 2_000));
     }
 }
+/**
+ * A delegated child's result for its parent (docs/agent-delegation.md): the
+ * session's final assistant reply, from the node's own transcript. Opened from
+ * disk when the session isn't live. Undefined for an unknown session.
+ */
+async function delegationAnswer(sessionId) {
+    let record = resolveSession(sessionId);
+    if (!record) {
+        const summary = (await listAllSessions()).find((s) => s.id === sessionId);
+        if (!summary?.path)
+            return undefined;
+        record = await createSession(defaultWorkspace, summary.path, { runtimeId: summary.agent, makeActive: false });
+    }
+    const messages = transcripts.forkMessages(record);
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const message = messages[i];
+        if (message?.role !== "assistant")
+            continue;
+        const text = runtimeContentText(message.content).trim();
+        if (text)
+            return text;
+    }
+    return undefined;
+}
 /** Text of the most recent user message in a session's transcript, if any. */
 function lastUserMessageText(record) {
     const messages = record.session.getMessages();
@@ -6327,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,
@@ -6612,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,
@@ -7789,6 +7959,11 @@ function attachSessionListeners(record) {
             // sheet for the right provider alongside the inline error bubble.
             maybeSignalAuthRequired(record, String(event.error ?? ""));
         }
+        if (event.type === "runtime.models") {
+            // A protocol agent published its model/effort catalog late (with its
+            // session). Push it so an open picker fills in without a refresh.
+            void modelsListEventFor(record).then((listed) => broadcast(listed)).catch(() => { });
+        }
         if (event.type === "runtime.commands") {
             // The agent learned its own slash commands mid-session (e.g. Claude Code's
             // system/init reports slash_commands only after the first turn starts).
@@ -8431,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
@@ -10361,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,
@@ -11277,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) });
@@ -11285,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) });
@@ -11293,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.7",
+  "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.",