groove-dev 0.27.211 → 0.27.213

package/node_modules/@groove-dev/daemon/src/tunnel-manager.js

@@ -20,6 +20,12 @@ const MAX_PORT_ATTEMPTS = 10;
 const HEALTH_INTERVAL = 30000;
 const HEALTH_TIMEOUT = 5000;
 const MAX_FAIL_COUNT = 3;
+// Long-timeout probe used to CONFIRM death before killing a tunnel — a busy
+// remote daemon can sit on /api/health well past the 5s routine probe.
+const CONFIRM_TIMEOUT = 15000;
+// At most one automatic rebuild per tunnel per window; beyond that it stays
+// disconnected rather than thrashing against a host that keeps dying.
+const REBUILD_COOLDOWN_MS = 10 * 60 * 1000;
 
 const INJECTION_CHARS = /[;|&`$(){}[\]<>!#\n\r\\]/;
 
@@ -283,9 +289,21 @@ export class TunnelManager {
     const config = this.saved.get(id);
     if (!config) throw new Error(`Remote ${id} not found`);
 
+    // An existing entry is only reusable if the tunnel actually still carries
+    // traffic. After a laptop sleep the SSH client can survive with its forward
+    // dead: the local port still ACCEPTS connections but never forwards them, so
+    // handing this back returns a port that hangs forever instead of failing —
+    // which is what left the remote GUI on a black screen. Probe before reusing,
+    // and tear it down if it's a corpse.
     if (this.active.has(id)) {
       const existing = this.active.get(id);
-      return { localPort: existing.localPort, pid: existing.pid, name: config.name };
+      if (await this._tunnelResponds(existing.localPort)) {
+        return { localPort: existing.localPort, pid: existing.pid, name: config.name };
+      }
+      console.log(`[Groove:Tunnel] ${config.name}: existing tunnel is not responding — rebuilding`);
+      // Reuse the dead tunnel's port so any GUI window pointed at it heals.
+      opts = { ...opts, preferredPort: opts.preferredPort || existing.localPort };
+      await this.disconnect(id);
     }
 
     this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'testing' } });
@@ -318,7 +336,14 @@ export class TunnelManager {
     // Establish SSH tunnel
     this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'connecting' } });
 
-    const localPort = await this._findAvailablePort();
+    // A rebuild wants its old port back: the remote GUI window is pointed at it
+    // and will self-heal over WebSocket retry only if the port stays the same.
+    let localPort;
+    if (opts.preferredPort && !(await this._isPortInUse(opts.preferredPort))) {
+      localPort = opts.preferredPort;
+    } else {
+      localPort = await this._findAvailablePort();
+    }
     const target = `${config.user}@${config.host}`;
     const keyArgs = config.sshKeyPath ? ['-i', config.sshKeyPath] : [];
 
@@ -432,11 +457,23 @@ export class TunnelManager {
     return { localPort, pid: tunnel.pid, name: config.name, url };
   }
 
+  // Does the tunnel actually serve a request, as opposed to merely holding an
+  // open listening socket? A wedged forward passes a TCP connect test but never
+  // answers, so only an HTTP round-trip proves it.
+  async _tunnelResponds(localPort, timeoutMs = this.healthTimeout ?? HEALTH_TIMEOUT) {
+    try {
+      const res = await fetch(`http://localhost:${localPort}/api/health`, {
+        signal: AbortSignal.timeout(timeoutMs),
+      });
+      return res.ok;
+    } catch { return false; }
+  }
+
   async disconnect(id) {
     const conn = this.active.get(id);
     if (!conn) return;
 
-    const { pid } = conn;
+    const { pid, localPort } = conn;
     try {
       const cmd = execFileSync('ps', ['-p', String(pid), '-o', 'command='], {
         encoding: 'utf8',
@@ -444,9 +481,20 @@ export class TunnelManager {
       }).trim();
       if (cmd.includes('ssh')) {
         process.kill(pid, 'SIGTERM');
+        // An SSH client stuck on a dead TCP session can sit on SIGTERM long
+        // enough that the next connect() finds the port still bound. Give it a
+        // moment, then stop asking politely — otherwise the leftover listener
+        // keeps answering (and hanging) on the port we're about to reuse.
+        const gone = await this._waitForExit(pid, 3000);
+        if (!gone) {
+          try { process.kill(pid, 'SIGKILL'); } catch { /* already gone */ }
+          await this._waitForExit(pid, 2000);
+        }
       }
     } catch { /* process already dead */ }
 
+    if (localPort) await this._waitForPortFree(localPort, 3000);
+
     this.active.delete(id);
 
     const config = this.saved.get(id);
@@ -873,11 +921,35 @@ export class TunnelManager {
   }
 
   async _healthCheckAll() {
+    // Reaping now awaits process death, which can outlast the interval — don't
+    // let a second pass start on top of one already tearing a tunnel down.
+    if (this._healthRunning) return;
+    this._healthRunning = true;
+    try { await this._healthCheckPass(); } finally { this._healthRunning = false; }
+  }
+
+  async _healthCheckPass() {
+    // Timers don't fire while the machine is asleep, so an interval that should
+    // have run every HEALTH_INTERVAL arriving far later means we PROBABLY just
+    // woke up — but not certainly: this daemon also blocks its event loop for
+    // long stretches (execFileSync ssh calls in test/upgrade paths), which
+    // produces the same gap on a machine that never slept. So a gap only makes
+    // tunnels *suspect* — it fast-tracks them to the confirmation ladder below.
+    // It must never lower the bar for killing one (that misdiagnosis dropped a
+    // healthy DGX tunnel twice in ten minutes).
+    const now = Date.now();
+    const gap = now - (this._lastHealthCheck || now);
+    this._lastHealthCheck = now;
+    const suspectAll = gap > HEALTH_INTERVAL * 3;
+    if (suspectAll && this.active.size > 0) {
+      console.log(`[Groove:Tunnel] ${Math.round(gap / 1000)}s timer gap (sleep or blocked loop) — verifying tunnels`);
+    }
+
     for (const [id, conn] of this.active) {
       try {
         const start = Date.now();
         const res = await fetch(`http://localhost:${conn.localPort}/api/health`, {
-          signal: AbortSignal.timeout(HEALTH_TIMEOUT),
+          signal: AbortSignal.timeout(this.healthTimeout ?? HEALTH_TIMEOUT),
         });
         if (res.ok) {
           conn.latencyMs = Date.now() - start;
@@ -889,9 +961,30 @@ export class TunnelManager {
         }
       } catch {
         conn.failCount = (conn.failCount || 0) + 1;
-        if (conn.failCount >= MAX_FAIL_COUNT) {
-          conn.healthy = false;
-          this.daemon.broadcast({ type: 'tunnel.unhealthy', data: { id } });
+        // A failed 5s probe is WEAK evidence: it can't distinguish a dead
+        // tunnel from a remote daemon that's briefly busy or our own blocked
+        // event loop. Never kill on it. Once failures accumulate (or a timer
+        // gap makes everything suspect), run the confirmation ladder, which
+        // can — a healthy verdict there resets the count.
+        if (conn.failCount >= MAX_FAIL_COUNT || suspectAll) {
+          const verdict = await this._confirmDead(conn);
+          if (verdict === 'alive') {
+            conn.failCount = 0;
+            conn.healthy = true;
+            conn._wedgedStreak = 0;
+          } else {
+            conn.healthy = false;
+            this.daemon.broadcast({ type: 'tunnel.unhealthy', data: { id } });
+            // 'wedged' (port accepts, HTTP silent even at long timeout) is the
+            // one verdict with a false-positive path — a remote event loop
+            // blocked 15s+ — so demand it twice in a row. proc-dead/port-dead
+            // are unambiguous: the ssh client is gone or nothing is listening.
+            conn._wedgedStreak = verdict === 'wedged' ? (conn._wedgedStreak || 0) + 1 : 0;
+            if (verdict !== 'wedged' || conn._wedgedStreak >= 2) {
+              await this._reapAndRebuild(id, conn, verdict);
+              continue;
+            }
+          }
         }
       }
       this.daemon.broadcast({
@@ -901,6 +994,70 @@ export class TunnelManager {
     }
   }
 
+  // Escalating evidence that a tunnel is actually dead, not merely slow:
+  //   'alive'     — answered a long-timeout HTTP probe; leave it alone
+  //   'proc-dead' — the ssh client process is gone
+  //   'port-dead' — nothing is listening on the local port
+  //   'wedged'    — port accepts TCP but HTTP never answers (dead forward)
+  async _confirmDead(conn) {
+    if (await this._tunnelResponds(conn.localPort, this.confirmTimeout ?? CONFIRM_TIMEOUT)) return 'alive';
+    if (conn.pid) {
+      try { process.kill(conn.pid, 0); } catch { return 'proc-dead'; }
+    }
+    if (!(await this._isPortInUse(conn.localPort))) return 'port-dead';
+    return 'wedged';
+  }
+
+  // Tear down a confirmed-dead tunnel and immediately rebuild it on the SAME
+  // local port. The remote GUI window points at that port and its WebSocket
+  // retries every 2s, so a same-port rebuild heals an open window without the
+  // user noticing. Only if the rebuild fails does this surface as a disconnect.
+  // Rate-limited so a genuinely dead host degrades to disconnected instead of
+  // thrashing reconnect attempts forever.
+  async _reapAndRebuild(id, conn, reason) {
+    const { localPort } = conn;
+    console.log(`[Groove:Tunnel] Tunnel ${id} confirmed dead (${reason}) — rebuilding`);
+    this.daemon.audit.log('tunnel.reap', { id, reason, failCount: conn.failCount });
+    await this.disconnect(id);
+
+    const lastRebuild = this._rebuildAt?.get(id) || 0;
+    if (Date.now() - lastRebuild < REBUILD_COOLDOWN_MS) {
+      console.log(`[Groove:Tunnel] ${id} already auto-rebuilt recently — leaving disconnected`);
+      return;
+    }
+    this._rebuildAt = this._rebuildAt || new Map();
+    this._rebuildAt.set(id, Date.now());
+
+    try {
+      this.daemon.broadcast({ type: 'tunnel.status', data: { id, step: 'reconnecting' } });
+      await this.connect(id, { preferredPort: localPort });
+      console.log(`[Groove:Tunnel] ${id} rebuilt on port ${localPort}`);
+    } catch (err) {
+      console.warn(`[Groove:Tunnel] Auto-rebuild of ${id} failed: ${err.message}`);
+      // disconnect() above already broadcast tunnel.disconnected — the GUI is
+      // consistent; the user can reconnect manually when the host is back.
+    }
+  }
+
+  // Signal 0 only tests for existence — no signal is delivered.
+  async _waitForExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      try { process.kill(pid, 0); } catch { return true; } // gone
+      await new Promise((r) => setTimeout(r, 150));
+    }
+    try { process.kill(pid, 0); return false; } catch { return true; }
+  }
+
+  async _waitForPortFree(port, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (!(await this._isPortInUse(port))) return true;
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    return !(await this._isPortInUse(port));
+  }
+
   _isPortInUse(port) {
     return new Promise((resolve) => {
       const conn = createConnection({ host: '127.0.0.1', port });

package/node_modules/@groove-dev/daemon/test/reach-hint.test.js

@@ -0,0 +1,100 @@
+// GROOVE — Agent reach hint (InnerChat discoverability)
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Spawn-prompt capabilities decay out of a long session, after which agents
+// deny they can contact anyone. These pin the per-turn hint that replaces it.
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { agentReachHint } from '../src/deliver.js';
+
+function daemonWith(agents, peers = []) {
+  return {
+    registry: { getAll: () => agents },
+    config: { innerchatPeers: peers },
+  };
+}
+
+const me = { name: 'fullstack-3', role: 'fullstack' };
+const roster = [me, { name: 'Integration-Manager', role: 'fullstack' }, { name: 'Axom-UX', role: 'frontend' }];
+
+describe('agentReachHint', () => {
+  it('always names the CLI verbs, even on an unrelated turn', () => {
+    const hint = agentReachHint(daemonWith(roster), me, 'refactor the token parser');
+    assert.match(hint, /groove ask/);
+    assert.match(hint, /groove who/);
+  });
+
+  it('rules out the built-in sub-agent tools that cannot reach GROOVE agents', () => {
+    const hint = agentReachHint(daemonWith(roster), me, 'anything');
+    assert.match(hint, /CANNOT reach them/i);
+  });
+
+  it('expands to a ready-to-run command naming the agent the user meant', () => {
+    const hint = agentReachHint(daemonWith(roster), me, 'ask Integration-Manager about the relay shape');
+    assert.match(hint, /groove ask Integration-Manager "your question here"/);
+    assert.doesNotMatch(hint, /<name>/, 'should not leave a placeholder to fill in');
+  });
+
+  it('falls back to the roster when intent is clear but the target is not', () => {
+    const hint = agentReachHint(daemonWith(roster), me, 'coordinate with the other agents on this');
+    assert.match(hint, /groove who/);
+    assert.match(hint, /Integration-Manager, Axom-UX/);
+  });
+
+  it('does not resolve a target from an ambiguous partial mention', () => {
+    const two = [me, { name: 'fullstack-1', role: 'x' }, { name: 'fullstack-2', role: 'x' }];
+    const hint = agentReachHint(daemonWith(two), me, 'ask fullstack about it');
+    assert.doesNotMatch(hint, /groove ask fullstack-1 "/);
+    assert.match(hint, /groove who/);
+  });
+
+  it('never suggests messaging yourself', () => {
+    const hint = agentReachHint(daemonWith(roster), me, 'ask fullstack-3 what it thinks');
+    assert.doesNotMatch(hint, /groove ask fullstack-3 "/);
+  });
+
+  it('mentions peer machines and the name@peer form when peers exist', () => {
+    const hint = agentReachHint(daemonWith(roster, [{ alias: 'spark' }]), me, 'ask someone about it');
+    assert.match(hint, /name@peer/);
+    assert.match(hint, /spark/);
+  });
+
+  it('stays silent when there is genuinely nobody to talk to', () => {
+    assert.equal(agentReachHint(daemonWith([me]), me, 'ask someone'), null);
+  });
+
+  // Naming the feature is an explicit request — the tier that must never rely
+  // on heuristics, because it is typically typed AFTER the agent has already
+  // claimed the capability does not exist.
+  it('re-sends the full reference when the user names InnerChat', () => {
+    for (const phrase of ['use innerChat', 'inner chat', 'inner-chat', 'InnerChat please', 'run groove ask']) {
+      const hint = agentReachHint({ port: 31415, ...daemonWith(roster) }, me, `${phrase} with the team`);
+      assert.match(hint, /Full reference/, `"${phrase}" should trigger the full block`);
+      assert.match(hint, /groove ask/);
+    }
+  });
+
+  it('tells the agent the feature is real when explicitly asked for it', () => {
+    const hint = agentReachHint({ port: 31415, ...daemonWith(roster) }, me, 'use innerchat');
+    assert.match(hint, /It exists, it is wired up/);
+    assert.match(hint, /Do not tell the user the feature is/);
+  });
+
+  it('still resolves the named target alongside the full reference', () => {
+    const hint = agentReachHint({ port: 31415, ...daemonWith(roster) }, me, 'use innerchat with Axom-UX');
+    assert.match(hint, /groove ask Axom-UX "your question here"/);
+    assert.match(hint, /Full reference/);
+  });
+
+  it('does not pay for the full reference on an ordinary turn', () => {
+    const hint = agentReachHint(daemonWith(roster), me, 'refactor the parser');
+    assert.doesNotMatch(hint, /Full reference/);
+    assert.ok(hint.length < 400, 'the always-on tier must stay cheap');
+  });
+
+  it('survives a broken registry rather than blocking delivery', () => {
+    const broken = { registry: { getAll() { throw new Error('boom'); } } };
+    assert.equal(agentReachHint(broken, me, 'ask someone'), null);
+  });
+});

package/node_modules/@groove-dev/daemon/test/tunnel-manager.test.js

@@ -0,0 +1,253 @@
+// GROOVE — TunnelManager Tests
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Regression coverage for wake-from-sleep recovery. The failure these guard
+// against: an SSH tunnel cut by a laptop sleep leaves a local listener that
+// still ACCEPTS TCP connections but never forwards them. A TCP-connect probe
+// calls that healthy, so the dead tunnel was handed out forever and the remote
+// GUI loaded a port that hung instead of failing — a black window that only a
+// full app restart cleared.
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { resolve } from 'path';
+import { createServer } from 'net';
+import { TunnelManager } from '../src/tunnel-manager.js';
+
+function makeDaemon(grooveDir) {
+  const broadcasts = [];
+  return {
+    broadcasts,
+    grooveDir,
+    projectDir: process.cwd(),
+    audit: { log() {} },
+    broadcast(m) { broadcasts.push(m); },
+  };
+}
+
+// A tunnel wedged by sleep: the socket is accepted and then ignored forever.
+function startWedgedListener() {
+  const sockets = [];
+  const server = createServer((sock) => { sockets.push(sock); });
+  return new Promise((res) => {
+    server.listen(0, '127.0.0.1', () => {
+      res({
+        port: server.address().port,
+        close: () => { for (const s of sockets) s.destroy(); server.close(); },
+      });
+    });
+  });
+}
+
+// A tunnel that works — answers /api/health like the remote daemon would.
+function startHealthyListener() {
+  const server = createServer((sock) => {
+    sock.on('data', () => {
+      const body = '{"ok":true}';
+      sock.end(
+        'HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n'
+        + `Content-Length: ${body.length}\r\nConnection: close\r\n\r\n${body}`,
+      );
+    });
+  });
+  return new Promise((res) => {
+    server.listen(0, '127.0.0.1', () => {
+      res({ port: server.address().port, close: () => server.close() });
+    });
+  });
+}
+
+describe('TunnelManager — wake-from-sleep recovery', () => {
+  let daemon, mgr, grooveDir;
+
+  beforeEach(() => {
+    grooveDir = mkdtempSync(resolve(tmpdir(), 'groove-tunnel-'));
+    daemon = makeDaemon(grooveDir);
+    mgr = new TunnelManager(daemon);
+    // Shrink probe timeouts (production: 5s routine / 15s confirm) so the
+    // wedged-listener tests don't burn real minutes waiting them out.
+    mgr.healthTimeout = 400;
+    mgr.confirmTimeout = 1200;
+  });
+
+  afterEach(() => {
+    mgr.shutdown();
+    try { rmSync(grooveDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('a TCP-accept probe cannot tell a wedged tunnel from a live one', async () => {
+    const wedged = await startWedgedListener();
+    try {
+      // This is what the old code trusted — and why the bug survived.
+      assert.equal(await mgr._isPortInUse(wedged.port), true);
+    } finally { wedged.close(); }
+  });
+
+  it('_tunnelResponds rejects a tunnel that accepts but never answers', async () => {
+    const wedged = await startWedgedListener();
+    try {
+      assert.equal(await mgr._tunnelResponds(wedged.port, 800), false);
+    } finally { wedged.close(); }
+  });
+
+  it('_tunnelResponds accepts a tunnel that actually serves', async () => {
+    const live = await startHealthyListener();
+    try {
+      assert.equal(await mgr._tunnelResponds(live.port, 3000), true);
+    } finally { live.close(); }
+  });
+
+  it('connect() rebuilds instead of handing back a wedged tunnel', async () => {
+    const wedged = await startWedgedListener();
+    try {
+      mgr.saved.set('s19', {
+        id: 's19', name: 'S19 Agency', host: 'example.invalid',
+        user: 'ops', port: 22, lastConnected: new Date().toISOString(),
+      });
+      mgr.active.set('s19', {
+        pid: 999999, localPort: wedged.port, healthy: true, failCount: 0,
+        startedAt: new Date().toISOString(),
+      });
+
+      // Host is unreachable, so the rebuild fails — the point is that it TRIED
+      // rather than returning the dead port as if it were usable.
+      await assert.rejects(
+        () => mgr.connect('s19', { skipTest: false }),
+        (err) => !/^$/.test(err.message),
+      );
+      assert.equal(mgr.active.has('s19'), false, 'the dead tunnel was torn down');
+    } finally { wedged.close(); }
+  });
+
+  it('connect() reuses a tunnel that is genuinely alive', async () => {
+    const live = await startHealthyListener();
+    try {
+      mgr.saved.set('spark', { id: 'spark', name: 'DGX Spark', host: '10.0.0.5', user: 'rok', port: 22 });
+      mgr.active.set('spark', {
+        pid: 12345, localPort: live.port, healthy: true, failCount: 0,
+        startedAt: new Date().toISOString(),
+      });
+
+      const res = await mgr.connect('spark');
+      assert.equal(res.localPort, live.port, 'a working tunnel is reused, not rebuilt');
+      assert.equal(mgr.active.has('spark'), true);
+    } finally { live.close(); }
+  });
+
+  it('the health pass reaps a proc-dead tunnel and tries to rebuild it', async () => {
+    const wedged = await startWedgedListener();
+    try {
+      mgr.saved.set('s19', { id: 's19', name: 'S19 Agency', host: 'example.invalid', user: 'ops', port: 22 });
+      mgr.active.set('s19', {
+        pid: 999999, // no such process → verdict 'proc-dead', reap on first confirm
+        localPort: wedged.port, healthy: true,
+        failCount: 99, // already past the failure limit
+        startedAt: new Date().toISOString(),
+      });
+
+      const rebuilds = [];
+      mgr.connect = async (id, opts) => { rebuilds.push({ id, opts }); throw new Error('host unreachable'); };
+
+      await mgr._healthCheckAll();
+
+      assert.equal(mgr.active.has('s19'), false, 'dead tunnel removed from active');
+      assert.equal(rebuilds.length, 1, 'an automatic rebuild was attempted');
+      assert.equal(rebuilds[0].opts.preferredPort, wedged.port, 'rebuild asks for the same port');
+      assert.ok(
+        daemon.broadcasts.some((b) => b.type === 'tunnel.unhealthy'),
+        'the GUI is told the tunnel went unhealthy',
+      );
+    } finally { wedged.close(); }
+  });
+
+  it('a slow-but-alive tunnel is never reaped — the long confirm probe clears it', async () => {
+    // Answers /api/health slower than the routine probe allows but inside the
+    // confirmation window. This is a busy DGX, not a dead tunnel.
+    const sockets = [];
+    const slow = createServer((sock) => {
+      sockets.push(sock);
+      sock.on('data', () => setTimeout(() => {
+        const body = '{"ok":true}';
+        try {
+          sock.end('HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n'
+            + `Content-Length: ${body.length}\r\nConnection: close\r\n\r\n${body}`);
+        } catch { /* closed */ }
+      }, 700));
+    });
+    await new Promise((r) => slow.listen(0, '127.0.0.1', r));
+    const port = slow.address().port;
+    try {
+      mgr.saved.set('dgx', { id: 'dgx', name: 'Axom Spark', host: 'edgexpert.local', user: 'rok', port: 22 });
+      mgr.active.set('dgx', {
+        pid: process.pid, // definitely alive
+        localPort: port, healthy: true, failCount: 99,
+        startedAt: new Date().toISOString(),
+      });
+
+      mgr.connect = async () => { throw new Error('rebuild must not be attempted'); };
+      await mgr._healthCheckAll();
+
+      const conn = mgr.active.get('dgx');
+      assert.ok(conn, 'the tunnel survived');
+      assert.equal(conn.healthy, true, 'confirmed alive by the long probe');
+      assert.equal(conn.failCount, 0, 'failure count reset');
+    } finally {
+      for (const s of sockets) s.destroy();
+      slow.close();
+    }
+  });
+
+  it('a wedged tunnel needs two consecutive confirmations before it is reaped', { timeout: 30000 }, async () => {
+    const wedged = await startWedgedListener();
+    try {
+      mgr.saved.set('s19', { id: 's19', name: 'S19 Agency', host: 'example.invalid', user: 'ops', port: 22 });
+      mgr.active.set('s19', {
+        pid: process.pid, // ssh "alive" → verdict is 'wedged', not 'proc-dead'
+        localPort: wedged.port, healthy: true, failCount: 99,
+        startedAt: new Date().toISOString(),
+      });
+      mgr.connect = async () => { throw new Error('unreachable'); };
+
+      await mgr._healthCheckAll();
+      assert.equal(mgr.active.has('s19'), true, 'first wedged verdict only flags it');
+      assert.equal(mgr.active.get('s19').healthy, false);
+
+      mgr.active.get('s19').failCount = 99; // still failing next tick
+      await mgr._healthCheckAll();
+      assert.equal(mgr.active.has('s19'), false, 'second wedged verdict reaps it');
+    } finally { wedged.close(); }
+  });
+
+  it('a timer gap fast-tracks confirmation but cannot kill a live tunnel', async () => {
+    const live = await startHealthyListener();
+    try {
+      mgr.saved.set('dgx', { id: 'dgx', name: 'Axom Spark', host: 'edgexpert.local', user: 'rok', port: 22 });
+      mgr.active.set('dgx', {
+        pid: process.pid, localPort: live.port, healthy: true, failCount: 0,
+        startedAt: new Date().toISOString(),
+      });
+
+      // 10-minute gap: sleep — or just a blocked event loop on a busy daemon.
+      mgr._lastHealthCheck = Date.now() - 10 * 60 * 1000;
+      mgr.connect = async () => { throw new Error('rebuild must not be attempted'); };
+      await mgr._healthCheckAll();
+
+      const conn = mgr.active.get('dgx');
+      assert.ok(conn, 'live tunnel survived the suspicious gap');
+      assert.equal(conn.healthy, true);
+    } finally { live.close(); }
+  });
+
+  it('_waitForPortFree reports a released port', async () => {
+    const live = await startHealthyListener();
+    assert.equal(await mgr._waitForPortFree(live.port, 600), false, 'still held while listening');
+    live.close();
+    assert.equal(await mgr._waitForPortFree(live.port, 3000), true, 'free once closed');
+  });
+
+  it('_waitForExit returns true for a pid that does not exist', async () => {
+    assert.equal(await mgr._waitForExit(999999, 500), true);
+  });
+});

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/gui",
-  "version": "0.27.211",
+  "version": "0.27.213",
   "description": "GROOVE GUI — visual agent control plane",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "groove-dev",
-  "version": "0.27.211",
+  "version": "0.27.213",
   "description": "Open-source agent orchestration layer — the AI company OS. Local model agent engine (GGUF/Ollama/llama-server), HuggingFace model browser, MCP integrations (Slack, Gmail, Stripe, 15+), agent scheduling (cron), business roles (CMO, CFO, EA). GUI dashboard, multi-agent coordination, zero cold-start, infinite sessions. Works with Claude Code, Codex, Gemini CLI, Ollama, any local model.",
   "license": "FSL-1.1-Apache-2.0",
   "author": "Groove Dev <hello@groovedev.ai> (https://groovedev.ai)",

package/packages/cli/bin/groove.js

@@ -21,6 +21,7 @@ import { disconnect } from '../src/commands/disconnect.js';
 import { remotes } from '../src/commands/remotes.js';
 import { audit } from '../src/commands/audit.js';
 import { federationPair, federationUnpair, federationList, federationStatus } from '../src/commands/federation.js';
+import { ask, tell, who } from '../src/commands/ask.js';
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 const { version } = require('../../../package.json');
@@ -74,6 +75,25 @@ program
   .option('-f, --force', 'Required when agents are still running')
   .action(nuke);
 
+// InnerChat — agent-to-agent messaging. Listed high in --help because an
+// agent that has lost the capability from context rediscovers it here.
+program
+  .command('ask <agent> <message>')
+  .description('Ask another agent a question and wait for their answer')
+  .option('--from <name>', 'your agent name (defaults to $GROOVE_AGENT_NAME)')
+  .action(ask);
+
+program
+  .command('tell <agent> <message>')
+  .description('Send another agent a message without waiting for a reply')
+  .option('--from <name>', 'your agent name (defaults to $GROOVE_AGENT_NAME)')
+  .action(tell);
+
+program
+  .command('who')
+  .description('List agents you can message with `groove ask` / `groove tell`')
+  .action(who);
+
 program
   .command('rotate <id>')
   .description('Rotate an agent (kill + respawn with fresh context)')

package/packages/cli/package.json

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

package/packages/cli/src/client.js

@@ -33,8 +33,15 @@ export async function apiCall(method, path, body) {
   const res = await fetch(url, options);
 
   if (!res.ok) {
-    const err = await res.json().catch(() => ({ error: res.statusText }));
-    throw new Error(err.error || `HTTP ${res.status}`);
+    const body = await res.json().catch(() => ({ error: res.statusText }));
+    const err = new Error(body.error || `HTTP ${res.status}`);
+    // Carry the response body onto the error. The daemon's actionable fields
+    // (availableAgents, didYouMean, note) are the whole point of its error
+    // messages — dropping them leaves the caller with a dead end.
+    err.status = res.status;
+    err.body = body;
+    Object.assign(err, body);
+    throw err;
   }
 
   return res.json();