voratiq 0.1.0-beta.5 → 0.1.0-beta.7

package/README.md

@@ -1,15 +1,15 @@
 # Voratiq
 
-Run agents in parallel, compare results, and apply the best solution.
+Run coding agents against each other. Merge the winner.
 
-![`voratiq run --spec specs/p1/agent-workspace-guardrails.md`](https://raw.githubusercontent.com/voratiq/voratiq/main/assets/run-demo.png)
+![`voratiq run --spec .voratiq/specs/apply-commit-flag.md`](https://raw.githubusercontent.com/voratiq/voratiq/main/assets/run-demo.png)
 
 ## Installation
 
 Voratiq is in public beta. Install via npm:
 
 ```bash
-npm install -g voratiq@beta
+npm install -g voratiq
 ```
 
 ### Requirements
@@ -18,7 +18,7 @@ Core:
 
 - Node 20+
 - git
-- 1+ AI coding agent (Claude [(>=2.0.55)](https://github.com/anthropics/claude-code?tab=readme-ov-file#get-started), Codex [(>=0.66.0)](https://github.com/openai/codex?tab=readme-ov-file#quickstart), or Gemini [(>=0.19.4)](https://github.com/google-gemini/gemini-cli?tab=readme-ov-file#quick-install))
+- 1+ AI coding agent (Claude [>=2.0.55](https://github.com/anthropics/claude-code?tab=readme-ov-file#get-started), Codex [>=0.66.0](https://github.com/openai/codex?tab=readme-ov-file#quickstart), or Gemini [>=0.19.4](https://github.com/google-gemini/gemini-cli?tab=readme-ov-file#quick-install))
 
 Platform-specific:
 
@@ -36,7 +36,10 @@ Note: Windows is not currently supported.
 voratiq init
 
 # Generate a spec
-voratiq spec --description "add dark mode toggle with localStorage persistence" --agent <agent-id> --yes
+voratiq spec \
+  --description "add dark mode toggle with localStorage persistence" \
+  --agent <agent-id> \
+  --yes
 
 # Run agents in parallel
 voratiq run --spec .voratiq/specs/add-dark-mode-toggle.md
@@ -48,7 +51,9 @@ voratiq review --run <run-id> --agent <agent-id>
 voratiq apply --run <run-id> --agent <agent-id>
 ```
 
-See the [docs](https://github.com/voratiq/voratiq/blob/main/docs/index.md) for core concepts, CLI reference, and guides on configuring agents, evals, runtime environments, and sandbox restrictions.
+For a full walkthrough, see the [CLI tutorial](https://github.com/voratiq/voratiq/blob/main/docs/tutorial.md).
+
+See the [docs](https://github.com/voratiq/voratiq/blob/main/docs/index.md) for core concepts, CLI reference, and configuration guides.
 
 ## License
 

package/dist/cli/apply.d.ts

@@ -4,6 +4,7 @@ export interface ApplyCommandOptions {
     runId: string;
     agentId: string;
     ignoreBaseMismatch?: boolean;
+    commit?: boolean;
 }
 export interface ApplyCommandResult {
     result: ApplyResult;

package/dist/cli/apply.js

@@ -4,7 +4,7 @@ import { ensureCleanWorkingTree, resolveCliContext, } from "../preflight/index.j
 import { renderApplyTranscript } from "../render/transcripts/apply.js";
 import { writeCommandOutput } from "./output.js";
 export async function runApplyCommand(options) {
-    const { runId, agentId, ignoreBaseMismatch = false } = options;
+    const { runId, agentId, ignoreBaseMismatch = false, commit = false, } = options;
     const { root, workspacePaths } = await resolveCliContext();
     await ensureCleanWorkingTree(root);
     const result = await executeApplyCommand({
@@ -13,6 +13,7 @@ export async function runApplyCommand(options) {
         runId,
         agentId,
         ignoreBaseMismatch,
+        commit,
     });
     const body = renderApplyTranscript(result);
     return { result, body };
@@ -23,12 +24,14 @@ export function createApplyCommand() {
         .requiredOption("--run <run-id>", "Identifier of the recorded run")
         .requiredOption("--agent <agent-id>", "Agent id to apply from the run")
         .option("--ignore-base-mismatch", "Apply even if the current HEAD differs from the recorded base", () => true)
+        .option("--commit", "Commit the applied diff immediately using the agent summary", () => true)
         .allowExcessArguments(false)
         .action(async (options) => {
         const result = await runApplyCommand({
             runId: options.run,
             agentId: options.agent,
             ignoreBaseMismatch: options.ignoreBaseMismatch ?? false,
+            commit: options.commit ?? false,
         });
         writeCommandOutput({
             body: result.body,

package/dist/cli/prune.d.ts

@@ -1,12 +1,13 @@
 import { Command } from "commander";
-import type { PruneResult } from "../commands/prune/types.js";
+import type { PruneAllResult, PruneResult } from "../commands/prune/types.js";
 export interface PruneCommandOptions {
-    runId: string;
+    runId?: string;
+    all?: boolean;
     purge?: boolean;
     yes?: boolean;
 }
 export interface PruneCommandResult {
-    result: PruneResult;
+    result: PruneResult | PruneAllResult;
     body: string;
     exitCode?: number;
 }

package/dist/cli/prune.js

@@ -1,12 +1,13 @@
-import { Command } from "commander";
-import { executePruneCommand } from "../commands/prune/command.js";
+import { Command, Option } from "commander";
+import { executePruneAllCommand, executePruneCommand, } from "../commands/prune/command.js";
 import { resolveCliContext } from "../preflight/index.js";
-import { renderPruneTranscript } from "../render/transcripts/prune.js";
+import { renderPruneAllTranscript, renderPruneTranscript, } from "../render/transcripts/prune.js";
 import { createConfirmationWorkflow } from "./confirmation.js";
 import { NonInteractiveShellError } from "./errors.js";
 import { writeCommandOutput } from "./output.js";
 export async function runPruneCommand(options) {
     const { runId } = options;
+    const all = Boolean(options.all);
     const purge = Boolean(options.purge);
     const assumeYes = Boolean(options.yes);
     const { root, workspacePaths } = await resolveCliContext();
@@ -17,6 +18,20 @@ export async function runPruneCommand(options) {
         },
     });
     try {
+        if (all) {
+            const result = await executePruneAllCommand({
+                root,
+                runsDir: workspacePaths.runsDir,
+                runsFilePath: workspacePaths.runsFile,
+                confirm: confirmation.confirm,
+                purge,
+            });
+            const body = renderPruneAllTranscript(result);
+            return { result, body };
+        }
+        if (!runId) {
+            throw new Error("Expected --run <run-id> when --all is not set.");
+        }
         const result = await executePruneCommand({
             root,
             runsDir: workspacePaths.runsDir,
@@ -35,14 +50,23 @@ export async function runPruneCommand(options) {
 export function createPruneCommand() {
     return new Command("prune")
         .description("Remove artifacts for a recorded run")
-        .requiredOption("--run <run-id>", "Identifier of the run to delete")
+        .addOption(new Option("--run <run-id>", "Identifier of the run to delete").conflicts("all"))
+        .addOption(new Option("--all", "Prune all non-pruned runs").conflicts("run"))
         .option("--purge", "Delete all associated configs and artifacts")
         .option("-y, --yes", "Assume yes for all prompts")
         .addHelpText("after", "\nThis command removes agent workspaces, deletes agent branches, and marks runs as pruned. \nPass --purge to also delete all associated configs and artifacts.")
         .allowExcessArguments(false)
-        .action(async (options) => {
+        .action(async (options, command) => {
+        const hasRun = typeof options.run === "string" && options.run.length > 0;
+        const wantsAll = Boolean(options.all);
+        if (!hasRun && !wantsAll) {
+            command.error("error: either --run <run-id> or --all must be provided", {
+                exitCode: 1,
+            });
+        }
         const result = await runPruneCommand({
             runId: options.run,
+            all: wantsAll,
             purge: Boolean(options.purge),
             yes: Boolean(options.yes),
         });

package/dist/cli/run.d.ts

@@ -3,6 +3,7 @@ import type { RunReport } from "../runs/records/types.js";
 export interface RunCommandOptions {
     specPath: string;
     maxParallel?: number;
+    branch?: boolean;
 }
 export interface RunCommandResult {
     report: RunReport;
@@ -10,4 +11,13 @@ export interface RunCommandResult {
     exitCode?: number;
 }
 export declare function runRunCommand(options: RunCommandOptions): Promise<RunCommandResult>;
+/**
+ * Derives a branch name from a spec file path by extracting the basename without extension.
+ *
+ * Examples:
+ * - `specs/separate-eval-outcomes.md` → `separate-eval-outcomes`
+ * - `specs/foo/bar.md` → `bar`
+ * - `my-feature.md` → `my-feature`
+ */
+export declare function deriveBranchNameFromSpecPath(specPath: string): string;
 export declare function createRunCommand(): Command;

package/dist/cli/run.js

@@ -1,17 +1,23 @@
+import { basename } from "node:path";
 import { Command } from "commander";
 import { checkPlatformSupport } from "../agents/runtime/sandbox.js";
 import { executeRunCommand } from "../commands/run/command.js";
+import { checkoutOrCreateBranch } from "../preflight/branch.js";
 import { ensureCleanWorkingTree, ensureSandboxDependencies, ensureSpecPath, resolveCliContext, } from "../preflight/index.js";
 import { createRunRenderer } from "../render/transcripts/run.js";
 import { parsePositiveInteger } from "../utils/validators.js";
 import { writeCommandOutput } from "./output.js";
 export async function runRunCommand(options) {
-    const { specPath, maxParallel } = options;
+    const { specPath, maxParallel, branch } = options;
     const { root, workspacePaths } = await resolveCliContext();
     checkPlatformSupport();
     ensureSandboxDependencies();
     await ensureCleanWorkingTree(root);
     const { absolutePath, displayPath } = await ensureSpecPath(specPath, root);
+    if (branch) {
+        const branchName = deriveBranchNameFromSpecPath(displayPath);
+        await checkoutOrCreateBranch(root, branchName);
+    }
     const renderer = createRunRenderer();
     const report = await executeRunCommand({
         root,
@@ -23,11 +29,28 @@ export async function runRunCommand(options) {
     });
     const body = renderer.complete(report);
     // Unlike other commands, `run` signals a degraded outcome via exit code 1
-    // when any agent or eval fails. All other CLI commands either throw on error
+    // when any agent fails. Eval failures are quality signals displayed in the output
+    // but do not affect exit code. All other CLI commands either throw on error
     // or return a clean success with exit code 0, so keep this deviation explicit.
-    const exitCode = report.hadAgentFailure || report.hadEvalFailure ? 1 : undefined;
+    const exitCode = report.hadAgentFailure ? 1 : undefined;
     return { report, body, exitCode };
 }
+/**
+ * Derives a branch name from a spec file path by extracting the basename without extension.
+ *
+ * Examples:
+ * - `specs/separate-eval-outcomes.md` → `separate-eval-outcomes`
+ * - `specs/foo/bar.md` → `bar`
+ * - `my-feature.md` → `my-feature`
+ */
+export function deriveBranchNameFromSpecPath(specPath) {
+    const base = basename(specPath);
+    const lastDotIndex = base.lastIndexOf(".");
+    if (lastDotIndex <= 0) {
+        return base;
+    }
+    return base.slice(0, lastDotIndex);
+}
 function parseMaxParallelOption(value) {
     return parsePositiveInteger(value, "Expected positive integer after --max-parallel", "--max-parallel must be greater than 0");
 }
@@ -36,11 +59,13 @@ export function createRunCommand() {
         .description("Execute configured agents against a spec")
         .requiredOption("--spec <path>", "Path to the specification to execute")
         .option("--max-parallel <count>", "Maximum number of agents to run concurrently", parseMaxParallelOption)
+        .option("--branch", "Checkout or create a branch named after the spec file")
         .allowExcessArguments(false)
         .action(async (options) => {
         const runOptions = {
             specPath: options.spec,
             maxParallel: options.maxParallel,
+            branch: options.branch,
         };
         const result = await runRunCommand(runOptions);
         writeCommandOutput({

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

@@ -5,5 +5,6 @@ export interface ApplyCommandInput {
     runId: string;
     agentId: string;
     ignoreBaseMismatch: boolean;
+    commit?: boolean;
 }
 export declare function executeApplyCommand(input: ApplyCommandInput): Promise<ApplyResult>;

package/dist/commands/apply/command.js

@@ -1,3 +1,4 @@
+import { readFile } from "node:fs/promises";
 import { buildRunRecordEnhanced } from "../../runs/records/enhanced.js";
 import { rewriteRunRecord } from "../../runs/records/persistence.js";
 import { toErrorMessage } from "../../utils/errors.js";
@@ -5,9 +6,9 @@ import { ensureFileExists } from "../../utils/fs.js";
 import { getGitStderr, getHeadRevision, runGitCommand, } from "../../utils/git.js";
 import { resolveDisplayPath } from "../../utils/path.js";
 import { fetchRunSafely } from "../fetch.js";
-import { ApplyAgentDiffMissingOnDiskError, ApplyAgentDiffNotRecordedError, ApplyAgentNotFoundError, ApplyBaseMismatchError, ApplyPatchApplicationError, ApplyRunDeletedError, } from "./errors.js";
+import { ApplyAgentDiffMissingOnDiskError, ApplyAgentDiffNotRecordedError, ApplyAgentNotFoundError, ApplyAgentSummaryEmptyError, ApplyAgentSummaryMissingOnDiskError, ApplyAgentSummaryNotRecordedError, ApplyBaseMismatchError, ApplyGitCommitError, ApplyPatchApplicationError, ApplyRunDeletedError, } from "./errors.js";
 export async function executeApplyCommand(input) {
-    const { root, runsFilePath, runId, agentId, ignoreBaseMismatch } = input;
+    const { root, runsFilePath, runId, agentId, ignoreBaseMismatch, commit = false, } = input;
     const runRecord = await fetchRunSafely({
         root,
         runsFilePath,
@@ -30,6 +31,8 @@ export async function executeApplyCommand(input) {
     }
     const diffAbsolutePath = resolveDisplayPath(root, diffDisplayPath) ?? diffDisplayPath;
     await ensureFileExists(diffAbsolutePath, () => new ApplyAgentDiffMissingOnDiskError(diffDisplayPath));
+    const summaryRecorded = agentRecord.artifacts?.summaryCaptured ?? false;
+    const summaryDisplayPath = enhancedAgent.assets.summaryPath;
     const headRevision = await getHeadRevision(root);
     const baseRevisionSha = runRecord.baseRevisionSha;
     const baseMismatch = headRevision !== baseRevisionSha;
@@ -63,6 +66,30 @@ export async function executeApplyCommand(input) {
         }
         throw error;
     }
+    let appliedCommitSha;
+    if (commit) {
+        try {
+            appliedCommitSha = await commitAppliedDiff({
+                root,
+                runId,
+                agentId,
+                summaryRecorded,
+                summaryDisplayPath,
+            });
+        }
+        catch (error) {
+            await recordApplyStatus({
+                root,
+                runsFilePath,
+                runId,
+                agentId,
+                ignoredBaseMismatch,
+                status: "failed",
+                detail: extractCommitFailureDetail(error),
+            });
+            throw error;
+        }
+    }
     await recordApplyStatus({
         root,
         runsFilePath,
@@ -70,6 +97,7 @@ export async function executeApplyCommand(input) {
         agentId,
         ignoredBaseMismatch,
         status: "succeeded",
+        appliedCommitSha,
     });
     return {
         runId: runRecord.runId,
@@ -81,6 +109,7 @@ export async function executeApplyCommand(input) {
         agent: agentRecord,
         diffPath: diffDisplayPath,
         ignoredBaseMismatch,
+        ...(appliedCommitSha ? { appliedCommitSha } : {}),
     };
 }
 async function applyPatch(options) {
@@ -96,7 +125,7 @@ async function applyPatch(options) {
     }
 }
 async function recordApplyStatus(options) {
-    const { root, runsFilePath, runId, agentId, status, ignoredBaseMismatch, detail, } = options;
+    const { root, runsFilePath, runId, agentId, status, ignoredBaseMismatch, appliedCommitSha, detail, } = options;
     const appliedAt = new Date().toISOString();
     const normalizedDetail = typeof detail === "string" && detail.length > 0
         ? truncateDetail(detail)
@@ -115,6 +144,9 @@ async function recordApplyStatus(options) {
             if (normalizedDetail !== undefined) {
                 applyStatus.detail = normalizedDetail;
             }
+            if (typeof appliedCommitSha === "string" && appliedCommitSha.length > 0) {
+                applyStatus.appliedCommitSha = appliedCommitSha;
+            }
             return {
                 ...record,
                 applyStatus,
@@ -129,7 +161,44 @@ function extractApplyFailureDetail(error) {
     }
     return error.message;
 }
+function extractCommitFailureDetail(error) {
+    const stderr = getGitStderr(error);
+    if (stderr && stderr.trim().length > 0) {
+        const [firstLine] = stderr.split(/\r?\n/);
+        if (firstLine && firstLine.trim().length > 0) {
+            return firstLine.trim();
+        }
+        return stderr.trim();
+    }
+    return toErrorMessage(error);
+}
 function truncateDetail(detail) {
     const trimmed = detail.trim();
     return trimmed.length > 256 ? trimmed.slice(0, 256) : trimmed;
 }
+async function commitAppliedDiff(options) {
+    const { root, runId, agentId, summaryRecorded, summaryDisplayPath } = options;
+    if (!summaryRecorded || !summaryDisplayPath) {
+        throw new ApplyAgentSummaryNotRecordedError(runId, agentId);
+    }
+    const summaryAbsolutePath = resolveDisplayPath(root, summaryDisplayPath) ?? summaryDisplayPath;
+    await ensureFileExists(summaryAbsolutePath, () => new ApplyAgentSummaryMissingOnDiskError(summaryDisplayPath));
+    const rawSummary = await readFile(summaryAbsolutePath, "utf8");
+    const commitSubject = normalizeCommitSubject(rawSummary);
+    if (!commitSubject) {
+        throw new ApplyAgentSummaryEmptyError(summaryDisplayPath);
+    }
+    try {
+        await runGitCommand(["add", "-A"], { cwd: root });
+        await runGitCommand(["commit", "-m", commitSubject], { cwd: root });
+        return await runGitCommand(["rev-parse", "HEAD"], { cwd: root });
+    }
+    catch (error) {
+        const detail = getGitStderr(error) ?? toErrorMessage(error);
+        throw new ApplyGitCommitError(detail);
+    }
+}
+function normalizeCommitSubject(summary) {
+    const normalized = summary.trim().replace(/\s+/gu, " ");
+    return normalized.length > 0 ? normalized : "";
+}

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

@@ -23,6 +23,22 @@ export declare class ApplyAgentDiffMissingOnDiskError extends ApplyError {
     readonly diffPath: string;
     constructor(diffPath: string);
 }
+export declare class ApplyAgentSummaryNotRecordedError extends ApplyError {
+    readonly runId: string;
+    readonly agentId: string;
+    constructor(runId: string, agentId: string);
+}
+export declare class ApplyAgentSummaryMissingOnDiskError extends ApplyError {
+    readonly summaryPath: string;
+    constructor(summaryPath: string);
+}
+export declare class ApplyAgentSummaryEmptyError extends ApplyError {
+    readonly summaryPath: string;
+    constructor(summaryPath: string);
+}
+export declare class ApplyGitCommitError extends ApplyError {
+    constructor(detail: string);
+}
 export interface ApplyBaseMismatchOptions {
     baseRevisionSha: string;
     headRevision: string;

package/dist/commands/apply/errors.js

@@ -53,6 +53,42 @@ export class ApplyAgentDiffMissingOnDiskError extends ApplyError {
         this.name = "ApplyAgentDiffMissingOnDiskError";
     }
 }
+export class ApplyAgentSummaryNotRecordedError extends ApplyError {
+    runId;
+    agentId;
+    constructor(runId, agentId) {
+        super(`Agent ${agentId} did not record a summary for run ${runId}.`, ["A summary artifact is required for `voratiq apply --commit`."], [
+            "Re-run the spec to regenerate artifacts or apply without `--commit` and commit manually.",
+        ]);
+        this.runId = runId;
+        this.agentId = agentId;
+        this.name = "ApplyAgentSummaryNotRecordedError";
+    }
+}
+export class ApplyAgentSummaryMissingOnDiskError extends ApplyError {
+    summaryPath;
+    constructor(summaryPath) {
+        super("Recorded summary is missing from disk.", [`Expected summary at ${summaryPath} but it was not found.`], ["Ensure the run directory still exists or re-run the agents."]);
+        this.summaryPath = summaryPath;
+        this.name = "ApplyAgentSummaryMissingOnDiskError";
+    }
+}
+export class ApplyAgentSummaryEmptyError extends ApplyError {
+    summaryPath;
+    constructor(summaryPath) {
+        super("Recorded summary is empty.", [`Expected summary at ${summaryPath} to contain a commit subject.`], [
+            "Re-run the spec to regenerate artifacts or apply without `--commit` and commit manually.",
+        ]);
+        this.summaryPath = summaryPath;
+        this.name = "ApplyAgentSummaryEmptyError";
+    }
+}
+export class ApplyGitCommitError extends ApplyError {
+    constructor(detail) {
+        super("Failed to create git commit.", [detail], ["The diff remains applied; resolve the issue and commit manually."]);
+        this.name = "ApplyGitCommitError";
+    }
+}
 export class ApplyBaseMismatchError extends ApplyError {
     constructor(options) {
         const { baseRevisionSha, headRevision } = options;

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

@@ -10,4 +10,5 @@ export interface ApplyResult {
     agent: AgentInvocationRecord;
     diffPath: string;
     ignoredBaseMismatch: boolean;
+    appliedCommitSha?: string;
 }

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

@@ -1,2 +1,3 @@
-import type { PruneCommandInput, PruneResult } from "./types.js";
+import type { PruneAllCommandInput, PruneAllResult, PruneCommandInput, PruneResult } from "./types.js";
 export declare function executePruneCommand(input: PruneCommandInput): Promise<PruneResult>;
+export declare function executePruneAllCommand(input: PruneAllCommandInput): Promise<PruneAllResult>;

package/dist/commands/prune/command.js

@@ -1,8 +1,8 @@
 import * as fs from "node:fs/promises";
 import { NonInteractiveShellError } from "../../cli/errors.js";
-import { buildPruneConfirmationPreface } from "../../render/transcripts/prune.js";
+import { buildPruneAllConfirmationPreface, buildPruneConfirmationPreface, } from "../../render/transcripts/prune.js";
 import { RunRecordNotFoundError, RunRecordParseError, } from "../../runs/records/errors.js";
-import { rewriteRunRecord, RUN_RECORD_FILENAME, } from "../../runs/records/persistence.js";
+import { fetchRunsSafely, rewriteRunRecord, RUN_RECORD_FILENAME, } from "../../runs/records/persistence.js";
 import { toErrorMessage } from "../../utils/errors.js";
 import { pathExists } from "../../utils/fs.js";
 import { getGitStderr, runGitCommand } from "../../utils/git.js";
@@ -103,6 +103,52 @@ export async function executePruneCommand(input) {
         branches: branchSummary,
     };
 }
+export async function executePruneAllCommand(input) {
+    const { root, runsFilePath, confirm, clock, purge: purgeInput } = input;
+    const purge = purgeInput ?? false;
+    if (!confirm) {
+        throw new NonInteractiveShellError();
+    }
+    if (!(await pathExists(runsFilePath))) {
+        return { status: "noop", runIds: [] };
+    }
+    const { records, warnings } = await fetchRunsSafely({
+        root,
+        runsFilePath,
+    });
+    const firstWarning = warnings[0];
+    if (firstWarning) {
+        if (firstWarning.kind === "parse-error") {
+            throw new RunRecordParseError(firstWarning.displayPath, firstWarning.details);
+        }
+        throw new RunMetadataMissingError(firstWarning.runId);
+    }
+    if (records.length === 0) {
+        return { status: "noop", runIds: [] };
+    }
+    const eligibleRuns = sortRunRecordsByCreatedAt(records);
+    const runIds = eligibleRuns.map((record) => record.runId);
+    const confirmationAccepted = await confirm({
+        message: "Proceed?",
+        defaultValue: false,
+        prefaceLines: buildPruneAllConfirmationPreface({
+            records: eligibleRuns,
+        }),
+    });
+    if (!confirmationAccepted) {
+        return { status: "aborted", runIds };
+    }
+    for (const runId of runIds) {
+        await executePruneCommand({
+            ...input,
+            runId,
+            confirm: () => Promise.resolve(true),
+            purge,
+            clock,
+        });
+    }
+    return { status: "pruned", runIds };
+}
 function buildAgentDirectoryDisplayPaths(options) {
     const { runRecord } = options;
     const unique = new Set();
@@ -311,6 +357,16 @@ async function branchExists(root, branch) {
     });
     return output.length > 0;
 }
+function sortRunRecordsByCreatedAt(records) {
+    return Array.from(records).sort((a, b) => {
+        const aTimestamp = Date.parse(a.createdAt);
+        const bTimestamp = Date.parse(b.createdAt);
+        if (Number.isNaN(aTimestamp) || Number.isNaN(bTimestamp)) {
+            return a.createdAt.localeCompare(b.createdAt);
+        }
+        return aTimestamp - bTimestamp;
+    });
+}
 async function rewriteHistory(options) {
     const { root, runsFilePath, runId, deletedAt } = options;
     try {

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

@@ -9,6 +9,14 @@ export interface PruneCommandInput {
     purge?: boolean;
     clock?: () => Date;
 }
+export interface PruneAllCommandInput {
+    root: string;
+    runsDir: string;
+    runsFilePath: string;
+    confirm: PruneConfirmationHandler;
+    purge?: boolean;
+    clock?: () => Date;
+}
 export interface PruneBranchSummary {
     deleted: string[];
     skipped: string[];
@@ -40,3 +48,16 @@ export interface PruneAbortedResult {
     runPath: string;
 }
 export type PruneResult = PruneSuccessResult | PruneAbortedResult;
+export interface PruneAllSuccessResult {
+    status: "pruned";
+    runIds: string[];
+}
+export interface PruneAllNoopResult {
+    status: "noop";
+    runIds: string[];
+}
+export interface PruneAllAbortedResult {
+    status: "aborted";
+    runIds: string[];
+}
+export type PruneAllResult = PruneAllSuccessResult | PruneAllNoopResult | PruneAllAbortedResult;

package/dist/commands/run/agents/run-context.js

@@ -83,26 +83,9 @@ export class AgentRunContext {
             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";
-        }
+        // Evals are quality signals, not execution outcomes.
+        // Agent status depends only on execution results (process exit code, etc.),
+        // not on eval failures. Eval results are tracked and exposed separately.
     }
     markChatArtifact(format) {
         this.artifactState.chatCaptured = true;

package/dist/commands/run/command.js

@@ -90,7 +90,7 @@ export async function executeRunCommand(input) {
             mutators,
         });
         agentRecords = executionResult.agentRecords;
-        const derivedRunStatus = executionResult.hadAgentFailure || executionResult.hadEvalFailure
+        const derivedRunStatus = executionResult.hadAgentFailure
             ? "failed"
             : executionResult.agentReports.some((report) => report.status === "errored")
                 ? "errored"

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

@@ -1,4 +1,5 @@
 import type { RunStatus } from "../../status/index.js";
+import { TERMINABLE_RUN_STATUSES } from "../../status/index.js";
 export declare const RUN_ABORT_WARNING = "Run aborted before agent completed.";
 interface ActiveRunContext {
     root: string;
@@ -11,9 +12,8 @@ interface ActiveRunAgentContext {
     providerId?: string;
     agentRoot: string;
 }
-declare const TERMINABLE_STATUSES: readonly ["failed", "aborted"];
 export declare function registerActiveRun(context: ActiveRunContext): void;
 export declare function clearActiveRun(runId: string): void;
 export declare function getActiveTerminationStatus(runId: string): RunStatus | undefined;
-export declare function terminateActiveRun(status: Extract<RunStatus, (typeof TERMINABLE_STATUSES)[number]>): Promise<void>;
+export declare function terminateActiveRun(status: Extract<RunStatus, (typeof TERMINABLE_RUN_STATUSES)[number]>): Promise<void>;
 export {};