groove-dev 0.27.39 → 0.27.41

package/CLAUDE.md

@@ -263,3 +263,10 @@ Audit-driven release. Multi-agent orchestration system with 7 coordination layer
 - Dashboard: routing donut, cache panel, context health gauges
 - Monitor/QC agent mode (stay active, loop)
 - 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:** GROOVE manages project memory automatically. Do not read or write MEMORY.md or .groove/memory/ files directly.
+<!-- GROOVE:END -->

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

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

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

@@ -3,6 +3,11 @@
 
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { resolve } from 'path';
+import { minimatch } from 'minimatch';
+
+// Treat these scope entries as "unrestricted" — agent can touch any file
+// under its workingDir without counting as a scope violation.
+const UNRESTRICTED_SCOPE_PATTERNS = new Set(['**', '**/*', '*', '']);
 
 const DEFAULT_THRESHOLD = 0.75;
 const NUDGE_UP = 0.02;   // Good session → allow more context
@@ -186,14 +191,28 @@ export class AdaptiveThresholds {
           signals.toolFailures++;
         }
 
-        // Scope violations: writes outside declared scope
+        // Scope violations: writes outside declared scope. Use real glob matching
+        // (the naive substring check flagged every write when scope was `["**"]`
+        // because `file.includes("**")` is always false — which tanked the
+        // quality score and triggered false-positive rotations). An unrestricted
+        // scope (`**`, `**/*`, empty pattern) skips the check entirely.
         if (agentScope && agentScope.length > 0 && entry.input) {
           if (entry.tool === 'Write' || entry.tool === 'Edit') {
             const file = entry.input;
-            const inScope = agentScope.some((pattern) =>
-              file.includes(pattern.replace('/**', '').replace('**/', ''))
-            );
-            if (!inScope) signals.scopeViolations++;
+            const unrestricted = agentScope.some((p) => UNRESTRICTED_SCOPE_PATTERNS.has(String(p).trim()));
+            if (!unrestricted) {
+              const inScope = agentScope.some((pattern) => {
+                try {
+                  if (minimatch(file, pattern, { matchBase: true, dot: true })) return true;
+                  // Also try matching the basename and any path suffix, since
+                  // scope patterns are relative to the agent's workingDir and
+                  // the recorded input may be absolute.
+                  const idx = file.indexOf('/' + pattern.replace(/\/?\*\*\/?/g, '').replace(/^\//, ''));
+                  return idx >= 0;
+                } catch { return true; } // if the pattern is malformed, don't penalize
+              });
+              if (!inScope) signals.scopeViolations++;
+            }
           }
         }
       }

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

@@ -2650,11 +2650,15 @@ Keep responses concise. Help them think, don't lecture them about the system the
     if (!found) {
       return res.status(404).json({ error: 'No recommended team found. Run a planner first.' });
     }
+    const planPath = found.path;
+    const planContents = readFileSync(planPath, 'utf8');
     try {
-      const raw = JSON.parse(readFileSync(found.path, 'utf8'));
+      const raw = JSON.parse(planContents);
 
-      // Delete immediately after reading to prevent duplicate launches from poll races
-      try { unlinkSync(found.path); } catch { /* already gone */ }
+      // Delete immediately after reading to prevent duplicate launches from poll races.
+      // If every spawn below fails, we'll restore the plan from planContents so the
+      // user can retry without re-prompting the planner.
+      try { unlinkSync(planPath); } catch { /* already gone */ }
 
       // Support both old format (bare array) and new format ({ projectDir, agents, preview })
       let agentConfigs;
@@ -2834,6 +2838,14 @@ Keep responses concise. Help them think, don't lecture them about the system the
         daemon.preview.stashPlan(defaultTeamId, previewBlock, projectWorkingDir);
       }
 
+      // Restore the plan if nothing actually spawned or was reused — deleting
+      // it on a total failure leaves the team with no recovery path. A failed
+      // spawn (scope collision, provider unavailable, etc.) should be retryable
+      // once the user fixes the condition.
+      if (spawned.length === 0 && reused.length === 0 && failed.length > 0) {
+        try { writeFileSync(planPath, planContents); } catch { /* best-effort */ }
+      }
+
       daemon.audit.log('team.launch', {
         phase1: spawned.length, reused: reused.length, phase2Pending: phase2.length, failed: failed.length,
         agents: [...spawned, ...reused].map((a) => a.role), projectDir: projectDir || null, preview: !!previewBlock,
@@ -2868,23 +2880,28 @@ Keep responses concise. Help them think, don't lecture them about the system the
     res.json(result);
   });
 
-  // Clean up stale artifacts (old plans, recommended teams, etc.)
+  // Clean up stale artifacts. Scope to a single team when teamId is provided —
+  // wiping every agent's working dir on a global cleanup would delete other
+  // in-flight teams' unlaunched plans. When called with no teamId, only the
+  // daemon-root plan file is touched (safe baseline).
   app.post('/api/cleanup', (req, res) => {
+    const teamId = req.body?.teamId || req.query?.teamId || null;
     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'));
+
+    if (teamId) {
+      // Only agents in this team get their workspace scanned
+      for (const agent of daemon.registry.getAll()) {
+        if (agent.teamId === teamId && 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 });
+    daemon.audit.log('cleanup', { cleaned, teamId });
     res.json({ ok: true, cleaned });
   });
 

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

@@ -19,6 +19,11 @@ import { lookup as mimeLookup } from './mimetypes.js';
 
 const READY_TIMEOUT_MS = 60_000;  // give dev servers a minute to boot
 const MAX_STDOUT_BYTES = 256 * 1024;
+// Strip CSI/OSC/other ANSI escape sequences — Vite prints URLs with inline
+// bold/color codes (e.g. "http://localhost:\x1b[1m5175\x1b[22m/") which would
+// otherwise break port-number regexes.
+const ANSI_REGEX = /[\u001B\u009B][[\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\d/#&.:=?%@~_]+)*|[a-zA-Z\d]+(?:;[-a-zA-Z\d/#&.:=?%@~_]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+function stripAnsi(s) { return s.replace(ANSI_REGEX, ''); }
 
 export class PreviewService {
   constructor(daemon) {
@@ -71,28 +76,46 @@ export class PreviewService {
    * preview upfront at launch time and hand it back when the team completes.
    */
   async launch(teamId, workingDir, preview) {
+    this.daemon.audit?.log('preview.attempt', { teamId, workingDir, preview });
+
     if (!preview || !preview.kind || preview.kind === 'none' || preview.kind === 'cli') {
-      return { launched: false, reason: preview?.kind || 'no_preview' };
+      const result = { launched: false, reason: preview?.kind || 'no_preview' };
+      this.daemon.audit?.log('preview.skipped', { teamId, reason: result.reason });
+      return result;
     }
 
-    // Kill any existing preview for this team
     await this.kill(teamId);
 
-    const baseDir = preview.cwd
-      ? resolve(workingDir || this.daemon.projectDir, preview.cwd)
-      : resolve(workingDir || this.daemon.projectDir);
+    // Resolve cwd with a sensible fallback. The planner sometimes names the
+    // cwd after projectDir which is applied by api/launch → the actual project
+    // root. If that specific subdir doesn't exist, try workingDir itself.
+    const root = resolve(workingDir || this.daemon.projectDir);
+    const candidates = [];
+    if (preview.cwd) candidates.push(resolve(root, preview.cwd));
+    candidates.push(root);
+    const baseDir = candidates.find((p) => existsSync(p));
 
-    if (!existsSync(baseDir)) {
-      return { launched: false, reason: `cwd_missing: ${baseDir}` };
+    if (!baseDir) {
+      const result = { launched: false, reason: `cwd_missing: tried ${candidates.join(' and ')}` };
+      this.daemon.audit?.log('preview.failed', { teamId, reason: result.reason });
+      return result;
     }
 
+    let result;
     if (preview.kind === 'static-html') {
-      return this._launchStatic(teamId, baseDir, preview);
+      result = await this._launchStatic(teamId, baseDir, preview);
+    } else if (preview.kind === 'dev-server') {
+      result = await this._launchDevServer(teamId, baseDir, preview);
+    } else {
+      result = { launched: false, reason: `unknown_kind: ${preview.kind}` };
     }
-    if (preview.kind === 'dev-server') {
-      return this._launchDevServer(teamId, baseDir, preview);
+
+    if (result.launched) {
+      this.daemon.audit?.log('preview.launched', { teamId, url: result.url, kind: result.kind, baseDir });
+    } else {
+      this.daemon.audit?.log('preview.failed', { teamId, reason: result.reason, baseDir });
     }
-    return { launched: false, reason: `unknown_kind: ${preview.kind}` };
+    return result;
   }
 
   _launchStatic(teamId, baseDir, preview) {
@@ -168,11 +191,12 @@ export class PreviewService {
       };
 
       const timer = setTimeout(() => {
-        finish({ launched: false, reason: `timeout waiting for url in stdout; last stderr: ${stderrBuf.slice(-400)}` });
+        const tail = stripAnsi(stderrBuf).slice(-400) || stripAnsi(stdoutBuf).slice(-400) || '(no output)';
+        finish({ launched: false, reason: `timeout waiting for url in stdout; last output: ${tail}` });
       }, READY_TIMEOUT_MS);
 
       const tryMatch = () => {
-        const combined = stdoutBuf + '\n' + stderrBuf;
+        const combined = stripAnsi(stdoutBuf + '\n' + stderrBuf);
         if (readyText && !combined.includes(readyText)) return;
         const m = combined.match(urlPattern);
         if (!m) return;
@@ -232,6 +256,7 @@ export class PreviewService {
       if (entry.server) entry.server.close();
       if (entry.proc) entry.proc.kill('SIGTERM');
     } catch { /* best-effort */ }
+    this.daemon.audit?.log('preview.stopped', { teamId });
     this.daemon.broadcast({ type: 'preview:stopped', teamId });
     return true;
   }

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);
       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.`
           );
         }
@@ -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 });
     });
   }
 

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

@@ -10,8 +10,10 @@ const DEFAULT_THRESHOLD = 0.65;      // For non-self-managing providers (was 0.7
 const HARD_CEILING = 0.80;           // Force rotate (was 0.85) — only for non-self-managing
 const CHECK_INTERVAL = 15_000;
 const QUALITY_THRESHOLD = 40;   // Score below this triggers quality rotation
-const MIN_EVENTS = 10;          // Minimum classifier events before scoring
-const MIN_AGE_SEC = 120;        // Minimum agent age before quality rotation
+const MIN_EVENTS = 20;          // Minimum classifier events before scoring
+const MIN_AGE_SEC = 300;        // Minimum agent age before quality rotation (5 min)
+const QUALITY_MIN_TOKENS = 20_000; // Minimum real token work before quality rotation can fire
+const QUALITY_MIN_FILES = 3;    // Or: 3 successful file writes proves the agent is productive
 const SCORE_HISTORY_MAX = 40;   // ~10 min at 15s intervals
 const COOLDOWN_MS = 5 * 60 * 1000;   // 5 minutes between rotations per agent
 const QUALITY_COOLDOWN_MS = 2 * 60 * 1000; // 2 minutes for quality degradation rotations
@@ -128,7 +130,20 @@ export class Rotator extends EventEmitter {
       return { score: 70, signals: {}, hasEnoughData: false, ageSec: Math.round(ageSec), eventCount: events.length };
     }
 
-    const signals = this.daemon.adaptive.extractSignals(events, agent.scope);
+    // Productive-work floor: don't even score an agent that hasn't produced
+    // enough to judge. A frontend agent scaffolding a project naturally emits
+    // noisy signals (npm install warnings, Write retries) in its first few
+    // minutes; killing it mid-scaffold destroys the context it was building.
+    // Only allow the score to gate rotation once EITHER substantial tokens
+    // have flowed OR the agent has already written multiple files successfully.
+    const tokens = agent.tokensUsed || 0;
+    const signalsEarly = this.daemon.adaptive.extractSignals(events, agent.scope);
+    const filesWritten = signalsEarly.filesWritten || 0;
+    if (tokens < QUALITY_MIN_TOKENS && filesWritten < QUALITY_MIN_FILES) {
+      return { score: 70, signals: signalsEarly, hasEnoughData: false, ageSec: Math.round(ageSec), eventCount: events.length, reason: 'below_productive_floor' };
+    }
+
+    const signals = signalsEarly;
     let score = this.daemon.adaptive.scoreSession(signals);
 
     if (ageSec > 1800) score -= 5;