@minionry/minion 0.7.36

package/dist/server/cli/headless/claude-invoker-process.js

@@ -0,0 +1,614 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { machineFile } from '../../../bin/machine-layout.js';
+import { resolveModelProfile } from '../../engines/credentials/model-profiles.js';
+import { ANTHROPIC_PROVIDER_ID, getApiKey, } from '../../engines/credentials/provider-credentials.js';
+import { isDirectory } from '../../services/pathUtils.js';
+import { profileAllowsBrowserControl } from '../../services/sdk/run-profile.js';
+import { getMaxConcurrentSessions, getSubagentModel, getSubagentModelForce, } from '../../services/settings.js';
+import { mintMcpCapabilityToken, } from '../../services/websocket/ask-user-question-bridge.js';
+import { flushNativeTimeoutBuffers, logFastModeDiagnostic, matchesSessionNotFound, verboseLog } from './claude-invoker-stream.js';
+import { classifyEngineNotice, filterBenignStderr, stderrTailOf } from './engine-notice.js';
+import { herror } from './headless-logger.js';
+import { BROWSER_SYSTEM_PROMPT, generateMcpConfig, isAgentBrowserSurfaceAvailable, removeMcpConfig, resolveAppToolsMcpContext, resolveQualityMcpOptions, sessionGetsQualityMcp, } from './mcp-config.js';
+import { buildMultimodalMessage } from './prompt-utils.js';
+function signalToNumber(signal) {
+    const map = {
+        SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGABRT: 6,
+        SIGKILL: 9, SIGTERM: 15, SIGUSR1: 10, SIGUSR2: 12,
+    };
+    return map[signal];
+}
+function numberToSignal(num) {
+    const map = {
+        1: 'SIGHUP', 2: 'SIGINT', 3: 'SIGQUIT', 6: 'SIGABRT',
+        9: 'SIGKILL', 15: 'SIGTERM', 10: 'SIGUSR1', 12: 'SIGUSR2',
+    };
+    return map[num];
+}
+function deriveSignalName(code, signal) {
+    if (signal)
+        return signal;
+    if (code !== null && code > 128)
+        return numberToSignal(code - 128);
+    return undefined;
+}
+const SPAWN_ERROR_MAP = {
+    EACCES: {
+        code: 'PERMISSION_DENIED',
+        message: 'Permission denied when running Claude Code. Please check file permissions.'
+    },
+    E2BIG: {
+        code: 'SPAWN_ARGS_TOO_LARGE',
+        message: 'Could not launch Claude Code: the command arguments/environment exceeded the OS size limit (E2BIG).'
+    }
+};
+function claudeNotInstalledMessage(command) {
+    let tried;
+    if (command === 'claude') {
+        tried = "`claude` is not on this server's PATH or in Claude Code's install locations (~/.local/bin, ~/.claude/local)";
+    }
+    else if (/[\\/]/.test(command)) {
+        tried = `\`${command}\` does not exist`;
+    }
+    else {
+        tried = `\`${command}\` is not on this server's PATH`;
+    }
+    return `Claude Code is not installed or not in PATH: ${tried}. Install it (https://code.claude.com/docs/en/setup), or set CLAUDE_COMMAND to the full path of the claude executable.`;
+}
+export function classifySpawnError(error, target) {
+    if ((error.code === 'ENOENT' || error.code === 'ENOTDIR') && !isDirectory(target.cwd)) {
+        return {
+            code: 'WORKING_DIRECTORY_NOT_FOUND',
+            message: `Could not start Claude Code: its working directory ${target.cwd} is not a directory — it may have been moved, renamed, or deleted.`,
+        };
+    }
+    if (error.code === 'ENOENT') {
+        return { code: 'CLAUDE_NOT_INSTALLED', message: claudeNotInstalledMessage(target.command) };
+    }
+    return error.code ? SPAWN_ERROR_MAP[error.code] : undefined;
+}
+export function handleSpawnError(error, config, reject) {
+    const mapped = classifySpawnError(error, { command: config.claudeCommand, cwd: resolveSpawnCwd(config) });
+    if (!mapped) {
+        reject(error);
+        return;
+    }
+    const formatted = `[[MINIONRY_ERROR:${mapped.code}]] ${mapped.message}`;
+    if (config.outputCallback) {
+        config.outputCallback(`\n${formatted}\n`);
+    }
+    reject(new Error(formatted));
+}
+function buildSettingsOverride(config) {
+    const override = {};
+    if (config.ultracode || config.effortLevel === 'ultracode') {
+        override.ultracode = true;
+    }
+    if (config.fastMode) {
+        override.fastMode = true;
+    }
+    return Object.keys(override).length > 0 ? JSON.stringify(override) : null;
+}
+export function isOpusTierModel(model) {
+    const normalized = (model ?? '').trim().toLowerCase();
+    const base = normalized.replace(/\[.*\]$/, '');
+    return (base === 'opus' ||
+        /\b(fable|mythos)\b/.test(normalized) ||
+        /claude-opus-(5|4-[78])/.test(normalized) ||
+        /opus-(5|4\.[78])/.test(normalized));
+}
+export function resolveClaudeEffort(model, effortLevel, inferenceOnly = false) {
+    if (!effortLevel)
+        return undefined;
+    const isSentinel = effortLevel === 'auto' ||
+        effortLevel === 'default' ||
+        (inferenceOnly && effortLevel === 'ultracode');
+    if (!isSentinel) {
+        return effortLevel === 'ultracode' ? undefined : effortLevel;
+    }
+    if (isOpusTierModel(model))
+        return inferenceOnly ? 'medium' : 'xhigh';
+    const normalized = (model ?? '').trim().toLowerCase();
+    const base = normalized.replace(/\[.*\]$/, '');
+    const isSonnetTier = base === 'sonnet' || /claude-sonnet-5/.test(normalized) || /sonnet-5/.test(normalized);
+    if (isSonnetTier)
+        return inferenceOnly ? 'medium' : 'high';
+    return undefined;
+}
+export function resolveSubagentModel(mainModel, setting) {
+    const choice = (setting ?? 'auto').trim();
+    if (choice === '' || choice === 'inherit')
+        return undefined;
+    if (choice !== 'auto')
+        return choice;
+    return isOpusTierModel(mainModel) ? 'sonnet' : undefined;
+}
+function resolveEffortArg(config) {
+    if (config.ultracode && !config.inferenceOnly)
+        return undefined;
+    return resolveClaudeEffort(config.model, config.effortLevel, config.inferenceOnly === true);
+}
+export function buildClaudeArgs(config, hasImageAttachments, useStreamJson, mcpConfigPath, 
+browserMcpActive = false) {
+    const args = ['--print'];
+    const profileModel = resolveModelProfile(config.model)?.profile.model;
+    const model = profileModel ?? config.model;
+    if (model && model !== 'default') {
+        args.push('--model', model);
+    }
+    const effort = resolveEffortArg(config);
+    if (effort) {
+        args.push('--effort', effort);
+    }
+    const settingsOverride = config.inferenceOnly ? null : buildSettingsOverride(config);
+    if (settingsOverride) {
+        args.push('--settings', settingsOverride);
+    }
+    if (useStreamJson) {
+        args.push('--output-format', 'stream-json', '--verbose', '--include-partial-messages');
+    }
+    if (hasImageAttachments) {
+        args.push('--input-format', 'stream-json');
+    }
+    if (config.inferenceOnly) {
+        args.push('--tools', '', '--strict-mcp-config');
+        return args;
+    }
+    if (config.claudeSessionId && config.continueSession) {
+        args.push('--resume', config.claudeSessionId);
+    }
+    else if (config.continueSession) {
+        args.push('--continue');
+    }
+    const disallowedTools = [
+        ...new Set([...(config.disallowedTools ?? []), ...(config.appRunProfile?.disallowedTools ?? [])]),
+    ];
+    if (disallowedTools.length > 0) {
+        args.push('--disallowedTools', disallowedTools.join(','));
+    }
+    pushPermissionAndPromptArgs(args, config, mcpConfigPath, browserMcpActive);
+    return args;
+}
+function pushPermissionAndPromptArgs(args, config, mcpConfigPath, browserMcpActive) {
+    if (mcpConfigPath) {
+        args.push('--mcp-config', mcpConfigPath);
+        args.push('--permission-prompt-tool', 'mcp__minionry-bouncer__approval_prompt');
+        if (browserMcpActive) {
+            args.push('--strict-mcp-config');
+        }
+    }
+    else {
+        args.push('--permission-mode', 'acceptEdits');
+    }
+    args.push('--append-system-prompt', 'IMPORTANT: Always use the Read tool to read a file before using Edit or Write on it. Never edit a file you have not read in this session.');
+    if (browserMcpActive) {
+        args.push('--append-system-prompt', BROWSER_SYSTEM_PROMPT);
+    }
+    if (config.appendSystemPrompt) {
+        args.push('--append-system-prompt', config.appendSystemPrompt);
+    }
+}
+function writeTextPromptToStdin(claudeProcess, prompt, config) {
+    claudeProcess.stdin.on('error', (err) => {
+        if (config.verbose) {
+            herror('[STDIN] Prompt write error:', err.message);
+        }
+    });
+    claudeProcess.stdin.write(prompt.replaceAll('\0', ''));
+    claudeProcess.stdin.end();
+}
+function writeImageAttachmentsToStdin(claudeProcess, prompt, config) {
+    claudeProcess.stdin.on('error', (err) => {
+        if (config.verbose) {
+            herror('[STDIN] Write error:', err.message);
+        }
+        config.outputCallback?.(`\n[[MINIONRY_ERROR:STDIN_WRITE_FAILED]] Failed to send image data to Claude: ${err.message}\n`);
+    });
+    const multimodalMessage = buildMultimodalMessage(prompt, config.imageAttachments);
+    claudeProcess.stdin.write(multimodalMessage);
+    claudeProcess.stdin.end();
+}
+const CLAUDE_SUBPROCESS_ENV_DEFAULTS = {
+    CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS: '0',
+    CLAUDE_CODE_ENABLE_TODO_TOOLS: '1',
+};
+function claudeCredentialEnv(model) {
+    const resolved = resolveModelProfile(model);
+    if (resolved) {
+        return {
+            ...(resolved.profile.baseUrl ? { ANTHROPIC_BASE_URL: resolved.profile.baseUrl } : {}),
+            ...(resolved.apiKey ? { ANTHROPIC_AUTH_TOKEN: resolved.apiKey } : {}),
+        };
+    }
+    const key = getApiKey(ANTHROPIC_PROVIDER_ID);
+    return key ? { ANTHROPIC_API_KEY: key } : {};
+}
+function claudeSubagentEnv(model) {
+    const resolved = resolveSubagentModel(model, getSubagentModel());
+    if (!resolved)
+        return {};
+    return {
+        CLAUDE_CODE_SUBAGENT_MODEL: resolved,
+        ...(getSubagentModelForce() ? { CLAUDE_CODE_SUBAGENT_MODEL_FORCE: '1' } : {}),
+    };
+}
+export function buildSpawnEnv(config, processEnv = process.env, credentialEnv = claudeCredentialEnv, subagentEnv = claudeSubagentEnv) {
+    const env = {
+        ...CLAUDE_SUBPROCESS_ENV_DEFAULTS,
+        ...processEnv,
+        ...credentialEnv(config.model),
+        ...subagentEnv(config.model),
+        ...config.extraEnv,
+    };
+    if (env.ENABLE_TOOL_SEARCH === undefined && !env.ANTHROPIC_BASE_URL) {
+        env.ENABLE_TOOL_SEARCH = 'true';
+    }
+    return env;
+}
+const SESSION_SLOT_POLL_MS = 500;
+const SESSION_SLOT_MAX_WAIT_MS = 10 * 60 * 1000;
+const SESSION_SLOT_UNLIMITED_SCAN = 256;
+const SESSION_SLOT_CLAIM_GRACE_MS = 10_000;
+export function sessionSlotsDir() {
+    return machineFile('sessionSlots');
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === 'EPERM';
+    }
+}
+function slotHeld(slot) {
+    let owner = Number.NaN;
+    try {
+        owner = Number.parseInt(readFileSync(join(slot, 'owner'), 'utf8'), 10);
+    }
+    catch {
+    }
+    if (Number.isFinite(owner))
+        return pidAlive(owner);
+    try {
+        return Date.now() - statSync(slot).mtimeMs < SESSION_SLOT_CLAIM_GRACE_MS;
+    }
+    catch {
+        return false;
+    }
+}
+function slotsHeldFrom(dir, from) {
+    let names;
+    try {
+        names = readdirSync(dir);
+    }
+    catch {
+        return false;
+    }
+    return names.some((name) => {
+        const index = name.startsWith('slot-') ? Number(name.slice('slot-'.length)) : Number.NaN;
+        return Number.isInteger(index) && index >= from && slotHeld(join(dir, name));
+    });
+}
+function tryClaimSessionSlot(dir, index) {
+    const slot = join(dir, `slot-${index}`);
+    try {
+        mkdirSync(slot);
+    }
+    catch (err) {
+        if (err.code !== 'EEXIST')
+            return null;
+        if (slotHeld(slot))
+            return null;
+        try {
+            rmSync(slot, { recursive: true, force: true });
+            mkdirSync(slot);
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        writeFileSync(join(slot, 'owner'), String(process.pid));
+    }
+    catch {
+    }
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        try {
+            rmSync(slot, { recursive: true, force: true });
+        }
+        catch {
+        }
+    };
+}
+function claimLowestFreeSlot(dir, count) {
+    for (let index = 0; index < count; index++) {
+        const release = tryClaimSessionSlot(dir, index);
+        if (release)
+            return release;
+    }
+    return null;
+}
+function claimSessionSlot(dir, max) {
+    if (!(max > 0))
+        return claimLowestFreeSlot(dir, SESSION_SLOT_UNLIMITED_SCAN) ?? (() => { });
+    return slotsHeldFrom(dir, max) ? null : claimLowestFreeSlot(dir, max);
+}
+export async function acquireSessionSlot(opts) {
+    const { dir = sessionSlotsDir(), maxWaitMs = SESSION_SLOT_MAX_WAIT_MS, pollMs = SESSION_SLOT_POLL_MS } = opts;
+    const started = Date.now();
+    let waiting = false;
+    for (;;) {
+        const max = opts.max();
+        try {
+            mkdirSync(dir, { recursive: true });
+        }
+        catch {
+            return () => { };
+        }
+        const release = claimSessionSlot(dir, max);
+        if (release)
+            return release;
+        if (Date.now() - started >= maxWaitMs) {
+            herror(`[${new Date().toISOString()}] Session slot wait exceeded ${maxWaitMs}ms with ${max} sessions running — proceeding past the soft cap`);
+            return () => { };
+        }
+        if (!waiting) {
+            waiting = true;
+            opts.onWait?.(max);
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollMs));
+    }
+}
+export async function buildBrowserMcpOptions(config, transport) {
+    if (!config.browserMcp)
+        return undefined;
+    if (!config.appRunProfile || !profileAllowsBrowserControl(config.appRunProfile))
+        return undefined;
+    if (!transport.port || !transport.bouncerSecret || !transport.capabilityToken)
+        return undefined;
+    if (!(await isAgentBrowserSurfaceAvailable()))
+        return undefined;
+    return {
+        ...config.browserMcp,
+        port: transport.port,
+        bouncerSecret: transport.bouncerSecret,
+        capabilityToken: transport.capabilityToken,
+    };
+}
+export function resolveSpawnCwd(config) {
+    return config.appRunProfile?.cwd ?? config.workingDir;
+}
+function browserChildCapability(spaceDir, run) {
+    return {
+        spaceDir,
+        agentId: run.agentId,
+        ...(run.agentLabel ? { agentLabel: run.agentLabel } : {}),
+        ...(run.planId ? { planId: run.planId } : {}),
+        ...(run.defaultTabId ? { defaultTabId: run.defaultTabId } : {}),
+        ...(run.agentSessionId ? { agentSessionId: run.agentSessionId } : {}),
+    };
+}
+export function mintSpawnMcpRouting(config) {
+    const minted = [];
+    const mint = (capability) => {
+        const entry = mintMcpCapabilityToken(capability);
+        minted.push(entry);
+        return entry.token;
+    };
+    const attribution = {
+        ...(config.agentId ? { agentId: config.agentId } : {}),
+        ...(config.planId ? { planId: config.planId } : {}),
+    };
+    const askUserQuestionRouting = config.tabId && config.minionryPort && config.bouncerSecret
+        ? {
+            tabId: config.tabId,
+            port: config.minionryPort,
+            bouncerSecret: config.bouncerSecret,
+            capabilityToken: mint({ spaceDir: config.workingDir, tabId: config.tabId, ...attribution }),
+        }
+        : undefined;
+    return {
+        askUserQuestionRouting,
+        appToolsTransport: {
+            port: config.minionryPort,
+            bouncerSecret: config.bouncerSecret,
+            ...(config.appTools
+                ? {
+                    capabilityToken: mint({
+                        spaceDir: config.appTools.spaceDir,
+                        ...(config.appTools.onlyAppId ? { onlyAppId: config.appTools.onlyAppId } : {}),
+                        ...attribution,
+                    }),
+                }
+                : {}),
+        },
+        browserTransport: {
+            port: config.minionryPort,
+            bouncerSecret: config.bouncerSecret,
+            ...(config.browserMcp
+                ? { capabilityToken: mint(browserChildCapability(config.workingDir, config.browserMcp)) }
+                : {}),
+        },
+        qualityTransport: {
+            port: config.minionryPort,
+            bouncerSecret: config.bouncerSecret,
+            ...(sessionGetsQualityMcp(config)
+                ? {
+                    capabilityToken: mint({ spaceDir: config.workingDir, tabId: config.tabId, ...attribution }),
+                }
+                : {}),
+        },
+        revokeAll: () => {
+            for (const entry of minted.splice(0))
+                entry.revoke();
+        },
+    };
+}
+export async function spawnAndRegister(config, prompt, hasImageAttachments, useStreamJson, runningProcesses, perfStart) {
+    if (config.inferenceOnly) {
+        const inferenceArgs = buildClaudeArgs(config, hasImageAttachments, useStreamJson, null);
+        return spawnClaude(config, prompt, hasImageAttachments, inferenceArgs, runningProcesses, perfStart);
+    }
+    const mcpRouting = mintSpawnMcpRouting(config);
+    const { askUserQuestionRouting } = mcpRouting;
+    const appTools = await resolveAppToolsMcpContext(config.appTools, mcpRouting.appToolsTransport);
+    const browserMcp = await buildBrowserMcpOptions(config, mcpRouting.browserTransport);
+    const qualityMcp = resolveQualityMcpOptions(config, mcpRouting.qualityTransport);
+    const mcpConfigPath = config.inferenceOnly
+        ? null
+        : generateMcpConfig(config.workingDir, config.verbose, {
+            userPrompt: prompt,
+            sessionId: randomUUID(),
+            deployMode: config.deployMode,
+            askUserQuestionRouting,
+            ...(config.appRunProfile
+                ? {
+                    sdkAppRun: {
+                        appId: config.appRunProfile.appId,
+                        origin: config.appRunProfile.origin,
+                        scopes: config.appRunProfile.scopes,
+                        workspaceDir: config.workingDir,
+                        sandboxDir: config.appRunProfile.cwd,
+                    },
+                }
+                : {}),
+            ...(appTools ? { appTools } : {}),
+            ...(browserMcp ? { browserMcp } : {}),
+            ...(qualityMcp ? { qualityMcp } : {}),
+        });
+    if (!mcpConfigPath && !config.inferenceOnly && config.outputCallback) {
+        config.outputCallback('\n[[MINIONRY_ERROR:BOUNCER_UNAVAILABLE]] Security bouncer not available. Running with limited permissions — file edits allowed, but shell commands may be restricted.\n');
+    }
+    const browserMcpActive = !!browserMcp && !!mcpConfigPath;
+    const args = buildClaudeArgs(config, hasImageAttachments, useStreamJson, mcpConfigPath, browserMcpActive);
+    try {
+        const claudeProcess = await spawnClaude(config, prompt, hasImageAttachments, args, runningProcesses, perfStart);
+        claudeProcess.once('close', mcpRouting.revokeAll);
+        claudeProcess.once('error', mcpRouting.revokeAll);
+        claudeProcess.once('close', () => removeMcpConfig(mcpConfigPath));
+        claudeProcess.once('error', () => removeMcpConfig(mcpConfigPath));
+        return claudeProcess;
+    }
+    catch (err) {
+        mcpRouting.revokeAll();
+        removeMcpConfig(mcpConfigPath);
+        throw err;
+    }
+}
+async function spawnClaude(config, prompt, hasImageAttachments, args, runningProcesses, perfStart) {
+    verboseLog(config.verbose, `[PERF] About to spawn: ${Date.now() - perfStart}ms`, `[PERF] Command: ${config.claudeCommand} ${args.join(' ')} (prompt: ${prompt.length} chars via stdin)`);
+    const releaseSlot = config.inferenceOnly
+        ? () => { }
+        : await acquireSessionSlot({
+            max: getMaxConcurrentSessions,
+            onWait: (max) => config.outputCallback?.(`\n⏳ Waiting for a free agent session slot — ${max} already running on this machine; starting anyway in ${SESSION_SLOT_MAX_WAIT_MS / 60_000} min (Space settings → Power → Max concurrent sessions)…\n`),
+        });
+    const spawnEnv = buildSpawnEnv(config);
+    let claudeProcess;
+    try {
+        claudeProcess = spawn(config.claudeCommand, args, {
+            cwd: resolveSpawnCwd(config),
+            detached: true,
+            env: spawnEnv,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+    }
+    catch (err) {
+        releaseSlot();
+        return new Promise((_resolve, reject) => {
+            handleSpawnError(err, config, reject);
+        });
+    }
+    claudeProcess.once('close', releaseSlot);
+    claudeProcess.once('error', releaseSlot);
+    if (claudeProcess.stdin) {
+        if (hasImageAttachments) {
+            writeImageAttachmentsToStdin(claudeProcess, prompt, config);
+        }
+        else {
+            writeTextPromptToStdin(claudeProcess, prompt, config);
+        }
+    }
+    if (claudeProcess.pid) {
+        runningProcesses.set(claudeProcess.pid, claudeProcess);
+    }
+    verboseLog(config.verbose, `[PERF] Spawned: ${Date.now() - perfStart}ms`);
+    return claudeProcess;
+}
+function backgroundExitState(ctx) {
+    const bg = ctx.backgroundActivity;
+    const pendingTaskCount = bg.pendingTasks.size;
+    const armedWakeup = bg.wakeup && bg.wakeup.fireAtMs > Date.now() ? { ...bg.wakeup } : undefined;
+    return {
+        backgroundTasksPendingAtExit: pendingTaskCount > 0 ? pendingTaskCount : undefined,
+        pendingWakeup: armedWakeup,
+        pendingBackgroundTasks: pendingTaskCount > 0
+            ? Array.from(bg.pendingTasks.values()).map((t) => ({
+                taskId: t.taskId,
+                ...(t.description ? { description: t.description } : {}),
+                ...(t.taskType ? { taskType: t.taskType } : {}),
+            }))
+            : undefined,
+    };
+}
+function resolveCloseNotice(ctx, actionableStderr) {
+    if (ctx.engineNotice)
+        return ctx.engineNotice;
+    return classifyEngineNotice(actionableStderr, 'stderr') ?? undefined;
+}
+function closeOutcomeFields(ctx, stderr, actionableStderr, startedAt) {
+    return {
+        engineNotice: resolveCloseNotice(ctx, actionableStderr),
+        resultSubtype: ctx.resultSubtype,
+        terminalReason: ctx.terminalReason,
+        resultIsError: ctx.resultIsError,
+        stderrTail: stderrTailOf(stderr),
+        firstEventLatencyMs: startedAt !== undefined && ctx.firstEventAt !== undefined ? ctx.firstEventAt - startedAt : undefined,
+        startupTimedOut: ctx.startupTimedOut || undefined,
+    };
+}
+export function buildCloseResult(ctx, stdout, stderr, code, signal, sessionCapture, startedAt) {
+    const postTimeout = flushNativeTimeoutBuffers(ctx);
+    logFastModeDiagnostic(ctx);
+    const resumeBuffered = ctx.resumeAssessmentActive ? (ctx.resumeAssessmentBuffer || undefined) : undefined;
+    const exitCode = code ?? (signal ? 128 + (signalToNumber(signal) ?? 0) : 0);
+    const signalName = deriveSignalName(code, signal);
+    const u = ctx.apiTokenUsage;
+    const hasTokenUsage = u.inputTokens > 0 || u.outputTokens > 0 || u.cacheCreationTokens > 0 || u.cacheReadTokens > 0;
+    const actionableStderr = filterBenignStderr(stderr);
+    return {
+        output: stdout,
+        error: actionableStderr || undefined,
+        exitCode,
+        signalName: signalName || undefined,
+        ...closeOutcomeFields(ctx, stderr, actionableStderr, startedAt),
+        assistantResponse: ctx.accumulatedAssistantResponse || undefined,
+        thinkingOutput: ctx.accumulatedThinking || undefined,
+        toolUseHistory: ctx.accumulatedToolUse.length > 0 ? ctx.accumulatedToolUse : undefined,
+        claudeSessionId: sessionCapture.claudeSessionId,
+        nativeTimeoutCount: ctx.nativeTimeoutDetector.timeoutCount || undefined,
+        postTimeoutOutput: postTimeout,
+        resumeBufferedOutput: resumeBuffered,
+        apiTokenUsage: hasTokenUsage ? { ...ctx.apiTokenUsage } : undefined,
+        stopReason: ctx.stopReason,
+        sessionNotFound: ctx.sessionNotFound || matchesSessionNotFound(stderr) || undefined,
+        failedMcpServers: ctx.failedMcpServers,
+        interrupted: ctx.resultInterrupted || undefined,
+        ...backgroundExitState(ctx),
+    };
+}
+export function spawnProvedEngineAvailable(result) {
+    if (result.engineNotice && result.engineNotice.kind !== 'server_error')
+        return false;
+    return Boolean(result.assistantResponse) || (result.toolUseHistory?.length ?? 0) > 0;
+}