@mono-agent/agent-app 0.6.2 → 0.8.0

package/dist/readiness-probe.js

@@ -0,0 +1,780 @@
+import { createHash } from "node:crypto";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Worker } from "node:worker_threads";
+import { loadAppCoreConfig } from "./app-config.js";
+import { validateMonoAgentFolder } from "./doctor.js";
+const CLOUD_READINESS_TIMEOUT_MS = 90_000;
+const LOCAL_READINESS_TIMEOUT_MS = 240_000;
+const MAX_SAFE_MESSAGE_CHARS = 400;
+const WORKER_SHUTDOWN_GRACE_MS = 1_000;
+const LOCAL_PI_PROVIDERS = new Set(["ollama", "lmstudio", "llamacpp"]);
+const SENSITIVE_ENV_NAME = /(api.?key|credential|password|secret|token)/iu;
+const SENSITIVE_FINGERPRINT_KEY = /(api.?key|authorization|cookie|credential|password|secret|token)/iu;
+/** Provider-aware hard deadline for the one-turn primary-model probe. */
+export function readinessProbeTimeoutMs(model) {
+    return model.sdk === "pi" && model.provider !== undefined && LOCAL_PI_PROVIDERS.has(model.provider)
+        ? LOCAL_READINESS_TIMEOUT_MS
+        : CLOUD_READINESS_TIMEOUT_MS;
+}
+/**
+ * The probe must not inherit a configured agent from the shell it happens to
+ * run in. Provider auth/runtime variables remain available, while every
+ * ambient MONO_AGENT_* override is excluded before layered config loading.
+ * Selected wizard secrets are an in-memory overlay and are intentionally added
+ * afterwards; they are never written to the disposable workspace.
+ */
+export function readinessProbeEnvironment(hostEnv, secretValues = {}, options = {}) {
+    const sanitized = Object.fromEntries(Object.entries(hostEnv).filter((entry) => !entry[0].startsWith("MONO_AGENT_") && typeof entry[1] === "string"));
+    const piAuthPath = options.resolvedPiAuthPath?.trim();
+    return {
+        ...sanitized,
+        ...secretValues,
+        ...(piAuthPath === undefined || piAuthPath.length === 0
+            ? {}
+            : { MONO_AGENT_PI_AUTH_PATH: piAuthPath }),
+    };
+}
+function safeMessage(value, secretValues, fallback) {
+    let message = typeof value === "string"
+        ? value
+        : value instanceof Error
+            ? value.message
+            : value === null || value === undefined
+                ? fallback
+                : String(value);
+    for (const secret of Object.values(secretValues)) {
+        if (secret.length >= 4) {
+            message = message.replaceAll(secret, "[REDACTED]");
+        }
+    }
+    message = message
+        .replace(/\bBearer\s+[^\s,;]+/giu, "Bearer [REDACTED]")
+        .replace(/\b(api[ _-]?key|access[ _-]?token|auth[ _-]?token|password|secret)(\s*[=:]\s*)([^\s,;]+)/giu, (_match, label, separator) => `${label}${separator}[REDACTED]`)
+        .replace(/\s+/gu, " ")
+        .trim();
+    if (message.length === 0) {
+        return fallback;
+    }
+    return message.length > MAX_SAFE_MESSAGE_CHARS
+        ? `${message.slice(0, MAX_SAFE_MESSAGE_CHARS - 1)}…`
+        : message;
+}
+function redactionValues(hostEnv, secretValues) {
+    const sensitiveHostValues = Object.fromEntries(Object.entries(hostEnv).filter((entry) => SENSITIVE_ENV_NAME.test(entry[0]) && typeof entry[1] === "string" && entry[1].length > 0));
+    return { ...sensitiveHostValues, ...secretValues };
+}
+const DIRECT_TOOL_EVENT_TYPES = new Set([
+    "bash",
+    "collab_agent_tool_call",
+    "command_execution",
+    "dynamic_tool_call",
+    "file_change",
+    "image_generation",
+    "image_view",
+    "mcp_tool_call",
+    "sleep",
+    "subagent_activity",
+    "tool_call",
+    "tool_result",
+    "tool_use",
+    "web_search",
+]);
+function normalizedEventType(value) {
+    return typeof value === "string"
+        ? value.replace(/([a-z0-9])([A-Z])/gu, "$1_$2").replace(/[./-]+/gu, "_").toLowerCase()
+        : "";
+}
+function toolActionInEvent(event) {
+    const eventType = normalizedEventType(event.type);
+    if (DIRECT_TOOL_EVENT_TYPES.has(eventType)) {
+        return eventType;
+    }
+    const item = event.item;
+    if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        const itemType = normalizedEventType(item.type);
+        if (DIRECT_TOOL_EVENT_TYPES.has(itemType)) {
+            return itemType;
+        }
+    }
+    const message = event.message;
+    if (typeof message !== "object" || message === null || Array.isArray(message)) {
+        return undefined;
+    }
+    const content = message.content;
+    if (!Array.isArray(content)) {
+        return undefined;
+    }
+    for (const block of content) {
+        if (typeof block !== "object" || block === null || Array.isArray(block)) {
+            continue;
+        }
+        const blockType = normalizedEventType(block.type);
+        if (blockType === "tool_use" || blockType === "tool_call" || blockType === "tool_result") {
+            return blockType;
+        }
+    }
+    return undefined;
+}
+function positiveTimeout(value, model) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0
+        ? Math.trunc(value)
+        : readinessProbeTimeoutMs(model);
+}
+function isReadinessWorkerMessage(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const message = value;
+    if (message.type === "disposed") {
+        return true;
+    }
+    if (message.type === "error") {
+        return typeof message.message === "string" && message.message.length <= MAX_SAFE_MESSAGE_CHARS;
+    }
+    if (message.type === "tool") {
+        return typeof message.action === "string" && DIRECT_TOOL_EVENT_TYPES.has(message.action);
+    }
+    return message.type === "result"
+        && typeof message.hasText === "boolean"
+        && typeof message.cancelled === "boolean"
+        && (message.failureKind === undefined
+            || (typeof message.failureKind === "string" && message.failureKind.length <= MAX_SAFE_MESSAGE_CHARS))
+        && (message.errorMessage === undefined
+            || (typeof message.errorMessage === "string" && message.errorMessage.length <= MAX_SAFE_MESSAGE_CHARS));
+}
+function workerResult(message) {
+    return {
+        text: message.hasText ? "ready" : "",
+        ...(message.cancelled ? { cancelled: true } : {}),
+        ...(message.failureKind === undefined ? {} : { failureKind: message.failureKind }),
+        ...(message.errorMessage === undefined ? {} : { error: message.errorMessage }),
+    };
+}
+function startReadinessWorker(input) {
+    const model = input.runtime.model;
+    const worker = new Worker(input.workerUrl ?? new URL("./readiness-probe-worker.js", import.meta.url), {
+        // The parent has already loaded and validated the disposable config. Only
+        // this clone-safe, credential-free execution spec crosses workerData.
+        workerData: {
+            cwd: input.cwd,
+            runtime: {
+                model: {
+                    sdk: model.sdk,
+                    model: model.model,
+                    ...(model.provider === undefined ? {} : { provider: model.provider }),
+                    ...(model.reference === undefined ? {} : { reference: model.reference }),
+                },
+                ...(input.runtime.executionMode === undefined
+                    ? {}
+                    : { executionMode: input.runtime.executionMode }),
+                ...(input.runtime.effort === undefined ? {} : { effort: input.runtime.effort }),
+                workspace: input.runtime.workspace,
+                artifactDir: input.runtime.artifactDir,
+                ...(input.runtime.piAuthPath === undefined ? {} : { piAuthPath: input.runtime.piAuthPath }),
+            },
+        },
+        env: { ...input.env },
+        // Provider SDKs must not be able to leak credentials through inherited
+        // worker stdout/stderr. The streams are deliberately drained below.
+        stdout: true,
+        stderr: true,
+    });
+    worker.stdout?.resume();
+    worker.stderr?.resume();
+    let exited = false;
+    let outcomeSettled = false;
+    let resolveOutcome;
+    let resolveStopped;
+    const stopped = new Promise((resolve) => {
+        resolveStopped = resolve;
+    });
+    const outcome = new Promise((resolve) => {
+        resolveOutcome = resolve;
+    });
+    const settleOutcome = (next) => {
+        if (!outcomeSettled) {
+            outcomeSettled = true;
+            resolveOutcome?.(next);
+        }
+    };
+    const abort = () => {
+        if (exited) {
+            return;
+        }
+        try {
+            worker.postMessage({ type: "abort" });
+        }
+        catch {
+            // The worker exited between the state check and postMessage.
+        }
+    };
+    worker.on("message", (value) => {
+        if (!isReadinessWorkerMessage(value)) {
+            settleOutcome({ type: "error", error: new Error("The isolated readiness worker returned an invalid response.") });
+            abort();
+            return;
+        }
+        if (value.type === "disposed") {
+            resolveStopped?.();
+            return;
+        }
+        if (value.type === "error") {
+            settleOutcome({ type: "error", error: new Error(value.message) });
+            return;
+        }
+        if (value.type === "tool") {
+            settleOutcome({ type: "tool", action: value.action });
+            abort();
+            return;
+        }
+        settleOutcome({ type: "result", result: workerResult(value) });
+    });
+    worker.once("error", () => {
+        // Deliberately discard the worker error object: a provider SDK may include
+        // credential-bearing request details in it.
+        settleOutcome({ type: "error", error: new Error("The isolated readiness worker failed.") });
+        resolveStopped?.();
+    });
+    worker.once("exit", () => {
+        exited = true;
+        settleOutcome({ type: "error", error: new Error("The isolated readiness worker exited before returning a result.") });
+        resolveStopped?.();
+    });
+    return {
+        outcome,
+        abort,
+        async shutdown() {
+            abort();
+            let timer;
+            try {
+                await Promise.race([
+                    stopped,
+                    new Promise((resolve) => {
+                        timer = setTimeout(resolve, WORKER_SHUTDOWN_GRACE_MS);
+                    }),
+                ]);
+            }
+            finally {
+                if (timer !== undefined) {
+                    clearTimeout(timer);
+                }
+                if (!exited) {
+                    // disposeAllSessions in the worker is best-effort and bounded. A
+                    // provider that ignores both abort and disposal cannot keep worker JS
+                    // alive. Any SDK-spawned orphan still has only the worker's exact env.
+                    await worker.terminate().catch(() => undefined);
+                }
+            }
+        },
+    };
+}
+function selectedReadinessRoutes(plan, options = {}) {
+    const runtime = (plan.configJson.runtime ?? {});
+    const primary = typeof runtime.model === "string" ? runtime.model : "";
+    const inheritedEffort = typeof runtime.effort === "string" ? runtime.effort : undefined;
+    const authored = [];
+    if (primary.length > 0) {
+        authored.push({ model: primary, ...(inheritedEffort === undefined ? {} : { effort: inheritedEffort }) });
+    }
+    // Canonical fallbacks have independent effort semantics: omission means the
+    // provider default, not inheritance from the primary route.
+    if (Array.isArray(runtime.fallbacks)) {
+        for (const raw of runtime.fallbacks) {
+            if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+                continue;
+            const entry = raw;
+            if (typeof entry.model !== "string" || entry.model.length === 0)
+                continue;
+            authored.push({
+                model: entry.model,
+                ...(typeof entry.effort === "string" ? { effort: entry.effort } : {}),
+            });
+        }
+    }
+    else if (Array.isArray(runtime.fallbackModels)) {
+        // Legacy fallbackModels intentionally retain their historical inheritance.
+        for (const model of runtime.fallbackModels) {
+            if (typeof model !== "string" || model.length === 0)
+                continue;
+            authored.push({ model, ...(inheritedEffort === undefined ? {} : { effort: inheritedEffort }) });
+        }
+    }
+    const immutableRoutes = authored.map((route, index) => ({ index, model: route.model, effort: route.effort ?? null }));
+    const executionRuntime = { ...runtime };
+    delete executionRuntime.model;
+    delete executionRuntime.effort;
+    delete executionRuntime.fallbacks;
+    delete executionRuntime.fallbackModels;
+    delete executionRuntime.session;
+    delete executionRuntime.workspace;
+    const nonSecretEnvironment = Object.fromEntries(Object.entries(options.hostEnv ?? process.env)
+        .filter((entry) => typeof entry[1] === "string"
+        && !SENSITIVE_ENV_NAME.test(entry[0])
+        && !entry[0].startsWith("MONO_AGENT_"))
+        .sort(([left], [right]) => left.localeCompare(right)));
+    const immutable = canonicalFingerprintValue({
+        version: 2,
+        routes: immutableRoutes,
+        runtime: executionRuntime,
+        providers: plan.configJson.providers ?? null,
+        resolvedPiAuthPath: options.resolvedPiAuthPath ?? null,
+        nonSecretEnvironment,
+        selectedSecretNames: Object.keys(options.secretValues ?? {}).sort(),
+        timeoutMs: options.timeoutMs ?? null,
+    });
+    const fingerprint = createHash("sha256")
+        .update(JSON.stringify(immutable))
+        .digest("hex");
+    return {
+        fingerprint,
+        routes: authored.map((route, index) => ({
+            index,
+            ...route,
+            key: createHash("sha256")
+                .update(JSON.stringify({ version: 1, index, model: route.model, effort: route.effort ?? null }))
+                .digest("hex"),
+        })),
+    };
+}
+function canonicalFingerprintValue(value, key = "") {
+    if (SENSITIVE_FINGERPRINT_KEY.test(key))
+        return "[secret-redacted]";
+    if (Array.isArray(value))
+        return value.map((entry) => canonicalFingerprintValue(entry));
+    if (typeof value !== "object" || value === null)
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([entryKey, entryValue]) => [entryKey, canonicalFingerprintValue(entryValue, entryKey)]));
+}
+function singleRouteWizardPlan(plan, route) {
+    const configJson = structuredClone(plan.configJson);
+    const runtime = {
+        ...(configJson.runtime ?? {}),
+        model: route.model,
+    };
+    delete runtime.fallbacks;
+    delete runtime.fallbackModels;
+    delete runtime.session;
+    if (route.effort === undefined)
+        delete runtime.effort;
+    else
+        runtime.effort = route.effort;
+    configJson.runtime = runtime;
+    return { ...plan, configJson: configJson };
+}
+/**
+ * Make one real, sequential no-tool turn for every selected persistent runtime
+ * route. A route is never allowed to invoke its configured fallback chain.
+ * Ordinary failures are collected so the operator gets one complete summary;
+ * caller cancellation stops the current route and records interruption state.
+ */
+export async function runReadinessProbe(options) {
+    const selected = selectedReadinessRoutes(options.plan, options);
+    if (selected.routes.length <= 1 && options.resume === undefined) {
+        return runSingleReadinessProbe(options);
+    }
+    return runSelectedReadinessRoutes(options, selected);
+}
+/**
+ * Always return the ordered route ledger, including for a primary-only plan.
+ * Guided setup uses this surface so a successful call can be resumed by its
+ * stable key; legacy callers may keep using runReadinessProbe's compact result.
+ */
+export async function runAllRouteReadinessProbe(options) {
+    return runSelectedReadinessRoutes(options, selectedReadinessRoutes(options.plan, options));
+}
+async function runSelectedReadinessRoutes(options, selected) {
+    if (selected.routes.length === 0) {
+        return {
+            ok: false,
+            kind: "invalid_plan",
+            message: "The readiness plan does not contain a selected runtime model.",
+            planFingerprint: selected.fingerprint,
+            routes: [],
+        };
+    }
+    const mayResume = options.resume?.planFingerprint === selected.fingerprint;
+    const successful = mayResume
+        ? new Set(options.resume?.successfulRouteKeys ?? [])
+        : new Set();
+    const results = [];
+    for (const route of selected.routes) {
+        const displayRoute = {
+            ...route,
+            model: boundedRouteField(route.model, 200),
+            ...(route.effort === undefined ? {} : { effort: boundedRouteField(route.effort, 32) }),
+        };
+        await notifyReadinessProgress(options.onRouteStart, {
+            ...displayRoute,
+            total: selected.routes.length,
+        });
+        if (options.abortSignal?.aborted === true) {
+            const completed = {
+                ...displayRoute,
+                status: "interrupted",
+                kind: "cancelled",
+                message: "The route check was interrupted before it started.",
+            };
+            results.push(completed);
+            await notifyReadinessProgress(options.onRouteComplete, completed);
+            return {
+                ok: false,
+                kind: "cancelled",
+                message: `Readiness was interrupted after ${results.filter((entry) => entry.status === "verified" || entry.status === "skipped_verified").length} of ${selected.routes.length} routes were verified.`,
+                planFingerprint: selected.fingerprint,
+                routes: results,
+                interrupted: true,
+            };
+        }
+        if (successful.has(route.key)) {
+            const completed = { ...displayRoute, status: "skipped_verified" };
+            results.push(completed);
+            await notifyReadinessProgress(options.onRouteComplete, completed);
+            continue;
+        }
+        const { resume: _resume, ...singleOptions } = options;
+        const result = await runSingleReadinessProbe({
+            ...singleOptions,
+            plan: singleRouteWizardPlan(options.plan, route),
+        });
+        if (result.ok) {
+            const completed = { ...displayRoute, status: "verified" };
+            results.push(completed);
+            await notifyReadinessProgress(options.onRouteComplete, completed);
+            continue;
+        }
+        const interrupted = result.kind === "cancelled";
+        const completed = {
+            ...displayRoute,
+            status: interrupted ? "interrupted" : "failed",
+            kind: result.kind,
+            message: result.message,
+        };
+        results.push(completed);
+        await notifyReadinessProgress(options.onRouteComplete, completed);
+        if (interrupted) {
+            return {
+                ok: false,
+                kind: "cancelled",
+                message: `Readiness was interrupted while checking route ${route.index + 1} of ${selected.routes.length}.`,
+                planFingerprint: selected.fingerprint,
+                routes: results,
+                interrupted: true,
+            };
+        }
+    }
+    const failures = results.filter((entry) => entry.status === "failed");
+    if (failures.length > 0) {
+        const first = failures[0];
+        return {
+            ok: false,
+            kind: first?.kind ?? "provider_failed",
+            message: `${failures.length} of ${selected.routes.length} runtime route checks failed. ${first?.model ?? "Selected route"}: ${first?.message ?? "provider failure"}`,
+            planFingerprint: selected.fingerprint,
+            routes: results,
+        };
+    }
+    return { ok: true, planFingerprint: selected.fingerprint, routes: results };
+}
+async function notifyReadinessProgress(callback, value) {
+    try {
+        await callback?.(value);
+    }
+    catch {
+        // Rendering/progress observers never alter readiness semantics.
+    }
+}
+function boundedRouteField(value, limit) {
+    const normalized = value.replace(/[\u0000-\u001f\u007f]/gu, " ").replace(/\s+/gu, " ").trim();
+    return normalized.length <= limit ? normalized : `${normalized.slice(0, Math.max(0, limit - 1))}…`;
+}
+/** Run exactly one route with no fallback chain. */
+async function runSingleReadinessProbe(options) {
+    const selectedModel = options.plan.configJson.runtime?.model;
+    if (typeof selectedModel === "string" && selectedModel.startsWith("opencode:")) {
+        return {
+            ok: false,
+            kind: "unsupported_guided_probe",
+            message: "Direct opencode:* is an advanced config-only backend and cannot run the guided no-tool readiness probe. " +
+                "Choose pi:opencode-go:<model>, or use non-interactive --model opencode:<provider>:<model> scaffolding and validate the explicit runtime.permissionMode configuration.",
+        };
+    }
+    const dir = await mkdtemp(join(tmpdir(), "mono-agent-readiness-"));
+    const secrets = options.secretValues ?? {};
+    const safeValues = redactionValues(options.hostEnv ?? process.env, secrets);
+    try {
+        const config = structuredClone(options.plan.configJson);
+        config.tools = { allowedTools: [], disallowedTools: [] };
+        const runtime = config.runtime;
+        config.runtime = { ...runtime, workspace: ".mono-agent/workspace" };
+        delete config.runtime.fallbackModels;
+        delete config.runtime.fallbacks;
+        delete config.runtime.session;
+        delete config.memory;
+        delete config.artifacts;
+        delete config.traceability;
+        delete config.observability;
+        const providers = config.providers;
+        if (providers?.piNative !== undefined && typeof providers.piNative === "object" && providers.piNative !== null) {
+            const piNative = { ...providers.piNative };
+            delete piNative.piSessionsRoot;
+            config.providers = { ...providers, piNative };
+        }
+        delete config.webhook;
+        delete config.telegram;
+        delete config.slack;
+        delete config.openaiApi;
+        delete config.cron;
+        // The target's context can point to files outside this ephemeral workspace.
+        // A probe validates a known-good, self-contained identity instead.
+        config.context = { identityPath: "./IDENTITY.md", selectedSkills: [] };
+        await writeFile(join(dir, "mono-agent.config.json"), `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+        await writeFile(join(dir, "IDENTITY.md"), "# Readiness probe identity\n\nYou are checking that the selected model can produce one concise response.\n", { mode: 0o600 });
+        await mkdir(join(dir, ".mono-agent", "workspace"), { recursive: true });
+        await mkdir(join(dir, ".mono-agent", "artifacts"), { recursive: true });
+        const overlay = readinessProbeEnvironment(options.hostEnv ?? process.env, secrets, {
+            ...(options.resolvedPiAuthPath === undefined ? {} : { resolvedPiAuthPath: options.resolvedPiAuthPath }),
+        });
+        const loaded = await loadAppCoreConfig({
+            cwd: dir,
+            configPath: join(dir, "mono-agent.config.json"),
+            env: overlay,
+        });
+        // This checks the generated config plus its IDENTITY.md before contacting a
+        // provider. No channel driver is loaded, no liveness probe runs, and writes
+        // are disabled; the disposable probe remains side-effect free.
+        const validation = await validateMonoAgentFolder({
+            cwd: dir,
+            configPath: join(dir, "mono-agent.config.json"),
+            env: overlay,
+            drivers: [],
+            liveness: false,
+            allowFilesystemWrites: false,
+            codexNoToolsProbe: true,
+        });
+        if (!validation.ok) {
+            return {
+                ok: false,
+                kind: "invalid_plan",
+                message: safeMessage(validation.sections.flatMap((section) => section.details).join(" "), safeValues, "The generated primary-model probe configuration is invalid."),
+            };
+        }
+        let firstToolAction;
+        const timeoutMs = positiveTimeout(options.timeoutMs, loaded.runtime.model);
+        const controller = new AbortController();
+        let resolveToolOutcome;
+        const toolOutcome = new Promise((resolve) => {
+            resolveToolOutcome = resolve;
+        });
+        let callerAbortListener;
+        const callerCancellation = new Promise((resolve) => {
+            if (options.abortSignal === undefined) {
+                return;
+            }
+            callerAbortListener = () => {
+                // Settle this race branch before aborting the provider. A runtime may
+                // synchronously reject on abort; the caller's cancellation must remain
+                // the reported reason.
+                resolve({ type: "cancelled" });
+                controller.abort();
+            };
+            if (options.abortSignal.aborted) {
+                callerAbortListener();
+            }
+            else {
+                options.abortSignal.addEventListener("abort", callerAbortListener, { once: true });
+            }
+        });
+        const runOptions = {
+            model: loaded.runtime.model,
+            ...(loaded.runtime.executionMode === undefined ? {} : { executionMode: loaded.runtime.executionMode }),
+            ...(loaded.runtime.effort === undefined ? {} : { effort: loaded.runtime.effort }),
+            messages: [{ role: "user", content: "Reply with a short readiness acknowledgement." }],
+            abortSignal: controller.signal,
+            cwd: dir,
+            maxTurns: 1,
+            allowedTools: [],
+            disallowedTools: [],
+            mcpServers: {},
+            // Codex app-server has no general allowlist. This dedicated mode uses a
+            // read-only/never-approve payload and fails on the first tool action.
+            codexNoToolsProbe: true,
+            onEvent: (event) => {
+                const action = toolActionInEvent(event);
+                if (action !== undefined && firstToolAction === undefined) {
+                    firstToolAction = action;
+                    // As with caller cancellation, publish the policy failure before
+                    // aborting so an abort-triggered provider rejection cannot mask it.
+                    resolveToolOutcome?.({ type: "tool", action });
+                    controller.abort();
+                }
+            },
+            sessionKeepAlive: false,
+            // The production runtime receives this environment through worker
+            // isolation. The explicit immutable copy gives injected runs the same
+            // deterministic contract without replacing the host process environment.
+            providerEnv: Object.freeze({ ...overlay }),
+        };
+        let workerHandle;
+        let workerAbortListener;
+        let providerOutcome;
+        if (options.abortSignal?.aborted === true) {
+            providerOutcome = new Promise(() => { });
+        }
+        else if (options.run !== undefined) {
+            const injectedRun = options.run;
+            const runPromise = Promise.resolve().then(() => injectedRun({ config: loaded, options: runOptions }));
+            // The timeout wins independently of provider abort support. Keep an explicit
+            // rejection consumer because an ignored abort may settle after we return.
+            void runPromise.catch(() => { });
+            providerOutcome = runPromise.then((result) => ({ type: "result", result }), (error) => ({ type: "error", error }));
+        }
+        else {
+            try {
+                workerHandle = startReadinessWorker({
+                    cwd: dir,
+                    runtime: {
+                        model: loaded.runtime.model,
+                        ...(loaded.runtime.executionMode === undefined
+                            ? {}
+                            : { executionMode: loaded.runtime.executionMode }),
+                        ...(loaded.runtime.effort === undefined ? {} : { effort: loaded.runtime.effort }),
+                        workspace: loaded.runtime.workspace,
+                        artifactDir: loaded.artifacts.dir,
+                        ...(loaded.providers?.piAuthPath === undefined
+                            ? {}
+                            : { piAuthPath: loaded.providers.piAuthPath }),
+                    },
+                    env: overlay,
+                    ...(options.workerUrl === undefined ? {} : { workerUrl: options.workerUrl }),
+                });
+                workerAbortListener = () => workerHandle?.abort();
+                controller.signal.addEventListener("abort", workerAbortListener, { once: true });
+                providerOutcome = workerHandle.outcome;
+            }
+            catch {
+                // Worker constructor details are not surfaced: exec arguments or a
+                // provider loader may have included sensitive values.
+                providerOutcome = Promise.resolve({
+                    type: "error",
+                    error: new Error("The isolated readiness worker could not be started."),
+                });
+            }
+        }
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = setTimeout(() => {
+                resolve({ type: "timeout" });
+                controller.abort();
+            }, timeoutMs);
+        });
+        let outcome;
+        try {
+            outcome = await Promise.race([
+                providerOutcome,
+                timeout,
+                callerCancellation,
+                toolOutcome,
+            ]);
+        }
+        finally {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+            }
+            if (callerAbortListener !== undefined) {
+                options.abortSignal?.removeEventListener("abort", callerAbortListener);
+            }
+            if (workerAbortListener !== undefined) {
+                controller.signal.removeEventListener("abort", workerAbortListener);
+            }
+            if (workerHandle !== undefined) {
+                await workerHandle.shutdown();
+            }
+            else {
+                await options.dispose?.();
+            }
+        }
+        if (outcome.type === "cancelled") {
+            return {
+                ok: false,
+                kind: "cancelled",
+                message: "The primary-model check was cancelled before completion.",
+            };
+        }
+        if (outcome.type === "tool") {
+            return {
+                ok: false,
+                kind: "tool_used",
+                message: `The selected model attempted a tool action (${outcome.action}) during the no-tool primary-model check.`,
+            };
+        }
+        if (outcome.type === "timeout") {
+            return {
+                ok: false,
+                kind: "timeout",
+                message: `The selected model did not finish the primary-model check within ${Math.ceil(timeoutMs / 1_000)} seconds.`,
+            };
+        }
+        if (outcome.type === "error") {
+            return {
+                ok: false,
+                kind: "probe_failed",
+                message: safeMessage(outcome.error, safeValues, "The primary-model check failed unexpectedly."),
+            };
+        }
+        const result = outcome.result;
+        for (const event of result.events ?? []) {
+            firstToolAction ??= toolActionInEvent(event);
+        }
+        if (firstToolAction !== undefined || result.failureKind === "tool_policy_violation") {
+            return {
+                ok: false,
+                kind: "tool_used",
+                message: `The selected model attempted a tool action (${firstToolAction ?? "provider tool"}) during the no-tool primary-model check.`,
+            };
+        }
+        if (result.cancelled === true) {
+            return {
+                ok: false,
+                kind: "cancelled",
+                message: "The selected model cancelled before completing the primary-model check.",
+            };
+        }
+        if (result.failureKind !== undefined && result.failureKind !== null) {
+            return {
+                ok: false,
+                kind: "provider_failed",
+                message: safeMessage(result.error, safeValues, `The selected model reported ${safeMessage(result.failureKind, safeValues, "a provider failure")}.`),
+            };
+        }
+        if (result.error !== undefined && result.error !== null) {
+            return {
+                ok: false,
+                kind: "provider_failed",
+                message: safeMessage(result.error, safeValues, "The selected model reported an error."),
+            };
+        }
+        if ((result.text ?? "").trim().length === 0) {
+            return {
+                ok: false,
+                kind: "empty_response",
+                message: "The selected model returned an empty primary-model response.",
+            };
+        }
+        return { ok: true };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            kind: "probe_failed",
+            message: safeMessage(error, safeValues, "The primary-model check failed unexpectedly."),
+        };
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=readiness-probe.js.map