@minionry/minion 0.7.36

package/dist/server/cli/headless/runner.js

@@ -0,0 +1,245 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { resolveClaudeCommand } from '../../engines/claude/claude-command.js';
+import { getCurrentMinionryPort } from '../../services/runtime-info.js';
+import { getBouncerSecret } from '../../services/websocket/ask-user-question-bridge.js';
+import { executeClaudeCommand } from './claude-invoker.js';
+import { estimateTokensFromOutput } from './output-utils.js';
+import { enrichPromptWithContext } from './prompt-utils.js';
+function readDefaultMinionryPort() {
+    return getCurrentMinionryPort();
+}
+function readDefaultBouncerSecret() {
+    return getBouncerSecret();
+}
+export function killProcessGroup(pid, signal) {
+    try {
+        process.kill(-pid, signal);
+    }
+    catch {
+        try {
+            process.kill(pid, signal);
+        }
+        catch {   }
+    }
+}
+function sharedResultFields(result) {
+    return {
+        exitCode: result.exitCode,
+        signalName: result.signalName,
+        engineNotice: result.engineNotice,
+        resultSubtype: result.resultSubtype,
+        terminalReason: result.terminalReason,
+        resultIsError: result.resultIsError,
+        stderrTail: result.stderrTail,
+        firstEventLatencyMs: result.firstEventLatencyMs,
+        startupTimedOut: result.startupTimedOut,
+        pendingBackgroundTasks: result.pendingBackgroundTasks,
+        apiTokenUsage: result.apiTokenUsage,
+        outputTokens: result.apiTokenUsage?.outputTokens,
+        assistantResponse: result.assistantResponse,
+        thinkingOutput: result.thinkingOutput,
+        toolUseHistory: result.toolUseHistory,
+        claudeSessionId: result.claudeSessionId,
+        nativeTimeoutCount: result.nativeTimeoutCount,
+        postTimeoutOutput: result.postTimeoutOutput,
+        resumeBufferedOutput: result.resumeBufferedOutput,
+        stopReason: result.stopReason,
+        sessionNotFound: result.sessionNotFound,
+        failedMcpServers: result.failedMcpServers,
+        backgroundTasksPendingAtExit: result.backgroundTasksPendingAtExit,
+        pendingWakeup: result.pendingWakeup,
+        interrupted: result.interrupted,
+    };
+}
+function isSignalExitWithOutput(result) {
+    if (result.exitCode < 128 && !result.interrupted)
+        return false;
+    if (result.backgroundTasksPendingAtExit || result.pendingWakeup)
+        return false;
+    return !!(result.assistantResponse || (result.toolUseHistory && result.toolUseHistory.length > 0));
+}
+function plainStdoutLines(output) {
+    const plainLines = output.split('\n')
+        .filter(l => l.trim() && !l.trim().startsWith('{'))
+        .join('\n')
+        .trim();
+    return plainLines ? plainLines.slice(0, 500) : undefined;
+}
+function deriveErrorMessage(result) {
+    if (result.engineNotice)
+        return result.engineNotice.text;
+    if (result.startupTimedOut) {
+        return result.error || 'The engine produced no output after starting.';
+    }
+    if (result.signalName && result.backgroundTasksPendingAtExit) {
+        return `Process killed (${result.signalName}) while ${result.backgroundTasksPendingAtExit} background task(s) were still running — background work was lost and must be re-launched.`;
+    }
+    if (result.interrupted && !result.error) {
+        return 'Execution was interrupted before completion';
+    }
+    const exitLine = `Claude exited with code ${result.exitCode}${result.signalName ? ` (${result.signalName})` : ''}`;
+    if (result.error)
+        return `${exitLine}: ${result.error.slice(0, 500)}`;
+    return plainStdoutLines(result.output) ?? exitLine;
+}
+function buildSuccessResult(sessionId, result) {
+    return {
+        completed: true,
+        needsHandoff: false,
+        totalTokens: estimateTokensFromOutput(result.output),
+        sessionId,
+        ...sharedResultFields(result),
+    };
+}
+function buildErrorResult(sessionId, result) {
+    return {
+        completed: false,
+        needsHandoff: false,
+        totalTokens: 0,
+        sessionId,
+        error: deriveErrorMessage(result),
+        ...sharedResultFields(result),
+    };
+}
+function resolveSupervisionConfig(config) {
+    return {
+        stallWarningMs: config.stallWarningMs ?? 300_000,
+        stallKillMs: config.stallKillMs ?? 1_800_000,
+        stallAssessEnabled: config.stallAssessEnabled !== false,
+        stallMaxExtensions: config.stallMaxExtensions ?? 3,
+        stallHardCapMs: config.stallHardCapMs ?? 14_400_000,
+        backgroundWaitGraceMs: config.backgroundWaitGraceMs ?? 300_000,
+        backgroundWaitCapMs: config.backgroundWaitCapMs ?? 3_600_000,
+        backgroundWaitAbsoluteCapMs: config.backgroundWaitAbsoluteCapMs ?? 10_800_000,
+        firstEventDeadlineMs: config.firstEventDeadlineMs ?? 90_000,
+    };
+}
+export class HeadlessRunner {
+    config;
+    runningProcesses = new Map();
+    liveContext = null;
+    constructor(config) {
+        this.config = {
+            workingDir: config.workingDir || process.cwd(),
+            tokenBudgetThreshold: config.tokenBudgetThreshold || 170000,
+            maxSessions: config.maxSessions || 50,
+            maxRetries: config.maxRetries || 3,
+            claudeCommand: config.claudeCommand || resolveClaudeCommand(),
+            verbose: !!config.verbose,
+            noColor: !!config.noColor,
+            improvisationMode: !!config.improvisationMode,
+            movementNumber: config.movementNumber ?? 0,
+            outputCallback: config.outputCallback,
+            thinkingCallback: config.thinkingCallback,
+            toolUseCallback: config.toolUseCallback,
+            continueSession: config.continueSession,
+            claudeSessionId: config.claudeSessionId,
+            directPrompt: config.directPrompt || '',
+            promptContext: config.promptContext || { accumulatedKnowledge: '', filesModified: [] },
+            imageAttachments: config.imageAttachments,
+            ...resolveSupervisionConfig(config),
+            model: config.model,
+            effortLevel: config.effortLevel,
+            fastMode: !!config.fastMode,
+            ultracode: !!config.ultracode,
+            appendSystemPrompt: config.appendSystemPrompt,
+            toolTimeoutProfiles: config.toolTimeoutProfiles,
+            enableToolWatchdog: config.enableToolWatchdog !== false,
+            maxAutoRetries: config.maxAutoRetries ?? 2,
+            onToolTimeout: config.onToolTimeout,
+            onBackgroundActivity: config.onBackgroundActivity,
+            onExecutionTargetResolved: config.onExecutionTargetResolved,
+            extraEnv: config.extraEnv,
+            disallowedTools: config.disallowedTools,
+            inferenceOnly: !!config.inferenceOnly,
+            deployMode: config.deployMode,
+            tabId: config.tabId,
+            minionryPort: config.minionryPort ?? readDefaultMinionryPort(),
+            bouncerSecret: config.bouncerSecret ?? readDefaultBouncerSecret(),
+            agentId: config.agentId,
+            agentLabel: config.agentLabel,
+            planId: config.planId,
+            appRunProfile: config.appRunProfile,
+            appTools: config.appTools,
+            browserMcp: config.browserMcp,
+        };
+    }
+    async run() {
+        if (this.config.directPrompt) {
+            return await this.runDirectPrompt(this.config.directPrompt, this.config.promptContext);
+        }
+        return {
+            completed: false,
+            needsHandoff: false,
+            totalTokens: 0,
+            sessionId: '',
+            error: 'No prompt provided. Use directPrompt in improvise mode.'
+        };
+    }
+    async runDirectPrompt(userPrompt, context) {
+        const sessionId = `direct-${Date.now()}`;
+        const enrichedPrompt = context
+            ? await enrichPromptWithContext(userPrompt, context)
+            : userPrompt;
+        const result = await this.executePromptCommand(enrichedPrompt, 'main', 1);
+        if (result.exitCode === 0 && !result.interrupted) {
+            return buildSuccessResult(sessionId, result);
+        }
+        if (isSignalExitWithOutput(result)) {
+            return buildSuccessResult(sessionId, result);
+        }
+        return buildErrorResult(sessionId, result);
+    }
+    async executePromptCommand(prompt, promptId, sessionNumber) {
+        const invokerOptions = {
+            config: this.config,
+            runningProcesses: this.runningProcesses,
+            onLiveContext: (live) => { this.liveContext = live; },
+        };
+        return executeClaudeCommand(prompt, promptId, sessionNumber, invokerOptions);
+    }
+    snapshot() {
+        const live = this.liveContext;
+        if (!live)
+            return null;
+        const { ctx, sessionCapture } = live;
+        const u = ctx.apiTokenUsage;
+        const hasTokenUsage = u.inputTokens > 0 || u.outputTokens > 0 || u.cacheCreationTokens > 0 || u.cacheReadTokens > 0;
+        return {
+            assistantResponse: ctx.accumulatedAssistantResponse || undefined,
+            thinkingOutput: ctx.accumulatedThinking || undefined,
+            toolUseHistory: ctx.accumulatedToolUse.length > 0 ? ctx.accumulatedToolUse.map((t) => ({ ...t })) : undefined,
+            claudeSessionId: sessionCapture.claudeSessionId,
+            apiTokenUsage: hasTokenUsage ? { ...u } : undefined,
+            engineNotice: ctx.engineNotice,
+        };
+    }
+    cleanup() {
+        if (this.runningProcesses.size === 0)
+            return;
+        const pids = new Set();
+        for (const [pid] of this.runningProcesses) {
+            pids.add(pid);
+            killProcessGroup(pid, 'SIGTERM');
+        }
+        setTimeout(() => {
+            for (const [pid, proc] of this.runningProcesses) {
+                if (pids.has(pid) && !proc.killed) {
+                    killProcessGroup(pid, 'SIGKILL');
+                }
+            }
+            this.runningProcesses.clear();
+        }, 5000);
+    }
+    sweepZombies() {
+        let swept = 0;
+        for (const [pid, proc] of this.runningProcesses) {
+            if (proc.exitCode !== null || proc.killed) {
+                this.runningProcesses.delete(pid);
+                swept++;
+            }
+        }
+        return swept;
+    }
+}

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

@@ -0,0 +1,295 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { loadSkillPrompt } from '../../services/plan/agent-loader.js';
+import { spawnHaikuRaw } from './haiku-assessments.js';
+import { hlog } from './headless-logger.js';
+export { assessApproval, assessBestResult, assessContextLoss, classifyError } from './haiku-assessments.js';
+const STALL_MAX_MINUTES = 180;
+const TOOL_TIMEOUT_MAX_MINUTES = 10;
+export function createToolActivityState() {
+    return {
+        pendingToolIds: new Set(),
+        pendingToolNames: new Set(),
+        pendingToolNameById: new Map(),
+        totalToolCalls: 0,
+    };
+}
+export function applyEngineEventToActivity(state, event) {
+    if (event.kind === 'tool.start') {
+        state.pendingToolIds.add(event.toolCallId);
+        state.pendingToolNames.add(event.toolName);
+        state.pendingToolNameById.set(event.toolCallId, event.toolName);
+        state.lastToolName = event.toolName;
+        state.lastToolInputSummary = summarizeToolInput(event.input);
+        state.totalToolCalls++;
+        return;
+    }
+    if (event.kind === 'tool.end') {
+        state.pendingToolIds.delete(event.toolCallId);
+        state.pendingToolNameById.delete(event.toolCallId);
+        const stillPending = Array.from(state.pendingToolNameById.values()).includes(event.toolName);
+        if (!stillPending)
+            state.pendingToolNames.delete(event.toolName);
+    }
+}
+export function buildStallContext(activity, timing) {
+    return {
+        originalPrompt: timing.originalPrompt,
+        silenceMs: timing.silenceMs,
+        elapsedTotalMs: timing.elapsedTotalMs,
+        tokenSilenceMs: timing.tokenSilenceMs,
+        lastToolName: activity.lastToolName,
+        lastToolInputSummary: activity.lastToolInputSummary,
+        pendingToolCount: activity.pendingToolIds.size,
+        pendingToolNames: new Set(activity.pendingToolNames),
+        totalToolCalls: activity.totalToolCalls,
+    };
+}
+function summarizeToolInput(input) {
+    if (input.url)
+        return `URL: ${String(input.url).slice(0, 200)}`;
+    if (input.query)
+        return `Query: ${String(input.query).slice(0, 200)}`;
+    if (input.command)
+        return `Command: ${String(input.command).slice(0, 200)}`;
+    if (input.prompt)
+        return `Prompt: ${String(input.prompt).slice(0, 200)}`;
+    const serialized = JSON.stringify(input);
+    return serialized ? serialized.slice(0, 200) : undefined;
+}
+function hasSubagentPending(pendingNames, lastToolName, hasPendingTools) {
+    return pendingNames.has('Task') || pendingNames.has('Agent')
+        || ((lastToolName === 'Task' || lastToolName === 'Agent') && hasPendingTools);
+}
+function checkAgentTeamsWaiting(ctx, hasPendingTools) {
+    if (!hasPendingTools &&
+        ctx.totalToolCalls > 0 &&
+        ctx.originalPrompt.includes('team_name')) {
+        return {
+            action: 'extend',
+            extensionMs: 30 * 60_000,
+            reason: 'Agent Teams lead waiting for teammate idle notifications — extending 30 min',
+        };
+    }
+    return null;
+}
+function quickHeuristic(ctx, toolWatchdogActive = false) {
+    const pendingNames = ctx.pendingToolNames ?? new Set();
+    const hasPendingTools = ctx.pendingToolCount > 0;
+    if (ctx.tokenSilenceMs !== undefined && ctx.tokenSilenceMs < 60_000) {
+        return {
+            action: 'extend',
+            extensionMs: 10 * 60_000,
+            reason: `Tokens still flowing (last activity ${Math.round(ctx.tokenSilenceMs / 1000)}s ago) — process is alive`,
+        };
+    }
+    if (toolWatchdogActive && hasPendingTools) {
+        const toolList = pendingNames.size > 0
+            ? Array.from(pendingNames).join(', ')
+            : `${ctx.pendingToolCount} tool(s)`;
+        return {
+            action: 'extend',
+            extensionMs: 15 * 60_000,
+            reason: `Watchdog active, deferring — pending: ${toolList}`,
+        };
+    }
+    if (hasSubagentPending(pendingNames, ctx.lastToolName, hasPendingTools)) {
+        const extensionMin = Math.min(30, 10 + ctx.pendingToolCount * 5);
+        return {
+            action: 'extend',
+            extensionMs: extensionMin * 60_000,
+            reason: `${ctx.pendingToolCount} Task subagent(s) still executing — extending ${extensionMin} min`,
+        };
+    }
+    const agentTeamsVerdict = checkAgentTeamsWaiting(ctx, hasPendingTools);
+    if (agentTeamsVerdict)
+        return agentTeamsVerdict;
+    if (ctx.pendingToolCount >= 3) {
+        return {
+            action: 'extend',
+            extensionMs: 15 * 60_000,
+            reason: `${ctx.pendingToolCount} parallel tool calls in progress — extending 15 min`,
+        };
+    }
+    if (!toolWatchdogActive && (ctx.lastToolName === 'WebSearch' || ctx.lastToolName === 'WebFetch')) {
+        return {
+            action: 'extend',
+            extensionMs: 5 * 60_000,
+            reason: `${ctx.lastToolName} in progress — extending 5 min`,
+        };
+    }
+    return null;
+}
+function buildAssessmentPrompt(ctx) {
+    const silenceMin = String(Math.round(ctx.silenceMs / 60_000));
+    const totalMin = String(Math.round(ctx.elapsedTotalMs / 60_000));
+    const promptPreview = ctx.originalPrompt.length > 500
+        ? `${ctx.originalPrompt.slice(0, 500)}...`
+        : ctx.originalPrompt;
+    const tokenLine = ctx.tokenSilenceMs !== undefined
+        ? `Token activity: last token event ${Math.round(ctx.tokenSilenceMs / 1000)}s ago (tokens flowing = process alive)`
+        : 'Token activity: no token events observed';
+    const lastToolInputLine = ctx.lastToolInputSummary ? `Last tool input: ${ctx.lastToolInputSummary}` : '';
+    const backgroundLine = ctx.backgroundTasksPending
+        ? `Background orchestration: ${ctx.backgroundTasksPending} background subagent/workflow task(s) still pending (these do not show up as pending tool calls; long silence between their progress events is normal)`
+        : '';
+    const wakeupLine = ctx.wakeupOverdueMs && ctx.wakeupOverdueMs > 0
+        ? `Scheduled wakeup: the process armed a self-wakeup that is now ${Math.round(ctx.wakeupOverdueMs / 60_000)} min overdue with no output — a fired wakeup should have produced activity`
+        : '';
+    const fromSkill = loadSkillPrompt('assess-stall', {
+        silenceMin,
+        totalMin,
+        lastToolName: ctx.lastToolName || 'none',
+        lastToolInputLine,
+        pendingToolCount: String(ctx.pendingToolCount),
+        totalToolCalls: String(ctx.totalToolCalls),
+        tokenLine,
+        backgroundLine,
+        wakeupLine,
+        promptPreview,
+    });
+    if (fromSkill)
+        return fromSkill;
+    return [
+        'You are a process health monitor. A Claude Code subprocess has gone silent (no stdout) and you must determine if it is working or stalled.',
+        '',
+        `Silent for: ${silenceMin} minutes`,
+        `Total runtime: ${totalMin} minutes`,
+        `Last tool before silence: ${ctx.lastToolName || 'none'}`,
+        lastToolInputLine,
+        `Pending tool calls: ${ctx.pendingToolCount}`,
+        `Total tool calls this session: ${ctx.totalToolCalls}`,
+        tokenLine,
+        backgroundLine,
+        wakeupLine,
+        `Task being executed: ${promptPreview}`,
+        '',
+        'Weigh BOTH silence and total runtime against task complexity.',
+        '- Simple tasks (single Read/Write, one-liner edit, ls a directory) should finish in minutes. If total runtime has already far exceeded what the task should need, verdict STALLED even if silence is short.',
+        '- Complex tasks (agent teams, multi-step migrations, large refactors, dependency installs) can legitimately run hours. Extend generously when pending tool activity, subagents, or background orchestration tasks justify it.',
+        '- Recent token activity = process is alive; favor WORKING.',
+        '',
+        'Respond in EXACTLY this format (3 lines, no extra text):',
+        'VERDICT: WORKING or STALLED',
+        'MINUTES: <integer 5-180, only if WORKING, how many more minutes to allow>',
+        'REASON: <brief one-line explanation that references task complexity vs elapsed time>',
+    ].filter(Boolean).join('\n');
+}
+export function parseAssessmentResponse(output, maxMinutes = STALL_MAX_MINUTES) {
+    const lines = output.trim().split('\n');
+    let verdict = 'STALLED';
+    let minutes = Math.min(10, maxMinutes);
+    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('MINUTES:')) {
+            const parsed = parseInt(trimmed.slice('MINUTES:'.length).trim(), 10);
+            if (!Number.isNaN(parsed) && parsed >= 1) {
+                minutes = Math.min(parsed, maxMinutes);
+            }
+        }
+        else if (trimmed.startsWith('REASON:')) {
+            reason = trimmed.slice('REASON:'.length).trim();
+        }
+    }
+    if (verdict.includes('WORKING')) {
+        return { action: 'extend', extensionMs: minutes * 60_000, reason, assessed: true };
+    }
+    return { action: 'kill', extensionMs: 0, reason, assessed: true };
+}
+async function spawnHaikuVerdict(prompt, claudeCommand, verbose, label = 'STALL-ASSESS', maxMinutes = STALL_MAX_MINUTES) {
+    const raw = await spawnHaikuRaw(prompt, claudeCommand, verbose, label);
+    return parseAssessmentResponse(raw, maxMinutes);
+}
+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;
+    }
+    try {
+        if (verbose)
+            hlog('[STALL-ASSESS] Running Haiku assessment...');
+        return await spawnHaikuVerdict(buildAssessmentPrompt(ctx), claudeCommand, verbose, 'STALL-ASSESS', STALL_MAX_MINUTES);
+    }
+    catch (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', assessed: false };
+    }
+}
+export async function assessToolTimeout(toolName, toolInput, elapsedMs, claudeCommand, verbose, tokenSilenceMs, backgroundWorkPending = false, declaredTimeoutMs) {
+    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',
+        Workflow: 'orchestrates many subagents via a script; large runs take tens of minutes to hours',
+        Monitor: 'blocks waiting for a condition or background work to change state',
+        TaskOutput: 'blocks waiting for a background task to produce output',
+        Bash: 'executes a shell command',
+        Write: 'writes file content that may be very large; content streams token-by-token through stdio before disk write',
+        Edit: 'applies string replacements to a file; streams through stdio protocol',
+        Read: 'reads file contents that may be very large; result streams through stdio protocol',
+        Grep: 'searches file contents with regex; large codebases produce large result streams',
+        Glob: 'finds files by pattern; large directory trees take time to scan',
+    };
+    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 backgroundLine = backgroundWorkPending
+        ? 'Background orchestration tasks (subagents/workflows) are pending in this session — long coordination waits are normal; favor WORKING.'
+        : '';
+    const declaredLine = declaredTimeoutMs
+        ? `Declared timeout: the caller budgeted ${Math.round(declaredTimeoutMs / 1000)}s for this call${elapsedMs < declaredTimeoutMs ? ' — it is still within that budget; strongly favor WORKING' : ' — that budget is now exceeded'}.`
+        : '';
+    const prompt = [
+        `You are a process health monitor. A ${toolName} tool call has been running for ${elapsedSec}s.`,
+        `${toolName} ${toolDesc}.`,
+        `Tool input: ${inputSummary}`,
+        tokenLine,
+        backgroundLine,
+        declaredLine,
+        '',
+        `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>',
+    ].filter(Boolean).join('\n');
+    try {
+        if (verbose)
+            hlog(`[TOOL-ASSESS] Running Haiku assessment for ${toolName} (${elapsedSec}s elapsed)...`);
+        return await spawnHaikuVerdict(prompt, claudeCommand, verbose, 'TOOL-ASSESS', TOOL_TIMEOUT_MAX_MINUTES);
+    }
+    catch (err) {
+        if (verbose)
+            hlog(`[TOOL-ASSESS] Haiku assessment failed: ${err}`);
+        return {
+            action: 'extend',
+            extensionMs: 5 * 60_000,
+            reason: `Timeout assessment unavailable (${err instanceof Error ? err.message : String(err)})${backgroundWorkPending ? '; background tasks pending' : ''}`,
+            assessed: false,
+        };
+    }
+}