groove-dev 0.27.77 → 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/process.js

@@ -466,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;
@@ -669,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);
@@ -878,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,
@@ -1025,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 */ }
+      }
     }
   }
 
@@ -1500,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 });
@@ -1645,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
@@ -1752,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 */ }
+    }
+  }
 }