groove-dev 0.26.39 → 0.27.0

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,55 @@ 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 {
@@ -555,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 });
@@ -734,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 });
@@ -2117,7 +2284,8 @@ 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);
 
       let quality = null;
       try {
@@ -2156,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,9 +35,11 @@ const LIGHT_SIGNALS = [
 ];
 
 export class TaskClassifier {
-  constructor() {
+  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
   }
 
   addEvent(agentId, event) {
@@ -75,6 +77,23 @@ export class TaskClassifier {
       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,
+        });
+      }
+    }
   }
 
   // Classify current activity for an agent

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

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

@@ -32,6 +32,7 @@ import { IntegrationStore } from './integrations.js';
 import { Scheduler } from './scheduler.js';
 import { FileWatcher } from './filewatcher.js';
 import { TimelineTracker } from './timeline.js';
+import { MemoryStore } from './memory.js';
 import { TerminalManager } from './terminal-pty.js';
 import { GatewayManager } from './gateways/manager.js';
 import { McpManager } from './mcp-manager.js';
@@ -111,6 +112,7 @@ export class Daemon {
     this.registry = new Registry(this.state);
     this.locks = new LockManager(this.grooveDir);
     this.tokens = new TokenTracker(this.grooveDir);
+    this.memory = new MemoryStore(this.grooveDir);
     this.timeline = new TimelineTracker(this);
     this.processes = new ProcessManager(this);
     this.introducer = new Introducer(this);
@@ -120,7 +122,7 @@ export class Daemon {
     this.adaptive = new AdaptiveThresholds(this.grooveDir);
     this.teams = new Teams(this);
     this.credentials = new CredentialStore(this.grooveDir);
-    this.classifier = new TaskClassifier();
+    this.classifier = new TaskClassifier(this);
     this.router = new ModelRouter(this);
     this.pm = new ProjectManager(this);
     this.indexer = new CodebaseIndexer(this);

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

@@ -107,6 +107,47 @@ export class Introducer {
         }
       }
 
+      // Project memory (Layer 7) — accumulated wisdom across all prior rotations.
+      // Constraints, recent role handoffs, known error→fix patterns. Total cap ~12K chars.
+      if (this.daemon.memory) {
+        const constraints = this.daemon.memory.getConstraintsMarkdown(4000);
+        const recentChain = this.daemon.memory.getRecentHandoffMarkdown(newAgent.role, 3, 4000);
+        const discoveries = this.daemon.memory.getDiscoveriesMarkdown(newAgent.role, 20, 4000);
+
+        if (constraints || recentChain || discoveries) {
+          lines.push('');
+          lines.push(`## Project Memory`);
+          lines.push('');
+          lines.push(`This is accumulated knowledge from prior agents working on this project. Read carefully — it will save you from rediscovering what others already learned.`);
+
+          if (constraints) {
+            lines.push('');
+            lines.push(`### Constraints`);
+            lines.push('');
+            lines.push(constraints);
+          }
+
+          if (recentChain) {
+            lines.push('');
+            lines.push(`### Recent ${newAgent.role} handoffs`);
+            lines.push('');
+            lines.push(recentChain);
+          }
+
+          if (discoveries) {
+            lines.push('');
+            lines.push(`### Known patterns (from prior ${newAgent.role} agents)`);
+            lines.push('');
+            lines.push(discoveries);
+          }
+
+          lines.push('');
+          lines.push(`You can contribute to this memory via:`);
+          lines.push(`- \`POST /api/memory/discoveries\` — share an error→fix you found`);
+          lines.push(`- \`POST /api/memory/constraints\` — declare a project rule you discovered`);
+        }
+      }
+
       // Project files section — tell the new agent what exists and what to read
       if (allTeamFiles.length > 0) {
         lines.push('');
@@ -149,11 +190,21 @@ export class Introducer {
       lines.push('');
       lines.push(`## Coordination Protocol`);
       lines.push('');
-      lines.push(`Before performing shared/destructive actions (restart server, npm install/build, modify package.json, modify shared config), coordinate with your team:`);
-      lines.push(`1. Read \`.groove/coordination.md\` to check for active operations`);
-      lines.push(`2. Write your intent to \`.groove/coordination.md\` (e.g., "backend-1: restarting server")`);
-      lines.push(`3. Proceed only if no conflicting operations are active`);
-      lines.push(`4. Clear your entry from \`.groove/coordination.md\` when done`);
+      lines.push(`Before performing shared/destructive actions (restart server, npm install/build, modify package.json, modify shared config), declare intent via the GROOVE daemon. Another agent holding the same resource will cause a 423 response — wait and retry.`);
+      lines.push('');
+      lines.push(`Declare:`);
+      lines.push('```');
+      lines.push(`POST http://127.0.0.1:31415/api/coordination/declare`);
+      lines.push(`{ "agentId": "${newAgent.id}", "operation": "npm install", "resources": ["package.json", "node_modules"] }`);
+      lines.push('```');
+      lines.push('');
+      lines.push(`Complete (always call this when done, even on failure):`);
+      lines.push('```');
+      lines.push(`POST http://127.0.0.1:31415/api/coordination/complete`);
+      lines.push(`{ "agentId": "${newAgent.id}" }`);
+      lines.push('```');
+      lines.push('');
+      lines.push(`Operations auto-expire after 10 minutes to prevent deadlock.`);
     }
 
     // File safety — prevent agents from deleting files they didn't create

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

@@ -355,7 +355,40 @@ export class Journalist {
     }
   }
 
-  async callHeadless(prompt) {
+  // Extract usage from stream-json stdout and record to token tracker.
+  // Reserved agent IDs (__journalist__, __pm__, etc.) capture overhead
+  // separately from user-facing agents. Silent no-op if provider doesn't
+  // emit usage data.
+  _recordHeadlessUsage(stdout, trackAs, modelId) {
+    if (!this.daemon?.tokens || !stdout) return;
+    const lines = stdout.split('\n');
+    for (const line of lines) {
+      try {
+        const data = JSON.parse(line);
+        if (data.type !== 'result') continue;
+        const usage = data.usage;
+        if (!usage) continue;
+        const inputTokens = usage.input_tokens || 0;
+        const outputTokens = usage.output_tokens || 0;
+        const cacheReadTokens = usage.cache_read_input_tokens || 0;
+        const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+        const total = inputTokens + outputTokens + cacheReadTokens + cacheCreationTokens;
+        if (total === 0) continue;
+        this.daemon.tokens.record(trackAs, {
+          tokens: total,
+          inputTokens,
+          outputTokens,
+          cacheReadTokens,
+          cacheCreationTokens,
+          model: modelId,
+          estimatedCostUsd: data.total_cost_usd || 0,
+        });
+        return;
+      } catch { /* skip non-JSON lines */ }
+    }
+  }
+
+  async callHeadless(prompt, { trackAs = '__journalist__' } = {}) {
     // Find the best available provider for headless synthesis
     // Priority: claude-code (cheapest via Haiku) > gemini > codex > ollama
     const priority = ['claude-code', 'gemini', 'codex', 'ollama'];
@@ -391,6 +424,7 @@ export class Journalist {
         proc.on('exit', (code) => {
           clearTimeout(timer);
           if (code !== 0) return reject(new Error(`Headless exited with code ${code}`));
+          this._recordHeadlessUsage(stdout, trackAs, modelId);
           // Process stdout same as execFile path below
           const lines = stdout.split('\n');
           for (const line of lines) {
@@ -413,6 +447,8 @@ export class Journalist {
       }, (err, stdout, stderr) => {
         if (err) return reject(err);
 
+        this._recordHeadlessUsage(stdout, trackAs, modelId);
+
         // Parse stream-json output to extract the result text
         const lines = stdout.split('\n');
         for (const line of lines) {
@@ -648,12 +684,18 @@ export class Journalist {
       .slice(-3)
       .join('\n');
 
+    // Pull recent rotation history from persistent memory (Layer 7).
+    // Gives the new agent causal continuity: what the last 3 agents struggled
+    // with, decided, and solved — not just what the current session did.
+    const recentChain = this.daemon.memory?.getRecentHandoffMarkdown(agent.role, 3, 3000) || '';
+
     return [
       `# Agent Handoff Brief`,
       ``,
       `You are continuing the work of **${agent.name}** (role: ${agent.role}).`,
       `This is a context rotation — the previous session is being replaced to keep context fresh.`,
       ``,
+      recentChain ? `## Rotation History (recent)\n\n${recentChain}\n` : '',
       `## Your Identity`,
       `- Role: ${agent.role}`,
       `- Scope: ${agent.scope?.join(', ') || 'unrestricted'}`,

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

@@ -1,14 +1,25 @@
 // GROOVE — File Lock Manager
 // FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Two lock namespaces:
+//   1. File-scope locks (register/release/check) — per-agent glob patterns
+//      registered at spawn time to enforce scope ownership
+//   2. Operation locks (declareOperation/completeOperation) — short-lived
+//      resource claims for coordinated actions (npm install, server restarts,
+//      shared config writes). Auto-expire to prevent deadlock if an agent
+//      crashes mid-operation.
 
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { resolve } from 'path';
 import { minimatch } from 'minimatch';
 
+const DEFAULT_OPERATION_TTL_MS = 10 * 60 * 1000; // 10 minutes
+
 export class LockManager {
   constructor(grooveDir) {
     this.path = resolve(grooveDir, 'locks.json');
     this.locks = new Map(); // agentId -> glob patterns[]
+    this.operations = new Map(); // agentId -> { name, resources, acquiredAt, expiresAt }
     this.load();
   }
 
@@ -37,6 +48,7 @@ export class LockManager {
 
   release(agentId) {
     this.locks.delete(agentId);
+    this.operations.delete(agentId);
     this.save();
   }
 
@@ -55,4 +67,52 @@ export class LockManager {
   getAll() {
     return Object.fromEntries(this.locks);
   }
+
+  // --- Operation locks (coordination protocol) ---
+
+  _expireOperations() {
+    const now = Date.now();
+    for (const [id, op] of this.operations) {
+      if (op.expiresAt <= now) this.operations.delete(id);
+    }
+  }
+
+  declareOperation(agentId, operation, resources, ttlMs = DEFAULT_OPERATION_TTL_MS) {
+    if (!agentId || !operation || !Array.isArray(resources) || resources.length === 0) {
+      return { conflict: false, error: 'agentId, operation, and resources[] required' };
+    }
+    this._expireOperations();
+
+    for (const [holderId, op] of this.operations) {
+      if (holderId === agentId) continue;
+      const overlap = op.resources.find((r) => resources.includes(r));
+      if (overlap) {
+        return {
+          conflict: true,
+          owner: holderId,
+          operation: op.name,
+          resource: overlap,
+          expiresAt: op.expiresAt,
+        };
+      }
+    }
+
+    const now = Date.now();
+    this.operations.set(agentId, {
+      name: operation,
+      resources,
+      acquiredAt: now,
+      expiresAt: now + ttlMs,
+    });
+    return { conflict: false };
+  }
+
+  completeOperation(agentId) {
+    return this.operations.delete(agentId);
+  }
+
+  getOperations() {
+    this._expireOperations();
+    return Object.fromEntries(this.operations);
+  }
 }

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

@@ -75,7 +75,7 @@ export class McpManager {
 
     proc.on('exit', (code, signal) => {
       console.log(`[Groove:MCP:${integrationId}] Process exited: code=${code} signal=${signal}`);
-      if (code !== 0 && code !== null) {
+      if ((code !== 0 && code !== null) || (code === null && signal)) {
         this._handleCrash(integrationId);
       }
     });
@@ -102,6 +102,7 @@ export class McpManager {
       await this.startServer(integrationId);
       server = this.servers.get(integrationId);
     }
+    if (!server) throw new Error(`Failed to start MCP server for ${integrationId}`);
 
     server.lastCall = Date.now();
     this._resetIdleTimer(server);