groove-dev 0.27.207 → 0.27.209

package/node_modules/@groove-dev/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.207",
+  "version": "0.27.209",
   "description": "GROOVE CLI — manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/node_modules/@groove-dev/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.27.207",
+  "version": "0.27.209",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/node_modules/@groove-dev/daemon/src/axom-connector.js

@@ -186,6 +186,7 @@ export class AxomConnector {
           live: !!info.live,
           ws: null,
           lastSeq: 0,
+          epoch: null,
           ring: [],
           overflow: 0,
           unknownKinds: {},
@@ -209,14 +210,35 @@ export class AxomConnector {
 
   _watchSession(ep, s) {
     if (this.destroyed) return;
-    const since = s.lastSeq > 0 ? `?since=ev-${String(s.lastSeq).padStart(6, '0')}` : '';
-    const wsUrl = `${ep.url.replace(/^http/, 'ws')}/ws/session/${encodeURIComponent(s.id)}${since}`;
+    // §16.4: reconnects carry both cursor and epoch; a stale epoch voids the
+    // cursor runtime-side and we get a full replay instead of a silent gap.
+    const params = [];
+    if (s.lastSeq > 0) params.push(`since=ev-${String(s.lastSeq).padStart(6, '0')}`);
+    if (s.epoch) params.push(`epoch=${encodeURIComponent(s.epoch)}`);
+    const query = params.length ? `?${params.join('&')}` : '';
+    const wsUrl = `${ep.url.replace(/^http/, 'ws')}/ws/session/${encodeURIComponent(s.id)}${query}`;
     const ws = new WebSocket(wsUrl);
     s.ws = ws;
 
     ws.on('message', (data) => {
       let envelope;
       try { envelope = JSON.parse(data.toString()); } catch { return; }
+      // §16.4 handshake frame — transport metadata, never a transcript event.
+      // A changed epoch means the runtime restarted and its event ids reset:
+      // our monotonic dedup would silently swallow the entire replay, so the
+      // cursor, ring, and GUI copy are all voided together.
+      if (envelope.kind === 'ws_hello') {
+        const epoch = envelope.payload?.epoch;
+        if (epoch && s.epoch && epoch !== s.epoch) {
+          s.lastSeq = 0;
+          s.ring = [];
+          s.overflow = 0;
+          s.unknownKinds = {};
+          this.daemon.broadcast({ type: 'axom:session:reset', endpoint: ep.name, session: s.id, epoch });
+        }
+        if (epoch) s.epoch = epoch;
+        return;
+      }
       const seq = seqOf(envelope.id);
       // Dedup on ring-buffer replay after reconnect — ids are monotonic.
       if (seq !== null && seq <= s.lastSeq) return;
@@ -371,6 +393,32 @@ export class AxomConnector {
 
   _broadcastStatus() {
     this.daemon.broadcast({ type: 'axom:status', data: this.status() });
+    // Runtime-level state is derived from connector state — push it too so
+    // the GUI's runtime cards move on events, not on a poll.
+    this.daemon.axomRuntimes?.broadcastStatus?.();
+  }
+
+  // Collapse the 'running but not connected' window: when a runtime is known
+  // to be answering /about, don't make the user wait out our backoff.
+  nudge(name) {
+    const ep = this.endpoints.get(name);
+    if (!ep || ep.status === 'connected' || this.destroyed) return;
+    if (ep.retryTimer) { clearTimeout(ep.retryTimer); ep.retryTimer = null; }
+    ep.backoffMs = this.backoffBaseMs;
+    this._handshake(ep);
+  }
+
+  // The inverse of nudge: after a deliberate stop, 'connected' is presumed
+  // stale — re-probe now so the endpoint transitions (and broadcasts) with the
+  // verb instead of lingering until the next scheduled poll fails.
+  recheck(name) {
+    const ep = this.endpoints.get(name);
+    if (!ep || this.destroyed) return;
+    if (ep.status === 'connected') {
+      this._pollSessions(ep).catch(() => this._endpointLost(ep));
+    } else {
+      this.nudge(name);
+    }
   }
 
   _teardownEndpoint(ep) {

package/node_modules/@groove-dev/daemon/src/axom-remote.js

@@ -55,8 +55,8 @@ export class AxomRemote {
     return this.daemon.config?.axom?.remote || null;
   }
 
-  _ssh(command, timeoutMs = 30000) {
-    const cfg = this._config();
+  _ssh(command, timeoutMs = 30000, cfgOverride = null) {
+    const cfg = cfgOverride || this._config();
     if (!cfg) return Promise.reject(new Error('no remote Axom host configured'));
     const problem = validateRemote(cfg);
     if (problem) return Promise.reject(new Error(`remote config invalid: ${problem}`));
@@ -71,14 +71,15 @@ export class AxomRemote {
   }
 
   // Is a runtime listening on the remote port right now?
-  async status() {
-    const cfg = this._config();
+  async status(cfgOverride = null) {
+    const cfg = cfgOverride || this._config();
     if (!cfg) return { configured: false, running: null };
     const port = cfg.port || AXOM_DEFAULT_PORT;
     try {
       const { stdout } = await this._ssh(
         `curl -sf --max-time 4 http://127.0.0.1:${port}/about >/dev/null 2>&1 && echo UP || echo DOWN`,
         15000,
+        cfg,
       );
       return {
         configured: true,
@@ -94,11 +95,11 @@ export class AxomRemote {
     }
   }
 
-  async start() {
-    const cfg = this._config();
+  async start(cfgOverride = null) {
+    const cfg = cfgOverride || this._config();
     if (!cfg) throw new Error('no remote Axom host configured');
     const port = cfg.port || AXOM_DEFAULT_PORT;
-    const already = await this.status();
+    const already = await this.status(cfg);
     if (already.running) return { started: false, alreadyRunning: true, port };
 
     const command = cfg.command
@@ -112,12 +113,12 @@ export class AxomRemote {
     // NOTHING while reporting success. Found by running it.
     const log = cfg.logPath || '~/axom-serve/serve.log';
     const quoted = `'${command.replace(/'/g, `'\\''`)}'`;
-    await this._ssh(`nohup bash -lc ${quoted} >> ${log} 2>&1 < /dev/null & disown; echo STARTED`, 30000);
+    await this._ssh(`nohup bash -lc ${quoted} >> ${log} 2>&1 < /dev/null & disown; echo STARTED`, 30000, cfg);
 
     // Confirm it actually came up rather than reporting optimism.
     for (let i = 0; i < 30; i++) {
       await new Promise((r) => setTimeout(r, 2000));
-      const s = await this.status();
+      const s = await this.status(cfg);
       if (s.running) {
         this.daemon.audit.log('axom.remote.start', { host: cfg.host, port });
         this._broadcast();
@@ -127,8 +128,8 @@ export class AxomRemote {
     throw new Error(`started the command but nothing answered on port ${port} within 60s — check ${log} on ${cfg.host}`);
   }
 
-  async stop({ force = false } = {}) {
-    const cfg = this._config();
+  async stop({ force = false } = {}, cfgOverride = null) {
+    const cfg = cfgOverride || this._config();
     if (!cfg) throw new Error('no remote Axom host configured');
     const port = cfg.port || AXOM_DEFAULT_PORT;
 
@@ -141,6 +142,7 @@ export class AxomRemote {
         + `-H 'Content-Type: application/json' -d '{"force":${force ? 'true' : 'false'}}' `
         + `http://127.0.0.1:${port}/shutdown`,
         20000,
+        cfg,
       );
       const code = parseInt(stdout.trim().slice(-3), 10);
       if (code === 202) {
@@ -156,7 +158,7 @@ export class AxomRemote {
 
     // Pre-§14 runtime: signal the process that owns the port. Still the
     // user's own machine, still an explicit action they asked for.
-    await this._ssh(`PID=$(lsof -t -i:${port} 2>/dev/null | head -1); [ -n "$PID" ] && kill $PID && echo KILLED || echo NOTFOUND`, 20000);
+    await this._ssh(`PID=$(lsof -t -i:${port} 2>/dev/null | head -1); [ -n "$PID" ] && kill $PID && echo KILLED || echo NOTFOUND`, 20000, cfg);
     this.daemon.audit.log('axom.remote.stop', { host: cfg.host, port, via: 'signal' });
     this._broadcast();
     return { stopped: true, via: 'signal' };
@@ -181,8 +183,8 @@ export class AxomRemote {
     }
   }
 
-  async ensureTunnel() {
-    const cfg = this._config();
+  async ensureTunnel(cfgOverride = null) {
+    const cfg = cfgOverride || this._config();
     if (!cfg) return { tunneled: false, reason: 'no remote configured' };
     const problem = validateRemote(cfg);
     if (problem) return { tunneled: false, reason: problem };