agentv 3.14.0 → 3.14.3

package/dist/{chunk-W6CGDNQR.js → chunk-FSNRKR7X.js}

@@ -22,7 +22,7 @@ import {
   validateFileReferences,
   validateTargetsFile,
   writeArtifactsFromResults
-} from "./chunk-YYECEMUV.js";
+} from "./chunk-VYDUBNCD.js";
 import {
   createBuiltinRegistry,
   executeScript,
@@ -39,7 +39,7 @@ import {
   toSnakeCaseDeep as toSnakeCaseDeep2,
   transpileEvalYamlFile,
   trimBaselineResult
-} from "./chunk-3TBDSUYD.js";
+} from "./chunk-ELQEFMGO.js";
 import {
   __commonJS,
   __esm,
@@ -4185,7 +4185,7 @@ var evalRunCommand = command({
   },
   handler: async (args) => {
     if (args.evalPaths.length === 0 && process.stdin.isTTY) {
-      const { launchInteractiveWizard } = await import("./interactive-AI75XY3X.js");
+      const { launchInteractiveWizard } = await import("./interactive-LBVPF2CG.js");
       await launchInteractiveWizard();
       return;
     }
@@ -4408,13 +4408,23 @@ var evalBenchCommand = command({
       type: string,
       displayName: "export-dir",
       description: "Export directory from pipeline input/grade"
+    }),
+    llmScores: option({
+      type: optional(string),
+      long: "llm-scores",
+      description: "Path to LLM scores JSON file (reads from stdin if omitted)"
     })
   },
-  handler: async ({ exportDir }) => {
+  handler: async ({ exportDir, llmScores: llmScoresPath }) => {
     const manifest = JSON.parse(await readFile(join(exportDir, "manifest.json"), "utf8"));
     const testIds = manifest.test_ids;
     const targetName = manifest.target?.name ?? "unknown";
-    const stdinData = await readStdin();
+    let stdinData;
+    if (llmScoresPath) {
+      stdinData = await readFile(llmScoresPath, "utf8");
+    } else {
+      stdinData = await readStdin();
+    }
     const llmScores = stdinData ? JSON.parse(stdinData) : {};
     const indexLines = [];
     const allPassRates = [];
@@ -4814,6 +4824,354 @@ async function writeJson(filePath, data) {
 `, "utf8");
 }
 
+// src/commands/pipeline/run.ts
+import { execSync } from "node:child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync4, unlinkSync } from "node:fs";
+import { mkdir as mkdir4, readFile as readFile4, readdir as readdir3, writeFile as writeFile5 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname as dirname2, join as join4, resolve as resolve2 } from "node:path";
+function loadEnvFile(dir) {
+  let current = resolve2(dir);
+  while (true) {
+    const candidate = join4(current, ".env");
+    if (existsSync2(candidate)) {
+      const env3 = {};
+      for (const line of readFileSync4(candidate, "utf8").split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1) continue;
+        env3[trimmed.slice(0, eqIdx).trim()] = trimmed.slice(eqIdx + 1).trim();
+      }
+      return env3;
+    }
+    const parent = dirname2(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return {};
+}
+var evalRunCommand2 = command({
+  name: "run",
+  description: "Extract inputs, invoke CLI targets, and run code graders in one step",
+  args: {
+    evalPath: positional({
+      type: string,
+      displayName: "eval-path",
+      description: "Path to eval YAML file"
+    }),
+    out: option({
+      type: string,
+      long: "out",
+      description: "Output directory for results"
+    }),
+    workers: option({
+      type: optional(number),
+      long: "workers",
+      description: "Parallel workers for target invocation (default: all tests)"
+    })
+  },
+  handler: async ({ evalPath, out, workers }) => {
+    const resolvedEvalPath = resolve2(evalPath);
+    const outDir = resolve2(out);
+    const repoRoot = await findRepoRoot(dirname2(resolvedEvalPath));
+    const evalDir = dirname2(resolvedEvalPath);
+    const suite = await loadTestSuite(resolvedEvalPath, repoRoot);
+    const tests = suite.tests;
+    if (tests.length === 0) {
+      console.error("No tests found in eval file.");
+      process.exit(1);
+    }
+    let targetInfo = null;
+    let targetName = "agent";
+    let targetKind = "agent";
+    try {
+      const selection = await selectTarget({
+        testFilePath: resolvedEvalPath,
+        repoRoot,
+        cwd: evalDir,
+        dryRun: false,
+        dryRunDelay: 0,
+        dryRunDelayMin: 0,
+        dryRunDelayMax: 0,
+        env: process.env
+      });
+      targetName = selection.targetName;
+      if (selection.resolvedTarget.kind === "cli") {
+        targetKind = "cli";
+        const config = selection.resolvedTarget.config;
+        targetInfo = {
+          kind: "cli",
+          command: config.command,
+          cwd: config.cwd ?? evalDir,
+          timeoutMs: config.timeoutMs ?? 3e4
+        };
+      }
+    } catch {
+    }
+    const testIds = [];
+    for (const test of tests) {
+      const testDir = join4(outDir, test.id);
+      await mkdir4(testDir, { recursive: true });
+      testIds.push(test.id);
+      const inputText = test.question;
+      const inputMessages = test.input.map((m) => ({
+        role: m.role,
+        content: typeof m.content === "string" ? m.content : m.content
+      }));
+      await writeJson2(join4(testDir, "input.json"), {
+        input_text: inputText,
+        input_messages: inputMessages,
+        file_paths: test.file_paths,
+        metadata: test.metadata ?? {}
+      });
+      if (targetInfo) {
+        await writeJson2(join4(testDir, "invoke.json"), {
+          kind: "cli",
+          command: targetInfo.command,
+          cwd: targetInfo.cwd,
+          timeout_ms: targetInfo.timeoutMs,
+          env: {}
+        });
+      } else {
+        await writeJson2(join4(testDir, "invoke.json"), {
+          kind: "agent",
+          instructions: "Execute this task in the current workspace. The agent IS the target."
+        });
+      }
+      await writeFile5(join4(testDir, "criteria.md"), test.criteria ?? "", "utf8");
+      if (test.expected_output.length > 0 || test.reference_answer !== void 0 && test.reference_answer !== "") {
+        await writeJson2(join4(testDir, "expected_output.json"), {
+          expected_output: test.expected_output,
+          reference_answer: test.reference_answer ?? ""
+        });
+      }
+      await writeGraderConfigs2(testDir, test.assertions ?? [], evalDir);
+    }
+    await writeJson2(join4(outDir, "manifest.json"), {
+      eval_file: resolvedEvalPath,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      target: { name: targetName, kind: targetKind },
+      test_ids: testIds
+    });
+    console.log(`Extracted ${testIds.length} test(s) to ${outDir}`);
+    if (targetInfo) {
+      const envVars = loadEnvFile(evalDir);
+      if (!process.env.AGENTV_RUN_TIMESTAMP) {
+        process.env.AGENTV_RUN_TIMESTAMP = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").replace(/\./g, "-");
+      }
+      const mergedEnv = { ...process.env, ...envVars };
+      const maxWorkers = workers ?? testIds.length;
+      console.log(`Invoking ${testIds.length} CLI target(s) (${maxWorkers} workers)...`);
+      const invokeTarget = async (testId) => {
+        const testDir = join4(outDir, testId);
+        const invoke = JSON.parse(await readFile4(join4(testDir, "invoke.json"), "utf8"));
+        if (invoke.kind !== "cli") return;
+        const inputData = JSON.parse(await readFile4(join4(testDir, "input.json"), "utf8"));
+        const template = invoke.command;
+        const cwd = invoke.cwd;
+        const timeoutMs = invoke.timeout_ms ?? 12e4;
+        const promptFile = join4(tmpdir(), `agentv-prompt-${testId}-${Date.now()}.txt`);
+        const outputFile = join4(tmpdir(), `agentv-output-${testId}-${Date.now()}.txt`);
+        await writeFile5(promptFile, inputData.input_text, "utf8");
+        let rendered = template;
+        rendered = rendered.replace("{PROMPT_FILE}", promptFile);
+        rendered = rendered.replace("{OUTPUT_FILE}", outputFile);
+        rendered = rendered.replace("{PROMPT}", inputData.input_text);
+        const start = performance.now();
+        try {
+          execSync(rendered, {
+            cwd,
+            timeout: timeoutMs,
+            env: mergedEnv,
+            stdio: ["pipe", "pipe", "pipe"],
+            maxBuffer: 10 * 1024 * 1024
+          });
+          const durationMs = Math.round(performance.now() - start);
+          let response;
+          if (existsSync2(outputFile)) {
+            response = readFileSync4(outputFile, "utf8");
+          } else {
+            response = "ERROR: No output file generated";
+          }
+          await writeFile5(join4(testDir, "response.md"), response, "utf8");
+          await writeJson2(join4(testDir, "timing.json"), {
+            duration_ms: durationMs,
+            total_duration_seconds: Math.round(durationMs / 10) / 100
+          });
+          console.log(`  ${testId}: OK (${durationMs}ms, ${response.length} chars)`);
+        } catch (error) {
+          const durationMs = Math.round(performance.now() - start);
+          const message = error instanceof Error ? error.message : String(error);
+          const response = `ERROR: target failed \u2014 ${message}`;
+          await writeFile5(join4(testDir, "response.md"), response, "utf8");
+          await writeJson2(join4(testDir, "timing.json"), {
+            duration_ms: durationMs,
+            total_duration_seconds: Math.round(durationMs / 10) / 100
+          });
+          console.error(`  ${testId}: FAILED (${durationMs}ms) \u2014 ${message.slice(0, 200)}`);
+        } finally {
+          try {
+            if (existsSync2(promptFile)) unlinkSync(promptFile);
+            if (existsSync2(outputFile)) unlinkSync(outputFile);
+          } catch {
+          }
+        }
+      };
+      const allTasks = testIds.map((testId) => invokeTarget(testId));
+      await Promise.all(allTasks);
+    } else {
+      console.log("Agent-as-target mode \u2014 skipping CLI invocation.");
+    }
+    let totalGraders = 0;
+    let totalPassed = 0;
+    for (const testId of testIds) {
+      const testDir = join4(outDir, testId);
+      const codeGradersDir = join4(testDir, "code_graders");
+      const resultsDir = join4(testDir, "code_grader_results");
+      let graderFiles;
+      try {
+        graderFiles = (await readdir3(codeGradersDir)).filter((f) => f.endsWith(".json"));
+      } catch {
+        continue;
+      }
+      if (graderFiles.length === 0) continue;
+      await mkdir4(resultsDir, { recursive: true });
+      const responseText = await readFile4(join4(testDir, "response.md"), "utf8");
+      const inputData = JSON.parse(await readFile4(join4(testDir, "input.json"), "utf8"));
+      for (const graderFile of graderFiles) {
+        const graderConfig = JSON.parse(await readFile4(join4(codeGradersDir, graderFile), "utf8"));
+        const graderName = graderConfig.name;
+        const payload = JSON.stringify({
+          output: [{ role: "assistant", content: responseText }],
+          input: inputData.input_messages,
+          question: inputData.input_text,
+          criteria: "",
+          expected_output: [],
+          reference_answer: "",
+          input_files: [],
+          trace: null,
+          token_usage: null,
+          cost_usd: null,
+          duration_ms: null,
+          start_time: null,
+          end_time: null,
+          file_changes: null,
+          workspace_path: null,
+          config: graderConfig.config ?? null,
+          metadata: {},
+          input_text: inputData.input_text,
+          output_text: responseText,
+          expected_output_text: ""
+        });
+        try {
+          const stdout = await executeScript(
+            graderConfig.command,
+            payload,
+            void 0,
+            graderConfig.cwd
+          );
+          const parsed = JSON.parse(stdout);
+          const score = typeof parsed.score === "number" ? parsed.score : 0;
+          const assertions = Array.isArray(parsed.assertions) ? parsed.assertions : [];
+          await writeFile5(
+            join4(resultsDir, `${graderName}.json`),
+            `${JSON.stringify(
+              {
+                name: graderName,
+                type: "code-grader",
+                score,
+                weight: graderConfig.weight ?? 1,
+                assertions,
+                details: parsed.details ?? {}
+              },
+              null,
+              2
+            )}
+`,
+            "utf8"
+          );
+          totalGraders++;
+          if (score >= 0.5) totalPassed++;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          console.error(`  ${testId}/${graderName}: ERROR \u2014 ${message}`);
+          await writeFile5(
+            join4(resultsDir, `${graderName}.json`),
+            `${JSON.stringify(
+              {
+                name: graderName,
+                type: "code-grader",
+                score: 0,
+                weight: graderConfig.weight ?? 1,
+                assertions: [{ text: `Error: ${message}`, passed: false }],
+                details: { error: message }
+              },
+              null,
+              2
+            )}
+`,
+            "utf8"
+          );
+          totalGraders++;
+        }
+      }
+    }
+    console.log(`Graded ${totalGraders} code-grader(s): ${totalPassed} passed`);
+    console.log(`
+Done. Agent can now perform LLM grading on responses in ${outDir}`);
+  }
+});
+async function writeJson2(filePath, data) {
+  await writeFile5(filePath, `${JSON.stringify(data, null, 2)}
+`, "utf8");
+}
+async function writeGraderConfigs2(testDir, assertions, evalDir) {
+  const codeGradersDir = join4(testDir, "code_graders");
+  const llmGradersDir = join4(testDir, "llm_graders");
+  let hasCodeGraders = false;
+  let hasLlmGraders = false;
+  for (const assertion of assertions) {
+    if (assertion.type === "code-grader") {
+      if (!hasCodeGraders) {
+        await mkdir4(codeGradersDir, { recursive: true });
+        hasCodeGraders = true;
+      }
+      const config = assertion;
+      await writeJson2(join4(codeGradersDir, `${config.name}.json`), {
+        name: config.name,
+        command: config.command,
+        cwd: config.resolvedCwd ?? config.cwd ?? evalDir,
+        weight: config.weight ?? 1,
+        config: config.config ?? {}
+      });
+    } else if (assertion.type === "llm-grader") {
+      if (!hasLlmGraders) {
+        await mkdir4(llmGradersDir, { recursive: true });
+        hasLlmGraders = true;
+      }
+      const config = assertion;
+      let promptContent = "";
+      if (config.resolvedPromptPath) {
+        try {
+          promptContent = readFileSync4(config.resolvedPromptPath, "utf8");
+        } catch {
+          promptContent = typeof config.prompt === "string" ? config.prompt : "";
+        }
+      } else if (typeof config.prompt === "string") {
+        promptContent = config.prompt;
+      }
+      await writeJson2(join4(llmGradersDir, `${config.name}.json`), {
+        name: config.name,
+        prompt_content: promptContent,
+        weight: config.weight ?? 1,
+        threshold: 0.5,
+        config: {}
+      });
+    }
+  }
+}
+
 // src/commands/pipeline/index.ts
 var pipelineCommand = subcommands({
   name: "pipeline",
@@ -4821,7 +5179,8 @@ var pipelineCommand = subcommands({
   cmds: {
     input: evalInputCommand,
     grade: evalGradeCommand,
-    bench: evalBenchCommand
+    bench: evalBenchCommand,
+    run: evalRunCommand2
   }
 });
 
@@ -4829,10 +5188,10 @@ var pipelineCommand = subcommands({
 import path7 from "node:path";
 
 // src/commands/results/shared.ts
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 
 // src/commands/trace/utils.ts
-import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
+import { readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
 import path6 from "node:path";
 var colors2 = {
   reset: "\x1B[0m",
@@ -4872,7 +5231,7 @@ function resolveTraceResultPath(filePath) {
   return resolveWorkspaceOrFilePath(filePath);
 }
 function loadJsonlRecords(filePath) {
-  const content = readFileSync4(filePath, "utf8");
+  const content = readFileSync5(filePath, "utf8");
   const lines = content.trim().split("\n").filter((line) => line.trim());
   return lines.map((line, i) => {
     const record = JSON.parse(line);
@@ -4925,7 +5284,7 @@ function toRawResult(result) {
   };
 }
 function loadOtlpTraceFile(filePath) {
-  const parsed = JSON.parse(readFileSync4(filePath, "utf8"));
+  const parsed = JSON.parse(readFileSync5(filePath, "utf8"));
   const spans = parsed.resourceSpans?.flatMap((resource) => resource.scopeSpans ?? []).flatMap((scope) => scope.spans ?? []);
   if (!spans || spans.length === 0) {
     return [];
@@ -5243,14 +5602,14 @@ async function resolveSourceFile(source, cwd) {
   let sourceFile;
   if (source) {
     sourceFile = resolveResultSourcePath(source, cwd);
-    if (!existsSync2(sourceFile)) {
+    if (!existsSync3(sourceFile)) {
       console.error(`Error: File not found: ${sourceFile}`);
       process.exit(1);
     }
   } else {
     const cache = await loadRunCache(cwd);
     const cachedFile = cache ? resolveRunCacheFile(cache) : "";
-    if (cachedFile && existsSync2(cachedFile)) {
+    if (cachedFile && existsSync3(cachedFile)) {
       sourceFile = cachedFile;
     } else {
       const metas = listResultFiles(cwd, 1);
@@ -5462,7 +5821,7 @@ var resultsShowCommand = command({
 });
 
 // src/commands/results/summary.ts
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
 function formatSummary(results, grading) {
   const total = results.length;
   let passed;
@@ -5513,9 +5872,9 @@ var resultsSummaryCommand = command({
       const { results, sourceFile } = await loadResults(source, cwd);
       let grading;
       const gradingPath = sourceFile.replace(/\.jsonl$/, ".grading.json");
-      if (existsSync3(gradingPath)) {
+      if (existsSync4(gradingPath)) {
         try {
-          grading = JSON.parse(readFileSync5(gradingPath, "utf8"));
+          grading = JSON.parse(readFileSync6(gradingPath, "utf8"));
         } catch {
         }
       }
@@ -5540,7 +5899,7 @@ var resultsCommand = subcommands({
 });
 
 // src/commands/results/serve.ts
-import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "node:fs";
 import path8 from "node:path";
 import { Hono } from "hono";
 function feedbackPath(resultDir) {
@@ -5548,11 +5907,11 @@ function feedbackPath(resultDir) {
 }
 function readFeedback(cwd) {
   const fp = feedbackPath(cwd);
-  if (!existsSync4(fp)) {
+  if (!existsSync5(fp)) {
     return { reviews: [] };
   }
   try {
-    return JSON.parse(readFileSync6(fp, "utf8"));
+    return JSON.parse(readFileSync7(fp, "utf8"));
   } catch (err2) {
     console.error(`Warning: could not parse ${fp}, starting fresh: ${err2.message}`);
     return { reviews: [] };
@@ -6352,7 +6711,7 @@ var resultsServeCommand = command({
       let sourceFile;
       if (source) {
         const resolved = resolveResultSourcePath(source, cwd);
-        if (!existsSync4(resolved)) {
+        if (!existsSync5(resolved)) {
           console.error(`Error: Source file not found: ${resolved}`);
           process.exit(1);
         }
@@ -6361,7 +6720,7 @@ var resultsServeCommand = command({
       } else {
         const cache = await loadRunCache(cwd);
         const cachedFile = cache ? resolveRunCacheFile(cache) : "";
-        if (cachedFile && existsSync4(cachedFile)) {
+        if (cachedFile && existsSync5(cachedFile)) {
           sourceFile = cachedFile;
           results = patchTestIds(loadManifestResults(cachedFile));
         } else {
@@ -6411,7 +6770,7 @@ function detectPackageManager() {
   return detectPackageManagerFromPath(process.argv[1] ?? "");
 }
 function runCommand(cmd, args) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const child = spawn(cmd, args, { stdio: ["inherit", "pipe", "inherit"], shell: true });
     let stdout = "";
     child.stdout?.on("data", (data) => {
@@ -6419,7 +6778,7 @@ function runCommand(cmd, args) {
       stdout += data.toString();
     });
     child.on("error", reject);
-    child.on("close", (code) => resolve2({ exitCode: code ?? 1, stdout }));
+    child.on("close", (code) => resolve3({ exitCode: code ?? 1, stdout }));
   });
 }
 var updateCommand = command({
@@ -7327,7 +7686,7 @@ var transpileCommand = command({
 });
 
 // src/commands/trim/index.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
 var trimCommand = command({
   name: "trim",
   description: "Trim evaluation results for baseline storage (strips debug/audit fields)",
@@ -7346,7 +7705,7 @@ var trimCommand = command({
   },
   handler: async ({ input, out }) => {
     try {
-      const content = readFileSync7(input, "utf8");
+      const content = readFileSync8(input, "utf8");
       const lines = content.trim().split("\n").filter((line) => line.trim());
       const trimmedLines = lines.map((line) => {
         const record = JSON.parse(line);
@@ -7452,7 +7811,7 @@ function isTTY() {
 
 // src/commands/validate/validate-files.ts
 import { constants } from "node:fs";
-import { access, readdir as readdir3, stat } from "node:fs/promises";
+import { access, readdir as readdir4, stat } from "node:fs/promises";
 import path10 from "node:path";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
@@ -7518,7 +7877,7 @@ async function expandPaths(paths) {
 async function findYamlFiles(dirPath) {
   const results = [];
   try {
-    const entries2 = await readdir3(dirPath, { withFileTypes: true });
+    const entries2 = await readdir4(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
       const fullPath = path10.join(dirPath, entry.name);
       if (entry.isDirectory()) {
@@ -7575,14 +7934,14 @@ var validateCommand = command({
 });
 
 // src/commands/workspace/clean.ts
-import { existsSync as existsSync5 } from "node:fs";
-import { readFile as readFile4, readdir as readdir4, rm } from "node:fs/promises";
+import { existsSync as existsSync6 } from "node:fs";
+import { readFile as readFile5, readdir as readdir5, rm } from "node:fs/promises";
 import path11 from "node:path";
 async function confirm(message) {
   const readline2 = await import("node:readline");
   const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
-  const answer = await new Promise((resolve2) => {
-    rl.question(`${message} [y/N] `, resolve2);
+  const answer = await new Promise((resolve3) => {
+    rl.question(`${message} [y/N] `, resolve3);
   });
   rl.close();
   return answer.toLowerCase() === "y";
@@ -7604,19 +7963,19 @@ var cleanCommand = command({
   },
   handler: async ({ repo, force }) => {
     const poolRoot = getWorkspacePoolRoot();
-    if (!existsSync5(poolRoot)) {
+    if (!existsSync6(poolRoot)) {
       console.log("No workspace pool entries found.");
       return;
     }
     if (repo) {
-      const entries2 = await readdir4(poolRoot, { withFileTypes: true });
+      const entries2 = await readdir5(poolRoot, { withFileTypes: true });
       const poolDirs = entries2.filter((e) => e.isDirectory());
       const matchingDirs = [];
       for (const dir of poolDirs) {
         const poolDir = path11.join(poolRoot, dir.name);
         const metadataPath = path11.join(poolDir, "metadata.json");
         try {
-          const raw = await readFile4(metadataPath, "utf-8");
+          const raw = await readFile5(metadataPath, "utf-8");
           const metadata = JSON.parse(raw);
           const hasRepo = metadata.repos?.some((r) => {
             if (r.source.type === "git" && r.source.url) {
@@ -7663,13 +8022,13 @@ var cleanCommand = command({
 });
 
 // src/commands/workspace/list.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { readFile as readFile5, readdir as readdir5, stat as stat2 } from "node:fs/promises";
+import { existsSync as existsSync7 } from "node:fs";
+import { readFile as readFile6, readdir as readdir6, stat as stat2 } from "node:fs/promises";
 import path12 from "node:path";
 async function getDirectorySize(dirPath) {
   let totalSize = 0;
   try {
-    const entries2 = await readdir5(dirPath, { withFileTypes: true });
+    const entries2 = await readdir6(dirPath, { withFileTypes: true });
     for (const entry of entries2) {
       const fullPath = path12.join(dirPath, entry.name);
       if (entry.isDirectory()) {
@@ -7695,11 +8054,11 @@ var listCommand = command({
   args: {},
   handler: async () => {
     const poolRoot = getWorkspacePoolRoot();
-    if (!existsSync6(poolRoot)) {
+    if (!existsSync7(poolRoot)) {
       console.log("No workspace pool entries found.");
       return;
     }
-    const entries2 = await readdir5(poolRoot, { withFileTypes: true });
+    const entries2 = await readdir6(poolRoot, { withFileTypes: true });
     const poolDirs = entries2.filter((e) => e.isDirectory());
     if (poolDirs.length === 0) {
       console.log("No workspace pool entries found.");
@@ -7708,12 +8067,12 @@ var listCommand = command({
     for (const dir of poolDirs) {
       const poolDir = path12.join(poolRoot, dir.name);
       const fingerprint = dir.name;
-      const poolEntries = await readdir5(poolDir, { withFileTypes: true });
+      const poolEntries = await readdir6(poolDir, { withFileTypes: true });
       const slots = poolEntries.filter((e) => e.isDirectory() && e.name.startsWith("slot-"));
       const metadataPath = path12.join(poolDir, "metadata.json");
       let metadata = null;
       try {
-        const raw = await readFile5(metadataPath, "utf-8");
+        const raw = await readFile6(metadataPath, "utf-8");
         metadata = JSON.parse(raw);
       } catch {
       }
@@ -7750,16 +8109,16 @@ var workspaceCommand = subcommands({
 
 // src/update-check.ts
 import { spawn as spawn2 } from "node:child_process";
-import { readFile as readFile6 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import { join as join5 } from "node:path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var AGENTV_DIR = getAgentvHome();
 var CACHE_FILE = "version-check.json";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/agentv/latest";
 async function getCachedUpdateInfo(path13) {
-  const filePath = path13 ?? join4(AGENTV_DIR, CACHE_FILE);
+  const filePath = path13 ?? join5(AGENTV_DIR, CACHE_FILE);
   try {
-    const raw = await readFile6(filePath, "utf-8");
+    const raw = await readFile7(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.latestVersion === "string" && typeof data.lastCheckedAt === "string") {
       return data;
@@ -7791,7 +8150,7 @@ function buildNotice(currentVersion, latestVersion) {
 }
 function backgroundUpdateCheck() {
   const dir = AGENTV_DIR;
-  const filePath = join4(dir, CACHE_FILE);
+  const filePath = join5(dir, CACHE_FILE);
   const script = `
     const https = require('https');
     const fs = require('fs');
@@ -7914,4 +8273,4 @@ export {
   preprocessArgv,
   runCli
 };
-//# sourceMappingURL=chunk-W6CGDNQR.js.map
+//# sourceMappingURL=chunk-FSNRKR7X.js.map