mstro-app 0.4.3 → 0.4.4

package/dist/server/cli/headless/stall-assessor.js

@@ -1,35 +1,24 @@
 // Copyright (c) 2025-present Mstro, Inc. All rights reserved.
 // Licensed under the MIT License. See LICENSE file for details.
 /**
- * Stall Assessor & Haiku Assessment Hub
+ * Stall Assessor — Two-layer stall detection (heuristic + Haiku AI).
  *
- * Provides Haiku-based intelligent assessment for:
- * - Stall detection (is a silent process working or hung?)
- * - Context loss detection (did Claude lose context after timeouts?)
- * - Approval prompt classification (is a user message an approval or new task?)
- * - Best result comparison (which retry attempt produced better work?)
- * - Error classification (what kind of error is in stderr?)
- *
- * Stall detection uses a two-layer approach:
  * 1. Fast heuristic: known long-running patterns get automatic extensions.
  * 2. Haiku assessment: ambiguous cases get a quick AI evaluation.
+ *
+ * Other Haiku-based assessments (context loss, approval, premature completion,
+ * best result, error classification) live in haiku-assessments.ts.
  */
-import { spawn } from 'node:child_process';
+import { spawnHaikuRaw } from './haiku-assessments.js';
 import { hlog } from './headless-logger.js';
-/** Check if Task/Agent subagents are currently pending (producing expected silence) */
+// Re-export assessment functions for backward compatibility
+export { assessApproval, assessBestResult, assessContextLoss, assessPrematureCompletion, classifyError } from './haiku-assessments.js';
+// ========== Fast Heuristic ==========
 function hasSubagentPending(pendingNames, lastToolName, hasPendingTools) {
     return pendingNames.has('Task') || pendingNames.has('Agent')
         || ((lastToolName === 'Task' || lastToolName === 'Agent') && hasPendingTools);
 }
-/**
- * Check if an Agent Teams lead is idle-waiting for teammate notifications.
- * After spawning teammates (Agent tool calls complete), the lead has no pending
- * tools but is legitimately waiting for teammate idle events.
- */
 function checkAgentTeamsWaiting(ctx, hasPendingTools) {
-    // The lead may use any tool while waiting (Glob to verify outputs, Bash to
-    // check disk, ToolSearch, etc.), so don't gate on lastToolName. The key
-    // signal is: prompt contains team_name, tools were called, nothing pending.
     if (!hasPendingTools &&
         ctx.totalToolCalls > 0 &&
         ctx.originalPrompt.includes('team_name')) {
@@ -41,19 +30,9 @@ function checkAgentTeamsWaiting(ctx, hasPendingTools) {
     }
     return null;
 }
-/**
- * Fast heuristic for known long-running patterns.
- * Returns a verdict immediately if the pattern is recognized, null otherwise.
- * When toolWatchdogActive is true, defers entirely to the watchdog for any
- * pending tool calls — the watchdog has per-tool adaptive timeouts that are
- * more precise than the stall detector's silence-based approach.
- */
 function quickHeuristic(ctx, toolWatchdogActive = false) {
     const pendingNames = ctx.pendingToolNames ?? new Set();
     const hasPendingTools = ctx.pendingToolCount > 0;
-    // Tokens still flowing = process is alive and actively processing.
-    // Extend generously when token activity is recent (< 60s), regardless
-    // of stdout silence. This covers silent thinking and tool result processing.
     if (ctx.tokenSilenceMs !== undefined && ctx.tokenSilenceMs < 60_000) {
         return {
             action: 'extend',
@@ -61,9 +40,6 @@ function quickHeuristic(ctx, toolWatchdogActive = false) {
             reason: `Tokens still flowing (last activity ${Math.round(ctx.tokenSilenceMs / 1000)}s ago) — process is alive`,
         };
     }
-    // When the watchdog is active and tools are pending, always defer.
-    // The watchdog manages per-tool timeouts; the stall detector should only
-    // fire when no tools are running and there's genuine silence.
     if (toolWatchdogActive && hasPendingTools) {
         const toolList = pendingNames.size > 0
             ? Array.from(pendingNames).join(', ')
@@ -74,8 +50,6 @@ function quickHeuristic(ctx, toolWatchdogActive = false) {
             reason: `Watchdog active, deferring — pending: ${toolList}`,
         };
     }
-    // Task/subagent launches are known to produce long silence periods.
-    // The parent Claude process emits nothing while waiting for subagent results.
     if (hasSubagentPending(pendingNames, ctx.lastToolName, hasPendingTools)) {
         const extensionMin = Math.min(30, 10 + ctx.pendingToolCount * 5);
         return {
@@ -84,11 +58,9 @@ function quickHeuristic(ctx, toolWatchdogActive = false) {
             reason: `${ctx.pendingToolCount} Task subagent(s) still executing — extending ${extensionMin} min`,
         };
     }
-    // Agent Teams lead waiting for teammate idle notifications (extracted for complexity)
     const agentTeamsVerdict = checkAgentTeamsWaiting(ctx, hasPendingTools);
     if (agentTeamsVerdict)
         return agentTeamsVerdict;
-    // Multiple parallel tool calls (e.g., parallel Bash, parallel Read/Grep)
     if (ctx.pendingToolCount >= 3) {
         return {
             action: 'extend',
@@ -96,9 +68,7 @@ function quickHeuristic(ctx, toolWatchdogActive = false) {
             reason: `${ctx.pendingToolCount} parallel tool calls in progress — extending 15 min`,
         };
     }
-    // WebSearch/WebFetch: skip when watchdog handles them more precisely
-    if (!toolWatchdogActive &&
-        (ctx.lastToolName === 'WebSearch' || ctx.lastToolName === 'WebFetch')) {
+    if (!toolWatchdogActive && (ctx.lastToolName === 'WebSearch' || ctx.lastToolName === 'WebFetch')) {
         return {
             action: 'extend',
             extensionMs: 5 * 60_000,
@@ -107,163 +77,10 @@ function quickHeuristic(ctx, toolWatchdogActive = false) {
     }
     return null;
 }
-/**
- * Main assessment entry point. Tries the fast heuristic first,
- * falls back to a Haiku model call for ambiguous cases.
- */
-export async function assessStall(ctx, claudeCommand, verbose, toolWatchdogActive = false) {
-    // Layer 1: fast heuristic
-    const quick = quickHeuristic(ctx, toolWatchdogActive);
-    if (quick) {
-        if (verbose) {
-            hlog(`[STALL-ASSESS] Heuristic verdict: ${quick.reason}`);
-        }
-        return quick;
-    }
-    // Layer 2: Haiku assessment
-    try {
-        if (verbose) {
-            hlog('[STALL-ASSESS] Running Haiku assessment...');
-        }
-        return await runHaikuAssessment(ctx, claudeCommand, verbose);
-    }
-    catch (err) {
-        if (verbose) {
-            hlog(`[STALL-ASSESS] Haiku assessment failed: ${err}`);
-        }
-        // If Haiku fails (timeout, auth issue, etc.), extend cautiously
-        return {
-            action: 'extend',
-            extensionMs: 10 * 60_000,
-            reason: 'Stall assessment unavailable — extending 10 min as precaution',
-        };
-    }
-}
-/**
- * Assess a specific tool timeout using Haiku.
- * Used by ToolWatchdog as a tiebreaker before killing a tool.
- */
-export async function assessToolTimeout(toolName, toolInput, elapsedMs, claudeCommand, verbose, tokenSilenceMs) {
-    const elapsedSec = Math.round(elapsedMs / 1000);
-    // Summarize what the tool is doing
-    let inputSummary = '';
-    if (toolInput.url) {
-        inputSummary = `URL: ${String(toolInput.url).slice(0, 200)}`;
-    }
-    else if (toolInput.query) {
-        inputSummary = `Query: ${String(toolInput.query).slice(0, 200)}`;
-    }
-    else if (toolInput.command) {
-        inputSummary = `Command: ${String(toolInput.command).slice(0, 200)}`;
-    }
-    else if (toolInput.prompt) {
-        inputSummary = `Prompt: ${String(toolInput.prompt).slice(0, 200)}`;
-    }
-    else {
-        inputSummary = JSON.stringify(toolInput).slice(0, 200);
-    }
-    const toolDescriptions = {
-        WebFetch: 'fetches a URL, converts HTML to markdown, and runs a Haiku summarization pass',
-        WebSearch: 'performs a web search and returns results',
-        Task: 'spawns a subagent that runs autonomously with its own tools',
-        Agent: 'spawns a subagent that runs autonomously with its own tools',
-        Bash: 'executes a shell command',
-    };
-    const toolDesc = toolDescriptions[toolName] || `executes the ${toolName} tool`;
-    const tokenLine = tokenSilenceMs !== undefined
-        ? `Token activity: last token event ${Math.round(tokenSilenceMs / 1000)}s ago (recent tokens = process is alive and processing)`
-        : 'Token activity: no token events observed';
-    const prompt = [
-        `You are a process health monitor. A ${toolName} tool call has been running for ${elapsedSec}s.`,
-        `${toolName} ${toolDesc}.`,
-        `Tool input: ${inputSummary}`,
-        tokenLine,
-        '',
-        `Is this tool call likely still working, or is it hung/frozen?`,
-        'Consider: network latency, server response times, anti-bot protections, large page sizes, complex operations.',
-        'IMPORTANT: If tokens were active recently (< 60s ago), the process is likely still alive and processing — strongly favor WORKING.',
-        '',
-        'Respond in EXACTLY this format (3 lines, no extra text):',
-        'VERDICT: WORKING or STALLED',
-        'MINUTES: <number 1-10, only if WORKING, how many more minutes to allow>',
-        'REASON: <brief one-line explanation>',
-    ].join('\n');
-    try {
-        if (verbose) {
-            hlog(`[TOOL-ASSESS] Running Haiku assessment for ${toolName} (${elapsedSec}s elapsed)...`);
-        }
-        return await spawnHaikuVerdict(prompt, claudeCommand, verbose, 'TOOL-ASSESS');
-    }
-    catch (err) {
-        if (verbose) {
-            hlog(`[TOOL-ASSESS] Haiku assessment failed: ${err}`);
-        }
-        // On failure, default to kill (the tool has already exceeded its timeout)
-        return {
-            action: 'kill',
-            extensionMs: 0,
-            reason: `Tool timeout assessment failed: ${err}`,
-        };
-    }
-}
-/**
- * Assess whether a Claude Code session lost context after tool timeouts.
- * Uses Haiku with enriched context signals — replaces brittle hardcoded
- * thresholds (200 chars thinking, 2x ratio, 500 chars response) with
- * a single LLM call that sees the full picture.
- *
- * Only call this when effectiveTimeouts > 0.
- */
-export async function assessContextLoss(ctx, claudeCommand, verbose) {
-    const tail = ctx.assistantResponse.slice(-800);
-    const prompt = [
-        'You are analyzing a Claude Code agent session that experienced tool timeouts.',
-        'Determine whether the agent lost context (needs recovery) or is still productively working.',
-        '',
-        'Session signals:',
-        `- ${ctx.effectiveTimeouts} tools timed out (${ctx.nativeTimeoutCount} detected in text stream, ${ctx.effectiveTimeouts - ctx.nativeTimeoutCount} detected structurally)`,
-        `- ${ctx.successfulToolCalls} tools completed successfully`,
-        `- Thinking output: ${ctx.thinkingOutputLength} characters`,
-        `- Response length: ${ctx.assistantResponse.length} characters`,
-        `- Successful file writes (Edit/Write/MultiEdit): ${ctx.hasSuccessfulWrite ? 'YES' : 'NO'}`,
-        '',
-        `Final response (last ${tail.length} chars):`,
-        tail,
-        '',
-        'WORKING signals: continued tool calls after timeouts, substantial thinking about the task, producing code/analysis, writing files, referencing the original task.',
-        'STALLED signals: asking "how can I help?", starting fresh, offering generic help, not referencing the original task, very short response with no substance, task abandoned mid-research.',
-        '',
-        'Respond in EXACTLY this format (2 lines, no extra text):',
-        'VERDICT: WORKING or STALLED',
-        'REASON: <brief one-line explanation>',
-    ].join('\n');
-    try {
-        if (verbose) {
-            hlog(`[CONTEXT-ASSESS] Running Haiku assessment (${ctx.effectiveTimeouts} timeouts, ${ctx.successfulToolCalls} successes, ${ctx.thinkingOutputLength} thinking chars)...`);
-        }
-        const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'CONTEXT-ASSESS');
-        const parsed = parseVerdictResponse(raw);
-        const contextLost = parsed.verdict === 'STALLED';
-        if (verbose) {
-            hlog(`[CONTEXT-ASSESS] Verdict: ${contextLost ? 'LOST' : 'CONTINUED'} — ${parsed.reason}`);
-        }
-        return { contextLost, reason: parsed.reason };
-    }
-    catch (err) {
-        if (verbose) {
-            hlog(`[CONTEXT-ASSESS] Haiku assessment failed: ${err}`);
-        }
-        // On failure, assume context was lost (safer to retry than to show a confused response)
-        return {
-            contextLost: true,
-            reason: `Context loss assessment failed: ${err}`,
-        };
-    }
-}
+// ========== Haiku Stall Assessment ==========
 function buildAssessmentPrompt(ctx) {
     const silenceMin = Math.round(ctx.silenceMs / 60_000);
     const totalMin = Math.round(ctx.elapsedTotalMs / 60_000);
-    // Truncate prompt to avoid huge payloads
     const promptPreview = ctx.originalPrompt.length > 500
         ? `${ctx.originalPrompt.slice(0, 500)}...`
         : ctx.originalPrompt;
@@ -309,290 +126,81 @@ function parseAssessmentResponse(output) {
         }
     }
     if (verdict.includes('WORKING')) {
-        return {
-            action: 'extend',
-            extensionMs: minutes * 60_000,
-            reason,
-        };
-    }
-    return {
-        action: 'kill',
-        extensionMs: 0,
-        reason,
-    };
-}
-const HAIKU_TIMEOUT_MS = 30_000;
-/** Low-level Haiku spawner: runs a prompt through `claude --print --model haiku` and returns raw text */
-function spawnHaikuRaw(prompt, claudeCommand, verbose, label) {
-    return new Promise((resolve, reject) => {
-        let stdout = '';
-        let settled = false;
-        const proc = spawn(claudeCommand, ['--print', '--model', 'haiku', prompt], { stdio: ['ignore', 'pipe', 'pipe'] });
-        const timer = setTimeout(() => {
-            if (!settled) {
-                settled = true;
-                proc.kill('SIGTERM');
-                reject(new Error('Haiku assessment timed out'));
-            }
-        }, HAIKU_TIMEOUT_MS);
-        proc.stdout.on('data', (data) => {
-            stdout += data.toString();
-        });
-        proc.stderr.on('data', (data) => {
-            if (verbose) {
-                hlog(`[${label}] haiku stderr: ${data.toString().trim()}`);
-            }
-        });
-        proc.on('close', (code) => {
-            clearTimeout(timer);
-            if (settled)
-                return;
-            settled = true;
-            if (code !== 0 || !stdout.trim()) {
-                reject(new Error(`Haiku exited with code ${code}, output: ${stdout.trim()}`));
-                return;
-            }
-            if (verbose) {
-                hlog(`[${label}] Haiku response: ${stdout.trim()}`);
-            }
-            resolve(stdout.trim());
-        });
-        proc.on('error', (err) => {
-            clearTimeout(timer);
-            if (settled)
-                return;
-            settled = true;
-            reject(err);
-        });
-    });
-}
-/** Parse VERDICT/REASON format from Haiku response */
-function parseVerdictResponse(raw) {
-    const lines = raw.split('\n');
-    let verdict = 'STALLED';
-    let reason = 'Assessment inconclusive';
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith('VERDICT:')) {
-            verdict = trimmed.slice('VERDICT:'.length).trim().toUpperCase();
-        }
-        else if (trimmed.startsWith('REASON:')) {
-            reason = trimmed.slice('REASON:'.length).trim();
-        }
+        return { action: 'extend', extensionMs: minutes * 60_000, reason };
     }
-    return { verdict, reason };
+    return { action: 'kill', extensionMs: 0, reason };
 }
-/** Haiku spawner that returns a parsed StallVerdict (for stall assessment) */
 async function spawnHaikuVerdict(prompt, claudeCommand, verbose, label = 'STALL-ASSESS') {
     const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, label);
     return parseAssessmentResponse(raw);
 }
-function runHaikuAssessment(ctx, claudeCommand, verbose) {
-    return spawnHaikuVerdict(buildAssessmentPrompt(ctx), claudeCommand, verbose);
-}
-/**
- * Assess whether a user message is an approval/continuation or a new task.
- * Uses Haiku to classify intent — handles natural language variations that
- * regex patterns miss ("sounds good", "yep do it", "option 2", etc.).
- */
-export async function assessApproval(userMessage, claudeCommand, verbose) {
-    const prompt = [
-        'You are classifying a user message in a multi-turn conversation with a coding assistant.',
-        'The assistant previously proposed a plan or asked a question, and the user is now responding.',
-        '',
-        `User's message: "${userMessage}"`,
-        '',
-        'Is this an approval/continuation (user agrees, says yes, wants to proceed) or a new task/question?',
-        '',
-        'APPROVAL signs: "yes", "sure", "go ahead", "sounds good", "do it", "yep", "option 2", "the first one", "proceed", references to previous proposal, short affirmative with modifications ("yes but use TypeScript").',
-        'NEW_TASK signs: asks a different question, gives new detailed instructions, changes topic, provides new requirements unrelated to any proposal.',
-        '',
-        'Respond in EXACTLY this format (2 lines, no extra text):',
-        'VERDICT: APPROVAL or NEW_TASK',
-        'REASON: <brief one-line explanation>',
-    ].join('\n');
-    try {
-        if (verbose) {
-            hlog('[APPROVAL-ASSESS] Running Haiku assessment...');
-        }
-        const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'APPROVAL-ASSESS');
-        const parsed = parseVerdictResponse(raw);
-        const isApproval = parsed.verdict.includes('APPROVAL');
-        if (verbose) {
-            hlog(`[APPROVAL-ASSESS] Verdict: ${isApproval ? 'APPROVAL' : 'NEW_TASK'} — ${parsed.reason}`);
-        }
-        return { isApproval, reason: parsed.reason };
-    }
-    catch (err) {
-        if (verbose) {
-            hlog(`[APPROVAL-ASSESS] Haiku assessment failed: ${err}`);
-        }
-        // On failure, assume not an approval (safer to treat as new task)
-        return { isApproval: false, reason: `Assessment failed: ${err}` };
+// ========== Public API ==========
+export async function assessStall(ctx, claudeCommand, verbose, toolWatchdogActive = false) {
+    const quick = quickHeuristic(ctx, toolWatchdogActive);
+    if (quick) {
+        if (verbose)
+            hlog(`[STALL-ASSESS] Heuristic verdict: ${quick.reason}`);
+        return quick;
     }
-}
-/**
- * Assess whether a completed Claude execution ended prematurely.
- * Called when stop_reason is 'end_turn' but the task may not be finished.
- * Haiku determines if the trailing response text indicates planned-but-unexecuted work.
- */
-export async function assessPrematureCompletion(ctx, claudeCommand, verbose) {
-    const prompt = [
-        'You are analyzing the FINAL output of a Claude Code agent that just exited normally.',
-        'Determine whether the agent finished its task or stopped prematurely mid-work.',
-        '',
-        'Session signals:',
-        `- ${ctx.successfulToolCalls} tool calls completed successfully`,
-        `- Response length: ${ctx.responseLength} characters`,
-        `- Extended thinking: ${ctx.hasThinking ? 'YES' : 'NO'}`,
-        '',
-        `Final response text (last ${ctx.responseTail.length} chars):`,
-        ctx.responseTail,
-        '',
-        'INCOMPLETE signals: "Now I\'ll...", "Let me fix...", "Next I\'ll...", "Moving on to...",',
-        '"I\'ll continue with...", announcing next steps that were never executed,',
-        'describing work that will happen next but no tool call followed.',
-        '',
-        'COMPLETE signals: summarizing what was done, confirming changes, reporting results,',
-        'asking the user a question, past-tense descriptions of completed work,',
-        '"all done", "changes applied", referencing finished state.',
-        '',
-        'Respond in EXACTLY this format (2 lines, no extra text):',
-        'VERDICT: COMPLETE or INCOMPLETE',
-        'REASON: <brief one-line explanation>',
-    ].join('\n');
     try {
-        if (verbose) {
-            hlog(`[PREMATURE-ASSESS] Running Haiku assessment (${ctx.successfulToolCalls} tools, ${ctx.responseLength} chars)...`);
-        }
-        const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'PREMATURE-ASSESS');
-        const parsed = parseVerdictResponse(raw);
-        const isIncomplete = parsed.verdict.includes('INCOMPLETE');
-        if (verbose) {
-            hlog(`[PREMATURE-ASSESS] Verdict: ${isIncomplete ? 'INCOMPLETE' : 'COMPLETE'} — ${parsed.reason}`);
-        }
-        return { isIncomplete, reason: parsed.reason };
+        if (verbose)
+            hlog('[STALL-ASSESS] Running Haiku assessment...');
+        return await spawnHaikuVerdict(buildAssessmentPrompt(ctx), claudeCommand, verbose);
     }
     catch (err) {
-        if (verbose) {
-            hlog(`[PREMATURE-ASSESS] Haiku assessment failed: ${err}`);
-        }
-        // On failure, don't retry — safer to let the user decide than to auto-continue incorrectly
-        return { isIncomplete: false, reason: `Assessment failed: ${err}` };
+        if (verbose)
+            hlog(`[STALL-ASSESS] Haiku assessment failed: ${err}`);
+        return { action: 'extend', extensionMs: 10 * 60_000, reason: 'Stall assessment unavailable — extending 10 min as precaution' };
     }
 }
-/**
- * Compare two retry results and determine which made more meaningful progress.
- * Uses Haiku to evaluate quality — replaces arbitrary numeric scoring
- * (tool count * 10 + response length / 50 + thinking bonus).
- */
-export async function assessBestResult(ctx, claudeCommand, verbose) {
-    const promptPreview = ctx.originalPrompt.length > 300
-        ? `${ctx.originalPrompt.slice(0, 300)}...`
-        : ctx.originalPrompt;
+export async function assessToolTimeout(toolName, toolInput, elapsedMs, claudeCommand, verbose, tokenSilenceMs) {
+    const elapsedSec = Math.round(elapsedMs / 1000);
+    let inputSummary = '';
+    if (toolInput.url)
+        inputSummary = `URL: ${String(toolInput.url).slice(0, 200)}`;
+    else if (toolInput.query)
+        inputSummary = `Query: ${String(toolInput.query).slice(0, 200)}`;
+    else if (toolInput.command)
+        inputSummary = `Command: ${String(toolInput.command).slice(0, 200)}`;
+    else if (toolInput.prompt)
+        inputSummary = `Prompt: ${String(toolInput.prompt).slice(0, 200)}`;
+    else
+        inputSummary = JSON.stringify(toolInput).slice(0, 200);
+    const toolDescriptions = {
+        WebFetch: 'fetches a URL, converts HTML to markdown, and runs a Haiku summarization pass',
+        WebSearch: 'performs a web search and returns results',
+        Task: 'spawns a subagent that runs autonomously with its own tools',
+        Agent: 'spawns a subagent that runs autonomously with its own tools',
+        Bash: 'executes a shell command',
+    };
+    const toolDesc = toolDescriptions[toolName] || `executes the ${toolName} tool`;
+    const tokenLine = tokenSilenceMs !== undefined
+        ? `Token activity: last token event ${Math.round(tokenSilenceMs / 1000)}s ago (recent tokens = process is alive and processing)`
+        : 'Token activity: no token events observed';
     const prompt = [
-        'You are comparing two AI assistant responses from retry attempts to determine which made more meaningful progress on the user\'s task.',
-        '',
-        `Original task: ${promptPreview}`,
-        '',
-        `Response A: ${ctx.resultA.successfulToolCalls} successful tool calls, ${ctx.resultA.responseLength} chars, ${ctx.resultA.hasThinking ? 'has' : 'no'} thinking output`,
-        `Last 500 chars of A: ${ctx.resultA.responseTail}`,
-        '',
-        `Response B: ${ctx.resultB.successfulToolCalls} successful tool calls, ${ctx.resultB.responseLength} chars, ${ctx.resultB.hasThinking ? 'has' : 'no'} thinking output`,
-        `Last 500 chars of B: ${ctx.resultB.responseTail}`,
+        `You are a process health monitor. A ${toolName} tool call has been running for ${elapsedSec}s.`,
+        `${toolName} ${toolDesc}.`,
+        `Tool input: ${inputSummary}`,
+        tokenLine,
         '',
-        'Which response made more meaningful progress? Consider:',
-        '- Did it actually work on the task (tool calls, code changes) vs just talking about it?',
-        '- Is it confused/lost context ("How can I help?") vs engaged with the original task?',
-        '- Quality of analysis and output, not just quantity.',
+        `Is this tool call likely still working, or is it hung/frozen?`,
+        'Consider: network latency, server response times, anti-bot protections, large page sizes, complex operations.',
+        'IMPORTANT: If tokens were active recently (< 60s ago), the process is likely still alive and processing — strongly favor WORKING.',
         '',
-        'Respond in EXACTLY this format (2 lines, no extra text):',
-        'VERDICT: A or B',
+        'Respond in EXACTLY this format (3 lines, no extra text):',
+        'VERDICT: WORKING or STALLED',
+        'MINUTES: <number 1-10, only if WORKING, how many more minutes to allow>',
         'REASON: <brief one-line explanation>',
     ].join('\n');
     try {
-        if (verbose) {
-            hlog('[BEST-RESULT] Running Haiku assessment...');
-        }
-        const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'BEST-RESULT');
-        const parsed = parseVerdictResponse(raw);
-        const winner = parsed.verdict.includes('B') ? 'B' : 'A';
-        if (verbose) {
-            hlog(`[BEST-RESULT] Verdict: ${winner} — ${parsed.reason}`);
-        }
-        return { winner, reason: parsed.reason };
-    }
-    catch (err) {
-        if (verbose) {
-            hlog(`[BEST-RESULT] Haiku assessment failed: ${err}`);
-        }
-        // On failure, prefer A (the previously-tracked best result)
-        return { winner: 'A', reason: `Assessment failed: ${err}` };
-    }
-}
-/**
- * Classify an unrecognized error from stderr using Haiku.
- * Called as a fallback when regex patterns in output-utils.ts don't match.
- * Returns null if the stderr content isn't a real error (just warnings/debug info).
- */
-export async function classifyError(stderrContent, claudeCommand, verbose) {
-    const tail = stderrContent.slice(-500);
-    if (!tail.trim())
-        return null;
-    const prompt = [
-        'You are classifying an error message from the Claude Code CLI that did not match known patterns.',
-        '',
-        `stderr (last ${tail.length} chars):`,
-        tail,
-        '',
-        'Classify into one of these categories:',
-        '- AUTH_REQUIRED: Authentication/login issues',
-        '- API_KEY_INVALID: API key problems',
-        '- QUOTA_EXCEEDED: Usage limits, billing, subscription',
-        '- RATE_LIMITED: Too many requests, throttling',
-        '- NETWORK_ERROR: Connection, DNS, timeout issues',
-        '- SSL_ERROR: Certificate/TLS problems',
-        '- SERVICE_UNAVAILABLE: Backend down (502/503/504)',
-        '- INTERNAL_ERROR: Server errors (500)',
-        '- CONTEXT_TOO_LONG: Token/context limit exceeded',
-        '- SESSION_NOT_FOUND: Invalid/expired session',
-        '- UNKNOWN: Cannot determine, not a real error, or just warnings/debug output',
-        '',
-        'If the stderr content is just warnings, debug info, or not an actual error, use UNKNOWN.',
-        '',
-        'Respond in EXACTLY this format (2 lines, no extra text):',
-        'CATEGORY: <one of the above>',
-        'MESSAGE: <brief user-friendly description of the error>',
-    ].join('\n');
-    try {
-        if (verbose) {
-            hlog('[ERROR-CLASSIFY] Running Haiku assessment...');
-        }
-        const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, 'ERROR-CLASSIFY');
-        const lines = raw.split('\n');
-        let category = 'UNKNOWN';
-        let message = '';
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (trimmed.startsWith('CATEGORY:')) {
-                category = trimmed.slice('CATEGORY:'.length).trim().toUpperCase();
-            }
-            else if (trimmed.startsWith('MESSAGE:')) {
-                message = trimmed.slice('MESSAGE:'.length).trim();
-            }
-        }
-        if (category === 'UNKNOWN' || !message)
-            return null;
-        if (verbose) {
-            hlog(`[ERROR-CLASSIFY] Verdict: ${category} — ${message}`);
-        }
-        return { errorCode: category, message };
+        if (verbose)
+            hlog(`[TOOL-ASSESS] Running Haiku assessment for ${toolName} (${elapsedSec}s elapsed)...`);
+        return await spawnHaikuVerdict(prompt, claudeCommand, verbose, 'TOOL-ASSESS');
     }
     catch (err) {
-        if (verbose) {
-            hlog(`[ERROR-CLASSIFY] Haiku assessment failed: ${err}`);
-        }
-        return null;
+        if (verbose)
+            hlog(`[TOOL-ASSESS] Haiku assessment failed: ${err}`);
+        return { action: 'kill', extensionMs: 0, reason: `Tool timeout assessment failed: ${err}` };
     }
 }
 //# sourceMappingURL=stall-assessor.js.map