groove-dev 0.27.211 → 0.27.213

package/CLAUDE.md

@@ -295,11 +295,3 @@ Audit-driven release. Multi-agent orchestration system with 7 coordination layer
 - Dashboard: routing donut, cache panel, context health gauges
 - Monitor/QC agent mode (stay active, loop)
 - Distribution: demo video, HN launch, Twitter content
-
-<!-- GROOVE:START -->
-## GROOVE Orchestration (auto-injected)
-Active agents: 0
-See AGENTS_REGISTRY.md for full agent state, the names of agents on other teams,
-and how to consult them directly (InnerChat).
-**Memory policy:** GROOVE manages project memory automatically. Do not read or write MEMORY.md or .groove/memory/ files directly.
-<!-- GROOVE:END -->

package/daemon-bridge.js

@@ -0,0 +1,87 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+import { existsSync, readdirSync } from 'fs';
+import { createRequire } from 'module';
+import { dirname, join } from 'path';
+import { pathToFileURL } from 'url';
+
+const port = 31415;
+const projectDir = process.argv[2] || process.cwd();
+
+function preflightCheck(daemonPath) {
+  if (!existsSync(daemonPath)) {
+    throw new Error(
+      `Daemon entry point not found at ${daemonPath}. ` +
+      'The app may not have been packaged correctly — try reinstalling Groove.'
+    );
+  }
+
+  const daemonDir = dirname(daemonPath);
+  const require = createRequire(daemonPath);
+  const critical = ['express', 'ws'];
+  const missing = critical.filter(dep => {
+    try { require.resolve(dep); return false; } catch { return true; }
+  });
+
+  if (missing.length) {
+    const diag = [`Missing deps: ${missing.join(', ')}`, `GROOVE_DAEMON_PATH: ${daemonPath}`];
+    let walkDir = daemonDir;
+    for (let i = 0; i < 5 && walkDir !== dirname(walkDir); i++) {
+      try {
+        const entries = readdirSync(walkDir);
+        diag.push(`${walkDir}/: [${entries.join(', ')}]`);
+      } catch { diag.push(`${walkDir}/: (unreadable)`); }
+      walkDir = dirname(walkDir);
+    }
+    throw new Error(
+      `Daemon is missing dependencies. ` +
+      `Diagnostics:\n${diag.join('\n')}\n` +
+      'The app bundle may be incomplete — try reinstalling Groove.'
+    );
+  }
+}
+
+async function main() {
+  let Daemon;
+  const daemonPath = process.env.GROOVE_DAEMON_PATH;
+
+  if (daemonPath) {
+    preflightCheck(daemonPath);
+    const mod = await import(pathToFileURL(daemonPath).href);
+    Daemon = mod.Daemon;
+  } else {
+    const mod = await import('@groove-dev/daemon');
+    Daemon = mod.Daemon;
+  }
+
+  const daemon = new Daemon({ port, projectDir });
+  await daemon.start();
+
+  process.send({ type: 'ready', port: daemon.port });
+
+  process.on('message', (msg) => {
+    if (msg.type === 'auth-token') {
+      (async () => {
+        try { await daemon.setAuthToken(msg.token); } catch (err) {
+          process.stderr.write(`[daemon-bridge] setAuthToken failed: ${err.message}\n`);
+        }
+      })();
+    }
+  });
+
+  process.on('SIGTERM', async () => {
+    await daemon.stop();
+    process.exit(0);
+  });
+
+  process.on('SIGINT', async () => {
+    await daemon.stop();
+    process.exit(0);
+  });
+}
+
+main().catch((err) => {
+  if (process.send) {
+    process.send({ type: 'error', message: err.message });
+  }
+  process.exit(1);
+});

package/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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();

package/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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/node_modules/@groove-dev/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"}'`,
     '```',