@neta-art/cohub-cli 10.5.0 → 10.6.0

package/README.md

@@ -137,7 +137,9 @@ cohub -s home spaces files ls
 
 ## Local Runtime
 
-Connect one local workspace to a Space and select Pi or Codex per turn.
+Connect one local workspace to a Space and select Pi, Codex, Claude Code or WorkBuddy per turn.
+Claude Code (`claude`) and WorkBuddy (`codebuddy`) run Cohub Turns only; terminal sync covers Pi and Codex.
+Without `--harness`, every installed harness is tried; one that cannot start is skipped with a warning.
 
 To keep using native terminals with ordinary Cohub Chats / Turns:
 
@@ -179,7 +181,7 @@ are never uploaded automatically. Use `runtime logs --json` to export a failure
 events carry the local `runtimeId` plus server `requestId` / `traceparent` when a turn has
 reached the Agent trace.
 
-The Runtime uses WebSockets, native Pi RPC / Codex app-server, and existing cloud
+The Runtime uses WebSockets, native Pi RPC / Codex app-server / Claude Code stream-json, and existing cloud
 streaming. Local executables and credentials are required. `sandbox up` has been
 removed. Reconnection and result reconciliation are automatic; no recovery command is needed.
 When a result genuinely cannot be determined, the affected Chat offers an explicit stop

package/dist/commands/runtime.js

@@ -1,4 +1,5 @@
 import { setTimeout as delay } from "node:timers/promises";
+import { LOCAL_HARNESS_SPECS, LOCAL_HARNESSES } from "@neta-art/cohub";
 import { createClient } from "../client.js";
 import { json as outJson, jsonRequested } from "../output.js";
 import { currentIdentityKey } from "../space.js";
@@ -9,6 +10,7 @@ import { RuntimeArchiveStore } from "../runtime/archive-store.js";
 import { readNativeConfig, runtimeStateRoot, writeNativeConfig } from "../runtime/native/config.js";
 import { MAX_IMPORT_CONCURRENCY, DEFAULT_IMPORT_CONCURRENCY } from "../runtime/native/ingest.js";
 import { installPiExtension, piExtensionState } from "../runtime/native/install.js";
+import { nativeSyncHarnesses } from "../runtime/harnesses/index.js";
 import { controlRuntimeInstance, requestRuntimeInstance, runtimeInstanceDirectory } from "../runtime/instance.js";
 import { atLeastLevel, diagnosticLevels, formatDiagnostic, formatImportProgress, formatNativeSync, printRuntimeSummary } from "../runtime/presentation.js";
 import { readRuntimeDiagnosticEvents, RuntimeDiagnosticReader, runtimeDiagnosticsDirectory, serializeDiagnosticError } from "../runtime/diagnostics.js";
@@ -17,6 +19,16 @@ const reportFailure = (cause) => {
     process.stderr.write(`Runtime failed: ${serializeDiagnosticError(cause).message}\n`);
     process.exitCode = 1;
 };
+const SYNCED = nativeSyncHarnesses(LOCAL_HARNESSES);
+const SYNCED_LABELS = SYNCED.map((harness) => LOCAL_HARNESS_SPECS[harness].label).join(" or ");
+/** Native sync and import cover only harnesses whose terminal conversations sync. */
+function parseSyncedHarnesses(values) {
+    const harnesses = parseRuntimeHarnesses(values);
+    const unsynced = harnesses.filter((harness) => !SYNCED.includes(harness));
+    if (unsynced.length)
+        throw new Error(`${unsynced.map((harness) => LOCAL_HARNESS_SPECS[harness].label).join(", ")} conversations do not sync; native sync covers ${SYNCED_LABELS}`);
+    return harnesses;
+}
 const megabytes = (bytes) => `${(bytes / 1024 / 1024).toFixed(1)} MB`;
 /** The bound Space of a directory, with its running Runtime; import and attach act through it. */
 async function boundRuntime(program, dir, space) {
@@ -32,15 +44,16 @@ async function boundRuntime(program, dir, space) {
 }
 export function registerRuntime(program) {
     const runtime = program.command("runtime").description("Connect a local workspace");
-    runtime.command("up [dir]")
+    const up = runtime.command("up [dir]")
         .description("Connect local Harnesses and files")
         .option("-s, --space <space>", "Target Space: ID, slug, or username/slug")
         .option("-n, --new", "Create a new Space")
         .option("--name <name>", "New Space name")
         .option("-d, --detach", "Run in the background")
-        .option("--harness <name>", "Pi or Codex; repeatable", (value, previous) => [...previous, value], [])
-        .option("--pi <path>", "Pi executable")
-        .option("--codex <path>", "Codex executable")
+        .option("--harness <name>", `${LOCAL_HARNESSES.join(", ")}; repeatable`, (value, previous) => [...previous, value], []);
+    for (const harness of LOCAL_HARNESSES)
+        up.option(`--${harness} <path>`, `${LOCAL_HARNESS_SPECS[harness].label} executable`);
+    up
         .option("--display [screen]", "Share a screen (default: auto when available), or xvfb[:WIDTHxHEIGHT] for a virtual one")
         .option("--no-display", "Disable screen sharing and skip its confirmation")
         .option("-y, --yes", "Accept defaults and authorize local execution, native sync, and screen sharing")
@@ -63,7 +76,7 @@ export function registerRuntime(program) {
         try {
             const harnesses = parseRuntimeHarnesses(options.harness.length ? options.harness : ["pi"]);
             if (!harnesses.includes("pi"))
-                throw new Error("Codex needs no extension; runtime up offers its shared app-server");
+                throw new Error("Only Pi uses an extension; Codex syncs through runtime up's shared app-server");
             const before = await piExtensionState();
             if (before === "foreign")
                 throw new Error("A Pi extension named cohub exists and is not managed by Cohub; move it aside, then retry");
@@ -84,14 +97,14 @@ export function registerRuntime(program) {
     runtime.command("detach")
         .description("Pause native sync; keep all data")
         .option("-s, --space <space>", "Target Space: ID, slug, or username/slug")
-        .option("--harness <name>", "Pi or Codex; repeatable", (value, previous) => [...previous, value], [])
+        .option("--harness <name>", `${SYNCED_LABELS}; repeatable`, (value, previous) => [...previous, value], [])
         .option("--json", "JSON output")
         .action(async (options) => {
         try {
             const { identity, spaceId, directory } = await boundRuntime(program, undefined, options.space);
             const stateRoot = runtimeStateRoot(spaceId);
             const config = await readNativeConfig(stateRoot, identity);
-            const paused = parseRuntimeHarnesses(options.harness.length ? options.harness : config?.harnesses ?? ["pi", "codex"]);
+            const paused = options.harness.length ? parseSyncedHarnesses(options.harness) : config?.harnesses ?? SYNCED;
             const harnesses = (config?.harnesses ?? []).filter((harness) => !paused.includes(harness));
             if (config)
                 await writeNativeConfig(stateRoot, { ...config, harnesses, codexShared: harnesses.includes("codex") && config.codexShared });
@@ -131,7 +144,7 @@ export function registerRuntime(program) {
                 throw new Error(`Use a concurrency from 1 to ${MAX_IMPORT_CONCURRENCY}`);
             const { spaceId, root, directory } = await boundRuntime(program, dir, options.space);
             // The Runtime does the work, so an import survives this command: Ctrl-C only pauses it.
-            const filter = { harnesses: options.harness.length ? parseRuntimeHarnesses(options.harness) : [], ...(options.session ? { nativeSessionId: options.session } : {}) };
+            const filter = { harnesses: options.harness.length ? parseSyncedHarnesses(options.harness) : [], ...(options.session ? { nativeSessionId: options.session } : {}) };
             const control = async (command, timeoutMs = 60_000) => {
                 const response = await controlRuntimeInstance(directory, "import", { ...filter, command, concurrency }, timeoutMs);
                 if (!response)

package/dist/commands/spaces.js

@@ -1,6 +1,6 @@
 import { readdir, stat } from "node:fs/promises";
 import { basename, dirname, relative, resolve, sep } from "node:path";
-import { readSentTurns, readSessionTurnOrigin, resolveCohubEnvironment } from "@neta-art/cohub";
+import { harnessSchema, readSentTurns, readSessionTurnOrigin, resolveCohubEnvironment } from "@neta-art/cohub";
 import { uploadAvatarAsset, uploadChatImageAsset } from "../avatar.js";
 import { createClient } from "../client.js";
 import { collectOption, readPromptContent } from "../command-input.js";
@@ -344,7 +344,7 @@ export function registerPrompt(program) {
         .option("--title <title>", "Title for a newly created session or schedule")
         .option("-m, --model <model>", "Model name")
         .option("-p, --provider <provider>", "Provider name")
-        .option("--harness <harness>", "Harness: cohub, pi, or codex", "cohub")
+        .option("--harness <harness>", `Harness: ${harnessSchema.options.join(", ")}`, "cohub")
         .option("--thinking-level <level>", "Thinking level: off|minimal|low|medium|high|xhigh|max")
         .option("--read-only", "Use read-only tools")
         .option("--steer", "Interrupt the current turn and run immediately")
@@ -703,7 +703,7 @@ export function registerSpaces(program) {
         .command("prompt [content...]", { hidden: true })
         .alias("send")
         .description("Send or schedule a prompt in the target space")
-        .option("--harness <harness>", "Harness: cohub, pi, or codex", "cohub")
+        .option("--harness <harness>", `Harness: ${harnessSchema.options.join(", ")}`, "cohub")
         .option("--session <id>", "Target session ID")
         .option("--title <title>", "Title for a newly created session or schedule")
         .option("-m, --model <model>", "Model name")

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

@@ -1,4 +1,4 @@
-import { type HarnessArchive, type HarnessArchiveIndex, type RuntimeArchivePage, type RuntimeArchiveUpload } from "@neta-art/cohub";
+import { type LocalHarness, type HarnessArchive, type HarnessArchiveIndex, type RuntimeArchivePage, type RuntimeArchiveUpload } from "@neta-art/cohub";
 export type ArchiveTransport = {
     fetchObject?: typeof fetch;
     prepareRuntimeArchive(index: HarnessArchiveIndex, options?: {
@@ -41,7 +41,7 @@ export declare class RuntimeArchiveStore {
     private readIndex;
     stage(state: {
         sessionId: string;
-        harness: "pi" | "codex";
+        harness: LocalHarness;
         nativeSessionId: string;
         path: string;
         sizeBytes?: number;

package/dist/runtime/archive-store.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { mkdir, open, readFile, readdir, rename, rm, stat, link } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { RUNTIME_ARCHIVE_SEGMENT_BYTES, harnessArchiveIndexSchema, validateArchiveBoundary, } from "@neta-art/cohub";
+import { LOCAL_HARNESS_SPECS, RUNTIME_ARCHIVE_SEGMENT_BYTES, harnessArchiveIndexSchema, validateArchiveBoundary, } from "@neta-art/cohub";
 const missing = (error) => error?.code === "ENOENT";
 /** Raised when local capture bytes fail integrity checks (checksum, truncation, boundary); retryable via cache rebuild. */
 export class ArchiveCaptureIntegrityError extends Error {
@@ -195,7 +195,7 @@ export class RuntimeArchiveStore {
                 }
             }
             index = harnessArchiveIndexSchema.parse({ ...identity, version: 1, nativeSessionId: state.nativeSessionId,
-                nativeFormat: state.harness === "pi" ? "pi.jsonl" : "codex.rollout", parentTurnId: parent?.turnId ?? null,
+                nativeFormat: LOCAL_HARNESS_SPECS[state.harness].nativeFormat, parentTurnId: parent?.turnId ?? null,
                 sizeBytes, sha256: digest.digest("hex"), segments });
             validateArchiveBoundary(index, parent);
             if (state.expectedChecksum && index.sha256 !== state.expectedChecksum)

package/dist/runtime/diagnostics.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeTraceContext } from "@neta-art/cohub";
+import type { LocalHarness, RuntimeTraceContext } from "@neta-art/cohub";
 export type RuntimeDiagnosticLevel = "debug" | "info" | "warn" | "error";
 export type RuntimeDiagnosticError = {
     name?: string;
@@ -27,7 +27,7 @@ export type RuntimeDiagnostic = {
     spaceId: string;
     sessionId?: string | null;
     turnId?: string | null;
-    harness?: "pi" | "codex" | null;
+    harness?: LocalHarness | null;
     traceContext?: RuntimeTraceContext;
     data?: Record<string, unknown>;
     error?: RuntimeDiagnosticError;
@@ -39,7 +39,7 @@ export type RuntimeDiagnosticContext = {
     spaceId?: string;
     sessionId?: string | null;
     turnId?: string | null;
-    harness?: "pi" | "codex" | null;
+    harness?: LocalHarness | null;
     traceContext?: RuntimeTraceContext;
 };
 export type RuntimeDiagnosticsOptions = {

package/dist/runtime/harnesses/chained-projection.d.ts

@@ -0,0 +1,40 @@
+import { type CanonicalProjectionMessage, type ContentBlock, type LocalHarness, type NativeProjection, type ProjectionInput, type ProjectionRecord } from "@neta-art/cohub";
+type ToolResult = Extract<ContentBlock, {
+    type: "tool_result";
+}>;
+/** Deterministic, UUID-shaped record ids keep re-projection stable without local state. */
+export declare function projectionUuid(key: string): string;
+/** Provider APIs restrict tool ids; hashing keeps call/result pairs linked. */
+export declare function projectionToolId(id: string): string;
+export type ProjectedSegment = {
+    role: "user" | "assistant";
+    blocks: ContentBlock[];
+    message: CanonicalProjectionMessage;
+    compactSummary: boolean;
+};
+/**
+ * Shared walk for transcript formats whose records form a parent-linked chain. `write` maps one
+ * user/assistant segment to native records; ids and parent links are assigned here.
+ */
+export declare function projectChainedSession(input: ProjectionInput, target: LocalHarness, fields: {
+    id: string;
+    parent: string;
+}, write: (segment: ProjectedSegment) => Record<string, unknown>[]): NativeProjection;
+export declare const projectionMeta: (input: ProjectionInput, message: CanonicalProjectionMessage) => {
+    messageId: string;
+    turnId: string;
+    schema: string;
+    spaceId: string;
+    sessionId: string;
+};
+export declare const toolResultText: (block: ToolResult) => string;
+/** Session id is stored on every record of these formats. */
+export declare const rebindSessionId: (records: ProjectionRecord[], nativeSessionId: string) => {
+    key: string;
+    sourceTurnId: string | null;
+    sourceMessageId: string | null;
+    record: {
+        sessionId: string;
+    };
+}[];
+export {};

package/dist/runtime/harnesses/chained-projection.js

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import { fingerprintProjectionTurns, isProjectionCompaction, isProjectionPendingGeneration, projectNativeMessageMeta, trimProjectionTurnsToCompaction, } from "@neta-art/cohub";
+/** Deterministic, UUID-shaped record ids keep re-projection stable without local state. */
+export function projectionUuid(key) {
+    const hex = createHash("sha256").update(key).digest("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-5${hex.slice(13, 16)}-${((Number.parseInt(hex[16] ?? "0", 16) & 3) | 8).toString(16)}${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
+}
+/** Provider APIs restrict tool ids; hashing keeps call/result pairs linked. */
+export function projectionToolId(id) {
+    return /^[A-Za-z0-9_-]{1,64}$/.test(id) ? id : `call_${createHash("sha256").update(id).digest("hex").slice(0, 32)}`;
+}
+const nonEmpty = (block) => block.type !== "text" || block.text.length > 0;
+/**
+ * Splits Cohub messages into alternating native records. A tool call is kept only with its result,
+ * because provider APIs reject unpaired calls; dropped content is reported as a projection warning.
+ */
+function segments(message, warnings) {
+    const warn = (reason) => warnings.push({ sourceMessageId: message.id, sourceTurnId: message.turnId, reason });
+    if (message.content.some((block) => block.type === "image" && block.source.type === "url"))
+        warn("external image URL omitted from native projection");
+    const visible = message.content.filter((block) => nonEmpty(block) && !(block.type === "image" && block.source.type === "url"));
+    if (message.role === "user") {
+        const blocks = visible.filter((block) => block.type === "text" || block.type === "image");
+        return blocks.length ? [{ role: "user", blocks }] : [];
+    }
+    const raw = [];
+    for (const block of visible) {
+        const role = block.type === "tool_result" ? "user" : "assistant";
+        if (role === "assistant" && !["text", "tool_use"].includes(block.type))
+            continue;
+        const last = raw.at(-1);
+        if (last?.role === role)
+            last.blocks.push(block);
+        else
+            raw.push({ role, blocks: [block] });
+    }
+    const paired = [];
+    raw.forEach((segment, index) => {
+        if (segment.role === "assistant") {
+            const results = new Set(raw[index + 1]?.role === "user" ? raw[index + 1]?.blocks.flatMap((block) => block.type === "tool_result" ? [block.tool_use_id] : []) : []);
+            const blocks = segment.blocks.filter((block) => block.type !== "tool_use" || results.has(block.id));
+            if (blocks.length !== segment.blocks.length)
+                warn("tool call without a result omitted from native projection");
+            if (blocks.length)
+                paired.push({ role: "assistant", blocks });
+        }
+        else {
+            const calls = new Set(raw[index - 1]?.role === "assistant" ? raw[index - 1]?.blocks.flatMap((block) => block.type === "tool_use" ? [block.id] : []) : []);
+            const blocks = segment.blocks.filter((block) => block.type === "tool_result" && calls.has(block.tool_use_id));
+            if (blocks.length !== segment.blocks.length)
+                warn("tool result without a call omitted from native projection");
+            if (blocks.length)
+                paired.push({ role: "user", blocks });
+        }
+    });
+    return paired;
+}
+const compactionText = (message) => message.content.flatMap((block) => block.type === "system_note" ? [block.text] : []).join("\n");
+/**
+ * Shared walk for transcript formats whose records form a parent-linked chain. `write` maps one
+ * user/assistant segment to native records; ids and parent links are assigned here.
+ */
+export function projectChainedSession(input, target, fields, write) {
+    const warnings = [];
+    const records = [];
+    let parentId = null;
+    for (const turn of trimProjectionTurnsToCompaction(input.turns)) {
+        for (const message of turn.messages) {
+            if (isProjectionPendingGeneration(message))
+                continue;
+            const parts = isProjectionCompaction(message)
+                ? compactionText(message) ? [{ role: "user", blocks: [{ type: "text", text: compactionText(message) }], compactSummary: true }] : []
+                : message.role === "system" ? [] : segments(message, warnings).map((segment) => ({ ...segment, compactSummary: false }));
+            let ordinal = 0;
+            for (const part of parts) {
+                for (const native of write({ ...part, message })) {
+                    const key = `${message.id}:${message.turnId}:${ordinal++}`;
+                    const id = projectionUuid(`${input.sessionId}:${key}`);
+                    records.push({ key, sourceTurnId: message.turnId, sourceMessageId: message.id, record: { [fields.parent]: parentId, [fields.id]: id, ...native } });
+                    parentId = id;
+                }
+            }
+        }
+    }
+    const last = input.turns.at(-1);
+    return { target, records, cursor: { sourceSequence: last?.sequence ?? null, sourceTurnId: last?.sourceTurnId ?? null, sourceFingerprint: fingerprintProjectionTurns(input.turns) }, warnings };
+}
+export const projectionMeta = (input, message) => ({
+    schema: "cohub.projection.v2", spaceId: input.spaceId, sessionId: input.sessionId, ...projectNativeMessageMeta(message),
+});
+export const toolResultText = (block) => typeof block.content === "string"
+    ? block.content
+    : block.content.flatMap((item) => item.type === "text" ? [item.text] : []).join("\n");
+/** Session id is stored on every record of these formats. */
+export const rebindSessionId = (records, nativeSessionId) => records.map((entry) => ({ ...entry, record: { ...entry.record, sessionId: nativeSessionId } }));

package/dist/runtime/harnesses/claude.d.ts

@@ -0,0 +1,8 @@
+import type { LocalHarnessAdapter } from "./types.js";
+/**
+ * Claude Code names a project directory by replacing every non-alphanumeric UTF-16 unit; a longer
+ * name keeps its first 200 units and appends the base-36 Java string hash of the path.
+ */
+export declare function claudeProjectName(cwd: string): string;
+export declare const claudeProjectDirectory: (cwd: string) => string;
+export declare const claudeHarness: LocalHarnessAdapter;

package/dist/runtime/harnesses/claude.js

@@ -0,0 +1,94 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { copyNativeArchive } from "../native/archive.js";
+import { projectChainedSession, projectionMeta, projectionToolId, rebindSessionId } from "./chained-projection.js";
+import { DEFAULT_MODEL, runStreamJson, streamJsonHelp, streamJsonModel } from "./stream-json.js";
+const MAX_PROJECT_NAME = 200;
+const dataRoot = () => process.env.CLAUDE_CONFIG_DIR?.trim() || join(homedir(), ".claude");
+/**
+ * Claude Code names a project directory by replacing every non-alphanumeric UTF-16 unit; a longer
+ * name keeps its first 200 units and appends the base-36 Java string hash of the path.
+ */
+export function claudeProjectName(cwd) {
+    const name = cwd.replace(/[^a-zA-Z0-9]/g, "-");
+    if (name.length <= MAX_PROJECT_NAME)
+        return name;
+    let hash = 0;
+    for (let index = 0; index < cwd.length; index++)
+        hash = (hash * 31 + cwd.charCodeAt(index)) | 0;
+    return `${name.slice(0, MAX_PROJECT_NAME)}-${Math.abs(hash).toString(36)}`;
+}
+export const claudeProjectDirectory = (cwd) => join(dataRoot(), "projects", claudeProjectName(cwd));
+const profile = {
+    harness: "claude",
+    label: "Claude Code",
+    binary: "claude",
+    provider: "anthropic",
+    dataRoot,
+    projectDirectory: claudeProjectDirectory,
+    effortLevels: ["low", "medium", "high", "xhigh", "max"],
+};
+function anthropicBlock(block) {
+    if (block.type === "text")
+        return { type: "text", text: block.text };
+    if (block.type === "image" && block.source.type === "base64")
+        return { type: "image", source: { type: "base64", media_type: block.source.media_type, data: block.source.data } };
+    if (block.type === "tool_use")
+        return { type: "tool_use", id: projectionToolId(block.id), name: block.name.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 128) || "tool", input: block.input };
+    if (block.type === "tool_result") {
+        const content = typeof block.content === "string" ? block.content : block.content.map(anthropicBlock).filter((item) => item !== null);
+        return { type: "tool_result", tool_use_id: projectionToolId(block.tool_use_id), content, is_error: block.is_error ?? false };
+    }
+    return null;
+}
+/** Claude Code merges consecutive assistant records sharing a message id; each projected call gets its own. */
+function withAssistantIds(projection) {
+    return { ...projection, records: projection.records.map((entry) => entry.record.type !== "assistant" ? entry : {
+            ...entry, record: { ...entry.record, message: { id: `msg_${String(entry.record.uuid).replaceAll("-", "")}`, ...entry.record.message } },
+        }) };
+}
+export const claudeHarness = {
+    id: "claude",
+    binary: profile.binary,
+    async models(executable, cwd) {
+        await streamJsonHelp(profile, executable, cwd);
+        // Aliases follow the signed-in account; Haiku takes no effort level.
+        return [
+            streamJsonModel(profile, DEFAULT_MODEL, "Default", { reasoning: true, isDefault: true }),
+            streamJsonModel(profile, "opus", "Claude Opus", { reasoning: true }),
+            streamJsonModel(profile, "sonnet", "Claude Sonnet", { reasoning: true }),
+            streamJsonModel(profile, "haiku", "Claude Haiku", { reasoning: false }),
+        ];
+    },
+    run: (executor, turn) => runStreamJson(profile, executor, turn),
+    session: {
+        path: (nativeSessionId, cwd) => join(claudeProjectDirectory(cwd), `${nativeSessionId}.jsonl`),
+        startsWithoutFile: true,
+        project: (input) => withAssistantIds(projectChainedSession(input, "claude", { id: "uuid", parent: "parentUuid" }, (segment) => {
+            const content = segment.blocks.map(anthropicBlock).filter((block) => block !== null);
+            return [{
+                    isSidechain: false, userType: "external", cwd: input.cwd, sessionId: input.nativeSessionId, version: "cohub",
+                    type: segment.role, timestamp: segment.message.createdAt || input.timestamp || new Date(0).toISOString(),
+                    ...(segment.compactSummary ? { isCompactSummary: true } : {}),
+                    message: segment.role === "user"
+                        ? { role: "user", content }
+                        : {
+                            type: "message", role: "assistant", model: segment.message.model || "cohub", content,
+                            stop_reason: segment.blocks.some((block) => block.type === "tool_use") ? "tool_use" : "end_turn", stop_sequence: null,
+                            usage: { input_tokens: 0, output_tokens: 0 },
+                        },
+                    cohub: projectionMeta(input, segment.message),
+                }];
+        })),
+        rebind: rebindSessionId,
+        archive: {
+            // The copy takes a fresh id: the archived one may already exist here, and is never replaced.
+            target: ({ id, cwd }) => join(claudeProjectDirectory(cwd), `${id}.jsonl`),
+            async import(input) {
+                const { checksum } = await copyNativeArchive({ ...input, sessionId: input.id });
+                return { checksum, nativeSessionId: input.id };
+            },
+        },
+    },
+    nativeSync: false,
+};

package/dist/runtime/harnesses/codex.d.ts

@@ -0,0 +1,4 @@
+import type { LocalHarnessAdapter, ThreadKind } from "./types.js";
+/** 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 codexHarness: LocalHarnessAdapter;