@neta-art/cohub-cli 10.5.0 → 10.7.0

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

@@ -1,15 +1,16 @@
-import type { RuntimeExecutionEvent, RuntimeTurnInput } from "@neta-art/cohub";
-import { type HarnessOptions } from "../harness.js";
+import { type RuntimeTurnInput } from "@neta-art/cohub";
 import type { RuntimeArchiveStore } from "../archive-store.js";
 import { type RuntimeDiagnosticContext, type RuntimeDiagnostics } from "../diagnostics.js";
-import { type CodexShared } from "./codex-link.js";
+import type { HarnessExecutables, HarnessResult, HarnessTurn } from "../harnesses/types.js";
+import type { CodexShared } from "./codex-link.js";
 import type { NativeIngest } from "./ingest.js";
-import { type PiLink } from "./pi-link.js";
+import type { PiLink } from "./pi-link.js";
 import type { ExecutionResults } from "./results.js";
-import type { NativeSession, NativeSessions } from "./sessions.js";
+import type { NativeSessions } from "./sessions.js";
+export type { HarnessResult } from "../harnesses/types.js";
 export type Executor = {
     cwd: string;
-    executables: HarnessOptions;
+    executables: HarnessExecutables;
     sessions: NativeSessions;
     results: ExecutionResults;
     ingest: NativeIngest;
@@ -19,27 +20,5 @@ export type Executor = {
     piExtension: string;
     diagnostics?: RuntimeDiagnostics;
 };
-export type HarnessResult = {
-    session: NativeSession;
-    event: Extract<RuntimeExecutionEvent, {
-        type: "turn.end";
-    }>;
-    uncertainCleanup?: {
-        processGroupId: number;
-        error: string;
-    };
-};
-type Turn = {
-    input: RuntimeTurnInput;
-    emit: (event: RuntimeExecutionEvent) => void;
-    signal: AbortSignal;
-    diverged: string | null;
-    started: (session: NativeSession) => Promise<void>;
-};
-/**
- * Run one Cohub Turn in a local harness. Both harnesses are driven through the same interface a
- * terminal user shares: Pi through the Cohub extension inside the Pi process, Codex through its
- * app-server.
- */
-export declare function executeTurn(executor: Executor, input: RuntimeTurnInput, emit: Turn["emit"], signal: AbortSignal, requestId: string | null, context?: RuntimeDiagnosticContext): Promise<HarnessResult>;
-export {};
+/** Run one Cohub Turn in a local harness through its adapter. */
+export declare function executeTurn(executor: Executor, input: RuntimeTurnInput, emit: HarnessTurn["emit"], signal: AbortSignal, requestId: string | null, context?: RuntimeDiagnosticContext): Promise<HarnessResult>;

package/dist/runtime/native/execution.js

@@ -1,26 +1,14 @@
-import { harnessCommand, imageForPi } from "../harness.js";
-import { JsonRpcProcess, record, RpcProcessClosedError } from "../json-rpc.js";
-import { describeError } from "../../network-error.js";
-import { ProcessCleanupUncertainError } from "../process-group.js";
+import { assertHarnessAccess } from "@neta-art/cohub";
 import { serializeDiagnosticError } from "../diagnostics.js";
-import { openPrivateServer } from "./codex-link.js";
-import { PI_DISCONNECTED } from "./pi-link.js";
-import { codexTranslator, piTranslator } from "./translate.js";
-const text = (value) => typeof value === "string" ? value : "";
-/** A stop request that the harness does not honour within this long ends its private process. */
-const ABORT_ESCALATION_MS = 5_000;
-/** Pause before asking a busy Pi again, so a Turn that is starting has reported itself. */
-const PI_BUSY_RETRY_MS = 100;
-/**
- * Run one Cohub Turn in a local harness. Both harnesses are driven through the same interface a
- * terminal user shares: Pi through the Cohub extension inside the Pi process, Codex through its
- * app-server.
- */
+import { harnessAdapter } from "../harnesses/index.js";
+import { closeHost } from "../harnesses/process.js";
+/** Run one Cohub Turn in a local harness through its adapter. */
 export async function executeTurn(executor, input, emit, signal, requestId, context) {
     signal.throwIfAborted();
+    assertHarnessAccess(input.harness, input.accessMode);
     const diverged = await executor.results.admit(input);
-    const turn = { input, emit, signal, diverged, started: (session) => executor.results.start(session, input, requestId) };
-    const run = await (input.harness === "pi" ? runPi : runCodex)(executor, turn, context);
+    const turn = { input, emit, signal, diverged, started: (session) => executor.results.start(session, input, requestId), context };
+    const run = await harnessAdapter(input.harness).run(executor, turn);
     let uncertainCleanup;
     if (run.host)
         uncertainCleanup = await closeHost(run.host, run.message.errorMessage);
@@ -33,309 +21,3 @@ export async function executeTurn(executor, input, emit, signal, requestId, cont
     executor.ingest.advance(run.session.path, input.turnId);
     return { session: run.session, event: { type: "turn.end", message, resume: run.resume, archive }, ...(uncertainCleanup ? { uncertainCleanup } : {}) };
 }
-/** Variables a Turn's tools see, so a `cohub` call inside a tool knows where it runs. */
-const turnEnvironment = (input) => ({ COHUB_SPACE_ID: input.spaceId, COHUB_SESSION_ID: input.sessionId, COHUB_TURN_ID: input.turnId });
-async function runPi(executor, turn, context) {
-    const { input, signal } = turn;
-    if (input.accessMode === "read_only")
-        throw new Error("Pi cannot enforce read-only access; select Cohub or Codex");
-    // Cohub drives every Pi through its extension, which needs the control socket and a recent Pi.
-    if (executor.pi.unavailable)
-        throw new Error(executor.pi.unavailable);
-    const prepared = await executor.sessions.prepare({
-        sessionId: input.sessionId, turnId: input.turnId, harness: "pi", cwd: executor.cwd,
-        provider: input.provider, context: input.context, signal,
-        // A terminal Pi is continued only through its extension; without one it is read-only.
-        resumable: (transcript) => transcript.path !== turn.diverged && (transcript.origin === "cohub" || executor.pi.find(transcript.nativeSessionId) !== null),
-    });
-    let session = prepared.session;
-    let link = executor.pi.find(session.nativeSessionId);
-    let host = null;
-    let message = { ordinal: 0, content: [] };
-    let begun = false;
-    try {
-        if (!link) {
-            host = new JsonRpcProcess(...harnessCommand(executor.executables.pi || "pi", ["--mode", "rpc", "--session", session.path, "-e", executor.piExtension], executor.cwd), executor.cwd, "pi", turnEnvironment(input));
-            watchHost(host, executor.diagnostics, context);
-            const rpc = host;
-            // Nobody is at this Pi's terminal to answer an extension's question.
-            rpc.onEvent((event) => {
-                if (event.type === "extension_ui_request" && ["confirm", "select", "input", "editor"].includes(text(event.method)))
-                    rpc.write({ type: "extension_ui_response", id: event.id, cancelled: true });
-            });
-            await configurePiHost(host, input);
-            link = await Promise.race([
-                executor.pi.waitFor({ sessionId: session.nativeSessionId, sessionFile: session.path }, signal),
-                new Promise((_, reject) => host?.onFailure(reject)),
-            ]);
-        }
-        const piSession = link;
-        session = { ...session, nativeSessionId: piSession.sessionId };
-        // Never interleave with a Turn a terminal user is running; follow it instead.
-        await executor.pi.idle(piSession.sessionId, signal);
-        const content = await piPrompt(input);
-        signal.throwIfAborted();
-        await turn.started(session);
-        begun = true;
-        const translator = piTranslator(turn.emit);
-        const model = !host && input.model && input.provider ? { provider: input.provider, id: input.model } : null;
-        await new Promise((resolve, reject) => {
-            let escalation;
-            /** Events held until Pi takes the prompt; until then they belong to a terminal Turn. */
-            let held = [];
-            let done = false;
-            const finish = (error) => {
-                if (done)
-                    return;
-                done = true;
-                off();
-                signal.removeEventListener("abort", abort);
-                clearTimeout(escalation);
-                if (error)
-                    reject(error);
-                else
-                    resolve();
-            };
-            const feed = (event) => {
-                try {
-                    if (translator.push(event))
-                        finish();
-                }
-                catch (error) {
-                    finish(error);
-                }
-            };
-            const off = executor.pi.subscribe(piSession.sessionId, (event) => {
-                if (event.type === PI_DISCONNECTED) {
-                    finish(new Error("Pi exited during the Turn"));
-                    return;
-                }
-                if (held)
-                    held.push(event);
-                else
-                    feed(event);
-            });
-            const abort = () => {
-                // Not taken yet: the Pi is running someone else's Turn, which is not Cohub's to stop.
-                if (held) {
-                    finish(signal.reason ?? new Error("Aborted"));
-                    return;
-                }
-                void executor.pi.abort(piSession.sessionId).catch(() => undefined);
-                if (host)
-                    escalation = setTimeout(() => void host?.close().catch(() => undefined), ABORT_ESCALATION_MS);
-            };
-            signal.addEventListener("abort", abort, { once: true });
-            void (async () => {
-                for (;;) {
-                    // Only what follows this request can be this Turn's.
-                    held = [];
-                    const { accepted } = await executor.pi.prompt(piSession.sessionId, { turnId: input.turnId, content, model, thinkingLevel: host ? null : input.thinkingLevel ?? null, env: turnEnvironment(input) });
-                    if (accepted)
-                        break;
-                    // The terminal started a Turn first: wait for it to settle, then ask again.
-                    await new Promise((resolve) => setTimeout(resolve, PI_BUSY_RETRY_MS));
-                    await executor.pi.idle(piSession.sessionId, signal);
-                    if (done)
-                        return;
-                }
-                const events = held ?? [];
-                held = null;
-                if (done) {
-                    void executor.pi.abort(piSession.sessionId).catch(() => undefined);
-                    return;
-                }
-                for (const event of events)
-                    feed(event);
-                if (signal.aborted)
-                    abort();
-            })().catch(finish);
-            if (signal.aborted)
-                abort();
-        });
-        message = translator.last();
-        // The Pi keeps running for its terminal user; its tools no longer work for this Turn.
-        if (!host)
-            void executor.pi.context(piSession.sessionId, { COHUB_TURN_ID: null }).catch(() => undefined);
-    }
-    catch (error) {
-        // Before the prompt, nothing ran and the error is the outcome.
-        if (!begun) {
-            if (host)
-                await closeHost(host, null).catch(() => undefined);
-            throw error;
-        }
-        message = { ...message, stopReason: signal.aborted ? "aborted" : "error", errorMessage: signal.aborted ? null : describeError(error) };
-    }
-    return { session, resume: prepared.resume, message, host };
-}
-/** A Pi that Cohub starts is configured through its RPC before the extension takes the prompt. */
-async function configurePiHost(host, input) {
-    if (input.model) {
-        let provider = input.provider;
-        if (!provider) {
-            const catalog = await host.request("get_available_models");
-            const matches = (Array.isArray(catalog.models) ? catalog.models : []).map(record).filter((model) => model.id === input.model);
-            if (matches.length !== 1)
-                throw new Error("Select a provider for this local model");
-            provider = text(matches[0]?.provider);
-        }
-        await host.request("set_model", { provider, modelId: input.model });
-    }
-    if (input.thinkingLevel)
-        await host.request("set_thinking_level", { level: input.thinkingLevel });
-}
-async function piPrompt(input) {
-    const blocks = input.messages.flatMap((message) => message.content);
-    return await Promise.all(blocks.map(async (block) => {
-        if (block.type === "image")
-            return await imageForPi(block);
-        return { type: "text", text: block.type === "text" ? block.text : JSON.stringify(block) };
-    }));
-}
-async function runCodex(executor, turn, context) {
-    const { input, signal } = turn;
-    const shared = await executor.codex.get();
-    const prepared = await executor.sessions.prepare({
-        sessionId: input.sessionId, turnId: input.turnId, harness: "codex", cwd: executor.cwd,
-        provider: input.provider, context: input.context, signal,
-        // Only the shared server coordinates with terminal clients; a private one never opens their files.
-        resumable: (transcript) => transcript.path !== turn.diverged && (transcript.origin === "cohub" || shared !== null),
-    });
-    let session = prepared.session;
-    let host = null;
-    let channel = shared;
-    let message = { ordinal: 0, content: [] };
-    let begun = false;
-    try {
-        if (!channel) {
-            host = new JsonRpcProcess(...harnessCommand(executor.executables.codex || "codex", ["app-server", "--listen", "stdio://"], executor.cwd), executor.cwd, "codex", turnEnvironment(input));
-            watchHost(host, executor.diagnostics, context);
-            channel = await openPrivateServer(host);
-        }
-        const codex = channel;
-        const threadOptions = {
-            cwd: executor.cwd,
-            ...(input.model ? { model: input.model } : {}),
-            ...(input.provider && input.provider !== "codex" ? { modelProvider: input.provider } : {}),
-            ...(input.accessMode === "read_only" ? { sandbox: "read-only" } : {}),
-            // Tools of a shared server otherwise see the environment of whoever started that server.
-            config: { "shell_environment_policy.set.COHUB_SPACE_ID": input.spaceId, "shell_environment_policy.set.COHUB_SESSION_ID": input.sessionId },
-        };
-        const existing = { ...threadOptions, threadId: session.nativeSessionId, path: session.path, excludeTurns: true };
-        const opened = prepared.resume === "new" ? await codex.request("thread/start", threadOptions)
-            : prepared.resume === "restored" ? await codex.request("thread/fork", existing)
-                : await codex.request("thread/resume", existing);
-        const thread = record(opened.thread);
-        if (typeof thread.id !== "string" || typeof thread.path !== "string")
-            throw new Error("Codex did not provide a durable native thread");
-        const threadId = thread.id;
-        if (thread.path !== session.path || threadId !== session.nativeSessionId) {
-            session = { ...session, nativeSessionId: threadId, path: thread.path };
-            executor.ingest.adopt(session, input.sessionId);
-        }
-        const translator = codexTranslator(turn.emit, { provider: text(opened.modelProvider) || "codex", model: text(opened.model) || input.model || null });
-        const content = await codexPrompt(input);
-        signal.throwIfAborted();
-        await turn.started(session);
-        begun = true;
-        let nativeTurnId = null;
-        executor.codex.driving.add(threadId);
-        await new Promise((resolve, reject) => {
-            let escalation;
-            let done = false;
-            const finish = (error) => {
-                if (done)
-                    return;
-                done = true;
-                off();
-                offClose();
-                signal.removeEventListener("abort", abort);
-                clearTimeout(escalation);
-                if (error)
-                    reject(error);
-                else
-                    resolve();
-            };
-            const interrupt = () => { if (nativeTurnId)
-                void codex.request("turn/interrupt", { threadId, turnId: nativeTurnId }).catch(() => undefined); };
-            const off = codex.onEvent((event) => {
-                const params = event.params;
-                if (event.id != null) {
-                    // An unattended Cohub Turn never grants an escalation.
-                    if (!codex.shared || params.threadId === threadId && (!nativeTurnId || params.turnId === nativeTurnId))
-                        codex.refuse(event.id, "Approval requires an interactive local client");
-                    return;
-                }
-                if (params.threadId !== threadId)
-                    return;
-                // A resumed thread replays its last usage; only this Turn's counts belong to it.
-                if (event.method === "thread/tokenUsage/updated" && params.turnId !== nativeTurnId)
-                    return;
-                if (event.method === "turn/started" && !nativeTurnId) {
-                    nativeTurnId = text(record(params.turn).id) || null;
-                    if (signal.aborted)
-                        interrupt();
-                }
-                if (event.method === "turn/completed" && nativeTurnId && text(record(params.turn).id) !== nativeTurnId)
-                    return;
-                try {
-                    if (translator.push(event))
-                        finish();
-                }
-                catch (error) {
-                    finish(error);
-                }
-            });
-            const offClose = codex.onClose((error) => finish(error));
-            const abort = () => {
-                interrupt();
-                if (host)
-                    escalation = setTimeout(() => void host?.close().catch(() => undefined), ABORT_ESCALATION_MS);
-            };
-            signal.addEventListener("abort", abort, { once: true });
-            codex.request("turn/start", { threadId, clientUserMessageId: input.turnId, input: content, ...(input.thinkingLevel ? { effort: input.thinkingLevel === "off" ? "none" : input.thinkingLevel } : {}) })
-                .then((result) => { nativeTurnId ??= text(record(result.turn).id) || null; if (signal.aborted)
-                interrupt(); })
-                .catch(finish);
-        }).finally(() => executor.codex.driving.delete(threadId));
-        message = translator.last();
-    }
-    catch (error) {
-        if (!begun) {
-            if (host)
-                await closeHost(host, null).catch(() => undefined);
-            throw error;
-        }
-        message = { ...message, stopReason: signal.aborted ? "aborted" : "error", errorMessage: signal.aborted ? null : describeError(error) };
-    }
-    return { session, resume: prepared.resume, message, host };
-}
-async function codexPrompt(input) {
-    return await Promise.all(input.messages.flatMap((message) => message.content).map(async (block) => {
-        if (block.type === "image") {
-            const image = await imageForPi(block);
-            return { type: "image", url: `data:${image.mimeType};base64,${image.data}` };
-        }
-        return { type: "text", text: block.type === "text" ? block.text : JSON.stringify(block), text_elements: [] };
-    }));
-}
-function watchHost(host, diagnostics, context) {
-    if (!diagnostics)
-        return;
-    host.onFailure((error) => {
-        if (!(error instanceof RpcProcessClosedError))
-            diagnostics.log("error", "harness.rpc_process_failed", { error: serializeDiagnosticError(error) }, { ...context, component: "harness" });
-    });
-    host.onTimeout((method, timeoutMs) => diagnostics.log("error", "harness.rpc_timeout", { method, timeoutMs }, { ...context, component: "harness" }));
-}
-/** Close a harness process Cohub started. An unconfirmable cleanup marks the result uncertain; it never masks it. */
-async function closeHost(host, executionError) {
-    return await host.close().then(() => undefined, (cleanupError) => {
-        const processGroupId = host.processGroupId;
-        if (!(cleanupError instanceof ProcessCleanupUncertainError) || processGroupId == null)
-            throw cleanupError;
-        const detail = executionError ? `; execution error: ${executionError}` : "";
-        return { processGroupId, error: `${cleanupError.message}${detail}` };
-    });
-}

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

@@ -1,9 +1,9 @@
+import type { LocalHarness } from "@neta-art/cohub";
 /** Deterministic UUID-shaped id. A native Turn always names the same cloud Turn. */
 export declare function nativeStableId(value: string): string;
 /**
  * Cloud Turn id of a native Turn. A transcript can reach more than one Space (a directory rebound
- * to another Space, or another account), so the Space is part of the identity; within it, Codex
- * Turn ids are globally unique (a fork shares its history's Turns) and Pi entry ids are per
- * session.
+ * to another Space, or another account), so the Space is part of the identity; within it, globally
+ * unique Turn keys (Codex: a fork shares its history's Turns) stand alone and others are per session.
  */
-export declare function nativeTurnId(spaceId: string, harness: "pi" | "codex", nativeSessionId: string, turnKey: string): string;
+export declare function nativeTurnId(spaceId: string, harness: LocalHarness, nativeSessionId: string, turnKey: string): string;

package/dist/runtime/native/identity.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { transcriptFormat } from "../harnesses/index.js";
 /** Deterministic UUID-shaped id. A native Turn always names the same cloud Turn. */
 export function nativeStableId(value) {
     const hex = createHash("sha256").update(value).digest("hex");
@@ -6,10 +7,9 @@ export function nativeStableId(value) {
 }
 /**
  * Cloud Turn id of a native Turn. A transcript can reach more than one Space (a directory rebound
- * to another Space, or another account), so the Space is part of the identity; within it, Codex
- * Turn ids are globally unique (a fork shares its history's Turns) and Pi entry ids are per
- * session.
+ * to another Space, or another account), so the Space is part of the identity; within it, globally
+ * unique Turn keys (Codex: a fork shares its history's Turns) stand alone and others are per session.
  */
 export function nativeTurnId(spaceId, harness, nativeSessionId, turnKey) {
-    return nativeStableId(JSON.stringify(harness === "pi" ? ["native", spaceId, "pi", nativeSessionId, turnKey] : ["native", spaceId, "codex", turnKey]));
+    return nativeStableId(JSON.stringify(transcriptFormat(harness).globalTurnKeys ? ["native", spaceId, harness, turnKey] : ["native", spaceId, harness, nativeSessionId, turnKey]));
 }

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

@@ -72,11 +72,11 @@ export type IngestTransport = {
 };
 export type IngestHooks = {
     /**
-     * Control-plane certainty about a Pi session's file as last written at `mtimeMs`: `true` when the
+     * Control-plane certainty about a session's file as last written at `mtimeMs`: `true` when the
      * agent settled after that write, `false` while it runs, `null` when the control plane cannot
      * tell.
      */
-    piSettled?: (nativeSessionId: string, mtimeMs: number) => boolean | null;
+    settled?: (state: TranscriptState, mtimeMs: number) => boolean | null;
     controllable?: (state: TranscriptState) => boolean;
     abortTurn?: (state: TranscriptState) => void;
     onGrowth?: (state: TranscriptState) => void;

package/dist/runtime/native/ingest.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { NATIVE_INGEST_MAX_TURNS, SETTLED_TURN_STATUSES } from "@neta-art/cohub";
 import { acceptsDirectory, acceptsTranscript, readSessionHeader, readTranscript, transcriptRoots } from "./adapters.js";
 import { nativeTurnId } from "./identity.js";
-import { ensurePlainCodexRollout } from "./transcript.js";
+import { transcriptFormat } from "../harnesses/index.js";
 import { containsNativePath } from "./paths.js";
 const missing = (error) => error?.code === "ENOENT";
 /** Transcripts read in parallel per lane. The live lane never waits behind a backfill. */
@@ -12,11 +12,9 @@ export const DEFAULT_IMPORT_CONCURRENCY = 4;
 export const MAX_IMPORT_CONCURRENCY = 8;
 /** A harness writes one Turn as many appends; filesystem events are coalesced for this long. */
 const WATCH_DEBOUNCE_MS = 150;
-/** A quiet Pi transcript whose last reply ended is settled after this long. */
-const PI_QUIET_SETTLE_MS = 10_000;
+/** A quiet transcript whose last reply ended is settled after this long, unless the file records Turn ends. */
+const QUIET_SETTLE_MS = 10_000;
 const SETTLED_STATUSES = new Set(SETTLED_TURN_STATUSES);
-/** Pi stop reasons that end a reply; anything else (a tool call) means more is coming. */
-const PI_ENDED = ["stop", "length", "error", "aborted"];
 /** A running Turn that shows signs of life tells the server at most this often. */
 const ALIVE_INTERVAL_MS = 5 * 60_000;
 /** A failed read is retried this many times with backoff; afterwards the next write or reconnect retries. */
@@ -28,15 +26,6 @@ const RETRY_MAX_MS = 5 * 60_000;
  * small enough to answer well within the request timeout; the protocol allows more.
  */
 const INGEST_BATCH_TURNS = Math.min(50, NATIVE_INGEST_MAX_TURNS);
-/**
- * Records that end or begin a Turn. New bytes of a known transcript are only searched for these;
- * the transcript is parsed and sent when one appears.
- */
-const BOUNDARIES = {
-    codex: ['"UserMessage"', '"user_message"', '"turn_complete"', '"task_complete"', '"turn_aborted"'],
-    pi: ['"role":"user"', ...PI_ENDED.map((reason) => `"stopReason":"${reason}"`)],
-};
-const BOUNDARY_OVERLAP = Math.max(...Object.values(BOUNDARIES).flat().map((token) => token.length));
 const IMPORT_FAILURES_KEPT = 100;
 /** Headers are read this many at a time; each costs one small read. */
 const HEADER_CONCURRENCY = 16;
@@ -272,7 +261,8 @@ export class NativeIngest {
     }
     status() {
         return {
-            transcripts: this.states.size,
+            // Cohub Turns of other harnesses are tracked here too; only synced transcripts count.
+            transcripts: [...this.states.values()].filter((state) => this.harnesses.includes(state.harness)).length,
             live: this.live.size + this.runningLive,
             running: [...this.states.values()].filter((state) => state.runningTurnId).length,
             import: { ...this.job, queued: this.importQueue.length, running: this.runningImport },
@@ -531,18 +521,21 @@ export class NativeIngest {
         this.markDirty(path);
     }
     async crossesBoundary(path, harness, from, to) {
+        // New bytes of a known transcript are only searched for records that begin or end a Turn.
+        const tokens = transcriptFormat(harness).boundaries;
+        const overlap = Math.max(0, ...tokens.map((token) => token.length));
         const file = await open(path, "r");
         try {
-            const chunk = Buffer.alloc(Math.min(to - from + BOUNDARY_OVERLAP, 1024 * 1024));
+            const chunk = Buffer.alloc(Math.min(to - from + overlap, 1024 * 1024));
             for (let position = from; position < to;) {
-                const start = Math.max(0, position - BOUNDARY_OVERLAP);
+                const start = Math.max(0, position - overlap);
                 const { bytesRead } = await file.read(chunk, 0, Math.min(chunk.length, to - start), start);
                 if (bytesRead <= position - start)
                     break;
                 const bytes = chunk.subarray(0, bytesRead);
                 // A token that ends inside the bytes already searched was seen before; it does not count again.
                 const fresh = position - start;
-                for (const token of BOUNDARIES[harness]) {
+                for (const token of tokens) {
                     for (let index = bytes.indexOf(token); index >= 0; index = bytes.indexOf(token, index + 1))
                         if (index + token.length > fresh)
                             return true;
@@ -566,17 +559,18 @@ export class NativeIngest {
         return null;
     }
     tailSettled(state, tail, mtimeMs) {
-        if (state.harness === "codex")
+        const format = transcriptFormat(state.harness);
+        if (format.turnEndRecorded)
             return tail.result !== null;
-        const certain = this.options.hooks?.piSettled?.(state.nativeSessionId, mtimeMs);
+        const certain = this.options.hooks?.settled?.(state, mtimeMs);
         if (certain != null)
             return certain;
-        if (!PI_ENDED.includes(tail.messages.at(-1)?.stopReason ?? ""))
+        if (!format.replyEnded?.(tail))
             return false;
         const idleMs = Date.now() - mtimeMs;
-        if (idleMs >= PI_QUIET_SETTLE_MS)
+        if (idleMs >= QUIET_SETTLE_MS)
             return true;
-        this.recheck(state.path, PI_QUIET_SETTLE_MS - idleMs);
+        this.recheck(state.path, QUIET_SETTLE_MS - idleMs);
         return false;
     }
     recheck(path, delayMs) {
@@ -624,7 +618,7 @@ export class NativeIngest {
             if (!settled && lane === "import")
                 break;
             // A prompt still being recorded would change the Turn's identity; it is sent once complete.
-            if (!settled && state.harness === "codex" && !turn.userFinal)
+            if (!settled && transcriptFormat(state.harness).userFinalMarked && !turn.userFinal)
                 break;
             const turnId = derived(turn);
             candidates.push({ turn, turnId, parentTurnId, settled });
@@ -736,11 +730,12 @@ export class NativeIngest {
             return;
         try {
             const source = turn.path ?? state.path;
+            const archiveSource = transcriptFormat(state.harness).archiveSource;
             await this.options.archives.stage({
                 sessionId: state.sessionId,
                 harness: state.harness,
                 nativeSessionId: state.nativeSessionId,
-                path: state.harness === "codex" ? await ensurePlainCodexRollout(source, join(this.options.root, "native", "rollouts")) : source,
+                path: archiveSource ? await archiveSource(source, join(this.options.root, "native", "rollouts")) : source,
                 sizeBytes: turn.endBytes,
                 expectedChecksum: turn.sha256,
             }, turnId);

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

@@ -1,11 +1,11 @@
-import { type RuntimeContext } from "@neta-art/cohub";
+import { type LocalHarness, type RuntimeContext } from "@neta-art/cohub";
 import type { SessionTurnProjectionClient } from "../turn-projection.js";
 import type { RuntimeArchiveStore } from "../archive-store.js";
 import type { NativeIngest, TranscriptState } from "./ingest.js";
 /** How the native file for a Turn was obtained; reported with the Turn result. */
 export type ResumeKind = "native" | "restored" | "handoff" | "new";
 export type NativeSession = {
-    harness: "pi" | "codex";
+    harness: LocalHarness;
     nativeSessionId: string;
     path: string;
     cwd: string;
@@ -26,14 +26,14 @@ export declare class NativeSessions {
         ingest: NativeIngest;
         onRestoreFailed?: (error: unknown, context: {
             sessionId: string;
-            harness: "pi" | "codex";
+            harness: LocalHarness;
             unrestorable: boolean;
         }) => void;
     });
     prepare(input: {
         sessionId: string;
         turnId: string;
-        harness: "pi" | "codex";
+        harness: LocalHarness;
         cwd: string;
         provider?: string | null;
         context: RuntimeContext;