@bivy/bivy 0.18.11-staging.1 → 0.18.11-staging.11

package/bin/acp-shim.mjs

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

package/bin/agent-manifest.json

@@ -22,7 +22,7 @@
       "hidden": false,
       "supportTier": "supported",
       "certification": "release-tested",
-      "testedVersion": "1.18.32",
+      "testedVersion": "1.18.33",
       "headlessFlags": [
         "run",
         "-s"
@@ -191,7 +191,7 @@
       "hidden": false,
       "supportTier": "supported",
       "certification": "release-tested",
-      "testedVersion": "1.0.41",
+      "testedVersion": "1.0.44",
       "headlessFlags": [
         "--always-approve",
         "-p",

package/bin/bivy.mjs

@@ -35,7 +35,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { randomBytes, createCipheriv, createDecipheriv, randomUUID, createHash, verify as cryptoVerify } from "node:crypto";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import vm from "node:vm";
-import { selectStaleSessions, sessionActivityMs } from "./prune-sessions.mjs";
+import { linkSessionWorktrees, selectStaleSessions, sessionActivityMs } from "./prune-sessions.mjs";
 import { nativeResumeRef, resolveSessionsLimit, truncateSavedSessions } from "./sessions-list.mjs";
 import { renderManagedBlock, upsertManagedBlock, removeManagedBlock, rcFileForShell } from "./shim-path.mjs";
 import { removeInstallAndState } from "./uninstall-paths.mjs";
@@ -1827,7 +1827,7 @@ function cmdCompletions(args = []) {
   const shell = (args[0] || "").toLowerCase();
   const commands = [
     "run", "runs", "sessions", "ls", "resume", "promote", "rename", "nodes", "agent", "agents", "agents:install", "shim", "takeover", "token", "exec",
-    "send", "attach", "suggest", "kill", "setup", "start", "stop", "restart", "status", "doctor", "diagnostics", "capabilities", "logs", "login", "logout", "signout", "provider", "model",
+    "send", "attach", "suggest", "delegate", "kill", "setup", "start", "stop", "restart", "status", "doctor", "diagnostics", "capabilities", "logs", "login", "logout", "signout", "provider", "model",
     "update", "update:log", "audit", "automation", "config", "plugin", "open", "service", "secrets", "voice", "link", "relay:setup",
     "github:connect", "github:app-create", "github:app-connect", "github:app-sync", "prune", "uninstall", "help", "version",
   ];
@@ -2462,6 +2462,125 @@ async function cmdSuggest(args = []) {
   console.log(c.green("Suggested in the chat. The user can start it in one tap."));
 }
 
+// Cross-agent / cross-machine delegation (docs/agent-delegation.md): hand a
+// self-contained task from this session to another agent, optionally on another
+// account machine, and get its answer back. Agent-agnostic — any agent with a
+// shell can call it — and meant for when the user asks for another agent/machine.
+const DELEGATE_USAGE = `Usage: bivy delegate "<task>" [--agent <id>] [--machine <name>] [--model <model>] [--repo owner/repo] [--wait [seconds]] [--json]
+       bivy delegate "<task>" --to <agent>[@<machine>],<agent>[@<machine>],… [--wait [seconds]]
+       bivy delegate machines [--json]
+       bivy delegate status <run-id> [--json]
+       bivy delegate wait <run-id> [--timeout <seconds>] [--json]
+
+Hands a self-contained task to another agent (and/or another machine on your account) as a
+delegated Run tied to this session ($BIVY_SESSION_ID). With --wait (or 'wait'), prints the
+child's final answer and any branch/PR it produced once it finishes. --to sends the same task
+to several agents/machines at once (up to 3) so the results can be compared.
+'machines' lists your machines and the agents installed on each.`;
+
+async function cmdDelegate(args = []) {
+  if (!args.length || args.some((a) => a === "-h" || a === "--help")) { console.log(DELEGATE_USAGE); return; }
+  const flagsWithValue = new Set(["--session", "--agent", "--machine", "--model", "--repo", "--timeout", "--to"]);
+  const flag = (name) => {
+    const i = args.indexOf(name);
+    return i >= 0 && i + 1 < args.length ? args[i + 1] : undefined;
+  };
+  const json = args.includes("--json");
+  const waitIndex = args.indexOf("--wait");
+  const waitArg = waitIndex >= 0 && /^\d+$/.test(args[waitIndex + 1] ?? "") ? args[waitIndex + 1] : undefined;
+  const positional = args.filter((a, i) => !a.startsWith("--") && !(i > 0 && flagsWithValue.has(args[i - 1])) && !(waitArg && i === waitIndex + 1));
+  const sessionId = resolveAttachSessionId({ sessionFlag: flag("--session"), env: process.env });
+  if (!sessionId) { console.error(c.red("No session id. Run inside an agent session ($BIVY_SESSION_ID) or pass --session <id>.")); process.exit(1); return; }
+  const config = loadConfig();
+  if (!(await ensureNodeRunning(config))) { console.error(c.red(`Could not reach the Bivy node at ${url(config)}.`)); process.exit(1); return; }
+  let token;
+  try { token = await localDeviceToken(config); } catch { token = undefined; }
+  const base = `${url(config)}/api/session/${encodeURIComponent(sessionId)}/delegated-runs`;
+  const call = async (path, body) => {
+    const res = await fetch(`${base}${path}`, {
+      method: body ? "POST" : "GET",
+      headers: { "content-type": "application/json", ...(token ? { authorization: `Bearer ${token}` } : {}) },
+      ...(body ? { body: JSON.stringify(body) } : {}),
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) throw new Error(data?.error || `HTTP ${res.status}`);
+    return data;
+  };
+  const terminal = (run) => ["succeeded", "failed", "cancelled"].includes(run?.status);
+  // The node caps one wait at 300s; loop until the child ends or our budget does.
+  const waitFor = async (runId, seconds) => {
+    const deadline = Date.now() + seconds * 1000;
+    let run = await call(`/${encodeURIComponent(runId)}`);
+    while (!terminal(run) && Date.now() < deadline) {
+      const slice = Math.max(1, Math.min(300, Math.ceil((deadline - Date.now()) / 1000)));
+      run = await call(`/${encodeURIComponent(runId)}/wait`, { timeoutSeconds: slice });
+    }
+    return run;
+  };
+  const print = (run) => {
+    if (json) { console.log(JSON.stringify(run, null, 2)); return; }
+    console.log(`Run ${run.runId}: ${run.status}${terminal(run) ? "" : " (still running — 'bivy delegate wait " + run.runId + "')"}`);
+    const refs = run.references || {};
+    if (refs.failure) console.log(`Failure: ${refs.failure}`);
+    if (refs.branch) console.log(`Branch: ${refs.branch}`);
+    if (refs.prUrl) console.log(`PR: ${refs.prUrl}`);
+    if (refs.sessionId) console.log(`Child session: ${refs.sessionId}`);
+    if (run.answer) console.log(`\nAnswer:\n${run.answer}`);
+  };
+  try {
+    const [action, runId] = positional;
+    if (action === "machines" && positional.length === 1) {
+      const res = await fetch(`${url(config)}/api/machines`, { headers: token ? { authorization: `Bearer ${token}` } : {} });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok) throw new Error(data?.error || `HTTP ${res.status}`);
+      if (json) { console.log(JSON.stringify(data.machines, null, 2)); return; }
+      for (const m of data.machines || []) {
+        const agents = m.agents ? m.agents.map((a) => a.id).join(", ") || "none" : m.error ? `unknown (${m.error})` : "unknown while offline";
+        console.log(`${m.name}${m.self ? " (this machine)" : ""} — ${m.online ? "online" : "offline"} — agents: ${agents}`);
+      }
+      return;
+    }
+    if (action === "status" && runId) return print(await call(`/${encodeURIComponent(runId)}`));
+    if (action === "wait" && runId) return print(await waitFor(runId, Number(flag("--timeout") ?? 600)));
+    const instructions = positional.join(" ").trim();
+    if (!instructions) { console.error(c.red(DELEGATE_USAGE)); process.exit(1); return; }
+    // Fan-out: the same task to several agent@machine targets, one group, so the
+    // parent's transcript shows them side by side to compare.
+    const to = flag("--to");
+    if (to) {
+      const targets = to.split(",").map((t) => t.trim()).filter(Boolean).map((t) => {
+        const [agent, machine] = t.split("@");
+        return { agent: agent ? governedChatAgentId(agent) : undefined, machine: machine || undefined, label: t };
+      });
+      const group = `fanout-${Date.now().toString(36)}`;
+      const runs = [];
+      for (const target of targets) {
+        runs.push({ target, run: await call("", { instructions, agent: target.agent, machine: target.machine, model: flag("--model"), repo: flag("--repo"), group }) });
+      }
+      if (waitIndex < 0) {
+        if (json) console.log(JSON.stringify(runs.map((r) => r.run), null, 2));
+        else for (const { target, run } of runs) console.log(`${target.label}: run ${run.runId} (${run.status})`);
+        return;
+      }
+      const finished = await Promise.all(runs.map(async ({ target, run }) => ({ target, run: await waitFor(run.runId, Number(waitArg ?? 600)) })));
+      if (json) { console.log(JSON.stringify(finished.map((f) => f.run), null, 2)); return; }
+      for (const { target, run } of finished) { console.log(`\n── ${target.label}`); print(run); }
+      return;
+    }
+    const agent = flag("--agent");
+    const started = await call("", { instructions, agent: agent ? governedChatAgentId(agent) : undefined, machine: flag("--machine"), model: flag("--model"), repo: flag("--repo") });
+    if (waitIndex < 0) {
+      if (!json) console.log(`Delegated as run ${started.runId} (${started.status}). Follow it with 'bivy delegate wait ${started.runId}'.`);
+      else print(started);
+      return;
+    }
+    print(await waitFor(started.runId, Number(waitArg ?? 600)));
+  } catch (error) {
+    console.error(c.red(`Delegate failed: ${error?.message || String(error)}`));
+    process.exit(1);
+  }
+}
+
 // Universal app publishing: every agent that can write JSON and run a command
 // uses the same contract. Relative static directories are manifest-relative.
 async function cmdApp(args = []) {
@@ -2472,7 +2591,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 +2637,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 +2677,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 +2787,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));
@@ -3037,6 +3168,11 @@ ${c.bold("bivy prune")} — remove old sessions, --clone workspaces, and git wor
   is never pruned while the node is running, regardless of --keep/--older-than —
   only idle worktrees are removed. If the node is down, nothing is live to guard.
 
+  A session and its worktree are removed together: pruning a worktree also
+  removes the sessions that ran in it, pruning a session also removes its
+  worktree (once no remaining session uses it), and sessions whose worktree is
+  already gone are removed — so no session is left pointing at a deleted checkout.
+
   Paths (default to the installed node)
     --data-dir <dir>      node data dir (default: this install's .bivy, or $BIVY_DATA_DIR)
     --workspace <dir>     also scan this workspace for worktrees (default: configured workspace)
@@ -3104,12 +3240,41 @@ async function cmdPrune(args = []) {
   const now = Date.now();
   const plan = [];
   let worktreeGuard = { reachable: false, protected: 0 };
-  if (doSessions) {
-    // Sessions live in the metadata index (all agents) plus each agent's own
-    // transcript store — not just .bivy/pi/sessions. Select from metadata so
-    // shim/native (Claude Code, Codex, …) sessions are actually covered; the old
-    // pi-sessions-only scan silently no-oped for every terminal-started session.
-    const staleSessions = selectStaleSessions(loadMetadataSessions(dataDir).sessions, keepFor("sessions"), ageMs, now);
+  // Sessions live in the metadata index (all agents) plus each agent's own
+  // transcript store — not just .bivy/pi/sessions. Select from metadata so
+  // shim/native (Claude Code, Codex, …) sessions are actually covered; the old
+  // pi-sessions-only scan silently no-oped for every terminal-started session.
+  const allSessions = loadMetadataSessions(dataDir).sessions;
+  const selectedSessions = doSessions ? selectStaleSessions(allSessions, keepFor("sessions"), ageMs, now) : [];
+  // Worktrees: keep the newest N overall (across all roots), matching the node
+  // prune script. Scan roots: the data dir plus the configured workspace repo.
+  const worktreeRoots = findWorktreeRoots([dataDir, workspace].filter(Boolean));
+  const staleWorktrees = doWorktrees ? selectStale(worktreeRoots.flatMap((r) => pruneListEntries(r, "dir")), keepFor("worktrees"), ageMs, now) : [];
+  // Guard: never delete a worktree a live agent is using. Ask the daemon what's
+  // live (it owns every runtime and PTY); protected worktrees drop out of the
+  // removal set entirely, so an aggressive --older-than can't nuke a running
+  // agent's checkout. Node down ⇒ nothing live ⇒ policy alone is safe.
+  const live = await liveWorktreePaths(config);
+  const isLive = (p) => isLiveWorktree(p, live.paths);
+  const idleWorktrees = staleWorktrees.filter((e) => !isLive(e.path));
+  worktreeGuard = { reachable: live.reachable, protected: staleWorktrees.length - idleWorktrees.length };
+  // A session and its worktree go together: removing one without the other left
+  // sessions pointing at a deleted checkout (or checkouts nobody can reach).
+  const linked = linkSessionWorktrees({
+    sessions: allSessions,
+    staleSessions: selectedSessions,
+    staleWorktrees: idleWorktrees.map((e) => e.path),
+    isLive,
+    exists: (p) => fs.existsSync(p),
+  });
+  const staleSessions = linked.sessions;
+  const worktreeMtime = new Map(idleWorktrees.map((e) => [path.resolve(e.path), e.mtimeMs]));
+  const worktreesToRemove = linked.worktrees.map((p) => {
+    let mtimeMs = worktreeMtime.get(p);
+    if (mtimeMs === undefined) { try { mtimeMs = fs.statSync(p).mtimeMs; } catch { mtimeMs = now; } }
+    return { path: p, mtimeMs };
+  }).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  if (doSessions || staleSessions.length) {
     plan.push({
       kind: "sessions",
       root: metadataFilePath(dataDir),
@@ -3132,20 +3297,8 @@ async function cmdPrune(args = []) {
     const dir = path.join(dataDir, "workspaces");
     plan.push({ kind: "workspaces", root: dir, remove: selectStale(pruneListEntries(dir, "dir"), keepFor("workspaces"), ageMs, now) });
   }
-  if (doWorktrees) {
-    // Keep the newest N worktrees overall (across all roots), matching the node
-    // prune script. Scan roots: the data dir plus the configured workspace repo.
-    const roots = findWorktreeRoots([dataDir, workspace].filter(Boolean));
-    const all = roots.flatMap((r) => pruneListEntries(r, "dir"));
-    const stale = selectStale(all, keepFor("worktrees"), ageMs, now);
-    // Guard: never delete a worktree a live agent is using. Ask the daemon what's
-    // live (it owns every runtime and PTY); protected worktrees drop out of the
-    // removal set entirely, so an aggressive --older-than can't nuke a running
-    // agent's checkout. Node down ⇒ nothing live ⇒ policy alone is safe.
-    const live = await liveWorktreePaths(config);
-    const remove = stale.filter((e) => !isLiveWorktree(e.path, live.paths));
-    worktreeGuard = { reachable: live.reachable, protected: stale.length - remove.length };
-    plan.push({ kind: "worktrees", root: roots.join(", ") || "(none found)", remove });
+  if (doWorktrees || worktreesToRemove.length) {
+    plan.push({ kind: "worktrees", root: worktreeRoots.join(", ") || "(none found)", remove: worktreesToRemove });
   }
   const total = plan.reduce((n, p) => n + p.remove.length, 0);
 
@@ -5456,6 +5609,9 @@ An agent's own --help passes through, e.g. 'bivy run claude --help'.`);
     case "suggest":
       await cmdSuggest(args);
       break;
+    case "delegate":
+      await cmdDelegate(args);
+      break;
     case "completions":
     case "completion":
       cmdCompletions(args);