groove-dev 0.27.40 → 0.27.42

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

@@ -377,18 +377,21 @@ export class ProcessManager {
       }
     }
 
-    // Scope collision check: refuse to spawn if another running agent already
-    // claims overlapping files. Oversight roles (planner, QC, security) and
-    // the ambassador bypass since their job requires broad access.
+    // Scope collision check: refuse to spawn if another running agent in the
+    // SAME working directory already claims overlapping files. Scopes are
+    // relative patterns rooted at the agent's workingDir, so two agents in
+    // different workingDirs can't step on each other even if their patterns
+    // look identical. Oversight roles (planner, QC, security) and ambassadors
+    // bypass entirely since their job requires broad access.
     const SCOPE_BYPASS_ROLES = new Set(['planner', 'fullstack', 'qc', 'pm', 'supervisor', 'security', 'ambassador']);
     if (config.scope && config.scope.length > 0 && !SCOPE_BYPASS_ROLES.has(config.role) && !config.allowScopeOverlap) {
-      const conflict = locks.findOverlappingOwner(config.scope);
+      const conflict = locks.findOverlappingOwner(config.scope, config.workingDir);
       if (conflict.overlap) {
         const owner = registry.get(conflict.owner);
-        if (owner && owner.status === 'running') {
+        if (owner && owner.status === 'running' && owner.workingDir === config.workingDir) {
           const ownerScope = Array.isArray(conflict.ownerScope) ? conflict.ownerScope.join(', ') : '';
           throw new Error(
-            `Scope collision: ${config.role} scope [${config.scope.join(', ')}] overlaps with ${owner.name} (${owner.role}) which owns [${ownerScope}]. ` +
+            `Scope collision: ${config.role} scope [${config.scope.join(', ')}] overlaps with ${owner.name} (${owner.role}) which owns [${ownerScope}] in the same workspace. ` +
             `Two agents cannot edit the same files. Either narrow the scope or wait for ${owner.name} to finish.`
           );
         }
@@ -460,7 +463,7 @@ export class ProcessManager {
 
     // Register file locks for the agent's scope
     if (agent.scope && agent.scope.length > 0) {
-      locks.register(agent.id, agent.scope);
+      locks.register(agent.id, agent.scope, agent.workingDir);
     }
 
     // Register ambassador with federation system
@@ -1098,16 +1101,25 @@ For normal file edits within your scope, proceed without review.
    *   - The daemon has a preview plan stashed for this team (planner wrote one).
    *   - No pending phase 2 groups for this team (QC hasn't spawned yet).
    *   - Every non-planner team agent is in a terminal state.
-   *   - At least one non-planner agent completed successfully (something to preview).
-   * Clears the plan after launching so repeated completions don't re-fire.
+   *   - At least one non-planner agent completed successfully.
+   *
+   * The plan is intentionally NOT cleared on failure so the user can hit the
+   * "Launch Preview" button manually after fixing whatever blocked the auto
+   * attempt (wrong cwd, missing deps, etc). We guard against infinite re-fires
+   * with _previewAttempted per teamId.
    */
   _checkPreviewReady(teamId) {
     const preview = this.daemon.preview;
     if (!preview) return;
+    if (!this._previewAttempted) this._previewAttempted = new Set();
+    if (this._previewAttempted.has(teamId)) return;
+
     const plan = preview.getPlan(teamId);
-    if (!plan) return;
+    if (!plan) {
+      this.daemon.audit?.log('preview.skipped', { teamId, reason: 'no_plan_stashed' });
+      return;
+    }
 
-    // If a phase 2 group for this team is still pending, let it spawn first.
     const pendingPhase2 = this.daemon._pendingPhase2 || [];
     for (const group of pendingPhase2) {
       for (const id of group.waitFor) {
@@ -1123,7 +1135,7 @@ For normal file edits within your scope, proceed without review.
     const anyCompleted = teamAgents.some((a) => a.status === 'completed');
     if (!allDone || !anyCompleted) return;
 
-    preview.clearPlan(teamId);
+    this._previewAttempted.add(teamId);
     const workingDir = plan.workingDir;
     preview.launch(teamId, workingDir, plan.preview).then((result) => {
       if (!result.launched) {
@@ -1137,6 +1149,7 @@ For normal file edits within your scope, proceed without review.
       }
     }).catch((err) => {
       console.error(`[Groove] Preview launch error for team ${teamId}:`, err.message);
+      this.daemon.broadcast({ type: 'preview:failed', teamId, reason: err.message });
     });
   }
 
@@ -1510,7 +1523,7 @@ For normal file edits within your scope, proceed without review.
 
     // Re-register locks
     if (newAgent.scope && newAgent.scope.length > 0) {
-      locks.register(newAgent.id, newAgent.scope);
+      locks.register(newAgent.id, newAgent.scope, newAgent.workingDir);
     }
 
     // Spawn the resumed process

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

@@ -34,14 +34,30 @@ export class Teams {
   }
 
   _ensureDefault() {
-    const hasDefault = [...this.teams.values()].some((t) => t.isDefault);
-    if (!hasDefault) {
+    const defaultDir = resolve(this.daemon.projectDir, 'default');
+    const existing = [...this.teams.values()].find((t) => t.isDefault);
+
+    if (!existing) {
+      try { mkdirSync(defaultDir, { recursive: true }); } catch { /* may exist */ }
       const id = randomUUID().slice(0, 8);
-      const team = { id, name: 'Default', isDefault: true, createdAt: new Date().toISOString() };
-      // Default team uses the project directory (no subdirectory)
-      team.workingDir = this.daemon.projectDir;
+      const team = {
+        id,
+        name: 'Default',
+        isDefault: true,
+        workingDir: defaultDir,
+        createdAt: new Date().toISOString(),
+      };
       this.teams.set(id, team);
       this._save();
+      return;
+    }
+
+    // Migrate legacy default teams that pointed at the project root — give them
+    // their own folder so generated files don't pile up alongside source code.
+    if (!existing.workingDir || existing.workingDir === this.daemon.projectDir) {
+      try { mkdirSync(defaultDir, { recursive: true }); } catch { /* may exist */ }
+      existing.workingDir = defaultDir;
+      this._save();
     }
   }
 
@@ -125,12 +141,13 @@ export class Teams {
   }
 
   /**
-   * Delete a team — removes directory and all contents, moves agents to default.
+   * Delete a team — kills its agents, removes its directory, drops it from the
+   * registry. Deleting the default team regenerates a fresh empty one so users
+   * can wipe accumulated state and keep working without restarting the daemon.
    */
   delete(id) {
     const team = this.teams.get(id);
     if (!team) throw new Error('Team not found');
-    if (team.isDefault) throw new Error('Cannot delete the default team');
 
     // Kill any running agents in this team
     const agents = this.daemon.registry.getAll().filter((a) => a.teamId === id);
@@ -145,8 +162,13 @@ export class Teams {
       this.daemon.registry.remove(agent.id);
     }
 
-    // Remove the working directory
-    if (team.workingDir && !team.isDefault && existsSync(team.workingDir)) {
+    // Remove the team's working directory — refuse to nuke the project root
+    // (legacy default teams that were never migrated point there).
+    if (
+      team.workingDir &&
+      team.workingDir !== this.daemon.projectDir &&
+      existsSync(team.workingDir)
+    ) {
       try {
         rmSync(team.workingDir, { recursive: true, force: true });
       } catch (err) {
@@ -158,6 +180,13 @@ export class Teams {
     this._save();
     this.daemon.broadcast({ type: 'team:deleted', teamId: id });
 
+    // Always keep a default team available — regenerate one with a clean folder
+    if (team.isDefault) {
+      this._ensureDefault();
+      const fresh = this.getDefault();
+      if (fresh) this.daemon.broadcast({ type: 'team:created', team: fresh });
+    }
+
     // Clean up orphaned logs immediately — don't wait for the 24h GC cycle
     try { this.daemon._gc(); } catch { /* gc should never block deletion */ }
 

package/node_modules/@groove-dev/daemon/src/tool-executor.js

@@ -158,7 +158,7 @@ export class ToolExecutor {
   _checkWriteScope(resolvedPath) {
     if (!this.daemon?.locks) return;
     const rel = relative(this.workingDir, resolvedPath);
-    const result = this.daemon.locks.check(this.agentId, rel);
+    const result = this.daemon.locks.check(this.agentId, rel, this.workingDir);
     if (result.conflict) {
       // Record conflict for supervisor + token savings
       if (this.daemon.supervisor) {

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

@@ -135,9 +135,19 @@ describe('Teams', () => {
     assert.equal(msg.teamId, team.id);
   });
 
-  it('should throw when deleting the default team', () => {
-    const d = teams.getDefault();
-    assert.throws(() => teams.delete(d.id), /Cannot delete the default/);
+  it('should regenerate a fresh default team when the default is deleted', () => {
+    const original = teams.getDefault();
+    broadcasts.length = 0;
+
+    teams.delete(original.id);
+
+    const fresh = teams.getDefault();
+    assert.ok(fresh, 'a new default team should be created');
+    assert.notEqual(fresh.id, original.id);
+    assert.equal(fresh.isDefault, true);
+    assert.equal(teams.list().length, 1);
+    assert.ok(broadcasts.find((b) => b.type === 'team:deleted' && b.teamId === original.id));
+    assert.ok(broadcasts.find((b) => b.type === 'team:created' && b.team?.id === fresh.id));
   });
 
   it('should throw when deleting nonexistent team', () => {