groove-dev 0.27.156 → 0.27.159

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/cli",
-  "version": "0.27.156",
+  "version": "0.27.159",
   "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.156",
+  "version": "0.27.159",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

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

@@ -483,6 +483,9 @@ export class Journalist {
       'Be specific. Name files, functions, and line numbers. Do not summarize vaguely.',
       'Preserve the investigation narrative — the next agent needs to understand the',
       'journey, not just the destination.',
+      'IMPORTANT: Focus on what the user ASKED the agent to do (the original task).',
+      'Do NOT include observations about unrelated code issues, potential improvements,',
+      'or things the agent noticed but did not act on. The next agent must stay on task.',
       'Keep your response under 4000 characters.',
       '',
       '---',
@@ -1024,7 +1027,13 @@ export class Journalist {
       originalTask ? `## Original Task\n\n${originalTask}\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 the work and deliver the output.`,
+      `## Instructions`,
+      ``,
+      `Continue and finish the in-progress task — deliver the output. Stay focused on that specific task only.`,
+      `- Do NOT explore the codebase looking for other things to fix or improve`,
+      `- Do NOT start new work outside the original task scope`,
+      `- Do NOT act on TODO comments, code quality issues, or improvements you notice in passing`,
+      `- If the task is already complete, report what was accomplished and STOP — await new instructions from the user`,
     ].filter(Boolean).join('\n');
 
     // Hard cap: 16000 chars — investigation context needs room to preserve the full narrative
@@ -1142,34 +1151,60 @@ export class Journalist {
    * Build a full context-resume prompt that preserves the conversation
    * thread so a fresh agent picks up where the previous session left off.
    */
-  buildConversationResumePrompt(agent, userMessage) {
+  buildConversationResumePrompt(agent, userMessage, { isRotation = false, reason } = {}) {
     const thread = this.extractConversationThread(agent);
     if (!thread) return null;
 
     const constraints = this.daemon.memory?.getConstraintsMarkdown(2000) || '';
     const discoveries = this.daemon.memory?.getDiscoveriesMarkdown(agent.role, 5, 1000, agent.scope, agent.teamId) || '';
 
+    // Extract the user's original task from the conversation — the first substantial
+    // user message is almost always the task assignment. This anchors the new agent.
+    const originalTask = this._extractOriginalTask(thread);
+
+    // Rotation and idle-resume need very different framing. During rotation the agent
+    // has no new user message — it must continue the exact in-progress task without
+    // drifting. During idle-resume the user explicitly sent a message to continue.
+    const isIdleResume = !isRotation && userMessage && userMessage.trim().length > 0;
+
+    const taskFocusBlock = isRotation ? [
+      `## CRITICAL: Task Focus`,
+      ``,
+      `You were auto-rotated (reason: ${reason || 'context_management'}) — this is a routine context refresh, NOT a new assignment.`,
+      originalTask ? `Your task: ${originalTask}` : '',
+      ``,
+      `Rules:`,
+      `- Continue ONLY the task described in the conversation below`,
+      `- Do NOT explore the codebase looking for other things to fix or improve`,
+      `- Do NOT start new work that was not part of the original task`,
+      `- Do NOT act on TODO comments, code quality issues, or improvements you notice in passing`,
+      `- If the task is complete, report what was done and STOP — await new instructions from the user`,
+      `- If the task is in progress, pick up exactly where the previous session left off`,
+      ``,
+    ] : [];
+
     let prompt = [
       `# Session Context Resume`,
       ``,
-      `You are continuing a session that went idle. Below is the full conversation`,
-      `from your previous session — your actual exchanges with the user. Pick up`,
-      `exactly where you left off. The user's new message follows at the end.`,
+      isRotation
+        ? `You are continuing a session after an automatic context rotation. Your context was refreshed but your task has NOT changed. The conversation below is your previous session — continue the same work.`
+        : `You are continuing a session that went idle. Below is the full conversation from your previous session — your actual exchanges with the user. Pick up exactly where you left off. The user's new message follows at the end.`,
       ``,
       `Role: ${agent.role} | Provider: ${agent.provider} | Scope: ${agent.scope?.join(', ') || 'unrestricted'}`,
       agent.workingDir ? `Working directory: ${agent.workingDir}` : '',
       ``,
+      ...taskFocusBlock,
       constraints ? `## Project Constraints\n\n${constraints}\n` : '',
       discoveries ? `## Known Issues & Fixes\n\n${discoveries}\n` : '',
       `## Previous Conversation\n\n${thread}`,
       ``,
       `---`,
       ``,
-      `## New Message From User`,
-      ``,
-      userMessage,
+      isIdleResume ? `## New Message From User\n\n${userMessage}` : '',
       ``,
-      `Continue seamlessly from the conversation above. You have the full context of what was discussed, what was tried, what worked and what didn't. Do not ask the user to repeat anything.`,
+      isRotation
+        ? `Continue the in-progress task from the conversation above. Stay focused on that task only. Do not ask the user to repeat anything. If the task was already completed, state that and wait for new instructions.`
+        : `Continue seamlessly from the conversation above. You have the full context of what was discussed, what was tried, what worked and what didn't. Do not ask the user to repeat anything.`,
     ].filter(Boolean).join('\n');
 
     // Hard cap at 80K chars (~20K tokens) to leave plenty of room in context window
@@ -1180,23 +1215,24 @@ export class Journalist {
         prompt = [
           `# Session Context Resume`,
           ``,
-          `You are continuing a session that went idle. Below is the conversation`,
-          `from your previous session (older turns summarized to fit). Pick up`,
-          `exactly where you left off.`,
+          isRotation
+            ? `You are continuing after an automatic context rotation. Your task has NOT changed.`
+            : `You are continuing a session that went idle (older turns summarized to fit). Pick up exactly where you left off.`,
           ``,
           `Role: ${agent.role} | Scope: ${agent.scope?.join(', ') || 'unrestricted'}`,
           agent.workingDir ? `Working directory: ${agent.workingDir}` : '',
           ``,
+          ...taskFocusBlock,
           constraints ? `## Project Constraints\n\n${constraints}\n` : '',
           `## Previous Conversation\n\n${smallerThread}`,
           ``,
           `---`,
           ``,
-          `## New Message From User`,
-          ``,
-          userMessage,
+          isIdleResume ? `## New Message From User\n\n${userMessage}` : '',
           ``,
-          `Continue seamlessly. Do not ask the user to repeat anything.`,
+          isRotation
+            ? `Continue the in-progress task only. Do not explore or start new work. If done, state that and wait.`
+            : `Continue seamlessly. Do not ask the user to repeat anything.`,
         ].filter(Boolean).join('\n');
       }
     }
@@ -1204,6 +1240,15 @@ export class Journalist {
     return prompt;
   }
 
+  _extractOriginalTask(thread) {
+    // Find the first substantial USER message in the thread — that's the task.
+    const match = thread.match(/\[USER\]:\n([\s\S]*?)(?=\n\n---|\n\[CLAUDE\]:|$)/);
+    if (!match) return '';
+    const firstMsg = match[1].trim();
+    if (firstMsg.length < 10) return '';
+    return firstMsg.length > 500 ? firstMsg.slice(0, 500) + '...' : firstMsg;
+  }
+
   // --- Workspace Grouping ---
 
   /**

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

@@ -507,6 +507,7 @@ export class ProcessManager {
 
     if (finalStatus === 'completed' && agent.role === 'planner') {
       this._extractRecommendedTeam(agent, logPath);
+      this._consumeRecommendedTeamAutonomous(agent);
       this._handleReviewComplete(agent);
     }
 
@@ -534,7 +535,7 @@ export class ProcessManager {
 
     this._checkPhase2(agent.id);
 
-    if (finalStatus === 'completed' && agent.role === 'fullstack' && agent.teamId) {
+    if (finalStatus === 'completed' && agent.role === 'fullstack' && agent.teamId && agent.metadata?.isQcPhase2) {
       this._triggerReview(agent);
     }
 
@@ -1755,6 +1756,114 @@ For normal file edits within your scope, proceed without review.
     } catch { /* best effort */ }
   }
 
+  /**
+   * Daemon-autonomous consumption of recommended-team.json.
+   * If the file exists and the GUI hasn't already consumed it (no _pendingPhase2
+   * for this team), broadcast a notification so the GUI picks it up on next tick.
+   * This closes the race where GUI polling stops before the file is written.
+   */
+  _consumeRecommendedTeamAutonomous(agent) {
+    try {
+      const workDir = agent.workingDir || this.daemon.projectDir;
+      const targetPath = resolve(workDir, '.groove', 'recommended-team.json');
+      if (!existsSync(targetPath)) return;
+
+      const teamId = agent.teamId || null;
+
+      // If phase 2 is already pending for this team, GUI already consumed it
+      const pending = this.daemon._pendingPhase2 || [];
+      if (teamId && pending.some(g => g.agents.some(a => a.teamId === teamId))) return;
+
+      // Broadcast so the GUI knows to fetch — even if its polling interval was cleared
+      this.daemon.broadcast({
+        type: 'recommended-team:ready',
+        teamId,
+        agentId: agent.id,
+        agentName: agent.name,
+      });
+
+      // Delayed self-consumption: if the GUI doesn't consume within 5s, daemon does it directly
+      setTimeout(() => {
+        if (!existsSync(targetPath)) return; // GUI consumed it
+        try {
+          const raw = JSON.parse(readFileSync(targetPath, 'utf8'));
+          delete raw._meta;
+          const agentConfigs = Array.isArray(raw) ? raw : (raw.agents || []);
+          if (agentConfigs.length === 0) return;
+
+          const phase1 = agentConfigs.filter(a => !a.phase || a.phase === 1);
+          const phase2 = agentConfigs.filter(a => a.phase === 2);
+          if (phase1.length === 0) return;
+
+          // Check again — GUI may have consumed during the timeout
+          const currentPending = this.daemon._pendingPhase2 || [];
+          if (teamId && currentPending.some(g => g.agents.some(a => a.teamId === teamId))) return;
+
+          const baseDir = agent.workingDir || this.daemon.projectDir;
+          const projectDir = raw.projectDir || null;
+          let projectWorkingDir = baseDir;
+          if (projectDir) {
+            const safeName = String(projectDir).replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 64);
+            projectWorkingDir = resolve(baseDir, safeName);
+            mkdirSync(projectWorkingDir, { recursive: true });
+          }
+
+          const defaultTeamId = teamId || this.daemon.teams.getDefault()?.id || null;
+          const phase1Ids = [];
+
+          // Spawn phase 1 agents
+          const spawnPromises = phase1.map(async (config) => {
+            try {
+              const validated = validateAgentConfig({
+                role: config.role,
+                scope: config.scope || [],
+                prompt: config.prompt || '',
+                provider: config.provider || agent.provider || this.daemon.config?.defaultProvider,
+                model: config.model || agent.model || this.daemon.config?.defaultModel || 'auto',
+                permission: config.permission || 'auto',
+                workingDir: config.workingDir || projectWorkingDir,
+                name: config.name || undefined,
+              });
+              validated.teamId = defaultTeamId;
+              const spawned = await this.spawn(validated);
+              phase1Ids.push(spawned.id);
+              return spawned;
+            } catch (err) {
+              console.error(`[Groove] Autonomous team launch: failed to spawn ${config.role}: ${err.message}`);
+              return null;
+            }
+          });
+
+          Promise.all(spawnPromises).then(() => {
+            // Set up phase 2 pending
+            if (phase2.length > 0 && phase1Ids.length > 0) {
+              this.daemon._pendingPhase2 = this.daemon._pendingPhase2 || [];
+              this.daemon._pendingPhase2.push({
+                waitFor: phase1Ids,
+                agents: phase2.map(c => ({
+                  role: c.role, scope: c.scope || [], prompt: c.prompt || '',
+                  provider: c.provider || agent.provider || this.daemon.config?.defaultProvider,
+                  model: c.model || agent.model || this.daemon.config?.defaultModel || 'auto',
+                  permission: c.permission || 'auto',
+                  workingDir: c.workingDir || projectWorkingDir,
+                  name: c.name || undefined,
+                  teamId: defaultTeamId,
+                })),
+              });
+            }
+
+            // Clean up the file
+            try { unlinkSync(targetPath); } catch { /* */ }
+            this.daemon.audit?.log('team.autonomousLaunch', { teamId: defaultTeamId, phase1: phase1Ids.length, phase2: phase2.length });
+            console.log(`[Groove] Autonomous team launch: ${phase1Ids.length} phase 1 agents spawned for team ${defaultTeamId}`);
+          });
+        } catch (err) {
+          console.error(`[Groove] Autonomous team consumption failed: ${err.message}`);
+        }
+      }, 5000);
+    } catch { /* best effort */ }
+  }
+
   /**
    * Check if a completed/crashed agent was the last phase 1 agent in a team.
    * If so, auto-spawn the phase 2 (QC/finisher) agents.
@@ -1834,13 +1943,26 @@ For normal file edits within your scope, proceed without review.
           try {
             const validated = validateAgentConfig(config);
             if (!validated.teamId) validated.teamId = this.daemon.teams.getDefault()?.id || null;
+            validated.metadata = { ...(validated.metadata || {}), isQcPhase2: true };
+            const existingId = existing?.id || null;
             const p = this.spawn(validated).then((agent) => {
+              registry.update(agent.id, { metadata: { ...(agent.metadata || {}), isQcPhase2: true } });
               this.daemon.broadcast({
                 type: 'phase2:spawned',
                 agentId: agent.id,
+                oldAgentId: existingId,
                 name: agent.name,
                 role: agent.role,
               });
+              if (existingId) {
+                this.daemon.broadcast({
+                  type: 'rotation:complete',
+                  agentId: agent.id,
+                  oldAgentId: existingId,
+                  agentName: agent.name,
+                  reason: 'phase2_respawn',
+                });
+              }
               this.daemon.audit.log('phase2.autoSpawn', { id: agent.id, name: agent.name, role: agent.role });
             }).catch((err) => {
               console.error(`[Groove] Phase 2 spawn failed for ${config.role}: ${err.message}`);
@@ -1884,6 +2006,7 @@ For normal file edits within your scope, proceed without review.
     const teamId = agent.teamId;
     if (!teamId) return;
     if (this._reviewTriggered.has(teamId)) return;
+    this._reviewTriggered.add(teamId);
 
     const registry = this.daemon.registry;
     const teamAgents = registry.getAll().filter(a => a.teamId === teamId);
@@ -1898,7 +2021,6 @@ For normal file edits within your scope, proceed without review.
       a.role !== 'planner' && (a.status === 'running' || a.status === 'starting'));
     if (hasRunning) return;
 
-    this._reviewTriggered.add(teamId);
     this._reviewPending.add(teamId);
 
     const journalist = this.daemon.journalist;
@@ -1912,6 +2034,12 @@ For normal file edits within your scope, proceed without review.
       for (const f of (journalist?.getAgentFiles(a) || [])) allFiles.add(f);
     }
 
+    if (!originalSpec.trim() && !plannerResult.trim() && allFiles.size === 0) {
+      console.log(`[Groove] Review skipped for team ${teamId}: no spec, plan, or files to review`);
+      this._reviewPending.delete(teamId);
+      return;
+    }
+
     const reviewPrompt = `You are reviewing a completed team build against the original specification.
 
 ## Original Task

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

@@ -367,7 +367,8 @@ export class Rotator extends EventEmitter {
       if (typeof journalist.buildConversationResumePrompt === 'function') {
         const conversationPrompt = journalist.buildConversationResumePrompt(
           agent,
-          options.additionalPrompt || ''
+          options.additionalPrompt || '',
+          { isRotation: true, reason: options.reason || 'auto' }
         );
         if (conversationPrompt && conversationPrompt.length > 500) {
           brief = conversationPrompt;

package/node_modules/@groove-dev/daemon/src/routes/files.js

@@ -665,24 +665,46 @@ export function registerFileRoutes(app, daemon) {
     const rawFiles = daemon.registry.getFilesTouched(req.params.id);
     const rootDir = agent.workingDir || daemon.projectDir;
 
-    // Build git diff numstat for line-level +/- counts
+    // Build git diff numstat for line-level +/- counts (unstaged + staged + untracked)
     let numstatMap = {};
     const writtenPaths = rawFiles.filter(f => f.writes > 0).map(f => f.path);
     if (writtenPaths.length > 0) {
-      try {
-        const out = execFileSync('git', ['diff', '--numstat', '--', ...writtenPaths], {
-          cwd: rootDir, timeout: 10000, maxBuffer: 2 * 1024 * 1024,
-        }).toString();
+      const parseNumstat = (out) => {
         for (const line of out.split('\n')) {
           const m = line.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
-          if (m) {
+          if (m && !numstatMap[m[3]]) {
             numstatMap[m[3]] = {
               additions: m[1] === '-' ? 0 : Number(m[1]),
               deletions: m[2] === '-' ? 0 : Number(m[2]),
             };
           }
         }
+      };
+      try {
+        const unstaged = execFileSync('git', ['diff', '--numstat', '--', ...writtenPaths], {
+          cwd: rootDir, timeout: 10000, maxBuffer: 2 * 1024 * 1024,
+        }).toString();
+        parseNumstat(unstaged);
       } catch { /* git not available or not a repo */ }
+      try {
+        const staged = execFileSync('git', ['diff', '--cached', '--numstat', '--', ...writtenPaths], {
+          cwd: rootDir, timeout: 10000, maxBuffer: 2 * 1024 * 1024,
+        }).toString();
+        parseNumstat(staged);
+      } catch { /* ignore */ }
+      // For untracked files not covered by diff, count lines as all additions
+      for (const p of writtenPaths) {
+        if (numstatMap[p]) continue;
+        const full = isAbsolute(p) ? p : resolve(rootDir, p);
+        try {
+          const stat = statSync(full);
+          if (stat.isFile()) {
+            const content = readFileSync(full, 'utf8');
+            const lineCount = content.split('\n').length;
+            numstatMap[p] = { additions: lineCount, deletions: 0 };
+          }
+        } catch { /* file may not exist */ }
+      }
     }
 
     const files = rawFiles.map(f => {