@apo-ai/sdk 0.4.0 → 0.6.0

package/dist/agent-task/public.js

@@ -8,14 +8,14 @@ import {
   resetApoTracing,
   withApoRun,
   withApoRunSync
-} from "../chunk-PMYLL2H4.js";
+} from "../chunk-GETY34VI.js";
 import {
   createApoTracer
-} from "../chunk-HKLBPIB4.js";
+} from "../chunk-H7ITLBWU.js";
 import "../chunk-HWZVL6TS.js";
 import {
   createApoOpenAI
-} from "../chunk-DT2LMB7O.js";
+} from "../chunk-6ZRW5IW6.js";
 import {
   createApoAnthropic
 } from "../chunk-SZDSIPXC.js";
@@ -235,8 +235,21 @@ function levenshtein(a, b) {
 }
 
 // src/agent-task/checks/judge.ts
-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}`;
+var VERDICT_FIRST_CONTRACT = 'Respond with ONLY a JSON object: {"pass": true/false, "reasoning": "your reasoning"}';
+var REASONING_FIRST_CONTRACT = 'Respond with ONLY a JSON object: {"reasoning": "your reasoning", "pass": true/false}';
+function isJudgeVerdictFirstOverrideEnabled() {
+  const value = process.env.APO_JUDGE_VERDICT_FIRST?.trim().toLowerCase();
+  return value === "1" || value === "true";
+}
+function judgeResponseContract() {
+  return isJudgeVerdictFirstOverrideEnabled() ? VERDICT_FIRST_CONTRACT : REASONING_FIRST_CONTRACT;
+}
+function judgeContractInUse() {
+  return isJudgeVerdictFirstOverrideEnabled() ? "verdict-first" : "reasoning-first";
+}
+function judgeSystemPrompt() {
+  return `You are an evaluation judge. Evaluate the given value(s) against the instruction. ${judgeResponseContract()}`;
+}
 function formatValue(value, depth = 0) {
   const indent = "  ".repeat(depth);
   if (value === null || value === void 0) return String(value);
@@ -297,6 +310,7 @@ function parseJudgeJson(raw) {
     reasoning: "Judge response could not be parsed as JSON \u2014 the verdict is unknown, so this check is treated as a failure. The model's raw response is available in the judge metadata."
   };
 }
+var JUDGE_TIMEOUT_MS = 12e4;
 var prefixQueues = /* @__PURE__ */ new Map();
 function runWithSharedPrefix(key, task2) {
   const prev = prefixQueues.get(key) ?? Promise.resolve();
@@ -324,6 +338,7 @@ ${deliverableText}`;
     const startedAt = Date.now();
     const response = await fetch(`${baseURL}/chat/completions`, {
       method: "POST",
+      signal: AbortSignal.timeout(JUDGE_TIMEOUT_MS),
       headers: {
         "Content-Type": "application/json",
         ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
@@ -363,6 +378,7 @@ ${deliverableText}`;
         reasoning: "Judge returned an empty or truncated response \u2014 likely a transient provider failure. The verdict is unknown, so this check is treated as a failure.",
         judge: {
           model: args.model,
+          contract: judgeContractInUse(),
           prompt: { system: systemPromptText, user: instructionText },
           response: text,
           tokens: parseJudgeUsage(data.usage),
@@ -376,6 +392,7 @@ ${deliverableText}`;
       reasoning: typeof parsed.reasoning === "string" ? parsed.reasoning : "",
       judge: {
         model: args.model,
+        contract: judgeContractInUse(),
         prompt: { system: systemPromptText, user: instructionText },
         response: text,
         tokens: parseJudgeUsage(data.usage),
@@ -387,7 +404,7 @@ ${deliverableText}`;
 function assembleBriefing(args) {
   if (!args.prompt) {
     return {
-      briefingText: JUDGE_SYSTEM_PROMPT,
+      briefingText: judgeSystemPrompt(),
       instructionText: `Instruction:
 ${args.instruction}`
     };
@@ -406,7 +423,7 @@ ${args.instruction}`
     // The SDK appends its own response contract to any custom briefing.
     briefingText: system ? `${system}
 
-${JUDGE_RESPONSE_CONTRACT}` : JUDGE_SYSTEM_PROMPT,
+${judgeResponseContract()}` : judgeSystemPrompt(),
     instructionText: user ?? `Instruction:
 ${args.instruction}`
   };
@@ -876,8 +893,8 @@ async function runTraceChecks(args) {
         ...rec.all.length > 0 ? { assertions: rec.all.map((a) => ({ ...a })) } : {},
         ...check.group_id ? { group_id: check.group_id } : {},
         ...check.group_name ? { group_name: check.group_name } : {},
-        // stamp the snapshot source so consumers can detect
-        // the deprecated legacy-flow compatibility path (source="legacy-flow").
+        // stamp the snapshot source so consumers can tell projection-first
+        // results (canonical) from locally recorded snapshots.
         ...args.snapshot.source !== "canonical" ? { source: args.snapshot.source } : {}
       };
     })
@@ -1380,6 +1397,115 @@ async function safeDetail(response) {
   }
 }
 
+// src/agent-task/checks/compact.ts
+import { createHash as createHash2 } from "crypto";
+var RECEIVED_VALUE_LIMIT = 4 * 1024;
+var JUDGE_SEGMENT_LIMIT = 16 * 1024;
+var PREVIEW_CHARS = 256;
+function compactChecksForSubmission(checks) {
+  let truncatedValues = 0;
+  let truncatedSegments = 0;
+  const compacted = checks.map((check) => {
+    const next = { ...check };
+    if ("received" in next && next.received !== void 0) {
+      const replaced = truncateValue(next.received);
+      if (replaced !== next.received) {
+        next.received = replaced;
+        truncatedValues += 1;
+      }
+    }
+    if (next.judge !== void 0) {
+      const { value, truncated } = truncateJudge(next.judge);
+      if (value !== next.judge) {
+        next.judge = value;
+        truncatedSegments += truncated;
+      }
+    }
+    const sourceAssertions = check.assertions;
+    if (sourceAssertions) {
+      const assertions = sourceAssertions.map((assertion) => {
+        const nextAssertion = { ...assertion };
+        if (nextAssertion.received !== void 0) {
+          const replaced = truncateValue(nextAssertion.received);
+          if (replaced !== nextAssertion.received) {
+            nextAssertion.received = replaced;
+            truncatedValues += 1;
+          }
+        }
+        if (nextAssertion.judge !== void 0) {
+          const { value, truncated } = truncateJudge(nextAssertion.judge);
+          if (value !== nextAssertion.judge) {
+            nextAssertion.judge = value;
+            truncatedSegments += truncated;
+          }
+        }
+        return nextAssertion;
+      });
+      if (assertions.some((a, i) => a !== sourceAssertions[i])) {
+        next.assertions = assertions;
+      }
+    }
+    return next;
+  });
+  return { checks: compacted, truncatedValues, truncatedSegments };
+}
+function truncateJudge(judge) {
+  if (typeof judge !== "object" || judge === null) {
+    return { value: judge, truncated: 0 };
+  }
+  let truncated = 0;
+  const next = { ...judge };
+  const prompt = next.prompt;
+  if (typeof prompt === "object" && prompt !== null) {
+    const nextPrompt = { ...prompt };
+    for (const key of ["system", "user"]) {
+      const value = nextPrompt[key];
+      if (typeof value === "string") {
+        const replaced = truncateText(value);
+        if (replaced !== value) {
+          nextPrompt[key] = replaced;
+          truncated += 1;
+        }
+      }
+    }
+    next.prompt = nextPrompt;
+  }
+  if (typeof next.response === "string") {
+    const replaced = truncateText(next.response);
+    if (replaced !== next.response) {
+      next.response = replaced;
+      truncated += 1;
+    }
+  }
+  return { value: next, truncated };
+}
+function truncateValue(value) {
+  if (value === void 0) return value;
+  let bytes;
+  try {
+    bytes = new TextEncoder().encode(JSON.stringify(value));
+  } catch {
+    bytes = new TextEncoder().encode(JSON.stringify(String(value)));
+  }
+  if (bytes.length <= RECEIVED_VALUE_LIMIT) return value;
+  return marker(bytes);
+}
+function truncateText(value) {
+  const bytes = new TextEncoder().encode(value);
+  if (bytes.length <= JUDGE_SEGMENT_LIMIT) return value;
+  return marker(bytes);
+}
+function marker(bytes) {
+  const previewBytes = bytes.slice(0, PREVIEW_CHARS);
+  const preview = Buffer.from(previewBytes).toString("utf8");
+  return {
+    kind: "truncated",
+    preview,
+    size_bytes: bytes.length,
+    sha256: createHash2("sha256").update(bytes).digest("hex")
+  };
+}
+
 // src/agent-task/flow/view.ts
 var FlowView = class {
   constructor(flow) {
@@ -1629,6 +1755,8 @@ function observationTypeFor(t) {
       return "EMBEDDING";
     case "GUARDRAIL":
       return "GUARDRAIL";
+    case "SKILL":
+      return "SKILL";
     default:
       return "SPAN";
   }
@@ -1975,369 +2103,222 @@ async function readCanonicalSnapshot(trace2) {
     return null;
   }
 }
-async function executeLoadedTask(loaded, options, rawTrace, traceRunId) {
+async function executeAdapterRun(loaded, options, rawTrace, continueWith) {
   const {
     task: task2,
     adapter,
     taskDir: absoluteDir,
     files,
     checksPath,
-    inlineChecks,
-    moduleUrl,
-    evalFileName
+    inlineChecks
   } = loaded;
-  const taskFiles = new TaskFiles(files);
   const tee = createProjectionTee(rawTrace);
-  const { trace: trace2, getSnapshot } = { trace: tee.trace, getSnapshot: () => tee.getSnapshot() };
+  const trace2 = tee.trace;
   return withApoRun(
     { trace: trace2, parentSpanId: rawTrace.rootSpanId, taskId: task2.id },
     async () => {
-      return executeRunBody();
-    }
-  );
-  async function executeRunBody() {
-    let state;
-    let session;
-    const transcriptTurns = [];
-    try {
-      await trace2.step(
-        {
-          step_name: "task.load",
-          input: { taskId: task2.id, taskDir: absoluteDir },
-          metadata: {
-            taskId: task2.id,
-            taskDir: absoluteDir,
-            fileCount: files.length,
-            hasChecks: inlineChecks || checksPath !== null
-          },
-          summarize: () => ({
-            taskId: task2.id,
-            adapterName: adapter.name
-          })
-        },
-        async () => loaded
-      );
-      if (adapter.initialize) {
-        const initState = await trace2.step(
-          {
-            step_name: "adapter.initialize",
-            input: { adapterName: adapter.name },
-            metadata: { adapterName: adapter.name },
-            summarize: (result) => ({
-              initialized: true,
-              stateKeys: result && typeof result === "object" ? Object.keys(result) : []
-            })
-          },
-          async () => adapter.initialize?.({
-            task: task2,
-            taskDir: absoluteDir,
-            files,
-            trace: trace2
-          })
-        );
-        state = initState ?? void 0;
-      }
-      session = await trace2.step(
-        {
-          step_name: "adapter.open-session",
-          input: { adapterName: adapter.name, hasState: state !== void 0 },
-          metadata: { adapterName: adapter.name },
-          summarize: () => ({ sessionOpened: true })
-        },
-        async () => adapter.startSession({
-          task: task2,
-          taskDir: absoluteDir,
-          files,
-          state,
-          trace: trace2
-        })
-      );
-      const runConfiguration = normalizeRunConfiguration(session.runConfiguration);
+      let state;
+      let session;
       try {
-        if (!inlineChecks && checksPath) {
-          resetTaskTurn();
-          resetFlowChecks();
-          await loadChecksModule(checksPath);
-        }
-        const taskTurn = getTaskTurn();
-        resetTaskTurn();
-        const turnFn = resolveTurn(adapter.turn, taskTurn);
-        if (turnFn) {
-          const turnTranscript = [];
-          let lastTurnResponse;
-          const maxTurns = options?.maxTurnsOverride ?? task2.maxTurns ?? 10;
-          for (let turnNum = 1; turnNum <= maxTurns; turnNum++) {
-            const userTurn = await turnFn({ files: taskFiles, transcript: turnTranscript });
-            if (userTurn === null || userTurn === void 0) break;
-            const result2 = await trace2.step(
-              {
-                step_name: "task.turn",
-                metadata: { turnNumber: turnNum },
-                summarize: (r) => ({ response: r.response })
-              },
-              async (spanId) => {
-                if (!session) throw new Error("Session not created");
-                return session.sendUserTurn(userTurn, {
-                  trace: trace2,
-                  turnNumber: turnNum,
-                  parentSpanId: spanId
-                });
-              }
-            );
-            turnTranscript.push({
-              turnNumber: turnNum,
-              input: userTurn,
-              output: result2.response
-            });
-            transcriptTurns.push({
-              turnNumber: turnNum,
-              userAction: userTurn,
-              agentResponse: result2.response
-            });
-            options?.onTurn?.(turnNum, userTurn, result2.response);
-            lastTurnResponse = result2.response;
-          }
-          if (lastTurnResponse !== void 0) {
-            rawTrace.endRoot({ output: { response: lastTurnResponse } });
-          }
-        }
-        const collected = await trace2.step(
+        await trace2.step(
           {
-            step_name: "adapter.collect-deliverables",
-            input: { adapterName: adapter.name, expectedDeliverables: task2.deliverables },
-            metadata: { adapterName: adapter.name },
-            summarize: (result2) => {
-              const keys = result2 && typeof result2 === "object" ? Object.keys(result2) : [];
-              return { deliverableCount: keys.length, deliverableNames: keys };
-            }
-          },
-          async () => {
-            if (!session) {
-              throw new Error("Adapter session was not created");
-            }
-            return adapter.collectDeliverables({
-              task: task2,
+            step_name: "task.load",
+            input: { taskId: task2.id, taskDir: absoluteDir },
+            metadata: {
+              taskId: task2.id,
               taskDir: absoluteDir,
-              files,
-              state,
-              session,
-              trace: trace2
-            });
-          }
-        );
-        const validationResults = await trace2.step(
-          {
-            step_name: "deliverables.validate",
-            input: { deliverableNames: task2.deliverables },
-            summarize: (result2) => {
-              const r = result2;
-              const passCount = r.results.filter((x) => x.pass).length;
-              const broken = Object.keys(r.brokenDeliverables);
-              return {
-                total: r.results.length,
-                passCount,
-                failCount: r.results.length - passCount,
-                brokenDeliverableCount: broken.length,
-                brokenDeliverables: broken
-              };
-            }
-          },
-          async () => validateDeliverables(task2, collected, adapter.deliverables)
-        );
-        const checksResults = await trace2.step(
-          {
-            step_name: "checks.run",
-            input: { sourceFile: inlineChecks ? evalFileName : checksPath },
-            metadata: { sourceFile: inlineChecks ? evalFileName : checksPath },
-            summarize: (result2) => summarizeEvaluationResults(result2)
+              fileCount: files.length,
+              hasChecks: inlineChecks || checksPath !== null
+            },
+            summarize: () => ({
+              taskId: task2.id,
+              adapterName: adapter.name
+            })
           },
-          async () => {
-            const judgeConfig = resolveJudgeConfig(options?.judge, task2.judge);
-            if (!inlineChecks) {
-              return loadAndRunFlowChecks(
-                checksPath,
-                {
-                  snapshot: getSnapshot(),
-                  deliverables: collected,
-                  files,
-                  task: task2,
-                  ...judgeConfig ? { judgeConfig } : {}
-                },
-                validationResults.brokenDeliverables
-              );
-            }
-            return runTraceChecks({
-              snapshot: getSnapshot(),
-              deliverables: proxyBrokenDeliverables(
-                collected,
-                validationResults.brokenDeliverables
-              ),
-              files,
-              task: task2,
-              ...judgeConfig ? { judgeConfig } : {},
-              moduleUrl,
-              displayFile: evalFileName
-            });
-          }
+          async () => loaded
         );
-        const result = aggregateResult(checksResults);
-        return {
-          task: task2,
-          taskDir: absoluteDir,
-          files,
-          traceRunId,
-          result,
-          deliverables: collected,
-          transcript: { turns: transcriptTurns },
-          runConfiguration
-        };
-      } catch (error) {
-        throw withRunConfiguration(error, runConfiguration);
-      }
-    } finally {
-      if (adapter.cleanup) {
-        try {
-          await trace2.step(
+        if (adapter.initialize) {
+          const initState = await trace2.step(
             {
-              step_name: "adapter.cleanup",
+              step_name: "adapter.initialize",
               input: { adapterName: adapter.name },
               metadata: { adapterName: adapter.name },
-              summarize: () => ({ cleaned: true })
+              summarize: (result) => ({
+                initialized: true,
+                stateKeys: result && typeof result === "object" ? Object.keys(result) : []
+              })
             },
-            async () => adapter.cleanup?.({
+            async () => adapter.initialize?.({
               task: task2,
               taskDir: absoluteDir,
               files,
-              state,
-              session,
               trace: trace2
             })
           );
-        } catch (error) {
-          console.error(
-            "[AgentTask] Cleanup failed:",
-            error instanceof Error ? error.message : String(error)
-          );
-        }
-      }
-      if (session?.close) {
-        try {
-          await session.close();
-        } catch {
-        }
-      }
-    }
-  }
-}
-async function captureExecution(loaded, options, rawTrace) {
-  const {
-    task: task2,
-    adapter,
-    taskDir: absoluteDir,
-    files,
-    checksPath,
-    inlineChecks
-  } = loaded;
-  const taskFiles = new TaskFiles(files);
-  const tee = createProjectionTee(rawTrace);
-  const trace2 = tee.trace;
-  return withApoRun(
-    { trace: trace2, parentSpanId: rawTrace.rootSpanId, taskId: task2.id },
-    async () => {
-      let state;
-      let session;
-      const transcriptTurns = [];
-      try {
-        await trace2.step(
-          { step_name: "task.load", input: { taskId: task2.id, taskDir: absoluteDir }, metadata: { taskId: task2.id, taskDir: absoluteDir, fileCount: files.length, hasChecks: inlineChecks || checksPath !== null }, summarize: () => ({ taskId: task2.id, adapterName: adapter.name }) },
-          async () => loaded
-        );
-        if (adapter.initialize) {
-          const initState = await trace2.step(
-            { step_name: "adapter.initialize", input: { adapterName: adapter.name }, metadata: { adapterName: adapter.name }, summarize: (result) => ({ initialized: true, stateKeys: result && typeof result === "object" ? Object.keys(result) : [] }) },
-            async () => adapter.initialize?.({ task: task2, taskDir: absoluteDir, files, trace: trace2 })
-          );
           state = initState ?? void 0;
         }
         session = await trace2.step(
-          { step_name: "adapter.open-session", input: { adapterName: adapter.name, hasState: state !== void 0 }, metadata: { adapterName: adapter.name }, summarize: () => ({ sessionOpened: true }) },
-          async () => adapter.startSession({ task: task2, taskDir: absoluteDir, files, state, trace: trace2 })
+          {
+            step_name: "adapter.open-session",
+            input: { adapterName: adapter.name, hasState: state !== void 0 },
+            metadata: { adapterName: adapter.name },
+            summarize: () => ({ sessionOpened: true })
+          },
+          async () => adapter.startSession({
+            task: task2,
+            taskDir: absoluteDir,
+            files,
+            state,
+            trace: trace2
+          })
+        );
+        const runConfiguration = normalizeRunConfiguration(
+          session.runConfiguration
         );
-        const runConfiguration = normalizeRunConfiguration(session.runConfiguration);
         try {
-          if (!inlineChecks && checksPath) {
-            resetTaskTurn();
-            resetFlowChecks();
-            await loadChecksModule(checksPath);
-          }
-          const taskTurn = getTaskTurn();
-          resetTaskTurn();
-          const turnFn = resolveTurn(adapter.turn, taskTurn);
-          if (turnFn) {
-            const turnTranscript = [];
-            let lastTurnResponse;
-            const maxTurns = options?.maxTurnsOverride ?? task2.maxTurns ?? 10;
-            for (let turnNum = 1; turnNum <= maxTurns; turnNum++) {
-              const userTurn = await turnFn({ files: taskFiles, transcript: turnTranscript });
-              if (userTurn === null || userTurn === void 0) break;
-              const result = await trace2.step(
-                { step_name: "task.turn", metadata: { turnNumber: turnNum }, summarize: (r) => ({ response: r.response }) },
-                async (spanId) => {
-                  if (!session) throw new Error("Session not created");
-                  return session.sendUserTurn(userTurn, { trace: trace2, turnNumber: turnNum, parentSpanId: spanId });
-                }
-              );
-              turnTranscript.push({ turnNumber: turnNum, input: userTurn, output: result.response });
-              transcriptTurns.push({ turnNumber: turnNum, userAction: userTurn, agentResponse: result.response });
-              options?.onTurn?.(turnNum, userTurn, result.response);
-              lastTurnResponse = result.response;
-            }
-            if (lastTurnResponse !== void 0) {
-              rawTrace.endRoot({ output: { response: lastTurnResponse } });
-            }
-          }
+          const transcriptTurns = await runTurnLoop(
+            loaded,
+            options,
+            session,
+            trace2,
+            rawTrace
+          );
           const collected = await trace2.step(
-            { step_name: "adapter.collect-deliverables", input: { adapterName: adapter.name, expectedDeliverables: task2.deliverables }, metadata: { adapterName: adapter.name }, summarize: (result) => {
-              const keys = result && typeof result === "object" ? Object.keys(result) : [];
-              return { deliverableCount: keys.length, deliverableNames: keys };
-            } },
+            {
+              step_name: "adapter.collect-deliverables",
+              input: {
+                adapterName: adapter.name,
+                expectedDeliverables: task2.deliverables
+              },
+              metadata: { adapterName: adapter.name },
+              summarize: (result) => {
+                const keys = result && typeof result === "object" ? Object.keys(result) : [];
+                return {
+                  deliverableCount: keys.length,
+                  deliverableNames: keys
+                };
+              }
+            },
             async () => {
-              if (!session) throw new Error("Adapter session was not created");
-              return adapter.collectDeliverables({ task: task2, taskDir: absoluteDir, files, state, session, trace: trace2 });
+              if (!session) {
+                throw new Error("Adapter session was not created");
+              }
+              return adapter.collectDeliverables({
+                task: task2,
+                taskDir: absoluteDir,
+                files,
+                state,
+                session,
+                trace: trace2
+              });
             }
           );
-          const snapshot = tee.getSnapshot();
-          return {
-            traceRunId: rawTrace.runId,
+          return await continueWith({
             collected,
             transcriptTurns,
             runConfiguration,
-            snapshot
-          };
+            trace: trace2,
+            getSnapshot: () => tee.getSnapshot()
+          });
         } catch (error) {
           throw withRunConfiguration(error, runConfiguration);
         }
       } finally {
-        if (adapter.cleanup) {
-          try {
-            await trace2.step(
-              { step_name: "adapter.cleanup", input: { adapterName: adapter.name }, metadata: { adapterName: adapter.name }, summarize: () => ({ cleaned: true }) },
-              async () => adapter.cleanup?.({ task: task2, taskDir: absoluteDir, files, state, session, trace: trace2 })
-            );
-          } catch (error) {
-            console.error("[AgentTask] Cleanup failed:", error instanceof Error ? error.message : String(error));
-          }
-        }
-        if (session?.close) {
-          try {
-            await session.close();
-          } catch {
-          }
-        }
+        await cleanupAdapter(loaded, trace2, state, session);
       }
     }
   );
 }
+async function executeLoadedTask(loaded, options, rawTrace, traceRunId) {
+  return executeAdapterRun(loaded, options, rawTrace, async (outcome) => {
+    const {
+      task: task2,
+      adapter,
+      taskDir: absoluteDir,
+      files,
+      checksPath,
+      inlineChecks,
+      moduleUrl,
+      evalFileName
+    } = loaded;
+    const { trace: trace2, collected, transcriptTurns, runConfiguration } = outcome;
+    const validationResults = await trace2.step(
+      {
+        step_name: "deliverables.validate",
+        input: { deliverableNames: task2.deliverables },
+        summarize: (result) => {
+          const r = result;
+          const passCount = r.results.filter((x) => x.pass).length;
+          const broken = Object.keys(r.brokenDeliverables);
+          return {
+            total: r.results.length,
+            passCount,
+            failCount: r.results.length - passCount,
+            brokenDeliverableCount: broken.length,
+            brokenDeliverables: broken
+          };
+        }
+      },
+      async () => validateDeliverables(task2, collected, adapter.deliverables)
+    );
+    const checksResults = await trace2.step(
+      {
+        step_name: "checks.run",
+        input: { sourceFile: inlineChecks ? evalFileName : checksPath },
+        metadata: { sourceFile: inlineChecks ? evalFileName : checksPath },
+        summarize: (result) => summarizeEvaluationResults(result)
+      },
+      async () => {
+        const judgeConfig = resolveJudgeConfig(options?.judge, task2.judge);
+        if (!inlineChecks) {
+          return loadAndRunFlowChecks(
+            checksPath,
+            {
+              snapshot: outcome.getSnapshot(),
+              deliverables: collected,
+              files,
+              task: task2,
+              ...judgeConfig ? { judgeConfig } : {}
+            },
+            validationResults.brokenDeliverables
+          );
+        }
+        return runTraceChecks({
+          snapshot: outcome.getSnapshot(),
+          deliverables: proxyBrokenDeliverables(
+            collected,
+            validationResults.brokenDeliverables
+          ),
+          files,
+          task: task2,
+          ...judgeConfig ? { judgeConfig } : {},
+          moduleUrl,
+          displayFile: evalFileName
+        });
+      }
+    );
+    return {
+      task: task2,
+      taskDir: absoluteDir,
+      files,
+      traceRunId,
+      result: aggregateResult(checksResults),
+      deliverables: collected,
+      transcript: { turns: transcriptTurns },
+      runConfiguration
+    };
+  });
+}
+async function captureExecution(loaded, options, rawTrace) {
+  return executeAdapterRun(loaded, options, rawTrace, async (outcome) => ({
+    traceRunId: rawTrace.runId,
+    collected: outcome.collected,
+    transcriptTurns: outcome.transcriptTurns,
+    runConfiguration: outcome.runConfiguration,
+    // Freeze the snapshot before the root span ends — Phase 2 reads it.
+    snapshot: outcome.getSnapshot()
+  }));
+}
 async function evaluate(loaded, options, phase1) {
   const {
     task: task2,
@@ -2386,6 +2367,89 @@ async function evaluate(loaded, options, phase1) {
     runConfiguration: phase1.runConfiguration
   };
 }
+async function runTurnLoop(loaded, options, session, trace2, rawTrace) {
+  const { task: task2, adapter, files, checksPath, inlineChecks } = loaded;
+  if (!inlineChecks && checksPath) {
+    resetTaskTurn();
+    resetFlowChecks();
+    await loadChecksModule(checksPath);
+  }
+  const taskTurn = getTaskTurn();
+  resetTaskTurn();
+  const turnFn = resolveTurn(adapter.turn, taskTurn);
+  if (!turnFn) return [];
+  const taskFiles = new TaskFiles(files);
+  const turnTranscript = [];
+  const transcriptTurns = [];
+  let lastTurnResponse;
+  const maxTurns = options?.maxTurnsOverride ?? task2.maxTurns ?? 10;
+  for (let turnNum = 1; turnNum <= maxTurns; turnNum++) {
+    const userTurn = await turnFn({ files: taskFiles, transcript: turnTranscript });
+    if (userTurn === null || userTurn === void 0) break;
+    const result = await trace2.step(
+      {
+        step_name: "task.turn",
+        metadata: { turnNumber: turnNum },
+        summarize: (r) => ({ response: r.response })
+      },
+      async (spanId) => session.sendUserTurn(userTurn, {
+        trace: trace2,
+        turnNumber: turnNum,
+        parentSpanId: spanId
+      })
+    );
+    turnTranscript.push({
+      turnNumber: turnNum,
+      input: userTurn,
+      output: result.response
+    });
+    transcriptTurns.push({
+      turnNumber: turnNum,
+      userAction: userTurn,
+      agentResponse: result.response
+    });
+    options?.onTurn?.(turnNum, userTurn, result.response);
+    lastTurnResponse = result.response;
+  }
+  if (lastTurnResponse !== void 0) {
+    rawTrace.endRoot({ output: { response: lastTurnResponse } });
+  }
+  return transcriptTurns;
+}
+async function cleanupAdapter(loaded, trace2, state, session) {
+  const { task: task2, adapter, taskDir: absoluteDir, files } = loaded;
+  if (adapter.cleanup) {
+    try {
+      await trace2.step(
+        {
+          step_name: "adapter.cleanup",
+          input: { adapterName: adapter.name },
+          metadata: { adapterName: adapter.name },
+          summarize: () => ({ cleaned: true })
+        },
+        async () => adapter.cleanup?.({
+          task: task2,
+          taskDir: absoluteDir,
+          files,
+          state,
+          session,
+          trace: trace2
+        })
+      );
+    } catch (error) {
+      console.error(
+        "[AgentTask] Cleanup failed:",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  if (session?.close) {
+    try {
+      await session.close();
+    } catch {
+    }
+  }
+}
 function summarizeEvaluationResults(results) {
   const passCount = results.filter((r) => r.pass).length;
   return {
@@ -3301,12 +3365,12 @@ function printOverallSummary(summaries, hasErrors) {
 }
 
 // src/agent-task/task-revision-manifest.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function normalizeManifestPath(path) {
   return path.split("\\").join("/").normalize("NFC");
 }
 function sha256Hex(bytes) {
-  return createHash2("sha256").update(bytes).digest("hex");
+  return createHash3("sha256").update(bytes).digest("hex");
 }
 function compareBytewiseUtf8(a, b) {
   const ba = Buffer.from(a, "utf8");
@@ -3354,11 +3418,14 @@ export {
   AgentTaskRunError,
   ApoSpanProcessor,
   FlowView,
+  JUDGE_SEGMENT_LIMIT,
+  RECEIVED_VALUE_LIMIT,
   RejudgeError,
   TEST_METHOD_NAMES,
   TaskFiles,
   buildManifest,
   canonicalManifestJson,
+  compactChecksForSubmission,
   contentSha256,
   createApoAnthropic,
   createApoOpenAI,