groove-dev 0.27.37 → 0.27.40

package/packages/daemon/src/preview.js

@@ -0,0 +1,249 @@
+// GROOVE — Preview Service
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Launches the one-click preview for a completed team. The planner writes a
+// "preview" block in recommended-team.json describing how to run the project
+// (dev-server command, static-html entry, or none). When the last phase
+// agent completes, we spawn the command, parse the URL from stdout, and
+// broadcast a preview:ready event so the GUI can show a View Site toast.
+//
+// One preview process per team. Starting a new preview for the same team
+// kills the previous one. Previews are also killed on team delete and on
+// daemon shutdown.
+
+import { spawn as cpSpawn } from 'child_process';
+import { resolve, extname } from 'path';
+import { existsSync, readFileSync, statSync } from 'fs';
+import { createServer } from 'http';
+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) {
+    this.daemon = daemon;
+    this.previews = new Map(); // teamId -> { proc?, server?, url, kind, startedAt }
+    this.pendingPlans = new Map(); // teamId -> { preview, workingDir }
+  }
+
+  /**
+   * Capture a preview plan at team launch time — api cleanup deletes the
+   * source file immediately after read, so the daemon is the only place the
+   * preview block survives.
+   */
+  stashPlan(teamId, preview, workingDir) {
+    if (!teamId || !preview) return;
+    this.pendingPlans.set(teamId, { preview, workingDir });
+  }
+
+  getPlan(teamId) {
+    return this.pendingPlans.get(teamId) || null;
+  }
+
+  clearPlan(teamId) {
+    this.pendingPlans.delete(teamId);
+  }
+
+  /**
+   * Read recommended-team.json for a given working directory and return the
+   * preview block (or null if none). We read from both the team working dir
+   * and the daemon .groove dir to cover the cases the api cleanup hits.
+   */
+  getPlanPreview(workingDir) {
+    const candidates = [
+      workingDir ? resolve(workingDir, '.groove', 'recommended-team.json') : null,
+      resolve(this.daemon.grooveDir, 'recommended-team.json'),
+    ].filter(Boolean);
+    for (const p of candidates) {
+      if (!existsSync(p)) continue;
+      try {
+        const data = JSON.parse(readFileSync(p, 'utf8'));
+        if (data && typeof data.preview === 'object') return data.preview;
+      } catch { /* malformed, keep looking */ }
+    }
+    return null;
+  }
+
+  /**
+   * Preview blocks are embedded in the plan artifact, which /api/cleanup
+   * deletes as soon as the user clicks Launch Team. Callers should grab the
+   * preview upfront at launch time and hand it back when the team completes.
+   */
+  async launch(teamId, workingDir, preview) {
+    if (!preview || !preview.kind || preview.kind === 'none' || preview.kind === 'cli') {
+      return { launched: false, reason: preview?.kind || 'no_preview' };
+    }
+
+    // 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);
+
+    if (!existsSync(baseDir)) {
+      return { launched: false, reason: `cwd_missing: ${baseDir}` };
+    }
+
+    if (preview.kind === 'static-html') {
+      return this._launchStatic(teamId, baseDir, preview);
+    }
+    if (preview.kind === 'dev-server') {
+      return this._launchDevServer(teamId, baseDir, preview);
+    }
+    return { launched: false, reason: `unknown_kind: ${preview.kind}` };
+  }
+
+  _launchStatic(teamId, baseDir, preview) {
+    const openPath = (preview.openPath || 'index.html').replace(/^\/+/, '');
+    const entryFile = resolve(baseDir, openPath);
+    if (!existsSync(entryFile)) {
+      return Promise.resolve({ launched: false, reason: `entry_missing: ${entryFile}` });
+    }
+    const server = createServer((req, res) => {
+      const url = decodeURIComponent((req.url || '/').split('?')[0]);
+      const rel = url === '/' ? openPath : url.replace(/^\/+/, '');
+      const filePath = resolve(baseDir, rel);
+      if (!filePath.startsWith(baseDir)) { res.statusCode = 403; return res.end(); }
+      if (!existsSync(filePath) || !statSync(filePath).isFile()) {
+        res.statusCode = 404; return res.end('Not found');
+      }
+      res.setHeader('Content-Type', mimeLookup(extname(filePath)) || 'application/octet-stream');
+      res.end(readFileSync(filePath));
+    });
+    return new Promise((done) => {
+      server.listen(0, '127.0.0.1', () => {
+        const port = server.address().port;
+        const url = `http://127.0.0.1:${port}/`;
+        this.previews.set(teamId, { server, url, kind: 'static-html', startedAt: Date.now() });
+        this._broadcastReady(teamId, url, 'static-html');
+        done({ launched: true, url, kind: 'static-html' });
+      });
+      server.on('error', (err) => done({ launched: false, reason: err.message }));
+    });
+  }
+
+  _launchDevServer(teamId, baseDir, preview) {
+    const command = String(preview.command || '').trim();
+    if (!command) {
+      return Promise.resolve({ launched: false, reason: 'no_command' });
+    }
+    const urlPattern = preview.urlPattern
+      ? new RegExp(preview.urlPattern)
+      : /https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0):\d+/;
+    const readyText = preview.readyText || '';
+
+    // Run the command via the user's shell so pipelines, && chains, env var
+    // expansion, and shell builtins work as the planner wrote them.
+    const proc = cpSpawn('bash', ['-lc', command], {
+      cwd: baseDir,
+      env: { ...process.env, FORCE_COLOR: '0', CI: '' },
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: false,
+    });
+
+    const entry = { proc, url: null, kind: 'dev-server', startedAt: Date.now(), command, baseDir };
+    this.previews.set(teamId, entry);
+
+    let stdoutBuf = '';
+    let stderrBuf = '';
+    let resolved = false;
+
+    return new Promise((done) => {
+      const finish = (result) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timer);
+        if (result.launched) {
+          entry.url = result.url;
+          this._broadcastReady(teamId, result.url, 'dev-server');
+        } else {
+          // Failed to detect URL — keep the process? Probably kill it; the user
+          // will just see broken output otherwise.
+          try { proc.kill('SIGTERM'); } catch {}
+          this.previews.delete(teamId);
+        }
+        done(result);
+      };
+
+      const timer = setTimeout(() => {
+        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 = stripAnsi(stdoutBuf + '\n' + stderrBuf);
+        if (readyText && !combined.includes(readyText)) return;
+        const m = combined.match(urlPattern);
+        if (!m) return;
+        let url = m[0];
+        const openPath = (preview.openPath || '').replace(/^\/+/, '');
+        if (openPath) url = url.replace(/\/$/, '') + '/' + openPath;
+        finish({ launched: true, url, kind: 'dev-server' });
+      };
+
+      proc.stdout.on('data', (c) => {
+        stdoutBuf += c.toString();
+        if (stdoutBuf.length > MAX_STDOUT_BYTES) stdoutBuf = stdoutBuf.slice(-MAX_STDOUT_BYTES);
+        tryMatch();
+      });
+      proc.stderr.on('data', (c) => {
+        stderrBuf += c.toString();
+        if (stderrBuf.length > MAX_STDOUT_BYTES) stderrBuf = stderrBuf.slice(-MAX_STDOUT_BYTES);
+        tryMatch();
+      });
+
+      proc.on('exit', (code, signal) => {
+        this.previews.delete(teamId);
+        if (!resolved) {
+          finish({ launched: false, reason: `process exited before url detected (code=${code} signal=${signal}); stderr tail: ${stderrBuf.slice(-400)}` });
+        } else {
+          this.daemon.broadcast({ type: 'preview:stopped', teamId, code, signal });
+        }
+      });
+      proc.on('error', (err) => {
+        if (!resolved) finish({ launched: false, reason: `spawn error: ${err.message}` });
+      });
+    });
+  }
+
+  _broadcastReady(teamId, url, kind) {
+    this.daemon.audit?.log('preview.ready', { teamId, url, kind });
+    this.daemon.broadcast({ type: 'preview:ready', teamId, url, kind });
+  }
+
+  get(teamId) {
+    const entry = this.previews.get(teamId);
+    if (!entry) return null;
+    return { teamId, url: entry.url, kind: entry.kind, startedAt: entry.startedAt };
+  }
+
+  list() {
+    return Array.from(this.previews.entries()).map(([teamId, e]) => ({
+      teamId, url: e.url, kind: e.kind, startedAt: e.startedAt,
+    }));
+  }
+
+  async kill(teamId) {
+    const entry = this.previews.get(teamId);
+    if (!entry) return false;
+    this.previews.delete(teamId);
+    try {
+      if (entry.server) entry.server.close();
+      if (entry.proc) entry.proc.kill('SIGTERM');
+    } catch { /* best-effort */ }
+    this.daemon.broadcast({ type: 'preview:stopped', teamId });
+    return true;
+  }
+
+  async killAll() {
+    const ids = Array.from(this.previews.keys());
+    await Promise.all(ids.map((id) => this.kill(id)));
+  }
+}

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/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;

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