@hawkeyexl/manni 4.5.0 → 4.6.0

package/dist/{chunk-SJO2FTPG.js → chunk-PL4UAF4S.js}

@@ -1,28 +1,57 @@
 #!/usr/bin/env node
 import {
-  applyAvailabilityRecord,
-  discoverConfig,
+  parseTraceFile,
+  renderTrace
+} from "./chunk-M2RLHZ4J.js";
+import {
+  evaluateWhen,
+  matchesGlob,
+  rejectWhen,
+  skippedTrigger,
+  validateWhen
+} from "./chunk-FQGLRJGX.js";
+import {
+  fail,
+  finding,
+  firstError,
+  optionalBoolean,
+  optionalEnum,
+  optionalNumber,
+  optionalString,
+  optionsError,
+  orderedBounds,
+  pass,
+  requireOneOf,
+  requiredString,
+  skippedWindow,
+  windowFor
+} from "./chunk-CWXZ2MRT.js";
+import {
   extractEvals,
   findManifest,
-  foldBranchAvailability,
-  makeRedactor,
-  newAvailability,
-  newReplay,
-  remapAvailability,
   resolveArtifacts
-} from "./chunk-3R5Y3XOL.js";
+} from "./chunk-APKH2T6E.js";
 import {
   discoverTraces
 } from "./chunk-4TSWU2SU.js";
+import {
+  discoverConfig
+} from "./chunk-XPEWUK7J.js";
+import {
+  announceSelection,
+  assertProviderSelection,
+  constructProvider,
+  resolveProviderIdentity,
+  selectProvider
+} from "./chunk-BWCWTHYS.js";
 import {
   TracevalsError
 } from "./chunk-UKZNLVJW.js";
 import {
   isTurnBudgetSkip,
-  parseDuration,
   realExec,
   turnBudgetSkipReason
-} from "./chunk-LJ2RDH3F.js";
+} from "./chunk-XG6PVB5S.js";
 import {
   NOT_GRANTED_REASON,
   grantsFor,
@@ -39,7 +68,7 @@ import {
 } from "./chunk-GLP5PSXB.js";
 import {
   declaredAt
-} from "./chunk-TVIX653Q.js";
+} from "./chunk-TLXE7LYK.js";
 import {
   PATH_JOIN,
   externalMetadataJoin,
@@ -47,15 +76,15 @@ import {
   loadExternalMetadata,
   memberOf,
   mergeWithMarks
-} from "./chunk-HVFR66GQ.js";
+} from "./chunk-TUAAR3MM.js";
 import {
   xmlEscape
-} from "./chunk-TCC737IS.js";
+} from "./chunk-5G53XATW.js";
 import {
   DocmetaError,
   classifyRef,
   extractFrontmatter
-} from "./chunk-527HHQPS.js";
+} from "./chunk-KCOFEWV5.js";
 import {
   palette
 } from "./chunk-RNVYGWIC.js";
@@ -64,18 +93,15 @@ import {
   escapeWorkflowCommandProperty
 } from "./chunk-MNH7QO4Z.js";
 import {
-  assertKnownProvider,
-  assertLocalFlag,
-  assertModelHasProvider,
   hasPagePlaceholder,
-  localNotice,
-  noticeOnce,
-  ownsKey,
-  providerSpecFor,
-  resolveIdentity,
-  selectProvider,
+  ownsKey
+} from "./chunk-XKBEHKWO.js";
+import {
   warn
-} from "./chunk-Q35YIDBV.js";
+} from "./chunk-HX44GB4Z.js";
+import {
+  parseDuration
+} from "./chunk-QCHVR4ZM.js";
 import {
   errorMessage
 } from "./chunk-G3T47CFV.js";
@@ -1300,701 +1326,7 @@ function renderCalibration(report, format, opts = {}) {
 
 // src/tracevals/commands/run.ts
 import { writeFile } from "node:fs/promises";
-import { resolve as resolve5 } from "node:path";
-
-// src/tracevals/trace/claude.ts
-import { readdir, readFile } from "node:fs/promises";
-import { basename as basename3, dirname, join, resolve } from "node:path";
-
-// src/tracevals/trace/detect.ts
-var SUPPORTED = "supported formats: Claude Code session files (~/.claude/projects/**.jsonl) and claude -p stream-json";
-function detectFormat(line) {
-  let rec;
-  try {
-    rec = JSON.parse(line);
-  } catch {
-    throw new TracevalsError(`trace is not JSONL (${SUPPORTED})`);
-  }
-  if (typeof rec !== "object" || rec === null) {
-    throw new TracevalsError(`unrecognized trace format (${SUPPORTED})`);
-  }
-  if ("parentUuid" in rec || "sessionId" in rec) return "claude-session";
-  if ("session_id" in rec) return "claude-stream";
-  throw new TracevalsError(`unrecognized trace format (${SUPPORTED})`);
-}
-function detectContentFormat(content) {
-  let sawParseable = false;
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    let rec;
-    try {
-      rec = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-    if (typeof rec !== "object" || rec === null) continue;
-    sawParseable = true;
-    const r = rec;
-    if ("parentUuid" in r || "sessionId" in r) return "claude-session";
-    if ("session_id" in r) return "claude-stream";
-  }
-  throw new TracevalsError(
-    sawParseable ? `unrecognized trace format (${SUPPORTED})` : `empty or unparseable trace file (${SUPPORTED})`
-  );
-}
-
-// src/tracevals/trace/claude.ts
-async function parseTraceFile(filePath) {
-  const absolute = resolve(filePath);
-  const content = await readFile(absolute, "utf-8");
-  const trace = parseTraceContent(content, absolute);
-  await mergeSidecarBranches(trace, absolute);
-  return trace;
-}
-function parseTraceContent(content, filePath) {
-  const format = detectContentFormat(content);
-  const { records, unparseable } = parseLines(content);
-  const trace = format === "claude-session" ? parseSession(records, filePath) : parseStream(records, filePath);
-  if (unparseable > 0) {
-    trace.warnings.push(
-      `${unparseable} unparseable JSONL line(s) were skipped`
-    );
-  }
-  return trace;
-}
-function parseLines(content) {
-  const records = [];
-  let unparseable = 0;
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const rec = JSON.parse(trimmed);
-      if (typeof rec === "object" && rec !== null) records.push(rec);
-      else unparseable += 1;
-    } catch {
-      unparseable += 1;
-    }
-  }
-  return { records, unparseable };
-}
-var SESSION_META_TYPES = /* @__PURE__ */ new Set([
-  "queue-operation",
-  "attachment",
-  "last-prompt",
-  "custom-title",
-  "summary",
-  "mode",
-  "pr-link"
-]);
-var COMMAND_NAME_RE = /<command-name>([^<]+)<\/command-name>/;
-var COMMAND_ARGS_RE = /<command-args>([^<]*)<\/command-args>/;
-function newTrace(filePath) {
-  return {
-    source: "claude-code",
-    file: filePath,
-    cwd: "",
-    events: [],
-    toolCalls: [],
-    skillInvocations: [],
-    agentSpawns: [],
-    subagentBranches: [],
-    availability: newAvailability(),
-    fileAccesses: [],
-    userMessages: [],
-    assistantTexts: [],
-    turnCount: 0,
-    warnings: []
-  };
-}
-function pushEvent(trace, event) {
-  const index = trace.events.length;
-  trace.events.push({ ...event, index });
-  return index;
-}
-function plainMessageText(rec) {
-  const content = rec.message?.content;
-  return typeof content === "string" ? content : void 0;
-}
-function resolveBranch(branches, parentUuid, rootText) {
-  if (typeof parentUuid !== "string") return void 0;
-  const inherited = branches.resolved.get(parentUuid);
-  if (inherited !== void 0) return inherited;
-  const pending = branches.spawns.get(parentUuid);
-  if (pending === void 0 || pending.length === 0) return void 0;
-  const byPrompt = rootText !== void 0 ? pending.find((b) => !b.claimed && b.prompt === rootText) : void 0;
-  const branch = byPrompt ?? pending.find((b) => !b.claimed) ?? pending[0];
-  if (branch === void 0) return void 0;
-  branch.claimed = true;
-  return branch.toolUseId;
-}
-function parseSession(records, filePath) {
-  const trace = newTrace(filePath);
-  const branches = { spawns: /* @__PURE__ */ new Map(), resolved: /* @__PURE__ */ new Map() };
-  const availability = newReplay();
-  const uuids = /* @__PURE__ */ new Set();
-  for (const rec of records) {
-    if (typeof rec.uuid === "string") uuids.add(rec.uuid);
-  }
-  const continuations = [];
-  let sawMessage = false;
-  let compactions = 0;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let sawUsage = false;
-  for (const rec of records) {
-    const type = rec.type;
-    const timestamp = rec.timestamp;
-    if (timestamp) {
-      trace.startedAt ??= timestamp;
-      trace.endedAt = timestamp;
-    }
-    if (rec.sessionId) trace.sessionId ??= rec.sessionId;
-    if (rec.subtype === "compact_boundary") compactions += 1;
-    if (type !== void 0 && SESSION_META_TYPES.has(type)) {
-      if (type === "summary" && !sawMessage && typeof rec.leafUuid === "string" && !uuids.has(rec.leafUuid)) {
-        continuations.push(rec.leafUuid);
-      }
-      const index = pushEvent(trace, { kind: "meta", timestamp, raw: rec });
-      if (type === "attachment" && applyAvailabilityRecord(availability, rec.attachment, index)) {
-        availability.roster.recorded = true;
-      }
-      continue;
-    }
-    const sidechain = rec.isSidechain === true;
-    if (!sidechain && typeof rec.cwd === "string") trace.cwd = rec.cwd;
-    if (!sidechain && typeof rec.gitBranch === "string") {
-      trace.gitBranch = rec.gitBranch;
-    }
-    const context = { sidechain, timestamp, branches };
-    if (typeof rec.uuid === "string") context.uuid = rec.uuid;
-    if (sidechain) {
-      const branchId = resolveBranch(
-        branches,
-        rec.parentUuid,
-        plainMessageText(rec)
-      );
-      if (branchId !== void 0) {
-        context.branchId = branchId;
-        if (context.uuid) branches.resolved.set(context.uuid, branchId);
-      }
-    }
-    const message = rec.message;
-    if (type === "user" && message) {
-      sawMessage = true;
-      handleUserMessage(trace, message, context, rec);
-    } else if (type === "assistant" && message) {
-      sawMessage = true;
-      const usage = handleAssistantMessage(trace, message, context, rec);
-      if (usage && !sidechain) {
-        inputTokens += usage.input;
-        outputTokens += usage.output;
-        sawUsage = true;
-      }
-    } else {
-      pushEvent(trace, { kind: "system", timestamp, raw: rec });
-    }
-  }
-  if (sawUsage) trace.usage = { inputTokens, outputTokens };
-  for (const leaf of continuations) {
-    trace.warnings.push(
-      `this trace is a fragment of a longer session: it resumes an earlier one recorded elsewhere (summary leafUuid ${leaf} is not in this file), so evals see only the turns recorded here`
-    );
-  }
-  if (compactions > 0) {
-    trace.warnings.push(
-      `the conversation was compacted ${compactions} time(s): the agent stopped seeing the turns before each boundary, so early transcript content is not what it was working from`
-    );
-  }
-  trace.availability = availability.roster;
-  trace.subagentBranches = buildBranches(trace);
-  return trace;
-}
-function buildBranches(trace, sidecars = /* @__PURE__ */ new Map()) {
-  const ranges = /* @__PURE__ */ new Map();
-  for (const event of trace.events) {
-    const id = event.branchId;
-    if (id === void 0) continue;
-    const range = ranges.get(id);
-    if (range === void 0) ranges.set(id, { min: event.index, max: event.index });
-    else range.max = Math.max(range.max, event.index);
-  }
-  if (ranges.size === 0) return [];
-  const spawnFor = /* @__PURE__ */ new Map();
-  for (const spawn of trace.agentSpawns) {
-    if (spawn.toolUseId) spawnFor.set(spawn.toolUseId, spawn);
-  }
-  const parentOf = /* @__PURE__ */ new Map();
-  for (const id of ranges.keys()) {
-    const spawn = spawnFor.get(id);
-    parentOf.set(
-      id,
-      spawn ? trace.events[spawn.index]?.branchId : void 0
-    );
-  }
-  const depthOf = (id) => {
-    let depth = 1;
-    let cursor = parentOf.get(id);
-    const seen = /* @__PURE__ */ new Set([id]);
-    while (cursor !== void 0 && !seen.has(cursor)) {
-      seen.add(cursor);
-      depth += 1;
-      cursor = parentOf.get(cursor);
-    }
-    return depth;
-  };
-  const branches = [];
-  for (const [id, range] of ranges) {
-    const spawn = spawnFor.get(id);
-    const sidecar = sidecars.get(id);
-    const branch = {
-      branchId: id,
-      agentType: sidecar?.agentType ?? spawn?.subagentType ?? id,
-      origin: sidecar ? "sidecar" : "inline",
-      spawnDepth: sidecar?.spawnDepth ?? depthOf(id),
-      spawnIndex: spawn?.index ?? range.min,
-      startIndex: range.min,
-      endIndex: range.max + 1
-    };
-    const description = sidecar?.description ?? spawn?.description;
-    if (description !== void 0) branch.description = description;
-    if (sidecar?.agentId) branch.agentId = sidecar.agentId;
-    if (sidecar?.parentAgentId) branch.parentAgentId = sidecar.parentAgentId;
-    if (sidecar?.file) branch.file = sidecar.file;
-    branches.push(branch);
-  }
-  branches.sort((a, b) => b.spawnDepth - a.spawnDepth);
-  const byId = new Map(branches.map((b) => [b.branchId, b]));
-  for (const branch of branches) {
-    const parentId = parentOf.get(branch.branchId);
-    const parent = parentId === void 0 ? void 0 : byId.get(parentId);
-    if (parent === void 0) continue;
-    parent.startIndex = Math.min(parent.startIndex, branch.startIndex);
-    parent.endIndex = Math.max(parent.endIndex, branch.endIndex);
-  }
-  branches.sort((a, b) => a.startIndex - b.startIndex);
-  return branches;
-}
-function handleUserMessage(trace, message, context, raw) {
-  const { sidechain, timestamp, branchId } = context;
-  const content = message.content;
-  if (typeof content === "string") {
-    const index = pushEvent(trace, {
-      kind: "user",
-      timestamp,
-      text: content,
-      sidechain,
-      branchId,
-      raw
-    });
-    if (sidechain) return;
-    const command = COMMAND_NAME_RE.exec(content);
-    if (command?.[1]) {
-      const invocation = {
-        name: command[1].replace(/^\//, ""),
-        via: "command-injection",
-        index
-      };
-      const args = COMMAND_ARGS_RE.exec(content)?.[1]?.trim();
-      if (args) invocation.args = args;
-      trace.skillInvocations.push(invocation);
-    }
-    trace.userMessages.push(content);
-    trace.turnCount += 1;
-    return;
-  }
-  if (Array.isArray(content)) {
-    let hasToolResult = false;
-    const texts = [];
-    for (const block of content) {
-      if (block?.type === "tool_result") hasToolResult = true;
-      if (block?.type === "text" && typeof block.text === "string") {
-        texts.push(block.text);
-      }
-    }
-    if (hasToolResult) {
-      pushEvent(trace, {
-        kind: "tool_result",
-        timestamp,
-        sidechain,
-        branchId,
-        raw
-      });
-      return;
-    }
-    const text = texts.join("\n");
-    pushEvent(trace, {
-      kind: "user",
-      timestamp,
-      text,
-      sidechain,
-      branchId,
-      raw
-    });
-    if (!sidechain && text) {
-      trace.userMessages.push(text);
-      trace.turnCount += 1;
-    }
-  }
-}
-function handleAssistantMessage(trace, message, context, raw) {
-  const { sidechain, timestamp, branchId } = context;
-  if (!sidechain && typeof message.model === "string") {
-    trace.model ??= message.model;
-  }
-  const content = message.content;
-  if (Array.isArray(content)) {
-    for (const block of content) {
-      if (block?.type === "text" && typeof block.text === "string") {
-        pushEvent(trace, {
-          kind: "assistant",
-          timestamp,
-          text: block.text,
-          sidechain,
-          branchId,
-          raw
-        });
-        if (!sidechain) trace.assistantTexts.push(block.text);
-      } else if (block?.type === "tool_use") {
-        extractToolUse(trace, block, context);
-      }
-    }
-  }
-  const usage = message.usage;
-  if (usage) {
-    return {
-      input: typeof usage.input_tokens === "number" ? usage.input_tokens : 0,
-      output: typeof usage.output_tokens === "number" ? usage.output_tokens : 0
-    };
-  }
-  return void 0;
-}
-function extractToolUse(trace, block, context) {
-  const { sidechain, timestamp, branchId } = context;
-  const name = block.name;
-  const input = block.input ?? {};
-  const toolUseId = typeof block.id === "string" ? block.id : void 0;
-  const index = pushEvent(trace, {
-    kind: "tool_call",
-    timestamp,
-    toolName: name,
-    sidechain,
-    branchId,
-    raw: block
-  });
-  const call = { name, input, index, sidechain };
-  if (timestamp) call.timestamp = timestamp;
-  if (branchId) call.branchId = branchId;
-  trace.toolCalls.push(call);
-  switch (name) {
-    case "Skill": {
-      if (typeof input.skill === "string") {
-        const invocation = {
-          name: input.skill,
-          via: "skill-tool",
-          index
-        };
-        if (toolUseId) invocation.toolUseId = toolUseId;
-        if (typeof input.args === "string" && input.args) {
-          invocation.args = input.args;
-        }
-        trace.skillInvocations.push(invocation);
-      }
-      break;
-    }
-    case "Agent": {
-      if (typeof input.subagent_type === "string") {
-        const spawn = {
-          subagentType: input.subagent_type,
-          index
-        };
-        if (typeof input.description === "string") {
-          spawn.description = input.description;
-        }
-        if (toolUseId) spawn.toolUseId = toolUseId;
-        trace.agentSpawns.push(spawn);
-      }
-      if (context.branches && context.uuid && toolUseId) {
-        const pending = context.branches.spawns.get(context.uuid) ?? [];
-        pending.push({
-          toolUseId,
-          prompt: typeof input.prompt === "string" ? input.prompt : void 0,
-          claimed: false
-        });
-        context.branches.spawns.set(context.uuid, pending);
-      }
-      break;
-    }
-    case "Read":
-    case "Write":
-    case "Edit": {
-      if (typeof input.file_path === "string") {
-        const op = name === "Read" ? "read" : name === "Write" ? "write" : "edit";
-        trace.fileAccesses.push({ path: input.file_path, op, index });
-      }
-      break;
-    }
-  }
-}
-function parseStream(records, filePath) {
-  const trace = newTrace(filePath);
-  const context = { sidechain: false };
-  let inputTokens = 0;
-  let outputTokens = 0;
-  let sawMessageUsage = false;
-  for (const rec of records) {
-    const type = rec.type;
-    if (type === "system" && (rec.subtype === "init" || !rec.subtype)) {
-      if (typeof rec.cwd === "string") trace.cwd = rec.cwd;
-      if (typeof rec.model === "string") trace.model = rec.model;
-      if (typeof rec.session_id === "string") trace.sessionId = rec.session_id;
-      pushEvent(trace, { kind: "system", raw: rec });
-      continue;
-    }
-    if (type === "assistant" || type === "user") {
-      const message = rec.message ?? rec;
-      if (type === "assistant") {
-        const usage = handleAssistantMessage(trace, message, context, rec);
-        if (usage) {
-          inputTokens += usage.input;
-          outputTokens += usage.output;
-          sawMessageUsage = true;
-        }
-      } else {
-        handleUserMessage(trace, message, context, rec);
-      }
-      continue;
-    }
-    if (type === "result") {
-      trace.isError = rec.is_error === true;
-      if (typeof rec.num_turns === "number") trace.turnCount = rec.num_turns;
-      const usage = rec.usage;
-      const totalCost = typeof rec.total_cost_usd === "number" ? rec.total_cost_usd : void 0;
-      if (usage) {
-        trace.usage = {
-          inputTokens: typeof usage.input_tokens === "number" ? usage.input_tokens : 0,
-          outputTokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0
-        };
-        if (totalCost !== void 0) trace.usage.totalCostUsd = totalCost;
-      } else if (sawMessageUsage) {
-        trace.usage = { inputTokens, outputTokens };
-        if (totalCost !== void 0) trace.usage.totalCostUsd = totalCost;
-      }
-      pushEvent(trace, { kind: "meta", raw: rec });
-      continue;
-    }
-    pushEvent(trace, { kind: "meta", raw: rec });
-  }
-  if (!trace.usage && sawMessageUsage) {
-    trace.usage = { inputTokens, outputTokens };
-  }
-  return trace;
-}
-var AGENT_META_RE = /^agent-(.+)\.meta\.json$/;
-var AGENT_JSONL_RE = /^agent-(.+)\.jsonl$/;
-function sidecarDirFor(traceFile) {
-  const stem = basename3(traceFile).replace(/\.jsonl$/i, "");
-  return join(dirname(traceFile), stem, "subagents");
-}
-function asSource(id, trace) {
-  return {
-    id,
-    events: trace.events,
-    toolCalls: trace.toolCalls,
-    fileAccesses: trace.fileAccesses,
-    skillInvocations: trace.skillInvocations,
-    agentSpawns: trace.agentSpawns
-  };
-}
-function stampBranch(sub, branchId) {
-  for (const event of sub.events) {
-    event.sidechain = true;
-    event.branchId = branchId;
-  }
-  for (const call of sub.toolCalls) {
-    call.sidechain = true;
-    call.branchId = branchId;
-  }
-}
-async function loadSidecars(dir, trace) {
-  let names2;
-  try {
-    names2 = await readdir(dir);
-  } catch (error) {
-    const code = error.code;
-    if (code !== "ENOENT" && code !== "ENOTDIR") {
-      trace.warnings.push(
-        `could not read the subagent transcript directory ${dir} (${code ?? "unknown error"}), so subagent turns are missing here`
-      );
-    }
-    return [];
-  }
-  const metas = /* @__PURE__ */ new Set();
-  const transcripts = /* @__PURE__ */ new Set();
-  for (const name of names2) {
-    const meta = AGENT_META_RE.exec(name);
-    if (meta?.[1] !== void 0) {
-      metas.add(meta[1]);
-      continue;
-    }
-    const jsonl = AGENT_JSONL_RE.exec(name);
-    if (jsonl?.[1] !== void 0) transcripts.add(jsonl[1]);
-  }
-  for (const orphan of [...transcripts].sort()) {
-    if (!metas.has(orphan)) {
-      trace.warnings.push(
-        `subagent transcript agent-${orphan}.jsonl has no agent-${orphan}.meta.json, so it names no Agent spawn and was not merged`
-      );
-    }
-  }
-  const loaded = [];
-  for (const agentId of [...metas].sort()) {
-    let meta;
-    try {
-      const raw = await readFile(
-        join(dir, `agent-${agentId}.meta.json`),
-        "utf-8"
-      );
-      const parsed = JSON.parse(raw);
-      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        throw new Error("shape");
-      }
-      meta = parsed;
-    } catch {
-      trace.warnings.push(
-        `subagent metadata agent-${agentId}.meta.json is unreadable or not an object, so that branch was not merged`
-      );
-      continue;
-    }
-    const file = join(dir, `agent-${agentId}.jsonl`);
-    let sub;
-    try {
-      sub = parseTraceContent(await readFile(file, "utf-8"), file);
-    } catch {
-      trace.warnings.push(
-        `subagent transcript agent-${agentId}.jsonl is missing or unreadable, so that branch was not merged`
-      );
-      continue;
-    }
-    for (const warning of sub.warnings) {
-      trace.warnings.push(`subagent ${meta.agentType ?? agentId}: ${warning}`);
-    }
-    loaded.push({ agentId, file, meta, sub, source: asSource(agentId, sub) });
-  }
-  return loaded;
-}
-async function mergeSidecarBranches(trace, traceFile) {
-  const loaded = await loadSidecars(sidecarDirFor(traceFile), trace);
-  if (loaded.length === 0) return;
-  const base = asSource("", trace);
-  const sources = /* @__PURE__ */ new Map([["", base]]);
-  const spawnOwner = /* @__PURE__ */ new Map();
-  const registerSpawns = (source) => {
-    for (const spawn of source.agentSpawns) {
-      if (spawn.toolUseId !== void 0) {
-        spawnOwner.set(spawn.toolUseId, {
-          sourceId: source.id,
-          local: spawn.index
-        });
-      }
-    }
-  };
-  registerSpawns(base);
-  const children = /* @__PURE__ */ new Map();
-  const attached = [];
-  const pending = [...loaded].sort(
-    (a, b) => (a.meta.spawnDepth ?? 1) - (b.meta.spawnDepth ?? 1) || (a.agentId < b.agentId ? -1 : a.agentId > b.agentId ? 1 : 0)
-  );
-  let progress = true;
-  while (progress) {
-    progress = false;
-    for (let i = 0; i < pending.length; i += 1) {
-      const sidecar = pending[i];
-      const branchId = sidecar.meta.toolUseId;
-      const owner = branchId === void 0 ? void 0 : spawnOwner.get(branchId);
-      if (branchId === void 0 || owner === void 0) continue;
-      pending.splice(i, 1);
-      i -= 1;
-      progress = true;
-      stampBranch(sidecar.sub, branchId);
-      sources.set(sidecar.agentId, sidecar.source);
-      const key = `${owner.sourceId}\0${owner.local}`;
-      children.set(key, [...children.get(key) ?? [], sidecar]);
-      registerSpawns(sidecar.source);
-      attached.push({ sidecar, branchId });
-    }
-  }
-  for (const sidecar of pending) {
-    trace.warnings.push(
-      `subagent transcript agent-${sidecar.agentId}.jsonl names Agent call ${sidecar.meta.toolUseId ?? "(none recorded)"}, which is not in this trace, so that branch was not merged`
-    );
-  }
-  if (attached.length === 0) return;
-  const slots = [];
-  const emit = (sourceId) => {
-    const source = sources.get(sourceId);
-    if (source === void 0) return;
-    for (let local = 0; local < source.events.length; local += 1) {
-      slots.push({ sourceId, local });
-      for (const kid of children.get(`${sourceId}\0${local}`) ?? []) {
-        emit(kid.agentId);
-      }
-    }
-  };
-  emit("");
-  const remap = /* @__PURE__ */ new Map();
-  slots.forEach((slot, final) => {
-    const row = remap.get(slot.sourceId) ?? [];
-    row[slot.local] = final;
-    remap.set(slot.sourceId, row);
-  });
-  const finalIndex = (sourceId, local) => remap.get(sourceId)?.[local] ?? local;
-  trace.events = slots.map((slot, final) => {
-    const event = sources.get(slot.sourceId)?.events[slot.local];
-    return { ...event, index: final };
-  });
-  const gather = (pick) => [...sources.values()].flatMap(
-    (source) => pick(source).map((item) => ({
-      ...item,
-      index: finalIndex(source.id, item.index)
-    }))
-  ).sort((a, b) => a.index - b.index);
-  trace.toolCalls = gather((s) => s.toolCalls);
-  trace.fileAccesses = gather((s) => s.fileAccesses);
-  trace.skillInvocations = gather((s) => s.skillInvocations);
-  trace.agentSpawns = gather((s) => s.agentSpawns);
-  trace.availability = remapAvailability(
-    trace.availability,
-    (index) => finalIndex("", index)
-  );
-  for (const { sidecar, branchId } of attached) {
-    const owner = spawnOwner.get(branchId);
-    foldBranchAvailability(
-      trace.availability,
-      sidecar.sub.availability,
-      branchId,
-      owner === void 0 ? 0 : finalIndex(owner.sourceId, owner.local)
-    );
-  }
-  const described = /* @__PURE__ */ new Map();
-  for (const { sidecar, branchId } of attached) {
-    const info = {
-      agentId: sidecar.agentId,
-      file: sidecar.file
-    };
-    if (sidecar.meta.agentType) info.agentType = sidecar.meta.agentType;
-    if (sidecar.meta.description) info.description = sidecar.meta.description;
-    if (sidecar.meta.parentAgentId) {
-      info.parentAgentId = sidecar.meta.parentAgentId;
-    }
-    if (typeof sidecar.meta.spawnDepth === "number") {
-      info.spawnDepth = sidecar.meta.spawnDepth;
-    }
-    described.set(branchId, info);
-  }
-  trace.subagentBranches = buildBranches(trace, described);
-}
+import { resolve as resolve4 } from "node:path";
 
 // src/tracevals/core/plan.ts
 var IMPLICIT_EVAL_NAME = "adheres-to-artifact";
@@ -2145,346 +1477,6 @@ ${graded}`
   return parts.join("\n\n");
 }
 
-// src/tracevals/graders/glob.ts
-var literal = (ch) => ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-var compiled = /* @__PURE__ */ new Map();
-function globToRegExp(glob) {
-  const cached = compiled.get(glob);
-  if (cached !== void 0) return cached;
-  const built = compile(glob);
-  compiled.set(glob, built);
-  return built;
-}
-function compile(glob) {
-  const spec = glob.replace(/\\/g, "/").toLowerCase().replace(/(?:\*\*\/)+/g, "**/");
-  let out = "";
-  for (let i = 0; i < spec.length; i += 1) {
-    const ch = spec[i];
-    if (ch === "?") {
-      out += "[^/]";
-      continue;
-    }
-    if (ch !== "*") {
-      out += literal(ch);
-      continue;
-    }
-    if (spec[i + 1] !== "*") {
-      out += "[^/]*";
-      continue;
-    }
-    i += 1;
-    if (spec[i + 1] === "/") {
-      i += 1;
-      if (out !== "") out += "(?:.*/)?";
-    } else if (out.endsWith("/")) {
-      out = `${out.slice(0, -1)}(?:/.*)?`;
-    } else {
-      out += ".*";
-    }
-  }
-  return new RegExp(`^(?:.*/)?${out}$`);
-}
-function normalizePath(path) {
-  return path.replace(/\\/g, "/").toLowerCase();
-}
-function matchesGlob(path, glob) {
-  return globToRegExp(glob).test(normalizePath(path));
-}
-
-// src/tracevals/graders/when.ts
-var stringValue = (kind) => (value) => typeof value === "string" && value.length > 0 ? void 0 : `options.when.${kind} must be a string`;
-var prompts = /* @__PURE__ */ new Map();
-function promptRe(pattern) {
-  const cached = prompts.get(pattern);
-  if (cached !== void 0) return cached;
-  const built = new RegExp(pattern);
-  prompts.set(pattern, built);
-  return built;
-}
-var CONDITIONS = {
-  "file-access": {
-    validate: stringValue("file-access"),
-    test: (value, window) => window.fileAccesses.some((a) => matchesGlob(a.path, value)),
-    reason: (value) => `no file matching "${value}" was accessed`
-  },
-  "tool-used": {
-    validate: stringValue("tool-used"),
-    test: (value, window) => window.toolCalls.some((c) => c.name === value),
-    reason: (value) => `the ${value} tool was never used`
-  },
-  "prompt-matches": {
-    validate: (value) => {
-      const shape = stringValue("prompt-matches")(value);
-      if (shape !== void 0) return shape;
-      try {
-        new RegExp(value);
-      } catch (err) {
-        return `options.when.prompt-matches is not a valid regular expression: ${err.message}`;
-      }
-      return void 0;
-    },
-    test: (value, window) => {
-      const re = promptRe(value);
-      return window.userMessages.some((text) => re.test(text));
-    },
-    reason: (value) => `no prompt matched /${value}/`
-  },
-  "turn-count-above": {
-    validate: (value) => {
-      if (typeof value !== "number" || !Number.isInteger(value)) {
-        return "options.when.turn-count-above must be a whole number";
-      }
-      if (value < 0) return "options.when.turn-count-above must be at least 0";
-      return void 0;
-    },
-    test: (value, window) => window.turnCount > value,
-    reason: (value, window) => `${window.turnCount} turn(s) is not more than ${value}`
-  }
-};
-var WHEN_CONDITIONS = Object.keys(
-  CONDITIONS
-);
-function validateWhen(options) {
-  const when = options.when;
-  if (when === void 0) return void 0;
-  if (typeof when !== "object" || when === null || Array.isArray(when)) {
-    return "options.when must be an object of conditions";
-  }
-  const conditions = when;
-  const keys = Object.keys(conditions);
-  if (keys.length === 0) {
-    return `options.when needs at least one of: ${WHEN_CONDITIONS.join(", ")}`;
-  }
-  for (const key of keys) {
-    const condition = CONDITIONS[key];
-    if (condition === void 0) {
-      return `options.when.${key} is not a known condition; expected one of: ${WHEN_CONDITIONS.join(", ")}`;
-    }
-    const invalid = condition.validate(conditions[key]);
-    if (invalid !== void 0) return invalid;
-  }
-  return void 0;
-}
-function evaluateWhen(options, window) {
-  const when = options.when;
-  if (when === void 0) return { armed: true };
-  for (const name of WHEN_CONDITIONS) {
-    const value = when[name];
-    if (value === void 0) continue;
-    const condition = CONDITIONS[name];
-    if (condition.test(value, window)) continue;
-    return {
-      armed: false,
-      reason: `trigger not met (${window.label}): ${condition.reason(value, window)}`
-    };
-  }
-  return { armed: true };
-}
-function rejectWhen(kind, options) {
-  if (options.when === void 0) return void 0;
-  return `options.when is not supported by the ${kind} grader, which grades the whole session rather than a window`;
-}
-function skippedTrigger(trigger) {
-  return { findings: [], skipped: trigger.reason ?? "trigger not met" };
-}
-
-// src/tracevals/graders/util.ts
-function finding(plan, message) {
-  return {
-    evalName: plan.evalName,
-    artifact: plan.artifact.path,
-    message,
-    severity: plan.severity
-  };
-}
-function fail(plan, message) {
-  return { findings: [finding(plan, message)] };
-}
-var pass = { findings: [] };
-function optionsError(kind, message) {
-  return { findings: [], error: `${kind}: ${message}` };
-}
-function firstError(...checks) {
-  return checks.find((check) => check !== void 0);
-}
-function requiredString(options, key) {
-  const value = options[key];
-  if (typeof value !== "string" || value.length === 0) {
-    return `options.${key} is required`;
-  }
-  return void 0;
-}
-function optionalString(options, key) {
-  const value = options[key];
-  if (value === void 0) return void 0;
-  if (typeof value !== "string" || value.length === 0) {
-    return `options.${key} must be a non-empty string`;
-  }
-  return void 0;
-}
-function optionalEnum(options, key, allowed) {
-  const value = options[key];
-  if (value === void 0) return void 0;
-  if (typeof value !== "string" || !allowed.includes(value)) {
-    return `options.${key} must be one of: ${allowed.join(", ")}`;
-  }
-  return void 0;
-}
-function optionalNumber(options, key, bounds = {}) {
-  const value = options[key];
-  if (value === void 0) return void 0;
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return `options.${key} must be a finite number`;
-  }
-  if (bounds.integer === true && !Number.isInteger(value)) {
-    return `options.${key} must be a whole number`;
-  }
-  if (bounds.min !== void 0 && value < bounds.min) {
-    return `options.${key} must be at least ${bounds.min}`;
-  }
-  return void 0;
-}
-function optionalBoolean(options, key) {
-  if (options[key] !== void 0 && typeof options[key] !== "boolean") {
-    return `options.${key} must be a boolean`;
-  }
-  return void 0;
-}
-function orderedBounds(options, minKey, maxKey) {
-  const min = options[minKey];
-  const max = options[maxKey];
-  if (typeof min === "number" && typeof max === "number" && min > max) {
-    return `options.${maxKey} must be greater than or equal to options.${minKey}`;
-  }
-  return void 0;
-}
-function requireOneOf(options, keys) {
-  if (keys.some((key) => options[key] !== void 0)) return void 0;
-  return `at least one of ${keys.map((k) => `options.${k}`).join(" or ")} is required`;
-}
-function windowFor(trace, plan) {
-  const { name, type } = plan.artifact;
-  if (type === "skill") return skillWindow(trace, name);
-  if (type === "agent") return agentWindow(trace, name);
-  if (type === "slash-command") return slashCommandWindow(trace, name);
-  return {
-    scope: "session",
-    label: "whole session",
-    empty: false,
-    events: trace.events,
-    toolCalls: trace.toolCalls,
-    fileAccesses: trace.fileAccesses,
-    skillInvocations: trace.skillInvocations,
-    userMessages: trace.userMessages,
-    assistantTexts: trace.assistantTexts,
-    turnCount: trace.turnCount
-  };
-}
-function skippedWindow(window) {
-  return { findings: [], skipped: window.reason ?? "the artifact governed no turns" };
-}
-function skillWindow(trace, name) {
-  return injectionWindow(trace, "skill", `skill "${name}"`, (s) => s.name === name);
-}
-function slashCommandWindow(trace, name) {
-  return injectionWindow(
-    trace,
-    "slash-command",
-    `slash command "/${name}"`,
-    (s) => s.name === name && s.via === "command-injection"
-  );
-}
-function injectionWindow(trace, scope, label, opensHere) {
-  const opens = trace.skillInvocations.filter(opensHere).map((s) => s.index);
-  if (opens.length === 0) {
-    return emptyWindow(
-      scope,
-      label,
-      `${label} was never invoked in this trace, so it governed no turns`
-    );
-  }
-  const chainOf = (index) => trace.events[index]?.branchId;
-  const own = new Set(opens.map(chainOf));
-  const boundaries = trace.skillInvocations.filter((s) => own.has(chainOf(s.index))).map((s) => s.index).sort((a, b) => a - b);
-  const spans = opens.map((start) => ({
-    start,
-    end: boundaries.find((b) => b > start) ?? Number.POSITIVE_INFINITY
-  }));
-  return materialize(trace, scope, label, spans, void 0, own);
-}
-function agentWindow(trace, name) {
-  const label = `agent "${name}"`;
-  const mine = trace.subagentBranches.filter((b) => b.agentType === name);
-  if (mine.length === 0) {
-    const spawned = trace.agentSpawns.some((a) => a.subagentType === name);
-    return emptyWindow(
-      "agent",
-      label,
-      spawned ? `${label} was spawned but recorded no subagent turns (no inline sidechain records and no sidecar transcript), so it governed no turns` : `${label} was never spawned in this trace, so it governed no turns`
-    );
-  }
-  const branchIds = new Set(mine.map((b) => b.branchId));
-  for (const branch of trace.subagentBranches) {
-    if (branchIds.has(branch.branchId)) continue;
-    const nested = mine.some(
-      (m) => m.startIndex <= branch.startIndex && branch.endIndex <= m.endIndex
-    );
-    if (nested) branchIds.add(branch.branchId);
-  }
-  const spans = mine.map((b) => ({ start: b.startIndex, end: b.endIndex }));
-  return materialize(
-    trace,
-    "agent",
-    label,
-    spans,
-    branchIds,
-    new Set(mine.map((b) => b.branchId))
-  );
-}
-function emptyWindow(scope, label, reason) {
-  return {
-    scope,
-    label,
-    empty: true,
-    reason,
-    events: [],
-    toolCalls: [],
-    fileAccesses: [],
-    skillInvocations: [],
-    userMessages: [],
-    assistantTexts: [],
-    turnCount: 0
-  };
-}
-function materialize(trace, scope, label, spans, branchIds, own) {
-  const inSpan = (index) => spans.some((s) => index >= s.start && index < s.end);
-  const excluded = /* @__PURE__ */ new Set();
-  if (branchIds !== void 0) {
-    for (const event of trace.events) {
-      if (!inSpan(event.index)) continue;
-      if (event.branchId === void 0 || !branchIds.has(event.branchId)) {
-        excluded.add(event.index);
-      }
-    }
-  }
-  const inWindow = (index) => inSpan(index) && !excluded.has(index);
-  const events = trace.events.filter((e) => inWindow(e.index));
-  const textOf = (kind) => events.filter((e) => e.kind === kind && own.has(e.branchId) && e.text).map((e) => e.text);
-  const userMessages = textOf("user");
-  return {
-    scope,
-    label,
-    empty: false,
-    events,
-    toolCalls: trace.toolCalls.filter((c) => inWindow(c.index)),
-    fileAccesses: trace.fileAccesses.filter((a) => inWindow(a.index)),
-    skillInvocations: trace.skillInvocations.filter((s) => inWindow(s.index)),
-    userMessages,
-    assistantTexts: textOf("assistant"),
-    turnCount: userMessages.length
-  };
-}
-
 // src/tracevals/graders/tool-usage.ts
 function checkContradiction(options) {
   const expect = options.expect ?? "used";
@@ -2789,7 +1781,7 @@ var costGrader = {
 
 // src/tracevals/core/target.ts
 import { readFileSync } from "node:fs";
-import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep } from "node:path";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve, sep } from "node:path";
 var DEFAULT_TARGET = "transcript";
 function describeTarget(target) {
   const t = target ?? DEFAULT_TARGET;
@@ -2817,7 +1809,7 @@ function readTarget(target, ctx) {
       reason: `target file "${t.path}" is an absolute path; name it relative to the project root`
     };
   }
-  const abs = resolve2(ctx.root, t.path);
+  const abs = resolve(ctx.root, t.path);
   const rel = relative2(ctx.root, abs);
   if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute2(rel)) {
     return {
@@ -2913,13 +1905,13 @@ var regexGrader = {
 
 // src/tracevals/graders/json-output.ts
 import { Ajv2020 } from "ajv/dist/2020.js";
-var compiled2 = /* @__PURE__ */ new Map();
+var compiled = /* @__PURE__ */ new Map();
 function compileSchema(schema) {
   const key = JSON.stringify(schema);
-  const hit = compiled2.get(key);
+  const hit = compiled.get(key);
   if (hit !== void 0) return hit;
   const built = new Ajv2020({ allErrors: true, strict: false }).compile(schema);
-  compiled2.set(key, built);
+  compiled.set(key, built);
   return built;
 }
 function validateOptions8(options) {
@@ -3060,133 +2052,6 @@ function listGraderKinds() {
   return [...graders.keys()];
 }
 
-// src/tracevals/judge/render.ts
-var DEFAULTS = {
-  maxBlockChars: 2e3,
-  maxTotalChars: 15e4,
-  redact: []
-};
-var MIN_TIMELINE_CHARS = 200;
-var HEADER_TRUNCATED = "\n[... header truncated ...]";
-var TIMELINE_SHELL = "\n\n## Timeline\n";
-function renderTrace(trace, options = {}, plan) {
-  const { maxBlockChars, maxTotalChars, redact } = { ...DEFAULTS, ...options };
-  const scrub = makeRedactor(redact);
-  const clip = (text, max) => {
-    const safe = scrub(text);
-    if (safe.length <= max) return safe;
-    return `${safe.slice(0, max)} [... truncated ${safe.length - max} chars ...]`;
-  };
-  const window = plan === void 0 ? void 0 : windowFor(trace, plan);
-  const scoped = window !== void 0 && window.scope !== "session" ? window : void 0;
-  const events = scoped?.events ?? trace.events;
-  const fullHeader = scrub(
-    [
-      "# Session",
-      `source: ${trace.source}`,
-      trace.model ? `model: ${trace.model}` : void 0,
-      `cwd: ${trace.cwd}`,
-      trace.gitBranch ? `branch: ${trace.gitBranch}` : void 0,
-      scoped ? `scope: ${scoped.label} \u2014 ${events.length} of ${trace.events.length} session events` : void 0,
-      // Everything below describes what the judge can actually see. On a
-      // scoped render the timeline is the window, so a session-wide count here
-      // reads as evidence that the rest was truncated away — the judge would
-      // discount a digest that is complete for what it was asked about. The
-      // session totals stay, in parentheses, because "3 of 87" is context the
-      // window count alone does not carry.
-      scoped ? `turns: ${scoped.turnCount} (of ${trace.turnCount} in the session)` : `turns: ${trace.turnCount}`,
-      (() => {
-        const used = (scoped ?? trace).skillInvocations.map((s) => s.name);
-        return used.length > 0 ? `skills used: ${used.join(", ")}` : "skills used: none";
-      })(),
-      (() => {
-        const inWindow = new Set(events.map((e) => e.index));
-        const spawns = trace.agentSpawns.filter(
-          (a) => !scoped || inWindow.has(a.index)
-        );
-        return spawns.length > 0 ? `agents spawned: ${spawns.map((a) => a.subagentType).join(", ")}` : void 0;
-      })(),
-      (() => {
-        const inWindow = new Set(events.map((e) => e.index));
-        const branches = trace.subagentBranches.filter(
-          (b) => !scoped || inWindow.has(b.spawnIndex)
-        );
-        return branches.length > 0 ? `subagent transcripts: ${branches.map((b) => `${b.agentType} (depth ${b.spawnDepth})`).join(", ")}` : void 0;
-      })()
-    ].filter((line) => line !== void 0).join("\n")
-  );
-  const headerRoom = Math.max(
-    maxTotalChars - TIMELINE_SHELL.length - MIN_TIMELINE_CHARS,
-    0
-  );
-  const header = fullHeader.length <= headerRoom ? fullHeader : fullHeader.slice(
-    0,
-    Math.max(headerRoom - HEADER_TRUNCATED.length, 0)
-  ) + HEADER_TRUNCATED;
-  const branchTypes = /* @__PURE__ */ new Map();
-  for (const spawn of trace.agentSpawns) {
-    if (spawn.toolUseId) branchTypes.set(spawn.toolUseId, spawn.subagentType);
-  }
-  for (const branch2 of trace.subagentBranches) {
-    branchTypes.set(branch2.branchId, branch2.agentType);
-  }
-  const label = (branchId) => branchTypes.get(branchId) ?? branchId;
-  const callAt = new Map(trace.toolCalls.map((call) => [call.index, call]));
-  if (scoped?.empty === true) {
-    return `${header}${TIMELINE_SHELL}[no turns: ${scrub(scoped.reason ?? "")}]`;
-  }
-  const lines = [];
-  let branch;
-  for (const event of events) {
-    const tag = event.branchId ? `:${label(event.branchId)}` : event.sidechain ? ":sidechain" : "";
-    let line;
-    switch (event.kind) {
-      case "user":
-        if (event.text) line = `[user${tag}] ${clip(event.text, maxBlockChars)}`;
-        break;
-      case "assistant":
-        if (event.text) {
-          line = `[assistant${tag}] ${clip(event.text, maxBlockChars)}`;
-        }
-        break;
-      case "tool_call": {
-        const call = callAt.get(event.index);
-        const input = call ? JSON.stringify(call.input) : "";
-        line = `[tool${tag}] ${event.toolName ?? call?.name ?? "?"} ${clip(input, Math.min(maxBlockChars, 500))}`;
-        break;
-      }
-      default:
-        break;
-    }
-    if (line === void 0) continue;
-    if (event.branchId !== branch) {
-      if (branch !== void 0) lines.push(`[/subagent ${label(branch)}]`);
-      branch = event.branchId;
-      if (branch !== void 0) {
-        lines.push(`[subagent ${label(branch)} (${branch})]`);
-      }
-    }
-    lines.push(line);
-  }
-  if (branch !== void 0) lines.push(`[/subagent ${label(branch)}]`);
-  let timeline = scrub(lines.join("\n"));
-  const budget = Math.max(
-    maxTotalChars - header.length - TIMELINE_SHELL.length,
-    MIN_TIMELINE_CHARS
-  );
-  if (timeline.length > budget) {
-    const marker = (omitted2) => `
-[... truncated ${omitted2} chars of transcript ...]
-`;
-    const room = Math.max(budget - marker(timeline.length).length, 0);
-    const headLen = Math.floor(room * 0.6);
-    const tailLen = room - headLen;
-    const omitted = timeline.length - headLen - tailLen;
-    timeline = `${timeline.slice(0, headLen)}${marker(omitted)}${tailLen > 0 ? timeline.slice(-tailLen) : ""}`;
-  }
-  return `${header}${TIMELINE_SHELL}${timeline}`;
-}
-
 // src/tracevals/core/engine.ts
 async function runEvals(options) {
   const start = Date.now();
@@ -3495,7 +2360,7 @@ function summariseManifest(found, coverage) {
 }
 
 // src/tracevals/evals/external.ts
-import { relative as relative3, resolve as resolve3, sep as sep2 } from "node:path";
+import { relative as relative3, resolve as resolve2, sep as sep2 } from "node:path";
 var METADATA_KEY = "metadata";
 var MARKED = /* @__PURE__ */ new Set([METADATA_KEY]);
 var toPosix2 = (path) => path.split(sep2).join("/");
@@ -3561,7 +2426,7 @@ function reader(scoped, opts) {
     const merged = await mergeWithMarks(
       label,
       extracted,
-      await indexFor(resolve3(base, label)),
+      await indexFor(resolve2(base, label)),
       [first.name],
       base,
       { encryptionKey: () => opts.key, marks: await marks() }
@@ -3569,7 +2434,7 @@ function reader(scoped, opts) {
     const locate2 = (pointer) => {
       const found = merged.locate(pointer);
       if (found === void 0 || classifyRef(found.file).kind === "url") return found;
-      return { ...found, file: resolve3(base, found.file) };
+      return { ...found, file: resolve2(base, found.file) };
     };
     const at = merged.locate(`/${METADATA_KEY}`);
     const [declaration] = first.externalMetadata;
@@ -3579,14 +2444,14 @@ function reader(scoped, opts) {
     const url = classifyRef(at.file).kind === "url";
     const owner = {
       collection: first.name,
-      path: url ? at.file : resolve3(base, at.file),
+      path: url ? at.file : resolve2(base, at.file),
       file: at.file,
       join: externalMetadataJoin(declaration),
       url
     };
     const out = { extracted: merged.extracted, locate: locate2, owner };
     if (owner.join === PATH_JOIN) {
-      out.entry = toPosix2(relative3(configDir, resolve3(base, label)));
+      out.entry = toPosix2(relative3(configDir, resolve2(base, label)));
     } else {
       const value = merged.joins.find((j) => j.field === owner.join)?.value ?? extracted.data[owner.join];
       if (typeof value === "string" && value !== "") out.entry = value;
@@ -3601,18 +2466,18 @@ function reader(scoped, opts) {
 
 // src/tracevals/graders/plugins.ts
 import { createRequire } from "node:module";
-import { isAbsolute as isAbsolute3, join as join2, resolve as resolve4 } from "node:path";
+import { isAbsolute as isAbsolute3, join, resolve as resolve3 } from "node:path";
 import { pathToFileURL } from "node:url";
 var alreadyLoaded = /* @__PURE__ */ new Set();
 var RELATIVE = /^\.\.?[/\\]/;
 function locate(specifier, configDir) {
   if (specifier.startsWith("file:")) return { href: specifier };
   if (RELATIVE.test(specifier) || isAbsolute3(specifier)) {
-    const path = resolve4(configDir, specifier);
+    const path = resolve3(configDir, specifier);
     return { href: pathToFileURL(path).href, shown: path };
   }
   try {
-    const path = createRequire(join2(resolve4(configDir), "package.json")).resolve(
+    const path = createRequire(join(resolve3(configDir), "package.json")).resolve(
       specifier
     );
     return { href: pathToFileURL(path).href, shown: path };
@@ -3691,8 +2556,8 @@ async function loadGraderPlugins(options) {
 }
 
 // src/tracevals/history.ts
-import { appendFile, mkdir, readFile as readFile2 } from "node:fs/promises";
-import { dirname as dirname2 } from "node:path";
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { dirname } from "node:path";
 function entryFor(report) {
   return {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -3711,7 +2576,7 @@ function entryFor(report) {
 }
 async function appendHistory(file, report) {
   try {
-    await mkdir(dirname2(file), { recursive: true });
+    await mkdir(dirname(file), { recursive: true });
     await appendFile(file, `${JSON.stringify(entryFor(report))}
 `, "utf-8");
   } catch (err) {
@@ -3723,7 +2588,7 @@ async function appendHistory(file, report) {
 async function loadHistory(file) {
   let content;
   try {
-    content = await readFile2(file, "utf-8");
+    content = await readFile(file, "utf-8");
   } catch {
     return [];
   }
@@ -3771,83 +2636,6 @@ function compareToLast(history, report) {
   };
 }
 
-// src/tracevals/judge/provider.ts
-import {
-  makeProvider as makeInferenceProvider,
-  mockVerdict
-} from "@hawkeyexl/inference";
-var CONFIG_KEY = "tracevals.provider";
-var toTracevalsError = (message) => new TracevalsError(message);
-function selectProvider2(config, flags = {}, ev = {}) {
-  assertLocalFlag(flags, toTracevalsError);
-  return selectProvider(flags, [
-    {
-      ...ev.provider !== void 0 ? { provider: ev.provider } : {},
-      ...ev.model !== void 0 ? { model: ev.model } : {},
-      ...ev.origin !== void 0 ? { origin: ev.origin } : {}
-    },
-    {
-      ...config.provider !== null ? { provider: config.provider } : {},
-      ...config.model !== null ? { model: config.model } : {},
-      origin: CONFIG_KEY
-    },
-    {
-      ...config.providers.provider !== void 0 ? { provider: config.providers.provider } : {},
-      ...config.providers.model !== void 0 ? { model: config.providers.model } : {},
-      origin: "providers.provider"
-    }
-  ]);
-}
-function announceSelection(selection) {
-  const message = localNotice(selection);
-  if (message !== void 0) noticeOnce(message);
-}
-function assertProviderSelection(selection) {
-  assertKnownProvider(selection.provider, toTracevalsError);
-  assertModelHasProvider(selection.provider, selection.model, CONFIG_KEY, toTracevalsError);
-}
-function providerSpecFor2(config, selection, options = {}) {
-  const spec = providerSpecFor(config.providers, selection);
-  switch (selection.provider) {
-    case "anthropic":
-      return { ...spec, anthropic: { toolName: "record_verdict" } };
-    case "openai":
-      return { ...spec, openai: { schemaName: "verdict" } };
-    case "mock":
-      return {
-        ...spec,
-        mockResponses: options.mockResponses ?? [mockVerdict("pass", 0.95)]
-      };
-    default:
-      return spec;
-  }
-}
-async function resolveProviderIdentity(config, flags = {}, ev = {}) {
-  const selection = selectProvider2(config, flags, ev);
-  const { provider, model } = selection;
-  assertKnownProvider(provider, toTracevalsError);
-  assertModelHasProvider(provider, model, CONFIG_KEY, toTracevalsError);
-  announceSelection(selection);
-  return resolveIdentity(
-    providerSpecFor2(config, { provider, model: model ?? null }),
-    toTracevalsError
-  );
-}
-function constructProvider(config, identity, options = {}) {
-  try {
-    return makeInferenceProvider(providerSpecFor2(config, identity, options));
-  } catch (e) {
-    throw new TracevalsError(errorMessage(e));
-  }
-}
-async function makeJudgeProvider(config, flags = {}, ev = {}, options = {}) {
-  return constructProvider(
-    config,
-    await resolveProviderIdentity(config, flags, ev),
-    options
-  );
-}
-
 // src/tracevals/judge/trace-judge.ts
 import {
   computeConsensus,
@@ -4113,7 +2901,7 @@ async function prepareRun(options) {
     ...options.model !== void 0 ? { model: options.model } : {},
     ...options.local !== void 0 ? { local: options.local } : {}
   };
-  const selection = selectProvider2(config, flags);
+  const selection = selectProvider(config, flags);
   assertProviderSelection(selection);
   let judge = options.judge;
   if (judge === void 0 && options.deterministicOnly !== true) {
@@ -4131,7 +2919,7 @@ async function prepareRun(options) {
       // then the family's `providers:` — so an eval cannot quietly outrank a
       // flag someone just typed.
       providerFor: async (ev) => {
-        const chosen = selectProvider2(config, flags, ev);
+        const chosen = selectProvider(config, flags, ev);
         announceSelection(chosen);
         const key = keyOf(chosen);
         if (key === defaultKey) return provider;
@@ -4151,7 +2939,7 @@ async function prepareRun(options) {
       runs: options.runs ?? config.judge.ensembleRuns,
       temperature: config.judge.temperature,
       zones: config.judge.zones,
-      cacheDir: resolve5(configDir, config.judge.cacheDir),
+      cacheDir: resolve4(configDir, config.judge.cacheDir),
       ...options.noCache !== void 0 ? { noCache: options.noCache } : {},
       maxTurns: options.maxTurns ?? config.judge.maxTurns
     });
@@ -4187,7 +2975,7 @@ async function runOne(options, context) {
   });
   let comparison;
   if (options.history) {
-    const historyFile = resolve5(context.configDir, config.history.file);
+    const historyFile = resolve4(context.configDir, config.history.file);
     comparison = compareToLast(await loadHistory(historyFile), report) ?? void 0;
     await appendHistory(historyFile, report);
   }
@@ -4314,27 +3102,15 @@ export {
   render,
   renderBatch,
   renderCalibration,
-  detectFormat,
-  detectContentFormat,
-  parseTraceFile,
-  parseTraceContent,
   IMPLICIT_EVAL_NAME,
   planEvals,
   PROMPT_VERSION,
   JUDGE_SYSTEM_PROMPT,
   buildUserContent,
-  globToRegExp,
-  matchesGlob,
-  WHEN_CONDITIONS,
-  validateWhen,
-  evaluateWhen,
-  windowFor,
-  skippedWindow,
   BUILTIN_GRADER_KINDS,
   registerGrader,
   graderFor,
   listGraderKinds,
-  renderTrace,
   runEvals,
   METADATA_KEY,
   urlManifestRefusal,
@@ -4344,13 +3120,6 @@ export {
   appendHistory,
   loadHistory,
   compareToLast,
-  selectProvider2 as selectProvider,
-  announceSelection,
-  assertProviderSelection,
-  providerSpecFor2 as providerSpecFor,
-  resolveProviderIdentity,
-  constructProvider,
-  makeJudgeProvider,
   sha256,
   VerdictCache,
   cacheKey,
@@ -4363,4 +3132,4 @@ export {
   resolveBatchTraces,
   runBatch
 };
-//# sourceMappingURL=chunk-SJO2FTPG.js.map
+//# sourceMappingURL=chunk-PL4UAF4S.js.map