@agentv/core 4.4.1 → 4.5.0

package/dist/index.cjs

@@ -1491,6 +1491,7 @@ __export(index_exports, {
   deriveProjectId: () => deriveProjectId,
   detectFormat: () => detectFormat,
   discoverAssertions: () => discoverAssertions,
+  discoverClaudeSessions: () => discoverClaudeSessions,
   discoverCopilotSessions: () => discoverCopilotSessions,
   discoverGraders: () => discoverGraders,
   discoverJudges: () => discoverGraders,
@@ -1550,12 +1551,14 @@ __export(index_exports, {
   negateScore: () => negateScore,
   normalizeLineEndings: () => normalizeLineEndings,
   parseAgentSkillsEvals: () => parseAgentSkillsEvals,
+  parseClaudeSession: () => parseClaudeSession,
   parseJsonFromText: () => parseJsonFromText,
   parseJsonSafe: () => parseJsonSafe,
   readJsonFile: () => readJsonFile,
   readTargetDefinitions: () => readTargetDefinitions,
   readTestSuiteMetadata: () => readTestSuiteMetadata,
   readTextFile: () => readTextFile,
+  readTranscriptFile: () => readTranscriptFile,
   removeProject: () => removeProject,
   resolveAndCreateProvider: () => resolveAndCreateProvider,
   resolveFileReference: () => resolveFileReference3,
@@ -8763,6 +8766,7 @@ var CopilotLogProvider = class {
 // src/evaluation/providers/copilot-sdk.ts
 init_cjs_shims();
 var import_node_crypto6 = require("crypto");
+var import_node_fs8 = require("fs");
 var import_promises17 = require("fs/promises");
 var import_node_path20 = __toESM(require("path"), 1);
 
@@ -8879,6 +8883,7 @@ var CopilotSdkProvider = class {
     const cwd = this.resolveCwd(request.cwd);
     if (cwd) {
       sessionOptions.workingDirectory = cwd;
+      sessionOptions.skillDirectories = resolveSkillDirectories(cwd);
     }
     const systemPrompt = this.config.systemPrompt;
     if (systemPrompt) {
@@ -9110,6 +9115,14 @@ var CopilotSdkProvider = class {
     }
   }
 };
+function resolveSkillDirectories(cwd) {
+  const candidates = [
+    import_node_path20.default.join(cwd, ".claude", "skills"),
+    import_node_path20.default.join(cwd, ".agents", "skills"),
+    import_node_path20.default.join(cwd, ".codex", "skills")
+  ];
+  return candidates.filter((dir) => (0, import_node_fs8.existsSync)(dir));
+}
 function summarizeSdkEvent(eventType, data) {
   if (!data || typeof data !== "object") {
     return eventType;
@@ -9179,7 +9192,7 @@ var MockProvider = class {
 init_cjs_shims();
 var import_node_child_process4 = require("child_process");
 var import_node_crypto7 = require("crypto");
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 var import_promises18 = require("fs/promises");
 var import_node_os5 = require("os");
 var import_node_path21 = __toESM(require("path"), 1);
@@ -9552,7 +9565,7 @@ var PiStreamLogger = class _PiStreamLogger {
   constructor(filePath, format) {
     this.filePath = filePath;
     this.format = format;
-    this.stream = (0, import_node_fs8.createWriteStream)(filePath, { flags: "a" });
+    this.stream = (0, import_node_fs9.createWriteStream)(filePath, { flags: "a" });
   }
   static async create(options) {
     const logger = new _PiStreamLogger(options.filePath, options.format);
@@ -10025,7 +10038,7 @@ async function defaultPiRunner(options) {
 init_cjs_shims();
 var import_node_child_process5 = require("child_process");
 var import_node_crypto8 = require("crypto");
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 var import_promises19 = require("fs/promises");
 var import_node_path22 = __toESM(require("path"), 1);
 var import_node_readline = require("readline");
@@ -10053,7 +10066,7 @@ function findAgentvRoot() {
   for (let i = 0; i < 10; i++) {
     try {
       const pkg = import_node_path22.default.join(dir, "package.json");
-      (0, import_node_fs9.accessSync)(pkg);
+      (0, import_node_fs10.accessSync)(pkg);
       return dir;
     } catch {
       const parent = import_node_path22.default.dirname(dir);
@@ -10143,6 +10156,11 @@ var PiCodingAgentProvider = class {
       const modelId = this.config.model ?? "gemini-2.5-flash";
       this.setApiKeyEnv(providerName);
       const model = sdk.getModel(providerName, modelId);
+      if (!model) {
+        throw new Error(
+          `pi-coding-agent: getModel('${providerName}', '${modelId}') returned undefined. The model '${modelId}' is not registered for provider '${providerName}' in pi-ai. Check that subprovider and model are correct in your target config.`
+        );
+      }
       const tools = this.resolveTools(sdk);
       const { session } = await sdk.createAgentSession({
         cwd,
@@ -10257,6 +10275,15 @@ ${fileList}`;
           await session.prompt(prompt);
         }
         const agentMessages = session.agent.state.messages;
+        const lastAssistant = [...agentMessages].reverse().find(
+          (m) => !!m && typeof m === "object" && m.role === "assistant"
+        );
+        if (lastAssistant?.stopReason === "error") {
+          const errorMsg = typeof lastAssistant.errorMessage === "string" ? lastAssistant.errorMessage : "unknown SDK error";
+          throw new Error(
+            `pi-coding-agent SDK error (provider: ${lastAssistant.provider ?? providerName}, model: ${lastAssistant.model ?? modelId}): ${errorMsg}`
+          );
+        }
         const output = [];
         for (const msg of agentMessages) {
           output.push(convertAgentMessage(msg, toolTrackers, completedToolResults));
@@ -10372,7 +10399,7 @@ var PiStreamLogger2 = class _PiStreamLogger {
   constructor(filePath, format) {
     this.filePath = filePath;
     this.format = format;
-    this.stream = (0, import_node_fs9.createWriteStream)(filePath, { flags: "a" });
+    this.stream = (0, import_node_fs10.createWriteStream)(filePath, { flags: "a" });
   }
   static async create(options) {
     const logger = new _PiStreamLogger(options.filePath, options.format);
@@ -11565,8 +11592,8 @@ function resolveCliConfig(target, env, evalFilePath) {
   const parseResult = CliTargetInputSchema.safeParse(target, { errorMap: cliErrorMap });
   if (!parseResult.success) {
     const firstError = parseResult.error.errors[0];
-    const path51 = firstError?.path.join(".") || "";
-    const prefix = path51 ? `${target.name} ${path51}: ` : `${target.name}: `;
+    const path52 = firstError?.path.join(".") || "";
+    const prefix = path52 ? `${target.name} ${path52}: ` : `${target.name}: `;
     throw new Error(`${prefix}${firstError?.message}`);
   }
   const normalized = normalizeCliTargetInput(parseResult.data, env, evalFilePath);
@@ -11827,12 +11854,12 @@ var import_node_path33 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/fs.ts
 init_cjs_shims();
-var import_node_fs10 = require("fs");
+var import_node_fs11 = require("fs");
 var import_promises20 = require("fs/promises");
 var import_node_path24 = __toESM(require("path"), 1);
 async function pathExists(target) {
   try {
-    await (0, import_promises20.access)(target, import_node_fs10.constants.F_OK);
+    await (0, import_promises20.access)(target, import_node_fs11.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -13312,7 +13339,7 @@ function isAgentProvider(provider) {
 
 // src/evaluation/providers/targets-file.ts
 init_cjs_shims();
-var import_node_fs11 = require("fs");
+var import_node_fs12 = require("fs");
 var import_promises27 = require("fs/promises");
 var import_node_path36 = __toESM(require("path"), 1);
 var import_yaml7 = require("yaml");
@@ -13344,7 +13371,7 @@ function assertTargetDefinition(value, index, filePath) {
 }
 async function fileExists3(filePath) {
   try {
-    await (0, import_promises27.access)(filePath, import_node_fs11.constants.F_OK);
+    await (0, import_promises27.access)(filePath, import_node_fs12.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -13629,15 +13656,15 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir17, readFile: readFile16, rm: rm6, writeFile: writeFile9 } = await import("fs/promises");
+  const { mkdir: mkdir17, readFile: readFile17, rm: rm6, writeFile: writeFile9 } = await import("fs/promises");
   const { tmpdir: tmpdir3 } = await import("os");
-  const path51 = await import("path");
+  const path52 = await import("path");
   const { randomUUID: randomUUID10 } = await import("crypto");
-  const dir = path51.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
+  const dir = path52.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
   await mkdir17(dir, { recursive: true });
-  const stdinPath = path51.join(dir, "stdin.txt");
-  const stdoutPath = path51.join(dir, "stdout.txt");
-  const stderrPath = path51.join(dir, "stderr.txt");
+  const stdinPath = path52.join(dir, "stdin.txt");
+  const stdoutPath = path52.join(dir, "stdout.txt");
+  const stderrPath = path52.join(dir, "stderr.txt");
   await writeFile9(stdinPath, stdinPayload, "utf8");
   const wrappedCommand = process.platform === "win32" ? `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
   const { spawn: spawn5 } = await import("child_process");
@@ -13667,8 +13694,8 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
         resolve(code ?? 0);
       });
     });
-    const stdout = (await readFile16(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile16(stderrPath, "utf8")).replace(/\r\n/g, "\n");
+    const stdout = (await readFile17(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
+    const stderr = (await readFile17(stderrPath, "utf8")).replace(/\r\n/g, "\n");
     return { stdout, stderr, exitCode };
   } finally {
     await rm6(dir, { recursive: true, force: true });
@@ -15148,11 +15175,11 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const stat9 = await import_promises29.default.stat(resolved);
-          if (stat9.isDirectory()) {
+          const stat10 = await import_promises29.default.stat(resolved);
+          if (stat10.isDirectory()) {
             return { error: `'${input.path}' is a directory, not a file` };
           }
-          const buffer = Buffer.alloc(Math.min(stat9.size, MAX_FILE_SIZE));
+          const buffer = Buffer.alloc(Math.min(stat10.size, MAX_FILE_SIZE));
           const fd = await import_promises29.default.open(resolved, "r");
           try {
             await fd.read(buffer, 0, buffer.length, 0);
@@ -15160,8 +15187,8 @@ function createFilesystemTools(workspacePath) {
             await fd.close();
           }
           const content = buffer.toString("utf-8");
-          const truncated = stat9.size > MAX_FILE_SIZE;
-          return { content, truncated, size: stat9.size };
+          const truncated = stat10.size > MAX_FILE_SIZE;
+          return { content, truncated, size: stat10.size };
         } catch (error) {
           return { error: error instanceof Error ? error.message : String(error) };
         }
@@ -15212,8 +15239,8 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
       const ext = import_node_path39.default.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
-        const stat9 = await import_promises29.default.stat(fullPath);
-        if (stat9.size > MAX_FILE_SIZE) continue;
+        const stat10 = await import_promises29.default.stat(fullPath);
+        if (stat10.size > MAX_FILE_SIZE) continue;
         const content = await import_promises29.default.readFile(fullPath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
@@ -15857,115 +15884,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path51, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path51);
-    const expectedValue = resolvePath(expectedData, path51);
+    const { path: path52, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path52);
+    const expectedValue = resolvePath(expectedData, path52);
     if (expectedValue === void 0) {
       return {
-        path: path51,
+        path: path52,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path51}: no expected value`
+        message: `${path52}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path51,
+          path: path52,
           score: 0,
           weight,
           hit: false,
-          message: `${path51} (required, missing)`
+          message: `${path52} (required, missing)`
         };
       }
       return {
-        path: path51,
+        path: path52,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path51}: optional field missing`
+        message: `${path52}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path51, candidateValue, expectedValue, weight);
+        return this.compareExact(path52, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path51,
+          path52,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path51, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path52, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path51,
+          path: path52,
           score: 0,
           weight,
           hit: false,
-          message: `${path51}: unknown match type "${match}"`
+          message: `${path52}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path51, candidateValue, expectedValue, weight) {
+  compareExact(path52, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path51,
+        path: path52,
         score: 1,
         weight,
         hit: true,
-        message: path51
+        message: path52
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path51,
+        path: path52,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path52} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path51,
+      path: path52,
       score: 0,
       weight,
       hit: false,
-      message: `${path51} (value mismatch)`
+      message: `${path52} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path51, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path52, 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: path51,
+        path: path52,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (non-numeric value)`
+        message: `${path52} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path51,
+        path: path52,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (invalid numeric value)`
+        message: `${path52} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -15978,61 +16005,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path51,
+        path: path52,
         score: 1,
         weight,
         hit: true,
-        message: `${path51} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path52} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path51,
+      path: path52,
       score: 0,
       weight,
       hit: false,
-      message: `${path51} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path52} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path51, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path52, 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: path51,
+        path: path52,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (unparseable candidate date)`
+        message: `${path52} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path51,
+        path: path52,
         score: 0,
         weight,
         hit: false,
-        message: `${path51} (unparseable expected date)`
+        message: `${path52} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path51,
+        path: path52,
         score: 1,
         weight,
         hit: true,
-        message: path51
+        message: path52
       };
     }
     return {
-      path: path51,
+      path: path52,
       score: 0,
       weight,
       hit: false,
-      message: `${path51} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path52} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -16065,11 +16092,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path51) {
-  if (!path51 || !obj) {
+function resolvePath(obj, path52) {
+  if (!path52 || !obj) {
     return void 0;
   }
-  const parts = path51.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path52.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -16295,6 +16322,14 @@ var SkillTriggerEvaluator = class {
         evidence = `Read tool loaded skill file via tool name "${toolName}"`;
         break;
       }
+      if (!triggered && toolCall.output != null) {
+        const outputStr = typeof toolCall.output === "string" ? toolCall.output : JSON.stringify(toolCall.output);
+        if (outputStr.includes(`skills/${skillName}/`)) {
+          triggered = true;
+          evidence = `Tool "${toolName}" output referenced skill file for "${skillName}"`;
+          break;
+        }
+      }
     }
     const pass = triggered === shouldTrigger;
     if (pass) {
@@ -16558,8 +16593,8 @@ var TokenUsageEvaluator = class {
 
 // src/evaluation/evaluators/tool-trajectory.ts
 init_cjs_shims();
-function getNestedValue(obj, path51) {
-  const parts = path51.split(".");
+function getNestedValue(obj, path52) {
+  const parts = path52.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -17957,7 +17992,7 @@ function getTCritical(df) {
 // src/evaluation/workspace/file-changes.ts
 init_cjs_shims();
 var import_node_child_process8 = require("child_process");
-var import_node_fs12 = require("fs");
+var import_node_fs13 = require("fs");
 var import_node_path43 = __toESM(require("path"), 1);
 var import_node_util4 = require("util");
 var execAsync4 = (0, import_node_util4.promisify)(import_node_child_process8.exec);
@@ -17986,7 +18021,7 @@ async function captureFileChanges(workspacePath, baselineCommit) {
 async function stageNestedRepoChanges(workspacePath) {
   let entries;
   try {
-    entries = (0, import_node_fs12.readdirSync)(workspacePath);
+    entries = (0, import_node_fs13.readdirSync)(workspacePath);
   } catch {
     return;
   }
@@ -17994,8 +18029,8 @@ async function stageNestedRepoChanges(workspacePath) {
     if (entry === ".git" || entry === "node_modules") continue;
     const childPath = import_node_path43.default.join(workspacePath, entry);
     try {
-      if (!(0, import_node_fs12.statSync)(childPath).isDirectory()) continue;
-      if (!(0, import_node_fs12.statSync)(import_node_path43.default.join(childPath, ".git")).isDirectory()) continue;
+      if (!(0, import_node_fs13.statSync)(childPath).isDirectory()) continue;
+      if (!(0, import_node_fs13.statSync)(import_node_path43.default.join(childPath, ".git")).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -18115,7 +18150,7 @@ async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
 init_cjs_shims();
 var import_node_child_process9 = require("child_process");
 var import_node_crypto10 = require("crypto");
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 var import_promises31 = require("fs/promises");
 var import_node_path45 = __toESM(require("path"), 1);
 var import_node_util5 = require("util");
@@ -18221,7 +18256,7 @@ var WorkspacePoolManager = class {
       if (!locked) {
         continue;
       }
-      const slotExists = (0, import_node_fs13.existsSync)(slotPath);
+      const slotExists = (0, import_node_fs14.existsSync)(slotPath);
       if (slotExists) {
         await this.resetSlot(slotPath, templatePath, repos, poolReset);
         return {
@@ -18327,7 +18362,7 @@ var WorkspacePoolManager = class {
     for (const entry of entries) {
       if (entry.startsWith("slot-") && !entry.endsWith(".lock")) {
         const lockPath = import_node_path45.default.join(poolDir, `${entry}.lock`);
-        if ((0, import_node_fs13.existsSync)(lockPath)) {
+        if ((0, import_node_fs14.existsSync)(lockPath)) {
           try {
             const pidStr = await (0, import_promises31.readFile)(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
@@ -18358,7 +18393,7 @@ var WorkspacePoolManager = class {
   async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
     for (const repo of repos) {
       const repoDir = import_node_path45.default.join(slotPath, repo.path);
-      if (!(0, import_node_fs13.existsSync)(repoDir)) {
+      if (!(0, import_node_fs14.existsSync)(repoDir)) {
         continue;
       }
       if (poolReset === "none") {
@@ -18384,7 +18419,7 @@ var WorkspacePoolManager = class {
 // src/evaluation/workspace/repo-manager.ts
 init_cjs_shims();
 var import_node_child_process10 = require("child_process");
-var import_node_fs14 = require("fs");
+var import_node_fs15 = require("fs");
 var import_node_path46 = __toESM(require("path"), 1);
 var import_node_util6 = require("util");
 var execFileAsync2 = (0, import_node_util6.promisify)(import_node_child_process10.execFile);
@@ -18436,7 +18471,7 @@ var RepoManager = class {
           resolvedSourcePath: sourcePath ?? "",
           reason: "empty_path"
         });
-      } else if (!(0, import_node_fs14.existsSync)(sourcePath)) {
+      } else if (!(0, import_node_fs15.existsSync)(sourcePath)) {
         errors.push({
           repoPath: repo.path,
           resolvedSourcePath: sourcePath,
@@ -18665,8 +18700,8 @@ async function executeWorkspaceScript(config, context2, failureMode = "fatal") {
 }
 
 // src/evaluation/orchestrator.ts
-function classifyQualityStatus(score) {
-  return score >= PASS_THRESHOLD ? "ok" : "quality_failure";
+function classifyQualityStatus(score, threshold = PASS_THRESHOLD) {
+  return score >= threshold ? "ok" : "quality_failure";
 }
 function buildSkippedEvaluatorError(scores) {
   const skippedScores = scores?.filter((score) => score.verdict === "skip") ?? [];
@@ -18742,7 +18777,8 @@ async function runEvaluation(options) {
     retainOnSuccess,
     retainOnFailure,
     graderTarget: cliGraderTarget,
-    model: cliModel
+    model: cliModel,
+    threshold: scoreThreshold
   } = options;
   let useCache = options.useCache;
   if (trials && trials.count > 1 && useCache) {
@@ -18871,7 +18907,8 @@ async function runEvaluation(options) {
         resolveGraderProvider,
         agentTimeoutMs,
         targetResolver,
-        availableTargets
+        availableTargets,
+        threshold: scoreThreshold
       });
     } catch (error) {
       if (verbose) {
@@ -19240,7 +19277,8 @@ async function runEvaluation(options) {
             typeRegistry,
             repoManager,
             evalDir,
-            verbose
+            verbose,
+            threshold: scoreThreshold
           };
           let result = trials && trials.count > 1 ? await runEvalCaseWithTrials(runCaseOptions, trials) : await runEvalCase(runCaseOptions);
           if (totalBudgetUsd !== void 0) {
@@ -19398,7 +19436,8 @@ async function runBatchEvaluation(options) {
     resolveGraderProvider,
     agentTimeoutMs,
     targetResolver,
-    availableTargets
+    availableTargets,
+    threshold: batchThreshold
   } = options;
   const promptInputsList = [];
   const formattingMode = usesFileReferencePrompt(provider) ? "agent" : "lm";
@@ -19483,7 +19522,8 @@ async function runBatchEvaluation(options) {
         endTime,
         targetResolver,
         availableTargets,
-        verbose
+        verbose,
+        threshold: batchThreshold
       });
       if (providerError) {
         result = {
@@ -19569,7 +19609,8 @@ async function runEvalCase(options) {
     typeRegistry: providedTypeRegistry,
     repoManager,
     evalDir,
-    verbose
+    verbose,
+    threshold: caseThreshold
   } = options;
   const setupDebug = process.env.AGENTV_SETUP_DEBUG === "1";
   const formattingMode = usesFileReferencePrompt(provider) ? "agent" : "lm";
@@ -19932,7 +19973,8 @@ async function runEvalCase(options) {
       availableTargets,
       fileChanges,
       workspacePath,
-      verbose
+      verbose,
+      threshold: caseThreshold
     });
     const totalDurationMs = Date.now() - caseStartMs;
     const graderTokens = aggregateEvaluatorTokenUsage(result.scores);
@@ -19947,7 +19989,7 @@ async function runEvalCase(options) {
       ...evalRunTokenUsage ? { tokenUsage: evalRunTokenUsage } : {}
     };
     const skippedEvaluatorError = buildSkippedEvaluatorError(result.scores);
-    const executionStatus = providerError || skippedEvaluatorError ? "execution_error" : classifyQualityStatus(result.score);
+    const executionStatus = providerError || skippedEvaluatorError ? "execution_error" : classifyQualityStatus(result.score, caseThreshold);
     const finalResult = providerError ? {
       ...result,
       evalRun,
@@ -20118,7 +20160,8 @@ async function evaluateCandidate(options) {
     targetResolver,
     availableTargets,
     fileChanges,
-    workspacePath
+    workspacePath,
+    threshold: evalThreshold
   } = options;
   const gradeTimestamp = nowFn();
   const { score, scores } = await runEvaluatorsForCase({
@@ -20191,7 +20234,7 @@ async function evaluateCandidate(options) {
     scores,
     trace: trace2,
     fileChanges,
-    executionStatus: classifyQualityStatus(score.score)
+    executionStatus: classifyQualityStatus(score.score, evalThreshold)
   };
 }
 async function runEvaluatorsForCase(options) {
@@ -20657,7 +20700,7 @@ function computeWeightedMean(entries) {
 
 // src/evaluation/evaluate.ts
 init_cjs_shims();
-var import_node_fs15 = require("fs");
+var import_node_fs16 = require("fs");
 var import_node_path49 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/function-provider.ts
@@ -20814,7 +20857,7 @@ async function discoverDefaultTarget(repoRoot) {
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
       const targetsPath = import_node_path49.default.join(dir, candidate);
-      if (!(0, import_node_fs15.existsSync)(targetsPath)) continue;
+      if (!(0, import_node_fs16.existsSync)(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
         const defaultTarget = definitions.find((d) => d.name === "default");
@@ -20831,7 +20874,7 @@ async function loadEnvHierarchy(repoRoot, startPath) {
   const envFiles = [];
   for (const dir of chain) {
     const envPath = import_node_path49.default.join(dir, ".env");
-    if ((0, import_node_fs15.existsSync)(envPath)) envFiles.push(envPath);
+    if ((0, import_node_fs16.existsSync)(envPath)) envFiles.push(envPath);
   }
   for (let i = 0; i < envFiles.length; i++) {
     try {
@@ -20908,12 +20951,12 @@ var CONFIG_FILE_NAMES = [
   ".agentv/config.js"
 ];
 async function loadTsConfig(projectRoot) {
-  const { existsSync: existsSync6 } = await import("fs");
+  const { existsSync: existsSync7 } = await import("fs");
   const { pathToFileURL } = await import("url");
   const { join: join2 } = await import("path");
   for (const fileName of CONFIG_FILE_NAMES) {
     const filePath = join2(projectRoot, fileName);
-    if (!existsSync6(filePath)) {
+    if (!existsSync7(filePath)) {
       continue;
     }
     try {
@@ -21060,7 +21103,7 @@ function shouldSkipCacheForTemperature(targetConfig) {
 
 // src/projects.ts
 init_cjs_shims();
-var import_node_fs16 = require("fs");
+var import_node_fs17 = require("fs");
 var import_node_path51 = __toESM(require("path"), 1);
 var import_yaml8 = require("yaml");
 function getProjectsRegistryPath() {
@@ -21068,11 +21111,11 @@ function getProjectsRegistryPath() {
 }
 function loadProjectRegistry() {
   const registryPath = getProjectsRegistryPath();
-  if (!(0, import_node_fs16.existsSync)(registryPath)) {
+  if (!(0, import_node_fs17.existsSync)(registryPath)) {
     return { projects: [] };
   }
   try {
-    const raw = (0, import_node_fs16.readFileSync)(registryPath, "utf-8");
+    const raw = (0, import_node_fs17.readFileSync)(registryPath, "utf-8");
     const parsed = (0, import_yaml8.parse)(raw);
     if (!parsed || !Array.isArray(parsed.projects)) {
       return { projects: [] };
@@ -21085,10 +21128,10 @@ function loadProjectRegistry() {
 function saveProjectRegistry(registry) {
   const registryPath = getProjectsRegistryPath();
   const dir = import_node_path51.default.dirname(registryPath);
-  if (!(0, import_node_fs16.existsSync)(dir)) {
-    (0, import_node_fs16.mkdirSync)(dir, { recursive: true });
+  if (!(0, import_node_fs17.existsSync)(dir)) {
+    (0, import_node_fs17.mkdirSync)(dir, { recursive: true });
   }
-  (0, import_node_fs16.writeFileSync)(registryPath, (0, import_yaml8.stringify)(registry), "utf-8");
+  (0, import_node_fs17.writeFileSync)(registryPath, (0, import_yaml8.stringify)(registry), "utf-8");
 }
 function deriveProjectId(dirPath, existingIds) {
   const base = import_node_path51.default.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
@@ -21102,10 +21145,10 @@ function deriveProjectId(dirPath, existingIds) {
 }
 function addProject(projectPath) {
   const absPath = import_node_path51.default.resolve(projectPath);
-  if (!(0, import_node_fs16.existsSync)(absPath)) {
+  if (!(0, import_node_fs17.existsSync)(absPath)) {
     throw new Error(`Directory not found: ${absPath}`);
   }
-  if (!(0, import_node_fs16.existsSync)(import_node_path51.default.join(absPath, ".agentv"))) {
+  if (!(0, import_node_fs17.existsSync)(import_node_path51.default.join(absPath, ".agentv"))) {
     throw new Error(`No .agentv/ directory found in ${absPath}. Run an evaluation first.`);
   }
   const registry = loadProjectRegistry();
@@ -21149,19 +21192,19 @@ function touchProject(projectId) {
 }
 function discoverProjects(rootDir, maxDepth = 2) {
   const absRoot = import_node_path51.default.resolve(rootDir);
-  if (!(0, import_node_fs16.existsSync)(absRoot) || !(0, import_node_fs16.statSync)(absRoot).isDirectory()) {
+  if (!(0, import_node_fs17.existsSync)(absRoot) || !(0, import_node_fs17.statSync)(absRoot).isDirectory()) {
     return [];
   }
   const results = [];
   function scan(dir, depth) {
     if (depth > maxDepth) return;
-    if ((0, import_node_fs16.existsSync)(import_node_path51.default.join(dir, ".agentv"))) {
+    if ((0, import_node_fs17.existsSync)(import_node_path51.default.join(dir, ".agentv"))) {
       results.push(dir);
       return;
     }
     if (depth === maxDepth) return;
     try {
-      const entries = (0, import_node_fs16.readdirSync)(dir, { withFileTypes: true });
+      const entries = (0, import_node_fs17.readdirSync)(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
@@ -21737,6 +21780,254 @@ function toHrTime(iso) {
 // src/observability/index.ts
 init_otlp_json_file_exporter();
 
+// src/import/index.ts
+init_cjs_shims();
+
+// src/import/claude-parser.ts
+init_cjs_shims();
+var SKIPPED_TYPES = /* @__PURE__ */ new Set(["progress", "system", "file-history-snapshot"]);
+function parseClaudeSession(jsonl) {
+  const messages = [];
+  let sessionId = "";
+  let projectPath;
+  let model;
+  let startTimestamp;
+  let endTimestamp;
+  const usageByRequestId = /* @__PURE__ */ new Map();
+  let lastAssistantRequestId;
+  let lastAssistantIdx = -1;
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  const lines = jsonl.split("\n").filter((l) => l.trim().length > 0);
+  for (const line of lines) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!event.type) continue;
+    if (event.timestamp) {
+      if (!startTimestamp) startTimestamp = event.timestamp;
+      endTimestamp = event.timestamp;
+    }
+    if (SKIPPED_TYPES.has(event.type)) continue;
+    if (event.isSidechain) continue;
+    if (!sessionId && event.sessionId) {
+      sessionId = event.sessionId;
+    }
+    if (!projectPath && event.cwd) {
+      projectPath = event.cwd;
+    }
+    switch (event.type) {
+      case "user": {
+        const msg = event.message;
+        if (!msg) break;
+        const contentArr = msg.content;
+        if (Array.isArray(contentArr)) {
+          for (const block of contentArr) {
+            if (block.type === "tool_result" && block.tool_use_id) {
+              const pending = pendingToolCalls.get(block.tool_use_id);
+              if (pending) {
+                const existingMsg = messages[pending.msgIdx];
+                const existingCalls = [...existingMsg.toolCalls ?? []];
+                existingCalls[pending.toolIdx] = {
+                  ...existingCalls[pending.toolIdx],
+                  output: extractToolResultContent(block.content)
+                };
+                messages[pending.msgIdx] = { ...existingMsg, toolCalls: existingCalls };
+                pendingToolCalls.delete(block.tool_use_id);
+              }
+            }
+          }
+        }
+        const text = extractTextContent2(contentArr);
+        if (text !== void 0) {
+          messages.push({ role: "user", content: text });
+        }
+        break;
+      }
+      case "assistant": {
+        const msg = event.message;
+        if (!msg) break;
+        if (!model && msg.model) {
+          model = msg.model;
+        }
+        if (msg.usage && event.requestId) {
+          usageByRequestId.set(event.requestId, msg.usage);
+        }
+        const { text, toolCalls } = extractAssistantContent(msg.content);
+        if (event.requestId && event.requestId === lastAssistantRequestId && lastAssistantIdx >= 0) {
+          messages[lastAssistantIdx] = {
+            role: "assistant",
+            content: text || void 0,
+            toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+          };
+          registerPendingToolCalls(toolCalls, lastAssistantIdx, pendingToolCalls);
+        } else {
+          if (text || toolCalls.length > 0) {
+            lastAssistantIdx = messages.length;
+            messages.push({
+              role: "assistant",
+              content: text || void 0,
+              toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+            });
+            registerPendingToolCalls(toolCalls, lastAssistantIdx, pendingToolCalls);
+          }
+        }
+        lastAssistantRequestId = event.requestId;
+        break;
+      }
+    }
+  }
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  for (const usage of usageByRequestId.values()) {
+    totalInputTokens += Number(usage.input_tokens ?? 0);
+    totalOutputTokens += Number(usage.output_tokens ?? 0);
+  }
+  const hasUsage = usageByRequestId.size > 0;
+  let durationMs;
+  if (startTimestamp && endTimestamp) {
+    durationMs = new Date(endTimestamp).getTime() - new Date(startTimestamp).getTime();
+  }
+  const source = {
+    provider: "claude",
+    sessionId,
+    projectPath,
+    startedAt: startTimestamp,
+    model
+  };
+  return {
+    messages,
+    source,
+    tokenUsage: hasUsage ? { input: totalInputTokens, output: totalOutputTokens } : void 0,
+    durationMs,
+    costUsd: null
+  };
+}
+function registerPendingToolCalls(toolCalls, msgIdx, pending) {
+  for (let i = 0; i < toolCalls.length; i++) {
+    const id = toolCalls[i].id;
+    if (id) {
+      pending.set(id, { msgIdx, toolIdx: i });
+    }
+  }
+}
+function extractTextContent2(content) {
+  if (content === void 0 || content === null) return void 0;
+  if (typeof content === "string") return content;
+  const textParts = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text) {
+      textParts.push(block.text);
+    }
+  }
+  return textParts.length > 0 ? textParts.join("") : void 0;
+}
+function extractAssistantContent(content) {
+  if (content === void 0 || content === null) {
+    return { text: void 0, toolCalls: [] };
+  }
+  if (typeof content === "string") {
+    return { text: content, toolCalls: [] };
+  }
+  const textParts = [];
+  const toolCalls = [];
+  for (const block of content) {
+    switch (block.type) {
+      case "text":
+        if (block.text) textParts.push(block.text);
+        break;
+      case "tool_use":
+        if (block.name) {
+          toolCalls.push({
+            tool: block.name,
+            input: block.input,
+            id: block.id
+          });
+        }
+        break;
+    }
+  }
+  return {
+    text: textParts.length > 0 ? textParts.join("") : void 0,
+    toolCalls
+  };
+}
+function extractToolResultContent(content) {
+  if (content === void 0 || content === null) return void 0;
+  if (typeof content === "string") return content;
+  const parts = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text) {
+      parts.push(block.text);
+    }
+  }
+  return parts.length > 0 ? parts.join("") : void 0;
+}
+
+// src/import/session-discovery.ts
+init_cjs_shims();
+var import_promises36 = require("fs/promises");
+var import_node_os8 = require("os");
+var import_node_path53 = __toESM(require("path"), 1);
+var DEFAULT_PROJECTS_DIR = () => import_node_path53.default.join((0, import_node_os8.homedir)(), ".claude", "projects");
+function encodeProjectPath(projectPath) {
+  return projectPath.replace(/\//g, "-");
+}
+async function discoverClaudeSessions(opts) {
+  const projectsDir = opts?.projectsDir ?? DEFAULT_PROJECTS_DIR();
+  const limit = opts?.latest ? 1 : opts?.limit ?? 10;
+  let projectDirs;
+  try {
+    projectDirs = await (0, import_promises36.readdir)(projectsDir);
+  } catch {
+    return [];
+  }
+  if (opts?.projectPath) {
+    const encoded = encodeProjectPath(opts.projectPath);
+    projectDirs = projectDirs.filter((dir) => dir === encoded || dir.includes(encoded));
+  }
+  const sessions = [];
+  for (const projectDir of projectDirs) {
+    const dirPath = import_node_path53.default.join(projectsDir, projectDir);
+    let entries;
+    try {
+      entries = await (0, import_promises36.readdir)(dirPath);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".jsonl")) continue;
+      const sessionId = entry.replace(/\.jsonl$/, "");
+      if (opts?.sessionId && sessionId !== opts.sessionId) continue;
+      const filePath = import_node_path53.default.join(dirPath, entry);
+      let updatedAt;
+      try {
+        const fileStat = await (0, import_promises36.stat)(filePath);
+        updatedAt = fileStat.mtime;
+      } catch {
+        updatedAt = /* @__PURE__ */ new Date(0);
+      }
+      sessions.push({
+        sessionId,
+        filePath,
+        projectDir,
+        updatedAt
+      });
+    }
+  }
+  sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+  return sessions.slice(0, limit);
+}
+
+// src/import/types.ts
+init_cjs_shims();
+var import_promises37 = require("fs/promises");
+async function readTranscriptFile(filePath) {
+  return (0, import_promises37.readFile)(filePath, "utf8");
+}
+
 // src/index.ts
 function createAgentKernel() {
   return { status: "stub" };
@@ -21807,6 +22098,7 @@ function createAgentKernel() {
   deriveProjectId,
   detectFormat,
   discoverAssertions,
+  discoverClaudeSessions,
   discoverCopilotSessions,
   discoverGraders,
   discoverJudges,
@@ -21866,12 +22158,14 @@ function createAgentKernel() {
   negateScore,
   normalizeLineEndings,
   parseAgentSkillsEvals,
+  parseClaudeSession,
   parseJsonFromText,
   parseJsonSafe,
   readJsonFile,
   readTargetDefinitions,
   readTestSuiteMetadata,
   readTextFile,
+  readTranscriptFile,
   removeProject,
   resolveAndCreateProvider,
   resolveFileReference,