@neta-art/cohub-cli 10.5.0 → 10.6.0

package/dist/runtime/native/sessions.js

@@ -1,10 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { mkdir, rename, rm, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { serializeProjectionRecords } from "@neta-art/cohub";
-import { ArchiveNotRestorableError, importNativeArchive } from "./archive.js";
-import { piSessionDirectoryName, readTranscript } from "./adapters.js";
+import { ArchiveNotRestorableError } from "./archive.js";
+import { readTranscript } from "./adapters.js";
+import { harnessAdapter } from "../harnesses/index.js";
 import { ProjectionStore, rebindProjectionNativeSession } from "../projection-store.js";
 /** Chooses the native file a Turn runs in. 1. */
 export class NativeSessions {
@@ -36,18 +36,19 @@ export class NativeSessions {
             }
         }
         const projected = await this.project(input);
-        // A new Codex thread gets its file when it starts; the executor adopts it then.
-        if (projected.resume !== "new" || input.harness === "pi")
+        // A harness that creates its own file gets it when the Turn starts; the executor adopts it then.
+        if (projected.resume !== "new" || !harnessAdapter(input.harness).session.startsWithoutFile)
             this.options.ingest.adopt(projected.session, input.sessionId);
         return projected;
     }
     async restore(input, archive, signal) {
         const id = randomUUID();
         const raw = join(this.options.root, "native", "restored", `${id}.jsonl`);
-        const path = nativePath(input.harness, id, input.cwd);
+        const format = harnessAdapter(input.harness).session.archive;
         try {
             const restored = await this.options.archives.restore(archive, raw, signal);
-            const imported = await importNativeArchive({ source: raw, target: path, harness: input.harness, nativeSessionId: restored.nativeSessionId, id, cwd: input.cwd, signal });
+            const path = format.target({ id, nativeSessionId: restored.nativeSessionId, cwd: input.cwd });
+            const imported = await format.import({ source: raw, target: path, nativeSessionId: restored.nativeSessionId, id, cwd: input.cwd, signal });
             return { harness: input.harness, nativeSessionId: imported.nativeSessionId, path, cwd: input.cwd };
         }
         finally {
@@ -55,8 +56,9 @@ export class NativeSessions {
         }
     }
     async project(input) {
+        const format = harnessAdapter(input.harness).session;
         const nativeSessionId = randomUUID();
-        const path = nativePath(input.harness, nativeSessionId, input.cwd);
+        const path = format.path(nativeSessionId, input.cwd);
         const projection = rebindProjectionNativeSession(await this.projections.project({
             spaceId: this.options.spaceId,
             sessionId: input.sessionId,
@@ -68,8 +70,8 @@ export class NativeSessions {
             throughTurnId: input.context.throughTurnId,
         }, input.signal), nativeSessionId);
         const session = { harness: input.harness, nativeSessionId, path, cwd: input.cwd };
-        // An empty Codex thread is created by Codex itself when the Turn starts.
-        if (!projection.turns.length && input.harness === "codex")
+        // Nothing to carry (no Turns, or none that project) starts natively where the harness creates its own file.
+        if ((!projection.turns.length || !projection.projection.records.length) && format.startsWithoutFile)
             return { session, resume: "new" };
         await mkdir(dirname(path), { recursive: true, mode: 0o700 });
         const temporary = `${path}.${randomUUID()}.projection`;
@@ -78,15 +80,3 @@ export class NativeSessions {
         return { session, resume: projection.turns.length ? "handoff" : "new" };
     }
 }
-/** Where a harness keeps a new transcript for the bound directory. */
-function nativePath(harness, nativeSessionId, cwd) {
-    const stamp = new Date().toISOString();
-    if (harness === "pi") {
-        const agent = process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent");
-        const directory = process.env.PI_CODING_AGENT_SESSION_DIR?.trim() || join(agent, "sessions", piSessionDirectoryName(cwd));
-        return join(directory, `${stamp.replace(/[:.]/g, "-")}_${nativeSessionId}.jsonl`);
-    }
-    const home = process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
-    const day = stamp.replace(/\.\d{3}Z$/, "").replaceAll(":", "-");
-    return join(home, "sessions", day.slice(0, 4), day.slice(5, 7), day.slice(8, 10), `rollout-${day}-${nativeSessionId}.jsonl`);
-}

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

@@ -1,4 +1,5 @@
 import type { ContentBlock, NativeTurnComplete, NativeTurnMessage } from "@neta-art/cohub";
+import { type JsonRecord } from "../json-rpc.js";
 export type NativeTranscriptTurn = {
     key: string;
     parentKey: string | null;
@@ -47,6 +48,8 @@ export type NativeTranscriptHeader = {
     rolloutId?: string;
     historyBase?: CodexHistoryBase;
 };
+/** Read exactly the first JSONL record of a stream without re-concatenating per chunk. */
+export declare function readFirstRecord(stream: AsyncIterable<Buffer>): Promise<JsonRecord>;
 /** Read only the session header before deciding whether a global Codex file belongs to this project. */
 export declare function readNativeTranscriptHeader(path: string, harness: "pi" | "codex", signal?: AbortSignal): Promise<NativeTranscriptHeader>;
 /** Raw JSONL bytes of a rollout, transparently decompressing `.zst` and honoring a lineage cutoff. */

package/dist/runtime/native/transcript.js

@@ -6,7 +6,8 @@ import { homedir } from "node:os";
 import { basename, join } from "node:path";
 import { createZstdDecompress } from "node:zlib";
 import { pipeline } from "node:stream/promises";
-import { identifiable, piContent } from "../harness.js";
+import { identifiable } from "../harnesses/process.js";
+import { piContent } from "./translate.js";
 import { codexTokenTotals, codexUsage } from "../codex-usage.js";
 import { record } from "../json-rpc.js";
 const text = (value) => typeof value === "string" ? value : "";
@@ -43,8 +44,8 @@ function parseCodexHistoryBase(value) {
         throw new Error("Codex history reference is invalid; retain the original files");
     return { rolloutId, endOrdinal, endBytes };
 }
-/** Read exactly the first JSONL line of a stream without re-concatenating per chunk. */
-async function readFirstLine(stream) {
+/** Read exactly the first JSONL record of a stream without re-concatenating per chunk. */
+export async function readFirstRecord(stream) {
     const chunks = [];
     let buffered = 0;
     for await (const chunk of stream) {
@@ -64,7 +65,7 @@ async function readFirstLine(stream) {
     throw new Error("Native transcript is empty");
 }
 async function readCodexHeader(path, signal) {
-    const value = await readFirstLine(codexRolloutBytes(path, null, signal));
+    const value = await readFirstRecord(codexRolloutBytes(path, null, signal));
     const payload = record(value.payload);
     const threadId = text(payload.id), cwd = text(payload.cwd);
     if (value.type !== "session_meta" || !threadId || !cwd)
@@ -75,7 +76,7 @@ async function readCodexHeader(path, signal) {
 /** Read only the session header before deciding whether a global Codex file belongs to this project. */
 export async function readNativeTranscriptHeader(path, harness, signal) {
     if (harness === "pi") {
-        const value = await readFirstLine(createReadStream(path, { signal }));
+        const value = await readFirstRecord(createReadStream(path, { signal }));
         if (value.type !== "session" || !text(value.id) || !text(value.cwd))
             throw new Error("Invalid native session header");
         return { nativeSessionId: text(value.id), cwd: text(value.cwd) };

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

@@ -1,5 +1,7 @@
 import type { ContentBlock, NativeTurnProgress, RuntimeExecutionEvent, RuntimeMessage } from "@neta-art/cohub";
 import { type JsonRecord } from "../json-rpc.js";
+export declare function piContent(value: unknown): ContentBlock[];
+export declare function codexItemContent(item: JsonRecord): ContentBlock[];
 /** Harness events mapped onto Cohub's streaming protocol. */
 export type Translator = {
     push(event: JsonRecord): boolean;

package/dist/runtime/native/translate.js

@@ -1,9 +1,42 @@
-import { codexItemContent, identifiable, piContent } from "../harness.js";
 import { codexTokenTotals, codexUsage, subtractCodexTokens } from "../codex-usage.js";
+import { identifiable } from "../harnesses/process.js";
 import { record } from "../json-rpc.js";
 const text = (value) => typeof value === "string" ? value : "";
 const list = (value) => Array.isArray(value) ? value : [];
 const hasToolCall = (content, id) => content.some((block) => block.type === "tool_use" && block.id === id);
+export function piContent(value) {
+    return list(value).flatMap((entry) => {
+        const block = record(entry);
+        if (block.type === "text")
+            return [{ type: "text", text: text(block.text) }];
+        if (block.type === "thinking")
+            return [{ type: "thinking", thinking: text(block.thinking), ...(typeof (block.thinkingSignature ?? block.signature) === "string" ? { signature: String(block.thinkingSignature ?? block.signature) } : {}) }];
+        if (block.type === "toolCall")
+            return identifiable(block.id) && identifiable(block.name) ? [{ type: "tool_use", id: block.id, name: block.name, input: record(block.arguments) }] : [];
+        if (block.type === "image")
+            return [{ type: "image", source: { type: "base64", data: text(block.data), media_type: text(block.mimeType) } }];
+        return [{ type: "text", text: JSON.stringify(block) }];
+    });
+}
+export function codexItemContent(item) {
+    if (item.type === "agentMessage" || item.type === "plan")
+        return [{ type: "text", text: text(item.text) }];
+    if (item.type === "reasoning")
+        return [{ type: "thinking", thinking: [...list(item.summary), ...list(item.content)].map(text).join("\n") }];
+    if (item.type === "userMessage")
+        return [];
+    if (item.type === "contextCompaction")
+        return [{ type: "system_note", note_type: "compacted", text: "Context compacted" }];
+    const id = item.id;
+    if (!identifiable(id))
+        return [];
+    const name = item.type === "commandExecution" ? "bash" : item.type === "fileChange" ? "apply_patch" : text(item.tool) || text(item.type);
+    const input = item.type === "commandExecution" ? { command: item.command, cwd: item.cwd } : item.type === "fileChange" ? { changes: item.changes } : record(item.arguments);
+    return [
+        { type: "tool_use", id, name, input },
+        { type: "tool_result", tool_use_id: id, content: typeof item.aggregatedOutput === "string" ? item.aggregatedOutput : JSON.stringify(item.result ?? item.error ?? item.changes ?? item), is_error: item.status === "failed" || typeof item.exitCode === "number" && item.exitCode !== 0 },
+    ];
+}
 /** Pi emits the same event shapes to its extensions as over RPC. */
 export function piTranslator(emit) {
     let ordinal = -1;

package/dist/runtime/native/version.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
-import { harnessCommand } from "../harness.js";
+import { harnessCommand } from "../harnesses/process.js";
 /** A harness binary's own version, or `null` when it cannot say. */
 export async function harnessVersion(binary) {
     const { stdout } = await Promise.resolve()

package/dist/runtime/presentation.js

@@ -1,3 +1,4 @@
+import { LOCAL_HARNESS_SPECS } from "@neta-art/cohub";
 import { webUrl } from "../web.js";
 export const diagnosticLevels = ["debug", "info", "warn", "error"];
 export const atLeastLevel = (level, minimum) => diagnosticLevels.indexOf(level) >= diagnosticLevels.indexOf(minimum);
@@ -98,7 +99,7 @@ export function formatNativeSync(config, native, error = null) {
         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  ${config.harnesses.map((harness) => harness === "pi" ? "Pi" : "Codex").join(" · ")}`];
+    const lines = [`Native sync  ${config.harnesses.map((harness) => LOCAL_HARNESS_SPECS[harness].label).join(" · ")}`];
     if (!native)
         return `${lines[0]} · Runtime not running\n`;
     if (native.pi) {

package/dist/runtime/projection-store.js

@@ -1,18 +1,8 @@
+import { harnessAdapter } from "./harnesses/index.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) {
-    const records = result.projection.records.map((entry) => {
-        if (entry.sourceTurnId !== null)
-            return entry;
-        if (entry.record.type === "session") {
-            return { ...entry, record: { ...entry.record, id: nativeSessionId, affinity: { ...entry.record.affinity, threadId: nativeSessionId } } };
-        }
-        if (entry.record.type === "session_meta") {
-            const payload = entry.record.payload;
-            return { ...entry, record: { ...entry.record, payload: { ...payload, id: nativeSessionId, session_id: nativeSessionId } } };
-        }
-        return entry;
-    });
+    const records = harnessAdapter(result.projection.target).session.rebind(result.projection.records, nativeSessionId);
     return { ...result, projection: { ...result.projection, records } };
 }
 /**

package/dist/runtime/supervisor.d.ts

@@ -1,13 +1,13 @@
-import { type RuntimeCapabilities } from "@neta-art/cohub";
-import { type HarnessOptions } from "./harness.js";
+import { type LocalHarness, type RuntimeCapabilities } from "@neta-art/cohub";
+import { type HarnessExecutables } from "./harnesses/index.js";
 import { type RuntimeDiagnostic, type RuntimeDiagnosticLevel } from "./diagnostics.js";
 import { type RuntimeSummary } from "./presentation.js";
 export type RuntimeLaunch = {
     spaceId: string;
     root: string;
     identity: string;
-    harnesses: ("pi" | "codex")[];
-    executables: HarnessOptions;
+    harnesses: LocalHarness[];
+    executables: HarnessExecutables;
     capabilities?: RuntimeCapabilities;
     background: boolean;
     verbose?: boolean;

package/dist/runtime/supervisor.js

@@ -10,7 +10,7 @@ import { createClient } from "../client.js";
 import { currentIdentityKey } from "../space.js";
 import { ensureSandboxdBinary } from "../commands/sandboxd-binary.js";
 import { serveRuntime } from "./connection.js";
-import { discoverHarnesses } from "./harness.js";
+import { discoverHarnesses } from "./harnesses/index.js";
 import { RuntimeDiagnostics, serializeDiagnosticError } from "./diagnostics.js";
 import { ownRuntimeInstance, runtimeInstanceDirectory } from "./instance.js";
 import { createDiagnosticConsole } from "./presentation.js";

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

@@ -1,4 +1,4 @@
-import { type CanonicalProjectionTurn, type MessageToolCallsFile, type ProjectionInput, type ProjectionTarget, type SessionTurnRecord, type StoredIntermediateMessage, type TurnIntermediateMessagesFile } from "@neta-art/cohub";
+import type { CanonicalProjectionTurn, MessageToolCallsFile, ProjectionInput, ProjectionTarget, SessionTurnRecord, StoredIntermediateMessage, TurnIntermediateMessagesFile } from "@neta-art/cohub";
 export type SessionTurnProjectionClient = {
     session(sessionId: string): {
         turns: {

package/dist/runtime/turn-projection.js

@@ -1,4 +1,4 @@
-import { projectNativeSession } from "@neta-art/cohub";
+import { harnessAdapter } from "./harnesses/index.js";
 const record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 const iso = (value) => value ?? new Date(0).toISOString();
 const sourceSessionId = (turn) => turn.sourceSessionId ?? turn.sessionId;
@@ -116,5 +116,5 @@ export async function listSessionProjectionTurns(source, sessionId, options = {}
     return mapWithConcurrency(turns, 4, (turn) => hydrateSessionTurn(turn, client, options.signal));
 }
 export function projectTurnBatch(input, target) {
-    return projectNativeSession(input, target);
+    return harnessAdapter(target).session.project(input);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "10.5.0",
+  "version": "10.6.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -18,7 +18,7 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@neta-art/cohub": "11.4.0",
+    "@neta-art/cohub": "11.5.0",
     "@neta-art/generation": "^0.1.39",
     "commander": "^15.0.0",
     "sharp": "^0.35.4",

package/dist/runtime/harness.d.ts

@@ -1,26 +0,0 @@
-import type { ContentBlock, RuntimeCapabilities } from "@neta-art/cohub";
-import { type JsonRecord } from "./json-rpc.js";
-export type HarnessOptions = {
-    pi?: string;
-    codex?: string;
-};
-export declare function harnessExecutableCandidates(binary: string, cwd: string, path: string, platform?: NodeJS.Platform, pathExt?: string | undefined): string[];
-/**
- * Windows npm/pnpm installs expose harnesses as .cmd shims, which cannot be spawned
- * without a shell. Run an .exe directly, or the shim's Node entry with this Node.
- */
-export declare function harnessCommand(binary: string, args: string[], cwd: string): [string, string[]];
-/** Discover installed executables only; authentication/capability errors stay explicit. */
-export declare function installedHarnesses(cwd: string, options: HarnessOptions, path?: string): Promise<("pi" | "codex")[]>;
-/** Aborted streams leave tool calls with an empty id or name. */
-export declare const identifiable: (value: unknown) => value is string;
-export declare function piContent(value: unknown): ContentBlock[];
-export declare function imageForPi(block: Extract<ContentBlock, {
-    type: "image";
-}>): Promise<{
-    type: string;
-    data: string;
-    mimeType: string;
-}>;
-export declare function discoverHarnesses(harnesses: ("pi" | "codex")[], options: HarnessOptions, cwd: string): Promise<RuntimeCapabilities>;
-export declare function codexItemContent(item: JsonRecord): ContentBlock[];

package/dist/runtime/harness.js

@@ -1,142 +0,0 @@
-import { access, stat } from "node:fs/promises";
-import { constants, readFileSync, statSync } from "node:fs";
-import { delimiter, join, resolve, win32 } from "node:path";
-import { JsonRpcProcess, record } from "./json-rpc.js";
-import { codexModelCatalog, piModelCatalog } from "./model-catalog.js";
-import { downloadPublicImage } from "../safe-remote-image.js";
-export function harnessExecutableCandidates(binary, cwd, path, platform = process.platform, pathExt = process.env.PATHEXT) {
-    const windows = platform === "win32";
-    const paths = windows ? win32 : { delimiter, join, resolve };
-    // Windows runs only PATHEXT names; npm/pnpm also write an extensionless sh script beside the .cmd shim.
-    const extensions = windows && !win32.extname(binary)
-        ? (pathExt || ".COM;.EXE;.BAT;.CMD").split(";").filter((ext) => /^\.[a-z0-9]+$/i.test(ext))
-        : [""];
-    const roots = binary.includes("/") || binary.includes("\\")
-        ? [paths.resolve(cwd, binary)]
-        : path.split(paths.delimiter).map((directory) => directory.replace(/^"(.*)"$/, "$1")).filter(Boolean).map((directory) => paths.resolve(cwd, directory, binary));
-    return roots.flatMap((root) => extensions.map((ext) => `${root}${ext}`));
-}
-/**
- * Windows npm/pnpm installs expose harnesses as .cmd shims, which cannot be spawned
- * without a shell. Run an .exe directly, or the shim's Node entry with this Node.
- */
-export function harnessCommand(binary, args, cwd) {
-    if (process.platform !== "win32")
-        return [binary, args];
-    const path = harnessExecutableCandidates(binary, cwd, process.env.PATH ?? "").find((candidate) => statSync(candidate, { throwIfNoEntry: false })?.isFile());
-    if (!path)
-        throw new Error(`${binary} was not found on PATH`);
-    const extension = win32.extname(path).toLowerCase();
-    if (extension === ".exe" || extension === ".com")
-        return [path, args];
-    if ([".js", ".mjs", ".cjs"].includes(extension))
-        return [process.execPath, [path, ...args]];
-    if (extension === ".cmd") {
-        // npm (cmd-shim): SET "_prog=node" … "%dp0%\entry" %*; pnpm (@zkochan/cmd-shim): node  "%~dp0\entry" %*
-        const shim = readFileSync(path, "utf8");
-        const runsNode = /SET "_prog=node"/i.test(shim) || /^\s*node\s+"%~dp0\\/im.test(shim);
-        const entry = runsNode ? /"%~?dp0%?\\([^"]+)"\s+%\*/i.exec(shim)?.[1] : undefined;
-        if (entry)
-            return [process.execPath, [win32.join(win32.dirname(path), entry), ...args]];
-    }
-    throw new Error(`Cannot run ${path} without a shell; pass --pi/--codex with an .exe or Node script`);
-}
-/** Discover installed executables only; authentication/capability errors stay explicit. */
-export async function installedHarnesses(cwd, options, path = process.env.PATH ?? "") {
-    const names = options.pi || options.codex ? ["pi", "codex"].filter((name) => options[name]) : ["pi", "codex"];
-    const found = await Promise.all(names.map(async (name) => {
-        const binary = options[name] || name;
-        const candidates = harnessExecutableCandidates(binary, cwd, path);
-        for (const candidate of candidates) {
-            try {
-                await access(candidate, process.platform === "win32" ? constants.F_OK : constants.X_OK);
-                if ((await stat(candidate)).isFile())
-                    return name;
-            }
-            catch { /* Try the next PATH entry. */ }
-        }
-        return null;
-    }));
-    return found.filter((name) => name !== null);
-}
-const array = (value) => Array.isArray(value) ? value : [];
-const text = (value) => typeof value === "string" ? value : "";
-/** Aborted streams leave tool calls with an empty id or name. */
-export const identifiable = (value) => typeof value === "string" && value.length > 0;
-export function piContent(value) {
-    return array(value).flatMap((entry) => {
-        const block = record(entry);
-        if (block.type === "text")
-            return [{ type: "text", text: text(block.text) }];
-        if (block.type === "thinking")
-            return [{ type: "thinking", thinking: text(block.thinking), ...(typeof (block.thinkingSignature ?? block.signature) === "string" ? { signature: String(block.thinkingSignature ?? block.signature) } : {}) }];
-        if (block.type === "toolCall")
-            return identifiable(block.id) && identifiable(block.name) ? [{ type: "tool_use", id: block.id, name: block.name, input: record(block.arguments) }] : [];
-        if (block.type === "image")
-            return [{ type: "image", source: { type: "base64", data: text(block.data), media_type: text(block.mimeType) } }];
-        return [{ type: "text", text: JSON.stringify(block) }];
-    });
-}
-export async function imageForPi(block) {
-    if (block.source.type === "base64")
-        return { type: "image", data: block.source.data, mimeType: block.source.media_type };
-    const image = await downloadPublicImage(block.source.url);
-    return { type: "image", data: Buffer.from(image.bytes).toString("base64"), mimeType: image.mimeType };
-}
-async function initializeCodex(rpc) {
-    await rpc.request("initialize", { clientInfo: { name: "cohub", title: "Cohub", version: "1" }, capabilities: { experimentalApi: true } });
-    rpc.write({ method: "initialized", params: {} });
-}
-export async function discoverHarnesses(harnesses, options, cwd) {
-    const models = [];
-    await Promise.all(harnesses.map(async (harness) => {
-        const rpc = new JsonRpcProcess(...harnessCommand(options[harness] || harness, harness === "pi" ? ["--mode", "rpc", "--no-session"] : ["app-server", "--listen", "stdio://"], cwd), cwd, harness);
-        try {
-            if (harness === "pi") {
-                const result = await rpc.request("get_available_models");
-                const state = await rpc.request("get_state");
-                models.push(...piModelCatalog(array(result.models), state));
-            }
-            else {
-                await initializeCodex(rpc);
-                const config = await rpc.request("config/read", { includeLayers: false, cwd });
-                const entries = [];
-                const cursors = new Set();
-                let cursor = null;
-                do {
-                    const result = await rpc.request("model/list", { cursor, limit: 100 });
-                    entries.push(...array(result.data));
-                    cursor = typeof result.nextCursor === "string" ? result.nextCursor : null;
-                    if (entries.length > 2000 || cursor && cursors.has(cursor))
-                        throw new Error("Invalid model catalog pagination");
-                    if (cursor)
-                        cursors.add(cursor);
-                } while (cursor);
-                models.push(...codexModelCatalog(config, entries));
-            }
-        }
-        finally {
-            await rpc.close();
-        }
-    }));
-    return { harnesses, models };
-}
-export function codexItemContent(item) {
-    if (item.type === "agentMessage" || item.type === "plan")
-        return [{ type: "text", text: text(item.text) }];
-    if (item.type === "reasoning")
-        return [{ type: "thinking", thinking: [...array(item.summary), ...array(item.content)].map(text).join("\n") }];
-    if (item.type === "userMessage")
-        return [];
-    if (item.type === "contextCompaction")
-        return [{ type: "system_note", note_type: "compacted", text: "Context compacted" }];
-    const id = item.id;
-    if (!identifiable(id))
-        return [];
-    const name = item.type === "commandExecution" ? "bash" : item.type === "fileChange" ? "apply_patch" : text(item.tool) || text(item.type);
-    const input = item.type === "commandExecution" ? { command: item.command, cwd: item.cwd } : item.type === "fileChange" ? { changes: item.changes } : record(item.arguments);
-    return [
-        { type: "tool_use", id, name, input },
-        { type: "tool_result", tool_use_id: id, content: typeof item.aggregatedOutput === "string" ? item.aggregatedOutput : JSON.stringify(item.result ?? item.error ?? item.changes ?? item), is_error: item.status === "failed" || typeof item.exitCode === "number" && item.exitCode !== 0 },
-    ];
-}