agentv 5.1.0-next.1 → 5.3.0-next.1

package/dist/{chunk-GIRUNQGP.js → chunk-T32NL3E6.js}

@@ -61,11 +61,11 @@ import {
   validateFileReferences,
   validateTargetsFile,
   validateWorkspacePaths
-} from "./chunk-AM2IPHKS.js";
+} from "./chunk-FVR4RQFK.js";
 import {
   materializeEvalBundle,
   writeArtifactsFromResults as writeArtifactsFromResults2
-} from "./chunk-CBBBRTQ3.js";
+} from "./chunk-BHKQHG26.js";
 import {
   discoverClaudeSessions,
   discoverCodexSessions,
@@ -77,16 +77,17 @@ import {
   prepareEvalWorkspace,
   readGitResultArtifact,
   runBeforeSessionHook,
-  scanRepoDeps,
   syncProjects,
   transpileEvalYamlFile,
   trimBaselineResult
-} from "./chunk-GJWPQXHN.js";
+} from "./chunk-V52ATPTT.js";
 import {
   AGENTV_RESULTS_ARTIFACTS_REF,
   DEFAULT_CATEGORY,
   DEFAULT_THRESHOLD,
   EXECUTION_TRACE_SCHEMA_VERSION,
+  LEGACY_METRICS_SCHEMA_VERSION,
+  METRICS_SCHEMA_VERSION,
   RESULT_INDEX_FILENAME,
   addProject,
   aggregateRunDir,
@@ -111,6 +112,7 @@ import {
   loadTestSuite,
   mergeConfigObjects,
   normalizeCategoryPath,
+  normalizeMetricsArtifactWire,
   normalizeResultRow,
   omitExternalTraceMetadataKeys,
   parseYamlValue,
@@ -140,7 +142,7 @@ import {
   traceEnvelopeToTranscriptMessages,
   traceFromTranscriptJsonLines,
   writeArtifactsFromResults
-} from "./chunk-ZGPCX334.js";
+} from "./chunk-6ZZCDZPD.js";
 import {
   __commonJS,
   __require,
@@ -901,7 +903,7 @@ var require_src = __commonJS({
 });
 
 // src/index.ts
-import path33 from "node:path";
+import path32 from "node:path";
 
 // ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -3975,7 +3977,8 @@ export default defineAssertion(({ output }) => {
   const pass = text.length > 0;
   return {
     pass,
-    assertions: [{ text: pass ? 'Output has content' : 'Output is empty', passed: pass }],
+    score: pass ? 1 : 0,
+    reason: pass ? 'Output has content' : 'Output is empty',
   };
 });
 `,
@@ -3989,7 +3992,14 @@ export default defineAssertion(({ output }) => {
   return {
     pass: score >= 0.5,
     score,
-    assertions: [{ text: 'Output has content', passed: score === 1.0 }],
+    reason: score === 1.0 ? 'Output has content' : 'Output is empty',
+    checks: [
+      {
+        text: 'Output has content',
+        pass: score === 1.0,
+        reason: score === 1.0 ? 'Output is non-empty' : 'Output is empty',
+      },
+    ],
   };
 });
 `
@@ -5042,15 +5052,19 @@ var ScriptGraderInputSchema = external_exports.object({
   workspacePath: external_exports.string().nullable().optional(),
   config: external_exports.record(external_exports.unknown()).nullable().optional()
 });
+var ScriptGraderCheckSchema = external_exports.object({
+  id: external_exports.string().optional(),
+  text: external_exports.string(),
+  pass: external_exports.boolean(),
+  score: external_exports.number().min(0).max(1).optional(),
+  reason: external_exports.string(),
+  evidence: external_exports.string().optional()
+});
 var ScriptGraderResultSchema = external_exports.object({
+  pass: external_exports.boolean(),
   score: external_exports.number().min(0).max(1),
-  assertions: external_exports.array(
-    external_exports.object({
-      text: external_exports.string(),
-      passed: external_exports.boolean(),
-      evidence: external_exports.string().optional()
-    })
-  ).optional().default([]),
+  reason: external_exports.string(),
+  checks: external_exports.array(ScriptGraderCheckSchema).optional().default([]),
   /** Optional structured details for domain-specific metrics (e.g., TP/TN/FP/FN counts, alignments). */
   details: external_exports.record(external_exports.unknown()).optional()
 });
@@ -5192,14 +5206,26 @@ async function runScriptGrader(handler) {
     const rawResult = await handler(input);
     const result = ScriptGraderResultSchema.parse({
       ...rawResult,
-      score: clampScore(rawResult.score)
+      score: clampScore(rawResult.score),
+      checks: rawResult.checks?.map((check2) => ({
+        ...check2,
+        ...check2.score !== void 0 ? { score: clampScore(check2.score) } : {}
+      }))
     });
     console.log(JSON.stringify(result, null, 2));
   } catch (error) {
     const errorMessage = formatError(error);
     const errorResult = {
+      pass: false,
       score: 0,
-      assertions: [{ text: `Evaluation failed: ${errorMessage}`, passed: false }]
+      reason: `Evaluation failed: ${errorMessage}`,
+      checks: [
+        {
+          text: "Script grader execution",
+          pass: false,
+          reason: errorMessage
+        }
+      ]
     };
     console.log(JSON.stringify(errorResult, null, 2));
     process.exit(1);
@@ -5267,27 +5293,36 @@ function parseJsonObjectFromText(text) {
 function isVitestJsonReport(value) {
   return typeof value === "object" && value !== null && Array.isArray(value.testResults);
 }
-function assertionText(file, assertion2) {
-  const title = assertion2.fullName ?? [...assertion2.ancestorTitles ?? [], assertion2.title].filter(Boolean).join(" ");
+function assertionText(file, assertion) {
+  const title = assertion.fullName ?? [...assertion.ancestorTitles ?? [], assertion.title].filter(Boolean).join(" ");
   return title || file.name || "Vitest assertion";
 }
 function vitestReportToScriptGraderResult(report, options = {}) {
-  const assertions = (report.testResults ?? []).flatMap(
+  const checks = (report.testResults ?? []).flatMap(
     (file) => (file.assertionResults ?? []).map((item) => {
-      const passed = item.status === "passed";
+      const pass2 = item.status === "passed";
       const evidence = item.failureMessages && item.failureMessages.length > 0 ? truncate(item.failureMessages.join("\n\n")) : void 0;
       return {
         text: assertionText(file, item),
-        passed,
+        pass: pass2,
+        reason: pass2 ? "Vitest test passed." : "Vitest test failed.",
         ...evidence !== void 0 ? { evidence } : {}
       };
     })
   );
-  if (assertions.length === 0) {
-    const passed = options.passWithNoTests === true;
+  if (checks.length === 0) {
+    const pass2 = options.passWithNoTests === true;
     return ScriptGraderResultSchema.parse({
-      score: passed ? 1 : 0,
-      assertions: [{ text: "Vitest reported no tests", passed }],
+      pass: pass2,
+      score: pass2 ? 1 : 0,
+      reason: pass2 ? "Vitest reported no tests; configured to pass." : "Vitest reported no tests.",
+      checks: [
+        {
+          text: "Vitest reported no tests",
+          pass: pass2,
+          reason: pass2 ? "passWithNoTests is enabled." : "No Vitest tests were discovered."
+        }
+      ],
       details: {
         vitest_success: report.success ?? false,
         num_total_tests: report.numTotalTests ?? 0,
@@ -5298,15 +5333,18 @@ function vitestReportToScriptGraderResult(report, options = {}) {
       }
     });
   }
-  const passedCount = assertions.filter((item) => item.passed).length;
+  const passedCount = checks.filter((item) => item.pass).length;
+  const pass = passedCount === checks.length;
   return ScriptGraderResultSchema.parse({
-    score: passedCount / assertions.length,
-    assertions,
+    pass,
+    score: passedCount / checks.length,
+    reason: `${passedCount}/${checks.length} Vitest tests passed.`,
+    checks,
     details: {
-      vitest_success: report.success ?? passedCount === assertions.length,
-      num_total_tests: report.numTotalTests ?? assertions.length,
+      vitest_success: report.success ?? pass,
+      num_total_tests: report.numTotalTests ?? checks.length,
       num_passed_tests: report.numPassedTests ?? passedCount,
-      num_failed_tests: report.numFailedTests ?? assertions.length - passedCount,
+      num_failed_tests: report.numFailedTests ?? checks.length - passedCount,
       num_pending_tests: report.numPendingTests ?? 0,
       num_todo_tests: report.numTodoTests ?? 0
     }
@@ -5384,12 +5422,14 @@ async function runVitestWorkspaceGrader(options, input) {
   const workspacePath = workspacePathFrom2(input);
   if (!workspacePath) {
     return {
+      pass: false,
       score: 0,
-      assertions: [
+      reason: "Vitest workspace verifier requires workspace_path.",
+      checks: [
         {
           text: "Vitest workspace verifier requires workspace_path",
-          passed: false,
-          evidence: "Configure workspace in the eval YAML so AgentV can pass workspace_path."
+          pass: false,
+          reason: "Configure an environment recipe in the eval YAML so AgentV can pass workspace_path."
         }
       ]
     };
@@ -5423,13 +5463,16 @@ async function runVitestWorkspaceGrader(options, input) {
     const report = await readVitestReport(result, outputFile);
     return vitestReportToScriptGraderResult(report, options);
   } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
     return {
+      pass: false,
       score: 0,
-      assertions: [
+      reason: "Vitest workspace verifier failed to run.",
+      checks: [
         {
           text: "Vitest workspace verifier failed to run",
-          passed: false,
-          evidence: error instanceof Error ? error.message : String(error)
+          pass: false,
+          reason
         }
       ]
     };
@@ -7970,13 +8013,31 @@ var inspectCommand = subcommands({
 import { existsSync as existsSync6 } from "node:fs";
 import { mkdir as mkdir6, readFile as readFile4, readdir, writeFile as writeFile6 } from "node:fs/promises";
 import { join } from "node:path";
-function toAssertionResult(assertion) {
+function toComponentResult(assertion, evaluator) {
   return {
-    text: assertion.text,
-    passed: assertion.passed,
-    evidence: assertion.evidence ?? "",
+    pass: assertion.passed,
     score: assertion.passed ? 1 : 0,
-    verdict: assertion.passed ? "pass" : "fail"
+    reason: assertion.evidence ?? assertion.text,
+    assertion: {
+      ...evaluator ? { name: evaluator.name, type: evaluator.type } : {},
+      value: assertion.text
+    }
+  };
+}
+function evaluatorComponent(evaluator) {
+  const pass = evaluator.score >= DEFAULT_THRESHOLD;
+  return {
+    pass,
+    score: evaluator.score,
+    reason: pass ? "Grader passed." : "Grader failed.",
+    assertion: {
+      name: evaluator.name,
+      type: evaluator.type,
+      weight: evaluator.weight
+    },
+    component_results: evaluator.assertions.map(
+      (assertion) => toComponentResult(assertion, evaluator)
+    )
   };
 }
 var evalBenchCommand = command({
@@ -8055,20 +8116,18 @@ var evalBenchCommand = command({
       const failed = allAssertions.filter((a) => !a.passed).length;
       const passRate = allAssertions.length > 0 ? Math.round(passed / allAssertions.length * 1e3) / 1e3 : weightedScore >= 0.5 ? 1 : 0;
       allPassRates.push(passRate);
+      const pass = weightedScore >= DEFAULT_THRESHOLD;
       const grading = {
+        pass,
         score: Math.round(weightedScore * 1e3) / 1e3,
-        verdict: weightedScore >= DEFAULT_THRESHOLD ? "pass" : "fail",
-        assertion_results: allAssertions.map(toAssertionResult),
-        summary: { passed, failed, total: allAssertions.length, pass_rate: passRate },
-        graders: evaluators.map((e) => ({
-          name: e.name,
-          type: e.type,
-          score: e.score,
-          verdict: e.score >= DEFAULT_THRESHOLD ? "pass" : "fail",
-          reasoning: "",
-          weight: e.weight,
-          assertion_results: e.assertions.map(toAssertionResult)
-        }))
+        reason: pass ? "All grading components passed." : "One or more grading components failed.",
+        component_results: evaluators.length > 0 ? evaluators.map(evaluatorComponent) : allAssertions.map((assertion) => toComponentResult(assertion)),
+        metadata: {
+          pass_count: passed,
+          fail_count: failed,
+          sample_count: allAssertions.length,
+          pass_rate: passRate
+        }
       };
       await writeFile6(
         join(testDir, "grading.json"),
@@ -8079,14 +8138,10 @@ var evalBenchCommand = command({
       const scores = evaluators.map((e) => ({
         name: e.name,
         type: e.type,
+        pass: e.score >= DEFAULT_THRESHOLD,
         score: e.score,
         weight: e.weight,
-        verdict: e.score >= 0.5 ? "pass" : "fail",
-        assertions: e.assertions.map((a) => ({
-          text: a.text,
-          passed: a.passed,
-          evidence: a.evidence ?? ""
-        }))
+        reason: e.score >= DEFAULT_THRESHOLD ? "Grader passed." : "Grader failed."
       }));
       let executionStatus = "ok";
       const metricsPath = join(testDir, "metrics.json");
@@ -12783,9 +12838,10 @@ function formatSummary(results, grading) {
   let failed;
   let passRate;
   if (grading) {
-    passed = grading.summary.passed;
-    failed = grading.summary.failed;
-    passRate = grading.summary.pass_rate;
+    const metadata = grading.metadata ?? {};
+    passed = typeof metadata.pass_count === "number" ? metadata.pass_count : grading.pass ? total : 0;
+    failed = typeof metadata.sample_count === "number" && typeof metadata.pass_count === "number" ? metadata.sample_count - metadata.pass_count : total - passed;
+    passRate = typeof metadata.pass_rate === "number" ? metadata.pass_rate : total > 0 ? Math.round(passed / total * 1e3) / 1e3 : 0;
   } else {
     passed = results.filter((r) => r.score >= 1).length;
     failed = total - passed;
@@ -12844,6 +12900,94 @@ var resultsSummaryCommand = command({
 // src/commands/results/validate.ts
 import { existsSync as existsSync14, readFileSync as readFileSync12, statSync as statSync5 } from "node:fs";
 import path24 from "node:path";
+var LEGACY_GRADING_FIELDS = [
+  "assertion_results",
+  "assertions",
+  "passed",
+  "evidence",
+  "verdict",
+  "graders",
+  "checks"
+];
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateGradingNode(value, pathLabel) {
+  if (!isRecord2(value)) {
+    return [`${pathLabel} must be an object`];
+  }
+  const errors = [];
+  if (typeof value.pass !== "boolean" || typeof value.score !== "number" || typeof value.reason !== "string") {
+    errors.push(`${pathLabel} must include pass, score, and reason`);
+  }
+  if (value.component_results !== void 0) {
+    if (!Array.isArray(value.component_results)) {
+      errors.push(`${pathLabel}.component_results must be an array when present`);
+    } else {
+      value.component_results.forEach((component, index) => {
+        errors.push(...validateGradingNode(component, `${pathLabel}.component_results[${index}]`));
+      });
+    }
+  }
+  return errors;
+}
+function validateNoLegacyGradingFields(value, pathLabel) {
+  if (Array.isArray(value)) {
+    return value.flatMap(
+      (entry, index) => validateNoLegacyGradingFields(entry, `${pathLabel}[${index}]`)
+    );
+  }
+  if (!isRecord2(value)) {
+    return [];
+  }
+  const errors = [];
+  const legacyFields = LEGACY_GRADING_FIELDS.filter((field) => Object.hasOwn(value, field));
+  if (legacyFields.length > 0) {
+    errors.push(`${pathLabel} uses legacy field(s): ${legacyFields.join(", ")}`);
+  }
+  for (const [key, entry] of Object.entries(value)) {
+    errors.push(...validateNoLegacyGradingFields(entry, `${pathLabel}.${key}`));
+  }
+  return errors;
+}
+function validateMetricsArtifact(value) {
+  if (!isRecord2(value)) {
+    return [{ severity: "error", message: "metrics.json must be an object" }];
+  }
+  const diagnostics = [];
+  const schemaVersion = value.schema_version;
+  const isCurrentSchema = schemaVersion === METRICS_SCHEMA_VERSION;
+  const isLegacySchema = schemaVersion === LEGACY_METRICS_SCHEMA_VERSION;
+  if (isCurrentSchema && Object.hasOwn(value, "trace")) {
+    diagnostics.push({
+      severity: "error",
+      message: "metrics.json must not include trace in agentv.metrics.v2"
+    });
+  } else if (isLegacySchema && Object.hasOwn(value, "trace")) {
+    diagnostics.push({
+      severity: "warning",
+      message: "metrics.json uses legacy trace identity; readers ignore it"
+    });
+  }
+  if (isCurrentSchema && Object.hasOwn(value, "metrics")) {
+    diagnostics.push({
+      severity: "error",
+      message: "metrics.json must not include nested metrics in agentv.metrics.v2"
+    });
+  } else if (isLegacySchema && Object.hasOwn(value, "metrics")) {
+    diagnostics.push({
+      severity: "warning",
+      message: "metrics.json uses legacy nested metrics; readers flatten it"
+    });
+  }
+  if (!normalizeMetricsArtifactWire(value)) {
+    diagnostics.push({
+      severity: "error",
+      message: "metrics.json does not match a supported metrics artifact shape"
+    });
+  }
+  return diagnostics;
+}
 function checkDirectoryNaming(runDir) {
   const dirName = path24.basename(runDir);
   const pathSegments = path24.normalize(runDir).split(path24.sep).filter(Boolean);
@@ -12962,7 +13106,8 @@ function checkIndexJsonl(runDir) {
           if (typeof s.name !== "string") missing.push("name");
           if (typeof s.type !== "string") missing.push("type");
           if (typeof s.score !== "number") missing.push("score");
-          if (typeof s.verdict !== "string") missing.push("verdict");
+          if (typeof s.pass !== "boolean") missing.push("pass");
+          if (typeof s.reason !== "string") missing.push("reason");
           if (missing.length > 0) {
             diagnostics.push({
               severity: "warning",
@@ -13035,22 +13180,13 @@ function checkArtifactFiles(runDir, entries2) {
       } else {
         try {
           const grading = JSON.parse(readFileSync12(gradingPath, "utf8"));
-          if (Array.isArray(grading.assertion_results)) {
-          } else if (Array.isArray(grading.assertions)) {
-            diagnostics.push({
-              severity: "warning",
-              message: `${testId}: grading.json uses legacy 'assertions' array; rewrite the run to emit 'assertion_results'`
-            });
-          } else {
+          for (const error of [
+            ...validateGradingNode(grading, "grading.json"),
+            ...validateNoLegacyGradingFields(grading, "grading.json")
+          ]) {
             diagnostics.push({
               severity: "error",
-              message: `${testId}: grading.json missing 'assertion_results' array`
-            });
-          }
-          if (!grading.summary) {
-            diagnostics.push({
-              severity: "warning",
-              message: `${testId}: grading.json missing 'summary' object`
+              message: `${testId}: ${error}`
             });
           }
         } catch {
@@ -13068,6 +13204,21 @@ function checkArtifactFiles(runDir, entries2) {
           severity: "warning",
           message: `${testId}: metrics.json not found at '${entry.metrics_path}'`
         });
+      } else {
+        try {
+          const metrics = JSON.parse(readFileSync12(metricsPath, "utf8"));
+          for (const diagnostic of validateMetricsArtifact(metrics)) {
+            diagnostics.push({
+              severity: diagnostic.severity,
+              message: `${testId}: ${diagnostic.message}`
+            });
+          }
+        } catch {
+          diagnostics.push({
+            severity: "error",
+            message: `${testId}: metrics.json is not valid JSON`
+          });
+        }
       }
     }
   }
@@ -13964,7 +14115,7 @@ function inferRawContentType(filePath) {
 function contentDispositionFilename(filePath) {
   return path27.basename(filePath).replace(/["\\\r\n]/g, "_");
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function nonEmptyString(value) {
@@ -13972,12 +14123,12 @@ function nonEmptyString(value) {
 }
 function artifactPointerPath(pointer) {
   if (typeof pointer === "string") return nonEmptyString(pointer);
-  if (!isRecord2(pointer)) return void 0;
+  if (!isRecord3(pointer)) return void 0;
   return nonEmptyString(pointer.path) ?? nonEmptyString(pointer.artifact_path) ?? nonEmptyString(pointer.relative_path);
 }
 function artifactPointerDescription(pointer) {
   if (typeof pointer === "string") return pointer;
-  if (!isRecord2(pointer)) return void 0;
+  if (!isRecord3(pointer)) return void 0;
   const ref = nonEmptyString(pointer.ref);
   const storage = nonEmptyString(pointer.storage);
   const uri = nonEmptyString(pointer.uri) ?? nonEmptyString(pointer.href);
@@ -13991,19 +14142,19 @@ function artifactPointerDescription(pointer) {
   return parts.length > 0 ? parts.join(", ") : void 0;
 }
 function artifactPointerRef(pointer) {
-  return isRecord2(pointer) ? nonEmptyString(pointer.ref) : void 0;
+  return isRecord3(pointer) ? nonEmptyString(pointer.ref) : void 0;
 }
 function artifactPointerKey(pointer) {
-  return isRecord2(pointer) ? nonEmptyString(pointer.key) : void 0;
+  return isRecord3(pointer) ? nonEmptyString(pointer.key) : void 0;
 }
 function artifactPointerSha256(pointer) {
-  return isRecord2(pointer) ? nonEmptyString(pointer.sha256) : void 0;
+  return isRecord3(pointer) ? nonEmptyString(pointer.sha256) : void 0;
 }
 function artifactPointerMediaType(pointer) {
-  return isRecord2(pointer) ? nonEmptyString(pointer.media_type) : void 0;
+  return isRecord3(pointer) ? nonEmptyString(pointer.media_type) : void 0;
 }
 function artifactPointerObjectVersion(pointer) {
-  return isRecord2(pointer) ? nonEmptyString(pointer.object_version) : void 0;
+  return isRecord3(pointer) ? nonEmptyString(pointer.object_version) : void 0;
 }
 function resolveRecordArtifactPointer(record, kind) {
   const legacyArtifactPointers = record.artifact_pointers;
@@ -14350,6 +14501,12 @@ async function readArtifactCatalogEntryText(searchDir, projectId, meta, entry) {
   });
   return { content };
 }
+function readableLocalCatalogEntry(meta, entry) {
+  if (!entry || entry.storage !== "local") return entry;
+  const baseDir = runWorkspaceDirFromManifestPath(meta.path);
+  const resolved = resolveReadableRunArtifactFile(baseDir, entry.displayPath);
+  return resolved.absolutePath ? entry : void 0;
+}
 function artifactFileContentResponse(c4, filePath, fileContent) {
   if (c4.req.query("raw") === "1" || c4.req.query("download") === "1") {
     c4.header("Content-Type", inferRawContentType(filePath));
@@ -14449,7 +14606,7 @@ function buildRepeatTrialReadModels(baseDir, record) {
     const answerPath = caseTrialArtifactPath(resultDir, runPath, "outputs/answer.md");
     const resultPath = caseTrialArtifactPath(resultDir, runPath, "result.json");
     const runResult = readArtifactJsonObject(baseDir, resultPath);
-    const metrics = readArtifactJsonObject(baseDir, metricsPath);
+    const metrics = normalizeMetricsArtifactWire(readArtifactJsonObject(baseDir, metricsPath));
     const timing = readArtifactJsonObject(baseDir, timingPath);
     const toolCalls = objectField(metrics, "tool_calls");
     const tokenUsage = objectField(metrics, "tokens") ?? objectField(timing, "token_usage");
@@ -15199,6 +15356,10 @@ async function handleEvalTranscript(c4, { searchDir, projectId }) {
       runPath
     );
     const answerEntry = findPointerArtifactCatalogEntry(catalog, answer, "answer", runPath);
+    const transcriptRawEntry = readableLocalCatalogEntry(
+      meta,
+      record.transcript_raw_path ? findArtifactCatalogEntry(catalog, record.transcript_raw_path) : void 0
+    );
     if (!transcriptEntry && !transcript.path) {
       return c4.json({
         status: transcript.unsupportedReason ? "unsupported" : "missing",
@@ -15242,6 +15403,7 @@ async function handleEvalTranscript(c4, { searchDir, projectId }) {
     return c4.json({
       status: "ok",
       transcript_path: transcriptEntry.displayPath,
+      ...transcriptRawEntry && { transcript_raw_path: transcriptRawEntry.displayPath },
       content,
       language: inferLanguage(transcriptEntry.displayPath),
       ...answerEntry && { answer_path: answerEntry.displayPath },
@@ -16326,7 +16488,7 @@ import { config as loadDotenv } from "dotenv";
 var TASK_EVAL_FILENAME = "EVAL.yaml";
 var TASK_TARGETS_FILENAME = "targets.yaml";
 var ENV_REF_PATTERN = /\$\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function displayRecord(record) {
@@ -16368,11 +16530,11 @@ function stringArray(value) {
   return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
 }
 function readExecutionTarget(parsedEval) {
-  if (!isRecord3(parsedEval)) {
+  if (!isRecord4(parsedEval)) {
     return void 0;
   }
   const execution = parsedEval.execution;
-  if (isRecord3(execution) && typeof execution.target === "string" && execution.target.length > 0) {
+  if (isRecord4(execution) && typeof execution.target === "string" && execution.target.length > 0) {
     return execution.target;
   }
   return typeof parsedEval.target === "string" && parsedEval.target.length > 0 ? parsedEval.target : void 0;
@@ -16383,10 +16545,10 @@ async function readTaskTarget(evalPath, fallback) {
 }
 async function readTargetDefinitions2(targetsPath) {
   const parsed = parseYamlValue(await readFile8(targetsPath, "utf8"));
-  if (!isRecord3(parsed) || !Array.isArray(parsed.targets)) {
+  if (!isRecord4(parsed) || !Array.isArray(parsed.targets)) {
     throw new Error(`Targets file is missing a top-level targets array: ${targetsPath}`);
   }
-  return parsed.targets.filter(isRecord3);
+  return parsed.targets.filter(isRecord4);
 }
 function targetName(definition) {
   if (typeof definition.id === "string" && definition.id.trim().length > 0) {
@@ -16442,7 +16604,7 @@ function collectEnvRefs(value, names = /* @__PURE__ */ new Set()) {
     }
     return names;
   }
-  if (isRecord3(value)) {
+  if (isRecord4(value)) {
     for (const [key, entry] of Object.entries(value)) {
       if (key === "required_env") {
         for (const required of stringArray(entry)) {
@@ -17595,58 +17757,6 @@ var validateCommand = command({
   }
 });
 
-// src/commands/workspace/deps.ts
-import path32 from "node:path";
-var depsCommand = command({
-  name: "deps",
-  description: "Scan eval files and list git repo dependencies needed by workspaces",
-  args: {
-    evalPaths: restPositionals({
-      type: string,
-      displayName: "eval-paths",
-      description: "Path(s) or glob(s) to evaluation .yaml file(s)"
-    }),
-    usedBy: flag({
-      long: "used-by",
-      description: "Include list of eval files that reference each repo"
-    })
-  },
-  handler: async ({ evalPaths, usedBy }) => {
-    if (evalPaths.length === 0) {
-      console.error("Usage: agentv workspace deps <eval-paths...>");
-      process.exit(1);
-    }
-    const cwd = process.cwd();
-    const resolvedPaths = await resolveEvalPaths(evalPaths, cwd);
-    const result = await scanRepoDeps(resolvedPaths);
-    for (const err2 of result.errors) {
-      console.error(`error: ${path32.relative(cwd, err2.file)}: ${err2.message}`);
-    }
-    if (result.errors.length > 0) {
-      process.exit(1);
-    }
-    const output = {
-      repos: result.repos.map((r) => ({
-        url: r.url,
-        ...r.ref !== void 0 && { ref: r.ref },
-        ...r.sparse !== void 0 && { sparse: r.sparse },
-        ...r.ancestor !== void 0 && { ancestor: r.ancestor },
-        ...usedBy && { used_by: r.usedBy.map((p) => path32.relative(cwd, p)) }
-      }))
-    };
-    console.log(JSON.stringify(output, null, 2));
-  }
-});
-
-// src/commands/workspace/index.ts
-var workspaceCommand = subcommands({
-  name: "workspace",
-  description: "Inspect workspace dependencies",
-  cmds: {
-    deps: depsCommand
-  }
-});
-
 // src/update-check.ts
 import { spawn as spawn4 } from "node:child_process";
 import { readFile as readFile9 } from "node:fs/promises";
@@ -17655,8 +17765,8 @@ var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var CONFIG_DIR = getAgentvConfigDir();
 var CACHE_FILE = "version-check.json";
 var NPM_REGISTRY_BASE2 = "https://registry.npmjs.org/agentv/";
-async function getCachedUpdateInfo(path34) {
-  const filePath = path34 ?? join6(CONFIG_DIR, CACHE_FILE);
+async function getCachedUpdateInfo(path33) {
+  const filePath = path33 ?? join6(CONFIG_DIR, CACHE_FILE);
   try {
     const raw = await readFile9(filePath, "utf-8");
     const data = JSON.parse(raw);
@@ -17761,8 +17871,7 @@ var app = subcommands({
     trend: trendCommand,
     transpile: transpileCommand,
     trim: trimCommand,
-    validate: validateCommand,
-    workspace: workspaceCommand
+    validate: validateCommand
   }
 });
 var EVAL_SUBCOMMANDS = /* @__PURE__ */ new Set(["run", "assert", "aggregate", "bundle", "vitest"]);
@@ -17788,8 +17897,7 @@ var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
   "trend",
   "transpile",
   "trim",
-  "validate",
-  "workspace"
+  "validate"
 ]);
 function usesDeprecatedStudioAlias(argv) {
   return argv[2] === "studio";
@@ -17845,7 +17953,7 @@ ${updateNotice}
   if (shouldRunBeforeSessionHook(processedArgv)) {
     const cwd = process.cwd();
     const repoRoot = await findRepoRoot(cwd);
-    const sessionConfig = await loadConfig(path33.join(cwd, "_"), repoRoot);
+    const sessionConfig = await loadConfig(path32.join(cwd, "_"), repoRoot);
     const beforeSessionCommand = sessionConfig?.hooks?.before_session;
     if (beforeSessionCommand) {
       runBeforeSessionHook(beforeSessionCommand);
@@ -17862,4 +17970,4 @@ export {
   preprocessArgv,
   runCli
 };
-//# sourceMappingURL=chunk-GIRUNQGP.js.map
+//# sourceMappingURL=chunk-T32NL3E6.js.map