@bivy/bivy 0.18.11-staging.3 → 0.18.11-staging.4

package/bin/acp-shim.mjs

@@ -139,6 +139,23 @@ let pendingModel = null;
 // toolCallId -> { requestId, options } so a later bivy tool.decision answers the
 // right ACP permission request with a concrete optionId.
 const permissionRequests = new Map();
+// Calls the human (or policy) already approved. An agent that performs an
+// approved edit through fs/write_text_file (Grok does) must not be gated — and
+// carded — a second time for the same file.
+const approvedCalls = new Set();
+
+/** The approved, still-running call whose inputs name `file`, if any. */
+function approvedCallWriting(file) {
+  for (const id of approvedCalls) {
+    const state = toolCallState.get(id);
+    if (!state) { approvedCalls.delete(id); continue; }
+    const input = toolCallInput(state);
+    const paths = [input.path, input.file_path, input.filePath, ...(state.locations || []).map((l) => l?.path)].filter(Boolean);
+    const root = fs.realpathSync(cwd);
+    if (paths.some((p) => path.resolve(root, String(p)) === file || path.resolve(cwd, String(p)) === file)) return id;
+  }
+  return undefined;
+}
 const sandboxTier = process.env.BIVY_ACP_SANDBOX || "workspace-write";
 
 function isWithin(root, candidate) {
@@ -190,6 +207,9 @@ function finishTurnDone() {
   turnDrainTimer = null;
   if (!turnDraining) return;
   turnDraining = false;
+  ownCalls.clear();
+  childParent.clear();
+  approvedCalls.clear();
   bivy({ type: "session.status", status: "idle" });
   bivy({ type: "session.done" });
 }
@@ -222,6 +242,11 @@ function mergeToolCallState(toolCallId, u) {
   const next = {
     kind: u.kind ?? prev.kind,
     title: u.title ?? prev.title,
+    // Agents open a call titled with the tool's own name ("task",
+    // "spawn_subagent", "bash") and later retitle it with prose ("Count README
+    // lines"). Keep the first identifier-like title as the stable name, so a
+    // delegation still classifies as one after the retitle.
+    name: prev.name ?? (typeof u.title === "string" && /^[A-Za-z_][\w.:-]*$/.test(u.title) ? u.title : undefined),
     rawInput: u.rawInput && typeof u.rawInput === "object" && Object.keys(u.rawInput).length ? u.rawInput : prev.rawInput,
     locations: Array.isArray(u.locations) && u.locations.length ? u.locations : prev.locations,
     content: content && content.length ? content : prev.content,
@@ -259,7 +284,60 @@ function toolCallInput(state) {
  *  both the node's bucket classifier and the client's own name-based heuristic,
  *  which both expect short tool-name-like tokens, not prose. */
 function toolCallName(state) {
-  return (state.kind && KIND_TOOL_NAME[state.kind]) || state.title || state.kind || "tool";
+  return (state.kind && KIND_TOOL_NAME[state.kind]) || state.name || state.title || state.kind || "tool";
+}
+
+// --- sub-agent sessions ------------------------------------------------------
+// Agents that run sub-agents as ACP sessions of their own (Grok's
+// spawn_subagent) stream the child's updates over this same connection, tagged
+// with the CHILD's sessionId. Folding those into the parent turn glued the
+// sub-agent's prose onto the parent's answer and listed its tools as the
+// parent's. Route them instead: child tool calls carry `parentToolCallId` (the
+// delegating call, so the transcript nests them) and child prose stays out of
+// the parent reply — the delegation's own tool result carries its answer.
+const childParent = new Map(); // child sessionId -> delegating toolCallId ("" if unknown)
+// This turn's own (non-child) calls, kept after they complete: a background
+// sub-agent's spawn call often finishes before the child's first update lands.
+const ownCalls = new Map(); // toolCallId -> accumulated state
+const DELEGATION_NAME = /agent|task|delegat/i;
+
+function isDelegation(state) {
+  const input = state?.rawInput || {};
+  return DELEGATION_NAME.test(String(state?.name || "")) || typeof input.subagent_type === "string" || typeof input.prompt === "string";
+}
+
+/** The delegating call for a child session: an explicit link when the agent
+ *  sent one (see linkChildSession), else the newest delegation-shaped call of
+ *  this turn that no other child has claimed, else the newest open call. */
+function parentCallFor(childSessionId) {
+  if (childParent.has(childSessionId)) return childParent.get(childSessionId);
+  const claimed = new Set(childParent.values());
+  const calls = [...ownCalls].reverse().filter(([id]) => !claimed.has(id));
+  const pick = calls.find(([, st]) => isDelegation(st)) ?? calls.find(([id]) => toolCallState.has(id));
+  const parent = pick?.[0] ?? "";
+  childParent.set(childSessionId, parent);
+  return parent;
+}
+
+/** An agent-specific notification that names a child session and its parent
+ *  (`child_session_id` / `parent_session_id`, plus the tool call id or the
+ *  delegation's description) pins the link instead of the heuristic above. */
+function linkChildSession(update) {
+  const child = update?.child_session_id ?? update?.childSessionId;
+  const parentSession = update?.parent_session_id ?? update?.parentSessionId;
+  if (!child || (parentSession && parentSession !== sessionId) || childParent.get(child)) return;
+  const byId = update.tool_call_id ?? update.toolCallId;
+  const match = byId && ownCalls.has(byId)
+    ? byId
+    : [...ownCalls].reverse().find(([, st]) => update.description && (st.title === update.description || st.rawInput?.description === update.description))?.[0];
+  if (match) childParent.set(child, match);
+}
+
+/** Routing for an update from `sid`: null for this session, else the parent
+ *  call id ("" when it can't be placed). */
+function childRoute(sid) {
+  if (!sid || !sessionId || sid === sessionId) return null;
+  return parentCallFor(sid);
 }
 
 async function ensureInitialized() {
@@ -309,6 +387,9 @@ function onSessionUpdate(params) {
   // window so session.done waits for it instead of sealing history short.
   if (turnDraining) scheduleTurnDone();
   const kind = String(u.sessionUpdate || "");
+  const parentCall = childRoute(params?.sessionId);
+  const child = parentCall !== null;
+  const nest = parentCall ? { parentToolCallId: parentCall } : {};
   const textOf = (content) => {
     if (!content) return "";
     if (typeof content === "string") return content;
@@ -327,12 +408,12 @@ function onSessionUpdate(params) {
   switch (kind) {
     case "agent_message_chunk": {
       const t = textOf(u.content);
-      if (t) bivy({ type: "message.delta", text: t });
+      if (t && !child) bivy({ type: "message.delta", text: t });
       break;
     }
     case "agent_thought_chunk": {
       const t = textOf(u.content);
-      if (t) bivy({ type: "message.reasoning", text: t });
+      if (t && !child) bivy({ type: "message.reasoning", text: t });
       break;
     }
     case "tool_call": {
@@ -340,12 +421,14 @@ function onSessionUpdate(params) {
       // shows the action; the result arrives via tool_call_update.
       const toolCallId = String(u.toolCallId ?? u.id ?? "");
       const state = mergeToolCallState(toolCallId, u);
-      bivy({ type: "tool.observe", toolCallId, name: toolCallName(state), input: toolCallInput(state) });
+      if (!child) ownCalls.set(toolCallId, state);
+      bivy({ type: "tool.observe", toolCallId, name: toolCallName(state), input: toolCallInput(state), ...nest });
       break;
     }
     case "tool_call_update": {
       const toolCallId = String(u.toolCallId ?? u.id ?? "");
       const state = mergeToolCallState(toolCallId, u);
+      if (!child && ownCalls.has(toolCallId)) ownCalls.set(toolCallId, state);
       const status = String(u.status || "");
       if (status === "completed" || status === "failed") {
         toolCallState.delete(toolCallId);
@@ -362,17 +445,18 @@ function onSessionUpdate(params) {
           // the terminal frame's content when it has some, else the accumulated.
           result: textOf(u.content) || textOf(state.content) || status,
           isError: status === "failed",
+          ...nest,
         });
       } else {
         // Still running: forward the fuller name/input as it fills in so a live
         // tool card isn't stuck with the sparse initial notification.
-        bivy({ type: "tool.update", toolCallId, name: toolCallName(state), input: toolCallInput(state) });
+        bivy({ type: "tool.update", toolCallId, name: toolCallName(state), input: toolCallInput(state), ...nest });
       }
       break;
     }
     case "plan":
       // Optional planning stream — fold into reasoning so nothing is lost.
-      if (Array.isArray(u.entries)) bivy({ type: "message.reasoning", text: u.entries.map((e) => `• ${e.content ?? ""}`).join("\n") });
+      if (!child && Array.isArray(u.entries)) bivy({ type: "message.reasoning", text: u.entries.map((e) => `• ${e.content ?? ""}`).join("\n") });
       break;
     default:
       break;
@@ -391,7 +475,9 @@ async function onAgentRequest(id, method, params) {
       const options = Array.isArray(params?.options) ? params.options : [];
       permissionRequests.set(toolCallId, { requestId: id, options });
       const state = mergeToolCallState(toolCallId, tc);
-      bivy({ type: "tool.call", toolCallId, name: toolCallName(state), input: toolCallInput(state) });
+      const parentCall = childRoute(params?.sessionId);
+      if (parentCall === null) ownCalls.set(toolCallId, state);
+      bivy({ type: "tool.call", toolCallId, name: toolCallName(state), input: toolCallInput(state), ...(parentCall ? { parentToolCallId: parentCall } : {}) });
       return;
     }
     case "fs/read_text_file": {
@@ -413,9 +499,15 @@ async function onAgentRequest(id, method, params) {
       try {
         if (sandboxTier === "read-only") throw new Error("writes are disabled by the read-only sandbox");
         const file = workspacePath(params?.path, { write: true });
+        if (approvedCallWriting(file)) {
+          fs.writeFileSync(file, String(params?.content ?? ""));
+          agentReply(id, {});
+          return;
+        }
         const toolCallId = `acp-fs-write-${id}`;
         permissionRequests.set(toolCallId, { kind: "fs-write", requestId: id, file, content: String(params?.content ?? "") });
-        bivy({ type: "tool.call", toolCallId, name: "write", input: { path: file } });
+        const parentCall = childRoute(params?.sessionId);
+        bivy({ type: "tool.call", toolCallId, name: "write", input: { path: file }, ...(parentCall ? { parentToolCallId: parentCall } : {}) });
       } catch (e) {
         agentReplyError(id, -32000, `write failed: ${e.message}`);
       }
@@ -449,6 +541,7 @@ createInterface({ input: agent.stdout }).on("line", (line) => {
   if (msg.id !== undefined && msg.method) { void onAgentRequest(msg.id, msg.method, msg.params); return; }
   // Notification (method, no id).
   if (msg.method === "session/update") onSessionUpdate(msg.params);
+  else if (msg.params?.update) linkChildSession(msg.params.update);
 });
 
 /**
@@ -554,16 +647,22 @@ async function onBivyCommand(msg) {
           permissionRequests.delete(msg.toolCallId);
           const allow = msg.decision !== "deny";
           if (entry.kind === "fs-write") {
-            if (!allow) agentReplyError(entry.requestId, -32001, String(msg.reason || "write denied by Bivy policy"));
-            else {
-              try { fs.writeFileSync(entry.file, entry.content); agentReply(entry.requestId, {}); }
-              catch (e) { agentReplyError(entry.requestId, -32000, `write failed: ${e.message}`); }
+            // The write card is the shim's own call, so the shim closes it too —
+            // left open it pinned the turn "Working" after the agent finished.
+            let error = allow ? "" : String(msg.reason || "write denied by Bivy policy");
+            if (allow) {
+              try { fs.writeFileSync(entry.file, entry.content); }
+              catch (e) { error = `write failed: ${e.message}`; }
             }
+            if (error) agentReplyError(entry.requestId, allow ? -32000 : -32001, error);
+            else agentReply(entry.requestId, {});
+            bivy({ type: "tool.result", toolCallId: msg.toolCallId, name: "write", result: error || `Wrote ${entry.file}`, isError: Boolean(error) });
             return;
           }
           // Pick an ACP option matching the human's choice by its `kind`
           // (allow_once/allow_always vs reject_once/reject_always); fall back to the
           // first option, or a cancelled outcome when nothing fits.
+          if (allow) approvedCalls.add(msg.toolCallId);
           const want = allow ? /^allow/ : /^reject/;
           const opt = entry.options.find((o) => want.test(String(o.kind || ""))) ?? entry.options[0];
           if (opt && opt.optionId !== undefined) agentReply(entry.requestId, { outcome: { outcome: "selected", optionId: opt.optionId } });

package/dist/controllers/fork-commands.js

@@ -11,7 +11,7 @@ import { buildForkBundle } from "../session/fork.js";
 import { captureDirtyPatch, captureWorkspaceDirtyPatch, captureWorkspaceSnapshot } from "../session/fork-dirty.js";
 export function createForkCommands(deps) {
     return {
-        async "session.fork.retire-source"(msg) {
+        async "session.fork.retire-source"(msg, ctx) {
             // Retire a MOVE's source once its destination is confirmed (1A). Gated (won't
             // retire without newSessionId) and idempotent (safe for the client to retry),
             // so a crashed-mid-move client can't orphan the source or lose it. Emits the
@@ -22,25 +22,25 @@ export function createForkCommands(deps) {
             try {
                 const outcome = await deps.retireSource({ sourceSessionId, newSessionId });
                 if (!outcome.ok) {
-                    deps.sendEvent({ type: "session.fork.error", requestId, sessionId: sourceSessionId || undefined, error: outcome.error });
+                    ctx.reply({ type: "session.fork.error", requestId, sessionId: sourceSessionId || undefined, error: outcome.error });
                     return;
                 }
                 if (outcome.retired)
                     deps.broadcast({ type: "session.deleted", sessionId: sourceSessionId });
-                deps.sendEvent({ type: "session.fork.retired", requestId, sourceSessionId, newSessionId, alreadyGone: outcome.alreadyGone });
+                ctx.reply({ type: "session.fork.retired", requestId, sourceSessionId, newSessionId, alreadyGone: outcome.alreadyGone });
             }
             catch (error) {
-                deps.sendEvent({ type: "session.fork.error", requestId, sessionId: sourceSessionId || undefined, error: error instanceof Error ? error.message : String(error) });
+                ctx.reply({ type: "session.fork.error", requestId, sessionId: sourceSessionId || undefined, error: error instanceof Error ? error.message : String(error) });
             }
         },
-        async "session.fork.export"(msg) {
+        async "session.fork.export"(msg, ctx) {
             // Source side of a session fork: package the session's transcript +
             // portable metadata + any uncommitted worktree changes into an E2E
             // bundle the client carries to the destination node.
             const requestId = typeof msg.requestId === "string" ? msg.requestId : undefined;
             const rec = deps.resolveSession(msg.sessionId);
             if (!rec) {
-                deps.sendEvent({ type: "session.fork.error", requestId, error: "Session not found on this node." });
+                ctx.reply({ type: "session.fork.error", requestId, error: "Session not found on this node." });
                 return;
             }
             try {
@@ -72,14 +72,14 @@ 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: rec.session.getMessages(), state: deps.forkInFlightState(rec) });
-                deps.sendEvent({ type: "session.fork.bundle", requestId, bundle });
+                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) });
+                ctx.reply({ type: "session.fork.bundle", requestId, bundle });
             }
             catch (error) {
-                deps.sendEvent({ type: "session.fork.error", requestId, error: error instanceof Error ? error.message : String(error) });
+                ctx.reply({ type: "session.fork.error", requestId, error: error instanceof Error ? error.message : String(error) });
             }
         },
-        async "session.fork.import"(msg) {
+        async "session.fork.import"(msg, ctx) {
             // Destination side of a fork: rebuild the repo/worktree, materialise the
             // transcript into the (possibly different) target runtime — full fidelity
             // for a same-runtime fork, a seeded continuation prompt otherwise — and
@@ -88,7 +88,7 @@ export function createForkCommands(deps) {
             const requestId = typeof msg.requestId === "string" ? msg.requestId : undefined;
             const bundle = msg.bundle;
             if (!bundle?.record || !bundle.normalized) {
-                deps.sendEvent({ type: "session.fork.error", requestId, error: "Malformed fork bundle." });
+                ctx.reply({ type: "session.fork.error", requestId, error: "Malformed fork bundle." });
                 return;
             }
             try {
@@ -112,16 +112,16 @@ export function createForkCommands(deps) {
                         : {}),
                 });
                 if (!outcome.ok) {
-                    deps.sendEvent({ type: "session.fork.error", requestId, error: outcome.error, missing: outcome.missing });
+                    ctx.reply({ type: "session.fork.error", requestId, error: outcome.error, missing: outcome.missing });
                     return;
                 }
-                deps.sendEvent(deps.forkDoneEvent(requestId, outcome.record, outcome.plan, outcome.missing));
+                ctx.reply(deps.forkDoneEvent(requestId, outcome.record, outcome.plan, outcome.missing));
             }
             catch (error) {
-                deps.sendEvent({ type: "session.fork.error", requestId, error: error instanceof Error ? error.message : String(error) });
+                ctx.reply({ type: "session.fork.error", requestId, error: error instanceof Error ? error.message : String(error) });
             }
         },
-        async "session.fork.local"(msg) {
+        async "session.fork.local"(msg, ctx) {
             // Fast path: fork a session on the SAME node and SAME runtime WITHOUT
             // round-tripping the transcript out to the client and back. We build the
             // fork bundle in-process and stand the new session
@@ -132,7 +132,7 @@ export function createForkCommands(deps) {
             const requestId = typeof msg.requestId === "string" ? msg.requestId : undefined;
             const rec = deps.resolveSession(msg.sessionId);
             if (!rec) {
-                deps.sendEvent({ type: "session.fork.error", requestId, error: "Session not found on this node." });
+                ctx.reply({ type: "session.fork.error", requestId, error: "Session not found on this node." });
                 return;
             }
             try {
@@ -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: rec.session.getMessages(), state: deps.forkInFlightState(rec) });
+                const bundle = buildForkBundle({ runtime, sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, workspaceSnapshot, targetRuntimeId: rec.runtimeId, liveMessages: deps.forkMessages(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({
@@ -162,13 +162,13 @@ export function createForkCommands(deps) {
                     fallback: { workspace: rec.workspace, cwd: rec.session.cwd || rec.worktree?.path || rec.workspace },
                 });
                 if (!outcome.ok) {
-                    deps.sendEvent({ type: "session.fork.error", requestId, error: outcome.error, missing: outcome.missing });
+                    ctx.reply({ type: "session.fork.error", requestId, error: outcome.error, missing: outcome.missing });
                     return;
                 }
-                deps.sendEvent(deps.forkDoneEvent(requestId, outcome.record, outcome.plan, outcome.missing));
+                ctx.reply(deps.forkDoneEvent(requestId, outcome.record, outcome.plan, outcome.missing));
             }
             catch (error) {
-                deps.sendEvent({ type: "session.fork.error", requestId, error: error instanceof Error ? error.message : String(error) });
+                ctx.reply({ type: "session.fork.error", requestId, error: error instanceof Error ? error.message : String(error) });
             }
         },
     };

package/dist/exec.js

@@ -15,6 +15,19 @@
 // unauthenticated CLI) exits non-zero with the error on stderr, rather than
 // reporting a silent empty success.
 import { WebSocket } from "ws";
+const USAGE = `Usage: bivy exec [options] "<prompt>"   (or pipe the prompt on stdin, or pass -)
+
+One-shot headless turn: prints the final answer to stdout, progress to stderr.
+
+  -a, --agent <id>       Agent to run (default: the node's default agent)
+  -m, --model <model>    Model id, bare or provider-qualified (gpt-5.6-sol, openai-codex/gpt-5.6-sol)
+  -n, --name <label>     Session name
+  -w, --workspace <dir>  Workspace directory
+      --session <ref>    Continue an existing session instead of starting one
+      --json             Print {"sessionId","answer"} instead of plain text
+      --timeout <sec>    Give up after this many seconds (default 600)
+  -h, --help             Show this help
+`;
 const err = (s) => process.stderr.write(s);
 function parseArgs(argv) {
     let url = process.env.BIVY_URL || `http://localhost:${process.env.PORT || "4317"}`;
@@ -25,6 +38,7 @@ function parseArgs(argv) {
     let name;
     let workspace;
     let json = false;
+    let help = false;
     let timeoutMs = Number(process.env.BIVY_EXEC_TIMEOUT_MS) || 10 * 60 * 1000;
     const prompt = [];
     for (let i = 0; i < argv.length; i++) {
@@ -59,12 +73,14 @@ function parseArgs(argv) {
             workspace = arg.slice("--workspace=".length);
         else if (arg === "--json")
             json = true;
+        else if (arg === "-h" || arg === "--help")
+            help = true;
         else if (arg === "--timeout" && argv[i + 1])
             timeoutMs = Number(argv[++i]) * 1000;
         else
             prompt.push(arg);
     }
-    return { url: url.replace(/\/+$/, ""), token, agent, model, session, name, workspace, prompt: prompt.join(" "), json, timeoutMs };
+    return { url: url.replace(/\/+$/, ""), token, agent, model, session, name, workspace, prompt: prompt.join(" "), json, timeoutMs, help };
 }
 function authHeaders(token) {
     return { "content-type": "application/json", ...(token ? { authorization: `Bearer ${token}` } : {}) };
@@ -116,11 +132,15 @@ async function readStdin() {
 }
 async function main() {
     const args = parseArgs(process.argv.slice(2));
+    if (args.help) {
+        process.stdout.write(USAGE);
+        return;
+    }
     let prompt = args.prompt.trim();
     if (prompt === "-" || (!prompt && !process.stdin.isTTY))
         prompt = (await readStdin()).trim();
     if (!prompt) {
-        err('Usage: bivy exec "<prompt>"  (or pipe the prompt on stdin)\n');
+        err(USAGE);
         process.exit(2);
     }
     // Establish the session — resume by ref or create fresh with the chosen agent.
@@ -149,6 +169,15 @@ async function main() {
                 }),
             });
             sessionId = created.id;
+            // The node binds the model best-effort and keeps the agent's default when
+            // it can't; say so instead of silently answering on another model.
+            const model = created.model;
+            if (args.model && model?.id) {
+                const qualified = !model.provider || model.id.startsWith(`${model.provider}/`) ? model.id : `${model.provider}/${model.id}`;
+                if (![model.id, qualified].some((id) => id === args.model || id.endsWith(`/${args.model}`))) {
+                    err(`Model "${args.model}" is not available for this agent; using ${qualified}.\n`);
+                }
+            }
         }
     }
     catch (error) {
@@ -163,6 +192,9 @@ async function main() {
     // Last stderr the agent surfaced (auth failures, crashes). Carried so a turn
     // that ends with no assistant text can explain WHY instead of printing empty.
     let lastStderr = "";
+    // A runtime that fails a turn (usage limit, provider error) seals it with an
+    // assistant message marked stopReason "error" before a normal agent_end.
+    let turnError = "";
     const finish = (code, errorText) => {
         if (settled)
             return;
@@ -224,6 +256,9 @@ async function main() {
                 const text = assistantText(ev);
                 if (text)
                     answer = text; // events carry the full message text so far
+                const message = ev.message;
+                if (message?.stopReason === "error" && typeof message.errorMessage === "string")
+                    turnError = message.errorMessage.trim();
             }
             else if (ev.type === "tool_execution_update" && ev.toolName === "agent_output") {
                 const input = (ev.input || {});
@@ -238,10 +273,12 @@ async function main() {
                 // non-zero). Printing an empty answer with exit 0 would report a silent
                 // false success to a script. Surface the failure instead: prefer an
                 // explicit error string, then the last stderr line, then the exit code.
-                const errText = typeof ev.error === "string" && ev.error.trim() ? ev.error.trim() : undefined;
+                const errText = typeof ev.error === "string" && ev.error.trim() ? ev.error.trim() : turnError || undefined;
                 const code = typeof ev.code === "number" ? ev.code : undefined;
                 const failed = !!errText || (code !== undefined && code !== 0);
-                if (!answer.trim() && failed) {
+                // A turn the runtime itself marked failed is a failure even when some
+                // prose streamed before the error.
+                if (turnError || (!answer.trim() && failed)) {
                     finish(1, errText || lastStderr || `The agent produced no output (exit code ${code ?? "unknown"}).`);
                 }
                 else {

package/dist/runtime/model-ref.js

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+// Bind a loosely written model reference to one entry of a session's catalog.
+//
+// The CLI (`bivy run --model`, `bivy exec --model`) and the `bivy-model:`
+// directive send `{ provider: "", id }`, where `id` may be bare ("gpt-5.6-sol")
+// or provider-qualified ("openai-codex/gpt-5.6-sol"). Runtimes key models
+// differently — Pi by (provider, id), ACP agents by a slash id whose prefix is
+// the provider ("opencode/gpt-5.6-sol") — so a runtime that needs the provider
+// (Pi) rejected the bare form and the session silently kept its default model.
+// Resolving against the session's own catalog makes every spelling work for any
+// runtime without per-agent code.
+/**
+ * Resolve `ref` against `models`. An explicit provider is kept as-is. Otherwise
+ * match, in order: the exact id, a `provider/id` split, then an id that ends in
+ * `/<ref.id>` (a bare name for an ACP slash id). Ties prefer the current
+ * model's provider. Unknown refs are returned unchanged so the runtime reports
+ * its own error.
+ */
+export function resolveModelRef(models, ref, current) {
+    if (ref.provider)
+        return ref;
+    const id = ref.id.trim();
+    const slash = id.indexOf("/");
+    const tiers = [
+        models.filter((m) => m.id === id),
+        slash > 0 ? models.filter((m) => m.provider === id.slice(0, slash) && m.id === id.slice(slash + 1)) : [],
+        models.filter((m) => m.id.endsWith(`/${id}`)),
+    ];
+    const candidates = tiers.find((tier) => tier.length) ?? [];
+    const pick = candidates.find((m) => m.provider === current?.provider) ?? candidates[0];
+    return pick ? { provider: pick.provider, id: pick.id } : ref;
+}

package/dist/runtime/protocol.js

@@ -10,6 +10,11 @@ import { mergeAgentCommands } from "./slash-commands.js";
 import { withExactCapabilitySurface } from "./types.js";
 import { extractTokenUsage } from "./cli-parsers.js";
 import { mapToolCall, mapToolResult } from "./tool-call-map.js";
+/** A tool message's sub-agent parent (`parentToolCallId`), spread into the
+ *  runtime event and persisted block so delegated work nests under its call. */
+function parentOf(msg) {
+    return typeof msg.parentToolCallId === "string" && msg.parentToolCallId ? { parentToolUseId: msg.parentToolCallId } : {};
+}
 /** A protocol `usage` message → UsageSnapshot (reuses the CLI token-key scan). */
 function parseProtocolUsage(raw) {
     if (!raw || typeof raw !== "object")
@@ -774,6 +779,7 @@ class ProtocolSession {
             const detail = mapToolCall(toolName, msg.input, { provider: this.runtimeOptions.id || "acp", protocol: "protocol" });
             if (detail)
                 this.toolDetailsByCallId.set(toolCallId, detail);
+            const parent = parentOf(msg);
             // `tool.observe` is for activity an upstream runtime reports after it has
             // already begun (Codex read-only MCP and sub-agent items, for example).
             // It must render and persist exactly like a call, but must never open a
@@ -789,12 +795,19 @@ class ProtocolSession {
             }
             else {
                 this.flushPendingTurnText();
-                this.turnContent.push({ type: "tool_use", id: toolCallId, name: toolName, input: msg.input ?? {}, ...(detail ? { detail } : {}) });
+                this.turnContent.push({ type: "tool_use", id: toolCallId, name: toolName, input: msg.input ?? {}, ...(detail ? { detail } : {}), ...parent });
+                // Prose after a tool is a new item: separate it in the cumulative live
+                // text too, or "…the README.Added `sub`…" reads as one sentence.
+                if (this.assistantText)
+                    this.assistantItemBoundary = true;
+                // Reasoning after a tool is a new thinking item as well; accumulating it
+                // re-showed the earlier thoughts as the prefix of the next block.
+                this.reasoningText = "";
             }
             // Stream the live tool card for every protocol agent. Interception is an
             // additional round-trip only for a real `tool.call`; observed activity is
             // informational because the upstream runtime is already executing it.
-            this.emit({ type: existing ? "tool_execution_update" : "tool_call", toolName, input: msg.input, toolCallId, ...(detail ? { detail } : {}) });
+            this.emit({ type: existing ? "tool_execution_update" : "tool_call", toolName, input: msg.input, toolCallId, ...(detail ? { detail } : {}), ...parent });
             if (type === "tool.call" && this.capabilitiesRef.toolInterception && this.toolInterceptor) {
                 const decision = await this.toolInterceptor({ sessionId: this.id, toolName, input: msg.input });
                 try {
@@ -827,7 +840,7 @@ class ProtocolSession {
                 if (detail)
                     block.detail = detail;
             }
-            this.emit({ type: "tool_execution_update", toolName, input: msg.input, toolCallId, ...(detail ? { detail } : {}) });
+            this.emit({ type: "tool_execution_update", toolName, input: msg.input, toolCallId, ...(detail ? { detail } : {}), ...parentOf(msg) });
             return;
         }
         if (type === "tool.result") {
@@ -842,7 +855,7 @@ class ProtocolSession {
             });
             const priorDetail = this.toolDetailsByCallId.get(toolCallId);
             const detail = priorDetail ? { ...priorDetail, result: mapToolResult(result, isError) } : undefined;
-            this.emit({ type: "tool_result", toolName: String(msg.name || "tool"), toolCallId, result, ...(detail ? { detail } : {}) });
+            this.emit({ type: "tool_result", toolName: String(msg.name || "tool"), toolCallId, result, ...(detail ? { detail } : {}), ...parentOf(msg) });
             return;
         }
         this.emit({ type, ...msg });

package/dist/server.js

@@ -40,6 +40,7 @@ import { createAppCommands } from "./controllers/app-commands.js";
 import { bindClientCommandRoutes } from "./http/client-command-routes.js";
 import { collectDiscoveredSessions, planNativeAdoption } from "./runtime/native-session-discovery.js";
 import { aggregateModelCatalog, catalogReplyEvent, mergeProviderCatalog } from "./runtime/model-catalog.js";
+import { resolveModelRef } from "./runtime/model-ref.js";
 import { RuntimeHost, enforcementLevelFor, remoteRuntimeEnabled } from "./runtime/host.js";
 import { RemoteRuntime, RemoteRuntimeSession } from "./runtime/remote.js";
 import { InMemorySessionLocationRegistry } from "./runtime/session-location.js";
@@ -2102,8 +2103,8 @@ const RELAY_COMMANDS = {
     // (server.ts decomposition). Late-bound singletons (forkStandUp/forkRetire/
     // branchPublish, declared below) are wrapped in thunks resolved at dispatch time.
     ...createForkCommands({
-        sendEvent: (event) => relay?.sendEvent(event),
         broadcast,
+        forkMessages: (rec) => transcripts.forkMessages(rec),
         resolveSession: (sessionId) => resolveSession(sessionId),
         getRuntime: (runtimeId) => getRuntime(runtimeId),
         forkRecordFor,
@@ -6096,6 +6097,17 @@ async function applyRequestedModel(record, model) {
     if (!model)
         return;
     try {
+        // A provider-less id (CLI --model, `bivy-model:`) binds against the
+        // session's catalog. Protocol agents only publish theirs once running, so
+        // warm it when the first lookup can't place the id.
+        if (!model.provider) {
+            const resolve = async () => resolveModelRef(await record.session.getModels(), model, record.session.getCurrentModel());
+            model = await resolve();
+            if (!model.provider && record.session.warmModels) {
+                await record.session.warmModels().catch(() => { });
+                model = await resolve();
+            }
+        }
         assertSessionModel(record, model.id);
         await record.session.setModel(model.provider, model.id);
         broadcast({ type: "model.updated", sessionId: record.id, model: publicModel(record.session.getCurrentModel(), record.session.getCurrentModel()) });
@@ -6604,6 +6616,7 @@ function persistSessionMetadata(record, status = sessionStatus(record)) {
         runtimeId: record.runtimeId,
         sandbox: record.sandbox,
         approvalMode: record.approvalMode,
+        ...sessionModelRef(record),
         credentialLabels: record.credentialLabels,
         agentName: getRuntime(record.runtimeId).displayName,
         contract: record.contract,
@@ -6671,6 +6684,12 @@ function bivySessionEnvelopeFromSummary(s, rec, meta) {
         prUrl: meta?.prUrl ?? s.prUrl,
     };
 }
+/** The session's current model as a metadata patch (empty when unknown, so a
+ *  reopened session that hasn't reported one yet keeps the stored value). */
+function sessionModelRef(record) {
+    const model = record.session.getCurrentModel();
+    return model?.id ? { model: { provider: String(model.provider ?? ""), id: model.id } } : {};
+}
 function touchSession(record) {
     record.lastTouchedAt = Date.now();
     metadata.touchSession(record.id, sessionStatus(record));
@@ -8378,6 +8397,13 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
     // session" in the sidebar.
     if (requestedSessionFile && storedMeta?.name && !session.getName())
         session.setName(storedMeta.name);
+    // Runtimes that learn their model from the next reply (Claude Code) reopen
+    // with none, so the picker showed the default and the next turn ran on it.
+    // Restore the model the session last used. Best-effort: a model this node no
+    // longer offers keeps the runtime default.
+    if (requestedSessionFile && storedMeta?.model && !session.getCurrentModel()) {
+        await session.setModel(storedMeta.model.provider, storedMeta.model.id).catch(() => { });
+    }
     const sessionWorkspace = session.cwd || runtimeWorkspace;
     // Best-effort here (unlike createWorkspaceSession, which must fail loudly):
     // this only decides whether to ADOPT an already-checked-out branch as the
@@ -11662,6 +11688,16 @@ wss.on("connection", (socket, req) => {
                 socket.send(JSON.stringify({ type: "pong", requestId: typeof requestId === "string" ? requestId : undefined }));
             return;
         }
+        if (typeof msg?.kind === "string" && msg.kind.startsWith("session.fork.")) {
+            // Fork/move is a request/reply exchange with no REST route, so direct
+            // (loopback/LAN) clients send it on this authenticated socket and get the
+            // reply here — the same handlers the relay dispatches.
+            const reply = (event) => { if (socket.readyState === WebSocket.OPEN)
+                socket.send(JSON.stringify(event)); };
+            void clientCommands.dispatch(msg.kind, msg, { reply, broadcast })
+                .catch((error) => reply({ type: "session.fork.error", requestId: msg.requestId, error: error instanceof Error ? error.message : String(error) }));
+            return;
+        }
         if (typeof msg?.kind === "string" && msg.kind.startsWith("terminal.")) {
             // A terminal client (`bivy run`/`bivy resume`) names its device once; typing
             // into a session's terminal then makes it that session's driver.

package/dist/session/event-log.js

@@ -737,9 +737,13 @@ export class EventLog {
      * `mergeConversation` helper.
      */
     deriveHistory(id, runtimeBase) {
+        return mergeTranscript(this.deriveBase(id, runtimeBase), this.read(id));
+    }
+    /** The conversation itself (runtime transcript over the logged base), without
+     *  the display overlays — what a fork carries to another agent. */
+    deriveBase(id, runtimeBase) {
         const logged = this.readBase(id);
-        const base = runtimeBase && runtimeBase.length ? mergeBases(logged, runtimeBase) : logged;
-        return mergeTranscript(base, this.read(id));
+        return runtimeBase && runtimeBase.length ? mergeBases(logged, runtimeBase) : logged;
     }
     /** Full ordered record list (already-flushed followed by pending). */
     entries(id) {

package/dist/session/transcript-merge.js

@@ -91,6 +91,28 @@ function insertionIndex(base, timeline, entry) {
     // Legacy / no-timestamp fallback: clamp the absolute count into range.
     return Math.max(0, Math.min(base.length, entry.afterMessageCount));
 }
+/** Tool-call ids a message references (tool_use/toolCall ids, tool_result targets). */
+function toolIds(content) {
+    if (!Array.isArray(content))
+        return [];
+    return content.flatMap((part) => {
+        if (!part || typeof part !== "object")
+            return [];
+        const record = part;
+        const id = record.tool_use_id ?? record.toolUseId ?? record.toolCallId ?? (/^(tool_use|toolCall)$/.test(String(record.type)) ? record.id : undefined);
+        return typeof id === "string" && id ? [id] : [];
+    });
+}
+/** base index of the first message referencing each tool id. */
+function toolIdIndex(base) {
+    const index = new Map();
+    base.forEach((message, i) => {
+        for (const id of toolIds(message.content))
+            if (!index.has(id))
+                index.set(id, i);
+    });
+    return index;
+}
 /**
  * Merge the `extras` (intermediate + tool-activity sidecar entries) into `base`,
  * each placed by time (see file header). Deduplicates intermediate reasoning that
@@ -100,10 +122,16 @@ export function mergeTranscript(base, extras) {
     if (!extras.length)
         return base;
     const timeline = baseTimeline(base);
+    const baseToolIndex = toolIdIndex(base);
     const byIndex = new Map();
     const seenIntermediate = new Set();
     for (const entry of extras) {
-        const index = insertionIndex(base, timeline, entry);
+        // A tool row whose call is already in the base transcript sits right after
+        // that message. Protocol runtimes persist a whole turn as one message when
+        // it ends, so time placement put every tool row ahead of the prose that
+        // preceded it in the turn (clients keep the first copy of a tool id).
+        const anchored = entry.bivyKind === "tool" ? toolIds(entry.content).map((id) => baseToolIndex.get(id)).find((i) => i !== undefined) : undefined;
+        const index = anchored !== undefined ? anchored + 1 : insertionIndex(base, timeline, entry);
         if (entry.bivyKind === "intermediate") {
             const text = normalizedIntermediateText(thinkingTextFromContent(entry.content));
             // Skip a sidecar reasoning copy when the adjacent persisted message already

package/dist/session/transcript-persistence.js

@@ -205,6 +205,9 @@ export function createTranscriptPersistence(deps) {
     function conversationMessages(record) {
         return eventLog.deriveHistory(record.id, record.session.getMessages());
     }
+    function forkMessages(record) {
+        return eventLog.deriveBase(record.id, record.session.getMessages());
+    }
     function buildHistoryEvent(opts) {
         const messages = opts.sessionId ? project(opts.sessionId, opts.messages) : opts.messages;
         const delta = historyDelta(messages, opts.cursor);
@@ -256,6 +259,7 @@ export function createTranscriptPersistence(deps) {
         persistIntermediateFromEvent,
         resolveInlineImages,
         conversationMessages,
+        forkMessages,
         buildHistoryEvent,
         buildReplayEvent,
         clearLiveIntermediate,

package/package.json

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