groove-dev 0.27.36 → 0.27.39

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

@@ -16,6 +16,8 @@ const COMPACTION_DROP_THRESHOLD = 0.25; // 25% drop from peak = natural compacti
 const COMPACTION_MIN_PEAK = 0.15;       // Ignore compaction if peak was below 15%
 const MAX_BUFFER_SIZE = 1_048_576;      // 1MB — discard oldest half if exceeded
 const STREAM_THROTTLE_MS = 250;         // 4 broadcasts/sec per agent
+const STALL_CHECK_INTERVAL_MS = 60_000; // Poll for stuck agents every 60s
+const STALL_THRESHOLD_MS = 5 * 60_000;  // 5 min of silence on a live PID = stalled stream
 
 // Role-specific prompt prefixes — applied during spawn regardless of entry point
 // (SpawnPanel, chat continue, CLI, API) for consistency
@@ -222,9 +224,26 @@ For MODE 1 (team creation):
     { "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, verify the build compiles (npm run build). Do NOT start long-running dev servers. Commit all changes." }
-  ]
+  ],
+  "preview": {
+    "kind": "dev-server",
+    "command": "npm run dev",
+    "cwd": "<projectDir>",
+    "urlPattern": "https?://(localhost|127\\.0\\.0\\.1):\\d+",
+    "readyText": "Local:",
+    "openPath": "/"
+  }
 }
 
+The "preview" block is how GROOVE launches a one-click preview for the user after the team finishes. Pick EXACTLY ONE kind based on what the project will produce:
+
+  - "dev-server"   — web app, API, anything that needs a running process (Vite, Next, Express, FastAPI, Rails, etc.). Set command to the exact shell command to start it. Set cwd to the subdir containing the runnable project (relative to the team working dir), or "" if it runs at the root. Set urlPattern to a regex that matches the URL in the command's stdout. Set readyText to a short substring that signals the server is up (optional but helps). Set openPath to the path the user should land on ("/").
+  - "static-html"  — slide deck, static site, anything where a browser opens index.html directly. Set command to "" and openPath to the relative path of the entry HTML (e.g. "index.html" or "slides/index.html"). GROOVE will serve the directory on a local port.
+  - "cli"          — library, CLI tool, anything with no visible preview. Set command to "" and let the kind signal no auto-launch.
+  - "none"         — explicitly no preview.
+
+NEVER invent preview kinds. Use these four exact strings.
+
 For MODE 2 (task routing to existing team):
 Only include the agents that need to do work. Use their EXISTING role — the system will find and reuse them.
 {
@@ -297,7 +316,44 @@ export class ProcessManager {
     this.pendingMessages = new Map(); // agentId -> { message, timestamp }
     this._streamThrottle = new Map(); // agentId -> { timer, pending }
     this._rotatingAgents = new Set(); // agentIds currently being rotated (rotator wrote handoff)
+    this._stalledAgents = new Set(); // agentIds already flagged as stalled (avoids duplicate broadcasts)
 
+    this._stallWatchdog = setInterval(() => this._checkStalls(), STALL_CHECK_INTERVAL_MS);
+    if (this._stallWatchdog.unref) this._stallWatchdog.unref();
+  }
+
+  _checkStalls() {
+    const { registry } = this.daemon;
+    const now = Date.now();
+    for (const agentId of this.handles.keys()) {
+      const agent = registry.get(agentId);
+      if (!agent || agent.status !== 'running') continue;
+      const lastActivity = agent.lastActivity ? new Date(agent.lastActivity).getTime() : now;
+      const silentMs = now - lastActivity;
+      if (silentMs < STALL_THRESHOLD_MS) {
+        if (this._stalledAgents.has(agentId)) {
+          this._stalledAgents.delete(agentId);
+          registry.update(agentId, { stalled: false });
+        }
+        continue;
+      }
+      if (this._stalledAgents.has(agentId)) continue;
+      this._stalledAgents.add(agentId);
+      registry.update(agentId, { stalled: true, stalledSince: new Date(lastActivity).toISOString() });
+      if (this.daemon.timeline) {
+        this.daemon.timeline.recordEvent('stall', {
+          agentId, agentName: agent.name, role: agent.role, silentMs,
+        });
+      }
+      this.daemon.broadcast({
+        type: 'agent:stalled',
+        agentId,
+        agentName: agent.name,
+        silentMs,
+        lastActivity: agent.lastActivity,
+      });
+      console.warn(`[Groove] Agent ${agent.name} (${agentId}) silent for ${Math.round(silentMs / 1000)}s — possible stalled API stream`);
+    }
   }
 
   async spawn(config) {
@@ -321,6 +377,24 @@ 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.
+    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') {
+          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}]. ` +
+            `Two agents cannot edit the same files. Either narrow the scope or wait for ${owner.name} to finish.`
+          );
+        }
+      }
+    }
+
     // Clean stale recommended-team.json when spawning a new planner
     if (config.role === 'planner') {
       const dirs = [this.daemon.grooveDir];
@@ -616,7 +690,11 @@ For normal file edits within your scope, proceed without review.
 
         this.daemon.broadcast({ type: 'agent:exit', agentId: agent.id, code: code || 0, signal, status });
         if (this.daemon.integrations) this.daemon.integrations.refreshMcpJson();
-        if (status === 'completed' && this.daemon.journalist) this.daemon.journalist.requestSynthesis('completion');
+        if (status === 'completed' && this.daemon.journalist) {
+          const turns = agentData?.turns || 0;
+          const tok = agentData?.tokensUsed || 0;
+          if (turns > 1 || tok >= 100) this.daemon.journalist.requestSynthesis('completion');
+        }
         this._checkPhase2(agent.id);
 
         // Auto-trigger idle QC + process cross-scope handoffs
@@ -685,7 +763,7 @@ For normal file edits within your scope, proceed without review.
     // Spawn the process (use pipe for stdin if provider needs to send prompt via stdin)
     const proc = cpSpawn(command, args, {
       cwd: agent.workingDir || this.daemon.projectDir,
-      env: { ...process.env, ...env, ...integrationEnv, GROOVE_AGENT_ID: agent.id, GROOVE_AGENT_NAME: agent.name },
+      env: { ...process.env, ...env, ...integrationEnv, GROOVE_AGENT_ID: agent.id, GROOVE_AGENT_NAME: agent.name, GROOVE_DAEMON_HOST: this.daemon.host || '127.0.0.1', GROOVE_DAEMON_PORT: String(this.daemon.port || 31415) },
       stdio: [stdinData ? 'pipe' : 'ignore', 'pipe', 'pipe'],
       detached: false,
     });
@@ -746,6 +824,7 @@ For normal file edits within your scope, proceed without review.
       // Clean up per-agent maps to prevent unbounded growth in long sessions
       this.peakContextUsage.delete(agent.id);
       this.pendingMessages.delete(agent.id);
+      this._stalledAgents.delete(agent.id);
 
       // Release file-scope locks so they don't persist after agent death
       if (this.daemon.locks) this.daemon.locks.release(agent.id);
@@ -806,14 +885,28 @@ For normal file edits within your scope, proceed without review.
         }
       }
 
-      // Trigger journalist synthesis on completion (event-driven, debounced)
+      // Trigger journalist synthesis on completion (event-driven, debounced).
+      // Skip trivial sessions — a greeting-only completion (user never gave a task)
+      // has nothing worth synthesizing and wastes a $0.04+ headless claude call.
       if (finalStatus === 'completed' && this.daemon.journalist) {
-        this.daemon.journalist.requestSynthesis('completion');
+        const a = registry.get(agent.id);
+        const turns = a?.turns || 0;
+        const tok = a?.tokensUsed || 0;
+        if (turns > 1 || tok >= 100) {
+          this.daemon.journalist.requestSynthesis('completion');
+        }
       }
 
       // Phase 2 auto-spawn: check if all phase 1 agents for a team are done
       this._checkPhase2(agent.id);
 
+      // Preview launch: when every agent in this team is in a terminal state,
+      // kick off the one-click preview (dev server or static serve) the planner
+      // staged in the team plan. Fires once per team launch.
+      if (finalStatus === 'completed' && agent.teamId) {
+        this._checkPreviewReady(agent.teamId);
+      }
+
       // 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') {
@@ -917,6 +1010,12 @@ For normal file edits within your scope, proceed without review.
 
     const updates = { lastActivity: new Date().toISOString() };
 
+    // Clear stall flag — output means the stream is alive again
+    if (this._stalledAgents.has(agentId)) {
+      this._stalledAgents.delete(agentId);
+      updates.stalled = false;
+    }
+
     // Token tracking — feed subsystems with full breakdown
     if (output.tokensUsed !== undefined && output.tokensUsed > 0) {
       updates.tokensUsed = agent.tokensUsed + output.tokensUsed;
@@ -993,6 +1092,54 @@ For normal file edits within your scope, proceed without review.
     }
   }
 
+  /**
+   * Fire the one-click preview when the whole team has finished building.
+   * Requirements:
+   *   - 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.
+   */
+  _checkPreviewReady(teamId) {
+    const preview = this.daemon.preview;
+    if (!preview) return;
+    const plan = preview.getPlan(teamId);
+    if (!plan) 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) {
+        const a = this.daemon.registry.get(id);
+        if (a?.teamId === teamId) return;
+      }
+    }
+
+    const teamAgents = this.daemon.registry.getAll().filter((a) => a.teamId === teamId && a.role !== 'planner');
+    if (teamAgents.length === 0) return;
+    const terminal = new Set(['completed', 'crashed', 'stopped', 'killed']);
+    const allDone = teamAgents.every((a) => terminal.has(a.status));
+    const anyCompleted = teamAgents.some((a) => a.status === 'completed');
+    if (!allDone || !anyCompleted) return;
+
+    preview.clearPlan(teamId);
+    const workingDir = plan.workingDir;
+    preview.launch(teamId, workingDir, plan.preview).then((result) => {
+      if (!result.launched) {
+        console.warn(`[Groove] Preview for team ${teamId} did not launch: ${result.reason}`);
+        this.daemon.broadcast({
+          type: 'preview:failed',
+          teamId,
+          kind: plan.preview?.kind,
+          reason: result.reason,
+        });
+      }
+    }).catch((err) => {
+      console.error(`[Groove] Preview launch error for team ${teamId}:`, err.message);
+    });
+  }
+
   _extractRecommendedTeam(agent, logPath) {
     try {
       const workDir = agent.workingDir || this.daemon.projectDir;
@@ -1163,6 +1310,13 @@ For normal file edits within your scope, proceed without review.
     try {
       const agentData = this.daemon.registry.get(agent.id);
 
+      // Skip sessions that did no meaningful work — a "greeting-only" completion
+      // (agent introduced itself, user gave no task) should not overwrite the chain
+      // with a useless brief. Gate on turns and tokens used in this session.
+      const turns = agentData?.turns || 0;
+      const tokens = agentData?.tokensUsed || 0;
+      if (turns <= 1 && tokens < 100) return;
+
       let brief;
       try {
         brief = await this.daemon.journalist.generateHandoffBrief(agent, { reason: 'completed' });
@@ -1362,7 +1516,7 @@ For normal file edits within your scope, proceed without review.
     // Spawn the resumed process
     const proc = cpSpawn(command, args, {
       cwd: config.workingDir || this.daemon.projectDir,
-      env: { ...process.env, ...env, GROOVE_AGENT_ID: newAgent.id, GROOVE_AGENT_NAME: newAgent.name },
+      env: { ...process.env, ...env, GROOVE_AGENT_ID: newAgent.id, GROOVE_AGENT_NAME: newAgent.name, GROOVE_DAEMON_HOST: this.daemon.host || '127.0.0.1', GROOVE_DAEMON_PORT: String(this.daemon.port || 31415) },
       stdio: ['ignore', 'pipe', 'pipe'],
       detached: false,
     });
@@ -1398,11 +1552,42 @@ For normal file edits within your scope, proceed without review.
       logStream.write(`[${new Date().toISOString()}] Process exited: code=${code} signal=${signal}\n`);
       logStream.end();
       this.handles.delete(newAgent.id);
+      this._stalledAgents.delete(newAgent.id);
       const finalStatus = signal === 'SIGTERM' || signal === 'SIGKILL' ? 'killed' : code === 0 ? 'completed' : 'crashed';
       registry.update(newAgent.id, { status: finalStatus, pid: null });
       this.daemon.broadcast({ type: 'agent:exit', agentId: newAgent.id, code, signal, status: finalStatus });
       if (finalStatus === 'completed' && this.daemon.journalist) {
-        this.daemon.journalist.requestSynthesis('completion');
+        const a = registry.get(newAgent.id);
+        const turns = a?.turns || 0;
+        const tok = a?.tokensUsed || 0;
+        if (turns > 1 || tok >= 100) this.daemon.journalist.requestSynthesis('completion');
+      }
+
+      // Persist Layer 7 state for resumed-session completions too, not just fresh spawns.
+      // Without this, every resume after the first loses its work from the handoff chain.
+      if (finalStatus === 'completed' && !this._rotatingAgents.has(newAgent.id)) {
+        this._writeCompletionHandoff(newAgent).catch(err =>
+          console.error(`[Groove] Completion handoff failed for ${newAgent.name}:`, err.message));
+      }
+      if (this._rotatingAgents.has(newAgent.id)) {
+        this._rotatingAgents.delete(newAgent.id);
+      }
+      if (this.daemon.memory && (finalStatus === 'completed' || finalStatus === 'crashed')) {
+        try {
+          const events = this.daemon.classifier?.agentWindows?.[newAgent.id] || [];
+          const signals = events.length >= 6
+            ? this.daemon.adaptive.extractSignals(events, newAgent.scope)
+            : null;
+          const score = signals ? this.daemon.adaptive.scoreSession(signals) : null;
+          const files = this.daemon.journalist?.getAgentFiles(newAgent) || [];
+          this.daemon.memory.updateSpecialization(newAgent.id, {
+            role: newAgent.role,
+            qualityScore: score,
+            filesTouched: files,
+            signals,
+            threshold: this.daemon.adaptive?.getThreshold(newAgent.provider, newAgent.role),
+          });
+        } catch { /* best-effort */ }
       }
     });
 
@@ -1410,6 +1595,7 @@ For normal file edits within your scope, proceed without review.
       logStream.write(`[error] ${err.message}\n`);
       logStream.end();
       this.handles.delete(newAgent.id);
+      this._stalledAgents.delete(newAgent.id);
       registry.update(newAgent.id, { status: 'crashed', pid: null });
     });
 
@@ -1548,6 +1734,10 @@ For normal file edits within your scope, proceed without review.
   async killAll() {
     const ids = Array.from(this.handles.keys());
     await Promise.all(ids.map((id) => this.kill(id)));
+    if (this._stallWatchdog) {
+      clearInterval(this._stallWatchdog);
+      this._stallWatchdog = null;
+    }
   }
 
   isRunning(agentId) {

package/node_modules/@groove-dev/daemon/src/providers/claude-code.js

@@ -3,10 +3,13 @@
 
 import { execSync, spawn as cpSpawn } from 'child_process';
 import { writeFileSync, readFileSync, existsSync } from 'fs';
-import { resolve } from 'path';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { homedir } from 'os';
 import { Provider } from './base.js';
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
 export class ClaudeCodeProvider extends Provider {
   static name = 'claude-code';
   static displayName = 'Claude Code';
@@ -14,6 +17,7 @@ export class ClaudeCodeProvider extends Provider {
   static authType = 'subscription';
   static managesOwnContext = true; // Claude Code compacts context internally (~25-37% → 2-8%)
   static models = [
+    { id: 'claude-opus-4-7', name: 'Claude Opus 4.7', tier: 'heavy', contextWindow: 1_000_000 },
     { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', tier: 'heavy', contextWindow: 1_000_000 },
     { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6', tier: 'medium', contextWindow: 200_000 },
     { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5', tier: 'light', contextWindow: 200_000 },
@@ -52,12 +56,16 @@ export class ClaudeCodeProvider extends Provider {
     //   --dangerously-skip-permissions  (autonomous operation)
     //   --output-format stream-json     (structured stdout for parsing)
     //   --verbose                       (richer output for journalist)
+    //   --settings {hooks:{PreToolUse:...}}  (knock protocol enforcement)
     //
     // The initial prompt is passed as a positional argument.
     // GROOVE context is injected via an append-only section in CLAUDE.md.
 
     const args = ['--output-format', 'stream-json', '--verbose', '--dangerously-skip-permissions'];
 
+    const knockSettings = ClaudeCodeProvider._buildKnockSettings();
+    if (knockSettings) args.push('--settings', knockSettings);
+
     if (agent.model) {
       args.push('--model', agent.model);
     }
@@ -83,11 +91,39 @@ export class ClaudeCodeProvider extends Provider {
     // Resume a previous session — preserves full conversation history
     // No cold start, no handoff brief needed
     const args = ['--resume', sessionId, '--output-format', 'stream-json', '--verbose', '--dangerously-skip-permissions'];
+    const knockSettings = ClaudeCodeProvider._buildKnockSettings();
+    if (knockSettings) args.push('--settings', knockSettings);
     if (model) args.push('--model', model);
     if (prompt) args.push(prompt);
     return { command: 'claude', args, env: {} };
   }
 
+  /**
+   * Build the --settings JSON that registers the GROOVE knock hook as a
+   * PreToolUse handler. The hook script forwards each Bash/Write/Edit tool
+   * call to the daemon, which decides allow/deny based on scope + active
+   * locks. Fails open if the daemon is unreachable.
+   */
+  static _buildKnockSettings() {
+    try {
+      const hookPath = resolve(__dirname, '..', '..', 'templates', 'knock-hook.cjs');
+      if (!existsSync(hookPath)) return null;
+      const settings = {
+        hooks: {
+          PreToolUse: [
+            {
+              matcher: 'Bash|Write|Edit|NotebookEdit|MultiEdit',
+              hooks: [{ type: 'command', command: `node ${hookPath}`, timeout: 5 }],
+            },
+          ],
+        },
+      };
+      return JSON.stringify(settings);
+    } catch {
+      return null;
+    }
+  }
+
   buildHeadlessCommand(prompt, model) {
     // Pass prompt via stdin to avoid OS argument length limits.
     // Long prompts (journalist synthesis with agent logs) can exceed ARG_MAX.
@@ -149,19 +185,22 @@ export class ClaudeCodeProvider extends Provider {
           const cacheReadTokens = usage?.cache_read_input_tokens || 0;
           const cacheCreationTokens = usage?.cache_creation_input_tokens || 0;
           const outputTokens = usage?.output_tokens || 0;
+          // tokensUsed = new processing tokens only (input + output). Cache reads are
+          // the same bytes re-read every turn and must NOT be accumulated — doing so
+          // inflated agent.tokensUsed ~50× and created the phantom "freeze at 1M".
+          // totalIn still drives contextUsage because cached bytes DO occupy context.
           const totalIn = inputTokens + cacheReadTokens + cacheCreationTokens;
           events.push({
             type: 'activity',
             subtype: 'assistant',
             data: data.message?.content || '',
-            tokensUsed: totalIn + outputTokens,
+            tokensUsed: inputTokens + outputTokens,
             inputTokens,
             outputTokens,
             cacheReadTokens,
             cacheCreationTokens,
             model: data.message?.model,
           });
-          // Compute context usage from assistant message usage
           if (totalIn > 0) {
             const modelId = data.message?.model || '';
             const modelMeta = ClaudeCodeProvider.models.find((m) => modelId.includes(m.id));
@@ -172,21 +211,12 @@ export class ClaudeCodeProvider extends Provider {
             });
           }
         } else if (data.type === 'result') {
-          // Result has cumulative usage for the full session
-          const usage = data.usage;
-          const inputTokens = usage?.input_tokens || 0;
-          const cacheReadTokens = usage?.cache_read_input_tokens || 0;
-          const cacheCreationTokens = usage?.cache_creation_input_tokens || 0;
-          const outputTokens = usage?.output_tokens || 0;
-          const totalIn = inputTokens + cacheReadTokens + cacheCreationTokens;
+          // Result carries cumulative session usage — per-turn counts were already
+          // accumulated from assistant events, so we do NOT emit tokensUsed here
+          // (that was the double-count). Only emit session-level metadata.
           events.push({
             type: 'result',
             data: data.result,
-            tokensUsed: totalIn + outputTokens,
-            inputTokens,
-            outputTokens,
-            cacheReadTokens,
-            cacheCreationTokens,
             cost: data.total_cost_usd,
             duration: data.duration_ms,
             turns: data.num_turns,

package/node_modules/@groove-dev/daemon/templates/knock-hook.cjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+// GROOVE — Claude Code PreToolUse hook for knock protocol enforcement.
+// Reads a tool-use payload from stdin, forwards it to the daemon's /api/knock
+// endpoint with the agent ID attached, and blocks the tool (exit 2) if the
+// daemon denies. Fails open on any error so daemon hiccups don't break agents.
+
+const http = require('http');
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (c) => { input += c; });
+process.stdin.on('end', () => {
+  try {
+    const data = input ? JSON.parse(input) : {};
+    const agentId = process.env.GROOVE_AGENT_ID;
+    if (!agentId) { process.exit(0); }
+    const port = Number(process.env.GROOVE_DAEMON_PORT) || 31415;
+    const host = process.env.GROOVE_DAEMON_HOST || '127.0.0.1';
+    const body = JSON.stringify({ ...data, grooveAgentId: agentId });
+    const req = http.request({
+      host, port, path: '/api/knock', method: 'POST',
+      headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(body) },
+    }, (res) => {
+      let out = '';
+      res.on('data', (c) => { out += c; });
+      res.on('end', () => {
+        try {
+          const parsed = JSON.parse(out);
+          if (parsed && parsed.allow === false) {
+            process.stderr.write(String(parsed.reason || 'Blocked by GROOVE PM: operation conflicts with another agent or violates scope rules.'));
+            process.exit(2);
+          }
+        } catch { /* fail open */ }
+        process.exit(0);
+      });
+    });
+    req.on('error', () => process.exit(0));
+    req.setTimeout(3000, () => { try { req.destroy(); } catch {} process.exit(0); });
+    req.write(body);
+    req.end();
+  } catch {
+    process.exit(0);
+  }
+});