agentv 2.1.1 → 2.5.1

package/dist/{chunk-HTTN5OWL.js → chunk-XREH4WAJ.js}

@@ -373,9 +373,9 @@ var compareCommand = command({
 
 // src/commands/convert/index.ts
 import { readFileSync as readFileSync2, writeFileSync } from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 
-// ../../packages/core/dist/chunk-KDEP4I7G.js
+// ../../packages/core/dist/chunk-RP3M7COZ.js
 import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
@@ -859,8 +859,8 @@ function getErrorMap() {
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path29, errorMaps, issueData } = params;
-  const fullPath = [...path29, ...issueData.path || []];
+  const { data, path: path30, errorMaps, issueData } = params;
+  const fullPath = [...path30, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -976,11 +976,11 @@ var errorUtil;
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path29, key2) {
+  constructor(parent, value, path30, key2) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path29;
+    this._path = path30;
     this._key = key2;
   }
   get path() {
@@ -4422,7 +4422,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../../packages/core/dist/chunk-KDEP4I7G.js
+// ../../packages/core/dist/chunk-RP3M7COZ.js
 async function fileExists(filePath) {
   try {
     await access(filePath, constants.F_OK);
@@ -5418,8 +5418,9 @@ function isAgentProvider(provider) {
 }
 
 // ../../packages/core/dist/index.js
-import { readFile as readFile5 } from "node:fs/promises";
-import path62 from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import path72 from "node:path";
+import micromatch3 from "micromatch";
 import { parse as parse22 } from "yaml";
 import { readFile as readFile4 } from "node:fs/promises";
 import path22 from "node:path";
@@ -5430,10 +5431,14 @@ import { access as access3 } from "node:fs/promises";
 import path13 from "node:path";
 import path32 from "node:path";
 import { readFile as readFile22 } from "node:fs/promises";
-import { readFile as readFile32 } from "node:fs/promises";
-import path42 from "node:path";
 import { readFile as readFile42 } from "node:fs/promises";
 import path52 from "node:path";
+import micromatch2 from "micromatch";
+import { parse as parseYaml } from "yaml";
+import { readFile as readFile32 } from "node:fs/promises";
+import path42 from "node:path";
+import { readFile as readFile5 } from "node:fs/promises";
+import path62 from "node:path";
 
 // ../../node_modules/.bun/@ai-sdk+provider@2.0.0/node_modules/@ai-sdk/provider/dist/index.mjs
 var marker = "vercel.ai.error";
@@ -6523,10 +6528,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path29) {
-  if (!path29)
+function getElementAtPath(obj, path30) {
+  if (!path30)
     return obj;
-  return path29.reduce((acc, key2) => acc?.[key2], obj);
+  return path30.reduce((acc, key2) => acc?.[key2], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -6846,11 +6851,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path29, issues) {
+function prefixIssues(path30, issues) {
   return issues.map((iss) => {
     var _a17;
     (_a17 = iss).path ?? (_a17.path = []);
-    iss.path.unshift(path29);
+    iss.path.unshift(path30);
     return iss;
   });
 }
@@ -6987,7 +6992,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path29 = []) => {
+  const processError = (error41, path30 = []) => {
     var _a17, _b8;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -6997,7 +7002,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path29, ...issue2.path];
+        const fullpath = [...path30, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -7027,9 +7032,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path29) {
+function toDotPath(path30) {
   const segs = [];
-  for (const seg of path29) {
+  for (const seg of path30) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -26582,14 +26587,14 @@ function createAzure(options = {}) {
     description: "Azure OpenAI resource name"
   });
   const apiVersion = (_a17 = options.apiVersion) != null ? _a17 : "v1";
-  const url2 = ({ path: path29, modelId }) => {
+  const url2 = ({ path: path30, modelId }) => {
     var _a24;
     const baseUrlPrefix = (_a24 = options.baseURL) != null ? _a24 : `https://${getResourceName()}.openai.azure.com/openai`;
     let fullUrl;
     if (options.useDeploymentBasedUrls) {
-      fullUrl = new URL(`${baseUrlPrefix}/deployments/${modelId}${path29}`);
+      fullUrl = new URL(`${baseUrlPrefix}/deployments/${modelId}${path30}`);
     } else {
-      fullUrl = new URL(`${baseUrlPrefix}/v1${path29}`);
+      fullUrl = new URL(`${baseUrlPrefix}/v1${path30}`);
     }
     fullUrl.searchParams.set("api-version", apiVersion);
     return fullUrl.toString();
@@ -33025,27 +33030,27 @@ import { randomUUID } from "node:crypto";
 import { createWriteStream } from "node:fs";
 import { mkdir as mkdir4, mkdtemp, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
 import { tmpdir } from "node:os";
+import path92 from "node:path";
 import path82 from "node:path";
-import path72 from "node:path";
 import { exec as execWithCallback } from "node:child_process";
 import fs from "node:fs/promises";
 import os2 from "node:os";
-import path92 from "node:path";
+import path102 from "node:path";
 import { promisify as promisify2 } from "node:util";
 import { exec as execCallback, spawn as spawn22 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { constants as constants22, createWriteStream as createWriteStream2 } from "node:fs";
 import { access as access22, mkdir as mkdir22, mkdtemp as mkdtemp2, rm as rm22, writeFile as writeFile22 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import path102 from "node:path";
+import path112 from "node:path";
 import { promisify as promisify22 } from "node:util";
 import { spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { createWriteStream as createWriteStream3 } from "node:fs";
 import { mkdir as mkdir32, mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile32 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
-import path112 from "node:path";
 import path122 from "node:path";
+import path132 from "node:path";
 
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/vscode/agentDispatch.js
 import { stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
@@ -35067,13 +35072,14 @@ async function provisionSubagents(options) {
 
 // ../../packages/core/dist/index.js
 import { constants as constants32 } from "node:fs";
-import { access as access32, readFile as readFile6 } from "node:fs/promises";
-import path132 from "node:path";
+import { access as access32, readFile as readFile7 } from "node:fs/promises";
+import path14 from "node:path";
 import { parse as parse32 } from "yaml";
 import { randomBytes } from "node:crypto";
 import { createServer } from "node:http";
 import { createHash } from "node:crypto";
-import path14 from "node:path";
+import path15 from "node:path";
+import micromatch4 from "micromatch";
 var TEST_MESSAGE_ROLE_VALUES = ["system", "user", "assistant", "tool"];
 var TEST_MESSAGE_ROLE_SET = new Set(TEST_MESSAGE_ROLE_VALUES);
 function isTestMessageRole(value) {
@@ -35449,11 +35455,11 @@ async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId
           );
         }
       }
-      const knownProps = /* @__PURE__ */ new Set(["name", "type", "script", "cwd", "weight", "target"]);
-      const config2 = {};
+      const knownProps2 = /* @__PURE__ */ new Set(["name", "type", "script", "cwd", "weight", "target"]);
+      const config22 = {};
       for (const [key2, value] of Object.entries(rawEvaluator)) {
-        if (!knownProps.has(key2) && value !== void 0) {
-          config2[key2] = value;
+        if (!knownProps2.has(key2) && value !== void 0) {
+          config22[key2] = value;
         }
       }
       evaluators.push({
@@ -35463,7 +35469,7 @@ async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId
         cwd,
         resolvedCwd,
         ...weight2 !== void 0 ? { weight: weight2 } : {},
-        ...Object.keys(config2).length > 0 ? { config: config2 } : {},
+        ...Object.keys(config22).length > 0 ? { config: config22 } : {},
         ...targetConfig !== void 0 ? { target: targetConfig } : {}
       });
       continue;
@@ -35628,7 +35634,7 @@ async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId
         continue;
       }
       const weight2 = validateWeight(rawEvaluator.weight, name16, evalId);
-      const config2 = {
+      const config22 = {
         name: name16,
         type: "tool_trajectory",
         mode,
@@ -35636,7 +35642,7 @@ async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId
         ...expected ? { expected } : {},
         ...weight2 !== void 0 ? { weight: weight2 } : {}
       };
-      evaluators.push(config2);
+      evaluators.push(config22);
       continue;
     }
     if (typeValue === "field_accuracy") {
@@ -35773,9 +35779,33 @@ async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId
       });
       continue;
     }
-    const prompt = asString(rawEvaluator.prompt);
+    const rawPrompt = rawEvaluator.prompt;
+    let prompt;
     let promptPath;
-    if (prompt) {
+    let resolvedPromptScript;
+    let promptScriptConfig;
+    if (isJsonObject2(rawPrompt)) {
+      const scriptArray = asStringArray(
+        rawPrompt.script,
+        `prompt.script for evaluator '${name16}' in '${evalId}'`
+      );
+      if (!scriptArray) {
+        throw new Error(`Evaluator '${name16}' in '${evalId}': prompt object requires script array`);
+      }
+      const scriptPath = scriptArray[scriptArray.length - 1];
+      const resolved = await resolveFileReference2(scriptPath, searchRoots);
+      if (resolved.resolvedPath) {
+        resolvedPromptScript = [...scriptArray.slice(0, -1), path32.resolve(resolved.resolvedPath)];
+      } else {
+        throw new Error(
+          `Evaluator '${name16}' in '${evalId}': prompt script file not found: ${resolved.displayPath}`
+        );
+      }
+      if (isJsonObject2(rawPrompt.config)) {
+        promptScriptConfig = rawPrompt.config;
+      }
+    } else if (typeof rawPrompt === "string") {
+      prompt = rawPrompt;
       const resolved = await resolveFileReference2(prompt, searchRoots);
       if (resolved.resolvedPath) {
         promptPath = path32.resolve(resolved.resolvedPath);
@@ -35794,12 +35824,7 @@ async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId
     }
     const _model = asString(rawEvaluator.model);
     const rawRubrics = rawEvaluator.rubrics;
-    const parsedRubrics = Array.isArray(rawRubrics) ? rawRubrics.filter((r) => isJsonObject2(r)).map((rubric, index) => ({
-      id: asString(rubric.id) ?? `rubric-${index + 1}`,
-      description: asString(rubric.description) ?? "",
-      weight: typeof rubric.weight === "number" ? rubric.weight : 1,
-      required: typeof rubric.required === "boolean" ? rubric.required : true
-    })).filter((r) => r.description.length > 0) : void 0;
+    const parsedRubrics = Array.isArray(rawRubrics) ? parseRubricItems(rawRubrics, name16, evalId) : void 0;
     if (typeValue === "rubric") {
       if (!parsedRubrics) {
         logWarning2(`Skipping rubric evaluator '${name16}' in '${evalId}': missing rubrics array`);
@@ -35819,13 +35844,26 @@ async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId
       continue;
     }
     const weight = validateWeight(rawEvaluator.weight, name16, evalId);
+    const knownProps = /* @__PURE__ */ new Set(["name", "type", "prompt", "model", "rubrics", "weight", "config"]);
+    const config2 = {};
+    for (const [key2, value] of Object.entries(rawEvaluator)) {
+      if (!knownProps.has(key2) && value !== void 0) {
+        config2[key2] = value;
+      }
+    }
+    const topLevelConfig = isJsonObject2(rawEvaluator.config) ? rawEvaluator.config : {};
+    const mergedConfig = { ...config2, ...topLevelConfig };
+    const finalConfig = promptScriptConfig ?? (Object.keys(mergedConfig).length > 0 ? mergedConfig : void 0);
     evaluators.push({
       name: name16,
       type: "llm_judge",
       prompt,
       promptPath,
+      ...promptPath ? { resolvedPromptPath: promptPath } : {},
+      ...resolvedPromptScript ? { resolvedPromptScript } : {},
       ...parsedRubrics && parsedRubrics.length > 0 ? { rubrics: parsedRubrics } : {},
-      ...weight !== void 0 ? { weight } : {}
+      ...weight !== void 0 ? { weight } : {},
+      ...finalConfig ? { config: finalConfig } : {}
     });
   }
   return evaluators.length > 0 ? evaluators : void 0;
@@ -35912,6 +35950,185 @@ var VALID_FIELD_AGGREGATION_TYPES = /* @__PURE__ */ new Set(["weighted_average",
 function isValidFieldAggregationType(value) {
   return typeof value === "string" && VALID_FIELD_AGGREGATION_TYPES.has(value);
 }
+function parseRubricItems(rawRubrics, evaluatorName, evalId) {
+  const items = [];
+  for (const [index, rawRubric] of rawRubrics.entries()) {
+    if (!isJsonObject2(rawRubric)) {
+      logWarning2(
+        `Skipping invalid rubric entry at index ${index} in evaluator '${evaluatorName}' (expected object)`
+      );
+      continue;
+    }
+    const id = asString(rawRubric.id) ?? `rubric-${index + 1}`;
+    const expectedOutcome = asString(rawRubric.expected_outcome) ?? asString(rawRubric.description) ?? "";
+    const weight = typeof rawRubric.weight === "number" ? rawRubric.weight : 1;
+    let requiredMinScore;
+    let required2;
+    if (typeof rawRubric.required_min_score === "number") {
+      const minScore = rawRubric.required_min_score;
+      if (!Number.isInteger(minScore) || minScore < 0 || minScore > 10) {
+        throw new Error(
+          `Invalid required_min_score for rubric '${id}' in evaluator '${evaluatorName}' in '${evalId}': must be an integer 0-10 (got ${minScore})`
+        );
+      }
+      requiredMinScore = minScore;
+    }
+    if (typeof rawRubric.required === "boolean") {
+      required2 = rawRubric.required;
+    }
+    let scoreRanges;
+    const rawScoreRanges = rawRubric.score_ranges;
+    if (rawScoreRanges !== void 0) {
+      if (!Array.isArray(rawScoreRanges)) {
+        throw new Error(
+          `Invalid score_ranges for rubric '${id}' in evaluator '${evaluatorName}' in '${evalId}': must be an array`
+        );
+      }
+      scoreRanges = parseScoreRanges(rawScoreRanges, id, evaluatorName, evalId);
+      items.push({
+        id,
+        weight,
+        ...expectedOutcome.length > 0 ? { expected_outcome: expectedOutcome } : {},
+        ...required2 !== void 0 ? { required: required2 } : {},
+        ...requiredMinScore !== void 0 ? { required_min_score: requiredMinScore } : {},
+        score_ranges: scoreRanges
+      });
+    } else {
+      if (expectedOutcome.length === 0) {
+        logWarning2(
+          `Skipping rubric '${id}' in evaluator '${evaluatorName}' in '${evalId}': missing expected_outcome`
+        );
+        continue;
+      }
+      items.push({
+        id,
+        expected_outcome: expectedOutcome,
+        weight,
+        // Default to required: true if not specified (backward compatibility)
+        required: required2 ?? true,
+        ...requiredMinScore !== void 0 ? { required_min_score: requiredMinScore } : {}
+      });
+    }
+  }
+  return items.length > 0 ? items : void 0;
+}
+function parseScoreRanges(rawRanges, rubricId, evaluatorName, evalId) {
+  const ranges = [];
+  for (const [index, rawRange] of rawRanges.entries()) {
+    if (!isJsonObject2(rawRange)) {
+      throw new Error(
+        `Invalid score_range entry at index ${index} for rubric '${rubricId}' in evaluator '${evaluatorName}' in '${evalId}': expected object`
+      );
+    }
+    const scoreRangeValue = rawRange.score_range;
+    if (!Array.isArray(scoreRangeValue) || scoreRangeValue.length !== 2 || typeof scoreRangeValue[0] !== "number" || typeof scoreRangeValue[1] !== "number") {
+      throw new Error(
+        `Invalid score_range at index ${index} for rubric '${rubricId}' in evaluator '${evaluatorName}' in '${evalId}': must be [min, max] array of two numbers`
+      );
+    }
+    const [min, max] = scoreRangeValue;
+    if (!Number.isInteger(min) || !Number.isInteger(max)) {
+      throw new Error(
+        `Invalid score_range at index ${index} for rubric '${rubricId}' in evaluator '${evaluatorName}' in '${evalId}': values must be integers (got [${min}, ${max}])`
+      );
+    }
+    if (min < 0 || min > 10 || max < 0 || max > 10) {
+      throw new Error(
+        `Invalid score_range at index ${index} for rubric '${rubricId}' in evaluator '${evaluatorName}' in '${evalId}': values must be 0-10 (got [${min}, ${max}])`
+      );
+    }
+    if (min > max) {
+      throw new Error(
+        `Invalid score_range at index ${index} for rubric '${rubricId}' in evaluator '${evaluatorName}' in '${evalId}': min must be <= max (got [${min}, ${max}])`
+      );
+    }
+    const expectedOutcome = asString(rawRange.expected_outcome) ?? asString(rawRange.description) ?? "";
+    if (expectedOutcome.length === 0) {
+      throw new Error(
+        `Missing expected_outcome for score_range [${min}, ${max}] in rubric '${rubricId}' in evaluator '${evaluatorName}' in '${evalId}'`
+      );
+    }
+    ranges.push({
+      score_range: [min, max],
+      expected_outcome: expectedOutcome
+    });
+  }
+  const sortedRanges = [...ranges].sort((a, b) => a.score_range[0] - b.score_range[0]);
+  for (let i = 1; i < sortedRanges.length; i++) {
+    const prev = sortedRanges[i - 1];
+    const curr = sortedRanges[i];
+    if (curr.score_range[0] <= prev.score_range[1]) {
+      throw new Error(
+        `Overlapping score_ranges in rubric '${rubricId}' in evaluator '${evaluatorName}' in '${evalId}': [${prev.score_range[0]}, ${prev.score_range[1]}] overlaps with [${curr.score_range[0]}, ${curr.score_range[1]}]`
+      );
+    }
+  }
+  const covered = /* @__PURE__ */ new Set();
+  for (const range of ranges) {
+    for (let i = range.score_range[0]; i <= range.score_range[1]; i++) {
+      covered.add(i);
+    }
+  }
+  const missing = [];
+  for (let i = 0; i <= 10; i++) {
+    if (!covered.has(i)) {
+      missing.push(i);
+    }
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      `Incomplete score_ranges coverage in rubric '${rubricId}' in evaluator '${evaluatorName}' in '${evalId}': missing coverage for scores: ${missing.join(", ")}. Ranges must cover all integers 0-10.`
+    );
+  }
+  return ranges;
+}
+function parseInlineRubrics(rawRubrics) {
+  const rubricItems = rawRubrics.filter((r) => isJsonObject2(r) || typeof r === "string").map((rubric, index) => {
+    if (typeof rubric === "string") {
+      return {
+        id: `rubric-${index + 1}`,
+        expected_outcome: rubric,
+        weight: 1,
+        required: true
+      };
+    }
+    const expectedOutcome = asString(rubric.expected_outcome) ?? asString(rubric.description) ?? "";
+    const rawScoreRanges = rubric.score_ranges;
+    const scoreRanges = Array.isArray(rawScoreRanges) && rawScoreRanges.length > 0 ? rawScoreRanges.filter((r) => isJsonObject2(r)).map((range) => ({
+      score_range: Array.isArray(range.score_range) ? range.score_range : [0, 10],
+      expected_outcome: asString(range.expected_outcome) ?? asString(range.description) ?? ""
+    })).filter((r) => r.expected_outcome.length > 0) : void 0;
+    const baseRubric = {
+      id: asString(rubric.id) ?? `rubric-${index + 1}`,
+      weight: typeof rubric.weight === "number" ? rubric.weight : 1
+    };
+    if (scoreRanges && scoreRanges.length > 0) {
+      return {
+        ...baseRubric,
+        ...expectedOutcome.length > 0 ? { expected_outcome: expectedOutcome } : {},
+        ...typeof rubric.required === "boolean" ? { required: rubric.required } : {},
+        ...typeof rubric.required_min_score === "number" ? { required_min_score: rubric.required_min_score } : {},
+        score_ranges: scoreRanges
+      };
+    }
+    return {
+      ...baseRubric,
+      expected_outcome: expectedOutcome,
+      required: typeof rubric.required === "boolean" ? rubric.required : true,
+      ...typeof rubric.required_min_score === "number" ? { required_min_score: rubric.required_min_score } : {}
+    };
+  }).filter(
+    (r) => r.expected_outcome && r.expected_outcome.length > 0 || "score_ranges" in r && r.score_ranges
+  );
+  if (rubricItems.length === 0) {
+    return void 0;
+  }
+  return {
+    name: "rubric",
+    type: "llm_judge",
+    rubrics: rubricItems
+  };
+}
 function formatFileContents(parts) {
   const fileCount = parts.filter((p) => p.isFile).length;
   if (fileCount > 0) {
@@ -36164,25 +36381,295 @@ async function processExpectedMessages(options) {
   }
   return segments;
 }
+function expandInputShorthand(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return [{ role: "user", content: value }];
+  }
+  if (Array.isArray(value)) {
+    const messages = value.filter((msg) => isTestMessage(msg));
+    return messages.length > 0 ? messages : void 0;
+  }
+  return void 0;
+}
+function expandExpectedOutputShorthand(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return [{ role: "assistant", content: value }];
+  }
+  if (Array.isArray(value)) {
+    if (value.length > 0 && isJsonObject(value[0]) && "role" in value[0]) {
+      const messages = value.filter((msg) => isTestMessage(msg));
+      return messages.length > 0 ? messages : void 0;
+    }
+    return [{ role: "assistant", content: value }];
+  }
+  if (isJsonObject(value)) {
+    if ("role" in value) {
+      return isTestMessage(value) ? [value] : void 0;
+    }
+    return [{ role: "assistant", content: value }];
+  }
+  return void 0;
+}
+function resolveInputMessages(raw) {
+  if (raw.input_messages !== void 0) {
+    if (Array.isArray(raw.input_messages)) {
+      const messages = raw.input_messages.filter((msg) => isTestMessage(msg));
+      return messages.length > 0 ? messages : void 0;
+    }
+    return void 0;
+  }
+  return expandInputShorthand(raw.input);
+}
+function resolveExpectedMessages(raw) {
+  if (raw.expected_messages !== void 0) {
+    if (Array.isArray(raw.expected_messages)) {
+      const messages = raw.expected_messages.filter(
+        (msg) => isTestMessage(msg)
+      );
+      return messages.length > 0 ? messages : void 0;
+    }
+    return void 0;
+  }
+  return expandExpectedOutputShorthand(raw.expected_output);
+}
 var ANSI_YELLOW5 = "\x1B[33m";
+var ANSI_RED = "\x1B[31m";
 var ANSI_RESET5 = "\x1B[0m";
+function detectFormat(filePath) {
+  const ext = path52.extname(filePath).toLowerCase();
+  if (ext === ".jsonl") return "jsonl";
+  if (ext === ".yaml" || ext === ".yml") return "yaml";
+  throw new Error(`Unsupported file format: '${ext}'. Supported formats: .yaml, .yml, .jsonl`);
+}
+async function loadSidecarMetadata(jsonlPath, verbose) {
+  const dir = path52.dirname(jsonlPath);
+  const base = path52.basename(jsonlPath, ".jsonl");
+  const sidecarPath = path52.join(dir, `${base}.yaml`);
+  if (!await fileExists2(sidecarPath)) {
+    if (verbose) {
+      logWarning4(`Sidecar metadata file not found: ${sidecarPath} (using defaults)`);
+    }
+    return {};
+  }
+  try {
+    const content = await readFile42(sidecarPath, "utf8");
+    const parsed = parseYaml(content);
+    if (!isJsonObject(parsed)) {
+      logWarning4(`Invalid sidecar metadata format in ${sidecarPath}`);
+      return {};
+    }
+    return {
+      description: asString4(parsed.description),
+      dataset: asString4(parsed.dataset),
+      execution: isJsonObject(parsed.execution) ? parsed.execution : void 0,
+      evaluator: parsed.evaluator
+    };
+  } catch (error40) {
+    logWarning4(`Could not read sidecar metadata from ${sidecarPath}: ${error40.message}`);
+    return {};
+  }
+}
+function parseJsonlContent(content, filePath) {
+  const lines = content.split("\n");
+  const cases = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line2 = lines[i].trim();
+    if (line2 === "") continue;
+    try {
+      const parsed = JSON.parse(line2);
+      if (!isJsonObject(parsed)) {
+        throw new Error("Expected JSON object");
+      }
+      cases.push(parsed);
+    } catch (error40) {
+      const message = error40 instanceof Error ? error40.message : String(error40);
+      throw new Error(`Line ${i + 1}: Invalid JSON - ${message}
+  File: ${filePath}`);
+    }
+  }
+  return cases;
+}
+async function loadEvalCasesFromJsonl(evalFilePath, repoRoot, options) {
+  const verbose = options?.verbose ?? false;
+  const filterPattern = options?.filter;
+  const absoluteTestPath = path52.resolve(evalFilePath);
+  const repoRootPath = resolveToAbsolutePath(repoRoot);
+  const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
+  const config2 = await loadConfig(absoluteTestPath, repoRootPath);
+  const guidelinePatterns = config2?.guideline_patterns;
+  const sidecar = await loadSidecarMetadata(absoluteTestPath, verbose);
+  const rawFile = await readFile42(absoluteTestPath, "utf8");
+  const rawCases = parseJsonlContent(rawFile, evalFilePath);
+  const fallbackDataset = path52.basename(absoluteTestPath, ".jsonl") || "eval";
+  const datasetName = sidecar.dataset && sidecar.dataset.trim().length > 0 ? sidecar.dataset : fallbackDataset;
+  const globalEvaluator = coerceEvaluator(sidecar.evaluator, "sidecar") ?? "llm_judge";
+  const globalExecution = sidecar.execution;
+  if (verbose) {
+    console.log(`
+[JSONL Dataset: ${evalFilePath}]`);
+    console.log(`  Cases: ${rawCases.length}`);
+    console.log(`  Dataset name: ${datasetName}`);
+    if (sidecar.description) {
+      console.log(`  Description: ${sidecar.description}`);
+    }
+  }
+  const results = [];
+  for (let lineIndex = 0; lineIndex < rawCases.length; lineIndex++) {
+    const evalcase = rawCases[lineIndex];
+    const lineNumber = lineIndex + 1;
+    const id = asString4(evalcase.id);
+    if (filterPattern && (!id || !micromatch2.isMatch(id, filterPattern))) {
+      continue;
+    }
+    const conversationId = asString4(evalcase.conversation_id);
+    const outcome = asString4(evalcase.expected_outcome) ?? asString4(evalcase.outcome);
+    const inputMessages = resolveInputMessages(evalcase);
+    const expectedMessages = resolveExpectedMessages(evalcase) ?? [];
+    if (!id || !outcome || !inputMessages || inputMessages.length === 0) {
+      logError(
+        `Skipping incomplete eval case at line ${lineNumber}: ${id ?? "unknown"}. Missing required fields: id, expected_outcome, and/or input_messages (or input)`
+      );
+      continue;
+    }
+    const hasExpectedMessages = expectedMessages.length > 0;
+    const guidelinePaths = [];
+    const inputTextParts = [];
+    const inputSegments = await processMessages({
+      messages: inputMessages,
+      searchRoots,
+      repoRootPath,
+      guidelinePatterns,
+      guidelinePaths,
+      textParts: inputTextParts,
+      messageType: "input",
+      verbose
+    });
+    const outputSegments = hasExpectedMessages ? await processExpectedMessages({
+      messages: expectedMessages,
+      searchRoots,
+      repoRootPath,
+      verbose
+    }) : [];
+    let referenceAnswer = "";
+    if (outputSegments.length > 0) {
+      const lastMessage = outputSegments[outputSegments.length - 1];
+      const content = lastMessage.content;
+      const toolCalls = lastMessage.tool_calls;
+      if (typeof content === "string") {
+        referenceAnswer = content;
+      } else if (content !== void 0 && content !== null) {
+        referenceAnswer = JSON.stringify(content, null, 2);
+      } else if (toolCalls !== void 0 && toolCalls !== null) {
+        referenceAnswer = JSON.stringify(toolCalls, null, 2);
+      }
+    }
+    const question = inputTextParts.map((part) => part.trim()).filter((part) => part.length > 0).join(" ");
+    const caseExecution = isJsonObject(evalcase.execution) ? evalcase.execution : void 0;
+    const mergedExecution = caseExecution ?? globalExecution;
+    const evalCaseEvaluatorKind = coerceEvaluator(evalcase.evaluator, id) ?? globalEvaluator;
+    let evaluators;
+    try {
+      evaluators = await parseEvaluators(evalcase, mergedExecution, searchRoots, id ?? "unknown");
+    } catch (error40) {
+      const message = error40 instanceof Error ? error40.message : String(error40);
+      logError(`Skipping eval case '${id}' at line ${lineNumber}: ${message}`);
+      continue;
+    }
+    const inlineRubrics = evalcase.rubrics;
+    if (inlineRubrics !== void 0 && Array.isArray(inlineRubrics)) {
+      const rubricEvaluator = parseInlineRubrics(inlineRubrics);
+      if (rubricEvaluator) {
+        evaluators = evaluators ? [rubricEvaluator, ...evaluators] : [rubricEvaluator];
+      }
+    }
+    const userFilePaths = [];
+    for (const segment of inputSegments) {
+      if (segment.type === "file" && typeof segment.resolvedPath === "string") {
+        userFilePaths.push(segment.resolvedPath);
+      }
+    }
+    const allFilePaths = [
+      ...guidelinePaths.map((guidelinePath) => path52.resolve(guidelinePath)),
+      ...userFilePaths
+    ];
+    const testCase = {
+      id,
+      dataset: datasetName,
+      conversation_id: conversationId,
+      question,
+      input_messages: inputMessages,
+      input_segments: inputSegments,
+      expected_messages: outputSegments,
+      reference_answer: referenceAnswer,
+      guideline_paths: guidelinePaths.map((guidelinePath) => path52.resolve(guidelinePath)),
+      guideline_patterns: guidelinePatterns,
+      file_paths: allFilePaths,
+      expected_outcome: outcome,
+      evaluator: evalCaseEvaluatorKind,
+      evaluators
+    };
+    if (verbose) {
+      console.log(`
+[Eval Case: ${id}]`);
+      if (testCase.guideline_paths.length > 0) {
+        console.log(`  Guidelines used: ${testCase.guideline_paths.length}`);
+        for (const guidelinePath of testCase.guideline_paths) {
+          console.log(`    - ${guidelinePath}`);
+        }
+      } else {
+        console.log("  No guidelines found");
+      }
+    }
+    results.push(testCase);
+  }
+  return results;
+}
+function asString4(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function logWarning4(message, details) {
+  if (details && details.length > 0) {
+    const detailBlock = details.join("\n");
+    console.warn(`${ANSI_YELLOW5}Warning: ${message}
+${detailBlock}${ANSI_RESET5}`);
+  } else {
+    console.warn(`${ANSI_YELLOW5}Warning: ${message}${ANSI_RESET5}`);
+  }
+}
+function logError(message, details) {
+  if (details && details.length > 0) {
+    const detailBlock = details.join("\n");
+    console.error(`${ANSI_RED}Error: ${message}
+${detailBlock}${ANSI_RESET5}`);
+  } else {
+    console.error(`${ANSI_RED}Error: ${message}${ANSI_RESET5}`);
+  }
+}
+var ANSI_YELLOW6 = "\x1B[33m";
+var ANSI_RESET6 = "\x1B[0m";
 async function buildPromptInputs(testCase, mode = "lm") {
   const guidelineParts = [];
   for (const rawPath of testCase.guideline_paths) {
-    const absolutePath = path52.resolve(rawPath);
+    const absolutePath = path62.resolve(rawPath);
     if (!await fileExists2(absolutePath)) {
-      logWarning4(`Could not read guideline file ${absolutePath}: file does not exist`);
+      logWarning5(`Could not read guideline file ${absolutePath}: file does not exist`);
       continue;
     }
     try {
-      const content = (await readFile42(absolutePath, "utf8")).replace(/\r\n/g, "\n").trim();
+      const content = (await readFile5(absolutePath, "utf8")).replace(/\r\n/g, "\n").trim();
       guidelineParts.push({
         content,
         isFile: true,
-        displayPath: path52.basename(absolutePath)
+        displayPath: path62.basename(absolutePath)
       });
     } catch (error40) {
-      logWarning4(`Could not read guideline file ${absolutePath}: ${error40.message}`);
+      logWarning5(`Could not read guideline file ${absolutePath}: ${error40.message}`);
     }
   }
   const guidelines = formatFileContents(guidelineParts);
@@ -36206,9 +36693,9 @@ async function buildPromptInputs(testCase, mode = "lm") {
             messageSegments.push({ type: "text", value: segment });
           }
         } else if (isJsonObject(segment)) {
-          const type = asString4(segment.type);
+          const type = asString5(segment.type);
           if (type === "file") {
-            const value = asString4(segment.value);
+            const value = asString5(segment.value);
             if (!value) continue;
             if (testCase.guideline_patterns && isGuidelineFile(value, testCase.guideline_patterns)) {
               messageSegments.push({ type: "guideline_ref", path: value });
@@ -36219,7 +36706,7 @@ async function buildPromptInputs(testCase, mode = "lm") {
               messageSegments.push({ type: "file", text: fileText, path: value });
             }
           } else if (type === "text") {
-            const textValue = asString4(segment.value);
+            const textValue = asString5(segment.value);
             if (textValue && textValue.trim().length > 0) {
               messageSegments.push({ type: "text", value: textValue });
             }
@@ -36373,19 +36860,19 @@ ${guidelineContent.trim()}`);
   }
   return chatPrompt.length > 0 ? chatPrompt : void 0;
 }
-function asString4(value) {
+function asString5(value) {
   return typeof value === "string" ? value : void 0;
 }
-function logWarning4(message) {
-  console.warn(`${ANSI_YELLOW5}Warning: ${message}${ANSI_RESET5}`);
+function logWarning5(message) {
+  console.warn(`${ANSI_YELLOW6}Warning: ${message}${ANSI_RESET6}`);
 }
-var ANSI_YELLOW6 = "\x1B[33m";
-var ANSI_RED = "\x1B[31m";
-var ANSI_RESET6 = "\x1B[0m";
+var ANSI_YELLOW7 = "\x1B[33m";
+var ANSI_RED2 = "\x1B[31m";
+var ANSI_RESET7 = "\x1B[0m";
 async function readTestSuiteMetadata(testFilePath) {
   try {
-    const absolutePath = path62.resolve(testFilePath);
-    const content = await readFile5(absolutePath, "utf8");
+    const absolutePath = path72.resolve(testFilePath);
+    const content = await readFile6(absolutePath, "utf8");
     const parsed = parse22(content);
     if (!isJsonObject(parsed)) {
       return {};
@@ -36396,21 +36883,25 @@ async function readTestSuiteMetadata(testFilePath) {
   }
 }
 async function loadEvalCases(evalFilePath, repoRoot, options) {
+  const format = detectFormat(evalFilePath);
+  if (format === "jsonl") {
+    return loadEvalCasesFromJsonl(evalFilePath, repoRoot, options);
+  }
   const verbose = options?.verbose ?? false;
-  const evalIdFilter = options?.evalId;
-  const absoluteTestPath = path62.resolve(evalFilePath);
+  const filterPattern = options?.filter;
+  const absoluteTestPath = path72.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
   const config2 = await loadConfig(absoluteTestPath, repoRootPath);
   const guidelinePatterns = config2?.guideline_patterns;
-  const rawFile = await readFile5(absoluteTestPath, "utf8");
+  const rawFile = await readFile6(absoluteTestPath, "utf8");
   const parsed = parse22(rawFile);
   if (!isJsonObject(parsed)) {
     throw new Error(`Invalid test file format: ${evalFilePath}`);
   }
   const suite = parsed;
-  const datasetNameFromSuite = asString5(suite.dataset)?.trim();
-  const fallbackDataset = path62.basename(absoluteTestPath).replace(/\.ya?ml$/i, "") || "eval";
+  const datasetNameFromSuite = asString6(suite.dataset)?.trim();
+  const fallbackDataset = path72.basename(absoluteTestPath).replace(/\.ya?ml$/i, "") || "eval";
   const datasetName = datasetNameFromSuite && datasetNameFromSuite.length > 0 ? datasetNameFromSuite : fallbackDataset;
   const rawTestcases = suite.evalcases;
   if (!Array.isArray(rawTestcases)) {
@@ -36418,37 +36909,29 @@ async function loadEvalCases(evalFilePath, repoRoot, options) {
   }
   const globalEvaluator = coerceEvaluator(suite.evaluator, "global") ?? "llm_judge";
   const globalExecution = isJsonObject(suite.execution) ? suite.execution : void 0;
-  const _globalTarget = asString5(globalExecution?.target) ?? asString5(suite.target);
+  const _globalTarget = asString6(globalExecution?.target) ?? asString6(suite.target);
   const results = [];
   for (const rawEvalcase of rawTestcases) {
     if (!isJsonObject(rawEvalcase)) {
-      logWarning5("Skipping invalid eval case entry (expected object)");
+      logWarning6("Skipping invalid eval case entry (expected object)");
       continue;
     }
     const evalcase = rawEvalcase;
-    const id = asString5(evalcase.id);
-    if (evalIdFilter && id !== evalIdFilter) {
+    const id = asString6(evalcase.id);
+    if (filterPattern && (!id || !micromatch3.isMatch(id, filterPattern))) {
       continue;
     }
-    const conversationId = asString5(evalcase.conversation_id);
-    const outcome = asString5(evalcase.expected_outcome) ?? asString5(evalcase.outcome);
-    const inputMessagesValue = evalcase.input_messages;
-    const expectedMessagesValue = evalcase.expected_messages;
-    if (!id || !outcome || !Array.isArray(inputMessagesValue)) {
-      logError(
-        `Skipping incomplete eval case: ${id ?? "unknown"}. Missing required fields: id, outcome, and/or input_messages`
+    const conversationId = asString6(evalcase.conversation_id);
+    const outcome = asString6(evalcase.expected_outcome) ?? asString6(evalcase.outcome);
+    const inputMessages = resolveInputMessages(evalcase);
+    const expectedMessages = resolveExpectedMessages(evalcase) ?? [];
+    if (!id || !outcome || !inputMessages || inputMessages.length === 0) {
+      logError2(
+        `Skipping incomplete eval case: ${id ?? "unknown"}. Missing required fields: id, outcome, and/or input_messages (or input)`
       );
       continue;
     }
-    const hasExpectedMessages = Array.isArray(expectedMessagesValue) && expectedMessagesValue.length > 0;
-    const inputMessages = inputMessagesValue.filter(
-      (msg) => isTestMessage(msg)
-    );
-    const expectedMessages = hasExpectedMessages ? expectedMessagesValue.filter((msg) => isTestMessage(msg)) : [];
-    if (hasExpectedMessages && expectedMessages.length === 0) {
-      logError(`No valid expected message found for eval case: ${id}`);
-      continue;
-    }
+    const hasExpectedMessages = expectedMessages.length > 0;
     const guidelinePaths = [];
     const inputTextParts = [];
     const inputSegments = await processMessages({
@@ -36487,33 +36970,13 @@ async function loadEvalCases(evalFilePath, repoRoot, options) {
       evaluators = await parseEvaluators(evalcase, globalExecution, searchRoots, id ?? "unknown");
     } catch (error40) {
       const message = error40 instanceof Error ? error40.message : String(error40);
-      logError(`Skipping eval case '${id}': ${message}`);
+      logError2(`Skipping eval case '${id}': ${message}`);
       continue;
     }
     const inlineRubrics = evalcase.rubrics;
     if (inlineRubrics !== void 0 && Array.isArray(inlineRubrics)) {
-      const rubricItems = inlineRubrics.filter((r) => isJsonObject(r) || typeof r === "string").map((rubric, index) => {
-        if (typeof rubric === "string") {
-          return {
-            id: `rubric-${index + 1}`,
-            description: rubric,
-            weight: 1,
-            required: true
-          };
-        }
-        return {
-          id: asString5(rubric.id) ?? `rubric-${index + 1}`,
-          description: asString5(rubric.description) ?? "",
-          weight: typeof rubric.weight === "number" ? rubric.weight : 1,
-          required: typeof rubric.required === "boolean" ? rubric.required : true
-        };
-      }).filter((r) => r.description.length > 0);
-      if (rubricItems.length > 0) {
-        const rubricEvaluator = {
-          name: "rubric",
-          type: "llm_judge",
-          rubrics: rubricItems
-        };
+      const rubricEvaluator = parseInlineRubrics(inlineRubrics);
+      if (rubricEvaluator) {
         evaluators = evaluators ? [rubricEvaluator, ...evaluators] : [rubricEvaluator];
       }
     }
@@ -36524,7 +36987,7 @@ async function loadEvalCases(evalFilePath, repoRoot, options) {
       }
     }
     const allFilePaths = [
-      ...guidelinePaths.map((guidelinePath) => path62.resolve(guidelinePath)),
+      ...guidelinePaths.map((guidelinePath) => path72.resolve(guidelinePath)),
       ...userFilePaths
     ];
     const testCase = {
@@ -36536,7 +36999,7 @@ async function loadEvalCases(evalFilePath, repoRoot, options) {
       input_segments: inputSegments,
       expected_messages: outputSegments,
       reference_answer: referenceAnswer,
-      guideline_paths: guidelinePaths.map((guidelinePath) => path62.resolve(guidelinePath)),
+      guideline_paths: guidelinePaths.map((guidelinePath) => path72.resolve(guidelinePath)),
       guideline_patterns: guidelinePatterns,
       file_paths: allFilePaths,
       expected_outcome: outcome,
@@ -36559,25 +37022,25 @@ async function loadEvalCases(evalFilePath, repoRoot, options) {
   }
   return results;
 }
-function asString5(value) {
+function asString6(value) {
   return typeof value === "string" ? value : void 0;
 }
-function logWarning5(message, details) {
+function logWarning6(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
-    console.warn(`${ANSI_YELLOW6}Warning: ${message}
-${detailBlock}${ANSI_RESET6}`);
+    console.warn(`${ANSI_YELLOW7}Warning: ${message}
+${detailBlock}${ANSI_RESET7}`);
   } else {
-    console.warn(`${ANSI_YELLOW6}Warning: ${message}${ANSI_RESET6}`);
+    console.warn(`${ANSI_YELLOW7}Warning: ${message}${ANSI_RESET7}`);
   }
 }
-function logError(message, details) {
+function logError2(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
-    console.error(`${ANSI_RED}Error: ${message}
-${detailBlock}${ANSI_RESET6}`);
+    console.error(`${ANSI_RED2}Error: ${message}
+${detailBlock}${ANSI_RESET7}`);
   } else {
-    console.error(`${ANSI_RED}Error: ${message}${ANSI_RESET6}`);
+    console.error(`${ANSI_RED2}Error: ${message}${ANSI_RESET7}`);
   }
 }
 var DEFAULT_SYSTEM_PROMPT = "You are a careful assistant. Follow all provided instructions and do not fabricate results.";
@@ -36966,7 +37429,7 @@ function normalizeInputFiles(inputFiles) {
   }
   const deduped = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path72.resolve(inputFile);
+    const absolutePath = path82.resolve(inputFile);
     if (!deduped.has(absolutePath)) {
       deduped.set(absolutePath, absolutePath);
     }
@@ -36979,14 +37442,14 @@ function collectGuidelineFiles(inputFiles, guidelinePatterns, overrides) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path72.resolve(inputFile);
+    const absolutePath = path82.resolve(inputFile);
     if (overrides?.has(absolutePath)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
       }
       continue;
     }
-    const normalized = absolutePath.split(path72.sep).join("/");
+    const normalized = absolutePath.split(path82.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -37001,7 +37464,7 @@ function collectInputFiles(inputFiles) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path72.resolve(inputFile);
+    const absolutePath = path82.resolve(inputFile);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -37013,7 +37476,7 @@ function buildMandatoryPrereadBlock(guidelineFiles, inputFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path72.basename(absolutePath);
+    const fileName = path82.basename(absolutePath);
     const fileUri = pathToFileUri2(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -37033,7 +37496,7 @@ ${buildList(inputFiles).join("\n")}.`);
   return sections.join("\n");
 }
 function pathToFileUri2(filePath) {
-  const absolutePath = path72.isAbsolute(filePath) ? filePath : path72.resolve(filePath);
+  const absolutePath = path82.isAbsolute(filePath) ? filePath : path82.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -37068,7 +37531,7 @@ var ClaudeCodeProvider = class {
     const workspaceRoot = await this.createWorkspace();
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
-      const promptFile = path82.join(workspaceRoot, PROMPT_FILENAME);
+      const promptFile = path92.join(workspaceRoot, PROMPT_FILENAME);
       await writeFile5(promptFile, request.question, "utf8");
       const args = this.buildClaudeCodeArgs(request.question, inputFiles);
       const cwd = this.resolveCwd();
@@ -37116,7 +37579,7 @@ var ClaudeCodeProvider = class {
     if (!this.config.cwd) {
       return process.cwd();
     }
-    return path82.resolve(this.config.cwd);
+    return path92.resolve(this.config.cwd);
   }
   buildClaudeCodeArgs(prompt, inputFiles) {
     const args = [];
@@ -37173,7 +37636,7 @@ ${filesContext}`;
     }
   }
   async createWorkspace() {
-    return await mkdtemp(path82.join(tmpdir(), WORKSPACE_PREFIX));
+    return await mkdtemp(path92.join(tmpdir(), WORKSPACE_PREFIX));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
@@ -37187,9 +37650,9 @@ ${filesContext}`;
       return void 0;
     }
     if (this.config.logDir) {
-      return path82.resolve(this.config.logDir);
+      return path92.resolve(this.config.logDir);
     }
-    return path82.join(process.cwd(), ".agentv", "logs", "claude-code");
+    return path92.join(process.cwd(), ".agentv", "logs", "claude-code");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -37203,7 +37666,7 @@ ${filesContext}`;
       console.warn(`Skipping Claude Code stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path82.join(logDir, buildLogFilename(request, this.targetName));
+    const filePath = path92.join(logDir, buildLogFilename(request, this.targetName));
     try {
       const logger = await ClaudeCodeStreamLogger.create({
         filePath,
@@ -37608,10 +38071,10 @@ function escapeShellArg(arg) {
 }
 async function defaultClaudeCodeRunner(options) {
   const tempId = randomUUID();
-  const stdoutFile = path82.join(tmpdir(), `agentv-cc-${tempId}-stdout`);
-  const stderrFile = path82.join(tmpdir(), `agentv-cc-${tempId}-stderr`);
-  const exitFile = path82.join(tmpdir(), `agentv-cc-${tempId}-exit`);
-  const pidFile = path82.join(tmpdir(), `agentv-cc-${tempId}-pid`);
+  const stdoutFile = path92.join(tmpdir(), `agentv-cc-${tempId}-stdout`);
+  const stderrFile = path92.join(tmpdir(), `agentv-cc-${tempId}-stderr`);
+  const exitFile = path92.join(tmpdir(), `agentv-cc-${tempId}-exit`);
+  const pidFile = path92.join(tmpdir(), `agentv-cc-${tempId}-pid`);
   try {
     return await runClaudeCodeWithTempFiles(options, stdoutFile, stderrFile, exitFile, pidFile);
   } finally {
@@ -37651,8 +38114,8 @@ async function runClaudeCodeWithTempFiles(options, stdoutFile, stderrFile, exitF
   let lastStdoutSize = 0;
   const readFileIfExists = async (filePath) => {
     try {
-      const { readFile: readFile72 } = await import("node:fs/promises");
-      return await readFile72(filePath, "utf8");
+      const { readFile: readFile82 } = await import("node:fs/promises");
+      return await readFile82(filePath, "utf8");
     } catch {
       return "";
     }
@@ -37727,7 +38190,8 @@ var ToolCallSchema = external_exports.object({
   input: external_exports.unknown().optional(),
   output: external_exports.unknown().optional(),
   id: external_exports.string().optional(),
-  timestamp: external_exports.string().optional()
+  timestamp: external_exports.string().optional(),
+  duration_ms: external_exports.number().optional()
 });
 var OutputMessageInputSchema = external_exports.object({
   role: external_exports.string(),
@@ -37735,6 +38199,7 @@ var OutputMessageInputSchema = external_exports.object({
   content: external_exports.unknown().optional(),
   tool_calls: external_exports.array(ToolCallSchema).optional(),
   timestamp: external_exports.string().optional(),
+  duration_ms: external_exports.number().optional(),
   metadata: external_exports.record(external_exports.unknown()).optional()
 });
 var TokenUsageSchema = external_exports.object({
@@ -37773,8 +38238,16 @@ function convertOutputMessages(messages) {
     role: msg.role,
     name: msg.name,
     content: msg.content,
-    toolCalls: msg.tool_calls,
+    toolCalls: msg.tool_calls?.map((tc) => ({
+      tool: tc.tool,
+      input: tc.input,
+      output: tc.output,
+      id: tc.id,
+      timestamp: tc.timestamp,
+      durationMs: tc.duration_ms
+    })),
     timestamp: msg.timestamp,
+    durationMs: msg.duration_ms,
     metadata: msg.metadata
   }));
 }
@@ -38176,7 +38649,7 @@ function normalizeInputFiles2(inputFiles) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const inputFile of inputFiles) {
-    const absolutePath = path92.resolve(inputFile);
+    const absolutePath = path102.resolve(inputFile);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -38190,7 +38663,7 @@ function formatFileList(files, template) {
   const formatter = template ?? "{path}";
   return files.map((filePath) => {
     const escapedPath = shellEscape(filePath);
-    const escapedName = shellEscape(path92.basename(filePath));
+    const escapedName = shellEscape(path102.basename(filePath));
     return formatter.replaceAll("{path}", escapedPath).replaceAll("{basename}", escapedName);
   }).join(" ");
 }
@@ -38214,7 +38687,7 @@ function generateOutputFilePath(evalCaseId, extension = ".json") {
   const safeEvalId = evalCaseId || "unknown";
   const timestamp = Date.now();
   const random = Math.random().toString(36).substring(2, 9);
-  return path92.join(os2.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
+  return path102.join(os2.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
 }
 function formatTimeoutSuffix2(timeoutMs) {
   if (!timeoutMs || timeoutMs <= 0) {
@@ -38305,7 +38778,7 @@ var CodexProvider = class {
       const promptContent = `${systemPrompt}
 
 ${basePrompt}`;
-      const promptFile = path102.join(workspaceRoot, PROMPT_FILENAME2);
+      const promptFile = path112.join(workspaceRoot, PROMPT_FILENAME2);
       await writeFile22(promptFile, promptContent, "utf8");
       const args = this.buildCodexArgs();
       const cwd = this.resolveCwd(workspaceRoot);
@@ -38355,7 +38828,7 @@ ${basePrompt}`;
     if (!this.config.cwd) {
       return workspaceRoot;
     }
-    return path102.resolve(this.config.cwd);
+    return path112.resolve(this.config.cwd);
   }
   buildCodexArgs() {
     const args = [
@@ -38397,7 +38870,7 @@ ${basePrompt}`;
     }
   }
   async createWorkspace() {
-    return await mkdtemp2(path102.join(tmpdir2(), WORKSPACE_PREFIX2));
+    return await mkdtemp2(path112.join(tmpdir2(), WORKSPACE_PREFIX2));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
@@ -38411,9 +38884,9 @@ ${basePrompt}`;
       return void 0;
     }
     if (this.config.logDir) {
-      return path102.resolve(this.config.logDir);
+      return path112.resolve(this.config.logDir);
     }
-    return path102.join(process.cwd(), ".agentv", "logs", "codex");
+    return path112.join(process.cwd(), ".agentv", "logs", "codex");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -38427,7 +38900,7 @@ ${basePrompt}`;
       console.warn(`Skipping Codex stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path102.join(logDir, buildLogFilename2(request, this.targetName));
+    const filePath = path112.join(logDir, buildLogFilename2(request, this.targetName));
     try {
       const logger = await CodexStreamLogger.create({
         filePath,
@@ -38642,7 +39115,7 @@ function tryParseJsonValue2(rawLine) {
 async function locateExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = path102.isAbsolute(candidate) ? candidate : path102.resolve(candidate);
+    const resolved = path112.isAbsolute(candidate) ? candidate : path112.resolve(candidate);
     const executablePath = await ensureWindowsExecutableVariant(resolved);
     await access22(executablePath, constants22.F_OK);
     return executablePath;
@@ -39216,7 +39689,7 @@ var PiCodingAgentProvider = class {
     const workspaceRoot = await this.createWorkspace();
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
-      const promptFile = path112.join(workspaceRoot, PROMPT_FILENAME3);
+      const promptFile = path122.join(workspaceRoot, PROMPT_FILENAME3);
       await writeFile32(promptFile, request.question, "utf8");
       const args = this.buildPiArgs(request.question, inputFiles);
       const cwd = this.resolveCwd(workspaceRoot);
@@ -39258,7 +39731,7 @@ var PiCodingAgentProvider = class {
     if (!this.config.cwd) {
       return workspaceRoot;
     }
-    return path112.resolve(this.config.cwd);
+    return path122.resolve(this.config.cwd);
   }
   buildPiArgs(prompt, inputFiles) {
     const args = [];
@@ -39347,7 +39820,7 @@ ${prompt}`;
     return env;
   }
   async createWorkspace() {
-    return await mkdtemp3(path112.join(tmpdir3(), WORKSPACE_PREFIX3));
+    return await mkdtemp3(path122.join(tmpdir3(), WORKSPACE_PREFIX3));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
@@ -39357,9 +39830,9 @@ ${prompt}`;
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return path112.resolve(this.config.logDir);
+      return path122.resolve(this.config.logDir);
     }
-    return path112.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
+    return path122.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -39373,7 +39846,7 @@ ${prompt}`;
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path112.join(logDir, buildLogFilename3(request, this.targetName));
+    const filePath = path122.join(logDir, buildLogFilename3(request, this.targetName));
     try {
       const logger = await PiStreamLogger.create({
         filePath,
@@ -39968,7 +40441,7 @@ function buildMandatoryPrereadBlock2(guidelineFiles, attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path122.basename(absolutePath);
+    const fileName = path132.basename(absolutePath);
     const fileUri = pathToFileUri22(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -39993,8 +40466,8 @@ function collectGuidelineFiles2(attachments, guidelinePatterns) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path122.resolve(attachment);
-    const normalized = absolutePath.split(path122.sep).join("/");
+    const absolutePath = path132.resolve(attachment);
+    const normalized = absolutePath.split(path132.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -40009,7 +40482,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path122.resolve(attachment);
+    const absolutePath = path132.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -40017,7 +40490,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri22(filePath) {
-  const absolutePath = path122.isAbsolute(filePath) ? filePath : path122.resolve(filePath);
+  const absolutePath = path132.isAbsolute(filePath) ? filePath : path132.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -40030,7 +40503,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(path122.resolve(attachment));
+    deduped.add(path132.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -40039,7 +40512,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(path122.resolve(inputFile));
+      deduped.add(path132.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -40119,11 +40592,11 @@ async function fileExists3(filePath) {
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = path132.resolve(filePath);
+  const absolutePath = path14.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await readFile6(absolutePath, "utf8");
+  const raw = await readFile7(absolutePath, "utf8");
   const parsed = parse32(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -40320,15 +40793,15 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command7, stdinPayload, options = {}) {
-  const { mkdir: mkdir42, readFile: readFile72, rm: rm4, writeFile: writeFile42 } = await import("node:fs/promises");
+  const { mkdir: mkdir42, readFile: readFile82, rm: rm4, writeFile: writeFile42 } = await import("node:fs/promises");
   const { tmpdir: tmpdir4 } = await import("node:os");
-  const path152 = await import("node:path");
+  const path162 = await import("node:path");
   const { randomUUID: randomUUID4 } = await import("node:crypto");
-  const dir = path152.join(tmpdir4(), `agentv-exec-${randomUUID4()}`);
+  const dir = path162.join(tmpdir4(), `agentv-exec-${randomUUID4()}`);
   await mkdir42(dir, { recursive: true });
-  const stdinPath = path152.join(dir, "stdin.txt");
-  const stdoutPath = path152.join(dir, "stdout.txt");
-  const stderrPath = path152.join(dir, "stderr.txt");
+  const stdinPath = path162.join(dir, "stdin.txt");
+  const stdoutPath = path162.join(dir, "stdout.txt");
+  const stderrPath = path162.join(dir, "stderr.txt");
   await writeFile42(stdinPath, stdinPayload, "utf8");
   const wrappedCommand = process.platform === "win32" ? `(${command7}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command7}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
   const { spawn: spawn4 } = await import("node:child_process");
@@ -40358,8 +40831,8 @@ async function execShellWithStdin(command7, stdinPayload, options = {}) {
         resolve2(code ?? 0);
       });
     });
-    const stdout = (await readFile72(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile72(stderrPath, "utf8")).replace(/\r\n/g, "\n");
+    const stdout = (await readFile82(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
+    const stderr = (await readFile82(stderrPath, "utf8")).replace(/\r\n/g, "\n");
     return { stdout, stderr, exitCode };
   } finally {
     await rm4(dir, { recursive: true, force: true });
@@ -40623,7 +41096,7 @@ var CodeEvaluator = class {
       outputMessages: context.outputMessages ?? null,
       guidelineFiles: context.evalCase.guideline_paths,
       inputFiles: context.evalCase.file_paths.filter(
-        (path152) => !context.evalCase.guideline_paths.includes(path152)
+        (path162) => !context.evalCase.guideline_paths.includes(path162)
       ),
       inputMessages: context.evalCase.input_messages,
       traceSummary: context.traceSummary ?? null,
@@ -40764,6 +41237,15 @@ var rubricEvaluationSchema = external_exports.object({
   checks: external_exports.array(rubricCheckResultSchema).describe("Results for each rubric item"),
   overall_reasoning: external_exports.string().describe("Overall assessment summary (1-2 sentences)")
 });
+var scoreRangeCheckResultSchema = external_exports.object({
+  id: external_exports.string().describe("The ID of the rubric criterion being scored"),
+  score: external_exports.number().int().min(0).max(10).describe("Integer score 0-10 for this criterion"),
+  reasoning: external_exports.string().describe("Brief explanation (1-2 sentences) for this score").optional()
+});
+var scoreRangeEvaluationSchema = external_exports.object({
+  checks: external_exports.array(scoreRangeCheckResultSchema).describe("Scores for each rubric criterion"),
+  overall_reasoning: external_exports.string().describe("Overall assessment summary (1-2 sentences)").optional()
+});
 var LlmJudgeEvaluator = class {
   kind = "llm_judge";
   resolveJudgeProvider;
@@ -40849,6 +41331,10 @@ var LlmJudgeEvaluator = class {
         `No rubrics found for evaluator "${context.evaluator?.name ?? "llm_judge"}". Run "agentv generate rubrics" first.`
       );
     }
+    const hasScoreRanges = rubrics.some((r) => r.score_ranges && r.score_ranges.length > 0);
+    if (hasScoreRanges) {
+      return this.evaluateWithScoreRanges(context, judgeProvider, rubrics);
+    }
     const prompt = this.buildRubricPrompt(context, rubrics);
     const systemPrompt = buildRubricOutputSchema();
     const evaluatorRawRequest = {
@@ -40874,6 +41360,84 @@ var LlmJudgeEvaluator = class {
       evaluatorRawRequest
     };
   }
+  /**
+   * Evaluate using score-range rubrics (analytic rubric scoring).
+   * Each criterion is scored 0-10 and normalized to 0-1.
+   */
+  async evaluateWithScoreRanges(context, judgeProvider, rubrics) {
+    const prompt = this.buildScoreRangePrompt(context, rubrics);
+    const systemPrompt = buildScoreRangeOutputSchema();
+    const evaluatorRawRequest = {
+      userPrompt: prompt,
+      systemPrompt,
+      target: judgeProvider.targetName
+    };
+    const { data } = await this.runWithRetry({
+      context,
+      judgeProvider,
+      systemPrompt,
+      userPrompt: prompt,
+      schema: scoreRangeEvaluationSchema
+    });
+    const { score, verdict, hits, misses, details } = calculateScoreRangeResult(data, rubrics);
+    return {
+      score,
+      verdict,
+      hits,
+      misses,
+      expectedAspectCount: rubrics.length,
+      reasoning: data.overall_reasoning,
+      evaluatorRawRequest,
+      details
+    };
+  }
+  /**
+   * Build prompt for score-range rubric evaluation.
+   */
+  buildScoreRangePrompt(context, rubrics) {
+    const formattedQuestion = context.promptInputs.question && context.promptInputs.question.trim().length > 0 ? context.promptInputs.question : context.evalCase.question;
+    const parts = [
+      "You are an expert evaluator. Score the candidate answer on each criterion below using the provided score ranges.",
+      "For each criterion, output an integer score from 0 to 10 based on which score range best matches the answer.",
+      "",
+      "[[ ## question ## ]]",
+      formattedQuestion,
+      "",
+      "[[ ## expected_outcome ## ]]",
+      context.evalCase.expected_outcome,
+      ""
+    ];
+    if (context.evalCase.reference_answer && context.evalCase.reference_answer.trim().length > 0) {
+      parts.push("[[ ## reference_answer ## ]]", context.evalCase.reference_answer, "");
+    }
+    parts.push(
+      "[[ ## candidate_answer ## ]]",
+      context.candidate,
+      "",
+      "[[ ## scoring_criteria ## ]]"
+    );
+    for (const rubric of rubrics) {
+      const weightLabel = rubric.weight !== 1 ? ` (weight: ${rubric.weight})` : "";
+      const minScoreLabel = rubric.required_min_score !== void 0 ? ` [REQUIRED: min score ${rubric.required_min_score}]` : "";
+      parts.push("", `### Criterion: ${rubric.id}${weightLabel}${minScoreLabel}`);
+      if (rubric.expected_outcome) {
+        parts.push(`Description: ${rubric.expected_outcome}`);
+      }
+      if (rubric.score_ranges && rubric.score_ranges.length > 0) {
+        parts.push("Score ranges:");
+        for (const range of rubric.score_ranges) {
+          const [min, max] = range.score_range;
+          const rangeLabel = min === max ? `${min}` : `${min}-${max}`;
+          parts.push(`  - Score ${rangeLabel}: ${range.expected_outcome}`);
+        }
+      }
+    }
+    parts.push(
+      "",
+      "For each criterion, provide an integer score 0-10 that matches one of its defined score ranges."
+    );
+    return parts.join("\n");
+  }
   buildRubricPrompt(context, rubrics) {
     const formattedQuestion = context.promptInputs.question && context.promptInputs.question.trim().length > 0 ? context.promptInputs.question : context.evalCase.question;
     const parts = [
@@ -40893,7 +41457,7 @@ var LlmJudgeEvaluator = class {
     for (const rubric of rubrics) {
       const requiredLabel = rubric.required ? " (REQUIRED)" : "";
       const weightLabel = rubric.weight !== 1 ? ` (weight: ${rubric.weight})` : "";
-      parts.push(`- [${rubric.id}]${requiredLabel}${weightLabel}: ${rubric.description}`);
+      parts.push(`- [${rubric.id}]${requiredLabel}${weightLabel}: ${rubric.expected_outcome}`);
     }
     parts.push("", "For each rubric, determine if it is satisfied and provide brief reasoning.");
     return parts.join("\n");
@@ -40980,9 +41544,9 @@ function calculateRubricScore(result, rubrics) {
     totalWeight += rubric.weight;
     if (check2.satisfied) {
       earnedWeight += rubric.weight;
-      hits.push(`[${rubric.id}] ${rubric.description}: ${check2.reasoning}`);
+      hits.push(`[${rubric.id}] ${rubric.expected_outcome}: ${check2.reasoning}`);
     } else {
-      misses.push(`[${rubric.id}] ${rubric.description}: ${check2.reasoning}`);
+      misses.push(`[${rubric.id}] ${rubric.expected_outcome}: ${check2.reasoning}`);
       if (rubric.required) {
         failedRequired = true;
       }
@@ -40992,6 +41556,76 @@ function calculateRubricScore(result, rubrics) {
   const verdict = failedRequired ? "fail" : scoreToVerdict(score);
   return { score, verdict, hits, misses };
 }
+function buildScoreRangeOutputSchema() {
+  return `You are an expert evaluator. Score the candidate answer on each criterion.
+You must return a valid JSON object matching this schema:
+{
+  "checks": [
+    {
+      "id": "string (criterion id)",
+      "score": integer (0-10),
+      "reasoning": "string (brief explanation for score)"
+    }
+  ],
+  "overall_reasoning": "string (summary, optional)"
+}
+
+Important: The "score" must be an integer from 0 to 10 that falls within one of the defined score ranges for that criterion.`;
+}
+function calculateScoreRangeResult(result, rubrics) {
+  const rubricMap = new Map(rubrics.map((rubric) => [rubric.id, rubric]));
+  const hits = [];
+  const misses = [];
+  const rawScores = {};
+  let totalWeight = 0;
+  let weightedScoreSum = 0;
+  let failedRequired = false;
+  for (const check2 of result.checks) {
+    const rubric = rubricMap.get(check2.id);
+    if (!rubric) {
+      continue;
+    }
+    const rawScore = Math.max(0, Math.min(10, check2.score));
+    const normalizedScore = rawScore / 10;
+    rawScores[rubric.id] = rawScore;
+    totalWeight += rubric.weight;
+    weightedScoreSum += normalizedScore * rubric.weight;
+    let requiredMinScore;
+    if (rubric.required_min_score !== void 0) {
+      requiredMinScore = rubric.required_min_score;
+    } else if (rubric.required === true) {
+      requiredMinScore = 10;
+    }
+    const matchingRange = rubric.score_ranges?.find(
+      (r) => rawScore >= r.score_range[0] && rawScore <= r.score_range[1]
+    );
+    const rangeDescription = matchingRange?.expected_outcome ?? "";
+    const criterionLabel = rubric.expected_outcome ?? rubric.id;
+    const reasoningText = check2.reasoning ? `: ${check2.reasoning}` : "";
+    const scoreInfo = `[${rubric.id}] ${criterionLabel} - Score: ${rawScore}/10 (${rangeDescription})${reasoningText}`;
+    if (requiredMinScore !== void 0 && rawScore < requiredMinScore) {
+      failedRequired = true;
+      misses.push(scoreInfo);
+    } else if (rawScore >= 7) {
+      hits.push(scoreInfo);
+    } else {
+      misses.push(scoreInfo);
+    }
+  }
+  const score = totalWeight > 0 ? Math.min(1, Math.max(0, weightedScoreSum / totalWeight)) : 0;
+  const verdict = failedRequired ? "fail" : scoreToVerdict(score);
+  return {
+    score,
+    verdict,
+    hits,
+    misses,
+    details: {
+      raw_scores: rawScores,
+      normalization: "score / 10",
+      aggregation: "weighted_average"
+    }
+  };
+}
 var DEFAULT_COMPOSITE_AGGREGATOR_PROMPT = `Review the following evaluation results:
 {{EVALUATOR_RESULTS_JSON}}
 
@@ -41369,115 +42003,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path152, match, required: required2 = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path152);
-    const expectedValue = resolvePath(expectedData, path152);
+    const { path: path162, match, required: required2 = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path162);
+    const expectedValue = resolvePath(expectedData, path162);
     if (expectedValue === void 0) {
       return {
-        path: path152,
+        path: path162,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path152}: no expected value`
+        message: `${path162}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required2) {
         return {
-          path: path152,
+          path: path162,
           score: 0,
           weight,
           hit: false,
-          message: `${path152} (required, missing)`
+          message: `${path162} (required, missing)`
         };
       }
       return {
-        path: path152,
+        path: path162,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path152}: optional field missing`
+        message: `${path162}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path152, candidateValue, expectedValue, weight);
+        return this.compareExact(path162, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path152,
+          path162,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path152, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path162, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path152,
+          path: path162,
           score: 0,
           weight,
           hit: false,
-          message: `${path152}: unknown match type "${match}"`
+          message: `${path162}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path152, candidateValue, expectedValue, weight) {
+  compareExact(path162, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path152,
+        path: path162,
         score: 1,
         weight,
         hit: true,
-        message: path152
+        message: path162
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path152,
+        path: path162,
         score: 0,
         weight,
         hit: false,
-        message: `${path152} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path162} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path152,
+      path: path162,
       score: 0,
       weight,
       hit: false,
-      message: `${path152} (value mismatch)`
+      message: `${path162} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path152, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path162, candidateValue, expectedValue, fieldConfig, weight) {
     const { tolerance = 0, relative = false } = fieldConfig;
     const candidateNum = toNumber(candidateValue);
     const expectedNum = toNumber(expectedValue);
     if (candidateNum === null || expectedNum === null) {
       return {
-        path: path152,
+        path: path162,
         score: 0,
         weight,
         hit: false,
-        message: `${path152} (non-numeric value)`
+        message: `${path162} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path152,
+        path: path162,
         score: 0,
         weight,
         hit: false,
-        message: `${path152} (invalid numeric value)`
+        message: `${path162} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -41490,61 +42124,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path152,
+        path: path162,
         score: 1,
         weight,
         hit: true,
-        message: `${path152} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path162} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path152,
+      path: path162,
       score: 0,
       weight,
       hit: false,
-      message: `${path152} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path162} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path152, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path162, candidateValue, expectedValue, fieldConfig, weight) {
     const formats = fieldConfig.formats ?? DEFAULT_DATE_FORMATS;
     const candidateDate = parseDate(String(candidateValue), formats);
     const expectedDate = parseDate(String(expectedValue), formats);
     if (candidateDate === null) {
       return {
-        path: path152,
+        path: path162,
         score: 0,
         weight,
         hit: false,
-        message: `${path152} (unparseable candidate date)`
+        message: `${path162} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path152,
+        path: path162,
         score: 0,
         weight,
         hit: false,
-        message: `${path152} (unparseable expected date)`
+        message: `${path162} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path152,
+        path: path162,
         score: 1,
         weight,
         hit: true,
-        message: path152
+        message: path162
       };
     }
     return {
-      path: path152,
+      path: path162,
       score: 0,
       weight,
       hit: false,
-      message: `${path152} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path162} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -41584,11 +42218,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path152) {
-  if (!path152 || !obj) {
+function resolvePath(obj, path162) {
+  if (!path162 || !obj) {
     return void 0;
   }
-  const parts = path152.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path162.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -41807,6 +42441,27 @@ function argsMatch(expected, actual) {
   }
   return true;
 }
+function checkLatency(toolName, maxDurationMs, actualDurationMs) {
+  if (maxDurationMs === void 0) {
+    return { status: "skip", message: "" };
+  }
+  if (actualDurationMs === void 0) {
+    return {
+      status: "skip",
+      message: `No duration data for ${toolName}; latency assertion skipped`
+    };
+  }
+  if (actualDurationMs <= maxDurationMs) {
+    return {
+      status: "pass",
+      message: `${toolName} completed in ${actualDurationMs}ms (max: ${maxDurationMs}ms)`
+    };
+  }
+  return {
+    status: "fail",
+    message: `${toolName} took ${actualDurationMs}ms (max: ${maxDurationMs}ms)`
+  };
+}
 var ToolTrajectoryEvaluator = class {
   kind = "tool_trajectory";
   config;
@@ -41865,7 +42520,8 @@ var ToolTrajectoryEvaluator = class {
         for (const call of message.toolCalls) {
           toolCalls.push({
             name: call.tool,
-            args: call.input
+            args: call.input,
+            durationMs: call.durationMs
           });
         }
       }
@@ -41933,17 +42589,27 @@ var ToolTrajectoryEvaluator = class {
     }
     const hits = [];
     const misses = [];
+    const warnings = [];
     let actualIndex = 0;
+    let sequenceHits = 0;
+    let latencyHits = 0;
+    let latencySkips = 0;
+    const latencyAssertionCount = expected.filter(
+      (item) => item.maxDurationMs !== void 0
+    ).length;
     for (let i = 0; i < expected.length; i++) {
       const expectedItem = expected[i];
       const expectedTool = expectedItem.tool;
       let found = false;
       let argsMismatch = false;
+      let matchedCall;
       while (actualIndex < toolCalls.length) {
         const actualCall = toolCalls[actualIndex];
         if (actualCall.name === expectedTool) {
           if (argsMatch(expectedItem.args, actualCall.args)) {
             hits.push(`Found ${expectedTool} at position ${actualIndex}`);
+            sequenceHits++;
+            matchedCall = actualCall;
             actualIndex++;
             found = true;
             break;
@@ -41960,14 +42626,35 @@ var ToolTrajectoryEvaluator = class {
       if (!found && !argsMismatch) {
         misses.push(`Expected ${expectedTool} at position ${i}, not found in remaining trace`);
       }
+      if (found && matchedCall) {
+        const latencyResult = checkLatency(
+          expectedTool,
+          expectedItem.maxDurationMs,
+          matchedCall.durationMs
+        );
+        if (latencyResult.status === "pass") {
+          hits.push(latencyResult.message);
+          latencyHits++;
+        } else if (latencyResult.status === "fail") {
+          misses.push(latencyResult.message);
+        } else if (latencyResult.message) {
+          warnings.push(latencyResult.message);
+          latencySkips++;
+        }
+      }
     }
-    const score = hits.length / expected.length;
+    for (const warning of warnings) {
+      console.warn(`[tool_trajectory] ${warning}`);
+    }
+    const effectiveLatencyAssertions = latencyAssertionCount - latencySkips;
+    const totalAssertions = expected.length + effectiveLatencyAssertions;
+    const score = totalAssertions > 0 ? (sequenceHits + latencyHits) / totalAssertions : 1;
     return {
       score,
       verdict: scoreToVerdict(score),
       hits,
       misses,
-      expectedAspectCount: expected.length
+      expectedAspectCount: totalAssertions
     };
   }
   evaluateExact(toolCalls) {
@@ -41983,6 +42670,13 @@ var ToolTrajectoryEvaluator = class {
     }
     const hits = [];
     const misses = [];
+    const warnings = [];
+    let sequenceHits = 0;
+    let latencyHits = 0;
+    let latencySkips = 0;
+    const latencyAssertionCount = expected.filter(
+      (item) => item.maxDurationMs !== void 0
+    ).length;
     if (toolCalls.length !== expected.length) {
       misses.push(`Expected ${expected.length} tool calls, got ${toolCalls.length}`);
     }
@@ -41992,26 +42686,50 @@ var ToolTrajectoryEvaluator = class {
       const expectedTool = expectedItem.tool;
       const actualCall = toolCalls[i];
       const actualTool = actualCall.name;
+      let sequenceMatched = false;
       if (actualTool === expectedTool) {
         if (argsMatch(expectedItem.args, actualCall.args)) {
           hits.push(`Position ${i}: ${expectedTool}`);
+          sequenceHits++;
+          sequenceMatched = true;
         } else {
           misses.push(`Position ${i}: ${expectedTool} args mismatch`);
         }
       } else {
         misses.push(`Position ${i}: expected ${expectedTool}, got ${actualTool}`);
       }
+      if (sequenceMatched) {
+        const latencyResult = checkLatency(
+          expectedTool,
+          expectedItem.maxDurationMs,
+          actualCall.durationMs
+        );
+        if (latencyResult.status === "pass") {
+          hits.push(latencyResult.message);
+          latencyHits++;
+        } else if (latencyResult.status === "fail") {
+          misses.push(latencyResult.message);
+        } else if (latencyResult.message) {
+          warnings.push(latencyResult.message);
+          latencySkips++;
+        }
+      }
     }
     for (let i = checkLength; i < expected.length; i++) {
       misses.push(`Position ${i}: expected ${expected[i].tool}, got nothing`);
     }
-    const score = hits.length / expected.length;
+    for (const warning of warnings) {
+      console.warn(`[tool_trajectory] ${warning}`);
+    }
+    const effectiveLatencyAssertions = latencyAssertionCount - latencySkips;
+    const totalAssertions = expected.length + effectiveLatencyAssertions;
+    const score = totalAssertions > 0 ? (sequenceHits + latencyHits) / totalAssertions : 1;
     return {
       score,
       verdict: scoreToVerdict(score),
       hits,
       misses,
-      expectedAspectCount: expected.length
+      expectedAspectCount: totalAssertions
     };
   }
 };
@@ -42167,17 +42885,17 @@ async function runEvaluation(options) {
     cache,
     useCache,
     now,
-    evalId,
+    filter: filter2,
     verbose,
     evalCases: preloadedEvalCases,
     onResult,
     onProgress
   } = options;
-  const evalCases = preloadedEvalCases ?? await loadEvalCases(evalFilePath, repoRoot, { verbose, evalId });
-  const filteredEvalCases = filterEvalCases(evalCases, evalId);
+  const evalCases = preloadedEvalCases ?? await loadEvalCases(evalFilePath, repoRoot, { verbose, filter: filter2 });
+  const filteredEvalCases = filterEvalCases(evalCases, filter2);
   if (filteredEvalCases.length === 0) {
-    if (evalId) {
-      throw new Error(`Eval case with id '${evalId}' not found in ${evalFilePath}`);
+    if (filter2) {
+      throw new Error(`No eval cases matched filter '${filter2}' in ${evalFilePath}`);
     }
     return [];
   }
@@ -42753,7 +43471,10 @@ async function runEvaluatorList(options) {
           attempt,
           promptInputs,
           now,
-          judgeProvider
+          judgeProvider,
+          outputMessages,
+          traceSummary,
+          agentTimeoutMs
         });
         const weight = evaluator.weight ?? 1;
         scored.push({ score: score2, name: evaluator.name, type: evaluator.type, weight });
@@ -42807,7 +43528,7 @@ async function runEvaluatorList(options) {
         });
       }
       if (evaluator.type === "composite") {
-        const evalFileDir = evalCase.guideline_paths[0] ? path14.dirname(evalCase.guideline_paths[0]) : process.cwd();
+        const evalFileDir = evalCase.guideline_paths[0] ? path15.dirname(evalCase.guideline_paths[0]) : process.cwd();
         const createEvaluator = (memberConfig) => {
           switch (memberConfig.type) {
             case "llm_judge":
@@ -43088,9 +43809,22 @@ async function runLlmJudgeEvaluator(options) {
     attempt,
     promptInputs,
     now,
-    judgeProvider
+    judgeProvider,
+    outputMessages,
+    traceSummary,
+    agentTimeoutMs
   } = options;
-  const customPrompt = await resolveCustomPrompt(config2);
+  const customPrompt = await resolveCustomPrompt(
+    config2,
+    {
+      evalCase,
+      candidate,
+      outputMessages,
+      traceSummary,
+      config: config2.config
+    },
+    agentTimeoutMs
+  );
   return evaluatorRegistry.llm_judge.evaluate({
     evalCase,
     candidate,
@@ -43104,23 +43838,70 @@ async function runLlmJudgeEvaluator(options) {
     evaluator: config2
   });
 }
-async function resolveCustomPrompt(config2) {
-  if (config2.promptPath) {
+async function resolveCustomPrompt(promptConfig, context, timeoutMs) {
+  if (promptConfig.resolvedPromptScript && promptConfig.resolvedPromptScript.length > 0) {
+    if (!context) {
+      throw new Error("Context required for executable prompt templates");
+    }
+    return executePromptTemplate(
+      promptConfig.resolvedPromptScript,
+      context,
+      promptConfig.config,
+      timeoutMs
+    );
+  }
+  const promptPath = promptConfig.resolvedPromptPath ?? promptConfig.promptPath;
+  if (promptPath) {
     try {
-      const content = await readTextFile(config2.promptPath);
+      const content = await readTextFile(promptPath);
       return content;
     } catch (error40) {
       const message = error40 instanceof Error ? error40.message : String(error40);
-      console.warn(`Could not read custom prompt at ${config2.promptPath}: ${message}`);
+      console.warn(`Could not read custom prompt at ${promptPath}: ${message}`);
     }
   }
-  return config2.prompt;
+  const promptValue = promptConfig.prompt;
+  if (typeof promptValue === "string") {
+    return promptValue;
+  }
+  return void 0;
+}
+async function executePromptTemplate(script, context, config2, timeoutMs) {
+  const payload = {
+    question: context.evalCase.question,
+    expectedOutcome: context.evalCase.expected_outcome,
+    expectedMessages: context.evalCase.expected_messages,
+    referenceAnswer: context.evalCase.reference_answer,
+    candidateAnswer: context.candidate,
+    outputMessages: context.outputMessages ?? null,
+    guidelineFiles: context.evalCase.guideline_paths,
+    inputFiles: context.evalCase.file_paths.filter(
+      (p) => !context.evalCase.guideline_paths.includes(p)
+    ),
+    inputMessages: context.evalCase.input_messages,
+    traceSummary: context.traceSummary ?? null,
+    config: config2 ?? context.config ?? null
+  };
+  const inputJson = JSON.stringify(toSnakeCaseDeep2(payload), null, 2);
+  const scriptPath = script[script.length - 1];
+  const cwd = path15.dirname(scriptPath);
+  try {
+    const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
+    const prompt = stdout.trim();
+    if (!prompt) {
+      throw new Error("Prompt template produced empty output");
+    }
+    return prompt;
+  } catch (error40) {
+    const message = error40 instanceof Error ? error40.message : String(error40);
+    throw new Error(`Prompt template execution failed: ${message}`);
+  }
 }
-function filterEvalCases(evalCases, evalId) {
-  if (!evalId) {
+function filterEvalCases(evalCases, filter2) {
+  if (!filter2) {
     return evalCases;
   }
-  return evalCases.filter((evalCase) => evalCase.id === evalId);
+  return evalCases.filter((evalCase) => micromatch4.isMatch(evalCase.id, filter2));
 }
 function buildEvaluatorRegistry(overrides, resolveJudgeProvider) {
   const llmJudge = overrides?.llm_judge ?? new LlmJudgeEvaluator({
@@ -43274,7 +44055,7 @@ function computeWeightedMean(entries) {
 }
 var rubricItemSchema = external_exports.object({
   id: external_exports.string().describe("Short identifier for this rubric (e.g., clarity, completeness)"),
-  description: external_exports.string().describe("What this rubric checks for"),
+  expected_outcome: external_exports.string().describe("Concrete expected outcome for this rubric item"),
   weight: external_exports.number().default(1).describe("Relative importance (default 1.0)"),
   required: external_exports.boolean().default(true).describe("Whether this is a mandatory requirement")
 });
@@ -43294,7 +44075,7 @@ You must return a valid JSON object matching this schema:
   "rubrics": [
     {
       "id": "string (short identifier)",
-      "description": "string (what to check)",
+      "expected_outcome": "string (concrete expected outcome for this rubric item)",
       "weight": number (default 1.0),
       "required": boolean (default true)
     }
@@ -43330,7 +44111,7 @@ function buildPrompt(expectedOutcome, question, referenceAnswer) {
     "Each rubric should:",
     "- Be specific and testable",
     "- Have a short, descriptive ID",
-    "- Include a clear description of what to check",
+    "- Include a clear expected outcome statement (what a good answer must demonstrate for this rubric)",
     "- Indicate if it is required (mandatory) or optional",
     "- Have an appropriate weight (default 1.0, use higher values for more important aspects)",
     "",
@@ -43395,7 +44176,7 @@ var convertCommand = command2({
     const outputPath = out ?? input.replace(/\.jsonl$/, ".yaml");
     try {
       const count = convertJsonlToYaml(input, outputPath);
-      console.log(`Converted ${count} records to ${path15.resolve(outputPath)}`);
+      console.log(`Converted ${count} records to ${path16.resolve(outputPath)}`);
     } catch (error40) {
       console.error(`Error: ${error40.message}`);
       process.exit(1);
@@ -43405,7 +44186,7 @@ var convertCommand = command2({
 
 // src/commands/eval/index.ts
 import { stat as stat4 } from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 import {
   command as command3,
   flag as flag2,
@@ -43420,19 +44201,19 @@ import fg from "fast-glob";
 // src/commands/eval/run-eval.ts
 import { constants as constants6 } from "node:fs";
 import { access as access6 } from "node:fs/promises";
-import path21 from "node:path";
+import path24 from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/commands/eval/env.ts
 import { constants as constants4 } from "node:fs";
 import { access as access4 } from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 import { config as loadDotenv } from "dotenv";
 function uniqueDirs(directories) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const dir of directories) {
-    const absolute = path16.resolve(dir);
+    const absolute = path17.resolve(dir);
     if (seen.has(absolute)) {
       continue;
     }
@@ -43451,14 +44232,14 @@ async function fileExists4(filePath) {
 }
 function collectAncestorDirectories(start, boundary) {
   const directories = [];
-  const boundaryDir = path16.resolve(boundary);
-  let current = path16.resolve(start);
+  const boundaryDir = path17.resolve(boundary);
+  let current = path17.resolve(start);
   while (current !== void 0) {
     directories.push(current);
     if (current === boundaryDir) {
       break;
     }
-    const parent = path16.dirname(current);
+    const parent = path17.dirname(current);
     if (parent === current) {
       break;
     }
@@ -43468,12 +44249,12 @@ function collectAncestorDirectories(start, boundary) {
 }
 async function loadEnvFromHierarchy(options) {
   const { testFilePath, repoRoot, verbose } = options;
-  const testDir = path16.dirname(path16.resolve(testFilePath));
+  const testDir = path17.dirname(path17.resolve(testFilePath));
   const cwd = process.cwd();
   const searchDirs = uniqueDirs([...collectAncestorDirectories(testDir, repoRoot), repoRoot, cwd]);
   const envFiles = [];
   for (const dir of searchDirs) {
-    const candidate = path16.join(dir, ".env");
+    const candidate = path17.join(dir, ".env");
     if (await fileExists4(candidate)) {
       envFiles.push(candidate);
     }
@@ -43497,7 +44278,7 @@ async function loadEnvFromHierarchy(options) {
 // src/commands/eval/jsonl-writer.ts
 import { createWriteStream as createWriteStream4 } from "node:fs";
 import { mkdir as mkdir5 } from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 import { finished } from "node:stream/promises";
 
 // ../../node_modules/.bun/async-mutex@0.5.0/node_modules/async-mutex/index.mjs
@@ -43715,7 +44496,7 @@ var JsonlWriter = class _JsonlWriter {
     this.stream = stream;
   }
   static async open(filePath) {
-    await mkdir5(path17.dirname(filePath), { recursive: true });
+    await mkdir5(path18.dirname(filePath), { recursive: true });
     const stream = createWriteStream4(filePath, { flags: "w", encoding: "utf8" });
     return new _JsonlWriter(stream);
   }
@@ -43748,7 +44529,7 @@ var JsonlWriter = class _JsonlWriter {
 // src/commands/eval/yaml-writer.ts
 import { createWriteStream as createWriteStream5 } from "node:fs";
 import { mkdir as mkdir6 } from "node:fs/promises";
-import path18 from "node:path";
+import path19 from "node:path";
 import { finished as finished2 } from "node:stream/promises";
 import { stringify as stringifyYaml2 } from "yaml";
 var YamlWriter = class _YamlWriter {
@@ -43760,7 +44541,7 @@ var YamlWriter = class _YamlWriter {
     this.stream = stream;
   }
   static async open(filePath) {
-    await mkdir6(path18.dirname(filePath), { recursive: true });
+    await mkdir6(path19.dirname(filePath), { recursive: true });
     const stream = createWriteStream5(filePath, { flags: "w", encoding: "utf8" });
     return new _YamlWriter(stream);
   }
@@ -43880,12 +44661,12 @@ var ProgressDisplay = class {
   }
   addLogPaths(paths, provider) {
     const newPaths = [];
-    for (const path29 of paths) {
-      if (this.logPathSet.has(path29)) {
+    for (const path30 of paths) {
+      if (this.logPathSet.has(path30)) {
         continue;
       }
-      this.logPathSet.add(path29);
-      newPaths.push(path29);
+      this.logPathSet.add(path30);
+      newPaths.push(path30);
     }
     if (newPaths.length === 0) {
       return;
@@ -43898,8 +44679,8 @@ var ProgressDisplay = class {
       this.hasPrintedLogHeader = true;
     }
     const startIndex = this.logPaths.length - newPaths.length;
-    newPaths.forEach((path29, offset) => {
-      console.log(`${startIndex + offset + 1}. ${path29}`);
+    newPaths.forEach((path30, offset) => {
+      console.log(`${startIndex + offset + 1}. ${path30}`);
     });
   }
   finish() {
@@ -44053,8 +44834,8 @@ function formatEvaluationSummary(summary) {
 }
 
 // ../../packages/core/dist/evaluation/validation/index.js
-import { readFile as readFile7 } from "node:fs/promises";
-import path19 from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import path20 from "node:path";
 import { parse as parse6 } from "yaml";
 import { readFile as readFile23 } from "node:fs/promises";
 import path23 from "node:path";
@@ -44072,7 +44853,7 @@ var SCHEMA_TARGETS_V2 = "agentv-targets-v2.2";
 var SCHEMA_CONFIG_V2 = "agentv-config-v2";
 async function detectFileType(filePath) {
   try {
-    const content = await readFile7(filePath, "utf8");
+    const content = await readFile8(filePath, "utf8");
     const parsed = parse6(content);
     if (typeof parsed !== "object" || parsed === null) {
       return inferFileTypeFromPath(filePath);
@@ -44097,8 +44878,8 @@ async function detectFileType(filePath) {
   }
 }
 function inferFileTypeFromPath(filePath) {
-  const normalized = path19.normalize(filePath).replace(/\\/g, "/");
-  const basename = path19.basename(filePath);
+  const normalized = path20.normalize(filePath).replace(/\\/g, "/");
+  const basename = path20.basename(filePath);
   if (normalized.includes("/.agentv/")) {
     if (basename === "config.yaml" || basename === "config.yml") {
       return "config";
@@ -44191,17 +44972,31 @@ async function validateEvalFile(filePath) {
       });
     }
     const inputMessages = evalCase.input_messages;
-    if (!Array.isArray(inputMessages)) {
+    const inputAlias = evalCase.input;
+    if (Array.isArray(inputMessages)) {
+      validateMessages(inputMessages, `${location}.input_messages`, absolutePath, errors);
+    } else if (inputAlias !== void 0) {
+      if (typeof inputAlias === "string") {
+      } else if (Array.isArray(inputAlias)) {
+        validateMessages(inputAlias, `${location}.input`, absolutePath, errors);
+      } else {
+        errors.push({
+          severity: "error",
+          filePath: absolutePath,
+          location: `${location}.input`,
+          message: "Invalid 'input' field (must be a string or array of messages)"
+        });
+      }
+    } else {
       errors.push({
         severity: "error",
         filePath: absolutePath,
         location: `${location}.input_messages`,
-        message: "Missing or invalid 'input_messages' field (must be an array)"
+        message: "Missing 'input_messages' or 'input' field (must provide one)"
       });
-    } else {
-      validateMessages(inputMessages, `${location}.input_messages`, absolutePath, errors);
     }
     const expectedMessages = evalCase.expected_messages;
+    const expectedOutputAlias = evalCase.expected_output;
     if (expectedMessages !== void 0 && !Array.isArray(expectedMessages)) {
       errors.push({
         severity: "error",
@@ -44211,6 +45006,26 @@ async function validateEvalFile(filePath) {
       });
     } else if (Array.isArray(expectedMessages)) {
       validateMessages(expectedMessages, `${location}.expected_messages`, absolutePath, errors);
+    } else if (expectedOutputAlias !== void 0) {
+      if (typeof expectedOutputAlias === "string") {
+      } else if (Array.isArray(expectedOutputAlias)) {
+        if (expectedOutputAlias.length > 0 && isObject2(expectedOutputAlias[0]) && "role" in expectedOutputAlias[0]) {
+          validateMessages(
+            expectedOutputAlias,
+            `${location}.expected_output`,
+            absolutePath,
+            errors
+          );
+        }
+      } else if (isObject2(expectedOutputAlias)) {
+      } else {
+        errors.push({
+          severity: "error",
+          filePath: absolutePath,
+          location: `${location}.expected_output`,
+          message: "Invalid 'expected_output' field (must be a string, object, or array)"
+        });
+      }
     }
   }
   return {
@@ -44863,12 +45678,12 @@ async function validateMessagesFileRefs(messages, location, searchRoots, filePat
 // src/utils/targets.ts
 import { constants as constants5 } from "node:fs";
 import { access as access5 } from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 var TARGET_FILE_CANDIDATES = [
   "targets.yaml",
   "targets.yml",
-  path20.join(".agentv", "targets.yaml"),
-  path20.join(".agentv", "targets.yml")
+  path21.join(".agentv", "targets.yaml"),
+  path21.join(".agentv", "targets.yml")
 ];
 async function fileExists5(filePath) {
   try {
@@ -44881,12 +45696,12 @@ async function fileExists5(filePath) {
 async function discoverTargetsFile(options) {
   const { explicitPath, testFilePath, repoRoot, cwd } = options;
   if (explicitPath) {
-    const resolvedExplicit = path20.resolve(explicitPath);
+    const resolvedExplicit = path21.resolve(explicitPath);
     if (await fileExists5(resolvedExplicit)) {
       return resolvedExplicit;
     }
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const nested = path20.join(resolvedExplicit, candidate);
+      const nested = path21.join(resolvedExplicit, candidate);
       if (await fileExists5(nested)) {
         return nested;
       }
@@ -44894,13 +45709,13 @@ async function discoverTargetsFile(options) {
     throw new Error(`targets.yaml not found at provided path: ${resolvedExplicit}`);
   }
   const directories = [...buildDirectoryChain(testFilePath, repoRoot)];
-  const resolvedCwd = path20.resolve(cwd);
+  const resolvedCwd = path21.resolve(cwd);
   if (!directories.includes(resolvedCwd)) {
     directories.push(resolvedCwd);
   }
   for (const directory of directories) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const fullPath = path20.join(directory, candidate);
+      const fullPath = path21.join(directory, candidate);
       if (await fileExists5(fullPath)) {
         return fullPath;
       }
@@ -44910,9 +45725,9 @@ async function discoverTargetsFile(options) {
 }
 
 // src/commands/eval/targets.ts
-var ANSI_YELLOW7 = "\x1B[33m";
-var ANSI_RED2 = "\x1B[31m";
-var ANSI_RESET7 = "\x1B[0m";
+var ANSI_YELLOW8 = "\x1B[33m";
+var ANSI_RED3 = "\x1B[31m";
+var ANSI_RESET8 = "\x1B[0m";
 function isTTY() {
   return process.stdout.isTTY ?? false;
 }
@@ -44958,8 +45773,8 @@ async function selectTarget(options) {
 Warnings in ${targetsFilePath}:`);
     for (const warning of warnings) {
       const location = warning.location ? ` [${warning.location}]` : "";
-      const prefix = useColors ? `${ANSI_YELLOW7}  \u26A0${ANSI_RESET7}` : "  \u26A0";
-      const message = useColors ? `${ANSI_YELLOW7}${warning.message}${ANSI_RESET7}` : warning.message;
+      const prefix = useColors ? `${ANSI_YELLOW8}  \u26A0${ANSI_RESET8}` : "  \u26A0";
+      const message = useColors ? `${ANSI_YELLOW8}${warning.message}${ANSI_RESET8}` : warning.message;
       console.warn(`${prefix}${location} ${message}`);
     }
     console.warn("");
@@ -44970,8 +45785,8 @@ Warnings in ${targetsFilePath}:`);
 Errors in ${targetsFilePath}:`);
     for (const error40 of errors) {
       const location = error40.location ? ` [${error40.location}]` : "";
-      const prefix = useColors ? `${ANSI_RED2}  \u2717${ANSI_RESET7}` : "  \u2717";
-      const message = useColors ? `${ANSI_RED2}${error40.message}${ANSI_RESET7}` : error40.message;
+      const prefix = useColors ? `${ANSI_RED3}  \u2717${ANSI_RESET8}` : "  \u2717";
+      const message = useColors ? `${ANSI_RED3}${error40.message}${ANSI_RESET8}` : error40.message;
       console.error(`${prefix}${location} ${message}`);
     }
     throw new Error(`Targets file validation failed with ${errors.length} error(s)`);
@@ -45054,7 +45869,7 @@ function normalizeOptions(rawOptions) {
   return {
     target: normalizeString(rawOptions.target),
     targetsPath: normalizeString(rawOptions.targets),
-    evalId: normalizeString(rawOptions.evalId),
+    filter: normalizeString(rawOptions.filter),
     workers: workers > 0 ? workers : void 0,
     outPath: normalizeString(rawOptions.out),
     format,
@@ -45076,15 +45891,15 @@ async function ensureFileExists(filePath, description) {
   }
 }
 async function findRepoRoot(start) {
-  const fallback = path21.resolve(start);
+  const fallback = path24.resolve(start);
   let current = fallback;
   while (current !== void 0) {
-    const candidate = path21.join(current, ".git");
+    const candidate = path24.join(current, ".git");
     try {
       await access6(candidate, constants6.F_OK);
       return current;
     } catch {
-      const parent = path21.dirname(current);
+      const parent = path24.dirname(current);
       if (parent === current) {
         break;
       }
@@ -45097,7 +45912,7 @@ function buildDefaultOutputPath(cwd, format) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const baseName = "eval";
   const extension = getDefaultExtension(format);
-  return path21.join(cwd, ".agentv", "results", `${baseName}_${timestamp}${extension}`);
+  return path24.join(cwd, ".agentv", "results", `${baseName}_${timestamp}${extension}`);
 }
 function createEvaluationCache() {
   const store = /* @__PURE__ */ new Map();
@@ -45122,7 +45937,7 @@ function createProgressReporter(maxWorkers, options) {
   };
 }
 function makeEvalKey(testFilePath, evalId) {
-  return `${path21.resolve(testFilePath)}::${evalId}`;
+  return `${path24.resolve(testFilePath)}::${evalId}`;
 }
 function createDisplayIdTracker() {
   const map2 = /* @__PURE__ */ new Map();
@@ -45179,9 +45994,9 @@ async function prepareFileMetadata(params) {
   const inlineTargetLabel = `${selection.targetName} [provider=${providerLabel}]`;
   const evalCases = await loadEvalCases(testFilePath, repoRoot, {
     verbose: options.verbose,
-    evalId: options.evalId
+    filter: options.filter
   });
-  const filteredIds = options.evalId ? evalCases.filter((value) => value.id === options.evalId).map((value) => value.id) : evalCases.map((value) => value.id);
+  const filteredIds = evalCases.map((value) => value.id);
   return { evalIds: filteredIds, evalCases, selection, inlineTargetLabel };
 }
 async function runWithLimit(items, limit, task) {
@@ -45252,7 +46067,6 @@ async function runSingleEvalFile(params) {
     agentTimeoutMs,
     cache,
     useCache: options.cache,
-    evalId: options.evalId,
     evalCases,
     verbose: options.verbose,
     maxConcurrency: resolvedWorkers,
@@ -45286,14 +46100,14 @@ async function runEvalCommand(input) {
   if (options.verbose) {
     console.log(`Repository root: ${repoRoot}`);
   }
-  const outputPath = options.outPath ? path21.resolve(options.outPath) : buildDefaultOutputPath(cwd, options.format);
+  const outputPath = options.outPath ? path24.resolve(options.outPath) : buildDefaultOutputPath(cwd, options.format);
   console.log(`Output path: ${outputPath}`);
   const outputWriter = await createOutputWriter(outputPath, options.format);
   const cache = options.cache ? createEvaluationCache() : void 0;
   const evaluationRunner = await resolveEvaluationRunner();
   const allResults = [];
   const seenEvalCases = /* @__PURE__ */ new Set();
-  const resolvedTestFiles = input.testFiles.map((file2) => path21.resolve(file2));
+  const resolvedTestFiles = input.testFiles.map((file2) => path24.resolve(file2));
   const displayIdTracker = createDisplayIdTracker();
   const totalWorkers = options.workers ?? DEFAULT_WORKERS;
   const fileConcurrency = Math.min(
@@ -45392,7 +46206,7 @@ async function resolveEvaluationRunner() {
   if (!overridePath) {
     return runEvaluation;
   }
-  const resolved = path21.isAbsolute(overridePath) ? overridePath : path21.resolve(process.cwd(), overridePath);
+  const resolved = path24.isAbsolute(overridePath) ? overridePath : path24.resolve(process.cwd(), overridePath);
   const moduleUrl = pathToFileURL(resolved).href;
   const mod = await import(moduleUrl);
   const candidate = mod.runEvaluation;
@@ -45428,7 +46242,7 @@ var evalCommand = command3({
     evalId: option3({
       type: optional4(string6),
       long: "eval-id",
-      description: "Run only the eval case with this identifier"
+      description: 'Filter eval cases by ID pattern (glob supported, e.g., "summary-*")'
     }),
     workers: option3({
       type: number5,
@@ -45495,7 +46309,7 @@ var evalCommand = command3({
     const rawOptions = {
       target: args.target,
       targets: args.targets,
-      evalId: args.evalId,
+      filter: args.evalId,
       workers: args.workers,
       out: args.out,
       outputFormat: args.outputFormat,
@@ -45519,10 +46333,10 @@ async function resolveEvalPaths(evalPaths, cwd) {
   const unmatched = [];
   const results = /* @__PURE__ */ new Set();
   for (const pattern of normalizedInputs) {
-    const candidatePath = path24.isAbsolute(pattern) ? path24.normalize(pattern) : path24.resolve(cwd, pattern);
+    const candidatePath = path25.isAbsolute(pattern) ? path25.normalize(pattern) : path25.resolve(cwd, pattern);
     try {
       const stats = await stat4(candidatePath);
-      if (stats.isFile() && /\.ya?ml$/i.test(candidatePath)) {
+      if (stats.isFile() && /\.(ya?ml|jsonl)$/i.test(candidatePath)) {
         results.add(candidatePath);
         continue;
       }
@@ -45537,20 +46351,20 @@ async function resolveEvalPaths(evalPaths, cwd) {
       dot: true,
       followSymbolicLinks: true
     });
-    const yamlMatches = matches.filter((filePath) => /\.ya?ml$/i.test(filePath));
+    const yamlMatches = matches.filter((filePath) => /\.(ya?ml|jsonl)$/i.test(filePath));
     if (yamlMatches.length === 0) {
       unmatched.push(pattern);
       continue;
     }
     for (const filePath of yamlMatches) {
-      results.add(path24.normalize(filePath));
+      results.add(path25.normalize(filePath));
     }
   }
   if (unmatched.length > 0) {
     throw new Error(
       `No eval files matched: ${unmatched.join(
         ", "
-      )}. Provide YAML paths or globs (e.g., "evals/**/*.yaml").`
+      )}. Provide YAML or JSONL paths or globs (e.g., "evals/**/*.yaml", "evals/**/*.jsonl").`
     );
   }
   const sorted = Array.from(results);
@@ -45562,20 +46376,20 @@ async function resolveEvalPaths(evalPaths, cwd) {
 import { command as command4, flag as flag3, option as option4, optional as optional5, positional as positional4, string as string7, subcommands } from "cmd-ts";
 
 // src/commands/generate/rubrics.ts
-import { readFile as readFile8, writeFile as writeFile6 } from "node:fs/promises";
-import path25 from "node:path";
+import { readFile as readFile9, writeFile as writeFile6 } from "node:fs/promises";
+import path26 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import { isMap, isSeq, parseDocument } from "yaml";
 function isJsonObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function asString6(value) {
+function asString7(value) {
   return typeof value === "string" ? value : void 0;
 }
 async function loadRubricGenerator() {
   const customGenerator = process.env.AGENTEVO_CLI_RUBRIC_GENERATOR;
   if (customGenerator) {
-    const generatorPath = path25.resolve(customGenerator);
+    const generatorPath = path26.resolve(customGenerator);
     const generatorUrl = pathToFileURL2(generatorPath).href;
     const module = await import(generatorUrl);
     return module.generateRubrics;
@@ -45585,8 +46399,8 @@ async function loadRubricGenerator() {
 async function generateRubricsCommand(options) {
   const { file: file2, target: targetOverride, verbose } = options;
   console.log(`Generating rubrics for: ${file2}`);
-  const absolutePath = path25.resolve(file2);
-  const content = await readFile8(absolutePath, "utf8");
+  const absolutePath = path26.resolve(file2);
+  const content = await readFile9(absolutePath, "utf8");
   const doc = parseDocument(content);
   const parsed = doc.toJSON();
   if (!isJsonObject3(parsed)) {
@@ -45625,8 +46439,8 @@ async function generateRubricsCommand(options) {
       continue;
     }
     const evalCase = rawCase;
-    const id = asString6(evalCase.id) ?? "unknown";
-    const expectedOutcome = asString6(evalCase.expected_outcome) ?? asString6(evalCase.outcome);
+    const id = asString7(evalCase.id) ?? "unknown";
+    const expectedOutcome = asString7(evalCase.expected_outcome) ?? asString7(evalCase.outcome);
     if (!expectedOutcome) {
       if (verbose) {
         console.log(`  Skipping ${id}: no expected_outcome`);
@@ -45643,7 +46457,7 @@ async function generateRubricsCommand(options) {
     }
     console.log(`  Generating rubrics for: ${id}`);
     const question = extractQuestion(evalCase);
-    const referenceAnswer = asString6(evalCase.reference_answer);
+    const referenceAnswer = asString7(evalCase.reference_answer);
     const rubrics = await generateRubricsFunc({
       expectedOutcome,
       question,
@@ -45654,14 +46468,12 @@ async function generateRubricsCommand(options) {
     if (caseNode && isMap(caseNode)) {
       caseNode.set(
         "rubrics",
-        rubrics.map(
-          (r) => ({
-            id: r.id,
-            description: r.description,
-            weight: r.weight,
-            required: r.required
-          })
-        )
+        rubrics.filter((r) => r.expected_outcome !== void 0).map((r) => ({
+          id: r.id,
+          expected_outcome: r.expected_outcome,
+          weight: r.weight,
+          required: r.required ?? true
+        }))
       );
     }
     updatedCount++;
@@ -45682,7 +46494,7 @@ Updated ${updatedCount} eval case(s) with generated rubrics`);
   }
 }
 function extractQuestion(evalCase) {
-  const explicitQuestion = asString6(evalCase.question);
+  const explicitQuestion = asString7(evalCase.question);
   if (explicitQuestion) {
     return explicitQuestion;
   }
@@ -45746,24 +46558,24 @@ var generateCommand = subcommands({
 
 // src/commands/init/index.ts
 import { existsSync, mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
-import path27 from "node:path";
+import path28 from "node:path";
 import * as readline from "node:readline/promises";
 import { command as command5, option as option5, optional as optional6, string as string8 } from "cmd-ts";
 
 // src/templates/index.ts
 import { readFileSync as readFileSync3, readdirSync, statSync } from "node:fs";
-import path26 from "node:path";
+import path27 from "node:path";
 import { fileURLToPath } from "node:url";
 function getGithubTemplates() {
   if (isDistRuntime()) {
     return getTemplatesFromDir(".github");
   }
   const templatesDir = getRepoRootFromDev();
-  const promptsDir = path26.join(templatesDir, ".github", "prompts");
+  const promptsDir = path27.join(templatesDir, ".github", "prompts");
   const promptFiles = readdirSync(promptsDir).filter((file2) => file2.startsWith("agentv-"));
   return promptFiles.map((file2) => ({
     path: `prompts/${file2}`,
-    content: readFileSync3(path26.join(promptsDir, file2), "utf-8")
+    content: readFileSync3(path27.join(promptsDir, file2), "utf-8")
   }));
 }
 function getAgentvTemplates() {
@@ -45774,47 +46586,47 @@ function getClaudeTemplates() {
     return getTemplatesFromDir(".claude");
   }
   const repoRoot = getRepoRootFromDev();
-  const skillsRoot = path26.join(repoRoot, ".claude", "skills");
+  const skillsRoot = path27.join(repoRoot, ".claude", "skills");
   const skillsToInclude = ["agentv-eval-builder", "agentv-prompt-optimizer"];
   const templates = [];
   for (const skill of skillsToInclude) {
-    const skillDir = path26.join(skillsRoot, skill);
-    const skillTemplates = readTemplatesRecursively(skillDir, path26.join("skills", skill));
+    const skillDir = path27.join(skillsRoot, skill);
+    const skillTemplates = readTemplatesRecursively(skillDir, path27.join("skills", skill));
     templates.push(...skillTemplates);
   }
   return templates;
 }
 function getTemplatesFromDir(subdir) {
-  const currentDir = path26.dirname(fileURLToPath(import.meta.url));
+  const currentDir = path27.dirname(fileURLToPath(import.meta.url));
   let templatesDir;
-  if (currentDir.includes(`${path26.sep}dist`)) {
-    templatesDir = path26.join(currentDir, "templates", subdir);
+  if (currentDir.includes(`${path27.sep}dist`)) {
+    templatesDir = path27.join(currentDir, "templates", subdir);
   } else {
-    templatesDir = path26.join(currentDir, subdir);
+    templatesDir = path27.join(currentDir, subdir);
   }
   return readTemplatesRecursively(templatesDir, "");
 }
 function isDistRuntime() {
-  const currentDir = path26.dirname(fileURLToPath(import.meta.url));
-  return currentDir.includes(`${path26.sep}dist`);
+  const currentDir = path27.dirname(fileURLToPath(import.meta.url));
+  return currentDir.includes(`${path27.sep}dist`);
 }
 function getRepoRootFromDev() {
-  const currentDir = path26.dirname(fileURLToPath(import.meta.url));
-  return path26.resolve(currentDir, "..", "..", "..", "..");
+  const currentDir = path27.dirname(fileURLToPath(import.meta.url));
+  return path27.resolve(currentDir, "..", "..", "..", "..");
 }
 function readTemplatesRecursively(dir, relativePath) {
   const templates = [];
   const entries = readdirSync(dir);
   for (const entry of entries) {
-    const fullPath = path26.join(dir, entry);
+    const fullPath = path27.join(dir, entry);
     const stat6 = statSync(fullPath);
-    const entryRelativePath = relativePath ? path26.join(relativePath, entry) : entry;
+    const entryRelativePath = relativePath ? path27.join(relativePath, entry) : entry;
     if (stat6.isDirectory()) {
       templates.push(...readTemplatesRecursively(fullPath, entryRelativePath));
     } else {
       const content = readFileSync3(fullPath, "utf-8");
       templates.push({
-        path: entryRelativePath.split(path26.sep).join("/"),
+        path: entryRelativePath.split(path27.sep).join("/"),
         // Normalize to forward slashes
         content
       });
@@ -45837,10 +46649,10 @@ async function promptYesNo(message) {
   }
 }
 async function initCommand(options = {}) {
-  const targetPath = path27.resolve(options.targetPath ?? ".");
-  const githubDir = path27.join(targetPath, ".github");
-  const agentvDir = path27.join(targetPath, ".agentv");
-  const claudeDir = path27.join(targetPath, ".claude");
+  const targetPath = path28.resolve(options.targetPath ?? ".");
+  const githubDir = path28.join(targetPath, ".github");
+  const agentvDir = path28.join(targetPath, ".agentv");
+  const claudeDir = path28.join(targetPath, ".claude");
   const githubTemplates = getGithubTemplates();
   const agentvTemplates = getAgentvTemplates();
   const claudeTemplates = getClaudeTemplates();
@@ -45848,32 +46660,32 @@ async function initCommand(options = {}) {
   const otherAgentvTemplates = agentvTemplates.filter((t) => t.path !== ".env.example");
   const existingFiles = [];
   if (envTemplate) {
-    const envFilePath = path27.join(targetPath, ".env.example");
+    const envFilePath = path28.join(targetPath, ".env.example");
     if (existsSync(envFilePath)) {
       existingFiles.push(".env.example");
     }
   }
   if (existsSync(githubDir)) {
     for (const template of githubTemplates) {
-      const targetFilePath = path27.join(githubDir, template.path);
+      const targetFilePath = path28.join(githubDir, template.path);
       if (existsSync(targetFilePath)) {
-        existingFiles.push(path27.relative(targetPath, targetFilePath));
+        existingFiles.push(path28.relative(targetPath, targetFilePath));
       }
     }
   }
   if (existsSync(agentvDir)) {
     for (const template of otherAgentvTemplates) {
-      const targetFilePath = path27.join(agentvDir, template.path);
+      const targetFilePath = path28.join(agentvDir, template.path);
       if (existsSync(targetFilePath)) {
-        existingFiles.push(path27.relative(targetPath, targetFilePath));
+        existingFiles.push(path28.relative(targetPath, targetFilePath));
       }
     }
   }
   if (existsSync(claudeDir)) {
     for (const template of claudeTemplates) {
-      const targetFilePath = path27.join(claudeDir, template.path);
+      const targetFilePath = path28.join(claudeDir, template.path);
       if (existsSync(targetFilePath)) {
-        existingFiles.push(path27.relative(targetPath, targetFilePath));
+        existingFiles.push(path28.relative(targetPath, targetFilePath));
       }
     }
   }
@@ -45900,36 +46712,36 @@ async function initCommand(options = {}) {
     mkdirSync(claudeDir, { recursive: true });
   }
   if (envTemplate) {
-    const envFilePath = path27.join(targetPath, ".env.example");
+    const envFilePath = path28.join(targetPath, ".env.example");
     writeFileSync2(envFilePath, envTemplate.content, "utf-8");
     console.log("Created .env.example");
   }
   for (const template of githubTemplates) {
-    const targetFilePath = path27.join(githubDir, template.path);
-    const targetDirPath = path27.dirname(targetFilePath);
+    const targetFilePath = path28.join(githubDir, template.path);
+    const targetDirPath = path28.dirname(targetFilePath);
     if (!existsSync(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync2(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path27.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path28.relative(targetPath, targetFilePath)}`);
   }
   for (const template of otherAgentvTemplates) {
-    const targetFilePath = path27.join(agentvDir, template.path);
-    const targetDirPath = path27.dirname(targetFilePath);
+    const targetFilePath = path28.join(agentvDir, template.path);
+    const targetDirPath = path28.dirname(targetFilePath);
     if (!existsSync(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync2(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path27.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path28.relative(targetPath, targetFilePath)}`);
   }
   for (const template of claudeTemplates) {
-    const targetFilePath = path27.join(claudeDir, template.path);
-    const targetDirPath = path27.dirname(targetFilePath);
+    const targetFilePath = path28.join(claudeDir, template.path);
+    const targetDirPath = path28.dirname(targetFilePath);
     if (!existsSync(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync2(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path27.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path28.relative(targetPath, targetFilePath)}`);
   }
   console.log("\nAgentV initialized successfully!");
   console.log("\nFiles installed to root:");
@@ -45937,17 +46749,17 @@ async function initCommand(options = {}) {
     console.log("  - .env.example");
   }
   console.log(`
-Files installed to ${path27.relative(targetPath, githubDir)}:`);
+Files installed to ${path28.relative(targetPath, githubDir)}:`);
   for (const t of githubTemplates) {
     console.log(`  - ${t.path}`);
   }
   console.log(`
-Files installed to ${path27.relative(targetPath, agentvDir)}:`);
+Files installed to ${path28.relative(targetPath, agentvDir)}:`);
   for (const t of otherAgentvTemplates) {
     console.log(`  - ${t.path}`);
   }
   console.log(`
-Files installed to ${path27.relative(targetPath, claudeDir)}:`);
+Files installed to ${path28.relative(targetPath, claudeDir)}:`);
   for (const t of claudeTemplates) {
     console.log(`  - ${t.path}`);
   }
@@ -45980,12 +46792,12 @@ var initCmdTsCommand = command5({
 import { command as command6, restPositionals as restPositionals2, string as string9 } from "cmd-ts";
 
 // src/commands/validate/format-output.ts
-var ANSI_RED3 = "\x1B[31m";
-var ANSI_YELLOW8 = "\x1B[33m";
+var ANSI_RED4 = "\x1B[31m";
+var ANSI_YELLOW9 = "\x1B[33m";
 var ANSI_GREEN = "\x1B[32m";
 var ANSI_CYAN = "\x1B[36m";
 var ANSI_BOLD = "\x1B[1m";
-var ANSI_RESET8 = "\x1B[0m";
+var ANSI_RESET9 = "\x1B[0m";
 function formatSummary(summary, useColors) {
   const lines = [];
   lines.push("");
@@ -46001,15 +46813,15 @@ function formatSummary(summary, useColors) {
 }
 function formatHeader(text2, useColors) {
   if (useColors) {
-    return `${ANSI_BOLD}${ANSI_CYAN}${text2}${ANSI_RESET8}`;
+    return `${ANSI_BOLD}${ANSI_CYAN}${text2}${ANSI_RESET9}`;
   }
   return text2;
 }
 function formatFileResult(result, useColors) {
   const lines = [];
   const status = result.valid ? "\u2713" : "\u2717";
-  const statusColor = result.valid ? ANSI_GREEN : ANSI_RED3;
-  const statusText = useColors ? `${statusColor}${status}${ANSI_RESET8}` : status;
+  const statusColor = result.valid ? ANSI_GREEN : ANSI_RED4;
+  const statusText = useColors ? `${statusColor}${status}${ANSI_RESET9}` : status;
   const fileName = result.filePath;
   lines.push(`${statusText} ${fileName}`);
   if (result.errors.length > 0) {
@@ -46021,8 +46833,8 @@ function formatFileResult(result, useColors) {
 }
 function formatError2(error40, useColors) {
   const prefix = error40.severity === "error" ? "  \u2717" : "  \u26A0";
-  const color = error40.severity === "error" ? ANSI_RED3 : ANSI_YELLOW8;
-  const coloredPrefix = useColors ? `${color}${prefix}${ANSI_RESET8}` : prefix;
+  const color = error40.severity === "error" ? ANSI_RED4 : ANSI_YELLOW9;
+  const coloredPrefix = useColors ? `${color}${prefix}${ANSI_RESET9}` : prefix;
   const location = error40.location ? ` [${error40.location}]` : "";
   return `${coloredPrefix}${location} ${error40.message}`;
 }
@@ -46035,15 +46847,15 @@ function formatStats(summary, useColors) {
     (r) => r.errors.some((e) => e.severity === "warning")
   ).length;
   if (useColors) {
-    lines.push(`${ANSI_BOLD}${totalText}${ANSI_RESET8}`);
-    lines.push(`${ANSI_GREEN}${validText}${ANSI_RESET8}`);
+    lines.push(`${ANSI_BOLD}${totalText}${ANSI_RESET9}`);
+    lines.push(`${ANSI_GREEN}${validText}${ANSI_RESET9}`);
     if (summary.invalidFiles > 0) {
-      lines.push(`${ANSI_RED3}${invalidText}${ANSI_RESET8}`);
+      lines.push(`${ANSI_RED4}${invalidText}${ANSI_RESET9}`);
     } else {
       lines.push(invalidText);
     }
     if (filesWithWarnings > 0) {
-      lines.push(`${ANSI_YELLOW8}Files with warnings: ${filesWithWarnings}${ANSI_RESET8}`);
+      lines.push(`${ANSI_YELLOW9}Files with warnings: ${filesWithWarnings}${ANSI_RESET9}`);
     }
   } else {
     lines.push(totalText);
@@ -46062,7 +46874,7 @@ function isTTY2() {
 // src/commands/validate/validate-files.ts
 import { constants as constants7 } from "node:fs";
 import { access as access7, readdir as readdir3, stat as stat5 } from "node:fs/promises";
-import path28 from "node:path";
+import path29 from "node:path";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
   const results = [];
@@ -46080,7 +46892,7 @@ async function validateFiles(paths) {
   };
 }
 async function validateSingleFile(filePath) {
-  const absolutePath = path28.resolve(filePath);
+  const absolutePath = path29.resolve(filePath);
   const fileType = await detectFileType(absolutePath);
   let result;
   if (fileType === "eval") {
@@ -46105,7 +46917,7 @@ async function validateSingleFile(filePath) {
 async function expandPaths(paths) {
   const expanded = [];
   for (const inputPath of paths) {
-    const absolutePath = path28.resolve(inputPath);
+    const absolutePath = path29.resolve(inputPath);
     try {
       await access7(absolutePath, constants7.F_OK);
     } catch {
@@ -46129,7 +46941,7 @@ async function findYamlFiles(dirPath) {
   try {
     const entries = await readdir3(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path28.join(dirPath, entry.name);
+      const fullPath = path29.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -46146,7 +46958,7 @@ async function findYamlFiles(dirPath) {
   return results;
 }
 function isYamlFile(filePath) {
-  const ext = path28.extname(filePath).toLowerCase();
+  const ext = path29.extname(filePath).toLowerCase();
   return ext === ".yaml" || ext === ".yml";
 }
 
@@ -46206,4 +47018,4 @@ export {
   app,
   runCli
 };
-//# sourceMappingURL=chunk-HTTN5OWL.js.map
+//# sourceMappingURL=chunk-XREH4WAJ.js.map