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

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

@@ -1,4 +1,4 @@
-import { DisplayableError } from "../utils/errors.js";
+import { DisplayableError } from "../../../utils/errors.js";
 export declare abstract class RunHistoryError extends DisplayableError {
     constructor(message: string);
 }

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

@@ -1,4 +1,4 @@
-import { DisplayableError } from "../utils/errors.js";
+import { DisplayableError } from "../../../utils/errors.js";
 export class RunHistoryError extends DisplayableError {
     constructor(message) {
         super(message);
@@ -8,7 +8,7 @@ export class RunRecordParseError extends RunHistoryError {
     displayPath;
     details;
     constructor(displayPath, details) {
-        super(`Failed to parse ${displayPath}: ${details}`);
+        super(`Failed to parse \`${displayPath}\`: ${details}`);
         this.displayPath = displayPath;
         this.details = details;
         this.name = "RunRecordParseError";
@@ -17,7 +17,7 @@ export class RunRecordParseError extends RunHistoryError {
 export class RunRecordNotFoundError extends RunHistoryError {
     runId;
     constructor(runId) {
-        super(`Run ${runId} not found.`);
+        super(`Run \`${runId}\` not found.`);
         this.runId = runId;
         this.name = "RunRecordNotFoundError";
     }
@@ -31,13 +31,13 @@ export class RunRecordMutationError extends RunHistoryError {
 export class RunHistoryLockTimeoutError extends RunHistoryError {
     lockPath;
     constructor(lockPath) {
-        super(`Timed out acquiring history lock at ${lockPath}.`);
+        super(`Timed out acquiring history lock at \`${lockPath}\`.`);
         this.lockPath = lockPath;
         this.name = "RunHistoryLockTimeoutError";
     }
 }
 export class RunOptionValidationError extends RunHistoryError {
     constructor(option, detail) {
-        super(`Invalid option "${option}": ${detail}`);
+        super(`Invalid option \`${option}\`: ${detail}`);
     }
 }

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

@@ -1,6 +1,6 @@
-import type { AgentDefinition } from "../configs/agents/types.js";
-import type { RunProgressRenderer } from "../render/transcripts/run.js";
-import type { AgentInvocationRecord } from "./types.js";
+import type { AgentDefinition } from "../../../configs/agents/types.js";
+import type { RunProgressRenderer } from "../../../render/transcripts/run.js";
+import { type AgentInvocationRecord } from "./types.js";
 export interface AgentRecordMutators {
     recordAgentQueued: (agent: AgentDefinition) => Promise<void>;
     recordAgentSnapshot: (record: AgentInvocationRecord) => Promise<void>;
@@ -15,3 +15,4 @@ export interface MutatorFactoryInput {
  * Create agent record mutation callbacks for a run.
  */
 export declare function createAgentRecordMutators(input: MutatorFactoryInput): AgentRecordMutators;
+export declare function mergeAgentRecords(existing: AgentInvocationRecord | undefined, incoming: AgentInvocationRecord): AgentInvocationRecord;

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

@@ -1,6 +1,8 @@
-import { getActiveTerminationStatus, RUN_ABORT_WARNING, } from "../commands/run/lifecycle.js";
-import { normalizeDiffStatistics } from "../utils/diff.js";
-import { rewriteRunRecord } from "./persistence.js";
+import { emitStageProgressEvent } from "../../../render/transcripts/stage-progress.js";
+import { normalizeDiffStatistics } from "../../../utils/diff.js";
+import { getActiveTerminationStatus, RUN_ABORT_WARNING, } from "../competition/termination-state.js";
+import { rewriteRunRecord } from "../persistence/adapter.js";
+import { extractedTokenUsageSchema, } from "./types.js";
 import { IN_PROGRESS_AGENT_STATUSES, TERMINAL_AGENT_STATUSES, } from "./types.js";
 /**
  * Create agent record mutation callbacks for a run.
@@ -39,20 +41,42 @@ export function createAgentRecordMutators(input) {
             };
             return mergeAgentRecords(existing, queuedRecord);
         });
-        if (renderer) {
-            renderer.update({
+        emitStageProgressEvent(renderer, {
+            type: "stage.candidate",
+            stage: "run",
+            candidate: {
                 agentId: agent.id,
                 model: agent.model,
                 status: "queued",
-            });
-        }
+            },
+        });
     };
     const recordAgentSnapshot = async (record) => {
         const snapshot = normalizeSnapshotForTermination(runId, record);
-        await updateAgentRecord(record.agentId, (existing) => mergeAgentRecords(existing, snapshot));
-        if (renderer) {
-            renderer.update(snapshot);
-        }
+        await rewriteRunRecord({
+            root,
+            runsFilePath,
+            runId,
+            forceFlush: TERMINAL_AGENT_STATUSES.includes(snapshot.status),
+            mutate: (existing) => {
+                const agents = [...existing.agents];
+                const index = agents.findIndex((agent) => agent.agentId === record.agentId);
+                const current = index >= 0 ? agents[index] : undefined;
+                const updated = mergeAgentRecords(current, snapshot);
+                if (index >= 0) {
+                    agents[index] = updated;
+                }
+                else {
+                    agents.push(updated);
+                }
+                return { ...existing, agents };
+            },
+        });
+        emitStageProgressEvent(renderer, {
+            type: "stage.candidate",
+            stage: "run",
+            candidate: snapshot,
+        });
     };
     return {
         recordAgentQueued,
@@ -68,20 +92,7 @@ function mergeArtifactState(existing, incoming) {
         ...(incoming ?? {}),
     };
 }
-function mergeEvalSnapshots(existing, incoming) {
-    if (!existing && !incoming) {
-        return undefined;
-    }
-    const bySlug = new Map();
-    for (const evaluation of existing ?? []) {
-        bySlug.set(evaluation.slug, evaluation);
-    }
-    for (const evaluation of incoming ?? []) {
-        bySlug.set(evaluation.slug, evaluation);
-    }
-    return Array.from(bySlug.values());
-}
-function mergeAgentRecords(existing, incoming) {
+export function mergeAgentRecords(existing, incoming) {
     if (existing &&
         TERMINAL_AGENT_STATUSES.includes(existing.status) &&
         IN_PROGRESS_AGENT_STATUSES.includes(incoming.status)) {
@@ -98,13 +109,6 @@ function mergeAgentRecords(existing, incoming) {
     else {
         delete merged.artifacts;
     }
-    const mergedEvals = mergeEvalSnapshots(existing?.evals, incoming.evals);
-    if (mergedEvals && mergedEvals.length > 0) {
-        merged.evals = mergedEvals;
-    }
-    else {
-        delete merged.evals;
-    }
     const normalizedIncomingDiff = normalizeDiffStatistics(incoming.diffStatistics);
     const normalizedExistingDiff = normalizeDiffStatistics(existing?.diffStatistics);
     const latestDiff = normalizedIncomingDiff ?? normalizedExistingDiff;
@@ -114,8 +118,25 @@ function mergeAgentRecords(existing, incoming) {
     else {
         delete merged.diffStatistics;
     }
+    const mergedTokenUsage = mergeTokenUsage(existing?.tokenUsage, incoming.tokenUsage);
+    if (mergedTokenUsage) {
+        merged.tokenUsage = mergedTokenUsage;
+    }
+    else {
+        delete merged.tokenUsage;
+    }
     return merged;
 }
+function mergeTokenUsage(existing, incoming) {
+    return normalizeTokenUsage(incoming) ?? normalizeTokenUsage(existing);
+}
+function normalizeTokenUsage(tokenUsage) {
+    if (!tokenUsage) {
+        return undefined;
+    }
+    const parsed = extractedTokenUsageSchema.safeParse(tokenUsage);
+    return parsed.success ? parsed.data : undefined;
+}
 function normalizeSnapshotForTermination(runId, record) {
     const terminationStatus = getActiveTerminationStatus(runId);
     if (terminationStatus !== "aborted") {
@@ -127,8 +148,9 @@ function normalizeSnapshotForTermination(runId, record) {
     if (record.status === "aborted") {
         return record;
     }
-    const completedAt = record.completedAt ?? new Date().toISOString();
-    const startedAt = record.startedAt ?? completedAt;
+    if (!record.startedAt || !record.completedAt) {
+        throw new Error(`Terminal agent snapshot for ${record.agentId} is missing canonical lifecycle timestamps.`);
+    }
     const warnings = record.warnings ?? [];
     const hasAbortWarning = warnings.includes(RUN_ABORT_WARNING);
     const abortWarnings = hasAbortWarning
@@ -137,8 +159,8 @@ function normalizeSnapshotForTermination(runId, record) {
     return {
         ...record,
         status: "aborted",
-        startedAt,
-        completedAt,
+        startedAt: record.startedAt,
+        completedAt: record.completedAt,
         warnings: abortWarnings,
     };
 }

package/dist/domain/run/model/types.d.ts

@@ -0,0 +1,376 @@
+import { z } from "zod";
+import { type AgentStatus, agentStatusSchema, IN_PROGRESS_AGENT_STATUSES, TERMINAL_AGENT_STATUSES } from "../../../status/index.js";
+import type { TokenUsageResult } from "../../../workspace/chat/token-usage-result.js";
+export type { AgentStatus };
+export { agentStatusSchema, IN_PROGRESS_AGENT_STATUSES, TERMINAL_AGENT_STATUSES, };
+export declare const runSpecDescriptorSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strip>;
+export type RunSpecDescriptor = z.infer<typeof runSpecDescriptorSchema>;
+export declare const CHAT_USAGE_PROVIDER_IDS: readonly ["claude", "codex", "gemini"];
+export declare const watchdogMetadataSchema: z.ZodObject<{
+    silenceTimeoutMs: z.ZodNumber;
+    wallClockCapMs: z.ZodNumber;
+    trigger: z.ZodOptional<z.ZodEnum<{
+        silence: "silence";
+        "wall-clock": "wall-clock";
+        "fatal-pattern": "fatal-pattern";
+        "sandbox-denial": "sandbox-denial";
+    }>>;
+}, z.core.$strip>;
+export type WatchdogMetadata = z.infer<typeof watchdogMetadataSchema>;
+export type ChatUsageProviderId = (typeof CHAT_USAGE_PROVIDER_IDS)[number];
+export declare const chatUsageProviderIdSchema: z.ZodEnum<{
+    claude: "claude";
+    codex: "codex";
+    gemini: "gemini";
+}>;
+export declare const claudeExtractedTokenUsageSchema: z.ZodObject<{
+    input_tokens: z.ZodOptional<z.ZodNumber>;
+    output_tokens: z.ZodOptional<z.ZodNumber>;
+    cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+    cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type ClaudeExtractedTokenUsage = z.infer<typeof claudeExtractedTokenUsageSchema>;
+export declare const codexExtractedTokenUsageSchema: z.ZodObject<{
+    input_tokens: z.ZodOptional<z.ZodNumber>;
+    cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+    output_tokens: z.ZodOptional<z.ZodNumber>;
+    reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+    total_tokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type CodexExtractedTokenUsage = z.infer<typeof codexExtractedTokenUsageSchema>;
+export declare const geminiExtractedTokenUsageSchema: z.ZodObject<{
+    input: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodOptional<z.ZodNumber>;
+    cached: z.ZodOptional<z.ZodNumber>;
+    thoughts: z.ZodOptional<z.ZodNumber>;
+    tool: z.ZodOptional<z.ZodNumber>;
+    total: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type GeminiExtractedTokenUsage = z.infer<typeof geminiExtractedTokenUsageSchema>;
+export declare const extractedTokenUsageSchemaByProvider: {
+    readonly claude: z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly codex: z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+        total_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly gemini: z.ZodObject<{
+        input: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+        cached: z.ZodOptional<z.ZodNumber>;
+        thoughts: z.ZodOptional<z.ZodNumber>;
+        tool: z.ZodOptional<z.ZodNumber>;
+        total: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+};
+export declare const extractedTokenUsageSchema: z.ZodUnion<readonly [z.ZodObject<{
+    input_tokens: z.ZodOptional<z.ZodNumber>;
+    output_tokens: z.ZodOptional<z.ZodNumber>;
+    cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+    cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    input_tokens: z.ZodOptional<z.ZodNumber>;
+    cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+    output_tokens: z.ZodOptional<z.ZodNumber>;
+    reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+    total_tokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    input: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodOptional<z.ZodNumber>;
+    cached: z.ZodOptional<z.ZodNumber>;
+    thoughts: z.ZodOptional<z.ZodNumber>;
+    tool: z.ZodOptional<z.ZodNumber>;
+    total: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>]>;
+export type ExtractedTokenUsage = z.infer<typeof extractedTokenUsageSchema>;
+export declare const agentArtifactStateSchema: z.ZodObject<{
+    diffAttempted: z.ZodOptional<z.ZodBoolean>;
+    diffCaptured: z.ZodOptional<z.ZodBoolean>;
+    stdoutCaptured: z.ZodOptional<z.ZodBoolean>;
+    stderrCaptured: z.ZodOptional<z.ZodBoolean>;
+    summaryCaptured: z.ZodOptional<z.ZodBoolean>;
+    chatCaptured: z.ZodOptional<z.ZodBoolean>;
+    chatFormat: z.ZodOptional<z.ZodEnum<{
+        json: "json";
+        jsonl: "jsonl";
+    }>>;
+}, z.core.$strip>;
+export type AgentArtifactState = z.infer<typeof agentArtifactStateSchema>;
+export declare const agentInvocationRecordSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    model: z.ZodString;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        errored: "errored";
+        aborted: "aborted";
+        skipped: "skipped";
+    }>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    commitSha: z.ZodOptional<z.ZodString>;
+    artifacts: z.ZodOptional<z.ZodObject<{
+        diffAttempted: z.ZodOptional<z.ZodBoolean>;
+        diffCaptured: z.ZodOptional<z.ZodBoolean>;
+        stdoutCaptured: z.ZodOptional<z.ZodBoolean>;
+        stderrCaptured: z.ZodOptional<z.ZodBoolean>;
+        summaryCaptured: z.ZodOptional<z.ZodBoolean>;
+        chatCaptured: z.ZodOptional<z.ZodBoolean>;
+        chatFormat: z.ZodOptional<z.ZodEnum<{
+            json: "json";
+            jsonl: "jsonl";
+        }>>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    diffStatistics: z.ZodOptional<z.ZodString>;
+    tokenUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        input_tokens: z.ZodOptional<z.ZodNumber>;
+        cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+        output_tokens: z.ZodOptional<z.ZodNumber>;
+        reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+        total_tokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        input: z.ZodOptional<z.ZodNumber>;
+        output: z.ZodOptional<z.ZodNumber>;
+        cached: z.ZodOptional<z.ZodNumber>;
+        thoughts: z.ZodOptional<z.ZodNumber>;
+        tool: z.ZodOptional<z.ZodNumber>;
+        total: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>]>>;
+    watchdog: z.ZodOptional<z.ZodObject<{
+        silenceTimeoutMs: z.ZodNumber;
+        wallClockCapMs: z.ZodNumber;
+        trigger: z.ZodOptional<z.ZodEnum<{
+            silence: "silence";
+            "wall-clock": "wall-clock";
+            "fatal-pattern": "fatal-pattern";
+            "sandbox-denial": "sandbox-denial";
+        }>>;
+    }, z.core.$strip>>;
+    failFastTriggered: z.ZodOptional<z.ZodBoolean>;
+    failFastTarget: z.ZodOptional<z.ZodString>;
+    failFastOperation: z.ZodOptional<z.ZodEnum<{
+        "network-connect": "network-connect";
+        "file-read": "file-read";
+        "file-write": "file-write";
+    }>>;
+}, z.core.$strip>;
+export type AgentInvocationRecord = z.infer<typeof agentInvocationRecordSchema>;
+export declare const applyStatusSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    status: z.ZodEnum<{
+        succeeded: "succeeded";
+        failed: "failed";
+    }>;
+    appliedAt: z.ZodString;
+    ignoredBaseMismatch: z.ZodBoolean;
+    appliedCommitSha: z.ZodOptional<z.ZodString>;
+    detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type RunApplyStatus = z.infer<typeof applyStatusSchema>;
+export declare const AUTO_TERMINAL_STATUS_VALUES: readonly ["succeeded", "failed", "action_required"];
+export type AutoTerminalStatus = (typeof AUTO_TERMINAL_STATUS_VALUES)[number];
+export declare const autoTerminalStatusSchema: z.ZodEnum<{
+    succeeded: "succeeded";
+    failed: "failed";
+    action_required: "action_required";
+}>;
+export declare const AUTO_APPLY_STATUS_VALUES: readonly ["succeeded", "failed", "skipped"];
+export type AutoApplyStatus = (typeof AUTO_APPLY_STATUS_VALUES)[number];
+export declare const autoApplyStatusSchema: z.ZodEnum<{
+    succeeded: "succeeded";
+    failed: "failed";
+    skipped: "skipped";
+}>;
+export declare const autoOutcomeSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        succeeded: "succeeded";
+        failed: "failed";
+        action_required: "action_required";
+    }>;
+    completedAt: z.ZodString;
+    detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    apply: z.ZodObject<{
+        status: z.ZodEnum<{
+            succeeded: "succeeded";
+            failed: "failed";
+            skipped: "skipped";
+        }>;
+        agentId: z.ZodOptional<z.ZodString>;
+        detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RunAutoOutcome = z.infer<typeof autoOutcomeSchema>;
+export declare const runRecordSchema: z.ZodObject<{
+    runId: z.ZodString;
+    baseRevisionSha: z.ZodString;
+    rootPath: z.ZodString;
+    spec: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strip>;
+    extraContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    extraContextMetadata: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        stagedPath: z.ZodString;
+        sourcePath: z.ZodString;
+    }, z.core.$strip>>>;
+    status: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        failed: "failed";
+        errored: "errored";
+        aborted: "aborted";
+        pruned: "pruned";
+    }>;
+    createdAt: z.ZodString;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    agents: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        model: z.ZodString;
+        status: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+            failed: "failed";
+            errored: "errored";
+            aborted: "aborted";
+            skipped: "skipped";
+        }>;
+        startedAt: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodString>;
+        commitSha: z.ZodOptional<z.ZodString>;
+        artifacts: z.ZodOptional<z.ZodObject<{
+            diffAttempted: z.ZodOptional<z.ZodBoolean>;
+            diffCaptured: z.ZodOptional<z.ZodBoolean>;
+            stdoutCaptured: z.ZodOptional<z.ZodBoolean>;
+            stderrCaptured: z.ZodOptional<z.ZodBoolean>;
+            summaryCaptured: z.ZodOptional<z.ZodBoolean>;
+            chatCaptured: z.ZodOptional<z.ZodBoolean>;
+            chatFormat: z.ZodOptional<z.ZodEnum<{
+                json: "json";
+                jsonl: "jsonl";
+            }>>;
+        }, z.core.$strip>>;
+        error: z.ZodOptional<z.ZodString>;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        diffStatistics: z.ZodOptional<z.ZodString>;
+        tokenUsage: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+            reasoning_output_tokens: z.ZodOptional<z.ZodNumber>;
+            total_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>, z.ZodObject<{
+            input: z.ZodOptional<z.ZodNumber>;
+            output: z.ZodOptional<z.ZodNumber>;
+            cached: z.ZodOptional<z.ZodNumber>;
+            thoughts: z.ZodOptional<z.ZodNumber>;
+            tool: z.ZodOptional<z.ZodNumber>;
+            total: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>]>>;
+        watchdog: z.ZodOptional<z.ZodObject<{
+            silenceTimeoutMs: z.ZodNumber;
+            wallClockCapMs: z.ZodNumber;
+            trigger: z.ZodOptional<z.ZodEnum<{
+                silence: "silence";
+                "wall-clock": "wall-clock";
+                "fatal-pattern": "fatal-pattern";
+                "sandbox-denial": "sandbox-denial";
+            }>>;
+        }, z.core.$strip>>;
+        failFastTriggered: z.ZodOptional<z.ZodBoolean>;
+        failFastTarget: z.ZodOptional<z.ZodString>;
+        failFastOperation: z.ZodOptional<z.ZodEnum<{
+            "network-connect": "network-connect";
+            "file-read": "file-read";
+            "file-write": "file-write";
+        }>>;
+    }, z.core.$strip>>;
+    applyStatus: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        status: z.ZodEnum<{
+            succeeded: "succeeded";
+            failed: "failed";
+        }>;
+        appliedAt: z.ZodString;
+        ignoredBaseMismatch: z.ZodBoolean;
+        appliedCommitSha: z.ZodOptional<z.ZodString>;
+        detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    auto: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            succeeded: "succeeded";
+            failed: "failed";
+            action_required: "action_required";
+        }>;
+        completedAt: z.ZodString;
+        detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        apply: z.ZodObject<{
+            status: z.ZodEnum<{
+                succeeded: "succeeded";
+                failed: "failed";
+                skipped: "skipped";
+            }>;
+            agentId: z.ZodOptional<z.ZodString>;
+            detail: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    deletedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type RunRecord = z.infer<typeof runRecordSchema>;
+export type AgentReport = {
+    agentId: AgentInvocationRecord["agentId"];
+    status: AgentInvocationRecord["status"];
+    tokenUsage?: ExtractedTokenUsage;
+    tokenUsageResult: TokenUsageResult;
+    runtimeManifestPath: string;
+    baseDirectory: string;
+    assets: {
+        stdoutPath?: string;
+        stderrPath?: string;
+        diffPath?: string;
+        summaryPath?: string;
+        chatPath?: string;
+    };
+    startedAt: string;
+    completedAt: string;
+    diffStatistics?: string;
+    error?: string;
+    warnings?: string[];
+    diffAttempted: boolean;
+    diffCaptured: boolean;
+};
+export type RunReport = {
+    runId: RunRecord["runId"];
+    spec: RunRecord["spec"];
+    status: RunRecord["status"];
+    createdAt: RunRecord["createdAt"];
+    startedAt?: RunRecord["startedAt"];
+    completedAt?: RunRecord["completedAt"];
+    baseRevisionSha: RunRecord["baseRevisionSha"];
+    agents: AgentReport[];
+    hadAgentFailure: boolean;
+};