groove-dev 0.27.60 → 0.27.61

package/packages/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/packages/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/packages/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/packages/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/packages/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'] });

package/packages/daemon/src/providers/codex.js

@@ -7,6 +7,26 @@ import { resolve } from 'path';
 import { homedir } from 'os';
 import { Provider } from './base.js';
 
+async function parseSSEStream(response, onEvent) {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  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 }); return; }
+        try { onEvent(JSON.parse(data)); } catch { /* skip malformed */ }
+      }
+    }
+  }
+}
+
 export class CodexProvider extends Provider {
   static name = 'codex';
   static displayName = 'Codex';
@@ -128,6 +148,41 @@ export class CodexProvider extends Provider {
     return (inputTokens / 1000) * model.pricing.input + (outputTokens / 1000) * model.pricing.output;
   }
 
+  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(); } };
+    fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: model || 'gpt-5.4-mini',
+        messages,
+        stream: true,
+      }),
+      signal: controller.signal,
+    }).then((res) => {
+      if (!res.ok) {
+        return res.text().then((t) => { throw new Error(`OpenAI API ${res.status}: ${t.slice(0, 200)}`); });
+      }
+      return parseSSEStream(res, (event) => {
+        if (event.done) { finish(); return; }
+        const content = event.choices?.[0]?.delta?.content;
+        if (content) onChunk(content);
+      });
+    }).then(() => {
+      finish();
+    }).catch((err) => {
+      if (err.name === 'AbortError') return;
+      onError(err);
+    });
+    return controller;
+  }
+
   parseOutput(line) {
     const trimmed = line.trim();
     if (!trimmed) return null;

package/packages/daemon/src/providers/gemini.js

@@ -4,6 +4,26 @@
 import { execSync } from 'child_process';
 import { Provider } from './base.js';
 
+async function parseSSEStream(response, onEvent) {
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  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 }); return; }
+        try { onEvent(JSON.parse(data)); } catch { /* skip malformed */ }
+      }
+    }
+  }
+}
+
 export class GeminiProvider extends Provider {
   static name = 'gemini';
   static displayName = 'Gemini CLI';
@@ -68,6 +88,39 @@ export class GeminiProvider extends Provider {
     return (inputTokens / 1000) * model.pricing.input + (outputTokens / 1000) * model.pricing.output;
   }
 
+  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 m = model || 'gemini-2.5-flash';
+    const contents = messages.map((msg) => ({
+      role: msg.role === 'assistant' ? 'model' : 'user',
+      parts: [{ text: msg.content }],
+    }));
+    fetch(`https://generativelanguage.googleapis.com/v1beta/models/${m}:streamGenerateContent?alt=sse&key=${apiKey}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ contents }),
+      signal: controller.signal,
+    }).then((res) => {
+      if (!res.ok) {
+        return res.text().then((t) => { throw new Error(`Gemini API ${res.status}: ${t.slice(0, 200)}`); });
+      }
+      return parseSSEStream(res, (event) => {
+        if (event.done) { finish(); return; }
+        const text = event.candidates?.[0]?.content?.parts?.[0]?.text;
+        if (text) onChunk(text);
+      });
+    }).then(() => {
+      finish();
+    }).catch((err) => {
+      if (err.name === 'AbortError') return;
+      onError(err);
+    });
+    return controller;
+  }
+
   parseOutput(line) {
     const trimmed = line.trim();
     if (!trimmed) return null;

package/packages/daemon/src/providers/local.js

@@ -194,6 +194,50 @@ export class LocalProvider extends Provider {
     return false; // Needs rotation for model switch
   }
 
+  streamChat(messages, model, apiKey, onChunk, onDone, onError) {
+    const controller = new AbortController();
+    let finished = false;
+    const finish = () => { if (!finished) { finished = true; onDone(); } };
+    fetch('http://localhost:11434/api/chat', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: model || 'qwen2.5-coder:7b',
+        messages,
+        stream: true,
+      }),
+      signal: controller.signal,
+    }).then(async (res) => {
+      if (!res.ok) {
+        const t = await res.text();
+        throw new Error(`Ollama API ${res.status}: ${t.slice(0, 200)}`);
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+      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.trim()) continue;
+          try {
+            const json = JSON.parse(line);
+            if (json.done) { finish(); return; }
+            if (json.message?.content) onChunk(json.message.content);
+          } catch { /* skip malformed */ }
+        }
+      }
+      finish();
+    }).catch((err) => {
+      if (err.name === 'AbortError') return;
+      onError(err);
+    });
+    return controller;
+  }
+
   parseOutput(line) {
     const trimmed = (line || '').trim();
     if (!trimmed) return null;

package/packages/daemon/src/providers/ollama.js

@@ -275,6 +275,50 @@ export class OllamaProvider extends Provider {
     return false; // Needs rotation for model switch
   }
 
+  streamChat(messages, model, apiKey, onChunk, onDone, onError) {
+    const controller = new AbortController();
+    let finished = false;
+    const finish = () => { if (!finished) { finished = true; onDone(); } };
+    fetch('http://localhost:11434/api/chat', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: model || 'llama3.1:8b',
+        messages,
+        stream: true,
+      }),
+      signal: controller.signal,
+    }).then(async (res) => {
+      if (!res.ok) {
+        const t = await res.text();
+        throw new Error(`Ollama API ${res.status}: ${t.slice(0, 200)}`);
+      }
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+      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.trim()) continue;
+          try {
+            const json = JSON.parse(line);
+            if (json.done) { finish(); return; }
+            if (json.message?.content) onChunk(json.message.content);
+          } catch { /* skip malformed */ }
+        }
+      }
+      finish();
+    }).catch((err) => {
+      if (err.name === 'AbortError') return;
+      onError(err);
+    });
+    return controller;
+  }
+
   parseOutput(line) {
     const trimmed = line.trim();
     if (!trimmed) return null;

package/packages/daemon/src/rotator.js

@@ -299,6 +299,10 @@ export class Rotator extends EventEmitter {
         brief = brief + '\n\n## User Instruction\n\n' + options.additionalPrompt;
       }
 
+      if (agent.role === 'planner' && !brief.includes('PLANNING ONLY')) {
+        brief = 'CRITICAL: You are a PLANNING ONLY agent. Do NOT implement code. Route all work to your team via .groove/recommended-team.json.\n\n' + brief;
+      }
+
       // Persist to Layer 7 handoff chain so future rotations have causal continuity
       if (this.daemon.memory) {
         this.daemon.memory.appendHandoffBrief(agent.role, {