@neta-art/cohub-cli 10.5.0 → 10.7.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
@@ -402,6 +404,8 @@ cohub generate "Lip-sync to this spoken take" \
   --image reference_image=https://example.com/portrait.png \
   --audio reference_audio=https://example.com/speech.mp3
 
+cohub generate -m song2 --text "prompt=upbeat synthwave" --text "lyrics=[Verse] Neon lights" --param seed=42
+
 cohub generate "a calm lake" \
   --model <model> \
   --async
@@ -412,6 +416,7 @@ cohub tasks get <taskRunId> --json
 Supported inputs:
 
 ```bash
+--text <role>=<text>
 --image <path-or-url>
 --image first_frame=<path-or-url>
 --image last_frame=<path-or-url>
@@ -422,7 +427,7 @@ Supported inputs:
 --audio reference_audio=<path-or-url>
 ```
 
-Role-qualified media values add `meta.role` to that content block. Repeat `--image reference_image=...` for multiple reference images. Seedance role-qualified media should use public URL inputs. Do not mix first/last frame roles with reference roles (`reference_image`, `reference_video`, `reference_audio`) in one request.
+Role-qualified values add `meta.role` to that content block. Text roles come from the model's text inputs (`cohub models show <model>`); repeat `--text <role>=<text>` for each text block. Repeat `--image reference_image=...` for multiple reference images. Seedance role-qualified media should use public URL inputs. Do not mix first/last frame roles with reference roles (`reference_image`, `reference_video`, `reference_audio`) in one request.
 
 Pass generation parameters with `--param key=value` or `--parameters '<json>'`.
 

package/dist/board-kernel.js

@@ -27490,9 +27490,14 @@ function fitTextToWidth(text, value, width) {
 }
 //#endregion
 //#region ../sdk/src/board/render/text-resolution.ts
-const MAX_BOARD_RESOLUTION = 2;
-function getBoardResolution() {
-	return Math.min(globalThis.devicePixelRatio || 1, MAX_BOARD_RESOLUTION);
+const MAX_BOARD_RESOLUTION = 3;
+const MAX_BOARD_PIXELS = 8e6;
+const MAX_TEXT_RESOLUTION = 6;
+function getBoardResolution(size, devicePixelRatio = globalThis.devicePixelRatio) {
+	const density = Number.isFinite(devicePixelRatio) && devicePixelRatio > 0 ? devicePixelRatio : 1;
+	const pixels = size ? size.width * size.height : 0;
+	const budget = pixels > 0 ? Math.sqrt(MAX_BOARD_PIXELS / pixels) : MAX_BOARD_RESOLUTION;
+	return Math.min(density, MAX_BOARD_RESOLUTION, budget);
 }
 /**
 * Zoom buckets for text re-rasterisation. Pixi Text is a bitmap: at high zoom it
@@ -27518,12 +27523,12 @@ function boardCardDetailed(zoom) {
 /** Effective text resolution for a given camera zoom. */
 function textResolutionForZoom(zoom) {
 	const bucket = textZoomBucket(zoom);
-	return Math.min(getBoardResolution() * Math.max(1, bucket), 6);
+	return Math.min(getBoardResolution() * Math.max(1, bucket), MAX_TEXT_RESOLUTION);
 }
 /** Update a Pixi text texture only when zoom crosses a resolution bucket. */
 function syncTextResolution(text, state, zoom) {
 	const resolution = textResolutionForZoom(zoom);
-	if (resolution === state.resolution) return;
+	if (resolution === state.resolution && resolution === text.resolution) return;
 	text.resolution = resolution;
 	state.resolution = resolution;
 }
@@ -28056,13 +28061,10 @@ function cardElevation(context, id) {
 }
 //#endregion
 //#region ../sdk/src/board/render/renderers/base-card-renderer.ts
-const TEXT_OPTIONS = {
-	resolution: getBoardResolution(),
-	roundPixels: true
-};
 function createLabel(text, style) {
 	return new Text({
-		...TEXT_OPTIONS,
+		resolution: getBoardResolution(),
+		roundPixels: true,
 		text,
 		style: {
 			fontFamily: BOARD_FONT_STACK,
@@ -29495,6 +29497,7 @@ function sync$5(container, item, context) {
 		parts.id = item.id;
 	}
 	positionShell(parts.root, item);
+	syncTextResolution(parts.label, parts.label, context.zoom);
 	const { width, height } = item.frame;
 	const resolution = Math.min(4, Math.max(.25, context.zoom * getBoardResolution()));
 	const texture = context.scripts?.frame(item, context.time, resolution) ?? null;

package/dist/commands/generations.js

@@ -32,6 +32,20 @@ function parseValue(value) {
     }
     return value;
 }
+function parseTextInputs(values) {
+    return values.map((value) => {
+        const index = value.indexOf("=");
+        if (index < 0)
+            return error("Invalid --text", "Pass --text <role>=<text>.");
+        const role = value.slice(0, index).trim();
+        if (!role)
+            return error("Invalid --text", "Pass a role: --text <role>=<text>.");
+        const text = value.slice(index + 1);
+        if (!text)
+            return error("Invalid --text", 'Pass text after "=": --text <role>=<text>.');
+        return { role, text };
+    });
+}
 function parseParams(param, parameters) {
     const result = parameters ? JSON.parse(parameters) : {};
     for (const item of param ?? []) {
@@ -260,8 +274,9 @@ export function registerGenerations(program) {
     program
         .command("generate")
         .description("Generate multimodal outputs")
-        .argument("<prompt>", "Prompt text")
+        .argument("[prompt]", "Prompt text; optional when --text is given")
         .requiredOption("-m, --model <model>", "Multimodal model ID from `cohub models ls --model-type multimodal`")
+        .option("--text <role=text>", "Text input with a role from the model's text inputs (`cohub models show <model>`); repeatable, split at the first =, text sent unchanged", collect, [])
         .option("--image <path-or-url>", "Image input file path or URL; prefix with first_frame=, last_frame=, or reference_image= when needed; repeatable", collect, [])
         .option("--video <path-or-url>", "Video input file path or URL; prefix with reference_video= when needed; repeatable", collect, [])
         .option("--audio <path-or-url>", "Audio input file path or URL; prefix with reference_audio= when needed; repeatable", collect, [])
@@ -285,10 +300,15 @@ Examples:
   cohub -s <space-id> generate "Smooth transition" -m seedance-2-0-fast --image first_frame=https://example.com/first.png --image last_frame=https://example.com/last.png
   cohub -s <space-id> generate "Use these references" -m seedance-2-0-fast --image reference_image=https://example.com/a.png --image reference_image=https://example.com/b.png
   cohub -s <space-id> generate "Lip-sync to the reference take" -m seedance-2-0-fast --image reference_image=https://example.com/portrait.png --audio reference_audio=https://example.com/speech.mp3
+  cohub -s <space-id> generate -m song2 --text "prompt=upbeat synthwave" --text "lyrics=[Verse] Neon lights" --param seed=42
   cohub -s <space-id> generate "A calm lake" -m <model> --async
 `)
         .action(async (prompt, opts) => {
         try {
+            const texts = parseTextInputs(opts.text);
+            if (prompt === undefined && texts.length === 0) {
+                return error("Missing prompt", "Pass a prompt or at least one --text <role>=<text>.");
+            }
             const spaceId = await resolveSpace(program, { home: true });
             const sessionId = envValue("COHUB_SESSION_ID");
             const inputs = await Promise.all([
@@ -330,7 +350,8 @@ Examples:
                 return asset.publicUrl;
             };
             const content = [
-                { type: "text", text: prompt },
+                ...(prompt === undefined ? [] : [{ type: "text", text: prompt }]),
+                ...texts.map(({ role, text }) => ({ type: "text", text, meta: { role } })),
                 ...await Promise.all(inputs.map((input) => mediaContent(input, upload))),
             ];
             const created = await client.generations.create({

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,153 @@
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { JsonRpcProcess, record } from "../json-rpc.js";
+import { copyNativeArchive } from "../native/archive.js";
+import { projectChainedSession, projectionMeta, projectionToolId, rebindSessionId } from "./chained-projection.js";
+import { array, harnessCommand, text } from "./process.js";
+import { DEFAULT_MODEL, runStreamJson, streamJsonHelp, streamJsonModel } from "./stream-json.js";
+const MAX_PROJECT_NAME = 200;
+const INITIALIZE_TIMEOUT_MS = 30_000;
+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 } },
+        }) };
+}
+/** Claude Code's own `/model` list (what the SDK's `supportedModels()` reads), gateway-discovered models included. */
+async function claudeInitialize(executable, cwd) {
+    const args = ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose", "--no-session-persistence", "--strict-mcp-config"];
+    const host = new JsonRpcProcess(...harnessCommand(executable, args, cwd), cwd, "stream");
+    const requestId = randomUUID();
+    let timer;
+    try {
+        return await new Promise((resolve, reject) => {
+            timer = setTimeout(() => reject(new Error("Claude Code initialize timed out")), INITIALIZE_TIMEOUT_MS);
+            host.onFailure(reject);
+            host.onEvent((event) => {
+                const response = record(event.response);
+                if (event.type !== "control_response" || response.request_id !== requestId)
+                    return;
+                if (response.subtype === "success")
+                    resolve(record(response.response));
+                else
+                    reject(new Error(text(response.error) || "Claude Code initialize failed"));
+            });
+            host.write({ type: "control_request", request_id: requestId, request: { subtype: "initialize" } });
+        });
+    }
+    finally {
+        clearTimeout(timer);
+        await host.close();
+    }
+}
+/** Gateway models are served by `ANTHROPIC_BASE_URL`, so they carry its host as provider. */
+function claudeModelCatalog(entries, baseUrl) {
+    let gateway = "gateway";
+    try {
+        if (baseUrl)
+            gateway = new URL(baseUrl).hostname.slice(0, 100) || gateway;
+    }
+    catch { /* Keep the generic name. */ }
+    const seen = new Set();
+    return entries.flatMap((value) => {
+        const model = record(value);
+        const id = text(model.value);
+        if (!id || id.length > 255 || seen.has(id))
+            return [];
+        seen.add(id);
+        const effortLevels = model.supportsEffort === true ? array(model.supportedEffortLevels).filter((level) => typeof level === "string") : [];
+        return [streamJsonModel(profile, id, (text(model.displayName) || id).slice(0, 255), {
+                reasoning: effortLevels.length > 0, effortLevels, isDefault: id === DEFAULT_MODEL,
+                provider: text(model.description).startsWith("From gateway") ? gateway : profile.provider,
+            })];
+    });
+}
+export const claudeHarness = {
+    id: "claude",
+    binary: profile.binary,
+    async models(executable, cwd) {
+        await streamJsonHelp(profile, executable, cwd);
+        try {
+            const models = claudeModelCatalog(array((await claudeInitialize(executable, cwd)).models), process.env.ANTHROPIC_BASE_URL);
+            if (models.some((model) => model.isDefault))
+                return models;
+        }
+        catch { /* A CLI without the initialize model list keeps the account aliases. */ }
+        // 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;