groove-dev 0.27.211 → 0.27.213

package/packages/cli/src/commands/ask.js

@@ -0,0 +1,99 @@
+// GROOVE CLI — InnerChat ask/tell/who
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Agent-to-agent messaging as first-class CLI verbs.
+//
+// The HTTP endpoints came first, and agents were taught them via a curl
+// snippet in the spawn prompt. That decays: on a long session the snippet
+// scrolls out of context and the agent no longer knows the capability exists,
+// or half-remembers it and reaches for a built-in tool that cannot see GROOVE
+// agents. A CLI verb survives that — an agent that has forgotten the details
+// can still run `groove --help` or simply guess `groove ask`, and the command
+// itself explains the rest.
+
+import chalk from 'chalk';
+import { apiCall } from '../client.js';
+
+// The caller is almost always an agent, and the daemon injects its identity
+// into the environment — so `--from` is a manual override, not a requirement.
+function resolveFrom(opts) {
+  const from = opts.from || process.env.GROOVE_AGENT_NAME;
+  if (!from) {
+    console.error(chalk.red('  Could not tell who is asking.'));
+    console.error(chalk.dim('  Pass --from <your-agent-name> (GROOVE_AGENT_NAME is unset — are you running outside an agent?)'));
+    process.exit(1);
+  }
+  return from;
+}
+
+function reportError(err, to) {
+  console.error(chalk.red('  Failed:'), err.message);
+  // The daemon returns actionable bodies (unknown name + roster, ambiguous
+  // name + candidates, exchange cap). Surface them rather than a bare status.
+  if (err.availableAgents?.length) {
+    console.error(chalk.dim(`  Agents you can reach: ${err.availableAgents.join(', ')}`));
+  }
+  if (err.didYouMean?.length) {
+    console.error(chalk.dim(`  "${to}" is ambiguous — did you mean: ${err.didYouMean.join(', ')}?`));
+  }
+  process.exit(1);
+}
+
+export async function ask(to, message, opts = {}) {
+  const from = resolveFrom(opts);
+  try {
+    console.error(chalk.dim(`  Asking ${to}… (this blocks until they answer — that is expected)`));
+    const res = await apiCall('POST', '/api/innerchat/ask', { from, to, message });
+    // The reply goes to stdout alone so it can be piped/read cleanly; the
+    // status chatter goes to stderr.
+    console.log(res.reply);
+    if (res.exchangesRemaining !== undefined) {
+      console.error(chalk.dim(`  (${res.exchangesRemaining} exchanges left in this conversation)`));
+    }
+  } catch (err) {
+    reportError(err, to);
+  }
+}
+
+export async function tell(to, message, opts = {}) {
+  const from = resolveFrom(opts);
+  try {
+    const res = await apiCall('POST', '/api/innerchat/tell', { from, to, message });
+    console.error(chalk.green('  Delivered.'), chalk.dim(res.note || `${to} will reply later if needed.`));
+  } catch (err) {
+    reportError(err, to);
+  }
+}
+
+// Who can I talk to? The question an agent asks first when it has lost the
+// roster from context — and the reason it otherwise starts guessing names.
+export async function who() {
+  try {
+    const me = process.env.GROOVE_AGENT_NAME;
+    const data = await apiCall('GET', '/api/agents');
+    const agents = Array.isArray(data) ? data : (data.agents || []);
+    const others = agents.filter((a) => a.name !== me);
+
+    if (!others.length) {
+      console.log(chalk.dim('  No other agents are running right now.'));
+    } else {
+      console.log(chalk.bold('  Agents you can message:'));
+      for (const a of others) {
+        const status = a.status === 'running' ? chalk.green('●') : chalk.dim('○');
+        console.log(`    ${status} ${chalk.bold(a.name)} ${chalk.dim(`(${a.role}${a.status !== 'running' ? `, ${a.status}` : ''})`)}`);
+      }
+    }
+
+    const peers = await apiCall('GET', '/api/innerchat/peers').catch(() => ({ peers: [] }));
+    if (peers.peers?.length) {
+      console.log(chalk.bold('\n  Peer machines (address as name@peer):'));
+      for (const p of peers.peers) console.log(`    ${chalk.bold('@' + p.alias)} ${chalk.dim(p.url)}`);
+    }
+
+    console.log(chalk.dim('\n  groove ask <name> "<question>"   — blocks until they answer'));
+    console.log(chalk.dim('  groove tell <name> "<message>"   — returns immediately'));
+  } catch (err) {
+    console.error(chalk.red('  Failed:'), err.message);
+    process.exit(1);
+  }
+}

package/packages/daemon/package.json

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

package/packages/daemon/src/deliver.js

@@ -2,6 +2,7 @@
 
 import { wrapWithRoleReminder } from './process.js';
 import { getProvider } from './providers/index.js';
+import { innerChatInstructions } from './innerchat-docs.js';
 
 // Reviving a >5M-token claude session has crashed the CLI mid-HTTP-parse
 // (V8 fatal in JsonStringifier) — past this ceiling the rotator's handoff
@@ -42,7 +43,12 @@ export async function deliverInstruction(daemon, agentId, message, opts = {}) {
   // and the user's direction, not by how much context has piled up.
   const clock = daemon.processes.sessionClock?.(agent);
   const timedMessage = clock ? `${clock}\n\n${finalMessage}` : finalMessage;
-  const wrappedMessage = wrapWithRoleReminder(agent.role, timedMessage);
+  // Spawn-prompt capabilities scroll out of a long session, after which the
+  // agent denies it can reach other agents at all. This rides every turn, so
+  // it cannot decay — terse by default, expanded when the turn actually asks
+  // the agent to contact someone.
+  const reach = agentReachHint(daemon, agent, finalMessage);
+  const wrappedMessage = wrapWithRoleReminder(agent.role, reach ? `${reach}\n\n${timedMessage}` : timedMessage);
 
   // Agent loop path — send straight to the running loop.
   if (daemon.processes.hasAgentLoop(agentId)) {
@@ -132,3 +138,97 @@ async function respawn(daemon, config) {
     throw spawnErr;
   }
 }
+
+// Phrases that mean "go talk to another agent". Deliberately broad: a false
+// positive costs a few tokens of accurate instruction, a false negative costs
+// the user a turn spent watching their agent claim the capability isn't real.
+const CONTACT_INTENT = /\b(ask|message|msg|tell|consult|coordinate|check|sync|reach out|talk|speak|ping|liaise|confer|follow up|loop in)\b/i;
+
+// Naming the feature is an EXPLICIT request for it — usually typed after the
+// agent has already failed to find it. That earns the full instructions
+// verbatim, not a hint: no inference, no heuristic that can miss. Matches
+// innerchat / inner chat / inner-chat / InnerChat, and the CLI verbs by name.
+const INNERCHAT_KEYWORD = /\b(inner[\s_-]?chat|groove\s+(?:ask|tell|who))\b/i;
+
+/**
+ * A capability line appended to every delivered turn.
+ *
+ * Spawn-time instructions decay — on a long session (or under a model that
+ * compacts aggressively) they scroll away, and the agent then insists it has
+ * no way to contact anyone, or reaches for a built-in sub-agent tool that
+ * cannot see GROOVE agents. Two tiers:
+ *
+ *   - Always: one terse line naming the CLI verbs. ~20 tokens.
+ *   - When the turn expresses intent to contact someone: the exact command,
+ *     with the target's real name already filled in.
+ */
+export function agentReachHint(daemon, agent, message) {
+  let others;
+  try {
+    others = (daemon.registry.getAll() || []).filter((a) => a.name !== agent.name);
+  } catch { return null; }
+
+  const peers = Array.isArray(daemon.config?.innerchatPeers) ? daemon.config.innerchatPeers : [];
+  if (!others.length && !peers.length) return null;
+
+  const base = '[You can talk to other GROOVE agents: `groove ask <name> "<question>"` waits for their '
+    + 'answer, `groove tell <name> "<message>"` does not. `groove who` lists who is reachable. '
+    + 'Your own built-in sub-agent/task tools CANNOT reach them.]';
+
+  const explicit = INNERCHAT_KEYWORD.test(message);
+  if (!explicit && !CONTACT_INTENT.test(message)) return base;
+
+  // Name the agent the user is actually pointing at, so the model has a
+  // runnable command rather than a template it has to fill in from memory.
+  const lower = message.toLowerCase();
+  const named = others.filter((a) => lower.includes(a.name.toLowerCase()));
+  const target = named.length === 1 ? named[0] : null;
+
+  const lines = [
+    '[REACHING ANOTHER AGENT — this capability is real and available right now.]',
+  ];
+  if (explicit) {
+    // The user named the feature. Say plainly that it exists, since the usual
+    // failure is the agent asserting it doesn't and stopping there.
+    lines.push(
+      'The user explicitly asked you to use InnerChat. It exists, it is wired up, and the',
+      'commands below work from your shell right now. Do not tell the user the feature is',
+      'unavailable and do not ask them how to use it — run the command.',
+      '',
+    );
+  }
+  if (target) {
+    lines.push(
+      `To contact ${target.name}, run exactly:`,
+      `    groove ask ${target.name} "your question here"`,
+      'That blocks until they answer and prints their reply. Use `groove tell` instead if you '
+      + 'do not need the answer before continuing.',
+    );
+  } else {
+    lines.push(
+      '    groove who                         — list who is reachable',
+      '    groove ask <name> "<question>"     — blocks until they answer, prints the reply',
+      '    groove tell <name> "<message>"     — returns immediately',
+      `Agents reachable now: ${others.map((a) => a.name).join(', ') || '(none)'}`,
+    );
+  }
+  if (peers.length) {
+    lines.push(`Agents on peer machines use name@peer (peers: ${peers.map((p) => p.alias).join(', ')}).`);
+  }
+  lines.push(
+    'Do NOT use your built-in sub-agent/Task/SendMessage tools for this — they cannot see GROOVE '
+    + 'agents and will fail. If a name is wrong the command tells you the valid ones; read it and retry.',
+  );
+
+  // Explicit request → re-attach the full reference, so the agent has the
+  // complete semantics (blocking vs not, exchange budget, peer addressing)
+  // even if the spawn prompt scrolled away long ago.
+  if (explicit) {
+    lines.push(
+      '',
+      '--- Full reference (re-sent because you asked for InnerChat by name) ---',
+      ...innerChatInstructions(daemon.port || 31415, agent.name, peers),
+    );
+  }
+  return lines.join('\n');
+}

package/packages/daemon/src/innerchat-docs.js

@@ -21,14 +21,26 @@ export function innerChatInstructions(port = 31415, agentName = 'YOUR_NAME', pee
     '',
     'Other GROOVE agents may be working alongside you, including on other teams.',
     'When the user asks you to reach out to, coordinate with, or get input from',
-    'another agent, use this — it sends them a message and waits for their reply:',
+    'another agent, use the `groove` CLI — it is already installed and on your PATH:',
     '',
-    '> **Do NOT use your built-in `SendMessage` / Agent tools to reach a GROOVE agent.**',
-    '> Those only address sub-agents you spawned yourself in this session, so they will',
-    '> fail with "not reachable" or ask you for an `a…-…` agent ID that does not exist',
-    '> here. GROOVE agents are separate processes. The curl below is the only way to',
-    '> reach them. Do not invent a fallback (writing a message into a file, etc.) —',
-    '> if the curl fails, read the error and report it to the user.',
+    '```bash',
+    'groove who                              # who can I reach right now?',
+    'groove ask <AGENT_NAME> "<QUESTION>"    # send + WAIT for their answer',
+    'groove tell <AGENT_NAME> "<MESSAGE>"    # send without waiting',
+    '```',
+    '',
+    '`groove ask` prints their reply to stdout. It knows who you are from your',
+    'environment, so there is no id or token to look up. If you get the name wrong,',
+    'the error lists the valid names — read it and retry rather than giving up.',
+    '',
+    '> **Do NOT use your built-in `SendMessage` / Task / sub-agent tools to reach a**',
+    '> **GROOVE agent.** Those only address sub-agents you spawned yourself in this',
+    '> session, so they will fail with "not reachable" or ask you for an `a…-…` agent',
+    '> ID that does not exist here. GROOVE agents are separate processes. Do not invent',
+    '> a fallback (writing a message into a file, etc.) — if the command fails, read the',
+    '> error and report it to the user.',
+    '',
+    'If the `groove` CLI is somehow unavailable, the same thing over HTTP:',
     '',
     '```bash',
     `curl -s http://localhost:${port}/api/innerchat/ask -X POST -H 'Content-Type: application/json' \\`,
@@ -54,6 +66,12 @@ export function innerChatInstructions(port = 31415, agentName = 'YOUR_NAME', pee
     'delivered back to you later, waking you if your turn has ended:',
     '',
     '```bash',
+    'groove tell <AGENT_NAME> "<MESSAGE>"',
+    '```',
+    '',
+    'Or over HTTP:',
+    '',
+    '```bash',
     `curl -s http://localhost:${port}/api/innerchat/tell -X POST -H 'Content-Type: application/json' \\`,
     `  -d '{"from":"${agentName}","to":"AGENT_NAME","message":"YOUR_MESSAGE"}'`,
     '```',

package/packages/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/packages/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",