voratiq 0.1.0-beta.0

package/dist/commands/run/agents/preparation.js

@@ -0,0 +1,123 @@
+import { ensureWorkspaceError, prepareAgentWorkspace, } from "../../../workspace/agents.js";
+import { buildAgentWorkspacePaths } from "../../../workspace/layout.js";
+import { MissingAgentProviderError, RunCommandError } from "../errors.js";
+import { registerStagedSandboxContext, teardownRegisteredSandboxContext, } from "../sandbox-registry.js";
+import { stageAgentAuth } from "./auth-stage.js";
+import { captureAgentChatTranscripts } from "./chat-preserver.js";
+import { AgentRunContext } from "./run-context.js";
+import { configureSandboxSettings } from "./sandbox-launcher.js";
+import { writeAgentManifest } from "./workspace-prep.js";
+export async function prepareAgentForExecution(context) {
+    const { agent, baseRevisionSha, runId, root, evalPlan, environment } = context;
+    const workspacePaths = buildAgentWorkspacePaths({
+        root,
+        runId,
+        agentId: agent.id,
+    });
+    const startedAt = new Date().toISOString();
+    const agentContext = new AgentRunContext({
+        agent,
+        runId,
+        startedAt,
+        evalPlan,
+    });
+    try {
+        await prepareAgentWorkspace({
+            paths: workspacePaths,
+            baseRevisionSha,
+            root,
+            agentId: agent.id,
+            runId,
+            environment,
+        });
+    }
+    catch (error) {
+        return {
+            status: "failed",
+            result: await agentContext.failWith(ensureWorkspaceFailure(error)),
+        };
+    }
+    let authContext;
+    let manifestEnv = {};
+    try {
+        const staged = await stageAgentAuth({
+            agent,
+            agentRoot: workspacePaths.agentRoot,
+            runId,
+            root,
+        });
+        authContext = staged.context;
+        registerStagedSandboxContext(authContext);
+        manifestEnv = staged.env;
+    }
+    catch (error) {
+        return {
+            status: "failed",
+            result: await agentContext.failWith(ensureWorkspaceFailure(error)),
+        };
+    }
+    try {
+        manifestEnv = await writeAgentManifest({
+            agent,
+            workspacePaths,
+            env: manifestEnv,
+            environment,
+        });
+    }
+    catch (error) {
+        await captureAgentChatTranscripts({
+            agent,
+            agentContext,
+            agentRoot: workspacePaths.agentRoot,
+            reason: "pre-run",
+        });
+        await teardownRegisteredSandboxContext(authContext);
+        return {
+            status: "failed",
+            result: await agentContext.failWith(ensureWorkspaceFailure(error)),
+        };
+    }
+    try {
+        const providerId = agent.provider;
+        if (!providerId) {
+            throw new MissingAgentProviderError(agent.id);
+        }
+        await configureSandboxSettings({
+            workspacePaths,
+            providerId,
+            root,
+        });
+    }
+    catch (error) {
+        await captureAgentChatTranscripts({
+            agent,
+            agentContext,
+            agentRoot: workspacePaths.agentRoot,
+            reason: "pre-run",
+        });
+        await teardownRegisteredSandboxContext(authContext);
+        return {
+            status: "failed",
+            result: await agentContext.failWith(ensureWorkspaceFailure(error)),
+        };
+    }
+    return {
+        status: "ready",
+        prepared: {
+            agent,
+            agentContext,
+            workspacePaths,
+            runtimeManifestPath: workspacePaths.runtimeManifestPath,
+            baseRevisionSha,
+            root,
+            runId,
+            evalPlan,
+            environment,
+            manifestEnv,
+            authContext,
+        },
+    };
+}
+function ensureWorkspaceFailure(error) {
+    return error instanceof RunCommandError ? error : ensureWorkspaceError(error);
+}

package/dist/commands/run/agents/run-context.d.ts

@@ -0,0 +1,46 @@
+import type { AgentDefinition } from "../../../configs/agents/types.js";
+import type { AgentEvalResult, EvalDefinition } from "../../../configs/evals/types.js";
+import type { AgentInvocationRecord, AgentStatus, WatchdogMetadata } from "../../../records/types.js";
+import type { ArtifactCollectionResult } from "../../../workspace/agents.js";
+import type { ChatArtifactFormat } from "../../../workspace/chat/types.js";
+import type { RunCommandError } from "../errors.js";
+import { type AgentExecutionResult, type AgentExecutionState } from "../reports.js";
+export declare class AgentRunContext {
+    readonly state: AgentExecutionState;
+    status: AgentStatus;
+    commitSha: string | undefined;
+    evalResults: AgentEvalResult[];
+    errorMessage: string | undefined;
+    watchdogMetadata: WatchdogMetadata | undefined;
+    private completedAt;
+    private startedAt;
+    private readonly evalPlan;
+    private readonly runId;
+    private readonly agent;
+    private artifactState;
+    private evalWarnings;
+    constructor(params: {
+        agent: AgentDefinition;
+        runId: string;
+        startedAt: string;
+        evalPlan: readonly EvalDefinition[];
+    });
+    markFailure(error: RunCommandError): void;
+    failWith(error: RunCommandError): Promise<AgentExecutionResult>;
+    isFailed(): boolean;
+    setCompleted(): void;
+    markStarted(): void;
+    getStartedAt(): string | undefined;
+    applyArtifacts(result: ArtifactCollectionResult): void;
+    applyEvaluations(results: AgentEvalResult[]): void;
+    markChatArtifact(format: ChatArtifactFormat): void;
+    recordEvalWarnings(warnings: readonly string[]): void;
+    setWatchdogMetadata(metadata: WatchdogMetadata): void;
+    finalize(): AgentExecutionResult;
+    /**
+     * Build an early failure record for immediate UI surfacing when watchdog triggers.
+     * Includes placeholder evals so the record satisfies agentInvocationRecordSchema.
+     */
+    buildEarlyFailureRecord(errorMessage: string): AgentInvocationRecord;
+}
+export declare function buildDefaultEvalResults(definitions: readonly EvalDefinition[]): AgentEvalResult[];

package/dist/commands/run/agents/run-context.js

@@ -0,0 +1,193 @@
+import { normalizeDiffStatistics } from "../../../utils/diff.js";
+import { finalizeAgentResult, } from "../reports.js";
+export class AgentRunContext {
+    state = {
+        diffAttempted: false,
+        diffCaptured: false,
+        diffStatistics: undefined,
+    };
+    status = "succeeded";
+    commitSha;
+    evalResults;
+    errorMessage;
+    watchdogMetadata;
+    completedAt;
+    startedAt;
+    evalPlan;
+    runId;
+    agent;
+    artifactState;
+    evalWarnings = [];
+    constructor(params) {
+        this.agent = params.agent;
+        this.runId = params.runId;
+        this.startedAt = params.startedAt;
+        this.evalPlan = params.evalPlan;
+        this.evalResults = buildDefaultEvalResults(this.evalPlan);
+        this.artifactState = {
+            diffAttempted: false,
+            diffCaptured: false,
+            stdoutCaptured: true,
+            stderrCaptured: true,
+        };
+    }
+    markFailure(error) {
+        this.status = "failed";
+        this.errorMessage = error.messageForDisplay();
+    }
+    async failWith(error) {
+        this.markFailure(error);
+        this.setCompleted();
+        await Promise.resolve();
+        return this.finalize();
+    }
+    isFailed() {
+        return this.status === "failed";
+    }
+    setCompleted() {
+        if (!this.completedAt) {
+            this.completedAt = new Date().toISOString();
+        }
+    }
+    markStarted() {
+        this.startedAt = new Date().toISOString();
+    }
+    getStartedAt() {
+        return this.startedAt;
+    }
+    applyArtifacts(result) {
+        if (result.summaryCaptured) {
+            this.artifactState.summaryCaptured = true;
+        }
+        if (result.diffAttempted) {
+            this.artifactState.diffAttempted = true;
+        }
+        if (result.diffCaptured) {
+            this.artifactState.diffCaptured = true;
+        }
+        if (result.commitSha) {
+            this.commitSha = result.commitSha;
+        }
+        const normalizedDiff = normalizeDiffStatistics(result.diffStatistics);
+        if (normalizedDiff) {
+            this.state.diffStatistics = normalizedDiff;
+        }
+        this.state.diffAttempted ||= result.diffAttempted;
+        this.state.diffCaptured ||= result.diffCaptured;
+    }
+    applyEvaluations(results) {
+        const defaults = buildDefaultEvalResults(this.evalPlan);
+        const bySlug = new Map(results.map((evaluation) => [evaluation.slug, evaluation]));
+        this.evalResults = defaults.map((fallback) => {
+            const evaluation = bySlug.get(fallback.slug);
+            return evaluation ?? fallback;
+        });
+        if (this.status === "failed") {
+            return;
+        }
+        const hasErrored = this.evalResults.some((evaluation) => {
+            return evaluation.status === "errored";
+        });
+        const hasFailed = this.evalResults.some((evaluation) => evaluation.status === "failed");
+        if (hasErrored) {
+            this.status = "errored";
+            if (!this.errorMessage) {
+                const erroredEval = this.evalResults.find((evaluation) => evaluation.status === "errored" && evaluation.error);
+                if (erroredEval?.error) {
+                    this.errorMessage = erroredEval.error;
+                }
+            }
+            return;
+        }
+        if (hasFailed) {
+            this.status = "failed";
+        }
+    }
+    markChatArtifact(format) {
+        this.artifactState.chatCaptured = true;
+        this.artifactState.chatFormat = format;
+    }
+    recordEvalWarnings(warnings) {
+        this.evalWarnings.push(...warnings);
+    }
+    setWatchdogMetadata(metadata) {
+        this.watchdogMetadata = metadata;
+    }
+    finalize() {
+        this.setCompleted();
+        const record = buildAgentRecord({
+            agent: this.agent,
+            commitSha: this.commitSha,
+            completedAt: this.completedAt ?? new Date().toISOString(),
+            errorMessage: this.errorMessage,
+            startedAt: this.startedAt,
+            status: this.status,
+            artifacts: this.artifactState,
+            evalResults: this.evalResults,
+            warnings: this.evalWarnings,
+            diffStatistics: this.state.diffStatistics,
+            watchdog: this.watchdogMetadata,
+        });
+        return finalizeAgentResult(this.runId, record, this.state);
+    }
+    /**
+     * Build an early failure record for immediate UI surfacing when watchdog triggers.
+     * Includes placeholder evals so the record satisfies agentInvocationRecordSchema.
+     */
+    buildEarlyFailureRecord(errorMessage) {
+        return buildAgentRecord({
+            agent: this.agent,
+            commitSha: undefined,
+            completedAt: new Date().toISOString(),
+            errorMessage,
+            startedAt: this.startedAt,
+            status: "failed",
+            artifacts: this.artifactState,
+            evalResults: this.evalResults,
+            warnings: this.evalWarnings,
+            diffStatistics: undefined,
+            watchdog: this.watchdogMetadata,
+        });
+    }
+}
+export function buildDefaultEvalResults(definitions) {
+    return definitions.map(({ slug, command }) => ({
+        slug,
+        command,
+        status: "skipped",
+    }));
+}
+function buildAgentRecord(options) {
+    const { agent, commitSha, completedAt, errorMessage, startedAt, status, artifacts, evalResults, warnings, diffStatistics, watchdog, } = options;
+    const snapshots = toEvalSnapshots(evalResults);
+    const artifactState = Object.keys(artifacts).length > 0 ? artifacts : undefined;
+    const normalizedWarnings = warnings.length > 0 ? Array.from(new Set(warnings)) : undefined;
+    const normalizedDiffStatistics = normalizeDiffStatistics(diffStatistics);
+    const record = {
+        agentId: agent.id,
+        model: agent.model,
+        startedAt,
+        completedAt,
+        status,
+        commitSha,
+        artifacts: artifactState,
+        evals: snapshots,
+        error: errorMessage,
+        warnings: normalizedWarnings,
+        watchdog,
+    };
+    if (normalizedDiffStatistics) {
+        record.diffStatistics = normalizedDiffStatistics;
+    }
+    return record;
+}
+function toEvalSnapshots(results) {
+    return results.map((evaluation) => ({
+        slug: evaluation.slug,
+        status: evaluation.status,
+        command: evaluation.command,
+        exitCode: evaluation.exitCode,
+        hasLog: evaluation.logPath !== undefined,
+        error: evaluation.error,
+    }));
+}

package/dist/commands/run/agents/sandbox-launcher.d.ts

@@ -0,0 +1,44 @@
+import type { WatchdogMetadata } from "../../../records/types.js";
+import type { AgentWorkspacePaths } from "../../../workspace/layout.js";
+import { type WatchdogTrigger } from "./watchdog.js";
+export interface AgentProcessOptions {
+    runtimeManifestPath: string;
+    agentRoot: string;
+    stdoutPath: string;
+    stderrPath: string;
+    sandboxSettingsPath: string;
+    resolveRunInvocation?: RunInvocationResolver;
+    /** Provider ID for watchdog fatal pattern matching. */
+    providerId?: string;
+    /** Callback fired immediately when watchdog triggers, before process exits. */
+    onWatchdogTrigger?: (trigger: WatchdogTrigger, reason: string) => void;
+}
+export interface AgentProcessResult {
+    exitCode: number;
+    errorMessage?: string;
+    signal?: NodeJS.Signals | null;
+    /** Watchdog metadata showing enforced limits and trigger reason. */
+    watchdog?: WatchdogMetadata;
+}
+export interface RunInvocationContext {
+    agentRoot: string;
+    configArg: string;
+    settingsArg: string;
+    shimEntryPath: string;
+}
+export interface RunInvocation {
+    command: string;
+    args: string[];
+}
+export type RunInvocationResolver = (context: RunInvocationContext) => Promise<RunInvocation> | RunInvocation;
+export interface SandboxSettingsInput {
+    workspacePaths: AgentWorkspacePaths;
+    providerId: string;
+    root: string;
+}
+export declare function configureSandboxSettings(input: SandboxSettingsInput): Promise<void>;
+export declare function getRunCommand(): Promise<string>;
+export declare function runAgentProcess(options: AgentProcessOptions): Promise<AgentProcessResult>;
+export declare function stageManifestForSandbox(options: {
+    runtimeManifestPath: string;
+}): Promise<string>;

package/dist/commands/run/agents/sandbox-launcher.js

@@ -0,0 +1,211 @@
+import { constants as fsConstants, createWriteStream, existsSync, } from "node:fs";
+import { access, readFile, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, relative as relativePath } from "node:path";
+import { getCliAssetPath, resolveCliAssetRoot, } from "../../../utils/cli-root.js";
+import { resolvePath } from "../../../utils/path.js";
+import { spawnStreamingProcess } from "../../../utils/process.js";
+import { ARTIFACTS_DIRNAME, EVALS_DIRNAME, } from "../../../workspace/structure.js";
+import { AgentProcessError } from "../errors.js";
+import { generateSandboxSettings, resolveSrtBinary, writeSandboxSettings, } from "../sandbox.js";
+import { createWatchdog, WATCHDOG_DEFAULTS, } from "./watchdog.js";
+const DEFAULT_SRT_ARGUMENTS = ["--debug"];
+const SRT_BINARY_ENV = "VORATIQ_SRT_BINARY";
+let cachedSrtBinaryPath;
+export async function configureSandboxSettings(input) {
+    const { workspacePaths, providerId, root } = input;
+    const artifactsPath = resolvePath(workspacePaths.agentRoot, ARTIFACTS_DIRNAME);
+    const evalsPath = resolvePath(workspacePaths.agentRoot, EVALS_DIRNAME);
+    const sandboxSettings = generateSandboxSettings({
+        sandboxHomePath: workspacePaths.sandboxHomePath,
+        workspacePath: workspacePaths.workspacePath,
+        provider: providerId,
+        root,
+        sandboxSettingsPath: workspacePaths.sandboxSettingsPath,
+        runtimePath: workspacePaths.runtimePath,
+        artifactsPath,
+        evalsPath,
+    });
+    await writeSandboxSettings(workspacePaths.sandboxSettingsPath, sandboxSettings);
+}
+export async function getRunCommand() {
+    const { X_OK } = fsConstants;
+    const binaryPath = resolveSrtBinaryPath();
+    try {
+        await access(binaryPath, X_OK);
+    }
+    catch {
+        throw new Error(`Sandbox Runtime binary not found or not executable at ${binaryPath}. Please reinstall dependencies with 'npm install'.`);
+    }
+    return binaryPath;
+}
+function getRunArgs(options) {
+    const { settingsArg, configArg, shimEntryPath } = options;
+    return [
+        ...DEFAULT_SRT_ARGUMENTS,
+        "--settings",
+        settingsArg,
+        "--",
+        process.execPath,
+        shimEntryPath,
+        "--config",
+        configArg,
+    ];
+}
+async function defaultResolveRunInvocation(context) {
+    const command = await getRunCommand();
+    const args = getRunArgs({
+        settingsArg: context.settingsArg,
+        configArg: context.configArg,
+        shimEntryPath: context.shimEntryPath,
+    });
+    return { command, args };
+}
+export async function runAgentProcess(options) {
+    const { runtimeManifestPath, agentRoot, stdoutPath, stderrPath, sandboxSettingsPath, resolveRunInvocation, providerId = "", onWatchdogTrigger, } = options;
+    const stdoutStream = createWriteStream(stdoutPath, { flags: "w" });
+    const stderrStream = createWriteStream(stderrPath, { flags: "w" });
+    const shimEntryPath = resolveShimEntryPath();
+    if (!existsSync(shimEntryPath)) {
+        throw new AgentProcessError({
+            detail: `Shim entry point missing at ${shimEntryPath}`,
+        });
+    }
+    const manifestArgPath = await stageManifestForSandbox({
+        runtimeManifestPath,
+    });
+    const relativeConfig = relativePath(agentRoot, manifestArgPath);
+    const configArg = relativeConfig === "" ? manifestArgPath : relativeConfig;
+    const relativeSettings = relativePath(agentRoot, sandboxSettingsPath);
+    const settingsArg = relativeSettings === "" ? sandboxSettingsPath : relativeSettings;
+    const invocationResolver = resolveRunInvocation ?? defaultResolveRunInvocation;
+    const { command, args } = await invocationResolver({
+        agentRoot,
+        configArg,
+        settingsArg,
+        shimEntryPath,
+    });
+    let watchdogController;
+    // Track abort signal subscription for cleanup
+    let abortSignalHandler;
+    // Shared abort controller - watchdog will fire it, spawnStreamingProcess will listen
+    const forceAbortController = new AbortController();
+    let exitCode;
+    let signal;
+    let aborted = false;
+    try {
+        const result = await spawnStreamingProcess({
+            command,
+            args,
+            cwd: agentRoot,
+            stdout: { writable: stdoutStream },
+            stderr: { writable: stderrStream },
+            // Spawn in new process group to enable killing entire process tree
+            detached: true,
+            onSpawn: (child) => {
+                watchdogController = createWatchdog(child, stderrStream, {
+                    providerId,
+                    onWatchdogTrigger,
+                });
+                // Bridge watchdog's abort signal to our shared abort controller
+                abortSignalHandler = () => forceAbortController.abort();
+                watchdogController.abortSignal.addEventListener("abort", abortSignalHandler, { once: true });
+            },
+            onData: (chunk) => {
+                watchdogController?.handleOutput(chunk);
+            },
+            abortSignal: forceAbortController.signal,
+        });
+        exitCode = result.exitCode;
+        signal = result.signal;
+        aborted = result.aborted ?? false;
+    }
+    finally {
+        // Clean up abort signal listener
+        if (abortSignalHandler && watchdogController) {
+            watchdogController.abortSignal.removeEventListener("abort", abortSignalHandler);
+        }
+        watchdogController?.cleanup();
+        // Ensure streams are fully closed to prevent hanging on exit
+        if (!stdoutStream.closed) {
+            stdoutStream.end();
+        }
+        if (!stderrStream.closed) {
+            stderrStream.end();
+        }
+    }
+    const watchdogState = watchdogController?.getState();
+    const watchdogTrigger = watchdogState?.triggered ?? undefined;
+    let errorMessage;
+    if (watchdogTrigger && watchdogState?.triggeredReason) {
+        errorMessage = aborted
+            ? `${watchdogState.triggeredReason} (force-aborted after unresponsive to signals)`
+            : watchdogState.triggeredReason;
+    }
+    else if (signal) {
+        errorMessage = `Agent terminated by signal ${signal}`;
+    }
+    else if (exitCode !== 0) {
+        errorMessage = `Agent exited with code ${exitCode}`;
+    }
+    const watchdog = {
+        silenceTimeoutMs: WATCHDOG_DEFAULTS.silenceTimeoutMs,
+        wallClockCapMs: WATCHDOG_DEFAULTS.wallClockCapMs,
+        trigger: watchdogTrigger,
+    };
+    return { exitCode, errorMessage, signal, watchdog };
+}
+export async function stageManifestForSandbox(options) {
+    const { runtimeManifestPath } = options;
+    let rawManifest;
+    try {
+        rawManifest = await readFile(runtimeManifestPath, "utf8");
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new AgentProcessError({
+            detail: `Failed to read manifest at "${runtimeManifestPath}": ${detail}`,
+        });
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(rawManifest);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        throw new AgentProcessError({
+            detail: `Manifest JSON at "${runtimeManifestPath}" is invalid: ${detail}`,
+        });
+    }
+    const manifestDir = dirname(runtimeManifestPath);
+    const promptAbsolute = isAbsolute(manifest.promptPath)
+        ? manifest.promptPath
+        : resolvePath(manifestDir, manifest.promptPath);
+    const workspaceAbsolute = isAbsolute(manifest.workspace)
+        ? manifest.workspace
+        : resolvePath(manifestDir, manifest.workspace);
+    const manifestNeedsUpdate = manifest.promptPath !== promptAbsolute ||
+        manifest.workspace !== workspaceAbsolute;
+    if (manifestNeedsUpdate) {
+        const updatedManifest = {
+            ...manifest,
+            promptPath: promptAbsolute,
+            workspace: workspaceAbsolute,
+        };
+        await writeFile(runtimeManifestPath, `${JSON.stringify(updatedManifest, null, 2)}\n`, "utf8");
+    }
+    return runtimeManifestPath;
+}
+function resolveSrtBinaryPath() {
+    const overridePath = process.env[SRT_BINARY_ENV];
+    if (overridePath && overridePath.length > 0) {
+        return overridePath;
+    }
+    if (!cachedSrtBinaryPath) {
+        const cliRoot = resolveCliAssetRoot();
+        cachedSrtBinaryPath = resolveSrtBinary(cliRoot);
+    }
+    return cachedSrtBinaryPath;
+}
+function resolveShimEntryPath() {
+    return getCliAssetPath("dist", "commands", "run", "shim", "run-agent-shim.mjs");
+}

package/dist/commands/run/agents/types.d.ts

@@ -0,0 +1,47 @@
+import type { AgentDefinition } from "../../../configs/agents/types.js";
+import type { EnvironmentConfig } from "../../../configs/environment/types.js";
+import type { EvalDefinition } from "../../../configs/evals/types.js";
+import type { AgentInvocationRecord } from "../../../records/types.js";
+import type { AgentWorkspacePaths } from "../../../workspace/layout.js";
+import type { AgentExecutionResult } from "../reports.js";
+import type { StagedAuthContext } from "./auth-stage.js";
+import { AgentRunContext } from "./run-context.js";
+export interface AgentExecutionContext {
+    agent: AgentDefinition;
+    baseRevisionSha: string;
+    runId: string;
+    root: string;
+    evalPlan: readonly EvalDefinition[];
+    environment: EnvironmentConfig;
+}
+export interface AgentProgressCallbacks {
+    onRunning?: (record: AgentInvocationRecord) => Promise<void> | void;
+    onCompleted?: (result: AgentExecutionResult) => Promise<void> | void;
+    /** Callback for early failure (e.g., watchdog trigger) before process fully exits. */
+    onEarlyFailure?: (record: AgentInvocationRecord) => Promise<void> | void;
+}
+export interface PreparedAgentExecution {
+    agent: AgentDefinition;
+    agentContext: AgentRunContext;
+    workspacePaths: AgentWorkspacePaths;
+    runtimeManifestPath: string;
+    baseRevisionSha: string;
+    root: string;
+    runId: string;
+    evalPlan: readonly EvalDefinition[];
+    environment: EnvironmentConfig;
+    manifestEnv: Record<string, string>;
+    progress?: AgentProgressCallbacks;
+    authContext?: StagedAuthContext;
+}
+export type AgentPreparationOutcome = {
+    status: "ready";
+    prepared: PreparedAgentExecution;
+} | {
+    status: "failed";
+    result: AgentExecutionResult;
+};
+export interface AgentPreparationResult {
+    ready: PreparedAgentExecution[];
+    failures: AgentExecutionResult[];
+}

package/dist/commands/run/agents/types.js

@@ -0,0 +1 @@
+export {};