groove-dev 0.27.60 → 0.27.62

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.60",
+  "version": "0.27.62",
   "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.62",
   "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, relative } 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 { spawn, execFile, execFileSync } from 'child_process';
+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' });
 
@@ -2908,6 +2914,18 @@ Keep responses concise. Help them think, don't lecture them about the system the
         console.log(`[Groove] Project directory: ${projectWorkingDir}`);
       }
 
+      function normalizeScope(patterns, baseDir) {
+        if (!patterns || !Array.isArray(patterns)) return patterns;
+        return patterns.map((p) => {
+          if (typeof p === 'string' && p.startsWith('/')) {
+            const rel = relative(baseDir, p);
+            if (!rel.startsWith('..')) return rel;
+            return p.slice(1);
+          }
+          return p;
+        });
+      }
+
       // Separate phase 1 (builders) and phase 2 (QC/finisher)
       const phase1 = agentConfigs.filter((a) => !a.phase || a.phase === 1);
       let phase2 = agentConfigs.filter((a) => a.phase === 2);
@@ -2967,7 +2985,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
             // Spawn fresh with the same name/team but new prompt + full context
             const validated = validateAgentConfig({
               role: existing.role,
-              scope: config.scope || existing.scope || [],
+              scope: normalizeScope(config.scope || existing.scope || [], existing.workingDir || projectWorkingDir),
               prompt,
               provider: config.provider || existing.provider || undefined,
               model: config.model || existing.model || daemon.config?.defaultModel || 'auto',
@@ -2989,7 +3007,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
           try {
             const validated = validateAgentConfig({
               role: config.role,
-              scope: config.scope || [],
+              scope: normalizeScope(config.scope || [], config.workingDir || projectWorkingDir),
               prompt,
               provider: config.provider || undefined,
               model: config.model || daemon.config?.defaultModel || 'auto',
@@ -3009,6 +3027,10 @@ Keep responses concise. Help them think, don't lecture them about the system the
         }
       }
 
+      if (failed.length > 0) {
+        console.warn(`[Groove] Team launch had ${failed.length} failure(s):`, failed.map((f) => `${f.role}: ${f.error}`).join(', '));
+      }
+
       // Phase 2 agents also scoped to projectWorkingDir
       if (phase2.length > 0 && phase1Ids.length > 0) {
         // Dedup: if a running idle fullstack already exists in this team,
@@ -3474,7 +3496,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 +3970,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 +4124,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 +4239,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 +4264,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 +4387,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 +4625,65 @@ 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');
+  }
+
+  let _cachedGitBash = undefined;
+  function findGitBash() {
+    if (_cachedGitBash !== undefined) return _cachedGitBash;
+    try {
+      const gitPath = execFileSync('where', ['git'], { timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] })
+        .toString().trim().split('\n')[0].trim();
+      // git.exe is typically at <Git>\cmd\git.exe — navigate up to Git root
+      const gitDir = dirname(dirname(gitPath));
+      const candidate = join(gitDir, 'bin', 'bash.exe');
+      if (existsSync(candidate)) { _cachedGitBash = candidate; return _cachedGitBash; }
+    } catch { /* where failed — try common paths */ }
+    const fallbacks = [
+      'C:\\Program Files\\Git\\bin\\bash.exe',
+      'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+    ];
+    for (const p of fallbacks) {
+      if (existsSync(p)) { _cachedGitBash = p; return _cachedGitBash; }
+    }
+    _cachedGitBash = null;
+    return null;
+  }
+
+  function spawnSetupSh(cwd) {
+    if (IS_WIN) {
+      const bashPath = findGitBash();
+      if (!bashPath) {
+        const err = new Error('Could not find bash. Ensure Git for Windows is installed from https://git-scm.com');
+        err.code = 'BASH_NOT_FOUND';
+        throw err;
+      }
+      return spawn(bashPath, ['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 +4707,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);
   }
 
@@ -4701,7 +4772,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
       };
 
       try {
-        const pat = daemon.credentials?.getKey?.('github-pat') || null;
+        const pat = daemon.credentials?.getKey?.('github') || daemon.credentials?.getKey?.('github-pat') || null;
 
         let installVersion;
         try {
@@ -4712,6 +4783,14 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
         broadcastInstallProgress('cloning', `Cloning network package ${installVersion}...`, 0);
 
+        // Pre-flight: verify git is installed before attempting clone.
+        const gitInstalled = await new Promise((resolveGit) => {
+          execFile('git', ['--version'], { timeout: 5000 }, (err) => resolveGit(!err));
+        });
+        if (!gitInstalled) {
+          return fail('Git is not installed. Install Git from https://git-scm.com and restart Groove.');
+        }
+
         const cloneArgs = ['clone', '--branch', installVersion, '--depth', '1', NETWORK_REPO_URL, installPath];
         const cloneEnv = { ...process.env, GIT_TERMINAL_PROMPT: '0' };
         if (pat) {
@@ -4741,18 +4820,30 @@ Keep responses concise. Help them think, don't lecture them about the system the
         });
 
         if (cloneCode.code !== 0) {
-          const hint = stripCredentials(cloneErr.trim().split('\n').slice(-1)[0] || 'git clone failed');
+          let hint;
+          const errMsg = cloneCode.err || '';
+          const lastLine = cloneErr.trim().split('\n').slice(-1)[0] || '';
+          if (errMsg.includes('ENOENT')) {
+            hint = 'Git is not installed. Install Git from https://git-scm.com and restart Groove.';
+          } else if (/Authentication failed|could not read Username/i.test(cloneErr)) {
+            hint = 'Authentication failed — run "groove set-key github-pat <token>" to set a GitHub PAT.';
+          } else if (/not found/i.test(cloneErr)) {
+            hint = `Repository or tag not found (${installVersion}). Check NETWORK_REPO_URL and tag.`;
+          } else {
+            hint = stripCredentials(lastLine || errMsg || 'git clone failed');
+          }
           return fail(`Clone failed: ${hint}`);
         }
 
         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' },
-        });
+        let setup;
+        try {
+          setup = spawnSetupSh(installPath);
+        } catch (spawnErr) {
+          return fail(`Setup failed: ${spawnErr.message}`);
+        }
 
         daemon.networkInstall.proc = setup;
 
@@ -4786,7 +4877,12 @@ Keep responses concise. Help them think, don't lecture them about the system the
         });
 
         if (setupResult.code !== 0) {
-          const hint = stderrBuf.trim().split('\n').slice(-1)[0] || `setup.sh exited ${setupResult.code}`;
+          let hint;
+          if (setupResult.code === -1 || setupResult.err?.includes('ENOENT')) {
+            hint = 'bash not found — ensure Git for Windows is installed from https://git-scm.com';
+          } else {
+            hint = stderrBuf.trim().split('\n').slice(-1)[0] || `setup.sh exited ${setupResult.code}`;
+          }
           return fail(`Setup failed: ${hint}`);
         }
 
@@ -4816,7 +4912,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();
@@ -4860,17 +4956,22 @@ Keep responses concise. Help them think, don't lecture them about the system the
   // surface that. Uses spawn with array args — no shell interpolation.
   function fetchLatestNetworkTag() {
     return new Promise((resolvePromise) => {
+      const tagEnv = { ...process.env, GIT_TERMINAL_PROMPT: '0' };
+      const tagPat = daemon.credentials?.getKey?.('github') || daemon.credentials?.getKey?.('github-pat') || null;
+      if (tagPat) {
+        tagEnv.GIT_CONFIG_COUNT = '1';
+        tagEnv.GIT_CONFIG_KEY_0 = 'http.extraHeader';
+        tagEnv.GIT_CONFIG_VALUE_0 = `Authorization: token ${tagPat}`;
+      }
       const proc = spawn('git', ['ls-remote', '--tags', NETWORK_REPO_URL], {
         stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+        env: tagEnv,
       });
       let stdout = '';
       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 +5058,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 +5103,12 @@ 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' },
-        });
+        let setup;
+        try {
+          setup = spawnSetupSh(installPath);
+        } catch (spawnErr) {
+          return fail(`Setup failed: ${spawnErr.message}`);
+        }
 
         daemon.networkInstall.proc = setup;
 
@@ -5037,7 +5139,12 @@ Keep responses concise. Help them think, don't lecture them about the system the
         });
 
         if (setupResult.code !== 0) {
-          const hint = stderrBuf.trim().split('\n').slice(-1)[0] || `setup.sh exited ${setupResult.code}`;
+          let hint;
+          if (setupResult.code === -1 || setupResult.err?.includes('ENOENT')) {
+            hint = 'bash not found — ensure Git for Windows is installed from https://git-scm.com';
+          } else {
+            hint = stderrBuf.trim().split('\n').slice(-1)[0] || `setup.sh exited ${setupResult.code}`;
+          }
           return fail(`Setup failed: ${hint}`);
         }
 

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');
   }