groove-dev 0.27.184 → 0.27.185

package/node_modules/@groove-dev/daemon/src/routes/innerchat.js

@@ -2,15 +2,51 @@
 
 import { MAX_EXCHANGES } from '../innerchat.js';
 
-// Agents know each other by name, not id — resolve either, preferring an
-// exact name match so `fullstack-1` never resolves to `fullstack-14`.
+// Agents know each other by name, not id. Exact matches win first so
+// `fullstack-1` never resolves to `fullstack-14`; only if nothing matches
+// exactly do we accept a single unambiguous partial, since agents routinely
+// half-remember a teammate's name. An ambiguous partial resolves to nothing
+// and the caller gets the candidate list instead of a wrong recipient.
 function resolveAgent(daemon, ref) {
   if (!ref || typeof ref !== 'string') return null;
   const all = daemon.registry.getAll();
-  return all.find((a) => a.id === ref)
+  const needle = ref.trim().toLowerCase();
+
+  const exact = all.find((a) => a.id === ref)
     || all.find((a) => a.name === ref)
-    || all.find((a) => a.name.toLowerCase() === ref.toLowerCase())
-    || null;
+    || all.find((a) => a.name.toLowerCase() === needle);
+  if (exact) return exact;
+
+  const partial = all.filter((a) => a.name.toLowerCase().includes(needle)
+    || needle.includes(a.name.toLowerCase()));
+  return partial.length === 1 ? partial[0] : null;
+}
+
+// Resolve the from/to pair from a request body, or write the appropriate
+// 400/404 and return null so the caller bails.
+function resolveParties(daemon, req, res) {
+  const { from, to, message } = req.body || {};
+
+  const fromAgent = resolveAgent(daemon, from);
+  if (!fromAgent) { res.status(404).json({ error: `Unknown calling agent: ${from}` }); return null; }
+
+  const toAgent = resolveAgent(daemon, to);
+  if (!toAgent) {
+    const others = daemon.registry.getAll().filter((a) => a.id !== fromAgent.id);
+    const needle = String(to || '').trim().toLowerCase();
+    const close = others.filter((a) => a.name.toLowerCase().includes(needle)).map((a) => a.name);
+    if (close.length > 1) {
+      res.status(404).json({ error: `"${to}" matches more than one agent — use the full name.`, didYouMean: close });
+    } else {
+      res.status(404).json({ error: `No agent named "${to}".`, availableAgents: others.map((a) => a.name) });
+    }
+    return null;
+  }
+
+  if (!message || typeof message !== 'string' || !message.trim()) {
+    res.status(400).json({ error: 'message is required' }); return null;
+  }
+  return { fromAgent, toAgent, message: message.trim() };
 }
 
 export function registerInnerChatRoutes(app, daemon) {
@@ -18,39 +54,25 @@ export function registerInnerChatRoutes(app, daemon) {
    * Ask another agent a question and BLOCK until it answers.
    *
    * This request is held open deliberately — the calling agent is waiting on
-   * it, and the response body is the other agent's reply. That's what lets two
-   * agents iterate without a human relaying between them.
+   * it, and the response body is the other agent's reply. Best for tight
+   * interface negotiation, where the finite exchange budget keeps both sides
+   * writing decision-dense messages.
    */
   app.post('/api/innerchat/ask', async (req, res) => {
     try {
-      const { from, to, message, timeoutMs } = req.body || {};
-
-      const fromAgent = resolveAgent(daemon, from);
-      if (!fromAgent) return res.status(404).json({ error: `Unknown calling agent: ${from}` });
-
-      const toAgent = resolveAgent(daemon, to);
-      if (!toAgent) {
-        const names = daemon.registry.getAll()
-          .filter((a) => a.id !== fromAgent.id)
-          .map((a) => a.name);
-        return res.status(404).json({
-          error: `No agent named "${to}".`,
-          availableAgents: names,
-        });
-      }
-
-      if (!message || typeof message !== 'string' || !message.trim()) {
-        return res.status(400).json({ error: 'message is required' });
-      }
+      const parties = resolveParties(daemon, req, res);
+      if (!parties) return;
 
       // Held open until the target answers — see the class doc in innerchat.js.
       req.setTimeout(0);
       res.setTimeout(0);
 
-      const result = await daemon.innerchat.ask(fromAgent.id, toAgent.id, message.trim(), { timeoutMs });
+      const result = await daemon.innerchat.ask(parties.fromAgent.id, parties.toAgent.id, parties.message, {
+        timeoutMs: req.body?.timeoutMs,
+      });
 
       res.json({
-        from: toAgent.name,
+        from: parties.toAgent.name,
         reply: result.reply,
         threadId: result.threadId,
         exchangesUsed: result.exchanges,
@@ -63,6 +85,36 @@ export function registerInnerChatRoutes(app, daemon) {
     }
   });
 
+  /**
+   * Send a message WITHOUT blocking — returns as soon as it's delivered. If the
+   * target replies, the reply is routed back to the sender asynchronously
+   * (resuming it if its turn ended). Best for handing off to a heads-down agent
+   * where waiting out a timeout would waste the turn.
+   */
+  app.post('/api/innerchat/tell', async (req, res) => {
+    try {
+      const parties = resolveParties(daemon, req, res);
+      if (!parties) return;
+
+      const result = await daemon.innerchat.tell(parties.fromAgent.id, parties.toAgent.id, parties.message, {
+        threadId: req.body?.threadId,
+      });
+
+      res.json({
+        ok: true,
+        to: parties.toAgent.name,
+        delivered: result.delivered,
+        threadId: result.threadId,
+        exchangesUsed: result.exchanges,
+        exchangesRemaining: result.remaining,
+        maxExchanges: MAX_EXCHANGES,
+        note: `Message delivered. ${parties.toAgent.name}'s reply, if any, will be routed back to you — you can end your turn.`,
+      });
+    } catch (err) {
+      res.status(409).json({ error: err.message });
+    }
+  });
+
   app.get('/api/innerchat/threads', (req, res) => {
     const { agentId } = req.query;
     res.json({ threads: daemon.innerchat.getThreads(agentId || null) });

package/node_modules/@groove-dev/daemon/src/routes/watch.js

@@ -0,0 +1,42 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+// Agents identify themselves by name; resolve to the live record.
+function resolveAgent(daemon, ref) {
+  if (!ref || typeof ref !== 'string') return null;
+  const all = daemon.registry.getAll();
+  return all.find((a) => a.id === ref)
+    || all.find((a) => a.name === ref)
+    || all.find((a) => a.name.toLowerCase() === ref.trim().toLowerCase())
+    || null;
+}
+
+export function registerWatchRoutes(app, daemon) {
+  // Register a watch and return immediately — the agent's turn ends, and the
+  // wake comes later when the watched thing finishes. This does NOT block.
+  app.post('/api/watch', (req, res) => {
+    try {
+      const { agent, command, until, label, timeoutMs, intervalMs } = req.body || {};
+      const who = resolveAgent(daemon, agent);
+      if (!who) return res.status(404).json({ error: `Unknown agent: ${agent}` });
+
+      const watch = daemon.watcher.create(who.id, { command, until, label, timeoutMs, intervalMs });
+      res.json({
+        ok: true,
+        watchId: watch.id,
+        message: `Watching "${watch.label}". You'll be resumed with the result when it ${watch.mode === 'command' ? 'finishes' : 'condition is met'}. You can end your turn now.`,
+      });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/watch', (req, res) => {
+    res.json({ watches: daemon.watcher.list(req.query.agentId || null) });
+  });
+
+  app.delete('/api/watch/:id', (req, res) => {
+    const ok = daemon.watcher.cancel(req.params.id);
+    if (!ok) return res.status(404).json({ error: 'Watch not found' });
+    res.json({ ok: true });
+  });
+}

package/node_modules/@groove-dev/daemon/src/watcher.js

@@ -0,0 +1,258 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+import { deliverInstruction } from './deliver.js';
+
+// Watches are bounded so a wedged process or a condition that never comes true
+// can't poll forever or hold a slot indefinitely.
+const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+const MAX_TIMEOUT_MS = 6 * 60 * 60 * 1000;
+const DEFAULT_POLL_MS = 15 * 1000;
+const MIN_POLL_MS = 3 * 1000;
+const MAX_WATCHES_PER_AGENT = 5;
+const OUTPUT_TAIL = 4000;
+
+/**
+ * Wake-on-completion for agents.
+ *
+ * An agent promises to "report back when the tests finish", but its process
+ * ends when the turn does — so nothing is left to report. A Watch lives in the
+ * daemon, not the agent's session: it outlives the turn, and when its target
+ * finishes it resumes the agent (from `completed` if need be, via the same
+ * pipe as user chat) with the outcome.
+ *
+ * Two flavours:
+ *   - command: the daemon runs a command detached and owns its lifecycle, so
+ *     it has the real exit code and output when it finishes.
+ *   - until:   the daemon polls a check command for something already running,
+ *     and wakes the agent when the check first succeeds (exit 0).
+ */
+export class Watcher {
+  constructor(daemon) {
+    this.daemon = daemon;
+    this.watches = new Map();
+  }
+
+  create(agentId, opts = {}) {
+    const agent = this.daemon.registry.get(agentId);
+    if (!agent) throw new Error('Agent not found');
+
+    const command = typeof opts.command === 'string' ? opts.command.trim() : '';
+    const until = typeof opts.until === 'string' ? opts.until.trim() : '';
+    if (!command && !until) throw new Error('Provide either "command" (run it) or "until" (poll it)');
+    if (command && until) throw new Error('Provide only one of "command" or "until"');
+
+    const active = [...this.watches.values()].filter((w) => w.agentId === agentId && w.status === 'active');
+    if (active.length >= MAX_WATCHES_PER_AGENT) {
+      throw new Error(`You already have ${MAX_WATCHES_PER_AGENT} active watches — cancel one before adding another`);
+    }
+
+    const timeoutMs = Math.min(Number(opts.timeoutMs) || DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+    const watch = {
+      id: randomUUID().slice(0, 12),
+      agentId,
+      agentName: agent.name,
+      label: (opts.label && String(opts.label).slice(0, 120)) || command || until,
+      mode: command ? 'command' : 'until',
+      command, until,
+      cwd: agent.workingDir || this.daemon.projectDir,
+      pollMs: Math.max(Number(opts.intervalMs) || DEFAULT_POLL_MS, MIN_POLL_MS),
+      timeoutMs,
+      status: 'active',
+      createdAt: Date.now(),
+      _child: null,
+      _poll: null,
+      _deadline: null,
+    };
+
+    this.watches.set(watch.id, watch);
+    watch._deadline = setTimeout(() => this._fireTimeout(watch), timeoutMs);
+    if (watch.mode === 'command') this._runCommand(watch);
+    else this._startPolling(watch);
+
+    this.daemon.audit?.log('watch.create', { id: watch.id, agent: agentId, mode: watch.mode });
+    this.daemon.broadcast?.({ type: 'watch:created', data: this._public(watch) });
+    return this._public(watch);
+  }
+
+  // ── command mode: daemon owns the process ─────────────────────
+
+  _runCommand(watch) {
+    const child = spawn('/bin/sh', ['-c', watch.command], {
+      cwd: watch.cwd,
+      env: process.env,
+      detached: false,
+    });
+    watch._child = child;
+
+    const chunks = [];
+    let bytes = 0;
+    const collect = (buf) => {
+      // Keep only the tail — a chatty build shouldn't grow this unbounded.
+      chunks.push(buf);
+      bytes += buf.length;
+      while (bytes > OUTPUT_TAIL * 2 && chunks.length > 1) bytes -= chunks.shift().length;
+    };
+    child.stdout?.on('data', collect);
+    child.stderr?.on('data', collect);
+
+    child.on('error', (err) => {
+      this._wake(watch, {
+        outcome: 'error',
+        summary: `Could not start the command: ${err.message}`,
+      });
+    });
+
+    child.on('close', (code, signal) => {
+      if (watch.status !== 'active') return; // already timed out / cancelled
+      const output = Buffer.concat(chunks).toString('utf8').slice(-OUTPUT_TAIL).trim();
+      this._wake(watch, {
+        outcome: code === 0 ? 'success' : 'failure',
+        exitCode: code,
+        signal,
+        summary: signal
+          ? `Terminated by signal ${signal}.`
+          : `Finished with exit code ${code}.`,
+        output,
+      });
+    });
+  }
+
+  // ── until mode: poll something already running ────────────────
+
+  _startPolling(watch) {
+    const tick = () => {
+      if (watch.status !== 'active') return;
+      const check = spawn('/bin/sh', ['-c', watch.until], { cwd: watch.cwd, env: process.env });
+      const chunks = [];
+      check.stdout?.on('data', (b) => chunks.push(b));
+      check.stderr?.on('data', (b) => chunks.push(b));
+      check.on('error', () => { /* transient — try again next tick */ });
+      check.on('close', (code) => {
+        if (watch.status !== 'active') return;
+        if (code === 0) {
+          const output = Buffer.concat(chunks).toString('utf8').slice(-OUTPUT_TAIL).trim();
+          this._wake(watch, { outcome: 'success', summary: 'Your watch condition is now true.', output });
+        }
+      });
+    };
+    watch._poll = setInterval(tick, watch.pollMs);
+    tick(); // check immediately — the condition may already hold
+  }
+
+  // ── firing ────────────────────────────────────────────────────
+
+  _fireTimeout(watch) {
+    if (watch.status !== 'active') return;
+    this._wake(watch, {
+      outcome: 'timeout',
+      summary: `Your watch "${watch.label}" hit its ${Math.round(watch.timeoutMs / 60000)}-minute time limit `
+        + 'without finishing. It may still be running — check on it directly.',
+    });
+  }
+
+  async _wake(watch, result) {
+    if (watch.status !== 'active') return;
+    watch.status = 'fired';
+    watch.firedAt = Date.now();
+    watch.result = result;
+    this._cleanup(watch);
+
+    const message = this._composeMessage(watch, result);
+
+    // Resolve by name, not the id we stored at creation: over a 30-minute
+    // watch the agent has very likely been chatted with and rotated to a new
+    // id. Names are stable across rotation, so this follows the agent; a
+    // purged/gone agent simply doesn't resolve and the watch is undeliverable
+    // rather than resurrecting a killed agent under a stale id.
+    const target = this.daemon.registry.getAll().find((a) => a.name === watch.agentName);
+    if (!target) {
+      watch.status = 'undeliverable';
+      watch.deliveryError = `Agent ${watch.agentName} no longer exists`;
+      this.daemon.audit?.log('watch.undeliverable', { id: watch.id, reason: 'agent gone' });
+      this.daemon.broadcast?.({ type: 'watch:fired', data: this._public(watch) });
+      return;
+    }
+
+    try {
+      const delivered = await deliverInstruction(this.daemon, target.id, message, { recordFeedback: false });
+      watch.agentId = delivered.agentId;
+      watch.status = 'delivered';
+    } catch (err) {
+      watch.status = 'undeliverable';
+      watch.deliveryError = err.message;
+      this.daemon.audit?.log('watch.undeliverable', { id: watch.id, error: err.message });
+    }
+
+    this.daemon.broadcast?.({ type: 'watch:fired', data: this._public(watch) });
+  }
+
+  _composeMessage(watch, result) {
+    const lines = [`[Watch fired — "${watch.label}"]`, '', result.summary];
+    if (result.output) {
+      lines.push('', 'Output (tail):', '```', result.output, '```');
+    }
+    lines.push('', 'This is the notification you set up earlier. Continue from here and report to the user.');
+    return lines.join('\n');
+  }
+
+  // ── lifecycle ─────────────────────────────────────────────────
+
+  cancel(id, agentId = null) {
+    const watch = this.watches.get(id);
+    if (!watch) return false;
+    if (agentId && watch.agentId !== agentId) return false;
+    if (watch.status === 'active') {
+      watch.status = 'cancelled';
+      this._cleanup(watch);
+      this.daemon.broadcast?.({ type: 'watch:cancelled', data: this._public(watch) });
+    }
+    return true;
+  }
+
+  // An agent that is killed/purged shouldn't leave watches firing into a void.
+  cancelForAgent(agentId) {
+    for (const watch of this.watches.values()) {
+      if (watch.agentId === agentId && watch.status === 'active') {
+        watch.status = 'cancelled';
+        this._cleanup(watch);
+      }
+    }
+  }
+
+  _cleanup(watch) {
+    if (watch._deadline) { clearTimeout(watch._deadline); watch._deadline = null; }
+    if (watch._poll) { clearInterval(watch._poll); watch._poll = null; }
+    if (watch._child && watch.mode === 'command' && watch.status === 'cancelled') {
+      // Only kill the process when the user/agent cancelled — a fired watch
+      // means it exited on its own.
+      try { watch._child.kill('SIGTERM'); } catch { /* already gone */ }
+    }
+    watch._child = null;
+  }
+
+  list(agentId = null) {
+    const all = [...this.watches.values()].sort((a, b) => b.createdAt - a.createdAt);
+    return (agentId ? all.filter((w) => w.agentId === agentId) : all).map((w) => this._public(w));
+  }
+
+  stop() {
+    for (const watch of this.watches.values()) {
+      if (watch._deadline) clearTimeout(watch._deadline);
+      if (watch._poll) clearInterval(watch._poll);
+      if (watch._child) { try { watch._child.kill('SIGTERM'); } catch { /* gone */ } }
+      watch._deadline = watch._poll = watch._child = null;
+    }
+  }
+
+  _public(w) {
+    return {
+      id: w.id, agentId: w.agentId, agentName: w.agentName, label: w.label,
+      mode: w.mode, command: w.command, until: w.until, status: w.status,
+      createdAt: w.createdAt, firedAt: w.firedAt || null, result: w.result || null,
+    };
+  }
+}
+
+export { DEFAULT_TIMEOUT_MS, MAX_WATCHES_PER_AGENT };

package/node_modules/@groove-dev/daemon/test/innerchat.test.js

@@ -1,7 +1,7 @@
 // GROOVE — InnerChat Tests
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { describe, it, beforeEach } from 'node:test';
+import { describe, it, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { InnerChat, MAX_EXCHANGES } from '../src/innerchat.js';
 
@@ -72,6 +72,9 @@ describe('InnerChat', () => {
     }
   });
 
+  // Clear any un-awaited ask/tell timers so the runner can exit.
+  afterEach(() => innerchat.stop());
+
   // ── The blocking round trip ───────────────────────────────
 
   it('blocks until the target answers, then resolves with the reply', async () => {
@@ -259,4 +262,71 @@ describe('InnerChat', () => {
     assert.ok(daemon.audits.some((a) => a.type === 'innerchat.ask'));
     assert.ok(daemon.audits.some((a) => a.type === 'innerchat.answer'));
   });
+
+  // ── tell: non-blocking send ───────────────────────────────
+
+  it('tell returns immediately without waiting for a reply', async () => {
+    const res = await innerchat.tell('a1', 'a2', 'heads up, spec is on disk');
+    assert.equal(res.delivered, true);
+    assert.ok(res.threadId);
+
+    // Delivered, framed as non-blocking.
+    const msg = daemon.sent.at(-1);
+    assert.equal(msg.id, 'a2');
+    assert.match(msg.msg, /sent you a message/);
+    assert.match(msg.msg, /NOT blocked/);
+  });
+
+  it('routes an async reply back to the sender, resuming it if needed', async () => {
+    await innerchat.tell('a1', 'a2', 'when you get a sec, confirm the error shape');
+    // a1 ended its turn: stopped, no loop.
+    daemon.processes._loops.delete('a1');
+    daemon.processes._running.delete('a1');
+
+    innerchat.onAgentOutput('a2', result('confirmed: {code, message}'));
+    await tick();
+
+    // Reply delivered to a1 — via resume, since it had ended.
+    const resume = daemon.resumes.at(-1);
+    assert.equal(resume.id, 'a1');
+    assert.match(resume.msg, /InnerChat reply from fullstack-14/);
+    assert.match(resume.msg, /confirmed: \{code, message\}/);
+    assert.match(resume.msg, /you were not blocking/);
+  });
+
+  it('does not block the sender or set blockedOn for a tell', async () => {
+    await innerchat.tell('a1', 'a2', 'fyi');
+    assert.equal(innerchat.blockedOn.get('a1'), undefined);
+    assert.ok(innerchat.getPending('a2'), 'still capturing the eventual reply');
+  });
+
+  it('a tell to a target already awaited is refused', async () => {
+    // Left blocking; afterEach stop() rejects it — swallow so it isn't unhandled.
+    innerchat.ask('a1', 'a2', 'blocking q').catch(() => {});
+    await tick();
+    await assert.rejects(() => innerchat.tell('a1', 'a2', 'second'), /unanswered message/);
+  });
+
+  it('ask and tell share the exchange budget', async () => {
+    const r1 = await innerchat.tell('a1', 'a2', 'one');
+    assert.equal(r1.exchanges, 1);
+    // a2 replies to the tell, freeing the slot.
+    innerchat.onAgentOutput('a2', result('ok'));
+    await tick();
+
+    const p = innerchat.ask('a1', 'a2', 'two');
+    await tick();
+    innerchat.onAgentOutput('a2', result('answer'));
+    const r2 = await p;
+    assert.equal(r2.exchanges, 2, 'tell + ask both count');
+  });
+
+  it('an async sender that vanishes is dropped quietly', async () => {
+    await innerchat.tell('a1', 'a2', 'x');
+    daemon.registry._agents.delete('a1'); // sender gone entirely
+    // Reply arrives with nobody to route to — must not throw.
+    innerchat.onAgentOutput('a2', result('late answer'));
+    await tick();
+    assert.equal(innerchat.getPending('a2'), null);
+  });
 });