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

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,86 @@ 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 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.`;
+
+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 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 === "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") });
+    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 +5548,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,9 @@ 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 (`bivy nodes` lists machines). 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

@@ -1193,7 +1193,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); }

package/dist/controllers/fork-commands.js

@@ -72,7 +72,7 @@ export function createForkCommands(deps) {
                 // When the client has already picked a target agent, pass it so the
                 // bundle omits the native payload for a cross-runtime fork (it could
                 // never be replayed there — see buildForkBundle). Unset => keep it.
-                const bundle = buildForkBundle({ runtime: deps.getRuntime(rec.runtimeId), sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, workspaceSnapshot, targetRuntimeId: deps.agentFrom(msg), liveMessages: deps.forkMessages(rec), state: deps.forkInFlightState(rec) });
+                const bundle = buildForkBundle({ runtime: deps.getRuntime(rec.runtimeId), sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, workspaceSnapshot, targetRuntimeId: deps.agentFrom(msg), liveMessages: deps.forkMessages(rec), display: deps.forkDisplay(rec), state: deps.forkInFlightState(rec) });
                 ctx.reply({ type: "session.fork.bundle", requestId, bundle });
             }
             catch (error) {
@@ -150,7 +150,7 @@ export function createForkCommands(deps) {
                     ? captureWorkspaceSnapshot(sourceCwd, { maxBytes: deps.forkWorkspaceMaxBytes() })
                     : undefined;
                 // Same runtime → the bundle carries the native payload → full fidelity.
-                const bundle = buildForkBundle({ runtime, sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, workspaceSnapshot, targetRuntimeId: rec.runtimeId, liveMessages: deps.forkMessages(rec), state: deps.forkInFlightState(rec) });
+                const bundle = buildForkBundle({ runtime, sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, workspaceSnapshot, targetRuntimeId: rec.runtimeId, liveMessages: deps.forkMessages(rec), display: deps.forkDisplay(rec), state: deps.forkInFlightState(rec) });
                 // Cut a fresh fork branch (the source still holds its own); skip prereq
                 // detection (same node + same runtime ⇒ agent and repo are present).
                 const outcome = await deps.standUpFork({

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,26 @@ 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|--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 label = [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 +134,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";
@@ -550,6 +551,31 @@ 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 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)
+            return undefined;
+        const client = new SiblingClient({ controlPlaneUrl: sessionAdvertiseTarget.controlPlaneUrl, enrollmentToken: sessionAdvertiseTarget.enrollmentToken, siblingNodeId: target.id, label: "Bivy delegation" });
+        try {
+            await client.connect();
+            const reply = await client.request({ kind: "delegation.answer", sessionId }, 20_000);
+            return typeof reply.answer === "string" ? reply.answer : undefined;
+        }
+        finally {
+            client.close();
+        }
+    },
 });
 // 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
@@ -2105,6 +2131,7 @@ const RELAY_COMMANDS = {
     ...createForkCommands({
         broadcast,
         forkMessages: (rec) => transcripts.forkMessages(rec),
+        forkDisplay: (rec) => transcripts.conversationMessages(rec),
         resolveSession: (sessionId) => resolveSession(sessionId),
         getRuntime: (runtimeId) => getRuntime(runtimeId),
         forkRecordFor,
@@ -2405,6 +2432,13 @@ 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.
+    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.
@@ -5161,6 +5195,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();
@@ -7788,6 +7846,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).
@@ -8919,6 +8982,7 @@ const forkStandUp = createForkStandUp({
     createSession,
     broadcast,
     persistSessionMetadata,
+    recordForkDisplay: (record, messages, forkedAt) => eventLog.appendForkDisplay(record.id, messages, forkedAt),
     scheduleAdvertise,
     bivySessionEnvelope,
     applyRequestedModel,

package/dist/session/event-log.js

@@ -209,6 +209,12 @@ function isBase(value) {
     const record = value;
     return record.bivyKind === "base" && Array.isArray(record.messages) && typeof record.reset === "boolean";
 }
+function isForkDisplay(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const record = value;
+    return record.bivyKind === "fork-display" && Array.isArray(record.messages) && typeof record.forkedAt === "number";
+}
 function isAttachment(value) {
     if (!value || typeof value !== "object")
         return false;
@@ -255,7 +261,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) || isAttachment(value) || isOutboundAttachment(value) || isInlineImage(value) || isAppPublication(value) || isAppReviewEntry(value) || isSuggestionEntry(value);
+    return 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
@@ -743,7 +749,23 @@ export class EventLog {
      *  the display overlays — what a fork carries to another agent. */
     deriveBase(id, runtimeBase) {
         const logged = this.readBase(id);
-        return runtimeBase && runtimeBase.length ? mergeBases(logged, runtimeBase) : logged;
+        const base = runtimeBase && runtimeBase.length ? mergeBases(logged, runtimeBase) : logged;
+        const display = this.entries(id).find(isForkDisplay);
+        if (!display)
+            return base;
+        const replayed = (m) => {
+            const ts = m.timestamp;
+            return typeof ts === "number" && ts <= display.forkedAt;
+        };
+        return [...display.messages, ...base.filter((m) => !replayed(m))];
+    }
+    /** Record a fork's source transcript for display (see ForkDisplayLogEntry). */
+    appendForkDisplay(id, messages, forkedAt) {
+        if (!messages.length)
+            return;
+        this.load(id);
+        const record = { bivyKind: "fork-display", createdAt: Date.now(), forkedAt, messages: JSON.parse(JSON.stringify(messages)) };
+        this.enqueue(id, this.syntheticKey(id), record);
     }
     /** Full ordered record list (already-flushed followed by pending). */
     entries(id) {

package/dist/session/fork-standup.js

@@ -217,6 +217,11 @@ export function createForkStandUp(deps) {
         const record = plan.kind === "resume"
             ? await deps.createSession(cwd, plan.sessionFile, { runtimeId: targetRuntimeId, source: bundle.record.source, sandbox: forkSandbox, makeActive: false, newSession: true })
             : await deps.createSession(cwd, undefined, { runtimeId: targetRuntimeId, source: bundle.record.source, sandbox: forkSandbox, makeActive: false, newSession: true });
+        // A replayed or seeded destination resumes from a text rendering of the
+        // conversation. Show the source's own transcript (tool cards, sub-agent
+        // nesting) in its place; everything the fork does from now on follows it.
+        if (plan.fidelity !== "full" && bundle.display?.length)
+            deps.recordForkDisplay(record, bundle.display, Date.now());
         // Mark the new session as a fork of its source, so the run card can show
         // "Forked from …" and the lineage survives a reload (persisted below).
         record.forkedFrom = bundle.record.sourceSessionId;

package/dist/session/fork.js

@@ -1,4 +1,7 @@
 import { normalizeMessages, buildSeedPrompt, buildForkHistory, } from "./transcript-normal.js";
+/** Cap on the display transcript a bundle carries; larger sessions fall back to
+ *  showing the destination agent's own (text) replay. */
+export const FORK_DISPLAY_MAX_BYTES = 2 * 1024 * 1024;
 /**
  * Capture a fork bundle on the source node. Always includes the normalized
  * transcript (the cross-runtime seed, and the fallback when a same-runtime
@@ -49,7 +52,8 @@ export function buildForkBundle(opts) {
             // transcript below still supports replay or a seeded continuation.
         }
     }
-    return { record, normalized, ...(native ? { native } : {}), ...(opts.dirtyPatch ? { dirtyPatch: opts.dirtyPatch } : {}), ...(opts.workspaceSnapshot ? { workspaceSnapshot: opts.workspaceSnapshot } : {}), ...(opts.state ? { state: opts.state } : {}) };
+    const display = opts.display?.length && JSON.stringify(opts.display).length <= FORK_DISPLAY_MAX_BYTES ? [...opts.display] : undefined;
+    return { record, normalized, ...(native ? { native } : {}), ...(display ? { display } : {}), ...(opts.dirtyPatch ? { dirtyPatch: opts.dirtyPatch } : {}), ...(opts.workspaceSnapshot ? { workspaceSnapshot: opts.workspaceSnapshot } : {}), ...(opts.state ? { state: opts.state } : {}) };
 }
 /**
  * Decide the best fidelity a fork of `bundle` into `targetRuntime` can achieve:

package/package.json

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