agileflow 2.99.8 → 3.0.1

package/lib/dashboard-server.js

@@ -21,32 +21,35 @@
 
 'use strict';
 
-const http = require('http');
-const crypto = require('crypto');
 const { EventEmitter } = require('events');
-const {
-  OutboundMessageType,
-  InboundMessageType,
-  createSessionState,
-  createError,
-  createNotification,
-  createGitDiff,
-  createTerminalOutput,
-  createTerminalExit,
-  createAutomationList,
-  createAutomationStatus,
-  createAutomationResult,
-  createInboxList,
-  createInboxItem,
-  createStatusUpdate,
-  createSessionList,
-  parseInboundMessage,
-  serializeMessage,
-} = require('./dashboard-protocol');
-const { getProjectRoot, isAgileflowProject, getAgentsDir } = require('./paths');
-const { validatePath } = require('./validate-paths');
-const { execFileSync, spawn } = require('child_process');
-const os = require('os');
+
+// Lazy-loaded dependencies - deferred until first use
+let _http, _crypto, _protocol, _paths, _validatePaths, _childProcess;
+
+function getHttp() {
+  if (!_http) _http = require('http');
+  return _http;
+}
+function getCrypto() {
+  if (!_crypto) _crypto = require('crypto');
+  return _crypto;
+}
+function getProtocol() {
+  if (!_protocol) _protocol = require('./dashboard-protocol');
+  return _protocol;
+}
+function getPaths() {
+  if (!_paths) _paths = require('./paths');
+  return _paths;
+}
+function getValidatePaths() {
+  if (!_validatePaths) _validatePaths = require('./validate-paths');
+  return _validatePaths;
+}
+function getChildProcess() {
+  if (!_childProcess) _childProcess = require('child_process');
+  return _childProcess;
+}
 
 // Lazy-load automation modules to avoid circular dependencies
 let AutomationRegistry = null;
@@ -142,7 +145,7 @@ class DashboardSession {
   send(message) {
     if (this.ws && this.ws.writable) {
       try {
-        const frame = encodeWebSocketFrame(serializeMessage(message));
+        const frame = encodeWebSocketFrame(getProtocol().serializeMessage(message));
         this.ws.write(frame);
         this.lastActivity = new Date();
       } catch (error) {
@@ -180,7 +183,7 @@ class DashboardSession {
   setState(state) {
     this.state = state;
     this.send(
-      createSessionState(this.id, state, {
+      getProtocol().createSessionState(this.id, state, {
         messageCount: this.messages.length,
         lastActivity: this.lastActivity.toISOString(),
       })
@@ -249,13 +252,13 @@ class TerminalInstance {
 
       this.pty.onData(data => {
         if (!this.closed) {
-          this.session.send(createTerminalOutput(this.id, data));
+          this.session.send(getProtocol().createTerminalOutput(this.id, data));
         }
       });
 
       this.pty.onExit(({ exitCode }) => {
         this.closed = true;
-        this.session.send(createTerminalExit(this.id, exitCode));
+        this.session.send(getProtocol().createTerminalExit(this.id, exitCode));
       });
 
       return true;
@@ -275,7 +278,7 @@ class TerminalInstance {
       const filteredEnv = this._getFilteredEnv();
 
       // Use bash with interactive flag for better compatibility
-      this.pty = spawn(this.shell, ['-i'], {
+      this.pty = getChildProcess().spawn(this.shell, ['-i'], {
         cwd: this.cwd,
         env: {
           ...filteredEnv,
@@ -291,25 +294,27 @@ class TerminalInstance {
 
       this.pty.stdout.on('data', data => {
         if (!this.closed) {
-          this.session.send(createTerminalOutput(this.id, data.toString()));
+          this.session.send(getProtocol().createTerminalOutput(this.id, data.toString()));
         }
       });
 
       this.pty.stderr.on('data', data => {
         if (!this.closed) {
-          this.session.send(createTerminalOutput(this.id, data.toString()));
+          this.session.send(getProtocol().createTerminalOutput(this.id, data.toString()));
         }
       });
 
       this.pty.on('close', exitCode => {
         this.closed = true;
-        this.session.send(createTerminalExit(this.id, exitCode));
+        this.session.send(getProtocol().createTerminalExit(this.id, exitCode));
       });
 
       this.pty.on('error', error => {
         console.error('[Terminal] Shell error:', error.message);
         if (!this.closed) {
-          this.session.send(createTerminalOutput(this.id, `\r\nError: ${error.message}\r\n`));
+          this.session.send(
+            getProtocol().createTerminalOutput(this.id, `\r\nError: ${error.message}\r\n`)
+          );
         }
       });
 
@@ -318,7 +323,7 @@ class TerminalInstance {
         if (!this.closed) {
           const welcomeMsg = `\x1b[32mAgileFlow Terminal\x1b[0m (basic mode - node-pty not available)\r\n`;
           const cwdMsg = `Working directory: ${this.cwd}\r\n\r\n`;
-          this.session.send(createTerminalOutput(this.id, welcomeMsg + cwdMsg));
+          this.session.send(getProtocol().createTerminalOutput(this.id, welcomeMsg + cwdMsg));
         }
       }, 100);
 
@@ -355,7 +360,7 @@ class TerminalInstance {
         }
 
         // Echo to terminal
-        this.session.send(createTerminalOutput(this.id, echoData));
+        this.session.send(getProtocol().createTerminalOutput(this.id, echoData));
 
         // Send to shell stdin
         this.pty.stdin.write(data);
@@ -406,7 +411,7 @@ class TerminalManager {
    * @returns {string} - Terminal ID
    */
   createTerminal(session, options = {}) {
-    const terminalId = options.id || crypto.randomBytes(8).toString('hex');
+    const terminalId = options.id || getCrypto().randomBytes(8).toString('hex');
     const terminal = new TerminalInstance(terminalId, session, {
       cwd: options.cwd || session.projectRoot,
       cols: options.cols,
@@ -507,13 +512,13 @@ class DashboardServer extends EventEmitter {
 
     this.port = options.port || DEFAULT_PORT;
     this.host = options.host || DEFAULT_HOST;
-    this.projectRoot = options.projectRoot || getProjectRoot();
+    this.projectRoot = options.projectRoot || getPaths().getProjectRoot();
 
     // Auth is on by default - auto-generate key if not provided
     // Set requireAuth: false explicitly to disable
     this.requireAuth = options.requireAuth !== false;
     this.apiKey =
-      options.apiKey || (this.requireAuth ? crypto.randomBytes(32).toString('hex') : null);
+      options.apiKey || (this.requireAuth ? getCrypto().randomBytes(32).toString('hex') : null);
 
     // Session management
     this.sessions = new Map();
@@ -536,12 +541,15 @@ class DashboardServer extends EventEmitter {
     this.httpServer = null;
 
     // Validate project
-    if (!isAgileflowProject(this.projectRoot)) {
+    if (!getPaths().isAgileflowProject(this.projectRoot)) {
       throw new Error(`Not an AgileFlow project: ${this.projectRoot}`);
     }
 
     // Initialize automation registry lazily
     this._initAutomations();
+
+    // Listen for team metrics saves to broadcast to clients
+    this._initTeamMetricsListener();
   }
 
   /**
@@ -555,12 +563,12 @@ class DashboardServer extends EventEmitter {
       // Listen to runner events
       this._automationRunner.on('started', ({ automationId }) => {
         this._runningAutomations.set(automationId, { startTime: Date.now() });
-        this.broadcast(createAutomationStatus(automationId, 'running'));
+        this.broadcast(getProtocol().createAutomationStatus(automationId, 'running'));
       });
 
       this._automationRunner.on('completed', ({ automationId, result }) => {
         this._runningAutomations.delete(automationId);
-        this.broadcast(createAutomationStatus(automationId, 'completed', result));
+        this.broadcast(getProtocol().createAutomationStatus(automationId, 'completed', result));
 
         // Add result to inbox if it has output or changes
         if (result.output || result.changes) {
@@ -570,7 +578,9 @@ class DashboardServer extends EventEmitter {
 
       this._automationRunner.on('failed', ({ automationId, result }) => {
         this._runningAutomations.delete(automationId);
-        this.broadcast(createAutomationStatus(automationId, 'error', { error: result.error }));
+        this.broadcast(
+          getProtocol().createAutomationStatus(automationId, 'error', { error: result.error })
+        );
 
         // Add failure to inbox
         this._addToInbox(automationId, result);
@@ -607,7 +617,7 @@ class DashboardServer extends EventEmitter {
     };
 
     this._inbox.set(itemId, item);
-    this.broadcast(createInboxItem(item));
+    this.broadcast(getProtocol().createInboxItem(item));
   }
 
   /**
@@ -623,7 +633,7 @@ class DashboardServer extends EventEmitter {
         'Cache-Control': 'no-store',
       };
 
-      this.httpServer = http.createServer((req, res) => {
+      this.httpServer = getHttp().createServer((req, res) => {
         // Simple health check endpoint
         if (req.url === '/health') {
           res.writeHead(200, securityHeaders);
@@ -713,7 +723,7 @@ class DashboardServer extends EventEmitter {
       const providedBuffer = Buffer.from(providedKey, 'utf8');
       if (
         keyBuffer.length !== providedBuffer.length ||
-        !crypto.timingSafeEqual(keyBuffer, providedBuffer)
+        !getCrypto().timingSafeEqual(keyBuffer, providedBuffer)
       ) {
         socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
         socket.destroy();
@@ -744,7 +754,7 @@ class DashboardServer extends EventEmitter {
 
     // Complete WebSocket handshake
     const key = req.headers['sec-websocket-key'];
-    const acceptKey = crypto
+    const acceptKey = getCrypto()
       .createHash('sha1')
       .update(key + WS_GUID)
       .digest('base64');
@@ -778,7 +788,7 @@ class DashboardServer extends EventEmitter {
     }
 
     // Generate new session ID
-    return crypto.randomBytes(16).toString('hex');
+    return getCrypto().randomBytes(16).toString('hex');
   }
 
   /**
@@ -801,7 +811,7 @@ class DashboardServer extends EventEmitter {
 
     // Send initial state
     session.send(
-      createSessionState(sessionId, 'connected', {
+      getProtocol().createSessionState(sessionId, 'connected', {
         resumed: isResume,
         messageCount: session.messages.length,
         project: require('path').basename(this.projectRoot),
@@ -814,6 +824,9 @@ class DashboardServer extends EventEmitter {
     // Send project status (stories/epics)
     this.sendStatusUpdate(session);
 
+    // Send team metrics
+    this.sendTeamMetrics(session);
+
     // Send session list with sync info
     this.sendSessionList(session);
 
@@ -874,83 +887,85 @@ class DashboardServer extends EventEmitter {
   handleMessage(session, data) {
     // Rate limit incoming messages
     if (!session.checkRateLimit()) {
-      session.send(createError('RATE_LIMITED', 'Too many messages, please slow down'));
+      session.send(
+        getProtocol().createError('RATE_LIMITED', 'Too many messages, please slow down')
+      );
       return;
     }
 
-    const message = parseInboundMessage(data);
+    const message = getProtocol().parseInboundMessage(data);
     if (!message) {
-      session.send(createError('INVALID_MESSAGE', 'Failed to parse message'));
+      session.send(getProtocol().createError('INVALID_MESSAGE', 'Failed to parse message'));
       return;
     }
 
     console.log(`[Session ${session.id}] Received: ${message.type}`);
 
     switch (message.type) {
-      case InboundMessageType.MESSAGE:
+      case getProtocol().InboundMessageType.MESSAGE:
         this.handleUserMessage(session, message);
         break;
 
-      case InboundMessageType.CANCEL:
+      case getProtocol().InboundMessageType.CANCEL:
         this.handleCancel(session);
         break;
 
-      case InboundMessageType.REFRESH:
+      case getProtocol().InboundMessageType.REFRESH:
         this.handleRefresh(session, message);
         break;
 
-      case InboundMessageType.GIT_STAGE:
-      case InboundMessageType.GIT_UNSTAGE:
-      case InboundMessageType.GIT_REVERT:
-      case InboundMessageType.GIT_COMMIT:
+      case getProtocol().InboundMessageType.GIT_STAGE:
+      case getProtocol().InboundMessageType.GIT_UNSTAGE:
+      case getProtocol().InboundMessageType.GIT_REVERT:
+      case getProtocol().InboundMessageType.GIT_COMMIT:
         this.handleGitAction(session, message);
         break;
 
-      case InboundMessageType.GIT_DIFF_REQUEST:
+      case getProtocol().InboundMessageType.GIT_DIFF_REQUEST:
         this.handleDiffRequest(session, message);
         break;
 
-      case InboundMessageType.SESSION_CLOSE:
+      case getProtocol().InboundMessageType.SESSION_CLOSE:
         this.closeSession(session.id);
         break;
 
-      case InboundMessageType.TERMINAL_SPAWN:
+      case getProtocol().InboundMessageType.TERMINAL_SPAWN:
         this.handleTerminalSpawn(session, message);
         break;
 
-      case InboundMessageType.TERMINAL_INPUT:
+      case getProtocol().InboundMessageType.TERMINAL_INPUT:
         this.handleTerminalInput(session, message);
         break;
 
-      case InboundMessageType.TERMINAL_RESIZE:
+      case getProtocol().InboundMessageType.TERMINAL_RESIZE:
         this.handleTerminalResize(session, message);
         break;
 
-      case InboundMessageType.TERMINAL_CLOSE:
+      case getProtocol().InboundMessageType.TERMINAL_CLOSE:
         this.handleTerminalClose(session, message);
         break;
 
-      case InboundMessageType.AUTOMATION_LIST_REQUEST:
+      case getProtocol().InboundMessageType.AUTOMATION_LIST_REQUEST:
         this.sendAutomationList(session);
         break;
 
-      case InboundMessageType.AUTOMATION_RUN:
+      case getProtocol().InboundMessageType.AUTOMATION_RUN:
         this.handleAutomationRun(session, message);
         break;
 
-      case InboundMessageType.AUTOMATION_STOP:
+      case getProtocol().InboundMessageType.AUTOMATION_STOP:
         this.handleAutomationStop(session, message);
         break;
 
-      case InboundMessageType.INBOX_LIST_REQUEST:
+      case getProtocol().InboundMessageType.INBOX_LIST_REQUEST:
         this.sendInboxList(session);
         break;
 
-      case InboundMessageType.INBOX_ACTION:
+      case getProtocol().InboundMessageType.INBOX_ACTION:
         this.handleInboxAction(session, message);
         break;
 
-      case InboundMessageType.OPEN_FILE:
+      case getProtocol().InboundMessageType.OPEN_FILE:
         this.handleOpenFile(session, message);
         break;
 
@@ -966,7 +981,7 @@ class DashboardServer extends EventEmitter {
   handleUserMessage(session, message) {
     const content = message.content?.trim();
     if (!content) {
-      session.send(createError('EMPTY_MESSAGE', 'Message content is empty'));
+      session.send(getProtocol().createError('EMPTY_MESSAGE', 'Message content is empty'));
       return;
     }
 
@@ -985,7 +1000,7 @@ class DashboardServer extends EventEmitter {
    */
   handleCancel(session) {
     session.setState('idle');
-    session.send(createNotification('info', 'Cancelled', 'Operation cancelled'));
+    session.send(getProtocol().createNotification('info', 'Cancelled', 'Operation cancelled'));
     this.emit('user:cancel', session);
   }
 
@@ -1015,9 +1030,13 @@ class DashboardServer extends EventEmitter {
       case 'inbox':
         this.sendInboxList(session);
         break;
+      case 'team_metrics':
+        this.sendTeamMetrics(session);
+        break;
       default:
         this.sendGitStatus(session);
         this.sendStatusUpdate(session);
+        this.sendTeamMetrics(session);
         this.sendSessionList(session);
         this.sendAutomationList(session);
         this.sendInboxList(session);
@@ -1035,12 +1054,12 @@ class DashboardServer extends EventEmitter {
     if (files && files.length > 0) {
       for (const f of files) {
         if (typeof f !== 'string' || f.includes('\0')) {
-          session.send(createError('GIT_ERROR', 'Invalid file path'));
+          session.send(getProtocol().createError('GIT_ERROR', 'Invalid file path'));
           return;
         }
         const resolved = require('path').resolve(this.projectRoot, f);
         if (!resolved.startsWith(this.projectRoot)) {
-          session.send(createError('GIT_ERROR', 'File path outside project'));
+          session.send(getProtocol().createError('GIT_ERROR', 'File path outside project'));
           return;
         }
       }
@@ -1053,7 +1072,7 @@ class DashboardServer extends EventEmitter {
         commitMessage.length > 10000 ||
         commitMessage.includes('\0')
       ) {
-        session.send(createError('GIT_ERROR', 'Invalid commit message'));
+        session.send(getProtocol().createError('GIT_ERROR', 'Invalid commit message'));
         return;
       }
     }
@@ -1062,40 +1081,50 @@ class DashboardServer extends EventEmitter {
 
     try {
       switch (type) {
-        case InboundMessageType.GIT_STAGE:
+        case getProtocol().InboundMessageType.GIT_STAGE:
           if (fileArgs) {
-            execFileSync('git', ['add', '--', ...fileArgs], { cwd: this.projectRoot });
+            getChildProcess().execFileSync('git', ['add', '--', ...fileArgs], {
+              cwd: this.projectRoot,
+            });
           } else {
-            execFileSync('git', ['add', '-A'], { cwd: this.projectRoot });
+            getChildProcess().execFileSync('git', ['add', '-A'], { cwd: this.projectRoot });
           }
           break;
-        case InboundMessageType.GIT_UNSTAGE:
+        case getProtocol().InboundMessageType.GIT_UNSTAGE:
           if (fileArgs) {
-            execFileSync('git', ['restore', '--staged', '--', ...fileArgs], {
+            getChildProcess().execFileSync('git', ['restore', '--staged', '--', ...fileArgs], {
               cwd: this.projectRoot,
             });
           } else {
-            execFileSync('git', ['restore', '--staged', '.'], { cwd: this.projectRoot });
+            getChildProcess().execFileSync('git', ['restore', '--staged', '.'], {
+              cwd: this.projectRoot,
+            });
           }
           break;
-        case InboundMessageType.GIT_REVERT:
+        case getProtocol().InboundMessageType.GIT_REVERT:
           if (fileArgs) {
-            execFileSync('git', ['checkout', '--', ...fileArgs], { cwd: this.projectRoot });
+            getChildProcess().execFileSync('git', ['checkout', '--', ...fileArgs], {
+              cwd: this.projectRoot,
+            });
           }
           break;
-        case InboundMessageType.GIT_COMMIT:
+        case getProtocol().InboundMessageType.GIT_COMMIT:
           if (commitMessage) {
-            execFileSync('git', ['commit', '-m', commitMessage], { cwd: this.projectRoot });
+            getChildProcess().execFileSync('git', ['commit', '-m', commitMessage], {
+              cwd: this.projectRoot,
+            });
           }
           break;
       }
 
       // Send updated git status
       this.sendGitStatus(session);
-      session.send(createNotification('success', 'Git', `${type.replace('git_', '')} completed`));
+      session.send(
+        getProtocol().createNotification('success', 'Git', `${type.replace('git_', '')} completed`)
+      );
     } catch (error) {
       console.error('[Git Error]', error.message);
-      session.send(createError('GIT_ERROR', 'Git operation failed'));
+      session.send(getProtocol().createError('GIT_ERROR', 'Git operation failed'));
     }
   }
 
@@ -1106,7 +1135,7 @@ class DashboardServer extends EventEmitter {
     try {
       const status = this.getGitStatus();
       session.send({
-        type: OutboundMessageType.GIT_STATUS,
+        type: getProtocol().OutboundMessageType.GIT_STATUS,
         ...status,
         timestamp: new Date().toISOString(),
       });
@@ -1120,13 +1149,15 @@ class DashboardServer extends EventEmitter {
    */
   getGitStatus() {
     try {
-      const branch = execFileSync('git', ['branch', '--show-current'], {
-        cwd: this.projectRoot,
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-      }).trim();
+      const branch = getChildProcess()
+        .execFileSync('git', ['branch', '--show-current'], {
+          cwd: this.projectRoot,
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        })
+        .trim();
 
-      const statusOutput = execFileSync('git', ['status', '--porcelain'], {
+      const statusOutput = getChildProcess().execFileSync('git', ['status', '--porcelain'], {
         cwd: this.projectRoot,
         encoding: 'utf8',
         stdio: ['pipe', 'pipe', 'pipe'],
@@ -1185,7 +1216,7 @@ class DashboardServer extends EventEmitter {
     const { path: filePath, staged } = message;
 
     if (!filePath) {
-      session.send(createError('INVALID_REQUEST', 'File path is required'));
+      session.send(getProtocol().createError('INVALID_REQUEST', 'File path is required'));
       return;
     }
 
@@ -1194,7 +1225,7 @@ class DashboardServer extends EventEmitter {
       const stats = this.parseDiffStats(diff);
 
       session.send(
-        createGitDiff(filePath, diff, {
+        getProtocol().createGitDiff(filePath, diff, {
           additions: stats.additions,
           deletions: stats.deletions,
           staged: !!staged,
@@ -1202,7 +1233,7 @@ class DashboardServer extends EventEmitter {
       );
     } catch (error) {
       console.error('[Diff Error]', error.message);
-      session.send(createError('DIFF_ERROR', 'Failed to get diff'));
+      session.send(getProtocol().createError('DIFF_ERROR', 'Failed to get diff'));
     }
   }
 
@@ -1214,7 +1245,9 @@ class DashboardServer extends EventEmitter {
    */
   getFileDiff(filePath, staged = false) {
     // Validate filePath stays within project root
-    const pathResult = validatePath(filePath, this.projectRoot, { allowSymlinks: true });
+    const pathResult = getValidatePaths().validatePath(filePath, this.projectRoot, {
+      allowSymlinks: true,
+    });
     if (!pathResult.ok) {
       return '';
     }
@@ -1222,17 +1255,19 @@ class DashboardServer extends EventEmitter {
     try {
       const diffArgs = staged ? ['diff', '--cached', '--', filePath] : ['diff', '--', filePath];
 
-      const diff = execFileSync('git', diffArgs, {
+      const diff = getChildProcess().execFileSync('git', diffArgs, {
         cwd: this.projectRoot,
         encoding: 'utf8',
       });
 
       // If no diff, file might be untracked - show entire file content as addition
       if (!diff && !staged) {
-        const statusOutput = execFileSync('git', ['status', '--porcelain', '--', filePath], {
-          cwd: this.projectRoot,
-          encoding: 'utf8',
-        }).trim();
+        const statusOutput = getChildProcess()
+          .execFileSync('git', ['status', '--porcelain', '--', filePath], {
+            cwd: this.projectRoot,
+            encoding: 'utf8',
+          })
+          .trim();
 
         // Check if file is untracked
         if (statusOutput.startsWith('??')) {
@@ -1318,12 +1353,68 @@ class DashboardServer extends EventEmitter {
         })),
       };
 
-      session.send(createStatusUpdate(summary));
+      session.send(getProtocol().createStatusUpdate(summary));
     } catch (error) {
       console.error('[Status Update Error]', error.message);
     }
   }
 
+  /**
+   * Initialize listener for team metrics events
+   */
+  _initTeamMetricsListener() {
+    try {
+      const { teamMetricsEmitter } = require('../scripts/lib/team-events');
+      teamMetricsEmitter.on('metrics_saved', () => {
+        this.broadcastTeamMetrics();
+      });
+    } catch (e) {
+      // team-events not available - non-critical
+    }
+  }
+
+  /**
+   * Send team metrics to a single session
+   */
+  sendTeamMetrics(session) {
+    const path = require('path');
+    const fs = require('fs');
+    const sessionStatePath = path.join(this.projectRoot, 'docs', '09-agents', 'session-state.json');
+    if (!fs.existsSync(sessionStatePath)) return;
+
+    try {
+      const state = JSON.parse(fs.readFileSync(sessionStatePath, 'utf8'));
+      const traces = (state.team_metrics && state.team_metrics.traces) || {};
+
+      for (const [traceId, metrics] of Object.entries(traces)) {
+        session.send(getProtocol().createTeamMetrics(traceId, metrics));
+      }
+    } catch (error) {
+      // Non-critical
+    }
+  }
+
+  /**
+   * Broadcast team metrics to all connected clients
+   */
+  broadcastTeamMetrics() {
+    const path = require('path');
+    const fs = require('fs');
+    const sessionStatePath = path.join(this.projectRoot, 'docs', '09-agents', 'session-state.json');
+    if (!fs.existsSync(sessionStatePath)) return;
+
+    try {
+      const state = JSON.parse(fs.readFileSync(sessionStatePath, 'utf8'));
+      const traces = (state.team_metrics && state.team_metrics.traces) || {};
+
+      for (const [traceId, metrics] of Object.entries(traces)) {
+        this.broadcast(getProtocol().createTeamMetrics(traceId, metrics));
+      }
+    } catch (error) {
+      // Non-critical
+    }
+  }
+
   /**
    * Send session list with sync status to dashboard
    */
@@ -1347,23 +1438,23 @@ class DashboardServer extends EventEmitter {
       // Get branch and sync status via git
       try {
         const cwd = s.metadata.worktreePath || this.projectRoot;
-        entry.branch = execFileSync('git', ['branch', '--show-current'], {
-          cwd,
-          encoding: 'utf8',
-          stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
+        entry.branch = getChildProcess()
+          .execFileSync('git', ['branch', '--show-current'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+          })
+          .trim();
 
         // Get ahead/behind counts relative to upstream
         try {
-          const counts = execFileSync(
-            'git',
-            ['rev-list', '--left-right', '--count', 'HEAD...@{u}'],
-            {
+          const counts = getChildProcess()
+            .execFileSync('git', ['rev-list', '--left-right', '--count', 'HEAD...@{u}'], {
               cwd,
               encoding: 'utf8',
               stdio: ['pipe', 'pipe', 'pipe'],
-            }
-          ).trim();
+            })
+            .trim();
           const [ahead, behind] = counts.split(/\s+/).map(Number);
           entry.ahead = ahead || 0;
           entry.behind = behind || 0;
@@ -1388,7 +1479,7 @@ class DashboardServer extends EventEmitter {
       sessions.push(entry);
     }
 
-    session.send(createSessionList(sessions));
+    session.send(getProtocol().createSessionList(sessions));
   }
 
   /**
@@ -1398,14 +1489,16 @@ class DashboardServer extends EventEmitter {
     const { path: filePath, line } = message;
 
     if (!filePath || typeof filePath !== 'string') {
-      session.send(createError('INVALID_REQUEST', 'File path is required'));
+      session.send(getProtocol().createError('INVALID_REQUEST', 'File path is required'));
       return;
     }
 
     // Validate the path stays within project root
-    const pathResult = validatePath(filePath, this.projectRoot, { allowSymlinks: true });
+    const pathResult = getValidatePaths().validatePath(filePath, this.projectRoot, {
+      allowSymlinks: true,
+    });
     if (!pathResult.ok) {
-      session.send(createError('OPEN_FILE_ERROR', 'File path outside project'));
+      session.send(getProtocol().createError('OPEN_FILE_ERROR', 'File path outside project'));
       return;
     }
 
@@ -1423,28 +1516,36 @@ class DashboardServer extends EventEmitter {
         case 'cursor':
         case 'windsurf': {
           const gotoArg = lineNum ? `${fullPath}:${lineNum}` : fullPath;
-          spawn(editor, ['--goto', gotoArg], { detached: true, stdio: 'ignore' }).unref();
+          getChildProcess()
+            .spawn(editor, ['--goto', gotoArg], { detached: true, stdio: 'ignore' })
+            .unref();
           break;
         }
         case 'subl':
         case 'sublime_text': {
           const sublArg = lineNum ? `${fullPath}:${lineNum}` : fullPath;
-          spawn(editor, [sublArg], { detached: true, stdio: 'ignore' }).unref();
+          getChildProcess().spawn(editor, [sublArg], { detached: true, stdio: 'ignore' }).unref();
           break;
         }
         default: {
           // Generic: just open the file
-          spawn(editor, [fullPath], { detached: true, stdio: 'ignore' }).unref();
+          getChildProcess().spawn(editor, [fullPath], { detached: true, stdio: 'ignore' }).unref();
           break;
         }
       }
 
       session.send(
-        createNotification('info', 'Editor', `Opened ${require('path').basename(fullPath)}`)
+        getProtocol().createNotification(
+          'info',
+          'Editor',
+          `Opened ${require('path').basename(fullPath)}`
+        )
       );
     } catch (error) {
       console.error('[Open File Error]', error.message);
-      session.send(createError('OPEN_FILE_ERROR', `Failed to open file: ${error.message}`));
+      session.send(
+        getProtocol().createError('OPEN_FILE_ERROR', `Failed to open file: ${error.message}`)
+      );
     }
   }
 
@@ -1457,10 +1558,15 @@ class DashboardServer extends EventEmitter {
     // Validate cwd stays within project root
     let safeCwd = this.projectRoot;
     if (cwd) {
-      const cwdResult = validatePath(cwd, this.projectRoot, { allowSymlinks: true });
+      const cwdResult = getValidatePaths().validatePath(cwd, this.projectRoot, {
+        allowSymlinks: true,
+      });
       if (!cwdResult.ok) {
         session.send(
-          createError('TERMINAL_ERROR', 'Working directory must be within project root')
+          getProtocol().createError(
+            'TERMINAL_ERROR',
+            'Working directory must be within project root'
+          )
         );
         return;
       }
@@ -1480,7 +1586,7 @@ class DashboardServer extends EventEmitter {
         timestamp: new Date().toISOString(),
       });
     } else {
-      session.send(createError('TERMINAL_ERROR', 'Failed to spawn terminal'));
+      session.send(getProtocol().createError('TERMINAL_ERROR', 'Failed to spawn terminal'));
     }
   }
 
@@ -1521,7 +1627,7 @@ class DashboardServer extends EventEmitter {
     }
 
     this.terminalManager.closeTerminal(terminalId);
-    session.send(createNotification('info', 'Terminal', 'Terminal closed'));
+    session.send(getProtocol().createNotification('info', 'Terminal', 'Terminal closed'));
   }
 
   // ==========================================================================
@@ -1533,7 +1639,7 @@ class DashboardServer extends EventEmitter {
    */
   sendAutomationList(session) {
     if (!this._automationRegistry) {
-      session.send(createAutomationList([]));
+      session.send(getProtocol().createAutomationList([]));
       return;
     }
 
@@ -1555,10 +1661,10 @@ class DashboardServer extends EventEmitter {
         };
       });
 
-      session.send(createAutomationList(enriched));
+      session.send(getProtocol().createAutomationList(enriched));
     } catch (error) {
       console.error('[Automations] List error:', error.message);
-      session.send(createAutomationList([]));
+      session.send(getProtocol().createAutomationList([]));
     }
   }
 
@@ -1628,12 +1734,14 @@ class DashboardServer extends EventEmitter {
     const { id: automationId } = message;
 
     if (!automationId) {
-      session.send(createError('INVALID_REQUEST', 'Automation ID is required'));
+      session.send(getProtocol().createError('INVALID_REQUEST', 'Automation ID is required'));
       return;
     }
 
     if (!this._automationRunner) {
-      session.send(createError('AUTOMATION_ERROR', 'Automation runner not initialized'));
+      session.send(
+        getProtocol().createError('AUTOMATION_ERROR', 'Automation runner not initialized')
+      );
       return;
     }
 
@@ -1641,12 +1749,18 @@ class DashboardServer extends EventEmitter {
       // Check if already running
       if (this._runningAutomations.has(automationId)) {
         session.send(
-          createNotification('warning', 'Automation', `${automationId} is already running`)
+          getProtocol().createNotification(
+            'warning',
+            'Automation',
+            `${automationId} is already running`
+          )
         );
         return;
       }
 
-      session.send(createNotification('info', 'Automation', `Starting ${automationId}...`));
+      session.send(
+        getProtocol().createNotification('info', 'Automation', `Starting ${automationId}...`)
+      );
 
       // Run the automation (async)
       const result = await this._automationRunner.run(automationId);
@@ -1654,23 +1768,39 @@ class DashboardServer extends EventEmitter {
       // Send result notification
       if (result.success) {
         session.send(
-          createNotification('success', 'Automation', `${automationId} completed successfully`)
+          getProtocol().createNotification(
+            'success',
+            'Automation',
+            `${automationId} completed successfully`
+          )
         );
       } else {
         session.send(
-          createNotification('error', 'Automation', `${automationId} failed: ${result.error}`)
+          getProtocol().createNotification(
+            'error',
+            'Automation',
+            `${automationId} failed: ${result.error}`
+          )
         );
       }
 
       // Send final status
-      session.send(createAutomationStatus(automationId, result.success ? 'idle' : 'error', result));
+      session.send(
+        getProtocol().createAutomationStatus(
+          automationId,
+          result.success ? 'idle' : 'error',
+          result
+        )
+      );
 
       // Refresh the list
       this.sendAutomationList(session);
     } catch (error) {
       console.error('[Automation Error]', error.message);
-      session.send(createError('AUTOMATION_ERROR', 'Automation execution failed'));
-      session.send(createAutomationStatus(automationId, 'error', { error: 'Execution failed' }));
+      session.send(getProtocol().createError('AUTOMATION_ERROR', 'Automation execution failed'));
+      session.send(
+        getProtocol().createAutomationStatus(automationId, 'error', { error: 'Execution failed' })
+      );
     }
   }
 
@@ -1681,7 +1811,7 @@ class DashboardServer extends EventEmitter {
     const { id: automationId } = message;
 
     if (!automationId) {
-      session.send(createError('INVALID_REQUEST', 'Automation ID is required'));
+      session.send(getProtocol().createError('INVALID_REQUEST', 'Automation ID is required'));
       return;
     }
 
@@ -1691,8 +1821,8 @@ class DashboardServer extends EventEmitter {
     }
 
     this._runningAutomations.delete(automationId);
-    session.send(createAutomationStatus(automationId, 'idle'));
-    session.send(createNotification('info', 'Automation', `${automationId} stopped`));
+    session.send(getProtocol().createAutomationStatus(automationId, 'idle'));
+    session.send(getProtocol().createNotification('info', 'Automation', `${automationId} stopped`));
   }
 
   // ==========================================================================
@@ -1707,7 +1837,7 @@ class DashboardServer extends EventEmitter {
       (a, b) => new Date(b.timestamp) - new Date(a.timestamp)
     );
 
-    session.send(createInboxList(items));
+    session.send(getProtocol().createInboxList(items));
   }
 
   /**
@@ -1717,13 +1847,13 @@ class DashboardServer extends EventEmitter {
     const { id: itemId, action } = message;
 
     if (!itemId) {
-      session.send(createError('INVALID_REQUEST', 'Item ID is required'));
+      session.send(getProtocol().createError('INVALID_REQUEST', 'Item ID is required'));
       return;
     }
 
     const item = this._inbox.get(itemId);
     if (!item) {
-      session.send(createError('NOT_FOUND', `Inbox item ${itemId} not found`));
+      session.send(getProtocol().createError('NOT_FOUND', `Inbox item ${itemId} not found`));
       return;
     }
 
@@ -1731,14 +1861,16 @@ class DashboardServer extends EventEmitter {
       case 'accept':
         // Mark as accepted and remove
         item.status = 'accepted';
-        session.send(createNotification('success', 'Inbox', `Accepted: ${item.title}`));
+        session.send(
+          getProtocol().createNotification('success', 'Inbox', `Accepted: ${item.title}`)
+        );
         this._inbox.delete(itemId);
         break;
 
       case 'dismiss':
         // Mark as dismissed and remove
         item.status = 'dismissed';
-        session.send(createNotification('info', 'Inbox', `Dismissed: ${item.title}`));
+        session.send(getProtocol().createNotification('info', 'Inbox', `Dismissed: ${item.title}`));
         this._inbox.delete(itemId);
         break;
 
@@ -1748,7 +1880,7 @@ class DashboardServer extends EventEmitter {
         break;
 
       default:
-        session.send(createError('INVALID_ACTION', `Unknown action: ${action}`));
+        session.send(getProtocol().createError('INVALID_ACTION', `Unknown action: ${action}`));
         return;
     }