voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/cli/apply.js

@@ -2,34 +2,53 @@ import { Command } from "commander";
 import { executeApplyCommand } from "../commands/apply/command.js";
 import { ensureCleanWorkingTree, resolveCliContext, } from "../preflight/index.js";
 import { renderApplyTranscript } from "../render/transcripts/apply.js";
+import { parseApplyExecutionCommandOptions } from "./contract.js";
+import { buildApplyOperatorEnvelope, writeOperatorResultEnvelope, } from "./operator-envelope.js";
 import { writeCommandOutput } from "./output.js";
 export async function runApplyCommand(options) {
-    const { runId, agentId, ignoreBaseMismatch = false } = options;
+    const { runId, agentId, ignoreBaseMismatch = false, commit = false, } = options;
     const { root, workspacePaths } = await resolveCliContext();
     await ensureCleanWorkingTree(root);
     const result = await executeApplyCommand({
         root,
         runsFilePath: workspacePaths.runsFile,
+        verificationsFilePath: workspacePaths.verificationsFile,
         runId,
         agentId,
         ignoreBaseMismatch,
+        commit,
     });
     const body = renderApplyTranscript(result);
     return { result, body };
 }
 export function createApplyCommand() {
     return new Command("apply")
-        .description("Apply the winning agent implementation from a run")
-        .requiredOption("--run <run-id>", "Identifier of the recorded run")
-        .requiredOption("--agent <agent-id>", "Agent id to apply from the run")
-        .option("--ignore-base-mismatch", "Apply even if the current HEAD differs from the recorded base", () => true)
+        .description("Apply an agent's diff from a run")
+        .requiredOption("--run <run-id>", "Run ID containing the agent")
+        .requiredOption("--agent <agent-id>", "Agent ID whose diff to apply")
+        .option("--ignore-base-mismatch", "Skip base revision check", () => true)
+        .option("--commit", "Commit after apply, using the agent's summary as the message", () => true)
+        .option("--json", "Emit a machine-readable result envelope")
         .allowExcessArguments(false)
-        .action(async (options) => {
+        .action(async (options, command) => {
+        const input = parseApplyExecutionCommandOptions(options, command);
         const result = await runApplyCommand({
-            runId: options.run,
-            agentId: options.agent,
-            ignoreBaseMismatch: options.ignoreBaseMismatch ?? false,
+            runId: input.runId,
+            agentId: input.agentId,
+            ignoreBaseMismatch: input.ignoreBaseMismatch ?? false,
+            commit: input.commit ?? false,
+            json: Boolean(options.json),
+            writeOutput: writeCommandOutput,
         });
+        if (options.json) {
+            writeOperatorResultEnvelope(buildApplyOperatorEnvelope({
+                runId: result.result.runId,
+                agentId: result.result.agent.agentId,
+                diffPath: result.result.diffPath,
+                ignoredBaseMismatch: result.result.ignoredBaseMismatch,
+            }), result.exitCode);
+            return;
+        }
         writeCommandOutput({
             body: result.body,
             exitCode: result.exitCode,

package/dist/cli/auto.d.ts

@@ -0,0 +1,32 @@
+import { Command } from "commander";
+import type { AutoApplyStatus, AutoTerminalStatus } from "../domain/run/model/types.js";
+export interface AutoCommandOptions {
+    specPath?: string;
+    description?: string;
+    runAgentIds?: readonly string[];
+    verifyAgentIds?: readonly string[];
+    profile?: string;
+    maxParallel?: number;
+    branch?: boolean;
+    apply?: boolean;
+    commit?: boolean;
+}
+export interface AutoCommandResult {
+    exitCode: number;
+    runId?: string;
+    appliedAgentId?: string;
+    auto: {
+        status: AutoTerminalStatus;
+        detail?: string;
+    };
+    apply: {
+        status: AutoApplyStatus;
+        detail?: string;
+    };
+}
+interface AutoRuntimeOptions {
+    now?: () => number;
+}
+export declare function runAutoCommand(options: AutoCommandOptions, runtime?: AutoRuntimeOptions): Promise<AutoCommandResult>;
+export declare function createAutoCommand(): Command;
+export {};

package/dist/cli/auto.js

@@ -0,0 +1,232 @@
+import { Command, Option } from "commander";
+import { executeAutoCommand, } from "../commands/auto/command.js";
+import { validateAutoCommandOptions, validateAutoVerificationConfig, } from "../commands/auto/validation.js";
+import { loadVerificationConfig } from "../configs/verification/loader.js";
+import { rewriteRunRecord } from "../domain/run/persistence/adapter.js";
+import { resolveCliContext } from "../preflight/index.js";
+import { renderAutoSummaryTranscript } from "../render/transcripts/auto.js";
+import { renderWorkspaceAutoInitializedNotice } from "../render/transcripts/shared.js";
+import { renderCliError } from "../render/utils/errors.js";
+import { HintedError } from "../utils/errors.js";
+import { formatAlertMessage } from "../utils/output.js";
+import { parsePositiveInteger } from "../utils/validators.js";
+import { runApplyCommand } from "./apply.js";
+import { toCliError } from "./errors.js";
+import { beginChainedCommandOutput, writeCommandOutput } from "./output.js";
+import { runRunCommand } from "./run.js";
+import { runSpecCommand } from "./spec.js";
+import { runVerifyCommand } from "./verify.js";
+function parseMaxParallelOption(value) {
+    return parsePositiveInteger(value, "Expected positive integer after --max-parallel", "--max-parallel must be greater than 0");
+}
+function collectRunAgentOption(value, previous) {
+    return [...previous, value];
+}
+function collectVerifyAgentOption(value, previous) {
+    return [...previous, value];
+}
+function replayAutoCommandEvent(event) {
+    if (event.kind === "body") {
+        writeCommandOutput({
+            body: event.body,
+            stderr: event.stderr,
+            exitCode: event.exitCode,
+        });
+        return;
+    }
+    if (event.kind === "warning") {
+        const warningBody = formatAlertMessage("Warning", "yellow", event.detail);
+        writeCommandOutput({
+            body: event.separateWithDivider ? `---\n\n${warningBody}` : warningBody,
+        });
+        return;
+    }
+    if (event.kind === "error") {
+        writeCommandOutput({ body: renderCliError(toCliError(event.error)) });
+        return;
+    }
+    const warningBody = formatAlertMessage("Action required", "yellow", event.detail);
+    writeCommandOutput({
+        body: event.separateWithDivider ? `---\n\n${warningBody}` : warningBody,
+    });
+}
+async function persistAutoOutcome(options) {
+    const { runId, outcome } = options;
+    if (!runId) {
+        return;
+    }
+    try {
+        const { root, workspacePaths } = await resolveCliContext();
+        await rewriteRunRecord({
+            root,
+            runsFilePath: workspacePaths.runsFile,
+            runId,
+            mutate: (record) => ({
+                ...record,
+                auto: outcome,
+            }),
+            forceFlush: true,
+        });
+    }
+    catch {
+        // Keep auto command behavior resilient in unit tests and non-standard
+        // harnesses where run records may be mocked or unavailable.
+    }
+}
+export async function runAutoCommand(options, runtime = {}) {
+    validateAutoCommandOptions(options);
+    const now = runtime.now ?? Date.now.bind(Date);
+    const { root, workspaceAutoInitialized } = await resolveCliContext({
+        workspaceAutoInitMode: "when-missing",
+        restoreShippedVerificationTemplates: false,
+    });
+    const workspaceNotice = workspaceAutoInitialized
+        ? renderWorkspaceAutoInitializedNotice()
+        : undefined;
+    if (workspaceNotice) {
+        writeCommandOutput({
+            alerts: [{ severity: "info", message: workspaceNotice }],
+            leadingNewline: false,
+        });
+    }
+    const verificationConfig = loadVerificationConfig({ root });
+    await validateAutoVerificationConfig({
+        root,
+        command: {
+            description: options.description,
+            specPath: options.specPath,
+        },
+        verificationConfig,
+    });
+    const chainedOutput = beginChainedCommandOutput();
+    try {
+        const dependencies = {
+            now,
+            onEvent: replayAutoCommandEvent,
+            runSpecStage: async (input) => {
+                const result = await runSpecCommand({
+                    description: input.description,
+                    profile: input.profile,
+                    maxParallel: input.maxParallel,
+                    suppressHint: input.suppressHint,
+                    writeOutput: writeCommandOutput,
+                });
+                if (!result.sessionId) {
+                    throw new HintedError("Spec stage did not return a session id.", {
+                        hintLines: [
+                            "Re-run the spec stage and confirm the spec session persisted correctly.",
+                        ],
+                    });
+                }
+                return {
+                    ...result,
+                    sessionId: result.sessionId,
+                };
+            },
+            runRunStage: async (input) => {
+                const suppressBlankLines = !process.stdout.isTTY;
+                return runRunCommand({
+                    specPath: input.specPath,
+                    agentIds: input.agentIds ? [...input.agentIds] : undefined,
+                    agentOverrideFlag: input.agentOverrideFlag,
+                    profile: input.profile,
+                    maxParallel: input.maxParallel,
+                    branch: input.branch,
+                    writeOutput: writeCommandOutput,
+                    suppressHint: true,
+                    suppressLeadingBlankLine: suppressBlankLines,
+                    suppressTrailingBlankLine: suppressBlankLines,
+                    stdout: chainedOutput.stdout,
+                    stderr: chainedOutput.stderr,
+                });
+            },
+            runVerifyStage: async (input) => runVerifyCommand({
+                target: input.target,
+                agentIds: input.agentIds ? [...input.agentIds] : undefined,
+                agentOverrideFlag: input.agentOverrideFlag,
+                profile: input.profile,
+                maxParallel: input.maxParallel,
+                suppressHint: input.suppressHint,
+                stdout: chainedOutput.stdout,
+                stderr: chainedOutput.stderr,
+            }).then((result) => ({
+                verificationId: result.verificationId,
+                body: result.body,
+                stderr: undefined,
+                exitCode: result.exitCode,
+                selectedSpecPath: result.selectedSpecPath,
+                selection: result.selection?.decision,
+                selectionWarnings: result.selection?.warnings,
+            })),
+            runApplyStage: async (input) => runApplyCommand({
+                runId: input.runId,
+                agentId: input.agentId,
+                commit: input.commit,
+            }),
+        };
+        const execution = await executeAutoCommand(options, dependencies);
+        const autoOutcome = {
+            status: execution.auto.status,
+            completedAt: new Date(now()).toISOString(),
+            ...(execution.auto.detail ? { detail: execution.auto.detail } : {}),
+            apply: {
+                status: execution.apply.status,
+                ...(execution.appliedAgentId
+                    ? { agentId: execution.appliedAgentId }
+                    : {}),
+                ...(execution.apply.detail ? { detail: execution.apply.detail } : {}),
+            },
+        };
+        await persistAutoOutcome({
+            runId: execution.runId,
+            outcome: autoOutcome,
+        });
+        writeCommandOutput({
+            body: renderAutoSummaryTranscript(execution.summary),
+            exitCode: execution.exitCode,
+        });
+        return {
+            exitCode: execution.exitCode,
+            runId: execution.runId,
+            ...(execution.appliedAgentId
+                ? { appliedAgentId: execution.appliedAgentId }
+                : {}),
+            auto: execution.auto,
+            apply: execution.apply,
+        };
+    }
+    finally {
+        chainedOutput.end();
+    }
+}
+export function createAutoCommand() {
+    return new Command("auto")
+        .description("Run spec, run, verify, and apply as one command")
+        .option("--spec <path>", "Existing spec to run")
+        .option("--description <text>", "Generate a spec, then run and verify it")
+        .addOption(new Option("--run-agent <agent-id>", "Set run-stage agents directly (repeatable; order preserved)")
+        .default([], "")
+        .argParser(collectRunAgentOption))
+        .addOption(new Option("--verify-agent <agent-id>", "Set verify-stage agents directly (repeatable)")
+        .default([], "")
+        .argParser(collectVerifyAgentOption))
+        .option("--profile <name>", 'Orchestration profile (default: "default")')
+        .option("--max-parallel <count>", "Max concurrent agents/verifiers", parseMaxParallelOption)
+        .option("--branch", "Create or checkout a branch named after the spec")
+        .option("--apply", "Apply the selected candidate after verification", () => true)
+        .option("--commit", "Commit after apply (requires --apply)", () => true)
+        .allowExcessArguments(false)
+        .action(async (options) => {
+        await runAutoCommand({
+            specPath: options.spec,
+            description: options.description,
+            runAgentIds: options.runAgent,
+            verifyAgentIds: options.verifyAgent,
+            profile: options.profile,
+            maxParallel: options.maxParallel,
+            branch: options.branch,
+            apply: options.apply ?? false,
+            commit: options.commit ?? false,
+        });
+    });
+}

package/dist/cli/contract.d.ts

@@ -0,0 +1,328 @@
+import { type Command } from "commander";
+import { z } from "zod";
+import { type ListMode, type ListOperator } from "../contracts/list.js";
+export declare const externalExecutionOperators: readonly ["spec", "run", "reduce", "verify", "message", "apply", "prune"];
+export declare const externalInspectionOperators: readonly ["spec", "run", "reduce", "verify", "message"];
+export declare const externalInspectionModes: readonly ["table", "detail"];
+export type ExternalExecutionOperator = (typeof externalExecutionOperators)[number];
+export type ExternalInspectionOperator = ListOperator;
+export type ExternalInspectionMode = ListMode;
+export declare const externalExecutionOperatorSchema: z.ZodEnum<{
+    message: "message";
+    reduce: "reduce";
+    apply: "apply";
+    spec: "spec";
+    run: "run";
+    verify: "verify";
+    prune: "prune";
+}>;
+export declare const externalInspectionOperatorSchema: z.ZodEnum<{
+    message: "message";
+    reduce: "reduce";
+    spec: "spec";
+    run: "run";
+    verify: "verify";
+}>;
+export declare const externalInspectionModeSchema: z.ZodEnum<{
+    detail: "detail";
+    table: "table";
+}>;
+export declare const externalSpecExecutionInputSchema: z.ZodObject<{
+    description: z.ZodString;
+    agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    profile: z.ZodOptional<z.ZodString>;
+    maxParallel: z.ZodOptional<z.ZodNumber>;
+    title: z.ZodOptional<z.ZodString>;
+    extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const externalRunExecutionInputSchema: z.ZodObject<{
+    specPath: z.ZodString;
+    agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    profile: z.ZodOptional<z.ZodString>;
+    maxParallel: z.ZodOptional<z.ZodNumber>;
+    branch: z.ZodOptional<z.ZodBoolean>;
+    extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const externalReduceExecutionInputSchema: z.ZodObject<{
+    target: z.ZodObject<{
+        type: z.ZodEnum<{
+            message: "message";
+            reduce: "reduce";
+            spec: "spec";
+            run: "run";
+            verify: "verify";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    profile: z.ZodOptional<z.ZodString>;
+    maxParallel: z.ZodOptional<z.ZodNumber>;
+    extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const externalMessageExecutionInputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    profile: z.ZodOptional<z.ZodString>;
+    maxParallel: z.ZodOptional<z.ZodNumber>;
+    extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const externalVerifyExecutionInputSchema: z.ZodObject<{
+    target: z.ZodObject<{
+        kind: z.ZodEnum<{
+            message: "message";
+            reduce: "reduce";
+            spec: "spec";
+            run: "run";
+        }>;
+        sessionId: z.ZodString;
+    }, z.core.$strict>;
+    agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    profile: z.ZodOptional<z.ZodString>;
+    maxParallel: z.ZodOptional<z.ZodNumber>;
+    extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const externalApplyExecutionInputSchema: z.ZodObject<{
+    runId: z.ZodString;
+    agentId: z.ZodString;
+    ignoreBaseMismatch: z.ZodOptional<z.ZodBoolean>;
+    commit: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const externalPruneExecutionInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    purge: z.ZodOptional<z.ZodBoolean>;
+    confirmed: z.ZodLiteral<true>;
+    scope: z.ZodLiteral<"run">;
+    runId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    purge: z.ZodOptional<z.ZodBoolean>;
+    confirmed: z.ZodLiteral<true>;
+    scope: z.ZodLiteral<"all">;
+}, z.core.$strict>], "scope">;
+export declare const externalListTableInputSchema: z.ZodObject<{
+    operator: z.ZodEnum<{
+        message: "message";
+        reduce: "reduce";
+        spec: "spec";
+        run: "run";
+        verify: "verify";
+    }>;
+    verbose: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodLiteral<"table">;
+}, z.core.$strict>;
+export declare const externalListDetailInputSchema: z.ZodObject<{
+    operator: z.ZodEnum<{
+        message: "message";
+        reduce: "reduce";
+        spec: "spec";
+        run: "run";
+        verify: "verify";
+    }>;
+    verbose: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodLiteral<"detail">;
+    sessionId: z.ZodString;
+}, z.core.$strict>;
+export declare const externalListInspectionInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operator: z.ZodEnum<{
+        message: "message";
+        reduce: "reduce";
+        spec: "spec";
+        run: "run";
+        verify: "verify";
+    }>;
+    verbose: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodLiteral<"table">;
+}, z.core.$strict>, z.ZodObject<{
+    operator: z.ZodEnum<{
+        message: "message";
+        reduce: "reduce";
+        spec: "spec";
+        run: "run";
+        verify: "verify";
+    }>;
+    verbose: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodLiteral<"detail">;
+    sessionId: z.ZodString;
+}, z.core.$strict>], "mode">;
+export declare const externalExecutionInputSchemas: {
+    readonly spec: z.ZodObject<{
+        description: z.ZodString;
+        agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        profile: z.ZodOptional<z.ZodString>;
+        maxParallel: z.ZodOptional<z.ZodNumber>;
+        title: z.ZodOptional<z.ZodString>;
+        extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    readonly run: z.ZodObject<{
+        specPath: z.ZodString;
+        agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        profile: z.ZodOptional<z.ZodString>;
+        maxParallel: z.ZodOptional<z.ZodNumber>;
+        branch: z.ZodOptional<z.ZodBoolean>;
+        extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    readonly reduce: z.ZodObject<{
+        target: z.ZodObject<{
+            type: z.ZodEnum<{
+                message: "message";
+                reduce: "reduce";
+                spec: "spec";
+                run: "run";
+                verify: "verify";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+        agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        profile: z.ZodOptional<z.ZodString>;
+        maxParallel: z.ZodOptional<z.ZodNumber>;
+        extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    readonly verify: z.ZodObject<{
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                message: "message";
+                reduce: "reduce";
+                spec: "spec";
+                run: "run";
+            }>;
+            sessionId: z.ZodString;
+        }, z.core.$strict>;
+        agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        profile: z.ZodOptional<z.ZodString>;
+        maxParallel: z.ZodOptional<z.ZodNumber>;
+        extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    readonly message: z.ZodObject<{
+        prompt: z.ZodString;
+        agentIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        profile: z.ZodOptional<z.ZodString>;
+        maxParallel: z.ZodOptional<z.ZodNumber>;
+        extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    readonly apply: z.ZodObject<{
+        runId: z.ZodString;
+        agentId: z.ZodString;
+        ignoreBaseMismatch: z.ZodOptional<z.ZodBoolean>;
+        commit: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    readonly prune: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        purge: z.ZodOptional<z.ZodBoolean>;
+        confirmed: z.ZodLiteral<true>;
+        scope: z.ZodLiteral<"run">;
+        runId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        purge: z.ZodOptional<z.ZodBoolean>;
+        confirmed: z.ZodLiteral<true>;
+        scope: z.ZodLiteral<"all">;
+    }, z.core.$strict>], "scope">;
+};
+export declare const externalInspectionInputSchemas: {
+    readonly list: {
+        readonly table: z.ZodObject<{
+            operator: z.ZodEnum<{
+                message: "message";
+                reduce: "reduce";
+                spec: "spec";
+                run: "run";
+                verify: "verify";
+            }>;
+            verbose: z.ZodOptional<z.ZodBoolean>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            mode: z.ZodLiteral<"table">;
+        }, z.core.$strict>;
+        readonly detail: z.ZodObject<{
+            operator: z.ZodEnum<{
+                message: "message";
+                reduce: "reduce";
+                spec: "spec";
+                run: "run";
+                verify: "verify";
+            }>;
+            verbose: z.ZodOptional<z.ZodBoolean>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            mode: z.ZodLiteral<"detail">;
+            sessionId: z.ZodString;
+        }, z.core.$strict>;
+        readonly union: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            operator: z.ZodEnum<{
+                message: "message";
+                reduce: "reduce";
+                spec: "spec";
+                run: "run";
+                verify: "verify";
+            }>;
+            verbose: z.ZodOptional<z.ZodBoolean>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            mode: z.ZodLiteral<"table">;
+        }, z.core.$strict>, z.ZodObject<{
+            operator: z.ZodEnum<{
+                message: "message";
+                reduce: "reduce";
+                spec: "spec";
+                run: "run";
+                verify: "verify";
+            }>;
+            verbose: z.ZodOptional<z.ZodBoolean>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            mode: z.ZodLiteral<"detail">;
+            sessionId: z.ZodString;
+        }, z.core.$strict>], "mode">;
+    };
+};
+export type ExternalSpecExecutionInput = z.infer<typeof externalSpecExecutionInputSchema>;
+export type ExternalRunExecutionInput = z.infer<typeof externalRunExecutionInputSchema>;
+export type ExternalReduceExecutionInput = z.infer<typeof externalReduceExecutionInputSchema>;
+export type ExternalMessageExecutionInput = z.infer<typeof externalMessageExecutionInputSchema>;
+export type ExternalVerifyExecutionInput = z.infer<typeof externalVerifyExecutionInputSchema>;
+export type ExternalApplyExecutionInput = z.infer<typeof externalApplyExecutionInputSchema>;
+export type ExternalPruneExecutionInput = z.infer<typeof externalPruneExecutionInputSchema>;
+export type ExternalListInspectionInput = z.infer<typeof externalListInspectionInputSchema>;
+export declare const externalAdapterContractReference: {
+    readonly execution: {
+        readonly operators: readonly ["spec", "run", "reduce", "verify", "message", "apply", "prune"];
+        readonly envelope: {
+            readonly authoritativeType: "OperatorResultEnvelope";
+            readonly versioned: true;
+        };
+        readonly exitCodesAreContract: true;
+    };
+    readonly inspection: {
+        readonly command: "list";
+        readonly jsonOnly: true;
+        readonly operators: readonly ["spec", "run", "reduce", "verify", "message"];
+        readonly modes: readonly ["table", "detail"];
+        readonly authoritativeType: "ListJsonOutput";
+        readonly versioned: false;
+    };
+    readonly excludedCommands: readonly ["init", "auto"];
+    readonly compatibility: {
+        readonly additiveChangesAreNonBreaking: true;
+        readonly breakingChangesRequireExecutionEnvelopeVersionBump: true;
+        readonly breakingChanges: readonly ["remove an existing field", "change a field type", "change the semantic meaning of an existing field", "change required-vs-optional status in a way that breaks clients"];
+    };
+    readonly semantics: {
+        readonly executionWarningsField: "alerts";
+        readonly executionFailuresField: "error";
+        readonly inspectionWarningsField: "warnings";
+        readonly listNotFoundReturnsDetailWithNullSession: true;
+        readonly listNotFoundExitCode: 0;
+        readonly adaptersMustNotParseHumanTranscriptOutput: true;
+    };
+};
+export interface PruneCommandSelection {
+    runId?: string;
+    all: boolean;
+    purge?: boolean;
+    yes?: boolean;
+}
+export declare function parseSpecExecutionCommandOptions(options: unknown, command: Command): ExternalSpecExecutionInput;
+export declare function parseRunExecutionCommandOptions(options: unknown, command: Command): ExternalRunExecutionInput;
+export declare function parseReduceExecutionCommandOptions(options: unknown, command: Command): ExternalReduceExecutionInput;
+export declare function parseMessageExecutionCommandOptions(options: unknown, command: Command): ExternalMessageExecutionInput;
+export declare function parseVerifyExecutionCommandOptions(options: unknown, command: Command): ExternalVerifyExecutionInput;
+export declare function parseApplyExecutionCommandOptions(options: unknown, command: Command): ExternalApplyExecutionInput;
+export declare function parseExternalPruneExecutionInput(input: unknown): ExternalPruneExecutionInput;
+export declare function parseListInspectionCommandOptions(options: unknown, command: Command): ExternalListInspectionInput;
+export declare function parsePruneCommandSelection(options: unknown, command: Command): PruneCommandSelection;