@bivy/bivy 0.10.1-staging.140 → 0.10.1-staging.142

package/bin/acp-shim.mjs

@@ -125,6 +125,31 @@ let pendingModel = null;
 // right ACP permission request with a concrete optionId.
 const permissionRequests = new Map();
 
+// --- trailing-update drain ---------------------------------------------------
+// opencode's ACP server resolves `session/prompt` (the end_turn reply) BEFORE the
+// final `agent_message_chunk` frames are flushed — a known upstream ordering race
+// (opencode#17505). If the shim declared session.done the instant the prompt reply
+// arrived, the turn would seal at ProtocolRuntime with the reply's tail still
+// unstreamed: the trailing text then streams live (message_update) but never
+// reaches getMessages(), so it vanishes the moment the session reopens. So the
+// turn is NOT done at prompt-resolve — hold session.done until the session/update
+// stream has been quiet for TRAILING_DRAIN_MS, letting the late chunks land while
+// the turn is still open and get sealed into history.
+const TRAILING_DRAIN_MS = 250;
+let turnDrainTimer = null;
+let turnDraining = false;
+function scheduleTurnDone() {
+  clearTimeout(turnDrainTimer);
+  turnDrainTimer = setTimeout(finishTurnDone, TRAILING_DRAIN_MS);
+}
+function finishTurnDone() {
+  turnDrainTimer = null;
+  if (!turnDraining) return;
+  turnDraining = false;
+  bivy({ type: "session.status", status: "idle" });
+  bivy({ type: "session.done" });
+}
+
 // --- tool-call field normalization -------------------------------------------
 // ACP's `tool_call`/`tool_call_update` carries a free-text `title` (whatever
 // prose the agent chose) AND a small fixed `kind` enum (read/edit/delete/move/
@@ -235,6 +260,10 @@ function publishModels(result) {
 function onSessionUpdate(params) {
   const u = params?.update;
   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 textOf = (content) => {
     if (!content) return "";
@@ -432,8 +461,19 @@ async function onBivyCommand(msg) {
         bivy({ replyTo: id, ok: true });
         bivy({ type: "session.status", status: "working" });
         agentRequest("session/prompt", { sessionId, prompt: [{ type: "text", text: String(msg.text ?? "") }] })
-          .then(() => { bivy({ type: "session.status", status: "idle" }); bivy({ type: "session.done" }); })
-          .catch((e) => bivy({ type: "session.error", error: e instanceof Error ? e.message : String(e) }));
+          .then(() => {
+            // The prompt reply is NOT the end of the turn for opencode — the last
+            // agent_message_chunk frames trail it (see the drain note above). Arm
+            // the drain; session.done fires once the update stream goes quiet.
+            turnDraining = true;
+            scheduleTurnDone();
+          })
+          .catch((e) => {
+            clearTimeout(turnDrainTimer);
+            turnDrainTimer = null;
+            turnDraining = false;
+            bivy({ type: "session.error", error: e instanceof Error ? e.message : String(e) });
+          });
         return;
       }
       case "tool.decision": {
@@ -465,6 +505,11 @@ async function onBivyCommand(msg) {
         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.
+        clearTimeout(turnDrainTimer);
+        turnDrainTimer = null;
+        turnDraining = false;
         if (sessionId) agentNotify("session/cancel", { sessionId });
         if (id !== undefined) bivy({ replyTo: id, ok: true });
         return;

package/dist/runtime/index.js

@@ -8,6 +8,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { ClaudeCodeRuntime, claudeRuntimeFromEnv, claudeSdkInstalled } from "./claude-code.js";
 import { deleteCodexSession, discoverNativeCodexSessions, loadCodexTranscript, writeCodexRollout } from "./codex-sessions.js";
+import { deleteOpenCodeSession, loadOpenCodeTranscript, writeOpenCodeHistory } from "./opencode-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`.
@@ -1314,6 +1315,20 @@ function acpRuntimeOptions(opts) {
         // ACP handshake doesn't carry them); a bare ACP agent has none.
         ...(slashCommands ? { slashCommands } : {}),
         ...(opts.credsDir ? { credentials: createCredentialStore(opts.credsDir) } : {}),
+        // OpenCode's own store is SQLite under $XDG_DATA_HOME, so an ACP-promoted
+        // opencode can both read a resumed session's transcript back for history
+        // preload (loadHistory), drop it on delete (deleteHistory), and — the fork
+        // win — materialise a cross-runtime fork's portable history as a REAL session
+        // in that store (writeHistory → capabilities.forkHistoryImport → fidelity
+        // "replayed" instead of a seeded summary prompt). Only opencode has this
+        // layout; a bare ACP agent gets none of these hooks.
+        ...(opts.id === "opencode"
+            ? {
+                loadHistory: (sessionRef) => loadOpenCodeTranscript(sessionRef),
+                deleteHistory: (sessionRef) => void deleteOpenCodeSession(sessionRef),
+                writeHistory: (history, ctx) => writeOpenCodeHistory(history, ctx),
+            }
+            : {}),
     };
 }
 function acpRuntimeFromEnv(credsDir) {

package/dist/runtime/opencode-sessions.js

@@ -0,0 +1,283 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+// OpenCode on-disk session store — the write/read side of materialising a
+// **cross-runtime** fork as a real session in OpenCode's own store (fidelity
+// "replayed", see docs/session-fork-plan.md), the same role codex-sessions.ts
+// plays for Codex.
+//
+// OpenCode (opencode-ai) persists every session in SQLite at
+//   $XDG_DATA_HOME/opencode/opencode.db        (XDG_DATA_HOME → ~/.local/share)
+// in three tables that are the source of truth for a conversation:
+//   - `session`  one row per session (id, slug, title, project_id, model, times)
+//   - `message`  one row per turn (data is JSON: role + model + time)
+//   - `part`     one row per content block (data is JSON: `{type:"text",text}`)
+// The `event`/`event_sequence` tables are OpenCode's event-sourcing log for live
+// sync/streaming; Bivy's governed path (`opencode acp` via bin/acp-shim.mjs)
+// loads a session purely from `session`/`message`/`part` — `session/load` and
+// `session/prompt` resume a hand-written session and replay the full transcript
+// to the model — and `opencode session list` / `opencode export` read the same
+// snapshot, so those three rows are all a replay fork needs.
+//
+// IMPORTANT — best-effort, verified against opencode 1.18.13 (the version
+// pin in CLI_AGENT_SPECS): the schema is version-variable, so the writer checks
+// for the `session`/`message`/`part` tables and throws (never corrupts) when a
+// node's OpenCode layout doesn't match. 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_OPENCODE_NO_FORK_REPLAY=1`.
+// Uses node:sqlite (Node ≥22.19 per engines) — no external dependency.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { DatabaseSync } from "node:sqlite";
+/** Fallback when the DB has no session row to learn the running version from. */
+const FALLBACK_VERSION = "1.18.13";
+/** The project every OpenCode install seeds; used for fork sessions so no
+ *  per-directory project row has to be synthesised. */
+const GLOBAL_PROJECT_ID = "global";
+/** The model recorded on real OpenCode sessions when none is requested. */
+const DEFAULT_MODEL_ID = "big-pickle";
+const DEFAULT_MODEL_PROVIDER = "opencode";
+/** OpenCode's data dir: $XDG_DATA_HOME/opencode (XDG_DATA_HOME → ~/.local/share). */
+export function opencodeDataDir() {
+    const base = process.env.XDG_DATA_HOME?.trim() || path.join(os.homedir(), ".local", "share");
+    return path.join(base, "opencode");
+}
+export function opencodeDbPath() {
+    return path.join(opencodeDataDir(), "opencode.db");
+}
+/** A cuid2-style id (`ses_<24 hex>`) like OpenCode's own ids. */
+function openCodeId(prefix) {
+    return `${prefix}${randomUUID().replace(/-/g, "").slice(0, 24)}`;
+}
+/**
+ * Open the node's OpenCode SQLite store read-write. Throws when the store
+ * doesn't exist or lacks the conversation tables (OpenCode never run, or a
+ * version/schema we don't know) — the caller must treat this as "no replay".
+ */
+function openOpenCodeDb(readWrite) {
+    const file = opencodeDbPath();
+    const present = (() => {
+        try {
+            return fs.existsSync(file);
+        }
+        catch {
+            return false;
+        }
+    })();
+    if (!present)
+        throw new Error(`OpenCode store not found at ${file} (run OpenCode once to create it)`);
+    const db = readWrite ? new DatabaseSync(file) : new DatabaseSync(file, { readOnly: true });
+    if (readWrite) {
+        // Cascade deletes (message/part/event rows under a session) need FK enforcement.
+        db.exec("PRAGMA foreign_keys = ON");
+        // OpenCode runs in WAL mode; a briefly-held writer (a live TUI/server) would
+        // otherwise reject the insert instantly instead of waiting a moment.
+        db.exec("PRAGMA busy_timeout = 5000");
+    }
+    for (const table of ["session", "message", "part"]) {
+        const row = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(table);
+        if (!row) {
+            db.close();
+            throw new Error(`OpenCode store at ${file} is missing the "${table}" table; fork replay requires a compatible OpenCode layout`);
+        }
+    }
+    return db;
+}
+/** The OpenCode version string to stamp on a fork session — learn it from the
+ *  newest session in the store (matches the installed binary), else a fallback. */
+function openCodeVersion(db) {
+    const row = db.prepare("SELECT version FROM session ORDER BY time_created DESC, id LIMIT 1").get();
+    return (row?.version && row.version.trim()) || FALLBACK_VERSION;
+}
+/** Resolve the model to stamp on the fork session from the fork context. */
+function resolveModel(ctx) {
+    const requested = ctx.model?.id?.trim();
+    if (requested) {
+        return {
+            modelID: requested,
+            providerID: ctx.model?.provider?.trim() || (requested.includes("/") ? requested.split("/")[0] : "opencode"),
+        };
+    }
+    return { modelID: DEFAULT_MODEL_ID, providerID: DEFAULT_MODEL_PROVIDER };
+}
+/**
+ * Materialise a **cross-runtime** fork's portable `{role, text}` history as a
+ * real session in OpenCode's own SQLite store — the write-side counterpart to
+ * `loadOpenCodeTranscript`, and OpenCode's `importHistoryForFork` (fidelity
+ * "replayed"). Inserts one `session` row, one `message` row per turn (JSON data
+ * mirroring OpenCode's own), and one `text` `part` row per message, keyed by the
+ * same `ses_`/`msg_`/`prt_` ids OpenCode uses — the exact layout `opencode acp`
+ * `session/load` resumes and `session/prompt` replays as real prior turns.
+ * Returns the new session id, which is both the resume ref and the id. Throws on
+ * any mismatch so the fork engine falls back to a seeded continuation prompt.
+ */
+export function writeOpenCodeHistory(history, ctx) {
+    if (process.env.BIVY_OPENCODE_NO_FORK_REPLAY === "1") {
+        throw new Error("OpenCode fork replay disabled (BIVY_OPENCODE_NO_FORK_REPLAY=1)");
+    }
+    if (history.length === 0)
+        throw new Error("Nothing to replay: fork history is empty");
+    const db = openOpenCodeDb(true);
+    try {
+        const version = openCodeVersion(db);
+        const { modelID, providerID } = resolveModel(ctx);
+        const sessionId = openCodeId("ses_");
+        const now = Date.now();
+        const created = now - history.length; // slightly in the past so the stream orders below now
+        const slug = `fork-${randomUUID().slice(0, 8)}`;
+        const title = "Forked session";
+        const cwd = ctx.cwd;
+        const directory = cwd;
+        const openCodePath = directory.replace(/^\/+/, "");
+        db.exec("BEGIN");
+        try {
+            // project_id → project.id. OpenCode seeds a `global` project only once a
+            // session needs it, so a fresh store may not have one yet — create it (same
+            // row OpenCode itself writes) so the fork session's FK always resolves.
+            db.prepare(`INSERT OR IGNORE INTO project (id, worktree, vcs, name, icon_url, icon_url_override, icon_color,
+          time_created, time_updated, time_initialized, sandboxes, commands)
+         VALUES ('global', '/', NULL, NULL, NULL, NULL, NULL, ?, ?, NULL, '[]', NULL)`).run(now, now);
+            db.prepare(`INSERT INTO session (id, project_id, workspace_id, parent_id, slug, directory, path, title, version,
+          cost, tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write,
+          model, time_created, time_updated)
+         VALUES (?, ?, NULL, NULL, ?, ?, ?, ?, ?, 0, 0, 0, 0, 0, 0, ?, ?, ?)`).run(sessionId, GLOBAL_PROJECT_ID, slug, directory, openCodePath, title, version, JSON.stringify({ id: modelID, providerID }), created, now);
+            const insertMessage = db.prepare(`INSERT INTO message (id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?)`);
+            const insertPart = db.prepare(`INSERT INTO part (id, message_id, session_id, time_created, time_updated, data) VALUES (?, ?, ?, ?, ?, ?)`);
+            let previousId = null;
+            history.forEach((turn, index) => {
+                const messageId = openCodeId("msg_");
+                const timeCreated = created + index;
+                const timeCompleted = timeCreated + 1;
+                let data;
+                if (turn.role === "user") {
+                    data = {
+                        role: "user",
+                        time: { created: timeCreated },
+                        agent: "build",
+                        model: { providerID, modelID },
+                    };
+                }
+                else {
+                    data = {
+                        ...(previousId ? { parentID: previousId } : {}),
+                        role: "assistant",
+                        mode: "build",
+                        agent: "build",
+                        path: { cwd, root: "/" },
+                        cost: 0,
+                        tokens: { total: 0, input: 0, output: 0, reasoning: 0, cache: { write: 0, read: 0 } },
+                        modelID,
+                        providerID,
+                        time: { created: timeCreated, completed: timeCompleted },
+                        finish: "end_turn",
+                    };
+                }
+                insertMessage.run(messageId, sessionId, timeCreated, timeCompleted, JSON.stringify(data));
+                insertPart.run(openCodeId("prt_"), messageId, sessionId, timeCreated, timeCompleted, JSON.stringify({ type: "text", text: turn.text }));
+                previousId = messageId;
+            });
+            db.exec("COMMIT");
+        }
+        catch (error) {
+            db.exec("ROLLBACK");
+            throw error;
+        }
+        return { sessionFile: sessionId, id: sessionId };
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Reconstruct a session's conversation from OpenCode's store as normalized
+ * RuntimeMessages (role + content + timestamp), the same shape loadCodexTranscript
+ * produces — the fast path behind reopening a resumed session (see
+ * ProtocolRuntimeOptions.loadHistory). Best-effort: a missing/unreadable store or
+ * unknown session yields an empty list, never a throw.
+ */
+export function loadOpenCodeTranscript(sessionRef) {
+    const messages = [];
+    let db;
+    try {
+        db = openOpenCodeDb(false);
+    }
+    catch {
+        return messages;
+    }
+    try {
+        const rows = db
+            .prepare("SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY time_created, id")
+            .all(sessionRef);
+        const partRows = db.prepare("SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created, id").all(sessionRef);
+        const partsByMessage = new Map();
+        for (const part of partRows) {
+            let text = "";
+            try {
+                const parsed = JSON.parse(part.data);
+                if (parsed.type === "text" && typeof parsed.text === "string")
+                    text = parsed.text;
+            }
+            catch {
+                // unreadable part — skip its text
+            }
+            if (!text)
+                continue;
+            partsByMessage.set(part.message_id, (partsByMessage.get(part.message_id) ?? "") + text);
+        }
+        for (const row of rows) {
+            let parsed;
+            try {
+                parsed = JSON.parse(row.data);
+            }
+            catch {
+                continue;
+            }
+            if (parsed.role !== "user" && parsed.role !== "assistant")
+                continue;
+            const content = partsByMessage.get(row.id);
+            if (!content)
+                continue;
+            messages.push({ role: parsed.role, content, timestamp: row.time_created });
+        }
+    }
+    finally {
+        db.close();
+    }
+    return messages;
+}
+/**
+ * Remove a session from OpenCode's own store so a user-initiated delete in the
+ * app actually sticks. Children (message/part rows) are removed explicitly so the
+ * cleanup works regardless of the FK action a given OpenCode version declares;
+ * `event`/`event_sequence` rows are left to OpenCode's own reaper (a fork session
+ * never writes them). Best-effort: returns true when a session row was removed; a
+ * missing store or unknown id is not an error. The write-side counterpart to
+ * loadOpenCodeTranscript.
+ */
+export function deleteOpenCodeSession(sessionRef) {
+    let db;
+    try {
+        db = openOpenCodeDb(true);
+    }
+    catch {
+        return false;
+    }
+    try {
+        db.exec("BEGIN");
+        try {
+            db.prepare("DELETE FROM part WHERE session_id = ?").run(sessionRef);
+            db.prepare("DELETE FROM message WHERE session_id = ?").run(sessionRef);
+            const result = db.prepare("DELETE FROM session WHERE id = ?").run(sessionRef);
+            db.exec("COMMIT");
+            return result.changes > 0;
+        }
+        catch (error) {
+            db.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/runtime/protocol.js

@@ -411,6 +411,40 @@ class ProtocolSession {
         if (pending)
             this.turnContent.push({ type: "text", text: pending });
     }
+    /**
+     * Fold assistant text that arrives after the turn was sealed (session.done)
+     * onto the last persisted assistant message — the ACP end_turn race (see the
+     * message.delta branch). The daemon's message_end handler re-snapshots the
+     * base transcript, so the tail survives a reopen; live viewers catch up via
+     * the emitted message_update + message_end. Text with no assistant message to
+     * fold onto is dropped (there is nowhere durable for it to go).
+     */
+    foldLateAssistantDelta(text) {
+        let lastIndex = -1;
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            if (this.messages[i]?.role === "assistant") {
+                lastIndex = i;
+                break;
+            }
+        }
+        if (lastIndex < 0)
+            return;
+        const msg = this.messages[lastIndex];
+        const raw = msg.content;
+        const content = Array.isArray(raw)
+            ? raw
+            : typeof raw === "string" && raw
+                ? [{ type: "text", text: raw }]
+                : [];
+        const lastBlock = content[content.length - 1];
+        if (lastBlock && lastBlock.type === "text")
+            lastBlock.text = `${lastBlock.text ?? ""}${text}`;
+        else
+            content.push({ type: "text", text });
+        msg.content = content;
+        this.emit({ type: "message_update", message: { role: "assistant", content } });
+        this.emit({ type: "message_end", message: { role: "assistant", content } });
+    }
     handleMessage(msg) {
         this.emitter.emit("protocol-message", msg);
         const replyTo = typeof msg.replyTo === "string" ? msg.replyTo : "";
@@ -450,10 +484,22 @@ class ProtocolSession {
         }
         if (type === "message.delta") {
             const text = String(msg.text ?? "");
-            if (!this.assistantText)
-                this.emit({ type: "message_start", message: { role: "assistant", content: "" } });
-            this.assistantText += text;
-            this.emit({ type: "message_update", message: { role: "assistant", content: this.assistantText } });
+            if (!text)
+                return;
+            if (this.streaming) {
+                if (!this.assistantText)
+                    this.emit({ type: "message_start", message: { role: "assistant", content: "" } });
+                this.assistantText += text;
+                this.emit({ type: "message_update", message: { role: "assistant", content: this.assistantText } });
+                return;
+            }
+            // The turn was already sealed (session.done) yet the agent is still
+            // streaming text — the ACP end_turn race where the final agent_message_chunk
+            // frames land after the prompt reply (opencode#17505). The shim drains the
+            // tail before declaring done, but this is the net for a chunk that outlives
+            // the drain: fold it onto the last assistant message so it survives a reopen
+            // instead of opening a fresh draft that is never persisted.
+            this.foldLateAssistantDelta(text);
             return;
         }
         if (type === "message.reasoning" || type === "reasoning.delta") {

package/dist/server.js

@@ -76,7 +76,7 @@ import { captureDirtyPatch, applyDirtyPatch } from "./session/fork-dirty.js";
 import { thinkingTextFromContent } from "./session/transcript-merge.js";
 import { normalizeMessages } from "./session/transcript-normal.js";
 import { buildNativeImportSeedPrompt } from "./session/native-import.js";
-import { EventLog } from "./session/event-log.js";
+import { EventLog, mergeBases } from "./session/event-log.js";
 import { revertFile } from "./session/revert-file.js";
 import { buildDiagnosticsReport, activationRecord } from "./diagnostics.js";
 import { AttachmentStore, isValidAttachmentHash } from "./session/attachment-store.js";
@@ -2443,12 +2443,25 @@ retireTranscriptsDir();
  * with no build-free `readMessages` and no external rollout. Skips the write when the
  * runtime has nothing yet, so a transient empty read can never clobber a good base
  * with `[]`. The log stores it as a bounded delta (see EventLog.appendBaseSnapshot).
+ *
+ * The snapshot must never SHRINK the log. A protocol runtime that resumes via a
+ * blank reconnect (e.g. opencode through the ACP shim: session/load returns no
+ * message history) starts empty and only reports the turns that ran after the
+ * resume — a transcript SHORTER than what the log already holds, despite being
+ * the same ongoing conversation. `appendBaseSnapshot` reads a shorter snapshot
+ * as a compaction and REPLACES the logged base, silently dropping every prior
+ * turn. Rebase the runtime's snapshot onto the logged history instead (the same
+ * union `EventLog.deriveHistory` applies on read): the merged view is exactly
+ * the prefix-extend case the log already handles, so the log grows monotonically.
+ * A genuine runtime compaction isn't a supported feature, so never treating a
+ * snapshot as a shrink is safe.
  */
 function persistTranscriptSnapshot(record) {
     const base = record.session.getMessages();
     if (!base.length)
         return;
-    eventLog.appendBaseSnapshot(record.id, base);
+    const logged = eventLog.readBase(record.id);
+    eventLog.appendBaseSnapshot(record.id, logged.length ? mergeBases(logged, base) : base);
 }
 // In-flight dedupe so two sessions (or two turns) referencing the same remote
 // image URL only ever trigger one outbound fetch. Process-lifetime only — a

package/dist/session/event-log.js

@@ -29,6 +29,30 @@
 import fs from "node:fs";
 import path from "node:path";
 import { normalizedIntermediateText, thinkingTextFromContent, mergeTranscript } from "./transcript-merge.js";
+/**
+ * Union of a persisted base and a runtime's live transcript, such that the result
+ * is never shorter than either input alone. A live session's runtime transcript
+ * extends the persisted base, so the union is just the runtime's (no duplication).
+ * A resumed runtime that reconnected blank and only re-saw post-resume turns
+ * reports a strict prefix of the persisted base, so the union keeps the persisted
+ * copy. Disjoint inputs (a resumed runtime whose new turns aren't in the log yet)
+ * concatenate in log-then-runtime order. Duplicates are collapsed by message
+ * identity, so the same conversation serialized twice never double-appears.
+ */
+export function mergeBases(logged, runtime) {
+    if (!logged.length)
+        return runtime;
+    const known = new Set(logged.map((m) => JSON.stringify(m)));
+    const merged = [...logged];
+    for (const m of runtime) {
+        const key = JSON.stringify(m);
+        if (!known.has(key)) {
+            known.add(key);
+            merged.push(m);
+        }
+    }
+    return merged;
+}
 /** Content-block type carried by a folded outbound attachment. MUST match
  *  `AGENT_ATTACHMENT_BLOCK` in packages/core/src/store-render.ts — the client's
  *  renderHistory keys on this exact string to render the chip. */
@@ -456,12 +480,21 @@ export class EventLog {
     }
     /**
      * The full derived conversation: overlay detail merged into the base transcript.
-     * Prefers the runtime's own live transcript when it has one; otherwise replays the
-     * base persisted in the log (a reopened session on a runtime that can't rebuild it).
-     * This is the single read path — it absorbs the former `mergeConversation` helper.
+     * The base is the UNION of the runtime's live transcript and the base persisted
+     * in the log — never one at the other's expense. A live session's runtime
+     * transcript extends the log (both are the same conversation, the runtime one
+     * message newer), so the union is just the runtime's. But a runtime that resumes
+     * via a blank reconnect (e.g. opencode through the ACP shim: session/load
+     * returns no message history) reports only the turns that ran AFTER the resume —
+     * a truncation of the same conversation, not the whole story. Preferring the
+     * runtime base there would mask every prior turn from every history read, so the
+     * union keeps the log's fuller copy while still surfacing whatever the runtime
+     * alone knows. This is the single read path — it absorbs the former
+     * `mergeConversation` helper.
      */
     deriveHistory(id, runtimeBase) {
-        const base = runtimeBase && runtimeBase.length ? runtimeBase : this.readBase(id);
+        const logged = this.readBase(id);
+        const base = runtimeBase && runtimeBase.length ? mergeBases(logged, runtimeBase) : logged;
         return mergeTranscript(base, this.read(id));
     }
     /** Full ordered record list (already-flushed followed by pending). */

package/package.json

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