@hawkeyexl/manni 4.4.1 → 4.6.0

package/dist/chunk-M2RLHZ4J.js

@@ -0,0 +1,849 @@
+#!/usr/bin/env node
+import {
+  windowFor
+} from "./chunk-CWXZ2MRT.js";
+import {
+  applyAvailabilityRecord,
+  foldBranchAvailability,
+  newAvailability,
+  newReplay,
+  remapAvailability
+} from "./chunk-APKH2T6E.js";
+import {
+  makeRedactor
+} from "./chunk-CU57HT2E.js";
+import {
+  TracevalsError
+} from "./chunk-UKZNLVJW.js";
+
+// src/tracevals/trace/claude.ts
+import { readdir, readFile } from "node:fs/promises";
+import { basename, 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 = basename(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 names;
+  try {
+    names = 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 names) {
+    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);
+}
+
+// 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 = options.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
+  );
+  if (fullHeader.length > headerRoom) options.onTruncated?.();
+  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) {
+    options.onTruncated?.();
+    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}`;
+}
+
+export {
+  detectFormat,
+  detectContentFormat,
+  parseTraceFile,
+  parseTraceContent,
+  renderTrace
+};
+//# sourceMappingURL=chunk-M2RLHZ4J.js.map