agentv 4.40.1-next.1 → 4.41.0-next.1

package/dist/{chunk-S2JJCLHV.js → chunk-6FXICR66.js}

@@ -25,6 +25,7 @@ import {
   isRemoteRunId,
   listMergedResultFiles,
   listResultFiles,
+  loadEnvFromHierarchy,
   loadLightweightResults,
   loadManifestResults,
   loadResultFile,
@@ -41,6 +42,7 @@ import {
   resolveRunCacheFile,
   resolveRunManifestPath,
   runEvalCommand,
+  selectMultipleTargets,
   selectTarget,
   setRemoteRunTags,
   syncRemoteResults,
@@ -52,11 +54,11 @@ import {
   validateTargetsFile,
   validateWorkspacePaths,
   writeRunTags
-} from "./chunk-WKA5QDNQ.js";
+} from "./chunk-CF5RCUWH.js";
 import {
   toSnakeCaseDeep as toSnakeCaseDeep2,
-  writeArtifactsFromResults
-} from "./chunk-TWQP7JYQ.js";
+  writeArtifactsFromResults as writeArtifactsFromResults2
+} from "./chunk-A4J456KS.js";
 import {
   DEFAULT_CATEGORY,
   deriveCategory,
@@ -65,12 +67,13 @@ import {
   getOutputFilenames,
   parseClaudeSession,
   parseCodexSession,
+  prepareEvalWorkspace,
   runBeforeSessionHook,
   scanRepoDeps,
   syncProjects,
   transpileEvalYamlFile,
   trimBaselineResult
-} from "./chunk-I3SC4FOT.js";
+} from "./chunk-Z45FKRMJ.js";
 import {
   DEFAULT_THRESHOLD,
   addProject,
@@ -85,6 +88,7 @@ import {
   getAgentvConfigDir,
   getProject,
   getWorkspacePoolRoot,
+  gradePreparedEvalCase,
   isAgentSkillsFormat,
   listTargetNames,
   loadConfig,
@@ -112,8 +116,9 @@ import {
   toCamelCaseDeep,
   toSnakeCaseDeep,
   toTranscriptJsonLines,
-  touchProject
-} from "./chunk-BLXYBUU4.js";
+  touchProject,
+  writeArtifactsFromResults
+} from "./chunk-ENHX2CCS.js";
 import {
   __commonJS,
   __require,
@@ -874,7 +879,7 @@ var require_src = __commonJS({
 });
 
 // src/index.ts
-import path32 from "node:path";
+import path34 from "node:path";
 
 // ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -4597,7 +4602,7 @@ var evalRunCommand = command({
   },
   handler: async (args) => {
     if (args.evalPaths.length === 0 && process.stdin.isTTY) {
-      const { launchInteractiveWizard } = await import("./interactive-OUB3GZRC.js");
+      const { launchInteractiveWizard } = await import("./interactive-4JKJTY3G.js");
       await launchInteractiveWizard();
       return;
     }
@@ -4684,9 +4689,351 @@ var evalCommand = subcommands({
   }
 });
 
+// src/commands/grade/index.ts
+import { readFile, stat } from "node:fs/promises";
+import path7 from "node:path";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function invalidManifest(manifestPath, message) {
+  return new Error(`Invalid prepared manifest at ${manifestPath}: ${message}`);
+}
+function expectString(record, key, manifestPath) {
+  const value = record[key];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw invalidManifest(manifestPath, `missing non-empty string field '${key}'`);
+  }
+  return value;
+}
+function expectArray(record, key, manifestPath) {
+  const value = record[key];
+  if (!Array.isArray(value)) {
+    throw invalidManifest(manifestPath, `missing array field '${key}'`);
+  }
+  return value;
+}
+function expectBaseline(value, manifestPath) {
+  if (!isRecord(value)) {
+    throw invalidManifest(manifestPath, "missing object field 'baseline'");
+  }
+  const status = value.status;
+  if (status !== "initialized" && status !== "unavailable") {
+    throw invalidManifest(
+      manifestPath,
+      "field 'baseline.status' must be 'initialized' or 'unavailable'"
+    );
+  }
+  const commit = value.commit;
+  if (commit !== void 0 && typeof commit !== "string") {
+    throw invalidManifest(manifestPath, "field 'baseline.commit' must be a string");
+  }
+  if (status === "initialized" && (!commit || commit.trim().length === 0)) {
+    throw invalidManifest(
+      manifestPath,
+      "field 'baseline.commit' is required when baseline.status is 'initialized'"
+    );
+  }
+  return {
+    status,
+    ...typeof commit === "string" && commit.trim().length > 0 && { commit }
+  };
+}
+function fromManifestWire(value, manifestPath) {
+  if (!isRecord(value)) {
+    throw invalidManifest(manifestPath, "expected a JSON object");
+  }
+  if (value.schema_version !== 1) {
+    throw invalidManifest(manifestPath, "field 'schema_version' must be 1");
+  }
+  const setupStatus = value.setup_status;
+  if (setupStatus !== "ok") {
+    throw invalidManifest(manifestPath, "field 'setup_status' must be 'ok'");
+  }
+  const preparedDir = path7.dirname(manifestPath);
+  const resolveManifestPath = (rawPath) => path7.isAbsolute(rawPath) ? rawPath : path7.resolve(preparedDir, rawPath);
+  return {
+    schemaVersion: 1,
+    evalPath: resolveManifestPath(expectString(value, "eval_path", manifestPath)),
+    testId: expectString(value, "test_id", manifestPath),
+    target: expectString(value, "target", manifestPath),
+    workspacePath: resolveManifestPath(expectString(value, "workspace_path", manifestPath)),
+    promptPath: resolveManifestPath(expectString(value, "prompt_path", manifestPath)),
+    setupStatus,
+    setupSteps: expectArray(value, "setup_steps", manifestPath),
+    repoPins: expectArray(value, "repo_pins", manifestPath),
+    baseline: expectBaseline(value.baseline, manifestPath),
+    createdAt: expectString(value, "created_at", manifestPath),
+    manifestPath,
+    preparedDir
+  };
+}
+async function resolvePreparedManifestPath(preparedPath) {
+  const resolved = path7.resolve(preparedPath);
+  try {
+    const stats = await stat(resolved);
+    return stats.isDirectory() ? path7.join(resolved, "agentv_prepare.json") : resolved;
+  } catch {
+    return path7.basename(resolved) === "agentv_prepare.json" ? resolved : path7.join(resolved, "agentv_prepare.json");
+  }
+}
+async function readPreparedManifest(preparedPath) {
+  const manifestPath = await resolvePreparedManifestPath(preparedPath);
+  let raw;
+  try {
+    raw = await readFile(manifestPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(
+        `Prepared manifest not found at ${manifestPath}. Run agentv prepare first and pass --prepared <dir>.`
+      );
+    }
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid prepared manifest JSON at ${manifestPath}: ${message}`);
+  }
+  return fromManifestWire(parsed, manifestPath);
+}
+async function ensureDirectoryExists(dirPath, description) {
+  try {
+    const stats = await stat(dirPath);
+    if (!stats.isDirectory()) {
+      throw new Error(`${description} is not a directory: ${dirPath}`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`${description} not found: ${dirPath}`);
+    }
+    throw error;
+  }
+}
+async function ensureFileExists(filePath, description) {
+  try {
+    const stats = await stat(filePath);
+    if (!stats.isFile()) {
+      throw new Error(`${description} is not a file: ${filePath}`);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`${description} not found: ${filePath}`);
+    }
+    throw error;
+  }
+}
+function assertMatchesManifest(options) {
+  const commandEvalPath = path7.resolve(options.evalPath);
+  if (path7.resolve(options.manifest.evalPath) !== commandEvalPath) {
+    throw new Error(
+      `Prepared manifest eval_path does not match command eval path: ${options.manifest.evalPath} !== ${commandEvalPath}`
+    );
+  }
+  if (options.testId && options.testId !== options.manifest.testId) {
+    throw new Error(
+      `Prepared manifest test_id '${options.manifest.testId}' does not match --test-id '${options.testId}'`
+    );
+  }
+  return options.testId ?? options.manifest.testId;
+}
+function toPreparedAttemptMetadata(manifest) {
+  return {
+    source: "manual",
+    manifestPath: manifest.manifestPath,
+    preparedDir: manifest.preparedDir,
+    workspacePath: manifest.workspacePath,
+    promptPath: manifest.promptPath,
+    target: manifest.target,
+    preparedAt: manifest.createdAt,
+    setupStatus: manifest.setupStatus,
+    baselineStatus: manifest.baseline.status,
+    ...manifest.baseline.commit !== void 0 && { baselineCommit: manifest.baseline.commit }
+  };
+}
+function toCommandOutputWire(result) {
+  return {
+    test_id: result.testId,
+    target: result.target,
+    score: result.score,
+    execution_status: result.executionStatus,
+    workspace_path: result.workspacePath,
+    manifest_path: result.manifestPath,
+    output_dir: result.outputDir,
+    index_path: result.indexPath
+  };
+}
+function printHumanOutput(result) {
+  console.log(`Graded prepared attempt for ${result.testId} (${result.target})`);
+  console.log(`Score: ${result.score.toFixed(3)} (${result.executionStatus})`);
+  console.log(`Workspace: ${result.workspacePath}`);
+  console.log(`Manifest: ${result.manifestPath}`);
+  console.log(`Artifact workspace: ${result.outputDir}`);
+  console.log(`Index: ${result.indexPath}`);
+}
+async function gradePreparedAttempt(options) {
+  const manifest = await readPreparedManifest(options.preparedPath);
+  const evalPath = path7.resolve(options.evalPath);
+  const testId = assertMatchesManifest({ manifest, evalPath, testId: options.testId });
+  await ensureDirectoryExists(manifest.workspacePath, "Prepared workspace");
+  await ensureFileExists(manifest.promptPath, "Prepared prompt");
+  const evalDir = path7.dirname(evalPath);
+  const repoRoot = await findRepoRoot(evalDir);
+  await loadEnvFromHierarchy({ testFilePath: evalPath, repoRoot, verbose: !!options.verbose });
+  const category = deriveCategory(path7.relative(process.cwd(), evalPath));
+  const suite = await loadTestSuite(evalPath, repoRoot, { category });
+  const test = suite.tests.find((candidate) => candidate.id === testId);
+  if (!test) {
+    throw new Error(`Test ID '${testId}' not found in ${evalPath}`);
+  }
+  const selections = await selectMultipleTargets({
+    testFilePath: evalPath,
+    repoRoot,
+    cwd: process.cwd(),
+    dryRun: false,
+    dryRunDelay: 0,
+    dryRunDelayMin: 0,
+    dryRunDelayMax: 0,
+    env: process.env,
+    targetNames: [manifest.target],
+    targetRefs: suite.targetRefs
+  });
+  const selection = selections[0];
+  if (!selection) {
+    throw new Error(`Target '${manifest.target}' could not be resolved`);
+  }
+  const target = {
+    ...selection.resolvedTarget,
+    name: manifest.target
+  };
+  const response = options.responsePath !== void 0 ? await readFile(path7.resolve(options.responsePath), "utf8") : void 0;
+  const runDir = path7.resolve(
+    options.outputDir ?? buildDefaultRunDir(process.cwd(), options.experiment)
+  );
+  const result = await gradePreparedEvalCase({
+    evalCase: test,
+    target,
+    targets: selection.definitions,
+    env: process.env,
+    evalFilePath: evalPath,
+    workspacePath: manifest.workspacePath,
+    baselineCommit: manifest.baseline.commit,
+    response,
+    verbose: options.verbose,
+    graderTarget: options.graderTarget,
+    model: options.model,
+    threshold: options.threshold ?? suite.threshold,
+    preparedAttempt: toPreparedAttemptMetadata(manifest)
+  });
+  const artifacts = await writeArtifactsFromResults([result], runDir, {
+    evalFile: evalPath,
+    experiment: options.experiment,
+    plannedTestCount: 1,
+    sourceTests: [test]
+  });
+  return {
+    testId,
+    target: manifest.target,
+    score: result.score,
+    executionStatus: result.executionStatus,
+    workspacePath: manifest.workspacePath,
+    manifestPath: manifest.manifestPath,
+    outputDir: runDir,
+    indexPath: artifacts.indexPath
+  };
+}
+var gradeCommand = command({
+  name: "grade",
+  description: "Grade a prepared workspace attempt without running the target provider",
+  args: {
+    evalPath: positional({
+      type: string,
+      displayName: "eval",
+      description: "Path to an eval file"
+    }),
+    testId: option({
+      type: optional(string),
+      long: "test-id",
+      description: "Exact test ID to grade; defaults to agentv_prepare.json test_id"
+    }),
+    prepared: option({
+      type: string,
+      long: "prepared",
+      description: "Prepared-attempt directory or agentv_prepare.json path"
+    }),
+    output: option({
+      type: optional(string),
+      long: "output",
+      short: "o",
+      description: "Run artifact directory (writes index.jsonl and per-test artifacts)"
+    }),
+    response: option({
+      type: optional(string),
+      long: "response",
+      description: "Optional final response text file from the human or external agent"
+    }),
+    experiment: option({
+      type: optional(string),
+      long: "experiment",
+      description: "Experiment label for canonical run output (default: default)"
+    }),
+    graderTarget: option({
+      type: optional(string),
+      long: "grader-target",
+      description: 'Override grader target for all evaluators (e.g., "agentv", or a target name from targets.yaml)'
+    }),
+    model: option({
+      type: optional(string),
+      long: "model",
+      description: 'Override model for the grader target (e.g., "openai:gpt-5-mini")'
+    }),
+    threshold: option({
+      type: optional(number),
+      long: "threshold",
+      description: "Per-test score threshold (0-1, default 0.8 or suite threshold)"
+    }),
+    format: option({
+      type: optional(oneOf(["text", "json"])),
+      long: "format",
+      description: "Output format: text (default) or json"
+    })
+  },
+  handler: async ({
+    evalPath,
+    testId,
+    prepared,
+    output,
+    response,
+    experiment,
+    graderTarget,
+    model,
+    threshold,
+    format
+  }) => {
+    const result = await gradePreparedAttempt({
+      evalPath,
+      testId,
+      preparedPath: prepared,
+      outputDir: output,
+      responsePath: response,
+      experiment,
+      graderTarget,
+      model,
+      threshold,
+      verbose: false
+    });
+    if (format === "json") {
+      console.log(JSON.stringify(toCommandOutputWire(result), null, 2));
+      return;
+    }
+    printHumanOutput(result);
+  }
+});
+
 // src/commands/import/claude.ts
 import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 var importClaudeCommand = command({
   name: "claude",
   description: "Import a Claude Code session transcript for offline grading",
@@ -4758,8 +5105,8 @@ var importClaudeCommand = command({
     const rawJsonl = await readTranscriptFile(sessionFilePath);
     const transcript = parseClaudeSession(rawJsonl);
     const shortId = (sessionId ?? transcript.source.sessionId).slice(0, 8);
-    const outputPath = output ?? path7.join(".agentv", "transcripts", `claude-${shortId}.jsonl`);
-    await mkdir3(path7.dirname(outputPath), { recursive: true });
+    const outputPath = output ?? path8.join(".agentv", "transcripts", `claude-${shortId}.jsonl`);
+    await mkdir3(path8.dirname(outputPath), { recursive: true });
     const jsonLines = toTranscriptJsonLines(transcript);
     await writeFile3(
       outputPath,
@@ -4803,7 +5150,7 @@ function formatDurationMs(ms) {
 
 // src/commands/import/codex.ts
 import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 var importCodexCommand = command({
   name: "codex",
   description: "Import a Codex CLI session transcript for offline grading",
@@ -4875,8 +5222,8 @@ var importCodexCommand = command({
     const rawJsonl = await readTranscriptFile(session.filePath);
     const transcript = parseCodexSession(rawJsonl);
     const shortId = session.sessionId.slice(0, 8);
-    const outputPath = output ?? path8.join(".agentv", "transcripts", `codex-${shortId}.jsonl`);
-    await mkdir4(path8.dirname(outputPath), { recursive: true });
+    const outputPath = output ?? path9.join(".agentv", "transcripts", `codex-${shortId}.jsonl`);
+    await mkdir4(path9.dirname(outputPath), { recursive: true });
     const jsonLines = toTranscriptJsonLines(transcript);
     await writeFile4(
       outputPath,
@@ -4914,8 +5261,8 @@ function formatDurationMs2(ms) {
 }
 
 // src/commands/import/copilot.ts
-import { mkdir as mkdir5, readFile, writeFile as writeFile5 } from "node:fs/promises";
-import path9 from "node:path";
+import { mkdir as mkdir5, readFile as readFile2, writeFile as writeFile5 } from "node:fs/promises";
+import path10 from "node:path";
 var importCopilotCommand = command({
   name: "copilot",
   description: "Import a Copilot CLI session transcript for offline grading",
@@ -4980,8 +5327,8 @@ var importCopilotCommand = command({
       );
       process.exit(1);
     }
-    const eventsPath = path9.join(sessionDir, "events.jsonl");
-    const rawJsonl = await readFile(eventsPath, "utf8");
+    const eventsPath = path10.join(sessionDir, "events.jsonl");
+    const rawJsonl = await readFile2(eventsPath, "utf8");
     const parsed = parseCopilotEvents(rawJsonl);
     const transcript = {
       messages: parsed.messages,
@@ -4997,8 +5344,8 @@ var importCopilotCommand = command({
       costUsd: null
     };
     const shortId = resolvedSessionId.slice(0, 8);
-    const outputPath = output ?? path9.join(".agentv", "transcripts", `copilot-${shortId}.jsonl`);
-    await mkdir5(path9.dirname(outputPath), { recursive: true });
+    const outputPath = output ?? path10.join(".agentv", "transcripts", `copilot-${shortId}.jsonl`);
+    await mkdir5(path10.dirname(outputPath), { recursive: true });
     const jsonLines = toTranscriptJsonLines(transcript);
     await writeFile5(
       outputPath,
@@ -5043,12 +5390,12 @@ function formatDurationMs3(ms) {
 // src/commands/import/huggingface.ts
 import { execFile } from "node:child_process";
 import { existsSync as existsSync2 } from "node:fs";
-import path10 from "node:path";
+import path11 from "node:path";
 function findScript() {
   const candidates = [
-    path10.resolve(__dirname, "..", "..", "..", "..", "..", "scripts", "import-huggingface.py"),
-    path10.resolve(__dirname, "..", "..", "..", "..", "scripts", "import-huggingface.py"),
-    path10.resolve(process.cwd(), "scripts", "import-huggingface.py")
+    path11.resolve(__dirname, "..", "..", "..", "..", "..", "scripts", "import-huggingface.py"),
+    path11.resolve(__dirname, "..", "..", "..", "..", "scripts", "import-huggingface.py"),
+    path11.resolve(process.cwd(), "scripts", "import-huggingface.py")
   ];
   for (const candidate of candidates) {
     if (existsSync2(candidate)) return candidate;
@@ -5147,18 +5494,18 @@ Imported ${summary.files_created} eval(s) from ${summary.dataset} \u2192 ${summa
 });
 
 // src/commands/import/promptfoo.ts
-import { mkdir as mkdir6, readFile as readFile2, writeFile as writeFile6 } from "node:fs/promises";
-import path11 from "node:path";
+import { mkdir as mkdir6, readFile as readFile3, writeFile as writeFile6 } from "node:fs/promises";
+import path12 from "node:path";
 import fg2 from "fast-glob";
 import JSON5 from "json5";
 import { parse as parseYaml, stringify as stringifyYaml2 } from "yaml";
 var FILE_PREFIX = "file://";
 var PROMPTFOO_COMMENT_PREFIX = "# Converted from promptfoo config: ";
 async function convertPromptfooToAgentvSuite(options) {
-  const absoluteInputPath = path11.resolve(options.inputPath);
-  const configDir = path11.dirname(absoluteInputPath);
+  const absoluteInputPath = path12.resolve(options.inputPath);
+  const configDir = path12.dirname(absoluteInputPath);
   const rawConfig = await loadPromptfooConfig(absoluteInputPath);
-  const suiteName = sanitizeName(path11.basename(absoluteInputPath, path11.extname(absoluteInputPath)));
+  const suiteName = sanitizeName(path12.basename(absoluteInputPath, path12.extname(absoluteInputPath)));
   const prompts = await loadPromptfooPrompts(rawConfig.prompts, configDir);
   if (prompts.length === 0) {
     throw new Error(`promptfoo import requires at least one prompt in ${absoluteInputPath}`);
@@ -5199,7 +5546,7 @@ async function convertPromptfooToAgentvYaml(inputPath) {
     indent: 2,
     lineWidth: 0
   });
-  return `${PROMPTFOO_COMMENT_PREFIX}${path11.resolve(inputPath)}
+  return `${PROMPTFOO_COMMENT_PREFIX}${path12.resolve(inputPath)}
 ${yaml}`;
 }
 var importPromptfooCommand = command({
@@ -5223,20 +5570,20 @@ var importPromptfooCommand = command({
     })
   },
   handler: async ({ input, output, dryRun: dryRun2 }) => {
-    const absoluteInput = path11.resolve(input);
+    const absoluteInput = path12.resolve(input);
     const yaml = await convertPromptfooToAgentvYaml(absoluteInput);
     if (dryRun2) {
       process.stdout.write(yaml);
       return;
     }
-    const outputPath = path11.resolve(output ?? path11.join(path11.dirname(absoluteInput), "EVAL.yaml"));
-    await mkdir6(path11.dirname(outputPath), { recursive: true });
+    const outputPath = path12.resolve(output ?? path12.join(path12.dirname(absoluteInput), "EVAL.yaml"));
+    await mkdir6(path12.dirname(outputPath), { recursive: true });
     await writeFile6(outputPath, yaml, "utf8");
     console.log(`Imported promptfoo config \u2192 ${outputPath}`);
   }
 });
 async function loadPromptfooConfig(filePath) {
-  const content = await readFile2(filePath, "utf8");
+  const content = await readFile3(filePath, "utf8");
   const parsed = parseStructuredText(content, filePath);
   if (!isJsonObject(parsed)) {
     throw new Error(`promptfoo config must be an object: ${filePath}`);
@@ -5244,7 +5591,7 @@ async function loadPromptfooConfig(filePath) {
   return parsed;
 }
 function parseStructuredText(content, filePath) {
-  const ext = path11.extname(filePath).toLowerCase();
+  const ext = path12.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".json5" || ext === ".jsonc") {
     return JSON5.parse(content);
   }
@@ -5318,8 +5665,8 @@ async function loadPromptFromReference(reference, baseDir, identity2) {
   const prompts = [];
   for (let index = 0; index < files.length; index++) {
     const filePath = files[index];
-    const ext = path11.extname(filePath).toLowerCase();
-    const raw = await readFile2(filePath, "utf8");
+    const ext = path12.extname(filePath).toLowerCase();
+    const raw = await readFile3(filePath, "utf8");
     if (ext === ".json" || ext === ".json5" || ext === ".jsonc") {
       const parsed = parseStructuredText(raw, filePath);
       if (!Array.isArray(parsed) || !parsed.every(isPromptMessage)) {
@@ -5373,7 +5720,7 @@ async function expandProviderEntry(rawProvider, baseDir) {
       const files = await resolvePromptfooFileReference(rawProvider, baseDir);
       const providers = [];
       for (const filePath of files) {
-        const parsed = parseStructuredText(await readFile2(filePath, "utf8"), filePath);
+        const parsed = parseStructuredText(await readFile3(filePath, "utf8"), filePath);
         if (!isJsonObject(parsed)) {
           throw new Error(`Provider file must be an object: ${filePath}`);
         }
@@ -5412,7 +5759,7 @@ async function loadDefaultTest(rawDefaultTest, baseDir) {
     if (files.length !== 1) {
       throw new Error(`defaultTest must resolve to exactly one file: ${rawDefaultTest}`);
     }
-    const parsed = parseStructuredText(await readFile2(files[0], "utf8"), files[0]);
+    const parsed = parseStructuredText(await readFile3(files[0], "utf8"), files[0]);
     if (!isJsonObject(parsed)) {
       throw new Error(`defaultTest file must contain an object: ${files[0]}`);
     }
@@ -5461,13 +5808,13 @@ async function loadPromptfooTestsFromReference(reference, baseDir) {
   const files = await resolvePromptfooFileReference(reference, baseDir);
   const tests = [];
   for (const filePath of files) {
-    const ext = path11.extname(stripSheetSuffix(filePath)).toLowerCase();
+    const ext = path12.extname(stripSheetSuffix(filePath)).toLowerCase();
     if (ext === ".xlsx" || ext === ".xls") {
       throw new Error(
-        `Unsupported test dataset '${path11.basename(filePath)}': XLSX promptfoo datasets are not imported yet`
+        `Unsupported test dataset '${path12.basename(filePath)}': XLSX promptfoo datasets are not imported yet`
       );
     }
-    const content = await readFile2(filePath, "utf8");
+    const content = await readFile3(filePath, "utf8");
     if (ext === ".csv") {
       tests.push(...parseCsvPromptfooTests(content, filePath));
       continue;
@@ -6062,7 +6409,7 @@ function normalizeAssertionType(rawType) {
 async function resolvePromptfooFileReference(reference, baseDir) {
   const rawPath = reference.slice(FILE_PREFIX.length);
   const [pathWithoutSheet] = rawPath.split("#");
-  const absolutePath = path11.resolve(baseDir, pathWithoutSheet);
+  const absolutePath = path12.resolve(baseDir, pathWithoutSheet);
   const normalizedPattern = absolutePath.replaceAll("\\", "/");
   const matches = await fg2(normalizedPattern, {
     onlyFiles: true,
@@ -6155,29 +6502,29 @@ var importCommand = subcommands({
 
 // src/commands/init/index.ts
 import { existsSync as existsSync3, mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 import * as readline from "node:readline/promises";
 
 // src/templates/index.ts
 import { readFileSync as readFileSync3, readdirSync, statSync } from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
 import { fileURLToPath } from "node:url";
 function getAgentvTemplates() {
   return getTemplatesFromDir(".agentv");
 }
 function getEnvExampleTemplate() {
-  const currentDir = path12.dirname(fileURLToPath(import.meta.url));
-  const templatesBase = currentDir.includes(`${path12.sep}dist`) ? path12.join(currentDir, "templates") : currentDir;
-  const content = readFileSync3(path12.join(templatesBase, ".env.example"), "utf-8");
+  const currentDir = path13.dirname(fileURLToPath(import.meta.url));
+  const templatesBase = currentDir.includes(`${path13.sep}dist`) ? path13.join(currentDir, "templates") : currentDir;
+  const content = readFileSync3(path13.join(templatesBase, ".env.example"), "utf-8");
   return { path: ".env.example", content };
 }
 function getTemplatesFromDir(subdir) {
-  const currentDir = path12.dirname(fileURLToPath(import.meta.url));
+  const currentDir = path13.dirname(fileURLToPath(import.meta.url));
   let templatesDir;
-  if (currentDir.includes(`${path12.sep}dist`)) {
-    templatesDir = path12.join(currentDir, "templates", subdir);
+  if (currentDir.includes(`${path13.sep}dist`)) {
+    templatesDir = path13.join(currentDir, "templates", subdir);
   } else {
-    templatesDir = path12.join(currentDir, subdir);
+    templatesDir = path13.join(currentDir, subdir);
   }
   return readTemplatesRecursively(templatesDir, "");
 }
@@ -6185,15 +6532,15 @@ function readTemplatesRecursively(dir, relativePath) {
   const templates = [];
   const entries2 = readdirSync(dir);
   for (const entry of entries2) {
-    const fullPath = path12.join(dir, entry);
-    const stat3 = statSync(fullPath);
-    const entryRelativePath = relativePath ? path12.join(relativePath, entry) : entry;
-    if (stat3.isDirectory()) {
+    const fullPath = path13.join(dir, entry);
+    const stat4 = statSync(fullPath);
+    const entryRelativePath = relativePath ? path13.join(relativePath, entry) : entry;
+    if (stat4.isDirectory()) {
       templates.push(...readTemplatesRecursively(fullPath, entryRelativePath));
     } else {
       const content = readFileSync3(fullPath, "utf-8");
       templates.push({
-        path: entryRelativePath.split(path12.sep).join("/"),
+        path: entryRelativePath.split(path13.sep).join("/"),
         // Normalize to forward slashes
         content
       });
@@ -6224,22 +6571,22 @@ async function promptYesNo(message) {
   }
 }
 async function initCommand(options = {}) {
-  const targetPath = path13.resolve(options.targetPath ?? ".");
-  const agentvDir = path13.join(targetPath, ".agentv");
+  const targetPath = path14.resolve(options.targetPath ?? ".");
+  const agentvDir = path14.join(targetPath, ".agentv");
   const otherAgentvTemplates = getAgentvTemplates();
   const envTemplate = getEnvExampleTemplate();
   const existingFiles = [];
   if (envTemplate) {
-    const envFilePath = path13.join(targetPath, ".env.example");
+    const envFilePath = path14.join(targetPath, ".env.example");
     if (existsSync3(envFilePath)) {
       existingFiles.push(".env.example");
     }
   }
   if (existsSync3(agentvDir)) {
     for (const template of otherAgentvTemplates) {
-      const targetFilePath = path13.join(agentvDir, template.path);
+      const targetFilePath = path14.join(agentvDir, template.path);
       if (existsSync3(targetFilePath)) {
-        existingFiles.push(path13.relative(targetPath, targetFilePath));
+        existingFiles.push(path14.relative(targetPath, targetFilePath));
       }
     }
   }
@@ -6261,18 +6608,18 @@ async function initCommand(options = {}) {
     mkdirSync(agentvDir, { recursive: true });
   }
   if (envTemplate) {
-    const envFilePath = path13.join(targetPath, ".env.example");
+    const envFilePath = path14.join(targetPath, ".env.example");
     writeFileSync2(envFilePath, envTemplate.content, "utf-8");
     console.log("Created .env.example");
   }
   for (const template of otherAgentvTemplates) {
-    const targetFilePath = path13.join(agentvDir, template.path);
-    const targetDirPath = path13.dirname(targetFilePath);
+    const targetFilePath = path14.join(agentvDir, template.path);
+    const targetDirPath = path14.dirname(targetFilePath);
     if (!existsSync3(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync2(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path13.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path14.relative(targetPath, targetFilePath)}`);
   }
   console.log("\nAgentV initialized successfully!");
   console.log("\nFiles installed to root:");
@@ -6280,7 +6627,7 @@ async function initCommand(options = {}) {
     console.log("  - .env.example");
   }
   console.log(`
-Files installed to ${path13.relative(targetPath, agentvDir)}:`);
+Files installed to ${path14.relative(targetPath, agentvDir)}:`);
   for (const t of otherAgentvTemplates) {
     console.log(`  - ${t.path}`);
   }
@@ -6312,13 +6659,13 @@ var initCmdTsCommand = command({
 
 // src/commands/inspect/filter.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 function collectIndexFiles(dir) {
   const files = [];
   try {
     const entries2 = readdirSync2(dir, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path14.join(dir, entry.name);
+      const fullPath = path15.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...collectIndexFiles(fullPath));
       } else if (entry.name === "index.jsonl") {
@@ -6371,7 +6718,7 @@ function parseFilterableRecords(filePath) {
     raw = normalizeResultRow(raw, { lineNumber: i + 1, sourceLabel: filePath });
     let experiment = typeof raw.experiment === "string" ? raw.experiment : void 0;
     if (!experiment) {
-      const parts = filePath.split(path14.sep);
+      const parts = filePath.split(path15.sep);
       const runsIdx = parts.indexOf("runs");
       if (runsIdx !== -1 && parts.length - runsIdx >= 3) {
         const candidate = parts[runsIdx + 1];
@@ -6426,7 +6773,7 @@ function buildFilterPredicate(opts) {
 }
 function discoverFilterSources(searchPath, cwd) {
   if (searchPath) {
-    const resolved = path14.isAbsolute(searchPath) ? searchPath : path14.resolve(cwd, searchPath);
+    const resolved = path15.isAbsolute(searchPath) ? searchPath : path15.resolve(cwd, searchPath);
     if (!existsSync4(resolved)) {
       console.error(`${c.red}Error:${c.reset} Path does not exist: ${resolved}`);
       process.exit(1);
@@ -6439,7 +6786,7 @@ function discoverFilterSources(searchPath, cwd) {
     }
     return [resolved];
   }
-  return collectIndexFiles(path14.join(cwd, ".agentv", "results", "runs"));
+  return collectIndexFiles(path15.join(cwd, ".agentv", "results", "runs"));
 }
 function formatFilterTable(records) {
   const lines = [];
@@ -6919,13 +7266,13 @@ var traceScoreCommand = command({
 
 // src/commands/inspect/search.ts
 import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 function collectJsonlFiles(dir) {
   const files = [];
   try {
     const entries2 = readdirSync3(dir, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path15.join(dir, entry.name);
+      const fullPath = path16.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...collectJsonlFiles(fullPath));
       } else if (entry.name.endsWith(".jsonl")) {
@@ -6984,7 +7331,7 @@ function searchJsonlFile(filePath, regex2, targetFilter, experimentFilter) {
 }
 function discoverSources(basePath, cwd) {
   if (basePath) {
-    const resolved = path15.isAbsolute(basePath) ? basePath : path15.resolve(cwd, basePath);
+    const resolved = path16.isAbsolute(basePath) ? basePath : path16.resolve(cwd, basePath);
     if (!existsSync5(resolved)) {
       console.error(`${c.red}Error:${c.reset} Path does not exist: ${resolved}`);
       process.exit(1);
@@ -6998,8 +7345,8 @@ function discoverSources(basePath, cwd) {
     return [resolved];
   }
   const sources = [];
-  sources.push(...collectJsonlFiles(path15.join(cwd, ".agentv", "results", "runs")));
-  sources.push(...collectJsonlFiles(path15.join(cwd, ".agentv", "transcripts")));
+  sources.push(...collectJsonlFiles(path16.join(cwd, ".agentv", "results", "runs")));
+  sources.push(...collectJsonlFiles(path16.join(cwd, ".agentv", "transcripts")));
   return sources;
 }
 function formatSearchResults(matches, pattern) {
@@ -7547,7 +7894,7 @@ var inspectCommand = subcommands({
 
 // src/commands/pipeline/bench.ts
 import { existsSync as existsSync6 } from "node:fs";
-import { readFile as readFile3, readdir, writeFile as writeFile7 } from "node:fs/promises";
+import { readFile as readFile4, readdir, writeFile as writeFile7 } from "node:fs/promises";
 import { join } from "node:path";
 var evalBenchCommand = command({
   name: "bench",
@@ -7560,7 +7907,7 @@ var evalBenchCommand = command({
     })
   },
   handler: async ({ exportDir }) => {
-    const manifest = JSON.parse(await readFile3(join(exportDir, "manifest.json"), "utf8"));
+    const manifest = JSON.parse(await readFile4(join(exportDir, "manifest.json"), "utf8"));
     const testIds = manifest.test_ids;
     const targetName2 = manifest.target?.name ?? "unknown";
     const suiteName = manifest.suite ?? "";
@@ -7578,7 +7925,7 @@ var evalBenchCommand = command({
       try {
         const resultFiles = (await readdir(codeResultsDir)).filter((f) => f.endsWith(".json"));
         for (const file of resultFiles) {
-          const result = JSON.parse(await readFile3(join(codeResultsDir, file), "utf8"));
+          const result = JSON.parse(await readFile4(join(codeResultsDir, file), "utf8"));
           evaluators.push({
             name: result.name,
             type: result.type ?? "code-grader",
@@ -7596,12 +7943,12 @@ var evalBenchCommand = command({
       try {
         const graderFiles = (await readdir(llmGradersDir)).filter((f) => f.endsWith(".json"));
         for (const file of graderFiles) {
-          const graderMeta = JSON.parse(await readFile3(join(llmGradersDir, file), "utf8"));
+          const graderMeta = JSON.parse(await readFile4(join(llmGradersDir, file), "utf8"));
           const graderName = graderMeta.name;
           const diskResultPath = join(testDir, "llm_grader_results", `${graderName}.json`);
           let llmResult;
           try {
-            llmResult = JSON.parse(await readFile3(diskResultPath, "utf8"));
+            llmResult = JSON.parse(await readFile4(diskResultPath, "utf8"));
           } catch {
           }
           if (llmResult) {
@@ -7659,7 +8006,7 @@ var evalBenchCommand = command({
       const timingPath = join(testDir, "timing.json");
       if (existsSync6(timingPath)) {
         try {
-          const timing = JSON.parse(await readFile3(timingPath, "utf8"));
+          const timing = JSON.parse(await readFile4(timingPath, "utf8"));
           if (typeof timing.execution_status === "string") {
             executionStatus = timing.execution_status;
           }
@@ -7754,7 +8101,7 @@ function computeStats(values) {
 }
 
 // src/commands/pipeline/grade.ts
-import { mkdir as mkdir7, readFile as readFile4, readdir as readdir2, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir7, readFile as readFile5, readdir as readdir2, writeFile as writeFile8 } from "node:fs/promises";
 import { join as join2 } from "node:path";
 var DEFAULT_CONCURRENCY = 10;
 async function runCodeGraders(tasks, concurrency) {
@@ -7770,7 +8117,7 @@ async function runCodeGraders(tasks, concurrency) {
   const executeGrader = async (task) => {
     const { testDir, resultsDir, graderFile, responseText } = task;
     const graderConfig = JSON.parse(
-      await readFile4(join2(testDir, "code_graders", graderFile), "utf8")
+      await readFile5(join2(testDir, "code_graders", graderFile), "utf8")
     );
     if (graderConfig.command) {
       await executeCodeGrader(graderConfig, task);
@@ -7929,7 +8276,7 @@ var evalGradeCommand = command({
   handler: async ({ exportDir, concurrency }) => {
     const maxWorkers = concurrency ?? DEFAULT_CONCURRENCY;
     const manifestPath = join2(exportDir, "manifest.json");
-    const manifest = JSON.parse(await readFile4(manifestPath, "utf8"));
+    const manifest = JSON.parse(await readFile5(manifestPath, "utf8"));
     const testIds = manifest.test_ids;
     const suiteName = manifest.suite ?? "";
     const safeSuiteName = suiteName ? suiteName.replace(/[\/\\:*?"<>|]/g, "_") : "";
@@ -7947,8 +8294,8 @@ var evalGradeCommand = command({
       }
       if (graderFiles.length === 0) continue;
       await mkdir7(resultsDir, { recursive: true });
-      const responseText = await readFile4(join2(testDir, "response.md"), "utf8");
-      const inputData = JSON.parse(await readFile4(join2(testDir, "input.json"), "utf8"));
+      const responseText = await readFile5(join2(testDir, "response.md"), "utf8");
+      const inputData = JSON.parse(await readFile5(join2(testDir, "input.json"), "utf8"));
       for (const graderFile of graderFiles) {
         tasks.push({ testId, testDir, resultsDir, graderFile, responseText, inputData });
       }
@@ -7959,7 +8306,7 @@ var evalGradeCommand = command({
 });
 
 // src/commands/pipeline/input.ts
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import { mkdir as mkdir8, writeFile as writeFile9 } from "node:fs/promises";
 import { dirname, join as join3, relative, resolve } from "node:path";
 var BUILTIN_ASSERTION_TYPES = /* @__PURE__ */ new Set([
@@ -8161,7 +8508,7 @@ async function writeGraderConfigs(testDir, assertions, evalDir) {
       let promptContent = "";
       if (config.resolvedPromptPath) {
         try {
-          promptContent = await readFile5(config.resolvedPromptPath, "utf8");
+          promptContent = await readFile6(config.resolvedPromptPath, "utf8");
         } catch {
           promptContent = typeof config.prompt === "string" ? config.prompt : "";
         }
@@ -8211,7 +8558,7 @@ async function writeJson(filePath, data) {
 // src/commands/pipeline/run.ts
 import { exec } from "node:child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync6, unlinkSync } from "node:fs";
-import { mkdir as mkdir9, readFile as readFile6, readdir as readdir3, writeFile as writeFile10 } from "node:fs/promises";
+import { mkdir as mkdir9, readFile as readFile7, readdir as readdir3, writeFile as writeFile10 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname as dirname2, join as join4, relative as relative2, resolve as resolve2 } from "node:path";
 function extractInputText(input) {
@@ -8390,9 +8737,9 @@ var evalRunCommand2 = command({
       const invokeTarget = async (testId) => {
         const subpath = safeSuiteName ? [safeSuiteName, testId] : [testId];
         const testDir = join4(outDir, ...subpath);
-        const invoke = JSON.parse(await readFile6(join4(testDir, "invoke.json"), "utf8"));
+        const invoke = JSON.parse(await readFile7(join4(testDir, "invoke.json"), "utf8"));
         if (invoke.kind !== "cli") return;
-        const inputData = JSON.parse(await readFile6(join4(testDir, "input.json"), "utf8"));
+        const inputData = JSON.parse(await readFile7(join4(testDir, "input.json"), "utf8"));
         const template = invoke.command;
         const cwd = invoke.cwd;
         const timeoutMs = invoke.timeout_ms ?? 12e4;
@@ -8531,8 +8878,8 @@ Done. Results in ${outDir}`);
       }
       if (graderFiles.length === 0) continue;
       await mkdir9(resultsDir, { recursive: true });
-      const responseText = await readFile6(join4(testDir, "response.md"), "utf8");
-      const inputData = JSON.parse(await readFile6(join4(testDir, "input.json"), "utf8"));
+      const responseText = await readFile7(join4(testDir, "response.md"), "utf8");
+      const inputData = JSON.parse(await readFile7(join4(testDir, "input.json"), "utf8"));
       for (const graderFile of graderFiles) {
         graderTasks.push({ testId, testDir, resultsDir, graderFile, responseText, inputData });
       }
@@ -8623,6 +8970,254 @@ var pipelineCommand = subcommands({
   }
 });
 
+// src/commands/prepare/index.ts
+import { cp, mkdir as mkdir10, rename, rm, writeFile as writeFile11 } from "node:fs/promises";
+import path17 from "node:path";
+function setupStatusFromHook(status) {
+  if (status === "success") {
+    return "ok";
+  }
+  if (status === "skipped") {
+    return "skipped";
+  }
+  return "warning";
+}
+function setupStepsFromPrepared(prepared) {
+  return [
+    ...prepared.hookExecutions.map((hook) => ({
+      name: `${hook.scope}_${hook.name}`,
+      status: setupStatusFromHook(hook.status),
+      ...hook.error !== void 0 && { message: hook.error }
+    })),
+    {
+      name: "workspace_baseline",
+      status: prepared.baseline.status === "initialized" ? "ok" : "skipped",
+      ...prepared.baseline.status === "unavailable" && { message: "baseline unavailable" }
+    }
+  ];
+}
+function toRepoPins(pins) {
+  return pins.map((pin) => ({
+    ...pin.path !== void 0 && { path: pin.path },
+    ...pin.repo !== void 0 && { repo: pin.repo },
+    ...pin.commit !== void 0 && { commit: pin.commit },
+    ...pin.baseCommit !== void 0 && { baseCommit: pin.baseCommit },
+    ...pin.ancestor !== void 0 && { ancestor: pin.ancestor },
+    ...pin.sparse !== void 0 && { sparse: pin.sparse }
+  }));
+}
+async function moveDirectory(sourcePath, destinationPath) {
+  try {
+    await rename(sourcePath, destinationPath);
+  } catch (error) {
+    if (error.code !== "EXDEV") {
+      throw error;
+    }
+    await cp(sourcePath, destinationPath, { recursive: true });
+    await rm(sourcePath, { recursive: true, force: true });
+  }
+}
+async function placePreparedWorkspace(prepared, destinationPath) {
+  const sourcePath = prepared.workspacePath;
+  if (path17.resolve(sourcePath) === path17.resolve(destinationPath)) {
+    return destinationPath;
+  }
+  await mkdir10(path17.dirname(destinationPath), { recursive: true });
+  await rm(destinationPath, { recursive: true, force: true });
+  if (prepared.cleanupPolicy.mode !== "static" && prepared.pool === void 0) {
+    await moveDirectory(sourcePath, destinationPath);
+    return destinationPath;
+  }
+  await cp(sourcePath, destinationPath, { recursive: true });
+  return destinationPath;
+}
+function renderPrompt(options) {
+  const taskInput = options.taskInput.trim() || "(No text input was provided.)";
+  return [
+    "# AgentV Prepared Attempt",
+    "",
+    "## Task Input",
+    "",
+    taskInput,
+    "",
+    "## Execution Instructions",
+    "",
+    `- Work in this workspace: ${options.workspacePath}`,
+    `- Complete the task input for target: ${options.target}`,
+    "- Leave the final files in the workspace for a later AgentV grading step.",
+    "- Do not run AgentV graders or inspect eval answer keys, rubrics, or oracle data.",
+    ""
+  ].join("\n");
+}
+function toManifestWire(result) {
+  return {
+    schema_version: result.schemaVersion,
+    eval_path: result.evalPath,
+    test_id: result.testId,
+    target: result.target,
+    workspace_path: result.workspacePath,
+    prompt_path: result.promptPath,
+    setup_status: result.setupStatus,
+    setup_steps: result.setupSteps.map((step) => ({
+      name: step.name,
+      status: step.status,
+      ...step.message !== void 0 && { message: step.message }
+    })),
+    repo_pins: result.repoPins.map((pin) => ({
+      ...pin.path !== void 0 && { path: pin.path },
+      ...pin.repo !== void 0 && { repo: pin.repo },
+      ...pin.commit !== void 0 && { commit: pin.commit },
+      ...pin.baseCommit !== void 0 && { base_commit: pin.baseCommit },
+      ...pin.ancestor !== void 0 && { ancestor: pin.ancestor },
+      ...pin.sparse !== void 0 && { sparse: pin.sparse }
+    })),
+    baseline: {
+      status: result.baseline.status,
+      ...result.baseline.commit !== void 0 && { commit: result.baseline.commit }
+    },
+    created_at: result.createdAt
+  };
+}
+function toCommandOutputWire2(result) {
+  return {
+    ...toManifestWire(result),
+    manifest_path: result.manifestPath
+  };
+}
+async function selectPrepareTarget(options) {
+  const selections = await selectMultipleTargets({
+    testFilePath: options.evalPath,
+    repoRoot: options.repoRoot,
+    cwd: process.cwd(),
+    dryRun: false,
+    dryRunDelay: 0,
+    dryRunDelayMin: 0,
+    dryRunDelayMax: 0,
+    env: process.env,
+    targetNames: [options.target],
+    targetRefs: options.targetRefs
+  });
+  const selection = selections[0];
+  if (!selection) {
+    throw new Error(`Target '${options.target}' could not be resolved`);
+  }
+  return {
+    resolvedTarget: {
+      ...selection.resolvedTarget,
+      name: options.target
+    },
+    ...selection.targetHooks !== void 0 && { targetHooks: selection.targetHooks }
+  };
+}
+async function prepareAttempt(options) {
+  const evalPath = path17.resolve(options.evalPath);
+  const outDir = path17.resolve(options.outDir);
+  const evalDir = path17.dirname(evalPath);
+  const repoRoot = await findRepoRoot(evalDir);
+  await loadEnvFromHierarchy({ testFilePath: evalPath, repoRoot, verbose: false });
+  const category = deriveCategory(path17.relative(process.cwd(), evalPath));
+  const suite = await loadTestSuite(evalPath, repoRoot, { category });
+  const test = suite.tests.find((candidate) => candidate.id === options.testId);
+  if (!test) {
+    throw new Error(`Test ID '${options.testId}' not found in ${evalPath}`);
+  }
+  const { resolvedTarget, targetHooks } = await selectPrepareTarget({
+    evalPath,
+    repoRoot,
+    target: options.target,
+    targetRefs: suite.targetRefs
+  });
+  const prepared = await prepareEvalWorkspace({
+    testFilePath: evalPath,
+    repoRoot,
+    target: resolvedTarget,
+    ...targetHooks !== void 0 && { targetHooks },
+    evalCases: suite.tests,
+    testId: options.testId,
+    verbose: false,
+    ...test.workspace?.path === void 0 && test.workspace?.mode !== "static" && { workspaceMode: "temp" },
+    retainOnSuccess: "keep",
+    retainOnFailure: "keep"
+  });
+  await mkdir10(outDir, { recursive: true });
+  const workspacePath = await placePreparedWorkspace(prepared, path17.join(outDir, "workspace"));
+  const promptPath = path17.join(outDir, "prompt.md");
+  const manifestPath = path17.join(outDir, "agentv_prepare.json");
+  const prompt = renderPrompt({
+    workspacePath,
+    target: options.target,
+    taskInput: prepared.promptSource.question
+  });
+  await writeFile11(promptPath, prompt, "utf8");
+  const result = {
+    schemaVersion: 1,
+    evalPath,
+    testId: prepared.testId,
+    target: options.target,
+    workspacePath,
+    promptPath,
+    manifestPath,
+    setupStatus: "ok",
+    setupSteps: setupStepsFromPrepared(prepared),
+    repoPins: toRepoPins(prepared.repoPins),
+    baseline: prepared.baseline,
+    createdAt: prepared.createdAt
+  };
+  await writeFile11(manifestPath, `${JSON.stringify(toManifestWire(result), null, 2)}
+`, "utf8");
+  return result;
+}
+function printHumanOutput2(result) {
+  console.log(`Prepared attempt for ${result.testId} (${result.target})`);
+  console.log(`Workspace: ${result.workspacePath}`);
+  console.log(`Prompt: ${result.promptPath}`);
+  console.log(`Manifest: ${result.manifestPath}`);
+  console.log("");
+  console.log("Next steps:");
+  console.log("  1. Give prompt.md to the human or external agent.");
+  console.log(`  2. Run the agent in ${result.workspacePath}.`);
+  console.log("  3. Keep the final workspace for a later AgentV grading command.");
+}
+var prepareCommand = command({
+  name: "prepare",
+  description: "Prepare one eval test workspace and safe prompt without running the target",
+  args: {
+    evalPath: positional({
+      type: string,
+      displayName: "eval",
+      description: "Path to an eval file"
+    }),
+    testId: option({
+      type: string,
+      long: "test-id",
+      description: "Exact test ID to prepare"
+    }),
+    target: option({
+      type: string,
+      long: "target",
+      description: "Target name this prepared attempt is for"
+    }),
+    out: option({
+      type: string,
+      long: "out",
+      description: "Prepared-attempt output directory"
+    }),
+    format: option({
+      type: optional(oneOf(["text", "json"])),
+      long: "format",
+      description: "Output format: text (default) or json"
+    })
+  },
+  handler: async ({ evalPath, testId, target, out, format }) => {
+    const result = await prepareAttempt({ evalPath, testId, target, outDir: out });
+    if (format === "json") {
+      console.log(JSON.stringify(toCommandOutputWire2(result), null, 2));
+      return;
+    }
+    printHumanOutput2(result);
+  }
+});
+
 // src/commands/results/combine.ts
 import * as readline2 from "node:readline/promises";
 
@@ -8636,7 +9231,7 @@ import {
   statSync as statSync4,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import path16 from "node:path";
+import path18 from "node:path";
 var CombineDuplicateError = class extends Error {
   constructor(conflicts) {
     super(`Duplicate result rows found for ${conflicts.length} (test_id, target) pair(s)`);
@@ -8652,7 +9247,7 @@ function readManifestRecords(manifestPath) {
 }
 function readBenchmarkMetadata(manifestPath) {
   try {
-    const benchmarkPath = path16.join(path16.dirname(manifestPath), "benchmark.json");
+    const benchmarkPath = path18.join(path18.dirname(manifestPath), "benchmark.json");
     const parsed = JSON.parse(readFileSync7(benchmarkPath, "utf8"));
     return {
       timestamp: parsed.metadata?.timestamp,
@@ -8771,7 +9366,7 @@ function defaultDisplayName(sources) {
 function defaultCombinedRunDir(cwd, startedAt) {
   const parsed = startedAt ? new Date(startedAt) : void 0;
   const timestamp = parsed && !Number.isNaN(parsed.getTime()) ? createRunDirName(parsed) : sanitizePathSegment(startedAt ?? "unknown-time");
-  return path16.join(cwd, ".agentv", "results", "runs", "combined", timestamp);
+  return path18.join(cwd, ".agentv", "results", "runs", "combined", timestamp);
 }
 function uniqueRunDir(baseDir) {
   if (!existsSync8(baseDir)) return baseDir;
@@ -8782,13 +9377,13 @@ function uniqueRunDir(baseDir) {
   return `${baseDir}-${suffix}`;
 }
 function toRunId(cwd, runDir) {
-  const runsRoot = path16.join(cwd, ".agentv", "results", "runs");
-  const relative3 = path16.relative(runsRoot, runDir);
-  if (relative3 === "" || relative3.startsWith("..") || path16.isAbsolute(relative3)) {
-    return path16.basename(runDir);
+  const runsRoot = path18.join(cwd, ".agentv", "results", "runs");
+  const relative3 = path18.relative(runsRoot, runDir);
+  if (relative3 === "" || relative3.startsWith("..") || path18.isAbsolute(relative3)) {
+    return path18.basename(runDir);
   }
-  const parts = relative3.split(path16.sep);
-  return parts.length > 1 ? `${parts[0]}::${parts.slice(1).join(path16.sep)}` : relative3;
+  const parts = relative3.split(path18.sep);
+  return parts.length > 1 ? `${parts[0]}::${parts.slice(1).join(path18.sep)}` : relative3;
 }
 var MANIFEST_PATH_FIELDS = [
   "grading_path",
@@ -8804,17 +9399,17 @@ var MANIFEST_PATH_FIELDS = [
 ];
 function copyReferencedArtifact(sourceBaseDir, outputDir, sourceIndex, relativePath) {
   if (!relativePath) return void 0;
-  if (path16.isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes("..")) {
+  if (path18.isAbsolute(relativePath) || relativePath.split(/[\\/]+/).includes("..")) {
     throw new Error(`Unsafe artifact path in source manifest: ${relativePath}`);
   }
-  const sourcePath = path16.join(sourceBaseDir, relativePath);
+  const sourcePath = path18.join(sourceBaseDir, relativePath);
   if (!existsSync8(sourcePath)) {
     return relativePath;
   }
-  const rewritten = path16.posix.join(`sources/source-${sourceIndex + 1}`, relativePath);
-  const destPath = path16.join(outputDir, rewritten);
+  const rewritten = path18.posix.join(`sources/source-${sourceIndex + 1}`, relativePath);
+  const destPath = path18.join(outputDir, rewritten);
   const sourceStat = statSync4(sourcePath);
-  mkdirSync2(path16.dirname(destPath), { recursive: true });
+  mkdirSync2(path18.dirname(destPath), { recursive: true });
   if (sourceStat.isDirectory()) {
     cpSync(sourcePath, destPath, { recursive: true });
   } else if (sourceStat.isFile()) {
@@ -8823,7 +9418,7 @@ function copyReferencedArtifact(sourceBaseDir, outputDir, sourceIndex, relativeP
   return rewritten;
 }
 function rewriteAndCopyRecord(row, outputDir) {
-  const sourceBaseDir = path16.dirname(row.source.manifestPath);
+  const sourceBaseDir = path18.dirname(row.source.manifestPath);
   const rewritten = { ...row.record };
   for (const field of MANIFEST_PATH_FIELDS) {
     rewritten[field] = copyReferencedArtifact(
@@ -8851,8 +9446,8 @@ function buildCombineRunSources(sourcePaths, cwd, options) {
   return sourcePaths.map((sourcePath, index) => {
     const manifestPath = resolveResultSourcePath(sourcePath, cwd);
     return {
-      id: options?.ids?.[index] ?? path16.basename(path16.dirname(manifestPath)),
-      displayName: options?.displayNames?.[index] ?? path16.basename(path16.dirname(manifestPath)),
+      id: options?.ids?.[index] ?? path18.basename(path18.dirname(manifestPath)),
+      displayName: options?.displayNames?.[index] ?? path18.basename(path18.dirname(manifestPath)),
       manifestPath,
       tags: options?.tags?.[index]
     };
@@ -8866,7 +9461,7 @@ function combineRunSources(options) {
   const startedAt = earliestTimestamp(loadedSources.map((source) => source.startedAt));
   const displayName = options.displayName?.trim() || defaultDisplayName(loadedSources);
   const runDir = uniqueRunDir(
-    options.outputDir ? path16.resolve(options.cwd, options.outputDir) : defaultCombinedRunDir(options.cwd, startedAt)
+    options.outputDir ? path18.resolve(options.cwd, options.outputDir) : defaultCombinedRunDir(options.cwd, startedAt)
   );
   const { rows, conflicts } = selectRows(
     loadedSources,
@@ -8880,10 +9475,10 @@ function combineRunSources(options) {
   });
   mkdirSync2(runDir, { recursive: true });
   const records = rows.map((row) => rewriteAndCopyRecord(row, runDir));
-  const manifestPath = path16.join(runDir, "index.jsonl");
+  const manifestPath = path18.join(runDir, "index.jsonl");
   writeJsonl(manifestPath, records);
   const timing = buildTimingArtifact(results);
-  const timingPath = path16.join(runDir, "timing.json");
+  const timingPath = path18.join(runDir, "timing.json");
   writeJson3(timingPath, timing);
   const benchmark = buildBenchmarkArtifact(results, "", "combined", results.length);
   const benchmarkWithMetadata = {
@@ -8897,7 +9492,7 @@ function combineRunSources(options) {
       duplicate_policy: options.duplicatePolicy
     }
   };
-  const benchmarkPath = path16.join(runDir, "benchmark.json");
+  const benchmarkPath = path18.join(runDir, "benchmark.json");
   writeJson3(benchmarkPath, benchmarkWithMetadata);
   const tags = [...new Set(loadedSources.flatMap((source) => source.tags ?? []))].sort();
   return {
@@ -9033,19 +9628,19 @@ import * as readline3 from "node:readline/promises";
 
 // src/commands/results/delete-run.ts
 import { existsSync as existsSync9, rmSync } from "node:fs";
-import path17 from "node:path";
+import path19 from "node:path";
 function localRunsRoot(cwd) {
-  return path17.resolve(cwd, ".agentv", "results", "runs");
+  return path19.resolve(cwd, ".agentv", "results", "runs");
 }
 function assertLocalRunManifest(cwd, manifestPath, runId) {
-  const resolvedManifestPath = path17.resolve(manifestPath);
-  if (path17.basename(resolvedManifestPath) !== RESULT_INDEX_FILENAME) {
+  const resolvedManifestPath = path19.resolve(manifestPath);
+  if (path19.basename(resolvedManifestPath) !== RESULT_INDEX_FILENAME) {
     throw new Error("Expected a run workspace directory or index.jsonl manifest");
   }
-  const runDir = path17.dirname(resolvedManifestPath);
+  const runDir = path19.dirname(resolvedManifestPath);
   const runsRoot = localRunsRoot(cwd);
-  const relativeRunDir = path17.relative(runsRoot, runDir);
-  if (relativeRunDir === "" || relativeRunDir.startsWith("..") || path17.isAbsolute(relativeRunDir)) {
+  const relativeRunDir = path19.relative(runsRoot, runDir);
+  if (relativeRunDir === "" || relativeRunDir.startsWith("..") || path19.isAbsolute(relativeRunDir)) {
     throw new Error("Run workspace is outside the local results directory");
   }
   if (!existsSync9(resolvedManifestPath)) {
@@ -9131,7 +9726,7 @@ var resultsDeleteCommand = command({
 });
 
 // src/commands/results/export.ts
-import path18 from "node:path";
+import path20 from "node:path";
 
 // src/commands/results/shared.ts
 import { existsSync as existsSync10 } from "node:fs";
@@ -9178,20 +9773,20 @@ async function loadResults(source, cwd) {
 
 // src/commands/results/export.ts
 function deriveOutputDir(cwd, sourceFile) {
-  if (path18.basename(sourceFile) !== RESULT_INDEX_FILENAME) {
+  if (path20.basename(sourceFile) !== RESULT_INDEX_FILENAME) {
     throw new Error(`Expected a run manifest named ${RESULT_INDEX_FILENAME}: ${sourceFile}`);
   }
-  const runDir = path18.dirname(sourceFile);
-  const segments = path18.normalize(runDir).split(path18.sep).filter(Boolean);
+  const runDir = path20.dirname(sourceFile);
+  const segments = path20.normalize(runDir).split(path20.sep).filter(Boolean);
   const runsIndex = segments.lastIndexOf("runs");
   if (runsIndex >= 0 && runsIndex < segments.length - 1) {
-    return path18.join(cwd, ".agentv", "results", "export", ...segments.slice(runsIndex + 1));
+    return path20.join(cwd, ".agentv", "results", "export", ...segments.slice(runsIndex + 1));
   }
-  const parentDir = path18.basename(runDir);
+  const parentDir = path20.basename(runDir);
   if (parentDir.startsWith("eval_")) {
-    return path18.join(cwd, ".agentv", "results", "export", parentDir.slice(5));
+    return path20.join(cwd, ".agentv", "results", "export", parentDir.slice(5));
   }
-  return path18.join(cwd, ".agentv", "results", "export", parentDir);
+  return path20.join(cwd, ".agentv", "results", "export", parentDir);
 }
 async function loadExportSource(source, cwd) {
   const { sourceFile } = await resolveSourceFile(source, cwd);
@@ -9224,8 +9819,8 @@ var resultsExportCommand = command({
     const cwd = dir ?? process.cwd();
     try {
       const { sourceFile, results } = await loadExportSource(source, cwd);
-      const outputDir = out ? path18.isAbsolute(out) ? out : path18.resolve(cwd, out) : deriveOutputDir(cwd, sourceFile);
-      await writeArtifactsFromResults(results, outputDir, {
+      const outputDir = out ? path20.isAbsolute(out) ? out : path20.resolve(cwd, out) : deriveOutputDir(cwd, sourceFile);
+      await writeArtifactsFromResults2(results, outputDir, {
         evalFile: sourceFile
       });
       console.log(`Exported ${results.length} test(s) to ${outputDir}`);
@@ -9285,7 +9880,7 @@ var resultsFailuresCommand = command({
 
 // src/commands/results/report.ts
 import { existsSync as existsSync11, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "node:fs";
-import path19 from "node:path";
+import path21 from "node:path";
 
 // src/commands/results/report-template.ts
 var RESULTS_REPORT_TEMPLATE = `<!DOCTYPE html>
@@ -10909,10 +11504,10 @@ function normalizeEvalFileLabel(value) {
   if (!trimmed) {
     return void 0;
   }
-  return path19.basename(trimmed).replace(/\.results\.jsonl$/i, "").replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "").replace(/\.jsonl$/i, "");
+  return path21.basename(trimmed).replace(/\.results\.jsonl$/i, "").replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "").replace(/\.jsonl$/i, "");
 }
 function readBenchmarkEvalFile(sourceFile) {
-  const benchmarkPath = path19.join(path19.dirname(sourceFile), "benchmark.json");
+  const benchmarkPath = path21.join(path21.dirname(sourceFile), "benchmark.json");
   if (!existsSync11(benchmarkPath)) {
     return void 0;
   }
@@ -10924,10 +11519,10 @@ function readBenchmarkEvalFile(sourceFile) {
   }
 }
 function deriveReportPath(sourceFile) {
-  return path19.join(path19.dirname(sourceFile), "report.html");
+  return path21.join(path21.dirname(sourceFile), "report.html");
 }
 function serializeReportResult(result, sourceFile, manifestRecord, benchmarkEvalFile) {
-  const fallbackEvalFile = normalizeEvalFileLabel(manifestRecord?.eval_file) ?? benchmarkEvalFile ?? normalizeEvalFileLabel(result.suite) ?? path19.basename(path19.dirname(sourceFile));
+  const fallbackEvalFile = normalizeEvalFileLabel(manifestRecord?.eval_file) ?? benchmarkEvalFile ?? normalizeEvalFileLabel(result.suite) ?? path21.basename(path21.dirname(sourceFile));
   return {
     timestamp: result.timestamp,
     test_id: result.testId,
@@ -10975,9 +11570,9 @@ function renderResultsReport(results, sourceFile, records, benchmarkEvalFile) {
 }
 async function writeResultsReport(source, outputPath, cwd) {
   const { sourceFile, results, records, benchmarkEvalFile } = await loadReportSource(source, cwd);
-  const resolvedOutputPath = outputPath ? path19.isAbsolute(outputPath) ? outputPath : path19.resolve(cwd, outputPath) : deriveReportPath(sourceFile);
+  const resolvedOutputPath = outputPath ? path21.isAbsolute(outputPath) ? outputPath : path21.resolve(cwd, outputPath) : deriveReportPath(sourceFile);
   const html = renderResultsReport(results, sourceFile, records, benchmarkEvalFile);
-  mkdirSync3(path19.dirname(resolvedOutputPath), { recursive: true });
+  mkdirSync3(path21.dirname(resolvedOutputPath), { recursive: true });
   writeFileSync4(resolvedOutputPath, html, "utf8");
   const written = readFileSync8(resolvedOutputPath, "utf8");
   if (written.includes("__DATA_PLACEHOLDER__")) {
@@ -11165,10 +11760,10 @@ var resultsSummaryCommand = command({
 
 // src/commands/results/validate.ts
 import { existsSync as existsSync13, readFileSync as readFileSync10, statSync as statSync5 } from "node:fs";
-import path20 from "node:path";
+import path22 from "node:path";
 function checkDirectoryNaming(runDir) {
-  const dirName = path20.basename(runDir);
-  const pathSegments = path20.normalize(runDir).split(path20.sep).filter(Boolean);
+  const dirName = path22.basename(runDir);
+  const pathSegments = path22.normalize(runDir).split(path22.sep).filter(Boolean);
   const runsIndex = pathSegments.lastIndexOf("runs");
   const diagnostics = [];
   if (runsIndex < 0 || runsIndex >= pathSegments.length - 1) {
@@ -11198,7 +11793,7 @@ function validateRunDirectory(runDir) {
   return { diagnostics, entries: entries2 };
 }
 function checkIndexJsonl(runDir) {
-  const indexPath = path20.join(runDir, "index.jsonl");
+  const indexPath = path22.join(runDir, "index.jsonl");
   const diagnostics = [];
   const entries2 = [];
   if (!existsSync13(indexPath)) {
@@ -11297,7 +11892,7 @@ function checkArtifactFiles(runDir, entries2) {
   for (const entry of entries2) {
     const testId = entry.test_id ?? "?";
     if (entry.grading_path) {
-      const gradingPath = path20.join(runDir, entry.grading_path);
+      const gradingPath = path22.join(runDir, entry.grading_path);
       if (!existsSync13(gradingPath)) {
         diagnostics.push({
           severity: "error",
@@ -11327,7 +11922,7 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
     if (entry.timing_path) {
-      const timingPath = path20.join(runDir, entry.timing_path);
+      const timingPath = path22.join(runDir, entry.timing_path);
       if (!existsSync13(timingPath)) {
         diagnostics.push({
           severity: "warning",
@@ -11336,7 +11931,7 @@ function checkArtifactFiles(runDir, entries2) {
       }
     }
   }
-  const benchmarkPath = path20.join(runDir, "benchmark.json");
+  const benchmarkPath = path22.join(runDir, "benchmark.json");
   if (!existsSync13(benchmarkPath)) {
     diagnostics.push({ severity: "warning", message: "benchmark.json is missing" });
   }
@@ -11353,7 +11948,7 @@ var resultsValidateCommand = command({
     })
   },
   handler: async ({ runDir }) => {
-    const resolvedDir = path20.resolve(runDir);
+    const resolvedDir = path22.resolve(runDir);
     if (!existsSync13(resolvedDir) || !statSync5(resolvedDir).isDirectory()) {
       console.error(`Error: '${runDir}' is not a directory`);
       process.exit(1);
@@ -11399,14 +11994,14 @@ var resultsCommand = subcommands({
 
 // src/commands/results/serve.ts
 import { existsSync as existsSync16, readFileSync as readFileSync12, readdirSync as readdirSync4, statSync as statSync6, writeFileSync as writeFileSync6 } from "node:fs";
-import path23 from "node:path";
+import path25 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { Hono } from "hono";
 
 // src/commands/results/eval-runner.ts
 import { execFileSync as execFileSync2, spawn } from "node:child_process";
 import { createWriteStream, existsSync as existsSync14, mkdirSync as mkdirSync4 } from "node:fs";
-import path21 from "node:path";
+import path23 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var activeRuns = /* @__PURE__ */ new Map();
 function generateRunId() {
@@ -11426,7 +12021,7 @@ function pruneFinishedRuns() {
 }
 function getActiveRunTarget(indexJsonlPath) {
   for (const run2 of activeRuns.values()) {
-    if (run2.outputDir && path21.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
+    if (run2.outputDir && path23.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
       return run2.target;
     }
   }
@@ -11434,7 +12029,7 @@ function getActiveRunTarget(indexJsonlPath) {
 }
 function getActiveRunStatus(indexJsonlPath) {
   for (const run2 of activeRuns.values()) {
-    if (run2.outputDir && path21.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
+    if (run2.outputDir && path23.join(run2.outputDir, "index.jsonl") === indexJsonlPath) {
       return run2.status;
     }
   }
@@ -11444,7 +12039,7 @@ async function discoverTargetsInProject(cwd) {
   const repoRoot = await findRepoRoot(cwd) ?? cwd;
   let targetsFilePath;
   for (const candidate of TARGET_FILE_CANDIDATES) {
-    const fullPath = path21.join(cwd, candidate);
+    const fullPath = path23.join(cwd, candidate);
     if (existsSync14(fullPath)) {
       targetsFilePath = fullPath;
       break;
@@ -11452,7 +12047,7 @@ async function discoverTargetsInProject(cwd) {
   }
   if (!targetsFilePath) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const fullPath = path21.join(repoRoot, candidate);
+      const fullPath = path23.join(repoRoot, candidate);
       if (existsSync14(fullPath)) {
         targetsFilePath = fullPath;
         break;
@@ -11526,17 +12121,17 @@ function buildCliPreview(args) {
 }
 function resolveCliPath(cwd) {
   const candidates = [
-    path21.join(cwd, "apps/cli/src/cli.ts"),
-    path21.join(cwd, "apps/cli/dist/cli.js")
+    path23.join(cwd, "apps/cli/src/cli.ts"),
+    path23.join(cwd, "apps/cli/dist/cli.js")
   ];
   for (const c4 of candidates) {
     if (existsSync14(c4)) {
       return { binPath: "bun", args: [c4] };
     }
   }
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path21.dirname(fileURLToPath2(import.meta.url));
-  const fromSrc = path21.resolve(currentDir, "../../cli.ts");
-  const fromDist = path21.resolve(currentDir, "cli.js");
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path23.dirname(fileURLToPath2(import.meta.url));
+  const fromSrc = path23.resolve(currentDir, "../../cli.ts");
+  const fromDist = path23.resolve(currentDir, "cli.js");
   if (existsSync14(fromSrc)) return { binPath: "bun", args: [fromSrc] };
   if (existsSync14(fromDist)) return { binPath: "bun", args: [fromDist] };
   if (isCommandAvailable("agentv")) {
@@ -11555,7 +12150,7 @@ function isCommandAvailable(cmd) {
 function openConsoleLogStream(outputDir) {
   try {
     mkdirSync4(outputDir, { recursive: true });
-    const stream = createWriteStream(path21.join(outputDir, "console.log"), { flags: "w" });
+    const stream = createWriteStream(path23.join(outputDir, "console.log"), { flags: "w" });
     stream.on("error", () => {
     });
     return stream;
@@ -11612,7 +12207,7 @@ function registerEvalRoutes(app2, getCwd, options) {
       return c4.json({ error: "Cannot locate agentv CLI entry point" }, 500);
     }
     const args = buildCliArgs(body);
-    const outputDir = body.output?.trim() ? path21.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
+    const outputDir = body.output?.trim() ? path23.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
     if (!body.output?.trim()) {
       args.push("--output", outputDir);
     }
@@ -11790,7 +12385,7 @@ Process error: ${err2.message}
       return c4.json({ error: "Cannot locate agentv CLI entry point" }, 500);
     }
     const args = buildCliArgs(body);
-    const outputDir = body.output?.trim() ? path21.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
+    const outputDir = body.output?.trim() ? path23.resolve(cwd, body.output.trim()) : buildDefaultRunDir(cwd);
     if (!body.output?.trim()) {
       args.push("--output", outputDir);
     }
@@ -11913,17 +12508,17 @@ Process error: ${err2.message}
 
 // src/commands/results/studio-config.ts
 import { existsSync as existsSync15, mkdirSync as mkdirSync5, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "node:fs";
-import path22 from "node:path";
+import path24 from "node:path";
 import { stringify as stringifyYaml3 } from "yaml";
 var DEFAULTS = {
   threshold: DEFAULT_THRESHOLD,
   appName: "agentv"
 };
 function loadStudioConfig(agentvDir) {
-  const localConfigPath = path22.join(agentvDir, "config.yaml");
-  const globalConfigPath = path22.join(getAgentvConfigDir(), "config.yaml");
+  const localConfigPath = path24.join(agentvDir, "config.yaml");
+  const globalConfigPath = path24.join(getAgentvConfigDir(), "config.yaml");
   const localConfig = loadParsedConfig(localConfigPath);
-  const globalConfig = path22.resolve(globalConfigPath) === path22.resolve(localConfigPath) ? void 0 : loadParsedConfig(globalConfigPath);
+  const globalConfig = path24.resolve(globalConfigPath) === path24.resolve(localConfigPath) ? void 0 : loadParsedConfig(globalConfigPath);
   const threshold = [
     readThreshold(localConfig?.dashboard),
     readThreshold(localConfig?.studio),
@@ -11963,7 +12558,7 @@ function saveStudioConfig(agentvDir, config) {
   if (!existsSync15(agentvDir)) {
     mkdirSync5(agentvDir, { recursive: true });
   }
-  const configPath = path22.join(agentvDir, "config.yaml");
+  const configPath = path24.join(agentvDir, "config.yaml");
   let existing = {};
   if (existsSync15(configPath)) {
     const raw = readFileSync11(configPath, "utf-8");
@@ -12034,13 +12629,13 @@ function resolveDashboardMode(_projectCount, options) {
 }
 function bootstrapCurrentProject(cwd, options) {
   if (options.single === true) return {};
-  if (!existsSync16(path23.join(cwd, ".agentv"))) return {};
+  if (!existsSync16(path25.join(cwd, ".agentv"))) return {};
   const entry = addProject(cwd);
   touchProject(entry.id);
   return { currentProjectId: entry.id };
 }
 function feedbackPath(resultDir) {
-  return path23.join(resultDir, "feedback.json");
+  return path25.join(resultDir, "feedback.json");
 }
 function readFeedback(cwd) {
   const fp = feedbackPath(cwd);
@@ -12067,8 +12662,8 @@ function buildFileTree(dirPath, relativeTo) {
     if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
     return a.name.localeCompare(b.name);
   }).map((entry) => {
-    const fullPath = path23.join(dirPath, entry.name);
-    const relPath = path23.relative(relativeTo, fullPath);
+    const fullPath = path25.join(dirPath, entry.name);
+    const relPath = path25.relative(relativeTo, fullPath);
     if (entry.isDirectory()) {
       return {
         name: entry.name,
@@ -12081,7 +12676,7 @@ function buildFileTree(dirPath, relativeTo) {
   });
 }
 function inferLanguage(filePath) {
-  const ext = path23.extname(filePath).toLowerCase();
+  const ext = path25.extname(filePath).toLowerCase();
   const langMap = {
     ".json": "json",
     ".jsonl": "json",
@@ -12108,14 +12703,14 @@ function inferLanguage(filePath) {
   return langMap[ext] ?? "plaintext";
 }
 function inferRawContentType(filePath) {
-  const ext = path23.extname(filePath).toLowerCase();
+  const ext = path25.extname(filePath).toLowerCase();
   if (ext === ".json") return "application/json; charset=utf-8";
   if (ext === ".jsonl") return "text/plain; charset=utf-8";
   if (ext === ".md") return "text/markdown; charset=utf-8";
   return "text/plain; charset=utf-8";
 }
 function contentDispositionFilename(filePath) {
-  return path23.basename(filePath).replace(/["\\\r\n]/g, "_");
+  return path25.basename(filePath).replace(/["\\\r\n]/g, "_");
 }
 function stripHeavyFields(results) {
   return results.map((r) => {
@@ -12335,7 +12930,7 @@ async function handleRunLog(c4, { searchDir, projectId }) {
   if (meta.source === "remote") {
     return c4.json({ error: "Run log is not available for remote runs" }, 404);
   }
-  const logPath = path23.join(path23.dirname(meta.path), "console.log");
+  const logPath = path25.join(path25.dirname(meta.path), "console.log");
   if (!existsSync16(logPath)) {
     return c4.json({ error: "Run log not found for this run" }, 404);
   }
@@ -12369,11 +12964,11 @@ async function handleRunDetail(c4, { searchDir, projectId }) {
 }
 function deriveResumeMeta(cwd, manifestPath) {
   const out = {};
-  const runDir = path23.dirname(manifestPath);
-  const relative3 = path23.relative(cwd, runDir);
+  const runDir = path25.dirname(manifestPath);
+  const relative3 = path25.relative(cwd, runDir);
   out.run_dir = relative3 !== "" && !relative3.startsWith("..") ? relative3 : runDir;
   try {
-    const benchmarkPath = path23.join(runDir, "benchmark.json");
+    const benchmarkPath = path25.join(runDir, "benchmark.json");
     if (existsSync16(benchmarkPath)) {
       const parsed = JSON.parse(readFileSync12(benchmarkPath, "utf8"));
       const evalFile = parsed.metadata?.eval_file;
@@ -12510,7 +13105,7 @@ async function handleEvalFiles(c4, { searchDir, projectId }) {
     const records = await parseManifestForMeta(searchDir, meta, projectId);
     const record = records.find((r) => r.test_id === evalId);
     if (!record) return c4.json({ error: "Eval not found" }, 404);
-    const baseDir = path23.dirname(meta.path);
+    const baseDir = path25.dirname(meta.path);
     const knownPaths = [
       record.grading_path,
       record.timing_path,
@@ -12526,14 +13121,14 @@ async function handleEvalFiles(c4, { searchDir, projectId }) {
       record.graders_path
     ].filter((p) => !!p);
     if (knownPaths.length === 0) return c4.json({ files: [] });
-    const artifactDirs = knownPaths.map((p) => path23.dirname(p));
+    const artifactDirs = knownPaths.map((p) => path25.dirname(p));
     let commonDir = artifactDirs[0];
     for (const dir of artifactDirs) {
       while (!dir.startsWith(commonDir)) {
-        commonDir = path23.dirname(commonDir);
+        commonDir = path25.dirname(commonDir);
       }
     }
-    const artifactAbsDir = path23.join(baseDir, commonDir);
+    const artifactAbsDir = path25.join(baseDir, commonDir);
     const files = buildFileTree(artifactAbsDir, baseDir);
     return c4.json({ files });
   } catch {
@@ -12555,9 +13150,9 @@ async function handleEvalFileContent(c4, { searchDir, projectId }) {
   }
   if (!filePath) return c4.json({ error: "No file path specified" }, 400);
   await ensureRunReadable(searchDir, meta, projectId);
-  const baseDir = path23.dirname(meta.path);
-  const absolutePath = path23.resolve(baseDir, filePath);
-  if (!absolutePath.startsWith(path23.resolve(baseDir) + path23.sep) && absolutePath !== path23.resolve(baseDir)) {
+  const baseDir = path25.dirname(meta.path);
+  const absolutePath = path25.resolve(baseDir, filePath);
+  if (!absolutePath.startsWith(path25.resolve(baseDir) + path25.sep) && absolutePath !== path25.resolve(baseDir)) {
     return c4.json({ error: "Path traversal not allowed" }, 403);
   }
   if (!existsSync16(absolutePath) || !statSync6(absolutePath).isFile()) {
@@ -12828,13 +13423,13 @@ function handleConfig(c4, { agentvDir, searchDir }, options) {
     threshold: config.threshold,
     app_name: config.appName,
     read_only: options?.readOnly === true,
-    project_name: path23.basename(searchDir),
+    project_name: path25.basename(searchDir),
     project_dashboard: options?.projectDashboard === true,
     ...options?.currentProjectId && { current_project_id: options.currentProjectId }
   });
 }
 function handleFeedbackRead(c4, { searchDir }) {
-  const resultsDir = path23.join(searchDir, ".agentv", "results");
+  const resultsDir = path25.join(searchDir, ".agentv", "results");
   return c4.json(readFeedback(existsSync16(resultsDir) ? resultsDir : searchDir));
 }
 async function handleRunTagsPut(c4, { searchDir, projectId }) {
@@ -12904,7 +13499,7 @@ async function handleRunDelete(c4, { searchDir, projectId }) {
   }
 }
 function getLocalRunsRoot(searchDir) {
-  return path23.join(searchDir, ".agentv", "results", "runs");
+  return path25.join(searchDir, ".agentv", "results", "runs");
 }
 function validateLocalCompletedRun(searchDir, meta, actionName = "Run combine") {
   if (meta.source === "remote") {
@@ -12913,13 +13508,13 @@ function validateLocalCompletedRun(searchDir, meta, actionName = "Run combine")
   if (getActiveRunStatus(meta.path) === "starting" || getActiveRunStatus(meta.path) === "running") {
     return { error: "Run is still active", status: 409 };
   }
-  const manifestPath = path23.resolve(meta.path);
-  if (path23.basename(manifestPath) !== "index.jsonl") {
+  const manifestPath = path25.resolve(meta.path);
+  if (path25.basename(manifestPath) !== "index.jsonl") {
     return { error: "Run workspace is invalid", status: 400 };
   }
-  const runDir = path23.dirname(manifestPath);
-  const runsRoot = path23.resolve(getLocalRunsRoot(searchDir));
-  if (runDir !== runsRoot && runDir.startsWith(`${runsRoot}${path23.sep}`) && existsSync16(runDir)) {
+  const runDir = path25.dirname(manifestPath);
+  const runsRoot = path25.resolve(getLocalRunsRoot(searchDir));
+  if (runDir !== runsRoot && runDir.startsWith(`${runsRoot}${path25.sep}`) && existsSync16(runDir)) {
     return { ok: true };
   }
   return { error: "Run workspace is outside the local results directory", status: 400 };
@@ -13001,7 +13596,7 @@ async function handleRunsCombine(c4, { searchDir, projectId }) {
 }
 function createApp(results, resultDir, cwd, sourceFile, options) {
   const searchDir = cwd ?? resultDir;
-  const agentvDir = path23.join(searchDir, ".agentv");
+  const agentvDir = path25.join(searchDir, ".agentv");
   const defaultCtx = { searchDir, agentvDir, projectId: options?.currentProjectId };
   const readOnly = options?.readOnly === true;
   const app2 = new Hono();
@@ -13012,7 +13607,7 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     }
     return handler(c4, {
       searchDir: project.path,
-      agentvDir: path23.join(project.path, ".agentv"),
+      agentvDir: path25.join(project.path, ".agentv"),
       projectId: project.id
     });
   }
@@ -13044,7 +13639,7 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
   }
   async function summarizeProjectRunMetas(project) {
     const { runs: metas } = await listMergedResultFiles(project.path, void 0, project.id);
-    const threshold = loadStudioConfig(path23.join(project.path, ".agentv")).threshold;
+    const threshold = loadStudioConfig(path25.join(project.path, ".agentv")).threshold;
     let passRateSum = 0;
     let executionErrorCount = 0;
     for (const meta of metas) {
@@ -13140,7 +13735,7 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
             if (records.length > 0) {
               const qualitySummary = summarizeQualityResults(
                 records,
-                loadStudioConfig(path23.join(p.path, ".agentv")).threshold
+                loadStudioConfig(path25.join(p.path, ".agentv")).threshold
               );
               target = records[0].target;
               experiment = records[0].experiment ?? experiment;
@@ -13410,22 +14005,22 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
     { readOnly }
   );
   const studioDistPath = options?.studioDir ?? resolveStudioDistDir();
-  if (!studioDistPath || !existsSync16(path23.join(studioDistPath, "index.html"))) {
+  if (!studioDistPath || !existsSync16(path25.join(studioDistPath, "index.html"))) {
     throw new Error(
       'Dashboard dist not found. Run "bun run build" in apps/dashboard/ to build the SPA.'
     );
   }
   app2.get("/", (c4) => {
-    const indexPath = path23.join(studioDistPath, "index.html");
+    const indexPath = path25.join(studioDistPath, "index.html");
     if (existsSync16(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
     return c4.notFound();
   });
   app2.get("/assets/*", (c4) => {
     const assetPath = c4.req.path;
-    const filePath = path23.join(studioDistPath, assetPath);
+    const filePath = path25.join(studioDistPath, assetPath);
     if (!existsSync16(filePath)) return c4.notFound();
     const content = readFileSync12(filePath);
-    const ext = path23.extname(filePath);
+    const ext = path25.extname(filePath);
     const mimeTypes = {
       ".js": "application/javascript",
       ".css": "text/css",
@@ -13446,26 +14041,26 @@ function createApp(results, resultDir, cwd, sourceFile, options) {
   });
   app2.get("*", (c4) => {
     if (c4.req.path.startsWith("/api/")) return c4.json({ error: "Not found" }, 404);
-    const indexPath = path23.join(studioDistPath, "index.html");
+    const indexPath = path25.join(studioDistPath, "index.html");
     if (existsSync16(indexPath)) return c4.html(readFileSync12(indexPath, "utf8"));
     return c4.notFound();
   });
   return app2;
 }
 function resolveStudioDistDir() {
-  const currentDir = typeof __dirname !== "undefined" ? __dirname : path23.dirname(fileURLToPath3(import.meta.url));
+  const currentDir = typeof __dirname !== "undefined" ? __dirname : path25.dirname(fileURLToPath3(import.meta.url));
   const candidates = [
     // From src/commands/results/ → sibling apps/dashboard/dist
-    path23.resolve(currentDir, "../../../../dashboard/dist"),
+    path25.resolve(currentDir, "../../../../dashboard/dist"),
     // From dist/ → sibling apps/dashboard/dist (monorepo dev)
-    path23.resolve(currentDir, "../../dashboard/dist"),
+    path25.resolve(currentDir, "../../dashboard/dist"),
     // Bundled inside CLI dist (published package: dist/dashboard/)
-    path23.resolve(currentDir, "dashboard"),
+    path25.resolve(currentDir, "dashboard"),
     // From dist/ in monorepo root context
-    path23.resolve(currentDir, "../../../apps/dashboard/dist")
+    path25.resolve(currentDir, "../../../apps/dashboard/dist")
   ];
   for (const candidate of candidates) {
-    if (existsSync16(candidate) && existsSync16(path23.join(candidate, "index.html"))) {
+    if (existsSync16(candidate) && existsSync16(path25.join(candidate, "index.html"))) {
       return candidate;
     }
   }
@@ -13535,7 +14130,7 @@ var resultsServeCommand = command({
       return;
     }
     const repoRoot = await findRepoRoot(cwd);
-    const yamlConfig = await loadConfig(path23.join(cwd, "_"), repoRoot);
+    const yamlConfig = await loadConfig(path25.join(cwd, "_"), repoRoot);
     if (yamlConfig?.required_version) {
       await enforceRequiredVersion(yamlConfig.required_version);
     }
@@ -13565,7 +14160,7 @@ var resultsServeCommand = command({
           }
         }
       }
-      const resultDir = sourceFile ? path23.dirname(path23.resolve(sourceFile)) : cwd;
+      const resultDir = sourceFile ? path25.dirname(path25.resolve(sourceFile)) : cwd;
       const app2 = createApp(results, resultDir, cwd, sourceFile, {
         readOnly,
         projectDashboard,
@@ -13601,26 +14196,26 @@ var resultsServeCommand = command({
 
 // src/commands/runs/rerun.ts
 import { constants } from "node:fs";
-import { access, readFile as readFile7 } from "node:fs/promises";
-import path24 from "node:path";
+import { access, readFile as readFile8 } from "node:fs/promises";
+import path26 from "node:path";
 import { config as loadDotenv } from "dotenv";
 var TASK_EVAL_FILENAME = "EVAL.yaml";
 var TASK_TARGETS_FILENAME = "targets.yaml";
 var ENV_REF_PATTERN = /\$\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function displayRecord(record) {
   return `${record.test_id ?? "unknown"}@${record.target ?? "unknown"}`;
 }
 function resolveSourcePath(cwd, source) {
-  return path24.isAbsolute(source) ? source : path24.resolve(cwd, source);
+  return path26.isAbsolute(source) ? source : path26.resolve(cwd, source);
 }
 function resolveRelativeRunPath(runDir, relativePath) {
   if (!relativePath || relativePath.trim().length === 0) {
     return void 0;
   }
-  return path24.resolve(runDir, relativePath);
+  return path26.resolve(runDir, relativePath);
 }
 async function ensureFile(filePath, label) {
   try {
@@ -13649,25 +14244,25 @@ function stringArray(value) {
   return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
 }
 function readExecutionTarget(parsedEval) {
-  if (!isRecord(parsedEval)) {
+  if (!isRecord2(parsedEval)) {
     return void 0;
   }
   const execution = parsedEval.execution;
-  if (isRecord(execution) && typeof execution.target === "string" && execution.target.length > 0) {
+  if (isRecord2(execution) && typeof execution.target === "string" && execution.target.length > 0) {
     return execution.target;
   }
   return typeof parsedEval.target === "string" && parsedEval.target.length > 0 ? parsedEval.target : void 0;
 }
 async function readTaskTarget(evalPath, fallback) {
-  const raw = await readFile7(evalPath, "utf8");
+  const raw = await readFile8(evalPath, "utf8");
   return readExecutionTarget(parseYamlValue(raw)) ?? fallback;
 }
 async function readTargetDefinitions2(targetsPath) {
-  const parsed = parseYamlValue(await readFile7(targetsPath, "utf8"));
-  if (!isRecord(parsed) || !Array.isArray(parsed.targets)) {
+  const parsed = parseYamlValue(await readFile8(targetsPath, "utf8"));
+  if (!isRecord2(parsed) || !Array.isArray(parsed.targets)) {
     throw new Error(`Targets file is missing a top-level targets array: ${targetsPath}`);
   }
-  return parsed.targets.filter(isRecord);
+  return parsed.targets.filter(isRecord2);
 }
 function targetName(definition) {
   return typeof definition.name === "string" && definition.name.trim().length > 0 ? definition.name.trim() : void 0;
@@ -13717,7 +14312,7 @@ function collectEnvRefs(value, names = /* @__PURE__ */ new Set()) {
     }
     return names;
   }
-  if (isRecord(value)) {
+  if (isRecord2(value)) {
     for (const [key, entry] of Object.entries(value)) {
       if (key === "required_env") {
         for (const required of stringArray(entry)) {
@@ -13778,15 +14373,15 @@ async function validateTargetFile(targetsPath, targetNames, label) {
   }
 }
 function isInsideOrSame(root, candidate) {
-  const relative3 = path24.relative(path24.resolve(root), path24.resolve(candidate));
-  return relative3 === "" || !relative3.startsWith("..") && !path24.isAbsolute(relative3);
+  const relative3 = path26.relative(path26.resolve(root), path26.resolve(candidate));
+  return relative3 === "" || !relative3.startsWith("..") && !path26.isAbsolute(relative3);
 }
 function forbiddenOutputRoots(sourceRunDir, selected) {
   return [
-    path24.resolve(sourceRunDir),
+    path26.resolve(sourceRunDir),
     ...selected.flatMap((bundle) => [
-      path24.resolve(bundle.artifactDir),
-      path24.resolve(bundle.taskDir)
+      path26.resolve(bundle.artifactDir),
+      path26.resolve(bundle.taskDir)
     ])
   ];
 }
@@ -13805,13 +14400,13 @@ function defaultOutputDir(cwd, sourceRunDir, selected, experiment) {
   if (!roots.some((root) => isInsideOrSame(root, candidate))) {
     return candidate;
   }
-  return path24.join(path24.dirname(path24.resolve(sourceRunDir)), `rerun-${createRunDirName()}`);
+  return path26.join(path26.dirname(path26.resolve(sourceRunDir)), `rerun-${createRunDirName()}`);
 }
 async function loadEnvFile2(envFile, cwd, verbose) {
   if (!envFile) {
     return;
   }
-  const resolved = path24.isAbsolute(envFile) ? envFile : path24.resolve(cwd, envFile);
+  const resolved = path26.isAbsolute(envFile) ? envFile : path26.resolve(cwd, envFile);
   await ensureFile(resolved, "Environment file");
   const loaded = loadDotenv({ path: resolved, override: false });
   if (loaded.error) {
@@ -13822,7 +14417,7 @@ async function loadEnvFile2(envFile, cwd, verbose) {
   }
 }
 async function loadSelectedTaskBundles(options) {
-  const content = await readFile7(options.indexPath, "utf8");
+  const content = await readFile8(options.indexPath, "utf8");
   const records = parseResultManifest(content);
   if (records.length === 0) {
     throw new Error(`Run manifest contains no result rows: ${options.indexPath}`);
@@ -13843,8 +14438,8 @@ async function loadSelectedTaskBundles(options) {
       options.sourceRunDir,
       record.task_dir && `${record.task_dir}/${TASK_TARGETS_FILENAME}`
     );
-    const taskDir = resolveRelativeRunPath(options.sourceRunDir, record.task_dir) ?? (evalPath ? path24.dirname(evalPath) : void 0);
-    const artifactDir = resolveRelativeRunPath(options.sourceRunDir, record.artifact_dir) ?? (taskDir ? path24.dirname(taskDir) : void 0);
+    const taskDir = resolveRelativeRunPath(options.sourceRunDir, record.task_dir) ?? (evalPath ? path26.dirname(evalPath) : void 0);
+    const artifactDir = resolveRelativeRunPath(options.sourceRunDir, record.artifact_dir) ?? (taskDir ? path26.dirname(taskDir) : void 0);
     if (!evalPath || !targetsPath || !taskDir || !artifactDir) {
       throw new Error(
         `Selected result ${recordLabel} is missing task bundle paths. Re-run requires task/EVAL.yaml and task/targets.yaml.`
@@ -13874,14 +14469,14 @@ async function loadSelectedTaskBundles(options) {
 function buildSourceMetadataByEvalFile(sourceRunDir, indexPath, selected) {
   return new Map(
     selected.map((bundle) => [
-      path24.resolve(bundle.evalPath),
+      path26.resolve(bundle.evalPath),
       {
         rerunSource: {
           mode: "rerun",
-          sourceRunDir: path24.resolve(sourceRunDir),
-          sourceIndexPath: path24.resolve(indexPath),
-          sourceArtifactDir: path24.resolve(bundle.artifactDir),
-          sourceTaskDir: path24.resolve(bundle.taskDir),
+          sourceRunDir: path26.resolve(sourceRunDir),
+          sourceIndexPath: path26.resolve(indexPath),
+          sourceArtifactDir: path26.resolve(bundle.artifactDir),
+          sourceTaskDir: path26.resolve(bundle.taskDir),
           sourceTestId: bundle.testId,
           sourceTarget: bundle.sourceTarget,
           sourceTimestamp: bundle.record.timestamp
@@ -13952,7 +14547,7 @@ var runsRerunCommand = command({
   handler: async (args) => {
     const cwd = process.cwd();
     const indexPath = resolveRunManifestPath(resolveSourcePath(cwd, args.runDir));
-    const sourceRunDir = path24.dirname(indexPath);
+    const sourceRunDir = path26.dirname(indexPath);
     await loadEnvFile2(args.envFile, cwd, args.verbose);
     const selected = await loadSelectedTaskBundles({
       indexPath,
@@ -13961,10 +14556,10 @@ var runsRerunCommand = command({
       sourceTargets: args.sourceTarget
     });
     const targetOverrides = args.target;
-    const outputDir = args.output ? path24.resolve(cwd, args.output) : defaultOutputDir(cwd, sourceRunDir, selected, args.experiment);
+    const outputDir = args.output ? path26.resolve(cwd, args.output) : defaultOutputDir(cwd, sourceRunDir, selected, args.experiment);
     assertOutputIsSeparate(outputDir, forbiddenOutputRoots(sourceRunDir, selected));
     if (args.targets) {
-      const overrideTargetsPath = path24.resolve(cwd, args.targets);
+      const overrideTargetsPath = path26.resolve(cwd, args.targets);
       await ensureFile(overrideTargetsPath, "Target override");
       const targetNames = targetOverrides.length > 0 ? targetOverrides : selected.map((bundle) => bundle.taskTarget);
       await validateTargetFile(overrideTargetsPath, targetNames, "Target override");
@@ -13988,7 +14583,7 @@ var runsRerunCommand = command({
       testFiles: selected.map((bundle) => bundle.evalPath),
       rawOptions: {
         target: targetOverrides,
-        targets: args.targets ? path24.resolve(cwd, args.targets) : void 0,
+        targets: args.targets ? path26.resolve(cwd, args.targets) : void 0,
         output: outputDir,
         experiment: args.experiment ?? "rerun",
         workers: args.workers,
@@ -14219,13 +14814,13 @@ var selfCommand = subcommands({
 
 // src/commands/skills/index.ts
 import { existsSync as existsSync18, readFileSync as readFileSync13, readdirSync as readdirSync5 } from "node:fs";
-import path25 from "node:path";
+import path27 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function isValidSkillsDir(dir) {
   if (!existsSync18(dir)) return false;
   try {
     return readdirSync5(dir, { withFileTypes: true }).some(
-      (e) => e.isDirectory() && existsSync18(path25.join(dir, e.name, "SKILL.md"))
+      (e) => e.isDirectory() && existsSync18(path27.join(dir, e.name, "SKILL.md"))
     );
   } catch {
     return false;
@@ -14233,15 +14828,15 @@ function isValidSkillsDir(dir) {
 }
 function findSkillsDir() {
   const selfFile = fileURLToPath4(import.meta.url);
-  let dir = path25.dirname(selfFile);
+  let dir = path27.dirname(selfFile);
   for (let i = 0; i < 6; i++) {
-    const distCandidate = path25.join(dir, "dist", "skills");
+    const distCandidate = path27.join(dir, "dist", "skills");
     if (isValidSkillsDir(distCandidate)) return distCandidate;
-    const repoRootCandidate = path25.join(dir, "skills-data");
+    const repoRootCandidate = path27.join(dir, "skills-data");
     if (isValidSkillsDir(repoRootCandidate)) return repoRootCandidate;
-    const legacyCandidate = path25.join(dir, "skills");
+    const legacyCandidate = path27.join(dir, "skills");
     if (isValidSkillsDir(legacyCandidate)) return legacyCandidate;
-    dir = path25.dirname(dir);
+    dir = path27.dirname(dir);
   }
   return null;
 }
@@ -14260,7 +14855,7 @@ function listSkillNames(skillsDir) {
   return readdirSync5(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
 }
 function readSkillFile(skillDir, relPath) {
-  const full = path25.join(skillDir, relPath);
+  const full = path27.join(skillDir, relPath);
   if (!existsSync18(full)) return null;
   return readFileSync13(full, "utf-8");
 }
@@ -14270,9 +14865,9 @@ function collectDir(dir, prefix = "") {
   for (const entry of readdirSync5(dir, { withFileTypes: true })) {
     const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
     if (entry.isDirectory()) {
-      Object.assign(result, collectDir(path25.join(dir, entry.name), relPath));
+      Object.assign(result, collectDir(path27.join(dir, entry.name), relPath));
     } else {
-      result[relPath] = readFileSync13(path25.join(dir, entry.name), "utf-8");
+      result[relPath] = readFileSync13(path27.join(dir, entry.name), "utf-8");
     }
   }
   return result;
@@ -14282,14 +14877,14 @@ function listSkillSubdirs(skillDir) {
   return readdirSync5(skillDir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort();
 }
 function readSkill(skillsDir, name, full) {
-  const skillDir = path25.join(skillsDir, name);
+  const skillDir = path27.join(skillsDir, name);
   if (!existsSync18(skillDir)) return null;
   const content = readSkillFile(skillDir, "SKILL.md");
   if (content === null) return null;
   if (!full) return { name, content };
   const files = {};
   for (const sub of listSkillSubdirs(skillDir)) {
-    const subDir = path25.join(skillDir, sub);
+    const subDir = path27.join(skillDir, sub);
     const collected = collectDir(subDir, sub);
     Object.assign(files, collected);
   }
@@ -14299,14 +14894,14 @@ function findRefFile(skillDir, refName) {
   const candidates = refName.endsWith(".md") ? [refName] : [refName, `${refName}.md`];
   for (const sub of listSkillSubdirs(skillDir)) {
     for (const candidate of candidates) {
-      const filePath = path25.join(skillDir, sub, candidate);
+      const filePath = path27.join(skillDir, sub, candidate);
       if (existsSync18(filePath)) {
         return { relPath: `${sub}/${candidate}`, content: readFileSync13(filePath, "utf-8") };
       }
     }
   }
   for (const candidate of candidates) {
-    const filePath = path25.join(skillDir, candidate);
+    const filePath = path27.join(skillDir, candidate);
     if (existsSync18(filePath)) {
       return { relPath: candidate, content: readFileSync13(filePath, "utf-8") };
     }
@@ -14316,7 +14911,7 @@ function findRefFile(skillDir, refName) {
 function listRefFiles(skillDir) {
   const out = [];
   for (const sub of listSkillSubdirs(skillDir)) {
-    const subDir = path25.join(skillDir, sub);
+    const subDir = path27.join(skillDir, sub);
     for (const entry of readdirSync5(subDir, { withFileTypes: true })) {
       if (entry.isFile()) out.push(`${sub}/${entry.name}`);
     }
@@ -14400,7 +14995,7 @@ var skillsGetCommand = command({
         }
         process.exit(1);
       }
-      const skillDir = path25.join(skillsDir, name);
+      const skillDir = path27.join(skillsDir, name);
       if (!existsSync18(skillDir)) {
         const msg = `skill '${name}' not found`;
         if (json) {
@@ -14489,7 +15084,7 @@ var skillsPathCommand = command({
   handler: ({ name }) => {
     const skillsDir = requireSkillsDir();
     if (name) {
-      const skillDir = path25.join(skillsDir, name);
+      const skillDir = path27.join(skillsDir, name);
       if (!existsSync18(skillDir)) {
         console.error(`Error: skill '${name}' not found`);
         process.exit(1);
@@ -14512,7 +15107,7 @@ var skillsCommand = subcommands({
 
 // src/commands/transpile/index.ts
 import { writeFileSync as writeFileSync7 } from "node:fs";
-import path26 from "node:path";
+import path28 from "node:path";
 var transpileCommand = command({
   name: "transpile",
   description: "Convert an EVAL.yaml file to Agent Skills evals.json format",
@@ -14536,7 +15131,7 @@ var transpileCommand = command({
   handler: async ({ input, outDir, stdout }) => {
     let result;
     try {
-      result = transpileEvalYamlFile(path26.resolve(input));
+      result = transpileEvalYamlFile(path28.resolve(input));
     } catch (error) {
       console.error(`Error: ${error.message}`);
       process.exit(1);
@@ -14560,11 +15155,11 @@ var transpileCommand = command({
       process.stdout.write("\n");
       return;
     }
-    const outputDir = outDir ? path26.resolve(outDir) : path26.dirname(path26.resolve(input));
+    const outputDir = outDir ? path28.resolve(outDir) : path28.dirname(path28.resolve(input));
     const fileNames = getOutputFilenames(result);
     for (const [skill, evalsJson] of result.files) {
       const fileName = fileNames.get(skill) ?? "evals.json";
-      const outputPath = path26.join(outputDir, fileName);
+      const outputPath = path28.join(outputDir, fileName);
       writeFileSync7(outputPath, `${JSON.stringify(evalsJson, null, 2)}
 `);
       console.log(`Transpiled to ${outputPath}`);
@@ -14573,7 +15168,7 @@ var transpileCommand = command({
 });
 
 // src/commands/trend/index.ts
-import path27 from "node:path";
+import path29 from "node:path";
 var colors2 = {
   reset: "\x1B[0m",
   bold: "\x1B[1m",
@@ -14623,7 +15218,7 @@ function colorizeSlope(value) {
 }
 function ensureTrendIndexPath(source, cwd) {
   const resolved = resolveResultSourcePath(source, cwd);
-  if (path27.basename(resolved) !== RESULT_INDEX_FILENAME) {
+  if (path29.basename(resolved) !== RESULT_INDEX_FILENAME) {
     throw new Error(
       `Unsupported result source for trend: ${source}. Use a run workspace directory or ${RESULT_INDEX_FILENAME} manifest.`
     );
@@ -14643,7 +15238,7 @@ function resolveTrendSources(cwd, sources, last) {
   if (last < 2) {
     throw new Error("--last must be at least 2");
   }
-  const metas = listResultFiles(cwd).filter((meta) => path27.basename(meta.path) === RESULT_INDEX_FILENAME).slice(0, last);
+  const metas = listResultFiles(cwd).filter((meta) => path29.basename(meta.path) === RESULT_INDEX_FILENAME).slice(0, last);
   if (metas.length < 2) {
     throw new Error(
       "Trend analysis requires at least 2 canonical run workspaces in .agentv/results/runs/"
@@ -14658,10 +15253,10 @@ function getRunLabel(sourcePath, timestamp) {
   if (timestamp) {
     return timestamp;
   }
-  return path27.basename(path27.dirname(sourcePath));
+  return path29.basename(path29.dirname(sourcePath));
 }
 function getRunSortKey(sourcePath, timestamp) {
-  return timestamp ?? path27.basename(path27.dirname(sourcePath));
+  return timestamp ?? path29.basename(path29.dirname(sourcePath));
 }
 function mean2(values) {
   return values.reduce((sum, value) => sum + value, 0) / values.length;
@@ -15041,8 +15636,8 @@ function isTTY() {
 
 // src/commands/validate/validate-files.ts
 import { constants as constants2 } from "node:fs";
-import { access as access2, readdir as readdir4, stat } from "node:fs/promises";
-import path28 from "node:path";
+import { access as access2, readdir as readdir4, stat as stat2 } from "node:fs/promises";
+import path30 from "node:path";
 import fg3 from "fast-glob";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
@@ -15057,7 +15652,7 @@ async function validateFiles(paths) {
   };
 }
 async function validateSingleFile(filePath) {
-  const absolutePath = path28.resolve(filePath);
+  const absolutePath = path30.resolve(filePath);
   const fileType = await detectFileType(absolutePath);
   let result;
   if (fileType === "eval") {
@@ -15101,10 +15696,10 @@ async function validateSingleFile(filePath) {
 async function expandPaths(paths) {
   const expanded = /* @__PURE__ */ new Set();
   for (const inputPath of paths) {
-    const absolutePath = path28.resolve(inputPath);
+    const absolutePath = path30.resolve(inputPath);
     try {
       await access2(absolutePath, constants2.F_OK);
-      const stats = await stat(absolutePath);
+      const stats = await stat2(absolutePath);
       if (stats.isFile()) {
         if (isYamlFile(absolutePath)) expanded.add(absolutePath);
         continue;
@@ -15129,7 +15724,7 @@ async function expandPaths(paths) {
     if (yamlMatches.length === 0) {
       console.warn(`Warning: No YAML files matched pattern: ${inputPath}`);
     }
-    for (const f of yamlMatches) expanded.add(path28.normalize(f));
+    for (const f of yamlMatches) expanded.add(path30.normalize(f));
   }
   const sorted = Array.from(expanded);
   sorted.sort();
@@ -15140,7 +15735,7 @@ async function findYamlFiles(dirPath) {
   try {
     const entries2 = await readdir4(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path28.join(dirPath, entry.name);
+      const fullPath = path30.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -15157,11 +15752,11 @@ async function findYamlFiles(dirPath) {
   return results;
 }
 function isYamlFile(filePath) {
-  const ext = path28.extname(filePath).toLowerCase();
+  const ext = path30.extname(filePath).toLowerCase();
   return ext === ".yaml" || ext === ".yml";
 }
 function isEvalYamlFile(filePath) {
-  const lower = path28.basename(filePath).toLowerCase();
+  const lower = path30.basename(filePath).toLowerCase();
   return lower.endsWith(".eval.yaml") || lower.endsWith(".eval.yml");
 }
 
@@ -15217,8 +15812,8 @@ var validateCommand = command({
 
 // src/commands/workspace/clean.ts
 import { existsSync as existsSync19 } from "node:fs";
-import { readFile as readFile8, readdir as readdir5, rm } from "node:fs/promises";
-import path29 from "node:path";
+import { readFile as readFile9, readdir as readdir5, rm as rm2 } from "node:fs/promises";
+import path31 from "node:path";
 async function confirm2(message) {
   const readline4 = await import("node:readline");
   const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
@@ -15254,10 +15849,10 @@ var cleanCommand = command({
       const poolDirs = entries2.filter((e) => e.isDirectory());
       const matchingDirs = [];
       for (const dir of poolDirs) {
-        const poolDir = path29.join(poolRoot, dir.name);
-        const metadataPath = path29.join(poolDir, "metadata.json");
+        const poolDir = path31.join(poolRoot, dir.name);
+        const metadataPath = path31.join(poolDir, "metadata.json");
         try {
-          const raw = await readFile8(metadataPath, "utf-8");
+          const raw = await readFile9(metadataPath, "utf-8");
           const metadata = JSON.parse(raw);
           const hasRepo = metadata.repos?.some((r) => {
             const value = r.repo ?? (r.source?.type === "git" ? r.source.url : r.source?.path);
@@ -15283,8 +15878,8 @@ var cleanCommand = command({
         }
       }
       for (const dir of matchingDirs) {
-        await rm(dir, { recursive: true, force: true });
-        console.log(`Removed: ${path29.basename(dir).slice(0, 12)}...`);
+        await rm2(dir, { recursive: true, force: true });
+        console.log(`Removed: ${path31.basename(dir).slice(0, 12)}...`);
       }
       console.log("Done.");
     } else {
@@ -15295,14 +15890,14 @@ var cleanCommand = command({
           return;
         }
       }
-      await rm(poolRoot, { recursive: true, force: true });
+      await rm2(poolRoot, { recursive: true, force: true });
       console.log("Workspace pool cleaned.");
     }
   }
 });
 
 // src/commands/workspace/deps.ts
-import path30 from "node:path";
+import path32 from "node:path";
 var depsCommand = command({
   name: "deps",
   description: "Scan eval files and list git repo dependencies needed by workspaces",
@@ -15326,7 +15921,7 @@ var depsCommand = command({
     const resolvedPaths = await resolveEvalPaths(evalPaths, cwd);
     const result = await scanRepoDeps(resolvedPaths);
     for (const err2 of result.errors) {
-      console.error(`error: ${path30.relative(cwd, err2.file)}: ${err2.message}`);
+      console.error(`error: ${path32.relative(cwd, err2.file)}: ${err2.message}`);
     }
     if (result.errors.length > 0) {
       process.exit(1);
@@ -15337,7 +15932,7 @@ var depsCommand = command({
         ...r.ref !== void 0 && { ref: r.ref },
         ...r.sparse !== void 0 && { sparse: r.sparse },
         ...r.ancestor !== void 0 && { ancestor: r.ancestor },
-        ...usedBy && { used_by: r.usedBy.map((p) => path30.relative(cwd, p)) }
+        ...usedBy && { used_by: r.usedBy.map((p) => path32.relative(cwd, p)) }
       }))
     };
     console.log(JSON.stringify(output, null, 2));
@@ -15346,18 +15941,18 @@ var depsCommand = command({
 
 // src/commands/workspace/list.ts
 import { existsSync as existsSync20 } from "node:fs";
-import { readFile as readFile9, readdir as readdir6, stat as stat2 } from "node:fs/promises";
-import path31 from "node:path";
+import { readFile as readFile10, readdir as readdir6, stat as stat3 } from "node:fs/promises";
+import path33 from "node:path";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
     const entries2 = await readdir6(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
-      const fullPath = path31.join(dirPath, entry.name);
+      const fullPath = path33.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         totalSize += await getDirectorySize(fullPath);
       } else {
-        const stats = await stat2(fullPath);
+        const stats = await stat3(fullPath);
         totalSize += stats.size;
       }
     }
@@ -15388,14 +15983,14 @@ var listCommand = command({
       return;
     }
     for (const dir of poolDirs) {
-      const poolDir = path31.join(poolRoot, dir.name);
+      const poolDir = path33.join(poolRoot, dir.name);
       const fingerprint = dir.name;
       const poolEntries = await readdir6(poolDir, { withFileTypes: true });
       const slots = poolEntries.filter((e) => e.isDirectory() && e.name.startsWith("slot-"));
-      const metadataPath = path31.join(poolDir, "metadata.json");
+      const metadataPath = path33.join(poolDir, "metadata.json");
       let metadata = null;
       try {
-        const raw = await readFile9(metadataPath, "utf-8");
+        const raw = await readFile10(metadataPath, "utf-8");
         metadata = JSON.parse(raw);
       } catch {
       }
@@ -15433,16 +16028,16 @@ var workspaceCommand = subcommands({
 
 // src/update-check.ts
 import { spawn as spawn3 } from "node:child_process";
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 import { join as join6 } from "node:path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var CONFIG_DIR = getAgentvConfigDir();
 var CACHE_FILE = "version-check.json";
 var NPM_REGISTRY_BASE2 = "https://registry.npmjs.org/agentv/";
-async function getCachedUpdateInfo(path33) {
-  const filePath = path33 ?? join6(CONFIG_DIR, CACHE_FILE);
+async function getCachedUpdateInfo(path35) {
+  const filePath = path35 ?? join6(CONFIG_DIR, CACHE_FILE);
   try {
-    const raw = await readFile10(filePath, "utf-8");
+    const raw = await readFile11(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.latestVersion === "string" && typeof data.lastCheckedAt === "string") {
       return data;
@@ -15527,6 +16122,7 @@ var app = subcommands({
   cmds: {
     dashboard: resultsServeCommand,
     eval: evalCommand,
+    grade: gradeCommand,
     import: importCommand,
     compare: compareCommand,
     convert: convertCommand,
@@ -15534,6 +16130,7 @@ var app = subcommands({
     doctor: doctorCommand,
     init: initCmdTsCommand,
     pipeline: pipelineCommand,
+    prepare: prepareCommand,
     results: resultsCommand,
     runs: runsCommand,
     self: selfCommand,
@@ -15556,8 +16153,10 @@ var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
   "create",
   "dashboard",
   "doctor",
+  "grade",
   "init",
   "pipeline",
+  "prepare",
   "results",
   "runs",
   "self",
@@ -15617,7 +16216,7 @@ ${updateNotice}
   }
   const cwd = process.cwd();
   const repoRoot = await findRepoRoot(cwd);
-  const sessionConfig = await loadConfig(path32.join(cwd, "_"), repoRoot);
+  const sessionConfig = await loadConfig(path34.join(cwd, "_"), repoRoot);
   const beforeSessionCommand = sessionConfig?.hooks?.before_session;
   if (beforeSessionCommand) {
     runBeforeSessionHook(beforeSessionCommand);
@@ -15631,4 +16230,4 @@ export {
   preprocessArgv,
   runCli
 };
-//# sourceMappingURL=chunk-S2JJCLHV.js.map
+//# sourceMappingURL=chunk-6FXICR66.js.map