voratiq 0.1.0-beta.0

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

@@ -0,0 +1,20 @@
+import { CliError } from "../../cli/errors.js";
+export declare class PruneError extends CliError {
+    constructor(message: string);
+}
+export declare class RunMetadataMissingError extends PruneError {
+    readonly runId: string;
+    constructor(runId: string);
+}
+export declare class InteractiveConfirmationRequiredError extends PruneError {
+    constructor();
+}
+export declare class PruneBranchDeletionError extends PruneError {
+    readonly branch: string;
+    readonly detail: string;
+    constructor(branch: string, detail: string);
+}
+export declare class PruneRunDeletedError extends PruneError {
+    readonly runId: string;
+    constructor(runId: string);
+}

package/dist/commands/prune/errors.js

@@ -0,0 +1,39 @@
+import { CliError } from "../../cli/errors.js";
+export class PruneError extends CliError {
+    constructor(message) {
+        super(message);
+        this.name = "PruneError";
+    }
+}
+export class RunMetadataMissingError extends PruneError {
+    runId;
+    constructor(runId) {
+        super(`Run metadata for ${runId} is missing from .voratiq/runs/${runId}/record.json; prune cannot proceed.`);
+        this.runId = runId;
+        this.name = "RunMetadataMissingError";
+    }
+}
+export class InteractiveConfirmationRequiredError extends PruneError {
+    constructor() {
+        super("Interactive confirmation required; re-run with --yes or from a tty.");
+        this.name = "InteractiveConfirmationRequiredError";
+    }
+}
+export class PruneBranchDeletionError extends PruneError {
+    branch;
+    detail;
+    constructor(branch, detail) {
+        super(`Failed to delete branch ${branch}: ${detail}`);
+        this.branch = branch;
+        this.detail = detail;
+        this.name = "PruneBranchDeletionError";
+    }
+}
+export class PruneRunDeletedError extends PruneError {
+    runId;
+    constructor(runId) {
+        super(`Run ${runId} has been deleted.`);
+        this.runId = runId;
+        this.name = "PruneRunDeletedError";
+    }
+}

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

@@ -0,0 +1,42 @@
+import type { ConfirmationOptions } from "../../render/interactions/confirmation.js";
+export type PruneConfirmationHandler = (options: ConfirmationOptions) => Promise<boolean>;
+export interface PruneCommandInput {
+    root: string;
+    runsDir: string;
+    runsFilePath: string;
+    runId: string;
+    confirm: PruneConfirmationHandler;
+    purge?: boolean;
+    clock?: () => Date;
+}
+export interface PruneBranchSummary {
+    deleted: string[];
+    skipped: string[];
+}
+export interface PruneWorkspaceSummary {
+    removed: string[];
+    missing: string[];
+}
+export interface PruneArtifactSummary {
+    purged: boolean;
+    removed: string[];
+    missing: string[];
+}
+export interface PruneSuccessResult {
+    status: "pruned";
+    runId: string;
+    specPath: string;
+    runPath: string;
+    createdAt: string;
+    deletedAt: string;
+    workspaces: PruneWorkspaceSummary;
+    artifacts: PruneArtifactSummary;
+    branches: PruneBranchSummary;
+}
+export interface PruneAbortedResult {
+    status: "aborted";
+    runId: string;
+    specPath: string;
+    runPath: string;
+}
+export type PruneResult = PruneSuccessResult | PruneAbortedResult;

package/dist/commands/prune/types.js

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

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

@@ -0,0 +1,10 @@
+import type { RunRecordEnhanced } from "../../records/enhanced.js";
+export interface ReviewCommandInput {
+    root: string;
+    runsFilePath: string;
+    runId: string;
+}
+export interface ReviewCommandResult {
+    runRecord: RunRecordEnhanced;
+}
+export declare function executeReviewCommand(input: ReviewCommandInput): Promise<ReviewCommandResult>;

package/dist/commands/review/command.js

@@ -0,0 +1,26 @@
+import { buildRunRecordView } from "../../records/enhanced.js";
+import { RunRecordNotFoundError } from "../../records/errors.js";
+import { fetchRunsSafely } from "../../records/persistence.js";
+import { RunNotFoundCliError } from "../errors.js";
+export async function executeReviewCommand(input) {
+    const { root, runsFilePath, runId } = input;
+    const { records } = await fetchRunsSafely({
+        root,
+        runsFilePath,
+        runId,
+        filters: { includeDeleted: true },
+    }).catch((error) => {
+        if (error instanceof RunRecordNotFoundError) {
+            throw new RunNotFoundCliError(runId);
+        }
+        throw error;
+    });
+    const runRecord = records[0];
+    if (!runRecord) {
+        throw new RunNotFoundCliError(runId);
+    }
+    const enhanced = await buildRunRecordView(runRecord, {
+        workspaceRoot: root,
+    });
+    return { runRecord: enhanced };
+}

package/dist/commands/run/agent-execution.d.ts

@@ -0,0 +1,19 @@
+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 { AgentRecordMutators } from "../../records/mutators.js";
+import type { AgentExecutionPhaseResult } from "./phases.js";
+export interface AgentExecutionInput {
+    readonly agents: readonly AgentDefinition[];
+    readonly baseRevisionSha: string;
+    readonly runId: string;
+    readonly root: string;
+    readonly evalPlan: readonly EvalDefinition[];
+    readonly effectiveMaxParallel: number;
+    readonly mutators: AgentRecordMutators;
+    readonly environment: EnvironmentConfig;
+}
+/**
+ * Execute all agents and aggregate results.
+ */
+export declare function executeAgents(input: AgentExecutionInput): Promise<AgentExecutionPhaseResult>;

package/dist/commands/run/agent-execution.js

@@ -0,0 +1,63 @@
+import { toError } from "../../utils/errors.js";
+import { prepareAgents, runAgentsWithLimit } from "./agents.js";
+import { hasEvalFailures } from "./reports.js";
+/**
+ * Execute all agents and aggregate results.
+ */
+export async function executeAgents(input) {
+    const { agents, baseRevisionSha, runId, root, evalPlan, effectiveMaxParallel, mutators, environment, } = input;
+    let executionError;
+    let phaseResult;
+    try {
+        for (const agent of agents) {
+            await mutators.recordAgentQueued(agent);
+        }
+        const { ready: preparedAgents, failures: preparationFailures } = await prepareAgents({
+            agents,
+            baseRevisionSha,
+            runId,
+            root,
+            evalPlan,
+            environment,
+        });
+        for (const failure of preparationFailures) {
+            await mutators.recordAgentSnapshot(failure.record);
+        }
+        for (const execution of preparedAgents) {
+            execution.progress = {
+                onRunning: mutators.recordAgentSnapshot,
+                onCompleted: async (result) => {
+                    await mutators.recordAgentSnapshot(result.record);
+                },
+            };
+        }
+        const executionResults = preparedAgents.length > 0 && effectiveMaxParallel > 0
+            ? await runAgentsWithLimit(preparedAgents, effectiveMaxParallel)
+            : [];
+        const agentExecutions = [...preparationFailures, ...executionResults];
+        const sortedExecutions = sortExecutions(agentExecutions);
+        const agentRecords = sortedExecutions.map((execution) => execution.record);
+        const agentReports = sortedExecutions.map((execution) => execution.report);
+        const hadAgentFailure = agentReports.some((report) => report.status === "failed");
+        const hadEvalFailure = hasEvalFailures(agentReports);
+        phaseResult = {
+            agentRecords,
+            agentReports,
+            hadAgentFailure,
+            hadEvalFailure,
+        };
+    }
+    catch (error) {
+        executionError = error;
+    }
+    if (executionError) {
+        throw toError(executionError);
+    }
+    if (!phaseResult) {
+        throw new Error(`Agent execution did not produce a result for run ${runId}`);
+    }
+    return phaseResult;
+}
+function sortExecutions(executions) {
+    return [...executions].sort((a, b) => a.record.agentId.localeCompare(b.record.agentId));
+}

package/dist/commands/run/agents/auth-stage.d.ts

@@ -0,0 +1,23 @@
+import type { AuthProvider, AuthRuntimeContext } from "../../../auth/providers/types.js";
+import type { AgentDefinition } from "../../../configs/agents/types.js";
+export interface StagedAuthContext {
+    provider: AuthProvider;
+    sandboxPath: string;
+    runtime: AuthRuntimeContext;
+    agentId: string;
+    runId: string;
+}
+export interface StageAuthOptions {
+    agent: AgentDefinition;
+    agentRoot: string;
+    runId: string;
+    root: string;
+    runtime?: AuthRuntimeContext;
+}
+export interface StageAuthResult {
+    env: Record<string, string>;
+    context: StagedAuthContext;
+}
+export declare function verifyAgentProviders(agents: readonly AgentDefinition[]): Promise<void>;
+export declare function stageAgentAuth(options: StageAuthOptions): Promise<StageAuthResult>;
+export declare function teardownAuthContext(context: StagedAuthContext | undefined): Promise<void>;

package/dist/commands/run/agents/auth-stage.js

@@ -0,0 +1,108 @@
+import { rm } from "node:fs/promises";
+import { resolveAuthProvider } from "../../../auth/providers/index.js";
+import { buildAuthRuntimeContext } from "../../../auth/runtime.js";
+import { toErrorMessage } from "../../../utils/errors.js";
+import { isFileSystemError } from "../../../utils/fs.js";
+import { AuthProviderStageError, AuthProviderVerificationError, MissingAgentProviderError, RunCommandError, UnknownAuthProviderError, } from "../errors.js";
+import { getRunCommand } from "./sandbox-launcher.js";
+export async function verifyAgentProviders(agents) {
+    if (agents.length === 0) {
+        return;
+    }
+    await getRunCommand();
+    const runtime = buildAuthRuntimeContext();
+    for (const agent of agents) {
+        const provider = resolveAgentProvider(agent);
+        try {
+            await provider.verify({
+                agentId: agent.id,
+                runtime,
+            });
+        }
+        catch (error) {
+            throw new AuthProviderVerificationError(extractAuthProviderMessage(error));
+        }
+    }
+}
+export async function stageAgentAuth(options) {
+    const { agent, agentRoot, runId } = options;
+    const provider = resolveAgentProvider(agent);
+    const runtime = options.runtime ?? buildAuthRuntimeContext();
+    try {
+        const stageResult = await provider.stage({
+            agentId: agent.id,
+            agentRoot,
+            runtime,
+            runId,
+            root: options.root,
+        });
+        return {
+            env: stageResult.env,
+            context: {
+                provider,
+                sandboxPath: stageResult.sandboxPath,
+                runtime,
+                agentId: agent.id,
+                runId,
+            },
+        };
+    }
+    catch (error) {
+        throw new AuthProviderStageError(extractAuthProviderMessage(error));
+    }
+}
+export async function teardownAuthContext(context) {
+    if (!context) {
+        return;
+    }
+    if (tornDownContexts.has(context)) {
+        return;
+    }
+    tornDownContexts.add(context);
+    try {
+        if (context.provider.teardown) {
+            try {
+                await context.provider.teardown({
+                    sandboxPath: context.sandboxPath,
+                });
+            }
+            catch (error) {
+                if (!isIgnorableTeardownError(error)) {
+                    throw error;
+                }
+            }
+        }
+        await rm(context.sandboxPath, { recursive: true, force: true });
+    }
+    catch (error) {
+        tornDownContexts.delete(context);
+        throw error;
+    }
+}
+const tornDownContexts = new WeakSet();
+function isIgnorableTeardownError(error) {
+    if (!isFileSystemError(error)) {
+        return false;
+    }
+    return error.code === "ENOENT";
+}
+function resolveAgentProvider(agent) {
+    const providerId = agent.provider;
+    if (!providerId) {
+        throw new MissingAgentProviderError(agent.id);
+    }
+    const provider = resolveAuthProvider(providerId);
+    if (!provider) {
+        throw new UnknownAuthProviderError(providerId);
+    }
+    return provider;
+}
+function extractAuthProviderMessage(error) {
+    if (error instanceof RunCommandError) {
+        return error.messageForDisplay();
+    }
+    if (error instanceof Error && error.message) {
+        return error.message;
+    }
+    return toErrorMessage(error);
+}

package/dist/commands/run/agents/chat-preserver.d.ts

@@ -0,0 +1,9 @@
+import type { AgentDefinition } from "../../../configs/agents/types.js";
+import { AgentRunContext } from "./run-context.js";
+export interface CaptureChatOptions {
+    agent: AgentDefinition;
+    agentContext: AgentRunContext;
+    agentRoot: string;
+    reason?: string;
+}
+export declare function captureAgentChatTranscripts(options: CaptureChatOptions): Promise<void>;

package/dist/commands/run/agents/chat-preserver.js

@@ -0,0 +1,35 @@
+import { toErrorMessage } from "../../../utils/errors.js";
+import { preserveProviderChatTranscripts } from "../../../workspace/chat/artifacts.js";
+export async function captureAgentChatTranscripts(options) {
+    const providerId = options.agent.provider;
+    if (!providerId) {
+        return;
+    }
+    const result = await preserveProviderChatTranscripts({
+        providerId,
+        agentRoot: options.agentRoot,
+    });
+    const format = result.format;
+    if ((result.status === "captured" || result.status === "already-exists") &&
+        format) {
+        options.agentContext.markChatArtifact(format);
+        if (result.status === "captured" &&
+            format === "json" &&
+            (result.sourceCount ?? 0) > 1) {
+            // Intentionally silent: avoid noisy warnings during routine runs.
+        }
+        return;
+    }
+    if (result.status === "not-found") {
+        return;
+    }
+    if (result.status === "error") {
+        throw new Error(formatChatWarning(options, `Failed to preserve ${providerId} transcripts: ${toErrorMessage(result.error)}`));
+    }
+}
+function formatChatWarning(options, message) {
+    const prefix = options.reason
+        ? `[voratiq] (${options.agent.id}, ${options.reason})`
+        : `[voratiq] (${options.agent.id})`;
+    return `${prefix} ${message}`;
+}

package/dist/commands/run/agents/eval-runner.d.ts

@@ -0,0 +1,19 @@
+import type { EnvironmentConfig } from "../../../configs/environment/types.js";
+import type { AgentEvalResult, EvalDefinition } from "../../../configs/evals/types.js";
+import { type ArtifactCollectionResult, type SandboxPersona } from "../../../workspace/agents.js";
+import type { AgentWorkspacePaths } from "../../../workspace/layout.js";
+export interface EvalRunInput {
+    evalPlan: readonly EvalDefinition[];
+    workspacePaths: AgentWorkspacePaths;
+    baseRevisionSha: string;
+    root: string;
+    manifestEnv: Record<string, string>;
+    environment: EnvironmentConfig;
+    persona: SandboxPersona;
+}
+export interface EvalRunResult {
+    artifacts: ArtifactCollectionResult;
+    evaluations: AgentEvalResult[];
+    warnings: string[];
+}
+export declare function runPostProcessingAndEvaluations(input: EvalRunInput): Promise<EvalRunResult>;

package/dist/commands/run/agents/eval-runner.js

@@ -0,0 +1,27 @@
+import { executeEvaluations } from "../../../evals/runner.js";
+import { collectAgentArtifacts, } from "../../../workspace/agents.js";
+export async function runPostProcessingAndEvaluations(input) {
+    const { evalPlan, workspacePaths, baseRevisionSha, root, manifestEnv, environment, persona, } = input;
+    const artifacts = await collectAgentArtifacts({
+        baseRevisionSha,
+        workspacePath: workspacePaths.workspacePath,
+        summaryPath: workspacePaths.summaryPath,
+        diffPath: workspacePaths.diffPath,
+        root,
+        environment,
+        persona,
+    });
+    const evalOutcome = await executeEvaluations({
+        evaluations: evalPlan,
+        cwd: workspacePaths.workspacePath,
+        root,
+        logsDirectory: workspacePaths.evalsDirPath,
+        env: manifestEnv,
+        environment,
+    });
+    return {
+        artifacts,
+        evaluations: evalOutcome.results,
+        warnings: evalOutcome.warnings,
+    };
+}

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

@@ -0,0 +1,7 @@
+export interface AgentFailureDetectionInput {
+    agentId: string;
+    provider: string;
+    stdoutPath: string;
+    stderrPath: string;
+}
+export declare function detectAgentProcessFailureDetail(input: AgentFailureDetectionInput): Promise<string | undefined>;

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

@@ -0,0 +1,32 @@
+import { readFile } from "node:fs/promises";
+import { CLAUDE_OAUTH_RELOGIN_HINT, CLAUDE_PROVIDER_ID, } from "../../../auth/providers/claude/constants.js";
+const CLAUDE_FAILURE_PATTERNS = [
+    /Please run \/login/i,
+    /OAuth token has expired/i,
+];
+export async function detectAgentProcessFailureDetail(input) {
+    if (input.provider !== CLAUDE_PROVIDER_ID) {
+        return undefined;
+    }
+    const combinedLogs = await readCombinedLogs(input.stdoutPath, input.stderrPath);
+    if (combinedLogs &&
+        CLAUDE_FAILURE_PATTERNS.some((pattern) => pattern.test(combinedLogs))) {
+        return CLAUDE_OAUTH_RELOGIN_HINT;
+    }
+    return undefined;
+}
+async function readCombinedLogs(stdoutPath, stderrPath) {
+    const [stdout, stderr] = await Promise.all([
+        safeRead(stdoutPath),
+        safeRead(stderrPath),
+    ]);
+    return `${stdout}\n${stderr}`;
+}
+async function safeRead(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch {
+        return "";
+    }
+}

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

@@ -0,0 +1,9 @@
+import type { AgentInvocationRecord } from "../../../records/types.js";
+import { RunCommandError } from "../errors.js";
+import type { AgentExecutionResult } from "../reports.js";
+import { AgentRunContext } from "./run-context.js";
+import type { PreparedAgentExecution } from "./types.js";
+export declare function runPreparedAgent(execution: PreparedAgentExecution): Promise<AgentExecutionResult>;
+export declare function executeAgentLifecycle(execution: PreparedAgentExecution): Promise<AgentExecutionResult>;
+export declare function buildRunningAgentRecord(execution: PreparedAgentExecution, agentContext: AgentRunContext): AgentInvocationRecord;
+export declare function classifyPostProcessError(error: unknown): RunCommandError;

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

@@ -0,0 +1,157 @@
+import { toErrorMessage } from "../../../utils/errors.js";
+import { GIT_AUTHOR_EMAIL, GIT_AUTHOR_NAME } from "../../../utils/git.js";
+import { AgentProcessError, GitOperationError, RunCommandError, } from "../errors.js";
+import { teardownRegisteredSandboxContext } from "../sandbox-registry.js";
+import { captureAgentChatTranscripts } from "./chat-preserver.js";
+import { runPostProcessingAndEvaluations } from "./eval-runner.js";
+import { detectAgentProcessFailureDetail } from "./failures.js";
+import { runAgentProcess } from "./sandbox-launcher.js";
+import { WATCHDOG_DEFAULTS } from "./watchdog.js";
+export async function runPreparedAgent(execution) {
+    try {
+        return await executeAgentLifecycle(execution);
+    }
+    finally {
+        await teardownRegisteredSandboxContext(execution.authContext);
+    }
+}
+export async function executeAgentLifecycle(execution) {
+    const { agentContext, agent, workspacePaths, baseRevisionSha, root, evalPlan, runtimeManifestPath, environment, manifestEnv, } = execution;
+    // Set initial watchdog metadata (will be updated with trigger if fired)
+    const initialWatchdog = {
+        silenceTimeoutMs: WATCHDOG_DEFAULTS.silenceTimeoutMs,
+        wallClockCapMs: WATCHDOG_DEFAULTS.wallClockCapMs,
+    };
+    agentContext.setWatchdogMetadata(initialWatchdog);
+    try {
+        agentContext.markStarted();
+        if (execution.progress?.onRunning) {
+            await execution.progress.onRunning(buildRunningAgentRecord(execution, agentContext));
+        }
+        // Create watchdog trigger callback for immediate UI surfacing
+        const onWatchdogTrigger = (trigger, reason) => {
+            // Update watchdog metadata with trigger
+            agentContext.setWatchdogMetadata({
+                ...initialWatchdog,
+                trigger,
+            });
+            // Fire early failure callback for immediate UI update
+            if (execution.progress?.onEarlyFailure) {
+                const earlyRecord = agentContext.buildEarlyFailureRecord(reason);
+                void execution.progress.onEarlyFailure(earlyRecord);
+            }
+        };
+        const processResult = await runAgentProcess({
+            runtimeManifestPath,
+            agentRoot: workspacePaths.agentRoot,
+            stdoutPath: workspacePaths.stdoutPath,
+            stderrPath: workspacePaths.stderrPath,
+            sandboxSettingsPath: workspacePaths.sandboxSettingsPath,
+            providerId: agent.provider,
+            onWatchdogTrigger,
+        });
+        // Update watchdog metadata from process result (in case trigger came via watchdog)
+        if (processResult.watchdog) {
+            agentContext.setWatchdogMetadata(processResult.watchdog);
+        }
+        if (processResult.exitCode !== 0 || processResult.errorMessage) {
+            // Use watchdog error message if available, otherwise detect from logs
+            const failureDetail = processResult.watchdog?.trigger && processResult.errorMessage
+                ? processResult.errorMessage
+                : await detectAgentProcessFailureDetail({
+                    agentId: agent.id,
+                    provider: agent.provider,
+                    stdoutPath: workspacePaths.stdoutPath,
+                    stderrPath: workspacePaths.stderrPath,
+                });
+            const failure = new AgentProcessError({
+                exitCode: processResult.exitCode,
+                detail: failureDetail,
+            });
+            agentContext.markFailure(failure);
+        }
+    }
+    catch (rawError) {
+        const failure = rawError instanceof RunCommandError
+            ? rawError
+            : new AgentProcessError({
+                detail: toErrorMessage(rawError),
+            });
+        agentContext.markFailure(failure);
+    }
+    await captureAgentChatTranscripts({
+        agent,
+        agentContext,
+        agentRoot: workspacePaths.agentRoot,
+        reason: "post-run",
+    });
+    if (agentContext.isFailed()) {
+        agentContext.setCompleted();
+        return finalizeExecution(execution, () => agentContext.finalize());
+    }
+    try {
+        const postProcessResult = await runPostProcessingAndEvaluations({
+            evalPlan,
+            workspacePaths,
+            baseRevisionSha,
+            root,
+            manifestEnv,
+            environment,
+            persona: resolveSandboxPersona(manifestEnv),
+        });
+        agentContext.applyArtifacts(postProcessResult.artifacts);
+        if (postProcessResult.warnings.length > 0) {
+            for (const warning of postProcessResult.warnings) {
+                console.warn(`[voratiq] ${warning}`);
+            }
+            agentContext.recordEvalWarnings(postProcessResult.warnings);
+        }
+        agentContext.applyEvaluations(postProcessResult.evaluations);
+    }
+    catch (rawError) {
+        const failure = classifyPostProcessError(rawError);
+        return finalizeExecution(execution, async () => agentContext.failWith(failure));
+    }
+    agentContext.setCompleted();
+    return finalizeExecution(execution, () => agentContext.finalize());
+}
+export function buildRunningAgentRecord(execution, agentContext) {
+    const { agent } = execution;
+    return {
+        agentId: agent.id,
+        model: agent.model,
+        status: "running",
+        startedAt: agentContext.getStartedAt(),
+        artifacts: {
+            diffAttempted: false,
+            diffCaptured: false,
+            stdoutCaptured: true,
+            stderrCaptured: true,
+        },
+    };
+}
+export function classifyPostProcessError(error) {
+    if (error instanceof RunCommandError) {
+        return error;
+    }
+    const detail = toErrorMessage(error);
+    return new GitOperationError({
+        operation: "Run finalization failed",
+        detail,
+    });
+}
+async function finalizeExecution(execution, finalize) {
+    const result = await finalize();
+    if (execution.progress?.onCompleted) {
+        await execution.progress.onCompleted(result);
+    }
+    return result;
+}
+function resolveSandboxPersona(env) {
+    // The sandbox shim injects these Git persona env vars before spawning agent binaries.
+    // Keep this helper synchronized with src/commands/run/shim/run-agent-shim.ts.
+    return {
+        authorName: env["GIT_AUTHOR_NAME"] ?? GIT_AUTHOR_NAME,
+        authorEmail: env["GIT_AUTHOR_EMAIL"] ?? GIT_AUTHOR_EMAIL,
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { AgentExecutionContext, AgentPreparationOutcome } from "./types.js";
+export declare function prepareAgentForExecution(context: AgentExecutionContext): Promise<AgentPreparationOutcome>;