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

package/bin/acp-shim.mjs

@@ -136,31 +136,9 @@ 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) {
@@ -212,9 +190,6 @@ 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" });
 }
@@ -247,11 +222,6 @@ 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,
@@ -289,60 +259,7 @@ 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.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);
+  return (state.kind && KIND_TOOL_NAME[state.kind]) || state.title || state.kind || "tool";
 }
 
 async function ensureInitialized() {
@@ -374,33 +291,24 @@ 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" }));
-  // 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);
+  if (!models.length) return;
+  modelConfigId = String(modelOption?.id ?? "model");
   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" || replayingHistory) return;
+  if (!u || typeof u !== "object") 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;
@@ -419,12 +327,12 @@ function onSessionUpdate(params) {
   switch (kind) {
     case "agent_message_chunk": {
       const t = textOf(u.content);
-      if (t && !child) bivy({ type: "message.delta", text: t });
+      if (t) bivy({ type: "message.delta", text: t });
       break;
     }
     case "agent_thought_chunk": {
       const t = textOf(u.content);
-      if (t && !child) bivy({ type: "message.reasoning", text: t });
+      if (t) bivy({ type: "message.reasoning", text: t });
       break;
     }
     case "tool_call": {
@@ -432,14 +340,12 @@ 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);
-      if (!child) ownCalls.set(toolCallId, state);
-      bivy({ type: "tool.observe", toolCallId, name: toolCallName(state), input: toolCallInput(state), ...nest });
+      bivy({ type: "tool.observe", toolCallId, name: toolCallName(state), input: toolCallInput(state) });
       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);
@@ -456,18 +362,17 @@ 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), ...nest });
+        bivy({ type: "tool.update", toolCallId, name: toolCallName(state), input: toolCallInput(state) });
       }
       break;
     }
     case "plan":
       // Optional planning stream — fold into reasoning so nothing is lost.
-      if (!child && Array.isArray(u.entries)) bivy({ type: "message.reasoning", text: u.entries.map((e) => `• ${e.content ?? ""}`).join("\n") });
+      if (Array.isArray(u.entries)) bivy({ type: "message.reasoning", text: u.entries.map((e) => `• ${e.content ?? ""}`).join("\n") });
       break;
     default:
       break;
@@ -486,9 +391,7 @@ 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);
-      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 } : {}) });
+      bivy({ type: "tool.call", toolCallId, name: toolCallName(state), input: toolCallInput(state) });
       return;
     }
     case "fs/read_text_file": {
@@ -510,15 +413,9 @@ 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 ?? "") });
-        const parentCall = childRoute(params?.sessionId);
-        bivy({ type: "tool.call", toolCallId, name: "write", input: { path: file }, ...(parentCall ? { parentToolCallId: parentCall } : {}) });
+        bivy({ type: "tool.call", toolCallId, name: "write", input: { path: file } });
       } catch (e) {
         agentReplyError(id, -32000, `write failed: ${e.message}`);
       }
@@ -552,7 +449,6 @@ 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);
 });
 
 /**
@@ -611,14 +507,7 @@ 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…".
-          // 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; }
+          const res = await agentRequest("session/load", { sessionId: ref, cwd, mcpServers }, { timeoutMs: 30_000 });
           sessionId = res?.sessionId ?? ref;
           publishModels(res);
         } catch (error) {
@@ -665,22 +554,16 @@ async function onBivyCommand(msg) {
           permissionRequests.delete(msg.toolCallId);
           const allow = msg.decision !== "deny";
           if (entry.kind === "fs-write") {
-            // 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 (!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}`); }
             }
-            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 } });
@@ -701,15 +584,6 @@ 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.33",
+      "testedVersion": "1.18.32",
       "headlessFlags": [
         "run",
         "-s"
@@ -191,7 +191,7 @@
       "hidden": false,
       "supportTier": "supported",
       "certification": "release-tested",
-      "testedVersion": "1.0.44",
+      "testedVersion": "1.0.41",
       "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 { linkSessionWorktrees, selectStaleSessions, sessionActivityMs } from "./prune-sessions.mjs";
+import { 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", "delegate", "kill", "setup", "start", "stop", "restart", "status", "doctor", "diagnostics", "capabilities", "logs", "login", "logout", "signout", "provider", "model",
+    "send", "attach", "suggest", "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,131 +2462,6 @@ 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] [--approval never|risky|always|autonomous] [--sandbox <tier>] [--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", "--approval", "--sandbox"]);
-  // Children inherit this session's approval/sandbox unless set here.
-  const safetyFlags = () => {
-    const safety = { approval: flag("--approval"), sandbox: flag("--sandbox") };
-    return safety.approval || safety.sandbox ? { safety } : {};
-  };
-  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;
-  };
-  // needs_attention = parked by the machine's policy; it won't move on its own.
-  const terminal = (run) => ["succeeded", "failed", "cancelled", "needs_attention"].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"), ...safetyFlags(), 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"), ...safetyFlags() });
-    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 = []) {
@@ -3174,11 +3049,6 @@ ${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)
@@ -3246,41 +3116,12 @@ async function cmdPrune(args = []) {
   const now = Date.now();
   const plan = [];
   let worktreeGuard = { reachable: false, protected: 0 };
-  // 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) {
+  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);
     plan.push({
       kind: "sessions",
       root: metadataFilePath(dataDir),
@@ -3303,8 +3144,20 @@ 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 || worktreesToRemove.length) {
-    plan.push({ kind: "worktrees", root: worktreeRoots.join(", ") || "(none found)", remove: worktreesToRemove });
+  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 });
   }
   const total = plan.reduce((n, p) => n + p.remove.length, 0);
 
@@ -5615,9 +5468,6 @@ An agent's own --help passes through, e.g. 'bivy run claude --help'.`);
     case "suggest":
       await cmdSuggest(args);
       break;
-    case "delegate":
-      await cmdDelegate(args);
-      break;
     case "completions":
     case "completion":
       cmdCompletions(args);

package/bin/prune-sessions.mjs

@@ -9,8 +9,6 @@
 // not just Pi's `.bivy/pi/sessions`. Prune selects from that index; these helpers
 // decide which entries are stale. No I/O here on purpose.
 
-import path from "node:path";
-
 // Mirrors the server's isEmptyUntitledSummary: a session with no real title, no
 // first message and no messages is the hidden "Untitled" noise the sidebar filters
 // out. Keep-N protects only *real* sessions; empties are always eligible.
@@ -32,42 +30,6 @@ export function sessionActivityMs(s) {
   return 0;
 }
 
-// A Bivy-managed worktree lives at <repo>/.bivy/worktrees/<slug>. Only those are
-// ever removed on a session's behalf — never an arbitrary path a record names.
-export function isManagedWorktreePath(p) {
-  const parts = path.resolve(String(p ?? "")).split(path.sep);
-  return parts.length >= 3 && parts[parts.length - 3] === ".bivy" && parts[parts.length - 2] === "worktrees";
-}
-
-// Sessions and their worktrees are pruned as one unit, so neither outlives the
-// other. Selection runs per kind (sessions and worktrees have different keep
-// counts), then this links the two removal sets:
-//   - a session goes when its worktree goes, or when its worktree is already
-//     gone from disk (a session that can no longer open its checkout);
-//   - a worktree goes when every session using it goes (and no live agent holds it).
-// Live ("working") sessions are never added, and their worktree is never removed. `isLive(path)` / `exists(path)` are
-// the caller's I/O; paths are compared resolved. Returns the widened sets.
-export function linkSessionWorktrees({ sessions, staleSessions, staleWorktrees, isLive = () => false, exists = () => true }) {
-  const removeSessions = new Map(staleSessions.map((s) => [s.id, s]));
-  const removeWorktrees = new Set(staleWorktrees.map((p) => path.resolve(p)));
-  const byWorktree = new Map();
-  for (const s of sessions) {
-    if (!s.worktree || !isManagedWorktreePath(s.worktree)) continue;
-    const wt = path.resolve(s.worktree);
-    byWorktree.set(wt, [...(byWorktree.get(wt) ?? []), s]);
-  }
-  for (const [wt, owners] of byWorktree) {
-    if (owners.some((s) => s.status === "working")) removeWorktrees.delete(wt);
-    else if (exists(wt) && owners.every((s) => removeSessions.has(s.id)) && !isLive(wt)) removeWorktrees.add(wt);
-  }
-  for (const [wt, owners] of byWorktree) {
-    if (!removeWorktrees.has(wt) && exists(wt)) continue;
-    for (const s of owners) if (s.status !== "working") removeSessions.set(s.id, s);
-  }
-  const sorted = [...removeSessions.values()].sort((a, b) => sessionActivityMs(b) - sessionActivityMs(a));
-  return { sessions: sorted, worktrees: [...removeWorktrees] };
-}
-
 // Removal set for sessions. Live ("working") sessions are never touched. The
 // newest `keep` NON-EMPTY sessions (across every agent) survive; empty/untitled
 // sessions are always beyond the keep window. An item is removed only when it is

package/dist/agent-instructions.js

@@ -42,10 +42,6 @@ export const BIVY_AGENT_NOTE = [
         '`bivy suggest "<complete instruction>" [--title "short label"]` instead of only listing them. The user can ' +
         "start each in one tap, in this session or in a parallel one that works in its own copy of the project, so " +
         "write it to stand on its own, with paths relative to the project root.",
-    "- Only when the user asks for another agent or another of their machines to take part: " +
-        '`bivy delegate "<self-contained task>" --agent <id> [--machine <name>] --wait` runs it there and prints ' +
-        "its answer and any branch/PR; `--to codex,grok@<machine>` asks several to compare, `bivy delegate machines` " +
-        "lists machines and their agents. Use your own sub-agents for everything else.",
 ].join("\n");
 const PREAMBLE = "The user's global Bivy instructions follow. They apply to every workspace; where they conflict with " +
     "instructions from the current repository (AGENTS.md, CLAUDE.md, …), the repository's instructions win.";

package/dist/agents/claude-code/integration.js

@@ -4,7 +4,7 @@ import { defineAgentIntegration } from "../definition.js";
 import { withExactCapabilitySurface } from "../../runtime/types.js";
 import { createCredentialStore } from "../../runtime/credentials.js";
 import { ClaudeCodeRuntime, claudeRuntimeFromEnv, claudeSdkInstalled, } from "./runtime.js";
-export const CLAUDE_TESTED_VERSION = "0.3.284";
+export const CLAUDE_TESTED_VERSION = "0.3.281";
 const CLAUDE_CAPABILITIES = withExactCapabilitySurface({
     toolInterception: true,
     modelSelection: true,