@neta-art/cohub-cli 10.4.4 → 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
@@ -282,6 +284,20 @@ cohub -s <spaceId> spaces activity 7
 cohub -s <spaceId> spaces activity 365 --json
 ```
 
+## Space wallet
+
+```bash
+cohub -s <spaceId> spaces wallet balance
+cohub -s <spaceId> spaces wallet catalog
+cohub -s <spaceId> spaces wallet recharge <productKey> --request-id <uuid>
+cohub -s <spaceId> spaces wallet confirm <orderId>
+cohub -s <spaceId> spaces wallet activity --page 1 --json
+```
+
+Recharge prints a payment URL. Reuse the request UUID when retrying the same
+recharge. Any signed-in user with access to the Space may contribute; payment
+does not grant additional permissions. Transfers and withdrawals are not supported.
+
 ## Boards
 
 A Board is one JSON document with three parts — `board` settings, an `items` map,

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/space-wallet.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerSpaceWallet(spaces: Command): void;

package/dist/commands/space-wallet.js

@@ -0,0 +1,64 @@
+import { createClient } from "../client.js";
+import { handleHttp, json as outJson, jsonRequested, table } from "../output.js";
+import { resolveSpace } from "../space.js";
+export function registerSpaceWallet(spaces) {
+    const wallet = spaces.command("wallet").description("Space wallet balance, recharge, and activity");
+    wallet.command("balance").option("--json", "Output as JSON").action(async (opts) => {
+        try {
+            const value = await createClient().space(await resolveSpace(spaces)).wallet.get();
+            if (jsonRequested(opts))
+                return outJson(value);
+            table([{ balance: `$${value.balanceUsd.toFixed(8)}`, usable: value.usable }], [{ key: "balance", label: "Balance" }, { key: "usable", label: "Usable" }]);
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    wallet.command("catalog").option("--json", "Output as JSON").action(async (opts) => {
+        try {
+            const value = await createClient().space(await resolveSpace(spaces)).wallet.catalog();
+            if (jsonRequested(opts))
+                return outJson(value);
+            table(value.products.map((product) => ({ key: product.key, name: product.name, price: product.pricing.amountUsd })), [{ key: "key", label: "Product" }, { key: "name", label: "Name" }, { key: "price", label: "Price (USD)" }]);
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    wallet.command("activity").option("--page <page>", "Page number", "1").option("--json", "Output as JSON").action(async (opts) => {
+        try {
+            const page = Number(opts.page);
+            if (!Number.isInteger(page) || page < 1 || page > 10_000)
+                throw new Error("Page must be an integer between 1 and 10000");
+            const value = await createClient().space(await resolveSpace(spaces)).wallet.activities(page);
+            if (jsonRequested(opts))
+                return outJson(value);
+            table(value.items, [{ key: "kind", label: "Activity" }, { key: "amountUsd", label: "Amount (USD)" }, { key: "actorUserId", label: "User" }, { key: "createdAt", label: "Date" }]);
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    wallet.command("recharge <product>").requiredOption("--request-id <uuid>", "Stable UUID; reuse when retrying this recharge").option("--json", "Output as JSON").action(async (productKey, opts) => {
+        try {
+            const value = await createClient().space(await resolveSpace(spaces)).wallet.createOrder({ id: opts.requestId, productKey });
+            if (jsonRequested(opts))
+                return outJson(value);
+            if (!value.checkout.checkoutUsable || !value.checkout.checkoutUrl)
+                throw new Error(value.checkout.message ?? "Checkout is unavailable");
+            console.log(value.checkout.checkoutUrl);
+            console.log(`Order: ${value.orderId}`);
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    wallet.command("confirm <order>").action(async (orderId) => {
+        try {
+            outJson(await createClient().space(await resolveSpace(spaces)).wallet.confirmOrder(orderId));
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+}

package/dist/commands/spaces.d.ts

@@ -1,10 +1,12 @@
 import type { CohubHttpClient, CreateSpaceInput } from "@neta-art/cohub";
 import type { Command } from "commander";
+import { createClient } from "../client.js";
 import { type LocalUploadEntry } from "../space-files/upload.js";
 export type SpaceCreateOptions = {
     name: string;
     description?: string;
     checkpoint?: string;
+    image?: string;
     autoDestroy?: string;
     idleTtl?: string;
     spec?: string;
@@ -17,4 +19,7 @@ export declare function registerPrompt(program: Command): void;
 export declare function registerSpaceCreate(spacesCmd: Command, dependencies?: {
     createClient?: () => CohubHttpClient;
 }): Command;
+export declare function registerSpaceSetup(spacesCmd: Command, deps?: {
+    createClient?: typeof createClient;
+}): void;
 export declare function registerSpaces(program: Command): void;

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";
@@ -11,6 +11,7 @@ import { uploadLocalFiles } from "../space-files/upload.js";
 import { registerDecisionCommand } from "./decision.js";
 import { registerSpaceCommerce } from "./space-commerce.js";
 import { registerSpaceFileTransfer } from "./space-files.js";
+import { registerSpaceWallet } from "./space-wallet.js";
 import { registerSpaceActivity } from "./space-activity.js";
 import { registerSpaceDisplays } from "./space-displays.js";
 import { registerSpaceInvitations } from "./space-invitations.js";
@@ -75,6 +76,7 @@ const parseSandboxSpec = (value) => value ? parseChoice(value, "sandbox spec", S
 export function buildSpaceCreateInput(opts) {
     const autoDestroy = parseAutoDestroy(opts);
     const spec = parseSandboxSpec(opts.spec);
+    const image = opts.image ? parseChoice(opts.image, "sandbox image", ["default", "game"]) : undefined;
     const checkpointId = opts.checkpoint?.trim();
     if (opts.checkpoint !== undefined && !checkpointId) {
         return error("Invalid checkpoint", "Checkpoint ID is required");
@@ -85,12 +87,13 @@ export function buildSpaceCreateInput(opts) {
         ...(checkpointId
             ? { bootstrapSource: { type: "checkpoint", checkpointId } }
             : {}),
-        ...((autoDestroy || spec)
+        ...((autoDestroy || spec || image)
             ? {
                 config: {
                     sandbox: {
                         ...(autoDestroy ? { autoDestroy } : {}),
                         ...(spec ? { spec } : {}),
+                        ...(image ? { image } : {}),
                     },
                 },
             }
@@ -341,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")
@@ -376,6 +379,7 @@ export function registerSpaceCreate(spacesCmd, dependencies = {}) {
         .requiredOption("-n, --name <name>", "Space name")
         .option("-d, --description <desc>", "Space description")
         .option("--checkpoint <id>", "Create from a checkpoint")
+        .option("--image <image>", "Sandbox image: default or game")
         .option("--auto-destroy <mode>", "Sandbox auto destroy mode: idle or never")
         .option("--idle-ttl <seconds>", "Idle auto destroy TTL in seconds, max 2592000 (30d)")
         .option("--spec <spec>", "Sandbox spec: standard, boost, or ultra")
@@ -454,6 +458,40 @@ function registerUserLabels(program) {
         }
     });
 }
+export function registerSpaceSetup(spacesCmd, deps = {}) {
+    spacesCmd
+        .command("setup [id]")
+        .description("Show cloud sandbox startup scripts, results, and log paths")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        try {
+            const spaceId = id ?? await resolveSpace(spacesCmd);
+            const { sandbox } = await (deps.createClient ?? createClient)().space(spaceId).sandbox.get();
+            const setup = sandbox?.meta?.setup ?? null;
+            if (jsonRequested(opts))
+                return outJson({ provider: sandbox?.provider ?? null, setup });
+            if (sandbox?.provider === "local")
+                return ok("Setup is disabled for local spaces.");
+            if (!setup)
+                return ok("No setup report is available.");
+            table([
+                { key: "Status", value: setup.status ?? (setup.error || setup.exitCode ? "failed" : "succeeded") },
+                { key: "Duration", value: setup.duration || "—" },
+                ...(setup.error ? [{ key: "Error", value: setup.error }] : []),
+            ], [{ key: "key", label: "Key" }, { key: "value", label: "Value" }]);
+            if (setup.steps?.length)
+                table(setup.steps.map((step) => ({
+                    script: step.path, status: step.status, duration: step.duration || "—", logs: step.logDir,
+                })), [
+                    { key: "script", label: "Script" }, { key: "status", label: "Status" },
+                    { key: "duration", label: "Duration" }, { key: "logs", label: "Logs" },
+                ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}
 export function registerSpaces(program) {
     const spacesCmd = program.command("spaces").description("Space management");
     registerSpaceInvitations(spacesCmd);
@@ -615,21 +653,24 @@ export function registerSpaces(program) {
             handleHttp(e);
         }
     });
+    registerSpaceSetup(spacesCmd);
     // ── spaces config ──
     spacesCmd
         .command("config <id>")
         .description("Show or update space configuration")
         .option("--auto-destroy <mode>", "Sandbox auto destroy mode: idle or never")
         .option("--idle-ttl <seconds>", "Idle auto destroy TTL in seconds, max 2592000 (30d)")
-        .option("--spec <spec>", "Sandbox spec: standard, boost, or ultra")
+        .option("--spec <spec>", "Sandbox spec: standard, boost, ultra, or auto")
+        .option("--image <image>", "Sandbox image: default, game, or auto")
         .option("--json", "Output as JSON")
         .action(async (id, opts) => {
         const client = createClient();
         try {
             const autoDestroy = parseAutoDestroy(opts);
-            const spec = parseSandboxSpec(opts.spec);
-            if (autoDestroy || spec) {
-                const result = await client.space(id).updateConfig({ sandbox: { ...(autoDestroy ? { autoDestroy } : {}), ...(spec ? { spec } : {}) } });
+            const spec = opts.spec === "auto" ? null : parseSandboxSpec(opts.spec);
+            const image = opts.image === "auto" ? null : opts.image ? parseChoice(opts.image, "sandbox image", ["default", "game"]) : undefined;
+            if (autoDestroy || spec !== undefined || image !== undefined) {
+                const result = await client.space(id).updateConfig({ sandbox: { ...(autoDestroy ? { autoDestroy } : {}), ...(spec !== undefined ? { spec } : {}), ...(image !== undefined ? { image } : {}) } });
                 if (jsonRequested(opts))
                     return outJson(result);
                 ok(`Space config updated${autoDestroy ? ` — sandbox auto destroy: ${formatAutoDestroy(autoDestroy)}` : ""}${spec ? ` — sandbox spec: ${spec}` : ""}${result.sandbox?.pendingRestart ? " — restart the sandbox to apply" : ""}`);
@@ -640,6 +681,11 @@ export function registerSpaces(program) {
                 return outJson(result);
             table([
                 { key: "sandbox.autoDestroy", value: formatAutoDestroy(result.config.sandbox.autoDestroy) },
+                { key: "sandbox.image", value: result.config.sandbox.image ?? "default" },
+                { key: "sandbox.imageSource", value: result.config.sandbox.preferences?.origins.image ?? "platform" },
+                { key: "sandbox.specSource", value: result.config.sandbox.preferences?.origins.spec ?? "platform" },
+                { key: "sandbox.warnings", value: result.config.sandbox.preferences?.warnings.join(", ") || "—" },
+                { key: "sandbox.pendingRestart", value: String(result.config.sandbox.preferences?.pendingRestart ?? false) },
                 { key: "sandbox.spec", value: result.config.sandbox.spec ?? "standard" },
                 { key: "sandbox.appliedSpec", value: result.config.sandbox.appliedSpec ?? "—" },
                 { key: "sandbox.allowedSpec", value: result.config.sandbox.allowedSpec ?? "standard" },
@@ -657,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")
@@ -737,6 +783,7 @@ export function registerSpaces(program) {
     // ── spaces commerce ──
     registerSpaceCommerce(spacesCmd);
     // ── spaces activity ──
+    registerSpaceWallet(spacesCmd);
     registerSpaceActivity(spacesCmd);
     // ── spaces usage ──
     spacesCmd

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;