@remits/remits-cli 0.1.162 → 0.1.163

package/index.js

@@ -4160,7 +4160,7 @@ const WORKLOAD_BUSY_MAX_RETRIES = 6;
  * How long to wait before retrying a request the platform refused as `WORKLOAD_BUSY`, or null when the
  * failure is anything else (or the retries are spent).
  *
- * The platform admits only a few heavyweight requests per instance and answers the rest with HTTP 429
+ * The platform admits only a few heavyweight requests at once and answers the rest with HTTP 429
  * BEFORE doing any work, so repeating the identical request is safe — which is not true of any other
  * failure, and is why this matches on the code rather than on the status alone. The wait starts at the
  * server's Retry-After and grows, with jitter so several refused agents do not come back in step.
@@ -4186,7 +4186,7 @@ async function postRidingOutBusy(api, endpoint, payload) {
     } catch (err) {
       const delayMs = workloadBusyRetryDelayMs(err, attempt, maxRetries, Math.random);
       if (delayMs == null) throw err;
-      console.error('Platform instance is busy with ' + (err.response.data.workload || 'other work') +
+      console.error('Platform is busy with ' + (err.response.data.workload || 'other work') +
         '; retrying in ' + Math.round(delayMs / 1000) + 's (' + (attempt + 1) + '/' + maxRetries + ').');
       await new Promise((resolve) => setTimeout(resolve, delayMs));
     }
@@ -9228,7 +9228,7 @@ function testRunOptionsFromFlags(flags = {}) {
 // How long a later shard of a parallel run waits for a free suite slot before the launch gives up.
 const SHARD_ADMISSION_WAIT_MS = 30 * 60 * 1000;
 
-// A start the platform refused because every suite slot on the instance is taken (safe to repeat: no work began).
+// A start the platform refused because every suite slot is taken (safe to repeat: no work began).
 function shardStartBusy(err) {
   const response = err && err.response;
   return !!(response && response.status === 429 && response.data && response.data.code === 'WORKLOAD_BUSY');
@@ -9340,7 +9340,7 @@ async function testCommand(flags) {
   };
   // Shards are started one after another (each start returns at once) and then run side by side on the platform.
   const shardStarts = [];
-  // The platform admits only a few suites per instance at once and refuses the rest as WORKLOAD_BUSY. Once one
+  // The platform admits only a few suites at once and refuses the rest as WORKLOAD_BUSY. Once one
   // of our shards is running it holds a slot it will give back, so a later shard keeps waiting for one (bounded)
   // instead of giving up after the usual retries and leaving a group that can never finish.
   const shardWaitDeadline = Date.now() + SHARD_ADMISSION_WAIT_MS;
@@ -9354,7 +9354,7 @@ async function testCommand(flags) {
         const data = err && err.response && err.response.data;
         if (shardStarts.length && shardStartBusy(err) && Date.now() < shardWaitDeadline) {
           console.error('Shard ' + (shardStarts.length + 1) + ' of ' + runOptions.parallel + ' is waiting for a free suite slot ' +
-            '(this platform instance runs a limited number of suites at once; the shards already running free them).');
+            '(the platform runs a limited number of suites at once; the shards already running free them).');
           await new Promise((resolve) => setTimeout(resolve, 10000));
           continue;
         }

package/lib/local-ai.js

@@ -354,6 +354,13 @@ function describe(state) {
   return parts.length ? ` (${parts.join('; ')})` : '';
 }
 
+// HTTP polling recovers what a WebSocket notification missed, renews worker presence (it expires after 90
+// seconds) and notices cancelled requests. With a live socket and nothing in flight, notifications carry
+// delivery and a slow poll only renews presence; otherwise poll fast. Idle `ai serve` processes had been
+// the largest share of all requests on the CLI node (2026-10-23: one request every 2s each, around the clock).
+const FAST_POLL_MS = 2000;
+const IDLE_POLL_MS = 30000;
+
 class Supervisor {
   constructor({ api, dir, worker, agent, model, log = console.error, run = runNative, clock = Date.now, onStop }) {
     Object.assign(this, { api, dir, worker, agent, model, log, run, clock, onStop });
@@ -361,14 +368,23 @@ class Supervisor {
     this.busySessions = new Set();
     this.stopping = false;
     this.polling = false;
+    this.socketReady = false;
     this.lastContact = clock();
   }
 
+  nextPollDelayMs() {
+    return this.socketReady && this.active.size === 0 ? IDLE_POLL_MS : FAST_POLL_MS;
+  }
+
   async register() { return this.api('register', { ...this.worker, agent: this.agent }); }
 
   async tick() {
-    if (this.polling || this.stopping) return;
+    if (this.stopping) return;
+    // A wakeup during a poll gets ONE follow-up poll: that poll's answer may predate the notification,
+    // and the next scheduled poll can be 30 seconds away.
+    if (this.polling) { this.pollAgain = true; return; }
     this.polling = true;
+    this.pollAgain = false;
     try {
       const work = await this.api('work');
       this.lastContact = this.clock();
@@ -402,6 +418,7 @@ class Supervisor {
         this.onStop?.();
       }
     } finally { this.polling = false; }
+    if (this.pollAgain && !this.stopping) await this.tick();
   }
 
   async handle(summary, task) {
@@ -565,7 +582,15 @@ async function command({ subcommand, flags, context, root, axios, Client, WebSoc
     console.error(`Local AI serving ${baseUrl} account ${accountId} ${dataMode}: ${agent}, worker ${worker.workerId}, capacity ${maxConcurrent}. Ctrl-C to stop.`);
     process.once('SIGINT', stop);
     process.once('SIGTERM', stop);
-    timer = setInterval(() => supervisor.tick(), 2000);
+    const schedule = () => {
+      if (supervisor.stopping) return;
+      timer = setTimeout(async () => {
+        try { await supervisor.tick(); } finally { schedule(); }
+      }, supervisor.nextPollDelayMs());
+    };
+    // A socket change re-paces at once, so losing the socket never leaves a 30-second gap.
+    const repace = () => { clearTimeout(timer); schedule(); };
+    schedule();
     const topic = session.websocketTopic || String(session.user.uuid || '').replace(/-/g, '');
     if (topic) {
       socket = new Client({
@@ -577,23 +602,34 @@ async function command({ subcommand, flags, context, root, axios, Client, WebSoc
         connectHeaders: { 'X-Auth-Token': session.token,
           'x-remits-ws-label': 'remits-cli-ai', 'x-remits-user-id': String(session.user.id) },
         onConnect: () => {
+          supervisor.socketReady = true;
+          repace();
           socket.subscribe('/topic/messages/' + topic, (message) => {
             try {
               const event = JSON.parse(message.body);
               if (event.type === 'cli_ai_request' && event.payload?.workerId === worker.workerId &&
-                  String(event.payload.accountId) === String(accountId) && event.payload.dataMode === dataMode) supervisor.tick();
+                  String(event.payload.accountId) === String(accountId) && event.payload.dataMode === dataMode) {
+                // A request that starts here needs the fast poll at once, to notice a cancellation.
+                supervisor.tick().finally(repace);
+              }
             } catch (_) { /* HTTP polling is authoritative. */ }
           });
           supervisor.tick();
         },
-        onStompError: () => console.error('Local AI WebSocket unavailable; authenticated polling continues.')
+        onWebSocketClose: () => { supervisor.socketReady = false; repace(); },
+        onStompError: () => {
+          supervisor.socketReady = false;
+          repace();
+          console.error('Local AI WebSocket unavailable; authenticated polling continues.');
+        }
       });
       socket.activate();
     }
     await supervisor.tick();
     await stopped;
   } finally {
-    clearInterval(timer);
+    if (supervisor) supervisor.stopping = true;
+    clearTimeout(timer);
     process.removeListener('SIGINT', stop);
     process.removeListener('SIGTERM', stop);
     if (socket) await socket.deactivate({ force: true });
@@ -602,5 +638,5 @@ async function command({ subcommand, flags, context, root, axios, Client, WebSoc
   }
 }
 
-module.exports = { command, help, Supervisor, runNative, nativeCommand, consumeEvent, promptFor, parseDecision,
+module.exports = { command, help, Supervisor, FAST_POLL_MS, IDLE_POLL_MS, runNative, nativeCommand, consumeEvent, promptFor, parseDecision,
   validateDecision, decisionSchema, offeredTools, continuation, assertTextRequest, stateDirectory, acquireLock, read, write, identifier };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remits/remits-cli",
-  "version": "0.1.162",
+  "version": "0.1.163",
   "description": "Local CLI for auth, component sync, and live test execution against Remits",
   "license": "MIT",
   "private": false,