@apo-ai/sdk 0.2.3 → 0.4.0

package/dist/agent-task/public.js

@@ -235,7 +235,8 @@ function levenshtein(a, b) {
 }
 
 // src/agent-task/checks/judge.ts
-var JUDGE_SYSTEM_PROMPT = 'You are an evaluation judge. Evaluate the given value(s) against the instruction. Respond with ONLY a JSON object: {"pass": true/false, "reasoning": "your reasoning"}';
+var JUDGE_RESPONSE_CONTRACT = 'Respond with ONLY a JSON object: {"pass": true/false, "reasoning": "your reasoning"}';
+var JUDGE_SYSTEM_PROMPT = `You are an evaluation judge. Evaluate the given value(s) against the instruction. ${JUDGE_RESPONSE_CONTRACT}`;
 function formatValue(value, depth = 0) {
   const indent = "  ".repeat(depth);
   if (value === null || value === void 0) return String(value);
@@ -314,12 +315,11 @@ async function callJudge(args) {
   const apiKey = args.apiKey ?? process.env.OPENROUTER_API_KEY ?? process.env.OPENAI_API_KEY;
   const deliverableText = `Values to evaluate:
 ${formatJudgeValues(args.values)}`;
-  const instructionText = `Instruction:
-${args.instruction}`;
-  const systemPromptText = `${JUDGE_SYSTEM_PROMPT}
+  const { briefingText, instructionText } = assembleBriefing(args);
+  const systemPromptText = `${briefingText}
 
 ${deliverableText}`;
-  const cacheKey = `${args.model}\0${deliverableText}`;
+  const cacheKey = `${args.model}\0${briefingText}\0${deliverableText}`;
   return runWithSharedPrefix(cacheKey, async () => {
     const startedAt = Date.now();
     const response = await fetch(`${baseURL}/chat/completions`, {
@@ -334,7 +334,7 @@ ${deliverableText}`;
           {
             role: "system",
             content: [
-              { type: "text", text: JUDGE_SYSTEM_PROMPT },
+              { type: "text", text: briefingText },
               {
                 type: "text",
                 text: deliverableText,
@@ -384,6 +384,33 @@ ${deliverableText}`;
     };
   });
 }
+function assembleBriefing(args) {
+  if (!args.prompt) {
+    return {
+      briefingText: JUDGE_SYSTEM_PROMPT,
+      instructionText: `Instruction:
+${args.instruction}`
+    };
+  }
+  const ctx = {
+    taskId: args.context?.taskId ?? "",
+    checkName: args.context?.checkName ?? "",
+    ...args.context?.taskDescription !== void 0 ? { taskDescription: args.context.taskDescription } : {},
+    ...args.context?.deliverableNames !== void 0 && args.context.deliverableNames.length > 0 ? { deliverableNames: args.context.deliverableNames } : {},
+    instruction: args.instruction
+  };
+  const built = args.prompt(ctx);
+  const system = built.system?.trim();
+  const user = built.user?.trim();
+  return {
+    // The SDK appends its own response contract to any custom briefing.
+    briefingText: system ? `${system}
+
+${JUDGE_RESPONSE_CONTRACT}` : JUDGE_SYSTEM_PROMPT,
+    instructionText: user ?? `Instruction:
+${args.instruction}`
+  };
+}
 
 // src/agent-task/checks/t.ts
 function resolveJudgeConfig(judgeConfig, override) {
@@ -392,7 +419,8 @@ function resolveJudgeConfig(judgeConfig, override) {
   return {
     model,
     baseURL: override?.baseURL ?? judgeConfig?.baseURL,
-    apiKey: override?.apiKey ?? judgeConfig?.apiKey
+    apiKey: override?.apiKey ?? judgeConfig?.apiKey,
+    prompt: override?.prompt ?? judgeConfig?.prompt
   };
 }
 var TEST_METHOD_NAMES = [
@@ -421,6 +449,67 @@ function matchName(name, m) {
   if (m instanceof RegExp) return m.test(name);
   return m(name);
 }
+function createJudgeMethod(rec, judgeConfig, judgeScope) {
+  return async (values, instruction, opts) => {
+    const label = opts?.label ?? "judge";
+    const location = rec.captureLocation();
+    const valueArray = Array.isArray(values) ? values : [values];
+    const effective = resolveJudgeConfig(judgeConfig, opts?.judge);
+    if (!effective) {
+      rec.record(
+        label,
+        false,
+        "No judge model configured. Set one of:\n\u2022 OPENROUTER_MODEL + OPENROUTER_API_KEY (OpenRouter \u2014 works with 200+ models, one account)\n\u2022 OPENAI_MODEL + OPENAI_API_KEY (OpenAI direct)\nOr pass { judge } to runTask() programmatically.",
+        { evaluator_type: "llm", location }
+      );
+      return;
+    }
+    const context2 = judgeScopeToContext(judgeScope);
+    try {
+      const { pass, reasoning, judge } = await callJudge({
+        values: valueArray,
+        instruction,
+        model: effective.model,
+        baseURL: effective.baseURL,
+        apiKey: effective.apiKey,
+        prompt: effective.prompt,
+        ...context2 ? { context: context2 } : {}
+      });
+      rec.record(label, pass, reasoning, {
+        evaluator_type: "llm",
+        judge,
+        expected: instruction,
+        // Store the raw evaluated value (not a truncated string) so the
+        // dashboard can render it with the right viewer — Markdown for
+        // prose, a JSON tree for structured objects.
+        received: valueArray.length === 1 ? valueArray[0] : valueArray,
+        location
+      });
+    } catch (error) {
+      rec.record(
+        label,
+        false,
+        `judge failed: ${error instanceof Error ? error.message : String(error)}`,
+        {
+          evaluator_type: "llm",
+          expected: instruction,
+          received: valueArray.length === 1 ? valueArray[0] : valueArray,
+          location
+        }
+      );
+    }
+  };
+}
+function judgeScopeToContext(scope) {
+  if (!scope) return void 0;
+  const deliverableNames = scope.readDeliverableNames?.();
+  return {
+    taskId: scope.taskId,
+    checkName: scope.checkName,
+    ...scope.taskDescription !== void 0 ? { taskDescription: scope.taskDescription } : {},
+    ...deliverableNames && deliverableNames.length > 0 ? { deliverableNames } : {}
+  };
+}
 var CAPABILITY_LABELS = {
   messages: "message",
   tools: "tool",
@@ -429,7 +518,7 @@ var CAPABILITY_LABELS = {
   skills: "skill",
   subagents: "subagent"
 };
-function createTraceTestContext(view, rec, judgeConfig) {
+function createTraceTestContext(view, rec, judgeConfig, judgeScope) {
   const unsupported = (id, capability) => {
     const label = CAPABILITY_LABELS[capability];
     rec.record(id, false, `${label} evidence is unavailable in this trace projection`, {
@@ -613,49 +702,9 @@ function createTraceTestContext(view, rec, judgeConfig) {
         { expected: matcher.label, received: describeValue(value) }
       );
     },
-    async judge(values, instruction, opts) {
-      const label = opts?.label ?? "judge";
-      const location = rec.captureLocation();
-      const valueArray = Array.isArray(values) ? values : [values];
-      const effective = resolveJudgeConfig(judgeConfig, opts?.judge);
-      if (!effective) {
-        rec.record(
-          label,
-          false,
-          "No judge model configured. Set one of:\n\u2022 OPENROUTER_MODEL + OPENROUTER_API_KEY (OpenRouter \u2014 works with 200+ models, one account)\n\u2022 OPENAI_MODEL + OPENAI_API_KEY (OpenAI direct)\nOr pass { judge } to runTask() programmatically.",
-          { evaluator_type: "llm", location }
-        );
-        return;
-      }
-      try {
-        const { pass, reasoning, judge } = await callJudge({
-          values: valueArray,
-          instruction,
-          model: effective.model,
-          baseURL: effective.baseURL,
-          apiKey: effective.apiKey
-        });
-        rec.record(label, pass, reasoning, {
-          evaluator_type: "llm",
-          judge,
-          expected: instruction,
-          received: valueArray.length === 1 ? valueArray[0] : valueArray,
-          location
-        });
-      } catch (error) {
-        rec.record(
-          label,
-          false,
-          `judge failed: ${error instanceof Error ? error.message : String(error)}`,
-          {
-            evaluator_type: "llm",
-            expected: instruction,
-            received: valueArray.length === 1 ? valueArray[0] : valueArray,
-            location
-          }
-        );
-      }
-    }
+    // judge does not consult trace capabilities; the scope carries the
+    // task/check frame for prompt builders (#161).
+    judge: createJudgeMethod(rec, judgeConfig, judgeScope)
   };
 }
 function matchesTraceToolCall(call, name, opts) {
@@ -787,14 +836,21 @@ function describe(id, nameOrFn, fn) {
 async function runTraceChecks(args) {
   const view = new TraceView(args.snapshot);
   const locate = args.moduleUrl && args.displayFile ? (stack) => parseCheckLocation(stack, args.moduleUrl, args.displayFile) : void 0;
+  const taskMeta = readTaskMeta(args.task);
   const results = await Promise.all(
     registry.map(async (check) => {
       const rec = new Recorder(locate);
-      const t = createTraceTestContext(view, rec, args.judgeConfig);
+      const reads = trackDeliverableReads(args.deliverables);
+      const t = createTraceTestContext(view, rec, args.judgeConfig, {
+        taskId: taskMeta.id ?? "",
+        ...taskMeta.description !== void 0 ? { taskDescription: taskMeta.description } : {},
+        checkName: check.id,
+        readDeliverableNames: reads.names
+      });
       let thrownLocation;
       try {
         await check.fn(t, {
-          deliverables: args.deliverables,
+          deliverables: reads.proxied,
           files: args.files,
           task: args.task
         });
@@ -866,6 +922,26 @@ function proxyBrokenDeliverables(deliverables, brokenDeliverables) {
     }
   });
 }
+function readTaskMeta(task2) {
+  if (!task2 || typeof task2 !== "object") return {};
+  const record = task2;
+  return {
+    ...typeof record.id === "string" ? { id: record.id } : {},
+    ...typeof record.description === "string" ? { description: record.description } : {}
+  };
+}
+function trackDeliverableReads(deliverables) {
+  const read = /* @__PURE__ */ new Set();
+  const proxied = new Proxy(deliverables, {
+    get(target, property, receiver) {
+      if (typeof property === "string" && Object.prototype.hasOwnProperty.call(target, property)) {
+        read.add(property);
+      }
+      return Reflect.get(target, property, receiver);
+    }
+  });
+  return { proxied, names: () => [...read] };
+}
 
 // src/agent-task/task/defineTask.ts
 var TASK_ADAPTER_SYMBOL = /* @__PURE__ */ Symbol.for("agent-task.adapter-definition");
@@ -919,7 +995,7 @@ function attachAdapter(taskDefinition, adapter) {
 }
 
 // src/agent-task/task/loadTask.ts
-import { copyFileSync as copyFileSync2, readdirSync, statSync, existsSync as existsSync2, unlinkSync as unlinkSync2 } from "fs";
+import { copyFileSync as copyFileSync2, readdirSync, statSync, existsSync as existsSync2, unlinkSync as unlinkSync2, writeFileSync } from "fs";
 import { join, resolve, basename as basename2 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 
@@ -966,6 +1042,48 @@ async function loadTask(taskDir) {
     evalFileName: basename2(taskFilePath)
   };
 }
+async function loadEvalSource(fileName, content, opts = {}) {
+  const dir = opts.siblingDir ?? opts.isolatedDir;
+  if (!dir) {
+    throw new Error("loadEvalSource requires a siblingDir or isolatedDir to materialize next to");
+  }
+  const tempPath = join(
+    dir,
+    `${fileName}.rejudge-${Date.now()}-${Math.random().toString(36).slice(2)}.ts`
+  );
+  writeFileSync(tempPath, content);
+  try {
+    const { task: task2, adapter, inlineChecks, moduleUrl } = await loadTaskDefinition(tempPath);
+    validateTaskDefinition(task2, dir);
+    if (!inlineChecks && !existsSync2(join(dir, "checks.ts"))) {
+      throw new Error(
+        `The pinned eval did not register checks: legacy two-file tasks need their checks module, which the stored definition revision does not include`
+      );
+    }
+    return {
+      task: task2,
+      adapter,
+      taskDir: dir,
+      files: loadFilesDirectory(dir),
+      checksPath: resolveChecksPath(task2, dir),
+      inlineChecks,
+      moduleUrl,
+      evalFileName: fileName
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!opts.siblingDir && /Failed to load task definition/.test(message)) {
+      throw new Error(
+        `Replay needs the task directory: the pinned eval imports sibling files that are not part of the stored definition revision. Point the command at a checkout of the task (--task-dir) and retry. Underlying error: ${message}`
+      );
+    }
+    throw error;
+  } finally {
+    if (existsSync2(tempPath)) {
+      unlinkSync2(tempPath);
+    }
+  }
+}
 async function loadTaskDefinition(taskFilePath) {
   const tempModulePath = `${taskFilePath}.${Date.now()}-${Math.random().toString(36).slice(2)}.ts`;
   try {
@@ -2034,6 +2152,7 @@ async function executeLoadedTask(loaded, options, rawTrace, traceRunId) {
             summarize: (result2) => summarizeEvaluationResults(result2)
           },
           async () => {
+            const judgeConfig = resolveJudgeConfig(options?.judge, task2.judge);
             if (!inlineChecks) {
               return loadAndRunFlowChecks(
                 checksPath,
@@ -2042,7 +2161,7 @@ async function executeLoadedTask(loaded, options, rawTrace, traceRunId) {
                   deliverables: collected,
                   files,
                   task: task2,
-                  judgeConfig: options?.judge
+                  ...judgeConfig ? { judgeConfig } : {}
                 },
                 validationResults.brokenDeliverables
               );
@@ -2055,7 +2174,7 @@ async function executeLoadedTask(loaded, options, rawTrace, traceRunId) {
               ),
               files,
               task: task2,
-              judgeConfig: options?.judge,
+              ...judgeConfig ? { judgeConfig } : {},
               moduleUrl,
               displayFile: evalFileName
             });
@@ -2235,12 +2354,13 @@ async function evaluate(loaded, options, phase1) {
     phase1.collected,
     validationResults.brokenDeliverables
   );
+  const judgeConfig = resolveJudgeConfig(options?.judge, task2.judge);
   const checksResults = await (inlineChecks ? runTraceChecks({
     snapshot: phase1.snapshot,
     deliverables,
     files,
     task: task2,
-    judgeConfig: options?.judge,
+    ...judgeConfig ? { judgeConfig } : {},
     moduleUrl,
     displayFile: evalFileName
   }) : loadAndRunFlowChecks(
@@ -2250,7 +2370,7 @@ async function evaluate(loaded, options, phase1) {
       deliverables,
       files,
       task: task2,
-      judgeConfig: options?.judge
+      ...judgeConfig ? { judgeConfig } : {}
     },
     validationResults.brokenDeliverables
   ));
@@ -2315,12 +2435,248 @@ function buildTraceRunOptions(loaded, tracing) {
   };
 }
 
+// src/agent-task/run/rejudge.ts
+import { mkdtempSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir } from "os";
+import { basename as basename4, dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+var RejudgeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RejudgeError";
+  }
+};
+var TERMINAL_VERDICT_STATUSES = /* @__PURE__ */ new Set(["passed", "failed"]);
+var MAX_SAMPLES = 50;
+async function rejudgeTaskRun(runId, endpoints, options = {}) {
+  const api = createApiClient(endpoints);
+  const progress = options.onProgress ?? (() => {
+  });
+  const detail = await api.get(`/v1/agent-task-runs/${runId}`);
+  if (!TERMINAL_VERDICT_STATUSES.has(detail.status)) {
+    throw new RejudgeError(
+      `Run ${runId} is '${detail.status}', not a completed run with a verdict \u2014 there is nothing to replay against yet`
+    );
+  }
+  const manifest = await api.get(
+    `/v1/agent-task-runs/${runId}/deliverables`
+  );
+  const items = manifest.items ?? [];
+  const notReady = items.filter((item) => item.status !== "ready");
+  if (notReady.length > 0) {
+    const names = notReady.map((item) => `${item.name} (${item.status})`).join(", ");
+    throw new RejudgeError(
+      `Refusing to replay run ${runId}: deliverables are not ready: ${names}. A missing deliverable must not render as a low score \u2014 re-run the agent instead.`
+    );
+  }
+  const requestedRevision = options.definitionRevisionId ?? detail.task_definition?.id ?? null;
+  if (!requestedRevision) {
+    throw new RejudgeError(
+      `Run ${runId} has no pinned Task Definition Revision \u2014 its checks cannot be replayed`
+    );
+  }
+  const sourceQuery = options.definitionRevisionId && options.definitionRevisionId !== detail.task_definition?.id ? `?revision=${encodeURIComponent(options.definitionRevisionId)}` : "";
+  progress(`fetching definition source (${requestedRevision})`);
+  const source = await api.get(
+    `/v1/agent-task-runs/${runId}/definition-source${sourceQuery}`
+  );
+  const revisionId = source.task_definition_revision_id;
+  const revisionIsPinned = revisionId === (detail.task_definition?.id ?? null);
+  const evalFile = source.files[0];
+  if (!evalFile) {
+    throw new RejudgeError(`Definition revision ${revisionId} carries no source files`);
+  }
+  progress("fetching stored deliverables");
+  const artifactDir = mkdtempSync(join2(tmpdir(), "apo-rejudge-artifacts-"));
+  let scaffoldDir = null;
+  try {
+    const taskDir = options.taskDir ?? null;
+    scaffoldDir = taskDir ? null : isolatedScaffoldDir();
+    const deliverables = await fetchDeliverables(api, runId, items, artifactDir);
+    progress("reading canonical trace projection");
+    const snapshotResult = await readCanonicalSnapshot2(
+      endpoints,
+      runId,
+      options.projectionDeadlineMs
+    );
+    if (!snapshotResult.available) {
+      progress(
+        "trace projection unavailable \u2014 trajectory assertions (t.calledTool, \u2026) will be recorded as unsupported rather than replayed"
+      );
+    }
+    const snapshot = snapshotResult.snapshot;
+    const loaded = await loadEvalSource(evalFile.path, evalFile.content, {
+      siblingDir: taskDir,
+      isolatedDir: scaffoldDir
+    });
+    progress(`loaded eval ${evalFile.path} from revision ${revisionId}`);
+    const missingDeliverables = loaded.task.deliverables.filter(
+      (name) => !Object.prototype.hasOwnProperty.call(deliverables, name)
+    );
+    if (missingDeliverables.length > 0) {
+      throw new RejudgeError(
+        `Refusing to replay run ${runId}: stored deliverables are incomplete; missing ${missingDeliverables.join(", ")}. Re-run the agent instead.`
+      );
+    }
+    const samples = Math.max(1, Math.min(options.samples ?? 1, MAX_SAMPLES));
+    const validation = validateDeliverables(
+      loaded.task,
+      deliverables,
+      loaded.adapter.deliverables
+    );
+    const proxied = proxyBrokenDeliverables(deliverables, validation.brokenDeliverables);
+    const passCounts = /* @__PURE__ */ new Map();
+    let primary = [];
+    const judgeConfig = resolveJudgeConfig(options.judge, loaded.task.judge);
+    for (let sample = 0; sample < samples; sample++) {
+      if (samples > 1) progress(`judging sample ${sample + 1}/${samples}`);
+      const results = await runChecksOnce(loaded, proxied, snapshot, judgeConfig);
+      if (sample === 0) primary = results;
+      for (const result of results) {
+        passCounts.set(result.id, (passCounts.get(result.id) ?? 0) + (result.pass ? 1 : 0));
+      }
+    }
+    const stability = primary.map((result) => ({
+      check_id: result.id,
+      passes: passCounts.get(result.id) ?? 0,
+      samples
+    }));
+    const aggregate = aggregateResult(primary);
+    return {
+      runId,
+      taskId: detail.task_id,
+      definitionRevisionId: revisionId,
+      definitionRevisionIsPinned: revisionIsPinned,
+      judge: judgeConfig ? {
+        model: judgeConfig.model,
+        baseURL: judgeConfig.baseURL ?? process.env.OPENROUTER_BASE_URL
+      } : null,
+      samples,
+      checks: aggregate.checks,
+      pass: aggregate.pass,
+      stability,
+      traceSnapshotAvailable: snapshotResult.available,
+      taskDirUsed: taskDir
+    };
+  } finally {
+    rmSync(artifactDir, { recursive: true, force: true });
+    if (scaffoldDir) rmSync(scaffoldDir, { recursive: true, force: true });
+  }
+}
+async function runChecksOnce(loaded, deliverables, snapshot, judgeConfig) {
+  if (loaded.inlineChecks) {
+    return runTraceChecks({
+      snapshot,
+      deliverables,
+      files: loaded.files,
+      task: loaded.task,
+      judgeConfig,
+      moduleUrl: loaded.moduleUrl,
+      displayFile: loaded.evalFileName
+    });
+  }
+  return loadAndRunFlowChecks(
+    loaded.checksPath,
+    {
+      snapshot,
+      deliverables,
+      files: loaded.files,
+      task: loaded.task,
+      judgeConfig
+    },
+    {}
+  );
+}
+async function fetchDeliverables(api, runId, items, artifactDir) {
+  const deliverables = {};
+  for (const [index, item] of items.entries()) {
+    if (item.kind === "artifact") {
+      const bytes = await api.getBytes(`/v1/agent-task-runs/${runId}/deliverables/${item.id}`);
+      const displayFilename = item.display_filename || item.name;
+      const safeFilename = basename4(displayFilename) || "artifact";
+      const path = join2(artifactDir, `artifact-${index}-${safeFilename}`);
+      writeFileSync2(path, bytes);
+      deliverables[item.name] = Object.freeze({
+        kind: "apo.file-artifact",
+        path,
+        mediaType: item.media_type ?? "application/octet-stream",
+        displayFilename
+      });
+    } else {
+      deliverables[item.name] = await api.getJson(
+        `/v1/agent-task-runs/${runId}/deliverables/${item.id}`
+      );
+    }
+  }
+  return deliverables;
+}
+async function readCanonicalSnapshot2(endpoints, runId, deadlineMs) {
+  try {
+    const snapshot = await readTaskRunProjection({
+      endpoint: endpoints.backendUrl,
+      authToken: endpoints.authToken,
+      taskRunId: runId,
+      deadlineMs: deadlineMs ?? 15e3
+    });
+    return { available: true, snapshot };
+  } catch {
+    return { available: false, snapshot: degenerateSnapshot(runId) };
+  }
+}
+function degenerateSnapshot(runId) {
+  return {
+    schemaVersion: 1,
+    projectionVersion: 1,
+    source: "local",
+    trace: { traceId: `rejudge-${runId}`, complete: true },
+    capabilities: {
+      messages: "unavailable",
+      tools: "unavailable",
+      errors: "unavailable",
+      timing: "unavailable",
+      skills: "unavailable",
+      subagents: "unavailable"
+    },
+    observations: []
+  };
+}
+function isolatedScaffoldDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  return mkdtempSync(join2(here, ".rejudge-scaffold-"));
+}
+function createApiClient(endpoints) {
+  const base = endpoints.backendUrl.replace(/\/$/, "");
+  const headers = { Authorization: `Bearer ${endpoints.authToken}` };
+  async function request(path) {
+    const response = await fetch(`${base}${path}`, { headers });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new RejudgeError(
+        `${path} failed (${response.status}): ${body.slice(0, 200) || response.statusText}`
+      );
+    }
+    return response;
+  }
+  return {
+    async get(path) {
+      return await request(path).then((r) => r.json());
+    },
+    async getJson(path) {
+      return request(path).then((r) => r.json());
+    },
+    async getBytes(path) {
+      const buffer = await request(path).then((r) => r.arrayBuffer());
+      return Buffer.from(new Uint8Array(buffer));
+    }
+  };
+}
+
 // src/agent-task/cli.ts
 import { relative, resolve as resolve3 } from "path";
 
 // src/agent-task/discovery.ts
 import { existsSync as existsSync3, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { join as join2, resolve as resolve2 } from "path";
+import { join as join3, resolve as resolve2 } from "path";
 function discoverAgentTaskDirs(rootDir) {
   const absoluteRoot = resolve2(rootDir);
   if (!existsSync3(absoluteRoot) || !statSync3(absoluteRoot).isDirectory()) {
@@ -2336,7 +2692,7 @@ function walkForTaskDirs(currentDir, discovered) {
     return;
   }
   for (const entry of readdirSync2(currentDir)) {
-    const absolutePath = join2(currentDir, entry);
+    const absolutePath = join3(currentDir, entry);
     if (!statSync3(absolutePath).isDirectory()) {
       continue;
     }
@@ -2998,6 +3354,7 @@ export {
   AgentTaskRunError,
   ApoSpanProcessor,
   FlowView,
+  RejudgeError,
   TEST_METHOD_NAMES,
   TaskFiles,
   buildManifest,
@@ -3028,6 +3385,7 @@ export {
   parseAgentTaskCliArgs,
   persistFileArtifacts,
   registerApoTracing,
+  rejudgeTaskRun,
   resetApoTracing,
   resetFlowChecks,
   resetTaskRegistry,