@agentv/core 4.4.0 → 4.5.0

package/dist/index.js

@@ -6803,6 +6803,7 @@ var CopilotLogProvider = class {
 
 // src/evaluation/providers/copilot-sdk.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
+import { existsSync as existsSync2 } from "node:fs";
 import { mkdir as mkdir5 } from "node:fs/promises";
 import path18 from "node:path";
 
@@ -6918,6 +6919,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) {
@@ -7149,6 +7151,14 @@ var CopilotSdkProvider = class {
     }
   }
 };
+function resolveSkillDirectories(cwd) {
+  const candidates = [
+    path18.join(cwd, ".claude", "skills"),
+    path18.join(cwd, ".agents", "skills"),
+    path18.join(cwd, ".codex", "skills")
+  ];
+  return candidates.filter((dir) => existsSync2(dir));
+}
 function summarizeSdkEvent(eventType, data) {
   if (!data || typeof data !== "object") {
     return eventType;
@@ -8177,6 +8187,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,
@@ -8291,6 +8306,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));
@@ -10340,15 +10364,15 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir16, readFile: readFile14, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
+  const { mkdir: mkdir16, readFile: readFile15, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
   const { tmpdir: tmpdir3 } = await import("node:os");
-  const path48 = await import("node:path");
+  const path49 = await import("node:path");
   const { randomUUID: randomUUID10 } = await import("node:crypto");
-  const dir = path48.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
+  const dir = path49.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
   await mkdir16(dir, { recursive: true });
-  const stdinPath = path48.join(dir, "stdin.txt");
-  const stdoutPath = path48.join(dir, "stdout.txt");
-  const stderrPath = path48.join(dir, "stderr.txt");
+  const stdinPath = path49.join(dir, "stdin.txt");
+  const stdoutPath = path49.join(dir, "stdout.txt");
+  const stderrPath = path49.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("node:child_process");
@@ -10378,8 +10402,8 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
         resolve(code ?? 0);
       });
     });
-    const stdout = (await readFile14(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile14(stderrPath, "utf8")).replace(/\r\n/g, "\n");
+    const stdout = (await readFile15(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
+    const stderr = (await readFile15(stderrPath, "utf8")).replace(/\r\n/g, "\n");
     return { stdout, stderr, exitCode };
   } finally {
     await rm6(dir, { recursive: true, force: true });
@@ -11855,11 +11879,11 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const stat9 = await fs2.stat(resolved);
-          if (stat9.isDirectory()) {
+          const stat10 = await fs2.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 fs2.open(resolved, "r");
           try {
             await fd.read(buffer, 0, buffer.length, 0);
@@ -11867,8 +11891,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) };
         }
@@ -11919,8 +11943,8 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
       const ext = path35.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
-        const stat9 = await fs2.stat(fullPath);
-        if (stat9.size > MAX_FILE_SIZE) continue;
+        const stat10 = await fs2.stat(fullPath);
+        if (stat10.size > MAX_FILE_SIZE) continue;
         const content = await fs2.readFile(fullPath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
@@ -12561,115 +12585,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path48, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path48);
-    const expectedValue = resolvePath(expectedData, path48);
+    const { path: path49, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path49);
+    const expectedValue = resolvePath(expectedData, path49);
     if (expectedValue === void 0) {
       return {
-        path: path48,
+        path: path49,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path48}: no expected value`
+        message: `${path49}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path48,
+          path: path49,
           score: 0,
           weight,
           hit: false,
-          message: `${path48} (required, missing)`
+          message: `${path49} (required, missing)`
         };
       }
       return {
-        path: path48,
+        path: path49,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path48}: optional field missing`
+        message: `${path49}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path48, candidateValue, expectedValue, weight);
+        return this.compareExact(path49, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path48,
+          path49,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path48, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path49, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path48,
+          path: path49,
           score: 0,
           weight,
           hit: false,
-          message: `${path48}: unknown match type "${match}"`
+          message: `${path49}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path48, candidateValue, expectedValue, weight) {
+  compareExact(path49, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path48,
+        path: path49,
         score: 1,
         weight,
         hit: true,
-        message: path48
+        message: path49
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path48,
+        path: path49,
         score: 0,
         weight,
         hit: false,
-        message: `${path48} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path49} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path48,
+      path: path49,
       score: 0,
       weight,
       hit: false,
-      message: `${path48} (value mismatch)`
+      message: `${path49} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path48, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path49, 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: path48,
+        path: path49,
         score: 0,
         weight,
         hit: false,
-        message: `${path48} (non-numeric value)`
+        message: `${path49} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path48,
+        path: path49,
         score: 0,
         weight,
         hit: false,
-        message: `${path48} (invalid numeric value)`
+        message: `${path49} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -12682,61 +12706,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path48,
+        path: path49,
         score: 1,
         weight,
         hit: true,
-        message: `${path48} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path49} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path48,
+      path: path49,
       score: 0,
       weight,
       hit: false,
-      message: `${path48} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path49} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path48, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path49, 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: path48,
+        path: path49,
         score: 0,
         weight,
         hit: false,
-        message: `${path48} (unparseable candidate date)`
+        message: `${path49} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path48,
+        path: path49,
         score: 0,
         weight,
         hit: false,
-        message: `${path48} (unparseable expected date)`
+        message: `${path49} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path48,
+        path: path49,
         score: 1,
         weight,
         hit: true,
-        message: path48
+        message: path49
       };
     }
     return {
-      path: path48,
+      path: path49,
       score: 0,
       weight,
       hit: false,
-      message: `${path48} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path49} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -12769,11 +12793,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path48) {
-  if (!path48 || !obj) {
+function resolvePath(obj, path49) {
+  if (!path49 || !obj) {
     return void 0;
   }
-  const parts = path48.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path49.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -12997,6 +13021,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) {
@@ -13257,8 +13289,8 @@ var TokenUsageEvaluator = class {
 };
 
 // src/evaluation/evaluators/tool-trajectory.ts
-function getNestedValue(obj, path48) {
-  const parts = path48.split(".");
+function getNestedValue(obj, path49) {
+  const parts = path49.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -14793,7 +14825,7 @@ async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
 // src/evaluation/workspace/pool-manager.ts
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { cp as cp2, mkdir as mkdir13, readFile as readFile12, readdir as readdir5, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
 import path41 from "node:path";
 import { promisify as promisify5 } from "node:util";
@@ -14899,7 +14931,7 @@ var WorkspacePoolManager = class {
       if (!locked) {
         continue;
       }
-      const slotExists = existsSync2(slotPath);
+      const slotExists = existsSync3(slotPath);
       if (slotExists) {
         await this.resetSlot(slotPath, templatePath, repos, poolReset);
         return {
@@ -15005,7 +15037,7 @@ var WorkspacePoolManager = class {
     for (const entry of entries) {
       if (entry.startsWith("slot-") && !entry.endsWith(".lock")) {
         const lockPath = path41.join(poolDir, `${entry}.lock`);
-        if (existsSync2(lockPath)) {
+        if (existsSync3(lockPath)) {
           try {
             const pidStr = await readFile12(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
@@ -15036,7 +15068,7 @@ var WorkspacePoolManager = class {
   async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
     for (const repo of repos) {
       const repoDir = path41.join(slotPath, repo.path);
-      if (!existsSync2(repoDir)) {
+      if (!existsSync3(repoDir)) {
         continue;
       }
       if (poolReset === "none") {
@@ -15061,7 +15093,7 @@ var WorkspacePoolManager = class {
 
 // src/evaluation/workspace/repo-manager.ts
 import { execFile as execFile2 } from "node:child_process";
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import path42 from "node:path";
 import { promisify as promisify6 } from "node:util";
 var execFileAsync2 = promisify6(execFile2);
@@ -15113,7 +15145,7 @@ var RepoManager = class {
           resolvedSourcePath: sourcePath ?? "",
           reason: "empty_path"
         });
-      } else if (!existsSync3(sourcePath)) {
+      } else if (!existsSync4(sourcePath)) {
         errors.push({
           repoPath: repo.path,
           resolvedSourcePath: sourcePath,
@@ -15340,8 +15372,8 @@ async function executeWorkspaceScript(config, context, 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") ?? [];
@@ -15417,7 +15449,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) {
@@ -15546,7 +15579,8 @@ async function runEvaluation(options) {
         resolveGraderProvider,
         agentTimeoutMs,
         targetResolver,
-        availableTargets
+        availableTargets,
+        threshold: scoreThreshold
       });
     } catch (error) {
       if (verbose) {
@@ -15915,7 +15949,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) {
@@ -16073,7 +16108,8 @@ async function runBatchEvaluation(options) {
     resolveGraderProvider,
     agentTimeoutMs,
     targetResolver,
-    availableTargets
+    availableTargets,
+    threshold: batchThreshold
   } = options;
   const promptInputsList = [];
   const formattingMode = usesFileReferencePrompt(provider) ? "agent" : "lm";
@@ -16158,7 +16194,8 @@ async function runBatchEvaluation(options) {
         endTime,
         targetResolver,
         availableTargets,
-        verbose
+        verbose,
+        threshold: batchThreshold
       });
       if (providerError) {
         result = {
@@ -16244,7 +16281,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";
@@ -16607,7 +16645,8 @@ async function runEvalCase(options) {
       availableTargets,
       fileChanges,
       workspacePath,
-      verbose
+      verbose,
+      threshold: caseThreshold
     });
     const totalDurationMs = Date.now() - caseStartMs;
     const graderTokens = aggregateEvaluatorTokenUsage(result.scores);
@@ -16622,7 +16661,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,
@@ -16793,7 +16832,8 @@ async function evaluateCandidate(options) {
     targetResolver,
     availableTargets,
     fileChanges,
-    workspacePath
+    workspacePath,
+    threshold: evalThreshold
   } = options;
   const gradeTimestamp = nowFn();
   const { score, scores } = await runEvaluatorsForCase({
@@ -16866,7 +16906,7 @@ async function evaluateCandidate(options) {
     scores,
     trace,
     fileChanges,
-    executionStatus: classifyQualityStatus(score.score)
+    executionStatus: classifyQualityStatus(score.score, evalThreshold)
   };
 }
 async function runEvaluatorsForCase(options) {
@@ -17331,7 +17371,7 @@ function computeWeightedMean(entries) {
 }
 
 // src/evaluation/evaluate.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync5 } from "node:fs";
 import path45 from "node:path";
 
 // src/evaluation/providers/function-provider.ts
@@ -17487,7 +17527,7 @@ async function discoverDefaultTarget(repoRoot) {
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
       const targetsPath = path45.join(dir, candidate);
-      if (!existsSync4(targetsPath)) continue;
+      if (!existsSync5(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
         const defaultTarget = definitions.find((d) => d.name === "default");
@@ -17504,7 +17544,7 @@ async function loadEnvHierarchy(repoRoot, startPath) {
   const envFiles = [];
   for (const dir of chain) {
     const envPath = path45.join(dir, ".env");
-    if (existsSync4(envPath)) envFiles.push(envPath);
+    if (existsSync5(envPath)) envFiles.push(envPath);
   }
   for (let i = 0; i < envFiles.length; i++) {
     try {
@@ -17580,12 +17620,12 @@ var CONFIG_FILE_NAMES = [
   ".agentv/config.js"
 ];
 async function loadTsConfig(projectRoot) {
-  const { existsSync: existsSync6 } = await import("node:fs");
+  const { existsSync: existsSync7 } = await import("node:fs");
   const { pathToFileURL } = await import("node:url");
   const { join: join2 } = await import("node:path");
   for (const fileName of CONFIG_FILE_NAMES) {
     const filePath = join2(projectRoot, fileName);
-    if (!existsSync6(filePath)) {
+    if (!existsSync7(filePath)) {
       continue;
     }
     try {
@@ -17723,7 +17763,7 @@ function shouldSkipCacheForTemperature(targetConfig) {
 }
 
 // src/projects.ts
-import { existsSync as existsSync5, mkdirSync, readFileSync as readFileSync2, readdirSync as readdirSync3, statSync as statSync2, writeFileSync } from "node:fs";
+import { existsSync as existsSync6, mkdirSync, readFileSync as readFileSync2, readdirSync as readdirSync3, statSync as statSync2, writeFileSync } from "node:fs";
 import path47 from "node:path";
 import { parse as parseYaml3, stringify as stringifyYaml } from "yaml";
 function getProjectsRegistryPath() {
@@ -17731,7 +17771,7 @@ function getProjectsRegistryPath() {
 }
 function loadProjectRegistry() {
   const registryPath = getProjectsRegistryPath();
-  if (!existsSync5(registryPath)) {
+  if (!existsSync6(registryPath)) {
     return { projects: [] };
   }
   try {
@@ -17748,7 +17788,7 @@ function loadProjectRegistry() {
 function saveProjectRegistry(registry) {
   const registryPath = getProjectsRegistryPath();
   const dir = path47.dirname(registryPath);
-  if (!existsSync5(dir)) {
+  if (!existsSync6(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   writeFileSync(registryPath, stringifyYaml(registry), "utf-8");
@@ -17765,10 +17805,10 @@ function deriveProjectId(dirPath, existingIds) {
 }
 function addProject(projectPath) {
   const absPath = path47.resolve(projectPath);
-  if (!existsSync5(absPath)) {
+  if (!existsSync6(absPath)) {
     throw new Error(`Directory not found: ${absPath}`);
   }
-  if (!existsSync5(path47.join(absPath, ".agentv"))) {
+  if (!existsSync6(path47.join(absPath, ".agentv"))) {
     throw new Error(`No .agentv/ directory found in ${absPath}. Run an evaluation first.`);
   }
   const registry = loadProjectRegistry();
@@ -17812,13 +17852,13 @@ function touchProject(projectId) {
 }
 function discoverProjects(rootDir, maxDepth = 2) {
   const absRoot = path47.resolve(rootDir);
-  if (!existsSync5(absRoot) || !statSync2(absRoot).isDirectory()) {
+  if (!existsSync6(absRoot) || !statSync2(absRoot).isDirectory()) {
     return [];
   }
   const results = [];
   function scan(dir, depth) {
     if (depth > maxDepth) return;
-    if (existsSync5(path47.join(dir, ".agentv"))) {
+    if (existsSync6(path47.join(dir, ".agentv"))) {
       results.push(dir);
       return;
     }
@@ -18391,6 +18431,248 @@ function toHrTime(iso) {
   return new Date(iso).getTime();
 }
 
+// src/import/claude-parser.ts
+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
+import { readdir as readdir8, stat as stat9 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import path48 from "node:path";
+var DEFAULT_PROJECTS_DIR = () => path48.join(homedir3(), ".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 readdir8(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 = path48.join(projectsDir, projectDir);
+    let entries;
+    try {
+      entries = await readdir8(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 = path48.join(dirPath, entry);
+      let updatedAt;
+      try {
+        const fileStat = await stat9(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
+import { readFile as readFile14 } from "node:fs/promises";
+async function readTranscriptFile(filePath) {
+  return readFile14(filePath, "utf8");
+}
+
 // src/index.ts
 function createAgentKernel() {
   return { status: "stub" };
@@ -18460,6 +18742,7 @@ export {
   deriveProjectId,
   detectFormat,
   discoverAssertions,
+  discoverClaudeSessions,
   discoverCopilotSessions,
   discoverGraders,
   discoverGraders as discoverJudges,
@@ -18519,12 +18802,14 @@ export {
   negateScore,
   normalizeLineEndings,
   parseAgentSkillsEvals,
+  parseClaudeSession,
   parseJsonFromText,
   parseJsonSafe,
   readJsonFile,
   readTargetDefinitions,
   readTestSuiteMetadata,
   readTextFile,
+  readTranscriptFile,
   removeProject,
   resolveAndCreateProvider,
   resolveFileReference,