@neta-art/cohub-cli 8.1.1 → 8.3.0

package/dist/runtime/native/translate.js

@@ -0,0 +1,263 @@
+import { codexItemContent, piContent } from "../harness.js";
+import { codexTokenTotals, codexUsage, subtractCodexTokens } from "../codex-usage.js";
+import { record } from "../json-rpc.js";
+const text = (value) => typeof value === "string" ? value : "";
+const list = (value) => Array.isArray(value) ? value : [];
+/** Pi emits the same event shapes to its extensions as over RPC. */
+export function piTranslator(emit) {
+    let ordinal = -1;
+    let current = [];
+    let last = { ordinal: 0, content: [] };
+    return {
+        last: () => last,
+        push(event) {
+            const type = text(event.type);
+            const message = record(event.message);
+            if (type === "message_start" && message.role === "assistant") {
+                ordinal += 1;
+                current = [];
+                emit({ type: "message.start", ordinal });
+            }
+            if (type === "message_end" && message.role === "assistant") {
+                current = piContent(message.content);
+                emit({ type: "content.replace", ordinal, content: current });
+            }
+            if (type === "tool_execution_start") {
+                const id = text(event.toolCallId);
+                if (!current.some((block) => block.type === "tool_use" && block.id === id))
+                    current.push({ type: "tool_use", id, name: text(event.toolName), input: record(event.args), _meta: { toolStatus: "running" } });
+                emit({ type: "content.replace", ordinal, content: [...current] });
+            }
+            if (type === "tool_execution_update" || type === "tool_execution_end") {
+                const id = text(event.toolCallId);
+                const raw = type === "tool_execution_end" ? event.result : event.partialResult;
+                const resultContent = typeof raw === "string" ? raw : piContent(record(raw).content);
+                current = current.filter((block) => block.type !== "tool_result" || block.tool_use_id !== id);
+                current.push({ type: "tool_result", tool_use_id: id, content: resultContent, is_error: Boolean(event.isError), _meta: { toolStatus: type === "tool_execution_end" ? "done" : "running" } });
+                emit({ type: "content.replace", ordinal, content: [...current] });
+            }
+            if (type === "message_update") {
+                const delta = record(event.assistantMessageEvent);
+                if (delta.type === "text_delta" || delta.type === "thinking_delta")
+                    emit({ type: "text.delta", ordinal, index: Number(delta.contentIndex ?? 0), kind: delta.type === "text_delta" ? "text" : "thinking", delta: text(delta.delta) });
+            }
+            if (type === "turn_end") {
+                const content = piContent(message.content);
+                for (const value of list(event.toolResults)) {
+                    const result = record(value);
+                    content.push({ type: "tool_result", tool_use_id: text(result.toolCallId), content: typeof result.content === "string" ? result.content : piContent(result.content), is_error: Boolean(result.isError) });
+                }
+                const stopReason = text(message.stopReason);
+                last = { ordinal: Math.max(0, ordinal), content, provider: text(message.provider) || null, model: text(message.model) || null, usage: message.usage, stopReason: stopReason === "toolUse" ? "tool_use" : stopReason || "stop", errorMessage: text(message.errorMessage) || null };
+                emit({ type: "content.replace", ordinal: last.ordinal, content });
+                if (last.stopReason === "tool_use")
+                    emit({ type: "message.commit", message: last });
+            }
+            // The run ends when Pi settles: an automatic retry or compaction continues after `agent_end`,
+            // and extensions are not told whether one follows.
+            return type === "agent_settled" || type === "agent_end" && event.willRetry === false;
+        },
+    };
+}
+/** Codex app-server notifications for one Turn of one thread. */
+export function codexTranslator(emit, identity) {
+    let ordinal = -1;
+    const items = new Map();
+    const ordinals = new Map();
+    const outputs = new Map();
+    const completed = new Set();
+    let pending = null;
+    let final = { ordinal: 0, content: [] };
+    let usage;
+    let baseline;
+    const { provider, model } = identity;
+    const latest = () => {
+        if (pending && pending.ordinal >= ordinal)
+            return pending;
+        const item = [...items.entries()].find(([id]) => ordinals.get(id) === ordinal)?.[1];
+        return { ordinal: Math.max(0, ordinal), content: item ? codexItemContent(item) : [] };
+    };
+    return {
+        last: () => usage ? { ...final, usage } : final,
+        push(event) {
+            const method = text(event.method);
+            const params = record(event.params);
+            if (method === "thread/tokenUsage/updated") {
+                const tokenUsage = record(params.tokenUsage);
+                const total = codexTokenTotals(tokenUsage.total);
+                baseline ??= subtractCodexTokens(total, codexTokenTotals(tokenUsage.last));
+                usage = codexUsage(subtractCodexTokens(total, baseline));
+            }
+            if (method === "item/started") {
+                const item = record(params.item);
+                if (item.type === "userMessage" || completed.has(text(item.id)))
+                    return false;
+                const existing = ordinals.get(text(item.id));
+                if (pending && (existing == null || existing > pending.ordinal)) {
+                    emit({ type: "message.commit", message: pending });
+                    pending = null;
+                }
+                if (existing != null) {
+                    items.set(text(item.id), item);
+                    if (item.type === "agentMessage" && text(item.text))
+                        emit({ type: "content.replace", ordinal: existing, content: codexItemContent(item) });
+                    return false;
+                }
+                ordinal += 1;
+                ordinals.set(text(item.id), ordinal);
+                items.set(text(item.id), item);
+                emit({ type: "message.start", ordinal });
+                if (!["agentMessage", "reasoning", "plan"].includes(text(item.type)))
+                    emit({ type: "content.replace", ordinal, content: codexItemContent(item).filter((block) => block.type !== "tool_result") });
+            }
+            if (method === "item/agentMessage/delta" || method === "item/reasoning/textDelta" || method === "item/reasoning/summaryTextDelta") {
+                const id = text(params.itemId);
+                if (completed.has(id))
+                    return false;
+                const itemOrdinal = ordinals.get(id);
+                const item = items.get(id);
+                if (item) {
+                    if (method === "item/agentMessage/delta")
+                        item.text = text(item.text) + text(params.delta);
+                    else {
+                        const key = method.includes("summary") ? "summary" : "content";
+                        item[key] = [list(item[key]).map(text).join("\n") + text(params.delta)];
+                    }
+                }
+                if (itemOrdinal != null)
+                    emit({ type: "text.delta", ordinal: itemOrdinal, index: 0, kind: method === "item/agentMessage/delta" ? "text" : "thinking", delta: text(params.delta) });
+            }
+            if (method === "item/commandExecution/outputDelta") {
+                const id = text(params.itemId);
+                const item = items.get(id);
+                const itemOrdinal = ordinals.get(id);
+                if (item && itemOrdinal != null) {
+                    const output = (outputs.get(id) ?? "") + text(params.delta);
+                    outputs.set(id, output);
+                    item.aggregatedOutput = output;
+                    emit({ type: "content.replace", ordinal: itemOrdinal, content: codexItemContent(item) });
+                }
+            }
+            if (method === "item/completed") {
+                const item = record(params.item);
+                if (item.type === "userMessage" || completed.has(text(item.id)))
+                    return false;
+                completed.add(text(item.id));
+                const itemOrdinal = ordinals.get(text(item.id)) ?? ++ordinal;
+                if (!ordinals.has(text(item.id))) {
+                    ordinals.set(text(item.id), itemOrdinal);
+                    emit({ type: "message.start", ordinal: itemOrdinal });
+                }
+                items.set(text(item.id), item);
+                const message = { ordinal: itemOrdinal, content: codexItemContent(item), provider, model, stopReason: "stop" };
+                emit({ type: "content.replace", ordinal: itemOrdinal, content: message.content });
+                if (pending && pending.ordinal > itemOrdinal)
+                    emit({ type: "message.commit", message });
+                else {
+                    if (pending && pending.ordinal !== itemOrdinal)
+                        emit({ type: "message.commit", message: pending });
+                    pending = message;
+                }
+            }
+            if (method === "turn/completed") {
+                const turn = record(params.turn);
+                final = { ...latest(), provider, model, stopReason: turn.status === "interrupted" ? "aborted" : turn.status === "failed" ? "error" : "stop", errorMessage: text(record(turn.error).message) || null };
+                return true;
+            }
+            return false;
+        },
+    };
+}
+/**
+ * Revisions only grow, across every preview of this process: the server keeps the highest one, so a
+ * preview restarted within the same millisecond, or after the clock stepped back, still lands.
+ */
+let lastRevision = 0;
+const nextRevision = () => (lastRevision = Math.max(Date.now(), lastRevision + 1));
+/**
+ * The live preview of a Turn a terminal user runs: harness events folded into messages and sent as
+ * ephemeral progress, at most once per interval and only from the first message that changed.
+ */
+export class LiveProgress {
+    sink;
+    intervalMs;
+    messages = [];
+    dirtyFrom = Number.POSITIVE_INFINITY;
+    synced = false;
+    timer = null;
+    inFlight = false;
+    disposed = false;
+    constructor(sink, intervalMs) {
+        this.sink = sink;
+        this.intervalMs = intervalMs;
+    }
+    apply(event) {
+        const ordinal = event.type === "message.start" || event.type === "content.replace" || event.type === "text.delta" ? event.ordinal
+            : event.type === "message.commit" || event.type === "turn.end" ? event.message.ordinal : null;
+        if (ordinal === null)
+            return;
+        const target = this.at(ordinal);
+        if (event.type === "content.replace")
+            target.content = event.content;
+        if (event.type === "message.commit" || event.type === "turn.end")
+            Object.assign(target, { content: event.message.content, provider: event.message.provider ?? null, model: event.message.model ?? null });
+        if (event.type === "text.delta") {
+            const block = target.content[event.index];
+            if (event.kind === "text")
+                target.content[event.index] = block?.type === "text" ? { ...block, text: block.text + event.delta } : { type: "text", text: event.delta };
+            else
+                target.content[event.index] = block?.type === "thinking" ? { ...block, thinking: block.thinking + event.delta } : { type: "thinking", thinking: event.delta };
+        }
+        this.touched(ordinal);
+    }
+    replace(messages) {
+        const first = messages.findIndex((message, index) => JSON.stringify(message) !== JSON.stringify(this.messages[index]));
+        if (first < 0 && messages.length === this.messages.length)
+            return;
+        this.messages = messages.map((message) => ({ ...message, content: [...message.content] }));
+        this.touched(first < 0 ? messages.length : first);
+    }
+    dispose() {
+        this.disposed = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+    }
+    touched(ordinal) {
+        this.dirtyFrom = Math.min(this.dirtyFrom, ordinal);
+        this.schedule();
+    }
+    schedule() {
+        if (this.disposed || this.inFlight)
+            return;
+        this.timer ??= setTimeout(() => { this.timer = null; this.flush(); }, this.intervalMs);
+        this.timer.unref?.();
+    }
+    flush() {
+        if (this.disposed || !Number.isFinite(this.dirtyFrom))
+            return;
+        const from = this.synced ? Math.min(this.dirtyFrom, this.messages.length) : 0;
+        const sent = this.sink({ revision: nextRevision(), from, messages: this.messages.slice(from) });
+        // Not yet recorded: stay dirty, the next event tries again.
+        if (!sent)
+            return;
+        this.dirtyFrom = Number.POSITIVE_INFINITY;
+        this.synced = true;
+        this.inFlight = true;
+        void sent.then((result) => {
+            const outcome = result;
+            if (outcome?.accepted === false || outcome?.resync)
+                this.synced = false;
+        }, () => { this.synced = false; }).finally(() => {
+            this.inFlight = false;
+            // Whatever changed meanwhile goes next; after a refusal, the next send is a full one.
+            if (Number.isFinite(this.dirtyFrom))
+                this.schedule();
+        });
+    }
+    at(ordinal) {
+        for (let index = this.messages.length; index <= ordinal; index += 1)
+            this.messages[index] = { content: [], provider: null, model: null };
+        return this.messages[ordinal];
+    }
+}

package/dist/runtime/native/transport.d.ts

@@ -0,0 +1,7 @@
+import type { NativeRuntimeEvent } from "@neta-art/cohub";
+import type { IngestTransport } from "./ingest.js";
+/**
+ * Transcript ingest travels over the existing Runtime WebSocket: one connection, one credential, no
+ * second channel and no local receipts.
+ */
+export declare function nativeWebSocketTransport(send: (event: NativeRuntimeEvent) => Promise<unknown>): IngestTransport;

package/dist/runtime/native/transport.js

@@ -0,0 +1,16 @@
+/**
+ * Transcript ingest travels over the existing Runtime WebSocket: one connection, one credential, no
+ * second channel and no local receipts.
+ */
+export function nativeWebSocketTransport(send) {
+    const call = async (event, options) => {
+        options?.signal?.throwIfAborted();
+        return await send(event);
+    };
+    return {
+        ingest: (event, options) => call(event, options),
+        known: async (turnIds, options) => (await call({ type: "known", input: { turnIds } }, options)).turns,
+        progress: (event, options) => call(event, options),
+        status: (sessionId, turnId, controllable, options) => call({ type: "status", sessionId, turnId, ...(controllable === undefined ? {} : { controllable }) }, options),
+    };
+}

package/dist/runtime/native/version.d.ts

@@ -0,0 +1,5 @@
+export type Version = readonly [number, number, number];
+/** A harness binary's own version, or `null` when it cannot say. */
+export declare function harnessVersion(binary: string): Promise<Version | null>;
+export declare function atLeast(version: Version | null, minimum: Version): boolean;
+export declare const formatVersion: (version: Version | null) => string;

package/dist/runtime/native/version.js

@@ -0,0 +1,18 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+/** A harness binary's own version, or `null` when it cannot say. */
+export async function harnessVersion(binary) {
+    const { stdout } = await promisify(execFile)(binary, ["--version"], { encoding: "utf8", timeout: 15_000 }).catch(() => ({ stdout: "" }));
+    const match = /(\d+)\.(\d+)\.(\d+)/.exec(stdout);
+    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+export function atLeast(version, minimum) {
+    if (!version)
+        return false;
+    for (let index = 0; index < 3; index += 1) {
+        if (version[index] !== minimum[index])
+            return (version[index] ?? 0) > (minimum[index] ?? 0);
+    }
+    return true;
+}
+export const formatVersion = (version) => version?.join(".") ?? "(unknown version)";

package/dist/runtime/presentation.d.ts

@@ -1,4 +1,5 @@
-import type { NativeSyncConfig } from "./native-sync.js";
+import type { NativeConfig } from "./native/config.js";
+import type { NativeStatus } from "./native/daemon.js";
 import type { RuntimeDiagnostic, RuntimeDiagnosticLevel } from "./diagnostics.js";
 export declare const diagnosticLevels: RuntimeDiagnosticLevel[];
 export declare const atLeastLevel: (level: RuntimeDiagnosticLevel, minimum: RuntimeDiagnosticLevel) => boolean;
@@ -17,14 +18,10 @@ export type RuntimeSummary = {
     workspaceConnected: boolean;
     diagnosticsPath: string;
     background: boolean;
+    native?: NativeStatus;
 };
 export declare function printRuntimeSummary(summary: RuntimeSummary, json?: boolean, reused?: boolean): void;
-export type NativeSessionStatus = {
-    harness: "pi" | "codex";
-    nativeSessionId: string;
-    sessionId: string | null;
-    pendingTurns: number;
-    pendingArchives: number;
-};
-/** `runtime status` native sync block: installation state plus per-Harness pending work. */
-export declare function formatNativeSync(config: NativeSyncConfig | null, sessions: NativeSessionStatus[], error?: string | null): string;
+/** One line of import progress: files and bytes, with an estimate once enough is known. */
+export declare function formatImportProgress(job: NativeStatus["import"], now?: number): string;
+/** `runtime status` native block: what syncs, what can be driven, and backfill progress. */
+export declare function formatNativeSync(config: NativeConfig | null, native: NativeStatus | undefined, error?: string | null): string;

package/dist/runtime/presentation.js

@@ -17,7 +17,9 @@ const messages = {
     "runtime.execution_transport_detached": "Execution continues locally; result replays after reconnect",
     "runtime.execution_transport_invalidated": "Execution interrupted; outcome needs reconciliation",
     "archive.upload_pending": "Archive upload pending; local data retained",
-    "native.sync_pending": "Native sync pending; local records retained",
+    "native.sync_pending": "Native sync pending; the native file is the record and is retried",
+    "native.stop_failed": "Could not stop the native Turn; stop it in the terminal",
+    "native.import_failed": "Import did not start; run cohub runtime import",
     "archive.capture_pending": "Archive capture pending",
     "archive.capture_unavailable": "Archive unavailable; original receipt retained",
     "archive.restore_failed": "Native restore unavailable; using saved history",
@@ -76,19 +78,42 @@ export function printRuntimeSummary(summary, json = false, reused = false) {
         process.stdout.write("  Ctrl+C to stop\n");
     process.stdout.write("\n");
 }
-/** `runtime status` native sync block: installation state plus per-Harness pending work. */
-export function formatNativeSync(config, sessions, error = null) {
+const plural = (count, word) => `${count.toLocaleString("en-US")} ${word}${count === 1 ? "" : "s"}`;
+const megabytes = (bytes) => `${(bytes / 1024 / 1024).toFixed(bytes < 10 * 1024 * 1024 ? 1 : 0)} MB`;
+/** One line of import progress: files and bytes, with an estimate once enough is known. */
+export function formatImportProgress(job, now = Date.now()) {
+    const parts = [`${job.done.toLocaleString("en-US")}/${plural(job.files, "conversation")}`, plural(job.turns, "Turn"), `${megabytes(job.bytes)}/${megabytes(job.totalBytes)}`];
+    const elapsed = job.startedAt ? now - Date.parse(job.startedAt) : 0;
+    if (job.state === "running" && job.bytes > 0 && elapsed > 2_000 && job.totalBytes > job.bytes) {
+        const seconds = Math.round((job.totalBytes - job.bytes) / (job.bytes / elapsed) / 1_000);
+        parts.push(`about ${seconds < 90 ? `${seconds}s` : `${Math.round(seconds / 60)}m`} left`);
+    }
+    return parts.join(" · ");
+}
+/** `runtime status` native block: what syncs, what can be driven, and backfill progress. */
+export function formatNativeSync(config, native, error = null) {
     if (error)
         return `Native sync  unknown — ${error} · fix or remove the config, then runtime up\n`;
     if (!config?.harnesses.length)
         return "Native sync  off · run cohub runtime up to enable\n";
-    const lines = [`Native sync  enabled · ${config.harnesses.join(", ")}`];
-    for (const session of sessions) {
-        lines.push(`  ${session.harness.padEnd(5)} ${session.nativeSessionId.slice(0, 8)}  ${session.pendingTurns} Turns · ${session.pendingArchives} archives pending`);
+    const lines = [`Native sync  ${config.harnesses.map((harness) => harness === "pi" ? "Pi" : "Codex").join(" · ")}`];
+    if (!native)
+        return `${lines[0]} · Runtime not running\n`;
+    if (native.pi) {
+        lines.push(native.pi.unavailable ? `  Pi     read-only · ${native.pi.unavailable}`
+            : native.pi.extension === "installed"
+                ? `  Pi     ${plural(native.pi.connected, "session")} connected`
+                : "  Pi     read-only · install the extension with cohub runtime attach --harness pi, then /reload");
     }
-    if (!sessions.length)
-        lines.push("  No native chats captured yet");
-    else if (sessions.every((session) => !session.pendingTurns && !session.pendingArchives))
-        lines.push("  Up to date");
+    if (native.codex)
+        lines.push(native.codex.control === "shared" ? "  Codex  shared app-server" : "  Codex  read-only in the terminal · Cohub Turns use a private app-server");
+    lines.push(`  Files  ${plural(native.transcripts, "transcript")}${native.running ? ` · ${plural(native.running, "Turn")} running` : ""}`);
+    const job = native.import;
+    if (job.state === "running")
+        lines.push(`  Import ${formatImportProgress(job)}`);
+    else if (job.state === "paused")
+        lines.push(`  Import paused at ${job.done}/${job.files} · run cohub runtime import to continue`);
+    if (job.failed.length)
+        lines.push(`  ${plural(job.failed.length, "conversation")} failed to import · cohub runtime logs`);
     return `${lines.join("\n")}\n`;
 }

package/dist/runtime/projection-store.d.ts

@@ -1,10 +1,5 @@
-import { type NativeProjection, type ProjectionTarget } from "@neta-art/cohub";
+import type { NativeProjection, ProjectionTarget } from "@neta-art/cohub";
 import { type ProjectionSourceTurn, type SessionTurnProjectionClient } from "./turn-projection.js";
-export type ProjectionCursorState = {
-    throughSequence: number | null;
-    throughTurnId: string | null;
-    sourceFingerprint: string | null;
-};
 export type ProjectionStoreInput = {
     spaceId: string;
     sessionId: string;
@@ -14,21 +9,19 @@ export type ProjectionStoreInput = {
     provider?: string | null;
     target: ProjectionTarget;
     throughTurnId: string | null;
-    cursor: ProjectionCursorState | null;
 };
 export type ProjectionStoreResult = {
     projection: NativeProjection;
     turns: ProjectionSourceTurn[];
-    append: boolean;
-    cursor: ProjectionCursorState;
 };
+/** Give the projection's own records (the native header) the identity of the file it becomes. */
 export declare function rebindProjectionNativeSession(result: ProjectionStoreResult, nativeSessionId: string): ProjectionStoreResult;
-/** Reads durable Cohub turns and materializes one harness-specific native projection batch. */
+/**
+ * Materializes a Session's durable Turns into one harness-specific native file. Cohub never appends
+ * to a native file it did not just write, so every projection is complete up to the Session head.
+ */
 export declare class ProjectionStore {
     private readonly source;
     constructor(source: SessionTurnProjectionClient);
     project(input: ProjectionStoreInput, signal?: AbortSignal): Promise<ProjectionStoreResult>;
-    private sourceSequence;
-    cursorForTurn(sessionId: string, turnId: string, signal?: AbortSignal): Promise<ProjectionCursorState>;
-    private readTurns;
 }

package/dist/runtime/projection-store.js

@@ -1,8 +1,6 @@
-import { fingerprintProjectionTurns, HttpError, isProjectionCompaction } from "@neta-art/cohub";
-import { getSessionProjectionTurn, listSessionProjectionTurns, projectTurnBatch } from "./turn-projection.js";
+import { listSessionProjectionTurns, projectTurnBatch } from "./turn-projection.js";
+/** Give the projection's own records (the native header) the identity of the file it becomes. */
 export function rebindProjectionNativeSession(result, nativeSessionId) {
-    if (result.append)
-        return result;
     const records = result.projection.records.map((entry) => {
         if (entry.sourceTurnId !== null)
             return entry;
@@ -17,87 +15,26 @@ export function rebindProjectionNativeSession(result, nativeSessionId) {
     });
     return { ...result, projection: { ...result.projection, records } };
 }
-/** Reads durable Cohub turns and materializes one harness-specific native projection batch. */
+/**
+ * Materializes a Session's durable Turns into one harness-specific native file. Cohub never appends
+ * to a native file it did not just write, so every projection is complete up to the Session head.
+ */
 export class ProjectionStore {
     source;
     constructor(source) {
         this.source = source;
     }
     async project(input, signal) {
-        const throughSequence = input.throughTurnId ? await this.sourceSequence(input.sessionId, input.throughTurnId, signal) : 0;
-        let source = await this.readTurns(input, throughSequence, signal);
-        if (source.append && source.turns.some((turn) => turn.messages.some(isProjectionCompaction))) {
-            source = { turns: await listSessionProjectionTurns(this.source, input.sessionId, { throughSequence, excludeTurnId: input.turnId, signal }), append: false };
-        }
+        const throughSequence = input.throughTurnId ? (await this.source.session(input.sessionId).turns.get(input.throughTurnId, { signal })).turn.sequence : 0;
+        const turns = await listSessionProjectionTurns(this.source, input.sessionId, { throughSequence, excludeTurnId: input.turnId, signal });
         const projection = projectTurnBatch({
             spaceId: input.spaceId,
             sessionId: input.sessionId,
             nativeSessionId: input.nativeSessionId,
             cwd: input.cwd,
             provider: input.provider,
-            turns: source.turns,
-        }, input.target, !source.append);
-        const last = source.turns.at(-1);
-        const previous = source.append ? input.cursor : null;
-        return {
-            projection,
-            turns: source.turns,
-            append: source.append,
-            cursor: {
-                throughSequence: last?.sequence ?? previous?.throughSequence ?? null,
-                throughTurnId: last?.sourceTurnId ?? previous?.throughTurnId ?? null,
-                sourceFingerprint: last ? fingerprintProjectionTurns([last]) : previous?.sourceFingerprint ?? null,
-            },
-        };
-    }
-    async sourceSequence(sessionId, turnId, signal) {
-        const client = this.source.session(sessionId);
-        const response = await client.turns.get(turnId, { signal });
-        return response.turn.sequence;
-    }
-    async cursorForTurn(sessionId, turnId, signal) {
-        const turn = await getSessionProjectionTurn(this.source, sessionId, turnId, signal);
-        return {
-            throughSequence: turn.sequence,
-            throughTurnId: turn.sourceTurnId,
-            sourceFingerprint: fingerprintProjectionTurns([turn]),
-        };
-    }
-    async readTurns(input, throughSequence, signal) {
-        const cursor = input.cursor;
-        if (cursor?.throughSequence != null && cursor.throughSequence > throughSequence) {
-            return { turns: await listSessionProjectionTurns(this.source, input.sessionId, { throughSequence, excludeTurnId: input.turnId, signal }), append: false };
-        }
-        if (cursor?.throughTurnId && cursor.throughSequence != null) {
-            let anchor;
-            try {
-                anchor = await getSessionProjectionTurn(this.source, input.sessionId, cursor.throughTurnId, signal);
-            }
-            catch (error) {
-                if (!(error instanceof HttpError) || error.status !== 404)
-                    throw error;
-                anchor = null;
-            }
-            const anchorFingerprint = anchor ? fingerprintProjectionTurns([anchor]) : null;
-            if (anchorFingerprint !== cursor.sourceFingerprint) {
-                return {
-                    turns: await listSessionProjectionTurns(this.source, input.sessionId, { throughSequence, excludeTurnId: input.turnId, signal }),
-                    append: false,
-                };
-            }
-            return {
-                turns: await listSessionProjectionTurns(this.source, input.sessionId, {
-                    afterSequence: Math.max(1, cursor.throughSequence),
-                    throughSequence,
-                    excludeTurnId: input.turnId,
-                    signal,
-                }),
-                append: true,
-            };
-        }
-        return {
-            turns: await listSessionProjectionTurns(this.source, input.sessionId, { throughSequence, excludeTurnId: input.turnId, signal }),
-            append: false,
-        };
+            turns,
+        }, input.target);
+        return { projection, turns };
     }
 }

package/dist/runtime/supervisor.d.ts

@@ -11,6 +11,8 @@ export type RuntimeLaunch = {
     capabilities?: RuntimeCapabilities;
     background: boolean;
     verbose?: boolean;
+    /** Start importing earlier conversations as soon as the Runtime is connected. */
+    importHistory?: boolean;
 };
 export declare function sandboxOutputLevel(value: unknown, stream: "stdout" | "stderr"): RuntimeDiagnosticLevel;
 export declare function runRuntime(config: RuntimeLaunch, onState: (status: RuntimeSummary) => void, externalSignal?: AbortSignal, onDiagnostic?: (event: RuntimeDiagnostic) => void): Promise<void>;