groove-dev 0.27.37 → 0.27.39

package/packages/daemon/src/process.js

@@ -224,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.
 {
@@ -360,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];
@@ -655,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
@@ -724,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,
     });
@@ -846,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') {
@@ -1039,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;
@@ -1209,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' });
@@ -1408,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,
     });
@@ -1449,7 +1557,37 @@ For normal file edits within your scope, proceed without review.
       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 */ }
       }
     });
 

package/packages/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.

package/packages/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);
+  }
+});