groove-dev 0.27.75 → 0.27.78

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

@@ -540,27 +540,76 @@ export class Journalist {
   }
 
   async callHeadless(prompt, { trackAs = '__journalist__' } = {}) {
-    // Find the best available provider for headless synthesis
-    // Priority: claude-code (cheapest via Haiku) > gemini > codex > ollama
-    const priority = ['claude-code', 'gemini', 'codex', 'ollama'];
+    const priority = ['claude-code', 'gemini', 'codex', 'grok', 'ollama'];
     const installed = getInstalledProviders();
-    const providerId = priority.find((p) => installed.some((i) => i.id === p));
-    if (!providerId) {
-      throw new Error('No provider available for synthesis');
+
+    for (const providerId of priority) {
+      if (!installed.some((i) => i.id === providerId)) continue;
+
+      const provider = getProvider(providerId);
+      if (!provider) continue;
+
+      const selectedModel = provider.constructor.models?.find((m) => m.tier === 'medium')
+        || provider.constructor.models?.find((m) => m.tier === 'light')
+        || provider.constructor.models?.[0];
+      const modelId = selectedModel?.id || null;
+
+      // Try CLI headless command first
+      const headlessCmd = provider.buildHeadlessCommand(prompt, modelId);
+      if (headlessCmd) {
+        try {
+          return await this._execHeadlessCmd(headlessCmd, trackAs, modelId);
+        } catch {
+          continue;
+        }
+      }
+
+      // Fallback: streamChat for API-only providers (e.g. Grok)
+      if (typeof provider.streamChat === 'function') {
+        const apiKey = this.daemon.credentials?.getKey(providerId);
+        if (!apiKey) continue;
+
+        try {
+          const text = await new Promise((resolve, reject) => {
+            let collected = '';
+            const ctrl = provider.streamChat(
+              [{ role: 'user', content: prompt }],
+              modelId,
+              apiKey,
+              (chunk) => { collected += chunk; },
+              () => resolve(collected),
+              (err) => reject(err),
+            );
+            if (!ctrl) reject(new Error('streamChat unavailable'));
+          });
+
+          if (text) {
+            const estimatedInputTokens = Math.ceil(prompt.length / 4);
+            const estimatedOutputTokens = Math.ceil(text.length / 4);
+            if (this.daemon?.tokens) {
+              this.daemon.tokens.record(trackAs, {
+                tokens: estimatedInputTokens + estimatedOutputTokens,
+                inputTokens: estimatedInputTokens,
+                outputTokens: estimatedOutputTokens,
+                model: modelId,
+                estimatedCostUsd: 0,
+              });
+            }
+            return text;
+          }
+        } catch {
+          continue;
+        }
+      }
     }
-    const provider = getProvider(providerId);
 
-    // Pick medium tier for higher-quality synthesis (fewer but better cycles)
-    const selectedModel = provider.constructor.models?.find((m) => m.tier === 'medium')
-      || provider.constructor.models?.find((m) => m.tier === 'light')
-      || provider.constructor.models?.[0];
-    const modelId = selectedModel?.id || null;
+    throw new Error('No provider available for synthesis');
+  }
 
-    const headlessCmd = provider.buildHeadlessCommand(prompt, modelId);
+  _execHeadlessCmd(headlessCmd, trackAs, modelId) {
     const { command, args, env, stdin: stdinData } = headlessCmd;
 
     return new Promise((resolve, reject) => {
-      // Use spawn with stdin pipe if provider needs it (e.g., Ollama)
       if (stdinData) {
         let stdout = '';
         const proc = cpSpawn(command, args, {
@@ -576,7 +625,6 @@ export class Journalist {
           clearTimeout(timer);
           if (code !== 0) return reject(new Error(`Headless exited with code ${code}`));
           this._recordHeadlessUsage(stdout, trackAs, modelId);
-          // Process stdout same as execFile path below
           const lines = stdout.split('\n');
           for (const line of lines) {
             try {
@@ -590,17 +638,14 @@ export class Journalist {
         return;
       }
 
-      const proc = execFile(command, args, {
+      execFile(command, args, {
         env: { ...process.env, ...env },
         cwd: this.daemon.projectDir,
         maxBuffer: 1024 * 1024 * 5,
         timeout: 60_000,
       }, (err, stdout, stderr) => {
         if (err) return reject(err);
-
         this._recordHeadlessUsage(stdout, trackAs, modelId);
-
-        // Parse stream-json output to extract the result text
         const lines = stdout.split('\n');
         for (const line of lines) {
           try {
@@ -610,8 +655,6 @@ export class Journalist {
             }
           } catch { /* skip */ }
         }
-
-        // Fallback: return raw stdout
         resolve(stdout);
       });
     });

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

@@ -168,6 +168,20 @@ export class PreviewService {
     if (!command) {
       return Promise.resolve({ launched: false, reason: 'no_command' });
     }
+    // If command references an npm script, verify it exists in package.json
+    const npmRunMatch = command.match(/npm\s+run\s+(\S+)/);
+    if (npmRunMatch) {
+      const scriptName = npmRunMatch[1];
+      const pkgPath = resolve(baseDir, 'package.json');
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        if (!pkg.scripts || !pkg.scripts[scriptName]) {
+          return Promise.resolve({ launched: false, reason: 'no_dev_script' });
+        }
+      } catch {
+        return Promise.resolve({ launched: false, reason: 'no_dev_script' });
+      }
+    }
     const urlPattern = preview.urlPattern
       ? new RegExp(preview.urlPattern)
       : /https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0):\d+/;

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

@@ -114,6 +114,9 @@ CRITICAL — NEVER DO THESE:
 - NEVER kill the daemon process. No "kill <pid>", "pkill groove", "killall node", etc.
 - NEVER run "./promote.sh", "./promote-local.sh", or any publish/deploy script.
 - NEVER start long-running dev servers (vite dev, npm start, next dev, etc.).
+- NEVER use 'git add -f' or 'git add --force' to bypass .gitignore. If a file is gitignored, it should stay gitignored. Only stage files that git tracks normally. If .gitignore prevents staging, report it in your output — do NOT force-add.
+- NEVER use 'git push --force' or 'git push -f'. Force-pushing can destroy shared history.
+- NEVER modify .gitignore to include files that were previously excluded.
 
 Restarting the daemon destroys ALL other agents currently running in other teams. Verification is done via "npm run build" and "npm test", which exit cleanly. If code changes require a daemon restart to take effect, report that in your output so the user can restart manually — do NOT do it yourself.
 
@@ -463,6 +466,15 @@ export class ProcessManager {
       model: isAutoRouted ? null : config.model, // Set after routing
     });
 
+    if (this.daemon.trajectoryCapture) {
+      try {
+        const teamSize = registry.getAll().filter(a => a.status === 'active' || a.status === 'running' || a.status === 'starting').length;
+        this.daemon.trajectoryCapture.onAgentSpawn(
+          agent.id, providerName, config.model || null, config.role, teamSize
+        ).catch(() => {});
+      } catch (e) { /* fail silent */ }
+    }
+
     // Auto-route: let the router pick the model based on role/complexity
     if (isAutoRouted) {
       const { router } = this.daemon;
@@ -666,6 +678,12 @@ For normal file edits within your scope, proceed without review.
     const logPath = resolve(logDir, `${sanitizeFilename(agent.name)}.log`);
     const logStream = createWriteStream(logPath, { flags: 'a', mode: 0o600 });
 
+    // Inject API key from credential store for agent-loop providers
+    if (provider.constructor.useAgentLoop && this.daemon.credentials) {
+      const storedKey = this.daemon.credentials.getKey(providerName);
+      if (storedKey) spawnConfig.apiKey = storedKey;
+    }
+
     // ─── Agent Loop path (local models with built-in agentic runtime) ───
     if (provider.constructor.useAgentLoop) {
       const loopConfig = provider.getLoopConfig(spawnConfig);
@@ -875,6 +893,22 @@ For normal file edits within your scope, proceed without review.
         });
       }
 
+      if (this.daemon.trajectoryCapture) {
+        try {
+          if (finalStatus === 'completed') {
+            this.daemon.trajectoryCapture.onAgentComplete(agent.id, {
+              status: 'SUCCESS', exit_code: code, signal,
+            });
+          } else {
+            this.daemon.trajectoryCapture.onAgentCrash(agent.id,
+              signal ? 'Killed by signal ' + signal : 'Exit code ' + code
+            );
+          }
+          const count = (this.daemon.state.get('training_sessions_captured') || 0) + 1;
+          this.daemon.state.set('training_sessions_captured', count);
+        } catch (e) { /* fail silent */ }
+      }
+
       this.daemon.broadcast({
         type: 'agent:exit',
         agentId: agent.id,
@@ -1022,6 +1056,12 @@ For normal file edits within your scope, proceed without review.
       } catch (err) {
         console.error(`[Groove] parseOutput error for ${agentId}: ${err.message}`);
       }
+      if (this.daemon.trajectoryCapture) {
+        try {
+          const parsed = JSON.parse(line);
+          this.daemon.trajectoryCapture.onStdoutLine(agentId, parsed);
+        } catch (e) { /* fail silent — non-JSON lines are expected */ }
+      }
     }
   }
 
@@ -1161,7 +1201,7 @@ For normal file edits within your scope, proceed without review.
     const workingDir = plan.workingDir;
     preview.launch(teamId, workingDir, plan.preview).then((result) => {
       if (!result.launched) {
-        const intentionalSkips = new Set(['no_preview', 'cli', 'none']);
+        const intentionalSkips = new Set(['no_preview', 'cli', 'none', 'no_command', 'no_dev_script']);
         if (intentionalSkips.has(result.reason)) {
           console.log(`[Groove] Preview for team ${teamId} intentionally skipped: ${result.reason}`);
           return;
@@ -1497,6 +1537,15 @@ For normal file edits within your scope, proceed without review.
     const agent = registry.get(agentId);
     if (!agent) throw new Error(`Agent ${agentId} not found`);
 
+    // Agent-loop providers: resume from saved session file
+    const resumeProvider = getProvider(agent.provider || 'claude-code');
+    if (resumeProvider?.constructor?.useAgentLoop) {
+      const sessionPath = resolve(this.daemon.grooveDir, 'sessions', `${agentId}.json`);
+      if (existsSync(sessionPath)) {
+        return this._resumeAgentLoop(agentId, agent, message, resumeProvider);
+      }
+    }
+
     // If no session ID, fall back to rotation (handoff brief)
     if (!agent.sessionId) {
       return this.daemon.rotator.rotate(agentId, { additionalPrompt: message });
@@ -1642,6 +1691,155 @@ For normal file edits within your scope, proceed without review.
     return newAgent;
   }
 
+  async _resumeAgentLoop(agentId, agent, message, provider) {
+    const { registry, locks } = this.daemon;
+    const config = { ...agent };
+
+    if (this.handles.has(agentId)) {
+      await this.kill(agentId);
+    }
+    registry.remove(agentId);
+    locks.release(agentId);
+
+    const newAgent = registry.add({
+      role: config.role,
+      scope: config.scope,
+      provider: config.provider,
+      model: config.model,
+      prompt: config.prompt,
+      permission: config.permission,
+      workingDir: config.workingDir || undefined,
+      name: config.name,
+      teamId: config.teamId,
+    });
+
+    if (config.tokensUsed > 0) {
+      registry.update(newAgent.id, { tokensUsed: config.tokensUsed });
+    }
+
+    if (newAgent.scope?.length > 0) {
+      locks.register(newAgent.id, newAgent.scope, newAgent.workingDir);
+    }
+
+    // Move session file from old agent ID to new agent ID
+    const sessionsDir = resolve(this.daemon.grooveDir, 'sessions');
+    const oldSessionPath = resolve(sessionsDir, `${agentId}.json`);
+    const newSessionPath = resolve(sessionsDir, `${newAgent.id}.json`);
+    if (oldSessionPath !== newSessionPath && existsSync(oldSessionPath)) {
+      try {
+        mkdirSync(sessionsDir, { recursive: true });
+        copyFileSync(oldSessionPath, newSessionPath);
+        unlinkSync(oldSessionPath);
+      } catch { /* AgentLoop will start fresh if file is missing */ }
+    }
+
+    const logDir = resolve(this.daemon.grooveDir, 'logs');
+    mkdirSync(logDir, { recursive: true });
+    const logPath = resolve(logDir, `${sanitizeFilename(newAgent.name)}.log`);
+    const logStream = createWriteStream(logPath, { flags: 'a', mode: 0o600 });
+    logStream.write(`[${new Date().toISOString()}] GROOVE resuming agent-loop session\n`);
+
+    // Inject API key
+    const spawnConfig = { ...newAgent, ...config };
+    if (this.daemon.credentials) {
+      const storedKey = this.daemon.credentials.getKey(newAgent.provider);
+      if (storedKey) spawnConfig.apiKey = storedKey;
+    }
+
+    const loopConfig = provider.getLoopConfig(spawnConfig);
+    const loop = new AgentLoop({ daemon: this.daemon, agent: newAgent, loopConfig, logStream });
+
+    this.handles.set(newAgent.id, { loop, logStream });
+    registry.update(newAgent.id, { status: 'running' });
+
+    if (this.daemon.timeline) {
+      this.daemon.timeline.recordEvent('spawn', {
+        agentId: newAgent.id, agentName: newAgent.name, role: newAgent.role,
+        provider: newAgent.provider, model: loopConfig.model,
+      });
+    }
+
+    loop.on('output', (output) => {
+      this._handleAgentOutput(newAgent.id, output);
+    });
+
+    loop.on('exit', ({ code, signal, status }) => {
+      logStream.write(`[${new Date().toISOString()}] Agent loop exited: status=${status}\n`);
+      logStream.end();
+      this.handles.delete(newAgent.id);
+
+      const throttle = this._streamThrottle.get(newAgent.id);
+      if (throttle?.timer) clearTimeout(throttle.timer);
+      this._streamThrottle.delete(newAgent.id);
+      this.peakContextUsage.delete(newAgent.id);
+      this.pendingMessages.delete(newAgent.id);
+      registry.update(newAgent.id, { status, pid: null });
+
+      const agentData = registry.get(newAgent.id);
+
+      if (this.daemon.timeline) {
+        const evtType = status === 'completed' ? 'complete' : status === 'crashed' ? 'crash' : 'kill';
+        this.daemon.timeline.recordEvent(evtType, {
+          agentId: newAgent.id, agentName: newAgent.name, role: newAgent.role,
+          finalTokens: agentData?.tokensUsed || 0, costUsd: agentData?.costUsd || 0,
+        });
+      }
+
+      this.daemon.broadcast({ type: 'agent:exit', agentId: newAgent.id, code: code || 0, signal, status });
+      if (this.daemon.integrations) this.daemon.integrations.refreshMcpJson();
+
+      if (status === 'completed' && this.daemon.journalist) {
+        const turns = agentData?.turns || 0;
+        const tok = agentData?.tokensUsed || 0;
+        if (turns > 1 || tok >= 100) this.daemon.journalist.requestSynthesis('completion');
+      }
+      this._checkPhase2(newAgent.id);
+
+      if (status === 'completed') {
+        const files = this.daemon.journalist?.getAgentFiles(newAgent) || [];
+        if (files.length > 0) this._triggerIdleQC(newAgent);
+        this._processHandoffs(newAgent);
+        if (this._rotatingAgents.has(newAgent.id)) {
+          this._rotatingAgents.delete(newAgent.id);
+        } else {
+          this._writeCompletionHandoff(newAgent).catch(err =>
+            console.error(`[Groove] Completion handoff failed for ${newAgent.name}:`, err.message));
+        }
+      }
+    });
+
+    loop.on('error', ({ message: errMsg }) => {
+      this.daemon.broadcast({
+        type: 'agent:output', agentId: newAgent.id,
+        data: { type: 'activity', subtype: 'error', data: errMsg },
+      });
+    });
+
+    loop.start();
+    loop.sendMessage(message);
+
+    this.daemon.broadcast({
+      type: 'rotation:complete',
+      agentId: newAgent.id,
+      agentName: newAgent.name,
+      oldAgentId: agentId,
+      reason: 'resume',
+      tokensSaved: 0,
+    });
+
+    return newAgent;
+  }
+
+  cleanupTeamSessions(teamId) {
+    const { registry } = this.daemon;
+    const teamAgents = registry.getAll().filter(a => a.teamId === teamId);
+    const sessionsDir = resolve(this.daemon.grooveDir, 'sessions');
+    for (const agent of teamAgents) {
+      const sessionPath = resolve(sessionsDir, `${agent.id}.json`);
+      try { if (existsSync(sessionPath)) unlinkSync(sessionPath); } catch { /* non-fatal */ }
+    }
+  }
+
   /**
    * Stop the agent's current work without killing the agent.
    * The process is terminated but the agent stays in the registry with its
@@ -1749,6 +1947,10 @@ For normal file edits within your scope, proceed without review.
     const agent = this.daemon.registry.get(agentId);
     const wrapped = agent ? wrapWithRoleReminder(agent.role, message) : message;
 
+    if (this.daemon.trajectoryCapture) {
+      try { this.daemon.trajectoryCapture.onUserMessage(agentId, message); } catch (e) { /* fail silent */ }
+    }
+
     loop.sendMessage(wrapped).catch(() => {});
     return true;
   }

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

@@ -37,6 +37,7 @@ export class GrokProvider extends Provider {
     { id: 'grok-3-mini', name: 'Grok 3 Mini', tier: 'light', maxContext: 131072, pricing: { input: 0.0003, output: 0.0005 } },
     { id: 'grok-imagine-image', name: 'Grok Imagine', tier: 'medium', type: 'image', pricing: { perImage: 0.07 } },
   ];
+  static useAgentLoop = true;
 
   static isInstalled() {
     return true; // API-only, no CLI needed
@@ -54,6 +55,20 @@ export class GrokProvider extends Provider {
     return null; // No CLI
   }
 
+  getLoopConfig(agent) {
+    return {
+      apiBase: 'https://api.x.ai/v1',
+      model: agent.model || 'grok-4-1-fast',
+      contextWindow: 131072,
+      temperature: 0.1,
+      maxResponseTokens: 16384,
+      stream: true,
+      apiKey: agent.apiKey,
+      headers: {},
+      introContext: agent.introContext || '',
+    };
+  }
+
   switchModel() {
     return false;
   }

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

@@ -1,12 +1,13 @@
 // GROOVE — State Persistence
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { readFileSync, existsSync } from 'fs';
+import { readFileSync, existsSync, readdirSync, unlinkSync } from 'fs';
 import { writeFile } from 'node:fs/promises';
 import { resolve } from 'path';
 
 export class StateManager {
   constructor(grooveDir) {
+    this.grooveDir = grooveDir;
     this.path = resolve(grooveDir, 'state.json');
     this.data = {};
   }
@@ -32,4 +33,22 @@ export class StateManager {
   set(key, value) {
     this.data[key] = value;
   }
+
+  getResumableSessions() {
+    const sessionsDir = resolve(this.grooveDir, 'sessions');
+    if (!existsSync(sessionsDir)) return [];
+    try {
+      return readdirSync(sessionsDir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => f.replace('.json', ''));
+    } catch { return []; }
+  }
+
+  cleanupSessions(agentIds) {
+    const sessionsDir = resolve(this.grooveDir, 'sessions');
+    for (const id of agentIds) {
+      const sessionPath = resolve(sessionsDir, `${id}.json`);
+      try { if (existsSync(sessionPath)) unlinkSync(sessionPath); } catch { /* non-fatal */ }
+    }
+  }
 }