groove-dev 0.18.0 → 0.18.2

package/CLAUDE.md

@@ -195,3 +195,10 @@ Fully functional multi-agent orchestration system. Tested end-to-end: planner
 - Remote access (--host 0.0.0.0 + token auth)
 - Semantic degradation detection
 - Distribution: demo video, HN launch, Twitter content
+
+<!-- GROOVE:START -->
+## GROOVE Orchestration (auto-injected)
+Active agents: 0
+See AGENTS_REGISTRY.md for full agent state.
+**Memory policy:** Ignore auto-memory. Do not read or write MEMORY.md. GROOVE manages all context.
+<!-- GROOVE:END -->

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

@@ -1,7 +1,7 @@
 {
   "name": "@groove-dev/cli",
   "version": "0.11.0",
-  "description": "GROOVE CLI — manage AI coding agents from your terminal",
+  "description": "GROOVE CLI \u2014 manage AI coding agents from your terminal",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",
   "bin": {
@@ -11,5 +11,6 @@
     "@groove-dev/daemon": "*",
     "commander": "^12.1.0",
     "chalk": "^5.3.0"
-  }
-}
+  },
+  "private": true
+}

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

@@ -1,7 +1,7 @@
 {
   "name": "@groove-dev/daemon",
   "version": "0.11.0",
-  "description": "GROOVE daemon — agent orchestration engine",
+  "description": "GROOVE daemon \u2014 agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",
   "main": "src/index.js",
@@ -14,5 +14,6 @@
     "ws": "^8.17.0",
     "express": "^4.21.0",
     "minimatch": "^10.0.0"
-  }
-}
+  },
+  "private": true
+}

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

@@ -784,6 +784,34 @@ 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 || '/';
+    if (absPath.includes('\0')) return res.status(400).json({ error: 'Invalid path' });
+    if (!existsSync(absPath)) return res.status(404).json({ error: 'Not found' });
+
+    try {
+      const entries = readdirSync(absPath, { withFileTypes: true })
+        .filter((e) => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules')
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((e) => {
+          const full = resolve(absPath, e.name);
+          let hasChildren = false;
+          try {
+            hasChildren = readdirSync(full, { withFileTypes: true })
+              .some((c) => c.isDirectory() && !c.name.startsWith('.') && c.name !== 'node_modules');
+          } catch { /* unreadable */ }
+          return { name: e.name, path: full, hasChildren };
+        });
+
+      const parent = absPath === '/' ? null : resolve(absPath, '..');
+      res.json({ current: absPath, parent, dirs: entries });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   // --- File Editor API ---
 
   const LANG_MAP = {
@@ -1124,9 +1152,25 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
   // --- Recommended Team (from planner) ---
 
+  // Find recommended-team.json — check all agent working dirs, then daemon's grooveDir
+  function findRecommendedTeam() {
+    // Check agent working dirs first (planner may have written there)
+    const agents = daemon.registry.getAll();
+    for (const agent of agents) {
+      if (agent.workingDir) {
+        const p = resolve(agent.workingDir, '.groove', 'recommended-team.json');
+        if (existsSync(p)) return p;
+      }
+    }
+    // Fallback to daemon's .groove dir
+    const p = resolve(daemon.grooveDir, 'recommended-team.json');
+    if (existsSync(p)) return p;
+    return null;
+  }
+
   app.get('/api/recommended-team', (req, res) => {
-    const teamPath = resolve(daemon.grooveDir, 'recommended-team.json');
-    if (!existsSync(teamPath)) {
+    const teamPath = findRecommendedTeam();
+    if (!teamPath) {
       return res.json({ exists: false, agents: [] });
     }
     try {
@@ -1138,8 +1182,8 @@ Keep responses concise. Help them think, don't lecture them about the system the
   });
 
   app.post('/api/recommended-team/launch', async (req, res) => {
-    const teamPath = resolve(daemon.grooveDir, 'recommended-team.json');
-    if (!existsSync(teamPath)) {
+    const teamPath = findRecommendedTeam();
+    if (!teamPath) {
       return res.status(404).json({ error: 'No recommended team found. Run a planner first.' });
     }
     try {
@@ -1148,8 +1192,24 @@ Keep responses concise. Help them think, don't lecture them about the system the
         return res.status(400).json({ error: 'Recommended team is empty' });
       }
 
+      const defaultDir = daemon.config?.defaultWorkingDir || undefined;
+
+      // Separate phase 1 (builders) and phase 2 (QC/finisher)
+      const phase1 = agents.filter((a) => !a.phase || a.phase === 1);
+      let phase2 = agents.filter((a) => a.phase === 2);
+
+      // Safety net: if planner forgot the QC agent, auto-add one
+      if (phase2.length === 0 && phase1.length >= 2) {
+        phase2 = [{
+          role: 'fullstack', phase: 2, scope: [],
+          prompt: 'QC Senior Dev: All builder agents have completed. Audit their changes for correctness, fix any issues, run tests, build the project, commit all changes, and launch. Output the localhost URL where the app can be accessed.',
+        }];
+      }
+
+      // Spawn phase 1 agents immediately
       const spawned = [];
-      for (const config of agents) {
+      const phase1Ids = [];
+      for (const config of phase1) {
         const validated = validateAgentConfig({
           role: config.role,
           scope: config.scope || [],
@@ -1157,19 +1217,59 @@ Keep responses concise. Help them think, don't lecture them about the system the
           provider: config.provider || 'claude-code',
           model: config.model || 'auto',
           permission: config.permission || 'auto',
-          workingDir: config.workingDir || undefined,
+          workingDir: config.workingDir || defaultDir,
+          name: config.name || undefined,
         });
         const agent = await daemon.processes.spawn(validated);
         spawned.push({ id: agent.id, name: agent.name, role: agent.role });
+        phase1Ids.push(agent.id);
       }
 
-      daemon.audit.log('team.launch', { count: spawned.length, agents: spawned.map((a) => a.role) });
-      res.json({ launched: spawned.length, agents: spawned });
+      // If there are phase 2 agents, register them for auto-spawn on phase 1 completion
+      if (phase2.length > 0 && phase1Ids.length > 0) {
+        daemon._pendingPhase2 = daemon._pendingPhase2 || [];
+        daemon._pendingPhase2.push({
+          waitFor: phase1Ids,
+          agents: phase2.map((c) => ({
+            role: c.role, scope: c.scope || [], prompt: c.prompt || '',
+            provider: c.provider || 'claude-code', model: c.model || 'auto',
+            permission: c.permission || 'auto',
+            workingDir: c.workingDir || defaultDir,
+            name: c.name || undefined,
+          })),
+        });
+      }
+
+      daemon.audit.log('team.launch', {
+        phase1: spawned.length, phase2Pending: phase2.length,
+        agents: spawned.map((a) => a.role),
+      });
+      res.json({ launched: spawned.length, phase2Pending: phase2.length, agents: spawned });
     } catch (err) {
       res.status(500).json({ error: err.message });
     }
   });
 
+  // Clean up stale artifacts (old plans, recommended teams, etc.)
+  app.post('/api/cleanup', (req, res) => {
+    let cleaned = 0;
+    // Clean recommended-team.json from all known locations
+    const locations = [resolve(daemon.grooveDir, 'recommended-team.json')];
+    for (const agent of daemon.registry.getAll()) {
+      if (agent.workingDir) {
+        locations.push(resolve(agent.workingDir, '.groove', 'recommended-team.json'));
+      }
+    }
+    const defaultDir = daemon.config?.defaultWorkingDir;
+    if (defaultDir) locations.push(resolve(defaultDir, '.groove', 'recommended-team.json'));
+
+    for (const p of locations) {
+      if (existsSync(p)) { try { unlinkSync(p); cleaned++; } catch { /* */ } }
+    }
+    daemon.audit.log('cleanup', { cleaned });
+    res.json({ ok: true, cleaned });
+  });
+
   // --- Command Center Dashboard ---
 
   app.get('/api/dashboard', (req, res) => {
@@ -1350,7 +1450,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
   app.patch('/api/config', async (req, res) => {
     const ALLOWED_KEYS = [
       'port', 'journalistInterval', 'rotationThreshold', 'autoRotation',
-      'qcThreshold', 'maxAgents', 'defaultProvider',
+      'qcThreshold', 'maxAgents', 'defaultProvider', 'defaultWorkingDir',
     ];
     for (const key of Object.keys(req.body)) {
       if (!ALLOWED_KEYS.includes(key)) {

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 } from 'fs';
+import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync, readdirSync, statSync } from 'fs';
 import express from 'express';
 import { WebSocketServer } from 'ws';
 import { Registry } from './registry.js';
@@ -247,6 +247,15 @@ export class Daemon {
       tester.listen(port, bindHost);
     }).catch(() => false);
 
+    if (!(await checkPort(this.port))) {
+      // Wait for port release (e.g., after groove stop)
+      let retries = 5;
+      while (retries > 0 && !(await checkPort(this.port))) {
+        await new Promise((r) => setTimeout(r, 1000));
+        retries--;
+      }
+    }
+
     if (!(await checkPort(this.port))) {
       const originalPort = this.port;
       // Try next 10 ports
@@ -281,6 +290,7 @@ export class Daemon {
         this.journalist.start();
         this.rotator.start();
         this.scheduler.start();
+        this._startGarbageCollector();
 
         // Scan codebase for workspace/structure awareness
         this.indexer.scan();
@@ -290,6 +300,62 @@ export class Daemon {
     });
   }
 
+  _startGarbageCollector() {
+    // Run once on startup, then every 24 hours
+    this._gc();
+    this._gcInterval = setInterval(() => this._gc(), 24 * 60 * 60 * 1000);
+  }
+
+  _gc() {
+    const { grooveDir } = this;
+    let cleaned = 0;
+
+    try {
+      // 1. Clean old log files (>7 days, agent no longer exists)
+      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 p = resolve(logsDir, file);
+          try {
+            const age = now - statSync(p).mtimeMs;
+            if (age > sevenDays) { unlinkSync(p); cleaned++; }
+          } catch { /* skip */ }
+        }
+      }
+
+      // 2. Clean stale recommended-team.json from daemon dir (not working dirs — those are user-managed)
+      //    Only clean if no planner agent is currently running
+      const hasPlanner = this.registry.getAll().some((a) => a.role === 'planner' && (a.status === 'running' || a.status === 'starting'));
+      if (!hasPlanner) {
+        const teamFile = resolve(grooveDir, 'recommended-team.json');
+        if (existsSync(teamFile)) {
+          try {
+            const age = Date.now() - statSync(teamFile).mtimeMs;
+            if (age > 24 * 60 * 60 * 1000) { unlinkSync(teamFile); cleaned++; } // >24h old
+          } catch { /* skip */ }
+        }
+      }
+
+      // 3. Prune audit log (keep last 1000 lines)
+      const auditFile = resolve(grooveDir, 'audit.log');
+      if (existsSync(auditFile)) {
+        try {
+          const lines = readFileSync(auditFile, 'utf8').split('\n');
+          if (lines.length > 1000) {
+            writeFileSync(auditFile, lines.slice(-1000).join('\n'));
+            cleaned++;
+          }
+        } catch { /* skip */ }
+      }
+
+      if (cleaned > 0) {
+        this.audit.log('gc.run', { cleaned });
+      }
+    } catch { /* gc should never crash the daemon */ }
+  }
+
   async stop() {
     // Persist state before shutdown
     this.state.set('agents', this.registry.getAll());
@@ -299,6 +365,7 @@ export class Daemon {
     this.journalist.stop();
     this.rotator.stop();
     this.scheduler.stop();
+    if (this._gcInterval) clearInterval(this._gcInterval);
 
     // Clean up file watchers and terminal sessions
     this.fileWatcher.unwatchAll();

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

@@ -2,9 +2,10 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
 
 import { spawn as cpSpawn } from 'child_process';
-import { createWriteStream, mkdirSync, chmodSync } from 'fs';
+import { createWriteStream, mkdirSync, chmodSync, existsSync, readFileSync, unlinkSync } from 'fs';
 import { resolve } from 'path';
 import { getProvider } from './providers/index.js';
+import { validateAgentConfig } from './validate.js';
 
 // Role-specific prompt prefixes — applied during spawn regardless of entry point
 // (SpawnPanel, chat continue, CLI, API) for consistency
@@ -58,11 +59,15 @@ Do NOT write code unless explicitly asked. Use your MCP tools (database queries,
 Do NOT write code unless explicitly asked. Use your MCP tools to interact with Home Assistant.
 
 `,
-  planner: `You are a planning and architecture agent. Research, analyze, and create plans — do NOT implement code unless explicitly asked. Focus on:
+  planner: `You are a PLANNING ONLY agent. You create plans. You do NOT write code, edit files, or run commands.
+
+ABSOLUTE RULE: Never use the Edit, Write, or Bash tools to modify source code. You ONLY use Read, Glob, and Grep to understand the codebase, then output a written plan. If the user says "build this" or "redesign this", create a PLAN for how other agents should build it — do NOT build it yourself.
+
+Focus on:
 - Understanding requirements
-- Exploring the codebase
+- Exploring the codebase to understand current architecture
 - Identifying approaches and trade-offs
-- Writing structured plans
+- Writing structured plans with agent assignments
 
 After completing your plan, you MUST do two things:
 
@@ -70,15 +75,25 @@ After completing your plan, you MUST do two things:
 
 2. Save a machine-readable team config to .groove/recommended-team.json using this EXACT format:
 [
-  { "role": "fullstack", "scope": [], "prompt": "Set up project infrastructure: package.json, tsconfig, vite config, dependencies. Once all other agents finish, audit and QC their work, fix any issues, then launch the dev server. Output the localhost URL where the app can be accessed." },
-  { "role": "backend", "scope": ["src/api/**", "src/server/**", "src/db/**", "src/lib/**"], "workingDir": "packages/backend", "prompt": "Build the backend: [specific tasks from your plan]" },
-  { "role": "frontend", "scope": ["src/components/**", "src/views/**", "src/pages/**", "src/styles/**"], "workingDir": "packages/frontend", "prompt": "Build the frontend: [specific tasks from your plan]" }
+  { "role": "frontend", "phase": 1, "scope": ["src/components/**", "src/views/**"], "prompt": "Build the frontend: [specific tasks]" },
+  { "role": "backend", "phase": 1, "scope": ["src/api/**", "src/server/**"], "prompt": "Build the backend: [specific tasks]" },
+  { "role": "fullstack", "phase": 2, "scope": [], "prompt": "QC Senior Dev: Audit all changes from phase 1 agents. Verify correctness, fix issues, run tests, build the project, commit, and launch. Output the localhost URL." }
 ]
 
-Include only the agents needed. Set appropriate scopes for each role. Write detailed prompts based on your plan so each agent knows exactly what to build.
-If the project is a monorepo or has distinct subdirectories (e.g. packages/, apps/), set "workingDir" to the relative path for each agent so it spawns inside its subdirectory. Omit workingDir for agents that need full project access (like fullstack or planner).
+MANDATORY RULES — NEVER SKIP THESE:
+
+1. The LAST entry in the array MUST be: { "role": "fullstack", "phase": 2, ... }
+   This is the QC Senior Dev. It auto-spawns after all other agents finish.
+   Its prompt: audit changes, fix issues, run tests, build, commit, launch.
+   NEVER omit this agent. Every team needs a QC.
+
+2. ALL other agents are phase: 1 — they run in parallel.
+
+3. Do NOT tell any agent to "wait for" another agent. Phase 2 handles sequencing automatically.
+
+4. Set appropriate scopes. Write detailed prompts so each agent knows exactly what to build.
 
-Always include a fullstack agent. Its job: set up infrastructure first, then after all other agents finish, audit their work, fix issues, build the project, launch the dev server, and output the localhost URL so the user can immediately see the result. Include testing/devops only if the project needs them.
+5. If the project is a monorepo, set "workingDir" for agents that need specific subdirectories.
 
 IMPORTANT: Do not use markdown formatting like ** or ### in your output. Write in plain text with clean formatting. Use line breaks, dashes, and indentation for structure.
 
@@ -105,6 +120,17 @@ export class ProcessManager {
   async spawn(config) {
     const { registry, locks, introducer } = this.daemon;
 
+    // Clean stale recommended-team.json when spawning a new planner
+    if (config.role === 'planner') {
+      const dirs = [this.daemon.grooveDir];
+      if (config.workingDir) dirs.push(resolve(config.workingDir, '.groove'));
+      if (this.daemon.config?.defaultWorkingDir) dirs.push(resolve(this.daemon.config.defaultWorkingDir, '.groove'));
+      for (const dir of dirs) {
+        const p = resolve(dir, 'recommended-team.json');
+        if (existsSync(p)) try { unlinkSync(p); } catch { /* */ }
+      }
+    }
+
     // Validate provider exists and is installed
     const provider = getProvider(config.provider || 'claude-code');
     if (!provider) {
@@ -325,6 +351,9 @@ For normal file edits within your scope, proceed without review.
       if (finalStatus === 'completed' && this.daemon.journalist) {
         this.daemon.journalist.cycle().catch(() => {});
       }
+
+      // Phase 2 auto-spawn: check if all phase 1 agents for a team are done
+      this._checkPhase2(agent.id);
     });
 
     proc.on('error', (err) => {
@@ -338,6 +367,49 @@ For normal file edits within your scope, proceed without review.
     return agent;
   }
 
+  /**
+   * 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.
+   */
+  _checkPhase2(completedAgentId) {
+    const pending = this.daemon._pendingPhase2;
+    if (!pending || pending.length === 0) return;
+
+    const registry = this.daemon.registry;
+
+    for (let i = pending.length - 1; i >= 0; i--) {
+      const group = pending[i];
+      if (!group.waitFor.includes(completedAgentId)) continue;
+
+      // Check if ALL phase 1 agents in this group are done
+      const allDone = group.waitFor.every((id) => {
+        const a = registry.get(id);
+        return !a || a.status === 'completed' || a.status === 'crashed' || a.status === 'stopped' || a.status === 'killed';
+      });
+
+      if (allDone) {
+        // Remove from pending
+        pending.splice(i, 1);
+
+        // Auto-spawn phase 2 agents
+        for (const config of group.agents) {
+          try {
+            const validated = validateAgentConfig(config);
+            this.spawn(validated).then((agent) => {
+              this.daemon.broadcast({
+                type: 'phase2:spawned',
+                agentId: agent.id,
+                name: agent.name,
+                role: agent.role,
+              });
+              this.daemon.audit.log('phase2.autoSpawn', { id: agent.id, name: agent.name, role: agent.role });
+            }).catch(() => {});
+          } catch { /* skip invalid configs */ }
+        }
+      }
+    }
+  }
+
   /**
    * Resume a completed agent's session with a new message.
    * Uses --resume SESSION_ID for zero cold-start continuation.
@@ -390,7 +462,7 @@ For normal file edits within your scope, proceed without review.
       model: config.model,
       prompt: config.prompt,
       permission: config.permission,
-      workingDir: config.workingDir,
+      workingDir: config.workingDir || this.daemon.config?.defaultWorkingDir || undefined,
       name: config.name,
     });
 

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

@@ -50,7 +50,7 @@ export class Registry extends EventEmitter {
     if (!agent) return null;
 
     // Only allow known fields to prevent prototype pollution
-    const SAFE_FIELDS = ['status', 'pid', 'tokensUsed', 'contextUsage', 'lastActivity', 'model', 'name', 'routingMode', 'routingReason', 'sessionId', 'skills', 'integrations'];
+    const SAFE_FIELDS = ['status', 'pid', 'tokensUsed', 'contextUsage', 'lastActivity', 'model', 'name', 'routingMode', 'routingReason', 'sessionId', 'skills', 'integrations', 'workingDir', 'effort'];
     for (const key of Object.keys(updates)) {
       if (SAFE_FIELDS.includes(key)) {
         agent[key] = updates[key];

package/node_modules/@groove-dev/gui/.groove/audit.log

@@ -0,0 +1 @@
+{"t":"2026-04-08T02:20:01.108Z","action":"credential.set","provider":"anthropic-api"}

package/node_modules/@groove-dev/gui/.groove/credentials.json

@@ -0,0 +1,6 @@
+{
+  "anthropic-api": {
+    "key": "bee44e798e85b64b04e5198bd44074f0:a0de1b79cca1a00842ca83193e383128:fb7b942b82313c940f802fd2c54f5945756ce6b65dae652b1534acd38d9cca19cdfaad8eee267f56e11f2c2ec6cd8db16c4a4139ddfe0777517437a3a4b5beb53e89210e31c1cfc1f964bba8b26ca75b93f62d36ea1dbc19d3910a91c8a976a2c4369b233a5d00f799e33ebd",
+    "setAt": "2026-04-08T02:20:01.107Z"
+  }
+}