@bivy/bivy 0.1.0-staging.4 → 0.1.0-staging.6

package/bin/bivy.mjs

@@ -3265,15 +3265,47 @@ async function cmdStatus(args = []) {
     try { status = await localApi(config, "/api/status"); } catch {}
   }
   if (json) {
-    console.log(JSON.stringify({ reachable, url: url(config), workspace: status?.workspace || config.workspace, service: serviceStatusLine(), remoteConfigured: Boolean(status?.relay?.configured || fs.existsSync(relayConfigPath)), status }, null, 2));
+    const relayCfgJson = loadRelayConfig();
+    console.log(JSON.stringify({
+      reachable,
+      url: url(config),
+      workspace: status?.workspace || config.workspace,
+      service: serviceStatusLine(),
+      remoteConfigured: Boolean(status?.relay?.configured || relayCfgJson),
+      relay: {
+        configured: Boolean(status?.relay?.configured || relayCfgJson),
+        connected: status?.relay?.connected ?? null,
+        app: status?.relay?.controlPlaneUrl || relayCfgJson?.controlPlaneUrl || null,
+        relay: status?.relay?.relayUrl || relayCfgJson?.url || null,
+        lastError: status?.relay?.lastError || null,
+      },
+      status,
+    }, null, 2));
     return;
   }
   console.log(c.bold("\n  Bivy node\n"));
   console.log(`  url:       ${url(config)}  ${reachable ? c.green("● reachable") : c.dim("○ not reachable")}`);
   console.log(`  workspace: ${status?.workspace || config.workspace}`);
   console.log(`  ${serviceStatusLine()}`);
-  console.log(`  remote:    ${status?.relay?.configured || fs.existsSync(relayConfigPath) ? c.green("relay configured") : "local only"}`);
   const relay = loadRelayConfig();
+  const relaySt = status?.relay;
+  const relayConfigured = Boolean(relaySt?.configured || relay);
+  if (!relayConfigured) {
+    console.log(`  remote:    ${c.dim("local only")}  ${c.dim("('bivy relay:setup' to enable remote access)")}`);
+  } else {
+    // The live link state is only knowable when the node is running; if it's
+    // down we can say it's configured but not whether it's currently connected.
+    let state;
+    if (!reachable) state = c.yellow("configured (node not running)");
+    else if (relaySt?.connected) state = c.green("● connected");
+    else state = c.yellow("○ configured, not connected");
+    const relErr = relaySt?.lastError ? c.dim(`  (${relaySt.lastError})`) : "";
+    console.log(`  remote:    ${state}${relErr}`);
+    const cpUrl = relaySt?.controlPlaneUrl || relay?.controlPlaneUrl;
+    const rlUrl = relaySt?.relayUrl || relay?.url;
+    if (cpUrl) console.log(`  app:       ${cpUrl}`);
+    if (rlUrl) console.log(`  relay:     ${rlUrl}`);
+  }
   if (relay?.controlPlaneUrl && relay?.enrollmentToken) {
     try {
       const acct = await controlPlaneNodeApi(relay, "/node/account");
@@ -3331,7 +3363,15 @@ async function cmdDoctor(args = []) {
   console.log(`  ${mark(agentAvailable, true)} agent ${runtimeInfo?.displayName || defaultAgent}${agentAvailable ? "" : c.dim(" not available — install it or run 'bivy setup'")}`);
   console.log(`  ${mark(hasModelConfig(config), authOwner !== "bivy")} model ${hasModelConfig(config) ? "configured" : authOwner === "bivy" ? c.dim("not configured — run 'bivy login'") : c.dim("agent-native auth — use the agent's CLI login if needed")}`);
   const relayConfigured = Boolean(status?.relay?.configured || fs.existsSync(relayConfigPath));
-  console.log(`  ${relayConfigured ? ok : c.dim("○")} remote ${relayConfigured ? (status?.relay?.connected ? c.green("relay connected") : "relay configured") : c.dim("local only — 'bivy relay:setup' to enable")}`);
+  const relayConnected = Boolean(status?.relay?.connected);
+  const relayApp = status?.relay?.controlPlaneUrl;
+  const relayErr = status?.relay?.lastError;
+  const relayLine = !relayConfigured
+    ? c.dim("local only — 'bivy relay:setup' to enable")
+    : relayConnected
+      ? c.green("relay connected") + (relayApp ? c.dim(`  ${relayApp}`) : "")
+      : c.yellow("configured, not connected") + (relayErr ? c.dim(`  (${relayErr})`) : "");
+  console.log(`  ${relayConfigured ? (relayConnected ? ok : warn) : c.dim("○")} remote ${relayLine}`);
   // Derived from BUILTIN_TERMINAL_AGENTS (the same list 'bivy agents'/'bivy run'
   // use) rather than a hand-maintained list, so it can't drift out of sync (#113).
   const agentCommands = [...BUILTIN_TERMINAL_AGENTS.values()].filter((a) => a.type === "command").map((a) => a.command);

package/dist/relay-client.js

@@ -51,6 +51,14 @@ export class RelayConnector {
     heartbeatTimer;
     stableTimer;
     lastPongAt = 0;
+    // True only between the relay's `ready` message (auth + entitlement passed)
+    // and the socket closing. This — not "a connector object exists" — is what
+    // "connected" means to the control plane, so it's what `bivy status` reports.
+    ready = false;
+    // Most recent relay-side failure (ticket mint, socket error, or an `error`
+    // frame), surfaced by `bivy status`/`doctor` so a node that never connects
+    // explains why instead of silently showing "configured".
+    lastErrorMessage;
     replay = new ReplayGuard();
     reassembler = new FrameReassembler();
     pairing;
@@ -71,12 +79,26 @@ export class RelayConnector {
             return;
         this.ws.send(JSON.stringify({ t: "pair", p: JSON.stringify({ k: "key.rotate", deliveries }) }));
     }
+    /**
+     * True only while the relay link is live AND the relay has sent `ready`
+     * (auth/entitlement checks passed) — i.e. the node is actually reachable from
+     * the control plane. A socket that opened but was rejected, or one still
+     * reconnecting, reads false.
+     */
+    get connected() {
+        return this.ready && this.ws?.readyState === WebSocket.OPEN;
+    }
+    /** Most recent relay-side failure, if any — for status/diagnostics. */
+    get lastError() {
+        return this.lastErrorMessage;
+    }
     start() {
         this.closed = false;
         void this.connect();
     }
     stop() {
         this.closed = true;
+        this.ready = false;
         this.stopHeartbeat();
         this.clearBackoffReset();
         this.ws?.close();
@@ -250,6 +272,7 @@ export class RelayConnector {
             ({ ticket, relayUrl } = await this.mintTicket());
         }
         catch (error) {
+            this.lastErrorMessage = `ticket mint failed: ${error.message}`;
             console.warn("[relay] could not mint relay ticket:", error.message);
             this.scheduleReconnect();
             return;
@@ -276,6 +299,8 @@ export class RelayConnector {
                 return;
             }
             if (env.t === "ready") {
+                this.ready = true;
+                this.lastErrorMessage = undefined;
                 this.startHeartbeat(ws);
                 this.scheduleBackoffReset(ws);
                 console.log("[relay] connected");
@@ -311,6 +336,7 @@ export class RelayConnector {
             }
             if (env.t === "error") {
                 const message = env.error || "Relay error";
+                this.lastErrorMessage = message;
                 console.warn("[relay] error:", message);
                 if (isFatalRelayError(message)) {
                     console.warn("[relay] disabling connector; fix relay setup/plan and restart the node dev server");
@@ -323,11 +349,13 @@ export class RelayConnector {
             this.lastPongAt = Date.now();
         });
         ws.on("close", () => {
+            this.ready = false;
             this.stopHeartbeat();
             this.clearBackoffReset();
             this.scheduleReconnect();
         });
         ws.on("error", (error) => {
+            this.lastErrorMessage = error.message;
             console.warn("[relay] socket error:", error.message);
         });
     }

package/dist/runtime/claude-code.js

@@ -1164,6 +1164,10 @@ export class ClaudeCodeRuntime {
         // The on-disk jsonl transcript can be exported and re-materialised on another
         // node under a fresh session id, so a claude->claude fork is full fidelity.
         forkTransport: true,
+        // Claude can also synthesise a resumable jsonl from portable {role,text}
+        // history, so a fork FROM another agent INTO claude is a true replay of the
+        // whole transcript rather than a seeded summary (see importHistoryForFork).
+        forkHistoryImport: true,
         // Claude Code ignores the streamingBehavior hint entirely — a mid-turn
         // prompt always re-enters the live input queue and behaves like an
         // immediate steer, regardless of what's asked for. There is no real
@@ -1281,6 +1285,46 @@ export class ClaudeCodeRuntime {
         fs.writeFileSync(path.join(projectDir, `${newId}.jsonl`), rewritten ? `${rewritten}\n` : "");
         return { sessionFile: newId, id: newId };
     }
+    /**
+     * Stand up a claude session from a **cross-runtime** fork's portable history:
+     * synthesise a resumable jsonl transcript from the `{role, text}` turns and
+     * write it under the destination cwd's project dir with a fresh session id, so
+     * `--resume <id>` opens on a copy of the whole conversation (fidelity
+     * "replayed"). Each turn becomes one claude jsonl entry whose `message` is a
+     * plain-text user/assistant message — the same shape loadClaudeTranscript reads
+     * back — chained by `uuid`/`parentUuid` exactly as claude's own transcripts are.
+     * Tool activity is already inlined as text upstream, so no `tool_use`/
+     * `tool_result` blocks (whose ids would dangle) are ever emitted. The source is
+     * never touched.
+     */
+    async importHistoryForFork(history, ctx) {
+        const newId = randomUUID();
+        const cwd = ctx.cwd || ctx.workspace;
+        // Claude encodes the cwd into the project-dir name by replacing every
+        // non-alphanumeric char with "-" (matches importForFork above).
+        const projectSlug = cwd.replace(/[^a-zA-Z0-9]/g, "-");
+        const root = claudeProjectDirs()[0] ?? path.join(os.homedir(), ".claude");
+        const projectDir = path.join(root, "projects", projectSlug);
+        fs.mkdirSync(projectDir, { recursive: true });
+        let parentUuid = null;
+        const lines = history.map((message) => {
+            const uuid = randomUUID();
+            const entry = {
+                parentUuid,
+                isSidechain: false,
+                userType: "external",
+                cwd,
+                sessionId: newId,
+                type: message.role,
+                message: { role: message.role, content: message.text },
+                uuid,
+            };
+            parentUuid = uuid;
+            return JSON.stringify(entry);
+        });
+        fs.writeFileSync(path.join(projectDir, `${newId}.jsonl`), lines.length ? `${lines.join("\n")}\n` : "");
+        return { sessionFile: newId, id: newId };
+    }
     async listSessions() {
         const dir = this.options.sessionsDir;
         if (dir) {

package/dist/runtime/codex-sessions.js

@@ -21,6 +21,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { randomUUID } from "node:crypto";
 import { hasLiveProcessForCwd } from "./native-process-scan.js";
 /** Binary names a live Codex process could be running under (see
  *  native-process-scan.ts's best-effort cwd match). */
@@ -132,6 +133,55 @@ export function loadCodexTranscriptFile(file) {
     }
     return messages;
 }
+/**
+ * Materialise a **cross-runtime** fork's portable history as a fresh Codex
+ * rollout so `codex ... resume <id>` (the app-server's `thread/resume`) opens on
+ * a copy of the whole conversation — the write-side counterpart to
+ * `loadCodexTranscript`, and Codex's `importHistoryForFork` (fidelity
+ * "replayed"). The rollout is written in the current wrapped layout — a
+ * `session_meta` line then one `response_item` per turn — under the id-addressed
+ * date path Codex uses (`$CODEX_HOME/sessions/YYYY/MM/DD/rollout-*.jsonl`), the
+ * same shape `loadCodexTranscriptFile` reads back and `discoverCodexSessionForCwd`
+ * locates. Message turns carry a Responses-API `message` item (`input_text` for
+ * the user, `output_text` for the assistant), which reads back through `textOf`.
+ *
+ * IMPORTANT — best-effort, and NOT verified against a live Codex resume here (see
+ * this module's header): Codex's rollout schema is version-variable, so whether a
+ * *synthesised* rollout is fully honored by `thread/resume` depends on the
+ * installed Codex. The fork engine calls this only as its "replayed" tier and
+ * falls back to a seeded continuation prompt if it throws; a node can force that
+ * fallback outright with `BIVY_CODEX_NO_FORK_REPLAY=1` when its Codex build
+ * doesn't accept synthesised rollouts.
+ */
+export function writeCodexRollout(history, cwd) {
+    if (process.env.BIVY_CODEX_NO_FORK_REPLAY === "1") {
+        throw new Error("Codex fork replay disabled (BIVY_CODEX_NO_FORK_REPLAY=1)");
+    }
+    const id = randomUUID();
+    const now = new Date();
+    const iso = now.toISOString();
+    const yyyy = String(now.getUTCFullYear());
+    const mm = String(now.getUTCMonth() + 1).padStart(2, "0");
+    const dd = String(now.getUTCDate()).padStart(2, "0");
+    const dir = path.join(codexSessionsDir(), yyyy, mm, dd);
+    fs.mkdirSync(dir, { recursive: true });
+    const stamp = iso.replace(/[:.]/g, "-").replace(/Z$/, "");
+    const file = path.join(dir, `rollout-${stamp}-${id}.jsonl`);
+    const records = [
+        { type: "session_meta", timestamp: iso, payload: { id, timestamp: iso, cwd, cli_version: "bivy-fork" } },
+        ...history.map((message) => ({
+            type: "response_item",
+            timestamp: iso,
+            payload: {
+                type: "message",
+                role: message.role,
+                content: [{ type: message.role === "user" ? "input_text" : "output_text", text: message.text }],
+            },
+        })),
+    ];
+    fs.writeFileSync(file, records.map((r) => JSON.stringify(r)).join("\n") + "\n");
+    return { sessionFile: id, id };
+}
 /** Enumerate Codex sessions on disk, newest first. Best-effort. */
 export function listCodexSessions() {
     const sessions = [];

package/dist/runtime/index.js

@@ -7,7 +7,7 @@ import { spawn, spawnSync } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { ClaudeCodeRuntime, claudeRuntimeFromEnv, claudeSdkInstalled } from "./claude-code.js";
-import { deleteCodexSession, discoverNativeCodexSessions, loadCodexTranscript } from "./codex-sessions.js";
+import { deleteCodexSession, discoverNativeCodexSessions, loadCodexTranscript, writeCodexRollout } from "./codex-sessions.js";
 import { createCredentialStore } from "./credentials.js";
 // Args that continue an existing Codex session each prompt. Codex assigns its own
 // session id (no launch-time pin), so a resumed run threads it via `exec resume`.
@@ -1076,6 +1076,10 @@ function codexAppServerRuntime(credsDir, tier) {
         resumable: true,
         loadHistory: (sessionId) => loadCodexTranscript(sessionId),
         deleteHistory: (sessionId) => void deleteCodexSession(sessionId),
+        // True cross-runtime replay INTO Codex: synthesise a resumable rollout from
+        // portable history so a fork from another agent opens on a copy of the whole
+        // conversation instead of a seeded summary (best-effort — see writeCodexRollout).
+        writeHistory: (history, ctx) => writeCodexRollout(history, ctx.cwd || ctx.workspace),
         suggestName: suggestCodexSessionName,
         // Native discovery (issue #156): enumerate Codex rollouts on this node that
         // Bivy didn't start, so a pre-existing `codex` session can be adopted here

package/dist/runtime/pi.js

@@ -366,6 +366,9 @@ export class PiRuntime {
         // pi transcripts are structured messages that round-trip through the session
         // store, so a pi->pi fork is full fidelity (see exportForFork/importForFork).
         forkTransport: true,
+        // pi can also stand up a session from portable {role,text} history, so a fork
+        // FROM another agent INTO pi is a true replay, not a seeded summary.
+        forkHistoryImport: true,
         // The pi-coding-agent SDK implements both explicitly: prompting mid-turn
         // with no streamingBehavior hint throws, forcing every caller to choose.
         streamingBehaviors: ["steer", "followUp"],
@@ -515,4 +518,22 @@ export class PiRuntime {
             throw new Error("pi.importForFork: session file was not persisted");
         return { sessionFile, id: sessionManager.getSessionId() };
     }
+    /**
+     * Stand up a pi session from a **cross-runtime** fork's portable history: open
+     * a fresh session in the destination workspace and append each `{role, text}`
+     * turn as a plain-text message, so the new session resumes on a copy of the
+     * whole conversation (fidelity "replayed"). The turns already have any tool
+     * activity inlined as text (see buildForkHistory), so nothing here needs to
+     * 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 sessionFile = sessionManager.getSessionFile();
+        if (!sessionFile)
+            throw new Error("pi.importHistoryForFork: session file was not persisted");
+        return { sessionFile, id: sessionManager.getSessionId() };
+    }
 }

package/dist/runtime/protocol.js

@@ -553,6 +553,10 @@ export class ProtocolRuntime {
         // and takeover treat it as resumable up front (the ProcessRuntime convention).
         if (options.resumable)
             this.capabilities.resume = true;
+        // A runtime that can write its own resumable store from portable history
+        // (Codex's rollout) supports true cross-runtime replay forks INTO it.
+        if (options.writeHistory)
+            this.capabilities.forkHistoryImport = true;
         if (options.capabilities)
             Object.assign(this.capabilities, options.capabilities);
     }
@@ -580,6 +584,18 @@ export class ProtocolRuntime {
     readMessages(sessionFile) {
         return this.options.loadHistory?.(sessionFile);
     }
+    /**
+     * Materialise a cross-runtime fork's portable history into this agent's own
+     * resumable store (fidelity "replayed"), delegating to the runtime-specific
+     * `writeHistory` hook (Codex's `writeCodexRollout`). Only present in effect
+     * when configured; the fork engine gates on `capabilities.forkHistoryImport`
+     * and falls back to a seeded prompt if this throws.
+     */
+    async importHistoryForFork(history, ctx) {
+        if (!this.options.writeHistory)
+            throw new Error(`${this.displayName} does not support history import.`);
+        return this.options.writeHistory(history, ctx);
+    }
     /** See ProtocolRuntimeOptions.discoverNativeSessions (issue #156). */
     async discoverNativeSessions() {
         try {

package/dist/server.js

@@ -3141,7 +3141,7 @@ const RELAY_COMMANDS = {
             // When the client has already picked a target agent, pass it so the
             // bundle omits the native payload for a cross-runtime fork (it could
             // never be replayed there — see buildForkBundle). Unset => keep it.
-            const bundle = buildForkBundle({ runtime: getRuntime(rec.runtimeId), sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, targetRuntimeId: agentFrom(msg) });
+            const bundle = buildForkBundle({ runtime: getRuntime(rec.runtimeId), sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, targetRuntimeId: agentFrom(msg), liveMessages: rec.session.getMessages() });
             relay?.sendEvent({ type: "session.fork.bundle", requestId, bundle });
         }
         catch (error) {
@@ -3225,7 +3225,7 @@ const RELAY_COMMANDS = {
                 catch { /* best effort */ }
             }
             // Same runtime → the bundle carries the native payload → full fidelity.
-            const bundle = buildForkBundle({ runtime, sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, targetRuntimeId: rec.runtimeId });
+            const bundle = buildForkBundle({ runtime, sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, targetRuntimeId: rec.runtimeId, liveMessages: rec.session.getMessages() });
             // Cut a fresh fork branch (the source still holds its own); skip prereq
             // detection (same node + same runtime ⇒ agent and repo are present).
             const outcome = await standUpFork({
@@ -7577,7 +7577,14 @@ app.get("/api/status", (_req, res) => {
             workspaceBoundary: true,
             strictApprovalOptIn: true,
         },
-        relay: { configured: Boolean(relayConfig), connected: Boolean(relay) },
+        relay: {
+            configured: Boolean(relayConfig),
+            // Real link state (relay sent `ready`), not merely "a connector exists".
+            connected: Boolean(relay?.connected),
+            controlPlaneUrl: relayConfig?.controlPlaneUrl,
+            relayUrl: relayConfig?.url,
+            ...(relay?.lastError ? { lastError: relay.lastError } : {}),
+        },
         sessions: {
             open: new Set(openSessions.values()).size,
             indexed: metadata.listSessions().length,

package/dist/session/fork.js

@@ -1,4 +1,4 @@
-import { normalizeMessages, buildSeedPrompt, } from "./transcript-normal.js";
+import { normalizeMessages, buildSeedPrompt, buildForkHistory, } from "./transcript-normal.js";
 /**
  * Capture a fork bundle on the source node. Always includes the normalized
  * transcript (the cross-runtime seed, and the fallback when a same-runtime
@@ -9,7 +9,10 @@ import { normalizeMessages, buildSeedPrompt, } from "./transcript-normal.js";
  */
 export function buildForkBundle(opts) {
     const { runtime, sessionFile, record } = opts;
-    const messages = runtime.readMessages?.(sessionFile);
+    // 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;
     const normalized = normalizeMessages(messages, {
         sourceRuntimeId: runtime.id,
         model: record.model,
@@ -24,30 +27,60 @@ export function buildForkBundle(opts) {
     return { record, normalized, ...(native ? { native } : {}), ...(opts.dirtyPatch ? { dirtyPatch: opts.dirtyPatch } : {}) };
 }
 /**
- * Decide the fidelity a fork of `bundle` into `targetRuntime` can achieve —
- * "full" only when the target is the SAME runtime that produced the native
- * payload and can import it; "seeded" otherwise. Pure; no side effects.
+ * Decide the best fidelity a fork of `bundle` into `targetRuntime` can achieve:
+ *   - "full"     when the target is the SAME runtime that produced the native
+ *                payload and can import it (byte-exact resume);
+ *   - "replayed" when a *different* target can import portable history
+ *                (`forkHistoryImport`) and there is history to replay — a true
+ *                fork onto a copy of the transcript;
+ *   - "seeded"   otherwise.
+ * Pure; no side effects. `materializeFork` degrades "replayed"→"seeded" if the
+ * import fails at run time, so this only reports the *intended* fidelity.
  */
 export function resolveForkFidelity(bundle, targetRuntime) {
     const native = bundle.native;
-    const canImport = !!native &&
+    const canImportNative = !!native &&
         native.runtimeId === targetRuntime.id &&
         !!targetRuntime.capabilities.forkTransport &&
         typeof targetRuntime.importForFork === "function";
-    return canImport ? "full" : "seeded";
+    if (canImportNative)
+        return "full";
+    const canReplayHistory = !!targetRuntime.capabilities.forkHistoryImport &&
+        typeof targetRuntime.importHistoryForFork === "function" &&
+        bundle.normalized.turns.length > 0;
+    return canReplayHistory ? "replayed" : "seeded";
 }
 /**
  * Turn a fork bundle into a concrete stand-up plan on the destination node:
- * either resume a natively imported transcript (full) or a seed prompt for a
- * fresh session (seeded). The server executes the returned plan (worktree +
- * session creation live there); this stays pure of daemon wiring.
+ * resume a natively imported transcript (full), replay the portable transcript
+ * as real history in the target's own store (replayed — a true cross-runtime
+ * fork), or a seed prompt for a fresh session (seeded). The server executes the
+ * returned plan (worktree + session creation live there); this stays pure of
+ * daemon wiring.
  */
 export async function materializeFork(opts) {
     const { bundle, targetRuntime, ctx } = opts;
-    if (resolveForkFidelity(bundle, targetRuntime) === "full" && bundle.native && targetRuntime.importForFork) {
+    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 };
     }
+    // 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) {
+        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 };
+            }
+        }
+        catch {
+            // fall through to the seeded continuation below
+        }
+    }
     const seedPrompt = buildSeedPrompt(bundle.normalized, {
         targetAgent: targetRuntime.displayName,
         context: { repoSlug: bundle.record.repoSlug, branch: bundle.record.branch, prUrl: bundle.record.prUrl },

package/dist/session/transcript-normal.js

@@ -90,26 +90,45 @@ function truncate(text, max) {
     return compact.length > max ? `${compact.slice(0, Math.max(0, max - 1))}…` : compact;
 }
 /**
- * Render a compact continuation prompt for a **seeded** (cross-runtime) fork.
+ * Render a continuation prompt for a **seeded** (cross-runtime) fork — the
+ * fallback when the target runtime can't replay history into its own store.
  *
- * Deliberately small — the last N turns plus a link to the full transcript —
- * rather than the entire history: enough to continue coherently, with the full
- * context one click away (the resolved decision in docs/session-fork-plan.md).
- * A structured superset of the old client-side `sessionHandoffSummary`.
+ * The recent-conversation block is **budget-adaptive**, not a fixed tail: it
+ * walks backward from the latest turn packing verbatim turns until `charBudget`
+ * is reached (or the optional `recentTurns` count cap is hit), so a long run of
+ * short turns carries far more context than the old fixed 12, while a few
+ * verbose turns still stay bounded for the target's context window and cost. Any
+ * turns that don't fit are summarised as an omission count that points at the
+ * full transcript — the complete history is one link away. A structured superset
+ * of the old client-side `sessionHandoffSummary`.
  */
 export function buildSeedPrompt(transcript, opts = {}) {
-    const recentTurns = opts.recentTurns ?? 12;
     const perTurnChars = opts.perTurnChars ?? 700;
+    const charBudget = opts.charBudget ?? 12000;
+    const maxCount = opts.recentTurns ?? Number.POSITIVE_INFINITY;
     const title = transcript.header.title || "Untitled session";
     const targetAgent = opts.targetAgent || "a new agent";
-    const recent = transcript.turns
+    const formatted = transcript.turns
         .filter((t) => t.text || t.toolSummary)
-        .slice(-recentTurns)
         .map((t) => {
         const body = t.text || (t.toolSummary ? `[${t.toolName ?? "tool"}] ${t.toolSummary}` : "");
         return `- ${t.role}: ${truncate(body, perTurnChars)}`;
-    })
-        .join("\n");
+    });
+    // Pack the newest turns first, within both the char budget and the count cap.
+    // The most recent turn is always kept, even if it alone exceeds the budget, so
+    // the seed is never empty.
+    const picked = [];
+    let used = 0;
+    for (let i = formatted.length - 1; i >= 0 && picked.length < maxCount; i -= 1) {
+        const cost = formatted[i].length + 1;
+        if (picked.length > 0 && used + cost > charBudget)
+            break;
+        picked.push(formatted[i]);
+        used += cost;
+    }
+    picked.reverse();
+    const omitted = formatted.length - picked.length;
+    const recent = picked.length ? picked.join("\n") : "- (no prior turns were available)";
     const lines = [
         `I am continuing an existing Bivy session (forked from ${transcript.header.sourceRuntimeId} to ${targetAgent}).`,
         `Session: ${title}`,
@@ -119,8 +138,10 @@ export function buildSeedPrompt(transcript, opts = {}) {
         opts.context?.branch ? `Branch: ${opts.context.branch}` : null,
         opts.context?.prUrl ? `PR: ${opts.context.prUrl}` : null,
         "",
-        "Recent conversation (most recent last):",
-        recent || "- (no prior turns were available)",
+        omitted > 0
+            ? `Recent conversation (most recent last; ${omitted} earlier turn${omitted === 1 ? "" : "s"} omitted — see the full transcript${opts.transcriptUrl ? " linked above" : ""}):`
+            : "Recent conversation (most recent last):",
+        recent,
         "",
         opts.transcriptUrl
             ? "Open the full transcript link above if this summary is missing anything, then continue from here."
@@ -128,3 +149,47 @@ export function buildSeedPrompt(transcript, opts = {}) {
     ];
     return lines.filter((line) => line != null).join("\n");
 }
+/**
+ * Render a normalized transcript as portable `{role, text}` turns for a
+ * **replayed** ("true fork") cross-runtime fork — the target runtime writes
+ * these as real prior conversation into its own store and resumes, so the new
+ * agent opens on a copy of the whole history instead of a seeded summary.
+ *
+ * Unlike `buildSeedPrompt` this keeps EVERY turn, not just the tail, and keeps
+ * each turn's own role instead of flattening the conversation into one user
+ * prompt. Two deliberate shaping rules keep the result valid on any target model:
+ *   - Tool activity is inlined as plain text (`[ran X] …`, `[tool result] …`),
+ *     never as provider-specific `tool_use`/`tool_result` blocks whose ids/schemas
+ *     would dangle or mismatch in a different runtime.
+ *   - Non-conversational roles fold into the model's voice: a pure tool-result
+ *     turn and a system/error notice both attach as `assistant` text (the agent's
+ *     own work), so only the human's turns ever carry the `user` role.
+ * Consecutive same-role turns are merged so the resumed history reads as clean
+ * alternating turns. Tool payloads inherit `normalizeMessages`' compaction, so a
+ * replayed fork is faithful in its prose but summarised in raw tool I/O — the
+ * working tree (carried separately as a dirty patch) holds the real file state.
+ */
+export function buildForkHistory(transcript) {
+    const history = [];
+    for (const turn of transcript.turns) {
+        const role = turn.role === "user" ? "user" : "assistant";
+        const parts = [];
+        if (turn.role === "error" && turn.text)
+            parts.push(`[system] ${turn.text}`);
+        else if (turn.text)
+            parts.push(turn.text);
+        if (turn.toolSummary) {
+            const label = turn.role === "tool" ? "tool result" : turn.toolName ? `ran ${turn.toolName}` : "tool";
+            parts.push(`[${label}] ${turn.toolSummary}`);
+        }
+        const text = parts.join("\n\n").trim();
+        if (!text)
+            continue;
+        const last = history[history.length - 1];
+        if (last && last.role === role)
+            last.text = `${last.text}\n\n${text}`;
+        else
+            history.push({ role, text });
+    }
+    return history;
+}

package/package.json

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