@bivy/bivy 0.20.7-staging.2 → 0.20.7-staging.3

package/dist/runtime/tool-call-map.js

@@ -190,18 +190,57 @@ export function mapToolCall(toolName, input, context = {}) {
         return decorate({ kind: "plan", ...(str(o, "plan", "text", "content", "message") ? { text: str(o, "plan", "text", "content", "message") } : {}) }, toolName, input, context);
     }
     if (inToolSet(DELEGATE, toolName, key)) {
-        const label = str(o, "subagent_type", "subagentType", "agent", "agentType", "role", "name");
+        const label = str(o, "subagent_type", "subagentType", "agent", "agentType", "role", "name", "task_name", "taskName");
         const description = str(o, "description", "task", "prompt", "instructions", "goal", "message");
         return decorate({ kind: "delegation", ...(label ? { label } : {}), ...(description ? { description } : {}) }, toolName, input, context);
     }
     return undefined;
 }
+/** The text of MCP-style content blocks (`[{type:"text",text}]`), the shape
+ * Claude, Pi and most MCP tools return. Undefined when there is no text block,
+ * so image-only or unknown payloads keep their JSON form. */
+function blockText(content) {
+    if (!Array.isArray(content))
+        return undefined;
+    const texts = content
+        .map((block) => asRecord(block))
+        .filter((block) => block.type === "text" && typeof block.text === "string")
+        .map((block) => block.text);
+    return texts.length ? texts.join("\n") : undefined;
+}
+/** Harness frames an agent wraps around a sub-agent's report before handing it
+ * to the model. The user should read the report, not the frame. Each row
+ * matches the frame's opening (and closing, if any) and how the report inside
+ * is indented. */
+const SUBAGENT_REPORT_FRAMES = [
+    // Claude Code 2.1.28x: "[Subagent hand-back] … The report follows:\n  <report>"
+    { header: /^\[Subagent hand-back\][^\n]*The report follows:\n/, indent: "  " },
+    // OpenCode's task tool: <task id=… state=…>\n<task_result>\n<report>\n</task_result>\n</task>
+    { header: /^<task\b[^>\n]*>\s*<task_result>\n?/, footer: /\n?<\/task_result>\s*<\/task>\s*$/, indent: "" },
+];
+function unwrapSubagentReport(text) {
+    for (const frame of SUBAGENT_REPORT_FRAMES) {
+        const match = frame.header.exec(text);
+        if (!match)
+            continue;
+        const inner = text.slice(match[0].length);
+        const body = frame.footer ? inner.replace(frame.footer, "") : inner;
+        if (!frame.indent)
+            return body;
+        return body
+            .split("\n")
+            .map((line) => (line.startsWith(frame.indent) ? line.slice(frame.indent.length) : line))
+            .join("\n");
+    }
+    return text;
+}
 export function mapToolResult(result, isError = false) {
     const o = asRecord(result);
+    const structured = asRecord(o.structuredContent ?? o.details);
     const content = o.content ?? o.output ?? o.text ?? o.aggregated_output ?? result;
-    const rawText = typeof content === "string" ? content : content == null ? "" : JSON.stringify(boundedToolPayload(content));
+    const rawText = unwrapSubagentReport(typeof content === "string" ? content : content == null ? "" : blockText(content) ?? JSON.stringify(boundedToolPayload(content)));
     const text = rawText.length > RAW_LIMIT ? rawText.slice(0, RAW_LIMIT) : rawText;
-    const exit = o.exitCode ?? o.exit_code ?? o.code;
+    const exit = o.exitCode ?? o.exit_code ?? o.code ?? structured.exitCode ?? structured.exit_code;
     return {
         ...(text ? { text } : {}),
         ...(typeof exit === "number" ? { exitCode: exit } : {}),
@@ -209,3 +248,28 @@ export function mapToolResult(result, isError = false) {
         ...(rawText.length > RAW_LIMIT ? { truncated: true } : {}),
     };
 }
+/**
+ * Fill in `detail` on tool_use blocks that lack it. Live tool events carry a
+ * detail, but a transcript reloaded from an agent's own store (a native session
+ * taken over, a reopened rollout) has bare blocks, which the client can only
+ * label generically. Messages without such blocks are returned as they were.
+ */
+export function withToolDetails(messages, provider = "unknown") {
+    return messages.map((message) => {
+        const content = message?.content;
+        if (!Array.isArray(content))
+            return message;
+        let changed = false;
+        const next = content.map((block) => {
+            const b = block;
+            if (b?.type !== "tool_use" || b.detail || typeof b.name !== "string")
+                return block;
+            const detail = mapToolCall(b.name, b.input, { provider, protocol: "unknown" });
+            if (!detail)
+                return block;
+            changed = true;
+            return { ...b, detail };
+        });
+        return changed ? { ...message, content: next } : message;
+    });
+}

package/dist/server.js

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright (c) 2026 Petter André Sjulstad
+// First: drop agent-session markers the node inherited before anything reads them.
+import "./node-env.js";
 import fs from "node:fs";
 import { createNodeUpdateChecker, managedInstall, updateRegistryUrl } from "./node-update.js";
 import { createRemoteSessionAdmission, RemoteSessionAdmissionError } from "./session/remote-session-admission.js";
@@ -69,7 +71,7 @@ import { isNativeOAuthProvider, loginModelOAuth } from "./runtime/oauth/model-oa
 import { decideOAuthLoginSweep } from "./runtime/oauth/oauth-login-sweep.js";
 import { listCodexSessions, loadCodexTranscript } from "./runtime/codex-sessions.js";
 import { dedupeSessionSummaries } from "./session-identity.js";
-import { listNativePiSessions } from "./agents/pi/integration.js";
+import { listNativePiSessions, piAgentDir } from "./agents/pi/integration.js";
 import { deriveSessionState } from "./session/session-state.js";
 import { resolveStreamingBehavior } from "./session/record.js";
 import { createSessionEngine } from "./session/engine.js";
@@ -149,7 +151,7 @@ import { MetadataStore } from "./metadata.js";
 import { resolveResumeRef, resumeRefFor, storedResumeRef } from "./session-ref.js";
 import { materializeFork } from "./session/fork.js";
 import { applyDirtyPatch } from "./session/fork-dirty.js";
-import { normalizeMessages } from "./session/transcript-normal.js";
+import { lastTranscriptModel, normalizeMessages } from "./session/transcript-normal.js";
 import { buildNativeImportSeedPrompt } from "./session/native-import.js";
 import { EventLog } from "./session/event-log.js";
 import { SessionEventSequencer } from "./session/event-sequencer.js";
@@ -281,6 +283,9 @@ const piDir = path.join(appDir, "pi");
 // the plaintext auth.json its native TUI reads, and its sessions.
 const credsDir = path.join(appDir, "credentials");
 const sessionsDir = path.join(piDir, "sessions");
+// Where a path-based session may be resumed from: Bivy's own Pi sessions, and
+// the native Pi store `bivy run pi` writes to (taken over or opened as chat).
+const resumeRoots = [sessionsDir, path.join(piAgentDir(), "sessions")];
 const intermediateMessagesDir = path.join(appDir, "intermediate-messages");
 const toolActivitiesDir = path.join(appDir, "tool-activities");
 // One append-only per-session log.
@@ -5189,6 +5194,13 @@ async function reconcileInterruptedSessions() {
             const record = await resolveOrResumeSession(id, meta.path);
             if (!record)
                 continue; // transcript gone / unresolvable — nothing to resume
+            // "Pick up where you left off" needs a conversation to pick up. A native
+            // terminal session whose agent kept no transcript reopens empty, and the
+            // prompt would only start a confused turn with no context.
+            if (!transcripts.conversationMessages(record).length) {
+                console.log(`[resume] skipped ${id}: no conversation to resume`);
+                continue;
+            }
             await runSessionTurn(record, buildInteractiveResumePrompt());
         }
         catch (error) {
@@ -6446,9 +6458,14 @@ async function applyRequestedModel(record, model) {
     if (!model)
         return;
     try {
+        // Protocol agents only publish their catalog once running. A fork or a new
+        // session asks for its model before that, so warm the catalog first or the
+        // choice is dropped and the agent's default model answers instead.
+        if (!(await record.session.getModels()).length && record.session.warmModels) {
+            await record.session.warmModels().catch(() => { });
+        }
         // 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.
+        // session's catalog; 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();
@@ -8399,7 +8416,7 @@ function fastHistoryEvent(msg) {
         if (!ref)
             return null;
         const runtimeId = agentFrom(msg) ?? meta?.runtimeId;
-        const file = resolveResumeRef({ ref, resumesByPath: runtimeResumesByPath(runtimeId), sessionsDir });
+        const file = resolveResumeRef({ ref, resumesByPath: runtimeResumesByPath(runtimeId), sessionsDir: resumeRoots });
         const rt = getRuntime(runtimeId);
         // Prefer the runtime's build-free read (pi/claude-code); otherwise use the
         // transcript Bivy persisted itself, so process agents (Codex, generic CLIs)
@@ -8619,7 +8636,7 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
     // refs could likewise resume the wrong id. Explicit path refs remain unchanged.
     const durableRef = requestedRef ? storedResumeRef(requestedRef, requestedMeta) : undefined;
     const requestedSessionFile = durableRef
-        ? resolveResumeRef({ ref: durableRef, resumesByPath: runtimeResumesByPath(refRuntimeId), sessionsDir })
+        ? resolveResumeRef({ ref: durableRef, resumesByPath: runtimeResumesByPath(refRuntimeId), sessionsDir: resumeRoots })
         : undefined;
     const storedMeta = requestedSessionFile ? metadata.getSession(requestedSessionFile) : undefined;
     const restoredWorktree = requestedSessionFile ? restoredWorktreeFromMetadata(storedMeta) : undefined;
@@ -8860,6 +8877,13 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
             // Best-effort; never block session creation.
         }
     }
+    // A resumed session with no model of its own keeps the one its transcript
+    // last answered with, instead of silently switching to the agent's default.
+    if (requestedSessionFile && !record.session.getCurrentModel()) {
+        const model = lastTranscriptModel(record.session.getMessages());
+        if (model)
+            await record.session.setModel(model.provider, model.id).catch(() => undefined);
+    }
     rememberSession(record);
     rememberWorkspace(sessionWorkspace);
     attachSessionListeners(record);
@@ -8938,7 +8962,7 @@ async function resolveOrResumeSession(sessionId, sessionPath) {
     const resumesByPath = runtimeResumesByPath(runtimeId);
     let key;
     try {
-        key = resolveResumeRef({ ref, resumesByPath, sessionsDir });
+        key = resolveResumeRef({ ref, resumesByPath, sessionsDir: resumeRoots });
     }
     catch (error) {
         // The sessions-dir path-traversal guard rejected this ref (path-based
@@ -9293,13 +9317,23 @@ const forkStandUp = createForkStandUp({
     applyDirtyPatch,
     gitRepoRoot,
     materializeFork,
-    saveForkTranscript: (markdown) => {
-        // Outside the worktree, so the hand-off never shows up as a repo change.
-        const dir = path.join(appDir, "fork-transcripts");
-        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-        const file = path.join(dir, `${new Date().toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}.md`);
-        fs.writeFileSync(file, markdown, { mode: 0o600 });
-        return file;
+    saveForkTranscript: (markdown, cwd) => {
+        // In the fork's own `.bivy/` (git-excluded, like its worktrees), so the
+        // agent can read it even when sandboxed to its workspace, and it never
+        // shows up as a repo change. The node's data dir is the fallback.
+        const name = `fork-transcript-${new Date().toISOString().replace(/[:.]/g, "-")}-${randomUUID().slice(0, 8)}.md`;
+        for (const dir of [path.join(cwd, ".bivy"), path.join(appDir, "fork-transcripts")]) {
+            try {
+                fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+                const file = path.join(dir, name);
+                fs.writeFileSync(file, markdown, { mode: 0o600 });
+                return file;
+            }
+            catch {
+                // try the next place
+            }
+        }
+        return undefined;
     },
     getRuntime,
     listRuntimes,
@@ -10709,7 +10743,7 @@ app.get("/api/multiplexers", async (_req, res) => {
 // runtimes (`codex` or governed `codex-approvals`), while this endpoint stays a
 // safe read-side view plus a `codex resume <id>` terminal handoff.
 app.get("/api/codex/sessions", (_req, res) => {
-    const sessions = listCodexSessions().map((s) => ({
+    const sessions = listCodexSessions().filter((s) => !s.parentThreadId).map((s) => ({
         id: s.id,
         cwd: s.cwd,
         createdAt: s.createdAt,

package/dist/session/event-log.js

@@ -180,20 +180,91 @@ export function mergeBases(logged, runtime) {
             loggedTexts.set(text, (loggedTexts.get(text) ?? 0) - n);
         return true;
     };
+    // The runtime's order, as either a message the merged list already has (its
+    // anchor) or one only the runtime had (fresh). Placement below uses it.
+    const sequence = [];
+    let byAtom; // first logged message holding each atom, built on first use
+    const anchorOf = (m) => {
+        if (!byAtom) {
+            byAtom = new Map();
+            for (const other of merged) {
+                const theirs = messageContentAtoms(other);
+                for (const atom of [...theirs.toolIds, ...theirs.texts])
+                    if (!byAtom.has(atom))
+                        byAtom.set(atom, other);
+            }
+        }
+        const atoms = messageContentAtoms(m);
+        for (const atom of [...atoms.toolIds, ...atoms.texts]) {
+            const found = byAtom.get(atom);
+            if (found)
+                return found;
+        }
+        return undefined;
+    };
     for (const m of runtime) {
         const key = JSON.stringify(m);
-        if (known.has(key))
+        if (known.has(key)) {
+            sequence.push({ anchor: merged[keys.indexOf(key)] });
             continue;
+        }
         const identity = identityOf(m);
         if (identity && identities.has(identity)) {
             add(m);
+            sequence.push({ anchor: m });
             continue;
         } // streaming refinement of a known turn
-        if (coveredByLogged(m))
-            continue; // reopen re-serialization already in the base
-        add(m); // a genuinely new (resumed) turn
+        if (coveredByLogged(m)) { // reopen re-serialization already in the base
+            const anchor = anchorOf(m);
+            if (anchor)
+                sequence.push({ anchor });
+            continue;
+        }
+        if (add(m))
+            sequence.push({ fresh: m }); // not in the logged base
+    }
+    return placeFresh(merged, sequence);
+}
+/**
+ * Put messages only the runtime had where they happened, not at the end. A
+ * reload can carry turns or detail the logged base never stored (a native run
+ * taken over as a chat; a Codex rollout's tool calls under a text-only base):
+ * appended, they land after turns that came later. Each goes right before the
+ * next message the runtime shares with the base, else right after the previous
+ * one. With nothing shared to anchor to, its timestamp places it, and a message
+ * with neither (or a genuinely new turn) goes last.
+ */
+function placeFresh(merged, sequence) {
+    const freshSet = new Set(sequence.flatMap((item) => ("fresh" in item ? [item.fresh] : [])));
+    if (!freshSet.size)
+        return merged;
+    const timeOf = (m) => {
+        const t = m.timestamp;
+        return typeof t === "number" && Number.isFinite(t) ? t : undefined;
+    };
+    const placed = merged.filter((m) => !freshSet.has(m));
+    let previous; // last anchor seen, or last fresh placed after it
+    for (let i = 0; i < sequence.length; i++) {
+        const item = sequence[i];
+        if ("anchor" in item) {
+            previous = item.anchor;
+            continue;
+        }
+        const next = sequence.slice(i + 1).find((later) => "anchor" in later)?.anchor;
+        let at;
+        if (previous && placed.includes(previous))
+            at = placed.indexOf(previous) + 1;
+        else if (next && placed.includes(next))
+            at = placed.indexOf(next);
+        else {
+            const t = timeOf(item.fresh);
+            const later = t === undefined ? -1 : placed.findIndex((other) => (timeOf(other) ?? -Infinity) > t);
+            at = later < 0 ? placed.length : later;
+        }
+        placed.splice(at, 0, item.fresh);
+        previous = item.fresh;
     }
-    return merged;
+    return placed;
 }
 /** Content-block type carried by a folded outbound attachment. MUST match
  *  `AGENT_ATTACHMENT_BLOCK` in packages/core/src/store-render.ts — the client's

package/dist/session/fork-standup.js

@@ -202,7 +202,7 @@ export function createForkStandUp(deps) {
                 }
                 if (applied.warning)
                     dirtyWarning = applied.warning;
-                workspace = forkRepoRoot;
+                workspace = wt.repoRoot;
                 cwd = wt.path;
                 worktree = wt;
             }

package/dist/session/fork.js

@@ -1,4 +1,4 @@
-import { normalizeMessages, buildSeedPrompt, buildForkHistory, renderForkTranscript, } from "./transcript-normal.js";
+import { normalizeMessages, buildSeedPrompt, buildForkHistory, relocateTranscript, renderForkTranscript, } from "./transcript-normal.js";
 /** Cap on the display transcript a bundle carries; larger sessions fall back to
  *  showing the destination agent's own (text) replay. */
 export const FORK_DISPLAY_MAX_BYTES = 2 * 1024 * 1024;
@@ -91,6 +91,8 @@ export function resolveForkFidelity(bundle, targetRuntime) {
 export async function materializeFork(opts) {
     const { bundle, targetRuntime, ctx } = opts;
     const intended = resolveForkFidelity(bundle, targetRuntime);
+    // The portable history as it reads from the fork's own working directory.
+    const normalized = relocateTranscript(bundle.normalized, bundle.record.cwd, ctx.cwd);
     const validImport = (result) => typeof result?.sessionFile === "string" && result.sessionFile.trim().length > 0 &&
         typeof result.id === "string" && result.id.trim().length > 0;
     // Native transport is the preferred same-runtime route, but never a single
@@ -113,7 +115,7 @@ export async function materializeFork(opts) {
         typeof targetRuntime.importHistoryForFork === "function";
     if (canReplay) {
         try {
-            const history = buildForkHistory(bundle.normalized);
+            const history = buildForkHistory(normalized);
             if (history.length > 0) {
                 const imported = await targetRuntime.importHistoryForFork(history, ctx);
                 if (validImport(imported))
@@ -128,12 +130,12 @@ export async function materializeFork(opts) {
     // its tools can read — an app URL is a web page it can't fetch.
     let transcriptFile;
     try {
-        transcriptFile = opts.saveTranscript?.(renderForkTranscript(bundle.normalized));
+        transcriptFile = opts.saveTranscript?.(renderForkTranscript(normalized), ctx.cwd);
     }
     catch {
         transcriptFile = undefined;
     }
-    const seedPrompt = buildSeedPrompt(bundle.normalized, {
+    const seedPrompt = buildSeedPrompt(normalized, {
         targetAgent: targetRuntime.displayName,
         context: { repoSlug: bundle.record.repoSlug, branch: bundle.record.branch, prUrl: bundle.record.prUrl },
         ...(transcriptFile ? { transcriptFile } : {}),

package/dist/session/transcript-normal.js

@@ -1,5 +1,36 @@
 import { handoffSeedOf } from "./handoff-seed.js";
 import { applyPlanUpdate, planChecklist, planUpdateOf } from "./plan.js";
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * The transcript as it reads from a new working directory. A fork runs in its
+ * own copy of the workspace, but the history names files at the source's
+ * paths, and an agent that follows them edits the original checkout. Rewrite
+ * the source directory to the fork's wherever it appears as a path.
+ */
+export function relocateTranscript(transcript, from, to) {
+    const source = from?.replace(/\/+$/, "");
+    const target = to?.replace(/\/+$/, "");
+    if (!source || !target || source === target)
+        return transcript;
+    const pattern = new RegExp(`${escapeRegExp(source)}(?=$|[/\\s"'\`)\\],:;])`, "g");
+    const move = (text) => text.replace(pattern, target);
+    return {
+        ...transcript,
+        turns: transcript.turns.map((turn) => ({
+            ...turn,
+            text: move(turn.text),
+            ...(turn.toolSummary ? { toolSummary: move(turn.toolSummary) } : {}),
+        })),
+        ...(transcript.plan ? { plan: transcript.plan.map((entry) => ({ ...entry, text: move(entry.text) })) } : {}),
+        workspace: { from: source, to: target },
+    };
+}
+/** One line telling the new agent where the work lives now. */
+function workspaceNote(workspace) {
+    return `This conversation now continues in ${workspace.to}, a separate copy of ${workspace.from} where the earlier work happened. Paths above already point at the copy; work there.`;
+}
 /** Cap a tool payload down to a short, log-safe one-liner. */
 function compactValue(value, max = 200) {
     let s;
@@ -209,6 +240,7 @@ export function buildSeedPrompt(transcript, opts = {}) {
         opts.context?.repoSlug ? `Repository: ${opts.context.repoSlug}` : null,
         opts.context?.branch ? `Branch: ${opts.context.branch}` : null,
         opts.context?.prUrl ? `PR: ${opts.context.prUrl}` : null,
+        transcript.workspace ? workspaceNote(transcript.workspace) : null,
         "",
         omitted > 0
             ? `Recent conversation (most recent last; ${omitted} earlier turn${omitted === 1 ? "" : "s"} omitted — see ${where}):`
@@ -274,6 +306,9 @@ export function buildForkHistory(transcript) {
     if (transcript.plan?.length && lastReply >= 0) {
         history[lastReply].text += `\n\n[plan] Where the plan stands:\n${planChecklist(transcript.plan)}`;
     }
+    if (transcript.workspace && lastReply >= 0) {
+        history[lastReply].text += `\n\n[workspace] ${workspaceNote(transcript.workspace)}`;
+    }
     return history;
 }
 /**
@@ -291,3 +326,20 @@ export function renderForkTranscript(transcript) {
     const turns = buildForkHistory(transcript).map((turn) => `## ${turn.role === "user" ? "User" : "Assistant"}\n\n${turn.text}`);
     return [...header, "", ...turns].join("\n\n").replace(/\n{3,}/g, "\n\n") + "\n";
 }
+/**
+ * The model the agent last answered with, as its own transcript records it
+ * (`model`, and `provider` when known, on an assistant message). A session
+ * resumed from a native transcript (a `bivy run <agent> --model …` taken over
+ * in chat) should keep that model, not fall back to the agent's default.
+ */
+export function lastTranscriptModel(messages) {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const message = messages[i];
+        if (message?.role !== "assistant" || message.bivyKind)
+            continue;
+        if (typeof message.model === "string" && message.model.trim()) {
+            return { provider: typeof message.provider === "string" ? message.provider : "", id: message.model.trim() };
+        }
+    }
+    return undefined;
+}

package/dist/session/transcript-persistence.js

@@ -19,6 +19,7 @@ import { mergeBases } from "./event-log.js";
 import { thinkingTextFromContent } from "./transcript-merge.js";
 import { extractInlineImageUrls, fetchInlineImage, isFetchImageError, inlineImageDisplayName, assistantTextForImageScan } from "./inline-image-fetch.js";
 import { historyDelta } from "../history-sync.js";
+import { withToolDetails } from "../runtime/tool-call-map.js";
 // Display-only intermediate reasoning is persisted as a length-capped HEAD so a
 // runaway/looping agent can't grow the append-only log without bound. HEAD (not
 // tail): once capped, the persisted text stops changing, so the skip-when-
@@ -75,6 +76,11 @@ export function createTranscriptPersistence(deps) {
     const { eventLog, attachmentStore } = deps;
     const project = createClientProjection(attachmentStore, eventLog);
     const liveIntermediateBySession = new Map();
+    // `${sessionId}\0${callId}` -> what the call's first event recorded. Runtimes
+    // stream progress as updates that carry only partial output (Pi's bash), so
+    // an update without its own detail/parent keeps the call's, rather than
+    // overwriting the persisted card with a generic one.
+    const toolCallOverlay = new Map();
     const lastPersistedIntermediateText = new Map();
     // In-flight dedupe + failure cooldown so a repeated remote image URL only ever
     // triggers one fetch and a broken URL isn't retried every message_end.
@@ -135,12 +141,19 @@ export function createTranscriptPersistence(deps) {
         if (!["tool_call", "tool_execution_start", "tool_execution_update", "tool_execution_end", "tool_result", "function_call", "function_result"].includes(type))
             return;
         const callId = toolEventId(event);
+        // A turn-level failure some runtimes report on the tool channel (Claude's
+        // non-success `result`) names no tool and no call: it is not tool activity,
+        // and persisting it left a blank error card keyed "tool:".
+        if (callId === "tool:" && !event.toolName && !event.name)
+            return;
         const toolCall = event.toolCall;
         const input = (event.input || event.toolInput || event.args || toolCall?.input || {});
         const name = String(event.toolName || event.name || toolCall?.name || "tool");
         const now = Date.now();
         const base = { role: "assistant", bivyKind: "tool", afterMessageCount: record.session.getMessages().length, createdAt: now };
+        const overlayKey = `${record.id}\0${callId}`;
         if (type === "tool_result" || type === "tool_execution_end" || type === "function_result") {
+            toolCallOverlay.delete(overlayKey);
             eventLog.append(record.id, { ...base, id: `bivy-tool-result-${callId}`, content: [{ type: "tool_result", toolUseId: callId, tool_use_id: callId, content: event.message ?? event.result ?? event.output ?? input.output ?? "", isError: Boolean(event.error || event.errorMessage), ...(event.detail ? { detail: event.detail } : {}) }] });
         }
         else if (isProgressOnlyPing(type, event.detail, input)) {
@@ -163,8 +176,11 @@ export function createTranscriptPersistence(deps) {
             // `parentToolUseId` (Claude, protocol agents) or `parentToolCallId` (Pi's
             // nested calls from codemode / ctx.executeTool).
             const rawParent = event.parentToolUseId ?? event.parentToolCallId;
-            const parentToolUseId = typeof rawParent === "string" && rawParent ? rawParent : undefined;
-            eventLog.append(record.id, { ...base, id: `bivy-tool-call-${callId}`, content: [{ type: "tool_use", id: callId, name, input, ...(parentToolUseId ? { parentToolUseId } : {}), ...(event.detail ? { detail: event.detail } : {}) }] });
+            const prior = toolCallOverlay.get(overlayKey);
+            const parentToolUseId = typeof rawParent === "string" && rawParent ? rawParent : prior?.parentToolUseId;
+            const detail = event.detail ?? prior?.detail;
+            toolCallOverlay.set(overlayKey, { detail, parentToolUseId });
+            eventLog.append(record.id, { ...base, id: `bivy-tool-call-${callId}`, content: [{ type: "tool_use", id: callId, name, input, ...(parentToolUseId ? { parentToolUseId } : {}), ...(detail ? { detail } : {}) }] });
         }
     }
     function persistIntermediateFromEvent(record, event, final = false) {
@@ -212,7 +228,8 @@ export function createTranscriptPersistence(deps) {
         return eventLog.deriveBase(record.id, record.session.getMessages());
     }
     function buildHistoryEvent(opts) {
-        const messages = opts.sessionId ? project(opts.sessionId, opts.messages) : opts.messages;
+        const described = withToolDetails(opts.messages, opts.runtimeId);
+        const messages = opts.sessionId ? project(opts.sessionId, described) : described;
         const delta = historyDelta(messages, opts.cursor);
         const record = opts.sessionId ? deps.getOpenSession(opts.sessionId) : undefined;
         const bSess = record ? deps.bivySessionEnvelope(record) : undefined;

package/dist/session-ref.js

@@ -31,11 +31,14 @@ export function sessionIdFromRef(ref) {
  * Throws for a path-based ref that escapes `sessionsDir`.
  */
 export function resolveResumeRef(opts) {
-    const { ref, resumesByPath, sessionsDir } = opts;
+    const { ref, resumesByPath } = opts;
     if (!resumesByPath)
         return sessionIdFromRef(ref);
     const resolved = path.resolve(ref);
-    if (!resolved.startsWith(path.resolve(sessionsDir) + path.sep)) {
+    // Every directory the node keeps or reads path-based transcripts in: its own,
+    // and the agent's native store (a `bivy run pi` session lives in Pi's).
+    const roots = typeof opts.sessionsDir === "string" ? [opts.sessionsDir] : opts.sessionsDir;
+    if (!roots.some((root) => resolved.startsWith(path.resolve(root) + path.sep))) {
         throw new Error("Session file is outside the sessions directory");
     }
     return resolved;

package/dist/worktree.js

@@ -29,6 +29,22 @@ export async function gitRepoRoot(dir) {
         return undefined;
     }
 }
+/**
+ * The main working tree of the repo containing `dir`. From inside a linked
+ * worktree (a session's or a fork's), `--show-toplevel` names that worktree;
+ * new worktrees and the `.bivy/` exclude rule belong to the main one, or a fork
+ * of a fork nests its checkout inside its parent's tree.
+ */
+async function gitMainRoot(dir) {
+    try {
+        const { stdout } = await exec("git", ["-C", dir, "rev-parse", "--path-format=absolute", "--git-common-dir"]);
+        const common = stdout.trim();
+        return common && path.basename(common) === ".git" ? path.dirname(common) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 async function currentRef(repoRoot) {
     try {
         const { stdout } = await exec("git", ["-C", repoRoot, "rev-parse", "--abbrev-ref", "HEAD"]);
@@ -57,14 +73,20 @@ function excludeMeshDir(repoRoot) {
  * `<repoRoot>/.bivy/worktrees/<slug>` by default (excluded from git).
  */
 export async function createWorktree(opts) {
-    const repoRoot = await gitRepoRoot(opts.repoDir);
-    if (!repoRoot)
+    const sourceRoot = await gitRepoRoot(opts.repoDir);
+    if (!sourceRoot)
         throw new Error(`Not a git repository: ${opts.repoDir}`);
+    const repoRoot = (await gitMainRoot(sourceRoot)) ?? sourceRoot;
     const slug = branchSlug(opts.id);
     const branch = opts.branch ?? `bivy/${slug}`;
     const root = opts.root ?? path.join(repoRoot, ".bivy", "worktrees");
     const wtPath = path.join(root, slug);
-    let base = opts.base ?? (await currentRef(repoRoot));
+    // Branch from the checkout asked for: a fork of a fork starts at its parent's HEAD.
+    let base = opts.base ?? (await currentRef(sourceRoot));
+    // A detached "HEAD" means the source's commit, not the main tree's HEAD.
+    if (base === "HEAD" && sourceRoot !== repoRoot) {
+        base = await exec("git", ["-C", sourceRoot, "rev-parse", "HEAD"]).then(({ stdout }) => stdout.trim() || "HEAD", () => "HEAD");
+    }
     excludeMeshDir(repoRoot);
     fs.mkdirSync(root, { recursive: true });
     // Reuse the registered checkout in place. Recovery must not force-remove

package/package.json

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