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

package/dist/auth/providers/gemini.js

@@ -42,10 +42,18 @@ export const geminiAuthProvider = {
     },
     async stage(options) {
         const apiKey = resolveGeminiApiKey(options.runtime.env);
+        const sandboxPaths = createSandboxPaths(options.agentRoot, {
+            gemini: [".gemini"],
+            tmp: ["tmp"],
+        });
+        await ensureDirectories([...Object.values(sandboxPaths)]);
         if (apiKey) {
-            return composeSandboxEnvResult(options.agentRoot, {
+            return composeSandboxEnvResult(sandboxPaths.home, {
                 GEMINI_API_KEY: apiKey,
                 GOOGLE_API_KEY: apiKey,
+                TMPDIR: sandboxPaths.tmp,
+                TEMP: sandboxPaths.tmp,
+                TMP: sandboxPaths.tmp,
             });
         }
         const homeDir = options.runtime.homeDir;
@@ -57,10 +65,6 @@ export const geminiAuthProvider = {
             const source = resolveChildPath(geminiHome, filename);
             await assertReadableFileOrThrow(source, (cause) => new GeminiAuthProviderError(GEMINI_LOGIN_HINT, { cause }));
         }
-        const sandboxPaths = createSandboxPaths(options.agentRoot, {
-            gemini: [".gemini"],
-        });
-        await ensureDirectories([...Object.values(sandboxPaths)]);
         const secretHandles = await stageRequiredFiles(geminiHome, sandboxPaths.gemini, sandboxPaths.home);
         try {
             await stageOptionalFiles(geminiHome, sandboxPaths.gemini, sandboxPaths.home);
@@ -70,7 +74,11 @@ export const geminiAuthProvider = {
             throw error;
         }
         registerSandboxSecrets(sandboxPaths.home, secretHandles);
-        return composeSandboxEnvResult(sandboxPaths.home, {});
+        return composeSandboxEnvResult(sandboxPaths.home, {
+            TMPDIR: sandboxPaths.tmp,
+            TEMP: sandboxPaths.tmp,
+            TMP: sandboxPaths.tmp,
+        });
     },
     async teardown(options) {
         await teardownAuthProvider(options);

package/dist/auth/providers/types.d.ts

@@ -15,6 +15,7 @@ export interface StageOptions extends VerifyOptions {
     agentRoot: string;
     runId?: string;
     root?: string;
+    includeConfigToml?: boolean;
 }
 export interface StageResult {
     sandboxPath: string;

package/dist/auth/providers/utils.d.ts

@@ -15,6 +15,5 @@ export declare function assertReadableFileOrThrow(path: string, createError: Err
 export declare function copyFileWithPermissions(source: string, destination: string, mode?: number): Promise<void>;
 export declare function writeFileWithPermissions(destination: string, data: string | NodeJS.ArrayBufferView, options?: Parameters<typeof writeFile>[2], mode?: number): Promise<void>;
 export declare function copyOptionalFileWithPermissions(source: string, destination: string, createError?: ErrorFactory): Promise<void>;
-export declare function copyOptionalDirectoryWithPermissions(source: string, destination: string, createError?: ErrorFactory, fileMode?: number, dirMode?: number): Promise<void>;
 export declare function composeSandboxEnvResult(sandboxPath: string, env: Record<string, string>): StageResult;
 export declare function teardownSandbox({ sandboxPath, }: TeardownOptions): Promise<void>;

package/dist/auth/providers/utils.js

@@ -1,5 +1,5 @@
 import { constants as fsConstants } from "node:fs";
-import { access, chmod, copyFile, mkdir, readdir, rm, stat, writeFile, } from "node:fs/promises";
+import { access, chmod, copyFile, mkdir, rm, stat, writeFile, } from "node:fs/promises";
 import { isAbsolute, resolve as resolveNative } from "node:path";
 import { isMissing } from "../../utils/fs.js";
 import { SANDBOX_DIRNAME } from "../../workspace/structure.js";
@@ -86,54 +86,6 @@ export async function copyOptionalFileWithPermissions(source, destination, creat
         throw error;
     }
 }
-export async function copyOptionalDirectoryWithPermissions(source, destination, createError, fileMode = STAGED_FILE_MODE, dirMode = 0o700) {
-    try {
-        const sourceStats = await stat(source);
-        if (!sourceStats.isDirectory()) {
-            if (createError) {
-                throw createError();
-            }
-            return;
-        }
-    }
-    catch (error) {
-        if (isMissing(error)) {
-            return;
-        }
-        if (createError) {
-            throw createError(error);
-        }
-        throw error;
-    }
-    try {
-        await copyDirectoryRecursive(source, destination, fileMode, dirMode);
-    }
-    catch (error) {
-        if (isMissing(error)) {
-            return;
-        }
-        if (createError) {
-            throw createError(error);
-        }
-        throw error;
-    }
-}
-async function copyDirectoryRecursive(source, destination, fileMode, dirMode) {
-    await mkdir(destination, { recursive: true, mode: dirMode });
-    await chmod(destination, dirMode).catch(() => { });
-    const entries = await readdir(source, { withFileTypes: true });
-    for (const entry of entries) {
-        const sourcePath = resolveChildPath(source, entry.name);
-        const destinationPath = resolveChildPath(destination, entry.name);
-        if (entry.isDirectory()) {
-            await copyDirectoryRecursive(sourcePath, destinationPath, fileMode, dirMode);
-            continue;
-        }
-        if (entry.isFile()) {
-            await copyFileWithPermissions(sourcePath, destinationPath, fileMode);
-        }
-    }
-}
 export function composeSandboxEnvResult(sandboxPath, env) {
     return {
         sandboxPath,

package/dist/bin.js

@@ -3,119 +3,416 @@ import { realpathSync } from "node:fs";
 import { resolve } from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
-import { Command, CommanderError } from "commander";
-import { createApplyCommand } from "./cli/apply.js";
-import { commanderAlreadyRendered } from "./cli/commander-utils.js";
-import { CliError, toCliError } from "./cli/errors.js";
-import { createInitCommand } from "./cli/init.js";
-import { createListCommand } from "./cli/list.js";
-import { writeCommandOutput } from "./cli/output.js";
-import { createPruneCommand } from "./cli/prune.js";
-import { createReviewCommand } from "./cli/review.js";
-import { createRunCommand } from "./cli/run.js";
-import { terminateActiveRun } from "./commands/run/lifecycle.js";
-import { flushAllRunRecordBuffers } from "./records/persistence.js";
-import { renderCliError } from "./render/utils/errors.js";
-import { toErrorMessage } from "./utils/errors.js";
-import { getVoratiqVersion } from "./utils/version.js";
 const SIGNAL_EXIT_CODES = {
+    SIGHUP: 129,
     SIGINT: 130,
     SIGTERM: 143,
 };
+let activeJsonEnvelopeOperator;
+let processGuardsInstalled = false;
 function installProcessGuards() {
-    process.once("SIGINT", () => {
-        void handleSignal("SIGINT");
-    });
-    process.once("SIGTERM", () => {
-        void handleSignal("SIGTERM");
-    });
-    process.on("uncaughtException", (error) => {
-        void terminateActiveRun("failed")
-            .catch((teardownError) => {
-            console.error(`[voratiq] Failed to teardown run after uncaught exception: ${toErrorMessage(teardownError)}`);
-        })
-            .finally(async () => {
-            await flushPendingHistory();
-            console.error(error);
-            process.exit(1);
+    if (processGuardsInstalled) {
+        return;
+    }
+    processGuardsInstalled = true;
+    for (const signal of ["SIGHUP", "SIGINT", "SIGTERM"]) {
+        process.once(signal, () => {
+            void handleSignal(signal);
         });
+    }
+    process.on("uncaughtException", (error) => {
+        void handleFatalError("uncaught exception", error);
     });
     process.on("unhandledRejection", (reason) => {
-        void terminateActiveRun("failed")
-            .catch((teardownError) => {
-            console.error(`[voratiq] Failed to teardown run after unhandled rejection: ${toErrorMessage(teardownError)}`);
-        })
-            .finally(async () => {
-            await flushPendingHistory();
-            console.error(reason);
-            process.exit(1);
-        });
+        void handleFatalError("unhandled rejection", reason);
     });
 }
+async function handleFatalError(context, error) {
+    await terminateActiveSessionsSafe("failed", context);
+    await flushPendingHistory();
+    if (activeJsonEnvelopeOperator) {
+        const { buildFailedOperatorEnvelope, writeOperatorResultEnvelope } = await import("./cli/operator-envelope.js");
+        writeOperatorResultEnvelope(buildFailedOperatorEnvelope({
+            operator: activeJsonEnvelopeOperator,
+            error,
+        }), 1);
+        process.exit(1);
+        return;
+    }
+    const { CliError, toCliError } = await import("./cli/errors.js");
+    const { renderCliError } = await import("./render/utils/errors.js");
+    const normalized = toCliError(error);
+    const rendered = renderCliError(new CliError(normalized.headline, [`Context: ${context}.`, ...normalized.detailLines], normalized.hintLines));
+    console.error(rendered);
+    process.exit(1);
+}
 async function handleSignal(signal) {
     const exitCode = SIGNAL_EXIT_CODES[signal] ?? 1;
-    try {
-        await terminateActiveRun("aborted");
-    }
-    catch (error) {
-        console.error(`[voratiq] Failed to teardown run after ${signal}: ${toErrorMessage(error)}`);
+    const teardownError = await terminateActiveSessionsSafe("aborted", signal);
+    if (teardownError) {
         await flushPendingHistory();
         process.exit(1);
         return;
     }
     await flushPendingHistory();
+    if (activeJsonEnvelopeOperator) {
+        const { buildFailedOperatorEnvelope, writeOperatorResultEnvelope } = await import("./cli/operator-envelope.js");
+        writeOperatorResultEnvelope(buildFailedOperatorEnvelope({
+            operator: activeJsonEnvelopeOperator,
+            error: new Error(`Signal received: ${signal}`),
+        }), exitCode);
+    }
     process.exit(exitCode);
 }
 async function flushPendingHistory() {
     try {
+        const { flushAllSpecRecordBuffers } = await import("./domain/spec/persistence/adapter.js");
+        await flushAllSpecRecordBuffers();
+    }
+    catch (error) {
+        console.warn(`[voratiq] Failed to flush spec history buffers: ${error.message}`);
+    }
+    try {
+        const { flushAllRunRecordBuffers } = await import("./domain/run/persistence/adapter.js");
         await flushAllRunRecordBuffers();
     }
     catch (error) {
         console.warn(`[voratiq] Failed to flush run history buffers: ${error.message}`);
     }
+    try {
+        const { flushAllReductionRecordBuffers } = await import("./domain/reduce/persistence/adapter.js");
+        await flushAllReductionRecordBuffers();
+    }
+    catch (error) {
+        console.warn(`[voratiq] Failed to flush reduction history buffers: ${error.message}`);
+    }
+    try {
+        const { flushAllVerificationRecordBuffers } = await import("./domain/verify/persistence/adapter.js");
+        await flushAllVerificationRecordBuffers();
+    }
+    catch (error) {
+        console.warn(`[voratiq] Failed to flush verification history buffers: ${error.message}`);
+    }
+    try {
+        const { flushAllMessageRecordBuffers } = await import("./domain/message/persistence/adapter.js");
+        await flushAllMessageRecordBuffers();
+    }
+    catch (error) {
+        console.warn(`[voratiq] Failed to flush message history buffers: ${error.message}`);
+    }
+    try {
+        const { flushAllInteractiveSessionBuffers } = await import("./domain/interactive/persistence/adapter.js");
+        await flushAllInteractiveSessionBuffers();
+    }
+    catch (error) {
+        console.warn(`[voratiq] Failed to flush interactive history buffers: ${error.message}`);
+    }
+}
+async function terminateActiveRunSafe(status, context) {
+    try {
+        const { terminateActiveRun } = await import("./commands/run/lifecycle.js");
+        await terminateActiveRun(status);
+        return null;
+    }
+    catch (error) {
+        const { toErrorMessage } = await import("./utils/errors.js");
+        const normalizedError = error instanceof Error ? error : new Error(toErrorMessage(error));
+        console.error(`[voratiq] Failed to teardown run after ${context}: ${toErrorMessage(error)}`);
+        return normalizedError;
+    }
+}
+async function terminateActiveVerificationSafe(status, context) {
+    try {
+        const { terminateActiveVerification } = await import("./commands/verify/lifecycle.js");
+        await terminateActiveVerification(status);
+        return null;
+    }
+    catch (error) {
+        const { toErrorMessage } = await import("./utils/errors.js");
+        const normalizedError = error instanceof Error ? error : new Error(toErrorMessage(error));
+        console.error(`[voratiq] Failed to teardown verification after ${context}: ${toErrorMessage(error)}`);
+        return normalizedError;
+    }
+}
+async function terminateActiveInteractiveSafe(status, context) {
+    try {
+        const { terminateActiveInteractive } = await import("./commands/interactive/lifecycle.js");
+        await terminateActiveInteractive(status, context);
+        return null;
+    }
+    catch (error) {
+        const { toErrorMessage } = await import("./utils/errors.js");
+        const normalizedError = error instanceof Error ? error : new Error(toErrorMessage(error));
+        console.error(`[voratiq] Failed to teardown interactive session after ${context}: ${toErrorMessage(error)}`);
+        return normalizedError;
+    }
+}
+async function terminateActiveMessageSafe(status, context) {
+    try {
+        const { terminateActiveMessage } = await import("./commands/message/lifecycle.js");
+        await terminateActiveMessage(status);
+        return null;
+    }
+    catch (error) {
+        const { toErrorMessage } = await import("./utils/errors.js");
+        const normalizedError = error instanceof Error ? error : new Error(toErrorMessage(error));
+        console.error(`[voratiq] Failed to teardown message after ${context}: ${toErrorMessage(error)}`);
+        return normalizedError;
+    }
+}
+async function terminateActiveSessionsSafe(status, context) {
+    const runError = await terminateActiveRunSafe(status, context);
+    const verificationError = await terminateActiveVerificationSafe(status, context);
+    const interactiveError = await terminateActiveInteractiveSafe(status, context);
+    const messageError = await terminateActiveMessageSafe(status, context);
+    const errors = [
+        runError,
+        verificationError,
+        interactiveError,
+        messageError,
+    ].filter((error) => error instanceof Error);
+    if (errors.length > 1) {
+        return new AggregateError(errors, `Failed to teardown active sessions after ${context}`);
+    }
+    return errors[0] ?? null;
 }
-installProcessGuards();
 export async function runCli(argv = process.argv) {
+    installProcessGuards();
+    const { Command, CommanderError } = await import("commander");
     const program = new Command();
+    const effectiveArgv = argv;
+    const { resolveJsonEnvelopeOperator } = await import("./cli/operator-envelope.js");
+    const jsonEnvelopeOperator = resolveJsonEnvelopeOperator(effectiveArgv);
+    activeJsonEnvelopeOperator = jsonEnvelopeOperator;
+    const commandName = findCommandName(effectiveArgv);
+    const localVersion = (await import("./utils/version.js")).getVoratiqVersion();
     program
         .name("voratiq")
-        .description("Voratiq CLI")
-        .version(getVoratiqVersion(), "-v, --version", "print the Voratiq version")
+        .description("Agent ensembles to design, generate, and select the best code for every task.")
+        .enablePositionalOptions()
+        .version(localVersion, "-v, --version", "print the Voratiq version")
         .exitOverride()
         .showHelpAfterError()
         .helpCommand(false);
-    program.addCommand(createInitCommand());
-    program.addCommand(createListCommand());
-    program.addCommand(createRunCommand());
-    program.addCommand(createReviewCommand());
-    program.addCommand(createApplyCommand());
-    program.addCommand(createPruneCommand());
-    if (argv.length <= 2) {
-        writeCommandOutput({ body: program.helpInformation() });
-        return;
+    if (jsonEnvelopeOperator) {
+        program.configureOutput({
+            writeOut: () => { },
+            writeErr: () => { },
+            outputError: () => { },
+        });
     }
+    const isMcpCommand = commandName === "mcp";
+    const updateHandle = isMcpCommand
+        ? undefined
+        : (await import("./update-check/checker.js")).startUpdateCheck(localVersion, {
+            isTty: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+            env: process.env,
+            cachePath: (await import("./update-check/state-path.js")).resolveUpdateStatePath(process.env),
+        });
     try {
-        await program.parseAsync(argv);
-    }
-    catch (error) {
-        if (error instanceof CommanderError) {
-            if (commanderAlreadyRendered(error)) {
-                process.exitCode = error.exitCode ?? 0;
+        if (!isMcpCommand) {
+            // Show update prompt if a cached notice is available
+            const updateNotice = updateHandle?.peekNotice();
+            if (updateNotice) {
+                const { showUpdatePrompt } = await import("./update-check/prompt.js");
+                const { createConfirmationInteractor } = await import("./render/interactions/confirmation.js");
+                const { writeCommandOutput } = await import("./cli/output.js");
+                const interactor = createConfirmationInteractor();
+                try {
+                    const result = await showUpdatePrompt(updateNotice, {
+                        prompt: (opts) => interactor.prompt(opts),
+                        write: (text) => process.stdout.write(text),
+                        writeCommandOutput,
+                    });
+                    if (result.shouldExit) {
+                        if (result.exitCode !== undefined && result.exitCode !== 0) {
+                            process.exitCode = result.exitCode;
+                        }
+                        return;
+                    }
+                }
+                finally {
+                    interactor.close();
+                }
+            }
+        }
+        await registerCommands(program, effectiveArgv);
+        const { shouldStartRootLauncher } = await import("./cli/root-launcher.js");
+        if (shouldStartRootLauncher(effectiveArgv)) {
+            try {
+                const { runInteractiveRootLauncher } = await import("./cli/root-launcher.js");
+                const { createEntrypointVoratiqCliTarget } = await import("./utils/voratiq-cli-target.js");
+                await runInteractiveRootLauncher({
+                    selfCliTarget: createEntrypointVoratiqCliTarget({
+                        cliEntrypoint: effectiveArgv[1],
+                    }),
+                });
+            }
+            catch (error) {
+                const { GitRepositoryError } = await import("./utils/errors.js");
+                if (error instanceof GitRepositoryError &&
+                    (error.reason === "no_repository" ||
+                        error.reason === "not_repository_root")) {
+                    const { writeCommandOutput } = await import("./cli/output.js");
+                    writeCommandOutput({ body: program.helpInformation() });
+                    return;
+                }
+                const { toCliError } = await import("./cli/errors.js");
+                const { renderCliError } = await import("./render/utils/errors.js");
+                const { writeCommandOutput } = await import("./cli/output.js");
+                const cliError = toCliError(error);
+                writeCommandOutput({
+                    body: renderCliError(cliError),
+                    exitCode: 1,
+                });
+            }
+            return;
+        }
+        if (effectiveArgv.length <= 2) {
+            const { writeCommandOutput } = await import("./cli/output.js");
+            writeCommandOutput({ body: program.helpInformation() });
+            return;
+        }
+        try {
+            await program.parseAsync(effectiveArgv);
+        }
+        catch (error) {
+            if (error instanceof CommanderError) {
+                if (jsonEnvelopeOperator) {
+                    const { buildFailedOperatorEnvelope, writeOperatorResultEnvelope } = await import("./cli/operator-envelope.js");
+                    writeOperatorResultEnvelope(buildFailedOperatorEnvelope({
+                        operator: jsonEnvelopeOperator,
+                        error,
+                    }), error.exitCode ?? 1);
+                    return;
+                }
+                const { commanderAlreadyRendered } = await import("./cli/commander-utils.js");
+                if (commanderAlreadyRendered(error)) {
+                    process.exitCode = error.exitCode ?? 0;
+                    return;
+                }
+                const { CliError } = await import("./cli/errors.js");
+                const { renderCliError } = await import("./render/utils/errors.js");
+                const { toErrorMessage } = await import("./utils/errors.js");
+                const { writeCommandOutput } = await import("./cli/output.js");
+                writeCommandOutput({
+                    body: renderCliError(new CliError(toErrorMessage(error))),
+                    exitCode: error.exitCode ?? 1,
+                });
                 return;
             }
+            if (jsonEnvelopeOperator) {
+                const { buildFailedOperatorEnvelope, writeOperatorResultEnvelope } = await import("./cli/operator-envelope.js");
+                writeOperatorResultEnvelope(buildFailedOperatorEnvelope({
+                    operator: jsonEnvelopeOperator,
+                    error,
+                }), 1);
+                return;
+            }
+            const { toCliError } = await import("./cli/errors.js");
+            const { renderCliError } = await import("./render/utils/errors.js");
+            const { writeCommandOutput } = await import("./cli/output.js");
+            const cliError = toCliError(error);
+            const body = renderCliError(cliError);
             writeCommandOutput({
-                body: renderCliError(new CliError(toErrorMessage(error))),
-                exitCode: error.exitCode ?? 1,
+                body,
+                exitCode: 1,
             });
-            return;
         }
-        const cliError = toCliError(error);
-        const body = renderCliError(cliError);
-        writeCommandOutput({
-            body,
-            exitCode: 1,
-        });
     }
+    finally {
+        activeJsonEnvelopeOperator = undefined;
+        updateHandle?.finish();
+    }
+}
+async function registerCommands(program, argv) {
+    const commandName = findCommandName(argv);
+    const wantsHelp = argv.includes("--help") || argv.includes("-h");
+    const wantsVersion = argv.includes("--version") || argv.includes("-v");
+    const knownCommandNames = new Set([
+        "init",
+        "spec",
+        "run",
+        "reduce",
+        "verify",
+        "message",
+        "auto",
+        "apply",
+        "list",
+        "prune",
+        "mcp",
+    ]);
+    const loadAll = commandName === undefined ||
+        (wantsHelp && commandName === undefined) ||
+        (commandName !== undefined && !knownCommandNames.has(commandName));
+    if (commandName === undefined && wantsVersion && !wantsHelp) {
+        return;
+    }
+    if (loadAll) {
+        program.addCommand((await import("./cli/init.js")).createInitCommand());
+        program.addCommand((await import("./cli/spec.js")).createSpecCommand());
+        program.addCommand((await import("./cli/run.js")).createRunCommand());
+        program.addCommand((await import("./cli/reduce.js")).createReduceCommand());
+        program.addCommand((await import("./cli/verify.js")).createVerifyCommand());
+        program.addCommand((await import("./cli/message.js")).createMessageCommand());
+        program.addCommand((await import("./cli/auto.js")).createAutoCommand());
+        program.addCommand((await import("./cli/apply.js")).createApplyCommand());
+        program.addCommand((await import("./cli/list.js")).createListCommand());
+        program.addCommand((await import("./cli/prune.js")).createPruneCommand());
+        program.addCommand((await import("./cli/mcp.js")).createMcpCommand());
+        return;
+    }
+    switch (commandName) {
+        case "init":
+            program.addCommand((await import("./cli/init.js")).createInitCommand());
+            break;
+        case "spec":
+            program.addCommand((await import("./cli/spec.js")).createSpecCommand());
+            break;
+        case "run":
+            program.addCommand((await import("./cli/run.js")).createRunCommand());
+            break;
+        case "reduce":
+            program.addCommand((await import("./cli/reduce.js")).createReduceCommand());
+            break;
+        case "verify":
+            program.addCommand((await import("./cli/verify.js")).createVerifyCommand());
+            break;
+        case "message":
+            program.addCommand((await import("./cli/message.js")).createMessageCommand());
+            break;
+        case "auto":
+            program.addCommand((await import("./cli/auto.js")).createAutoCommand());
+            break;
+        case "apply":
+            program.addCommand((await import("./cli/apply.js")).createApplyCommand());
+            break;
+        case "list":
+            program.addCommand((await import("./cli/list.js")).createListCommand());
+            break;
+        case "prune":
+            program.addCommand((await import("./cli/prune.js")).createPruneCommand());
+            break;
+        case "mcp":
+            program.addCommand((await import("./cli/mcp.js")).createMcpCommand());
+            break;
+    }
+}
+function findCommandName(argv) {
+    for (let index = 2; index < argv.length; index += 1) {
+        const entry = argv[index];
+        if (!entry) {
+            continue;
+        }
+        if (entry === "--") {
+            return argv[index + 1];
+        }
+        if (entry.startsWith("-")) {
+            continue;
+        }
+        return entry;
+    }
+    return undefined;
 }
 function shouldAutorun() {
     if (process.env.VORATIQ_CLI_SKIP_AUTORUN === "1") {
@@ -139,5 +436,6 @@ function safeRealpath(path) {
     }
 }
 if (shouldAutorun()) {
+    installProcessGuards();
     void runCli();
 }

package/dist/cli/apply.d.ts

@@ -1,9 +1,13 @@
 import { Command } from "commander";
 import type { ApplyResult } from "../commands/apply/types.js";
+import { type CommandOutputWriter } from "./output.js";
 export interface ApplyCommandOptions {
     runId: string;
     agentId: string;
     ignoreBaseMismatch?: boolean;
+    commit?: boolean;
+    json?: boolean;
+    writeOutput?: CommandOutputWriter;
 }
 export interface ApplyCommandResult {
     result: ApplyResult;