@bivy/bivy 0.18.11-staging.2 → 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/bin/bivy.mjs

@@ -2472,7 +2472,7 @@ async function cmdApp(args = []) {
        bivy app remove <app-id> [--session <id>]
        bivy app shot [app-id] [--widths 390,1280] [--themes light,dark] [--path /page] [--session <id>]
        bivy app present [view] [--path /page] [--note "…"] [--session <id>]
-       bivy app share [app-id] [--view <view>] [--session <id>]
+       bivy app share [app-id] [--view <view>] [--for 1h|1d|7d] [--view-only] [--session <id>]
        bivy app notes [app-id] [--view <view>] [--since <time>] [--session <id>]
        bivy app run [--name <name>] [--restart-on-change] [--session <id>] -- <command> [args…]
        bivy app click <x> <y> [--right|--middle] [--double] [--app <app>]
@@ -2518,9 +2518,10 @@ the chat with the app at phone width (and before/after), and it opens the live
 preview. Use it when you finish a visible change, or when the user asks to see
 it. [view] is an app or view name or ID (default: the one opened last).
 "share" mints a reusable link to one web view and prints its URL and expiry
-(24 hours, or until Revoke access in Apps, the app is removed or the machine
-restarts). [app-id] is an app ID or name, --view a view ID or name (default: the
-one opened last). Anyone who has the link can use the app, including a live
+(--for: 1h, 1d or 7d, default 1d; sooner if the user stops sharing in Apps, the
+app is removed or the machine restarts). [app-id] is an app ID or name, --view
+a view ID or name (default: the one opened last). --view-only leaves out the
+reviewer tools (Point, Draw, notes): people see just the app. Anyone who has the link can use the app, including a live
 server's backend, until it expires or is revoked: only post it where everyone
 who can read it may use the app.
 "notes" prints the notes people left through share links (Leave a note), as
@@ -2557,6 +2558,17 @@ Web previews require operator setup; see docs/apps.md.`);
       rest.splice(i, 2);
     }
   }
+  if (action === "share") {
+    const i = rest.indexOf("--for");
+    if (i >= 0) {
+      const value = rest[i + 1];
+      if (!["1h", "1d", "7d"].includes(value)) throw new Error("--for takes 1h, 1d or 7d.");
+      shot.duration = value;
+      rest.splice(i, 2);
+    }
+    const viewOnly = rest.indexOf("--view-only");
+    if (viewOnly >= 0) { shot.controls = false; rest.splice(viewOnly, 1); }
+  }
   if (action === "notes") {
     const i = rest.indexOf("--since");
     if (i >= 0) {
@@ -2656,7 +2668,7 @@ async function appRequest(action, body, { print = true } = {}) {
   if (action === "share") {
     const { type: _type, requestId: _requestId, ...link } = result;
     console.log(JSON.stringify({ ...link, expires: new Date(link.expiresAt).toISOString() }, null, 2));
-    console.error("Anyone with this link can use the app, including its live backend, until it expires or you revoke it (Apps → Revoke access).");
+    console.error("Anyone with this link can use the app, including its live backend, until it expires or the user stops sharing (Apps → Share → Stop sharing).");
     return;
   }
   if (print) console.log(JSON.stringify(result, null, 2));

package/dist/apps/gateway.js

@@ -132,6 +132,8 @@ const poll=async()=>{try{const r=await fetch(location.href,{method:'HEAD',cache:
 }
 /** Copied links are reusable until revoked, capped so a forgotten one lapses. */
 export const SHARE_TTL = 24 * HOUR;
+/** The longest a copied link may be asked to last. */
+export const SHARE_TTL_MAX = 7 * 24 * HOUR;
 /** Bivy's packaged apps load the client from their own scheme, so a preview
  * framed there has this ancestor instead of a web origin. (Node's URL gives
  * these "null" origins, so they cannot be configured as return origins.) */
@@ -204,9 +206,13 @@ export class AppGateway {
         ["/__bivy/styles.css", readFileSync(new URL("./styles.css", import.meta.url))],
     ]);
     /** `reviewer`: the browser session came from a copied (shared) link.
+     *  `viewOnly`: that link came without the reviewer tools.
      *  `embedded`: it runs framed inside a Bivy client (a third-party frame). */
     sessions = new Map();
     sockets = new Map();
+    /** Connections opened by people with a copied link, so Stop sharing can end
+     * theirs and leave the owner's. */
+    shared = new WeakSet();
     captureAfter = 0;
     capturing = false;
     displays = new WebSocketServer({ noServer: true, maxPayload: 1024 * 1024, perMessageDeflate: false });
@@ -255,11 +261,33 @@ export class AppGateway {
         return `${this.origin(id)}${OPEN_PATH}#${this.grant({ appId: id, expires: Date.now() + 60_000 })}`;
     }
     /** Public reviewers use the same isolated controls as the owner, but can
-     * only submit notes. Valid until revoked or SHARE_TTL. */
-    share(id) {
+     * only submit notes; without `controls` they only see the app. Valid until
+     * revoked, sharing stops, or `ttl` (SHARE_TTL by default). */
+    share(id, { ttl = SHARE_TTL, controls = true } = {}) {
         this.requireWeb(id);
-        const expiresAt = Date.now() + SHARE_TTL;
-        return { url: `${this.shellOrigin(id)}${OPEN_PATH}#${this.grant({ appId: id, expires: expiresAt, reusable: true })}`, expiresAt };
+        if (!Number.isFinite(ttl) || ttl <= 0 || ttl > SHARE_TTL_MAX)
+            throw new Error("A share link can last at most 7 days.");
+        const expiresAt = Date.now() + ttl;
+        return { url: `${this.shellOrigin(id)}${OPEN_PATH}#${this.grant({ appId: id, expires: expiresAt, reusable: true, ...(controls ? {} : { viewOnly: true }) })}`, expiresAt, controls };
+    }
+    /** Copied links that still work: how many, and when the last one lapses. */
+    sharing(id) {
+        this.sweep();
+        const links = [...this.tickets.values()].filter((grant) => grant.appId === id && grant.reusable);
+        return links.length ? { links: links.length, expiresAt: Math.max(...links.map((grant) => grant.expires)) } : undefined;
+    }
+    /** Ends every copied link and the browser sessions and connections opened
+     * from them. The owner's own previews keep working. */
+    unshare(id) {
+        for (const [key, grant] of this.tickets)
+            if (grant.appId === id && grant.reusable)
+                this.tickets.delete(key);
+        for (const [key, session] of this.sessions)
+            if (session.appId === id && session.reviewer)
+                this.sessions.delete(key);
+        for (const socket of this.sockets.get(id) ?? [])
+            if (this.shared.has(socket))
+                socket.destroy();
     }
     revoke(id) {
         for (const map of [this.tickets, this.sessions])
@@ -313,13 +341,15 @@ export class AppGateway {
         const session = token ? this.sessions.get(token) : undefined;
         return session?.appId === id ? session : undefined;
     }
-    authorize(req, id) { return this.session(req, id)?.expires; }
-    track(id, socket, expires) {
+    track(id, socket, session) {
+        const expires = session.expires;
         let sockets = this.sockets.get(id);
         if (!sockets) {
             sockets = new Set();
             this.sockets.set(id, sockets);
         }
+        if (session.reviewer)
+            this.shared.add(socket);
         if (sockets.has(socket))
             return;
         sockets.add(socket);
@@ -369,7 +399,7 @@ export class AppGateway {
             res.setHeader("Content-Type", "application/json");
             // Someone opening a shared link sees "Made with Bivy" under the app; the owner doesn't.
             const badge = grant.reusable && this.badge ? await this.badge().catch(() => true) : false;
-            res.end(JSON.stringify({ name: entry.app.name, origin: this.origin(id), returnTo: grant.returnTo, ...(grant.reusable ? { reviewer: true } : {}), ...(badge ? { badge: true } : {}), ...(entry.target.kind === "display" ? { inspect: false } : {}) }));
+            res.end(JSON.stringify({ name: entry.app.name, origin: this.origin(id), returnTo: grant.returnTo, ...(grant.reusable ? { reviewer: true } : {}), ...(grant.viewOnly ? { controls: false } : {}), ...(badge ? { badge: true } : {}), ...(entry.target.kind === "display" ? { inspect: false } : {}) }));
             return;
         }
         res.writeHead(404);
@@ -433,7 +463,7 @@ fetch('${REDEEM_PATH}',{method:'POST',headers:{'Content-Type':'text/plain'},body
             // A browser session never outlives the link that created it.
             const expires = Math.min(Date.now() + HOUR, grant.expires);
             const token = randomBytes(32).toString("hex");
-            this.sessions.set(token, { appId: id, expires, reviewer: grant.reusable === true, ...(embedded ? { embedded } : {}) });
+            this.sessions.set(token, { appId: id, expires, reviewer: grant.reusable === true, ...(grant.viewOnly ? { viewOnly: true } : {}), ...(embedded ? { embedded } : {}) });
             // Framed inside Bivy, the cookie is third-party: it must be SameSite=None,
             // and Partitioned keys it to Bivy's top-level site so no other site can use it.
             const scope = embedded ? "SameSite=None; Partitioned" : "SameSite=Lax";
@@ -442,16 +472,16 @@ fetch('${REDEEM_PATH}',{method:'POST',headers:{'Content-Type':'text/plain'},body
             res.end();
             return;
         }
-        const session = this.session(req, id), expires = session?.expires;
+        const session = this.session(req, id);
         // A home-screen visit without access goes through Bivy to sign in, then
         // comes back to the same page. Framed loads keep the plain message.
-        const signIn = !expires && req.method === "GET" && req.headers["sec-fetch-dest"] === "document" && req.url?.startsWith("/") ? this.signIn?.(entry, req.url) : undefined;
+        const signIn = !session && req.method === "GET" && req.headers["sec-fetch-dest"] === "document" && req.url?.startsWith("/") ? this.signIn?.(entry, req.url) : undefined;
         if (signIn) {
             res.writeHead(303, { location: signIn });
             res.end();
             return;
         }
-        if (!expires) {
+        if (!session) {
             res.writeHead(401);
             res.end("Preview access expired. Open a new preview link from Bivy.");
             return;
@@ -472,7 +502,7 @@ fetch('${REDEEM_PATH}',{method:'POST',headers:{'Content-Type':'text/plain'},body
             res.end();
             return;
         }
-        this.track(id, req.socket, expires);
+        this.track(id, req.socket, session);
         if (req.url.startsWith(`${REVISION_PATH}?`) && req.method === "GET") {
             this.revision(req, res, entry);
             return;
@@ -483,10 +513,16 @@ fetch('${REDEEM_PATH}',{method:'POST',headers:{'Content-Type':'text/plain'},body
         }
         if (req.url === INSPECTOR_PATH && req.method === "GET") {
             res.writeHead(200, { "content-type": "text/javascript; charset=utf-8", "cache-control": "no-store" });
-            res.end(inspectorScript(this.shellOrigin(id), session?.reviewer === true, session?.embedded === true));
+            res.end(inspectorScript(this.shellOrigin(id), session.reviewer === true && !session.viewOnly, session.embedded === true));
             return;
         }
         if (req.url === NOTES_PATH && req.method === "POST") {
+            // A view-only link shows the app and nothing else.
+            if (session.viewOnly) {
+                res.writeHead(403);
+                res.end();
+                return;
+            }
             await this.note(req, res, entry);
             return;
         }
@@ -880,13 +916,13 @@ fetch('${REDEEM_PATH}',{method:'POST',headers:{'Content-Type':'text/plain'},body
     }
     upgrade(req, socket, head) {
         const entry = this.entry(req);
-        const expires = entry && this.authorize(req, entry.view.id);
+        const session = entry && this.session(req, entry.view.id);
         const display = entry?.target.kind === "display";
-        if (!entry || !expires || (entry.target.kind !== "service" && !(display && req.url === DISPLAY_SOCKET_PATH)) || req.headers.origin !== this.origin(entry.view.id) || req.headers.upgrade?.toLowerCase() !== "websocket" || !req.url?.startsWith("/") || req.url.startsWith("//")) {
+        if (!entry || !session || (entry.target.kind !== "service" && !(display && req.url === DISPLAY_SOCKET_PATH)) || req.headers.origin !== this.origin(entry.view.id) || req.headers.upgrade?.toLowerCase() !== "websocket" || !req.url?.startsWith("/") || req.url.startsWith("//")) {
             socket.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n");
             return;
         }
-        this.track(entry.view.id, socket, expires);
+        this.track(entry.view.id, socket, session);
         if (display) {
             this.displaySocket(req, socket, head, entry);
             return;
@@ -898,7 +934,7 @@ fetch('${REDEEM_PATH}',{method:'POST',headers:{'Content-Type':'text/plain'},body
         upstream.setTimeout(10_000, () => upstream.destroy());
         upstream.on("upgrade", (response, peer, upstreamHead) => {
             peer.setTimeout(0);
-            this.track(entry.view.id, peer, expires);
+            this.track(entry.view.id, peer, session);
             const headers = cleanHeaders(response.headers);
             delete headers["set-cookie"];
             socket.write(`HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n${Object.entries(headers).filter(([, value]) => value !== undefined).map(([key, value]) => `${key}: ${value}\r\n`).join("")}\r\n`);

package/dist/apps/preview-shell.js

@@ -162,6 +162,8 @@ function show(data,launch){
     $('draft-text').maxLength=1000;
     $('send-errors').textContent='Leave a note…';
   }
+  // A view-only share link shows the app without Bivy's tools.
+  $('dock').hidden=data.controls===false;
   $('made-with').hidden=!data.badge;
   document.body.classList.toggle('badged',Boolean(data.badge));
   $('title').textContent=data.name;

package/dist/apps/remote-preview.js

@@ -65,11 +65,13 @@ export class RemotePreview {
             throw new Error("Preview delivery is unavailable. Reconnect the machine and try again.");
         return this.gateway.open(id, returnTo);
     }
-    share(id) {
+    share(id, options) {
         if (!this.available)
             throw new Error("Preview delivery is unavailable. Reconnect the machine and try again.");
-        return this.gateway.share(id);
+        return this.gateway.share(id, options);
     }
+    sharing(id) { return this.gateway?.sharing(id); }
+    unshare(id) { this.gateway?.unshare(id); }
     revoke(id) { this.gateway?.revoke(id); }
     address(id) { return this.available ? this.gateway.address(id) : undefined; }
     openDirect(id) {

package/dist/apps/service.js

@@ -1,3 +1,6 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import { SHARE_DURATIONS } from "./types.js";
 import { randomBytes } from "node:crypto";
 import { REVIEW_MODES, shouldReview, visualChange } from "./review.js";
 import fs from "node:fs";
@@ -73,6 +76,9 @@ export class AppService {
                     view.stats = structuredClone(entry.stats);
                 if (entry?.lastPath)
                     view.lastPath = entry.lastPath;
+                const sharing = this.gateway?.sharing?.(view.id);
+                if (sharing)
+                    view.sharing = sharing;
             }
         return { apps, previewAvailable: available };
     }
@@ -577,18 +583,21 @@ export class AppService {
         void server.pending?.then((termId) => this.terminals.close(termId)).catch(() => { });
         this.servers.delete(id);
     }
-    share(sessionId, appId, viewId) {
+    share(sessionId, appId, viewId, options = {}) {
         if (this.registry.requireView(sessionId, appId, viewId).view.kind !== "web")
             throw new Error("Only web views have preview links.");
         if (!this.gateway)
             throw new Error("Bivy's preview service is unavailable on this connection.");
-        return this.gateway.share(viewId);
+        const duration = options.duration === undefined ? undefined : SHARE_DURATIONS.find((row) => row.id === options.duration);
+        if (options.duration !== undefined && !duration)
+            throw new Error(`A share link lasts ${SHARE_DURATIONS.map((row) => row.id).join(", ")}.`);
+        return this.gateway.share(viewId, { ...(duration ? { ttl: duration.ms } : {}), controls: options.controls !== false });
     }
     /** `bivy app share`: mints a share link for a web view picked by app and/or
      * view ID or name, like `present` (default: the one opened last). */
     shareView(sessionId, input) {
         const entry = this.pickTarget(sessionId, input);
-        return { ...this.share(sessionId, entry.app.id, entry.view.id), appId: entry.app.id, viewId: entry.view.id, app: entry.app.name, view: entry.view.name };
+        return { ...this.share(sessionId, entry.app.id, entry.view.id, input), appId: entry.app.id, viewId: entry.view.id, app: entry.app.name, view: entry.view.name };
     }
     clearNotes(sessionId, appId, viewId) {
         this.registry.requireView(sessionId, appId, viewId);
@@ -623,6 +632,12 @@ export class AppService {
             throw new Error(`No web view called "${input.view}"${input.app ? ` in "${input.app}"` : ""}. Run bivy app list to see them.`);
         return found;
     }
+    /** Ends a view's share links and what people opened with them; the owner's previews and the app stay. */
+    unshare(sessionId, appId, viewId) {
+        this.registry.requireView(sessionId, appId, viewId);
+        this.gateway?.unshare?.(viewId);
+        return { ok: true };
+    }
     /** Ends every link, browser session and open connection for one view; the app stays. */
     revoke(sessionId, appId, viewId) {
         this.registry.requireView(sessionId, appId, viewId);

package/dist/apps/styles.css

@@ -3147,6 +3147,9 @@ p.setup-note .btn.link { min-height: 44px; margin-block: calc((1lh - 44px) / 2);
 .apps-empty strong { color: var(--ink); font-size: var(--text-base); }
 .apps-empty p { margin: 0; max-inline-size: 34ch; }
 .apps-foot { margin: 0; padding: 0 var(--space-1); color: var(--muted); font-size: var(--text-xs); line-height: var(--lh-xs); }
+/* Share sheet (AppAccess.tsx): the sharing status sits in the sheet, not at page edge. */
+.apps-sheet > .banner { border-radius: var(--radius-md); padding: var(--space-2) var(--space-3); }
+.apps-sheet > .settings-toggle-row { padding-inline: var(--space-1); }
 /* Peek: an app preview framed in a drawer over the chat (PreviewPeek.tsx). */
 .preview-peek { display: block; inline-size: 100%; block-size: 100%; border: 0; border-radius: var(--radius-md); background: var(--bg); }
 /* Share-sheet landing (ShareDestinationSheet.tsx): what was shared, then one

package/dist/apps/types.js

@@ -24,3 +24,11 @@ export function isAppReference(value) {
     const ref = value;
     return typeof ref.appId === "string" && /^[a-f0-9]{32}$/.test(ref.appId) && typeof ref.sessionId === "string" && ref.sessionId.length > 0 && typeof ref.name === "string" && ref.name.length <= 100;
 }
+/** How long a new share link works. Links live in the machine's memory, so a
+ * restart ends them sooner. Adding a choice means adding a row. */
+export const SHARE_DURATIONS = [
+    { id: "1h", label: "1 hour", ms: 3_600_000 },
+    { id: "1d", label: "1 day", ms: 86_400_000 },
+    { id: "7d", label: "7 days", ms: 7 * 86_400_000 },
+];
+export const DEFAULT_SHARE_DURATION = "1d";

package/dist/controllers/app-commands.js

@@ -34,9 +34,13 @@ export function createAppCommands(service, workspaceFor, published = () => { })
         "apps.notes": (msg) => service.notes(String(msg.sessionId), { app: typeof msg.appId === "string" ? msg.appId : undefined, view: typeof msg.view === "string" ? msg.view : undefined, since: typeof msg.since === "number" ? msg.since : undefined }),
         "apps.logs": (msg) => service.logs(String(msg.sessionId), String(msg.appId), String(msg.viewId)),
         // The app UI passes exact IDs; `bivy app share` passes an app and/or view by ID or name.
-        "apps.share": (msg) => typeof msg.viewId === "string" && typeof msg.appId === "string"
-            ? service.share(String(msg.sessionId), msg.appId, msg.viewId)
-            : service.shareView(String(msg.sessionId), { app: typeof msg.appId === "string" ? msg.appId : undefined, view: typeof msg.view === "string" ? msg.view : undefined }),
+        "apps.share": (msg) => {
+            const options = { duration: msg.duration, controls: msg.controls !== false };
+            return typeof msg.viewId === "string" && typeof msg.appId === "string"
+                ? service.share(String(msg.sessionId), msg.appId, msg.viewId, options)
+                : service.shareView(String(msg.sessionId), { app: typeof msg.appId === "string" ? msg.appId : undefined, view: typeof msg.view === "string" ? msg.view : undefined, ...options });
+        },
+        "apps.unshare": (msg) => service.unshare(String(msg.sessionId), String(msg.appId), String(msg.viewId)),
         "apps.revoke": (msg) => service.revoke(String(msg.sessionId), String(msg.appId), String(msg.viewId)),
         "apps.remove": (msg) => { service.remove(String(msg.sessionId), String(msg.appId)); return { ok: true }; },
     };

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/protocol/client-command-routes.js

@@ -3,7 +3,7 @@
 /** Direct-mode adapters for operations whose canonical implementation is the
  * client command registry. Relay and HTTP now differ only in framing. */
 export const CLIENT_COMMAND_ROUTES = [
-    ...["list", "publish", "offers", "adopt", "open", "logs", "shot", "input", "menu", "present", "showMe", "mute", "reviewMode", "annotate", "clearNotes", "agentNotes", "notes", "share", "revoke", "remove"].map((action) => ({ method: "post", path: `/api/apps/${action}`, kind: `apps.${action}` })),
+    ...["list", "publish", "offers", "adopt", "open", "logs", "shot", "input", "menu", "present", "showMe", "mute", "reviewMode", "annotate", "clearNotes", "agentNotes", "notes", "share", "unshare", "revoke", "remove"].map((action) => ({ method: "post", path: `/api/apps/${action}`, kind: `apps.${action}` })),
     { method: "post", path: "/api/artifacts/list", kind: "artifacts.list" },
     { method: "post", path: "/api/auth/credentials/native-preview", kind: "credentials.native.preview" },
     { method: "post", path: "/api/auth/credentials/native-import", kind: "credentials.native.import" },

package/dist/protocol/client-command-schemas.js

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright (c) 2026 Petter André Sjulstad
 import { Type } from "typebox";
+import { SHARE_DURATIONS } from "../apps/types.js";
 const request = { requestId: Type.Optional(Type.String()) };
 const session = { sessionId: Type.String() };
 const optionalSession = { sessionId: Type.Optional(Type.String()) };
@@ -31,7 +32,9 @@ export const CLIENT_COMMAND_SCHEMAS = {
     "apps.agentNotes": Type.Object({ ...request, ...session, appId: Type.String(), enabled: Type.Boolean() }),
     "apps.notes": Type.Object({ ...request, ...session, appId: Type.Optional(Type.String({ maxLength: 200 })), view: Type.Optional(Type.String({ maxLength: 200 })), since: Type.Optional(Type.Number()) }),
     "apps.logs": Type.Object({ ...request, ...session, appId: Type.String(), viewId: Type.String() }),
-    "apps.share": Type.Object({ ...request, ...session, appId: Type.Optional(Type.String({ maxLength: 200 })), viewId: Type.Optional(Type.String()), view: Type.Optional(Type.String({ maxLength: 200 })) }),
+    "apps.share": Type.Object({ ...request, ...session, appId: Type.Optional(Type.String({ maxLength: 200 })), viewId: Type.Optional(Type.String()), view: Type.Optional(Type.String({ maxLength: 200 })),
+        duration: Type.Optional(Type.Union(SHARE_DURATIONS.map((row) => Type.Literal(row.id)))), controls: Type.Optional(Type.Boolean()) }),
+    "apps.unshare": Type.Object({ ...request, ...session, appId: Type.String(), viewId: Type.String() }),
     "apps.revoke": Type.Object({ ...request, ...session, appId: Type.String(), viewId: Type.String() }),
     "apps.remove": Type.Object({ ...request, ...session, appId: Type.String() }),
     "credentials.native.preview": Type.Object({ ...request, label: Type.Optional(Type.String({ maxLength: 100 })) }),

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.2",
+  "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.",