@agentv/core 4.31.3 → 4.32.0-next.1

package/dist/index.cjs

@@ -727,6 +727,43 @@ var init_case_file_loader = __esm({
   }
 });
 
+// src/paths.ts
+function readEnvPath(name) {
+  const value = process.env[name];
+  if (!value || value === "undefined") return void 0;
+  return value;
+}
+function getAgentvConfigDir() {
+  return readEnvPath("AGENTV_HOME") ?? import_node_path3.default.join(import_node_os.default.homedir(), ".agentv");
+}
+function getAgentvHome() {
+  return getAgentvConfigDir();
+}
+function getAgentvDataDir() {
+  return readEnvPath("AGENTV_DATA_DIR") ?? getAgentvConfigDir();
+}
+function getWorkspacesRoot() {
+  return import_node_path3.default.join(getAgentvDataDir(), "workspaces");
+}
+function getSubagentsRoot() {
+  return import_node_path3.default.join(getAgentvDataDir(), "subagents");
+}
+function getTraceStateRoot() {
+  return import_node_path3.default.join(getAgentvDataDir(), "trace-state");
+}
+function getWorkspacePoolRoot() {
+  return import_node_path3.default.join(getAgentvDataDir(), "workspace-pool");
+}
+var import_node_os, import_node_path3;
+var init_paths = __esm({
+  "src/paths.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_os = __toESM(require("os"), 1);
+    import_node_path3 = __toESM(require("path"), 1);
+  }
+});
+
 // src/evaluation/loaders/file-resolver.ts
 async function fileExists(absolutePath) {
   try {
@@ -744,15 +781,15 @@ function resolveToAbsolutePath(candidate) {
     if (candidate.startsWith("file:")) {
       return (0, import_node_url.fileURLToPath)(candidate);
     }
-    return import_node_path3.default.resolve(candidate);
+    return import_node_path4.default.resolve(candidate);
   }
   throw new TypeError("Unsupported repoRoot value. Expected string or URL.");
 }
 function buildDirectoryChain(filePath, repoRoot) {
   const directories = [];
   const seen = /* @__PURE__ */ new Set();
-  const boundary = import_node_path3.default.resolve(repoRoot);
-  let current = import_node_path3.default.resolve(import_node_path3.default.dirname(filePath));
+  const boundary = import_node_path4.default.resolve(repoRoot);
+  let current = import_node_path4.default.resolve(import_node_path4.default.dirname(filePath));
   while (current !== void 0) {
     if (!seen.has(current)) {
       directories.push(current);
@@ -761,7 +798,7 @@ function buildDirectoryChain(filePath, repoRoot) {
     if (current === boundary) {
       break;
     }
-    const parent = import_node_path3.default.dirname(current);
+    const parent = import_node_path4.default.dirname(current);
     if (parent === current) {
       break;
     }
@@ -775,16 +812,16 @@ function buildDirectoryChain(filePath, repoRoot) {
 function buildSearchRoots(evalPath, repoRoot) {
   const uniqueRoots = [];
   const addRoot = (root) => {
-    const normalized = import_node_path3.default.resolve(root);
+    const normalized = import_node_path4.default.resolve(root);
     if (!uniqueRoots.includes(normalized)) {
       uniqueRoots.push(normalized);
     }
   };
-  let currentDir = import_node_path3.default.dirname(evalPath);
+  let currentDir = import_node_path4.default.dirname(evalPath);
   let reachedBoundary = false;
   while (!reachedBoundary) {
     addRoot(currentDir);
-    const parentDir = import_node_path3.default.dirname(currentDir);
+    const parentDir = import_node_path4.default.dirname(currentDir);
     if (currentDir === repoRoot || parentDir === currentDir) {
       reachedBoundary = true;
     } else {
@@ -802,16 +839,16 @@ function trimLeadingSeparators(value) {
 async function resolveFileReference2(rawValue, searchRoots) {
   const displayPath = trimLeadingSeparators(rawValue);
   const potentialPaths = [];
-  if (import_node_path3.default.isAbsolute(rawValue)) {
-    potentialPaths.push(import_node_path3.default.normalize(rawValue));
+  if (import_node_path4.default.isAbsolute(rawValue)) {
+    potentialPaths.push(import_node_path4.default.normalize(rawValue));
   }
   for (const base of searchRoots) {
-    potentialPaths.push(import_node_path3.default.resolve(base, displayPath));
+    potentialPaths.push(import_node_path4.default.resolve(base, displayPath));
   }
   const attempted = [];
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of potentialPaths) {
-    const absoluteCandidate = import_node_path3.default.resolve(candidate);
+    const absoluteCandidate = import_node_path4.default.resolve(candidate);
     if (seen.has(absoluteCandidate)) {
       continue;
     }
@@ -823,14 +860,14 @@ async function resolveFileReference2(rawValue, searchRoots) {
   }
   return { displayPath, attempted };
 }
-var import_node_fs, import_promises3, import_node_path3, import_node_url;
+var import_node_fs, import_promises3, import_node_path4, import_node_url;
 var init_file_resolver = __esm({
   "src/evaluation/loaders/file-resolver.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_fs = require("fs");
     import_promises3 = require("fs/promises");
-    import_node_path3 = __toESM(require("path"), 1);
+    import_node_path4 = __toESM(require("path"), 1);
     import_node_url = require("url");
   }
 });
@@ -839,52 +876,56 @@ var init_file_resolver = __esm({
 async function loadConfig(evalFilePath, repoRoot) {
   const directories = buildDirectoryChain(evalFilePath, repoRoot);
   for (const directory of directories) {
-    const configPath = import_node_path4.default.join(directory, ".agentv", "config.yaml");
+    const configPath = import_node_path5.default.join(directory, ".agentv", "config.yaml");
     if (!await fileExists(configPath)) {
       continue;
     }
-    try {
-      const rawConfig = await (0, import_promises4.readFile)(configPath, "utf8");
-      const parsed = interpolateEnv(parseYamlValue(rawConfig), process.env);
-      if (!isJsonObject(parsed)) {
-        logWarning(`Invalid .agentv/config.yaml format at ${configPath}`);
-        continue;
-      }
-      const config = parsed;
-      const requiredVersion = parsed.required_version;
-      if (requiredVersion !== void 0 && typeof requiredVersion !== "string") {
-        logWarning(`Invalid required_version in ${configPath}, expected string`);
-        continue;
-      }
-      const evalPatterns = config.eval_patterns;
-      if (evalPatterns !== void 0 && !Array.isArray(evalPatterns)) {
-        logWarning(`Invalid eval_patterns in ${configPath}, expected array`);
-        continue;
-      }
-      if (Array.isArray(evalPatterns) && !evalPatterns.every((p) => typeof p === "string")) {
-        logWarning(`Invalid eval_patterns in ${configPath}, all entries must be strings`);
-        continue;
-      }
-      const executionDefaults = parseExecutionDefaults(
-        parsed.execution,
-        configPath
-      );
-      const results = parseResultsConfig(parsed.results, configPath);
-      const hooks = parseHooksConfig(parsed.hooks, configPath);
-      return {
-        required_version: requiredVersion,
-        eval_patterns: evalPatterns,
-        execution: executionDefaults,
-        results,
-        ...hooks && { hooks }
-      };
-    } catch (error) {
-      logWarning(
-        `Could not read .agentv/config.yaml at ${configPath}: ${error.message}`
-      );
+    const config = await readConfigFile(configPath);
+    if (config) return config;
+  }
+  const globalConfigPath = import_node_path5.default.join(getAgentvConfigDir(), "config.yaml");
+  return await fileExists(globalConfigPath) ? readConfigFile(globalConfigPath) : null;
+}
+async function readConfigFile(configPath) {
+  try {
+    const rawConfig = await (0, import_promises4.readFile)(configPath, "utf8");
+    const parsed = interpolateEnv(parseYamlValue(rawConfig), process.env);
+    if (!isJsonObject(parsed)) {
+      logWarning(`Invalid config.yaml format at ${configPath}`);
+      return null;
+    }
+    const config = parsed;
+    const requiredVersion = parsed.required_version;
+    if (requiredVersion !== void 0 && typeof requiredVersion !== "string") {
+      logWarning(`Invalid required_version in ${configPath}, expected string`);
+      return null;
     }
+    const evalPatterns = config.eval_patterns;
+    if (evalPatterns !== void 0 && !Array.isArray(evalPatterns)) {
+      logWarning(`Invalid eval_patterns in ${configPath}, expected array`);
+      return null;
+    }
+    if (Array.isArray(evalPatterns) && !evalPatterns.every((p) => typeof p === "string")) {
+      logWarning(`Invalid eval_patterns in ${configPath}, all entries must be strings`);
+      return null;
+    }
+    const executionDefaults = parseExecutionDefaults(
+      parsed.execution,
+      configPath
+    );
+    const results = parseResultsConfig(parsed.results, configPath);
+    const hooks = parseHooksConfig(parsed.hooks, configPath);
+    return {
+      required_version: requiredVersion,
+      eval_patterns: evalPatterns,
+      execution: executionDefaults,
+      results,
+      ...hooks && { hooks }
+    };
+  } catch (error) {
+    logWarning(`Could not read config.yaml at ${configPath}: ${error.message}`);
+    return null;
   }
-  return null;
 }
 function extractTargetFromSuite(suite) {
   const execution = suite.execution;
@@ -1246,13 +1287,14 @@ function parseHooksConfig(raw, configPath) {
 function logWarning(message) {
   console.warn(`${ANSI_YELLOW2}Warning: ${message}${ANSI_RESET3}`);
 }
-var import_promises4, import_node_path4, ANSI_YELLOW2, ANSI_RESET3, DEFAULT_EVAL_PATTERNS, VALID_TRIAL_STRATEGIES;
+var import_promises4, import_node_path5, ANSI_YELLOW2, ANSI_RESET3, DEFAULT_EVAL_PATTERNS, VALID_TRIAL_STRATEGIES;
 var init_config_loader = __esm({
   "src/evaluation/loaders/config-loader.ts"() {
     "use strict";
     init_cjs_shims();
     import_promises4 = require("fs/promises");
-    import_node_path4 = __toESM(require("path"), 1);
+    import_node_path5 = __toESM(require("path"), 1);
+    init_paths();
     init_interpolation();
     init_types();
     init_yaml_loader();
@@ -1560,19 +1602,19 @@ function resolveLocalFilePath(value, basePath) {
   if (/^[a-z]+:\/\//i.test(value)) {
     return void 0;
   }
-  return basePath ? import_node_path5.default.resolve(basePath, value) : import_node_path5.default.resolve(value);
+  return basePath ? import_node_path6.default.resolve(basePath, value) : import_node_path6.default.resolve(value);
 }
 function formatFileText(filePath, text) {
   return `[[ file: ${filePath} ]]
 ${text}`;
 }
-var import_promises5, import_node_path5, import_node_url2, MIME_TYPE_ALIASES, REPLACEMENT_CHAR;
+var import_promises5, import_node_path6, import_node_url2, MIME_TYPE_ALIASES, REPLACEMENT_CHAR;
 var init_content_preprocessor = __esm({
   "src/evaluation/content-preprocessor.ts"() {
     "use strict";
     init_cjs_shims();
     import_promises5 = require("fs/promises");
-    import_node_path5 = __toESM(require("path"), 1);
+    import_node_path6 = __toESM(require("path"), 1);
     import_node_url2 = require("url");
     init_exec();
     MIME_TYPE_ALIASES = {
@@ -1730,8 +1772,8 @@ function isTemplateReference(value) {
 }
 async function resolveAssertionTemplateReference(include, searchRoots) {
   const templateCandidates = isTemplateReference(include) ? [
-    import_node_path6.default.join(".agentv", "templates", `${include}.yaml`),
-    import_node_path6.default.join(".agentv", "templates", `${include}.yml`)
+    import_node_path7.default.join(".agentv", "templates", `${include}.yaml`),
+    import_node_path7.default.join(".agentv", "templates", `${include}.yml`)
   ] : [include];
   const attempted = [];
   for (const candidate of templateCandidates) {
@@ -1784,10 +1826,10 @@ ${resolved.attempted.map((attempt) => `  Tried: ${attempt}`).join("\n")}` : "";
       `Invalid assertion template file in '${evalId}': ${resolved.resolvedPath} is missing a top-level assertions array`
     );
   }
-  const templateDir = import_node_path6.default.dirname(resolved.resolvedPath);
+  const templateDir = import_node_path7.default.dirname(resolved.resolvedPath);
   const nestedSearchRoots = [
     templateDir,
-    ...searchRoots.filter((root) => import_node_path6.default.resolve(root) !== templateDir)
+    ...searchRoots.filter((root) => import_node_path7.default.resolve(root) !== templateDir)
   ];
   return await expandGraderEntries(assertions, nestedSearchRoots, evalId, {
     depth: nextDepth,
@@ -1949,7 +1991,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
       if (cwd) {
         const resolved = await resolveFileReference2(cwd, searchRoots);
         if (resolved.resolvedPath) {
-          resolvedCwd = import_node_path6.default.resolve(resolved.resolvedPath);
+          resolvedCwd = import_node_path7.default.resolve(resolved.resolvedPath);
         } else {
           logWarning2(
             `Code-grader evaluator '${name}' in '${evalId}': cwd not found (${resolved.displayPath})`,
@@ -2134,7 +2176,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
             aggregatorPrompt = fileRef;
             const resolved = await resolveFileReference2(fileRef, searchRoots);
             if (resolved.resolvedPath) {
-              promptPath2 = import_node_path6.default.resolve(resolved.resolvedPath);
+              promptPath2 = import_node_path7.default.resolve(resolved.resolvedPath);
             } else {
               throw new Error(
                 `Composite aggregator in '${evalId}': prompt file not found: ${resolved.displayPath}`
@@ -2814,7 +2856,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
       const commandPath = commandArray[commandArray.length - 1];
       const resolved = await resolveFileReference2(commandPath, searchRoots);
       if (resolved.resolvedPath) {
-        resolvedPromptScript = [...commandArray.slice(0, -1), import_node_path6.default.resolve(resolved.resolvedPath)];
+        resolvedPromptScript = [...commandArray.slice(0, -1), import_node_path7.default.resolve(resolved.resolvedPath)];
       } else {
         throw new Error(
           `Grader '${name}' in '${evalId}': prompt command file not found: ${resolved.displayPath}`
@@ -2829,7 +2871,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
         prompt = fileRef;
         const resolved = await resolveFileReference2(fileRef, searchRoots);
         if (resolved.resolvedPath) {
-          promptPath = import_node_path6.default.resolve(resolved.resolvedPath);
+          promptPath = import_node_path7.default.resolve(resolved.resolvedPath);
           try {
             await validateCustomPromptContent(promptPath);
           } catch (error) {
@@ -2987,7 +3029,7 @@ async function parsePreprocessors(rawValue, searchRoots, evaluatorName, evalId)
     preprocessors.push({
       type,
       command,
-      resolvedCommand: [...command.slice(0, -1), import_node_path6.default.resolve(resolved.resolvedPath)]
+      resolvedCommand: [...command.slice(0, -1), import_node_path7.default.resolve(resolved.resolvedPath)]
     });
   }
   return preprocessors;
@@ -3379,13 +3421,13 @@ function parseInlineRubrics(rawRubrics) {
     rubrics: rubricItems
   };
 }
-var import_promises7, import_node_path6, ANSI_YELLOW4, ANSI_RESET5, MAX_ASSERTION_INCLUDE_DEPTH, PROMPT_FILE_PREFIX, VALID_FIELD_MATCH_TYPES, VALID_FIELD_AGGREGATION_TYPES;
+var import_promises7, import_node_path7, ANSI_YELLOW4, ANSI_RESET5, MAX_ASSERTION_INCLUDE_DEPTH, PROMPT_FILE_PREFIX, VALID_FIELD_MATCH_TYPES, VALID_FIELD_AGGREGATION_TYPES;
 var init_grader_parser = __esm({
   "src/evaluation/loaders/grader-parser.ts"() {
     "use strict";
     init_cjs_shims();
     import_promises7 = require("fs/promises");
-    import_node_path6 = __toESM(require("path"), 1);
+    import_node_path7 = __toESM(require("path"), 1);
     init_content_preprocessor();
     init_interpolation();
     init_types();
@@ -3463,7 +3505,7 @@ var init_segment_formatter = __esm({
 
 // src/evaluation/loaders/message-processor.ts
 function detectImageMediaType(filePath) {
-  const ext = import_node_path7.default.extname(filePath).toLowerCase();
+  const ext = import_node_path8.default.extname(filePath).toLowerCase();
   return IMAGE_MEDIA_TYPES[ext];
 }
 async function processMessages(options) {
@@ -3525,7 +3567,7 @@ async function processMessages(options) {
             ...cloneJsonObject(rawSegment),
             path: displayPath,
             text: fileContent,
-            resolvedPath: import_node_path7.default.resolve(resolvedPath)
+            resolvedPath: import_node_path8.default.resolve(resolvedPath)
           });
           if (verbose) {
             const label = messageType === "input" ? "[File]" : "[Expected Output File]";
@@ -3649,7 +3691,7 @@ async function processExpectedMessages(options) {
               type: "file",
               path: displayPath,
               text: fileContent,
-              resolvedPath: import_node_path7.default.resolve(resolvedPath)
+              resolvedPath: import_node_path8.default.resolve(resolvedPath)
             });
             if (verbose) {
               console.log(`  [Expected Output File] Found: ${displayPath}`);
@@ -3717,13 +3759,13 @@ async function processExpectedMessages(options) {
   }
   return segments;
 }
-var import_promises8, import_node_path7, IMAGE_MEDIA_TYPES, ANSI_YELLOW5, ANSI_RESET6;
+var import_promises8, import_node_path8, IMAGE_MEDIA_TYPES, ANSI_YELLOW5, ANSI_RESET6;
 var init_message_processor = __esm({
   "src/evaluation/loaders/message-processor.ts"() {
     "use strict";
     init_cjs_shims();
     import_promises8 = require("fs/promises");
-    import_node_path7 = __toESM(require("path"), 1);
+    import_node_path8 = __toESM(require("path"), 1);
     init_segment_formatter();
     init_input_message_utils();
     init_types();
@@ -3821,7 +3863,7 @@ function matchesFilter(id, filter) {
   return typeof filter === "string" ? import_micromatch.default.isMatch(id, filter) : filter.some((pattern) => import_micromatch.default.isMatch(id, pattern));
 }
 function detectFormat(filePath) {
-  const ext = import_node_path8.default.extname(filePath).toLowerCase();
+  const ext = import_node_path9.default.extname(filePath).toLowerCase();
   if (ext === ".jsonl") return "jsonl";
   if (ext === ".yaml" || ext === ".yml") return "yaml";
   if (ext === ".json") return "agent-skills-json";
@@ -3831,9 +3873,9 @@ function detectFormat(filePath) {
   );
 }
 async function loadSidecarMetadata(jsonlPath, verbose) {
-  const dir = import_node_path8.default.dirname(jsonlPath);
-  const base = import_node_path8.default.basename(jsonlPath, ".jsonl");
-  const sidecarPath = import_node_path8.default.join(dir, `${base}.yaml`);
+  const dir = import_node_path9.default.dirname(jsonlPath);
+  const base = import_node_path9.default.basename(jsonlPath, ".jsonl");
+  const sidecarPath = import_node_path9.default.join(dir, `${base}.yaml`);
   if (!await fileExists(sidecarPath)) {
     if (verbose) {
       logWarning4(`Sidecar metadata file not found: ${sidecarPath} (using defaults)`);
@@ -3882,13 +3924,13 @@ function parseJsonlContent(content, filePath) {
 async function loadTestsFromJsonl(evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
   const filterPattern = options?.filter;
-  const absoluteTestPath = import_node_path8.default.resolve(evalFilePath);
+  const absoluteTestPath = import_node_path9.default.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots(absoluteTestPath, repoRootPath);
   const sidecar = await loadSidecarMetadata(absoluteTestPath, verbose);
   const rawFile = await (0, import_promises9.readFile)(absoluteTestPath, "utf8");
   const rawCases = parseJsonlContent(rawFile, evalFilePath);
-  const fallbackSuiteName = import_node_path8.default.basename(absoluteTestPath, ".jsonl") || "eval";
+  const fallbackSuiteName = import_node_path9.default.basename(absoluteTestPath, ".jsonl") || "eval";
   const suiteName = sidecar.name && sidecar.name.trim().length > 0 ? sidecar.name : fallbackSuiteName;
   const globalEvaluator = coerceEvaluator(sidecar.evaluator, "sidecar") ?? "llm-grader";
   const globalExecution = sidecar.execution;
@@ -4021,13 +4063,13 @@ ${detailBlock}${ANSI_RESET7}`);
     console.error(`${ANSI_RED2}Error: ${message}${ANSI_RESET7}`);
   }
 }
-var import_promises9, import_node_path8, import_micromatch, ANSI_YELLOW6, ANSI_RED2, ANSI_RESET7;
+var import_promises9, import_node_path9, import_micromatch, ANSI_YELLOW6, ANSI_RED2, ANSI_RESET7;
 var init_jsonl_parser = __esm({
   "src/evaluation/loaders/jsonl-parser.ts"() {
     "use strict";
     init_cjs_shims();
     import_promises9 = require("fs/promises");
-    import_node_path8 = __toESM(require("path"), 1);
+    import_node_path9 = __toESM(require("path"), 1);
     import_micromatch = __toESM(require("micromatch"), 1);
     init_input_message_utils();
     init_interpolation();
@@ -4311,14 +4353,14 @@ async function readJsonFile(filePath) {
   return JSON.parse(content);
 }
 async function findGitRoot(startPath) {
-  let currentDir = import_node_path9.default.dirname(import_node_path9.default.resolve(startPath));
-  const root = import_node_path9.default.parse(currentDir).root;
+  let currentDir = import_node_path10.default.dirname(import_node_path10.default.resolve(startPath));
+  const root = import_node_path10.default.parse(currentDir).root;
   while (currentDir !== root) {
-    const gitPath = import_node_path9.default.join(currentDir, ".git");
+    const gitPath = import_node_path10.default.join(currentDir, ".git");
     if (await fileExists2(gitPath)) {
       return currentDir;
     }
-    const parentDir = import_node_path9.default.dirname(currentDir);
+    const parentDir = import_node_path10.default.dirname(currentDir);
     if (parentDir === currentDir) {
       break;
     }
@@ -4329,8 +4371,8 @@ async function findGitRoot(startPath) {
 function buildDirectoryChain2(filePath, repoRoot) {
   const directories = [];
   const seen = /* @__PURE__ */ new Set();
-  const boundary = import_node_path9.default.resolve(repoRoot);
-  let current = import_node_path9.default.resolve(import_node_path9.default.dirname(filePath));
+  const boundary = import_node_path10.default.resolve(repoRoot);
+  let current = import_node_path10.default.resolve(import_node_path10.default.dirname(filePath));
   while (current !== void 0) {
     if (!seen.has(current)) {
       directories.push(current);
@@ -4339,7 +4381,7 @@ function buildDirectoryChain2(filePath, repoRoot) {
     if (current === boundary) {
       break;
     }
-    const parent = import_node_path9.default.dirname(current);
+    const parent = import_node_path10.default.dirname(current);
     if (parent === current) {
       break;
     }
@@ -4353,16 +4395,16 @@ function buildDirectoryChain2(filePath, repoRoot) {
 function buildSearchRoots2(evalPath, repoRoot) {
   const uniqueRoots = [];
   const addRoot = (root) => {
-    const normalized = import_node_path9.default.resolve(root);
+    const normalized = import_node_path10.default.resolve(root);
     if (!uniqueRoots.includes(normalized)) {
       uniqueRoots.push(normalized);
     }
   };
-  let currentDir = import_node_path9.default.dirname(evalPath);
+  let currentDir = import_node_path10.default.dirname(evalPath);
   let reachedBoundary = false;
   while (!reachedBoundary) {
     addRoot(currentDir);
-    const parentDir = import_node_path9.default.dirname(currentDir);
+    const parentDir = import_node_path10.default.dirname(currentDir);
     if (currentDir === repoRoot || parentDir === currentDir) {
       reachedBoundary = true;
     } else {
@@ -4380,16 +4422,16 @@ function trimLeadingSeparators2(value) {
 async function resolveFileReference3(rawValue, searchRoots) {
   const displayPath = trimLeadingSeparators2(rawValue);
   const potentialPaths = [];
-  if (import_node_path9.default.isAbsolute(rawValue)) {
-    potentialPaths.push(import_node_path9.default.normalize(rawValue));
+  if (import_node_path10.default.isAbsolute(rawValue)) {
+    potentialPaths.push(import_node_path10.default.normalize(rawValue));
   }
   for (const base of searchRoots) {
-    potentialPaths.push(import_node_path9.default.resolve(base, displayPath));
+    potentialPaths.push(import_node_path10.default.resolve(base, displayPath));
   }
   const attempted = [];
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of potentialPaths) {
-    const absoluteCandidate = import_node_path9.default.resolve(candidate);
+    const absoluteCandidate = import_node_path10.default.resolve(candidate);
     if (seen.has(absoluteCandidate)) {
       continue;
     }
@@ -4401,14 +4443,14 @@ async function resolveFileReference3(rawValue, searchRoots) {
   }
   return { displayPath, attempted };
 }
-var import_node_fs2, import_promises10, import_node_path9;
+var import_node_fs2, import_promises10, import_node_path10;
 var init_file_utils = __esm({
   "src/evaluation/file-utils.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_fs2 = require("fs");
     import_promises10 = require("fs/promises");
-    import_node_path9 = __toESM(require("path"), 1);
+    import_node_path10 = __toESM(require("path"), 1);
   }
 });
 
@@ -4660,44 +4702,6 @@ var init_p_limit = __esm({
   }
 });
 
-// src/paths.ts
-function getAgentvConfigDir() {
-  return import_node_path10.default.join(import_node_os.default.homedir(), ".agentv");
-}
-function getAgentvHome() {
-  const envHome = process.env.AGENTV_HOME;
-  if (envHome && envHome !== "undefined") {
-    if (!logged) {
-      logged = true;
-      console.log(`Using AGENTV_HOME: ${envHome}`);
-    }
-    return envHome;
-  }
-  return import_node_path10.default.join(import_node_os.default.homedir(), ".agentv");
-}
-function getWorkspacesRoot() {
-  return import_node_path10.default.join(getAgentvHome(), "workspaces");
-}
-function getSubagentsRoot() {
-  return import_node_path10.default.join(getAgentvHome(), "subagents");
-}
-function getTraceStateRoot() {
-  return import_node_path10.default.join(getAgentvHome(), "trace-state");
-}
-function getWorkspacePoolRoot() {
-  return import_node_path10.default.join(getAgentvHome(), "workspace-pool");
-}
-var import_node_os, import_node_path10, logged;
-var init_paths = __esm({
-  "src/paths.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_node_os = __toESM(require("os"), 1);
-    import_node_path10 = __toESM(require("path"), 1);
-    logged = false;
-  }
-});
-
 // src/runtime/target-proxy.ts
 async function createTargetProxy(options) {
   const { defaultProvider, targetResolver, availableTargets, maxCalls } = options;
@@ -14234,7 +14238,7 @@ async function promptInstall() {
   }
 }
 function findManagedSdkInstallRoot() {
-  return import_node_path25.default.join(getAgentvHome(), "deps", "pi-sdk");
+  return import_node_path25.default.join(getAgentvDataDir(), "deps", "pi-sdk");
 }
 function resolveGlobalNpmRoot() {
   try {
@@ -24828,6 +24832,7 @@ __export(index_exports, {
   freeformEvaluationSchema: () => freeformEvaluationSchema,
   generateRubrics: () => generateRubrics,
   getAgentvConfigDir: () => getAgentvConfigDir,
+  getAgentvDataDir: () => getAgentvDataDir,
   getAgentvHome: () => getAgentvHome,
   getOutputFilenames: () => getOutputFilenames,
   getProject: () => getProject,
@@ -25546,6 +25551,8 @@ var import_node_path54 = __toESM(require("path"), 1);
 var import_node_util8 = require("util");
 init_paths();
 var execFileAsync4 = (0, import_node_util8.promisify)(import_node_child_process12.execFile);
+var RESULTS_REPO_RESULTS_DIR = ".agentv/results";
+var RESULTS_REPO_RUNS_DIR = `${RESULTS_REPO_RESULTS_DIR}/runs`;
 function sanitizeRepoSlug(repo) {
   return repo.trim().replace(/[^A-Za-z0-9._-]+/g, "-");
 }
@@ -25565,7 +25572,7 @@ function expandHome(p) {
 }
 function normalizeResultsConfig(config) {
   const repo = config.repo.trim();
-  const resolvedPath = config.path ? expandHome(config.path.trim()) : import_node_path54.default.join(getAgentvHome(), "results", sanitizeRepoSlug(repo));
+  const resolvedPath = config.path ? expandHome(config.path.trim()) : import_node_path54.default.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
   return {
     mode: "github",
     repo,
@@ -25581,7 +25588,7 @@ function resolveResultsRepoUrl(repo) {
   return `https://github.com/${repo}.git`;
 }
 function getResultsRepoLocalPaths(repo) {
-  const rootDir = import_node_path54.default.join(getAgentvHome(), "cache", "results-repo", sanitizeRepoSlug(repo));
+  const rootDir = import_node_path54.default.join(getAgentvDataDir(), "cache", "results-repo", sanitizeRepoSlug(repo));
   return {
     rootDir,
     repoDir: import_node_path54.default.join(rootDir, "repo"),
@@ -25778,7 +25785,7 @@ async function stageResultsArtifacts(params) {
 }
 function resolveResultsRepoRunsDir(config) {
   const normalized = normalizeResultsConfig(config);
-  return import_node_path54.default.join(normalized.path, "runs");
+  return import_node_path54.default.join(normalized.path, RESULTS_REPO_RESULTS_DIR, "runs");
 }
 async function directorySizeBytes(targetPath) {
   const entry = await (0, import_promises39.stat)(targetPath);
@@ -25841,7 +25848,12 @@ async function directPushResults(params) {
   const repoDir = await ensureResultsRepoClone(normalized);
   const baseBranch = await resolveDefaultBranch(repoDir);
   await fetchResultsRepo(repoDir);
-  const destinationDir = import_node_path54.default.join(repoDir, "runs", params.destinationPath);
+  const destinationDir = import_node_path54.default.join(
+    repoDir,
+    RESULTS_REPO_RESULTS_DIR,
+    "runs",
+    params.destinationPath
+  );
   await stageResultsArtifacts({
     repoDir,
     sourceDir: params.sourceDir,
@@ -25989,9 +26001,12 @@ function parseGitBatchBlobs(output) {
   return blobs;
 }
 async function listGitRuns(repoDir, ref = "origin/main") {
-  const { stdout: treeOut } = await runGit(["ls-tree", "-r", "--name-only", ref, "runs"], {
-    cwd: repoDir
-  });
+  const { stdout: treeOut } = await runGit(
+    ["ls-tree", "-r", "--name-only", ref, RESULTS_REPO_RUNS_DIR],
+    {
+      cwd: repoDir
+    }
+  );
   const benchmarkPaths = treeOut.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.endsWith("/benchmark.json"));
   if (benchmarkPaths.length === 0) {
     return [];
@@ -26008,7 +26023,7 @@ async function listGitRuns(repoDir, ref = "origin/main") {
     const benchmarkPath = benchmarkPaths[index];
     const benchmark = JSON.parse(blob.content.toString("utf8"));
     const runDir = import_node_path54.default.posix.dirname(benchmarkPath);
-    const relativeRunPath = import_node_path54.default.posix.relative("runs", runDir);
+    const relativeRunPath = import_node_path54.default.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
     const runId = buildGitRunId(relativeRunPath);
     const timestamp = benchmark.metadata?.timestamp?.trim() || import_node_path54.default.posix.basename(runDir);
     const targets = benchmark.metadata?.targets ?? [];
@@ -26034,7 +26049,7 @@ async function listGitRuns(repoDir, ref = "origin/main") {
 }
 async function materializeGitRun(repoDir, relativeRunPath, ref = "origin/main") {
   const normalizedRunPath = relativeRunPath.split(import_node_path54.default.sep).join("/");
-  const runTreePath = import_node_path54.default.posix.join("runs", normalizedRunPath);
+  const runTreePath = import_node_path54.default.posix.join(RESULTS_REPO_RUNS_DIR, normalizedRunPath);
   const targetRunDir = import_node_path54.default.join(repoDir, ...runTreePath.split("/"));
   const { stdout: treeOut } = await runGit(["ls-tree", "-r", "--name-only", ref, runTreePath], {
     cwd: repoDir
@@ -27709,6 +27724,7 @@ function createAgentKernel() {
   freeformEvaluationSchema,
   generateRubrics,
   getAgentvConfigDir,
+  getAgentvDataDir,
   getAgentvHome,
   getOutputFilenames,
   getProject,