groove-dev 0.27.172 → 0.27.175

package/packages/daemon/package.json

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

package/packages/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/packages/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/packages/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/packages/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/packages/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/packages/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/packages/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) {