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

package/dist/commands/apply/command.js

@@ -1,20 +1,29 @@
-import { buildRunRecordEnhanced } from "../../records/enhanced.js";
-import { rewriteRunRecord } from "../../records/persistence.js";
+import { readFile } from "node:fs/promises";
+import { buildRunRecordEnhanced } from "../../domain/run/model/enhanced.js";
+import { rewriteRunRecord } from "../../domain/run/persistence/adapter.js";
+import { readVerificationRecords } from "../../domain/verify/persistence/adapter.js";
+import { buildVerificationSelectorSource, deriveSelectorSelectionDecision, loadVerificationSelectionPolicyOutput, } from "../../policy/index.js";
 import { toErrorMessage } from "../../utils/errors.js";
 import { ensureFileExists } from "../../utils/fs.js";
 import { getGitStderr, getHeadRevision, runGitCommand, } from "../../utils/git.js";
 import { resolveDisplayPath } from "../../utils/path.js";
 import { fetchRunSafely } from "../fetch.js";
-import { ApplyAgentDiffMissingOnDiskError, ApplyAgentDiffNotRecordedError, ApplyAgentNotFoundError, ApplyBaseMismatchError, ApplyPatchApplicationError, ApplyRunDeletedError, } from "./errors.js";
+import { ApplyAgentDiffMissingOnDiskError, ApplyAgentDiffNotRecordedError, ApplyAgentNotFoundError, ApplyAgentSelectorAmbiguousError, ApplyAgentSelectorUnresolvedError, ApplyAgentSummaryEmptyError, ApplyAgentSummaryMissingOnDiskError, ApplyAgentSummaryNotRecordedError, ApplyBaseMismatchError, ApplyGitCommitError, ApplyPatchApplicationError, ApplyVerificationPolicyLoadError, } from "./errors.js";
 export async function executeApplyCommand(input) {
-    const { root, runsFilePath, runId, agentId, ignoreBaseMismatch } = input;
+    const { root, runsFilePath, verificationsFilePath, runId, agentId: selector, ignoreBaseMismatch, commit = false, } = input;
     const runRecord = await fetchRunSafely({
         root,
         runsFilePath,
         runId,
-        onDeleted: (record) => new ApplyRunDeletedError(record.runId),
     });
     const enhanced = buildRunRecordEnhanced(runRecord);
+    const agentId = await resolveApplyAgentSelector({
+        root,
+        runId,
+        selector,
+        canonicalAgentIds: runRecord.agents.map((agent) => agent.agentId),
+        verificationsFilePath,
+    });
     const agentRecord = runRecord.agents.find((agent) => agent.agentId === agentId);
     if (!agentRecord) {
         throw new ApplyAgentNotFoundError(runId, agentId);
@@ -30,6 +39,8 @@ export async function executeApplyCommand(input) {
     }
     const diffAbsolutePath = resolveDisplayPath(root, diffDisplayPath) ?? diffDisplayPath;
     await ensureFileExists(diffAbsolutePath, () => new ApplyAgentDiffMissingOnDiskError(diffDisplayPath));
+    const summaryRecorded = agentRecord.artifacts?.summaryCaptured ?? false;
+    const summaryDisplayPath = enhancedAgent.assets.summaryPath;
     const headRevision = await getHeadRevision(root);
     const baseRevisionSha = runRecord.baseRevisionSha;
     const baseMismatch = headRevision !== baseRevisionSha;
@@ -63,6 +74,30 @@ export async function executeApplyCommand(input) {
         }
         throw error;
     }
+    let appliedCommitSha;
+    if (commit) {
+        try {
+            appliedCommitSha = await commitAppliedDiff({
+                root,
+                runId,
+                agentId,
+                summaryRecorded,
+                summaryDisplayPath,
+            });
+        }
+        catch (error) {
+            await recordApplyStatus({
+                root,
+                runsFilePath,
+                runId,
+                agentId,
+                ignoredBaseMismatch,
+                status: "failed",
+                detail: extractCommitFailureDetail(error),
+            });
+            throw error;
+        }
+    }
     await recordApplyStatus({
         root,
         runsFilePath,
@@ -70,6 +105,7 @@ export async function executeApplyCommand(input) {
         agentId,
         ignoredBaseMismatch,
         status: "succeeded",
+        appliedCommitSha,
     });
     return {
         runId: runRecord.runId,
@@ -81,8 +117,70 @@ export async function executeApplyCommand(input) {
         agent: agentRecord,
         diffPath: diffDisplayPath,
         ignoredBaseMismatch,
+        ...(appliedCommitSha ? { appliedCommitSha } : {}),
     };
 }
+async function resolveApplyAgentSelector(options) {
+    const { root, runId, selector, canonicalAgentIds, verificationsFilePath } = options;
+    if (canonicalAgentIds.includes(selector)) {
+        return selector;
+    }
+    const effectiveVerificationsPath = verificationsFilePath ?? `${root}/.voratiq/verify/index.json`;
+    const verificationRecords = await readVerificationRecords({
+        root,
+        verificationsFilePath: effectiveVerificationsPath,
+        predicate: (record) => record.target.kind === "run" && record.target.sessionId === runId,
+    }).catch(() => []);
+    const verificationFailures = [];
+    const sources = (await Promise.all(verificationRecords.map(async (record) => {
+        try {
+            const output = await loadVerificationSelectionPolicyOutput({
+                root,
+                record,
+            });
+            return buildVerificationSelectorSource(output);
+        }
+        catch (error) {
+            verificationFailures.push({
+                verificationId: record.sessionId,
+                detail: toErrorMessage(error),
+            });
+            return undefined;
+        }
+    }))).filter((source) => source !== undefined);
+    const selectorDecision = deriveSelectorSelectionDecision({
+        selector,
+        canonicalAgentIds,
+        sources,
+    });
+    if (selectorDecision.state === "resolvable") {
+        return selectorDecision.selectedCanonicalAgentId;
+    }
+    if (verificationFailures.length > 0) {
+        throw new ApplyVerificationPolicyLoadError({
+            runId,
+            verificationFailures,
+        });
+    }
+    const ambiguousReason = selectorDecision.unresolvedReasons.find((reason) => reason.code === "selector_ambiguous");
+    if (ambiguousReason) {
+        throw new ApplyAgentSelectorAmbiguousError({
+            runId,
+            selector,
+            matches: ambiguousReason.resolutions.map((resolution) => ({
+                verificationId: resolution.sourceId,
+                agentId: resolution.selectedCanonicalAgentId,
+            })),
+        });
+    }
+    const unresolvedReason = selectorDecision.unresolvedReasons.find((reason) => reason.code === "selector_unresolved");
+    throw new ApplyAgentSelectorUnresolvedError({
+        runId,
+        selector,
+        canonicalAgentIds,
+        aliases: unresolvedReason?.availableAliases ?? [],
+    });
+}
 async function applyPatch(options) {
     const { root, diffAbsolutePath, diffDisplayPath, runId, agentId } = options;
     try {
@@ -96,7 +194,7 @@ async function applyPatch(options) {
     }
 }
 async function recordApplyStatus(options) {
-    const { root, runsFilePath, runId, agentId, status, ignoredBaseMismatch, detail, } = options;
+    const { root, runsFilePath, runId, agentId, status, ignoredBaseMismatch, appliedCommitSha, detail, } = options;
     const appliedAt = new Date().toISOString();
     const normalizedDetail = typeof detail === "string" && detail.length > 0
         ? truncateDetail(detail)
@@ -115,11 +213,15 @@ async function recordApplyStatus(options) {
             if (normalizedDetail !== undefined) {
                 applyStatus.detail = normalizedDetail;
             }
+            if (typeof appliedCommitSha === "string" && appliedCommitSha.length > 0) {
+                applyStatus.appliedCommitSha = appliedCommitSha;
+            }
             return {
                 ...record,
                 applyStatus,
             };
         },
+        forceFlush: true,
     });
 }
 function extractApplyFailureDetail(error) {
@@ -129,7 +231,44 @@ function extractApplyFailureDetail(error) {
     }
     return error.message;
 }
+function extractCommitFailureDetail(error) {
+    const stderr = getGitStderr(error);
+    if (stderr && stderr.trim().length > 0) {
+        const [firstLine] = stderr.split(/\r?\n/);
+        if (firstLine && firstLine.trim().length > 0) {
+            return firstLine.trim();
+        }
+        return stderr.trim();
+    }
+    return toErrorMessage(error);
+}
 function truncateDetail(detail) {
     const trimmed = detail.trim();
     return trimmed.length > 256 ? trimmed.slice(0, 256) : trimmed;
 }
+async function commitAppliedDiff(options) {
+    const { root, runId, agentId, summaryRecorded, summaryDisplayPath } = options;
+    if (!summaryRecorded || !summaryDisplayPath) {
+        throw new ApplyAgentSummaryNotRecordedError(runId, agentId);
+    }
+    const summaryAbsolutePath = resolveDisplayPath(root, summaryDisplayPath) ?? summaryDisplayPath;
+    await ensureFileExists(summaryAbsolutePath, () => new ApplyAgentSummaryMissingOnDiskError(summaryDisplayPath));
+    const rawSummary = await readFile(summaryAbsolutePath, "utf8");
+    const commitSubject = normalizeCommitSubject(rawSummary);
+    if (!commitSubject) {
+        throw new ApplyAgentSummaryEmptyError(summaryDisplayPath);
+    }
+    try {
+        await runGitCommand(["add", "-A"], { cwd: root });
+        await runGitCommand(["commit", "-m", commitSubject], { cwd: root });
+        return await runGitCommand(["rev-parse", "HEAD"], { cwd: root });
+    }
+    catch (error) {
+        const detail = getGitStderr(error) ?? toErrorMessage(error);
+        throw new ApplyGitCommitError(detail);
+    }
+}
+function normalizeCommitSubject(summary) {
+    const normalized = summary.trim().replace(/\s+/gu, " ");
+    return normalized.length > 0 ? normalized : "";
+}

package/dist/commands/apply/errors.d.ts

@@ -2,10 +2,6 @@ import { CliError } from "../../cli/errors.js";
 export declare class ApplyError extends CliError {
     constructor(headline: string, detailLines?: readonly string[], hintLines?: readonly string[]);
 }
-export declare class ApplyRunDeletedError extends ApplyError {
-    readonly runId: string;
-    constructor(runId: string);
-}
 export declare class ApplyRunMetadataCorruptedError extends ApplyError {
     constructor(detail: string);
 }
@@ -14,6 +10,33 @@ export declare class ApplyAgentNotFoundError extends ApplyError {
     readonly agentId: string;
     constructor(runId: string, agentId: string);
 }
+export declare class ApplyAgentSelectorUnresolvedError extends ApplyError {
+    constructor(options: {
+        runId: string;
+        selector: string;
+        canonicalAgentIds: readonly string[];
+        aliases: readonly string[];
+    });
+}
+export declare class ApplyAgentSelectorAmbiguousError extends ApplyError {
+    constructor(options: {
+        runId: string;
+        selector: string;
+        matches: Array<{
+            verificationId: string;
+            agentId: string;
+        }>;
+    });
+}
+export declare class ApplyVerificationPolicyLoadError extends ApplyError {
+    constructor(options: {
+        runId: string;
+        verificationFailures: readonly {
+            verificationId: string;
+            detail: string;
+        }[];
+    });
+}
 export declare class ApplyAgentDiffNotRecordedError extends ApplyError {
     readonly runId: string;
     readonly agentId: string;
@@ -23,6 +46,22 @@ export declare class ApplyAgentDiffMissingOnDiskError extends ApplyError {
     readonly diffPath: string;
     constructor(diffPath: string);
 }
+export declare class ApplyAgentSummaryNotRecordedError extends ApplyError {
+    readonly runId: string;
+    readonly agentId: string;
+    constructor(runId: string, agentId: string);
+}
+export declare class ApplyAgentSummaryMissingOnDiskError extends ApplyError {
+    readonly summaryPath: string;
+    constructor(summaryPath: string);
+}
+export declare class ApplyAgentSummaryEmptyError extends ApplyError {
+    readonly summaryPath: string;
+    constructor(summaryPath: string);
+}
+export declare class ApplyGitCommitError extends ApplyError {
+    constructor(detail: string);
+}
 export interface ApplyBaseMismatchOptions {
     baseRevisionSha: string;
     headRevision: string;

package/dist/commands/apply/errors.js

@@ -5,19 +5,9 @@ export class ApplyError extends CliError {
         this.name = "ApplyError";
     }
 }
-export class ApplyRunDeletedError extends ApplyError {
-    runId;
-    constructor(runId) {
-        super(`Run ${runId} has been deleted.`, [], ["Re-run the spec to generate fresh artifacts before applying."]);
-        this.runId = runId;
-        this.name = "ApplyRunDeletedError";
-    }
-}
 export class ApplyRunMetadataCorruptedError extends ApplyError {
     constructor(detail) {
-        super("Run history is corrupted; cannot apply.", [detail], [
-            "Inspect `.voratiq/runs/index.json` and the affected run directory under `.voratiq/runs/sessions/<id>` or regenerate the run with `voratiq run`.",
-        ]);
+        super("Run history is corrupted.", [detail], ["Check `run/index.json` and the affected session directory."]);
         this.name = "ApplyRunMetadataCorruptedError";
     }
 }
@@ -25,19 +15,75 @@ export class ApplyAgentNotFoundError extends ApplyError {
     runId;
     agentId;
     constructor(runId, agentId) {
-        super(`Agent ${agentId} not found in run ${runId}.`, [], [`To review run information: voratiq review --run ${runId}.`]);
+        super(`Agent \`${agentId}\` not found in run \`${runId}\`.`, [], ["Check available agents with `voratiq list --run <run-id>`."]);
         this.runId = runId;
         this.agentId = agentId;
         this.name = "ApplyAgentNotFoundError";
     }
 }
+export class ApplyAgentSelectorUnresolvedError extends ApplyError {
+    constructor(options) {
+        const { runId, selector, canonicalAgentIds, aliases } = options;
+        const canonicalPreview = canonicalAgentIds
+            .slice(0, 20)
+            .map((agentId) => `\`${agentId}\``)
+            .join(", ");
+        const aliasPreview = aliases
+            .slice(0, 20)
+            .map((alias) => `\`${alias}\``)
+            .join(", ");
+        const detailLines = [
+            ...(canonicalAgentIds.length > 0
+                ? [
+                    `Available agent ids: ${canonicalPreview}${canonicalAgentIds.length > 20 ? ", ..." : ""}.`,
+                ]
+                : []),
+            ...(aliases.length > 0
+                ? [
+                    `Available blinded aliases: ${aliasPreview}${aliases.length > 20 ? ", ..." : ""}.`,
+                ]
+                : []),
+        ];
+        super(`Agent selector \`${selector}\` did not match run \`${runId}\`.`, detailLines, [
+            "Use an agent id or a verification-selected blinded alias for this run.",
+        ]);
+        this.name = "ApplyAgentSelectorUnresolvedError";
+    }
+}
+export class ApplyAgentSelectorAmbiguousError extends ApplyError {
+    constructor(options) {
+        const { runId, selector, matches } = options;
+        const lines = matches
+            .slice(0, 10)
+            .map((match) => `- \`${match.verificationId}\`: \`${match.agentId}\``);
+        super(`Blinded alias \`${selector}\` is ambiguous for run \`${runId}\`.`, [
+            "This alias resolves differently across verification sessions:",
+            ...lines,
+            matches.length > 10 ? "- ..." : "",
+        ].filter((line) => line.length > 0), ["Use a canonical agent id for this run."]);
+        this.name = "ApplyAgentSelectorAmbiguousError";
+    }
+}
+export class ApplyVerificationPolicyLoadError extends ApplyError {
+    constructor(options) {
+        const { runId, verificationFailures } = options;
+        const detailLines = verificationFailures
+            .slice(0, 10)
+            .flatMap((failure) => [
+            `Verification: \`${failure.verificationId}\`.`,
+            failure.detail,
+        ]);
+        super(`Failed to load verification policy data for run \`${runId}\`.`, detailLines, [
+            "Re-run `voratiq verify` for this run to regenerate verification artifacts.",
+        ]);
+        this.name = "ApplyVerificationPolicyLoadError";
+    }
+}
 export class ApplyAgentDiffNotRecordedError extends ApplyError {
     runId;
     agentId;
     constructor(runId, agentId) {
-        super(`Agent ${agentId} did not record a diff for run ${runId}.`, [
-            `Select an agent that produced a diff via \`voratiq review --run ${runId}\`.`,
-        ]);
+        super(`Agent \`${agentId}\` did not record a diff for run \`${runId}\`.`, [], ["Select an agent that produced a diff in the recorded run."]);
         this.runId = runId;
         this.agentId = agentId;
         this.name = "ApplyAgentDiffNotRecordedError";
@@ -46,25 +92,57 @@ export class ApplyAgentDiffNotRecordedError extends ApplyError {
 export class ApplyAgentDiffMissingOnDiskError extends ApplyError {
     diffPath;
     constructor(diffPath) {
-        super("Recorded diff is missing from disk.", [`Expected diff at ${diffPath} but it was not found.`], ["Ensure the run directory still exists or re-run the agents."]);
+        super("Recorded diff is missing from disk.", [`Expected diff: \`${diffPath}\`.`], ["Re-run to regenerate artifacts."]);
         this.diffPath = diffPath;
         this.name = "ApplyAgentDiffMissingOnDiskError";
     }
 }
+export class ApplyAgentSummaryNotRecordedError extends ApplyError {
+    runId;
+    agentId;
+    constructor(runId, agentId) {
+        super(`Agent \`${agentId}\` did not record a summary for run \`${runId}\`.`, ["A summary artifact is required when using `--commit`."], ["Apply without `--commit` and write the commit message manually."]);
+        this.runId = runId;
+        this.agentId = agentId;
+        this.name = "ApplyAgentSummaryNotRecordedError";
+    }
+}
+export class ApplyAgentSummaryMissingOnDiskError extends ApplyError {
+    summaryPath;
+    constructor(summaryPath) {
+        super("Recorded summary is missing from disk.", [`Expected summary: \`${summaryPath}\`.`], ["Re-run to regenerate artifacts."]);
+        this.summaryPath = summaryPath;
+        this.name = "ApplyAgentSummaryMissingOnDiskError";
+    }
+}
+export class ApplyAgentSummaryEmptyError extends ApplyError {
+    summaryPath;
+    constructor(summaryPath) {
+        super("Recorded summary is empty.", [`Expected summary with a commit subject: \`${summaryPath}\`.`], ["Apply without `--commit` and write the commit message manually."]);
+        this.summaryPath = summaryPath;
+        this.name = "ApplyAgentSummaryEmptyError";
+    }
+}
+export class ApplyGitCommitError extends ApplyError {
+    constructor(detail) {
+        super("Failed to create git commit.", [detail], ["The diff remains applied; resolve the issue and commit manually."]);
+        this.name = "ApplyGitCommitError";
+    }
+}
 export class ApplyBaseMismatchError extends ApplyError {
     constructor(options) {
         const { baseRevisionSha, headRevision } = options;
-        super(`Repository HEAD (${shortSha(headRevision)}) no longer matches the run's base revision (${shortSha(baseRevisionSha)}).`, [
-            "Reset to the recorded base or rerun the specification, or pass `--ignore-base-mismatch` to proceed at your own risk.",
-        ]);
+        super(`Repository HEAD \`${shortSha(headRevision)}\` no longer matches run base \`${shortSha(baseRevisionSha)}\`.`, [], ["Use `--ignore-base-mismatch` to apply anyway (conflicts may occur)."]);
         this.name = "ApplyBaseMismatchError";
     }
 }
 export class ApplyPatchApplicationError extends ApplyError {
     constructor(detail, diffPath, runId, agentId) {
-        super("Failed to apply the recorded diff.", [detail, `Inspect the patch at ${diffPath} for additional context.`], [
-            `Resolve the conflict and rerun \`voratiq apply --run ${runId} --agent ${agentId}\`.`,
-        ]);
+        super("Failed to apply recorded diff.", [
+            detail,
+            `Run: \`${runId}\`, agent: \`${agentId}\`.`,
+            `Patch: \`${diffPath}\`.`,
+        ], ["Resolve the conflict, then re-run apply for the same run and agent."]);
         this.name = "ApplyPatchApplicationError";
     }
 }

package/dist/commands/apply/types.d.ts

@@ -1,4 +1,4 @@
-import type { AgentInvocationRecord } from "../../records/types.js";
+import type { AgentInvocationRecord } from "../../domain/run/model/types.js";
 import type { RunStatus } from "../../status/index.js";
 export interface ApplyResult {
     runId: string;
@@ -10,4 +10,5 @@ export interface ApplyResult {
     agent: AgentInvocationRecord;
     diffPath: string;
     ignoredBaseMismatch: boolean;
+    appliedCommitSha?: string;
 }

package/dist/commands/auto/command.d.ts

@@ -0,0 +1,145 @@
+import type { AutoApplyStatus, AutoTerminalStatus } from "../../domain/run/model/types.js";
+import type { SelectionDecision } from "../../policy/index.js";
+import { type RunStatus } from "../../status/index.js";
+export interface ExecuteAutoCommandInput {
+    specPath?: string;
+    description?: string;
+    runAgentIds?: readonly string[];
+    verifyAgentIds?: readonly string[];
+    profile?: string;
+    maxParallel?: number;
+    branch?: boolean;
+    apply?: boolean;
+    commit?: boolean;
+}
+export interface AutoSpecStageInput {
+    description: string;
+    profile?: string;
+    maxParallel?: number;
+    suppressHint: boolean;
+}
+export interface AutoSpecStageResult {
+    body: string;
+    sessionId: string;
+    generatedSpecPaths?: readonly string[];
+    specPath?: string;
+}
+export interface AutoRunAgentResult {
+    agentId: string;
+}
+export interface AutoRunStageReport {
+    runId: string;
+    status: RunStatus;
+    createdAt: string;
+    baseRevisionSha: string;
+    spec?: {
+        path?: string;
+    };
+    agents: readonly AutoRunAgentResult[];
+}
+export interface AutoRunStageInput {
+    specPath: string;
+    agentIds?: readonly string[];
+    agentOverrideFlag: string;
+    profile?: string;
+    maxParallel?: number;
+    branch?: boolean;
+}
+export interface AutoRunStageResult {
+    report: AutoRunStageReport;
+    body: string;
+    exitCode?: number;
+}
+export interface AutoVerifyStageInput {
+    target: {
+        kind: "spec" | "run";
+        sessionId: string;
+    };
+    agentIds?: readonly string[];
+    agentOverrideFlag: string;
+    profile?: string;
+    maxParallel?: number;
+    suppressHint: boolean;
+}
+export interface AutoVerifyStageResult {
+    verificationId?: string;
+    body: string;
+    stderr?: string;
+    exitCode?: number;
+    selectedSpecPath?: string;
+    selection?: SelectionDecision;
+    selectionWarnings?: readonly string[];
+}
+export interface AutoApplyStageInput {
+    runId: string;
+    agentId: string;
+    commit: boolean;
+}
+export interface AutoApplyStageResult {
+    body: string;
+    exitCode?: number;
+}
+export type AutoCommandEvent = {
+    kind: "body";
+    body: string;
+    stderr?: string;
+    exitCode?: number;
+} | {
+    kind: "warning";
+    detail: string;
+    separateWithDivider: boolean;
+} | {
+    kind: "error";
+    error: unknown;
+} | {
+    kind: "action_required";
+    detail: string;
+    separateWithDivider: boolean;
+};
+export interface AutoPhaseSummary {
+    status: "succeeded" | "failed" | "skipped";
+    durationMs?: number;
+    detail?: string;
+}
+export interface AutoExecutionSummary {
+    status: AutoTerminalStatus;
+    totalDurationMs: number;
+    spec: AutoPhaseSummary & {
+        specPath?: string;
+    };
+    run: AutoPhaseSummary & {
+        runId?: string;
+        runStatus?: RunStatus;
+        createdAt?: string;
+        specPath?: string;
+        baseRevisionSha?: string;
+    };
+    verify: AutoPhaseSummary;
+    apply: AutoPhaseSummary & {
+        agentId?: string;
+    };
+}
+export interface ExecuteAutoCommandResult {
+    exitCode: number;
+    runId?: string;
+    appliedAgentId?: string;
+    auto: {
+        status: AutoTerminalStatus;
+        detail?: string;
+    };
+    apply: {
+        status: AutoApplyStatus;
+        detail?: string;
+    };
+    summary: AutoExecutionSummary;
+    events: readonly AutoCommandEvent[];
+}
+export interface AutoCommandDependencies {
+    now?: () => number;
+    onEvent?: (event: AutoCommandEvent) => void;
+    runSpecStage: (input: AutoSpecStageInput) => Promise<AutoSpecStageResult>;
+    runRunStage: (input: AutoRunStageInput) => Promise<AutoRunStageResult>;
+    runVerifyStage: (input: AutoVerifyStageInput) => Promise<AutoVerifyStageResult>;
+    runApplyStage: (input: AutoApplyStageInput) => Promise<AutoApplyStageResult>;
+}
+export declare function executeAutoCommand(options: ExecuteAutoCommandInput, dependencies: AutoCommandDependencies): Promise<ExecuteAutoCommandResult>;