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

package/dist/domain/run/competition/agent-execution.js

@@ -0,0 +1,45 @@
+import { executeCompetitionWithAdapter } from "../../../competition/command-adapter.js";
+import { createRunCompetitionAdapter } from "../../../domain/run/competition/adapter.js";
+import { RunProcessStreamError } from "../../../domain/run/competition/errors.js";
+import { toError } from "../../../utils/errors.js";
+/**
+ * Execute all agents and aggregate results.
+ */
+export async function executeAgents(input) {
+    const { agents, baseRevisionSha, runId, root, specContent, extraContextFiles, effectiveMaxParallel, mutators, environment, } = input;
+    let executionError;
+    let phaseResult;
+    try {
+        const sortedExecutions = await executeCompetitionWithAdapter({
+            candidates: agents,
+            maxParallel: effectiveMaxParallel,
+            adapter: createRunCompetitionAdapter({
+                baseRevisionSha,
+                runId,
+                root,
+                specContent,
+                extraContextFiles,
+                mutators,
+                environment,
+            }),
+        });
+        const agentRecords = sortedExecutions.map((execution) => execution.record);
+        const agentReports = sortedExecutions.map((execution) => execution.report);
+        const hadAgentFailure = agentReports.some((report) => report.status === "failed" || report.status === "errored");
+        phaseResult = {
+            agentRecords,
+            agentReports,
+            hadAgentFailure,
+        };
+    }
+    catch (error) {
+        executionError = error;
+    }
+    if (executionError) {
+        throw new RunProcessStreamError(toError(executionError).message);
+    }
+    if (!phaseResult) {
+        throw new RunProcessStreamError(`Agent execution did not produce a result for run \`${runId}\`.`);
+    }
+    return phaseResult;
+}

package/dist/domain/run/competition/agent-preparation.d.ts

@@ -0,0 +1,12 @@
+import type { AgentDefinition } from "../../../configs/agents/types.js";
+import type { EnvironmentConfig } from "../../../configs/environment/types.js";
+import type { AgentPreparationResult } from "./agents/types.js";
+export declare function prepareAgents(options: {
+    agents: readonly AgentDefinition[];
+    baseRevisionSha: string;
+    runId: string;
+    root: string;
+    specContent: string;
+    extraContextFiles: readonly import("../../../competition/shared/extra-context.js").ResolvedExtraContextFile[];
+    environment: EnvironmentConfig;
+}): Promise<AgentPreparationResult>;

package/dist/domain/run/competition/agent-preparation.js

@@ -0,0 +1,24 @@
+import { prepareAgentForExecution } from "./agents/preparation.js";
+export async function prepareAgents(options) {
+    const { agents, baseRevisionSha, runId, root, specContent, extraContextFiles, environment, } = options;
+    const ready = [];
+    const failures = [];
+    for (const agent of agents) {
+        const preparation = await prepareAgentForExecution({
+            agent,
+            baseRevisionSha,
+            runId,
+            root,
+            specContent,
+            extraContextFiles,
+            environment,
+        });
+        if (preparation.status === "ready") {
+            ready.push(preparation.prepared);
+        }
+        else {
+            failures.push(preparation.result);
+        }
+    }
+    return { ready, failures };
+}

package/dist/domain/run/competition/agents/artifacts.d.ts

@@ -0,0 +1,17 @@
+import type { EnvironmentConfig } from "../../../../configs/environment/types.js";
+import type { SandboxPersona } from "../../../../workspace/agents.js";
+import { type RunAgentWorkspacePaths } from "./workspace.js";
+export interface ArtifactCollectionResult {
+    summaryCaptured: boolean;
+    diffStatistics?: string;
+    commitSha?: string;
+    diffAttempted: boolean;
+    diffCaptured: boolean;
+}
+export declare function collectAgentArtifacts(options: {
+    baseRevisionSha: string;
+    workspacePaths: RunAgentWorkspacePaths;
+    root: string;
+    environment: EnvironmentConfig;
+    persona: SandboxPersona;
+}): Promise<ArtifactCollectionResult>;

package/dist/domain/run/competition/agents/artifacts.js

@@ -0,0 +1,173 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { relative } from "node:path";
+import { AgentProcessError, GitOperationError, } from "../../../../domain/run/competition/errors.js";
+import { toErrorMessage } from "../../../../utils/errors.js";
+import { isFileSystemError } from "../../../../utils/fs.js";
+import { gitAddAll, gitCommitAll, gitDiff, gitDiffShortStat, gitHasStagedChanges, runGitCommand, } from "../../../../utils/git.js";
+import { enforceCredentialExclusion } from "../../../../workspace/credential-guard.js";
+import { cleanupWorkspaceDependencies, ensureWorkspaceDependencies, WorkspaceDependencyCleanupError, } from "../../../../workspace/dependencies.js";
+import { promoteWorkspaceFile } from "../../../../workspace/promotion.js";
+import { WORKSPACE_SUMMARY_FILENAME, } from "./workspace.js";
+export async function collectAgentArtifacts(options) {
+    const { baseRevisionSha, workspacePaths, root, environment, persona } = options;
+    const { workspacePath, artifactsPath, summaryPath, diffPath } = workspacePaths;
+    let dependenciesCleanup = {
+        nodeRemoved: false,
+        pythonRemoved: false,
+    };
+    let cleanupFailed = false;
+    try {
+        dependenciesCleanup = await cleanupWorkspaceDependencies({
+            root,
+            workspacePath,
+            environment,
+        });
+    }
+    catch (error) {
+        cleanupFailed = true;
+        if (error instanceof WorkspaceDependencyCleanupError) {
+            dependenciesCleanup = error.cleanup;
+        }
+    }
+    let runFailed = true;
+    let artifactResult;
+    let dependencyRestoreError;
+    try {
+        await runGitStep("Git add failed", async () => gitAddAll(workspacePath));
+        const hasChangesBeforeSummary = await gitHasStagedChanges(workspacePath);
+        if (!hasChangesBeforeSummary) {
+            throw new AgentProcessError({
+                detail: "Agent process failed. No workspace changes detected.",
+            });
+        }
+        const { summary } = await harvestSummary({
+            workspacePath,
+            artifactsPath,
+            summaryPath,
+        });
+        await runGitStep("Git add failed", async () => gitAddAll(workspacePath));
+        const hasChanges = await gitHasStagedChanges(workspacePath);
+        if (!hasChanges) {
+            throw new AgentProcessError({
+                detail: "Agent process failed. No workspace changes detected.",
+            });
+        }
+        let diffStatistics;
+        let commitSha;
+        await runGitStep("Git commit failed", async () => gitCommitAll({
+            cwd: workspacePath,
+            message: summary,
+            authorName: persona.authorName,
+            authorEmail: persona.authorEmail,
+            bypassHooks: true,
+        }));
+        commitSha = await runGitStep("Git rev-parse failed", async () => runGitCommand(["rev-parse", "HEAD"], { cwd: workspacePath }));
+        const diffContent = await runGitStep("Git diff failed", async () => gitDiff({
+            cwd: workspacePath,
+            baseRevision: baseRevisionSha,
+            targetRevision: "HEAD",
+        }));
+        await enforceCredentialExclusion({
+            workspacePath,
+            diffContent,
+        });
+        await writeFile(diffPath, diffContent, { encoding: "utf8" });
+        diffStatistics = await runGitStep("Git diff --shortstat failed", async () => gitDiffShortStat({
+            cwd: workspacePath,
+            baseRevision: baseRevisionSha,
+            targetRevision: "HEAD",
+        }));
+        runFailed = false;
+        artifactResult = {
+            summaryCaptured: true,
+            diffStatistics,
+            commitSha,
+            diffAttempted: true,
+            diffCaptured: true,
+        };
+    }
+    finally {
+        const cleanupTouched = dependenciesCleanup.nodeRemoved || dependenciesCleanup.pythonRemoved;
+        const shouldRestoreDependencies = cleanupTouched || cleanupFailed;
+        if (shouldRestoreDependencies) {
+            try {
+                await ensureWorkspaceDependencies({
+                    root,
+                    workspacePath,
+                    environment,
+                });
+            }
+            catch (error) {
+                if (!runFailed) {
+                    dependencyRestoreError = new AgentProcessError({
+                        detail: `[voratiq] Failed to restore workspace dependencies after export: ${toErrorMessage(error)}`,
+                    });
+                }
+            }
+        }
+    }
+    if (dependencyRestoreError) {
+        throw dependencyRestoreError;
+    }
+    if (!artifactResult) {
+        throw new AgentProcessError({
+            detail: "Agent process failed before artifacts were collected.",
+        });
+    }
+    return artifactResult;
+}
+const NO_CHANGE_SUMMARY_DETAIL = "Agent process failed. No change summary detected.";
+async function harvestSummary(options) {
+    const { workspacePath, artifactsPath, summaryPath } = options;
+    try {
+        const { summary } = await promoteSummary({
+            workspacePath,
+            artifactsPath,
+            summaryPath,
+        });
+        return { summary };
+    }
+    catch (error) {
+        if (error instanceof AgentProcessError) {
+            throw error;
+        }
+        if (isFileSystemError(error) && error.code === "ENOENT") {
+            throw new AgentProcessError({ detail: NO_CHANGE_SUMMARY_DETAIL });
+        }
+        throw new AgentProcessError({ detail: toErrorMessage(error) });
+    }
+}
+async function promoteSummary(options) {
+    const { workspacePath, artifactsPath, summaryPath } = options;
+    let trimmed;
+    const promoteResult = await promoteWorkspaceFile({
+        workspacePath,
+        artifactsPath,
+        stagedRelativePath: WORKSPACE_SUMMARY_FILENAME,
+        artifactRelativePath: relative(artifactsPath, summaryPath),
+        transform: (raw) => {
+            const candidate = raw.toString("utf8").trim();
+            if (!candidate) {
+                throw new AgentProcessError({
+                    detail: NO_CHANGE_SUMMARY_DETAIL,
+                });
+            }
+            trimmed = candidate;
+            return `${candidate}\n`;
+        },
+    });
+    return {
+        summary: trimmed ?? (await readFile(promoteResult.artifactPath, "utf8")).trim(),
+    };
+}
+async function runGitStep(operationMessage, step) {
+    try {
+        return await step();
+    }
+    catch (error) {
+        throw new GitOperationError({
+            operation: operationMessage,
+            detail: toErrorMessage(error),
+        });
+    }
+}

package/dist/{commands/run → domain/run/competition}/agents/lifecycle.d.ts

@@ -1,6 +1,6 @@
-import type { AgentInvocationRecord } from "../../../records/types.js";
-import { RunCommandError } from "../errors.js";
-import type { AgentExecutionResult } from "../reports.js";
+import { RunCommandError } from "../../../../domain/run/competition/errors.js";
+import type { AgentExecutionResult } from "../../../../domain/run/competition/reports.js";
+import type { AgentInvocationRecord } from "../../../../domain/run/model/types.js";
 import { AgentRunContext } from "./run-context.js";
 import type { PreparedAgentExecution } from "./types.js";
 export declare function runPreparedAgent(execution: PreparedAgentExecution): Promise<AgentExecutionResult>;

package/dist/{commands/run → domain/run/competition}/agents/lifecycle.js

@@ -1,24 +1,19 @@
-import { loadSandboxProviderConfig } from "../../../configs/sandbox/loader.js";
-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 { DEFAULT_DENIAL_BACKOFF, } from "../sandbox.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";
+import { detectAgentProcessFailureDetail } from "../../../../agents/runtime/failures.js";
+import { runSandboxedAgent } from "../../../../agents/runtime/harness.js";
+import { WATCHDOG_DEFAULTS, } from "../../../../agents/runtime/watchdog.js";
+import { composeStageSandboxPolicy } from "../../../../competition/shared/sandbox-policy.js";
+import { AgentProcessError, GitOperationError, RunCommandError, } from "../../../../domain/run/competition/errors.js";
+import { toErrorMessage } from "../../../../utils/errors.js";
+import { GIT_AUTHOR_EMAIL, GIT_AUTHOR_NAME } from "../../../../utils/git.js";
+import { extractProviderNativeTokenUsageForSession } from "../../../../workspace/chat/native-usage.js";
+import { VORATIQ_RUN_DIR } from "../../../../workspace/structure.js";
+import { runPostProcessingAndCollectArtifacts } from "./post-processing.js";
 export async function runPreparedAgent(execution) {
-    try {
-        return await executeAgentLifecycle(execution);
-    }
-    finally {
-        await teardownRegisteredSandboxContext(execution.authContext);
-    }
+    return await executeAgentLifecycle(execution);
 }
 export async function executeAgentLifecycle(execution) {
-    const { agentContext, agent, workspacePaths, baseRevisionSha, root, evalPlan, runtimeManifestPath, environment, manifestEnv, } = execution;
+    const { agentContext, agent, workspacePaths, baseRevisionSha, root, prompt, environment, } = execution;
+    let manifestEnv = {};
     // Set initial watchdog metadata (will be updated with trigger if fired)
     const initialWatchdog = {
         silenceTimeoutMs: WATCHDOG_DEFAULTS.silenceTimeoutMs,
@@ -46,28 +41,30 @@ export async function executeAgentLifecycle(execution) {
                 void execution.progress.onEarlyFailure(earlyRecord);
             }
         };
-        let denialBackoff = DEFAULT_DENIAL_BACKOFF;
-        try {
-            const sandboxProviderConfig = loadSandboxProviderConfig({
-                root,
-                providerId: agent.provider,
-            });
-            denialBackoff = sandboxProviderConfig.denialBackoff;
-        }
-        catch {
-            // If sandbox.yaml is missing or invalid, fall back to defaults rather than
-            // failing the entire agent lifecycle.
-        }
-        const processResult = await runAgentProcess({
-            runtimeManifestPath,
-            agentRoot: workspacePaths.agentRoot,
-            stdoutPath: workspacePaths.stdoutPath,
-            stderrPath: workspacePaths.stderrPath,
-            sandboxSettingsPath: workspacePaths.sandboxSettingsPath,
-            providerId: agent.provider,
+        const processResult = await runSandboxedAgent({
+            root,
+            sessionId: execution.runId,
+            sandboxStageId: "run",
+            agent,
+            prompt,
+            environment,
+            paths: {
+                agentRoot: workspacePaths.agentRoot,
+                workspacePath: workspacePaths.workspacePath,
+                sandboxHomePath: workspacePaths.sandboxHomePath,
+                runtimeManifestPath: workspacePaths.runtimeManifestPath,
+                sandboxSettingsPath: workspacePaths.sandboxSettingsPath,
+                runtimePath: workspacePaths.runtimePath,
+                artifactsPath: workspacePaths.artifactsPath,
+                stdoutPath: workspacePaths.stdoutPath,
+                stderrPath: workspacePaths.stderrPath,
+            },
+            captureChat: true,
+            teardownAuthOnExit: false,
+            ...composeStageSandboxPolicy({}),
             onWatchdogTrigger,
-            denialBackoff,
         });
+        manifestEnv = processResult.manifestEnv;
         // Update watchdog metadata from process result (in case trigger came via watchdog)
         if (processResult.watchdog) {
             agentContext.setWatchdogMetadata(processResult.watchdog);
@@ -76,21 +73,33 @@ export async function executeAgentLifecycle(execution) {
             agentContext.setFailFastTriggered(processResult.failFast);
         }
         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 watchdogTrigger = processResult.watchdog?.trigger;
+            const extractedDetail = await detectAgentProcessFailureDetail({
+                provider: agent.provider,
+                stdoutPath: workspacePaths.stdoutPath,
+                stderrPath: workspacePaths.stderrPath,
+            });
+            const fallbackError = processResult.errorMessage &&
+                isGenericProcessFailure(processResult.errorMessage)
+                ? undefined
+                : processResult.errorMessage;
+            const failureDetail = watchdogTrigger === "fatal-pattern"
+                ? (extractedDetail ?? fallbackError)
+                : (fallbackError ?? extractedDetail);
             const failure = new AgentProcessError({
                 exitCode: processResult.exitCode,
                 detail: failureDetail,
             });
             agentContext.markFailure(failure);
         }
+        if (processResult.chat?.captured && processResult.chat.format) {
+            agentContext.markChatArtifact(processResult.chat.format);
+            await tryExtractProviderNativeTokenUsage({
+                execution,
+                artifactPath: processResult.chat.artifactPath,
+                format: processResult.chat.format,
+            });
+        }
     }
     catch (rawError) {
         const failure = rawError instanceof RunCommandError
@@ -100,34 +109,19 @@ export async function executeAgentLifecycle(execution) {
             });
         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,
+        const artifacts = await runPostProcessingAndCollectArtifacts({
             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);
+        agentContext.applyArtifacts(artifacts);
     }
     catch (rawError) {
         const failure = classifyPostProcessError(rawError);
@@ -161,6 +155,16 @@ export function classifyPostProcessError(error) {
         detail,
     });
 }
+function isGenericProcessFailure(message) {
+    const trimmed = message.trim();
+    if (trimmed.startsWith("Agent exited with code ")) {
+        return true;
+    }
+    if (trimmed.startsWith("Agent terminated by signal ")) {
+        return true;
+    }
+    return false;
+}
 async function finalizeExecution(execution, finalize) {
     const result = await finalize();
     if (execution.progress?.onCompleted) {
@@ -176,3 +180,19 @@ function resolveSandboxPersona(env) {
         authorEmail: env["GIT_AUTHOR_EMAIL"] ?? GIT_AUTHOR_EMAIL,
     };
 }
+async function tryExtractProviderNativeTokenUsage(options) {
+    const { execution, artifactPath, format } = options;
+    const { agent, root, runId, agentContext } = execution;
+    const extracted = await extractProviderNativeTokenUsageForSession({
+        root,
+        domain: VORATIQ_RUN_DIR,
+        sessionId: runId,
+        agentId: agent.id,
+        provider: agent.provider,
+        modelId: agent.model,
+        chatCaptured: true,
+        format,
+        artifactPath,
+    });
+    agentContext.setTokenUsageResult(extracted);
+}

package/dist/domain/run/competition/agents/post-processing.d.ts

@@ -0,0 +1,12 @@
+import type { EnvironmentConfig } from "../../../../configs/environment/types.js";
+import type { SandboxPersona } from "../../../../workspace/agents.js";
+import { type ArtifactCollectionResult } from "./artifacts.js";
+import type { RunAgentWorkspacePaths } from "./workspace.js";
+export interface RunPostProcessingInput {
+    workspacePaths: RunAgentWorkspacePaths;
+    baseRevisionSha: string;
+    root: string;
+    environment: EnvironmentConfig;
+    persona: SandboxPersona;
+}
+export declare function runPostProcessingAndCollectArtifacts(input: RunPostProcessingInput): Promise<ArtifactCollectionResult>;

package/dist/domain/run/competition/agents/post-processing.js

@@ -0,0 +1,4 @@
+import { collectAgentArtifacts, } from "./artifacts.js";
+export async function runPostProcessingAndCollectArtifacts(input) {
+    return await collectAgentArtifacts(input);
+}

package/dist/domain/run/competition/agents/preparation.js

@@ -0,0 +1,64 @@
+import { stageExtraContextFiles } from "../../../../competition/shared/extra-context.js";
+import { RunCommandError } from "../../../../domain/run/competition/errors.js";
+import { ensureWorkspaceError } from "../../../../workspace/agents.js";
+import { buildRunPrompt } from "../prompt.js";
+import { AgentRunContext } from "./run-context.js";
+import { buildRunAgentWorkspace } from "./workspace.js";
+export async function prepareAgentForExecution(context) {
+    const { agent, baseRevisionSha, runId, root, specContent, extraContextFiles, environment, } = context;
+    const startedAt = new Date().toISOString();
+    const agentContext = new AgentRunContext({
+        agent,
+        runId,
+        startedAt,
+    });
+    let workspacePaths;
+    try {
+        workspacePaths = await buildRunAgentWorkspace({
+            root,
+            runId,
+            agentId: agent.id,
+            baseRevisionSha,
+            environment,
+        });
+    }
+    catch (error) {
+        return {
+            status: "failed",
+            result: await agentContext.failWith(ensureWorkspaceFailure(error)),
+        };
+    }
+    try {
+        await stageExtraContextFiles({
+            contextPath: workspacePaths.contextPath,
+            files: extraContextFiles,
+        });
+    }
+    catch (error) {
+        return {
+            status: "failed",
+            result: await agentContext.failWith(ensureWorkspaceFailure(error)),
+        };
+    }
+    const prompt = buildRunPrompt({
+        specContent,
+        workspacePath: workspacePaths.workspacePath,
+        extraContextFiles,
+    });
+    return {
+        status: "ready",
+        prepared: {
+            agent,
+            agentContext,
+            workspacePaths: workspacePaths,
+            baseRevisionSha,
+            root,
+            runId,
+            prompt,
+            environment,
+        },
+    };
+}
+function ensureWorkspaceFailure(error) {
+    return error instanceof RunCommandError ? error : ensureWorkspaceError(error);
+}

package/dist/{commands/run → domain/run/competition}/agents/run-context.d.ts

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