@neta-art/cohub-cli 8.0.1 → 8.1.1

package/dist/runtime/supervisor.js

@@ -41,7 +41,6 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
         pid: process.pid, harnesses: config.harnesses, background: config.background,
         state: "starting", harnessConnected: false, workspaceConnected: false,
         diagnosticsPath: diagnostics.directory,
-        nativeSync: true,
     };
     let hasBeenReady = false;
     const update = (patch) => {
@@ -221,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.0.1",
+  "version": "8.1.1",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -22,7 +22,7 @@
     "commander": "^15.0.0",
     "pixi.js": "^8.20.1",
     "sharp": "^0.35.4",
-    "@neta-art/cohub": "8.21.0"
+    "@neta-art/cohub": "8.21.1"
   },
   "publishConfig": {
     "access": "public"