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

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

@@ -1,30 +1,32 @@
-import { normalizeDiffStatistics } from "../../../utils/diff.js";
-import { finalizeAgentResult, } from "../reports.js";
+import { finalizeAgentResult, } from "../../../../domain/run/competition/reports.js";
+import { buildUnavailableTokenUsageResult, resolveTokenUsage, } from "../../../../domain/shared/token-usage.js";
+import { normalizeDiffStatistics } from "../../../../utils/diff.js";
 export class AgentRunContext {
-    state = {
-        diffAttempted: false,
-        diffCaptured: false,
-        diffStatistics: undefined,
-    };
+    state;
     status = "succeeded";
     commitSha;
-    evalResults;
     errorMessage;
     watchdogMetadata;
     failFast;
     completedAt;
     startedAt;
-    evalPlan;
     runId;
     agent;
     artifactState;
-    evalWarnings = [];
     constructor(params) {
         this.agent = params.agent;
         this.runId = params.runId;
         this.startedAt = params.startedAt;
-        this.evalPlan = params.evalPlan;
-        this.evalResults = buildDefaultEvalResults(this.evalPlan);
+        this.state = {
+            diffAttempted: false,
+            diffCaptured: false,
+            diffStatistics: undefined,
+            tokenUsage: undefined,
+            tokenUsageResult: buildUnavailableTokenUsageResult({
+                provider: params.agent.provider,
+                modelId: params.agent.model,
+            }),
+        };
         this.artifactState = {
             diffAttempted: false,
             diffCaptured: false,
@@ -76,47 +78,20 @@ export class AgentRunContext {
         this.state.diffAttempted ||= result.diffAttempted;
         this.state.diffCaptured ||= result.diffCaptured;
     }
-    applyEvaluations(results) {
-        const defaults = buildDefaultEvalResults(this.evalPlan);
-        const bySlug = new Map(results.map((evaluation) => [evaluation.slug, evaluation]));
-        this.evalResults = defaults.map((fallback) => {
-            const evaluation = bySlug.get(fallback.slug);
-            return evaluation ?? fallback;
-        });
-        if (this.status === "failed") {
-            return;
-        }
-        const hasErrored = this.evalResults.some((evaluation) => {
-            return evaluation.status === "errored";
-        });
-        const hasFailed = this.evalResults.some((evaluation) => evaluation.status === "failed");
-        if (hasErrored) {
-            this.status = "errored";
-            if (!this.errorMessage) {
-                const erroredEval = this.evalResults.find((evaluation) => evaluation.status === "errored" && evaluation.error);
-                if (erroredEval?.error) {
-                    this.errorMessage = erroredEval.error;
-                }
-            }
-            return;
-        }
-        if (hasFailed) {
-            this.status = "failed";
-        }
-    }
     markChatArtifact(format) {
         this.artifactState.chatCaptured = true;
         this.artifactState.chatFormat = format;
     }
-    recordEvalWarnings(warnings) {
-        this.evalWarnings.push(...warnings);
-    }
     setWatchdogMetadata(metadata) {
         this.watchdogMetadata = metadata;
     }
     setFailFastTriggered(info) {
         this.failFast = info;
     }
+    setTokenUsageResult(result) {
+        this.state.tokenUsageResult = result;
+        this.state.tokenUsage = resolveTokenUsage(result);
+    }
     finalize() {
         this.setCompleted();
         const record = buildAgentRecord({
@@ -127,9 +102,8 @@ export class AgentRunContext {
             startedAt: this.startedAt,
             status: this.status,
             artifacts: this.artifactState,
-            evalResults: this.evalResults,
-            warnings: this.evalWarnings,
             diffStatistics: this.state.diffStatistics,
+            tokenUsage: this.state.tokenUsage,
             watchdog: this.watchdogMetadata,
             failFast: this.failFast,
         });
@@ -137,7 +111,6 @@ export class AgentRunContext {
     }
     /**
      * Build an early failure record for immediate UI surfacing when watchdog triggers.
-     * Includes placeholder evals so the record satisfies agentInvocationRecordSchema.
      */
     buildEarlyFailureRecord(errorMessage) {
         return buildAgentRecord({
@@ -148,26 +121,16 @@ export class AgentRunContext {
             startedAt: this.startedAt,
             status: "failed",
             artifacts: this.artifactState,
-            evalResults: this.evalResults,
-            warnings: this.evalWarnings,
             diffStatistics: undefined,
+            tokenUsage: this.state.tokenUsage,
             watchdog: this.watchdogMetadata,
             failFast: this.failFast,
         });
     }
 }
-export function buildDefaultEvalResults(definitions) {
-    return definitions.map(({ slug, command }) => ({
-        slug,
-        command,
-        status: "skipped",
-    }));
-}
 function buildAgentRecord(options) {
-    const { agent, commitSha, completedAt, errorMessage, startedAt, status, artifacts, evalResults, warnings, diffStatistics, watchdog, failFast, } = options;
-    const snapshots = toEvalSnapshots(evalResults);
+    const { agent, commitSha, completedAt, errorMessage, startedAt, status, artifacts, diffStatistics, tokenUsage, watchdog, failFast, } = options;
     const artifactState = Object.keys(artifacts).length > 0 ? artifacts : undefined;
-    const normalizedWarnings = warnings.length > 0 ? Array.from(new Set(warnings)) : undefined;
     const normalizedDiffStatistics = normalizeDiffStatistics(diffStatistics);
     const record = {
         agentId: agent.id,
@@ -177,9 +140,8 @@ function buildAgentRecord(options) {
         status,
         commitSha,
         artifacts: artifactState,
-        evals: snapshots,
         error: errorMessage,
-        warnings: normalizedWarnings,
+        tokenUsage,
         watchdog,
         ...(failFast
             ? {
@@ -194,13 +156,3 @@ function buildAgentRecord(options) {
     }
     return record;
 }
-function toEvalSnapshots(results) {
-    return results.map((evaluation) => ({
-        slug: evaluation.slug,
-        status: evaluation.status,
-        command: evaluation.command,
-        exitCode: evaluation.exitCode,
-        hasLog: evaluation.logPath !== undefined,
-        error: evaluation.error,
-    }));
-}

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

@@ -1,17 +1,17 @@
-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 { AgentInvocationRecord } from "../../../records/types.js";
-import type { AgentWorkspacePaths } from "../../../workspace/layout.js";
-import type { AgentExecutionResult } from "../reports.js";
-import type { StagedAuthContext } from "./auth-stage.js";
+import type { ResolvedExtraContextFile } from "../../../../competition/shared/extra-context.js";
+import type { AgentDefinition } from "../../../../configs/agents/types.js";
+import type { EnvironmentConfig } from "../../../../configs/environment/types.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 { RunAgentWorkspacePaths } from "./workspace.js";
 export interface AgentExecutionContext {
     agent: AgentDefinition;
     baseRevisionSha: string;
     runId: string;
     root: string;
-    evalPlan: readonly EvalDefinition[];
+    specContent: string;
+    extraContextFiles: readonly ResolvedExtraContextFile[];
     environment: EnvironmentConfig;
 }
 export interface AgentProgressCallbacks {
@@ -23,16 +23,13 @@ export interface AgentProgressCallbacks {
 export interface PreparedAgentExecution {
     agent: AgentDefinition;
     agentContext: AgentRunContext;
-    workspacePaths: AgentWorkspacePaths;
-    runtimeManifestPath: string;
+    workspacePaths: RunAgentWorkspacePaths;
     baseRevisionSha: string;
     root: string;
     runId: string;
-    evalPlan: readonly EvalDefinition[];
+    prompt: string;
     environment: EnvironmentConfig;
-    manifestEnv: Record<string, string>;
     progress?: AgentProgressCallbacks;
-    authContext?: StagedAuthContext;
 }
 export type AgentPreparationOutcome = {
     status: "ready";

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

@@ -0,0 +1,21 @@
+import type { AgentId } from "../../../../configs/agents/types.js";
+import type { EnvironmentConfig } from "../../../../configs/environment/types.js";
+import { type AgentWorkspacePaths } from "../../../../workspace/layout.js";
+export declare const WORKSPACE_SUMMARY_FILENAME: ".summary.txt";
+export interface RunAgentWorkspacePaths extends AgentWorkspacePaths {
+    diffPath: string;
+    summaryPath: string;
+}
+export declare function buildRunAgentWorkspace(options: {
+    root: string;
+    runId: string;
+    agentId: AgentId;
+    baseRevisionSha: string;
+    environment: EnvironmentConfig;
+}): Promise<RunAgentWorkspacePaths>;
+export declare function buildRunAgentWorkspacePaths(options: {
+    root: string;
+    runId: string;
+    agentId: AgentId;
+    corePaths: AgentWorkspacePaths;
+}): RunAgentWorkspacePaths;

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

@@ -0,0 +1,47 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { normalizePathForDisplay, resolvePath, } from "../../../../utils/path.js";
+import { prepareAgentWorkspace } from "../../../../workspace/agents.js";
+import { buildAgentWorkspacePaths, } from "../../../../workspace/layout.js";
+import { getAgentSessionDiffPath, getAgentSessionSummaryPath, VORATIQ_RUN_DIR, } from "../../../../workspace/structure.js";
+export const WORKSPACE_SUMMARY_FILENAME = ".summary.txt";
+export async function buildRunAgentWorkspace(options) {
+    const { root, runId, agentId, baseRevisionSha, environment } = options;
+    const corePaths = buildAgentWorkspacePaths({
+        root,
+        runId,
+        agentId,
+    });
+    const workspacePaths = buildRunAgentWorkspacePaths({
+        root,
+        runId,
+        agentId,
+        corePaths,
+    });
+    await prepareAgentWorkspace({
+        paths: corePaths,
+        baseRevisionSha,
+        root,
+        agentId,
+        runId,
+        environment,
+    });
+    await ensureRunArtifactWorkspace(workspacePaths);
+    return workspacePaths;
+}
+async function ensureRunArtifactWorkspace(paths) {
+    await mkdir(dirname(paths.diffPath), { recursive: true });
+    await mkdir(dirname(paths.summaryPath), { recursive: true });
+    await writeFile(paths.diffPath, "", { encoding: "utf8" });
+    await writeFile(paths.summaryPath, "", { encoding: "utf8" });
+}
+export function buildRunAgentWorkspacePaths(options) {
+    const { root, runId, agentId, corePaths } = options;
+    const diffRelative = normalizePathForDisplay(getAgentSessionDiffPath(VORATIQ_RUN_DIR, runId, agentId));
+    const summaryRelative = normalizePathForDisplay(getAgentSessionSummaryPath(VORATIQ_RUN_DIR, runId, agentId));
+    return {
+        ...corePaths,
+        diffPath: resolvePath(root, diffRelative),
+        summaryPath: resolvePath(root, summaryRelative),
+    };
+}

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

@@ -1,4 +1,6 @@
-import { DisplayableError, type HintedErrorOptions } from "../../utils/errors.js";
+import { type PreflightIssue } from "../../../competition/shared/preflight.js";
+import { DisplayableError, type HintedErrorOptions } from "../../../utils/errors.js";
+export type { PreflightIssue } from "../../../competition/shared/preflight.js";
 export type RunErrorKind = "workspace-setup" | "agent-process" | "process-spawn" | "git-operation" | "run-report";
 export declare abstract class RunCommandError extends DisplayableError {
     abstract readonly kind: RunErrorKind;
@@ -47,6 +49,11 @@ export declare class AuthProviderStageError extends RunCommandError {
     readonly kind: "workspace-setup";
     constructor(detail: string);
 }
+export declare class RunPreflightError extends RunCommandError {
+    readonly kind: "workspace-setup";
+    readonly issues: readonly PreflightIssue[];
+    constructor(issues: readonly PreflightIssue[], hintLines?: readonly string[]);
+}
 export declare class NoAgentsEnabledError extends RunCommandError {
     readonly kind: "workspace-setup";
     constructor();

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

@@ -1,4 +1,5 @@
-import { DisplayableError, } from "../../utils/errors.js";
+import { formatPreflightIssueLines, PREFLIGHT_HINT, } from "../../../competition/shared/preflight.js";
+import { DisplayableError, } from "../../../utils/errors.js";
 export class RunCommandError extends DisplayableError {
     constructor(message, options = {}) {
         super(message, options);
@@ -14,7 +15,7 @@ export class AgentProcessError extends RunCommandError {
     kind = "agent-process";
     constructor(options = {}) {
         const { detail, exitCode } = options;
-        const baseMessage = detail ?? "Agent process failed. Please review the logs.";
+        const baseMessage = detail ?? "Agent process failed.";
         const formattedMessage = typeof exitCode === "number"
             ? `${baseMessage} (exit code ${exitCode})`
             : baseMessage;
@@ -38,43 +39,72 @@ export class GitOperationError extends RunCommandError {
 export class RunDirectoryExistsError extends RunCommandError {
     kind = "workspace-setup";
     constructor(runId, displayPath) {
-        super(`Run directory already exists for id ${runId}: ${displayPath}`);
+        super(`Run directory already exists for run \`${runId}\`: \`${displayPath}\`.`, {
+            hintLines: ["Remove the existing run directory and retry."],
+        });
     }
 }
 export class MissingAgentProviderError extends RunCommandError {
     kind = "workspace-setup";
     constructor(agentId) {
-        super(`Agent "${agentId}" missing provider.`);
+        super(`Agent \`${agentId}\` is missing a provider.`, {
+            hintLines: ["Set `provider` for this agent in `agents.yaml`."],
+        });
     }
 }
 export class UnknownAuthProviderError extends RunCommandError {
     kind = "workspace-setup";
     constructor(providerId) {
-        super(`Unknown auth provider "${providerId}".`);
+        super(`Unknown auth provider \`${providerId}\`.`, {
+            hintLines: ["Use a provider configured by Voratiq."],
+        });
     }
 }
 export class AuthProviderVerificationError extends RunCommandError {
     kind = "workspace-setup";
     constructor(detail) {
-        super(detail);
+        super(detail, {
+            hintLines: ["Authenticate this provider, then retry."],
+        });
     }
 }
 export class AuthProviderStageError extends RunCommandError {
     kind = "workspace-setup";
     constructor(detail) {
-        super(detail);
+        super(detail, {
+            hintLines: ["Verify provider credentials, then retry."],
+        });
+    }
+}
+const RUN_PREFLIGHT_UNLABELED_AGENT_IDS = ["settings"];
+export class RunPreflightError extends RunCommandError {
+    kind = "workspace-setup";
+    issues;
+    constructor(issues, hintLines = [PREFLIGHT_HINT]) {
+        super("Preflight failed. Aborting run.", {
+            detailLines: formatPreflightIssueLines(issues, {
+                unlabeledAgentIds: RUN_PREFLIGHT_UNLABELED_AGENT_IDS,
+            }),
+            hintLines,
+        });
+        this.issues = Array.from(issues);
+        this.name = "RunPreflightError";
     }
 }
 export class NoAgentsEnabledError extends RunCommandError {
     kind = "workspace-setup";
     constructor() {
-        super("No agents enabled in `.voratiq/agents.yaml`. Set `enabled: true` on at least one agent.");
+        super("No agents are enabled in `agents.yaml`.", {
+            hintLines: ["Set `enabled: true` on at least one agent."],
+        });
     }
 }
 export class RunProcessStreamError extends RunCommandError {
     kind = "process-spawn";
     constructor(detail) {
-        super(detail);
+        super(detail, {
+            hintLines: ["Inspect `stderr.log` to diagnose the failure."],
+        });
         this.name = "RunProcessStreamError";
     }
 }

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

@@ -1,4 +1,4 @@
-import type { AgentInvocationRecord, AgentReport, RunRecord } from "../../records/types.js";
+import type { AgentInvocationRecord, AgentReport, RunRecord } from "../../../domain/run/model/types.js";
 export interface RunRecordInitResult {
     readonly initialRecord: RunRecord;
     readonly recordPersisted: boolean;
@@ -7,5 +7,4 @@ export interface AgentExecutionPhaseResult {
     readonly agentRecords: AgentInvocationRecord[];
     readonly agentReports: AgentReport[];
     readonly hadAgentFailure: boolean;
-    readonly hadEvalFailure: boolean;
 }

package/dist/domain/run/competition/phases.js

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

package/dist/domain/run/competition/prompt.d.ts

@@ -0,0 +1,7 @@
+import { type ResolvedExtraContextFile } from "../../../competition/shared/extra-context.js";
+export interface BuildRunPromptOptions {
+    specContent: string;
+    workspacePath: string;
+    extraContextFiles?: readonly ResolvedExtraContextFile[];
+}
+export declare function buildRunPrompt(options: BuildRunPromptOptions): string;

package/dist/domain/run/competition/prompt.js

@@ -0,0 +1,27 @@
+import { appendExtraContextPromptSection, } from "../../../competition/shared/extra-context.js";
+import { appendConstraints, appendOutputRequirements, buildWorkspaceArtifactRequirements, } from "../../../competition/shared/prompt-helpers.js";
+export function buildRunPrompt(options) {
+    const { specContent, workspacePath, extraContextFiles = [] } = options;
+    const lines = [
+        "Implement the following task:",
+        "",
+        "```",
+        specContent.trimEnd(),
+        "```",
+    ];
+    appendConstraints(lines, {
+        readAccess: workspacePath,
+        writeAccess: workspacePath,
+    });
+    appendExtraContextPromptSection(lines, extraContextFiles);
+    appendOutputRequirements(lines, [
+        "- When finished, clean the workspace of temporary files/dirs you created (e.g., `tmp`, `.tmp`, etc.) unless they are intended deliverables.",
+        ...buildWorkspaceArtifactRequirements([
+            {
+                instruction: "Then write a 1-2 sentence summary",
+                path: ".summary.txt",
+            },
+        ]),
+    ]);
+    return `${lines.join("\n")}\n`;
+}

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

@@ -1,8 +1,11 @@
-import type { AgentInvocationRecord, AgentReport, RunRecord, RunReport } from "../../records/types.js";
+import type { AgentInvocationRecord, AgentReport, ExtractedTokenUsage, RunRecord, RunReport } from "../../../domain/run/model/types.js";
+import type { TokenUsageResult } from "../../../workspace/chat/token-usage-result.js";
 export interface AgentExecutionState {
     diffAttempted: boolean;
     diffCaptured: boolean;
     diffStatistics?: string;
+    tokenUsage?: ExtractedTokenUsage;
+    tokenUsageResult: TokenUsageResult;
 }
 export interface AgentExecutionResult {
     record: AgentInvocationRecord;
@@ -10,5 +13,4 @@ export interface AgentExecutionResult {
 }
 export declare function finalizeAgentResult(runId: string, record: AgentInvocationRecord, derivations: AgentExecutionState): AgentExecutionResult;
 export declare function toAgentReport(runId: string, record: AgentInvocationRecord, derivations: AgentExecutionState): AgentReport;
-export declare function hasEvalFailures(reports: AgentReport[]): boolean;
-export declare function toRunReport(record: RunRecord, agents: AgentReport[], hadAgentFailure: boolean, hadEvalFailure: boolean): RunReport;
+export declare function toRunReport(record: RunRecord, agents: AgentReport[], hadAgentFailure: boolean): RunReport;

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

@@ -1,4 +1,4 @@
-import { buildAgentArtifactPaths, buildAgentEvalViews, getAgentDirectoryPath, getAgentManifestPath, } from "../../workspace/structure.js";
+import { buildAgentArtifactPaths, getAgentDirectoryPath, getAgentManifestPath, } from "../../../workspace/structure.js";
 import { RunReportInvariantError } from "./errors.js";
 export function finalizeAgentResult(runId, record, derivations) {
     return {
@@ -7,9 +7,6 @@ export function finalizeAgentResult(runId, record, derivations) {
     };
 }
 export function toAgentReport(runId, record, derivations) {
-    if (!record.evals) {
-        throw new RunReportInvariantError(`Agent ${record.agentId} is missing evaluation results for status ${record.status}.`);
-    }
     if (!record.startedAt || !record.completedAt) {
         throw new RunReportInvariantError(`Agent ${record.agentId} is missing lifecycle timestamps for status ${record.status}.`);
     }
@@ -21,15 +18,12 @@ export function toAgentReport(runId, record, derivations) {
     return {
         agentId: record.agentId,
         status: record.status,
+        tokenUsage: record.tokenUsage ?? derivations.tokenUsage,
+        tokenUsageResult: derivations.tokenUsageResult,
         runtimeManifestPath: getAgentManifestPath(runId, record.agentId),
         baseDirectory: getAgentDirectoryPath(runId, record.agentId),
         diffStatistics: derivations.diffStatistics,
         assets,
-        evals: buildAgentEvalViews({
-            runId,
-            agentId: record.agentId,
-            evals: record.evals,
-        }),
         error: record.error,
         warnings: record.warnings,
         startedAt: record.startedAt,
@@ -38,26 +32,20 @@ export function toAgentReport(runId, record, derivations) {
         diffCaptured: derivations.diffCaptured,
     };
 }
-export function hasEvalFailures(reports) {
-    return reports.some((report) => report.evals.some((evaluation) => evaluation.status === "failed" || evaluation.status === "errored"));
-}
-export function toRunReport(record, agents, hadAgentFailure, hadEvalFailure) {
-    const derivedAgentFailure = agents.some((agent) => agent.status === "failed");
-    const derivedEvalFailure = hasEvalFailures(agents);
+export function toRunReport(record, agents, hadAgentFailure) {
+    const derivedAgentFailure = agents.some((agent) => agent.status === "failed" || agent.status === "errored");
     if (hadAgentFailure !== derivedAgentFailure) {
         throw new RunReportInvariantError(`RunReport mismatch: hadAgentFailure (${hadAgentFailure}) does not match derived value (${derivedAgentFailure}).`);
     }
-    if (hadEvalFailure !== derivedEvalFailure) {
-        throw new RunReportInvariantError(`RunReport mismatch: hadEvalFailure (${hadEvalFailure}) does not match derived value (${derivedEvalFailure}).`);
-    }
     return {
         runId: record.runId,
         spec: record.spec,
         status: record.status,
         createdAt: record.createdAt,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
         baseRevisionSha: record.baseRevisionSha,
         agents,
         hadAgentFailure: derivedAgentFailure,
-        hadEvalFailure: derivedEvalFailure,
     };
 }

package/dist/domain/run/competition/termination-state.d.ts

@@ -0,0 +1,4 @@
+import type { RunStatus } from "../../../status/index.js";
+export declare const RUN_ABORT_WARNING = "Run aborted before agent completed.";
+export declare function setActiveTerminationStatus(runId: string, status: RunStatus | undefined): void;
+export declare function getActiveTerminationStatus(runId: string): RunStatus | undefined;

package/dist/domain/run/competition/termination-state.js

@@ -0,0 +1,12 @@
+export const RUN_ABORT_WARNING = "Run aborted before agent completed.";
+const activeTerminationStatuses = new Map();
+export function setActiveTerminationStatus(runId, status) {
+    if (status === undefined) {
+        activeTerminationStatuses.delete(runId);
+        return;
+    }
+    activeTerminationStatuses.set(runId, status);
+}
+export function getActiveTerminationStatus(runId) {
+    return activeTerminationStatuses.get(runId);
+}

package/dist/{records → domain/run/model}/enhanced.d.ts

@@ -1,8 +1,5 @@
-import { type AgentArtifactPaths } from "../workspace/structure.js";
-import type { AgentEvalSnapshot, AgentStatus, RunApplyStatus, RunRecord, RunSpecDescriptor } from "./types.js";
-export type AgentEvalEnhanced = AgentEvalSnapshot & {
-    logPath?: string;
-};
+import { type AgentArtifactPaths } from "../../../workspace/structure.js";
+import type { AgentStatus, ExtractedTokenUsage, RunApplyStatus, RunAutoOutcome, RunRecord, RunSpecDescriptor } from "./types.js";
 export interface AgentInvocationEnhanced {
     agentId: string;
     model: string;
@@ -13,22 +10,24 @@ export interface AgentInvocationEnhanced {
     runtimeManifestPath: string;
     baseDirectory: string;
     assets: AgentArtifactPaths;
-    evals: AgentEvalEnhanced[];
     diffStatistics?: string;
+    tokenUsage?: ExtractedTokenUsage;
     error?: string;
     warnings?: string[];
 }
 export interface RunRecordEnhanced {
     runId: string;
     createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
     status: RunRecord["status"];
     baseRevisionSha: string;
     rootPath: string;
     spec: RunSpecDescriptor;
-    promptPath: string;
     agents: AgentInvocationEnhanced[];
     deletedAt?: string | null;
     applyStatus?: RunApplyStatus;
+    auto?: RunAutoOutcome;
 }
 export interface BuildRunRecordViewOptions {
     workspaceRoot?: string;

package/dist/{records → domain/run/model}/enhanced.js

@@ -1,10 +1,9 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { normalizeDiffStatistics } from "../utils/diff.js";
-import { isFileSystemError } from "../utils/fs.js";
-import { buildAgentArtifactPaths, buildAgentEvalViews, getAgentDirectoryPath, getAgentManifestPath, getRunPromptPath, } from "../workspace/structure.js";
+import { normalizeDiffStatistics } from "../../../utils/diff.js";
+import { isFileSystemError } from "../../../utils/fs.js";
+import { buildAgentArtifactPaths, getAgentDirectoryPath, getAgentManifestPath, } from "../../../workspace/structure.js";
 export function buildRunRecordEnhanced(record) {
-    const promptPath = getRunPromptPath(record.runId);
     const agents = (record.agents ?? []).map((agent) => {
         const baseDirectory = getAgentDirectoryPath(record.runId, agent.agentId);
         const runtimeManifestPath = getAgentManifestPath(record.runId, agent.agentId);
@@ -13,11 +12,6 @@ export function buildRunRecordEnhanced(record) {
             agentId: agent.agentId,
             artifacts: agent.artifacts,
         });
-        const evals = buildAgentEvalViews({
-            runId: record.runId,
-            agentId: agent.agentId,
-            evals: agent.evals,
-        });
         const enhancedAgent = {
             agentId: agent.agentId,
             model: agent.model,
@@ -25,7 +19,6 @@ export function buildRunRecordEnhanced(record) {
             runtimeManifestPath,
             baseDirectory,
             assets,
-            evals,
         };
         const normalizedDiff = normalizeDiffStatistics(agent.diffStatistics);
         if (normalizedDiff) {
@@ -46,16 +39,20 @@ export function buildRunRecordEnhanced(record) {
         if (Array.isArray(agent.warnings) && agent.warnings.length > 0) {
             enhancedAgent.warnings = [...agent.warnings];
         }
+        if (agent.tokenUsage) {
+            enhancedAgent.tokenUsage = agent.tokenUsage;
+        }
         return enhancedAgent;
     });
     const enhanced = {
         runId: record.runId,
         createdAt: record.createdAt,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
         status: record.status,
         baseRevisionSha: record.baseRevisionSha,
         rootPath: record.rootPath,
         spec: record.spec,
-        promptPath,
         agents,
     };
     if (Object.prototype.hasOwnProperty.call(record, "deletedAt")) {
@@ -64,6 +61,9 @@ export function buildRunRecordEnhanced(record) {
     if (record.applyStatus) {
         enhanced.applyStatus = record.applyStatus;
     }
+    if (record.auto) {
+        enhanced.auto = record.auto;
+    }
     return enhanced;
 }
 export async function buildRunRecordView(record, options = {}) {