@apo-ai/sdk 0.2.0

package/dist/agent-task/public.js

@@ -0,0 +1,3026 @@
+// Auto-generated by `pnpm --filter @apo-ai/sdk build` (tsup.config.ts).
+// Do not edit by hand — edit the src/ originals and rebuild.
+import {
+  ApoSpanProcessor,
+  configureApoTelemetry,
+  getActiveApoRun,
+  registerApoTracing,
+  resetApoTracing,
+  withApoRun,
+  withApoRunSync
+} from "../chunk-PMYLL2H4.js";
+import {
+  createApoTracer
+} from "../chunk-HKLBPIB4.js";
+import "../chunk-HWZVL6TS.js";
+import {
+  createApoOpenAI
+} from "../chunk-DT2LMB7O.js";
+import {
+  createApoAnthropic
+} from "../chunk-SZDSIPXC.js";
+import "../chunk-GDB6SDGN.js";
+
+// src/agent-task/trace-projection/view.ts
+function invocationOrderKey(obs) {
+  const hasTs = obs.startedAt != null ? 0 : 1;
+  return [hasTs, obs.startedAt ?? "", obs.spanId];
+}
+var TraceView = class {
+  constructor(snapshot) {
+    this.snapshot = snapshot;
+  }
+  /** Evidence availability for a capability. */
+  requireCapability(capability) {
+    return this.snapshot.capabilities[capability];
+  }
+  /** Whether a capability is reported as available (not partial/unavailable). */
+  isAvailable(capability) {
+    return this.snapshot.capabilities[capability] === "available";
+  }
+  /** All chat messages flattened across generation observations, in order. */
+  get messages() {
+    const out = [];
+    for (const obs of this.sortedObservations) {
+      if (obs.messages) out.push(...obs.messages);
+    }
+    return out;
+  }
+  /** Tool calls derived from `TOOL` observations, in invocation order. */
+  get toolCalls() {
+    return this.sortedObservations.filter((o) => o.type === "TOOL").map((o) => ({
+      spanId: o.spanId,
+      name: o.toolName ?? o.name,
+      input: o.toolParameters ?? o.input,
+      output: o.toolResult ?? o.output,
+      status: o.status,
+      startedAt: o.startedAt
+    }));
+  }
+  /** Tool names in invocation order with deterministic span-ID tie-breaking. */
+  get toolNamesInOrder() {
+    return this.toolCalls.map((c) => c.name);
+  }
+  /** Skill loads derived from `SKILL` observations, in invocation order. */
+  get skillLoads() {
+    return this.sortedObservations.filter((o) => o.type === "SKILL").map((o) => ({ spanId: o.spanId, skill: o.name, startedAt: o.startedAt }));
+  }
+  /** Subagent delegations derived from `AGENT` observations, in invocation order. */
+  get subagentCalls() {
+    return this.sortedObservations.filter((o) => o.type === "AGENT").map((o) => ({
+      spanId: o.spanId,
+      agent: o.name,
+      output: o.output,
+      status: o.status,
+      startedAt: o.startedAt
+    }));
+  }
+  /** Last assistant message content — the agent's "reply". Empty if none. */
+  get reply() {
+    const msgs = this.messages;
+    for (let i = msgs.length - 1; i >= 0; i--) {
+      if (msgs[i].role === "assistant") return msgs[i].content;
+    }
+    return "";
+  }
+  /**
+   * Number of completed assistant turns, or `undefined` when message evidence
+   * is unavailable (capability honesty).
+   */
+  get turnCount() {
+    if (!this.isAvailable("messages")) return void 0;
+    return this.messages.filter((m) => m.role === "assistant").length;
+  }
+  /**
+   * Number of tool/subagent observations that reported an error, or `undefined`
+   * when error evidence is unavailable (capability honesty).
+   */
+  get failedActions() {
+    if (!this.isAvailable("errors")) return void 0;
+    return this.sortedObservations.filter(
+      (o) => (o.type === "TOOL" || o.type === "AGENT") && o.status === "error"
+    ).length;
+  }
+  /**
+   * Total execution duration in milliseconds, or `undefined` when timing
+   * evidence is unavailable (capability honesty). Uses trace-level
+   * startedAt/endedAt when present.
+   */
+  get durationMs() {
+    if (!this.isAvailable("timing")) return void 0;
+    const { startedAt, endedAt } = this.snapshot.trace;
+    if (startedAt != null && endedAt != null) {
+      const ms = Date.parse(endedAt) - Date.parse(startedAt);
+      return Number.isNaN(ms) ? void 0 : Math.max(0, ms);
+    }
+    return void 0;
+  }
+  /**
+   * Observations sorted deterministically by invocation time then span ID.
+   * Memoized per TraceView instance since the snapshot is immutable.
+   */
+  get sortedObservations() {
+    if (this._sorted !== void 0) return this._sorted;
+    const sorted = [...this.snapshot.observations].sort((a, b) => {
+      const ka = invocationOrderKey(a);
+      const kb = invocationOrderKey(b);
+      return ka[0] - kb[0] || ka[1].localeCompare(kb[1]) || ka[2].localeCompare(kb[2]);
+    });
+    this._sorted = sorted;
+    return sorted;
+  }
+};
+
+// src/agent-task/checks/matchers.ts
+function asString(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function describeValue(value) {
+  return asString(value);
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((v, i) => deepEqual(v, b[i]));
+  }
+  const ao = a;
+  const bo = b;
+  const ak = Object.keys(ao);
+  const bk = Object.keys(bo);
+  if (ak.length !== bk.length) return false;
+  return ak.every(
+    (k) => Object.prototype.hasOwnProperty.call(bo, k) && deepEqual(ao[k], bo[k])
+  );
+}
+function includes(needle) {
+  const re = typeof needle === "string" ? new RegExp(escapeRegExp(needle)) : needle;
+  return {
+    label: `includes ${needle instanceof RegExp ? needle.source : needle}`,
+    test: (v) => re.test(asString(v))
+  };
+}
+function equals(expected) {
+  return {
+    label: `equals ${asString(expected)}`,
+    test: (v) => deepEqual(v, expected)
+  };
+}
+function matches(schema) {
+  return {
+    label: "matches schema",
+    test: (v) => schema.safeParse(v).success === true
+  };
+}
+function satisfies(predicate, label) {
+  return { label, test: predicate };
+}
+function matchValue(actual, matcher) {
+  if (matcher instanceof RegExp) return matcher.test(asString(actual));
+  if (typeof matcher === "function") {
+    return matcher(actual);
+  }
+  if (matcher !== null && typeof matcher === "object") {
+    if (actual === null || typeof actual !== "object") return false;
+    const a = actual;
+    const m = matcher;
+    return Object.keys(m).every(
+      (k) => Object.prototype.hasOwnProperty.call(a, k) && matchValue(a[k], m[k])
+    );
+  }
+  return deepEqual(actual, matcher);
+}
+function similarity(expected, threshold = 0.8) {
+  return {
+    label: `similar to "${expected}" (\u2265 ${threshold})`,
+    test: (v) => normalizedSimilarity(asString(v), expected) >= threshold
+  };
+}
+function normalizedSimilarity(a, b) {
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen === 0) return 1;
+  return 1 - levenshtein(a, b) / maxLen;
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = Array.from({ length: n + 1 }, () => 0);
+  let curr = Array.from({ length: n + 1 }, () => 0);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}
+
+// 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"}';
+function formatValue(value, depth = 0) {
+  const indent = "  ".repeat(depth);
+  if (value === null || value === void 0) return String(value);
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => `${indent}${formatValue(item, depth + 1)}`).join("\n");
+  }
+  if (typeof value === "object") {
+    return Object.entries(value).map(([key, val]) => {
+      if (val && typeof val === "object") {
+        return `${indent}${key}:
+${formatValue(val, depth + 1)}`;
+      }
+      return `${indent}${key}: ${formatValue(val, depth + 1)}`;
+    }).join("\n");
+  }
+  return String(value);
+}
+function formatJudgeValues(values) {
+  if (values.length === 1) return formatValue(values[0]);
+  return values.map((v, i) => `--- Value ${i + 1} ---
+${formatValue(v)}`).join("\n\n");
+}
+function parseJudgeUsage(usage) {
+  if (!usage) return void 0;
+  const cacheCreation = usage.cache_creation_input_tokens ?? usage.prompt_tokens_details?.cache_write_tokens;
+  const cacheRead = usage.cache_read_input_tokens ?? usage.prompt_tokens_details?.cached_tokens;
+  const tokens = {
+    input: usage.prompt_tokens ?? 0,
+    output: usage.completion_tokens ?? 0
+  };
+  if (typeof cacheCreation === "number") tokens.cache_creation = cacheCreation;
+  if (typeof cacheRead === "number") tokens.cache_read = cacheRead;
+  return tokens;
+}
+function parseJudgeJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+  }
+  const fenced = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (fenced) {
+    try {
+      return JSON.parse(fenced[1].trim());
+    } catch {
+    }
+  }
+  const block = raw.match(/\{[\s\S]*\}/);
+  if (block) {
+    try {
+      return JSON.parse(block[0]);
+    } catch {
+    }
+  }
+  return {
+    pass: false,
+    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 prefixQueues = /* @__PURE__ */ new Map();
+function runWithSharedPrefix(key, task2) {
+  const prev = prefixQueues.get(key) ?? Promise.resolve();
+  const next = prev.then(task2, task2);
+  prefixQueues.set(
+    key,
+    next.then(
+      () => void 0,
+      () => void 0
+    )
+  );
+  return next;
+}
+async function callJudge(args) {
+  const baseURL = args.baseURL ?? process.env.OPENROUTER_BASE_URL ?? "https://openrouter.ai/api/v1";
+  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}
+
+${deliverableText}`;
+  const cacheKey = `${args.model}\0${deliverableText}`;
+  return runWithSharedPrefix(cacheKey, async () => {
+    const startedAt = Date.now();
+    const response = await fetch(`${baseURL}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+      },
+      body: JSON.stringify({
+        model: args.model,
+        messages: [
+          {
+            role: "system",
+            content: [
+              { type: "text", text: JUDGE_SYSTEM_PROMPT },
+              {
+                type: "text",
+                text: deliverableText,
+                cache_control: { type: "ephemeral" }
+              }
+            ]
+          },
+          { role: "user", content: instructionText }
+        ],
+        temperature: 0,
+        response_format: { type: "json_object" }
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`Judge API ${response.status}: ${body.slice(0, 200)}`);
+    }
+    const data = await response.json();
+    const text = data.choices?.[0]?.message?.content ?? "";
+    const outputTokens = data.usage?.completion_tokens;
+    const isEmpty = !text.trim();
+    const reportedZeroTokens = data.usage !== void 0 && outputTokens === 0;
+    if (isEmpty || reportedZeroTokens) {
+      return {
+        pass: false,
+        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,
+          prompt: { system: systemPromptText, user: instructionText },
+          response: text,
+          tokens: parseJudgeUsage(data.usage),
+          latency_ms: Date.now() - startedAt
+        }
+      };
+    }
+    const parsed = parseJudgeJson(text);
+    return {
+      pass: parsed.pass === true,
+      reasoning: typeof parsed.reasoning === "string" ? parsed.reasoning : "",
+      judge: {
+        model: args.model,
+        prompt: { system: systemPromptText, user: instructionText },
+        response: text,
+        tokens: parseJudgeUsage(data.usage),
+        latency_ms: Date.now() - startedAt
+      }
+    };
+  });
+}
+
+// src/agent-task/checks/t.ts
+function resolveJudgeConfig(judgeConfig, override) {
+  const model = override?.model ?? judgeConfig?.model;
+  if (!model) return void 0;
+  return {
+    model,
+    baseURL: override?.baseURL ?? judgeConfig?.baseURL,
+    apiKey: override?.apiKey ?? judgeConfig?.apiKey
+  };
+}
+var TEST_METHOD_NAMES = [
+  "calledTool",
+  "notCalledTool",
+  "toolOrder",
+  "usedNoTools",
+  "maxToolCalls",
+  "noFailedActions",
+  "loadedSkill",
+  "calledSubagent",
+  "messageIncludes",
+  "maxTurns",
+  "maxDurationMs",
+  "assert",
+  "check",
+  "judge"
+];
+function describeName(m) {
+  if (typeof m === "string") return `"${m}"`;
+  if (m instanceof RegExp) return m.source;
+  return "<predicate>";
+}
+function matchName(name, m) {
+  if (typeof m === "string") return name === m;
+  if (m instanceof RegExp) return m.test(name);
+  return m(name);
+}
+var CAPABILITY_LABELS = {
+  messages: "message",
+  tools: "tool",
+  errors: "error",
+  timing: "timing",
+  skills: "skill",
+  subagents: "subagent"
+};
+function createTraceTestContext(view, rec, judgeConfig) {
+  const unsupported = (id, capability) => {
+    const label = CAPABILITY_LABELS[capability];
+    rec.record(id, false, `${label} evidence is unavailable in this trace projection`, {
+      outcome: "unsupported",
+      expected: `${label} evidence available`,
+      received: view.requireCapability(capability)
+    });
+  };
+  const isAvailable = (c) => view.requireCapability(c) === "available";
+  return {
+    calledTool(name, opts) {
+      if (!isAvailable("tools")) {
+        unsupported(`calledTool(${describeName(name)})`, "tools");
+        return;
+      }
+      if (opts?.status !== void 0 && !isAvailable("errors")) {
+        unsupported(`calledTool(${describeName(name)}, { status })`, "errors");
+        return;
+      }
+      const count = view.toolCalls.filter(
+        (call) => matchesTraceToolCall(call, name, opts)
+      ).length;
+      const want = opts?.count;
+      const pass = want === void 0 ? count > 0 : count === want;
+      rec.record(
+        `calledTool(${describeName(name)})`,
+        pass,
+        pass ? "" : want === void 0 ? `expected at least one ${describeName(name)} call, got ${count}` : `expected exactly ${want} ${describeName(name)} calls, got ${count}`,
+        {
+          expected: want === void 0 ? `\u22651 ${describeName(name)} call` : `exactly ${want} ${describeName(name)} calls`,
+          received: `${count}`
+        }
+      );
+    },
+    notCalledTool(name, opts) {
+      if (!isAvailable("tools")) {
+        unsupported(`notCalledTool(${describeName(name)})`, "tools");
+        return;
+      }
+      const count = view.toolCalls.filter(
+        (call) => matchesTraceToolCall(call, name, opts)
+      ).length;
+      rec.record(
+        `notCalledTool(${describeName(name)})`,
+        count === 0,
+        count === 0 ? "" : `expected no ${describeName(name)} calls, got ${count}`,
+        { expected: `0 ${describeName(name)} calls`, received: `${count}` }
+      );
+    },
+    toolOrder(names) {
+      if (!isAvailable("tools")) {
+        unsupported(`toolOrder(${names.join(" \u2192 ")})`, "tools");
+        return;
+      }
+      const order = view.toolNamesInOrder;
+      let cursor = 0;
+      let missingIdx = -1;
+      for (let i = 0; i < names.length; i++) {
+        const found = order.indexOf(names[i], cursor);
+        if (found === -1) {
+          missingIdx = i;
+          break;
+        }
+        cursor = found + 1;
+      }
+      const ok = missingIdx === -1;
+      const expectedStr = names.join(" \u2192 ");
+      const actualStr = order.length > 0 ? order.join(" \u2192 ") : "(no tools)";
+      const message = ok ? "" : missingIdx === 0 ? `expected "${names[0]}" first; actual order ${actualStr}` : `expected "${names[missingIdx]}" after "${names[missingIdx - 1]}"; actual order ${actualStr}`;
+      rec.record(`toolOrder(${expectedStr})`, ok, message, {
+        expected: expectedStr,
+        received: actualStr
+      });
+    },
+    usedNoTools() {
+      if (!isAvailable("tools")) {
+        unsupported("usedNoTools", "tools");
+        return;
+      }
+      const count = view.toolCalls.length;
+      rec.record("usedNoTools", count === 0, count === 0 ? "" : `expected no tool calls, got ${count}`, {
+        expected: "0 tool calls",
+        received: `${count}`
+      });
+    },
+    maxToolCalls(n) {
+      if (!isAvailable("tools")) {
+        unsupported(`maxToolCalls(${n})`, "tools");
+        return;
+      }
+      const count = view.toolCalls.length;
+      rec.record(`maxToolCalls(${n})`, count <= n, count <= n ? "" : `expected \u2264 ${n} tool calls, got ${count}`, {
+        expected: `\u2264 ${n} tool calls`,
+        received: `${count}`
+      });
+    },
+    noFailedActions() {
+      if (!isAvailable("errors")) {
+        unsupported("noFailedActions", "errors");
+        return;
+      }
+      const failed = view.failedActions ?? 0;
+      rec.record("noFailedActions", failed === 0, failed === 0 ? "" : `${failed} failed action(s)`, {
+        expected: "0 failed actions",
+        received: `${failed}`
+      });
+    },
+    loadedSkill(skill) {
+      if (!isAvailable("skills")) {
+        unsupported(`loadedSkill("${skill}")`, "skills");
+        return;
+      }
+      const ok = view.skillLoads.some((s) => s.skill === skill);
+      rec.record(`loadedSkill("${skill}")`, ok, ok ? "" : `skill "${skill}" was not loaded`, {
+        expected: `skill "${skill}" loaded`,
+        received: view.skillLoads.map((s) => s.skill).join(", ") || "none"
+      });
+    },
+    calledSubagent(agent) {
+      if (!isAvailable("subagents")) {
+        unsupported(`calledSubagent("${agent}")`, "subagents");
+        return;
+      }
+      const ok = view.subagentCalls.some((s) => s.agent === agent);
+      rec.record(`calledSubagent("${agent}")`, ok, ok ? "" : `subagent "${agent}" was not called`, {
+        expected: `subagent "${agent}" called`,
+        received: view.subagentCalls.map((s) => s.agent).join(", ") || "none"
+      });
+    },
+    messageIncludes(token) {
+      if (!isAvailable("messages")) {
+        unsupported(`messageIncludes(${token instanceof RegExp ? token.source : token})`, "messages");
+        return;
+      }
+      const re = typeof token === "string" ? new RegExp(token) : token;
+      const ok = re.test(view.reply);
+      rec.record(`messageIncludes(${token instanceof RegExp ? token.source : token})`, ok, ok ? "" : `reply did not include ${token}`, {
+        expected: `reply includes ${token instanceof RegExp ? token.source : token}`,
+        received: describeValue(view.reply).slice(0, 200)
+      });
+    },
+    maxTurns(n) {
+      if (!isAvailable("messages")) {
+        unsupported(`maxTurns(${n})`, "messages");
+        return;
+      }
+      const turns = view.turnCount ?? 0;
+      rec.record(`maxTurns(${n})`, turns <= n, turns <= n ? "" : `expected \u2264 ${n} turns, got ${turns}`, {
+        expected: `\u2264 ${n} turns`,
+        received: `${turns}`
+      });
+    },
+    maxDurationMs(n) {
+      if (!isAvailable("timing")) {
+        unsupported(`maxDurationMs(${n})`, "timing");
+        return;
+      }
+      const ms = view.durationMs;
+      if (ms === void 0) {
+        unsupported(`maxDurationMs(${n})`, "timing");
+        return;
+      }
+      rec.record(`maxDurationMs(${n})`, ms <= n, ms <= n ? "" : `expected \u2264 ${n}ms, took ${ms}ms`, {
+        expected: `\u2264 ${n}ms`,
+        received: `${ms}ms`
+      });
+    },
+    assert(label, predicate) {
+      const pass = predicate(view);
+      rec.record(label, pass, pass ? "" : `assertion "${label}" failed`, {
+        expected: label,
+        received: pass ? "true" : "false"
+      });
+    },
+    check(value, matcher, label) {
+      const pass = matcher.test(value);
+      rec.record(
+        label ?? "check",
+        pass,
+        pass ? "" : `expected ${label ?? "value"} ${matcher.label}`,
+        { 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
+          }
+        );
+      }
+    }
+  };
+}
+function matchesTraceToolCall(call, name, opts) {
+  if (!matchName(call.name, name)) return false;
+  if (opts?.input !== void 0 && !matchValue(call.input, opts.input)) {
+    return false;
+  }
+  if (opts?.output !== void 0 && !matchValue(call.output, opts.output)) {
+    return false;
+  }
+  if (opts?.status !== void 0 && call.status !== opts.status) {
+    return false;
+  }
+  return true;
+}
+
+// src/agent-task/checks/recorder.ts
+var Recorder = class {
+  constructor(locate) {
+    this.records = [];
+    this.locate = locate;
+  }
+  /**
+   * Record an assertion.
+   *
+   * - ``extra.location`` overrides auto-capture (used by the runner for thrown
+   *   errors, whose relevant stack is the error's own, not the call site).
+   * - ``extra.expected`` / ``extra.received`` carry the structured values for
+   *   testing-framework-style display.
+   */
+  /**
+   * Capture the call site location synchronously. Use this when a record will
+   * happen AFTER an `await` (e.g. `t.judge`): once an async function resumes,
+   * `new Error().stack` reports the caller's frame at an unreliable line
+   * (often the statement's closing brace). Capturing here, before the await,
+   * pins the location to the actual call line; pass it to ``record`` via
+   * ``extra.location``.
+   */
+  captureLocation() {
+    return this.locate ? this.locate(new Error().stack ?? "") : void 0;
+  }
+  record(id, pass, reasoning, extra) {
+    const location = extra?.location ?? (this.locate ? this.locate(new Error().stack ?? "") : void 0);
+    this.records.push({
+      id,
+      pass,
+      reasoning,
+      location,
+      expected: extra?.expected,
+      received: extra?.received,
+      evaluator_type: extra?.evaluator_type,
+      judge: extra?.judge,
+      outcome: extra?.outcome
+    });
+  }
+  get all() {
+    return this.records;
+  }
+};
+
+// src/agent-task/checks/location.ts
+var FRAME_TAIL = /:(\d+):(\d+)\)?\s*$/;
+function parseCheckLocation(stack, moduleUrl, displayFile) {
+  if (!stack || !moduleUrl) return void 0;
+  const needle = moduleUrl.replace(/^file:\/\//, "");
+  for (const line of stack.split("\n")) {
+    if (!line.includes(moduleUrl) && !line.includes(needle)) continue;
+    const m = line.match(FRAME_TAIL);
+    if (m) {
+      return { file: displayFile, line: Number(m[1]), column: Number(m[2]) };
+    }
+  }
+  return void 0;
+}
+
+// src/agent-task/checks/flow-runner.ts
+import { copyFileSync, existsSync, unlinkSync } from "fs";
+import { basename } from "path";
+import { pathToFileURL } from "url";
+function filePaths(files) {
+  if (!Array.isArray(files)) return [];
+  return files.map((f) => f.relativePath);
+}
+var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("@apo-ai/sdk/agent-task/check-registry");
+var registryStore = globalThis;
+var registry = registryStore[REGISTRY_KEY] ??= [];
+var GROUP_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("@apo-ai/sdk/agent-task/group-registry");
+var groupRegistry = registryStore[GROUP_REGISTRY_KEY] ??= [];
+var currentGroupId = null;
+var currentGroupName = null;
+function defineCheck(id, fn) {
+  if (registry.some((c) => c.id === id)) {
+    throw new Error(`Duplicate check id '${id}'`);
+  }
+  registry.push({
+    id,
+    fn,
+    ...currentGroupId ? { group_id: currentGroupId } : {},
+    ...currentGroupName ? { group_name: currentGroupName } : {}
+  });
+}
+function resetFlowChecks() {
+  registry.length = 0;
+  groupRegistry.length = 0;
+  currentGroupId = null;
+  currentGroupName = null;
+}
+function describe(id, nameOrFn, fn) {
+  const name = typeof nameOrFn === "string" ? nameOrFn : id;
+  const body = typeof nameOrFn === "string" ? fn : nameOrFn;
+  if (currentGroupId !== null) {
+    throw new Error(
+      `describe("${id}") cannot nest inside describe("${currentGroupId}"); groups are single-level only.`
+    );
+  }
+  if (groupRegistry.some((g) => g.id === id)) {
+    throw new Error(`Duplicate describe id '${id}'`);
+  }
+  groupRegistry.push({ id, name });
+  currentGroupId = id;
+  currentGroupName = name;
+  try {
+    body();
+  } finally {
+    currentGroupId = null;
+    currentGroupName = null;
+  }
+}
+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 results = await Promise.all(
+    registry.map(async (check) => {
+      const rec = new Recorder(locate);
+      const t = createTraceTestContext(view, rec, args.judgeConfig);
+      let thrownLocation;
+      try {
+        await check.fn(t, {
+          deliverables: args.deliverables,
+          files: args.files,
+          task: args.task
+        });
+      } catch (error) {
+        thrownLocation = locate ? locate(error instanceof Error ? error.stack ?? "" : "") : void 0;
+        rec.record("check-error", false, error instanceof Error ? error.message : String(error), {
+          location: thrownLocation
+        });
+      }
+      const failed = rec.all.filter((r) => !r.pass);
+      const pass = failed.length === 0;
+      const reasoning = failed.length > 0 ? failed.map((r) => r.reasoning || r.id).join("; ") : rec.all.length > 0 ? "passed" : "no assertions recorded";
+      const location = failed.find((r) => r.location)?.location;
+      const judge = rec.all.find((r) => r.judge)?.judge;
+      return {
+        id: check.id,
+        pass,
+        reasoning,
+        evaluator_type: "code",
+        ...judge ? { judge } : {},
+        ...location ? { location } : {},
+        ...args.displayFile ? { source_file: args.displayFile } : {},
+        ...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").
+        ...args.snapshot.source !== "canonical" ? { source: args.snapshot.source } : {}
+      };
+    })
+  );
+  return results;
+}
+async function loadAndRunFlowChecks(checksPath, args, brokenDeliverables = {}) {
+  if (!checksPath) return [];
+  resetFlowChecks();
+  const moduleUrl = await loadChecksModule(checksPath);
+  if (moduleUrl === null || registry.length === 0) return [];
+  return runTraceChecks({
+    snapshot: args.snapshot,
+    deliverables: proxyBrokenDeliverables(args.deliverables, brokenDeliverables),
+    files: args.files,
+    task: args.task,
+    judgeConfig: args.judgeConfig,
+    moduleUrl,
+    displayFile: basename(checksPath)
+  });
+}
+async function loadChecksModule(checksPath) {
+  const tempModulePath = `${checksPath}.${Date.now()}-${Math.random().toString(36).slice(2)}.ts`;
+  try {
+    copyFileSync(checksPath, tempModulePath);
+    const moduleUrl = pathToFileURL(tempModulePath).href;
+    await import(moduleUrl);
+    if (registry.length === 0) return null;
+    return moduleUrl;
+  } finally {
+    if (existsSync(tempModulePath)) unlinkSync(tempModulePath);
+  }
+}
+function proxyBrokenDeliverables(deliverables, brokenDeliverables) {
+  if (Object.keys(brokenDeliverables).length === 0) return deliverables;
+  return new Proxy(deliverables, {
+    get(target, property, receiver) {
+      if (typeof property === "string" && property in brokenDeliverables) {
+        throw new Error(brokenDeliverables[property]);
+      }
+      return Reflect.get(target, property, receiver);
+    }
+  });
+}
+
+// src/agent-task/task/defineTask.ts
+var TASK_ADAPTER_SYMBOL = /* @__PURE__ */ Symbol.for("agent-task.adapter-definition");
+var TASK_REGISTRY_KEY = /* @__PURE__ */ Symbol.for("@apo-ai/sdk/agent-task/task-registry");
+var taskRegistryStore = globalThis;
+var taskRegistry = taskRegistryStore[TASK_REGISTRY_KEY] ??= [];
+function resetTaskRegistry() {
+  taskRegistry.length = 0;
+}
+function getRegisteredTask() {
+  return taskRegistry[0];
+}
+function defineTask(adapter, config) {
+  const definedTask = {
+    ...config,
+    adapter: adapter.name
+  };
+  attachAdapter(definedTask, adapter);
+  return definedTask;
+}
+function task(name, config) {
+  const adapter = config.adapter;
+  const {
+    adapter: _adapter,
+    deliverables,
+    ...rest
+  } = config;
+  const definedTask = {
+    ...rest,
+    id: name,
+    adapter: adapter.name,
+    deliverables: [...deliverables]
+  };
+  attachAdapter(definedTask, adapter);
+  taskRegistry.push(definedTask);
+  return {
+    test: defineCheck,
+    describe
+  };
+}
+function getTaskAdapterDefinition(task2) {
+  return task2[TASK_ADAPTER_SYMBOL] ?? null;
+}
+function attachAdapter(taskDefinition, adapter) {
+  Object.defineProperty(taskDefinition, TASK_ADAPTER_SYMBOL, {
+    value: adapter,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+}
+
+// src/agent-task/task/loadTask.ts
+import { copyFileSync as copyFileSync2, readdirSync, statSync, existsSync as existsSync2, unlinkSync as unlinkSync2 } from "fs";
+import { join, resolve, basename as basename2 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+
+// src/agent-task/turn.ts
+var TURN_KEY = /* @__PURE__ */ Symbol.for("@apo-ai/sdk/agent-task/task-turn");
+function turn(fn) {
+  globalThis[TURN_KEY] = fn;
+}
+function getTaskTurn() {
+  return globalThis[TURN_KEY];
+}
+function resetTaskTurn() {
+  delete globalThis[TURN_KEY];
+}
+function resolveTurn(adapterTurn, taskTurn) {
+  const resolved = taskTurn ?? adapterTurn;
+  if (!resolved) {
+    throw new Error(
+      "No turn behavior defined. Add a turn() call to your task file or a turn field to your adapter."
+    );
+  }
+  return resolved;
+}
+
+// src/agent-task/task/loadTask.ts
+async function loadTask(taskDir) {
+  const absoluteDir = resolve(taskDir);
+  const taskFilePath = findEvalFile(absoluteDir);
+  if (!taskFilePath) {
+    throw new Error(`No .eval.ts file found in: ${absoluteDir}`);
+  }
+  const { task: task2, adapter, inlineChecks, moduleUrl } = await loadTaskDefinition(taskFilePath);
+  validateTaskDefinition(task2, absoluteDir);
+  const files = loadFilesDirectory(absoluteDir);
+  const checksPath = resolveChecksPath(task2, absoluteDir);
+  return {
+    task: task2,
+    adapter,
+    taskDir: absoluteDir,
+    files,
+    checksPath,
+    inlineChecks,
+    moduleUrl,
+    evalFileName: basename2(taskFilePath)
+  };
+}
+async function loadTaskDefinition(taskFilePath) {
+  const tempModulePath = `${taskFilePath}.${Date.now()}-${Math.random().toString(36).slice(2)}.ts`;
+  try {
+    copyFileSync2(taskFilePath, tempModulePath);
+    const moduleUrl = pathToFileURL2(tempModulePath).href;
+    resetTaskRegistry();
+    resetFlowChecks();
+    resetTaskTurn();
+    const loaded = await import(moduleUrl);
+    const registeredTask = getRegisteredTask();
+    const task2 = registeredTask ?? loaded.default;
+    if (!task2 || typeof task2 !== "object") {
+      throw new Error(
+        "No task definition found \u2014 call task(name, config) or default export defineTask(adapter, config)"
+      );
+    }
+    const adapter = getTaskAdapterDefinition(task2);
+    if (!adapter) {
+      throw new Error(
+        registeredTask ? "task() config must include an adapter" : "Task module must default export defineTask(adapter, {...})"
+      );
+    }
+    return {
+      task: task2,
+      adapter,
+      inlineChecks: registeredTask !== void 0,
+      moduleUrl
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to load task definition: ${taskFilePath} (${message})`);
+  } finally {
+    if (existsSync2(tempModulePath)) {
+      unlinkSync2(tempModulePath);
+    }
+  }
+}
+function validateTaskDefinition(task2, taskDir) {
+  if (!task2.id || typeof task2.id !== "string") {
+    throw new Error(`Task must have a string 'id': ${taskDir}`);
+  }
+  if (!task2.adapter || typeof task2.adapter !== "string") {
+    throw new Error(`Task must have a derived string 'adapter': ${taskDir}`);
+  }
+  if (!Array.isArray(task2.deliverables)) {
+    throw new Error(`Task must have a 'deliverables' array: ${taskDir}`);
+  }
+}
+function loadFilesDirectory(taskDir) {
+  const filesDir = join(taskDir, "files");
+  if (!existsSync2(filesDir) || !statSync(filesDir).isDirectory()) {
+    return [];
+  }
+  return walkDirectory(filesDir, filesDir);
+}
+function walkDirectory(dir, root) {
+  const entries = [];
+  for (const name of readdirSync(dir)) {
+    const fullPath = join(dir, name);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      entries.push(...walkDirectory(fullPath, root));
+    } else {
+      entries.push({
+        relativePath: fullPath.slice(root.length + 1),
+        absolutePath: fullPath
+      });
+    }
+  }
+  return entries;
+}
+function resolveChecksPath(task2, taskDir) {
+  if (task2.checks === false) {
+    return null;
+  }
+  if (typeof task2.checks === "string") {
+    const customPath = resolve(taskDir, task2.checks);
+    if (!existsSync2(customPath)) {
+      throw new Error(`Custom checks file not found: ${customPath}`);
+    }
+    return customPath;
+  }
+  const conventionPath = join(taskDir, "checks.ts");
+  return existsSync2(conventionPath) ? conventionPath : null;
+}
+function findEvalFile(dir) {
+  try {
+    const files = readdirSync(dir);
+    const evalFile = files.find((f) => f.endsWith(".eval.ts"));
+    return evalFile ? join(dir, evalFile) : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/agent-task/task/TaskFiles.ts
+import { readFile } from "fs/promises";
+var TaskFiles = class {
+  constructor(entries) {
+    this.entries = entries;
+  }
+  async read(relativePath) {
+    const entry = this.find(relativePath);
+    if (!entry) {
+      throw new Error(`File not found: ${relativePath}`);
+    }
+    return readFile(entry.absolutePath, "utf-8");
+  }
+  async readBuffer(relativePath) {
+    const entry = this.find(relativePath);
+    if (!entry) {
+      throw new Error(`File not found: ${relativePath}`);
+    }
+    return readFile(entry.absolutePath);
+  }
+  find(relativePath) {
+    return this.entries.find((entry) => entry.relativePath === relativePath);
+  }
+  list() {
+    return [...this.entries];
+  }
+  has(relativePath) {
+    return this.entries.some((entry) => entry.relativePath === relativePath);
+  }
+};
+
+// src/agent-task/adapter/defineAdapter.ts
+function defineAdapter(adapter) {
+  return adapter;
+}
+
+// src/agent-task/deliverables/artifact.ts
+import { basename as basename3 } from "path";
+import { lstatSync, statSync as statSync2 } from "fs";
+var DEFAULT_MEDIA_TYPE = "application/octet-stream";
+function fileArtifact(path, options = {}) {
+  if (!path) {
+    throw new Error("fileArtifact: path must not be empty");
+  }
+  let stat;
+  try {
+    const lstat = lstatSync(path);
+    if (lstat.isSymbolicLink()) {
+      throw new Error(`fileArtifact: '${path}' is a symbolic link, not a regular file`);
+    }
+    stat = statSync2(path);
+  } catch (error) {
+    if (!existsLike(error)) throw error;
+    throw new Error(`fileArtifact: '${path}' is not a regular file`);
+  }
+  if (!stat.isFile()) {
+    throw new Error(`fileArtifact: '${path}' is not a regular file`);
+  }
+  const displayFilename = options.displayFilename ?? basename3(path);
+  if (!displayFilename) {
+    throw new Error("fileArtifact: displayFilename must not be empty");
+  }
+  return Object.freeze({
+    kind: "apo.file-artifact",
+    path,
+    mediaType: options.mediaType ?? DEFAULT_MEDIA_TYPE,
+    displayFilename
+  });
+}
+function isFileArtifact(value) {
+  return typeof value === "object" && value !== null && value.kind === "apo.file-artifact" && typeof value.path === "string";
+}
+function existsLike(error) {
+  if (!(error instanceof Error)) return false;
+  const code = error.code;
+  return code === "ENOENT";
+}
+
+// src/agent-task/deliverables/upload.ts
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+import { basename as basename4 } from "path";
+import { Readable } from "stream";
+var DEFAULT_FETCH = typeof fetch === "function" ? fetch : void 0;
+async function persistFileArtifacts(deliverables, config) {
+  const jsonDeliverables = {};
+  const artifactUploads = [];
+  for (const [name, value] of Object.entries(deliverables)) {
+    if (isFileArtifact(value)) {
+      const summary = await uploadOne(name, value, config);
+      artifactUploads.push(summary);
+    } else {
+      jsonDeliverables[name] = value;
+    }
+  }
+  return { jsonDeliverables, artifactUploads };
+}
+async function uploadOne(name, artifact, config) {
+  const { size, sha256 } = await hashFile(artifact.path);
+  const intent = await createIntent(name, artifact, size, sha256, config);
+  const body = Readable.toWeb(createReadStream(artifact.path));
+  const summary = await putBytes(intent.upload_url, body, size, config);
+  void basename4;
+  return summary;
+}
+async function hashFile(path) {
+  return new Promise((resolve4, reject) => {
+    const hash = createHash("sha256");
+    let size = 0;
+    const stream = createReadStream(path);
+    stream.on("data", (chunk) => {
+      hash.update(chunk);
+      size += chunk.length;
+    });
+    stream.on("error", reject);
+    stream.on("end", () => resolve4({ size, sha256: hash.digest("hex") }));
+  });
+}
+async function createIntent(name, artifact, sizeBytes, sha256, config) {
+  const url = `${config.baseUrl}/v1/agent-task-runs/${config.taskRunId}/artifact-uploads`;
+  const response = await doFetch(config, url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${config.authToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      name,
+      display_filename: artifact.displayFilename,
+      media_type: artifact.mediaType,
+      size_bytes: sizeBytes,
+      sha256
+    })
+  });
+  if (response.status === 201) {
+    const body = await response.json();
+    return body;
+  }
+  const detail = await safeDetail(response);
+  throw new Error(
+    `artifact upload intent for '${name}' failed (${response.status}): ${detail}`
+  );
+}
+async function putBytes(uploadUrl, body, sizeBytes, config) {
+  const url = uploadUrl.startsWith("http") ? uploadUrl : `${config.baseUrl}${uploadUrl}`;
+  const response = await doFetch(config, url, {
+    method: "PUT",
+    headers: {
+      Authorization: `Bearer ${config.authToken}`,
+      "Content-Type": "application/octet-stream",
+      "Content-Length": String(sizeBytes)
+    },
+    body,
+    duplex: "half"
+  });
+  if (response.status === 200) {
+    return await response.json();
+  }
+  const detail = await safeDetail(response);
+  throw new Error(
+    `artifact upload of ${sizeBytes} bytes failed (${response.status}): ${detail}`
+  );
+}
+async function doFetch(config, input, init) {
+  const fetchImpl = config.fetch ?? DEFAULT_FETCH;
+  if (!fetchImpl) {
+    throw new Error("persistFileArtifacts: fetch is not available in this environment");
+  }
+  return fetchImpl(input, init);
+}
+async function safeDetail(response) {
+  try {
+    const text = await response.text();
+    return text.slice(0, 500);
+  } catch {
+    return "<no body>";
+  }
+}
+
+// src/agent-task/flow/view.ts
+var FlowView = class {
+  constructor(flow) {
+    this.events = flow.events;
+    this.startedAt = flow.startedAt;
+    this.endedAt = flow.endedAt;
+  }
+  get messages() {
+    return this.events.filter((e) => e.kind === "message");
+  }
+  get toolCalls() {
+    return this.events.filter((e) => e.kind === "tool_call");
+  }
+  get skillLoads() {
+    return this.events.filter((e) => e.kind === "skill_load");
+  }
+  get subagentCalls() {
+    return this.events.filter(
+      (e) => e.kind === "subagent_call"
+    );
+  }
+  get toolNamesInOrder() {
+    return this.toolCalls.map((c) => c.name);
+  }
+  /** Last assistant message text — the agent's "reply". */
+  get reply() {
+    for (let i = this.messages.length - 1; i >= 0; i--) {
+      if (this.messages[i].role === "assistant") return this.messages[i].text;
+    }
+    return "";
+  }
+  /** Number of completed assistant turns. */
+  get turnCount() {
+    return this.messages.filter((m) => m.role === "assistant").length;
+  }
+  /** Tool or subagent calls that reported an error. */
+  get failedActions() {
+    return this.events.filter(
+      (e) => (e.kind === "tool_call" || e.kind === "subagent_call") && e.status === "error"
+    ).length;
+  }
+  get durationMs() {
+    if (this.startedAt != null && this.endedAt != null) {
+      return Math.max(0, this.endedAt - this.startedAt);
+    }
+    return this.events.reduce((sum, e) => {
+      if ("latencyMs" in e && typeof e.latencyMs === "number") {
+        return sum + e.latencyMs;
+      }
+      return sum;
+    }, 0);
+  }
+};
+
+// src/agent-task/flow/sources.ts
+function safeParse(raw) {
+  if (typeof raw !== "string") return raw;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function fromOpenAIMessages(messages) {
+  const events = [];
+  const results = /* @__PURE__ */ new Map();
+  for (const m of messages) {
+    if (m.role === "tool" && m.tool_call_id) {
+      results.set(m.tool_call_id, m.content);
+    }
+  }
+  for (const m of messages) {
+    if (m.role === "user") {
+      events.push({ kind: "message", role: "user", text: m.content ?? "" });
+    } else if (m.role === "assistant") {
+      events.push({ kind: "message", role: "assistant", text: m.content ?? "" });
+      for (const tc of m.tool_calls ?? []) {
+        events.push({
+          kind: "tool_call",
+          name: tc.function?.name ?? "unknown",
+          input: safeParse(tc.function?.arguments),
+          output: tc.id ? results.get(tc.id) : void 0
+        });
+      }
+    }
+  }
+  return { events };
+}
+function fromAnthropicMessages(messages) {
+  const events = [];
+  const results = /* @__PURE__ */ new Map();
+  for (const m of messages) {
+    for (const block of m.content ?? []) {
+      if (block.type === "tool_result") {
+        results.set(block.tool_use_id, block.content);
+      }
+    }
+  }
+  for (const m of messages) {
+    const role = m.role === "user" ? "user" : "assistant";
+    for (const block of m.content ?? []) {
+      if (block.type === "text") {
+        events.push({ kind: "message", role, text: block.text });
+      } else if (block.type === "tool_use") {
+        events.push({
+          kind: "tool_call",
+          name: block.name,
+          input: block.input,
+          output: results.get(block.id)
+        });
+      }
+    }
+  }
+  return { events };
+}
+function fromAISDK(result) {
+  const events = [];
+  for (const step of result.steps ?? []) {
+    if (step.text) {
+      events.push({ kind: "message", role: "assistant", text: step.text });
+    }
+    const outputs = step.toolResults ?? [];
+    const toolCalls = step.toolCalls ?? [];
+    toolCalls.forEach((tc, i) => {
+      events.push({
+        kind: "tool_call",
+        name: tc.toolName,
+        input: tc.input,
+        output: outputs[i]?.output
+      });
+    });
+  }
+  return { events };
+}
+
+// src/agent-task/run/run-configuration.ts
+function normalizeRunConfiguration(raw) {
+  if (!raw) return void 0;
+  const model = normalizeScalar(raw.model, "run_configuration.model", MAX_MODEL_BYTES, true);
+  const effort = normalizeScalar(
+    raw.effort,
+    "run_configuration.effort",
+    MAX_EFFORT_BYTES,
+    false
+  );
+  return effort === void 0 ? { model } : { model, effort };
+}
+var MAX_MODEL_BYTES = 255;
+var MAX_EFFORT_BYTES = 64;
+var CONTROL_CHARS = /[\x00-\x1f\x7f]/;
+var utf8Encoder = new TextEncoder();
+function utf8ByteLength(value) {
+  return utf8Encoder.encode(value).length;
+}
+function normalizeScalar(value, field, maxBytes, required) {
+  if (value === void 0) {
+    if (required) throw new Error(`${field} is required`);
+    return void 0;
+  }
+  if (CONTROL_CHARS.test(value)) {
+    throw new Error(`${field} must not contain control characters`);
+  }
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    if (required) throw new Error(`${field} is required and must be non-empty`);
+    return void 0;
+  }
+  if (utf8ByteLength(trimmed) > maxBytes) {
+    throw new Error(`${field} must be at most ${maxBytes} UTF-8 bytes`);
+  }
+  return trimmed;
+}
+
+// src/agent-task/deliverables/validate.ts
+function isZodSchema(value) {
+  return typeof value === "object" && value !== null && "safeParse" in value && typeof value.safeParse === "function";
+}
+function validateDeliverables(task2, collected, deliverableDefs) {
+  const results = [];
+  const brokenDeliverables = {};
+  for (const deliverableName of task2.deliverables) {
+    const value = collected[deliverableName];
+    if (value === void 0 || value === null) {
+      const reason = `Deliverable '${deliverableName}' is missing`;
+      results.push({
+        id: `deliverable:${deliverableName}`,
+        pass: false,
+        reasoning: reason
+      });
+      brokenDeliverables[deliverableName] = reason;
+      continue;
+    }
+    const schema = resolveDeliverableSchema(
+      deliverableDefs?.[deliverableName]
+    );
+    if (schema && isZodSchema(schema)) {
+      const result = schema.safeParse(value);
+      if (!result.success) {
+        const reason = `Deliverable '${deliverableName}' failed schema validation: ${result.error?.message ?? "Unknown error"}`;
+        results.push({
+          id: `deliverable:${deliverableName}`,
+          pass: false,
+          reasoning: reason
+        });
+        brokenDeliverables[deliverableName] = reason;
+      }
+    }
+  }
+  return { results, brokenDeliverables };
+}
+function resolveDeliverableSchema(definition) {
+  if (!definition) {
+    return void 0;
+  }
+  if (isZodSchema(definition)) {
+    return definition;
+  }
+  if (typeof definition === "object" && definition !== null && "schema" in definition && isZodSchema(definition.schema)) {
+    return definition.schema;
+  }
+  return void 0;
+}
+
+// src/agent-task/trace-projection/projection-tee.ts
+function monotonicNowMs() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+function round3(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+function observationTypeFor(t) {
+  switch (t) {
+    case "GENERATION":
+      return "GENERATION";
+    case "TOOL":
+      return "TOOL";
+    case "AGENT":
+      return "AGENT";
+    case "CHAIN":
+      return "CHAIN";
+    case "RETRIEVER":
+      return "RETRIEVER";
+    case "EMBEDDING":
+      return "EMBEDDING";
+    case "GUARDRAIL":
+      return "GUARDRAIL";
+    default:
+      return "SPAN";
+  }
+}
+function extractText(output) {
+  if (typeof output === "string") return output;
+  if (output != null && typeof output === "object" && "text" in output) {
+    const text = output.text;
+    if (typeof text === "string") return text;
+  }
+  return "";
+}
+function deriveCapabilities(observations) {
+  const hasType = (t) => observations.some((o) => o.type === t);
+  const hasMessages = observations.some(
+    (o) => o.type === "GENERATION" && o.messages && o.messages.length > 0
+  );
+  return {
+    messages: hasMessages ? "available" : "unavailable",
+    tools: hasType("TOOL") ? "available" : "unavailable",
+    // Local capture records every span's status, so error evidence is always
+    // available — the absence of error observations IS proof of no errors.
+    errors: "available",
+    timing: "available",
+    skills: hasType("SKILL") ? "available" : "unavailable",
+    subagents: hasType("AGENT") ? "available" : "unavailable"
+  };
+}
+function createProjectionTee(real) {
+  const observations = [];
+  const pending = /* @__PURE__ */ new Map();
+  const realIdByTeeId = /* @__PURE__ */ new Map();
+  let spanCounter = 0;
+  const rootStartMs = monotonicNowMs();
+  const rootStartIso = new Date(rootStartMs).toISOString();
+  function complete(spanId, params) {
+    const p = pending.get(spanId);
+    if (!p) return;
+    pending.delete(spanId);
+    const endedAtMs = monotonicNowMs();
+    const isError = params?.level === "ERROR";
+    const status = isError ? "error" : "ok";
+    const obs = {
+      spanId: p.spanId,
+      type: p.type,
+      name: p.name,
+      startedAt: p.startedAtIso,
+      endedAt: new Date(endedAtMs).toISOString(),
+      durationMs: round3(endedAtMs - p.startedAtMs),
+      status
+    };
+    if (p.parentSpanId) obs.parentSpanId = p.parentSpanId;
+    if (p.model) obs.model = p.model;
+    if (isError && params?.status_message) obs.errorMessage = params.status_message;
+    const meta = params?.metadata;
+    if (p.type === "TOOL") {
+      obs.toolName = meta?.tool_name ?? p.name;
+      if (meta?.tool_parameters !== void 0) obs.toolParameters = meta.tool_parameters;
+      else if (p.input !== void 0) obs.toolParameters = p.input;
+      if (meta?.tool_result !== void 0) obs.toolResult = meta.tool_result;
+      else if (params?.output !== void 0) obs.output = params.output;
+    } else if (params?.output !== void 0) {
+      obs.output = params.output;
+    }
+    if (p.type === "GENERATION" && params?.output != null) {
+      const text = extractText(params.output);
+      if (text !== "") {
+        obs.messages = [{ role: "assistant", content: text }];
+      }
+    }
+    observations.push(obs);
+  }
+  function recordStart(opts) {
+    spanCounter += 1;
+    const spanId = `${real.rootSpanId}-${String(spanCounter).padStart(6, "0")}`;
+    pending.set(spanId, {
+      spanId,
+      parentSpanId: opts.parent_call_id ?? real.rootSpanId,
+      type: observationTypeFor(opts.observation_type),
+      name: opts.step_name ?? "step",
+      startedAtIso: new Date(monotonicNowMs()).toISOString(),
+      startedAtMs: monotonicNowMs(),
+      model: opts.model ?? void 0,
+      input: opts.input
+    });
+    return spanId;
+  }
+  const trace2 = {
+    runId: real.runId,
+    rootSpanId: real.rootSpanId,
+    async step(opts, fn) {
+      const obsSpanId = recordStart(opts);
+      const start = monotonicNowMs();
+      try {
+        const result = await real.step(opts, fn);
+        complete(obsSpanId, {
+          latency_ms: round3(monotonicNowMs() - start),
+          output: opts.summarize?.(result),
+          metadata: opts.metadata
+        });
+        return result;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        complete(obsSpanId, {
+          latency_ms: round3(monotonicNowMs() - start),
+          status_message: message,
+          level: "ERROR",
+          metadata: { ...opts.metadata, failed: true }
+        });
+        throw error;
+      }
+    },
+    recordEvent(evOptions) {
+      const spanId = recordStart(evOptions);
+      complete(spanId, {
+        latency_ms: evOptions.latency_ms,
+        output: evOptions.output,
+        metadata: evOptions.metadata
+      });
+      try {
+        real.recordEvent(evOptions);
+      } catch {
+      }
+      return spanId;
+    },
+    endRoot(endParams) {
+      try {
+        real.endRoot(endParams);
+      } catch {
+      }
+    },
+    createSpan(spanOptions) {
+      const spanId = recordStart(spanOptions);
+      const isFromOtelProcessor = spanOptions.metadata?.source === "otel-processor";
+      if (!isFromOtelProcessor) {
+        try {
+          const realId = real.createSpan(spanOptions);
+          realIdByTeeId.set(spanId, realId);
+        } catch {
+        }
+      }
+      return spanId;
+    },
+    endSpan(spanId, endParams) {
+      complete(spanId, endParams);
+      const realId = realIdByTeeId.get(spanId) ?? spanId;
+      realIdByTeeId.delete(spanId);
+      try {
+        real.endSpan(realId, endParams);
+      } catch {
+      }
+    },
+    async traceTool(name, params, fn) {
+      return real.traceTool(name, params, fn);
+    },
+    async traceRetriever(query, fn) {
+      return real.traceRetriever(query, fn);
+    },
+    async traceChain(name, fn) {
+      return real.traceChain(name, fn);
+    },
+    async traceAgent(name, fn) {
+      return real.traceAgent(name, fn);
+    },
+    async traceGuardrail(name, fn) {
+      return real.traceGuardrail(name, fn);
+    },
+    async traceEmbedding(model, input, fn) {
+      return real.traceEmbedding(model, input, fn);
+    },
+    async score(params) {
+      return real.score(params);
+    }
+  };
+  return {
+    trace: trace2,
+    getSnapshot() {
+      const endMs = monotonicNowMs();
+      return {
+        schemaVersion: 1,
+        projectionVersion: 1,
+        source: "local",
+        trace: {
+          traceId: real.runId,
+          startedAt: rootStartIso,
+          endedAt: new Date(endMs).toISOString(),
+          durationMs: round3(endMs - rootStartMs),
+          complete: true
+        },
+        capabilities: deriveCapabilities(observations),
+        observations: [...observations]
+      };
+    }
+  };
+}
+
+// src/agent-task/trace-projection/remote-capture.ts
+var ProjectionTimeoutError = class extends Error {
+  constructor(taskRunId, deadlineMs) {
+    super(
+      `Trace projection for task run ${taskRunId} was not ready within ${deadlineMs}ms`
+    );
+    this.name = "ProjectionTimeoutError";
+  }
+};
+async function readTaskRunProjection(options) {
+  const deadlineMs = options.deadlineMs ?? 3e4;
+  const initialIntervalMs = options.initialIntervalMs ?? 500;
+  const maxIntervalMs = options.maxIntervalMs ?? 5e3;
+  const url = `${options.endpoint.replace(/\/$/, "")}/v1/agent-task-runs/${encodeURIComponent(options.taskRunId)}/trace-projection`;
+  const start = Date.now();
+  let interval = initialIntervalMs;
+  while (true) {
+    if (Date.now() - start > deadlineMs) {
+      throw new ProjectionTimeoutError(options.taskRunId, deadlineMs);
+    }
+    const response = await fetch(url, {
+      headers: { Authorization: `Bearer ${options.authToken}` }
+    });
+    if (response.status === 200) {
+      return await response.json();
+    }
+    if (response.status === 202) {
+      await sleep(interval);
+      interval = Math.min(interval * 1.5, maxIntervalMs);
+      continue;
+    }
+    const detail = await response.json().catch(() => ({ detail: response.statusText }));
+    throw new Error(
+      `Projection read failed (${response.status}): ${detail.detail ?? response.statusText}`
+    );
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+
+// src/semconv.ts
+var APO_TASK_ID = "apo.task.id";
+var APO_TASK_RUN_ID = "apo.task.run.id";
+
+// src/agent-task/run/aggregate.ts
+var NO_CHECKS_REGISTERED_MESSAGE = "No tests were registered by the eval module \u2014 a task must define at least one test().";
+function aggregateResult(checksResults) {
+  if (checksResults.length === 0) {
+    return { checks: checksResults, pass: false };
+  }
+  const pass = checksResults.every((r) => r.pass);
+  return { checks: checksResults, pass };
+}
+
+// src/agent-task/tracing.ts
+function createNoopAgentTaskTraceContext() {
+  const noopFn = async (fn) => fn();
+  return {
+    runId: "agent-task-untraced",
+    rootSpanId: "agent-task-untraced-root",
+    async step(options, fn) {
+      return fn(options.id ?? "agent-task-untraced-step");
+    },
+    recordEvent(options) {
+      return options.id ?? "agent-task-untraced-event";
+    },
+    endRoot() {
+    },
+    traceTool(_name, _params, fn) {
+      return noopFn(fn);
+    },
+    traceRetriever(_query, fn) {
+      return noopFn(fn);
+    },
+    traceChain(_name, fn) {
+      return noopFn(fn);
+    },
+    traceAgent(_name, fn) {
+      return noopFn(fn);
+    },
+    traceGuardrail(_name, fn) {
+      return noopFn(fn);
+    },
+    traceEmbedding(_model, _input, fn) {
+      return noopFn(fn);
+    },
+    async score(_params) {
+    },
+    createSpan(_options) {
+      return "agent-task-untraced-span";
+    },
+    endSpan(_spanId, _params) {
+    }
+  };
+}
+
+// src/agent-task/run/runTask.ts
+var AgentTaskRunError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "AgentTaskRunError";
+    this.runConfiguration = options.runConfiguration;
+    this.cause = options.cause;
+  }
+};
+function withRunConfiguration(error, runConfiguration) {
+  if (!runConfiguration) return error;
+  if (error instanceof AgentTaskRunError) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  return new AgentTaskRunError(message, { runConfiguration, cause: error });
+}
+async function runTask(taskDir, options) {
+  const loaded = options?.loaded ?? await loadTask(taskDir);
+  const trace2 = options?.tracing;
+  if (!trace2) {
+    return executeLoadedTask(
+      loaded,
+      options,
+      createNoopAgentTaskTraceContext(),
+      void 0
+    );
+  }
+  const phase1 = await trace2.client.traceRun(
+    buildTraceRunOptions(loaded, trace2),
+    async (traceContext) => captureExecution(loaded, options, traceContext)
+  );
+  const canonical = await readCanonicalSnapshot(trace2);
+  if (canonical) phase1.snapshot = canonical;
+  return evaluate(loaded, options, phase1);
+}
+async function readCanonicalSnapshot(trace2) {
+  if (!trace2.taskRunId) return null;
+  const endpoint = process.env.AGENT_TASK_TRACE_ENDPOINT;
+  const authToken = process.env.APO_AUTH_TOKEN;
+  if (!endpoint || !authToken) return null;
+  try {
+    return await readTaskRunProjection({
+      endpoint,
+      authToken,
+      taskRunId: trace2.taskRunId
+    });
+  } catch (error) {
+    console.error(
+      "[AgentTask] Backend projection read failed, using local snapshot:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return null;
+  }
+}
+async function executeLoadedTask(loaded, options, rawTrace, traceRunId) {
+  const {
+    task: task2,
+    adapter,
+    taskDir: absoluteDir,
+    files,
+    checksPath,
+    inlineChecks,
+    moduleUrl,
+    evalFileName
+  } = loaded;
+  const taskFiles = new TaskFiles(files);
+  const tee = createProjectionTee(rawTrace);
+  const { trace: trace2, getSnapshot } = { trace: tee.trace, getSnapshot: () => tee.getSnapshot() };
+  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);
+      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(
+          {
+            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,
+              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)
+          },
+          async () => {
+            if (!inlineChecks) {
+              return loadAndRunFlowChecks(
+                checksPath,
+                {
+                  snapshot: getSnapshot(),
+                  deliverables: collected,
+                  files,
+                  task: task2,
+                  judgeConfig: options?.judge
+                },
+                validationResults.brokenDeliverables
+              );
+            }
+            return runTraceChecks({
+              snapshot: getSnapshot(),
+              deliverables: proxyBrokenDeliverables(
+                collected,
+                validationResults.brokenDeliverables
+              ),
+              files,
+              task: task2,
+              judgeConfig: options?.judge,
+              moduleUrl,
+              displayFile: evalFileName
+            });
+          }
+        );
+        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(
+            {
+              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 {
+        }
+      }
+    }
+  }
+}
+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 })
+        );
+        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 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 };
+            } },
+            async () => {
+              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,
+            collected,
+            transcriptTurns,
+            runConfiguration,
+            snapshot
+          };
+        } 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 {
+          }
+        }
+      }
+    }
+  );
+}
+async function evaluate(loaded, options, phase1) {
+  const {
+    task: task2,
+    adapter,
+    taskDir: absoluteDir,
+    files,
+    checksPath,
+    inlineChecks,
+    moduleUrl,
+    evalFileName
+  } = loaded;
+  const validationResults = validateDeliverables(task2, phase1.collected, adapter.deliverables);
+  const deliverables = proxyBrokenDeliverables(
+    phase1.collected,
+    validationResults.brokenDeliverables
+  );
+  const checksResults = await (inlineChecks ? runTraceChecks({
+    snapshot: phase1.snapshot,
+    deliverables,
+    files,
+    task: task2,
+    judgeConfig: options?.judge,
+    moduleUrl,
+    displayFile: evalFileName
+  }) : loadAndRunFlowChecks(
+    checksPath,
+    {
+      snapshot: phase1.snapshot,
+      deliverables,
+      files,
+      task: task2,
+      judgeConfig: options?.judge
+    },
+    validationResults.brokenDeliverables
+  ));
+  const result = aggregateResult(checksResults);
+  return {
+    task: task2,
+    taskDir: absoluteDir,
+    files,
+    traceRunId: phase1.traceRunId,
+    result,
+    deliverables: phase1.collected,
+    transcript: { turns: phase1.transcriptTurns },
+    runConfiguration: phase1.runConfiguration
+  };
+}
+function summarizeEvaluationResults(results) {
+  const passCount = results.filter((r) => r.pass).length;
+  return {
+    total: results.length,
+    passCount,
+    failCount: results.length - passCount,
+    results: results.map((r) => ({
+      id: r.id,
+      pass: r.pass,
+      reasoning: r.reasoning,
+      evaluator_type: r.evaluator_type,
+      judge_model: r.judge?.model
+    }))
+  };
+}
+function buildTraceRunOptions(loaded, tracing) {
+  const tags = Array.from(/* @__PURE__ */ new Set(["agent-task", "e2e", ...tracing.tags ?? []]));
+  const rootMetadata = {
+    taskId: loaded.task.id,
+    taskDir: loaded.taskDir,
+    adapterName: loaded.adapter.name
+  };
+  if (tracing.taskRunId) {
+    rootMetadata[APO_TASK_ID] = loaded.task.id;
+    rootMetadata[APO_TASK_RUN_ID] = tracing.taskRunId;
+  }
+  return {
+    project: tracing.project,
+    task_id: loaded.task.id,
+    flow_name: tracing.flowName ?? `agent-task.${loaded.task.id}`,
+    version: tracing.version,
+    environment: tracing.environment,
+    tags,
+    run_metadata: {
+      taskDir: loaded.taskDir,
+      adapterName: loaded.adapter.name,
+      source: "agent-task-e2e",
+      ...tracing.runMetadata
+    },
+    rootSpan: {
+      task_id: loaded.task.id,
+      step_name: "agent-task.run",
+      observation_type: "CHAIN",
+      model: "agent-task",
+      metadata: rootMetadata
+    }
+  };
+}
+
+// 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";
+function discoverAgentTaskDirs(rootDir) {
+  const absoluteRoot = resolve2(rootDir);
+  if (!existsSync3(absoluteRoot) || !statSync3(absoluteRoot).isDirectory()) {
+    throw new Error(`Task directory not found: ${absoluteRoot}`);
+  }
+  const discovered = [];
+  walkForTaskDirs(absoluteRoot, discovered);
+  return discovered.sort();
+}
+function walkForTaskDirs(currentDir, discovered) {
+  if (readdirSync2(currentDir).some((f) => f.endsWith(".eval.ts"))) {
+    discovered.push(currentDir);
+    return;
+  }
+  for (const entry of readdirSync2(currentDir)) {
+    const absolutePath = join2(currentDir, entry);
+    if (!statSync3(absolutePath).isDirectory()) {
+      continue;
+    }
+    walkForTaskDirs(absolutePath, discovered);
+  }
+}
+
+// src/agent-task/otel-trace-client.ts
+import { trace, context } from "@opentelemetry/api";
+function monotonicNowMs2() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+function round32(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+function createOtelAgentTaskTraceClient(config) {
+  let myHandle = null;
+  async function ensureProvider() {
+    if (!myHandle) {
+      const headers = config.headers ?? (config.authToken ? { Authorization: `Bearer ${config.authToken}` } : {});
+      myHandle = await configureApoTelemetry({
+        takeOwnership: true,
+        endpoint: `${config.endpoint.replace(/\/$/, "")}/api/public/otel/v1/traces`,
+        serviceName: "apo-agent-task",
+        project: config.project,
+        headers,
+        processor: "simple",
+        registerGlobal: true
+      });
+    }
+    return myHandle.tracer;
+  }
+  const activeSpans = /* @__PURE__ */ new Map();
+  let activeTracer = null;
+  function createSpan(params) {
+    if (!activeTracer) throw new Error("traceRun not started");
+    const spanName = params.step_name || params.observation_type || "span";
+    const span = activeTracer.startSpan(spanName);
+    if (params.observation_type) {
+      span.setAttribute("apo.observation.type", params.observation_type);
+    }
+    if (params.model) {
+      span.setAttribute("gen_ai.request.model", params.model);
+    }
+    if (params.input) {
+      if (params.input.messages) {
+        span.setAttribute("gen_ai.input.messages", JSON.stringify(params.input.messages));
+      } else {
+        span.setAttribute("gen_ai.input.messages", JSON.stringify([{
+          role: "system",
+          parts: [{ type: "text", content: JSON.stringify(params.input) }]
+        }]));
+      }
+    }
+    if (params.metadata) {
+      span.setAttribute("apo.metadata", JSON.stringify(params.metadata));
+    }
+    const spanId = span.spanContext().spanId;
+    activeSpans.set(spanId, {
+      span,
+      startedAt: monotonicNowMs2(),
+      model: params.model || "unknown"
+    });
+    return spanId;
+  }
+  function endSpan(params) {
+    const active = activeSpans.get(params.id);
+    if (!active) {
+      return;
+    }
+    const latency = params.latency_ms ?? round32(monotonicNowMs2() - active.startedAt);
+    active.span.setAttribute("latency_ms", latency);
+    if (params.output !== void 0) {
+      if (params.output.text) {
+        active.span.setAttribute("gen_ai.output.messages", JSON.stringify([{
+          role: "assistant",
+          parts: [{ type: "text", content: String(params.output.text) }]
+        }]));
+      } else if (params.output.messages) {
+        active.span.setAttribute("gen_ai.output.messages", JSON.stringify(params.output.messages));
+      } else if (params.output.error) {
+        active.span.setAttribute("gen_ai.output.messages", JSON.stringify([{
+          role: "assistant",
+          parts: [{ type: "text", content: String(params.output.error) }]
+        }]));
+      } else {
+        active.span.setAttribute("gen_ai.output.messages", JSON.stringify([{
+          role: "assistant",
+          parts: [{ type: "text", content: JSON.stringify(params.output) }]
+        }]));
+      }
+    }
+    if (params.prompt_tokens !== void 0) {
+      active.span.setAttribute("gen_ai.usage.input_tokens", params.prompt_tokens);
+    }
+    if (params.completion_tokens !== void 0) {
+      active.span.setAttribute("gen_ai.usage.output_tokens", params.completion_tokens);
+    }
+    if (params.status_message) {
+      active.span.setAttribute("apo.status_message", params.status_message);
+    }
+    if (params.level === "ERROR") {
+      active.span.setStatus({ code: 2, message: params.status_message || "error" });
+    }
+    if (params.metadata) {
+      active.span.setAttribute("apo.metadata", JSON.stringify(params.metadata));
+    }
+    active.span.end();
+    activeSpans.delete(params.id);
+  }
+  return {
+    async traceRun(params, fn) {
+      const tracer = await ensureProvider();
+      activeTracer = tracer;
+      const project = params.project ?? config.project;
+      const taskId = params.task_id ?? params.flow_name ?? "task";
+      const flowName = params.flow_name ?? taskId;
+      const rootSpan = tracer.startSpan("apo.task.run");
+      rootSpan.setAttribute("apo.observation.type", "AGENT");
+      rootSpan.setAttribute("apo.run.flow_name", flowName);
+      rootSpan.setAttribute("apo.run.task_id", taskId);
+      if (params.version) {
+        rootSpan.setAttribute("apo.run.version", params.version);
+      }
+      if (params.run_metadata) {
+        rootSpan.setAttribute("apo.run.metadata", JSON.stringify(params.run_metadata));
+      }
+      if (params.tags?.length) {
+        rootSpan.setAttribute("apo.run.tags", JSON.stringify(params.tags));
+      }
+      const rootMeta = params.rootSpan?.metadata;
+      const taskRunId = params.taskRunId ?? rootMeta?.["apo.task.run.id"] ?? params.run_metadata?.["agent_task_run_id"];
+      if (taskRunId) {
+        rootSpan.setAttribute("apo.task.id", taskId);
+        rootSpan.setAttribute("apo.task.run.id", taskRunId);
+      }
+      const runId = rootSpan.spanContext().traceId;
+      const rootSpanId = rootSpan.spanContext().spanId;
+      activeSpans.set(rootSpanId, {
+        span: rootSpan,
+        startedAt: monotonicNowMs2(),
+        model: "trace"
+      });
+      let callCount = 1;
+      let rootEnded = false;
+      const traceContext = {
+        runId,
+        rootSpanId,
+        async step(options, stepFn) {
+          const spanId = createSpan({
+            ...options,
+            project,
+            task_id: options.task_id ?? taskId,
+            run_id: runId,
+            parent_call_id: options.parent_call_id ?? rootSpanId,
+            flow_name: options.flow_name ?? flowName
+          });
+          const startedAt = monotonicNowMs2();
+          const activeSpan = activeSpans.get(spanId);
+          const ctxWithSpan = activeSpan ? trace.setSpan(context.active(), activeSpan.span) : context.active();
+          try {
+            const result = await context.with(ctxWithSpan, () => stepFn(spanId));
+            endSpan({
+              id: spanId,
+              latency_ms: round32(monotonicNowMs2() - startedAt),
+              output: options.summarize?.(result),
+              metadata: options.metadata
+            });
+            callCount += 1;
+            return result;
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            endSpan({
+              id: spanId,
+              latency_ms: round32(monotonicNowMs2() - startedAt),
+              output: { error: message },
+              status_message: message,
+              level: "ERROR",
+              metadata: { ...options.metadata, failed: true }
+            });
+            throw error;
+          }
+        },
+        recordEvent(options) {
+          const spanId = createSpan({
+            ...options,
+            project,
+            task_id: options.task_id ?? taskId,
+            run_id: runId,
+            parent_call_id: options.parent_call_id ?? rootSpanId,
+            flow_name: options.flow_name ?? flowName
+          });
+          endSpan({
+            id: spanId,
+            latency_ms: options.latency_ms,
+            output: options.output,
+            metadata: options.metadata
+          });
+          callCount += 1;
+          return spanId;
+        },
+        endRoot(endParams) {
+          if (rootEnded) return;
+          endSpan({ id: rootSpanId, ...endParams });
+          rootEnded = true;
+        },
+        // Non-LLM tracing helpers — these create spans through the same tracer
+        async traceTool(name, params2, fn2) {
+          const spanId = createSpan({
+            project,
+            task_id: taskId,
+            run_id: runId,
+            parent_call_id: rootSpanId,
+            flow_name: flowName,
+            step_name: `tool ${name}`,
+            observation_type: "TOOL",
+            model: "unknown",
+            input: params2
+          });
+          try {
+            const result = await fn2();
+            endSpan({ id: spanId, output: result });
+            callCount += 1;
+            return result;
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            endSpan({ id: spanId, output: { error: msg }, status_message: msg, level: "ERROR" });
+            throw error;
+          }
+        },
+        async traceRetriever(query, fn2) {
+          const spanId = createSpan({
+            project,
+            task_id: taskId,
+            run_id: runId,
+            parent_call_id: rootSpanId,
+            flow_name: flowName,
+            step_name: "retrieve",
+            observation_type: "RETRIEVER",
+            model: "unknown",
+            input: { query }
+          });
+          try {
+            const r = await fn2();
+            endSpan({ id: spanId, output: r });
+            callCount += 1;
+            return r;
+          } catch (e) {
+            const m = e instanceof Error ? e.message : String(e);
+            endSpan({ id: spanId, output: { error: m }, level: "ERROR" });
+            throw e;
+          }
+        },
+        async traceChain(name, fn2) {
+          const spanId = createSpan({
+            project,
+            task_id: taskId,
+            run_id: runId,
+            parent_call_id: rootSpanId,
+            flow_name: flowName,
+            step_name: name,
+            observation_type: "CHAIN",
+            model: "unknown"
+          });
+          try {
+            const r = await fn2();
+            endSpan({ id: spanId, output: r });
+            callCount += 1;
+            return r;
+          } catch (e) {
+            const m = e instanceof Error ? e.message : String(e);
+            endSpan({ id: spanId, output: { error: m }, level: "ERROR" });
+            throw e;
+          }
+        },
+        async traceAgent(name, fn2) {
+          const spanId = createSpan({
+            project,
+            task_id: taskId,
+            run_id: runId,
+            parent_call_id: rootSpanId,
+            flow_name: flowName,
+            step_name: name,
+            observation_type: "AGENT",
+            model: "unknown"
+          });
+          try {
+            const r = await fn2();
+            endSpan({ id: spanId, output: r });
+            callCount += 1;
+            return r;
+          } catch (e) {
+            const m = e instanceof Error ? e.message : String(e);
+            endSpan({ id: spanId, output: { error: m }, level: "ERROR" });
+            throw e;
+          }
+        },
+        async traceGuardrail(name, fn2) {
+          const spanId = createSpan({
+            project,
+            task_id: taskId,
+            run_id: runId,
+            parent_call_id: rootSpanId,
+            flow_name: flowName,
+            step_name: name,
+            observation_type: "GUARDRAIL",
+            model: "unknown"
+          });
+          try {
+            const r = await fn2();
+            endSpan({ id: spanId, output: r });
+            callCount += 1;
+            return r;
+          } catch (e) {
+            const m = e instanceof Error ? e.message : String(e);
+            endSpan({ id: spanId, output: { error: m }, level: "ERROR" });
+            throw e;
+          }
+        },
+        async traceEmbedding(model, input, fn2) {
+          const spanId = createSpan({
+            project,
+            task_id: taskId,
+            run_id: runId,
+            parent_call_id: rootSpanId,
+            flow_name: flowName,
+            step_name: "embedding",
+            observation_type: "EMBEDDING",
+            model,
+            input: { value: input }
+          });
+          try {
+            const r = await fn2();
+            endSpan({ id: spanId, output: r });
+            callCount += 1;
+            return r;
+          } catch (e) {
+            const m = e instanceof Error ? e.message : String(e);
+            endSpan({ id: spanId, output: { error: m }, level: "ERROR" });
+            throw e;
+          }
+        },
+        async score(scoreParams) {
+          const { score: scoreFn } = await import("../otel/index.js");
+          const scoreHeaders = config.headers ?? (config.authToken ? { Authorization: `Bearer ${config.authToken}` } : {});
+          await scoreFn(
+            { traceId: runId, ...scoreParams },
+            { endpoint: config.endpoint, headers: scoreHeaders }
+          );
+        }
+      };
+      const agentTaskContext = {
+        ...traceContext,
+        createSpan(options) {
+          const spanId = createSpan({
+            ...options,
+            project,
+            run_id: runId,
+            task_id: options.task_id ?? taskId,
+            flow_name: options.flow_name ?? flowName
+          });
+          callCount += 1;
+          return spanId;
+        },
+        endSpan(spanId, endParams) {
+          endSpan({ id: spanId, ...endParams });
+        }
+      };
+      return context.with(trace.setSpan(context.active(), rootSpan), async () => {
+        let result;
+        let runError;
+        try {
+          result = await fn(agentTaskContext);
+          agentTaskContext.endRoot();
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          agentTaskContext.endRoot({
+            output: { error: message },
+            status_message: message,
+            level: "ERROR",
+            metadata: { failed: true }
+          });
+          runError = error;
+        }
+        let flushError;
+        if (myHandle) {
+          try {
+            await myHandle.forceFlush();
+          } catch (error) {
+            flushError = error;
+          }
+          await myHandle.shutdown();
+          myHandle = null;
+        }
+        if (runError !== void 0) throw runError;
+        if (flushError !== void 0 && config.requirePersistence) {
+          const detail = flushError instanceof Error ? flushError.message : String(flushError);
+          throw new Error(`OTLP trace persistence failed: ${detail}`);
+        }
+        return result;
+      });
+    }
+  };
+}
+
+// src/agent-task/task-runtime.ts
+async function loadTaskRuntime(_taskDir) {
+  return {
+    judge: resolveJudgeFromEnv()
+  };
+}
+function resolveJudgeFromEnv() {
+  const openRouterModel = process.env.OPENROUTER_MODEL;
+  const model = openRouterModel ?? process.env.OPENAI_MODEL;
+  if (!model) return void 0;
+  return {
+    model,
+    baseURL: openRouterModel ? process.env.OPENROUTER_BASE_URL : process.env.OPENAI_BASE_URL ?? "https://api.openai.com/v1",
+    apiKey: openRouterModel ? process.env.OPENROUTER_API_KEY : process.env.OPENAI_API_KEY
+  };
+}
+async function runTaskDir(taskDir) {
+  const [loaded, runtime] = await Promise.all([
+    loadTask(taskDir),
+    loadTaskRuntime(taskDir)
+  ]);
+  const endpoint = process.env.AGENT_TASK_TRACE_ENDPOINT;
+  const hasTracing = endpoint && process.env.AGENT_TASK_PROJECT;
+  const taskRunId = process.env.AGENT_TASK_RUN_ID;
+  const tracing = hasTracing ? {
+    client: createOtelAgentTaskTraceClient({
+      endpoint,
+      project: process.env.AGENT_TASK_PROJECT,
+      headers: _buildAuthHeaders()
+    }),
+    project: process.env.AGENT_TASK_PROJECT,
+    environment: process.env.AGENT_TASK_ENVIRONMENT ?? "default",
+    ...taskRunId ? { taskRunId } : {}
+  } : void 0;
+  const result = await runTask(taskDir, { ...runtime, tracing, loaded });
+  return {
+    taskDir: loaded.taskDir,
+    taskId: loaded.task.id,
+    pass: result.result.pass,
+    checks: result.result.checks,
+    adapterName: loaded.adapter.name,
+    traceRunId: result.traceRunId,
+    deliverables: result.deliverables,
+    transcript: result.transcript,
+    runConfiguration: result.runConfiguration
+  };
+}
+function _buildAuthHeaders() {
+  const pk = process.env.APO_PUBLIC_KEY;
+  const sk = process.env.APO_SECRET_KEY;
+  if (pk && sk) {
+    const creds = typeof btoa === "function" ? btoa(`${pk}:${sk}`) : Buffer.from(`${pk}:${sk}`).toString("base64");
+    return { Authorization: `Basic ${creds}` };
+  }
+  const token = process.env.APO_AUTH_TOKEN;
+  if (token) {
+    return { Authorization: `Bearer ${token}` };
+  }
+  return void 0;
+}
+
+// src/agent-task/cli.ts
+function parseAgentTaskCliArgs(argv) {
+  const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+      continue;
+    }
+    if (arg === "--task") {
+      options.task = requireNextValue(argv, index, "--task");
+      index += 1;
+      continue;
+    }
+    if (arg === "--dir") {
+      options.dir = requireNextValue(argv, index, "--dir");
+      index += 1;
+      continue;
+    }
+    if (arg === "--grep") {
+      options.grep = requireNextValue(argv, index, "--grep");
+      index += 1;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+  if (options.task && options.dir) {
+    throw new Error("Use either --task or --dir, not both");
+  }
+  return options;
+}
+async function runAgentTaskCli(argv, cwd = process.cwd()) {
+  const normalizedArgv = argv[0] === "--" ? argv.slice(1) : argv;
+  const options = parseAgentTaskCliArgs(normalizedArgv);
+  if (options.help) {
+    printHelp();
+    return 0;
+  }
+  const selectedTaskDirs = resolveSelectedTaskDirs(options, cwd);
+  if (selectedTaskDirs.length === 0) {
+    throw new Error("No task folders found for the selected input");
+  }
+  let hasFailures = false;
+  let hasErrors = false;
+  const results = await Promise.allSettled(
+    selectedTaskDirs.map((taskDir) => runTaskDir(taskDir))
+  );
+  const summaries = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    const taskDir = selectedTaskDirs[i];
+    if (result.status === "fulfilled") {
+      summaries.push(result.value);
+      printTaskSummary(result.value, cwd);
+      hasFailures ||= !result.value.pass;
+    } else {
+      hasErrors = true;
+      printTaskError(taskDir, cwd, result.reason);
+    }
+  }
+  printOverallSummary(summaries, hasErrors);
+  if (hasErrors) {
+    return 2;
+  }
+  return hasFailures ? 1 : 0;
+}
+function resolveSelectedTaskDirs(options, cwd) {
+  if (options.task) {
+    return [resolve3(cwd, options.task)];
+  }
+  const rootDir = resolve3(cwd, options.dir ?? "e2e");
+  const discovered = discoverAgentTaskDirs(rootDir);
+  if (!options.grep) {
+    return discovered;
+  }
+  return discovered.filter(
+    (taskDir) => (
+      // String.prototype.includes (not Array.includes) — false positive
+      // react-doctor-disable-next-line react-doctor/js-set-map-lookups
+      relative(cwd, taskDir).includes(options.grep)
+    )
+  );
+}
+function requireNextValue(argv, index, flag) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith("--")) {
+    throw new Error(`Missing value for ${flag}`);
+  }
+  return value;
+}
+function printHelp() {
+  console.log("Usage: agent-task-e2e [--task <task-folder> | --dir <tasks-root>] [--grep <substring>]");
+  console.log("");
+  console.log("Options");
+  console.log("- --task <path>  Run one task folder");
+  console.log("- --dir <path>   Run all task folders under a root directory");
+  console.log("- --grep <text>  Filter discovered task paths by substring");
+  console.log("- --help         Show this help");
+}
+function printTaskSummary(summary, cwd) {
+  const relativeTaskDir = relative(cwd, summary.taskDir);
+  console.log("");
+  console.log(`${summary.pass ? "PASS" : "FAIL"} ${summary.taskId}`);
+  console.log(`Path: ${relativeTaskDir}`);
+  printResultGroup("Checks", summary.checks);
+  if (summary.checks.length === 0 && !summary.pass) {
+    console.log(NO_CHECKS_REGISTERED_MESSAGE);
+  }
+}
+function printResultGroup(label, results) {
+  if (results.length === 0) {
+    return;
+  }
+  console.log(label);
+  for (const result of results) {
+    console.log(`- ${result.id}: ${result.pass ? "PASS" : "FAIL"}`);
+    if (result.reasoning) {
+      console.log(`  ${result.reasoning}`);
+    }
+  }
+}
+function printTaskError(taskDir, cwd, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.log("");
+  console.log(`ERROR ${relative(cwd, taskDir)}`);
+  console.log(message);
+}
+function printOverallSummary(summaries, hasErrors) {
+  const passed = summaries.filter((summary) => summary.pass).length;
+  const failed = summaries.length - passed;
+  console.log("");
+  console.log("Summary");
+  console.log(`- total: ${summaries.length}`);
+  console.log(`- passed: ${passed}`);
+  console.log(`- failed: ${failed}`);
+  console.log(`- errors: ${hasErrors ? "yes" : "no"}`);
+}
+
+// src/agent-task/task-revision-manifest.ts
+import { createHash as createHash2 } from "crypto";
+function normalizeManifestPath(path) {
+  return path.split("\\").join("/").normalize("NFC");
+}
+function sha256Hex(bytes) {
+  return createHash2("sha256").update(bytes).digest("hex");
+}
+function compareBytewiseUtf8(a, b) {
+  const ba = Buffer.from(a, "utf8");
+  const bb = Buffer.from(b, "utf8");
+  for (let i = 0; i < Math.min(ba.length, bb.length); i++) {
+    if (ba[i] !== bb[i]) return ba[i] < bb[i] ? -1 : 1;
+  }
+  return ba.length - bb.length;
+}
+function buildManifest(files, summary) {
+  const entries = files.map((f) => {
+    const path = normalizeManifestPath(f.path);
+    return {
+      path,
+      sizeBytes: f.content.byteLength,
+      sha256: sha256Hex(f.content),
+      modeClass: f.modeClass
+    };
+  });
+  entries.sort((a, b) => compareBytewiseUtf8(a.path, b.path));
+  return {
+    schemaVersion: 1,
+    files: entries,
+    summary: {
+      fileCount: entries.length,
+      uncompressedSizeBytes: entries.reduce((n, f) => n + f.sizeBytes, 0),
+      excludedFileCount: summary?.excludedFileCount ?? 0,
+      excludedDirectoryCount: summary?.excludedDirectoryCount ?? 0
+    }
+  };
+}
+function canonicalManifestJson(manifest) {
+  const filesPayload = manifest.files.map((f) => ({
+    modeClass: f.modeClass,
+    path: f.path,
+    sha256: f.sha256,
+    sizeBytes: f.sizeBytes
+  }));
+  return JSON.stringify({ files: filesPayload, schemaVersion: manifest.schemaVersion });
+}
+function contentSha256(manifest) {
+  return sha256Hex(Buffer.from(canonicalManifestJson(manifest), "utf8"));
+}
+export {
+  AgentTaskRunError,
+  ApoSpanProcessor,
+  FlowView,
+  TEST_METHOD_NAMES,
+  TaskFiles,
+  buildManifest,
+  canonicalManifestJson,
+  contentSha256,
+  createApoAnthropic,
+  createApoOpenAI,
+  createApoTracer,
+  defineAdapter,
+  defineTask,
+  describe,
+  discoverAgentTaskDirs,
+  equals,
+  fileArtifact,
+  filePaths,
+  fromAISDK,
+  fromAnthropicMessages,
+  fromOpenAIMessages,
+  getActiveApoRun,
+  getTaskTurn,
+  includes,
+  isFileArtifact,
+  loadTask,
+  loadTaskRuntime,
+  matchValue,
+  matches,
+  normalizeManifestPath,
+  parseAgentTaskCliArgs,
+  persistFileArtifacts,
+  registerApoTracing,
+  resetApoTracing,
+  resetFlowChecks,
+  resetTaskRegistry,
+  resetTaskTurn,
+  resolveTurn,
+  runAgentTaskCli,
+  runTask,
+  runTaskDir,
+  satisfies,
+  sha256Hex,
+  similarity,
+  task,
+  defineCheck as test,
+  turn,
+  withApoRun,
+  withApoRunSync
+};
+//# sourceMappingURL=public.js.map