@bivy/bivy 0.0.0 → 0.1.0-staging.2

package/dist/session/replicator.js

@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// Owner + standby ORCHESTRATION for warm session replication
+// (docs/session-replication.md). This ties the pure decision core
+// (replication.ts), the transcript log (event-log.ts), and the git checkpoint
+// bundle (checkpoint-pack.ts) together behind an INJECTED transport, so the
+// end-to-end flow is unit-testable without a relay, a daemon, or a second node
+// (test/replicator.test.ts) — mirroring adoption.ts / backpressure.ts.
+//
+// Owner: on each turn boundary, build a frame from the transcript delta + (when
+// worktree sync is on) a git bundle of the new checkpoint, and send it to the
+// standby. Advance the per-standby cursor on ack; on a needFull/resync ack, drop
+// the cursor so the next send is a full frame + full bundle (self-healing).
+//
+// Standby: apply each frame both-or-neither — the git bundle lands first (inside
+// applyReplFrame's fetch step, so a missing prerequisite aborts before the
+// transcript is touched), then the transcript, then the working tree is refreshed.
+import { applyReplFrame, buildReplFrame, cursorOf, initialReplState, } from "./replication.js";
+/**
+ * Per-session owner replicator. Holds the cursor the standby last acked; produces
+ * one wire frame per turn and applies acks. Transport is the caller's job: send
+ * `buildTurnFrame(...)` to the standby and feed its reply to `applyAck(...)`.
+ */
+export class OwnerReplicator {
+    deps;
+    cursors = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** The cursor the standby has acknowledged for a session (undefined = cold). */
+    cursor(sessionId) {
+        return this.cursors.get(sessionId);
+    }
+    /**
+     * Build the frame to send the standby for the current state, or `null` when the
+     * standby is already up to date (no new transcript records and no new checkpoint).
+     */
+    async buildTurnFrame(sessionId) {
+        const cursor = this.cursors.get(sessionId);
+        const [records, epoch] = await Promise.all([
+            Promise.resolve(this.deps.readRecords(sessionId)),
+            Promise.resolve(this.deps.epochOf(sessionId)),
+        ]);
+        const head = await this.deps.checkpointHead(sessionId);
+        const frame = buildReplFrame({
+            sessionId,
+            epoch,
+            records,
+            checkpointCommit: head,
+            runtimeSessionRef: this.deps.runtimeSessionRef?.(sessionId),
+            cursor,
+        });
+        if (!frame)
+            return null;
+        let bundle;
+        if (this.deps.worktreeSync() && head && head !== cursor?.checkpointCommit) {
+            const buf = await this.deps.bundleCheckpoint(sessionId, cursor?.checkpointCommit);
+            if (buf)
+                bundle = buf.toString("base64");
+        }
+        return bundle ? { ...frame, bundle } : frame;
+    }
+    /**
+     * Apply the standby's ack. Returns `true` when the owner should immediately
+     * re-send (the standby asked for a full resync / full bundle) — the caller then
+     * calls `buildTurnFrame` again, which now produces a full frame because the
+     * cursor was dropped.
+     */
+    applyAck(sessionId, ack) {
+        if (ack.status === "applied") {
+            this.cursors.set(sessionId, ack.cursor);
+            return false;
+        }
+        if (ack.status === "resync" || ack.status === "needFull") {
+            // Drop the cursor so the next frame is a full transcript + full bundle.
+            this.cursors.delete(sessionId);
+            return true;
+        }
+        // stale: this owner has been superseded by a promotion — stop replicating.
+        return false;
+    }
+    /** Forget a session (closed/deleted/demoted). */
+    forget(sessionId) {
+        this.cursors.delete(sessionId);
+    }
+}
+/** A sentinel so a missing-prerequisite bundle aborts the frame cleanly. */
+class NeedFullError extends Error {
+}
+/**
+ * Per-session standby applier. Holds the replica `ReplState`; applies each wire
+ * frame both-or-neither and returns the ack the owner needs. Fencing, gap-resync,
+ * and the checkpoint-before-transcript ordering all come from applyReplFrame.
+ */
+export class StandbyApplier {
+    deps;
+    states = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    state(sessionId) {
+        return this.states.get(sessionId);
+    }
+    async receive(frame) {
+        const state = this.states.get(frame.sessionId) ?? initialReplState();
+        this.states.set(frame.sessionId, state);
+        const bundleBuf = frame.bundle ? Buffer.from(frame.bundle, "base64") : undefined;
+        try {
+            const outcome = await applyReplFrame(state, frame, {
+                persist: (sid, records) => this.deps.persistRecords(sid, records),
+                // The checkpoint step (before persisting the transcript): land the git
+                // objects, then refresh the working tree. A missing prerequisite throws
+                // NeedFull so the whole frame aborts without touching the transcript.
+                fetchCheckpoint: bundleBuf
+                    ? async (sid) => {
+                        const res = await this.deps.applyBundle(sid, bundleBuf);
+                        if (!res.ok)
+                            throw new NeedFullError();
+                        await this.deps.materialize(sid);
+                    }
+                    : undefined,
+            });
+            if (outcome.status === "applied")
+                return { status: "applied", cursor: outcome.cursor };
+            if (outcome.status === "resync")
+                return { status: "resync", cursor: outcome.cursor };
+            return { status: "stale", ownerEpoch: outcome.ownerEpoch };
+        }
+        catch (err) {
+            if (err instanceof NeedFullError)
+                return { status: "needFull", cursor: cursorOf(state) };
+            throw err;
+        }
+    }
+    /** Forget a session's replica state (deleted, or promoted to live locally). */
+    forget(sessionId) {
+        this.states.delete(sessionId);
+    }
+}

package/dist/session/session-new-dedupe.js

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// Idempotency for `session.new`, keyed by the client's requestId.
+//
+// Mobile Safari can silently drop a backgrounded PWA's WebSocket reply without
+// ever closing the socket, so the `session.history` answer to a `session.new`
+// never reaches the client and its view wedges on the opening spinner. The
+// client recovers by re-firing the SAME `session.new` (same requestId) once it
+// reconnects. To make that retry safe, creation is deduped by requestId: a
+// concurrent or later request carrying a requestId we've already handled adopts
+// the session the first request created instead of spawning a duplicate.
+//
+// The in-flight Promise is stored synchronously (before any await), so a retry
+// that races the original still joins it rather than creating a second session.
+export function createSessionNewDedupe(options = {}) {
+    const ttlMs = options.ttlMs ?? 10 * 60_000;
+    const schedule = options.schedule ??
+        ((fn, ms) => {
+            setTimeout(fn, ms).unref();
+        });
+    const inflight = new Map();
+    function run(requestId, create) {
+        if (!requestId)
+            return create();
+        const existing = inflight.get(requestId);
+        if (existing)
+            return existing;
+        const p = create();
+        // Register synchronously so a retry racing the original joins this promise
+        // rather than starting a second creation.
+        inflight.set(requestId, p);
+        p.then(() => schedule(() => inflight.delete(requestId), ttlMs), 
+        // A failed creation must not be cached: drop it immediately so a genuine
+        // retry of the same requestId can attempt creation again.
+        () => {
+            inflight.delete(requestId);
+        });
+        return p;
+    }
+    return { run, size: () => inflight.size };
+}

package/dist/session/sibling-client.js

@@ -0,0 +1,201 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// A NODE acting as a relay CLIENT of a sibling node it co-owns — the transport
+// that lets an owner daemon stream replication frames to its standby
+// (docs/session-replication.md). Bivy has no node↔node link; nodes reach each
+// other only the way a phone reaches a node: as a client in the sibling's relay
+// room. This is the node-side port of the browser client
+// (packages/core/src/transport-relay.ts), built on the already-unit-tested
+// node crypto core (relay-cli-crypto.ts) + framing (relay-chunk.ts).
+//
+// Handshake (all relay frames opaque to the relay):
+//   1. POST /node/sibling-link-grant {nodeId} (Bearer enrollment token)
+//        → a client-scoped grant for the sibling (closes the credential gap).
+//   2. POST /client/relay-ticket {nodeId}     (Bearer grant) → single-use ticket.
+//   3. WS  <relay>/client?ticket=..&nodeId=sibling
+//   4. pair.account {grant, devicePublicKeyB64} → pair.welcome {nodePub, wrapped}
+//        → ECDH-unwrap the sibling's room key (acceptWelcome).
+//   5. sealed request/reply frames, correlated by requestId.
+//
+// NOTE: the live path requires a running relay + control plane + a second node,
+// so it is exercised by the multi-node validation plan in the doc, not by an
+// in-process unit test. The framing/correlation logic is kept small and the
+// crypto it calls is unit-tested in relay-cli-crypto.test.ts.
+import { WebSocket } from "ws";
+import { newDeviceKeypair, acceptWelcome, RoomCipher } from "../relay-cli-crypto.js";
+import { frameMessages, FrameReassembler } from "../relay-chunk.js";
+export class SiblingClient {
+    opts;
+    ws;
+    cipher;
+    keypair = newDeviceKeypair();
+    reassembler = new FrameReassembler();
+    pending = new Map();
+    paired;
+    resolvePaired;
+    rejectPaired;
+    closed = false;
+    reqSeq = 0;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    get fetchImpl() {
+        return this.opts.fetchImpl ?? fetch;
+    }
+    /** Connect + pair; resolves once the sibling's room key is established. */
+    async connect() {
+        const cp = this.opts.controlPlaneUrl.replace(/\/$/, "");
+        // 1. Mint a client grant for the sibling using our enrollment token.
+        const grantRes = await this.postJson(`${cp}/node/sibling-link-grant`, this.opts.enrollmentToken, {
+            nodeId: this.opts.siblingNodeId,
+        });
+        const grant = String(grantRes.grant ?? "");
+        if (!grant)
+            throw new Error("sibling-link-grant returned no grant");
+        const relayFromGrant = typeof grantRes.relayUrl === "string" ? grantRes.relayUrl : undefined;
+        // 2. Exchange the grant for a single-use relay ticket.
+        const ticketRes = await this.postJson(`${cp}/client/relay-ticket`, grant, { nodeId: this.opts.siblingNodeId });
+        const ticket = String(ticketRes.ticket ?? "");
+        if (!ticket)
+            throw new Error("relay-ticket returned no ticket");
+        const relayBase = (typeof ticketRes.relayUrl === "string" ? ticketRes.relayUrl : relayFromGrant || this.opts.relayUrl || "").replace(/\/$/, "");
+        if (!relayBase)
+            throw new Error("no relay URL for sibling");
+        // 3. Open the /client socket in the sibling's room.
+        const url = `${relayBase}/client?ticket=${encodeURIComponent(ticket)}&nodeId=${encodeURIComponent(this.opts.siblingNodeId)}`;
+        const WSImpl = this.opts.WebSocketImpl ?? WebSocket;
+        const ws = new WSImpl(url);
+        this.ws = ws;
+        this.paired = new Promise((resolve, reject) => {
+            this.resolvePaired = resolve;
+            this.rejectPaired = reject;
+        });
+        ws.on("message", (data) => this.onMessage(String(data), grant));
+        ws.on("close", () => this.handleClose());
+        ws.on("error", (err) => this.rejectPaired?.(err));
+        await this.paired;
+    }
+    async onMessage(raw, grant) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (msg.t === "ready" || msg.t === "peer.online") {
+            // Begin account pairing to obtain the sibling's room key.
+            // `ephemeral`: a sibling replica is a node↔node bridge, not a user device —
+            // authorized for the room key but never listed as a signed-in device.
+            this.sendControl({ t: "pair", p: { k: "pair.account", sessionToken: grant, devicePublicKeyB64: this.keypair.publicKeyB64, label: this.opts.label ?? "Bivy replica", ephemeral: true } });
+            return;
+        }
+        if (msg.t === "pair") {
+            this.handlePair(msg.p);
+            return;
+        }
+        if (msg.t === "frame" && typeof msg.p === "string" && this.cipher) {
+            const full = this.reassembler.accept(msg);
+            if (!full)
+                return;
+            try {
+                const frame = this.cipher.open(full);
+                this.dispatchEvent(frame.data);
+            }
+            catch {
+                /* undecryptable frame — ignore */
+            }
+        }
+    }
+    handlePair(p) {
+        const k = String(p?.k ?? "");
+        if (k === "pair.welcome") {
+            try {
+                const roomKey = acceptWelcome(this.keypair, { nodePublicKeyB64: String(p.nodePublicKeyB64 ?? ""), wrapped: String(p.wrapped ?? "") });
+                this.cipher = new RoomCipher(roomKey);
+                this.resolvePaired?.();
+            }
+            catch (err) {
+                this.rejectPaired?.(err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+        else if (k === "pair.error") {
+            this.rejectPaired?.(new Error(String(p.error ?? "pairing rejected by sibling")));
+        }
+    }
+    dispatchEvent(event) {
+        const requestId = typeof event.requestId === "string" ? event.requestId : undefined;
+        if (requestId && this.pending.has(requestId)) {
+            const waiter = this.pending.get(requestId);
+            clearTimeout(waiter.timer);
+            this.pending.delete(requestId);
+            waiter.resolve(event);
+            return;
+        }
+        this.opts.onEvent?.(event);
+    }
+    /** Send a command and await its correlated reply event (by requestId). */
+    request(command, timeoutMs = 30_000) {
+        const requestId = `repl-${++this.reqSeq}-${Date.now()}`;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error("sibling reply timed out"));
+            }, timeoutMs);
+            this.pending.set(requestId, { resolve, reject, timer });
+            try {
+                this.sendSealed({ ...command, requestId });
+            }
+            catch (err) {
+                clearTimeout(timer);
+                this.pending.delete(requestId);
+                reject(err instanceof Error ? err : new Error(String(err)));
+            }
+        });
+    }
+    sendSealed(command) {
+        if (!this.cipher || this.ws?.readyState !== WebSocket.OPEN)
+            throw new Error("sibling client not connected");
+        const payload = this.cipher.seal(command);
+        for (const frame of frameMessages(payload)) {
+            if (this.ws?.readyState !== WebSocket.OPEN)
+                throw new Error("sibling client closed mid-send");
+            this.ws.send(frame);
+        }
+    }
+    sendControl(obj) {
+        if (this.ws?.readyState === WebSocket.OPEN)
+            this.ws.send(JSON.stringify(obj));
+    }
+    async postJson(url, bearer, body) {
+        const res = await this.fetchImpl(url, {
+            method: "POST",
+            headers: { "content-type": "application/json", authorization: `Bearer ${bearer}` },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new Error(`${url} → ${res.status}`);
+        return (await res.json());
+    }
+    handleClose() {
+        if (this.closed)
+            return;
+        for (const [, waiter] of this.pending) {
+            clearTimeout(waiter.timer);
+            waiter.reject(new Error("sibling client closed"));
+        }
+        this.pending.clear();
+        this.rejectPaired?.(new Error("closed before pairing"));
+        this.opts.onClose?.();
+    }
+    close() {
+        this.closed = true;
+        try {
+            this.ws?.close();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}

package/dist/session/transcript-merge.js

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// Fold Bivy's per-session sidecars (intermediate reasoning + tool activity) into
+// a runtime's base transcript. Pure and unit-tested (test/transcript-merge.test.ts)
+// so the placement logic is verifiable without the daemon.
+//
+// Why anchoring by TIME, not by an absolute message index:
+//   Each sidecar entry recorded `afterMessageCount = getMessages().length` at the
+//   moment it happened. That's an absolute index into a list whose length
+//   CHANGES — it grows during a turn, and (for runtimes like Claude Code) SHRINKS
+//   when the conversation is compacted. After compaction the base transcript is
+//   shorter than the counts the sidecar recorded, so every over-the-end entry got
+//   clamped to `base.length` and piled up AFTER the final message (a big clump of
+//   recent tool cards below the newest reply — the reported bug).
+//   Messages and sidecar entries both carry an epoch-ms time (`timestamp` /
+//   `createdAt`), and surviving messages keep their timestamps across compaction,
+//   so placing each entry after the base messages that precede it IN TIME is
+//   stable. We fall back to the old clamped-count placement only when timestamps
+//   are unavailable.
+export function normalizedIntermediateText(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+export function thinkingTextFromContent(content) {
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (!part || typeof part !== "object")
+            return "";
+        const record = part;
+        const type = String(record.type || "").toLowerCase();
+        if (type === "thinking")
+            return typeof record.thinking === "string" ? record.thinking : typeof record.text === "string" ? record.text : "";
+        if (type === "reasoning")
+            return typeof record.reasoning === "string" ? record.reasoning : typeof record.text === "string" ? record.text : "";
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+/** Parse a `timestamp` field (epoch-ms number or ISO string) to epoch ms. */
+function toTs(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const t = Date.parse(value);
+        if (!Number.isNaN(t))
+            return t;
+    }
+    return undefined;
+}
+/**
+ * Non-decreasing timeline of the base messages' timestamps. Gaps (a message with
+ * no timestamp) carry forward the previous value so the array stays monotonic and
+ * binary-searchable. `hasTime` is false when NO base message is timestamped, in
+ * which case callers fall back to count-based placement.
+ */
+function baseTimeline(base) {
+    const times = new Array(base.length);
+    let last = 0;
+    let hasTime = false;
+    for (let i = 0; i < base.length; i++) {
+        const t = toTs(base[i]?.timestamp);
+        if (t !== undefined) {
+            hasTime = true;
+            if (t > last)
+                last = t;
+        }
+        times[i] = last;
+    }
+    return { times, hasTime };
+}
+/** Count of `times` entries ≤ `value` (upper bound). `times` is non-decreasing. */
+function countAtOrBefore(times, value) {
+    let lo = 0;
+    let hi = times.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        if (times[mid] <= value)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}
+function insertionIndex(base, timeline, entry) {
+    if (timeline.hasTime && typeof entry.createdAt === "number" && Number.isFinite(entry.createdAt)) {
+        return countAtOrBefore(timeline.times, entry.createdAt);
+    }
+    // Legacy / no-timestamp fallback: clamp the absolute count into range.
+    return Math.max(0, Math.min(base.length, entry.afterMessageCount));
+}
+/**
+ * Merge the `extras` (intermediate + tool-activity sidecar entries) into `base`,
+ * each placed by time (see file header). Deduplicates intermediate reasoning that
+ * already appears in an adjacent persisted message or was emitted twice.
+ */
+export function mergeTranscript(base, extras) {
+    if (!extras.length)
+        return base;
+    const timeline = baseTimeline(base);
+    const byIndex = new Map();
+    const seenIntermediate = new Set();
+    for (const entry of extras) {
+        const index = insertionIndex(base, timeline, entry);
+        if (entry.bivyKind === "intermediate") {
+            const text = normalizedIntermediateText(thinkingTextFromContent(entry.content));
+            // Skip a sidecar reasoning copy when the adjacent persisted message already
+            // carries the same reasoning, and dedupe repeated stream-final copies.
+            const alreadyInTranscript = text && [base[index - 1], base[index]].some((message) => normalizedIntermediateText(thinkingTextFromContent(message?.content)) === text);
+            const dedupeKey = `${index}:${text}`;
+            if (alreadyInTranscript || seenIntermediate.has(dedupeKey))
+                continue;
+            if (text)
+                seenIntermediate.add(dedupeKey);
+        }
+        const bucket = byIndex.get(index) ?? [];
+        bucket.push(entry);
+        byIndex.set(index, bucket);
+    }
+    const merged = [];
+    for (let i = 0; i <= base.length; i++) {
+        const bucket = byIndex.get(i);
+        if (bucket)
+            merged.push(...bucket.sort((a, b) => a.createdAt - b.createdAt));
+        if (i < base.length)
+            merged.push(base[i]);
+    }
+    return merged;
+}

package/dist/session/transcript-normal.js

@@ -0,0 +1,130 @@
+/** Cap a tool payload down to a short, log-safe one-liner. */
+function compactValue(value, max = 200) {
+    let s;
+    try {
+        s = typeof value === "string" ? value : JSON.stringify(value);
+    }
+    catch {
+        s = String(value);
+    }
+    s = String(s ?? "").replace(/\s+/g, " ").trim();
+    return s.length > max ? `${s.slice(0, Math.max(0, max - 1))}…` : s;
+}
+/** Flatten one runtime message's content into text + tool annotations. */
+function readContent(content) {
+    if (typeof content === "string") {
+        return { text: content, tools: [], toolResultOnly: false };
+    }
+    if (!Array.isArray(content)) {
+        return { text: "", tools: [], toolResultOnly: false };
+    }
+    const texts = [];
+    const tools = [];
+    let sawText = false;
+    let sawToolResult = false;
+    for (const raw of content) {
+        const type = raw?.type;
+        if (type === "text" && typeof raw.text === "string") {
+            texts.push(raw.text);
+            sawText = true;
+        }
+        else if (type === "tool_use") {
+            tools.push({ name: raw.name, summary: `${raw.name ?? "tool"}(${compactValue(raw.input)})` });
+        }
+        else if (type === "tool_result") {
+            sawToolResult = true;
+            tools.push({ name: undefined, summary: `→ ${compactValue(raw.content)}` });
+        }
+        // "thinking" and unknown block types are intentionally dropped: internal
+        // reasoning is neither portable across runtimes nor needed for continuity.
+    }
+    return { text: texts.join("\n").trim(), tools, toolResultOnly: sawToolResult && !sawText };
+}
+function normalizeRole(role, toolResultOnly) {
+    if (role === "assistant")
+        return "assistant";
+    if (role === "system" || role === "error")
+        return "error";
+    // A "user" message that is purely tool_result is really tool output.
+    if (role === "user")
+        return toolResultOnly ? "tool" : "user";
+    return "user";
+}
+function toTs(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const t = Date.parse(value);
+        if (!Number.isNaN(t))
+            return t;
+    }
+    return undefined;
+}
+/**
+ * Flatten a runtime transcript (`readMessages()` output) into portable turns.
+ * Pure and defensive: unknown shapes degrade to empty text rather than throwing.
+ */
+export function normalizeMessages(messages, header) {
+    const turns = [];
+    for (const message of messages ?? []) {
+        const m = message;
+        const { text, tools, toolResultOnly } = readContent(m.content);
+        const role = normalizeRole(m.role, toolResultOnly);
+        const namedTool = tools.find((t) => t.name)?.name;
+        const toolSummary = tools.length ? tools.map((t) => t.summary).join("; ") : undefined;
+        // Skip turns that carry nothing a destination could use.
+        if (!text && !toolSummary)
+            continue;
+        turns.push({
+            role,
+            text,
+            ...(namedTool ? { toolName: namedTool } : {}),
+            ...(toolSummary ? { toolSummary } : {}),
+            ...(toTs(m.timestamp ?? m.ts) !== undefined ? { ts: toTs(m.timestamp ?? m.ts) } : {}),
+        });
+    }
+    return { header, turns };
+}
+function truncate(text, max) {
+    const compact = String(text || "").replace(/\s+/g, " ").trim();
+    return compact.length > max ? `${compact.slice(0, Math.max(0, max - 1))}…` : compact;
+}
+/**
+ * Render a compact continuation prompt for a **seeded** (cross-runtime) fork.
+ *
+ * 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`.
+ */
+export function buildSeedPrompt(transcript, opts = {}) {
+    const recentTurns = opts.recentTurns ?? 12;
+    const perTurnChars = opts.perTurnChars ?? 700;
+    const title = transcript.header.title || "Untitled session";
+    const targetAgent = opts.targetAgent || "a new agent";
+    const recent = 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");
+    const lines = [
+        `I am continuing an existing Bivy session (forked from ${transcript.header.sourceRuntimeId} to ${targetAgent}).`,
+        `Session: ${title}`,
+        opts.transcriptUrl ? `Full original transcript: ${opts.transcriptUrl}` : null,
+        transcript.header.model ? `Model before fork: ${transcript.header.model}` : null,
+        opts.context?.repoSlug ? `Repository: ${opts.context.repoSlug}` : null,
+        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)",
+        "",
+        opts.transcriptUrl
+            ? "Open the full transcript link above if this summary is missing anything, then continue from here."
+            : "Continue from here.",
+    ];
+    return lines.filter((line) => line != null).join("\n");
+}

package/dist/session/workspace-context.js

@@ -0,0 +1 @@
+export {};