@apo-ai/sdk 0.7.1 → 0.9.0

package/dist/agent-task/public.js

@@ -8,20 +8,21 @@ import {
   resetApoTracing,
   withApoRun,
   withApoRunSync
-} from "../chunk-GETY34VI.js";
+} from "../chunk-KLZLE3VQ.js";
 import {
   createApoTracer
-} from "../chunk-QHRWPVPZ.js";
-import "../chunk-HWZVL6TS.js";
+} from "../chunk-IK4GJX7H.js";
+import "../chunk-HRYXLRXJ.js";
 import {
   createApoOpenAI
-} from "../chunk-6ZRW5IW6.js";
+} from "../chunk-3B3L2H4Y.js";
 import {
   createApoAnthropic
-} from "../chunk-SZDSIPXC.js";
-import "../chunk-GDB6SDGN.js";
+} from "../chunk-43OI6GP7.js";
+import "../chunk-3OQ3JBFJ.js";
 
 // src/agent-task/trace-projection/view.ts
+var TASK_TURN_SPAN_NAME = "task.turn";
 function invocationOrderKey(obs) {
   const hasTs = obs.startedAt != null ? 0 : 1;
   return [hasTs, obs.startedAt ?? "", obs.spanId];
@@ -32,11 +33,11 @@ var TraceView = class {
   }
   /** Evidence availability for a capability. */
   requireCapability(capability) {
-    return this.snapshot.capabilities[capability];
+    return this.snapshot.capabilities[capability] ?? "unavailable";
   }
   /** Whether a capability is reported as available (not partial/unavailable). */
   isAvailable(capability) {
-    return this.snapshot.capabilities[capability] === "available";
+    return this.requireCapability(capability) === "available";
   }
   /** All chat messages flattened across generation observations, in order. */
   get messages() {
@@ -115,6 +116,135 @@ var TraceView = class {
     }
     return void 0;
   }
+  /**
+   * Task Turns in invocation order, or `undefined` when timing evidence is
+   * not available. Each is one `task.turn` span: the adapter's whole
+   * `sendUserTurn` call for that turn.
+   */
+  get turns() {
+    if (!this.isAvailable("timing")) return void 0;
+    return this.turnSpans.map((o, i) => ({
+      turnNumber: i + 1,
+      spanId: o.spanId,
+      ...o.durationMs !== void 0 ? { durationMs: o.durationMs } : {},
+      status: o.status
+    }));
+  }
+  /**
+   * Tokens the agent under test spent: usage on observations inside
+   * `task.turn` spans (every turn, or only turn `turn`). Work outside the
+   * turns — the evaluation phase's judges, adapter setup — is not the
+   * agent's and is excluded. `undefined` when usage evidence is not
+   * available or the requested turn does not exist.
+   */
+  /** How many Task Turns ran — independent of timing evidence. */
+  get turnCountFromSpans() {
+    return this.turnSpans.length;
+  }
+  tokens(kind, opts) {
+    if (!this.isAvailable("usage")) return void 0;
+    const turnSpans = this.turnSpans;
+    let roots;
+    if (opts?.turn !== void 0) {
+      const one = turnSpans[opts.turn - 1];
+      if (!one) return void 0;
+      roots = [one];
+    } else {
+      roots = turnSpans;
+    }
+    const tally = { tokens: 0, reported: 0, unreported: 0 };
+    const children = this.childrenByParent;
+    const isLlmCall = (o) => o.type === "GENERATION" || o.usage != null;
+    const isStep = (o) => isLlmCall(o) && o.type !== "TOOL" && o.type !== "AGENT";
+    const order = [];
+    const visited = new Set(roots.map((r) => r.spanId));
+    const topLevel = roots.flatMap((r) => children.get(r.spanId) ?? []);
+    const stack = [...topLevel];
+    const scopeChildren = /* @__PURE__ */ new Map();
+    while (stack.length > 0) {
+      const obs = stack.pop();
+      if (visited.has(obs.spanId)) continue;
+      visited.add(obs.spanId);
+      order.push(obs);
+      const kids = (children.get(obs.spanId) ?? []).filter((c) => !visited.has(c.spanId));
+      scopeChildren.set(obs.spanId, kids);
+      for (const kid of kids) stack.push(kid);
+    }
+    const effective = /* @__PURE__ */ new Map();
+    for (let i = order.length - 1; i >= 0; i--) {
+      const obs = order[i];
+      const { count, complete } = tokenCount(obs, kind);
+      if (count !== void 0) tally.reported += 1;
+      const ownKnown = complete && obs.status !== "error";
+      let steps;
+      let stepsUnreported = 0;
+      let separate;
+      let separateUnreported = 0;
+      for (const child of scopeChildren.get(obs.spanId) ?? []) {
+        const c = effective.get(child.spanId);
+        if (!c) continue;
+        if (isStep(child)) {
+          if (c.tokens !== void 0) steps = (steps ?? 0) + c.tokens;
+          stepsUnreported += c.unreported;
+        } else {
+          if (c.tokens !== void 0) separate = (separate ?? 0) + c.tokens;
+          separateUnreported += c.unreported;
+        }
+      }
+      const own = count === void 0 ? steps : steps === void 0 ? count : Math.max(count, steps);
+      const unreported = (isLlmCall(obs) && !ownKnown ? 1 : 0) + (isLlmCall(obs) && ownKnown ? 0 : stepsUnreported) + separateUnreported;
+      effective.set(obs.spanId, {
+        tokens: own === void 0 && separate === void 0 ? void 0 : (own ?? 0) + (separate ?? 0),
+        unreported
+      });
+    }
+    for (const obs of topLevel) {
+      const e = effective.get(obs.spanId);
+      if (!e) continue;
+      tally.tokens += e.tokens ?? 0;
+      tally.unreported += e.unreported;
+      effective.delete(obs.spanId);
+    }
+    return tally;
+  }
+  /**
+   * The run's own Task Turns: `task.turn` observations with no `task.turn`
+   * ancestor (a nested run or a user span of the same name inside a turn is
+   * part of that turn, not a turn of its own). Turns run sequentially, so
+   * invocation order is turn order.
+   */
+  get turnSpans() {
+    if (this._turnSpans !== void 0) return this._turnSpans;
+    const byId = new Map(this.snapshot.observations.map((o) => [o.spanId, o]));
+    const insideAnotherTurn = (obs) => {
+      const visited = /* @__PURE__ */ new Set([obs.spanId]);
+      let parentId = obs.parentSpanId;
+      while (parentId !== void 0 && !visited.has(parentId)) {
+        visited.add(parentId);
+        const parent = byId.get(parentId);
+        if (!parent) return false;
+        if (parent.name === TASK_TURN_SPAN_NAME) return true;
+        parentId = parent.parentSpanId;
+      }
+      return false;
+    };
+    this._turnSpans = this.sortedObservations.filter(
+      (o) => o.name === TASK_TURN_SPAN_NAME && !insideAnotherTurn(o)
+    );
+    return this._turnSpans;
+  }
+  get childrenByParent() {
+    if (this._children !== void 0) return this._children;
+    const children = /* @__PURE__ */ new Map();
+    for (const obs of this.snapshot.observations) {
+      if (obs.parentSpanId == null) continue;
+      const list = children.get(obs.parentSpanId);
+      if (list) list.push(obs);
+      else children.set(obs.parentSpanId, [obs]);
+    }
+    this._children = children;
+    return children;
+  }
   /**
    * Observations sorted deterministically by invocation time then span ID.
    * Memoized per TraceView instance since the snapshot is immutable.
@@ -130,6 +260,18 @@ var TraceView = class {
     return sorted;
   }
 };
+function tokenCount(obs, kind) {
+  const known = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+  const input = known(obs.usage?.inputTokens);
+  const output = known(obs.usage?.outputTokens);
+  if (kind === "input") return { count: input, complete: input !== void 0 };
+  if (kind === "output") return { count: output, complete: output !== void 0 };
+  if (input === void 0 && output === void 0) return { count: void 0, complete: false };
+  return {
+    count: (input ?? 0) + (output ?? 0),
+    complete: input !== void 0 && output !== void 0
+  };
+}
 
 // src/agent-task/checks/matchers.ts
 function asString(value) {
@@ -253,9 +395,24 @@ function decisionsEndpoint(chatBaseURL) {
   const base = chatBaseURL.replace(/\/v1\/?$/, "");
   return `${base}/alpha/decisions`;
 }
+var INPUT_TOO_LARGE_MARKERS = [
+  "max_tokens_exceeded",
+  "context_length_exceeded",
+  "maximum context length"
+];
+function isInputTooLargeRejection(status, body) {
+  if (status !== 400 && status !== 413) return false;
+  return INPUT_TOO_LARGE_MARKERS.some((marker2) => body.includes(marker2));
+}
+function estimateTokens(text) {
+  return Math.round(text.length / 4 / 1e3) * 1e3;
+}
 async function callSecondJudge(args) {
   const startedAt = Date.now();
-  const evidence = { model: args.model };
+  const evidence = {
+    model: args.model,
+    ...args.projected ? { projected: true } : {}
+  };
   try {
     const response = await fetch(decisionsEndpoint(args.baseURL), {
       method: "POST",
@@ -281,6 +438,10 @@ async function callSecondJudge(args) {
     });
     if (!response.ok) {
       const body = await response.text().catch(() => "");
+      if (isInputTooLargeRejection(response.status, body)) {
+        evidence.skipped = `input ~${estimateTokens(args.state).toLocaleString("en-US")} tokens exceeds ${args.model}'s context limit \u2014 project a smaller view with t.judge(value, instruction, { secondJudgeValue })`;
+        return evidence;
+      }
       evidence.error = `Second judge API ${response.status}: ${body.slice(0, 200)}`;
       return evidence;
     }
@@ -314,6 +475,12 @@ async function callSecondJudge(args) {
 }
 
 // src/agent-task/checks/judge.ts
+var JudgeUnavailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "JudgeUnavailableError";
+  }
+};
 var VERDICT_FIRST_CONTRACT = 'Respond with ONLY a JSON object: {"pass": true/false, "reasoning": "your reasoning"}';
 var REASONING_FIRST_CONTRACT = 'Respond with ONLY a JSON object: {"reasoning": "your reasoning", "pass": true/false}';
 function isJudgeVerdictFirstOverrideEnabled() {
@@ -389,7 +556,92 @@ function parseJudgeJson(raw) {
     reasoning: "Judge response could not be parsed as JSON \u2014 the verdict is unknown, so this check is treated as a failure. The model's raw response is available in the judge metadata."
   };
 }
-var JUDGE_TIMEOUT_MS = 12e4;
+var JUDGE_TIMEOUT_MS = 3e5;
+var JUDGE_IDLE_TIMEOUT_MS = 9e4;
+var JUDGE_RETRY_DELAY_MS = 1e3;
+var JUDGE_RETRY_AFTER_CAP_MS = 2e4;
+var JUDGE_MIN_RETRY_BUDGET_MS = 6e4;
+function isRetryableStatus(status) {
+  return status === 429 || status >= 500;
+}
+function retryDelayMs(retryAfter) {
+  if (!retryAfter) return JUDGE_RETRY_DELAY_MS;
+  const seconds = Number(retryAfter);
+  const ms = Number.isFinite(seconds) ? seconds * 1e3 : Date.parse(retryAfter) - Date.now();
+  if (!Number.isFinite(ms)) return JUDGE_RETRY_DELAY_MS;
+  return Math.min(Math.max(ms, JUDGE_RETRY_DELAY_MS), JUDGE_RETRY_AFTER_CAP_MS);
+}
+async function readCompletion(response, onData) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("text/event-stream")) {
+    const data = await response.json();
+    return {
+      text: data.choices?.[0]?.message?.content ?? "",
+      usage: data.usage,
+      finishReason: data.choices?.[0]?.finish_reason ?? void 0
+    };
+  }
+  let text = "";
+  let usage;
+  let finishReason;
+  let eventType = "message";
+  let dataLines = [];
+  let finished = false;
+  const dispatch = () => {
+    const payload = dataLines.join("\n").trim();
+    const type = eventType;
+    eventType = "message";
+    dataLines = [];
+    if (payload === "[DONE]") finished = true;
+    if (!payload || finished) return;
+    onData();
+    let chunk;
+    try {
+      chunk = JSON.parse(payload);
+    } catch {
+      chunk = void 0;
+    }
+    if (type === "error" || chunk?.error) {
+      const error = chunk?.error;
+      const message = typeof error === "string" ? error : error?.message ?? (chunk ? void 0 : payload);
+      throw new JudgeUnavailableError(`Judge stream error: ${message ?? "unknown"}`);
+    }
+    if (!chunk) return;
+    const choice = chunk.choices?.[0];
+    text += choice?.delta?.content ?? "";
+    if (choice?.finish_reason) finishReason = choice.finish_reason;
+    if (chunk.usage) usage = chunk.usage;
+  };
+  const handleLine = (line) => {
+    if (line === "") return dispatch();
+    if (line.startsWith(":")) return;
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    let value = colon === -1 ? "" : line.slice(colon + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    if (field === "data") dataLines.push(value);
+    else if (field === "event") eventType = value;
+  };
+  const reader = response.body?.getReader();
+  if (!reader) return { text, usage, finishReason };
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split(/\r\n|\r(?!$)|\n/);
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      handleLine(line);
+      if (finished) return { text, usage, finishReason };
+    }
+  }
+  buffer += decoder.decode();
+  for (const line of buffer.split(/\r\n|\r|\n/)) if (line) handleLine(line);
+  dispatch();
+  return { text, usage, finishReason };
+}
 var prefixQueues = /* @__PURE__ */ new Map();
 function runWithSharedPrefix(key, task2) {
   const prev = prefixQueues.get(key) ?? Promise.resolve();
@@ -413,84 +665,171 @@ ${formatJudgeValues(args.values)}`;
 
 ${deliverableText}`;
   const secondJudgeModel = resolveSecondJudgeModel();
+  const secondJudgeProjected = args.secondJudgeValue !== void 0;
+  const secondJudgeValues = args.secondJudgeValue ?? args.values;
+  const secondJudgeDeliverableText = `Values to evaluate:
+${formatJudgeValues(secondJudgeValues)}`;
   const secondJudgePromise = secondJudgeModel ? callSecondJudge({
-    state: `${systemPromptText}
+    state: `${briefingText}
+
+${secondJudgeDeliverableText}
 
 ${instructionText}`,
     model: secondJudgeModel,
     baseURL: resolveSecondJudgeBaseURL(baseURL),
-    apiKey: resolveSecondJudgeAPIKey(apiKey)
+    apiKey: resolveSecondJudgeAPIKey(apiKey),
+    ...secondJudgeProjected ? { projected: true } : {}
   }) : void 0;
   const cacheKey = `${args.model}\0${briefingText}\0${deliverableText}`;
-  return runWithSharedPrefix(cacheKey, async () => {
-    const startedAt = Date.now();
-    const response = await fetch(`${baseURL}/chat/completions`, {
-      method: "POST",
-      signal: AbortSignal.timeout(JUDGE_TIMEOUT_MS),
-      headers: {
-        "Content-Type": "application/json",
-        ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
-      },
-      body: JSON.stringify({
-        model: args.model,
-        messages: [
+  const requestBody = (stream) => JSON.stringify({
+    model: args.model,
+    messages: [
+      {
+        role: "system",
+        content: [
+          { type: "text", text: briefingText },
           {
-            role: "system",
-            content: [
-              { type: "text", text: briefingText },
-              {
-                type: "text",
-                text: deliverableText,
-                cache_control: { type: "ephemeral" }
-              }
-            ]
+            type: "text",
+            text: deliverableText,
+            cache_control: { type: "ephemeral" }
+          }
+        ]
+      },
+      { role: "user", content: instructionText }
+    ],
+    temperature: 0,
+    response_format: { type: "json_object" },
+    ...stream ? { stream: true, stream_options: { include_usage: true } } : {}
+  });
+  const attempt = async (stream, deadline) => {
+    const controller = new AbortController();
+    const expire = (reason, name) => () => controller.abort(new DOMException(reason, name));
+    const total = setTimeout(
+      expire(`no complete response within ${JUDGE_TIMEOUT_MS / 1e3}s`, "TimeoutError"),
+      Math.max(deadline - Date.now(), 0)
+    );
+    const stalled = expire(`no data for ${JUDGE_IDLE_TIMEOUT_MS / 1e3}s`, "IdleTimeoutError");
+    let idle;
+    const onData = () => {
+      clearTimeout(idle);
+      idle = setTimeout(stalled, JUDGE_IDLE_TIMEOUT_MS);
+    };
+    try {
+      let response;
+      try {
+        response = await fetch(`${baseURL}/chat/completions`, {
+          method: "POST",
+          signal: controller.signal,
+          headers: {
+            "Content-Type": "application/json",
+            ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
           },
-          { 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)}`);
+          body: requestBody(stream)
+        });
+      } catch (error) {
+        return transportFailure("Judge request failed", controller.signal.reason ?? error);
+      }
+      if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        return {
+          kind: "unavailable",
+          error: new JudgeUnavailableError(`Judge API ${response.status}: ${body.slice(0, 200)}`),
+          retryable: isRetryableStatus(response.status),
+          ...isRetryableStatus(response.status) ? { retryDelayMs: retryDelayMs(response.headers.get("retry-after")) } : {},
+          // Name the field, not the word: gateways echo request params in
+          // unrelated 400 bodies.
+          ...stream && response.status === 400 && /stream_options|["'`]stream["'`]/.test(body) ? { streamRejected: true } : {}
+        };
+      }
+      try {
+        return { kind: "completion", completion: await readCompletion(response, onData) };
+      } catch (error) {
+        return transportFailure("Judge response failed", controller.signal.reason ?? error);
+      }
+    } finally {
+      clearTimeout(total);
+      clearTimeout(idle);
+      controller.abort();
     }
-    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) {
+  };
+  const isTruncated = ({ text, usage, finishReason }) => {
+    if (!text.trim()) return true;
+    if (usage !== void 0 && usage.completion_tokens === 0) return true;
+    if (finishReason !== "length" && finishReason !== "content_filter" && finishReason !== "error") {
+      return false;
+    }
+    try {
+      JSON.parse(text);
+      return false;
+    } catch {
+      return true;
+    }
+  };
+  return runWithSharedPrefix(cacheKey, async () => {
+    const startedAt = Date.now();
+    const deadline = startedAt + JUDGE_TIMEOUT_MS;
+    let stream = true;
+    let result = await attempt(stream, deadline);
+    const truncated = result.kind === "completion" && isTruncated(result.completion);
+    const streamRejected = result.kind === "unavailable" && result.streamRejected === true;
+    const retryable = result.kind === "unavailable" && result.retryable;
+    if (truncated || streamRejected || retryable) {
+      const delay = result.kind === "unavailable" && result.retryDelayMs !== void 0 ? result.retryDelayMs : streamRejected ? 0 : JUDGE_RETRY_DELAY_MS;
+      if (deadline - Date.now() - delay >= JUDGE_MIN_RETRY_BUDGET_MS) {
+        if (streamRejected) stream = false;
+        await new Promise((resolve4) => setTimeout(resolve4, delay));
+        const first = result;
+        result = await attempt(stream, deadline);
+        if (result.kind === "unavailable" && first.kind === "unavailable") {
+          result = {
+            ...result,
+            error: new JudgeUnavailableError(
+              `${first.error.message} (retry: ${result.error.message})`
+            )
+          };
+        }
+      }
+    }
+    if (result.kind === "unavailable") throw result.error;
+    const { text, usage } = result.completion;
+    const judge = {
+      model: args.model,
+      contract: judgeContractInUse(),
+      prompt: { system: systemPromptText, user: instructionText },
+      response: text,
+      tokens: parseJudgeUsage(usage),
+      latency_ms: Date.now() - startedAt,
+      secondJudge: await secondJudgePromise
+    };
+    if (isTruncated(result.completion)) {
       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,
-          contract: judgeContractInUse(),
-          prompt: { system: systemPromptText, user: instructionText },
-          response: text,
-          tokens: parseJudgeUsage(data.usage),
-          latency_ms: Date.now() - startedAt,
-          secondJudge: await secondJudgePromise
-        }
+        reasoning: "Judge returned an empty or truncated response \u2014 likely a transient provider failure. The verdict is unknown, so this check is recorded as a judge error, not a verdict.",
+        judge,
+        unavailable: true
       };
     }
     const parsed = parseJudgeJson(text);
     return {
       pass: parsed.pass === true,
       reasoning: typeof parsed.reasoning === "string" ? parsed.reasoning : "",
-      judge: {
-        model: args.model,
-        contract: judgeContractInUse(),
-        prompt: { system: systemPromptText, user: instructionText },
-        response: text,
-        tokens: parseJudgeUsage(data.usage),
-        latency_ms: Date.now() - startedAt,
-        secondJudge: await secondJudgePromise
-      }
+      judge
     };
   });
 }
+function transportFailure(prefix, error) {
+  if (error instanceof JudgeUnavailableError) {
+    return { kind: "unavailable", error, retryable: true };
+  }
+  const timedOut = error instanceof Error && error.name === "TimeoutError";
+  return {
+    kind: "unavailable",
+    error: new JudgeUnavailableError(
+      `${prefix}: ${error instanceof Error ? error.message : String(error)}`
+    ),
+    retryable: !timedOut
+  };
+}
 function assembleBriefing(args) {
   if (!args.prompt) {
     return {
@@ -521,6 +860,53 @@ ${args.instruction}`
 
 // src/agent-task/checks/agent-session.ts
 import { createHash } from "crypto";
+
+// 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) {
+    }
+  };
+}
+function isTraceableSpanId(spanId) {
+  return spanId !== void 0 && !spanId.startsWith("agent-task-untraced");
+}
+
+// src/agent-task/checks/agent-session.ts
 var DEFAULT_BUDGET = {
   maxTurns: 12,
   maxToolCalls: 24,
@@ -581,7 +967,7 @@ function extractVerdict(steps) {
   return void 0;
 }
 function buildEvidenceTools(args) {
-  const { z, tool, evidence, scope, budget, ledger, stepIndexOf, includeTrace } = args;
+  const { z, tool, evidence, scope, budget, ledger, stepIndexOf, includeTrace, includeHistory, tracer } = args;
   const budgetGuard = () => {
     ledger.toolCallsUsed += 1;
     if (ledger.toolCallsUsed > budget.maxToolCalls) {
@@ -600,6 +986,7 @@ function buildEvidenceTools(args) {
     });
     return ledger.readBytesUsed > budget.maxReadBytes ? overflow() : null;
   };
+  const span = (name, input, fn) => tracer ? tracer.traceTool(name, input, fn) : fn();
   const tools = {
     read_deliverable: tool({
       description: `Read one of this run's deliverables by name, with optional offset/limit for pagination (max ${MAX_READ_WINDOW} bytes per call).`,
@@ -610,21 +997,23 @@ function buildEvidenceTools(args) {
       }),
       execute: async (input) => {
         const { name, offset, limit } = input;
-        const guard = budgetGuard();
-        if (guard) return { error: guard };
-        if (!Object.prototype.hasOwnProperty.call(evidence.deliverables, name)) {
-          return { error: `unknown deliverable: ${name}` };
-        }
-        const content = renderValue(evidence.deliverables[name]);
-        const slice = content.slice(offset, offset + limit);
-        const overflow = accountRead(
-          "read_deliverable",
-          JSON.stringify({ name, offset, limit }),
-          slice,
-          () => `read budget exhausted (${budget.maxReadBytes} bytes); call finish_verdict now`
-        );
-        if (overflow) return { error: overflow };
-        return { name, total_bytes: content.length, offset, returned: slice.length, content: slice };
+        return span("read_deliverable", input, async () => {
+          const guard = budgetGuard();
+          if (guard) return { error: guard };
+          if (!Object.prototype.hasOwnProperty.call(evidence.deliverables, name)) {
+            return { error: `unknown deliverable: ${name}` };
+          }
+          const content = renderValue(evidence.deliverables[name]);
+          const slice = content.slice(offset, offset + limit);
+          const overflow = accountRead(
+            "read_deliverable",
+            JSON.stringify({ name, offset, limit }),
+            slice,
+            () => `read budget exhausted (${budget.maxReadBytes} bytes); call finish_verdict now`
+          );
+          if (overflow) return { error: overflow };
+          return { name, total_bytes: content.length, offset, returned: slice.length, content: slice };
+        });
       }
     }),
     search_deliverable: tool({
@@ -632,49 +1021,53 @@ function buildEvidenceTools(args) {
       inputSchema: z.object({ name: z.string(), pattern: z.string() }),
       execute: async (input) => {
         const { name, pattern } = input;
-        const guard = budgetGuard();
-        if (guard) return { error: guard };
-        if (!Object.prototype.hasOwnProperty.call(evidence.deliverables, name)) {
-          return { error: `unknown deliverable: ${name}` };
-        }
-        if (pattern.length > SEARCH_MAX_PATTERN) {
-          return { error: `pattern too long (max ${SEARCH_MAX_PATTERN} chars)` };
-        }
-        let re;
-        try {
-          re = new RegExp(pattern, "gi");
-        } catch (error) {
-          return { error: `invalid regex: ${error instanceof Error ? error.message : String(error)}` };
-        }
-        const content = renderValue(evidence.deliverables[name]).slice(0, SEARCH_SCAN_LIMIT);
-        const hits = [];
-        let m;
-        let execs = 0;
-        while ((m = re.exec(content)) && hits.length < SEARCH_HITS) {
-          if (++execs > SEARCH_MAX_EXEC) break;
-          const start = Math.max(0, m.index - SEARCH_CONTEXT);
-          hits.push({ at_byte: m.index, context: content.slice(start, m.index + m[0].length + SEARCH_CONTEXT) });
-          if (m.index === re.lastIndex) re.lastIndex++;
-        }
-        const served = JSON.stringify({ total_bytes: content.length, match_count: hits.length, matches: hits });
-        const overflow = accountRead(
-          "search_deliverable",
-          JSON.stringify({ name, pattern }),
-          served,
-          () => `read budget exhausted (${budget.maxReadBytes} bytes); call finish_verdict now`
-        );
-        if (overflow) return { error: overflow };
-        return { total_bytes: content.length, match_count: hits.length, matches: hits };
+        return span("search_deliverable", input, async () => {
+          const guard = budgetGuard();
+          if (guard) return { error: guard };
+          if (!Object.prototype.hasOwnProperty.call(evidence.deliverables, name)) {
+            return { error: `unknown deliverable: ${name}` };
+          }
+          if (pattern.length > SEARCH_MAX_PATTERN) {
+            return { error: `pattern too long (max ${SEARCH_MAX_PATTERN} chars)` };
+          }
+          let re;
+          try {
+            re = new RegExp(pattern, "gi");
+          } catch (error) {
+            return { error: `invalid regex: ${error instanceof Error ? error.message : String(error)}` };
+          }
+          const content = renderValue(evidence.deliverables[name]).slice(0, SEARCH_SCAN_LIMIT);
+          const hits = [];
+          let m;
+          let execs = 0;
+          while ((m = re.exec(content)) && hits.length < SEARCH_HITS) {
+            if (++execs > SEARCH_MAX_EXEC) break;
+            const start = Math.max(0, m.index - SEARCH_CONTEXT);
+            hits.push({ at_byte: m.index, context: content.slice(start, m.index + m[0].length + SEARCH_CONTEXT) });
+            if (m.index === re.lastIndex) re.lastIndex++;
+          }
+          const served = JSON.stringify({ total_bytes: content.length, match_count: hits.length, matches: hits });
+          const overflow = accountRead(
+            "search_deliverable",
+            JSON.stringify({ name, pattern }),
+            served,
+            () => `read budget exhausted (${budget.maxReadBytes} bytes); call finish_verdict now`
+          );
+          if (overflow) return { error: overflow };
+          return { total_bytes: content.length, match_count: hits.length, matches: hits };
+        });
       }
     }),
-    ...evidence.history ? {
+    ...includeHistory && evidence.history ? {
       list_runs: tool({
         description: "List runs of this task \u2014 id, status, pass/fail, model, check counts. The run under judgment is flagged; use get_run for a prior run's full check report.",
         inputSchema: z.object({}),
         execute: async () => {
-          const guard = budgetGuard();
-          if (guard) return { error: guard };
-          return evidence.history.runs;
+          return span("list_runs", {}, async () => {
+            const guard = budgetGuard();
+            if (guard) return { error: guard };
+            return evidence.history.runs;
+          });
         }
       }),
       get_run: tool({
@@ -682,18 +1075,20 @@ function buildEvidenceTools(args) {
         inputSchema: z.object({ run_id: z.string() }),
         execute: async (input) => {
           const { run_id } = input;
-          const guard = budgetGuard();
-          if (guard) return { error: guard };
-          const detail = await evidence.history.getRun(run_id);
-          const served = JSON.stringify(detail);
-          const overflow = accountRead(
-            "get_run",
-            JSON.stringify({ run_id }),
-            served,
-            () => `read budget exhausted (${budget.maxReadBytes} bytes); call finish_verdict now`
-          );
-          if (overflow) return { error: overflow };
-          return detail;
+          return span("get_run", input, async () => {
+            const guard = budgetGuard();
+            if (guard) return { error: guard };
+            const detail = await evidence.history.getRun(run_id);
+            const served = JSON.stringify(detail);
+            const overflow = accountRead(
+              "get_run",
+              JSON.stringify({ run_id }),
+              served,
+              () => `read budget exhausted (${budget.maxReadBytes} bytes); call finish_verdict now`
+            );
+            if (overflow) return { error: overflow };
+            return detail;
+          });
         }
       })
     } : {},
@@ -701,13 +1096,15 @@ function buildEvidenceTools(args) {
       description: "The task this run executed: id, description, deliverable names.",
       inputSchema: z.object({}),
       execute: async () => {
-        const guard = budgetGuard();
-        if (guard) return { error: guard };
-        return {
-          task_id: scope?.taskId,
-          description: scope?.taskDescription ?? "(unavailable)",
-          deliverables: Object.keys(evidence.deliverables)
-        };
+        return span("get_task_definition", {}, async () => {
+          const guard = budgetGuard();
+          if (guard) return { error: guard };
+          return {
+            task_id: scope?.taskId,
+            description: scope?.taskDescription ?? "(unavailable)",
+            deliverables: Object.keys(evidence.deliverables)
+          };
+        });
       }
     })
   };
@@ -717,21 +1114,23 @@ function buildEvidenceTools(args) {
       inputSchema: z.object({ query: z.string().describe("substring filter on tool names; empty = all") }),
       execute: async (input) => {
         const { query } = input;
-        const guard = budgetGuard();
-        if (guard) return { error: guard };
-        const view = evidence.view;
-        if (!view) {
-          return {
-            status: "unsupported",
-            detail: "no trace projection exists for this run \u2014 judge on deliverables instead"
-          };
-        }
-        if (view.requireCapability("tools") !== "available") {
-          return { status: "unsupported", detail: "tool-call evidence is unavailable in this trace projection" };
-        }
-        const calls = view.toolCalls.filter((c) => query ? c.name.includes(query) : true).slice(0, 30).map((c) => ({ name: c.name, input: renderValue(c.input).slice(0, 200) }));
-        const reply = view.requireCapability("messages") === "available" && view.reply ? view.reply.slice(0, 1500) : void 0;
-        return { turns: view.turnCount, tool_calls: calls, ...reply !== void 0 ? { final_reply: reply } : {} };
+        return span("get_trace", input, async () => {
+          const guard = budgetGuard();
+          if (guard) return { error: guard };
+          const view = evidence.view;
+          if (!view) {
+            return {
+              status: "unsupported",
+              detail: "no trace projection exists for this run \u2014 judge on deliverables instead"
+            };
+          }
+          if (view.requireCapability("tools") !== "available") {
+            return { status: "unsupported", detail: "tool-call evidence is unavailable in this trace projection" };
+          }
+          const calls = view.toolCalls.filter((c) => query ? c.name.includes(query) : true).slice(0, 30).map((c) => ({ name: c.name, input: renderValue(c.input).slice(0, 200) }));
+          const reply = view.requireCapability("messages") === "available" && view.reply ? view.reply.slice(0, 1500) : void 0;
+          return { turns: view.turnCount, tool_calls: calls, ...reply !== void 0 ? { final_reply: reply } : {} };
+        });
       }
     });
   }
@@ -858,7 +1257,9 @@ async function runAgentSession(spec) {
     budget,
     ledger,
     stepIndexOf: () => liveSteps.length,
-    includeTrace: spec.tools?.trace !== false
+    includeTrace: spec.tools?.trace !== false,
+    includeHistory: spec.tools?.history !== false,
+    tracer: spec.tracer
   });
   const system = buildBriefing(spec.scope, spec.evidence, budget);
   const exhibitsBlock = spec.exhibits?.length ? "\n\nValues submitted for judgment:\n" + spec.exhibits.map((v, i) => `  [${i + 1}] ${renderValue(v).slice(0, RECORD_RESULT_LIMIT)}`).join("\n") : "";
@@ -918,7 +1319,7 @@ async function runAgentSession(spec) {
     latency_ms: Date.now() - started
   };
 }
-function createAgentMethod(rec, judgeConfig, judgeScope, evidence) {
+function createAgentMethod(rec, judgeConfig, judgeScope, evidence, judgeTracer) {
   return async (instruction, opts) => {
     const label = opts?.label ?? "agent";
     const location = rec.captureLocation();
@@ -930,22 +1331,58 @@ function createAgentMethod(rec, judgeConfig, judgeScope, evidence) {
         label,
         false,
         "No judge model configured for t.agent. Set one of:\n\u2022 OPENROUTER_MODEL + OPENROUTER_API_KEY (OpenRouter \u2014 needs a tool-calling-capable model)\n\u2022 OPENAI_MODEL + OPENAI_API_KEY (OpenAI direct)\nOr pass { judge } to runTask() programmatically.",
-        { evaluator_type: "agent", location }
+        { evaluator_type: "agent", location, outcome: "error" }
       );
       return;
     }
+    const run = () => runAgentSession({
+      instruction,
+      model: effective.model,
+      baseURL: effective.baseURL,
+      apiKey: effective.apiKey,
+      evidence: evidence ?? { deliverables: {} },
+      scope: judgeScope,
+      exhibits,
+      tools: opts?.tools,
+      budget: opts?.budget,
+      tracer: judgeTracer
+    });
     try {
-      const result = await runAgentSession({
-        instruction,
-        model: effective.model,
-        baseURL: effective.baseURL,
-        apiKey: effective.apiKey,
-        evidence: evidence ?? { deliverables: {} },
-        scope: judgeScope,
-        exhibits,
-        tools: opts?.tools,
-        budget: opts?.budget
-      });
+      let sessionSpanId;
+      const result = await (judgeTracer ? judgeTracer.step(
+        {
+          step_name: `t.agent:${judgeScope?.checkName ?? label}`,
+          observation_type: "AGENT",
+          // The span carries the model + tokens so the backend prices the
+          // judge session and trace rollups count its spend (issue #288).
+          model: effective.model,
+          input: { model: effective.model, instruction },
+          usage: (r) => {
+            const usage = r?.usage;
+            return usage ? {
+              prompt_tokens: usage.input_tokens,
+              completion_tokens: usage.output_tokens
+            } : void 0;
+          },
+          summarize: (r) => {
+            const res = r;
+            const reasoning = res?.verdict?.reasoning?.slice(0, 2e3) ?? `session ended without a verdict (${res?.outcome ?? "unknown"})`;
+            return {
+              text: reasoning,
+              // reasoning-first, matching the judge response
+              // contract's default order (#163).
+              verdict: {
+                reasoning,
+                pass: res?.verdict?.pass ?? null
+              }
+            };
+          }
+        },
+        async (spanId) => {
+          sessionSpanId = spanId;
+          return run();
+        }
+      ) : run());
       const judge = {
         model: effective.model,
         temperature: 0,
@@ -956,7 +1393,8 @@ function createAgentMethod(rec, judgeConfig, judgeScope, evidence) {
         },
         ...result.cost !== void 0 ? { cost: result.cost } : {},
         latency_ms: result.latency_ms,
-        session: result.session
+        session: result.session,
+        ...isTraceableSpanId(sessionSpanId) ? { span_id: sessionSpanId } : {}
       };
       const detail = result.outcome === "error" ? `agentic judge session errored before verdicting: ${result.error ?? "unknown error"}` : `agentic judge session ended without a verdict (budget exhausted after ${result.session.usage?.steps ?? "?"} steps; last tool: ${result.session.steps?.at(-1)?.tool_calls?.map((c) => c.name).join(", ") ?? "none"})`;
       rec.record(label, result.verdict?.pass ?? false, result.verdict?.reasoning ?? detail, {
@@ -1001,6 +1439,8 @@ var TEST_METHOD_NAMES = [
   "messageIncludes",
   "maxTurns",
   "maxDurationMs",
+  "maxTokens",
+  "minTokens",
   "assert",
   "check",
   "judge",
@@ -1016,7 +1456,14 @@ function matchName(name, m) {
   if (m instanceof RegExp) return m.test(name);
   return m(name);
 }
-function createJudgeMethod(rec, judgeConfig, judgeScope) {
+function trackPending(rec, method) {
+  return ((...args) => {
+    const promise = method(...args);
+    rec.track(promise);
+    return promise;
+  });
+}
+function createJudgeMethod(rec, judgeConfig, judgeScope, judgeTracer) {
   return async (values, instruction, opts) => {
     const label = opts?.label ?? "judge";
     const location = rec.captureLocation();
@@ -1027,21 +1474,59 @@ function createJudgeMethod(rec, judgeConfig, judgeScope) {
         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 }
+        // No judge means no verdict — the same bucket as an unreachable judge.
+        { evaluator_type: "llm", location, outcome: "error" }
       );
       return;
     }
     const context2 = judgeScopeToContext(judgeScope);
-    try {
-      const { pass, reasoning, judge } = await callJudge({
-        values: valueArray,
-        instruction,
+    const secondJudgeValue = opts?.secondJudgeValue;
+    const call = () => callJudge({
+      values: valueArray,
+      instruction,
+      model: effective.model,
+      baseURL: effective.baseURL,
+      apiKey: effective.apiKey,
+      prompt: effective.prompt,
+      ...context2 ? { context: context2 } : {},
+      ...secondJudgeValue !== void 0 ? {
+        secondJudgeValue: Array.isArray(secondJudgeValue) ? secondJudgeValue : [secondJudgeValue]
+      } : {}
+    });
+    let judgeSpanId;
+    const traced = judgeTracer ? judgeTracer.step(
+      {
+        step_name: `judge:${judgeScope?.checkName ?? label}`,
+        // A single-shot judge call is an LLM generation — project it
+        // with the same observation semantics as the main agent's.
+        observation_type: "GENERATION",
+        // The span carries the model + tokens so the backend prices the
+        // judge call and trace rollups count its spend (issue #288).
         model: effective.model,
-        baseURL: effective.baseURL,
-        apiKey: effective.apiKey,
-        prompt: effective.prompt,
-        ...context2 ? { context: context2 } : {}
-      });
+        input: { model: effective.model, instruction },
+        summarize: (r) => {
+          const res = r;
+          return {
+            text: res?.reasoning?.slice(0, 2e3) ?? "",
+            verdict: {
+              reasoning: res?.reasoning?.slice(0, 2e3) ?? null,
+              pass: res?.pass ?? null
+            }
+          };
+        },
+        usage: (r) => {
+          const tokens = r?.judge?.tokens;
+          return tokens ? { prompt_tokens: tokens.input, completion_tokens: tokens.output } : void 0;
+        }
+      },
+      async (spanId) => {
+        judgeSpanId = spanId;
+        return call();
+      }
+    ) : call();
+    try {
+      const { pass, reasoning, judge, unavailable } = await traced;
+      if (isTraceableSpanId(judgeSpanId)) judge.span_id = judgeSpanId;
       rec.record(label, pass, reasoning, {
         evaluator_type: "llm",
         judge,
@@ -1050,7 +1535,8 @@ function createJudgeMethod(rec, judgeConfig, judgeScope) {
         // dashboard can render it with the right viewer — Markdown for
         // prose, a JSON tree for structured objects.
         received: valueArray.length === 1 ? valueArray[0] : valueArray,
-        location
+        location,
+        ...unavailable ? { outcome: "error" } : {}
       });
     } catch (error) {
       rec.record(
@@ -1061,7 +1547,8 @@ function createJudgeMethod(rec, judgeConfig, judgeScope) {
           evaluator_type: "llm",
           expected: instruction,
           received: valueArray.length === 1 ? valueArray[0] : valueArray,
-          location
+          location,
+          outcome: "error"
         }
       );
     }
@@ -1083,9 +1570,10 @@ var CAPABILITY_LABELS = {
   errors: "error",
   timing: "timing",
   skills: "skill",
-  subagents: "subagent"
+  subagents: "subagent",
+  usage: "token usage"
 };
-function createTraceTestContext(view, rec, judgeConfig, judgeScope, agentEvidence) {
+function createTraceTestContext(view, rec, judgeConfig, judgeScope, agentEvidence, judgeTracer) {
   const unsupported = (id, capability) => {
     const label = CAPABILITY_LABELS[capability];
     rec.record(id, false, `${label} evidence is unavailable in this trace projection`, {
@@ -1238,7 +1726,11 @@ function createTraceTestContext(view, rec, judgeConfig, judgeScope, agentEvidenc
         received: `${turns}`
       });
     },
-    maxDurationMs(n) {
+    maxDurationMs(n, opts) {
+      if (opts?.turn !== void 0) {
+        recordTurnDuration(view, rec, n, opts.turn, unsupported);
+        return;
+      }
       if (!isAvailable("timing")) {
         unsupported(`maxDurationMs(${n})`, "timing");
         return;
@@ -1253,6 +1745,12 @@ function createTraceTestContext(view, rec, judgeConfig, judgeScope, agentEvidenc
         received: `${ms}ms`
       });
     },
+    maxTokens(n, opts) {
+      recordTokenBudget(view, rec, "max", n, opts, unsupported);
+    },
+    minTokens(n, opts) {
+      recordTokenBudget(view, rec, "min", n, opts, unsupported);
+    },
     assert(label, predicate) {
       const pass = predicate(view);
       rec.record(label, pass, pass ? "" : `assertion "${label}" failed`, {
@@ -1271,10 +1769,99 @@ function createTraceTestContext(view, rec, judgeConfig, judgeScope, agentEvidenc
     },
     // judge does not consult trace capabilities; the scope carries the
     // task/check frame for prompt builders (#161).
-    judge: createJudgeMethod(rec, judgeConfig, judgeScope),
-    agent: createAgentMethod(rec, judgeConfig, judgeScope, agentEvidence ?? { deliverables: {}, view })
+    judge: trackPending(rec, createJudgeMethod(rec, judgeConfig, judgeScope, judgeTracer)),
+    agent: trackPending(rec, createAgentMethod(rec, judgeConfig, judgeScope, agentEvidence ?? { deliverables: {}, view }, judgeTracer))
   };
 }
+function requireBudget(method, n) {
+  if (!Number.isFinite(n) || n < 0) {
+    throw new TypeError(`${method}: the budget must be a finite, non-negative number, got ${n}`);
+  }
+}
+var TOKEN_KINDS = ["input", "output", "total"];
+function requireTurnNumber(method, turn2) {
+  if (!Number.isInteger(turn2) || turn2 < 1) {
+    throw new TypeError(`${method}: turn must be a positive integer (1-based), got ${turn2}`);
+  }
+}
+function recordTurnDuration(view, rec, n, turn2, unsupported) {
+  requireBudget("maxDurationMs", n);
+  requireTurnNumber("maxDurationMs", turn2);
+  const id = `maxDurationMs(${n}, turn ${turn2})`;
+  const turns = view.turns;
+  if (turns === void 0) {
+    unsupported(id, "timing");
+    return;
+  }
+  const record = turns[turn2 - 1];
+  if (!record) {
+    rec.record(id, false, `turn ${turn2} did not run (the run had ${turns.length} turn(s))`, {
+      expected: `turn ${turn2} \u2264 ${n}ms`,
+      received: `${turns.length} turn(s)`
+    });
+    return;
+  }
+  const ms = record.durationMs;
+  if (ms === void 0) {
+    unsupported(id, "timing");
+    return;
+  }
+  rec.record(id, ms <= n, ms <= n ? "" : `expected turn ${turn2} \u2264 ${n}ms, took ${ms}ms`, {
+    expected: `turn ${turn2} \u2264 ${n}ms`,
+    received: `${ms}ms`
+  });
+}
+function recordTokenBudget(view, rec, bound, n, opts, unsupported) {
+  const method = bound === "max" ? "maxTokens" : "minTokens";
+  const kind = opts?.kind ?? "total";
+  const turn2 = opts?.turn;
+  requireBudget(method, n);
+  if (!TOKEN_KINDS.includes(kind)) {
+    throw new TypeError(`${method}: kind must be one of ${TOKEN_KINDS.join(", ")}, got ${String(kind)}`);
+  }
+  if (turn2 !== void 0) requireTurnNumber(method, turn2);
+  const scope = turn2 === void 0 ? "" : `, turn ${turn2}`;
+  const id = `${method}(${n}${kind === "total" ? "" : `, ${kind}`}${scope})`;
+  const op = bound === "max" ? "\u2264" : "\u2265";
+  const expected = `${op} ${n} ${kind} tokens${turn2 === void 0 ? "" : ` in turn ${turn2}`}`;
+  if (view.requireCapability("usage") !== "available") {
+    unsupported(id, "usage");
+    return;
+  }
+  if (turn2 !== void 0) {
+    const turnCount = view.turnCountFromSpans;
+    if (turn2 > turnCount) {
+      rec.record(id, false, `turn ${turn2} did not run (the run had ${turnCount} turn(s))`, {
+        expected,
+        received: `${turnCount} turn(s)`
+      });
+      return;
+    }
+  }
+  const tally = view.tokens(kind, turn2 === void 0 ? void 0 : { turn: turn2 });
+  if (tally === void 0 || tally.reported === 0 && tally.unreported === 0) {
+    rec.record(id, false, `no LLM call${turn2 === void 0 ? " inside a turn" : ` in turn ${turn2}`} reported ${kind} token usage`, {
+      outcome: "unsupported",
+      expected,
+      received: "no usage-bearing LLM calls in scope"
+    });
+    return;
+  }
+  const received = tally.unreported > 0 ? `\u2265 ${tally.tokens} tokens (${tally.unreported} LLM call(s) with unknown or errored usage)` : `${tally.tokens} tokens`;
+  const within = bound === "max" ? tally.tokens <= n : tally.tokens >= n;
+  if (tally.unreported > 0 && !(bound === "min" && within)) {
+    rec.record(id, false, `usage is incomplete: ${tally.unreported} LLM call(s) in scope have unknown or errored ${kind} usage`, {
+      outcome: "unsupported",
+      expected,
+      received
+    });
+    return;
+  }
+  rec.record(id, within, within ? "" : `expected ${expected}, got ${tally.tokens}`, {
+    expected,
+    received
+  });
+}
 function matchesTraceToolCall(call, name, opts) {
   if (!matchName(call.name, name)) return false;
   if (opts?.input !== void 0 && !matchValue(call.input, opts.input)) {
@@ -1293,16 +1880,9 @@ function matchesTraceToolCall(call, name, opts) {
 var Recorder = class {
   constructor(locate) {
     this.records = [];
+    this.pending = [];
     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,
@@ -1314,6 +1894,28 @@ var Recorder = class {
   captureLocation() {
     return this.locate ? this.locate(new Error().stack ?? "") : void 0;
   }
+  /**
+   * Register an async evaluation (``t.judge`` / ``t.agent``) started by this
+   * check. If the check returns without awaiting it, the runner still waits
+   * for its record via ``settlePending`` — a dropped await must not let the
+   * check vacuously pass ("no assertions recorded") while the verdict is
+   * still in flight.
+   */
+  track(promise) {
+    this.pending.push(promise);
+  }
+  /** Wait until every tracked evaluation has settled (and recorded). */
+  async settlePending() {
+    await Promise.allSettled(this.pending);
+  }
+  /**
+   * 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.
+   */
   record(id, pass, reasoning, extra) {
     const location = extra?.location ?? (this.locate ? this.locate(new Error().stack ?? "") : void 0);
     this.records.push({
@@ -1425,8 +2027,10 @@ async function runTraceChecks(args) {
         {
           deliverables: args.deliverables,
           view,
-          ...args.historyPlane ? { history: args.historyPlane } : {}
-        }
+          ...args.historyPlane ? { history: args.historyPlane } : {},
+          ...args.historyUnavailableReason ? { historyUnavailable: args.historyUnavailableReason } : {}
+        },
+        args.judgeTracer
       );
       let thrownLocation;
       try {
@@ -1441,8 +2045,10 @@ async function runTraceChecks(args) {
           location: thrownLocation
         });
       }
+      await rec.settlePending();
       const failed = rec.all.filter((r) => !r.pass);
       const pass = failed.length === 0;
+      const outcome = rollUpCheckOutcome(failed);
       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;
@@ -1451,6 +2057,7 @@ async function runTraceChecks(args) {
         pass,
         reasoning,
         evaluator_type: "code",
+        ...outcome ? { outcome } : {},
         ...judge ? { judge } : {},
         ...location ? { location } : {},
         ...args.displayFile ? { source_file: args.displayFile } : {},
@@ -1465,6 +2072,14 @@ async function runTraceChecks(args) {
   );
   return results;
 }
+function rollUpCheckOutcome(failed) {
+  if (failed.length === 0) return void 0;
+  const verdictless = failed.filter(
+    (r) => r.outcome === "error" || r.outcome === "unsupported"
+  );
+  if (verdictless.length < failed.length) return void 0;
+  return verdictless.some((r) => r.outcome === "error") ? "error" : "unsupported";
+}
 async function loadAndRunFlowChecks(checksPath, args, brokenDeliverables = {}) {
   if (!checksPath) return [];
   resetFlowChecks();
@@ -1477,6 +2092,7 @@ async function loadAndRunFlowChecks(checksPath, args, brokenDeliverables = {}) {
     task: args.task,
     judgeConfig: args.judgeConfig,
     ...args.historyPlane ? { historyPlane: args.historyPlane } : {},
+    ...args.judgeTracer ? { judgeTracer: args.judgeTracer } : {},
     moduleUrl,
     displayFile: basename(checksPath)
   });
@@ -2347,6 +2963,7 @@ function resolveDeliverableSchema(definition) {
 }
 
 // src/agent-task/trace-projection/projection-tee.ts
+import { AsyncLocalStorage } from "async_hooks";
 function monotonicNowMs() {
   if (typeof performance !== "undefined" && typeof performance.now === "function") {
     return performance.now();
@@ -2386,7 +3003,7 @@ function extractText(output) {
   }
   return "";
 }
-function deriveCapabilities(observations) {
+function deriveCapabilities(observations, hierarchyAmbiguous) {
   const hasType = (t) => observations.some((o) => o.type === t);
   const hasMessages = observations.some(
     (o) => o.type === "GENERATION" && o.messages && o.messages.length > 0
@@ -2399,13 +3016,29 @@ function deriveCapabilities(observations) {
     errors: "available",
     timing: "available",
     skills: hasType("SKILL") ? "available" : "unavailable",
-    subagents: hasType("AGENT") ? "available" : "unavailable"
+    subagents: hasType("AGENT") ? "available" : "unavailable",
+    // Usage is attributed to turns through parentSpanId; with an ambiguous
+    // step id the chain is broken, so a per-turn or per-run sum could
+    // silently drop turns.
+    usage: !observations.some((o) => o.usage !== void 0) ? "unavailable" : hierarchyAmbiguous ? "partial" : "available"
+  };
+}
+function usageFrom(params) {
+  if (params?.prompt_tokens === void 0 && params?.completion_tokens === void 0) {
+    return void 0;
+  }
+  return {
+    ...params.prompt_tokens !== void 0 ? { inputTokens: params.prompt_tokens } : {},
+    ...params.completion_tokens !== void 0 ? { outputTokens: params.completion_tokens } : {}
   };
 }
 function createProjectionTee(real) {
   const observations = [];
   const pending = /* @__PURE__ */ new Map();
   const realIdByTeeId = /* @__PURE__ */ new Map();
+  const teeIdByRealStepId = /* @__PURE__ */ new Map();
+  const ambiguousRealStepIds = /* @__PURE__ */ new Set();
+  const activeStep = new AsyncLocalStorage();
   let spanCounter = 0;
   const rootStartMs = monotonicNowMs();
   const rootStartIso = new Date(rootStartMs).toISOString();
@@ -2427,6 +3060,8 @@ function createProjectionTee(real) {
     };
     if (p.parentSpanId) obs.parentSpanId = p.parentSpanId;
     if (p.model) obs.model = p.model;
+    const usage = usageFrom(params);
+    if (usage) obs.usage = usage;
     if (isError && params?.status_message) obs.errorMessage = params.status_message;
     const meta = params?.metadata;
     if (p.type === "TOOL") {
@@ -2449,9 +3084,10 @@ function createProjectionTee(real) {
   function recordStart(opts) {
     spanCounter += 1;
     const spanId = `${real.rootSpanId}-${String(spanCounter).padStart(6, "0")}`;
+    const parent = opts.parent_call_id ?? activeStep.getStore() ?? real.rootSpanId;
     pending.set(spanId, {
       spanId,
-      parentSpanId: opts.parent_call_id ?? real.rootSpanId,
+      parentSpanId: teeIdByRealStepId.get(parent) ?? parent,
       type: observationTypeFor(opts.observation_type),
       name: opts.step_name ?? "step",
       toolName: opts.tool_name ?? void 0,
@@ -2469,11 +3105,22 @@ function createProjectionTee(real) {
       const obsSpanId = recordStart(opts);
       const start = monotonicNowMs();
       try {
-        const result = await real.step(opts, fn);
+        const result = await real.step(opts, (realSpanId) => {
+          if (realSpanId && !ambiguousRealStepIds.has(realSpanId)) {
+            if (teeIdByRealStepId.has(realSpanId)) {
+              teeIdByRealStepId.delete(realSpanId);
+              ambiguousRealStepIds.add(realSpanId);
+            } else {
+              teeIdByRealStepId.set(realSpanId, obsSpanId);
+            }
+          }
+          return activeStep.run(obsSpanId, () => fn(realSpanId));
+        });
         complete(obsSpanId, {
           latency_ms: round3(monotonicNowMs() - start),
           output: opts.summarize?.(result),
-          metadata: opts.metadata
+          metadata: opts.metadata,
+          ...opts.usage?.(result)
         });
         return result;
       } catch (error) {
@@ -2528,7 +3175,29 @@ function createProjectionTee(real) {
       }
     },
     async traceTool(name, params, fn) {
-      return real.traceTool(name, params, fn);
+      const obsSpanId = recordStart({
+        step_name: `tool ${name}`,
+        observation_type: "TOOL",
+        tool_name: name,
+        input: params
+      });
+      const start = monotonicNowMs();
+      try {
+        const result = await real.traceTool(name, params, fn);
+        complete(obsSpanId, {
+          latency_ms: round3(monotonicNowMs() - start),
+          output: result
+        });
+        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"
+        });
+        throw error;
+      }
     },
     async traceRetriever(query, fn) {
       return real.traceRetriever(query, fn);
@@ -2564,7 +3233,7 @@ function createProjectionTee(real) {
           durationMs: round3(endMs - rootStartMs),
           complete: true
         },
-        capabilities: deriveCapabilities(observations),
+        capabilities: deriveCapabilities(observations, ambiguousRealStepIds.size > 0),
         observations: [...observations]
       };
     }
@@ -2716,49 +3385,22 @@ function aggregateResult(checksResults) {
     return { checks: checksResults, pass: false };
   }
   const pass = checksResults.every((r) => r.pass);
-  return { checks: checksResults, pass };
+  return isNoVerdict(checksResults) ? { checks: checksResults, pass, noVerdict: true } : { 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) {
-    }
-  };
+function isNoVerdict(checksResults) {
+  const failing = checksResults.filter((r) => !r.pass);
+  return failing.length > 0 && failing.every((r) => checkOutcome(r) === "error");
+}
+function checkOutcome(check) {
+  if (check.pass) return void 0;
+  const assertions = check.assertions;
+  if (assertions && assertions.length > 0) {
+    const failed = assertions.filter((a) => !a.pass).map((a) => a.outcome);
+    if (failed.length === 0) return void 0;
+    if (!failed.every((o) => o === "error" || o === "unsupported")) return void 0;
+    return failed.includes("error") ? "error" : "unsupported";
+  }
+  return check.outcome;
 }
 
 // src/agent-task/run/runTask.ts
@@ -2787,13 +3429,15 @@ async function runTask(taskDir, options) {
       void 0
     );
   }
-  const phase1 = await trace2.client.traceRun(
+  return trace2.client.traceRun(
     buildTraceRunOptions(loaded, trace2),
-    async (traceContext) => captureExecution(loaded, options, traceContext)
+    async (traceContext) => {
+      const phase1 = await captureExecution(loaded, options, traceContext);
+      const canonical = await readCanonicalSnapshot(trace2);
+      if (canonical) phase1.snapshot = canonical;
+      return evaluate(loaded, options, phase1, 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;
@@ -2991,6 +3635,7 @@ async function executeLoadedTask(loaded, options, rawTrace, traceRunId) {
               files,
               task: task2,
               ...judgeConfig ? { judgeConfig } : {},
+              judgeTracer: trace2,
               ...historyPlane ? { historyPlane } : {}
             },
             validationResults.brokenDeliverables
@@ -3005,6 +3650,7 @@ async function executeLoadedTask(loaded, options, rawTrace, traceRunId) {
           files,
           task: task2,
           ...judgeConfig ? { judgeConfig } : {},
+          judgeTracer: trace2,
           ...historyPlane ? { historyPlane } : {},
           moduleUrl,
           displayFile: evalFileName
@@ -3033,7 +3679,7 @@ async function captureExecution(loaded, options, rawTrace) {
     snapshot: outcome.getSnapshot()
   }));
 }
-async function evaluate(loaded, options, phase1) {
+async function evaluate(loaded, options, phase1, judgeTracer) {
   const {
     task: task2,
     adapter,
@@ -3051,12 +3697,13 @@ async function evaluate(loaded, options, phase1) {
   );
   const judgeConfig = resolveJudgeConfig(options?.judge, task2.judge);
   const historyPlane = await freezeHistoryPlaneFromEnv(task2.id);
-  const checksResults = await (inlineChecks ? runTraceChecks({
+  const runChecks = async () => inlineChecks ? runTraceChecks({
     snapshot: phase1.snapshot,
     deliverables,
     files,
     task: task2,
     ...judgeConfig ? { judgeConfig } : {},
+    ...judgeTracer ? { judgeTracer } : {},
     ...historyPlane ? { historyPlane } : {},
     moduleUrl,
     displayFile: evalFileName
@@ -3068,10 +3715,22 @@ async function evaluate(loaded, options, phase1) {
       files,
       task: task2,
       ...judgeConfig ? { judgeConfig } : {},
+      ...judgeTracer ? { judgeTracer } : {},
       ...historyPlane ? { historyPlane } : {}
     },
     validationResults.brokenDeliverables
-  ));
+  );
+  const hasChecksModule = inlineChecks || checksPath !== null;
+  const checksResults = await (judgeTracer && hasChecksModule ? judgeTracer.step(
+    {
+      step_name: "checks.run",
+      observation_type: "CHAIN",
+      input: { sourceFile: inlineChecks ? evalFileName : checksPath },
+      metadata: { sourceFile: inlineChecks ? evalFileName : checksPath },
+      summarize: (result2) => summarizeEvaluationResults(result2)
+    },
+    runChecks
+  ) : runChecks());
   const result = aggregateResult(checksResults);
   return {
     task: task2,
@@ -3109,11 +3768,18 @@ async function runTurnLoop(loaded, options, session, trace2, rawTrace) {
         metadata: { turnNumber: turnNum },
         summarize: (r) => ({ response: r.response })
       },
-      async (spanId) => session.sendUserTurn(userTurn, {
-        trace: trace2,
-        turnNumber: turnNum,
-        parentSpanId: spanId
-      })
+      // Re-scope the run context to this turn so GenAI spans the OTel
+      // processor captures parent under the turn span, not the run root —
+      // turn-scoped assertions (t.maxTokens({ turn })) walk that chain.
+      async (spanId) => {
+        const run = getActiveApoRun();
+        const send = () => session.sendUserTurn(userTurn, {
+          trace: trace2,
+          turnNumber: turnNum,
+          parentSpanId: spanId
+        });
+        return run ? withApoRun({ ...run, parentSpanId: spanId, turnNumber: turnNum }, send) : send();
+      }
     );
     turnTranscript.push({
       turnNumber: turnNum,
@@ -3169,17 +3835,29 @@ async function cleanupAdapter(loaded, trace2, state, session) {
 }
 function summarizeEvaluationResults(results) {
   const passCount = results.filter((r) => r.pass).length;
+  const noVerdictCount = results.filter(
+    (r) => !r.pass && (r.outcome === "error" || r.outcome === "unsupported")
+  ).length;
+  const failCount = results.length - passCount - noVerdictCount;
+  const suffix = noVerdictCount > 0 ? ` (${noVerdictCount} no-verdict)` : "";
   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
-    }))
+    text: `${passCount}/${results.length} checks passed${suffix}`,
+    verdict: {
+      total: results.length,
+      passCount,
+      failCount,
+      noVerdictCount,
+      results: results.map((r) => ({
+        id: r.id,
+        pass: r.pass,
+        reasoning: r.reasoning?.slice(0, 2e3),
+        evaluator_type: r.evaluator_type,
+        judge_model: r.judge?.model,
+        ...r.outcome ? { outcome: r.outcome } : {},
+        ...r.group_id ? { group_id: r.group_id } : {},
+        ...r.group_name ? { group_name: r.group_name } : {}
+      }))
+    }
   };
 }
 function buildTraceRunOptions(loaded, tracing) {
@@ -3229,12 +3907,20 @@ var RejudgeError = class extends Error {
 };
 var TERMINAL_VERDICT_STATUSES = /* @__PURE__ */ new Set(["passed", "failed"]);
 var MAX_SAMPLES = 50;
+var NO_VERDICT_MESSAGE_PREFIX = "No verdict: ";
+function isJudgeNoVerdictRun(detail) {
+  if (detail.status !== "error" || detail.pass_result != null) return false;
+  if (detail.no_verdict_reason !== void 0) return detail.no_verdict_reason === "judge";
+  const generations = detail.generation_execution;
+  const generationsDominate = generations != null && generations.total > 0 && generations.errored * 2 > generations.total;
+  return (detail.error_message ?? "").startsWith(NO_VERDICT_MESSAGE_PREFIX) && detail.failed_checks === 0 && (detail.errored_checks ?? 0) > 0 && !generationsDominate;
+}
 async function rejudgeTaskRun(runId, endpoints, options = {}) {
   const api = createApiClient(endpoints);
   const progress = options.onProgress ?? (() => {
   });
   const detail = await api.get(`/v1/agent-task-runs/${runId}`);
-  if (!TERMINAL_VERDICT_STATUSES.has(detail.status)) {
+  if (!TERMINAL_VERDICT_STATUSES.has(detail.status) && !isJudgeNoVerdictRun(detail)) {
     throw new RejudgeError(
       `Run ${runId} is '${detail.status}', not a completed run with a verdict \u2014 there is nothing to replay against yet`
     );
@@ -3306,22 +3992,14 @@ async function rejudgeTaskRun(runId, endpoints, options = {}) {
       loaded.adapter.deliverables
     );
     const proxied = proxyBrokenDeliverables(deliverables, validation.brokenDeliverables);
-    const passCounts = /* @__PURE__ */ new Map();
-    let primary = [];
+    const sampled = [];
     const judgeConfig = resolveJudgeConfig(options.judge, loaded.task.judge);
     for (let sample = 0; sample < samples; sample++) {
       if (samples > 1) progress(`judging sample ${sample + 1}/${samples}`);
-      const results = await runChecksOnce(loaded, proxied, snapshot, judgeConfig);
-      if (sample === 0) primary = results;
-      for (const result of results) {
-        passCounts.set(result.id, (passCounts.get(result.id) ?? 0) + (result.pass ? 1 : 0));
-      }
+      sampled.push(await runChecksOnce(loaded, proxied, snapshot, judgeConfig));
     }
-    const stability = primary.map((result) => ({
-      check_id: result.id,
-      passes: passCounts.get(result.id) ?? 0,
-      samples
-    }));
+    const primary = sampled[0] ?? [];
+    const stability = checkStability(sampled);
     const aggregate = aggregateResult(primary);
     return {
       runId,
@@ -3335,6 +4013,7 @@ async function rejudgeTaskRun(runId, endpoints, options = {}) {
       samples,
       checks: aggregate.checks,
       pass: aggregate.pass,
+      ...aggregate.noVerdict ? { noVerdict: true } : {},
       stability,
       traceSnapshotAvailable: snapshotResult.available,
       taskDirUsed: taskDir
@@ -3344,6 +4023,24 @@ async function rejudgeTaskRun(runId, endpoints, options = {}) {
     if (scaffoldDir) rmSync(scaffoldDir, { recursive: true, force: true });
   }
 }
+function checkStability(sampled) {
+  const passCounts = /* @__PURE__ */ new Map();
+  const errorCounts = /* @__PURE__ */ new Map();
+  for (const results of sampled) {
+    for (const result of results) {
+      passCounts.set(result.id, (passCounts.get(result.id) ?? 0) + (result.pass ? 1 : 0));
+      if (checkOutcome(result) === "error") {
+        errorCounts.set(result.id, (errorCounts.get(result.id) ?? 0) + 1);
+      }
+    }
+  }
+  return (sampled[0] ?? []).map((result) => ({
+    check_id: result.id,
+    passes: passCounts.get(result.id) ?? 0,
+    samples: sampled.length,
+    ...errorCounts.get(result.id) ? { errored: errorCounts.get(result.id) } : {}
+  }));
+}
 async function runChecksOnce(loaded, deliverables, snapshot, judgeConfig) {
   if (loaded.inlineChecks) {
     return runTraceChecks({
@@ -3416,7 +4113,8 @@ function degenerateSnapshot(runId) {
       errors: "unavailable",
       timing: "unavailable",
       skills: "unavailable",
-      subagents: "unavailable"
+      subagents: "unavailable",
+      usage: "unavailable"
     },
     observations: []
   };
@@ -3544,6 +4242,7 @@ function createOtelAgentTaskTraceClient(config) {
     activeSpans.set(spanId, {
       span,
       startedAt: monotonicNowMs2(),
+      startWallMs: Date.now(),
       model: params.model || "unknown",
       observationType: params.observation_type
     });
@@ -3561,6 +4260,13 @@ function createOtelAgentTaskTraceClient(config) {
         const payload = params.output && typeof params.output === "object" ? params.output : { value: params.output };
         active.span.setAttribute("gen_ai.tool.call.result", JSON.stringify(payload));
       } else if (params.output.text) {
+        active.span.setAttribute("gen_ai.response.text", String(params.output.text));
+        if (params.output.verdict !== void 0) {
+          active.span.setAttribute(
+            "gen_ai.tool.call.result",
+            JSON.stringify(params.output.verdict)
+          );
+        }
         active.span.setAttribute("gen_ai.output.messages", JSON.stringify([{
           role: "assistant",
           parts: [{ type: "text", content: String(params.output.text) }]
@@ -3585,6 +4291,12 @@ function createOtelAgentTaskTraceClient(config) {
     if (params.completion_tokens !== void 0) {
       active.span.setAttribute("gen_ai.usage.output_tokens", params.completion_tokens);
     }
+    if (params.reasoning_tokens !== void 0) {
+      active.span.setAttribute(
+        "gen_ai.usage.reasoning.output_tokens",
+        params.reasoning_tokens
+      );
+    }
     if (params.status_message) {
       active.span.setAttribute("apo.status_message", params.status_message);
     }
@@ -3594,7 +4306,7 @@ function createOtelAgentTaskTraceClient(config) {
     if (params.metadata) {
       active.span.setAttribute("apo.metadata", JSON.stringify(params.metadata));
     }
-    active.span.end();
+    active.span.end(new Date(active.startWallMs + latency));
     activeSpans.delete(params.id);
   }
   return {
@@ -3628,6 +4340,7 @@ function createOtelAgentTaskTraceClient(config) {
       activeSpans.set(rootSpanId, {
         span: rootSpan,
         startedAt: monotonicNowMs2(),
+        startWallMs: Date.now(),
         model: "trace"
       });
       let callCount = 1;
@@ -3653,7 +4366,8 @@ function createOtelAgentTaskTraceClient(config) {
               id: spanId,
               latency_ms: round32(monotonicNowMs2() - startedAt),
               output: options.summarize?.(result),
-              metadata: options.metadata
+              metadata: options.metadata,
+              ...options.usage?.(result)
             });
             callCount += 1;
             return result;
@@ -3932,6 +4646,7 @@ async function runTaskDir(taskDir) {
     taskDir: loaded.taskDir,
     taskId: loaded.task.id,
     pass: result.result.pass,
+    ...result.result.noVerdict ? { noVerdict: true } : {},
     checks: result.result.checks,
     adapterName: loaded.adapter.name,
     traceRunId: result.traceRunId,
@@ -4008,7 +4723,8 @@ async function runAgentTaskCli(argv, cwd = process.cwd()) {
     if (result.status === "fulfilled") {
       summaries.push(result.value);
       printTaskSummary(result.value, cwd);
-      hasFailures ||= !result.value.pass;
+      if (result.value.noVerdict) hasErrors = true;
+      else hasFailures ||= !result.value.pass;
     } else {
       hasErrors = true;
       printTaskError(taskDir, cwd, result.reason);
@@ -4056,7 +4772,8 @@ function printHelp() {
 function printTaskSummary(summary, cwd) {
   const relativeTaskDir = relative(cwd, summary.taskDir);
   console.log("");
-  console.log(`${summary.pass ? "PASS" : "FAIL"} ${summary.taskId}`);
+  const verdict = summary.noVerdict ? "NO VERDICT" : summary.pass ? "PASS" : "FAIL";
+  console.log(`${verdict} ${summary.taskId}`);
   console.log(`Path: ${relativeTaskDir}`);
   printResultGroup("Checks", summary.checks);
   if (summary.checks.length === 0 && !summary.pass) {
@@ -4083,12 +4800,14 @@ function printTaskError(taskDir, cwd, error) {
 }
 function printOverallSummary(summaries, hasErrors) {
   const passed = summaries.filter((summary) => summary.pass).length;
-  const failed = summaries.length - passed;
+  const noVerdict = summaries.filter((summary) => summary.noVerdict).length;
+  const failed = summaries.length - passed - noVerdict;
   console.log("");
   console.log("Summary");
   console.log(`- total: ${summaries.length}`);
   console.log(`- passed: ${passed}`);
   console.log(`- failed: ${failed}`);
+  if (noVerdict > 0) console.log(`- no verdict: ${noVerdict}`);
   console.log(`- errors: ${hasErrors ? "yes" : "no"}`);
 }