groove-dev 0.27.60 → 0.27.61

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.60",
+  "version": "0.27.61",
   "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.60",
+  "version": "0.27.61",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

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

@@ -2,11 +2,11 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
 import express from 'express';
-import { resolve, dirname, join } from 'path';
+import { resolve, dirname, join, sep } from 'path';
 import { fileURLToPath } from 'url';
 import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, mkdirSync, unlinkSync, renameSync, rmSync, createReadStream, copyFileSync, realpathSync } from 'fs';
 import { spawn, execFile } from 'child_process';
-import { createHash } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
 import { hostname, networkInterfaces, homedir } from 'os';
 import { lookup as mimeLookup } from './mimetypes.js';
 import { listProviders, getProvider } from './providers/index.js';
@@ -14,7 +14,7 @@ import { OllamaProvider } from './providers/ollama.js';
 import { ClaudeCodeProvider } from './providers/claude-code.js';
 import { supportsSignalFlag, compareSemver, parseSemver } from './providers/groove-network.js';
 import { validateAgentConfig } from './validate.js';
-import { ROLE_INTEGRATIONS } from './process.js';
+import { ROLE_INTEGRATIONS, wrapWithRoleReminder } from './process.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkgVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
@@ -846,13 +846,18 @@ export function createApi(app, daemon) {
       if (req.body.title !== undefined) daemon.conversations.rename(req.params.id, req.body.title);
       if (req.body.pinned !== undefined) daemon.conversations.pin(req.params.id, req.body.pinned);
       if (req.body.archived !== undefined) daemon.conversations.archive(req.params.id, req.body.archived);
+      if (req.body.model !== undefined || req.body.provider !== undefined) {
+        const newProvider = req.body.provider || conv.provider;
+        const newModel = req.body.model || conv.model;
+        daemon.conversations.updateModel(req.params.id, newProvider, newModel);
+      }
       if (req.body.mode !== undefined) {
         if (req.body.mode !== 'api' && req.body.mode !== 'agent') {
           return res.status(400).json({ error: 'mode must be "api" or "agent"' });
         }
         await daemon.conversations.setMode(req.params.id, req.body.mode);
       }
-      daemon.audit.log('conversation.update', { id: req.params.id, mode: req.body.mode });
+      daemon.audit.log('conversation.update', { id: req.params.id, provider: req.body.provider, model: req.body.model, mode: req.body.mode });
       res.json(daemon.conversations.get(req.params.id));
     } catch (err) {
       res.status(400).json({ error: err.message });
@@ -1105,8 +1110,9 @@ export function createApi(app, daemon) {
       if (daemon.journalist) daemon.journalist.recordUserFeedback(agent, message.trim());
 
       // Agent loop path — send message directly to the running loop
+      const wrappedMessage = wrapWithRoleReminder(agent.role, message.trim());
       if (daemon.processes.hasAgentLoop(req.params.id)) {
-        const sent = await daemon.processes.sendMessage(req.params.id, message.trim());
+        const sent = await daemon.processes.sendMessage(req.params.id, wrappedMessage);
         if (sent) {
           daemon.audit.log('agent.chat', { id: req.params.id });
           return res.json({ id: agent.id, status: 'message_sent' });
@@ -1144,7 +1150,7 @@ export function createApi(app, daemon) {
       // Running CLI agent (no loop) — queue the message for delivery after
       // the current task completes instead of killing and respawning.
       if (daemon.processes.isRunning(req.params.id)) {
-        daemon.processes.queueMessage(req.params.id, message.trim());
+        daemon.processes.queueMessage(req.params.id, wrappedMessage);
         daemon.audit.log('agent.chat.queued', { id: req.params.id });
         return res.json({ id: agent.id, status: 'message_queued' });
       }
@@ -1156,8 +1162,8 @@ export function createApi(app, daemon) {
       const SESSION_RESUME_CEILING = 5_000_000;
       const resumed = !!agent.sessionId && (agent.tokensUsed || 0) < SESSION_RESUME_CEILING;
       const newAgent = resumed
-        ? await daemon.processes.resume(req.params.id, message.trim())
-        : await daemon.rotator.rotate(req.params.id, { additionalPrompt: message.trim() });
+        ? await daemon.processes.resume(req.params.id, wrappedMessage)
+        : await daemon.rotator.rotate(req.params.id, { additionalPrompt: wrappedMessage });
 
       daemon.audit.log('agent.instruct', { id: req.params.id, newId: newAgent.id, resumed });
       res.json(newAgent);
@@ -2340,7 +2346,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
   // Browse absolute paths (for directory picker in agent config)
   // Dirs only, localhost-only, no file content exposed
   app.get('/api/browse-system', (req, res) => {
-    const absPath = req.query.path || process.env.HOME || '/';
+    const absPath = req.query.path || homedir();
     if (absPath.includes('\0')) return res.status(400).json({ error: 'Invalid path' });
     if (!existsSync(absPath)) return res.status(404).json({ error: 'Not found' });
 
@@ -3474,7 +3480,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
       // Resolve shell shortcuts — GUI sends ~/... and ./...
       let resolvedPath = targetPath;
       if (resolvedPath.startsWith('~/') || resolvedPath === '~') {
-        resolvedPath = resolve(process.env.HOME || '/tmp', resolvedPath.slice(2));
+        resolvedPath = resolve(homedir(), resolvedPath.slice(2));
       } else if (!resolvedPath.startsWith('/')) {
         resolvedPath = resolve(daemon.projectDir, resolvedPath);
       }
@@ -3948,15 +3954,14 @@ Keep responses concise. Help them think, don't lecture them about the system the
   const BETA_RATE_WINDOW_MS = 60_000;
 
   function getMachineId() {
-    const nets = networkInterfaces();
-    const macs = [];
-    for (const name of Object.keys(nets)) {
-      for (const iface of nets[name] || []) {
-        if (iface.mac && iface.mac !== '00:00:00:00:00:00') macs.push(iface.mac);
-      }
-    }
-    macs.sort();
-    return createHash('sha256').update(`${hostname()}|${macs.join(',')}`).digest('hex');
+    const idFile = join(daemon.grooveDir, '.machine-id');
+    try {
+      const existing = readFileSync(idFile, 'utf8').trim();
+      if (existing.length >= 32) return existing;
+    } catch {}
+    const id = createHash('sha256').update(`${hostname()}|${randomUUID()}`).digest('hex');
+    try { writeFileSync(idFile, id, { mode: 0o600 }); } catch {}
+    return id;
   }
 
   async function validateCodeWithServer(code) {
@@ -4103,11 +4108,9 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
   app.post('/api/beta/deactivate', async (req, res) => {
     // Stop the node if it's running before locking the feature away.
-    try {
-      if (daemon.networkNode?.proc && !daemon.networkNode.proc.killed) {
-        daemon.networkNode.proc.kill('SIGINT');
-      }
-    } catch { /* ignore */ }
+    if (daemon.networkNode?.proc && !daemon.networkNode.proc.killed) {
+      safeKill(daemon.networkNode.proc);
+    }
     daemon.networkNode = {
       active: false, status: 'stopped', pid: null, proc: null,
       nodeId: null, layers: null, model: null, sessions: 0,
@@ -4220,15 +4223,15 @@ Keep responses concise. Help them think, don't lecture them about the system the
     // Resolve deploy path (handles ~ and defaults to ~/Desktop/groove-deploy)
     let deployPath = cfg.deployPath || null;
     if (!deployPath) {
-      deployPath = resolve(process.env.HOME || '', 'Desktop/groove-deploy');
+      deployPath = resolve(homedir(), 'Desktop', 'groove-deploy');
     } else if (deployPath.startsWith('~/')) {
-      deployPath = resolve(process.env.HOME || '', deployPath.slice(2));
+      deployPath = resolve(homedir(), deployPath.slice(2));
     }
 
     if (!existsSync(deployPath)) {
       return res.status(400).json({ error: `Deploy path not found: ${deployPath}` });
     }
-    if (!isInsideGrooveHome(deployPath) && !deployPath.startsWith(resolve(process.env.HOME || '', 'Desktop'))) {
+    if (!isInsideGrooveHome(deployPath) && !deployPath.startsWith(resolve(homedir(), 'Desktop'))) {
       return res.status(400).json({ error: 'Deploy path outside allowed directories' });
     }
 
@@ -4245,7 +4248,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
     let proc;
     try {
-      proc = spawn(join(deployPath, 'venv', 'bin', 'python3'), args, {
+      proc = spawn(venvPython(deployPath), args, {
         cwd: deployPath,
         env: { ...process.env, PYTHONUNBUFFERED: '1' },
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -4368,11 +4371,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
     if (!node?.active || !node.proc) {
       return res.status(409).json({ error: 'Node not running' });
     }
-    try {
-      node.proc.kill('SIGINT');
-    } catch (err) {
-      return res.status(500).json({ error: `Failed to stop node: ${err.message}` });
-    }
+    safeKill(node.proc);
     daemon.networkNode.status = 'stopping';
     pushNodeEvent('stopping', { pid: node.pid });
     broadcastNodeStatus();
@@ -4610,9 +4609,37 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
   // --- Network package install/uninstall ---
 
+  const IS_WIN = process.platform === 'win32';
   const NETWORK_REPO_URL = 'https://github.com/grooveai-dev/groove-network.git';
   const NETWORK_VERSION = 'v0.2.0';
 
+  function venvPython(base) {
+    return IS_WIN
+      ? join(base, 'venv', 'Scripts', 'python.exe')
+      : join(base, 'venv', 'bin', 'python3');
+  }
+
+  function spawnSetupSh(cwd) {
+    if (IS_WIN) {
+      return spawn('cmd.exe', ['/c', 'bash setup.sh --json'], {
+        cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env, PYTHONUNBUFFERED: '1' },
+      });
+    }
+    return spawn('bash', ['setup.sh', '--json'], {
+      cwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, PYTHONUNBUFFERED: '1' },
+    });
+  }
+
+  function safeKill(proc, signal = 'SIGINT') {
+    try {
+      if (IS_WIN) { proc.kill(); } else { proc.kill(signal); }
+    } catch { /* ignore */ }
+  }
+
   function networkRoot() {
     return resolve(homedir(), '.groove', 'network');
   }
@@ -4636,12 +4663,12 @@ Keep responses concise. Help them think, don't lecture them about the system the
   // Defensive: only permit fs ops on paths that resolve inside ~/.groove/.
   // Uses realpathSync when the path exists to defeat symlink escapes.
   function isInsideGrooveHome(target) {
-    const home = resolve(homedir(), '.groove') + '/';
+    const home = resolve(homedir(), '.groove') + sep;
     const resolved = resolve(target);
     let full;
-    try { full = existsSync(resolved) ? realpathSync(resolved) + '/' : resolved + '/'; }
-    catch { full = resolved + '/'; }
-    const realHome = existsSync(home.slice(0, -1)) ? realpathSync(home.slice(0, -1)) + '/' : home;
+    try { full = existsSync(resolved) ? realpathSync(resolved) + sep : resolved + sep; }
+    catch { full = resolved + sep; }
+    const realHome = existsSync(home.slice(0, -1)) ? realpathSync(home.slice(0, -1)) + sep : home;
     return full.startsWith(realHome);
   }
 
@@ -4748,11 +4775,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
         broadcastInstallProgress('cloned', 'Repository cloned', 10);
 
         // Run setup.sh --json from the install directory
-        const setup = spawn('bash', ['setup.sh', '--json'], {
-          cwd: installPath,
-          stdio: ['ignore', 'pipe', 'pipe'],
-          env: { ...process.env, PYTHONUNBUFFERED: '1' },
-        });
+        const setup = spawnSetupSh(installPath);
 
         daemon.networkInstall.proc = setup;
 
@@ -4816,7 +4839,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
     try {
       const node = daemon.networkNode;
       if (node?.active && node.proc && !node.proc.killed) {
-        try { node.proc.kill('SIGINT'); } catch { /* ignore */ }
+        safeKill(node.proc);
         daemon.networkNode.status = 'stopping';
         pushNodeEvent('stopping', { pid: node.pid, reason: 'uninstall' });
         broadcastNodeStatus();
@@ -4868,9 +4891,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
       let stderr = '';
       proc.stdout.on('data', (c) => { stdout += c.toString(); });
       proc.stderr.on('data', (c) => { stderr += c.toString(); });
-      const timeout = setTimeout(() => {
-        try { proc.kill('SIGTERM'); } catch { /* ignore */ }
-      }, 10_000);
+      const timeout = setTimeout(() => { safeKill(proc, 'SIGTERM'); }, 10_000);
       proc.on('error', () => { clearTimeout(timeout); resolvePromise(null); });
       proc.on('close', (code) => {
         clearTimeout(timeout);
@@ -4957,7 +4978,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
         try {
           const node = daemon.networkNode;
           if (node?.active && node.proc && !node.proc.killed) {
-            try { node.proc.kill('SIGINT'); } catch { /* ignore */ }
+            safeKill(node.proc);
             daemon.networkNode.status = 'stopping';
             pushNodeEvent('stopping', { pid: node.pid, reason: 'update' });
             broadcastNodeStatus();
@@ -5002,11 +5023,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
         broadcastUpdateProgress('deps', 'Updating dependencies...', 30);
 
-        const setup = spawn('bash', ['setup.sh', '--json'], {
-          cwd: installPath,
-          stdio: ['ignore', 'pipe', 'pipe'],
-          env: { ...process.env, PYTHONUNBUFFERED: '1' },
-        });
+        const setup = spawnSetupSh(installPath);
 
         daemon.networkInstall.proc = setup;
 

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

@@ -200,6 +200,17 @@ export class ConversationManager {
     this.daemon.broadcast({ type: 'conversation:updated', data: conv });
   }
 
+  updateModel(id, provider, model) {
+    const conv = this.conversations.get(id);
+    if (!conv) throw new Error('Conversation not found');
+    conv.provider = provider;
+    conv.model = model;
+    conv.updatedAt = new Date().toISOString();
+    this._save();
+    this.daemon.broadcast({ type: 'conversation:updated', data: conv });
+    return conv;
+  }
+
   async setMode(id, mode) {
     const conv = this.conversations.get(id);
     if (!conv) throw new Error('Conversation not found');
@@ -259,35 +270,90 @@ export class ConversationManager {
 
   _killStreamingProcess(conversationId) {
     const procs = this._getStreamingProcesses();
-    const proc = procs.get(conversationId);
-    if (proc && !proc.killed) {
-      proc.kill();
+    const handle = procs.get(conversationId);
+    if (!handle) return;
+    if (handle.abort) {
+      handle.abort();
+    } else if (handle.kill && !handle.killed) {
+      handle.kill();
     }
     procs.delete(conversationId);
   }
 
+  _getApiKey(providerName) {
+    const envMap = {
+      'claude-code': 'ANTHROPIC_API_KEY',
+      'codex': 'OPENAI_API_KEY',
+      'gemini': 'GEMINI_API_KEY',
+    };
+    const envVar = envMap[providerName];
+    if (envVar && process.env[envVar]) return process.env[envVar];
+    try {
+      return this.daemon.credentials?.getKey(providerName) || null;
+    } catch { return null; }
+  }
+
   async sendMessage(id, message, history) {
     const conv = this.conversations.get(id);
     if (!conv) throw new Error('Conversation not found');
     if (conv.mode !== 'api') throw new Error('sendMessage only works in API mode');
 
-    // Kill any previous streaming process for this conversation
     this._killStreamingProcess(id);
 
-    const prompt = this._buildHistoryPrompt(history, message);
-
-    // Resolve the provider for this conversation
     let provider = getProvider(conv.provider);
     let modelId = conv.model;
+    let providerName = conv.provider;
 
     if (!provider || !isProviderInstalled(conv.provider)) {
       const priority = ['claude-code', 'gemini', 'codex', 'ollama'];
       const fallbackId = priority.find((p) => isProviderInstalled(p));
       if (!fallbackId) throw new Error('No provider available for chat');
       provider = getProvider(fallbackId);
+      providerName = fallbackId;
       modelId = null;
     }
 
+    // Build messages array for direct API call
+    const messages = (history || []).map((m) => ({
+      role: m.from === 'user' ? 'user' : 'assistant',
+      content: m.text,
+    }));
+    messages.push({ role: 'user', content: message });
+
+    const apiKey = this._getApiKey(providerName);
+
+    // Try direct API streaming first (sub-second latency)
+    const controller = provider.streamChat(
+      messages, modelId, apiKey,
+      (text) => {
+        this.daemon.broadcast({
+          type: 'conversation:chunk',
+          data: { conversationId: id, text },
+        });
+      },
+      () => {
+        this._getStreamingProcesses().delete(id);
+        this.daemon.broadcast({
+          type: 'conversation:complete',
+          data: { conversationId: id },
+        });
+      },
+      (err) => {
+        this._getStreamingProcesses().delete(id);
+        this.daemon.broadcast({
+          type: 'conversation:error',
+          data: { conversationId: id, error: err.message },
+        });
+      },
+    );
+
+    if (controller) {
+      this._getStreamingProcesses().set(id, controller);
+      return;
+    }
+
+    // Fallback: headless CLI spawn (for providers without streamChat or missing API key)
+    const prompt = this._buildHistoryPrompt(history, message);
     const headlessCmd = provider.buildHeadlessCommand(prompt, modelId);
     const { command, args, env, stdin: stdinData, cwd } = headlessCmd;
 
@@ -305,23 +371,15 @@ export class ConversationManager {
       proc.stdin.end();
     }
 
-    let fullOutput = '';
-
     proc.stdout.on('data', (data) => {
       const text = data.toString();
-      fullOutput += text;
-
-      // Parse provider output for streaming chunks
       const lines = text.split('\n');
       for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed) continue;
 
-        // Try to parse as JSON (stream-json format)
         try {
           const json = JSON.parse(trimmed);
-
-          // Claude Code stream-json: assistant message content
           if (json.type === 'assistant' && json.message?.content) {
             for (const block of json.message.content) {
               if (block.type === 'text' && block.text) {
@@ -333,8 +391,6 @@ export class ConversationManager {
             }
             continue;
           }
-
-          // Claude Code stream-json: content_block_delta
           if (json.type === 'content_block_delta' && json.delta?.text) {
             this.daemon.broadcast({
               type: 'conversation:chunk',
@@ -342,14 +398,7 @@ export class ConversationManager {
             });
             continue;
           }
-
-          // Claude Code stream-json: result block — skip broadcasting since
-          // the content was already streamed via assistant/content_block_delta
-          if (json.type === 'result' && json.result) {
-            continue;
-          }
-
-          // Groove Network: token events
+          if (json.type === 'result' && json.result) continue;
           if (json.type === 'token' && json.text != null) {
             this.daemon.broadcast({
               type: 'conversation:chunk',
@@ -357,8 +406,6 @@ export class ConversationManager {
             });
             continue;
           }
-
-          // Groove Network: done/complete/result
           if ((json.type === 'done' || json.type === 'complete' || json.type === 'result') && json.text) {
             this.daemon.broadcast({
               type: 'conversation:chunk',
@@ -366,8 +413,6 @@ export class ConversationManager {
             });
             continue;
           }
-
-          // Gemini / Codex: content text
           if (json.content?.[0]?.text) {
             this.daemon.broadcast({
               type: 'conversation:chunk',
@@ -375,9 +420,8 @@ export class ConversationManager {
             });
             continue;
           }
-        } catch { /* not JSON — treat as raw text */ }
+        } catch { /* not JSON */ }
 
-        // Non-JSON output: broadcast raw text (some providers output plain text)
         if (!trimmed.startsWith('{')) {
           this.daemon.broadcast({
             type: 'conversation:chunk',

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

@@ -884,6 +884,7 @@ export class Journalist {
       recentChain ? `## Rotation History\n\n${recentChain}\n` : '',
       agent.prompt ? `## Original Task\n\n${agent.prompt}\n` : '',
       ``,
+      agent.role === 'planner' ? 'CRITICAL: You are a PLANNING ONLY agent. Do NOT implement code. Route all work to your team via .groove/recommended-team.json.\n' : '',
       `Continue seamlessly — finish what was in progress and deliver the output. Do not announce rotation or greet the user.`,
     ].filter(Boolean).join('\n');
   }

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

@@ -308,6 +308,13 @@ function sanitizeFilename(name) {
   return String(name).replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
 }
 
+export function wrapWithRoleReminder(role, message) {
+  if (role === 'planner' && !message.startsWith('ROLE REMINDER:')) {
+    return 'ROLE REMINDER: You are a PLANNING ONLY agent. Do NOT write code, edit files, or use Edit/Write/Bash tools. Route this task to your team by writing .groove/recommended-team.json.\n\nUser message: ' + message;
+  }
+  return message;
+}
+
 export class ProcessManager {
   constructor(daemon) {
     this.daemon = daemon;
@@ -568,7 +575,7 @@ Do NOT:
 - Analyze the codebase proactively
 
 DO: Introduce yourself in one sentence and ask the user what they would like you to work on. Then wait.`;
-        } else if (spawnConfig.prompt.startsWith('# Agent Handoff Brief')) {
+        } else if (spawnConfig.prompt.startsWith('# Handoff Brief')) {
           spawnConfig.prompt += '\n\n## Role Constraints\n\n' + rolePrompt.trim();
         } else {
           spawnConfig.prompt = rolePrompt + 'Task: ' + spawnConfig.prompt;
@@ -640,7 +647,7 @@ If response says \`"approved":false\`, adjust your approach based on the reason.
 For normal file edits within your scope, proceed without review.
 
 `;
-      if (spawnConfig.prompt.startsWith('# Agent Handoff Brief')) {
+      if (spawnConfig.prompt.startsWith('# Handoff Brief')) {
         spawnConfig.prompt += '\n\n' + pmPrompt.trim();
       } else {
         spawnConfig.prompt = pmPrompt + spawnConfig.prompt;
@@ -1728,9 +1735,10 @@ For normal file edits within your scope, proceed without review.
     const { loop } = handle;
     if (!loop.running) return false;
 
-    // Fire and forget — the loop processes the message asynchronously
-    // and emits output events that flow through the normal handler
-    loop.sendMessage(message).catch(() => {});
+    const agent = this.daemon.registry.get(agentId);
+    const wrapped = agent ? wrapWithRoleReminder(agent.role, message) : message;
+
+    loop.sendMessage(wrapped).catch(() => {});
     return true;
   }
 
@@ -1743,8 +1751,10 @@ For normal file edits within your scope, proceed without review.
   }
 
   queueMessage(agentId, message) {
-    this.pendingMessages.set(agentId, { message, timestamp: Date.now() });
-    this.daemon.broadcast({ type: 'agent:message_queued', agentId, message });
+    const agent = this.daemon.registry.get(agentId);
+    const wrapped = agent ? wrapWithRoleReminder(agent.role, message) : message;
+    this.pendingMessages.set(agentId, { message: wrapped, timestamp: Date.now() });
+    this.daemon.broadcast({ type: 'agent:message_queued', agentId, message: wrapped });
   }
 
   consumePendingMessage(agentId) {

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

@@ -32,4 +32,8 @@ export class Provider {
   parseOutput(line) {
     return null;
   }
+
+  streamChat(messages, model, apiKey, onChunk, onDone, onError) {
+    return null;
+  }
 }

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

@@ -10,6 +10,28 @@ import { Provider } from './base.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
+async function parseSSEStream(response, onEvent) {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let gotDone = false;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop();
+    for (const line of lines) {
+      if (line.startsWith('data: ')) {
+        const data = line.slice(6);
+        if (data === '[DONE]') { onEvent({ done: true }); gotDone = true; return; }
+        try { onEvent(JSON.parse(data)); } catch { /* skip malformed */ }
+      }
+    }
+  }
+  if (!gotDone) onEvent({ done: true });
+}
+
 export class ClaudeCodeProvider extends Provider {
   static name = 'claude-code';
   static displayName = 'Claude Code';
@@ -254,6 +276,47 @@ export class ClaudeCodeProvider extends Provider {
     return merged;
   }
 
+  streamChat(messages, model, apiKey, onChunk, onDone, onError) {
+    if (!apiKey) return null;
+    const controller = new AbortController();
+    let finished = false;
+    const finish = () => { if (!finished) { finished = true; onDone(); } };
+    const body = JSON.stringify({
+      model: model || 'claude-sonnet-4-6',
+      messages,
+      max_tokens: 8192,
+      stream: true,
+    });
+    fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        'content-type': 'application/json',
+      },
+      body,
+      signal: controller.signal,
+    }).then((res) => {
+      if (!res.ok) {
+        return res.text().then((t) => { throw new Error(`Anthropic API ${res.status}: ${t.slice(0, 200)}`); });
+      }
+      return parseSSEStream(res, (event) => {
+        if (event.done) { finish(); return; }
+        if (event.type === 'content_block_delta' && event.delta?.text) {
+          onChunk(event.delta.text);
+        } else if (event.type === 'message_stop') {
+          finish();
+        }
+      });
+    }).then(() => {
+      finish();
+    }).catch((err) => {
+      if (err.name === 'AbortError') return;
+      onError(err);
+    });
+    return controller;
+  }
+
   static getAuthStatus() {
     try {
       const out = execSync('claude auth status --json', { encoding: 'utf8', timeout: 10_000, stdio: ['pipe', 'pipe', 'pipe'] });