@neta-art/cohub-cli 8.1.0 → 8.1.1

package/dist/commands/app-commerce.js

@@ -1,6 +1,6 @@
 import { resolveExecutionAppId, } from "@neta-art/cohub";
 import { createClient } from "../client.js";
-import { error, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
+import { error, formatLocalDateTime, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
 function collectOption(value, previous = []) {
     return [...previous, value];
 }
@@ -69,7 +69,7 @@ function printOrder(order) {
         { key: "status", label: "Status" },
         { key: "amount", label: "Amount" },
         { key: "paid", label: "Paid" },
-        { key: "created", label: "Created" },
+        { key: "created", label: "Created", format: formatLocalDateTime },
         { key: "paidAt", label: "Paid At" },
     ]);
 }

package/dist/commands/me.js

@@ -1,5 +1,5 @@
 import { createClient } from "../client.js";
-import { handleHttp, json as outJson, jsonRequested, table } from "../output.js";
+import { formatLocalDateTime, handleHttp, json as outJson, jsonRequested, table } from "../output.js";
 function parseInteger(value, name, min) {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isSafeInteger(parsed) || parsed < min) {
@@ -70,7 +70,7 @@ export function registerMe(program) {
             });
             if (jsonRequested(opts))
                 return outJson(activity);
-            console.log(`\n  ${activity.range.from} → ${activity.range.to}`);
+            console.log(`\n  ${formatLocalDateTime(activity.range.from)} → ${formatLocalDateTime(activity.range.to)}`);
             table([activity.summary], [
                 { key: "totalTokens", label: "Tokens" },
                 { key: "costTotal", label: "Cost ($)" },

package/dist/commands/references.js

@@ -1,6 +1,6 @@
 import { isUuid, } from "@neta-art/cohub";
 import { createClient } from "../client.js";
-import { table, json as outJson, jsonRequested, error, handleHttp } from "../output.js";
+import { formatLocalDateTime, table, json as outJson, jsonRequested, error, handleHttp } from "../output.js";
 const RESOURCE_TYPES = new Set([
     "turn",
     "session",
@@ -104,7 +104,7 @@ Examples:
                 source: `${r.sourceType}:${r.sourceId.slice(0, 8)}`,
                 target: formatTarget(r.targetType, r.targetId),
                 count: r.count,
-                lastSeen: r.updatedAt.slice(0, 10),
+                lastSeen: formatLocalDateTime(r.updatedAt).slice(0, 10),
             }));
             table(rows, [
                 { key: "kind", label: "Kind" },

package/dist/commands/runtime.d.ts

@@ -1,3 +1,15 @@
 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

@@ -17,6 +17,16 @@ 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;
+}
 export function registerRuntime(program) {
     const runtime = program.command("runtime").description("Connect a local workspace");
     runtime.command("up [dir]")
@@ -107,7 +117,7 @@ export function registerRuntime(program) {
             const candidates = discovered.candidates.filter((candidate) => !options.session || candidate.nativeSessionId === options.session);
             const result = {
                 spaceId, root, harnesses, candidates, errors: discovered.errors,
-                imported: 0, failed: [], dryRun: Boolean(options.dryRun),
+                imported: 0, failed: [], skipped: [], dryRun: Boolean(options.dryRun),
                 complete: discovered.errors.length === 0,
             };
             if (jsonRequested(options) && options.dryRun) {
@@ -163,9 +173,7 @@ export function registerRuntime(program) {
                 try {
                     const response = await requestNativeDaemon({ harness: candidate.harness, cwd: root, path: candidate.path, nativeSessionId: candidate.nativeSessionId,
                         sessionStartedAt: candidate.sessionStartedAt, origin: "local_import", settled: true });
-                    if (!response.ok)
-                        throw new Error(response.message);
-                    result.imported += 1;
+                    applyNativeImportResponse(result, candidate.path, response);
                 }
                 catch (error) {
                     result.failed.push({ path: candidate.path, message: error instanceof Error ? error.message : String(error) });
@@ -176,7 +184,7 @@ export function registerRuntime(program) {
                 outJson(result);
             else {
                 process.stdout.write(`Imported ${result.imported}/${candidates.length} native conversation${candidates.length === 1 ? "" : "s"}\n`);
-                for (const error of [...discovered.errors, ...result.failed])
+                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");
             }

package/dist/commands/search.js

@@ -1,6 +1,6 @@
 import { isUuid } from "@neta-art/cohub";
 import { createClient } from "../client.js";
-import { table, json as outJson, jsonRequested, error, handleHttp } from "../output.js";
+import { formatLocalDateTime, table, json as outJson, jsonRequested, error, handleHttp } from "../output.js";
 const DEFAULT_LIMIT = 20;
 const MAX_TITLE_LENGTH = 72;
 const MAX_CONTEXT_LENGTH = 42;
@@ -50,7 +50,7 @@ function rowsFor(items) {
         title: truncate(item.title, MAX_TITLE_LENGTH),
         context: truncate(contextFor(item), MAX_CONTEXT_LENGTH),
         match: item.matchedField,
-        updated: item.updatedAt ? item.updatedAt.slice(0, 10) : "",
+        updated: item.updatedAt ? formatLocalDateTime(item.updatedAt).slice(0, 10) : "",
         href: item.href,
     }));
 }

package/dist/commands/space-commerce.js

@@ -1,5 +1,5 @@
 import { createClient } from "../client.js";
-import { error, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
+import { error, formatLocalDateTime, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
 import { resolveSpace } from "../space.js";
 const PRODUCT_STATUSES = ["draft", "active"];
 const PRODUCT_UPDATE_STATUSES = ["draft", "active", "archived"];
@@ -135,7 +135,7 @@ function printOrders(orders) {
         { key: "product", label: "Product" },
         { key: "status", label: "Status" },
         { key: "amount", label: "Amount" },
-        { key: "created", label: "Created" },
+        { key: "created", label: "Created", format: formatLocalDateTime },
     ]);
 }
 async function confirmDanger(opts, detail) {

package/dist/output.d.ts

@@ -10,11 +10,18 @@ export type Column = {
     format?: (value: unknown, row: Row) => string;
 };
 /**
- * Epoch milliseconds → ISO 8601, matching the ISO timestamps other tables print.
+ * Timestamp → local ISO-style date and time with the system's UTC offset.
+ *
+ * CLI tables are for people and follow the machine's local timezone. Structured
+ * output remains untouched so scripts continue to receive the server value.
+ */
+export declare function formatLocalDateTime(value: unknown): string;
+/**
+ * Epoch milliseconds → local date and time.
  *
  * Absent values render empty rather than falling through `Number()` coercion:
  * `null` and `""` both become 0 there, which would print a confident-looking
- * `1970-01-01T00:00:00.000Z` for a timestamp the server never sent.
+ * Unix epoch for a timestamp the server never sent.
  */
 export declare function formatEpochMs(value: unknown): string;
 export declare function table(rows: Row[], columns: Column[]): void;

package/dist/output.js

@@ -1,11 +1,34 @@
 import process from "node:process";
 import { extractBillingPayload } from "@neta-art/cohub";
 /**
- * Epoch milliseconds → ISO 8601, matching the ISO timestamps other tables print.
+ * Timestamp → local ISO-style date and time with the system's UTC offset.
+ *
+ * CLI tables are for people and follow the machine's local timezone. Structured
+ * output remains untouched so scripts continue to receive the server value.
+ */
+export function formatLocalDateTime(value) {
+    const date = value instanceof Date
+        ? value
+        : typeof value === "number"
+            ? new Date(value)
+            : typeof value === "string" && value.trim() !== ""
+                ? new Date(value)
+                : null;
+    if (!date || Number.isNaN(date.getTime()))
+        return "";
+    const pad = (part) => String(part).padStart(2, "0");
+    const offsetMinutes = -date.getTimezoneOffset();
+    const offsetSign = offsetMinutes >= 0 ? "+" : "-";
+    const absoluteOffset = Math.abs(offsetMinutes);
+    const offset = `${offsetSign}${pad(Math.floor(absoluteOffset / 60))}:${pad(absoluteOffset % 60)}`;
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())} ${offset}`;
+}
+/**
+ * Epoch milliseconds → local date and time.
  *
  * Absent values render empty rather than falling through `Number()` coercion:
  * `null` and `""` both become 0 there, which would print a confident-looking
- * `1970-01-01T00:00:00.000Z` for a timestamp the server never sent.
+ * Unix epoch for a timestamp the server never sent.
  */
 export function formatEpochMs(value) {
     const ms = typeof value === "number"
@@ -15,13 +38,14 @@ export function formatEpochMs(value) {
             : Number.NaN;
     if (!Number.isFinite(ms))
         return "";
-    const date = new Date(ms);
-    return Number.isNaN(date.getTime()) ? "" : date.toISOString();
+    return formatLocalDateTime(ms);
 }
 function cellText(column, row) {
     const raw = row[column.key];
     if (column.format)
         return column.format(raw, row);
+    if (/(?:At|Timestamp)$/.test(column.key))
+        return formatLocalDateTime(raw);
     const v = raw ?? "";
     return typeof v === "object" ? JSON.stringify(v) : String(v);
 }

package/dist/runtime/native-codex-hook.js

@@ -9,7 +9,7 @@ export async function runCodexNativeHook(payload) {
     if (typeof value.transcript_path !== "string" || !value.transcript_path)
         return;
     const result = await requestNativeDaemon({ harness: "codex", cwd: value.cwd, path: value.transcript_path, nativeSessionId: value.session_id });
-    if (!result.ok)
+    if (!result.ok && !result.skipped)
         throw new Error(result.message);
 }
 async function main() {

package/dist/runtime/native-ipc.d.ts

@@ -10,13 +10,22 @@ type NativeIpcRequest = {
     sessionStartedAt?: string;
     origin?: "local_import";
 };
-type NativeIpcResponse = {
+export type NativeIpcResponse = {
     ok: true;
     pendingTurns: number;
 } | {
     ok: false;
+    skipped?: true;
     message: string;
 };
+/**
+ * `store: null` means the request was valid but nothing was applicable yet (an unbound
+ * workspace, or a transcript a harness has not written). That is not a sync failure, so
+ * clients stay silent instead of warning about it.
+ */
+export declare function nativeCaptureResponse(result: {
+    store: NativeSyncStore | null;
+}): Promise<NativeIpcResponse>;
 export declare function nativeDaemonSocketFor(cwd: string): Promise<string | null>;
 export declare function requestNativeDaemon(input: Omit<NativeIpcRequest, "type">): Promise<NativeIpcResponse>;
 export declare function serveNativeDaemon(input: {

package/dist/runtime/native-ipc.js

@@ -6,6 +6,16 @@ import { currentIdentityKey } from "../space.js";
 import { canonicalRuntimeRoot, getRuntimeSpaceBinding } from "./space-binding.js";
 const MAX_LINE_BYTES = 4 * 1024 * 1024;
 const socketPath = (runtimeRoot) => join(runtimeRoot, "native", "daemon.sock");
+/**
+ * `store: null` means the request was valid but nothing was applicable yet (an unbound
+ * workspace, or a transcript a harness has not written). That is not a sync failure, so
+ * clients stay silent instead of warning about it.
+ */
+export async function nativeCaptureResponse(result) {
+    if (!result.store)
+        return { ok: false, skipped: true, message: "No native capture is pending" };
+    return { ok: true, pendingTurns: (await result.store.status()).pendingTurns };
+}
 const parse = (raw) => {
     const value = JSON.parse(raw);
     if (value?.type !== "native.capture" || !["pi", "codex"].includes(value.harness)
@@ -20,14 +30,19 @@ export async function nativeDaemonSocketFor(cwd) {
     const identity = currentIdentityKey();
     if (!identity)
         return null;
-    const root = await canonicalRuntimeRoot(cwd);
+    // A vanished workspace is unbound, not an error; the terminal has nothing left to sync.
+    const root = await canonicalRuntimeRoot(cwd).catch((error) => { if (error.code === "ENOENT")
+        return null; throw error; });
+    if (!root)
+        return null;
     const binding = await getRuntimeSpaceBinding(root, identity);
     return binding ? socketPath(nativeRuntimeRoot(binding.spaceId)) : null;
 }
 export async function requestNativeDaemon(input) {
     const path = await nativeDaemonSocketFor(input.cwd);
+    // An unbound workspace is a normal state, not an error the terminal should surface.
     if (!path)
-        return { ok: false, message: "Native Runtime is not bound" };
+        return { ok: false, skipped: true, message: "Native Runtime is not bound" };
     return new Promise((resolve, reject) => {
         const socket = createConnection(path);
         let buffer = "";
@@ -88,7 +103,7 @@ export async function serveNativeDaemon(input) {
             void (async () => {
                 const request = parse(buffer.slice(0, newline));
                 const result = await input.handle(request);
-                respond({ ok: true, pendingTurns: result.store ? (await result.store.status()).pendingTurns : 0 });
+                respond(await nativeCaptureResponse(result));
             })().catch((error) => respond({ ok: false, message: error instanceof Error ? error.message : String(error) }));
         });
     });

package/dist/runtime/native-pi-extension.js

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import { requestNativeDaemon } from "./native-ipc.js";
 /** Thin native adapter. The Runtime Daemon owns Cohub auth, WS, retries and archives. */
 export default function cohubNativeExtension(pi) {
@@ -6,7 +7,6 @@ export default function cohubNativeExtension(pi) {
     let context = null;
     let captures = Promise.resolve();
     let lastError = "";
-    let timer;
     const report = (error) => {
         const message = error instanceof Error ? error.message : String(error);
         if (message !== lastError)
@@ -19,9 +19,16 @@ export default function cohubNativeExtension(pi) {
         if (!path)
             return Promise.resolve();
         captures = captures.then(async () => {
+            // Pi persists the transcript lazily; a not-yet-created file is not a sync failure.
+            if (!existsSync(path))
+                return;
             const result = await requestNativeDaemon({ harness: "pi", cwd: ctx.cwd, path, nativeSessionId: ctx.sessionManager.getSessionId(), leafId: ctx.sessionManager.getLeafId(), settled });
-            if (!result.ok)
+            // Nothing to sync yet (unbound workspace, or config not installed) is silence, not a warning.
+            if (!result.ok) {
+                if (result.skipped)
+                    return;
                 throw new Error(result.message);
+            }
             ctx.ui.setStatus("cohub", "Cohub");
             lastError = "";
         }).catch(report);
@@ -29,17 +36,10 @@ export default function cohubNativeExtension(pi) {
     };
     pi.on("session_start", async (_event, ctx) => {
         await capture(ctx, ctx.isIdle());
-        if (timer)
-            clearInterval(timer);
-        timer = setInterval(() => { void capture(ctx, ctx.isIdle()); }, 5000);
-        timer.unref();
     });
     pi.on("message_end", (_event, ctx) => capture(ctx));
     pi.on("agent_settled", (_event, ctx) => capture(ctx, true));
     pi.on("session_shutdown", async (_event, ctx) => {
-        if (timer)
-            clearInterval(timer);
-        timer = undefined;
         await captures;
         ctx.ui.setStatus("cohub", undefined);
         context = null;

package/dist/runtime/native-sync.d.ts

@@ -47,4 +47,4 @@ export declare function captureNativeSession(input: {
 }): Promise<NativeSyncStore | null>;
 /** The existing Runtime supervisor retries receipts even after the original terminal has exited. */
 export declare function nativeWebSocketTransport(spaceId: string, identity: string, send: (event: NativeRuntimeEvent) => Promise<unknown>): NativeSyncTransport;
-export declare function flushNativeSessions(spaceId: string, identity: string, signal: AbortSignal, report: (error: unknown) => void, transportOverride?: NativeSyncTransport): Promise<void>;
+export declare function flushNativeSessions(spaceId: string, identity: string, signal: AbortSignal, report: (error: unknown) => void, transportOverride?: NativeSyncTransport): Promise<boolean>;

package/dist/runtime/native-sync.js

@@ -120,6 +120,10 @@ export async function readNativeSyncConfig(runtimeRoot, identity) {
     }
 }
 const nativeStores = new Map();
+const missing = (error) => error.code === "ENOENT";
+/** Canonical alias, but a missing target reports itself instead of failing capture. */
+const canonicalPathOrNull = async (path) => canonicalRuntimeRoot(path).catch((error) => { if (missing(error))
+    return null; throw error; });
 /** Local capture only. Neither Pi callbacks nor Codex hooks wait for Cohub's network. */
 export async function captureNativeSession(input) {
     if (process.env.COHUB_TURN_ID || process.env.COHUB_EXECUTION_TOKEN)
@@ -127,7 +131,11 @@ export async function captureNativeSession(input) {
     const identity = currentIdentityKey();
     if (!identity)
         return null;
-    const root = await canonicalRuntimeRoot(input.cwd);
+    // Pi and Codex create their transcripts lazily, so a pending capture for a file that does
+    // not exist yet (or a workspace that has since been removed) is not a sync failure.
+    const root = await canonicalPathOrNull(input.cwd);
+    if (!root)
+        return null;
     const space = await getRuntimeSpaceBinding(root, identity);
     if (!space)
         return null;
@@ -135,9 +143,11 @@ export async function captureNativeSession(input) {
     const config = await readNativeSyncConfig(runtimeRoot, identity);
     if (!config || config.root !== root || config.spaceId !== space.spaceId || !config.harnesses.includes(input.harness))
         return null;
-    const path = await canonicalRuntimeRoot(input.path);
+    const path = await canonicalPathOrNull(input.path);
+    if (!path)
+        return null;
     const transcript = await readNativeTranscript(path, input.harness, input);
-    if (await canonicalRuntimeRoot(transcript.cwd) !== root || input.nativeSessionId && transcript.nativeSessionId !== input.nativeSessionId)
+    if (await canonicalPathOrNull(transcript.cwd) !== root || input.nativeSessionId && transcript.nativeSessionId !== input.nativeSessionId)
         throw new Error("Native transcript belongs to another project or Session");
     const key = JSON.stringify([identity, space.spaceId, input.harness, transcript.nativeSessionId, path]);
     let store = nativeStores.get(key);
@@ -152,8 +162,7 @@ export async function captureNativeSession(input) {
             }
         if (!store) {
             const managed = await findRuntimeNativeSession(runtimeRoot, input.harness, transcript.nativeSessionId, path);
-            const managedPath = managed ? await canonicalRuntimeRoot(managed.path).catch((error) => { if (error.code === "ENOENT")
-                return null; throw error; }) : null;
+            const managedPath = managed ? await canonicalPathOrNull(managed.path) : null;
             if (candidates.length && managedPath !== path)
                 throw new Error("Native path changed; original bindings retained");
             // Restored Pi working copies can share a native ID. Existing Cohub sidecars disambiguate them.
@@ -180,30 +189,33 @@ export function nativeWebSocketTransport(spaceId, identity, send) {
 }
 export async function flushNativeSessions(spaceId, identity, signal, report, transportOverride) {
     if (currentIdentityKey() !== identity)
-        return;
+        return false;
     const runtimeRoot = nativeRuntimeRoot(spaceId);
     const config = await readNativeSyncConfig(runtimeRoot, identity);
     if (!config || config.spaceId !== spaceId)
-        return;
+        return false;
     const transport = transportOverride;
     if (!transport)
-        return;
+        return false;
     const stores = await listNativeSyncStores(runtimeRoot, spaceId, identity, transport);
+    let failed = false;
     for (const store of stores) {
         signal.throwIfAborted();
         const binding = await store.binding();
         if (!config.harnesses.includes(binding.harness))
             continue;
         try {
-            // Codex hooks only push capture requests while its terminal lives; the Daemon keeps re-reading
-            // the transcript between hooks so Stop-flushed Turns are picked up even if a hook is missed.
+            // Codex hooks trigger captures; re-reading here also closes gaps after reconnects or missed hooks.
             if (binding.harness === "codex")
                 await store.capture(binding.path, await readNativeTranscript(binding.path, "codex"));
             await store.flush(AbortSignal.any([signal, AbortSignal.timeout(30_000)]));
         }
         catch (error) {
-            if (!signal.aborted)
+            if (!signal.aborted) {
+                failed = true;
                 report(error);
+            }
         }
     }
+    return failed;
 }

package/dist/runtime/supervisor.js

@@ -220,29 +220,81 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
             }
         };
         bridgeTask = runBridge();
-        closeNativeDaemon = await serveNativeDaemon({ runtimeRoot: store.root, handle: async (request) => ({
-                store: await captureNativeSession(request),
-            }) });
+        // Native reconciliation is event-driven: captures and channel reconnects wake it, while failures
+        // get bounded exponential retries so idle Runtimes do not scan every few seconds.
+        let nativeWakePending = true;
+        let nativeWake = null;
+        let nativeRetryTimer;
+        let nativeRetryDelay = 1000;
+        const wakeNativeSync = () => {
+            nativeWakePending = true;
+            if (nativeRetryTimer) {
+                clearTimeout(nativeRetryTimer);
+                nativeRetryTimer = undefined;
+            }
+            nativeWake?.();
+            nativeWake = null;
+        };
+        const waitForNativeWake = async () => {
+            if (nativeWakePending) {
+                nativeWakePending = false;
+                return;
+            }
+            await new Promise((resolve) => {
+                const finish = () => {
+                    signal.removeEventListener("abort", finish);
+                    if (nativeWake === finish)
+                        nativeWake = null;
+                    resolve();
+                };
+                nativeWake = finish;
+                signal.addEventListener("abort", finish, { once: true });
+                if (signal.aborted)
+                    finish();
+            });
+            nativeWakePending = false;
+        };
         nativeSyncTask = (async () => {
             const report = (error) => diagnostics.log("warn", "native.sync_pending", { error: serializeDiagnosticError(error) });
             while (!signal.aborted) {
+                await waitForNativeWake();
+                if (signal.aborted)
+                    break;
+                if (!nativeSend)
+                    continue;
+                let failed = false;
                 try {
-                    if (nativeSend)
-                        await flushNativeSessions(config.spaceId, config.identity, signal, report, nativeWebSocketTransport(config.spaceId, config.identity, nativeSend));
+                    failed = await flushNativeSessions(config.spaceId, config.identity, signal, report, nativeWebSocketTransport(config.spaceId, config.identity, nativeSend));
                 }
                 catch (error) {
-                    if (!signal.aborted)
+                    if (!signal.aborted) {
                         report(error);
+                        failed = true;
+                    }
+                }
+                if (failed && !signal.aborted) {
+                    nativeRetryTimer = setTimeout(() => { nativeRetryTimer = undefined; wakeNativeSync(); }, nativeRetryDelay);
+                    nativeRetryDelay = Math.min(30_000, nativeRetryDelay * 2);
+                }
+                else if (!failed) {
+                    nativeRetryDelay = 1000;
                 }
-                await delay(5000, undefined, { signal }).catch(() => undefined);
             }
+            if (nativeRetryTimer)
+                clearTimeout(nativeRetryTimer);
         })();
+        closeNativeDaemon = await serveNativeDaemon({ runtimeRoot: store.root, handle: async (request) => {
+                const result = { store: await captureNativeSession(request) };
+                if (result.store)
+                    wakeNativeSync();
+                return result;
+            } });
         await serveRuntime({
             spaceId: config.spaceId, cwd: config.root, url: url.toString(), capabilities,
             harnesses: config.executables, runtimeId: status.runtimeId, diagnostics, token, signal, store,
             onReady: () => update({ harnessConnected: true }),
             onDisconnected: () => { nativeSend = null; update({ harnessConnected: false }); },
-            onNativeChannel: (send) => { nativeSend = send; },
+            onNativeChannel: (send) => { nativeSend = send; wakeNativeSync(); },
         });
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "8.1.0",
+  "version": "8.1.1",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {