groove-dev 0.26.17 → 0.26.19

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

@@ -1768,7 +1768,17 @@ Keep responses concise. Help them think, don't lecture them about the system the
       }
 
       const baseDir = daemon.config?.defaultWorkingDir || daemon.projectDir;
-      const defaultTeamId = daemon.teams.getDefault()?.id || null;
+
+      // Use the planner's teamId so launched agents join the correct team.
+      // Accept explicit teamId from request body, or find the most recent planner agent.
+      let launchTeamId = req.body?.teamId || null;
+      if (!launchTeamId) {
+        const planners = daemon.registry.getAll()
+          .filter((a) => a.role === 'planner')
+          .sort((a, b) => (b.lastActivity || '').localeCompare(a.lastActivity || ''));
+        launchTeamId = planners[0]?.teamId || null;
+      }
+      const defaultTeamId = launchTeamId || daemon.teams.getDefault()?.id || null;
 
       // If planner specified a project directory, create it and use it as workingDir
       let projectWorkingDir = baseDir;
@@ -1793,29 +1803,57 @@ Keep responses concise. Help them think, don't lecture them about the system the
         }];
       }
 
-      // Spawn phase 1 agents immediately — all scoped to projectWorkingDir
+      // Spawn phase 1 agents — reuse idle team members with matching roles when possible
       const spawned = [];
+      const reused = [];
       const failed = [];
       const phase1Ids = [];
+      const teamAgents = daemon.registry.getAll().filter((a) => a.teamId === defaultTeamId);
+
       for (const config of phase1) {
-        try {
-          const validated = validateAgentConfig({
-            role: config.role,
-            scope: config.scope || [],
-            prompt: config.prompt || '',
-            provider: config.provider || undefined,
-            model: config.model || 'auto',
-            permission: config.permission || 'auto',
-            workingDir: config.workingDir || projectWorkingDir,
-            name: config.name || undefined,
-          });
-          validated.teamId = defaultTeamId;
-          const agent = await daemon.processes.spawn(validated);
-          spawned.push({ id: agent.id, name: agent.name, role: agent.role });
-          phase1Ids.push(agent.id);
-        } catch (err) {
-          failed.push({ role: config.role, error: err.message });
-          console.log(`[Groove] Failed to spawn ${config.role}: ${err.message}`);
+        const prompt = config.prompt || '';
+
+        // Reuse an existing agent with matching role in this team — never spawn
+        // duplicates. The team's agents persist across tasks.
+        const existing = teamAgents.find((a) =>
+          a.role === config.role &&
+          a.role !== 'planner' &&
+          (a.status === 'running' || a.status === 'completed') &&
+          !reused.some((r) => r.id === a.id) // don't reuse the same agent twice
+        );
+
+        if (existing && prompt) {
+          // Instruct the existing agent instead of spawning a new one
+          try {
+            const newAgent = await daemon.processes.resume(existing.id, prompt);
+            reused.push({ id: newAgent.id, name: newAgent.name, role: newAgent.role, reusedFrom: existing.name });
+            phase1Ids.push(newAgent.id);
+            daemon.audit.log('team.reuse', { oldId: existing.id, newId: newAgent.id, role: config.role });
+          } catch (err) {
+            // Reuse failed — fall through to spawn
+            failed.push({ role: config.role, error: `reuse failed: ${err.message}` });
+          }
+        } else {
+          // No matching idle agent — spawn a new one
+          try {
+            const validated = validateAgentConfig({
+              role: config.role,
+              scope: config.scope || [],
+              prompt,
+              provider: config.provider || undefined,
+              model: config.model || 'auto',
+              permission: config.permission || 'auto',
+              workingDir: config.workingDir || projectWorkingDir,
+              name: config.name || undefined,
+            });
+            validated.teamId = defaultTeamId;
+            const agent = await daemon.processes.spawn(validated);
+            spawned.push({ id: agent.id, name: agent.name, role: agent.role });
+            phase1Ids.push(agent.id);
+          } catch (err) {
+            failed.push({ role: config.role, error: err.message });
+            console.log(`[Groove] Failed to spawn ${config.role}: ${err.message}`);
+          }
         }
       }
 
@@ -1836,10 +1874,10 @@ Keep responses concise. Help them think, don't lecture them about the system the
       }
 
       daemon.audit.log('team.launch', {
-        phase1: spawned.length, phase2Pending: phase2.length, failed: failed.length,
-        agents: spawned.map((a) => a.role), projectDir: projectDir || null,
+        phase1: spawned.length, reused: reused.length, phase2Pending: phase2.length, failed: failed.length,
+        agents: [...spawned, ...reused].map((a) => a.role), projectDir: projectDir || null,
       });
-      res.json({ launched: spawned.length, phase2Pending: phase2.length, agents: spawned, failed, projectDir: projectDir || null });
+      res.json({ launched: spawned.length, reused: reused.length, phase2Pending: phase2.length, agents: [...spawned, ...reused], failed, projectDir: projectDir || null });
     } catch (err) {
       res.status(500).json({ error: err.message });
     }

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

@@ -5,7 +5,7 @@ import { createServer as createHttpServer } from 'http';
 import { createServer as createNetServer } from 'net';
 import { execFileSync } from 'child_process';
 import { resolve } from 'path';
-import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync, readdirSync, rmdirSync, statSync } from 'fs';
+import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync, readdirSync, rmdirSync, rmSync, statSync } from 'fs';
 import express from 'express';
 import { WebSocketServer } from 'ws';
 import { Registry } from './registry.js';
@@ -345,42 +345,23 @@ export class Daemon {
       // Build set of agent names still in the registry — never remove their logs
       const activeNames = new Set(this.registry.getAll().map((a) => a.name));
 
-      // 1. Clean old raw log files (>7 days, agent no longer in registry)
+      // 1. Clean raw log files for agents no longer in the registry
       const logsDir = resolve(grooveDir, 'logs');
       if (existsSync(logsDir)) {
-        const now = Date.now();
-        const sevenDays = 7 * 24 * 60 * 60 * 1000;
         for (const file of readdirSync(logsDir)) {
           const agentName = file.replace(/\.log$/, '');
-          if (activeNames.has(agentName)) continue; // agent still exists
-          const p = resolve(logsDir, file);
-          try {
-            const age = now - statSync(p).mtimeMs;
-            if (age > sevenDays) { unlinkSync(p); cleaned++; }
-          } catch { /* skip */ }
+          if (activeNames.has(agentName)) continue;
+          try { unlinkSync(resolve(logsDir, file)); cleaned++; } catch { /* skip */ }
         }
       }
 
-      // 2. Clean old GROOVE_AGENT_LOGS/ session logs (>3 days, agent no longer in registry)
+      // 2. Clean GROOVE_AGENT_LOGS/ for agents no longer in the registry
       const agentLogsDir = resolve(this.projectDir, 'GROOVE_AGENT_LOGS');
       if (existsSync(agentLogsDir)) {
-        const threeDays = 3 * 24 * 60 * 60 * 1000;
-        const now2 = Date.now();
         for (const dir of readdirSync(agentLogsDir, { withFileTypes: true })) {
           if (!dir.isDirectory()) continue;
-          if (activeNames.has(dir.name)) continue; // agent still exists
-          const agentDir = resolve(agentLogsDir, dir.name);
-          try {
-            const files = readdirSync(agentDir);
-            for (const f of files) {
-              const fp = resolve(agentDir, f);
-              try {
-                if (now2 - statSync(fp).mtimeMs > threeDays) { unlinkSync(fp); cleaned++; }
-              } catch { /* skip */ }
-            }
-            // Remove empty agent directories
-            if (readdirSync(agentDir).length === 0) { rmdirSync(agentDir); cleaned++; }
-          } catch { /* skip */ }
+          if (activeNames.has(dir.name)) continue;
+          try { rmSync(resolve(agentLogsDir, dir.name), { recursive: true }); cleaned++; } catch { /* skip */ }
         }
         // Remove GROOVE_AGENT_LOGS/ itself if empty
         try { if (readdirSync(agentLogsDir).length === 0) rmdirSync(agentLogsDir); } catch { /* skip */ }
@@ -411,7 +392,19 @@ export class Daemon {
         } catch { /* skip */ }
       }
 
+      // 5. Refresh journalist context — regenerate project map and registry
+      //    so stale agent references don't persist in GROOVE_PROJECT_MAP.md
       if (cleaned > 0) {
+        this.introducer.writeRegistryFile(this.projectDir);
+        this.introducer.injectGrooveSection(this.projectDir);
+        // Clear journalist's stale in-memory state for removed agents
+        this.journalist.lastLogSizes = Object.fromEntries(
+          Object.entries(this.journalist.lastLogSizes).filter(([id]) => {
+            return this.registry.getAll().some((a) => a.id === id);
+          })
+        );
+        // Re-synthesize project map based on current agents only
+        this.journalist.cycle().catch(() => {});
         this.audit.log('gc.run', { cleaned });
       }
     } catch { /* gc should never crash the daemon */ }

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

@@ -370,8 +370,9 @@ For normal file edits within your scope, proceed without review.
         this._checkPhase2(agent.id);
 
         // Auto-trigger idle QC in the same team
-        if (status === 'completed' && (agent.tokensUsed || 0) > 2000) {
-          this._triggerIdleQC(agent);
+        if (status === 'completed') {
+          const files = this.daemon.journalist?.getAgentFiles(agent) || [];
+          if (files.length > 0) this._triggerIdleQC(agent);
         }
       });
 
@@ -567,10 +568,11 @@ For normal file edits within your scope, proceed without review.
       // Phase 2 auto-spawn: check if all phase 1 agents for a team are done
       this._checkPhase2(agent.id);
 
-      // Auto-trigger idle QC: if this agent did real work and there's an idle QC
+      // Auto-trigger idle QC: if this agent modified files and there's an idle QC
       // in the same team, activate it to verify the changes
-      if (finalStatus === 'completed' && (agent.tokensUsed || 0) > 2000) {
-        this._triggerIdleQC(agent);
+      if (finalStatus === 'completed') {
+        const files = this.daemon.journalist?.getAgentFiles(agent) || [];
+        if (files.length > 0) this._triggerIdleQC(agent);
       }
     });
 
@@ -671,11 +673,14 @@ For normal file edits within your scope, proceed without review.
         // Remove from pending
         pending.splice(i, 1);
 
-        // Check if phase 1 agents did any real work.
-        // Low token usage means they just introduced themselves and waited.
+        // Check if phase 1 agents did any real work by looking at file modifications.
+        // If no agent modified any files, there's nothing to QC.
+        const journalist = this.daemon.journalist;
         const phase1Idle = group.waitFor.every((id) => {
           const a = registry.get(id);
-          return !a || (a.tokensUsed || 0) < 2000;
+          if (!a) return true;
+          const files = journalist?.getAgentFiles(a) || [];
+          return files.length === 0;
         });
 
         // Auto-spawn phase 2 agents — if phase 1 was idle, clear the prompt
@@ -716,19 +721,20 @@ For normal file edits within your scope, proceed without review.
 
   /**
    * Auto-trigger an idle QC agent in the same team when a teammate completes real work.
-   * "Idle" = running with low token usage (just an intro message, awaiting instructions).
+   * "Idle" = running fullstack agent that hasn't modified any files yet.
    */
   _triggerIdleQC(completedAgent) {
     const registry = this.daemon.registry;
     if (!completedAgent.teamId) return;
 
-    // Find a running fullstack/QC agent in the same team that's idle
+    // Find a running fullstack/QC agent in the same team that's idle (no files modified)
+    const journalist = this.daemon.journalist;
     const qc = registry.getAll().find((a) =>
       a.id !== completedAgent.id &&
       a.teamId === completedAgent.teamId &&
       a.role === 'fullstack' &&
       a.status === 'running' &&
-      (a.tokensUsed || 0) < 2000
+      (journalist?.getAgentFiles(a) || []).length === 0
     );
     if (!qc) return;
 

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

@@ -157,6 +157,10 @@ export class Teams {
     this.teams.delete(id);
     this._save();
     this.daemon.broadcast({ type: 'team:deleted', teamId: id });
+
+    // Clean up orphaned logs immediately — don't wait for the 24h GC cycle
+    try { this.daemon._gc(); } catch { /* gc should never block deletion */ }
+
     return true;
   }