@neta-art/cohub-cli 10.5.0 → 10.7.0

package/dist/runtime/json-rpc.js

@@ -65,6 +65,8 @@ export class JsonRpcProcess {
     stderr = "";
     closed;
     closing = null;
+    inputEnded = false;
+    /** `pi` and `jsonrpc` correlate request responses; `stream` delivers every line as an event. */
     constructor(binary, args, cwd, mode, context = {}) {
         this.mode = mode;
         this.child = spawn(binary, args, { cwd, env: { ...harnessEnvironment(), ...context }, stdio: "pipe", detached: process.platform !== "win32", windowsHide: true });
@@ -90,7 +92,7 @@ export class JsonRpcProcess {
     fail(value) {
         if (this.failure)
             return;
-        this.failure = this.closing ? new RpcProcessClosedError() : value instanceof Error ? value : new Error(String(value));
+        this.failure = this.closing || this.inputEnded ? new RpcProcessClosedError() : value instanceof Error ? value : new Error(String(value));
         for (const pending of this.pending.values()) {
             clearTimeout(pending.timer);
             pending.reject(this.failure);
@@ -101,7 +103,7 @@ export class JsonRpcProcess {
     }
     receive(value) {
         const key = value.id == null ? null : String(value.id);
-        const response = this.mode === "pi" ? value.type === "response" : "result" in value || "error" in value;
+        const response = this.mode === "pi" ? value.type === "response" : this.mode === "jsonrpc" && ("result" in value || "error" in value);
         if (key && response) {
             const pending = this.pending.get(key);
             if (!pending)
@@ -147,6 +149,25 @@ export class JsonRpcProcess {
             }
         });
     }
+    /** Signal end of input; a stream-mode CLI flushes its transcript and exits. */
+    endInput() {
+        if (this.failure)
+            return;
+        // The exit that follows is expected, not a failure.
+        this.inputEnded = true;
+        this.child.stdin.end();
+    }
+    /** Whether the process exits within the timeout. */
+    async exited(timeoutMs) {
+        let timer;
+        const timeout = new Promise((resolve) => { timer = setTimeout(() => resolve(false), timeoutMs); });
+        try {
+            return await Promise.race([this.closed.then(() => true), timeout]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
     onEvent(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener); }
     onFailure(listener) {
         this.failureListeners.add(listener);

package/dist/runtime/launch.d.ts

@@ -1,21 +1,23 @@
+import { type LocalHarness } from "@neta-art/cohub";
+import { type HarnessExecutables } from "./harnesses/index.js";
 import type { Command } from "commander";
 import { type RuntimeSummary } from "./presentation.js";
 import { type RuntimeLaunch } from "./supervisor.js";
-export type RuntimeUpOptions = {
+export type RuntimeUpOptions = HarnessExecutables & {
     space?: string;
     new?: boolean;
     name?: string;
     harness: string[];
-    pi?: string;
-    codex?: string;
     display?: string | boolean;
     yes?: boolean;
     json?: boolean;
     detach?: boolean;
     verbose?: boolean;
 };
+/** Executable overrides come from the per-harness `--<harness> <path>` options. */
+export declare const runtimeExecutables: (options: HarnessExecutables) => HarnessExecutables;
 export declare const resolveLocalSpaceName: (root: string, name?: string) => string;
-export declare function parseRuntimeHarnesses(values: string[]): ("pi" | "codex")[];
+export declare function parseRuntimeHarnesses(values: string[]): LocalHarness[];
 export declare function parseRuntimeDisplay(value: string | boolean | undefined, platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string | undefined;
 export declare function resolveRuntimeTarget(program: Command, target?: string): Promise<string>;
 export declare function startBackgroundRuntime(config: RuntimeLaunch): Promise<RuntimeSummary>;

package/dist/runtime/launch.js

@@ -4,21 +4,24 @@ import { stat } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { createInterface } from "node:readline/promises";
-import { isLocalHarness } from "@neta-art/cohub";
-import { discoverHarnesses, installedHarnesses } from "./harness.js";
+import { isLocalHarness, LOCAL_HARNESS_SPECS, LOCAL_HARNESSES } from "@neta-art/cohub";
+import { discoverHarnesses, installedHarnesses } from "./harnesses/index.js";
 import { requireAccessToken } from "../auth.js";
 import { createClient } from "../client.js";
 import { currentIdentityKey, explicitSpace, resolveSpaceRef } from "../space.js";
 import { canonicalRuntimeRoot, getRuntimeSpaceBinding, resolveRuntimeSpace } from "./space-binding.js";
 import { controlRuntimeInstance, requestRuntimeInstance, runtimeInstanceDirectory } from "./instance.js";
 import { ensureNativeSync, repairIntegrations } from "./native/attach.js";
+import { serializeDiagnosticError } from "./diagnostics.js";
 import { createDiagnosticConsole, printRuntimeSummary, runtimeWebUrl } from "./presentation.js";
 import { runRuntime } from "./supervisor.js";
+/** Executable overrides come from the per-harness `--<harness> <path>` options. */
+export const runtimeExecutables = (options) => Object.fromEntries(LOCAL_HARNESSES.flatMap((harness) => options[harness] ? [[harness, options[harness]]] : []));
 export const resolveLocalSpaceName = (root, name) => name?.trim() || basename(root) || "local-space";
 export function parseRuntimeHarnesses(values) {
     const names = values.flatMap((value) => value.split(",")).map((name) => name.trim()).filter(Boolean);
     if (names.some((name) => !isLocalHarness(name)))
-        throw new Error("Harness must be pi or codex");
+        throw new Error(`Harness must be one of: ${LOCAL_HARNESSES.join(", ")}`);
     return [...new Set(names.length ? names : ["pi"])];
 }
 export function parseRuntimeDisplay(value, platform = process.platform, env = process.env) {
@@ -123,16 +126,17 @@ export async function runtimeUp(program, dir, options) {
     const binding = await getRuntimeSpaceBinding(root, identity);
     const existingId = requested || binding?.spaceId;
     let harnesses = parseRuntimeHarnesses(options.harness);
+    const executables = runtimeExecutables(options);
     let display = options.display === undefined ? undefined : parseRuntimeDisplay(options.display);
     if (existingId && !options.new) {
         const existing = await requestRuntimeInstance(runtimeInstanceDirectory(identity, existingId));
         if (existing) {
-            if (existing.root !== root || options.harness.length && [...existing.harnesses].sort().join() !== [...harnesses].sort().join() || options.pi || options.codex || options.display !== undefined && display !== existing.display) {
+            if (existing.root !== root || options.harness.length && [...existing.harnesses].sort().join() !== [...harnesses].sort().join() || Object.keys(executables).length || options.display !== undefined && display !== existing.display) {
                 throw new Error("Runtime is running with a different configuration. Use down first");
             }
             // `up` is the single idempotent entry: a reused instance adopts its running
             // Harnesses (unless explicitly overridden) and completes native sync setup.
-            const native = await ensureNativeSync({ root, spaceId: existing.spaceId, identity, harnesses: options.harness.length ? harnesses : parseRuntimeHarnesses(existing.harnesses), yes: options.yes, executables: { pi: options.pi, codex: options.codex } });
+            const native = await ensureNativeSync({ root, spaceId: existing.spaceId, identity, harnesses: options.harness.length ? harnesses : parseRuntimeHarnesses(existing.harnesses), yes: options.yes, executables });
             // The running Runtime applies consent given now without restarting.
             const directory = runtimeInstanceDirectory(identity, existing.spaceId);
             await controlRuntimeInstance(directory, "reload").catch(() => undefined);
@@ -144,9 +148,9 @@ export async function runtimeUp(program, dir, options) {
     }
     display = parseRuntimeDisplay(options.display);
     if (!options.harness.length)
-        harnesses = await installedHarnesses(root, options);
+        harnesses = await installedHarnesses(root, executables);
     if (!harnesses.length)
-        throw new Error("Install and sign in to Pi or Codex, or pass --harness");
+        throw new Error(`Install and sign in to ${LOCAL_HARNESSES.map((harness) => LOCAL_HARNESS_SPECS[harness].label).join(", ")}, or pass --harness`);
     let createNew = Boolean(options.new);
     let name = resolveLocalSpaceName(root, options.name);
     if (!options.yes) {
@@ -190,8 +194,14 @@ export async function runtimeUp(program, dir, options) {
         throw new Error("Stop the existing Runtime before rebinding this directory");
     }
     await repairIntegrations(options.pi);
-    // Fail local preflight before creating remote state; the worker reuses this catalog.
-    const capabilities = await discoverHarnesses(harnesses, options, root);
+    // Fail local preflight before creating remote state; the worker reuses this catalog. Without
+    // `--harness`, a discovered harness that cannot start is skipped with a warning.
+    const capabilities = await discoverHarnesses(harnesses, executables, root, options.harness.length ? undefined : (harness, error) => {
+        process.stderr.write(`Skipping ${LOCAL_HARNESS_SPECS[harness].label}: ${serializeDiagnosticError(error).message.split("\n")[0]}\n`);
+    });
+    if (!capabilities.harnesses.length)
+        throw new Error("No installed harness could start; fix the warnings above or pass --harness");
+    harnesses = capabilities.harnesses;
     const client = createClient();
     const { spaceId, source } = await resolveRuntimeSpace({
         root, identityKey: identity, explicitSpaceId: requested,
@@ -204,8 +214,8 @@ export async function runtimeUp(program, dir, options) {
         },
     });
     // Consent (or --yes) precedes any user-level integration install; failure never blocks startup.
-    const native = await ensureNativeSync({ root, spaceId, identity, harnesses, yes: options.yes, executables: { pi: options.pi, codex: options.codex } });
-    const config = { spaceId, root, identity, harnesses, capabilities, executables: { pi: options.pi, codex: options.codex }, background: Boolean(options.detach), verbose: options.verbose, importHistory: native.importHistory, display };
+    const native = await ensureNativeSync({ root, spaceId, identity, harnesses, yes: options.yes, executables });
+    const config = { spaceId, root, identity, harnesses, capabilities, executables, background: Boolean(options.detach), verbose: options.verbose, importHistory: native.importHistory, display };
     const existing = await requestRuntimeInstance(runtimeInstanceDirectory(identity, spaceId));
     if (existing) {
         if (existing.root !== root)

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

@@ -1,32 +1,15 @@
-import { type NativeTranscript, type NativeTranscriptTurn } from "./transcript.js";
-export type { NativeTranscript, NativeTranscriptTurn };
-export type Harness = "pi" | "codex";
-/**
- * Why a Codex thread exists. Codex writes every thread it starts into one rollout tree: the user's
- * conversations, its own background work (guardian reviews, compaction, memory consolidation) and
- * agents spawned from a conversation.
- */
-export type ThreadKind = "user" | "internal" | "spawned";
-export type SessionHeader = {
-    harness: Harness;
-    nativeSessionId: string;
-    cwd: string;
-    thread: ThreadKind;
-};
+import type { LocalHarness } from "@neta-art/cohub";
+import type { SessionHeader, ThreadKind } from "../harnesses/types.js";
+import type { NativeTranscript, NativeTranscriptTurn } from "./transcript.js";
+export type { NativeTranscript, NativeTranscriptTurn, SessionHeader, ThreadKind };
+export type Harness = LocalHarness;
 /** Directories holding this harness's transcripts; a transcript's header says which project it is. */
-export declare function transcriptRoots(harness: Harness): string[];
-/** Pi's encoding of a project directory into its session folder name. */
-export declare const piSessionDirectoryName: (cwd: string) => string;
+export declare const transcriptRoots: (harness: Harness) => string[];
 /** Whether a directory found under a root can hold transcripts of `cwd`. */
-export declare function acceptsDirectory(path: string, root: string, harness: Harness, cwd: string): boolean;
+export declare const acceptsDirectory: (path: string, root: string, harness: Harness, cwd: string) => boolean;
 /** Name-only check: can this path hold a transcript of this harness for `cwd`? */
-export declare function acceptsTranscript(path: string, harness: Harness, cwd: string): boolean;
-/** Codex's first line is the only place a thread's purpose is recorded. */
-export declare function codexThreadKind(payload: Record<string, unknown>): ThreadKind;
+export declare const acceptsTranscript: (path: string, harness: Harness, cwd: string) => boolean;
 /** The first line of a transcript: identity, project and purpose. Nothing else is read. */
-export declare function readSessionHeader(path: string, harness: Harness, signal?: AbortSignal): Promise<SessionHeader | null>;
-/**
- * Parse a transcript into Turns. Codex records its own Turn boundary; a Pi Turn's end is inferred
- * by the caller, so Pi is parsed as settled here and the caller withdraws a tail still in flight.
- */
-export declare function readTranscript(path: string, harness: Harness, signal?: AbortSignal): Promise<NativeTranscript>;
+export declare const readSessionHeader: (path: string, harness: Harness, signal?: AbortSignal) => Promise<SessionHeader | null>;
+/** Parse a transcript into Turns. */
+export declare const readTranscript: (path: string, harness: Harness, signal?: AbortSignal) => Promise<NativeTranscript>;

package/dist/runtime/native/adapters.js

@@ -1,79 +1,11 @@
-import { createReadStream } from "node:fs";
-import { homedir } from "node:os";
-import { basename, dirname, join } from "node:path";
-import { codexArchivedSessionsDirectory, codexRolloutBytes, codexRolloutIdOf, codexSessionsDirectory, readNativeTranscript } from "./transcript.js";
-const text = (value) => typeof value === "string" ? value : "";
-const record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
-const HEADER_MAX_BYTES = 1024 * 1024;
+import { transcriptFormat } from "../harnesses/index.js";
 /** Directories holding this harness's transcripts; a transcript's header says which project it is. */
-export function transcriptRoots(harness) {
-    if (harness === "codex")
-        return [codexSessionsDirectory(), codexArchivedSessionsDirectory()];
-    const custom = process.env.PI_CODING_AGENT_SESSION_DIR?.trim();
-    if (custom)
-        return [custom];
-    return [join(process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent"), "sessions")];
-}
-/** Pi's encoding of a project directory into its session folder name. */
-export const piSessionDirectoryName = (cwd) => `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-/** Whether a Pi project folder may hold sessions of `cwd` or a subdirectory of it. */
-function piProjectFolderMatches(folder, cwd) {
-    const project = piSessionDirectoryName(cwd).slice(0, -2);
-    const name = basename(folder);
-    return name === `${project}--` || name.startsWith(`${project}-`);
-}
+export const transcriptRoots = (harness) => transcriptFormat(harness).roots();
 /** Whether a directory found under a root can hold transcripts of `cwd`. */
-export function acceptsDirectory(path, root, harness, cwd) {
-    if (harness === "codex" || process.env.PI_CODING_AGENT_SESSION_DIR?.trim() || dirname(path) !== root)
-        return true;
-    return piProjectFolderMatches(path, cwd);
-}
+export const acceptsDirectory = (path, root, harness, cwd) => transcriptFormat(harness).acceptsDirectory(path, root, cwd);
 /** Name-only check: can this path hold a transcript of this harness for `cwd`? */
-export function acceptsTranscript(path, harness, cwd) {
-    const name = basename(path);
-    if (harness === "codex")
-        return codexRolloutIdOf(name) !== null;
-    return name.endsWith(".jsonl") && (Boolean(process.env.PI_CODING_AGENT_SESSION_DIR?.trim()) || piProjectFolderMatches(dirname(path), cwd));
-}
-async function firstRecord(bytes) {
-    const chunks = [];
-    let buffered = 0;
-    for await (const chunk of bytes) {
-        chunks.push(chunk);
-        buffered += chunk.length;
-        const newline = chunk.indexOf(10);
-        if (newline >= 0)
-            return record(JSON.parse(Buffer.concat(chunks, buffered).subarray(0, buffered - chunk.length + newline).toString("utf8")));
-        if (buffered > HEADER_MAX_BYTES)
-            throw new Error("Native session header is too large");
-    }
-    throw new Error("Native transcript is empty");
-}
-/** Codex's first line is the only place a thread's purpose is recorded. */
-export function codexThreadKind(payload) {
-    const source = payload.source;
-    if (source && typeof source === "object")
-        return record(record(source).subagent).thread_spawn ? "spawned" : "internal";
-    return ["subagent", "guardian_review", "memory_consolidation"].includes(text(payload.thread_source)) ? "internal" : "user";
-}
+export const acceptsTranscript = (path, harness, cwd) => transcriptFormat(harness).acceptsTranscript(path, cwd);
 /** The first line of a transcript: identity, project and purpose. Nothing else is read. */
-export async function readSessionHeader(path, harness, signal) {
-    if (harness === "pi") {
-        const header = await firstRecord(createReadStream(path, { signal }));
-        if (header.type !== "session" || !text(header.id) || !text(header.cwd))
-            return null;
-        return { harness, nativeSessionId: text(header.id), cwd: text(header.cwd), thread: "user" };
-    }
-    const header = await firstRecord(codexRolloutBytes(path, null, signal));
-    const payload = record(header.payload);
-    if (header.type !== "session_meta" || !text(payload.id) || !text(payload.cwd))
-        return null;
-    return { harness, nativeSessionId: text(payload.id), cwd: text(payload.cwd), thread: codexThreadKind(payload) };
-}
-/**
- * Parse a transcript into Turns. Codex records its own Turn boundary; a Pi Turn's end is inferred
- * by the caller, so Pi is parsed as settled here and the caller withdraws a tail still in flight.
- */
-export async function readTranscript(path, harness, signal) {
-    return await readNativeTranscript(path, harness, { settled: harness === "pi", signal });
-}
+export const readSessionHeader = async (path, harness, signal) => await transcriptFormat(harness).header(path, signal);
+/** Parse a transcript into Turns. */
+export const readTranscript = async (path, harness, signal) => await transcriptFormat(harness).read(path, signal);

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

@@ -1,17 +1,19 @@
+import type { JsonRecord } from "../json-rpc.js";
 /** A structurally unrestorable archive (e.g. its history reference is not carried); never retried. */
 export declare class ArchiveNotRestorableError extends Error {
     constructor(message: string);
 }
-/** Change only the header of a working copy. Raw archive bytes remain untouched. */
-export declare function importNativeArchive(input: {
+/**
+ * Create a working copy of raw archive bytes. The header line may be rewritten, or with `sessionId`
+ * the top-level session id of every line; the target is created exclusively, so an existing native
+ * file is never replaced.
+ */
+export declare function copyNativeArchive(input: {
     source: string;
     target: string;
-    harness: "pi" | "codex";
-    nativeSessionId: string;
-    id: string;
-    cwd: string;
     signal?: AbortSignal;
+    header?: (header: JsonRecord) => JsonRecord;
+    sessionId?: string;
 }): Promise<{
     checksum: string;
-    nativeSessionId: string;
 }>;

package/dist/runtime/native/archive.js

@@ -7,58 +7,119 @@ import { RUNTIME_MAX_FRAME_BYTES } from "@neta-art/cohub";
 export class ArchiveNotRestorableError extends Error {
     constructor(message) { super(message); this.name = "ArchiveNotRestorableError"; }
 }
-/** Change only the header of a working copy. Raw archive bytes remain untouched. */
-export async function importNativeArchive(input) {
+const NEWLINE = Buffer.from("\n");
+const SESSION_ID_KEY = Buffer.from('"sessionId"');
+/** End of the JSON string starting at `start`, or -1 when the line ends inside it. */
+function stringEnd(line, start) {
+    for (let index = start + 1; index < line.length; index++) {
+        if (line[index] === 0x5c)
+            index++;
+        else if (line[index] === 0x22)
+            return index;
+    }
+    return -1;
+}
+const skipSpace = (line, index) => {
+    while ([0x20, 0x09, 0x0d].includes(line[index] ?? -1))
+        index++;
+    return index;
+};
+/**
+ * Replace the top-level `sessionId` string of one JSON line; every other byte, including numbers a
+ * parser would round and lines that are not JSON, is kept as written. Structural JSON bytes are
+ * ASCII, which UTF-8 never uses inside a multi-byte character, so bytes are scanned directly.
+ */
+function rebindLine(line, sessionId) {
+    let depth = 0;
+    for (let index = 0; index < line.length; index++) {
+        const byte = line[index];
+        if (byte === 0x22) {
+            const end = stringEnd(line, index);
+            if (end < 0)
+                return line;
+            const colon = skipSpace(line, end + 1);
+            if (depth === 1 && line[colon] === 0x3a && line.subarray(index, end + 1).equals(SESSION_ID_KEY)) {
+                const value = skipSpace(line, colon + 1);
+                const valueEnd = line[value] === 0x22 ? stringEnd(line, value) : -1;
+                if (valueEnd < 0)
+                    return line;
+                return Buffer.concat([line.subarray(0, value), Buffer.from(JSON.stringify(sessionId)), line.subarray(valueEnd + 1)]);
+            }
+            index = end;
+        }
+        else if (byte === 0x7b || byte === 0x5b)
+            depth++;
+        else if (byte === 0x7d || byte === 0x5d)
+            depth--;
+    }
+    return line;
+}
+/**
+ * Create a working copy of raw archive bytes. The header line may be rewritten, or with `sessionId`
+ * the top-level session id of every line; the target is created exclusively, so an existing native
+ * file is never replaced.
+ */
+export async function copyNativeArchive(input) {
     await mkdir(dirname(input.target), { recursive: true, mode: 0o700 });
     const temporary = `${input.target}.${randomUUID()}.importing`;
     const file = await open(temporary, "wx", 0o600);
     const digest = createHash("sha256");
-    let headerReady = false, headerBytes = 0;
+    let headerReady = !input.header, headerBytes = 0;
     const fragments = [];
     const write = async (bytes) => { digest.update(bytes); await file.writeFile(bytes); };
     const writeHeader = async () => {
-        const header = JSON.parse(Buffer.concat(fragments).toString("utf8"));
-        if (input.harness === "pi") {
-            if (header?.type !== "session" || header.id !== input.nativeSessionId)
-                throw new Error("Pi archive identity mismatch");
-            header.cwd = input.cwd;
-            delete header.parentSession;
-        }
-        else {
-            if (header?.type !== "session_meta" || header.payload?.id !== input.nativeSessionId)
-                throw new Error("Codex archive identity mismatch");
-            // A leaf archive does not carry its ancestor rollout.
-            if (header.payload?.history_base != null)
-                throw new ArchiveNotRestorableError("Codex archive references history it does not carry; rebuild from the Session instead");
-            header.payload.id = input.id;
-            if (header.payload.session_id != null)
-                header.payload.session_id = input.id;
-            header.payload.history_mode = "legacy";
-            header.payload.cwd = input.cwd;
-        }
+        const header = input.header?.(JSON.parse(Buffer.concat(fragments).toString("utf8")));
         await write(Buffer.from(`${JSON.stringify(header)}\n`));
         fragments.length = 0;
         headerReady = true;
     };
     try {
-        for await (const bytes of createReadStream(input.source, { signal: input.signal })) {
-            if (headerReady) {
-                await write(bytes);
-                continue;
+        if (input.sessionId) {
+            const sessionId = input.sessionId;
+            const line = [];
+            let lineBytes = 0;
+            const flush = async (newline) => {
+                const bytes = Buffer.concat(line);
+                line.length = 0;
+                lineBytes = 0;
+                await write(Buffer.concat([rebindLine(bytes, sessionId), newline ? NEWLINE : Buffer.alloc(0)]));
+            };
+            for await (const chunk of createReadStream(input.source, { signal: input.signal })) {
+                let bytes = chunk;
+                for (let newline = bytes.indexOf(10); newline >= 0; newline = bytes.indexOf(10)) {
+                    line.push(bytes.subarray(0, newline));
+                    await flush(true);
+                    bytes = bytes.subarray(newline + 1);
+                }
+                lineBytes += bytes.length;
+                if (lineBytes > RUNTIME_MAX_FRAME_BYTES)
+                    throw new Error("Native record is too large");
+                if (bytes.length)
+                    line.push(bytes);
             }
-            const newline = bytes.indexOf(10);
-            const prefix = newline < 0 ? bytes : bytes.subarray(0, newline);
-            headerBytes += prefix.length;
-            if (headerBytes > RUNTIME_MAX_FRAME_BYTES)
-                throw new Error("Native header is too large");
-            fragments.push(prefix);
-            if (newline >= 0) {
-                await writeHeader();
-                await write(bytes.subarray(newline + 1));
+            if (line.length)
+                await flush(false);
+        }
+        else {
+            for await (const bytes of createReadStream(input.source, { signal: input.signal })) {
+                if (headerReady) {
+                    await write(bytes);
+                    continue;
+                }
+                const newline = bytes.indexOf(10);
+                const prefix = newline < 0 ? bytes : bytes.subarray(0, newline);
+                headerBytes += prefix.length;
+                if (headerBytes > RUNTIME_MAX_FRAME_BYTES)
+                    throw new Error("Native header is too large");
+                fragments.push(prefix);
+                if (newline >= 0) {
+                    await writeHeader();
+                    await write(bytes.subarray(newline + 1));
+                }
             }
+            if (!headerReady)
+                await writeHeader();
         }
-        if (!headerReady)
-            await writeHeader();
         input.signal?.throwIfAborted();
         await file.sync();
         await file.close();
@@ -72,7 +133,7 @@ export async function importNativeArchive(input) {
                 await directory.close();
             }
         }
-        return { checksum: digest.digest("hex"), nativeSessionId: input.harness === "pi" ? input.nativeSessionId : input.id };
+        return { checksum: digest.digest("hex") };
     }
     finally {
         await file.close();

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

@@ -1,3 +1,4 @@
+import type { HarnessExecutables } from "../harnesses/types.js";
 import type { Harness } from "./adapters.js";
 import { type NativeConfig } from "./config.js";
 export type NativeSyncReport = {
@@ -13,10 +14,7 @@ type Input = {
     identity: string;
     harnesses: Harness[];
     yes?: boolean;
-    executables?: {
-        pi?: string;
-        codex?: string;
-    };
+    executables?: HarnessExecutables;
 };
 type Ask = (question: string) => Promise<boolean>;
 /** Whether this directory already syncs every requested harness. */
@@ -29,7 +27,7 @@ export declare function nativeSyncSatisfied(config: NativeConfig | null, input:
  * Enable native sync after consent. Native history may contain secrets, so nothing is read before
  * the user agrees; a failure here never blocks the Runtime, it only leaves sessions read-only.
  */
-export declare function ensureNativeSync(input: Input, log?: (line: string) => void, ask?: Ask): Promise<NativeSyncReport>;
+export declare function ensureNativeSync(requested: Input, log?: (line: string) => void, ask?: Ask): Promise<NativeSyncReport>;
 /**
  * Before any harness starts, repair what earlier releases installed: an outdated Pi extension can keep
  * Pi from starting, and legacy Codex hooks run a script that is gone. Both had consent back then.

package/dist/runtime/native/attach.js

@@ -1,5 +1,7 @@
 import { createInterface } from "node:readline/promises";
+import { LOCAL_HARNESS_SPECS } from "@neta-art/cohub";
 import { serializeDiagnosticError } from "../diagnostics.js";
+import { nativeSyncHarnesses } from "../harnesses/index.js";
 import { CODEX_SHARED_MIN_VERSION, sharedServerAvailable, supportsSharedServer } from "./codex-link.js";
 import { PI_MIN_VERSION } from "./pi-link.js";
 import { atLeast, formatVersion, harnessVersion } from "./version.js";
@@ -23,7 +25,11 @@ async function defaultAsk(question) {
  * Enable native sync after consent. Native history may contain secrets, so nothing is read before
  * the user agrees; a failure here never blocks the Runtime, it only leaves sessions read-only.
  */
-export async function ensureNativeSync(input, log = (line) => process.stderr.write(line), ask = defaultAsk) {
+export async function ensureNativeSync(requested, log = (line) => process.stderr.write(line), ask = defaultAsk) {
+    // A harness without a native integration runs Cohub Turns only.
+    const input = { ...requested, harnesses: nativeSyncHarnesses(requested.harnesses) };
+    if (!input.harnesses.length)
+        return { enabled: false, harnesses: [], codexShared: false, importHistory: false, note: "unsupported" };
     const stateRoot = runtimeStateRoot(input.spaceId);
     const previous = await readNativeConfig(stateRoot, input.identity).catch(() => null);
     if (previous && nativeSyncSatisfied(previous, input)) {
@@ -36,7 +42,7 @@ export async function ensureNativeSync(input, log = (line) => process.stderr.wri
         log("Native sync off · rerun interactively or with --yes to enable\n");
         return { enabled: false, harnesses: input.harnesses, codexShared: false, importHistory: false, note: "non-interactive" };
     }
-    const names = input.harnesses.map((harness) => harness === "pi" ? "Pi" : "Codex").join(" and ");
+    const names = input.harnesses.map((harness) => LOCAL_HARNESS_SPECS[harness].label).join(" and ");
     if (!await confirm(`Sync ${names} chats in this folder to this Space so they continue on the web? Their history may contain secrets. [Y/n] `)) {
         return { enabled: false, harnesses: input.harnesses, codexShared: false, importHistory: false, note: "declined" };
     }

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

@@ -1,7 +1,7 @@
 import type { NativeRuntimeEvent } from "@neta-art/cohub";
 import type { RuntimeArchiveStore } from "../archive-store.js";
 import { type RuntimeDiagnostics } from "../diagnostics.js";
-import type { HarnessOptions } from "../harness.js";
+import type { HarnessExecutables } from "../harnesses/types.js";
 import type { SessionTurnProjectionClient } from "../turn-projection.js";
 import { type Harness } from "./adapters.js";
 import { type NativeConfig } from "./config.js";
@@ -47,7 +47,7 @@ export declare class NativeRuntime {
         root: string;
         stateRoot: string;
         harnesses: Harness[];
-        executables: HarnessOptions;
+        executables: HarnessExecutables;
         identity: string;
         config: NativeConfig | null;
         archives: RuntimeArchiveStore;

package/dist/runtime/native/daemon.js

@@ -59,8 +59,8 @@ export class NativeRuntime {
             root: options.stateRoot,
             archives: options.archives,
             hooks: {
-                piSettled: (nativeSessionId, mtimeMs) => {
-                    const link = this.pi.find(nativeSessionId);
+                settled: (state, mtimeMs) => {
+                    const link = state.harness === "pi" ? this.pi.find(state.nativeSessionId) : null;
                     if (!link)
                         return null;
                     if (!link.idle)
@@ -68,13 +68,14 @@ export class NativeRuntime {
                     // Idle and nothing written since it settled: done. A newer write lets the file decide.
                     return link.settledAt >= mtimeMs ? true : null;
                 },
+                // Only Pi (extension) and Codex (shared app-server) have a control plane; other synced clients are read-only.
                 controllable: (state) => state.harness === "pi"
                     ? this.pi.find(state.nativeSessionId) !== null
-                    : this.codex.enabled && (this.active.has(state.nativeSessionId) || this.watched.has(state.nativeSessionId) || this.codex.driving.has(state.nativeSessionId)),
+                    : state.harness === "codex" && this.codex.enabled && (this.active.has(state.nativeSessionId) || this.watched.has(state.nativeSessionId) || this.codex.driving.has(state.nativeSessionId)),
                 abortTurn: (state) => {
                     const stop = state.harness === "pi"
                         ? this.pi.abort(state.nativeSessionId)
-                        : state.runningTurnKey ? this.codex.interrupt(state.nativeSessionId, state.runningTurnKey) : Promise.resolve(false);
+                        : state.harness === "codex" && state.runningTurnKey ? this.codex.interrupt(state.nativeSessionId, state.runningTurnKey) : Promise.resolve(false);
                     void stop.catch((error) => options.diagnostics.log("warn", "native.stop_failed", { error: serializeDiagnosticError(error) }, { harness: state.harness, sessionId: state.sessionId ?? undefined }));
                 },
                 onGrowth: (state) => this.onGrowth(state),