mstro-app 0.3.0 → 0.3.1

package/server/services/websocket/session-handlers.ts

@@ -10,8 +10,8 @@ import type { SessionRegistry } from './session-registry.js';
 import type { WebSocketMessage, WSContext } from './types.js';
 
 /** Convert tool history entries into OutputLine-compatible lines */
-function convertToolHistoryToLines(tools: any[], ts: number): any[] {
-  const lines: any[] = [];
+function convertToolHistoryToLines(tools: Array<{ toolName: string; toolInput?: Record<string, unknown>; result?: string; isError?: boolean }>, ts: number): Array<Record<string, unknown>> {
+  const lines: Array<Record<string, unknown>> = [];
   for (const tool of tools) {
     lines.push({ type: 'tool-call', text: '', toolName: tool.toolName, toolInput: tool.toolInput || {}, timestamp: ts });
     if (tool.result !== undefined) {
@@ -22,8 +22,8 @@ function convertToolHistoryToLines(tools: any[], ts: number): any[] {
 }
 
 /** Convert a single movement record into OutputLine-compatible entries */
-function convertMovementToLines(movement: { userPrompt: string; timestamp: string; thinkingOutput?: string; toolUseHistory?: any[]; assistantResponse?: string; errorOutput?: string; tokensUsed: number; durationMs?: number }): any[] {
-  const lines: any[] = [];
+function convertMovementToLines(movement: { userPrompt: string; timestamp: string; thinkingOutput?: string; toolUseHistory?: Array<{ toolName: string; toolInput?: Record<string, unknown>; result?: string; isError?: boolean }>; assistantResponse?: string; errorOutput?: string; tokensUsed: number; durationMs?: number }): Array<Record<string, unknown>> {
+  const lines: Array<Record<string, unknown>> = [];
   const ts = new Date(movement.timestamp).getTime();
 
   lines.push({ type: 'user', text: movement.userPrompt, timestamp: ts });
@@ -67,7 +67,7 @@ function getSession(ctx: HandlerContext, ws: WSContext, tabId: string): Improvis
   return ctx.sessions.get(sessionId) || null;
 }
 
-export function buildOutputHistory(session: ImprovisationSessionManager): any[] {
+export function buildOutputHistory(session: ImprovisationSessionManager): Array<Record<string, unknown>> {
   const history = session.getHistory();
   return history.movements.flatMap(convertMovementToLines);
 }
@@ -88,7 +88,7 @@ export function setupSessionListeners(ctx: HandlerContext, session: Improvisatio
     ctx.broadcastToAll({ type: 'tabStateChanged', data: { tabId, isExecuting: true, executionStartTimestamp: session.executionStartTimestamp } });
   });
 
-  session.on('onMovementComplete', (movement: any) => {
+  session.on('onMovementComplete', (movement: Record<string, unknown>) => {
     ctx.send(ws, { type: 'movementComplete', tabId, data: movement });
 
     const registry = ctx.getRegistry('');
@@ -99,7 +99,7 @@ export function setupSessionListeners(ctx: HandlerContext, session: Improvisatio
 
     if (ctx.usageReporter && movement.tokensUsed) {
       ctx.usageReporter({
-        tokensUsed: movement.tokensUsed,
+        tokensUsed: movement.tokensUsed as number,
         sessionId: session.getSessionInfo().sessionId,
         movementId: `${movement.sequenceNumber}`
       });
@@ -111,15 +111,15 @@ export function setupSessionListeners(ctx: HandlerContext, session: Improvisatio
     ctx.broadcastToAll({ type: 'tabStateChanged', data: { tabId, isExecuting: false } });
   });
 
-  session.on('onSessionUpdate', (history: any) => {
+  session.on('onSessionUpdate', (history: Record<string, unknown>) => {
     ctx.send(ws, { type: 'sessionUpdate', tabId, data: history });
   });
 
-  session.on('onPlanNeedsConfirmation', (plan: any) => {
+  session.on('onPlanNeedsConfirmation', (plan: Record<string, unknown>) => {
     ctx.send(ws, { type: 'approvalRequired', tabId, data: plan });
   });
 
-  session.on('onToolUse', (event: any) => {
+  session.on('onToolUse', (event: Record<string, unknown>) => {
     ctx.send(ws, { type: 'toolUse', tabId, data: { ...event, timestamp: Date.now() } });
   });
 
@@ -163,13 +163,13 @@ export function handleSessionMessage(ctx: HandlerContext, ws: WSContext, msg: We
     }
     case 'approve': {
       const session = requireSession(ctx, ws, tabId);
-      (session as any).respondToApproval?.(true);
+      session.respondToApproval(true);
       ctx.send(ws, { type: 'output', tabId, data: { text: '\n✅ Approved - proceeding with operation\n' } });
       break;
     }
     case 'reject': {
       const session = requireSession(ctx, ws, tabId);
-      (session as any).respondToApproval?.(false);
+      session.respondToApproval(false);
       ctx.send(ws, { type: 'output', tabId, data: { text: '\n🚫 Rejected - operation cancelled\n' } });
       break;
     }
@@ -309,8 +309,8 @@ export async function resumeHistoricalSession(
 
   try {
     session = ImprovisationSessionManager.resumeFromHistory(workingDir, historicalSessionId, { model: getModel() });
-  } catch (error: any) {
-    console.warn(`[WebSocketImproviseHandler] Could not resume session ${historicalSessionId}: ${error.message}. Creating new session.`);
+  } catch (error: unknown) {
+    console.warn(`[WebSocketImproviseHandler] Could not resume session ${historicalSessionId}: ${error instanceof Error ? error.message : String(error)}. Creating new session.`);
     session = new ImprovisationSessionManager({ workingDir, model: getModel() });
     isNewSession = true;
   }
@@ -381,7 +381,7 @@ function getSessionsCount(workingDir: string): number {
   return readdirSync(sessionsDir).filter((name: string) => name.endsWith('.json')).length;
 }
 
-function getSessionsList(workingDir: string, limit: number = 20, offset: number = 0): { sessions: any[]; total: number; hasMore: boolean } {
+function getSessionsList(workingDir: string, limit: number = 20, offset: number = 0): { sessions: Array<Record<string, unknown> | null>; total: number; hasMore: boolean } {
   const sessionsDir = join(workingDir, '.mstro', 'history');
 
   if (!existsSync(sessionsDir)) {
@@ -405,8 +405,8 @@ function getSessionsList(workingDir: string, limit: number = 20, offset: number
       const historyData = JSON.parse(readFileSync(historyPath, 'utf-8'));
       const firstPrompt = historyData.movements?.[0]?.userPrompt || '';
 
-      const movementPreviews = (historyData.movements || []).slice(0, 3).map((m: any) => ({
-        userPrompt: m.userPrompt?.slice(0, 100) || ''
+      const movementPreviews = (historyData.movements || []).slice(0, 3).map((m: Record<string, unknown>) => ({
+        userPrompt: (typeof m.userPrompt === 'string' ? m.userPrompt : '').slice(0, 100) || ''
       }));
 
       return {
@@ -426,7 +426,7 @@ function getSessionsList(workingDir: string, limit: number = 20, offset: number
   return { sessions, total, hasMore: offset + limit < total };
 }
 
-function getSessionById(workingDir: string, sessionId: string): any {
+function getSessionById(workingDir: string, sessionId: string): Record<string, unknown> | null {
   const sessionsDir = join(workingDir, '.mstro', 'history');
   if (!existsSync(sessionsDir)) return null;
 
@@ -508,32 +508,33 @@ function clearAllSessions(workingDir: string): { success: boolean; deletedCount:
   }
 }
 
-function movementMatchesQuery(movements: any[] | undefined, lowerQuery: string): boolean {
+function movementMatchesQuery(movements: Array<Record<string, unknown>> | undefined, lowerQuery: string): boolean {
   if (!movements) return false;
-  return movements.some((m: any) =>
-    m.userPrompt?.toLowerCase().includes(lowerQuery) ||
-    m.summary?.toLowerCase().includes(lowerQuery) ||
-    m.assistantResponse?.toLowerCase().includes(lowerQuery)
+  return movements.some((m: Record<string, unknown>) =>
+    (typeof m.userPrompt === 'string' && m.userPrompt.toLowerCase().includes(lowerQuery)) ||
+    (typeof m.summary === 'string' && m.summary.toLowerCase().includes(lowerQuery)) ||
+    (typeof m.assistantResponse === 'string' && m.assistantResponse.toLowerCase().includes(lowerQuery))
   );
 }
 
-function buildSessionSummary(historyData: any): any {
-  const firstPrompt = historyData.movements?.[0]?.userPrompt || '';
-  const movementPreviews = (historyData.movements || []).slice(0, 3).map((m: any) => ({
-    userPrompt: m.userPrompt?.slice(0, 100) || ''
+function buildSessionSummary(historyData: Record<string, unknown>): Record<string, unknown> {
+  const movements = historyData.movements as Array<Record<string, unknown>> | undefined;
+  const firstPrompt = (typeof movements?.[0]?.userPrompt === 'string' ? movements[0].userPrompt : '') || '';
+  const movementPreviews = (movements || []).slice(0, 3).map((m: Record<string, unknown>) => ({
+    userPrompt: (typeof m.userPrompt === 'string' ? m.userPrompt : '').slice(0, 100) || ''
   }));
   return {
     sessionId: historyData.sessionId,
     startedAt: historyData.startedAt,
     lastActivityAt: historyData.lastActivityAt,
     totalTokens: historyData.totalTokens,
-    movementCount: historyData.movements?.length || 0,
+    movementCount: movements?.length || 0,
     title: firstPrompt.slice(0, 80) + (firstPrompt.length > 80 ? '...' : ''),
     movements: movementPreviews
   };
 }
 
-function searchSessions(workingDir: string, query: string, limit: number = 20, offset: number = 0): { sessions: any[]; total: number; hasMore: boolean } {
+function searchSessions(workingDir: string, query: string, limit: number = 20, offset: number = 0): { sessions: Array<Record<string, unknown>>; total: number; hasMore: boolean } {
   const sessionsDir = join(workingDir, '.mstro', 'history');
   if (!existsSync(sessionsDir)) return { sessions: [], total: 0, hasMore: false };
 
@@ -548,7 +549,7 @@ function searchSessions(workingDir: string, query: string, limit: number = 20, o
         return timestampB - timestampA;
       });
 
-    const allMatches: any[] = [];
+    const allMatches: Array<Record<string, unknown>> = [];
     for (const filename of historyFiles) {
       try {
         const content = readFileSync(join(sessionsDir, filename), 'utf-8');

package/server/services/websocket/tab-handlers.ts

@@ -11,7 +11,7 @@ export function handleGetActiveTabs(ctx: HandlerContext, ws: WSContext, workingD
   const registry = ctx.getRegistry(workingDir);
   const allTabs = registry.getAllTabs();
 
-  const tabs: Record<string, any> = {};
+  const tabs: Record<string, unknown> = {};
   for (const [tabId, regTab] of Object.entries(allTabs)) {
     const session = ctx.sessions.get(regTab.sessionId);
     if (session) {

package/server/services/websocket/terminal-handlers.ts

@@ -83,12 +83,12 @@ function handleTerminalInit(
       shell,
       is_reconnect: isReconnect,
     });
-  } catch (error: any) {
+  } catch (error: unknown) {
     console.error(`[WebSocketImproviseHandler] Failed to create terminal:`, error);
     ctx.send(ws, {
       type: 'terminalError',
       terminalId,
-      data: { error: error.message || 'Failed to create terminal' }
+      data: { error: (error instanceof Error ? error.message : String(error)) || 'Failed to create terminal' }
     });
     removeTerminalSubscriber(ctx, terminalId, ws);
   }

package/server/services/websocket/types.ts

@@ -108,6 +108,7 @@ export interface WebSocketMessage {
     | 'updateSettings';
   tabId?: string;
   terminalId?: string;
+  // biome-ignore lint/suspicious/noExplicitAny: message envelope carries heterogeneous payloads
   data?: any;
   /** Injected by server relay for sandboxed shared users (control + view) */
   _permission?: 'control' | 'view';
@@ -211,6 +212,7 @@ export interface WebSocketResponse {
     | 'settingsUpdated';
   tabId?: string;
   terminalId?: string;
+  // biome-ignore lint/suspicious/noExplicitAny: message envelope carries heterogeneous payloads
   data?: any;
 }
 

package/server/utils/agent-manager.ts

@@ -289,14 +289,14 @@ export class AgentManager {
   /**
    * Extract agent names from a score object
    */
-  extractAgentNamesFromScore(score: any): string[] {
+  extractAgentNamesFromScore(score: { movements?: Array<{ musicians?: Array<{ type?: string; config?: { agent?: string }; role?: string }> }> }): string[] {
     if (!Array.isArray(score.movements)) return [];
 
-    const names = (score.movements as any[])
+    const names = score.movements
       .flatMap(m => Array.isArray(m.musicians) ? m.musicians : [])
-      .filter((m: any) => m.type === 'custom')
-      .map((m: any) => m.config?.agent || m.role)
-      .filter(Boolean);
+      .filter(m => m.type === 'custom')
+      .map(m => m.config?.agent || m.role)
+      .filter(Boolean) as string[];
 
     return [...new Set<string>(names)];
   }
@@ -304,7 +304,7 @@ export class AgentManager {
   /**
    * Ensure all agents required by a score are available
    */
-  async ensureScoreAgentsAvailable(score: any, workingDir: string): Promise<Map<string, AgentInfo>> {
+  async ensureScoreAgentsAvailable(score: { movements?: Array<{ musicians?: Array<{ type?: string; config?: { agent?: string }; role?: string }> }> }, workingDir: string): Promise<Map<string, AgentInfo>> {
     const agentNames = this.extractAgentNamesFromScore(score);
     const results = new Map<string, AgentInfo>();
 

package/server/utils/port-manager.ts

@@ -20,7 +20,7 @@ async function isPortAvailable(port: number): Promise<boolean> {
   return new Promise((resolve) => {
     const server = createServer()
 
-    server.once('error', (err: any) => {
+    server.once('error', (err: NodeJS.ErrnoException) => {
       if (err.code === 'EADDRINUSE') {
         resolve(false)
       } else {

package/server/cli/headless/output-utils.test.ts

@@ -1,225 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  detectErrorInStderr,
-  estimateTokensFromOutput,
-  extractCleanOutput,
-  extractModifiedFiles,
-} from './output-utils.js';
-
-// ========== extractCleanOutput ==========
-
-describe('extractCleanOutput', () => {
-  it('filters out JSON lines with "type" field', () => {
-    const input = [
-      '{"type": "system", "data": "init"}',
-      'Hello world',
-      '{"type": "assistant", "text": "hi"}',
-      'Some output',
-    ].join('\n');
-    expect(extractCleanOutput(input)).toBe('Hello world\nSome output');
-  });
-
-  it('strips ANSI color codes', () => {
-    const input = '\x1b[32mgreen text\x1b[0m and \x1b[1;31mred bold\x1b[0m';
-    expect(extractCleanOutput(input)).toBe('green text and red bold');
-  });
-
-  it('normalizes CRLF to LF', () => {
-    const input = 'line1\r\nline2\r\nline3';
-    expect(extractCleanOutput(input)).toBe('line1\nline2\nline3');
-  });
-
-  it('trims whitespace', () => {
-    const input = '  \n  Hello  \n  ';
-    expect(extractCleanOutput(input)).toBe('Hello');
-  });
-
-  it('filters empty lines', () => {
-    const input = 'line1\n\n\nline2';
-    expect(extractCleanOutput(input)).toBe('line1\nline2');
-  });
-
-  it('returns empty string for all-JSON input', () => {
-    const input = '{"type": "system"}\n{"type": "result"}';
-    expect(extractCleanOutput(input)).toBe('');
-  });
-
-  it('handles combined ANSI + JSON + CRLF', () => {
-    const input = '{"type": "system"}\r\n\x1b[33mwarning\x1b[0m\r\n{"type": "result"}';
-    expect(extractCleanOutput(input)).toBe('warning');
-  });
-});
-
-// ========== estimateTokensFromOutput ==========
-
-describe('estimateTokensFromOutput', () => {
-  it('estimates tokens as length / 4', () => {
-    expect(estimateTokensFromOutput('12345678')).toBe(2);
-    expect(estimateTokensFromOutput('1234')).toBe(1);
-  });
-
-  it('floors the result', () => {
-    expect(estimateTokensFromOutput('12345')).toBe(1); // 5/4 = 1.25 → 1
-    expect(estimateTokensFromOutput('123')).toBe(0);   // 3/4 = 0.75 → 0
-  });
-
-  it('returns 0 for empty string', () => {
-    expect(estimateTokensFromOutput('')).toBe(0);
-  });
-});
-
-// ========== extractModifiedFiles ==========
-
-describe('extractModifiedFiles', () => {
-  it('extracts files from "wrote" pattern', () => {
-    const output = 'wrote file "src/index.ts" successfully';
-    expect(extractModifiedFiles(output)).toContain('src/index.ts');
-  });
-
-  it('extracts files from "modified" pattern', () => {
-    const output = 'modified utils.js in place';
-    expect(extractModifiedFiles(output)).toContain('utils.js');
-  });
-
-  it('extracts files from "created" pattern', () => {
-    const output = "created file 'new-file.tsx'";
-    expect(extractModifiedFiles(output)).toContain('new-file.tsx');
-  });
-
-  it('extracts files from "edited" pattern', () => {
-    const output = 'edited config.json';
-    expect(extractModifiedFiles(output)).toContain('config.json');
-  });
-
-  it('deduplicates files', () => {
-    const output = 'wrote src/index.ts\nmodified src/index.ts';
-    const files = extractModifiedFiles(output);
-    expect(files.filter(f => f === 'src/index.ts')).toHaveLength(1);
-  });
-
-  it('returns empty array when no files found', () => {
-    expect(extractModifiedFiles('no files mentioned here')).toEqual([]);
-  });
-
-  it('extracts multiple different files', () => {
-    const output = 'wrote src/a.ts\ncreated src/b.ts\nedited src/c.ts';
-    const files = extractModifiedFiles(output);
-    expect(files).toContain('src/a.ts');
-    expect(files).toContain('src/b.ts');
-    expect(files).toContain('src/c.ts');
-  });
-});
-
-// ========== detectErrorInStderr ==========
-
-describe('detectErrorInStderr', () => {
-  it('detects auth errors', () => {
-    const result = detectErrorInStderr('Error: not logged in to Claude');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('AUTH_REQUIRED');
-  });
-
-  it('detects session expired', () => {
-    const result = detectErrorInStderr('Your session has expired, please re-authenticate');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('AUTH_REQUIRED');
-  });
-
-  it('detects account not found', () => {
-    const result = detectErrorInStderr('account not found for this user');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('ACCOUNT_NOT_FOUND');
-  });
-
-  it('detects API key errors', () => {
-    const result = detectErrorInStderr('invalid api key provided');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('API_KEY_INVALID');
-  });
-
-  it('detects quota exceeded', () => {
-    const result = detectErrorInStderr('quota exceeded for your subscription');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('QUOTA_EXCEEDED');
-  });
-
-  it('detects billing issues', () => {
-    const result = detectErrorInStderr('payment required to continue');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('QUOTA_EXCEEDED');
-  });
-
-  it('detects rate limiting', () => {
-    const result = detectErrorInStderr('rate limit exceeded, retry after 30s');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('RATE_LIMITED');
-  });
-
-  it('detects 429 status', () => {
-    const result = detectErrorInStderr('HTTP 429 too many requests');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('RATE_LIMITED');
-  });
-
-  it('detects network errors', () => {
-    const result = detectErrorInStderr('ECONNREFUSED 127.0.0.1:443');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('NETWORK_ERROR');
-  });
-
-  it('detects DNS failures', () => {
-    const result = detectErrorInStderr('ENOTFOUND api.anthropic.com');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('NETWORK_ERROR');
-  });
-
-  it('detects SSL errors', () => {
-    const result = detectErrorInStderr('CERT_HAS_EXPIRED for api.example.com');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('SSL_ERROR');
-  });
-
-  it('detects service unavailable', () => {
-    const result = detectErrorInStderr('service unavailable, try again later');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('SERVICE_UNAVAILABLE');
-  });
-
-  it('detects 503 status', () => {
-    const result = detectErrorInStderr('HTTP 503 from upstream');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('SERVICE_UNAVAILABLE');
-  });
-
-  it('detects internal errors', () => {
-    const result = detectErrorInStderr('internal server error occurred');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('INTERNAL_ERROR');
-  });
-
-  it('detects context too long', () => {
-    const result = detectErrorInStderr('context too long, exceeds 200k tokens');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('CONTEXT_TOO_LONG');
-  });
-
-  it('detects session not found', () => {
-    const result = detectErrorInStderr('session not found, please create a new one');
-    expect(result).not.toBeNull();
-    expect(result!.errorCode).toBe('SESSION_NOT_FOUND');
-  });
-
-  it('returns null for non-matching stderr', () => {
-    expect(detectErrorInStderr('Processing file...')).toBeNull();
-    expect(detectErrorInStderr('Warning: deprecated API usage')).toBeNull();
-    expect(detectErrorInStderr('')).toBeNull();
-  });
-
-  it('returns user-friendly messages', () => {
-    const result = detectErrorInStderr('not logged in');
-    expect(result).not.toBeNull();
-    expect(result!.message).toContain('authentication');
-    // Should not expose raw error
-    expect(result!.message).not.toContain('not logged in');
-  });
-});

package/server/cli/headless/stall-assessor.test.ts

@@ -1,165 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { StallContext } from './stall-assessor.js';
-
-// quickHeuristic, parseAssessmentResponse, and parseVerdictResponse are not exported.
-// We test them via assessStall (which calls quickHeuristic first) and by testing
-// the parsing functions indirectly. Since quickHeuristic is the critical logic
-// and assessStall calls it before Haiku, we can test the heuristic paths by
-// providing contexts that match known patterns.
-//
-// To avoid spawning Haiku (which requires `claude` CLI), we only test contexts
-// that trigger the heuristic fast-path (return non-null from quickHeuristic).
-
-import { assessStall } from './stall-assessor.js';
-
-function makeContext(overrides: Partial<StallContext> = {}): StallContext {
-  return {
-    originalPrompt: 'Fix the bug in auth.ts',
-    silenceMs: 120_000,
-    pendingToolCount: 0,
-    totalToolCalls: 5,
-    elapsedTotalMs: 300_000,
-    ...overrides,
-  };
-}
-
-describe('assessStall - quickHeuristic paths', () => {
-  it('extends when tokens are still flowing (tokenSilenceMs < 60s)', async () => {
-    const ctx = makeContext({ tokenSilenceMs: 30_000 });
-    const verdict = await assessStall(ctx, 'claude', false, false);
-    expect(verdict.action).toBe('extend');
-    expect(verdict.extensionMs).toBe(10 * 60_000);
-    expect(verdict.reason).toContain('Tokens still flowing');
-  });
-
-  it('extends when tokenSilenceMs is 0', async () => {
-    const ctx = makeContext({ tokenSilenceMs: 0 });
-    const verdict = await assessStall(ctx, 'claude', false, false);
-    expect(verdict.action).toBe('extend');
-    expect(verdict.reason).toContain('Tokens still flowing');
-  });
-
-  it('does not use token heuristic when tokenSilenceMs >= 60s', async () => {
-    const ctx = makeContext({
-      tokenSilenceMs: 60_000,
-      pendingToolCount: 3, // will trigger parallel tools heuristic
-    });
-    const verdict = await assessStall(ctx, 'claude', false, false);
-    // Should NOT hit the token heuristic, should hit the 3+ parallel tools one
-    expect(verdict.action).toBe('extend');
-    expect(verdict.reason).toContain('parallel tool calls');
-  });
-
-  it('defers to watchdog when active and tools are pending', async () => {
-    const ctx = makeContext({ pendingToolCount: 1, lastToolName: 'Bash' });
-    const verdict = await assessStall(ctx, 'claude', false, true);
-    expect(verdict.action).toBe('extend');
-    expect(verdict.extensionMs).toBe(15 * 60_000);
-    expect(verdict.reason).toContain('Watchdog active');
-  });
-
-  it('defers to watchdog and lists pending tool names', async () => {
-    const ctx = makeContext({
-      pendingToolCount: 2,
-      pendingToolNames: new Set(['WebFetch', 'Bash']),
-    });
-    const verdict = await assessStall(ctx, 'claude', false, true);
-    expect(verdict.action).toBe('extend');
-    expect(verdict.reason).toContain('WebFetch');
-    expect(verdict.reason).toContain('Bash');
-  });
-
-  it('extends for Task subagent via pendingToolNames', async () => {
-    const ctx = makeContext({
-      pendingToolCount: 1,
-      pendingToolNames: new Set(['Task']),
-    });
-    const verdict = await assessStall(ctx, 'claude', false, false);
-    expect(verdict.action).toBe('extend');
-    expect(verdict.reason).toContain('Task subagent');
-  });
-
-  it('extends for Task subagent via lastToolName fallback', async () => {
-    const ctx = makeContext({
-      pendingToolCount: 1,
-      lastToolName: 'Task',
-    });
-    const verdict = await assessStall(ctx, 'claude', false, false);
-    expect(verdict.action).toBe('extend');
-    expect(verdict.reason).toContain('Task subagent');
-  });
-
-  it('scales Task extension with pending count', async () => {
-    const ctx1 = makeContext({
-      pendingToolCount: 1,
-      pendingToolNames: new Set(['Task']),
-    });
-    const ctx3 = makeContext({
-      pendingToolCount: 3,
-      pendingToolNames: new Set(['Task']),
-    });
-    const v1 = await assessStall(ctx1, 'claude', false, false);
-    const v3 = await assessStall(ctx3, 'claude', false, false);
-    // More pending = more extension, capped at 30 min
-    expect(v3.extensionMs).toBeGreaterThanOrEqual(v1.extensionMs);
-    expect(v3.extensionMs).toBeLessThanOrEqual(30 * 60_000);
-  });
-
-  it('extends for 3+ parallel tool calls', async () => {
-    const ctx = makeContext({ pendingToolCount: 3 });
-    const verdict = await assessStall(ctx, 'claude', false, false);
-    expect(verdict.action).toBe('extend');
-    expect(verdict.extensionMs).toBe(15 * 60_000);
-    expect(verdict.reason).toContain('parallel tool calls');
-  });
-
-  it('extends for 5 parallel tool calls', async () => {
-    const ctx = makeContext({ pendingToolCount: 5 });
-    const verdict = await assessStall(ctx, 'claude', false, false);
-    expect(verdict.action).toBe('extend');
-    expect(verdict.reason).toContain('5 parallel tool calls');
-  });
-
-  it('extends for WebSearch without watchdog', async () => {
-    const ctx = makeContext({ lastToolName: 'WebSearch', pendingToolCount: 1 });
-    // pendingToolCount < 3, not Task, not watchdog active, but WebSearch
-    const verdict = await assessStall(ctx, 'claude', false, false);
-    expect(verdict.action).toBe('extend');
-    expect(verdict.extensionMs).toBe(5 * 60_000);
-    expect(verdict.reason).toContain('WebSearch');
-  });
-
-  it('extends for WebFetch without watchdog', async () => {
-    const ctx = makeContext({ lastToolName: 'WebFetch', pendingToolCount: 1 });
-    const verdict = await assessStall(ctx, 'claude', false, false);
-    expect(verdict.action).toBe('extend');
-    expect(verdict.extensionMs).toBe(5 * 60_000);
-    expect(verdict.reason).toContain('WebFetch');
-  });
-
-  it('does NOT extend for WebSearch when watchdog is active', async () => {
-    // When watchdog is active and tools are pending, the watchdog deferral
-    // takes priority over the WebSearch heuristic
-    const ctx = makeContext({
-      lastToolName: 'WebSearch',
-      pendingToolCount: 1,
-    });
-    const verdict = await assessStall(ctx, 'claude', false, true);
-    // Should defer to watchdog, not WebSearch heuristic
-    expect(verdict.action).toBe('extend');
-    expect(verdict.reason).toContain('Watchdog active');
-  });
-
-  it('falls back to extend when Haiku assessment fails', async () => {
-    // Context that doesn't match any heuristic → triggers Haiku →
-    // Haiku fails (no `claude` binary) → cautious extend
-    const ctx = makeContext({
-      pendingToolCount: 1,
-      lastToolName: 'Edit',
-    });
-    const verdict = await assessStall(ctx, 'nonexistent-claude-binary', false, false);
-    expect(verdict.action).toBe('extend');
-    expect(verdict.extensionMs).toBe(10 * 60_000);
-    expect(verdict.reason).toContain('unavailable');
-  });
-});