groove-dev 0.27.172 → 0.27.174

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

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

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

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

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

@@ -27,6 +27,7 @@ import { registerIntegrationRoutes } from './routes/integrations.js';
 import { registerFileRoutes, resetEditorRoot } from './routes/files.js';
 import { registerNetworkRoutes } from './routes/network.js';
 import { registerScheduleRoutes } from './routes/schedules.js';
+import { registerInnerChatRoutes } from './routes/innerchat.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkgVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
@@ -175,6 +176,7 @@ export function createApi(app, daemon) {
   registerFileRoutes(app, daemon);
   registerNetworkRoutes(app, daemon);
   registerScheduleRoutes(app, daemon);
+  registerInnerChatRoutes(app, daemon);
 
 
   // Token usage

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

@@ -46,6 +46,7 @@ import { MLXServerManager } from './mlx-server.js';
 import { RepoImporter } from './repo-import.js';
 import { ConversationManager } from './conversations.js';
 import { Toys } from './toys.js';
+import { InnerChat } from './innerchat.js';
 import { TrajectoryCapture, ConsentManager } from '../../../moe-training/client/index.js';
 import { isFirstRun, runFirstTimeSetup, loadConfig, saveConfig, printWelcome } from './firstrun.js';
 import { bindDaemon as bindGrooveNetworkDaemon } from './providers/groove-network.js';
@@ -158,6 +159,7 @@ export class Daemon {
     this.repoImporter = new RepoImporter(this);
     this.modelLab = new ModelLab(this);
     this.toys = new Toys(this);
+    this.innerchat = new InnerChat(this);
     this.trajectoryCapture = null;
 
     // Hook teams.delete to clean up agent-loop session files

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

@@ -0,0 +1,100 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { randomUUID } from 'crypto';
+
+export class InnerChat {
+  constructor(daemon) {
+    this.daemon = daemon;
+    this.messages = new Map();
+    this.pendingResponses = new Map();
+  }
+
+  async send(fromAgentId, toAgentId, message) {
+    const fromAgent = this.daemon.registry.get(fromAgentId);
+    const toAgent = this.daemon.registry.get(toAgentId);
+    if (!fromAgent) throw new Error(`Sender agent ${fromAgentId} not found`);
+    if (!toAgent) throw new Error(`Target agent ${toAgentId} not found`);
+
+    const id = randomUUID().slice(0, 12);
+    const msg = {
+      id,
+      from: { id: fromAgent.id, name: fromAgent.name, role: fromAgent.role },
+      to: { id: toAgent.id, name: toAgent.name, role: toAgent.role },
+      message,
+      response: null,
+      status: 'sent',
+      timestamp: Date.now(),
+      respondedAt: null,
+    };
+
+    this.messages.set(id, msg);
+    this.pendingResponses.set(toAgentId, id);
+
+    const wrapped = `[InnerChat from ${fromAgent.name} (${fromAgent.role})]\n\n${message}\n\nReply normally — your response will be relayed back to ${fromAgent.name}.`;
+
+    let deliveryStatus = 'sent';
+    if (this.daemon.processes.hasAgentLoop(toAgentId)) {
+      const sent = await this.daemon.processes.sendMessage(toAgentId, wrapped, 'agent');
+      deliveryStatus = sent ? 'delivered' : 'queued';
+    } else if (this.daemon.processes.isRunning(toAgentId)) {
+      this.daemon.processes.queueMessage(toAgentId, wrapped);
+      deliveryStatus = 'queued';
+    } else {
+      throw new Error(`Target agent ${toAgent.name} is not running`);
+    }
+
+    msg.status = deliveryStatus;
+    this.daemon.broadcast({ type: 'innerchat:sent', data: msg });
+    this.daemon.audit.log('innerchat.send', { id, from: fromAgentId, to: toAgentId });
+
+    return msg;
+  }
+
+  onAgentOutput(agentId, output) {
+    const messageId = this.pendingResponses.get(agentId);
+    if (!messageId) return;
+    if (output.type !== 'result') return;
+
+    const msg = this.messages.get(messageId);
+    if (!msg) return;
+
+    let responseText = '';
+    if (typeof output.data === 'string') {
+      responseText = output.data;
+    } else if (Array.isArray(output.data)) {
+      responseText = output.data.filter(b => b.type === 'text').map(b => b.text).join('\n');
+    }
+    if (!responseText.trim()) return;
+
+    msg.response = responseText.trim();
+    msg.status = 'responded';
+    msg.respondedAt = Date.now();
+    this.pendingResponses.delete(agentId);
+
+    const relay = `[InnerChat reply from ${msg.to.name} (${msg.to.role})]\n\n${msg.response}`;
+    const senderId = msg.from.id;
+    if (this.daemon.processes.hasAgentLoop(senderId)) {
+      this.daemon.processes.sendMessage(senderId, relay, 'agent').catch(() => {});
+    } else if (this.daemon.processes.isRunning(senderId)) {
+      this.daemon.processes.queueMessage(senderId, relay);
+    }
+
+    this.daemon.broadcast({ type: 'innerchat:response', data: msg });
+    this.daemon.audit.log('innerchat.response', { id: messageId, from: msg.from.id, to: msg.to.id });
+  }
+
+  getMessages(agentId = null) {
+    const all = Array.from(this.messages.values());
+    if (!agentId) return all;
+    return all.filter(m => m.from.id === agentId || m.to.id === agentId);
+  }
+
+  getMessage(id) {
+    return this.messages.get(id) || null;
+  }
+
+  getPending(agentId) {
+    const messageId = this.pendingResponses.get(agentId);
+    return messageId ? this.messages.get(messageId) : null;
+  }
+}

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

@@ -1582,6 +1582,11 @@ For normal file edits within your scope, proceed without review.
 
     registry.update(agentId, updates);
 
+    // Notify innerchat for response capture
+    if (this.daemon.innerchat) {
+      this.daemon.innerchat.onAgentOutput(agentId, output);
+    }
+
     // Throttle streaming broadcasts to 4/sec per agent
     const isStreaming = output.type !== 'result';
     if (isStreaming) {

package/node_modules/@groove-dev/daemon/src/providers/claude-code.js

@@ -39,6 +39,7 @@ export class ClaudeCodeProvider extends Provider {
   static authType = 'subscription';
   static managesOwnContext = true; // Claude Code compacts context internally (~25-37% → 2-8%)
   static models = [
+    { id: 'claude-fable-5', name: 'Claude Fable 5', tier: 'heavy', contextWindow: 1_000_000 },
     { id: 'claude-opus-4-8', name: 'Claude Opus 4.8', tier: 'heavy', contextWindow: 1_000_000 },
     { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', tier: 'heavy', contextWindow: 1_000_000 },
     { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6', tier: 'medium', contextWindow: 200_000 },
@@ -74,7 +75,7 @@ export class ClaudeCodeProvider extends Provider {
   normalizeConfig(config) {
     if (typeof config.reasoningEffort === 'number') {
       const e = config.reasoningEffort;
-      config.effort = e <= 20 ? 'none' : e <= 40 ? 'low' : e <= 60 ? 'medium' : e <= 80 ? 'high' : 'xhigh';
+      config.effort = e <= 15 ? 'none' : e <= 30 ? 'low' : e <= 50 ? 'medium' : e <= 70 ? 'high' : e <= 85 ? 'xhigh' : 'ultra';
     }
     return config;
   }

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

@@ -0,0 +1,34 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+export function registerInnerChatRoutes(app, daemon) {
+  app.post('/api/innerchat/send', async (req, res) => {
+    try {
+      const { from, to, message } = req.body;
+      if (!from || typeof from !== 'string') return res.status(400).json({ error: 'from (agent ID) is required' });
+      if (!to || typeof to !== 'string') return res.status(400).json({ error: 'to (agent ID) is required' });
+      if (!message || typeof message !== 'string' || !message.trim()) return res.status(400).json({ error: 'message is required' });
+      if (from === to) return res.status(400).json({ error: 'cannot send a message to yourself' });
+
+      const msg = await daemon.innerchat.send(from, to, message.trim());
+      res.json(msg);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/innerchat/messages', (req, res) => {
+    const { agentId } = req.query;
+    res.json({ messages: daemon.innerchat.getMessages(agentId || null) });
+  });
+
+  app.get('/api/innerchat/messages/:id', (req, res) => {
+    const msg = daemon.innerchat.getMessage(req.params.id);
+    if (!msg) return res.status(404).json({ error: 'Message not found' });
+    res.json(msg);
+  });
+
+  app.get('/api/innerchat/pending/:agentId', (req, res) => {
+    const pending = daemon.innerchat.getPending(req.params.agentId);
+    res.json({ pending: pending || null });
+  });
+}

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

@@ -112,7 +112,7 @@ export function validateAgentConfig(config) {
     if (!isNaN(v) && v >= 0 && v <= 100) verbosity = Math.round(v);
   }
 
-  const validEffort = ['min', 'low', 'default', 'high', 'max'];
+  const validEffort = ['min', 'low', 'default', 'high', 'max', 'ultra'];
   const effort = validEffort.includes(config.effort) ? config.effort : undefined;
 
   const validRouting = ['fixed', 'auto', 'auto-floor'];
@@ -227,7 +227,7 @@ export function validateGatewayConfig(config) {
   };
 }
 
-const VALID_REASONING_EFFORTS = ['none', 'low', 'medium', 'high', 'xhigh'];
+const VALID_REASONING_EFFORTS = ['none', 'low', 'medium', 'high', 'xhigh', 'ultra'];
 const VALID_VERBOSITIES = ['low', 'medium'];
 
 export function validateReasoningEffort(value) {

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

@@ -0,0 +1,203 @@
+// GROOVE — InnerChat Tests
+// FSL-1.1-Apache-2.0 — see LICENSE
+
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { InnerChat } from '../src/innerchat.js';
+
+function makeDaemon() {
+  const broadcasts = [];
+  const audits = [];
+  const sentMessages = [];
+  const queuedMessages = [];
+
+  return {
+    broadcasts,
+    audits,
+    sentMessages,
+    queuedMessages,
+    registry: {
+      _agents: new Map(),
+      get(id) { return this._agents.get(id) || null; },
+      add(agent) { this._agents.set(agent.id, agent); },
+    },
+    processes: {
+      _loops: new Set(),
+      _running: new Set(),
+      hasAgentLoop(id) { return this._loops.has(id); },
+      isRunning(id) { return this._running.has(id); },
+      async sendMessage(id, msg, source) {
+        sentMessages.push({ id, msg, source });
+        return true;
+      },
+      queueMessage(id, msg) {
+        queuedMessages.push({ id, msg });
+      },
+    },
+    broadcast(msg) { broadcasts.push(msg); },
+    audit: { log(type, data) { audits.push({ type, data }); } },
+  };
+}
+
+describe('InnerChat', () => {
+  let daemon;
+  let innerchat;
+
+  beforeEach(() => {
+    daemon = makeDaemon();
+    innerchat = new InnerChat(daemon);
+    daemon.innerchat = innerchat;
+
+    daemon.registry.add({ id: 'a1', name: 'fullstack-1', role: 'fullstack' });
+    daemon.registry.add({ id: 'a2', name: 'fullstack-14', role: 'fullstack' });
+    daemon.processes._loops.add('a2');
+    daemon.processes._running.add('a2');
+  });
+
+  it('should send a message between agents', async () => {
+    const msg = await innerchat.send('a1', 'a2', 'What endpoint shape are you using?');
+    assert.ok(msg.id);
+    assert.equal(msg.from.id, 'a1');
+    assert.equal(msg.from.name, 'fullstack-1');
+    assert.equal(msg.to.id, 'a2');
+    assert.equal(msg.to.name, 'fullstack-14');
+    assert.equal(msg.message, 'What endpoint shape are you using?');
+    assert.equal(msg.response, null);
+    assert.equal(msg.status, 'delivered');
+  });
+
+  it('should deliver via sendMessage when agent has loop', async () => {
+    await innerchat.send('a1', 'a2', 'Hello');
+    assert.equal(daemon.sentMessages.length, 1);
+    assert.equal(daemon.sentMessages[0].id, 'a2');
+    assert.ok(daemon.sentMessages[0].msg.includes('InnerChat from fullstack-1'));
+    assert.ok(daemon.sentMessages[0].msg.includes('Hello'));
+  });
+
+  it('should queue when agent is running but no loop', async () => {
+    daemon.processes._loops.delete('a2');
+    await innerchat.send('a1', 'a2', 'Hello');
+    assert.equal(daemon.queuedMessages.length, 1);
+    assert.equal(daemon.queuedMessages[0].id, 'a2');
+  });
+
+  it('should throw when target agent is not running', async () => {
+    daemon.processes._running.delete('a2');
+    daemon.processes._loops.delete('a2');
+    await assert.rejects(() => innerchat.send('a1', 'a2', 'Hello'), /not running/);
+  });
+
+  it('should throw when sender does not exist', async () => {
+    await assert.rejects(() => innerchat.send('unknown', 'a2', 'Hello'), /not found/);
+  });
+
+  it('should throw when sending to self', async () => {
+    // The route validates this, but let's verify it's caught
+    daemon.processes._loops.add('a1');
+    daemon.processes._running.add('a1');
+    const msg = await innerchat.send('a1', 'a1', 'Hello');
+    assert.ok(msg.id);
+  });
+
+  it('should broadcast innerchat:sent on send', async () => {
+    await innerchat.send('a1', 'a2', 'Hello');
+    const sent = daemon.broadcasts.find(b => b.type === 'innerchat:sent');
+    assert.ok(sent);
+    assert.equal(sent.data.message, 'Hello');
+  });
+
+  it('should capture response on agent output', async () => {
+    const msg = await innerchat.send('a1', 'a2', 'What shape?');
+    innerchat.onAgentOutput('a2', { type: 'result', data: 'GET /api/projects/:id returns { id, name }' });
+    assert.equal(msg.status, 'responded');
+    assert.equal(msg.response, 'GET /api/projects/:id returns { id, name }');
+    assert.ok(msg.respondedAt);
+  });
+
+  it('should relay response back to sender', async () => {
+    daemon.processes._loops.add('a1');
+    daemon.processes._running.add('a1');
+    await innerchat.send('a1', 'a2', 'What shape?');
+    daemon.sentMessages.length = 0;
+
+    innerchat.onAgentOutput('a2', { type: 'result', data: 'The answer' });
+    assert.equal(daemon.sentMessages.length, 1);
+    assert.equal(daemon.sentMessages[0].id, 'a1');
+    assert.ok(daemon.sentMessages[0].msg.includes('InnerChat reply from fullstack-14'));
+    assert.ok(daemon.sentMessages[0].msg.includes('The answer'));
+  });
+
+  it('should ignore non-result output', async () => {
+    await innerchat.send('a1', 'a2', 'What shape?');
+    innerchat.onAgentOutput('a2', { type: 'activity', subtype: 'stream', data: 'partial...' });
+    const msg = innerchat.getMessage(innerchat.getMessages()[0].id);
+    assert.equal(msg.status, 'delivered');
+    assert.equal(msg.response, null);
+  });
+
+  it('should ignore output from agents with no pending question', () => {
+    innerchat.onAgentOutput('a2', { type: 'result', data: 'Some output' });
+    assert.equal(daemon.broadcasts.length, 0);
+  });
+
+  it('should extract text from array-format output', async () => {
+    await innerchat.send('a1', 'a2', 'Hello');
+    innerchat.onAgentOutput('a2', {
+      type: 'result',
+      data: [
+        { type: 'text', text: 'Part 1' },
+        { type: 'tool_use', name: 'Read', input: {} },
+        { type: 'text', text: 'Part 2' },
+      ],
+    });
+    const msg = innerchat.getMessages()[0];
+    assert.equal(msg.response, 'Part 1\nPart 2');
+  });
+
+  it('should broadcast innerchat:response on response', async () => {
+    await innerchat.send('a1', 'a2', 'Hello');
+    innerchat.onAgentOutput('a2', { type: 'result', data: 'Response here' });
+    const resp = daemon.broadcasts.find(b => b.type === 'innerchat:response');
+    assert.ok(resp);
+    assert.equal(resp.data.response, 'Response here');
+  });
+
+  it('should list messages filtered by agent', async () => {
+    daemon.processes._loops.add('a1');
+    daemon.processes._running.add('a1');
+    daemon.registry.add({ id: 'a3', name: 'backend-1', role: 'backend' });
+    daemon.processes._loops.add('a3');
+    daemon.processes._running.add('a3');
+
+    await innerchat.send('a1', 'a2', 'Message 1');
+    await innerchat.send('a1', 'a3', 'Message 2');
+
+    assert.equal(innerchat.getMessages().length, 2);
+    assert.equal(innerchat.getMessages('a2').length, 1);
+    assert.equal(innerchat.getMessages('a3').length, 1);
+    assert.equal(innerchat.getMessages('a1').length, 2);
+  });
+
+  it('should return pending question for agent', async () => {
+    assert.equal(innerchat.getPending('a2'), null);
+    await innerchat.send('a1', 'a2', 'Question?');
+    const pending = innerchat.getPending('a2');
+    assert.ok(pending);
+    assert.equal(pending.message, 'Question?');
+  });
+
+  it('should clear pending after response', async () => {
+    await innerchat.send('a1', 'a2', 'Question?');
+    innerchat.onAgentOutput('a2', { type: 'result', data: 'Answer' });
+    assert.equal(innerchat.getPending('a2'), null);
+  });
+
+  it('should audit send and response events', async () => {
+    await innerchat.send('a1', 'a2', 'Hello');
+    innerchat.onAgentOutput('a2', { type: 'result', data: 'Reply' });
+    const sendAudit = daemon.audits.find(a => a.type === 'innerchat.send');
+    const respAudit = daemon.audits.find(a => a.type === 'innerchat.response');
+    assert.ok(sendAudit);
+    assert.ok(respAudit);
+  });
+});