@neta-art/cohub-cli 8.1.1 → 8.3.0

package/dist/commands/runtime.d.ts

@@ -1,15 +1,3 @@
 import type { Command } from "commander";
-import { type NativeIpcResponse } from "../runtime/native-ipc.js";
 export { resolveLocalSpaceName, parseRuntimeHarnesses } from "../runtime/launch.js";
-export declare function applyNativeImportResponse(result: {
-    imported: number;
-    failed: Array<{
-        path: string;
-        message: string;
-    }>;
-    skipped: Array<{
-        path: string;
-        message: string;
-    }>;
-}, path: string, response: NativeIpcResponse): void;
 export declare function registerRuntime(program: Command): void;

package/dist/commands/runtime.js

@@ -4,28 +4,31 @@ import { json as outJson, jsonRequested } from "../output.js";
 import { currentIdentityKey } from "../space.js";
 import { resolveRuntimeTarget, runtimeUp, parseRuntimeHarnesses } from "../runtime/launch.js";
 import { canonicalRuntimeRoot, getRuntimeSpaceBinding } from "../runtime/space-binding.js";
-import { installNativeSync } from "../runtime/native-install.js";
-import { discoverNativeImportCandidates, nativeRuntimeRoot, readNativeSyncConfig } from "../runtime/native-sync.js";
-import { listNativeSyncStores } from "../runtime/native-sync-store.js";
-import { requestNativeDaemon } from "../runtime/native-ipc.js";
-import { requestRuntimeInstance, runtimeInstanceDirectory } from "../runtime/instance.js";
-import { atLeastLevel, diagnosticLevels, formatDiagnostic, formatNativeSync, printRuntimeSummary } from "../runtime/presentation.js";
-import { RuntimeSessionStore } from "../runtime/session-store.js";
+import { join } from "node:path";
+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 { 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";
 export { resolveLocalSpaceName, parseRuntimeHarnesses } from "../runtime/launch.js";
 const reportFailure = (cause) => {
     process.stderr.write(`Runtime failed: ${serializeDiagnosticError(cause).message}\n`);
     process.exitCode = 1;
 };
-export function applyNativeImportResponse(result, path, response) {
-    if (!response.ok) {
-        if (response.skipped) {
-            result.skipped.push({ path, message: response.message });
-            return;
-        }
-        throw new Error(response.message);
-    }
-    result.imported += 1;
+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) {
+    const identity = currentIdentityKey();
+    if (!identity)
+        throw new Error("Sign in first");
+    const root = await canonicalRuntimeRoot(dir ?? process.cwd());
+    const spaceId = await resolveRuntimeTarget(program, space);
+    const binding = await getRuntimeSpaceBinding(root, identity);
+    if (!binding || binding.spaceId !== spaceId)
+        throw new Error("Bind this directory with runtime up first");
+    return { identity, root, spaceId, directory: runtimeInstanceDirectory(identity, spaceId) };
 }
 export function registerRuntime(program) {
     const runtime = program.command("runtime").description("Connect a local workspace");
@@ -49,37 +52,68 @@ export function registerRuntime(program) {
             reportFailure(cause);
         }
     });
-    runtime.command("detach")
-        .description("Pause native sync; retain all receipts")
+    runtime.command("attach")
+        .description("Connect native harnesses to Cohub: install the Pi extension")
         .option("-s, --space <id>", "Target Space")
-        .option("--harness <name>", "Pi or Codex; repeatable", (value, previous) => [...previous, value], [])
+        .option("--harness <name>", "Pi; repeatable", (value, previous) => [...previous, value], [])
         .option("--json", "JSON output")
         .action(async (options) => {
         try {
-            const spaceId = await resolveRuntimeTarget(program, options.space);
+            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");
+            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");
+            await installPiExtension();
+            const spaceId = await resolveRuntimeTarget(program, options.space).catch(() => null);
             const identity = currentIdentityKey();
-            if (!identity)
-                throw new Error("Sign in first");
-            const root = await canonicalRuntimeRoot(process.cwd());
-            if ((await getRuntimeSpaceBinding(root, identity))?.spaceId !== spaceId)
-                throw new Error("Bind this directory with runtime up first");
-            const instance = await requestRuntimeInstance(runtimeInstanceDirectory(identity, spaceId));
-            const harnesses = parseRuntimeHarnesses(options.harness.length ? options.harness : instance?.harnesses ?? ["pi", "codex"]);
-            const result = await installNativeSync({ root, spaceId, identity, harnesses, disabled: true });
+            if (spaceId && identity)
+                await controlRuntimeInstance(runtimeInstanceDirectory(identity, spaceId), "reload").catch(() => undefined);
             if (jsonRequested(options))
-                outJson({ ...result, enabled: false });
+                outJson({ harness: "pi", extension: "installed", updated: before !== "installed" });
             else
-                process.stdout.write("Native sync paused; all local records retained\n");
+                process.stdout.write(before === "installed" ? "Pi extension is up to date\n" : "Pi extension installed. Run /reload in open Pi sessions to connect them\n");
+        }
+        catch (cause) {
+            reportFailure(cause);
+        }
+    });
+    runtime.command("detach")
+        .description("Pause native sync; keep all data")
+        .option("-s, --space <id>", "Target Space")
+        .option("--harness <name>", "Pi or Codex; 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 harnesses = (config?.harnesses ?? []).filter((harness) => !paused.includes(harness));
+            if (config)
+                await writeNativeConfig(stateRoot, { ...config, harnesses, codexShared: harnesses.includes("codex") && config.codexShared });
+            await controlRuntimeInstance(directory, "reload").catch(() => undefined);
+            const codexWasShared = Boolean(config?.codexShared) && paused.includes("codex");
+            if (jsonRequested(options))
+                outJson({ spaceId, harnesses, paused, enabled: harnesses.length > 0 });
+            else {
+                process.stdout.write(harnesses.length ? `Native sync paused for ${paused.join(", ")}; still syncing ${harnesses.join(", ")}\n` : "Native sync paused; all data retained\n");
+                // Cohub never stops a server that terminal clients may be attached to.
+                if (codexWasShared)
+                    process.stdout.write("Codex's shared app-server keeps running; stop it with codex app-server daemon stop\n");
+            }
         }
         catch (cause) {
             reportFailure(cause);
         }
     });
     runtime.command("import [dir]")
-        .description("Import local conversations")
+        .description("Import earlier local conversations, newest first")
         .option("-s, --space <id>", "Target Space")
         .option("--harness <name>", "Filter by harness; repeatable", (value, previous) => [...previous, value], [])
         .option("--session <id>", "Filter by native session ID")
+        .option("--concurrency <count>", `Conversations read in parallel, 1 to ${MAX_IMPORT_CONCURRENCY}`, String(DEFAULT_IMPORT_CONCURRENCY))
         .option("--dry-run", "Preview without importing")
         .option("-y, --yes", "Skip confirmation")
         .option("--json", "Output as JSON")
@@ -88,66 +122,34 @@ export function registerRuntime(program) {
         const stop = () => controller.abort();
         process.once("SIGINT", stop);
         process.once("SIGTERM", stop);
+        const asJson = jsonRequested(options);
         try {
-            const identity = currentIdentityKey();
-            if (!identity)
-                throw new Error("Sign in first");
-            const root = await canonicalRuntimeRoot(dir ?? process.cwd());
-            const spaceId = await resolveRuntimeTarget(program, options.space);
-            const binding = await getRuntimeSpaceBinding(root, identity);
-            if (!binding || binding.spaceId !== spaceId)
-                throw new Error("Bind this directory with runtime up first");
-            const local = await requestRuntimeInstance(runtimeInstanceDirectory(identity, spaceId));
-            if (!local)
-                throw new Error("Local Runtime is not running");
-            const config = await readNativeSyncConfig(nativeRuntimeRoot(spaceId), identity);
-            if (!config || config.root !== root)
-                throw new Error("Native sync is not enabled for this directory");
-            const harnesses = parseRuntimeHarnesses(options.harness.length ? options.harness : config.harnesses);
-            let lastProgress = 0;
-            const discovered = await discoverNativeImportCandidates(root, harnesses, {
-                signal: controller.signal,
-                onProgress: ({ harness, scanned, candidates: found }) => {
-                    if (jsonRequested(options) || scanned - lastProgress < 25)
-                        return;
-                    lastProgress = scanned;
-                    process.stderr.write(`Scanned ${scanned} ${harness} transcript${scanned === 1 ? "" : "s"}; found ${found}\n`);
-                },
-            });
-            const candidates = discovered.candidates.filter((candidate) => !options.session || candidate.nativeSessionId === options.session);
-            const result = {
-                spaceId, root, harnesses, candidates, errors: discovered.errors,
-                imported: 0, failed: [], skipped: [], dryRun: Boolean(options.dryRun),
-                complete: discovered.errors.length === 0,
+            const concurrency = Number(options.concurrency);
+            if (!Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > MAX_IMPORT_CONCURRENCY)
+                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 control = async (command, timeoutMs = 60_000) => {
+                const response = await controlRuntimeInstance(directory, "import", { ...filter, command, concurrency }, timeoutMs);
+                if (!response)
+                    throw new Error("Local Runtime is not running; start it with cohub runtime up");
+                return response.result;
             };
-            if (jsonRequested(options) && options.dryRun) {
-                result.complete = result.complete && result.failed.length === 0;
-                outJson(result);
-                if (!result.complete)
-                    process.exitCode = 1;
-                return;
-            }
-            if (!candidates.length) {
-                if (!result.complete)
-                    process.exitCode = 1;
-                if (jsonRequested(options))
-                    outJson(result);
-                else
-                    process.stdout.write("No existing native conversations found\n");
-                return;
-            }
-            if (options.dryRun) {
-                if (jsonRequested(options))
-                    outJson(result);
+            const plan = await control("plan");
+            const summary = { spaceId, root, ...plan, dryRun: Boolean(options.dryRun) };
+            if (options.dryRun || !plan.files) {
+                if (asJson)
+                    outJson(summary);
+                else if (!plan.files)
+                    process.stdout.write("No earlier conversations left to import\n");
                 else {
-                    process.stdout.write(`Found ${candidates.length} native conversation${candidates.length === 1 ? "" : "s"}\n`);
-                    for (const candidate of candidates)
-                        process.stdout.write(`  ${candidate.harness} ${candidate.nativeSessionId} ${candidate.turnCount} Turn${candidate.turnCount === 1 ? "" : "s"} ${candidate.path}\n`);
-                    for (const error of discovered.errors)
-                        process.stdout.write(`Skipped ${error.path}: ${error.message}\n`);
+                    process.stdout.write(`Found ${plan.files} conversation${plan.files === 1 ? "" : "s"} · ${megabytes(plan.bytes)}\n`);
+                    for (const item of plan.sample)
+                        process.stdout.write(`  ${item.harness.padEnd(5)} ${new Date(item.mtimeMs).toISOString().slice(0, 16).replace("T", " ")}  ${item.nativeSessionId ?? ""}  ${item.path}\n`);
+                    if (plan.files > plan.sample.length)
+                        process.stdout.write(`  … and ${plan.files - plan.sample.length} more\n`);
                 }
-                if (!result.complete)
-                    process.exitCode = 1;
                 return;
             }
             if (!options.yes) {
@@ -156,10 +158,10 @@ export function registerRuntime(program) {
                 const { createInterface } = await import("node:readline/promises");
                 const rl = createInterface({ input: process.stdin, output: process.stderr });
                 try {
-                    const answer = await rl.question(`Import ${candidates.length} native conversation${candidates.length === 1 ? "" : "s"} to Space ${spaceId}? [Y/n] `);
+                    const answer = await rl.question(`Import ${plan.files} conversation${plan.files === 1 ? "" : "s"} (${megabytes(plan.bytes)}) to Space ${spaceId}? [Y/n] `);
                     if (!/^(|y(es)?)$/i.test(answer.trim())) {
-                        if (jsonRequested(options))
-                            outJson({ ...result, cancelled: true });
+                        if (asJson)
+                            outJson({ ...summary, cancelled: true });
                         else
                             process.stdout.write("Import cancelled\n");
                         return;
@@ -169,26 +171,31 @@ export function registerRuntime(program) {
                     rl.close();
                 }
             }
-            for (const candidate of candidates) {
-                try {
-                    const response = await requestNativeDaemon({ harness: candidate.harness, cwd: root, path: candidate.path, nativeSessionId: candidate.nativeSessionId,
-                        sessionStartedAt: candidate.sessionStartedAt, origin: "local_import", settled: true });
-                    applyNativeImportResponse(result, candidate.path, response);
-                }
-                catch (error) {
-                    result.failed.push({ path: candidate.path, message: error instanceof Error ? error.message : String(error) });
-                }
+            let job = await control("start");
+            while (!controller.signal.aborted && job.state === "running") {
+                if (!asJson && process.stderr.isTTY)
+                    process.stderr.write(`\r\x1b[2KImporting ${formatImportProgress(job)}`);
+                await delay(500, undefined, { signal: controller.signal }).catch(() => undefined);
+                const status = await requestRuntimeInstance(directory);
+                if (!status?.native)
+                    throw new Error("Local Runtime stopped; the import resumes when it starts again");
+                job = status.native.import;
             }
-            result.complete = result.complete && result.failed.length === 0;
-            if (jsonRequested(options))
-                outJson(result);
+            if (controller.signal.aborted)
+                job = await control("pause", 5_000);
+            const paused = job.state === "paused";
+            if (asJson)
+                outJson({ ...summary, ...job, paused });
             else {
-                process.stdout.write(`Imported ${result.imported}/${candidates.length} native conversation${candidates.length === 1 ? "" : "s"}\n`);
-                for (const error of [...discovered.errors, ...result.skipped, ...result.failed])
-                    process.stdout.write(`Skipped ${error.path}: ${error.message}\n`);
-                process.stdout.write("Uploads continue in the local Runtime background\n");
+                if (process.stderr.isTTY)
+                    process.stderr.write("\r\x1b[2K");
+                process.stdout.write(`${paused ? "Paused" : "Imported"} ${formatImportProgress(job)}\n`);
+                for (const failure of job.failed)
+                    process.stdout.write(`Skipped ${failure.path}: ${failure.message}\n`);
+                if (paused)
+                    process.stdout.write("Run cohub runtime import again to continue\n");
             }
-            if (!result.complete)
+            if (job.failed.length)
                 process.exitCode = 1;
         }
         catch (cause) {
@@ -208,16 +215,15 @@ export function registerRuntime(program) {
             const identity = currentIdentityKey();
             const local = identity ? await requestRuntimeInstance(runtimeInstanceDirectory(identity, spaceId)) : null;
             const space = createClient().space(spaceId);
-            const store = new RuntimeSessionStore(spaceId, { projectionSource: space, archiveTransport: null });
-            const [remote, pendingLocalArchives, failedLocalArchives, nativeStores] = await Promise.all([
+            const stateRoot = runtimeStateRoot(spaceId);
+            const archives = new RuntimeArchiveStore(join(stateRoot, "archives"));
+            const [remote, pendingLocalArchives, failedLocalArchives] = await Promise.all([
                 space.getRuntime(undefined, { signal: AbortSignal.timeout(5000) }).then((value) => ({ value, error: null })).catch((error) => ({ value: null, error: serializeDiagnosticError(error).message })),
-                store.archives.pendingCount(), store.archives.failedCaptureCount(),
-                identity ? listNativeSyncStores(store.root, spaceId, identity) : [],
+                archives.pendingCount(), archives.failedCaptureCount(),
             ]);
-            const nativeSessions = await Promise.all(nativeStores.map((native) => native.status()));
             // A corrupt native sync config must never take down the whole status report.
-            const nativeSync = identity ? await readNativeSyncConfig(store.root, identity).then((config) => ({ config, error: null }), (error) => ({ config: null, error: serializeDiagnosticError(error).message })) : { config: null, error: null };
-            const result = { ...remote.value, spaceId, local, remote: remote.value, remoteError: remote.error, diagnosticsPath: runtimeDiagnosticsDirectory(store.root), pendingLocalArchives, failedLocalArchives, nativeSync: nativeSync.config, nativeSyncError: nativeSync.error, nativeSessions };
+            const nativeSync = identity ? await readNativeConfig(stateRoot, identity).then((config) => ({ config, error: null }), (error) => ({ config: null, error: serializeDiagnosticError(error).message })) : { config: null, error: null };
+            const result = { ...remote.value, spaceId, local, remote: remote.value, remoteError: remote.error, diagnosticsPath: runtimeDiagnosticsDirectory(stateRoot), pendingLocalArchives, failedLocalArchives, nativeSync: nativeSync.config, nativeSyncError: nativeSync.error, native: local?.native ?? null };
             if (jsonRequested(options))
                 outJson(result);
             else {
@@ -226,7 +232,7 @@ export function registerRuntime(program) {
                 else
                     process.stdout.write(`Local process  Not running\nSpace  ${spaceId}\nLogs  ${result.diagnosticsPath}\n`);
                 process.stdout.write(`Server  ${remote.error ? `Unknown — ${remote.error}` : remote.value?.online ? "Harness connected" : "Offline"}\nArchives  ${pendingLocalArchives} pending · ${failedLocalArchives} failed\n`);
-                process.stdout.write(formatNativeSync(nativeSync.config, nativeSessions, nativeSync.error));
+                process.stdout.write(formatNativeSync(nativeSync.config, local?.native, nativeSync.error));
             }
         }
         catch (cause) {
@@ -260,8 +266,12 @@ export function registerRuntime(program) {
                 throw new Error("Runtime is still stopping; inspect logs");
             if (jsonRequested(options))
                 outJson({ spaceId, stopped: true });
-            else
+            else {
                 process.stdout.write("Runtime stopped; data retained\n");
+                // Terminal clients may still be attached to it, so it is never stopped for them.
+                if (local?.native?.codex?.control === "shared")
+                    process.stdout.write("Codex's shared app-server keeps running; stop it with codex app-server daemon stop\n");
+            }
         }
         catch (cause) {
             reportFailure(cause);
@@ -278,18 +288,18 @@ export function registerRuntime(program) {
         const stop = () => controller.abort();
         try {
             const spaceId = await resolveRuntimeTarget(program, options.space);
-            const store = new RuntimeSessionStore(spaceId, { projectionSource: createClient().space(spaceId), archiveTransport: null });
+            const stateRoot = runtimeStateRoot(spaceId);
             const limit = Number(options.limit);
             if (!Number.isSafeInteger(limit) || limit < 1 || limit > 10_000)
                 throw new Error("Use a limit from 1 to 10000");
             if (!diagnosticLevels.includes(options.level))
                 throw new Error("Use debug, info, warn or error");
             const asJson = jsonRequested(options);
-            const reader = new RuntimeDiagnosticReader(store.root);
+            const reader = new RuntimeDiagnosticReader(stateRoot);
             process.once("SIGINT", stop);
             process.once("SIGTERM", stop);
             do {
-                const events = (options.follow ? await reader.read({ limit }) : await readRuntimeDiagnosticEvents(store.root, { limit }))
+                const events = (options.follow ? await reader.read({ limit }) : await readRuntimeDiagnosticEvents(stateRoot, { limit }))
                     .filter((event) => atLeastLevel(event.level, options.level));
                 if (asJson && !options.follow)
                     outJson(events);

package/dist/commands/search.js

@@ -1,6 +1,6 @@
 import { isUuid } from "@neta-art/cohub";
 import { createClient } from "../client.js";
-import { formatLocalDateTime, table, json as outJson, jsonRequested, error, handleHttp } from "../output.js";
+import { formatLocalDateTime, table, json as outJson, jsonRequested, error, handleHttp, truncateText } from "../output.js";
 const DEFAULT_LIMIT = 20;
 const MAX_TITLE_LENGTH = 72;
 const MAX_CONTEXT_LENGTH = 42;
@@ -11,12 +11,6 @@ function clampLimit(value) {
         return DEFAULT_LIMIT;
     return Math.min(Math.max(Math.floor(parsed), 1), 50);
 }
-function truncate(value, maxLength) {
-    const text = (value ?? "").replace(/\s+/g, " ").trim();
-    if (text.length <= maxLength)
-        return text;
-    return `${text.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
-}
 function contextFor(item) {
     const owner = item.ownerProfile;
     if (owner?.username)
@@ -47,8 +41,8 @@ function parseSearchInput(opts) {
 function rowsFor(items) {
     return items.map((item) => ({
         type: item.type,
-        title: truncate(item.title, MAX_TITLE_LENGTH),
-        context: truncate(contextFor(item), MAX_CONTEXT_LENGTH),
+        title: truncateText(item.title, MAX_TITLE_LENGTH),
+        context: truncateText(contextFor(item), MAX_CONTEXT_LENGTH),
         match: item.matchedField,
         updated: item.updatedAt ? formatLocalDateTime(item.updatedAt).slice(0, 10) : "",
         href: item.href,

package/dist/commands/spaces.js

@@ -5,7 +5,7 @@ import { resolveCohubEnvironment } from "@neta-art/cohub";
 import { uploadAvatarAsset, uploadChatImageAsset } from "../avatar.js";
 import { createClient } from "../client.js";
 import { putLocalFile } from "../http-put.js";
-import { table, json as outJson, jsonRequested, ok, error, handleHttp, formatEpochMs } from "../output.js";
+import { table, json as outJson, jsonRequested, ok, error, handleHttp, formatEpochMs, truncateText } from "../output.js";
 import { resolveSpace } from "../space.js";
 import { registerSpaceCommerce } from "./space-commerce.js";
 import { registerSpaceActivity } from "./space-activity.js";
@@ -17,6 +17,8 @@ const defaultIdleTtlSeconds = cliEnv === "prod" ? 12 * 60 * 60 : 10 * 60;
 const SPACE_ROLES = ["host", "builder", "guest"];
 const SANDBOX_SPEC_IDS = ["standard", "boost", "ultra"];
 const LABEL_RESOURCE_TYPES = ["session", "checkpoint", "file"];
+/** Table cell width for space descriptions; `--json` keeps the full value. */
+const SPACE_DESCRIPTION_COLUMN_WIDTH = 40;
 function parseInteger(value, name, options = {}) {
     if (!/^-?\d+$/.test(value.trim()))
         return error(`Invalid ${name}`, `${name} must be an integer`);
@@ -476,6 +478,7 @@ export function registerSpaces(program) {
             table(filtered, [
                 { key: "id", label: "ID" },
                 { key: "name", label: "Name" },
+                { key: "description", label: "Description", format: (value) => truncateText(value, SPACE_DESCRIPTION_COLUMN_WIDTH) },
                 { key: "isPinned", label: "Pinned" },
                 { key: "createdAt", label: "Created" },
             ]);
@@ -500,7 +503,7 @@ export function registerSpaces(program) {
                 { key: "id", label: "ID" },
                 { key: "name", label: "Name" },
                 { key: "slug", label: "Slug" },
-                { key: "description", label: "Description" },
+                { key: "description", label: "Description", format: (value) => truncateText(value, SPACE_DESCRIPTION_COLUMN_WIDTH) },
                 { key: "status", label: "Status" },
                 { key: "createdAt", label: "Created" },
             ]);

package/dist/output.d.ts

@@ -24,6 +24,12 @@ export declare function formatLocalDateTime(value: unknown): string;
  * Unix epoch for a timestamp the server never sent.
  */
 export declare function formatEpochMs(value: unknown): string;
+/**
+ * Collapse whitespace and clip long text for a single-line table cell, so
+ * multi-line values cannot break the row layout. `--json` output keeps the
+ * raw value; only the human-facing table is shortened.
+ */
+export declare function truncateText(value: unknown, maxLength: number): string;
 export declare function table(rows: Row[], columns: Column[]): void;
 export declare function json(data: unknown): void;
 export declare function jsonRequested(opts?: {

package/dist/output.js

@@ -40,6 +40,17 @@ export function formatEpochMs(value) {
         return "";
     return formatLocalDateTime(ms);
 }
+/**
+ * Collapse whitespace and clip long text for a single-line table cell, so
+ * multi-line values cannot break the row layout. `--json` output keeps the
+ * raw value; only the human-facing table is shortened.
+ */
+export function truncateText(value, maxLength) {
+    const text = typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
+    if (text.length <= maxLength)
+        return text;
+    return `${text.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
 function cellText(column, row) {
     const raw = row[column.key];
     if (column.format)

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

@@ -15,6 +15,10 @@ export type ArchiveTransport = {
         signal?: AbortSignal;
     }): Promise<RuntimeArchivePage>;
 };
+/** Raised when local capture bytes fail integrity checks (checksum, truncation, boundary); retryable via cache rebuild. */
+export declare class ArchiveCaptureIntegrityError extends Error {
+    constructor(message: string);
+}
 export declare function checksumNativeFile(path: string): Promise<string>;
 export declare function atomicRuntimeJson(path: string, value: unknown): Promise<void>;
 /** Immutable local segments are the outbox. Model acknowledgements never remove them. */

package/dist/runtime/archive-store.js

@@ -4,6 +4,10 @@ import { mkdir, open, readFile, readdir, rename, rm, stat, link } from "node:fs/
 import { dirname, join } from "node:path";
 import { 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 {
+    constructor(message) { super(message); this.name = "ArchiveCaptureIntegrityError"; }
+}
 const hash = (bytes, algorithm = "sha256") => createHash(algorithm).update(bytes).digest("hex");
 export async function checksumNativeFile(path) {
     const digest = createHash("sha256");
@@ -118,7 +122,7 @@ export class RuntimeArchiveStore {
             if (saved.sessionId !== state.sessionId || saved.harness !== state.harness)
                 throw new Error("Archive identity mismatch");
             if (state.expectedChecksum && state.expectedChecksum !== saved.sha256)
-                throw new Error("Native Turn bytes changed; original archive retained");
+                throw new ArchiveCaptureIntegrityError("Native Turn bytes changed; original archive retained");
             const committed = await stat(join(this.root, "ready", `${turnId}.json`)).catch((error) => { if (missing(error))
                 return null; throw error; });
             if (!committed)
@@ -133,10 +137,10 @@ export class RuntimeArchiveStore {
         try {
             const before = await file.stat();
             if (!before.isFile() || !before.size)
-                throw new Error("Native archive is empty");
+                throw new ArchiveCaptureIntegrityError("Native archive is empty");
             const sizeBytes = state.sizeBytes ?? before.size;
             if (!Number.isSafeInteger(sizeBytes) || sizeBytes < 1 || sizeBytes > before.size)
-                throw new Error("Native archive boundary is unavailable");
+                throw new ArchiveCaptureIntegrityError("Native archive boundary is unavailable");
             const buffer = Buffer.alloc(RUNTIME_ARCHIVE_SEGMENT_BYTES);
             let offset = 0;
             let digest = createHash("sha256");
@@ -172,14 +176,14 @@ export class RuntimeArchiveStore {
             }
             const after = await stat(state.path);
             if (before.ino !== after.ino || after.size < sizeBytes || state.sizeBytes === undefined && (before.size !== after.size || before.mtimeMs !== after.mtimeMs))
-                throw new Error("Native file changed during capture");
+                throw new ArchiveCaptureIntegrityError("Native file changed during capture");
             if (state.sizeBytes !== undefined) {
                 // Native clients may append while an earlier Turn is captured. Validate the exact prefix twice.
                 const verified = createHash("sha256");
                 for await (const bytes of createReadStream(state.path, { end: sizeBytes - 1 }))
                     verified.update(bytes);
                 if (verified.digest("hex") !== digest.copy().digest("hex"))
-                    throw new Error("Native prefix changed during capture");
+                    throw new ArchiveCaptureIntegrityError("Native prefix changed during capture");
             }
             if (process.platform !== "win32") {
                 const directory = await open(join(this.root, "objects"), "r");
@@ -195,7 +199,7 @@ export class RuntimeArchiveStore {
                 sizeBytes, sha256: digest.digest("hex"), segments });
             validateArchiveBoundary(index, parent);
             if (state.expectedChecksum && index.sha256 !== state.expectedChecksum)
-                throw new Error("Native Turn bytes changed during capture; original retained");
+                throw new ArchiveCaptureIntegrityError("Native Turn bytes changed during capture; original retained");
         }
         finally {
             await file.close();

package/dist/runtime/codex-usage.d.ts

@@ -4,6 +4,4 @@ export type CodexTokenTotals = Record<typeof fields[number], number>;
 export declare const codexTokenTotals: (value: unknown) => CodexTokenTotals;
 export declare const subtractCodexTokens: (total: CodexTokenTotals, base: CodexTokenTotals) => CodexTokenTotals;
 export declare function codexUsage(total: CodexTokenTotals): NonNullable<RuntimeMessage["usage"]>;
-/** Seed portable imports from the original native counters, not a prior turn's `last`. */
-export declare function codexArchiveTotals(records: Record<string, unknown>[]): CodexTokenTotals | undefined;
 export {};

package/dist/runtime/codex-usage.js

@@ -9,15 +9,3 @@ export const subtractCodexTokens = (total, base) => Object.fromEntries(fields.ma
 export function codexUsage(total) {
     return { input: Math.max(0, total.inputTokens - total.cachedInputTokens - total.cacheWriteInputTokens), output: total.outputTokens, cacheRead: total.cachedInputTokens, cacheWrite: total.cacheWriteInputTokens, totalTokens: total.totalTokens };
 }
-/** Seed portable imports from the original native counters, not a prior turn's `last`. */
-export function codexArchiveTotals(records) {
-    for (let i = records.length - 1; i >= 0; i--) {
-        const entry = records[i];
-        if (entry?.type !== "token_usage_record")
-            continue;
-        const value = record(record(entry.payload).thread_token_usage);
-        if (typeof value.total_tokens !== "number")
-            continue;
-        return codexTokenTotals({ inputTokens: value.input_tokens, outputTokens: value.output_tokens, cachedInputTokens: value.cached_input_tokens, cacheWriteInputTokens: value.cache_write_input_tokens, totalTokens: value.total_tokens });
-    }
-}

package/dist/runtime/connection.d.ts

@@ -1,21 +1,21 @@
-import { type RuntimeCapabilities, type NativeRuntimeEvent } from "@neta-art/cohub";
-import { type HarnessOptions } from "./harness.js";
-import { type RuntimeSessionStore } from "./session-store.js";
+import { type RuntimeNativeStop, type RuntimeCapabilities, type NativeRuntimeEvent } from "@neta-art/cohub";
+import { type Executor } from "./native/execution.js";
 import { type RuntimeDiagnostics } from "./diagnostics.js";
 export type RuntimeConnectionOptions = {
     spaceId: string;
     cwd: string;
     url: string;
     capabilities: RuntimeCapabilities;
-    harnesses: HarnessOptions;
     token: (forceRefresh?: boolean) => Promise<string>;
     signal: AbortSignal;
-    store: RuntimeSessionStore;
+    executor: Executor;
     onReady: () => void;
     onDisconnected?: () => void;
     runtimeId?: string;
     diagnostics?: RuntimeDiagnostics;
     leaseConflictTimeoutMs?: number;
     onNativeChannel?: (send: (event: NativeRuntimeEvent) => Promise<unknown>) => void;
+    /** The web asked to stop a Turn; one running in a native client is stopped there. */
+    onNativeStop?: (stop: RuntimeNativeStop) => void;
 };
 export declare function serveRuntime(options: RuntimeConnectionOptions): Promise<void>;