@neta-art/cohub-cli 10.6.0 → 10.8.0

package/dist/commands/boards/examples.js

@@ -10,9 +10,9 @@ export const BOARD_EXAMPLES = {
         value: {
             board: { title: "Launch plan" },
             items: {
-                title: { type: "text", position: { x: 80, y: 60 }, props: { text: "Launch plan", fontSize: 48, fontWeight: 700 } },
-                note: { type: "text", position: { x: 80, y: 140 }, props: { text: "Ship the beta to ten design partners, then widen.", fontSize: 20, width: 420 } },
-                goal: { type: "shape", position: { x: 600, y: 60 }, size: { width: 240, height: 140 }, style: { stroke: "green", fill: "green", fillOpacity: 0.12, radius: 16 }, props: { text: "Beta in March" } },
+                title: { type: "text", position: { x: 80, y: 60 }, props: { text: "Launch plan", fontSize: 40, fontWeight: 700 } },
+                note: { type: "text", position: { x: 80, y: 128 }, props: { text: "Ship the beta to ten design partners, then widen.", width: 420 } },
+                goal: { type: "shape", position: { x: 600, y: 60 }, size: { width: 200, height: 140 }, style: { stroke: "green", fill: "green", fillOpacity: 0.12, radius: 16 }, props: { text: "Beta in March" } },
             },
         },
     },
@@ -29,14 +29,14 @@ export const BOARD_EXAMPLES = {
         },
     },
     slides: {
-        description: "Frames as slides; children move and clip with their frame.",
+        description: "960×540 frames as slides; children move and clip with their frame.",
         value: {
             items: {
-                s1: { type: "frame", position: { x: 0, y: 0 }, size: { width: 1600, height: 900 }, props: { label: "Intro" } },
-                "s1-title": { type: "text", parent: "s1", position: { x: 120, y: 120 }, props: { text: "Special relativity", fontSize: 96, fontWeight: 700 } },
-                "s1-sub": { type: "text", parent: "s1", position: { x: 120, y: 260 }, props: { text: "Nothing outruns light", fontSize: 40 } },
-                s2: { type: "frame", position: { x: 1800, y: 0 }, size: { width: 1600, height: 900 }, props: { label: "Time dilation" } },
-                "s2-title": { type: "text", parent: "s2", position: { x: 120, y: 120 }, props: { text: "Moving clocks run slow", fontSize: 72, fontWeight: 700 } },
+                s1: { type: "frame", position: { x: 0, y: 0 }, size: { width: 960, height: 540 }, props: { label: "Intro" } },
+                "s1-title": { type: "text", parent: "s1", position: { x: 72, y: 72 }, props: { text: "Special relativity", fontSize: 56, fontWeight: 700 } },
+                "s1-sub": { type: "text", parent: "s1", position: { x: 72, y: 160 }, props: { text: "Nothing outruns light" } },
+                s2: { type: "frame", position: { x: 1080, y: 0 }, size: { width: 960, height: 540 }, props: { label: "Time dilation" } },
+                "s2-title": { type: "text", parent: "s2", position: { x: 72, y: 72 }, props: { text: "Moving clocks run slow", fontSize: 40, fontWeight: 700 } },
             },
         },
     },
@@ -44,12 +44,12 @@ export const BOARD_EXAMPLES = {
         description: "An animated lesson: entrances, a drawn arrow, typed text and camera moves with pause markers.",
         value: {
             items: {
-                s1: { type: "frame", size: { width: 1600, height: 900 }, props: { label: "Length contraction" } },
-                title: { type: "text", parent: "s1", position: { x: 120, y: 100 }, props: { text: "Moving rulers get shorter", fontSize: 72, fontWeight: 700 } },
-                ruler: { type: "shape", parent: "s1", position: { x: 200, y: 420 }, size: { width: 800, height: 60 }, style: { stroke: "blue", fill: "blue", fillOpacity: 0.15 }, props: { text: "1 m" } },
-                caption: { type: "text", parent: "s1", position: { x: 200, y: 560 }, props: { text: "L = L₀ √(1 − v²/c²)", fontSize: 44, font: "serif", reveal: 1 } },
-                motion: { type: "arrow", parent: "s1", style: { stroke: "rose", strokeWidth: 4 }, props: { start: { x: 200, y: 360 }, end: { x: 1000, y: 360 }, label: "v → c" } },
-                glow: { type: "effect", parent: "s1", position: { x: 1050, y: 380 }, size: { width: 160, height: 160 }, style: { fill: "amber" }, props: { kind: "glow" } },
+                s1: { type: "frame", size: { width: 960, height: 540 }, props: { label: "Length contraction" } },
+                title: { type: "text", parent: "s1", position: { x: 72, y: 60 }, props: { text: "Moving rulers get shorter", fontSize: 40, fontWeight: 700 } },
+                ruler: { type: "shape", parent: "s1", position: { x: 120, y: 252 }, size: { width: 480, height: 40 }, style: { stroke: "blue", fill: "blue", fillOpacity: 0.15 }, props: { text: "1 m", fontSize: 16 } },
+                caption: { type: "text", parent: "s1", position: { x: 120, y: 336 }, props: { text: "L = L₀ √(1 − v²/c²)", font: "serif", reveal: 1 } },
+                motion: { type: "arrow", parent: "s1", style: { stroke: "rose", strokeWidth: 3 }, props: { start: { x: 120, y: 216 }, end: { x: 600, y: 216 }, label: "v → c" } },
+                glow: { type: "effect", parent: "s1", position: { x: 630, y: 224 }, size: { width: 96, height: 96 }, style: { fill: "amber" }, props: { kind: "glow" } },
             },
             animations: {
                 lecture: {
@@ -69,7 +69,7 @@ export const BOARD_EXAMPLES = {
         description: "Custom Canvas content; use --module to print scripts/wave.js.",
         value: {
             items: {
-                wave: { type: "custom", position: { x: 0, y: 0 }, size: { width: 640, height: 360 }, script: { src: "scripts/wave.js", params: { amplitude: 60 } } },
+                wave: { type: "custom", position: { x: 0, y: 0 }, size: { width: 480, height: 270 }, script: { src: "scripts/wave.js", params: { amplitude: 48 } } },
             },
         },
     },

package/dist/commands/boards.js

@@ -151,7 +151,7 @@ function registerExportCommand(boards) {
         .requiredOption("-o, --out <file>", "Output file; the extension picks the format. Sequences need %d, e.g. frames/%04d.png")
         .option("--at <time>", "A moment, comma-separated moments, or start:end:step")
         .option("--camera", "Follow the animation camera")
-        .option("--size <widthxheight>", "Camera viewport in pixels", "1600x900")
+        .option("--size <widthxheight>", "Camera output in pixels; frames keep their own size", "1600x900")
         .option("--animation <id>", "Animation the --at times refer to")
         .option("--frame <item-id>", "Export one frame as a page")
         .option("--items <ids>", "Comma-separated item ids")

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

@@ -10,7 +10,6 @@ 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";
@@ -19,16 +18,6 @@ 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) {
@@ -97,14 +86,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>", `${SYNCED_LABELS}; repeatable`, (value, previous) => [...previous, value], [])
+        .option("--harness <name>", `${LOCAL_HARNESSES.join(", ")}; 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 = options.harness.length ? parseSyncedHarnesses(options.harness) : config?.harnesses ?? SYNCED;
+            const paused = options.harness.length ? parseRuntimeHarnesses(options.harness) : config?.harnesses ?? [...LOCAL_HARNESSES];
             const harnesses = (config?.harnesses ?? []).filter((harness) => !paused.includes(harness));
             if (config)
                 await writeNativeConfig(stateRoot, { ...config, harnesses, codexShared: harnesses.includes("codex") && config.codexShared });
@@ -144,7 +133,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 ? parseSyncedHarnesses(options.harness) : [], ...(options.session ? { nativeSessionId: options.session } : {}) };
+            const filter = { harnesses: options.harness.length ? parseRuntimeHarnesses(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/runtime/harnesses/chained-transcript.d.ts

@@ -0,0 +1,24 @@
+import type { ContentBlock, LocalHarness } from "@neta-art/cohub";
+import type { JsonRecord } from "../json-rpc.js";
+import { type NativeTranscriptTurn, type TranscriptLine } from "../native/transcript.js";
+import type { SessionHeader } from "./types.js";
+/**
+ * `<data root>/projects/<project>/<session id>.jsonl`; sub-agent files live in deeper directories. A
+ * subdirectory's project name extends its parent's, so a prefix admits them; the header decides ownership.
+ */
+export declare function projectTranscript(path: string, root: string, project: string): boolean;
+export declare function projectDirectory(path: string, root: string, project: string): boolean;
+/** The session id is the file name; the first record carrying a `cwd` names the project. */
+export declare function chainedSessionHeader(path: string, harness: LocalHarness, signal?: AbortSignal): Promise<SessionHeader | null>;
+export declare function readChainedLines(path: string, signal?: AbortSignal): Promise<{
+    lines: TranscriptLine[];
+    prefixes: Map<number, string>;
+}>;
+/**
+ * The branch ending at the file's last linked record, oldest first. These formats only append, so a
+ * parent is the latest earlier record with that id: a rewound or repeated id never forms a cycle.
+ */
+export declare function chainBranch(lines: TranscriptLine[], id: (value: JsonRecord) => string, parent: (value: JsonRecord) => string): TranscriptLine[];
+export declare function startTurn(line: TranscriptLine, key: string, parentKey: string | null, userContent: ContentBlock[], cloudTurnId: string): NativeTranscriptTurn;
+/** Every branch record extends the Turn's bytes; only conversation records extend its content. */
+export declare function extendTurn(turn: NativeTranscriptTurn, line: TranscriptLine, content: boolean): void;

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

@@ -0,0 +1,62 @@
+import { createReadStream } from "node:fs";
+import { basename, dirname } from "node:path";
+import { iso, readFirstMatchingRecord, readTranscriptLines } from "../native/transcript.js";
+import { text } from "./process.js";
+/**
+ * `<data root>/projects/<project>/<session id>.jsonl`; sub-agent files live in deeper directories. A
+ * subdirectory's project name extends its parent's, so a prefix admits them; the header decides ownership.
+ */
+export function projectTranscript(path, root, project) {
+    return path.endsWith(".jsonl") && projectDirectory(dirname(path), root, project);
+}
+export function projectDirectory(path, root, project) {
+    return dirname(path) === root && basename(path).startsWith(project);
+}
+/** The session id is the file name; the first record carrying a `cwd` names the project. */
+export async function chainedSessionHeader(path, harness, signal) {
+    const value = await readFirstMatchingRecord(createReadStream(path, { signal }), (entry) => Boolean(text(entry.cwd)) && Boolean(text(entry.sessionId)));
+    return value ? { harness, nativeSessionId: basename(path, ".jsonl"), cwd: text(value.cwd), thread: "user" } : null;
+}
+export async function readChainedLines(path, signal) {
+    const read = await readTranscriptLines(createReadStream(path, { signal }));
+    if (!read.lines.length)
+        throw new Error("Native transcript is empty");
+    return read;
+}
+/**
+ * The branch ending at the file's last linked record, oldest first. These formats only append, so a
+ * parent is the latest earlier record with that id: a rewound or repeated id never forms a cycle.
+ */
+export function chainBranch(lines, id, parent) {
+    const latest = new Map();
+    const parents = [];
+    let leaf = -1;
+    lines.forEach((line, index) => {
+        const own = id(line.value);
+        parents[index] = -1;
+        if (!own)
+            return;
+        const before = latest.get(parent(line.value));
+        parents[index] = before ?? -1;
+        latest.set(own, index);
+        leaf = index;
+    });
+    const branch = [];
+    for (let index = leaf; index >= 0; index = parents[index] ?? -1)
+        branch.push(lines[index]);
+    return branch.reverse();
+}
+export function startTurn(line, key, parentKey, userContent, cloudTurnId) {
+    return {
+        key, parentKey, ...(cloudTurnId ? { cloudTurnId } : {}), userContent, messages: [], startedAt: iso(line.value.timestamp),
+        startBytes: line.startBytes, endBytes: line.endBytes, contentEndBytes: line.endBytes, boundaries: {}, sha256: line.sha256, result: null,
+    };
+}
+/** Every branch record extends the Turn's bytes; only conversation records extend its content. */
+export function extendTurn(turn, line, content) {
+    turn.endBytes = line.endBytes;
+    turn.sha256 = line.sha256;
+    turn.boundaries[line.endBytes] = line.sha256;
+    if (content)
+        turn.contentEndBytes = line.endBytes;
+}

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

@@ -0,0 +1,8 @@
+import { type NativeTranscript } from "../native/transcript.js";
+export declare const CLAUDE_REPLY_ENDED: string[];
+/**
+ * Claude Code appends one record per content block, linked by `parentUuid` (`logicalParentUuid`
+ * across a compaction). A Turn starts at a prompt; its tool results and an interruption share the
+ * prompt's `promptId`. Interactive sessions record each end (`turn_duration`), `-p` sessions do not.
+ */
+export declare function readClaudeTranscript(path: string, nativeSessionId: string, signal?: AbortSignal): Promise<NativeTranscript>;

package/dist/runtime/harnesses/claude-transcript.js

@@ -0,0 +1,138 @@
+import { record } from "../json-rpc.js";
+import { iso } from "../native/transcript.js";
+import { chainBranch, extendTurn, readChainedLines, startTurn } from "./chained-transcript.js";
+import { array, text } from "./process.js";
+import { streamContent, streamUsage } from "./stream-json.js";
+const COMMAND = /^<command-name>\s*([^<]*)<\/command-name>/;
+const COMMAND_ARGS = /<command-args>([\s\S]*?)<\/command-args>/;
+const BASH_INPUT = /^<bash-input>([\s\S]*?)<\/bash-input>/;
+/** Output of a local command or `!` shell, recorded as a user message but never sent as a prompt. */
+const LOCAL_OUTPUT = /^<(?:local-command-(?:stdout|stderr|caveat)|bash-(?:stdout|stderr))>/;
+const INTERRUPTED = "[Request interrupted by user";
+export const CLAUDE_REPLY_ENDED = ["end_turn", "stop_sequence", "max_tokens", "refusal", "aborted", "error"];
+const nonEmpty = (block) => !(block.type === "text" && !block.text) && !(block.type === "thinking" && !block.thinking);
+/** A local `/command` or `!shell` is shown as typed; one that never reached the model is no Turn. */
+function prompt(value) {
+    const content = typeof value === "string" ? [{ type: "text", text: value }] : streamContent(value).filter((block) => block.type === "text" || block.type === "image");
+    const first = content.find((block) => block.type === "text")?.text.trimStart() ?? "";
+    if (LOCAL_OUTPUT.test(first) || first.startsWith(INTERRUPTED))
+        return null;
+    const command = COMMAND.exec(first);
+    if (command)
+        return { content: [{ type: "text", text: `${command[1]?.trim() ?? ""} ${COMMAND_ARGS.exec(first)?.[1]?.trim() ?? ""}`.trim() }], local: true };
+    const bash = BASH_INPUT.exec(first);
+    if (bash)
+        return { content: [{ type: "text", text: `!${bash[1] ?? ""}` }], local: true };
+    const visible = content.filter(nonEmpty);
+    return visible.length ? { content: visible, local: false } : null;
+}
+/**
+ * Claude Code appends one record per content block, linked by `parentUuid` (`logicalParentUuid`
+ * across a compaction). A Turn starts at a prompt; its tool results and an interruption share the
+ * prompt's `promptId`. Interactive sessions record each end (`turn_duration`), `-p` sessions do not.
+ */
+export async function readClaudeTranscript(path, nativeSessionId, signal) {
+    const read = await readChainedLines(path, signal);
+    const branch = chainBranch(read.lines, (value) => value.isSidechain === true ? "" : text(value.uuid), (value) => text(value.parentUuid) || text(value.logicalParentUuid));
+    const turns = [];
+    const owners = new Map();
+    const messageIds = new Map();
+    let cwd = "", cloudSessionId = "";
+    let current = null;
+    let promptId = "", local = false, interrupted = false, completedAt = "";
+    const finish = () => {
+        if (!current)
+            return;
+        // A local command that never reached the model is not a conversation Turn.
+        if (local && !current.messages.length) {
+            current = null;
+            return;
+        }
+        const last = current.messages.at(-1);
+        const status = interrupted || !last || last.stopReason === "tool_use" ? "interrupted" : last.stopReason === "error" ? "failed" : "completed";
+        current.result = { messages: current.messages, completedAt: completedAt || current.startedAt, status };
+        turns.push(current);
+        current = null;
+    };
+    for (const line of branch) {
+        const value = line.value;
+        cwd ||= text(value.cwd);
+        if (value.type === "user") {
+            const message = record(value.message);
+            const results = array(message.content).map(record).filter((block) => block.type === "tool_result");
+            const opened = value.isMeta === true || value.isCompactSummary === true || results.length ? null : prompt(message.content);
+            if (opened && !(current && text(value.promptId) && text(value.promptId) === promptId)) {
+                finish();
+                const cohub = record(value.cohub);
+                cloudSessionId ||= text(cohub.sessionId);
+                // Cohub sends its Turn id as the prompt's record id; a projected record names its Turn.
+                current = startTurn(line, text(value.uuid), turns.at(-1)?.key ?? null, opened.content, text(cohub.turnId) || text(value.uuid));
+                promptId = text(value.promptId);
+                local = opened.local;
+                interrupted = false;
+                completedAt = current.startedAt;
+                owners.clear();
+                messageIds.clear();
+                continue;
+            }
+            if (!current)
+                continue;
+            for (const block of results) {
+                const id = text(block.tool_use_id);
+                const owner = owners.get(id);
+                if (!owner)
+                    continue;
+                owner.content.push({ type: "tool_result", tool_use_id: id, content: typeof block.content === "string" ? block.content : streamContent(block.content), is_error: block.is_error === true });
+            }
+            if (array(message.content).some((block) => text(record(block).text).startsWith(INTERRUPTED)) || text(message.content).startsWith(INTERRUPTED)) {
+                interrupted = true;
+                current.ended = true;
+            }
+            completedAt = iso(value.timestamp);
+            extendTurn(current, line, true);
+            continue;
+        }
+        if (!current)
+            continue;
+        if (value.type === "assistant") {
+            const native = record(value.message);
+            const id = text(native.id);
+            let target = current.messages.at(-1);
+            if (!target || !id || messageIds.get(target) !== id) {
+                target = { content: [], provider: null, model: null, stopReason: null, errorMessage: null };
+                current.messages.push(target);
+                messageIds.set(target, id);
+            }
+            const content = streamContent(native.content).filter(nonEmpty);
+            for (const block of content) {
+                const index = block.type === "tool_use" ? target.content.findIndex((existing) => existing.type === "tool_use" && existing.id === block.id) : -1;
+                if (index >= 0)
+                    target.content[index] = block;
+                else
+                    target.content.push(block);
+                if (block.type === "tool_use")
+                    owners.set(block.id, target);
+            }
+            const model = text(native.model);
+            if (model && model !== "<synthetic>")
+                target.model = model;
+            if (text(native.stop_reason))
+                target.stopReason = text(native.stop_reason);
+            const usage = streamUsage(native.usage, undefined);
+            if (usage)
+                target.usage = usage;
+            if (value.isApiErrorMessage === true) {
+                target.stopReason = "error";
+                target.errorMessage = content.flatMap((block) => block.type === "text" ? [block.text] : []).join("\n") || "API error";
+            }
+            completedAt = iso(value.timestamp);
+            extendTurn(current, line, true);
+            continue;
+        }
+        if (value.type === "system" && value.subtype === "turn_duration")
+            current.ended = true;
+        extendTurn(current, line, false);
+    }
+    finish();
+    return { nativeSessionId, cwd, ...(cloudSessionId ? { cloudSessionId } : {}), turns, prefixes: read.prefixes };
+}

package/dist/runtime/harnesses/claude.js

@@ -1,9 +1,15 @@
+import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { basename, 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 { chainedSessionHeader, projectDirectory, projectTranscript } from "./chained-transcript.js";
+import { CLAUDE_REPLY_ENDED, readClaudeTranscript } from "./claude-transcript.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
@@ -19,6 +25,9 @@ export function claudeProjectName(cwd) {
     return `${name.slice(0, MAX_PROJECT_NAME)}-${Math.abs(hash).toString(36)}`;
 }
 export const claudeProjectDirectory = (cwd) => join(dataRoot(), "projects", claudeProjectName(cwd));
+const projectsRoot = () => join(dataRoot(), "projects");
+/** Every subdirectory's project name starts with this; a hashed long name keeps its first 200 units. */
+const projectPrefix = (cwd) => cwd.replace(/[^a-zA-Z0-9]/g, "-").slice(0, MAX_PROJECT_NAME);
 const profile = {
     harness: "claude",
     label: "Claude Code",
@@ -27,6 +36,7 @@ const profile = {
     dataRoot,
     projectDirectory: claudeProjectDirectory,
     effortLevels: ["low", "medium", "high", "xhigh", "max"],
+    promptUuid: true,
 };
 function anthropicBlock(block) {
     if (block.type === "text")
@@ -47,11 +57,66 @@ function withAssistantIds(projection) {
             ...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 }),
@@ -90,5 +155,17 @@ export const claudeHarness = {
             },
         },
     },
-    nativeSync: false,
+    transcript: {
+        roots: () => [projectsRoot()],
+        acceptsDirectory: (path, root, cwd) => projectDirectory(path, root, projectPrefix(cwd)),
+        acceptsTranscript: (path, cwd) => projectTranscript(path, projectsRoot(), projectPrefix(cwd)),
+        header: (path, signal) => chainedSessionHeader(path, "claude", signal),
+        read: (path, signal) => readClaudeTranscript(path, basename(path, ".jsonl"), signal),
+        boundaries: ['"promptSource"', '"subtype":"turn_duration"', '"interruptedMessageId"', '"isApiErrorMessage":true', ...CLAUDE_REPLY_ENDED.map((reason) => `"stop_reason":"${reason}"`)],
+        turnEndRecorded: false,
+        replyEnded: (turn) => CLAUDE_REPLY_ENDED.includes(turn.messages.at(-1)?.stopReason ?? ""),
+        userFinalMarked: false,
+        globalTurnKeys: false,
+        marksCohubTurns: true,
+    },
 };

package/dist/runtime/harnesses/codex.js

@@ -223,7 +223,7 @@ export const codexHarness = {
         turnEndRecorded: true,
         userFinalMarked: true,
         globalTurnKeys: true,
+        marksCohubTurns: true,
         archiveSource: (path, cacheDirectory) => ensurePlainCodexRollout(path, cacheDirectory),
     },
-    nativeSync: true,
 };

package/dist/runtime/harnesses/cursor-transcript.d.ts

@@ -0,0 +1,37 @@
+import type { NativeTranscript } from "../native/transcript.js";
+import type { SessionHeader } from "./types.js";
+/** Chats (`store.db` and `meta.json`) live under the config directory, transcripts under the data directory. */
+export declare const cursorConfigDirectory: () => string;
+export declare const cursorProjectsRoot: () => string;
+export declare const cursorChatsRoot: () => string;
+/** Cursor's project name for a workspace path. */
+export declare const cursorProjectName: (cwd: string) => string;
+export declare const cursorTranscriptPath: (nativeSessionId: string, cwd: string) => string;
+/** A chat's store directory is keyed by the MD5 of the directory the CLI ran in. */
+export declare const cursorChatDirectory: (nativeSessionId: string, cwd: string) => string;
+export declare function acceptsCursorDirectory(path: string, root: string, cwd: string): boolean;
+export declare function acceptsCursorTranscript(path: string, cwd: string): boolean;
+/**
+ * The directory a project name stands for, matched against real directories. On Windows the name
+ * starts with the drive letter and matching ignores case. Several directories with the same name
+ * (`a/b` and `a-b`) cannot be told apart, so none is chosen.
+ */
+type Entry = {
+    name: string;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+};
+export declare function projectDirectory(name: string, platform?: NodeJS.Platform, list?: (directory: string) => Promise<Entry[]>): Promise<string | null>;
+/**
+ * The transcript does not name its project. A CLI chat's `meta.json` does; the IDE writes the same
+ * transcripts without one, so its project name is resolved to the directory it stands for.
+ */
+export declare function cursorSessionHeader(path: string): Promise<SessionHeader | null>;
+/**
+ * Cursor writes the model's messages without ids or times: a prompt (`<user_query>`, or a bare text
+ * that no other user line follows), one line per reply step with its tool calls (results are not
+ * recorded), and `turn_ended` after every Turn. A user line followed by another is context. A Turn
+ * is keyed by the file's checksum through its prompt, so a rewritten history never reuses a key.
+ */
+export declare function readCursorTranscript(path: string, nativeSessionId: string, signal?: AbortSignal): Promise<NativeTranscript>;
+export {};