@neta-art/cohub-cli 10.8.2 → 10.10.0

package/dist/board-media.d.ts

@@ -0,0 +1,4 @@
+import { type BoardDocument, type BoardMediaFileResolver } from "@neta-art/cohub/board";
+export declare function boardMediaFileResolver(spaceId: string): BoardMediaFileResolver;
+export declare function settleBoardDocument(spaceId: string, document: BoardDocument): Promise<BoardDocument>;
+export declare function settleBoardPatch<T extends Record<string, unknown>>(spaceId: string, patch: T, current: (ids: string[]) => Promise<Record<string, unknown> | null>): Promise<T>;

package/dist/board-media.js

@@ -0,0 +1,63 @@
+import { execFile } from "node:child_process";
+import { resolve } from "node:path";
+import { promisify } from "node:util";
+import { diffMergePatch, mergePatch, parseBoardItem, settleBoardMediaSizes, } from "@neta-art/cohub/board";
+import { createClient } from "./client.js";
+import { WORKSPACE_ROOT } from "./space-files/operands.js";
+const run = promisify(execFile);
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const oriented = (width, height, turned) => width > 0 && height > 0 ? (turned ? { width: height, height: width } : { width, height }) : null;
+async function localMediaSize(file, type, signal) {
+    try {
+        if (type === "image") {
+            const { default: sharp } = await import("sharp");
+            const { width = 0, height = 0, orientation = 1 } = await sharp(file).metadata();
+            return oriented(width, height, orientation >= 5);
+        }
+        const { stdout } = await run("ffprobe", [
+            "-v", "error", "-select_streams", "v:0",
+            "-show_entries", "stream=width,height:stream_side_data=rotation", "-of", "json", file,
+        ], { signal, timeout: 5_000 });
+        const stream = JSON.parse(stdout).streams?.[0];
+        const rotation = stream?.side_data_list?.find((data) => data.rotation !== undefined)?.rotation ?? 0;
+        return oriented(stream?.width ?? 0, stream?.height ?? 0, Math.abs(rotation) % 180 === 90);
+    }
+    catch {
+        return null;
+    }
+}
+export function boardMediaFileResolver(spaceId) {
+    const local = process.env.COHUB_SPACE_ID === spaceId;
+    return async (path, type, signal) => {
+        const file = resolve(WORKSPACE_ROOT, path);
+        const size = local && file.startsWith(`${WORKSPACE_ROOT}/`) ? await localMediaSize(file, type, signal) : null;
+        return size ?? createClient().space(spaceId).files.resolveUrl(path, { purpose: "playback", signal }).catch(() => null);
+    };
+}
+export async function settleBoardDocument(spaceId, document) {
+    const settled = await settleBoardMediaSizes(document.items, { resolveFile: boardMediaFileResolver(spaceId) });
+    return Object.keys(settled).length ? { ...document, items: { ...document.items, ...settled } } : document;
+}
+export async function settleBoardPatch(spaceId, patch, current) {
+    const items = isRecord(patch.items) ? patch.items : {};
+    const created = {};
+    for (const [id, value] of Object.entries(items)) {
+        if (!isRecord(value) || (value.type !== "image" && value.type !== "video"))
+            continue;
+        const parsed = parseBoardItem(value, `items.${id}`);
+        if (parsed.ok)
+            created[id] = parsed.item;
+    }
+    const existing = Object.keys(created).length ? await current(Object.keys(created)) : null;
+    if (!existing)
+        return patch;
+    for (const [id, item] of Object.entries(existing)) {
+        if (isRecord(item) && item.type === created[id]?.type)
+            delete created[id];
+    }
+    const settled = await settleBoardMediaSizes(created, { resolveFile: boardMediaFileResolver(spaceId) });
+    if (!Object.keys(settled).length)
+        return patch;
+    const adopted = Object.entries(settled).map(([id, item]) => [id, mergePatch(items[id], diffMergePatch(created[id], item))]);
+    return { ...patch, items: { ...items, ...Object.fromEntries(adopted) } };
+}

package/dist/commands/boards/authoring.js

@@ -1,5 +1,6 @@
 import { readBoardJsonObject } from "../../board-command-support.js";
 import { loadBoardDocument, resolveBundledFonts } from "../../board-export.js";
+import { settleBoardDocument } from "../../board-media.js";
 import { boardPathTrack, boardSequencePatch, buildBoardScene, createBoardAnimationSampler, createNodeBoardRenderer, inspectBoardItems, } from "../../board-kernel.js";
 import { parseBoardTimes } from "../../board-time.js";
 import { handleHttp, json as outJson } from "../../output.js";
@@ -19,7 +20,8 @@ Checks native layout only, not camera cropping or content drawn inside scripts.
 Example: cohub boards inspect lesson.board --animation lecture --at 0:20s:1s --json`)
         .action(async (target, options) => {
         try {
-            const { document } = await loadBoardDocument(await resolveSpace(boards), target);
+            const spaceId = await resolveSpace(boards);
+            const document = await settleBoardDocument(spaceId, (await loadBoardDocument(spaceId, target)).document);
             const times = parseBoardTimes(options.at, "--at", 100);
             const sampler = options.animation ? createBoardAnimationSampler(document, options.animation) : null;
             const renderer = await createNodeBoardRenderer({ fonts: resolveBundledFonts() });

package/dist/commands/boards.js

@@ -2,9 +2,10 @@ import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
-import { BOARD_PRESET_NAMES, BOARD_SCHEMA_TARGETS, BOARD_SCRIPT_API, boardJsonSchema, boardPresetTracks, boardSchemaOverview, isBoardPresetName, listBoardPresets, } from "@neta-art/cohub/board";
+import { BOARD_PRESET_NAMES, BOARD_SCHEMA_TARGETS, BOARD_SCRIPT_API, BOARD_THEME_IDS, boardJsonSchema, boardPresetTracks, boardSchemaOverview, isBoardPresetName, listBoardPresets, } from "@neta-art/cohub/board";
 import { BOARD_CREATE_INPUT_MAX_BYTES, BOARD_TRANSACTION_INPUT_MAX_BYTES, parseBoardJsonObject, readBoardJsonObject, resolveBoardId, writeBoardOutput, } from "../board-command-support.js";
 import { BOARD_EXPORT_IMAGE_MEMORY_MIB } from "../board-export-resources.js";
+import { settleBoardPatch } from "../board-media.js";
 import { formatBoardTime, parseBoardTime, parseBoardTimes } from "../board-time.js";
 import { createClient, createRealtimeClient } from "../client.js";
 import { error, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
@@ -52,8 +53,8 @@ function list(value) {
     const entries = value?.split(",").map((entry) => entry.trim()).filter(Boolean);
     return entries?.length ? entries : undefined;
 }
-async function boardClient(boards, target) {
-    const spaceId = await resolveSpace(boards);
+async function boardClient(boards, target, spaceId) {
+    spaceId ??= await resolveSpace(boards);
     return createClient().space(spaceId).board(await resolveBoardId(spaceId, target));
 }
 /** A patch from an inline argument, a file, or stdin (`-`). */
@@ -158,7 +159,7 @@ function registerExportCommand(boards) {
         .option("--rect <rect>", "World rect as x,y,width,height")
         .option("--scale <factor>", "Output pixels per board unit", "2")
         .option("--padding <units>", "Padding around the content in board units")
-        .option("--theme <mode>", "dark or light", "dark")
+        .option("--theme <name>", `Cohub theme: ${BOARD_THEME_IDS.join(", ")}`, "dark")
         .option("--paper <mode>", "Output paper: paper or transparent", "paper")
         .option("--format <format>", `Override the format (${BOARD_EXPORT_FORMATS.join(", ")}, ${BOARD_VIDEO_FORMATS.join(", ")})`)
         .option("--quality <q>", "JPEG/WebP quality from 0 to 1", "0.92")
@@ -230,7 +231,7 @@ Examples:
                     ...(options.animation ? { animation: options.animation } : {}),
                     scale: parseNumber(options.scale ?? "2", "--scale", { min: 0.01, max: 16 }),
                     ...(options.padding === undefined ? {} : { padding: parseNumber(options.padding, "--padding", { min: 0 }) }),
-                    colorScheme: parseChoice(options.theme, "--theme", ["dark", "light"]),
+                    theme: parseChoice(options.theme, "--theme", BOARD_THEME_IDS),
                     background: parseChoice(options.paper, "--paper", ["paper", "transparent"]),
                     format: videoFormat,
                     fps,
@@ -271,7 +272,7 @@ Examples:
                 ...(options.animation ? { animation: options.animation } : {}),
                 scale: parseNumber(options.scale ?? "2", "--scale", { min: 0.01, max: 16 }),
                 ...(options.padding === undefined ? {} : { padding: parseNumber(options.padding, "--padding", { min: 0 }) }),
-                colorScheme: parseChoice(options.theme, "--theme", ["dark", "light"]),
+                theme: parseChoice(options.theme, "--theme", BOARD_THEME_IDS),
                 background: parseChoice(options.paper, "--paper", ["paper", "transparent"]),
                 format: parseExportFormat(options, out),
                 quality: parseNumber(options.quality ?? "0.92", "--quality", { min: 0, max: 1 }),
@@ -327,14 +328,16 @@ Times are milliseconds; 500ms, 12.5s and 2m also work on the command line.`);
   cohub boards create lesson.board -i lesson.json`)
         .action(async (path, options) => {
         try {
-            const document = options.input ? await readBoardJsonObject(options.input, BOARD_CREATE_INPUT_MAX_BYTES) : undefined;
+            const spaceId = await resolveSpace(boards);
+            const read = options.input ? await readBoardJsonObject(options.input, BOARD_CREATE_INPUT_MAX_BYTES) : undefined;
+            const document = read && await settleBoardPatch(spaceId, read, async () => ({}));
             const input = {
                 path,
                 mutationId: options.mutationId ?? randomUUID(),
                 ...(options.title ? { title: options.title } : {}),
                 ...(document ? { document: document } : {}),
             };
-            const result = await createClient().space(await resolveSpace(boards)).boards.create(input);
+            const result = await createClient().space(spaceId).boards.create(input);
             if (jsonRequested(options))
                 return outJson({ path, id: result.id, title: result.title, version: result.version });
             ok(`Created ${path}`);
@@ -411,8 +414,11 @@ Times are milliseconds; 500ms, 12.5s and 2m also work on the command line.`);
   cohub boards preset rise --targets a,b --animation intro | cohub boards apply plan.board -i -`)
         .action(async (target, inline, options) => {
         try {
-            const patch = await readPatch(inline, options.input, BOARD_TRANSACTION_INPUT_MAX_BYTES);
-            const result = await (await boardClient(boards, target)).apply(patch, {
+            const spaceId = await resolveSpace(boards);
+            const board = await boardClient(boards, target, spaceId);
+            const read = await readPatch(inline, options.input, BOARD_TRANSACTION_INPUT_MAX_BYTES);
+            const patch = await settleBoardPatch(spaceId, read, async (items) => options.replace ? {} : board.get({ only: ["items"], items }).then((result) => result.items ?? {}, () => null));
+            const result = await board.apply(patch, {
                 ...(options.replace ? { replace: true } : {}),
                 ...(options.cascade ? { cascade: true } : {}),
                 ...(options.dryRun ? { dryRun: true } : {}),

package/dist/commands/feedback.d.ts

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

package/dist/commands/feedback.js

@@ -0,0 +1,129 @@
+import { openAsBlob } from "node:fs";
+import { stat } from "node:fs/promises";
+import { arch, platform, release } from "node:os";
+import { basename, resolve } from "node:path";
+import { mimeTypeForPath, readRequestSourceFromEnv, resolveApiBaseUrl, resolveCohubEnvironment } from "@neta-art/cohub";
+import { authSource } from "../auth.js";
+import { createClient } from "../client.js";
+import { collectOption, readPromptContent } from "../command-input.js";
+import { describeError } from "../network-error.js";
+import { error, json as outJson, jsonRequested, spinner } from "../output.js";
+import { readRuntimeDiagnosticEvents } from "../runtime/diagnostics.js";
+import { resolveRuntimeTarget } from "../runtime/launch.js";
+import { runtimeStateRoot } from "../runtime/native/config.js";
+import { explicitSpace } from "../space.js";
+// Shared with the web feedback dialog; cfeed enforces attachment limits server-side.
+const CFEED_ENDPOINT = "https://cfeed.neta.art/api/v1/feedback";
+const CFEED_APP = "cohub";
+const RUNTIME_LOG_MAX_BYTES = 5 * 1024 * 1024;
+const RUNTIME_LOG_EVENTS = 2_000;
+const USER_LOOKUP_TIMEOUT_MS = 3_000;
+const SUBMIT_TIMEOUT_MS = 120_000;
+async function readAttachment(path) {
+    const absolute = resolve(path);
+    const info = await stat(absolute).catch(() => null);
+    if (!info?.isFile())
+        return error(`Cannot attach ${path}`, "Pass a path to an existing file");
+    const type = mimeTypeForPath(absolute) ?? "application/octet-stream";
+    return new File([await openAsBlob(absolute, { type })], basename(absolute), { type });
+}
+async function runtimeLogFile(program, now) {
+    const spaceId = await resolveRuntimeTarget(program).catch((cause) => error("Cannot attach Runtime logs", describeError(cause)));
+    let events = await readRuntimeDiagnosticEvents(runtimeStateRoot(spaceId), { limit: RUNTIME_LOG_EVENTS });
+    let dropped = 0;
+    let text = JSON.stringify({ spaceId, dropped, events });
+    // Keep the newest events when the log exceeds the budget.
+    while (Buffer.byteLength(text) > RUNTIME_LOG_MAX_BYTES && events.length > 0) {
+        const count = Math.ceil(events.length / 2);
+        events = events.slice(count);
+        dropped += count;
+        text = JSON.stringify({ spaceId, dropped, events });
+    }
+    const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\..+$/, "");
+    return new File([text], `cohub-runtime-${stamp}.json`, { type: "application/json" });
+}
+async function currentUserUuid() {
+    if (!authSource())
+        return null;
+    let timer;
+    const timeout = new Promise((done) => { timer = setTimeout(() => done(null), USER_LOOKUP_TIMEOUT_MS); });
+    const lookup = createClient().user.getMe().then((user) => user.uuid ?? null, () => null);
+    try {
+        return await Promise.race([lookup, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function submitFeedback(content, extra, files) {
+    const body = new FormData();
+    body.set("app", CFEED_APP);
+    body.set("content", content);
+    body.set("extra", JSON.stringify(extra));
+    for (const file of files)
+        body.append("files", file, file.name);
+    const response = await fetch(CFEED_ENDPOINT, { method: "POST", body, signal: AbortSignal.timeout(SUBMIT_TIMEOUT_MS) });
+    const payload = (await response.json().catch(() => null));
+    if (!response.ok)
+        throw new Error(payload?.error?.message ?? `${response.status} ${response.statusText}`);
+    if (!payload)
+        throw new Error("Feedback service returned an empty response");
+    return payload;
+}
+export function registerFeedback(program) {
+    program
+        .command("feedback [message...]")
+        .description("Send feedback or a bug report to the Cohub team")
+        .option("-f, --file <path>", "Attach a file; repeatable", collectOption, [])
+        .option("--runtime-logs", "Attach recent local Runtime diagnostics for the target Space")
+        .option("--json", "Output as JSON")
+        .addHelpText("after", `
+The message comes from arguments or stdin. CLI version, OS, environment, account,
+and COHUB_* Space/Chat context are attached automatically; your working directory is not.
+
+Examples:
+  $ cohub feedback "runtime up hangs after sign-in"
+  $ cohub feedback "Board export is blurry" -f board.png -f export.log
+  $ cohub feedback --runtime-logs "Codex chats stopped syncing"
+  $ cat report.md | cohub feedback`)
+        .action(async (words, opts) => {
+        const asJson = jsonRequested(opts);
+        const content = await readPromptContent(words);
+        const now = new Date();
+        const [files, userUuid] = await Promise.all([
+            Promise.all([
+                ...opts.file.map(readAttachment),
+                ...(opts.runtimeLogs ? [runtimeLogFile(program, now)] : []),
+            ]),
+            currentUserUuid(),
+        ]);
+        const extra = {
+            user_uuid: userUuid,
+            cli_version: program.version() ?? null,
+            node: process.versions.node,
+            os: `${platform()} ${release()}`,
+            arch: arch(),
+            env: resolveCohubEnvironment(),
+            api_base_url: resolveApiBaseUrl(),
+            space: explicitSpace(program),
+            source: readRequestSourceFromEnv(process.env, { via: "cli" }),
+            locale: Intl.DateTimeFormat().resolvedOptions().locale,
+            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            tty: Boolean(process.stdout.isTTY),
+            has_runtime_logs: Boolean(opts.runtimeLogs),
+        };
+        const sp = asJson ? null : spinner();
+        sp?.start("Sending feedback");
+        try {
+            const result = await submitFeedback(content, extra, files);
+            if (asJson)
+                return outJson(result);
+            sp?.stop(`Feedback sent · ${result.id}`);
+        }
+        catch (cause) {
+            if (sp)
+                process.stderr.write("\n");
+            error("Couldn't send feedback", describeError(cause));
+        }
+    });
+}

package/dist/index.js

@@ -6,6 +6,7 @@ import { registerAuth } from "./commands/auth.js";
 import { registerBoards } from "./commands/boards.js";
 import { registerChannels } from "./commands/channels.js";
 import { registerCronJobs } from "./commands/cron-jobs.js";
+import { registerFeedback } from "./commands/feedback.js";
 import { registerGenerations } from "./commands/generations.js";
 import { registerMe } from "./commands/me.js";
 import { registerModels } from "./commands/models.js";
@@ -71,6 +72,7 @@ Common commands:
   cohub models ls
   cohub models ls --model-type multimodal
   cohub generate "A calm lake at sunrise" --model <model> --output lake.png
+  cohub feedback "Describe the problem" -f screenshot.png
 
 Target space:
   -s <space>, then COHUB_SPACE_ID, then the current directory Runtime binding.
@@ -108,6 +110,7 @@ registerTasks(program);
 registerCronJobs(program);
 registerApps(program);
 registerRooms(program);
+registerFeedback(program);
 registerDesktop(program);
 registerLegacyUi(program);
 const argv = process.argv.slice(2);

package/dist/runtime/native/attach.js

@@ -29,22 +29,21 @@ export async function ensureNativeSync(input, log = (line) => process.stderr.wri
         return { enabled: false, harnesses: [], codexShared: false, importHistory: false, note: "unsupported" };
     const stateRoot = runtimeStateRoot(input.spaceId);
     const previous = await readNativeConfig(stateRoot, input.identity).catch(() => null);
-    if (previous && nativeSyncSatisfied(previous, input)) {
-        await maintain(previous, log, input.executables?.pi);
-        return { enabled: true, harnesses: previous.harnesses, codexShared: previous.codexShared, importHistory: false };
-    }
+    const alreadySynced = previous && nativeSyncSatisfied(previous, input);
     const interactive = process.stdin.isTTY === true;
     const confirm = async (question) => input.yes ? true : interactive ? await ask(question) : false;
-    if (!input.yes && !interactive) {
-        log("Native sync off · rerun interactively or with --yes to enable\n");
-        return { enabled: false, harnesses: input.harnesses, codexShared: false, importHistory: false, note: "non-interactive" };
-    }
-    const names = input.harnesses.map((harness) => LOCAL_HARNESS_SPECS[harness].label).join(" and ");
-    if (!await confirm(`Sync ${names} chats in this folder to this Space so they continue on the web? Their history may contain secrets. [Y/n] `)) {
-        return { enabled: false, harnesses: input.harnesses, codexShared: false, importHistory: false, note: "declined" };
+    if (!alreadySynced) {
+        if (!input.yes && !interactive) {
+            log("Native sync off · rerun interactively or with --yes to enable\n");
+            return { enabled: false, harnesses: input.harnesses, codexShared: false, importHistory: false, note: "non-interactive" };
+        }
+        const names = input.harnesses.map((harness) => LOCAL_HARNESS_SPECS[harness].label).join(" and ");
+        if (!await confirm(`Sync ${names} chats in this folder to this Space so they continue on the web? Their history may contain secrets. [Y/n] `)) {
+            return { enabled: false, harnesses: input.harnesses, codexShared: false, importHistory: false, note: "declined" };
+        }
     }
     let codexShared = previous?.codexShared ?? false;
-    if (input.harnesses.includes("codex") && !codexShared) {
+    if (input.harnesses.includes("codex") && !codexShared && (input.yes || interactive)) {
         const version = await harnessVersion(input.executables?.codex || "codex");
         if (!sharedServerAvailable) {
             log("Shared Codex sessions are unavailable on Windows; terminal Codex chats sync read-only\n");
@@ -56,6 +55,16 @@ export async function ensureNativeSync(input, log = (line) => process.stderr.wri
             codexShared = await confirm("Let terminal Codex and the web drive the same live sessions? Cohub starts Codex's shared app-server, which keeps running in the background. [Y/n] ");
         }
     }
+    if (previous && alreadySynced) {
+        if (codexShared !== previous.codexShared) {
+            await writeNativeConfig(stateRoot, { ...previous, codexShared }).catch((error) => {
+                log(`Shared Codex sessions unavailable; Runtime continues without them — ${serializeDiagnosticError(error).message}\n`);
+                codexShared = previous.codexShared;
+            });
+        }
+        await maintain(previous, log, input.executables?.pi);
+        return { enabled: true, harnesses: previous.harnesses, codexShared, importHistory: false };
+    }
     const harnesses = [...new Set([...(previous?.root === input.root ? previous.harnesses : []), ...input.harnesses])];
     const config = {
         version: 2, identity: input.identity, spaceId: input.spaceId, root: input.root, harnesses,

package/dist/runtime/native/transcript.js

@@ -158,11 +158,22 @@ async function scanCodexRollouts(signal) {
     codexRolloutIndexCache = { at: Date.now(), home, index };
     return index;
 }
+async function* compressedCodexRolloutBytes(path, signal) {
+    const decoder = createZstdDecompress();
+    // pipeline keeps error listeners attached, so stopping at a header or prefix cannot crash with an unhandled decoder error.
+    const pumping = pipeline(createReadStream(path), decoder, { signal }).catch(() => { });
+    try {
+        yield* decoder;
+    }
+    finally {
+        decoder.destroy();
+        await pumping;
+    }
+}
 /** Raw JSONL bytes of a rollout, transparently decompressing `.zst` and honoring a lineage cutoff. */
 export async function* codexRolloutBytes(path, endBytes, signal) {
-    // compose (not pipe) so a source error propagates and early exit destroys both streams.
     const stream = path.endsWith(".zst")
-        ? createReadStream(path, { signal }).compose(createZstdDecompress())
+        ? compressedCodexRolloutBytes(path, signal)
         : createReadStream(path, endBytes != null ? { end: endBytes - 1, signal } : { signal });
     let total = 0, last = -1;
     for await (const chunk of stream) {
@@ -522,9 +533,10 @@ function parseCodexLines(lines, segment) {
                 calls.get(id)?.content.push({ type: "tool_result", tool_use_id: id, content: typeof payload.output === "string" ? payload.output : JSON.stringify(payload.output ?? null) });
             }
         }
+        // Cohub tags a Turn it starts with its own cloud Turn id (`client_id`), so the file itself records
+        // which Turns already belong to a cloud Turn and must not be ingested twice. Older Codex writes it
+        // on `item_completed`'s UserMessage, newer Codex on `user_message`.
         if (entry.type === "event_msg" && payload.type === "item_completed") {
-            // Cohub tags a Turn it starts with its own cloud Turn id, so the file itself records which
-            // Turns already belong to a cloud Turn (and must not be ingested twice).
             const item = record(payload.item);
             if (item.type === "UserMessage") {
                 const clientId = text(item.client_id);
@@ -540,6 +552,9 @@ function parseCodexLines(lines, segment) {
             }
         }
         if (entry.type === "event_msg" && payload.type === "user_message") {
+            const clientId = text(payload.client_id);
+            if (clientId)
+                current.cloudTurnId = clientId;
             if (!userFromResponse)
                 current.userContent = [{ type: "text", text: text(payload.message) }];
             userFromResponse = true;

package/dist/runtime/supervisor.js

@@ -152,11 +152,23 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
                     });
                     bridge.stdin?.on("error", () => undefined);
                     const closed = new Promise((resolve) => {
+                        let drainTimer;
                         bridge.once("error", (error) => diagnostics.log("error", "sandboxd.process_error", { error: serializeDiagnosticError(error) }));
-                        bridge.once("close", (code, exitSignal) => {
+                        bridge.once("exit", (code, exitSignal) => {
                             childStopped = true;
                             if (!signal.aborted)
                                 diagnostics.log("warn", "sandboxd.process_exit", { code, signal: exitSignal });
+                            // Descendants may still hold inherited pipes. After draining buffered
+                            // output, close only our ends so supervision can continue.
+                            drainTimer = setTimeout(() => {
+                                diagnostics.log("warn", "sandboxd.stdio_drain_timeout");
+                                for (const stream of bridge.stdio)
+                                    stream?.destroy();
+                            }, 1000);
+                        });
+                        bridge.once("close", () => {
+                            childStopped = true;
+                            clearTimeout(drainTimer);
                             resolve();
                         });
                     });

package/dist/space-files/operands.d.ts

@@ -11,6 +11,7 @@ export type FileOperand = SpaceOperand | LocalOperand;
 export declare class InvalidFileOperandError extends Error {
     name: string;
 }
+export declare const WORKSPACE_ROOT = "/workspace";
 export declare function normalizeSpacePath(raw: string): string;
 export declare function parseSpaceFileOperand(raw: string): SpaceOperand;
 export declare function parseCopyOperand(raw: string, currentSpaceDeclared: boolean): FileOperand;

package/dist/space-files/operands.js

@@ -3,7 +3,7 @@ import { parseSpaceRef } from "@neta-art/cohub";
 export class InvalidFileOperandError extends Error {
     name = "InvalidFileOperandError";
 }
-const WORKSPACE_ROOT = "/workspace";
+export const WORKSPACE_ROOT = "/workspace";
 const isWorkspacePath = (path) => path === WORKSPACE_ROOT || path.startsWith(`${WORKSPACE_ROOT}/`);
 export function normalizeSpacePath(raw) {
     let path = raw.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "10.8.2",
+  "version": "10.10.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -18,7 +18,7 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@neta-art/cohub": "12.1.0",
+    "@neta-art/cohub": "12.2.0",
     "@neta-art/generation": "^0.1.40",
     "commander": "^15.0.0",
     "sharp": "^0.35.4",
@@ -28,8 +28,9 @@
     "access": "public"
   },
   "devDependencies": {
-    "@fontsource/geist": "^5.3.0",
-    "@fontsource/geist-mono": "^5.3.0",
+    "@fontsource-variable/figtree": "^5.3.0",
+    "@fontsource-variable/geist": "^5.3.0",
+    "@fontsource-variable/geist-mono": "^5.3.0",
     "@types/node": "26.6.4",
     "@types/ws": "^8.18.1",
     "pixi.js": "^8.20.1",
@@ -37,7 +38,7 @@
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
-    "@napi-rs/canvas": "^1.0.8"
+    "@napi-rs/canvas": "^1.0.13"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json && tsdown",