groove-dev 0.26.38 → 0.27.0

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

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/daemon",
-  "version": "0.11.0",
+  "version": "0.27.0",
   "description": "GROOVE daemon — agent orchestration engine",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

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

@@ -103,9 +103,9 @@ export class AdaptiveThresholds {
     const errorCount = signals.errorCount || 0;
     score -= errorCount * 5;
 
-    // Repetitions: each detected repetition costs 8 points (agent repeating itself)
+    // Repetitions: 3+ Write/Edit to the same file in a sliding window
     const repetitions = signals.repetitions || 0;
-    score -= repetitions * 8;
+    score -= Math.min(repetitions * 6, 30);
 
     // Out-of-scope access: each violation costs 10 points
     const scopeViolations = signals.scopeViolations || 0;
@@ -116,12 +116,12 @@ export class AdaptiveThresholds {
     const toolFailures = signals.toolFailures || 0;
     if (toolCalls > 0) {
       const successRate = (toolCalls - toolFailures) / toolCalls;
-      score += Math.round((successRate - 0.8) * 20); // Bonus/penalty around 80%
+      score += Math.round((successRate - 0.8) * 20);
     }
 
-    // File churn: editing same file 3+ times signals circular refactoring
+    // File churn: same file written 5+ times — genuine circular refactoring
     const fileChurn = signals.fileChurn || 0;
-    score -= fileChurn * 12;
+    score -= fileChurn * 10;
 
     // Error trend: increasing errors in second half = degradation
     const errorTrend = signals.errorTrend || 0;
@@ -162,46 +162,34 @@ export class AdaptiveThresholds {
       errorTrend: 0,        // errors increasing in recent window → degradation signal
     };
 
-    const recentTools = [];
     const writtenFiles = new Set();
-    const fileWriteCounts = {}; // track how many times each file is written
-    const errorTimestamps = [];
+    const fileWriteCounts = {};
+    const writeEditOps = [];
 
     for (const entry of entries) {
       if (entry.type === 'error') {
         signals.errorCount++;
-        errorTimestamps.push(entry.timestamp || Date.now());
       }
 
       if (entry.type === 'tool') {
         signals.toolCalls++;
 
-        // Track file writes and churn
         if (entry.tool === 'Write' || entry.tool === 'Edit') {
           if (entry.input) {
             writtenFiles.add(entry.input);
             fileWriteCounts[entry.input] = (fileWriteCounts[entry.input] || 0) + 1;
+            writeEditOps.push(entry.input);
           }
         }
 
-        // Track tool failures — errors that follow tool calls indicate failure
-        // (stream-json emits tool_use then tool_result with is_error)
-        if (entry.type === 'tool' && entry.isError) {
+        if (entry.isError) {
           signals.toolFailures++;
         }
 
-        // Detect repetitions: same tool+input within last 5 calls
-        const key = `${entry.tool}:${entry.input}`;
-        if (recentTools.includes(key)) {
-          signals.repetitions++;
-        }
-        recentTools.push(key);
-        if (recentTools.length > 5) recentTools.shift();
-
-        // Detect scope violations (simplified check)
+        // Scope violations: writes outside declared scope
         if (agentScope && agentScope.length > 0 && entry.input) {
-          const file = entry.input;
           if (entry.tool === 'Write' || entry.tool === 'Edit') {
+            const file = entry.input;
             const inScope = agentScope.some((pattern) =>
               file.includes(pattern.replace('/**', '').replace('**/', ''))
             );
@@ -213,9 +201,19 @@ export class AdaptiveThresholds {
 
     signals.filesWritten = writtenFiles.size;
 
-    // File churn: count files written 3+ times (circular refactoring signal)
+    // Repetitions: only count Write/Edit to the same file as circular behavior.
+    // Read/Grep/Glob revisits are normal investigation — not degradation.
+    // Require 3+ writes to the same file within a 15-op sliding window.
+    for (let i = 0; i < writeEditOps.length; i++) {
+      const windowStart = Math.max(0, i - 14);
+      const window = writeEditOps.slice(windowStart, i);
+      const count = window.filter((f) => f === writeEditOps[i]).length;
+      if (count >= 2) signals.repetitions++;
+    }
+
+    // File churn: files written 5+ times (circular refactoring, not normal iteration)
     for (const count of Object.values(fileWriteCounts)) {
-      if (count >= 3) signals.fileChurn++;
+      if (count >= 5) signals.fileChurn++;
     }
 
     // Error trend: compare error rate in first half vs second half of session

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

@@ -117,6 +117,116 @@ export function createApi(app, daemon) {
     res.json(daemon.locks.getAll());
   });
 
+  // Coordination protocol — agents declare intent on shared resources
+  // (npm install, server restart, package.json edit) to prevent races.
+  // Returns 423 Locked if another agent holds a conflicting resource.
+  app.post('/api/coordination/declare', (req, res) => {
+    const { agentId, operation, resources, ttlMs } = req.body || {};
+    if (!agentId || !operation || !Array.isArray(resources) || resources.length === 0) {
+      return res.status(400).json({ error: 'agentId, operation, and resources[] required' });
+    }
+    const result = daemon.locks.declareOperation(agentId, operation, resources, ttlMs);
+    if (result.conflict) {
+      daemon.audit.log('coordination.conflict', { agentId, operation, resource: result.resource, owner: result.owner });
+      return res.status(423).json(result);
+    }
+    daemon.audit.log('coordination.declared', { agentId, operation, resources });
+    daemon.broadcast({ type: 'coordination:declared', agentId, operation, resources });
+    res.json({ declared: true, operation, resources });
+  });
+
+  app.post('/api/coordination/complete', (req, res) => {
+    const { agentId } = req.body || {};
+    if (!agentId) return res.status(400).json({ error: 'agentId required' });
+    const removed = daemon.locks.completeOperation(agentId);
+    daemon.audit.log('coordination.completed', { agentId });
+    daemon.broadcast({ type: 'coordination:completed', agentId });
+    res.json({ completed: removed });
+  });
+
+  app.get('/api/coordination', (req, res) => {
+    res.json({ operations: daemon.locks.getOperations() });
+  });
+
+  // --- Persistent Memory (Layer 7) ---
+  // Constraints: project rules discovered by agents / set by user
+  app.get('/api/memory/constraints', (req, res) => {
+    res.json({ constraints: daemon.memory.listConstraints() });
+  });
+
+  app.post('/api/memory/constraints', (req, res) => {
+    const { text, category } = req.body || {};
+    const result = daemon.memory.addConstraint({ text, category });
+    if (!result.added && result.error) {
+      return res.status(400).json(result);
+    }
+    if (result.added) {
+      daemon.audit.log('memory.constraint.added', { hash: result.hash, category });
+      daemon.broadcast({ type: 'memory:constraint:added', hash: result.hash });
+    }
+    res.json(result);
+  });
+
+  app.delete('/api/memory/constraints/:hash', (req, res) => {
+    const removed = daemon.memory.removeConstraint(req.params.hash);
+    if (removed) {
+      daemon.audit.log('memory.constraint.removed', { hash: req.params.hash });
+      daemon.broadcast({ type: 'memory:constraint:removed', hash: req.params.hash });
+    }
+    res.json({ removed });
+  });
+
+  // Handoff chains (per role)
+  app.get('/api/memory/handoff-chain/:role', (req, res) => {
+    res.json({
+      role: req.params.role,
+      entries: daemon.memory.getHandoffChain(req.params.role),
+    });
+  });
+
+  app.get('/api/memory/handoff-chain/:role/recent', (req, res) => {
+    const count = Math.min(parseInt(req.query.count) || 3, 10);
+    res.json({
+      role: req.params.role,
+      markdown: daemon.memory.getRecentHandoffMarkdown(req.params.role, count, 10_000),
+    });
+  });
+
+  app.get('/api/memory/handoff-chain', (req, res) => {
+    res.json({ roles: daemon.memory.listHandoffRoles() });
+  });
+
+  // Discoveries (error → fix pairs)
+  app.get('/api/memory/discoveries', (req, res) => {
+    const role = req.query.role;
+    const limit = Math.min(parseInt(req.query.limit) || 100, 500);
+    res.json({ discoveries: daemon.memory.listDiscoveries({ role, limit }) });
+  });
+
+  app.post('/api/memory/discoveries', (req, res) => {
+    const { agentId, role, trigger, fix, outcome } = req.body || {};
+    const result = daemon.memory.addDiscovery({ agentId, role, trigger, fix, outcome });
+    if (!result.added && result.error) {
+      return res.status(400).json(result);
+    }
+    if (result.added) {
+      daemon.audit.log('memory.discovery.added', { agentId, role });
+      daemon.broadcast({ type: 'memory:discovery:added', agentId, role });
+    }
+    res.json(result);
+  });
+
+  // Specializations (per-agent + per-role quality profiles)
+  app.get('/api/memory/specializations', (req, res) => {
+    res.json(daemon.memory.getAllSpecializations());
+  });
+
+  app.get('/api/memory/specializations/:agentId', (req, res) => {
+    const spec = daemon.memory.getSpecialization(req.params.agentId);
+    if (!spec) return res.status(404).json({ error: 'No specialization data for this agent' });
+    res.json(spec);
+  });
+
   // Token usage
   app.get('/api/tokens', (req, res) => {
     res.json(daemon.tokens.getAll());
@@ -375,6 +485,14 @@ export function createApi(app, daemon) {
     res.json(rec);
   });
 
+  // Downshift suggestion — NEVER auto-applied. User must accept via UI.
+  // Returns null (204) when classifier has no strong suggestion.
+  app.get('/api/agents/:id/routing/suggestion', (req, res) => {
+    const suggestion = daemon.router.getSuggestion(req.params.id);
+    if (!suggestion) return res.status(204).send();
+    res.json(suggestion);
+  });
+
   // Daemon status
   app.get('/api/status', (req, res) => {
     res.json({
@@ -459,6 +577,68 @@ export function createApi(app, daemon) {
     res.json(daemon.tokens.getSummary());
   });
 
+  // Per-team token burn ranked by total. Answers "which team burned the most?"
+  app.get('/api/tokens/by-team', (req, res) => {
+    const agents = daemon.registry.getAll();
+    const usage = daemon.tokens.getAll();
+    const teams = daemon.teams.list();
+    const unassignedId = '__unassigned__';
+
+    const perTeam = new Map();
+    for (const t of teams) {
+      perTeam.set(t.id, {
+        teamId: t.id,
+        teamName: t.name,
+        isDefault: !!t.isDefault,
+        agentCount: 0,
+        totalTokens: 0,
+        totalCostUsd: 0,
+        avgTokensPerAgent: 0,
+      });
+    }
+    perTeam.set(unassignedId, {
+      teamId: unassignedId,
+      teamName: '(unassigned)',
+      isDefault: false,
+      agentCount: 0,
+      totalTokens: 0,
+      totalCostUsd: 0,
+      avgTokensPerAgent: 0,
+    });
+
+    for (const agent of agents) {
+      const bucket = perTeam.get(agent.teamId) || perTeam.get(unassignedId);
+      const u = usage[agent.id];
+      if (!u) continue;
+      bucket.agentCount += 1;
+      bucket.totalTokens += u.total || 0;
+      bucket.totalCostUsd += u.totalCostUsd || 0;
+    }
+
+    const result = [...perTeam.values()]
+      .map((t) => ({
+        ...t,
+        avgTokensPerAgent: t.agentCount > 0 ? Math.round(t.totalTokens / t.agentCount) : 0,
+      }))
+      .filter((t) => t.agentCount > 0 || t.isDefault)
+      .sort((a, b) => b.totalTokens - a.totalTokens);
+
+    res.json({ teams: result });
+  });
+
+  // Stop an agent's current work without killing the agent
+  app.post('/api/agents/:id/stop', async (req, res) => {
+    try {
+      const agent = daemon.registry.get(req.params.id);
+      if (!agent) return res.status(404).json({ error: 'Agent not found' });
+      await daemon.processes.stop(req.params.id);
+      daemon.audit.log('agent.stop', { id: req.params.id, name: agent.name });
+      res.json({ id: req.params.id, status: 'stopped' });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
   // Rotate an agent
   app.post('/api/agents/:id/rotate', async (req, res) => {
     try {
@@ -542,7 +722,7 @@ export function createApi(app, daemon) {
         '\nAnswer concisely based on the agent context above.',
       ].filter(Boolean).join('\n');
 
-      const response = await daemon.journalist.callHeadless(prompt);
+      const response = await daemon.journalist.callHeadless(prompt, { trackAs: '__agent_qa__' });
       res.json({ response, agentId: agent.id, agentName: agent.name });
     } catch (err) {
       res.status(400).json({ error: err.message });
@@ -721,7 +901,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
 
       // Slow path: CLI fallback for subscription auth (~10s)
       const fullPrompt = `${PLAN_SYSTEM}\n\n${prompt}`;
-      const response = await daemon.journalist.callHeadless(fullPrompt);
+      const response = await daemon.journalist.callHeadless(fullPrompt, { trackAs: '__planner__' });
       res.json({ response, mode: 'cli' });
     } catch (err) {
       res.status(500).json({ error: err.message });
@@ -1025,6 +1205,17 @@ Keep responses concise. Help them think, don't lecture them about the system the
     }
   });
 
+  app.post('/api/integrations/google-workspace/oauth/start', (req, res) => {
+    try {
+      const { integrationIds } = req.body || {};
+      if (!integrationIds?.length) return res.status(400).json({ error: 'integrationIds required' });
+      const url = daemon.integrations.getGoogleWorkspaceOAuthUrl(integrationIds);
+      res.json({ url });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
   // Parameterized :id routes (after specific routes above)
 
   app.post('/api/integrations/:id/authenticate', (req, res) => {
@@ -1092,6 +1283,134 @@ Keep responses concise. Help them think, don't lecture them about the system the
     }
   });
 
+  // --- Integration Execution (provider-agnostic) ---
+
+  const _execRates = new Map();
+  const EXEC_RATE_LIMIT = 30;
+  const EXEC_RATE_WINDOW = 60_000;
+
+  app.post('/api/integrations/:id/exec', async (req, res) => {
+    try {
+      const { tool, params, approvalId, agent: agentId } = req.body || {};
+      if (!tool || typeof tool !== 'string') {
+        return res.status(400).json({ error: 'tool (string) is required' });
+      }
+      if (params !== undefined && (typeof params !== 'object' || Array.isArray(params))) {
+        return res.status(400).json({ error: 'params must be an object' });
+      }
+      const integrationId = req.params.id;
+      if (!daemon.integrations._isInstalled(integrationId)) {
+        return res.status(400).json({ error: 'Integration not installed' });
+      }
+
+      // Rate limiting — sliding window per integration
+      const now = Date.now();
+      let window = _execRates.get(integrationId) || [];
+      window = window.filter((t) => now - t < EXEC_RATE_WINDOW);
+      if (window.length >= EXEC_RATE_LIMIT) {
+        daemon.audit.log('integration.exec.rate_limited', { integrationId, tool, agentId });
+        return res.status(429).json({ error: `Rate limit exceeded (${EXEC_RATE_LIMIT}/min) for ${integrationId}` });
+      }
+      window.push(now);
+      _execRates.set(integrationId, window);
+
+      // Approval gate — dangerous tools require human approval (unless agent is set to auto)
+      const entry = daemon.integrations.registry.find((s) => s.id === integrationId);
+      const callingAgent = agentId ? daemon.registry.get(agentId) : null;
+      const autoApprove = callingAgent?.integrationApproval === 'auto';
+      if (entry?.requiresApproval?.includes(tool) && !autoApprove) {
+        if (approvalId) {
+          const approval = daemon.supervisor.getApproval(approvalId);
+          if (!approval) return res.status(404).json({ error: 'Approval not found' });
+          if (approval.status === 'rejected') {
+            return res.status(403).json({ error: 'Approval rejected', reason: approval.reason });
+          }
+          if (approval.status !== 'approved') {
+            return res.status(202).json({ requiresApproval: true, approvalId, status: 'pending', message: 'Waiting for human approval' });
+          }
+        } else {
+          const paramsSummary = params ? JSON.stringify(params).slice(0, 500) : '{}';
+          const approval = daemon.supervisor.requestApproval(agentId || null, {
+            type: 'integration_exec',
+            integrationId,
+            tool,
+            params: paramsSummary,
+            description: `${entry.name}: ${tool}`,
+          });
+          daemon.audit.log('integration.exec.blocked', { integrationId, tool, approvalId: approval.id, agentId });
+          return res.status(202).json({
+            requiresApproval: true,
+            approvalId: approval.id,
+            message: `Tool "${tool}" requires approval. Retry with this approvalId once approved.`,
+          });
+        }
+      }
+
+      const result = await daemon.mcpManager.execTool(integrationId, tool, params || {});
+      daemon.audit.log('integration.exec', { integrationId, tool, params: params ? JSON.stringify(params).slice(0, 200) : '{}', agentId });
+      res.json({ result });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  app.get('/api/integrations/:id/tools', async (req, res) => {
+    try {
+      if (!daemon.integrations._isInstalled(req.params.id)) {
+        return res.status(400).json({ error: 'Integration not installed' });
+      }
+      const tools = await daemon.mcpManager.listTools(req.params.id);
+      res.json({ tools });
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
+  // --- Google Drive Upload (file → native Google Workspace format) ---
+
+  app.post('/api/integrations/google-drive/upload', async (req, res) => {
+    try {
+      const { filePath, name, folderId, convert, approvalId, agent: agentId } = req.body || {};
+      if (!filePath || typeof filePath !== 'string') {
+        return res.status(400).json({ error: 'filePath (string) is required' });
+      }
+
+      // Approval gate (unless agent is set to auto)
+      const uploadAgent = agentId ? daemon.registry.get(agentId) : null;
+      const autoApproveUpload = uploadAgent?.integrationApproval === 'auto';
+      if (!autoApproveUpload) {
+        if (approvalId) {
+          const approval = daemon.supervisor.getApproval(approvalId);
+          if (!approval) return res.status(404).json({ error: 'Approval not found' });
+          if (approval.status === 'rejected') return res.status(403).json({ error: 'Approval rejected', reason: approval.reason });
+          if (approval.status !== 'approved') return res.status(202).json({ requiresApproval: true, approvalId, status: 'pending' });
+        } else {
+          const approval = daemon.supervisor.requestApproval(agentId || null, {
+            type: 'google_drive_upload',
+            filePath,
+            name: name || filePath.split('/').pop(),
+            description: `Upload to Google Drive: ${name || filePath.split('/').pop()}`,
+          });
+          daemon.audit.log('integration.upload.blocked', { filePath, approvalId: approval.id, agentId });
+          return res.status(202).json({
+            requiresApproval: true,
+            approvalId: approval.id,
+            message: `Upload requires approval. Retry with this approvalId once approved.`,
+          });
+        }
+      }
+
+      const result = await daemon.integrations.uploadToGoogleDrive(filePath, {
+        name, folderId, convert: convert !== false,
+      });
+
+      daemon.audit.log('integration.upload', { filePath, driveFileId: result.id, name: result.name, agentId });
+      res.json(result);
+    } catch (err) {
+      res.status(400).json({ error: err.message });
+    }
+  });
+
   // --- Agent Integrations (attach/detach) ---
 
   app.post('/api/agents/:agentId/integrations/:integrationId', (req, res) => {
@@ -1939,8 +2258,9 @@ Keep responses concise. Help them think, don't lecture them about the system the
       // Recalculate savings estimates
       const estimated = registryTokens + tokenSummary.savings.total;
       tokenSummary.savings.estimatedWithoutGroove = estimated;
-      tokenSummary.savings.percentage = estimated > 0
-        ? Math.round((tokenSummary.savings.total / estimated) * 100) : 0;
+      const rawPct = estimated > 0 ? (tokenSummary.savings.total / estimated) * 100 : 0;
+      tokenSummary.savings.percentage = rawPct > 0 && rawPct < 1
+        ? Math.round(rawPct * 10) / 10 : Math.round(rawPct);
     }
     const rotationStats = daemon.rotator.getStats();
     const rotationHistory = daemon.rotator.getHistory();
@@ -1964,27 +2284,31 @@ Keep responses concise. Help them think, don't lecture them about the system the
     // Per-agent enriched data with quality signals
     const agentBreakdown = agents.map((a) => {
       const tokenData = daemon.tokens.getAgent(a.id);
-      const agentCacheTotal = (tokenData.cacheReadTokens || 0) + (tokenData.cacheCreationTokens || 0) + (tokenData.inputTokens || 0);
+      // Cache rate denominator: reads + creation (cacheable), excludes fresh inputTokens
+      const agentCacheable = (tokenData.cacheReadTokens || 0) + (tokenData.cacheCreationTokens || 0);
 
-      // Quality signals from classifier + adaptive
       let quality = null;
       try {
-        const signals = daemon.adaptive.extractSignals ? daemon.adaptive.extractSignals(a.id) : null;
+        const events = daemon.classifier.agentWindows[a.id] || [];
+        const signals = events.length >= 6 ? daemon.adaptive.extractSignals(events, a.scope) : null;
+        const score = signals ? daemon.adaptive.scoreSession(signals) : null;
         const classification = daemon.classifier.classify(a.id);
-        if (signals || classification) {
-          quality = {
-            score: signals?.score || null,
-            errorCount: signals?.errorCount || 0,
-            toolCalls: signals?.toolCalls || 0,
-            toolFailures: signals?.toolFailures || 0,
-            toolSuccessRate: signals?.toolCalls > 0 ? 1 - (signals.toolFailures / signals.toolCalls) : 1,
-            filesWritten: signals?.filesWritten || 0,
-            fileChurn: signals?.fileChurn || 0,
-            repetitions: signals?.repetitions || 0,
-            tier: classification?.tier || 'medium',
-          };
-        }
-      } catch { /* classifier/adaptive may not have data for this agent */ }
+        const history = daemon.rotator.scoreHistory[a.id] || [];
+        quality = {
+          score,
+          scoreHistory: history,
+          errorCount: signals?.errorCount || 0,
+          toolCalls: signals?.toolCalls || 0,
+          toolFailures: signals?.toolFailures || 0,
+          toolSuccessRate: signals?.toolCalls > 0 ? 1 - (signals.toolFailures / signals.toolCalls) : 1,
+          filesWritten: signals?.filesWritten || 0,
+          fileChurn: signals?.fileChurn || 0,
+          repetitions: signals?.repetitions || 0,
+          errorTrend: signals?.errorTrend || 0,
+          tier: classification?.tier || classification || 'medium',
+          eventCount: events.length,
+        };
+      } catch { /* classifier/adaptive may not have data yet */ }
 
       return {
         id: a.id,
@@ -2000,7 +2324,7 @@ Keep responses concise. Help them think, don't lecture them about the system the
         costSource: a.provider === 'claude-code' ? 'actual' : a.provider === 'ollama' ? 'local' : 'estimated',
         inputTokens: tokenData.inputTokens || 0,
         outputTokens: tokenData.outputTokens || 0,
-        cacheHitRate: agentCacheTotal > 0 ? Math.round(((tokenData.cacheReadTokens || 0) / agentCacheTotal) * 1000) / 1000 : 0,
+        cacheHitRate: agentCacheable > 0 ? Math.round(((tokenData.cacheReadTokens || 0) / agentCacheable) * 1000) / 1000 : 0,
         contextUsage: a.contextUsage || 0,
         rotationThreshold: daemon.adaptive.getThreshold(a.provider, a.role),
         durationMs: a.durationMs || tokenData.totalDurationMs || 0,

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

@@ -35,17 +35,64 @@ const LIGHT_SIGNALS = [
 ];
 
 export class TaskClassifier {
-  constructor() {
-    this.windowSize = 50; // Look at last N events — needs to be large enough
+  constructor(daemon = null) {
+    this.windowSize = 200; // Large enough for quality signal extraction across tool calls
     this.agentWindows = {}; // for degradation detection and adaptive scoring
+    this.daemon = daemon; // optional — enables broadcast of classification updates
+    this._lastBroadcastCount = {}; // per-agent throttle
   }
 
-  // Add an event to the classification window
   addEvent(agentId, event) {
     if (!this.agentWindows[agentId]) this.agentWindows[agentId] = [];
-    this.agentWindows[agentId].push(event);
-    if (this.agentWindows[agentId].length > this.windowSize) {
-      this.agentWindows[agentId].shift();
+    const window = this.agentWindows[agentId];
+
+    // Extract structured tool/error events from Claude Code content blocks.
+    // Claude's stream-json emits assistant messages with content arrays containing
+    // tool_use and tool_result blocks that drive quality signal extraction.
+    let extracted = false;
+    if (event.type === 'activity' && Array.isArray(event.data)) {
+      for (const block of event.data) {
+        if (block.type === 'tool_use') {
+          window.push({
+            type: 'tool',
+            tool: block.name,
+            input: block.input?.file_path || block.input?.path || block.input?.command || '',
+            isError: false,
+            timestamp: Date.now(),
+          });
+          extracted = true;
+        }
+        if (block.type === 'tool_result') {
+          if (block.is_error) {
+            window.push({ type: 'error', timestamp: Date.now() });
+            extracted = true;
+          }
+        }
+      }
+    }
+
+    // Only push the raw event if we didn't extract structured events from it —
+    // avoids double-counting and window bloat from activity wrappers.
+    if (!extracted) {
+      window.push({ ...event, timestamp: event.timestamp || Date.now() });
+    }
+    while (window.length > this.windowSize) window.shift();
+
+    // Broadcast classification updates periodically. Enables GUI to surface
+    // downshift suggestions ("agent's been doing light work — switch to Haiku?").
+    // Requires 40+ events before any broadcast; throttles to every 20 events.
+    if (this.daemon?.broadcast && window.length >= 40) {
+      const lastBroadcast = this._lastBroadcastCount[agentId] || 0;
+      if (window.length - lastBroadcast >= 20) {
+        this._lastBroadcastCount[agentId] = window.length;
+        const tier = this.classify(agentId);
+        this.daemon.broadcast({
+          type: 'classifier:update',
+          agentId,
+          tier,
+          eventCount: window.length,
+        });
+      }
     }
   }
 

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

@@ -15,6 +15,16 @@ const DEFAULT_CONFIG = {
   qcThreshold: 4,
   maxAgents: 10,
   defaultProvider: 'claude-code',
+  // Self-healing rotation triggers. Catch pathological agent behavior
+  // (stuck loops, runaway tool-call cycles) and auto-rotate with fresh
+  // context. Tokens carry forward; journalist generates handoff brief.
+  // Set autoRotate=false to disable and get broadcast-only notifications.
+  safety: {
+    autoRotate: true,
+    tokenCeilingPerAgent: 5_000_000,
+    velocityWindowSeconds: 300,
+    velocityTokenThreshold: 1_500_000,
+  },
 };
 
 export function isFirstRun(grooveDir) {
@@ -123,7 +133,10 @@ export function loadConfig(grooveDir) {
 
   try {
     const saved = JSON.parse(readFileSync(configPath, 'utf8'));
-    return { ...DEFAULT_CONFIG, ...saved };
+    const merged = { ...DEFAULT_CONFIG, ...saved };
+    // Deep-merge safety subtree so partial user config doesn't drop defaults
+    merged.safety = { ...DEFAULT_CONFIG.safety, ...(saved.safety || {}) };
+    return merged;
   } catch {
     return { ...DEFAULT_CONFIG };
   }

package/node_modules/@groove-dev/daemon/src/gateways/manager.js

@@ -638,7 +638,7 @@ export class GatewayManager {
         '\nSynthesize a concise answer based on the team\'s collective context.',
       ].join('\n');
 
-      const response = await this.daemon.journalist.callHeadless(prompt);
+      const response = await this.daemon.journalist.callHeadless(prompt, { trackAs: '__gateway__' });
       return { text: `\ud83d\udcac Team ${result.team.name}:\n${truncate(response, 3000)}` };
     }
 
@@ -659,7 +659,7 @@ export class GatewayManager {
       '\nAnswer concisely based on the agent context above.',
     ].filter(Boolean).join('\n');
 
-    const response = await this.daemon.journalist.callHeadless(prompt);
+    const response = await this.daemon.journalist.callHeadless(prompt, { trackAs: '__gateway__' });
     return { text: `\ud83d\udcac ${agent.name || agent.id}:\n${truncate(response, 3000)}` };
   }