@bivy/bivy 0.9.1-staging.128 → 0.9.1-staging.129

package/dist/runtime/claude-code.js

@@ -1457,17 +1457,46 @@ export class ClaudeCodeRuntime {
         const projectDir = path.join(root, "projects", projectSlug);
         fs.mkdirSync(projectDir, { recursive: true });
         let parentUuid = null;
-        const lines = history.map((message) => {
+        const model = ctx.model?.provider === "anthropic"
+            ? ctx.model.id
+            : this.options.defaultModel ?? FALLBACK_MODELS.find((candidate) => candidate.id.includes("sonnet")).id;
+        const timestamp = Date.now();
+        const lines = history.map((turn, index) => {
             const uuid = randomUUID();
+            // Claude's store is permissive when read for display, but `--resume` / the
+            // Agent SDK expects provider-native assistant envelopes. Keep the portable
+            // history generic until this final serializer, then emit the same minimum
+            // shape as a real Claude transcript (content blocks, model/id, stop reason,
+            // usage and timestamps). This is the Claude counterpart to pi's native
+            // serializer and prevents a replay that paints correctly but fails on the
+            // first continued prompt.
+            const message = turn.role === "user"
+                ? { role: "user", content: turn.text }
+                : {
+                    model,
+                    id: `msg_bivy_${uuid.replace(/-/g, "")}`,
+                    type: "message",
+                    role: "assistant",
+                    content: [{ type: "text", text: turn.text }],
+                    stop_reason: "end_turn",
+                    stop_sequence: null,
+                    usage: {
+                        input_tokens: 0,
+                        cache_creation_input_tokens: 0,
+                        cache_read_input_tokens: 0,
+                        output_tokens: 0,
+                    },
+                };
             const entry = {
                 parentUuid,
                 isSidechain: false,
                 userType: "external",
                 cwd,
                 sessionId: newId,
-                type: message.role,
-                message: { role: message.role, content: message.text },
+                type: turn.role,
+                message,
                 uuid,
+                timestamp: new Date(timestamp + index).toISOString(),
             };
             parentUuid = uuid;
             return JSON.stringify(entry);

package/dist/runtime/pi.js

@@ -12,7 +12,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { completeSimple } from "@earendil-works/pi-ai/compat";
-import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent";
 import { createPiModelRuntime } from "./pi-oauth.js";
 import { toModelInfo as sharedToModelInfo } from "./normalize.js";
 import { provisionPiAuthJson } from "./credential-provisioning.js";
@@ -539,9 +539,48 @@ export class PiRuntime {
      * reconstruct provider-specific tool blocks. Never touches the source.
      */
     async importHistoryForFork(history, ctx) {
-        const sessionManager = SessionManager.create(ctx.cwd || ctx.workspace, this.options.sessionsDir);
-        for (const message of history) {
-            sessionManager.appendMessage({ role: message.role, content: message.text });
+        const cwd = ctx.cwd || ctx.workspace;
+        const sessionManager = SessionManager.create(cwd, this.options.sessionsDir);
+        const settings = SettingsManager.create(cwd, this.options.piDir);
+        const defaultProvider = settings.getDefaultProvider();
+        const defaultModel = settings.getDefaultModel();
+        const targetModel = ctx.model ?? (defaultProvider && defaultModel ? { provider: defaultProvider, id: defaultModel } : undefined);
+        const timestamp = Date.now();
+        for (const [index, message] of history.entries()) {
+            // SessionManager deliberately persists unvalidated objects. A bare
+            // `{role, content: string}` looks readable in the UI, but is NOT a valid
+            // pi AssistantMessage: the first real prompt later reaches provider and
+            // usage code that expects block-array content plus model/usage metadata.
+            // That was the codex→pi fork crash ("reading 'length'"). Materialise the
+            // portable prose as complete pi-ai messages instead.
+            const imported = message.role === "user"
+                ? {
+                    role: "user",
+                    content: [{ type: "text", text: message.text }],
+                    timestamp: timestamp + index,
+                }
+                : {
+                    role: "assistant",
+                    content: [{ type: "text", text: message.text }],
+                    // The target model is enough for pi to restore the requested model
+                    // before Bivy applies it again after stand-up. The synthetic API id
+                    // intentionally prevents provider-specific reasoning replay rules;
+                    // this history contains portable plain text only.
+                    api: "bivy-fork",
+                    provider: targetModel?.provider ?? "bivy-fork",
+                    model: targetModel?.id ?? "portable-history",
+                    usage: {
+                        input: 0,
+                        output: 0,
+                        cacheRead: 0,
+                        cacheWrite: 0,
+                        totalTokens: 0,
+                        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+                    },
+                    stopReason: "stop",
+                    timestamp: timestamp + index,
+                };
+            sessionManager.appendMessage(imported);
         }
         const sessionFile = sessionManager.getSessionFile();
         if (!sessionFile)

package/dist/server.js

@@ -3598,27 +3598,12 @@ const RELAY_COMMANDS = {
         // changes into an E2E bundle the client carries to the destination node.
         const requestId = typeof msg.requestId === "string" ? msg.requestId : undefined;
         const rec = resolveSession(msg.sessionId);
-        if (!rec || !rec.sessionFile) {
-            relay?.sendEvent({ type: "session.fork.error", requestId, error: "Session not found or not resumable on this node." });
+        if (!rec) {
+            relay?.sendEvent({ type: "session.fork.error", requestId, error: "Session not found on this node." });
             return;
         }
         try {
-            const src = rec.source ?? "";
-            const repoSlug = src.startsWith("repo:") ? src.slice(5) : src.startsWith("issue:") ? src.slice(6).replace(/#\d+$/, "") : undefined;
-            const forkRecord = {
-                sourceSessionId: rec.id,
-                runtimeId: rec.runtimeId,
-                workspace: rec.workspace,
-                cwd: rec.session.cwd || rec.worktree?.path || rec.workspace,
-                worktree: rec.worktree?.path,
-                branch: rec.worktree?.branch,
-                repoSlug,
-                prUrl: rec.prUrl,
-                source: rec.source,
-                title: rec.session.getName(),
-                model: rec.session.getCurrentModel()?.name,
-                sandbox: rec.sandbox,
-            };
+            const forkRecord = forkRecordFor(rec);
             let dirtyPatch;
             if (rec.worktree) {
                 try {
@@ -3673,6 +3658,12 @@ const RELAY_COMMANDS = {
                 // so cut an independent fork branch instead of trying to adopt it.
                 worktree: msg.sameNode === true ? "fresh" : "adopt",
                 detectPrereqs: true,
+                // A same-node cross-agent fork can safely retain a non-repo workspace.
+                // A cross-node path belongs to the source machine, so standUpFork keeps
+                // its destination default unless repo metadata lets it reconstruct one.
+                ...(msg.sameNode === true
+                    ? { fallback: { workspace: bundle.record.workspace, cwd: bundle.record.cwd } }
+                    : {}),
             });
             if (!outcome.ok) {
                 relay?.sendEvent({ type: "session.fork.error", requestId, error: outcome.error, missing: outcome.missing });
@@ -3694,28 +3685,13 @@ const RELAY_COMMANDS = {
         // (model may still change); any node/agent change goes through import above.
         const requestId = typeof msg.requestId === "string" ? msg.requestId : undefined;
         const rec = resolveSession(msg.sessionId);
-        if (!rec || !rec.sessionFile) {
-            relay?.sendEvent({ type: "session.fork.error", requestId, error: "Session not found or not resumable on this node." });
+        if (!rec) {
+            relay?.sendEvent({ type: "session.fork.error", requestId, error: "Session not found on this node." });
             return;
         }
         try {
             const runtime = getRuntime(rec.runtimeId);
-            const src = rec.source ?? "";
-            const repoSlug = src.startsWith("repo:") ? src.slice(5) : src.startsWith("issue:") ? src.slice(6).replace(/#\d+$/, "") : undefined;
-            const forkRecord = {
-                sourceSessionId: rec.id,
-                runtimeId: rec.runtimeId,
-                workspace: rec.workspace,
-                cwd: rec.session.cwd || rec.worktree?.path || rec.workspace,
-                worktree: rec.worktree?.path,
-                branch: rec.worktree?.branch,
-                repoSlug,
-                prUrl: rec.prUrl,
-                source: rec.source,
-                title: rec.session.getName(),
-                model: rec.session.getCurrentModel()?.name,
-                sandbox: rec.sandbox,
-            };
+            const forkRecord = forkRecordFor(rec);
             // Carry uncommitted work: capture from the SOURCE worktree; standUpFork
             // re-applies it into the fork's fresh worktree. Local git ops only.
             let dirtyPatch;
@@ -6066,6 +6042,33 @@ async function withRepoLock(key, fn) {
     repoWorktreeLocks.set(key, run.then(() => { }, () => { }));
     return run;
 }
+/** Build the runtime-neutral metadata carried by both local and remote forks. */
+function forkRecordFor(rec) {
+    const src = rec.source ?? "";
+    const repoSlug = src.startsWith("repo:")
+        ? src.slice(5)
+        : src.startsWith("issue:")
+            ? src.slice(6).replace(/#\d+$/, "")
+            : undefined;
+    const currentModel = rec.session.getCurrentModel();
+    return {
+        sourceSessionId: rec.id,
+        runtimeId: rec.runtimeId,
+        workspace: rec.workspace,
+        cwd: rec.session.cwd || rec.worktree?.path || rec.workspace,
+        worktree: rec.worktree?.path,
+        branch: rec.worktree?.branch,
+        repoSlug,
+        prUrl: rec.prUrl,
+        source: rec.source,
+        title: rec.session.getName(),
+        model: currentModel?.name,
+        ...(currentModel?.provider && currentModel.id
+            ? { modelRef: { provider: String(currentModel.provider), id: String(currentModel.id) } }
+            : {}),
+        sandbox: rec.sandbox,
+    };
+}
 /**
  * Best-effort push of a fork SOURCE's branch to origin before the bundle leaves
  * the node, so a cross-node fork's committed work travels via origin (the
@@ -6198,7 +6201,13 @@ async function standUpFork(opts) {
     }
     // Materialise the transcript, then stand the session up — resume the imported
     // transcript (full) or a fresh session the caller seeds with plan.seedPrompt.
-    const plan = await materializeFork({ bundle, targetRuntime, ctx: { workspace, cwd }, seed: { transcriptUrl: opts.transcriptUrl } });
+    // Preserve the source model only when the runtime itself is unchanged. A
+    // cross-agent fork must let the destination choose its own default unless the
+    // caller explicitly supplied a model valid for that target. Thread the final
+    // choice through the generic import context: adapters that need native model
+    // metadata (Pi/Claude) can serialize it; the others simply ignore it.
+    const targetModel = opts.model ?? (targetRuntimeId === bundle.record.runtimeId ? bundle.record.modelRef : undefined);
+    const plan = await materializeFork({ bundle, targetRuntime, ctx: { workspace, cwd, model: targetModel }, seed: { transcriptUrl: opts.transcriptUrl } });
     const record = plan.kind === "resume"
         ? await createSession(cwd, plan.sessionFile, { runtimeId: targetRuntimeId, source: bundle.record.source, sandbox: forkSandbox, makeActive: false })
         : await createSession(cwd, undefined, { runtimeId: targetRuntimeId, source: bundle.record.source, sandbox: forkSandbox, makeActive: false });
@@ -6224,7 +6233,7 @@ async function standUpFork(opts) {
     // cleanly, so the fork isn't silently missing work-in-progress.
     if (dirtyWarning)
         broadcast({ type: "session.notice", sessionId: record.id, message: dirtyWarning });
-    await applyRequestedModel(record, opts.model ?? nodeDefaultModel() ?? undefined);
+    await applyRequestedModel(record, targetModel);
     persistSessionMetadata(record);
     scheduleAdvertise();
     const missing = opts.detectPrereqs

package/dist/session/fork.js

@@ -12,7 +12,17 @@ export function buildForkBundle(opts) {
     // Prefer the build-free readMessages fast path (pi/Claude); fall back to the
     // live session's transcript for runtimes without one (the generic CLI runtime),
     // so a fork *from* any agent still carries its real history.
-    const messages = runtime.readMessages?.(sessionFile) ?? opts.liveMessages;
+    let messages = opts.liveMessages;
+    if (sessionFile && runtime.readMessages) {
+        try {
+            messages = runtime.readMessages(sessionFile) ?? messages;
+        }
+        catch {
+            // Runtime-native readers are best-effort. The live transcript is the
+            // universal source fallback and keeps one broken adapter from blocking a
+            // fork out to every other agent.
+        }
+    }
     const normalized = normalizeMessages(messages, {
         sourceRuntimeId: runtime.id,
         model: record.model,
@@ -21,9 +31,16 @@ export function buildForkBundle(opts) {
     });
     // Only worth capturing when the target is the same runtime (or not yet known).
     const nativeCouldReplay = !opts.targetRuntimeId || opts.targetRuntimeId === runtime.id;
-    const native = nativeCouldReplay && runtime.capabilities.forkTransport && runtime.exportForFork
-        ? runtime.exportForFork(sessionFile)
-        : undefined;
+    let native;
+    if (sessionFile && nativeCouldReplay && runtime.capabilities.forkTransport && runtime.exportForFork) {
+        try {
+            native = runtime.exportForFork(sessionFile);
+        }
+        catch {
+            // A native export is an optimization, never the only route. The portable
+            // transcript below still supports replay or a seeded continuation.
+        }
+    }
     return { record, normalized, ...(native ? { native } : {}), ...(opts.dirtyPatch ? { dirtyPatch: opts.dirtyPatch } : {}) };
 }
 /**
@@ -47,6 +64,7 @@ export function resolveForkFidelity(bundle, targetRuntime) {
         return "full";
     const canReplayHistory = !!targetRuntime.capabilities.forkHistoryImport &&
         typeof targetRuntime.importHistoryForFork === "function" &&
+        Array.isArray(bundle.normalized?.turns) &&
         bundle.normalized.turns.length > 0;
     return canReplayHistory ? "replayed" : "seeded";
 }
@@ -60,25 +78,38 @@ export function resolveForkFidelity(bundle, targetRuntime) {
  */
 export async function materializeFork(opts) {
     const { bundle, targetRuntime, ctx } = opts;
-    const fidelity = resolveForkFidelity(bundle, targetRuntime);
-    if (fidelity === "full" && bundle.native && targetRuntime.importForFork) {
-        const { sessionFile, id } = await targetRuntime.importForFork(bundle.native, ctx);
-        return { kind: "resume", fidelity: "full", sessionFile, id };
+    const intended = resolveForkFidelity(bundle, targetRuntime);
+    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
+    // point of failure. An adapter upgrade, stale native store, or malformed
+    // payload degrades through the exact same portable path all agents share.
+    if (intended === "full" && bundle.native && targetRuntime.importForFork) {
+        try {
+            const imported = await targetRuntime.importForFork(bundle.native, ctx);
+            if (validImport(imported))
+                return { kind: "resume", fidelity: "full", ...imported };
+        }
+        catch {
+            // Continue to portable replay (if supported), then the universal seed.
+        }
     }
-    // True cross-runtime fork: write the whole transcript as real prior turns into
-    // the target runtime's own store and resume it. Best-effort — if the runtime's
-    // history import throws (a malformed store, an unwritable dir), fall through to
-    // a seeded prompt so the fork still succeeds rather than erroring outright.
-    if (fidelity === "replayed" && targetRuntime.importHistoryForFork) {
+    // Write the runtime-neutral conversation into any destination that advertises
+    // a native history serializer. This path also rescues a failed same-runtime
+    // native import, so Pi/Claude/Codex all share one degradation ladder.
+    const canReplay = !!targetRuntime.capabilities.forkHistoryImport &&
+        typeof targetRuntime.importHistoryForFork === "function";
+    if (canReplay) {
         try {
             const history = buildForkHistory(bundle.normalized);
             if (history.length > 0) {
-                const { sessionFile, id } = await targetRuntime.importHistoryForFork(history, ctx);
-                return { kind: "resume", fidelity: "replayed", sessionFile, id };
+                const imported = await targetRuntime.importHistoryForFork(history, ctx);
+                if (validImport(imported))
+                    return { kind: "resume", fidelity: "replayed", ...imported };
             }
         }
         catch {
-            // fall through to the seeded continuation below
+            // Fall through to the agent-independent seeded continuation below.
         }
     }
     const seedPrompt = buildSeedPrompt(bundle.normalized, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.9.1-staging.128",
+  "version": "0.9.1-staging.129",
   "type": "module",
   "license": "FSL-1.1-ALv2",
   "description": "Run coding agents on machines you own. Source-available, self-hostable agent workspace.",